drivers/scsi/imm.c

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