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