aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video/em28xx/em28xx-i2c.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/video/em28xx/em28xx-i2c.c')
-rw-r--r--drivers/media/video/em28xx/em28xx-i2c.c586
1 files changed, 586 insertions, 0 deletions
diff --git a/drivers/media/video/em28xx/em28xx-i2c.c b/drivers/media/video/em28xx/em28xx-i2c.c
new file mode 100644
index 000000000000..b32d9852f34c
--- /dev/null
+++ b/drivers/media/video/em28xx/em28xx-i2c.c
@@ -0,0 +1,586 @@
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@brturbo.com.br>
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#include <linux/video_decoder.h>
29
30#include "em28xx.h"
31#include <media/tuner.h>
32
33/* ----------------------------------------------------------- */
34
35static unsigned int i2c_scan = 0;
36module_param(i2c_scan, int, 0444);
37MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
38
39static unsigned int i2c_debug = 0;
40module_param(i2c_debug, int, 0644);
41MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
42
43#define dprintk1(lvl,fmt, args...) if (i2c_debug>=lvl) do {\
44 printk(fmt , ##args); } while (0)
45#define dprintk2(lvl,fmt, args...) if (i2c_debug>=lvl) do{ \
46 printk(KERN_DEBUG "%s at %s: " fmt, \
47 dev->name, __FUNCTION__ , ##args); } while (0)
48
49/*
50 * em2800_i2c_send_max4()
51 * send up to 4 bytes to the i2c device
52 */
53static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
54 char *buf, int len)
55{
56 int ret;
57 int write_timeout;
58 unsigned char b2[6];
59 BUG_ON(len < 1 || len > 4);
60 b2[5] = 0x80 + len - 1;
61 b2[4] = addr;
62 b2[3] = buf[0];
63 if (len > 1)
64 b2[2] = buf[1];
65 if (len > 2)
66 b2[1] = buf[2];
67 if (len > 3)
68 b2[0] = buf[3];
69
70 ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
71 if (ret != 2 + len) {
72 em28xx_warn("writting to i2c device failed (error=%i)\n", ret);
73 return -EIO;
74 }
75 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
76 write_timeout -= 5) {
77 ret = dev->em28xx_read_reg(dev, 0x05);
78 if (ret == 0x80 + len - 1)
79 return len;
80 mdelay(5);
81 }
82 em28xx_warn("i2c write timed out\n");
83 return -EIO;
84}
85
86/*
87 * em2800_i2c_send_bytes()
88 */
89static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf,
90 short len)
91{
92 char *bufPtr = buf;
93 int ret;
94 int wrcount = 0;
95 int count;
96 int maxLen = 4;
97 struct em28xx *dev = (struct em28xx *)data;
98 while (len > 0) {
99 count = (len > maxLen) ? maxLen : len;
100 ret = em2800_i2c_send_max4(dev, addr, bufPtr, count);
101 if (ret > 0) {
102 len -= count;
103 bufPtr += count;
104 wrcount += count;
105 } else
106 return (ret < 0) ? ret : -EFAULT;
107 }
108 return wrcount;
109}
110
111/*
112 * em2800_i2c_check_for_device()
113 * check if there is a i2c_device at the supplied address
114 */
115static int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
116{
117 char msg;
118 int ret;
119 int write_timeout;
120 msg = addr;
121 ret = dev->em28xx_write_regs(dev, 0x04, &msg, 1);
122 if (ret < 0) {
123 em28xx_warn("setting i2c device address failed (error=%i)\n",
124 ret);
125 return ret;
126 }
127 msg = 0x84;
128 ret = dev->em28xx_write_regs(dev, 0x05, &msg, 1);
129 if (ret < 0) {
130 em28xx_warn("preparing i2c read failed (error=%i)\n", ret);
131 return ret;
132 }
133 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
134 write_timeout -= 5) {
135 unsigned msg = dev->em28xx_read_reg(dev, 0x5);
136 if (msg == 0x94)
137 return -ENODEV;
138 else if (msg == 0x84)
139 return 0;
140 mdelay(5);
141 }
142 return -ENODEV;
143}
144
145/*
146 * em2800_i2c_recv_bytes()
147 * read from the i2c device
148 */
149static int em2800_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
150 char *buf, int len)
151{
152 int ret;
153 /* check for the device and set i2c read address */
154 ret = em2800_i2c_check_for_device(dev, addr);
155 if (ret) {
156 em28xx_warn
157 ("preparing read at i2c address 0x%x failed (error=%i)\n",
158 addr, ret);
159 return ret;
160 }
161 ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x3, buf, len);
162 if (ret < 0) {
163 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
164 addr, ret);
165 return ret;
166 }
167 return ret;
168}
169
170/*
171 * em28xx_i2c_send_bytes()
172 * untested for more than 4 bytes
173 */
174static int em28xx_i2c_send_bytes(void *data, unsigned char addr, char *buf,
175 short len, int stop)
176{
177 int wrcount = 0;
178 struct em28xx *dev = (struct em28xx *)data;
179
180 wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
181
182 return wrcount;
183}
184
185/*
186 * em28xx_i2c_recv_bytes()
187 * read a byte from the i2c device
188 */
189static int em28xx_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
190 char *buf, int len)
191{
192 int ret;
193 ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
194 if (ret < 0) {
195 em28xx_warn("reading i2c device failed (error=%i)\n", ret);
196 return ret;
197 }
198 if (dev->em28xx_read_reg(dev, 0x5) != 0)
199 return -ENODEV;
200 return ret;
201}
202
203/*
204 * em28xx_i2c_check_for_device()
205 * check if there is a i2c_device at the supplied address
206 */
207static int em28xx_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
208{
209 char msg;
210 int ret;
211 msg = addr;
212
213 ret = dev->em28xx_read_reg_req(dev, 2, addr);
214 if (ret < 0) {
215 em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
216 return ret;
217 }
218 if (dev->em28xx_read_reg(dev, 0x5) != 0)
219 return -ENODEV;
220 return 0;
221}
222
223/*
224 * em28xx_i2c_xfer()
225 * the main i2c transfer function
226 */
227static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
228 struct i2c_msg msgs[], int num)
229{
230 struct em28xx *dev = i2c_adap->algo_data;
231 int addr, rc, i, byte;
232
233 if (num <= 0)
234 return 0;
235 for (i = 0; i < num; i++) {
236 addr = msgs[i].addr << 1;
237 dprintk2(2,"%s %s addr=%x len=%d:",
238 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
239 i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
240 if (!msgs[i].len) { /* no len: check only for device presence */
241 if (dev->is_em2800)
242 rc = em2800_i2c_check_for_device(dev, addr);
243 else
244 rc = em28xx_i2c_check_for_device(dev, addr);
245 if (rc < 0) {
246 dprintk2(2," no device\n");
247 return rc;
248 }
249
250 } else if (msgs[i].flags & I2C_M_RD) {
251 /* read bytes */
252 if (dev->is_em2800)
253 rc = em2800_i2c_recv_bytes(dev, addr,
254 msgs[i].buf,
255 msgs[i].len);
256 else
257 rc = em28xx_i2c_recv_bytes(dev, addr,
258 msgs[i].buf,
259 msgs[i].len);
260 if (i2c_debug>=2) {
261 for (byte = 0; byte < msgs[i].len; byte++) {
262 printk(" %02x", msgs[i].buf[byte]);
263 }
264 }
265 } else {
266 /* write bytes */
267 if (i2c_debug>=2) {
268 for (byte = 0; byte < msgs[i].len; byte++)
269 printk(" %02x", msgs[i].buf[byte]);
270 }
271 if (dev->is_em2800)
272 rc = em2800_i2c_send_bytes(dev, addr,
273 msgs[i].buf,
274 msgs[i].len);
275 else
276 rc = em28xx_i2c_send_bytes(dev, addr,
277 msgs[i].buf,
278 msgs[i].len,
279 i == num - 1);
280 if (rc < 0)
281 goto err;
282 }
283 if (i2c_debug>=2)
284 printk("\n");
285 }
286
287 return num;
288 err:
289 dprintk2(2," ERROR: %i\n", rc);
290 return rc;
291}
292
293static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
294{
295 unsigned char buf, *p = eedata;
296 struct em28xx_eeprom *em_eeprom = (void *)eedata;
297 int i, err, size = len, block;
298
299 dev->i2c_client.addr = 0xa0 >> 1;
300
301 /* Check if board has eeprom */
302 err = i2c_master_recv(&dev->i2c_client, &buf, 0);
303 if (err < 0)
304 return -1;
305
306 buf = 0;
307 if (1 != (err = i2c_master_send(&dev->i2c_client, &buf, 1))) {
308 printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
309 dev->name, err);
310 return -1;
311 }
312 while (size > 0) {
313 if (size > 16)
314 block = 16;
315 else
316 block = size;
317
318 if (block !=
319 (err = i2c_master_recv(&dev->i2c_client, p, block))) {
320 printk(KERN_WARNING
321 "%s: i2c eeprom read error (err=%d)\n",
322 dev->name, err);
323 return -1;
324 }
325 size -= block;
326 p += block;
327 }
328 for (i = 0; i < len; i++) {
329 if (0 == (i % 16))
330 printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
331 printk(" %02x", eedata[i]);
332 if (15 == (i % 16))
333 printk("\n");
334 }
335
336 printk(KERN_INFO "EEPROM ID= 0x%08x\n", em_eeprom->id);
337 printk(KERN_INFO "Vendor/Product ID= %04x:%04x\n", em_eeprom->vendor_ID,
338 em_eeprom->product_ID);
339
340 switch (em_eeprom->chip_conf >> 4 & 0x3) {
341 case 0:
342 printk(KERN_INFO "No audio on board.\n");
343 break;
344 case 1:
345 printk(KERN_INFO "AC97 audio (5 sample rates)\n");
346 break;
347 case 2:
348 printk(KERN_INFO "I2S audio, sample rate=32k\n");
349 break;
350 case 3:
351 printk(KERN_INFO "I2S audio, 3 sample rates\n");
352 break;
353 }
354
355 if (em_eeprom->chip_conf & 1 << 3)
356 printk(KERN_INFO "USB Remote wakeup capable\n");
357
358 if (em_eeprom->chip_conf & 1 << 2)
359 printk(KERN_INFO "USB Self power capable\n");
360
361 switch (em_eeprom->chip_conf & 0x3) {
362 case 0:
363 printk(KERN_INFO "500mA max power\n");
364 break;
365 case 1:
366 printk(KERN_INFO "400mA max power\n");
367 break;
368 case 2:
369 printk(KERN_INFO "300mA max power\n");
370 break;
371 case 3:
372 printk(KERN_INFO "200mA max power\n");
373 break;
374 }
375 printk(KERN_INFO "Table at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
376 em_eeprom->string_idx_table,em_eeprom->string1,
377 em_eeprom->string2,em_eeprom->string3);
378
379 return 0;
380}
381
382/* ----------------------------------------------------------- */
383
384/*
385 * algo_control()
386 */
387static int algo_control(struct i2c_adapter *adapter,
388 unsigned int cmd, unsigned long arg)
389{
390 return 0;
391}
392
393/*
394 * functionality()
395 */
396static u32 functionality(struct i2c_adapter *adap)
397{
398 return I2C_FUNC_SMBUS_EMUL;
399}
400
401#ifndef I2C_PEC
402static void inc_use(struct i2c_adapter *adap)
403{
404 MOD_INC_USE_COUNT;
405}
406
407static void dec_use(struct i2c_adapter *adap)
408{
409 MOD_DEC_USE_COUNT;
410}
411#endif
412
413static int em28xx_set_tuner(int check_eeprom, struct i2c_client *client)
414{
415 struct em28xx *dev = client->adapter->algo_data;
416 struct tuner_setup tun_setup;
417
418 if (dev->has_tuner) {
419 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
420 tun_setup.type = dev->tuner_type;
421 tun_setup.addr = dev->tuner_addr;
422
423 em28xx_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR, &tun_setup);
424 }
425
426 return (0);
427}
428
429/*
430 * attach_inform()
431 * gets called when a device attaches to the i2c bus
432 * does some basic configuration
433 */
434static int attach_inform(struct i2c_client *client)
435{
436 struct em28xx *dev = client->adapter->algo_data;
437
438 switch (client->addr << 1) {
439 case 0x86:
440 em28xx_i2c_call_clients(dev, TDA9887_SET_CONFIG, &dev->tda9887_conf);
441 break;
442 case 0x42:
443 dprintk1(1,"attach_inform: saa7114 detected.\n");
444 break;
445 case 0x4a:
446 dprintk1(1,"attach_inform: saa7113 detected.\n");
447 break;
448 case 0xa0:
449 dprintk1(1,"attach_inform: eeprom detected.\n");
450 break;
451 case 0x60:
452 case 0x8e:
453 {
454 struct IR_i2c *ir = i2c_get_clientdata(client);
455 dprintk1(1,"attach_inform: IR detected (%s).\n",ir->phys);
456 em28xx_set_ir(dev,ir);
457 break;
458 }
459 case 0x80:
460 case 0x88:
461 dprintk1(1,"attach_inform: msp34xx detected.\n");
462 break;
463 case 0xb8:
464 case 0xba:
465 dprintk1(1,"attach_inform: tvp5150 detected.\n");
466 break;
467 default:
468 dprintk1(1,"attach inform: detected I2C address %x\n", client->addr << 1);
469 dev->tuner_addr = client->addr;
470 em28xx_set_tuner(-1, client);
471 }
472
473 return 0;
474}
475
476static struct i2c_algorithm em28xx_algo = {
477 .master_xfer = em28xx_i2c_xfer,
478 .algo_control = algo_control,
479 .functionality = functionality,
480};
481
482static struct i2c_adapter em28xx_adap_template = {
483#ifdef I2C_PEC
484 .owner = THIS_MODULE,
485#else
486 .inc_use = inc_use,
487 .dec_use = dec_use,
488#endif
489#ifdef I2C_CLASS_TV_ANALOG
490 .class = I2C_CLASS_TV_ANALOG,
491#endif
492 .name = "em28xx",
493 .id = I2C_HW_B_EM28XX,
494 .algo = &em28xx_algo,
495 .client_register = attach_inform,
496};
497
498static struct i2c_client em28xx_client_template = {
499 .name = "em28xx internal",
500 .flags = I2C_CLIENT_ALLOW_USE,
501};
502
503/* ----------------------------------------------------------- */
504
505/*
506 * i2c_devs
507 * incomplete list of known devices
508 */
509static char *i2c_devs[128] = {
510 [0x4a >> 1] = "saa7113h",
511 [0x60 >> 1] = "remote IR sensor",
512 [0x8e >> 1] = "remote IR sensor",
513 [0x86 >> 1] = "tda9887",
514 [0x80 >> 1] = "msp34xx",
515 [0x88 >> 1] = "msp34xx",
516 [0xa0 >> 1] = "eeprom",
517 [0xb8 >> 1] = "tvp5150a",
518 [0xba >> 1] = "tvp5150a",
519 [0xc0 >> 1] = "tuner (analog)",
520 [0xc2 >> 1] = "tuner (analog)",
521 [0xc4 >> 1] = "tuner (analog)",
522 [0xc6 >> 1] = "tuner (analog)",
523};
524
525/*
526 * do_i2c_scan()
527 * check i2c address range for devices
528 */
529static void do_i2c_scan(char *name, struct i2c_client *c)
530{
531 unsigned char buf;
532 int i, rc;
533
534 for (i = 0; i < 128; i++) {
535 c->addr = i;
536 rc = i2c_master_recv(c, &buf, 0);
537 if (rc < 0)
538 continue;
539 printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n", name,
540 i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
541 }
542}
543
544/*
545 * em28xx_i2c_call_clients()
546 * send commands to all attached i2c devices
547 */
548void em28xx_i2c_call_clients(struct em28xx *dev, unsigned int cmd, void *arg)
549{
550 BUG_ON(NULL == dev->i2c_adap.algo_data);
551 i2c_clients_command(&dev->i2c_adap, cmd, arg);
552}
553
554/*
555 * em28xx_i2c_register()
556 * register i2c bus
557 */
558int em28xx_i2c_register(struct em28xx *dev)
559{
560 BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
561 BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
562 dev->i2c_adap = em28xx_adap_template;
563 dev->i2c_adap.dev.parent = &dev->udev->dev;
564 strcpy(dev->i2c_adap.name, dev->name);
565 dev->i2c_adap.algo_data = dev;
566 i2c_add_adapter(&dev->i2c_adap);
567
568 dev->i2c_client = em28xx_client_template;
569 dev->i2c_client.adapter = &dev->i2c_adap;
570
571 em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
572
573 if (i2c_scan)
574 do_i2c_scan(dev->name, &dev->i2c_client);
575 return 0;
576}
577
578/*
579 * em28xx_i2c_unregister()
580 * unregister i2c_bus
581 */
582int em28xx_i2c_unregister(struct em28xx *dev)
583{
584 i2c_del_adapter(&dev->i2c_adap);
585 return 0;
586}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-16 16:07:43 -0500