2 * Copyright (c) 1999 Luoqi Chen.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/kernel.h>
34 #include <sys/mutex.h>
35 #include <sys/malloc.h>
38 #include <machine/bus.h>
41 #include <cam/cam_ccb.h>
42 #include <cam/cam_sim.h>
43 #include <cam/cam_xpt_sim.h>
44 #include <cam/cam_debug.h>
46 #include <cam/scsi/scsi_message.h>
48 #include <dev/aic/aic6360reg.h>
49 #include <dev/aic/aicvar.h>
51 static void aic_action(struct cam_sim *sim, union ccb *ccb);
52 static void aic_execute_scb(void *arg, bus_dma_segment_t *dm_segs,
54 static void aic_start(struct aic_softc *aic);
55 static void aic_select(struct aic_softc *aic);
56 static void aic_selected(struct aic_softc *aic);
57 static void aic_reselected(struct aic_softc *aic);
58 static void aic_reconnect(struct aic_softc *aic, int tag);
59 static void aic_cmd(struct aic_softc *aic);
60 static void aic_msgin(struct aic_softc *aic);
61 static void aic_handle_msgin(struct aic_softc *aic);
62 static void aic_msgout(struct aic_softc *aic);
63 static void aic_datain(struct aic_softc *aic);
64 static void aic_dataout(struct aic_softc *aic);
65 static void aic_done(struct aic_softc *aic, struct aic_scb *scb);
66 static void aic_poll(struct cam_sim *sim);
67 static void aic_timeout(void *arg);
68 static void aic_scsi_reset(struct aic_softc *aic);
69 static void aic_chip_reset(struct aic_softc *aic);
70 static void aic_reset(struct aic_softc *aic, int initiate_reset);
72 devclass_t aic_devclass;
74 static struct aic_scb *free_scbs;
76 static struct aic_scb *
77 aic_get_scb(struct aic_softc *aic)
81 if ((scb = free_scbs) != NULL)
82 free_scbs = (struct aic_scb *)free_scbs->ccb;
88 aic_free_scb(struct aic_softc *aic, struct aic_scb *scb)
91 if ((aic->flags & AIC_RESOURCE_SHORTAGE) != 0 &&
92 (scb->ccb->ccb_h.status & CAM_RELEASE_SIMQ) == 0) {
93 scb->ccb->ccb_h.status |= CAM_RELEASE_SIMQ;
94 aic->flags &= ~AIC_RESOURCE_SHORTAGE;
97 scb->ccb = (union ccb *)free_scbs;
103 aic_action(struct cam_sim *sim, union ccb *ccb)
105 struct aic_softc *aic;
108 CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, ("aic_action\n"));
110 aic = (struct aic_softc *)cam_sim_softc(sim);
112 switch (ccb->ccb_h.func_code) {
113 case XPT_SCSI_IO: /* Execute the requested I/O operation */
114 case XPT_RESET_DEV: /* Bus Device Reset the specified SCSI device */
118 if ((scb = aic_get_scb(aic)) == NULL) {
120 aic->flags |= AIC_RESOURCE_SHORTAGE;
122 xpt_freeze_simq(aic->sim, /*count*/1);
123 ccb->ccb_h.status = CAM_REQUEUE_REQ;
129 ccb->ccb_h.ccb_scb_ptr = scb;
130 ccb->ccb_h.ccb_aic_ptr = aic;
132 scb->target = ccb->ccb_h.target_id;
133 scb->lun = ccb->ccb_h.target_lun;
135 if (ccb->ccb_h.func_code == XPT_SCSI_IO) {
136 scb->cmd_len = ccb->csio.cdb_len;
137 if (ccb->ccb_h.flags & CAM_CDB_POINTER) {
138 if (ccb->ccb_h.flags & CAM_CDB_PHYS) {
139 ccb->ccb_h.status = CAM_REQ_INVALID;
140 aic_free_scb(aic, scb);
144 scb->cmd_ptr = ccb->csio.cdb_io.cdb_ptr;
146 scb->cmd_ptr = ccb->csio.cdb_io.cdb_bytes;
148 if ((ccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
149 if ((ccb->ccb_h.flags & CAM_DATA_MASK) !=
151 ccb->ccb_h.status = CAM_REQ_INVALID;
152 aic_free_scb(aic, scb);
156 scb->data_ptr = ccb->csio.data_ptr;
157 scb->data_len = ccb->csio.dxfer_len;
159 scb->data_ptr = NULL;
162 aic_execute_scb(scb, NULL, 0, 0);
164 scb->flags |= SCB_DEVICE_RESET;
165 aic_execute_scb(scb, NULL, 0, 0);
169 case XPT_SET_TRAN_SETTINGS:
171 struct ccb_trans_settings *cts = &ccb->cts;
172 struct aic_tinfo *ti = &aic->tinfo[ccb->ccb_h.target_id];
173 struct ccb_trans_settings_scsi *scsi =
174 &cts->proto_specific.scsi;
175 struct ccb_trans_settings_spi *spi =
176 &cts->xport_specific.spi;
180 if ((spi->valid & CTS_SPI_VALID_DISC) != 0 &&
181 (aic->flags & AIC_DISC_ENABLE) != 0) {
182 if ((spi->flags & CTS_SPI_FLAGS_DISC_ENB) != 0)
183 ti->flags |= TINFO_DISC_ENB;
185 ti->flags &= ~TINFO_DISC_ENB;
188 if ((scsi->valid & CTS_SCSI_VALID_TQ) != 0) {
189 if ((scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) != 0)
190 ti->flags |= TINFO_TAG_ENB;
192 ti->flags &= ~TINFO_TAG_ENB;
195 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) {
196 ti->goal.period = spi->sync_period;
198 if (ti->goal.period > aic->min_period) {
201 } else if (ti->goal.period < aic->max_period)
202 ti->goal.period = aic->max_period;
205 if ((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0) {
206 ti->goal.offset = spi->sync_offset;
207 if (ti->goal.offset == 0)
209 else if (ti->goal.offset > AIC_SYNC_OFFSET)
210 ti->goal.offset = AIC_SYNC_OFFSET;
213 if ((ti->goal.period != ti->current.period)
214 || (ti->goal.offset != ti->current.offset))
215 ti->flags |= TINFO_SDTR_NEGO;
218 ccb->ccb_h.status = CAM_REQ_CMP;
222 case XPT_GET_TRAN_SETTINGS:
224 struct ccb_trans_settings *cts = &ccb->cts;
225 struct aic_tinfo *ti = &aic->tinfo[ccb->ccb_h.target_id];
226 struct ccb_trans_settings_scsi *scsi =
227 &cts->proto_specific.scsi;
228 struct ccb_trans_settings_spi *spi =
229 &cts->xport_specific.spi;
231 cts->protocol = PROTO_SCSI;
232 cts->protocol_version = SCSI_REV_2;
233 cts->transport = XPORT_SPI;
234 cts->transport_version = 2;
235 scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB;
236 spi->flags &= ~CTS_SPI_FLAGS_DISC_ENB;
239 if ((ti->flags & TINFO_DISC_ENB) != 0)
240 spi->flags |= CTS_SPI_FLAGS_DISC_ENB;
241 if ((ti->flags & TINFO_TAG_ENB) != 0)
242 scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB;
244 if (cts->type == CTS_TYPE_CURRENT_SETTINGS) {
245 spi->sync_period = ti->current.period;
246 spi->sync_offset = ti->current.offset;
248 spi->sync_period = ti->user.period;
249 spi->sync_offset = ti->user.offset;
253 spi->bus_width = MSG_EXT_WDTR_BUS_8_BIT;
254 spi->valid = CTS_SPI_VALID_SYNC_RATE
255 | CTS_SPI_VALID_SYNC_OFFSET
256 | CTS_SPI_VALID_BUS_WIDTH
257 | CTS_SPI_VALID_DISC;
258 scsi->valid = CTS_SCSI_VALID_TQ;
260 ccb->ccb_h.status = CAM_REQ_CMP;
264 case XPT_CALC_GEOMETRY:
266 cam_calc_geometry(&ccb->ccg, /*extended*/1);
270 case XPT_RESET_BUS: /* Reset the specified SCSI bus */
271 aic_reset(aic, /*initiate_reset*/TRUE);
272 ccb->ccb_h.status = CAM_REQ_CMP;
275 case XPT_PATH_INQ: /* Path routing inquiry */
277 struct ccb_pathinq *cpi = &ccb->cpi;
279 cpi->version_num = 1; /* XXX??? */
280 cpi->hba_inquiry = PI_SDTR_ABLE | PI_TAG_ABLE;
281 cpi->target_sprt = 0;
283 cpi->hba_eng_cnt = 0;
286 cpi->initiator_id = aic->initiator;
287 cpi->bus_id = cam_sim_bus(sim);
288 cpi->base_transfer_speed = 3300;
289 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
290 strncpy(cpi->hba_vid, "Adaptec", HBA_IDLEN);
291 strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
292 cpi->unit_number = cam_sim_unit(sim);
293 cpi->transport = XPORT_SPI;
294 cpi->transport_version = 2;
295 cpi->protocol = PROTO_SCSI;
296 cpi->protocol_version = SCSI_REV_2;
297 cpi->ccb_h.status = CAM_REQ_CMP;
302 ccb->ccb_h.status = CAM_REQ_INVALID;
309 aic_execute_scb(void *arg, bus_dma_segment_t *dm_segs, int nseg, int error)
311 struct aic_scb *scb = (struct aic_scb *)arg;
312 union ccb *ccb = scb->ccb;
313 struct aic_softc *aic = (struct aic_softc *)ccb->ccb_h.ccb_aic_ptr;
318 if (ccb->ccb_h.status != CAM_REQ_INPROG) {
320 aic_free_scb(aic, scb);
325 scb->flags |= SCB_ACTIVE;
326 ccb->ccb_h.status |= CAM_SIM_QUEUED;
327 TAILQ_INSERT_TAIL(&aic->pending_ccbs, &ccb->ccb_h, sim_links.tqe);
329 ccb->ccb_h.timeout_ch = timeout(aic_timeout, (caddr_t)scb,
330 (ccb->ccb_h.timeout * hz) / 1000);
337 * Start another command if the controller is not busy.
340 aic_start(struct aic_softc *aic)
342 struct ccb_hdr *ccb_h;
343 struct aic_tinfo *ti;
345 if (aic->state != AIC_IDLE)
348 TAILQ_FOREACH(ccb_h, &aic->pending_ccbs, sim_links.tqe) {
349 ti = &aic->tinfo[ccb_h->target_id];
350 if ((ti->lubusy & (1 << ccb_h->target_lun)) == 0) {
351 TAILQ_REMOVE(&aic->pending_ccbs, ccb_h, sim_links.tqe);
352 aic->nexus = (struct aic_scb *)ccb_h->ccb_scb_ptr;
358 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_start: idle\n"));
360 aic_outb(aic, SIMODE0, ENSELDI);
361 aic_outb(aic, SIMODE1, ENSCSIRST);
362 aic_outb(aic, SCSISEQ, ENRESELI);
369 aic_select(struct aic_softc *aic)
371 struct aic_scb *scb = aic->nexus;
373 CAM_DEBUG(scb->ccb->ccb_h.path, CAM_DEBUG_TRACE,
374 ("aic_select - ccb %p\n", scb->ccb));
376 aic->state = AIC_SELECTING;
378 aic_outb(aic, DMACNTRL1, 0);
379 aic_outb(aic, SCSIID, aic->initiator << OID_S | scb->target);
380 aic_outb(aic, SXFRCTL1, STIMO_256ms | ENSTIMER |
381 (aic->flags & AIC_PARITY_ENABLE ? ENSPCHK : 0));
383 aic_outb(aic, SIMODE0, ENSELDI|ENSELDO);
384 aic_outb(aic, SIMODE1, ENSCSIRST|ENSELTIMO);
385 aic_outb(aic, SCSISEQ, ENRESELI|ENSELO|ENAUTOATNO);
389 * We have successfully selected a target, prepare for the information
393 aic_selected(struct aic_softc *aic)
395 struct aic_scb *scb = aic->nexus;
396 union ccb *ccb = scb->ccb;
397 struct aic_tinfo *ti = &aic->tinfo[scb->target];
399 CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE,
400 ("aic_selected - ccb %p\n", ccb));
402 aic->state = AIC_HASNEXUS;
404 if (scb->flags & SCB_DEVICE_RESET) {
405 aic->msg_buf[0] = MSG_BUS_DEV_RESET;
407 aic->msg_outq = AIC_MSG_MSGBUF;
409 aic->msg_outq = AIC_MSG_IDENTIFY;
410 if ((ti->flags & TINFO_TAG_ENB) != 0 &&
411 (ccb->ccb_h.flags & CAM_TAG_ACTION_VALID) != 0)
412 aic->msg_outq |= AIC_MSG_TAG_Q;
414 ti->lubusy |= 1 << scb->lun;
415 if ((ti->flags & TINFO_SDTR_NEGO) != 0)
416 aic->msg_outq |= AIC_MSG_SDTR;
419 aic_outb(aic, CLRSINT0, CLRSELDO);
420 aic_outb(aic, CLRSINT1, CLRBUSFREE);
421 aic_outb(aic, SCSISEQ, ENAUTOATNP);
422 aic_outb(aic, SIMODE0, 0);
423 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT);
424 aic_outb(aic, SCSIRATE, ti->scsirate);
428 * We are re-selected by a target, save the target id and wait for the
429 * target to further identify itself.
432 aic_reselected(struct aic_softc *aic)
436 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_reselected\n"));
439 * If we have started a selection, it must have lost out in
440 * the arbitration, put the command back to the pending queue.
443 TAILQ_INSERT_HEAD(&aic->pending_ccbs,
444 &aic->nexus->ccb->ccb_h, sim_links.tqe);
448 selid = aic_inb(aic, SELID) & ~(1 << aic->initiator);
449 if (selid & (selid - 1)) {
450 /* this should never have happened */
451 printf("aic_reselected: invalid selid %x\n", selid);
452 aic_reset(aic, /*initiate_reset*/TRUE);
456 aic->state = AIC_RESELECTED;
457 aic->target = ffs(selid) - 1;
460 aic_outb(aic, CLRSINT0, CLRSELDI);
461 aic_outb(aic, CLRSINT1, CLRBUSFREE);
462 aic_outb(aic, SIMODE0, 0);
463 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT);
464 aic_outb(aic, SCSISEQ, ENAUTOATNP);
465 aic_outb(aic, SCSIRATE, aic->tinfo[aic->target].scsirate);
469 * Raise ATNO to signal the target that we have a message for it.
472 aic_sched_msgout(struct aic_softc *aic, u_int8_t msg)
475 aic->msg_buf[0] = msg;
478 aic->msg_outq |= AIC_MSG_MSGBUF;
479 aic_outb(aic, SCSISIGO, aic_inb(aic, SCSISIGI) | ATNO);
483 * Wait for SPIORDY (SCSI PIO ready) flag, or a phase change.
486 aic_spiordy(struct aic_softc *aic)
488 while (!(aic_inb(aic, DMASTAT) & INTSTAT) &&
489 !(aic_inb(aic, SSTAT0) & SPIORDY))
491 return !(aic_inb(aic, DMASTAT) & INTSTAT);
495 * Reestablish a disconnected nexus.
498 aic_reconnect(struct aic_softc *aic, int tag)
501 struct ccb_hdr *ccb_h;
503 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_reconnect\n"));
507 TAILQ_FOREACH(ccb_h, &aic->nexus_ccbs, sim_links.tqe) {
508 scb = (struct aic_scb *)ccb_h->ccb_scb_ptr;
509 if (scb->target == aic->target && scb->lun == aic->lun &&
510 (tag == -1 || scb->tag == tag))
514 /* ABORT if nothing is found */
517 aic_sched_msgout(aic, MSG_ABORT);
519 aic_sched_msgout(aic, MSG_ABORT_TAG);
520 xpt_async(AC_UNSOL_RESEL, aic->path, NULL);
524 /* Reestablish the nexus */
525 TAILQ_REMOVE(&aic->nexus_ccbs, ccb_h, sim_links.tqe);
527 scb->flags &= ~SCB_DISCONNECTED;
528 aic->state = AIC_HASNEXUS;
535 aic_msgin(struct aic_softc *aic)
539 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_msgin\n"));
541 aic_outb(aic, SIMODE1, ENSCSIRST|ENPHASEMIS|ENBUSFREE);
542 aic_outb(aic, SXFRCTL0, CHEN|SPIOEN);
544 aic->flags &= ~AIC_DROP_MSGIN;
548 * If a parity error is detected, drop the remaining
549 * bytes and inform the target so it could resend
552 if (aic_inb(aic, SSTAT1) & SCSIPERR) {
553 aic_outb(aic, CLRSINT1, CLRSCSIPERR);
554 aic->flags |= AIC_DROP_MSGIN;
555 aic_sched_msgout(aic, MSG_PARITY_ERROR);
557 if ((aic->flags & AIC_DROP_MSGIN)) {
558 aic_inb(aic, SCSIDAT);
561 /* read the message byte without ACKing on it */
562 aic->msg_buf[aic->msg_len++] = aic_inb(aic, SCSIBUS);
563 if (aic->msg_buf[0] == MSG_EXTENDED) {
564 if (aic->msg_len < 2) {
565 (void) aic_inb(aic, SCSIDAT);
568 switch (aic->msg_buf[2]) {
570 msglen = MSG_EXT_SDTR_LEN;
573 msglen = MSG_EXT_WDTR_LEN;
579 if (aic->msg_buf[1] != msglen) {
580 aic->flags |= AIC_DROP_MSGIN;
581 aic_sched_msgout(aic, MSG_MESSAGE_REJECT);
584 } else if (aic->msg_buf[0] >= 0x20 && aic->msg_buf[0] <= 0x2f)
589 * If we have a complete message, handle it before the final
590 * ACK (in case we decide to reject the message).
592 if (aic->msg_len == msglen) {
593 aic_handle_msgin(aic);
596 /* ACK on the message byte */
597 (void) aic_inb(aic, SCSIDAT);
598 } while (aic_spiordy(aic));
600 aic_outb(aic, SXFRCTL0, CHEN);
601 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT);
608 aic_handle_msgin(struct aic_softc *aic)
611 struct ccb_hdr *ccb_h;
612 struct aic_tinfo *ti;
613 struct ccb_trans_settings neg;
614 struct ccb_trans_settings_spi *spi = &neg.xport_specific.spi;
616 if (aic->state == AIC_RESELECTED) {
617 if (!MSG_ISIDENTIFY(aic->msg_buf[0])) {
618 aic_sched_msgout(aic, MSG_MESSAGE_REJECT);
621 aic->lun = aic->msg_buf[0] & MSG_IDENTIFY_LUNMASK;
622 if (aic->tinfo[aic->target].lubusy & (1 << aic->lun))
623 aic_reconnect(aic, -1);
625 aic->state = AIC_RECONNECTING;
629 if (aic->state == AIC_RECONNECTING) {
630 if (aic->msg_buf[0] != MSG_SIMPLE_Q_TAG) {
631 aic_sched_msgout(aic, MSG_MESSAGE_REJECT);
634 aic_reconnect(aic, aic->msg_buf[1]);
638 switch (aic->msg_buf[0]) {
639 case MSG_CMDCOMPLETE: {
640 struct ccb_scsiio *csio;
642 ccb_h = &scb->ccb->ccb_h;
643 csio = &scb->ccb->csio;
644 if ((scb->flags & SCB_SENSE) != 0) {
645 /* auto REQUEST SENSE command */
646 scb->flags &= ~SCB_SENSE;
647 csio->sense_resid = scb->data_len;
648 if (scb->status == SCSI_STATUS_OK) {
650 CAM_SCSI_STATUS_ERROR|CAM_AUTOSNS_VALID;
651 /*scsi_sense_print(csio);*/
653 ccb_h->status |= CAM_AUTOSENSE_FAIL;
654 printf("ccb %p sense failed %x\n",
658 csio->scsi_status = scb->status;
659 csio->resid = scb->data_len;
660 if (scb->status == SCSI_STATUS_OK) {
661 /* everything goes well */
662 ccb_h->status |= CAM_REQ_CMP;
663 } else if ((ccb_h->flags & CAM_DIS_AUTOSENSE) == 0 &&
664 (csio->scsi_status == SCSI_STATUS_CHECK_COND ||
665 csio->scsi_status == SCSI_STATUS_CMD_TERMINATED)) {
666 /* try to retrieve sense information */
667 scb->flags |= SCB_SENSE;
668 aic->flags |= AIC_BUSFREE_OK;
671 ccb_h->status |= CAM_SCSI_STATUS_ERROR;
674 aic->flags |= AIC_BUSFREE_OK;
678 switch (aic->msg_buf[2]) {
681 ti = &aic->tinfo[scb->target];
682 if (ti->flags & TINFO_SDTR_SENT) {
683 ti->current.period = aic->msg_buf[3];
684 ti->current.offset = aic->msg_buf[4];
686 ti->current.period = aic->msg_buf[3] =
687 max(ti->goal.period, aic->msg_buf[3]);
688 ti->current.offset = aic->msg_buf[4] =
689 min(ti->goal.offset, aic->msg_buf[4]);
691 * The target initiated the negotiation,
692 * send back a response.
694 aic_sched_msgout(aic, 0);
696 ti->flags &= ~(TINFO_SDTR_SENT|TINFO_SDTR_NEGO);
697 ti->scsirate = ti->current.offset ? ti->current.offset |
698 ((ti->current.period * 4 + 49) / 50 - 2) << 4 : 0;
699 aic_outb(aic, SCSIRATE, ti->scsirate);
700 memset(&neg, 0, sizeof (neg));
701 neg.protocol = PROTO_SCSI;
702 neg.protocol_version = SCSI_REV_2;
703 neg.transport = XPORT_SPI;
704 neg.transport_version = 2;
705 spi->sync_period = ti->goal.period = ti->current.period;
706 spi->sync_offset = ti->goal.offset = ti->current.offset;
707 spi->valid = CTS_SPI_VALID_SYNC_RATE
708 | CTS_SPI_VALID_SYNC_OFFSET;
709 ccb_h = &scb->ccb->ccb_h;
710 xpt_setup_ccb(&neg.ccb_h, ccb_h->path, 1);
711 xpt_async(AC_TRANSFER_NEG, ccb_h->path, &neg);
715 aic_sched_msgout(aic, MSG_MESSAGE_REJECT);
721 ccb_h = &scb->ccb->ccb_h;
722 TAILQ_INSERT_TAIL(&aic->nexus_ccbs, ccb_h, sim_links.tqe);
723 scb->flags |= SCB_DISCONNECTED;
724 aic->flags |= AIC_BUSFREE_OK;
726 CAM_DEBUG(ccb_h->path, CAM_DEBUG_TRACE, ("disconnected\n"));
728 case MSG_MESSAGE_REJECT:
729 switch (aic->msg_outq & -aic->msg_outq) {
732 ti = &aic->tinfo[scb->target];
733 ti->flags &= ~TINFO_TAG_ENB;
734 ti->lubusy |= 1 << scb->lun;
738 ti = &aic->tinfo[scb->target];
739 ti->current.period = ti->goal.period = 0;
740 ti->current.offset = ti->goal.offset = 0;
741 ti->flags &= ~(TINFO_SDTR_SENT|TINFO_SDTR_NEGO);
743 aic_outb(aic, SCSIRATE, ti->scsirate);
744 memset(&neg, 0, sizeof (neg));
745 neg.protocol = PROTO_SCSI;
746 neg.protocol_version = SCSI_REV_2;
747 neg.transport = XPORT_SPI;
748 neg.transport_version = 2;
749 spi->sync_period = ti->current.period;
750 spi->sync_offset = ti->current.offset;
751 spi->valid = CTS_SPI_VALID_SYNC_RATE
752 | CTS_SPI_VALID_SYNC_OFFSET;
753 ccb_h = &scb->ccb->ccb_h;
754 xpt_setup_ccb(&neg.ccb_h, ccb_h->path, 1);
755 xpt_async(AC_TRANSFER_NEG, ccb_h->path, &neg);
761 case MSG_SAVEDATAPOINTER:
763 case MSG_RESTOREPOINTERS:
768 aic_sched_msgout(aic, MSG_MESSAGE_REJECT);
777 aic_msgout(struct aic_softc *aic)
781 struct aic_tinfo *ti;
784 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_msgout\n"));
786 aic_outb(aic, SIMODE1, ENSCSIRST|ENPHASEMIS|ENBUSFREE);
787 aic_outb(aic, SXFRCTL0, CHEN|SPIOEN);
790 * If the previous phase is also the message out phase,
791 * we need to retransmit all the messages, probably
792 * because the target has detected a parity error during
793 * the past transmission.
795 if (aic->prev_phase == PH_MSGOUT)
796 aic->msg_outq = aic->msg_sent;
799 int q = aic->msg_outq;
800 if (msgidx > 0 && msgidx == aic->msg_len) {
801 /* complete message sent, start the next one */
809 /* setup the message */
811 case AIC_MSG_IDENTIFY:
814 ti = &aic->tinfo[scb->target];
815 aic->msg_buf[0] = MSG_IDENTIFY(scb->lun,
816 (ti->flags & TINFO_DISC_ENB) &&
817 !(ccb->ccb_h.flags & CAM_DIS_DISCONNECT));
823 aic->msg_buf[0] = ccb->csio.tag_action;
824 aic->msg_buf[1] = scb->tag;
829 ti = &aic->tinfo[scb->target];
830 aic->msg_buf[0] = MSG_EXTENDED;
831 aic->msg_buf[1] = MSG_EXT_SDTR_LEN;
832 aic->msg_buf[2] = MSG_EXT_SDTR;
833 aic->msg_buf[3] = ti->goal.period;
834 aic->msg_buf[4] = ti->goal.offset;
835 aic->msg_len = MSG_EXT_SDTR_LEN + 2;
836 ti->flags |= TINFO_SDTR_SENT;
839 /* a single message already in the buffer */
840 if (aic->msg_buf[0] == MSG_BUS_DEV_RESET ||
841 aic->msg_buf[0] == MSG_ABORT ||
842 aic->msg_buf[0] == MSG_ABORT_TAG)
843 aic->flags |= AIC_BUSFREE_OK;
848 * If this is the last message byte of all messages,
849 * clear ATNO to signal transmission complete.
851 if ((q & (q - 1)) == 0 && msgidx == aic->msg_len - 1)
852 aic_outb(aic, CLRSINT1, CLRATNO);
853 /* transmit the message byte */
854 aic_outb(aic, SCSIDAT, aic->msg_buf[msgidx++]);
855 } while (aic_spiordy(aic));
857 aic_outb(aic, SXFRCTL0, CHEN);
858 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT);
865 aic_datain(struct aic_softc *aic)
867 struct aic_scb *scb = aic->nexus;
868 u_int8_t dmastat, dmacntrl0;
871 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_datain\n"));
873 aic_outb(aic, SIMODE1, ENSCSIRST|ENPHASEMIS|ENBUSFREE);
874 aic_outb(aic, SXFRCTL0, SCSIEN|DMAEN|CHEN);
877 if (aic->flags & AIC_DWIO_ENABLE)
878 dmacntrl0 |= DWORDPIO;
879 aic_outb(aic, DMACNTRL0, dmacntrl0);
881 while (scb->data_len > 0) {
883 /* wait for the fifo to fill up or a phase change */
884 dmastat = aic_inb(aic, DMASTAT);
885 if (dmastat & (INTSTAT|DFIFOFULL))
888 if (dmastat & DFIFOFULL) {
892 * No more data, wait for the remaining bytes in
893 * the scsi fifo to be transfer to the host fifo.
895 while (!(aic_inb(aic, SSTAT2) & SEMPTY))
897 n = aic_inb(aic, FIFOSTAT);
899 n = imin(scb->data_len, n);
900 if (aic->flags & AIC_DWIO_ENABLE) {
902 aic_insl(aic, DMADATALONG, scb->data_ptr, n>>2);
903 scb->data_ptr += n & ~3;
904 scb->data_len -= n & ~3;
909 aic_insw(aic, DMADATA, scb->data_ptr, n >> 1);
910 scb->data_ptr += n & ~1;
911 scb->data_len -= n & ~1;
916 aic_outb(aic, DMACNTRL0, ENDMA|B8MODE);
917 aic_insb(aic, DMADATA, scb->data_ptr, n);
920 aic_outb(aic, DMACNTRL0, dmacntrl0);
923 if (dmastat & INTSTAT)
927 aic_outb(aic, SXFRCTL0, CHEN);
928 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT);
935 aic_dataout(struct aic_softc *aic)
937 struct aic_scb *scb = aic->nexus;
938 u_int8_t dmastat, dmacntrl0, sstat2;
941 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_dataout\n"));
943 aic_outb(aic, SIMODE1, ENSCSIRST|ENPHASEMIS|ENBUSFREE);
944 aic_outb(aic, SXFRCTL0, SCSIEN|DMAEN|CHEN);
946 dmacntrl0 = ENDMA|WRITE;
947 if (aic->flags & AIC_DWIO_ENABLE)
948 dmacntrl0 |= DWORDPIO;
949 aic_outb(aic, DMACNTRL0, dmacntrl0);
951 while (scb->data_len > 0) {
953 /* wait for the fifo to clear up or a phase change */
954 dmastat = aic_inb(aic, DMASTAT);
955 if (dmastat & (INTSTAT|DFIFOEMP))
958 if (dmastat & INTSTAT)
960 n = imin(scb->data_len, FIFOSIZE);
961 if (aic->flags & AIC_DWIO_ENABLE) {
963 aic_outsl(aic, DMADATALONG, scb->data_ptr,n>>2);
964 scb->data_ptr += n & ~3;
965 scb->data_len -= n & ~3;
970 aic_outsw(aic, DMADATA, scb->data_ptr, n >> 1);
971 scb->data_ptr += n & ~1;
972 scb->data_len -= n & ~1;
977 aic_outb(aic, DMACNTRL0, ENDMA|WRITE|B8MODE);
978 aic_outsb(aic, DMADATA, scb->data_ptr, n);
981 aic_outb(aic, DMACNTRL0, dmacntrl0);
986 /* wait until all bytes in the fifos are transmitted */
987 dmastat = aic_inb(aic, DMASTAT);
988 sstat2 = aic_inb(aic, SSTAT2);
989 if ((dmastat & DFIFOEMP) && (sstat2 & SEMPTY))
991 if (dmastat & INTSTAT) {
992 /* adjust for untransmitted bytes */
993 n = aic_inb(aic, FIFOSTAT) + (sstat2 & 0xf);
997 aic_outb(aic, SXFRCTL0, CHEN|CLRCH);
998 aic_outb(aic, DMACNTRL0, RSTFIFO);
1003 aic_outb(aic, SXFRCTL0, CHEN);
1004 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT);
1008 * Send the scsi command.
1011 aic_cmd(struct aic_softc *aic)
1013 struct aic_scb *scb = aic->nexus;
1014 struct scsi_request_sense sense_cmd;
1016 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_cmd\n"));
1018 if (scb->flags & SCB_SENSE) {
1019 /* autosense request */
1020 sense_cmd.opcode = REQUEST_SENSE;
1021 sense_cmd.byte2 = scb->lun << 5;
1022 sense_cmd.length = scb->ccb->csio.sense_len;
1023 sense_cmd.control = 0;
1024 sense_cmd.unused[0] = 0;
1025 sense_cmd.unused[1] = 0;
1026 scb->cmd_ptr = (u_int8_t *)&sense_cmd;
1027 scb->cmd_len = sizeof(sense_cmd);
1028 scb->data_ptr = (u_int8_t *)&scb->ccb->csio.sense_data;
1029 scb->data_len = scb->ccb->csio.sense_len;
1032 aic_outb(aic, SIMODE1, ENSCSIRST|ENPHASEMIS|ENBUSFREE);
1033 aic_outb(aic, DMACNTRL0, ENDMA|WRITE);
1034 aic_outb(aic, SXFRCTL0, SCSIEN|DMAEN|CHEN);
1035 aic_outsw(aic, DMADATA, (u_int16_t *)scb->cmd_ptr, scb->cmd_len >> 1);
1036 while ((aic_inb(aic, SSTAT2) & SEMPTY) == 0 &&
1037 (aic_inb(aic, DMASTAT) & INTSTAT) == 0)
1039 aic_outb(aic, SXFRCTL0, CHEN);
1040 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT);
1044 * Finish off a command. The caller is responsible to remove the ccb
1048 aic_done(struct aic_softc *aic, struct aic_scb *scb)
1050 union ccb *ccb = scb->ccb;
1052 CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE,
1053 ("aic_done - ccb %p status %x resid %d\n",
1054 ccb, ccb->ccb_h.status, ccb->csio.resid));
1056 untimeout(aic_timeout, (caddr_t)scb, ccb->ccb_h.timeout_ch);
1058 if ((scb->flags & SCB_DEVICE_RESET) != 0 &&
1059 ccb->ccb_h.func_code != XPT_RESET_DEV) {
1060 struct cam_path *path;
1061 struct ccb_hdr *ccb_h;
1064 error = xpt_create_path(&path, /*periph*/NULL,
1065 cam_sim_path(aic->sim),
1069 if (error == CAM_REQ_CMP) {
1070 xpt_async(AC_SENT_BDR, path, NULL);
1071 xpt_free_path(path);
1074 ccb_h = TAILQ_FIRST(&aic->pending_ccbs);
1075 while (ccb_h != NULL) {
1076 struct aic_scb *pending_scb;
1078 pending_scb = (struct aic_scb *)ccb_h->ccb_scb_ptr;
1079 if (ccb_h->target_id == scb->target) {
1080 ccb_h->status |= CAM_BDR_SENT;
1081 ccb_h = TAILQ_NEXT(ccb_h, sim_links.tqe);
1082 TAILQ_REMOVE(&aic->pending_ccbs,
1083 &pending_scb->ccb->ccb_h, sim_links.tqe);
1084 aic_done(aic, pending_scb);
1087 timeout(aic_timeout, (caddr_t)pending_scb,
1088 (ccb_h->timeout * hz) / 1000);
1089 ccb_h = TAILQ_NEXT(ccb_h, sim_links.tqe);
1093 ccb_h = TAILQ_FIRST(&aic->nexus_ccbs);
1094 while (ccb_h != NULL) {
1095 struct aic_scb *nexus_scb;
1097 nexus_scb = (struct aic_scb *)ccb_h->ccb_scb_ptr;
1098 if (ccb_h->target_id == scb->target) {
1099 ccb_h->status |= CAM_BDR_SENT;
1100 ccb_h = TAILQ_NEXT(ccb_h, sim_links.tqe);
1101 TAILQ_REMOVE(&aic->nexus_ccbs,
1102 &nexus_scb->ccb->ccb_h, sim_links.tqe);
1103 aic_done(aic, nexus_scb);
1106 timeout(aic_timeout, (caddr_t)nexus_scb,
1107 (ccb_h->timeout * hz) / 1000);
1108 ccb_h = TAILQ_NEXT(ccb_h, sim_links.tqe);
1113 if (aic->nexus == scb || scb->flags & SCB_DISCONNECTED)
1114 aic->tinfo[scb->target].lubusy &= ~(1 << scb->lun);
1116 if (aic->nexus == scb) {
1119 aic_free_scb(aic, scb);
1124 aic_poll(struct cam_sim *sim)
1126 aic_intr(cam_sim_softc(sim));
1130 aic_timeout(void *arg)
1132 struct aic_scb *scb = (struct aic_scb *)arg;
1133 union ccb *ccb = scb->ccb;
1134 struct aic_softc *aic = (struct aic_softc *)ccb->ccb_h.ccb_aic_ptr;
1137 xpt_print_path(ccb->ccb_h.path);
1138 printf("ccb %p - timed out", ccb);
1139 if (aic->nexus && aic->nexus != scb)
1140 printf(", nexus %p", aic->nexus->ccb);
1141 printf(", phase 0x%x, state %d\n", aic_inb(aic, SCSISIGI), aic->state);
1145 if ((scb->flags & SCB_ACTIVE) == 0) {
1147 xpt_print_path(ccb->ccb_h.path);
1148 printf("ccb %p - timed out already completed\n", ccb);
1152 if ((scb->flags & SCB_DEVICE_RESET) == 0 && aic->nexus == scb) {
1153 struct ccb_hdr *ccb_h = &scb->ccb->ccb_h;
1155 if ((ccb_h->status & CAM_RELEASE_SIMQ) == 0) {
1156 xpt_freeze_simq(aic->sim, /*count*/1);
1157 ccb_h->status |= CAM_RELEASE_SIMQ;
1160 TAILQ_FOREACH(ccb_h, &aic->pending_ccbs, sim_links.tqe) {
1161 untimeout(aic_timeout, (caddr_t)ccb_h->ccb_scb_ptr,
1165 TAILQ_FOREACH(ccb_h, &aic->nexus_ccbs, sim_links.tqe) {
1166 untimeout(aic_timeout, (caddr_t)ccb_h->ccb_scb_ptr,
1170 scb->flags |= SCB_DEVICE_RESET;
1171 ccb->ccb_h.timeout_ch =
1172 timeout(aic_timeout, (caddr_t)scb, 5 * hz);
1173 aic_sched_msgout(aic, MSG_BUS_DEV_RESET);
1175 if (aic->nexus == scb) {
1176 ccb->ccb_h.status |= CAM_CMD_TIMEOUT;
1179 aic_reset(aic, /*initiate_reset*/TRUE);
1188 struct aic_softc *aic = (struct aic_softc *)arg;
1189 u_int8_t sstat0, sstat1;
1191 struct aic_scb *scb;
1193 if (!(aic_inb(aic, DMASTAT) & INTSTAT))
1196 aic_outb(aic, DMACNTRL0, 0);
1198 sstat0 = aic_inb(aic, SSTAT0);
1199 sstat1 = aic_inb(aic, SSTAT1);
1201 if ((sstat1 & SCSIRSTI) != 0) {
1202 /* a device-initiated bus reset */
1203 aic_outb(aic, CLRSINT1, CLRSCSIRSTI);
1204 aic_reset(aic, /*initiate_reset*/FALSE);
1208 if ((sstat1 & SCSIPERR) != 0) {
1209 aic_outb(aic, CLRSINT1, CLRSCSIPERR);
1210 aic_sched_msgout(aic, MSG_PARITY_ERROR);
1211 aic_outb(aic, DMACNTRL0, INTEN);
1215 if (aic_inb(aic, SSTAT4)) {
1216 aic_outb(aic, CLRSERR, CLRSYNCERR|CLRFWERR|CLRFRERR);
1217 aic_reset(aic, /*initiate_reset*/TRUE);
1221 if (aic->state <= AIC_SELECTING) {
1222 if ((sstat0 & SELDI) != 0) {
1223 aic_reselected(aic);
1224 aic_outb(aic, DMACNTRL0, INTEN);
1228 if ((sstat0 & SELDO) != 0) {
1230 aic_outb(aic, DMACNTRL0, INTEN);
1234 if ((sstat1 & SELTO) != 0) {
1237 ccb->ccb_h.status = CAM_SEL_TIMEOUT;
1239 while ((sstat1 & BUSFREE) == 0)
1240 sstat1 = aic_inb(aic, SSTAT1);
1241 aic->flags |= AIC_BUSFREE_OK;
1245 if ((sstat1 & BUSFREE) != 0) {
1246 aic_outb(aic, SCSISEQ, 0);
1247 aic_outb(aic, CLRSINT0, sstat0);
1248 aic_outb(aic, CLRSINT1, sstat1);
1249 if ((scb = aic->nexus)) {
1250 if ((aic->flags & AIC_BUSFREE_OK) == 0) {
1252 ccb->ccb_h.status = CAM_UNEXP_BUSFREE;
1254 } else if (scb->flags & SCB_DEVICE_RESET) {
1256 if (ccb->ccb_h.func_code == XPT_RESET_DEV) {
1257 xpt_async(AC_SENT_BDR,
1258 ccb->ccb_h.path, NULL);
1259 ccb->ccb_h.status |= CAM_REQ_CMP;
1261 ccb->ccb_h.status |= CAM_CMD_TIMEOUT;
1263 } else if (scb->flags & SCB_SENSE) {
1264 /* autosense request */
1265 aic->flags &= ~AIC_BUSFREE_OK;
1266 aic->tinfo[scb->target].lubusy &=
1269 aic_outb(aic, DMACNTRL0, INTEN);
1273 aic->flags &= ~AIC_BUSFREE_OK;
1274 aic->state = AIC_IDLE;
1276 aic_outb(aic, DMACNTRL0, INTEN);
1280 if ((sstat1 & REQINIT) != 0) {
1281 u_int8_t phase = aic_inb(aic, SCSISIGI) & PH_MASK;
1282 aic_outb(aic, SCSISIGO, phase);
1283 aic_outb(aic, CLRSINT1, CLRPHASECHG);
1295 aic_outb(aic, DMACNTRL0, 0);
1296 aic_outb(aic, SXFRCTL0, CHEN|SPIOEN);
1297 scb->status = aic_inb(aic, SCSIDAT);
1298 aic_outb(aic, SXFRCTL0, CHEN);
1310 aic->prev_phase = phase;
1311 aic_outb(aic, DMACNTRL0, INTEN);
1315 printf("aic_intr: unexpected intr sstat0 %x sstat1 %x\n",
1317 aic_outb(aic, DMACNTRL0, INTEN);
1324 aic_chip_reset(struct aic_softc *aic)
1327 * Doc. recommends to clear these two registers before
1328 * operations commence
1330 aic_outb(aic, SCSITEST, 0);
1331 aic_outb(aic, TEST, 0);
1333 /* Reset SCSI-FIFO and abort any transfers */
1334 aic_outb(aic, SXFRCTL0, CHEN|CLRCH|CLRSTCNT);
1336 /* Reset HOST-FIFO */
1337 aic_outb(aic, DMACNTRL0, RSTFIFO);
1338 aic_outb(aic, DMACNTRL1, 0);
1340 /* Disable all selection features */
1341 aic_outb(aic, SCSISEQ, 0);
1342 aic_outb(aic, SXFRCTL1, 0);
1344 /* Disable interrupts */
1345 aic_outb(aic, SIMODE0, 0);
1346 aic_outb(aic, SIMODE1, 0);
1348 /* Clear interrupts */
1349 aic_outb(aic, CLRSINT0, 0x7f);
1350 aic_outb(aic, CLRSINT1, 0xef);
1352 /* Disable synchronous transfers */
1353 aic_outb(aic, SCSIRATE, 0);
1355 /* Haven't seen ant errors (yet) */
1356 aic_outb(aic, CLRSERR, 0x07);
1358 /* Set our SCSI-ID */
1359 aic_outb(aic, SCSIID, aic->initiator << OID_S);
1360 aic_outb(aic, BRSTCNTRL, EISA_BRST_TIM);
1364 * Reset the SCSI bus
1367 aic_scsi_reset(struct aic_softc *aic)
1369 aic_outb(aic, SCSISEQ, SCSIRSTO);
1371 aic_outb(aic, SCSISEQ, 0);
1376 * Reset. Abort all pending commands.
1379 aic_reset(struct aic_softc *aic, int initiate_reset)
1381 struct ccb_hdr *ccb_h;
1383 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_reset\n"));
1386 aic_scsi_reset(aic);
1387 aic_chip_reset(aic);
1389 xpt_async(AC_BUS_RESET, aic->path, NULL);
1391 while ((ccb_h = TAILQ_FIRST(&aic->pending_ccbs)) != NULL) {
1392 TAILQ_REMOVE(&aic->pending_ccbs, ccb_h, sim_links.tqe);
1393 ccb_h->status |= CAM_SCSI_BUS_RESET;
1394 aic_done(aic, (struct aic_scb *)ccb_h->ccb_scb_ptr);
1397 while ((ccb_h = TAILQ_FIRST(&aic->nexus_ccbs)) != NULL) {
1398 TAILQ_REMOVE(&aic->nexus_ccbs, ccb_h, sim_links.tqe);
1399 ccb_h->status |= CAM_SCSI_BUS_RESET;
1400 aic_done(aic, (struct aic_scb *)ccb_h->ccb_scb_ptr);
1404 ccb_h = &aic->nexus->ccb->ccb_h;
1405 ccb_h->status |= CAM_SCSI_BUS_RESET;
1406 aic_done(aic, aic->nexus);
1409 aic->state = AIC_IDLE;
1410 aic_outb(aic, DMACNTRL0, INTEN);
1413 static char *aic_chip_names[] = {
1414 "AIC6260", "AIC6360", "AIC6370", "GM82C700",
1420 } aic_chip_ids[] = {
1421 { AIC6360, IDSTRING_AIC6360 },
1422 { AIC6370, IDSTRING_AIC6370 },
1423 { GM82C700, IDSTRING_GM82C700 },
1427 aic_init(struct aic_softc *aic)
1429 struct aic_scb *scb;
1430 struct aic_tinfo *ti;
1431 u_int8_t porta, portb;
1435 TAILQ_INIT(&aic->pending_ccbs);
1436 TAILQ_INIT(&aic->nexus_ccbs);
1438 aic->state = AIC_IDLE;
1439 aic->prev_phase = -1;
1442 aic_chip_reset(aic);
1443 aic_scsi_reset(aic);
1445 /* determine the chip type from its ID string */
1446 aic->chip_type = AIC6260;
1447 aic_insb(aic, ID, chip_id, sizeof(chip_id) - 1);
1448 chip_id[sizeof(chip_id) - 1] = '\0';
1449 for (i = 0; i < sizeof(aic_chip_ids) / sizeof(aic_chip_ids[0]); i++) {
1450 if (!strcmp(chip_id, aic_chip_ids[i].idstring)) {
1451 aic->chip_type = aic_chip_ids[i].type;
1456 porta = aic_inb(aic, PORTA);
1457 portb = aic_inb(aic, PORTB);
1459 aic->initiator = PORTA_ID(porta);
1460 if (PORTA_PARITY(porta))
1461 aic->flags |= AIC_PARITY_ENABLE;
1462 if (PORTB_DISC(portb))
1463 aic->flags |= AIC_DISC_ENABLE;
1464 if (PORTB_DMA(portb))
1465 aic->flags |= AIC_DMA_ENABLE;
1468 * We can do fast SCSI (10MHz clock rate) if bit 4 of portb
1469 * is set and we've got a 6360. The 6260 can only do standard
1472 if (aic->chip_type > AIC6260 || aic_inb(aic, REV)) {
1473 if (PORTB_FSYNC(portb))
1474 aic->flags |= AIC_FAST_ENABLE;
1475 aic->flags |= AIC_DWIO_ENABLE;
1478 if (aic->flags & AIC_FAST_ENABLE)
1479 aic->max_period = AIC_FAST_SYNC_PERIOD;
1481 aic->max_period = AIC_SYNC_PERIOD;
1482 aic->min_period = AIC_MIN_SYNC_PERIOD;
1485 for (i = 255; i >= 0; i--) {
1486 scb = &aic->scbs[i];
1488 aic_free_scb(aic, scb);
1491 for (i = 0; i < 8; i++) {
1492 if (i == aic->initiator)
1494 ti = &aic->tinfo[i];
1495 bzero(ti, sizeof(*ti));
1496 ti->flags = TINFO_TAG_ENB;
1497 if (aic->flags & AIC_DISC_ENABLE)
1498 ti->flags |= TINFO_DISC_ENB;
1499 ti->user.period = aic->max_period;
1500 ti->user.offset = AIC_SYNC_OFFSET;
1504 aic_outb(aic, DMACNTRL0, INTEN);
1508 aic_probe(struct aic_softc *aic)
1512 /* Remove aic6360 from possible powerdown mode */
1513 aic_outb(aic, DMACNTRL0, 0);
1516 aic_outb(aic, DMACNTRL1, 0); /* Reset stack pointer */
1517 for (i = 0; i < STSIZE; i++)
1518 aic_outb(aic, STACK, i);
1520 /* See if we can pull out the same sequence */
1521 aic_outb(aic, DMACNTRL1, 0);
1522 for (i = 0; i < STSIZE && aic_inb(aic, STACK) == i; i++)
1531 aic_attach(struct aic_softc *aic)
1533 struct cam_devq *devq;
1536 * Create the device queue for our SIM.
1538 devq = cam_simq_alloc(256);
1543 * Construct our SIM entry
1545 aic->sim = cam_sim_alloc(aic_action, aic_poll, "aic", aic,
1546 aic->unit, &Giant, 2, 256, devq);
1547 if (aic->sim == NULL) {
1548 cam_simq_free(devq);
1552 if (xpt_bus_register(aic->sim, aic->dev, 0) != CAM_SUCCESS) {
1553 cam_sim_free(aic->sim, /*free_devq*/TRUE);
1557 if (xpt_create_path(&aic->path, /*periph*/NULL,
1558 cam_sim_path(aic->sim), CAM_TARGET_WILDCARD,
1559 CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
1560 xpt_bus_deregister(cam_sim_path(aic->sim));
1561 cam_sim_free(aic->sim, /*free_devq*/TRUE);
1567 printf("aic%d: %s", aic->unit, aic_chip_names[aic->chip_type]);
1568 if (aic->flags & AIC_DMA_ENABLE)
1570 if (aic->flags & AIC_DISC_ENABLE)
1571 printf(", disconnection");
1572 if (aic->flags & AIC_PARITY_ENABLE)
1573 printf(", parity check");
1574 if (aic->flags & AIC_FAST_ENABLE)
1575 printf(", fast SCSI");
1581 aic_detach(struct aic_softc *aic)
1583 xpt_async(AC_LOST_DEVICE, aic->path, NULL);
1584 xpt_free_path(aic->path);
1585 xpt_bus_deregister(cam_sim_path(aic->sim));
1586 cam_sim_free(aic->sim, /*free_devq*/TRUE);