V4L/DVB (6762): ivtv: update version number to 1.2
[linux-2.6] / drivers / media / video / ivtv / ivtv-i2c.c
1 /*
2     I2C functions
3     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
4     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
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, or
9     (at your option) any later version.
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     This file includes an i2c implementation that was reverse engineered
23     from the Hauppauge windows driver.  Older ivtv versions used i2c-algo-bit,
24     which whilst fine under most circumstances, had trouble with the Zilog
25     CPU on the PVR-150 which handles IR functions (occasional inability to
26     communicate with the chip until it was reset) and also with the i2c
27     bus being completely unreachable when multiple PVR cards were present.
28
29     The implementation is very similar to i2c-algo-bit, but there are enough
30     subtle differences that the two are hard to merge.  The general strategy
31     employed by i2c-algo-bit is to use udelay() to implement the timing
32     when putting out bits on the scl/sda lines.  The general strategy taken
33     here is to poll the lines for state changes (see ivtv_waitscl and
34     ivtv_waitsda).  In addition there are small delays at various locations
35     which poll the SCL line 5 times (ivtv_scldelay).  I would guess that
36     since this is memory mapped I/O that the length of those delays is tied
37     to the PCI bus clock.  There is some extra code to do with recovery
38     and retries.  Since it is not known what causes the actual i2c problems
39     in the first place, the only goal if one was to attempt to use
40     i2c-algo-bit would be to try to make it follow the same code path.
41     This would be a lot of work, and I'm also not convinced that it would
42     provide a generic benefit to i2c-algo-bit.  Therefore consider this
43     an engineering solution -- not pretty, but it works.
44
45     Some more general comments about what we are doing:
46
47     The i2c bus is a 2 wire serial bus, with clock (SCL) and data (SDA)
48     lines.  To communicate on the bus (as a master, we don't act as a slave),
49     we first initiate a start condition (ivtv_start).  We then write the
50     address of the device that we want to communicate with, along with a flag
51     that indicates whether this is a read or a write.  The slave then issues
52     an ACK signal (ivtv_ack), which tells us that it is ready for reading /
53     writing.  We then proceed with reading or writing (ivtv_read/ivtv_write),
54     and finally issue a stop condition (ivtv_stop) to make the bus available
55     to other masters.
56
57     There is an additional form of transaction where a write may be
58     immediately followed by a read.  In this case, there is no intervening
59     stop condition.  (Only the msp3400 chip uses this method of data transfer).
60  */
61
62 #include "ivtv-driver.h"
63 #include "ivtv-cards.h"
64 #include "ivtv-gpio.h"
65 #include "ivtv-i2c.h"
66
67 #include <media/ir-kbd-i2c.h>
68
69 /* i2c implementation for cx23415/6 chip, ivtv project.
70  * Author: Kevin Thayer (nufan_wfk at yahoo.com)
71  */
72 /* i2c stuff */
73 #define IVTV_REG_I2C_SETSCL_OFFSET 0x7000
74 #define IVTV_REG_I2C_SETSDA_OFFSET 0x7004
75 #define IVTV_REG_I2C_GETSCL_OFFSET 0x7008
76 #define IVTV_REG_I2C_GETSDA_OFFSET 0x700c
77
78 #ifndef I2C_ADAP_CLASS_TV_ANALOG
79 #define I2C_ADAP_CLASS_TV_ANALOG I2C_CLASS_TV_ANALOG
80 #endif /* I2C_ADAP_CLASS_TV_ANALOG */
81
82 #define IVTV_CS53L32A_I2C_ADDR          0x11
83 #define IVTV_M52790_I2C_ADDR            0x48
84 #define IVTV_CX25840_I2C_ADDR           0x44
85 #define IVTV_SAA7115_I2C_ADDR           0x21
86 #define IVTV_SAA7127_I2C_ADDR           0x44
87 #define IVTV_SAA717x_I2C_ADDR           0x21
88 #define IVTV_MSP3400_I2C_ADDR           0x40
89 #define IVTV_HAUPPAUGE_I2C_ADDR         0x50
90 #define IVTV_WM8739_I2C_ADDR            0x1a
91 #define IVTV_WM8775_I2C_ADDR            0x1b
92 #define IVTV_TEA5767_I2C_ADDR           0x60
93 #define IVTV_UPD64031A_I2C_ADDR         0x12
94 #define IVTV_UPD64083_I2C_ADDR          0x5c
95 #define IVTV_TDA985X_I2C_ADDR           0x5b
96
97 /* This array should match the IVTV_HW_ defines */
98 static const u8 hw_driverids[] = {
99         I2C_DRIVERID_CX25840,
100         I2C_DRIVERID_SAA711X,
101         I2C_DRIVERID_SAA7127,
102         I2C_DRIVERID_MSP3400,
103         I2C_DRIVERID_TUNER,
104         I2C_DRIVERID_WM8775,
105         I2C_DRIVERID_CS53L32A,
106         I2C_DRIVERID_TVEEPROM,
107         I2C_DRIVERID_SAA711X,
108         I2C_DRIVERID_TVAUDIO,
109         I2C_DRIVERID_UPD64031A,
110         I2C_DRIVERID_UPD64083,
111         I2C_DRIVERID_SAA717X,
112         I2C_DRIVERID_WM8739,
113         I2C_DRIVERID_VP27SMPX,
114         I2C_DRIVERID_M52790,
115         0               /* IVTV_HW_GPIO dummy driver ID */
116 };
117
118 /* This array should match the IVTV_HW_ defines */
119 static const char * const hw_drivernames[] = {
120         "cx2584x",
121         "saa7115",
122         "saa7127",
123         "msp3400",
124         "tuner",
125         "wm8775",
126         "cs53l32a",
127         "tveeprom",
128         "saa7114",
129         "tvaudio",
130         "upd64031a",
131         "upd64083",
132         "saa717x",
133         "wm8739",
134         "vp27smpx",
135         "m52790",
136         "gpio",
137 };
138
139 static int attach_inform(struct i2c_client *client)
140 {
141         struct ivtv *itv = (struct ivtv *)i2c_get_adapdata(client->adapter);
142         int i;
143
144         IVTV_DEBUG_I2C("i2c client attach\n");
145         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
146                 if (itv->i2c_clients[i] == NULL) {
147                         itv->i2c_clients[i] = client;
148                         break;
149                 }
150         }
151         if (i == I2C_CLIENTS_MAX) {
152                 IVTV_ERR("Insufficient room for new I2C client\n");
153         }
154         return 0;
155 }
156
157 static int detach_inform(struct i2c_client *client)
158 {
159         int i;
160         struct ivtv *itv = (struct ivtv *)i2c_get_adapdata(client->adapter);
161
162         IVTV_DEBUG_I2C("i2c client detach\n");
163         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
164                 if (itv->i2c_clients[i] == client) {
165                         itv->i2c_clients[i] = NULL;
166                         break;
167                 }
168         }
169         IVTV_DEBUG_I2C("i2c detach [client=%s,%s]\n",
170                    client->name, (i < I2C_CLIENTS_MAX) ? "ok" : "failed");
171
172         return 0;
173 }
174
175 /* Set the serial clock line to the desired state */
176 static void ivtv_setscl(struct ivtv *itv, int state)
177 {
178         /* write them out */
179         /* write bits are inverted */
180         write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET);
181 }
182
183 /* Set the serial data line to the desired state */
184 static void ivtv_setsda(struct ivtv *itv, int state)
185 {
186         /* write them out */
187         /* write bits are inverted */
188         write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET);
189 }
190
191 /* Read the serial clock line */
192 static int ivtv_getscl(struct ivtv *itv)
193 {
194         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
195 }
196
197 /* Read the serial data line */
198 static int ivtv_getsda(struct ivtv *itv)
199 {
200         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
201 }
202
203 /* Implement a short delay by polling the serial clock line */
204 static void ivtv_scldelay(struct ivtv *itv)
205 {
206         int i;
207
208         for (i = 0; i < 5; ++i)
209                 ivtv_getscl(itv);
210 }
211
212 /* Wait for the serial clock line to become set to a specific value */
213 static int ivtv_waitscl(struct ivtv *itv, int val)
214 {
215         int i;
216
217         ivtv_scldelay(itv);
218         for (i = 0; i < 1000; ++i) {
219                 if (ivtv_getscl(itv) == val)
220                         return 1;
221         }
222         return 0;
223 }
224
225 /* Wait for the serial data line to become set to a specific value */
226 static int ivtv_waitsda(struct ivtv *itv, int val)
227 {
228         int i;
229
230         ivtv_scldelay(itv);
231         for (i = 0; i < 1000; ++i) {
232                 if (ivtv_getsda(itv) == val)
233                         return 1;
234         }
235         return 0;
236 }
237
238 /* Wait for the slave to issue an ACK */
239 static int ivtv_ack(struct ivtv *itv)
240 {
241         int ret = 0;
242
243         if (ivtv_getscl(itv) == 1) {
244                 IVTV_DEBUG_HI_I2C("SCL was high starting an ack\n");
245                 ivtv_setscl(itv, 0);
246                 if (!ivtv_waitscl(itv, 0)) {
247                         IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n");
248                         return -EREMOTEIO;
249                 }
250         }
251         ivtv_setsda(itv, 1);
252         ivtv_scldelay(itv);
253         ivtv_setscl(itv, 1);
254         if (!ivtv_waitsda(itv, 0)) {
255                 IVTV_DEBUG_I2C("Slave did not ack\n");
256                 ret = -EREMOTEIO;
257         }
258         ivtv_setscl(itv, 0);
259         if (!ivtv_waitscl(itv, 0)) {
260                 IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n");
261                 ret = -EREMOTEIO;
262         }
263         return ret;
264 }
265
266 /* Write a single byte to the i2c bus and wait for the slave to ACK */
267 static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte)
268 {
269         int i, bit;
270
271         IVTV_DEBUG_HI_I2C("write %x\n",byte);
272         for (i = 0; i < 8; ++i, byte<<=1) {
273                 ivtv_setscl(itv, 0);
274                 if (!ivtv_waitscl(itv, 0)) {
275                         IVTV_DEBUG_I2C("Error setting SCL low\n");
276                         return -EREMOTEIO;
277                 }
278                 bit = (byte>>7)&1;
279                 ivtv_setsda(itv, bit);
280                 if (!ivtv_waitsda(itv, bit)) {
281                         IVTV_DEBUG_I2C("Error setting SDA\n");
282                         return -EREMOTEIO;
283                 }
284                 ivtv_setscl(itv, 1);
285                 if (!ivtv_waitscl(itv, 1)) {
286                         IVTV_DEBUG_I2C("Slave not ready for bit\n");
287                         return -EREMOTEIO;
288                 }
289         }
290         ivtv_setscl(itv, 0);
291         if (!ivtv_waitscl(itv, 0)) {
292                 IVTV_DEBUG_I2C("Error setting SCL low\n");
293                 return -EREMOTEIO;
294         }
295         return ivtv_ack(itv);
296 }
297
298 /* Read a byte from the i2c bus and send a NACK if applicable (i.e. for the
299    final byte) */
300 static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack)
301 {
302         int i;
303
304         *byte = 0;
305
306         ivtv_setsda(itv, 1);
307         ivtv_scldelay(itv);
308         for (i = 0; i < 8; ++i) {
309                 ivtv_setscl(itv, 0);
310                 ivtv_scldelay(itv);
311                 ivtv_setscl(itv, 1);
312                 if (!ivtv_waitscl(itv, 1)) {
313                         IVTV_DEBUG_I2C("Error setting SCL high\n");
314                         return -EREMOTEIO;
315                 }
316                 *byte = ((*byte)<<1)|ivtv_getsda(itv);
317         }
318         ivtv_setscl(itv, 0);
319         ivtv_scldelay(itv);
320         ivtv_setsda(itv, nack);
321         ivtv_scldelay(itv);
322         ivtv_setscl(itv, 1);
323         ivtv_scldelay(itv);
324         ivtv_setscl(itv, 0);
325         ivtv_scldelay(itv);
326         IVTV_DEBUG_HI_I2C("read %x\n",*byte);
327         return 0;
328 }
329
330 /* Issue a start condition on the i2c bus to alert slaves to prepare for
331    an address write */
332 static int ivtv_start(struct ivtv *itv)
333 {
334         int sda;
335
336         sda = ivtv_getsda(itv);
337         if (sda != 1) {
338                 IVTV_DEBUG_HI_I2C("SDA was low at start\n");
339                 ivtv_setsda(itv, 1);
340                 if (!ivtv_waitsda(itv, 1)) {
341                         IVTV_DEBUG_I2C("SDA stuck low\n");
342                         return -EREMOTEIO;
343                 }
344         }
345         if (ivtv_getscl(itv) != 1) {
346                 ivtv_setscl(itv, 1);
347                 if (!ivtv_waitscl(itv, 1)) {
348                         IVTV_DEBUG_I2C("SCL stuck low at start\n");
349                         return -EREMOTEIO;
350                 }
351         }
352         ivtv_setsda(itv, 0);
353         ivtv_scldelay(itv);
354         return 0;
355 }
356
357 /* Issue a stop condition on the i2c bus to release it */
358 static int ivtv_stop(struct ivtv *itv)
359 {
360         int i;
361
362         if (ivtv_getscl(itv) != 0) {
363                 IVTV_DEBUG_HI_I2C("SCL not low when stopping\n");
364                 ivtv_setscl(itv, 0);
365                 if (!ivtv_waitscl(itv, 0)) {
366                         IVTV_DEBUG_I2C("SCL could not be set low\n");
367                 }
368         }
369         ivtv_setsda(itv, 0);
370         ivtv_scldelay(itv);
371         ivtv_setscl(itv, 1);
372         if (!ivtv_waitscl(itv, 1)) {
373                 IVTV_DEBUG_I2C("SCL could not be set high\n");
374                 return -EREMOTEIO;
375         }
376         ivtv_scldelay(itv);
377         ivtv_setsda(itv, 1);
378         if (!ivtv_waitsda(itv, 1)) {
379                 IVTV_DEBUG_I2C("resetting I2C\n");
380                 for (i = 0; i < 16; ++i) {
381                         ivtv_setscl(itv, 0);
382                         ivtv_scldelay(itv);
383                         ivtv_setscl(itv, 1);
384                         ivtv_scldelay(itv);
385                         ivtv_setsda(itv, 1);
386                 }
387                 ivtv_waitsda(itv, 1);
388                 return -EREMOTEIO;
389         }
390         return 0;
391 }
392
393 /* Write a message to the given i2c slave.  do_stop may be 0 to prevent
394    issuing the i2c stop condition (when following with a read) */
395 static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop)
396 {
397         int retry, ret = -EREMOTEIO;
398         u32 i;
399
400         for (retry = 0; ret != 0 && retry < 8; ++retry) {
401                 ret = ivtv_start(itv);
402
403                 if (ret == 0) {
404                         ret = ivtv_sendbyte(itv, addr<<1);
405                         for (i = 0; ret == 0 && i < len; ++i)
406                                 ret = ivtv_sendbyte(itv, data[i]);
407                 }
408                 if (ret != 0 || do_stop) {
409                         ivtv_stop(itv);
410                 }
411         }
412         if (ret)
413                 IVTV_DEBUG_I2C("i2c write to %x failed\n", addr);
414         return ret;
415 }
416
417 /* Read data from the given i2c slave.  A stop condition is always issued. */
418 static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len)
419 {
420         int retry, ret = -EREMOTEIO;
421         u32 i;
422
423         for (retry = 0; ret != 0 && retry < 8; ++retry) {
424                 ret = ivtv_start(itv);
425                 if (ret == 0)
426                         ret = ivtv_sendbyte(itv, (addr << 1) | 1);
427                 for (i = 0; ret == 0 && i < len; ++i) {
428                         ret = ivtv_readbyte(itv, &data[i], i == len - 1);
429                 }
430                 ivtv_stop(itv);
431         }
432         if (ret)
433                 IVTV_DEBUG_I2C("i2c read from %x failed\n", addr);
434         return ret;
435 }
436
437 /* Kernel i2c transfer implementation.  Takes a number of messages to be read
438    or written.  If a read follows a write, this will occur without an
439    intervening stop condition */
440 static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
441 {
442         struct ivtv *itv = i2c_get_adapdata(i2c_adap);
443         int retval;
444         int i;
445
446         mutex_lock(&itv->i2c_bus_lock);
447         for (i = retval = 0; retval == 0 && i < num; i++) {
448                 if (msgs[i].flags & I2C_M_RD)
449                         retval = ivtv_read(itv, msgs[i].addr, msgs[i].buf, msgs[i].len);
450                 else {
451                         /* if followed by a read, don't stop */
452                         int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD);
453
454                         retval = ivtv_write(itv, msgs[i].addr, msgs[i].buf, msgs[i].len, stop);
455                 }
456         }
457         mutex_unlock(&itv->i2c_bus_lock);
458         return retval ? retval : num;
459 }
460
461 /* Kernel i2c capabilities */
462 static u32 ivtv_functionality(struct i2c_adapter *adap)
463 {
464         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
465 }
466
467 static struct i2c_algorithm ivtv_algo = {
468         .master_xfer   = ivtv_xfer,
469         .functionality = ivtv_functionality,
470 };
471
472 /* template for our-bit banger */
473 static struct i2c_adapter ivtv_i2c_adap_hw_template = {
474         .name = "ivtv i2c driver",
475         .id = I2C_HW_B_CX2341X,
476         .algo = &ivtv_algo,
477         .algo_data = NULL,                      /* filled from template */
478         .client_register = attach_inform,
479         .client_unregister = detach_inform,
480         .owner = THIS_MODULE,
481 #ifdef I2C_ADAP_CLASS_TV_ANALOG
482         .class = I2C_ADAP_CLASS_TV_ANALOG,
483 #endif
484 };
485
486 static void ivtv_setscl_old(void *data, int state)
487 {
488         struct ivtv *itv = (struct ivtv *)data;
489
490         if (state)
491                 itv->i2c_state |= 0x01;
492         else
493                 itv->i2c_state &= ~0x01;
494
495         /* write them out */
496         /* write bits are inverted */
497         write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET);
498 }
499
500 static void ivtv_setsda_old(void *data, int state)
501 {
502         struct ivtv *itv = (struct ivtv *)data;
503
504         if (state)
505                 itv->i2c_state |= 0x01;
506         else
507                 itv->i2c_state &= ~0x01;
508
509         /* write them out */
510         /* write bits are inverted */
511         write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSDA_OFFSET);
512 }
513
514 static int ivtv_getscl_old(void *data)
515 {
516         struct ivtv *itv = (struct ivtv *)data;
517
518         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
519 }
520
521 static int ivtv_getsda_old(void *data)
522 {
523         struct ivtv *itv = (struct ivtv *)data;
524
525         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
526 }
527
528 /* template for i2c-bit-algo */
529 static struct i2c_adapter ivtv_i2c_adap_template = {
530         .name = "ivtv i2c driver",
531         .id = I2C_HW_B_CX2341X,         /* algo-bit is OR'd with this */
532         .algo = NULL,                   /* set by i2c-algo-bit */
533         .algo_data = NULL,              /* filled from template */
534         .client_register = attach_inform,
535         .client_unregister = detach_inform,
536         .owner = THIS_MODULE,
537 #ifdef I2C_ADAP_CLASS_TV_ANALOG
538         .class = I2C_ADAP_CLASS_TV_ANALOG,
539 #endif
540 };
541
542 static const struct i2c_algo_bit_data ivtv_i2c_algo_template = {
543         .setsda         = ivtv_setsda_old,
544         .setscl         = ivtv_setscl_old,
545         .getsda         = ivtv_getsda_old,
546         .getscl         = ivtv_getscl_old,
547         .udelay         = 10,
548         .timeout        = 200,
549 };
550
551 static struct i2c_client ivtv_i2c_client_template = {
552         .name = "ivtv internal",
553 };
554
555 int ivtv_call_i2c_client(struct ivtv *itv, int addr, unsigned int cmd, void *arg)
556 {
557         struct i2c_client *client;
558         int retval;
559         int i;
560
561         IVTV_DEBUG_I2C("call_i2c_client addr=%02x\n", addr);
562         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
563                 client = itv->i2c_clients[i];
564                 if (client == NULL) {
565                         continue;
566                 }
567                 if (client->driver->command == NULL) {
568                         continue;
569                 }
570                 if (addr == client->addr) {
571                         retval = client->driver->command(client, cmd, arg);
572                         return retval;
573                 }
574         }
575         if (cmd != VIDIOC_G_CHIP_IDENT)
576                 IVTV_ERR("i2c addr 0x%02x not found for command 0x%x\n", addr, cmd);
577         return -ENODEV;
578 }
579
580 /* Find the i2c device based on the driver ID and return
581    its i2c address or -ENODEV if no matching device was found. */
582 static int ivtv_i2c_id_addr(struct ivtv *itv, u32 id)
583 {
584         struct i2c_client *client;
585         int retval = -ENODEV;
586         int i;
587
588         for (i = 0; i < I2C_CLIENTS_MAX; i++) {
589                 client = itv->i2c_clients[i];
590                 if (client == NULL)
591                         continue;
592                 if (id == client->driver->id) {
593                         retval = client->addr;
594                         break;
595                 }
596         }
597         return retval;
598 }
599
600 /* Find the i2c device name matching the DRIVERID */
601 static const char *ivtv_i2c_id_name(u32 id)
602 {
603         int i;
604
605         for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
606                 if (hw_driverids[i] == id)
607                         return hw_drivernames[i];
608         return "unknown device";
609 }
610
611 /* Find the i2c device name matching the IVTV_HW_ flag */
612 static const char *ivtv_i2c_hw_name(u32 hw)
613 {
614         int i;
615
616         for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
617                 if (1 << i == hw)
618                         return hw_drivernames[i];
619         return "unknown device";
620 }
621
622 /* Find the i2c device matching the IVTV_HW_ flag and return
623    its i2c address or -ENODEV if no matching device was found. */
624 int ivtv_i2c_hw_addr(struct ivtv *itv, u32 hw)
625 {
626         int i;
627
628         for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
629                 if (1 << i == hw)
630                         return ivtv_i2c_id_addr(itv, hw_driverids[i]);
631         return -ENODEV;
632 }
633
634 /* Calls i2c device based on IVTV_HW_ flag. If hw == 0, then do nothing.
635    If hw == IVTV_HW_GPIO then call the gpio handler. */
636 int ivtv_i2c_hw(struct ivtv *itv, u32 hw, unsigned int cmd, void *arg)
637 {
638         int addr;
639
640         if (hw == IVTV_HW_GPIO)
641                 return ivtv_gpio(itv, cmd, arg);
642         if (hw == 0)
643                 return 0;
644
645         addr = ivtv_i2c_hw_addr(itv, hw);
646         if (addr < 0) {
647                 IVTV_ERR("i2c hardware 0x%08x (%s) not found for command 0x%x\n",
648                                hw, ivtv_i2c_hw_name(hw), cmd);
649                 return addr;
650         }
651         return ivtv_call_i2c_client(itv, addr, cmd, arg);
652 }
653
654 /* Calls i2c device based on I2C driver ID. */
655 int ivtv_i2c_id(struct ivtv *itv, u32 id, unsigned int cmd, void *arg)
656 {
657         int addr;
658
659         addr = ivtv_i2c_id_addr(itv, id);
660         if (addr < 0) {
661                 if (cmd != VIDIOC_G_CHIP_IDENT)
662                         IVTV_ERR("i2c ID 0x%08x (%s) not found for command 0x%x\n",
663                                 id, ivtv_i2c_id_name(id), cmd);
664                 return addr;
665         }
666         return ivtv_call_i2c_client(itv, addr, cmd, arg);
667 }
668
669 int ivtv_cx25840(struct ivtv *itv, unsigned int cmd, void *arg)
670 {
671         return ivtv_call_i2c_client(itv, IVTV_CX25840_I2C_ADDR, cmd, arg);
672 }
673
674 int ivtv_saa7115(struct ivtv *itv, unsigned int cmd, void *arg)
675 {
676         return ivtv_call_i2c_client(itv, IVTV_SAA7115_I2C_ADDR, cmd, arg);
677 }
678
679 int ivtv_saa7127(struct ivtv *itv, unsigned int cmd, void *arg)
680 {
681         return ivtv_call_i2c_client(itv, IVTV_SAA7127_I2C_ADDR, cmd, arg);
682 }
683
684 int ivtv_saa717x(struct ivtv *itv, unsigned int cmd, void *arg)
685 {
686         return ivtv_call_i2c_client(itv, IVTV_SAA717x_I2C_ADDR, cmd, arg);
687 }
688
689 int ivtv_upd64031a(struct ivtv *itv, unsigned int cmd, void *arg)
690 {
691         return ivtv_call_i2c_client(itv, IVTV_UPD64031A_I2C_ADDR, cmd, arg);
692 }
693
694 int ivtv_upd64083(struct ivtv *itv, unsigned int cmd, void *arg)
695 {
696         return ivtv_call_i2c_client(itv, IVTV_UPD64083_I2C_ADDR, cmd, arg);
697 }
698
699 /* broadcast cmd for all I2C clients and for the gpio subsystem */
700 void ivtv_call_i2c_clients(struct ivtv *itv, unsigned int cmd, void *arg)
701 {
702         if (itv->i2c_adap.algo == NULL) {
703                 IVTV_ERR("Adapter is not set");
704                 return;
705         }
706         i2c_clients_command(&itv->i2c_adap, cmd, arg);
707         if (itv->hw_flags & IVTV_HW_GPIO)
708                 ivtv_gpio(itv, cmd, arg);
709 }
710
711 /* init + register i2c algo-bit adapter */
712 int init_ivtv_i2c(struct ivtv *itv)
713 {
714         IVTV_DEBUG_I2C("i2c init\n");
715
716         if (itv->options.newi2c > 0) {
717                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_hw_template,
718                        sizeof(struct i2c_adapter));
719         } else {
720                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_template,
721                        sizeof(struct i2c_adapter));
722                 memcpy(&itv->i2c_algo, &ivtv_i2c_algo_template,
723                        sizeof(struct i2c_algo_bit_data));
724                 itv->i2c_algo.data = itv;
725                 itv->i2c_adap.algo_data = &itv->i2c_algo;
726         }
727
728         sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d",
729                 itv->num);
730         i2c_set_adapdata(&itv->i2c_adap, itv);
731
732         memcpy(&itv->i2c_client, &ivtv_i2c_client_template,
733                sizeof(struct i2c_client));
734         itv->i2c_client.adapter = &itv->i2c_adap;
735         itv->i2c_adap.dev.parent = &itv->dev->dev;
736
737         IVTV_DEBUG_I2C("setting scl and sda to 1\n");
738         ivtv_setscl(itv, 1);
739         ivtv_setsda(itv, 1);
740
741         if (itv->options.newi2c > 0)
742                 return i2c_add_adapter(&itv->i2c_adap);
743         else
744                 return i2c_bit_add_bus(&itv->i2c_adap);
745 }
746
747 void exit_ivtv_i2c(struct ivtv *itv)
748 {
749         IVTV_DEBUG_I2C("i2c exit\n");
750
751         i2c_del_adapter(&itv->i2c_adap);
752 }