]> git.proxmox.com Git - mirror_ubuntu-kernels.git/blob - drivers/media/usb/em28xx/em28xx-i2c.c
projects / mirror_ubuntu-kernels.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
HID: logitech-dj: fix spelling in printk
[mirror_ubuntu-kernels.git] / drivers / media / usb / em28xx / em28xx-i2c.c
1 // SPDX-License-Identifier: GPL-2.0+
2 //
3 // em28xx-i2c.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
4 //
5 // Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
6 // Markus Rechberger <mrechberger@gmail.com>
7 // Mauro Carvalho Chehab <mchehab@kernel.org>
8 // Sascha Sommer <saschasommer@freenet.de>
9 // Copyright (C) 2013 Frank Schäfer <fschaefer.oss@googlemail.com>
10 //
11 // This program is free software; you can redistribute it and/or modify
12 // it under the terms of the GNU General Public License as published by
13 // the Free Software Foundation; either version 2 of the License, or
14 // (at your option) any later version.
15 //
16 // This program is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU General Public License for more details.
20
21 #include "em28xx.h"
22
23 #include <linux/module.h>
24 #include <linux/kernel.h>
25 #include <linux/usb.h>
26 #include <linux/i2c.h>
27 #include <linux/jiffies.h>
28
29 #include "tuner-xc2028.h"
30 #include <media/v4l2-common.h>
31 #include <media/tuner.h>
32
33 /* ----------------------------------------------------------- */
34
35 static unsigned int i2c_scan;
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;
40 module_param(i2c_debug, int, 0644);
41 MODULE_PARM_DESC(i2c_debug, "i2c debug message level (1: normal debug, 2: show I2C transfers)");
42
43 #define dprintk(level, fmt, arg...) do { \
44 if (i2c_debug > level) \
45 dev_printk(KERN_DEBUG, &dev->intf->dev, \
46 "i2c: %s: " fmt, __func__, ## arg); \
47 } while (0)
48
49 /*
50 * Time in msecs to wait for i2c xfers to finish.
51 * 35ms is the maximum time a SMBUS device could wait when
52 * clock stretching is used. As the transfer itself will take
53 * some time to happen, set it to 35 ms.
54 *
55 * Ok, I2C doesn't specify any limit. So, eventually, we may need
56 * to increase this timeout.
57 */
58 #define EM28XX_I2C_XFER_TIMEOUT 35 /* ms */
59
60 static int em28xx_i2c_timeout(struct em28xx *dev)
61 {
62 int time = EM28XX_I2C_XFER_TIMEOUT;
63
64 switch (dev->i2c_speed & 0x03) {
65 case EM28XX_I2C_FREQ_25_KHZ:
66 time += 4; /* Assume 4 ms for transfers */
67 break;
68 case EM28XX_I2C_FREQ_100_KHZ:
69 case EM28XX_I2C_FREQ_400_KHZ:
70 time += 1; /* Assume 1 ms for transfers */
71 break;
72 default: /* EM28XX_I2C_FREQ_1_5_MHZ */
73 break;
74 }
75
76 return msecs_to_jiffies(time);
77 }
78
79 /*
80 * em2800_i2c_send_bytes()
81 * send up to 4 bytes to the em2800 i2c device
82 */
83 static int em2800_i2c_send_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
84 {
85 unsigned long timeout = jiffies + em28xx_i2c_timeout(dev);
86 int ret;
87 u8 b2[6];
88
89 if (len < 1 || len > 4)
90 return -EOPNOTSUPP;
91
92 b2[5] = 0x80 + len - 1;
93 b2[4] = addr;
94 b2[3] = buf[0];
95 if (len > 1)
96 b2[2] = buf[1];
97 if (len > 2)
98 b2[1] = buf[2];
99 if (len > 3)
100 b2[0] = buf[3];
101
102 /* trigger write */
103 ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
104 if (ret != 2 + len) {
105 dev_warn(&dev->intf->dev,
106 "failed to trigger write to i2c address 0x%x (error=%i)\n",
107 addr, ret);
108 return (ret < 0) ? ret : -EIO;
109 }
110 /* wait for completion */
111 while (time_is_after_jiffies(timeout)) {
112 ret = dev->em28xx_read_reg(dev, 0x05);
113 if (ret == 0x80 + len - 1)
114 return len;
115 if (ret == 0x94 + len - 1) {
116 dprintk(1, "R05 returned 0x%02x: I2C ACK error\n", ret);
117 return -ENXIO;
118 }
119 if (ret < 0) {
120 dev_warn(&dev->intf->dev,
121 "failed to get i2c transfer status from bridge register (error=%i)\n",
122 ret);
123 return ret;
124 }
125 usleep_range(5000, 6000);
126 }
127 dprintk(0, "write to i2c device at 0x%x timed out\n", addr);
128 return -ETIMEDOUT;
129 }
130
131 /*
132 * em2800_i2c_recv_bytes()
133 * read up to 4 bytes from the em2800 i2c device
134 */
135 static int em2800_i2c_recv_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
136 {
137 unsigned long timeout = jiffies + em28xx_i2c_timeout(dev);
138 u8 buf2[4];
139 int ret;
140 int i;
141
142 if (len < 1 || len > 4)
143 return -EOPNOTSUPP;
144
145 /* trigger read */
146 buf2[1] = 0x84 + len - 1;
147 buf2[0] = addr;
148 ret = dev->em28xx_write_regs(dev, 0x04, buf2, 2);
149 if (ret != 2) {
150 dev_warn(&dev->intf->dev,
151 "failed to trigger read from i2c address 0x%x (error=%i)\n",
152 addr, ret);
153 return (ret < 0) ? ret : -EIO;
154 }
155
156 /* wait for completion */
157 while (time_is_after_jiffies(timeout)) {
158 ret = dev->em28xx_read_reg(dev, 0x05);
159 if (ret == 0x84 + len - 1)
160 break;
161 if (ret == 0x94 + len - 1) {
162 dprintk(1, "R05 returned 0x%02x: I2C ACK error\n",
163 ret);
164 return -ENXIO;
165 }
166 if (ret < 0) {
167 dev_warn(&dev->intf->dev,
168 "failed to get i2c transfer status from bridge register (error=%i)\n",
169 ret);
170 return ret;
171 }
172 usleep_range(5000, 6000);
173 }
174 if (ret != 0x84 + len - 1)
175 dprintk(0, "read from i2c device at 0x%x timed out\n", addr);
176
177 /* get the received message */
178 ret = dev->em28xx_read_reg_req_len(dev, 0x00, 4 - len, buf2, len);
179 if (ret != len) {
180 dev_warn(&dev->intf->dev,
181 "reading from i2c device at 0x%x failed: couldn't get the received message from the bridge (error=%i)\n",
182 addr, ret);
183 return (ret < 0) ? ret : -EIO;
184 }
185 for (i = 0; i < len; i++)
186 buf[i] = buf2[len - 1 - i];
187
188 return ret;
189 }
190
191 /*
192 * em2800_i2c_check_for_device()
193 * check if there is an i2c device at the supplied address
194 */
195 static int em2800_i2c_check_for_device(struct em28xx *dev, u8 addr)
196 {
197 u8 buf;
198 int ret;
199
200 ret = em2800_i2c_recv_bytes(dev, addr, &buf, 1);
201 if (ret == 1)
202 return 0;
203 return (ret < 0) ? ret : -EIO;
204 }
205
206 /*
207 * em28xx_i2c_send_bytes()
208 */
209 static int em28xx_i2c_send_bytes(struct em28xx *dev, u16 addr, u8 *buf,
210 u16 len, int stop)
211 {
212 unsigned long timeout = jiffies + em28xx_i2c_timeout(dev);
213 int ret;
214
215 if (len < 1 || len > 64)
216 return -EOPNOTSUPP;
217 /*
218 * NOTE: limited by the USB ctrl message constraints
219 * Zero length reads always succeed, even if no device is connected
220 */
221
222 /* Write to i2c device */
223 ret = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
224 if (ret != len) {
225 if (ret < 0) {
226 dev_warn(&dev->intf->dev,
227 "writing to i2c device at 0x%x failed (error=%i)\n",
228 addr, ret);
229 return ret;
230 }
231 dev_warn(&dev->intf->dev,
232 "%i bytes write to i2c device at 0x%x requested, but %i bytes written\n",
233 len, addr, ret);
234 return -EIO;
235 }
236
237 /* wait for completion */
238 while (time_is_after_jiffies(timeout)) {
239 ret = dev->em28xx_read_reg(dev, 0x05);
240 if (ret == 0) /* success */
241 return len;
242 if (ret == 0x10) {
243 dprintk(1, "I2C ACK error on writing to addr 0x%02x\n",
244 addr);
245 return -ENXIO;
246 }
247 if (ret < 0) {
248 dev_warn(&dev->intf->dev,
249 "failed to get i2c transfer status from bridge register (error=%i)\n",
250 ret);
251 return ret;
252 }
253 usleep_range(5000, 6000);
254 /*
255 * NOTE: do we really have to wait for success ?
256 * Never seen anything else than 0x00 or 0x10
257 * (even with high payload) ...
258 */
259 }
260
261 if (ret == 0x02 || ret == 0x04) {
262 /* NOTE: these errors seem to be related to clock stretching */
263 dprintk(0,
264 "write to i2c device at 0x%x timed out (status=%i)\n",
265 addr, ret);
266 return -ETIMEDOUT;
267 }
268
269 dev_warn(&dev->intf->dev,
270 "write to i2c device at 0x%x failed with unknown error (status=%i)\n",
271 addr, ret);
272 return -EIO;
273 }
274
275 /*
276 * em28xx_i2c_recv_bytes()
277 * read a byte from the i2c device
278 */
279 static int em28xx_i2c_recv_bytes(struct em28xx *dev, u16 addr, u8 *buf, u16 len)
280 {
281 int ret;
282
283 if (len < 1 || len > 64)
284 return -EOPNOTSUPP;
285 /*
286 * NOTE: limited by the USB ctrl message constraints
287 * Zero length reads always succeed, even if no device is connected
288 */
289
290 /* Read data from i2c device */
291 ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
292 if (ret < 0) {
293 dev_warn(&dev->intf->dev,
294 "reading from i2c device at 0x%x failed (error=%i)\n",
295 addr, ret);
296 return ret;
297 }
298 /*
299 * NOTE: some devices with two i2c busses have the bad habit to return 0
300 * bytes if we are on bus B AND there was no write attempt to the
301 * specified slave address before AND no device is present at the
302 * requested slave address.
303 * Anyway, the next check will fail with -ENXIO in this case, so avoid
304 * spamming the system log on device probing and do nothing here.
305 */
306
307 /* Check success of the i2c operation */
308 ret = dev->em28xx_read_reg(dev, 0x05);
309 if (ret == 0) /* success */
310 return len;
311 if (ret < 0) {
312 dev_warn(&dev->intf->dev,
313 "failed to get i2c transfer status from bridge register (error=%i)\n",
314 ret);
315 return ret;
316 }
317 if (ret == 0x10) {
318 dprintk(1, "I2C ACK error on writing to addr 0x%02x\n",
319 addr);
320 return -ENXIO;
321 }
322
323 if (ret == 0x02 || ret == 0x04) {
324 /* NOTE: these errors seem to be related to clock stretching */
325 dprintk(0,
326 "write to i2c device at 0x%x timed out (status=%i)\n",
327 addr, ret);
328 return -ETIMEDOUT;
329 }
330
331 dev_warn(&dev->intf->dev,
332 "write to i2c device at 0x%x failed with unknown error (status=%i)\n",
333 addr, ret);
334 return -EIO;
335 }
336
337 /*
338 * em28xx_i2c_check_for_device()
339 * check if there is a i2c_device at the supplied address
340 */
341 static int em28xx_i2c_check_for_device(struct em28xx *dev, u16 addr)
342 {
343 int ret;
344 u8 buf;
345
346 ret = em28xx_i2c_recv_bytes(dev, addr, &buf, 1);
347 if (ret == 1)
348 return 0;
349 return (ret < 0) ? ret : -EIO;
350 }
351
352 /*
353 * em25xx_bus_B_send_bytes
354 * write bytes to the i2c device
355 */
356 static int em25xx_bus_B_send_bytes(struct em28xx *dev, u16 addr, u8 *buf,
357 u16 len)
358 {
359 int ret;
360
361 if (len < 1 || len > 64)
362 return -EOPNOTSUPP;
363 /*
364 * NOTE: limited by the USB ctrl message constraints
365 * Zero length reads always succeed, even if no device is connected
366 */
367
368 /* Set register and write value */
369 ret = dev->em28xx_write_regs_req(dev, 0x06, addr, buf, len);
370 if (ret != len) {
371 if (ret < 0) {
372 dev_warn(&dev->intf->dev,
373 "writing to i2c device at 0x%x failed (error=%i)\n",
374 addr, ret);
375 return ret;
376 }
377
378 dev_warn(&dev->intf->dev,
379 "%i bytes write to i2c device at 0x%x requested, but %i bytes written\n",
380 len, addr, ret);
381 return -EIO;
382 }
383 /* Check success */
384 ret = dev->em28xx_read_reg_req(dev, 0x08, 0x0000);
385 /*
386 * NOTE: the only error we've seen so far is
387 * 0x01 when the slave device is not present
388 */
389 if (!ret)
390 return len;
391
392 if (ret > 0) {
393 dprintk(1, "Bus B R08 returned 0x%02x: I2C ACK error\n", ret);
394 return -ENXIO;
395 }
396
397 return ret;
398 /*
399 * NOTE: With chip types (other chip IDs) which actually don't support
400 * this operation, it seems to succeed ALWAYS ! (even if there is no
401 * slave device or even no second i2c bus provided)
402 */
403 }
404
405 /*
406 * em25xx_bus_B_recv_bytes
407 * read bytes from the i2c device
408 */
409 static int em25xx_bus_B_recv_bytes(struct em28xx *dev, u16 addr, u8 *buf,
410 u16 len)
411 {
412 int ret;
413
414 if (len < 1 || len > 64)
415 return -EOPNOTSUPP;
416 /*
417 * NOTE: limited by the USB ctrl message constraints
418 * Zero length reads always succeed, even if no device is connected
419 */
420
421 /* Read value */
422 ret = dev->em28xx_read_reg_req_len(dev, 0x06, addr, buf, len);
423 if (ret < 0) {
424 dev_warn(&dev->intf->dev,
425 "reading from i2c device at 0x%x failed (error=%i)\n",
426 addr, ret);
427 return ret;
428 }
429 /*
430 * NOTE: some devices with two i2c busses have the bad habit to return 0
431 * bytes if we are on bus B AND there was no write attempt to the
432 * specified slave address before AND no device is present at the
433 * requested slave address.
434 * Anyway, the next check will fail with -ENXIO in this case, so avoid
435 * spamming the system log on device probing and do nothing here.
436 */
437
438 /* Check success */
439 ret = dev->em28xx_read_reg_req(dev, 0x08, 0x0000);
440 /*
441 * NOTE: the only error we've seen so far is
442 * 0x01 when the slave device is not present
443 */
444 if (!ret)
445 return len;
446
447 if (ret > 0) {
448 dprintk(1, "Bus B R08 returned 0x%02x: I2C ACK error\n", ret);
449 return -ENXIO;
450 }
451
452 return ret;
453 /*
454 * NOTE: With chip types (other chip IDs) which actually don't support
455 * this operation, it seems to succeed ALWAYS ! (even if there is no
456 * slave device or even no second i2c bus provided)
457 */
458 }
459
460 /*
461 * em25xx_bus_B_check_for_device()
462 * check if there is a i2c device at the supplied address
463 */
464 static int em25xx_bus_B_check_for_device(struct em28xx *dev, u16 addr)
465 {
466 u8 buf;
467 int ret;
468
469 ret = em25xx_bus_B_recv_bytes(dev, addr, &buf, 1);
470 if (ret < 0)
471 return ret;
472
473 return 0;
474 /*
475 * NOTE: With chips which do not support this operation,
476 * it seems to succeed ALWAYS ! (even if no device connected)
477 */
478 }
479
480 static inline int i2c_check_for_device(struct em28xx_i2c_bus *i2c_bus, u16 addr)
481 {
482 struct em28xx *dev = i2c_bus->dev;
483 int rc = -EOPNOTSUPP;
484
485 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX)
486 rc = em28xx_i2c_check_for_device(dev, addr);
487 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800)
488 rc = em2800_i2c_check_for_device(dev, addr);
489 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)
490 rc = em25xx_bus_B_check_for_device(dev, addr);
491 return rc;
492 }
493
494 static inline int i2c_recv_bytes(struct em28xx_i2c_bus *i2c_bus,
495 struct i2c_msg msg)
496 {
497 struct em28xx *dev = i2c_bus->dev;
498 u16 addr = msg.addr << 1;
499 int rc = -EOPNOTSUPP;
500
501 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX)
502 rc = em28xx_i2c_recv_bytes(dev, addr, msg.buf, msg.len);
503 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800)
504 rc = em2800_i2c_recv_bytes(dev, addr, msg.buf, msg.len);
505 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)
506 rc = em25xx_bus_B_recv_bytes(dev, addr, msg.buf, msg.len);
507 return rc;
508 }
509
510 static inline int i2c_send_bytes(struct em28xx_i2c_bus *i2c_bus,
511 struct i2c_msg msg, int stop)
512 {
513 struct em28xx *dev = i2c_bus->dev;
514 u16 addr = msg.addr << 1;
515 int rc = -EOPNOTSUPP;
516
517 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX)
518 rc = em28xx_i2c_send_bytes(dev, addr, msg.buf, msg.len, stop);
519 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800)
520 rc = em2800_i2c_send_bytes(dev, addr, msg.buf, msg.len);
521 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)
522 rc = em25xx_bus_B_send_bytes(dev, addr, msg.buf, msg.len);
523 return rc;
524 }
525
526 /*
527 * em28xx_i2c_xfer()
528 * the main i2c transfer function
529 */
530 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
531 struct i2c_msg msgs[], int num)
532 {
533 struct em28xx_i2c_bus *i2c_bus = i2c_adap->algo_data;
534 struct em28xx *dev = i2c_bus->dev;
535 unsigned int bus = i2c_bus->bus;
536 int addr, rc, i;
537 u8 reg;
538
539 /*
540 * prevent i2c xfer attempts after device is disconnected
541 * some fe's try to do i2c writes/reads from their release
542 * interfaces when called in disconnect path
543 */
544 if (dev->disconnected)
545 return -ENODEV;
546
547 if (!rt_mutex_trylock(&dev->i2c_bus_lock))
548 return -EAGAIN;
549
550 /* Switch I2C bus if needed */
551 if (bus != dev->cur_i2c_bus &&
552 i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX) {
553 if (bus == 1)
554 reg = EM2874_I2C_SECONDARY_BUS_SELECT;
555 else
556 reg = 0;
557 em28xx_write_reg_bits(dev, EM28XX_R06_I2C_CLK, reg,
558 EM2874_I2C_SECONDARY_BUS_SELECT);
559 dev->cur_i2c_bus = bus;
560 }
561
562 for (i = 0; i < num; i++) {
563 addr = msgs[i].addr << 1;
564 if (!msgs[i].len) {
565 /*
566 * no len: check only for device presence
567 * This code is only called during device probe.
568 */
569 rc = i2c_check_for_device(i2c_bus, addr);
570
571 if (rc == -ENXIO)
572 rc = -ENODEV;
573 } else if (msgs[i].flags & I2C_M_RD) {
574 /* read bytes */
575 rc = i2c_recv_bytes(i2c_bus, msgs[i]);
576 } else {
577 /* write bytes */
578 rc = i2c_send_bytes(i2c_bus, msgs[i], i == num - 1);
579 }
580
581 if (rc < 0)
582 goto error;
583
584 dprintk(2, "%s %s addr=%02x len=%d: %*ph\n",
585 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
586 i == num - 1 ? "stop" : "nonstop",
587 addr, msgs[i].len,
588 msgs[i].len, msgs[i].buf);
589 }
590
591 rt_mutex_unlock(&dev->i2c_bus_lock);
592 return num;
593
594 error:
595 dprintk(2, "%s %s addr=%02x len=%d: %sERROR: %i\n",
596 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
597 i == num - 1 ? "stop" : "nonstop",
598 addr, msgs[i].len,
599 (rc == -ENODEV) ? "no device " : "",
600 rc);
601
602 rt_mutex_unlock(&dev->i2c_bus_lock);
603 return rc;
604 }
605
606 /*
607 * based on linux/sunrpc/svcauth.h and linux/hash.h
608 * The original hash function returns a different value, if arch is x86_64
609 * or i386.
610 */
611 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
612 {
613 unsigned long hash = 0;
614 unsigned long l = 0;
615 int len = 0;
616 unsigned char c;
617
618 do {
619 if (len == length) {
620 c = (char)len;
621 len = -1;
622 } else {
623 c = *buf++;
624 }
625 l = (l << 8) | c;
626 len++;
627 if ((len & (32 / 8 - 1)) == 0)
628 hash = ((hash ^ l) * 0x9e370001UL);
629 } while (len);
630
631 return (hash >> (32 - bits)) & 0xffffffffUL;
632 }
633
634 /*
635 * Helper function to read data blocks from i2c clients with 8 or 16 bit
636 * address width, 8 bit register width and auto incrementation been activated
637 */
638 static int em28xx_i2c_read_block(struct em28xx *dev, unsigned int bus, u16 addr,
639 bool addr_w16, u16 len, u8 *data)
640 {
641 int remain = len, rsize, rsize_max, ret;
642 u8 buf[2];
643
644 /* Sanity check */
645 if (addr + remain > (addr_w16 * 0xff00 + 0xff + 1))
646 return -EINVAL;
647 /* Select address */
648 buf[0] = addr >> 8;
649 buf[1] = addr & 0xff;
650 ret = i2c_master_send(&dev->i2c_client[bus],
651 buf + !addr_w16, 1 + addr_w16);
652 if (ret < 0)
653 return ret;
654 /* Read data */
655 if (dev->board.is_em2800)
656 rsize_max = 4;
657 else
658 rsize_max = 64;
659 while (remain > 0) {
660 if (remain > rsize_max)
661 rsize = rsize_max;
662 else
663 rsize = remain;
664
665 ret = i2c_master_recv(&dev->i2c_client[bus], data, rsize);
666 if (ret < 0)
667 return ret;
668
669 remain -= rsize;
670 data += rsize;
671 }
672
673 return len;
674 }
675
676 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned int bus,
677 u8 **eedata, u16 *eedata_len)
678 {
679 const u16 len = 256;
680 /*
681 * FIXME common length/size for bytes to read, to display, hash
682 * calculation and returned device dataset. Simplifies the code a lot,
683 * but we might have to deal with multiple sizes in the future !
684 */
685 int err;
686 struct em28xx_eeprom *dev_config;
687 u8 buf, *data;
688
689 *eedata = NULL;
690 *eedata_len = 0;
691
692 /* EEPROM is always on i2c bus 0 on all known devices. */
693
694 dev->i2c_client[bus].addr = 0xa0 >> 1;
695
696 /* Check if board has eeprom */
697 err = i2c_master_recv(&dev->i2c_client[bus], &buf, 0);
698 if (err < 0) {
699 dev_info(&dev->intf->dev, "board has no eeprom\n");
700 return -ENODEV;
701 }
702
703 data = kzalloc(len, GFP_KERNEL);
704 if (!data)
705 return -ENOMEM;
706
707 /* Read EEPROM content */
708 err = em28xx_i2c_read_block(dev, bus, 0x0000,
709 dev->eeprom_addrwidth_16bit,
710 len, data);
711 if (err != len) {
712 dev_err(&dev->intf->dev,
713 "failed to read eeprom (err=%d)\n", err);
714 goto error;
715 }
716
717 if (i2c_debug) {
718 /* Display eeprom content */
719 print_hex_dump(KERN_DEBUG, "em28xx eeprom ", DUMP_PREFIX_OFFSET,
720 16, 1, data, len, true);
721
722 if (dev->eeprom_addrwidth_16bit)
723 dev_info(&dev->intf->dev,
724 "eeprom %06x: ... (skipped)\n", 256);
725 }
726
727 if (dev->eeprom_addrwidth_16bit &&
728 data[0] == 0x26 && data[3] == 0x00) {
729 /* new eeprom format; size 4-64kb */
730 u16 mc_start;
731 u16 hwconf_offset;
732
733 dev->hash = em28xx_hash_mem(data, len, 32);
734 mc_start = (data[1] << 8) + 4; /* usually 0x0004 */
735
736 dev_info(&dev->intf->dev,
737 "EEPROM ID = %4ph, EEPROM hash = 0x%08lx\n",
738 data, dev->hash);
739 dev_info(&dev->intf->dev,
740 "EEPROM info:\n");
741 dev_info(&dev->intf->dev,
742 "\tmicrocode start address = 0x%04x, boot configuration = 0x%02x\n",
743 mc_start, data[2]);
744 /*
745 * boot configuration (address 0x0002):
746 * [0] microcode download speed: 1 = 400 kHz; 0 = 100 kHz
747 * [1] always selects 12 kb RAM
748 * [2] USB device speed: 1 = force Full Speed; 0 = auto detect
749 * [4] 1 = force fast mode and no suspend for device testing
750 * [5:7] USB PHY tuning registers; determined by device
751 * characterization
752 */
753
754 /*
755 * Read hardware config dataset offset from address
756 * (microcode start + 46)
757 */
758 err = em28xx_i2c_read_block(dev, bus, mc_start + 46, 1, 2,
759 data);
760 if (err != 2) {
761 dev_err(&dev->intf->dev,
762 "failed to read hardware configuration data from eeprom (err=%d)\n",
763 err);
764 goto error;
765 }
766
767 /* Calculate hardware config dataset start address */
768 hwconf_offset = mc_start + data[0] + (data[1] << 8);
769
770 /* Read hardware config dataset */
771 /*
772 * NOTE: the microcode copy can be multiple pages long, but
773 * we assume the hardware config dataset is the same as in
774 * the old eeprom and not longer than 256 bytes.
775 * tveeprom is currently also limited to 256 bytes.
776 */
777 err = em28xx_i2c_read_block(dev, bus, hwconf_offset, 1, len,
778 data);
779 if (err != len) {
780 dev_err(&dev->intf->dev,
781 "failed to read hardware configuration data from eeprom (err=%d)\n",
782 err);
783 goto error;
784 }
785
786 /* Verify hardware config dataset */
787 /* NOTE: not all devices provide this type of dataset */
788 if (data[0] != 0x1a || data[1] != 0xeb ||
789 data[2] != 0x67 || data[3] != 0x95) {
790 dev_info(&dev->intf->dev,
791 "\tno hardware configuration dataset found in eeprom\n");
792 kfree(data);
793 return 0;
794 }
795
796 /*
797 * TODO: decrypt eeprom data for camera bridges
798 * (em25xx, em276x+)
799 */
800
801 } else if (!dev->eeprom_addrwidth_16bit &&
802 data[0] == 0x1a && data[1] == 0xeb &&
803 data[2] == 0x67 && data[3] == 0x95) {
804 dev->hash = em28xx_hash_mem(data, len, 32);
805 dev_info(&dev->intf->dev,
806 "EEPROM ID = %4ph, EEPROM hash = 0x%08lx\n",
807 data, dev->hash);
808 dev_info(&dev->intf->dev,
809 "EEPROM info:\n");
810 } else {
811 dev_info(&dev->intf->dev,
812 "unknown eeprom format or eeprom corrupted !\n");
813 err = -ENODEV;
814 goto error;
815 }
816
817 *eedata = data;
818 *eedata_len = len;
819 dev_config = (void *)*eedata;
820
821 switch (le16_to_cpu(dev_config->chip_conf) >> 4 & 0x3) {
822 case 0:
823 dev_info(&dev->intf->dev, "\tNo audio on board.\n");
824 break;
825 case 1:
826 dev_info(&dev->intf->dev, "\tAC97 audio (5 sample rates)\n");
827 break;
828 case 2:
829 if (dev->chip_id < CHIP_ID_EM2860)
830 dev_info(&dev->intf->dev,
831 "\tI2S audio, sample rate=32k\n");
832 else
833 dev_info(&dev->intf->dev,
834 "\tI2S audio, 3 sample rates\n");
835 break;
836 case 3:
837 if (dev->chip_id < CHIP_ID_EM2860)
838 dev_info(&dev->intf->dev,
839 "\tI2S audio, 3 sample rates\n");
840 else
841 dev_info(&dev->intf->dev,
842 "\tI2S audio, 5 sample rates\n");
843 break;
844 }
845
846 if (le16_to_cpu(dev_config->chip_conf) & 1 << 3)
847 dev_info(&dev->intf->dev, "\tUSB Remote wakeup capable\n");
848
849 if (le16_to_cpu(dev_config->chip_conf) & 1 << 2)
850 dev_info(&dev->intf->dev, "\tUSB Self power capable\n");
851
852 switch (le16_to_cpu(dev_config->chip_conf) & 0x3) {
853 case 0:
854 dev_info(&dev->intf->dev, "\t500mA max power\n");
855 break;
856 case 1:
857 dev_info(&dev->intf->dev, "\t400mA max power\n");
858 break;
859 case 2:
860 dev_info(&dev->intf->dev, "\t300mA max power\n");
861 break;
862 case 3:
863 dev_info(&dev->intf->dev, "\t200mA max power\n");
864 break;
865 }
866 dev_info(&dev->intf->dev,
867 "\tTable at offset 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
868 dev_config->string_idx_table,
869 le16_to_cpu(dev_config->string1),
870 le16_to_cpu(dev_config->string2),
871 le16_to_cpu(dev_config->string3));
872
873 return 0;
874
875 error:
876 kfree(data);
877 return err;
878 }
879
880 /* ----------------------------------------------------------- */
881
882 /*
883 * functionality()
884 */
885 static u32 functionality(struct i2c_adapter *i2c_adap)
886 {
887 struct em28xx_i2c_bus *i2c_bus = i2c_adap->algo_data;
888
889 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX ||
890 i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B) {
891 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
892 } else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800) {
893 return (I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL) &
894 ~I2C_FUNC_SMBUS_WRITE_BLOCK_DATA;
895 }
896
897 WARN(1, "Unknown i2c bus algorithm.\n");
898 return 0;
899 }
900
901 static const struct i2c_algorithm em28xx_algo = {
902 .master_xfer = em28xx_i2c_xfer,
903 .functionality = functionality,
904 };
905
906 static const struct i2c_adapter em28xx_adap_template = {
907 .owner = THIS_MODULE,
908 .name = "em28xx",
909 .algo = &em28xx_algo,
910 };
911
912 static const struct i2c_client em28xx_client_template = {
913 .name = "em28xx internal",
914 };
915
916 /* ----------------------------------------------------------- */
917
918 /*
919 * i2c_devs
920 * incomplete list of known devices
921 */
922 static char *i2c_devs[128] = {
923 [0x1c >> 1] = "lgdt330x",
924 [0x3e >> 1] = "remote IR sensor",
925 [0x4a >> 1] = "saa7113h",
926 [0x52 >> 1] = "drxk",
927 [0x60 >> 1] = "remote IR sensor",
928 [0x8e >> 1] = "remote IR sensor",
929 [0x86 >> 1] = "tda9887",
930 [0x80 >> 1] = "msp34xx",
931 [0x88 >> 1] = "msp34xx",
932 [0xa0 >> 1] = "eeprom",
933 [0xb0 >> 1] = "tda9874",
934 [0xb8 >> 1] = "tvp5150a",
935 [0xba >> 1] = "webcam sensor or tvp5150a",
936 [0xc0 >> 1] = "tuner (analog)",
937 [0xc2 >> 1] = "tuner (analog)",
938 [0xc4 >> 1] = "tuner (analog)",
939 [0xc6 >> 1] = "tuner (analog)",
940 };
941
942 /*
943 * do_i2c_scan()
944 * check i2c address range for devices
945 */
946 void em28xx_do_i2c_scan(struct em28xx *dev, unsigned int bus)
947 {
948 u8 i2c_devicelist[128];
949 unsigned char buf;
950 int i, rc;
951
952 memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
953
954 for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
955 dev->i2c_client[bus].addr = i;
956 rc = i2c_master_recv(&dev->i2c_client[bus], &buf, 0);
957 if (rc < 0)
958 continue;
959 i2c_devicelist[i] = i;
960 dev_info(&dev->intf->dev,
961 "found i2c device @ 0x%x on bus %d [%s]\n",
962 i << 1, bus, i2c_devs[i] ? i2c_devs[i] : "???");
963 }
964
965 if (bus == dev->def_i2c_bus)
966 dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
967 ARRAY_SIZE(i2c_devicelist), 32);
968 }
969
970 /*
971 * em28xx_i2c_register()
972 * register i2c bus
973 */
974 int em28xx_i2c_register(struct em28xx *dev, unsigned int bus,
975 enum em28xx_i2c_algo_type algo_type)
976 {
977 int retval;
978
979 if (WARN_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg ||
980 !dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req))
981 return -ENODEV;
982
983 if (bus >= NUM_I2C_BUSES)
984 return -ENODEV;
985
986 dev->i2c_adap[bus] = em28xx_adap_template;
987 dev->i2c_adap[bus].dev.parent = &dev->intf->dev;
988 strscpy(dev->i2c_adap[bus].name, dev_name(&dev->intf->dev),
989 sizeof(dev->i2c_adap[bus].name));
990
991 dev->i2c_bus[bus].bus = bus;
992 dev->i2c_bus[bus].algo_type = algo_type;
993 dev->i2c_bus[bus].dev = dev;
994 dev->i2c_adap[bus].algo_data = &dev->i2c_bus[bus];
995
996 retval = i2c_add_adapter(&dev->i2c_adap[bus]);
997 if (retval < 0) {
998 dev_err(&dev->intf->dev,
999 "%s: i2c_add_adapter failed! retval [%d]\n",
1000 __func__, retval);
1001 return retval;
1002 }
1003
1004 dev->i2c_client[bus] = em28xx_client_template;
1005 dev->i2c_client[bus].adapter = &dev->i2c_adap[bus];
1006
1007 /* Up to now, all eeproms are at bus 0 */
1008 if (!bus) {
1009 retval = em28xx_i2c_eeprom(dev, bus,
1010 &dev->eedata, &dev->eedata_len);
1011 if (retval < 0 && retval != -ENODEV) {
1012 dev_err(&dev->intf->dev,
1013 "%s: em28xx_i2_eeprom failed! retval [%d]\n",
1014 __func__, retval);
1015 }
1016 }
1017
1018 if (i2c_scan)
1019 em28xx_do_i2c_scan(dev, bus);
1020
1021 return 0;
1022 }
1023
1024 /*
1025 * em28xx_i2c_unregister()
1026 * unregister i2c_bus
1027 */
1028 int em28xx_i2c_unregister(struct em28xx *dev, unsigned int bus)
1029 {
1030 if (bus >= NUM_I2C_BUSES)
1031 return -ENODEV;
1032
1033 i2c_del_adapter(&dev->i2c_adap[bus]);
1034 return 0;
1035 }
Ubuntu combined Linux kernel mirror