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