Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs
[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 /* i2c implementation for cx23415/6 chip, ivtv project.
68  * Author: Kevin Thayer (nufan_wfk at yahoo.com)
69  */
70 /* i2c stuff */
71 #define IVTV_REG_I2C_SETSCL_OFFSET 0x7000
72 #define IVTV_REG_I2C_SETSDA_OFFSET 0x7004
73 #define IVTV_REG_I2C_GETSCL_OFFSET 0x7008
74 #define IVTV_REG_I2C_GETSDA_OFFSET 0x700c
75
76 #define IVTV_CS53L32A_I2C_ADDR          0x11
77 #define IVTV_M52790_I2C_ADDR            0x48
78 #define IVTV_CX25840_I2C_ADDR           0x44
79 #define IVTV_SAA7115_I2C_ADDR           0x21
80 #define IVTV_SAA7127_I2C_ADDR           0x44
81 #define IVTV_SAA717x_I2C_ADDR           0x21
82 #define IVTV_MSP3400_I2C_ADDR           0x40
83 #define IVTV_HAUPPAUGE_I2C_ADDR         0x50
84 #define IVTV_WM8739_I2C_ADDR            0x1a
85 #define IVTV_WM8775_I2C_ADDR            0x1b
86 #define IVTV_TEA5767_I2C_ADDR           0x60
87 #define IVTV_UPD64031A_I2C_ADDR         0x12
88 #define IVTV_UPD64083_I2C_ADDR          0x5c
89 #define IVTV_VP27SMPX_I2C_ADDR          0x5b
90 #define IVTV_M52790_I2C_ADDR            0x48
91
92 /* This array should match the IVTV_HW_ defines */
93 static const u8 hw_addrs[] = {
94         IVTV_CX25840_I2C_ADDR,
95         IVTV_SAA7115_I2C_ADDR,
96         IVTV_SAA7127_I2C_ADDR,
97         IVTV_MSP3400_I2C_ADDR,
98         0,
99         IVTV_WM8775_I2C_ADDR,
100         IVTV_CS53L32A_I2C_ADDR,
101         0,
102         IVTV_SAA7115_I2C_ADDR,
103         IVTV_UPD64031A_I2C_ADDR,
104         IVTV_UPD64083_I2C_ADDR,
105         IVTV_SAA717x_I2C_ADDR,
106         IVTV_WM8739_I2C_ADDR,
107         IVTV_VP27SMPX_I2C_ADDR,
108         IVTV_M52790_I2C_ADDR,
109         0               /* IVTV_HW_GPIO dummy driver ID */
110 };
111
112 /* This array should match the IVTV_HW_ defines */
113 static const char *hw_modules[] = {
114         "cx25840",
115         "saa7115",
116         "saa7127",
117         "msp3400",
118         "tuner",
119         "wm8775",
120         "cs53l32a",
121         NULL,
122         "saa7115",
123         "upd64031a",
124         "upd64083",
125         "saa717x",
126         "wm8739",
127         "vp27smpx",
128         "m52790",
129         NULL
130 };
131
132 /* This array should match the IVTV_HW_ defines */
133 static const char * const hw_devicenames[] = {
134         "cx25840",
135         "saa7115",
136         "saa7127_auto", /* saa7127 or saa7129 */
137         "msp3400",
138         "tuner",
139         "wm8775",
140         "cs53l32a",
141         "tveeprom",
142         "saa7114",
143         "upd64031a",
144         "upd64083",
145         "saa717x",
146         "wm8739",
147         "vp27smpx",
148         "m52790",
149         "gpio",
150 };
151
152 int ivtv_i2c_register(struct ivtv *itv, unsigned idx)
153 {
154         struct v4l2_subdev *sd;
155         struct i2c_adapter *adap = &itv->i2c_adap;
156         const char *mod = hw_modules[idx];
157         const char *type = hw_devicenames[idx];
158         u32 hw = 1 << idx;
159
160         if (idx >= ARRAY_SIZE(hw_addrs))
161                 return -1;
162         if (hw == IVTV_HW_TUNER) {
163                 /* special tuner handling */
164                 sd = v4l2_i2c_new_probed_subdev(&itv->v4l2_dev,
165                                 adap, mod, type,
166                                 itv->card_i2c->radio);
167                 if (sd)
168                         sd->grp_id = 1 << idx;
169                 sd = v4l2_i2c_new_probed_subdev(&itv->v4l2_dev,
170                                 adap, mod, type,
171                                 itv->card_i2c->demod);
172                 if (sd)
173                         sd->grp_id = 1 << idx;
174                 sd = v4l2_i2c_new_probed_subdev(&itv->v4l2_dev,
175                                 adap, mod, type,
176                                 itv->card_i2c->tv);
177                 if (sd)
178                         sd->grp_id = 1 << idx;
179                 return sd ? 0 : -1;
180         }
181         if (!hw_addrs[idx])
182                 return -1;
183         if (hw == IVTV_HW_UPD64031A || hw == IVTV_HW_UPD6408X) {
184                 sd = v4l2_i2c_new_probed_subdev_addr(&itv->v4l2_dev,
185                                 adap, mod, type, hw_addrs[idx]);
186         } else {
187                 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
188                                 adap, mod, type, hw_addrs[idx]);
189         }
190         if (sd)
191                 sd->grp_id = 1 << idx;
192         return sd ? 0 : -1;
193 }
194
195 struct v4l2_subdev *ivtv_find_hw(struct ivtv *itv, u32 hw)
196 {
197         struct v4l2_subdev *result = NULL;
198         struct v4l2_subdev *sd;
199
200         spin_lock(&itv->v4l2_dev.lock);
201         v4l2_device_for_each_subdev(sd, &itv->v4l2_dev) {
202                 if (sd->grp_id == hw) {
203                         result = sd;
204                         break;
205                 }
206         }
207         spin_unlock(&itv->v4l2_dev.lock);
208         return result;
209 }
210
211 /* Set the serial clock line to the desired state */
212 static void ivtv_setscl(struct ivtv *itv, int state)
213 {
214         /* write them out */
215         /* write bits are inverted */
216         write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET);
217 }
218
219 /* Set the serial data line to the desired state */
220 static void ivtv_setsda(struct ivtv *itv, int state)
221 {
222         /* write them out */
223         /* write bits are inverted */
224         write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET);
225 }
226
227 /* Read the serial clock line */
228 static int ivtv_getscl(struct ivtv *itv)
229 {
230         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
231 }
232
233 /* Read the serial data line */
234 static int ivtv_getsda(struct ivtv *itv)
235 {
236         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
237 }
238
239 /* Implement a short delay by polling the serial clock line */
240 static void ivtv_scldelay(struct ivtv *itv)
241 {
242         int i;
243
244         for (i = 0; i < 5; ++i)
245                 ivtv_getscl(itv);
246 }
247
248 /* Wait for the serial clock line to become set to a specific value */
249 static int ivtv_waitscl(struct ivtv *itv, int val)
250 {
251         int i;
252
253         ivtv_scldelay(itv);
254         for (i = 0; i < 1000; ++i) {
255                 if (ivtv_getscl(itv) == val)
256                         return 1;
257         }
258         return 0;
259 }
260
261 /* Wait for the serial data line to become set to a specific value */
262 static int ivtv_waitsda(struct ivtv *itv, int val)
263 {
264         int i;
265
266         ivtv_scldelay(itv);
267         for (i = 0; i < 1000; ++i) {
268                 if (ivtv_getsda(itv) == val)
269                         return 1;
270         }
271         return 0;
272 }
273
274 /* Wait for the slave to issue an ACK */
275 static int ivtv_ack(struct ivtv *itv)
276 {
277         int ret = 0;
278
279         if (ivtv_getscl(itv) == 1) {
280                 IVTV_DEBUG_HI_I2C("SCL was high starting an ack\n");
281                 ivtv_setscl(itv, 0);
282                 if (!ivtv_waitscl(itv, 0)) {
283                         IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n");
284                         return -EREMOTEIO;
285                 }
286         }
287         ivtv_setsda(itv, 1);
288         ivtv_scldelay(itv);
289         ivtv_setscl(itv, 1);
290         if (!ivtv_waitsda(itv, 0)) {
291                 IVTV_DEBUG_I2C("Slave did not ack\n");
292                 ret = -EREMOTEIO;
293         }
294         ivtv_setscl(itv, 0);
295         if (!ivtv_waitscl(itv, 0)) {
296                 IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n");
297                 ret = -EREMOTEIO;
298         }
299         return ret;
300 }
301
302 /* Write a single byte to the i2c bus and wait for the slave to ACK */
303 static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte)
304 {
305         int i, bit;
306
307         IVTV_DEBUG_HI_I2C("write %x\n",byte);
308         for (i = 0; i < 8; ++i, byte<<=1) {
309                 ivtv_setscl(itv, 0);
310                 if (!ivtv_waitscl(itv, 0)) {
311                         IVTV_DEBUG_I2C("Error setting SCL low\n");
312                         return -EREMOTEIO;
313                 }
314                 bit = (byte>>7)&1;
315                 ivtv_setsda(itv, bit);
316                 if (!ivtv_waitsda(itv, bit)) {
317                         IVTV_DEBUG_I2C("Error setting SDA\n");
318                         return -EREMOTEIO;
319                 }
320                 ivtv_setscl(itv, 1);
321                 if (!ivtv_waitscl(itv, 1)) {
322                         IVTV_DEBUG_I2C("Slave not ready for bit\n");
323                         return -EREMOTEIO;
324                 }
325         }
326         ivtv_setscl(itv, 0);
327         if (!ivtv_waitscl(itv, 0)) {
328                 IVTV_DEBUG_I2C("Error setting SCL low\n");
329                 return -EREMOTEIO;
330         }
331         return ivtv_ack(itv);
332 }
333
334 /* Read a byte from the i2c bus and send a NACK if applicable (i.e. for the
335    final byte) */
336 static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack)
337 {
338         int i;
339
340         *byte = 0;
341
342         ivtv_setsda(itv, 1);
343         ivtv_scldelay(itv);
344         for (i = 0; i < 8; ++i) {
345                 ivtv_setscl(itv, 0);
346                 ivtv_scldelay(itv);
347                 ivtv_setscl(itv, 1);
348                 if (!ivtv_waitscl(itv, 1)) {
349                         IVTV_DEBUG_I2C("Error setting SCL high\n");
350                         return -EREMOTEIO;
351                 }
352                 *byte = ((*byte)<<1)|ivtv_getsda(itv);
353         }
354         ivtv_setscl(itv, 0);
355         ivtv_scldelay(itv);
356         ivtv_setsda(itv, nack);
357         ivtv_scldelay(itv);
358         ivtv_setscl(itv, 1);
359         ivtv_scldelay(itv);
360         ivtv_setscl(itv, 0);
361         ivtv_scldelay(itv);
362         IVTV_DEBUG_HI_I2C("read %x\n",*byte);
363         return 0;
364 }
365
366 /* Issue a start condition on the i2c bus to alert slaves to prepare for
367    an address write */
368 static int ivtv_start(struct ivtv *itv)
369 {
370         int sda;
371
372         sda = ivtv_getsda(itv);
373         if (sda != 1) {
374                 IVTV_DEBUG_HI_I2C("SDA was low at start\n");
375                 ivtv_setsda(itv, 1);
376                 if (!ivtv_waitsda(itv, 1)) {
377                         IVTV_DEBUG_I2C("SDA stuck low\n");
378                         return -EREMOTEIO;
379                 }
380         }
381         if (ivtv_getscl(itv) != 1) {
382                 ivtv_setscl(itv, 1);
383                 if (!ivtv_waitscl(itv, 1)) {
384                         IVTV_DEBUG_I2C("SCL stuck low at start\n");
385                         return -EREMOTEIO;
386                 }
387         }
388         ivtv_setsda(itv, 0);
389         ivtv_scldelay(itv);
390         return 0;
391 }
392
393 /* Issue a stop condition on the i2c bus to release it */
394 static int ivtv_stop(struct ivtv *itv)
395 {
396         int i;
397
398         if (ivtv_getscl(itv) != 0) {
399                 IVTV_DEBUG_HI_I2C("SCL not low when stopping\n");
400                 ivtv_setscl(itv, 0);
401                 if (!ivtv_waitscl(itv, 0)) {
402                         IVTV_DEBUG_I2C("SCL could not be set low\n");
403                 }
404         }
405         ivtv_setsda(itv, 0);
406         ivtv_scldelay(itv);
407         ivtv_setscl(itv, 1);
408         if (!ivtv_waitscl(itv, 1)) {
409                 IVTV_DEBUG_I2C("SCL could not be set high\n");
410                 return -EREMOTEIO;
411         }
412         ivtv_scldelay(itv);
413         ivtv_setsda(itv, 1);
414         if (!ivtv_waitsda(itv, 1)) {
415                 IVTV_DEBUG_I2C("resetting I2C\n");
416                 for (i = 0; i < 16; ++i) {
417                         ivtv_setscl(itv, 0);
418                         ivtv_scldelay(itv);
419                         ivtv_setscl(itv, 1);
420                         ivtv_scldelay(itv);
421                         ivtv_setsda(itv, 1);
422                 }
423                 ivtv_waitsda(itv, 1);
424                 return -EREMOTEIO;
425         }
426         return 0;
427 }
428
429 /* Write a message to the given i2c slave.  do_stop may be 0 to prevent
430    issuing the i2c stop condition (when following with a read) */
431 static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop)
432 {
433         int retry, ret = -EREMOTEIO;
434         u32 i;
435
436         for (retry = 0; ret != 0 && retry < 8; ++retry) {
437                 ret = ivtv_start(itv);
438
439                 if (ret == 0) {
440                         ret = ivtv_sendbyte(itv, addr<<1);
441                         for (i = 0; ret == 0 && i < len; ++i)
442                                 ret = ivtv_sendbyte(itv, data[i]);
443                 }
444                 if (ret != 0 || do_stop) {
445                         ivtv_stop(itv);
446                 }
447         }
448         if (ret)
449                 IVTV_DEBUG_I2C("i2c write to %x failed\n", addr);
450         return ret;
451 }
452
453 /* Read data from the given i2c slave.  A stop condition is always issued. */
454 static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len)
455 {
456         int retry, ret = -EREMOTEIO;
457         u32 i;
458
459         for (retry = 0; ret != 0 && retry < 8; ++retry) {
460                 ret = ivtv_start(itv);
461                 if (ret == 0)
462                         ret = ivtv_sendbyte(itv, (addr << 1) | 1);
463                 for (i = 0; ret == 0 && i < len; ++i) {
464                         ret = ivtv_readbyte(itv, &data[i], i == len - 1);
465                 }
466                 ivtv_stop(itv);
467         }
468         if (ret)
469                 IVTV_DEBUG_I2C("i2c read from %x failed\n", addr);
470         return ret;
471 }
472
473 /* Kernel i2c transfer implementation.  Takes a number of messages to be read
474    or written.  If a read follows a write, this will occur without an
475    intervening stop condition */
476 static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
477 {
478         struct v4l2_device *v4l2_dev = i2c_get_adapdata(i2c_adap);
479         struct ivtv *itv = to_ivtv(v4l2_dev);
480         int retval;
481         int i;
482
483         mutex_lock(&itv->i2c_bus_lock);
484         for (i = retval = 0; retval == 0 && i < num; i++) {
485                 if (msgs[i].flags & I2C_M_RD)
486                         retval = ivtv_read(itv, msgs[i].addr, msgs[i].buf, msgs[i].len);
487                 else {
488                         /* if followed by a read, don't stop */
489                         int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD);
490
491                         retval = ivtv_write(itv, msgs[i].addr, msgs[i].buf, msgs[i].len, stop);
492                 }
493         }
494         mutex_unlock(&itv->i2c_bus_lock);
495         return retval ? retval : num;
496 }
497
498 /* Kernel i2c capabilities */
499 static u32 ivtv_functionality(struct i2c_adapter *adap)
500 {
501         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
502 }
503
504 static struct i2c_algorithm ivtv_algo = {
505         .master_xfer   = ivtv_xfer,
506         .functionality = ivtv_functionality,
507 };
508
509 /* template for our-bit banger */
510 static struct i2c_adapter ivtv_i2c_adap_hw_template = {
511         .name = "ivtv i2c driver",
512         .id = I2C_HW_B_CX2341X,
513         .algo = &ivtv_algo,
514         .algo_data = NULL,                      /* filled from template */
515         .owner = THIS_MODULE,
516 };
517
518 static void ivtv_setscl_old(void *data, int state)
519 {
520         struct ivtv *itv = (struct ivtv *)data;
521
522         if (state)
523                 itv->i2c_state |= 0x01;
524         else
525                 itv->i2c_state &= ~0x01;
526
527         /* write them out */
528         /* write bits are inverted */
529         write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET);
530 }
531
532 static void ivtv_setsda_old(void *data, int state)
533 {
534         struct ivtv *itv = (struct ivtv *)data;
535
536         if (state)
537                 itv->i2c_state |= 0x01;
538         else
539                 itv->i2c_state &= ~0x01;
540
541         /* write them out */
542         /* write bits are inverted */
543         write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSDA_OFFSET);
544 }
545
546 static int ivtv_getscl_old(void *data)
547 {
548         struct ivtv *itv = (struct ivtv *)data;
549
550         return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
551 }
552
553 static int ivtv_getsda_old(void *data)
554 {
555         struct ivtv *itv = (struct ivtv *)data;
556
557         return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
558 }
559
560 /* template for i2c-bit-algo */
561 static struct i2c_adapter ivtv_i2c_adap_template = {
562         .name = "ivtv i2c driver",
563         .id = I2C_HW_B_CX2341X,
564         .algo = NULL,                   /* set by i2c-algo-bit */
565         .algo_data = NULL,              /* filled from template */
566         .owner = THIS_MODULE,
567 };
568
569 static const struct i2c_algo_bit_data ivtv_i2c_algo_template = {
570         .setsda         = ivtv_setsda_old,
571         .setscl         = ivtv_setscl_old,
572         .getsda         = ivtv_getsda_old,
573         .getscl         = ivtv_getscl_old,
574         .udelay         = 10,
575         .timeout        = 200,
576 };
577
578 static struct i2c_client ivtv_i2c_client_template = {
579         .name = "ivtv internal",
580 };
581
582 /* init + register i2c algo-bit adapter */
583 int init_ivtv_i2c(struct ivtv *itv)
584 {
585         IVTV_DEBUG_I2C("i2c init\n");
586
587         /* Sanity checks for the I2C hardware arrays. They must be the
588          * same size and GPIO must be the last entry.
589          */
590         if (ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_addrs) ||
591             ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_modules) ||
592             IVTV_HW_GPIO != (1 << (ARRAY_SIZE(hw_addrs) - 1))) {
593                 IVTV_ERR("Mismatched I2C hardware arrays\n");
594                 return -ENODEV;
595         }
596         if (itv->options.newi2c > 0) {
597                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_hw_template,
598                        sizeof(struct i2c_adapter));
599         } else {
600                 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_template,
601                        sizeof(struct i2c_adapter));
602                 memcpy(&itv->i2c_algo, &ivtv_i2c_algo_template,
603                        sizeof(struct i2c_algo_bit_data));
604         }
605         itv->i2c_algo.data = itv;
606         itv->i2c_adap.algo_data = &itv->i2c_algo;
607
608         sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d",
609                 itv->instance);
610         i2c_set_adapdata(&itv->i2c_adap, &itv->v4l2_dev);
611
612         memcpy(&itv->i2c_client, &ivtv_i2c_client_template,
613                sizeof(struct i2c_client));
614         itv->i2c_client.adapter = &itv->i2c_adap;
615         itv->i2c_adap.dev.parent = &itv->pdev->dev;
616
617         IVTV_DEBUG_I2C("setting scl and sda to 1\n");
618         ivtv_setscl(itv, 1);
619         ivtv_setsda(itv, 1);
620
621         if (itv->options.newi2c > 0)
622                 return i2c_add_adapter(&itv->i2c_adap);
623         else
624                 return i2c_bit_add_bus(&itv->i2c_adap);
625 }
626
627 void exit_ivtv_i2c(struct ivtv *itv)
628 {
629         IVTV_DEBUG_I2C("i2c exit\n");
630
631         i2c_del_adapter(&itv->i2c_adap);
632 }