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