drivers/scsi/imm.c

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