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