开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
ieee1284_ops.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：23k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

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