Merge git://oak/home/sfr/kernels/iseries/work
[linux-2.6] / drivers / media / video / em28xx / em28xx-i2c.c
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
35 static unsigned int i2c_scan = 0;
36 module_param(i2c_scan, int, 0444);
37 MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
38
39 static unsigned int i2c_debug = 0;
40 module_param(i2c_debug, int, 0644);
41 MODULE_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  */
53 static 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  */
89 static 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  */
115 static 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  */
149 static 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  */
174 static 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  */
189 static 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  */
207 static 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  */
227 static 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
293 static 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  */
387 static int algo_control(struct i2c_adapter *adapter,
388                         unsigned int cmd, unsigned long arg)
389 {
390         return 0;
391 }
392
393 /*
394  * functionality()
395  */
396 static u32 functionality(struct i2c_adapter *adap)
397 {
398         return I2C_FUNC_SMBUS_EMUL;
399 }
400
401 #ifndef I2C_PEC
402 static void inc_use(struct i2c_adapter *adap)
403 {
404         MOD_INC_USE_COUNT;
405 }
406
407 static void dec_use(struct i2c_adapter *adap)
408 {
409         MOD_DEC_USE_COUNT;
410 }
411 #endif
412
413 static 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  */
434 static 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
476 static struct i2c_algorithm em28xx_algo = {
477         .master_xfer   = em28xx_i2c_xfer,
478         .algo_control  = algo_control,
479         .functionality = functionality,
480 };
481
482 static 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
498 static 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  */
509 static 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  */
529 static 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  */
548 void 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  */
558 int 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  */
582 int em28xx_i2c_unregister(struct em28xx *dev)
583 {
584         i2c_del_adapter(&dev->i2c_adap);
585         return 0;
586 }