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