This source file includes following definitions.
- get_key_adaptec
- ivtv_i2c_new_ir
- ivtv_i2c_new_ir_legacy
- ivtv_i2c_register
- ivtv_find_hw
- ivtv_setscl
- ivtv_setsda
- ivtv_getscl
- ivtv_getsda
- ivtv_scldelay
- ivtv_waitscl
- ivtv_waitsda
- ivtv_ack
- ivtv_sendbyte
- ivtv_readbyte
- ivtv_start
- ivtv_stop
- ivtv_write
- ivtv_read
- ivtv_xfer
- ivtv_functionality
- ivtv_setscl_old
- ivtv_setsda_old
- ivtv_getscl_old
- ivtv_getsda_old
- init_ivtv_i2c
- exit_ivtv_i2c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50 #include "ivtv-driver.h"
51 #include "ivtv-cards.h"
52 #include "ivtv-gpio.h"
53 #include "ivtv-i2c.h"
54 #include <media/drv-intf/cx25840.h>
55
56
57
58
59
60 #define IVTV_REG_I2C_SETSCL_OFFSET 0x7000
61 #define IVTV_REG_I2C_SETSDA_OFFSET 0x7004
62 #define IVTV_REG_I2C_GETSCL_OFFSET 0x7008
63 #define IVTV_REG_I2C_GETSDA_OFFSET 0x700c
64
65 #define IVTV_CS53L32A_I2C_ADDR 0x11
66 #define IVTV_M52790_I2C_ADDR 0x48
67 #define IVTV_CX25840_I2C_ADDR 0x44
68 #define IVTV_SAA7115_I2C_ADDR 0x21
69 #define IVTV_SAA7127_I2C_ADDR 0x44
70 #define IVTV_SAA717x_I2C_ADDR 0x21
71 #define IVTV_MSP3400_I2C_ADDR 0x40
72 #define IVTV_HAUPPAUGE_I2C_ADDR 0x50
73 #define IVTV_WM8739_I2C_ADDR 0x1a
74 #define IVTV_WM8775_I2C_ADDR 0x1b
75 #define IVTV_TEA5767_I2C_ADDR 0x60
76 #define IVTV_UPD64031A_I2C_ADDR 0x12
77 #define IVTV_UPD64083_I2C_ADDR 0x5c
78 #define IVTV_VP27SMPX_I2C_ADDR 0x5b
79 #define IVTV_M52790_I2C_ADDR 0x48
80 #define IVTV_AVERMEDIA_IR_RX_I2C_ADDR 0x40
81 #define IVTV_HAUP_EXT_IR_RX_I2C_ADDR 0x1a
82 #define IVTV_HAUP_INT_IR_RX_I2C_ADDR 0x18
83 #define IVTV_Z8F0811_IR_TX_I2C_ADDR 0x70
84 #define IVTV_Z8F0811_IR_RX_I2C_ADDR 0x71
85 #define IVTV_ADAPTEC_IR_ADDR 0x6b
86
87
88 static const u8 hw_addrs[] = {
89 IVTV_CX25840_I2C_ADDR,
90 IVTV_SAA7115_I2C_ADDR,
91 IVTV_SAA7127_I2C_ADDR,
92 IVTV_MSP3400_I2C_ADDR,
93 0,
94 IVTV_WM8775_I2C_ADDR,
95 IVTV_CS53L32A_I2C_ADDR,
96 0,
97 IVTV_SAA7115_I2C_ADDR,
98 IVTV_UPD64031A_I2C_ADDR,
99 IVTV_UPD64083_I2C_ADDR,
100 IVTV_SAA717x_I2C_ADDR,
101 IVTV_WM8739_I2C_ADDR,
102 IVTV_VP27SMPX_I2C_ADDR,
103 IVTV_M52790_I2C_ADDR,
104 0,
105 IVTV_AVERMEDIA_IR_RX_I2C_ADDR,
106 IVTV_HAUP_EXT_IR_RX_I2C_ADDR,
107 IVTV_HAUP_INT_IR_RX_I2C_ADDR,
108 IVTV_Z8F0811_IR_RX_I2C_ADDR,
109 IVTV_ADAPTEC_IR_ADDR,
110 };
111
112
113 static const char * const hw_devicenames[] = {
114 "cx25840",
115 "saa7115",
116 "saa7127_auto",
117 "msp3400",
118 "tuner",
119 "wm8775",
120 "cs53l32a",
121 "tveeprom",
122 "saa7114",
123 "upd64031a",
124 "upd64083",
125 "saa717x",
126 "wm8739",
127 "vp27smpx",
128 "m52790",
129 "gpio",
130 "ir_video",
131 "ir_video",
132 "ir_video",
133 "ir_z8f0811_haup",
134 "ir_video",
135 };
136
137 static int get_key_adaptec(struct IR_i2c *ir, enum rc_proto *protocol,
138 u32 *scancode, u8 *toggle)
139 {
140 unsigned char keybuf[4];
141
142 keybuf[0] = 0x00;
143 i2c_master_send(ir->c, keybuf, 1);
144
145 if (i2c_master_recv(ir->c, keybuf, sizeof(keybuf)) != sizeof(keybuf)) {
146 return 0;
147 }
148
149
150 if (keybuf[2] == 0xff)
151 return 0;
152
153
154 keybuf[2] &= 0x7f;
155 keybuf[3] |= 0x80;
156
157 *protocol = RC_PROTO_UNKNOWN;
158 *scancode = keybuf[3] | keybuf[2] << 8 | keybuf[1] << 16 |keybuf[0] << 24;
159 *toggle = 0;
160 return 1;
161 }
162
163 static int ivtv_i2c_new_ir(struct ivtv *itv, u32 hw, const char *type, u8 addr)
164 {
165 struct i2c_board_info info;
166 struct i2c_adapter *adap = &itv->i2c_adap;
167 struct IR_i2c_init_data *init_data = &itv->ir_i2c_init_data;
168 unsigned short addr_list[2] = { addr, I2C_CLIENT_END };
169
170
171 if (itv->hw_flags & IVTV_HW_IR_ANY)
172 return -1;
173
174
175 switch (hw) {
176 case IVTV_HW_I2C_IR_RX_AVER:
177 init_data->ir_codes = RC_MAP_AVERMEDIA_CARDBUS;
178 init_data->internal_get_key_func =
179 IR_KBD_GET_KEY_AVERMEDIA_CARDBUS;
180 init_data->type = RC_PROTO_BIT_OTHER;
181 init_data->name = "AVerMedia AVerTV card";
182 break;
183 case IVTV_HW_I2C_IR_RX_HAUP_EXT:
184 case IVTV_HW_I2C_IR_RX_HAUP_INT:
185 init_data->ir_codes = RC_MAP_HAUPPAUGE;
186 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP;
187 init_data->type = RC_PROTO_BIT_RC5;
188 init_data->name = itv->card_name;
189 break;
190 case IVTV_HW_Z8F0811_IR_HAUP:
191
192 init_data->ir_codes = RC_MAP_HAUPPAUGE;
193 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP_XVR;
194 init_data->type = RC_PROTO_BIT_RC5 | RC_PROTO_BIT_RC6_MCE |
195 RC_PROTO_BIT_RC6_6A_32;
196 init_data->name = itv->card_name;
197 break;
198 case IVTV_HW_I2C_IR_RX_ADAPTEC:
199 init_data->get_key = get_key_adaptec;
200 init_data->name = itv->card_name;
201
202 init_data->ir_codes = RC_MAP_EMPTY;
203 init_data->type = RC_PROTO_BIT_UNKNOWN;
204 break;
205 }
206
207 memset(&info, 0, sizeof(struct i2c_board_info));
208 info.platform_data = init_data;
209 strscpy(info.type, type, I2C_NAME_SIZE);
210
211 return i2c_new_probed_device(adap, &info, addr_list, NULL) == NULL ?
212 -1 : 0;
213 }
214
215
216 struct i2c_client *ivtv_i2c_new_ir_legacy(struct ivtv *itv)
217 {
218 struct i2c_board_info info;
219
220
221
222
223
224
225
226
227
228
229
230 static const unsigned short addr_list[] = {
231 0x1a,
232 0x18,
233 I2C_CLIENT_END
234 };
235
236 memset(&info, 0, sizeof(struct i2c_board_info));
237 strscpy(info.type, "ir_video", I2C_NAME_SIZE);
238 return i2c_new_probed_device(&itv->i2c_adap, &info, addr_list, NULL);
239 }
240
241 int ivtv_i2c_register(struct ivtv *itv, unsigned idx)
242 {
243 struct v4l2_subdev *sd;
244 struct i2c_adapter *adap = &itv->i2c_adap;
245 const char *type = hw_devicenames[idx];
246 u32 hw = 1 << idx;
247
248 if (hw == IVTV_HW_TUNER) {
249
250 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev, adap, type, 0,
251 itv->card_i2c->radio);
252 if (sd)
253 sd->grp_id = 1 << idx;
254 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev, adap, type, 0,
255 itv->card_i2c->demod);
256 if (sd)
257 sd->grp_id = 1 << idx;
258 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev, adap, type, 0,
259 itv->card_i2c->tv);
260 if (sd)
261 sd->grp_id = 1 << idx;
262 return sd ? 0 : -1;
263 }
264
265 if (hw & IVTV_HW_IR_ANY)
266 return ivtv_i2c_new_ir(itv, hw, type, hw_addrs[idx]);
267
268
269 if (!hw_addrs[idx])
270 return -1;
271
272
273 if (hw == IVTV_HW_UPD64031A || hw == IVTV_HW_UPD6408X) {
274 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
275 adap, type, 0, I2C_ADDRS(hw_addrs[idx]));
276 } else if (hw == IVTV_HW_CX25840) {
277 struct cx25840_platform_data pdata;
278 struct i2c_board_info cx25840_info = {
279 .type = "cx25840",
280 .addr = hw_addrs[idx],
281 .platform_data = &pdata,
282 };
283
284 memset(&pdata, 0, sizeof(pdata));
285 pdata.pvr150_workaround = itv->pvr150_workaround;
286 sd = v4l2_i2c_new_subdev_board(&itv->v4l2_dev, adap,
287 &cx25840_info, NULL);
288 } else {
289 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
290 adap, type, hw_addrs[idx], NULL);
291 }
292 if (sd)
293 sd->grp_id = 1 << idx;
294 return sd ? 0 : -1;
295 }
296
297 struct v4l2_subdev *ivtv_find_hw(struct ivtv *itv, u32 hw)
298 {
299 struct v4l2_subdev *result = NULL;
300 struct v4l2_subdev *sd;
301
302 spin_lock(&itv->v4l2_dev.lock);
303 v4l2_device_for_each_subdev(sd, &itv->v4l2_dev) {
304 if (sd->grp_id == hw) {
305 result = sd;
306 break;
307 }
308 }
309 spin_unlock(&itv->v4l2_dev.lock);
310 return result;
311 }
312
313
314 static void ivtv_setscl(struct ivtv *itv, int state)
315 {
316
317
318 write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET);
319 }
320
321
322 static void ivtv_setsda(struct ivtv *itv, int state)
323 {
324
325
326 write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET);
327 }
328
329
330 static int ivtv_getscl(struct ivtv *itv)
331 {
332 return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
333 }
334
335
336 static int ivtv_getsda(struct ivtv *itv)
337 {
338 return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
339 }
340
341
342 static void ivtv_scldelay(struct ivtv *itv)
343 {
344 int i;
345
346 for (i = 0; i < 5; ++i)
347 ivtv_getscl(itv);
348 }
349
350
351 static int ivtv_waitscl(struct ivtv *itv, int val)
352 {
353 int i;
354
355 ivtv_scldelay(itv);
356 for (i = 0; i < 1000; ++i) {
357 if (ivtv_getscl(itv) == val)
358 return 1;
359 }
360 return 0;
361 }
362
363
364 static int ivtv_waitsda(struct ivtv *itv, int val)
365 {
366 int i;
367
368 ivtv_scldelay(itv);
369 for (i = 0; i < 1000; ++i) {
370 if (ivtv_getsda(itv) == val)
371 return 1;
372 }
373 return 0;
374 }
375
376
377 static int ivtv_ack(struct ivtv *itv)
378 {
379 int ret = 0;
380
381 if (ivtv_getscl(itv) == 1) {
382 IVTV_DEBUG_HI_I2C("SCL was high starting an ack\n");
383 ivtv_setscl(itv, 0);
384 if (!ivtv_waitscl(itv, 0)) {
385 IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n");
386 return -EREMOTEIO;
387 }
388 }
389 ivtv_setsda(itv, 1);
390 ivtv_scldelay(itv);
391 ivtv_setscl(itv, 1);
392 if (!ivtv_waitsda(itv, 0)) {
393 IVTV_DEBUG_I2C("Slave did not ack\n");
394 ret = -EREMOTEIO;
395 }
396 ivtv_setscl(itv, 0);
397 if (!ivtv_waitscl(itv, 0)) {
398 IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n");
399 ret = -EREMOTEIO;
400 }
401 return ret;
402 }
403
404
405 static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte)
406 {
407 int i, bit;
408
409 IVTV_DEBUG_HI_I2C("write %x\n",byte);
410 for (i = 0; i < 8; ++i, byte<<=1) {
411 ivtv_setscl(itv, 0);
412 if (!ivtv_waitscl(itv, 0)) {
413 IVTV_DEBUG_I2C("Error setting SCL low\n");
414 return -EREMOTEIO;
415 }
416 bit = (byte>>7)&1;
417 ivtv_setsda(itv, bit);
418 if (!ivtv_waitsda(itv, bit)) {
419 IVTV_DEBUG_I2C("Error setting SDA\n");
420 return -EREMOTEIO;
421 }
422 ivtv_setscl(itv, 1);
423 if (!ivtv_waitscl(itv, 1)) {
424 IVTV_DEBUG_I2C("Slave not ready for bit\n");
425 return -EREMOTEIO;
426 }
427 }
428 ivtv_setscl(itv, 0);
429 if (!ivtv_waitscl(itv, 0)) {
430 IVTV_DEBUG_I2C("Error setting SCL low\n");
431 return -EREMOTEIO;
432 }
433 return ivtv_ack(itv);
434 }
435
436
437
438 static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack)
439 {
440 int i;
441
442 *byte = 0;
443
444 ivtv_setsda(itv, 1);
445 ivtv_scldelay(itv);
446 for (i = 0; i < 8; ++i) {
447 ivtv_setscl(itv, 0);
448 ivtv_scldelay(itv);
449 ivtv_setscl(itv, 1);
450 if (!ivtv_waitscl(itv, 1)) {
451 IVTV_DEBUG_I2C("Error setting SCL high\n");
452 return -EREMOTEIO;
453 }
454 *byte = ((*byte)<<1)|ivtv_getsda(itv);
455 }
456 ivtv_setscl(itv, 0);
457 ivtv_scldelay(itv);
458 ivtv_setsda(itv, nack);
459 ivtv_scldelay(itv);
460 ivtv_setscl(itv, 1);
461 ivtv_scldelay(itv);
462 ivtv_setscl(itv, 0);
463 ivtv_scldelay(itv);
464 IVTV_DEBUG_HI_I2C("read %x\n",*byte);
465 return 0;
466 }
467
468
469
470 static int ivtv_start(struct ivtv *itv)
471 {
472 int sda;
473
474 sda = ivtv_getsda(itv);
475 if (sda != 1) {
476 IVTV_DEBUG_HI_I2C("SDA was low at start\n");
477 ivtv_setsda(itv, 1);
478 if (!ivtv_waitsda(itv, 1)) {
479 IVTV_DEBUG_I2C("SDA stuck low\n");
480 return -EREMOTEIO;
481 }
482 }
483 if (ivtv_getscl(itv) != 1) {
484 ivtv_setscl(itv, 1);
485 if (!ivtv_waitscl(itv, 1)) {
486 IVTV_DEBUG_I2C("SCL stuck low at start\n");
487 return -EREMOTEIO;
488 }
489 }
490 ivtv_setsda(itv, 0);
491 ivtv_scldelay(itv);
492 return 0;
493 }
494
495
496 static int ivtv_stop(struct ivtv *itv)
497 {
498 int i;
499
500 if (ivtv_getscl(itv) != 0) {
501 IVTV_DEBUG_HI_I2C("SCL not low when stopping\n");
502 ivtv_setscl(itv, 0);
503 if (!ivtv_waitscl(itv, 0)) {
504 IVTV_DEBUG_I2C("SCL could not be set low\n");
505 }
506 }
507 ivtv_setsda(itv, 0);
508 ivtv_scldelay(itv);
509 ivtv_setscl(itv, 1);
510 if (!ivtv_waitscl(itv, 1)) {
511 IVTV_DEBUG_I2C("SCL could not be set high\n");
512 return -EREMOTEIO;
513 }
514 ivtv_scldelay(itv);
515 ivtv_setsda(itv, 1);
516 if (!ivtv_waitsda(itv, 1)) {
517 IVTV_DEBUG_I2C("resetting I2C\n");
518 for (i = 0; i < 16; ++i) {
519 ivtv_setscl(itv, 0);
520 ivtv_scldelay(itv);
521 ivtv_setscl(itv, 1);
522 ivtv_scldelay(itv);
523 ivtv_setsda(itv, 1);
524 }
525 ivtv_waitsda(itv, 1);
526 return -EREMOTEIO;
527 }
528 return 0;
529 }
530
531
532
533 static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop)
534 {
535 int retry, ret = -EREMOTEIO;
536 u32 i;
537
538 for (retry = 0; ret != 0 && retry < 8; ++retry) {
539 ret = ivtv_start(itv);
540
541 if (ret == 0) {
542 ret = ivtv_sendbyte(itv, addr<<1);
543 for (i = 0; ret == 0 && i < len; ++i)
544 ret = ivtv_sendbyte(itv, data[i]);
545 }
546 if (ret != 0 || do_stop) {
547 ivtv_stop(itv);
548 }
549 }
550 if (ret)
551 IVTV_DEBUG_I2C("i2c write to %x failed\n", addr);
552 return ret;
553 }
554
555
556 static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len)
557 {
558 int retry, ret = -EREMOTEIO;
559 u32 i;
560
561 for (retry = 0; ret != 0 && retry < 8; ++retry) {
562 ret = ivtv_start(itv);
563 if (ret == 0)
564 ret = ivtv_sendbyte(itv, (addr << 1) | 1);
565 for (i = 0; ret == 0 && i < len; ++i) {
566 ret = ivtv_readbyte(itv, &data[i], i == len - 1);
567 }
568 ivtv_stop(itv);
569 }
570 if (ret)
571 IVTV_DEBUG_I2C("i2c read from %x failed\n", addr);
572 return ret;
573 }
574
575
576
577
578 static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
579 {
580 struct v4l2_device *v4l2_dev = i2c_get_adapdata(i2c_adap);
581 struct ivtv *itv = to_ivtv(v4l2_dev);
582 int retval;
583 int i;
584
585 mutex_lock(&itv->i2c_bus_lock);
586 for (i = retval = 0; retval == 0 && i < num; i++) {
587 if (msgs[i].flags & I2C_M_RD)
588 retval = ivtv_read(itv, msgs[i].addr, msgs[i].buf, msgs[i].len);
589 else {
590
591 int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD);
592
593 retval = ivtv_write(itv, msgs[i].addr, msgs[i].buf, msgs[i].len, stop);
594 }
595 }
596 mutex_unlock(&itv->i2c_bus_lock);
597 return retval ? retval : num;
598 }
599
600
601 static u32 ivtv_functionality(struct i2c_adapter *adap)
602 {
603 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
604 }
605
606 static const struct i2c_algorithm ivtv_algo = {
607 .master_xfer = ivtv_xfer,
608 .functionality = ivtv_functionality,
609 };
610
611
612 static const struct i2c_adapter ivtv_i2c_adap_hw_template = {
613 .name = "ivtv i2c driver",
614 .algo = &ivtv_algo,
615 .algo_data = NULL,
616 .owner = THIS_MODULE,
617 };
618
619 static void ivtv_setscl_old(void *data, int state)
620 {
621 struct ivtv *itv = (struct ivtv *)data;
622
623 if (state)
624 itv->i2c_state |= 0x01;
625 else
626 itv->i2c_state &= ~0x01;
627
628
629
630 write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET);
631 }
632
633 static void ivtv_setsda_old(void *data, int state)
634 {
635 struct ivtv *itv = (struct ivtv *)data;
636
637 if (state)
638 itv->i2c_state |= 0x01;
639 else
640 itv->i2c_state &= ~0x01;
641
642
643
644 write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSDA_OFFSET);
645 }
646
647 static int ivtv_getscl_old(void *data)
648 {
649 struct ivtv *itv = (struct ivtv *)data;
650
651 return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
652 }
653
654 static int ivtv_getsda_old(void *data)
655 {
656 struct ivtv *itv = (struct ivtv *)data;
657
658 return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
659 }
660
661
662 static const struct i2c_adapter ivtv_i2c_adap_template = {
663 .name = "ivtv i2c driver",
664 .algo = NULL,
665 .algo_data = NULL,
666 .owner = THIS_MODULE,
667 };
668
669 #define IVTV_ALGO_BIT_TIMEOUT (2)
670
671 static const struct i2c_algo_bit_data ivtv_i2c_algo_template = {
672 .setsda = ivtv_setsda_old,
673 .setscl = ivtv_setscl_old,
674 .getsda = ivtv_getsda_old,
675 .getscl = ivtv_getscl_old,
676 .udelay = IVTV_DEFAULT_I2C_CLOCK_PERIOD / 2,
677 .timeout = IVTV_ALGO_BIT_TIMEOUT * HZ,
678 };
679
680 static const struct i2c_client ivtv_i2c_client_template = {
681 .name = "ivtv internal",
682 };
683
684
685 int init_ivtv_i2c(struct ivtv *itv)
686 {
687 int retval;
688
689 IVTV_DEBUG_I2C("i2c init\n");
690
691
692
693
694 if (ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_addrs)) {
695 IVTV_ERR("Mismatched I2C hardware arrays\n");
696 return -ENODEV;
697 }
698 if (itv->options.newi2c > 0) {
699 itv->i2c_adap = ivtv_i2c_adap_hw_template;
700 } else {
701 itv->i2c_adap = ivtv_i2c_adap_template;
702 itv->i2c_algo = ivtv_i2c_algo_template;
703 }
704 itv->i2c_algo.udelay = itv->options.i2c_clock_period / 2;
705 itv->i2c_algo.data = itv;
706 itv->i2c_adap.algo_data = &itv->i2c_algo;
707
708 sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d",
709 itv->instance);
710 i2c_set_adapdata(&itv->i2c_adap, &itv->v4l2_dev);
711
712 itv->i2c_client = ivtv_i2c_client_template;
713 itv->i2c_client.adapter = &itv->i2c_adap;
714 itv->i2c_adap.dev.parent = &itv->pdev->dev;
715
716 IVTV_DEBUG_I2C("setting scl and sda to 1\n");
717 ivtv_setscl(itv, 1);
718 ivtv_setsda(itv, 1);
719
720 if (itv->options.newi2c > 0)
721 retval = i2c_add_adapter(&itv->i2c_adap);
722 else
723 retval = i2c_bit_add_bus(&itv->i2c_adap);
724
725 return retval;
726 }
727
728 void exit_ivtv_i2c(struct ivtv *itv)
729 {
730 IVTV_DEBUG_I2C("i2c exit\n");
731
732 i2c_del_adapter(&itv->i2c_adap);
733 }