drivers/media/usb/em28xx/em28xx-i2c.c

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