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