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 * em2800_i2c_send_bytes()
46 * send up to 4 bytes to the em2800 i2c device
48 static int em2800_i2c_send_bytes(struct em28xx
*dev
, u8 addr
, u8
*buf
, u16 len
)
54 if (len
< 1 || len
> 4)
57 BUG_ON(len
< 1 || len
> 4);
58 b2
[5] = 0x80 + len
- 1;
69 ret
= dev
->em28xx_write_regs(dev
, 4 - len
, &b2
[4 - len
], 2 + len
);
71 em28xx_warn("failed to trigger write to i2c address 0x%x "
72 "(error=%i)\n", addr
, ret
);
73 return (ret
< 0) ? ret
: -EIO
;
75 /* wait for completion */
76 for (write_timeout
= EM2800_I2C_XFER_TIMEOUT
; write_timeout
> 0;
78 ret
= dev
->em28xx_read_reg(dev
, 0x05);
79 if (ret
== 0x80 + len
- 1) {
81 } else if (ret
== 0x94 + len
- 1) {
84 em28xx_warn("failed to get i2c transfer status from "
85 "bridge register (error=%i)\n", ret
);
90 em28xx_warn("write to i2c device at 0x%x timed out\n", addr
);
95 * em2800_i2c_recv_bytes()
96 * read up to 4 bytes from the em2800 i2c device
98 static int em2800_i2c_recv_bytes(struct em28xx
*dev
, u8 addr
, u8
*buf
, u16 len
)
105 if (len
< 1 || len
> 4)
109 buf2
[1] = 0x84 + len
- 1;
111 ret
= dev
->em28xx_write_regs(dev
, 0x04, buf2
, 2);
113 em28xx_warn("failed to trigger read from i2c address 0x%x "
114 "(error=%i)\n", addr
, ret
);
115 return (ret
< 0) ? ret
: -EIO
;
118 /* wait for completion */
119 for (read_timeout
= EM2800_I2C_XFER_TIMEOUT
; read_timeout
> 0;
121 ret
= dev
->em28xx_read_reg(dev
, 0x05);
122 if (ret
== 0x84 + len
- 1) {
124 } else if (ret
== 0x94 + len
- 1) {
126 } else if (ret
< 0) {
127 em28xx_warn("failed to get i2c transfer status from "
128 "bridge register (error=%i)\n", ret
);
133 if (ret
!= 0x84 + len
- 1)
134 em28xx_warn("read from i2c device at 0x%x timed out\n", addr
);
136 /* get the received message */
137 ret
= dev
->em28xx_read_reg_req_len(dev
, 0x00, 4-len
, buf2
, len
);
139 em28xx_warn("reading from i2c device at 0x%x failed: "
140 "couldn't get the received message from the bridge "
141 "(error=%i)\n", addr
, ret
);
142 return (ret
< 0) ? ret
: -EIO
;
144 for (i
= 0; i
< len
; i
++)
145 buf
[i
] = buf2
[len
- 1 - i
];
151 * em2800_i2c_check_for_device()
152 * check if there is an i2c device at the supplied address
154 static int em2800_i2c_check_for_device(struct em28xx
*dev
, u8 addr
)
159 ret
= em2800_i2c_recv_bytes(dev
, addr
, &buf
, 1);
162 return (ret
< 0) ? ret
: -EIO
;
166 * em28xx_i2c_send_bytes()
168 static int em28xx_i2c_send_bytes(struct em28xx
*dev
, u16 addr
, u8
*buf
,
171 int write_timeout
, ret
;
173 if (len
< 1 || len
> 64)
175 /* NOTE: limited by the USB ctrl message constraints
176 * Zero length reads always succeed, even if no device is connected */
178 /* Write to i2c device */
179 ret
= dev
->em28xx_write_regs_req(dev
, stop
? 2 : 3, addr
, buf
, len
);
182 em28xx_warn("writing to i2c device at 0x%x failed "
183 "(error=%i)\n", addr
, ret
);
186 em28xx_warn("%i bytes write to i2c device at 0x%x "
187 "requested, but %i bytes written\n",
193 /* Check success of the i2c operation */
194 for (write_timeout
= EM2800_I2C_XFER_TIMEOUT
; write_timeout
> 0;
195 write_timeout
-= 5) {
196 ret
= dev
->em28xx_read_reg(dev
, 0x05);
197 if (ret
== 0) { /* success */
199 } else if (ret
== 0x10) {
201 } else if (ret
< 0) {
202 em28xx_warn("failed to read i2c transfer status from "
203 "bridge (error=%i)\n", ret
);
207 /* NOTE: do we really have to wait for success ?
208 Never seen anything else than 0x00 or 0x10
209 (even with high payload) ... */
211 em28xx_warn("write to i2c device at 0x%x timed out\n", addr
);
216 * em28xx_i2c_recv_bytes()
217 * read a byte from the i2c device
219 static int em28xx_i2c_recv_bytes(struct em28xx
*dev
, u16 addr
, u8
*buf
, u16 len
)
223 if (len
< 1 || len
> 64)
225 /* NOTE: limited by the USB ctrl message constraints
226 * Zero length reads always succeed, even if no device is connected */
228 /* Read data from i2c device */
229 ret
= dev
->em28xx_read_reg_req_len(dev
, 2, addr
, buf
, len
);
232 em28xx_warn("reading from i2c device at 0x%x failed "
233 "(error=%i)\n", addr
, ret
);
236 em28xx_warn("%i bytes requested from i2c device at "
237 "0x%x, but %i bytes received\n",
243 /* Check success of the i2c operation */
244 ret
= dev
->em28xx_read_reg(dev
, 0x05);
246 em28xx_warn("failed to read i2c transfer status from "
247 "bridge (error=%i)\n", ret
);
254 em28xx_warn("unknown i2c error (status=%i)\n", ret
);
262 * em28xx_i2c_check_for_device()
263 * check if there is a i2c_device at the supplied address
265 static int em28xx_i2c_check_for_device(struct em28xx
*dev
, u16 addr
)
270 ret
= em28xx_i2c_recv_bytes(dev
, addr
, &buf
, 1);
273 return (ret
< 0) ? ret
: -EIO
;
278 * the main i2c transfer function
280 static int em28xx_i2c_xfer(struct i2c_adapter
*i2c_adap
,
281 struct i2c_msg msgs
[], int num
)
283 struct em28xx
*dev
= i2c_adap
->algo_data
;
284 int addr
, rc
, i
, byte
;
288 for (i
= 0; i
< num
; i
++) {
289 addr
= msgs
[i
].addr
<< 1;
291 printk(KERN_DEBUG
"%s at %s: %s %s addr=%02x len=%d:",
292 dev
->name
, __func__
,
293 (msgs
[i
].flags
& I2C_M_RD
) ? "read" : "write",
294 i
== num
- 1 ? "stop" : "nonstop",
296 if (!msgs
[i
].len
) { /* no len: check only for device presence */
297 if (dev
->board
.is_em2800
)
298 rc
= em2800_i2c_check_for_device(dev
, addr
);
300 rc
= em28xx_i2c_check_for_device(dev
, addr
);
303 printk(" no device\n");
306 } else if (msgs
[i
].flags
& I2C_M_RD
) {
308 if (dev
->board
.is_em2800
)
309 rc
= em2800_i2c_recv_bytes(dev
, addr
,
313 rc
= em28xx_i2c_recv_bytes(dev
, addr
,
317 for (byte
= 0; byte
< msgs
[i
].len
; byte
++)
318 printk(" %02x", msgs
[i
].buf
[byte
]);
323 for (byte
= 0; byte
< msgs
[i
].len
; byte
++)
324 printk(" %02x", msgs
[i
].buf
[byte
]);
326 if (dev
->board
.is_em2800
)
327 rc
= em2800_i2c_send_bytes(dev
, addr
,
331 rc
= em28xx_i2c_send_bytes(dev
, addr
,
338 printk(" ERROR: %i\n", rc
);
348 /* based on linux/sunrpc/svcauth.h and linux/hash.h
349 * The original hash function returns a different value, if arch is x86_64
352 static inline unsigned long em28xx_hash_mem(char *buf
, int length
, int bits
)
354 unsigned long hash
= 0;
366 if ((len
& (32 / 8 - 1)) == 0)
367 hash
= ((hash
^l
) * 0x9e370001UL
);
370 return (hash
>> (32 - bits
)) & 0xffffffffUL
;
373 /* Helper function to read data blocks from i2c clients with 8 or 16 bit
374 * address width, 8 bit register width and auto incrementation been activated */
375 static int em28xx_i2c_read_block(struct em28xx
*dev
, u16 addr
, bool addr_w16
,
378 int remain
= len
, rsize
, rsize_max
, ret
;
382 if (addr
+ remain
> (addr_w16
* 0xff00 + 0xff + 1))
386 buf
[1] = addr
& 0xff;
387 ret
= i2c_master_send(&dev
->i2c_client
, buf
+ !addr_w16
, 1 + addr_w16
);
391 if (dev
->board
.is_em2800
)
396 if (remain
> rsize_max
)
401 ret
= i2c_master_recv(&dev
->i2c_client
, data
, rsize
);
412 static int em28xx_i2c_eeprom(struct em28xx
*dev
, unsigned char **eedata
, int len
)
415 struct em28xx_eeprom
*em_eeprom
;
420 dev
->i2c_client
.addr
= 0xa0 >> 1;
422 /* Check if board has eeprom */
423 err
= i2c_master_recv(&dev
->i2c_client
, &buf
, 0);
425 em28xx_info("board has no eeprom\n");
429 data
= kzalloc(len
, GFP_KERNEL
);
433 /* Read EEPROM content */
434 err
= em28xx_i2c_read_block(dev
, 0x0000, dev
->eeprom_addrwidth_16bit
,
437 em28xx_errdev("failed to read eeprom (err=%d)\n", err
);
442 /* Display eeprom content */
443 for (i
= 0; i
< len
; i
++) {
445 if (dev
->eeprom_addrwidth_16bit
)
446 em28xx_info("i2c eeprom %04x:", i
);
448 em28xx_info("i2c eeprom %02x:", i
);
450 printk(" %02x", data
[i
]);
455 if (dev
->eeprom_addrwidth_16bit
&&
456 data
[0] == 0x26 && data
[3] == 0x00) {
457 /* new eeprom format; size 4-64kb */
458 dev
->hash
= em28xx_hash_mem(data
, len
, 32);
459 em28xx_info("EEPROM hash = 0x%08lx\n", dev
->hash
);
460 em28xx_info("EEPROM info: boot page address = 0x%02x04, "
461 "boot configuration = 0x%02x\n",
463 /* boot configuration (address 0x0002):
464 * [0] microcode download speed: 1 = 400 kHz; 0 = 100 kHz
465 * [1] always selects 12 kb RAM
466 * [2] USB device speed: 1 = force Full Speed; 0 = auto detect
467 * [4] 1 = force fast mode and no suspend for device testing
468 * [5:7] USB PHY tuning registers; determined by device
473 * - read more than 256 bytes / addresses above 0x00ff
474 * - find offset for device config dataset and extract it
475 * - decrypt eeprom data for camera bridges (em25xx, em276x+)
476 * - use separate/different eeprom hashes (not yet used)
480 } else if (data
[0] != 0x1a || data
[1] != 0xeb ||
481 data
[2] != 0x67 || data
[3] != 0x95) {
482 em28xx_info("unknown eeprom format or eeprom corrupted !\n");
487 em_eeprom
= (void *)eedata
;
489 dev
->hash
= em28xx_hash_mem(data
, len
, 32);
491 em28xx_info("EEPROM ID = %02x %02x %02x %02x, EEPROM hash = 0x%08lx\n",
492 em_eeprom
->id
[0], em_eeprom
->id
[1],
493 em_eeprom
->id
[2], em_eeprom
->id
[3], dev
->hash
);
495 em28xx_info("EEPROM info:\n");
497 switch (le16_to_cpu(em_eeprom
->chip_conf
) >> 4 & 0x3) {
499 em28xx_info("\tNo audio on board.\n");
502 em28xx_info("\tAC97 audio (5 sample rates)\n");
505 em28xx_info("\tI2S audio, sample rate=32k\n");
508 em28xx_info("\tI2S audio, 3 sample rates\n");
512 if (le16_to_cpu(em_eeprom
->chip_conf
) & 1 << 3)
513 em28xx_info("\tUSB Remote wakeup capable\n");
515 if (le16_to_cpu(em_eeprom
->chip_conf
) & 1 << 2)
516 em28xx_info("\tUSB Self power capable\n");
518 switch (le16_to_cpu(em_eeprom
->chip_conf
) & 0x3) {
520 em28xx_info("\t500mA max power\n");
523 em28xx_info("\t400mA max power\n");
526 em28xx_info("\t300mA max power\n");
529 em28xx_info("\t200mA max power\n");
532 em28xx_info("\tTable at offset 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
533 em_eeprom
->string_idx_table
,
534 le16_to_cpu(em_eeprom
->string1
),
535 le16_to_cpu(em_eeprom
->string2
),
536 le16_to_cpu(em_eeprom
->string3
));
541 /* ----------------------------------------------------------- */
546 static u32
functionality(struct i2c_adapter
*adap
)
548 struct em28xx
*dev
= adap
->algo_data
;
549 u32 func_flags
= I2C_FUNC_I2C
| I2C_FUNC_SMBUS_EMUL
;
550 if (dev
->board
.is_em2800
)
551 func_flags
&= ~I2C_FUNC_SMBUS_WRITE_BLOCK_DATA
;
555 static struct i2c_algorithm em28xx_algo
= {
556 .master_xfer
= em28xx_i2c_xfer
,
557 .functionality
= functionality
,
560 static struct i2c_adapter em28xx_adap_template
= {
561 .owner
= THIS_MODULE
,
563 .algo
= &em28xx_algo
,
566 static struct i2c_client em28xx_client_template
= {
567 .name
= "em28xx internal",
570 /* ----------------------------------------------------------- */
574 * incomplete list of known devices
576 static char *i2c_devs
[128] = {
577 [0x3e >> 1] = "remote IR sensor",
578 [0x4a >> 1] = "saa7113h",
579 [0x52 >> 1] = "drxk",
580 [0x60 >> 1] = "remote IR sensor",
581 [0x8e >> 1] = "remote IR sensor",
582 [0x86 >> 1] = "tda9887",
583 [0x80 >> 1] = "msp34xx",
584 [0x88 >> 1] = "msp34xx",
585 [0xa0 >> 1] = "eeprom",
586 [0xb0 >> 1] = "tda9874",
587 [0xb8 >> 1] = "tvp5150a",
588 [0xba >> 1] = "webcam sensor or tvp5150a",
589 [0xc0 >> 1] = "tuner (analog)",
590 [0xc2 >> 1] = "tuner (analog)",
591 [0xc4 >> 1] = "tuner (analog)",
592 [0xc6 >> 1] = "tuner (analog)",
597 * check i2c address range for devices
599 void em28xx_do_i2c_scan(struct em28xx
*dev
)
601 u8 i2c_devicelist
[128];
605 memset(i2c_devicelist
, 0, ARRAY_SIZE(i2c_devicelist
));
607 for (i
= 0; i
< ARRAY_SIZE(i2c_devs
); i
++) {
608 dev
->i2c_client
.addr
= i
;
609 rc
= i2c_master_recv(&dev
->i2c_client
, &buf
, 0);
612 i2c_devicelist
[i
] = i
;
613 em28xx_info("found i2c device @ 0x%x [%s]\n",
614 i
<< 1, i2c_devs
[i
] ? i2c_devs
[i
] : "???");
617 dev
->i2c_hash
= em28xx_hash_mem(i2c_devicelist
,
618 ARRAY_SIZE(i2c_devicelist
), 32);
622 * em28xx_i2c_register()
625 int em28xx_i2c_register(struct em28xx
*dev
)
629 BUG_ON(!dev
->em28xx_write_regs
|| !dev
->em28xx_read_reg
);
630 BUG_ON(!dev
->em28xx_write_regs_req
|| !dev
->em28xx_read_reg_req
);
631 dev
->i2c_adap
= em28xx_adap_template
;
632 dev
->i2c_adap
.dev
.parent
= &dev
->udev
->dev
;
633 strcpy(dev
->i2c_adap
.name
, dev
->name
);
634 dev
->i2c_adap
.algo_data
= dev
;
635 i2c_set_adapdata(&dev
->i2c_adap
, &dev
->v4l2_dev
);
637 retval
= i2c_add_adapter(&dev
->i2c_adap
);
639 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
644 dev
->i2c_client
= em28xx_client_template
;
645 dev
->i2c_client
.adapter
= &dev
->i2c_adap
;
647 retval
= em28xx_i2c_eeprom(dev
, &dev
->eedata
, 256);
648 if ((retval
< 0) && (retval
!= -ENODEV
)) {
649 em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
656 em28xx_do_i2c_scan(dev
);
662 * em28xx_i2c_unregister()
665 int em28xx_i2c_unregister(struct em28xx
*dev
)
667 i2c_del_adapter(&dev
->i2c_adap
);