Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
em28xx-i2c.c
Go to the documentation of this file.
1 /*
2  em28xx-i2c.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
3 
4  Copyright (C) 2005 Ludovico Cavedon <[email protected]>
5  Markus Rechberger <[email protected]>
6  Mauro Carvalho Chehab <[email protected]>
7  Sascha Sommer <[email protected]>
8 
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.
13 
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.
18 
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.
22  */
23 
24 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/usb.h>
27 #include <linux/i2c.h>
28 
29 #include "em28xx.h"
30 #include "tuner-xc2028.h"
31 #include <media/v4l2-common.h>
32 #include <media/tuner.h>
33 
34 /* ----------------------------------------------------------- */
35 
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");
39 
40 static unsigned int i2c_debug;
41 module_param(i2c_debug, int, 0644);
42 MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
43 
44 #define dprintk2(lvl, fmt, args...) \
45 do { \
46  if (i2c_debug >= lvl) { \
47  printk(KERN_DEBUG "%s at %s: " fmt, \
48  dev->name, __func__ , ##args); \
49  } \
50 } while (0)
51 
52 /*
53  * em2800_i2c_send_max4()
54  * send up to 4 bytes to the i2c device
55  */
56 static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
57  char *buf, int len)
58 {
59  int ret;
60  int write_timeout;
61  unsigned char b2[6];
62  BUG_ON(len < 1 || len > 4);
63  b2[5] = 0x80 + len - 1;
64  b2[4] = addr;
65  b2[3] = buf[0];
66  if (len > 1)
67  b2[2] = buf[1];
68  if (len > 2)
69  b2[1] = buf[2];
70  if (len > 3)
71  b2[0] = buf[3];
72 
73  ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
74  if (ret != 2 + len) {
75  em28xx_warn("writing to i2c device failed (error=%i)\n", ret);
76  return -EIO;
77  }
78  for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
79  write_timeout -= 5) {
80  ret = dev->em28xx_read_reg(dev, 0x05);
81  if (ret == 0x80 + len - 1)
82  return len;
83  msleep(5);
84  }
85  em28xx_warn("i2c write timed out\n");
86  return -EIO;
87 }
88 
89 /*
90  * em2800_i2c_send_bytes()
91  */
92 static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf,
93  short len)
94 {
95  char *bufPtr = buf;
96  int ret;
97  int wrcount = 0;
98  int count;
99  int maxLen = 4;
100  struct em28xx *dev = (struct em28xx *)data;
101  while (len > 0) {
102  count = (len > maxLen) ? maxLen : len;
103  ret = em2800_i2c_send_max4(dev, addr, bufPtr, count);
104  if (ret > 0) {
105  len -= count;
106  bufPtr += count;
107  wrcount += count;
108  } else
109  return (ret < 0) ? ret : -EFAULT;
110  }
111  return wrcount;
112 }
113 
114 /*
115  * em2800_i2c_check_for_device()
116  * check if there is a i2c_device at the supplied address
117  */
118 static int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
119 {
120  char msg;
121  int ret;
122  int write_timeout;
123  msg = addr;
124  ret = dev->em28xx_write_regs(dev, 0x04, &msg, 1);
125  if (ret < 0) {
126  em28xx_warn("setting i2c device address failed (error=%i)\n",
127  ret);
128  return ret;
129  }
130  msg = 0x84;
131  ret = dev->em28xx_write_regs(dev, 0x05, &msg, 1);
132  if (ret < 0) {
133  em28xx_warn("preparing i2c read failed (error=%i)\n", ret);
134  return ret;
135  }
136  for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
137  write_timeout -= 5) {
138  unsigned reg = dev->em28xx_read_reg(dev, 0x5);
139 
140  if (reg == 0x94)
141  return -ENODEV;
142  else if (reg == 0x84)
143  return 0;
144  msleep(5);
145  }
146  return -ENODEV;
147 }
148 
149 /*
150  * em2800_i2c_recv_bytes()
151  * read from the i2c device
152  */
153 static int em2800_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
154  char *buf, int len)
155 {
156  int ret;
157  /* check for the device and set i2c read address */
158  ret = em2800_i2c_check_for_device(dev, addr);
159  if (ret) {
160  em28xx_warn
161  ("preparing read at i2c address 0x%x failed (error=%i)\n",
162  addr, ret);
163  return ret;
164  }
165  ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x3, buf, len);
166  if (ret < 0) {
167  em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
168  addr, ret);
169  return ret;
170  }
171  return ret;
172 }
173 
174 /*
175  * em28xx_i2c_send_bytes()
176  */
177 static int em28xx_i2c_send_bytes(void *data, unsigned char addr, char *buf,
178  short len, int stop)
179 {
180  int wrcount = 0;
181  struct em28xx *dev = (struct em28xx *)data;
182  int write_timeout, ret;
183 
184  wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
185 
186  /* Seems to be required after a write */
187  for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
188  write_timeout -= 5) {
189  ret = dev->em28xx_read_reg(dev, 0x05);
190  if (!ret)
191  break;
192  msleep(5);
193  }
194 
195  return wrcount;
196 }
197 
198 /*
199  * em28xx_i2c_recv_bytes()
200  * read a byte from the i2c device
201  */
202 static int em28xx_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
203  char *buf, int len)
204 {
205  int ret;
206  ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
207  if (ret < 0) {
208  em28xx_warn("reading i2c device failed (error=%i)\n", ret);
209  return ret;
210  }
211  if (dev->em28xx_read_reg(dev, 0x5) != 0)
212  return -ENODEV;
213  return ret;
214 }
215 
216 /*
217  * em28xx_i2c_check_for_device()
218  * check if there is a i2c_device at the supplied address
219  */
220 static int em28xx_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
221 {
222  int ret;
223 
224  ret = dev->em28xx_read_reg_req(dev, 2, addr);
225  if (ret < 0) {
226  em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
227  return ret;
228  }
229  if (dev->em28xx_read_reg(dev, 0x5) != 0)
230  return -ENODEV;
231  return 0;
232 }
233 
234 /*
235  * em28xx_i2c_xfer()
236  * the main i2c transfer function
237  */
238 static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
239  struct i2c_msg msgs[], int num)
240 {
241  struct em28xx *dev = i2c_adap->algo_data;
242  int addr, rc, i, byte;
243 
244  if (num <= 0)
245  return 0;
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 */
252  if (dev->board.is_em2800)
253  rc = em2800_i2c_check_for_device(dev, addr);
254  else
255  rc = em28xx_i2c_check_for_device(dev, addr);
256  if (rc < 0) {
257  dprintk2(2, " no device\n");
258  return rc;
259  }
260 
261  } else if (msgs[i].flags & I2C_M_RD) {
262  /* read bytes */
263  if (dev->board.is_em2800)
264  rc = em2800_i2c_recv_bytes(dev, addr,
265  msgs[i].buf,
266  msgs[i].len);
267  else
268  rc = em28xx_i2c_recv_bytes(dev, addr,
269  msgs[i].buf,
270  msgs[i].len);
271  if (i2c_debug >= 2) {
272  for (byte = 0; byte < msgs[i].len; byte++)
273  printk(" %02x", msgs[i].buf[byte]);
274  }
275  } else {
276  /* write bytes */
277  if (i2c_debug >= 2) {
278  for (byte = 0; byte < msgs[i].len; byte++)
279  printk(" %02x", msgs[i].buf[byte]);
280  }
281  if (dev->board.is_em2800)
282  rc = em2800_i2c_send_bytes(dev, addr,
283  msgs[i].buf,
284  msgs[i].len);
285  else
286  rc = em28xx_i2c_send_bytes(dev, addr,
287  msgs[i].buf,
288  msgs[i].len,
289  i == num - 1);
290  }
291  if (rc < 0)
292  goto err;
293  if (i2c_debug >= 2)
294  printk("\n");
295  }
296 
297  return num;
298 err:
299  dprintk2(2, " ERROR: %i\n", rc);
300  return rc;
301 }
302 
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
305  * or i386.
306  */
307 static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
308 {
309  unsigned long hash = 0;
310  unsigned long l = 0;
311  int len = 0;
312  unsigned char c;
313  do {
314  if (len == length) {
315  c = (char)len;
316  len = -1;
317  } else
318  c = *buf++;
319  l = (l << 8) | c;
320  len++;
321  if ((len & (32 / 8 - 1)) == 0)
322  hash = ((hash^l) * 0x9e370001UL);
323  } while (len);
324 
325  return (hash >> (32 - bits)) & 0xffffffffUL;
326 }
327 
328 static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
329 {
330  unsigned char buf, *p = eedata;
331  struct em28xx_eeprom *em_eeprom = (void *)eedata;
332  int i, err, size = len, block;
333 
334  if (dev->chip_id == CHIP_ID_EM2874 ||
335  dev->chip_id == CHIP_ID_EM28174 ||
336  dev->chip_id == CHIP_ID_EM2884) {
337  /* Empia switched to a 16-bit addressable eeprom in newer
338  devices. While we could certainly write a routine to read
339  the eeprom, there is nothing of use in there that cannot be
340  accessed through registers, and there is the risk that we
341  could corrupt the eeprom (since a 16-bit read call is
342  interpreted as a write call by 8-bit eeproms).
343  */
344  return 0;
345  }
346 
347  dev->i2c_client.addr = 0xa0 >> 1;
348 
349  /* Check if board has eeprom */
350  err = i2c_master_recv(&dev->i2c_client, &buf, 0);
351  if (err < 0) {
352  em28xx_errdev("board has no eeprom\n");
353  memset(eedata, 0, len);
354  return -ENODEV;
355  }
356 
357  buf = 0;
358 
359  err = i2c_master_send(&dev->i2c_client, &buf, 1);
360  if (err != 1) {
361  printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
362  dev->name, err);
363  return err;
364  }
365  while (size > 0) {
366  if (size > 16)
367  block = 16;
368  else
369  block = size;
370 
371  if (block !=
372  (err = i2c_master_recv(&dev->i2c_client, p, block))) {
373  printk(KERN_WARNING
374  "%s: i2c eeprom read error (err=%d)\n",
375  dev->name, err);
376  return err;
377  }
378  size -= block;
379  p += block;
380  }
381  for (i = 0; i < len; i++) {
382  if (0 == (i % 16))
383  printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
384  printk(" %02x", eedata[i]);
385  if (15 == (i % 16))
386  printk("\n");
387  }
388 
389  if (em_eeprom->id == 0x9567eb1a)
390  dev->hash = em28xx_hash_mem(eedata, len, 32);
391 
392  printk(KERN_INFO "%s: EEPROM ID= 0x%08x, EEPROM hash = 0x%08lx\n",
393  dev->name, em_eeprom->id, dev->hash);
394 
395  printk(KERN_INFO "%s: EEPROM info:\n", dev->name);
396 
397  switch (em_eeprom->chip_conf >> 4 & 0x3) {
398  case 0:
399  printk(KERN_INFO "%s:\tNo audio on board.\n", dev->name);
400  break;
401  case 1:
402  printk(KERN_INFO "%s:\tAC97 audio (5 sample rates)\n",
403  dev->name);
404  break;
405  case 2:
406  printk(KERN_INFO "%s:\tI2S audio, sample rate=32k\n",
407  dev->name);
408  break;
409  case 3:
410  printk(KERN_INFO "%s:\tI2S audio, 3 sample rates\n",
411  dev->name);
412  break;
413  }
414 
415  if (em_eeprom->chip_conf & 1 << 3)
416  printk(KERN_INFO "%s:\tUSB Remote wakeup capable\n", dev->name);
417 
418  if (em_eeprom->chip_conf & 1 << 2)
419  printk(KERN_INFO "%s:\tUSB Self power capable\n", dev->name);
420 
421  switch (em_eeprom->chip_conf & 0x3) {
422  case 0:
423  printk(KERN_INFO "%s:\t500mA max power\n", dev->name);
424  break;
425  case 1:
426  printk(KERN_INFO "%s:\t400mA max power\n", dev->name);
427  break;
428  case 2:
429  printk(KERN_INFO "%s:\t300mA max power\n", dev->name);
430  break;
431  case 3:
432  printk(KERN_INFO "%s:\t200mA max power\n", dev->name);
433  break;
434  }
435  printk(KERN_INFO "%s:\tTable at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
436  dev->name,
437  em_eeprom->string_idx_table,
438  em_eeprom->string1,
439  em_eeprom->string2,
440  em_eeprom->string3);
441 
442  return 0;
443 }
444 
445 /* ----------------------------------------------------------- */
446 
447 /*
448  * functionality()
449  */
450 static u32 functionality(struct i2c_adapter *adap)
451 {
452  return I2C_FUNC_SMBUS_EMUL;
453 }
454 
455 static struct i2c_algorithm em28xx_algo = {
456  .master_xfer = em28xx_i2c_xfer,
457  .functionality = functionality,
458 };
459 
460 static struct i2c_adapter em28xx_adap_template = {
461  .owner = THIS_MODULE,
462  .name = "em28xx",
463  .algo = &em28xx_algo,
464 };
465 
466 static struct i2c_client em28xx_client_template = {
467  .name = "em28xx internal",
468 };
469 
470 /* ----------------------------------------------------------- */
471 
472 /*
473  * i2c_devs
474  * incomplete list of known devices
475  */
476 static char *i2c_devs[128] = {
477  [0x4a >> 1] = "saa7113h",
478  [0x52 >> 1] = "drxk",
479  [0x60 >> 1] = "remote IR sensor",
480  [0x8e >> 1] = "remote IR sensor",
481  [0x86 >> 1] = "tda9887",
482  [0x80 >> 1] = "msp34xx",
483  [0x88 >> 1] = "msp34xx",
484  [0xa0 >> 1] = "eeprom",
485  [0xb0 >> 1] = "tda9874",
486  [0xb8 >> 1] = "tvp5150a",
487  [0xba >> 1] = "webcam sensor or tvp5150a",
488  [0xc0 >> 1] = "tuner (analog)",
489  [0xc2 >> 1] = "tuner (analog)",
490  [0xc4 >> 1] = "tuner (analog)",
491  [0xc6 >> 1] = "tuner (analog)",
492 };
493 
494 /*
495  * do_i2c_scan()
496  * check i2c address range for devices
497  */
498 void em28xx_do_i2c_scan(struct em28xx *dev)
499 {
500  u8 i2c_devicelist[128];
501  unsigned char buf;
502  int i, rc;
503 
504  memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
505 
506  for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
507  dev->i2c_client.addr = i;
508  rc = i2c_master_recv(&dev->i2c_client, &buf, 0);
509  if (rc < 0)
510  continue;
511  i2c_devicelist[i] = i;
512  printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n",
513  dev->name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
514  }
515 
516  dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
517  ARRAY_SIZE(i2c_devicelist), 32);
518 }
519 
520 /*
521  * em28xx_i2c_register()
522  * register i2c bus
523  */
524 int em28xx_i2c_register(struct em28xx *dev)
525 {
526  int retval;
527 
528  BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
529  BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
530  dev->i2c_adap = em28xx_adap_template;
531  dev->i2c_adap.dev.parent = &dev->udev->dev;
532  strcpy(dev->i2c_adap.name, dev->name);
533  dev->i2c_adap.algo_data = dev;
534  i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
535 
536  retval = i2c_add_adapter(&dev->i2c_adap);
537  if (retval < 0) {
538  em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
539  __func__, retval);
540  return retval;
541  }
542 
543  dev->i2c_client = em28xx_client_template;
544  dev->i2c_client.adapter = &dev->i2c_adap;
545 
546  retval = em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
547  if ((retval < 0) && (retval != -ENODEV)) {
548  em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
549  __func__, retval);
550 
551  return retval;
552  }
553 
554  if (i2c_scan)
555  em28xx_do_i2c_scan(dev);
556 
557  return 0;
558 }
559 
560 /*
561  * em28xx_i2c_unregister()
562  * unregister i2c_bus
563  */
564 int em28xx_i2c_unregister(struct em28xx *dev)
565 {
566  i2c_del_adapter(&dev->i2c_adap);
567  return 0;
568 }
Generated on Thu Jan 10 2013 13:51:37 for Linux Kernel by   doxygen 1.8.2