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