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

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

嵌入式Linux

开发平台：

Unix_Linux

ppa.c：源码内容
  1. /* ppa.c   --  low level driver for the IOMEGA PPA3 
  2.  * parallel port SCSI host adapter.
  3.  * 
  4.  * (The PPA3 is the embedded controller in the ZIP drive.)
  5.  * 
  6.  * (c) 1995,1996 Grant R. Guenther, grant@torque.net,
  7.  * under the terms of the GNU General Public License.
  8.  * 
  9.  * Current Maintainer: David Campbell (Perth, Western Australia, GMT+0800)
  10.  *                     campbell@torque.net
  11.  */
  13. #include <linux/config.h>
  15. /* The following #define is to avoid a clash with hosts.c */
  16. #define PPA_CODE 1
  18. #include <linux/blk.h>
  19. #include <asm/io.h>
  20. #include <linux/parport.h>
  21. #include "sd.h"
  22. #include "hosts.h"
  23. int ppa_release(struct Scsi_Host *);
  24. static void ppa_reset_pulse(unsigned int base);
  26. typedef struct {
  27.     struct pardevice *dev; /* Parport device entry         */
  28.     int base; /* Actual port address          */
  29.     int mode; /* Transfer mode                */
  30.     int host; /* Host number (for proc)       */
  31.     Scsi_Cmnd *cur_cmd; /* Current queued command       */
  32.     struct tq_struct ppa_tq; /* Polling interrupt stuff       */
  33.     unsigned long jstart; /* Jiffies at start             */
  34.     unsigned long recon_tmo;    /* How many usecs to wait for reconnection (6th bit) */
  35.     unsigned int failed:1; /* Failure flag                 */
  36.     unsigned int p_busy:1; /* Parport sharing busy flag    */
  37. } ppa_struct;
  39. #define PPA_EMPTY
  40. { dev: NULL,
  41. base: -1,
  42. mode: PPA_AUTODETECT,
  43. host: -1,
  44. cur_cmd: NULL,
  45. ppa_tq: { routine: ppa_interrupt },
  46. jstart: 0,
  47. recon_tmo:      PPA_RECON_TMO,
  48. failed: 0,
  49. p_busy: 0
  50. }
  52. #include  "ppa.h"
  54. #define NO_HOSTS 4
  55. static ppa_struct ppa_hosts[NO_HOSTS] =
  56. {PPA_EMPTY, PPA_EMPTY, PPA_EMPTY, PPA_EMPTY};
  58. #define PPA_BASE(x) ppa_hosts[(x)].base
  60. void ppa_wakeup(void *ref)
  61. {
  62.     ppa_struct *ppa_dev = (ppa_struct *) ref;
  64.     if (!ppa_dev->p_busy)
  65. return;
  67.     if (parport_claim(ppa_dev->dev)) {
  68. printk("ppa: bug in ppa_wakeupn");
  69. return;
  70.     }
  71.     ppa_dev->p_busy = 0;
  72.     ppa_dev->base = ppa_dev->dev->port->base;
  73.     if (ppa_dev->cur_cmd)
  74. ppa_dev->cur_cmd->SCp.phase++;
  75.     return;
  76. }
  78. int ppa_release(struct Scsi_Host *host)
  79. {
  80.     int host_no = host->unique_id;
  82.     printk("Releasing ppa%in", host_no);
  83.     parport_unregister_device(ppa_hosts[host_no].dev);
  84.     return 0;
  85. }
  87. static int ppa_pb_claim(int host_no)
  88. {
  89.     if (parport_claim(ppa_hosts[host_no].dev)) {
  90. ppa_hosts[host_no].p_busy = 1;
  91. return 1;
  92.     }
  93.     if (ppa_hosts[host_no].cur_cmd)
  94. ppa_hosts[host_no].cur_cmd->SCp.phase++;
  95.     return 0;
  96. }
  98. #define ppa_pb_release(x) parport_release(ppa_hosts[(x)].dev)
  100. /***************************************************************************
  101.  *                   Parallel port probing routines                        *
  102.  ***************************************************************************/
  104. static Scsi_Host_Template driver_template = PPA;
  105. #include  "scsi_module.c"
  107. /*
  108.  * Start of Chipset kludges
  109.  */
  111. int ppa_detect(Scsi_Host_Template * host)
  112. {
  113.     struct Scsi_Host *hreg;
  114.     int ports;
  115.     int i, nhosts, try_again;
  116.     struct parport *pb;
  118.     /*
  119.      * unlock to allow the lowlevel parport driver to probe
  120.      * the irqs
  121.      */
  122.     spin_unlock_irq(&io_request_lock);
  123.     pb = parport_enumerate();
  125.     printk("ppa: Version %sn", PPA_VERSION);
  126.     nhosts = 0;
  127.     try_again = 0;
  129.     if (!pb) {
  130. printk("ppa: parport reports no devices.n");
  131. spin_lock_irq(&io_request_lock);
  132. return 0;
  133.     }
  134.   retry_entry:
  135.     for (i = 0; pb; i++, pb = pb->next) {
  136. int modes, ppb, ppb_hi;
  138. ppa_hosts[i].dev =
  139.     parport_register_device(pb, "ppa", NULL, ppa_wakeup,
  140.     NULL, 0, (void *) &ppa_hosts[i]);
  142. if (!ppa_hosts[i].dev)
  143.     continue;
  145. /* Claim the bus so it remembers what we do to the control
  146.  * registers. [ CTR and ECP ]
  147.  */
  148. if (ppa_pb_claim(i)) {
  149.     unsigned long now = jiffies;
  150.     while (ppa_hosts[i].p_busy) {
  151. schedule(); /* We are safe to schedule here */
  152. if (time_after(jiffies, now + 3 * HZ)) {
  153.     printk(KERN_ERR "ppa%d: failed to claim parport because a "
  154.       "pardevice is owning the port for too longtime!n",
  155.    i);
  156.     parport_unregister_device(ppa_hosts[i].dev);
  157.     spin_lock_irq(&io_request_lock);
  158.     return 0;
  159. }
  160.     }
  161. }
  162. ppb = PPA_BASE(i) = ppa_hosts[i].dev->port->base;
  163. ppb_hi =  ppa_hosts[i].dev->port->base_hi;
  164. w_ctr(ppb, 0x0c);
  165. modes = ppa_hosts[i].dev->port->modes;
  167. /* Mode detection works up the chain of speed
  168.  * This avoids a nasty if-then-else-if-... tree
  169.  */
  170. ppa_hosts[i].mode = PPA_NIBBLE;
  172. if (modes & PARPORT_MODE_TRISTATE)
  173.     ppa_hosts[i].mode = PPA_PS2;
  175. if (modes & PARPORT_MODE_ECP) {
  176.     w_ecr(ppb_hi, 0x20);
  177.     ppa_hosts[i].mode = PPA_PS2;
  178. }
  179. if ((modes & PARPORT_MODE_EPP) && (modes & PARPORT_MODE_ECP))
  180.     w_ecr(ppb_hi, 0x80);
  182. /* Done configuration */
  183. ppa_pb_release(i);
  185. if (ppa_init(i)) {
  186.     parport_unregister_device(ppa_hosts[i].dev);
  187.     continue;
  188. }
  189. /* now the glue ... */
  190. switch (ppa_hosts[i].mode) {
  191. case PPA_NIBBLE:
  192.     ports = 3;
  193.     break;
  194. case PPA_PS2:
  195.     ports = 3;
  196.     break;
  197. case PPA_EPP_8:
  198. case PPA_EPP_16:
  199. case PPA_EPP_32:
  200.     ports = 8;
  201.     break;
  202. default: /* Never gets here */
  203.     continue;
  204. }
  206. host->can_queue = PPA_CAN_QUEUE;
  207. host->sg_tablesize = ppa_sg;
  208. hreg = scsi_register(host, 0);
  209. if(hreg == NULL)
  210. continue;
  211. hreg->io_port = pb->base;
  212. hreg->n_io_port = ports;
  213. hreg->dma_channel = -1;
  214. hreg->unique_id = i;
  215. ppa_hosts[i].host = hreg->host_no;
  216. nhosts++;
  217.     }
  218.     if (nhosts == 0) {
  219. if (try_again == 1) {
  220.     printk("WARNING - no ppa compatible devices found.n");
  221.     printk("  As of 31/Aug/1998 Iomega started shipping paralleln");
  222.     printk("  port ZIP drives with a different interface which isn");
  223.     printk("  supported by the imm (ZIP Plus) driver. If then");
  224.     printk("  cable is marked with "AutoDetect", this is what hasn");
  225.     printk("  happened.n");
  226.     spin_lock_irq(&io_request_lock);
  227.     return 0;
  228. }
  229. try_again = 1;
  230. goto retry_entry;
  231.     } else {
  232. spin_lock_irq(&io_request_lock);
  233. return 1; /* return number of hosts detected */
  234.     }
  235. }
  237. /* This is to give the ppa driver a way to modify the timings (and other
  238.  * parameters) by writing to the /proc/scsi/ppa/0 file.
  239.  * Very simple method really... (To simple, no error checking :( )
  240.  * Reason: Kernel hackers HATE having to unload and reload modules for
  241.  * testing...
  242.  * Also gives a method to use a script to obtain optimum timings (TODO)
  243.  */
  245. static inline int ppa_proc_write(int hostno, char *buffer, int length)
  246. {
  247.     unsigned long x;
  249.     if ((length > 5) && (strncmp(buffer, "mode=", 5) == 0)) {
  250. x = simple_strtoul(buffer + 5, NULL, 0);
  251. ppa_hosts[hostno].mode = x;
  252. return length;
  253.     }
  254.     if ((length > 10) && (strncmp(buffer, "recon_tmo=", 10) == 0)) {
  255. x = simple_strtoul(buffer + 10, NULL, 0);
  256. ppa_hosts[hostno].recon_tmo = x;
  257.         printk("ppa: recon_tmo set to %ldn", x);
  258. return length;
  259.     }
  260.     printk("ppa /proc: invalid variablen");
  261.     return (-EINVAL);
  262. }
  264. int ppa_proc_info(char *buffer, char **start, off_t offset,
  265.   int length, int hostno, int inout)
  266. {
  267.     int i;
  268.     int len = 0;
  270.     for (i = 0; i < 4; i++)
  271. if (ppa_hosts[i].host == hostno)
  272.     break;
  274.     if (inout)
  275. return ppa_proc_write(i, buffer, length);
  277.     len += sprintf(buffer + len, "Version : %sn", PPA_VERSION);
  278.     len += sprintf(buffer + len, "Parport : %sn", ppa_hosts[i].dev->port->name);
  279.     len += sprintf(buffer + len, "Mode    : %sn", PPA_MODE_STRING[ppa_hosts[i].mode]);
  280. #if PPA_DEBUG > 0
  281.     len += sprintf(buffer + len, "recon_tmo : %lun", ppa_hosts[i].recon_tmo);
  282. #endif
  284.     /* Request for beyond end of buffer */
  285.     if (offset > length)
  286. return 0;
  288.     *start = buffer + offset;
  289.     len -= offset;
  290.     if (len > length)
  291. len = length;
  292.     return len;
  293. }
  295. static int device_check(int host_no);
  297. #if PPA_DEBUG > 0
  298. #define ppa_fail(x,y) printk("ppa: ppa_fail(%i) from %s at line %dn",
  299.    y, __FUNCTION__, __LINE__); ppa_fail_func(x,y);
  300. static inline void ppa_fail_func(int host_no, int error_code)
  301. #else
  302. static inline void ppa_fail(int host_no, int error_code)
  303. #endif
  304. {
  305.     /* If we fail a device then we trash status / message bytes */
  306.     if (ppa_hosts[host_no].cur_cmd) {
  307. ppa_hosts[host_no].cur_cmd->result = error_code << 16;
  308. ppa_hosts[host_no].failed = 1;
  309.     }
  310. }
  312. /*
  313.  * Wait for the high bit to be set.
  314.  * 
  315.  * In principle, this could be tied to an interrupt, but the adapter
  316.  * doesn't appear to be designed to support interrupts.  We spin on
  317.  * the 0x80 ready bit. 
  318.  */
  319. static unsigned char ppa_wait(int host_no)
  320. {
  321.     int k;
  322.     unsigned short ppb = PPA_BASE(host_no);
  323.     unsigned char r;
  325.     k = PPA_SPIN_TMO;
  326.     /* Wait for bit 6 and 7 - PJC */
  327.     for (r = r_str (ppb); ((r & 0xc0)!=0xc0) && (k); k--) {
  328.     udelay (1);
  329.     r = r_str (ppb);
  330.     }
  332.     /*
  333.      * return some status information.
  334.      * Semantics: 0xc0 = ZIP wants more data
  335.      *            0xd0 = ZIP wants to send more data
  336.      *            0xe0 = ZIP is expecting SCSI command data
  337.      *            0xf0 = end of transfer, ZIP is sending status
  338.      */
  339.     if (k)
  340. return (r & 0xf0);
  342.     /* Counter expired - Time out occurred */
  343.     ppa_fail(host_no, DID_TIME_OUT);
  344.     printk("ppa timeout in ppa_waitn");
  345.     return 0; /* command timed out */
  346. }
  348. /*
  349.  * Clear EPP Timeout Bit 
  350.  */
  351. static inline void epp_reset(unsigned short ppb)
  352. {
  353.     int i;
  355.     i = r_str(ppb);
  356.     w_str(ppb, i);
  357.     w_str(ppb, i & 0xfe);
  358. }
  360. /* 
  361.  * Wait for empty ECP fifo (if we are in ECP fifo mode only)
  362.  */
  363. static inline void ecp_sync(unsigned short hostno)
  364. {
  365.     int i, ppb_hi=ppa_hosts[hostno].dev->port->base_hi;
  367.     if (ppb_hi == 0) return;
  369.     if ((r_ecr(ppb_hi) & 0xe0) == 0x60) { /* mode 011 == ECP fifo mode */
  370.         for (i = 0; i < 100; i++) {
  371.             if (r_ecr(ppb_hi) & 0x01)
  372.                 return;
  373.             udelay(5);
  374.         }
  375.         printk("ppa: ECP sync failed as data still present in FIFO.n");
  376.     }
  377. }
  379. static int ppa_byte_out(unsigned short base, const char *buffer, int len)
  380. {
  381.     int i;
  383.     for (i = len; i; i--) {
  384. w_dtr(base, *buffer++);
  385. w_ctr(base, 0xe);
  386. w_ctr(base, 0xc);
  387.     }
  388.     return 1; /* All went well - we hope! */
  389. }
  391. static int ppa_byte_in(unsigned short base, char *buffer, int len)
  392. {
  393.     int i;
  395.     for (i = len; i; i--) {
  396. *buffer++ = r_dtr(base);
  397. w_ctr(base, 0x27);
  398. w_ctr(base, 0x25);
  399.     }
  400.     return 1; /* All went well - we hope! */
  401. }
  403. static int ppa_nibble_in(unsigned short base, char *buffer, int len)
  404. {
  405.     for (; len; len--) {
  406. unsigned char h;
  408. w_ctr(base, 0x4);
  409. h = r_str(base) & 0xf0;
  410. w_ctr(base, 0x6);
  411. *buffer++ = h | ((r_str(base) & 0xf0) >> 4);
  412.     }
  413.     return 1; /* All went well - we hope! */
  414. }
  416. static int ppa_out(int host_no, char *buffer, int len)
  417. {
  418.     int r;
  419.     unsigned short ppb = PPA_BASE(host_no);
  421.     r = ppa_wait(host_no);
  423.     if ((r & 0x50) != 0x40) {
  424. ppa_fail(host_no, DID_ERROR);
  425. return 0;
  426.     }
  427.     switch (ppa_hosts[host_no].mode) {
  428.     case PPA_NIBBLE:
  429.     case PPA_PS2:
  430. /* 8 bit output, with a loop */
  431. r = ppa_byte_out(ppb, buffer, len);
  432. break;
  434.     case PPA_EPP_32:
  435.     case PPA_EPP_16:
  436.     case PPA_EPP_8:
  437. epp_reset(ppb);
  438. w_ctr(ppb, 0x4);
  439. #ifdef CONFIG_SCSI_IZIP_EPP16
  440. if (!(((long) buffer | len) & 0x01))
  441.     outsw(ppb + 4, buffer, len >> 1);
  442. #else
  443. if (!(((long) buffer | len) & 0x03))
  444.     outsl(ppb + 4, buffer, len >> 2);
  445. #endif
  446. else
  447.     outsb(ppb + 4, buffer, len);
  448. w_ctr(ppb, 0xc);
  449. r = !(r_str(ppb) & 0x01);
  450. w_ctr(ppb, 0xc);
  451. ecp_sync(host_no);
  452. break;
  454.     default:
  455. printk("PPA: bug in ppa_out()n");
  456. r = 0;
  457.     }
  458.     return r;
  459. }
  461. static int ppa_in(int host_no, char *buffer, int len)
  462. {
  463.     int r;
  464.     unsigned short ppb = PPA_BASE(host_no);
  466.     r = ppa_wait(host_no);
  468.     if ((r & 0x50) != 0x50) {
  469. ppa_fail(host_no, DID_ERROR);
  470. return 0;
  471.     }
  472.     switch (ppa_hosts[host_no].mode) {
  473.     case PPA_NIBBLE:
  474. /* 4 bit input, with a loop */
  475. r = ppa_nibble_in(ppb, buffer, len);
  476. w_ctr(ppb, 0xc);
  477. break;
  479.     case PPA_PS2:
  480. /* 8 bit input, with a loop */
  481. w_ctr(ppb, 0x25);
  482. r = ppa_byte_in(ppb, buffer, len);
  483. w_ctr(ppb, 0x4);
  484. w_ctr(ppb, 0xc);
  485. break;
  487.     case PPA_EPP_32:
  488.     case PPA_EPP_16:
  489.     case PPA_EPP_8:
  490. epp_reset(ppb);
  491. w_ctr(ppb, 0x24);
  492. #ifdef CONFIG_SCSI_IZIP_EPP16
  493. if (!(((long) buffer | len) & 0x01))
  494.     insw(ppb + 4, buffer, len >> 1);
  495. #else
  496. if (!(((long) buffer | len) & 0x03))
  497.     insl(ppb + 4, buffer, len >> 2);
  498. #endif
  499. else
  500.     insb(ppb + 4, buffer, len);
  501. w_ctr(ppb, 0x2c);
  502. r = !(r_str(ppb) & 0x01);
  503. w_ctr(ppb, 0x2c);
  504. ecp_sync(host_no);
  505. break;
  507.     default:
  508. printk("PPA: bug in ppa_ins()n");
  509. r = 0;
  510. break;
  511.     }
  512.     return r;
  513. }
  515. /* end of ppa_io.h */
  516. static inline void ppa_d_pulse(unsigned short ppb, unsigned char b)
  517. {
  518.     w_dtr(ppb, b);
  519.     w_ctr(ppb, 0xc);
  520.     w_ctr(ppb, 0xe);
  521.     w_ctr(ppb, 0xc);
  522.     w_ctr(ppb, 0x4);
  523.     w_ctr(ppb, 0xc);
  524. }
  526. static void ppa_disconnect(int host_no)
  527. {
  528.     unsigned short ppb = PPA_BASE(host_no);
  530.     ppa_d_pulse(ppb, 0);
  531.     ppa_d_pulse(ppb, 0x3c);
  532.     ppa_d_pulse(ppb, 0x20);
  533.     ppa_d_pulse(ppb, 0xf);
  534. }
  536. static inline void ppa_c_pulse(unsigned short ppb, unsigned char b)
  537. {
  538.     w_dtr(ppb, b);
  539.     w_ctr(ppb, 0x4);
  540.     w_ctr(ppb, 0x6);
  541.     w_ctr(ppb, 0x4);
  542.     w_ctr(ppb, 0xc);
  543. }
  545. static inline void ppa_connect(int host_no, int flag)
  546. {
  547.     unsigned short ppb = PPA_BASE(host_no);
  549.     ppa_c_pulse(ppb, 0);
  550.     ppa_c_pulse(ppb, 0x3c);
  551.     ppa_c_pulse(ppb, 0x20);
  552.     if ((flag == CONNECT_EPP_MAYBE) &&
  553. IN_EPP_MODE(ppa_hosts[host_no].mode))
  554. ppa_c_pulse(ppb, 0xcf);
  555.     else
  556. ppa_c_pulse(ppb, 0x8f);
  557. }
  559. static int ppa_select(int host_no, int target)
  560. {
  561.     int k;
  562.     unsigned short ppb = PPA_BASE(host_no);
  564.     /*
  565.      * Bit 6 (0x40) is the device selected bit.
  566.      * First we must wait till the current device goes off line...
  567.      */
  568.     k = PPA_SELECT_TMO;
  569.     do {
  570. k--;
  571. udelay(1);
  572.     } while ((r_str(ppb) & 0x40) && (k));
  573.     if (!k)
  574. return 0;
  576.     w_dtr(ppb, (1 << target));
  577.     w_ctr(ppb, 0xe);
  578.     w_ctr(ppb, 0xc);
  579.     w_dtr(ppb, 0x80); /* This is NOT the initator */
  580.     w_ctr(ppb, 0x8);
  582.     k = PPA_SELECT_TMO;
  583.     do {
  584. k--;
  585. udelay(1);
  586.     }
  587.     while (!(r_str(ppb) & 0x40) && (k));
  588.     if (!k)
  589. return 0;
  591.     return 1;
  592. }
  594. /* 
  595.  * This is based on a trace of what the Iomega DOS 'guest' driver does.
  596.  * I've tried several different kinds of parallel ports with guest and
  597.  * coded this to react in the same ways that it does.
  598.  * 
  599.  * The return value from this function is just a hint about where the
  600.  * handshaking failed.
  601.  * 
  602.  */
  603. static int ppa_init(int host_no)
  604. {
  605.     int retv;
  606.     unsigned short ppb = PPA_BASE(host_no);
  608. #if defined(CONFIG_PARPORT) || defined(CONFIG_PARPORT_MODULE)
  609.     if (ppa_pb_claim(host_no))
  610. while (ppa_hosts[host_no].p_busy)
  611.     schedule(); /* We can safe schedule here */
  612. #endif
  614.     ppa_disconnect(host_no);
  615.     ppa_connect(host_no, CONNECT_NORMAL);
  617.     retv = 2; /* Failed */
  619.     w_ctr(ppb, 0xe);
  620.     if ((r_str(ppb) & 0x08) == 0x08)
  621. retv--;
  623.     w_ctr(ppb, 0xc);
  624.     if ((r_str(ppb) & 0x08) == 0x00)
  625. retv--;
  627.     if (!retv)
  628. ppa_reset_pulse(ppb);
  629.     udelay(1000); /* Allow devices to settle down */
  630.     ppa_disconnect(host_no);
  631.     udelay(1000); /* Another delay to allow devices to settle */
  633.     if (!retv)
  634. retv = device_check(host_no);
  636.     ppa_pb_release(host_no);
  637.     return retv;
  638. }
  640. static inline int ppa_send_command(Scsi_Cmnd * cmd)
  641. {
  642.     int host_no = cmd->host->unique_id;
  643.     int k;
  645.     w_ctr(PPA_BASE(host_no), 0x0c);
  647.     for (k = 0; k < cmd->cmd_len; k++)
  648. if (!ppa_out(host_no, &cmd->cmnd[k], 1))
  649.     return 0;
  650.     return 1;
  651. }
  653. /*
  654.  * The bulk flag enables some optimisations in the data transfer loops,
  655.  * it should be true for any command that transfers data in integral
  656.  * numbers of sectors.
  657.  * 
  658.  * The driver appears to remain stable if we speed up the parallel port
  659.  * i/o in this function, but not elsewhere.
  660.  */
  661. static int ppa_completion(Scsi_Cmnd * cmd)
  662. {
  663.     /* Return codes:
  664.      * -1     Error
  665.      *  0     Told to schedule
  666.      *  1     Finished data transfer
  667.      */
  668.     int host_no = cmd->host->unique_id;
  669.     unsigned short ppb = PPA_BASE(host_no);
  670.     unsigned long start_jiffies = jiffies;
  672.     unsigned char r, v;
  673.     int fast, bulk, status;
  675.     v = cmd->cmnd[0];
  676.     bulk = ((v == READ_6) ||
  677.     (v == READ_10) ||
  678.     (v == WRITE_6) ||
  679.     (v == WRITE_10));
  681.     /*
  682.      * We only get here if the drive is ready to comunicate,
  683.      * hence no need for a full ppa_wait.
  684.      */
  685.     r = (r_str(ppb) & 0xf0);
  687.     while (r != (unsigned char) 0xf0) {
  688. /*
  689.  * If we have been running for more than a full timer tick
  690.  * then take a rest.
  691.  */
  692. if (time_after(jiffies, start_jiffies + 1))
  693.     return 0;
  695. if ((cmd->SCp.this_residual <= 0)) {
  696.     ppa_fail(host_no, DID_ERROR);
  697.     return -1; /* ERROR_RETURN */
  698. }
  700. /* On some hardware we have SCSI disconnected (6th bit low)
  701.  * for about 100usecs. It is too expensive to wait a 
  702.  * tick on every loop so we busy wait for no more than
  703.  * 500usecs to give the drive a chance first. We do not 
  704.  * change things for "normal" hardware since generally 
  705.  * the 6th bit is always high.
  706.  * This makes the CPU load higher on some hardware 
  707.  * but otherwise we can not get more then 50K/secs 
  708.  * on this problem hardware.
  709.  */
  710. if ((r & 0xc0) != 0xc0) {
  711.    /* Wait for reconnection should be no more than 
  712.     * jiffy/2 = 5ms = 5000 loops
  713.     */
  714.    unsigned long k = ppa_hosts[host_no].recon_tmo; 
  715.    for (; k && ((r = (r_str(ppb) & 0xf0)) & 0xc0) != 0xc0; k--)
  716.      udelay(1);
  718.    if(!k) 
  719.      return 0;
  720. }    
  722. /* determine if we should use burst I/O */ 
  723. fast = (bulk && (cmd->SCp.this_residual >= PPA_BURST_SIZE)) 
  724.      ? PPA_BURST_SIZE : 1;
  726. if (r == (unsigned char) 0xc0)
  727.     status = ppa_out(host_no, cmd->SCp.ptr, fast);
  728. else
  729.     status = ppa_in(host_no, cmd->SCp.ptr, fast);
  731. cmd->SCp.ptr += fast;
  732. cmd->SCp.this_residual -= fast;
  734. if (!status) {
  735.     ppa_fail(host_no, DID_BUS_BUSY);
  736.     return -1; /* ERROR_RETURN */
  737. }
  738. if (cmd->SCp.buffer && !cmd->SCp.this_residual) {
  739.     /* if scatter/gather, advance to the next segment */
  740.     if (cmd->SCp.buffers_residual--) {
  741. cmd->SCp.buffer++;
  742. cmd->SCp.this_residual = cmd->SCp.buffer->length;
  743. cmd->SCp.ptr = cmd->SCp.buffer->address;
  744.     }
  745. }
  746. /* Now check to see if the drive is ready to comunicate */
  747. r = (r_str(ppb) & 0xf0);
  748. /* If not, drop back down to the scheduler and wait a timer tick */
  749. if (!(r & 0x80))
  750.     return 0;
  751.     }
  752.     return 1; /* FINISH_RETURN */
  753. }
  755. /* deprecated synchronous interface */
  756. int ppa_command(Scsi_Cmnd * cmd)
  757. {
  758.     static int first_pass = 1;
  759.     int host_no = cmd->host->unique_id;
  761.     if (first_pass) {
  762. printk("ppa: using non-queuing interfacen");
  763. first_pass = 0;
  764.     }
  765.     if (ppa_hosts[host_no].cur_cmd) {
  766. printk("PPA: bug in ppa_commandn");
  767. return 0;
  768.     }
  769.     ppa_hosts[host_no].failed = 0;
  770.     ppa_hosts[host_no].jstart = jiffies;
  771.     ppa_hosts[host_no].cur_cmd = cmd;
  772.     cmd->result = DID_ERROR << 16; /* default return code */
  773.     cmd->SCp.phase = 0;
  775.     ppa_pb_claim(host_no);
  777.     while (ppa_engine(&ppa_hosts[host_no], cmd))
  778. schedule();
  780.     if (cmd->SCp.phase) /* Only disconnect if we have connected */
  781. ppa_disconnect(cmd->host->unique_id);
  783.     ppa_pb_release(host_no);
  784.     ppa_hosts[host_no].cur_cmd = 0;
  785.     return cmd->result;
  786. }
  788. /*
  789.  * Since the PPA itself doesn't generate interrupts, we use
  790.  * the scheduler's task queue to generate a stream of call-backs and
  791.  * complete the request when the drive is ready.
  792.  */
  793. static void ppa_interrupt(void *data)
  794. {
  795.     ppa_struct *tmp = (ppa_struct *) data;
  796.     Scsi_Cmnd *cmd = tmp->cur_cmd;
  797.     unsigned long flags;
  799.     if (!cmd) {
  800. printk("PPA: bug in ppa_interruptn");
  801. return;
  802.     }
  803.     if (ppa_engine(tmp, cmd)) {
  804. tmp->ppa_tq.data = (void *) tmp;
  805. tmp->ppa_tq.sync = 0;
  806. queue_task(&tmp->ppa_tq, &tq_timer);
  807. return;
  808.     }
  809.     /* Command must of completed hence it is safe to let go... */
  810. #if PPA_DEBUG > 0
  811.     switch ((cmd->result >> 16) & 0xff) {
  812.     case DID_OK:
  813. break;
  814.     case DID_NO_CONNECT:
  815. printk("ppa: no device at SCSI ID %in", cmd->target);
  816. break;
  817.     case DID_BUS_BUSY:
  818. printk("ppa: BUS BUSY - EPP timeout detectedn");
  819. break;
  820.     case DID_TIME_OUT:
  821. printk("ppa: unknown timeoutn");
  822. break;
  823.     case DID_ABORT:
  824. printk("ppa: told to abortn");
  825. break;
  826.     case DID_PARITY:
  827. printk("ppa: parity error (???)n");
  828. break;
  829.     case DID_ERROR:
  830. printk("ppa: internal driver errorn");
  831. break;
  832.     case DID_RESET:
  833. printk("ppa: told to reset devicen");
  834. break;
  835.     case DID_BAD_INTR:
  836. printk("ppa: bad interrupt (???)n");
  837. break;
  838.     default:
  839. printk("ppa: bad return code (%02x)n", (cmd->result >> 16) & 0xff);
  840.     }
  841. #endif
  843.     if (cmd->SCp.phase > 1)
  844. ppa_disconnect(cmd->host->unique_id);
  845.     if (cmd->SCp.phase > 0)
  846. ppa_pb_release(cmd->host->unique_id);
  848.     tmp->cur_cmd = 0;
  849.     
  850.     spin_lock_irqsave(&io_request_lock, flags);
  851.     cmd->scsi_done(cmd);
  852.     spin_unlock_irqrestore(&io_request_lock, flags);
  853.     return;
  854. }
  856. static int ppa_engine(ppa_struct * tmp, Scsi_Cmnd * cmd)
  857. {
  858.     int host_no = cmd->host->unique_id;
  859.     unsigned short ppb = PPA_BASE(host_no);
  860.     unsigned char l = 0, h = 0;
  861.     int retv;
  863.     /* First check for any errors that may of occurred
  864.      * Here we check for internal errors
  865.      */
  866.     if (tmp->failed)
  867. return 0;
  869.     switch (cmd->SCp.phase) {
  870.     case 0: /* Phase 0 - Waiting for parport */
  871. if ((jiffies - tmp->jstart) > HZ) {
  872.     /*
  873.      * We waited more than a second
  874.      * for parport to call us
  875.      */
  876.     ppa_fail(host_no, DID_BUS_BUSY);
  877.     return 0;
  878. }
  879. return 1; /* wait until ppa_wakeup claims parport */
  880.     case 1: /* Phase 1 - Connected */
  881. { /* Perform a sanity check for cable unplugged */
  882.     int retv = 2; /* Failed */
  884.     ppa_connect(host_no, CONNECT_EPP_MAYBE);
  886.     w_ctr(ppb, 0xe);
  887.     if ((r_str(ppb) & 0x08) == 0x08)
  888. retv--;
  890.     w_ctr(ppb, 0xc);
  891.     if ((r_str(ppb) & 0x08) == 0x00)
  892. retv--;
  894.     if (retv) {
  895. if ((jiffies - tmp->jstart) > (1 * HZ)) {
  896.     printk("ppa: Parallel port cable is unplugged!!n");
  897.     ppa_fail(host_no, DID_BUS_BUSY);
  898.     return 0;
  899. } else {
  900.     ppa_disconnect(host_no);
  901.     return 1; /* Try again in a jiffy */
  902. }
  903.     }
  904.     cmd->SCp.phase++;
  905. }
  907.     case 2: /* Phase 2 - We are now talking to the scsi bus */
  908. if (!ppa_select(host_no, cmd->target)) {
  909.     ppa_fail(host_no, DID_NO_CONNECT);
  910.     return 0;
  911. }
  912. cmd->SCp.phase++;
  914.     case 3: /* Phase 3 - Ready to accept a command */
  915. w_ctr(ppb, 0x0c);
  916. if (!(r_str(ppb) & 0x80))
  917.     return 1;
  919. if (!ppa_send_command(cmd))
  920.     return 0;
  921. cmd->SCp.phase++;
  923.     case 4: /* Phase 4 - Setup scatter/gather buffers */
  924. if (cmd->use_sg) {
  925.     /* if many buffers are available, start filling the first */
  926.     cmd->SCp.buffer = (struct scatterlist *) cmd->request_buffer;
  927.     cmd->SCp.this_residual = cmd->SCp.buffer->length;
  928.     cmd->SCp.ptr = cmd->SCp.buffer->address;
  929. } else {
  930.     /* else fill the only available buffer */
  931.     cmd->SCp.buffer = NULL;
  932.     cmd->SCp.this_residual = cmd->request_bufflen;
  933.     cmd->SCp.ptr = cmd->request_buffer;
  934. }
  935. cmd->SCp.buffers_residual = cmd->use_sg;
  936. cmd->SCp.phase++;
  938.     case 5: /* Phase 5 - Data transfer stage */
  939. w_ctr(ppb, 0x0c);
  940. if (!(r_str(ppb) & 0x80))
  941.     return 1;
  943. retv = ppa_completion(cmd);
  944. if (retv == -1)
  945.     return 0;
  946. if (retv == 0)
  947.     return 1;
  948. cmd->SCp.phase++;
  950.     case 6: /* Phase 6 - Read status/message */
  951. cmd->result = DID_OK << 16;
  952. /* Check for data overrun */
  953. if (ppa_wait(host_no) != (unsigned char) 0xf0) {
  954.     ppa_fail(host_no, DID_ERROR);
  955.     return 0;
  956. }
  957. if (ppa_in(host_no, &l, 1)) { /* read status byte */
  958.     /* Check for optional message byte */
  959.     if (ppa_wait(host_no) == (unsigned char) 0xf0)
  960. ppa_in(host_no, &h, 1);
  961.     cmd->result = (DID_OK << 16) + (h << 8) + (l & STATUS_MASK);
  962. }
  963. return 0; /* Finished */
  964. break;
  966.     default:
  967. printk("ppa: Invalid scsi phasen");
  968.     }
  969.     return 0;
  970. }
  972. int ppa_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
  973. {
  974.     int host_no = cmd->host->unique_id;
  976.     if (ppa_hosts[host_no].cur_cmd) {
  977. printk("PPA: bug in ppa_queuecommandn");
  978. return 0;
  979.     }
  980.     ppa_hosts[host_no].failed = 0;
  981.     ppa_hosts[host_no].jstart = jiffies;
  982.     ppa_hosts[host_no].cur_cmd = cmd;
  983.     cmd->scsi_done = done;
  984.     cmd->result = DID_ERROR << 16; /* default return code */
  985.     cmd->SCp.phase = 0; /* bus free */
  987.     ppa_pb_claim(host_no);
  989.     ppa_hosts[host_no].ppa_tq.data = ppa_hosts + host_no;
  990.     ppa_hosts[host_no].ppa_tq.sync = 0;
  991.     queue_task(&ppa_hosts[host_no].ppa_tq, &tq_immediate);
  992.     mark_bh(IMMEDIATE_BH);
  994.     return 0;
  995. }
  997. /*
  998.  * Apparently the the disk->capacity attribute is off by 1 sector 
  999.  * for all disk drives.  We add the one here, but it should really
  1000.  * be done in sd.c.  Even if it gets fixed there, this will still
  1001.  * work.
  1002.  */
  1003. int ppa_biosparam(Disk * disk, kdev_t dev, int ip[])
  1004. {
  1005.     ip[0] = 0x40;
  1006.     ip[1] = 0x20;
  1007.     ip[2] = (disk->capacity + 1) / (ip[0] * ip[1]);
  1008.     if (ip[2] > 1024) {
  1009. ip[0] = 0xff;
  1010. ip[1] = 0x3f;
  1011. ip[2] = (disk->capacity + 1) / (ip[0] * ip[1]);
  1012. if (ip[2] > 1023)
  1013.     ip[2] = 1023;
  1014.     }
  1015.     return 0;
  1016. }
  1018. int ppa_abort(Scsi_Cmnd * cmd)
  1019. {
  1020.     int host_no = cmd->host->unique_id;
  1021.     /*
  1022.      * There is no method for aborting commands since Iomega
  1023.      * have tied the SCSI_MESSAGE line high in the interface
  1024.      */
  1026.     switch (cmd->SCp.phase) {
  1027.     case 0: /* Do not have access to parport */
  1028.     case 1: /* Have not connected to interface */
  1029. ppa_hosts[host_no].cur_cmd = NULL; /* Forget the problem */
  1030. return SUCCESS;
  1031. break;
  1032.     default: /* SCSI command sent, can not abort */
  1033. return FAILED;
  1034. break;
  1035.     }
  1036. }
  1038. static void ppa_reset_pulse(unsigned int base)
  1039. {
  1040.     w_dtr(base, 0x40);
  1041.     w_ctr(base, 0x8);
  1042.     udelay(30);
  1043.     w_ctr(base, 0xc);
  1044. }
  1046. int ppa_reset(Scsi_Cmnd * cmd)
  1047. {
  1048.     int host_no = cmd->host->unique_id;
  1050.     if (cmd->SCp.phase)
  1051. ppa_disconnect(host_no);
  1052.     ppa_hosts[host_no].cur_cmd = NULL; /* Forget the problem */
  1054.     ppa_connect(host_no, CONNECT_NORMAL);
  1055.     ppa_reset_pulse(PPA_BASE(host_no));
  1056.     udelay(1000); /* device settle delay */
  1057.     ppa_disconnect(host_no);
  1058.     udelay(1000); /* device settle delay */
  1059.     return SUCCESS;
  1060. }
  1062. static int device_check(int host_no)
  1063. {
  1064.     /* This routine looks for a device and then attempts to use EPP
  1065.        to send a command. If all goes as planned then EPP is available. */
  1067.     static char cmd[6] =
  1068.     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  1069.     int loop, old_mode, status, k, ppb = PPA_BASE(host_no);
  1070.     unsigned char l;
  1072.     old_mode = ppa_hosts[host_no].mode;
  1073.     for (loop = 0; loop < 8; loop++) {
  1074. /* Attempt to use EPP for Test Unit Ready */
  1075. if ((ppb & 0x0007) == 0x0000)
  1076.     ppa_hosts[host_no].mode = PPA_EPP_32;
  1078.       second_pass:
  1079. ppa_connect(host_no, CONNECT_EPP_MAYBE);
  1080. /* Select SCSI device */
  1081. if (!ppa_select(host_no, loop)) {
  1082.     ppa_disconnect(host_no);
  1083.     continue;
  1084. }
  1085. printk("ppa: Found device at ID %i, Attempting to use %sn", loop,
  1086.        PPA_MODE_STRING[ppa_hosts[host_no].mode]);
  1088. /* Send SCSI command */
  1089. status = 1;
  1090. w_ctr(ppb, 0x0c);
  1091. for (l = 0; (l < 6) && (status); l++)
  1092.     status = ppa_out(host_no, cmd, 1);
  1094. if (!status) {
  1095.     ppa_disconnect(host_no);
  1096.     ppa_connect(host_no, CONNECT_EPP_MAYBE);
  1097.     w_dtr(ppb, 0x40);
  1098.     w_ctr(ppb, 0x08);
  1099.     udelay(30);
  1100.     w_ctr(ppb, 0x0c);
  1101.     udelay(1000);
  1102.     ppa_disconnect(host_no);
  1103.     udelay(1000);
  1104.     if (ppa_hosts[host_no].mode == PPA_EPP_32) {
  1105. ppa_hosts[host_no].mode = old_mode;
  1106. goto second_pass;
  1107.     }
  1108.     printk("ppa: Unable to establish communication, aborting driver load.n");
  1109.     return 1;
  1110. }
  1111. w_ctr(ppb, 0x0c);
  1112. k = 1000000; /* 1 Second */
  1113. do {
  1114.     l = r_str(ppb);
  1115.     k--;
  1116.     udelay(1);
  1117. } while (!(l & 0x80) && (k));
  1119. l &= 0xf0;
  1121. if (l != 0xf0) {
  1122.     ppa_disconnect(host_no);
  1123.     ppa_connect(host_no, CONNECT_EPP_MAYBE);
  1124.     ppa_reset_pulse(ppb);
  1125.     udelay(1000);
  1126.     ppa_disconnect(host_no);
  1127.     udelay(1000);
  1128.     if (ppa_hosts[host_no].mode == PPA_EPP_32) {
  1129. ppa_hosts[host_no].mode = old_mode;
  1130. goto second_pass;
  1131.     }
  1132.     printk("ppa: Unable to establish communication, aborting driver load.n");
  1133.     return 1;
  1134. }
  1135. ppa_disconnect(host_no);
  1136. printk("ppa: Communication established with ID %i using %sn", loop,
  1137.        PPA_MODE_STRING[ppa_hosts[host_no].mode]);
  1138. ppa_connect(host_no, CONNECT_EPP_MAYBE);
  1139. ppa_reset_pulse(ppb);
  1140. udelay(1000);
  1141. ppa_disconnect(host_no);
  1142. udelay(1000);
  1143. return 0;
  1144.     }
  1145.     printk("ppa: No devices found, aborting driver load.n");
  1146.     return 1;
  1147. }
  1148. MODULE_LICENSE("GPL");