Root/
1 | /* IEEE-1284 operations for parport. |
2 | * |
3 | * This file is for generic IEEE 1284 operations. The idea is that |
4 | * they are used by the low-level drivers. If they have a special way |
5 | * of doing something, they can provide their own routines (and put |
6 | * the function pointers in port->ops); if not, they can just use these |
7 | * as a fallback. |
8 | * |
9 | * Note: Make no assumptions about hardware or architecture in this file! |
10 | * |
11 | * Author: Tim Waugh <tim@cyberelk.demon.co.uk> |
12 | * Fixed AUTOFD polarity in ecp_forward_to_reverse(). Fred Barnes, 1999 |
13 | * Software emulated EPP fixes, Fred Barnes, 04/2001. |
14 | */ |
15 | |
16 | |
17 | #include <linux/module.h> |
18 | #include <linux/parport.h> |
19 | #include <linux/delay.h> |
20 | #include <linux/sched.h> |
21 | #include <asm/uaccess.h> |
22 | |
23 | #undef DEBUG /* undef me for production */ |
24 | |
25 | #ifdef CONFIG_LP_CONSOLE |
26 | #undef DEBUG /* Don't want a garbled console */ |
27 | #endif |
28 | |
29 | #ifdef DEBUG |
30 | #define DPRINTK(stuff...) printk (stuff) |
31 | #else |
32 | #define DPRINTK(stuff...) |
33 | #endif |
34 | |
35 | /*** * |
36 | * One-way data transfer functions. * |
37 | * ***/ |
38 | |
39 | /* Compatibility mode. */ |
40 | size_t parport_ieee1284_write_compat (struct parport *port, |
41 | const void *buffer, size_t len, |
42 | int flags) |
43 | { |
44 | int no_irq = 1; |
45 | ssize_t count = 0; |
46 | const unsigned char *addr = buffer; |
47 | unsigned char byte; |
48 | struct pardevice *dev = port->physport->cad; |
49 | unsigned char ctl = (PARPORT_CONTROL_SELECT |
50 | | PARPORT_CONTROL_INIT); |
51 | |
52 | if (port->irq != PARPORT_IRQ_NONE) { |
53 | parport_enable_irq (port); |
54 | no_irq = 0; |
55 | } |
56 | |
57 | port->physport->ieee1284.phase = IEEE1284_PH_FWD_DATA; |
58 | parport_write_control (port, ctl); |
59 | parport_data_forward (port); |
60 | while (count < len) { |
61 | unsigned long expire = jiffies + dev->timeout; |
62 | long wait = msecs_to_jiffies(10); |
63 | unsigned char mask = (PARPORT_STATUS_ERROR |
64 | | PARPORT_STATUS_BUSY); |
65 | unsigned char val = (PARPORT_STATUS_ERROR |
66 | | PARPORT_STATUS_BUSY); |
67 | |
68 | /* Wait until the peripheral's ready */ |
69 | do { |
70 | /* Is the peripheral ready yet? */ |
71 | if (!parport_wait_peripheral (port, mask, val)) |
72 | /* Skip the loop */ |
73 | goto ready; |
74 | |
75 | /* Is the peripheral upset? */ |
76 | if ((parport_read_status (port) & |
77 | (PARPORT_STATUS_PAPEROUT | |
78 | PARPORT_STATUS_SELECT | |
79 | PARPORT_STATUS_ERROR)) |
80 | != (PARPORT_STATUS_SELECT | |
81 | PARPORT_STATUS_ERROR)) |
82 | /* If nFault is asserted (i.e. no |
83 | * error) and PAPEROUT and SELECT are |
84 | * just red herrings, give the driver |
85 | * a chance to check it's happy with |
86 | * that before continuing. */ |
87 | goto stop; |
88 | |
89 | /* Have we run out of time? */ |
90 | if (!time_before (jiffies, expire)) |
91 | break; |
92 | |
93 | /* Yield the port for a while. If this is the |
94 | first time around the loop, don't let go of |
95 | the port. This way, we find out if we have |
96 | our interrupt handler called. */ |
97 | if (count && no_irq) { |
98 | parport_release (dev); |
99 | schedule_timeout_interruptible(wait); |
100 | parport_claim_or_block (dev); |
101 | } |
102 | else |
103 | /* We must have the device claimed here */ |
104 | parport_wait_event (port, wait); |
105 | |
106 | /* Is there a signal pending? */ |
107 | if (signal_pending (current)) |
108 | break; |
109 | |
110 | /* Wait longer next time. */ |
111 | wait *= 2; |
112 | } while (time_before (jiffies, expire)); |
113 | |
114 | if (signal_pending (current)) |
115 | break; |
116 | |
117 | DPRINTK (KERN_DEBUG "%s: Timed out\n", port->name); |
118 | break; |
119 | |
120 | ready: |
121 | /* Write the character to the data lines. */ |
122 | byte = *addr++; |
123 | parport_write_data (port, byte); |
124 | udelay (1); |
125 | |
126 | /* Pulse strobe. */ |
127 | parport_write_control (port, ctl | PARPORT_CONTROL_STROBE); |
128 | udelay (1); /* strobe */ |
129 | |
130 | parport_write_control (port, ctl); |
131 | udelay (1); /* hold */ |
132 | |
133 | /* Assume the peripheral received it. */ |
134 | count++; |
135 | |
136 | /* Let another process run if it needs to. */ |
137 | if (time_before (jiffies, expire)) |
138 | if (!parport_yield_blocking (dev) |
139 | && need_resched()) |
140 | schedule (); |
141 | } |
142 | stop: |
143 | port->physport->ieee1284.phase = IEEE1284_PH_FWD_IDLE; |
144 | |
145 | return count; |
146 | } |
147 | |
148 | /* Nibble mode. */ |
149 | size_t parport_ieee1284_read_nibble (struct parport *port, |
150 | void *buffer, size_t len, |
151 | int flags) |
152 | { |
153 | #ifndef CONFIG_PARPORT_1284 |
154 | return 0; |
155 | #else |
156 | unsigned char *buf = buffer; |
157 | int i; |
158 | unsigned char byte = 0; |
159 | |
160 | len *= 2; /* in nibbles */ |
161 | for (i=0; i < len; i++) { |
162 | unsigned char nibble; |
163 | |
164 | /* Does the error line indicate end of data? */ |
165 | if (((i & 1) == 0) && |
166 | (parport_read_status(port) & PARPORT_STATUS_ERROR)) { |
167 | goto end_of_data; |
168 | } |
169 | |
170 | /* Event 7: Set nAutoFd low. */ |
171 | parport_frob_control (port, |
172 | PARPORT_CONTROL_AUTOFD, |
173 | PARPORT_CONTROL_AUTOFD); |
174 | |
175 | /* Event 9: nAck goes low. */ |
176 | port->ieee1284.phase = IEEE1284_PH_REV_DATA; |
177 | if (parport_wait_peripheral (port, |
178 | PARPORT_STATUS_ACK, 0)) { |
179 | /* Timeout -- no more data? */ |
180 | DPRINTK (KERN_DEBUG |
181 | "%s: Nibble timeout at event 9 (%d bytes)\n", |
182 | port->name, i/2); |
183 | parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0); |
184 | break; |
185 | } |
186 | |
187 | |
188 | /* Read a nibble. */ |
189 | nibble = parport_read_status (port) >> 3; |
190 | nibble &= ~8; |
191 | if ((nibble & 0x10) == 0) |
192 | nibble |= 8; |
193 | nibble &= 0xf; |
194 | |
195 | /* Event 10: Set nAutoFd high. */ |
196 | parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0); |
197 | |
198 | /* Event 11: nAck goes high. */ |
199 | if (parport_wait_peripheral (port, |
200 | PARPORT_STATUS_ACK, |
201 | PARPORT_STATUS_ACK)) { |
202 | /* Timeout -- no more data? */ |
203 | DPRINTK (KERN_DEBUG |
204 | "%s: Nibble timeout at event 11\n", |
205 | port->name); |
206 | break; |
207 | } |
208 | |
209 | if (i & 1) { |
210 | /* Second nibble */ |
211 | byte |= nibble << 4; |
212 | *buf++ = byte; |
213 | } else |
214 | byte = nibble; |
215 | } |
216 | |
217 | if (i == len) { |
218 | /* Read the last nibble without checking data avail. */ |
219 | if (parport_read_status (port) & PARPORT_STATUS_ERROR) { |
220 | end_of_data: |
221 | DPRINTK (KERN_DEBUG |
222 | "%s: No more nibble data (%d bytes)\n", |
223 | port->name, i/2); |
224 | |
225 | /* Go to reverse idle phase. */ |
226 | parport_frob_control (port, |
227 | PARPORT_CONTROL_AUTOFD, |
228 | PARPORT_CONTROL_AUTOFD); |
229 | port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE; |
230 | } |
231 | else |
232 | port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL; |
233 | } |
234 | |
235 | return i/2; |
236 | #endif /* IEEE1284 support */ |
237 | } |
238 | |
239 | /* Byte mode. */ |
240 | size_t parport_ieee1284_read_byte (struct parport *port, |
241 | void *buffer, size_t len, |
242 | int flags) |
243 | { |
244 | #ifndef CONFIG_PARPORT_1284 |
245 | return 0; |
246 | #else |
247 | unsigned char *buf = buffer; |
248 | ssize_t count = 0; |
249 | |
250 | for (count = 0; count < len; count++) { |
251 | unsigned char byte; |
252 | |
253 | /* Data available? */ |
254 | if (parport_read_status (port) & PARPORT_STATUS_ERROR) { |
255 | goto end_of_data; |
256 | } |
257 | |
258 | /* Event 14: Place data bus in high impedance state. */ |
259 | parport_data_reverse (port); |
260 | |
261 | /* Event 7: Set nAutoFd low. */ |
262 | parport_frob_control (port, |
263 | PARPORT_CONTROL_AUTOFD, |
264 | PARPORT_CONTROL_AUTOFD); |
265 | |
266 | /* Event 9: nAck goes low. */ |
267 | port->physport->ieee1284.phase = IEEE1284_PH_REV_DATA; |
268 | if (parport_wait_peripheral (port, |
269 | PARPORT_STATUS_ACK, |
270 | 0)) { |
271 | /* Timeout -- no more data? */ |
272 | parport_frob_control (port, PARPORT_CONTROL_AUTOFD, |
273 | 0); |
274 | DPRINTK (KERN_DEBUG "%s: Byte timeout at event 9\n", |
275 | port->name); |
276 | break; |
277 | } |
278 | |
279 | byte = parport_read_data (port); |
280 | *buf++ = byte; |
281 | |
282 | /* Event 10: Set nAutoFd high */ |
283 | parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0); |
284 | |
285 | /* Event 11: nAck goes high. */ |
286 | if (parport_wait_peripheral (port, |
287 | PARPORT_STATUS_ACK, |
288 | PARPORT_STATUS_ACK)) { |
289 | /* Timeout -- no more data? */ |
290 | DPRINTK (KERN_DEBUG "%s: Byte timeout at event 11\n", |
291 | port->name); |
292 | break; |
293 | } |
294 | |
295 | /* Event 16: Set nStrobe low. */ |
296 | parport_frob_control (port, |
297 | PARPORT_CONTROL_STROBE, |
298 | PARPORT_CONTROL_STROBE); |
299 | udelay (5); |
300 | |
301 | /* Event 17: Set nStrobe high. */ |
302 | parport_frob_control (port, PARPORT_CONTROL_STROBE, 0); |
303 | } |
304 | |
305 | if (count == len) { |
306 | /* Read the last byte without checking data avail. */ |
307 | if (parport_read_status (port) & PARPORT_STATUS_ERROR) { |
308 | end_of_data: |
309 | DPRINTK (KERN_DEBUG |
310 | "%s: No more byte data (%Zd bytes)\n", |
311 | port->name, count); |
312 | |
313 | /* Go to reverse idle phase. */ |
314 | parport_frob_control (port, |
315 | PARPORT_CONTROL_AUTOFD, |
316 | PARPORT_CONTROL_AUTOFD); |
317 | port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE; |
318 | } |
319 | else |
320 | port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL; |
321 | } |
322 | |
323 | return count; |
324 | #endif /* IEEE1284 support */ |
325 | } |
326 | |
327 | /*** * |
328 | * ECP Functions. * |
329 | * ***/ |
330 | |
331 | #ifdef CONFIG_PARPORT_1284 |
332 | |
333 | static inline |
334 | int ecp_forward_to_reverse (struct parport *port) |
335 | { |
336 | int retval; |
337 | |
338 | /* Event 38: Set nAutoFd low */ |
339 | parport_frob_control (port, |
340 | PARPORT_CONTROL_AUTOFD, |
341 | PARPORT_CONTROL_AUTOFD); |
342 | parport_data_reverse (port); |
343 | udelay (5); |
344 | |
345 | /* Event 39: Set nInit low to initiate bus reversal */ |
346 | parport_frob_control (port, |
347 | PARPORT_CONTROL_INIT, |
348 | 0); |
349 | |
350 | /* Event 40: PError goes low */ |
351 | retval = parport_wait_peripheral (port, |
352 | PARPORT_STATUS_PAPEROUT, 0); |
353 | |
354 | if (!retval) { |
355 | DPRINTK (KERN_DEBUG "%s: ECP direction: reverse\n", |
356 | port->name); |
357 | port->ieee1284.phase = IEEE1284_PH_REV_IDLE; |
358 | } else { |
359 | DPRINTK (KERN_DEBUG "%s: ECP direction: failed to reverse\n", |
360 | port->name); |
361 | port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN; |
362 | } |
363 | |
364 | return retval; |
365 | } |
366 | |
367 | static inline |
368 | int ecp_reverse_to_forward (struct parport *port) |
369 | { |
370 | int retval; |
371 | |
372 | /* Event 47: Set nInit high */ |
373 | parport_frob_control (port, |
374 | PARPORT_CONTROL_INIT |
375 | | PARPORT_CONTROL_AUTOFD, |
376 | PARPORT_CONTROL_INIT |
377 | | PARPORT_CONTROL_AUTOFD); |
378 | |
379 | /* Event 49: PError goes high */ |
380 | retval = parport_wait_peripheral (port, |
381 | PARPORT_STATUS_PAPEROUT, |
382 | PARPORT_STATUS_PAPEROUT); |
383 | |
384 | if (!retval) { |
385 | parport_data_forward (port); |
386 | DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n", |
387 | port->name); |
388 | port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; |
389 | } else { |
390 | DPRINTK (KERN_DEBUG |
391 | "%s: ECP direction: failed to switch forward\n", |
392 | port->name); |
393 | port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN; |
394 | } |
395 | |
396 | |
397 | return retval; |
398 | } |
399 | |
400 | #endif /* IEEE1284 support */ |
401 | |
402 | /* ECP mode, forward channel, data. */ |
403 | size_t parport_ieee1284_ecp_write_data (struct parport *port, |
404 | const void *buffer, size_t len, |
405 | int flags) |
406 | { |
407 | #ifndef CONFIG_PARPORT_1284 |
408 | return 0; |
409 | #else |
410 | const unsigned char *buf = buffer; |
411 | size_t written; |
412 | int retry; |
413 | |
414 | port = port->physport; |
415 | |
416 | if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE) |
417 | if (ecp_reverse_to_forward (port)) |
418 | return 0; |
419 | |
420 | port->ieee1284.phase = IEEE1284_PH_FWD_DATA; |
421 | |
422 | /* HostAck high (data, not command) */ |
423 | parport_frob_control (port, |
424 | PARPORT_CONTROL_AUTOFD |
425 | | PARPORT_CONTROL_STROBE |
426 | | PARPORT_CONTROL_INIT, |
427 | PARPORT_CONTROL_INIT); |
428 | for (written = 0; written < len; written++, buf++) { |
429 | unsigned long expire = jiffies + port->cad->timeout; |
430 | unsigned char byte; |
431 | |
432 | byte = *buf; |
433 | try_again: |
434 | parport_write_data (port, byte); |
435 | parport_frob_control (port, PARPORT_CONTROL_STROBE, |
436 | PARPORT_CONTROL_STROBE); |
437 | udelay (5); |
438 | for (retry = 0; retry < 100; retry++) { |
439 | if (!parport_wait_peripheral (port, |
440 | PARPORT_STATUS_BUSY, 0)) |
441 | goto success; |
442 | |
443 | if (signal_pending (current)) { |
444 | parport_frob_control (port, |
445 | PARPORT_CONTROL_STROBE, |
446 | 0); |
447 | break; |
448 | } |
449 | } |
450 | |
451 | /* Time for Host Transfer Recovery (page 41 of IEEE1284) */ |
452 | DPRINTK (KERN_DEBUG "%s: ECP transfer stalled!\n", port->name); |
453 | |
454 | parport_frob_control (port, PARPORT_CONTROL_INIT, |
455 | PARPORT_CONTROL_INIT); |
456 | udelay (50); |
457 | if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) { |
458 | /* It's buggered. */ |
459 | parport_frob_control (port, PARPORT_CONTROL_INIT, 0); |
460 | break; |
461 | } |
462 | |
463 | parport_frob_control (port, PARPORT_CONTROL_INIT, 0); |
464 | udelay (50); |
465 | if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT)) |
466 | break; |
467 | |
468 | DPRINTK (KERN_DEBUG "%s: Host transfer recovered\n", |
469 | port->name); |
470 | |
471 | if (time_after_eq (jiffies, expire)) break; |
472 | goto try_again; |
473 | success: |
474 | parport_frob_control (port, PARPORT_CONTROL_STROBE, 0); |
475 | udelay (5); |
476 | if (parport_wait_peripheral (port, |
477 | PARPORT_STATUS_BUSY, |
478 | PARPORT_STATUS_BUSY)) |
479 | /* Peripheral hasn't accepted the data. */ |
480 | break; |
481 | } |
482 | |
483 | port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; |
484 | |
485 | return written; |
486 | #endif /* IEEE1284 support */ |
487 | } |
488 | |
489 | /* ECP mode, reverse channel, data. */ |
490 | size_t parport_ieee1284_ecp_read_data (struct parport *port, |
491 | void *buffer, size_t len, int flags) |
492 | { |
493 | #ifndef CONFIG_PARPORT_1284 |
494 | return 0; |
495 | #else |
496 | struct pardevice *dev = port->cad; |
497 | unsigned char *buf = buffer; |
498 | int rle_count = 0; /* shut gcc up */ |
499 | unsigned char ctl; |
500 | int rle = 0; |
501 | ssize_t count = 0; |
502 | |
503 | port = port->physport; |
504 | |
505 | if (port->ieee1284.phase != IEEE1284_PH_REV_IDLE) |
506 | if (ecp_forward_to_reverse (port)) |
507 | return 0; |
508 | |
509 | port->ieee1284.phase = IEEE1284_PH_REV_DATA; |
510 | |
511 | /* Set HostAck low to start accepting data. */ |
512 | ctl = parport_read_control (port); |
513 | ctl &= ~(PARPORT_CONTROL_STROBE | PARPORT_CONTROL_INIT | |
514 | PARPORT_CONTROL_AUTOFD); |
515 | parport_write_control (port, |
516 | ctl | PARPORT_CONTROL_AUTOFD); |
517 | while (count < len) { |
518 | unsigned long expire = jiffies + dev->timeout; |
519 | unsigned char byte; |
520 | int command; |
521 | |
522 | /* Event 43: Peripheral sets nAck low. It can take as |
523 | long as it wants. */ |
524 | while (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) { |
525 | /* The peripheral hasn't given us data in |
526 | 35ms. If we have data to give back to the |
527 | caller, do it now. */ |
528 | if (count) |
529 | goto out; |
530 | |
531 | /* If we've used up all the time we were allowed, |
532 | give up altogether. */ |
533 | if (!time_before (jiffies, expire)) |
534 | goto out; |
535 | |
536 | /* Yield the port for a while. */ |
537 | if (count && dev->port->irq != PARPORT_IRQ_NONE) { |
538 | parport_release (dev); |
539 | schedule_timeout_interruptible(msecs_to_jiffies(40)); |
540 | parport_claim_or_block (dev); |
541 | } |
542 | else |
543 | /* We must have the device claimed here. */ |
544 | parport_wait_event (port, msecs_to_jiffies(40)); |
545 | |
546 | /* Is there a signal pending? */ |
547 | if (signal_pending (current)) |
548 | goto out; |
549 | } |
550 | |
551 | /* Is this a command? */ |
552 | if (rle) |
553 | /* The last byte was a run-length count, so |
554 | this can't be as well. */ |
555 | command = 0; |
556 | else |
557 | command = (parport_read_status (port) & |
558 | PARPORT_STATUS_BUSY) ? 1 : 0; |
559 | |
560 | /* Read the data. */ |
561 | byte = parport_read_data (port); |
562 | |
563 | /* If this is a channel command, rather than an RLE |
564 | command or a normal data byte, don't accept it. */ |
565 | if (command) { |
566 | if (byte & 0x80) { |
567 | DPRINTK (KERN_DEBUG "%s: stopping short at " |
568 | "channel command (%02x)\n", |
569 | port->name, byte); |
570 | goto out; |
571 | } |
572 | else if (port->ieee1284.mode != IEEE1284_MODE_ECPRLE) |
573 | DPRINTK (KERN_DEBUG "%s: device illegally " |
574 | "using RLE; accepting anyway\n", |
575 | port->name); |
576 | |
577 | rle_count = byte + 1; |
578 | |
579 | /* Are we allowed to read that many bytes? */ |
580 | if (rle_count > (len - count)) { |
581 | DPRINTK (KERN_DEBUG "%s: leaving %d RLE bytes " |
582 | "for next time\n", port->name, |
583 | rle_count); |
584 | break; |
585 | } |
586 | |
587 | rle = 1; |
588 | } |
589 | |
590 | /* Event 44: Set HostAck high, acknowledging handshake. */ |
591 | parport_write_control (port, ctl); |
592 | |
593 | /* Event 45: The peripheral has 35ms to set nAck high. */ |
594 | if (parport_wait_peripheral (port, PARPORT_STATUS_ACK, |
595 | PARPORT_STATUS_ACK)) { |
596 | /* It's gone wrong. Return what data we have |
597 | to the caller. */ |
598 | DPRINTK (KERN_DEBUG "ECP read timed out at 45\n"); |
599 | |
600 | if (command) |
601 | printk (KERN_WARNING |
602 | "%s: command ignored (%02x)\n", |
603 | port->name, byte); |
604 | |
605 | break; |
606 | } |
607 | |
608 | /* Event 46: Set HostAck low and accept the data. */ |
609 | parport_write_control (port, |
610 | ctl | PARPORT_CONTROL_AUTOFD); |
611 | |
612 | /* If we just read a run-length count, fetch the data. */ |
613 | if (command) |
614 | continue; |
615 | |
616 | /* If this is the byte after a run-length count, decompress. */ |
617 | if (rle) { |
618 | rle = 0; |
619 | memset (buf, byte, rle_count); |
620 | buf += rle_count; |
621 | count += rle_count; |
622 | DPRINTK (KERN_DEBUG "%s: decompressed to %d bytes\n", |
623 | port->name, rle_count); |
624 | } else { |
625 | /* Normal data byte. */ |
626 | *buf = byte; |
627 | buf++, count++; |
628 | } |
629 | } |
630 | |
631 | out: |
632 | port->ieee1284.phase = IEEE1284_PH_REV_IDLE; |
633 | return count; |
634 | #endif /* IEEE1284 support */ |
635 | } |
636 | |
637 | /* ECP mode, forward channel, commands. */ |
638 | size_t parport_ieee1284_ecp_write_addr (struct parport *port, |
639 | const void *buffer, size_t len, |
640 | int flags) |
641 | { |
642 | #ifndef CONFIG_PARPORT_1284 |
643 | return 0; |
644 | #else |
645 | const unsigned char *buf = buffer; |
646 | size_t written; |
647 | int retry; |
648 | |
649 | port = port->physport; |
650 | |
651 | if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE) |
652 | if (ecp_reverse_to_forward (port)) |
653 | return 0; |
654 | |
655 | port->ieee1284.phase = IEEE1284_PH_FWD_DATA; |
656 | |
657 | /* HostAck low (command, not data) */ |
658 | parport_frob_control (port, |
659 | PARPORT_CONTROL_AUTOFD |
660 | | PARPORT_CONTROL_STROBE |
661 | | PARPORT_CONTROL_INIT, |
662 | PARPORT_CONTROL_AUTOFD |
663 | | PARPORT_CONTROL_INIT); |
664 | for (written = 0; written < len; written++, buf++) { |
665 | unsigned long expire = jiffies + port->cad->timeout; |
666 | unsigned char byte; |
667 | |
668 | byte = *buf; |
669 | try_again: |
670 | parport_write_data (port, byte); |
671 | parport_frob_control (port, PARPORT_CONTROL_STROBE, |
672 | PARPORT_CONTROL_STROBE); |
673 | udelay (5); |
674 | for (retry = 0; retry < 100; retry++) { |
675 | if (!parport_wait_peripheral (port, |
676 | PARPORT_STATUS_BUSY, 0)) |
677 | goto success; |
678 | |
679 | if (signal_pending (current)) { |
680 | parport_frob_control (port, |
681 | PARPORT_CONTROL_STROBE, |
682 | 0); |
683 | break; |
684 | } |
685 | } |
686 | |
687 | /* Time for Host Transfer Recovery (page 41 of IEEE1284) */ |
688 | DPRINTK (KERN_DEBUG "%s: ECP transfer stalled!\n", port->name); |
689 | |
690 | parport_frob_control (port, PARPORT_CONTROL_INIT, |
691 | PARPORT_CONTROL_INIT); |
692 | udelay (50); |
693 | if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) { |
694 | /* It's buggered. */ |
695 | parport_frob_control (port, PARPORT_CONTROL_INIT, 0); |
696 | break; |
697 | } |
698 | |
699 | parport_frob_control (port, PARPORT_CONTROL_INIT, 0); |
700 | udelay (50); |
701 | if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT)) |
702 | break; |
703 | |
704 | DPRINTK (KERN_DEBUG "%s: Host transfer recovered\n", |
705 | port->name); |
706 | |
707 | if (time_after_eq (jiffies, expire)) break; |
708 | goto try_again; |
709 | success: |
710 | parport_frob_control (port, PARPORT_CONTROL_STROBE, 0); |
711 | udelay (5); |
712 | if (parport_wait_peripheral (port, |
713 | PARPORT_STATUS_BUSY, |
714 | PARPORT_STATUS_BUSY)) |
715 | /* Peripheral hasn't accepted the data. */ |
716 | break; |
717 | } |
718 | |
719 | port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; |
720 | |
721 | return written; |
722 | #endif /* IEEE1284 support */ |
723 | } |
724 | |
725 | /*** * |
726 | * EPP functions. * |
727 | * ***/ |
728 | |
729 | /* EPP mode, forward channel, data. */ |
730 | size_t parport_ieee1284_epp_write_data (struct parport *port, |
731 | const void *buffer, size_t len, |
732 | int flags) |
733 | { |
734 | unsigned char *bp = (unsigned char *) buffer; |
735 | size_t ret = 0; |
736 | |
737 | /* set EPP idle state (just to make sure) with strobe low */ |
738 | parport_frob_control (port, |
739 | PARPORT_CONTROL_STROBE | |
740 | PARPORT_CONTROL_AUTOFD | |
741 | PARPORT_CONTROL_SELECT | |
742 | PARPORT_CONTROL_INIT, |
743 | PARPORT_CONTROL_STROBE | |
744 | PARPORT_CONTROL_INIT); |
745 | port->ops->data_forward (port); |
746 | for (; len > 0; len--, bp++) { |
747 | /* Event 62: Write data and set autofd low */ |
748 | parport_write_data (port, *bp); |
749 | parport_frob_control (port, PARPORT_CONTROL_AUTOFD, |
750 | PARPORT_CONTROL_AUTOFD); |
751 | |
752 | /* Event 58: wait for busy (nWait) to go high */ |
753 | if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10)) |
754 | break; |
755 | |
756 | /* Event 63: set nAutoFd (nDStrb) high */ |
757 | parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0); |
758 | |
759 | /* Event 60: wait for busy (nWait) to go low */ |
760 | if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, |
761 | PARPORT_STATUS_BUSY, 5)) |
762 | break; |
763 | |
764 | ret++; |
765 | } |
766 | |
767 | /* Event 61: set strobe (nWrite) high */ |
768 | parport_frob_control (port, PARPORT_CONTROL_STROBE, 0); |
769 | |
770 | return ret; |
771 | } |
772 | |
773 | /* EPP mode, reverse channel, data. */ |
774 | size_t parport_ieee1284_epp_read_data (struct parport *port, |
775 | void *buffer, size_t len, |
776 | int flags) |
777 | { |
778 | unsigned char *bp = (unsigned char *) buffer; |
779 | unsigned ret = 0; |
780 | |
781 | /* set EPP idle state (just to make sure) with strobe high */ |
782 | parport_frob_control (port, |
783 | PARPORT_CONTROL_STROBE | |
784 | PARPORT_CONTROL_AUTOFD | |
785 | PARPORT_CONTROL_SELECT | |
786 | PARPORT_CONTROL_INIT, |
787 | PARPORT_CONTROL_INIT); |
788 | port->ops->data_reverse (port); |
789 | for (; len > 0; len--, bp++) { |
790 | /* Event 67: set nAutoFd (nDStrb) low */ |
791 | parport_frob_control (port, |
792 | PARPORT_CONTROL_AUTOFD, |
793 | PARPORT_CONTROL_AUTOFD); |
794 | /* Event 58: wait for Busy to go high */ |
795 | if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) { |
796 | break; |
797 | } |
798 | |
799 | *bp = parport_read_data (port); |
800 | |
801 | /* Event 63: set nAutoFd (nDStrb) high */ |
802 | parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0); |
803 | |
804 | /* Event 60: wait for Busy to go low */ |
805 | if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, |
806 | PARPORT_STATUS_BUSY, 5)) { |
807 | break; |
808 | } |
809 | |
810 | ret++; |
811 | } |
812 | port->ops->data_forward (port); |
813 | |
814 | return ret; |
815 | } |
816 | |
817 | /* EPP mode, forward channel, addresses. */ |
818 | size_t parport_ieee1284_epp_write_addr (struct parport *port, |
819 | const void *buffer, size_t len, |
820 | int flags) |
821 | { |
822 | unsigned char *bp = (unsigned char *) buffer; |
823 | size_t ret = 0; |
824 | |
825 | /* set EPP idle state (just to make sure) with strobe low */ |
826 | parport_frob_control (port, |
827 | PARPORT_CONTROL_STROBE | |
828 | PARPORT_CONTROL_AUTOFD | |
829 | PARPORT_CONTROL_SELECT | |
830 | PARPORT_CONTROL_INIT, |
831 | PARPORT_CONTROL_STROBE | |
832 | PARPORT_CONTROL_INIT); |
833 | port->ops->data_forward (port); |
834 | for (; len > 0; len--, bp++) { |
835 | /* Event 56: Write data and set nAStrb low. */ |
836 | parport_write_data (port, *bp); |
837 | parport_frob_control (port, PARPORT_CONTROL_SELECT, |
838 | PARPORT_CONTROL_SELECT); |
839 | |
840 | /* Event 58: wait for busy (nWait) to go high */ |
841 | if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10)) |
842 | break; |
843 | |
844 | /* Event 59: set nAStrb high */ |
845 | parport_frob_control (port, PARPORT_CONTROL_SELECT, 0); |
846 | |
847 | /* Event 60: wait for busy (nWait) to go low */ |
848 | if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, |
849 | PARPORT_STATUS_BUSY, 5)) |
850 | break; |
851 | |
852 | ret++; |
853 | } |
854 | |
855 | /* Event 61: set strobe (nWrite) high */ |
856 | parport_frob_control (port, PARPORT_CONTROL_STROBE, 0); |
857 | |
858 | return ret; |
859 | } |
860 | |
861 | /* EPP mode, reverse channel, addresses. */ |
862 | size_t parport_ieee1284_epp_read_addr (struct parport *port, |
863 | void *buffer, size_t len, |
864 | int flags) |
865 | { |
866 | unsigned char *bp = (unsigned char *) buffer; |
867 | unsigned ret = 0; |
868 | |
869 | /* Set EPP idle state (just to make sure) with strobe high */ |
870 | parport_frob_control (port, |
871 | PARPORT_CONTROL_STROBE | |
872 | PARPORT_CONTROL_AUTOFD | |
873 | PARPORT_CONTROL_SELECT | |
874 | PARPORT_CONTROL_INIT, |
875 | PARPORT_CONTROL_INIT); |
876 | port->ops->data_reverse (port); |
877 | for (; len > 0; len--, bp++) { |
878 | /* Event 64: set nSelectIn (nAStrb) low */ |
879 | parport_frob_control (port, PARPORT_CONTROL_SELECT, |
880 | PARPORT_CONTROL_SELECT); |
881 | |
882 | /* Event 58: wait for Busy to go high */ |
883 | if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) { |
884 | break; |
885 | } |
886 | |
887 | *bp = parport_read_data (port); |
888 | |
889 | /* Event 59: set nSelectIn (nAStrb) high */ |
890 | parport_frob_control (port, PARPORT_CONTROL_SELECT, |
891 | 0); |
892 | |
893 | /* Event 60: wait for Busy to go low */ |
894 | if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, |
895 | PARPORT_STATUS_BUSY, 5)) |
896 | break; |
897 | |
898 | ret++; |
899 | } |
900 | port->ops->data_forward (port); |
901 | |
902 | return ret; |
903 | } |
904 | |
905 | EXPORT_SYMBOL(parport_ieee1284_ecp_write_data); |
906 | EXPORT_SYMBOL(parport_ieee1284_ecp_read_data); |
907 | EXPORT_SYMBOL(parport_ieee1284_ecp_write_addr); |
908 | EXPORT_SYMBOL(parport_ieee1284_write_compat); |
909 | EXPORT_SYMBOL(parport_ieee1284_read_nibble); |
910 | EXPORT_SYMBOL(parport_ieee1284_read_byte); |
911 | EXPORT_SYMBOL(parport_ieee1284_epp_write_data); |
912 | EXPORT_SYMBOL(parport_ieee1284_epp_read_data); |
913 | EXPORT_SYMBOL(parport_ieee1284_epp_write_addr); |
914 | EXPORT_SYMBOL(parport_ieee1284_epp_read_addr); |
915 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9