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