git.oblomov.eu Git - linux-2.6/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         char msg;
 222         int ret;
 223         msg = addr;
 224
 225         ret = dev->em28xx_read_reg_req(dev, 2, addr);
 226         if (ret < 0) {
 227                 em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
 228                 return ret;
 229         }
 230         if (dev->em28xx_read_reg(dev, 0x5) != 0)
 231                 return -ENODEV;
 232         return 0;
 233 }
 234
 235 /*
 236  * em28xx_i2c_xfer()
 237  * the main i2c transfer function
 238  */
 239 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
 240                            struct i2c_msg msgs[], int num)
 241 {
 242         struct em28xx *dev = i2c_adap->algo_data;
 243         int addr, rc, i, byte;
 244
 245         if (num <= 0)
 246                 return 0;
 247         for (i = 0; i < num; i++) {
 248                 addr = msgs[i].addr << 1;
 249                 dprintk2(2, "%s %s addr=%x len=%d:",
 250                          (msgs[i].flags & I2C_M_RD) ? "read" : "write",
 251                          i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
 252                 if (!msgs[i].len) { /* no len: check only for device presence */
 253                         if (dev->board.is_em2800)
 254                                 rc = em2800_i2c_check_for_device(dev, addr);
 255                         else
 256                                 rc = em28xx_i2c_check_for_device(dev, addr);
 257                         if (rc < 0) {
 258                                 dprintk2(2, " no device\n");
 259                                 return rc;
 260                         }
 261
 262                 } else if (msgs[i].flags & I2C_M_RD) {
 263                         /* read bytes */
 264                         if (dev->board.is_em2800)
 265                                 rc = em2800_i2c_recv_bytes(dev, addr,
 266                                                            msgs[i].buf,
 267                                                            msgs[i].len);
 268                         else
 269                                 rc = em28xx_i2c_recv_bytes(dev, addr,
 270                                                            msgs[i].buf,
 271                                                            msgs[i].len);
 272                         if (i2c_debug >= 2) {
 273                                 for (byte = 0; byte < msgs[i].len; byte++)
 274                                         printk(" %02x", msgs[i].buf[byte]);
 275                         }
 276                 } else {
 277                         /* write bytes */
 278                         if (i2c_debug >= 2) {
 279                                 for (byte = 0; byte < msgs[i].len; byte++)
 280                                         printk(" %02x", msgs[i].buf[byte]);
 281                         }
 282                         if (dev->board.is_em2800)
 283                                 rc = em2800_i2c_send_bytes(dev, addr,
 284                                                            msgs[i].buf,
 285                                                            msgs[i].len);
 286                         else
 287                                 rc = em28xx_i2c_send_bytes(dev, addr,
 288                                                            msgs[i].buf,
 289                                                            msgs[i].len,
 290                                                            i == num - 1);
 291                 }
 292                 if (rc < 0)
 293                         goto err;
 294                 if (i2c_debug >= 2)
 295                         printk("\n");
 296         }
 297
 298         return num;
 299 err:
 300         dprintk2(2, " ERROR: %i\n", rc);
 301         return rc;
 302 }
 303
 304 /* based on linux/sunrpc/svcauth.h and linux/hash.h
 305  * The original hash function returns a different value, if arch is x86_64
 306  *  or i386.
 307  */
 308 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
 309 {
 310         unsigned long hash = 0;
 311         unsigned long l = 0;
 312         int len = 0;
 313         unsigned char c;
 314         do {
 315                 if (len == length) {
 316                         c = (char)len;
 317                         len = -1;
 318                 } else
 319                         c = *buf++;
 320                 l = (l << 8) | c;
 321                 len++;
 322                 if ((len & (32 / 8 - 1)) == 0)
 323                         hash = ((hash^l) * 0x9e370001UL);
 324         } while (len);
 325
 326         return (hash >> (32 - bits)) & 0xffffffffUL;
 327 }
 328
 329 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
 330 {
 331         unsigned char buf, *p = eedata;
 332         struct em28xx_eeprom *em_eeprom = (void *)eedata;
 333         int i, err, size = len, block;
 334
 335         if (dev->chip_id == CHIP_ID_EM2874) {
 336                 /* Empia switched to a 16-bit addressable eeprom in newer
 337                    devices.  While we could certainly write a routine to read
 338                    the eeprom, there is nothing of use in there that cannot be
 339                    accessed through registers, and there is the risk that we
 340                    could corrupt the eeprom (since a 16-bit read call is
 341                    interpreted as a write call by 8-bit eeproms).
 342                 */
 343                 return 0;
 344         }
 345
 346         dev->i2c_client.addr = 0xa0 >> 1;
 347
 348         /* Check if board has eeprom */
 349         err = i2c_master_recv(&dev->i2c_client, &buf, 0);
 350         if (err < 0) {
 351                 em28xx_errdev("board has no eeprom\n");
 352                 memset(eedata, 0, len);
 353                 return -ENODEV;
 354         }
 355
 356         buf = 0;
 357
 358         err = i2c_master_send(&dev->i2c_client, &buf, 1);
 359         if (err != 1) {
 360                 printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
 361                        dev->name, err);
 362                 return err;
 363         }
 364         while (size > 0) {
 365                 if (size > 16)
 366                         block = 16;
 367                 else
 368                         block = size;
 369
 370                 if (block !=
 371                     (err = i2c_master_recv(&dev->i2c_client, p, block))) {
 372                         printk(KERN_WARNING
 373                                "%s: i2c eeprom read error (err=%d)\n",
 374                                dev->name, err);
 375                         return err;
 376                 }
 377                 size -= block;
 378                 p += block;
 379         }
 380         for (i = 0; i < len; i++) {
 381                 if (0 == (i % 16))
 382                         printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
 383                 printk(" %02x", eedata[i]);
 384                 if (15 == (i % 16))
 385                         printk("\n");
 386         }
 387
 388         if (em_eeprom->id == 0x9567eb1a)
 389                 dev->hash = em28xx_hash_mem(eedata, len, 32);
 390
 391         printk(KERN_INFO "%s: EEPROM ID= 0x%08x, EEPROM hash = 0x%08lx\n",
 392                dev->name, em_eeprom->id, dev->hash);
 393
 394         printk(KERN_INFO "%s: EEPROM info:\n", dev->name);
 395
 396         switch (em_eeprom->chip_conf >> 4 & 0x3) {
 397         case 0:
 398                 printk(KERN_INFO "%s:\tNo audio on board.\n", dev->name);
 399                 break;
 400         case 1:
 401                 printk(KERN_INFO "%s:\tAC97 audio (5 sample rates)\n",
 402                                  dev->name);
 403                 break;
 404         case 2:
 405                 printk(KERN_INFO "%s:\tI2S audio, sample rate=32k\n",
 406                                  dev->name);
 407                 break;
 408         case 3:
 409                 printk(KERN_INFO "%s:\tI2S audio, 3 sample rates\n",
 410                                  dev->name);
 411                 break;
 412         }
 413
 414         if (em_eeprom->chip_conf & 1 << 3)
 415                 printk(KERN_INFO "%s:\tUSB Remote wakeup capable\n", dev->name);
 416
 417         if (em_eeprom->chip_conf & 1 << 2)
 418                 printk(KERN_INFO "%s:\tUSB Self power capable\n", dev->name);
 419
 420         switch (em_eeprom->chip_conf & 0x3) {
 421         case 0:
 422                 printk(KERN_INFO "%s:\t500mA max power\n", dev->name);
 423                 break;
 424         case 1:
 425                 printk(KERN_INFO "%s:\t400mA max power\n", dev->name);
 426                 break;
 427         case 2:
 428                 printk(KERN_INFO "%s:\t300mA max power\n", dev->name);
 429                 break;
 430         case 3:
 431                 printk(KERN_INFO "%s:\t200mA max power\n", dev->name);
 432                 break;
 433         }
 434         printk(KERN_INFO "%s:\tTable at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
 435                                 dev->name,
 436                                 em_eeprom->string_idx_table,
 437                                 em_eeprom->string1,
 438                                 em_eeprom->string2,
 439                                 em_eeprom->string3);
 440
 441         return 0;
 442 }
 443
 444 /* ----------------------------------------------------------- */
 445
 446 /*
 447  * functionality()
 448  */
 449 static u32 functionality(struct i2c_adapter *adap)
 450 {
 451         return I2C_FUNC_SMBUS_EMUL;
 452 }
 453
 454 /*
 455  * attach_inform()
 456  * gets called when a device attaches to the i2c bus
 457  * does some basic configuration
 458  */
 459 static int attach_inform(struct i2c_client *client)
 460 {
 461         struct em28xx *dev = client->adapter->algo_data;
 462
 463         switch (client->addr << 1) {
 464         case 0x86:
 465         case 0x84:
 466         case 0x96:
 467         case 0x94:
 468         {
 469                 struct v4l2_priv_tun_config tda9887_cfg;
 470
 471                 struct tuner_setup tun_setup;
 472
 473                 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
 474                 tun_setup.type = TUNER_TDA9887;
 475                 tun_setup.addr = client->addr;
 476
 477                 em28xx_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR,
 478                         &tun_setup);
 479
 480                 tda9887_cfg.tuner = TUNER_TDA9887;
 481                 tda9887_cfg.priv = &dev->tda9887_conf;
 482                 em28xx_i2c_call_clients(dev, TUNER_SET_CONFIG,
 483                                         &tda9887_cfg);
 484                 break;
 485         }
 486         case 0x42:
 487                 dprintk1(1, "attach_inform: saa7114 detected.\n");
 488                 break;
 489         case 0x4a:
 490                 dprintk1(1, "attach_inform: saa7113 detected.\n");
 491                 break;
 492         case 0xa0:
 493                 dprintk1(1, "attach_inform: eeprom detected.\n");
 494                 break;
 495         case 0x60:
 496         case 0x8e:
 497         {
 498                 struct IR_i2c *ir = i2c_get_clientdata(client);
 499                 dprintk1(1, "attach_inform: IR detected (%s).\n",
 500                         ir->phys);
 501                 em28xx_set_ir(dev, ir);
 502                 break;
 503         }
 504         case 0x80:
 505         case 0x88:
 506                 dprintk1(1, "attach_inform: msp34xx detected.\n");
 507                 break;
 508         case 0xb8:
 509         case 0xba:
 510                 dprintk1(1, "attach_inform: tvp5150 detected.\n");
 511                 break;
 512
 513         case 0xb0:
 514                 dprintk1(1, "attach_inform: tda9874 detected\n");
 515                 break;
 516
 517         default:
 518                 if (!dev->tuner_addr)
 519                         dev->tuner_addr = client->addr;
 520
 521                 dprintk1(1, "attach inform: detected I2C address %x\n",
 522                                 client->addr << 1);
 523                 dprintk1(1, "driver id %d\n", client->driver->id);
 524
 525         }
 526
 527         return 0;
 528 }
 529
 530 static struct i2c_algorithm em28xx_algo = {
 531         .master_xfer   = em28xx_i2c_xfer,
 532         .functionality = functionality,
 533 };
 534
 535 static struct i2c_adapter em28xx_adap_template = {
 536         .owner = THIS_MODULE,
 537         .class = I2C_CLASS_TV_ANALOG,
 538         .name = "em28xx",
 539         .id = I2C_HW_B_EM28XX,
 540         .algo = &em28xx_algo,
 541         .client_register = attach_inform,
 542 };
 543
 544 static struct i2c_client em28xx_client_template = {
 545         .name = "em28xx internal",
 546 };
 547
 548 /* ----------------------------------------------------------- */
 549
 550 /*
 551  * i2c_devs
 552  * incomplete list of known devices
 553  */
 554 static char *i2c_devs[128] = {
 555         [0x4a >> 1] = "saa7113h",
 556         [0x60 >> 1] = "remote IR sensor",
 557         [0x8e >> 1] = "remote IR sensor",
 558         [0x86 >> 1] = "tda9887",
 559         [0x80 >> 1] = "msp34xx",
 560         [0x88 >> 1] = "msp34xx",
 561         [0xa0 >> 1] = "eeprom",
 562         [0xb0 >> 1] = "tda9874",
 563         [0xb8 >> 1] = "tvp5150a",
 564         [0xba >> 1] = "tvp5150a",
 565         [0xc0 >> 1] = "tuner (analog)",
 566         [0xc2 >> 1] = "tuner (analog)",
 567         [0xc4 >> 1] = "tuner (analog)",
 568         [0xc6 >> 1] = "tuner (analog)",
 569 };
 570
 571 /*
 572  * do_i2c_scan()
 573  * check i2c address range for devices
 574  */
 575 void em28xx_do_i2c_scan(struct em28xx *dev)
 576 {
 577         u8 i2c_devicelist[128];
 578         unsigned char buf;
 579         int i, rc;
 580
 581         memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
 582
 583         for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
 584                 dev->i2c_client.addr = i;
 585                 rc = i2c_master_recv(&dev->i2c_client, &buf, 0);
 586                 if (rc < 0)
 587                         continue;
 588                 i2c_devicelist[i] = i;
 589                 printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n",
 590                        dev->name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
 591         }
 592
 593         dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
 594                                         ARRAY_SIZE(i2c_devicelist), 32);
 595 }
 596
 597 /*
 598  * em28xx_i2c_call_clients()
 599  * send commands to all attached i2c devices
 600  */
 601 void em28xx_i2c_call_clients(struct em28xx *dev, unsigned int cmd, void *arg)
 602 {
 603         BUG_ON(NULL == dev->i2c_adap.algo_data);
 604         i2c_clients_command(&dev->i2c_adap, cmd, arg);
 605 }
 606
 607 /*
 608  * em28xx_i2c_register()
 609  * register i2c bus
 610  */
 611 int em28xx_i2c_register(struct em28xx *dev)
 612 {
 613         int retval;
 614
 615         BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
 616         BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
 617         dev->i2c_adap = em28xx_adap_template;
 618         dev->i2c_adap.dev.parent = &dev->udev->dev;
 619         strcpy(dev->i2c_adap.name, dev->name);
 620         dev->i2c_adap.algo_data = dev;
 621
 622         retval = i2c_add_adapter(&dev->i2c_adap);
 623         if (retval < 0) {
 624                 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
 625                         __func__, retval);
 626                 return retval;
 627         }
 628
 629         dev->i2c_client = em28xx_client_template;
 630         dev->i2c_client.adapter = &dev->i2c_adap;
 631
 632         retval = em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
 633         if ((retval < 0) && (retval != -ENODEV)) {
 634                 em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
 635                         __func__, retval);
 636
 637                 return retval;
 638         }
 639
 640         if (i2c_scan)
 641                 em28xx_do_i2c_scan(dev);
 642
 643         return 0;
 644 }
 645
 646 /*
 647  * em28xx_i2c_unregister()
 648  * unregister i2c_bus
 649  */
 650 int em28xx_i2c_unregister(struct em28xx *dev)
 651 {
 652         i2c_del_adapter(&dev->i2c_adap);
 653         return 0;
 654 }