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 * 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
18 *
19 */
20
21 #include "pvrusb2-i2c-core.h"
22 #include "pvrusb2-hdw-internal.h"
23 #include "pvrusb2-debug.h"
24 #include "pvrusb2-fx2-cmd.h"
25 #include "pvrusb2.h"
26
27 #define trace_i2c(...) pvr2_trace(PVR2_TRACE_I2C,__VA_ARGS__)
28
29 /*
30
31 This module attempts to implement a compliant I2C adapter for the pvrusb2
32 device. By doing this we can then make use of existing functionality in
33 V4L (e.g. tuner.c) rather than rolling our own.
34
35 */
36
37 static unsigned int i2c_scan;
38 module_param(i2c_scan, int, S_IRUGO|S_IWUSR);
39 MODULE_PARM_DESC(i2c_scan,"scan i2c bus at insmod time");
40
41 static int ir_mode[PVR_NUM] = { [0 ... PVR_NUM-1] = 1 };
42 module_param_array(ir_mode, int, NULL, 0444);
43 MODULE_PARM_DESC(ir_mode,"specify: 0=disable IR reception, 1=normal IR");
44
45 static unsigned int pvr2_i2c_client_describe(struct pvr2_i2c_client *cp,
46 unsigned int detail,
47 char *buf,unsigned int maxlen);
48
pvr2_i2c_write(struct pvr2_hdw * hdw,u8 i2c_addr,u8 * data,u16 length)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"
62 " (desired=%u limit=%u)",
63 i2c_addr,
64 length,(unsigned int)(sizeof(hdw->cmd_buffer) - 3));
65 return -ENOTSUPP;
66 }
67
68 LOCK_TAKE(hdw->ctl_lock);
69
70 /* Clear the command buffer (likely to be paranoia) */
71 memset(hdw->cmd_buffer, 0, sizeof(hdw->cmd_buffer));
72
73 /* Set up command buffer for an I2C write */
74 hdw->cmd_buffer[0] = FX2CMD_I2C_WRITE; /* write prefix */
75 hdw->cmd_buffer[1] = i2c_addr; /* i2c addr of chip */
76 hdw->cmd_buffer[2] = length; /* length of what follows */
77 if (length) memcpy(hdw->cmd_buffer + 3, data, length);
78
79 /* Do the operation */
80 ret = pvr2_send_request(hdw,
81 hdw->cmd_buffer,
82 length + 3,
83 hdw->cmd_buffer,
84 1);
85 if (!ret) {
86 if (hdw->cmd_buffer[0] != 8) {
87 ret = -EIO;
88 if (hdw->cmd_buffer[0] != 7) {
89 trace_i2c("unexpected status"
90 " from i2_write[%d]: %d",
91 i2c_addr,hdw->cmd_buffer[0]);
92 }
93 }
94 }
95
96 LOCK_GIVE(hdw->ctl_lock);
97
98 return ret;
99 }
100
pvr2_i2c_read(struct pvr2_hdw * hdw,u8 i2c_addr,u8 * data,u16 dlen,u8 * res,u16 rlen)101 static int pvr2_i2c_read(struct pvr2_hdw *hdw, /* Context */
102 u8 i2c_addr, /* I2C address we're talking to */
103 u8 *data, /* Data to write */
104 u16 dlen, /* Size of data to write */
105 u8 *res, /* Where to put data we read */
106 u16 rlen) /* Amount of data to read */
107 {
108 /* Return value - default 0 means success */
109 int ret;
110
111
112 if (!data) dlen = 0;
113 if (dlen > (sizeof(hdw->cmd_buffer) - 4)) {
114 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
115 "Killing an I2C read to %u that has wlen too large"
116 " (desired=%u limit=%u)",
117 i2c_addr,
118 dlen,(unsigned int)(sizeof(hdw->cmd_buffer) - 4));
119 return -ENOTSUPP;
120 }
121 if (res && (rlen > (sizeof(hdw->cmd_buffer) - 1))) {
122 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
123 "Killing an I2C read to %u that has rlen too large"
124 " (desired=%u limit=%u)",
125 i2c_addr,
126 rlen,(unsigned int)(sizeof(hdw->cmd_buffer) - 1));
127 return -ENOTSUPP;
128 }
129
130 LOCK_TAKE(hdw->ctl_lock);
131
132 /* Clear the command buffer (likely to be paranoia) */
133 memset(hdw->cmd_buffer, 0, sizeof(hdw->cmd_buffer));
134
135 /* Set up command buffer for an I2C write followed by a read */
136 hdw->cmd_buffer[0] = FX2CMD_I2C_READ; /* read prefix */
137 hdw->cmd_buffer[1] = dlen; /* arg length */
138 hdw->cmd_buffer[2] = rlen; /* answer length. Device will send one
139 more byte (status). */
140 hdw->cmd_buffer[3] = i2c_addr; /* i2c addr of chip */
141 if (dlen) memcpy(hdw->cmd_buffer + 4, data, dlen);
142
143 /* Do the operation */
144 ret = pvr2_send_request(hdw,
145 hdw->cmd_buffer,
146 4 + dlen,
147 hdw->cmd_buffer,
148 rlen + 1);
149 if (!ret) {
150 if (hdw->cmd_buffer[0] != 8) {
151 ret = -EIO;
152 if (hdw->cmd_buffer[0] != 7) {
153 trace_i2c("unexpected status"
154 " from i2_read[%d]: %d",
155 i2c_addr,hdw->cmd_buffer[0]);
156 }
157 }
158 }
159
160 /* Copy back the result */
161 if (res && rlen) {
162 if (ret) {
163 /* Error, just blank out the return buffer */
164 memset(res, 0, rlen);
165 } else {
166 memcpy(res, hdw->cmd_buffer + 1, rlen);
167 }
168 }
169
170 LOCK_GIVE(hdw->ctl_lock);
171
172 return ret;
173 }
174
175 /* This is the common low level entry point for doing I2C operations to the
176 hardware. */
pvr2_i2c_basic_op(struct pvr2_hdw * hdw,u8 i2c_addr,u8 * wdata,u16 wlen,u8 * rdata,u16 rlen)177 static int pvr2_i2c_basic_op(struct pvr2_hdw *hdw,
178 u8 i2c_addr,
179 u8 *wdata,
180 u16 wlen,
181 u8 *rdata,
182 u16 rlen)
183 {
184 if (!rdata) rlen = 0;
185 if (!wdata) wlen = 0;
186 if (rlen || !wlen) {
187 return pvr2_i2c_read(hdw,i2c_addr,wdata,wlen,rdata,rlen);
188 } else {
189 return pvr2_i2c_write(hdw,i2c_addr,wdata,wlen);
190 }
191 }
192
193
194 /* This is a special entry point for cases of I2C transaction attempts to
195 the IR receiver. The implementation here simulates the IR receiver by
196 issuing a command to the FX2 firmware and using that response to return
197 what the real I2C receiver would have returned. We use this for 24xxx
198 devices, where the IR receiver chip has been removed and replaced with
199 FX2 related logic. */
i2c_24xxx_ir(struct pvr2_hdw * hdw,u8 i2c_addr,u8 * wdata,u16 wlen,u8 * rdata,u16 rlen)200 static int i2c_24xxx_ir(struct pvr2_hdw *hdw,
201 u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
202 {
203 u8 dat[4];
204 unsigned int stat;
205
206 if (!(rlen || wlen)) {
207 /* This is a probe attempt. Just let it succeed. */
208 return 0;
209 }
210
211 /* We don't understand this kind of transaction */
212 if ((wlen != 0) || (rlen == 0)) return -EIO;
213
214 if (rlen < 3) {
215 /* Mike Isely <isely@pobox.com> Appears to be a probe
216 attempt from lirc. Just fill in zeroes and return. If
217 we try instead to do the full transaction here, then bad
218 things seem to happen within the lirc driver module
219 (version 0.8.0-7 sources from Debian, when run under
220 vanilla 2.6.17.6 kernel) - and I don't have the patience
221 to chase it down. */
222 if (rlen > 0) rdata[0] = 0;
223 if (rlen > 1) rdata[1] = 0;
224 return 0;
225 }
226
227 /* Issue a command to the FX2 to read the IR receiver. */
228 LOCK_TAKE(hdw->ctl_lock); do {
229 hdw->cmd_buffer[0] = FX2CMD_GET_IR_CODE;
230 stat = pvr2_send_request(hdw,
231 hdw->cmd_buffer,1,
232 hdw->cmd_buffer,4);
233 dat[0] = hdw->cmd_buffer[0];
234 dat[1] = hdw->cmd_buffer[1];
235 dat[2] = hdw->cmd_buffer[2];
236 dat[3] = hdw->cmd_buffer[3];
237 } while (0); LOCK_GIVE(hdw->ctl_lock);
238
239 /* Give up if that operation failed. */
240 if (stat != 0) return stat;
241
242 /* Mangle the results into something that looks like the real IR
243 receiver. */
244 rdata[2] = 0xc1;
245 if (dat[0] != 1) {
246 /* No code received. */
247 rdata[0] = 0;
248 rdata[1] = 0;
249 } else {
250 u16 val;
251 /* Mash the FX2 firmware-provided IR code into something
252 that the normal i2c chip-level driver expects. */
253 val = dat[1];
254 val <<= 8;
255 val |= dat[2];
256 val >>= 1;
257 val &= ~0x0003;
258 val |= 0x8000;
259 rdata[0] = (val >> 8) & 0xffu;
260 rdata[1] = val & 0xffu;
261 }
262
263 return 0;
264 }
265
266 /* This is a special entry point that is entered if an I2C operation is
267 attempted to a wm8775 chip on model 24xxx hardware. Autodetect of this
268 part doesn't work, but we know it is really there. So let's look for
269 the autodetect attempt and just return success if we see that. */
i2c_hack_wm8775(struct pvr2_hdw * hdw,u8 i2c_addr,u8 * wdata,u16 wlen,u8 * rdata,u16 rlen)270 static int i2c_hack_wm8775(struct pvr2_hdw *hdw,
271 u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
272 {
273 if (!(rlen || wlen)) {
274 // This is a probe attempt. Just let it succeed.
275 return 0;
276 }
277 return pvr2_i2c_basic_op(hdw,i2c_addr,wdata,wlen,rdata,rlen);
278 }
279
280 /* This is an entry point designed to always fail any attempt to perform a
281 transfer. We use this to cause certain I2C addresses to not be
282 probed. */
i2c_black_hole(struct pvr2_hdw * hdw,u8 i2c_addr,u8 * wdata,u16 wlen,u8 * rdata,u16 rlen)283 static int i2c_black_hole(struct pvr2_hdw *hdw,
284 u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
285 {
286 return -EIO;
287 }
288
289 /* This is a special entry point that is entered if an I2C operation is
290 attempted to a cx25840 chip on model 24xxx hardware. This chip can
291 sometimes wedge itself. Worse still, when this happens msp3400 can
292 falsely detect this part and then the system gets hosed up after msp3400
293 gets confused and dies. What we want to do here is try to keep msp3400
294 away and also try to notice if the chip is wedged and send a warning to
295 the system log. */
i2c_hack_cx25840(struct pvr2_hdw * hdw,u8 i2c_addr,u8 * wdata,u16 wlen,u8 * rdata,u16 rlen)296 static int i2c_hack_cx25840(struct pvr2_hdw *hdw,
297 u8 i2c_addr,u8 *wdata,u16 wlen,u8 *rdata,u16 rlen)
298 {
299 int ret;
300 unsigned int subaddr;
301 u8 wbuf[2];
302 int state = hdw->i2c_cx25840_hack_state;
303
304 if (!(rlen || wlen)) {
305 // Probe attempt - always just succeed and don't bother the
306 // hardware (this helps to make the state machine further
307 // down somewhat easier).
308 return 0;
309 }
310
311 if (state == 3) {
312 return pvr2_i2c_basic_op(hdw,i2c_addr,wdata,wlen,rdata,rlen);
313 }
314
315 /* We're looking for the exact pattern where the revision register
316 is being read. The cx25840 module will always look at the
317 revision register first. Any other pattern of access therefore
318 has to be a probe attempt from somebody else so we'll reject it.
319 Normally we could just let each client just probe the part
320 anyway, but when the cx25840 is wedged, msp3400 will get a false
321 positive and that just screws things up... */
322
323 if (wlen == 0) {
324 switch (state) {
325 case 1: subaddr = 0x0100; break;
326 case 2: subaddr = 0x0101; break;
327 default: goto fail;
328 }
329 } else if (wlen == 2) {
330 subaddr = (wdata[0] << 8) | wdata[1];
331 switch (subaddr) {
332 case 0x0100: state = 1; break;
333 case 0x0101: state = 2; break;
334 default: goto fail;
335 }
336 } else {
337 goto fail;
338 }
339 if (!rlen) goto success;
340 state = 0;
341 if (rlen != 1) goto fail;
342
343 /* If we get to here then we have a legitimate read for one of the
344 two revision bytes, so pass it through. */
345 wbuf[0] = subaddr >> 8;
346 wbuf[1] = subaddr;
347 ret = pvr2_i2c_basic_op(hdw,i2c_addr,wbuf,2,rdata,rlen);
348
349 if ((ret != 0) || (*rdata == 0x04) || (*rdata == 0x0a)) {
350 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
351 "WARNING: Detected a wedged cx25840 chip;"
352 " the device will not work.");
353 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
354 "WARNING: Try power cycling the pvrusb2 device.");
355 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
356 "WARNING: Disabling further access to the device"
357 " to prevent other foul-ups.");
358 // This blocks all further communication with the part.
359 hdw->i2c_func[0x44] = NULL;
360 pvr2_hdw_render_useless(hdw);
361 goto fail;
362 }
363
364 /* Success! */
365 pvr2_trace(PVR2_TRACE_CHIPS,"cx25840 appears to be OK.");
366 state = 3;
367
368 success:
369 hdw->i2c_cx25840_hack_state = state;
370 return 0;
371
372 fail:
373 hdw->i2c_cx25840_hack_state = state;
374 return -EIO;
375 }
376
377 /* This is a very, very limited I2C adapter implementation. We can only
378 support what we actually know will work on the device... */
pvr2_i2c_xfer(struct i2c_adapter * i2c_adap,struct i2c_msg msgs[],int num)379 static int pvr2_i2c_xfer(struct i2c_adapter *i2c_adap,
380 struct i2c_msg msgs[],
381 int num)
382 {
383 int ret = -ENOTSUPP;
384 pvr2_i2c_func funcp = NULL;
385 struct pvr2_hdw *hdw = (struct pvr2_hdw *)(i2c_adap->algo_data);
386
387 if (!num) {
388 ret = -EINVAL;
389 goto done;
390 }
391 if (msgs[0].addr < PVR2_I2C_FUNC_CNT) {
392 funcp = hdw->i2c_func[msgs[0].addr];
393 }
394 if (!funcp) {
395 ret = -EIO;
396 goto done;
397 }
398
399 if (num == 1) {
400 if (msgs[0].flags & I2C_M_RD) {
401 /* Simple read */
402 u16 tcnt,bcnt,offs;
403 if (!msgs[0].len) {
404 /* Length == 0 read. This is a probe. */
405 if (funcp(hdw,msgs[0].addr,NULL,0,NULL,0)) {
406 ret = -EIO;
407 goto done;
408 }
409 ret = 1;
410 goto done;
411 }
412 /* If the read is short enough we'll do the whole
413 thing atomically. Otherwise we have no choice
414 but to break apart the reads. */
415 tcnt = msgs[0].len;
416 offs = 0;
417 while (tcnt) {
418 bcnt = tcnt;
419 if (bcnt > sizeof(hdw->cmd_buffer)-1) {
420 bcnt = sizeof(hdw->cmd_buffer)-1;
421 }
422 if (funcp(hdw,msgs[0].addr,NULL,0,
423 msgs[0].buf+offs,bcnt)) {
424 ret = -EIO;
425 goto done;
426 }
427 offs += bcnt;
428 tcnt -= bcnt;
429 }
430 ret = 1;
431 goto done;
432 } else {
433 /* Simple write */
434 ret = 1;
435 if (funcp(hdw,msgs[0].addr,
436 msgs[0].buf,msgs[0].len,NULL,0)) {
437 ret = -EIO;
438 }
439 goto done;
440 }
441 } else if (num == 2) {
442 if (msgs[0].addr != msgs[1].addr) {
443 trace_i2c("i2c refusing 2 phase transfer with"
444 " conflicting target addresses");
445 ret = -ENOTSUPP;
446 goto done;
447 }
448 if ((!((msgs[0].flags & I2C_M_RD))) &&
449 (msgs[1].flags & I2C_M_RD)) {
450 u16 tcnt,bcnt,wcnt,offs;
451 /* Write followed by atomic read. If the read
452 portion is short enough we'll do the whole thing
453 atomically. Otherwise we have no choice but to
454 break apart the reads. */
455 tcnt = msgs[1].len;
456 wcnt = msgs[0].len;
457 offs = 0;
458 while (tcnt || wcnt) {
459 bcnt = tcnt;
460 if (bcnt > sizeof(hdw->cmd_buffer)-1) {
461 bcnt = sizeof(hdw->cmd_buffer)-1;
462 }
463 if (funcp(hdw,msgs[0].addr,
464 msgs[0].buf,wcnt,
465 msgs[1].buf+offs,bcnt)) {
466 ret = -EIO;
467 goto done;
468 }
469 offs += bcnt;
470 tcnt -= bcnt;
471 wcnt = 0;
472 }
473 ret = 2;
474 goto done;
475 } else {
476 trace_i2c("i2c refusing complex transfer"
477 " read0=%d read1=%d",
478 (msgs[0].flags & I2C_M_RD),
479 (msgs[1].flags & I2C_M_RD));
480 }
481 } else {
482 trace_i2c("i2c refusing %d phase transfer",num);
483 }
484
485 done:
486 if (pvrusb2_debug & PVR2_TRACE_I2C_TRAF) {
487 unsigned int idx,offs,cnt;
488 for (idx = 0; idx < num; idx++) {
489 cnt = msgs[idx].len;
490 printk(KERN_INFO
491 "pvrusb2 i2c xfer %u/%u:"
492 " addr=0x%x len=%d %s",
493 idx+1,num,
494 msgs[idx].addr,
495 cnt,
496 (msgs[idx].flags & I2C_M_RD ?
497 "read" : "write"));
498 if ((ret > 0) || !(msgs[idx].flags & I2C_M_RD)) {
499 if (cnt > 8) cnt = 8;
500 printk(" [");
501 for (offs = 0; offs < (cnt>8?8:cnt); offs++) {
502 if (offs) printk(" ");
503 printk("%02x",msgs[idx].buf[offs]);
504 }
505 if (offs < cnt) printk(" ...");
506 printk("]");
507 }
508 if (idx+1 == num) {
509 printk(" result=%d",ret);
510 }
511 printk("\n");
512 }
513 if (!num) {
514 printk(KERN_INFO
515 "pvrusb2 i2c xfer null transfer result=%d\n",
516 ret);
517 }
518 }
519 return ret;
520 }
521
pvr2_i2c_functionality(struct i2c_adapter * adap)522 static u32 pvr2_i2c_functionality(struct i2c_adapter *adap)
523 {
524 return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C;
525 }
526
pvr2_i2c_core_singleton(struct i2c_client * cp,unsigned int cmd,void * arg)527 static int pvr2_i2c_core_singleton(struct i2c_client *cp,
528 unsigned int cmd,void *arg)
529 {
530 int stat;
531 if (!cp) return -EINVAL;
532 if (!(cp->driver)) return -EINVAL;
533 if (!(cp->driver->command)) return -EINVAL;
534 if (!try_module_get(cp->driver->driver.owner)) return -EAGAIN;
535 stat = cp->driver->command(cp,cmd,arg);
536 module_put(cp->driver->driver.owner);
537 return stat;
538 }
539
pvr2_i2c_client_cmd(struct pvr2_i2c_client * cp,unsigned int cmd,void * arg)540 int pvr2_i2c_client_cmd(struct pvr2_i2c_client *cp,unsigned int cmd,void *arg)
541 {
542 int stat;
543 if (pvrusb2_debug & PVR2_TRACE_I2C_CMD) {
544 char buf[100];
545 unsigned int cnt;
546 cnt = pvr2_i2c_client_describe(cp,PVR2_I2C_DETAIL_DEBUG,
547 buf,sizeof(buf));
548 pvr2_trace(PVR2_TRACE_I2C_CMD,
549 "i2c COMMAND (code=%u 0x%x) to %.*s",
550 cmd,cmd,cnt,buf);
551 }
552 stat = pvr2_i2c_core_singleton(cp->client,cmd,arg);
553 if (pvrusb2_debug & PVR2_TRACE_I2C_CMD) {
554 char buf[100];
555 unsigned int cnt;
556 cnt = pvr2_i2c_client_describe(cp,PVR2_I2C_DETAIL_DEBUG,
557 buf,sizeof(buf));
558 pvr2_trace(PVR2_TRACE_I2C_CMD,
559 "i2c COMMAND to %.*s (ret=%d)",cnt,buf,stat);
560 }
561 return stat;
562 }
563
pvr2_i2c_core_cmd(struct pvr2_hdw * hdw,unsigned int cmd,void * arg)564 int pvr2_i2c_core_cmd(struct pvr2_hdw *hdw,unsigned int cmd,void *arg)
565 {
566 struct pvr2_i2c_client *cp, *ncp;
567 int stat = -EINVAL;
568
569 if (!hdw) return stat;
570
571 mutex_lock(&hdw->i2c_list_lock);
572 list_for_each_entry_safe(cp, ncp, &hdw->i2c_clients, list) {
573 if (!cp->recv_enable) continue;
574 mutex_unlock(&hdw->i2c_list_lock);
575 stat = pvr2_i2c_client_cmd(cp,cmd,arg);
576 mutex_lock(&hdw->i2c_list_lock);
577 }
578 mutex_unlock(&hdw->i2c_list_lock);
579 return stat;
580 }
581
582
handler_check(struct pvr2_i2c_client * cp)583 static int handler_check(struct pvr2_i2c_client *cp)
584 {
585 struct pvr2_i2c_handler *hp = cp->handler;
586 if (!hp) return 0;
587 if (!hp->func_table->check) return 0;
588 return hp->func_table->check(hp->func_data) != 0;
589 }
590
591 #define BUFSIZE 500
592
593
pvr2_i2c_core_status_poll(struct pvr2_hdw * hdw)594 void pvr2_i2c_core_status_poll(struct pvr2_hdw *hdw)
595 {
596 struct pvr2_i2c_client *cp;
597 mutex_lock(&hdw->i2c_list_lock); do {
598 struct v4l2_tuner *vtp = &hdw->tuner_signal_info;
599 memset(vtp,0,sizeof(*vtp));
600 list_for_each_entry(cp, &hdw->i2c_clients, list) {
601 if (!cp->detected_flag) continue;
602 if (!cp->status_poll) continue;
603 cp->status_poll(cp);
604 }
605 hdw->tuner_signal_stale = 0;
606 pvr2_trace(PVR2_TRACE_CHIPS,"i2c status poll"
607 " type=%u strength=%u audio=0x%x cap=0x%x"
608 " low=%u hi=%u",
609 vtp->type,
610 vtp->signal,vtp->rxsubchans,vtp->capability,
611 vtp->rangelow,vtp->rangehigh);
612 } while (0); mutex_unlock(&hdw->i2c_list_lock);
613 }
614
615
616 /* Issue various I2C operations to bring chip-level drivers into sync with
617 state stored in this driver. */
pvr2_i2c_core_sync(struct pvr2_hdw * hdw)618 void pvr2_i2c_core_sync(struct pvr2_hdw *hdw)
619 {
620 unsigned long msk;
621 unsigned int idx;
622 struct pvr2_i2c_client *cp, *ncp;
623
624 if (!hdw->i2c_linked) return;
625 if (!(hdw->i2c_pend_types & PVR2_I2C_PEND_ALL)) {
626 return;
627 }
628 mutex_lock(&hdw->i2c_list_lock); do {
629 pvr2_trace(PVR2_TRACE_I2C_CORE,"i2c: core_sync BEGIN");
630 if (hdw->i2c_pend_types & PVR2_I2C_PEND_DETECT) {
631 /* One or more I2C clients have attached since we
632 last synced. So scan the list and identify the
633 new clients. */
634 char *buf;
635 unsigned int cnt;
636 unsigned long amask = 0;
637 buf = kmalloc(BUFSIZE,GFP_KERNEL);
638 pvr2_trace(PVR2_TRACE_I2C_CORE,"i2c: PEND_DETECT");
639 hdw->i2c_pend_types &= ~PVR2_I2C_PEND_DETECT;
640 list_for_each_entry(cp, &hdw->i2c_clients, list) {
641 if (!cp->detected_flag) {
642 cp->ctl_mask = 0;
643 pvr2_i2c_probe(hdw,cp);
644 cp->detected_flag = !0;
645 msk = cp->ctl_mask;
646 cnt = 0;
647 if (buf) {
648 cnt = pvr2_i2c_client_describe(
649 cp,
650 PVR2_I2C_DETAIL_ALL,
651 buf,BUFSIZE);
652 }
653 trace_i2c("Probed: %.*s",cnt,buf);
654 if (handler_check(cp)) {
655 hdw->i2c_pend_types |=
656 PVR2_I2C_PEND_CLIENT;
657 }
658 cp->pend_mask = msk;
659 hdw->i2c_pend_mask |= msk;
660 hdw->i2c_pend_types |=
661 PVR2_I2C_PEND_REFRESH;
662 }
663 amask |= cp->ctl_mask;
664 }
665 hdw->i2c_active_mask = amask;
666 if (buf) kfree(buf);
667 }
668 if (hdw->i2c_pend_types & PVR2_I2C_PEND_STALE) {
669 /* Need to do one or more global updates. Arrange
670 for this to happen. */
671 unsigned long m2;
672 pvr2_trace(PVR2_TRACE_I2C_CORE,
673 "i2c: PEND_STALE (0x%lx)",
674 hdw->i2c_stale_mask);
675 hdw->i2c_pend_types &= ~PVR2_I2C_PEND_STALE;
676 list_for_each_entry(cp, &hdw->i2c_clients, list) {
677 m2 = hdw->i2c_stale_mask;
678 m2 &= cp->ctl_mask;
679 m2 &= ~cp->pend_mask;
680 if (m2) {
681 pvr2_trace(PVR2_TRACE_I2C_CORE,
682 "i2c: cp=%p setting 0x%lx",
683 cp,m2);
684 cp->pend_mask |= m2;
685 }
686 }
687 hdw->i2c_pend_mask |= hdw->i2c_stale_mask;
688 hdw->i2c_stale_mask = 0;
689 hdw->i2c_pend_types |= PVR2_I2C_PEND_REFRESH;
690 }
691 if (hdw->i2c_pend_types & PVR2_I2C_PEND_CLIENT) {
692 /* One or more client handlers are asking for an
693 update. Run through the list of known clients
694 and update each one. */
695 pvr2_trace(PVR2_TRACE_I2C_CORE,"i2c: PEND_CLIENT");
696 hdw->i2c_pend_types &= ~PVR2_I2C_PEND_CLIENT;
697 list_for_each_entry_safe(cp, ncp, &hdw->i2c_clients,
698 list) {
699 if (!cp->handler) continue;
700 if (!cp->handler->func_table->update) continue;
701 pvr2_trace(PVR2_TRACE_I2C_CORE,
702 "i2c: cp=%p update",cp);
703 mutex_unlock(&hdw->i2c_list_lock);
704 cp->handler->func_table->update(
705 cp->handler->func_data);
706 mutex_lock(&hdw->i2c_list_lock);
707 /* If client's update function set some
708 additional pending bits, account for that
709 here. */
710 if (cp->pend_mask & ~hdw->i2c_pend_mask) {
711 hdw->i2c_pend_mask |= cp->pend_mask;
712 hdw->i2c_pend_types |=
713 PVR2_I2C_PEND_REFRESH;
714 }
715 }
716 }
717 if (hdw->i2c_pend_types & PVR2_I2C_PEND_REFRESH) {
718 const struct pvr2_i2c_op *opf;
719 unsigned long pm;
720 /* Some actual updates are pending. Walk through
721 each update type and perform it. */
722 pvr2_trace(PVR2_TRACE_I2C_CORE,"i2c: PEND_REFRESH"
723 " (0x%lx)",hdw->i2c_pend_mask);
724 hdw->i2c_pend_types &= ~PVR2_I2C_PEND_REFRESH;
725 pm = hdw->i2c_pend_mask;
726 hdw->i2c_pend_mask = 0;
727 for (idx = 0, msk = 1; pm; idx++, msk <<= 1) {
728 if (!(pm & msk)) continue;
729 pm &= ~msk;
730 list_for_each_entry(cp, &hdw->i2c_clients,
731 list) {
732 if (cp->pend_mask & msk) {
733 cp->pend_mask &= ~msk;
734 cp->recv_enable = !0;
735 } else {
736 cp->recv_enable = 0;
737 }
738 }
739 opf = pvr2_i2c_get_op(idx);
740 if (!opf) continue;
741 mutex_unlock(&hdw->i2c_list_lock);
742 opf->update(hdw);
743 mutex_lock(&hdw->i2c_list_lock);
744 }
745 }
746 pvr2_trace(PVR2_TRACE_I2C_CORE,"i2c: core_sync END");
747 } while (0); mutex_unlock(&hdw->i2c_list_lock);
748 }
749
pvr2_i2c_core_check_stale(struct pvr2_hdw * hdw)750 int pvr2_i2c_core_check_stale(struct pvr2_hdw *hdw)
751 {
752 unsigned long msk,sm,pm;
753 unsigned int idx;
754 const struct pvr2_i2c_op *opf;
755 struct pvr2_i2c_client *cp;
756 unsigned int pt = 0;
757
758 pvr2_trace(PVR2_TRACE_I2C_CORE,"pvr2_i2c_core_check_stale BEGIN");
759
760 pm = hdw->i2c_active_mask;
761 sm = 0;
762 for (idx = 0, msk = 1; pm; idx++, msk <<= 1) {
763 if (!(msk & pm)) continue;
764 pm &= ~msk;
765 opf = pvr2_i2c_get_op(idx);
766 if (!opf) continue;
767 if (opf->check(hdw)) {
768 sm |= msk;
769 }
770 }
771 if (sm) pt |= PVR2_I2C_PEND_STALE;
772
773 list_for_each_entry(cp, &hdw->i2c_clients, list)
774 if (handler_check(cp))
775 pt |= PVR2_I2C_PEND_CLIENT;
776
777 if (pt) {
778 mutex_lock(&hdw->i2c_list_lock); do {
779 hdw->i2c_pend_types |= pt;
780 hdw->i2c_stale_mask |= sm;
781 hdw->i2c_pend_mask |= hdw->i2c_stale_mask;
782 } while (0); mutex_unlock(&hdw->i2c_list_lock);
783 }
784
785 pvr2_trace(PVR2_TRACE_I2C_CORE,
786 "i2c: types=0x%x stale=0x%lx pend=0x%lx",
787 hdw->i2c_pend_types,
788 hdw->i2c_stale_mask,
789 hdw->i2c_pend_mask);
790 pvr2_trace(PVR2_TRACE_I2C_CORE,"pvr2_i2c_core_check_stale END");
791
792 return (hdw->i2c_pend_types & PVR2_I2C_PEND_ALL) != 0;
793 }
794
pvr2_i2c_client_describe(struct pvr2_i2c_client * cp,unsigned int detail,char * buf,unsigned int maxlen)795 static unsigned int pvr2_i2c_client_describe(struct pvr2_i2c_client *cp,
796 unsigned int detail,
797 char *buf,unsigned int maxlen)
798 {
799 unsigned int ccnt,bcnt;
800 int spcfl = 0;
801 const struct pvr2_i2c_op *opf;
802
803 ccnt = 0;
804 if (detail & PVR2_I2C_DETAIL_DEBUG) {
805 bcnt = scnprintf(buf,maxlen,
806 "ctxt=%p ctl_mask=0x%lx",
807 cp,cp->ctl_mask);
808 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
809 spcfl = !0;
810 }
811 bcnt = scnprintf(buf,maxlen,
812 "%s%s @ 0x%x",
813 (spcfl ? " " : ""),
814 cp->client->name,
815 cp->client->addr);
816 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
817 if ((detail & PVR2_I2C_DETAIL_HANDLER) &&
818 cp->handler && cp->handler->func_table->describe) {
819 bcnt = scnprintf(buf,maxlen," (");
820 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
821 bcnt = cp->handler->func_table->describe(
822 cp->handler->func_data,buf,maxlen);
823 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
824 bcnt = scnprintf(buf,maxlen,")");
825 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
826 }
827 if ((detail & PVR2_I2C_DETAIL_CTLMASK) && cp->ctl_mask) {
828 unsigned int idx;
829 unsigned long msk,sm;
830
831 bcnt = scnprintf(buf,maxlen," [");
832 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
833 sm = 0;
834 spcfl = 0;
835 for (idx = 0, msk = 1; msk; idx++, msk <<= 1) {
836 if (!(cp->ctl_mask & msk)) continue;
837 opf = pvr2_i2c_get_op(idx);
838 if (opf) {
839 bcnt = scnprintf(buf,maxlen,"%s%s",
840 spcfl ? " " : "",
841 opf->name);
842 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
843 spcfl = !0;
844 } else {
845 sm |= msk;
846 }
847 }
848 if (sm) {
849 bcnt = scnprintf(buf,maxlen,"%s%lx",
850 idx != 0 ? " " : "",sm);
851 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
852 }
853 bcnt = scnprintf(buf,maxlen,"]");
854 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
855 }
856 return ccnt;
857 }
858
pvr2_i2c_report(struct pvr2_hdw * hdw,char * buf,unsigned int maxlen)859 unsigned int pvr2_i2c_report(struct pvr2_hdw *hdw,
860 char *buf,unsigned int maxlen)
861 {
862 unsigned int ccnt,bcnt;
863 struct pvr2_i2c_client *cp;
864 ccnt = 0;
865 mutex_lock(&hdw->i2c_list_lock); do {
866 list_for_each_entry(cp, &hdw->i2c_clients, list) {
867 bcnt = pvr2_i2c_client_describe(
868 cp,
869 (PVR2_I2C_DETAIL_HANDLER|
870 PVR2_I2C_DETAIL_CTLMASK),
871 buf,maxlen);
872 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
873 bcnt = scnprintf(buf,maxlen,"\n");
874 ccnt += bcnt; buf += bcnt; maxlen -= bcnt;
875 }
876 } while (0); mutex_unlock(&hdw->i2c_list_lock);
877 return ccnt;
878 }
879
pvr2_i2c_attach_inform(struct i2c_client * client)880 static int pvr2_i2c_attach_inform(struct i2c_client *client)
881 {
882 struct pvr2_hdw *hdw = (struct pvr2_hdw *)(client->adapter->algo_data);
883 struct pvr2_i2c_client *cp;
884 int fl = !(hdw->i2c_pend_types & PVR2_I2C_PEND_ALL);
885 cp = kzalloc(sizeof(*cp),GFP_KERNEL);
886 trace_i2c("i2c_attach [client=%s @ 0x%x ctxt=%p]",
887 client->name,
888 client->addr,cp);
889 if (!cp) return -ENOMEM;
890 cp->hdw = hdw;
891 INIT_LIST_HEAD(&cp->list);
892 cp->client = client;
893 mutex_lock(&hdw->i2c_list_lock); do {
894 hdw->cropcap_stale = !0;
895 list_add_tail(&cp->list,&hdw->i2c_clients);
896 hdw->i2c_pend_types |= PVR2_I2C_PEND_DETECT;
897 } while (0); mutex_unlock(&hdw->i2c_list_lock);
898 if (fl) queue_work(hdw->workqueue,&hdw->worki2csync);
899 return 0;
900 }
901
pvr2_i2c_detach_inform(struct i2c_client * client)902 static int pvr2_i2c_detach_inform(struct i2c_client *client)
903 {
904 struct pvr2_hdw *hdw = (struct pvr2_hdw *)(client->adapter->algo_data);
905 struct pvr2_i2c_client *cp, *ncp;
906 unsigned long amask = 0;
907 int foundfl = 0;
908 mutex_lock(&hdw->i2c_list_lock); do {
909 hdw->cropcap_stale = !0;
910 list_for_each_entry_safe(cp, ncp, &hdw->i2c_clients, list) {
911 if (cp->client == client) {
912 trace_i2c("pvr2_i2c_detach"
913 " [client=%s @ 0x%x ctxt=%p]",
914 client->name,
915 client->addr,cp);
916 if (cp->handler &&
917 cp->handler->func_table->detach) {
918 cp->handler->func_table->detach(
919 cp->handler->func_data);
920 }
921 list_del(&cp->list);
922 kfree(cp);
923 foundfl = !0;
924 continue;
925 }
926 amask |= cp->ctl_mask;
927 }
928 hdw->i2c_active_mask = amask;
929 } while (0); mutex_unlock(&hdw->i2c_list_lock);
930 if (!foundfl) {
931 trace_i2c("pvr2_i2c_detach [client=%s @ 0x%x ctxt=<unknown>]",
932 client->name,
933 client->addr);
934 }
935 return 0;
936 }
937
938 static struct i2c_algorithm pvr2_i2c_algo_template = {
939 .master_xfer = pvr2_i2c_xfer,
940 .functionality = pvr2_i2c_functionality,
941 };
942
943 static struct i2c_adapter pvr2_i2c_adap_template = {
944 .owner = THIS_MODULE,
945 .class = I2C_CLASS_TV_ANALOG,
946 .id = I2C_HW_B_BT848,
947 .client_register = pvr2_i2c_attach_inform,
948 .client_unregister = pvr2_i2c_detach_inform,
949 };
950
951
952 /* Return true if device exists at given address */
do_i2c_probe(struct pvr2_hdw * hdw,int addr)953 static int do_i2c_probe(struct pvr2_hdw *hdw, int addr)
954 {
955 struct i2c_msg msg[1];
956 int rc;
957 msg[0].addr = 0;
958 msg[0].flags = I2C_M_RD;
959 msg[0].len = 0;
960 msg[0].buf = NULL;
961 msg[0].addr = addr;
962 rc = i2c_transfer(&hdw->i2c_adap, msg, ARRAY_SIZE(msg));
963 return rc == 1;
964 }
965
do_i2c_scan(struct pvr2_hdw * hdw)966 static void do_i2c_scan(struct pvr2_hdw *hdw)
967 {
968 int i;
969 printk(KERN_INFO "%s: i2c scan beginning\n", hdw->name);
970 for (i = 0; i < 128; i++) {
971 if (do_i2c_probe(hdw, i)) {
972 printk(KERN_INFO "%s: i2c scan: found device @ 0x%x\n",
973 hdw->name, i);
974 }
975 }
976 printk(KERN_INFO "%s: i2c scan done.\n", hdw->name);
977 }
978
pvr2_i2c_core_init(struct pvr2_hdw * hdw)979 void pvr2_i2c_core_init(struct pvr2_hdw *hdw)
980 {
981 unsigned int idx;
982
983 /* The default action for all possible I2C addresses is just to do
984 the transfer normally. */
985 for (idx = 0; idx < PVR2_I2C_FUNC_CNT; idx++) {
986 hdw->i2c_func[idx] = pvr2_i2c_basic_op;
987 }
988
989 /* However, deal with various special cases for 24xxx hardware. */
990 if (ir_mode[hdw->unit_number] == 0) {
991 printk(KERN_INFO "%s: IR disabled\n",hdw->name);
992 hdw->i2c_func[0x18] = i2c_black_hole;
993 } else if (ir_mode[hdw->unit_number] == 1) {
994 if (hdw->hdw_desc->ir_scheme == PVR2_IR_SCHEME_24XXX) {
995 hdw->i2c_func[0x18] = i2c_24xxx_ir;
996 }
997 }
998 if (hdw->hdw_desc->flag_has_cx25840) {
999 hdw->i2c_func[0x44] = i2c_hack_cx25840;
1000 }
1001 if (hdw->hdw_desc->flag_has_wm8775) {
1002 hdw->i2c_func[0x1b] = i2c_hack_wm8775;
1003 }
1004
1005 // Configure the adapter and set up everything else related to it.
1006 memcpy(&hdw->i2c_adap,&pvr2_i2c_adap_template,sizeof(hdw->i2c_adap));
1007 memcpy(&hdw->i2c_algo,&pvr2_i2c_algo_template,sizeof(hdw->i2c_algo));
1008 strlcpy(hdw->i2c_adap.name,hdw->name,sizeof(hdw->i2c_adap.name));
1009 hdw->i2c_adap.dev.parent = &hdw->usb_dev->dev;
1010 hdw->i2c_adap.algo = &hdw->i2c_algo;
1011 hdw->i2c_adap.algo_data = hdw;
1012 hdw->i2c_pend_mask = 0;
1013 hdw->i2c_stale_mask = 0;
1014 hdw->i2c_active_mask = 0;
1015 INIT_LIST_HEAD(&hdw->i2c_clients);
1016 mutex_init(&hdw->i2c_list_lock);
1017 hdw->i2c_linked = !0;
1018 i2c_add_adapter(&hdw->i2c_adap);
1019 if (hdw->i2c_func[0x18] == i2c_24xxx_ir) {
1020 /* Probe for a different type of IR receiver on this
1021 device. If present, disable the emulated IR receiver. */
1022 if (do_i2c_probe(hdw, 0x71)) {
1023 pvr2_trace(PVR2_TRACE_INFO,
1024 "Device has newer IR hardware;"
1025 " disabling unneeded virtual IR device");
1026 hdw->i2c_func[0x18] = NULL;
1027 }
1028 }
1029 if (i2c_scan) do_i2c_scan(hdw);
1030 }
1031
pvr2_i2c_core_done(struct pvr2_hdw * hdw)1032 void pvr2_i2c_core_done(struct pvr2_hdw *hdw)
1033 {
1034 if (hdw->i2c_linked) {
1035 i2c_del_adapter(&hdw->i2c_adap);
1036 hdw->i2c_linked = 0;
1037 }
1038 }
1039
1040 /*
1041 Stuff for Emacs to see, in order to encourage consistent editing style:
1042 *** Local Variables: ***
1043 *** mode: c ***
1044 *** fill-column: 75 ***
1045 *** tab-width: 8 ***
1046 *** c-basic-offset: 8 ***
1047 *** End: ***
1048 */
1049