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