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