2 em28xx-i2c.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
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>
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.
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.
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.
24 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/usb.h>
27 #include <linux/i2c.h>
30 #include "tuner-xc2028.h"
31 #include <media/v4l2-common.h>
32 #include <media/tuner.h>
34 /* ----------------------------------------------------------- */
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");
40 static unsigned int i2c_debug
;
41 module_param(i2c_debug
, int, 0644);
42 MODULE_PARM_DESC(i2c_debug
, "enable debug messages [i2c]");
45 #define dprintk1(lvl, fmt, args...) \
47 if (i2c_debug >= lvl) { \
48 printk(fmt, ##args); \
52 #define dprintk2(lvl, fmt, args...) \
54 if (i2c_debug >= lvl) { \
55 printk(KERN_DEBUG "%s at %s: " fmt, \
56 dev->name, __func__ , ##args); \
61 * em2800_i2c_send_max4()
62 * send up to 4 bytes to the i2c device
64 static int em2800_i2c_send_max4(struct em28xx
*dev
, unsigned char addr
,
70 BUG_ON(len
< 1 || len
> 4);
71 b2
[5] = 0x80 + len
- 1;
81 ret
= dev
->em28xx_write_regs(dev
, 4 - len
, &b2
[4 - len
], 2 + len
);
83 em28xx_warn("writing to i2c device failed (error=%i)\n", ret
);
86 for (write_timeout
= EM2800_I2C_WRITE_TIMEOUT
; write_timeout
> 0;
88 ret
= dev
->em28xx_read_reg(dev
, 0x05);
89 if (ret
== 0x80 + len
- 1)
93 em28xx_warn("i2c write timed out\n");
98 * em2800_i2c_send_bytes()
100 static int em2800_i2c_send_bytes(void *data
, unsigned char addr
, char *buf
,
108 struct em28xx
*dev
= (struct em28xx
*)data
;
110 count
= (len
> maxLen
) ? maxLen
: len
;
111 ret
= em2800_i2c_send_max4(dev
, addr
, bufPtr
, count
);
117 return (ret
< 0) ? ret
: -EFAULT
;
123 * em2800_i2c_check_for_device()
124 * check if there is a i2c_device at the supplied address
126 static int em2800_i2c_check_for_device(struct em28xx
*dev
, unsigned char addr
)
132 ret
= dev
->em28xx_write_regs(dev
, 0x04, &msg
, 1);
134 em28xx_warn("setting i2c device address failed (error=%i)\n",
139 ret
= dev
->em28xx_write_regs(dev
, 0x05, &msg
, 1);
141 em28xx_warn("preparing i2c read failed (error=%i)\n", ret
);
144 for (write_timeout
= EM2800_I2C_WRITE_TIMEOUT
; write_timeout
> 0;
145 write_timeout
-= 5) {
146 unsigned msg
= dev
->em28xx_read_reg(dev
, 0x5);
149 else if (msg
== 0x84)
157 * em2800_i2c_recv_bytes()
158 * read from the i2c device
160 static int em2800_i2c_recv_bytes(struct em28xx
*dev
, unsigned char addr
,
164 /* check for the device and set i2c read address */
165 ret
= em2800_i2c_check_for_device(dev
, addr
);
168 ("preparing read at i2c address 0x%x failed (error=%i)\n",
172 ret
= dev
->em28xx_read_reg_req_len(dev
, 0x0, 0x3, buf
, len
);
174 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
182 * em28xx_i2c_send_bytes()
183 * untested for more than 4 bytes
185 static int em28xx_i2c_send_bytes(void *data
, unsigned char addr
, char *buf
,
189 struct em28xx
*dev
= (struct em28xx
*)data
;
191 wrcount
= dev
->em28xx_write_regs_req(dev
, stop
? 2 : 3, addr
, buf
, len
);
197 * em28xx_i2c_recv_bytes()
198 * read a byte from the i2c device
200 static int em28xx_i2c_recv_bytes(struct em28xx
*dev
, unsigned char addr
,
204 ret
= dev
->em28xx_read_reg_req_len(dev
, 2, addr
, buf
, len
);
206 em28xx_warn("reading i2c device failed (error=%i)\n", ret
);
209 if (dev
->em28xx_read_reg(dev
, 0x5) != 0)
215 * em28xx_i2c_check_for_device()
216 * check if there is a i2c_device at the supplied address
218 static int em28xx_i2c_check_for_device(struct em28xx
*dev
, unsigned char addr
)
224 ret
= dev
->em28xx_read_reg_req(dev
, 2, addr
);
226 em28xx_warn("reading from i2c device failed (error=%i)\n", ret
);
229 if (dev
->em28xx_read_reg(dev
, 0x5) != 0)
236 * the main i2c transfer function
238 static int em28xx_i2c_xfer(struct i2c_adapter
*i2c_adap
,
239 struct i2c_msg msgs
[], int num
)
241 struct em28xx
*dev
= i2c_adap
->algo_data
;
242 int addr
, rc
, i
, byte
;
246 for (i
= 0; i
< num
; i
++) {
247 addr
= msgs
[i
].addr
<< 1;
248 dprintk2(2, "%s %s addr=%x len=%d:",
249 (msgs
[i
].flags
& I2C_M_RD
) ? "read" : "write",
250 i
== num
- 1 ? "stop" : "nonstop", addr
, msgs
[i
].len
);
251 if (!msgs
[i
].len
) { /* no len: check only for device presence */
253 rc
= em2800_i2c_check_for_device(dev
, addr
);
255 rc
= em28xx_i2c_check_for_device(dev
, addr
);
257 dprintk2(2, " no device\n");
261 } else if (msgs
[i
].flags
& I2C_M_RD
) {
264 rc
= em2800_i2c_recv_bytes(dev
, addr
,
268 rc
= em28xx_i2c_recv_bytes(dev
, addr
,
271 if (i2c_debug
>= 2) {
272 for (byte
= 0; byte
< msgs
[i
].len
; byte
++)
273 printk(" %02x", msgs
[i
].buf
[byte
]);
277 if (i2c_debug
>= 2) {
278 for (byte
= 0; byte
< msgs
[i
].len
; byte
++)
279 printk(" %02x", msgs
[i
].buf
[byte
]);
282 rc
= em2800_i2c_send_bytes(dev
, addr
,
286 rc
= em28xx_i2c_send_bytes(dev
, addr
,
299 dprintk2(2, " ERROR: %i\n", rc
);
303 /* based on linux/sunrpc/svcauth.h and linux/hash.h
304 * The original hash function returns a different value, if arch is x86_64
307 static inline unsigned long em28xx_hash_mem(char *buf
, int length
, int bits
)
309 unsigned long hash
= 0;
321 if ((len
& (32 / 8 - 1)) == 0)
322 hash
= ((hash
^l
) * 0x9e370001UL
);
325 return (hash
>> (32 - bits
)) & 0xffffffffUL
;
328 static int em28xx_i2c_eeprom(struct em28xx
*dev
, unsigned char *eedata
, int len
)
330 unsigned char buf
, *p
= eedata
;
331 struct em28xx_eeprom
*em_eeprom
= (void *)eedata
;
332 int i
, err
, size
= len
, block
;
334 dev
->i2c_client
.addr
= 0xa0 >> 1;
336 /* Check if board has eeprom */
337 err
= i2c_master_recv(&dev
->i2c_client
, &buf
, 0);
343 err
= i2c_master_send(&dev
->i2c_client
, &buf
, 1);
345 printk(KERN_INFO
"%s: Huh, no eeprom present (err=%d)?\n",
356 (err
= i2c_master_recv(&dev
->i2c_client
, p
, block
))) {
358 "%s: i2c eeprom read error (err=%d)\n",
365 for (i
= 0; i
< len
; i
++) {
367 printk(KERN_INFO
"%s: i2c eeprom %02x:", dev
->name
, i
);
368 printk(" %02x", eedata
[i
]);
373 if (em_eeprom
->id
== 0x9567eb1a)
374 dev
->hash
= em28xx_hash_mem(eedata
, len
, 32);
376 printk(KERN_INFO
"EEPROM ID= 0x%08x, hash = 0x%08lx\n",
377 em_eeprom
->id
, dev
->hash
);
378 printk(KERN_INFO
"Vendor/Product ID= %04x:%04x\n", em_eeprom
->vendor_ID
,
379 em_eeprom
->product_ID
);
381 switch (em_eeprom
->chip_conf
>> 4 & 0x3) {
383 printk(KERN_INFO
"No audio on board.\n");
386 printk(KERN_INFO
"AC97 audio (5 sample rates)\n");
389 printk(KERN_INFO
"I2S audio, sample rate=32k\n");
392 printk(KERN_INFO
"I2S audio, 3 sample rates\n");
396 if (em_eeprom
->chip_conf
& 1 << 3)
397 printk(KERN_INFO
"USB Remote wakeup capable\n");
399 if (em_eeprom
->chip_conf
& 1 << 2)
400 printk(KERN_INFO
"USB Self power capable\n");
402 switch (em_eeprom
->chip_conf
& 0x3) {
404 printk(KERN_INFO
"500mA max power\n");
407 printk(KERN_INFO
"400mA max power\n");
410 printk(KERN_INFO
"300mA max power\n");
413 printk(KERN_INFO
"200mA max power\n");
416 printk(KERN_INFO
"Table at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
417 em_eeprom
->string_idx_table
,
425 /* ----------------------------------------------------------- */
430 static u32
functionality(struct i2c_adapter
*adap
)
432 return I2C_FUNC_SMBUS_EMUL
;
438 * gets called when a device attaches to the i2c bus
439 * does some basic configuration
441 static int attach_inform(struct i2c_client
*client
)
443 struct em28xx
*dev
= client
->adapter
->algo_data
;
445 switch (client
->addr
<< 1) {
451 struct v4l2_priv_tun_config tda9887_cfg
;
453 struct tuner_setup tun_setup
;
455 tun_setup
.mode_mask
= T_ANALOG_TV
| T_RADIO
;
456 tun_setup
.type
= TUNER_TDA9887
;
457 tun_setup
.addr
= client
->addr
;
459 em28xx_i2c_call_clients(dev
, TUNER_SET_TYPE_ADDR
,
462 tda9887_cfg
.tuner
= TUNER_TDA9887
;
463 tda9887_cfg
.priv
= &dev
->tda9887_conf
;
464 em28xx_i2c_call_clients(dev
, TUNER_SET_CONFIG
,
469 dprintk1(1, "attach_inform: saa7114 detected.\n");
472 dprintk1(1, "attach_inform: saa7113 detected.\n");
475 dprintk1(1, "attach_inform: eeprom detected.\n");
480 struct IR_i2c
*ir
= i2c_get_clientdata(client
);
481 dprintk1(1, "attach_inform: IR detected (%s).\n",
483 em28xx_set_ir(dev
, ir
);
488 dprintk1(1, "attach_inform: msp34xx detected.\n");
492 dprintk1(1, "attach_inform: tvp5150 detected.\n");
496 if (!dev
->tuner_addr
)
497 dev
->tuner_addr
= client
->addr
;
499 dprintk1(1, "attach inform: detected I2C address %x\n",
507 static struct i2c_algorithm em28xx_algo
= {
508 .master_xfer
= em28xx_i2c_xfer
,
509 .functionality
= functionality
,
512 static struct i2c_adapter em28xx_adap_template
= {
513 .owner
= THIS_MODULE
,
514 .class = I2C_CLASS_TV_ANALOG
,
516 .id
= I2C_HW_B_EM28XX
,
517 .algo
= &em28xx_algo
,
518 .client_register
= attach_inform
,
521 static struct i2c_client em28xx_client_template
= {
522 .name
= "em28xx internal",
525 /* ----------------------------------------------------------- */
529 * incomplete list of known devices
531 static char *i2c_devs
[128] = {
532 [0x4a >> 1] = "saa7113h",
533 [0x60 >> 1] = "remote IR sensor",
534 [0x8e >> 1] = "remote IR sensor",
535 [0x86 >> 1] = "tda9887",
536 [0x80 >> 1] = "msp34xx",
537 [0x88 >> 1] = "msp34xx",
538 [0xa0 >> 1] = "eeprom",
539 [0xb8 >> 1] = "tvp5150a",
540 [0xba >> 1] = "tvp5150a",
541 [0xc0 >> 1] = "tuner (analog)",
542 [0xc2 >> 1] = "tuner (analog)",
543 [0xc4 >> 1] = "tuner (analog)",
544 [0xc6 >> 1] = "tuner (analog)",
549 * check i2c address range for devices
551 void em28xx_do_i2c_scan(struct em28xx
*dev
)
553 u8 i2c_devicelist
[128];
557 memset(i2c_devicelist
, 0, ARRAY_SIZE(i2c_devicelist
));
559 for (i
= 0; i
< ARRAY_SIZE(i2c_devs
); i
++) {
560 dev
->i2c_client
.addr
= i
;
561 rc
= i2c_master_recv(&dev
->i2c_client
, &buf
, 0);
564 i2c_devicelist
[i
] = i
;
565 printk(KERN_INFO
"%s: found i2c device @ 0x%x [%s]\n",
566 dev
->name
, i
<< 1, i2c_devs
[i
] ? i2c_devs
[i
] : "???");
569 dev
->i2c_hash
= em28xx_hash_mem(i2c_devicelist
,
570 ARRAY_SIZE(i2c_devicelist
), 32);
574 * em28xx_i2c_call_clients()
575 * send commands to all attached i2c devices
577 void em28xx_i2c_call_clients(struct em28xx
*dev
, unsigned int cmd
, void *arg
)
579 BUG_ON(NULL
== dev
->i2c_adap
.algo_data
);
580 i2c_clients_command(&dev
->i2c_adap
, cmd
, arg
);
584 * em28xx_i2c_register()
587 int em28xx_i2c_register(struct em28xx
*dev
)
589 BUG_ON(!dev
->em28xx_write_regs
|| !dev
->em28xx_read_reg
);
590 BUG_ON(!dev
->em28xx_write_regs_req
|| !dev
->em28xx_read_reg_req
);
591 dev
->i2c_adap
= em28xx_adap_template
;
592 dev
->i2c_adap
.dev
.parent
= &dev
->udev
->dev
;
593 strcpy(dev
->i2c_adap
.name
, dev
->name
);
594 dev
->i2c_adap
.algo_data
= dev
;
595 i2c_add_adapter(&dev
->i2c_adap
);
597 dev
->i2c_client
= em28xx_client_template
;
598 dev
->i2c_client
.adapter
= &dev
->i2c_adap
;
600 em28xx_i2c_eeprom(dev
, dev
->eedata
, sizeof(dev
->eedata
));
603 em28xx_do_i2c_scan(dev
);
608 * em28xx_i2c_unregister()
611 int em28xx_i2c_unregister(struct em28xx
*dev
)
613 i2c_del_adapter(&dev
->i2c_adap
);