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