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