4 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
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
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.
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
21 #include <linux/i2c.h>
22 #include <media/ir-kbd-i2c.h>
23 #include "pvrusb2-i2c-core.h"
24 #include "pvrusb2-hdw-internal.h"
25 #include "pvrusb2-debug.h"
26 #include "pvrusb2-fx2-cmd.h"
29 #define trace_i2c(...) pvr2_trace(PVR2_TRACE_I2C,__VA_ARGS__)
33 This module attempts to implement a compliant I2C adapter for the pvrusb2
38 static unsigned int i2c_scan;
39 module_param(i2c_scan, int, S_IRUGO|S_IWUSR);
40 MODULE_PARM_DESC(i2c_scan,"scan i2c bus at insmod time");
42 static int ir_mode[PVR_NUM] = { [0 ... PVR_NUM-1] = 1 };
43 module_param_array(ir_mode, int, NULL, 0444);
44 MODULE_PARM_DESC(ir_mode,"specify: 0=disable IR reception, 1=normal IR");
46 static int pvr2_disable_ir_video;
47 module_param_named(disable_autoload_ir_video, pvr2_disable_ir_video,
48 int, S_IRUGO|S_IWUSR);
49 MODULE_PARM_DESC(disable_autoload_ir_video,
50 "1=do not try to autoload ir_video IR receiver");
52 static int pvr2_i2c_write(struct pvr2_hdw *hdw, /* Context */
53 u8 i2c_addr, /* I2C address we're talking to */
54 u8 *data, /* Data to write */
55 u16 length) /* Size of data to write */
57 /* Return value - default 0 means success */
61 if (!data) length = 0;
62 if (length > (sizeof(hdw->cmd_buffer) - 3)) {
63 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
64 "Killing an I2C write to %u that is too large"
65 " (desired=%u limit=%u)",
67 length,(unsigned int)(sizeof(hdw->cmd_buffer) - 3));
71 LOCK_TAKE(hdw->ctl_lock);
73 /* Clear the command buffer (likely to be paranoia) */
74 memset(hdw->cmd_buffer, 0, sizeof(hdw->cmd_buffer));
76 /* Set up command buffer for an I2C write */
77 hdw->cmd_buffer[0] = FX2CMD_I2C_WRITE; /* write prefix */
78 hdw->cmd_buffer[1] = i2c_addr; /* i2c addr of chip */
79 hdw->cmd_buffer[2] = length; /* length of what follows */
80 if (length) memcpy(hdw->cmd_buffer + 3, data, length);
82 /* Do the operation */
83 ret = pvr2_send_request(hdw,
89 if (hdw->cmd_buffer[0] != 8) {
91 if (hdw->cmd_buffer[0] != 7) {
92 trace_i2c("unexpected status"
93 " from i2_write[%d]: %d",
94 i2c_addr,hdw->cmd_buffer[0]);
99 LOCK_GIVE(hdw->ctl_lock);
104 static int pvr2_i2c_read(struct pvr2_hdw *hdw, /* Context */
105 u8 i2c_addr, /* I2C address we're talking to */
106 u8 *data, /* Data to write */
107 u16 dlen, /* Size of data to write */
108 u8 *res, /* Where to put data we read */
109 u16 rlen) /* Amount of data to read */
111 /* Return value - default 0 means success */
116 if (dlen > (sizeof(hdw->cmd_buffer) - 4)) {
117 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
118 "Killing an I2C read to %u that has wlen too large"
119 " (desired=%u limit=%u)",
121 dlen,(unsigned int)(sizeof(hdw->cmd_buffer) - 4));
124 if (res && (rlen > (sizeof(hdw->cmd_buffer) - 1))) {
125 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
126 "Killing an I2C read to %u that has rlen too large"
127 " (desired=%u limit=%u)",
129 rlen,(unsigned int)(sizeof(hdw->cmd_buffer) - 1));
133 LOCK_TAKE(hdw->ctl_lock);
135 /* Clear the command buffer (likely to be paranoia) */
136 memset(hdw->cmd_buffer, 0, sizeof(hdw->cmd_buffer));
138 /* Set up command buffer for an I2C write followed by a read */
139 hdw->cmd_buffer[0] = FX2CMD_I2C_READ; /* read prefix */
140 hdw->cmd_buffer[1] = dlen; /* arg length */
141 hdw->cmd_buffer[2] = rlen; /* answer length. Device will send one
142 more byte (status). */
143 hdw->cmd_buffer[3] = i2c_addr; /* i2c addr of chip */
144 if (dlen) memcpy(hdw->cmd_buffer + 4, data, dlen);
146 /* Do the operation */
147 ret = pvr2_send_request(hdw,
153 if (hdw->cmd_buffer[0] != 8) {
155 if (hdw->cmd_buffer[0] != 7) {
156 trace_i2c("unexpected status"
157 " from i2_read[%d]: %d",
158 i2c_addr,hdw->cmd_buffer[0]);
163 /* Copy back the result */
166 /* Error, just blank out the return buffer */
167 memset(res, 0, rlen);
169 memcpy(res, hdw->cmd_buffer + 1, rlen);
173 LOCK_GIVE(hdw->ctl_lock);
178 /* This is the common low level entry point for doing I2C operations to the
180 static int pvr2_i2c_basic_op(struct pvr2_hdw *hdw,
187 if (!rdata) rlen = 0;
188 if (!wdata) wlen = 0;
190 return pvr2_i2c_read(hdw,i2c_addr,wdata,wlen,rdata,rlen);
192 return pvr2_i2c_write(hdw,i2c_addr,wdata,wlen);
197 /* This is a special entry point for cases of I2C transaction attempts to
198 the IR receiver. The implementation here simulates the IR receiver by
199 issuing a command to the FX2 firmware and using that response to return
200 what the real I2C receiver would have returned. We use this for 24xxx
201 devices, where the IR receiver chip has been removed and replaced with
202 FX2 related logic. */
203 static int i2c_24xxx_ir(struct pvr2_hdw *hdw,
204 u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
209 if (!(rlen || wlen)) {
210 /* This is a probe attempt. Just let it succeed. */
214 /* We don't understand this kind of transaction */
215 if ((wlen != 0) || (rlen == 0)) return -EIO;
218 /* Mike Isely <isely@pobox.com> Appears to be a probe
219 attempt from lirc. Just fill in zeroes and return. If
220 we try instead to do the full transaction here, then bad
221 things seem to happen within the lirc driver module
222 (version 0.8.0-7 sources from Debian, when run under
223 vanilla 2.6.17.6 kernel) - and I don't have the patience
225 if (rlen > 0) rdata[0] = 0;
226 if (rlen > 1) rdata[1] = 0;
230 /* Issue a command to the FX2 to read the IR receiver. */
231 LOCK_TAKE(hdw->ctl_lock); do {
232 hdw->cmd_buffer[0] = FX2CMD_GET_IR_CODE;
233 stat = pvr2_send_request(hdw,
236 dat[0] = hdw->cmd_buffer[0];
237 dat[1] = hdw->cmd_buffer[1];
238 dat[2] = hdw->cmd_buffer[2];
239 dat[3] = hdw->cmd_buffer[3];
240 } while (0); LOCK_GIVE(hdw->ctl_lock);
242 /* Give up if that operation failed. */
243 if (stat != 0) return stat;
245 /* Mangle the results into something that looks like the real IR
249 /* No code received. */
254 /* Mash the FX2 firmware-provided IR code into something
255 that the normal i2c chip-level driver expects. */
262 rdata[0] = (val >> 8) & 0xffu;
263 rdata[1] = val & 0xffu;
269 /* This is a special entry point that is entered if an I2C operation is
270 attempted to a wm8775 chip on model 24xxx hardware. Autodetect of this
271 part doesn't work, but we know it is really there. So let's look for
272 the autodetect attempt and just return success if we see that. */
273 static int i2c_hack_wm8775(struct pvr2_hdw *hdw,
274 u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
276 if (!(rlen || wlen)) {
277 // This is a probe attempt. Just let it succeed.
280 return pvr2_i2c_basic_op(hdw,i2c_addr,wdata,wlen,rdata,rlen);
283 /* This is an entry point designed to always fail any attempt to perform a
284 transfer. We use this to cause certain I2C addresses to not be
286 static int i2c_black_hole(struct pvr2_hdw *hdw,
287 u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
292 /* This is a special entry point that is entered if an I2C operation is
293 attempted to a cx25840 chip on model 24xxx hardware. This chip can
294 sometimes wedge itself. Worse still, when this happens msp3400 can
295 falsely detect this part and then the system gets hosed up after msp3400
296 gets confused and dies. What we want to do here is try to keep msp3400
297 away and also try to notice if the chip is wedged and send a warning to
299 static int i2c_hack_cx25840(struct pvr2_hdw *hdw,
300 u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
303 unsigned int subaddr;
305 int state = hdw->i2c_cx25840_hack_state;
307 if (!(rlen || wlen)) {
308 // Probe attempt - always just succeed and don't bother the
309 // hardware (this helps to make the state machine further
310 // down somewhat easier).
315 return pvr2_i2c_basic_op(hdw,i2c_addr,wdata,wlen,rdata,rlen);
318 /* We're looking for the exact pattern where the revision register
319 is being read. The cx25840 module will always look at the
320 revision register first. Any other pattern of access therefore
321 has to be a probe attempt from somebody else so we'll reject it.
322 Normally we could just let each client just probe the part
323 anyway, but when the cx25840 is wedged, msp3400 will get a false
324 positive and that just screws things up... */
328 case 1: subaddr = 0x0100; break;
329 case 2: subaddr = 0x0101; break;
332 } else if (wlen == 2) {
333 subaddr = (wdata[0] << 8) | wdata[1];
335 case 0x0100: state = 1; break;
336 case 0x0101: state = 2; break;
342 if (!rlen) goto success;
344 if (rlen != 1) goto fail;
346 /* If we get to here then we have a legitimate read for one of the
347 two revision bytes, so pass it through. */
348 wbuf[0] = subaddr >> 8;
350 ret = pvr2_i2c_basic_op(hdw,i2c_addr,wbuf,2,rdata,rlen);
352 if ((ret != 0) || (*rdata == 0x04) || (*rdata == 0x0a)) {
353 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
354 "WARNING: Detected a wedged cx25840 chip;"
355 " the device will not work.");
356 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
357 "WARNING: Try power cycling the pvrusb2 device.");
358 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
359 "WARNING: Disabling further access to the device"
360 " to prevent other foul-ups.");
361 // This blocks all further communication with the part.
362 hdw->i2c_func[0x44] = NULL;
363 pvr2_hdw_render_useless(hdw);
368 pvr2_trace(PVR2_TRACE_CHIPS,"cx25840 appears to be OK.");
372 hdw->i2c_cx25840_hack_state = state;
376 hdw->i2c_cx25840_hack_state = state;
380 /* This is a very, very limited I2C adapter implementation. We can only
381 support what we actually know will work on the device... */
382 static int pvr2_i2c_xfer(struct i2c_adapter *i2c_adap,
383 struct i2c_msg msgs[],
387 pvr2_i2c_func funcp = NULL;
388 struct pvr2_hdw *hdw = (struct pvr2_hdw *)(i2c_adap->algo_data);
394 if (msgs[0].addr < PVR2_I2C_FUNC_CNT) {
395 funcp = hdw->i2c_func[msgs[0].addr];
403 if (msgs[0].flags & I2C_M_RD) {
407 /* Length == 0 read. This is a probe. */
408 if (funcp(hdw,msgs[0].addr,NULL,0,NULL,0)) {
415 /* If the read is short enough we'll do the whole
416 thing atomically. Otherwise we have no choice
417 but to break apart the reads. */
422 if (bcnt > sizeof(hdw->cmd_buffer)-1) {
423 bcnt = sizeof(hdw->cmd_buffer)-1;
425 if (funcp(hdw,msgs[0].addr,NULL,0,
426 msgs[0].buf+offs,bcnt)) {
438 if (funcp(hdw,msgs[0].addr,
439 msgs[0].buf,msgs[0].len,NULL,0)) {
444 } else if (num == 2) {
445 if (msgs[0].addr != msgs[1].addr) {
446 trace_i2c("i2c refusing 2 phase transfer with"
447 " conflicting target addresses");
451 if ((!((msgs[0].flags & I2C_M_RD))) &&
452 (msgs[1].flags & I2C_M_RD)) {
453 u16 tcnt,bcnt,wcnt,offs;
454 /* Write followed by atomic read. If the read
455 portion is short enough we'll do the whole thing
456 atomically. Otherwise we have no choice but to
457 break apart the reads. */
461 while (tcnt || wcnt) {
463 if (bcnt > sizeof(hdw->cmd_buffer)-1) {
464 bcnt = sizeof(hdw->cmd_buffer)-1;
466 if (funcp(hdw,msgs[0].addr,
468 msgs[1].buf+offs,bcnt)) {
479 trace_i2c("i2c refusing complex transfer"
480 " read0=%d read1=%d",
481 (msgs[0].flags & I2C_M_RD),
482 (msgs[1].flags & I2C_M_RD));
485 trace_i2c("i2c refusing %d phase transfer",num);
489 if (pvrusb2_debug & PVR2_TRACE_I2C_TRAF) {
490 unsigned int idx,offs,cnt;
491 for (idx = 0; idx < num; idx++) {
494 "pvrusb2 i2c xfer %u/%u:"
495 " addr=0x%x len=%d %s",
499 (msgs[idx].flags & I2C_M_RD ?
501 if ((ret > 0) || !(msgs[idx].flags & I2C_M_RD)) {
502 if (cnt > 8) cnt = 8;
504 for (offs = 0; offs < (cnt>8?8:cnt); offs++) {
505 if (offs) printk(" ");
506 printk("%02x",msgs[idx].buf[offs]);
508 if (offs < cnt) printk(" ...");
512 printk(" result=%d",ret);
518 "pvrusb2 i2c xfer null transfer result=%d\n",
525 static u32 pvr2_i2c_functionality(struct i2c_adapter *adap)
527 return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C;
530 static struct i2c_algorithm pvr2_i2c_algo_template = {
531 .master_xfer = pvr2_i2c_xfer,
532 .functionality = pvr2_i2c_functionality,
535 static struct i2c_adapter pvr2_i2c_adap_template = {
536 .owner = THIS_MODULE,
541 /* Return true if device exists at given address */
542 static int do_i2c_probe(struct pvr2_hdw *hdw, int addr)
544 struct i2c_msg msg[1];
547 msg[0].flags = I2C_M_RD;
551 rc = i2c_transfer(&hdw->i2c_adap, msg, ARRAY_SIZE(msg));
555 static void do_i2c_scan(struct pvr2_hdw *hdw)
558 printk(KERN_INFO "%s: i2c scan beginning\n", hdw->name);
559 for (i = 0; i < 128; i++) {
560 if (do_i2c_probe(hdw, i)) {
561 printk(KERN_INFO "%s: i2c scan: found device @ 0x%x\n",
565 printk(KERN_INFO "%s: i2c scan done.\n", hdw->name);
568 static void pvr2_i2c_register_ir(struct pvr2_hdw *hdw)
570 struct i2c_board_info info;
571 struct IR_i2c_init_data *init_data = &hdw->ir_init_data;
572 if (pvr2_disable_ir_video) {
573 pvr2_trace(PVR2_TRACE_INFO,
574 "Automatic binding of ir_video has been disabled.");
577 memset(&info, 0, sizeof(struct i2c_board_info));
578 switch (hdw->ir_scheme_active) {
579 case PVR2_IR_SCHEME_24XXX: /* FX2-controlled IR */
580 case PVR2_IR_SCHEME_29XXX: /* Original 29xxx device */
581 init_data->ir_codes = RC_MAP_HAUPPAUGE_NEW;
582 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP;
583 init_data->type = RC_TYPE_RC5;
584 init_data->name = hdw->hdw_desc->description;
585 init_data->polling_interval = 100; /* ms From ir-kbd-i2c */
588 info.platform_data = init_data;
589 strlcpy(info.type, "ir_video", 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);
594 case PVR2_IR_SCHEME_ZILOG: /* HVR-1950 style */
595 case PVR2_IR_SCHEME_24XXX_MCE: /* 24xxx MCE device */
596 init_data->ir_codes = RC_MAP_HAUPPAUGE_NEW;
597 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP_XVR;
598 init_data->type = RC_TYPE_RC5;
599 init_data->name = hdw->hdw_desc->description;
600 init_data->polling_interval = 260; /* ms From lirc_zilog */
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);
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);
617 /* The device either doesn't support I2C-based IR or we
618 don't know (yet) how to operate IR on the device. */
623 void pvr2_i2c_core_init(struct pvr2_hdw *hdw)
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;
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
641 hdw->i2c_func[0x18] = i2c_24xxx_ir;
644 if (hdw->hdw_desc->flag_has_cx25840) {
645 hdw->i2c_func[0x44] = i2c_hack_cx25840;
647 if (hdw->hdw_desc->flag_has_wm8775) {
648 hdw->i2c_func[0x1b] = i2c_hack_wm8775;
651 // Configure the adapter and set up everything else related to it.
652 memcpy(&hdw->i2c_adap,&pvr2_i2c_adap_template,sizeof(hdw->i2c_adap));
653 memcpy(&hdw->i2c_algo,&pvr2_i2c_algo_template,sizeof(hdw->i2c_algo));
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;
677 if (i2c_scan) do_i2c_scan(hdw);
679 pvr2_i2c_register_ir(hdw);
682 void pvr2_i2c_core_done(struct pvr2_hdw *hdw)
684 if (hdw->i2c_linked) {
685 i2c_del_adapter(&hdw->i2c_adap);
691 Stuff for Emacs to see, in order to encourage consistent editing style:
692 *** Local Variables: ***
694 *** fill-column: 75 ***
696 *** c-basic-offset: 8 ***