1283 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/* imm.c -- low level driver for the IOMEGA MatchMaker3 * parallel port SCSI host adapter.4 * 5 * (The IMM is the embedded controller in the ZIP Plus drive.)6 * 7 * My unofficial company acronym list is 21 pages long:8 * FLA: Four letter acronym with built in facility for9 * future expansion to five letters.10 */11 12#include <linux/init.h>13#include <linux/kernel.h>14#include <linux/module.h>15#include <linux/blkdev.h>16#include <linux/parport.h>17#include <linux/workqueue.h>18#include <linux/delay.h>19#include <linux/slab.h>20#include <asm/io.h>21 22#include <scsi/scsi.h>23#include <scsi/scsi_cmnd.h>24#include <scsi/scsi_device.h>25#include <scsi/scsi_host.h>26 27/* The following #define is to avoid a clash with hosts.c */28#define IMM_PROBE_SPP 0x000129#define IMM_PROBE_PS2 0x000230#define IMM_PROBE_ECR 0x001031#define IMM_PROBE_EPP17 0x010032#define IMM_PROBE_EPP19 0x020033 34 35typedef struct {36 struct pardevice *dev; /* Parport device entry */37 int base; /* Actual port address */38 int base_hi; /* Hi Base address for ECP-ISA chipset */39 int mode; /* Transfer mode */40 struct scsi_cmnd *cur_cmd; /* Current queued command */41 struct delayed_work imm_tq; /* Polling interrupt stuff */42 unsigned long jstart; /* Jiffies at start */43 unsigned failed:1; /* Failure flag */44 unsigned dp:1; /* Data phase present */45 unsigned rd:1; /* Read data in data phase */46 unsigned wanted:1; /* Parport sharing busy flag */47 unsigned int dev_no; /* Device number */48 wait_queue_head_t *waiting;49 struct Scsi_Host *host;50 struct list_head list;51} imm_struct;52 53static void imm_reset_pulse(unsigned int base);54static int device_check(imm_struct *dev, bool autodetect);55 56#include "imm.h"57 58static unsigned int mode = IMM_AUTODETECT;59module_param(mode, uint, 0644);60MODULE_PARM_DESC(mode, "Transfer mode (0 = Autodetect, 1 = SPP 4-bit, "61 "2 = SPP 8-bit, 3 = EPP 8-bit, 4 = EPP 16-bit, 5 = EPP 32-bit");62 63static inline imm_struct *imm_dev(struct Scsi_Host *host)64{65 return *(imm_struct **)&host->hostdata;66}67 68static DEFINE_SPINLOCK(arbitration_lock);69 70static void got_it(imm_struct *dev)71{72 dev->base = dev->dev->port->base;73 if (dev->cur_cmd)74 imm_scsi_pointer(dev->cur_cmd)->phase = 1;75 else76 wake_up(dev->waiting);77}78 79static void imm_wakeup(void *ref)80{81 imm_struct *dev = (imm_struct *) ref;82 unsigned long flags;83 84 spin_lock_irqsave(&arbitration_lock, flags);85 if (dev->wanted) {86 if (parport_claim(dev->dev) == 0) {87 got_it(dev);88 dev->wanted = 0;89 }90 }91 spin_unlock_irqrestore(&arbitration_lock, flags);92}93 94static int imm_pb_claim(imm_struct *dev)95{96 unsigned long flags;97 int res = 1;98 spin_lock_irqsave(&arbitration_lock, flags);99 if (parport_claim(dev->dev) == 0) {100 got_it(dev);101 res = 0;102 }103 dev->wanted = res;104 spin_unlock_irqrestore(&arbitration_lock, flags);105 return res;106}107 108static void imm_pb_dismiss(imm_struct *dev)109{110 unsigned long flags;111 int wanted;112 spin_lock_irqsave(&arbitration_lock, flags);113 wanted = dev->wanted;114 dev->wanted = 0;115 spin_unlock_irqrestore(&arbitration_lock, flags);116 if (!wanted)117 parport_release(dev->dev);118}119 120static inline void imm_pb_release(imm_struct *dev)121{122 parport_release(dev->dev);123}124 125/* This is to give the imm driver a way to modify the timings (and other126 * parameters) by writing to the /proc/scsi/imm/0 file.127 * Very simple method really... (Too simple, no error checking :( )128 * Reason: Kernel hackers HATE having to unload and reload modules for129 * testing...130 * Also gives a method to use a script to obtain optimum timings (TODO)131 */132static int imm_write_info(struct Scsi_Host *host, char *buffer, int length)133{134 imm_struct *dev = imm_dev(host);135 136 if ((length > 5) && (strncmp(buffer, "mode=", 5) == 0)) {137 dev->mode = simple_strtoul(buffer + 5, NULL, 0);138 return length;139 }140 printk("imm /proc: invalid variable\n");141 return -EINVAL;142}143 144static int imm_show_info(struct seq_file *m, struct Scsi_Host *host)145{146 imm_struct *dev = imm_dev(host);147 148 seq_printf(m, "Version : %s\n", IMM_VERSION);149 seq_printf(m, "Parport : %s\n", dev->dev->port->name);150 seq_printf(m, "Mode : %s\n", IMM_MODE_STRING[dev->mode]);151 return 0;152}153 154#if IMM_DEBUG > 0155#define imm_fail(x,y) printk("imm: imm_fail(%i) from %s at line %d\n",\156 y, __func__, __LINE__); imm_fail_func(x,y);157static inline void158imm_fail_func(imm_struct *dev, int error_code)159#else160static inline void161imm_fail(imm_struct *dev, int error_code)162#endif163{164 /* If we fail a device then we trash status / message bytes */165 if (dev->cur_cmd) {166 dev->cur_cmd->result = error_code << 16;167 dev->failed = 1;168 }169}170 171/*172 * Wait for the high bit to be set.173 * 174 * In principle, this could be tied to an interrupt, but the adapter175 * doesn't appear to be designed to support interrupts. We spin on176 * the 0x80 ready bit. 177 */178static unsigned char imm_wait(imm_struct *dev)179{180 int k;181 unsigned short ppb = dev->base;182 unsigned char r;183 184 w_ctr(ppb, 0x0c);185 186 k = IMM_SPIN_TMO;187 do {188 r = r_str(ppb);189 k--;190 udelay(1);191 }192 while (!(r & 0x80) && (k));193 194 /*195 * STR register (LPT base+1) to SCSI mapping:196 *197 * STR imm imm198 * ===================================199 * 0x80 S_REQ S_REQ200 * 0x40 !S_BSY (????)201 * 0x20 !S_CD !S_CD202 * 0x10 !S_IO !S_IO203 * 0x08 (????) !S_BSY204 *205 * imm imm meaning206 * ==================================207 * 0xf0 0xb8 Bit mask208 * 0xc0 0x88 ZIP wants more data209 * 0xd0 0x98 ZIP wants to send more data210 * 0xe0 0xa8 ZIP is expecting SCSI command data211 * 0xf0 0xb8 end of transfer, ZIP is sending status212 */213 w_ctr(ppb, 0x04);214 if (k)215 return (r & 0xb8);216 217 /* Counter expired - Time out occurred */218 imm_fail(dev, DID_TIME_OUT);219 printk("imm timeout in imm_wait\n");220 return 0; /* command timed out */221}222 223static int imm_negotiate(imm_struct * tmp)224{225 /*226 * The following is supposedly the IEEE 1284-1994 negotiate227 * sequence. I have yet to obtain a copy of the above standard228 * so this is a bit of a guess...229 *230 * A fair chunk of this is based on the Linux parport implementation231 * of IEEE 1284.232 *233 * Return 0 if data available234 * 1 if no data available235 */236 237 unsigned short base = tmp->base;238 unsigned char a, mode;239 240 switch (tmp->mode) {241 case IMM_NIBBLE:242 mode = 0x00;243 break;244 case IMM_PS2:245 mode = 0x01;246 break;247 default:248 return 0;249 }250 251 w_ctr(base, 0x04);252 udelay(5);253 w_dtr(base, mode);254 udelay(100);255 w_ctr(base, 0x06);256 udelay(5);257 a = (r_str(base) & 0x20) ? 0 : 1;258 udelay(5);259 w_ctr(base, 0x07);260 udelay(5);261 w_ctr(base, 0x06);262 263 if (a) {264 printk265 ("IMM: IEEE1284 negotiate indicates no data available.\n");266 imm_fail(tmp, DID_ERROR);267 }268 return a;269}270 271/* 272 * Clear EPP timeout bit. 273 */274static inline void epp_reset(unsigned short ppb)275{276 int i;277 278 i = r_str(ppb);279 w_str(ppb, i);280 w_str(ppb, i & 0xfe);281}282 283/* 284 * Wait for empty ECP fifo (if we are in ECP fifo mode only)285 */286static inline void ecp_sync(imm_struct *dev)287{288 int i, ppb_hi = dev->base_hi;289 290 if (ppb_hi == 0)291 return;292 293 if ((r_ecr(ppb_hi) & 0xe0) == 0x60) { /* mode 011 == ECP fifo mode */294 for (i = 0; i < 100; i++) {295 if (r_ecr(ppb_hi) & 0x01)296 return;297 udelay(5);298 }299 printk("imm: ECP sync failed as data still present in FIFO.\n");300 }301}302 303static int imm_byte_out(unsigned short base, const char *buffer, int len)304{305 int i;306 307 w_ctr(base, 0x4); /* apparently a sane mode */308 for (i = len >> 1; i; i--) {309 w_dtr(base, *buffer++);310 w_ctr(base, 0x5); /* Drop STROBE low */311 w_dtr(base, *buffer++);312 w_ctr(base, 0x0); /* STROBE high + INIT low */313 }314 w_ctr(base, 0x4); /* apparently a sane mode */315 return 1; /* All went well - we hope! */316}317 318static int imm_nibble_in(unsigned short base, char *buffer, int len)319{320 unsigned char l;321 int i;322 323 /*324 * The following is based on documented timing signals325 */326 w_ctr(base, 0x4);327 for (i = len; i; i--) {328 w_ctr(base, 0x6);329 l = (r_str(base) & 0xf0) >> 4;330 w_ctr(base, 0x5);331 *buffer++ = (r_str(base) & 0xf0) | l;332 w_ctr(base, 0x4);333 }334 return 1; /* All went well - we hope! */335}336 337static int imm_byte_in(unsigned short base, char *buffer, int len)338{339 int i;340 341 /*342 * The following is based on documented timing signals343 */344 w_ctr(base, 0x4);345 for (i = len; i; i--) {346 w_ctr(base, 0x26);347 *buffer++ = r_dtr(base);348 w_ctr(base, 0x25);349 }350 return 1; /* All went well - we hope! */351}352 353static int imm_out(imm_struct *dev, char *buffer, int len)354{355 unsigned short ppb = dev->base;356 int r = imm_wait(dev);357 358 /*359 * Make sure that:360 * a) the SCSI bus is BUSY (device still listening)361 * b) the device is listening362 */363 if ((r & 0x18) != 0x08) {364 imm_fail(dev, DID_ERROR);365 printk("IMM: returned SCSI status %2x\n", r);366 return 0;367 }368 switch (dev->mode) {369 case IMM_EPP_32:370 case IMM_EPP_16:371 case IMM_EPP_8:372 epp_reset(ppb);373 w_ctr(ppb, 0x4);374 if (dev->mode == IMM_EPP_32 && !(((long) buffer | len) & 0x03))375 outsl(ppb + 4, buffer, len >> 2);376 else if (dev->mode == IMM_EPP_16 && !(((long) buffer | len) & 0x01))377 outsw(ppb + 4, buffer, len >> 1);378 else379 outsb(ppb + 4, buffer, len);380 w_ctr(ppb, 0xc);381 r = !(r_str(ppb) & 0x01);382 w_ctr(ppb, 0xc);383 ecp_sync(dev);384 break;385 386 case IMM_NIBBLE:387 case IMM_PS2:388 /* 8 bit output, with a loop */389 r = imm_byte_out(ppb, buffer, len);390 break;391 392 default:393 printk("IMM: bug in imm_out()\n");394 r = 0;395 }396 return r;397}398 399static int imm_in(imm_struct *dev, char *buffer, int len)400{401 unsigned short ppb = dev->base;402 int r = imm_wait(dev);403 404 /*405 * Make sure that:406 * a) the SCSI bus is BUSY (device still listening)407 * b) the device is sending data408 */409 if ((r & 0x18) != 0x18) {410 imm_fail(dev, DID_ERROR);411 return 0;412 }413 switch (dev->mode) {414 case IMM_NIBBLE:415 /* 4 bit input, with a loop */416 r = imm_nibble_in(ppb, buffer, len);417 w_ctr(ppb, 0xc);418 break;419 420 case IMM_PS2:421 /* 8 bit input, with a loop */422 r = imm_byte_in(ppb, buffer, len);423 w_ctr(ppb, 0xc);424 break;425 426 case IMM_EPP_32:427 case IMM_EPP_16:428 case IMM_EPP_8:429 epp_reset(ppb);430 w_ctr(ppb, 0x24);431 if (dev->mode == IMM_EPP_32 && !(((long) buffer | len) & 0x03))432 insw(ppb + 4, buffer, len >> 2);433 else if (dev->mode == IMM_EPP_16 && !(((long) buffer | len) & 0x01))434 insl(ppb + 4, buffer, len >> 1);435 else436 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 451static int imm_cpp(unsigned short ppb, unsigned char b)452{453 /*454 * Comments on udelay values refer to the455 * 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 device479 * 0010 00aa Select device aa in EPP Winbond mode480 * 0010 10aa Select device aa in EPP mode481 * 0011 xxxx Deselect all devices482 * 0110 00aa Test device aa483 * 1101 00aa Select device aa in ECP mode484 * 1110 00aa Select device aa in Compatible mode485 */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 Fault502 * S1 0 X 1 1 1503 * S2 1 X 0 1 1504 * S3 L X 1 1 S505 *506 * L => Last device in chain507 * S => Selected508 *509 * Observered values for S1,S2,S3 are:510 * Disconnect => f8/58/78511 * Connect => f8/58/70512 */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 521static 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 535static void imm_disconnect(imm_struct *dev)536{537 imm_cpp(dev->base, 0x30); /* Disconnect all devices */538}539 540static 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 nothing547 * 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 bus561 */562 w_ctr(ppb, 0x4);563 w_dtr(ppb, 0x80 | (1 << target));564 udelay(1);565 566 /*567 * Deassert SELIN first followed by STROBE568 */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 589static int imm_init(imm_struct *dev)590{591 bool autodetect = dev->mode == IMM_AUTODETECT;592 593 if (autodetect) {594 int modes = dev->dev->port->modes;595 596 /* Mode detection works up the chain of speed597 * This avoids a nasty if-then-else-if-... tree598 */599 dev->mode = IMM_NIBBLE;600 601 if (modes & PARPORT_MODE_TRISTATE)602 dev->mode = IMM_PS2;603 }604 605 if (imm_connect(dev, 0) != 1)606 return -EIO;607 imm_reset_pulse(dev->base);608 mdelay(1); /* Delay to allow devices to settle */609 imm_disconnect(dev);610 mdelay(1); /* Another delay to allow devices to settle */611 612 return device_check(dev, autodetect);613}614 615static inline int imm_send_command(struct scsi_cmnd *cmd)616{617 imm_struct *dev = imm_dev(cmd->device->host);618 int k;619 620 /* NOTE: IMM uses byte pairs */621 for (k = 0; k < cmd->cmd_len; k += 2)622 if (!imm_out(dev, &cmd->cmnd[k], 2))623 return 0;624 return 1;625}626 627/*628 * The bulk flag enables some optimisations in the data transfer loops,629 * it should be true for any command that transfers data in integral630 * numbers of sectors.631 * 632 * The driver appears to remain stable if we speed up the parallel port633 * i/o in this function, but not elsewhere.634 */635static int imm_completion(struct scsi_cmnd *const cmd)636{637 /* Return codes:638 * -1 Error639 * 0 Told to schedule640 * 1 Finished data transfer641 */642 struct scsi_pointer *scsi_pointer = imm_scsi_pointer(cmd);643 imm_struct *dev = imm_dev(cmd->device->host);644 unsigned short ppb = dev->base;645 unsigned long start_jiffies = jiffies;646 647 unsigned char r, v;648 int fast, bulk, status;649 650 v = cmd->cmnd[0];651 bulk = ((v == READ_6) ||652 (v == READ_10) || (v == WRITE_6) || (v == WRITE_10));653 654 /*655 * We only get here if the drive is ready to comunicate,656 * hence no need for a full imm_wait.657 */658 w_ctr(ppb, 0x0c);659 r = (r_str(ppb) & 0xb8);660 661 /*662 * while (device is not ready to send status byte)663 * loop;664 */665 while (r != (unsigned char) 0xb8) {666 /*667 * If we have been running for more than a full timer tick668 * then take a rest.669 */670 if (time_after(jiffies, start_jiffies + 1))671 return 0;672 673 /*674 * FAIL if:675 * a) Drive status is screwy (!ready && !present)676 * b) Drive is requesting/sending more data than expected677 */678 if ((r & 0x88) != 0x88 || scsi_pointer->this_residual <= 0) {679 imm_fail(dev, DID_ERROR);680 return -1; /* ERROR_RETURN */681 }682 /* determine if we should use burst I/O */683 if (dev->rd == 0) {684 fast = bulk && scsi_pointer->this_residual >=685 IMM_BURST_SIZE ? IMM_BURST_SIZE : 2;686 status = imm_out(dev, scsi_pointer->ptr, fast);687 } else {688 fast = bulk && scsi_pointer->this_residual >=689 IMM_BURST_SIZE ? IMM_BURST_SIZE : 1;690 status = imm_in(dev, scsi_pointer->ptr, fast);691 }692 693 scsi_pointer->ptr += fast;694 scsi_pointer->this_residual -= fast;695 696 if (!status) {697 imm_fail(dev, DID_BUS_BUSY);698 return -1; /* ERROR_RETURN */699 }700 if (scsi_pointer->buffer && !scsi_pointer->this_residual) {701 /* if scatter/gather, advance to the next segment */702 if (scsi_pointer->buffers_residual--) {703 scsi_pointer->buffer =704 sg_next(scsi_pointer->buffer);705 scsi_pointer->this_residual =706 scsi_pointer->buffer->length;707 scsi_pointer->ptr = sg_virt(scsi_pointer->buffer);708 709 /*710 * Make sure that we transfer even number of bytes711 * otherwise it makes imm_byte_out() messy.712 */713 if (scsi_pointer->this_residual & 0x01)714 scsi_pointer->this_residual++;715 }716 }717 /* Now check to see if the drive is ready to comunicate */718 w_ctr(ppb, 0x0c);719 r = (r_str(ppb) & 0xb8);720 721 /* If not, drop back down to the scheduler and wait a timer tick */722 if (!(r & 0x80))723 return 0;724 }725 return 1; /* FINISH_RETURN */726}727 728/*729 * Since the IMM itself doesn't generate interrupts, we use730 * the scheduler's task queue to generate a stream of call-backs and731 * complete the request when the drive is ready.732 */733static void imm_interrupt(struct work_struct *work)734{735 imm_struct *dev = container_of(work, imm_struct, imm_tq.work);736 struct scsi_cmnd *cmd = dev->cur_cmd;737 struct Scsi_Host *host = cmd->device->host;738 unsigned long flags;739 740 if (imm_engine(dev, cmd)) {741 schedule_delayed_work(&dev->imm_tq, 1);742 return;743 }744 /* Command must of completed hence it is safe to let go... */745#if IMM_DEBUG > 0746 switch ((cmd->result >> 16) & 0xff) {747 case DID_OK:748 break;749 case DID_NO_CONNECT:750 printk("imm: no device at SCSI ID %i\n", cmd->device->id);751 break;752 case DID_BUS_BUSY:753 printk("imm: BUS BUSY - EPP timeout detected\n");754 break;755 case DID_TIME_OUT:756 printk("imm: unknown timeout\n");757 break;758 case DID_ABORT:759 printk("imm: told to abort\n");760 break;761 case DID_PARITY:762 printk("imm: parity error (???)\n");763 break;764 case DID_ERROR:765 printk("imm: internal driver error\n");766 break;767 case DID_RESET:768 printk("imm: told to reset device\n");769 break;770 case DID_BAD_INTR:771 printk("imm: bad interrupt (???)\n");772 break;773 default:774 printk("imm: bad return code (%02x)\n",775 (cmd->result >> 16) & 0xff);776 }777#endif778 779 if (imm_scsi_pointer(cmd)->phase > 1)780 imm_disconnect(dev);781 782 imm_pb_dismiss(dev);783 784 spin_lock_irqsave(host->host_lock, flags);785 dev->cur_cmd = NULL;786 scsi_done(cmd);787 spin_unlock_irqrestore(host->host_lock, flags);788 return;789}790 791static int imm_engine(imm_struct *dev, struct scsi_cmnd *const cmd)792{793 struct scsi_pointer *scsi_pointer = imm_scsi_pointer(cmd);794 unsigned short ppb = dev->base;795 unsigned char l = 0, h = 0;796 int retv, x;797 798 /* First check for any errors that may have occurred799 * Here we check for internal errors800 */801 if (dev->failed)802 return 0;803 804 switch (scsi_pointer->phase) {805 case 0: /* Phase 0 - Waiting for parport */806 if (time_after(jiffies, dev->jstart + HZ)) {807 /*808 * We waited more than a second809 * for parport to call us810 */811 imm_fail(dev, DID_BUS_BUSY);812 return 0;813 }814 return 1; /* wait until imm_wakeup claims parport */815 816 case 1: /* Phase 1 - Connected */817 imm_connect(dev, CONNECT_EPP_MAYBE);818 scsi_pointer->phase++;819 fallthrough;820 821 case 2: /* Phase 2 - We are now talking to the scsi bus */822 if (!imm_select(dev, scmd_id(cmd))) {823 imm_fail(dev, DID_NO_CONNECT);824 return 0;825 }826 scsi_pointer->phase++;827 fallthrough;828 829 case 3: /* Phase 3 - Ready to accept a command */830 w_ctr(ppb, 0x0c);831 if (!(r_str(ppb) & 0x80))832 return 1;833 834 if (!imm_send_command(cmd))835 return 0;836 scsi_pointer->phase++;837 fallthrough;838 839 case 4: /* Phase 4 - Setup scatter/gather buffers */840 if (scsi_bufflen(cmd)) {841 scsi_pointer->buffer = scsi_sglist(cmd);842 scsi_pointer->this_residual = scsi_pointer->buffer->length;843 scsi_pointer->ptr = sg_virt(scsi_pointer->buffer);844 } else {845 scsi_pointer->buffer = NULL;846 scsi_pointer->this_residual = 0;847 scsi_pointer->ptr = NULL;848 }849 scsi_pointer->buffers_residual = scsi_sg_count(cmd) - 1;850 scsi_pointer->phase++;851 if (scsi_pointer->this_residual & 0x01)852 scsi_pointer->this_residual++;853 fallthrough;854 855 case 5: /* Phase 5 - Pre-Data transfer stage */856 /* Spin lock for BUSY */857 w_ctr(ppb, 0x0c);858 if (!(r_str(ppb) & 0x80))859 return 1;860 861 /* Require negotiation for read requests */862 x = (r_str(ppb) & 0xb8);863 dev->rd = (x & 0x10) ? 1 : 0;864 dev->dp = (x & 0x20) ? 0 : 1;865 866 if ((dev->dp) && (dev->rd))867 if (imm_negotiate(dev))868 return 0;869 scsi_pointer->phase++;870 fallthrough;871 872 case 6: /* Phase 6 - Data transfer stage */873 /* Spin lock for BUSY */874 w_ctr(ppb, 0x0c);875 if (!(r_str(ppb) & 0x80))876 return 1;877 878 if (dev->dp) {879 retv = imm_completion(cmd);880 if (retv == -1)881 return 0;882 if (retv == 0)883 return 1;884 }885 scsi_pointer->phase++;886 fallthrough;887 888 case 7: /* Phase 7 - Post data transfer stage */889 if ((dev->dp) && (dev->rd)) {890 if ((dev->mode == IMM_NIBBLE) || (dev->mode == IMM_PS2)) {891 w_ctr(ppb, 0x4);892 w_ctr(ppb, 0xc);893 w_ctr(ppb, 0xe);894 w_ctr(ppb, 0x4);895 }896 }897 scsi_pointer->phase++;898 fallthrough;899 900 case 8: /* Phase 8 - Read status/message */901 /* Check for data overrun */902 if (imm_wait(dev) != (unsigned char) 0xb8) {903 imm_fail(dev, DID_ERROR);904 return 0;905 }906 if (imm_negotiate(dev))907 return 0;908 if (imm_in(dev, &l, 1)) { /* read status byte */909 /* Check for optional message byte */910 if (imm_wait(dev) == (unsigned char) 0xb8)911 imm_in(dev, &h, 1);912 cmd->result = (DID_OK << 16) | (l & STATUS_MASK);913 }914 if ((dev->mode == IMM_NIBBLE) || (dev->mode == IMM_PS2)) {915 w_ctr(ppb, 0x4);916 w_ctr(ppb, 0xc);917 w_ctr(ppb, 0xe);918 w_ctr(ppb, 0x4);919 }920 return 0; /* Finished */921 922 default:923 printk("imm: Invalid scsi phase\n");924 }925 return 0;926}927 928static int imm_queuecommand_lck(struct scsi_cmnd *cmd)929{930 imm_struct *dev = imm_dev(cmd->device->host);931 932 if (dev->cur_cmd) {933 printk("IMM: bug in imm_queuecommand\n");934 return 0;935 }936 dev->failed = 0;937 dev->jstart = jiffies;938 dev->cur_cmd = cmd;939 cmd->result = DID_ERROR << 16; /* default return code */940 imm_scsi_pointer(cmd)->phase = 0; /* bus free */941 942 schedule_delayed_work(&dev->imm_tq, 0);943 944 imm_pb_claim(dev);945 946 return 0;947}948 949static DEF_SCSI_QCMD(imm_queuecommand)950 951/*952 * Apparently the disk->capacity attribute is off by 1 sector 953 * for all disk drives. We add the one here, but it should really954 * be done in sd.c. Even if it gets fixed there, this will still955 * work.956 */957static int imm_biosparam(struct scsi_device *sdev, struct block_device *dev,958 sector_t capacity, int ip[])959{960 ip[0] = 0x40;961 ip[1] = 0x20;962 ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);963 if (ip[2] > 1024) {964 ip[0] = 0xff;965 ip[1] = 0x3f;966 ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);967 }968 return 0;969}970 971static int imm_abort(struct scsi_cmnd *cmd)972{973 imm_struct *dev = imm_dev(cmd->device->host);974 /*975 * There is no method for aborting commands since Iomega976 * have tied the SCSI_MESSAGE line high in the interface977 */978 979 switch (imm_scsi_pointer(cmd)->phase) {980 case 0: /* Do not have access to parport */981 case 1: /* Have not connected to interface */982 dev->cur_cmd = NULL; /* Forget the problem */983 return SUCCESS;984 default: /* SCSI command sent, can not abort */985 return FAILED;986 }987}988 989static void imm_reset_pulse(unsigned int base)990{991 w_ctr(base, 0x04);992 w_dtr(base, 0x40);993 udelay(1);994 w_ctr(base, 0x0c);995 w_ctr(base, 0x0d);996 udelay(50);997 w_ctr(base, 0x0c);998 w_ctr(base, 0x04);999}1000 1001static int imm_reset(struct scsi_cmnd *cmd)1002{1003 imm_struct *dev = imm_dev(cmd->device->host);1004 1005 if (imm_scsi_pointer(cmd)->phase)1006 imm_disconnect(dev);1007 dev->cur_cmd = NULL; /* Forget the problem */1008 1009 imm_connect(dev, CONNECT_NORMAL);1010 imm_reset_pulse(dev->base);1011 mdelay(1); /* device settle delay */1012 imm_disconnect(dev);1013 mdelay(1); /* device settle delay */1014 return SUCCESS;1015}1016 1017static int device_check(imm_struct *dev, bool autodetect)1018{1019 /* This routine looks for a device and then attempts to use EPP1020 to send a command. If all goes as planned then EPP is available. */1021 1022 static char cmd[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };1023 int loop, old_mode, status, k, ppb = dev->base;1024 unsigned char l;1025 1026 old_mode = dev->mode;1027 for (loop = 0; loop < 8; loop++) {1028 /* Attempt to use EPP for Test Unit Ready */1029 if (autodetect && (ppb & 0x0007) == 0x0000)1030 dev->mode = IMM_EPP_8;1031 1032 second_pass:1033 imm_connect(dev, CONNECT_EPP_MAYBE);1034 /* Select SCSI device */1035 if (!imm_select(dev, loop)) {1036 imm_disconnect(dev);1037 continue;1038 }1039 printk("imm: Found device at ID %i, Attempting to use %s\n",1040 loop, IMM_MODE_STRING[dev->mode]);1041 1042 /* Send SCSI command */1043 status = 1;1044 w_ctr(ppb, 0x0c);1045 for (l = 0; (l < 3) && (status); l++)1046 status = imm_out(dev, &cmd[l << 1], 2);1047 1048 if (!status) {1049 imm_disconnect(dev);1050 imm_connect(dev, CONNECT_EPP_MAYBE);1051 imm_reset_pulse(dev->base);1052 udelay(1000);1053 imm_disconnect(dev);1054 udelay(1000);1055 if (dev->mode != old_mode) {1056 dev->mode = old_mode;1057 goto second_pass;1058 }1059 printk("imm: Unable to establish communication\n");1060 return -EIO;1061 }1062 w_ctr(ppb, 0x0c);1063 1064 k = 1000000; /* 1 Second */1065 do {1066 l = r_str(ppb);1067 k--;1068 udelay(1);1069 } while (!(l & 0x80) && (k));1070 1071 l &= 0xb8;1072 1073 if (l != 0xb8) {1074 imm_disconnect(dev);1075 imm_connect(dev, CONNECT_EPP_MAYBE);1076 imm_reset_pulse(dev->base);1077 udelay(1000);1078 imm_disconnect(dev);1079 udelay(1000);1080 if (dev->mode != old_mode) {1081 dev->mode = old_mode;1082 goto second_pass;1083 }1084 printk1085 ("imm: Unable to establish communication\n");1086 return -EIO;1087 }1088 imm_disconnect(dev);1089 printk1090 ("imm: Communication established at 0x%x with ID %i using %s\n",1091 ppb, loop, IMM_MODE_STRING[dev->mode]);1092 imm_connect(dev, CONNECT_EPP_MAYBE);1093 imm_reset_pulse(dev->base);1094 udelay(1000);1095 imm_disconnect(dev);1096 udelay(1000);1097 return 0;1098 }1099 printk("imm: No devices found\n");1100 return -ENODEV;1101}1102 1103static const struct scsi_host_template imm_template = {1104 .module = THIS_MODULE,1105 .proc_name = "imm",1106 .show_info = imm_show_info,1107 .write_info = imm_write_info,1108 .name = "Iomega VPI2 (imm) interface",1109 .queuecommand = imm_queuecommand,1110 .eh_abort_handler = imm_abort,1111 .eh_host_reset_handler = imm_reset,1112 .bios_param = imm_biosparam,1113 .this_id = 7,1114 .sg_tablesize = SG_ALL,1115 .can_queue = 1,1116 .cmd_size = sizeof(struct scsi_pointer),1117};1118 1119/***************************************************************************1120 * Parallel port probing routines *1121 ***************************************************************************/1122 1123static LIST_HEAD(imm_hosts);1124 1125/*1126 * Finds the first available device number that can be alloted to the1127 * new imm device and returns the address of the previous node so that1128 * we can add to the tail and have a list in the ascending order.1129 */1130 1131static inline imm_struct *find_parent(void)1132{1133 imm_struct *dev, *par = NULL;1134 unsigned int cnt = 0;1135 1136 if (list_empty(&imm_hosts))1137 return NULL;1138 1139 list_for_each_entry(dev, &imm_hosts, list) {1140 if (dev->dev_no != cnt)1141 return par;1142 cnt++;1143 par = dev;1144 }1145 1146 return par;1147}1148 1149static int __imm_attach(struct parport *pb)1150{1151 struct Scsi_Host *host;1152 imm_struct *dev, *temp;1153 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waiting);1154 DEFINE_WAIT(wait);1155 int ports;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 = mode < IMM_UNKNOWN ? 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 control1184 * 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 dev->base = dev->dev->port->base;1203 dev->base_hi = dev->dev->port->base_hi;1204 w_ctr(dev->base, 0x0c);1205 1206 /* Done configuration */1207 1208 err = imm_init(dev);1209 1210 imm_pb_release(dev);1211 1212 if (err)1213 goto out1;1214 1215 /* now the glue ... */1216 if (dev->mode == IMM_NIBBLE || dev->mode == IMM_PS2)1217 ports = 3;1218 else1219 ports = 8;1220 1221 INIT_DELAYED_WORK(&dev->imm_tq, imm_interrupt);1222 1223 err = -ENOMEM;1224 host = scsi_host_alloc(&imm_template, sizeof(imm_struct *));1225 if (!host)1226 goto out1;1227 host->no_highmem = true;1228 host->io_port = pb->base;1229 host->n_io_port = ports;1230 host->dma_channel = -1;1231 host->unique_id = pb->number;1232 *(imm_struct **)&host->hostdata = dev;1233 dev->host = host;1234 if (!temp)1235 list_add_tail(&dev->list, &imm_hosts);1236 else1237 list_add_tail(&dev->list, &temp->list);1238 err = scsi_add_host(host, NULL);1239 if (err)1240 goto out2;1241 scsi_scan_host(host);1242 return 0;1243 1244out2:1245 list_del_init(&dev->list);1246 scsi_host_put(host);1247out1:1248 parport_unregister_device(dev->dev);1249out:1250 kfree(dev);1251 return err;1252}1253 1254static void imm_attach(struct parport *pb)1255{1256 __imm_attach(pb);1257}1258 1259static void imm_detach(struct parport *pb)1260{1261 imm_struct *dev;1262 list_for_each_entry(dev, &imm_hosts, list) {1263 if (dev->dev->port == pb) {1264 list_del_init(&dev->list);1265 scsi_remove_host(dev->host);1266 scsi_host_put(dev->host);1267 parport_unregister_device(dev->dev);1268 kfree(dev);1269 break;1270 }1271 }1272}1273 1274static struct parport_driver imm_driver = {1275 .name = "imm",1276 .match_port = imm_attach,1277 .detach = imm_detach,1278};1279module_parport_driver(imm_driver);1280 1281MODULE_DESCRIPTION("IOMEGA MatchMaker parallel port SCSI host adapter driver");1282MODULE_LICENSE("GPL");1283