1 /* $Id: aha1542.c,v 1.1 1992/07/24 06:27:38 root Exp root $
2 * linux/kernel/aha1542.c
4 * Copyright (C) 1992 Tommy Thorn
5 * Copyright (C) 1993, 1994, 1995 Eric Youngdale
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
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
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
24 * Modified by Adam Fritzler
25 * Added proper detection of the AHA-1640 (MCA, now deleted)
28 #include <linux/module.h>
29 #include <linux/interrupt.h>
30 #include <linux/kernel.h>
31 #include <linux/types.h>
32 #include <linux/string.h>
33 #include <linux/ioport.h>
34 #include <linux/delay.h>
35 #include <linux/proc_fs.h>
36 #include <linux/init.h>
37 #include <linux/spinlock.h>
38 #include <linux/isa.h>
39 #include <linux/pnp.h>
40 #include <linux/blkdev.h>
41 #include <linux/slab.h>
47 #include <scsi/scsi_host.h>
49 #include <linux/stat.h>
58 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 $";
61 /* The adaptec can be configured for quite a number of addresses, but
62 I generally do not want the card poking around at random. We allow
63 two addresses - this allows people to use the Adaptec with a Midi
64 card, which also used 0x330 -- can be overridden with LILO! */
66 #define MAXBOARDS 4 /* Increase this and the sizes of the
67 arrays below, if you need more.. */
69 /* Boards 3,4 slots are reserved for ISAPnP scans */
71 static unsigned int bases[MAXBOARDS] = {0x330, 0x334, 0, 0};
73 /* set by aha1542_setup according to the command line; they also may
74 be marked __initdata, but require zero initializers then */
76 static int setup_called[MAXBOARDS];
77 static int setup_buson[MAXBOARDS];
78 static int setup_busoff[MAXBOARDS];
79 static int setup_dmaspeed[MAXBOARDS] = { -1, -1, -1, -1 };
82 * LILO/Module params: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]
84 * Where: <PORTBASE> is any of the valid AHA addresses:
85 * 0x130, 0x134, 0x230, 0x234, 0x330, 0x334
86 * <BUSON> is the time (in microsecs) that AHA spends on the AT-bus
87 * when transferring data. 1542A power-on default is 11us,
88 * valid values are in range: 2..15 (decimal)
89 * <BUSOFF> is the time that AHA spends OFF THE BUS after while
90 * it is transferring data (not to monopolize the bus).
91 * Power-on default is 4us, valid range: 1..64 microseconds.
92 * <DMASPEED> Default is jumper selected (1542A: on the J1),
93 * but experimenter can alter it with this.
94 * Valid values: 5, 6, 7, 8, 10 (MB/s)
95 * Factory default is 5 MB/s.
99 static bool isapnp = 0;
100 static int aha1542[] = {0x330, 11, 4, -1};
101 module_param_array(aha1542, int, NULL, 0);
102 module_param(isapnp, bool, 0);
104 static int isapnp = 1;
107 #define BIOS_TRANSLATION_1632 0 /* Used by some old 1542A boards */
108 #define BIOS_TRANSLATION_6432 1 /* Default case these days */
109 #define BIOS_TRANSLATION_25563 2 /* Big disk case */
111 struct aha1542_hostdata {
112 /* This will effectively start both of them at the first mailbox */
113 int bios_translation; /* Mapping bios uses - for compatibility */
114 int aha1542_last_mbi_used;
115 int aha1542_last_mbo_used;
116 Scsi_Cmnd *SCint[AHA1542_MAILBOXES];
117 struct mailbox mb[2 * AHA1542_MAILBOXES];
118 struct ccb ccb[AHA1542_MAILBOXES];
121 static DEFINE_SPINLOCK(aha1542_lock);
123 static inline void aha1542_intr_reset(u16 base)
125 outb(IRST, CONTROL(base));
128 static inline bool wait_mask(u16 port, u8 mask, u8 allof, u8 noneof, int timeout)
138 u8 bits = inb(port) & mask;
139 if ((bits & allof) == allof && ((bits & noneof) == 0))
150 /* This is a bit complicated, but we need to make sure that an interrupt
151 routine does not send something out while we are in the middle of this.
152 Fortunately, it is only at boot time that multi-byte messages
154 static int aha1542_outb(unsigned int base, u8 cmd)
159 if (!wait_mask(STATUS(base), CDF, 0, CDF, 0)) {
160 printk(KERN_ERR "aha1542_outb failed");
163 spin_lock_irqsave(&aha1542_lock, flags);
164 if (inb(STATUS(base)) & CDF) {
165 spin_unlock_irqrestore(&aha1542_lock, flags);
168 outb(cmd, DATA(base));
169 spin_unlock_irqrestore(&aha1542_lock, flags);
174 static int aha1542_out(unsigned int base, u8 *cmdp, int len)
178 spin_lock_irqsave(&aha1542_lock, flags);
180 if (!wait_mask(STATUS(base), CDF, 0, CDF, 0)) {
181 spin_unlock_irqrestore(&aha1542_lock, flags);
182 printk(KERN_ERR "aha1542_out failed(%d): ", len + 1);
185 outb(*cmdp++, DATA(base));
187 spin_unlock_irqrestore(&aha1542_lock, flags);
192 /* Only used at boot time, so we do not need to worry about latency as much
195 static int aha1542_in(unsigned int base, u8 *cmdp, int len, int timeout)
199 spin_lock_irqsave(&aha1542_lock, flags);
201 if (!wait_mask(STATUS(base), DF, DF, 0, timeout)) {
202 spin_unlock_irqrestore(&aha1542_lock, flags);
204 printk(KERN_ERR "aha1542_in failed(%d): ", len + 1);
207 *cmdp++ = inb(DATA(base));
209 spin_unlock_irqrestore(&aha1542_lock, flags);
213 static int makecode(unsigned hosterr, unsigned scsierr)
217 case 0xa: /* Linked command complete without error and linked normally */
218 case 0xb: /* Linked command complete without error, interrupt generated */
222 case 0x11: /* Selection time out-The initiator selection or target
223 reselection was not complete within the SCSI Time out period */
224 hosterr = DID_TIME_OUT;
227 case 0x12: /* Data overrun/underrun-The target attempted to transfer more data
228 than was allocated by the Data Length field or the sum of the
229 Scatter / Gather Data Length fields. */
231 case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
233 case 0x15: /* MBO command was not 00, 01 or 02-The first byte of the CB was
234 invalid. This usually indicates a software failure. */
236 case 0x16: /* Invalid CCB Operation Code-The first byte of the CCB was invalid.
237 This usually indicates a software failure. */
239 case 0x17: /* Linked CCB does not have the same LUN-A subsequent CCB of a set
240 of linked CCB's does not specify the same logical unit number as
242 case 0x18: /* Invalid Target Direction received from Host-The direction of a
243 Target Mode CCB was invalid. */
245 case 0x19: /* Duplicate CCB Received in Target Mode-More than once CCB was
246 received to service data transfer between the same target LUN
247 and initiator SCSI ID in the same direction. */
249 case 0x1a: /* Invalid CCB or Segment List Parameter-A segment list with a zero
250 length segment or invalid segment list boundaries was received.
251 A CCB parameter was invalid. */
252 DEB(printk("Aha1542: %x %x\n", hosterr, scsierr));
253 hosterr = DID_ERROR; /* Couldn't find any better */
256 case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus
257 phase sequence was requested by the target. The host adapter
258 will generate a SCSI Reset Condition, notifying the host with
263 printk(KERN_ERR "aha1542: makecode: unknown hoststatus %x\n", hosterr);
266 return scsierr | (hosterr << 16);
269 static int aha1542_test_port(int bse, struct Scsi_Host *shpnt)
271 u8 inquiry_result[4];
275 /* Quick and dirty test for presence of the card. */
276 if (inb(STATUS(bse)) == 0xff)
279 /* Reset the adapter. I ought to make a hard reset, but it's not really necessary */
281 /* In case some other card was probing here, reset interrupts */
282 aha1542_intr_reset(bse); /* reset interrupts, so they don't block */
284 outb(SRST | IRST /*|SCRST */ , CONTROL(bse));
286 mdelay(20); /* Wait a little bit for things to settle down. */
288 /* Expect INIT and IDLE, any of the others are bad */
289 if (!wait_mask(STATUS(bse), STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0))
292 /* Shouldn't have generated any interrupts during reset */
293 if (inb(INTRFLAGS(bse)) & INTRMASK)
296 /* Perform a host adapter inquiry instead so we do not need to set
297 up the mailboxes ahead of time */
299 aha1542_outb(bse, CMD_INQUIRY);
302 cmdp = &inquiry_result[0];
305 if (!wait_mask(STATUS(bse), DF, DF, 0, 0))
307 *cmdp++ = inb(DATA(bse));
310 /* Reading port should reset DF */
311 if (inb(STATUS(bse)) & DF)
314 /* When HACC, command is completed, and we're though testing */
315 if (!wait_mask(INTRFLAGS(bse), HACC, HACC, 0, 0))
318 /* Clear interrupts */
319 outb(IRST, CONTROL(bse));
324 /* A "high" level interrupt handler */
325 static void aha1542_intr_handle(struct Scsi_Host *shost)
327 struct aha1542_hostdata *aha1542 = shost_priv(shost);
328 void (*my_done) (Scsi_Cmnd *) = NULL;
329 int errstatus, mbi, mbo, mbistatus;
334 struct mailbox *mb = aha1542->mb;
335 struct ccb *ccb = aha1542->ccb;
339 flag = inb(INTRFLAGS(shost->io_port));
340 printk(KERN_DEBUG "aha1542_intr_handle: ");
341 if (!(flag & ANYINTR))
342 printk("no interrupt?");
351 printk("status %02x\n", inb(STATUS(shost->io_port)));
357 flag = inb(INTRFLAGS(shost->io_port));
359 /* Check for unusual interrupts. If any of these happen, we should
360 probably do something special, but for now just printing a message
361 is sufficient. A SCSI reset detected is something that we really
362 need to deal with in some way. */
371 aha1542_intr_reset(shost->io_port);
373 spin_lock_irqsave(&aha1542_lock, flags);
374 mbi = aha1542->aha1542_last_mbi_used + 1;
375 if (mbi >= 2 * AHA1542_MAILBOXES)
376 mbi = AHA1542_MAILBOXES;
379 if (mb[mbi].status != 0)
382 if (mbi >= 2 * AHA1542_MAILBOXES)
383 mbi = AHA1542_MAILBOXES;
384 } while (mbi != aha1542->aha1542_last_mbi_used);
386 if (mb[mbi].status == 0) {
387 spin_unlock_irqrestore(&aha1542_lock, flags);
388 /* Hmm, no mail. Must have read it the last time around */
389 if (!number_serviced)
390 printk(KERN_WARNING "aha1542.c: interrupt received, but no mail.\n");
394 mbo = (scsi2int(mb[mbi].ccbptr) - (isa_virt_to_bus(&ccb[0]))) / sizeof(struct ccb);
395 mbistatus = mb[mbi].status;
397 aha1542->aha1542_last_mbi_used = mbi;
398 spin_unlock_irqrestore(&aha1542_lock, flags);
402 if (ccb[mbo].tarstat | ccb[mbo].hastat)
403 printk(KERN_DEBUG "aha1542_command: returning %x (status %d)\n",
404 ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status);
409 continue; /* Aborted command not found */
412 printk(KERN_DEBUG "...done %d %d\n", mbo, mbi);
415 SCtmp = aha1542->SCint[mbo];
417 if (!SCtmp || !SCtmp->scsi_done) {
418 printk(KERN_WARNING "aha1542_intr_handle: Unexpected interrupt\n");
419 printk(KERN_WARNING "tarstat=%x, hastat=%x idlun=%x ccb#=%d \n", ccb[mbo].tarstat,
420 ccb[mbo].hastat, ccb[mbo].idlun, mbo);
423 my_done = SCtmp->scsi_done;
424 kfree(SCtmp->host_scribble);
425 SCtmp->host_scribble = NULL;
426 /* Fetch the sense data, and tuck it away, in the required slot. The
427 Adaptec automatically fetches it, and there is no guarantee that
428 we will still have it in the cdb when we come back */
429 if (ccb[mbo].tarstat == 2)
430 memcpy(SCtmp->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen],
431 SCSI_SENSE_BUFFERSIZE);
434 /* is there mail :-) */
436 /* more error checking left out here */
438 /* This is surely wrong, but I don't know what's right */
439 errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat);
445 printk(KERN_DEBUG "(aha1542 error:%x %x %x) ", errstatus,
446 ccb[mbo].hastat, ccb[mbo].tarstat);
449 if (ccb[mbo].tarstat == 2) {
453 DEB(printk("aha1542_intr_handle: sense:"));
455 for (i = 0; i < 12; i++)
456 printk("%02x ", ccb[mbo].cdb[ccb[mbo].cdblen + i]);
460 DEB(printk("aha1542_intr_handle: buf:"));
461 for (i = 0; i < bufflen; i++)
462 printk("%02x ", ((unchar *)buff)[i]);
466 DEB(if (errstatus) printk("aha1542_intr_handle: returning %6x\n", errstatus));
467 SCtmp->result = errstatus;
468 aha1542->SCint[mbo] = NULL; /* This effectively frees up the mailbox slot, as
469 far as queuecommand is concerned */
475 /* A quick wrapper for do_aha1542_intr_handle to grab the spin lock */
476 static irqreturn_t do_aha1542_intr_handle(int dummy, void *dev_id)
479 struct Scsi_Host *shost = dev_id;
481 spin_lock_irqsave(shost->host_lock, flags);
482 aha1542_intr_handle(shost);
483 spin_unlock_irqrestore(shost->host_lock, flags);
487 static int aha1542_queuecommand_lck(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
489 struct aha1542_hostdata *aha1542 = shost_priv(SCpnt->device->host);
491 u8 *cmd = (u8 *) SCpnt->cmnd;
492 u8 target = SCpnt->device->id;
493 u8 lun = SCpnt->device->lun;
495 int bufflen = scsi_bufflen(SCpnt);
497 struct mailbox *mb = aha1542->mb;
498 struct ccb *ccb = aha1542->ccb;
502 DEB(if (target > 1) {
503 SCpnt->result = DID_TIME_OUT << 16;
504 done(SCpnt); return 0;
508 if (*cmd == REQUEST_SENSE) {
509 /* Don't do the command - we have the sense data already */
515 if (*cmd == READ_10 || *cmd == WRITE_10)
516 i = xscsi2int(cmd + 2);
517 else if (*cmd == READ_6 || *cmd == WRITE_6)
518 i = scsi2int(cmd + 2);
522 printk(KERN_DEBUG "aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
524 printk(KERN_DEBUG "aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
525 printk(KERN_DEBUG "aha1542_queuecommand: dumping scsi cmd:");
526 for (i = 0; i < SCpnt->cmd_len; i++)
527 printk("%02x ", cmd[i]);
529 if (*cmd == WRITE_10 || *cmd == WRITE_6)
530 return 0; /* we are still testing, so *don't* write */
532 /* Use the outgoing mailboxes in a round-robin fashion, because this
533 is how the host adapter will scan for them */
535 spin_lock_irqsave(&aha1542_lock, flags);
536 mbo = aha1542->aha1542_last_mbo_used + 1;
537 if (mbo >= AHA1542_MAILBOXES)
541 if (mb[mbo].status == 0 && aha1542->SCint[mbo] == NULL)
544 if (mbo >= AHA1542_MAILBOXES)
546 } while (mbo != aha1542->aha1542_last_mbo_used);
548 if (mb[mbo].status || aha1542->SCint[mbo])
549 panic("Unable to find empty mailbox for aha1542.\n");
551 aha1542->SCint[mbo] = SCpnt; /* This will effectively prevent someone else from
552 screwing with this cdb. */
554 aha1542->aha1542_last_mbo_used = mbo;
555 spin_unlock_irqrestore(&aha1542_lock, flags);
558 printk(KERN_DEBUG "Sending command (%d %x)...", mbo, done);
561 any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo])); /* This gets trashed for some reason */
563 memset(&ccb[mbo], 0, sizeof(struct ccb));
565 ccb[mbo].cdblen = SCpnt->cmd_len;
568 if (*cmd == READ_10 || *cmd == READ_6)
570 else if (*cmd == WRITE_10 || *cmd == WRITE_6)
573 memcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
576 struct scatterlist *sg;
581 int i, sg_count = scsi_sg_count(SCpnt);
582 ccb[mbo].op = 2; /* SCSI Initiator Command w/scatter-gather */
583 SCpnt->host_scribble = kmalloc(sizeof(*cptr)*sg_count,
584 GFP_KERNEL | GFP_DMA);
585 cptr = (struct chain *) SCpnt->host_scribble;
587 /* free the claimed mailbox slot */
588 aha1542->SCint[mbo] = NULL;
589 return SCSI_MLQUEUE_HOST_BUSY;
591 scsi_for_each_sg(SCpnt, sg, sg_count, i) {
592 any2scsi(cptr[i].dataptr, isa_page_to_bus(sg_page(sg))
594 any2scsi(cptr[i].datalen, sg->length);
596 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain));
597 any2scsi(ccb[mbo].dataptr, isa_virt_to_bus(cptr));
599 printk("cptr %x: ", cptr);
600 ptr = (unsigned char *) cptr;
601 for (i = 0; i < 18; i++)
602 printk("%02x ", ptr[i]);
605 ccb[mbo].op = 0; /* SCSI Initiator Command */
606 SCpnt->host_scribble = NULL;
607 any2scsi(ccb[mbo].datalen, 0);
608 any2scsi(ccb[mbo].dataptr, 0);
610 ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7); /*SCSI Target Id */
611 ccb[mbo].rsalen = 16;
612 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
613 ccb[mbo].commlinkid = 0;
618 printk(KERN_DEBUG "aha1542_command: sending.. ");
619 for (i = 0; i < sizeof(ccb[mbo]) - 10; i++)
620 printk("%02x ", ((u8 *) &ccb[mbo])[i]);
625 DEB(printk("aha1542_queuecommand: now waiting for interrupt "));
626 SCpnt->scsi_done = done;
628 aha1542_outb(SCpnt->device->host->io_port, CMD_START_SCSI);
630 printk("aha1542_queuecommand: done can't be NULL\n");
635 static DEF_SCSI_QCMD(aha1542_queuecommand)
637 /* Initialize mailboxes */
638 static void setup_mailboxes(int bse, struct Scsi_Host *shpnt)
640 struct aha1542_hostdata *aha1542 = shost_priv(shpnt);
642 struct mailbox *mb = aha1542->mb;
643 struct ccb *ccb = aha1542->ccb;
645 u8 cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
647 for (i = 0; i < AHA1542_MAILBOXES; i++) {
648 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0;
649 any2scsi(mb[i].ccbptr, isa_virt_to_bus(&ccb[i]));
651 aha1542_intr_reset(bse); /* reset interrupts, so they don't block */
652 any2scsi((cmd + 2), isa_virt_to_bus(mb));
653 aha1542_out(bse, cmd, 5);
654 if (!wait_mask(INTRFLAGS(bse), INTRMASK, HACC, 0, 0))
655 printk(KERN_ERR "aha1542_detect: failed setting up mailboxes\n");
656 aha1542_intr_reset(bse);
659 static int aha1542_getconfig(int base_io, unsigned char *irq_level, unsigned char *dma_chan, unsigned char *scsi_id)
661 u8 inquiry_result[3];
663 i = inb(STATUS(base_io));
665 i = inb(DATA(base_io));
667 aha1542_outb(base_io, CMD_RETCONF);
668 aha1542_in(base_io, inquiry_result, 3, 0);
669 if (!wait_mask(INTRFLAGS(base_io), INTRMASK, HACC, 0, 0))
670 printk(KERN_ERR "aha1542_detect: query board settings\n");
671 aha1542_intr_reset(base_io);
672 switch (inquiry_result[0]) {
686 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel.
687 Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */
691 printk(KERN_ERR "Unable to determine Adaptec DMA priority. Disabling board\n");
694 switch (inquiry_result[1]) {
714 printk(KERN_ERR "Unable to determine Adaptec IRQ level. Disabling board\n");
717 *scsi_id = inquiry_result[2] & 7;
721 /* This function should only be called for 1542C boards - we can detect
722 the special firmware settings and unlock the board */
724 static int aha1542_mbenable(int base)
726 static u8 mbenable_cmd[3];
727 static u8 mbenable_result[2];
730 retval = BIOS_TRANSLATION_6432;
732 aha1542_outb(base, CMD_EXTBIOS);
733 if (aha1542_in(base, mbenable_result, 2, 100))
735 if (!wait_mask(INTRFLAGS(base), INTRMASK, HACC, 0, 100))
737 aha1542_intr_reset(base);
739 if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
740 mbenable_cmd[0] = CMD_MBENABLE;
742 mbenable_cmd[2] = mbenable_result[1];
744 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03))
745 retval = BIOS_TRANSLATION_25563;
747 aha1542_out(base, mbenable_cmd, 3);
748 if (!wait_mask(INTRFLAGS(base), INTRMASK, HACC, 0, 0))
753 printk(KERN_ERR "aha1542_mbenable: Mailbox init failed\n");
755 aha1542_intr_reset(base);
759 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */
760 static int aha1542_query(int base_io, int *transl)
762 u8 inquiry_result[4];
764 i = inb(STATUS(base_io));
766 i = inb(DATA(base_io));
768 aha1542_outb(base_io, CMD_INQUIRY);
769 aha1542_in(base_io, inquiry_result, 4, 0);
770 if (!wait_mask(INTRFLAGS(base_io), INTRMASK, HACC, 0, 0))
771 printk(KERN_ERR "aha1542_detect: query card type\n");
772 aha1542_intr_reset(base_io);
774 *transl = BIOS_TRANSLATION_6432; /* Default case */
776 /* For an AHA1740 series board, we ignore the board since there is a
777 hardware bug which can lead to wrong blocks being returned if the board
778 is operating in the 1542 emulation mode. Since there is an extended mode
779 driver, we simply ignore the board and let the 1740 driver pick it up.
782 if (inquiry_result[0] == 0x43) {
783 printk(KERN_INFO "aha1542.c: Emulation mode not supported for AHA 174N hardware.\n");
787 /* Always call this - boards that do not support extended bios translation
788 will ignore the command, and we will set the proper default */
790 *transl = aha1542_mbenable(base_io);
796 static char *setup_str[MAXBOARDS] __initdata;
797 static int setup_idx = 0;
799 static void __init aha1542_setup(char *str, int *ints)
801 const char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n";
804 if (setup_idx >= MAXBOARDS) {
805 printk(KERN_ERR "aha1542: aha1542_setup called too many times! Bad LILO params ?\n");
806 printk(KERN_ERR " Entryline 1: %s\n", setup_str[0]);
807 printk(KERN_ERR " Entryline 2: %s\n", setup_str[1]);
808 printk(KERN_ERR " This line: %s\n", str);
811 if (ints[0] < 1 || ints[0] > 4) {
812 printk(KERN_ERR "aha1542: %s\n", str);
814 printk(KERN_ERR "aha1542: Wrong parameters may cause system malfunction.. We try anyway..\n");
816 setup_called[setup_idx] = ints[0];
817 setup_str[setup_idx] = str;
819 setup_portbase = ints[0] >= 1 ? ints[1] : 0; /* Preserve the default value.. */
820 setup_buson[setup_idx] = ints[0] >= 2 ? ints[2] : 7;
821 setup_busoff[setup_idx] = ints[0] >= 3 ? ints[3] : 5;
842 printk(KERN_ERR "aha1542: %s\n", str);
844 printk(KERN_ERR "aha1542: Valid values for DMASPEED are 5-8, 10 MB/s. Using jumper defaults.\n");
847 setup_dmaspeed[setup_idx] = atbt;
849 if (setup_portbase != 0)
850 bases[setup_idx] = setup_portbase;
855 static int __init do_setup(char *str)
861 get_options(str, ARRAY_SIZE(ints), ints);
862 aha1542_setup(str,ints);
864 return count<setup_idx;
867 __setup("aha1542=",do_setup);
870 /* return non-zero on detection */
871 static struct Scsi_Host *aha1542_hw_init(struct scsi_host_template *tpnt, struct device *pdev, int indx)
873 unsigned char dma_chan;
874 unsigned char irq_level;
875 unsigned char scsi_id;
877 unsigned int base_io;
879 struct Scsi_Host *shpnt = NULL;
880 struct aha1542_hostdata *aha1542;
882 DEB(printk("aha1542_detect: \n"));
884 tpnt->proc_name = "aha1542";
886 if (bases[indx] != 0 && request_region(bases[indx], 4, "aha1542")) {
887 shpnt = scsi_host_alloc(tpnt,
888 sizeof(struct aha1542_hostdata));
891 release_region(bases[indx], 4);
894 aha1542 = shost_priv(shpnt);
895 if (!aha1542_test_port(bases[indx], shpnt))
898 base_io = bases[indx];
900 /* Set the Bus on/off-times as not to ruin floppy performance */
902 u8 oncmd[] = {CMD_BUSON_TIME, 7};
903 u8 offcmd[] = {CMD_BUSOFF_TIME, 5};
905 if (setup_called[indx]) {
906 oncmd[1] = setup_buson[indx];
907 offcmd[1] = setup_busoff[indx];
909 aha1542_intr_reset(base_io);
910 aha1542_out(base_io, oncmd, 2);
911 if (!wait_mask(INTRFLAGS(base_io), INTRMASK, HACC, 0, 0))
913 aha1542_intr_reset(base_io);
914 aha1542_out(base_io, offcmd, 2);
915 if (!wait_mask(INTRFLAGS(base_io), INTRMASK, HACC, 0, 0))
917 if (setup_dmaspeed[indx] >= 0) {
918 u8 dmacmd[] = {CMD_DMASPEED, 0};
919 dmacmd[1] = setup_dmaspeed[indx];
920 aha1542_intr_reset(base_io);
921 aha1542_out(base_io, dmacmd, 2);
922 if (!wait_mask(INTRFLAGS(base_io), INTRMASK, HACC, 0, 0))
927 printk(KERN_ERR "aha1542_detect: setting bus on/off-time failed\n");
929 aha1542_intr_reset(base_io);
931 if (aha1542_query(base_io, &trans))
934 if (aha1542_getconfig(base_io, &irq_level, &dma_chan, &scsi_id) == -1)
937 printk(KERN_INFO "Configuring Adaptec (SCSI-ID %d) at IO:%x, IRQ %d", scsi_id, base_io, irq_level);
938 if (dma_chan != 0xFF)
939 printk(", DMA priority %d", dma_chan);
942 setup_mailboxes(base_io, shpnt);
944 DEB(printk("aha1542_detect: enable interrupt channel %d\n", irq_level));
945 spin_lock_irqsave(&aha1542_lock, flags);
946 if (request_irq(irq_level, do_aha1542_intr_handle, 0,
948 printk(KERN_ERR "Unable to allocate IRQ for adaptec controller.\n");
949 spin_unlock_irqrestore(&aha1542_lock, flags);
952 if (dma_chan != 0xFF) {
953 if (request_dma(dma_chan, "aha1542")) {
954 printk(KERN_ERR "Unable to allocate DMA channel for Adaptec.\n");
955 free_irq(irq_level, shpnt);
956 spin_unlock_irqrestore(&aha1542_lock, flags);
959 if (dma_chan == 0 || dma_chan >= 5) {
960 set_dma_mode(dma_chan, DMA_MODE_CASCADE);
961 enable_dma(dma_chan);
965 shpnt->this_id = scsi_id;
966 shpnt->unique_id = base_io;
967 shpnt->io_port = base_io;
968 shpnt->n_io_port = 4; /* Number of bytes of I/O space used */
969 shpnt->dma_channel = dma_chan;
970 shpnt->irq = irq_level;
971 aha1542->bios_translation = trans;
972 if (trans == BIOS_TRANSLATION_25563)
973 printk(KERN_INFO "aha1542.c: Using extended bios translation\n");
974 aha1542->aha1542_last_mbi_used = (2 * AHA1542_MAILBOXES - 1);
975 aha1542->aha1542_last_mbo_used = (AHA1542_MAILBOXES - 1);
976 memset(aha1542->SCint, 0, sizeof(aha1542->SCint));
977 spin_unlock_irqrestore(&aha1542_lock, flags);
979 if (scsi_add_host(shpnt, pdev)) {
980 if (shpnt->dma_channel != 0xff)
981 free_dma(shpnt->dma_channel);
982 free_irq(irq_level, shpnt);
986 scsi_scan_host(shpnt);
990 release_region(bases[indx], 4);
991 scsi_host_put(shpnt);
999 static int aha1542_release(struct Scsi_Host *shost)
1001 scsi_remove_host(shost);
1003 free_irq(shost->irq, shost);
1004 if (shost->dma_channel != 0xff)
1005 free_dma(shost->dma_channel);
1006 if (shost->io_port && shost->n_io_port)
1007 release_region(shost->io_port, shost->n_io_port);
1008 scsi_host_put(shost);
1014 * This is a device reset. This is handled by sending a special command
1017 static int aha1542_dev_reset(Scsi_Cmnd * SCpnt)
1019 struct aha1542_hostdata *aha1542 = shost_priv(SCpnt->device->host);
1020 unsigned long flags;
1021 struct mailbox *mb = aha1542->mb;
1022 u8 target = SCpnt->device->id;
1023 u8 lun = SCpnt->device->lun;
1025 struct ccb *ccb = aha1542->ccb;
1027 spin_lock_irqsave(&aha1542_lock, flags);
1028 mbo = aha1542->aha1542_last_mbo_used + 1;
1029 if (mbo >= AHA1542_MAILBOXES)
1033 if (mb[mbo].status == 0 && aha1542->SCint[mbo] == NULL)
1036 if (mbo >= AHA1542_MAILBOXES)
1038 } while (mbo != aha1542->aha1542_last_mbo_used);
1040 if (mb[mbo].status || aha1542->SCint[mbo])
1041 panic("Unable to find empty mailbox for aha1542.\n");
1043 aha1542->SCint[mbo] = SCpnt; /* This will effectively
1044 prevent someone else from
1045 screwing with this cdb. */
1047 aha1542->aha1542_last_mbo_used = mbo;
1048 spin_unlock_irqrestore(&aha1542_lock, flags);
1050 any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo])); /* This gets trashed for some reason */
1052 memset(&ccb[mbo], 0, sizeof(struct ccb));
1054 ccb[mbo].op = 0x81; /* BUS DEVICE RESET */
1056 ccb[mbo].idlun = (target & 7) << 5 | (lun & 7); /*SCSI Target Id */
1058 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
1059 ccb[mbo].commlinkid = 0;
1062 * Now tell the 1542 to flush all pending commands for this
1065 aha1542_outb(SCpnt->device->host->io_port, CMD_START_SCSI);
1067 scmd_printk(KERN_WARNING, SCpnt,
1068 "Trying device reset for target\n");
1073 static int aha1542_reset(Scsi_Cmnd *SCpnt, u8 reset_cmd)
1075 struct aha1542_hostdata *aha1542 = shost_priv(SCpnt->device->host);
1079 * This does a scsi reset for all devices on the bus.
1080 * In principle, we could also reset the 1542 - should
1081 * we do this? Try this first, and we can add that later
1082 * if it turns out to be useful.
1084 outb(reset_cmd, CONTROL(SCpnt->device->host->io_port));
1087 * Wait for the thing to settle down a bit. Unfortunately
1088 * this is going to basically lock up the machine while we
1089 * wait for this to complete. To be 100% correct, we need to
1090 * check for timeout, and if we are doing something like this
1091 * we are pretty desperate anyways.
1094 spin_lock_irq(SCpnt->device->host->host_lock);
1096 if (!wait_mask(STATUS(SCpnt->device->host->io_port),
1097 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0)) {
1098 spin_unlock_irq(SCpnt->device->host->host_lock);
1102 * We need to do this too before the 1542 can interact with
1103 * us again after host reset.
1105 if (reset_cmd & HRST)
1106 setup_mailboxes(SCpnt->device->host->io_port, SCpnt->device->host);
1108 * Now try to pick up the pieces. For all pending commands,
1109 * free any internal data structures, and basically clear things
1110 * out. We do not try and restart any commands or anything -
1111 * the strategy handler takes care of that crap.
1113 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1115 for (i = 0; i < AHA1542_MAILBOXES; i++) {
1116 if (aha1542->SCint[i] != NULL) {
1118 SCtmp = aha1542->SCint[i];
1120 if (SCtmp->device->soft_reset) {
1122 * If this device implements the soft reset option,
1123 * then it is still holding onto the command, and
1124 * may yet complete it. In this case, we don't
1129 kfree(SCtmp->host_scribble);
1130 SCtmp->host_scribble = NULL;
1131 aha1542->SCint[i] = NULL;
1132 aha1542->mb[i].status = 0;
1136 spin_unlock_irq(SCpnt->device->host->host_lock);
1140 static int aha1542_bus_reset(Scsi_Cmnd *SCpnt)
1142 return aha1542_reset(SCpnt, SCRST);
1145 static int aha1542_host_reset(Scsi_Cmnd *SCpnt)
1147 return aha1542_reset(SCpnt, HRST | SCRST);
1150 static int aha1542_biosparam(struct scsi_device *sdev,
1151 struct block_device *bdev, sector_t capacity, int *ip)
1153 struct aha1542_hostdata *aha1542 = shost_priv(sdev->host);
1154 int translation_algorithm;
1155 int size = capacity;
1157 translation_algorithm = aha1542->bios_translation;
1159 if ((size >> 11) > 1024 && translation_algorithm == BIOS_TRANSLATION_25563) {
1160 /* Please verify that this is the same as what DOS returns */
1163 ip[2] = size / 255 / 63;
1172 MODULE_LICENSE("GPL");
1174 static struct scsi_host_template driver_template = {
1175 .module = THIS_MODULE,
1176 .proc_name = "aha1542",
1177 .name = "Adaptec 1542",
1178 .queuecommand = aha1542_queuecommand,
1179 .eh_device_reset_handler= aha1542_dev_reset,
1180 .eh_bus_reset_handler = aha1542_bus_reset,
1181 .eh_host_reset_handler = aha1542_host_reset,
1182 .bios_param = aha1542_biosparam,
1183 .can_queue = AHA1542_MAILBOXES,
1187 .unchecked_isa_dma = 1,
1188 .use_clustering = ENABLE_CLUSTERING,
1191 static int aha1542_isa_match(struct device *pdev, unsigned int ndev)
1193 struct Scsi_Host *sh = aha1542_hw_init(&driver_template, pdev, ndev);
1198 dev_set_drvdata(pdev, sh);
1202 static int aha1542_isa_remove(struct device *pdev,
1205 aha1542_release(dev_get_drvdata(pdev));
1206 dev_set_drvdata(pdev, NULL);
1210 static struct isa_driver aha1542_isa_driver = {
1211 .match = aha1542_isa_match,
1212 .remove = aha1542_isa_remove,
1217 static int isa_registered;
1220 static struct pnp_device_id aha1542_pnp_ids[] = {
1221 { .id = "ADP1542" },
1224 MODULE_DEVICE_TABLE(pnp, aha1542_pnp_ids);
1226 static int aha1542_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id)
1229 struct Scsi_Host *sh;
1231 for (indx = 0; indx < ARRAY_SIZE(bases); indx++) {
1235 if (pnp_activate_dev(pdev) < 0)
1238 bases[indx] = pnp_port_start(pdev, 0);
1240 /* The card can be queried for its DMA, we have
1241 the DMA set up that is enough */
1243 printk(KERN_INFO "ISAPnP found an AHA1535 at I/O 0x%03X\n", bases[indx]);
1246 sh = aha1542_hw_init(&driver_template, &pdev->dev, indx);
1250 pnp_set_drvdata(pdev, sh);
1254 static void aha1542_pnp_remove(struct pnp_dev *pdev)
1256 aha1542_release(pnp_get_drvdata(pdev));
1257 pnp_set_drvdata(pdev, NULL);
1260 static struct pnp_driver aha1542_pnp_driver = {
1262 .id_table = aha1542_pnp_ids,
1263 .probe = aha1542_pnp_probe,
1264 .remove = aha1542_pnp_remove,
1266 static int pnp_registered;
1267 #endif /* CONFIG_PNP */
1269 static int __init aha1542_init(void)
1275 bases[0] = aha1542[0];
1276 setup_buson[0] = aha1542[1];
1277 setup_busoff[0] = aha1542[2];
1279 switch (aha1542[3]) {
1296 setup_dmaspeed[0] = atbt;
1301 ret = pnp_register_driver(&aha1542_pnp_driver);
1306 ret = isa_register_driver(&aha1542_isa_driver, MAXBOARDS);
1320 static void __exit aha1542_exit(void)
1324 pnp_unregister_driver(&aha1542_pnp_driver);
1327 isa_unregister_driver(&aha1542_isa_driver);
1330 module_init(aha1542_init);
1331 module_exit(aha1542_exit);