Pileus Git - ~andy/linux/blob - 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  * untested for more than 4 bytes
 185  */
 186 static int em28xx_i2c_send_bytes(void *data, unsigned char addr, char *buf,
 187                                  short len, int stop)
 188 {
 189         int wrcount = 0;
 190         struct em28xx *dev = (struct em28xx *)data;
 191
 192         wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
 193
 194         return wrcount;
 195 }
 196
 197 /*
 198  * em28xx_i2c_recv_bytes()
 199  * read a byte from the i2c device
 200  */
 201 static int em28xx_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
 202                                  char *buf, int len)
 203 {
 204         int ret;
 205         ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
 206         if (ret < 0) {
 207                 em28xx_warn("reading i2c device failed (error=%i)\n", ret);
 208                 return ret;
 209         }
 210         if (dev->em28xx_read_reg(dev, 0x5) != 0)
 211                 return -ENODEV;
 212         return ret;
 213 }
 214
 215 /*
 216  * em28xx_i2c_check_for_device()
 217  * check if there is a i2c_device at the supplied address
 218  */
 219 static int em28xx_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
 220 {
 221         int ret;
 222
 223         ret = dev->em28xx_read_reg_req(dev, 2, addr);
 224         if (ret < 0) {
 225                 em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
 226                 return ret;
 227         }
 228         if (dev->em28xx_read_reg(dev, 0x5) != 0)
 229                 return -ENODEV;
 230         return 0;
 231 }
 232
 233 /*
 234  * em28xx_i2c_xfer()
 235  * the main i2c transfer function
 236  */
 237 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
 238                            struct i2c_msg msgs[], int num)
 239 {
 240         struct em28xx *dev = i2c_adap->algo_data;
 241         int addr, rc, i, byte;
 242
 243         if (num <= 0)
 244                 return 0;
 245         for (i = 0; i < num; i++) {
 246                 addr = msgs[i].addr << 1;
 247                 dprintk2(2, "%s %s addr=%x len=%d:",
 248                          (msgs[i].flags & I2C_M_RD) ? "read" : "write",
 249                          i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
 250                 if (!msgs[i].len) { /* no len: check only for device presence */
 251                         if (dev->board.is_em2800)
 252                                 rc = em2800_i2c_check_for_device(dev, addr);
 253                         else
 254                                 rc = em28xx_i2c_check_for_device(dev, addr);
 255                         if (rc < 0) {
 256                                 dprintk2(2, " no device\n");
 257                                 return rc;
 258                         }
 259
 260                 } else if (msgs[i].flags & I2C_M_RD) {
 261                         /* read bytes */
 262                         if (dev->board.is_em2800)
 263                                 rc = em2800_i2c_recv_bytes(dev, addr,
 264                                                            msgs[i].buf,
 265                                                            msgs[i].len);
 266                         else
 267                                 rc = em28xx_i2c_recv_bytes(dev, addr,
 268                                                            msgs[i].buf,
 269                                                            msgs[i].len);
 270                         if (i2c_debug >= 2) {
 271                                 for (byte = 0; byte < msgs[i].len; byte++)
 272                                         printk(" %02x", msgs[i].buf[byte]);
 273                         }
 274                 } else {
 275                         /* write bytes */
 276                         if (i2c_debug >= 2) {
 277                                 for (byte = 0; byte < msgs[i].len; byte++)
 278                                         printk(" %02x", msgs[i].buf[byte]);
 279                         }
 280                         if (dev->board.is_em2800)
 281                                 rc = em2800_i2c_send_bytes(dev, addr,
 282                                                            msgs[i].buf,
 283                                                            msgs[i].len);
 284                         else
 285                                 rc = em28xx_i2c_send_bytes(dev, addr,
 286                                                            msgs[i].buf,
 287                                                            msgs[i].len,
 288                                                            i == num - 1);
 289                 }
 290                 if (rc < 0)
 291                         goto err;
 292                 if (i2c_debug >= 2)
 293                         printk("\n");
 294         }
 295
 296         return num;
 297 err:
 298         dprintk2(2, " ERROR: %i\n", rc);
 299         return rc;
 300 }
 301
 302 /* based on linux/sunrpc/svcauth.h and linux/hash.h
 303  * The original hash function returns a different value, if arch is x86_64
 304  *  or i386.
 305  */
 306 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
 307 {
 308         unsigned long hash = 0;
 309         unsigned long l = 0;
 310         int len = 0;
 311         unsigned char c;
 312         do {
 313                 if (len == length) {
 314                         c = (char)len;
 315                         len = -1;
 316                 } else
 317                         c = *buf++;
 318                 l = (l << 8) | c;
 319                 len++;
 320                 if ((len & (32 / 8 - 1)) == 0)
 321                         hash = ((hash^l) * 0x9e370001UL);
 322         } while (len);
 323
 324         return (hash >> (32 - bits)) & 0xffffffffUL;
 325 }
 326
 327 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
 328 {
 329         unsigned char buf, *p = eedata;
 330         struct em28xx_eeprom *em_eeprom = (void *)eedata;
 331         int i, err, size = len, block;
 332
 333         if (dev->chip_id == CHIP_ID_EM2874 || dev->chip_id == CHIP_ID_EM28174) {
 334                 /* Empia switched to a 16-bit addressable eeprom in newer
 335                    devices.  While we could certainly write a routine to read
 336                    the eeprom, there is nothing of use in there that cannot be
 337                    accessed through registers, and there is the risk that we
 338                    could corrupt the eeprom (since a 16-bit read call is
 339                    interpreted as a write call by 8-bit eeproms).
 340                 */
 341                 return 0;
 342         }
 343
 344         dev->i2c_client.addr = 0xa0 >> 1;
 345
 346         /* Check if board has eeprom */
 347         err = i2c_master_recv(&dev->i2c_client, &buf, 0);
 348         if (err < 0) {
 349                 em28xx_errdev("board has no eeprom\n");
 350                 memset(eedata, 0, len);
 351                 return -ENODEV;
 352         }
 353
 354         buf = 0;
 355
 356         err = i2c_master_send(&dev->i2c_client, &buf, 1);
 357         if (err != 1) {
 358                 printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
 359                        dev->name, err);
 360                 return err;
 361         }
 362         while (size > 0) {
 363                 if (size > 16)
 364                         block = 16;
 365                 else
 366                         block = size;
 367
 368                 if (block !=
 369                     (err = i2c_master_recv(&dev->i2c_client, p, block))) {
 370                         printk(KERN_WARNING
 371                                "%s: i2c eeprom read error (err=%d)\n",
 372                                dev->name, err);
 373                         return err;
 374                 }
 375                 size -= block;
 376                 p += block;
 377         }
 378         for (i = 0; i < len; i++) {
 379                 if (0 == (i % 16))
 380                         printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
 381                 printk(" %02x", eedata[i]);
 382                 if (15 == (i % 16))
 383                         printk("\n");
 384         }
 385
 386         if (em_eeprom->id == 0x9567eb1a)
 387                 dev->hash = em28xx_hash_mem(eedata, len, 32);
 388
 389         printk(KERN_INFO "%s: EEPROM ID= 0x%08x, EEPROM hash = 0x%08lx\n",
 390                dev->name, em_eeprom->id, dev->hash);
 391
 392         printk(KERN_INFO "%s: EEPROM info:\n", dev->name);
 393
 394         switch (em_eeprom->chip_conf >> 4 & 0x3) {
 395         case 0:
 396                 printk(KERN_INFO "%s:\tNo audio on board.\n", dev->name);
 397                 break;
 398         case 1:
 399                 printk(KERN_INFO "%s:\tAC97 audio (5 sample rates)\n",
 400                                  dev->name);
 401                 break;
 402         case 2:
 403                 printk(KERN_INFO "%s:\tI2S audio, sample rate=32k\n",
 404                                  dev->name);
 405                 break;
 406         case 3:
 407                 printk(KERN_INFO "%s:\tI2S audio, 3 sample rates\n",
 408                                  dev->name);
 409                 break;
 410         }
 411
 412         if (em_eeprom->chip_conf & 1 << 3)
 413                 printk(KERN_INFO "%s:\tUSB Remote wakeup capable\n", dev->name);
 414
 415         if (em_eeprom->chip_conf & 1 << 2)
 416                 printk(KERN_INFO "%s:\tUSB Self power capable\n", dev->name);
 417
 418         switch (em_eeprom->chip_conf & 0x3) {
 419         case 0:
 420                 printk(KERN_INFO "%s:\t500mA max power\n", dev->name);
 421                 break;
 422         case 1:
 423                 printk(KERN_INFO "%s:\t400mA max power\n", dev->name);
 424                 break;
 425         case 2:
 426                 printk(KERN_INFO "%s:\t300mA max power\n", dev->name);
 427                 break;
 428         case 3:
 429                 printk(KERN_INFO "%s:\t200mA max power\n", dev->name);
 430                 break;
 431         }
 432         printk(KERN_INFO "%s:\tTable at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
 433                                 dev->name,
 434                                 em_eeprom->string_idx_table,
 435                                 em_eeprom->string1,
 436                                 em_eeprom->string2,
 437                                 em_eeprom->string3);
 438
 439         return 0;
 440 }
 441
 442 /* ----------------------------------------------------------- */
 443
 444 /*
 445  * functionality()
 446  */
 447 static u32 functionality(struct i2c_adapter *adap)
 448 {
 449         return I2C_FUNC_SMBUS_EMUL;
 450 }
 451
 452 static struct i2c_algorithm em28xx_algo = {
 453         .master_xfer   = em28xx_i2c_xfer,
 454         .functionality = functionality,
 455 };
 456
 457 static struct i2c_adapter em28xx_adap_template = {
 458         .owner = THIS_MODULE,
 459         .name = "em28xx",
 460         .algo = &em28xx_algo,
 461 };
 462
 463 static struct i2c_client em28xx_client_template = {
 464         .name = "em28xx internal",
 465 };
 466
 467 /* ----------------------------------------------------------- */
 468
 469 /*
 470  * i2c_devs
 471  * incomplete list of known devices
 472  */
 473 static char *i2c_devs[128] = {
 474         [0x4a >> 1] = "saa7113h",
 475         [0x60 >> 1] = "remote IR sensor",
 476         [0x8e >> 1] = "remote IR sensor",
 477         [0x86 >> 1] = "tda9887",
 478         [0x80 >> 1] = "msp34xx",
 479         [0x88 >> 1] = "msp34xx",
 480         [0xa0 >> 1] = "eeprom",
 481         [0xb0 >> 1] = "tda9874",
 482         [0xb8 >> 1] = "tvp5150a",
 483         [0xba >> 1] = "webcam sensor or tvp5150a",
 484         [0xc0 >> 1] = "tuner (analog)",
 485         [0xc2 >> 1] = "tuner (analog)",
 486         [0xc4 >> 1] = "tuner (analog)",
 487         [0xc6 >> 1] = "tuner (analog)",
 488 };
 489
 490 /*
 491  * do_i2c_scan()
 492  * check i2c address range for devices
 493  */
 494 void em28xx_do_i2c_scan(struct em28xx *dev)
 495 {
 496         u8 i2c_devicelist[128];
 497         unsigned char buf;
 498         int i, rc;
 499
 500         memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
 501
 502         for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
 503                 dev->i2c_client.addr = i;
 504                 rc = i2c_master_recv(&dev->i2c_client, &buf, 0);
 505                 if (rc < 0)
 506                         continue;
 507                 i2c_devicelist[i] = i;
 508                 printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n",
 509                        dev->name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
 510         }
 511
 512         dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
 513                                         ARRAY_SIZE(i2c_devicelist), 32);
 514 }
 515
 516 /*
 517  * em28xx_i2c_register()
 518  * register i2c bus
 519  */
 520 int em28xx_i2c_register(struct em28xx *dev)
 521 {
 522         int retval;
 523
 524         BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
 525         BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
 526         dev->i2c_adap = em28xx_adap_template;
 527         dev->i2c_adap.dev.parent = &dev->udev->dev;
 528         strcpy(dev->i2c_adap.name, dev->name);
 529         dev->i2c_adap.algo_data = dev;
 530         i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
 531
 532         retval = i2c_add_adapter(&dev->i2c_adap);
 533         if (retval < 0) {
 534                 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
 535                         __func__, retval);
 536                 return retval;
 537         }
 538
 539         dev->i2c_client = em28xx_client_template;
 540         dev->i2c_client.adapter = &dev->i2c_adap;
 541
 542         retval = em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
 543         if ((retval < 0) && (retval != -ENODEV)) {
 544                 em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
 545                         __func__, retval);
 546
 547                 return retval;
 548         }
 549
 550         if (i2c_scan)
 551                 em28xx_do_i2c_scan(dev);
 552
 553         /* Instantiate the IR receiver device, if present */
 554         em28xx_register_i2c_ir(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 }