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    Copyright (C) 2013 Frank Schäfer <fschaefer.oss@googlemail.com>
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #include <linux/module.h>
  26 #include <linux/kernel.h>
  27 #include <linux/usb.h>
  28 #include <linux/i2c.h>
  29
  30 #include "em28xx.h"
  31 #include "tuner-xc2028.h"
  32 #include <media/v4l2-common.h>
  33 #include <media/tuner.h>
  34
  35 /* ----------------------------------------------------------- */
  36
  37 static unsigned int i2c_scan;
  38 module_param(i2c_scan, int, 0444);
  39 MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
  40
  41 static unsigned int i2c_debug;
  42 module_param(i2c_debug, int, 0644);
  43 MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
  44
  45 /*
  46  * em2800_i2c_send_bytes()
  47  * send up to 4 bytes to the em2800 i2c device
  48  */
  49 static int em2800_i2c_send_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
  50 {
  51         int ret;
  52         int write_timeout;
  53         u8 b2[6];
  54
  55         if (len < 1 || len > 4)
  56                 return -EOPNOTSUPP;
  57
  58         BUG_ON(len < 1 || len > 4);
  59         b2[5] = 0x80 + len - 1;
  60         b2[4] = addr;
  61         b2[3] = buf[0];
  62         if (len > 1)
  63                 b2[2] = buf[1];
  64         if (len > 2)
  65                 b2[1] = buf[2];
  66         if (len > 3)
  67                 b2[0] = buf[3];
  68
  69         /* trigger write */
  70         ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
  71         if (ret != 2 + len) {
  72                 em28xx_warn("failed to trigger write to i2c address 0x%x (error=%i)\n",
  73                             addr, ret);
  74                 return (ret < 0) ? ret : -EIO;
  75         }
  76         /* wait for completion */
  77         for (write_timeout = EM2800_I2C_XFER_TIMEOUT; write_timeout > 0;
  78              write_timeout -= 5) {
  79                 ret = dev->em28xx_read_reg(dev, 0x05);
  80                 if (ret == 0x80 + len - 1) {
  81                         return len;
  82                 } else if (ret == 0x94 + len - 1) {
  83                         return -ENODEV;
  84                 } else if (ret < 0) {
  85                         em28xx_warn("failed to get i2c transfer status from bridge register (error=%i)\n",
  86                                     ret);
  87                         return ret;
  88                 }
  89                 msleep(5);
  90         }
  91         em28xx_warn("write to i2c device at 0x%x timed out\n", addr);
  92         return -EIO;
  93 }
  94
  95 /*
  96  * em2800_i2c_recv_bytes()
  97  * read up to 4 bytes from the em2800 i2c device
  98  */
  99 static int em2800_i2c_recv_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
 100 {
 101         u8 buf2[4];
 102         int ret;
 103         int read_timeout;
 104         int i;
 105
 106         if (len < 1 || len > 4)
 107                 return -EOPNOTSUPP;
 108
 109         /* trigger read */
 110         buf2[1] = 0x84 + len - 1;
 111         buf2[0] = addr;
 112         ret = dev->em28xx_write_regs(dev, 0x04, buf2, 2);
 113         if (ret != 2) {
 114                 em28xx_warn("failed to trigger read from i2c address 0x%x (error=%i)\n",
 115                             addr, ret);
 116                 return (ret < 0) ? ret : -EIO;
 117         }
 118
 119         /* wait for completion */
 120         for (read_timeout = EM2800_I2C_XFER_TIMEOUT; read_timeout > 0;
 121              read_timeout -= 5) {
 122                 ret = dev->em28xx_read_reg(dev, 0x05);
 123                 if (ret == 0x84 + len - 1) {
 124                         break;
 125                 } else if (ret == 0x94 + len - 1) {
 126                         return -ENODEV;
 127                 } else if (ret < 0) {
 128                         em28xx_warn("failed to get i2c transfer status from bridge register (error=%i)\n",
 129                                     ret);
 130                         return ret;
 131                 }
 132                 msleep(5);
 133         }
 134         if (ret != 0x84 + len - 1)
 135                 em28xx_warn("read from i2c device at 0x%x timed out\n", addr);
 136
 137         /* get the received message */
 138         ret = dev->em28xx_read_reg_req_len(dev, 0x00, 4-len, buf2, len);
 139         if (ret != len) {
 140                 em28xx_warn("reading from i2c device at 0x%x failed: couldn't get the received message from the bridge (error=%i)\n",
 141                             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 write_timeout, ret;
 172
 173         if (len < 1 || len > 64)
 174                 return -EOPNOTSUPP;
 175         /*
 176          * NOTE: limited by the USB ctrl message constraints
 177          * Zero length reads always succeed, even if no device is connected
 178          */
 179
 180         /* Write to i2c device */
 181         ret = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
 182         if (ret != len) {
 183                 if (ret < 0) {
 184                         em28xx_warn("writing to i2c device at 0x%x failed (error=%i)\n",
 185                                     addr, ret);
 186                         return ret;
 187                 } else {
 188                         em28xx_warn("%i bytes write to i2c device at 0x%x requested, but %i bytes written\n",
 189                                     len, addr, ret);
 190                         return -EIO;
 191                 }
 192         }
 193
 194         /* Check success of the i2c operation */
 195         for (write_timeout = EM2800_I2C_XFER_TIMEOUT; write_timeout > 0;
 196              write_timeout -= 5) {
 197                 ret = dev->em28xx_read_reg(dev, 0x05);
 198                 if (ret == 0) { /* success */
 199                         return len;
 200                 } else if (ret == 0x10) {
 201                         return -ENODEV;
 202                 } else if (ret < 0) {
 203                         em28xx_warn("failed to read i2c transfer status from bridge (error=%i)\n",
 204                                     ret);
 205                         return ret;
 206                 }
 207                 msleep(5);
 208                 /*
 209                  * NOTE: do we really have to wait for success ?
 210                  * Never seen anything else than 0x00 or 0x10
 211                  * (even with high payload) ...
 212                  */
 213         }
 214         em28xx_warn("write to i2c device at 0x%x timed out\n", addr);
 215         return -EIO;
 216 }
 217
 218 /*
 219  * em28xx_i2c_recv_bytes()
 220  * read a byte from the i2c device
 221  */
 222 static int em28xx_i2c_recv_bytes(struct em28xx *dev, u16 addr, u8 *buf, u16 len)
 223 {
 224         int ret;
 225
 226         if (len < 1 || len > 64)
 227                 return -EOPNOTSUPP;
 228         /*
 229          * NOTE: limited by the USB ctrl message constraints
 230          * Zero length reads always succeed, even if no device is connected
 231          */
 232
 233         /* Read data from i2c device */
 234         ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
 235         if (ret < 0) {
 236                 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)\n",
 237                             addr, ret);
 238                 return ret;
 239         }
 240         /*
 241          * NOTE: some devices with two i2c busses have the bad habit to return 0
 242          * bytes if we are on bus B AND there was no write attempt to the
 243          * specified slave address before AND no device is present at the
 244          * requested slave address.
 245          * Anyway, the next check will fail with -ENODEV in this case, so avoid
 246          * spamming the system log on device probing and do nothing here.
 247          */
 248
 249         /* Check success of the i2c operation */
 250         ret = dev->em28xx_read_reg(dev, 0x05);
 251         if (ret < 0) {
 252                 em28xx_warn("failed to read i2c transfer status from bridge (error=%i)\n",
 253                             ret);
 254                 return ret;
 255         }
 256         if (ret > 0) {
 257                 if (ret == 0x10) {
 258                         return -ENODEV;
 259                 } else {
 260                         em28xx_warn("unknown i2c error (status=%i)\n", ret);
 261                         return -EIO;
 262                 }
 263         }
 264         return len;
 265 }
 266
 267 /*
 268  * em28xx_i2c_check_for_device()
 269  * check if there is a i2c_device at the supplied address
 270  */
 271 static int em28xx_i2c_check_for_device(struct em28xx *dev, u16 addr)
 272 {
 273         int ret;
 274         u8 buf;
 275
 276         ret = em28xx_i2c_recv_bytes(dev, addr, &buf, 1);
 277         if (ret == 1)
 278                 return 0;
 279         return (ret < 0) ? ret : -EIO;
 280 }
 281
 282 /*
 283  * em25xx_bus_B_send_bytes
 284  * write bytes to the i2c device
 285  */
 286 static int em25xx_bus_B_send_bytes(struct em28xx *dev, u16 addr, u8 *buf,
 287                                    u16 len)
 288 {
 289         int ret;
 290
 291         if (len < 1 || len > 64)
 292                 return -EOPNOTSUPP;
 293         /*
 294          * NOTE: limited by the USB ctrl message constraints
 295          * Zero length reads always succeed, even if no device is connected
 296          */
 297
 298         /* Set register and write value */
 299         ret = dev->em28xx_write_regs_req(dev, 0x06, addr, buf, len);
 300         if (ret != len) {
 301                 if (ret < 0) {
 302                         em28xx_warn("writing to i2c device at 0x%x failed (error=%i)\n",
 303                                     addr, ret);
 304                         return ret;
 305                 } else {
 306                         em28xx_warn("%i bytes write to i2c device at 0x%x requested, but %i bytes written\n",
 307                                     len, addr, ret);
 308                         return -EIO;
 309                 }
 310         }
 311         /* Check success */
 312         ret = dev->em28xx_read_reg_req(dev, 0x08, 0x0000);
 313         /*
 314          * NOTE: the only error we've seen so far is
 315          * 0x01 when the slave device is not present
 316          */
 317         if (!ret)
 318                 return len;
 319         else if (ret > 0)
 320                 return -ENODEV;
 321
 322         return ret;
 323         /*
 324          * NOTE: With chip types (other chip IDs) which actually don't support
 325          * this operation, it seems to succeed ALWAYS ! (even if there is no
 326          * slave device or even no second i2c bus provided)
 327          */
 328 }
 329
 330 /*
 331  * em25xx_bus_B_recv_bytes
 332  * read bytes from the i2c device
 333  */
 334 static int em25xx_bus_B_recv_bytes(struct em28xx *dev, u16 addr, u8 *buf,
 335                                    u16 len)
 336 {
 337         int ret;
 338
 339         if (len < 1 || len > 64)
 340                 return -EOPNOTSUPP;
 341         /*
 342          * NOTE: limited by the USB ctrl message constraints
 343          * Zero length reads always succeed, even if no device is connected
 344          */
 345
 346         /* Read value */
 347         ret = dev->em28xx_read_reg_req_len(dev, 0x06, addr, buf, len);
 348         if (ret < 0) {
 349                 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)\n",
 350                             addr, ret);
 351                 return ret;
 352         }
 353         /*
 354          * NOTE: some devices with two i2c busses have the bad habit to return 0
 355          * bytes if we are on bus B AND there was no write attempt to the
 356          * specified slave address before AND no device is present at the
 357          * requested slave address.
 358          * Anyway, the next check will fail with -ENODEV in this case, so avoid
 359          * spamming the system log on device probing and do nothing here.
 360          */
 361
 362         /* Check success */
 363         ret = dev->em28xx_read_reg_req(dev, 0x08, 0x0000);
 364         /*
 365          * NOTE: the only error we've seen so far is
 366          * 0x01 when the slave device is not present
 367          */
 368         if (!ret)
 369                 return len;
 370         else if (ret > 0)
 371                 return -ENODEV;
 372
 373         return ret;
 374         /*
 375          * NOTE: With chip types (other chip IDs) which actually don't support
 376          * this operation, it seems to succeed ALWAYS ! (even if there is no
 377          * slave device or even no second i2c bus provided)
 378          */
 379 }
 380
 381 /*
 382  * em25xx_bus_B_check_for_device()
 383  * check if there is a i2c device at the supplied address
 384  */
 385 static int em25xx_bus_B_check_for_device(struct em28xx *dev, u16 addr)
 386 {
 387         u8 buf;
 388         int ret;
 389
 390         ret = em25xx_bus_B_recv_bytes(dev, addr, &buf, 1);
 391         if (ret < 0)
 392                 return ret;
 393
 394         return 0;
 395         /*
 396          * NOTE: With chips which do not support this operation,
 397          * it seems to succeed ALWAYS ! (even if no device connected)
 398          */
 399 }
 400
 401 static inline int i2c_check_for_device(struct em28xx_i2c_bus *i2c_bus, u16 addr)
 402 {
 403         struct em28xx *dev = i2c_bus->dev;
 404         int rc = -EOPNOTSUPP;
 405
 406         if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX)
 407                 rc = em28xx_i2c_check_for_device(dev, addr);
 408         else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800)
 409                 rc = em2800_i2c_check_for_device(dev, addr);
 410         else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)
 411                 rc = em25xx_bus_B_check_for_device(dev, addr);
 412         if (rc == -ENODEV) {
 413                 if (i2c_debug)
 414                         printk(" no device\n");
 415         }
 416         return rc;
 417 }
 418
 419 static inline int i2c_recv_bytes(struct em28xx_i2c_bus *i2c_bus,
 420                                  struct i2c_msg msg)
 421 {
 422         struct em28xx *dev = i2c_bus->dev;
 423         u16 addr = msg.addr << 1;
 424         int byte, rc = -EOPNOTSUPP;
 425
 426         if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX)
 427                 rc = em28xx_i2c_recv_bytes(dev, addr, msg.buf, msg.len);
 428         else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800)
 429                 rc = em2800_i2c_recv_bytes(dev, addr, msg.buf, msg.len);
 430         else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)
 431                 rc = em25xx_bus_B_recv_bytes(dev, addr, msg.buf, msg.len);
 432         if (i2c_debug) {
 433                 for (byte = 0; byte < msg.len; byte++)
 434                         printk(" %02x", msg.buf[byte]);
 435         }
 436         return rc;
 437 }
 438
 439 static inline int i2c_send_bytes(struct em28xx_i2c_bus *i2c_bus,
 440                                  struct i2c_msg msg, int stop)
 441 {
 442         struct em28xx *dev = i2c_bus->dev;
 443         u16 addr = msg.addr << 1;
 444         int byte, rc = -EOPNOTSUPP;
 445
 446         if (i2c_debug) {
 447                 for (byte = 0; byte < msg.len; byte++)
 448                         printk(" %02x", msg.buf[byte]);
 449         }
 450         if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX)
 451                 rc = em28xx_i2c_send_bytes(dev, addr, msg.buf, msg.len, stop);
 452         else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800)
 453                 rc = em2800_i2c_send_bytes(dev, addr, msg.buf, msg.len);
 454         else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)
 455                 rc = em25xx_bus_B_send_bytes(dev, addr, msg.buf, msg.len);
 456         return rc;
 457 }
 458
 459 /*
 460  * em28xx_i2c_xfer()
 461  * the main i2c transfer function
 462  */
 463 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
 464                            struct i2c_msg msgs[], int num)
 465 {
 466         struct em28xx_i2c_bus *i2c_bus = i2c_adap->algo_data;
 467         struct em28xx *dev = i2c_bus->dev;
 468         unsigned bus = i2c_bus->bus;
 469         int addr, rc, i;
 470         u8 reg;
 471
 472         rc = rt_mutex_trylock(&dev->i2c_bus_lock);
 473         if (rc < 0)
 474                 return rc;
 475
 476         /* Switch I2C bus if needed */
 477         if (bus != dev->cur_i2c_bus &&
 478             i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX) {
 479                 if (bus == 1)
 480                         reg = EM2874_I2C_SECONDARY_BUS_SELECT;
 481                 else
 482                         reg = 0;
 483                 em28xx_write_reg_bits(dev, EM28XX_R06_I2C_CLK, reg,
 484                                       EM2874_I2C_SECONDARY_BUS_SELECT);
 485                 dev->cur_i2c_bus = bus;
 486         }
 487
 488         if (num <= 0) {
 489                 rt_mutex_unlock(&dev->i2c_bus_lock);
 490                 return 0;
 491         }
 492         for (i = 0; i < num; i++) {
 493                 addr = msgs[i].addr << 1;
 494                 if (i2c_debug)
 495                         printk(KERN_DEBUG "%s at %s: %s %s addr=%02x len=%d:",
 496                                dev->name, __func__ ,
 497                                (msgs[i].flags & I2C_M_RD) ? "read" : "write",
 498                                i == num - 1 ? "stop" : "nonstop",
 499                                addr, msgs[i].len);
 500                 if (!msgs[i].len) { /* no len: check only for device presence */
 501                         rc = i2c_check_for_device(i2c_bus, addr);
 502                         if (rc == -ENODEV) {
 503                                 rt_mutex_unlock(&dev->i2c_bus_lock);
 504                                 return rc;
 505                         }
 506                 } else if (msgs[i].flags & I2C_M_RD) {
 507                         /* read bytes */
 508                         rc = i2c_recv_bytes(i2c_bus, msgs[i]);
 509                 } else {
 510                         /* write bytes */
 511                         rc = i2c_send_bytes(i2c_bus, msgs[i], i == num - 1);
 512                 }
 513                 if (rc < 0) {
 514                         if (i2c_debug)
 515                                 printk(" ERROR: %i\n", rc);
 516                         rt_mutex_unlock(&dev->i2c_bus_lock);
 517                         return rc;
 518                 }
 519                 if (i2c_debug)
 520                         printk("\n");
 521         }
 522
 523         rt_mutex_unlock(&dev->i2c_bus_lock);
 524         return num;
 525 }
 526
 527 /*
 528  * based on linux/sunrpc/svcauth.h and linux/hash.h
 529  * The original hash function returns a different value, if arch is x86_64
 530  * or i386.
 531  */
 532 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
 533 {
 534         unsigned long hash = 0;
 535         unsigned long l = 0;
 536         int len = 0;
 537         unsigned char c;
 538         do {
 539                 if (len == length) {
 540                         c = (char)len;
 541                         len = -1;
 542                 } else
 543                         c = *buf++;
 544                 l = (l << 8) | c;
 545                 len++;
 546                 if ((len & (32 / 8 - 1)) == 0)
 547                         hash = ((hash^l) * 0x9e370001UL);
 548         } while (len);
 549
 550         return (hash >> (32 - bits)) & 0xffffffffUL;
 551 }
 552
 553 /*
 554  * Helper function to read data blocks from i2c clients with 8 or 16 bit
 555  * address width, 8 bit register width and auto incrementation been activated
 556  */
 557 static int em28xx_i2c_read_block(struct em28xx *dev, unsigned bus, u16 addr,
 558                                  bool addr_w16, u16 len, u8 *data)
 559 {
 560         int remain = len, rsize, rsize_max, ret;
 561         u8 buf[2];
 562
 563         /* Sanity check */
 564         if (addr + remain > (addr_w16 * 0xff00 + 0xff + 1))
 565                 return -EINVAL;
 566         /* Select address */
 567         buf[0] = addr >> 8;
 568         buf[1] = addr & 0xff;
 569         ret = i2c_master_send(&dev->i2c_client[bus], buf + !addr_w16, 1 + addr_w16);
 570         if (ret < 0)
 571                 return ret;
 572         /* Read data */
 573         if (dev->board.is_em2800)
 574                 rsize_max = 4;
 575         else
 576                 rsize_max = 64;
 577         while (remain > 0) {
 578                 if (remain > rsize_max)
 579                         rsize = rsize_max;
 580                 else
 581                         rsize = remain;
 582
 583                 ret = i2c_master_recv(&dev->i2c_client[bus], data, rsize);
 584                 if (ret < 0)
 585                         return ret;
 586
 587                 remain -= rsize;
 588                 data += rsize;
 589         }
 590
 591         return len;
 592 }
 593
 594 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned bus,
 595                              u8 **eedata, u16 *eedata_len)
 596 {
 597         const u16 len = 256;
 598         /*
 599          * FIXME common length/size for bytes to read, to display, hash
 600          * calculation and returned device dataset. Simplifies the code a lot,
 601          * but we might have to deal with multiple sizes in the future !
 602          */
 603         int i, err;
 604         struct em28xx_eeprom *dev_config;
 605         u8 buf, *data;
 606
 607         *eedata = NULL;
 608         *eedata_len = 0;
 609
 610         /* EEPROM is always on i2c bus 0 on all known devices. */
 611
 612         dev->i2c_client[bus].addr = 0xa0 >> 1;
 613
 614         /* Check if board has eeprom */
 615         err = i2c_master_recv(&dev->i2c_client[bus], &buf, 0);
 616         if (err < 0) {
 617                 em28xx_info("board has no eeprom\n");
 618                 return -ENODEV;
 619         }
 620
 621         data = kzalloc(len, GFP_KERNEL);
 622         if (data == NULL)
 623                 return -ENOMEM;
 624
 625         /* Read EEPROM content */
 626         err = em28xx_i2c_read_block(dev, bus, 0x0000,
 627                                     dev->eeprom_addrwidth_16bit,
 628                                     len, data);
 629         if (err != len) {
 630                 em28xx_errdev("failed to read eeprom (err=%d)\n", err);
 631                 goto error;
 632         }
 633
 634         /* Display eeprom content */
 635         for (i = 0; i < len; i++) {
 636                 if (0 == (i % 16)) {
 637                         if (dev->eeprom_addrwidth_16bit)
 638                                 em28xx_info("i2c eeprom %04x:", i);
 639                         else
 640                                 em28xx_info("i2c eeprom %02x:", i);
 641                 }
 642                 printk(" %02x", data[i]);
 643                 if (15 == (i % 16))
 644                         printk("\n");
 645         }
 646         if (dev->eeprom_addrwidth_16bit)
 647                 em28xx_info("i2c eeprom %04x: ... (skipped)\n", i);
 648
 649         if (dev->eeprom_addrwidth_16bit &&
 650             data[0] == 0x26 && data[3] == 0x00) {
 651                 /* new eeprom format; size 4-64kb */
 652                 u16 mc_start;
 653                 u16 hwconf_offset;
 654
 655                 dev->hash = em28xx_hash_mem(data, len, 32);
 656                 mc_start = (data[1] << 8) + 4;  /* usually 0x0004 */
 657
 658                 em28xx_info("EEPROM ID = %02x %02x %02x %02x, EEPROM hash = 0x%08lx\n",
 659                             data[0], data[1], data[2], data[3], dev->hash);
 660                 em28xx_info("EEPROM info:\n");
 661                 em28xx_info("\tmicrocode start address = 0x%04x, boot configuration = 0x%02x\n",
 662                             mc_start, data[2]);
 663                 /*
 664                  * boot configuration (address 0x0002):
 665                  * [0]   microcode download speed: 1 = 400 kHz; 0 = 100 kHz
 666                  * [1]   always selects 12 kb RAM
 667                  * [2]   USB device speed: 1 = force Full Speed; 0 = auto detect
 668                  * [4]   1 = force fast mode and no suspend for device testing
 669                  * [5:7] USB PHY tuning registers; determined by device
 670                  *       characterization
 671                  */
 672
 673                 /*
 674                  * Read hardware config dataset offset from address
 675                  * (microcode start + 46)
 676                  */
 677                 err = em28xx_i2c_read_block(dev, bus, mc_start + 46, 1, 2,
 678                                             data);
 679                 if (err != 2) {
 680                         em28xx_errdev("failed to read hardware configuration data from eeprom (err=%d)\n",
 681                                       err);
 682                         goto error;
 683                 }
 684
 685                 /* Calculate hardware config dataset start address */
 686                 hwconf_offset = mc_start + data[0] + (data[1] << 8);
 687
 688                 /* Read hardware config dataset */
 689                 /*
 690                  * NOTE: the microcode copy can be multiple pages long, but
 691                  * we assume the hardware config dataset is the same as in
 692                  * the old eeprom and not longer than 256 bytes.
 693                  * tveeprom is currently also limited to 256 bytes.
 694                  */
 695                 err = em28xx_i2c_read_block(dev, bus, hwconf_offset, 1, len,
 696                                             data);
 697                 if (err != len) {
 698                         em28xx_errdev("failed to read hardware configuration data from eeprom (err=%d)\n",
 699                                       err);
 700                         goto error;
 701                 }
 702
 703                 /* Verify hardware config dataset */
 704                 /* NOTE: not all devices provide this type of dataset */
 705                 if (data[0] != 0x1a || data[1] != 0xeb ||
 706                     data[2] != 0x67 || data[3] != 0x95) {
 707                         em28xx_info("\tno hardware configuration dataset found in eeprom\n");
 708                         kfree(data);
 709                         return 0;
 710                 }
 711
 712                 /* TODO: decrypt eeprom data for camera bridges (em25xx, em276x+) */
 713
 714         } else if (!dev->eeprom_addrwidth_16bit &&
 715                    data[0] == 0x1a && data[1] == 0xeb &&
 716                    data[2] == 0x67 && data[3] == 0x95) {
 717                 dev->hash = em28xx_hash_mem(data, len, 32);
 718                 em28xx_info("EEPROM ID = %02x %02x %02x %02x, EEPROM hash = 0x%08lx\n",
 719                             data[0], data[1], data[2], data[3], dev->hash);
 720                 em28xx_info("EEPROM info:\n");
 721         } else {
 722                 em28xx_info("unknown eeprom format or eeprom corrupted !\n");
 723                 err = -ENODEV;
 724                 goto error;
 725         }
 726
 727         *eedata = data;
 728         *eedata_len = len;
 729         dev_config = (void *)*eedata;
 730
 731         switch (le16_to_cpu(dev_config->chip_conf) >> 4 & 0x3) {
 732         case 0:
 733                 em28xx_info("\tNo audio on board.\n");
 734                 break;
 735         case 1:
 736                 em28xx_info("\tAC97 audio (5 sample rates)\n");
 737                 break;
 738         case 2:
 739                 em28xx_info("\tI2S audio, sample rate=32k\n");
 740                 break;
 741         case 3:
 742                 em28xx_info("\tI2S audio, 3 sample rates\n");
 743                 break;
 744         }
 745
 746         if (le16_to_cpu(dev_config->chip_conf) & 1 << 3)
 747                 em28xx_info("\tUSB Remote wakeup capable\n");
 748
 749         if (le16_to_cpu(dev_config->chip_conf) & 1 << 2)
 750                 em28xx_info("\tUSB Self power capable\n");
 751
 752         switch (le16_to_cpu(dev_config->chip_conf) & 0x3) {
 753         case 0:
 754                 em28xx_info("\t500mA max power\n");
 755                 break;
 756         case 1:
 757                 em28xx_info("\t400mA max power\n");
 758                 break;
 759         case 2:
 760                 em28xx_info("\t300mA max power\n");
 761                 break;
 762         case 3:
 763                 em28xx_info("\t200mA max power\n");
 764                 break;
 765         }
 766         em28xx_info("\tTable at offset 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
 767                     dev_config->string_idx_table,
 768                     le16_to_cpu(dev_config->string1),
 769                     le16_to_cpu(dev_config->string2),
 770                     le16_to_cpu(dev_config->string3));
 771
 772         return 0;
 773
 774 error:
 775         kfree(data);
 776         return err;
 777 }
 778
 779 /* ----------------------------------------------------------- */
 780
 781 /*
 782  * functionality()
 783  */
 784 static u32 functionality(struct i2c_adapter *i2c_adap)
 785 {
 786         struct em28xx_i2c_bus *i2c_bus = i2c_adap->algo_data;
 787
 788         if ((i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX) ||
 789             (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)) {
 790                 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 791         } else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800)  {
 792                 return (I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL) &
 793                         ~I2C_FUNC_SMBUS_WRITE_BLOCK_DATA;
 794         }
 795
 796         WARN(1, "Unknown i2c bus algorithm.\n");
 797         return 0;
 798 }
 799
 800 static struct i2c_algorithm em28xx_algo = {
 801         .master_xfer   = em28xx_i2c_xfer,
 802         .functionality = functionality,
 803 };
 804
 805 static struct i2c_adapter em28xx_adap_template = {
 806         .owner = THIS_MODULE,
 807         .name = "em28xx",
 808         .algo = &em28xx_algo,
 809 };
 810
 811 static struct i2c_client em28xx_client_template = {
 812         .name = "em28xx internal",
 813 };
 814
 815 /* ----------------------------------------------------------- */
 816
 817 /*
 818  * i2c_devs
 819  * incomplete list of known devices
 820  */
 821 static char *i2c_devs[128] = {
 822         [0x3e >> 1] = "remote IR sensor",
 823         [0x4a >> 1] = "saa7113h",
 824         [0x52 >> 1] = "drxk",
 825         [0x60 >> 1] = "remote IR sensor",
 826         [0x8e >> 1] = "remote IR sensor",
 827         [0x86 >> 1] = "tda9887",
 828         [0x80 >> 1] = "msp34xx",
 829         [0x88 >> 1] = "msp34xx",
 830         [0xa0 >> 1] = "eeprom",
 831         [0xb0 >> 1] = "tda9874",
 832         [0xb8 >> 1] = "tvp5150a",
 833         [0xba >> 1] = "webcam sensor or tvp5150a",
 834         [0xc0 >> 1] = "tuner (analog)",
 835         [0xc2 >> 1] = "tuner (analog)",
 836         [0xc4 >> 1] = "tuner (analog)",
 837         [0xc6 >> 1] = "tuner (analog)",
 838 };
 839
 840 /*
 841  * do_i2c_scan()
 842  * check i2c address range for devices
 843  */
 844 void em28xx_do_i2c_scan(struct em28xx *dev, unsigned bus)
 845 {
 846         u8 i2c_devicelist[128];
 847         unsigned char buf;
 848         int i, rc;
 849
 850         memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
 851
 852         for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
 853                 dev->i2c_client[bus].addr = i;
 854                 rc = i2c_master_recv(&dev->i2c_client[bus], &buf, 0);
 855                 if (rc < 0)
 856                         continue;
 857                 i2c_devicelist[i] = i;
 858                 em28xx_info("found i2c device @ 0x%x on bus %d [%s]\n",
 859                             i << 1, bus, i2c_devs[i] ? i2c_devs[i] : "???");
 860         }
 861
 862         if (bus == dev->def_i2c_bus)
 863                 dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
 864                                                 ARRAY_SIZE(i2c_devicelist), 32);
 865 }
 866
 867 /*
 868  * em28xx_i2c_register()
 869  * register i2c bus
 870  */
 871 int em28xx_i2c_register(struct em28xx *dev, unsigned bus,
 872                         enum em28xx_i2c_algo_type algo_type)
 873 {
 874         int retval;
 875
 876         BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
 877         BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
 878
 879         if (bus >= NUM_I2C_BUSES)
 880                 return -ENODEV;
 881
 882         dev->i2c_adap[bus] = em28xx_adap_template;
 883         dev->i2c_adap[bus].dev.parent = &dev->udev->dev;
 884         strcpy(dev->i2c_adap[bus].name, dev->name);
 885
 886         dev->i2c_bus[bus].bus = bus;
 887         dev->i2c_bus[bus].algo_type = algo_type;
 888         dev->i2c_bus[bus].dev = dev;
 889         dev->i2c_adap[bus].algo_data = &dev->i2c_bus[bus];
 890         i2c_set_adapdata(&dev->i2c_adap[bus], &dev->v4l2_dev);
 891
 892         retval = i2c_add_adapter(&dev->i2c_adap[bus]);
 893         if (retval < 0) {
 894                 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
 895                         __func__, retval);
 896                 return retval;
 897         }
 898
 899         dev->i2c_client[bus] = em28xx_client_template;
 900         dev->i2c_client[bus].adapter = &dev->i2c_adap[bus];
 901
 902         /* Up to now, all eeproms are at bus 0 */
 903         if (!bus) {
 904                 retval = em28xx_i2c_eeprom(dev, bus, &dev->eedata, &dev->eedata_len);
 905                 if ((retval < 0) && (retval != -ENODEV)) {
 906                         em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
 907                                 __func__, retval);
 908
 909                         return retval;
 910                 }
 911         }
 912
 913         if (i2c_scan)
 914                 em28xx_do_i2c_scan(dev, bus);
 915
 916         return 0;
 917 }
 918
 919 /*
 920  * em28xx_i2c_unregister()
 921  * unregister i2c_bus
 922  */
 923 int em28xx_i2c_unregister(struct em28xx *dev, unsigned bus)
 924 {
 925         if (bus >= NUM_I2C_BUSES)
 926                 return -ENODEV;
 927
 928         i2c_del_adapter(&dev->i2c_adap[bus]);
 929         return 0;
 930 }