USB: pegasus error path not resetting task's state
[linux-2.6] / drivers / scsi / imm.c
1 /* imm.c   --  low level driver for the IOMEGA MatchMaker
2  * parallel port SCSI host adapter.
3  * 
4  * (The IMM is the embedded controller in the ZIP Plus drive.)
5  * 
6  * My unoffical company acronym list is 21 pages long:
7  *      FLA:    Four letter acronym with built in facility for
8  *              future expansion to five letters.
9  */
10
11 #include <linux/init.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/blkdev.h>
15 #include <linux/parport.h>
16 #include <linux/workqueue.h>
17 #include <linux/delay.h>
18 #include <asm/io.h>
19
20 #include <scsi/scsi.h>
21 #include <scsi/scsi_cmnd.h>
22 #include <scsi/scsi_device.h>
23 #include <scsi/scsi_host.h>
24
25 /* The following #define is to avoid a clash with hosts.c */
26 #define IMM_PROBE_SPP   0x0001
27 #define IMM_PROBE_PS2   0x0002
28 #define IMM_PROBE_ECR   0x0010
29 #define IMM_PROBE_EPP17 0x0100
30 #define IMM_PROBE_EPP19 0x0200
31
32
33 typedef struct {
34         struct pardevice *dev;  /* Parport device entry         */
35         int base;               /* Actual port address          */
36         int base_hi;            /* Hi Base address for ECP-ISA chipset */
37         int mode;               /* Transfer mode                */
38         struct scsi_cmnd *cur_cmd;      /* Current queued command       */
39         struct work_struct imm_tq;      /* Polling interrupt stuff       */
40         unsigned long jstart;   /* Jiffies at start             */
41         unsigned failed:1;      /* Failure flag                 */
42         unsigned dp:1;          /* Data phase present           */
43         unsigned rd:1;          /* Read data in data phase      */
44         unsigned wanted:1;      /* Parport sharing busy flag    */
45         wait_queue_head_t *waiting;
46         struct Scsi_Host *host;
47         struct list_head list;
48 } imm_struct;
49
50 static void imm_reset_pulse(unsigned int base);
51 static int device_check(imm_struct *dev);
52
53 #include "imm.h"
54
55 static inline imm_struct *imm_dev(struct Scsi_Host *host)
56 {
57         return *(imm_struct **)&host->hostdata;
58 }
59
60 static DEFINE_SPINLOCK(arbitration_lock);
61
62 static void got_it(imm_struct *dev)
63 {
64         dev->base = dev->dev->port->base;
65         if (dev->cur_cmd)
66                 dev->cur_cmd->SCp.phase = 1;
67         else
68                 wake_up(dev->waiting);
69 }
70
71 static void imm_wakeup(void *ref)
72 {
73         imm_struct *dev = (imm_struct *) ref;
74         unsigned long flags;
75
76         spin_lock_irqsave(&arbitration_lock, flags);
77         if (dev->wanted) {
78                 parport_claim(dev->dev);
79                 got_it(dev);
80                 dev->wanted = 0;
81         }
82         spin_unlock_irqrestore(&arbitration_lock, flags);
83 }
84
85 static int imm_pb_claim(imm_struct *dev)
86 {
87         unsigned long flags;
88         int res = 1;
89         spin_lock_irqsave(&arbitration_lock, flags);
90         if (parport_claim(dev->dev) == 0) {
91                 got_it(dev);
92                 res = 0;
93         }
94         dev->wanted = res;
95         spin_unlock_irqrestore(&arbitration_lock, flags);
96         return res;
97 }
98
99 static void imm_pb_dismiss(imm_struct *dev)
100 {
101         unsigned long flags;
102         int wanted;
103         spin_lock_irqsave(&arbitration_lock, flags);
104         wanted = dev->wanted;
105         dev->wanted = 0;
106         spin_unlock_irqrestore(&arbitration_lock, flags);
107         if (!wanted)
108                 parport_release(dev->dev);
109 }
110
111 static inline void imm_pb_release(imm_struct *dev)
112 {
113         parport_release(dev->dev);
114 }
115
116 /* This is to give the imm driver a way to modify the timings (and other
117  * parameters) by writing to the /proc/scsi/imm/0 file.
118  * Very simple method really... (Too simple, no error checking :( )
119  * Reason: Kernel hackers HATE having to unload and reload modules for
120  * testing...
121  * Also gives a method to use a script to obtain optimum timings (TODO)
122  */
123 static inline int imm_proc_write(imm_struct *dev, char *buffer, int length)
124 {
125         unsigned long x;
126
127         if ((length > 5) && (strncmp(buffer, "mode=", 5) == 0)) {
128                 x = simple_strtoul(buffer + 5, NULL, 0);
129                 dev->mode = x;
130                 return length;
131         }
132         printk("imm /proc: invalid variable\n");
133         return (-EINVAL);
134 }
135
136 static int imm_proc_info(struct Scsi_Host *host, char *buffer, char **start,
137                         off_t offset, int length, int inout)
138 {
139         imm_struct *dev = imm_dev(host);
140         int len = 0;
141
142         if (inout)
143                 return imm_proc_write(dev, buffer, length);
144
145         len += sprintf(buffer + len, "Version : %s\n", IMM_VERSION);
146         len +=
147             sprintf(buffer + len, "Parport : %s\n",
148                     dev->dev->port->name);
149         len +=
150             sprintf(buffer + len, "Mode    : %s\n",
151                     IMM_MODE_STRING[dev->mode]);
152
153         /* Request for beyond end of buffer */
154         if (offset > len)
155                 return 0;
156
157         *start = buffer + offset;
158         len -= offset;
159         if (len > length)
160                 len = length;
161         return len;
162 }
163
164 #if IMM_DEBUG > 0
165 #define imm_fail(x,y) printk("imm: imm_fail(%i) from %s at line %d\n",\
166            y, __FUNCTION__, __LINE__); imm_fail_func(x,y);
167 static inline void
168 imm_fail_func(imm_struct *dev, int error_code)
169 #else
170 static inline void
171 imm_fail(imm_struct *dev, int error_code)
172 #endif
173 {
174         /* If we fail a device then we trash status / message bytes */
175         if (dev->cur_cmd) {
176                 dev->cur_cmd->result = error_code << 16;
177                 dev->failed = 1;
178         }
179 }
180
181 /*
182  * Wait for the high bit to be set.
183  * 
184  * In principle, this could be tied to an interrupt, but the adapter
185  * doesn't appear to be designed to support interrupts.  We spin on
186  * the 0x80 ready bit. 
187  */
188 static unsigned char imm_wait(imm_struct *dev)
189 {
190         int k;
191         unsigned short ppb = dev->base;
192         unsigned char r;
193
194         w_ctr(ppb, 0x0c);
195
196         k = IMM_SPIN_TMO;
197         do {
198                 r = r_str(ppb);
199                 k--;
200                 udelay(1);
201         }
202         while (!(r & 0x80) && (k));
203
204         /*
205          * STR register (LPT base+1) to SCSI mapping:
206          *
207          * STR      imm     imm
208          * ===================================
209          * 0x80     S_REQ   S_REQ
210          * 0x40     !S_BSY  (????)
211          * 0x20     !S_CD   !S_CD
212          * 0x10     !S_IO   !S_IO
213          * 0x08     (????)  !S_BSY
214          *
215          * imm      imm     meaning
216          * ==================================
217          * 0xf0     0xb8    Bit mask
218          * 0xc0     0x88    ZIP wants more data
219          * 0xd0     0x98    ZIP wants to send more data
220          * 0xe0     0xa8    ZIP is expecting SCSI command data
221          * 0xf0     0xb8    end of transfer, ZIP is sending status
222          */
223         w_ctr(ppb, 0x04);
224         if (k)
225                 return (r & 0xb8);
226
227         /* Counter expired - Time out occurred */
228         imm_fail(dev, DID_TIME_OUT);
229         printk("imm timeout in imm_wait\n");
230         return 0;               /* command timed out */
231 }
232
233 static int imm_negotiate(imm_struct * tmp)
234 {
235         /*
236          * The following is supposedly the IEEE 1284-1994 negotiate
237          * sequence. I have yet to obtain a copy of the above standard
238          * so this is a bit of a guess...
239          *
240          * A fair chunk of this is based on the Linux parport implementation
241          * of IEEE 1284.
242          *
243          * Return 0 if data available
244          *        1 if no data available
245          */
246
247         unsigned short base = tmp->base;
248         unsigned char a, mode;
249
250         switch (tmp->mode) {
251         case IMM_NIBBLE:
252                 mode = 0x00;
253                 break;
254         case IMM_PS2:
255                 mode = 0x01;
256                 break;
257         default:
258                 return 0;
259         }
260
261         w_ctr(base, 0x04);
262         udelay(5);
263         w_dtr(base, mode);
264         udelay(100);
265         w_ctr(base, 0x06);
266         udelay(5);
267         a = (r_str(base) & 0x20) ? 0 : 1;
268         udelay(5);
269         w_ctr(base, 0x07);
270         udelay(5);
271         w_ctr(base, 0x06);
272
273         if (a) {
274                 printk
275                     ("IMM: IEEE1284 negotiate indicates no data available.\n");
276                 imm_fail(tmp, DID_ERROR);
277         }
278         return a;
279 }
280
281 /* 
282  * Clear EPP timeout bit. 
283  */
284 static inline void epp_reset(unsigned short ppb)
285 {
286         int i;
287
288         i = r_str(ppb);
289         w_str(ppb, i);
290         w_str(ppb, i & 0xfe);
291 }
292
293 /* 
294  * Wait for empty ECP fifo (if we are in ECP fifo mode only)
295  */
296 static inline void ecp_sync(imm_struct *dev)
297 {
298         int i, ppb_hi = dev->base_hi;
299
300         if (ppb_hi == 0)
301                 return;
302
303         if ((r_ecr(ppb_hi) & 0xe0) == 0x60) {   /* mode 011 == ECP fifo mode */
304                 for (i = 0; i < 100; i++) {
305                         if (r_ecr(ppb_hi) & 0x01)
306                                 return;
307                         udelay(5);
308                 }
309                 printk("imm: ECP sync failed as data still present in FIFO.\n");
310         }
311 }
312
313 static int imm_byte_out(unsigned short base, const char *buffer, int len)
314 {
315         int i;
316
317         w_ctr(base, 0x4);       /* apparently a sane mode */
318         for (i = len >> 1; i; i--) {
319                 w_dtr(base, *buffer++);
320                 w_ctr(base, 0x5);       /* Drop STROBE low */
321                 w_dtr(base, *buffer++);
322                 w_ctr(base, 0x0);       /* STROBE high + INIT low */
323         }
324         w_ctr(base, 0x4);       /* apparently a sane mode */
325         return 1;               /* All went well - we hope! */
326 }
327
328 static int imm_nibble_in(unsigned short base, char *buffer, int len)
329 {
330         unsigned char l;
331         int i;
332
333         /*
334          * The following is based on documented timing signals
335          */
336         w_ctr(base, 0x4);
337         for (i = len; i; i--) {
338                 w_ctr(base, 0x6);
339                 l = (r_str(base) & 0xf0) >> 4;
340                 w_ctr(base, 0x5);
341                 *buffer++ = (r_str(base) & 0xf0) | l;
342                 w_ctr(base, 0x4);
343         }
344         return 1;               /* All went well - we hope! */
345 }
346
347 static int imm_byte_in(unsigned short base, char *buffer, int len)
348 {
349         int i;
350
351         /*
352          * The following is based on documented timing signals
353          */
354         w_ctr(base, 0x4);
355         for (i = len; i; i--) {
356                 w_ctr(base, 0x26);
357                 *buffer++ = r_dtr(base);
358                 w_ctr(base, 0x25);
359         }
360         return 1;               /* All went well - we hope! */
361 }
362
363 static int imm_out(imm_struct *dev, char *buffer, int len)
364 {
365         unsigned short ppb = dev->base;
366         int r = imm_wait(dev);
367
368         /*
369          * Make sure that:
370          * a) the SCSI bus is BUSY (device still listening)
371          * b) the device is listening
372          */
373         if ((r & 0x18) != 0x08) {
374                 imm_fail(dev, DID_ERROR);
375                 printk("IMM: returned SCSI status %2x\n", r);
376                 return 0;
377         }
378         switch (dev->mode) {
379         case IMM_EPP_32:
380         case IMM_EPP_16:
381         case IMM_EPP_8:
382                 epp_reset(ppb);
383                 w_ctr(ppb, 0x4);
384 #ifdef CONFIG_SCSI_IZIP_EPP16
385                 if (!(((long) buffer | len) & 0x01))
386                         outsw(ppb + 4, buffer, len >> 1);
387 #else
388                 if (!(((long) buffer | len) & 0x03))
389                         outsl(ppb + 4, buffer, len >> 2);
390 #endif
391                 else
392                         outsb(ppb + 4, buffer, len);
393                 w_ctr(ppb, 0xc);
394                 r = !(r_str(ppb) & 0x01);
395                 w_ctr(ppb, 0xc);
396                 ecp_sync(dev);
397                 break;
398
399         case IMM_NIBBLE:
400         case IMM_PS2:
401                 /* 8 bit output, with a loop */
402                 r = imm_byte_out(ppb, buffer, len);
403                 break;
404
405         default:
406                 printk("IMM: bug in imm_out()\n");
407                 r = 0;
408         }
409         return r;
410 }
411
412 static int imm_in(imm_struct *dev, char *buffer, int len)
413 {
414         unsigned short ppb = dev->base;
415         int r = imm_wait(dev);
416
417         /*
418          * Make sure that:
419          * a) the SCSI bus is BUSY (device still listening)
420          * b) the device is sending data
421          */
422         if ((r & 0x18) != 0x18) {
423                 imm_fail(dev, DID_ERROR);
424                 return 0;
425         }
426         switch (dev->mode) {
427         case IMM_NIBBLE:
428                 /* 4 bit input, with a loop */
429                 r = imm_nibble_in(ppb, buffer, len);
430                 w_ctr(ppb, 0xc);
431                 break;
432
433         case IMM_PS2:
434                 /* 8 bit input, with a loop */
435                 r = imm_byte_in(ppb, buffer, len);
436                 w_ctr(ppb, 0xc);
437                 break;
438
439         case IMM_EPP_32:
440         case IMM_EPP_16:
441         case IMM_EPP_8:
442                 epp_reset(ppb);
443                 w_ctr(ppb, 0x24);
444 #ifdef CONFIG_SCSI_IZIP_EPP16
445                 if (!(((long) buffer | len) & 0x01))
446                         insw(ppb + 4, buffer, len >> 1);
447 #else
448                 if (!(((long) buffer | len) & 0x03))
449                         insl(ppb + 4, buffer, len >> 2);
450 #endif
451                 else
452                         insb(ppb + 4, buffer, len);
453                 w_ctr(ppb, 0x2c);
454                 r = !(r_str(ppb) & 0x01);
455                 w_ctr(ppb, 0x2c);
456                 ecp_sync(dev);
457                 break;
458
459         default:
460                 printk("IMM: bug in imm_ins()\n");
461                 r = 0;
462                 break;
463         }
464         return r;
465 }
466
467 static int imm_cpp(unsigned short ppb, unsigned char b)
468 {
469         /*
470          * Comments on udelay values refer to the
471          * Command Packet Protocol (CPP) timing diagram.
472          */
473
474         unsigned char s1, s2, s3;
475         w_ctr(ppb, 0x0c);
476         udelay(2);              /* 1 usec - infinite */
477         w_dtr(ppb, 0xaa);
478         udelay(10);             /* 7 usec - infinite */
479         w_dtr(ppb, 0x55);
480         udelay(10);             /* 7 usec - infinite */
481         w_dtr(ppb, 0x00);
482         udelay(10);             /* 7 usec - infinite */
483         w_dtr(ppb, 0xff);
484         udelay(10);             /* 7 usec - infinite */
485         s1 = r_str(ppb) & 0xb8;
486         w_dtr(ppb, 0x87);
487         udelay(10);             /* 7 usec - infinite */
488         s2 = r_str(ppb) & 0xb8;
489         w_dtr(ppb, 0x78);
490         udelay(10);             /* 7 usec - infinite */
491         s3 = r_str(ppb) & 0x38;
492         /*
493          * Values for b are:
494          * 0000 00aa    Assign address aa to current device
495          * 0010 00aa    Select device aa in EPP Winbond mode
496          * 0010 10aa    Select device aa in EPP mode
497          * 0011 xxxx    Deselect all devices
498          * 0110 00aa    Test device aa
499          * 1101 00aa    Select device aa in ECP mode
500          * 1110 00aa    Select device aa in Compatible mode
501          */
502         w_dtr(ppb, b);
503         udelay(2);              /* 1 usec - infinite */
504         w_ctr(ppb, 0x0c);
505         udelay(10);             /* 7 usec - infinite */
506         w_ctr(ppb, 0x0d);
507         udelay(2);              /* 1 usec - infinite */
508         w_ctr(ppb, 0x0c);
509         udelay(10);             /* 7 usec - infinite */
510         w_dtr(ppb, 0xff);
511         udelay(10);             /* 7 usec - infinite */
512
513         /*
514          * The following table is electrical pin values.
515          * (BSY is inverted at the CTR register)
516          *
517          *       BSY  ACK  POut SEL  Fault
518          * S1    0    X    1    1    1
519          * S2    1    X    0    1    1
520          * S3    L    X    1    1    S
521          *
522          * L => Last device in chain
523          * S => Selected
524          *
525          * Observered values for S1,S2,S3 are:
526          * Disconnect => f8/58/78
527          * Connect    => f8/58/70
528          */
529         if ((s1 == 0xb8) && (s2 == 0x18) && (s3 == 0x30))
530                 return 1;       /* Connected */
531         if ((s1 == 0xb8) && (s2 == 0x18) && (s3 == 0x38))
532                 return 0;       /* Disconnected */
533
534         return -1;              /* No device present */
535 }
536
537 static inline int imm_connect(imm_struct *dev, int flag)
538 {
539         unsigned short ppb = dev->base;
540
541         imm_cpp(ppb, 0xe0);     /* Select device 0 in compatible mode */
542         imm_cpp(ppb, 0x30);     /* Disconnect all devices */
543
544         if ((dev->mode == IMM_EPP_8) ||
545             (dev->mode == IMM_EPP_16) ||
546             (dev->mode == IMM_EPP_32))
547                 return imm_cpp(ppb, 0x28);      /* Select device 0 in EPP mode */
548         return imm_cpp(ppb, 0xe0);      /* Select device 0 in compatible mode */
549 }
550
551 static void imm_disconnect(imm_struct *dev)
552 {
553         imm_cpp(dev->base, 0x30);       /* Disconnect all devices */
554 }
555
556 static int imm_select(imm_struct *dev, int target)
557 {
558         int k;
559         unsigned short ppb = dev->base;
560
561         /*
562          * Firstly we want to make sure there is nothing
563          * holding onto the SCSI bus.
564          */
565         w_ctr(ppb, 0xc);
566
567         k = IMM_SELECT_TMO;
568         do {
569                 k--;
570         } while ((r_str(ppb) & 0x08) && (k));
571
572         if (!k)
573                 return 0;
574
575         /*
576          * Now assert the SCSI ID (HOST and TARGET) on the data bus
577          */
578         w_ctr(ppb, 0x4);
579         w_dtr(ppb, 0x80 | (1 << target));
580         udelay(1);
581
582         /*
583          * Deassert SELIN first followed by STROBE
584          */
585         w_ctr(ppb, 0xc);
586         w_ctr(ppb, 0xd);
587
588         /*
589          * ACK should drop low while SELIN is deasserted.
590          * FAULT should drop low when the SCSI device latches the bus.
591          */
592         k = IMM_SELECT_TMO;
593         do {
594                 k--;
595         }
596         while (!(r_str(ppb) & 0x08) && (k));
597
598         /*
599          * Place the interface back into a sane state (status mode)
600          */
601         w_ctr(ppb, 0xc);
602         return (k) ? 1 : 0;
603 }
604
605 static int imm_init(imm_struct *dev)
606 {
607         if (imm_connect(dev, 0) != 1)
608                 return -EIO;
609         imm_reset_pulse(dev->base);
610         mdelay(1);      /* Delay to allow devices to settle */
611         imm_disconnect(dev);
612         mdelay(1);      /* Another delay to allow devices to settle */
613         return device_check(dev);
614 }
615
616 static inline int imm_send_command(struct scsi_cmnd *cmd)
617 {
618         imm_struct *dev = imm_dev(cmd->device->host);
619         int k;
620
621         /* NOTE: IMM uses byte pairs */
622         for (k = 0; k < cmd->cmd_len; k += 2)
623                 if (!imm_out(dev, &cmd->cmnd[k], 2))
624                         return 0;
625         return 1;
626 }
627
628 /*
629  * The bulk flag enables some optimisations in the data transfer loops,
630  * it should be true for any command that transfers data in integral
631  * numbers of sectors.
632  * 
633  * The driver appears to remain stable if we speed up the parallel port
634  * i/o in this function, but not elsewhere.
635  */
636 static int imm_completion(struct scsi_cmnd *cmd)
637 {
638         /* Return codes:
639          * -1     Error
640          *  0     Told to schedule
641          *  1     Finished data transfer
642          */
643         imm_struct *dev = imm_dev(cmd->device->host);
644         unsigned short ppb = dev->base;
645         unsigned long start_jiffies = jiffies;
646
647         unsigned char r, v;
648         int fast, bulk, status;
649
650         v = cmd->cmnd[0];
651         bulk = ((v == READ_6) ||
652                 (v == READ_10) || (v == WRITE_6) || (v == WRITE_10));
653
654         /*
655          * We only get here if the drive is ready to comunicate,
656          * hence no need for a full imm_wait.
657          */
658         w_ctr(ppb, 0x0c);
659         r = (r_str(ppb) & 0xb8);
660
661         /*
662          * while (device is not ready to send status byte)
663          *     loop;
664          */
665         while (r != (unsigned char) 0xb8) {
666                 /*
667                  * If we have been running for more than a full timer tick
668                  * then take a rest.
669                  */
670                 if (time_after(jiffies, start_jiffies + 1))
671                         return 0;
672
673                 /*
674                  * FAIL if:
675                  * a) Drive status is screwy (!ready && !present)
676                  * b) Drive is requesting/sending more data than expected
677                  */
678                 if (((r & 0x88) != 0x88) || (cmd->SCp.this_residual <= 0)) {
679                         imm_fail(dev, DID_ERROR);
680                         return -1;      /* ERROR_RETURN */
681                 }
682                 /* determine if we should use burst I/O */
683                 if (dev->rd == 0) {
684                         fast = (bulk
685                                 && (cmd->SCp.this_residual >=
686                                     IMM_BURST_SIZE)) ? IMM_BURST_SIZE : 2;
687                         status = imm_out(dev, cmd->SCp.ptr, fast);
688                 } else {
689                         fast = (bulk
690                                 && (cmd->SCp.this_residual >=
691                                     IMM_BURST_SIZE)) ? IMM_BURST_SIZE : 1;
692                         status = imm_in(dev, cmd->SCp.ptr, fast);
693                 }
694
695                 cmd->SCp.ptr += fast;
696                 cmd->SCp.this_residual -= fast;
697
698                 if (!status) {
699                         imm_fail(dev, DID_BUS_BUSY);
700                         return -1;      /* ERROR_RETURN */
701                 }
702                 if (cmd->SCp.buffer && !cmd->SCp.this_residual) {
703                         /* if scatter/gather, advance to the next segment */
704                         if (cmd->SCp.buffers_residual--) {
705                                 cmd->SCp.buffer++;
706                                 cmd->SCp.this_residual =
707                                     cmd->SCp.buffer->length;
708                                 cmd->SCp.ptr =
709                                     page_address(cmd->SCp.buffer->page) +
710                                     cmd->SCp.buffer->offset;
711
712                                 /*
713                                  * Make sure that we transfer even number of bytes
714                                  * otherwise it makes imm_byte_out() messy.
715                                  */
716                                 if (cmd->SCp.this_residual & 0x01)
717                                         cmd->SCp.this_residual++;
718                         }
719                 }
720                 /* Now check to see if the drive is ready to comunicate */
721                 w_ctr(ppb, 0x0c);
722                 r = (r_str(ppb) & 0xb8);
723
724                 /* If not, drop back down to the scheduler and wait a timer tick */
725                 if (!(r & 0x80))
726                         return 0;
727         }
728         return 1;               /* FINISH_RETURN */
729 }
730
731 /*
732  * Since the IMM itself doesn't generate interrupts, we use
733  * the scheduler's task queue to generate a stream of call-backs and
734  * complete the request when the drive is ready.
735  */
736 static void imm_interrupt(void *data)
737 {
738         imm_struct *dev = (imm_struct *) data;
739         struct scsi_cmnd *cmd = dev->cur_cmd;
740         struct Scsi_Host *host = cmd->device->host;
741         unsigned long flags;
742
743         if (!cmd) {
744                 printk("IMM: bug in imm_interrupt\n");
745                 return;
746         }
747         if (imm_engine(dev, cmd)) {
748                 INIT_WORK(&dev->imm_tq, imm_interrupt, (void *) dev);
749                 schedule_delayed_work(&dev->imm_tq, 1);
750                 return;
751         }
752         /* Command must of completed hence it is safe to let go... */
753 #if IMM_DEBUG > 0
754         switch ((cmd->result >> 16) & 0xff) {
755         case DID_OK:
756                 break;
757         case DID_NO_CONNECT:
758                 printk("imm: no device at SCSI ID %i\n", cmd->device->id);
759                 break;
760         case DID_BUS_BUSY:
761                 printk("imm: BUS BUSY - EPP timeout detected\n");
762                 break;
763         case DID_TIME_OUT:
764                 printk("imm: unknown timeout\n");
765                 break;
766         case DID_ABORT:
767                 printk("imm: told to abort\n");
768                 break;
769         case DID_PARITY:
770                 printk("imm: parity error (???)\n");
771                 break;
772         case DID_ERROR:
773                 printk("imm: internal driver error\n");
774                 break;
775         case DID_RESET:
776                 printk("imm: told to reset device\n");
777                 break;
778         case DID_BAD_INTR:
779                 printk("imm: bad interrupt (???)\n");
780                 break;
781         default:
782                 printk("imm: bad return code (%02x)\n",
783                        (cmd->result >> 16) & 0xff);
784         }
785 #endif
786
787         if (cmd->SCp.phase > 1)
788                 imm_disconnect(dev);
789
790         imm_pb_dismiss(dev);
791
792         spin_lock_irqsave(host->host_lock, flags);
793         dev->cur_cmd = NULL;
794         cmd->scsi_done(cmd);
795         spin_unlock_irqrestore(host->host_lock, flags);
796         return;
797 }
798
799 static int imm_engine(imm_struct *dev, struct scsi_cmnd *cmd)
800 {
801         unsigned short ppb = dev->base;
802         unsigned char l = 0, h = 0;
803         int retv, x;
804
805         /* First check for any errors that may have occurred
806          * Here we check for internal errors
807          */
808         if (dev->failed)
809                 return 0;
810
811         switch (cmd->SCp.phase) {
812         case 0:         /* Phase 0 - Waiting for parport */
813                 if (time_after(jiffies, dev->jstart + HZ)) {
814                         /*
815                          * We waited more than a second
816                          * for parport to call us
817                          */
818                         imm_fail(dev, DID_BUS_BUSY);
819                         return 0;
820                 }
821                 return 1;       /* wait until imm_wakeup claims parport */
822                 /* Phase 1 - Connected */
823         case 1:
824                 imm_connect(dev, CONNECT_EPP_MAYBE);
825                 cmd->SCp.phase++;
826
827                 /* Phase 2 - We are now talking to the scsi bus */
828         case 2:
829                 if (!imm_select(dev, scmd_id(cmd))) {
830                         imm_fail(dev, DID_NO_CONNECT);
831                         return 0;
832                 }
833                 cmd->SCp.phase++;
834
835                 /* Phase 3 - Ready to accept a command */
836         case 3:
837                 w_ctr(ppb, 0x0c);
838                 if (!(r_str(ppb) & 0x80))
839                         return 1;
840
841                 if (!imm_send_command(cmd))
842                         return 0;
843                 cmd->SCp.phase++;
844
845                 /* Phase 4 - Setup scatter/gather buffers */
846         case 4:
847                 if (cmd->use_sg) {
848                         /* if many buffers are available, start filling the first */
849                         cmd->SCp.buffer =
850                             (struct scatterlist *) cmd->request_buffer;
851                         cmd->SCp.this_residual = cmd->SCp.buffer->length;
852                         cmd->SCp.ptr =
853                             page_address(cmd->SCp.buffer->page) +
854                             cmd->SCp.buffer->offset;
855                 } else {
856                         /* else fill the only available buffer */
857                         cmd->SCp.buffer = NULL;
858                         cmd->SCp.this_residual = cmd->request_bufflen;
859                         cmd->SCp.ptr = cmd->request_buffer;
860                 }
861                 cmd->SCp.buffers_residual = cmd->use_sg - 1;
862                 cmd->SCp.phase++;
863                 if (cmd->SCp.this_residual & 0x01)
864                         cmd->SCp.this_residual++;
865                 /* Phase 5 - Pre-Data transfer stage */
866         case 5:
867                 /* Spin lock for BUSY */
868                 w_ctr(ppb, 0x0c);
869                 if (!(r_str(ppb) & 0x80))
870                         return 1;
871
872                 /* Require negotiation for read requests */
873                 x = (r_str(ppb) & 0xb8);
874                 dev->rd = (x & 0x10) ? 1 : 0;
875                 dev->dp = (x & 0x20) ? 0 : 1;
876
877                 if ((dev->dp) && (dev->rd))
878                         if (imm_negotiate(dev))
879                                 return 0;
880                 cmd->SCp.phase++;
881
882                 /* Phase 6 - Data transfer stage */
883         case 6:
884                 /* Spin lock for BUSY */
885                 w_ctr(ppb, 0x0c);
886                 if (!(r_str(ppb) & 0x80))
887                         return 1;
888
889                 if (dev->dp) {
890                         retv = imm_completion(cmd);
891                         if (retv == -1)
892                                 return 0;
893                         if (retv == 0)
894                                 return 1;
895                 }
896                 cmd->SCp.phase++;
897
898                 /* Phase 7 - Post data transfer stage */
899         case 7:
900                 if ((dev->dp) && (dev->rd)) {
901                         if ((dev->mode == IMM_NIBBLE) || (dev->mode == IMM_PS2)) {
902                                 w_ctr(ppb, 0x4);
903                                 w_ctr(ppb, 0xc);
904                                 w_ctr(ppb, 0xe);
905                                 w_ctr(ppb, 0x4);
906                         }
907                 }
908                 cmd->SCp.phase++;
909
910                 /* Phase 8 - Read status/message */
911         case 8:
912                 /* Check for data overrun */
913                 if (imm_wait(dev) != (unsigned char) 0xb8) {
914                         imm_fail(dev, DID_ERROR);
915                         return 0;
916                 }
917                 if (imm_negotiate(dev))
918                         return 0;
919                 if (imm_in(dev, &l, 1)) {       /* read status byte */
920                         /* Check for optional message byte */
921                         if (imm_wait(dev) == (unsigned char) 0xb8)
922                                 imm_in(dev, &h, 1);
923                         cmd->result = (DID_OK << 16) + (l & STATUS_MASK);
924                 }
925                 if ((dev->mode == IMM_NIBBLE) || (dev->mode == IMM_PS2)) {
926                         w_ctr(ppb, 0x4);
927                         w_ctr(ppb, 0xc);
928                         w_ctr(ppb, 0xe);
929                         w_ctr(ppb, 0x4);
930                 }
931                 return 0;       /* Finished */
932                 break;
933
934         default:
935                 printk("imm: Invalid scsi phase\n");
936         }
937         return 0;
938 }
939
940 static int imm_queuecommand(struct scsi_cmnd *cmd,
941                 void (*done)(struct scsi_cmnd *))
942 {
943         imm_struct *dev = imm_dev(cmd->device->host);
944
945         if (dev->cur_cmd) {
946                 printk("IMM: bug in imm_queuecommand\n");
947                 return 0;
948         }
949         dev->failed = 0;
950         dev->jstart = jiffies;
951         dev->cur_cmd = cmd;
952         cmd->scsi_done = done;
953         cmd->result = DID_ERROR << 16;  /* default return code */
954         cmd->SCp.phase = 0;     /* bus free */
955
956         INIT_WORK(&dev->imm_tq, imm_interrupt, dev);
957         schedule_work(&dev->imm_tq);
958
959         imm_pb_claim(dev);
960
961         return 0;
962 }
963
964 /*
965  * Apparently the disk->capacity attribute is off by 1 sector 
966  * for all disk drives.  We add the one here, but it should really
967  * be done in sd.c.  Even if it gets fixed there, this will still
968  * work.
969  */
970 static int imm_biosparam(struct scsi_device *sdev, struct block_device *dev,
971                          sector_t capacity, int ip[])
972 {
973         ip[0] = 0x40;
974         ip[1] = 0x20;
975         ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);
976         if (ip[2] > 1024) {
977                 ip[0] = 0xff;
978                 ip[1] = 0x3f;
979                 ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);
980         }
981         return 0;
982 }
983
984 static int imm_abort(struct scsi_cmnd *cmd)
985 {
986         imm_struct *dev = imm_dev(cmd->device->host);
987         /*
988          * There is no method for aborting commands since Iomega
989          * have tied the SCSI_MESSAGE line high in the interface
990          */
991
992         switch (cmd->SCp.phase) {
993         case 0:         /* Do not have access to parport */
994         case 1:         /* Have not connected to interface */
995                 dev->cur_cmd = NULL;    /* Forget the problem */
996                 return SUCCESS;
997                 break;
998         default:                /* SCSI command sent, can not abort */
999                 return FAILED;
1000                 break;
1001         }
1002 }
1003
1004 static void imm_reset_pulse(unsigned int base)
1005 {
1006         w_ctr(base, 0x04);
1007         w_dtr(base, 0x40);
1008         udelay(1);
1009         w_ctr(base, 0x0c);
1010         w_ctr(base, 0x0d);
1011         udelay(50);
1012         w_ctr(base, 0x0c);
1013         w_ctr(base, 0x04);
1014 }
1015
1016 static int imm_reset(struct scsi_cmnd *cmd)
1017 {
1018         imm_struct *dev = imm_dev(cmd->device->host);
1019
1020         if (cmd->SCp.phase)
1021                 imm_disconnect(dev);
1022         dev->cur_cmd = NULL;    /* Forget the problem */
1023
1024         imm_connect(dev, CONNECT_NORMAL);
1025         imm_reset_pulse(dev->base);
1026         mdelay(1);              /* device settle delay */
1027         imm_disconnect(dev);
1028         mdelay(1);              /* device settle delay */
1029         return SUCCESS;
1030 }
1031
1032 static int device_check(imm_struct *dev)
1033 {
1034         /* This routine looks for a device and then attempts to use EPP
1035            to send a command. If all goes as planned then EPP is available. */
1036
1037         static char cmd[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
1038         int loop, old_mode, status, k, ppb = dev->base;
1039         unsigned char l;
1040
1041         old_mode = dev->mode;
1042         for (loop = 0; loop < 8; loop++) {
1043                 /* Attempt to use EPP for Test Unit Ready */
1044                 if ((ppb & 0x0007) == 0x0000)
1045                         dev->mode = IMM_EPP_32;
1046
1047               second_pass:
1048                 imm_connect(dev, CONNECT_EPP_MAYBE);
1049                 /* Select SCSI device */
1050                 if (!imm_select(dev, loop)) {
1051                         imm_disconnect(dev);
1052                         continue;
1053                 }
1054                 printk("imm: Found device at ID %i, Attempting to use %s\n",
1055                        loop, IMM_MODE_STRING[dev->mode]);
1056
1057                 /* Send SCSI command */
1058                 status = 1;
1059                 w_ctr(ppb, 0x0c);
1060                 for (l = 0; (l < 3) && (status); l++)
1061                         status = imm_out(dev, &cmd[l << 1], 2);
1062
1063                 if (!status) {
1064                         imm_disconnect(dev);
1065                         imm_connect(dev, CONNECT_EPP_MAYBE);
1066                         imm_reset_pulse(dev->base);
1067                         udelay(1000);
1068                         imm_disconnect(dev);
1069                         udelay(1000);
1070                         if (dev->mode == IMM_EPP_32) {
1071                                 dev->mode = old_mode;
1072                                 goto second_pass;
1073                         }
1074                         printk("imm: Unable to establish communication\n");
1075                         return -EIO;
1076                 }
1077                 w_ctr(ppb, 0x0c);
1078
1079                 k = 1000000;    /* 1 Second */
1080                 do {
1081                         l = r_str(ppb);
1082                         k--;
1083                         udelay(1);
1084                 } while (!(l & 0x80) && (k));
1085
1086                 l &= 0xb8;
1087
1088                 if (l != 0xb8) {
1089                         imm_disconnect(dev);
1090                         imm_connect(dev, CONNECT_EPP_MAYBE);
1091                         imm_reset_pulse(dev->base);
1092                         udelay(1000);
1093                         imm_disconnect(dev);
1094                         udelay(1000);
1095                         if (dev->mode == IMM_EPP_32) {
1096                                 dev->mode = old_mode;
1097                                 goto second_pass;
1098                         }
1099                         printk
1100                             ("imm: Unable to establish communication\n");
1101                         return -EIO;
1102                 }
1103                 imm_disconnect(dev);
1104                 printk
1105                     ("imm: Communication established at 0x%x with ID %i using %s\n",
1106                      ppb, loop, IMM_MODE_STRING[dev->mode]);
1107                 imm_connect(dev, CONNECT_EPP_MAYBE);
1108                 imm_reset_pulse(dev->base);
1109                 udelay(1000);
1110                 imm_disconnect(dev);
1111                 udelay(1000);
1112                 return 0;
1113         }
1114         printk("imm: No devices found\n");
1115         return -ENODEV;
1116 }
1117
1118 /*
1119  * imm cannot deal with highmem, so this causes all IO pages for this host
1120  * to reside in low memory (hence mapped)
1121  */
1122 static int imm_adjust_queue(struct scsi_device *device)
1123 {
1124         blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
1125         return 0;
1126 }
1127
1128 static struct scsi_host_template imm_template = {
1129         .module                 = THIS_MODULE,
1130         .proc_name              = "imm",
1131         .proc_info              = imm_proc_info,
1132         .name                   = "Iomega VPI2 (imm) interface",
1133         .queuecommand           = imm_queuecommand,
1134         .eh_abort_handler       = imm_abort,
1135         .eh_bus_reset_handler   = imm_reset,
1136         .eh_host_reset_handler  = imm_reset,
1137         .bios_param             = imm_biosparam,
1138         .this_id                = 7,
1139         .sg_tablesize           = SG_ALL,
1140         .cmd_per_lun            = 1,
1141         .use_clustering         = ENABLE_CLUSTERING,
1142         .can_queue              = 1,
1143         .slave_alloc            = imm_adjust_queue,
1144 };
1145
1146 /***************************************************************************
1147  *                   Parallel port probing routines                        *
1148  ***************************************************************************/
1149
1150 static LIST_HEAD(imm_hosts);
1151
1152 static int __imm_attach(struct parport *pb)
1153 {
1154         struct Scsi_Host *host;
1155         imm_struct *dev;
1156         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waiting);
1157         DEFINE_WAIT(wait);
1158         int ports;
1159         int modes, ppb;
1160         int err = -ENOMEM;
1161
1162         init_waitqueue_head(&waiting);
1163
1164         dev = kmalloc(sizeof(imm_struct), GFP_KERNEL);
1165         if (!dev)
1166                 return -ENOMEM;
1167
1168         memset(dev, 0, sizeof(imm_struct));
1169
1170         dev->base = -1;
1171         dev->mode = IMM_AUTODETECT;
1172         INIT_LIST_HEAD(&dev->list);
1173
1174         dev->dev = parport_register_device(pb, "imm", NULL, imm_wakeup,
1175                                                 NULL, 0, dev);
1176
1177         if (!dev->dev)
1178                 goto out;
1179
1180
1181         /* Claim the bus so it remembers what we do to the control
1182          * registers. [ CTR and ECP ]
1183          */
1184         err = -EBUSY;
1185         dev->waiting = &waiting;
1186         prepare_to_wait(&waiting, &wait, TASK_UNINTERRUPTIBLE);
1187         if (imm_pb_claim(dev))
1188                 schedule_timeout(3 * HZ);
1189         if (dev->wanted) {
1190                 printk(KERN_ERR "imm%d: failed to claim parport because "
1191                         "a pardevice is owning the port for too long "
1192                         "time!\n", pb->number);
1193                 imm_pb_dismiss(dev);
1194                 dev->waiting = NULL;
1195                 finish_wait(&waiting, &wait);
1196                 goto out1;
1197         }
1198         dev->waiting = NULL;
1199         finish_wait(&waiting, &wait);
1200         ppb = dev->base = dev->dev->port->base;
1201         dev->base_hi = dev->dev->port->base_hi;
1202         w_ctr(ppb, 0x0c);
1203         modes = dev->dev->port->modes;
1204
1205         /* Mode detection works up the chain of speed
1206          * This avoids a nasty if-then-else-if-... tree
1207          */
1208         dev->mode = IMM_NIBBLE;
1209
1210         if (modes & PARPORT_MODE_TRISTATE)
1211                 dev->mode = IMM_PS2;
1212
1213         /* Done configuration */
1214
1215         err = imm_init(dev);
1216
1217         imm_pb_release(dev);
1218
1219         if (err)
1220                 goto out1;
1221
1222         /* now the glue ... */
1223         if (dev->mode == IMM_NIBBLE || dev->mode == IMM_PS2)
1224                 ports = 3;
1225         else
1226                 ports = 8;
1227
1228         INIT_WORK(&dev->imm_tq, imm_interrupt, dev);
1229
1230         err = -ENOMEM;
1231         host = scsi_host_alloc(&imm_template, sizeof(imm_struct *));
1232         if (!host)
1233                 goto out1;
1234         host->io_port = pb->base;
1235         host->n_io_port = ports;
1236         host->dma_channel = -1;
1237         host->unique_id = pb->number;
1238         *(imm_struct **)&host->hostdata = dev;
1239         dev->host = host;
1240         list_add_tail(&dev->list, &imm_hosts);
1241         err = scsi_add_host(host, NULL);
1242         if (err)
1243                 goto out2;
1244         scsi_scan_host(host);
1245         return 0;
1246
1247 out2:
1248         list_del_init(&dev->list);
1249         scsi_host_put(host);
1250 out1:
1251         parport_unregister_device(dev->dev);
1252 out:
1253         kfree(dev);
1254         return err;
1255 }
1256
1257 static void imm_attach(struct parport *pb)
1258 {
1259         __imm_attach(pb);
1260 }
1261
1262 static void imm_detach(struct parport *pb)
1263 {
1264         imm_struct *dev;
1265         list_for_each_entry(dev, &imm_hosts, list) {
1266                 if (dev->dev->port == pb) {
1267                         list_del_init(&dev->list);
1268                         scsi_remove_host(dev->host);
1269                         scsi_host_put(dev->host);
1270                         parport_unregister_device(dev->dev);
1271                         kfree(dev);
1272                         break;
1273                 }
1274         }
1275 }
1276
1277 static struct parport_driver imm_driver = {
1278         .name   = "imm",
1279         .attach = imm_attach,
1280         .detach = imm_detach,
1281 };
1282
1283 static int __init imm_driver_init(void)
1284 {
1285         printk("imm: Version %s\n", IMM_VERSION);
1286         return parport_register_driver(&imm_driver);
1287 }
1288
1289 static void __exit imm_driver_exit(void)
1290 {
1291         parport_unregister_driver(&imm_driver);
1292 }
1293
1294 module_init(imm_driver_init);
1295 module_exit(imm_driver_exit);
1296
1297 MODULE_LICENSE("GPL");