drivers/media/usb/em28xx/em28xx-i2c.c

   1 /*
   2    em28xx-i2c.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
   3
   4    Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
   5                       Markus Rechberger <mrechberger@gmail.com>
   6                       Mauro Carvalho Chehab <mchehab@infradead.org>
   7                       Sascha Sommer <saschasommer@freenet.de>
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/kernel.h>
  26 #include <linux/usb.h>
  27 #include <linux/i2c.h>
  28
  29 #include "em28xx.h"
  30 #include "tuner-xc2028.h"
  31 #include <media/v4l2-common.h>
  32 #include <media/tuner.h>
  33
  34 /* ----------------------------------------------------------- */
  35
  36 static unsigned int i2c_scan;
  37 module_param(i2c_scan, int, 0444);
  38 MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
  39
  40 static unsigned int i2c_debug;
  41 module_param(i2c_debug, int, 0644);
  42 MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
  43
  44 #define dprintk2(lvl, fmt, args...)                     \
  45 do {                                                    \
  46         if (i2c_debug >= lvl) {                         \
  47                 printk(KERN_DEBUG "%s at %s: " fmt,     \
  48                        dev->name, __func__ , ##args);   \
  49       }                                                 \
  50 } while (0)
  51
  52 /*
  53  * em2800_i2c_send_bytes()
  54  * send up to 4 bytes to the em2800 i2c device
  55  */
  56 static int em2800_i2c_send_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
  57 {
  58         int ret;
  59         int write_timeout;
  60         u8 b2[6];
  61
  62         if (len < 1 || len > 4)
  63                 return -EOPNOTSUPP;
  64
  65         BUG_ON(len < 1 || len > 4);
  66         b2[5] = 0x80 + len - 1;
  67         b2[4] = addr;
  68         b2[3] = buf[0];
  69         if (len > 1)
  70                 b2[2] = buf[1];
  71         if (len > 2)
  72                 b2[1] = buf[2];
  73         if (len > 3)
  74                 b2[0] = buf[3];
  75
  76         /* trigger write */
  77         ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
  78         if (ret != 2 + len) {
  79                 em28xx_warn("writing to i2c device failed (error=%i)\n", ret);
  80                 return -EIO;
  81         }
  82         /* wait for completion */
  83         for (write_timeout = EM2800_I2C_XFER_TIMEOUT; write_timeout > 0;
  84              write_timeout -= 5) {
  85                 ret = dev->em28xx_read_reg(dev, 0x05);
  86                 if (ret == 0x80 + len - 1)
  87                         return len;
  88                 msleep(5);
  89         }
  90         em28xx_warn("i2c write timed out\n");
  91         return -EIO;
  92 }
  93
  94 /*
  95  * em2800_i2c_recv_bytes()
  96  * read up to 4 bytes from the em2800 i2c device
  97  */
  98 static int em2800_i2c_recv_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
  99 {
 100         u8 buf2[4];
 101         int ret;
 102         int read_timeout;
 103         int i;
 104
 105         if (len < 1 || len > 4)
 106                 return -EOPNOTSUPP;
 107
 108         /* trigger read */
 109         buf2[1] = 0x84 + len - 1;
 110         buf2[0] = addr;
 111         ret = dev->em28xx_write_regs(dev, 0x04, buf2, 2);
 112         if (ret != 2) {
 113                 em28xx_warn("failed to trigger read from i2c address 0x%x "
 114                             "(error=%i)\n", addr, ret);
 115                 return (ret < 0) ? ret : -EIO;
 116         }
 117
 118         /* wait for completion */
 119         for (read_timeout = EM2800_I2C_XFER_TIMEOUT; read_timeout > 0;
 120              read_timeout -= 5) {
 121                 ret = dev->em28xx_read_reg(dev, 0x05);
 122                 if (ret == 0x84 + len - 1) {
 123                         break;
 124                 } else if (ret == 0x94 + len - 1) {
 125                         return -ENODEV;
 126                 } else if (ret < 0) {
 127                         em28xx_warn("failed to get i2c transfer status from "
 128                                     "bridge register (error=%i)\n", ret);
 129                         return ret;
 130                 }
 131                 msleep(5);
 132         }
 133         if (ret != 0x84 + len - 1)
 134                 em28xx_warn("read from i2c device at 0x%x timed out\n", addr);
 135
 136         /* get the received message */
 137         ret = dev->em28xx_read_reg_req_len(dev, 0x00, 4-len, buf2, len);
 138         if (ret != len) {
 139                 em28xx_warn("reading from i2c device at 0x%x failed: "
 140                             "couldn't get the received message from the bridge "
 141                             "(error=%i)\n", addr, ret);
 142                 return (ret < 0) ? ret : -EIO;
 143         }
 144         for (i = 0; i < len; i++)
 145                 buf[i] = buf2[len - 1 - i];
 146
 147         return ret;
 148 }
 149
 150 /*
 151  * em2800_i2c_check_for_device()
 152  * check if there is an i2c device at the supplied address
 153  */
 154 static int em2800_i2c_check_for_device(struct em28xx *dev, u8 addr)
 155 {
 156         u8 buf;
 157         int ret;
 158
 159         ret = em2800_i2c_recv_bytes(dev, addr, &buf, 1);
 160         if (ret == 1)
 161                 return 0;
 162         return (ret < 0) ? ret : -EIO;
 163 }
 164
 165 /*
 166  * em28xx_i2c_send_bytes()
 167  */
 168 static int em28xx_i2c_send_bytes(struct em28xx *dev, u16 addr, u8 *buf,
 169                                  u16 len, int stop)
 170 {
 171         int wrcount = 0;
 172         int write_timeout, ret;
 173
 174         if (len < 1 || len > 64)
 175                 return -EOPNOTSUPP;
 176
 177         wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
 178
 179         /* Seems to be required after a write */
 180         for (write_timeout = EM2800_I2C_XFER_TIMEOUT; write_timeout > 0;
 181              write_timeout -= 5) {
 182                 ret = dev->em28xx_read_reg(dev, 0x05);
 183                 if (!ret)
 184                         break;
 185                 msleep(5);
 186         }
 187
 188         return wrcount;
 189 }
 190
 191 /*
 192  * em28xx_i2c_recv_bytes()
 193  * read a byte from the i2c device
 194  */
 195 static int em28xx_i2c_recv_bytes(struct em28xx *dev, u16 addr, u8 *buf, u16 len)
 196 {
 197         int ret;
 198
 199         if (len < 1 || len > 64)
 200                 return -EOPNOTSUPP;
 201
 202         ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
 203         if (ret < 0) {
 204                 em28xx_warn("reading i2c device failed (error=%i)\n", ret);
 205                 return ret;
 206         }
 207         if (dev->em28xx_read_reg(dev, 0x5) != 0)
 208                 return -ENODEV;
 209         return ret;
 210 }
 211
 212 /*
 213  * em28xx_i2c_check_for_device()
 214  * check if there is a i2c_device at the supplied address
 215  */
 216 static int em28xx_i2c_check_for_device(struct em28xx *dev, u16 addr)
 217 {
 218         int ret;
 219
 220         ret = dev->em28xx_read_reg_req(dev, 2, addr);
 221         if (ret < 0) {
 222                 em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
 223                 return ret;
 224         }
 225         if (dev->em28xx_read_reg(dev, 0x5) != 0)
 226                 return -ENODEV;
 227         return 0;
 228 }
 229
 230 /*
 231  * em28xx_i2c_xfer()
 232  * the main i2c transfer function
 233  */
 234 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
 235                            struct i2c_msg msgs[], int num)
 236 {
 237         struct em28xx *dev = i2c_adap->algo_data;
 238         int addr, rc, i, byte;
 239
 240         if (num <= 0)
 241                 return 0;
 242         for (i = 0; i < num; i++) {
 243                 addr = msgs[i].addr << 1;
 244                 dprintk2(2, "%s %s addr=%x len=%d:",
 245                          (msgs[i].flags & I2C_M_RD) ? "read" : "write",
 246                          i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
 247                 if (!msgs[i].len) { /* no len: check only for device presence */
 248                         if (dev->board.is_em2800)
 249                                 rc = em2800_i2c_check_for_device(dev, addr);
 250                         else
 251                                 rc = em28xx_i2c_check_for_device(dev, addr);
 252                         if (rc < 0) {
 253                                 dprintk2(2, " no device\n");
 254                                 return rc;
 255                         }
 256
 257                 } else if (msgs[i].flags & I2C_M_RD) {
 258                         /* read bytes */
 259                         if (dev->board.is_em2800)
 260                                 rc = em2800_i2c_recv_bytes(dev, addr,
 261                                                            msgs[i].buf,
 262                                                            msgs[i].len);
 263                         else
 264                                 rc = em28xx_i2c_recv_bytes(dev, addr,
 265                                                            msgs[i].buf,
 266                                                            msgs[i].len);
 267                         if (i2c_debug >= 2) {
 268                                 for (byte = 0; byte < msgs[i].len; byte++)
 269                                         printk(" %02x", msgs[i].buf[byte]);
 270                         }
 271                 } else {
 272                         /* write bytes */
 273                         if (i2c_debug >= 2) {
 274                                 for (byte = 0; byte < msgs[i].len; byte++)
 275                                         printk(" %02x", msgs[i].buf[byte]);
 276                         }
 277                         if (dev->board.is_em2800)
 278                                 rc = em2800_i2c_send_bytes(dev, addr,
 279                                                            msgs[i].buf,
 280                                                            msgs[i].len);
 281                         else
 282                                 rc = em28xx_i2c_send_bytes(dev, addr,
 283                                                            msgs[i].buf,
 284                                                            msgs[i].len,
 285                                                            i == num - 1);
 286                 }
 287                 if (rc < 0)
 288                         goto err;
 289                 if (i2c_debug >= 2)
 290                         printk("\n");
 291         }
 292
 293         return num;
 294 err:
 295         dprintk2(2, " ERROR: %i\n", rc);
 296         return rc;
 297 }
 298
 299 /* based on linux/sunrpc/svcauth.h and linux/hash.h
 300  * The original hash function returns a different value, if arch is x86_64
 301  *  or i386.
 302  */
 303 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
 304 {
 305         unsigned long hash = 0;
 306         unsigned long l = 0;
 307         int len = 0;
 308         unsigned char c;
 309         do {
 310                 if (len == length) {
 311                         c = (char)len;
 312                         len = -1;
 313                 } else
 314                         c = *buf++;
 315                 l = (l << 8) | c;
 316                 len++;
 317                 if ((len & (32 / 8 - 1)) == 0)
 318                         hash = ((hash^l) * 0x9e370001UL);
 319         } while (len);
 320
 321         return (hash >> (32 - bits)) & 0xffffffffUL;
 322 }
 323
 324 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
 325 {
 326         unsigned char buf, *p = eedata;
 327         struct em28xx_eeprom *em_eeprom = (void *)eedata;
 328         int i, err, size = len, block;
 329
 330         if (dev->chip_id == CHIP_ID_EM2874 ||
 331             dev->chip_id == CHIP_ID_EM28174 ||
 332             dev->chip_id == CHIP_ID_EM2884) {
 333                 /* Empia switched to a 16-bit addressable eeprom in newer
 334                    devices.  While we could certainly write a routine to read
 335                    the eeprom, there is nothing of use in there that cannot be
 336                    accessed through registers, and there is the risk that we
 337                    could corrupt the eeprom (since a 16-bit read call is
 338                    interpreted as a write call by 8-bit eeproms).
 339                 */
 340                 return 0;
 341         }
 342
 343         dev->i2c_client.addr = 0xa0 >> 1;
 344
 345         /* Check if board has eeprom */
 346         err = i2c_master_recv(&dev->i2c_client, &buf, 0);
 347         if (err < 0) {
 348                 em28xx_errdev("board has no eeprom\n");
 349                 memset(eedata, 0, len);
 350                 return -ENODEV;
 351         }
 352
 353         buf = 0;
 354
 355         err = i2c_master_send(&dev->i2c_client, &buf, 1);
 356         if (err != 1) {
 357                 printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
 358                        dev->name, err);
 359                 return err;
 360         }
 361         while (size > 0) {
 362                 if (size > 16)
 363                         block = 16;
 364                 else
 365                         block = size;
 366
 367                 if (block !=
 368                     (err = i2c_master_recv(&dev->i2c_client, p, block))) {
 369                         printk(KERN_WARNING
 370                                "%s: i2c eeprom read error (err=%d)\n",
 371                                dev->name, err);
 372                         return err;
 373                 }
 374                 size -= block;
 375                 p += block;
 376         }
 377         for (i = 0; i < len; i++) {
 378                 if (0 == (i % 16))
 379                         printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
 380                 printk(" %02x", eedata[i]);
 381                 if (15 == (i % 16))
 382                         printk("\n");
 383         }
 384
 385         if (em_eeprom->id == 0x9567eb1a)
 386                 dev->hash = em28xx_hash_mem(eedata, len, 32);
 387
 388         printk(KERN_INFO "%s: EEPROM ID= 0x%08x, EEPROM hash = 0x%08lx\n",
 389                dev->name, em_eeprom->id, dev->hash);
 390
 391         printk(KERN_INFO "%s: EEPROM info:\n", dev->name);
 392
 393         switch (em_eeprom->chip_conf >> 4 & 0x3) {
 394         case 0:
 395                 printk(KERN_INFO "%s:\tNo audio on board.\n", dev->name);
 396                 break;
 397         case 1:
 398                 printk(KERN_INFO "%s:\tAC97 audio (5 sample rates)\n",
 399                                  dev->name);
 400                 break;
 401         case 2:
 402                 printk(KERN_INFO "%s:\tI2S audio, sample rate=32k\n",
 403                                  dev->name);
 404                 break;
 405         case 3:
 406                 printk(KERN_INFO "%s:\tI2S audio, 3 sample rates\n",
 407                                  dev->name);
 408                 break;
 409         }
 410
 411         if (em_eeprom->chip_conf & 1 << 3)
 412                 printk(KERN_INFO "%s:\tUSB Remote wakeup capable\n", dev->name);
 413
 414         if (em_eeprom->chip_conf & 1 << 2)
 415                 printk(KERN_INFO "%s:\tUSB Self power capable\n", dev->name);
 416
 417         switch (em_eeprom->chip_conf & 0x3) {
 418         case 0:
 419                 printk(KERN_INFO "%s:\t500mA max power\n", dev->name);
 420                 break;
 421         case 1:
 422                 printk(KERN_INFO "%s:\t400mA max power\n", dev->name);
 423                 break;
 424         case 2:
 425                 printk(KERN_INFO "%s:\t300mA max power\n", dev->name);
 426                 break;
 427         case 3:
 428                 printk(KERN_INFO "%s:\t200mA max power\n", dev->name);
 429                 break;
 430         }
 431         printk(KERN_INFO "%s:\tTable at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
 432                                 dev->name,
 433                                 em_eeprom->string_idx_table,
 434                                 em_eeprom->string1,
 435                                 em_eeprom->string2,
 436                                 em_eeprom->string3);
 437
 438         return 0;
 439 }
 440
 441 /* ----------------------------------------------------------- */
 442
 443 /*
 444  * functionality()
 445  */
 446 static u32 functionality(struct i2c_adapter *adap)
 447 {
 448         struct em28xx *dev = adap->algo_data;
 449         u32 func_flags = I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 450         if (dev->board.is_em2800)
 451                 func_flags &= ~I2C_FUNC_SMBUS_WRITE_BLOCK_DATA;
 452         return func_flags;
 453 }
 454
 455 static struct i2c_algorithm em28xx_algo = {
 456         .master_xfer   = em28xx_i2c_xfer,
 457         .functionality = functionality,
 458 };
 459
 460 static struct i2c_adapter em28xx_adap_template = {
 461         .owner = THIS_MODULE,
 462         .name = "em28xx",
 463         .algo = &em28xx_algo,
 464 };
 465
 466 static struct i2c_client em28xx_client_template = {
 467         .name = "em28xx internal",
 468 };
 469
 470 /* ----------------------------------------------------------- */
 471
 472 /*
 473  * i2c_devs
 474  * incomplete list of known devices
 475  */
 476 static char *i2c_devs[128] = {
 477         [0x4a >> 1] = "saa7113h",
 478         [0x52 >> 1] = "drxk",
 479         [0x60 >> 1] = "remote IR sensor",
 480         [0x8e >> 1] = "remote IR sensor",
 481         [0x86 >> 1] = "tda9887",
 482         [0x80 >> 1] = "msp34xx",
 483         [0x88 >> 1] = "msp34xx",
 484         [0xa0 >> 1] = "eeprom",
 485         [0xb0 >> 1] = "tda9874",
 486         [0xb8 >> 1] = "tvp5150a",
 487         [0xba >> 1] = "webcam sensor or tvp5150a",
 488         [0xc0 >> 1] = "tuner (analog)",
 489         [0xc2 >> 1] = "tuner (analog)",
 490         [0xc4 >> 1] = "tuner (analog)",
 491         [0xc6 >> 1] = "tuner (analog)",
 492 };
 493
 494 /*
 495  * do_i2c_scan()
 496  * check i2c address range for devices
 497  */
 498 void em28xx_do_i2c_scan(struct em28xx *dev)
 499 {
 500         u8 i2c_devicelist[128];
 501         unsigned char buf;
 502         int i, rc;
 503
 504         memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
 505
 506         for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
 507                 dev->i2c_client.addr = i;
 508                 rc = i2c_master_recv(&dev->i2c_client, &buf, 0);
 509                 if (rc < 0)
 510                         continue;
 511                 i2c_devicelist[i] = i;
 512                 printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n",
 513                        dev->name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
 514         }
 515
 516         dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
 517                                         ARRAY_SIZE(i2c_devicelist), 32);
 518 }
 519
 520 /*
 521  * em28xx_i2c_register()
 522  * register i2c bus
 523  */
 524 int em28xx_i2c_register(struct em28xx *dev)
 525 {
 526         int retval;
 527
 528         BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
 529         BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
 530         dev->i2c_adap = em28xx_adap_template;
 531         dev->i2c_adap.dev.parent = &dev->udev->dev;
 532         strcpy(dev->i2c_adap.name, dev->name);
 533         dev->i2c_adap.algo_data = dev;
 534         i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
 535
 536         retval = i2c_add_adapter(&dev->i2c_adap);
 537         if (retval < 0) {
 538                 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
 539                         __func__, retval);
 540                 return retval;
 541         }
 542
 543         dev->i2c_client = em28xx_client_template;
 544         dev->i2c_client.adapter = &dev->i2c_adap;
 545
 546         retval = em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
 547         if ((retval < 0) && (retval != -ENODEV)) {
 548                 em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
 549                         __func__, retval);
 550
 551                 return retval;
 552         }
 553
 554         if (i2c_scan)
 555                 em28xx_do_i2c_scan(dev);
 556
 557         return 0;
 558 }
 559
 560 /*
 561  * em28xx_i2c_unregister()
 562  * unregister i2c_bus
 563  */
 564 int em28xx_i2c_unregister(struct em28xx *dev)
 565 {
 566         i2c_del_adapter(&dev->i2c_adap);
 567         return 0;
 568 }