5 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "pvrusb2-i2c-core.h"
23 #include "pvrusb2-hdw-internal.h"
24 #include "pvrusb2-debug.h"
26 #define trace_i2c(...) pvr2_trace(PVR2_TRACE_I2C,__VA_ARGS__)
30 This module attempts to implement a compliant I2C adapter for the pvrusb2
31 device. By doing this we can then make use of existing functionality in
32 V4L (e.g. tuner.c) rather than rolling our own.
36 static unsigned int i2c_scan
= 0;
37 module_param(i2c_scan
, int, S_IRUGO
|S_IWUSR
);
38 MODULE_PARM_DESC(i2c_scan
,"scan i2c bus at insmod time");
40 static unsigned int pvr2_i2c_client_describe(struct pvr2_i2c_client
*cp
,
42 char *buf
,unsigned int maxlen
);
44 static int pvr2_i2c_write(struct pvr2_hdw
*hdw
, /* Context */
45 u8 i2c_addr
, /* I2C address we're talking to */
46 u8
*data
, /* Data to write */
47 u16 length
) /* Size of data to write */
49 /* Return value - default 0 means success */
53 if (!data
) length
= 0;
54 if (length
> (sizeof(hdw
->cmd_buffer
) - 3)) {
55 pvr2_trace(PVR2_TRACE_ERROR_LEGS
,
56 "Killing an I2C write to %u that is too large"
57 " (desired=%u limit=%u)",
59 length
,(unsigned int)(sizeof(hdw
->cmd_buffer
) - 3));
63 LOCK_TAKE(hdw
->ctl_lock
);
65 /* Clear the command buffer (likely to be paranoia) */
66 memset(hdw
->cmd_buffer
, 0, sizeof(hdw
->cmd_buffer
));
68 /* Set up command buffer for an I2C write */
69 hdw
->cmd_buffer
[0] = 0x08; /* write prefix */
70 hdw
->cmd_buffer
[1] = i2c_addr
; /* i2c addr of chip */
71 hdw
->cmd_buffer
[2] = length
; /* length of what follows */
72 if (length
) memcpy(hdw
->cmd_buffer
+ 3, data
, length
);
74 /* Do the operation */
75 ret
= pvr2_send_request(hdw
,
81 if (hdw
->cmd_buffer
[0] != 8) {
83 if (hdw
->cmd_buffer
[0] != 7) {
84 trace_i2c("unexpected status"
85 " from i2_write[%d]: %d",
86 i2c_addr
,hdw
->cmd_buffer
[0]);
91 LOCK_GIVE(hdw
->ctl_lock
);
96 static int pvr2_i2c_read(struct pvr2_hdw
*hdw
, /* Context */
97 u8 i2c_addr
, /* I2C address we're talking to */
98 u8
*data
, /* Data to write */
99 u16 dlen
, /* Size of data to write */
100 u8
*res
, /* Where to put data we read */
101 u16 rlen
) /* Amount of data to read */
103 /* Return value - default 0 means success */
108 if (dlen
> (sizeof(hdw
->cmd_buffer
) - 4)) {
109 pvr2_trace(PVR2_TRACE_ERROR_LEGS
,
110 "Killing an I2C read to %u that has wlen too large"
111 " (desired=%u limit=%u)",
113 dlen
,(unsigned int)(sizeof(hdw
->cmd_buffer
) - 4));
116 if (res
&& (rlen
> (sizeof(hdw
->cmd_buffer
) - 1))) {
117 pvr2_trace(PVR2_TRACE_ERROR_LEGS
,
118 "Killing an I2C read to %u that has rlen too large"
119 " (desired=%u limit=%u)",
121 rlen
,(unsigned int)(sizeof(hdw
->cmd_buffer
) - 1));
125 LOCK_TAKE(hdw
->ctl_lock
);
127 /* Clear the command buffer (likely to be paranoia) */
128 memset(hdw
->cmd_buffer
, 0, sizeof(hdw
->cmd_buffer
));
130 /* Set up command buffer for an I2C write followed by a read */
131 hdw
->cmd_buffer
[0] = 0x09; /* read prefix */
132 hdw
->cmd_buffer
[1] = dlen
; /* arg length */
133 hdw
->cmd_buffer
[2] = rlen
; /* answer length. Device will send one
134 more byte (status). */
135 hdw
->cmd_buffer
[3] = i2c_addr
; /* i2c addr of chip */
136 if (dlen
) memcpy(hdw
->cmd_buffer
+ 4, data
, dlen
);
138 /* Do the operation */
139 ret
= pvr2_send_request(hdw
,
145 if (hdw
->cmd_buffer
[0] != 8) {
147 if (hdw
->cmd_buffer
[0] != 7) {
148 trace_i2c("unexpected status"
149 " from i2_read[%d]: %d",
150 i2c_addr
,hdw
->cmd_buffer
[0]);
155 /* Copy back the result */
158 /* Error, just blank out the return buffer */
159 memset(res
, 0, rlen
);
161 memcpy(res
, hdw
->cmd_buffer
+ 1, rlen
);
165 LOCK_GIVE(hdw
->ctl_lock
);
170 /* This is the common low level entry point for doing I2C operations to the
172 static int pvr2_i2c_basic_op(struct pvr2_hdw
*hdw
,
179 if (!rdata
) rlen
= 0;
180 if (!wdata
) wlen
= 0;
182 return pvr2_i2c_read(hdw
,i2c_addr
,wdata
,wlen
,rdata
,rlen
);
184 return pvr2_i2c_write(hdw
,i2c_addr
,wdata
,wlen
);
188 #ifdef CONFIG_VIDEO_PVRUSB2_24XXX
190 /* This is a special entry point that is entered if an I2C operation is
191 attempted to a wm8775 chip on model 24xxx hardware. Autodetect of this
192 part doesn't work, but we know it is really there. So let's look for
193 the autodetect attempt and just return success if we see that. */
194 static int i2c_hack_wm8775(struct pvr2_hdw
*hdw
,
195 u8 i2c_addr
,u8
*wdata
,u16 wlen
,u8
*rdata
,u16 rlen
)
197 if (!(rlen
|| wlen
)) {
198 // This is a probe attempt. Just let it succeed.
201 return pvr2_i2c_basic_op(hdw
,i2c_addr
,wdata
,wlen
,rdata
,rlen
);
204 /* This is a special entry point that is entered if an I2C operation is
205 attempted to a cx25840 chip on model 24xxx hardware. This chip can
206 sometimes wedge itself. Worse still, when this happens msp3400 can
207 falsely detect this part and then the system gets hosed up after msp3400
208 gets confused and dies. What we want to do here is try to keep msp3400
209 away and also try to notice if the chip is wedged and send a warning to
211 static int i2c_hack_cx25840(struct pvr2_hdw
*hdw
,
212 u8 i2c_addr
,u8
*wdata
,u16 wlen
,u8
*rdata
,u16 rlen
)
215 unsigned int subaddr
;
217 int state
= hdw
->i2c_cx25840_hack_state
;
219 if (!(rlen
|| wlen
)) {
220 // Probe attempt - always just succeed and don't bother the
221 // hardware (this helps to make the state machine further
222 // down somewhat easier).
227 return pvr2_i2c_basic_op(hdw
,i2c_addr
,wdata
,wlen
,rdata
,rlen
);
230 /* We're looking for the exact pattern where the revision register
231 is being read. The cx25840 module will always look at the
232 revision register first. Any other pattern of access therefore
233 has to be a probe attempt from somebody else so we'll reject it.
234 Normally we could just let each client just probe the part
235 anyway, but when the cx25840 is wedged, msp3400 will get a false
236 positive and that just screws things up... */
240 case 1: subaddr
= 0x0100; break;
241 case 2: subaddr
= 0x0101; break;
244 } else if (wlen
== 2) {
245 subaddr
= (wdata
[0] << 8) | wdata
[1];
247 case 0x0100: state
= 1; break;
248 case 0x0101: state
= 2; break;
254 if (!rlen
) goto success
;
256 if (rlen
!= 1) goto fail
;
258 /* If we get to here then we have a legitimate read for one of the
259 two revision bytes, so pass it through. */
260 wbuf
[0] = subaddr
>> 8;
262 ret
= pvr2_i2c_basic_op(hdw
,i2c_addr
,wbuf
,2,rdata
,rlen
);
264 if ((ret
!= 0) || (*rdata
== 0x04) || (*rdata
== 0x0a)) {
265 pvr2_trace(PVR2_TRACE_ERROR_LEGS
,
266 "WARNING: Detected a wedged cx25840 chip;"
267 " the device will not work.");
268 pvr2_trace(PVR2_TRACE_ERROR_LEGS
,
269 "WARNING: Try power cycling the pvrusb2 device.");
270 pvr2_trace(PVR2_TRACE_ERROR_LEGS
,
271 "WARNING: Disabling further access to the device"
272 " to prevent other foul-ups.");
273 // This blocks all further communication with the part.
274 hdw
->i2c_func
[0x44] = NULL
;
275 pvr2_hdw_render_useless(hdw
);
280 pvr2_trace(PVR2_TRACE_CHIPS
,"cx25840 appears to be OK.");
284 hdw
->i2c_cx25840_hack_state
= state
;
288 hdw
->i2c_cx25840_hack_state
= state
;
292 #endif /* CONFIG_VIDEO_PVRUSB2_24XXX */
294 /* This is a very, very limited I2C adapter implementation. We can only
295 support what we actually know will work on the device... */
296 static int pvr2_i2c_xfer(struct i2c_adapter
*i2c_adap
,
297 struct i2c_msg msgs
[],
301 pvr2_i2c_func funcp
= NULL
;
302 struct pvr2_hdw
*hdw
= (struct pvr2_hdw
*)(i2c_adap
->algo_data
);
308 if ((msgs
[0].flags
& I2C_M_NOSTART
)) {
309 trace_i2c("i2c refusing I2C_M_NOSTART");
312 if (msgs
[0].addr
< PVR2_I2C_FUNC_CNT
) {
313 funcp
= hdw
->i2c_func
[msgs
[0].addr
];
321 if (msgs
[0].flags
& I2C_M_RD
) {
325 /* Length == 0 read. This is a probe. */
326 if (funcp(hdw
,msgs
[0].addr
,NULL
,0,NULL
,0)) {
333 /* If the read is short enough we'll do the whole
334 thing atomically. Otherwise we have no choice
335 but to break apart the reads. */
340 if (bcnt
> sizeof(hdw
->cmd_buffer
)-1) {
341 bcnt
= sizeof(hdw
->cmd_buffer
)-1;
343 if (funcp(hdw
,msgs
[0].addr
,NULL
,0,
344 msgs
[0].buf
+offs
,bcnt
)) {
356 if (funcp(hdw
,msgs
[0].addr
,
357 msgs
[0].buf
,msgs
[0].len
,NULL
,0)) {
362 } else if (num
== 2) {
363 if (msgs
[0].addr
!= msgs
[1].addr
) {
364 trace_i2c("i2c refusing 2 phase transfer with"
365 " conflicting target addresses");
369 if ((!((msgs
[0].flags
& I2C_M_RD
))) &&
370 (msgs
[1].flags
& I2C_M_RD
)) {
371 u16 tcnt
,bcnt
,wcnt
,offs
;
372 /* Write followed by atomic read. If the read
373 portion is short enough we'll do the whole thing
374 atomically. Otherwise we have no choice but to
375 break apart the reads. */
379 while (tcnt
|| wcnt
) {
381 if (bcnt
> sizeof(hdw
->cmd_buffer
)-1) {
382 bcnt
= sizeof(hdw
->cmd_buffer
)-1;
384 if (funcp(hdw
,msgs
[0].addr
,
386 msgs
[1].buf
+offs
,bcnt
)) {
397 trace_i2c("i2c refusing complex transfer"
398 " read0=%d read1=%d",
399 (msgs
[0].flags
& I2C_M_RD
),
400 (msgs
[1].flags
& I2C_M_RD
));
403 trace_i2c("i2c refusing %d phase transfer",num
);
407 if (pvrusb2_debug
& PVR2_TRACE_I2C_TRAF
) {
408 unsigned int idx
,offs
,cnt
;
409 for (idx
= 0; idx
< num
; idx
++) {
412 "pvrusb2 i2c xfer %u/%u:"
413 " addr=0x%x len=%d %s%s",
417 (msgs
[idx
].flags
& I2C_M_RD
?
419 (msgs
[idx
].flags
& I2C_M_NOSTART
?
421 if ((ret
> 0) || !(msgs
[idx
].flags
& I2C_M_RD
)) {
422 if (cnt
> 8) cnt
= 8;
424 for (offs
= 0; offs
< (cnt
>8?8:cnt
); offs
++) {
425 if (offs
) printk(" ");
426 printk("%02x",msgs
[idx
].buf
[offs
]);
428 if (offs
< cnt
) printk(" ...");
432 printk(" result=%d",ret
);
438 "pvrusb2 i2c xfer null transfer result=%d\n",
445 static int pvr2_i2c_control(struct i2c_adapter
*adapter
,
446 unsigned int cmd
, unsigned long arg
)
451 static u32
pvr2_i2c_functionality(struct i2c_adapter
*adap
)
453 return I2C_FUNC_SMBUS_EMUL
| I2C_FUNC_I2C
| I2C_FUNC_SMBUS_BYTE_DATA
;
456 static int pvr2_i2c_core_singleton(struct i2c_client
*cp
,
457 unsigned int cmd
,void *arg
)
460 if (!cp
) return -EINVAL
;
461 if (!(cp
->driver
)) return -EINVAL
;
462 if (!(cp
->driver
->command
)) return -EINVAL
;
463 if (!try_module_get(cp
->driver
->driver
.owner
)) return -EAGAIN
;
464 stat
= cp
->driver
->command(cp
,cmd
,arg
);
465 module_put(cp
->driver
->driver
.owner
);
469 int pvr2_i2c_client_cmd(struct pvr2_i2c_client
*cp
,unsigned int cmd
,void *arg
)
472 if (pvrusb2_debug
& PVR2_TRACE_I2C_CMD
) {
475 cnt
= pvr2_i2c_client_describe(cp
,PVR2_I2C_DETAIL_DEBUG
,
477 pvr2_trace(PVR2_TRACE_I2C_CMD
,
478 "i2c COMMAND (code=%u 0x%x) to %.*s",
481 stat
= pvr2_i2c_core_singleton(cp
->client
,cmd
,arg
);
482 if (pvrusb2_debug
& PVR2_TRACE_I2C_CMD
) {
485 cnt
= pvr2_i2c_client_describe(cp
,PVR2_I2C_DETAIL_DEBUG
,
487 pvr2_trace(PVR2_TRACE_I2C_CMD
,
488 "i2c COMMAND to %.*s (ret=%d)",cnt
,buf
,stat
);
493 int pvr2_i2c_core_cmd(struct pvr2_hdw
*hdw
,unsigned int cmd
,void *arg
)
495 struct list_head
*item
,*nc
;
496 struct pvr2_i2c_client
*cp
;
499 if (!hdw
) return stat
;
501 mutex_lock(&hdw
->i2c_list_lock
);
502 list_for_each_safe(item
,nc
,&hdw
->i2c_clients
) {
503 cp
= list_entry(item
,struct pvr2_i2c_client
,list
);
504 if (!cp
->recv_enable
) continue;
505 mutex_unlock(&hdw
->i2c_list_lock
);
506 stat
= pvr2_i2c_client_cmd(cp
,cmd
,arg
);
507 mutex_lock(&hdw
->i2c_list_lock
);
509 mutex_unlock(&hdw
->i2c_list_lock
);
514 static int handler_check(struct pvr2_i2c_client
*cp
)
516 struct pvr2_i2c_handler
*hp
= cp
->handler
;
518 if (!hp
->func_table
->check
) return 0;
519 return hp
->func_table
->check(hp
->func_data
) != 0;
524 void pvr2_i2c_core_sync(struct pvr2_hdw
*hdw
)
528 struct list_head
*item
,*nc
;
529 struct pvr2_i2c_client
*cp
;
531 if (!hdw
->i2c_linked
) return;
532 if (!(hdw
->i2c_pend_types
& PVR2_I2C_PEND_ALL
)) {
535 mutex_lock(&hdw
->i2c_list_lock
); do {
536 pvr2_trace(PVR2_TRACE_I2C_CORE
,"i2c: core_sync BEGIN");
537 if (hdw
->i2c_pend_types
& PVR2_I2C_PEND_DETECT
) {
538 /* One or more I2C clients have attached since we
539 last synced. So scan the list and identify the
543 unsigned long amask
= 0;
544 buf
= kmalloc(BUFSIZE
,GFP_KERNEL
);
545 pvr2_trace(PVR2_TRACE_I2C_CORE
,"i2c: PEND_DETECT");
546 hdw
->i2c_pend_types
&= ~PVR2_I2C_PEND_DETECT
;
547 list_for_each(item
,&hdw
->i2c_clients
) {
548 cp
= list_entry(item
,struct pvr2_i2c_client
,
550 if (!cp
->detected_flag
) {
552 pvr2_i2c_probe(hdw
,cp
);
553 cp
->detected_flag
= !0;
557 cnt
= pvr2_i2c_client_describe(
562 trace_i2c("Probed: %.*s",cnt
,buf
);
563 if (handler_check(cp
)) {
564 hdw
->i2c_pend_types
|=
565 PVR2_I2C_PEND_CLIENT
;
568 hdw
->i2c_pend_mask
|= msk
;
569 hdw
->i2c_pend_types
|=
570 PVR2_I2C_PEND_REFRESH
;
572 amask
|= cp
->ctl_mask
;
574 hdw
->i2c_active_mask
= amask
;
577 if (hdw
->i2c_pend_types
& PVR2_I2C_PEND_STALE
) {
578 /* Need to do one or more global updates. Arrange
579 for this to happen. */
581 pvr2_trace(PVR2_TRACE_I2C_CORE
,
582 "i2c: PEND_STALE (0x%lx)",
583 hdw
->i2c_stale_mask
);
584 hdw
->i2c_pend_types
&= ~PVR2_I2C_PEND_STALE
;
585 list_for_each(item
,&hdw
->i2c_clients
) {
586 cp
= list_entry(item
,struct pvr2_i2c_client
,
588 m2
= hdw
->i2c_stale_mask
;
590 m2
&= ~cp
->pend_mask
;
592 pvr2_trace(PVR2_TRACE_I2C_CORE
,
593 "i2c: cp=%p setting 0x%lx",
598 hdw
->i2c_pend_mask
|= hdw
->i2c_stale_mask
;
599 hdw
->i2c_stale_mask
= 0;
600 hdw
->i2c_pend_types
|= PVR2_I2C_PEND_REFRESH
;
602 if (hdw
->i2c_pend_types
& PVR2_I2C_PEND_CLIENT
) {
603 /* One or more client handlers are asking for an
604 update. Run through the list of known clients
605 and update each one. */
606 pvr2_trace(PVR2_TRACE_I2C_CORE
,"i2c: PEND_CLIENT");
607 hdw
->i2c_pend_types
&= ~PVR2_I2C_PEND_CLIENT
;
608 list_for_each_safe(item
,nc
,&hdw
->i2c_clients
) {
609 cp
= list_entry(item
,struct pvr2_i2c_client
,
611 if (!cp
->handler
) continue;
612 if (!cp
->handler
->func_table
->update
) continue;
613 pvr2_trace(PVR2_TRACE_I2C_CORE
,
614 "i2c: cp=%p update",cp
);
615 mutex_unlock(&hdw
->i2c_list_lock
);
616 cp
->handler
->func_table
->update(
617 cp
->handler
->func_data
);
618 mutex_lock(&hdw
->i2c_list_lock
);
619 /* If client's update function set some
620 additional pending bits, account for that
622 if (cp
->pend_mask
& ~hdw
->i2c_pend_mask
) {
623 hdw
->i2c_pend_mask
|= cp
->pend_mask
;
624 hdw
->i2c_pend_types
|=
625 PVR2_I2C_PEND_REFRESH
;
629 if (hdw
->i2c_pend_types
& PVR2_I2C_PEND_REFRESH
) {
630 const struct pvr2_i2c_op
*opf
;
632 /* Some actual updates are pending. Walk through
633 each update type and perform it. */
634 pvr2_trace(PVR2_TRACE_I2C_CORE
,"i2c: PEND_REFRESH"
635 " (0x%lx)",hdw
->i2c_pend_mask
);
636 hdw
->i2c_pend_types
&= ~PVR2_I2C_PEND_REFRESH
;
637 pm
= hdw
->i2c_pend_mask
;
638 hdw
->i2c_pend_mask
= 0;
639 for (idx
= 0, msk
= 1; pm
; idx
++, msk
<<= 1) {
640 if (!(pm
& msk
)) continue;
642 list_for_each(item
,&hdw
->i2c_clients
) {
643 cp
= list_entry(item
,
644 struct pvr2_i2c_client
,
646 if (cp
->pend_mask
& msk
) {
647 cp
->pend_mask
&= ~msk
;
648 cp
->recv_enable
= !0;
653 opf
= pvr2_i2c_get_op(idx
);
655 mutex_unlock(&hdw
->i2c_list_lock
);
657 mutex_lock(&hdw
->i2c_list_lock
);
660 pvr2_trace(PVR2_TRACE_I2C_CORE
,"i2c: core_sync END");
661 } while (0); mutex_unlock(&hdw
->i2c_list_lock
);
664 int pvr2_i2c_core_check_stale(struct pvr2_hdw
*hdw
)
666 unsigned long msk
,sm
,pm
;
668 const struct pvr2_i2c_op
*opf
;
669 struct list_head
*item
;
670 struct pvr2_i2c_client
*cp
;
673 pvr2_trace(PVR2_TRACE_I2C_CORE
,"pvr2_i2c_core_check_stale BEGIN");
675 pm
= hdw
->i2c_active_mask
;
677 for (idx
= 0, msk
= 1; pm
; idx
++, msk
<<= 1) {
678 if (!(msk
& pm
)) continue;
680 opf
= pvr2_i2c_get_op(idx
);
682 if (opf
->check(hdw
)) {
686 if (sm
) pt
|= PVR2_I2C_PEND_STALE
;
688 list_for_each(item
,&hdw
->i2c_clients
) {
689 cp
= list_entry(item
,struct pvr2_i2c_client
,list
);
690 if (!handler_check(cp
)) continue;
691 pt
|= PVR2_I2C_PEND_CLIENT
;
695 mutex_lock(&hdw
->i2c_list_lock
); do {
696 hdw
->i2c_pend_types
|= pt
;
697 hdw
->i2c_stale_mask
|= sm
;
698 hdw
->i2c_pend_mask
|= hdw
->i2c_stale_mask
;
699 } while (0); mutex_unlock(&hdw
->i2c_list_lock
);
702 pvr2_trace(PVR2_TRACE_I2C_CORE
,
703 "i2c: types=0x%x stale=0x%lx pend=0x%lx",
707 pvr2_trace(PVR2_TRACE_I2C_CORE
,"pvr2_i2c_core_check_stale END");
709 return (hdw
->i2c_pend_types
& PVR2_I2C_PEND_ALL
) != 0;
712 static unsigned int pvr2_i2c_client_describe(struct pvr2_i2c_client
*cp
,
714 char *buf
,unsigned int maxlen
)
716 unsigned int ccnt
,bcnt
;
718 const struct pvr2_i2c_op
*opf
;
721 if (detail
& PVR2_I2C_DETAIL_DEBUG
) {
722 bcnt
= scnprintf(buf
,maxlen
,
723 "ctxt=%p ctl_mask=0x%lx",
725 ccnt
+= bcnt
; buf
+= bcnt
; maxlen
-= bcnt
;
728 bcnt
= scnprintf(buf
,maxlen
,
733 ccnt
+= bcnt
; buf
+= bcnt
; maxlen
-= bcnt
;
734 if ((detail
& PVR2_I2C_DETAIL_HANDLER
) &&
735 cp
->handler
&& cp
->handler
->func_table
->describe
) {
736 bcnt
= scnprintf(buf
,maxlen
," (");
737 ccnt
+= bcnt
; buf
+= bcnt
; maxlen
-= bcnt
;
738 bcnt
= cp
->handler
->func_table
->describe(
739 cp
->handler
->func_data
,buf
,maxlen
);
740 ccnt
+= bcnt
; buf
+= bcnt
; maxlen
-= bcnt
;
741 bcnt
= scnprintf(buf
,maxlen
,")");
742 ccnt
+= bcnt
; buf
+= bcnt
; maxlen
-= bcnt
;
744 if ((detail
& PVR2_I2C_DETAIL_CTLMASK
) && cp
->ctl_mask
) {
746 unsigned long msk
,sm
;
748 bcnt
= scnprintf(buf
,maxlen
," [");
749 ccnt
+= bcnt
; buf
+= bcnt
; maxlen
-= bcnt
;
752 for (idx
= 0, msk
= 1; msk
; idx
++, msk
<<= 1) {
753 if (!(cp
->ctl_mask
& msk
)) continue;
754 opf
= pvr2_i2c_get_op(idx
);
756 bcnt
= scnprintf(buf
,maxlen
,"%s%s",
759 ccnt
+= bcnt
; buf
+= bcnt
; maxlen
-= bcnt
;
766 bcnt
= scnprintf(buf
,maxlen
,"%s%lx",
767 idx
!= 0 ? " " : "",sm
);
768 ccnt
+= bcnt
; buf
+= bcnt
; maxlen
-= bcnt
;
770 bcnt
= scnprintf(buf
,maxlen
,"]");
771 ccnt
+= bcnt
; buf
+= bcnt
; maxlen
-= bcnt
;
776 unsigned int pvr2_i2c_report(struct pvr2_hdw
*hdw
,
777 char *buf
,unsigned int maxlen
)
779 unsigned int ccnt
,bcnt
;
780 struct list_head
*item
;
781 struct pvr2_i2c_client
*cp
;
783 mutex_lock(&hdw
->i2c_list_lock
); do {
784 list_for_each(item
,&hdw
->i2c_clients
) {
785 cp
= list_entry(item
,struct pvr2_i2c_client
,list
);
786 bcnt
= pvr2_i2c_client_describe(
788 (PVR2_I2C_DETAIL_HANDLER
|
789 PVR2_I2C_DETAIL_CTLMASK
),
791 ccnt
+= bcnt
; buf
+= bcnt
; maxlen
-= bcnt
;
792 bcnt
= scnprintf(buf
,maxlen
,"\n");
793 ccnt
+= bcnt
; buf
+= bcnt
; maxlen
-= bcnt
;
795 } while (0); mutex_unlock(&hdw
->i2c_list_lock
);
799 static int pvr2_i2c_attach_inform(struct i2c_client
*client
)
801 struct pvr2_hdw
*hdw
= (struct pvr2_hdw
*)(client
->adapter
->algo_data
);
802 struct pvr2_i2c_client
*cp
;
803 int fl
= !(hdw
->i2c_pend_types
& PVR2_I2C_PEND_ALL
);
804 cp
= kmalloc(sizeof(*cp
),GFP_KERNEL
);
805 trace_i2c("i2c_attach [client=%s @ 0x%x ctxt=%p]",
808 if (!cp
) return -ENOMEM
;
809 memset(cp
,0,sizeof(*cp
));
810 INIT_LIST_HEAD(&cp
->list
);
812 mutex_lock(&hdw
->i2c_list_lock
); do {
813 list_add_tail(&cp
->list
,&hdw
->i2c_clients
);
814 hdw
->i2c_pend_types
|= PVR2_I2C_PEND_DETECT
;
815 } while (0); mutex_unlock(&hdw
->i2c_list_lock
);
816 if (fl
) pvr2_hdw_poll_trigger_unlocked(hdw
);
820 static int pvr2_i2c_detach_inform(struct i2c_client
*client
)
822 struct pvr2_hdw
*hdw
= (struct pvr2_hdw
*)(client
->adapter
->algo_data
);
823 struct pvr2_i2c_client
*cp
;
824 struct list_head
*item
,*nc
;
825 unsigned long amask
= 0;
827 mutex_lock(&hdw
->i2c_list_lock
); do {
828 list_for_each_safe(item
,nc
,&hdw
->i2c_clients
) {
829 cp
= list_entry(item
,struct pvr2_i2c_client
,list
);
830 if (cp
->client
== client
) {
831 trace_i2c("pvr2_i2c_detach"
832 " [client=%s @ 0x%x ctxt=%p]",
836 cp
->handler
->func_table
->detach
) {
837 cp
->handler
->func_table
->detach(
838 cp
->handler
->func_data
);
845 amask
|= cp
->ctl_mask
;
847 hdw
->i2c_active_mask
= amask
;
848 } while (0); mutex_unlock(&hdw
->i2c_list_lock
);
850 trace_i2c("pvr2_i2c_detach [client=%s @ 0x%x ctxt=<unknown>]",
857 static struct i2c_algorithm pvr2_i2c_algo_template
= {
858 .master_xfer
= pvr2_i2c_xfer
,
859 .algo_control
= pvr2_i2c_control
,
860 .functionality
= pvr2_i2c_functionality
,
863 static struct i2c_adapter pvr2_i2c_adap_template
= {
864 .owner
= THIS_MODULE
,
865 .class = I2C_CLASS_TV_ANALOG
,
866 .id
= I2C_HW_B_BT848
,
867 .client_register
= pvr2_i2c_attach_inform
,
868 .client_unregister
= pvr2_i2c_detach_inform
,
871 static void do_i2c_scan(struct pvr2_hdw
*hdw
)
873 struct i2c_msg msg
[1];
876 msg
[0].flags
= I2C_M_RD
;
879 printk("%s: i2c scan beginning\n",hdw
->name
);
880 for (i
= 0; i
< 128; i
++) {
882 rc
= i2c_transfer(&hdw
->i2c_adap
,msg
,
883 sizeof(msg
)/sizeof(msg
[0]));
884 if (rc
!= 1) continue;
885 printk("%s: i2c scan: found device @ 0x%x\n",hdw
->name
,i
);
887 printk("%s: i2c scan done.\n",hdw
->name
);
890 void pvr2_i2c_core_init(struct pvr2_hdw
*hdw
)
894 // The default action for all possible I2C addresses is just to do
895 // the transfer normally.
896 for (idx
= 0; idx
< PVR2_I2C_FUNC_CNT
; idx
++) {
897 hdw
->i2c_func
[idx
] = pvr2_i2c_basic_op
;
900 #ifdef CONFIG_VIDEO_PVRUSB2_24XXX
901 // If however we're dealing with new hardware, insert some hacks in
902 // the I2C transfer stack to let things work better.
903 if (hdw
->hdw_type
== PVR2_HDW_TYPE_24XXX
) {
904 hdw
->i2c_func
[0x1b] = i2c_hack_wm8775
;
905 hdw
->i2c_func
[0x44] = i2c_hack_cx25840
;
909 // Configure the adapter and set up everything else related to it.
910 memcpy(&hdw
->i2c_adap
,&pvr2_i2c_adap_template
,sizeof(hdw
->i2c_adap
));
911 memcpy(&hdw
->i2c_algo
,&pvr2_i2c_algo_template
,sizeof(hdw
->i2c_algo
));
912 strlcpy(hdw
->i2c_adap
.name
,hdw
->name
,sizeof(hdw
->i2c_adap
.name
));
913 hdw
->i2c_adap
.algo
= &hdw
->i2c_algo
;
914 hdw
->i2c_adap
.algo_data
= hdw
;
915 hdw
->i2c_pend_mask
= 0;
916 hdw
->i2c_stale_mask
= 0;
917 hdw
->i2c_active_mask
= 0;
918 INIT_LIST_HEAD(&hdw
->i2c_clients
);
919 mutex_init(&hdw
->i2c_list_lock
);
920 hdw
->i2c_linked
= !0;
921 i2c_add_adapter(&hdw
->i2c_adap
);
922 if (i2c_scan
) do_i2c_scan(hdw
);
925 void pvr2_i2c_core_done(struct pvr2_hdw
*hdw
)
927 if (hdw
->i2c_linked
) {
928 i2c_del_adapter(&hdw
->i2c_adap
);
934 Stuff for Emacs to see, in order to encourage consistent editing style:
935 *** Local Variables: ***
937 *** fill-column: 75 ***
939 *** c-basic-offset: 8 ***