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