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