drivers/media/video/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_max4()
  54  * send up to 4 bytes to the i2c device
  55  */
  56 static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
  57                                 char *buf, int len)
  58 {
  59         int ret;
  60         int write_timeout;
  61         unsigned char b2[6];
  62         BUG_ON(len < 1 || len > 4);
  63         b2[5] = 0x80 + len - 1;
  64         b2[4] = addr;
  65         b2[3] = buf[0];
  66         if (len > 1)
  67                 b2[2] = buf[1];
  68         if (len > 2)
  69                 b2[1] = buf[2];
  70         if (len > 3)
  71                 b2[0] = buf[3];
  72
  73         ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
  74         if (ret != 2 + len) {
  75                 em28xx_warn("writing to i2c device failed (error=%i)\n", ret);
  76                 return -EIO;
  77         }
  78         for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
  79              write_timeout -= 5) {
  80                 ret = dev->em28xx_read_reg(dev, 0x05);
  81                 if (ret == 0x80 + len - 1)
  82                         return len;
  83                 msleep(5);
  84         }
  85         em28xx_warn("i2c write timed out\n");
  86         return -EIO;
  87 }
  88
  89 /*
  90  * em2800_i2c_send_bytes()
  91  */
  92 static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf,
  93                                  short len)
  94 {
  95         char *bufPtr = buf;
  96         int ret;
  97         int wrcount = 0;
  98         int count;
  99         int maxLen = 4;
 100         struct em28xx *dev = (struct em28xx *)data;
 101         while (len > 0) {
 102                 count = (len > maxLen) ? maxLen : len;
 103                 ret = em2800_i2c_send_max4(dev, addr, bufPtr, count);
 104                 if (ret > 0) {
 105                         len -= count;
 106                         bufPtr += count;
 107                         wrcount += count;
 108                 } else
 109                         return (ret < 0) ? ret : -EFAULT;
 110         }
 111         return wrcount;
 112 }
 113
 114 /*
 115  * em2800_i2c_check_for_device()
 116  * check if there is a i2c_device at the supplied address
 117  */
 118 static int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
 119 {
 120         char msg;
 121         int ret;
 122         int write_timeout;
 123         msg = addr;
 124         ret = dev->em28xx_write_regs(dev, 0x04, &msg, 1);
 125         if (ret < 0) {
 126                 em28xx_warn("setting i2c device address failed (error=%i)\n",
 127                             ret);
 128                 return ret;
 129         }
 130         msg = 0x84;
 131         ret = dev->em28xx_write_regs(dev, 0x05, &msg, 1);
 132         if (ret < 0) {
 133                 em28xx_warn("preparing i2c read failed (error=%i)\n", ret);
 134                 return ret;
 135         }
 136         for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
 137              write_timeout -= 5) {
 138                 unsigned reg = dev->em28xx_read_reg(dev, 0x5);
 139
 140                 if (reg == 0x94)
 141                         return -ENODEV;
 142                 else if (reg == 0x84)
 143                         return 0;
 144                 msleep(5);
 145         }
 146         return -ENODEV;
 147 }
 148
 149 /*
 150  * em2800_i2c_recv_bytes()
 151  * read from the i2c device
 152  */
 153 static int em2800_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
 154                                  char *buf, int len)
 155 {
 156         int ret;
 157         /* check for the device and set i2c read address */
 158         ret = em2800_i2c_check_for_device(dev, addr);
 159         if (ret) {
 160                 em28xx_warn
 161                     ("preparing read at i2c address 0x%x failed (error=%i)\n",
 162                      addr, ret);
 163                 return ret;
 164         }
 165         ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x3, buf, len);
 166         if (ret < 0) {
 167                 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
 168                             addr, ret);
 169                 return ret;
 170         }
 171         return ret;
 172 }
 173
 174 /*
 175  * em28xx_i2c_send_bytes()
 176  */
 177 static int em28xx_i2c_send_bytes(void *data, unsigned char addr, char *buf,
 178                                  short len, int stop)
 179 {
 180         int wrcount = 0;
 181         struct em28xx *dev = (struct em28xx *)data;
 182         int write_timeout, ret;
 183
 184         wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
 185
 186         /* Seems to be required after a write */
 187         for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
 188              write_timeout -= 5) {
 189                 ret = dev->em28xx_read_reg(dev, 0x05);
 190                 if (!ret)
 191                         break;
 192                 msleep(5);
 193         }
 194
 195         return wrcount;
 196 }
 197
 198 /*
 199  * em28xx_i2c_recv_bytes()
 200  * read a byte from the i2c device
 201  */
 202 static int em28xx_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
 203                                  char *buf, int len)
 204 {
 205         int ret;
 206         ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
 207         if (ret < 0) {
 208                 em28xx_warn("reading i2c device failed (error=%i)\n", ret);
 209                 return ret;
 210         }
 211         if (dev->em28xx_read_reg(dev, 0x5) != 0)
 212                 return -ENODEV;
 213         return ret;
 214 }
 215
 216 /*
 217  * em28xx_i2c_check_for_device()
 218  * check if there is a i2c_device at the supplied address
 219  */
 220 static int em28xx_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
 221 {
 222         int ret;
 223
 224         ret = dev->em28xx_read_reg_req(dev, 2, addr);
 225         if (ret < 0) {
 226                 em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
 227                 return ret;
 228         }
 229         if (dev->em28xx_read_reg(dev, 0x5) != 0)
 230                 return -ENODEV;
 231         return 0;
 232 }
 233
 234 /*
 235  * em28xx_i2c_xfer()
 236  * the main i2c transfer function
 237  */
 238 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
 239                            struct i2c_msg msgs[], int num)
 240 {
 241         struct em28xx *dev = i2c_adap->algo_data;
 242         int addr, rc, i, byte;
 243
 244         if (num <= 0)
 245                 return 0;
 246         for (i = 0; i < num; i++) {
 247                 addr = msgs[i].addr << 1;
 248                 dprintk2(2, "%s %s addr=%x len=%d:",
 249                          (msgs[i].flags & I2C_M_RD) ? "read" : "write",
 250                          i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
 251                 if (!msgs[i].len) { /* no len: check only for device presence */
 252                         if (dev->board.is_em2800)
 253                                 rc = em2800_i2c_check_for_device(dev, addr);
 254                         else
 255                                 rc = em28xx_i2c_check_for_device(dev, addr);
 256                         if (rc < 0) {
 257                                 dprintk2(2, " no device\n");
 258                                 return rc;
 259                         }
 260
 261                 } else if (msgs[i].flags & I2C_M_RD) {
 262                         /* read bytes */
 263                         if (dev->board.is_em2800)
 264                                 rc = em2800_i2c_recv_bytes(dev, addr,
 265                                                            msgs[i].buf,
 266                                                            msgs[i].len);
 267                         else
 268                                 rc = em28xx_i2c_recv_bytes(dev, addr,
 269                                                            msgs[i].buf,
 270                                                            msgs[i].len);
 271                         if (i2c_debug >= 2) {
 272                                 for (byte = 0; byte < msgs[i].len; byte++)
 273                                         printk(" %02x", msgs[i].buf[byte]);
 274                         }
 275                 } else {
 276                         /* write bytes */
 277                         if (i2c_debug >= 2) {
 278                                 for (byte = 0; byte < msgs[i].len; byte++)
 279                                         printk(" %02x", msgs[i].buf[byte]);
 280                         }
 281                         if (dev->board.is_em2800)
 282                                 rc = em2800_i2c_send_bytes(dev, addr,
 283                                                            msgs[i].buf,
 284                                                            msgs[i].len);
 285                         else
 286                                 rc = em28xx_i2c_send_bytes(dev, addr,
 287                                                            msgs[i].buf,
 288                                                            msgs[i].len,
 289                                                            i == num - 1);
 290                 }
 291                 if (rc < 0)
 292                         goto err;
 293                 if (i2c_debug >= 2)
 294                         printk("\n");
 295         }
 296
 297         return num;
 298 err:
 299         dprintk2(2, " ERROR: %i\n", rc);
 300         return rc;
 301 }
 302
 303 /* based on linux/sunrpc/svcauth.h and linux/hash.h
 304  * The original hash function returns a different value, if arch is x86_64
 305  *  or i386.
 306  */
 307 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
 308 {
 309         unsigned long hash = 0;
 310         unsigned long l = 0;
 311         int len = 0;
 312         unsigned char c;
 313         do {
 314                 if (len == length) {
 315                         c = (char)len;
 316                         len = -1;
 317                 } else
 318                         c = *buf++;
 319                 l = (l << 8) | c;
 320                 len++;
 321                 if ((len & (32 / 8 - 1)) == 0)
 322                         hash = ((hash^l) * 0x9e370001UL);
 323         } while (len);
 324
 325         return (hash >> (32 - bits)) & 0xffffffffUL;
 326 }
 327
 328 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
 329 {
 330         unsigned char buf, *p = eedata;
 331         struct em28xx_eeprom *em_eeprom = (void *)eedata;
 332         int i, err, size = len, block;
 333
 334         if (dev->chip_id == CHIP_ID_EM2874 ||
 335             dev->chip_id == CHIP_ID_EM28174 ||
 336             dev->chip_id == CHIP_ID_EM2884) {
 337                 /* Empia switched to a 16-bit addressable eeprom in newer
 338                    devices.  While we could certainly write a routine to read
 339                    the eeprom, there is nothing of use in there that cannot be
 340                    accessed through registers, and there is the risk that we
 341                    could corrupt the eeprom (since a 16-bit read call is
 342                    interpreted as a write call by 8-bit eeproms).
 343                 */
 344                 return 0;
 345         }
 346
 347         dev->i2c_client.addr = 0xa0 >> 1;
 348
 349         /* Check if board has eeprom */
 350         err = i2c_master_recv(&dev->i2c_client, &buf, 0);
 351         if (err < 0) {
 352                 em28xx_errdev("board has no eeprom\n");
 353                 memset(eedata, 0, len);
 354                 return -ENODEV;
 355         }
 356
 357         buf = 0;
 358
 359         err = i2c_master_send(&dev->i2c_client, &buf, 1);
 360         if (err != 1) {
 361                 printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
 362                        dev->name, err);
 363                 return err;
 364         }
 365         while (size > 0) {
 366                 if (size > 16)
 367                         block = 16;
 368                 else
 369                         block = size;
 370
 371                 if (block !=
 372                     (err = i2c_master_recv(&dev->i2c_client, p, block))) {
 373                         printk(KERN_WARNING
 374                                "%s: i2c eeprom read error (err=%d)\n",
 375                                dev->name, err);
 376                         return err;
 377                 }
 378                 size -= block;
 379                 p += block;
 380         }
 381         for (i = 0; i < len; i++) {
 382                 if (0 == (i % 16))
 383                         printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
 384                 printk(" %02x", eedata[i]);
 385                 if (15 == (i % 16))
 386                         printk("\n");
 387         }
 388
 389         if (em_eeprom->id == 0x9567eb1a)
 390                 dev->hash = em28xx_hash_mem(eedata, len, 32);
 391
 392         printk(KERN_INFO "%s: EEPROM ID= 0x%08x, EEPROM hash = 0x%08lx\n",
 393                dev->name, em_eeprom->id, dev->hash);
 394
 395         printk(KERN_INFO "%s: EEPROM info:\n", dev->name);
 396
 397         switch (em_eeprom->chip_conf >> 4 & 0x3) {
 398         case 0:
 399                 printk(KERN_INFO "%s:\tNo audio on board.\n", dev->name);
 400                 break;
 401         case 1:
 402                 printk(KERN_INFO "%s:\tAC97 audio (5 sample rates)\n",
 403                                  dev->name);
 404                 break;
 405         case 2:
 406                 printk(KERN_INFO "%s:\tI2S audio, sample rate=32k\n",
 407                                  dev->name);
 408                 break;
 409         case 3:
 410                 printk(KERN_INFO "%s:\tI2S audio, 3 sample rates\n",
 411                                  dev->name);
 412                 break;
 413         }
 414
 415         if (em_eeprom->chip_conf & 1 << 3)
 416                 printk(KERN_INFO "%s:\tUSB Remote wakeup capable\n", dev->name);
 417
 418         if (em_eeprom->chip_conf & 1 << 2)
 419                 printk(KERN_INFO "%s:\tUSB Self power capable\n", dev->name);
 420
 421         switch (em_eeprom->chip_conf & 0x3) {
 422         case 0:
 423                 printk(KERN_INFO "%s:\t500mA max power\n", dev->name);
 424                 break;
 425         case 1:
 426                 printk(KERN_INFO "%s:\t400mA max power\n", dev->name);
 427                 break;
 428         case 2:
 429                 printk(KERN_INFO "%s:\t300mA max power\n", dev->name);
 430                 break;
 431         case 3:
 432                 printk(KERN_INFO "%s:\t200mA max power\n", dev->name);
 433                 break;
 434         }
 435         printk(KERN_INFO "%s:\tTable at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
 436                                 dev->name,
 437                                 em_eeprom->string_idx_table,
 438                                 em_eeprom->string1,
 439                                 em_eeprom->string2,
 440                                 em_eeprom->string3);
 441
 442         return 0;
 443 }
 444
 445 /* ----------------------------------------------------------- */
 446
 447 /*
 448  * functionality()
 449  */
 450 static u32 functionality(struct i2c_adapter *adap)
 451 {
 452         return I2C_FUNC_SMBUS_EMUL;
 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         [0x60 >> 1] = "remote IR sensor",
 479         [0x8e >> 1] = "remote IR sensor",
 480         [0x86 >> 1] = "tda9887",
 481         [0x80 >> 1] = "msp34xx",
 482         [0x88 >> 1] = "msp34xx",
 483         [0xa0 >> 1] = "eeprom",
 484         [0xb0 >> 1] = "tda9874",
 485         [0xb8 >> 1] = "tvp5150a",
 486         [0xba >> 1] = "webcam sensor or tvp5150a",
 487         [0xc0 >> 1] = "tuner (analog)",
 488         [0xc2 >> 1] = "tuner (analog)",
 489         [0xc4 >> 1] = "tuner (analog)",
 490         [0xc6 >> 1] = "tuner (analog)",
 491 };
 492
 493 /*
 494  * do_i2c_scan()
 495  * check i2c address range for devices
 496  */
 497 void em28xx_do_i2c_scan(struct em28xx *dev)
 498 {
 499         u8 i2c_devicelist[128];
 500         unsigned char buf;
 501         int i, rc;
 502
 503         memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
 504
 505         for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
 506                 dev->i2c_client.addr = i;
 507                 rc = i2c_master_recv(&dev->i2c_client, &buf, 0);
 508                 if (rc < 0)
 509                         continue;
 510                 i2c_devicelist[i] = i;
 511                 printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n",
 512                        dev->name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
 513         }
 514
 515         dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
 516                                         ARRAY_SIZE(i2c_devicelist), 32);
 517 }
 518
 519 /*
 520  * em28xx_i2c_register()
 521  * register i2c bus
 522  */
 523 int em28xx_i2c_register(struct em28xx *dev)
 524 {
 525         int retval;
 526
 527         BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
 528         BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
 529         dev->i2c_adap = em28xx_adap_template;
 530         dev->i2c_adap.dev.parent = &dev->udev->dev;
 531         strcpy(dev->i2c_adap.name, dev->name);
 532         dev->i2c_adap.algo_data = dev;
 533         i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
 534
 535         retval = i2c_add_adapter(&dev->i2c_adap);
 536         if (retval < 0) {
 537                 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
 538                         __func__, retval);
 539                 return retval;
 540         }
 541
 542         dev->i2c_client = em28xx_client_template;
 543         dev->i2c_client.adapter = &dev->i2c_adap;
 544
 545         retval = em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
 546         if ((retval < 0) && (retval != -ENODEV)) {
 547                 em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
 548                         __func__, retval);
 549
 550                 return retval;
 551         }
 552
 553         if (i2c_scan)
 554                 em28xx_do_i2c_scan(dev);
 555
 556         return 0;
 557 }
 558
 559 /*
 560  * em28xx_i2c_unregister()
 561  * unregister i2c_bus
 562  */
 563 int em28xx_i2c_unregister(struct em28xx *dev)
 564 {
 565         i2c_del_adapter(&dev->i2c_adap);
 566         return 0;
 567 }