kernel/drivers/media/usb/pvrusb2/pvrusb2-i2c-core.c

   1 /*
   2  *
   3  *
   4  *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include <linux/i2c.h>
  22 #include <linux/module.h>
  23 #include <media/ir-kbd-i2c.h>
  24 #include "pvrusb2-i2c-core.h"
  25 #include "pvrusb2-hdw-internal.h"
  26 #include "pvrusb2-debug.h"
  27 #include "pvrusb2-fx2-cmd.h"
  28 #include "pvrusb2.h"
  29
  30 #define trace_i2c(...) pvr2_trace(PVR2_TRACE_I2C,__VA_ARGS__)
  31
  32 /*
  33
  34   This module attempts to implement a compliant I2C adapter for the pvrusb2
  35   device.
  36
  37 */
  38
  39 static unsigned int i2c_scan;
  40 module_param(i2c_scan, int, S_IRUGO|S_IWUSR);
  41 MODULE_PARM_DESC(i2c_scan,"scan i2c bus at insmod time");
  42
  43 static int ir_mode[PVR_NUM] = { [0 ... PVR_NUM-1] = 1 };
  44 module_param_array(ir_mode, int, NULL, 0444);
  45 MODULE_PARM_DESC(ir_mode,"specify: 0=disable IR reception, 1=normal IR");
  46
  47 static int pvr2_disable_ir_video;
  48 module_param_named(disable_autoload_ir_video, pvr2_disable_ir_video,
  49                    int, S_IRUGO|S_IWUSR);
  50 MODULE_PARM_DESC(disable_autoload_ir_video,
  51                  "1=do not try to autoload ir_video IR receiver");
  52
  53 static int pvr2_i2c_write(struct pvr2_hdw *hdw, /* Context */
  54                           u8 i2c_addr,      /* I2C address we're talking to */
  55                           u8 *data,         /* Data to write */
  56                           u16 length)       /* Size of data to write */
  57 {
  58         /* Return value - default 0 means success */
  59         int ret;
  60
  61
  62         if (!data) length = 0;
  63         if (length > (sizeof(hdw->cmd_buffer) - 3)) {
  64                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
  65                            "Killing an I2C write to %u that is too large"
  66                            " (desired=%u limit=%u)",
  67                            i2c_addr,
  68                            length,(unsigned int)(sizeof(hdw->cmd_buffer) - 3));
  69                 return -ENOTSUPP;
  70         }
  71
  72         LOCK_TAKE(hdw->ctl_lock);
  73
  74         /* Clear the command buffer (likely to be paranoia) */
  75         memset(hdw->cmd_buffer, 0, sizeof(hdw->cmd_buffer));
  76
  77         /* Set up command buffer for an I2C write */
  78         hdw->cmd_buffer[0] = FX2CMD_I2C_WRITE;      /* write prefix */
  79         hdw->cmd_buffer[1] = i2c_addr;  /* i2c addr of chip */
  80         hdw->cmd_buffer[2] = length;    /* length of what follows */
  81         if (length) memcpy(hdw->cmd_buffer + 3, data, length);
  82
  83         /* Do the operation */
  84         ret = pvr2_send_request(hdw,
  85                                 hdw->cmd_buffer,
  86                                 length + 3,
  87                                 hdw->cmd_buffer,
  88                                 1);
  89         if (!ret) {
  90                 if (hdw->cmd_buffer[0] != 8) {
  91                         ret = -EIO;
  92                         if (hdw->cmd_buffer[0] != 7) {
  93                                 trace_i2c("unexpected status"
  94                                           " from i2_write[%d]: %d",
  95                                           i2c_addr,hdw->cmd_buffer[0]);
  96                         }
  97                 }
  98         }
  99
 100         LOCK_GIVE(hdw->ctl_lock);
 101
 102         return ret;
 103 }
 104
 105 static int pvr2_i2c_read(struct pvr2_hdw *hdw, /* Context */
 106                          u8 i2c_addr,       /* I2C address we're talking to */
 107                          u8 *data,          /* Data to write */
 108                          u16 dlen,          /* Size of data to write */
 109                          u8 *res,           /* Where to put data we read */
 110                          u16 rlen)          /* Amount of data to read */
 111 {
 112         /* Return value - default 0 means success */
 113         int ret;
 114
 115
 116         if (!data) dlen = 0;
 117         if (dlen > (sizeof(hdw->cmd_buffer) - 4)) {
 118                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 119                            "Killing an I2C read to %u that has wlen too large"
 120                            " (desired=%u limit=%u)",
 121                            i2c_addr,
 122                            dlen,(unsigned int)(sizeof(hdw->cmd_buffer) - 4));
 123                 return -ENOTSUPP;
 124         }
 125         if (res && (rlen > (sizeof(hdw->cmd_buffer) - 1))) {
 126                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 127                            "Killing an I2C read to %u that has rlen too large"
 128                            " (desired=%u limit=%u)",
 129                            i2c_addr,
 130                            rlen,(unsigned int)(sizeof(hdw->cmd_buffer) - 1));
 131                 return -ENOTSUPP;
 132         }
 133
 134         LOCK_TAKE(hdw->ctl_lock);
 135
 136         /* Clear the command buffer (likely to be paranoia) */
 137         memset(hdw->cmd_buffer, 0, sizeof(hdw->cmd_buffer));
 138
 139         /* Set up command buffer for an I2C write followed by a read */
 140         hdw->cmd_buffer[0] = FX2CMD_I2C_READ;  /* read prefix */
 141         hdw->cmd_buffer[1] = dlen;  /* arg length */
 142         hdw->cmd_buffer[2] = rlen;  /* answer length. Device will send one
 143                                        more byte (status). */
 144         hdw->cmd_buffer[3] = i2c_addr;  /* i2c addr of chip */
 145         if (dlen) memcpy(hdw->cmd_buffer + 4, data, dlen);
 146
 147         /* Do the operation */
 148         ret = pvr2_send_request(hdw,
 149                                 hdw->cmd_buffer,
 150                                 4 + dlen,
 151                                 hdw->cmd_buffer,
 152                                 rlen + 1);
 153         if (!ret) {
 154                 if (hdw->cmd_buffer[0] != 8) {
 155                         ret = -EIO;
 156                         if (hdw->cmd_buffer[0] != 7) {
 157                                 trace_i2c("unexpected status"
 158                                           " from i2_read[%d]: %d",
 159                                           i2c_addr,hdw->cmd_buffer[0]);
 160                         }
 161                 }
 162         }
 163
 164         /* Copy back the result */
 165         if (res && rlen) {
 166                 if (ret) {
 167                         /* Error, just blank out the return buffer */
 168                         memset(res, 0, rlen);
 169                 } else {
 170                         memcpy(res, hdw->cmd_buffer + 1, rlen);
 171                 }
 172         }
 173
 174         LOCK_GIVE(hdw->ctl_lock);
 175
 176         return ret;
 177 }
 178
 179 /* This is the common low level entry point for doing I2C operations to the
 180    hardware. */
 181 static int pvr2_i2c_basic_op(struct pvr2_hdw *hdw,
 182                              u8 i2c_addr,
 183                              u8 *wdata,
 184                              u16 wlen,
 185                              u8 *rdata,
 186                              u16 rlen)
 187 {
 188         if (!rdata) rlen = 0;
 189         if (!wdata) wlen = 0;
 190         if (rlen || !wlen) {
 191                 return pvr2_i2c_read(hdw,i2c_addr,wdata,wlen,rdata,rlen);
 192         } else {
 193                 return pvr2_i2c_write(hdw,i2c_addr,wdata,wlen);
 194         }
 195 }
 196
 197
 198 /* This is a special entry point for cases of I2C transaction attempts to
 199    the IR receiver.  The implementation here simulates the IR receiver by
 200    issuing a command to the FX2 firmware and using that response to return
 201    what the real I2C receiver would have returned.  We use this for 24xxx
 202    devices, where the IR receiver chip has been removed and replaced with
 203    FX2 related logic. */
 204 static int i2c_24xxx_ir(struct pvr2_hdw *hdw,
 205                         u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
 206 {
 207         u8 dat[4];
 208         unsigned int stat;
 209
 210         if (!(rlen || wlen)) {
 211                 /* This is a probe attempt.  Just let it succeed. */
 212                 return 0;
 213         }
 214
 215         /* We don't understand this kind of transaction */
 216         if ((wlen != 0) || (rlen == 0)) return -EIO;
 217
 218         if (rlen < 3) {
 219                 /* Mike Isely <isely@pobox.com> Appears to be a probe
 220                    attempt from lirc.  Just fill in zeroes and return.  If
 221                    we try instead to do the full transaction here, then bad
 222                    things seem to happen within the lirc driver module
 223                    (version 0.8.0-7 sources from Debian, when run under
 224                    vanilla 2.6.17.6 kernel) - and I don't have the patience
 225                    to chase it down. */
 226                 if (rlen > 0) rdata[0] = 0;
 227                 if (rlen > 1) rdata[1] = 0;
 228                 return 0;
 229         }
 230
 231         /* Issue a command to the FX2 to read the IR receiver. */
 232         LOCK_TAKE(hdw->ctl_lock); do {
 233                 hdw->cmd_buffer[0] = FX2CMD_GET_IR_CODE;
 234                 stat = pvr2_send_request(hdw,
 235                                          hdw->cmd_buffer,1,
 236                                          hdw->cmd_buffer,4);
 237                 dat[0] = hdw->cmd_buffer[0];
 238                 dat[1] = hdw->cmd_buffer[1];
 239                 dat[2] = hdw->cmd_buffer[2];
 240                 dat[3] = hdw->cmd_buffer[3];
 241         } while (0); LOCK_GIVE(hdw->ctl_lock);
 242
 243         /* Give up if that operation failed. */
 244         if (stat != 0) return stat;
 245
 246         /* Mangle the results into something that looks like the real IR
 247            receiver. */
 248         rdata[2] = 0xc1;
 249         if (dat[0] != 1) {
 250                 /* No code received. */
 251                 rdata[0] = 0;
 252                 rdata[1] = 0;
 253         } else {
 254                 u16 val;
 255                 /* Mash the FX2 firmware-provided IR code into something
 256                    that the normal i2c chip-level driver expects. */
 257                 val = dat[1];
 258                 val <<= 8;
 259                 val |= dat[2];
 260                 val >>= 1;
 261                 val &= ~0x0003;
 262                 val |= 0x8000;
 263                 rdata[0] = (val >> 8) & 0xffu;
 264                 rdata[1] = val & 0xffu;
 265         }
 266
 267         return 0;
 268 }
 269
 270 /* This is a special entry point that is entered if an I2C operation is
 271    attempted to a wm8775 chip on model 24xxx hardware.  Autodetect of this
 272    part doesn't work, but we know it is really there.  So let's look for
 273    the autodetect attempt and just return success if we see that. */
 274 static int i2c_hack_wm8775(struct pvr2_hdw *hdw,
 275                            u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
 276 {
 277         if (!(rlen || wlen)) {
 278                 // This is a probe attempt.  Just let it succeed.
 279                 return 0;
 280         }
 281         return pvr2_i2c_basic_op(hdw,i2c_addr,wdata,wlen,rdata,rlen);
 282 }
 283
 284 /* This is an entry point designed to always fail any attempt to perform a
 285    transfer.  We use this to cause certain I2C addresses to not be
 286    probed. */
 287 static int i2c_black_hole(struct pvr2_hdw *hdw,
 288                            u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
 289 {
 290         return -EIO;
 291 }
 292
 293 /* This is a special entry point that is entered if an I2C operation is
 294    attempted to a cx25840 chip on model 24xxx hardware.  This chip can
 295    sometimes wedge itself.  Worse still, when this happens msp3400 can
 296    falsely detect this part and then the system gets hosed up after msp3400
 297    gets confused and dies.  What we want to do here is try to keep msp3400
 298    away and also try to notice if the chip is wedged and send a warning to
 299    the system log. */
 300 static int i2c_hack_cx25840(struct pvr2_hdw *hdw,
 301                             u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
 302 {
 303         int ret;
 304         unsigned int subaddr;
 305         u8 wbuf[2];
 306         int state = hdw->i2c_cx25840_hack_state;
 307
 308         if (!(rlen || wlen)) {
 309                 // Probe attempt - always just succeed and don't bother the
 310                 // hardware (this helps to make the state machine further
 311                 // down somewhat easier).
 312                 return 0;
 313         }
 314
 315         if (state == 3) {
 316                 return pvr2_i2c_basic_op(hdw,i2c_addr,wdata,wlen,rdata,rlen);
 317         }
 318
 319         /* We're looking for the exact pattern where the revision register
 320            is being read.  The cx25840 module will always look at the
 321            revision register first.  Any other pattern of access therefore
 322            has to be a probe attempt from somebody else so we'll reject it.
 323            Normally we could just let each client just probe the part
 324            anyway, but when the cx25840 is wedged, msp3400 will get a false
 325            positive and that just screws things up... */
 326
 327         if (wlen == 0) {
 328                 switch (state) {
 329                 case 1: subaddr = 0x0100; break;
 330                 case 2: subaddr = 0x0101; break;
 331                 default: goto fail;
 332                 }
 333         } else if (wlen == 2) {
 334                 subaddr = (wdata[0] << 8) | wdata[1];
 335                 switch (subaddr) {
 336                 case 0x0100: state = 1; break;
 337                 case 0x0101: state = 2; break;
 338                 default: goto fail;
 339                 }
 340         } else {
 341                 goto fail;
 342         }
 343         if (!rlen) goto success;
 344         state = 0;
 345         if (rlen != 1) goto fail;
 346
 347         /* If we get to here then we have a legitimate read for one of the
 348            two revision bytes, so pass it through. */
 349         wbuf[0] = subaddr >> 8;
 350         wbuf[1] = subaddr;
 351         ret = pvr2_i2c_basic_op(hdw,i2c_addr,wbuf,2,rdata,rlen);
 352
 353         if ((ret != 0) || (*rdata == 0x04) || (*rdata == 0x0a)) {
 354                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 355                            "WARNING: Detected a wedged cx25840 chip;"
 356                            " the device will not work.");
 357                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 358                            "WARNING: Try power cycling the pvrusb2 device.");
 359                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 360                            "WARNING: Disabling further access to the device"
 361                            " to prevent other foul-ups.");
 362                 // This blocks all further communication with the part.
 363                 hdw->i2c_func[0x44] = NULL;
 364                 pvr2_hdw_render_useless(hdw);
 365                 goto fail;
 366         }
 367
 368         /* Success! */
 369         pvr2_trace(PVR2_TRACE_CHIPS,"cx25840 appears to be OK.");
 370         state = 3;
 371
 372  success:
 373         hdw->i2c_cx25840_hack_state = state;
 374         return 0;
 375
 376  fail:
 377         hdw->i2c_cx25840_hack_state = state;
 378         return -EIO;
 379 }
 380
 381 /* This is a very, very limited I2C adapter implementation.  We can only
 382    support what we actually know will work on the device... */
 383 static int pvr2_i2c_xfer(struct i2c_adapter *i2c_adap,
 384                          struct i2c_msg msgs[],
 385                          int num)
 386 {
 387         int ret = -ENOTSUPP;
 388         pvr2_i2c_func funcp = NULL;
 389         struct pvr2_hdw *hdw = (struct pvr2_hdw *)(i2c_adap->algo_data);
 390
 391         if (!num) {
 392                 ret = -EINVAL;
 393                 goto done;
 394         }
 395         if (msgs[0].addr < PVR2_I2C_FUNC_CNT) {
 396                 funcp = hdw->i2c_func[msgs[0].addr];
 397         }
 398         if (!funcp) {
 399                 ret = -EIO;
 400                 goto done;
 401         }
 402
 403         if (num == 1) {
 404                 if (msgs[0].flags & I2C_M_RD) {
 405                         /* Simple read */
 406                         u16 tcnt,bcnt,offs;
 407                         if (!msgs[0].len) {
 408                                 /* Length == 0 read.  This is a probe. */
 409                                 if (funcp(hdw,msgs[0].addr,NULL,0,NULL,0)) {
 410                                         ret = -EIO;
 411                                         goto done;
 412                                 }
 413                                 ret = 1;
 414                                 goto done;
 415                         }
 416                         /* If the read is short enough we'll do the whole
 417                            thing atomically.  Otherwise we have no choice
 418                            but to break apart the reads. */
 419                         tcnt = msgs[0].len;
 420                         offs = 0;
 421                         while (tcnt) {
 422                                 bcnt = tcnt;
 423                                 if (bcnt > sizeof(hdw->cmd_buffer)-1) {
 424                                         bcnt = sizeof(hdw->cmd_buffer)-1;
 425                                 }
 426                                 if (funcp(hdw,msgs[0].addr,NULL,0,
 427                                           msgs[0].buf+offs,bcnt)) {
 428                                         ret = -EIO;
 429                                         goto done;
 430                                 }
 431                                 offs += bcnt;
 432                                 tcnt -= bcnt;
 433                         }
 434                         ret = 1;
 435                         goto done;
 436                 } else {
 437                         /* Simple write */
 438                         ret = 1;
 439                         if (funcp(hdw,msgs[0].addr,
 440                                   msgs[0].buf,msgs[0].len,NULL,0)) {
 441                                 ret = -EIO;
 442                         }
 443                         goto done;
 444                 }
 445         } else if (num == 2) {
 446                 if (msgs[0].addr != msgs[1].addr) {
 447                         trace_i2c("i2c refusing 2 phase transfer with"
 448                                   " conflicting target addresses");
 449                         ret = -ENOTSUPP;
 450                         goto done;
 451                 }
 452                 if ((!((msgs[0].flags & I2C_M_RD))) &&
 453                     (msgs[1].flags & I2C_M_RD)) {
 454                         u16 tcnt,bcnt,wcnt,offs;
 455                         /* Write followed by atomic read.  If the read
 456                            portion is short enough we'll do the whole thing
 457                            atomically.  Otherwise we have no choice but to
 458                            break apart the reads. */
 459                         tcnt = msgs[1].len;
 460                         wcnt = msgs[0].len;
 461                         offs = 0;
 462                         while (tcnt || wcnt) {
 463                                 bcnt = tcnt;
 464                                 if (bcnt > sizeof(hdw->cmd_buffer)-1) {
 465                                         bcnt = sizeof(hdw->cmd_buffer)-1;
 466                                 }
 467                                 if (funcp(hdw,msgs[0].addr,
 468                                           msgs[0].buf,wcnt,
 469                                           msgs[1].buf+offs,bcnt)) {
 470                                         ret = -EIO;
 471                                         goto done;
 472                                 }
 473                                 offs += bcnt;
 474                                 tcnt -= bcnt;
 475                                 wcnt = 0;
 476                         }
 477                         ret = 2;
 478                         goto done;
 479                 } else {
 480                         trace_i2c("i2c refusing complex transfer"
 481                                   " read0=%d read1=%d",
 482                                   (msgs[0].flags & I2C_M_RD),
 483                                   (msgs[1].flags & I2C_M_RD));
 484                 }
 485         } else {
 486                 trace_i2c("i2c refusing %d phase transfer",num);
 487         }
 488
 489  done:
 490         if (pvrusb2_debug & PVR2_TRACE_I2C_TRAF) {
 491                 unsigned int idx,offs,cnt;
 492                 for (idx = 0; idx < num; idx++) {
 493                         cnt = msgs[idx].len;
 494                         printk(KERN_INFO
 495                                "pvrusb2 i2c xfer %u/%u:"
 496                                " addr=0x%x len=%d %s",
 497                                idx+1,num,
 498                                msgs[idx].addr,
 499                                cnt,
 500                                (msgs[idx].flags & I2C_M_RD ?
 501                                 "read" : "write"));
 502                         if ((ret > 0) || !(msgs[idx].flags & I2C_M_RD)) {
 503                                 if (cnt > 8) cnt = 8;
 504                                 printk(" [");
 505                                 for (offs = 0; offs < (cnt>8?8:cnt); offs++) {
 506                                         if (offs) printk(" ");
 507                                         printk("%02x",msgs[idx].buf[offs]);
 508                                 }
 509                                 if (offs < cnt) printk(" ...");
 510                                 printk("]");
 511                         }
 512                         if (idx+1 == num) {
 513                                 printk(" result=%d",ret);
 514                         }
 515                         printk("\n");
 516                 }
 517                 if (!num) {
 518                         printk(KERN_INFO
 519                                "pvrusb2 i2c xfer null transfer result=%d\n",
 520                                ret);
 521                 }
 522         }
 523         return ret;
 524 }
 525
 526 static u32 pvr2_i2c_functionality(struct i2c_adapter *adap)
 527 {
 528         return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C;
 529 }
 530
 531 static struct i2c_algorithm pvr2_i2c_algo_template = {
 532         .master_xfer   = pvr2_i2c_xfer,
 533         .functionality = pvr2_i2c_functionality,
 534 };
 535
 536 static struct i2c_adapter pvr2_i2c_adap_template = {
 537         .owner         = THIS_MODULE,
 538         .class         = 0,
 539 };
 540
 541
 542 /* Return true if device exists at given address */
 543 static int do_i2c_probe(struct pvr2_hdw *hdw, int addr)
 544 {
 545         struct i2c_msg msg[1];
 546         int rc;
 547         msg[0].addr = 0;
 548         msg[0].flags = I2C_M_RD;
 549         msg[0].len = 0;
 550         msg[0].buf = NULL;
 551         msg[0].addr = addr;
 552         rc = i2c_transfer(&hdw->i2c_adap, msg, ARRAY_SIZE(msg));
 553         return rc == 1;
 554 }
 555
 556 static void do_i2c_scan(struct pvr2_hdw *hdw)
 557 {
 558         int i;
 559         printk(KERN_INFO "%s: i2c scan beginning\n", hdw->name);
 560         for (i = 0; i < 128; i++) {
 561                 if (do_i2c_probe(hdw, i)) {
 562                         printk(KERN_INFO "%s: i2c scan: found device @ 0x%x\n",
 563                                hdw->name, i);
 564                 }
 565         }
 566         printk(KERN_INFO "%s: i2c scan done.\n", hdw->name);
 567 }
 568
 569 static void pvr2_i2c_register_ir(struct pvr2_hdw *hdw)
 570 {
 571         struct i2c_board_info info;
 572         struct IR_i2c_init_data *init_data = &hdw->ir_init_data;
 573         if (pvr2_disable_ir_video) {
 574                 pvr2_trace(PVR2_TRACE_INFO,
 575                            "Automatic binding of ir_video has been disabled.");
 576                 return;
 577         }
 578         memset(&info, 0, sizeof(struct i2c_board_info));
 579         switch (hdw->ir_scheme_active) {
 580         case PVR2_IR_SCHEME_24XXX: /* FX2-controlled IR */
 581         case PVR2_IR_SCHEME_29XXX: /* Original 29xxx device */
 582                 init_data->ir_codes              = RC_MAP_HAUPPAUGE;
 583                 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP;
 584                 init_data->type                  = RC_BIT_RC5;
 585                 init_data->name                  = hdw->hdw_desc->description;
 586                 init_data->polling_interval      = 100; /* ms From ir-kbd-i2c */
 587                 /* IR Receiver */
 588                 info.addr          = 0x18;
 589                 info.platform_data = init_data;
 590                 strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
 591                 pvr2_trace(PVR2_TRACE_INFO, "Binding %s to i2c address 0x%02x.",
 592                            info.type, info.addr);
 593                 i2c_new_device(&hdw->i2c_adap, &info);
 594                 break;
 595         case PVR2_IR_SCHEME_ZILOG:     /* HVR-1950 style */
 596         case PVR2_IR_SCHEME_24XXX_MCE: /* 24xxx MCE device */
 597                 init_data->ir_codes              = RC_MAP_HAUPPAUGE;
 598                 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP_XVR;
 599                 init_data->type                  = RC_BIT_RC5;
 600                 init_data->name                  = hdw->hdw_desc->description;
 601                 /* IR Receiver */
 602                 info.addr          = 0x71;
 603                 info.platform_data = init_data;
 604                 strlcpy(info.type, "ir_rx_z8f0811_haup", I2C_NAME_SIZE);
 605                 pvr2_trace(PVR2_TRACE_INFO, "Binding %s to i2c address 0x%02x.",
 606                            info.type, info.addr);
 607                 i2c_new_device(&hdw->i2c_adap, &info);
 608                 /* IR Trasmitter */
 609                 info.addr          = 0x70;
 610                 info.platform_data = init_data;
 611                 strlcpy(info.type, "ir_tx_z8f0811_haup", I2C_NAME_SIZE);
 612                 pvr2_trace(PVR2_TRACE_INFO, "Binding %s to i2c address 0x%02x.",
 613                            info.type, info.addr);
 614                 i2c_new_device(&hdw->i2c_adap, &info);
 615                 break;
 616         default:
 617                 /* The device either doesn't support I2C-based IR or we
 618                    don't know (yet) how to operate IR on the device. */
 619                 break;
 620         }
 621 }
 622
 623 void pvr2_i2c_core_init(struct pvr2_hdw *hdw)
 624 {
 625         unsigned int idx;
 626
 627         /* The default action for all possible I2C addresses is just to do
 628            the transfer normally. */
 629         for (idx = 0; idx < PVR2_I2C_FUNC_CNT; idx++) {
 630                 hdw->i2c_func[idx] = pvr2_i2c_basic_op;
 631         }
 632
 633         /* However, deal with various special cases for 24xxx hardware. */
 634         if (ir_mode[hdw->unit_number] == 0) {
 635                 printk(KERN_INFO "%s: IR disabled\n",hdw->name);
 636                 hdw->i2c_func[0x18] = i2c_black_hole;
 637         } else if (ir_mode[hdw->unit_number] == 1) {
 638                 if (hdw->ir_scheme_active == PVR2_IR_SCHEME_24XXX) {
 639                         /* Set up translation so that our IR looks like a
 640                            29xxx device */
 641                         hdw->i2c_func[0x18] = i2c_24xxx_ir;
 642                 }
 643         }
 644         if (hdw->hdw_desc->flag_has_cx25840) {
 645                 hdw->i2c_func[0x44] = i2c_hack_cx25840;
 646         }
 647         if (hdw->hdw_desc->flag_has_wm8775) {
 648                 hdw->i2c_func[0x1b] = i2c_hack_wm8775;
 649         }
 650
 651         // Configure the adapter and set up everything else related to it.
 652         hdw->i2c_adap = pvr2_i2c_adap_template;
 653         hdw->i2c_algo = pvr2_i2c_algo_template;
 654         strlcpy(hdw->i2c_adap.name,hdw->name,sizeof(hdw->i2c_adap.name));
 655         hdw->i2c_adap.dev.parent = &hdw->usb_dev->dev;
 656         hdw->i2c_adap.algo = &hdw->i2c_algo;
 657         hdw->i2c_adap.algo_data = hdw;
 658         hdw->i2c_linked = !0;
 659         i2c_set_adapdata(&hdw->i2c_adap, &hdw->v4l2_dev);
 660         i2c_add_adapter(&hdw->i2c_adap);
 661         if (hdw->i2c_func[0x18] == i2c_24xxx_ir) {
 662                 /* Probe for a different type of IR receiver on this
 663                    device.  This is really the only way to differentiate
 664                    older 24xxx devices from 24xxx variants that include an
 665                    IR blaster.  If the IR blaster is present, the IR
 666                    receiver is part of that chip and thus we must disable
 667                    the emulated IR receiver. */
 668                 if (do_i2c_probe(hdw, 0x71)) {
 669                         pvr2_trace(PVR2_TRACE_INFO,
 670                                    "Device has newer IR hardware;"
 671                                    " disabling unneeded virtual IR device");
 672                         hdw->i2c_func[0x18] = NULL;
 673                         /* Remember that this is a different device... */
 674                         hdw->ir_scheme_active = PVR2_IR_SCHEME_24XXX_MCE;
 675                 }
 676         }
 677         if (i2c_scan) do_i2c_scan(hdw);
 678
 679         pvr2_i2c_register_ir(hdw);
 680 }
 681
 682 void pvr2_i2c_core_done(struct pvr2_hdw *hdw)
 683 {
 684         if (hdw->i2c_linked) {
 685                 i2c_del_adapter(&hdw->i2c_adap);
 686                 hdw->i2c_linked = 0;
 687         }
 688 }