1 /* $OpenBSD: iha.c,v 1.42 2012/02/04 21:44:54 krw Exp $ */ 2 /*------------------------------------------------------------------------- 3 * 4 * Device driver for the INI-9XXXU/UW or INIC-940/950 PCI SCSI Controller. 5 * 6 * Written for 386bsd and FreeBSD by 7 * Winston Hung <winstonh@initio.com> 8 * 9 * Copyright (c) 1997-1999 Initio Corp 10 * Copyright (c) 2000-2002 Ken Westerback 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer, 17 * without modification, immediately at the beginning of the file. 18 * 2. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT, 25 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 26 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 27 * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 29 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 30 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 31 * THE POSSIBILITY OF SUCH DAMAGE. 32 * 33 *------------------------------------------------------------------------- 34 */ 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/buf.h> 39 #include <sys/device.h> 40 41 #include <machine/bus.h> 42 #include <machine/intr.h> 43 44 #include <scsi/scsi_all.h> 45 #include <scsi/scsiconf.h> 46 #include <scsi/scsi_message.h> 47 48 #include <dev/ic/iha.h> 49 50 /* #define IHA_DEBUG_STATE */ 51 52 struct cfdriver iha_cd = { 53 NULL, "iha", DV_DULL 54 }; 55 56 struct scsi_adapter iha_switch = { 57 iha_scsi_cmd, /* scsi_cmd() */ 58 iha_minphys, /* scsi_minphys() */ 59 NULL, /* probe_dev(void) */ 60 NULL /* free_dev() */ 61 }; 62 63 /* 64 * SCSI Rate Table, indexed by FLAG_SCSI_RATE field of 65 * TCS_Flags. 66 */ 67 static const u_int8_t iha_rate_tbl[] = { 68 /* fast 20 */ 69 /* nanosecond divide by 4 */ 70 12, /* 50ns, 20M */ 71 18, /* 75ns, 13.3M */ 72 25, /* 100ns, 10M */ 73 31, /* 125ns, 8M */ 74 37, /* 150ns, 6.6M */ 75 43, /* 175ns, 5.7M */ 76 50, /* 200ns, 5M */ 77 62 /* 250ns, 4M */ 78 }; 79 80 int iha_setup_sg_list(struct iha_softc *, struct iha_scb *); 81 u_int8_t iha_data_over_run(struct iha_scb *); 82 int iha_push_sense_request(struct iha_softc *, struct iha_scb *); 83 void iha_timeout(void *); 84 int iha_alloc_scbs(struct iha_softc *); 85 void iha_read_eeprom(bus_space_tag_t, bus_space_handle_t, 86 struct iha_nvram *); 87 void iha_se2_instr(bus_space_tag_t, bus_space_handle_t, u_int8_t); 88 u_int16_t iha_se2_rd(bus_space_tag_t, bus_space_handle_t, u_int8_t); 89 void iha_reset_scsi_bus(struct iha_softc *); 90 void iha_reset_chip(struct iha_softc *, 91 bus_space_tag_t, bus_space_handle_t); 92 void iha_reset_dma(bus_space_tag_t, bus_space_handle_t); 93 void iha_reset_tcs(struct tcs *, u_int8_t); 94 void iha_print_info(struct iha_softc *, int); 95 void iha_done_scb(struct iha_softc *, struct iha_scb *); 96 void iha_exec_scb(struct iha_softc *, struct iha_scb *); 97 void iha_main(struct iha_softc *, bus_space_tag_t, bus_space_handle_t); 98 void iha_scsi(struct iha_softc *, bus_space_tag_t, bus_space_handle_t); 99 int iha_wait(struct iha_softc *, bus_space_tag_t, bus_space_handle_t, 100 u_int8_t); 101 void iha_mark_busy_scb(struct iha_scb *); 102 void *iha_scb_alloc(void *); 103 void iha_scb_free(void *, void *); 104 void iha_append_done_scb(struct iha_softc *, struct iha_scb *, 105 u_int8_t); 106 struct iha_scb *iha_pop_done_scb(struct iha_softc *); 107 void iha_append_pend_scb(struct iha_softc *, struct iha_scb *); 108 void iha_push_pend_scb(struct iha_softc *, struct iha_scb *); 109 struct iha_scb *iha_find_pend_scb(struct iha_softc *); 110 void iha_sync_done(struct iha_softc *, 111 bus_space_tag_t, bus_space_handle_t); 112 void iha_wide_done(struct iha_softc *, 113 bus_space_tag_t, bus_space_handle_t); 114 void iha_bad_seq(struct iha_softc *); 115 int iha_next_state(struct iha_softc *, 116 bus_space_tag_t, bus_space_handle_t); 117 int iha_state_1(struct iha_softc *, 118 bus_space_tag_t, bus_space_handle_t); 119 int iha_state_2(struct iha_softc *, 120 bus_space_tag_t, bus_space_handle_t); 121 int iha_state_3(struct iha_softc *, 122 bus_space_tag_t, bus_space_handle_t); 123 int iha_state_4(struct iha_softc *, 124 bus_space_tag_t, bus_space_handle_t); 125 int iha_state_5(struct iha_softc *, 126 bus_space_tag_t, bus_space_handle_t); 127 int iha_state_6(struct iha_softc *, 128 bus_space_tag_t, bus_space_handle_t); 129 int iha_state_8(struct iha_softc *, 130 bus_space_tag_t, bus_space_handle_t); 131 void iha_set_ssig(bus_space_tag_t, 132 bus_space_handle_t, u_int8_t, u_int8_t); 133 int iha_xpad_in(struct iha_softc *, 134 bus_space_tag_t, bus_space_handle_t); 135 int iha_xpad_out(struct iha_softc *, 136 bus_space_tag_t, bus_space_handle_t); 137 int iha_xfer_data(struct iha_scb *, 138 bus_space_tag_t, bus_space_handle_t, 139 int direction); 140 int iha_status_msg(struct iha_softc *, 141 bus_space_tag_t, bus_space_handle_t); 142 int iha_msgin(struct iha_softc *, bus_space_tag_t, bus_space_handle_t); 143 int iha_msgin_sdtr(struct iha_softc *); 144 int iha_msgin_extended(struct iha_softc *, 145 bus_space_tag_t, bus_space_handle_t); 146 int iha_msgin_ignore_wid_resid(struct iha_softc *, 147 bus_space_tag_t, bus_space_handle_t); 148 int iha_msgout(struct iha_softc *, 149 bus_space_tag_t, bus_space_handle_t, u_int8_t); 150 int iha_msgout_extended(struct iha_softc *, 151 bus_space_tag_t, bus_space_handle_t); 152 void iha_msgout_abort(struct iha_softc *, 153 bus_space_tag_t, bus_space_handle_t, u_int8_t); 154 int iha_msgout_reject(struct iha_softc *, 155 bus_space_tag_t, bus_space_handle_t); 156 int iha_msgout_sdtr(struct iha_softc *, 157 bus_space_tag_t, bus_space_handle_t); 158 int iha_msgout_wdtr(struct iha_softc *, 159 bus_space_tag_t, bus_space_handle_t); 160 void iha_select(struct iha_softc *, 161 bus_space_tag_t, bus_space_handle_t, 162 struct iha_scb *, u_int8_t); 163 void iha_busfree(struct iha_softc *, 164 bus_space_tag_t, bus_space_handle_t); 165 int iha_resel(struct iha_softc *, bus_space_tag_t, bus_space_handle_t); 166 void iha_abort_xs(struct iha_softc *, struct scsi_xfer *, u_int8_t); 167 168 /* 169 * iha_intr - the interrupt service routine for the iha driver 170 */ 171 int 172 iha_intr(void *arg) 173 { 174 bus_space_handle_t ioh; 175 struct iha_softc *sc; 176 bus_space_tag_t iot; 177 int s; 178 179 sc = (struct iha_softc *)arg; 180 iot = sc->sc_iot; 181 ioh = sc->sc_ioh; 182 183 if ((bus_space_read_1(iot, ioh, TUL_STAT0) & INTPD) == 0) 184 return (0); 185 186 s = splbio(); /* XXX - Or are interrupts off when ISR's are called? */ 187 188 if (sc->HCS_Semaph != SEMAPH_IN_MAIN) { 189 /* XXX - need these inside a splbio()/splx()? */ 190 bus_space_write_1(iot, ioh, TUL_IMSK, MASK_ALL); 191 sc->HCS_Semaph = SEMAPH_IN_MAIN; 192 193 iha_main(sc, iot, ioh); 194 195 sc->HCS_Semaph = ~SEMAPH_IN_MAIN; 196 bus_space_write_1(iot, ioh, TUL_IMSK, (MASK_ALL & ~MSCMP)); 197 } 198 199 splx(s); 200 201 return (1); 202 } 203 204 /* 205 * iha_setup_sg_list - initialize scatter gather list of pScb from 206 * pScb->SCB_DataDma. 207 */ 208 int 209 iha_setup_sg_list(struct iha_softc *sc, struct iha_scb *pScb) 210 { 211 bus_dma_segment_t *segs = pScb->SCB_DataDma->dm_segs; 212 int i, error, nseg = pScb->SCB_DataDma->dm_nsegs; 213 214 if (nseg > 1) { 215 error = bus_dmamap_load(sc->sc_dmat, pScb->SCB_SGDma, 216 pScb->SCB_SGList, sizeof(pScb->SCB_SGList), NULL, 217 (pScb->SCB_Flags & SCSI_NOSLEEP) ? 218 BUS_DMA_NOWAIT : BUS_DMA_WAITOK); 219 if (error) { 220 sc_print_addr(pScb->SCB_Xs->sc_link); 221 printf("error %d loading SG list dma map\n", error); 222 return (error); 223 } 224 225 /* 226 * Only set FLAG_SG when SCB_SGDma is loaded so iha_scsi_done 227 * will not unload an unloaded map. 228 */ 229 pScb->SCB_Flags |= FLAG_SG; 230 bzero(pScb->SCB_SGList, sizeof(pScb->SCB_SGList)); 231 232 pScb->SCB_SGIdx = 0; 233 pScb->SCB_SGCount = nseg; 234 235 for (i=0; i < nseg; i++) { 236 pScb->SCB_SGList[i].SG_Len = segs[i].ds_len; 237 pScb->SCB_SGList[i].SG_Addr = segs[i].ds_addr; 238 } 239 240 bus_dmamap_sync(sc->sc_dmat, pScb->SCB_SGDma, 241 0, sizeof(pScb->SCB_SGList), BUS_DMASYNC_PREWRITE); 242 } 243 244 return (0); 245 } 246 247 /* 248 * iha_scsi_cmd - start execution of a SCSI command. This is called 249 * from the generic SCSI driver via the field 250 * sc_adapter.scsi_cmd of iha_softc. 251 */ 252 void 253 iha_scsi_cmd(struct scsi_xfer *xs) 254 { 255 struct iha_scb *pScb; 256 struct scsi_link *sc_link = xs->sc_link; 257 struct iha_softc *sc = sc_link->adapter_softc; 258 int error; 259 260 if ((xs->cmdlen > 12) || (sc_link->target >= IHA_MAX_TARGETS)) { 261 xs->error = XS_DRIVER_STUFFUP; 262 scsi_done(xs); 263 return; 264 } 265 266 pScb = xs->io; 267 268 pScb->SCB_Target = sc_link->target; 269 pScb->SCB_Lun = sc_link->lun; 270 pScb->SCB_Tcs = &sc->HCS_Tcs[pScb->SCB_Target]; 271 pScb->SCB_Flags = xs->flags; 272 pScb->SCB_Ident = MSG_IDENTIFYFLAG | 273 (pScb->SCB_Lun & MSG_IDENTIFY_LUNMASK); 274 275 if ((xs->cmd->opcode != REQUEST_SENSE) 276 && ((pScb->SCB_Flags & SCSI_POLL) == 0)) 277 pScb->SCB_Ident |= MSG_IDENTIFY_DISCFLAG; 278 279 pScb->SCB_Xs = xs; 280 pScb->SCB_CDBLen = xs->cmdlen; 281 bcopy(xs->cmd, &pScb->SCB_CDB, xs->cmdlen); 282 283 pScb->SCB_BufCharsLeft = pScb->SCB_BufChars = xs->datalen; 284 285 if ((pScb->SCB_Flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) != 0) { 286 error = bus_dmamap_load(sc->sc_dmat, pScb->SCB_DataDma, 287 xs->data, pScb->SCB_BufChars, NULL, 288 (pScb->SCB_Flags & SCSI_NOSLEEP) ? 289 BUS_DMA_NOWAIT : BUS_DMA_WAITOK); 290 291 if (error) { 292 sc_print_addr(xs->sc_link); 293 if (error == EFBIG) 294 printf("buffer needs >%d dma segments\n", 295 IHA_MAX_SG_ENTRIES); 296 else 297 printf("error %d loading buffer dma map\n", 298 error); 299 300 xs->error = XS_DRIVER_STUFFUP; 301 scsi_done(xs); 302 return; 303 } 304 bus_dmamap_sync(sc->sc_dmat, pScb->SCB_DataDma, 305 0, pScb->SCB_BufChars, 306 (pScb->SCB_Flags & SCSI_DATA_IN) ? 307 BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE); 308 309 error = iha_setup_sg_list(sc, pScb); 310 if (error) { 311 bus_dmamap_unload(sc->sc_dmat, pScb->SCB_DataDma); 312 xs->error = XS_DRIVER_STUFFUP; 313 scsi_done(xs); 314 return; 315 } 316 317 } 318 319 /* 320 * Always initialize the stimeout structure as it may 321 * contain garbage that confuses timeout_del() later on. 322 * But, timeout_add() ONLY if we are not polling. 323 */ 324 timeout_set(&xs->stimeout, iha_timeout, pScb); 325 326 iha_exec_scb(sc, pScb); 327 } 328 329 /* 330 * iha_init_tulip - initialize the inic-940/950 card and the rest of the 331 * iha_softc structure supplied 332 */ 333 int 334 iha_init_tulip(struct iha_softc *sc) 335 { 336 struct iha_scb *pScb; 337 struct iha_nvram_scsi *pScsi; 338 bus_space_handle_t ioh; 339 struct iha_nvram iha_nvram; 340 bus_space_tag_t iot; 341 int i, error; 342 343 iot = sc->sc_iot; 344 ioh = sc->sc_ioh; 345 346 iha_read_eeprom(iot, ioh, &iha_nvram); 347 348 pScsi = &iha_nvram.NVM_Scsi[0]; 349 350 TAILQ_INIT(&sc->HCS_FreeScb); 351 TAILQ_INIT(&sc->HCS_PendScb); 352 TAILQ_INIT(&sc->HCS_DoneScb); 353 354 mtx_init(&sc->sc_scb_mtx, IPL_BIO); 355 scsi_iopool_init(&sc->sc_iopool, sc, iha_scb_alloc, iha_scb_free); 356 357 /* 358 * fill in the prototype scsi_link. 359 */ 360 sc->sc_link.adapter_softc = sc; 361 sc->sc_link.adapter = &iha_switch; 362 sc->sc_link.openings = 4; /* # xs's allowed per device */ 363 sc->sc_link.adapter_target = pScsi->NVM_SCSI_Id; 364 sc->sc_link.adapter_buswidth = pScsi->NVM_SCSI_Targets; 365 sc->sc_link.pool = &sc->sc_iopool; 366 367 /* 368 * fill in the rest of the iha_softc fields 369 */ 370 sc->HCS_Semaph = ~SEMAPH_IN_MAIN; 371 sc->HCS_JSStatus0 = 0; 372 sc->HCS_ActScb = NULL; 373 374 error = iha_alloc_scbs(sc); 375 if (error != 0) 376 return (error); 377 378 for (i = 0, pScb = sc->HCS_Scb; i < IHA_MAX_SCB; i++, pScb++) { 379 pScb->SCB_TagId = i; 380 381 error = bus_dmamap_create(sc->sc_dmat, 382 (IHA_MAX_SG_ENTRIES-1) * PAGE_SIZE, IHA_MAX_SG_ENTRIES, 383 (IHA_MAX_SG_ENTRIES-1) * PAGE_SIZE, 0, 384 BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &pScb->SCB_DataDma); 385 386 if (error != 0) { 387 printf("%s: couldn't create SCB data DMA map, error = %d\n", 388 sc->sc_dev.dv_xname, error); 389 return (error); 390 } 391 392 error = bus_dmamap_create(sc->sc_dmat, 393 sizeof(pScb->SCB_SGList), 1, 394 sizeof(pScb->SCB_SGList), 0, 395 BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, 396 &pScb->SCB_SGDma); 397 if (error != 0) { 398 printf("%s: couldn't create SCB SG DMA map, error = %d\n", 399 sc->sc_dev.dv_xname, error); 400 return (error); 401 } 402 403 TAILQ_INSERT_TAIL(&sc->HCS_FreeScb, pScb, SCB_ScbList); 404 } 405 406 /* Mask all the interrupts */ 407 bus_space_write_1(iot, ioh, TUL_IMSK, MASK_ALL); 408 409 /* Stop any I/O and reset the scsi module */ 410 iha_reset_dma(iot, ioh); 411 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSMOD); 412 413 /* Program HBA's SCSI ID */ 414 bus_space_write_1(iot, ioh, TUL_SID, sc->sc_link.adapter_target << 4); 415 416 /* 417 * Configure the channel as requested by the NVRAM settings read 418 * into iha_nvram by iha_read_eeprom() above. 419 */ 420 421 if ((pScsi->NVM_SCSI_Cfg & CFG_EN_PAR) != 0) 422 sc->HCS_SConf1 = (SCONFIG0DEFAULT | SPCHK); 423 else 424 sc->HCS_SConf1 = (SCONFIG0DEFAULT); 425 bus_space_write_1(iot, ioh, TUL_SCONFIG0, sc->HCS_SConf1); 426 427 /* selection time out in units of 1.6385 millisecond = 250 ms */ 428 bus_space_write_1(iot, ioh, TUL_STIMO, 153); 429 430 /* Enable desired SCSI termination configuration read from eeprom */ 431 bus_space_write_1(iot, ioh, TUL_DCTRL0, 432 (pScsi->NVM_SCSI_Cfg & (CFG_ACT_TERM1 | CFG_ACT_TERM2))); 433 434 bus_space_write_1(iot, ioh, TUL_GCTRL1, 435 ((pScsi->NVM_SCSI_Cfg & CFG_AUTO_TERM) >> 4) 436 | (bus_space_read_1(iot, ioh, TUL_GCTRL1) & (~ATDEN))); 437 438 for (i = 0; i < IHA_MAX_TARGETS; i++) { 439 sc->HCS_Tcs[i].TCS_Flags = pScsi->NVM_SCSI_TargetFlags[i]; 440 iha_reset_tcs(&sc->HCS_Tcs[i], sc->HCS_SConf1); 441 } 442 443 iha_reset_chip(sc, iot, ioh); 444 bus_space_write_1(iot, ioh, TUL_SIEN, ALL_INTERRUPTS); 445 446 return (0); 447 } 448 449 /* 450 * iha_minphys - reduce bp->b_bcount to something less than 451 * or equal to the largest I/O possible through 452 * the adapter. Called from higher layers 453 * via sc->sc_adapter.scsi_minphys. 454 */ 455 void 456 iha_minphys(struct buf *bp, struct scsi_link *sl) 457 { 458 if (bp->b_bcount > ((IHA_MAX_SG_ENTRIES - 1) * PAGE_SIZE)) 459 bp->b_bcount = ((IHA_MAX_SG_ENTRIES - 1) * PAGE_SIZE); 460 461 minphys(bp); 462 } 463 464 /* 465 * iha_reset_dma - abort any active DMA xfer, reset tulip FIFO. 466 */ 467 void 468 iha_reset_dma(bus_space_tag_t iot, bus_space_handle_t ioh) 469 { 470 if ((bus_space_read_1(iot, ioh, TUL_ISTUS1) & XPEND) != 0) { 471 /* if DMA xfer is pending, abort DMA xfer */ 472 bus_space_write_1(iot, ioh, TUL_DCMD, ABTXFR); 473 /* wait Abort DMA xfer done */ 474 while ((bus_space_read_1(iot, ioh, TUL_ISTUS0) & DABT) == 0) 475 ; 476 } 477 478 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 479 } 480 481 /* 482 * iha_scb_alloc - return the first free SCB, or NULL if there are none. 483 */ 484 void * 485 iha_scb_alloc(void *xsc) 486 { 487 struct iha_softc *sc = xsc; 488 struct iha_scb *pScb; 489 490 mtx_enter(&sc->sc_scb_mtx); 491 pScb = TAILQ_FIRST(&sc->HCS_FreeScb); 492 if (pScb != NULL) { 493 pScb->SCB_Status = STATUS_RENT; 494 TAILQ_REMOVE(&sc->HCS_FreeScb, pScb, SCB_ScbList); 495 } 496 mtx_leave(&sc->sc_scb_mtx); 497 498 return (pScb); 499 } 500 501 /* 502 * iha_scb_free - append the supplied SCB to the tail of the 503 * HCS_FreeScb queue after clearing and resetting 504 * everything possible. 505 */ 506 void 507 iha_scb_free(void *xsc, void *xscb) 508 { 509 struct iha_softc *sc = xsc; 510 struct iha_scb *pScb = xscb; 511 int s; 512 513 s = splbio(); 514 if (pScb == sc->HCS_ActScb) 515 sc->HCS_ActScb = NULL; 516 splx(s); 517 518 pScb->SCB_Status = STATUS_QUEUED; 519 pScb->SCB_HaStat = HOST_OK; 520 pScb->SCB_TaStat = SCSI_OK; 521 522 pScb->SCB_NxtStat = 0; 523 pScb->SCB_Flags = 0; 524 pScb->SCB_Target = 0; 525 pScb->SCB_Lun = 0; 526 pScb->SCB_CDBLen = 0; 527 pScb->SCB_Ident = 0; 528 pScb->SCB_TagMsg = 0; 529 530 pScb->SCB_BufChars = 0; 531 pScb->SCB_BufCharsLeft = 0; 532 533 pScb->SCB_Xs = NULL; 534 pScb->SCB_Tcs = NULL; 535 536 bzero(pScb->SCB_CDB, sizeof(pScb->SCB_CDB)); 537 538 /* 539 * SCB_TagId is set at initialization and never changes 540 */ 541 542 mtx_enter(&sc->sc_scb_mtx); 543 TAILQ_INSERT_TAIL(&sc->HCS_FreeScb, pScb, SCB_ScbList); 544 mtx_leave(&sc->sc_scb_mtx); 545 } 546 547 void 548 iha_append_pend_scb(struct iha_softc *sc, struct iha_scb *pScb) 549 { 550 /* ASSUMPTION: only called within a splbio()/splx() pair */ 551 552 if (pScb == sc->HCS_ActScb) 553 sc->HCS_ActScb = NULL; 554 555 pScb->SCB_Status = STATUS_QUEUED; 556 557 TAILQ_INSERT_TAIL(&sc->HCS_PendScb, pScb, SCB_ScbList); 558 } 559 560 void 561 iha_push_pend_scb(struct iha_softc *sc, struct iha_scb *pScb) 562 { 563 int s; 564 565 s = splbio(); 566 567 if (pScb == sc->HCS_ActScb) 568 sc->HCS_ActScb = NULL; 569 570 pScb->SCB_Status = STATUS_QUEUED; 571 572 TAILQ_INSERT_HEAD(&sc->HCS_PendScb, pScb, SCB_ScbList); 573 574 splx(s); 575 } 576 577 /* 578 * iha_find_pend_scb - scan the pending queue for a SCB that can be 579 * processed immediately. Return NULL if none found 580 * and a pointer to the SCB if one is found. If there 581 * is an active SCB, return NULL! 582 */ 583 struct iha_scb * 584 iha_find_pend_scb(struct iha_softc *sc) 585 { 586 struct iha_scb *pScb; 587 struct tcs *pTcs; 588 int s; 589 590 s = splbio(); 591 592 if (sc->HCS_ActScb != NULL) 593 pScb = NULL; 594 595 else 596 TAILQ_FOREACH(pScb, &sc->HCS_PendScb, SCB_ScbList) { 597 if ((pScb->SCB_Flags & SCSI_RESET) != 0) 598 /* ALWAYS willing to reset a device */ 599 break; 600 601 pTcs = pScb->SCB_Tcs; 602 603 if ((pScb->SCB_TagMsg) != 0) { 604 /* 605 * A Tagged I/O. OK to start If no 606 * non-tagged I/O is active on the same 607 * target 608 */ 609 if (pTcs->TCS_NonTagScb == NULL) 610 break; 611 612 } else if (pScb->SCB_CDB[0] == REQUEST_SENSE) { 613 /* 614 * OK to do a non-tagged request sense 615 * even if a non-tagged I/O has been 616 * started, because we don't allow any 617 * disconnect during a request sense op 618 */ 619 break; 620 621 } else if (pTcs->TCS_TagCnt == 0) { 622 /* 623 * No tagged I/O active on this target, 624 * ok to start a non-tagged one if one 625 * is not already active 626 */ 627 if (pTcs->TCS_NonTagScb == NULL) 628 break; 629 } 630 } 631 632 splx(s); 633 634 return (pScb); 635 } 636 637 void 638 iha_mark_busy_scb(struct iha_scb *pScb) 639 { 640 int s; 641 642 s = splbio(); 643 644 pScb->SCB_Status = STATUS_BUSY; 645 646 if (pScb->SCB_TagMsg == 0) 647 pScb->SCB_Tcs->TCS_NonTagScb = pScb; 648 else 649 pScb->SCB_Tcs->TCS_TagCnt++; 650 651 splx(s); 652 } 653 654 void 655 iha_append_done_scb(struct iha_softc *sc, struct iha_scb *pScb, u_int8_t hastat) 656 { 657 struct tcs *pTcs; 658 int s; 659 660 s = splbio(); 661 662 if (pScb->SCB_Xs != NULL) 663 timeout_del(&pScb->SCB_Xs->stimeout); 664 665 if (pScb == sc->HCS_ActScb) 666 sc->HCS_ActScb = NULL; 667 668 pTcs = pScb->SCB_Tcs; 669 670 if (pScb->SCB_TagMsg != 0) { 671 if (pTcs->TCS_TagCnt) 672 pTcs->TCS_TagCnt--; 673 } else if (pTcs->TCS_NonTagScb == pScb) 674 pTcs->TCS_NonTagScb = NULL; 675 676 pScb->SCB_Status = STATUS_QUEUED; 677 pScb->SCB_HaStat = hastat; 678 679 TAILQ_INSERT_TAIL(&sc->HCS_DoneScb, pScb, SCB_ScbList); 680 681 splx(s); 682 } 683 684 struct iha_scb * 685 iha_pop_done_scb(struct iha_softc *sc) 686 { 687 struct iha_scb *pScb; 688 int s; 689 690 s = splbio(); 691 692 pScb = TAILQ_FIRST(&sc->HCS_DoneScb); 693 694 if (pScb != NULL) { 695 pScb->SCB_Status = STATUS_RENT; 696 TAILQ_REMOVE(&sc->HCS_DoneScb, pScb, SCB_ScbList); 697 } 698 699 splx(s); 700 701 return (pScb); 702 } 703 704 /* 705 * iha_abort_xs - find the SCB associated with the supplied xs and 706 * stop all processing on it, moving it to the done 707 * queue with the supplied host status value. 708 */ 709 void 710 iha_abort_xs(struct iha_softc *sc, struct scsi_xfer *xs, u_int8_t hastat) 711 { 712 struct iha_scb *pScb, *next; 713 int i, s; 714 715 s = splbio(); 716 717 /* Check the pending queue for the SCB pointing to xs */ 718 719 for (pScb = TAILQ_FIRST(&sc->HCS_PendScb); pScb != NULL; pScb = next) { 720 next = TAILQ_NEXT(pScb, SCB_ScbList); 721 if (pScb->SCB_Xs == xs) { 722 TAILQ_REMOVE(&sc->HCS_PendScb, pScb, SCB_ScbList); 723 iha_append_done_scb(sc, pScb, hastat); 724 splx(s); 725 return; 726 } 727 } 728 729 /* 730 * If that didn't work, check all BUSY/SELECTING SCB's for one 731 * pointing to xs 732 */ 733 734 for (i = 0, pScb = sc->HCS_Scb; i < IHA_MAX_SCB; i++, pScb++) 735 switch (pScb->SCB_Status) { 736 case STATUS_BUSY: 737 case STATUS_SELECT: 738 if (pScb->SCB_Xs == xs) { 739 iha_append_done_scb(sc, pScb, hastat); 740 splx(s); 741 return; 742 } 743 break; 744 default: 745 break; 746 } 747 748 splx(s); 749 } 750 751 /* 752 * iha_bad_seq - a SCSI bus phase was encountered out of the 753 * correct/expected sequence. Reset the SCSI bus. 754 */ 755 void 756 iha_bad_seq(struct iha_softc *sc) 757 { 758 struct iha_scb *pScb = sc->HCS_ActScb; 759 760 if (pScb != NULL) 761 iha_append_done_scb(sc, pScb, HOST_BAD_PHAS); 762 763 iha_reset_scsi_bus(sc); 764 iha_reset_chip(sc, sc->sc_iot, sc->sc_ioh); 765 } 766 767 /* 768 * iha_push_sense_request - obtain auto sense data by pushing the 769 * SCB needing it back onto the pending 770 * queue with a REQUEST_SENSE CDB. 771 */ 772 int 773 iha_push_sense_request(struct iha_softc *sc, struct iha_scb *pScb) 774 { 775 struct scsi_sense *sensecmd; 776 int error; 777 778 /* First sync & unload any existing DataDma and SGDma maps */ 779 if ((pScb->SCB_Flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) != 0) { 780 bus_dmamap_sync(sc->sc_dmat, pScb->SCB_DataDma, 781 0, pScb->SCB_BufChars, 782 ((pScb->SCB_Flags & SCSI_DATA_IN) ? 783 BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE)); 784 bus_dmamap_unload(sc->sc_dmat, pScb->SCB_DataDma); 785 /* Don't unload this map again until it is reloaded */ 786 pScb->SCB_Flags &= ~(SCSI_DATA_IN | SCSI_DATA_OUT); 787 } 788 if ((pScb->SCB_Flags & FLAG_SG) != 0) { 789 bus_dmamap_sync(sc->sc_dmat, pScb->SCB_SGDma, 790 0, sizeof(pScb->SCB_SGList), 791 BUS_DMASYNC_POSTWRITE); 792 bus_dmamap_unload(sc->sc_dmat, pScb->SCB_SGDma); 793 /* Don't unload this map again until it is reloaded */ 794 pScb->SCB_Flags &= ~FLAG_SG; 795 } 796 797 pScb->SCB_BufChars = sizeof(pScb->SCB_ScsiSenseData); 798 pScb->SCB_BufCharsLeft = sizeof(pScb->SCB_ScsiSenseData); 799 bzero(&pScb->SCB_ScsiSenseData, sizeof(pScb->SCB_ScsiSenseData)); 800 801 error = bus_dmamap_load(sc->sc_dmat, pScb->SCB_DataDma, 802 &pScb->SCB_ScsiSenseData, 803 sizeof(pScb->SCB_ScsiSenseData), NULL, 804 (pScb->SCB_Flags & SCSI_NOSLEEP) ? 805 BUS_DMA_NOWAIT : BUS_DMA_WAITOK); 806 if (error) { 807 sc_print_addr(pScb->SCB_Xs->sc_link); 808 printf("error %d loading request sense buffer dma map\n", 809 error); 810 return (error); 811 } 812 bus_dmamap_sync(sc->sc_dmat, pScb->SCB_DataDma, 813 0, pScb->SCB_BufChars, BUS_DMASYNC_PREREAD); 814 815 /* Save _POLL and _NOSLEEP flags. */ 816 pScb->SCB_Flags &= SCSI_POLL | SCSI_NOSLEEP; 817 pScb->SCB_Flags |= FLAG_RSENS | SCSI_DATA_IN; 818 819 error = iha_setup_sg_list(sc, pScb); 820 if (error) 821 return (error); 822 823 pScb->SCB_Ident &= ~MSG_IDENTIFY_DISCFLAG; 824 825 pScb->SCB_TagMsg = 0; 826 pScb->SCB_TaStat = SCSI_OK; 827 828 bzero(pScb->SCB_CDB, sizeof(pScb->SCB_CDB)); 829 830 sensecmd = (struct scsi_sense *)pScb->SCB_CDB; 831 pScb->SCB_CDBLen = sizeof(*sensecmd); 832 sensecmd->opcode = REQUEST_SENSE; 833 sensecmd->byte2 = pScb->SCB_Xs->sc_link->lun << 5; 834 sensecmd->length = sizeof(pScb->SCB_ScsiSenseData); 835 836 if ((pScb->SCB_Flags & SCSI_POLL) == 0) 837 timeout_add_msec(&pScb->SCB_Xs->stimeout, 838 pScb->SCB_Xs->timeout); 839 840 iha_push_pend_scb(sc, pScb); 841 842 return (0); 843 } 844 845 /* 846 * iha_main - process the active SCB, taking one off pending and making it 847 * active if necessary, and any done SCB's created as 848 * a result until there are no interrupts pending and no pending 849 * SCB's that can be started. 850 */ 851 void 852 iha_main(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 853 { 854 struct iha_scb *pScb; 855 856 for (;;) { 857 iha_scsi_label: 858 iha_scsi(sc, iot, ioh); 859 860 while ((pScb = iha_pop_done_scb(sc)) != NULL) { 861 862 switch (pScb->SCB_TaStat) { 863 case SCSI_TERMINATED: 864 case SCSI_ACA_ACTIVE: 865 case SCSI_CHECK: 866 pScb->SCB_Tcs->TCS_Flags &= 867 ~(FLAG_SYNC_DONE | FLAG_WIDE_DONE); 868 869 if ((pScb->SCB_Flags & FLAG_RSENS) != 0) 870 /* Check condition on check condition*/ 871 pScb->SCB_HaStat = HOST_BAD_PHAS; 872 else if (iha_push_sense_request(sc, pScb) != 0) 873 /* Could not push sense request */ 874 pScb->SCB_HaStat = HOST_BAD_PHAS; 875 else 876 /* REQUEST SENSE ready to process */ 877 goto iha_scsi_label; 878 break; 879 880 default: 881 if ((pScb->SCB_Flags & FLAG_RSENS) != 0) 882 /* 883 * Return the original SCSI_CHECK, not 884 * the status of the request sense 885 * command! 886 */ 887 pScb->SCB_TaStat = SCSI_CHECK; 888 break; 889 } 890 891 iha_done_scb(sc, pScb); 892 } 893 894 /* 895 * If there are no interrupts pending, or we can't start 896 * a pending sc, break out of the for(;;). Otherwise 897 * continue the good work with another call to 898 * iha_scsi(). 899 */ 900 if (((bus_space_read_1(iot, ioh, TUL_STAT0) & INTPD) == 0) 901 && (iha_find_pend_scb(sc) == NULL)) 902 break; 903 } 904 } 905 906 /* 907 * iha_scsi - service any outstanding interrupts. If there are none, try to 908 * start another SCB currently in the pending queue. 909 */ 910 void 911 iha_scsi(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 912 { 913 struct iha_scb *pScb; 914 struct tcs *pTcs; 915 u_int8_t stat; 916 int i; 917 918 /* service pending interrupts asap */ 919 920 stat = bus_space_read_1(iot, ioh, TUL_STAT0); 921 if ((stat & INTPD) != 0) { 922 sc->HCS_JSStatus0 = stat; 923 sc->HCS_JSStatus1 = bus_space_read_1(iot, ioh, TUL_STAT1); 924 sc->HCS_JSInt = bus_space_read_1(iot, ioh, TUL_SISTAT); 925 926 sc->HCS_Phase = sc->HCS_JSStatus0 & PH_MASK; 927 928 if ((sc->HCS_JSInt & SRSTD) != 0) { 929 iha_reset_scsi_bus(sc); 930 return; 931 } 932 933 if ((sc->HCS_JSInt & RSELED) != 0) { 934 iha_resel(sc, iot, ioh); 935 return; 936 } 937 938 if ((sc->HCS_JSInt & (STIMEO | DISCD)) != 0) { 939 iha_busfree(sc, iot, ioh); 940 return; 941 } 942 943 if ((sc->HCS_JSInt & (SCMDN | SBSRV)) != 0) { 944 iha_next_state(sc, iot, ioh); 945 return; 946 } 947 948 if ((sc->HCS_JSInt & SELED) != 0) 949 iha_set_ssig(iot, ioh, 0, 0); 950 } 951 952 /* 953 * There were no interrupts pending which required action elsewhere, so 954 * see if it is possible to start the selection phase on a pending SCB 955 */ 956 if ((pScb = iha_find_pend_scb(sc)) == NULL) 957 return; 958 959 pTcs = pScb->SCB_Tcs; 960 961 /* program HBA's SCSI ID & target SCSI ID */ 962 bus_space_write_1(iot, ioh, TUL_SID, 963 (sc->sc_link.adapter_target << 4) | pScb->SCB_Target); 964 965 if ((pScb->SCB_Flags & SCSI_RESET) == 0) { 966 bus_space_write_1(iot, ioh, TUL_SYNCM, pTcs->TCS_JS_Period); 967 968 if (((pTcs->TCS_Flags & FLAG_NO_NEG_WIDE) == 0) 969 || 970 ((pTcs->TCS_Flags & FLAG_NO_NEG_SYNC) == 0)) 971 iha_select(sc, iot, ioh, pScb, SELATNSTOP); 972 973 else if (pScb->SCB_TagMsg != 0) 974 iha_select(sc, iot, ioh, pScb, SEL_ATN3); 975 976 else 977 iha_select(sc, iot, ioh, pScb, SEL_ATN); 978 979 } else { 980 iha_select(sc, iot, ioh, pScb, SELATNSTOP); 981 pScb->SCB_NxtStat = 8; 982 } 983 984 if ((pScb->SCB_Flags & SCSI_POLL) != 0) { 985 for (i = pScb->SCB_Xs->timeout; i > 0; i--) { 986 if (iha_wait(sc, iot, ioh, NO_OP) == -1) 987 break; 988 if (iha_next_state(sc, iot, ioh) == -1) 989 break; 990 delay(1000); /* Only happens in boot, so it's ok */ 991 } 992 993 /* 994 * Since done queue processing not done until AFTER this 995 * function returns, pScb is on the done queue, not 996 * the free queue at this point and still has valid data 997 * 998 * Conversely, xs->error has not been set yet 999 */ 1000 if (i == 0) 1001 iha_timeout(pScb); 1002 1003 else if ((pScb->SCB_CDB[0] == INQUIRY) 1004 && (pScb->SCB_Lun == 0) 1005 && (pScb->SCB_HaStat == HOST_OK) 1006 && (pScb->SCB_TaStat == SCSI_OK)) 1007 iha_print_info(sc, pScb->SCB_Target); 1008 } 1009 } 1010 1011 /* 1012 * iha_data_over_run - return HOST_OK for all SCSI opcodes where BufCharsLeft 1013 * is an 'Allocation Length'. All other SCSI opcodes 1014 * get HOST_DO_DU as they SHOULD have xferred all the 1015 * data requested. 1016 * 1017 * The list of opcodes using 'Allocation Length' was 1018 * found by scanning all the SCSI-3 T10 drafts. See 1019 * www.t10.org for the curious with a .pdf reader. 1020 */ 1021 u_int8_t 1022 iha_data_over_run(struct iha_scb *pScb) 1023 { 1024 switch (pScb->SCB_CDB[0]) { 1025 case 0x03: /* Request Sense SPC-2 */ 1026 case 0x12: /* Inquiry SPC-2 */ 1027 case 0x1a: /* Mode Sense (6 byte version) SPC-2 */ 1028 case 0x1c: /* Receive Diagnostic Results SPC-2 */ 1029 case 0x23: /* Read Format Capacities MMC-2 */ 1030 case 0x29: /* Read Generation SBC */ 1031 case 0x34: /* Read Position SSC-2 */ 1032 case 0x37: /* Read Defect Data SBC */ 1033 case 0x3c: /* Read Buffer SPC-2 */ 1034 case 0x42: /* Read Sub Channel MMC-2 */ 1035 case 0x43: /* Read TOC/PMA/ATIP MMC */ 1036 1037 /* XXX - 2 with same opcode of 0x44? */ 1038 case 0x44: /* Read Header/Read Density Suprt MMC/SSC*/ 1039 1040 case 0x46: /* Get Configuration MMC-2 */ 1041 case 0x4a: /* Get Event/Status Notification MMC-2 */ 1042 case 0x4d: /* Log Sense SPC-2 */ 1043 case 0x51: /* Read Disc Information MMC */ 1044 case 0x52: /* Read Track Information MMC */ 1045 case 0x59: /* Read Master CUE MMC */ 1046 case 0x5a: /* Mode Sense (10 byte version) SPC-2 */ 1047 case 0x5c: /* Read Buffer Capacity MMC */ 1048 case 0x5e: /* Persistent Reserve In SPC-2 */ 1049 case 0x84: /* Receive Copy Results SPC-2 */ 1050 case 0xa0: /* Report LUNs SPC-2 */ 1051 case 0xa3: /* Various Report requests SBC-2/SCC-2*/ 1052 case 0xa4: /* Report Key MMC-2 */ 1053 case 0xad: /* Read DVD Structure MMC-2 */ 1054 case 0xb4: /* Read Element Status (Attached) SMC */ 1055 case 0xb5: /* Request Volume Element Address SMC */ 1056 case 0xb7: /* Read Defect Data (12 byte ver.) SBC */ 1057 case 0xb8: /* Read Element Status (Independ.) SMC */ 1058 case 0xba: /* Report Redundancy SCC-2 */ 1059 case 0xbd: /* Mechanism Status MMC */ 1060 case 0xbe: /* Report Basic Redundancy SCC-2 */ 1061 1062 return (HOST_OK); 1063 break; 1064 1065 default: 1066 return (HOST_DO_DU); 1067 break; 1068 } 1069 } 1070 1071 /* 1072 * iha_next_state - process the current SCB as requested in its 1073 * SCB_NxtStat member. 1074 */ 1075 int 1076 iha_next_state(struct iha_softc *sc, bus_space_tag_t iot, 1077 bus_space_handle_t ioh) 1078 { 1079 if (sc->HCS_ActScb == NULL) 1080 return (-1); 1081 1082 switch (sc->HCS_ActScb->SCB_NxtStat) { 1083 case 1: 1084 if (iha_state_1(sc, iot, ioh) == 3) 1085 goto state_3; 1086 break; 1087 1088 case 2: 1089 switch (iha_state_2(sc, iot, ioh)) { 1090 case 3: goto state_3; 1091 case 4: goto state_4; 1092 default: break; 1093 } 1094 break; 1095 1096 case 3: 1097 state_3: 1098 if (iha_state_3(sc, iot, ioh) == 4) 1099 goto state_4; 1100 break; 1101 1102 case 4: 1103 state_4: 1104 switch (iha_state_4(sc, iot, ioh)) { 1105 case 0: return (0); 1106 case 6: goto state_6; 1107 default: break; 1108 } 1109 break; 1110 1111 case 5: 1112 switch (iha_state_5(sc, iot, ioh)) { 1113 case 4: goto state_4; 1114 case 6: goto state_6; 1115 default: break; 1116 } 1117 break; 1118 1119 case 6: 1120 state_6: 1121 iha_state_6(sc, iot, ioh); 1122 break; 1123 1124 case 8: 1125 iha_state_8(sc, iot, ioh); 1126 break; 1127 1128 default: 1129 #ifdef IHA_DEBUG_STATE 1130 sc_print_addr(sc->HCS_ActScb->SCB_Xs->sc_link); 1131 printf("[debug] -unknown state: %i-\n", 1132 sc->HCS_ActScb->SCB_NxtStat); 1133 #endif 1134 iha_bad_seq(sc); 1135 break; 1136 } 1137 1138 return (-1); 1139 } 1140 1141 /* 1142 * iha_state_1 - selection is complete after a SELATNSTOP. If the target 1143 * has put the bus into MSG_OUT phase start wide/sync 1144 * negotiation. Otherwise clear the FIFO and go to state 3, 1145 * which will send the SCSI CDB to the target. 1146 */ 1147 int 1148 iha_state_1(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 1149 { 1150 struct iha_scb *pScb = sc->HCS_ActScb; 1151 struct tcs *pTcs; 1152 u_int16_t flags; 1153 1154 iha_mark_busy_scb(pScb); 1155 1156 pTcs = pScb->SCB_Tcs; 1157 1158 bus_space_write_1(iot, ioh, TUL_SCONFIG0, pTcs->TCS_SConfig0); 1159 1160 /* 1161 * If we are in PHASE_MSG_OUT, send 1162 * a) IDENT message (with tags if appropriate) 1163 * b) WDTR if the target is configured to negotiate wide xfers 1164 * ** OR ** 1165 * c) SDTR if the target is configured to negotiate sync xfers 1166 * but not wide ones 1167 * 1168 * If we are NOT, then the target is not asking for anything but 1169 * the data/command, so go straight to state 3. 1170 */ 1171 if (sc->HCS_Phase == PHASE_MSG_OUT) { 1172 bus_space_write_1(iot, ioh, TUL_SCTRL1, (ESBUSIN | EHRSL)); 1173 bus_space_write_1(iot, ioh, TUL_SFIFO, pScb->SCB_Ident); 1174 1175 if (pScb->SCB_TagMsg != 0) { 1176 bus_space_write_1(iot, ioh, TUL_SFIFO, 1177 pScb->SCB_TagMsg); 1178 bus_space_write_1(iot, ioh, TUL_SFIFO, 1179 pScb->SCB_TagId); 1180 } 1181 1182 flags = pTcs->TCS_Flags; 1183 if ((flags & FLAG_NO_NEG_WIDE) == 0) { 1184 if (iha_msgout_wdtr(sc, iot, ioh) == -1) 1185 return (-1); 1186 } else if ((flags & FLAG_NO_NEG_SYNC) == 0) { 1187 if (iha_msgout_sdtr(sc, iot, ioh) == -1) 1188 return (-1); 1189 } 1190 1191 } else { 1192 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 1193 iha_set_ssig(iot, ioh, REQ | BSY | SEL | ATN, 0); 1194 } 1195 1196 return (3); 1197 } 1198 1199 /* 1200 * iha_state_2 - selection is complete after a SEL_ATN or SEL_ATN3. If the SCSI 1201 * CDB has already been send, go to state 4 to start the data 1202 * xfer. Otherwise reset the FIFO and go to state 3, sending 1203 * the SCSI CDB. 1204 */ 1205 int 1206 iha_state_2(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 1207 { 1208 struct iha_scb *pScb = sc->HCS_ActScb; 1209 1210 iha_mark_busy_scb(pScb); 1211 1212 bus_space_write_1(iot, ioh, TUL_SCONFIG0, pScb->SCB_Tcs->TCS_SConfig0); 1213 1214 if ((sc->HCS_JSStatus1 & CPDNE) != 0) 1215 return (4); 1216 1217 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 1218 1219 iha_set_ssig(iot, ioh, REQ | BSY | SEL | ATN, 0); 1220 1221 return (3); 1222 } 1223 1224 /* 1225 * iha_state_3 - send the SCSI CDB to the target, processing any status 1226 * or other messages received until that is done or 1227 * abandoned. 1228 */ 1229 int 1230 iha_state_3(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 1231 { 1232 struct iha_scb *pScb = sc->HCS_ActScb; 1233 u_int16_t flags; 1234 1235 for (;;) 1236 switch (sc->HCS_Phase) { 1237 case PHASE_CMD_OUT: 1238 bus_space_write_multi_1(iot, ioh, TUL_SFIFO, 1239 pScb->SCB_CDB, pScb->SCB_CDBLen); 1240 if (iha_wait(sc, iot, ioh, XF_FIFO_OUT) == -1) 1241 return (-1); 1242 else if (sc->HCS_Phase == PHASE_CMD_OUT) { 1243 iha_bad_seq(sc); 1244 return (-1); 1245 } else 1246 return (4); 1247 1248 case PHASE_MSG_IN: 1249 pScb->SCB_NxtStat = 3; 1250 if (iha_msgin(sc, iot, ioh) == -1) 1251 return (-1); 1252 break; 1253 1254 case PHASE_STATUS_IN: 1255 if (iha_status_msg(sc, iot, ioh) == -1) 1256 return (-1); 1257 break; 1258 1259 case PHASE_MSG_OUT: 1260 flags = pScb->SCB_Tcs->TCS_Flags; 1261 if ((flags & FLAG_NO_NEG_SYNC) != 0) { 1262 if (iha_msgout(sc, iot, ioh, MSG_NOOP) == -1) 1263 return (-1); 1264 } else if (iha_msgout_sdtr(sc, iot, ioh) == -1) 1265 return (-1); 1266 break; 1267 1268 default: 1269 #ifdef IHA_DEBUG_STATE 1270 sc_print_addr(pScb->SCB_Xs->sc_link); 1271 printf("[debug] -s3- bad phase = %d\n", sc->HCS_Phase); 1272 #endif 1273 iha_bad_seq(sc); 1274 return (-1); 1275 } 1276 } 1277 1278 /* 1279 * iha_state_4 - start a data xfer. Handle any bus state 1280 * transitions until PHASE_DATA_IN/_OUT 1281 * or the attempt is abandoned. If there is 1282 * no data to xfer, go to state 6 and finish 1283 * processing the current SCB. 1284 */ 1285 int 1286 iha_state_4(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 1287 { 1288 struct iha_scb *pScb = sc->HCS_ActScb; 1289 1290 if ((pScb->SCB_Flags & FLAG_DIR) == FLAG_DIR) 1291 return (6); /* Both dir flags set => NO xfer was requested */ 1292 1293 for (;;) { 1294 if (pScb->SCB_BufCharsLeft == 0) 1295 return (6); 1296 1297 switch (sc->HCS_Phase) { 1298 case PHASE_STATUS_IN: 1299 if ((pScb->SCB_Flags & FLAG_DIR) != 0) 1300 pScb->SCB_HaStat = iha_data_over_run(pScb); 1301 if ((iha_status_msg(sc, iot, ioh)) == -1) 1302 return (-1); 1303 break; 1304 1305 case PHASE_MSG_IN: 1306 pScb->SCB_NxtStat = 4; 1307 if (iha_msgin(sc, iot, ioh) == -1) 1308 return (-1); 1309 break; 1310 1311 case PHASE_MSG_OUT: 1312 if ((sc->HCS_JSStatus0 & SPERR) != 0) { 1313 pScb->SCB_BufCharsLeft = 0; 1314 pScb->SCB_HaStat = HOST_SPERR; 1315 if (iha_msgout(sc, iot, ioh, 1316 MSG_INITIATOR_DET_ERR) == -1) 1317 return (-1); 1318 else 1319 return (6); 1320 } else { 1321 if (iha_msgout(sc, iot, ioh, MSG_NOOP) == -1) 1322 return (-1); 1323 } 1324 break; 1325 1326 case PHASE_DATA_IN: 1327 return (iha_xfer_data(pScb, iot, ioh, SCSI_DATA_IN)); 1328 1329 case PHASE_DATA_OUT: 1330 return (iha_xfer_data(pScb, iot, ioh, SCSI_DATA_OUT)); 1331 1332 default: 1333 iha_bad_seq(sc); 1334 return (-1); 1335 } 1336 } 1337 } 1338 1339 /* 1340 * iha_state_5 - handle the partial or final completion of the current 1341 * data xfer. If DMA is still active stop it. If there is 1342 * more data to xfer, go to state 4 and start the xfer. 1343 * If not go to state 6 and finish the SCB. 1344 */ 1345 int 1346 iha_state_5(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 1347 { 1348 struct iha_scb *pScb = sc->HCS_ActScb; 1349 struct iha_sg_element *pSg; 1350 u_int32_t cnt; 1351 u_int16_t period; 1352 u_int8_t stat; 1353 long xcnt; /* cannot use unsigned!! see code: if (xcnt < 0) */ 1354 1355 cnt = bus_space_read_4(iot, ioh, TUL_STCNT0) & TCNT; 1356 1357 /* 1358 * Stop any pending DMA activity and check for parity error. 1359 */ 1360 1361 if ((bus_space_read_1(iot, ioh, TUL_DCMD) & XDIR) != 0) { 1362 /* Input Operation */ 1363 if ((sc->HCS_JSStatus0 & SPERR) != 0) 1364 pScb->SCB_HaStat = HOST_SPERR; 1365 1366 if ((bus_space_read_1(iot, ioh, TUL_ISTUS1) & XPEND) != 0) { 1367 bus_space_write_1(iot, ioh, TUL_DCTRL0, 1368 bus_space_read_1(iot, ioh, TUL_DCTRL0) | SXSTP); 1369 while (bus_space_read_1(iot, ioh, TUL_ISTUS1) & XPEND) 1370 ; 1371 } 1372 1373 } else { 1374 /* Output Operation */ 1375 if ((sc->HCS_JSStatus1 & SXCMP) == 0) { 1376 period = pScb->SCB_Tcs->TCS_JS_Period; 1377 if ((period & PERIOD_WIDE_SCSI) != 0) 1378 cnt += (bus_space_read_1(iot, ioh, 1379 TUL_SFIFOCNT) & FIFOC) << 1; 1380 else 1381 cnt += (bus_space_read_1(iot, ioh, 1382 TUL_SFIFOCNT) & FIFOC); 1383 } 1384 1385 if ((bus_space_read_1(iot, ioh, TUL_ISTUS1) & XPEND) != 0) { 1386 bus_space_write_1(iot, ioh, TUL_DCMD, ABTXFR); 1387 do 1388 stat = bus_space_read_1(iot, ioh, TUL_ISTUS0); 1389 while ((stat & DABT) == 0); 1390 } 1391 1392 if ((cnt == 1) && (sc->HCS_Phase == PHASE_DATA_OUT)) { 1393 if (iha_wait(sc, iot, ioh, XF_FIFO_OUT) == -1) 1394 return (-1); 1395 cnt = 0; 1396 1397 } else if ((sc->HCS_JSStatus1 & SXCMP) == 0) 1398 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 1399 } 1400 1401 if (cnt == 0) { 1402 pScb->SCB_BufCharsLeft = 0; 1403 return (6); 1404 } 1405 1406 /* Update active data pointer and restart the I/O at the new point */ 1407 1408 xcnt = pScb->SCB_BufCharsLeft - cnt; /* xcnt == bytes xferred */ 1409 pScb->SCB_BufCharsLeft = cnt; /* cnt == bytes left */ 1410 1411 bus_dmamap_sync(sc->sc_dmat, pScb->SCB_SGDma, 1412 0, sizeof(pScb->SCB_SGList), BUS_DMASYNC_POSTWRITE); 1413 1414 if ((pScb->SCB_Flags & FLAG_SG) != 0) { 1415 pSg = &pScb->SCB_SGList[pScb->SCB_SGIdx]; 1416 for (; pScb->SCB_SGIdx < pScb->SCB_SGCount; pSg++, pScb->SCB_SGIdx++) { 1417 xcnt -= pSg->SG_Len; 1418 if (xcnt < 0) { 1419 xcnt += pSg->SG_Len; 1420 1421 pSg->SG_Addr += xcnt; 1422 pSg->SG_Len -= xcnt; 1423 1424 bus_dmamap_sync(sc->sc_dmat, pScb->SCB_SGDma, 1425 0, sizeof(pScb->SCB_SGList), 1426 BUS_DMASYNC_PREWRITE); 1427 1428 return (4); 1429 } 1430 } 1431 return (6); 1432 1433 } 1434 1435 return (4); 1436 } 1437 1438 /* 1439 * iha_state_6 - finish off the active scb (may require several 1440 * iterations if PHASE_MSG_IN) and return -1 to indicate 1441 * the bus is free. 1442 */ 1443 int 1444 iha_state_6(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 1445 { 1446 for (;;) 1447 switch (sc->HCS_Phase) { 1448 case PHASE_STATUS_IN: 1449 if (iha_status_msg(sc, iot, ioh) == -1) 1450 return (-1); 1451 break; 1452 1453 case PHASE_MSG_IN: 1454 sc->HCS_ActScb->SCB_NxtStat = 6; 1455 if ((iha_msgin(sc, iot, ioh)) == -1) 1456 return (-1); 1457 break; 1458 1459 case PHASE_MSG_OUT: 1460 if ((iha_msgout(sc, iot, ioh, MSG_NOOP)) == -1) 1461 return (-1); 1462 break; 1463 1464 case PHASE_DATA_IN: 1465 if (iha_xpad_in(sc, iot, ioh) == -1) 1466 return (-1); 1467 break; 1468 1469 case PHASE_DATA_OUT: 1470 if (iha_xpad_out(sc, iot, ioh) == -1) 1471 return (-1); 1472 break; 1473 1474 default: 1475 iha_bad_seq(sc); 1476 return (-1); 1477 } 1478 } 1479 1480 /* 1481 * iha_state_8 - reset the active device and all busy SCBs using it 1482 */ 1483 int 1484 iha_state_8(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 1485 { 1486 struct iha_scb *pScb; 1487 u_int32_t i; 1488 u_int8_t tar; 1489 1490 if (sc->HCS_Phase == PHASE_MSG_OUT) { 1491 bus_space_write_1(iot, ioh, TUL_SFIFO, MSG_BUS_DEV_RESET); 1492 1493 pScb = sc->HCS_ActScb; 1494 1495 /* This SCB finished correctly -- resetting the device */ 1496 iha_append_done_scb(sc, pScb, HOST_OK); 1497 1498 iha_reset_tcs(pScb->SCB_Tcs, sc->HCS_SConf1); 1499 1500 tar = pScb->SCB_Target; 1501 for (i = 0, pScb = sc->HCS_Scb; i < IHA_MAX_SCB; i++, pScb++) 1502 if (pScb->SCB_Target == tar) 1503 switch (pScb->SCB_Status) { 1504 case STATUS_BUSY: 1505 iha_append_done_scb(sc, 1506 pScb, HOST_DEV_RST); 1507 break; 1508 1509 case STATUS_SELECT: 1510 iha_push_pend_scb(sc, pScb); 1511 break; 1512 1513 default: 1514 break; 1515 } 1516 1517 sc->HCS_Flags |= FLAG_EXPECT_DISC; 1518 1519 if (iha_wait(sc, iot, ioh, XF_FIFO_OUT) == -1) 1520 return (-1); 1521 } 1522 1523 iha_bad_seq(sc); 1524 return (-1); 1525 } 1526 1527 /* 1528 * iha_xfer_data - initiate the DMA xfer of the data 1529 */ 1530 int 1531 iha_xfer_data(struct iha_scb *pScb, bus_space_tag_t iot, bus_space_handle_t ioh, 1532 int direction) 1533 { 1534 u_int32_t xferaddr, xferlen; 1535 u_int8_t xfertype; 1536 1537 if ((pScb->SCB_Flags & FLAG_DIR) != direction) 1538 return (6); /* wrong direction, abandon I/O */ 1539 1540 bus_space_write_4(iot, ioh, TUL_STCNT0, pScb->SCB_BufCharsLeft); 1541 1542 if ((pScb->SCB_Flags & FLAG_SG) == 0) { 1543 xferaddr = pScb->SCB_DataDma->dm_segs[0].ds_addr 1544 + (pScb->SCB_BufChars - pScb->SCB_BufCharsLeft); 1545 xferlen = pScb->SCB_BufCharsLeft; 1546 xfertype = (direction == SCSI_DATA_IN) ? ST_X_IN : ST_X_OUT; 1547 1548 } else { 1549 xferaddr = pScb->SCB_SGDma->dm_segs[0].ds_addr 1550 + (pScb->SCB_SGIdx * sizeof(struct iha_sg_element)); 1551 xferlen = (pScb->SCB_SGCount - pScb->SCB_SGIdx) 1552 * sizeof(struct iha_sg_element); 1553 xfertype = (direction == SCSI_DATA_IN) ? ST_SG_IN : ST_SG_OUT; 1554 } 1555 1556 bus_space_write_4(iot, ioh, TUL_DXC, xferlen); 1557 bus_space_write_4(iot, ioh, TUL_DXPA, xferaddr); 1558 bus_space_write_1(iot, ioh, TUL_DCMD, xfertype); 1559 1560 bus_space_write_1(iot, ioh, TUL_SCMD, 1561 (direction == SCSI_DATA_IN) ? XF_DMA_IN : XF_DMA_OUT); 1562 1563 pScb->SCB_NxtStat = 5; 1564 1565 return (0); 1566 } 1567 1568 int 1569 iha_xpad_in(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 1570 { 1571 struct iha_scb *pScb = sc->HCS_ActScb; 1572 1573 if ((pScb->SCB_Flags & FLAG_DIR) != 0) 1574 pScb->SCB_HaStat = HOST_DO_DU; 1575 1576 for (;;) { 1577 if ((pScb->SCB_Tcs->TCS_JS_Period & PERIOD_WIDE_SCSI) != 0) 1578 bus_space_write_4(iot, ioh, TUL_STCNT0, 2); 1579 else 1580 bus_space_write_4(iot, ioh, TUL_STCNT0, 1); 1581 1582 switch (iha_wait(sc, iot, ioh, XF_FIFO_IN)) { 1583 case -1: 1584 return (-1); 1585 1586 case PHASE_DATA_IN: 1587 bus_space_read_1(iot, ioh, TUL_SFIFO); 1588 break; 1589 1590 default: 1591 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 1592 return (6); 1593 } 1594 } 1595 } 1596 1597 int 1598 iha_xpad_out(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 1599 { 1600 struct iha_scb *pScb = sc->HCS_ActScb; 1601 1602 if ((pScb->SCB_Flags & FLAG_DIR) != 0) 1603 pScb->SCB_HaStat = HOST_DO_DU; 1604 1605 for (;;) { 1606 if ((pScb->SCB_Tcs->TCS_JS_Period & PERIOD_WIDE_SCSI) != 0) 1607 bus_space_write_4(iot, ioh, TUL_STCNT0, 2); 1608 else 1609 bus_space_write_4(iot, ioh, TUL_STCNT0, 1); 1610 1611 bus_space_write_1(iot, ioh, TUL_SFIFO, 0); 1612 1613 switch (iha_wait(sc, iot, ioh, XF_FIFO_OUT)) { 1614 case -1: 1615 return (-1); 1616 1617 case PHASE_DATA_OUT: 1618 break; 1619 1620 default: 1621 /* Disable wide CPU to allow read 16 bits */ 1622 bus_space_write_1(iot, ioh, TUL_SCTRL1, EHRSL); 1623 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 1624 return (6); 1625 } 1626 } 1627 } 1628 1629 int 1630 iha_status_msg(struct iha_softc *sc, bus_space_tag_t iot, 1631 bus_space_handle_t ioh) 1632 { 1633 struct iha_scb *pScb; 1634 u_int8_t msg; 1635 int phase; 1636 1637 if ((phase = iha_wait(sc, iot, ioh, CMD_COMP)) == -1) 1638 return (-1); 1639 1640 pScb = sc->HCS_ActScb; 1641 1642 pScb->SCB_TaStat = bus_space_read_1(iot, ioh, TUL_SFIFO); 1643 1644 if (phase == PHASE_MSG_OUT) { 1645 if ((sc->HCS_JSStatus0 & SPERR) == 0) 1646 bus_space_write_1(iot, ioh, TUL_SFIFO, 1647 MSG_NOOP); 1648 else 1649 bus_space_write_1(iot, ioh, TUL_SFIFO, 1650 MSG_PARITY_ERROR); 1651 1652 return (iha_wait(sc, iot, ioh, XF_FIFO_OUT)); 1653 1654 } else if (phase == PHASE_MSG_IN) { 1655 msg = bus_space_read_1(iot, ioh, TUL_SFIFO); 1656 1657 if ((sc->HCS_JSStatus0 & SPERR) != 0) 1658 switch (iha_wait(sc, iot, ioh, MSG_ACCEPT)) { 1659 case -1: 1660 return (-1); 1661 case PHASE_MSG_OUT: 1662 bus_space_write_1(iot, ioh, TUL_SFIFO, 1663 MSG_PARITY_ERROR); 1664 return (iha_wait(sc, iot, ioh, XF_FIFO_OUT)); 1665 default: 1666 iha_bad_seq(sc); 1667 return (-1); 1668 } 1669 1670 if (msg == MSG_CMDCOMPLETE) { 1671 if ((pScb->SCB_TaStat 1672 & (SCSI_INTERM | SCSI_BUSY)) == SCSI_INTERM) { 1673 iha_bad_seq(sc); 1674 return (-1); 1675 } 1676 sc->HCS_Flags |= FLAG_EXPECT_DONE_DISC; 1677 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 1678 return (iha_wait(sc, iot, ioh, MSG_ACCEPT)); 1679 } 1680 1681 if ((msg == MSG_LINK_CMD_COMPLETE) 1682 || (msg == MSG_LINK_CMD_COMPLETEF)) { 1683 if ((pScb->SCB_TaStat 1684 & (SCSI_INTERM | SCSI_BUSY)) == SCSI_INTERM) 1685 return (iha_wait(sc, iot, ioh, MSG_ACCEPT)); 1686 } 1687 } 1688 1689 iha_bad_seq(sc); 1690 return (-1); 1691 } 1692 1693 /* 1694 * iha_busfree - SCSI bus free detected as a result of a TIMEOUT or 1695 * DISCONNECT interrupt. Reset the tulip FIFO and 1696 * SCONFIG0 and enable hardware reselect. Move any active 1697 * SCB to HCS_DoneScb list. Return an appropriate host status 1698 * if an I/O was active. 1699 */ 1700 void 1701 iha_busfree(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 1702 { 1703 struct iha_scb *pScb; 1704 1705 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 1706 bus_space_write_1(iot, ioh, TUL_SCONFIG0, SCONFIG0DEFAULT); 1707 bus_space_write_1(iot, ioh, TUL_SCTRL1, EHRSL); 1708 1709 pScb = sc->HCS_ActScb; 1710 1711 if (pScb != NULL) { 1712 if (pScb->SCB_Status == STATUS_SELECT) 1713 /* selection timeout */ 1714 iha_append_done_scb(sc, pScb, HOST_SEL_TOUT); 1715 else 1716 /* Unexpected bus free */ 1717 iha_append_done_scb(sc, pScb, HOST_BAD_PHAS); 1718 1719 } 1720 } 1721 1722 void 1723 iha_reset_scsi_bus(struct iha_softc *sc) 1724 { 1725 struct iha_scb *pScb; 1726 struct tcs *pTcs; 1727 int i, s; 1728 1729 s = splbio(); 1730 1731 iha_reset_dma(sc->sc_iot, sc->sc_ioh); 1732 1733 for (i = 0, pScb = sc->HCS_Scb; i < IHA_MAX_SCB; i++, pScb++) 1734 switch (pScb->SCB_Status) { 1735 case STATUS_BUSY: 1736 iha_append_done_scb(sc, pScb, HOST_SCSI_RST); 1737 break; 1738 1739 case STATUS_SELECT: 1740 iha_push_pend_scb(sc, pScb); 1741 break; 1742 1743 default: 1744 break; 1745 } 1746 1747 for (i = 0, pTcs = sc->HCS_Tcs; i < IHA_MAX_TARGETS; i++, pTcs++) 1748 iha_reset_tcs(pTcs, sc->HCS_SConf1); 1749 1750 splx(s); 1751 } 1752 1753 /* 1754 * iha_resel - handle a detected SCSI bus reselection request. 1755 */ 1756 int 1757 iha_resel(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 1758 { 1759 struct iha_scb *pScb; 1760 struct tcs *pTcs; 1761 u_int8_t tag, target, lun, msg, abortmsg; 1762 1763 if (sc->HCS_ActScb != NULL) { 1764 if (sc->HCS_ActScb->SCB_Status == STATUS_SELECT) 1765 iha_push_pend_scb(sc, sc->HCS_ActScb); 1766 sc->HCS_ActScb = NULL; 1767 } 1768 1769 target = bus_space_read_1(iot, ioh, TUL_SBID); 1770 lun = bus_space_read_1(iot, ioh, TUL_SALVC) & MSG_IDENTIFY_LUNMASK; 1771 1772 pTcs = &sc->HCS_Tcs[target]; 1773 1774 bus_space_write_1(iot, ioh, TUL_SCONFIG0, pTcs->TCS_SConfig0); 1775 bus_space_write_1(iot, ioh, TUL_SYNCM, pTcs->TCS_JS_Period); 1776 1777 abortmsg = MSG_ABORT; /* until a valid tag has been obtained */ 1778 1779 if (pTcs->TCS_NonTagScb != NULL) 1780 /* There is a non-tagged I/O active on the target */ 1781 pScb = pTcs->TCS_NonTagScb; 1782 1783 else { 1784 /* 1785 * Since there is no active non-tagged operation 1786 * read the tag type, the tag itself, and find 1787 * the appropriate pScb by indexing HCS_Scb with 1788 * the tag. 1789 */ 1790 1791 switch (iha_wait(sc, iot, ioh, MSG_ACCEPT)) { 1792 case -1: 1793 return (-1); 1794 case PHASE_MSG_IN: 1795 bus_space_write_4(iot, ioh, TUL_STCNT0, 1); 1796 if ((iha_wait(sc, iot, ioh, XF_FIFO_IN)) == -1) 1797 return (-1); 1798 break; 1799 default: 1800 goto abort; 1801 } 1802 1803 msg = bus_space_read_1(iot, ioh, TUL_SFIFO); /* Read Tag Msg */ 1804 1805 if ((msg < MSG_SIMPLE_Q_TAG) || (msg > MSG_ORDERED_Q_TAG)) 1806 goto abort; 1807 1808 switch (iha_wait(sc, iot, ioh, MSG_ACCEPT)) { 1809 case -1: 1810 return (-1); 1811 case PHASE_MSG_IN: 1812 bus_space_write_4(iot, ioh, TUL_STCNT0, 1); 1813 if ((iha_wait(sc, iot, ioh, XF_FIFO_IN)) == -1) 1814 return (-1); 1815 break; 1816 default: 1817 goto abort; 1818 } 1819 1820 tag = bus_space_read_1(iot, ioh, TUL_SFIFO); /* Read Tag ID */ 1821 pScb = &sc->HCS_Scb[tag]; 1822 1823 abortmsg = MSG_ABORT_TAG; /* Now that we have valdid tag! */ 1824 } 1825 1826 if ((pScb->SCB_Target != target) 1827 || (pScb->SCB_Lun != lun) 1828 || (pScb->SCB_Status != STATUS_BUSY)) { 1829 abort: 1830 iha_msgout_abort(sc, iot, ioh, abortmsg); 1831 return (-1); 1832 } 1833 1834 sc->HCS_ActScb = pScb; 1835 1836 if (iha_wait(sc, iot, ioh, MSG_ACCEPT) == -1) 1837 return (-1); 1838 1839 return(iha_next_state(sc, iot, ioh)); 1840 } 1841 1842 int 1843 iha_msgin(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 1844 { 1845 u_int16_t flags; 1846 u_int8_t msg; 1847 int phase; 1848 1849 for (;;) { 1850 if ((bus_space_read_1(iot, ioh, TUL_SFIFOCNT) & FIFOC) > 0) 1851 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 1852 1853 bus_space_write_4(iot, ioh, TUL_STCNT0, 1); 1854 1855 phase = iha_wait(sc, iot, ioh, XF_FIFO_IN); 1856 msg = bus_space_read_1(iot, ioh, TUL_SFIFO); 1857 1858 switch (msg) { 1859 case MSG_DISCONNECT: 1860 sc->HCS_Flags |= FLAG_EXPECT_DISC; 1861 if (iha_wait(sc, iot, ioh, MSG_ACCEPT) != -1) 1862 iha_bad_seq(sc); 1863 phase = -1; 1864 break; 1865 case MSG_SAVEDATAPOINTER: 1866 case MSG_RESTOREPOINTERS: 1867 case MSG_NOOP: 1868 phase = iha_wait(sc, iot, ioh, MSG_ACCEPT); 1869 break; 1870 case MSG_MESSAGE_REJECT: 1871 /* XXX - need to clear FIFO like other 'Clear ATN'?*/ 1872 iha_set_ssig(iot, ioh, REQ | BSY | SEL | ATN, 0); 1873 flags = sc->HCS_ActScb->SCB_Tcs->TCS_Flags; 1874 if ((flags & FLAG_NO_NEG_SYNC) == 0) 1875 iha_set_ssig(iot, ioh, REQ | BSY | SEL, ATN); 1876 phase = iha_wait(sc, iot, ioh, MSG_ACCEPT); 1877 break; 1878 case MSG_EXTENDED: 1879 phase = iha_msgin_extended(sc, iot, ioh); 1880 break; 1881 case MSG_IGN_WIDE_RESIDUE: 1882 phase = iha_msgin_ignore_wid_resid(sc, iot, ioh); 1883 break; 1884 case MSG_CMDCOMPLETE: 1885 sc->HCS_Flags |= FLAG_EXPECT_DONE_DISC; 1886 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 1887 phase = iha_wait(sc, iot, ioh, MSG_ACCEPT); 1888 if (phase != -1) { 1889 iha_bad_seq(sc); 1890 return (-1); 1891 } 1892 break; 1893 default: 1894 #ifdef IHA_DEBUG_STATE 1895 printf("[debug] iha_msgin: bad msg type: %d\n", msg); 1896 #endif 1897 phase = iha_msgout_reject(sc, iot, ioh); 1898 break; 1899 } 1900 1901 if (phase != PHASE_MSG_IN) 1902 return (phase); 1903 } 1904 /* NOTREACHED */ 1905 } 1906 1907 int 1908 iha_msgin_ignore_wid_resid(struct iha_softc *sc, bus_space_tag_t iot, 1909 bus_space_handle_t ioh) 1910 { 1911 int phase; 1912 1913 phase = iha_wait(sc, iot, ioh, MSG_ACCEPT); 1914 1915 if (phase == PHASE_MSG_IN) { 1916 phase = iha_wait(sc, iot, ioh, XF_FIFO_IN); 1917 1918 if (phase != -1) { 1919 bus_space_write_1(iot, ioh, TUL_SFIFO, 0); 1920 bus_space_read_1 (iot, ioh, TUL_SFIFO); 1921 bus_space_read_1 (iot, ioh, TUL_SFIFO); 1922 1923 phase = iha_wait(sc, iot, ioh, MSG_ACCEPT); 1924 } 1925 } 1926 1927 return (phase); 1928 } 1929 1930 int 1931 iha_msgin_extended(struct iha_softc *sc, bus_space_tag_t iot, 1932 bus_space_handle_t ioh) 1933 { 1934 u_int16_t flags; 1935 int i, phase, msglen, msgcode; 1936 1937 /* XXX - can we just stop reading and reject, or do we have to 1938 * read all input, discarding the excess, and then reject 1939 */ 1940 for (i = 0; i < IHA_MAX_EXTENDED_MSG; i++) { 1941 phase = iha_wait(sc, iot, ioh, MSG_ACCEPT); 1942 1943 if (phase != PHASE_MSG_IN) 1944 return (phase); 1945 1946 bus_space_write_4(iot, ioh, TUL_STCNT0, 1); 1947 1948 if (iha_wait(sc, iot, ioh, XF_FIFO_IN) == -1) 1949 return (-1); 1950 1951 sc->HCS_Msg[i] = bus_space_read_1(iot, ioh, TUL_SFIFO); 1952 1953 if (sc->HCS_Msg[0] == i) 1954 break; 1955 } 1956 1957 msglen = sc->HCS_Msg[0]; 1958 msgcode = sc->HCS_Msg[1]; 1959 1960 if ((msglen == MSG_EXT_SDTR_LEN) && (msgcode == MSG_EXT_SDTR)) { 1961 if (iha_msgin_sdtr(sc) == 0) { 1962 iha_sync_done(sc, iot, ioh); 1963 return (iha_wait(sc, iot, ioh, MSG_ACCEPT)); 1964 } 1965 1966 iha_set_ssig(iot, ioh, REQ | BSY | SEL, ATN); 1967 1968 phase = iha_wait(sc, iot, ioh, MSG_ACCEPT); 1969 if (phase != PHASE_MSG_OUT) 1970 return (phase); 1971 1972 /* Clear FIFO for important message - final SYNC offer */ 1973 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 1974 1975 iha_sync_done(sc, iot, ioh); /* This is our final offer */ 1976 1977 } else if ((msglen == MSG_EXT_WDTR_LEN) && (msgcode == MSG_EXT_WDTR)) { 1978 1979 flags = sc->HCS_ActScb->SCB_Tcs->TCS_Flags; 1980 1981 if ((flags & FLAG_NO_WIDE) != 0) 1982 /* Offer 8 bit xfers only */ 1983 sc->HCS_Msg[2] = MSG_EXT_WDTR_BUS_8_BIT; 1984 1985 else if (sc->HCS_Msg[2] > MSG_EXT_WDTR_BUS_32_BIT) 1986 return (iha_msgout_reject(sc, iot, ioh)); 1987 1988 else if (sc->HCS_Msg[2] == MSG_EXT_WDTR_BUS_32_BIT) 1989 /* Offer 16 instead */ 1990 sc->HCS_Msg[2] = MSG_EXT_WDTR_BUS_32_BIT; 1991 1992 else { 1993 iha_wide_done(sc, iot, ioh); 1994 if ((flags & FLAG_NO_NEG_SYNC) == 0) 1995 iha_set_ssig(iot, ioh, REQ | BSY | SEL, ATN); 1996 return (iha_wait(sc, iot, ioh, MSG_ACCEPT)); 1997 } 1998 1999 iha_set_ssig(iot, ioh, REQ | BSY | SEL, ATN); 2000 2001 phase = iha_wait(sc, iot, ioh, MSG_ACCEPT); 2002 if (phase != PHASE_MSG_OUT) 2003 return (phase); 2004 2005 } else 2006 return (iha_msgout_reject(sc, iot, ioh)); 2007 2008 /* Send message built in sc->HCS_Msg[] */ 2009 return (iha_msgout_extended(sc, iot, ioh)); 2010 } 2011 2012 /* 2013 * iha_msgin_sdtr - check SDTR msg in HCS_Msg. If the offer is 2014 * acceptable leave HCS_Msg as is and return 0. 2015 * If the negotiation must continue, modify HCS_Msg 2016 * as needed and return 1. Else return 0. 2017 */ 2018 int 2019 iha_msgin_sdtr(struct iha_softc *sc) 2020 { 2021 u_int16_t flags; 2022 u_int8_t default_period; 2023 int newoffer; 2024 2025 flags = sc->HCS_ActScb->SCB_Tcs->TCS_Flags; 2026 2027 default_period = iha_rate_tbl[flags & FLAG_SCSI_RATE]; 2028 2029 if (sc->HCS_Msg[3] == 0) /* target offered async only. Accept it. */ 2030 return (0); 2031 2032 newoffer = 0; 2033 2034 if ((flags & FLAG_NO_SYNC) != 0) { 2035 sc->HCS_Msg[3] = 0; 2036 newoffer = 1; 2037 } 2038 2039 if (sc->HCS_Msg[3] > IHA_MAX_TARGETS-1) { 2040 sc->HCS_Msg[3] = IHA_MAX_TARGETS-1; 2041 newoffer = 1; 2042 } 2043 2044 if (sc->HCS_Msg[2] < default_period) { 2045 sc->HCS_Msg[2] = default_period; 2046 newoffer = 1; 2047 } 2048 2049 if (sc->HCS_Msg[2] >= 59) { 2050 sc->HCS_Msg[3] = 0; 2051 newoffer = 1; 2052 } 2053 2054 return (newoffer); 2055 } 2056 2057 int 2058 iha_msgout(struct iha_softc *sc, bus_space_tag_t iot, 2059 bus_space_handle_t ioh, u_int8_t msg) 2060 { 2061 bus_space_write_1(iot, ioh, TUL_SFIFO, msg); 2062 2063 return (iha_wait(sc, iot, ioh, XF_FIFO_OUT)); 2064 } 2065 2066 void 2067 iha_msgout_abort(struct iha_softc *sc, bus_space_tag_t iot, 2068 bus_space_handle_t ioh, u_int8_t aborttype) 2069 { 2070 iha_set_ssig(iot, ioh, REQ | BSY | SEL, ATN); 2071 2072 switch (iha_wait(sc, iot, ioh, MSG_ACCEPT)) { 2073 case -1: 2074 break; 2075 2076 case PHASE_MSG_OUT: 2077 sc->HCS_Flags |= FLAG_EXPECT_DISC; 2078 if (iha_msgout(sc, iot, ioh, aborttype) != -1) 2079 iha_bad_seq(sc); 2080 break; 2081 2082 default: 2083 iha_bad_seq(sc); 2084 break; 2085 } 2086 } 2087 2088 int 2089 iha_msgout_reject(struct iha_softc *sc, bus_space_tag_t iot, 2090 bus_space_handle_t ioh) 2091 { 2092 iha_set_ssig(iot, ioh, REQ | BSY | SEL, ATN); 2093 2094 if (iha_wait(sc, iot, ioh, MSG_ACCEPT) == PHASE_MSG_OUT) 2095 return (iha_msgout(sc, iot, ioh, MSG_MESSAGE_REJECT)); 2096 2097 return (-1); 2098 } 2099 2100 int 2101 iha_msgout_extended(struct iha_softc *sc, bus_space_tag_t iot, 2102 bus_space_handle_t ioh) 2103 { 2104 int phase; 2105 2106 bus_space_write_1(iot, ioh, TUL_SFIFO, MSG_EXTENDED); 2107 2108 bus_space_write_multi_1(iot, ioh, TUL_SFIFO, 2109 sc->HCS_Msg, sc->HCS_Msg[0]+1); 2110 2111 phase = iha_wait(sc, iot, ioh, XF_FIFO_OUT); 2112 2113 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 2114 iha_set_ssig(iot, ioh, REQ | BSY | SEL | ATN, 0); 2115 2116 return (phase); 2117 } 2118 2119 int 2120 iha_msgout_wdtr(struct iha_softc *sc, bus_space_tag_t iot, 2121 bus_space_handle_t ioh) 2122 { 2123 sc->HCS_ActScb->SCB_Tcs->TCS_Flags |= FLAG_WIDE_DONE; 2124 2125 sc->HCS_Msg[0] = MSG_EXT_WDTR_LEN; 2126 sc->HCS_Msg[1] = MSG_EXT_WDTR; 2127 sc->HCS_Msg[2] = MSG_EXT_WDTR_BUS_16_BIT; 2128 2129 return (iha_msgout_extended(sc, iot, ioh)); 2130 } 2131 2132 int 2133 iha_msgout_sdtr(struct iha_softc *sc, bus_space_tag_t iot, 2134 bus_space_handle_t ioh) 2135 { 2136 u_int16_t rateindex; 2137 u_int8_t sync_rate; 2138 2139 rateindex = sc->HCS_ActScb->SCB_Tcs->TCS_Flags & FLAG_SCSI_RATE; 2140 2141 sync_rate = iha_rate_tbl[rateindex]; 2142 2143 sc->HCS_Msg[0] = MSG_EXT_SDTR_LEN; 2144 sc->HCS_Msg[1] = MSG_EXT_SDTR; 2145 sc->HCS_Msg[2] = sync_rate; 2146 sc->HCS_Msg[3] = IHA_MAX_TARGETS-1; /* REQ/ACK */ 2147 2148 return (iha_msgout_extended(sc, iot, ioh)); 2149 } 2150 2151 void 2152 iha_wide_done(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 2153 { 2154 struct tcs *pTcs = sc->HCS_ActScb->SCB_Tcs; 2155 2156 pTcs->TCS_JS_Period = 0; 2157 2158 if (sc->HCS_Msg[2] != 0) 2159 pTcs->TCS_JS_Period |= PERIOD_WIDE_SCSI; 2160 2161 pTcs->TCS_SConfig0 &= ~ALTPD; 2162 pTcs->TCS_Flags &= ~FLAG_SYNC_DONE; 2163 pTcs->TCS_Flags |= FLAG_WIDE_DONE; 2164 2165 bus_space_write_1(iot, ioh, TUL_SCONFIG0, pTcs->TCS_SConfig0); 2166 bus_space_write_1(iot, ioh, TUL_SYNCM, pTcs->TCS_JS_Period); 2167 } 2168 2169 void 2170 iha_sync_done(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh) 2171 { 2172 struct tcs *pTcs = sc->HCS_ActScb->SCB_Tcs; 2173 int i; 2174 2175 if ((pTcs->TCS_Flags & FLAG_SYNC_DONE) == 0) { 2176 if (sc->HCS_Msg[3] != 0) { 2177 pTcs->TCS_JS_Period |= sc->HCS_Msg[3]; 2178 2179 /* pick the highest possible rate */ 2180 for (i = 0; i < sizeof(iha_rate_tbl); i++) 2181 if (iha_rate_tbl[i] >= sc->HCS_Msg[2]) 2182 break; 2183 2184 pTcs->TCS_JS_Period |= (i << 4); 2185 pTcs->TCS_SConfig0 |= ALTPD; 2186 } 2187 2188 pTcs->TCS_Flags |= FLAG_SYNC_DONE; 2189 2190 bus_space_write_1(iot, ioh, TUL_SCONFIG0, pTcs->TCS_SConfig0); 2191 bus_space_write_1(iot, ioh, TUL_SYNCM, pTcs->TCS_JS_Period); 2192 } 2193 } 2194 2195 void 2196 iha_reset_chip(struct iha_softc *sc, bus_space_tag_t iot, 2197 bus_space_handle_t ioh) 2198 { 2199 int i; 2200 2201 /* reset tulip chip */ 2202 2203 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSCSI); 2204 2205 do 2206 sc->HCS_JSInt = bus_space_read_1(iot, ioh, TUL_SISTAT); 2207 while((sc->HCS_JSInt & SRSTD) == 0); 2208 2209 iha_set_ssig(iot, ioh, 0, 0); 2210 2211 /* 2212 * Stall for 2 seconds, wait for target's firmware ready. 2213 */ 2214 for (i = 0; i < 2000; i++) 2215 DELAY (1000); 2216 2217 bus_space_read_1(iot, ioh, TUL_SISTAT); /* Clear any active interrupt*/ 2218 } 2219 2220 void 2221 iha_select(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh, 2222 struct iha_scb *pScb, u_int8_t select_type) 2223 { 2224 int s; 2225 2226 switch (select_type) { 2227 case SEL_ATN: 2228 bus_space_write_1(iot, ioh, TUL_SFIFO, pScb->SCB_Ident); 2229 bus_space_write_multi_1(iot, ioh, TUL_SFIFO, 2230 pScb->SCB_CDB, pScb->SCB_CDBLen); 2231 2232 pScb->SCB_NxtStat = 2; 2233 break; 2234 2235 case SELATNSTOP: 2236 pScb->SCB_NxtStat = 1; 2237 break; 2238 2239 case SEL_ATN3: 2240 bus_space_write_1(iot, ioh, TUL_SFIFO, pScb->SCB_Ident); 2241 bus_space_write_1(iot, ioh, TUL_SFIFO, pScb->SCB_TagMsg); 2242 bus_space_write_1(iot, ioh, TUL_SFIFO, pScb->SCB_TagId); 2243 2244 bus_space_write_multi_1(iot, ioh, TUL_SFIFO, pScb->SCB_CDB, 2245 pScb->SCB_CDBLen); 2246 2247 pScb->SCB_NxtStat = 2; 2248 break; 2249 2250 default: 2251 #ifdef IHA_DEBUG_STATE 2252 sc_print_addr(pScb->SCB_Xs->sc_link); 2253 printf("[debug] iha_select() - unknown select type = 0x%02x\n", 2254 select_type); 2255 #endif 2256 return; 2257 } 2258 2259 s = splbio(); 2260 TAILQ_REMOVE(&sc->HCS_PendScb, pScb, SCB_ScbList); 2261 splx(s); 2262 2263 pScb->SCB_Status = STATUS_SELECT; 2264 2265 sc->HCS_ActScb = pScb; 2266 2267 bus_space_write_1(iot, ioh, TUL_SCMD, select_type); 2268 } 2269 2270 /* 2271 * iha_wait - wait for an interrupt to service or a SCSI bus phase change 2272 * after writing the supplied command to the tulip chip. If 2273 * the command is NO_OP, skip the command writing. 2274 */ 2275 int 2276 iha_wait(struct iha_softc *sc, bus_space_tag_t iot, bus_space_handle_t ioh, 2277 u_int8_t cmd) 2278 { 2279 if (cmd != NO_OP) 2280 bus_space_write_1(iot, ioh, TUL_SCMD, cmd); 2281 2282 /* 2283 * Have to do this here, in addition to in iha_isr, because 2284 * interrupts might be turned off when we get here. 2285 */ 2286 do 2287 sc->HCS_JSStatus0 = bus_space_read_1(iot, ioh, TUL_STAT0); 2288 while ((sc->HCS_JSStatus0 & INTPD) == 0); 2289 2290 sc->HCS_JSStatus1 = bus_space_read_1(iot, ioh, TUL_STAT1); 2291 sc->HCS_JSInt = bus_space_read_1(iot, ioh, TUL_SISTAT); 2292 2293 sc->HCS_Phase = sc->HCS_JSStatus0 & PH_MASK; 2294 2295 if ((sc->HCS_JSInt & SRSTD) != 0) { 2296 /* SCSI bus reset interrupt */ 2297 iha_reset_scsi_bus(sc); 2298 return (-1); 2299 } 2300 2301 if ((sc->HCS_JSInt & RSELED) != 0) 2302 /* Reselection interrupt */ 2303 return (iha_resel(sc, iot, ioh)); 2304 2305 if ((sc->HCS_JSInt & STIMEO) != 0) { 2306 /* selected/reselected timeout interrupt */ 2307 iha_busfree(sc, iot, ioh); 2308 return (-1); 2309 } 2310 2311 if ((sc->HCS_JSInt & DISCD) != 0) { 2312 /* BUS disconnection interrupt */ 2313 if ((sc->HCS_Flags & FLAG_EXPECT_DONE_DISC) != 0) { 2314 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 2315 bus_space_write_1(iot, ioh, TUL_SCONFIG0, 2316 SCONFIG0DEFAULT); 2317 bus_space_write_1(iot, ioh, TUL_SCTRL1, EHRSL); 2318 iha_append_done_scb(sc, sc->HCS_ActScb, HOST_OK); 2319 sc->HCS_Flags &= ~FLAG_EXPECT_DONE_DISC; 2320 2321 } else if ((sc->HCS_Flags & FLAG_EXPECT_DISC) != 0) { 2322 bus_space_write_1(iot, ioh, TUL_SCTRL0, RSFIFO); 2323 bus_space_write_1(iot, ioh, TUL_SCONFIG0, 2324 SCONFIG0DEFAULT); 2325 bus_space_write_1(iot, ioh, TUL_SCTRL1, EHRSL); 2326 sc->HCS_ActScb = NULL; 2327 sc->HCS_Flags &= ~FLAG_EXPECT_DISC; 2328 2329 } else 2330 iha_busfree(sc, iot, ioh); 2331 2332 return (-1); 2333 } 2334 2335 return (sc->HCS_Phase); 2336 } 2337 2338 /* 2339 * iha_done_scb - We have a scb which has been processed by the 2340 * adaptor, now we look to see how the operation went. 2341 */ 2342 void 2343 iha_done_scb(struct iha_softc *sc, struct iha_scb *pScb) 2344 { 2345 struct scsi_sense_data *s1, *s2; 2346 struct scsi_xfer *xs = pScb->SCB_Xs; 2347 2348 if (xs != NULL) { 2349 timeout_del(&xs->stimeout); 2350 2351 xs->status = pScb->SCB_TaStat; 2352 2353 if ((pScb->SCB_Flags & (SCSI_DATA_IN | SCSI_DATA_OUT)) != 0) { 2354 bus_dmamap_sync(sc->sc_dmat, pScb->SCB_DataDma, 2355 0, pScb->SCB_BufChars, 2356 ((pScb->SCB_Flags & SCSI_DATA_IN) ? 2357 BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE)); 2358 bus_dmamap_unload(sc->sc_dmat, pScb->SCB_DataDma); 2359 } 2360 if ((pScb->SCB_Flags & FLAG_SG) != 0) { 2361 bus_dmamap_sync(sc->sc_dmat, pScb->SCB_SGDma, 2362 0, sizeof(pScb->SCB_SGList), 2363 BUS_DMASYNC_POSTWRITE); 2364 bus_dmamap_unload(sc->sc_dmat, pScb->SCB_SGDma); 2365 } 2366 2367 switch (pScb->SCB_HaStat) { 2368 case HOST_OK: 2369 switch (pScb->SCB_TaStat) { 2370 case SCSI_OK: 2371 case SCSI_COND_MET: 2372 case SCSI_INTERM: 2373 case SCSI_INTERM_COND_MET: 2374 xs->resid = pScb->SCB_BufCharsLeft; 2375 xs->error = XS_NOERROR; 2376 break; 2377 2378 case SCSI_RESV_CONFLICT: 2379 case SCSI_BUSY: 2380 case SCSI_QUEUE_FULL: 2381 xs->error = XS_BUSY; 2382 break; 2383 2384 case SCSI_TERMINATED: 2385 case SCSI_ACA_ACTIVE: 2386 case SCSI_CHECK: 2387 s1 = &pScb->SCB_ScsiSenseData; 2388 s2 = &xs->sense; 2389 *s2 = *s1; 2390 2391 xs->error = XS_SENSE; 2392 break; 2393 2394 default: 2395 xs->error = XS_DRIVER_STUFFUP; 2396 break; 2397 } 2398 break; 2399 2400 case HOST_SEL_TOUT: 2401 xs->error = XS_SELTIMEOUT; 2402 break; 2403 2404 case HOST_SCSI_RST: 2405 case HOST_DEV_RST: 2406 xs->error = XS_RESET; 2407 break; 2408 2409 case HOST_SPERR: 2410 sc_print_addr(xs->sc_link); 2411 printf("SCSI Parity error detected\n"); 2412 xs->error = XS_DRIVER_STUFFUP; 2413 break; 2414 2415 case HOST_TIMED_OUT: 2416 xs->error = XS_TIMEOUT; 2417 break; 2418 2419 case HOST_DO_DU: 2420 case HOST_BAD_PHAS: 2421 default: 2422 xs->error = XS_DRIVER_STUFFUP; 2423 break; 2424 } 2425 scsi_done(xs); 2426 } 2427 } 2428 2429 void 2430 iha_timeout(void *arg) 2431 { 2432 struct iha_scb *pScb = (struct iha_scb *)arg; 2433 struct scsi_xfer *xs = pScb->SCB_Xs; 2434 2435 if (xs != NULL) { 2436 sc_print_addr(xs->sc_link); 2437 printf("SCSI OpCode 0x%02x timed out\n", xs->cmd->opcode); 2438 iha_abort_xs(xs->sc_link->adapter_softc, xs, HOST_TIMED_OUT); 2439 } 2440 } 2441 2442 void 2443 iha_exec_scb(struct iha_softc *sc, struct iha_scb *pScb) 2444 { 2445 struct scsi_xfer *xs = pScb->SCB_Xs; 2446 bus_space_handle_t ioh; 2447 bus_space_tag_t iot; 2448 int s; 2449 2450 s = splbio(); 2451 2452 if ((pScb->SCB_Flags & SCSI_POLL) == 0) 2453 timeout_add_msec(&xs->stimeout, xs->timeout); 2454 2455 if (((pScb->SCB_Flags & SCSI_RESET) != 0) 2456 || (pScb->SCB_CDB[0] == REQUEST_SENSE)) 2457 iha_push_pend_scb(sc, pScb); /* Insert SCB at head of Pend */ 2458 else 2459 iha_append_pend_scb(sc, pScb); /* Append SCB to tail of Pend */ 2460 2461 /* 2462 * Run through iha_main() to ensure something is active, if 2463 * only this new SCB. 2464 */ 2465 if (sc->HCS_Semaph != SEMAPH_IN_MAIN) { 2466 iot = sc->sc_iot; 2467 ioh = sc->sc_ioh; 2468 2469 bus_space_write_1(iot, ioh, TUL_IMSK, MASK_ALL); 2470 sc->HCS_Semaph = SEMAPH_IN_MAIN; 2471 2472 splx(s); 2473 iha_main(sc, iot, ioh); 2474 s = splbio(); 2475 2476 sc->HCS_Semaph = ~SEMAPH_IN_MAIN; 2477 bus_space_write_1(iot, ioh, TUL_IMSK, (MASK_ALL & ~MSCMP)); 2478 } 2479 2480 splx(s); 2481 } 2482 2483 2484 /* 2485 * iha_set_ssig - read the current scsi signal mask, then write a new 2486 * one which turns off/on the specified signals. 2487 */ 2488 void 2489 iha_set_ssig(bus_space_tag_t iot, bus_space_handle_t ioh, u_int8_t offsigs, 2490 u_int8_t onsigs) 2491 { 2492 u_int8_t currsigs; 2493 2494 currsigs = bus_space_read_1(iot, ioh, TUL_SSIGI); 2495 bus_space_write_1(iot, ioh, TUL_SSIGO, (currsigs & ~offsigs) | onsigs); 2496 } 2497 2498 void 2499 iha_print_info(struct iha_softc *sc, int target) 2500 { 2501 u_int8_t period = sc->HCS_Tcs[target].TCS_JS_Period; 2502 u_int8_t config = sc->HCS_Tcs[target].TCS_SConfig0; 2503 int rate; 2504 2505 printf("%s: target %d using %d bit ", sc->sc_dev.dv_xname, target, 2506 (period & PERIOD_WIDE_SCSI) ? 16 : 8); 2507 2508 if ((period & PERIOD_SYOFS) == 0) 2509 printf("async "); 2510 else { 2511 rate = (period & PERIOD_SYXPD) >> 4; 2512 if ((config & ALTPD) == 0) 2513 rate = 100 + rate * 50; 2514 else 2515 rate = 50 + rate * 25; 2516 rate = 1000000000 / rate; 2517 printf("%d.%d MHz %d REQ/ACK offset ", rate / 1000000, 2518 (rate % 1000000 + 99999) / 100000, period & PERIOD_SYOFS); 2519 } 2520 2521 printf("xfers\n"); 2522 } 2523 2524 2525 /* 2526 * iha_alloc_scbs - allocate and map the SCB's for the supplied iha_softc 2527 */ 2528 int 2529 iha_alloc_scbs(struct iha_softc *sc) 2530 { 2531 bus_dma_segment_t seg; 2532 int error, rseg; 2533 2534 /* 2535 * Allocate dma-safe memory for the SCB's 2536 */ 2537 if ((error = bus_dmamem_alloc(sc->sc_dmat, 2538 sizeof(struct iha_scb)*IHA_MAX_SCB, 2539 NBPG, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT | BUS_DMA_ZERO)) 2540 != 0) { 2541 printf("%s: unable to allocate SCBs," 2542 " error = %d\n", sc->sc_dev.dv_xname, error); 2543 return (error); 2544 } 2545 if ((error = bus_dmamem_map(sc->sc_dmat, 2546 &seg, rseg, sizeof(struct iha_scb)*IHA_MAX_SCB, 2547 (caddr_t *)&sc->HCS_Scb, BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) 2548 != 0) { 2549 printf("%s: unable to map SCBs, error = %d\n", 2550 sc->sc_dev.dv_xname, error); 2551 return (error); 2552 } 2553 2554 return (0); 2555 } 2556 2557 /* 2558 * iha_read_eeprom - read contents of serial EEPROM into iha_nvram pointed at 2559 * by parameter nvram. 2560 */ 2561 void 2562 iha_read_eeprom(bus_space_tag_t iot, bus_space_handle_t ioh, 2563 struct iha_nvram *nvram) 2564 { 2565 u_int32_t chksum; 2566 u_int16_t *np; 2567 u_int8_t gctrl, addr; 2568 2569 const int chksum_addr = offsetof(struct iha_nvram, NVM_CheckSum) / 2; 2570 2571 /* Enable EEProm programming */ 2572 gctrl = bus_space_read_1(iot, ioh, TUL_GCTRL0) | EEPRG; 2573 bus_space_write_1(iot, ioh, TUL_GCTRL0, gctrl); 2574 2575 /* Read EEProm */ 2576 np = (u_int16_t *)nvram; 2577 for (addr=0, chksum=0; addr < chksum_addr; addr++, np++) { 2578 *np = iha_se2_rd(iot, ioh, addr); 2579 chksum += *np; 2580 } 2581 2582 chksum &= 0x0000ffff; 2583 nvram->NVM_CheckSum = iha_se2_rd(iot, ioh, chksum_addr); 2584 2585 /* Disable EEProm programming */ 2586 gctrl = bus_space_read_1(iot, ioh, TUL_GCTRL0) & ~EEPRG; 2587 bus_space_write_1(iot, ioh, TUL_GCTRL0, gctrl); 2588 2589 if ((nvram->NVM_Signature != SIGNATURE) 2590 || 2591 (nvram->NVM_CheckSum != chksum)) 2592 panic("iha: invalid EEPROM, bad signature or checksum"); 2593 } 2594 2595 /* 2596 * iha_se2_rd - read & return the 16 bit value at the specified 2597 * offset in the Serial E2PROM 2598 * 2599 */ 2600 u_int16_t 2601 iha_se2_rd(bus_space_tag_t iot, bus_space_handle_t ioh, u_int8_t addr) 2602 { 2603 u_int16_t readWord; 2604 u_int8_t bit; 2605 int i; 2606 2607 /* Send 'READ' instruction == address | READ bit */ 2608 iha_se2_instr(iot, ioh, (addr | NVREAD)); 2609 2610 readWord = 0; 2611 for (i = 15; i >= 0; i--) { 2612 bus_space_write_1(iot, ioh, TUL_NVRAM, NVRCS | NVRCK); 2613 DELAY(5); 2614 2615 bus_space_write_1(iot, ioh, TUL_NVRAM, NVRCS); 2616 DELAY(5); 2617 2618 /* sample data after the following edge of clock */ 2619 bit = bus_space_read_1(iot, ioh, TUL_NVRAM) & NVRDI; 2620 DELAY(5); 2621 2622 readWord += bit << i; 2623 } 2624 2625 bus_space_write_1(iot, ioh, TUL_NVRAM, 0); 2626 DELAY(5); 2627 2628 return (readWord); 2629 } 2630 2631 /* 2632 * iha_se2_instr - write an octet to serial E2PROM one bit at a time 2633 */ 2634 void 2635 iha_se2_instr(bus_space_tag_t iot, bus_space_handle_t ioh, u_int8_t instr) 2636 { 2637 u_int8_t b; 2638 int i; 2639 2640 b = NVRCS | NVRDO; /* Write the start bit (== 1) */ 2641 2642 bus_space_write_1(iot, ioh, TUL_NVRAM, b); 2643 DELAY(5); 2644 bus_space_write_1(iot, ioh, TUL_NVRAM, b | NVRCK); 2645 DELAY(5); 2646 2647 for (i = 0; i < 8; i++, instr <<= 1) { 2648 if (instr & 0x80) 2649 b = NVRCS | NVRDO; /* Write a 1 bit */ 2650 else 2651 b = NVRCS; /* Write a 0 bit */ 2652 2653 bus_space_write_1(iot, ioh, TUL_NVRAM, b); 2654 DELAY(5); 2655 bus_space_write_1(iot, ioh, TUL_NVRAM, b | NVRCK); 2656 DELAY(5); 2657 } 2658 2659 bus_space_write_1(iot, ioh, TUL_NVRAM, NVRCS); 2660 DELAY(5); 2661 2662 return; 2663 } 2664 2665 /* 2666 * iha_reset_tcs - reset the target control structure pointed 2667 * to by pTcs to default values. TCS_Flags 2668 * only has the negotiation done bits reset as 2669 * the other bits are fixed at initialization. 2670 */ 2671 void 2672 iha_reset_tcs(struct tcs *pTcs, u_int8_t config0) 2673 { 2674 pTcs->TCS_Flags &= ~(FLAG_SYNC_DONE | FLAG_WIDE_DONE); 2675 pTcs->TCS_JS_Period = 0; 2676 pTcs->TCS_SConfig0 = config0; 2677 pTcs->TCS_TagCnt = 0; 2678 pTcs->TCS_NonTagScb = NULL; 2679 } 2680