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