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