1 /*
2 em28xx-i2c.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
3
4 Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
5 Markus Rechberger <mrechberger@gmail.com>
6 Mauro Carvalho Chehab <mchehab@infradead.org>
7 Sascha Sommer <saschasommer@freenet.de>
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/usb.h>
27 #include <linux/i2c.h>
28
29 #include "em28xx.h"
30 #include "tuner-xc2028.h"
31 #include <media/v4l2-common.h>
32 #include <media/tuner.h>
33
34 /* ----------------------------------------------------------- */
35
36 static unsigned int i2c_scan;
37 module_param(i2c_scan, int, 0444);
38 MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
39
40 static unsigned int i2c_debug;
41 module_param(i2c_debug, int, 0644);
42 MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
43
44
45 #define dprintk1(lvl, fmt, args...) \
46 do { \
47 if (i2c_debug >= lvl) { \
48 printk(fmt, ##args); \
49 } \
50 } while (0)
51
52 #define dprintk2(lvl, fmt, args...) \
53 do { \
54 if (i2c_debug >= lvl) { \
55 printk(KERN_DEBUG "%s at %s: " fmt, \
56 dev->name, __func__ , ##args); \
57 } \
58 } while (0)
59
60 /*
61 * em2800_i2c_send_max4()
62 * send up to 4 bytes to the i2c device
63 */
em2800_i2c_send_max4(struct em28xx * dev,unsigned char addr,char * buf,int len)64 static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
65 char *buf, int len)
66 {
67 int ret;
68 int write_timeout;
69 unsigned char b2[6];
70 BUG_ON(len < 1 || len > 4);
71 b2[5] = 0x80 + len - 1;
72 b2[4] = addr;
73 b2[3] = buf[0];
74 if (len > 1)
75 b2[2] = buf[1];
76 if (len > 2)
77 b2[1] = buf[2];
78 if (len > 3)
79 b2[0] = buf[3];
80
81 ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
82 if (ret != 2 + len) {
83 em28xx_warn("writing to i2c device failed (error=%i)\n", ret);
84 return -EIO;
85 }
86 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
87 write_timeout -= 5) {
88 ret = dev->em28xx_read_reg(dev, 0x05);
89 if (ret == 0x80 + len - 1)
90 return len;
91 msleep(5);
92 }
93 em28xx_warn("i2c write timed out\n");
94 return -EIO;
95 }
96
97 /*
98 * em2800_i2c_send_bytes()
99 */
em2800_i2c_send_bytes(void * data,unsigned char addr,char * buf,short len)100 static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf,
101 short len)
102 {
103 char *bufPtr = buf;
104 int ret;
105 int wrcount = 0;
106 int count;
107 int maxLen = 4;
108 struct em28xx *dev = (struct em28xx *)data;
109 while (len > 0) {
110 count = (len > maxLen) ? maxLen : len;
111 ret = em2800_i2c_send_max4(dev, addr, bufPtr, count);
112 if (ret > 0) {
113 len -= count;
114 bufPtr += count;
115 wrcount += count;
116 } else
117 return (ret < 0) ? ret : -EFAULT;
118 }
119 return wrcount;
120 }
121
122 /*
123 * em2800_i2c_check_for_device()
124 * check if there is a i2c_device at the supplied address
125 */
em2800_i2c_check_for_device(struct em28xx * dev,unsigned char addr)126 static int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
127 {
128 char msg;
129 int ret;
130 int write_timeout;
131 msg = addr;
132 ret = dev->em28xx_write_regs(dev, 0x04, &msg, 1);
133 if (ret < 0) {
134 em28xx_warn("setting i2c device address failed (error=%i)\n",
135 ret);
136 return ret;
137 }
138 msg = 0x84;
139 ret = dev->em28xx_write_regs(dev, 0x05, &msg, 1);
140 if (ret < 0) {
141 em28xx_warn("preparing i2c read failed (error=%i)\n", ret);
142 return ret;
143 }
144 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
145 write_timeout -= 5) {
146 unsigned reg = dev->em28xx_read_reg(dev, 0x5);
147
148 if (reg == 0x94)
149 return -ENODEV;
150 else if (reg == 0x84)
151 return 0;
152 msleep(5);
153 }
154 return -ENODEV;
155 }
156
157 /*
158 * em2800_i2c_recv_bytes()
159 * read from the i2c device
160 */
em2800_i2c_recv_bytes(struct em28xx * dev,unsigned char addr,char * buf,int len)161 static int em2800_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
162 char *buf, int len)
163 {
164 int ret;
165 /* check for the device and set i2c read address */
166 ret = em2800_i2c_check_for_device(dev, addr);
167 if (ret) {
168 em28xx_warn
169 ("preparing read at i2c address 0x%x failed (error=%i)\n",
170 addr, ret);
171 return ret;
172 }
173 ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x3, buf, len);
174 if (ret < 0) {
175 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
176 addr, ret);
177 return ret;
178 }
179 return ret;
180 }
181
182 /*
183 * em28xx_i2c_send_bytes()
184 * untested for more than 4 bytes
185 */
em28xx_i2c_send_bytes(void * data,unsigned char addr,char * buf,short len,int stop)186 static int em28xx_i2c_send_bytes(void *data, unsigned char addr, char *buf,
187 short len, int stop)
188 {
189 int wrcount = 0;
190 struct em28xx *dev = (struct em28xx *)data;
191
192 wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
193
194 return wrcount;
195 }
196
197 /*
198 * em28xx_i2c_recv_bytes()
199 * read a byte from the i2c device
200 */
em28xx_i2c_recv_bytes(struct em28xx * dev,unsigned char addr,char * buf,int len)201 static int em28xx_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
202 char *buf, int len)
203 {
204 int ret;
205 ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
206 if (ret < 0) {
207 em28xx_warn("reading i2c device failed (error=%i)\n", ret);
208 return ret;
209 }
210 if (dev->em28xx_read_reg(dev, 0x5) != 0)
211 return -ENODEV;
212 return ret;
213 }
214
215 /*
216 * em28xx_i2c_check_for_device()
217 * check if there is a i2c_device at the supplied address
218 */
em28xx_i2c_check_for_device(struct em28xx * dev,unsigned char addr)219 static int em28xx_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
220 {
221 char msg;
222 int ret;
223 msg = addr;
224
225 ret = dev->em28xx_read_reg_req(dev, 2, addr);
226 if (ret < 0) {
227 em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
228 return ret;
229 }
230 if (dev->em28xx_read_reg(dev, 0x5) != 0)
231 return -ENODEV;
232 return 0;
233 }
234
235 /*
236 * em28xx_i2c_xfer()
237 * the main i2c transfer function
238 */
em28xx_i2c_xfer(struct i2c_adapter * i2c_adap,struct i2c_msg msgs[],int num)239 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
240 struct i2c_msg msgs[], int num)
241 {
242 struct em28xx *dev = i2c_adap->algo_data;
243 int addr, rc, i, byte;
244
245 if (num <= 0)
246 return 0;
247 for (i = 0; i < num; i++) {
248 addr = msgs[i].addr << 1;
249 dprintk2(2, "%s %s addr=%x len=%d:",
250 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
251 i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
252 if (!msgs[i].len) { /* no len: check only for device presence */
253 if (dev->board.is_em2800)
254 rc = em2800_i2c_check_for_device(dev, addr);
255 else
256 rc = em28xx_i2c_check_for_device(dev, addr);
257 if (rc < 0) {
258 dprintk2(2, " no device\n");
259 return rc;
260 }
261
262 } else if (msgs[i].flags & I2C_M_RD) {
263 /* read bytes */
264 if (dev->board.is_em2800)
265 rc = em2800_i2c_recv_bytes(dev, addr,
266 msgs[i].buf,
267 msgs[i].len);
268 else
269 rc = em28xx_i2c_recv_bytes(dev, addr,
270 msgs[i].buf,
271 msgs[i].len);
272 if (i2c_debug >= 2) {
273 for (byte = 0; byte < msgs[i].len; byte++)
274 printk(" %02x", msgs[i].buf[byte]);
275 }
276 } else {
277 /* write bytes */
278 if (i2c_debug >= 2) {
279 for (byte = 0; byte < msgs[i].len; byte++)
280 printk(" %02x", msgs[i].buf[byte]);
281 }
282 if (dev->board.is_em2800)
283 rc = em2800_i2c_send_bytes(dev, addr,
284 msgs[i].buf,
285 msgs[i].len);
286 else
287 rc = em28xx_i2c_send_bytes(dev, addr,
288 msgs[i].buf,
289 msgs[i].len,
290 i == num - 1);
291 }
292 if (rc < 0)
293 goto err;
294 if (i2c_debug >= 2)
295 printk("\n");
296 }
297
298 return num;
299 err:
300 dprintk2(2, " ERROR: %i\n", rc);
301 return rc;
302 }
303
304 /* based on linux/sunrpc/svcauth.h and linux/hash.h
305 * The original hash function returns a different value, if arch is x86_64
306 * or i386.
307 */
em28xx_hash_mem(char * buf,int length,int bits)308 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
309 {
310 unsigned long hash = 0;
311 unsigned long l = 0;
312 int len = 0;
313 unsigned char c;
314 do {
315 if (len == length) {
316 c = (char)len;
317 len = -1;
318 } else
319 c = *buf++;
320 l = (l << 8) | c;
321 len++;
322 if ((len & (32 / 8 - 1)) == 0)
323 hash = ((hash^l) * 0x9e370001UL);
324 } while (len);
325
326 return (hash >> (32 - bits)) & 0xffffffffUL;
327 }
328
em28xx_i2c_eeprom(struct em28xx * dev,unsigned char * eedata,int len)329 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
330 {
331 unsigned char buf, *p = eedata;
332 struct em28xx_eeprom *em_eeprom = (void *)eedata;
333 int i, err, size = len, block;
334
335 if (dev->chip_id == CHIP_ID_EM2874) {
336 /* Empia switched to a 16-bit addressable eeprom in newer
337 devices. While we could certainly write a routine to read
338 the eeprom, there is nothing of use in there that cannot be
339 accessed through registers, and there is the risk that we
340 could corrupt the eeprom (since a 16-bit read call is
341 interpreted as a write call by 8-bit eeproms).
342 */
343 return 0;
344 }
345
346 dev->i2c_client.addr = 0xa0 >> 1;
347
348 /* Check if board has eeprom */
349 err = i2c_master_recv(&dev->i2c_client, &buf, 0);
350 if (err < 0) {
351 em28xx_errdev("board has no eeprom\n");
352 memset(eedata, 0, len);
353 return -ENODEV;
354 }
355
356 buf = 0;
357
358 err = i2c_master_send(&dev->i2c_client, &buf, 1);
359 if (err != 1) {
360 printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
361 dev->name, err);
362 return err;
363 }
364 while (size > 0) {
365 if (size > 16)
366 block = 16;
367 else
368 block = size;
369
370 if (block !=
371 (err = i2c_master_recv(&dev->i2c_client, p, block))) {
372 printk(KERN_WARNING
373 "%s: i2c eeprom read error (err=%d)\n",
374 dev->name, err);
375 return err;
376 }
377 size -= block;
378 p += block;
379 }
380 for (i = 0; i < len; i++) {
381 if (0 == (i % 16))
382 printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
383 printk(" %02x", eedata[i]);
384 if (15 == (i % 16))
385 printk("\n");
386 }
387
388 if (em_eeprom->id == 0x9567eb1a)
389 dev->hash = em28xx_hash_mem(eedata, len, 32);
390
391 printk(KERN_INFO "%s: EEPROM ID= 0x%08x, EEPROM hash = 0x%08lx\n",
392 dev->name, em_eeprom->id, dev->hash);
393
394 printk(KERN_INFO "%s: EEPROM info:\n", dev->name);
395
396 switch (em_eeprom->chip_conf >> 4 & 0x3) {
397 case 0:
398 printk(KERN_INFO "%s:\tNo audio on board.\n", dev->name);
399 break;
400 case 1:
401 printk(KERN_INFO "%s:\tAC97 audio (5 sample rates)\n",
402 dev->name);
403 break;
404 case 2:
405 printk(KERN_INFO "%s:\tI2S audio, sample rate=32k\n", dev->name);
406 break;
407 case 3:
408 printk(KERN_INFO "%s:\tI2S audio, 3 sample rates\n", dev->name);
409 break;
410 }
411
412 if (em_eeprom->chip_conf & 1 << 3)
413 printk(KERN_INFO "%s:\tUSB Remote wakeup capable\n", dev->name);
414
415 if (em_eeprom->chip_conf & 1 << 2)
416 printk(KERN_INFO "%s:\tUSB Self power capable\n", dev->name);
417
418 switch (em_eeprom->chip_conf & 0x3) {
419 case 0:
420 printk(KERN_INFO "%s:\t500mA max power\n", dev->name);
421 break;
422 case 1:
423 printk(KERN_INFO "%s:\t400mA max power\n", dev->name);
424 break;
425 case 2:
426 printk(KERN_INFO "%s:\t300mA max power\n", dev->name);
427 break;
428 case 3:
429 printk(KERN_INFO "%s:\t200mA max power\n", dev->name);
430 break;
431 }
432 printk(KERN_INFO "%s:\tTable at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
433 dev->name,
434 em_eeprom->string_idx_table,
435 em_eeprom->string1,
436 em_eeprom->string2,
437 em_eeprom->string3);
438
439 return 0;
440 }
441
442 /* ----------------------------------------------------------- */
443
444 /*
445 * functionality()
446 */
functionality(struct i2c_adapter * adap)447 static u32 functionality(struct i2c_adapter *adap)
448 {
449 return I2C_FUNC_SMBUS_EMUL;
450 }
451
452 /*
453 * attach_inform()
454 * gets called when a device attaches to the i2c bus
455 * does some basic configuration
456 */
attach_inform(struct i2c_client * client)457 static int attach_inform(struct i2c_client *client)
458 {
459 struct em28xx *dev = client->adapter->algo_data;
460
461 switch (client->addr << 1) {
462 case 0x86:
463 case 0x84:
464 case 0x96:
465 case 0x94:
466 {
467 struct v4l2_priv_tun_config tda9887_cfg;
468
469 struct tuner_setup tun_setup;
470
471 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
472 tun_setup.type = TUNER_TDA9887;
473 tun_setup.addr = client->addr;
474
475 em28xx_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR,
476 &tun_setup);
477
478 tda9887_cfg.tuner = TUNER_TDA9887;
479 tda9887_cfg.priv = &dev->tda9887_conf;
480 em28xx_i2c_call_clients(dev, TUNER_SET_CONFIG,
481 &tda9887_cfg);
482 break;
483 }
484 case 0x42:
485 dprintk1(1, "attach_inform: saa7114 detected.\n");
486 break;
487 case 0x4a:
488 dprintk1(1, "attach_inform: saa7113 detected.\n");
489 break;
490 case 0xa0:
491 dprintk1(1, "attach_inform: eeprom detected.\n");
492 break;
493 case 0x60:
494 case 0x8e:
495 {
496 struct IR_i2c *ir = i2c_get_clientdata(client);
497 dprintk1(1, "attach_inform: IR detected (%s).\n",
498 ir->phys);
499 em28xx_set_ir(dev, ir);
500 break;
501 }
502 case 0x80:
503 case 0x88:
504 dprintk1(1, "attach_inform: msp34xx detected.\n");
505 break;
506 case 0xb8:
507 case 0xba:
508 dprintk1(1, "attach_inform: tvp5150 detected.\n");
509 break;
510
511 default:
512 if (!dev->tuner_addr)
513 dev->tuner_addr = client->addr;
514
515 dprintk1(1, "attach inform: detected I2C address %x\n",
516 client->addr << 1);
517
518 }
519
520 return 0;
521 }
522
523 static struct i2c_algorithm em28xx_algo = {
524 .master_xfer = em28xx_i2c_xfer,
525 .functionality = functionality,
526 };
527
528 static struct i2c_adapter em28xx_adap_template = {
529 .owner = THIS_MODULE,
530 .class = I2C_CLASS_TV_ANALOG,
531 .name = "em28xx",
532 .id = I2C_HW_B_EM28XX,
533 .algo = &em28xx_algo,
534 .client_register = attach_inform,
535 };
536
537 static struct i2c_client em28xx_client_template = {
538 .name = "em28xx internal",
539 };
540
541 /* ----------------------------------------------------------- */
542
543 /*
544 * i2c_devs
545 * incomplete list of known devices
546 */
547 static char *i2c_devs[128] = {
548 [0x4a >> 1] = "saa7113h",
549 [0x60 >> 1] = "remote IR sensor",
550 [0x8e >> 1] = "remote IR sensor",
551 [0x86 >> 1] = "tda9887",
552 [0x80 >> 1] = "msp34xx",
553 [0x88 >> 1] = "msp34xx",
554 [0xa0 >> 1] = "eeprom",
555 [0xb8 >> 1] = "tvp5150a",
556 [0xba >> 1] = "tvp5150a",
557 [0xc0 >> 1] = "tuner (analog)",
558 [0xc2 >> 1] = "tuner (analog)",
559 [0xc4 >> 1] = "tuner (analog)",
560 [0xc6 >> 1] = "tuner (analog)",
561 };
562
563 /*
564 * do_i2c_scan()
565 * check i2c address range for devices
566 */
em28xx_do_i2c_scan(struct em28xx * dev)567 void em28xx_do_i2c_scan(struct em28xx *dev)
568 {
569 u8 i2c_devicelist[128];
570 unsigned char buf;
571 int i, rc;
572
573 memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
574
575 for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
576 dev->i2c_client.addr = i;
577 rc = i2c_master_recv(&dev->i2c_client, &buf, 0);
578 if (rc < 0)
579 continue;
580 i2c_devicelist[i] = i;
581 printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n",
582 dev->name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
583 }
584
585 dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
586 ARRAY_SIZE(i2c_devicelist), 32);
587 }
588
589 /*
590 * em28xx_i2c_call_clients()
591 * send commands to all attached i2c devices
592 */
em28xx_i2c_call_clients(struct em28xx * dev,unsigned int cmd,void * arg)593 void em28xx_i2c_call_clients(struct em28xx *dev, unsigned int cmd, void *arg)
594 {
595 BUG_ON(NULL == dev->i2c_adap.algo_data);
596 i2c_clients_command(&dev->i2c_adap, cmd, arg);
597 }
598
599 /*
600 * em28xx_i2c_register()
601 * register i2c bus
602 */
em28xx_i2c_register(struct em28xx * dev)603 int em28xx_i2c_register(struct em28xx *dev)
604 {
605 int retval;
606
607 BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
608 BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
609 dev->i2c_adap = em28xx_adap_template;
610 dev->i2c_adap.dev.parent = &dev->udev->dev;
611 strcpy(dev->i2c_adap.name, dev->name);
612 dev->i2c_adap.algo_data = dev;
613
614 retval = i2c_add_adapter(&dev->i2c_adap);
615 if (retval < 0) {
616 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
617 __func__, retval);
618 return retval;
619 }
620
621 dev->i2c_client = em28xx_client_template;
622 dev->i2c_client.adapter = &dev->i2c_adap;
623
624 retval = em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
625 if ((retval < 0) && (retval != -ENODEV)) {
626 em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
627 __func__, retval);
628
629 return retval;
630 }
631
632 if (i2c_scan)
633 em28xx_do_i2c_scan(dev);
634
635 return 0;
636 }
637
638 /*
639 * em28xx_i2c_unregister()
640 * unregister i2c_bus
641 */
em28xx_i2c_unregister(struct em28xx * dev)642 int em28xx_i2c_unregister(struct em28xx *dev)
643 {
644 i2c_del_adapter(&dev->i2c_adap);
645 return 0;
646 }
647