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