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/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
169 typedef 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. */
177 struct 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
225 static 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. */
262 static int ultrastor_bus_reset;
263
264
265 /* Allowed BIOS base addresses (NULL indicates reserved) */
266 static 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 */
272 static const unsigned char interrupt_table_14f[4] = { 15, 14, 11, 10 };
273
274 /* Allowed DMA channels for 14f (0 indicates reserved) */
275 static const unsigned char dma_channel_table_14f[4] = { 5, 6, 7, 0 };
276
277 /* Head/sector mappings allowed by 14f */
278 static 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 */
285 static const unsigned short ultrastor_ports_14f[] = {
286 0x330, 0x340, /*0x310,*/ 0x230, 0x240, 0x210, 0x130, 0x140,
287 };
288 #endif
289
290 static void ultrastor_interrupt(void *);
291 static irqreturn_t do_ultrastor_interrupt(int, void *);
292 static inline void build_sg_list(struct mscp *, struct scsi_cmnd *SCpnt);
293
294
295 /* Always called with host lock held */
296
find_and_clear_bit_16(unsigned long * field)297 static 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 */
xchgb(unsigned char reg,volatile unsigned char * mem)322 static 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 */
log_ultrastor_abort(struct ultrastor_config * config,int command)332 static 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
ultrastor_14f_detect(struct scsi_host_template * tpnt)353 static 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 /*
511 * Brrr, &config.mscp[0].SCint->host) it is something magical....
512 * XXX and FIXME
513 */
514 if (request_irq(config.interrupt, do_ultrastor_interrupt, 0, "Ultrastor", &config.mscp[0].SCint->device->host)) {
515 printk("Unable to allocate IRQ%u for UltraStor controller.\n",
516 config.interrupt);
517 goto out_release_port;
518 }
519 if (config.dma_channel && request_dma(config.dma_channel,"Ultrastor")) {
520 printk("Unable to allocate DMA channel %u for UltraStor controller.\n",
521 config.dma_channel);
522 free_irq(config.interrupt, NULL);
523 goto out_release_port;
524 }
525 tpnt->sg_tablesize = ULTRASTOR_14F_MAX_SG;
526 printk("UltraStor driver version" VERSION ". Using %d SG lists.\n",
527 ULTRASTOR_14F_MAX_SG);
528
529 return TRUE;
530 out_release_port:
531 release_region(config.port_address, 0x0c);
532 return FALSE;
533 }
534
ultrastor_24f_detect(struct scsi_host_template * tpnt)535 static int ultrastor_24f_detect(struct scsi_host_template * tpnt)
536 {
537 int i;
538 struct Scsi_Host * shpnt = NULL;
539
540 #if (ULTRASTOR_DEBUG & UD_DETECT)
541 printk("US24F: detect");
542 #endif
543
544 /* probe each EISA slot at slot address C80 */
545 for (i = 1; i < 15; i++)
546 {
547 unsigned char config_1, config_2;
548 unsigned short addr = (i << 12) | ULTRASTOR_24F_PORT;
549
550 if (inb(addr) != US24F_PRODUCT_ID_0 &&
551 inb(addr+1) != US24F_PRODUCT_ID_1 &&
552 inb(addr+2) != US24F_PRODUCT_ID_2)
553 continue;
554
555 config.revision = inb(addr+3);
556 config.slot = i;
557 if (! (inb(addr+4) & 1))
558 {
559 #if (ULTRASTOR_DEBUG & UD_DETECT)
560 printk("U24F: found disabled card in slot %u\n", i);
561 #endif
562 continue;
563 }
564 #if (ULTRASTOR_DEBUG & UD_DETECT)
565 printk("U24F: found card in slot %u\n", i);
566 #endif
567 config_1 = inb(addr + 5);
568 config.bios_segment = bios_segment_table[config_1 & 7];
569 switch(config_1 >> 4)
570 {
571 case 1:
572 config.interrupt = 15;
573 break;
574 case 2:
575 config.interrupt = 14;
576 break;
577 case 4:
578 config.interrupt = 11;
579 break;
580 case 8:
581 config.interrupt = 10;
582 break;
583 default:
584 printk("U24F: invalid IRQ\n");
585 return FALSE;
586 }
587
588 /* BIOS addr set */
589 /* base port set */
590 config.port_address = addr;
591 config.doorbell_address = addr + 12;
592 config.ogm_address = addr + 0x17;
593 config.icm_address = addr + 0x1C;
594 config_2 = inb(addr + 7);
595 config.ha_scsi_id = config_2 & 7;
596 config.heads = mapping_table[(config_2 >> 3) & 3].heads;
597 config.sectors = mapping_table[(config_2 >> 3) & 3].sectors;
598 #if (ULTRASTOR_DEBUG & UD_DETECT)
599 printk("US24F: detect: detect succeeded\n"
600 " Port address: %03X\n"
601 " BIOS segment: %05X\n"
602 " Interrupt: %u\n"
603 " H/A SCSI ID: %u\n",
604 config.port_address, config.bios_segment,
605 config.interrupt, config.ha_scsi_id);
606 #endif
607 tpnt->this_id = config.ha_scsi_id;
608 tpnt->unchecked_isa_dma = 0;
609 tpnt->sg_tablesize = ULTRASTOR_24F_MAX_SG;
610
611 shpnt = scsi_register(tpnt, 0);
612 if (!shpnt) {
613 printk(KERN_WARNING "(ultrastor:) Could not register scsi device. Aborting registration.\n");
614 free_irq(config.interrupt, do_ultrastor_interrupt);
615 return FALSE;
616 }
617
618 if (request_irq(config.interrupt, do_ultrastor_interrupt, 0, "Ultrastor", shpnt))
619 {
620 printk("Unable to allocate IRQ%u for UltraStor controller.\n",
621 config.interrupt);
622 return FALSE;
623 }
624
625 shpnt->irq = config.interrupt;
626 shpnt->dma_channel = config.dma_channel;
627 shpnt->io_port = config.port_address;
628
629 #if ULTRASTOR_MAX_CMDS > 1
630 config.mscp_free = ~0;
631 #endif
632 /* Mark ICM and OGM free */
633 outb(0, addr + 0x16);
634 outb(0, addr + 0x1B);
635
636 /* Set local doorbell mask to disallow bus reset unless
637 ultrastor_bus_reset is true. */
638 outb(ultrastor_bus_reset ? 0xc2 : 0x82, LCL_DOORBELL_MASK(addr+12));
639 outb(0x02, SYS_DOORBELL_MASK(addr+12));
640 printk("UltraStor driver version " VERSION ". Using %d SG lists.\n",
641 tpnt->sg_tablesize);
642 return TRUE;
643 }
644 return FALSE;
645 }
646
ultrastor_detect(struct scsi_host_template * tpnt)647 static int ultrastor_detect(struct scsi_host_template * tpnt)
648 {
649 tpnt->proc_name = "ultrastor";
650 return ultrastor_14f_detect(tpnt) || ultrastor_24f_detect(tpnt);
651 }
652
ultrastor_release(struct Scsi_Host * shost)653 static int ultrastor_release(struct Scsi_Host *shost)
654 {
655 if (shost->irq)
656 free_irq(shost->irq, NULL);
657 if (shost->dma_channel != 0xff)
658 free_dma(shost->dma_channel);
659 if (shost->io_port && shost->n_io_port)
660 release_region(shost->io_port, shost->n_io_port);
661 scsi_unregister(shost);
662 return 0;
663 }
664
ultrastor_info(struct Scsi_Host * shpnt)665 static const char *ultrastor_info(struct Scsi_Host * shpnt)
666 {
667 static char buf[64];
668
669 if (config.slot)
670 sprintf(buf, "UltraStor 24F SCSI @ Slot %u IRQ%u",
671 config.slot, config.interrupt);
672 else if (config.subversion)
673 sprintf(buf, "UltraStor 34F SCSI @ Port %03X BIOS %05X IRQ%u",
674 config.port_address, (int)config.bios_segment,
675 config.interrupt);
676 else
677 sprintf(buf, "UltraStor 14F SCSI @ Port %03X BIOS %05X IRQ%u DMA%u",
678 config.port_address, (int)config.bios_segment,
679 config.interrupt, config.dma_channel);
680 return buf;
681 }
682
build_sg_list(struct mscp * mscp,struct scsi_cmnd * SCpnt)683 static inline void build_sg_list(struct mscp *mscp, struct scsi_cmnd *SCpnt)
684 {
685 struct scatterlist *sg;
686 long transfer_length = 0;
687 int i, max;
688
689 max = scsi_sg_count(SCpnt);
690 scsi_for_each_sg(SCpnt, sg, max, i) {
691 mscp->sglist[i].address = isa_page_to_bus(sg_page(sg)) + sg->offset;
692 mscp->sglist[i].num_bytes = sg->length;
693 transfer_length += sg->length;
694 }
695 mscp->number_of_sg_list = max;
696 mscp->transfer_data = isa_virt_to_bus(mscp->sglist);
697 /* ??? May not be necessary. Docs are unclear as to whether transfer
698 length field is ignored or whether it should be set to the total
699 number of bytes of the transfer. */
700 mscp->transfer_data_length = transfer_length;
701 }
702
ultrastor_queuecommand_lck(struct scsi_cmnd * SCpnt,void (* done)(struct scsi_cmnd *))703 static int ultrastor_queuecommand_lck(struct scsi_cmnd *SCpnt,
704 void (*done) (struct scsi_cmnd *))
705 {
706 struct mscp *my_mscp;
707 #if ULTRASTOR_MAX_CMDS > 1
708 int mscp_index;
709 #endif
710 unsigned int status;
711
712 /* Next test is for debugging; "can't happen" */
713 if ((config.mscp_free & ((1U << ULTRASTOR_MAX_CMDS) - 1)) == 0)
714 panic("ultrastor_queuecommand: no free MSCP\n");
715 mscp_index = find_and_clear_bit_16(&config.mscp_free);
716
717 /* Has the command been aborted? */
718 if (xchgb(0xff, &config.aborted[mscp_index]) != 0)
719 {
720 status = DID_ABORT << 16;
721 goto aborted;
722 }
723
724 my_mscp = &config.mscp[mscp_index];
725
726 *(unsigned char *)my_mscp = OP_SCSI | (DTD_SCSI << 3);
727
728 /* Tape drives don't work properly if the cache is used. The SCSI
729 READ command for a tape doesn't have a block offset, and the adapter
730 incorrectly assumes that all reads from the tape read the same
731 blocks. Results will depend on read buffer size and other disk
732 activity.
733
734 ??? Which other device types should never use the cache? */
735 my_mscp->ca = SCpnt->device->type != TYPE_TAPE;
736 my_mscp->target_id = SCpnt->device->id;
737 my_mscp->ch_no = 0;
738 my_mscp->lun = SCpnt->device->lun;
739 if (scsi_sg_count(SCpnt)) {
740 /* Set scatter/gather flag in SCSI command packet */
741 my_mscp->sg = TRUE;
742 build_sg_list(my_mscp, SCpnt);
743 } else {
744 /* Unset scatter/gather flag in SCSI command packet */
745 my_mscp->sg = FALSE;
746 my_mscp->transfer_data = isa_virt_to_bus(scsi_sglist(SCpnt));
747 my_mscp->transfer_data_length = scsi_bufflen(SCpnt);
748 }
749 my_mscp->command_link = 0; /*???*/
750 my_mscp->scsi_command_link_id = 0; /*???*/
751 my_mscp->length_of_sense_byte = SCSI_SENSE_BUFFERSIZE;
752 my_mscp->length_of_scsi_cdbs = SCpnt->cmd_len;
753 memcpy(my_mscp->scsi_cdbs, SCpnt->cmnd, my_mscp->length_of_scsi_cdbs);
754 my_mscp->adapter_status = 0;
755 my_mscp->target_status = 0;
756 my_mscp->sense_data = isa_virt_to_bus(&SCpnt->sense_buffer);
757 my_mscp->done = done;
758 my_mscp->SCint = SCpnt;
759 SCpnt->host_scribble = (unsigned char *)my_mscp;
760
761 /* Find free OGM slot. On 24F, look for OGM status byte == 0.
762 On 14F and 34F, wait for local interrupt pending flag to clear.
763
764 FIXME: now we are using new_eh we should punt here and let the
765 midlayer sort it out */
766
767 retry:
768 if (config.slot)
769 while (inb(config.ogm_address - 1) != 0 && config.aborted[mscp_index] == 0xff)
770 barrier();
771
772 /* else??? */
773
774 while ((inb(LCL_DOORBELL_INTR(config.doorbell_address)) & (config.slot ? 2 : 1)) && config.aborted[mscp_index] == 0xff)
775 barrier();
776
777 /* To avoid race conditions, keep the code to write to the adapter
778 atomic. This simplifies the abort code. Right now the
779 scsi mid layer has the host_lock already held
780 */
781
782 if (inb(LCL_DOORBELL_INTR(config.doorbell_address)) & (config.slot ? 2 : 1))
783 goto retry;
784
785 status = xchgb(0, &config.aborted[mscp_index]);
786 if (status != 0xff) {
787
788 #if ULTRASTOR_DEBUG & (UD_COMMAND | UD_ABORT)
789 printk("USx4F: queuecommand: aborted\n");
790 #if ULTRASTOR_MAX_CMDS > 1
791 log_ultrastor_abort(&config, mscp_index);
792 #endif
793 #endif
794 status <<= 16;
795
796 aborted:
797 set_bit(mscp_index, &config.mscp_free);
798 /* If the driver queues commands, call the done proc here. Otherwise
799 return an error. */
800 #if ULTRASTOR_MAX_CMDS > 1
801 SCpnt->result = status;
802 done(SCpnt);
803 return 0;
804 #else
805 return status;
806 #endif
807 }
808
809 /* Store pointer in OGM address bytes */
810 outl(isa_virt_to_bus(my_mscp), config.ogm_address);
811
812 /* Issue OGM interrupt */
813 if (config.slot) {
814 /* Write OGM command register on 24F */
815 outb(1, config.ogm_address - 1);
816 outb(0x2, LCL_DOORBELL_INTR(config.doorbell_address));
817 } else {
818 outb(0x1, LCL_DOORBELL_INTR(config.doorbell_address));
819 }
820
821 #if (ULTRASTOR_DEBUG & UD_COMMAND)
822 printk("USx4F: queuecommand: returning\n");
823 #endif
824
825 return 0;
826 }
827
DEF_SCSI_QCMD(ultrastor_queuecommand)828 static DEF_SCSI_QCMD(ultrastor_queuecommand)
829
830 /* This code must deal with 2 cases:
831
832 1. The command has not been written to the OGM. In this case, set
833 the abort flag and return.
834
835 2. The command has been written to the OGM and is stuck somewhere in
836 the adapter.
837
838 2a. On a 24F, ask the adapter to abort the command. It will interrupt
839 when it does.
840
841 2b. Call the command's done procedure.
842
843 */
844
845 static int ultrastor_abort(struct scsi_cmnd *SCpnt)
846 {
847 #if ULTRASTOR_DEBUG & UD_ABORT
848 char out[108];
849 unsigned char icm_status = 0, ogm_status = 0;
850 unsigned int icm_addr = 0, ogm_addr = 0;
851 #endif
852 unsigned int mscp_index;
853 unsigned char old_aborted;
854 unsigned long flags;
855 void (*done)(struct scsi_cmnd *);
856 struct Scsi_Host *host = SCpnt->device->host;
857
858 if(config.slot)
859 return FAILED; /* Do not attempt an abort for the 24f */
860
861 /* Simple consistency checking */
862 if(!SCpnt->host_scribble)
863 return FAILED;
864
865 mscp_index = ((struct mscp *)SCpnt->host_scribble) - config.mscp;
866 if (mscp_index >= ULTRASTOR_MAX_CMDS)
867 panic("Ux4F aborting invalid MSCP");
868
869 #if ULTRASTOR_DEBUG & UD_ABORT
870 if (config.slot)
871 {
872 int port0 = (config.slot << 12) | 0xc80;
873 int i;
874 unsigned long flags;
875
876 spin_lock_irqsave(host->host_lock, flags);
877 strcpy(out, "OGM %d:%x ICM %d:%x ports: ");
878 for (i = 0; i < 16; i++)
879 {
880 unsigned char p = inb(port0 + i);
881 out[28 + i * 3] = "0123456789abcdef"[p >> 4];
882 out[29 + i * 3] = "0123456789abcdef"[p & 15];
883 out[30 + i * 3] = ' ';
884 }
885 out[28 + i * 3] = '\n';
886 out[29 + i * 3] = 0;
887 ogm_status = inb(port0 + 22);
888 ogm_addr = (unsigned int)isa_bus_to_virt(inl(port0 + 23));
889 icm_status = inb(port0 + 27);
890 icm_addr = (unsigned int)isa_bus_to_virt(inl(port0 + 28));
891 spin_unlock_irqrestore(host->host_lock, flags);
892 }
893
894 /* First check to see if an interrupt is pending. I suspect the SiS
895 chipset loses interrupts. (I also suspect is mangles data, but
896 one bug at a time... */
897 if (config.slot ? inb(config.icm_address - 1) == 2 :
898 (inb(SYS_DOORBELL_INTR(config.doorbell_address)) & 1))
899 {
900 printk("Ux4F: abort while completed command pending\n");
901
902 spin_lock_irqsave(host->host_lock, flags);
903 /* FIXME: Ewww... need to think about passing host around properly */
904 ultrastor_interrupt(NULL);
905 spin_unlock_irqrestore(host->host_lock, flags);
906 return SUCCESS;
907 }
908 #endif
909
910 old_aborted = xchgb(DID_ABORT, &config.aborted[mscp_index]);
911
912 /* aborted == 0xff is the signal that queuecommand has not yet sent
913 the command. It will notice the new abort flag and fail. */
914 if (old_aborted == 0xff)
915 return SUCCESS;
916
917 /* On 24F, send an abort MSCP request. The adapter will interrupt
918 and the interrupt handler will call done. */
919 if (config.slot && inb(config.ogm_address - 1) == 0)
920 {
921 unsigned long flags;
922
923 spin_lock_irqsave(host->host_lock, flags);
924 outl(isa_virt_to_bus(&config.mscp[mscp_index]), config.ogm_address);
925 udelay(8);
926 outb(0x80, config.ogm_address - 1);
927 outb(0x2, LCL_DOORBELL_INTR(config.doorbell_address));
928 #if ULTRASTOR_DEBUG & UD_ABORT
929 log_ultrastor_abort(&config, mscp_index);
930 printk(out, ogm_status, ogm_addr, icm_status, icm_addr);
931 #endif
932 spin_unlock_irqrestore(host->host_lock, flags);
933 /* FIXME: add a wait for the abort to complete */
934 return SUCCESS;
935 }
936
937 #if ULTRASTOR_DEBUG & UD_ABORT
938 log_ultrastor_abort(&config, mscp_index);
939 #endif
940
941 /* Can't request a graceful abort. Either this is not a 24F or
942 the OGM is busy. Don't free the command -- the adapter might
943 still be using it. Setting SCint = 0 causes the interrupt
944 handler to ignore the command. */
945
946 /* FIXME - devices that implement soft resets will still be running
947 the command after a bus reset. We would probably rather leave
948 the command in the queue. The upper level code will automatically
949 leave the command in the active state instead of requeueing it. ERY */
950
951 #if ULTRASTOR_DEBUG & UD_ABORT
952 if (config.mscp[mscp_index].SCint != SCpnt)
953 printk("abort: command mismatch, %p != %p\n",
954 config.mscp[mscp_index].SCint, SCpnt);
955 #endif
956 if (config.mscp[mscp_index].SCint == NULL)
957 return FAILED;
958
959 if (config.mscp[mscp_index].SCint != SCpnt) panic("Bad abort");
960 config.mscp[mscp_index].SCint = NULL;
961 done = config.mscp[mscp_index].done;
962 config.mscp[mscp_index].done = NULL;
963 SCpnt->result = DID_ABORT << 16;
964
965 /* Take the host lock to guard against scsi layer re-entry */
966 done(SCpnt);
967
968 /* Need to set a timeout here in case command never completes. */
969 return SUCCESS;
970 }
971
ultrastor_host_reset(struct scsi_cmnd * SCpnt)972 static int ultrastor_host_reset(struct scsi_cmnd * SCpnt)
973 {
974 unsigned long flags;
975 int i;
976 struct Scsi_Host *host = SCpnt->device->host;
977
978 #if (ULTRASTOR_DEBUG & UD_RESET)
979 printk("US14F: reset: called\n");
980 #endif
981
982 if(config.slot)
983 return FAILED;
984
985 spin_lock_irqsave(host->host_lock, flags);
986 /* Reset the adapter and SCSI bus. The SCSI bus reset can be
987 inhibited by clearing ultrastor_bus_reset before probe. */
988 outb(0xc0, LCL_DOORBELL_INTR(config.doorbell_address));
989 if (config.slot)
990 {
991 outb(0, config.ogm_address - 1);
992 outb(0, config.icm_address - 1);
993 }
994
995 #if ULTRASTOR_MAX_CMDS == 1
996 if (config.mscp_busy && config.mscp->done && config.mscp->SCint)
997 {
998 config.mscp->SCint->result = DID_RESET << 16;
999 config.mscp->done(config.mscp->SCint);
1000 }
1001 config.mscp->SCint = 0;
1002 #else
1003 for (i = 0; i < ULTRASTOR_MAX_CMDS; i++)
1004 {
1005 if (! (config.mscp_free & (1 << i)) &&
1006 config.mscp[i].done && config.mscp[i].SCint)
1007 {
1008 config.mscp[i].SCint->result = DID_RESET << 16;
1009 config.mscp[i].done(config.mscp[i].SCint);
1010 config.mscp[i].done = NULL;
1011 }
1012 config.mscp[i].SCint = NULL;
1013 }
1014 #endif
1015
1016 /* FIXME - if the device implements soft resets, then the command
1017 will still be running. ERY
1018
1019 Even bigger deal with new_eh!
1020 */
1021
1022 memset((unsigned char *)config.aborted, 0, sizeof config.aborted);
1023 #if ULTRASTOR_MAX_CMDS == 1
1024 config.mscp_busy = 0;
1025 #else
1026 config.mscp_free = ~0;
1027 #endif
1028
1029 spin_unlock_irqrestore(host->host_lock, flags);
1030 return SUCCESS;
1031
1032 }
1033
ultrastor_biosparam(struct scsi_device * sdev,struct block_device * bdev,sector_t capacity,int * dkinfo)1034 int ultrastor_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1035 sector_t capacity, int * dkinfo)
1036 {
1037 int size = capacity;
1038 unsigned int s = config.heads * config.sectors;
1039
1040 dkinfo[0] = config.heads;
1041 dkinfo[1] = config.sectors;
1042 dkinfo[2] = size / s; /* Ignore partial cylinders */
1043 #if 0
1044 if (dkinfo[2] > 1024)
1045 dkinfo[2] = 1024;
1046 #endif
1047 return 0;
1048 }
1049
ultrastor_interrupt(void * dev_id)1050 static void ultrastor_interrupt(void *dev_id)
1051 {
1052 unsigned int status;
1053 #if ULTRASTOR_MAX_CMDS > 1
1054 unsigned int mscp_index;
1055 #endif
1056 struct mscp *mscp;
1057 void (*done) (struct scsi_cmnd *);
1058 struct scsi_cmnd *SCtmp;
1059
1060 #if ULTRASTOR_MAX_CMDS == 1
1061 mscp = &config.mscp[0];
1062 #else
1063 mscp = (struct mscp *)isa_bus_to_virt(inl(config.icm_address));
1064 mscp_index = mscp - config.mscp;
1065 if (mscp_index >= ULTRASTOR_MAX_CMDS) {
1066 printk("Ux4F interrupt: bad MSCP address %x\n", (unsigned int) mscp);
1067 /* A command has been lost. Reset and report an error
1068 for all commands. */
1069 ultrastor_host_reset(dev_id);
1070 return;
1071 }
1072 #endif
1073
1074 /* Clean ICM slot (set ICMINT bit to 0) */
1075 if (config.slot) {
1076 unsigned char icm_status = inb(config.icm_address - 1);
1077 #if ULTRASTOR_DEBUG & (UD_INTERRUPT|UD_ERROR|UD_ABORT)
1078 if (icm_status != 1 && icm_status != 2)
1079 printk("US24F: ICM status %x for MSCP %d (%x)\n", icm_status,
1080 mscp_index, (unsigned int) mscp);
1081 #endif
1082 /* The manual says clear interrupt then write 0 to ICM status.
1083 This seems backwards, but I'll do it anyway. --jfc */
1084 outb(2, SYS_DOORBELL_INTR(config.doorbell_address));
1085 outb(0, config.icm_address - 1);
1086 if (icm_status == 4) {
1087 printk("UltraStor abort command failed\n");
1088 return;
1089 }
1090 if (icm_status == 3) {
1091 void (*done)(struct scsi_cmnd *) = mscp->done;
1092 if (done) {
1093 mscp->done = NULL;
1094 mscp->SCint->result = DID_ABORT << 16;
1095 done(mscp->SCint);
1096 }
1097 return;
1098 }
1099 } else {
1100 outb(1, SYS_DOORBELL_INTR(config.doorbell_address));
1101 }
1102
1103 SCtmp = mscp->SCint;
1104 mscp->SCint = NULL;
1105
1106 if (!SCtmp)
1107 {
1108 #if ULTRASTOR_DEBUG & (UD_ABORT|UD_INTERRUPT)
1109 printk("MSCP %d (%x): no command\n", mscp_index, (unsigned int) mscp);
1110 #endif
1111 #if ULTRASTOR_MAX_CMDS == 1
1112 config.mscp_busy = FALSE;
1113 #else
1114 set_bit(mscp_index, &config.mscp_free);
1115 #endif
1116 config.aborted[mscp_index] = 0;
1117 return;
1118 }
1119
1120 /* Save done locally and zero before calling. This is needed as
1121 once we call done, we may get another command queued before this
1122 interrupt service routine can return. */
1123 done = mscp->done;
1124 mscp->done = NULL;
1125
1126 /* Let the higher levels know that we're done */
1127 switch (mscp->adapter_status)
1128 {
1129 case 0:
1130 status = DID_OK << 16;
1131 break;
1132 case 0x01: /* invalid command */
1133 case 0x02: /* invalid parameters */
1134 case 0x03: /* invalid data list */
1135 default:
1136 status = DID_ERROR << 16;
1137 break;
1138 case 0x84: /* SCSI bus abort */
1139 status = DID_ABORT << 16;
1140 break;
1141 case 0x91:
1142 status = DID_TIME_OUT << 16;
1143 break;
1144 }
1145
1146 SCtmp->result = status | mscp->target_status;
1147
1148 SCtmp->host_scribble = NULL;
1149
1150 /* Free up mscp block for next command */
1151 #if ULTRASTOR_MAX_CMDS == 1
1152 config.mscp_busy = FALSE;
1153 #else
1154 set_bit(mscp_index, &config.mscp_free);
1155 #endif
1156
1157 #if ULTRASTOR_DEBUG & (UD_ABORT|UD_INTERRUPT)
1158 if (config.aborted[mscp_index])
1159 printk("Ux4 interrupt: MSCP %d (%x) aborted = %d\n",
1160 mscp_index, (unsigned int) mscp, config.aborted[mscp_index]);
1161 #endif
1162 config.aborted[mscp_index] = 0;
1163
1164 if (done)
1165 done(SCtmp);
1166 else
1167 printk("US14F: interrupt: unexpected interrupt\n");
1168
1169 if (config.slot ? inb(config.icm_address - 1) :
1170 (inb(SYS_DOORBELL_INTR(config.doorbell_address)) & 1))
1171 #if (ULTRASTOR_DEBUG & UD_MULTI_CMD)
1172 printk("Ux4F: multiple commands completed\n");
1173 #else
1174 ;
1175 #endif
1176
1177 #if (ULTRASTOR_DEBUG & UD_INTERRUPT)
1178 printk("USx4F: interrupt: returning\n");
1179 #endif
1180 }
1181
do_ultrastor_interrupt(int irq,void * dev_id)1182 static irqreturn_t do_ultrastor_interrupt(int irq, void *dev_id)
1183 {
1184 unsigned long flags;
1185 struct Scsi_Host *dev = dev_id;
1186
1187 spin_lock_irqsave(dev->host_lock, flags);
1188 ultrastor_interrupt(dev_id);
1189 spin_unlock_irqrestore(dev->host_lock, flags);
1190 return IRQ_HANDLED;
1191 }
1192
1193 MODULE_LICENSE("GPL");
1194
1195 static struct scsi_host_template driver_template = {
1196 .name = "UltraStor 14F/24F/34F",
1197 .detect = ultrastor_detect,
1198 .release = ultrastor_release,
1199 .info = ultrastor_info,
1200 .queuecommand = ultrastor_queuecommand,
1201 .eh_abort_handler = ultrastor_abort,
1202 .eh_host_reset_handler = ultrastor_host_reset,
1203 .bios_param = ultrastor_biosparam,
1204 .can_queue = ULTRASTOR_MAX_CMDS,
1205 .sg_tablesize = ULTRASTOR_14F_MAX_SG,
1206 .cmd_per_lun = ULTRASTOR_MAX_CMDS_PER_LUN,
1207 .unchecked_isa_dma = 1,
1208 .use_clustering = ENABLE_CLUSTERING,
1209 };
1210 #include "scsi_module.c"
1211