]> git.ipfire.org Git - people/ms/linux.git/blob - drivers/scsi/aha1542.c
projects / people / ms / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Linux-2.6.12-rc2
[people/ms/linux.git] / drivers / scsi / aha1542.c
1 /* $Id: aha1542.c,v 1.1 1992/07/24 06:27:38 root Exp root $
2 * linux/kernel/aha1542.c
3 *
4 * Copyright (C) 1992 Tommy Thorn
5 * Copyright (C) 1993, 1994, 1995 Eric Youngdale
6 *
7 * Modified by Eric Youngdale
8 * Use request_irq and request_dma to help prevent unexpected conflicts
9 * Set up on-board DMA controller, such that we do not have to
10 * have the bios enabled to use the aha1542.
11 * Modified by David Gentzel
12 * Don't call request_dma if dma mask is 0 (for BusLogic BT-445S VL-Bus
13 * controller).
14 * Modified by Matti Aarnio
15 * Accept parameters from LILO cmd-line. -- 1-Oct-94
16 * Modified by Mike McLagan <mike.mclagan@linux.org>
17 * Recognise extended mode on AHA1542CP, different bit than 1542CF
18 * 1-Jan-97
19 * Modified by Bjorn L. Thordarson and Einar Thor Einarsson
20 * Recognize that DMA0 is valid DMA channel -- 13-Jul-98
21 * Modified by Chris Faulhaber <jedgar@fxp.org>
22 * Added module command-line options
23 * 19-Jul-99
24 * Modified by Adam Fritzler <mid@auk.cx>
25 * Added proper detection of the AHA-1640 (MCA version of AHA-1540)
26 */
27
28 #include <linux/config.h>
29 #include <linux/module.h>
30 #include <linux/interrupt.h>
31 #include <linux/kernel.h>
32 #include <linux/types.h>
33 #include <linux/string.h>
34 #include <linux/ioport.h>
35 #include <linux/delay.h>
36 #include <linux/proc_fs.h>
37 #include <linux/init.h>
38 #include <linux/spinlock.h>
39 #include <linux/pci.h>
40 #include <linux/isapnp.h>
41 #include <linux/blkdev.h>
42 #include <linux/mca.h>
43 #include <linux/mca-legacy.h>
44
45 #include <asm/dma.h>
46 #include <asm/system.h>
47 #include <asm/io.h>
48
49 #include "scsi.h"
50 #include <scsi/scsi_host.h>
51 #include "aha1542.h"
52
53 #define SCSI_BUF_PA(address) isa_virt_to_bus(address)
54 #define SCSI_SG_PA(sgent) (isa_page_to_bus((sgent)->page) + (sgent)->offset)
55
56 static void BAD_DMA(void *address, unsigned int length)
57 {
58 printk(KERN_CRIT "buf vaddress %p paddress 0x%lx length %d\n",
59 address,
60 SCSI_BUF_PA(address),
61 length);
62 panic("Buffer at physical address > 16Mb used for aha1542");
63 }
64
65 static void BAD_SG_DMA(Scsi_Cmnd * SCpnt,
66 struct scatterlist *sgpnt,
67 int nseg,
68 int badseg)
69 {
70 printk(KERN_CRIT "sgpnt[%d:%d] page %p/0x%llx length %u\n",
71 badseg, nseg,
72 page_address(sgpnt[badseg].page) + sgpnt[badseg].offset,
73 (unsigned long long)SCSI_SG_PA(&sgpnt[badseg]),
74 sgpnt[badseg].length);
75
76 /*
77 * Not safe to continue.
78 */
79 panic("Buffer at physical address > 16Mb used for aha1542");
80 }
81
82 #include<linux/stat.h>
83
84 #ifdef DEBUG
85 #define DEB(x) x
86 #else
87 #define DEB(x)
88 #endif
89
90 /*
91 static const char RCSid[] = "$Header: /usr/src/linux/kernel/blk_drv/scsi/RCS/aha1542.c,v 1.1 1992/07/24 06:27:38 root Exp root $";
92 */
93
94 /* The adaptec can be configured for quite a number of addresses, but
95 I generally do not want the card poking around at random. We allow
96 two addresses - this allows people to use the Adaptec with a Midi
97 card, which also used 0x330 -- can be overridden with LILO! */
98
99 #define MAXBOARDS 4 /* Increase this and the sizes of the
100 arrays below, if you need more.. */
101
102 /* Boards 3,4 slots are reserved for ISAPnP/MCA scans */
103
104 static unsigned int bases[MAXBOARDS] __initdata = {0x330, 0x334, 0, 0};
105
106 /* set by aha1542_setup according to the command line; they also may
107 be marked __initdata, but require zero initializers then */
108
109 static int setup_called[MAXBOARDS];
110 static int setup_buson[MAXBOARDS];
111 static int setup_busoff[MAXBOARDS];
112 static int setup_dmaspeed[MAXBOARDS] __initdata = { -1, -1, -1, -1 };
113
114 /*
115 * LILO/Module params: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]
116 *
117 * Where: <PORTBASE> is any of the valid AHA addresses:
118 * 0x130, 0x134, 0x230, 0x234, 0x330, 0x334
119 * <BUSON> is the time (in microsecs) that AHA spends on the AT-bus
120 * when transferring data. 1542A power-on default is 11us,
121 * valid values are in range: 2..15 (decimal)
122 * <BUSOFF> is the time that AHA spends OFF THE BUS after while
123 * it is transferring data (not to monopolize the bus).
124 * Power-on default is 4us, valid range: 1..64 microseconds.
125 * <DMASPEED> Default is jumper selected (1542A: on the J1),
126 * but experimenter can alter it with this.
127 * Valid values: 5, 6, 7, 8, 10 (MB/s)
128 * Factory default is 5 MB/s.
129 */
130
131 #if defined(MODULE)
132 static int isapnp = 0;
133 static int aha1542[] = {0x330, 11, 4, -1};
134 module_param_array(aha1542, int, NULL, 0);
135 module_param(isapnp, bool, 0);
136
137 static struct isapnp_device_id id_table[] __initdata = {
138 {
139 ISAPNP_ANY_ID, ISAPNP_ANY_ID,
140 ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1542),
141 0
142 },
143 {0}
144 };
145
146 MODULE_DEVICE_TABLE(isapnp, id_table);
147
148 #else
149 static int isapnp = 1;
150 #endif
151
152 #define BIOS_TRANSLATION_1632 0 /* Used by some old 1542A boards */
153 #define BIOS_TRANSLATION_6432 1 /* Default case these days */
154 #define BIOS_TRANSLATION_25563 2 /* Big disk case */
155
156 struct aha1542_hostdata {
157 /* This will effectively start both of them at the first mailbox */
158 int bios_translation; /* Mapping bios uses - for compatibility */
159 int aha1542_last_mbi_used;
160 int aha1542_last_mbo_used;
161 Scsi_Cmnd *SCint[AHA1542_MAILBOXES];
162 struct mailbox mb[2 * AHA1542_MAILBOXES];
163 struct ccb ccb[AHA1542_MAILBOXES];
164 };
165
166 #define HOSTDATA(host) ((struct aha1542_hostdata *) &host->hostdata)
167
168 static struct Scsi_Host *aha_host[7]; /* One for each IRQ level (9-15) */
169
170 static DEFINE_SPINLOCK(aha1542_lock);
171
172
173
174 #define WAITnexttimeout 3000000
175
176 static void setup_mailboxes(int base_io, struct Scsi_Host *shpnt);
177 static int aha1542_restart(struct Scsi_Host *shost);
178 static void aha1542_intr_handle(struct Scsi_Host *shost, void *dev_id, struct pt_regs *regs);
179 static irqreturn_t do_aha1542_intr_handle(int irq, void *dev_id,
180 struct pt_regs *regs);
181
182 #define aha1542_intr_reset(base) outb(IRST, CONTROL(base))
183
184 #define WAIT(port, mask, allof, noneof) \
185 { register int WAITbits; \
186 register int WAITtimeout = WAITnexttimeout; \
187 while (1) { \
188 WAITbits = inb(port) & (mask); \
189 if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
190 break; \
191 if (--WAITtimeout == 0) goto fail; \
192 } \
193 }
194
195 /* Similar to WAIT, except we use the udelay call to regulate the
196 amount of time we wait. */
197 #define WAITd(port, mask, allof, noneof, timeout) \
198 { register int WAITbits; \
199 register int WAITtimeout = timeout; \
200 while (1) { \
201 WAITbits = inb(port) & (mask); \
202 if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
203 break; \
204 mdelay(1); \
205 if (--WAITtimeout == 0) goto fail; \
206 } \
207 }
208
209 static void aha1542_stat(void)
210 {
211 /* int s = inb(STATUS), i = inb(INTRFLAGS);
212 printk("status=%x intrflags=%x\n", s, i, WAITnexttimeout-WAITtimeout); */
213 }
214
215 /* This is a bit complicated, but we need to make sure that an interrupt
216 routine does not send something out while we are in the middle of this.
217 Fortunately, it is only at boot time that multi-byte messages
218 are ever sent. */
219 static int aha1542_out(unsigned int base, unchar * cmdp, int len)
220 {
221 unsigned long flags = 0;
222 int got_lock;
223
224 if (len == 1) {
225 got_lock = 0;
226 while (1 == 1) {
227 WAIT(STATUS(base), CDF, 0, CDF);
228 spin_lock_irqsave(&aha1542_lock, flags);
229 if (inb(STATUS(base)) & CDF) {
230 spin_unlock_irqrestore(&aha1542_lock, flags);
231 continue;
232 }
233 outb(*cmdp, DATA(base));
234 spin_unlock_irqrestore(&aha1542_lock, flags);
235 return 0;
236 }
237 } else {
238 spin_lock_irqsave(&aha1542_lock, flags);
239 got_lock = 1;
240 while (len--) {
241 WAIT(STATUS(base), CDF, 0, CDF);
242 outb(*cmdp++, DATA(base));
243 }
244 spin_unlock_irqrestore(&aha1542_lock, flags);
245 }
246 return 0;
247 fail:
248 if (got_lock)
249 spin_unlock_irqrestore(&aha1542_lock, flags);
250 printk(KERN_ERR "aha1542_out failed(%d): ", len + 1);
251 aha1542_stat();
252 return 1;
253 }
254
255 /* Only used at boot time, so we do not need to worry about latency as much
256 here */
257
258 static int __init aha1542_in(unsigned int base, unchar * cmdp, int len)
259 {
260 unsigned long flags;
261
262 spin_lock_irqsave(&aha1542_lock, flags);
263 while (len--) {
264 WAIT(STATUS(base), DF, DF, 0);
265 *cmdp++ = inb(DATA(base));
266 }
267 spin_unlock_irqrestore(&aha1542_lock, flags);
268 return 0;
269 fail:
270 spin_unlock_irqrestore(&aha1542_lock, flags);
271 printk(KERN_ERR "aha1542_in failed(%d): ", len + 1);
272 aha1542_stat();
273 return 1;
274 }
275
276 /* Similar to aha1542_in, except that we wait a very short period of time.
277 We use this if we know the board is alive and awake, but we are not sure
278 if the board will respond to the command we are about to send or not */
279 static int __init aha1542_in1(unsigned int base, unchar * cmdp, int len)
280 {
281 unsigned long flags;
282
283 spin_lock_irqsave(&aha1542_lock, flags);
284 while (len--) {
285 WAITd(STATUS(base), DF, DF, 0, 100);
286 *cmdp++ = inb(DATA(base));
287 }
288 spin_unlock_irqrestore(&aha1542_lock, flags);
289 return 0;
290 fail:
291 spin_unlock_irqrestore(&aha1542_lock, flags);
292 return 1;
293 }
294
295 static int makecode(unsigned hosterr, unsigned scsierr)
296 {
297 switch (hosterr) {
298 case 0x0:
299 case 0xa: /* Linked command complete without error and linked normally */
300 case 0xb: /* Linked command complete without error, interrupt generated */
301 hosterr = 0;
302 break;
303
304 case 0x11: /* Selection time out-The initiator selection or target
305 reselection was not complete within the SCSI Time out period */
306 hosterr = DID_TIME_OUT;
307 break;
308
309 case 0x12: /* Data overrun/underrun-The target attempted to transfer more data
310 than was allocated by the Data Length field or the sum of the
311 Scatter / Gather Data Length fields. */
312
313 case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
314
315 case 0x15: /* MBO command was not 00, 01 or 02-The first byte of the CB was
316 invalid. This usually indicates a software failure. */
317
318 case 0x16: /* Invalid CCB Operation Code-The first byte of the CCB was invalid.
319 This usually indicates a software failure. */
320
321 case 0x17: /* Linked CCB does not have the same LUN-A subsequent CCB of a set
322 of linked CCB's does not specify the same logical unit number as
323 the first. */
324 case 0x18: /* Invalid Target Direction received from Host-The direction of a
325 Target Mode CCB was invalid. */
326
327 case 0x19: /* Duplicate CCB Received in Target Mode-More than once CCB was
328 received to service data transfer between the same target LUN
329 and initiator SCSI ID in the same direction. */
330
331 case 0x1a: /* Invalid CCB or Segment List Parameter-A segment list with a zero
332 length segment or invalid segment list boundaries was received.
333 A CCB parameter was invalid. */
334 DEB(printk("Aha1542: %x %x\n", hosterr, scsierr));
335 hosterr = DID_ERROR; /* Couldn't find any better */
336 break;
337
338 case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus
339 phase sequence was requested by the target. The host adapter
340 will generate a SCSI Reset Condition, notifying the host with
341 a SCRD interrupt */
342 hosterr = DID_RESET;
343 break;
344 default:
345 printk(KERN_ERR "aha1542: makecode: unknown hoststatus %x\n", hosterr);
346 break;
347 }
348 return scsierr | (hosterr << 16);
349 }
350
351 static int __init aha1542_test_port(int bse, struct Scsi_Host *shpnt)
352 {
353 unchar inquiry_cmd[] = {CMD_INQUIRY};
354 unchar inquiry_result[4];
355 unchar *cmdp;
356 int len;
357 volatile int debug = 0;
358
359 /* Quick and dirty test for presence of the card. */
360 if (inb(STATUS(bse)) == 0xff)
361 return 0;
362
363 /* Reset the adapter. I ought to make a hard reset, but it's not really necessary */
364
365 /* DEB(printk("aha1542_test_port called \n")); */
366
367 /* In case some other card was probing here, reset interrupts */
368 aha1542_intr_reset(bse); /* reset interrupts, so they don't block */
369
370 outb(SRST | IRST /*|SCRST */ , CONTROL(bse));
371
372 mdelay(20); /* Wait a little bit for things to settle down. */
373
374 debug = 1;
375 /* Expect INIT and IDLE, any of the others are bad */
376 WAIT(STATUS(bse), STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
377
378 debug = 2;
379 /* Shouldn't have generated any interrupts during reset */
380 if (inb(INTRFLAGS(bse)) & INTRMASK)
381 goto fail;
382
383
384 /* Perform a host adapter inquiry instead so we do not need to set
385 up the mailboxes ahead of time */
386
387 aha1542_out(bse, inquiry_cmd, 1);
388
389 debug = 3;
390 len = 4;
391 cmdp = &inquiry_result[0];
392
393 while (len--) {
394 WAIT(STATUS(bse), DF, DF, 0);
395 *cmdp++ = inb(DATA(bse));
396 }
397
398 debug = 8;
399 /* Reading port should reset DF */
400 if (inb(STATUS(bse)) & DF)
401 goto fail;
402
403 debug = 9;
404 /* When HACC, command is completed, and we're though testing */
405 WAIT(INTRFLAGS(bse), HACC, HACC, 0);
406 /* now initialize adapter */
407
408 debug = 10;
409 /* Clear interrupts */
410 outb(IRST, CONTROL(bse));
411
412 debug = 11;
413
414 return debug; /* 1 = ok */
415 fail:
416 return 0; /* 0 = not ok */
417 }
418
419 /* A quick wrapper for do_aha1542_intr_handle to grab the spin lock */
420 static irqreturn_t do_aha1542_intr_handle(int irq, void *dev_id,
421 struct pt_regs *regs)
422 {
423 unsigned long flags;
424 struct Scsi_Host *shost;
425
426 shost = aha_host[irq - 9];
427 if (!shost)
428 panic("Splunge!");
429
430 spin_lock_irqsave(shost->host_lock, flags);
431 aha1542_intr_handle(shost, dev_id, regs);
432 spin_unlock_irqrestore(shost->host_lock, flags);
433 return IRQ_HANDLED;
434 }
435
436 /* A "high" level interrupt handler */
437 static void aha1542_intr_handle(struct Scsi_Host *shost, void *dev_id, struct pt_regs *regs)
438 {
439 void (*my_done) (Scsi_Cmnd *) = NULL;
440 int errstatus, mbi, mbo, mbistatus;
441 int number_serviced;
442 unsigned long flags;
443 Scsi_Cmnd *SCtmp;
444 int flag;
445 int needs_restart;
446 struct mailbox *mb;
447 struct ccb *ccb;
448
449 mb = HOSTDATA(shost)->mb;
450 ccb = HOSTDATA(shost)->ccb;
451
452 #ifdef DEBUG
453 {
454 flag = inb(INTRFLAGS(shost->io_port));
455 printk(KERN_DEBUG "aha1542_intr_handle: ");
456 if (!(flag & ANYINTR))
457 printk("no interrupt?");
458 if (flag & MBIF)
459 printk("MBIF ");
460 if (flag & MBOA)
461 printk("MBOF ");
462 if (flag & HACC)
463 printk("HACC ");
464 if (flag & SCRD)
465 printk("SCRD ");
466 printk("status %02x\n", inb(STATUS(shost->io_port)));
467 };
468 #endif
469 number_serviced = 0;
470 needs_restart = 0;
471
472 while (1 == 1) {
473 flag = inb(INTRFLAGS(shost->io_port));
474
475 /* Check for unusual interrupts. If any of these happen, we should
476 probably do something special, but for now just printing a message
477 is sufficient. A SCSI reset detected is something that we really
478 need to deal with in some way. */
479 if (flag & ~MBIF) {
480 if (flag & MBOA)
481 printk("MBOF ");
482 if (flag & HACC)
483 printk("HACC ");
484 if (flag & SCRD) {
485 needs_restart = 1;
486 printk("SCRD ");
487 }
488 }
489 aha1542_intr_reset(shost->io_port);
490
491 spin_lock_irqsave(&aha1542_lock, flags);
492 mbi = HOSTDATA(shost)->aha1542_last_mbi_used + 1;
493 if (mbi >= 2 * AHA1542_MAILBOXES)
494 mbi = AHA1542_MAILBOXES;
495
496 do {
497 if (mb[mbi].status != 0)
498 break;
499 mbi++;
500 if (mbi >= 2 * AHA1542_MAILBOXES)
501 mbi = AHA1542_MAILBOXES;
502 } while (mbi != HOSTDATA(shost)->aha1542_last_mbi_used);
503
504 if (mb[mbi].status == 0) {
505 spin_unlock_irqrestore(&aha1542_lock, flags);
506 /* Hmm, no mail. Must have read it the last time around */
507 if (!number_serviced && !needs_restart)
508 printk(KERN_WARNING "aha1542.c: interrupt received, but no mail.\n");
509 /* We detected a reset. Restart all pending commands for
510 devices that use the hard reset option */
511 if (needs_restart)
512 aha1542_restart(shost);
513 return;
514 };
515
516 mbo = (scsi2int(mb[mbi].ccbptr) - (SCSI_BUF_PA(&ccb[0]))) / sizeof(struct ccb);
517 mbistatus = mb[mbi].status;
518 mb[mbi].status = 0;
519 HOSTDATA(shost)->aha1542_last_mbi_used = mbi;
520 spin_unlock_irqrestore(&aha1542_lock, flags);
521
522 #ifdef DEBUG
523 {
524 if (ccb[mbo].tarstat | ccb[mbo].hastat)
525 printk(KERN_DEBUG "aha1542_command: returning %x (status %d)\n",
526 ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status);
527 };
528 #endif
529
530 if (mbistatus == 3)
531 continue; /* Aborted command not found */
532
533 #ifdef DEBUG
534 printk(KERN_DEBUG "...done %d %d\n", mbo, mbi);
535 #endif
536
537 SCtmp = HOSTDATA(shost)->SCint[mbo];
538
539 if (!SCtmp || !SCtmp->scsi_done) {
540 printk(KERN_WARNING "aha1542_intr_handle: Unexpected interrupt\n");
541 printk(KERN_WARNING "tarstat=%x, hastat=%x idlun=%x ccb#=%d \n", ccb[mbo].tarstat,
542 ccb[mbo].hastat, ccb[mbo].idlun, mbo);
543 return;
544 }
545 my_done = SCtmp->scsi_done;
546 if (SCtmp->host_scribble) {
547 kfree(SCtmp->host_scribble);
548 SCtmp->host_scribble = NULL;
549 }
550 /* Fetch the sense data, and tuck it away, in the required slot. The
551 Adaptec automatically fetches it, and there is no guarantee that
552 we will still have it in the cdb when we come back */
553 if (ccb[mbo].tarstat == 2)
554 memcpy(SCtmp->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen],
555 sizeof(SCtmp->sense_buffer));
556
557
558 /* is there mail :-) */
559
560 /* more error checking left out here */
561 if (mbistatus != 1)
562 /* This is surely wrong, but I don't know what's right */
563 errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat);
564 else
565 errstatus = 0;
566
567 #ifdef DEBUG
568 if (errstatus)
569 printk(KERN_DEBUG "(aha1542 error:%x %x %x) ", errstatus,
570 ccb[mbo].hastat, ccb[mbo].tarstat);
571 #endif
572
573 if (ccb[mbo].tarstat == 2) {
574 #ifdef DEBUG
575 int i;
576 #endif
577 DEB(printk("aha1542_intr_handle: sense:"));
578 #ifdef DEBUG
579 for (i = 0; i < 12; i++)
580 printk("%02x ", ccb[mbo].cdb[ccb[mbo].cdblen + i]);
581 printk("\n");
582 #endif
583 /*
584 DEB(printk("aha1542_intr_handle: buf:"));
585 for (i = 0; i < bufflen; i++)
586 printk("%02x ", ((unchar *)buff)[i]);
587 printk("\n");
588 */
589 }
590 DEB(if (errstatus) printk("aha1542_intr_handle: returning %6x\n", errstatus));
591 SCtmp->result = errstatus;
592 HOSTDATA(shost)->SCint[mbo] = NULL; /* This effectively frees up the mailbox slot, as
593 far as queuecommand is concerned */
594 my_done(SCtmp);
595 number_serviced++;
596 };
597 }
598
599 static int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
600 {
601 unchar ahacmd = CMD_START_SCSI;
602 unchar direction;
603 unchar *cmd = (unchar *) SCpnt->cmnd;
604 unchar target = SCpnt->device->id;
605 unchar lun = SCpnt->device->lun;
606 unsigned long flags;
607 void *buff = SCpnt->request_buffer;
608 int bufflen = SCpnt->request_bufflen;
609 int mbo;
610 struct mailbox *mb;
611 struct ccb *ccb;
612
613 DEB(int i);
614
615 mb = HOSTDATA(SCpnt->device->host)->mb;
616 ccb = HOSTDATA(SCpnt->device->host)->ccb;
617
618 DEB(if (target > 1) {
619 SCpnt->result = DID_TIME_OUT << 16;
620 done(SCpnt); return 0;
621 }
622 );
623
624 if (*cmd == REQUEST_SENSE) {
625 /* Don't do the command - we have the sense data already */
626 #if 0
627 /* scsi_request_sense() provides a buffer of size 256,
628 so there is no reason to expect equality */
629 if (bufflen != sizeof(SCpnt->sense_buffer))
630 printk(KERN_CRIT "aha1542: Wrong buffer length supplied "
631 "for request sense (%d)\n", bufflen);
632 #endif
633 SCpnt->result = 0;
634 done(SCpnt);
635 return 0;
636 }
637 #ifdef DEBUG
638 if (*cmd == READ_10 || *cmd == WRITE_10)
639 i = xscsi2int(cmd + 2);
640 else if (*cmd == READ_6 || *cmd == WRITE_6)
641 i = scsi2int(cmd + 2);
642 else
643 i = -1;
644 if (done)
645 printk(KERN_DEBUG "aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
646 else
647 printk(KERN_DEBUG "aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
648 aha1542_stat();
649 printk(KERN_DEBUG "aha1542_queuecommand: dumping scsi cmd:");
650 for (i = 0; i < SCpnt->cmd_len; i++)
651 printk("%02x ", cmd[i]);
652 printk("\n");
653 if (*cmd == WRITE_10 || *cmd == WRITE_6)
654 return 0; /* we are still testing, so *don't* write */
655 #endif
656 /* Use the outgoing mailboxes in a round-robin fashion, because this
657 is how the host adapter will scan for them */
658
659 spin_lock_irqsave(&aha1542_lock, flags);
660 mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1;
661 if (mbo >= AHA1542_MAILBOXES)
662 mbo = 0;
663
664 do {
665 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL)
666 break;
667 mbo++;
668 if (mbo >= AHA1542_MAILBOXES)
669 mbo = 0;
670 } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used);
671
672 if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo])
673 panic("Unable to find empty mailbox for aha1542.\n");
674
675 HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt; /* This will effectively prevent someone else from
676 screwing with this cdb. */
677
678 HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo;
679 spin_unlock_irqrestore(&aha1542_lock, flags);
680
681 #ifdef DEBUG
682 printk(KERN_DEBUG "Sending command (%d %x)...", mbo, done);
683 #endif
684
685 any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo])); /* This gets trashed for some reason */
686
687 memset(&ccb[mbo], 0, sizeof(struct ccb));
688
689 ccb[mbo].cdblen = SCpnt->cmd_len;
690
691 direction = 0;
692 if (*cmd == READ_10 || *cmd == READ_6)
693 direction = 8;
694 else if (*cmd == WRITE_10 || *cmd == WRITE_6)
695 direction = 16;
696
697 memcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
698
699 if (SCpnt->use_sg) {
700 struct scatterlist *sgpnt;
701 struct chain *cptr;
702 #ifdef DEBUG
703 unsigned char *ptr;
704 #endif
705 int i;
706 ccb[mbo].op = 2; /* SCSI Initiator Command w/scatter-gather */
707 SCpnt->host_scribble = (unsigned char *) kmalloc(512, GFP_KERNEL | GFP_DMA);
708 sgpnt = (struct scatterlist *) SCpnt->request_buffer;
709 cptr = (struct chain *) SCpnt->host_scribble;
710 if (cptr == NULL) {
711 /* free the claimed mailbox slot */
712 HOSTDATA(SCpnt->device->host)->SCint[mbo] = NULL;
713 return SCSI_MLQUEUE_HOST_BUSY;
714 }
715 for (i = 0; i < SCpnt->use_sg; i++) {
716 if (sgpnt[i].length == 0 || SCpnt->use_sg > 16 ||
717 (((int) sgpnt[i].offset) & 1) || (sgpnt[i].length & 1)) {
718 unsigned char *ptr;
719 printk(KERN_CRIT "Bad segment list supplied to aha1542.c (%d, %d)\n", SCpnt->use_sg, i);
720 for (i = 0; i < SCpnt->use_sg; i++) {
721 printk(KERN_CRIT "%d: %p %d\n", i,
722 (page_address(sgpnt[i].page) +
723 sgpnt[i].offset),
724 sgpnt[i].length);
725 };
726 printk(KERN_CRIT "cptr %x: ", (unsigned int) cptr);
727 ptr = (unsigned char *) &cptr[i];
728 for (i = 0; i < 18; i++)
729 printk("%02x ", ptr[i]);
730 panic("Foooooooood fight!");
731 };
732 any2scsi(cptr[i].dataptr, SCSI_SG_PA(&sgpnt[i]));
733 if (SCSI_SG_PA(&sgpnt[i]) + sgpnt[i].length - 1 > ISA_DMA_THRESHOLD)
734 BAD_SG_DMA(SCpnt, sgpnt, SCpnt->use_sg, i);
735 any2scsi(cptr[i].datalen, sgpnt[i].length);
736 };
737 any2scsi(ccb[mbo].datalen, SCpnt->use_sg * sizeof(struct chain));
738 any2scsi(ccb[mbo].dataptr, SCSI_BUF_PA(cptr));
739 #ifdef DEBUG
740 printk("cptr %x: ", cptr);
741 ptr = (unsigned char *) cptr;
742 for (i = 0; i < 18; i++)
743 printk("%02x ", ptr[i]);
744 #endif
745 } else {
746 ccb[mbo].op = 0; /* SCSI Initiator Command */
747 SCpnt->host_scribble = NULL;
748 any2scsi(ccb[mbo].datalen, bufflen);
749 if (buff && SCSI_BUF_PA(buff + bufflen - 1) > ISA_DMA_THRESHOLD)
750 BAD_DMA(buff, bufflen);
751 any2scsi(ccb[mbo].dataptr, SCSI_BUF_PA(buff));
752 };
753 ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7); /*SCSI Target Id */
754 ccb[mbo].rsalen = 16;
755 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
756 ccb[mbo].commlinkid = 0;
757
758 #ifdef DEBUG
759 {
760 int i;
761 printk(KERN_DEBUG "aha1542_command: sending.. ");
762 for (i = 0; i < sizeof(ccb[mbo]) - 10; i++)
763 printk("%02x ", ((unchar *) & ccb[mbo])[i]);
764 };
765 #endif
766
767 if (done) {
768 DEB(printk("aha1542_queuecommand: now waiting for interrupt ");
769 aha1542_stat());
770 SCpnt->scsi_done = done;
771 mb[mbo].status = 1;
772 aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1); /* start scsi command */
773 DEB(aha1542_stat());
774 } else
775 printk("aha1542_queuecommand: done can't be NULL\n");
776
777 return 0;
778 }
779
780 /* Initialize mailboxes */
781 static void setup_mailboxes(int bse, struct Scsi_Host *shpnt)
782 {
783 int i;
784 struct mailbox *mb;
785 struct ccb *ccb;
786
787 unchar cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
788
789 mb = HOSTDATA(shpnt)->mb;
790 ccb = HOSTDATA(shpnt)->ccb;
791
792 for (i = 0; i < AHA1542_MAILBOXES; i++) {
793 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0;
794 any2scsi(mb[i].ccbptr, SCSI_BUF_PA(&ccb[i]));
795 };
796 aha1542_intr_reset(bse); /* reset interrupts, so they don't block */
797 any2scsi((cmd + 2), SCSI_BUF_PA(mb));
798 aha1542_out(bse, cmd, 5);
799 WAIT(INTRFLAGS(bse), INTRMASK, HACC, 0);
800 while (0) {
801 fail:
802 printk(KERN_ERR "aha1542_detect: failed setting up mailboxes\n");
803 }
804 aha1542_intr_reset(bse);
805 }
806
807 static int __init aha1542_getconfig(int base_io, unsigned char *irq_level, unsigned char *dma_chan, unsigned char *scsi_id)
808 {
809 unchar inquiry_cmd[] = {CMD_RETCONF};
810 unchar inquiry_result[3];
811 int i;
812 i = inb(STATUS(base_io));
813 if (i & DF) {
814 i = inb(DATA(base_io));
815 };
816 aha1542_out(base_io, inquiry_cmd, 1);
817 aha1542_in(base_io, inquiry_result, 3);
818 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
819 while (0) {
820 fail:
821 printk(KERN_ERR "aha1542_detect: query board settings\n");
822 }
823 aha1542_intr_reset(base_io);
824 switch (inquiry_result[0]) {
825 case 0x80:
826 *dma_chan = 7;
827 break;
828 case 0x40:
829 *dma_chan = 6;
830 break;
831 case 0x20:
832 *dma_chan = 5;
833 break;
834 case 0x01:
835 *dma_chan = 0;
836 break;
837 case 0:
838 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel.
839 Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */
840 *dma_chan = 0xFF;
841 break;
842 default:
843 printk(KERN_ERR "Unable to determine Adaptec DMA priority. Disabling board\n");
844 return -1;
845 };
846 switch (inquiry_result[1]) {
847 case 0x40:
848 *irq_level = 15;
849 break;
850 case 0x20:
851 *irq_level = 14;
852 break;
853 case 0x8:
854 *irq_level = 12;
855 break;
856 case 0x4:
857 *irq_level = 11;
858 break;
859 case 0x2:
860 *irq_level = 10;
861 break;
862 case 0x1:
863 *irq_level = 9;
864 break;
865 default:
866 printk(KERN_ERR "Unable to determine Adaptec IRQ level. Disabling board\n");
867 return -1;
868 };
869 *scsi_id = inquiry_result[2] & 7;
870 return 0;
871 }
872
873 /* This function should only be called for 1542C boards - we can detect
874 the special firmware settings and unlock the board */
875
876 static int __init aha1542_mbenable(int base)
877 {
878 static unchar mbenable_cmd[3];
879 static unchar mbenable_result[2];
880 int retval;
881
882 retval = BIOS_TRANSLATION_6432;
883
884 mbenable_cmd[0] = CMD_EXTBIOS;
885 aha1542_out(base, mbenable_cmd, 1);
886 if (aha1542_in1(base, mbenable_result, 2))
887 return retval;
888 WAITd(INTRFLAGS(base), INTRMASK, HACC, 0, 100);
889 aha1542_intr_reset(base);
890
891 if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
892 mbenable_cmd[0] = CMD_MBENABLE;
893 mbenable_cmd[1] = 0;
894 mbenable_cmd[2] = mbenable_result[1];
895
896 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03))
897 retval = BIOS_TRANSLATION_25563;
898
899 aha1542_out(base, mbenable_cmd, 3);
900 WAIT(INTRFLAGS(base), INTRMASK, HACC, 0);
901 };
902 while (0) {
903 fail:
904 printk(KERN_ERR "aha1542_mbenable: Mailbox init failed\n");
905 }
906 aha1542_intr_reset(base);
907 return retval;
908 }
909
910 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */
911 static int __init aha1542_query(int base_io, int *transl)
912 {
913 unchar inquiry_cmd[] = {CMD_INQUIRY};
914 unchar inquiry_result[4];
915 int i;
916 i = inb(STATUS(base_io));
917 if (i & DF) {
918 i = inb(DATA(base_io));
919 };
920 aha1542_out(base_io, inquiry_cmd, 1);
921 aha1542_in(base_io, inquiry_result, 4);
922 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
923 while (0) {
924 fail:
925 printk(KERN_ERR "aha1542_detect: query card type\n");
926 }
927 aha1542_intr_reset(base_io);
928
929 *transl = BIOS_TRANSLATION_6432; /* Default case */
930
931 /* For an AHA1740 series board, we ignore the board since there is a
932 hardware bug which can lead to wrong blocks being returned if the board
933 is operating in the 1542 emulation mode. Since there is an extended mode
934 driver, we simply ignore the board and let the 1740 driver pick it up.
935 */
936
937 if (inquiry_result[0] == 0x43) {
938 printk(KERN_INFO "aha1542.c: Emulation mode not supported for AHA 174N hardware.\n");
939 return 1;
940 };
941
942 /* Always call this - boards that do not support extended bios translation
943 will ignore the command, and we will set the proper default */
944
945 *transl = aha1542_mbenable(base_io);
946
947 return 0;
948 }
949
950 #ifndef MODULE
951 static char *setup_str[MAXBOARDS] __initdata;
952 static int setup_idx = 0;
953
954 static void __init aha1542_setup(char *str, int *ints)
955 {
956 const char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n";
957 int setup_portbase;
958
959 if (setup_idx >= MAXBOARDS) {
960 printk(KERN_ERR "aha1542: aha1542_setup called too many times! Bad LILO params ?\n");
961 printk(KERN_ERR " Entryline 1: %s\n", setup_str[0]);
962 printk(KERN_ERR " Entryline 2: %s\n", setup_str[1]);
963 printk(KERN_ERR " This line: %s\n", str);
964 return;
965 }
966 if (ints[0] < 1 || ints[0] > 4) {
967 printk(KERN_ERR "aha1542: %s\n", str);
968 printk(ahausage);
969 printk(KERN_ERR "aha1542: Wrong parameters may cause system malfunction.. We try anyway..\n");
970 }
971 setup_called[setup_idx] = ints[0];
972 setup_str[setup_idx] = str;
973
974 setup_portbase = ints[0] >= 1 ? ints[1] : 0; /* Preserve the default value.. */
975 setup_buson[setup_idx] = ints[0] >= 2 ? ints[2] : 7;
976 setup_busoff[setup_idx] = ints[0] >= 3 ? ints[3] : 5;
977 if (ints[0] >= 4)
978 {
979 int atbt = -1;
980 switch (ints[4]) {
981 case 5:
982 atbt = 0x00;
983 break;
984 case 6:
985 atbt = 0x04;
986 break;
987 case 7:
988 atbt = 0x01;
989 break;
990 case 8:
991 atbt = 0x02;
992 break;
993 case 10:
994 atbt = 0x03;
995 break;
996 default:
997 printk(KERN_ERR "aha1542: %s\n", str);
998 printk(ahausage);
999 printk(KERN_ERR "aha1542: Valid values for DMASPEED are 5-8, 10 MB/s. Using jumper defaults.\n");
1000 break;
1001 }
1002 setup_dmaspeed[setup_idx] = atbt;
1003 }
1004 if (setup_portbase != 0)
1005 bases[setup_idx] = setup_portbase;
1006
1007 ++setup_idx;
1008 }
1009
1010 static int __init do_setup(char *str)
1011 {
1012 int ints[5];
1013
1014 int count=setup_idx;
1015
1016 get_options(str, sizeof(ints)/sizeof(int), ints);
1017 aha1542_setup(str,ints);
1018
1019 return count<setup_idx;
1020 }
1021
1022 __setup("aha1542=",do_setup);
1023 #endif
1024
1025 /* return non-zero on detection */
1026 static int __init aha1542_detect(Scsi_Host_Template * tpnt)
1027 {
1028 unsigned char dma_chan;
1029 unsigned char irq_level;
1030 unsigned char scsi_id;
1031 unsigned long flags;
1032 unsigned int base_io;
1033 int trans;
1034 struct Scsi_Host *shpnt = NULL;
1035 int count = 0;
1036 int indx;
1037
1038 DEB(printk("aha1542_detect: \n"));
1039
1040 tpnt->proc_name = "aha1542";
1041
1042 #ifdef MODULE
1043 bases[0] = aha1542[0];
1044 setup_buson[0] = aha1542[1];
1045 setup_busoff[0] = aha1542[2];
1046 {
1047 int atbt = -1;
1048 switch (aha1542[3]) {
1049 case 5:
1050 atbt = 0x00;
1051 break;
1052 case 6:
1053 atbt = 0x04;
1054 break;
1055 case 7:
1056 atbt = 0x01;
1057 break;
1058 case 8:
1059 atbt = 0x02;
1060 break;
1061 case 10:
1062 atbt = 0x03;
1063 break;
1064 };
1065 setup_dmaspeed[0] = atbt;
1066 }
1067 #endif
1068
1069 /*
1070 * Find MicroChannel cards (AHA1640)
1071 */
1072 #ifdef CONFIG_MCA_LEGACY
1073 if(MCA_bus) {
1074 int slot = 0;
1075 int pos = 0;
1076
1077 for (indx = 0; (slot != MCA_NOTFOUND) &&
1078 (indx < sizeof(bases)/sizeof(bases[0])); indx++) {
1079
1080 if (bases[indx])
1081 continue;
1082
1083 /* Detect only AHA-1640 cards -- MCA ID 0F1F */
1084 slot = mca_find_unused_adapter(0x0f1f, slot);
1085 if (slot == MCA_NOTFOUND)
1086 break;
1087
1088
1089 /* Found one */
1090 pos = mca_read_stored_pos(slot, 3);
1091
1092 /* Decode address */
1093 if (pos & 0x80) {
1094 if (pos & 0x02) {
1095 if (pos & 0x01)
1096 bases[indx] = 0x334;
1097 else
1098 bases[indx] = 0x234;
1099 } else {
1100 if (pos & 0x01)
1101 bases[indx] = 0x134;
1102 }
1103 } else {
1104 if (pos & 0x02) {
1105 if (pos & 0x01)
1106 bases[indx] = 0x330;
1107 else
1108 bases[indx] = 0x230;
1109 } else {
1110 if (pos & 0x01)
1111 bases[indx] = 0x130;
1112 }
1113 }
1114
1115 /* No need to decode IRQ and Arb level -- those are
1116 * read off the card later.
1117 */
1118 printk(KERN_INFO "Found an AHA-1640 in MCA slot %d, I/O 0x%04x\n", slot, bases[indx]);
1119
1120 mca_set_adapter_name(slot, "Adapter AHA-1640");
1121 mca_set_adapter_procfn(slot, NULL, NULL);
1122 mca_mark_as_used(slot);
1123
1124 /* Go on */
1125 slot++;
1126 }
1127
1128 }
1129 #endif
1130
1131 /*
1132 * Hunt for ISA Plug'n'Pray Adaptecs (AHA1535)
1133 */
1134
1135 if(isapnp)
1136 {
1137 struct pnp_dev *pdev = NULL;
1138 for(indx = 0; indx <sizeof(bases)/sizeof(bases[0]);indx++)
1139 {
1140 if(bases[indx])
1141 continue;
1142 pdev = pnp_find_dev(NULL, ISAPNP_VENDOR('A', 'D', 'P'),
1143 ISAPNP_FUNCTION(0x1542), pdev);
1144 if(pdev==NULL)
1145 break;
1146 /*
1147 * Activate the PnP card
1148 */
1149
1150 if(pnp_device_attach(pdev)<0)
1151 continue;
1152
1153 if(pnp_activate_dev(pdev)<0) {
1154 pnp_device_detach(pdev);
1155 continue;
1156 }
1157
1158 if(!pnp_port_valid(pdev, 0)) {
1159 pnp_device_detach(pdev);
1160 continue;
1161 }
1162
1163 bases[indx] = pnp_port_start(pdev, 0);
1164
1165 /* The card can be queried for its DMA, we have
1166 the DMA set up that is enough */
1167
1168 printk(KERN_INFO "ISAPnP found an AHA1535 at I/O 0x%03X\n", bases[indx]);
1169 }
1170 }
1171 for (indx = 0; indx < sizeof(bases) / sizeof(bases[0]); indx++)
1172 if (bases[indx] != 0 && request_region(bases[indx], 4, "aha1542")) {
1173 shpnt = scsi_register(tpnt,
1174 sizeof(struct aha1542_hostdata));
1175
1176 if(shpnt==NULL) {
1177 release_region(bases[indx], 4);
1178 continue;
1179 }
1180 /* For now we do this - until kmalloc is more intelligent
1181 we are resigned to stupid hacks like this */
1182 if (SCSI_BUF_PA(shpnt) >= ISA_DMA_THRESHOLD) {
1183 printk(KERN_ERR "Invalid address for shpnt with 1542.\n");
1184 goto unregister;
1185 }
1186 if (!aha1542_test_port(bases[indx], shpnt))
1187 goto unregister;
1188
1189
1190 base_io = bases[indx];
1191
1192 /* Set the Bus on/off-times as not to ruin floppy performance */
1193 {
1194 unchar oncmd[] = {CMD_BUSON_TIME, 7};
1195 unchar offcmd[] = {CMD_BUSOFF_TIME, 5};
1196
1197 if (setup_called[indx]) {
1198 oncmd[1] = setup_buson[indx];
1199 offcmd[1] = setup_busoff[indx];
1200 }
1201 aha1542_intr_reset(base_io);
1202 aha1542_out(base_io, oncmd, 2);
1203 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1204 aha1542_intr_reset(base_io);
1205 aha1542_out(base_io, offcmd, 2);
1206 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1207 if (setup_dmaspeed[indx] >= 0) {
1208 unchar dmacmd[] = {CMD_DMASPEED, 0};
1209 dmacmd[1] = setup_dmaspeed[indx];
1210 aha1542_intr_reset(base_io);
1211 aha1542_out(base_io, dmacmd, 2);
1212 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1213 }
1214 while (0) {
1215 fail:
1216 printk(KERN_ERR "aha1542_detect: setting bus on/off-time failed\n");
1217 }
1218 aha1542_intr_reset(base_io);
1219 }
1220 if (aha1542_query(base_io, &trans))
1221 goto unregister;
1222
1223 if (aha1542_getconfig(base_io, &irq_level, &dma_chan, &scsi_id) == -1)
1224 goto unregister;
1225
1226 printk(KERN_INFO "Configuring Adaptec (SCSI-ID %d) at IO:%x, IRQ %d", scsi_id, base_io, irq_level);
1227 if (dma_chan != 0xFF)
1228 printk(", DMA priority %d", dma_chan);
1229 printk("\n");
1230
1231 DEB(aha1542_stat());
1232 setup_mailboxes(base_io, shpnt);
1233
1234 DEB(aha1542_stat());
1235
1236 DEB(printk("aha1542_detect: enable interrupt channel %d\n", irq_level));
1237 spin_lock_irqsave(&aha1542_lock, flags);
1238 if (request_irq(irq_level, do_aha1542_intr_handle, 0, "aha1542", NULL)) {
1239 printk(KERN_ERR "Unable to allocate IRQ for adaptec controller.\n");
1240 spin_unlock_irqrestore(&aha1542_lock, flags);
1241 goto unregister;
1242 }
1243 if (dma_chan != 0xFF) {
1244 if (request_dma(dma_chan, "aha1542")) {
1245 printk(KERN_ERR "Unable to allocate DMA channel for Adaptec.\n");
1246 free_irq(irq_level, NULL);
1247 spin_unlock_irqrestore(&aha1542_lock, flags);
1248 goto unregister;
1249 }
1250 if (dma_chan == 0 || dma_chan >= 5) {
1251 set_dma_mode(dma_chan, DMA_MODE_CASCADE);
1252 enable_dma(dma_chan);
1253 }
1254 }
1255 aha_host[irq_level - 9] = shpnt;
1256 shpnt->this_id = scsi_id;
1257 shpnt->unique_id = base_io;
1258 shpnt->io_port = base_io;
1259 shpnt->n_io_port = 4; /* Number of bytes of I/O space used */
1260 shpnt->dma_channel = dma_chan;
1261 shpnt->irq = irq_level;
1262 HOSTDATA(shpnt)->bios_translation = trans;
1263 if (trans == BIOS_TRANSLATION_25563)
1264 printk(KERN_INFO "aha1542.c: Using extended bios translation\n");
1265 HOSTDATA(shpnt)->aha1542_last_mbi_used = (2 * AHA1542_MAILBOXES - 1);
1266 HOSTDATA(shpnt)->aha1542_last_mbo_used = (AHA1542_MAILBOXES - 1);
1267 memset(HOSTDATA(shpnt)->SCint, 0, sizeof(HOSTDATA(shpnt)->SCint));
1268 spin_unlock_irqrestore(&aha1542_lock, flags);
1269 #if 0
1270 DEB(printk(" *** READ CAPACITY ***\n"));
1271
1272 {
1273 unchar buf[8];
1274 static unchar cmd[] = { READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1275 int i;
1276
1277 for (i = 0; i < sizeof(buf); ++i)
1278 buf[i] = 0x87;
1279 for (i = 0; i < 2; ++i)
1280 if (!aha1542_command(i, cmd, buf, sizeof(buf))) {
1281 printk(KERN_DEBUG "aha_detect: LU %d sector_size %d device_size %d\n",
1282 i, xscsi2int(buf + 4), xscsi2int(buf));
1283 }
1284 }
1285
1286 DEB(printk(" *** NOW RUNNING MY OWN TEST *** \n"));
1287
1288 for (i = 0; i < 4; ++i) {
1289 unsigned char cmd[10];
1290 static buffer[512];
1291
1292 cmd[0] = READ_10;
1293 cmd[1] = 0;
1294 xany2scsi(cmd + 2, i);
1295 cmd[6] = 0;
1296 cmd[7] = 0;
1297 cmd[8] = 1;
1298 cmd[9] = 0;
1299 aha1542_command(0, cmd, buffer, 512);
1300 }
1301 #endif
1302 count++;
1303 continue;
1304 unregister:
1305 release_region(bases[indx], 4);
1306 scsi_unregister(shpnt);
1307 continue;
1308
1309 };
1310
1311 return count;
1312 }
1313
1314 static int aha1542_release(struct Scsi_Host *shost)
1315 {
1316 if (shost->irq)
1317 free_irq(shost->irq, NULL);
1318 if (shost->dma_channel != 0xff)
1319 free_dma(shost->dma_channel);
1320 if (shost->io_port && shost->n_io_port)
1321 release_region(shost->io_port, shost->n_io_port);
1322 scsi_unregister(shost);
1323 return 0;
1324 }
1325
1326 static int aha1542_restart(struct Scsi_Host *shost)
1327 {
1328 int i;
1329 int count = 0;
1330 #if 0
1331 unchar ahacmd = CMD_START_SCSI;
1332 #endif
1333
1334 for (i = 0; i < AHA1542_MAILBOXES; i++)
1335 if (HOSTDATA(shost)->SCint[i] &&
1336 !(HOSTDATA(shost)->SCint[i]->device->soft_reset)) {
1337 #if 0
1338 HOSTDATA(shost)->mb[i].status = 1; /* Indicate ready to restart... */
1339 #endif
1340 count++;
1341 }
1342 printk(KERN_DEBUG "Potential to restart %d stalled commands...\n", count);
1343 #if 0
1344 /* start scsi command */
1345 if (count)
1346 aha1542_out(shost->io_port, &ahacmd, 1);
1347 #endif
1348 return 0;
1349 }
1350
1351 static int aha1542_abort(Scsi_Cmnd * SCpnt)
1352 {
1353
1354 /*
1355 * The abort command does not leave the device in a clean state where
1356 * it is available to be used again. Until this gets worked out, we
1357 * will leave it commented out.
1358 */
1359
1360 printk(KERN_ERR "aha1542.c: Unable to abort command for target %d\n",
1361 SCpnt->device->id);
1362 return FAILED;
1363 }
1364
1365 /*
1366 * This is a device reset. This is handled by sending a special command
1367 * to the device.
1368 */
1369 static int aha1542_dev_reset(Scsi_Cmnd * SCpnt)
1370 {
1371 unsigned long flags;
1372 struct mailbox *mb;
1373 unchar target = SCpnt->device->id;
1374 unchar lun = SCpnt->device->lun;
1375 int mbo;
1376 struct ccb *ccb;
1377 unchar ahacmd = CMD_START_SCSI;
1378
1379 ccb = HOSTDATA(SCpnt->device->host)->ccb;
1380 mb = HOSTDATA(SCpnt->device->host)->mb;
1381
1382 spin_lock_irqsave(&aha1542_lock, flags);
1383 mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1;
1384 if (mbo >= AHA1542_MAILBOXES)
1385 mbo = 0;
1386
1387 do {
1388 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL)
1389 break;
1390 mbo++;
1391 if (mbo >= AHA1542_MAILBOXES)
1392 mbo = 0;
1393 } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used);
1394
1395 if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo])
1396 panic("Unable to find empty mailbox for aha1542.\n");
1397
1398 HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt; /* This will effectively
1399 prevent someone else from
1400 screwing with this cdb. */
1401
1402 HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo;
1403 spin_unlock_irqrestore(&aha1542_lock, flags);
1404
1405 any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo])); /* This gets trashed for some reason */
1406
1407 memset(&ccb[mbo], 0, sizeof(struct ccb));
1408
1409 ccb[mbo].op = 0x81; /* BUS DEVICE RESET */
1410
1411 ccb[mbo].idlun = (target & 7) << 5 | (lun & 7); /*SCSI Target Id */
1412
1413 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
1414 ccb[mbo].commlinkid = 0;
1415
1416 /*
1417 * Now tell the 1542 to flush all pending commands for this
1418 * target
1419 */
1420 aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1);
1421
1422 printk(KERN_WARNING "aha1542.c: Trying device reset for target %d\n", SCpnt->device->id);
1423
1424 return SUCCESS;
1425
1426
1427 #ifdef ERIC_neverdef
1428 /*
1429 * With the 1542 we apparently never get an interrupt to
1430 * acknowledge a device reset being sent. Then again, Leonard
1431 * says we are doing this wrong in the first place...
1432 *
1433 * Take a wait and see attitude. If we get spurious interrupts,
1434 * then the device reset is doing something sane and useful, and
1435 * we will wait for the interrupt to post completion.
1436 */
1437 printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1438
1439 /*
1440 * Free the command block for all commands running on this
1441 * target...
1442 */
1443 for (i = 0; i < AHA1542_MAILBOXES; i++) {
1444 if (HOSTDATA(SCpnt->host)->SCint[i] &&
1445 HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) {
1446 Scsi_Cmnd *SCtmp;
1447 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1448 if (SCtmp->host_scribble) {
1449 kfree(SCtmp->host_scribble);
1450 SCtmp->host_scribble = NULL;
1451 }
1452 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1453 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1454 }
1455 }
1456 return SUCCESS;
1457
1458 return FAILED;
1459 #endif /* ERIC_neverdef */
1460 }
1461
1462 static int aha1542_bus_reset(Scsi_Cmnd * SCpnt)
1463 {
1464 int i;
1465
1466 /*
1467 * This does a scsi reset for all devices on the bus.
1468 * In principle, we could also reset the 1542 - should
1469 * we do this? Try this first, and we can add that later
1470 * if it turns out to be useful.
1471 */
1472 outb(SCRST, CONTROL(SCpnt->device->host->io_port));
1473
1474 /*
1475 * Wait for the thing to settle down a bit. Unfortunately
1476 * this is going to basically lock up the machine while we
1477 * wait for this to complete. To be 100% correct, we need to
1478 * check for timeout, and if we are doing something like this
1479 * we are pretty desperate anyways.
1480 */
1481 spin_unlock_irq(SCpnt->device->host->host_lock);
1482 ssleep(4);
1483 spin_lock_irq(SCpnt->device->host->host_lock);
1484
1485 WAIT(STATUS(SCpnt->device->host->io_port),
1486 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1487
1488 /*
1489 * Now try to pick up the pieces. For all pending commands,
1490 * free any internal data structures, and basically clear things
1491 * out. We do not try and restart any commands or anything -
1492 * the strategy handler takes care of that crap.
1493 */
1494 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1495
1496 for (i = 0; i < AHA1542_MAILBOXES; i++) {
1497 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1498 Scsi_Cmnd *SCtmp;
1499 SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1500
1501
1502 if (SCtmp->device->soft_reset) {
1503 /*
1504 * If this device implements the soft reset option,
1505 * then it is still holding onto the command, and
1506 * may yet complete it. In this case, we don't
1507 * flush the data.
1508 */
1509 continue;
1510 }
1511 if (SCtmp->host_scribble) {
1512 kfree(SCtmp->host_scribble);
1513 SCtmp->host_scribble = NULL;
1514 }
1515 HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1516 HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1517 }
1518 }
1519
1520 return SUCCESS;
1521
1522 fail:
1523 return FAILED;
1524 }
1525
1526 static int aha1542_host_reset(Scsi_Cmnd * SCpnt)
1527 {
1528 int i;
1529
1530 /*
1531 * This does a scsi reset for all devices on the bus.
1532 * In principle, we could also reset the 1542 - should
1533 * we do this? Try this first, and we can add that later
1534 * if it turns out to be useful.
1535 */
1536 outb(HRST | SCRST, CONTROL(SCpnt->device->host->io_port));
1537
1538 /*
1539 * Wait for the thing to settle down a bit. Unfortunately
1540 * this is going to basically lock up the machine while we
1541 * wait for this to complete. To be 100% correct, we need to
1542 * check for timeout, and if we are doing something like this
1543 * we are pretty desperate anyways.
1544 */
1545 spin_unlock_irq(SCpnt->device->host->host_lock);
1546 ssleep(4);
1547 spin_lock_irq(SCpnt->device->host->host_lock);
1548
1549 WAIT(STATUS(SCpnt->device->host->io_port),
1550 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1551
1552 /*
1553 * We need to do this too before the 1542 can interact with
1554 * us again.
1555 */
1556 setup_mailboxes(SCpnt->device->host->io_port, SCpnt->device->host);
1557
1558 /*
1559 * Now try to pick up the pieces. For all pending commands,
1560 * free any internal data structures, and basically clear things
1561 * out. We do not try and restart any commands or anything -
1562 * the strategy handler takes care of that crap.
1563 */
1564 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1565
1566 for (i = 0; i < AHA1542_MAILBOXES; i++) {
1567 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1568 Scsi_Cmnd *SCtmp;
1569 SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1570
1571 if (SCtmp->device->soft_reset) {
1572 /*
1573 * If this device implements the soft reset option,
1574 * then it is still holding onto the command, and
1575 * may yet complete it. In this case, we don't
1576 * flush the data.
1577 */
1578 continue;
1579 }
1580 if (SCtmp->host_scribble) {
1581 kfree(SCtmp->host_scribble);
1582 SCtmp->host_scribble = NULL;
1583 }
1584 HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1585 HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1586 }
1587 }
1588
1589 return SUCCESS;
1590
1591 fail:
1592 return FAILED;
1593 }
1594
1595 #if 0
1596 /*
1597 * These are the old error handling routines. They are only temporarily
1598 * here while we play with the new error handling code.
1599 */
1600 static int aha1542_old_abort(Scsi_Cmnd * SCpnt)
1601 {
1602 #if 0
1603 unchar ahacmd = CMD_START_SCSI;
1604 unsigned long flags;
1605 struct mailbox *mb;
1606 int mbi, mbo, i;
1607
1608 printk(KERN_DEBUG "In aha1542_abort: %x %x\n",
1609 inb(STATUS(SCpnt->host->io_port)),
1610 inb(INTRFLAGS(SCpnt->host->io_port)));
1611
1612 spin_lock_irqsave(&aha1542_lock, flags);
1613 mb = HOSTDATA(SCpnt->host)->mb;
1614 mbi = HOSTDATA(SCpnt->host)->aha1542_last_mbi_used + 1;
1615 if (mbi >= 2 * AHA1542_MAILBOXES)
1616 mbi = AHA1542_MAILBOXES;
1617
1618 do {
1619 if (mb[mbi].status != 0)
1620 break;
1621 mbi++;
1622 if (mbi >= 2 * AHA1542_MAILBOXES)
1623 mbi = AHA1542_MAILBOXES;
1624 } while (mbi != HOSTDATA(SCpnt->host)->aha1542_last_mbi_used);
1625 spin_unlock_irqrestore(&aha1542_lock, flags);
1626
1627 if (mb[mbi].status) {
1628 printk(KERN_ERR "Lost interrupt discovered on irq %d - attempting to recover\n",
1629 SCpnt->host->irq);
1630 aha1542_intr_handle(SCpnt->host, NULL);
1631 return 0;
1632 }
1633 /* OK, no lost interrupt. Try looking to see how many pending commands
1634 we think we have. */
1635
1636 for (i = 0; i < AHA1542_MAILBOXES; i++)
1637 if (HOSTDATA(SCpnt->host)->SCint[i]) {
1638 if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1639 printk(KERN_ERR "Timed out command pending for %s\n",
1640 SCpnt->request->rq_disk ?
1641 SCpnt->request->rq_disk->disk_name : "?"
1642 );
1643 if (HOSTDATA(SCpnt->host)->mb[i].status) {
1644 printk(KERN_ERR "OGMB still full - restarting\n");
1645 aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1646 };
1647 } else
1648 printk(KERN_ERR "Other pending command %s\n",
1649 SCpnt->request->rq_disk ?
1650 SCpnt->request->rq_disk->disk_name : "?"
1651 );
1652 }
1653 #endif
1654
1655 DEB(printk("aha1542_abort\n"));
1656 #if 0
1657 spin_lock_irqsave(&aha1542_lock, flags);
1658 for (mbo = 0; mbo < AHA1542_MAILBOXES; mbo++) {
1659 if (SCpnt == HOSTDATA(SCpnt->host)->SCint[mbo]) {
1660 mb[mbo].status = 2; /* Abort command */
1661 aha1542_out(SCpnt->host->io_port, &ahacmd, 1); /* start scsi command */
1662 spin_unlock_irqrestore(&aha1542_lock, flags);
1663 break;
1664 }
1665 }
1666 if (AHA1542_MAILBOXES == mbo)
1667 spin_unlock_irqrestore(&aha1542_lock, flags);
1668 #endif
1669 return SCSI_ABORT_SNOOZE;
1670 }
1671
1672 /* We do not implement a reset function here, but the upper level code
1673 assumes that it will get some kind of response for the command in
1674 SCpnt. We must oblige, or the command will hang the scsi system.
1675 For a first go, we assume that the 1542 notifies us with all of the
1676 pending commands (it does implement soft reset, after all). */
1677
1678 static int aha1542_old_reset(Scsi_Cmnd * SCpnt, unsigned int reset_flags)
1679 {
1680 unchar ahacmd = CMD_START_SCSI;
1681 int i;
1682
1683 /*
1684 * See if a bus reset was suggested.
1685 */
1686 if (reset_flags & SCSI_RESET_SUGGEST_BUS_RESET) {
1687 /*
1688 * This does a scsi reset for all devices on the bus.
1689 * In principle, we could also reset the 1542 - should
1690 * we do this? Try this first, and we can add that later
1691 * if it turns out to be useful.
1692 */
1693 outb(HRST | SCRST, CONTROL(SCpnt->host->io_port));
1694
1695 /*
1696 * Wait for the thing to settle down a bit. Unfortunately
1697 * this is going to basically lock up the machine while we
1698 * wait for this to complete. To be 100% correct, we need to
1699 * check for timeout, and if we are doing something like this
1700 * we are pretty desperate anyways.
1701 */
1702 WAIT(STATUS(SCpnt->host->io_port),
1703 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1704
1705 /*
1706 * We need to do this too before the 1542 can interact with
1707 * us again.
1708 */
1709 setup_mailboxes(SCpnt->host->io_port, SCpnt->host);
1710
1711 /*
1712 * Now try to pick up the pieces. Restart all commands
1713 * that are currently active on the bus, and reset all of
1714 * the datastructures. We have some time to kill while
1715 * things settle down, so print a nice message.
1716 */
1717 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->host->host_no);
1718
1719 for (i = 0; i < AHA1542_MAILBOXES; i++)
1720 if (HOSTDATA(SCpnt->host)->SCint[i] != NULL) {
1721 Scsi_Cmnd *SCtmp;
1722 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1723 SCtmp->result = DID_RESET << 16;
1724 if (SCtmp->host_scribble) {
1725 kfree(SCtmp->host_scribble);
1726 SCtmp->host_scribble = NULL;
1727 }
1728 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target);
1729 SCtmp->scsi_done(SCpnt);
1730
1731 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1732 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1733 }
1734 /*
1735 * Now tell the mid-level code what we did here. Since
1736 * we have restarted all of the outstanding commands,
1737 * then report SUCCESS.
1738 */
1739 return (SCSI_RESET_SUCCESS | SCSI_RESET_BUS_RESET);
1740 fail:
1741 printk(KERN_CRIT "aha1542.c: Unable to perform hard reset.\n");
1742 printk(KERN_CRIT "Power cycle machine to reset\n");
1743 return (SCSI_RESET_ERROR | SCSI_RESET_BUS_RESET);
1744
1745
1746 } else {
1747 /* This does a selective reset of just the one device */
1748 /* First locate the ccb for this command */
1749 for (i = 0; i < AHA1542_MAILBOXES; i++)
1750 if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1751 HOSTDATA(SCpnt->host)->ccb[i].op = 0x81; /* BUS DEVICE RESET */
1752 /* Now tell the 1542 to flush all pending commands for this target */
1753 aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1754
1755 /* Here is the tricky part. What to do next. Do we get an interrupt
1756 for the commands that we aborted with the specified target, or
1757 do we generate this on our own? Try it without first and see
1758 what happens */
1759 printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1760
1761 /* If the first does not work, then try the second. I think the
1762 first option is more likely to be correct. Free the command
1763 block for all commands running on this target... */
1764 for (i = 0; i < AHA1542_MAILBOXES; i++)
1765 if (HOSTDATA(SCpnt->host)->SCint[i] &&
1766 HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) {
1767 Scsi_Cmnd *SCtmp;
1768 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1769 SCtmp->result = DID_RESET << 16;
1770 if (SCtmp->host_scribble) {
1771 kfree(SCtmp->host_scribble);
1772 SCtmp->host_scribble = NULL;
1773 }
1774 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target);
1775 SCtmp->scsi_done(SCpnt);
1776
1777 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1778 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1779 }
1780 return SCSI_RESET_SUCCESS;
1781 }
1782 }
1783 /* No active command at this time, so this means that each time we got
1784 some kind of response the last time through. Tell the mid-level code
1785 to request sense information in order to decide what to do next. */
1786 return SCSI_RESET_PUNT;
1787 }
1788 #endif /* end of big comment block around old_abort + old_reset */
1789
1790 static int aha1542_biosparam(struct scsi_device *sdev,
1791 struct block_device *bdev, sector_t capacity, int *ip)
1792 {
1793 int translation_algorithm;
1794 int size = capacity;
1795
1796 translation_algorithm = HOSTDATA(sdev->host)->bios_translation;
1797
1798 if ((size >> 11) > 1024 && translation_algorithm == BIOS_TRANSLATION_25563) {
1799 /* Please verify that this is the same as what DOS returns */
1800 ip[0] = 255;
1801 ip[1] = 63;
1802 ip[2] = size / 255 / 63;
1803 } else {
1804 ip[0] = 64;
1805 ip[1] = 32;
1806 ip[2] = size >> 11;
1807 }
1808
1809 return 0;
1810 }
1811 MODULE_LICENSE("GPL");
1812
1813
1814 static Scsi_Host_Template driver_template = {
1815 .proc_name = "aha1542",
1816 .name = "Adaptec 1542",
1817 .detect = aha1542_detect,
1818 .release = aha1542_release,
1819 .queuecommand = aha1542_queuecommand,
1820 .eh_abort_handler = aha1542_abort,
1821 .eh_device_reset_handler= aha1542_dev_reset,
1822 .eh_bus_reset_handler = aha1542_bus_reset,
1823 .eh_host_reset_handler = aha1542_host_reset,
1824 .bios_param = aha1542_biosparam,
1825 .can_queue = AHA1542_MAILBOXES,
1826 .this_id = 7,
1827 .sg_tablesize = AHA1542_SCATTER,
1828 .cmd_per_lun = AHA1542_CMDLUN,
1829 .unchecked_isa_dma = 1,
1830 .use_clustering = ENABLE_CLUSTERING,
1831 };
1832 #include "scsi_module.c"
Michael's Linux tree.