drivers/scsi/imm.c

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