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 reg
= dev
->em28xx_read_reg(dev
, 0x5);
150 else if (reg
== 0x84)
158 * em2800_i2c_recv_bytes()
159 * read from the i2c device
161 static int em2800_i2c_recv_bytes(struct em28xx
*dev
, unsigned char addr
,
165 /* check for the device and set i2c read address */
166 ret
= em2800_i2c_check_for_device(dev
, addr
);
169 ("preparing read at i2c address 0x%x failed (error=%i)\n",
173 ret
= dev
->em28xx_read_reg_req_len(dev
, 0x0, 0x3, buf
, len
);
175 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
183 * em28xx_i2c_send_bytes()
184 * untested for more than 4 bytes
186 static int em28xx_i2c_send_bytes(void *data
, unsigned char addr
, char *buf
,
190 struct em28xx
*dev
= (struct em28xx
*)data
;
192 wrcount
= dev
->em28xx_write_regs_req(dev
, stop
? 2 : 3, addr
, buf
, len
);
198 * em28xx_i2c_recv_bytes()
199 * read a byte from the i2c device
201 static int em28xx_i2c_recv_bytes(struct em28xx
*dev
, unsigned char addr
,
205 ret
= dev
->em28xx_read_reg_req_len(dev
, 2, addr
, buf
, len
);
207 em28xx_warn("reading i2c device failed (error=%i)\n", ret
);
210 if (dev
->em28xx_read_reg(dev
, 0x5) != 0)
216 * em28xx_i2c_check_for_device()
217 * check if there is a i2c_device at the supplied address
219 static int em28xx_i2c_check_for_device(struct em28xx
*dev
, unsigned char addr
)
225 ret
= dev
->em28xx_read_reg_req(dev
, 2, addr
);
227 em28xx_warn("reading from i2c device failed (error=%i)\n", ret
);
230 if (dev
->em28xx_read_reg(dev
, 0x5) != 0)
237 * the main i2c transfer function
239 static int em28xx_i2c_xfer(struct i2c_adapter
*i2c_adap
,
240 struct i2c_msg msgs
[], int num
)
242 struct em28xx
*dev
= i2c_adap
->algo_data
;
243 int addr
, rc
, i
, byte
;
247 for (i
= 0; i
< num
; i
++) {
248 addr
= msgs
[i
].addr
<< 1;
249 dprintk2(2, "%s %s addr=%x len=%d:",
250 (msgs
[i
].flags
& I2C_M_RD
) ? "read" : "write",
251 i
== num
- 1 ? "stop" : "nonstop", addr
, msgs
[i
].len
);
252 if (!msgs
[i
].len
) { /* no len: check only for device presence */
254 rc
= em2800_i2c_check_for_device(dev
, addr
);
256 rc
= em28xx_i2c_check_for_device(dev
, addr
);
258 dprintk2(2, " no device\n");
262 } else if (msgs
[i
].flags
& I2C_M_RD
) {
265 rc
= em2800_i2c_recv_bytes(dev
, addr
,
269 rc
= em28xx_i2c_recv_bytes(dev
, addr
,
272 if (i2c_debug
>= 2) {
273 for (byte
= 0; byte
< msgs
[i
].len
; byte
++)
274 printk(" %02x", msgs
[i
].buf
[byte
]);
278 if (i2c_debug
>= 2) {
279 for (byte
= 0; byte
< msgs
[i
].len
; byte
++)
280 printk(" %02x", msgs
[i
].buf
[byte
]);
283 rc
= em2800_i2c_send_bytes(dev
, addr
,
287 rc
= em28xx_i2c_send_bytes(dev
, addr
,
300 dprintk2(2, " ERROR: %i\n", rc
);
304 /* based on linux/sunrpc/svcauth.h and linux/hash.h
305 * The original hash function returns a different value, if arch is x86_64
308 static inline unsigned long em28xx_hash_mem(char *buf
, int length
, int bits
)
310 unsigned long hash
= 0;
322 if ((len
& (32 / 8 - 1)) == 0)
323 hash
= ((hash
^l
) * 0x9e370001UL
);
326 return (hash
>> (32 - bits
)) & 0xffffffffUL
;
329 static int em28xx_i2c_eeprom(struct em28xx
*dev
, unsigned char *eedata
, int len
)
331 unsigned char buf
, *p
= eedata
;
332 struct em28xx_eeprom
*em_eeprom
= (void *)eedata
;
333 int i
, err
, size
= len
, block
;
335 dev
->i2c_client
.addr
= 0xa0 >> 1;
337 /* Check if board has eeprom */
338 err
= i2c_master_recv(&dev
->i2c_client
, &buf
, 0);
340 em28xx_errdev("board has no eeprom\n");
341 memset(eedata
, 0, len
);
347 err
= i2c_master_send(&dev
->i2c_client
, &buf
, 1);
349 printk(KERN_INFO
"%s: Huh, no eeprom present (err=%d)?\n",
360 (err
= i2c_master_recv(&dev
->i2c_client
, p
, block
))) {
362 "%s: i2c eeprom read error (err=%d)\n",
369 for (i
= 0; i
< len
; i
++) {
371 printk(KERN_INFO
"%s: i2c eeprom %02x:", dev
->name
, i
);
372 printk(" %02x", eedata
[i
]);
377 if (em_eeprom
->id
== 0x9567eb1a)
378 dev
->hash
= em28xx_hash_mem(eedata
, len
, 32);
380 printk(KERN_INFO
"EEPROM ID= 0x%08x, hash = 0x%08lx\n",
381 em_eeprom
->id
, dev
->hash
);
382 printk(KERN_INFO
"Vendor/Product ID= %04x:%04x\n", em_eeprom
->vendor_ID
,
383 em_eeprom
->product_ID
);
385 switch (em_eeprom
->chip_conf
>> 4 & 0x3) {
387 printk(KERN_INFO
"No audio on board.\n");
390 printk(KERN_INFO
"AC97 audio (5 sample rates)\n");
393 printk(KERN_INFO
"I2S audio, sample rate=32k\n");
396 printk(KERN_INFO
"I2S audio, 3 sample rates\n");
400 if (em_eeprom
->chip_conf
& 1 << 3)
401 printk(KERN_INFO
"USB Remote wakeup capable\n");
403 if (em_eeprom
->chip_conf
& 1 << 2)
404 printk(KERN_INFO
"USB Self power capable\n");
406 switch (em_eeprom
->chip_conf
& 0x3) {
408 printk(KERN_INFO
"500mA max power\n");
411 printk(KERN_INFO
"400mA max power\n");
414 printk(KERN_INFO
"300mA max power\n");
417 printk(KERN_INFO
"200mA max power\n");
420 printk(KERN_INFO
"Table at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
421 em_eeprom
->string_idx_table
,
429 /* ----------------------------------------------------------- */
434 static u32
functionality(struct i2c_adapter
*adap
)
436 return I2C_FUNC_SMBUS_EMUL
;
441 * gets called when a device attaches to the i2c bus
442 * does some basic configuration
444 static int attach_inform(struct i2c_client
*client
)
446 struct em28xx
*dev
= client
->adapter
->algo_data
;
448 switch (client
->addr
<< 1) {
454 struct v4l2_priv_tun_config tda9887_cfg
;
456 struct tuner_setup tun_setup
;
458 tun_setup
.mode_mask
= T_ANALOG_TV
| T_RADIO
;
459 tun_setup
.type
= TUNER_TDA9887
;
460 tun_setup
.addr
= client
->addr
;
462 em28xx_i2c_call_clients(dev
, TUNER_SET_TYPE_ADDR
,
465 tda9887_cfg
.tuner
= TUNER_TDA9887
;
466 tda9887_cfg
.priv
= &dev
->tda9887_conf
;
467 em28xx_i2c_call_clients(dev
, TUNER_SET_CONFIG
,
472 dprintk1(1, "attach_inform: saa7114 detected.\n");
475 dprintk1(1, "attach_inform: saa7113 detected.\n");
478 dprintk1(1, "attach_inform: eeprom detected.\n");
483 struct IR_i2c
*ir
= i2c_get_clientdata(client
);
484 dprintk1(1, "attach_inform: IR detected (%s).\n",
486 em28xx_set_ir(dev
, ir
);
491 dprintk1(1, "attach_inform: msp34xx detected.\n");
495 dprintk1(1, "attach_inform: tvp5150 detected.\n");
499 if (!dev
->tuner_addr
)
500 dev
->tuner_addr
= client
->addr
;
502 dprintk1(1, "attach inform: detected I2C address %x\n",
510 static struct i2c_algorithm em28xx_algo
= {
511 .master_xfer
= em28xx_i2c_xfer
,
512 .functionality
= functionality
,
515 static struct i2c_adapter em28xx_adap_template
= {
516 .owner
= THIS_MODULE
,
517 .class = I2C_CLASS_TV_ANALOG
,
519 .id
= I2C_HW_B_EM28XX
,
520 .algo
= &em28xx_algo
,
521 .client_register
= attach_inform
,
524 static struct i2c_client em28xx_client_template
= {
525 .name
= "em28xx internal",
528 /* ----------------------------------------------------------- */
532 * incomplete list of known devices
534 static char *i2c_devs
[128] = {
535 [0x4a >> 1] = "saa7113h",
536 [0x60 >> 1] = "remote IR sensor",
537 [0x8e >> 1] = "remote IR sensor",
538 [0x86 >> 1] = "tda9887",
539 [0x80 >> 1] = "msp34xx",
540 [0x88 >> 1] = "msp34xx",
541 [0xa0 >> 1] = "eeprom",
542 [0xb8 >> 1] = "tvp5150a",
543 [0xba >> 1] = "tvp5150a",
544 [0xc0 >> 1] = "tuner (analog)",
545 [0xc2 >> 1] = "tuner (analog)",
546 [0xc4 >> 1] = "tuner (analog)",
547 [0xc6 >> 1] = "tuner (analog)",
552 * check i2c address range for devices
554 void em28xx_do_i2c_scan(struct em28xx
*dev
)
556 u8 i2c_devicelist
[128];
560 memset(i2c_devicelist
, 0, ARRAY_SIZE(i2c_devicelist
));
562 for (i
= 0; i
< ARRAY_SIZE(i2c_devs
); i
++) {
563 dev
->i2c_client
.addr
= i
;
564 rc
= i2c_master_recv(&dev
->i2c_client
, &buf
, 0);
567 i2c_devicelist
[i
] = i
;
568 printk(KERN_INFO
"%s: found i2c device @ 0x%x [%s]\n",
569 dev
->name
, i
<< 1, i2c_devs
[i
] ? i2c_devs
[i
] : "???");
572 dev
->i2c_hash
= em28xx_hash_mem(i2c_devicelist
,
573 ARRAY_SIZE(i2c_devicelist
), 32);
577 * em28xx_i2c_call_clients()
578 * send commands to all attached i2c devices
580 void em28xx_i2c_call_clients(struct em28xx
*dev
, unsigned int cmd
, void *arg
)
582 BUG_ON(NULL
== dev
->i2c_adap
.algo_data
);
583 i2c_clients_command(&dev
->i2c_adap
, cmd
, arg
);
587 * em28xx_i2c_register()
590 int em28xx_i2c_register(struct em28xx
*dev
)
594 BUG_ON(!dev
->em28xx_write_regs
|| !dev
->em28xx_read_reg
);
595 BUG_ON(!dev
->em28xx_write_regs_req
|| !dev
->em28xx_read_reg_req
);
596 dev
->i2c_adap
= em28xx_adap_template
;
597 dev
->i2c_adap
.dev
.parent
= &dev
->udev
->dev
;
598 strcpy(dev
->i2c_adap
.name
, dev
->name
);
599 dev
->i2c_adap
.algo_data
= dev
;
601 retval
= i2c_add_adapter(&dev
->i2c_adap
);
603 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
608 dev
->i2c_client
= em28xx_client_template
;
609 dev
->i2c_client
.adapter
= &dev
->i2c_adap
;
611 retval
= em28xx_i2c_eeprom(dev
, dev
->eedata
, sizeof(dev
->eedata
));
612 if ((retval
< 0) && (retval
!= -ENODEV
)) {
613 em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
620 em28xx_do_i2c_scan(dev
);
626 * em28xx_i2c_unregister()
629 int em28xx_i2c_unregister(struct em28xx
*dev
)
631 i2c_del_adapter(&dev
->i2c_adap
);