Subversion Repositories shark

Rev

Rev 773 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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