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 pr_info("pvrusb2 i2c xfer %u/%u: addr=0x%x len=%d %s", 482 idx+1,num, 483 msgs[idx].addr, 484 cnt, 485 (msgs[idx].flags & I2C_M_RD ? 486 "read" : "write")); 487 if ((ret > 0) || !(msgs[idx].flags & I2C_M_RD)) { 488 if (cnt > 8) cnt = 8; 489 pr_cont(" ["); 490 for (offs = 0; offs < cnt; offs++) { 491 if (offs) pr_cont(" "); 492 pr_cont("%02x", msgs[idx].buf[offs]); 493 } 494 if (offs < cnt) pr_cont(" ..."); 495 pr_cont("]"); 496 } 497 if (idx+1 == num) { 498 pr_cont(" result=%d", ret); 499 } 500 pr_cont("\n"); 501 } 502 if (!num) { 503 pr_info("pvrusb2 i2c xfer null transfer result=%d\n", 504 ret); 505 } 506 } 507 return ret; 508 } 509 510 static u32 pvr2_i2c_functionality(struct i2c_adapter *adap) 511 { 512 return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C; 513 } 514 515 static const struct i2c_algorithm pvr2_i2c_algo_template = { 516 .master_xfer = pvr2_i2c_xfer, 517 .functionality = pvr2_i2c_functionality, 518 }; 519 520 static const struct i2c_adapter pvr2_i2c_adap_template = { 521 .owner = THIS_MODULE, 522 .class = 0, 523 }; 524 525 526 /* Return true if device exists at given address */ 527 static int do_i2c_probe(struct pvr2_hdw *hdw, int addr) 528 { 529 struct i2c_msg msg[1]; 530 int rc; 531 msg[0].addr = 0; 532 msg[0].flags = I2C_M_RD; 533 msg[0].len = 0; 534 msg[0].buf = NULL; 535 msg[0].addr = addr; 536 rc = i2c_transfer(&hdw->i2c_adap, msg, ARRAY_SIZE(msg)); 537 return rc == 1; 538 } 539 540 static void do_i2c_scan(struct pvr2_hdw *hdw) 541 { 542 int i; 543 pr_info("%s: i2c scan beginning\n", hdw->name); 544 for (i = 0; i < 128; i++) { 545 if (do_i2c_probe(hdw, i)) { 546 pr_info("%s: i2c scan: found device @ 0x%x\n", 547 hdw->name, i); 548 } 549 } 550 pr_info("%s: i2c scan done.\n", hdw->name); 551 } 552 553 static void pvr2_i2c_register_ir(struct pvr2_hdw *hdw) 554 { 555 struct i2c_board_info info; 556 struct IR_i2c_init_data *init_data = &hdw->ir_init_data; 557 if (pvr2_disable_ir_video) { 558 pvr2_trace(PVR2_TRACE_INFO, 559 "Automatic binding of ir_video has been disabled."); 560 return; 561 } 562 memset(&info, 0, sizeof(struct i2c_board_info)); 563 switch (hdw->ir_scheme_active) { 564 case PVR2_IR_SCHEME_24XXX: /* FX2-controlled IR */ 565 case PVR2_IR_SCHEME_29XXX: /* Original 29xxx device */ 566 init_data->ir_codes = RC_MAP_HAUPPAUGE; 567 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP; 568 init_data->type = RC_PROTO_BIT_RC5; 569 init_data->name = hdw->hdw_desc->description; 570 init_data->polling_interval = 100; /* ms From ir-kbd-i2c */ 571 /* IR Receiver */ 572 info.addr = 0x18; 573 info.platform_data = init_data; 574 strscpy(info.type, "ir_video", I2C_NAME_SIZE); 575 pvr2_trace(PVR2_TRACE_INFO, "Binding %s to i2c address 0x%02x.", 576 info.type, info.addr); 577 i2c_new_device(&hdw->i2c_adap, &info); 578 break; 579 case PVR2_IR_SCHEME_ZILOG: /* HVR-1950 style */ 580 case PVR2_IR_SCHEME_24XXX_MCE: /* 24xxx MCE device */ 581 init_data->ir_codes = RC_MAP_HAUPPAUGE; 582 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP_XVR; 583 init_data->type = RC_PROTO_BIT_RC5 | RC_PROTO_BIT_RC6_MCE | 584 RC_PROTO_BIT_RC6_6A_32; 585 init_data->name = hdw->hdw_desc->description; 586 /* IR Transceiver */ 587 info.addr = 0x71; 588 info.platform_data = init_data; 589 strscpy(info.type, "ir_z8f0811_haup", I2C_NAME_SIZE); 590 pvr2_trace(PVR2_TRACE_INFO, "Binding %s to i2c address 0x%02x.", 591 info.type, info.addr); 592 i2c_new_device(&hdw->i2c_adap, &info); 593 break; 594 default: 595 /* The device either doesn't support I2C-based IR or we 596 don't know (yet) how to operate IR on the device. */ 597 break; 598 } 599 } 600 601 void pvr2_i2c_core_init(struct pvr2_hdw *hdw) 602 { 603 unsigned int idx; 604 605 /* The default action for all possible I2C addresses is just to do 606 the transfer normally. */ 607 for (idx = 0; idx < PVR2_I2C_FUNC_CNT; idx++) { 608 hdw->i2c_func[idx] = pvr2_i2c_basic_op; 609 } 610 611 /* However, deal with various special cases for 24xxx hardware. */ 612 if (ir_mode[hdw->unit_number] == 0) { 613 pr_info("%s: IR disabled\n", hdw->name); 614 hdw->i2c_func[0x18] = i2c_black_hole; 615 } else if (ir_mode[hdw->unit_number] == 1) { 616 if (hdw->ir_scheme_active == PVR2_IR_SCHEME_24XXX) { 617 /* Set up translation so that our IR looks like a 618 29xxx device */ 619 hdw->i2c_func[0x18] = i2c_24xxx_ir; 620 } 621 } 622 if (hdw->hdw_desc->flag_has_cx25840) { 623 hdw->i2c_func[0x44] = i2c_hack_cx25840; 624 } 625 if (hdw->hdw_desc->flag_has_wm8775) { 626 hdw->i2c_func[0x1b] = i2c_hack_wm8775; 627 } 628 629 // Configure the adapter and set up everything else related to it. 630 hdw->i2c_adap = pvr2_i2c_adap_template; 631 hdw->i2c_algo = pvr2_i2c_algo_template; 632 strscpy(hdw->i2c_adap.name, hdw->name, sizeof(hdw->i2c_adap.name)); 633 hdw->i2c_adap.dev.parent = &hdw->usb_dev->dev; 634 hdw->i2c_adap.algo = &hdw->i2c_algo; 635 hdw->i2c_adap.algo_data = hdw; 636 hdw->i2c_linked = !0; 637 i2c_set_adapdata(&hdw->i2c_adap, &hdw->v4l2_dev); 638 i2c_add_adapter(&hdw->i2c_adap); 639 if (hdw->i2c_func[0x18] == i2c_24xxx_ir) { 640 /* Probe for a different type of IR receiver on this 641 device. This is really the only way to differentiate 642 older 24xxx devices from 24xxx variants that include an 643 IR blaster. If the IR blaster is present, the IR 644 receiver is part of that chip and thus we must disable 645 the emulated IR receiver. */ 646 if (do_i2c_probe(hdw, 0x71)) { 647 pvr2_trace(PVR2_TRACE_INFO, 648 "Device has newer IR hardware; disabling unneeded virtual IR device"); 649 hdw->i2c_func[0x18] = NULL; 650 /* Remember that this is a different device... */ 651 hdw->ir_scheme_active = PVR2_IR_SCHEME_24XXX_MCE; 652 } 653 } 654 if (i2c_scan) do_i2c_scan(hdw); 655 656 pvr2_i2c_register_ir(hdw); 657 } 658 659 void pvr2_i2c_core_done(struct pvr2_hdw *hdw) 660 { 661 if (hdw->i2c_linked) { 662 i2c_del_adapter(&hdw->i2c_adap); 663 hdw->i2c_linked = 0; 664 } 665 } 666