1 | /* |
2 | * IEEE-1284 implementation for parport. |
3 | * |
4 | * Authors: Phil Blundell <philb@gnu.org> |
5 | * Carsten Gross <carsten@sol.wohnheim.uni-ulm.de> |
6 | * Jose Renau <renau@acm.org> |
7 | * Tim Waugh <tim@cyberelk.demon.co.uk> (largely rewritten) |
8 | * |
9 | * This file is responsible for IEEE 1284 negotiation, and for handing |
10 | * read/write requests to low-level drivers. |
11 | * |
12 | * Any part of this program may be used in documents licensed under |
13 | * the GNU Free Documentation License, Version 1.1 or any later version |
14 | * published by the Free Software Foundation. |
15 | * |
16 | * Various hacks, Fred Barnes <frmb2@ukc.ac.uk>, 04/2000 |
17 | */ |
18 | |
19 | #include <linux/module.h> |
20 | #include <linux/threads.h> |
21 | #include <linux/parport.h> |
22 | #include <linux/delay.h> |
23 | #include <linux/kernel.h> |
24 | #include <linux/interrupt.h> |
25 | #include <linux/timer.h> |
26 | #include <linux/sched/signal.h> |
27 | |
28 | #undef DEBUG /* undef me for production */ |
29 | |
30 | #ifdef CONFIG_LP_CONSOLE |
31 | #undef DEBUG /* Don't want a garbled console */ |
32 | #endif |
33 | |
34 | /* Make parport_wait_peripheral wake up. |
35 | * It will be useful to call this from an interrupt handler. */ |
36 | static void parport_ieee1284_wakeup (struct parport *port) |
37 | { |
38 | up (sem: &port->physport->ieee1284.irq); |
39 | } |
40 | |
41 | static void timeout_waiting_on_port (struct timer_list *t) |
42 | { |
43 | struct parport *port = from_timer(port, t, timer); |
44 | |
45 | parport_ieee1284_wakeup (port); |
46 | } |
47 | |
48 | /** |
49 | * parport_wait_event - wait for an event on a parallel port |
50 | * @port: port to wait on |
51 | * @timeout: time to wait (in jiffies) |
52 | * |
53 | * This function waits for up to @timeout jiffies for an |
54 | * interrupt to occur on a parallel port. If the port timeout is |
55 | * set to zero, it returns immediately. |
56 | * |
57 | * If an interrupt occurs before the timeout period elapses, this |
58 | * function returns zero immediately. If it times out, it returns |
59 | * one. An error code less than zero indicates an error (most |
60 | * likely a pending signal), and the calling code should finish |
61 | * what it's doing as soon as it can. |
62 | */ |
63 | |
64 | int parport_wait_event (struct parport *port, signed long timeout) |
65 | { |
66 | int ret; |
67 | |
68 | if (!port->physport->cad->timeout) |
69 | /* Zero timeout is special, and we can't down() the |
70 | semaphore. */ |
71 | return 1; |
72 | |
73 | timer_setup(&port->timer, timeout_waiting_on_port, 0); |
74 | mod_timer(timer: &port->timer, expires: jiffies + timeout); |
75 | ret = down_interruptible (sem: &port->physport->ieee1284.irq); |
76 | if (!del_timer_sync(timer: &port->timer) && !ret) |
77 | /* Timed out. */ |
78 | ret = 1; |
79 | |
80 | return ret; |
81 | } |
82 | |
83 | /** |
84 | * parport_poll_peripheral - poll status lines |
85 | * @port: port to watch |
86 | * @mask: status lines to watch |
87 | * @result: desired values of chosen status lines |
88 | * @usec: timeout |
89 | * |
90 | * This function busy-waits until the masked status lines have |
91 | * the desired values, or until the timeout period elapses. The |
92 | * @mask and @result parameters are bitmasks, with the bits |
93 | * defined by the constants in parport.h: %PARPORT_STATUS_BUSY, |
94 | * and so on. |
95 | * |
96 | * This function does not call schedule(); instead it busy-waits |
97 | * using udelay(). It currently has a resolution of 5usec. |
98 | * |
99 | * If the status lines take on the desired values before the |
100 | * timeout period elapses, parport_poll_peripheral() returns zero |
101 | * immediately. A return value greater than zero indicates |
102 | * a timeout. An error code (less than zero) indicates an error, |
103 | * most likely a signal that arrived, and the caller should |
104 | * finish what it is doing as soon as possible. |
105 | */ |
106 | |
107 | int parport_poll_peripheral(struct parport *port, |
108 | unsigned char mask, |
109 | unsigned char result, |
110 | int usec) |
111 | { |
112 | /* Zero return code is success, >0 is timeout. */ |
113 | int count = usec / 5 + 2; |
114 | int i; |
115 | unsigned char status; |
116 | for (i = 0; i < count; i++) { |
117 | status = parport_read_status (port); |
118 | if ((status & mask) == result) |
119 | return 0; |
120 | if (signal_pending (current)) |
121 | return -EINTR; |
122 | if (need_resched()) |
123 | break; |
124 | if (i >= 2) |
125 | udelay (5); |
126 | } |
127 | |
128 | return 1; |
129 | } |
130 | |
131 | /** |
132 | * parport_wait_peripheral - wait for status lines to change in 35ms |
133 | * @port: port to watch |
134 | * @mask: status lines to watch |
135 | * @result: desired values of chosen status lines |
136 | * |
137 | * This function waits until the masked status lines have the |
138 | * desired values, or until 35ms have elapsed (see IEEE 1284-1994 |
139 | * page 24 to 25 for why this value in particular is hardcoded). |
140 | * The @mask and @result parameters are bitmasks, with the bits |
141 | * defined by the constants in parport.h: %PARPORT_STATUS_BUSY, |
142 | * and so on. |
143 | * |
144 | * The port is polled quickly to start off with, in anticipation |
145 | * of a fast response from the peripheral. This fast polling |
146 | * time is configurable (using /proc), and defaults to 500usec. |
147 | * If the timeout for this port (see parport_set_timeout()) is |
148 | * zero, the fast polling time is 35ms, and this function does |
149 | * not call schedule(). |
150 | * |
151 | * If the timeout for this port is non-zero, after the fast |
152 | * polling fails it uses parport_wait_event() to wait for up to |
153 | * 10ms, waking up if an interrupt occurs. |
154 | */ |
155 | |
156 | int parport_wait_peripheral(struct parport *port, |
157 | unsigned char mask, |
158 | unsigned char result) |
159 | { |
160 | int ret; |
161 | int usec; |
162 | unsigned long deadline; |
163 | unsigned char status; |
164 | |
165 | usec = port->physport->spintime; /* usecs of fast polling */ |
166 | if (!port->physport->cad->timeout) |
167 | /* A zero timeout is "special": busy wait for the |
168 | entire 35ms. */ |
169 | usec = 35000; |
170 | |
171 | /* Fast polling. |
172 | * |
173 | * This should be adjustable. |
174 | * How about making a note (in the device structure) of how long |
175 | * it takes, so we know for next time? |
176 | */ |
177 | ret = parport_poll_peripheral (port, mask, result, usec); |
178 | if (ret != 1) |
179 | return ret; |
180 | |
181 | if (!port->physport->cad->timeout) |
182 | /* We may be in an interrupt handler, so we can't poll |
183 | * slowly anyway. */ |
184 | return 1; |
185 | |
186 | /* 40ms of slow polling. */ |
187 | deadline = jiffies + msecs_to_jiffies(m: 40); |
188 | while (time_before (jiffies, deadline)) { |
189 | if (signal_pending (current)) |
190 | return -EINTR; |
191 | |
192 | /* Wait for 10ms (or until an interrupt occurs if |
193 | * the handler is set) */ |
194 | if ((ret = parport_wait_event (port, timeout: msecs_to_jiffies(m: 10))) < 0) |
195 | return ret; |
196 | |
197 | status = parport_read_status (port); |
198 | if ((status & mask) == result) |
199 | return 0; |
200 | |
201 | if (!ret) { |
202 | /* parport_wait_event didn't time out, but the |
203 | * peripheral wasn't actually ready either. |
204 | * Wait for another 10ms. */ |
205 | schedule_timeout_interruptible(timeout: msecs_to_jiffies(m: 10)); |
206 | } |
207 | } |
208 | |
209 | return 1; |
210 | } |
211 | |
212 | #ifdef CONFIG_PARPORT_1284 |
213 | /* Terminate a negotiated mode. */ |
214 | static void parport_ieee1284_terminate (struct parport *port) |
215 | { |
216 | int r; |
217 | port = port->physport; |
218 | |
219 | /* EPP terminates differently. */ |
220 | switch (port->ieee1284.mode) { |
221 | case IEEE1284_MODE_EPP: |
222 | case IEEE1284_MODE_EPPSL: |
223 | case IEEE1284_MODE_EPPSWE: |
224 | /* Terminate from EPP mode. */ |
225 | |
226 | /* Event 68: Set nInit low */ |
227 | parport_frob_control (port, PARPORT_CONTROL_INIT, 0); |
228 | udelay (50); |
229 | |
230 | /* Event 69: Set nInit high, nSelectIn low */ |
231 | parport_frob_control (port, |
232 | PARPORT_CONTROL_SELECT |
233 | | PARPORT_CONTROL_INIT, |
234 | PARPORT_CONTROL_SELECT |
235 | | PARPORT_CONTROL_INIT); |
236 | break; |
237 | |
238 | case IEEE1284_MODE_ECP: |
239 | case IEEE1284_MODE_ECPRLE: |
240 | case IEEE1284_MODE_ECPSWE: |
241 | /* In ECP we can only terminate from fwd idle phase. */ |
242 | if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE) { |
243 | /* Event 47: Set nInit high */ |
244 | parport_frob_control (port, |
245 | PARPORT_CONTROL_INIT |
246 | | PARPORT_CONTROL_AUTOFD, |
247 | PARPORT_CONTROL_INIT |
248 | | PARPORT_CONTROL_AUTOFD); |
249 | |
250 | /* Event 49: PError goes high */ |
251 | r = parport_wait_peripheral (port, |
252 | PARPORT_STATUS_PAPEROUT, |
253 | PARPORT_STATUS_PAPEROUT); |
254 | if (r) |
255 | pr_debug("%s: Timeout at event 49\n" , |
256 | port->name); |
257 | |
258 | parport_data_forward (port); |
259 | pr_debug("%s: ECP direction: forward\n" , port->name); |
260 | port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; |
261 | } |
262 | |
263 | fallthrough; |
264 | |
265 | default: |
266 | /* Terminate from all other modes. */ |
267 | |
268 | /* Event 22: Set nSelectIn low, nAutoFd high */ |
269 | parport_frob_control (port, |
270 | PARPORT_CONTROL_SELECT |
271 | | PARPORT_CONTROL_AUTOFD, |
272 | PARPORT_CONTROL_SELECT); |
273 | |
274 | /* Event 24: nAck goes low */ |
275 | r = parport_wait_peripheral (port, PARPORT_STATUS_ACK, result: 0); |
276 | if (r) |
277 | pr_debug("%s: Timeout at event 24\n" , port->name); |
278 | |
279 | /* Event 25: Set nAutoFd low */ |
280 | parport_frob_control (port, |
281 | PARPORT_CONTROL_AUTOFD, |
282 | PARPORT_CONTROL_AUTOFD); |
283 | |
284 | /* Event 27: nAck goes high */ |
285 | r = parport_wait_peripheral (port, |
286 | PARPORT_STATUS_ACK, |
287 | PARPORT_STATUS_ACK); |
288 | if (r) |
289 | pr_debug("%s: Timeout at event 27\n" , port->name); |
290 | |
291 | /* Event 29: Set nAutoFd high */ |
292 | parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0); |
293 | } |
294 | |
295 | port->ieee1284.mode = IEEE1284_MODE_COMPAT; |
296 | port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; |
297 | |
298 | pr_debug("%s: In compatibility (forward idle) mode\n" , port->name); |
299 | } |
300 | #endif /* IEEE1284 support */ |
301 | |
302 | /** |
303 | * parport_negotiate - negotiate an IEEE 1284 mode |
304 | * @port: port to use |
305 | * @mode: mode to negotiate to |
306 | * |
307 | * Use this to negotiate to a particular IEEE 1284 transfer mode. |
308 | * The @mode parameter should be one of the constants in |
309 | * parport.h starting %IEEE1284_MODE_xxx. |
310 | * |
311 | * The return value is 0 if the peripheral has accepted the |
312 | * negotiation to the mode specified, -1 if the peripheral is not |
313 | * IEEE 1284 compliant (or not present), or 1 if the peripheral |
314 | * has rejected the negotiation. |
315 | */ |
316 | |
317 | int parport_negotiate (struct parport *port, int mode) |
318 | { |
319 | #ifndef CONFIG_PARPORT_1284 |
320 | if (mode == IEEE1284_MODE_COMPAT) |
321 | return 0; |
322 | pr_err("parport: IEEE1284 not supported in this kernel\n" ); |
323 | return -1; |
324 | #else |
325 | int m = mode & ~IEEE1284_ADDR; |
326 | int r; |
327 | unsigned char xflag; |
328 | |
329 | port = port->physport; |
330 | |
331 | /* Is there anything to do? */ |
332 | if (port->ieee1284.mode == mode) |
333 | return 0; |
334 | |
335 | /* Is the difference just an address-or-not bit? */ |
336 | if ((port->ieee1284.mode & ~IEEE1284_ADDR) == (mode & ~IEEE1284_ADDR)){ |
337 | port->ieee1284.mode = mode; |
338 | return 0; |
339 | } |
340 | |
341 | /* Go to compatibility forward idle mode */ |
342 | if (port->ieee1284.mode != IEEE1284_MODE_COMPAT) |
343 | parport_ieee1284_terminate (port); |
344 | |
345 | if (mode == IEEE1284_MODE_COMPAT) |
346 | /* Compatibility mode: no negotiation. */ |
347 | return 0; |
348 | |
349 | switch (mode) { |
350 | case IEEE1284_MODE_ECPSWE: |
351 | m = IEEE1284_MODE_ECP; |
352 | break; |
353 | case IEEE1284_MODE_EPPSL: |
354 | case IEEE1284_MODE_EPPSWE: |
355 | m = IEEE1284_MODE_EPP; |
356 | break; |
357 | case IEEE1284_MODE_BECP: |
358 | return -ENOSYS; /* FIXME (implement BECP) */ |
359 | } |
360 | |
361 | if (mode & IEEE1284_EXT_LINK) |
362 | m = 1<<7; /* request extensibility link */ |
363 | |
364 | port->ieee1284.phase = IEEE1284_PH_NEGOTIATION; |
365 | |
366 | /* Start off with nStrobe and nAutoFd high, and nSelectIn low */ |
367 | parport_frob_control (port, |
368 | PARPORT_CONTROL_STROBE |
369 | | PARPORT_CONTROL_AUTOFD |
370 | | PARPORT_CONTROL_SELECT, |
371 | PARPORT_CONTROL_SELECT); |
372 | udelay(1); |
373 | |
374 | /* Event 0: Set data */ |
375 | parport_data_forward (port); |
376 | parport_write_data (port, m); |
377 | udelay (400); /* Shouldn't need to wait this long. */ |
378 | |
379 | /* Event 1: Set nSelectIn high, nAutoFd low */ |
380 | parport_frob_control (port, |
381 | PARPORT_CONTROL_SELECT |
382 | | PARPORT_CONTROL_AUTOFD, |
383 | PARPORT_CONTROL_AUTOFD); |
384 | |
385 | /* Event 2: PError, Select, nFault go high, nAck goes low */ |
386 | if (parport_wait_peripheral (port, |
387 | PARPORT_STATUS_ERROR |
388 | | PARPORT_STATUS_SELECT |
389 | | PARPORT_STATUS_PAPEROUT |
390 | | PARPORT_STATUS_ACK, |
391 | PARPORT_STATUS_ERROR |
392 | | PARPORT_STATUS_SELECT |
393 | | PARPORT_STATUS_PAPEROUT)) { |
394 | /* Timeout */ |
395 | parport_frob_control (port, |
396 | PARPORT_CONTROL_SELECT |
397 | | PARPORT_CONTROL_AUTOFD, |
398 | PARPORT_CONTROL_SELECT); |
399 | pr_debug("%s: Peripheral not IEEE1284 compliant (0x%02X)\n" , |
400 | port->name, parport_read_status (port)); |
401 | port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; |
402 | return -1; /* Not IEEE1284 compliant */ |
403 | } |
404 | |
405 | /* Event 3: Set nStrobe low */ |
406 | parport_frob_control (port, |
407 | PARPORT_CONTROL_STROBE, |
408 | PARPORT_CONTROL_STROBE); |
409 | |
410 | /* Event 4: Set nStrobe and nAutoFd high */ |
411 | udelay (5); |
412 | parport_frob_control (port, |
413 | PARPORT_CONTROL_STROBE |
414 | | PARPORT_CONTROL_AUTOFD, |
415 | 0); |
416 | |
417 | /* Event 6: nAck goes high */ |
418 | if (parport_wait_peripheral (port, |
419 | PARPORT_STATUS_ACK, |
420 | PARPORT_STATUS_ACK)) { |
421 | /* This shouldn't really happen with a compliant device. */ |
422 | pr_debug("%s: Mode 0x%02x not supported? (0x%02x)\n" , |
423 | port->name, mode, port->ops->read_status (port)); |
424 | parport_ieee1284_terminate (port); |
425 | return 1; |
426 | } |
427 | |
428 | xflag = parport_read_status (port) & PARPORT_STATUS_SELECT; |
429 | |
430 | /* xflag should be high for all modes other than nibble (0). */ |
431 | if (mode && !xflag) { |
432 | /* Mode not supported. */ |
433 | pr_debug("%s: Mode 0x%02x rejected by peripheral\n" , |
434 | port->name, mode); |
435 | parport_ieee1284_terminate (port); |
436 | return 1; |
437 | } |
438 | |
439 | /* More to do if we've requested extensibility link. */ |
440 | if (mode & IEEE1284_EXT_LINK) { |
441 | m = mode & 0x7f; |
442 | udelay (1); |
443 | parport_write_data (port, m); |
444 | udelay (1); |
445 | |
446 | /* Event 51: Set nStrobe low */ |
447 | parport_frob_control (port, |
448 | PARPORT_CONTROL_STROBE, |
449 | PARPORT_CONTROL_STROBE); |
450 | |
451 | /* Event 52: nAck goes low */ |
452 | if (parport_wait_peripheral (port, PARPORT_STATUS_ACK, result: 0)) { |
453 | /* This peripheral is _very_ slow. */ |
454 | pr_debug("%s: Event 52 didn't happen\n" , port->name); |
455 | parport_ieee1284_terminate (port); |
456 | return 1; |
457 | } |
458 | |
459 | /* Event 53: Set nStrobe high */ |
460 | parport_frob_control (port, |
461 | PARPORT_CONTROL_STROBE, |
462 | 0); |
463 | |
464 | /* Event 55: nAck goes high */ |
465 | if (parport_wait_peripheral (port, |
466 | PARPORT_STATUS_ACK, |
467 | PARPORT_STATUS_ACK)) { |
468 | /* This shouldn't really happen with a compliant |
469 | * device. */ |
470 | pr_debug("%s: Mode 0x%02x not supported? (0x%02x)\n" , |
471 | port->name, mode, |
472 | port->ops->read_status(port)); |
473 | parport_ieee1284_terminate (port); |
474 | return 1; |
475 | } |
476 | |
477 | /* Event 54: Peripheral sets XFlag to reflect support */ |
478 | xflag = parport_read_status (port) & PARPORT_STATUS_SELECT; |
479 | |
480 | /* xflag should be high. */ |
481 | if (!xflag) { |
482 | /* Extended mode not supported. */ |
483 | pr_debug("%s: Extended mode 0x%02x not supported\n" , |
484 | port->name, mode); |
485 | parport_ieee1284_terminate (port); |
486 | return 1; |
487 | } |
488 | |
489 | /* Any further setup is left to the caller. */ |
490 | } |
491 | |
492 | /* Mode is supported */ |
493 | pr_debug("%s: In mode 0x%02x\n" , port->name, mode); |
494 | port->ieee1284.mode = mode; |
495 | |
496 | /* But ECP is special */ |
497 | if (!(mode & IEEE1284_EXT_LINK) && (m & IEEE1284_MODE_ECP)) { |
498 | port->ieee1284.phase = IEEE1284_PH_ECP_SETUP; |
499 | |
500 | /* Event 30: Set nAutoFd low */ |
501 | parport_frob_control (port, |
502 | PARPORT_CONTROL_AUTOFD, |
503 | PARPORT_CONTROL_AUTOFD); |
504 | |
505 | /* Event 31: PError goes high. */ |
506 | r = parport_wait_peripheral (port, |
507 | PARPORT_STATUS_PAPEROUT, |
508 | PARPORT_STATUS_PAPEROUT); |
509 | if (r) { |
510 | pr_debug("%s: Timeout at event 31\n" , port->name); |
511 | } |
512 | |
513 | port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; |
514 | pr_debug("%s: ECP direction: forward\n" , port->name); |
515 | } else switch (mode) { |
516 | case IEEE1284_MODE_NIBBLE: |
517 | case IEEE1284_MODE_BYTE: |
518 | port->ieee1284.phase = IEEE1284_PH_REV_IDLE; |
519 | break; |
520 | default: |
521 | port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; |
522 | } |
523 | |
524 | |
525 | return 0; |
526 | #endif /* IEEE1284 support */ |
527 | } |
528 | |
529 | /* Acknowledge that the peripheral has data available. |
530 | * Events 18-20, in order to get from Reverse Idle phase |
531 | * to Host Busy Data Available. |
532 | * This will most likely be called from an interrupt. |
533 | * Returns zero if data was available. |
534 | */ |
535 | #ifdef CONFIG_PARPORT_1284 |
536 | static int parport_ieee1284_ack_data_avail (struct parport *port) |
537 | { |
538 | if (parport_read_status (port) & PARPORT_STATUS_ERROR) |
539 | /* Event 18 didn't happen. */ |
540 | return -1; |
541 | |
542 | /* Event 20: nAutoFd goes high. */ |
543 | port->ops->frob_control (port, PARPORT_CONTROL_AUTOFD, 0); |
544 | port->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL; |
545 | return 0; |
546 | } |
547 | #endif /* IEEE1284 support */ |
548 | |
549 | /* Handle an interrupt. */ |
550 | void parport_ieee1284_interrupt (void *handle) |
551 | { |
552 | struct parport *port = handle; |
553 | parport_ieee1284_wakeup (port); |
554 | |
555 | #ifdef CONFIG_PARPORT_1284 |
556 | if (port->ieee1284.phase == IEEE1284_PH_REV_IDLE) { |
557 | /* An interrupt in this phase means that data |
558 | * is now available. */ |
559 | pr_debug("%s: Data available\n" , port->name); |
560 | parport_ieee1284_ack_data_avail (port); |
561 | } |
562 | #endif /* IEEE1284 support */ |
563 | } |
564 | |
565 | /** |
566 | * parport_write - write a block of data to a parallel port |
567 | * @port: port to write to |
568 | * @buffer: data buffer (in kernel space) |
569 | * @len: number of bytes of data to transfer |
570 | * |
571 | * This will write up to @len bytes of @buffer to the port |
572 | * specified, using the IEEE 1284 transfer mode most recently |
573 | * negotiated to (using parport_negotiate()), as long as that |
574 | * mode supports forward transfers (host to peripheral). |
575 | * |
576 | * It is the caller's responsibility to ensure that the first |
577 | * @len bytes of @buffer are valid. |
578 | * |
579 | * This function returns the number of bytes transferred (if zero |
580 | * or positive), or else an error code. |
581 | */ |
582 | |
583 | ssize_t parport_write (struct parport *port, const void *buffer, size_t len) |
584 | { |
585 | #ifndef CONFIG_PARPORT_1284 |
586 | return port->ops->compat_write_data (port, buffer, len, 0); |
587 | #else |
588 | ssize_t retval; |
589 | int mode = port->ieee1284.mode; |
590 | int addr = mode & IEEE1284_ADDR; |
591 | size_t (*fn) (struct parport *, const void *, size_t, int); |
592 | |
593 | /* Ignore the device-ID-request bit and the address bit. */ |
594 | mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR); |
595 | |
596 | /* Use the mode we're in. */ |
597 | switch (mode) { |
598 | case IEEE1284_MODE_NIBBLE: |
599 | case IEEE1284_MODE_BYTE: |
600 | parport_negotiate (port, IEEE1284_MODE_COMPAT); |
601 | fallthrough; |
602 | case IEEE1284_MODE_COMPAT: |
603 | pr_debug("%s: Using compatibility mode\n" , port->name); |
604 | fn = port->ops->compat_write_data; |
605 | break; |
606 | |
607 | case IEEE1284_MODE_EPP: |
608 | pr_debug("%s: Using EPP mode\n" , port->name); |
609 | if (addr) { |
610 | fn = port->ops->epp_write_addr; |
611 | } else { |
612 | fn = port->ops->epp_write_data; |
613 | } |
614 | break; |
615 | case IEEE1284_MODE_EPPSWE: |
616 | pr_debug("%s: Using software-emulated EPP mode\n" , port->name); |
617 | if (addr) { |
618 | fn = parport_ieee1284_epp_write_addr; |
619 | } else { |
620 | fn = parport_ieee1284_epp_write_data; |
621 | } |
622 | break; |
623 | case IEEE1284_MODE_ECP: |
624 | case IEEE1284_MODE_ECPRLE: |
625 | pr_debug("%s: Using ECP mode\n" , port->name); |
626 | if (addr) { |
627 | fn = port->ops->ecp_write_addr; |
628 | } else { |
629 | fn = port->ops->ecp_write_data; |
630 | } |
631 | break; |
632 | |
633 | case IEEE1284_MODE_ECPSWE: |
634 | pr_debug("%s: Using software-emulated ECP mode\n" , port->name); |
635 | /* The caller has specified that it must be emulated, |
636 | * even if we have ECP hardware! */ |
637 | if (addr) { |
638 | fn = parport_ieee1284_ecp_write_addr; |
639 | } else { |
640 | fn = parport_ieee1284_ecp_write_data; |
641 | } |
642 | break; |
643 | |
644 | default: |
645 | pr_debug("%s: Unknown mode 0x%02x\n" , |
646 | port->name, port->ieee1284.mode); |
647 | return -ENOSYS; |
648 | } |
649 | |
650 | retval = (*fn) (port, buffer, len, 0); |
651 | pr_debug("%s: wrote %zd/%zu bytes\n" , port->name, retval, len); |
652 | return retval; |
653 | #endif /* IEEE1284 support */ |
654 | } |
655 | |
656 | /** |
657 | * parport_read - read a block of data from a parallel port |
658 | * @port: port to read from |
659 | * @buffer: data buffer (in kernel space) |
660 | * @len: number of bytes of data to transfer |
661 | * |
662 | * This will read up to @len bytes of @buffer to the port |
663 | * specified, using the IEEE 1284 transfer mode most recently |
664 | * negotiated to (using parport_negotiate()), as long as that |
665 | * mode supports reverse transfers (peripheral to host). |
666 | * |
667 | * It is the caller's responsibility to ensure that the first |
668 | * @len bytes of @buffer are available to write to. |
669 | * |
670 | * This function returns the number of bytes transferred (if zero |
671 | * or positive), or else an error code. |
672 | */ |
673 | |
674 | ssize_t parport_read (struct parport *port, void *buffer, size_t len) |
675 | { |
676 | #ifndef CONFIG_PARPORT_1284 |
677 | pr_err("parport: IEEE1284 not supported in this kernel\n" ); |
678 | return -ENODEV; |
679 | #else |
680 | int mode = port->physport->ieee1284.mode; |
681 | int addr = mode & IEEE1284_ADDR; |
682 | size_t (*fn) (struct parport *, void *, size_t, int); |
683 | |
684 | /* Ignore the device-ID-request bit and the address bit. */ |
685 | mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR); |
686 | |
687 | /* Use the mode we're in. */ |
688 | switch (mode) { |
689 | case IEEE1284_MODE_COMPAT: |
690 | /* if we can tri-state use BYTE mode instead of NIBBLE mode, |
691 | * if that fails, revert to NIBBLE mode -- ought to store somewhere |
692 | * the device's ability to do BYTE mode reverse transfers, so we don't |
693 | * end up needlessly calling negotiate(BYTE) repeately.. (fb) |
694 | */ |
695 | if ((port->physport->modes & PARPORT_MODE_TRISTATE) && |
696 | !parport_negotiate (port, IEEE1284_MODE_BYTE)) { |
697 | /* got into BYTE mode OK */ |
698 | pr_debug("%s: Using byte mode\n" , port->name); |
699 | fn = port->ops->byte_read_data; |
700 | break; |
701 | } |
702 | if (parport_negotiate (port, IEEE1284_MODE_NIBBLE)) { |
703 | return -EIO; |
704 | } |
705 | fallthrough; /* to NIBBLE */ |
706 | case IEEE1284_MODE_NIBBLE: |
707 | pr_debug("%s: Using nibble mode\n" , port->name); |
708 | fn = port->ops->nibble_read_data; |
709 | break; |
710 | |
711 | case IEEE1284_MODE_BYTE: |
712 | pr_debug("%s: Using byte mode\n" , port->name); |
713 | fn = port->ops->byte_read_data; |
714 | break; |
715 | |
716 | case IEEE1284_MODE_EPP: |
717 | pr_debug("%s: Using EPP mode\n" , port->name); |
718 | if (addr) { |
719 | fn = port->ops->epp_read_addr; |
720 | } else { |
721 | fn = port->ops->epp_read_data; |
722 | } |
723 | break; |
724 | case IEEE1284_MODE_EPPSWE: |
725 | pr_debug("%s: Using software-emulated EPP mode\n" , port->name); |
726 | if (addr) { |
727 | fn = parport_ieee1284_epp_read_addr; |
728 | } else { |
729 | fn = parport_ieee1284_epp_read_data; |
730 | } |
731 | break; |
732 | case IEEE1284_MODE_ECP: |
733 | case IEEE1284_MODE_ECPRLE: |
734 | pr_debug("%s: Using ECP mode\n" , port->name); |
735 | fn = port->ops->ecp_read_data; |
736 | break; |
737 | |
738 | case IEEE1284_MODE_ECPSWE: |
739 | pr_debug("%s: Using software-emulated ECP mode\n" , port->name); |
740 | fn = parport_ieee1284_ecp_read_data; |
741 | break; |
742 | |
743 | default: |
744 | pr_debug("%s: Unknown mode 0x%02x\n" , |
745 | port->name, port->physport->ieee1284.mode); |
746 | return -ENOSYS; |
747 | } |
748 | |
749 | return (*fn) (port, buffer, len, 0); |
750 | #endif /* IEEE1284 support */ |
751 | } |
752 | |
753 | /** |
754 | * parport_set_timeout - set the inactivity timeout for a device |
755 | * @dev: device on a port |
756 | * @inactivity: inactivity timeout (in jiffies) |
757 | * |
758 | * This sets the inactivity timeout for a particular device on a |
759 | * port. This affects functions like parport_wait_peripheral(). |
760 | * The special value 0 means not to call schedule() while dealing |
761 | * with this device. |
762 | * |
763 | * The return value is the previous inactivity timeout. |
764 | * |
765 | * Any callers of parport_wait_event() for this device are woken |
766 | * up. |
767 | */ |
768 | |
769 | long parport_set_timeout (struct pardevice *dev, long inactivity) |
770 | { |
771 | long int old = dev->timeout; |
772 | |
773 | dev->timeout = inactivity; |
774 | |
775 | if (dev->port->physport->cad == dev) |
776 | parport_ieee1284_wakeup (port: dev->port); |
777 | |
778 | return old; |
779 | } |
780 | |
781 | /* Exported symbols for modules. */ |
782 | |
783 | EXPORT_SYMBOL(parport_negotiate); |
784 | EXPORT_SYMBOL(parport_write); |
785 | EXPORT_SYMBOL(parport_read); |
786 | EXPORT_SYMBOL(parport_wait_peripheral); |
787 | EXPORT_SYMBOL(parport_wait_event); |
788 | EXPORT_SYMBOL(parport_set_timeout); |
789 | EXPORT_SYMBOL(parport_ieee1284_interrupt); |
790 | |