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>8?8: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