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