2 * Driver for Adaptec AHA-1542 SCSI host adapters
4 * Copyright (C) 1992 Tommy Thorn
5 * Copyright (C) 1993, 1994, 1995 Eric Youngdale
6 * Copyright (C) 2015 Ondrej Zary
9 #include <linux/module.h>
10 #include <linux/interrupt.h>
11 #include <linux/kernel.h>
12 #include <linux/types.h>
13 #include <linux/string.h>
14 #include <linux/delay.h>
15 #include <linux/init.h>
16 #include <linux/spinlock.h>
17 #include <linux/isa.h>
18 #include <linux/pnp.h>
19 #include <linux/slab.h>
22 #include <scsi/scsi_cmnd.h>
23 #include <scsi/scsi_device.h>
24 #include <scsi/scsi_host.h>
29 static bool isapnp = 1;
30 module_param(isapnp, bool, 0);
31 MODULE_PARM_DESC(isapnp, "enable PnP support (default=1)");
33 static int io[MAXBOARDS] = { 0x330, 0x334, 0, 0 };
34 module_param_array(io, int, NULL, 0);
35 MODULE_PARM_DESC(io, "base IO address of controller (0x130,0x134,0x230,0x234,0x330,0x334, default=0x330,0x334)");
37 /* time AHA spends on the AT-bus during data transfer */
38 static int bus_on[MAXBOARDS] = { -1, -1, -1, -1 }; /* power-on default: 11us */
39 module_param_array(bus_on, int, NULL, 0);
40 MODULE_PARM_DESC(bus_on, "bus on time [us] (2-15, default=-1 [HW default: 11])");
42 /* time AHA spends off the bus (not to monopolize it) during data transfer */
43 static int bus_off[MAXBOARDS] = { -1, -1, -1, -1 }; /* power-on default: 4us */
44 module_param_array(bus_off, int, NULL, 0);
45 MODULE_PARM_DESC(bus_off, "bus off time [us] (1-64, default=-1 [HW default: 4])");
47 /* default is jumper selected (J1 on 1542A), factory default = 5 MB/s */
48 static int dma_speed[MAXBOARDS] = { -1, -1, -1, -1 };
49 module_param_array(dma_speed, int, NULL, 0);
50 MODULE_PARM_DESC(dma_speed, "DMA speed [MB/s] (5,6,7,8,10, default=-1 [by jumper])");
52 #define BIOS_TRANSLATION_6432 1 /* Default case these days */
53 #define BIOS_TRANSLATION_25563 2 /* Big disk case */
55 struct aha1542_hostdata {
56 /* This will effectively start both of them at the first mailbox */
57 int bios_translation; /* Mapping bios uses - for compatibility */
58 int aha1542_last_mbi_used;
59 int aha1542_last_mbo_used;
60 struct scsi_cmnd *int_cmds[AHA1542_MAILBOXES];
61 struct mailbox mb[2 * AHA1542_MAILBOXES];
62 struct ccb ccb[AHA1542_MAILBOXES];
65 static inline void aha1542_intr_reset(u16 base)
67 outb(IRST, CONTROL(base));
70 static inline bool wait_mask(u16 port, u8 mask, u8 allof, u8 noneof, int timeout)
80 u8 bits = inb(port) & mask;
81 if ((bits & allof) == allof && ((bits & noneof) == 0))
92 static int aha1542_outb(unsigned int base, u8 val)
94 if (!wait_mask(STATUS(base), CDF, 0, CDF, 0))
96 outb(val, DATA(base));
101 static int aha1542_out(unsigned int base, u8 *buf, int len)
104 if (!wait_mask(STATUS(base), CDF, 0, CDF, 0))
106 outb(*buf++, DATA(base));
108 if (!wait_mask(INTRFLAGS(base), INTRMASK, HACC, 0, 0))
114 /* Only used at boot time, so we do not need to worry about latency as much
117 static int aha1542_in(unsigned int base, u8 *buf, int len, int timeout)
120 if (!wait_mask(STATUS(base), DF, DF, 0, timeout))
122 *buf++ = inb(DATA(base));
127 static int makecode(unsigned hosterr, unsigned scsierr)
131 case 0xa: /* Linked command complete without error and linked normally */
132 case 0xb: /* Linked command complete without error, interrupt generated */
136 case 0x11: /* Selection time out-The initiator selection or target
137 reselection was not complete within the SCSI Time out period */
138 hosterr = DID_TIME_OUT;
141 case 0x12: /* Data overrun/underrun-The target attempted to transfer more data
142 than was allocated by the Data Length field or the sum of the
143 Scatter / Gather Data Length fields. */
145 case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
147 case 0x15: /* MBO command was not 00, 01 or 02-The first byte of the CB was
148 invalid. This usually indicates a software failure. */
150 case 0x16: /* Invalid CCB Operation Code-The first byte of the CCB was invalid.
151 This usually indicates a software failure. */
153 case 0x17: /* Linked CCB does not have the same LUN-A subsequent CCB of a set
154 of linked CCB's does not specify the same logical unit number as
156 case 0x18: /* Invalid Target Direction received from Host-The direction of a
157 Target Mode CCB was invalid. */
159 case 0x19: /* Duplicate CCB Received in Target Mode-More than once CCB was
160 received to service data transfer between the same target LUN
161 and initiator SCSI ID in the same direction. */
163 case 0x1a: /* Invalid CCB or Segment List Parameter-A segment list with a zero
164 length segment or invalid segment list boundaries was received.
165 A CCB parameter was invalid. */
167 printk("Aha1542: %x %x\n", hosterr, scsierr);
169 hosterr = DID_ERROR; /* Couldn't find any better */
172 case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus
173 phase sequence was requested by the target. The host adapter
174 will generate a SCSI Reset Condition, notifying the host with
179 printk(KERN_ERR "aha1542: makecode: unknown hoststatus %x\n", hosterr);
182 return scsierr | (hosterr << 16);
185 static int aha1542_test_port(struct Scsi_Host *sh)
187 u8 inquiry_result[4];
190 /* Quick and dirty test for presence of the card. */
191 if (inb(STATUS(sh->io_port)) == 0xff)
194 /* Reset the adapter. I ought to make a hard reset, but it's not really necessary */
196 /* In case some other card was probing here, reset interrupts */
197 aha1542_intr_reset(sh->io_port); /* reset interrupts, so they don't block */
199 outb(SRST | IRST /*|SCRST */ , CONTROL(sh->io_port));
201 mdelay(20); /* Wait a little bit for things to settle down. */
203 /* Expect INIT and IDLE, any of the others are bad */
204 if (!wait_mask(STATUS(sh->io_port), STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0))
207 /* Shouldn't have generated any interrupts during reset */
208 if (inb(INTRFLAGS(sh->io_port)) & INTRMASK)
211 /* Perform a host adapter inquiry instead so we do not need to set
212 up the mailboxes ahead of time */
214 aha1542_outb(sh->io_port, CMD_INQUIRY);
216 for (i = 0; i < 4; i++) {
217 if (!wait_mask(STATUS(sh->io_port), DF, DF, 0, 0))
219 inquiry_result[i] = inb(DATA(sh->io_port));
222 /* Reading port should reset DF */
223 if (inb(STATUS(sh->io_port)) & DF)
226 /* When HACC, command is completed, and we're though testing */
227 if (!wait_mask(INTRFLAGS(sh->io_port), HACC, HACC, 0, 0))
230 /* Clear interrupts */
231 outb(IRST, CONTROL(sh->io_port));
236 static irqreturn_t aha1542_interrupt(int irq, void *dev_id)
238 struct Scsi_Host *sh = dev_id;
239 struct aha1542_hostdata *aha1542 = shost_priv(sh);
240 void (*my_done)(struct scsi_cmnd *) = NULL;
241 int errstatus, mbi, mbo, mbistatus;
244 struct scsi_cmnd *tmp_cmd;
246 struct mailbox *mb = aha1542->mb;
247 struct ccb *ccb = aha1542->ccb;
251 flag = inb(INTRFLAGS(sh->io_port));
252 shost_printk(KERN_DEBUG, sh, "aha1542_intr_handle: ");
253 if (!(flag & ANYINTR))
254 printk("no interrupt?");
263 printk("status %02x\n", inb(STATUS(sh->io_port)));
268 spin_lock_irqsave(sh->host_lock, flags);
270 flag = inb(INTRFLAGS(sh->io_port));
272 /* Check for unusual interrupts. If any of these happen, we should
273 probably do something special, but for now just printing a message
274 is sufficient. A SCSI reset detected is something that we really
275 need to deal with in some way. */
284 aha1542_intr_reset(sh->io_port);
286 mbi = aha1542->aha1542_last_mbi_used + 1;
287 if (mbi >= 2 * AHA1542_MAILBOXES)
288 mbi = AHA1542_MAILBOXES;
291 if (mb[mbi].status != 0)
294 if (mbi >= 2 * AHA1542_MAILBOXES)
295 mbi = AHA1542_MAILBOXES;
296 } while (mbi != aha1542->aha1542_last_mbi_used);
298 if (mb[mbi].status == 0) {
299 spin_unlock_irqrestore(sh->host_lock, flags);
300 /* Hmm, no mail. Must have read it the last time around */
301 if (!number_serviced)
302 shost_printk(KERN_WARNING, sh, "interrupt received, but no mail.\n");
306 mbo = (scsi2int(mb[mbi].ccbptr) - (isa_virt_to_bus(&ccb[0]))) / sizeof(struct ccb);
307 mbistatus = mb[mbi].status;
309 aha1542->aha1542_last_mbi_used = mbi;
312 if (ccb[mbo].tarstat | ccb[mbo].hastat)
313 shost_printk(KERN_DEBUG, sh, "aha1542_command: returning %x (status %d)\n",
314 ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status);
318 continue; /* Aborted command not found */
321 shost_printk(KERN_DEBUG, sh, "...done %d %d\n", mbo, mbi);
324 tmp_cmd = aha1542->int_cmds[mbo];
326 if (!tmp_cmd || !tmp_cmd->scsi_done) {
327 spin_unlock_irqrestore(sh->host_lock, flags);
328 shost_printk(KERN_WARNING, sh, "Unexpected interrupt\n");
329 shost_printk(KERN_WARNING, sh, "tarstat=%x, hastat=%x idlun=%x ccb#=%d\n", ccb[mbo].tarstat,
330 ccb[mbo].hastat, ccb[mbo].idlun, mbo);
333 my_done = tmp_cmd->scsi_done;
334 kfree(tmp_cmd->host_scribble);
335 tmp_cmd->host_scribble = NULL;
336 /* Fetch the sense data, and tuck it away, in the required slot. The
337 Adaptec automatically fetches it, and there is no guarantee that
338 we will still have it in the cdb when we come back */
339 if (ccb[mbo].tarstat == 2)
340 memcpy(tmp_cmd->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen],
341 SCSI_SENSE_BUFFERSIZE);
344 /* is there mail :-) */
346 /* more error checking left out here */
348 /* This is surely wrong, but I don't know what's right */
349 errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat);
355 shost_printk(KERN_DEBUG, sh, "(aha1542 error:%x %x %x) ", errstatus,
356 ccb[mbo].hastat, ccb[mbo].tarstat);
357 if (ccb[mbo].tarstat == 2)
358 print_hex_dump_bytes("sense: ", DUMP_PREFIX_NONE, &ccb[mbo].cdb[ccb[mbo].cdblen], 12);
360 printk("aha1542_intr_handle: returning %6x\n", errstatus);
362 tmp_cmd->result = errstatus;
363 aha1542->int_cmds[mbo] = NULL; /* This effectively frees up the mailbox slot, as
364 far as queuecommand is concerned */
370 static int aha1542_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
372 struct aha1542_hostdata *aha1542 = shost_priv(sh);
374 u8 target = cmd->device->id;
375 u8 lun = cmd->device->lun;
377 int bufflen = scsi_bufflen(cmd);
379 struct mailbox *mb = aha1542->mb;
380 struct ccb *ccb = aha1542->ccb;
382 if (*cmd->cmnd == REQUEST_SENSE) {
383 /* Don't do the command - we have the sense data already */
391 if (*cmd->cmnd == READ_10 || *cmd->cmnd == WRITE_10)
392 i = xscsi2int(cmd->cmnd + 2);
393 else if (*cmd->cmnd == READ_6 || *cmd->cmnd == WRITE_6)
394 i = scsi2int(cmd->cmnd + 2);
395 shost_printk(KERN_DEBUG, sh, "aha1542_queuecommand: dev %d cmd %02x pos %d len %d",
396 target, *cmd->cmnd, i, bufflen);
397 print_hex_dump_bytes("command: ", DUMP_PREFIX_NONE, cmd->cmnd, cmd->cmd_len);
400 /* Use the outgoing mailboxes in a round-robin fashion, because this
401 is how the host adapter will scan for them */
403 spin_lock_irqsave(sh->host_lock, flags);
404 mbo = aha1542->aha1542_last_mbo_used + 1;
405 if (mbo >= AHA1542_MAILBOXES)
409 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL)
412 if (mbo >= AHA1542_MAILBOXES)
414 } while (mbo != aha1542->aha1542_last_mbo_used);
416 if (mb[mbo].status || aha1542->int_cmds[mbo])
417 panic("Unable to find empty mailbox for aha1542.\n");
419 aha1542->int_cmds[mbo] = cmd; /* This will effectively prevent someone else from
420 screwing with this cdb. */
422 aha1542->aha1542_last_mbo_used = mbo;
425 shost_printk(KERN_DEBUG, sh, "Sending command (%d %p)...", mbo, cmd->scsi_done);
428 any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo])); /* This gets trashed for some reason */
430 memset(&ccb[mbo], 0, sizeof(struct ccb));
432 ccb[mbo].cdblen = cmd->cmd_len;
435 if (*cmd->cmnd == READ_10 || *cmd->cmnd == READ_6)
437 else if (*cmd->cmnd == WRITE_10 || *cmd->cmnd == WRITE_6)
440 memcpy(ccb[mbo].cdb, cmd->cmnd, ccb[mbo].cdblen);
443 struct scatterlist *sg;
445 int i, sg_count = scsi_sg_count(cmd);
447 ccb[mbo].op = 2; /* SCSI Initiator Command w/scatter-gather */
448 cmd->host_scribble = kmalloc(sizeof(*cptr)*sg_count,
449 GFP_KERNEL | GFP_DMA);
450 cptr = (struct chain *) cmd->host_scribble;
452 /* free the claimed mailbox slot */
453 aha1542->int_cmds[mbo] = NULL;
454 spin_unlock_irqrestore(sh->host_lock, flags);
455 return SCSI_MLQUEUE_HOST_BUSY;
457 scsi_for_each_sg(cmd, sg, sg_count, i) {
458 any2scsi(cptr[i].dataptr, isa_page_to_bus(sg_page(sg))
460 any2scsi(cptr[i].datalen, sg->length);
462 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain));
463 any2scsi(ccb[mbo].dataptr, isa_virt_to_bus(cptr));
465 shost_printk(KERN_DEBUG, sh, "cptr %p: ", cptr);
466 print_hex_dump_bytes("cptr: ", DUMP_PREFIX_NONE, cptr, 18);
469 ccb[mbo].op = 0; /* SCSI Initiator Command */
470 cmd->host_scribble = NULL;
471 any2scsi(ccb[mbo].datalen, 0);
472 any2scsi(ccb[mbo].dataptr, 0);
474 ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7); /*SCSI Target Id */
475 ccb[mbo].rsalen = 16;
476 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
477 ccb[mbo].commlinkid = 0;
480 print_hex_dump_bytes("sending: ", DUMP_PREFIX_NONE, &ccb[mbo], sizeof(ccb[mbo]) - 10);
481 printk("aha1542_queuecommand: now waiting for interrupt ");
484 aha1542_outb(cmd->device->host->io_port, CMD_START_SCSI);
485 spin_unlock_irqrestore(sh->host_lock, flags);
490 /* Initialize mailboxes */
491 static void setup_mailboxes(struct Scsi_Host *sh)
493 struct aha1542_hostdata *aha1542 = shost_priv(sh);
495 struct mailbox *mb = aha1542->mb;
496 struct ccb *ccb = aha1542->ccb;
498 u8 mb_cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
500 for (i = 0; i < AHA1542_MAILBOXES; i++) {
501 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0;
502 any2scsi(mb[i].ccbptr, isa_virt_to_bus(&ccb[i]));
504 aha1542_intr_reset(sh->io_port); /* reset interrupts, so they don't block */
505 any2scsi((mb_cmd + 2), isa_virt_to_bus(mb));
506 if (aha1542_out(sh->io_port, mb_cmd, 5))
507 shost_printk(KERN_ERR, sh, "failed setting up mailboxes\n");
508 aha1542_intr_reset(sh->io_port);
511 static int aha1542_getconfig(struct Scsi_Host *sh)
513 u8 inquiry_result[3];
515 i = inb(STATUS(sh->io_port));
517 i = inb(DATA(sh->io_port));
519 aha1542_outb(sh->io_port, CMD_RETCONF);
520 aha1542_in(sh->io_port, inquiry_result, 3, 0);
521 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0))
522 shost_printk(KERN_ERR, sh, "error querying board settings\n");
523 aha1542_intr_reset(sh->io_port);
524 switch (inquiry_result[0]) {
538 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel.
539 Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */
540 sh->dma_channel = 0xFF;
543 shost_printk(KERN_ERR, sh, "Unable to determine DMA channel.\n");
546 switch (inquiry_result[1]) {
566 shost_printk(KERN_ERR, sh, "Unable to determine IRQ level.\n");
569 sh->this_id = inquiry_result[2] & 7;
573 /* This function should only be called for 1542C boards - we can detect
574 the special firmware settings and unlock the board */
576 static int aha1542_mbenable(struct Scsi_Host *sh)
578 static u8 mbenable_cmd[3];
579 static u8 mbenable_result[2];
582 retval = BIOS_TRANSLATION_6432;
584 aha1542_outb(sh->io_port, CMD_EXTBIOS);
585 if (aha1542_in(sh->io_port, mbenable_result, 2, 100))
587 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 100))
589 aha1542_intr_reset(sh->io_port);
591 if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
592 mbenable_cmd[0] = CMD_MBENABLE;
594 mbenable_cmd[2] = mbenable_result[1];
596 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03))
597 retval = BIOS_TRANSLATION_25563;
599 if (aha1542_out(sh->io_port, mbenable_cmd, 3))
604 shost_printk(KERN_ERR, sh, "Mailbox init failed\n");
606 aha1542_intr_reset(sh->io_port);
610 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */
611 static int aha1542_query(struct Scsi_Host *sh)
613 struct aha1542_hostdata *aha1542 = shost_priv(sh);
614 u8 inquiry_result[4];
616 i = inb(STATUS(sh->io_port));
618 i = inb(DATA(sh->io_port));
620 aha1542_outb(sh->io_port, CMD_INQUIRY);
621 aha1542_in(sh->io_port, inquiry_result, 4, 0);
622 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0))
623 shost_printk(KERN_ERR, sh, "error querying card type\n");
624 aha1542_intr_reset(sh->io_port);
626 aha1542->bios_translation = BIOS_TRANSLATION_6432; /* Default case */
628 /* For an AHA1740 series board, we ignore the board since there is a
629 hardware bug which can lead to wrong blocks being returned if the board
630 is operating in the 1542 emulation mode. Since there is an extended mode
631 driver, we simply ignore the board and let the 1740 driver pick it up.
634 if (inquiry_result[0] == 0x43) {
635 shost_printk(KERN_INFO, sh, "Emulation mode not supported for AHA-1740 hardware, use aha1740 driver instead.\n");
639 /* Always call this - boards that do not support extended bios translation
640 will ignore the command, and we will set the proper default */
642 aha1542->bios_translation = aha1542_mbenable(sh);
647 static u8 dma_speed_hw(int dma_speed)
662 return 0xff; /* invalid */
665 /* Set the Bus on/off-times as not to ruin floppy performance */
666 static void aha1542_set_bus_times(struct Scsi_Host *sh, int bus_on, int bus_off, int dma_speed)
669 u8 oncmd[] = { CMD_BUSON_TIME, clamp(bus_on, 2, 15) };
671 aha1542_intr_reset(sh->io_port);
672 if (aha1542_out(sh->io_port, oncmd, 2))
677 u8 offcmd[] = { CMD_BUSOFF_TIME, clamp(bus_off, 1, 64) };
679 aha1542_intr_reset(sh->io_port);
680 if (aha1542_out(sh->io_port, offcmd, 2))
684 if (dma_speed_hw(dma_speed) != 0xff) {
685 u8 dmacmd[] = { CMD_DMASPEED, dma_speed_hw(dma_speed) };
687 aha1542_intr_reset(sh->io_port);
688 if (aha1542_out(sh->io_port, dmacmd, 2))
691 aha1542_intr_reset(sh->io_port);
694 shost_printk(KERN_ERR, sh, "setting bus on/off-time failed\n");
695 aha1542_intr_reset(sh->io_port);
698 /* return non-zero on detection */
699 static struct Scsi_Host *aha1542_hw_init(struct scsi_host_template *tpnt, struct device *pdev, int indx)
701 unsigned int base_io = io[indx];
702 struct Scsi_Host *sh;
703 struct aha1542_hostdata *aha1542;
704 char dma_info[] = "no DMA";
709 if (!request_region(base_io, AHA1542_REGION_SIZE, "aha1542"))
712 sh = scsi_host_alloc(tpnt, sizeof(struct aha1542_hostdata));
715 aha1542 = shost_priv(sh);
717 sh->unique_id = base_io;
718 sh->io_port = base_io;
719 sh->n_io_port = AHA1542_REGION_SIZE;
720 aha1542->aha1542_last_mbi_used = 2 * AHA1542_MAILBOXES - 1;
721 aha1542->aha1542_last_mbo_used = AHA1542_MAILBOXES - 1;
723 if (!aha1542_test_port(sh))
726 aha1542_set_bus_times(sh, bus_on[indx], bus_off[indx], dma_speed[indx]);
727 if (aha1542_query(sh))
729 if (aha1542_getconfig(sh) == -1)
732 if (sh->dma_channel != 0xFF)
733 snprintf(dma_info, sizeof(dma_info), "DMA %d", sh->dma_channel);
734 shost_printk(KERN_INFO, sh, "Adaptec AHA-1542 (SCSI-ID %d) at IO 0x%x, IRQ %d, %s\n",
735 sh->this_id, base_io, sh->irq, dma_info);
736 if (aha1542->bios_translation == BIOS_TRANSLATION_25563)
737 shost_printk(KERN_INFO, sh, "Using extended bios translation\n");
741 if (request_irq(sh->irq, aha1542_interrupt, 0, "aha1542", sh)) {
742 shost_printk(KERN_ERR, sh, "Unable to allocate IRQ.\n");
745 if (sh->dma_channel != 0xFF) {
746 if (request_dma(sh->dma_channel, "aha1542")) {
747 shost_printk(KERN_ERR, sh, "Unable to allocate DMA channel.\n");
750 if (sh->dma_channel == 0 || sh->dma_channel >= 5) {
751 set_dma_mode(sh->dma_channel, DMA_MODE_CASCADE);
752 enable_dma(sh->dma_channel);
756 if (scsi_add_host(sh, pdev))
763 if (sh->dma_channel != 0xff)
764 free_dma(sh->dma_channel);
766 free_irq(sh->irq, sh);
770 release_region(base_io, AHA1542_REGION_SIZE);
775 static int aha1542_release(struct Scsi_Host *sh)
777 scsi_remove_host(sh);
778 if (sh->dma_channel != 0xff)
779 free_dma(sh->dma_channel);
781 free_irq(sh->irq, sh);
782 if (sh->io_port && sh->n_io_port)
783 release_region(sh->io_port, sh->n_io_port);
790 * This is a device reset. This is handled by sending a special command
793 static int aha1542_dev_reset(struct scsi_cmnd *cmd)
795 struct Scsi_Host *sh = cmd->device->host;
796 struct aha1542_hostdata *aha1542 = shost_priv(sh);
798 struct mailbox *mb = aha1542->mb;
799 u8 target = cmd->device->id;
800 u8 lun = cmd->device->lun;
802 struct ccb *ccb = aha1542->ccb;
804 spin_lock_irqsave(sh->host_lock, flags);
805 mbo = aha1542->aha1542_last_mbo_used + 1;
806 if (mbo >= AHA1542_MAILBOXES)
810 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL)
813 if (mbo >= AHA1542_MAILBOXES)
815 } while (mbo != aha1542->aha1542_last_mbo_used);
817 if (mb[mbo].status || aha1542->int_cmds[mbo])
818 panic("Unable to find empty mailbox for aha1542.\n");
820 aha1542->int_cmds[mbo] = cmd; /* This will effectively
821 prevent someone else from
822 screwing with this cdb. */
824 aha1542->aha1542_last_mbo_used = mbo;
826 any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo])); /* This gets trashed for some reason */
828 memset(&ccb[mbo], 0, sizeof(struct ccb));
830 ccb[mbo].op = 0x81; /* BUS DEVICE RESET */
832 ccb[mbo].idlun = (target & 7) << 5 | (lun & 7); /*SCSI Target Id */
834 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
835 ccb[mbo].commlinkid = 0;
838 * Now tell the 1542 to flush all pending commands for this
841 aha1542_outb(sh->io_port, CMD_START_SCSI);
842 spin_unlock_irqrestore(sh->host_lock, flags);
844 scmd_printk(KERN_WARNING, cmd,
845 "Trying device reset for target\n");
850 static int aha1542_reset(struct scsi_cmnd *cmd, u8 reset_cmd)
852 struct Scsi_Host *sh = cmd->device->host;
853 struct aha1542_hostdata *aha1542 = shost_priv(sh);
857 spin_lock_irqsave(sh->host_lock, flags);
859 * This does a scsi reset for all devices on the bus.
860 * In principle, we could also reset the 1542 - should
861 * we do this? Try this first, and we can add that later
862 * if it turns out to be useful.
864 outb(reset_cmd, CONTROL(cmd->device->host->io_port));
866 if (!wait_mask(STATUS(cmd->device->host->io_port),
867 STATMASK, IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0)) {
868 spin_unlock_irqrestore(sh->host_lock, flags);
873 * We need to do this too before the 1542 can interact with
874 * us again after host reset.
876 if (reset_cmd & HRST)
877 setup_mailboxes(cmd->device->host);
880 * Now try to pick up the pieces. For all pending commands,
881 * free any internal data structures, and basically clear things
882 * out. We do not try and restart any commands or anything -
883 * the strategy handler takes care of that crap.
885 shost_printk(KERN_WARNING, cmd->device->host, "Sent BUS RESET to scsi host %d\n", cmd->device->host->host_no);
887 for (i = 0; i < AHA1542_MAILBOXES; i++) {
888 if (aha1542->int_cmds[i] != NULL) {
889 struct scsi_cmnd *tmp_cmd;
890 tmp_cmd = aha1542->int_cmds[i];
892 if (tmp_cmd->device->soft_reset) {
894 * If this device implements the soft reset option,
895 * then it is still holding onto the command, and
896 * may yet complete it. In this case, we don't
901 kfree(tmp_cmd->host_scribble);
902 tmp_cmd->host_scribble = NULL;
903 aha1542->int_cmds[i] = NULL;
904 aha1542->mb[i].status = 0;
908 spin_unlock_irqrestore(sh->host_lock, flags);
912 static int aha1542_bus_reset(struct scsi_cmnd *cmd)
914 return aha1542_reset(cmd, SCRST);
917 static int aha1542_host_reset(struct scsi_cmnd *cmd)
919 return aha1542_reset(cmd, HRST | SCRST);
922 static int aha1542_biosparam(struct scsi_device *sdev,
923 struct block_device *bdev, sector_t capacity, int geom[])
925 struct aha1542_hostdata *aha1542 = shost_priv(sdev->host);
927 if (capacity >= 0x200000 &&
928 aha1542->bios_translation == BIOS_TRANSLATION_25563) {
929 /* Please verify that this is the same as what DOS returns */
930 geom[0] = 255; /* heads */
931 geom[1] = 63; /* sectors */
933 geom[0] = 64; /* heads */
934 geom[1] = 32; /* sectors */
936 geom[2] = sector_div(capacity, geom[0] * geom[1]); /* cylinders */
940 MODULE_LICENSE("GPL");
942 static struct scsi_host_template driver_template = {
943 .module = THIS_MODULE,
944 .proc_name = "aha1542",
945 .name = "Adaptec 1542",
946 .queuecommand = aha1542_queuecommand,
947 .eh_device_reset_handler= aha1542_dev_reset,
948 .eh_bus_reset_handler = aha1542_bus_reset,
949 .eh_host_reset_handler = aha1542_host_reset,
950 .bios_param = aha1542_biosparam,
951 .can_queue = AHA1542_MAILBOXES,
955 .unchecked_isa_dma = 1,
956 .use_clustering = ENABLE_CLUSTERING,
959 static int aha1542_isa_match(struct device *pdev, unsigned int ndev)
961 struct Scsi_Host *sh = aha1542_hw_init(&driver_template, pdev, ndev);
966 dev_set_drvdata(pdev, sh);
970 static int aha1542_isa_remove(struct device *pdev,
973 aha1542_release(dev_get_drvdata(pdev));
974 dev_set_drvdata(pdev, NULL);
978 static struct isa_driver aha1542_isa_driver = {
979 .match = aha1542_isa_match,
980 .remove = aha1542_isa_remove,
985 static int isa_registered;
988 static struct pnp_device_id aha1542_pnp_ids[] = {
992 MODULE_DEVICE_TABLE(pnp, aha1542_pnp_ids);
994 static int aha1542_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id)
997 struct Scsi_Host *sh;
999 for (indx = 0; indx < ARRAY_SIZE(io); indx++) {
1003 if (pnp_activate_dev(pdev) < 0)
1006 io[indx] = pnp_port_start(pdev, 0);
1008 /* The card can be queried for its DMA, we have
1009 the DMA set up that is enough */
1011 dev_info(&pdev->dev, "ISAPnP found an AHA1535 at I/O 0x%03X", io[indx]);
1014 sh = aha1542_hw_init(&driver_template, &pdev->dev, indx);
1018 pnp_set_drvdata(pdev, sh);
1022 static void aha1542_pnp_remove(struct pnp_dev *pdev)
1024 aha1542_release(pnp_get_drvdata(pdev));
1025 pnp_set_drvdata(pdev, NULL);
1028 static struct pnp_driver aha1542_pnp_driver = {
1030 .id_table = aha1542_pnp_ids,
1031 .probe = aha1542_pnp_probe,
1032 .remove = aha1542_pnp_remove,
1034 static int pnp_registered;
1035 #endif /* CONFIG_PNP */
1037 static int __init aha1542_init(void)
1043 ret = pnp_register_driver(&aha1542_pnp_driver);
1048 ret = isa_register_driver(&aha1542_isa_driver, MAXBOARDS);
1062 static void __exit aha1542_exit(void)
1066 pnp_unregister_driver(&aha1542_pnp_driver);
1069 isa_unregister_driver(&aha1542_isa_driver);
1072 module_init(aha1542_init);
1073 module_exit(aha1542_exit);