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