Root/drivers/media/common/saa7146_i2c.c

1#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
2
3#include <media/saa7146_vv.h>
4
5static u32 saa7146_i2c_func(struct i2c_adapter *adapter)
6{
7    /* DEB_I2C("'%s'\n", adapter->name); */
8
9    return I2C_FUNC_I2C
10        | I2C_FUNC_SMBUS_QUICK
11        | I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE
12        | I2C_FUNC_SMBUS_READ_BYTE_DATA | I2C_FUNC_SMBUS_WRITE_BYTE_DATA;
13}
14
15/* this function returns the status-register of our i2c-device */
16static 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. */
27static 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. */
92static 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 */
114static 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 */
120    saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
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)*/
130        saa7146_write(dev, I2C_STATUS, (dev->i2c_bitrate | MASK_07));
131        saa7146_write(dev, MC2, (MASK_00 | MASK_16));
132        msleep(SAA7146_I2C_DELAY);
133
134        /* clear all error-bits pending; this is needed because p.123, note 1 */
135        saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
136        saa7146_write(dev, MC2, (MASK_00 | MASK_16));
137        msleep(SAA7146_I2C_DELAY);
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 */
149        saa7146_write(dev, I2C_STATUS, (dev->i2c_bitrate | MASK_07));
150        saa7146_write(dev, MC2, (MASK_00 | MASK_16));
151        msleep(SAA7146_I2C_DELAY);
152
153        /* clear all error-bits pending */
154        saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
155        saa7146_write(dev, MC2, (MASK_00 | MASK_16));
156        msleep(SAA7146_I2C_DELAY);
157
158        /* the data sheet says it might be necessary to clear the status
159           twice after an abort */
160        saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
161        saa7146_write(dev, MC2, (MASK_00 | MASK_16));
162        msleep(SAA7146_I2C_DELAY);
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) */
178static 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
190        saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
191        saa7146_write(dev, I2C_TRANSFER, le32_to_cpu(*dword));
192
193        dev->i2c_op = 1;
194        SAA7146_ISR_CLEAR(dev, MASK_16|MASK_17);
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);
202            SAA7146_ISR_CLEAR(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 {
213        saa7146_write(dev, I2C_STATUS, dev->i2c_bitrate);
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 |
255                 SAA7146_I2C_DTERR | SAA7146_I2C_DRERR |
256                 SAA7146_I2C_AL | SAA7146_I2C_ERR |
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
293static 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
300    if (mutex_lock_interruptible(&dev->i2c_lock))
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);
368out:
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 */
384static 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 */
398static struct i2c_algorithm saa7146_algo = {
399    .master_xfer = saa7146_i2c_xfer,
400    .functionality = saa7146_i2c_func,
401};
402
403int saa7146_i2c_adapter_prepare(struct saa7146_dev *dev, struct i2c_adapter *i2c_adapter, u32 bitrate)
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}
424

Archive Download this file



interactive