From 30136d82b241e577fcc76b58a798c130227b9862 Mon Sep 17 00:00:00 2001 From: "Justin T. Gibbs" Date: Mon, 11 Nov 1996 05:24:46 +0000 Subject: [PATCH] Clean up the memory mapped/Programmed I/O stuff so that the driver completely uses one or the other. This required some changes to the ahc_reset() function, and how early the probes had to allocate their softc. Turn the AHC_IN/OUT* macros into inline functions and lowercase their names to indicate this change. Geting AHC_OUTSB to work as a macro doing conditional memory mapped I/O would have been too gross. Stop setting STPWEN in the main driver and let the PCI front end do it instead. It knows better. Add the clearing of the QOUTQCNT variable during command complete processing in the SCB paging case. Go back to doing unconditional retries for the QUEUE FULL status condition. This is really a kludge, but the code to handle it properly is on the SCSI branch and will not make it into 2.2. --- sys/i386/scsi/aic7xxx.c | 555 ++++++++++++++++++++-------------------- sys/i386/scsi/aic7xxx.h | 84 ++++-- 2 files changed, 337 insertions(+), 302 deletions(-) diff --git a/sys/i386/scsi/aic7xxx.c b/sys/i386/scsi/aic7xxx.c index 1605f2fe3ad..7aa272a3c83 100644 --- a/sys/i386/scsi/aic7xxx.c +++ b/sys/i386/scsi/aic7xxx.c @@ -32,7 +32,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: aic7xxx.c,v 1.83 1996/11/05 08:39:33 gibbs Exp $ + * $Id: aic7xxx.c,v 1.84 1996/11/07 06:39:44 gibbs Exp $ */ /* * TODO: @@ -203,13 +203,13 @@ static inline void pause_sequencer(ahc) struct ahc_softc *ahc; { - AHC_OUTB(ahc, HCNTRL, ahc->pause); + ahc_outb(ahc, HCNTRL, ahc->pause); /* * Since the sequencer can disable pausing in a critical section, we * must loop until it actually stops. */ - while ((AHC_INB(ahc, HCNTRL) & PAUSE) == 0) + while ((ahc_inb(ahc, HCNTRL) & PAUSE) == 0) ; } @@ -219,8 +219,8 @@ unpause_sequencer(ahc, unpause_always) int unpause_always; { if (unpause_always - || (AHC_INB(ahc, INTSTAT) & (SCSIINT | SEQINT | BRKADRINT)) == 0) - AHC_OUTB(ahc, HCNTRL, ahc->unpause); + || (ahc_inb(ahc, INTSTAT) & (SCSIINT | SEQINT | BRKADRINT)) == 0) + ahc_outb(ahc, HCNTRL, ahc->unpause); } /* @@ -231,9 +231,9 @@ restart_sequencer(ahc) struct ahc_softc *ahc; { do { - AHC_OUTB(ahc, SEQCTL, SEQRESET|FASTMODE); - } while ((AHC_INB(ahc, SEQADDR0) != 0) - || (AHC_INB(ahc, SEQADDR1) != 0)); + ahc_outb(ahc, SEQCTL, SEQRESET|FASTMODE); + } while ((ahc_inb(ahc, SEQADDR0) != 0) + || (ahc_inb(ahc, SEQADDR1) != 0)); unpause_sequencer(ahc, /*unpause_always*/TRUE); } @@ -313,20 +313,22 @@ static void ahc_print_scb(scb) struct scb *scb; { + struct hardware_scb *hscb = scb->hscb; + printf("scb:%p control:0x%x tcl:0x%x cmdlen:%d cmdpointer:0x%lx\n", scb, - scb->control, - scb->tcl, - scb->cmdlen, - scb->cmdpointer ); + hscb->control, + hscb->tcl, + hscb->cmdlen, + hscb->cmdpointer ); printf(" datlen:%d data:0x%lx segs:0x%x segp:0x%lx\n", - scb->datalen, - scb->data, - scb->SG_segment_count, - scb->SG_list_pointer); + hscb->datalen, + hscb->data, + hscb->SG_segment_count, + hscb->SG_list_pointer); printf(" sg_addr:%lx sg_len:%ld\n", - scb->ahc_dma[0].addr, - scb->ahc_dma[0].len); + hscb->ahc_dma[0].addr, + hscb->ahc_dma[0].len); } #endif @@ -372,8 +374,6 @@ static int ahc_num_syncrates = /* * Allocate a controller structures for a new device and initialize it. - * ahc_reset should be called before now since we assume that the card - * is paused. */ #if defined(__FreeBSD__) struct ahc_softc * @@ -436,7 +436,7 @@ ahc_construct(ahc, bc, ioh, maddr, type, flags) ahc->maddr = (volatile u_int8_t *)maddr; ahc->type = type; ahc->flags = flags; - ahc->unpause = (AHC_INB(ahc, HCNTRL) & IRQMS) | INTEN; + ahc->unpause = (ahc_inb(ahc, HCNTRL) & IRQMS) | INTEN; ahc->pause = ahc->unpause | PAUSE; #if defined(__FreeBSD__) @@ -455,53 +455,27 @@ ahc_free(ahc) } void -#if defined(__FreeBSD__) -ahc_reset(iobase) - u_int32_t iobase; -#elif defined(__NetBSD__) -ahc_reset(devname, bc, ioh) - char *devname; - bus_chipset_tag_t bc; - bus_io_handle_t ioh; -#endif +ahc_reset(ahc) + struct ahc_softc *ahc; { u_int8_t hcntrl; int wait; /* Retain the IRQ type accross the chip reset */ -#if defined(__FreeBSD__) - hcntrl = (inb(HCNTRL + iobase) & IRQMS) | INTEN; + hcntrl = (ahc_inb(ahc, HCNTRL) & IRQMS) | INTEN; - outb(HCNTRL + iobase, CHIPRST | PAUSE); -#elif defined(__NetBSD__) - hcntrl = (bus_io_read_1(bc, ioh, HCNTRL) & IRQMS) | INTEN; - - bus_io_write_1(bc, ioh, HCNTRL, CHIPRST | PAUSE); -#endif + ahc_outb(ahc, HCNTRL, CHIPRST | PAUSE); /* * Ensure that the reset has finished */ wait = 1000; -#if defined(__FreeBSD__) - while (--wait && !(inb(HCNTRL + iobase) & CHIPRSTACK)) -#elif defined(__NetBSD__) - while (--wait && !(bus_io_read_1(bc, ioh, HCNTRL) & CHIPRSTACK)) -#endif + while (--wait && !(ahc_inb(ahc, HCNTRL) & CHIPRSTACK)) DELAY(1000); if (wait == 0) { -#if defined(__FreeBSD__) - printf("ahc at 0x%lx: WARNING - Failed chip reset! " - "Trying to initialize anyway.\n", iobase); -#elif defined(__NetBSD__) printf("%s: WARNING - Failed chip reset! " - "Trying to initialize anyway.\n", devname); -#endif + "Trying to initialize anyway.\n", ahc_name(ahc)); } -#if defined(__FreeBSD__) - outb(HCNTRL + iobase, hcntrl | PAUSE); -#elif defined(__NetBSD__) - bus_io_write_1(bc, ioh, HCNTRL, hcntrl | PAUSE); -#endif + ahc_outb(ahc, HCNTRL, hcntrl | PAUSE); } /* @@ -572,8 +546,8 @@ ahc_scsirate(ahc, scsirate, period, offset, channel, target ) ultra_enb_addr = ULTRA_ENB; if (channel == 'B' || target > 7) ultra_enb_addr++; - ultra_enb = AHC_INB(ahc, ultra_enb_addr); - sxfrctl0 = AHC_INB(ahc, SXFRCTL0); + ultra_enb = ahc_inb(ahc, ultra_enb_addr); + sxfrctl0 = ahc_inb(ahc, SXFRCTL0); if (*scsirate != 0 && ahc_syncrates[i].sxfr & ULTRA_SXFR) { ultra_enb |= 0x01 << (target & 0x07); sxfrctl0 |= ULTRAEN; @@ -581,8 +555,8 @@ ahc_scsirate(ahc, scsirate, period, offset, channel, target ) ultra_enb &= ~(0x01 << (target & 0x07)); sxfrctl0 &= ~ULTRAEN; } - AHC_OUTB(ahc, ultra_enb_addr, ultra_enb); - AHC_OUTB(ahc, SXFRCTL0, sxfrctl0); + ahc_outb(ahc, ultra_enb_addr, ultra_enb); + ahc_outb(ahc, SXFRCTL0, sxfrctl0); } #if defined(__NetBSD__) @@ -730,7 +704,7 @@ ahc_intr(arg) u_int8_t intstat; ahc = (struct ahc_softc *)arg; - intstat = AHC_INB(ahc, INTSTAT); + intstat = ahc_inb(ahc, INTSTAT); /* * Is this interrupt for me? or for * someone who is sharing my interrupt @@ -749,14 +723,14 @@ ahc_intr(arg) */ int i, error, num_errors; - error = AHC_INB(ahc, ERROR); + error = ahc_inb(ahc, ERROR); num_errors = sizeof(hard_error)/sizeof(hard_error[0]); for (i = 0; error != 1 && i < num_errors; i++) error >>= 1; panic("%s: brkadrint, %s at seqaddr = 0x%x\n", ahc_name(ahc), hard_error[i].errmesg, - (AHC_INB(ahc, SEQADDR1) << 8) | - AHC_INB(ahc, SEQADDR0)); + (ahc_inb(ahc, SEQADDR1) << 8) | + ahc_inb(ahc, SEQADDR0)); } if (intstat & SEQINT) ahc_handle_seqint(ahc, intstat); @@ -771,10 +745,9 @@ ahc_intr(arg) int int_cleared; int_cleared = 0; - while (qoutcnt = (AHC_INB(ahc, QOUTCNT) & ahc->qcntmask)) { - + while (qoutcnt = (ahc_inb(ahc, QOUTCNT) & ahc->qcntmask)) { for (; qoutcnt > 0; qoutcnt--) { - scb_index = AHC_INB(ahc, QOUTFIFO); + scb_index = ahc_inb(ahc, QOUTFIFO); scb = ahc->scb_data->scbarray[scb_index]; if (!scb || !(scb->flags & SCB_ACTIVE)) { printf("%s: WARNING " @@ -790,14 +763,26 @@ ahc_intr(arg) */ if (scb->hscb->residual_SG_segment_count != 0) ahc_calc_residual(scb); - ahc_done(ahc, scb); + if (scb->hscb->status != SCSI_QUEUE_FULL) + ahc_done(ahc, scb); } - AHC_OUTB(ahc, CLRINT, CLRCMDINT); + ahc_outb(ahc, CLRINT, CLRCMDINT); int_cleared++; } + if ((ahc->flags & AHC_PAGESCBS) != 0) { + if ((ahc->type & AHC_AIC78X0) == 0) + pause_sequencer(ahc); + + /* We've emptied the Queue */ + ahc_outb(ahc, QOUTQCNT, 0); + + if ((ahc->type & AHC_AIC78X0) == 0) + unpause_sequencer(ahc, FALSE); + } + if (int_cleared == 0) - AHC_OUTB(ahc, CLRINT, CLRCMDINT); + ahc_outb(ahc, CLRINT, CLRCMDINT); } if (ahc->waiting_scbs.stqh_first != NULL) @@ -814,9 +799,9 @@ ahc_handle_seqint(ahc, intstat) { struct scb *scb; u_int16_t targ_mask; - u_int8_t target = (AHC_INB(ahc, SCSIID) >> 4) & 0x0f; + u_int8_t target = (ahc_inb(ahc, SCSIID) >> 4) & 0x0f; int scratch_offset = target; - char channel = AHC_INB(ahc, SBLKCTL) & SELBUSB ? 'B': 'A'; + char channel = ahc_inb(ahc, SBLKCTL) & SELBUSB ? 'B': 'A'; if (channel == 'B') scratch_offset += 8; @@ -835,7 +820,7 @@ ahc_handle_seqint(ahc, intstat) u_int8_t busy_scbid; busy_scbid = ahc_unbusy_target(ahc, target, channel); - scb_index = AHC_INB(ahc, ARG_1); + scb_index = ahc_inb(ahc, ARG_1); if (scb_index == SCB_LIST_NULL) /* Untagged Request */ @@ -854,7 +839,7 @@ ahc_handle_seqint(ahc, intstat) "target - issuing ABORT\n", ahc_name(ahc), channel, target); printf("SAVED_TCL == 0x%x\n", - AHC_INB(ahc, SAVED_TCL)); + ahc_inb(ahc, SAVED_TCL)); break; } case NO_MATCH_BUSY: @@ -864,7 +849,7 @@ ahc_handle_seqint(ahc, intstat) u_int8_t busy_scbindex; struct scb *busy_scb = NULL; - scb_index = AHC_INB(ahc, CUR_SCBID); + scb_index = ahc_inb(ahc, CUR_SCBID); scb = ahc->scb_data->scbarray[scb_index]; /* Find the busy SCB and unbusy this target */ @@ -887,7 +872,7 @@ ahc_handle_seqint(ahc, intstat) if ((scb->hscb->control & ABORT_SCB) == 0) { /* We didn't want to abort this one too */ - AHC_OUTB(ahc, QINFIFO, scb_index); + ahc_outb(ahc, QINFIFO, scb_index); } else /* It's been aborted */ ahc_done(ahc, scb); @@ -895,7 +880,7 @@ ahc_handle_seqint(ahc, intstat) } case SEND_REJECT: { - u_int8_t rejbyte = AHC_INB(ahc, REJBYTE); + u_int8_t rejbyte = ahc_inb(ahc, REJBYTE); printf("%s:%c:%d: Warning - unknown message recieved from " "target (0x%x). Rejecting\n", ahc_name(ahc), channel, target, rejbyte); @@ -905,7 +890,7 @@ ahc_handle_seqint(ahc, intstat) panic("%s:%c:%d: Target did not send an IDENTIFY message. " "SAVED_TCL == 0x%x\n", ahc_name(ahc), channel, target, - AHC_INB(ahc, SAVED_TCL)); + ahc_inb(ahc, SAVED_TCL)); break; case BAD_PHASE: printf("%s:%c:%d: unknown scsi bus phase. Attempting to " @@ -916,8 +901,8 @@ ahc_handle_seqint(ahc, intstat) u_int8_t message_length; u_int8_t message_code; - message_length = AHC_INB(ahc, MSGIN_EXT_LEN); - message_code = AHC_INB(ahc, MSGIN_EXT_OPCODE); + message_length = ahc_inb(ahc, MSGIN_EXT_LEN); + message_code = ahc_inb(ahc, MSGIN_EXT_OPCODE); switch (message_code) { case MSG_EXT_SDTR: { @@ -929,13 +914,13 @@ ahc_handle_seqint(ahc, intstat) u_int8_t rate; if (message_length != MSG_EXT_SDTR_LEN) { - AHC_OUTB(ahc, RETURN_1, SEND_REJ); + ahc_outb(ahc, RETURN_1, SEND_REJ); ahc->sdtrpending &= ~targ_mask; break; } - period = AHC_INB(ahc, MSGIN_EXT_BYTE0); - saved_offset = AHC_INB(ahc, MSGIN_EXT_BYTE1); - targ_scratch = AHC_INB(ahc, TARG_SCRATCH + period = ahc_inb(ahc, MSGIN_EXT_BYTE0); + saved_offset = ahc_inb(ahc, MSGIN_EXT_BYTE1); + targ_scratch = ahc_inb(ahc, TARG_SCRATCH + scratch_offset); if (targ_scratch & WIDEXFER) maxoffset = MAX_OFFSET_16BIT; @@ -951,9 +936,9 @@ ahc_handle_seqint(ahc, intstat) * Update both the target scratch area and the * current SCSIRATE. */ - AHC_OUTB(ahc, TARG_SCRATCH + scratch_offset, + ahc_outb(ahc, TARG_SCRATCH + scratch_offset, targ_scratch); - AHC_OUTB(ahc, SCSIRATE, targ_scratch); + ahc_outb(ahc, SCSIRATE, targ_scratch); /* * See if we initiated Sync Negotiation @@ -966,9 +951,10 @@ ahc_handle_seqint(ahc, intstat) * Don't send an SDTR back to * the target */ - AHC_OUTB(ahc, RETURN_1, 0); + ahc_outb(ahc, RETURN_1, 0); } else - AHC_OUTB(ahc, RETURN_1, SEND_REJ); + /* Went too low - force async */ + ahc_outb(ahc, RETURN_1, SEND_REJ); } else { /* * Send our own SDTR in reply @@ -976,7 +962,7 @@ ahc_handle_seqint(ahc, intstat) printf("Sending SDTR!!\n"); ahc_construct_sdtr(ahc, /*start_byte*/0, period, offset); - AHC_OUTB(ahc, RETURN_1, SEND_MSG); + ahc_outb(ahc, RETURN_1, SEND_MSG); } ahc->needsdtr &= ~targ_mask; ahc->sdtrpending &= ~targ_mask; @@ -987,21 +973,20 @@ ahc_handle_seqint(ahc, intstat) u_int8_t scratch, bus_width; if (message_length != MSG_EXT_WDTR_LEN) { - AHC_OUTB(ahc, RETURN_1, SEND_REJ); + ahc_outb(ahc, RETURN_1, SEND_REJ); ahc->wdtrpending &= ~targ_mask; break; } - bus_width = AHC_INB(ahc, MSGIN_EXT_BYTE0); - scratch = AHC_INB(ahc, TARG_SCRATCH - + scratch_offset); + bus_width = ahc_inb(ahc, MSGIN_EXT_BYTE0); + scratch = ahc_inb(ahc, TARG_SCRATCH + scratch_offset); if (ahc->wdtrpending & targ_mask) { /* * Don't send a WDTR back to the * target, since we asked first. */ - AHC_OUTB(ahc, RETURN_1, 0); + ahc_outb(ahc, RETURN_1, 0); switch (bus_width){ case BUS_8_BIT: scratch &= 0x7f; @@ -1018,7 +1003,7 @@ ahc_handle_seqint(ahc, intstat) * How can we do 32bit transfers * on a 16bit bus? */ - AHC_OUTB(ahc, RETURN_1, SEND_REJ); + ahc_outb(ahc, RETURN_1, SEND_REJ); printf("%s: target %d requested 32Bit " "transfers. Rejecting...\n", ahc_name(ahc), target); @@ -1054,18 +1039,18 @@ ahc_handle_seqint(ahc, intstat) } ahc_construct_wdtr(ahc, /*start_byte*/0, bus_width); - AHC_OUTB(ahc, RETURN_1, SEND_MSG); + ahc_outb(ahc, RETURN_1, SEND_MSG); } ahc->needwdtr &= ~targ_mask; ahc->wdtrpending &= ~targ_mask; - AHC_OUTB(ahc, TARG_SCRATCH + scratch_offset, scratch); - AHC_OUTB(ahc, SCSIRATE, scratch); + ahc_outb(ahc, TARG_SCRATCH + scratch_offset, scratch); + ahc_outb(ahc, SCSIRATE, scratch); break; } default: /* Unknown extended message. Reject it. */ - AHC_OUTB(ahc, RETURN_1, SEND_REJ); + ahc_outb(ahc, RETURN_1, SEND_REJ); } break; } @@ -1080,7 +1065,7 @@ ahc_handle_seqint(ahc, intstat) u_int8_t targ_scratch; - targ_scratch = AHC_INB(ahc, TARG_SCRATCH + targ_scratch = ahc_inb(ahc, TARG_SCRATCH + scratch_offset); if (ahc->wdtrpending & targ_mask) { @@ -1111,8 +1096,8 @@ ahc_handle_seqint(ahc, intstat) #endif break; } - AHC_OUTB(ahc, TARG_SCRATCH + scratch_offset, targ_scratch); - AHC_OUTB(ahc, SCSIRATE, targ_scratch); + ahc_outb(ahc, TARG_SCRATCH + scratch_offset, targ_scratch); + ahc_outb(ahc, SCSIRATE, targ_scratch); break; } case BAD_STATUS: @@ -1131,7 +1116,7 @@ ahc_handle_seqint(ahc, intstat) * the in kernel copy directly. */ - scb_index = AHC_INB(ahc, SCB_TAG); + scb_index = ahc_inb(ahc, SCB_TAG); scb = ahc->scb_data->scbarray[scb_index]; hscb = scb->hscb; @@ -1141,7 +1126,7 @@ ahc_handle_seqint(ahc, intstat) * this if needed and this reduces code * duplication. */ - AHC_OUTB(ahc, RETURN_1, 0); + ahc_outb(ahc, RETURN_1, 0); if (!(scb && (scb->flags & SCB_ACTIVE))) { printf("%s:%c:%d: ahc_intr - referenced scb " "not valid during seqint 0x%x scb(%d)\n", @@ -1207,7 +1192,7 @@ ahc_handle_seqint(ahc, intstat) hscb->cmdlen = sizeof(*sc); scb->flags |= SCB_SENSE; - AHC_OUTB(ahc, RETURN_1, SEND_SENSE); + ahc_outb(ahc, RETURN_1, SEND_SENSE); break; } /* @@ -1232,7 +1217,10 @@ ahc_handle_seqint(ahc, intstat) * handle this properly. */ printf("Queue Full\n"); - xs->error = XS_BUSY; + /* + * XXX requeue this unconditionally. + */ + STAILQ_INSERT_HEAD(&ahc->waiting_scbs, scb, links); break; default: sc_print_addr(xs->sc_link); @@ -1247,7 +1235,7 @@ ahc_handle_seqint(ahc, intstat) u_int8_t scb_index; struct scsi_xfer *xs; - scb_index = AHC_INB(ahc, SCB_TAG); + scb_index = ahc_inb(ahc, SCB_TAG); scb = ahc->scb_data->scbarray[scb_index]; xs = scb->xs; /* @@ -1265,7 +1253,7 @@ ahc_handle_seqint(ahc, intstat) { int scb_index; - scb_index = AHC_INB(ahc, SCB_TAG); + scb_index = ahc_inb(ahc, SCB_TAG); scb = ahc->scb_data->scbarray[scb_index]; /* * This SCB had MK_MESSAGE set in its control byte, @@ -1273,12 +1261,12 @@ ahc_handle_seqint(ahc, intstat) * special message to this target. */ if (scb->flags & SCB_DEVICE_RESET) { - AHC_OUTB(ahc, MSG0, + ahc_outb(ahc, MSG0, MSG_BUS_DEV_RESET); - AHC_OUTB(ahc, MSG_LEN, 1); + ahc_outb(ahc, MSG_LEN, 1); printf("Bus Device Reset Message Sent\n"); } else if (scb->flags & SCB_MSGOUT_WDTR) { - ahc_construct_wdtr(ahc, AHC_INB(ahc, MSG_LEN), + ahc_construct_wdtr(ahc, ahc_inb(ahc, MSG_LEN), BUS_16_BIT); } else if (scb->flags & SCB_MSGOUT_SDTR) { u_int8_t target_scratch; @@ -1287,14 +1275,14 @@ ahc_handle_seqint(ahc, intstat) int i; /* Pull the user defined setting */ - target_scratch = AHC_INB(ahc, TARG_SCRATCH + target_scratch = ahc_inb(ahc, TARG_SCRATCH + scratch_offset); sxfr = target_scratch & SXFR; if (scratch_offset < 8) - ultraenable = AHC_INB(ahc, ULTRA_ENB); + ultraenable = ahc_inb(ahc, ULTRA_ENB); else - ultraenable = AHC_INB(ahc, ULTRA_ENB + 1); + ultraenable = ahc_inb(ahc, ULTRA_ENB + 1); if (ultraenable & targ_mask) /* Want an ultra speed in the table */ @@ -1304,7 +1292,7 @@ ahc_handle_seqint(ahc, intstat) if (sxfr == ahc_syncrates[i].sxfr) break; - ahc_construct_sdtr(ahc, AHC_INB(ahc, MSG_LEN), + ahc_construct_sdtr(ahc, ahc_inb(ahc, MSG_LEN), ahc_syncrates[i].period, (target_scratch & WIDEXFER) ? MAX_OFFSET_16BIT : MAX_OFFSET_8BIT); @@ -1318,7 +1306,7 @@ ahc_handle_seqint(ahc, intstat) /* * Take care of device reset messages */ - u_int8_t scbindex = AHC_INB(ahc, SCB_TAG); + u_int8_t scbindex = ahc_inb(ahc, SCB_TAG); scb = ahc->scb_data->scbarray[scbindex]; if (scb->flags & SCB_DEVICE_RESET) { @@ -1333,10 +1321,10 @@ ahc_handle_seqint(ahc, intstat) ahc->needwdtr |= ahc->needwdtr_orig & targ_mask; ahc->sdtrpending &= ~targ_mask; ahc->wdtrpending &= ~targ_mask; - targ_scratch = AHC_INB(ahc, TARG_SCRATCH + targ_scratch = ahc_inb(ahc, TARG_SCRATCH + scratch_offset); targ_scratch &= SXFR; - AHC_OUTB(ahc, TARG_SCRATCH + scratch_offset, + ahc_outb(ahc, TARG_SCRATCH + scratch_offset, targ_scratch); found = ahc_reset_device(ahc, target, channel, NULL, @@ -1359,12 +1347,12 @@ ahc_handle_seqint(ahc, intstat) * target to complete its transfer in * BITBUCKET mode. */ - u_int8_t scbindex = AHC_INB(ahc, SCB_TAG); + u_int8_t scbindex = ahc_inb(ahc, SCB_TAG); u_int32_t overrun; scb = ahc->scb_data->scbarray[scbindex]; - overrun = AHC_INB(ahc, STCNT0) - | (AHC_INB(ahc, STCNT1) << 8) - | (AHC_INB(ahc, STCNT2) << 16); + overrun = ahc_inb(ahc, STCNT0) + | (ahc_inb(ahc, STCNT1) << 8) + | (ahc_inb(ahc, STCNT2) << 16); overrun = 0x00ffffff - overrun; sc_print_addr(scb->xs->sc_link); printf("data overrun of %d bytes detected." @@ -1386,7 +1374,7 @@ ahc_handle_seqint(ahc, intstat) default: printf("ahc_intr: seqint, " "intstat == 0x%x, scsisigi = 0x%x\n", - intstat, AHC_INB(ahc, SCSISIGI)); + intstat, ahc_inb(ahc, SCSISIGI)); break; } @@ -1395,7 +1383,7 @@ clear: * Clear the upper byte that holds SEQINT status * codes and clear the SEQINT bit. */ - AHC_OUTB(ahc, CLRINT, CLRSEQINT); + ahc_outb(ahc, CLRINT, CLRSEQINT); /* * The sequencer is paused immediately on @@ -1414,13 +1402,13 @@ ahc_handle_scsiint(ahc, intstat) u_int8_t status; struct scb *scb; - scb_index = AHC_INB(ahc, SCB_TAG); - status = AHC_INB(ahc, SSTAT1); + scb_index = ahc_inb(ahc, SCB_TAG); + status = ahc_inb(ahc, SSTAT1); scb = ahc->scb_data->scbarray[scb_index]; if (status & SCSIRSTI) { char channel; - channel = (AHC_INB(ahc, SBLKCTL) & SELBUSB) ? 'B' : 'A'; + channel = (ahc_inb(ahc, SBLKCTL) & SELBUSB) ? 'B' : 'A'; printf("%s: Someone reset channel %c\n", ahc_name(ahc), channel); ahc_reset_channel(ahc, @@ -1433,9 +1421,9 @@ ahc_handle_scsiint(ahc, intstat) printf("%s: ahc_intr - referenced scb not " "valid during scsiint 0x%x scb(%d)\n", ahc_name(ahc), status, scb_index); - AHC_OUTB(ahc, CLRSINT1, status); + ahc_outb(ahc, CLRSINT1, status); unpause_sequencer(ahc, /*unpause_always*/TRUE); - AHC_OUTB(ahc, CLRINT, CLRSCSIINT); + ahc_outb(ahc, CLRINT, CLRSCSIINT); scb = NULL; } else if (status & SCSIPERR) { /* @@ -1444,7 +1432,7 @@ ahc_handle_scsiint(ahc, intstat) */ char *phase; u_int8_t mesg_out = MSG_NOOP; - u_int8_t lastphase = AHC_INB(ahc, LASTPHASE); + u_int8_t lastphase = ahc_inb(ahc, LASTPHASE); struct scsi_xfer *xs; xs = scb->xs; @@ -1486,8 +1474,8 @@ ahc_handle_scsiint(ahc, intstat) * mesg_out to something other than MSG_NOP. */ if (mesg_out != MSG_NOOP) { - AHC_OUTB(ahc, MSG0, mesg_out); - AHC_OUTB(ahc, MSG_LEN, 1); + ahc_outb(ahc, MSG0, mesg_out); + ahc_outb(ahc, MSG_LEN, 1); } else /* * Should we allow the target to make @@ -1506,36 +1494,36 @@ ahc_handle_scsiint(ahc, intstat) * Clear any pending messages for the timed out * target, and mark the target as free */ - flags = AHC_INB(ahc, FLAGS); - AHC_OUTB(ahc, MSG_LEN, 0); + flags = ahc_inb(ahc, FLAGS); + ahc_outb(ahc, MSG_LEN, 0); ahc_unbusy_target(ahc, xs->sc_link->target, IS_SCSIBUS_B(ahc, xs->sc_link) ? 'B' : 'A'); /* Stop the selection */ - AHC_OUTB(ahc, SCSISEQ, 0); + ahc_outb(ahc, SCSISEQ, 0); - AHC_OUTB(ahc, SCB_CONTROL, 0); + ahc_outb(ahc, SCB_CONTROL, 0); - AHC_OUTB(ahc, CLRSINT1, CLRSELTIMEO); + ahc_outb(ahc, CLRSINT1, CLRSELTIMEO); - AHC_OUTB(ahc, CLRINT, CLRSCSIINT); + ahc_outb(ahc, CLRINT, CLRSCSIINT); /* Shift the waiting Q forward. */ - scbptr = AHC_INB(ahc, WAITING_SCBH); - AHC_OUTB(ahc, SCBPTR, scbptr); - nextscb = AHC_INB(ahc, SCB_NEXT); - AHC_OUTB(ahc, WAITING_SCBH, nextscb); + scbptr = ahc_inb(ahc, WAITING_SCBH); + ahc_outb(ahc, SCBPTR, scbptr); + nextscb = ahc_inb(ahc, SCB_NEXT); + ahc_outb(ahc, WAITING_SCBH, nextscb); /* Put this SCB back on the free list */ - nextscb = AHC_INB(ahc, FREE_SCBH); - AHC_OUTB(ahc, SCB_NEXT, nextscb); - AHC_OUTB(ahc, FREE_SCBH, scbptr); + nextscb = ahc_inb(ahc, FREE_SCBH); + ahc_outb(ahc, SCB_NEXT, nextscb); + ahc_outb(ahc, FREE_SCBH, scbptr); restart_sequencer(ahc); } else if (!(status & BUSFREE)) { sc_print_addr(scb->xs->sc_link); printf("Unknown SCSIINT. Status = 0x%x\n", status); - AHC_OUTB(ahc, CLRSINT1, status); + ahc_outb(ahc, CLRSINT1, status); unpause_sequencer(ahc, /*unpause_always*/TRUE); - AHC_OUTB(ahc, CLRINT, CLRSCSIINT); + ahc_outb(ahc, CLRINT, CLRSCSIINT); scb = NULL; } if (scb != NULL) { @@ -1648,9 +1636,9 @@ ahc_init(ahc) #endif /* Determine channel configuration and who we are on the scsi bus. */ - switch ((sblkctl = AHC_INB(ahc, SBLKCTL) & 0x0a)) { + switch ((sblkctl = ahc_inb(ahc, SBLKCTL) & 0x0a)) { case 0: - ahc->our_id = (AHC_INB(ahc, SCSICONF) & HSCSIID); + ahc->our_id = (ahc_inb(ahc, SCSICONF) & HSCSIID); ahc->flags &= ~AHC_CHANNEL_B_PRIMARY; if ((ahc->type & AHC_39X) != 0) { char channel = 'A'; @@ -1661,10 +1649,10 @@ ahc_init(ahc) ahc->our_id); } else printf("Single Channel, SCSI Id=%d, ", ahc->our_id); - AHC_OUTB(ahc, FLAGS, SINGLE_BUS | (ahc->flags & AHC_PAGESCBS)); + ahc_outb(ahc, FLAGS, SINGLE_BUS | (ahc->flags & AHC_PAGESCBS)); break; case 2: - ahc->our_id = (AHC_INB(ahc, SCSICONF + 1) & HWSCSIID); + ahc->our_id = (ahc_inb(ahc, SCSICONF + 1) & HWSCSIID); ahc->flags &= ~AHC_CHANNEL_B_PRIMARY; if ((ahc->type & AHC_39X) != 0) { char channel = 'A'; @@ -1676,15 +1664,15 @@ ahc_init(ahc) } else printf("Wide Channel, SCSI Id=%d, ", ahc->our_id); ahc->type |= AHC_WIDE; - AHC_OUTB(ahc, FLAGS, WIDE_BUS | (ahc->flags & AHC_PAGESCBS)); + ahc_outb(ahc, FLAGS, WIDE_BUS | (ahc->flags & AHC_PAGESCBS)); break; case 8: - ahc->our_id = (AHC_INB(ahc, SCSICONF) & HSCSIID); - ahc->our_id_b = (AHC_INB(ahc, SCSICONF + 1) & HSCSIID); + ahc->our_id = (ahc_inb(ahc, SCSICONF) & HSCSIID); + ahc->our_id_b = (ahc_inb(ahc, SCSICONF + 1) & HSCSIID); printf("Twin Channel, A SCSI Id=%d, B SCSI Id=%d, ", ahc->our_id, ahc->our_id_b); ahc->type |= AHC_TWIN; - AHC_OUTB(ahc, FLAGS, TWIN_BUS | (ahc->flags & AHC_PAGESCBS)); + ahc_outb(ahc, FLAGS, TWIN_BUS | (ahc->flags & AHC_PAGESCBS)); break; default: printf(" Unsupported adapter type. Ignoring\n"); @@ -1695,37 +1683,37 @@ ahc_init(ahc) if (ahc->scb_data->maxhscbs == 0) { /* SCB 0 heads the free list */ - AHC_OUTB(ahc, FREE_SCBH, 0); + ahc_outb(ahc, FREE_SCBH, 0); for (i = 0; i < AHC_SCB_MAX; i++) { - AHC_OUTB(ahc, SCBPTR, i); - AHC_OUTB(ahc, SCB_CONTROL, i); - if(AHC_INB(ahc, SCB_CONTROL) != i) + ahc_outb(ahc, SCBPTR, i); + ahc_outb(ahc, SCB_CONTROL, i); + if(ahc_inb(ahc, SCB_CONTROL) != i) break; - AHC_OUTB(ahc, SCBPTR, 0); - if(AHC_INB(ahc, SCB_CONTROL) != 0) + ahc_outb(ahc, SCBPTR, 0); + if(ahc_inb(ahc, SCB_CONTROL) != 0) break; - AHC_OUTB(ahc, SCBPTR, i); + ahc_outb(ahc, SCBPTR, i); /* Clear the control byte. */ - AHC_OUTB(ahc, SCB_CONTROL, 0); + ahc_outb(ahc, SCB_CONTROL, 0); /* Set the next pointer */ - AHC_OUTB(ahc, SCB_NEXT, i+1); + ahc_outb(ahc, SCB_NEXT, i+1); /* No Busy non-tagged targets yet */ - AHC_OUTB(ahc, SCB_ACTIVE0, SCB_LIST_NULL); - AHC_OUTB(ahc, SCB_ACTIVE1, SCB_LIST_NULL); - AHC_OUTB(ahc, SCB_ACTIVE2, SCB_LIST_NULL); - AHC_OUTB(ahc, SCB_ACTIVE3, SCB_LIST_NULL); + ahc_outb(ahc, SCB_ACTIVE0, SCB_LIST_NULL); + ahc_outb(ahc, SCB_ACTIVE1, SCB_LIST_NULL); + ahc_outb(ahc, SCB_ACTIVE2, SCB_LIST_NULL); + ahc_outb(ahc, SCB_ACTIVE3, SCB_LIST_NULL); } /* Make that the last SCB terminates the free list */ - AHC_OUTB(ahc, SCBPTR, i-1); - AHC_OUTB(ahc, SCB_NEXT, SCB_LIST_NULL); + ahc_outb(ahc, SCBPTR, i-1); + ahc_outb(ahc, SCB_NEXT, SCB_LIST_NULL); /* Ensure we clear the 0 SCB's control byte. */ - AHC_OUTB(ahc, SCBPTR, 0); - AHC_OUTB(ahc, SCB_CONTROL, 0); + ahc_outb(ahc, SCBPTR, 0); + ahc_outb(ahc, SCB_CONTROL, 0); ahc->scb_data->maxhscbs = i; } @@ -1758,55 +1746,55 @@ ahc_init(ahc) * The device is gated to channel B after a chip reset, * so set those values first */ - AHC_OUTB(ahc, SCSIID, ahc->our_id_b); - scsi_conf = AHC_INB(ahc, SCSICONF + 1); - AHC_OUTB(ahc, SXFRCTL1, (scsi_conf & (ENSPCHK|STIMESEL)) - | ENSTIMER|ACTNEGEN|STPWEN); - AHC_OUTB(ahc, SIMODE1, ENSELTIMO|ENSCSIRST|ENSCSIPERR); + ahc_outb(ahc, SCSIID, ahc->our_id_b); + scsi_conf = ahc_inb(ahc, SCSICONF + 1); + ahc_outb(ahc, SXFRCTL1, (scsi_conf & (ENSPCHK|STIMESEL)) + | ENSTIMER|ACTNEGEN); + ahc_outb(ahc, SIMODE1, ENSELTIMO|ENSCSIRST|ENSCSIPERR); if (ahc->type & AHC_ULTRA) - AHC_OUTB(ahc, SXFRCTL0, DFON|SPIOEN|ULTRAEN); + ahc_outb(ahc, SXFRCTL0, DFON|SPIOEN|ULTRAEN); else - AHC_OUTB(ahc, SXFRCTL0, DFON|SPIOEN); + ahc_outb(ahc, SXFRCTL0, DFON|SPIOEN); if (scsi_conf & RESET_SCSI) { /* Reset the bus */ if (bootverbose) printf("%s: Reseting Channel B\n", ahc_name(ahc)); - AHC_OUTB(ahc, SCSISEQ, SCSIRSTO); + ahc_outb(ahc, SCSISEQ, SCSIRSTO); DELAY(1000); - AHC_OUTB(ahc, SCSISEQ, 0); + ahc_outb(ahc, SCSISEQ, 0); /* Ensure we don't get a RSTI interrupt from this */ - AHC_OUTB(ahc, CLRSINT1, CLRSCSIRSTI); - AHC_OUTB(ahc, CLRINT, CLRSCSIINT); + ahc_outb(ahc, CLRSINT1, CLRSCSIRSTI); + ahc_outb(ahc, CLRINT, CLRSCSIINT); } /* Select Channel A */ - AHC_OUTB(ahc, SBLKCTL, 0); + ahc_outb(ahc, SBLKCTL, 0); } - AHC_OUTB(ahc, SCSIID, ahc->our_id); - scsi_conf = AHC_INB(ahc, SCSICONF); - AHC_OUTB(ahc, SXFRCTL1, (scsi_conf & (ENSPCHK|STIMESEL)) - | ENSTIMER|ACTNEGEN|STPWEN); - AHC_OUTB(ahc, SIMODE1, ENSELTIMO|ENSCSIRST|ENSCSIPERR); + ahc_outb(ahc, SCSIID, ahc->our_id); + scsi_conf = ahc_inb(ahc, SCSICONF); + ahc_outb(ahc, SXFRCTL1, (scsi_conf & (ENSPCHK|STIMESEL)) + | ENSTIMER|ACTNEGEN); + ahc_outb(ahc, SIMODE1, ENSELTIMO|ENSCSIRST|ENSCSIPERR); if (ahc->type & AHC_ULTRA) - AHC_OUTB(ahc, SXFRCTL0, DFON|SPIOEN|ULTRAEN); + ahc_outb(ahc, SXFRCTL0, DFON|SPIOEN|ULTRAEN); else - AHC_OUTB(ahc, SXFRCTL0, DFON|SPIOEN); + ahc_outb(ahc, SXFRCTL0, DFON|SPIOEN); if (scsi_conf & RESET_SCSI) { /* Reset the bus */ if (bootverbose) printf("%s: Reseting Channel A\n", ahc_name(ahc)); - AHC_OUTB(ahc, SCSISEQ, SCSIRSTO); + ahc_outb(ahc, SCSISEQ, SCSIRSTO); DELAY(1000); - AHC_OUTB(ahc, SCSISEQ, 0); + ahc_outb(ahc, SCSISEQ, 0); /* Ensure we don't get a RSTI interrupt from this */ - AHC_OUTB(ahc, CLRSINT1, CLRSCSIRSTI); - AHC_OUTB(ahc, CLRINT, CLRSCSIINT); + ahc_outb(ahc, CLRSINT1, CLRSCSIRSTI); + ahc_outb(ahc, CLRINT, CLRSCSIINT); } /* @@ -1827,8 +1815,8 @@ ahc_init(ahc) "device parameters\n", ahc_name(ahc)); ahc->discenable = 0xff; } else - ahc->discenable = ~((AHC_INB(ahc, DISC_DSB + 1) << 8) - | AHC_INB(ahc, DISC_DSB)); + ahc->discenable = ~((ahc_inb(ahc, DISC_DSB + 1) << 8) + | ahc_inb(ahc, DISC_DSB)); if (!(ahc->type & (AHC_WIDE|AHC_TWIN))) max_targ = 7; @@ -1841,7 +1829,7 @@ ahc_init(ahc) ahc->needwdtr_orig |= (0x01 << i); } else { /* Take the settings leftover in scratch RAM. */ - target_settings = AHC_INB(ahc, TARG_SCRATCH + i); + target_settings = ahc_inb(ahc, TARG_SCRATCH + i); if (target_settings & 0x0f) { ahc->needsdtr_orig |= (0x01 << i); @@ -1874,7 +1862,7 @@ ahc_init(ahc) } } } - AHC_OUTB(ahc, TARG_SCRATCH+i,target_settings); + ahc_outb(ahc, TARG_SCRATCH+i,target_settings); } /* * If we are not a WIDE device, forget WDTR. This @@ -1891,8 +1879,8 @@ ahc_init(ahc) ahc->tagenable = 0; ahc->orderedtag = 0; - AHC_OUTB(ahc, ULTRA_ENB, ultraenable & 0xff); - AHC_OUTB(ahc, ULTRA_ENB + 1, (ultraenable >> 8) & 0xff); + ahc_outb(ahc, ULTRA_ENB, ultraenable & 0xff); + ahc_outb(ahc, ULTRA_ENB + 1, (ultraenable >> 8) & 0xff); #ifdef AHC_DEBUG /* How did we do? */ @@ -1904,13 +1892,13 @@ ahc_init(ahc) /* * Set the number of availible hardware SCBs */ - AHC_OUTB(ahc, SCBCOUNT, ahc->scb_data->maxhscbs); + ahc_outb(ahc, SCBCOUNT, ahc->scb_data->maxhscbs); /* * 2's compliment of maximum tag value */ i = ahc->scb_data->maxscbs; - AHC_OUTB(ahc, COMP_SCBCOUNT, -i & 0xff); + ahc_outb(ahc, COMP_SCBCOUNT, -i & 0xff); /* * Allocate enough "hardware scbs" to handle @@ -1945,10 +1933,10 @@ ahc_init(ahc) /* Tell the sequencer where it can find the hscb array. */ hscb_physaddr = vtophys(ahc->scb_data->hscbs); - AHC_OUTB(ahc, HSCB_ADDR0, hscb_physaddr & 0xFF); - AHC_OUTB(ahc, HSCB_ADDR1, (hscb_physaddr >> 8)& 0xFF); - AHC_OUTB(ahc, HSCB_ADDR2, (hscb_physaddr >> 16)& 0xFF); - AHC_OUTB(ahc, HSCB_ADDR3, (hscb_physaddr >> 24)& 0xFF); + ahc_outb(ahc, HSCB_ADDR0, hscb_physaddr & 0xFF); + ahc_outb(ahc, HSCB_ADDR1, (hscb_physaddr >> 8)& 0xFF); + ahc_outb(ahc, HSCB_ADDR2, (hscb_physaddr >> 16)& 0xFF); + ahc_outb(ahc, HSCB_ADDR3, (hscb_physaddr >> 24)& 0xFF); } /* @@ -1978,19 +1966,26 @@ ahc_init(ahc) * * QFullCount to guard against overflowing the * QINFIFO or QOUTFIFO when we are paging SCBs. + * + * QOUTQCNT is a scratch ram variable that counts + * up as the sequencer fills the QOUTFIFO so it + * can guard against overflowing the FIFO. Since + * the fifo starts empty, clear it. */ - AHC_OUTB(ahc, QCNTMASK, ahc->qcntmask); + ahc_outb(ahc, QCNTMASK, ahc->qcntmask); - AHC_OUTB(ahc, QFULLCNT, ahc->qfullcount); + ahc_outb(ahc, QFULLCNT, ahc->qfullcount); + + ahc_outb(ahc, QOUTQCNT, 0); /* We don't have any waiting selections */ - AHC_OUTB(ahc, WAITING_SCBH, SCB_LIST_NULL); + ahc_outb(ahc, WAITING_SCBH, SCB_LIST_NULL); /* Our disconnection list is empty too */ - AHC_OUTB(ahc, DISCONNECTED_SCBH, SCB_LIST_NULL); + ahc_outb(ahc, DISCONNECTED_SCBH, SCB_LIST_NULL); /* Message out buffer starts empty */ - AHC_OUTB(ahc, MSG_LEN, 0x00); + ahc_outb(ahc, MSG_LEN, 0x00); /* * Load the Sequencer program and Enable the adapter @@ -2005,7 +2000,7 @@ ahc_init(ahc) if (bootverbose) printf("Done\n"); - AHC_OUTB(ahc, SEQCTL, FASTMODE); + ahc_outb(ahc, SEQCTL, FASTMODE); unpause_sequencer(ahc, /*unpause_always*/TRUE); @@ -2236,13 +2231,13 @@ ahc_run_waiting_queue(ahc) while ((scb = ahc->waiting_scbs.stqh_first) != NULL) { if (ahc->curqincnt >= ahc->qfullcount) { - ahc->curqincnt = AHC_INB(ahc, QINCNT) & ahc->qcntmask; + ahc->curqincnt = ahc_inb(ahc, QINCNT) & ahc->qcntmask; if (ahc->curqincnt >= ahc->qfullcount) /* Still no space */ break; } STAILQ_REMOVE_HEAD(&ahc->waiting_scbs, links); - AHC_OUTB(ahc, QINFIFO, scb->hscb->tag); + ahc_outb(ahc, QINFIFO, scb->hscb->tag); if ((ahc->flags & AHC_PAGESCBS) != 0) /* @@ -2401,14 +2396,14 @@ static void ahc_loadseq(ahc) # include "aic7xxx_seq.h" }; - AHC_OUTB(ahc, SEQCTL, PERRORDIS|SEQRESET|LOADRAM); + ahc_outb(ahc, SEQCTL, PERRORDIS|SEQRESET|LOADRAM); - AHC_OUTSB(ahc, SEQRAM, seqprog, sizeof(seqprog)); + ahc_outsb(ahc, SEQRAM, seqprog, sizeof(seqprog)); do { - AHC_OUTB(ahc, SEQCTL, SEQRESET|FASTMODE); - } while ((AHC_INB(ahc, SEQADDR0) != 0) - || (AHC_INB(ahc, SEQADDR1) != 0)); + ahc_outb(ahc, SEQCTL, SEQRESET|FASTMODE); + } while ((ahc_inb(ahc, SEQADDR0) != 0) + || (ahc_inb(ahc, SEQADDR1) != 0)); } /* @@ -2422,7 +2417,7 @@ ahc_poll(ahc, wait) { while (--wait) { DELAY(1000); - if (AHC_INB(ahc, INTSTAT) & INT_PEND) + if (ahc_inb(ahc, INTSTAT) & INT_PEND) break; } if (wait == 0) { printf("%s: board is not responding\n", ahc_name(ahc)); @@ -2493,7 +2488,7 @@ ahc_timeout(arg) * Take a snapshot of the bus state and print out * some information so we can track down driver bugs. */ - bus_state = AHC_INB(ahc, LASTPHASE); + bus_state = ahc_inb(ahc, LASTPHASE); switch(bus_state & PHASE_MASK) { @@ -2526,8 +2521,10 @@ ahc_timeout(arg) break; } - printf(", SCSISIGI == 0x%x\n", AHC_INB(ahc, SCSISIGI)); + printf(", SCSISIGI == 0x%x\n", ahc_inb(ahc, SCSISIGI)); + printf("SEQADDR == 0x%x\n", ahc_inb(ahc, SEQADDR0) + | (ahc_inb(ahc, SEQADDR1) << 8)); /* Decide our course of action */ if (scb->flags & SCB_ABORTED) { @@ -2573,17 +2570,17 @@ ahc_timeout(arg) u_int8_t active_scb_index; struct scb *active_scb; - saved_scbptr = AHC_INB(ahc, SCBPTR); - active_scb_index = AHC_INB(ahc, SCB_TAG); + saved_scbptr = ahc_inb(ahc, SCBPTR); + active_scb_index = ahc_inb(ahc, SCB_TAG); active_scb = ahc->scb_data->scbarray[active_scb_index]; if (bus_state != 0) { /* Send the abort to the active SCB */ - AHC_OUTB(ahc, MSG_LEN, 1); - AHC_OUTB(ahc, MSG0, + ahc_outb(ahc, MSG_LEN, 1); + ahc_outb(ahc, MSG0, (active_scb->hscb->control & TAG_ENB) == 0 ? MSG_ABORT : MSG_ABORT_TAG); - AHC_OUTB(ahc, SCSISIGO, bus_state|ATNO); + ahc_outb(ahc, SCSISIGO, bus_state|ATNO); sc_print_addr(active_scb->xs->sc_link); printf("abort message in message buffer\n"); active_scb->flags |= SCB_ABORTED; @@ -2605,8 +2602,8 @@ ahc_timeout(arg) if (hscb_index == SCB_LIST_NULL) disconnected = TRUE; else { - AHC_OUTB(ahc, SCBPTR, hscb_index); - if (AHC_INB(ahc, SCB_CONTROL) & DISCONNECTED) + ahc_outb(ahc, SCBPTR, hscb_index); + if (ahc_inb(ahc, SCB_CONTROL) & DISCONNECTED) disconnected = TRUE; } @@ -2615,10 +2612,10 @@ ahc_timeout(arg) /* Simply set the ABORT_SCB control bit */ scb->hscb->control |= ABORT_SCB; if (hscb_index != SCB_LIST_NULL) - AHC_OUTB(ahc, SCB_CONTROL, ABORT_SCB); + ahc_outb(ahc, SCB_CONTROL, ABORT_SCB); timeout(ahc_timeout, (caddr_t)scb, (2 * hz)); } - AHC_OUTB(ahc, SCBPTR, saved_scbptr); + ahc_outb(ahc, SCBPTR, saved_scbptr); unpause_sequencer(ahc, /*unpause_always*/FALSE); if (!disconnected) /* Go "immediatly" to the bus reset */ @@ -2642,14 +2639,14 @@ find_scb(ahc, scb) u_int8_t saved_scbptr; u_int8_t curindex; - saved_scbptr = AHC_INB(ahc, SCBPTR); + saved_scbptr = ahc_inb(ahc, SCBPTR); curindex = 0; for (curindex = 0; curindex < ahc->scb_data->maxhscbs; curindex++) { - AHC_OUTB(ahc, SCBPTR, curindex); - if (AHC_INB(ahc, SCB_TAG) == scb->hscb->tag) + ahc_outb(ahc, SCBPTR, curindex); + if (ahc_inb(ahc, SCB_TAG) == scb->hscb->tag) break; } - AHC_OUTB(ahc, SCBPTR, saved_scbptr); + ahc_outb(ahc, SCBPTR, saved_scbptr); if (curindex > ahc->scb_data->maxhscbs) curindex = SCB_LIST_NULL; @@ -2674,17 +2671,17 @@ ahc_reset_device(ahc, target, channel, timedout_scb, xs_error) int found = 0; /* restore this when we're done */ - active_scb = AHC_INB(ahc, SCBPTR); + active_scb = ahc_inb(ahc, SCBPTR); /* * Search the QINFIFO. */ { u_int8_t saved_queue[AHC_SCB_MAX]; - u_int8_t queued = AHC_INB(ahc, QINCNT) & ahc->qcntmask; + u_int8_t queued = ahc_inb(ahc, QINCNT) & ahc->qcntmask; for (i = 0; i < (queued - found); i++) { - saved_queue[i] = AHC_INB(ahc, QINFIFO); + saved_queue[i] = ahc_inb(ahc, QINFIFO); scbp = ahc->scb_data->scbarray[saved_queue[i]]; if (ahc_match_scb (scbp, target, channel)) { /* @@ -2700,7 +2697,7 @@ ahc_reset_device(ahc, target, channel, timedout_scb, xs_error) } /* Now put the saved scbs back. */ for (queued = 0; queued < i; queued++) { - AHC_OUTB(ahc, QINFIFO, saved_queue[queued]); + ahc_outb(ahc, QINFIFO, saved_queue[queued]); } } @@ -2710,19 +2707,19 @@ ahc_reset_device(ahc, target, channel, timedout_scb, xs_error) { u_int8_t next, prev; - next = AHC_INB(ahc, WAITING_SCBH); /* Start at head of list. */ + next = ahc_inb(ahc, WAITING_SCBH); /* Start at head of list. */ prev = SCB_LIST_NULL; while (next != SCB_LIST_NULL) { - AHC_OUTB(ahc, SCBPTR, next); - scbp = ahc->scb_data->scbarray[AHC_INB(ahc, SCB_TAG)]; + ahc_outb(ahc, SCBPTR, next); + scbp = ahc->scb_data->scbarray[ahc_inb(ahc, SCB_TAG)]; if (ahc_match_scb(scbp, target, channel)) { next = ahc_abort_wscb(ahc, scbp, next, prev, timedout_scb, xs_error); found++; } else { prev = next; - next = AHC_INB(ahc, SCB_NEXT); + next = ahc_inb(ahc, SCB_NEXT); } } } @@ -2745,7 +2742,7 @@ ahc_reset_device(ahc, target, channel, timedout_scb, xs_error) found++; } } - AHC_OUTB(ahc, SCBPTR, active_scb); + ahc_outb(ahc, SCBPTR, active_scb); return found; } @@ -2769,33 +2766,33 @@ ahc_abort_wscb (ahc, scbp, scbpos, prev, timedout_scb, xs_error) * Select the SCB we want to abort and * pull the next pointer out of it. */ - curscb = AHC_INB(ahc, SCBPTR); - AHC_OUTB(ahc, SCBPTR, scbpos); - next = AHC_INB(ahc, SCB_NEXT); + curscb = ahc_inb(ahc, SCBPTR); + ahc_outb(ahc, SCBPTR, scbpos); + next = ahc_inb(ahc, SCB_NEXT); /* Clear the necessary fields */ - AHC_OUTB(ahc, SCB_CONTROL, 0); - AHC_OUTB(ahc, SCB_NEXT, SCB_LIST_NULL); + ahc_outb(ahc, SCB_CONTROL, 0); + ahc_outb(ahc, SCB_NEXT, SCB_LIST_NULL); ahc_unbusy_target(ahc, target, channel); /* update the waiting list */ if (prev == SCB_LIST_NULL) /* First in the list */ - AHC_OUTB(ahc, WAITING_SCBH, next); + ahc_outb(ahc, WAITING_SCBH, next); else { /* * Select the scb that pointed to us * and update its next pointer. */ - AHC_OUTB(ahc, SCBPTR, prev); - AHC_OUTB(ahc, SCB_NEXT, next); + ahc_outb(ahc, SCBPTR, prev); + ahc_outb(ahc, SCB_NEXT, next); } /* * Point us back at the original scb position * and inform the SCSI system that the command * has been aborted. */ - AHC_OUTB(ahc, SCBPTR, curscb); + ahc_outb(ahc, SCBPTR, curscb); scbp->flags = SCB_ABORTED|SCB_QUEUED_FOR_DONE; scbp->xs->error |= xs_error; if (scbp != timedout_scb) @@ -2817,12 +2814,12 @@ ahc_unbusy_target(ahc, target, channel) info_scb = target / 4; if (channel == 'B') info_scb += 2; - active_scb = AHC_INB(ahc, SCBPTR); - AHC_OUTB(ahc, SCBPTR, info_scb); + active_scb = ahc_inb(ahc, SCBPTR); + ahc_outb(ahc, SCBPTR, info_scb); scb_offset = SCB_ACTIVE0 + (target & 0x03); - busy_scbid = AHC_INB(ahc, scb_offset); - AHC_OUTB(ahc, scb_offset, SCB_LIST_NULL); - AHC_OUTB(ahc, SCBPTR, active_scb); + busy_scbid = ahc_inb(ahc, scb_offset); + ahc_outb(ahc, scb_offset, SCB_LIST_NULL); + ahc_outb(ahc, SCBPTR, active_scb); return busy_scbid; } @@ -2830,9 +2827,9 @@ static void ahc_reset_current_bus(ahc) struct ahc_softc *ahc; { - AHC_OUTB(ahc, SCSISEQ, SCSIRSTO); + ahc_outb(ahc, SCSISEQ, SCSIRSTO); DELAY(1000); - AHC_OUTB(ahc, SCSISEQ, 0); + ahc_outb(ahc, SCSISEQ, 0); } static int @@ -2887,35 +2884,35 @@ ahc_reset_channel(ahc, channel, timedout_scb, xs_error, initiate_reset) */ u_int8_t targ_scratch; - targ_scratch = AHC_INB(ahc, offset); + targ_scratch = ahc_inb(ahc, offset); targ_scratch &= SXFR; - AHC_OUTB(ahc, offset, targ_scratch); + ahc_outb(ahc, offset, targ_scratch); } /* * Reset the bus if we are initiating this reset and * restart/unpause the sequencer */ - sblkctl = AHC_INB(ahc, SBLKCTL); + sblkctl = ahc_inb(ahc, SBLKCTL); cur_channel = (sblkctl & SELBUSB) ? 'B' : 'A'; if (cur_channel != channel) { /* Case 1: Command for another bus is active * Stealthily reset the other bus without * upsetting the current bus. */ - AHC_OUTB(ahc, SBLKCTL, sblkctl ^ SELBUSB); + ahc_outb(ahc, SBLKCTL, sblkctl ^ SELBUSB); if (initiate_reset) ahc_reset_current_bus(ahc); - AHC_OUTB(ahc, CLRSINT1, CLRSCSIRSTI|CLRSELTIMEO); - AHC_OUTB(ahc, CLRINT, CLRSCSIINT); - AHC_OUTB(ahc, SBLKCTL, sblkctl); + ahc_outb(ahc, CLRSINT1, CLRSCSIRSTI|CLRSELTIMEO); + ahc_outb(ahc, CLRINT, CLRSCSIINT); + ahc_outb(ahc, SBLKCTL, sblkctl); unpause_sequencer(ahc, /*unpause_always*/TRUE); } else { /* Case 2: A command from this bus is active or we're idle */ if (initiate_reset) ahc_reset_current_bus(ahc); - AHC_OUTB(ahc, CLRSINT1, CLRSCSIRSTI|CLRSELTIMEO); - AHC_OUTB(ahc, CLRINT, CLRSCSIINT); + ahc_outb(ahc, CLRSINT1, CLRSCSIRSTI|CLRSELTIMEO); + ahc_outb(ahc, CLRINT, CLRSCSIINT); restart_sequencer(ahc); } ahc_run_done_queue(ahc); @@ -2958,12 +2955,12 @@ ahc_construct_sdtr(ahc, start_byte, period, offset) u_int8_t period; u_int8_t offset; { - AHC_OUTB(ahc, MSG0 + start_byte, MSG_EXTENDED); - AHC_OUTB(ahc, MSG1 + start_byte, MSG_EXT_SDTR_LEN); - AHC_OUTB(ahc, MSG2 + start_byte, MSG_EXT_SDTR); - AHC_OUTB(ahc, MSG3 + start_byte, period); - AHC_OUTB(ahc, MSG4 + start_byte, offset); - AHC_OUTB(ahc, MSG_LEN, start_byte + 5); + ahc_outb(ahc, MSG0 + start_byte, MSG_EXTENDED); + ahc_outb(ahc, MSG1 + start_byte, MSG_EXT_SDTR_LEN); + ahc_outb(ahc, MSG2 + start_byte, MSG_EXT_SDTR); + ahc_outb(ahc, MSG3 + start_byte, period); + ahc_outb(ahc, MSG4 + start_byte, offset); + ahc_outb(ahc, MSG_LEN, start_byte + 5); } static void @@ -2972,11 +2969,11 @@ ahc_construct_wdtr(ahc, start_byte, bus_width) int start_byte; u_int8_t bus_width; { - AHC_OUTB(ahc, MSG0 + start_byte, MSG_EXTENDED); - AHC_OUTB(ahc, MSG1 + start_byte, MSG_EXT_WDTR_LEN); - AHC_OUTB(ahc, MSG2 + start_byte, MSG_EXT_WDTR); - AHC_OUTB(ahc, MSG3 + start_byte, bus_width); - AHC_OUTB(ahc, MSG_LEN, start_byte + 4); + ahc_outb(ahc, MSG0 + start_byte, MSG_EXTENDED); + ahc_outb(ahc, MSG1 + start_byte, MSG_EXT_WDTR_LEN); + ahc_outb(ahc, MSG2 + start_byte, MSG_EXT_WDTR); + ahc_outb(ahc, MSG3 + start_byte, bus_width); + ahc_outb(ahc, MSG_LEN, start_byte + 4); } static void diff --git a/sys/i386/scsi/aic7xxx.h b/sys/i386/scsi/aic7xxx.h index 02d6f3db38b..77d306dd365 100644 --- a/sys/i386/scsi/aic7xxx.h +++ b/sys/i386/scsi/aic7xxx.h @@ -30,7 +30,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: aic7xxx.h,v 1.31 1996/10/28 06:10:02 gibbs Exp $ + * $Id: aic7xxx.h,v 1.32 1996/11/05 07:57:29 gibbs Exp $ */ #ifndef _AIC7XXX_H_ @@ -56,26 +56,6 @@ #define stqe_next sqe_next #endif -#if defined(__FreeBSD__) -#define AHC_INB(ahc, port) \ - (((ahc)->maddr != NULL) ? \ - ((ahc)->maddr[port]) : \ - inb((ahc)->baseport+(port))) -#define AHC_OUTB(ahc, port, val) \ - (((ahc)->maddr != NULL) ? \ - ((ahc)->maddr[port] = (val)) : \ - outb((ahc)->baseport+(port), val)) -#define AHC_OUTSB(ahc, port, valp, size) \ - outsb((ahc)->baseport+(port), valp, size) -#elif defined(__NetBSD__) -#define AHC_INB(ahc, port) \ - bus_io_read_1((ahc)->sc_bc, (ahc)->sc_ioh, port) -#define AHC_OUTB(ahc, port, val) \ - bus_io_write_1((ahc)->sc_bc, (ahc)->sc_ioh, port, val) -#define AHC_OUTSB(ahc, port, valp, size) \ - bus_io_write_multi_1((ahc)->sc_bc, (ahc)->sc_ioh, port, valp, size) -#endif - #define AHC_NSEG 256 /* number of dma segments supported */ #define AHC_SCB_MAX 255 /* @@ -312,7 +292,6 @@ extern int ahc_debug; /* Initialized in i386/scsi/aic7xxx.c */ char *ahc_name __P((struct ahc_softc *ahc)); -void ahc_reset __P((u_int32_t iobase)); struct ahc_softc *ahc_alloc __P((int unit, u_int32_t io_base, vm_offset_t maddr, ahc_type type, ahc_flag flags, struct scb_data *scb_data)); @@ -320,9 +299,9 @@ struct ahc_softc *ahc_alloc __P((int unit, u_int32_t io_base, #define ahc_name(ahc) (ahc)->sc_dev.dv_xname -void ahc_reset __P((char *devname, bus_chipset_tag_t bc, bus_io_handle_t ioh)); void ahc_construct __P((struct ahc_softc *ahc, bus_chipset_tag_t bc, bus_io_handle_t ioh, ahc_type type, ahc_flag flags)); #endif +void ahc_reset __P((struct ahc_softc *ahc)); void ahc_free __P((struct ahc_softc *)); int ahc_init __P((struct ahc_softc *)); int ahc_attach __P((struct ahc_softc *)); @@ -332,4 +311,63 @@ void ahc_intr __P((void *arg)); int ahc_intr __P((void *arg)); #endif +#if defined(__FreeBSD__) +static __inline u_int8_t ahc_inb __P((struct ahc_softc *ahc, u_int32_t port)); +static __inline void ahc_outb __P((struct ahc_softc *ahc, u_int32_t port, + u_int8_t val)); +static __inline void ahc_outsb __P((struct ahc_softc *ahc, u_int32_t port, + u_int8_t *valp, size_t size)); + +static __inline u_int8_t +ahc_inb(ahc, port) + struct ahc_softc *ahc; + u_int32_t port; +{ + if (ahc->maddr != NULL) + return ahc->maddr[port]; + else + return inb(ahc->baseport + port); +} + +static __inline void +ahc_outb(ahc, port, val) + struct ahc_softc *ahc; + u_int32_t port; + u_int8_t val; +{ + if (ahc->maddr != NULL) + ahc->maddr[port] = val; + else + outb(ahc->baseport + port, val); +} + +static __inline void +ahc_outsb(ahc, port, valp, size) + struct ahc_softc *ahc; + u_int32_t port; + u_int8_t *valp; + size_t size; +{ + if (ahc->maddr != NULL) { + __asm __volatile(" + cld; + 1: lodsb; + movb %%al,(%0); + loop 1b" : + : + "r" ((ahc)->maddr + (port)), + "S" ((valp)), "c" ((size)) : + "%esi", "%ecx", "%eax"); + } else + outsb(ahc->baseport + port, valp, size); +} +#elif defined(__NetBSD__) +#define ahc_inb(ahc, port) \ + bus_io_read_1((ahc)->sc_bc, (ahc)->sc_ioh, port) +#define ahc_outb(ahc, port, val) \ + bus_io_write_1((ahc)->sc_bc, (ahc)->sc_ioh, port, val) +#define ahc_outsb(ahc, port, valp, size) \ + bus_io_write_multi_1((ahc)->sc_bc, (ahc)->sc_ioh, port, valp, size) +#endif + #endif /* _AIC7XXX_H_ */