Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /* imm.c   --  low level driver for the IOMEGA MatchMaker
0003  * parallel port SCSI host adapter.
0004  * 
0005  * (The IMM is the embedded controller in the ZIP Plus drive.)
0006  * 
0007  * My unofficial company acronym list is 21 pages long:
0008  *      FLA:    Four letter acronym with built in facility for
0009  *              future expansion to five letters.
0010  */
0011 
0012 #include <linux/init.h>
0013 #include <linux/kernel.h>
0014 #include <linux/module.h>
0015 #include <linux/blkdev.h>
0016 #include <linux/parport.h>
0017 #include <linux/workqueue.h>
0018 #include <linux/delay.h>
0019 #include <linux/slab.h>
0020 #include <asm/io.h>
0021 
0022 #include <scsi/scsi.h>
0023 #include <scsi/scsi_cmnd.h>
0024 #include <scsi/scsi_device.h>
0025 #include <scsi/scsi_host.h>
0026 
0027 /* The following #define is to avoid a clash with hosts.c */
0028 #define IMM_PROBE_SPP   0x0001
0029 #define IMM_PROBE_PS2   0x0002
0030 #define IMM_PROBE_ECR   0x0010
0031 #define IMM_PROBE_EPP17 0x0100
0032 #define IMM_PROBE_EPP19 0x0200
0033 
0034 
0035 typedef struct {
0036     struct pardevice *dev;  /* Parport device entry         */
0037     int base;       /* Actual port address          */
0038     int base_hi;        /* Hi Base address for ECP-ISA chipset */
0039     int mode;       /* Transfer mode                */
0040     struct scsi_cmnd *cur_cmd;  /* Current queued command       */
0041     struct delayed_work imm_tq; /* Polling interrupt stuff       */
0042     unsigned long jstart;   /* Jiffies at start             */
0043     unsigned failed:1;  /* Failure flag                 */
0044     unsigned dp:1;      /* Data phase present           */
0045     unsigned rd:1;      /* Read data in data phase      */
0046     unsigned wanted:1;  /* Parport sharing busy flag    */
0047     unsigned int dev_no;    /* Device number        */
0048     wait_queue_head_t *waiting;
0049     struct Scsi_Host *host;
0050     struct list_head list;
0051 } imm_struct;
0052 
0053 static void imm_reset_pulse(unsigned int base);
0054 static int device_check(imm_struct *dev);
0055 
0056 #include "imm.h"
0057 
0058 static inline imm_struct *imm_dev(struct Scsi_Host *host)
0059 {
0060     return *(imm_struct **)&host->hostdata;
0061 }
0062 
0063 static DEFINE_SPINLOCK(arbitration_lock);
0064 
0065 static void got_it(imm_struct *dev)
0066 {
0067     dev->base = dev->dev->port->base;
0068     if (dev->cur_cmd)
0069         imm_scsi_pointer(dev->cur_cmd)->phase = 1;
0070     else
0071         wake_up(dev->waiting);
0072 }
0073 
0074 static void imm_wakeup(void *ref)
0075 {
0076     imm_struct *dev = (imm_struct *) ref;
0077     unsigned long flags;
0078 
0079     spin_lock_irqsave(&arbitration_lock, flags);
0080     if (dev->wanted) {
0081         if (parport_claim(dev->dev) == 0) {
0082             got_it(dev);
0083             dev->wanted = 0;
0084         }
0085     }
0086     spin_unlock_irqrestore(&arbitration_lock, flags);
0087 }
0088 
0089 static int imm_pb_claim(imm_struct *dev)
0090 {
0091     unsigned long flags;
0092     int res = 1;
0093     spin_lock_irqsave(&arbitration_lock, flags);
0094     if (parport_claim(dev->dev) == 0) {
0095         got_it(dev);
0096         res = 0;
0097     }
0098     dev->wanted = res;
0099     spin_unlock_irqrestore(&arbitration_lock, flags);
0100     return res;
0101 }
0102 
0103 static void imm_pb_dismiss(imm_struct *dev)
0104 {
0105     unsigned long flags;
0106     int wanted;
0107     spin_lock_irqsave(&arbitration_lock, flags);
0108     wanted = dev->wanted;
0109     dev->wanted = 0;
0110     spin_unlock_irqrestore(&arbitration_lock, flags);
0111     if (!wanted)
0112         parport_release(dev->dev);
0113 }
0114 
0115 static inline void imm_pb_release(imm_struct *dev)
0116 {
0117     parport_release(dev->dev);
0118 }
0119 
0120 /* This is to give the imm driver a way to modify the timings (and other
0121  * parameters) by writing to the /proc/scsi/imm/0 file.
0122  * Very simple method really... (Too simple, no error checking :( )
0123  * Reason: Kernel hackers HATE having to unload and reload modules for
0124  * testing...
0125  * Also gives a method to use a script to obtain optimum timings (TODO)
0126  */
0127 static int imm_write_info(struct Scsi_Host *host, char *buffer, int length)
0128 {
0129     imm_struct *dev = imm_dev(host);
0130 
0131     if ((length > 5) && (strncmp(buffer, "mode=", 5) == 0)) {
0132         dev->mode = simple_strtoul(buffer + 5, NULL, 0);
0133         return length;
0134     }
0135     printk("imm /proc: invalid variable\n");
0136     return -EINVAL;
0137 }
0138 
0139 static int imm_show_info(struct seq_file *m, struct Scsi_Host *host)
0140 {
0141     imm_struct *dev = imm_dev(host);
0142 
0143     seq_printf(m, "Version : %s\n", IMM_VERSION);
0144     seq_printf(m, "Parport : %s\n", dev->dev->port->name);
0145     seq_printf(m, "Mode    : %s\n", IMM_MODE_STRING[dev->mode]);
0146     return 0;
0147 }
0148 
0149 #if IMM_DEBUG > 0
0150 #define imm_fail(x,y) printk("imm: imm_fail(%i) from %s at line %d\n",\
0151        y, __func__, __LINE__); imm_fail_func(x,y);
0152 static inline void
0153 imm_fail_func(imm_struct *dev, int error_code)
0154 #else
0155 static inline void
0156 imm_fail(imm_struct *dev, int error_code)
0157 #endif
0158 {
0159     /* If we fail a device then we trash status / message bytes */
0160     if (dev->cur_cmd) {
0161         dev->cur_cmd->result = error_code << 16;
0162         dev->failed = 1;
0163     }
0164 }
0165 
0166 /*
0167  * Wait for the high bit to be set.
0168  * 
0169  * In principle, this could be tied to an interrupt, but the adapter
0170  * doesn't appear to be designed to support interrupts.  We spin on
0171  * the 0x80 ready bit. 
0172  */
0173 static unsigned char imm_wait(imm_struct *dev)
0174 {
0175     int k;
0176     unsigned short ppb = dev->base;
0177     unsigned char r;
0178 
0179     w_ctr(ppb, 0x0c);
0180 
0181     k = IMM_SPIN_TMO;
0182     do {
0183         r = r_str(ppb);
0184         k--;
0185         udelay(1);
0186     }
0187     while (!(r & 0x80) && (k));
0188 
0189     /*
0190      * STR register (LPT base+1) to SCSI mapping:
0191      *
0192      * STR      imm     imm
0193      * ===================================
0194      * 0x80     S_REQ   S_REQ
0195      * 0x40     !S_BSY  (????)
0196      * 0x20     !S_CD   !S_CD
0197      * 0x10     !S_IO   !S_IO
0198      * 0x08     (????)  !S_BSY
0199      *
0200      * imm      imm     meaning
0201      * ==================================
0202      * 0xf0     0xb8    Bit mask
0203      * 0xc0     0x88    ZIP wants more data
0204      * 0xd0     0x98    ZIP wants to send more data
0205      * 0xe0     0xa8    ZIP is expecting SCSI command data
0206      * 0xf0     0xb8    end of transfer, ZIP is sending status
0207      */
0208     w_ctr(ppb, 0x04);
0209     if (k)
0210         return (r & 0xb8);
0211 
0212     /* Counter expired - Time out occurred */
0213     imm_fail(dev, DID_TIME_OUT);
0214     printk("imm timeout in imm_wait\n");
0215     return 0;       /* command timed out */
0216 }
0217 
0218 static int imm_negotiate(imm_struct * tmp)
0219 {
0220     /*
0221      * The following is supposedly the IEEE 1284-1994 negotiate
0222      * sequence. I have yet to obtain a copy of the above standard
0223      * so this is a bit of a guess...
0224      *
0225      * A fair chunk of this is based on the Linux parport implementation
0226      * of IEEE 1284.
0227      *
0228      * Return 0 if data available
0229      *        1 if no data available
0230      */
0231 
0232     unsigned short base = tmp->base;
0233     unsigned char a, mode;
0234 
0235     switch (tmp->mode) {
0236     case IMM_NIBBLE:
0237         mode = 0x00;
0238         break;
0239     case IMM_PS2:
0240         mode = 0x01;
0241         break;
0242     default:
0243         return 0;
0244     }
0245 
0246     w_ctr(base, 0x04);
0247     udelay(5);
0248     w_dtr(base, mode);
0249     udelay(100);
0250     w_ctr(base, 0x06);
0251     udelay(5);
0252     a = (r_str(base) & 0x20) ? 0 : 1;
0253     udelay(5);
0254     w_ctr(base, 0x07);
0255     udelay(5);
0256     w_ctr(base, 0x06);
0257 
0258     if (a) {
0259         printk
0260             ("IMM: IEEE1284 negotiate indicates no data available.\n");
0261         imm_fail(tmp, DID_ERROR);
0262     }
0263     return a;
0264 }
0265 
0266 /* 
0267  * Clear EPP timeout bit. 
0268  */
0269 static inline void epp_reset(unsigned short ppb)
0270 {
0271     int i;
0272 
0273     i = r_str(ppb);
0274     w_str(ppb, i);
0275     w_str(ppb, i & 0xfe);
0276 }
0277 
0278 /* 
0279  * Wait for empty ECP fifo (if we are in ECP fifo mode only)
0280  */
0281 static inline void ecp_sync(imm_struct *dev)
0282 {
0283     int i, ppb_hi = dev->base_hi;
0284 
0285     if (ppb_hi == 0)
0286         return;
0287 
0288     if ((r_ecr(ppb_hi) & 0xe0) == 0x60) {   /* mode 011 == ECP fifo mode */
0289         for (i = 0; i < 100; i++) {
0290             if (r_ecr(ppb_hi) & 0x01)
0291                 return;
0292             udelay(5);
0293         }
0294         printk("imm: ECP sync failed as data still present in FIFO.\n");
0295     }
0296 }
0297 
0298 static int imm_byte_out(unsigned short base, const char *buffer, int len)
0299 {
0300     int i;
0301 
0302     w_ctr(base, 0x4);   /* apparently a sane mode */
0303     for (i = len >> 1; i; i--) {
0304         w_dtr(base, *buffer++);
0305         w_ctr(base, 0x5);   /* Drop STROBE low */
0306         w_dtr(base, *buffer++);
0307         w_ctr(base, 0x0);   /* STROBE high + INIT low */
0308     }
0309     w_ctr(base, 0x4);   /* apparently a sane mode */
0310     return 1;       /* All went well - we hope! */
0311 }
0312 
0313 static int imm_nibble_in(unsigned short base, char *buffer, int len)
0314 {
0315     unsigned char l;
0316     int i;
0317 
0318     /*
0319      * The following is based on documented timing signals
0320      */
0321     w_ctr(base, 0x4);
0322     for (i = len; i; i--) {
0323         w_ctr(base, 0x6);
0324         l = (r_str(base) & 0xf0) >> 4;
0325         w_ctr(base, 0x5);
0326         *buffer++ = (r_str(base) & 0xf0) | l;
0327         w_ctr(base, 0x4);
0328     }
0329     return 1;       /* All went well - we hope! */
0330 }
0331 
0332 static int imm_byte_in(unsigned short base, char *buffer, int len)
0333 {
0334     int i;
0335 
0336     /*
0337      * The following is based on documented timing signals
0338      */
0339     w_ctr(base, 0x4);
0340     for (i = len; i; i--) {
0341         w_ctr(base, 0x26);
0342         *buffer++ = r_dtr(base);
0343         w_ctr(base, 0x25);
0344     }
0345     return 1;       /* All went well - we hope! */
0346 }
0347 
0348 static int imm_out(imm_struct *dev, char *buffer, int len)
0349 {
0350     unsigned short ppb = dev->base;
0351     int r = imm_wait(dev);
0352 
0353     /*
0354      * Make sure that:
0355      * a) the SCSI bus is BUSY (device still listening)
0356      * b) the device is listening
0357      */
0358     if ((r & 0x18) != 0x08) {
0359         imm_fail(dev, DID_ERROR);
0360         printk("IMM: returned SCSI status %2x\n", r);
0361         return 0;
0362     }
0363     switch (dev->mode) {
0364     case IMM_EPP_32:
0365     case IMM_EPP_16:
0366     case IMM_EPP_8:
0367         epp_reset(ppb);
0368         w_ctr(ppb, 0x4);
0369 #ifdef CONFIG_SCSI_IZIP_EPP16
0370         if (!(((long) buffer | len) & 0x01))
0371             outsw(ppb + 4, buffer, len >> 1);
0372 #else
0373         if (!(((long) buffer | len) & 0x03))
0374             outsl(ppb + 4, buffer, len >> 2);
0375 #endif
0376         else
0377             outsb(ppb + 4, buffer, len);
0378         w_ctr(ppb, 0xc);
0379         r = !(r_str(ppb) & 0x01);
0380         w_ctr(ppb, 0xc);
0381         ecp_sync(dev);
0382         break;
0383 
0384     case IMM_NIBBLE:
0385     case IMM_PS2:
0386         /* 8 bit output, with a loop */
0387         r = imm_byte_out(ppb, buffer, len);
0388         break;
0389 
0390     default:
0391         printk("IMM: bug in imm_out()\n");
0392         r = 0;
0393     }
0394     return r;
0395 }
0396 
0397 static int imm_in(imm_struct *dev, char *buffer, int len)
0398 {
0399     unsigned short ppb = dev->base;
0400     int r = imm_wait(dev);
0401 
0402     /*
0403      * Make sure that:
0404      * a) the SCSI bus is BUSY (device still listening)
0405      * b) the device is sending data
0406      */
0407     if ((r & 0x18) != 0x18) {
0408         imm_fail(dev, DID_ERROR);
0409         return 0;
0410     }
0411     switch (dev->mode) {
0412     case IMM_NIBBLE:
0413         /* 4 bit input, with a loop */
0414         r = imm_nibble_in(ppb, buffer, len);
0415         w_ctr(ppb, 0xc);
0416         break;
0417 
0418     case IMM_PS2:
0419         /* 8 bit input, with a loop */
0420         r = imm_byte_in(ppb, buffer, len);
0421         w_ctr(ppb, 0xc);
0422         break;
0423 
0424     case IMM_EPP_32:
0425     case IMM_EPP_16:
0426     case IMM_EPP_8:
0427         epp_reset(ppb);
0428         w_ctr(ppb, 0x24);
0429 #ifdef CONFIG_SCSI_IZIP_EPP16
0430         if (!(((long) buffer | len) & 0x01))
0431             insw(ppb + 4, buffer, len >> 1);
0432 #else
0433         if (!(((long) buffer | len) & 0x03))
0434             insl(ppb + 4, buffer, len >> 2);
0435 #endif
0436         else
0437             insb(ppb + 4, buffer, len);
0438         w_ctr(ppb, 0x2c);
0439         r = !(r_str(ppb) & 0x01);
0440         w_ctr(ppb, 0x2c);
0441         ecp_sync(dev);
0442         break;
0443 
0444     default:
0445         printk("IMM: bug in imm_ins()\n");
0446         r = 0;
0447         break;
0448     }
0449     return r;
0450 }
0451 
0452 static int imm_cpp(unsigned short ppb, unsigned char b)
0453 {
0454     /*
0455      * Comments on udelay values refer to the
0456      * Command Packet Protocol (CPP) timing diagram.
0457      */
0458 
0459     unsigned char s1, s2, s3;
0460     w_ctr(ppb, 0x0c);
0461     udelay(2);      /* 1 usec - infinite */
0462     w_dtr(ppb, 0xaa);
0463     udelay(10);     /* 7 usec - infinite */
0464     w_dtr(ppb, 0x55);
0465     udelay(10);     /* 7 usec - infinite */
0466     w_dtr(ppb, 0x00);
0467     udelay(10);     /* 7 usec - infinite */
0468     w_dtr(ppb, 0xff);
0469     udelay(10);     /* 7 usec - infinite */
0470     s1 = r_str(ppb) & 0xb8;
0471     w_dtr(ppb, 0x87);
0472     udelay(10);     /* 7 usec - infinite */
0473     s2 = r_str(ppb) & 0xb8;
0474     w_dtr(ppb, 0x78);
0475     udelay(10);     /* 7 usec - infinite */
0476     s3 = r_str(ppb) & 0x38;
0477     /*
0478      * Values for b are:
0479      * 0000 00aa    Assign address aa to current device
0480      * 0010 00aa    Select device aa in EPP Winbond mode
0481      * 0010 10aa    Select device aa in EPP mode
0482      * 0011 xxxx    Deselect all devices
0483      * 0110 00aa    Test device aa
0484      * 1101 00aa    Select device aa in ECP mode
0485      * 1110 00aa    Select device aa in Compatible mode
0486      */
0487     w_dtr(ppb, b);
0488     udelay(2);      /* 1 usec - infinite */
0489     w_ctr(ppb, 0x0c);
0490     udelay(10);     /* 7 usec - infinite */
0491     w_ctr(ppb, 0x0d);
0492     udelay(2);      /* 1 usec - infinite */
0493     w_ctr(ppb, 0x0c);
0494     udelay(10);     /* 7 usec - infinite */
0495     w_dtr(ppb, 0xff);
0496     udelay(10);     /* 7 usec - infinite */
0497 
0498     /*
0499      * The following table is electrical pin values.
0500      * (BSY is inverted at the CTR register)
0501      *
0502      *       BSY  ACK  POut SEL  Fault
0503      * S1    0    X    1    1    1
0504      * S2    1    X    0    1    1
0505      * S3    L    X    1    1    S
0506      *
0507      * L => Last device in chain
0508      * S => Selected
0509      *
0510      * Observered values for S1,S2,S3 are:
0511      * Disconnect => f8/58/78
0512      * Connect    => f8/58/70
0513      */
0514     if ((s1 == 0xb8) && (s2 == 0x18) && (s3 == 0x30))
0515         return 1;   /* Connected */
0516     if ((s1 == 0xb8) && (s2 == 0x18) && (s3 == 0x38))
0517         return 0;   /* Disconnected */
0518 
0519     return -1;      /* No device present */
0520 }
0521 
0522 static inline int imm_connect(imm_struct *dev, int flag)
0523 {
0524     unsigned short ppb = dev->base;
0525 
0526     imm_cpp(ppb, 0xe0); /* Select device 0 in compatible mode */
0527     imm_cpp(ppb, 0x30); /* Disconnect all devices */
0528 
0529     if ((dev->mode == IMM_EPP_8) ||
0530         (dev->mode == IMM_EPP_16) ||
0531         (dev->mode == IMM_EPP_32))
0532         return imm_cpp(ppb, 0x28);  /* Select device 0 in EPP mode */
0533     return imm_cpp(ppb, 0xe0);  /* Select device 0 in compatible mode */
0534 }
0535 
0536 static void imm_disconnect(imm_struct *dev)
0537 {
0538     imm_cpp(dev->base, 0x30);   /* Disconnect all devices */
0539 }
0540 
0541 static int imm_select(imm_struct *dev, int target)
0542 {
0543     int k;
0544     unsigned short ppb = dev->base;
0545 
0546     /*
0547      * Firstly we want to make sure there is nothing
0548      * holding onto the SCSI bus.
0549      */
0550     w_ctr(ppb, 0xc);
0551 
0552     k = IMM_SELECT_TMO;
0553     do {
0554         k--;
0555     } while ((r_str(ppb) & 0x08) && (k));
0556 
0557     if (!k)
0558         return 0;
0559 
0560     /*
0561      * Now assert the SCSI ID (HOST and TARGET) on the data bus
0562      */
0563     w_ctr(ppb, 0x4);
0564     w_dtr(ppb, 0x80 | (1 << target));
0565     udelay(1);
0566 
0567     /*
0568      * Deassert SELIN first followed by STROBE
0569      */
0570     w_ctr(ppb, 0xc);
0571     w_ctr(ppb, 0xd);
0572 
0573     /*
0574      * ACK should drop low while SELIN is deasserted.
0575      * FAULT should drop low when the SCSI device latches the bus.
0576      */
0577     k = IMM_SELECT_TMO;
0578     do {
0579         k--;
0580     }
0581     while (!(r_str(ppb) & 0x08) && (k));
0582 
0583     /*
0584      * Place the interface back into a sane state (status mode)
0585      */
0586     w_ctr(ppb, 0xc);
0587     return (k) ? 1 : 0;
0588 }
0589 
0590 static int imm_init(imm_struct *dev)
0591 {
0592     if (imm_connect(dev, 0) != 1)
0593         return -EIO;
0594     imm_reset_pulse(dev->base);
0595     mdelay(1);  /* Delay to allow devices to settle */
0596     imm_disconnect(dev);
0597     mdelay(1);  /* Another delay to allow devices to settle */
0598     return device_check(dev);
0599 }
0600 
0601 static inline int imm_send_command(struct scsi_cmnd *cmd)
0602 {
0603     imm_struct *dev = imm_dev(cmd->device->host);
0604     int k;
0605 
0606     /* NOTE: IMM uses byte pairs */
0607     for (k = 0; k < cmd->cmd_len; k += 2)
0608         if (!imm_out(dev, &cmd->cmnd[k], 2))
0609             return 0;
0610     return 1;
0611 }
0612 
0613 /*
0614  * The bulk flag enables some optimisations in the data transfer loops,
0615  * it should be true for any command that transfers data in integral
0616  * numbers of sectors.
0617  * 
0618  * The driver appears to remain stable if we speed up the parallel port
0619  * i/o in this function, but not elsewhere.
0620  */
0621 static int imm_completion(struct scsi_cmnd *const cmd)
0622 {
0623     /* Return codes:
0624      * -1     Error
0625      *  0     Told to schedule
0626      *  1     Finished data transfer
0627      */
0628     struct scsi_pointer *scsi_pointer = imm_scsi_pointer(cmd);
0629     imm_struct *dev = imm_dev(cmd->device->host);
0630     unsigned short ppb = dev->base;
0631     unsigned long start_jiffies = jiffies;
0632 
0633     unsigned char r, v;
0634     int fast, bulk, status;
0635 
0636     v = cmd->cmnd[0];
0637     bulk = ((v == READ_6) ||
0638         (v == READ_10) || (v == WRITE_6) || (v == WRITE_10));
0639 
0640     /*
0641      * We only get here if the drive is ready to comunicate,
0642      * hence no need for a full imm_wait.
0643      */
0644     w_ctr(ppb, 0x0c);
0645     r = (r_str(ppb) & 0xb8);
0646 
0647     /*
0648      * while (device is not ready to send status byte)
0649      *     loop;
0650      */
0651     while (r != (unsigned char) 0xb8) {
0652         /*
0653          * If we have been running for more than a full timer tick
0654          * then take a rest.
0655          */
0656         if (time_after(jiffies, start_jiffies + 1))
0657             return 0;
0658 
0659         /*
0660          * FAIL if:
0661          * a) Drive status is screwy (!ready && !present)
0662          * b) Drive is requesting/sending more data than expected
0663          */
0664         if ((r & 0x88) != 0x88 || scsi_pointer->this_residual <= 0) {
0665             imm_fail(dev, DID_ERROR);
0666             return -1;  /* ERROR_RETURN */
0667         }
0668         /* determine if we should use burst I/O */
0669         if (dev->rd == 0) {
0670             fast = bulk && scsi_pointer->this_residual >=
0671                 IMM_BURST_SIZE ? IMM_BURST_SIZE : 2;
0672             status = imm_out(dev, scsi_pointer->ptr, fast);
0673         } else {
0674             fast = bulk && scsi_pointer->this_residual >=
0675                 IMM_BURST_SIZE ? IMM_BURST_SIZE : 1;
0676             status = imm_in(dev, scsi_pointer->ptr, fast);
0677         }
0678 
0679         scsi_pointer->ptr += fast;
0680         scsi_pointer->this_residual -= fast;
0681 
0682         if (!status) {
0683             imm_fail(dev, DID_BUS_BUSY);
0684             return -1;  /* ERROR_RETURN */
0685         }
0686         if (scsi_pointer->buffer && !scsi_pointer->this_residual) {
0687             /* if scatter/gather, advance to the next segment */
0688             if (scsi_pointer->buffers_residual--) {
0689                 scsi_pointer->buffer =
0690                     sg_next(scsi_pointer->buffer);
0691                 scsi_pointer->this_residual =
0692                     scsi_pointer->buffer->length;
0693                 scsi_pointer->ptr = sg_virt(scsi_pointer->buffer);
0694 
0695                 /*
0696                  * Make sure that we transfer even number of bytes
0697                  * otherwise it makes imm_byte_out() messy.
0698                  */
0699                 if (scsi_pointer->this_residual & 0x01)
0700                     scsi_pointer->this_residual++;
0701             }
0702         }
0703         /* Now check to see if the drive is ready to comunicate */
0704         w_ctr(ppb, 0x0c);
0705         r = (r_str(ppb) & 0xb8);
0706 
0707         /* If not, drop back down to the scheduler and wait a timer tick */
0708         if (!(r & 0x80))
0709             return 0;
0710     }
0711     return 1;       /* FINISH_RETURN */
0712 }
0713 
0714 /*
0715  * Since the IMM itself doesn't generate interrupts, we use
0716  * the scheduler's task queue to generate a stream of call-backs and
0717  * complete the request when the drive is ready.
0718  */
0719 static void imm_interrupt(struct work_struct *work)
0720 {
0721     imm_struct *dev = container_of(work, imm_struct, imm_tq.work);
0722     struct scsi_cmnd *cmd = dev->cur_cmd;
0723     struct Scsi_Host *host = cmd->device->host;
0724     unsigned long flags;
0725 
0726     if (imm_engine(dev, cmd)) {
0727         schedule_delayed_work(&dev->imm_tq, 1);
0728         return;
0729     }
0730     /* Command must of completed hence it is safe to let go... */
0731 #if IMM_DEBUG > 0
0732     switch ((cmd->result >> 16) & 0xff) {
0733     case DID_OK:
0734         break;
0735     case DID_NO_CONNECT:
0736         printk("imm: no device at SCSI ID %i\n", cmd->device->id);
0737         break;
0738     case DID_BUS_BUSY:
0739         printk("imm: BUS BUSY - EPP timeout detected\n");
0740         break;
0741     case DID_TIME_OUT:
0742         printk("imm: unknown timeout\n");
0743         break;
0744     case DID_ABORT:
0745         printk("imm: told to abort\n");
0746         break;
0747     case DID_PARITY:
0748         printk("imm: parity error (???)\n");
0749         break;
0750     case DID_ERROR:
0751         printk("imm: internal driver error\n");
0752         break;
0753     case DID_RESET:
0754         printk("imm: told to reset device\n");
0755         break;
0756     case DID_BAD_INTR:
0757         printk("imm: bad interrupt (???)\n");
0758         break;
0759     default:
0760         printk("imm: bad return code (%02x)\n",
0761                (cmd->result >> 16) & 0xff);
0762     }
0763 #endif
0764 
0765     if (imm_scsi_pointer(cmd)->phase > 1)
0766         imm_disconnect(dev);
0767 
0768     imm_pb_dismiss(dev);
0769 
0770     spin_lock_irqsave(host->host_lock, flags);
0771     dev->cur_cmd = NULL;
0772     scsi_done(cmd);
0773     spin_unlock_irqrestore(host->host_lock, flags);
0774     return;
0775 }
0776 
0777 static int imm_engine(imm_struct *dev, struct scsi_cmnd *const cmd)
0778 {
0779     struct scsi_pointer *scsi_pointer = imm_scsi_pointer(cmd);
0780     unsigned short ppb = dev->base;
0781     unsigned char l = 0, h = 0;
0782     int retv, x;
0783 
0784     /* First check for any errors that may have occurred
0785      * Here we check for internal errors
0786      */
0787     if (dev->failed)
0788         return 0;
0789 
0790     switch (scsi_pointer->phase) {
0791     case 0:     /* Phase 0 - Waiting for parport */
0792         if (time_after(jiffies, dev->jstart + HZ)) {
0793             /*
0794              * We waited more than a second
0795              * for parport to call us
0796              */
0797             imm_fail(dev, DID_BUS_BUSY);
0798             return 0;
0799         }
0800         return 1;   /* wait until imm_wakeup claims parport */
0801 
0802     case 1:     /* Phase 1 - Connected */
0803         imm_connect(dev, CONNECT_EPP_MAYBE);
0804         scsi_pointer->phase++;
0805         fallthrough;
0806 
0807     case 2:     /* Phase 2 - We are now talking to the scsi bus */
0808         if (!imm_select(dev, scmd_id(cmd))) {
0809             imm_fail(dev, DID_NO_CONNECT);
0810             return 0;
0811         }
0812         scsi_pointer->phase++;
0813         fallthrough;
0814 
0815     case 3:     /* Phase 3 - Ready to accept a command */
0816         w_ctr(ppb, 0x0c);
0817         if (!(r_str(ppb) & 0x80))
0818             return 1;
0819 
0820         if (!imm_send_command(cmd))
0821             return 0;
0822         scsi_pointer->phase++;
0823         fallthrough;
0824 
0825     case 4:     /* Phase 4 - Setup scatter/gather buffers */
0826         if (scsi_bufflen(cmd)) {
0827             scsi_pointer->buffer = scsi_sglist(cmd);
0828             scsi_pointer->this_residual = scsi_pointer->buffer->length;
0829             scsi_pointer->ptr = sg_virt(scsi_pointer->buffer);
0830         } else {
0831             scsi_pointer->buffer = NULL;
0832             scsi_pointer->this_residual = 0;
0833             scsi_pointer->ptr = NULL;
0834         }
0835         scsi_pointer->buffers_residual = scsi_sg_count(cmd) - 1;
0836         scsi_pointer->phase++;
0837         if (scsi_pointer->this_residual & 0x01)
0838             scsi_pointer->this_residual++;
0839         fallthrough;
0840 
0841     case 5:     /* Phase 5 - Pre-Data transfer stage */
0842         /* Spin lock for BUSY */
0843         w_ctr(ppb, 0x0c);
0844         if (!(r_str(ppb) & 0x80))
0845             return 1;
0846 
0847         /* Require negotiation for read requests */
0848         x = (r_str(ppb) & 0xb8);
0849         dev->rd = (x & 0x10) ? 1 : 0;
0850         dev->dp = (x & 0x20) ? 0 : 1;
0851 
0852         if ((dev->dp) && (dev->rd))
0853             if (imm_negotiate(dev))
0854                 return 0;
0855         scsi_pointer->phase++;
0856         fallthrough;
0857 
0858     case 6:     /* Phase 6 - Data transfer stage */
0859         /* Spin lock for BUSY */
0860         w_ctr(ppb, 0x0c);
0861         if (!(r_str(ppb) & 0x80))
0862             return 1;
0863 
0864         if (dev->dp) {
0865             retv = imm_completion(cmd);
0866             if (retv == -1)
0867                 return 0;
0868             if (retv == 0)
0869                 return 1;
0870         }
0871         scsi_pointer->phase++;
0872         fallthrough;
0873 
0874     case 7:     /* Phase 7 - Post data transfer stage */
0875         if ((dev->dp) && (dev->rd)) {
0876             if ((dev->mode == IMM_NIBBLE) || (dev->mode == IMM_PS2)) {
0877                 w_ctr(ppb, 0x4);
0878                 w_ctr(ppb, 0xc);
0879                 w_ctr(ppb, 0xe);
0880                 w_ctr(ppb, 0x4);
0881             }
0882         }
0883         scsi_pointer->phase++;
0884         fallthrough;
0885 
0886     case 8:     /* Phase 8 - Read status/message */
0887         /* Check for data overrun */
0888         if (imm_wait(dev) != (unsigned char) 0xb8) {
0889             imm_fail(dev, DID_ERROR);
0890             return 0;
0891         }
0892         if (imm_negotiate(dev))
0893             return 0;
0894         if (imm_in(dev, &l, 1)) {   /* read status byte */
0895             /* Check for optional message byte */
0896             if (imm_wait(dev) == (unsigned char) 0xb8)
0897                 imm_in(dev, &h, 1);
0898             cmd->result = (DID_OK << 16) | (l & STATUS_MASK);
0899         }
0900         if ((dev->mode == IMM_NIBBLE) || (dev->mode == IMM_PS2)) {
0901             w_ctr(ppb, 0x4);
0902             w_ctr(ppb, 0xc);
0903             w_ctr(ppb, 0xe);
0904             w_ctr(ppb, 0x4);
0905         }
0906         return 0;   /* Finished */
0907 
0908     default:
0909         printk("imm: Invalid scsi phase\n");
0910     }
0911     return 0;
0912 }
0913 
0914 static int imm_queuecommand_lck(struct scsi_cmnd *cmd)
0915 {
0916     imm_struct *dev = imm_dev(cmd->device->host);
0917 
0918     if (dev->cur_cmd) {
0919         printk("IMM: bug in imm_queuecommand\n");
0920         return 0;
0921     }
0922     dev->failed = 0;
0923     dev->jstart = jiffies;
0924     dev->cur_cmd = cmd;
0925     cmd->result = DID_ERROR << 16;  /* default return code */
0926     imm_scsi_pointer(cmd)->phase = 0;   /* bus free */
0927 
0928     schedule_delayed_work(&dev->imm_tq, 0);
0929 
0930     imm_pb_claim(dev);
0931 
0932     return 0;
0933 }
0934 
0935 static DEF_SCSI_QCMD(imm_queuecommand)
0936 
0937 /*
0938  * Apparently the disk->capacity attribute is off by 1 sector 
0939  * for all disk drives.  We add the one here, but it should really
0940  * be done in sd.c.  Even if it gets fixed there, this will still
0941  * work.
0942  */
0943 static int imm_biosparam(struct scsi_device *sdev, struct block_device *dev,
0944              sector_t capacity, int ip[])
0945 {
0946     ip[0] = 0x40;
0947     ip[1] = 0x20;
0948     ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);
0949     if (ip[2] > 1024) {
0950         ip[0] = 0xff;
0951         ip[1] = 0x3f;
0952         ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);
0953     }
0954     return 0;
0955 }
0956 
0957 static int imm_abort(struct scsi_cmnd *cmd)
0958 {
0959     imm_struct *dev = imm_dev(cmd->device->host);
0960     /*
0961      * There is no method for aborting commands since Iomega
0962      * have tied the SCSI_MESSAGE line high in the interface
0963      */
0964 
0965     switch (imm_scsi_pointer(cmd)->phase) {
0966     case 0:     /* Do not have access to parport */
0967     case 1:     /* Have not connected to interface */
0968         dev->cur_cmd = NULL;    /* Forget the problem */
0969         return SUCCESS;
0970     default:        /* SCSI command sent, can not abort */
0971         return FAILED;
0972     }
0973 }
0974 
0975 static void imm_reset_pulse(unsigned int base)
0976 {
0977     w_ctr(base, 0x04);
0978     w_dtr(base, 0x40);
0979     udelay(1);
0980     w_ctr(base, 0x0c);
0981     w_ctr(base, 0x0d);
0982     udelay(50);
0983     w_ctr(base, 0x0c);
0984     w_ctr(base, 0x04);
0985 }
0986 
0987 static int imm_reset(struct scsi_cmnd *cmd)
0988 {
0989     imm_struct *dev = imm_dev(cmd->device->host);
0990 
0991     if (imm_scsi_pointer(cmd)->phase)
0992         imm_disconnect(dev);
0993     dev->cur_cmd = NULL;    /* Forget the problem */
0994 
0995     imm_connect(dev, CONNECT_NORMAL);
0996     imm_reset_pulse(dev->base);
0997     mdelay(1);      /* device settle delay */
0998     imm_disconnect(dev);
0999     mdelay(1);      /* device settle delay */
1000     return SUCCESS;
1001 }
1002 
1003 static int device_check(imm_struct *dev)
1004 {
1005     /* This routine looks for a device and then attempts to use EPP
1006        to send a command. If all goes as planned then EPP is available. */
1007 
1008     static char cmd[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
1009     int loop, old_mode, status, k, ppb = dev->base;
1010     unsigned char l;
1011 
1012     old_mode = dev->mode;
1013     for (loop = 0; loop < 8; loop++) {
1014         /* Attempt to use EPP for Test Unit Ready */
1015         if ((ppb & 0x0007) == 0x0000)
1016             dev->mode = IMM_EPP_32;
1017 
1018           second_pass:
1019         imm_connect(dev, CONNECT_EPP_MAYBE);
1020         /* Select SCSI device */
1021         if (!imm_select(dev, loop)) {
1022             imm_disconnect(dev);
1023             continue;
1024         }
1025         printk("imm: Found device at ID %i, Attempting to use %s\n",
1026                loop, IMM_MODE_STRING[dev->mode]);
1027 
1028         /* Send SCSI command */
1029         status = 1;
1030         w_ctr(ppb, 0x0c);
1031         for (l = 0; (l < 3) && (status); l++)
1032             status = imm_out(dev, &cmd[l << 1], 2);
1033 
1034         if (!status) {
1035             imm_disconnect(dev);
1036             imm_connect(dev, CONNECT_EPP_MAYBE);
1037             imm_reset_pulse(dev->base);
1038             udelay(1000);
1039             imm_disconnect(dev);
1040             udelay(1000);
1041             if (dev->mode == IMM_EPP_32) {
1042                 dev->mode = old_mode;
1043                 goto second_pass;
1044             }
1045             printk("imm: Unable to establish communication\n");
1046             return -EIO;
1047         }
1048         w_ctr(ppb, 0x0c);
1049 
1050         k = 1000000;    /* 1 Second */
1051         do {
1052             l = r_str(ppb);
1053             k--;
1054             udelay(1);
1055         } while (!(l & 0x80) && (k));
1056 
1057         l &= 0xb8;
1058 
1059         if (l != 0xb8) {
1060             imm_disconnect(dev);
1061             imm_connect(dev, CONNECT_EPP_MAYBE);
1062             imm_reset_pulse(dev->base);
1063             udelay(1000);
1064             imm_disconnect(dev);
1065             udelay(1000);
1066             if (dev->mode == IMM_EPP_32) {
1067                 dev->mode = old_mode;
1068                 goto second_pass;
1069             }
1070             printk
1071                 ("imm: Unable to establish communication\n");
1072             return -EIO;
1073         }
1074         imm_disconnect(dev);
1075         printk
1076             ("imm: Communication established at 0x%x with ID %i using %s\n",
1077              ppb, loop, IMM_MODE_STRING[dev->mode]);
1078         imm_connect(dev, CONNECT_EPP_MAYBE);
1079         imm_reset_pulse(dev->base);
1080         udelay(1000);
1081         imm_disconnect(dev);
1082         udelay(1000);
1083         return 0;
1084     }
1085     printk("imm: No devices found\n");
1086     return -ENODEV;
1087 }
1088 
1089 /*
1090  * imm cannot deal with highmem, so this causes all IO pages for this host
1091  * to reside in low memory (hence mapped)
1092  */
1093 static int imm_adjust_queue(struct scsi_device *device)
1094 {
1095     blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
1096     return 0;
1097 }
1098 
1099 static struct scsi_host_template imm_template = {
1100     .module         = THIS_MODULE,
1101     .proc_name      = "imm",
1102     .show_info      = imm_show_info,
1103     .write_info     = imm_write_info,
1104     .name           = "Iomega VPI2 (imm) interface",
1105     .queuecommand       = imm_queuecommand,
1106     .eh_abort_handler   = imm_abort,
1107     .eh_host_reset_handler  = imm_reset,
1108     .bios_param     = imm_biosparam,
1109     .this_id        = 7,
1110     .sg_tablesize       = SG_ALL,
1111     .can_queue      = 1,
1112     .slave_alloc        = imm_adjust_queue,
1113     .cmd_size       = sizeof(struct scsi_pointer),
1114 };
1115 
1116 /***************************************************************************
1117  *                   Parallel port probing routines                        *
1118  ***************************************************************************/
1119 
1120 static LIST_HEAD(imm_hosts);
1121 
1122 /*
1123  * Finds the first available device number that can be alloted to the
1124  * new imm device and returns the address of the previous node so that
1125  * we can add to the tail and have a list in the ascending order.
1126  */
1127 
1128 static inline imm_struct *find_parent(void)
1129 {
1130     imm_struct *dev, *par = NULL;
1131     unsigned int cnt = 0;
1132 
1133     if (list_empty(&imm_hosts))
1134         return NULL;
1135 
1136     list_for_each_entry(dev, &imm_hosts, list) {
1137         if (dev->dev_no != cnt)
1138             return par;
1139         cnt++;
1140         par = dev;
1141     }
1142 
1143     return par;
1144 }
1145 
1146 static int __imm_attach(struct parport *pb)
1147 {
1148     struct Scsi_Host *host;
1149     imm_struct *dev, *temp;
1150     DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waiting);
1151     DEFINE_WAIT(wait);
1152     int ports;
1153     int modes, ppb;
1154     int err = -ENOMEM;
1155     struct pardev_cb imm_cb;
1156 
1157     init_waitqueue_head(&waiting);
1158 
1159     dev = kzalloc(sizeof(imm_struct), GFP_KERNEL);
1160     if (!dev)
1161         return -ENOMEM;
1162 
1163 
1164     dev->base = -1;
1165     dev->mode = IMM_AUTODETECT;
1166     INIT_LIST_HEAD(&dev->list);
1167 
1168     temp = find_parent();
1169     if (temp)
1170         dev->dev_no = temp->dev_no + 1;
1171 
1172     memset(&imm_cb, 0, sizeof(imm_cb));
1173     imm_cb.private = dev;
1174     imm_cb.wakeup = imm_wakeup;
1175 
1176     dev->dev = parport_register_dev_model(pb, "imm", &imm_cb, dev->dev_no);
1177     if (!dev->dev)
1178         goto out;
1179 
1180 
1181     /* Claim the bus so it remembers what we do to the control
1182      * registers. [ CTR and ECP ]
1183      */
1184     err = -EBUSY;
1185     dev->waiting = &waiting;
1186     prepare_to_wait(&waiting, &wait, TASK_UNINTERRUPTIBLE);
1187     if (imm_pb_claim(dev))
1188         schedule_timeout(3 * HZ);
1189     if (dev->wanted) {
1190         printk(KERN_ERR "imm%d: failed to claim parport because "
1191             "a pardevice is owning the port for too long "
1192             "time!\n", pb->number);
1193         imm_pb_dismiss(dev);
1194         dev->waiting = NULL;
1195         finish_wait(&waiting, &wait);
1196         goto out1;
1197     }
1198     dev->waiting = NULL;
1199     finish_wait(&waiting, &wait);
1200     ppb = dev->base = dev->dev->port->base;
1201     dev->base_hi = dev->dev->port->base_hi;
1202     w_ctr(ppb, 0x0c);
1203     modes = dev->dev->port->modes;
1204 
1205     /* Mode detection works up the chain of speed
1206      * This avoids a nasty if-then-else-if-... tree
1207      */
1208     dev->mode = IMM_NIBBLE;
1209 
1210     if (modes & PARPORT_MODE_TRISTATE)
1211         dev->mode = IMM_PS2;
1212 
1213     /* Done configuration */
1214 
1215     err = imm_init(dev);
1216 
1217     imm_pb_release(dev);
1218 
1219     if (err)
1220         goto out1;
1221 
1222     /* now the glue ... */
1223     if (dev->mode == IMM_NIBBLE || dev->mode == IMM_PS2)
1224         ports = 3;
1225     else
1226         ports = 8;
1227 
1228     INIT_DELAYED_WORK(&dev->imm_tq, imm_interrupt);
1229 
1230     err = -ENOMEM;
1231     host = scsi_host_alloc(&imm_template, sizeof(imm_struct *));
1232     if (!host)
1233         goto out1;
1234     host->io_port = pb->base;
1235     host->n_io_port = ports;
1236     host->dma_channel = -1;
1237     host->unique_id = pb->number;
1238     *(imm_struct **)&host->hostdata = dev;
1239     dev->host = host;
1240     if (!temp)
1241         list_add_tail(&dev->list, &imm_hosts);
1242     else
1243         list_add_tail(&dev->list, &temp->list);
1244     err = scsi_add_host(host, NULL);
1245     if (err)
1246         goto out2;
1247     scsi_scan_host(host);
1248     return 0;
1249 
1250 out2:
1251     list_del_init(&dev->list);
1252     scsi_host_put(host);
1253 out1:
1254     parport_unregister_device(dev->dev);
1255 out:
1256     kfree(dev);
1257     return err;
1258 }
1259 
1260 static void imm_attach(struct parport *pb)
1261 {
1262     __imm_attach(pb);
1263 }
1264 
1265 static void imm_detach(struct parport *pb)
1266 {
1267     imm_struct *dev;
1268     list_for_each_entry(dev, &imm_hosts, list) {
1269         if (dev->dev->port == pb) {
1270             list_del_init(&dev->list);
1271             scsi_remove_host(dev->host);
1272             scsi_host_put(dev->host);
1273             parport_unregister_device(dev->dev);
1274             kfree(dev);
1275             break;
1276         }
1277     }
1278 }
1279 
1280 static struct parport_driver imm_driver = {
1281     .name       = "imm",
1282     .match_port = imm_attach,
1283     .detach     = imm_detach,
1284     .devmodel   = true,
1285 };
1286 module_parport_driver(imm_driver);
1287 
1288 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!