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