1/* 2 * ultrastor.c Copyright (C) 1992 David B. Gentzel 3 * Low-level SCSI driver for UltraStor 14F, 24F, and 34F 4 * by David B. Gentzel, Whitfield Software Services, Carnegie, PA 5 * (gentzel@nova.enet.dec.com) 6 * scatter/gather added by Scott Taylor (n217cg@tamuts.tamu.edu) 7 * 24F and multiple command support by John F. Carr (jfc@athena.mit.edu) 8 * John's work modified by Caleb Epstein (cae@jpmorgan.com) and 9 * Eric Youngdale (ericy@cais.com). 10 * Thanks to UltraStor for providing the necessary documentation 11 * 12 * This is an old driver, for the 14F and 34F you should be using the 13 * u14-34f driver instead. 14 */ 15 16/* 17 * TODO: 18 * 1. Find out why scatter/gather is limited to 16 requests per command. 19 * This is fixed, at least on the 24F, as of version 1.12 - CAE. 20 * 2. Look at command linking (mscp.command_link and 21 * mscp.command_link_id). (Does not work with many disks, 22 * and no performance increase. ERY). 23 * 3. Allow multiple adapters. 24 */ 25 26/* 27 * NOTES: 28 * The UltraStor 14F, 24F, and 34F are a family of intelligent, high 29 * performance SCSI-2 host adapters. They all support command queueing 30 * and scatter/gather I/O. Some of them can also emulate the standard 31 * WD1003 interface for use with OS's which don't support SCSI. Here 32 * is the scoop on the various models: 33 * 14F - ISA first-party DMA HA with floppy support and WD1003 emulation. 34 * 14N - ISA HA with floppy support. I think that this is a non-DMA 35 * HA. Nothing further known. 36 * 24F - EISA Bus Master HA with floppy support and WD1003 emulation. 37 * 34F - VL-Bus Bus Master HA with floppy support (no WD1003 emulation). 38 * 39 * The 14F, 24F, and 34F are supported by this driver. 40 * 41 * Places flagged with a triple question-mark are things which are either 42 * unfinished, questionable, or wrong. 43 */ 44 45/* Changes from version 1.11 alpha to 1.12 46 * 47 * Increased the size of the scatter-gather list to 33 entries for 48 * the 24F adapter (it was 16). I don't have the specs for the 14F 49 * or the 34F, so they may support larger s-g lists as well. 50 * 51 * Caleb Epstein <cae@jpmorgan.com> 52 */ 53 54/* Changes from version 1.9 to 1.11 55 * 56 * Patches to bring this driver up to speed with the default kernel 57 * driver which supports only the 14F and 34F adapters. This version 58 * should compile cleanly into 0.99.13, 0.99.12 and probably 0.99.11. 59 * 60 * Fixes from Eric Youngdale to fix a few possible race conditions and 61 * several problems with bit testing operations (insufficient 62 * parentheses). 63 * 64 * Removed the ultrastor_abort() and ultrastor_reset() functions 65 * (enclosed them in #if 0 / #endif). These functions, at least on 66 * the 24F, cause the SCSI bus to do odd things and generally lead to 67 * kernel panics and machine hangs. This is like the Adaptec code. 68 * 69 * Use check/snarf_region for 14f, 34f to avoid I/O space address conflicts. 70 */ 71 72/* Changes from version 1.8 to version 1.9 73 * 74 * 0.99.11 patches (cae@jpmorgan.com) */ 75 76/* Changes from version 1.7 to version 1.8 77 * 78 * Better error reporting. 79 */ 80 81/* Changes from version 1.6 to version 1.7 82 * 83 * Removed CSIR command code. 84 * 85 * Better race condition avoidance (xchgb function added). 86 * 87 * Set ICM and OGM status to zero at probe (24F) 88 * 89 * reset sends soft reset to UltraStor adapter 90 * 91 * reset adapter if adapter interrupts with an invalid MSCP address 92 * 93 * handle aborted command interrupt (24F) 94 * 95 */ 96 97/* Changes from version 1.5 to version 1.6: 98 * 99 * Read MSCP address from ICM _before_ clearing the interrupt flag. 100 * This fixes a race condition. 101 */ 102 103/* Changes from version 1.4 to version 1.5: 104 * 105 * Abort now calls done when multiple commands are enabled. 106 * 107 * Clear busy when aborted command finishes, not when abort is called. 108 * 109 * More debugging messages for aborts. 110 */ 111 112/* Changes from version 1.3 to version 1.4: 113 * 114 * Enable automatic request of sense data on error (requires newer version 115 * of scsi.c to be useful). 116 * 117 * Fix PORT_OVERRIDE for 14F. 118 * 119 * Fix abort and reset to work properly (config.aborted wasn't cleared 120 * after it was tested, so after a command abort no further commands would 121 * work). 122 * 123 * Boot time test to enable SCSI bus reset (defaults to not allowing reset). 124 * 125 * Fix test for OGM busy -- the busy bit is in different places on the 24F. 126 * 127 * Release ICM slot by clearing first byte on 24F. 128 */ 129 130#include <linux/module.h> 131#include <linux/blkdev.h> 132#include <linux/interrupt.h> 133#include <linux/stddef.h> 134#include <linux/string.h> 135#include <linux/kernel.h> 136#include <linux/ioport.h> 137#include <linux/proc_fs.h> 138#include <linux/spinlock.h> 139#include <linux/stat.h> 140#include <linux/bitops.h> 141 142#include <asm/io.h> 143#include <asm/system.h> 144#include <asm/dma.h> 145 146#define ULTRASTOR_PRIVATE /* Get the private stuff from ultrastor.h */ 147#include "scsi.h" 148#include <scsi/scsi_host.h> 149#include "ultrastor.h" 150 151#define FALSE 0 152#define TRUE 1 153 154#ifndef ULTRASTOR_DEBUG 155#define ULTRASTOR_DEBUG (UD_ABORT|UD_CSIR|UD_RESET) 156#endif 157 158#define VERSION "1.12" 159 160#define PACKED __attribute__((packed)) 161#define ALIGNED(x) __attribute__((aligned(x))) 162 163 164/* The 14F uses an array of 4-byte ints for its scatter/gather list. 165 The data can be unaligned, but need not be. It's easier to give 166 the list normal alignment since it doesn't need to fit into a 167 packed structure. */ 168 169typedef struct { 170 u32 address; 171 u32 num_bytes; 172} ultrastor_sg_list; 173 174 175/* MailBox SCSI Command Packet. Basic command structure for communicating 176 with controller. */ 177struct mscp { 178 unsigned char opcode: 3; /* type of command */ 179 unsigned char xdir: 2; /* data transfer direction */ 180 unsigned char dcn: 1; /* disable disconnect */ 181 unsigned char ca: 1; /* use cache (if available) */ 182 unsigned char sg: 1; /* scatter/gather operation */ 183 unsigned char target_id: 3; /* target SCSI id */ 184 unsigned char ch_no: 2; /* SCSI channel (always 0 for 14f) */ 185 unsigned char lun: 3; /* logical unit number */ 186 unsigned int transfer_data PACKED; /* transfer data pointer */ 187 unsigned int transfer_data_length PACKED; /* length in bytes */ 188 unsigned int command_link PACKED; /* for linking command chains */ 189 unsigned char scsi_command_link_id; /* identifies command in chain */ 190 unsigned char number_of_sg_list; /* (if sg is set) 8 bytes per list */ 191 unsigned char length_of_sense_byte; 192 unsigned char length_of_scsi_cdbs; /* 6, 10, or 12 */ 193 unsigned char scsi_cdbs[12]; /* SCSI commands */ 194 unsigned char adapter_status; /* non-zero indicates HA error */ 195 unsigned char target_status; /* non-zero indicates target error */ 196 u32 sense_data PACKED; 197 /* The following fields are for software only. They are included in 198 the MSCP structure because they are associated with SCSI requests. */ 199 void (*done) (struct scsi_cmnd *); 200 struct scsi_cmnd *SCint; 201 ultrastor_sg_list sglist[ULTRASTOR_24F_MAX_SG]; /* use larger size for 24F */ 202}; 203 204 205/* Port addresses (relative to the base address) */ 206#define U14F_PRODUCT_ID(port) ((port) + 0x4) 207#define CONFIG(port) ((port) + 0x6) 208 209/* Port addresses relative to the doorbell base address. */ 210#define LCL_DOORBELL_MASK(port) ((port) + 0x0) 211#define LCL_DOORBELL_INTR(port) ((port) + 0x1) 212#define SYS_DOORBELL_MASK(port) ((port) + 0x2) 213#define SYS_DOORBELL_INTR(port) ((port) + 0x3) 214 215 216/* Used to store configuration info read from config i/o registers. Most of 217 this is not used yet, but might as well save it. 218 219 This structure also holds port addresses that are not at the same offset 220 on the 14F and 24F. 221 222 This structure holds all data that must be duplicated to support multiple 223 adapters. */ 224 225static struct ultrastor_config 226{ 227 unsigned short port_address; /* base address of card */ 228 unsigned short doorbell_address; /* base address of doorbell CSRs */ 229 unsigned short ogm_address; /* base address of OGM */ 230 unsigned short icm_address; /* base address of ICM */ 231 const void *bios_segment; 232 unsigned char interrupt: 4; 233 unsigned char dma_channel: 3; 234 unsigned char bios_drive_number: 1; 235 unsigned char heads; 236 unsigned char sectors; 237 unsigned char ha_scsi_id: 3; 238 unsigned char subversion: 4; 239 unsigned char revision; 240 /* The slot number is used to distinguish the 24F (slot != 0) from 241 the 14F and 34F (slot == 0). */ 242 unsigned char slot; 243 244#ifdef PRINT_U24F_VERSION 245 volatile int csir_done; 246#endif 247 248 /* A pool of MSCP structures for this adapter, and a bitmask of 249 busy structures. (If ULTRASTOR_14F_MAX_CMDS == 1, a 1 byte 250 busy flag is used instead.) */ 251 252#if ULTRASTOR_MAX_CMDS == 1 253 unsigned char mscp_busy; 254#else 255 unsigned long mscp_free; 256#endif 257 volatile unsigned char aborted[ULTRASTOR_MAX_CMDS]; 258 struct mscp mscp[ULTRASTOR_MAX_CMDS]; 259} config = {0}; 260 261/* Set this to 1 to reset the SCSI bus on error. */ 262static int ultrastor_bus_reset; 263 264 265/* Allowed BIOS base addresses (NULL indicates reserved) */ 266static const void *const bios_segment_table[8] = { 267 NULL, (void *)0xC4000, (void *)0xC8000, (void *)0xCC000, 268 (void *)0xD0000, (void *)0xD4000, (void *)0xD8000, (void *)0xDC000, 269}; 270 271/* Allowed IRQs for 14f */ 272static const unsigned char interrupt_table_14f[4] = { 15, 14, 11, 10 }; 273 274/* Allowed DMA channels for 14f (0 indicates reserved) */ 275static const unsigned char dma_channel_table_14f[4] = { 5, 6, 7, 0 }; 276 277/* Head/sector mappings allowed by 14f */ 278static const struct { 279 unsigned char heads; 280 unsigned char sectors; 281} mapping_table[4] = { { 16, 63 }, { 64, 32 }, { 64, 63 }, { 64, 32 } }; 282 283#ifndef PORT_OVERRIDE 284/* ??? A probe of address 0x310 screws up NE2000 cards */ 285static const unsigned short ultrastor_ports_14f[] = { 286 0x330, 0x340, /*0x310,*/ 0x230, 0x240, 0x210, 0x130, 0x140, 287}; 288#endif 289 290static void ultrastor_interrupt(void *); 291static irqreturn_t do_ultrastor_interrupt(int, void *); 292static inline void build_sg_list(struct mscp *, struct scsi_cmnd *SCpnt); 293 294 295/* Always called with host lock held */ 296 297static inline int find_and_clear_bit_16(unsigned long *field) 298{ 299 int rv; 300 301 if (*field == 0) 302 panic("No free mscp"); 303 304 asm volatile ( 305 "xorl %0,%0\n\t" 306 "0: bsfw %1,%w0\n\t" 307 "btr %0,%1\n\t" 308 "jnc 0b" 309 : "=&r" (rv), "=m" (*field) :); 310 311 return rv; 312} 313 314/* This has been re-implemented with the help of Richard Earnshaw, 315 <rwe@pegasus.esprit.ec.org> and works with gcc-2.5.8 and gcc-2.6.0. 316 The instability noted by jfc below appears to be a bug in 317 gcc-2.5.x when compiling w/o optimization. --Caleb 318 319 This asm is fragile: it doesn't work without the casts and it may 320 not work without optimization. Maybe I should add a swap builtin 321 to gcc. --jfc */ 322static inline unsigned char xchgb(unsigned char reg, 323 volatile unsigned char *mem) 324{ 325 __asm__ ("xchgb %0,%1" : "=q" (reg), "=m" (*mem) : "0" (reg)); 326 return reg; 327} 328 329#if ULTRASTOR_DEBUG & (UD_COMMAND | UD_ABORT) 330 331/* Always called with the host lock held */ 332static void log_ultrastor_abort(struct ultrastor_config *config, 333 int command) 334{ 335 static char fmt[80] = "abort %d (%x); MSCP free pool: %x;"; 336 int i; 337 338 for (i = 0; i < ULTRASTOR_MAX_CMDS; i++) 339 { 340 fmt[20 + i*2] = ' '; 341 if (! (config->mscp_free & (1 << i))) 342 fmt[21 + i*2] = '0' + config->mscp[i].target_id; 343 else 344 fmt[21 + i*2] = '-'; 345 } 346 fmt[20 + ULTRASTOR_MAX_CMDS * 2] = '\n'; 347 fmt[21 + ULTRASTOR_MAX_CMDS * 2] = 0; 348 printk(fmt, command, &config->mscp[command], config->mscp_free); 349 350} 351#endif 352 353static int ultrastor_14f_detect(struct scsi_host_template * tpnt) 354{ 355 size_t i; 356 unsigned char in_byte, version_byte = 0; 357 struct config_1 { 358 unsigned char bios_segment: 3; 359 unsigned char removable_disks_as_fixed: 1; 360 unsigned char interrupt: 2; 361 unsigned char dma_channel: 2; 362 } config_1; 363 struct config_2 { 364 unsigned char ha_scsi_id: 3; 365 unsigned char mapping_mode: 2; 366 unsigned char bios_drive_number: 1; 367 unsigned char tfr_port: 2; 368 } config_2; 369 370#if (ULTRASTOR_DEBUG & UD_DETECT) 371 printk("US14F: detect: called\n"); 372#endif 373 374 /* If a 24F has already been configured, don't look for a 14F. */ 375 if (config.bios_segment) 376 return FALSE; 377 378#ifdef PORT_OVERRIDE 379 if(!request_region(PORT_OVERRIDE, 0xc, "ultrastor")) { 380 printk("Ultrastor I/O space already in use\n"); 381 return FALSE; 382 }; 383 config.port_address = PORT_OVERRIDE; 384#else 385 for (i = 0; i < ARRAY_SIZE(ultrastor_ports_14f); i++) { 386 if(!request_region(ultrastor_ports_14f[i], 0x0c, "ultrastor")) continue; 387 config.port_address = ultrastor_ports_14f[i]; 388#endif 389 390#if (ULTRASTOR_DEBUG & UD_DETECT) 391 printk("US14F: detect: testing port address %03X\n", config.port_address); 392#endif 393 394 in_byte = inb(U14F_PRODUCT_ID(config.port_address)); 395 if (in_byte != US14F_PRODUCT_ID_0) { 396#if (ULTRASTOR_DEBUG & UD_DETECT) 397# ifdef PORT_OVERRIDE 398 printk("US14F: detect: wrong product ID 0 - %02X\n", in_byte); 399# else 400 printk("US14F: detect: no adapter at port %03X\n", config.port_address); 401# endif 402#endif 403#ifdef PORT_OVERRIDE 404 goto out_release_port; 405#else 406 release_region(config.port_address, 0x0c); 407 continue; 408#endif 409 } 410 in_byte = inb(U14F_PRODUCT_ID(config.port_address) + 1); 411 /* Only upper nibble is significant for Product ID 1 */ 412 if ((in_byte & 0xF0) != US14F_PRODUCT_ID_1) { 413#if (ULTRASTOR_DEBUG & UD_DETECT) 414# ifdef PORT_OVERRIDE 415 printk("US14F: detect: wrong product ID 1 - %02X\n", in_byte); 416# else 417 printk("US14F: detect: no adapter at port %03X\n", config.port_address); 418# endif 419#endif 420#ifdef PORT_OVERRIDE 421 goto out_release_port; 422#else 423 release_region(config.port_address, 0x0c); 424 continue; 425#endif 426 } 427 version_byte = in_byte; 428#ifndef PORT_OVERRIDE 429 break; 430 } 431 if (i == ARRAY_SIZE(ultrastor_ports_14f)) { 432# if (ULTRASTOR_DEBUG & UD_DETECT) 433 printk("US14F: detect: no port address found!\n"); 434# endif 435 /* all ports probed already released - we can just go straight out */ 436 return FALSE; 437 } 438#endif 439 440#if (ULTRASTOR_DEBUG & UD_DETECT) 441 printk("US14F: detect: adapter found at port address %03X\n", 442 config.port_address); 443#endif 444 445 /* Set local doorbell mask to disallow bus reset unless 446 ultrastor_bus_reset is true. */ 447 outb(ultrastor_bus_reset ? 0xc2 : 0x82, LCL_DOORBELL_MASK(config.port_address)); 448 449 /* All above tests passed, must be the right thing. Get some useful 450 info. */ 451 452 /* Register the I/O space that we use */ 453 454 *(char *)&config_1 = inb(CONFIG(config.port_address + 0)); 455 *(char *)&config_2 = inb(CONFIG(config.port_address + 1)); 456 config.bios_segment = bios_segment_table[config_1.bios_segment]; 457 config.doorbell_address = config.port_address; 458 config.ogm_address = config.port_address + 0x8; 459 config.icm_address = config.port_address + 0xC; 460 config.interrupt = interrupt_table_14f[config_1.interrupt]; 461 config.ha_scsi_id = config_2.ha_scsi_id; 462 config.heads = mapping_table[config_2.mapping_mode].heads; 463 config.sectors = mapping_table[config_2.mapping_mode].sectors; 464 config.bios_drive_number = config_2.bios_drive_number; 465 config.subversion = (version_byte & 0x0F); 466 if (config.subversion == U34F) 467 config.dma_channel = 0; 468 else 469 config.dma_channel = dma_channel_table_14f[config_1.dma_channel]; 470 471 if (!config.bios_segment) { 472#if (ULTRASTOR_DEBUG & UD_DETECT) 473 printk("US14F: detect: not detected.\n"); 474#endif 475 goto out_release_port; 476 } 477 478 /* Final consistency check, verify previous info. */ 479 if (config.subversion != U34F) 480 if (!config.dma_channel || !(config_2.tfr_port & 0x2)) { 481#if (ULTRASTOR_DEBUG & UD_DETECT) 482 printk("US14F: detect: consistency check failed\n"); 483#endif 484 goto out_release_port; 485 } 486 487 /* If we were TRULY paranoid, we could issue a host adapter inquiry 488 command here and verify the data returned. But frankly, I'm 489 exhausted! */ 490 491 /* Finally! Now I'm satisfied... */ 492#if (ULTRASTOR_DEBUG & UD_DETECT) 493 printk("US14F: detect: detect succeeded\n" 494 " Port address: %03X\n" 495 " BIOS segment: %05X\n" 496 " Interrupt: %u\n" 497 " DMA channel: %u\n" 498 " H/A SCSI ID: %u\n" 499 " Subversion: %u\n", 500 config.port_address, config.bios_segment, config.interrupt, 501 config.dma_channel, config.ha_scsi_id, config.subversion); 502#endif 503 tpnt->this_id = config.ha_scsi_id; 504 tpnt->unchecked_isa_dma = (config.subversion != U34F); 505 506#if ULTRASTOR_MAX_CMDS > 1 507 config.mscp_free = ~0; 508#endif 509 510 if (request_irq(config.interrupt, do_ultrastor_interrupt, 0, "Ultrastor", &config.mscp[0].SCint->device->host)) { 511 printk("Unable to allocate IRQ%u for UltraStor controller.\n", 512 config.interrupt); 513 goto out_release_port; 514 } 515 if (config.dma_channel && request_dma(config.dma_channel,"Ultrastor")) { 516 printk("Unable to allocate DMA channel %u for UltraStor controller.\n", 517 config.dma_channel); 518 free_irq(config.interrupt, NULL); 519 goto out_release_port; 520 } 521 tpnt->sg_tablesize = ULTRASTOR_14F_MAX_SG; 522 printk("UltraStor driver version" VERSION ". Using %d SG lists.\n", 523 ULTRASTOR_14F_MAX_SG); 524 525 return TRUE; 526out_release_port: 527 release_region(config.port_address, 0x0c); 528 return FALSE; 529} 530 531static int ultrastor_24f_detect(struct scsi_host_template * tpnt) 532{ 533 int i; 534 struct Scsi_Host * shpnt = NULL; 535 536#if (ULTRASTOR_DEBUG & UD_DETECT) 537 printk("US24F: detect"); 538#endif 539 540 /* probe each EISA slot at slot address C80 */ 541 for (i = 1; i < 15; i++) 542 { 543 unsigned char config_1, config_2; 544 unsigned short addr = (i << 12) | ULTRASTOR_24F_PORT; 545 546 if (inb(addr) != US24F_PRODUCT_ID_0 && 547 inb(addr+1) != US24F_PRODUCT_ID_1 && 548 inb(addr+2) != US24F_PRODUCT_ID_2) 549 continue; 550 551 config.revision = inb(addr+3); 552 config.slot = i; 553 if (! (inb(addr+4) & 1)) 554 { 555#if (ULTRASTOR_DEBUG & UD_DETECT) 556 printk("U24F: found disabled card in slot %u\n", i); 557#endif 558 continue; 559 } 560#if (ULTRASTOR_DEBUG & UD_DETECT) 561 printk("U24F: found card in slot %u\n", i); 562#endif 563 config_1 = inb(addr + 5); 564 config.bios_segment = bios_segment_table[config_1 & 7]; 565 switch(config_1 >> 4) 566 { 567 case 1: 568 config.interrupt = 15; 569 break; 570 case 2: 571 config.interrupt = 14; 572 break; 573 case 4: 574 config.interrupt = 11; 575 break; 576 case 8: 577 config.interrupt = 10; 578 break; 579 default: 580 printk("U24F: invalid IRQ\n"); 581 return FALSE; 582 } 583 584 /* BIOS addr set */ 585 /* base port set */ 586 config.port_address = addr; 587 config.doorbell_address = addr + 12; 588 config.ogm_address = addr + 0x17; 589 config.icm_address = addr + 0x1C; 590 config_2 = inb(addr + 7); 591 config.ha_scsi_id = config_2 & 7; 592 config.heads = mapping_table[(config_2 >> 3) & 3].heads; 593 config.sectors = mapping_table[(config_2 >> 3) & 3].sectors; 594#if (ULTRASTOR_DEBUG & UD_DETECT) 595 printk("US24F: detect: detect succeeded\n" 596 " Port address: %03X\n" 597 " BIOS segment: %05X\n" 598 " Interrupt: %u\n" 599 " H/A SCSI ID: %u\n", 600 config.port_address, config.bios_segment, 601 config.interrupt, config.ha_scsi_id); 602#endif 603 tpnt->this_id = config.ha_scsi_id; 604 tpnt->unchecked_isa_dma = 0; 605 tpnt->sg_tablesize = ULTRASTOR_24F_MAX_SG; 606 607 shpnt = scsi_register(tpnt, 0); 608 if (!shpnt) { 609 printk(KERN_WARNING "(ultrastor:) Could not register scsi device. Aborting registration.\n"); 610 free_irq(config.interrupt, do_ultrastor_interrupt); 611 return FALSE; 612 } 613 614 if (request_irq(config.interrupt, do_ultrastor_interrupt, 0, "Ultrastor", shpnt)) 615 { 616 printk("Unable to allocate IRQ%u for UltraStor controller.\n", 617 config.interrupt); 618 return FALSE; 619 } 620 621 shpnt->irq = config.interrupt; 622 shpnt->dma_channel = config.dma_channel; 623 shpnt->io_port = config.port_address; 624 625#if ULTRASTOR_MAX_CMDS > 1 626 config.mscp_free = ~0; 627#endif 628 /* Mark ICM and OGM free */ 629 outb(0, addr + 0x16); 630 outb(0, addr + 0x1B); 631 632 /* Set local doorbell mask to disallow bus reset unless 633 ultrastor_bus_reset is true. */ 634 outb(ultrastor_bus_reset ? 0xc2 : 0x82, LCL_DOORBELL_MASK(addr+12)); 635 outb(0x02, SYS_DOORBELL_MASK(addr+12)); 636 printk("UltraStor driver version " VERSION ". Using %d SG lists.\n", 637 tpnt->sg_tablesize); 638 return TRUE; 639 } 640 return FALSE; 641} 642 643static int ultrastor_detect(struct scsi_host_template * tpnt) 644{ 645 tpnt->proc_name = "ultrastor"; 646 return ultrastor_14f_detect(tpnt) || ultrastor_24f_detect(tpnt); 647} 648 649static int ultrastor_release(struct Scsi_Host *shost) 650{ 651 if (shost->irq) 652 free_irq(shost->irq, NULL); 653 if (shost->dma_channel != 0xff) 654 free_dma(shost->dma_channel); 655 if (shost->io_port && shost->n_io_port) 656 release_region(shost->io_port, shost->n_io_port); 657 scsi_unregister(shost); 658 return 0; 659} 660 661static const char *ultrastor_info(struct Scsi_Host * shpnt) 662{ 663 static char buf[64]; 664 665 if (config.slot) 666 sprintf(buf, "UltraStor 24F SCSI @ Slot %u IRQ%u", 667 config.slot, config.interrupt); 668 else if (config.subversion) 669 sprintf(buf, "UltraStor 34F SCSI @ Port %03X BIOS %05X IRQ%u", 670 config.port_address, (int)config.bios_segment, 671 config.interrupt); 672 else 673 sprintf(buf, "UltraStor 14F SCSI @ Port %03X BIOS %05X IRQ%u DMA%u", 674 config.port_address, (int)config.bios_segment, 675 config.interrupt, config.dma_channel); 676 return buf; 677} 678 679static inline void build_sg_list(struct mscp *mscp, struct scsi_cmnd *SCpnt) 680{ 681 struct scatterlist *sg; 682 long transfer_length = 0; 683 int i, max; 684 685 max = scsi_sg_count(SCpnt); 686 scsi_for_each_sg(SCpnt, sg, max, i) { 687 mscp->sglist[i].address = isa_page_to_bus(sg_page(sg)) + sg->offset; 688 mscp->sglist[i].num_bytes = sg->length; 689 transfer_length += sg->length; 690 } 691 mscp->number_of_sg_list = max; 692 mscp->transfer_data = isa_virt_to_bus(mscp->sglist); 693 /* ??? May not be necessary. Docs are unclear as to whether transfer 694 length field is ignored or whether it should be set to the total 695 number of bytes of the transfer. */ 696 mscp->transfer_data_length = transfer_length; 697} 698 699static int ultrastor_queuecommand(struct scsi_cmnd *SCpnt, 700 void (*done) (struct scsi_cmnd *)) 701{ 702 struct mscp *my_mscp; 703#if ULTRASTOR_MAX_CMDS > 1 704 int mscp_index; 705#endif 706 unsigned int status; 707 708 /* Next test is for debugging; "can't happen" */ 709 if ((config.mscp_free & ((1U << ULTRASTOR_MAX_CMDS) - 1)) == 0) 710 panic("ultrastor_queuecommand: no free MSCP\n"); 711 mscp_index = find_and_clear_bit_16(&config.mscp_free); 712 713 /* Has the command been aborted? */ 714 if (xchgb(0xff, &config.aborted[mscp_index]) != 0) 715 { 716 status = DID_ABORT << 16; 717 goto aborted; 718 } 719 720 my_mscp = &config.mscp[mscp_index]; 721 722 *(unsigned char *)my_mscp = OP_SCSI | (DTD_SCSI << 3); 723 724 /* Tape drives don't work properly if the cache is used. The SCSI 725 READ command for a tape doesn't have a block offset, and the adapter 726 incorrectly assumes that all reads from the tape read the same 727 blocks. Results will depend on read buffer size and other disk 728 activity. 729 730 ??? Which other device types should never use the cache? */ 731 my_mscp->ca = SCpnt->device->type != TYPE_TAPE; 732 my_mscp->target_id = SCpnt->device->id; 733 my_mscp->ch_no = 0; 734 my_mscp->lun = SCpnt->device->lun; 735 if (scsi_sg_count(SCpnt)) { 736 /* Set scatter/gather flag in SCSI command packet */ 737 my_mscp->sg = TRUE; 738 build_sg_list(my_mscp, SCpnt); 739 } else { 740 /* Unset scatter/gather flag in SCSI command packet */ 741 my_mscp->sg = FALSE; 742 my_mscp->transfer_data = isa_virt_to_bus(scsi_sglist(SCpnt)); 743 my_mscp->transfer_data_length = scsi_bufflen(SCpnt); 744 } 745 my_mscp->command_link = 0; /*???*/ 746 my_mscp->scsi_command_link_id = 0; /*???*/ 747 my_mscp->length_of_sense_byte = SCSI_SENSE_BUFFERSIZE; 748 my_mscp->length_of_scsi_cdbs = SCpnt->cmd_len; 749 memcpy(my_mscp->scsi_cdbs, SCpnt->cmnd, my_mscp->length_of_scsi_cdbs); 750 my_mscp->adapter_status = 0; 751 my_mscp->target_status = 0; 752 my_mscp->sense_data = isa_virt_to_bus(&SCpnt->sense_buffer); 753 my_mscp->done = done; 754 my_mscp->SCint = SCpnt; 755 SCpnt->host_scribble = (unsigned char *)my_mscp; 756 757 758retry: 759 if (config.slot) 760 while (inb(config.ogm_address - 1) != 0 && config.aborted[mscp_index] == 0xff) 761 barrier(); 762 763 /* else??? */ 764 765 while ((inb(LCL_DOORBELL_INTR(config.doorbell_address)) & (config.slot ? 2 : 1)) && config.aborted[mscp_index] == 0xff) 766 barrier(); 767 768 /* To avoid race conditions, keep the code to write to the adapter 769 atomic. This simplifies the abort code. Right now the 770 scsi mid layer has the host_lock already held 771 */ 772 773 if (inb(LCL_DOORBELL_INTR(config.doorbell_address)) & (config.slot ? 2 : 1)) 774 goto retry; 775 776 status = xchgb(0, &config.aborted[mscp_index]); 777 if (status != 0xff) { 778 779#if ULTRASTOR_DEBUG & (UD_COMMAND | UD_ABORT) 780 printk("USx4F: queuecommand: aborted\n"); 781#if ULTRASTOR_MAX_CMDS > 1 782 log_ultrastor_abort(&config, mscp_index); 783#endif 784#endif 785 status <<= 16; 786 787 aborted: 788 set_bit(mscp_index, &config.mscp_free); 789 /* If the driver queues commands, call the done proc here. Otherwise 790 return an error. */ 791#if ULTRASTOR_MAX_CMDS > 1 792 SCpnt->result = status; 793 done(SCpnt); 794 return 0; 795#else 796 return status; 797#endif 798 } 799 800 /* Store pointer in OGM address bytes */ 801 outl(isa_virt_to_bus(my_mscp), config.ogm_address); 802 803 /* Issue OGM interrupt */ 804 if (config.slot) { 805 /* Write OGM command register on 24F */ 806 outb(1, config.ogm_address - 1); 807 outb(0x2, LCL_DOORBELL_INTR(config.doorbell_address)); 808 } else { 809 outb(0x1, LCL_DOORBELL_INTR(config.doorbell_address)); 810 } 811 812#if (ULTRASTOR_DEBUG & UD_COMMAND) 813 printk("USx4F: queuecommand: returning\n"); 814#endif 815 816 return 0; 817} 818 819/* This code must deal with 2 cases: 820 821 1. The command has not been written to the OGM. In this case, set 822 the abort flag and return. 823 824 2. The command has been written to the OGM and is stuck somewhere in 825 the adapter. 826 827 2a. On a 24F, ask the adapter to abort the command. It will interrupt 828 when it does. 829 830 2b. Call the command's done procedure. 831 832 */ 833 834static int ultrastor_abort(struct scsi_cmnd *SCpnt) 835{ 836#if ULTRASTOR_DEBUG & UD_ABORT 837 char out[108]; 838 unsigned char icm_status = 0, ogm_status = 0; 839 unsigned int icm_addr = 0, ogm_addr = 0; 840#endif 841 unsigned int mscp_index; 842 unsigned char old_aborted; 843 unsigned long flags; 844 void (*done)(struct scsi_cmnd *); 845 struct Scsi_Host *host = SCpnt->device->host; 846 847 if(config.slot) 848 return FAILED; /* Do not attempt an abort for the 24f */ 849 850 /* Simple consistency checking */ 851 if(!SCpnt->host_scribble) 852 return FAILED; 853 854 mscp_index = ((struct mscp *)SCpnt->host_scribble) - config.mscp; 855 if (mscp_index >= ULTRASTOR_MAX_CMDS) 856 panic("Ux4F aborting invalid MSCP"); 857 858#if ULTRASTOR_DEBUG & UD_ABORT 859 if (config.slot) 860 { 861 int port0 = (config.slot << 12) | 0xc80; 862 int i; 863 unsigned long flags; 864 865 spin_lock_irqsave(host->host_lock, flags); 866 strcpy(out, "OGM %d:%x ICM %d:%x ports: "); 867 for (i = 0; i < 16; i++) 868 { 869 unsigned char p = inb(port0 + i); 870 out[28 + i * 3] = "0123456789abcdef"[p >> 4]; 871 out[29 + i * 3] = "0123456789abcdef"[p & 15]; 872 out[30 + i * 3] = ' '; 873 } 874 out[28 + i * 3] = '\n'; 875 out[29 + i * 3] = 0; 876 ogm_status = inb(port0 + 22); 877 ogm_addr = (unsigned int)isa_bus_to_virt(inl(port0 + 23)); 878 icm_status = inb(port0 + 27); 879 icm_addr = (unsigned int)isa_bus_to_virt(inl(port0 + 28)); 880 spin_unlock_irqrestore(host->host_lock, flags); 881 } 882 883 /* First check to see if an interrupt is pending. I suspect the SiS 884 chipset loses interrupts. (I also suspect is mangles data, but 885 one bug at a time... */ 886 if (config.slot ? inb(config.icm_address - 1) == 2 : 887 (inb(SYS_DOORBELL_INTR(config.doorbell_address)) & 1)) 888 { 889 printk("Ux4F: abort while completed command pending\n"); 890 891 spin_lock_irqsave(host->host_lock, flags); 892 ultrastor_interrupt(NULL); 893 spin_unlock_irqrestore(host->host_lock, flags); 894 return SUCCESS; 895 } 896#endif 897 898 old_aborted = xchgb(DID_ABORT, &config.aborted[mscp_index]); 899 900 /* aborted == 0xff is the signal that queuecommand has not yet sent 901 the command. It will notice the new abort flag and fail. */ 902 if (old_aborted == 0xff) 903 return SUCCESS; 904 905 /* On 24F, send an abort MSCP request. The adapter will interrupt 906 and the interrupt handler will call done. */ 907 if (config.slot && inb(config.ogm_address - 1) == 0) 908 { 909 unsigned long flags; 910 911 spin_lock_irqsave(host->host_lock, flags); 912 outl(isa_virt_to_bus(&config.mscp[mscp_index]), config.ogm_address); 913 udelay(8); 914 outb(0x80, config.ogm_address - 1); 915 outb(0x2, LCL_DOORBELL_INTR(config.doorbell_address)); 916#if ULTRASTOR_DEBUG & UD_ABORT 917 log_ultrastor_abort(&config, mscp_index); 918 printk(out, ogm_status, ogm_addr, icm_status, icm_addr); 919#endif 920 spin_unlock_irqrestore(host->host_lock, flags); 921 return SUCCESS; 922 } 923 924#if ULTRASTOR_DEBUG & UD_ABORT 925 log_ultrastor_abort(&config, mscp_index); 926#endif 927 928 /* Can't request a graceful abort. Either this is not a 24F or 929 the OGM is busy. Don't free the command -- the adapter might 930 still be using it. Setting SCint = 0 causes the interrupt 931 handler to ignore the command. */ 932 933 934#if ULTRASTOR_DEBUG & UD_ABORT 935 if (config.mscp[mscp_index].SCint != SCpnt) 936 printk("abort: command mismatch, %p != %p\n", 937 config.mscp[mscp_index].SCint, SCpnt); 938#endif 939 if (config.mscp[mscp_index].SCint == NULL) 940 return FAILED; 941 942 if (config.mscp[mscp_index].SCint != SCpnt) panic("Bad abort"); 943 config.mscp[mscp_index].SCint = NULL; 944 done = config.mscp[mscp_index].done; 945 config.mscp[mscp_index].done = NULL; 946 SCpnt->result = DID_ABORT << 16; 947 948 /* Take the host lock to guard against scsi layer re-entry */ 949 done(SCpnt); 950 951 /* Need to set a timeout here in case command never completes. */ 952 return SUCCESS; 953} 954 955static int ultrastor_host_reset(struct scsi_cmnd * SCpnt) 956{ 957 unsigned long flags; 958 int i; 959 struct Scsi_Host *host = SCpnt->device->host; 960 961#if (ULTRASTOR_DEBUG & UD_RESET) 962 printk("US14F: reset: called\n"); 963#endif 964 965 if(config.slot) 966 return FAILED; 967 968 spin_lock_irqsave(host->host_lock, flags); 969 /* Reset the adapter and SCSI bus. The SCSI bus reset can be 970 inhibited by clearing ultrastor_bus_reset before probe. */ 971 outb(0xc0, LCL_DOORBELL_INTR(config.doorbell_address)); 972 if (config.slot) 973 { 974 outb(0, config.ogm_address - 1); 975 outb(0, config.icm_address - 1); 976 } 977 978#if ULTRASTOR_MAX_CMDS == 1 979 if (config.mscp_busy && config.mscp->done && config.mscp->SCint) 980 { 981 config.mscp->SCint->result = DID_RESET << 16; 982 config.mscp->done(config.mscp->SCint); 983 } 984 config.mscp->SCint = 0; 985#else 986 for (i = 0; i < ULTRASTOR_MAX_CMDS; i++) 987 { 988 if (! (config.mscp_free & (1 << i)) && 989 config.mscp[i].done && config.mscp[i].SCint) 990 { 991 config.mscp[i].SCint->result = DID_RESET << 16; 992 config.mscp[i].done(config.mscp[i].SCint); 993 config.mscp[i].done = NULL; 994 } 995 config.mscp[i].SCint = NULL; 996 } 997#endif 998 999 1000 memset((unsigned char *)config.aborted, 0, sizeof config.aborted); 1001#if ULTRASTOR_MAX_CMDS == 1 1002 config.mscp_busy = 0; 1003#else 1004 config.mscp_free = ~0; 1005#endif 1006 1007 spin_unlock_irqrestore(host->host_lock, flags); 1008 return SUCCESS; 1009 1010} 1011 1012int ultrastor_biosparam(struct scsi_device *sdev, struct block_device *bdev, 1013 sector_t capacity, int * dkinfo) 1014{ 1015 int size = capacity; 1016 unsigned int s = config.heads * config.sectors; 1017 1018 dkinfo[0] = config.heads; 1019 dkinfo[1] = config.sectors; 1020 dkinfo[2] = size / s; /* Ignore partial cylinders */ 1021 return 0; 1022} 1023 1024static void ultrastor_interrupt(void *dev_id) 1025{ 1026 unsigned int status; 1027#if ULTRASTOR_MAX_CMDS > 1 1028 unsigned int mscp_index; 1029#endif 1030 struct mscp *mscp; 1031 void (*done) (struct scsi_cmnd *); 1032 struct scsi_cmnd *SCtmp; 1033 1034#if ULTRASTOR_MAX_CMDS == 1 1035 mscp = &config.mscp[0]; 1036#else 1037 mscp = (struct mscp *)isa_bus_to_virt(inl(config.icm_address)); 1038 mscp_index = mscp - config.mscp; 1039 if (mscp_index >= ULTRASTOR_MAX_CMDS) { 1040 printk("Ux4F interrupt: bad MSCP address %x\n", (unsigned int) mscp); 1041 /* A command has been lost. Reset and report an error 1042 for all commands. */ 1043 ultrastor_host_reset(dev_id); 1044 return; 1045 } 1046#endif 1047 1048 /* Clean ICM slot (set ICMINT bit to 0) */ 1049 if (config.slot) { 1050 unsigned char icm_status = inb(config.icm_address - 1); 1051#if ULTRASTOR_DEBUG & (UD_INTERRUPT|UD_ERROR|UD_ABORT) 1052 if (icm_status != 1 && icm_status != 2) 1053 printk("US24F: ICM status %x for MSCP %d (%x)\n", icm_status, 1054 mscp_index, (unsigned int) mscp); 1055#endif 1056 /* The manual says clear interrupt then write 0 to ICM status. 1057 This seems backwards, but I'll do it anyway. --jfc */ 1058 outb(2, SYS_DOORBELL_INTR(config.doorbell_address)); 1059 outb(0, config.icm_address - 1); 1060 if (icm_status == 4) { 1061 printk("UltraStor abort command failed\n"); 1062 return; 1063 } 1064 if (icm_status == 3) { 1065 void (*done)(struct scsi_cmnd *) = mscp->done; 1066 if (done) { 1067 mscp->done = NULL; 1068 mscp->SCint->result = DID_ABORT << 16; 1069 done(mscp->SCint); 1070 } 1071 return; 1072 } 1073 } else { 1074 outb(1, SYS_DOORBELL_INTR(config.doorbell_address)); 1075 } 1076 1077 SCtmp = mscp->SCint; 1078 mscp->SCint = NULL; 1079 1080 if (!SCtmp) 1081 { 1082#if ULTRASTOR_DEBUG & (UD_ABORT|UD_INTERRUPT) 1083 printk("MSCP %d (%x): no command\n", mscp_index, (unsigned int) mscp); 1084#endif 1085#if ULTRASTOR_MAX_CMDS == 1 1086 config.mscp_busy = FALSE; 1087#else 1088 set_bit(mscp_index, &config.mscp_free); 1089#endif 1090 config.aborted[mscp_index] = 0; 1091 return; 1092 } 1093 1094 /* Save done locally and zero before calling. This is needed as 1095 once we call done, we may get another command queued before this 1096 interrupt service routine can return. */ 1097 done = mscp->done; 1098 mscp->done = NULL; 1099 1100 /* Let the higher levels know that we're done */ 1101 switch (mscp->adapter_status) 1102 { 1103 case 0: 1104 status = DID_OK << 16; 1105 break; 1106 case 0x01: /* invalid command */ 1107 case 0x02: /* invalid parameters */ 1108 case 0x03: /* invalid data list */ 1109 default: 1110 status = DID_ERROR << 16; 1111 break; 1112 case 0x84: /* SCSI bus abort */ 1113 status = DID_ABORT << 16; 1114 break; 1115 case 0x91: 1116 status = DID_TIME_OUT << 16; 1117 break; 1118 } 1119 1120 SCtmp->result = status | mscp->target_status; 1121 1122 SCtmp->host_scribble = NULL; 1123 1124 /* Free up mscp block for next command */ 1125#if ULTRASTOR_MAX_CMDS == 1 1126 config.mscp_busy = FALSE; 1127#else 1128 set_bit(mscp_index, &config.mscp_free); 1129#endif 1130 1131#if ULTRASTOR_DEBUG & (UD_ABORT|UD_INTERRUPT) 1132 if (config.aborted[mscp_index]) 1133 printk("Ux4 interrupt: MSCP %d (%x) aborted = %d\n", 1134 mscp_index, (unsigned int) mscp, config.aborted[mscp_index]); 1135#endif 1136 config.aborted[mscp_index] = 0; 1137 1138 if (done) 1139 done(SCtmp); 1140 else 1141 printk("US14F: interrupt: unexpected interrupt\n"); 1142 1143 if (config.slot ? inb(config.icm_address - 1) : 1144 (inb(SYS_DOORBELL_INTR(config.doorbell_address)) & 1)) 1145#if (ULTRASTOR_DEBUG & UD_MULTI_CMD) 1146 printk("Ux4F: multiple commands completed\n"); 1147#else 1148 ; 1149#endif 1150 1151#if (ULTRASTOR_DEBUG & UD_INTERRUPT) 1152 printk("USx4F: interrupt: returning\n"); 1153#endif 1154} 1155 1156static irqreturn_t do_ultrastor_interrupt(int irq, void *dev_id) 1157{ 1158 unsigned long flags; 1159 struct Scsi_Host *dev = dev_id; 1160 1161 spin_lock_irqsave(dev->host_lock, flags); 1162 ultrastor_interrupt(dev_id); 1163 spin_unlock_irqrestore(dev->host_lock, flags); 1164 return IRQ_HANDLED; 1165} 1166 1167MODULE_LICENSE("GPL"); 1168 1169static struct scsi_host_template driver_template = { 1170 .name = "UltraStor 14F/24F/34F", 1171 .detect = ultrastor_detect, 1172 .release = ultrastor_release, 1173 .info = ultrastor_info, 1174 .queuecommand = ultrastor_queuecommand, 1175 .eh_abort_handler = ultrastor_abort, 1176 .eh_host_reset_handler = ultrastor_host_reset, 1177 .bios_param = ultrastor_biosparam, 1178 .can_queue = ULTRASTOR_MAX_CMDS, 1179 .sg_tablesize = ULTRASTOR_14F_MAX_SG, 1180 .cmd_per_lun = ULTRASTOR_MAX_CMDS_PER_LUN, 1181 .unchecked_isa_dma = 1, 1182 .use_clustering = ENABLE_CLUSTERING, 1183}; 1184#include "scsi_module.c" 1185