linux/drivers/scsi/imm.c
<<
>>
Prefs
   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
  34typedef 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
  51static void imm_reset_pulse(unsigned int base);
  52static int device_check(imm_struct *dev);
  53
  54#include "imm.h"
  55
  56static inline imm_struct *imm_dev(struct Scsi_Host *host)
  57{
  58        return *(imm_struct **)&host->hostdata;
  59}
  60
  61static DEFINE_SPINLOCK(arbitration_lock);
  62
  63static 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
  72static 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
  86static 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
 100static 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
 112static 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 */
 124static 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
 136static 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);
 149static inline void
 150imm_fail_func(imm_struct *dev, int error_code)
 151#else
 152static inline void
 153imm_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 */
 170static 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
 215static 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 */
 266static 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 */
 278static 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
 295static 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
 310static 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
 329static 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
 345static 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
 394static 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
 449static 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
 519static 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
 533static void imm_disconnect(imm_struct *dev)
 534{
 535        imm_cpp(dev->base, 0x30);       /* Disconnect all devices */
 536}
 537
 538static 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
 587static 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
 598static 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 */
 618static 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 */
 716static 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
 774static 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
 910static 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
 933static 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 */
 941static 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
 955static 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
 975static 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
 987static 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
1003static 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 */
1093static 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
1099static 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
1122static LIST_HEAD(imm_hosts);
1123
1124static 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
1218out2:
1219        list_del_init(&dev->list);
1220        scsi_host_put(host);
1221out1:
1222        parport_unregister_device(dev->dev);
1223out:
1224        kfree(dev);
1225        return err;
1226}
1227
1228static void imm_attach(struct parport *pb)
1229{
1230        __imm_attach(pb);
1231}
1232
1233static 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
1248static struct parport_driver imm_driver = {
1249        .name   = "imm",
1250        .attach = imm_attach,
1251        .detach = imm_detach,
1252};
1253
1254static int __init imm_driver_init(void)
1255{
1256        printk("imm: Version %s\n", IMM_VERSION);
1257        return parport_register_driver(&imm_driver);
1258}
1259
1260static void __exit imm_driver_exit(void)
1261{
1262        parport_unregister_driver(&imm_driver);
1263}
1264
1265module_init(imm_driver_init);
1266module_exit(imm_driver_exit);
1267
1268MODULE_LICENSE("GPL");
1269
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.