projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] v4l: 800: whitespace cleanups
[deliverable/linux.git] / drivers / media / video / em28xx / em28xx-i2c.c
CommitLineData
a6c2ba28 1/*
596d92d5 2 em2820-i2c.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
a6c2ba28 3
4 Copyright (C) 2005 Markus Rechberger <mrechberger@gmail.com>
4ac97914
MCC		 5 Ludovico Cavedon <cavedon@sssup.it>
6 Mauro Carvalho Chehab <mchehab@brturbo.com.br>
a6c2ba28 7
8 Based on the em2800 driver from Sascha Sommer <saschasommer@freenet.de>
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25#include <linux/module.h>
26#include <linux/kernel.h>
27#include <linux/usb.h>
28#include <linux/i2c.h>
a6c2ba28 29#include <linux/video_decoder.h>
30
a6c2ba28 31#include "em2820.h"
d5e52653 32#include <media/tuner.h>
a6c2ba28 33
34/* ----------------------------------------------------------- */
35
36static unsigned int i2c_scan = 0;
37module_param(i2c_scan, int, 0444);
38MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
39
40static unsigned int i2c_debug = 0;
41module_param(i2c_debug, int, 0644);
42MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
43
d5e52653 44#define dprintk1(lvl,fmt, args...) if (i2c_debug>=lvl) do {\
a6c2ba28 45 printk(fmt , ##args); } while (0)
d5e52653
MCC		 46#define dprintk2(lvl,fmt, args...) if (i2c_debug>=lvl) do{ \
47 printk(KERN_DEBUG "%s at %s: " fmt, \
48 dev->name, __FUNCTION__ , ##args); } while (0)
a6c2ba28 49
50/*
596d92d5
MCC		 51 * em2800_i2c_send_max4()
52 * send up to 4 bytes to the i2c device
53 */
54static int em2800_i2c_send_max4(struct em2820 *dev, unsigned char addr,
55 char *buf, int len)
56{
57 int ret;
58 int write_timeout;
59 unsigned char b2[6];
60 BUG_ON(len < 1 || len > 4);
61 b2[5] = 0x80 + len - 1;
62 b2[4] = addr;
63 b2[3] = buf[0];
64 if (len > 1)
65 b2[2] = buf[1];
66 if (len > 2)
67 b2[1] = buf[2];
68 if (len > 3)
69 b2[0] = buf[3];
70
71 ret = dev->em2820_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
72 if (ret != 2 + len) {
73 em2820_warn("writting to i2c device failed (error=%i)\n", ret);
74 return -EIO;
75 }
76 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
77 write_timeout -= 5) {
78 ret = dev->em2820_read_reg(dev, 0x05);
79 if (ret == 0x80 + len - 1)
80 return len;
81 mdelay(5);
82 }
83 em2820_warn("i2c write timed out\n");
84 return -EIO;
85}
86
87/*
88 * em2800_i2c_send_bytes()
89 */
90static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf,
91 short len)
92{
93 char *bufPtr = buf;
94 int ret;
95 int wrcount = 0;
96 int count;
97 int maxLen = 4;
98 struct em2820 *dev = (struct em2820 *)data;
99 while (len > 0) {
100 count = (len > maxLen) ? maxLen : len;
101 ret = em2800_i2c_send_max4(dev, addr, bufPtr, count);
102 if (ret > 0) {
103 len -= count;
104 bufPtr += count;
105 wrcount += count;
106 } else
107 return (ret < 0) ? ret : -EFAULT;
108 }
109 return wrcount;
110}
111
112/*
113 * em2800_i2c_check_for_device()
114 * check if there is a i2c_device at the supplied address
115 */
116static int em2800_i2c_check_for_device(struct em2820 *dev, unsigned char addr)
117{
118 char msg;
119 int ret;
120 int write_timeout;
121 msg = addr;
122 ret = dev->em2820_write_regs(dev, 0x04, &msg, 1);
123 if (ret < 0) {
124 em2820_warn("setting i2c device address failed (error=%i)\n",
125 ret);
126 return ret;
127 }
128 msg = 0x84;
129 ret = dev->em2820_write_regs(dev, 0x05, &msg, 1);
130 if (ret < 0) {
131 em2820_warn("preparing i2c read failed (error=%i)\n", ret);
132 return ret;
133 }
134 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
135 write_timeout -= 5) {
136 unsigned msg = dev->em2820_read_reg(dev, 0x5);
137 if (msg == 0x94)
138 return -ENODEV;
139 else if (msg == 0x84)
140 return 0;
141 mdelay(5);
142 }
143 return -ENODEV;
144}
145
146/*
147 * em2800_i2c_recv_bytes()
148 * read from the i2c device
149 */
150static int em2800_i2c_recv_bytes(struct em2820 *dev, unsigned char addr,
151 char *buf, int len)
152{
153 int ret;
154 /* check for the device and set i2c read address */
155 ret = em2800_i2c_check_for_device(dev, addr);
156 if (ret) {
157 em2820_warn
158 ("preparing read at i2c address 0x%x failed (error=%i)\n",
159 addr, ret);
160 return ret;
161 }
162 ret = dev->em2820_read_reg_req_len(dev, 0x0, 0x3, buf, len);
163 if (ret < 0) {
164 em2820_warn("reading from i2c device at 0x%x failed (error=%i)",
165 addr, ret);
166 return ret;
167 }
168 return ret;
169}
170
171/*
172 * em2820_i2c_send_bytes()
a6c2ba28 173 * untested for more than 4 bytes
174 */
596d92d5
MCC		 175static int em2820_i2c_send_bytes(void *data, unsigned char addr, char *buf,
176 short len, int stop)
a6c2ba28 177{
178 int wrcount = 0;
179 struct em2820 *dev = (struct em2820 *)data;
180
181 wrcount = dev->em2820_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
182
183 return wrcount;
184}
185
186/*
596d92d5 187 * em2820_i2c_recv_bytes()
a6c2ba28 188 * read a byte from the i2c device
189 */
596d92d5
MCC		 190static int em2820_i2c_recv_bytes(struct em2820 *dev, unsigned char addr,
191 char *buf, int len)
a6c2ba28 192{
193 int ret;
194 ret = dev->em2820_read_reg_req_len(dev, 2, addr, buf, len);
195 if (ret < 0) {
196 em2820_warn("reading i2c device failed (error=%i)\n", ret);
197 return ret;
198 }
199 if (dev->em2820_read_reg(dev, 0x5) != 0)
200 return -ENODEV;
201 return ret;
202}
203
204/*
596d92d5 205 * em2820_i2c_check_for_device()
a6c2ba28 206 * check if there is a i2c_device at the supplied address
207 */
596d92d5 208static int em2820_i2c_check_for_device(struct em2820 *dev, unsigned char addr)
a6c2ba28 209{
210 char msg;
211 int ret;
212 msg = addr;
213
214 ret = dev->em2820_read_reg_req(dev, 2, addr);
215 if (ret < 0) {
216 em2820_warn("reading from i2c device failed (error=%i)\n", ret);
217 return ret;
218 }
219 if (dev->em2820_read_reg(dev, 0x5) != 0)
220 return -ENODEV;
221 return 0;
222}
223
224/*
225 * em2820_i2c_xfer()
226 * the main i2c transfer function
227 */
228static int em2820_i2c_xfer(struct i2c_adapter *i2c_adap,
229 struct i2c_msg msgs[], int num)
230{
231 struct em2820 *dev = i2c_adap->algo_data;
232 int addr, rc, i, byte;
233
234 if (num <= 0)
235 return 0;
236 for (i = 0; i < num; i++) {
237 addr = msgs[i].addr << 1;
d5e52653 238 dprintk2(2,"%s %s addr=%x len=%d:",
a6c2ba28 239 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
240 i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
241 if (!msgs[i].len) { /* no len: check only for device presence */
596d92d5
MCC		 242 if (dev->is_em2800)
243 rc = em2800_i2c_check_for_device(dev, addr);
244 else
245 rc = em2820_i2c_check_for_device(dev, addr);
a6c2ba28 246 if (rc < 0) {
d5e52653 247 dprintk2(2," no device\n");
a6c2ba28 248 return rc;
249 }
250
596d92d5 251 } else if (msgs[i].flags & I2C_M_RD) {
a6c2ba28 252 /* read bytes */
596d92d5
MCC		 253 if (dev->is_em2800)
254 rc = em2800_i2c_recv_bytes(dev, addr,
255 msgs[i].buf,
256 msgs[i].len);
257 else
258 rc = em2820_i2c_recv_bytes(dev, addr,
259 msgs[i].buf,
260 msgs[i].len);
d5e52653 261 if (i2c_debug>=2) {
a6c2ba28 262 for (byte = 0; byte < msgs[i].len; byte++) {
263 printk(" %02x", msgs[i].buf[byte]);
264 }
265 }
266 } else {
267 /* write bytes */
d5e52653 268 if (i2c_debug>=2) {
a6c2ba28 269 for (byte = 0; byte < msgs[i].len; byte++)
270 printk(" %02x", msgs[i].buf[byte]);
271 }
596d92d5
MCC		 272 if (dev->is_em2800)
273 rc = em2800_i2c_send_bytes(dev, addr,
274 msgs[i].buf,
275 msgs[i].len);
276 else
277 rc = em2820_i2c_send_bytes(dev, addr,
278 msgs[i].buf,
279 msgs[i].len,
280 i == num - 1);
a6c2ba28 281 if (rc < 0)
282 goto err;
283 }
d5e52653 284 if (i2c_debug>=2)
a6c2ba28 285 printk("\n");
286 }
287
288 return num;
289 err:
d5e52653 290 dprintk2(2," ERROR: %i\n", rc);
a6c2ba28 291 return rc;
292}
293
294static int em2820_i2c_eeprom(struct em2820 *dev, unsigned char *eedata, int len)
295{
296 unsigned char buf, *p = eedata;
297 struct em2820_eeprom *em_eeprom = (void *)eedata;
298 int i, err, size = len, block;
299
300 dev->i2c_client.addr = 0xa0 >> 1;
596d92d5
MCC		 301
302 /* Check if board has eeprom */
303 err = i2c_master_recv(&dev->i2c_client, &buf, 0);
304 if (err < 0)
305 return -1;
306
a6c2ba28 307 buf = 0;
308 if (1 != (err = i2c_master_send(&dev->i2c_client, &buf, 1))) {
309 printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
310 dev->name, err);
311 return -1;
312 }
313 while (size > 0) {
314 if (size > 16)
315 block = 16;
316 else
317 block = size;
318
319 if (block !=
320 (err = i2c_master_recv(&dev->i2c_client, p, block))) {
321 printk(KERN_WARNING
322 "%s: i2c eeprom read error (err=%d)\n",
323 dev->name, err);
324 return -1;
325 }
326 size -= block;
327 p += block;
328 }
329 for (i = 0; i < len; i++) {
330 if (0 == (i % 16))
331 printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
332 printk(" %02x", eedata[i]);
333 if (15 == (i % 16))
334 printk("\n");
335 }
336
337 printk(KERN_INFO "EEPROM ID= 0x%08x\n", em_eeprom->id);
338 printk(KERN_INFO "Vendor/Product ID= %04x:%04x\n", em_eeprom->vendor_ID,
339 em_eeprom->product_ID);
340
341 switch (em_eeprom->chip_conf >> 4 & 0x3) {
342 case 0:
343 printk(KERN_INFO "No audio on board.\n");
344 break;
345 case 1:
346 printk(KERN_INFO "AC97 audio (5 sample rates)\n");
347 break;
348 case 2:
349 printk(KERN_INFO "I2S audio, sample rate=32k\n");
350 break;
351 case 3:
352 printk(KERN_INFO "I2S audio, 3 sample rates\n");
353 break;
354 }
355
356 if (em_eeprom->chip_conf & 1 << 3)
357 printk(KERN_INFO "USB Remote wakeup capable\n");
358
359 if (em_eeprom->chip_conf & 1 << 2)
360 printk(KERN_INFO "USB Self power capable\n");
361
362 switch (em_eeprom->chip_conf & 0x3) {
363 case 0:
364 printk(KERN_INFO "500mA max power\n");
365 break;
366 case 1:
367 printk(KERN_INFO "400mA max power\n");
368 break;
369 case 2:
370 printk(KERN_INFO "300mA max power\n");
371 break;
372 case 3:
373 printk(KERN_INFO "200mA max power\n");
374 break;
375 }
376
377 return 0;
378}
379
380/* ----------------------------------------------------------- */
381
382/*
383 * algo_control()
384 */
385static int algo_control(struct i2c_adapter *adapter,
386 unsigned int cmd, unsigned long arg)
387{
388 return 0;
389}
390
391/*
392 * functionality()
393 */
394static u32 functionality(struct i2c_adapter *adap)
395{
396 return I2C_FUNC_SMBUS_EMUL;
397}
398
399#ifndef I2C_PEC
400static void inc_use(struct i2c_adapter *adap)
401{
402 MOD_INC_USE_COUNT;
403}
404
405static void dec_use(struct i2c_adapter *adap)
406{
407 MOD_DEC_USE_COUNT;
408}
409#endif
410
411static int em2820_set_tuner(int check_eeprom, struct i2c_client *client)
412{
413 struct em2820 *dev = client->adapter->algo_data;
a6c2ba28 414 struct tuner_setup tun_setup;
415
a6c2ba28 416 if (dev->has_tuner) {
417 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
418 tun_setup.type = dev->tuner_type;
419 tun_setup.addr = dev->tuner_addr;
420
421 em2820_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR, &tun_setup);
422 }
fd35a6b4 423
a6c2ba28 424 return (0);
425}
426
427/*
428 * attach_inform()
429 * gets called when a device attaches to the i2c bus
430 * does some basic configuration
431 */
432static int attach_inform(struct i2c_client *client)
433{
434 struct em2820 *dev = client->adapter->algo_data;
435
a6c2ba28 436 switch (client->addr << 1) {
a9ae9fb1
MR		 437 case 0x86:
438 em2820_i2c_call_clients(dev, TDA9887_SET_CONFIG, &dev->tda9887_conf);
439 break;
440 case 0x4a:
d5e52653 441 dprintk1(1,"attach_inform: saa7113 detected.\n");
a9ae9fb1
MR		 442 break;
443 case 0xa0:
d5e52653
MCC		 444 dprintk1(1,"attach_inform: eeprom detected.\n");
445 break;
446 case 0x60:
447 case 0x8e:
448 {
449 struct IR_i2c *ir = i2c_get_clientdata(client);
450 dprintk1(1,"attach_inform: IR detected (%s).\n",ir->phys);
451 em2820_set_ir(dev,ir);
a9ae9fb1 452 break;
d5e52653 453 }
a9ae9fb1
MR		 454 case 0x80:
455 case 0x88:
d5e52653 456 dprintk1(1,"attach_inform: msp34xx detected.\n");
a9ae9fb1
MR		 457 break;
458 case 0xb8:
459 case 0xba:
d5e52653 460 dprintk1(1,"attach_inform: tvp5150 detected.\n");
a9ae9fb1
MR		 461 break;
462 default:
d5e52653 463 dprintk1(1,"attach inform: detected I2C address %x\n", client->addr << 1);
a9ae9fb1
MR		 464 dev->tuner_addr = client->addr;
465 em2820_set_tuner(-1, client);
a6c2ba28 466 }
467
468 return 0;
469}
470
471static struct i2c_algorithm em2820_algo = {
a6c2ba28 472 .master_xfer = em2820_i2c_xfer,
473 .algo_control = algo_control,
474 .functionality = functionality,
475};
476
477static struct i2c_adapter em2820_adap_template = {
478#ifdef I2C_PEC
479 .owner = THIS_MODULE,
480#else
481 .inc_use = inc_use,
482 .dec_use = dec_use,
483#endif
484#ifdef I2C_CLASS_TV_ANALOG
485 .class = I2C_CLASS_TV_ANALOG,
486#endif
487 .name = "em2820",
488 .id = I2C_HW_B_EM2820,
489 .algo = &em2820_algo,
490 .client_register = attach_inform,
491};
492
493static struct i2c_client em2820_client_template = {
494 .name = "em2820 internal",
495 .flags = I2C_CLIENT_ALLOW_USE,
496};
497
498/* ----------------------------------------------------------- */
499
500/*
501 * i2c_devs
502 * incomplete list of known devices
503 */
504static char *i2c_devs[128] = {
505 [0x4a >> 1] = "saa7113h",
506 [0x60 >> 1] = "remote IR sensor",
da45a2a5 507 [0x8e >> 1] = "remote IR sensor",
a6c2ba28 508 [0x86 >> 1] = "tda9887",
509 [0x80 >> 1] = "msp34xx",
510 [0x88 >> 1] = "msp34xx",
511 [0xa0 >> 1] = "eeprom",
512 [0xb8 >> 1] = "tvp5150a",
513 [0xba >> 1] = "tvp5150a",
514 [0xc0 >> 1] = "tuner (analog)",
515 [0xc2 >> 1] = "tuner (analog)",
516 [0xc4 >> 1] = "tuner (analog)",
517 [0xc6 >> 1] = "tuner (analog)",
518};
519
520/*
521 * do_i2c_scan()
522 * check i2c address range for devices
523 */
524static void do_i2c_scan(char *name, struct i2c_client *c)
525{
526 unsigned char buf;
527 int i, rc;
528
529 for (i = 0; i < 128; i++) {
530 c->addr = i;
531 rc = i2c_master_recv(c, &buf, 0);
532 if (rc < 0)
533 continue;
596d92d5 534 printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n", name,
a6c2ba28 535 i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
536 }
537}
538
539/*
540 * em2820_i2c_call_clients()
541 * send commands to all attached i2c devices
542 */
543void em2820_i2c_call_clients(struct em2820 *dev, unsigned int cmd, void *arg)
544{
545 BUG_ON(NULL == dev->i2c_adap.algo_data);
546 i2c_clients_command(&dev->i2c_adap, cmd, arg);
547}
548
549/*
550 * em2820_i2c_register()
551 * register i2c bus
552 */
553int em2820_i2c_register(struct em2820 *dev)
554{
555 BUG_ON(!dev->em2820_write_regs || !dev->em2820_read_reg);
556 BUG_ON(!dev->em2820_write_regs_req || !dev->em2820_read_reg_req);
557 dev->i2c_adap = em2820_adap_template;
558 dev->i2c_adap.dev.parent = &dev->udev->dev;
559 strcpy(dev->i2c_adap.name, dev->name);
560 dev->i2c_adap.algo_data = dev;
561 i2c_add_adapter(&dev->i2c_adap);
562
563 dev->i2c_client = em2820_client_template;
564 dev->i2c_client.adapter = &dev->i2c_adap;
565
566 em2820_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
567
568 if (i2c_scan)
569 do_i2c_scan(dev->name, &dev->i2c_client);
570 return 0;
571}
572
573/*
574 * em2820_i2c_unregister()
575 * unregister i2c_bus
576 */
577int em2820_i2c_unregister(struct em2820 *dev)
578{
579 i2c_del_adapter(&dev->i2c_adap);
580 return 0;
581}
Linux kernel - Deliverables
This page took 0.048561 seconds and 5 git commands to generate.