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