1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 1999 Luoqi Chen. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/param.h> 33 #include <sys/conf.h> 34 #include <sys/systm.h> 35 #include <sys/kernel.h> 36 #include <sys/lock.h> 37 #include <sys/mutex.h> 38 #include <sys/malloc.h> 39 #include <sys/bus.h> 40 41 #include <machine/bus.h> 42 #include <sys/rman.h> 43 44 #include <cam/cam.h> 45 #include <cam/cam_ccb.h> 46 #include <cam/cam_sim.h> 47 #include <cam/cam_xpt_sim.h> 48 #include <cam/cam_debug.h> 49 50 #include <cam/scsi/scsi_message.h> 51 52 #include <dev/aic/aic6360reg.h> 53 #include <dev/aic/aicvar.h> 54 55 static void aic_action(struct cam_sim *sim, union ccb *ccb); 56 static void aic_execute_scb(void *arg, bus_dma_segment_t *dm_segs, 57 int nseg, int error); 58 static void aic_intr_locked(struct aic_softc *aic); 59 static void aic_start(struct aic_softc *aic); 60 static void aic_select(struct aic_softc *aic); 61 static void aic_selected(struct aic_softc *aic); 62 static void aic_reselected(struct aic_softc *aic); 63 static void aic_reconnect(struct aic_softc *aic, int tag); 64 static void aic_cmd(struct aic_softc *aic); 65 static void aic_msgin(struct aic_softc *aic); 66 static void aic_handle_msgin(struct aic_softc *aic); 67 static void aic_msgout(struct aic_softc *aic); 68 static void aic_datain(struct aic_softc *aic); 69 static void aic_dataout(struct aic_softc *aic); 70 static void aic_done(struct aic_softc *aic, struct aic_scb *scb); 71 static void aic_poll(struct cam_sim *sim); 72 static void aic_timeout(void *arg); 73 static void aic_scsi_reset(struct aic_softc *aic); 74 static void aic_chip_reset(struct aic_softc *aic); 75 static void aic_reset(struct aic_softc *aic, int initiate_reset); 76 77 devclass_t aic_devclass; 78 79 static struct aic_scb * 80 aic_get_scb(struct aic_softc *aic) 81 { 82 struct aic_scb *scb; 83 84 if (!dumping) 85 mtx_assert(&aic->lock, MA_OWNED); 86 if ((scb = SLIST_FIRST(&aic->free_scbs)) != NULL) 87 SLIST_REMOVE_HEAD(&aic->free_scbs, link); 88 return (scb); 89 } 90 91 static void 92 aic_free_scb(struct aic_softc *aic, struct aic_scb *scb) 93 { 94 95 if (!dumping) 96 mtx_assert(&aic->lock, MA_OWNED); 97 if ((aic->flags & AIC_RESOURCE_SHORTAGE) != 0 && 98 (scb->ccb->ccb_h.status & CAM_RELEASE_SIMQ) == 0) { 99 scb->ccb->ccb_h.status |= CAM_RELEASE_SIMQ; 100 aic->flags &= ~AIC_RESOURCE_SHORTAGE; 101 } 102 scb->flags = 0; 103 SLIST_INSERT_HEAD(&aic->free_scbs, scb, link); 104 } 105 106 static void 107 aic_action(struct cam_sim *sim, union ccb *ccb) 108 { 109 struct aic_softc *aic; 110 111 CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, ("aic_action\n")); 112 113 aic = (struct aic_softc *)cam_sim_softc(sim); 114 mtx_assert(&aic->lock, MA_OWNED); 115 116 switch (ccb->ccb_h.func_code) { 117 case XPT_SCSI_IO: /* Execute the requested I/O operation */ 118 case XPT_RESET_DEV: /* Bus Device Reset the specified SCSI device */ 119 { 120 struct aic_scb *scb; 121 122 if ((scb = aic_get_scb(aic)) == NULL) { 123 aic->flags |= AIC_RESOURCE_SHORTAGE; 124 xpt_freeze_simq(aic->sim, /*count*/1); 125 ccb->ccb_h.status = CAM_REQUEUE_REQ; 126 xpt_done(ccb); 127 return; 128 } 129 130 scb->ccb = ccb; 131 ccb->ccb_h.ccb_scb_ptr = scb; 132 ccb->ccb_h.ccb_aic_ptr = aic; 133 134 scb->target = ccb->ccb_h.target_id; 135 scb->lun = ccb->ccb_h.target_lun; 136 137 if (ccb->ccb_h.func_code == XPT_SCSI_IO) { 138 scb->cmd_len = ccb->csio.cdb_len; 139 if (ccb->ccb_h.flags & CAM_CDB_POINTER) { 140 if (ccb->ccb_h.flags & CAM_CDB_PHYS) { 141 ccb->ccb_h.status = CAM_REQ_INVALID; 142 aic_free_scb(aic, scb); 143 xpt_done(ccb); 144 return; 145 } 146 scb->cmd_ptr = ccb->csio.cdb_io.cdb_ptr; 147 } else { 148 scb->cmd_ptr = ccb->csio.cdb_io.cdb_bytes; 149 } 150 if ((ccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE) { 151 if ((ccb->ccb_h.flags & CAM_DATA_MASK) != 152 CAM_DATA_VADDR) { 153 ccb->ccb_h.status = CAM_REQ_INVALID; 154 aic_free_scb(aic, scb); 155 xpt_done(ccb); 156 return; 157 } 158 scb->data_ptr = ccb->csio.data_ptr; 159 scb->data_len = ccb->csio.dxfer_len; 160 } else { 161 scb->data_ptr = NULL; 162 scb->data_len = 0; 163 } 164 aic_execute_scb(scb, NULL, 0, 0); 165 } else { 166 scb->flags |= SCB_DEVICE_RESET; 167 aic_execute_scb(scb, NULL, 0, 0); 168 } 169 break; 170 } 171 case XPT_SET_TRAN_SETTINGS: 172 { 173 struct ccb_trans_settings *cts = &ccb->cts; 174 struct aic_tinfo *ti = &aic->tinfo[ccb->ccb_h.target_id]; 175 struct ccb_trans_settings_scsi *scsi = 176 &cts->proto_specific.scsi; 177 struct ccb_trans_settings_spi *spi = 178 &cts->xport_specific.spi; 179 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; 184 else 185 ti->flags &= ~TINFO_DISC_ENB; 186 } 187 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; 191 else 192 ti->flags &= ~TINFO_TAG_ENB; 193 } 194 195 if ((spi->valid & CTS_SPI_VALID_SYNC_RATE) != 0) { 196 ti->goal.period = spi->sync_period; 197 198 if (ti->goal.period > aic->min_period) { 199 ti->goal.period = 0; 200 ti->goal.offset = 0; 201 } else if (ti->goal.period < aic->max_period) 202 ti->goal.period = aic->max_period; 203 } 204 205 if ((spi->valid & CTS_SPI_VALID_SYNC_OFFSET) != 0) { 206 ti->goal.offset = spi->sync_offset; 207 if (ti->goal.offset == 0) 208 ti->goal.period = 0; 209 else if (ti->goal.offset > AIC_SYNC_OFFSET) 210 ti->goal.offset = AIC_SYNC_OFFSET; 211 } 212 213 if ((ti->goal.period != ti->current.period) 214 || (ti->goal.offset != ti->current.offset)) 215 ti->flags |= TINFO_SDTR_NEGO; 216 217 ccb->ccb_h.status = CAM_REQ_CMP; 218 xpt_done(ccb); 219 break; 220 } 221 case XPT_GET_TRAN_SETTINGS: 222 { 223 struct ccb_trans_settings *cts = &ccb->cts; 224 struct aic_tinfo *ti = &aic->tinfo[ccb->ccb_h.target_id]; 225 struct ccb_trans_settings_scsi *scsi = 226 &cts->proto_specific.scsi; 227 struct ccb_trans_settings_spi *spi = 228 &cts->xport_specific.spi; 229 230 cts->protocol = PROTO_SCSI; 231 cts->protocol_version = SCSI_REV_2; 232 cts->transport = XPORT_SPI; 233 cts->transport_version = 2; 234 scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB; 235 spi->flags &= ~CTS_SPI_FLAGS_DISC_ENB; 236 237 if ((ti->flags & TINFO_DISC_ENB) != 0) 238 spi->flags |= CTS_SPI_FLAGS_DISC_ENB; 239 if ((ti->flags & TINFO_TAG_ENB) != 0) 240 scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB; 241 242 if (cts->type == CTS_TYPE_CURRENT_SETTINGS) { 243 spi->sync_period = ti->current.period; 244 spi->sync_offset = ti->current.offset; 245 } else { 246 spi->sync_period = ti->user.period; 247 spi->sync_offset = ti->user.offset; 248 } 249 250 spi->bus_width = MSG_EXT_WDTR_BUS_8_BIT; 251 spi->valid = CTS_SPI_VALID_SYNC_RATE 252 | CTS_SPI_VALID_SYNC_OFFSET 253 | CTS_SPI_VALID_BUS_WIDTH 254 | CTS_SPI_VALID_DISC; 255 scsi->valid = CTS_SCSI_VALID_TQ; 256 257 ccb->ccb_h.status = CAM_REQ_CMP; 258 xpt_done(ccb); 259 break; 260 } 261 case XPT_CALC_GEOMETRY: 262 { 263 cam_calc_geometry(&ccb->ccg, /*extended*/1); 264 xpt_done(ccb); 265 break; 266 } 267 case XPT_RESET_BUS: /* Reset the specified SCSI bus */ 268 aic_reset(aic, /*initiate_reset*/TRUE); 269 ccb->ccb_h.status = CAM_REQ_CMP; 270 xpt_done(ccb); 271 break; 272 case XPT_PATH_INQ: /* Path routing inquiry */ 273 { 274 struct ccb_pathinq *cpi = &ccb->cpi; 275 276 cpi->version_num = 1; /* XXX??? */ 277 cpi->hba_inquiry = PI_SDTR_ABLE | PI_TAG_ABLE; 278 cpi->target_sprt = 0; 279 cpi->hba_misc = 0; 280 cpi->hba_eng_cnt = 0; 281 cpi->max_target = 7; 282 cpi->max_lun = 7; 283 cpi->initiator_id = aic->initiator; 284 cpi->bus_id = cam_sim_bus(sim); 285 cpi->base_transfer_speed = 3300; 286 strlcpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); 287 strlcpy(cpi->hba_vid, "Adaptec", HBA_IDLEN); 288 strlcpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN); 289 cpi->unit_number = cam_sim_unit(sim); 290 cpi->transport = XPORT_SPI; 291 cpi->transport_version = 2; 292 cpi->protocol = PROTO_SCSI; 293 cpi->protocol_version = SCSI_REV_2; 294 cpi->ccb_h.status = CAM_REQ_CMP; 295 xpt_done(ccb); 296 break; 297 } 298 default: 299 ccb->ccb_h.status = CAM_REQ_INVALID; 300 xpt_done(ccb); 301 break; 302 } 303 } 304 305 static void 306 aic_execute_scb(void *arg, bus_dma_segment_t *dm_segs, int nseg, int error) 307 { 308 struct aic_scb *scb = (struct aic_scb *)arg; 309 union ccb *ccb = scb->ccb; 310 struct aic_softc *aic = (struct aic_softc *)ccb->ccb_h.ccb_aic_ptr; 311 312 if (!dumping) 313 mtx_assert(&aic->lock, MA_OWNED); 314 if (ccb->ccb_h.status != CAM_REQ_INPROG) { 315 aic_free_scb(aic, scb); 316 xpt_done(ccb); 317 return; 318 } 319 320 scb->flags |= SCB_ACTIVE; 321 ccb->ccb_h.status |= CAM_SIM_QUEUED; 322 TAILQ_INSERT_TAIL(&aic->pending_ccbs, &ccb->ccb_h, sim_links.tqe); 323 324 callout_reset_sbt(&scb->timer, SBT_1MS * ccb->ccb_h.timeout, 0, 325 aic_timeout, scb, 0); 326 327 aic_start(aic); 328 } 329 330 /* 331 * Start another command if the controller is not busy. 332 */ 333 static void 334 aic_start(struct aic_softc *aic) 335 { 336 struct ccb_hdr *ccb_h; 337 struct aic_tinfo *ti; 338 339 if (aic->state != AIC_IDLE) 340 return; 341 342 TAILQ_FOREACH(ccb_h, &aic->pending_ccbs, sim_links.tqe) { 343 ti = &aic->tinfo[ccb_h->target_id]; 344 if ((ti->lubusy & (1 << ccb_h->target_lun)) == 0) { 345 TAILQ_REMOVE(&aic->pending_ccbs, ccb_h, sim_links.tqe); 346 aic->nexus = (struct aic_scb *)ccb_h->ccb_scb_ptr; 347 aic_select(aic); 348 return; 349 } 350 } 351 352 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_start: idle\n")); 353 354 aic_outb(aic, SIMODE0, ENSELDI); 355 aic_outb(aic, SIMODE1, ENSCSIRST); 356 aic_outb(aic, SCSISEQ, ENRESELI); 357 } 358 359 /* 360 * Start a selection. 361 */ 362 static void 363 aic_select(struct aic_softc *aic) 364 { 365 struct aic_scb *scb = aic->nexus; 366 367 CAM_DEBUG(scb->ccb->ccb_h.path, CAM_DEBUG_TRACE, 368 ("aic_select - ccb %p\n", scb->ccb)); 369 370 aic->state = AIC_SELECTING; 371 372 aic_outb(aic, DMACNTRL1, 0); 373 aic_outb(aic, SCSIID, aic->initiator << OID_S | scb->target); 374 aic_outb(aic, SXFRCTL1, STIMO_256ms | ENSTIMER | 375 (aic->flags & AIC_PARITY_ENABLE ? ENSPCHK : 0)); 376 377 aic_outb(aic, SIMODE0, ENSELDI|ENSELDO); 378 aic_outb(aic, SIMODE1, ENSCSIRST|ENSELTIMO); 379 aic_outb(aic, SCSISEQ, ENRESELI|ENSELO|ENAUTOATNO); 380 } 381 382 /* 383 * We have successfully selected a target, prepare for the information 384 * transfer phases. 385 */ 386 static void 387 aic_selected(struct aic_softc *aic) 388 { 389 struct aic_scb *scb = aic->nexus; 390 union ccb *ccb = scb->ccb; 391 struct aic_tinfo *ti = &aic->tinfo[scb->target]; 392 393 CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, 394 ("aic_selected - ccb %p\n", ccb)); 395 396 aic->state = AIC_HASNEXUS; 397 398 if (scb->flags & SCB_DEVICE_RESET) { 399 aic->msg_buf[0] = MSG_BUS_DEV_RESET; 400 aic->msg_len = 1; 401 aic->msg_outq = AIC_MSG_MSGBUF; 402 } else { 403 aic->msg_outq = AIC_MSG_IDENTIFY; 404 if ((ti->flags & TINFO_TAG_ENB) != 0 && 405 (ccb->ccb_h.flags & CAM_TAG_ACTION_VALID) != 0) 406 aic->msg_outq |= AIC_MSG_TAG_Q; 407 else 408 ti->lubusy |= 1 << scb->lun; 409 if ((ti->flags & TINFO_SDTR_NEGO) != 0) 410 aic->msg_outq |= AIC_MSG_SDTR; 411 } 412 413 aic_outb(aic, CLRSINT0, CLRSELDO); 414 aic_outb(aic, CLRSINT1, CLRBUSFREE); 415 aic_outb(aic, SCSISEQ, ENAUTOATNP); 416 aic_outb(aic, SIMODE0, 0); 417 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT); 418 aic_outb(aic, SCSIRATE, ti->scsirate); 419 } 420 421 /* 422 * We are re-selected by a target, save the target id and wait for the 423 * target to further identify itself. 424 */ 425 static void 426 aic_reselected(struct aic_softc *aic) 427 { 428 u_int8_t selid; 429 430 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_reselected\n")); 431 432 /* 433 * If we have started a selection, it must have lost out in 434 * the arbitration, put the command back to the pending queue. 435 */ 436 if (aic->nexus) { 437 TAILQ_INSERT_HEAD(&aic->pending_ccbs, 438 &aic->nexus->ccb->ccb_h, sim_links.tqe); 439 aic->nexus = NULL; 440 } 441 442 selid = aic_inb(aic, SELID) & ~(1 << aic->initiator); 443 if (selid & (selid - 1)) { 444 /* this should never have happened */ 445 printf("aic_reselected: invalid selid %x\n", selid); 446 aic_reset(aic, /*initiate_reset*/TRUE); 447 return; 448 } 449 450 aic->state = AIC_RESELECTED; 451 aic->target = ffs(selid) - 1; 452 aic->lun = -1; 453 454 aic_outb(aic, CLRSINT0, CLRSELDI); 455 aic_outb(aic, CLRSINT1, CLRBUSFREE); 456 aic_outb(aic, SIMODE0, 0); 457 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT); 458 aic_outb(aic, SCSISEQ, ENAUTOATNP); 459 aic_outb(aic, SCSIRATE, aic->tinfo[aic->target].scsirate); 460 } 461 462 /* 463 * Raise ATNO to signal the target that we have a message for it. 464 */ 465 static __inline void 466 aic_sched_msgout(struct aic_softc *aic, u_int8_t msg) 467 { 468 if (msg) { 469 aic->msg_buf[0] = msg; 470 aic->msg_len = 1; 471 } 472 aic->msg_outq |= AIC_MSG_MSGBUF; 473 aic_outb(aic, SCSISIGO, aic_inb(aic, SCSISIGI) | ATNO); 474 } 475 476 /* 477 * Wait for SPIORDY (SCSI PIO ready) flag, or a phase change. 478 */ 479 static __inline int 480 aic_spiordy(struct aic_softc *aic) 481 { 482 while (!(aic_inb(aic, DMASTAT) & INTSTAT) && 483 !(aic_inb(aic, SSTAT0) & SPIORDY)) 484 ; 485 return !(aic_inb(aic, DMASTAT) & INTSTAT); 486 } 487 488 /* 489 * Reestablish a disconnected nexus. 490 */ 491 static void 492 aic_reconnect(struct aic_softc *aic, int tag) 493 { 494 struct aic_scb *scb; 495 struct ccb_hdr *ccb_h; 496 497 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_reconnect\n")); 498 499 /* Find the nexus */ 500 scb = NULL; 501 TAILQ_FOREACH(ccb_h, &aic->nexus_ccbs, sim_links.tqe) { 502 scb = (struct aic_scb *)ccb_h->ccb_scb_ptr; 503 if (scb->target == aic->target && scb->lun == aic->lun && 504 (tag == -1 || scb->tag == tag)) 505 break; 506 } 507 508 /* ABORT if nothing is found */ 509 if (!ccb_h) { 510 if (tag == -1) 511 aic_sched_msgout(aic, MSG_ABORT); 512 else 513 aic_sched_msgout(aic, MSG_ABORT_TAG); 514 xpt_async(AC_UNSOL_RESEL, aic->path, NULL); 515 return; 516 } 517 518 /* Reestablish the nexus */ 519 TAILQ_REMOVE(&aic->nexus_ccbs, ccb_h, sim_links.tqe); 520 aic->nexus = scb; 521 scb->flags &= ~SCB_DISCONNECTED; 522 aic->state = AIC_HASNEXUS; 523 } 524 525 /* 526 * Read messages. 527 */ 528 static void 529 aic_msgin(struct aic_softc *aic) 530 { 531 int msglen; 532 533 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_msgin\n")); 534 535 aic_outb(aic, SIMODE1, ENSCSIRST|ENPHASEMIS|ENBUSFREE); 536 aic_outb(aic, SXFRCTL0, CHEN|SPIOEN); 537 538 aic->flags &= ~AIC_DROP_MSGIN; 539 aic->msg_len = 0; 540 do { 541 /* 542 * If a parity error is detected, drop the remaining 543 * bytes and inform the target so it could resend 544 * the messages. 545 */ 546 if (aic_inb(aic, SSTAT1) & SCSIPERR) { 547 aic_outb(aic, CLRSINT1, CLRSCSIPERR); 548 aic->flags |= AIC_DROP_MSGIN; 549 aic_sched_msgout(aic, MSG_PARITY_ERROR); 550 } 551 if ((aic->flags & AIC_DROP_MSGIN)) { 552 aic_inb(aic, SCSIDAT); 553 continue; 554 } 555 /* read the message byte without ACKing on it */ 556 aic->msg_buf[aic->msg_len++] = aic_inb(aic, SCSIBUS); 557 if (aic->msg_buf[0] == MSG_EXTENDED) { 558 if (aic->msg_len < 2) { 559 (void) aic_inb(aic, SCSIDAT); 560 continue; 561 } 562 switch (aic->msg_buf[2]) { 563 case MSG_EXT_SDTR: 564 msglen = MSG_EXT_SDTR_LEN; 565 break; 566 case MSG_EXT_WDTR: 567 msglen = MSG_EXT_WDTR_LEN; 568 break; 569 default: 570 msglen = 0; 571 break; 572 } 573 if (aic->msg_buf[1] != msglen) { 574 aic->flags |= AIC_DROP_MSGIN; 575 aic_sched_msgout(aic, MSG_MESSAGE_REJECT); 576 } 577 msglen += 2; 578 } else if (aic->msg_buf[0] >= 0x20 && aic->msg_buf[0] <= 0x2f) 579 msglen = 2; 580 else 581 msglen = 1; 582 /* 583 * If we have a complete message, handle it before the final 584 * ACK (in case we decide to reject the message). 585 */ 586 if (aic->msg_len == msglen) { 587 aic_handle_msgin(aic); 588 aic->msg_len = 0; 589 } 590 /* ACK on the message byte */ 591 (void) aic_inb(aic, SCSIDAT); 592 } while (aic_spiordy(aic)); 593 594 aic_outb(aic, SXFRCTL0, CHEN); 595 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT); 596 } 597 598 /* 599 * Handle a message. 600 */ 601 static void 602 aic_handle_msgin(struct aic_softc *aic) 603 { 604 struct aic_scb *scb; 605 struct ccb_hdr *ccb_h; 606 struct aic_tinfo *ti; 607 struct ccb_trans_settings neg; 608 struct ccb_trans_settings_spi *spi = &neg.xport_specific.spi; 609 610 if (aic->state == AIC_RESELECTED) { 611 if (!MSG_ISIDENTIFY(aic->msg_buf[0])) { 612 aic_sched_msgout(aic, MSG_MESSAGE_REJECT); 613 return; 614 } 615 aic->lun = aic->msg_buf[0] & MSG_IDENTIFY_LUNMASK; 616 if (aic->tinfo[aic->target].lubusy & (1 << aic->lun)) 617 aic_reconnect(aic, -1); 618 else 619 aic->state = AIC_RECONNECTING; 620 return; 621 } 622 623 if (aic->state == AIC_RECONNECTING) { 624 if (aic->msg_buf[0] != MSG_SIMPLE_Q_TAG) { 625 aic_sched_msgout(aic, MSG_MESSAGE_REJECT); 626 return; 627 } 628 aic_reconnect(aic, aic->msg_buf[1]); 629 return; 630 } 631 632 switch (aic->msg_buf[0]) { 633 case MSG_CMDCOMPLETE: { 634 struct ccb_scsiio *csio; 635 scb = aic->nexus; 636 ccb_h = &scb->ccb->ccb_h; 637 csio = &scb->ccb->csio; 638 if ((scb->flags & SCB_SENSE) != 0) { 639 /* auto REQUEST SENSE command */ 640 scb->flags &= ~SCB_SENSE; 641 csio->sense_resid = scb->data_len; 642 if (scb->status == SCSI_STATUS_OK) { 643 ccb_h->status |= 644 CAM_SCSI_STATUS_ERROR|CAM_AUTOSNS_VALID; 645 /*scsi_sense_print(csio);*/ 646 } else { 647 ccb_h->status |= CAM_AUTOSENSE_FAIL; 648 printf("ccb %p sense failed %x\n", 649 ccb_h, scb->status); 650 } 651 } else { 652 csio->scsi_status = scb->status; 653 csio->resid = scb->data_len; 654 if (scb->status == SCSI_STATUS_OK) { 655 /* everything goes well */ 656 ccb_h->status |= CAM_REQ_CMP; 657 } else if ((ccb_h->flags & CAM_DIS_AUTOSENSE) == 0 && 658 (csio->scsi_status == SCSI_STATUS_CHECK_COND || 659 csio->scsi_status == SCSI_STATUS_CMD_TERMINATED)) { 660 /* try to retrieve sense information */ 661 scb->flags |= SCB_SENSE; 662 aic->flags |= AIC_BUSFREE_OK; 663 return; 664 } else 665 ccb_h->status |= CAM_SCSI_STATUS_ERROR; 666 } 667 aic_done(aic, scb); 668 aic->flags |= AIC_BUSFREE_OK; 669 break; 670 } 671 case MSG_EXTENDED: 672 switch (aic->msg_buf[2]) { 673 case MSG_EXT_SDTR: 674 scb = aic->nexus; 675 ti = &aic->tinfo[scb->target]; 676 if (ti->flags & TINFO_SDTR_SENT) { 677 ti->current.period = aic->msg_buf[3]; 678 ti->current.offset = aic->msg_buf[4]; 679 } else { 680 ti->current.period = aic->msg_buf[3] = 681 max(ti->goal.period, aic->msg_buf[3]); 682 ti->current.offset = aic->msg_buf[4] = 683 min(ti->goal.offset, aic->msg_buf[4]); 684 /* 685 * The target initiated the negotiation, 686 * send back a response. 687 */ 688 aic_sched_msgout(aic, 0); 689 } 690 ti->flags &= ~(TINFO_SDTR_SENT|TINFO_SDTR_NEGO); 691 ti->scsirate = ti->current.offset ? ti->current.offset | 692 ((ti->current.period * 4 + 49) / 50 - 2) << 4 : 0; 693 aic_outb(aic, SCSIRATE, ti->scsirate); 694 memset(&neg, 0, sizeof (neg)); 695 neg.protocol = PROTO_SCSI; 696 neg.protocol_version = SCSI_REV_2; 697 neg.transport = XPORT_SPI; 698 neg.transport_version = 2; 699 spi->sync_period = ti->goal.period = ti->current.period; 700 spi->sync_offset = ti->goal.offset = ti->current.offset; 701 spi->valid = CTS_SPI_VALID_SYNC_RATE 702 | CTS_SPI_VALID_SYNC_OFFSET; 703 ccb_h = &scb->ccb->ccb_h; 704 xpt_setup_ccb(&neg.ccb_h, ccb_h->path, 1); 705 xpt_async(AC_TRANSFER_NEG, ccb_h->path, &neg); 706 break; 707 case MSG_EXT_WDTR: 708 default: 709 aic_sched_msgout(aic, MSG_MESSAGE_REJECT); 710 break; 711 } 712 break; 713 case MSG_DISCONNECT: 714 scb = aic->nexus; 715 ccb_h = &scb->ccb->ccb_h; 716 TAILQ_INSERT_TAIL(&aic->nexus_ccbs, ccb_h, sim_links.tqe); 717 scb->flags |= SCB_DISCONNECTED; 718 aic->flags |= AIC_BUSFREE_OK; 719 aic->nexus = NULL; 720 CAM_DEBUG(ccb_h->path, CAM_DEBUG_TRACE, ("disconnected\n")); 721 break; 722 case MSG_MESSAGE_REJECT: 723 switch (aic->msg_outq & -aic->msg_outq) { 724 case AIC_MSG_TAG_Q: 725 scb = aic->nexus; 726 ti = &aic->tinfo[scb->target]; 727 ti->flags &= ~TINFO_TAG_ENB; 728 ti->lubusy |= 1 << scb->lun; 729 break; 730 case AIC_MSG_SDTR: 731 scb = aic->nexus; 732 ti = &aic->tinfo[scb->target]; 733 ti->current.period = ti->goal.period = 0; 734 ti->current.offset = ti->goal.offset = 0; 735 ti->flags &= ~(TINFO_SDTR_SENT|TINFO_SDTR_NEGO); 736 ti->scsirate = 0; 737 aic_outb(aic, SCSIRATE, ti->scsirate); 738 memset(&neg, 0, sizeof (neg)); 739 neg.protocol = PROTO_SCSI; 740 neg.protocol_version = SCSI_REV_2; 741 neg.transport = XPORT_SPI; 742 neg.transport_version = 2; 743 spi->sync_period = ti->current.period; 744 spi->sync_offset = ti->current.offset; 745 spi->valid = CTS_SPI_VALID_SYNC_RATE 746 | CTS_SPI_VALID_SYNC_OFFSET; 747 ccb_h = &scb->ccb->ccb_h; 748 xpt_setup_ccb(&neg.ccb_h, ccb_h->path, 1); 749 xpt_async(AC_TRANSFER_NEG, ccb_h->path, &neg); 750 break; 751 default: 752 break; 753 } 754 break; 755 case MSG_SAVEDATAPOINTER: 756 break; 757 case MSG_RESTOREPOINTERS: 758 break; 759 case MSG_NOOP: 760 break; 761 default: 762 aic_sched_msgout(aic, MSG_MESSAGE_REJECT); 763 break; 764 } 765 } 766 767 /* 768 * Send messages. 769 */ 770 static void 771 aic_msgout(struct aic_softc *aic) 772 { 773 struct aic_scb *scb; 774 union ccb *ccb; 775 struct aic_tinfo *ti; 776 int msgidx = 0; 777 778 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_msgout\n")); 779 780 aic_outb(aic, SIMODE1, ENSCSIRST|ENPHASEMIS|ENBUSFREE); 781 aic_outb(aic, SXFRCTL0, CHEN|SPIOEN); 782 783 /* 784 * If the previous phase is also the message out phase, 785 * we need to retransmit all the messages, probably 786 * because the target has detected a parity error during 787 * the past transmission. 788 */ 789 if (aic->prev_phase == PH_MSGOUT) 790 aic->msg_outq = aic->msg_sent; 791 792 do { 793 int q = aic->msg_outq; 794 if (msgidx > 0 && msgidx == aic->msg_len) { 795 /* complete message sent, start the next one */ 796 q &= -q; 797 aic->msg_sent |= q; 798 aic->msg_outq ^= q; 799 q = aic->msg_outq; 800 msgidx = 0; 801 } 802 if (msgidx == 0) { 803 /* setup the message */ 804 switch (q & -q) { 805 case AIC_MSG_IDENTIFY: 806 scb = aic->nexus; 807 ccb = scb->ccb; 808 ti = &aic->tinfo[scb->target]; 809 aic->msg_buf[0] = MSG_IDENTIFY(scb->lun, 810 (ti->flags & TINFO_DISC_ENB) && 811 !(ccb->ccb_h.flags & CAM_DIS_DISCONNECT)); 812 aic->msg_len = 1; 813 break; 814 case AIC_MSG_TAG_Q: 815 scb = aic->nexus; 816 ccb = scb->ccb; 817 aic->msg_buf[0] = ccb->csio.tag_action; 818 aic->msg_buf[1] = scb->tag; 819 aic->msg_len = 2; 820 break; 821 case AIC_MSG_SDTR: 822 scb = aic->nexus; 823 ti = &aic->tinfo[scb->target]; 824 aic->msg_buf[0] = MSG_EXTENDED; 825 aic->msg_buf[1] = MSG_EXT_SDTR_LEN; 826 aic->msg_buf[2] = MSG_EXT_SDTR; 827 aic->msg_buf[3] = ti->goal.period; 828 aic->msg_buf[4] = ti->goal.offset; 829 aic->msg_len = MSG_EXT_SDTR_LEN + 2; 830 ti->flags |= TINFO_SDTR_SENT; 831 break; 832 case AIC_MSG_MSGBUF: 833 /* a single message already in the buffer */ 834 if (aic->msg_buf[0] == MSG_BUS_DEV_RESET || 835 aic->msg_buf[0] == MSG_ABORT || 836 aic->msg_buf[0] == MSG_ABORT_TAG) 837 aic->flags |= AIC_BUSFREE_OK; 838 break; 839 } 840 } 841 /* 842 * If this is the last message byte of all messages, 843 * clear ATNO to signal transmission complete. 844 */ 845 if ((q & (q - 1)) == 0 && msgidx == aic->msg_len - 1) 846 aic_outb(aic, CLRSINT1, CLRATNO); 847 /* transmit the message byte */ 848 aic_outb(aic, SCSIDAT, aic->msg_buf[msgidx++]); 849 } while (aic_spiordy(aic)); 850 851 aic_outb(aic, SXFRCTL0, CHEN); 852 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT); 853 } 854 855 /* 856 * Read data bytes. 857 */ 858 static void 859 aic_datain(struct aic_softc *aic) 860 { 861 struct aic_scb *scb = aic->nexus; 862 u_int8_t dmastat, dmacntrl0; 863 int n; 864 865 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_datain\n")); 866 867 aic_outb(aic, SIMODE1, ENSCSIRST|ENPHASEMIS|ENBUSFREE); 868 aic_outb(aic, SXFRCTL0, SCSIEN|DMAEN|CHEN); 869 870 dmacntrl0 = ENDMA; 871 if (aic->flags & AIC_DWIO_ENABLE) 872 dmacntrl0 |= DWORDPIO; 873 aic_outb(aic, DMACNTRL0, dmacntrl0); 874 875 while (scb->data_len > 0) { 876 for (;;) { 877 /* wait for the fifo to fill up or a phase change */ 878 dmastat = aic_inb(aic, DMASTAT); 879 if (dmastat & (INTSTAT|DFIFOFULL)) 880 break; 881 } 882 if (dmastat & DFIFOFULL) { 883 n = FIFOSIZE; 884 } else { 885 /* 886 * No more data, wait for the remaining bytes in 887 * the scsi fifo to be transfer to the host fifo. 888 */ 889 while (!(aic_inb(aic, SSTAT2) & SEMPTY)) 890 ; 891 n = aic_inb(aic, FIFOSTAT); 892 } 893 n = imin(scb->data_len, n); 894 if (aic->flags & AIC_DWIO_ENABLE) { 895 if (n >= 12) { 896 aic_insl(aic, DMADATALONG, scb->data_ptr, n>>2); 897 scb->data_ptr += n & ~3; 898 scb->data_len -= n & ~3; 899 n &= 3; 900 } 901 } else { 902 if (n >= 8) { 903 aic_insw(aic, DMADATA, scb->data_ptr, n >> 1); 904 scb->data_ptr += n & ~1; 905 scb->data_len -= n & ~1; 906 n &= 1; 907 } 908 } 909 if (n) { 910 aic_outb(aic, DMACNTRL0, ENDMA|B8MODE); 911 aic_insb(aic, DMADATA, scb->data_ptr, n); 912 scb->data_ptr += n; 913 scb->data_len -= n; 914 aic_outb(aic, DMACNTRL0, dmacntrl0); 915 } 916 917 if (dmastat & INTSTAT) 918 break; 919 } 920 921 aic_outb(aic, SXFRCTL0, CHEN); 922 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT); 923 } 924 925 /* 926 * Send data bytes. 927 */ 928 static void 929 aic_dataout(struct aic_softc *aic) 930 { 931 struct aic_scb *scb = aic->nexus; 932 u_int8_t dmastat, dmacntrl0, sstat2; 933 int n; 934 935 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_dataout\n")); 936 937 aic_outb(aic, SIMODE1, ENSCSIRST|ENPHASEMIS|ENBUSFREE); 938 aic_outb(aic, SXFRCTL0, SCSIEN|DMAEN|CHEN); 939 940 dmacntrl0 = ENDMA|WRITE; 941 if (aic->flags & AIC_DWIO_ENABLE) 942 dmacntrl0 |= DWORDPIO; 943 aic_outb(aic, DMACNTRL0, dmacntrl0); 944 945 while (scb->data_len > 0) { 946 for (;;) { 947 /* wait for the fifo to clear up or a phase change */ 948 dmastat = aic_inb(aic, DMASTAT); 949 if (dmastat & (INTSTAT|DFIFOEMP)) 950 break; 951 } 952 if (dmastat & INTSTAT) 953 break; 954 n = imin(scb->data_len, FIFOSIZE); 955 if (aic->flags & AIC_DWIO_ENABLE) { 956 if (n >= 12) { 957 aic_outsl(aic, DMADATALONG, scb->data_ptr,n>>2); 958 scb->data_ptr += n & ~3; 959 scb->data_len -= n & ~3; 960 n &= 3; 961 } 962 } else { 963 if (n >= 8) { 964 aic_outsw(aic, DMADATA, scb->data_ptr, n >> 1); 965 scb->data_ptr += n & ~1; 966 scb->data_len -= n & ~1; 967 n &= 1; 968 } 969 } 970 if (n) { 971 aic_outb(aic, DMACNTRL0, ENDMA|WRITE|B8MODE); 972 aic_outsb(aic, DMADATA, scb->data_ptr, n); 973 scb->data_ptr += n; 974 scb->data_len -= n; 975 aic_outb(aic, DMACNTRL0, dmacntrl0); 976 } 977 } 978 979 for (;;) { 980 /* wait until all bytes in the fifos are transmitted */ 981 dmastat = aic_inb(aic, DMASTAT); 982 sstat2 = aic_inb(aic, SSTAT2); 983 if ((dmastat & DFIFOEMP) && (sstat2 & SEMPTY)) 984 break; 985 if (dmastat & INTSTAT) { 986 /* adjust for untransmitted bytes */ 987 n = aic_inb(aic, FIFOSTAT) + (sstat2 & 0xf); 988 scb->data_ptr -= n; 989 scb->data_len += n; 990 /* clear the fifo */ 991 aic_outb(aic, SXFRCTL0, CHEN|CLRCH); 992 aic_outb(aic, DMACNTRL0, RSTFIFO); 993 break; 994 } 995 } 996 997 aic_outb(aic, SXFRCTL0, CHEN); 998 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT); 999 } 1000 1001 /* 1002 * Send the scsi command. 1003 */ 1004 static void 1005 aic_cmd(struct aic_softc *aic) 1006 { 1007 struct aic_scb *scb = aic->nexus; 1008 struct scsi_request_sense sense_cmd; 1009 1010 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_cmd\n")); 1011 1012 if (scb->flags & SCB_SENSE) { 1013 /* autosense request */ 1014 sense_cmd.opcode = REQUEST_SENSE; 1015 sense_cmd.byte2 = scb->lun << 5; 1016 sense_cmd.length = scb->ccb->csio.sense_len; 1017 sense_cmd.control = 0; 1018 sense_cmd.unused[0] = 0; 1019 sense_cmd.unused[1] = 0; 1020 scb->cmd_ptr = (u_int8_t *)&sense_cmd; 1021 scb->cmd_len = sizeof(sense_cmd); 1022 scb->data_ptr = (u_int8_t *)&scb->ccb->csio.sense_data; 1023 scb->data_len = scb->ccb->csio.sense_len; 1024 } 1025 1026 aic_outb(aic, SIMODE1, ENSCSIRST|ENPHASEMIS|ENBUSFREE); 1027 aic_outb(aic, DMACNTRL0, ENDMA|WRITE); 1028 aic_outb(aic, SXFRCTL0, SCSIEN|DMAEN|CHEN); 1029 aic_outsw(aic, DMADATA, (u_int16_t *)scb->cmd_ptr, scb->cmd_len >> 1); 1030 while ((aic_inb(aic, SSTAT2) & SEMPTY) == 0 && 1031 (aic_inb(aic, DMASTAT) & INTSTAT) == 0) 1032 ; 1033 aic_outb(aic, SXFRCTL0, CHEN); 1034 aic_outb(aic, SIMODE1, ENSCSIRST|ENBUSFREE|ENREQINIT); 1035 } 1036 1037 /* 1038 * Finish off a command. The caller is responsible to remove the ccb 1039 * from any queue. 1040 */ 1041 static void 1042 aic_done(struct aic_softc *aic, struct aic_scb *scb) 1043 { 1044 union ccb *ccb = scb->ccb; 1045 1046 CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, 1047 ("aic_done - ccb %p status %x resid %d\n", 1048 ccb, ccb->ccb_h.status, ccb->csio.resid)); 1049 1050 callout_stop(&scb->timer); 1051 1052 if ((scb->flags & SCB_DEVICE_RESET) != 0 && 1053 ccb->ccb_h.func_code != XPT_RESET_DEV) { 1054 struct cam_path *path; 1055 struct ccb_hdr *ccb_h; 1056 cam_status error; 1057 1058 error = xpt_create_path(&path, /*periph*/NULL, 1059 cam_sim_path(aic->sim), 1060 scb->target, 1061 CAM_LUN_WILDCARD); 1062 1063 if (error == CAM_REQ_CMP) { 1064 xpt_async(AC_SENT_BDR, path, NULL); 1065 xpt_free_path(path); 1066 } 1067 1068 ccb_h = TAILQ_FIRST(&aic->pending_ccbs); 1069 while (ccb_h != NULL) { 1070 struct aic_scb *pending_scb; 1071 1072 pending_scb = (struct aic_scb *)ccb_h->ccb_scb_ptr; 1073 if (ccb_h->target_id == scb->target) { 1074 ccb_h->status |= CAM_BDR_SENT; 1075 ccb_h = TAILQ_NEXT(ccb_h, sim_links.tqe); 1076 TAILQ_REMOVE(&aic->pending_ccbs, 1077 &pending_scb->ccb->ccb_h, sim_links.tqe); 1078 aic_done(aic, pending_scb); 1079 } else { 1080 callout_reset_sbt(&pending_scb->timer, 1081 SBT_1MS * ccb_h->timeout, 0, aic_timeout, 1082 pending_scb, 0); 1083 ccb_h = TAILQ_NEXT(ccb_h, sim_links.tqe); 1084 } 1085 } 1086 1087 ccb_h = TAILQ_FIRST(&aic->nexus_ccbs); 1088 while (ccb_h != NULL) { 1089 struct aic_scb *nexus_scb; 1090 1091 nexus_scb = (struct aic_scb *)ccb_h->ccb_scb_ptr; 1092 if (ccb_h->target_id == scb->target) { 1093 ccb_h->status |= CAM_BDR_SENT; 1094 ccb_h = TAILQ_NEXT(ccb_h, sim_links.tqe); 1095 TAILQ_REMOVE(&aic->nexus_ccbs, 1096 &nexus_scb->ccb->ccb_h, sim_links.tqe); 1097 aic_done(aic, nexus_scb); 1098 } else { 1099 callout_reset_sbt(&nexus_scb->timer, 1100 SBT_1MS * ccb_h->timeout, 0, aic_timeout, 1101 nexus_scb, 0); 1102 ccb_h = TAILQ_NEXT(ccb_h, sim_links.tqe); 1103 } 1104 } 1105 } 1106 1107 if (aic->nexus == scb || scb->flags & SCB_DISCONNECTED) 1108 aic->tinfo[scb->target].lubusy &= ~(1 << scb->lun); 1109 1110 if (aic->nexus == scb) { 1111 aic->nexus = NULL; 1112 } 1113 aic_free_scb(aic, scb); 1114 xpt_done(ccb); 1115 } 1116 1117 static void 1118 aic_poll(struct cam_sim *sim) 1119 { 1120 aic_intr_locked(cam_sim_softc(sim)); 1121 } 1122 1123 static void 1124 aic_timeout(void *arg) 1125 { 1126 struct aic_scb *scb = (struct aic_scb *)arg; 1127 union ccb *ccb = scb->ccb; 1128 struct aic_softc *aic = (struct aic_softc *)ccb->ccb_h.ccb_aic_ptr; 1129 1130 mtx_assert(&aic->lock, MA_OWNED); 1131 xpt_print_path(ccb->ccb_h.path); 1132 printf("ccb %p - timed out", ccb); 1133 if (aic->nexus && aic->nexus != scb) 1134 printf(", nexus %p", aic->nexus->ccb); 1135 printf(", phase 0x%x, state %d\n", aic_inb(aic, SCSISIGI), aic->state); 1136 1137 if ((scb->flags & SCB_ACTIVE) == 0) { 1138 xpt_print_path(ccb->ccb_h.path); 1139 printf("ccb %p - timed out already completed\n", ccb); 1140 return; 1141 } 1142 1143 if ((scb->flags & SCB_DEVICE_RESET) == 0 && aic->nexus == scb) { 1144 struct ccb_hdr *ccb_h = &scb->ccb->ccb_h; 1145 struct aic_scb *pending_scb; 1146 1147 if ((ccb_h->status & CAM_RELEASE_SIMQ) == 0) { 1148 xpt_freeze_simq(aic->sim, /*count*/1); 1149 ccb_h->status |= CAM_RELEASE_SIMQ; 1150 } 1151 1152 TAILQ_FOREACH(ccb_h, &aic->pending_ccbs, sim_links.tqe) { 1153 pending_scb = ccb_h->ccb_scb_ptr; 1154 callout_stop(&pending_scb->timer); 1155 } 1156 1157 TAILQ_FOREACH(ccb_h, &aic->nexus_ccbs, sim_links.tqe) { 1158 pending_scb = ccb_h->ccb_scb_ptr; 1159 callout_stop(&pending_scb->timer); 1160 } 1161 1162 scb->flags |= SCB_DEVICE_RESET; 1163 callout_reset(&scb->timer, 5 * hz, aic_timeout, scb); 1164 aic_sched_msgout(aic, MSG_BUS_DEV_RESET); 1165 } else { 1166 if (aic->nexus == scb) { 1167 ccb->ccb_h.status |= CAM_CMD_TIMEOUT; 1168 aic_done(aic, scb); 1169 } 1170 aic_reset(aic, /*initiate_reset*/TRUE); 1171 } 1172 } 1173 1174 void 1175 aic_intr(void *arg) 1176 { 1177 struct aic_softc *aic = (struct aic_softc *)arg; 1178 1179 mtx_lock(&aic->lock); 1180 aic_intr_locked(aic); 1181 mtx_unlock(&aic->lock); 1182 } 1183 1184 void 1185 aic_intr_locked(struct aic_softc *aic) 1186 { 1187 u_int8_t sstat0, sstat1; 1188 union ccb *ccb; 1189 struct aic_scb *scb; 1190 1191 if (!(aic_inb(aic, DMASTAT) & INTSTAT)) 1192 return; 1193 1194 aic_outb(aic, DMACNTRL0, 0); 1195 1196 sstat0 = aic_inb(aic, SSTAT0); 1197 sstat1 = aic_inb(aic, SSTAT1); 1198 1199 if ((sstat1 & SCSIRSTI) != 0) { 1200 /* a device-initiated bus reset */ 1201 aic_outb(aic, CLRSINT1, CLRSCSIRSTI); 1202 aic_reset(aic, /*initiate_reset*/FALSE); 1203 return; 1204 } 1205 1206 if ((sstat1 & SCSIPERR) != 0) { 1207 aic_outb(aic, CLRSINT1, CLRSCSIPERR); 1208 aic_sched_msgout(aic, MSG_PARITY_ERROR); 1209 aic_outb(aic, DMACNTRL0, INTEN); 1210 return; 1211 } 1212 1213 if (aic_inb(aic, SSTAT4)) { 1214 aic_outb(aic, CLRSERR, CLRSYNCERR|CLRFWERR|CLRFRERR); 1215 aic_reset(aic, /*initiate_reset*/TRUE); 1216 return; 1217 } 1218 1219 if (aic->state <= AIC_SELECTING) { 1220 if ((sstat0 & SELDI) != 0) { 1221 aic_reselected(aic); 1222 aic_outb(aic, DMACNTRL0, INTEN); 1223 return; 1224 } 1225 1226 if ((sstat0 & SELDO) != 0) { 1227 aic_selected(aic); 1228 aic_outb(aic, DMACNTRL0, INTEN); 1229 return; 1230 } 1231 1232 if ((sstat1 & SELTO) != 0) { 1233 scb = aic->nexus; 1234 ccb = scb->ccb; 1235 ccb->ccb_h.status = CAM_SEL_TIMEOUT; 1236 aic_done(aic, scb); 1237 while ((sstat1 & BUSFREE) == 0) 1238 sstat1 = aic_inb(aic, SSTAT1); 1239 aic->flags |= AIC_BUSFREE_OK; 1240 } 1241 } 1242 1243 if ((sstat1 & BUSFREE) != 0) { 1244 aic_outb(aic, SCSISEQ, 0); 1245 aic_outb(aic, CLRSINT0, sstat0); 1246 aic_outb(aic, CLRSINT1, sstat1); 1247 if ((scb = aic->nexus)) { 1248 if ((aic->flags & AIC_BUSFREE_OK) == 0) { 1249 ccb = scb->ccb; 1250 ccb->ccb_h.status = CAM_UNEXP_BUSFREE; 1251 aic_done(aic, scb); 1252 } else if (scb->flags & SCB_DEVICE_RESET) { 1253 ccb = scb->ccb; 1254 if (ccb->ccb_h.func_code == XPT_RESET_DEV) { 1255 xpt_async(AC_SENT_BDR, 1256 ccb->ccb_h.path, NULL); 1257 ccb->ccb_h.status |= CAM_REQ_CMP; 1258 } else 1259 ccb->ccb_h.status |= CAM_CMD_TIMEOUT; 1260 aic_done(aic, scb); 1261 } else if (scb->flags & SCB_SENSE) { 1262 /* autosense request */ 1263 aic->flags &= ~AIC_BUSFREE_OK; 1264 aic->tinfo[scb->target].lubusy &= 1265 ~(1 << scb->lun); 1266 aic_select(aic); 1267 aic_outb(aic, DMACNTRL0, INTEN); 1268 return; 1269 } 1270 } 1271 aic->flags &= ~AIC_BUSFREE_OK; 1272 aic->state = AIC_IDLE; 1273 aic_start(aic); 1274 aic_outb(aic, DMACNTRL0, INTEN); 1275 return; 1276 } 1277 1278 if ((sstat1 & REQINIT) != 0) { 1279 u_int8_t phase = aic_inb(aic, SCSISIGI) & PH_MASK; 1280 aic_outb(aic, SCSISIGO, phase); 1281 aic_outb(aic, CLRSINT1, CLRPHASECHG); 1282 1283 switch (phase) { 1284 case PH_MSGOUT: 1285 aic_msgout(aic); 1286 break; 1287 case PH_MSGIN: 1288 aic_msgin(aic); 1289 break; 1290 case PH_STAT: 1291 scb = aic->nexus; 1292 ccb = scb->ccb; 1293 aic_outb(aic, DMACNTRL0, 0); 1294 aic_outb(aic, SXFRCTL0, CHEN|SPIOEN); 1295 scb->status = aic_inb(aic, SCSIDAT); 1296 aic_outb(aic, SXFRCTL0, CHEN); 1297 break; 1298 case PH_CMD: 1299 aic_cmd(aic); 1300 break; 1301 case PH_DATAIN: 1302 aic_datain(aic); 1303 break; 1304 case PH_DATAOUT: 1305 aic_dataout(aic); 1306 break; 1307 } 1308 aic->prev_phase = phase; 1309 aic_outb(aic, DMACNTRL0, INTEN); 1310 return; 1311 } 1312 1313 printf("aic_intr: unexpected intr sstat0 %x sstat1 %x\n", 1314 sstat0, sstat1); 1315 aic_outb(aic, DMACNTRL0, INTEN); 1316 } 1317 1318 /* 1319 * Reset ourselves. 1320 */ 1321 static void 1322 aic_chip_reset(struct aic_softc *aic) 1323 { 1324 /* 1325 * Doc. recommends to clear these two registers before 1326 * operations commence 1327 */ 1328 aic_outb(aic, SCSITEST, 0); 1329 aic_outb(aic, TEST, 0); 1330 1331 /* Reset SCSI-FIFO and abort any transfers */ 1332 aic_outb(aic, SXFRCTL0, CHEN|CLRCH|CLRSTCNT); 1333 1334 /* Reset HOST-FIFO */ 1335 aic_outb(aic, DMACNTRL0, RSTFIFO); 1336 aic_outb(aic, DMACNTRL1, 0); 1337 1338 /* Disable all selection features */ 1339 aic_outb(aic, SCSISEQ, 0); 1340 aic_outb(aic, SXFRCTL1, 0); 1341 1342 /* Disable interrupts */ 1343 aic_outb(aic, SIMODE0, 0); 1344 aic_outb(aic, SIMODE1, 0); 1345 1346 /* Clear interrupts */ 1347 aic_outb(aic, CLRSINT0, 0x7f); 1348 aic_outb(aic, CLRSINT1, 0xef); 1349 1350 /* Disable synchronous transfers */ 1351 aic_outb(aic, SCSIRATE, 0); 1352 1353 /* Haven't seen ant errors (yet) */ 1354 aic_outb(aic, CLRSERR, 0x07); 1355 1356 /* Set our SCSI-ID */ 1357 aic_outb(aic, SCSIID, aic->initiator << OID_S); 1358 aic_outb(aic, BRSTCNTRL, EISA_BRST_TIM); 1359 } 1360 1361 /* 1362 * Reset the SCSI bus 1363 */ 1364 static void 1365 aic_scsi_reset(struct aic_softc *aic) 1366 { 1367 aic_outb(aic, SCSISEQ, SCSIRSTO); 1368 DELAY(500); 1369 aic_outb(aic, SCSISEQ, 0); 1370 DELAY(50); 1371 } 1372 1373 /* 1374 * Reset. Abort all pending commands. 1375 */ 1376 static void 1377 aic_reset(struct aic_softc *aic, int initiate_reset) 1378 { 1379 struct ccb_hdr *ccb_h; 1380 1381 CAM_DEBUG_PRINT(CAM_DEBUG_TRACE, ("aic_reset\n")); 1382 1383 if (initiate_reset) 1384 aic_scsi_reset(aic); 1385 aic_chip_reset(aic); 1386 1387 xpt_async(AC_BUS_RESET, aic->path, NULL); 1388 1389 while ((ccb_h = TAILQ_FIRST(&aic->pending_ccbs)) != NULL) { 1390 TAILQ_REMOVE(&aic->pending_ccbs, ccb_h, sim_links.tqe); 1391 ccb_h->status |= CAM_SCSI_BUS_RESET; 1392 aic_done(aic, (struct aic_scb *)ccb_h->ccb_scb_ptr); 1393 } 1394 1395 while ((ccb_h = TAILQ_FIRST(&aic->nexus_ccbs)) != NULL) { 1396 TAILQ_REMOVE(&aic->nexus_ccbs, ccb_h, sim_links.tqe); 1397 ccb_h->status |= CAM_SCSI_BUS_RESET; 1398 aic_done(aic, (struct aic_scb *)ccb_h->ccb_scb_ptr); 1399 } 1400 1401 if (aic->nexus) { 1402 ccb_h = &aic->nexus->ccb->ccb_h; 1403 ccb_h->status |= CAM_SCSI_BUS_RESET; 1404 aic_done(aic, aic->nexus); 1405 } 1406 1407 aic->state = AIC_IDLE; 1408 aic_outb(aic, DMACNTRL0, INTEN); 1409 } 1410 1411 static char *aic_chip_names[] = { 1412 "AIC6260", "AIC6360", "AIC6370", "GM82C700", 1413 }; 1414 1415 static struct { 1416 int type; 1417 char *idstring; 1418 } aic_chip_ids[] = { 1419 { AIC6360, IDSTRING_AIC6360 }, 1420 { AIC6370, IDSTRING_AIC6370 }, 1421 { GM82C700, IDSTRING_GM82C700 }, 1422 }; 1423 1424 static void 1425 aic_init(struct aic_softc *aic) 1426 { 1427 struct aic_scb *scb; 1428 struct aic_tinfo *ti; 1429 u_int8_t porta, portb; 1430 char chip_id[33]; 1431 int i; 1432 1433 TAILQ_INIT(&aic->pending_ccbs); 1434 TAILQ_INIT(&aic->nexus_ccbs); 1435 SLIST_INIT(&aic->free_scbs); 1436 aic->nexus = NULL; 1437 aic->state = AIC_IDLE; 1438 aic->prev_phase = -1; 1439 aic->flags = 0; 1440 1441 aic_chip_reset(aic); 1442 aic_scsi_reset(aic); 1443 1444 /* determine the chip type from its ID string */ 1445 aic->chip_type = AIC6260; 1446 aic_insb(aic, ID, chip_id, sizeof(chip_id) - 1); 1447 chip_id[sizeof(chip_id) - 1] = '\0'; 1448 for (i = 0; i < nitems(aic_chip_ids); i++) { 1449 if (!strcmp(chip_id, aic_chip_ids[i].idstring)) { 1450 aic->chip_type = aic_chip_ids[i].type; 1451 break; 1452 } 1453 } 1454 1455 porta = aic_inb(aic, PORTA); 1456 portb = aic_inb(aic, PORTB); 1457 1458 aic->initiator = PORTA_ID(porta); 1459 if (PORTA_PARITY(porta)) 1460 aic->flags |= AIC_PARITY_ENABLE; 1461 if (PORTB_DISC(portb)) 1462 aic->flags |= AIC_DISC_ENABLE; 1463 if (PORTB_DMA(portb)) 1464 aic->flags |= AIC_DMA_ENABLE; 1465 1466 /* 1467 * We can do fast SCSI (10MHz clock rate) if bit 4 of portb 1468 * is set and we've got a 6360. The 6260 can only do standard 1469 * 5MHz SCSI. 1470 */ 1471 if (aic->chip_type > AIC6260 || aic_inb(aic, REV)) { 1472 if (PORTB_FSYNC(portb)) 1473 aic->flags |= AIC_FAST_ENABLE; 1474 aic->flags |= AIC_DWIO_ENABLE; 1475 } 1476 1477 if (aic->flags & AIC_FAST_ENABLE) 1478 aic->max_period = AIC_FAST_SYNC_PERIOD; 1479 else 1480 aic->max_period = AIC_SYNC_PERIOD; 1481 aic->min_period = AIC_MIN_SYNC_PERIOD; 1482 1483 for (i = 255; i >= 0; i--) { 1484 scb = &aic->scbs[i]; 1485 scb->tag = i; 1486 callout_init_mtx(&scb->timer, &aic->lock, 0); 1487 aic_free_scb(aic, scb); 1488 } 1489 1490 for (i = 0; i < 8; i++) { 1491 if (i == aic->initiator) 1492 continue; 1493 ti = &aic->tinfo[i]; 1494 bzero(ti, sizeof(*ti)); 1495 ti->flags = TINFO_TAG_ENB; 1496 if (aic->flags & AIC_DISC_ENABLE) 1497 ti->flags |= TINFO_DISC_ENB; 1498 ti->user.period = aic->max_period; 1499 ti->user.offset = AIC_SYNC_OFFSET; 1500 ti->scsirate = 0; 1501 } 1502 1503 aic_outb(aic, DMACNTRL0, INTEN); 1504 } 1505 1506 int 1507 aic_probe(struct aic_softc *aic) 1508 { 1509 int i; 1510 1511 /* Remove aic6360 from possible powerdown mode */ 1512 aic_outb(aic, DMACNTRL0, 0); 1513 1514 #define STSIZE 16 1515 aic_outb(aic, DMACNTRL1, 0); /* Reset stack pointer */ 1516 for (i = 0; i < STSIZE; i++) 1517 aic_outb(aic, STACK, i); 1518 1519 /* See if we can pull out the same sequence */ 1520 aic_outb(aic, DMACNTRL1, 0); 1521 for (i = 0; i < STSIZE && aic_inb(aic, STACK) == i; i++) 1522 ; 1523 if (i != STSIZE) 1524 return (ENXIO); 1525 #undef STSIZE 1526 return (0); 1527 } 1528 1529 int 1530 aic_attach(struct aic_softc *aic) 1531 { 1532 struct cam_devq *devq; 1533 1534 /* 1535 * Create the device queue for our SIM. 1536 */ 1537 devq = cam_simq_alloc(256); 1538 if (devq == NULL) 1539 return (ENOMEM); 1540 1541 /* 1542 * Construct our SIM entry 1543 */ 1544 aic->sim = cam_sim_alloc(aic_action, aic_poll, "aic", aic, 1545 device_get_unit(aic->dev), &aic->lock, 2, 256, devq); 1546 if (aic->sim == NULL) { 1547 cam_simq_free(devq); 1548 return (ENOMEM); 1549 } 1550 1551 mtx_lock(&aic->lock); 1552 if (xpt_bus_register(aic->sim, aic->dev, 0) != CAM_SUCCESS) { 1553 cam_sim_free(aic->sim, /*free_devq*/TRUE); 1554 mtx_unlock(&aic->lock); 1555 return (ENXIO); 1556 } 1557 1558 if (xpt_create_path(&aic->path, /*periph*/NULL, 1559 cam_sim_path(aic->sim), CAM_TARGET_WILDCARD, 1560 CAM_LUN_WILDCARD) != CAM_REQ_CMP) { 1561 xpt_bus_deregister(cam_sim_path(aic->sim)); 1562 cam_sim_free(aic->sim, /*free_devq*/TRUE); 1563 mtx_unlock(&aic->lock); 1564 return (ENXIO); 1565 } 1566 1567 aic_init(aic); 1568 1569 device_printf(aic->dev, "%s", aic_chip_names[aic->chip_type]); 1570 if (aic->flags & AIC_DMA_ENABLE) 1571 printf(", dma"); 1572 if (aic->flags & AIC_DISC_ENABLE) 1573 printf(", disconnection"); 1574 if (aic->flags & AIC_PARITY_ENABLE) 1575 printf(", parity check"); 1576 if (aic->flags & AIC_FAST_ENABLE) 1577 printf(", fast SCSI"); 1578 printf("\n"); 1579 mtx_unlock(&aic->lock); 1580 gone_in_dev(aic->dev, 12, "aic(4) driver"); 1581 return (0); 1582 } 1583 1584 int 1585 aic_detach(struct aic_softc *aic) 1586 { 1587 struct aic_scb *scb; 1588 int i; 1589 1590 mtx_lock(&aic->lock); 1591 xpt_async(AC_LOST_DEVICE, aic->path, NULL); 1592 xpt_free_path(aic->path); 1593 xpt_bus_deregister(cam_sim_path(aic->sim)); 1594 cam_sim_free(aic->sim, /*free_devq*/TRUE); 1595 mtx_unlock(&aic->lock); 1596 for (i = 255; i >= 0; i--) { 1597 scb = &aic->scbs[i]; 1598 callout_drain(&scb->timer); 1599 } 1600 return (0); 1601 } 1602