1159 lines · c
1/* ppa.c -- low level driver for the IOMEGA PPA3 2 * parallel port SCSI host adapter.3 * 4 * (The PPA3 is the embedded controller in the ZIP drive.)5 * 6 * (c) 1995,1996 Grant R. Guenther, grant@torque.net,7 * under the terms of the GNU General Public License.8 * 9 */10 11#include <linux/init.h>12#include <linux/kernel.h>13#include <linux/slab.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/jiffies.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 28static void ppa_reset_pulse(unsigned int base);29 30typedef struct {31 struct pardevice *dev; /* Parport device entry */32 int base; /* Actual port address */33 int mode; /* Transfer mode */34 struct scsi_cmnd *cur_cmd; /* Current queued command */35 struct delayed_work ppa_tq; /* Polling interrupt stuff */36 unsigned long jstart; /* Jiffies at start */37 unsigned long recon_tmo; /* How many usecs to wait for reconnection (6th bit) */38 unsigned int failed:1; /* Failure flag */39 unsigned wanted:1; /* Parport sharing busy flag */40 unsigned int dev_no; /* Device number */41 wait_queue_head_t *waiting;42 struct Scsi_Host *host;43 struct list_head list;44} ppa_struct;45 46#include "ppa.h"47 48static unsigned int mode = PPA_AUTODETECT;49module_param(mode, uint, 0644);50MODULE_PARM_DESC(mode, "Transfer mode (0 = Autodetect, 1 = SPP 4-bit, "51 "2 = SPP 8-bit, 3 = EPP 8-bit, 4 = EPP 16-bit, 5 = EPP 32-bit");52 53static struct scsi_pointer *ppa_scsi_pointer(struct scsi_cmnd *cmd)54{55 return scsi_cmd_priv(cmd);56}57 58static inline ppa_struct *ppa_dev(struct Scsi_Host *host)59{60 return *(ppa_struct **)&host->hostdata;61}62 63static DEFINE_SPINLOCK(arbitration_lock);64 65static void got_it(ppa_struct *dev)66{67 dev->base = dev->dev->port->base;68 if (dev->cur_cmd)69 ppa_scsi_pointer(dev->cur_cmd)->phase = 1;70 else71 wake_up(dev->waiting);72}73 74static void ppa_wakeup(void *ref)75{76 ppa_struct *dev = (ppa_struct *) ref;77 unsigned long flags;78 79 spin_lock_irqsave(&arbitration_lock, flags);80 if (dev->wanted) {81 parport_claim(dev->dev);82 got_it(dev);83 dev->wanted = 0;84 }85 spin_unlock_irqrestore(&arbitration_lock, flags);86 return;87}88 89static int ppa_pb_claim(ppa_struct *dev)90{91 unsigned long flags;92 int res = 1;93 spin_lock_irqsave(&arbitration_lock, flags);94 if (parport_claim(dev->dev) == 0) {95 got_it(dev);96 res = 0;97 }98 dev->wanted = res;99 spin_unlock_irqrestore(&arbitration_lock, flags);100 return res;101}102 103static void ppa_pb_dismiss(ppa_struct *dev)104{105 unsigned long flags;106 int wanted;107 spin_lock_irqsave(&arbitration_lock, flags);108 wanted = dev->wanted;109 dev->wanted = 0;110 spin_unlock_irqrestore(&arbitration_lock, flags);111 if (!wanted)112 parport_release(dev->dev);113}114 115static inline void ppa_pb_release(ppa_struct *dev)116{117 parport_release(dev->dev);118}119 120/*121 * Start of Chipset kludges122 */123 124/* This is to give the ppa driver a way to modify the timings (and other125 * parameters) by writing to the /proc/scsi/ppa/0 file.126 * Very simple method really... (To simple, no error checking :( )127 * Reason: Kernel hackers HATE having to unload and reload modules for128 * testing...129 * Also gives a method to use a script to obtain optimum timings (TODO)130 */131 132static inline int ppa_write_info(struct Scsi_Host *host, char *buffer, int length)133{134 ppa_struct *dev = ppa_dev(host);135 unsigned long x;136 137 if ((length > 5) && (strncmp(buffer, "mode=", 5) == 0)) {138 x = simple_strtoul(buffer + 5, NULL, 0);139 dev->mode = x;140 return length;141 }142 if ((length > 10) && (strncmp(buffer, "recon_tmo=", 10) == 0)) {143 x = simple_strtoul(buffer + 10, NULL, 0);144 dev->recon_tmo = x;145 printk(KERN_INFO "ppa: recon_tmo set to %ld\n", x);146 return length;147 }148 printk(KERN_WARNING "ppa /proc: invalid variable\n");149 return -EINVAL;150}151 152static int ppa_show_info(struct seq_file *m, struct Scsi_Host *host)153{154 ppa_struct *dev = ppa_dev(host);155 156 seq_printf(m, "Version : %s\n", PPA_VERSION);157 seq_printf(m, "Parport : %s\n", dev->dev->port->name);158 seq_printf(m, "Mode : %s\n", PPA_MODE_STRING[dev->mode]);159#if PPA_DEBUG > 0160 seq_printf(m, "recon_tmo : %lu\n", dev->recon_tmo);161#endif162 return 0;163}164 165static int device_check(ppa_struct *dev, bool autodetect);166 167#if PPA_DEBUG > 0168#define ppa_fail(x,y) printk("ppa: ppa_fail(%i) from %s at line %d\n",\169 y, __func__, __LINE__); ppa_fail_func(x,y);170static inline void ppa_fail_func(ppa_struct *dev, int error_code)171#else172static inline void ppa_fail(ppa_struct *dev, int error_code)173#endif174{175 /* If we fail a device then we trash status / message bytes */176 if (dev->cur_cmd) {177 dev->cur_cmd->result = error_code << 16;178 dev->failed = 1;179 }180}181 182/*183 * Wait for the high bit to be set.184 * 185 * In principle, this could be tied to an interrupt, but the adapter186 * doesn't appear to be designed to support interrupts. We spin on187 * the 0x80 ready bit. 188 */189static unsigned char ppa_wait(ppa_struct *dev)190{191 int k;192 unsigned short ppb = dev->base;193 unsigned char r;194 195 k = PPA_SPIN_TMO;196 /* Wait for bit 6 and 7 - PJC */197 for (r = r_str(ppb); ((r & 0xc0) != 0xc0) && (k); k--) {198 udelay(1);199 r = r_str(ppb);200 }201 202 /*203 * return some status information.204 * Semantics: 0xc0 = ZIP wants more data205 * 0xd0 = ZIP wants to send more data206 * 0xe0 = ZIP is expecting SCSI command data207 * 0xf0 = end of transfer, ZIP is sending status208 */209 if (k)210 return (r & 0xf0);211 212 /* Counter expired - Time out occurred */213 ppa_fail(dev, DID_TIME_OUT);214 printk(KERN_WARNING "ppa timeout in ppa_wait\n");215 return 0; /* command timed out */216}217 218/*219 * Clear EPP Timeout Bit 220 */221static inline void epp_reset(unsigned short ppb)222{223 int i;224 225 i = r_str(ppb);226 w_str(ppb, i);227 w_str(ppb, i & 0xfe);228}229 230/* 231 * Wait for empty ECP fifo (if we are in ECP fifo mode only)232 */233static inline void ecp_sync(ppa_struct *dev)234{235 int i, ppb_hi = dev->dev->port->base_hi;236 237 if (ppb_hi == 0)238 return;239 240 if ((r_ecr(ppb_hi) & 0xe0) == 0x60) { /* mode 011 == ECP fifo mode */241 for (i = 0; i < 100; i++) {242 if (r_ecr(ppb_hi) & 0x01)243 return;244 udelay(5);245 }246 printk(KERN_WARNING "ppa: ECP sync failed as data still present in FIFO.\n");247 }248}249 250static int ppa_byte_out(unsigned short base, const char *buffer, int len)251{252 int i;253 254 for (i = len; i; i--) {255 w_dtr(base, *buffer++);256 w_ctr(base, 0xe);257 w_ctr(base, 0xc);258 }259 return 1; /* All went well - we hope! */260}261 262static int ppa_byte_in(unsigned short base, char *buffer, int len)263{264 int i;265 266 for (i = len; i; i--) {267 *buffer++ = r_dtr(base);268 w_ctr(base, 0x27);269 w_ctr(base, 0x25);270 }271 return 1; /* All went well - we hope! */272}273 274static int ppa_nibble_in(unsigned short base, char *buffer, int len)275{276 for (; len; len--) {277 unsigned char h;278 279 w_ctr(base, 0x4);280 h = r_str(base) & 0xf0;281 w_ctr(base, 0x6);282 *buffer++ = h | ((r_str(base) & 0xf0) >> 4);283 }284 return 1; /* All went well - we hope! */285}286 287static int ppa_out(ppa_struct *dev, char *buffer, int len)288{289 int r;290 unsigned short ppb = dev->base;291 292 r = ppa_wait(dev);293 294 if ((r & 0x50) != 0x40) {295 ppa_fail(dev, DID_ERROR);296 return 0;297 }298 switch (dev->mode) {299 case PPA_NIBBLE:300 case PPA_PS2:301 /* 8 bit output, with a loop */302 r = ppa_byte_out(ppb, buffer, len);303 break;304 305 case PPA_EPP_32:306 case PPA_EPP_16:307 case PPA_EPP_8:308 epp_reset(ppb);309 w_ctr(ppb, 0x4);310 if (dev->mode == PPA_EPP_32 && !(((long) buffer | len) & 0x03))311 outsl(ppb + 4, buffer, len >> 2);312 else if (dev->mode == PPA_EPP_16 && !(((long) buffer | len) & 0x01))313 outsw(ppb + 4, buffer, len >> 1);314 else315 outsb(ppb + 4, buffer, len);316 w_ctr(ppb, 0xc);317 r = !(r_str(ppb) & 0x01);318 w_ctr(ppb, 0xc);319 ecp_sync(dev);320 break;321 322 default:323 printk(KERN_ERR "PPA: bug in ppa_out()\n");324 r = 0;325 }326 return r;327}328 329static int ppa_in(ppa_struct *dev, char *buffer, int len)330{331 int r;332 unsigned short ppb = dev->base;333 334 r = ppa_wait(dev);335 336 if ((r & 0x50) != 0x50) {337 ppa_fail(dev, DID_ERROR);338 return 0;339 }340 switch (dev->mode) {341 case PPA_NIBBLE:342 /* 4 bit input, with a loop */343 r = ppa_nibble_in(ppb, buffer, len);344 w_ctr(ppb, 0xc);345 break;346 347 case PPA_PS2:348 /* 8 bit input, with a loop */349 w_ctr(ppb, 0x25);350 r = ppa_byte_in(ppb, buffer, len);351 w_ctr(ppb, 0x4);352 w_ctr(ppb, 0xc);353 break;354 355 case PPA_EPP_32:356 case PPA_EPP_16:357 case PPA_EPP_8:358 epp_reset(ppb);359 w_ctr(ppb, 0x24);360 if (dev->mode == PPA_EPP_32 && !(((long) buffer | len) & 0x03))361 insl(ppb + 4, buffer, len >> 2);362 else if (dev->mode == PPA_EPP_16 && !(((long) buffer | len) & 0x01))363 insw(ppb + 4, buffer, len >> 1);364 else365 insb(ppb + 4, buffer, len);366 w_ctr(ppb, 0x2c);367 r = !(r_str(ppb) & 0x01);368 w_ctr(ppb, 0x2c);369 ecp_sync(dev);370 break;371 372 default:373 printk(KERN_ERR "PPA: bug in ppa_ins()\n");374 r = 0;375 break;376 }377 return r;378}379 380/* end of ppa_io.h */381static inline void ppa_d_pulse(unsigned short ppb, unsigned char b)382{383 w_dtr(ppb, b);384 w_ctr(ppb, 0xc);385 w_ctr(ppb, 0xe);386 w_ctr(ppb, 0xc);387 w_ctr(ppb, 0x4);388 w_ctr(ppb, 0xc);389}390 391static void ppa_disconnect(ppa_struct *dev)392{393 unsigned short ppb = dev->base;394 395 ppa_d_pulse(ppb, 0);396 ppa_d_pulse(ppb, 0x3c);397 ppa_d_pulse(ppb, 0x20);398 ppa_d_pulse(ppb, 0xf);399}400 401static inline void ppa_c_pulse(unsigned short ppb, unsigned char b)402{403 w_dtr(ppb, b);404 w_ctr(ppb, 0x4);405 w_ctr(ppb, 0x6);406 w_ctr(ppb, 0x4);407 w_ctr(ppb, 0xc);408}409 410static inline void ppa_connect(ppa_struct *dev, int flag)411{412 unsigned short ppb = dev->base;413 414 ppa_c_pulse(ppb, 0);415 ppa_c_pulse(ppb, 0x3c);416 ppa_c_pulse(ppb, 0x20);417 if ((flag == CONNECT_EPP_MAYBE) && IN_EPP_MODE(dev->mode))418 ppa_c_pulse(ppb, 0xcf);419 else420 ppa_c_pulse(ppb, 0x8f);421}422 423static int ppa_select(ppa_struct *dev, int target)424{425 int k;426 unsigned short ppb = dev->base;427 428 /*429 * Bit 6 (0x40) is the device selected bit.430 * First we must wait till the current device goes off line...431 */432 k = PPA_SELECT_TMO;433 do {434 k--;435 udelay(1);436 } while ((r_str(ppb) & 0x40) && (k));437 if (!k)438 return 0;439 440 w_dtr(ppb, (1 << target));441 w_ctr(ppb, 0xe);442 w_ctr(ppb, 0xc);443 w_dtr(ppb, 0x80); /* This is NOT the initator */444 w_ctr(ppb, 0x8);445 446 k = PPA_SELECT_TMO;447 do {448 k--;449 udelay(1);450 }451 while (!(r_str(ppb) & 0x40) && (k));452 if (!k)453 return 0;454 455 return 1;456}457 458/* 459 * This is based on a trace of what the Iomega DOS 'guest' driver does.460 * I've tried several different kinds of parallel ports with guest and461 * coded this to react in the same ways that it does.462 * 463 * The return value from this function is just a hint about where the464 * handshaking failed.465 * 466 */467static int ppa_init(ppa_struct *dev)468{469 int retv;470 unsigned short ppb = dev->base;471 bool autodetect = dev->mode == PPA_AUTODETECT;472 473 if (autodetect) {474 int modes = dev->dev->port->modes;475 int ppb_hi = dev->dev->port->base_hi;476 477 /* Mode detection works up the chain of speed478 * This avoids a nasty if-then-else-if-... tree479 */480 dev->mode = PPA_NIBBLE;481 482 if (modes & PARPORT_MODE_TRISTATE)483 dev->mode = PPA_PS2;484 485 if (modes & PARPORT_MODE_ECP) {486 w_ecr(ppb_hi, 0x20);487 dev->mode = PPA_PS2;488 }489 if ((modes & PARPORT_MODE_EPP) && (modes & PARPORT_MODE_ECP))490 w_ecr(ppb_hi, 0x80);491 }492 493 ppa_disconnect(dev);494 ppa_connect(dev, CONNECT_NORMAL);495 496 retv = 2; /* Failed */497 498 w_ctr(ppb, 0xe);499 if ((r_str(ppb) & 0x08) == 0x08)500 retv--;501 502 w_ctr(ppb, 0xc);503 if ((r_str(ppb) & 0x08) == 0x00)504 retv--;505 506 if (!retv)507 ppa_reset_pulse(ppb);508 udelay(1000); /* Allow devices to settle down */509 ppa_disconnect(dev);510 udelay(1000); /* Another delay to allow devices to settle */511 512 if (retv)513 return -EIO;514 515 return device_check(dev, autodetect);516}517 518static inline int ppa_send_command(struct scsi_cmnd *cmd)519{520 ppa_struct *dev = ppa_dev(cmd->device->host);521 int k;522 523 w_ctr(dev->base, 0x0c);524 525 for (k = 0; k < cmd->cmd_len; k++)526 if (!ppa_out(dev, &cmd->cmnd[k], 1))527 return 0;528 return 1;529}530 531/*532 * The bulk flag enables some optimisations in the data transfer loops,533 * it should be true for any command that transfers data in integral534 * numbers of sectors.535 * 536 * The driver appears to remain stable if we speed up the parallel port537 * i/o in this function, but not elsewhere.538 */539static int ppa_completion(struct scsi_cmnd *const cmd)540{541 /* Return codes:542 * -1 Error543 * 0 Told to schedule544 * 1 Finished data transfer545 */546 struct scsi_pointer *scsi_pointer = ppa_scsi_pointer(cmd);547 ppa_struct *dev = ppa_dev(cmd->device->host);548 unsigned short ppb = dev->base;549 unsigned long start_jiffies = jiffies;550 551 unsigned char r, v;552 int fast, bulk, status;553 554 v = cmd->cmnd[0];555 bulk = ((v == READ_6) ||556 (v == READ_10) || (v == WRITE_6) || (v == WRITE_10));557 558 /*559 * We only get here if the drive is ready to comunicate,560 * hence no need for a full ppa_wait.561 */562 r = (r_str(ppb) & 0xf0);563 564 while (r != (unsigned char) 0xf0) {565 /*566 * If we have been running for more than a full timer tick567 * then take a rest.568 */569 if (time_after(jiffies, start_jiffies + 1))570 return 0;571 572 if (scsi_pointer->this_residual <= 0) {573 ppa_fail(dev, DID_ERROR);574 return -1; /* ERROR_RETURN */575 }576 577 /* On some hardware we have SCSI disconnected (6th bit low)578 * for about 100usecs. It is too expensive to wait a 579 * tick on every loop so we busy wait for no more than580 * 500usecs to give the drive a chance first. We do not 581 * change things for "normal" hardware since generally 582 * the 6th bit is always high.583 * This makes the CPU load higher on some hardware 584 * but otherwise we can not get more than 50K/secs 585 * on this problem hardware.586 */587 if ((r & 0xc0) != 0xc0) {588 /* Wait for reconnection should be no more than 589 * jiffy/2 = 5ms = 5000 loops590 */591 unsigned long k = dev->recon_tmo;592 for (; k && ((r = (r_str(ppb) & 0xf0)) & 0xc0) != 0xc0;593 k--)594 udelay(1);595 596 if (!k)597 return 0;598 }599 600 /* determine if we should use burst I/O */601 fast = bulk && scsi_pointer->this_residual >= PPA_BURST_SIZE ?602 PPA_BURST_SIZE : 1;603 604 if (r == (unsigned char) 0xc0)605 status = ppa_out(dev, scsi_pointer->ptr, fast);606 else607 status = ppa_in(dev, scsi_pointer->ptr, fast);608 609 scsi_pointer->ptr += fast;610 scsi_pointer->this_residual -= fast;611 612 if (!status) {613 ppa_fail(dev, DID_BUS_BUSY);614 return -1; /* ERROR_RETURN */615 }616 if (scsi_pointer->buffer && !scsi_pointer->this_residual) {617 /* if scatter/gather, advance to the next segment */618 if (scsi_pointer->buffers_residual--) {619 scsi_pointer->buffer =620 sg_next(scsi_pointer->buffer);621 scsi_pointer->this_residual =622 scsi_pointer->buffer->length;623 scsi_pointer->ptr =624 sg_virt(scsi_pointer->buffer);625 }626 }627 /* Now check to see if the drive is ready to comunicate */628 r = (r_str(ppb) & 0xf0);629 /* If not, drop back down to the scheduler and wait a timer tick */630 if (!(r & 0x80))631 return 0;632 }633 return 1; /* FINISH_RETURN */634}635 636/*637 * Since the PPA itself doesn't generate interrupts, we use638 * the scheduler's task queue to generate a stream of call-backs and639 * complete the request when the drive is ready.640 */641static void ppa_interrupt(struct work_struct *work)642{643 ppa_struct *dev = container_of(work, ppa_struct, ppa_tq.work);644 struct scsi_cmnd *cmd = dev->cur_cmd;645 646 if (!cmd) {647 printk(KERN_ERR "PPA: bug in ppa_interrupt\n");648 return;649 }650 if (ppa_engine(dev, cmd)) {651 schedule_delayed_work(&dev->ppa_tq, 1);652 return;653 }654 /* Command must of completed hence it is safe to let go... */655#if PPA_DEBUG > 0656 switch ((cmd->result >> 16) & 0xff) {657 case DID_OK:658 break;659 case DID_NO_CONNECT:660 printk(KERN_DEBUG "ppa: no device at SCSI ID %i\n", scmd_id(cmd));661 break;662 case DID_BUS_BUSY:663 printk(KERN_DEBUG "ppa: BUS BUSY - EPP timeout detected\n");664 break;665 case DID_TIME_OUT:666 printk(KERN_DEBUG "ppa: unknown timeout\n");667 break;668 case DID_ABORT:669 printk(KERN_DEBUG "ppa: told to abort\n");670 break;671 case DID_PARITY:672 printk(KERN_DEBUG "ppa: parity error (???)\n");673 break;674 case DID_ERROR:675 printk(KERN_DEBUG "ppa: internal driver error\n");676 break;677 case DID_RESET:678 printk(KERN_DEBUG "ppa: told to reset device\n");679 break;680 case DID_BAD_INTR:681 printk(KERN_WARNING "ppa: bad interrupt (???)\n");682 break;683 default:684 printk(KERN_WARNING "ppa: bad return code (%02x)\n",685 (cmd->result >> 16) & 0xff);686 }687#endif688 689 if (ppa_scsi_pointer(cmd)->phase > 1)690 ppa_disconnect(dev);691 692 ppa_pb_dismiss(dev);693 694 dev->cur_cmd = NULL;695 696 scsi_done(cmd);697}698 699static int ppa_engine(ppa_struct *dev, struct scsi_cmnd *cmd)700{701 struct scsi_pointer *scsi_pointer = ppa_scsi_pointer(cmd);702 unsigned short ppb = dev->base;703 unsigned char l = 0, h = 0;704 int retv;705 706 /* First check for any errors that may of occurred707 * Here we check for internal errors708 */709 if (dev->failed)710 return 0;711 712 switch (scsi_pointer->phase) {713 case 0: /* Phase 0 - Waiting for parport */714 if (time_after(jiffies, dev->jstart + HZ)) {715 /*716 * We waited more than a second717 * for parport to call us718 */719 ppa_fail(dev, DID_BUS_BUSY);720 return 0;721 }722 return 1; /* wait until ppa_wakeup claims parport */723 case 1: /* Phase 1 - Connected */724 { /* Perform a sanity check for cable unplugged */725 int retv = 2; /* Failed */726 727 ppa_connect(dev, CONNECT_EPP_MAYBE);728 729 w_ctr(ppb, 0xe);730 if ((r_str(ppb) & 0x08) == 0x08)731 retv--;732 733 w_ctr(ppb, 0xc);734 if ((r_str(ppb) & 0x08) == 0x00)735 retv--;736 737 if (retv) {738 if (time_after(jiffies, dev->jstart + (1 * HZ))) {739 printk(KERN_ERR "ppa: Parallel port cable is unplugged.\n");740 ppa_fail(dev, DID_BUS_BUSY);741 return 0;742 } else {743 ppa_disconnect(dev);744 return 1; /* Try again in a jiffy */745 }746 }747 scsi_pointer->phase++;748 }749 fallthrough;750 751 case 2: /* Phase 2 - We are now talking to the scsi bus */752 if (!ppa_select(dev, scmd_id(cmd))) {753 ppa_fail(dev, DID_NO_CONNECT);754 return 0;755 }756 scsi_pointer->phase++;757 fallthrough;758 759 case 3: /* Phase 3 - Ready to accept a command */760 w_ctr(ppb, 0x0c);761 if (!(r_str(ppb) & 0x80))762 return 1;763 764 if (!ppa_send_command(cmd))765 return 0;766 scsi_pointer->phase++;767 fallthrough;768 769 case 4: /* Phase 4 - Setup scatter/gather buffers */770 if (scsi_bufflen(cmd)) {771 scsi_pointer->buffer = scsi_sglist(cmd);772 scsi_pointer->this_residual =773 scsi_pointer->buffer->length;774 scsi_pointer->ptr = sg_virt(scsi_pointer->buffer);775 } else {776 scsi_pointer->buffer = NULL;777 scsi_pointer->this_residual = 0;778 scsi_pointer->ptr = NULL;779 }780 scsi_pointer->buffers_residual = scsi_sg_count(cmd) - 1;781 scsi_pointer->phase++;782 fallthrough;783 784 case 5: /* Phase 5 - Data transfer stage */785 w_ctr(ppb, 0x0c);786 if (!(r_str(ppb) & 0x80))787 return 1;788 789 retv = ppa_completion(cmd);790 if (retv == -1)791 return 0;792 if (retv == 0)793 return 1;794 scsi_pointer->phase++;795 fallthrough;796 797 case 6: /* Phase 6 - Read status/message */798 cmd->result = DID_OK << 16;799 /* Check for data overrun */800 if (ppa_wait(dev) != (unsigned char) 0xf0) {801 ppa_fail(dev, DID_ERROR);802 return 0;803 }804 if (ppa_in(dev, &l, 1)) { /* read status byte */805 /* Check for optional message byte */806 if (ppa_wait(dev) == (unsigned char) 0xf0)807 ppa_in(dev, &h, 1);808 cmd->result =809 (DID_OK << 16) + (h << 8) + (l & STATUS_MASK);810 }811 return 0; /* Finished */812 813 default:814 printk(KERN_ERR "ppa: Invalid scsi phase\n");815 }816 return 0;817}818 819static int ppa_queuecommand_lck(struct scsi_cmnd *cmd)820{821 ppa_struct *dev = ppa_dev(cmd->device->host);822 823 if (dev->cur_cmd) {824 printk(KERN_ERR "PPA: bug in ppa_queuecommand\n");825 return 0;826 }827 dev->failed = 0;828 dev->jstart = jiffies;829 dev->cur_cmd = cmd;830 cmd->result = DID_ERROR << 16; /* default return code */831 ppa_scsi_pointer(cmd)->phase = 0; /* bus free */832 833 schedule_delayed_work(&dev->ppa_tq, 0);834 835 ppa_pb_claim(dev);836 837 return 0;838}839 840static DEF_SCSI_QCMD(ppa_queuecommand)841 842/*843 * Apparently the disk->capacity attribute is off by 1 sector 844 * for all disk drives. We add the one here, but it should really845 * be done in sd.c. Even if it gets fixed there, this will still846 * work.847 */848static int ppa_biosparam(struct scsi_device *sdev, struct block_device *dev,849 sector_t capacity, int ip[])850{851 ip[0] = 0x40;852 ip[1] = 0x20;853 ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);854 if (ip[2] > 1024) {855 ip[0] = 0xff;856 ip[1] = 0x3f;857 ip[2] = ((unsigned long) capacity + 1) / (ip[0] * ip[1]);858 if (ip[2] > 1023)859 ip[2] = 1023;860 }861 return 0;862}863 864static int ppa_abort(struct scsi_cmnd *cmd)865{866 ppa_struct *dev = ppa_dev(cmd->device->host);867 /*868 * There is no method for aborting commands since Iomega869 * have tied the SCSI_MESSAGE line high in the interface870 */871 872 switch (ppa_scsi_pointer(cmd)->phase) {873 case 0: /* Do not have access to parport */874 case 1: /* Have not connected to interface */875 dev->cur_cmd = NULL; /* Forget the problem */876 return SUCCESS;877 default: /* SCSI command sent, can not abort */878 return FAILED;879 }880}881 882static void ppa_reset_pulse(unsigned int base)883{884 w_dtr(base, 0x40);885 w_ctr(base, 0x8);886 udelay(30);887 w_ctr(base, 0xc);888}889 890static int ppa_reset(struct scsi_cmnd *cmd)891{892 ppa_struct *dev = ppa_dev(cmd->device->host);893 894 if (ppa_scsi_pointer(cmd)->phase)895 ppa_disconnect(dev);896 dev->cur_cmd = NULL; /* Forget the problem */897 898 ppa_connect(dev, CONNECT_NORMAL);899 ppa_reset_pulse(dev->base);900 mdelay(1); /* device settle delay */901 ppa_disconnect(dev);902 mdelay(1); /* device settle delay */903 return SUCCESS;904}905 906static int device_check(ppa_struct *dev, bool autodetect)907{908 /* This routine looks for a device and then attempts to use EPP909 to send a command. If all goes as planned then EPP is available. */910 911 static u8 cmd[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };912 int loop, old_mode, status, k, ppb = dev->base;913 unsigned char l;914 915 old_mode = dev->mode;916 for (loop = 0; loop < 8; loop++) {917 /* Attempt to use EPP for Test Unit Ready */918 if (autodetect && (ppb & 0x0007) == 0x0000)919 dev->mode = PPA_EPP_8;920 921second_pass:922 ppa_connect(dev, CONNECT_EPP_MAYBE);923 /* Select SCSI device */924 if (!ppa_select(dev, loop)) {925 ppa_disconnect(dev);926 continue;927 }928 printk(KERN_INFO "ppa: Found device at ID %i, Attempting to use %s\n",929 loop, PPA_MODE_STRING[dev->mode]);930 931 /* Send SCSI command */932 status = 1;933 w_ctr(ppb, 0x0c);934 for (l = 0; (l < 6) && (status); l++)935 status = ppa_out(dev, cmd, 1);936 937 if (!status) {938 ppa_disconnect(dev);939 ppa_connect(dev, CONNECT_EPP_MAYBE);940 w_dtr(ppb, 0x40);941 w_ctr(ppb, 0x08);942 udelay(30);943 w_ctr(ppb, 0x0c);944 udelay(1000);945 ppa_disconnect(dev);946 udelay(1000);947 if (dev->mode != old_mode) {948 dev->mode = old_mode;949 goto second_pass;950 }951 return -EIO;952 }953 w_ctr(ppb, 0x0c);954 k = 1000000; /* 1 Second */955 do {956 l = r_str(ppb);957 k--;958 udelay(1);959 } while (!(l & 0x80) && (k));960 961 l &= 0xf0;962 963 if (l != 0xf0) {964 ppa_disconnect(dev);965 ppa_connect(dev, CONNECT_EPP_MAYBE);966 ppa_reset_pulse(ppb);967 udelay(1000);968 ppa_disconnect(dev);969 udelay(1000);970 if (dev->mode != old_mode) {971 dev->mode = old_mode;972 goto second_pass;973 }974 return -EIO;975 }976 ppa_disconnect(dev);977 printk(KERN_INFO "ppa: Communication established with ID %i using %s\n",978 loop, PPA_MODE_STRING[dev->mode]);979 ppa_connect(dev, CONNECT_EPP_MAYBE);980 ppa_reset_pulse(ppb);981 udelay(1000);982 ppa_disconnect(dev);983 udelay(1000);984 return 0;985 }986 return -ENODEV;987}988 989static const struct scsi_host_template ppa_template = {990 .module = THIS_MODULE,991 .proc_name = "ppa",992 .show_info = ppa_show_info,993 .write_info = ppa_write_info,994 .name = "Iomega VPI0 (ppa) interface",995 .queuecommand = ppa_queuecommand,996 .eh_abort_handler = ppa_abort,997 .eh_host_reset_handler = ppa_reset,998 .bios_param = ppa_biosparam,999 .this_id = -1,1000 .sg_tablesize = SG_ALL,1001 .can_queue = 1,1002 .cmd_size = sizeof(struct scsi_pointer),1003};1004 1005/***************************************************************************1006 * Parallel port probing routines *1007 ***************************************************************************/1008 1009static LIST_HEAD(ppa_hosts);1010 1011/*1012 * Finds the first available device number that can be alloted to the1013 * new ppa device and returns the address of the previous node so that1014 * we can add to the tail and have a list in the ascending order.1015 */1016 1017static inline ppa_struct *find_parent(void)1018{1019 ppa_struct *dev, *par = NULL;1020 unsigned int cnt = 0;1021 1022 if (list_empty(&ppa_hosts))1023 return NULL;1024 1025 list_for_each_entry(dev, &ppa_hosts, list) {1026 if (dev->dev_no != cnt)1027 return par;1028 cnt++;1029 par = dev;1030 }1031 1032 return par;1033}1034 1035static int __ppa_attach(struct parport *pb)1036{1037 struct Scsi_Host *host;1038 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waiting);1039 DEFINE_WAIT(wait);1040 ppa_struct *dev, *temp;1041 int ports;1042 int err = -ENOMEM;1043 struct pardev_cb ppa_cb;1044 1045 dev = kzalloc(sizeof(ppa_struct), GFP_KERNEL);1046 if (!dev)1047 return -ENOMEM;1048 dev->base = -1;1049 dev->mode = mode < PPA_UNKNOWN ? mode : PPA_AUTODETECT;1050 dev->recon_tmo = PPA_RECON_TMO;1051 init_waitqueue_head(&waiting);1052 temp = find_parent();1053 if (temp)1054 dev->dev_no = temp->dev_no + 1;1055 1056 memset(&ppa_cb, 0, sizeof(ppa_cb));1057 ppa_cb.private = dev;1058 ppa_cb.wakeup = ppa_wakeup;1059 1060 dev->dev = parport_register_dev_model(pb, "ppa", &ppa_cb, dev->dev_no);1061 1062 if (!dev->dev)1063 goto out;1064 1065 /* Claim the bus so it remembers what we do to the control1066 * registers. [ CTR and ECP ]1067 */1068 err = -EBUSY;1069 dev->waiting = &waiting;1070 prepare_to_wait(&waiting, &wait, TASK_UNINTERRUPTIBLE);1071 if (ppa_pb_claim(dev))1072 schedule_timeout(3 * HZ);1073 if (dev->wanted) {1074 printk(KERN_ERR "ppa%d: failed to claim parport because "1075 "a pardevice is owning the port for too long "1076 "time!\n", pb->number);1077 ppa_pb_dismiss(dev);1078 dev->waiting = NULL;1079 finish_wait(&waiting, &wait);1080 goto out1;1081 }1082 dev->waiting = NULL;1083 finish_wait(&waiting, &wait);1084 dev->base = dev->dev->port->base;1085 w_ctr(dev->base, 0x0c);1086 1087 /* Done configuration */1088 1089 err = ppa_init(dev);1090 ppa_pb_release(dev);1091 1092 if (err)1093 goto out1;1094 1095 /* now the glue ... */1096 if (dev->mode == PPA_NIBBLE || dev->mode == PPA_PS2)1097 ports = 3;1098 else1099 ports = 8;1100 1101 INIT_DELAYED_WORK(&dev->ppa_tq, ppa_interrupt);1102 1103 err = -ENOMEM;1104 host = scsi_host_alloc(&ppa_template, sizeof(ppa_struct *));1105 if (!host)1106 goto out1;1107 host->no_highmem = true;1108 host->io_port = pb->base;1109 host->n_io_port = ports;1110 host->dma_channel = -1;1111 host->unique_id = pb->number;1112 *(ppa_struct **)&host->hostdata = dev;1113 dev->host = host;1114 list_add_tail(&dev->list, &ppa_hosts);1115 err = scsi_add_host(host, NULL);1116 if (err)1117 goto out2;1118 scsi_scan_host(host);1119 return 0;1120out2:1121 list_del_init(&dev->list);1122 scsi_host_put(host);1123out1:1124 parport_unregister_device(dev->dev);1125out:1126 kfree(dev);1127 return err;1128}1129 1130static void ppa_attach(struct parport *pb)1131{1132 __ppa_attach(pb);1133}1134 1135static void ppa_detach(struct parport *pb)1136{1137 ppa_struct *dev;1138 list_for_each_entry(dev, &ppa_hosts, list) {1139 if (dev->dev->port == pb) {1140 list_del_init(&dev->list);1141 scsi_remove_host(dev->host);1142 scsi_host_put(dev->host);1143 parport_unregister_device(dev->dev);1144 kfree(dev);1145 break;1146 }1147 }1148}1149 1150static struct parport_driver ppa_driver = {1151 .name = "ppa",1152 .match_port = ppa_attach,1153 .detach = ppa_detach,1154};1155module_parport_driver(ppa_driver);1156 1157MODULE_DESCRIPTION("IOMEGA PPA3 parallel port SCSI host adapter driver");1158MODULE_LICENSE("GPL");1159