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