1 /* $OpenBSD: ciss.c,v 1.75 2016/08/14 04:08:03 dlg Exp $ */ 2 3 /* 4 * Copyright (c) 2005,2006 Michael Shalayeff 5 * All rights reserved. 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER IN 16 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 17 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #include "bio.h" 21 22 /* #define CISS_DEBUG */ 23 24 #include <sys/param.h> 25 #include <sys/systm.h> 26 #include <sys/buf.h> 27 #include <sys/ioctl.h> 28 #include <sys/device.h> 29 #include <sys/kernel.h> 30 #include <sys/malloc.h> 31 32 #include <machine/bus.h> 33 34 #include <scsi/scsi_all.h> 35 #include <scsi/scsiconf.h> 36 37 #include <dev/ic/cissreg.h> 38 #include <dev/ic/cissvar.h> 39 40 #if NBIO > 0 41 #include <dev/biovar.h> 42 #endif 43 #include <sys/sensors.h> 44 45 #ifdef CISS_DEBUG 46 #define CISS_DPRINTF(m,a) if (ciss_debug & (m)) printf a 47 #define CISS_D_CMD 0x0001 48 #define CISS_D_INTR 0x0002 49 #define CISS_D_MISC 0x0004 50 #define CISS_D_DMA 0x0008 51 #define CISS_D_IOCTL 0x0010 52 #define CISS_D_ERR 0x0020 53 int ciss_debug = 0 54 /* | CISS_D_CMD */ 55 /* | CISS_D_INTR */ 56 /* | CISS_D_MISC */ 57 /* | CISS_D_DMA */ 58 /* | CISS_D_IOCTL */ 59 /* | CISS_D_ERR */ 60 ; 61 #else 62 #define CISS_DPRINTF(m,a) /* m, a */ 63 #endif 64 65 struct cfdriver ciss_cd = { 66 NULL, "ciss", DV_DULL 67 }; 68 69 void ciss_scsi_cmd(struct scsi_xfer *xs); 70 int ciss_scsi_ioctl(struct scsi_link *, u_long, caddr_t, int); 71 void cissminphys(struct buf *bp, struct scsi_link *sl); 72 73 struct scsi_adapter ciss_switch = { 74 ciss_scsi_cmd, cissminphys, NULL, NULL, ciss_scsi_ioctl 75 }; 76 77 #if NBIO > 0 78 int ciss_ioctl(struct device *, u_long, caddr_t); 79 #endif 80 int ciss_sync(struct ciss_softc *sc); 81 void ciss_heartbeat(void *v); 82 #ifndef SMALL_KERNEL 83 void ciss_sensors(void *); 84 #endif 85 86 void * ciss_get_ccb(void *); 87 void ciss_put_ccb(void *, void *); 88 int ciss_cmd(struct ciss_ccb *ccb, int flags, int wait); 89 int ciss_done(struct ciss_ccb *ccb); 90 int ciss_error(struct ciss_ccb *ccb); 91 92 struct ciss_ld *ciss_pdscan(struct ciss_softc *sc, int ld); 93 int ciss_inq(struct ciss_softc *sc, struct ciss_inquiry *inq); 94 int ciss_ldmap(struct ciss_softc *sc); 95 int ciss_ldid(struct ciss_softc *, int, struct ciss_ldid *); 96 int ciss_ldstat(struct ciss_softc *, int, struct ciss_ldstat *); 97 int ciss_pdid(struct ciss_softc *, u_int8_t, struct ciss_pdid *, int); 98 int ciss_blink(struct ciss_softc *, int, int, int, struct ciss_blink *); 99 100 void * 101 ciss_get_ccb(void *xsc) 102 { 103 struct ciss_softc *sc = xsc; 104 struct ciss_ccb *ccb; 105 106 mtx_enter(&sc->sc_free_ccb_mtx); 107 ccb = SLIST_FIRST(&sc->sc_free_ccb); 108 if (ccb != NULL) { 109 SLIST_REMOVE_HEAD(&sc->sc_free_ccb, ccb_link); 110 ccb->ccb_state = CISS_CCB_READY; 111 ccb->ccb_xs = NULL; 112 } 113 mtx_leave(&sc->sc_free_ccb_mtx); 114 115 return (ccb); 116 } 117 118 void 119 ciss_put_ccb(void *xsc, void *xccb) 120 { 121 struct ciss_softc *sc = xsc; 122 struct ciss_ccb *ccb = xccb; 123 124 ccb->ccb_state = CISS_CCB_FREE; 125 ccb->ccb_xs = NULL; 126 ccb->ccb_data = NULL; 127 128 mtx_enter(&sc->sc_free_ccb_mtx); 129 SLIST_INSERT_HEAD(&sc->sc_free_ccb, ccb, ccb_link); 130 mtx_leave(&sc->sc_free_ccb_mtx); 131 } 132 133 int 134 ciss_attach(struct ciss_softc *sc) 135 { 136 struct scsibus_attach_args saa; 137 struct scsibus_softc *scsibus; 138 struct ciss_ccb *ccb; 139 struct ciss_cmd *cmd; 140 struct ciss_inquiry *inq; 141 bus_dma_segment_t seg[1]; 142 int error, i, total, rseg, maxfer; 143 ciss_lock_t lock; 144 paddr_t pa; 145 146 bus_space_read_region_4(sc->iot, sc->cfg_ioh, sc->cfgoff, 147 (u_int32_t *)&sc->cfg, sizeof(sc->cfg) / 4); 148 149 if (sc->cfg.signature != CISS_SIGNATURE) { 150 printf(": bad sign 0x%08x\n", sc->cfg.signature); 151 return -1; 152 } 153 154 if (!(sc->cfg.methods & CISS_METH_SIMPL)) { 155 printf(": not simple 0x%08x\n", sc->cfg.methods); 156 return -1; 157 } 158 159 sc->cfg.rmethod = CISS_METH_SIMPL; 160 sc->cfg.paddr_lim = 0; /* 32bit addrs */ 161 sc->cfg.int_delay = 0; /* disable coalescing */ 162 sc->cfg.int_count = 0; 163 strlcpy(sc->cfg.hostname, "HUMPPA", sizeof(sc->cfg.hostname)); 164 sc->cfg.driverf |= CISS_DRV_PRF; /* enable prefetch */ 165 if (!sc->cfg.maxsg) 166 sc->cfg.maxsg = MAXPHYS / PAGE_SIZE; 167 168 bus_space_write_region_4(sc->iot, sc->cfg_ioh, sc->cfgoff, 169 (u_int32_t *)&sc->cfg, sizeof(sc->cfg) / 4); 170 bus_space_barrier(sc->iot, sc->cfg_ioh, sc->cfgoff, sizeof(sc->cfg), 171 BUS_SPACE_BARRIER_READ|BUS_SPACE_BARRIER_WRITE); 172 173 bus_space_write_4(sc->iot, sc->ioh, CISS_IDB, CISS_IDB_CFG); 174 bus_space_barrier(sc->iot, sc->ioh, CISS_IDB, 4, 175 BUS_SPACE_BARRIER_WRITE); 176 for (i = 1000; i--; DELAY(1000)) { 177 /* XXX maybe IDB is really 64bit? - hp dl380 needs this */ 178 (void)bus_space_read_4(sc->iot, sc->ioh, CISS_IDB + 4); 179 if (!(bus_space_read_4(sc->iot, sc->ioh, CISS_IDB) & CISS_IDB_CFG)) 180 break; 181 bus_space_barrier(sc->iot, sc->ioh, CISS_IDB, 4, 182 BUS_SPACE_BARRIER_READ); 183 } 184 185 if (bus_space_read_4(sc->iot, sc->ioh, CISS_IDB) & CISS_IDB_CFG) { 186 printf(": cannot set config\n"); 187 return -1; 188 } 189 190 bus_space_read_region_4(sc->iot, sc->cfg_ioh, sc->cfgoff, 191 (u_int32_t *)&sc->cfg, sizeof(sc->cfg) / 4); 192 193 if (!(sc->cfg.amethod & CISS_METH_SIMPL)) { 194 printf(": cannot simplify 0x%08x\n", sc->cfg.amethod); 195 return -1; 196 } 197 198 /* i'm ready for you and i hope you're ready for me */ 199 for (i = 30000; i--; DELAY(1000)) { 200 if (bus_space_read_4(sc->iot, sc->cfg_ioh, sc->cfgoff + 201 offsetof(struct ciss_config, amethod)) & CISS_METH_READY) 202 break; 203 bus_space_barrier(sc->iot, sc->cfg_ioh, sc->cfgoff + 204 offsetof(struct ciss_config, amethod), 4, 205 BUS_SPACE_BARRIER_READ); 206 } 207 208 if (!(bus_space_read_4(sc->iot, sc->cfg_ioh, sc->cfgoff + 209 offsetof(struct ciss_config, amethod)) & CISS_METH_READY)) { 210 printf(": she never came ready for me 0x%08x\n", 211 sc->cfg.amethod); 212 return -1; 213 } 214 215 sc->maxcmd = sc->cfg.maxcmd; 216 sc->maxsg = sc->cfg.maxsg; 217 if (sc->maxsg > MAXPHYS / PAGE_SIZE) 218 sc->maxsg = MAXPHYS / PAGE_SIZE; 219 i = sizeof(struct ciss_ccb) + 220 sizeof(ccb->ccb_cmd.sgl[0]) * (sc->maxsg - 1); 221 for (sc->ccblen = 0x10; sc->ccblen < i; sc->ccblen <<= 1); 222 223 total = sc->ccblen * sc->maxcmd; 224 if ((error = bus_dmamem_alloc(sc->dmat, total, PAGE_SIZE, 0, 225 sc->cmdseg, 1, &rseg, BUS_DMA_NOWAIT | BUS_DMA_ZERO))) { 226 printf(": cannot allocate CCBs (%d)\n", error); 227 return -1; 228 } 229 230 if ((error = bus_dmamem_map(sc->dmat, sc->cmdseg, rseg, total, 231 (caddr_t *)&sc->ccbs, BUS_DMA_NOWAIT))) { 232 printf(": cannot map CCBs (%d)\n", error); 233 return -1; 234 } 235 236 if ((error = bus_dmamap_create(sc->dmat, total, 1, 237 total, 0, BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &sc->cmdmap))) { 238 printf(": cannot create CCBs dmamap (%d)\n", error); 239 bus_dmamem_free(sc->dmat, sc->cmdseg, 1); 240 return -1; 241 } 242 243 if ((error = bus_dmamap_load(sc->dmat, sc->cmdmap, sc->ccbs, total, 244 NULL, BUS_DMA_NOWAIT))) { 245 printf(": cannot load CCBs dmamap (%d)\n", error); 246 bus_dmamem_free(sc->dmat, sc->cmdseg, 1); 247 bus_dmamap_destroy(sc->dmat, sc->cmdmap); 248 return -1; 249 } 250 251 SLIST_INIT(&sc->sc_free_ccb); 252 mtx_init(&sc->sc_free_ccb_mtx, IPL_BIO); 253 254 maxfer = sc->maxsg * PAGE_SIZE; 255 for (i = 0; total; i++, total -= sc->ccblen) { 256 ccb = sc->ccbs + i * sc->ccblen; 257 cmd = &ccb->ccb_cmd; 258 pa = sc->cmdseg[0].ds_addr + i * sc->ccblen; 259 260 ccb->ccb_sc = sc; 261 ccb->ccb_cmdpa = pa + offsetof(struct ciss_ccb, ccb_cmd); 262 ccb->ccb_state = CISS_CCB_FREE; 263 264 cmd->id = htole32(i << 2); 265 cmd->id_hi = htole32(0); 266 cmd->sgin = sc->maxsg; 267 cmd->sglen = htole16((u_int16_t)cmd->sgin); 268 cmd->err_len = htole32(sizeof(ccb->ccb_err)); 269 pa += offsetof(struct ciss_ccb, ccb_err); 270 cmd->err_pa = htole64((u_int64_t)pa); 271 272 if ((error = bus_dmamap_create(sc->dmat, maxfer, sc->maxsg, 273 maxfer, 0, BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, 274 &ccb->ccb_dmamap))) 275 break; 276 277 SLIST_INSERT_HEAD(&sc->sc_free_ccb, ccb, ccb_link); 278 } 279 280 scsi_iopool_init(&sc->sc_iopool, sc, ciss_get_ccb, ciss_put_ccb); 281 282 if (i < sc->maxcmd) { 283 printf(": cannot create ccb#%d dmamap (%d)\n", i, error); 284 if (i == 0) { 285 /* TODO leaking cmd's dmamaps and shitz */ 286 bus_dmamem_free(sc->dmat, sc->cmdseg, 1); 287 bus_dmamap_destroy(sc->dmat, sc->cmdmap); 288 return -1; 289 } 290 } 291 292 if ((error = bus_dmamem_alloc(sc->dmat, PAGE_SIZE, PAGE_SIZE, 0, 293 seg, 1, &rseg, BUS_DMA_NOWAIT | BUS_DMA_ZERO))) { 294 printf(": cannot allocate scratch buffer (%d)\n", error); 295 return -1; 296 } 297 298 if ((error = bus_dmamem_map(sc->dmat, seg, rseg, PAGE_SIZE, 299 (caddr_t *)&sc->scratch, BUS_DMA_NOWAIT))) { 300 printf(": cannot map scratch buffer (%d)\n", error); 301 return -1; 302 } 303 304 lock = CISS_LOCK_SCRATCH(sc); 305 inq = sc->scratch; 306 if (ciss_inq(sc, inq)) { 307 printf(": adapter inquiry failed\n"); 308 CISS_UNLOCK_SCRATCH(sc, lock); 309 bus_dmamem_free(sc->dmat, sc->cmdseg, 1); 310 bus_dmamap_destroy(sc->dmat, sc->cmdmap); 311 return -1; 312 } 313 314 if (!(inq->flags & CISS_INQ_BIGMAP)) { 315 printf(": big map is not supported, flags=%b\n", 316 inq->flags, CISS_INQ_BITS); 317 CISS_UNLOCK_SCRATCH(sc, lock); 318 bus_dmamem_free(sc->dmat, sc->cmdseg, 1); 319 bus_dmamap_destroy(sc->dmat, sc->cmdmap); 320 return -1; 321 } 322 323 sc->maxunits = inq->numld; 324 sc->nbus = inq->nscsi_bus; 325 sc->ndrives = inq->buswidth? inq->buswidth : 256; 326 printf(": %d LD%s, HW rev %d, FW %4.4s/%4.4s", 327 inq->numld, inq->numld == 1? "" : "s", 328 inq->hw_rev, inq->fw_running, inq->fw_stored); 329 if (sc->cfg.methods & CISS_METH_FIFO64) 330 printf(", 64bit fifo"); 331 else if (sc->cfg.methods & CISS_METH_FIFO64_RRO) 332 printf(", 64bit fifo rro"); 333 printf("\n"); 334 335 CISS_UNLOCK_SCRATCH(sc, lock); 336 337 timeout_set(&sc->sc_hb, ciss_heartbeat, sc); 338 timeout_add_sec(&sc->sc_hb, 3); 339 340 /* map LDs */ 341 if (ciss_ldmap(sc)) { 342 printf("%s: adapter LD map failed\n", sc->sc_dev.dv_xname); 343 bus_dmamem_free(sc->dmat, sc->cmdseg, 1); 344 bus_dmamap_destroy(sc->dmat, sc->cmdmap); 345 return -1; 346 } 347 348 if (!(sc->sc_lds = mallocarray(sc->maxunits, sizeof(*sc->sc_lds), 349 M_DEVBUF, M_NOWAIT | M_ZERO))) { 350 bus_dmamem_free(sc->dmat, sc->cmdseg, 1); 351 bus_dmamap_destroy(sc->dmat, sc->cmdmap); 352 return -1; 353 } 354 355 sc->sc_flush = CISS_FLUSH_ENABLE; 356 357 sc->sc_link.adapter_softc = sc; 358 sc->sc_link.openings = sc->maxcmd; 359 sc->sc_link.adapter = &ciss_switch; 360 sc->sc_link.luns = 1; 361 sc->sc_link.adapter_target = sc->maxunits; 362 sc->sc_link.adapter_buswidth = sc->maxunits; 363 sc->sc_link.pool = &sc->sc_iopool; 364 bzero(&saa, sizeof(saa)); 365 saa.saa_sc_link = &sc->sc_link; 366 scsibus = (struct scsibus_softc *)config_found_sm(&sc->sc_dev, 367 &saa, scsiprint, NULL); 368 369 #if NBIO > 0 370 /* XXX for now we can only deal w/ one volume. */ 371 if (!scsibus || sc->maxunits > 1) 372 return 0; 373 374 /* now map all the physdevs into their lds */ 375 /* XXX currently we assign all pf 'em into ld#0 */ 376 for (i = 0; i < sc->maxunits; i++) 377 if (!(sc->sc_lds[i] = ciss_pdscan(sc, i))) 378 return 0; 379 380 if (bio_register(&sc->sc_dev, ciss_ioctl) != 0) 381 printf("%s: controller registration failed", 382 sc->sc_dev.dv_xname); 383 384 sc->sc_flags |= CISS_BIO; 385 #ifndef SMALL_KERNEL 386 sc->sensors = mallocarray(sc->maxunits, sizeof(struct ksensor), 387 M_DEVBUF, M_NOWAIT | M_ZERO); 388 if (sc->sensors) { 389 struct device *dev; 390 391 strlcpy(sc->sensordev.xname, sc->sc_dev.dv_xname, 392 sizeof(sc->sensordev.xname)); 393 for (i = 0; i < sc->maxunits; i++) { 394 sc->sensors[i].type = SENSOR_DRIVE; 395 sc->sensors[i].status = SENSOR_S_UNKNOWN; 396 dev = scsi_get_link(scsibus, i, 0)->device_softc; 397 strlcpy(sc->sensors[i].desc, dev->dv_xname, 398 sizeof(sc->sensors[i].desc)); 399 strlcpy(sc->sc_lds[i]->xname, dev->dv_xname, 400 sizeof(sc->sc_lds[i]->xname)); 401 sensor_attach(&sc->sensordev, &sc->sensors[i]); 402 } 403 if (sensor_task_register(sc, ciss_sensors, 10) == NULL) 404 free(sc->sensors, M_DEVBUF, 405 sc->maxunits * sizeof(struct ksensor)); 406 else 407 sensordev_install(&sc->sensordev); 408 } 409 #endif /* SMALL_KERNEL */ 410 #endif /* BIO > 0 */ 411 412 return 0; 413 } 414 415 void 416 ciss_shutdown(void *v) 417 { 418 struct ciss_softc *sc = v; 419 420 sc->sc_flush = CISS_FLUSH_DISABLE; 421 timeout_del(&sc->sc_hb); 422 ciss_sync(sc); 423 } 424 425 void 426 cissminphys(struct buf *bp, struct scsi_link *sl) 427 { 428 #if 0 /* TODO */ 429 #define CISS_MAXFER (PAGE_SIZE * (sc->maxsg + 1)) 430 if (bp->b_bcount > CISS_MAXFER) 431 bp->b_bcount = CISS_MAXFER; 432 #endif 433 minphys(bp); 434 } 435 436 /* 437 * submit a command and optionally wait for completition. 438 * wait arg abuses SCSI_POLL|SCSI_NOSLEEP flags to request 439 * to wait (SCSI_POLL) and to allow tsleep() (!SCSI_NOSLEEP) 440 * instead of busy loop waiting 441 */ 442 int 443 ciss_cmd(struct ciss_ccb *ccb, int flags, int wait) 444 { 445 struct ciss_softc *sc = ccb->ccb_sc; 446 struct ciss_cmd *cmd = &ccb->ccb_cmd; 447 struct ciss_ccb *ccb1; 448 bus_dmamap_t dmap = ccb->ccb_dmamap; 449 u_int64_t addr; 450 u_int32_t id; 451 int i, tohz, error = 0; 452 453 splassert(IPL_BIO); 454 455 if (ccb->ccb_state != CISS_CCB_READY) { 456 printf("%s: ccb %d not ready state=%b\n", sc->sc_dev.dv_xname, 457 cmd->id, ccb->ccb_state, CISS_CCB_BITS); 458 return (EINVAL); 459 } 460 461 if (ccb->ccb_data) { 462 bus_dma_segment_t *sgd; 463 464 if ((error = bus_dmamap_load(sc->dmat, dmap, ccb->ccb_data, 465 ccb->ccb_len, NULL, flags))) { 466 if (error == EFBIG) 467 printf("more than %d dma segs\n", sc->maxsg); 468 else 469 printf("error %d loading dma map\n", error); 470 if (ccb->ccb_xs) { 471 ccb->ccb_xs->error = XS_DRIVER_STUFFUP; 472 scsi_done(ccb->ccb_xs); 473 ccb->ccb_xs = NULL; 474 } 475 return (error); 476 } 477 cmd->sgin = dmap->dm_nsegs; 478 479 sgd = dmap->dm_segs; 480 CISS_DPRINTF(CISS_D_DMA, ("data=%p/%u<0x%lx/%u", 481 ccb->ccb_data, ccb->ccb_len, sgd->ds_addr, sgd->ds_len)); 482 483 for (i = 0; i < dmap->dm_nsegs; sgd++, i++) { 484 cmd->sgl[i].addr_lo = htole32(sgd->ds_addr); 485 cmd->sgl[i].addr_hi = 486 htole32((u_int64_t)sgd->ds_addr >> 32); 487 cmd->sgl[i].len = htole32(sgd->ds_len); 488 cmd->sgl[i].flags = htole32(0); 489 if (i) 490 CISS_DPRINTF(CISS_D_DMA, 491 (",0x%lx/%u", sgd->ds_addr, sgd->ds_len)); 492 } 493 494 CISS_DPRINTF(CISS_D_DMA, ("> ")); 495 496 bus_dmamap_sync(sc->dmat, dmap, 0, dmap->dm_mapsize, 497 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); 498 } else 499 cmd->sgin = 0; 500 cmd->sglen = htole16((u_int16_t)cmd->sgin); 501 bzero(&ccb->ccb_err, sizeof(ccb->ccb_err)); 502 503 bus_dmamap_sync(sc->dmat, sc->cmdmap, 0, sc->cmdmap->dm_mapsize, 504 BUS_DMASYNC_PREWRITE); 505 506 ccb->ccb_state = CISS_CCB_ONQ; 507 CISS_DPRINTF(CISS_D_CMD, ("submit=0x%x ", cmd->id)); 508 if (sc->cfg.methods & (CISS_METH_FIFO64|CISS_METH_FIFO64_RRO)) { 509 /* 510 * Write the upper 32bits immediately before the lower 511 * 32bits and set bit 63 to indicate 64bit FIFO mode. 512 */ 513 addr = (u_int64_t)ccb->ccb_cmdpa; 514 bus_space_write_4(sc->iot, sc->ioh, CISS_INQ64_HI, 515 (addr >> 32) | 0x80000000); 516 bus_space_write_4(sc->iot, sc->ioh, CISS_INQ64_LO, 517 addr & 0x00000000ffffffffULL); 518 } else 519 bus_space_write_4(sc->iot, sc->ioh, CISS_INQ, ccb->ccb_cmdpa); 520 521 if (wait & SCSI_POLL) { 522 struct timeval tv; 523 int etick; 524 CISS_DPRINTF(CISS_D_CMD, ("waiting ")); 525 526 i = ccb->ccb_xs? ccb->ccb_xs->timeout : 60000; 527 tv.tv_sec = i / 1000; 528 tv.tv_usec = (i % 1000) * 1000; 529 tohz = tvtohz(&tv); 530 if (tohz == 0) 531 tohz = 1; 532 for (i *= 100, etick = tick + tohz; i--; ) { 533 if (!(wait & SCSI_NOSLEEP)) { 534 ccb->ccb_state = CISS_CCB_POLL; 535 CISS_DPRINTF(CISS_D_CMD, ("tsleep(%d) ", tohz)); 536 if (tsleep(ccb, PRIBIO + 1, "ciss_cmd", 537 tohz) == EWOULDBLOCK) { 538 break; 539 } 540 if (ccb->ccb_state != CISS_CCB_ONQ) { 541 tohz = etick - tick; 542 if (tohz <= 0) 543 break; 544 CISS_DPRINTF(CISS_D_CMD, ("T")); 545 continue; 546 } 547 ccb1 = ccb; 548 } else { 549 DELAY(10); 550 551 if (!(bus_space_read_4(sc->iot, sc->ioh, 552 CISS_ISR) & sc->iem)) { 553 CISS_DPRINTF(CISS_D_CMD, ("N")); 554 continue; 555 } 556 557 if (sc->cfg.methods & CISS_METH_FIFO64) { 558 if (bus_space_read_4(sc->iot, sc->ioh, 559 CISS_OUTQ64_HI) == 0xffffffff) { 560 CISS_DPRINTF(CISS_D_CMD, ("Q")); 561 continue; 562 } 563 id = bus_space_read_4(sc->iot, sc->ioh, 564 CISS_OUTQ64_LO); 565 } else if (sc->cfg.methods & 566 CISS_METH_FIFO64_RRO) { 567 id = bus_space_read_4(sc->iot, sc->ioh, 568 CISS_OUTQ64_LO); 569 if (id == 0xffffffff) { 570 CISS_DPRINTF(CISS_D_CMD, ("Q")); 571 continue; 572 } 573 (void)bus_space_read_4(sc->iot, 574 sc->ioh, CISS_OUTQ64_HI); 575 } else { 576 id = bus_space_read_4(sc->iot, sc->ioh, 577 CISS_OUTQ); 578 if (id == 0xffffffff) { 579 CISS_DPRINTF(CISS_D_CMD, ("Q")); 580 continue; 581 } 582 } 583 584 CISS_DPRINTF(CISS_D_CMD, ("got=0x%x ", id)); 585 ccb1 = sc->ccbs + (id >> 2) * sc->ccblen; 586 ccb1->ccb_cmd.id = htole32(id); 587 ccb1->ccb_cmd.id_hi = htole32(0); 588 } 589 590 error = ciss_done(ccb1); 591 if (ccb1 == ccb) 592 return (error); 593 } 594 595 /* if never got a chance to be done above... */ 596 ccb->ccb_err.cmd_stat = CISS_ERR_TMO; 597 error = ciss_done(ccb); 598 599 CISS_DPRINTF(CISS_D_CMD, ("done %d:%d", 600 ccb->ccb_err.cmd_stat, ccb->ccb_err.scsi_stat)); 601 } 602 603 return (error); 604 } 605 606 int 607 ciss_done(struct ciss_ccb *ccb) 608 { 609 struct ciss_softc *sc = ccb->ccb_sc; 610 struct scsi_xfer *xs = ccb->ccb_xs; 611 struct ciss_cmd *cmd = &ccb->ccb_cmd; 612 ciss_lock_t lock; 613 int error = 0; 614 615 CISS_DPRINTF(CISS_D_CMD, ("ciss_done(%p) ", ccb)); 616 617 if (ccb->ccb_state != CISS_CCB_ONQ) { 618 printf("%s: unqueued ccb %p ready, state=%b\n", 619 sc->sc_dev.dv_xname, ccb, ccb->ccb_state, CISS_CCB_BITS); 620 return 1; 621 } 622 lock = CISS_LOCK(sc); 623 ccb->ccb_state = CISS_CCB_READY; 624 625 if (ccb->ccb_cmd.id & CISS_CMD_ERR) 626 error = ciss_error(ccb); 627 628 if (ccb->ccb_data) { 629 bus_dmamap_sync(sc->dmat, ccb->ccb_dmamap, 0, 630 ccb->ccb_dmamap->dm_mapsize, (cmd->flags & CISS_CDB_IN) ? 631 BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE); 632 bus_dmamap_unload(sc->dmat, ccb->ccb_dmamap); 633 } 634 635 if (xs) { 636 xs->resid = 0; 637 scsi_done(xs); 638 } 639 640 CISS_UNLOCK(sc, lock); 641 642 return error; 643 } 644 645 int 646 ciss_error(struct ciss_ccb *ccb) 647 { 648 struct ciss_softc *sc = ccb->ccb_sc; 649 struct ciss_error *err = &ccb->ccb_err; 650 struct scsi_xfer *xs = ccb->ccb_xs; 651 int rv; 652 653 switch ((rv = letoh16(err->cmd_stat))) { 654 case CISS_ERR_OK: 655 rv = 0; 656 break; 657 658 case CISS_ERR_INVCMD: 659 printf("%s: invalid cmd 0x%x: 0x%x is not valid @ 0x%x[%d]\n", 660 sc->sc_dev.dv_xname, ccb->ccb_cmd.id, 661 err->err_info, err->err_type[3], err->err_type[2]); 662 if (xs) { 663 bzero(&xs->sense, sizeof(xs->sense)); 664 xs->sense.error_code = SSD_ERRCODE_VALID | 665 SSD_ERRCODE_CURRENT; 666 xs->sense.flags = SKEY_ILLEGAL_REQUEST; 667 xs->sense.add_sense_code = 0x24; /* ill field */ 668 xs->error = XS_SENSE; 669 } 670 rv = EIO; 671 break; 672 673 case CISS_ERR_TMO: 674 xs->error = XS_TIMEOUT; 675 rv = ETIMEDOUT; 676 break; 677 678 default: 679 if (xs) { 680 switch (err->scsi_stat) { 681 case SCSI_CHECK: 682 xs->error = XS_SENSE; 683 bcopy(&err->sense[0], &xs->sense, 684 sizeof(xs->sense)); 685 rv = EIO; 686 break; 687 688 case SCSI_BUSY: 689 xs->error = XS_BUSY; 690 rv = EBUSY; 691 break; 692 693 default: 694 CISS_DPRINTF(CISS_D_ERR, ("%s: " 695 "cmd_stat %x scsi_stat 0x%x\n", 696 sc->sc_dev.dv_xname, rv, err->scsi_stat)); 697 xs->error = XS_DRIVER_STUFFUP; 698 rv = EIO; 699 break; 700 } 701 xs->resid = letoh32(err->resid); 702 } else 703 rv = EIO; 704 } 705 ccb->ccb_cmd.id &= htole32(~3); 706 707 return rv; 708 } 709 710 int 711 ciss_inq(struct ciss_softc *sc, struct ciss_inquiry *inq) 712 { 713 struct ciss_ccb *ccb; 714 struct ciss_cmd *cmd; 715 int rv; 716 int s; 717 718 ccb = scsi_io_get(&sc->sc_iopool, SCSI_POLL|SCSI_NOSLEEP); 719 if (ccb == NULL) 720 return ENOMEM; 721 722 ccb->ccb_len = sizeof(*inq); 723 ccb->ccb_data = inq; 724 cmd = &ccb->ccb_cmd; 725 cmd->tgt = htole32(CISS_CMD_MODE_PERIPH); 726 cmd->tgt2 = 0; 727 cmd->cdblen = 10; 728 cmd->flags = CISS_CDB_CMD | CISS_CDB_SIMPL | CISS_CDB_IN; 729 cmd->tmo = htole16(0); 730 bzero(&cmd->cdb[0], sizeof(cmd->cdb)); 731 cmd->cdb[0] = CISS_CMD_CTRL_GET; 732 cmd->cdb[6] = CISS_CMS_CTRL_CTRL; 733 cmd->cdb[7] = sizeof(*inq) >> 8; /* biiiig endian */ 734 cmd->cdb[8] = sizeof(*inq) & 0xff; 735 736 s = splbio(); 737 rv = ciss_cmd(ccb, BUS_DMA_NOWAIT, SCSI_POLL|SCSI_NOSLEEP); 738 splx(s); 739 740 scsi_io_put(&sc->sc_iopool, ccb); 741 742 return (rv); 743 } 744 745 int 746 ciss_ldmap(struct ciss_softc *sc) 747 { 748 struct ciss_ccb *ccb; 749 struct ciss_cmd *cmd; 750 struct ciss_ldmap *lmap; 751 ciss_lock_t lock; 752 int total, rv; 753 754 lock = CISS_LOCK_SCRATCH(sc); 755 lmap = sc->scratch; 756 lmap->size = htobe32(sc->maxunits * sizeof(lmap->map)); 757 total = sizeof(*lmap) + (sc->maxunits - 1) * sizeof(lmap->map); 758 759 ccb = scsi_io_get(&sc->sc_iopool, SCSI_POLL|SCSI_NOSLEEP); 760 if (ccb == NULL) { 761 CISS_UNLOCK_SCRATCH(sc, lock); 762 return ENOMEM; 763 } 764 765 ccb->ccb_len = total; 766 ccb->ccb_data = lmap; 767 cmd = &ccb->ccb_cmd; 768 cmd->tgt = CISS_CMD_MODE_PERIPH; 769 cmd->tgt2 = 0; 770 cmd->cdblen = 12; 771 cmd->flags = CISS_CDB_CMD | CISS_CDB_SIMPL | CISS_CDB_IN; 772 cmd->tmo = htole16(30); 773 bzero(&cmd->cdb[0], sizeof(cmd->cdb)); 774 cmd->cdb[0] = CISS_CMD_LDMAP; 775 cmd->cdb[8] = total >> 8; /* biiiig endian */ 776 cmd->cdb[9] = total & 0xff; 777 778 rv = ciss_cmd(ccb, BUS_DMA_NOWAIT, SCSI_POLL|SCSI_NOSLEEP); 779 scsi_io_put(&sc->sc_iopool, ccb); 780 CISS_UNLOCK_SCRATCH(sc, lock); 781 782 if (rv) 783 return rv; 784 785 CISS_DPRINTF(CISS_D_MISC, ("lmap %x:%x\n", 786 lmap->map[0].tgt, lmap->map[0].tgt2)); 787 788 return 0; 789 } 790 791 int 792 ciss_sync(struct ciss_softc *sc) 793 { 794 struct ciss_ccb *ccb; 795 struct ciss_cmd *cmd; 796 struct ciss_flush *flush; 797 ciss_lock_t lock; 798 int rv; 799 800 lock = CISS_LOCK_SCRATCH(sc); 801 flush = sc->scratch; 802 bzero(flush, sizeof(*flush)); 803 flush->flush = sc->sc_flush; 804 805 ccb = scsi_io_get(&sc->sc_iopool, SCSI_POLL|SCSI_NOSLEEP); 806 if (ccb == NULL) { 807 CISS_UNLOCK_SCRATCH(sc, lock); 808 return ENOMEM; 809 } 810 811 ccb->ccb_len = sizeof(*flush); 812 ccb->ccb_data = flush; 813 cmd = &ccb->ccb_cmd; 814 cmd->tgt = CISS_CMD_MODE_PERIPH; 815 cmd->tgt2 = 0; 816 cmd->cdblen = 10; 817 cmd->flags = CISS_CDB_CMD | CISS_CDB_SIMPL | CISS_CDB_OUT; 818 cmd->tmo = htole16(0); 819 bzero(&cmd->cdb[0], sizeof(cmd->cdb)); 820 cmd->cdb[0] = CISS_CMD_CTRL_SET; 821 cmd->cdb[6] = CISS_CMS_CTRL_FLUSH; 822 cmd->cdb[7] = sizeof(*flush) >> 8; /* biiiig endian */ 823 cmd->cdb[8] = sizeof(*flush) & 0xff; 824 825 rv = ciss_cmd(ccb, BUS_DMA_NOWAIT, SCSI_POLL|SCSI_NOSLEEP); 826 scsi_io_put(&sc->sc_iopool, ccb); 827 CISS_UNLOCK_SCRATCH(sc, lock); 828 829 return rv; 830 } 831 832 void 833 ciss_scsi_cmd(struct scsi_xfer *xs) 834 { 835 struct scsi_link *link = xs->sc_link; 836 u_int8_t target = link->target; 837 struct ciss_ccb *ccb; 838 struct ciss_cmd *cmd; 839 ciss_lock_t lock; 840 841 CISS_DPRINTF(CISS_D_CMD, ("ciss_scsi_cmd ")); 842 843 if (xs->cmdlen > CISS_MAX_CDB) { 844 CISS_DPRINTF(CISS_D_CMD, ("CDB too big %p ", xs)); 845 bzero(&xs->sense, sizeof(xs->sense)); 846 xs->sense.error_code = SSD_ERRCODE_VALID | SSD_ERRCODE_CURRENT; 847 xs->sense.flags = SKEY_ILLEGAL_REQUEST; 848 xs->sense.add_sense_code = 0x20; /* illcmd, 0x24 illfield */ 849 xs->error = XS_SENSE; 850 scsi_done(xs); 851 return; 852 } 853 854 xs->error = XS_NOERROR; 855 856 /* XXX emulate SYNCHRONIZE_CACHE ??? */ 857 858 ccb = xs->io; 859 860 cmd = &ccb->ccb_cmd; 861 ccb->ccb_len = xs->datalen; 862 ccb->ccb_data = xs->data; 863 ccb->ccb_xs = xs; 864 cmd->tgt = CISS_CMD_MODE_LD | target; 865 cmd->tgt2 = 0; 866 cmd->cdblen = xs->cmdlen; 867 cmd->flags = CISS_CDB_CMD | CISS_CDB_SIMPL; 868 if (xs->flags & SCSI_DATA_IN) 869 cmd->flags |= CISS_CDB_IN; 870 else if (xs->flags & SCSI_DATA_OUT) 871 cmd->flags |= CISS_CDB_OUT; 872 cmd->tmo = htole16(xs->timeout < 1000? 1 : xs->timeout / 1000); 873 bzero(&cmd->cdb[0], sizeof(cmd->cdb)); 874 bcopy(xs->cmd, &cmd->cdb[0], CISS_MAX_CDB); 875 876 lock = CISS_LOCK(sc); 877 ciss_cmd(ccb, BUS_DMA_WAITOK, xs->flags & (SCSI_POLL|SCSI_NOSLEEP)); 878 CISS_UNLOCK(sc, lock); 879 } 880 881 int 882 ciss_intr(void *v) 883 { 884 struct ciss_softc *sc = v; 885 struct ciss_ccb *ccb; 886 bus_size_t reg; 887 u_int32_t id; 888 int hit = 0; 889 890 CISS_DPRINTF(CISS_D_INTR, ("intr ")); 891 892 if (!(bus_space_read_4(sc->iot, sc->ioh, CISS_ISR) & sc->iem)) 893 return 0; 894 895 if (sc->cfg.methods & CISS_METH_FIFO64) 896 reg = CISS_OUTQ64_HI; 897 else if (sc->cfg.methods & CISS_METH_FIFO64_RRO) 898 reg = CISS_OUTQ64_LO; 899 else 900 reg = CISS_OUTQ; 901 while ((id = bus_space_read_4(sc->iot, sc->ioh, reg)) != 0xffffffff) { 902 if (reg == CISS_OUTQ64_HI) 903 id = bus_space_read_4(sc->iot, sc->ioh, 904 CISS_OUTQ64_LO); 905 else if (reg == CISS_OUTQ64_LO) 906 (void)bus_space_read_4(sc->iot, sc->ioh, 907 CISS_OUTQ64_HI); 908 ccb = sc->ccbs + (id >> 2) * sc->ccblen; 909 ccb->ccb_cmd.id = htole32(id); 910 ccb->ccb_cmd.id_hi = htole32(0); /* ignore the upper 32bits */ 911 if (ccb->ccb_state == CISS_CCB_POLL) { 912 ccb->ccb_state = CISS_CCB_ONQ; 913 wakeup(ccb); 914 } else 915 ciss_done(ccb); 916 917 hit = 1; 918 } 919 CISS_DPRINTF(CISS_D_INTR, ("exit ")); 920 return hit; 921 } 922 923 void 924 ciss_heartbeat(void *v) 925 { 926 struct ciss_softc *sc = v; 927 u_int32_t hb; 928 929 hb = bus_space_read_4(sc->iot, sc->cfg_ioh, 930 sc->cfgoff + offsetof(struct ciss_config, heartbeat)); 931 if (hb == sc->heartbeat) { 932 sc->fibrillation++; 933 CISS_DPRINTF(CISS_D_ERR, ("%s: fibrillation #%d (value=%d)\n", 934 sc->sc_dev.dv_xname, sc->fibrillation, hb)); 935 if (sc->fibrillation >= 11) { 936 /* No heartbeat for 33 seconds */ 937 panic("%s: dead", sc->sc_dev.dv_xname); /* XXX reset! */ 938 } 939 } else { 940 sc->heartbeat = hb; 941 if (sc->fibrillation) { 942 CISS_DPRINTF(CISS_D_ERR, ("%s: " 943 "fibrillation ended (value=%d)\n", 944 sc->sc_dev.dv_xname, hb)); 945 } 946 sc->fibrillation = 0; 947 } 948 949 timeout_add_sec(&sc->sc_hb, 3); 950 } 951 952 int 953 ciss_scsi_ioctl(struct scsi_link *link, u_long cmd, caddr_t addr, int flag) 954 { 955 #if NBIO > 0 956 return ciss_ioctl(link->adapter_softc, cmd, addr); 957 #else 958 return ENOTTY; 959 #endif 960 } 961 962 #if NBIO > 0 963 const int ciss_level[] = { 0, 4, 1, 5, 51, 7 }; 964 const int ciss_stat[] = { BIOC_SVONLINE, BIOC_SVOFFLINE, BIOC_SVOFFLINE, 965 BIOC_SVDEGRADED, BIOC_SVREBUILD, BIOC_SVREBUILD, BIOC_SVDEGRADED, 966 BIOC_SVDEGRADED, BIOC_SVINVALID, BIOC_SVINVALID, BIOC_SVBUILDING, 967 BIOC_SVOFFLINE, BIOC_SVBUILDING }; 968 969 int 970 ciss_ioctl(struct device *dev, u_long cmd, caddr_t addr) 971 { 972 struct ciss_softc *sc = (struct ciss_softc *)dev; 973 struct bioc_inq *bi; 974 struct bioc_vol *bv; 975 struct bioc_disk *bd; 976 struct bioc_blink *bb; 977 /* struct bioc_alarm *ba; */ 978 /* struct bioc_setstate *bss; */ 979 struct ciss_ldid *ldid; 980 struct ciss_ldstat *ldstat; 981 struct ciss_pdid *pdid; 982 struct ciss_blink *blink; 983 struct ciss_ld *ldp; 984 ciss_lock_t lock; 985 u_int8_t drv; 986 int ld, pd, error = 0; 987 u_int blks; 988 989 if (!(sc->sc_flags & CISS_BIO)) 990 return ENOTTY; 991 992 lock = CISS_LOCK(sc); 993 switch (cmd) { 994 case BIOCINQ: 995 bi = (struct bioc_inq *)addr; 996 strlcpy(bi->bi_dev, sc->sc_dev.dv_xname, sizeof(bi->bi_dev)); 997 bi->bi_novol = sc->maxunits; 998 bi->bi_nodisk = sc->ndrives; 999 break; 1000 1001 case BIOCVOL: 1002 bv = (struct bioc_vol *)addr; 1003 if (bv->bv_volid > sc->maxunits) { 1004 error = EINVAL; 1005 break; 1006 } 1007 ldp = sc->sc_lds[bv->bv_volid]; 1008 if (!ldp) { 1009 error = EINVAL; 1010 break; 1011 } 1012 ldid = sc->scratch; 1013 if ((error = ciss_ldid(sc, bv->bv_volid, ldid))) 1014 break; 1015 /* params 30:88:ff:00:00:00:00:00:00:00:00:00:00:00:20:00 */ 1016 bv->bv_status = BIOC_SVINVALID; 1017 blks = (u_int)letoh16(ldid->nblocks[1]) << 16 | 1018 letoh16(ldid->nblocks[0]); 1019 bv->bv_size = blks * (uint64_t)letoh16(ldid->blksize); 1020 bv->bv_level = ciss_level[ldid->type]; 1021 bv->bv_nodisk = ldp->ndrives; 1022 strlcpy(bv->bv_dev, ldp->xname, sizeof(bv->bv_dev)); 1023 strlcpy(bv->bv_vendor, "CISS", sizeof(bv->bv_vendor)); 1024 ldstat = sc->scratch; 1025 bzero(ldstat, sizeof(*ldstat)); 1026 if ((error = ciss_ldstat(sc, bv->bv_volid, ldstat))) 1027 break; 1028 bv->bv_percent = -1; 1029 bv->bv_seconds = 0; 1030 if (ldstat->stat < nitems(ciss_stat)) 1031 bv->bv_status = ciss_stat[ldstat->stat]; 1032 if (bv->bv_status == BIOC_SVREBUILD || 1033 bv->bv_status == BIOC_SVBUILDING) 1034 bv->bv_percent = (blks - 1035 (((u_int)ldstat->prog[3] << 24) | 1036 ((u_int)ldstat->prog[2] << 16) | 1037 ((u_int)ldstat->prog[1] << 8) | 1038 (u_int)ldstat->prog[0])) * 100ULL / blks; 1039 break; 1040 1041 case BIOCDISK: 1042 bd = (struct bioc_disk *)addr; 1043 if (bd->bd_volid > sc->maxunits) { 1044 error = EINVAL; 1045 break; 1046 } 1047 ldp = sc->sc_lds[bd->bd_volid]; 1048 if (!ldp || (pd = bd->bd_diskid) > ldp->ndrives) { 1049 error = EINVAL; 1050 break; 1051 } 1052 ldstat = sc->scratch; 1053 if ((error = ciss_ldstat(sc, bd->bd_volid, ldstat))) 1054 break; 1055 bd->bd_status = -1; 1056 if (ldstat->stat == CISS_LD_REBLD && 1057 ldstat->bigrebuild == ldp->tgts[pd]) 1058 bd->bd_status = BIOC_SDREBUILD; 1059 if (ciss_bitset(ldp->tgts[pd] & (~CISS_BIGBIT), 1060 ldstat->bigfailed)) { 1061 bd->bd_status = BIOC_SDFAILED; 1062 bd->bd_size = 0; 1063 bd->bd_channel = (ldp->tgts[pd] & (~CISS_BIGBIT)) / 1064 sc->ndrives; 1065 bd->bd_target = ldp->tgts[pd] % sc->ndrives; 1066 bd->bd_lun = 0; 1067 bd->bd_vendor[0] = '\0'; 1068 bd->bd_serial[0] = '\0'; 1069 bd->bd_procdev[0] = '\0'; 1070 } else { 1071 pdid = sc->scratch; 1072 if ((error = ciss_pdid(sc, ldp->tgts[pd], pdid, 1073 SCSI_POLL))) 1074 break; 1075 if (bd->bd_status < 0) { 1076 if (pdid->config & CISS_PD_SPARE) 1077 bd->bd_status = BIOC_SDHOTSPARE; 1078 else if (pdid->present & CISS_PD_PRESENT) 1079 bd->bd_status = BIOC_SDONLINE; 1080 else 1081 bd->bd_status = BIOC_SDINVALID; 1082 } 1083 bd->bd_size = (u_int64_t)letoh32(pdid->nblocks) * 1084 letoh16(pdid->blksz); 1085 bd->bd_channel = pdid->bus; 1086 bd->bd_target = pdid->target; 1087 bd->bd_lun = 0; 1088 strlcpy(bd->bd_vendor, pdid->model, 1089 sizeof(bd->bd_vendor)); 1090 strlcpy(bd->bd_serial, pdid->serial, 1091 sizeof(bd->bd_serial)); 1092 bd->bd_procdev[0] = '\0'; 1093 } 1094 break; 1095 1096 case BIOCBLINK: 1097 bb = (struct bioc_blink *)addr; 1098 blink = sc->scratch; 1099 error = EINVAL; 1100 /* XXX workaround completely dumb scsi addressing */ 1101 for (ld = 0; ld < sc->maxunits; ld++) { 1102 ldp = sc->sc_lds[ld]; 1103 if (!ldp) 1104 continue; 1105 if (sc->ndrives == 256) 1106 drv = bb->bb_target; 1107 else 1108 drv = CISS_BIGBIT + 1109 bb->bb_channel * sc->ndrives + 1110 bb->bb_target; 1111 for (pd = 0; pd < ldp->ndrives; pd++) 1112 if (ldp->tgts[pd] == drv) 1113 error = ciss_blink(sc, ld, pd, 1114 bb->bb_status, blink); 1115 } 1116 break; 1117 1118 case BIOCALARM: 1119 case BIOCSETSTATE: 1120 default: 1121 CISS_DPRINTF(CISS_D_IOCTL, ("%s: invalid ioctl\n", 1122 sc->sc_dev.dv_xname)); 1123 error = ENOTTY; 1124 } 1125 CISS_UNLOCK(sc, lock); 1126 1127 return error; 1128 } 1129 1130 #ifndef SMALL_KERNEL 1131 void 1132 ciss_sensors(void *v) 1133 { 1134 struct ciss_softc *sc = v; 1135 struct ciss_ldstat *ldstat; 1136 int i, error; 1137 1138 for (i = 0; i < sc->maxunits; i++) { 1139 ldstat = sc->scratch; 1140 if ((error = ciss_ldstat(sc, i, ldstat))) { 1141 sc->sensors[i].value = 0; 1142 sc->sensors[i].status = SENSOR_S_UNKNOWN; 1143 continue; 1144 } 1145 1146 switch (ldstat->stat) { 1147 case CISS_LD_OK: 1148 sc->sensors[i].value = SENSOR_DRIVE_ONLINE; 1149 sc->sensors[i].status = SENSOR_S_OK; 1150 break; 1151 1152 case CISS_LD_DEGRAD: 1153 sc->sensors[i].value = SENSOR_DRIVE_PFAIL; 1154 sc->sensors[i].status = SENSOR_S_WARN; 1155 break; 1156 1157 case CISS_LD_EXPND: 1158 case CISS_LD_QEXPND: 1159 case CISS_LD_RBLDRD: 1160 case CISS_LD_REBLD: 1161 sc->sensors[i].value = SENSOR_DRIVE_REBUILD; 1162 sc->sensors[i].status = SENSOR_S_WARN; 1163 break; 1164 1165 case CISS_LD_NORDY: 1166 case CISS_LD_PDINV: 1167 case CISS_LD_PDUNC: 1168 case CISS_LD_FAILED: 1169 case CISS_LD_UNCONF: 1170 sc->sensors[i].value = SENSOR_DRIVE_FAIL; 1171 sc->sensors[i].status = SENSOR_S_CRIT; 1172 break; 1173 1174 default: 1175 sc->sensors[i].value = 0; 1176 sc->sensors[i].status = SENSOR_S_UNKNOWN; 1177 } 1178 } 1179 } 1180 #endif /* SMALL_KERNEL */ 1181 1182 int 1183 ciss_ldid(struct ciss_softc *sc, int target, struct ciss_ldid *id) 1184 { 1185 struct ciss_ccb *ccb; 1186 struct ciss_cmd *cmd; 1187 int rv; 1188 int s; 1189 1190 ccb = scsi_io_get(&sc->sc_iopool, SCSI_POLL); 1191 if (ccb == NULL) 1192 return ENOMEM; 1193 1194 ccb->ccb_len = sizeof(*id); 1195 ccb->ccb_data = id; 1196 cmd = &ccb->ccb_cmd; 1197 cmd->tgt = htole32(CISS_CMD_MODE_PERIPH); 1198 cmd->tgt2 = 0; 1199 cmd->cdblen = 10; 1200 cmd->flags = CISS_CDB_CMD | CISS_CDB_SIMPL | CISS_CDB_IN; 1201 cmd->tmo = htole16(0); 1202 bzero(&cmd->cdb[0], sizeof(cmd->cdb)); 1203 cmd->cdb[0] = CISS_CMD_CTRL_GET; 1204 cmd->cdb[5] = target; 1205 cmd->cdb[6] = CISS_CMS_CTRL_LDIDEXT; 1206 cmd->cdb[7] = sizeof(*id) >> 8; /* biiiig endian */ 1207 cmd->cdb[8] = sizeof(*id) & 0xff; 1208 1209 s = splbio(); 1210 rv = ciss_cmd(ccb, BUS_DMA_NOWAIT, SCSI_POLL); 1211 splx(s); 1212 1213 scsi_io_put(&sc->sc_iopool, ccb); 1214 1215 return (rv); 1216 } 1217 1218 int 1219 ciss_ldstat(struct ciss_softc *sc, int target, struct ciss_ldstat *stat) 1220 { 1221 struct ciss_ccb *ccb; 1222 struct ciss_cmd *cmd; 1223 int rv; 1224 int s; 1225 1226 ccb = scsi_io_get(&sc->sc_iopool, SCSI_POLL); 1227 if (ccb == NULL) 1228 return ENOMEM; 1229 1230 ccb->ccb_len = sizeof(*stat); 1231 ccb->ccb_data = stat; 1232 cmd = &ccb->ccb_cmd; 1233 cmd->tgt = htole32(CISS_CMD_MODE_PERIPH); 1234 cmd->tgt2 = 0; 1235 cmd->cdblen = 10; 1236 cmd->flags = CISS_CDB_CMD | CISS_CDB_SIMPL | CISS_CDB_IN; 1237 cmd->tmo = htole16(0); 1238 bzero(&cmd->cdb[0], sizeof(cmd->cdb)); 1239 cmd->cdb[0] = CISS_CMD_CTRL_GET; 1240 cmd->cdb[5] = target; 1241 cmd->cdb[6] = CISS_CMS_CTRL_LDSTAT; 1242 cmd->cdb[7] = sizeof(*stat) >> 8; /* biiiig endian */ 1243 cmd->cdb[8] = sizeof(*stat) & 0xff; 1244 1245 s = splbio(); 1246 rv = ciss_cmd(ccb, BUS_DMA_NOWAIT, SCSI_POLL); 1247 splx(s); 1248 1249 scsi_io_put(&sc->sc_iopool, ccb); 1250 1251 return (rv); 1252 } 1253 1254 int 1255 ciss_pdid(struct ciss_softc *sc, u_int8_t drv, struct ciss_pdid *id, int wait) 1256 { 1257 struct ciss_ccb *ccb; 1258 struct ciss_cmd *cmd; 1259 int rv; 1260 int s; 1261 1262 ccb = scsi_io_get(&sc->sc_iopool, SCSI_POLL); 1263 if (ccb == NULL) 1264 return ENOMEM; 1265 1266 ccb->ccb_len = sizeof(*id); 1267 ccb->ccb_data = id; 1268 cmd = &ccb->ccb_cmd; 1269 cmd->tgt = htole32(CISS_CMD_MODE_PERIPH); 1270 cmd->tgt2 = 0; 1271 cmd->cdblen = 10; 1272 cmd->flags = CISS_CDB_CMD | CISS_CDB_SIMPL | CISS_CDB_IN; 1273 cmd->tmo = htole16(0); 1274 bzero(&cmd->cdb[0], sizeof(cmd->cdb)); 1275 cmd->cdb[0] = CISS_CMD_CTRL_GET; 1276 cmd->cdb[2] = drv; 1277 cmd->cdb[6] = CISS_CMS_CTRL_PDID; 1278 cmd->cdb[7] = sizeof(*id) >> 8; /* biiiig endian */ 1279 cmd->cdb[8] = sizeof(*id) & 0xff; 1280 1281 s = splbio(); 1282 rv = ciss_cmd(ccb, BUS_DMA_NOWAIT, wait); 1283 splx(s); 1284 1285 scsi_io_put(&sc->sc_iopool, ccb); 1286 1287 return (rv); 1288 } 1289 1290 1291 struct ciss_ld * 1292 ciss_pdscan(struct ciss_softc *sc, int ld) 1293 { 1294 struct ciss_pdid *pdid; 1295 struct ciss_ld *ldp; 1296 u_int8_t drv, buf[128]; 1297 int i, j, k = 0; 1298 1299 pdid = sc->scratch; 1300 if (sc->ndrives == 256) { 1301 for (i = 0; i < CISS_BIGBIT; i++) 1302 if (!ciss_pdid(sc, i, pdid, SCSI_NOSLEEP|SCSI_POLL) && 1303 (pdid->present & CISS_PD_PRESENT)) 1304 buf[k++] = i; 1305 } else 1306 for (i = 0; i < sc->nbus; i++) 1307 for (j = 0; j < sc->ndrives; j++) { 1308 drv = CISS_BIGBIT + i * sc->ndrives + j; 1309 if (!ciss_pdid(sc, drv, pdid, 1310 SCSI_NOSLEEP|SCSI_POLL)) 1311 buf[k++] = drv; 1312 } 1313 1314 if (!k) 1315 return NULL; 1316 1317 ldp = malloc(sizeof(*ldp) + (k-1), M_DEVBUF, M_NOWAIT); 1318 if (!ldp) 1319 return NULL; 1320 1321 bzero(&ldp->bling, sizeof(ldp->bling)); 1322 ldp->ndrives = k; 1323 bcopy(buf, ldp->tgts, k); 1324 return ldp; 1325 } 1326 1327 int 1328 ciss_blink(struct ciss_softc *sc, int ld, int pd, int stat, 1329 struct ciss_blink *blink) 1330 { 1331 struct ciss_ccb *ccb; 1332 struct ciss_cmd *cmd; 1333 struct ciss_ld *ldp; 1334 int rv; 1335 int s; 1336 1337 if (ld > sc->maxunits) 1338 return EINVAL; 1339 1340 ldp = sc->sc_lds[ld]; 1341 if (!ldp || pd > ldp->ndrives) 1342 return EINVAL; 1343 1344 ldp->bling.pdtab[ldp->tgts[pd]] = stat == BIOC_SBUNBLINK? 0 : 1345 CISS_BLINK_ALL; 1346 bcopy(&ldp->bling, blink, sizeof(*blink)); 1347 1348 ccb = scsi_io_get(&sc->sc_iopool, SCSI_POLL); 1349 if (ccb == NULL) 1350 return ENOMEM; 1351 1352 ccb->ccb_len = sizeof(*blink); 1353 ccb->ccb_data = blink; 1354 cmd = &ccb->ccb_cmd; 1355 cmd->tgt = htole32(CISS_CMD_MODE_PERIPH); 1356 cmd->tgt2 = 0; 1357 cmd->cdblen = 10; 1358 cmd->flags = CISS_CDB_CMD | CISS_CDB_SIMPL | CISS_CDB_OUT; 1359 cmd->tmo = htole16(0); 1360 bzero(&cmd->cdb[0], sizeof(cmd->cdb)); 1361 cmd->cdb[0] = CISS_CMD_CTRL_SET; 1362 cmd->cdb[6] = CISS_CMS_CTRL_PDBLINK; 1363 cmd->cdb[7] = sizeof(*blink) >> 8; /* biiiig endian */ 1364 cmd->cdb[8] = sizeof(*blink) & 0xff; 1365 1366 s = splbio(); 1367 rv = ciss_cmd(ccb, BUS_DMA_NOWAIT, SCSI_POLL); 1368 splx(s); 1369 1370 scsi_io_put(&sc->sc_iopool, ccb); 1371 1372 return (rv); 1373 } 1374 #endif 1375