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