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