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
em28xx_i2c_timeout(struct em28xx * dev)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 */
em2800_i2c_send_bytes(struct em28xx * dev,u8 addr,u8 * buf,u16 len)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 */
em2800_i2c_recv_bytes(struct em28xx * dev,u8 addr,u8 * buf,u16 len)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 */
em2800_i2c_check_for_device(struct em28xx * dev,u8 addr)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 */
em28xx_i2c_send_bytes(struct em28xx * dev,u16 addr,u8 * buf,u16 len,int stop)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 */
em28xx_i2c_recv_bytes(struct em28xx * dev,u16 addr,u8 * buf,u16 len)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 } else if (ret != len) {
298 dev_dbg(&dev->intf->dev,
299 "%i bytes read from i2c device at 0x%x requested, but %i bytes written\n",
300 ret, addr, len);
301 }
302 /*
303 * NOTE: some devices with two i2c buses have the bad habit to return 0
304 * bytes if we are on bus B AND there was no write attempt to the
305 * specified slave address before AND no device is present at the
306 * requested slave address.
307 * Anyway, the next check will fail with -ENXIO in this case, so avoid
308 * spamming the system log on device probing and do nothing here.
309 */
310
311 /* Check success of the i2c operation */
312 ret = dev->em28xx_read_reg(dev, 0x05);
313 if (ret == 0) /* success */
314 return len;
315 if (ret < 0) {
316 dev_warn(&dev->intf->dev,
317 "failed to get i2c transfer status from bridge register (error=%i)\n",
318 ret);
319 return ret;
320 }
321 if (ret == 0x10) {
322 dprintk(1, "I2C ACK error on writing to addr 0x%02x\n",
323 addr);
324 return -ENXIO;
325 }
326
327 if (ret == 0x02 || ret == 0x04) {
328 /* NOTE: these errors seem to be related to clock stretching */
329 dprintk(0,
330 "write to i2c device at 0x%x timed out (status=%i)\n",
331 addr, ret);
332 return -ETIMEDOUT;
333 }
334
335 dev_warn(&dev->intf->dev,
336 "read from i2c device at 0x%x failed with unknown error (status=%i)\n",
337 addr, ret);
338 return -EIO;
339 }
340
341 /*
342 * em28xx_i2c_check_for_device()
343 * check if there is a i2c_device at the supplied address
344 */
em28xx_i2c_check_for_device(struct em28xx * dev,u16 addr)345 static int em28xx_i2c_check_for_device(struct em28xx *dev, u16 addr)
346 {
347 int ret;
348 u8 buf;
349
350 ret = em28xx_i2c_recv_bytes(dev, addr, &buf, 1);
351 if (ret == 1)
352 return 0;
353 return (ret < 0) ? ret : -EIO;
354 }
355
356 /*
357 * em25xx_bus_B_send_bytes
358 * write bytes to the i2c device
359 */
em25xx_bus_B_send_bytes(struct em28xx * dev,u16 addr,u8 * buf,u16 len)360 static int em25xx_bus_B_send_bytes(struct em28xx *dev, u16 addr, u8 *buf,
361 u16 len)
362 {
363 int ret;
364
365 if (len < 1 || len > 64)
366 return -EOPNOTSUPP;
367 /*
368 * NOTE: limited by the USB ctrl message constraints
369 * Zero length reads always succeed, even if no device is connected
370 */
371
372 /* Set register and write value */
373 ret = dev->em28xx_write_regs_req(dev, 0x06, addr, buf, len);
374 if (ret != len) {
375 if (ret < 0) {
376 dev_warn(&dev->intf->dev,
377 "writing to i2c device at 0x%x failed (error=%i)\n",
378 addr, ret);
379 return ret;
380 }
381
382 dev_warn(&dev->intf->dev,
383 "%i bytes write to i2c device at 0x%x requested, but %i bytes written\n",
384 len, addr, ret);
385 return -EIO;
386 }
387 /* Check success */
388 ret = dev->em28xx_read_reg_req(dev, 0x08, 0x0000);
389 /*
390 * NOTE: the only error we've seen so far is
391 * 0x01 when the slave device is not present
392 */
393 if (!ret)
394 return len;
395
396 if (ret > 0) {
397 dprintk(1, "Bus B R08 returned 0x%02x: I2C ACK error\n", ret);
398 return -ENXIO;
399 }
400
401 return ret;
402 /*
403 * NOTE: With chip types (other chip IDs) which actually don't support
404 * this operation, it seems to succeed ALWAYS ! (even if there is no
405 * slave device or even no second i2c bus provided)
406 */
407 }
408
409 /*
410 * em25xx_bus_B_recv_bytes
411 * read bytes from the i2c device
412 */
em25xx_bus_B_recv_bytes(struct em28xx * dev,u16 addr,u8 * buf,u16 len)413 static int em25xx_bus_B_recv_bytes(struct em28xx *dev, u16 addr, u8 *buf,
414 u16 len)
415 {
416 int ret;
417
418 if (len < 1 || len > 64)
419 return -EOPNOTSUPP;
420 /*
421 * NOTE: limited by the USB ctrl message constraints
422 * Zero length reads always succeed, even if no device is connected
423 */
424
425 /* Read value */
426 ret = dev->em28xx_read_reg_req_len(dev, 0x06, addr, buf, len);
427 if (ret < 0) {
428 dev_warn(&dev->intf->dev,
429 "reading from i2c device at 0x%x failed (error=%i)\n",
430 addr, ret);
431 return ret;
432 }
433 /*
434 * NOTE: some devices with two i2c buses have the bad habit to return 0
435 * bytes if we are on bus B AND there was no write attempt to the
436 * specified slave address before AND no device is present at the
437 * requested slave address.
438 * Anyway, the next check will fail with -ENXIO in this case, so avoid
439 * spamming the system log on device probing and do nothing here.
440 */
441
442 /* Check success */
443 ret = dev->em28xx_read_reg_req(dev, 0x08, 0x0000);
444 /*
445 * NOTE: the only error we've seen so far is
446 * 0x01 when the slave device is not present
447 */
448 if (!ret)
449 return len;
450
451 if (ret > 0) {
452 dprintk(1, "Bus B R08 returned 0x%02x: I2C ACK error\n", ret);
453 return -ENXIO;
454 }
455
456 return ret;
457 /*
458 * NOTE: With chip types (other chip IDs) which actually don't support
459 * this operation, it seems to succeed ALWAYS ! (even if there is no
460 * slave device or even no second i2c bus provided)
461 */
462 }
463
464 /*
465 * em25xx_bus_B_check_for_device()
466 * check if there is a i2c device at the supplied address
467 */
em25xx_bus_B_check_for_device(struct em28xx * dev,u16 addr)468 static int em25xx_bus_B_check_for_device(struct em28xx *dev, u16 addr)
469 {
470 u8 buf;
471 int ret;
472
473 ret = em25xx_bus_B_recv_bytes(dev, addr, &buf, 1);
474 if (ret < 0)
475 return ret;
476
477 return 0;
478 /*
479 * NOTE: With chips which do not support this operation,
480 * it seems to succeed ALWAYS ! (even if no device connected)
481 */
482 }
483
i2c_check_for_device(struct em28xx_i2c_bus * i2c_bus,u16 addr)484 static inline int i2c_check_for_device(struct em28xx_i2c_bus *i2c_bus, u16 addr)
485 {
486 struct em28xx *dev = i2c_bus->dev;
487 int rc = -EOPNOTSUPP;
488
489 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX)
490 rc = em28xx_i2c_check_for_device(dev, addr);
491 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800)
492 rc = em2800_i2c_check_for_device(dev, addr);
493 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)
494 rc = em25xx_bus_B_check_for_device(dev, addr);
495 return rc;
496 }
497
i2c_recv_bytes(struct em28xx_i2c_bus * i2c_bus,struct i2c_msg msg)498 static inline int i2c_recv_bytes(struct em28xx_i2c_bus *i2c_bus,
499 struct i2c_msg msg)
500 {
501 struct em28xx *dev = i2c_bus->dev;
502 u16 addr = msg.addr << 1;
503 int rc = -EOPNOTSUPP;
504
505 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX)
506 rc = em28xx_i2c_recv_bytes(dev, addr, msg.buf, msg.len);
507 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800)
508 rc = em2800_i2c_recv_bytes(dev, addr, msg.buf, msg.len);
509 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)
510 rc = em25xx_bus_B_recv_bytes(dev, addr, msg.buf, msg.len);
511 return rc;
512 }
513
i2c_send_bytes(struct em28xx_i2c_bus * i2c_bus,struct i2c_msg msg,int stop)514 static inline int i2c_send_bytes(struct em28xx_i2c_bus *i2c_bus,
515 struct i2c_msg msg, int stop)
516 {
517 struct em28xx *dev = i2c_bus->dev;
518 u16 addr = msg.addr << 1;
519 int rc = -EOPNOTSUPP;
520
521 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX)
522 rc = em28xx_i2c_send_bytes(dev, addr, msg.buf, msg.len, stop);
523 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800)
524 rc = em2800_i2c_send_bytes(dev, addr, msg.buf, msg.len);
525 else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B)
526 rc = em25xx_bus_B_send_bytes(dev, addr, msg.buf, msg.len);
527 return rc;
528 }
529
530 /*
531 * em28xx_i2c_xfer()
532 * the main i2c transfer function
533 */
em28xx_i2c_xfer(struct i2c_adapter * i2c_adap,struct i2c_msg msgs[],int num)534 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
535 struct i2c_msg msgs[], int num)
536 {
537 struct em28xx_i2c_bus *i2c_bus = i2c_adap->algo_data;
538 struct em28xx *dev = i2c_bus->dev;
539 unsigned int bus = i2c_bus->bus;
540 int addr, rc, i;
541 u8 reg;
542
543 /*
544 * prevent i2c xfer attempts after device is disconnected
545 * some fe's try to do i2c writes/reads from their release
546 * interfaces when called in disconnect path
547 */
548 if (dev->disconnected)
549 return -ENODEV;
550
551 if (!rt_mutex_trylock(&dev->i2c_bus_lock))
552 return -EAGAIN;
553
554 /* Switch I2C bus if needed */
555 if (bus != dev->cur_i2c_bus &&
556 i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX) {
557 if (bus == 1)
558 reg = EM2874_I2C_SECONDARY_BUS_SELECT;
559 else
560 reg = 0;
561 em28xx_write_reg_bits(dev, EM28XX_R06_I2C_CLK, reg,
562 EM2874_I2C_SECONDARY_BUS_SELECT);
563 dev->cur_i2c_bus = bus;
564 }
565
566 for (i = 0; i < num; i++) {
567 addr = msgs[i].addr << 1;
568 if (!msgs[i].len) {
569 /*
570 * no len: check only for device presence
571 * This code is only called during device probe.
572 */
573 rc = i2c_check_for_device(i2c_bus, addr);
574
575 if (rc == -ENXIO)
576 rc = -ENODEV;
577 } else if (msgs[i].flags & I2C_M_RD) {
578 /* read bytes */
579 rc = i2c_recv_bytes(i2c_bus, msgs[i]);
580 } else {
581 /* write bytes */
582 rc = i2c_send_bytes(i2c_bus, msgs[i], i == num - 1);
583 }
584
585 if (rc < 0)
586 goto error;
587
588 dprintk(2, "%s %s addr=%02x len=%d: %*ph\n",
589 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
590 i == num - 1 ? "stop" : "nonstop",
591 addr, msgs[i].len,
592 msgs[i].len, msgs[i].buf);
593 }
594
595 rt_mutex_unlock(&dev->i2c_bus_lock);
596 return num;
597
598 error:
599 dprintk(2, "%s %s addr=%02x len=%d: %sERROR: %i\n",
600 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
601 i == num - 1 ? "stop" : "nonstop",
602 addr, msgs[i].len,
603 (rc == -ENODEV) ? "no device " : "",
604 rc);
605
606 rt_mutex_unlock(&dev->i2c_bus_lock);
607 return rc;
608 }
609
610 /*
611 * based on linux/sunrpc/svcauth.h and linux/hash.h
612 * The original hash function returns a different value, if arch is x86_64
613 * or i386.
614 */
em28xx_hash_mem(char * buf,int length,int bits)615 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
616 {
617 unsigned long hash = 0;
618 unsigned long l = 0;
619 int len = 0;
620 unsigned char c;
621
622 do {
623 if (len == length) {
624 c = (char)len;
625 len = -1;
626 } else {
627 c = *buf++;
628 }
629 l = (l << 8) | c;
630 len++;
631 if ((len & (32 / 8 - 1)) == 0)
632 hash = ((hash ^ l) * 0x9e370001UL);
633 } while (len);
634
635 return (hash >> (32 - bits)) & 0xffffffffUL;
636 }
637
638 /*
639 * Helper function to read data blocks from i2c clients with 8 or 16 bit
640 * address width, 8 bit register width and auto incrementation been activated
641 */
em28xx_i2c_read_block(struct em28xx * dev,unsigned int bus,u16 addr,bool addr_w16,u16 len,u8 * data)642 static int em28xx_i2c_read_block(struct em28xx *dev, unsigned int bus, u16 addr,
643 bool addr_w16, u16 len, u8 *data)
644 {
645 int remain = len, rsize, rsize_max, ret;
646 u8 buf[2];
647
648 /* Sanity check */
649 if (addr + remain > (addr_w16 * 0xff00 + 0xff + 1))
650 return -EINVAL;
651 /* Select address */
652 buf[0] = addr >> 8;
653 buf[1] = addr & 0xff;
654 ret = i2c_master_send(&dev->i2c_client[bus],
655 buf + !addr_w16, 1 + addr_w16);
656 if (ret < 0)
657 return ret;
658 /* Read data */
659 if (dev->board.is_em2800)
660 rsize_max = 4;
661 else
662 rsize_max = 64;
663 while (remain > 0) {
664 if (remain > rsize_max)
665 rsize = rsize_max;
666 else
667 rsize = remain;
668
669 ret = i2c_master_recv(&dev->i2c_client[bus], data, rsize);
670 if (ret < 0)
671 return ret;
672
673 remain -= rsize;
674 data += rsize;
675 }
676
677 return len;
678 }
679
em28xx_i2c_eeprom(struct em28xx * dev,unsigned int bus,u8 ** eedata,u16 * eedata_len)680 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned int bus,
681 u8 **eedata, u16 *eedata_len)
682 {
683 const u16 len = 256;
684 /*
685 * FIXME common length/size for bytes to read, to display, hash
686 * calculation and returned device dataset. Simplifies the code a lot,
687 * but we might have to deal with multiple sizes in the future !
688 */
689 int err;
690 struct em28xx_eeprom *dev_config;
691 u8 buf, *data;
692
693 *eedata = NULL;
694 *eedata_len = 0;
695
696 /* EEPROM is always on i2c bus 0 on all known devices. */
697
698 dev->i2c_client[bus].addr = 0xa0 >> 1;
699
700 /* Check if board has eeprom */
701 err = i2c_master_recv(&dev->i2c_client[bus], &buf, 0);
702 if (err < 0) {
703 dev_info(&dev->intf->dev, "board has no eeprom\n");
704 return -ENODEV;
705 }
706
707 data = kzalloc(len, GFP_KERNEL);
708 if (!data)
709 return -ENOMEM;
710
711 /* Read EEPROM content */
712 err = em28xx_i2c_read_block(dev, bus, 0x0000,
713 dev->eeprom_addrwidth_16bit,
714 len, data);
715 if (err != len) {
716 dev_err(&dev->intf->dev,
717 "failed to read eeprom (err=%d)\n", err);
718 goto error;
719 }
720
721 if (i2c_debug) {
722 /* Display eeprom content */
723 print_hex_dump(KERN_DEBUG, "em28xx eeprom ", DUMP_PREFIX_OFFSET,
724 16, 1, data, len, true);
725
726 if (dev->eeprom_addrwidth_16bit)
727 dev_info(&dev->intf->dev,
728 "eeprom %06x: ... (skipped)\n", 256);
729 }
730
731 if (dev->eeprom_addrwidth_16bit &&
732 data[0] == 0x26 && data[3] == 0x00) {
733 /* new eeprom format; size 4-64kb */
734 u16 mc_start;
735 u16 hwconf_offset;
736
737 dev->hash = em28xx_hash_mem(data, len, 32);
738 mc_start = (data[1] << 8) + 4; /* usually 0x0004 */
739
740 dev_info(&dev->intf->dev,
741 "EEPROM ID = %4ph, EEPROM hash = 0x%08lx\n",
742 data, dev->hash);
743 dev_info(&dev->intf->dev,
744 "EEPROM info:\n");
745 dev_info(&dev->intf->dev,
746 "\tmicrocode start address = 0x%04x, boot configuration = 0x%02x\n",
747 mc_start, data[2]);
748 /*
749 * boot configuration (address 0x0002):
750 * [0] microcode download speed: 1 = 400 kHz; 0 = 100 kHz
751 * [1] always selects 12 kb RAM
752 * [2] USB device speed: 1 = force Full Speed; 0 = auto detect
753 * [4] 1 = force fast mode and no suspend for device testing
754 * [5:7] USB PHY tuning registers; determined by device
755 * characterization
756 */
757
758 /*
759 * Read hardware config dataset offset from address
760 * (microcode start + 46)
761 */
762 err = em28xx_i2c_read_block(dev, bus, mc_start + 46, 1, 2,
763 data);
764 if (err != 2) {
765 dev_err(&dev->intf->dev,
766 "failed to read hardware configuration data from eeprom (err=%d)\n",
767 err);
768 goto error;
769 }
770
771 /* Calculate hardware config dataset start address */
772 hwconf_offset = mc_start + data[0] + (data[1] << 8);
773
774 /* Read hardware config dataset */
775 /*
776 * NOTE: the microcode copy can be multiple pages long, but
777 * we assume the hardware config dataset is the same as in
778 * the old eeprom and not longer than 256 bytes.
779 * tveeprom is currently also limited to 256 bytes.
780 */
781 err = em28xx_i2c_read_block(dev, bus, hwconf_offset, 1, len,
782 data);
783 if (err != len) {
784 dev_err(&dev->intf->dev,
785 "failed to read hardware configuration data from eeprom (err=%d)\n",
786 err);
787 goto error;
788 }
789
790 /* Verify hardware config dataset */
791 /* NOTE: not all devices provide this type of dataset */
792 if (data[0] != 0x1a || data[1] != 0xeb ||
793 data[2] != 0x67 || data[3] != 0x95) {
794 dev_info(&dev->intf->dev,
795 "\tno hardware configuration dataset found in eeprom\n");
796 kfree(data);
797 return 0;
798 }
799
800 /*
801 * TODO: decrypt eeprom data for camera bridges
802 * (em25xx, em276x+)
803 */
804
805 } else if (!dev->eeprom_addrwidth_16bit &&
806 data[0] == 0x1a && data[1] == 0xeb &&
807 data[2] == 0x67 && data[3] == 0x95) {
808 dev->hash = em28xx_hash_mem(data, len, 32);
809 dev_info(&dev->intf->dev,
810 "EEPROM ID = %4ph, EEPROM hash = 0x%08lx\n",
811 data, dev->hash);
812 dev_info(&dev->intf->dev,
813 "EEPROM info:\n");
814 } else {
815 dev_info(&dev->intf->dev,
816 "unknown eeprom format or eeprom corrupted !\n");
817 err = -ENODEV;
818 goto error;
819 }
820
821 *eedata = data;
822 *eedata_len = len;
823 dev_config = (void *)*eedata;
824
825 switch (le16_to_cpu(dev_config->chip_conf) >> 4 & 0x3) {
826 case 0:
827 dev_info(&dev->intf->dev, "\tNo audio on board.\n");
828 break;
829 case 1:
830 dev_info(&dev->intf->dev, "\tAC97 audio (5 sample rates)\n");
831 break;
832 case 2:
833 if (dev->chip_id < CHIP_ID_EM2860)
834 dev_info(&dev->intf->dev,
835 "\tI2S audio, sample rate=32k\n");
836 else
837 dev_info(&dev->intf->dev,
838 "\tI2S audio, 3 sample rates\n");
839 break;
840 case 3:
841 if (dev->chip_id < CHIP_ID_EM2860)
842 dev_info(&dev->intf->dev,
843 "\tI2S audio, 3 sample rates\n");
844 else
845 dev_info(&dev->intf->dev,
846 "\tI2S audio, 5 sample rates\n");
847 break;
848 }
849
850 if (le16_to_cpu(dev_config->chip_conf) & 1 << 3)
851 dev_info(&dev->intf->dev, "\tUSB Remote wakeup capable\n");
852
853 if (le16_to_cpu(dev_config->chip_conf) & 1 << 2)
854 dev_info(&dev->intf->dev, "\tUSB Self power capable\n");
855
856 switch (le16_to_cpu(dev_config->chip_conf) & 0x3) {
857 case 0:
858 dev_info(&dev->intf->dev, "\t500mA max power\n");
859 break;
860 case 1:
861 dev_info(&dev->intf->dev, "\t400mA max power\n");
862 break;
863 case 2:
864 dev_info(&dev->intf->dev, "\t300mA max power\n");
865 break;
866 case 3:
867 dev_info(&dev->intf->dev, "\t200mA max power\n");
868 break;
869 }
870 dev_info(&dev->intf->dev,
871 "\tTable at offset 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
872 dev_config->string_idx_table,
873 le16_to_cpu(dev_config->string1),
874 le16_to_cpu(dev_config->string2),
875 le16_to_cpu(dev_config->string3));
876
877 return 0;
878
879 error:
880 kfree(data);
881 return err;
882 }
883
884 /* ----------------------------------------------------------- */
885
886 /*
887 * functionality()
888 */
functionality(struct i2c_adapter * i2c_adap)889 static u32 functionality(struct i2c_adapter *i2c_adap)
890 {
891 struct em28xx_i2c_bus *i2c_bus = i2c_adap->algo_data;
892
893 if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM28XX ||
894 i2c_bus->algo_type == EM28XX_I2C_ALGO_EM25XX_BUS_B) {
895 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
896 } else if (i2c_bus->algo_type == EM28XX_I2C_ALGO_EM2800) {
897 return (I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL) &
898 ~I2C_FUNC_SMBUS_WRITE_BLOCK_DATA;
899 }
900
901 WARN(1, "Unknown i2c bus algorithm.\n");
902 return 0;
903 }
904
905 static const struct i2c_algorithm em28xx_algo = {
906 .master_xfer = em28xx_i2c_xfer,
907 .functionality = functionality,
908 };
909
910 static const struct i2c_adapter em28xx_adap_template = {
911 .owner = THIS_MODULE,
912 .name = "em28xx",
913 .algo = &em28xx_algo,
914 };
915
916 static const struct i2c_client em28xx_client_template = {
917 .name = "em28xx internal",
918 };
919
920 /* ----------------------------------------------------------- */
921
922 /*
923 * i2c_devs
924 * incomplete list of known devices
925 */
926 static char *i2c_devs[128] = {
927 [0x1c >> 1] = "lgdt330x",
928 [0x3e >> 1] = "remote IR sensor",
929 [0x4a >> 1] = "saa7113h",
930 [0x52 >> 1] = "drxk",
931 [0x60 >> 1] = "remote IR sensor",
932 [0x8e >> 1] = "remote IR sensor",
933 [0x86 >> 1] = "tda9887",
934 [0x80 >> 1] = "msp34xx",
935 [0x88 >> 1] = "msp34xx",
936 [0xa0 >> 1] = "eeprom",
937 [0xb0 >> 1] = "tda9874",
938 [0xb8 >> 1] = "tvp5150a",
939 [0xba >> 1] = "webcam sensor or tvp5150a",
940 [0xc0 >> 1] = "tuner (analog)",
941 [0xc2 >> 1] = "tuner (analog)",
942 [0xc4 >> 1] = "tuner (analog)",
943 [0xc6 >> 1] = "tuner (analog)",
944 };
945
946 /*
947 * do_i2c_scan()
948 * check i2c address range for devices
949 */
em28xx_do_i2c_scan(struct em28xx * dev,unsigned int bus)950 void em28xx_do_i2c_scan(struct em28xx *dev, unsigned int bus)
951 {
952 u8 i2c_devicelist[128];
953 unsigned char buf;
954 int i, rc;
955
956 memset(i2c_devicelist, 0, sizeof(i2c_devicelist));
957
958 for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
959 dev->i2c_client[bus].addr = i;
960 rc = i2c_master_recv(&dev->i2c_client[bus], &buf, 0);
961 if (rc < 0)
962 continue;
963 i2c_devicelist[i] = i;
964 dev_info(&dev->intf->dev,
965 "found i2c device @ 0x%x on bus %d [%s]\n",
966 i << 1, bus, i2c_devs[i] ? i2c_devs[i] : "???");
967 }
968
969 if (bus == dev->def_i2c_bus)
970 dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
971 sizeof(i2c_devicelist), 32);
972 }
973
974 /*
975 * em28xx_i2c_register()
976 * register i2c bus
977 */
em28xx_i2c_register(struct em28xx * dev,unsigned int bus,enum em28xx_i2c_algo_type algo_type)978 int em28xx_i2c_register(struct em28xx *dev, unsigned int bus,
979 enum em28xx_i2c_algo_type algo_type)
980 {
981 int retval;
982
983 if (WARN_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg ||
984 !dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req))
985 return -ENODEV;
986
987 if (bus >= NUM_I2C_BUSES)
988 return -ENODEV;
989
990 dev->i2c_adap[bus] = em28xx_adap_template;
991 dev->i2c_adap[bus].dev.parent = &dev->intf->dev;
992 strscpy(dev->i2c_adap[bus].name, dev_name(&dev->intf->dev),
993 sizeof(dev->i2c_adap[bus].name));
994
995 dev->i2c_bus[bus].bus = bus;
996 dev->i2c_bus[bus].algo_type = algo_type;
997 dev->i2c_bus[bus].dev = dev;
998 dev->i2c_adap[bus].algo_data = &dev->i2c_bus[bus];
999
1000 retval = i2c_add_adapter(&dev->i2c_adap[bus]);
1001 if (retval < 0) {
1002 dev_err(&dev->intf->dev,
1003 "%s: i2c_add_adapter failed! retval [%d]\n",
1004 __func__, retval);
1005 return retval;
1006 }
1007
1008 dev->i2c_client[bus] = em28xx_client_template;
1009 dev->i2c_client[bus].adapter = &dev->i2c_adap[bus];
1010
1011 /* Up to now, all eeproms are at bus 0 */
1012 if (!bus) {
1013 retval = em28xx_i2c_eeprom(dev, bus,
1014 &dev->eedata, &dev->eedata_len);
1015 if (retval < 0 && retval != -ENODEV) {
1016 dev_err(&dev->intf->dev,
1017 "%s: em28xx_i2_eeprom failed! retval [%d]\n",
1018 __func__, retval);
1019 }
1020 }
1021
1022 if (i2c_scan)
1023 em28xx_do_i2c_scan(dev, bus);
1024
1025 return 0;
1026 }
1027
1028 /*
1029 * em28xx_i2c_unregister()
1030 * unregister i2c_bus
1031 */
em28xx_i2c_unregister(struct em28xx * dev,unsigned int bus)1032 int em28xx_i2c_unregister(struct em28xx *dev, unsigned int bus)
1033 {
1034 if (bus >= NUM_I2C_BUSES)
1035 return -ENODEV;
1036
1037 i2c_del_adapter(&dev->i2c_adap[bus]);
1038 return 0;
1039 }
1040