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