Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
saa7146_i2c.c
Go to the documentation of this file.
1 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
2 
3 #include <media/saa7146_vv.h>
4 
5 static u32 saa7146_i2c_func(struct i2c_adapter *adapter)
6 {
7  /* DEB_I2C("'%s'\n", adapter->name); */
8 
9  return I2C_FUNC_I2C
13 }
14 
15 /* this function returns the status-register of our i2c-device */
16 static inline u32 saa7146_i2c_status(struct saa7146_dev *dev)
17 {
18  u32 iicsta = saa7146_read(dev, I2C_STATUS);
19  /* DEB_I2C("status: 0x%08x\n", iicsta); */
20  return iicsta;
21 }
22 
23 /* this function runs through the i2c-messages and prepares the data to be
24  sent through the saa7146. have a look at the specifications p. 122 ff
25  to understand this. it returns the number of u32s to send, or -1
26  in case of an error. */
27 static int saa7146_i2c_msg_prepare(const struct i2c_msg *m, int num, __le32 *op)
28 {
29  int h1, h2;
30  int i, j, addr;
31  int mem = 0, op_count = 0;
32 
33  /* first determine size of needed memory */
34  for(i = 0; i < num; i++) {
35  mem += m[i].len + 1;
36  }
37 
38  /* worst case: we need one u32 for three bytes to be send
39  plus one extra byte to address the device */
40  mem = 1 + ((mem-1) / 3);
41 
42  /* we assume that op points to a memory of at least
43  * SAA7146_I2C_MEM bytes size. if we exceed this limit...
44  */
45  if ((4 * mem) > SAA7146_I2C_MEM) {
46  /* DEB_I2C("cannot prepare i2c-message\n"); */
47  return -ENOMEM;
48  }
49 
50  /* be careful: clear out the i2c-mem first */
51  memset(op,0,sizeof(__le32)*mem);
52 
53  /* loop through all messages */
54  for(i = 0; i < num; i++) {
55 
56  /* insert the address of the i2c-slave.
57  note: we get 7 bit i2c-addresses,
58  so we have to perform a translation */
59  addr = (m[i].addr*2) + ( (0 != (m[i].flags & I2C_M_RD)) ? 1 : 0);
60  h1 = op_count/3; h2 = op_count%3;
61  op[h1] |= cpu_to_le32( (u8)addr << ((3-h2)*8));
62  op[h1] |= cpu_to_le32(SAA7146_I2C_START << ((3-h2)*2));
63  op_count++;
64 
65  /* loop through all bytes of message i */
66  for(j = 0; j < m[i].len; j++) {
67  /* insert the data bytes */
68  h1 = op_count/3; h2 = op_count%3;
69  op[h1] |= cpu_to_le32( (u32)((u8)m[i].buf[j]) << ((3-h2)*8));
70  op[h1] |= cpu_to_le32( SAA7146_I2C_CONT << ((3-h2)*2));
71  op_count++;
72  }
73 
74  }
75 
76  /* have a look at the last byte inserted:
77  if it was: ...CONT change it to ...STOP */
78  h1 = (op_count-1)/3; h2 = (op_count-1)%3;
79  if ( SAA7146_I2C_CONT == (0x3 & (le32_to_cpu(op[h1]) >> ((3-h2)*2))) ) {
80  op[h1] &= ~cpu_to_le32(0x2 << ((3-h2)*2));
81  op[h1] |= cpu_to_le32(SAA7146_I2C_STOP << ((3-h2)*2));
82  }
83 
84  /* return the number of u32s to send */
85  return mem;
86 }
87 
88 /* this functions loops through all i2c-messages. normally, it should determine
89  which bytes were read through the adapter and write them back to the corresponding
90  i2c-message. but instead, we simply write back all bytes.
91  fixme: this could be improved. */
92 static int saa7146_i2c_msg_cleanup(const struct i2c_msg *m, int num, __le32 *op)
93 {
94  int i, j;
95  int op_count = 0;
96 
97  /* loop through all messages */
98  for(i = 0; i < num; i++) {
99 
100  op_count++;
101 
102  /* loop through all bytes of message i */
103  for(j = 0; j < m[i].len; j++) {
104  /* write back all bytes that could have been read */
105  m[i].buf[j] = (le32_to_cpu(op[op_count/3]) >> ((3-(op_count%3))*8));
106  op_count++;
107  }
108  }
109 
110  return 0;
111 }
112 
113 /* this functions resets the i2c-device and returns 0 if everything was fine, otherwise -1 */
114 static int saa7146_i2c_reset(struct saa7146_dev *dev)
115 {
116  /* get current status */
117  u32 status = saa7146_i2c_status(dev);
118 
119  /* clear registers for sure */
121  saa7146_write(dev, I2C_TRANSFER, 0);
122 
123  /* check if any operation is still in progress */
124  if ( 0 != ( status & SAA7146_I2C_BUSY) ) {
125 
126  /* yes, kill ongoing operation */
127  DEB_I2C("busy_state detected\n");
128 
129  /* set "ABORT-OPERATION"-bit (bit 7)*/
131  saa7146_write(dev, MC2, (MASK_00 | MASK_16));
133 
134  /* clear all error-bits pending; this is needed because p.123, note 1 */
136  saa7146_write(dev, MC2, (MASK_00 | MASK_16));
138  }
139 
140  /* check if any error is (still) present. (this can be necessary because p.123, note 1) */
141  status = saa7146_i2c_status(dev);
142 
143  if ( dev->i2c_bitrate != status ) {
144 
145  DEB_I2C("error_state detected. status:0x%08x\n", status);
146 
147  /* Repeat the abort operation. This seems to be necessary
148  after serious protocol errors caused by e.g. the SAA7740 */
150  saa7146_write(dev, MC2, (MASK_00 | MASK_16));
152 
153  /* clear all error-bits pending */
155  saa7146_write(dev, MC2, (MASK_00 | MASK_16));
157 
158  /* the data sheet says it might be necessary to clear the status
159  twice after an abort */
161  saa7146_write(dev, MC2, (MASK_00 | MASK_16));
163  }
164 
165  /* if any error is still present, a fatal error has occurred ... */
166  status = saa7146_i2c_status(dev);
167  if ( dev->i2c_bitrate != status ) {
168  DEB_I2C("fatal error. status:0x%08x\n", status);
169  return -1;
170  }
171 
172  return 0;
173 }
174 
175 /* this functions writes out the data-byte 'dword' to the i2c-device.
176  it returns 0 if ok, -1 if the transfer failed, -2 if the transfer
177  failed badly (e.g. address error) */
178 static int saa7146_i2c_writeout(struct saa7146_dev *dev, __le32 *dword, int short_delay)
179 {
180  u32 status = 0, mc2 = 0;
181  int trial = 0;
182  unsigned long timeout;
183 
184  /* write out i2c-command */
185  DEB_I2C("before: 0x%08x (status: 0x%08x), %d\n",
186  *dword, saa7146_read(dev, I2C_STATUS), dev->i2c_op);
187 
188  if( 0 != (SAA7146_USE_I2C_IRQ & dev->ext->flags)) {
189 
191  saa7146_write(dev, I2C_TRANSFER, le32_to_cpu(*dword));
192 
193  dev->i2c_op = 1;
195  SAA7146_IER_ENABLE(dev, MASK_16|MASK_17);
196  saa7146_write(dev, MC2, (MASK_00 | MASK_16));
197 
198  timeout = HZ/100 + 1; /* 10ms */
199  timeout = wait_event_interruptible_timeout(dev->i2c_wq, dev->i2c_op == 0, timeout);
200  if (timeout == -ERESTARTSYS || dev->i2c_op) {
201  SAA7146_IER_DISABLE(dev, MASK_16|MASK_17);
203  if (timeout == -ERESTARTSYS)
204  /* a signal arrived */
205  return -ERESTARTSYS;
206 
207  pr_warn("%s %s [irq]: timed out waiting for end of xfer\n",
208  dev->name, __func__);
209  return -EIO;
210  }
211  status = saa7146_read(dev, I2C_STATUS);
212  } else {
214  saa7146_write(dev, I2C_TRANSFER, le32_to_cpu(*dword));
215  saa7146_write(dev, MC2, (MASK_00 | MASK_16));
216 
217  /* do not poll for i2c-status before upload is complete */
218  timeout = jiffies + HZ/100 + 1; /* 10ms */
219  while(1) {
220  mc2 = (saa7146_read(dev, MC2) & 0x1);
221  if( 0 != mc2 ) {
222  break;
223  }
224  if (time_after(jiffies,timeout)) {
225  pr_warn("%s %s: timed out waiting for MC2\n",
226  dev->name, __func__);
227  return -EIO;
228  }
229  }
230  /* wait until we get a transfer done or error */
231  timeout = jiffies + HZ/100 + 1; /* 10ms */
232  /* first read usually delivers bogus results... */
233  saa7146_i2c_status(dev);
234  while(1) {
235  status = saa7146_i2c_status(dev);
236  if ((status & 0x3) != 1)
237  break;
238  if (time_after(jiffies,timeout)) {
239  /* this is normal when probing the bus
240  * (no answer from nonexisistant device...)
241  */
242  pr_warn("%s %s [poll]: timed out waiting for end of xfer\n",
243  dev->name, __func__);
244  return -EIO;
245  }
246  if (++trial < 50 && short_delay)
247  udelay(10);
248  else
249  msleep(1);
250  }
251  }
252 
253  /* give a detailed status report */
254  if ( 0 != (status & (SAA7146_I2C_SPERR | SAA7146_I2C_APERR |
257  SAA7146_I2C_BUSY)) ) {
258 
259  if ( 0 == (status & SAA7146_I2C_ERR) ||
260  0 == (status & SAA7146_I2C_BUSY) ) {
261  /* it may take some time until ERR goes high - ignore */
262  DEB_I2C("unexpected i2c status %04x\n", status);
263  }
264  if( 0 != (status & SAA7146_I2C_SPERR) ) {
265  DEB_I2C("error due to invalid start/stop condition\n");
266  }
267  if( 0 != (status & SAA7146_I2C_DTERR) ) {
268  DEB_I2C("error in data transmission\n");
269  }
270  if( 0 != (status & SAA7146_I2C_DRERR) ) {
271  DEB_I2C("error when receiving data\n");
272  }
273  if( 0 != (status & SAA7146_I2C_AL) ) {
274  DEB_I2C("error because arbitration lost\n");
275  }
276 
277  /* we handle address-errors here */
278  if( 0 != (status & SAA7146_I2C_APERR) ) {
279  DEB_I2C("error in address phase\n");
280  return -EREMOTEIO;
281  }
282 
283  return -EIO;
284  }
285 
286  /* read back data, just in case we were reading ... */
287  *dword = cpu_to_le32(saa7146_read(dev, I2C_TRANSFER));
288 
289  DEB_I2C("after: 0x%08x\n", *dword);
290  return 0;
291 }
292 
293 static int saa7146_i2c_transfer(struct saa7146_dev *dev, const struct i2c_msg *msgs, int num, int retries)
294 {
295  int i = 0, count = 0;
296  __le32 *buffer = dev->d_i2c.cpu_addr;
297  int err = 0;
298  int short_delay = 0;
299 
301  return -ERESTARTSYS;
302 
303  for(i=0;i<num;i++) {
304  DEB_I2C("msg:%d/%d\n", i+1, num);
305  }
306 
307  /* prepare the message(s), get number of u32s to transfer */
308  count = saa7146_i2c_msg_prepare(msgs, num, buffer);
309  if ( 0 > count ) {
310  err = -1;
311  goto out;
312  }
313 
314  if ( count > 3 || 0 != (SAA7146_I2C_SHORT_DELAY & dev->ext->flags) )
315  short_delay = 1;
316 
317  do {
318  /* reset the i2c-device if necessary */
319  err = saa7146_i2c_reset(dev);
320  if ( 0 > err ) {
321  DEB_I2C("could not reset i2c-device\n");
322  goto out;
323  }
324 
325  /* write out the u32s one after another */
326  for(i = 0; i < count; i++) {
327  err = saa7146_i2c_writeout(dev, &buffer[i], short_delay);
328  if ( 0 != err) {
329  /* this one is unsatisfying: some i2c slaves on some
330  dvb cards don't acknowledge correctly, so the saa7146
331  thinks that an address error occurred. in that case, the
332  transaction should be retrying, even if an address error
333  occurred. analog saa7146 based cards extensively rely on
334  i2c address probing, however, and address errors indicate that a
335  device is really *not* there. retrying in that case
336  increases the time the device needs to probe greatly, so
337  it should be avoided. So we bail out in irq mode after an
338  address error and trust the saa7146 address error detection. */
339  if (-EREMOTEIO == err && 0 != (SAA7146_USE_I2C_IRQ & dev->ext->flags))
340  goto out;
341  DEB_I2C("error while sending message(s). starting again\n");
342  break;
343  }
344  }
345  if( 0 == err ) {
346  err = num;
347  break;
348  }
349 
350  /* delay a bit before retrying */
351  msleep(10);
352 
353  } while (err != num && retries--);
354 
355  /* quit if any error occurred */
356  if (err != num)
357  goto out;
358 
359  /* if any things had to be read, get the results */
360  if ( 0 != saa7146_i2c_msg_cleanup(msgs, num, buffer)) {
361  DEB_I2C("could not cleanup i2c-message\n");
362  err = -1;
363  goto out;
364  }
365 
366  /* return the number of delivered messages */
367  DEB_I2C("transmission successful. (msg:%d)\n", err);
368 out:
369  /* another bug in revision 0: the i2c-registers get uploaded randomly by other
370  uploads, so we better clear them out before continuing */
371  if( 0 == dev->revision ) {
372  __le32 zero = 0;
373  saa7146_i2c_reset(dev);
374  if( 0 != saa7146_i2c_writeout(dev, &zero, short_delay)) {
375  pr_info("revision 0 error. this should never happen\n");
376  }
377  }
378 
379  mutex_unlock(&dev->i2c_lock);
380  return err;
381 }
382 
383 /* utility functions */
384 static int saa7146_i2c_xfer(struct i2c_adapter* adapter, struct i2c_msg *msg, int num)
385 {
386  struct v4l2_device *v4l2_dev = i2c_get_adapdata(adapter);
387  struct saa7146_dev *dev = to_saa7146_dev(v4l2_dev);
388 
389  /* use helper function to transfer data */
390  return saa7146_i2c_transfer(dev, msg, num, adapter->retries);
391 }
392 
393 
394 /*****************************************************************************/
395 /* i2c-adapter helper functions */
396 
397 /* exported algorithm data */
398 static struct i2c_algorithm saa7146_algo = {
399  .master_xfer = saa7146_i2c_xfer,
400  .functionality = saa7146_i2c_func,
401 };
402 
404 {
405  DEB_EE("bitrate: 0x%08x\n", bitrate);
406 
407  /* enable i2c-port pins */
408  saa7146_write(dev, MC1, (MASK_08 | MASK_24));
409 
410  dev->i2c_bitrate = bitrate;
411  saa7146_i2c_reset(dev);
412 
413  if (i2c_adapter) {
414  i2c_set_adapdata(i2c_adapter, &dev->v4l2_dev);
415  i2c_adapter->dev.parent = &dev->pci->dev;
416  i2c_adapter->algo = &saa7146_algo;
417  i2c_adapter->algo_data = NULL;
418  i2c_adapter->timeout = SAA7146_I2C_TIMEOUT;
419  i2c_adapter->retries = SAA7146_I2C_RETRIES;
420  }
421 
422  return 0;
423 }