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