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 */
em28xx_i2c_send_bytes(void * data,unsigned char addr,char * buf,short len,int stop)185 static int em28xx_i2c_send_bytes(void *data, unsigned char addr, char *buf,
186 short len, int stop)
187 {
188 int wrcount = 0;
189 struct em28xx *dev = (struct em28xx *)data;
190 int write_timeout, ret;
191
192 wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
193
194 /* Seems to be required after a write */
195 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
196 write_timeout -= 5) {
197 ret = dev->em28xx_read_reg(dev, 0x05);
198 if (!ret)
199 break;
200 msleep(5);
201 }
202
203 return wrcount;
204 }
205
206 /*
207 * em28xx_i2c_recv_bytes()
208 * read a byte from the i2c device
209 */
em28xx_i2c_recv_bytes(struct em28xx * dev,unsigned char addr,char * buf,int len)210 static int em28xx_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
211 char *buf, int len)
212 {
213 int ret;
214 ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
215 if (ret < 0) {
216 em28xx_warn("reading i2c device failed (error=%i)\n", ret);
217 return ret;
218 }
219 if (dev->em28xx_read_reg(dev, 0x5) != 0)
220 return -ENODEV;
221 return ret;
222 }
223
224 /*
225 * em28xx_i2c_check_for_device()
226 * check if there is a i2c_device at the supplied address
227 */
em28xx_i2c_check_for_device(struct em28xx * dev,unsigned char addr)228 static int em28xx_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
229 {
230 int ret;
231
232 ret = dev->em28xx_read_reg_req(dev, 2, addr);
233 if (ret < 0) {
234 em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
235 return ret;
236 }
237 if (dev->em28xx_read_reg(dev, 0x5) != 0)
238 return -ENODEV;
239 return 0;
240 }
241
242 /*
243 * em28xx_i2c_xfer()
244 * the main i2c transfer function
245 */
em28xx_i2c_xfer(struct i2c_adapter * i2c_adap,struct i2c_msg msgs[],int num)246 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
247 struct i2c_msg msgs[], int num)
248 {
249 struct em28xx *dev = i2c_adap->algo_data;
250 int addr, rc, i, byte;
251
252 if (num <= 0)
253 return 0;
254 for (i = 0; i < num; i++) {
255 addr = msgs[i].addr << 1;
256 dprintk2(2, "%s %s addr=%x len=%d:",
257 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
258 i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
259 if (!msgs[i].len) { /* no len: check only for device presence */
260 if (dev->board.is_em2800)
261 rc = em2800_i2c_check_for_device(dev, addr);
262 else
263 rc = em28xx_i2c_check_for_device(dev, addr);
264 if (rc < 0) {
265 dprintk2(2, " no device\n");
266 return rc;
267 }
268
269 } else if (msgs[i].flags & I2C_M_RD) {
270 /* read bytes */
271 if (dev->board.is_em2800)
272 rc = em2800_i2c_recv_bytes(dev, addr,
273 msgs[i].buf,
274 msgs[i].len);
275 else
276 rc = em28xx_i2c_recv_bytes(dev, addr,
277 msgs[i].buf,
278 msgs[i].len);
279 if (i2c_debug >= 2) {
280 for (byte = 0; byte < msgs[i].len; byte++)
281 printk(" %02x", msgs[i].buf[byte]);
282 }
283 } else {
284 /* write bytes */
285 if (i2c_debug >= 2) {
286 for (byte = 0; byte < msgs[i].len; byte++)
287 printk(" %02x", msgs[i].buf[byte]);
288 }
289 if (dev->board.is_em2800)
290 rc = em2800_i2c_send_bytes(dev, addr,
291 msgs[i].buf,
292 msgs[i].len);
293 else
294 rc = em28xx_i2c_send_bytes(dev, addr,
295 msgs[i].buf,
296 msgs[i].len,
297 i == num - 1);
298 }
299 if (rc < 0)
300 goto err;
301 if (i2c_debug >= 2)
302 printk("\n");
303 }
304
305 return num;
306 err:
307 dprintk2(2, " ERROR: %i\n", rc);
308 return rc;
309 }
310
311 /* based on linux/sunrpc/svcauth.h and linux/hash.h
312 * The original hash function returns a different value, if arch is x86_64
313 * or i386.
314 */
em28xx_hash_mem(char * buf,int length,int bits)315 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
316 {
317 unsigned long hash = 0;
318 unsigned long l = 0;
319 int len = 0;
320 unsigned char c;
321 do {
322 if (len == length) {
323 c = (char)len;
324 len = -1;
325 } else
326 c = *buf++;
327 l = (l << 8) | c;
328 len++;
329 if ((len & (32 / 8 - 1)) == 0)
330 hash = ((hash^l) * 0x9e370001UL);
331 } while (len);
332
333 return (hash >> (32 - bits)) & 0xffffffffUL;
334 }
335
em28xx_i2c_eeprom(struct em28xx * dev,unsigned char * eedata,int len)336 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
337 {
338 unsigned char buf, *p = eedata;
339 struct em28xx_eeprom *em_eeprom = (void *)eedata;
340 int i, err, size = len, block;
341
342 if (dev->chip_id == CHIP_ID_EM2874 ||
343 dev->chip_id == CHIP_ID_EM28174 ||
344 dev->chip_id == CHIP_ID_EM2884) {
345 /* Empia switched to a 16-bit addressable eeprom in newer
346 devices. While we could certainly write a routine to read
347 the eeprom, there is nothing of use in there that cannot be
348 accessed through registers, and there is the risk that we
349 could corrupt the eeprom (since a 16-bit read call is
350 interpreted as a write call by 8-bit eeproms).
351 */
352 return 0;
353 }
354
355 dev->i2c_client.addr = 0xa0 >> 1;
356
357 /* Check if board has eeprom */
358 err = i2c_master_recv(&dev->i2c_client, &buf, 0);
359 if (err < 0) {
360 em28xx_errdev("board has no eeprom\n");
361 memset(eedata, 0, len);
362 return -ENODEV;
363 }
364
365 buf = 0;
366
367 err = i2c_master_send(&dev->i2c_client, &buf, 1);
368 if (err != 1) {
369 printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
370 dev->name, err);
371 return err;
372 }
373 while (size > 0) {
374 if (size > 16)
375 block = 16;
376 else
377 block = size;
378
379 if (block !=
380 (err = i2c_master_recv(&dev->i2c_client, p, block))) {
381 printk(KERN_WARNING
382 "%s: i2c eeprom read error (err=%d)\n",
383 dev->name, err);
384 return err;
385 }
386 size -= block;
387 p += block;
388 }
389 for (i = 0; i < len; i++) {
390 if (0 == (i % 16))
391 printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
392 printk(" %02x", eedata[i]);
393 if (15 == (i % 16))
394 printk("\n");
395 }
396
397 if (em_eeprom->id == 0x9567eb1a)
398 dev->hash = em28xx_hash_mem(eedata, len, 32);
399
400 printk(KERN_INFO "%s: EEPROM ID= 0x%08x, EEPROM hash = 0x%08lx\n",
401 dev->name, em_eeprom->id, dev->hash);
402
403 printk(KERN_INFO "%s: EEPROM info:\n", dev->name);
404
405 switch (em_eeprom->chip_conf >> 4 & 0x3) {
406 case 0:
407 printk(KERN_INFO "%s:\tNo audio on board.\n", dev->name);
408 break;
409 case 1:
410 printk(KERN_INFO "%s:\tAC97 audio (5 sample rates)\n",
411 dev->name);
412 break;
413 case 2:
414 printk(KERN_INFO "%s:\tI2S audio, sample rate=32k\n",
415 dev->name);
416 break;
417 case 3:
418 printk(KERN_INFO "%s:\tI2S audio, 3 sample rates\n",
419 dev->name);
420 break;
421 }
422
423 if (em_eeprom->chip_conf & 1 << 3)
424 printk(KERN_INFO "%s:\tUSB Remote wakeup capable\n", dev->name);
425
426 if (em_eeprom->chip_conf & 1 << 2)
427 printk(KERN_INFO "%s:\tUSB Self power capable\n", dev->name);
428
429 switch (em_eeprom->chip_conf & 0x3) {
430 case 0:
431 printk(KERN_INFO "%s:\t500mA max power\n", dev->name);
432 break;
433 case 1:
434 printk(KERN_INFO "%s:\t400mA max power\n", dev->name);
435 break;
436 case 2:
437 printk(KERN_INFO "%s:\t300mA max power\n", dev->name);
438 break;
439 case 3:
440 printk(KERN_INFO "%s:\t200mA max power\n", dev->name);
441 break;
442 }
443 printk(KERN_INFO "%s:\tTable at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
444 dev->name,
445 em_eeprom->string_idx_table,
446 em_eeprom->string1,
447 em_eeprom->string2,
448 em_eeprom->string3);
449
450 return 0;
451 }
452
453 /* ----------------------------------------------------------- */
454
455 /*
456 * functionality()
457 */
functionality(struct i2c_adapter * adap)458 static u32 functionality(struct i2c_adapter *adap)
459 {
460 return I2C_FUNC_SMBUS_EMUL;
461 }
462
463 static struct i2c_algorithm em28xx_algo = {
464 .master_xfer = em28xx_i2c_xfer,
465 .functionality = functionality,
466 };
467
468 static struct i2c_adapter em28xx_adap_template = {
469 .owner = THIS_MODULE,
470 .name = "em28xx",
471 .algo = &em28xx_algo,
472 };
473
474 static struct i2c_client em28xx_client_template = {
475 .name = "em28xx internal",
476 };
477
478 /* ----------------------------------------------------------- */
479
480 /*
481 * i2c_devs
482 * incomplete list of known devices
483 */
484 static char *i2c_devs[128] = {
485 [0x4a >> 1] = "saa7113h",
486 [0x60 >> 1] = "remote IR sensor",
487 [0x8e >> 1] = "remote IR sensor",
488 [0x86 >> 1] = "tda9887",
489 [0x80 >> 1] = "msp34xx",
490 [0x88 >> 1] = "msp34xx",
491 [0xa0 >> 1] = "eeprom",
492 [0xb0 >> 1] = "tda9874",
493 [0xb8 >> 1] = "tvp5150a",
494 [0xba >> 1] = "webcam sensor or tvp5150a",
495 [0xc0 >> 1] = "tuner (analog)",
496 [0xc2 >> 1] = "tuner (analog)",
497 [0xc4 >> 1] = "tuner (analog)",
498 [0xc6 >> 1] = "tuner (analog)",
499 };
500
501 /*
502 * do_i2c_scan()
503 * check i2c address range for devices
504 */
em28xx_do_i2c_scan(struct em28xx * dev)505 void em28xx_do_i2c_scan(struct em28xx *dev)
506 {
507 u8 i2c_devicelist[128];
508 unsigned char buf;
509 int i, rc;
510
511 memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
512
513 for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
514 dev->i2c_client.addr = i;
515 rc = i2c_master_recv(&dev->i2c_client, &buf, 0);
516 if (rc < 0)
517 continue;
518 i2c_devicelist[i] = i;
519 printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n",
520 dev->name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
521 }
522
523 dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
524 ARRAY_SIZE(i2c_devicelist), 32);
525 }
526
527 /*
528 * em28xx_i2c_register()
529 * register i2c bus
530 */
em28xx_i2c_register(struct em28xx * dev)531 int em28xx_i2c_register(struct em28xx *dev)
532 {
533 int retval;
534
535 BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
536 BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
537 dev->i2c_adap = em28xx_adap_template;
538 dev->i2c_adap.dev.parent = &dev->udev->dev;
539 strcpy(dev->i2c_adap.name, dev->name);
540 dev->i2c_adap.algo_data = dev;
541 i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
542
543 retval = i2c_add_adapter(&dev->i2c_adap);
544 if (retval < 0) {
545 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
546 __func__, retval);
547 return retval;
548 }
549
550 dev->i2c_client = em28xx_client_template;
551 dev->i2c_client.adapter = &dev->i2c_adap;
552
553 retval = em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
554 if ((retval < 0) && (retval != -ENODEV)) {
555 em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
556 __func__, retval);
557
558 return retval;
559 }
560
561 if (i2c_scan)
562 em28xx_do_i2c_scan(dev);
563
564 /* Instantiate the IR receiver device, if present */
565 em28xx_register_i2c_ir(dev);
566
567 return 0;
568 }
569
570 /*
571 * em28xx_i2c_unregister()
572 * unregister i2c_bus
573 */
em28xx_i2c_unregister(struct em28xx * dev)574 int em28xx_i2c_unregister(struct em28xx *dev)
575 {
576 i2c_del_adapter(&dev->i2c_adap);
577 return 0;
578 }
579