Annotation of sys/dev/ic/ami.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ami.c,v 1.184 2007/06/24 05:34:35 dlg Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2001 Michael Shalayeff
! 5: * Copyright (c) 2005 Marco Peereboom
! 6: * Copyright (c) 2006 David Gwynne
! 7: * All rights reserved.
! 8: *
! 9: * The SCSI emulation layer is derived from gdt(4) driver,
! 10: * Copyright (c) 1999, 2000 Niklas Hallqvist. All rights reserved.
! 11: *
! 12: * Redistribution and use in source and binary forms, with or without
! 13: * modification, are permitted provided that the following conditions
! 14: * are met:
! 15: * 1. Redistributions of source code must retain the above copyright
! 16: * notice, this list of conditions and the following disclaimer.
! 17: * 2. Redistributions in binary form must reproduce the above copyright
! 18: * notice, this list of conditions and the following disclaimer in the
! 19: * documentation and/or other materials provided with the distribution.
! 20: *
! 21: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 22: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 23: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 24: * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
! 25: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 26: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
! 27: * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 29: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
! 30: * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
! 31: * THE POSSIBILITY OF SUCH DAMAGE.
! 32: */
! 33: /*
! 34: * American Megatrends Inc. MegaRAID controllers driver
! 35: *
! 36: * This driver was made because these ppl and organizations
! 37: * donated hardware and provided documentation:
! 38: *
! 39: * - 428 model card
! 40: * John Kerbawy, Stephan Matis, Mark Stovall;
! 41: *
! 42: * - 467 and 475 model cards, docs
! 43: * American Megatrends Inc.;
! 44: *
! 45: * - uninterruptable electric power for cvs
! 46: * Theo de Raadt.
! 47: */
! 48:
! 49: #include "bio.h"
! 50:
! 51: /* #define AMI_DEBUG */
! 52:
! 53: #include <sys/param.h>
! 54: #include <sys/systm.h>
! 55: #include <sys/buf.h>
! 56: #include <sys/ioctl.h>
! 57: #include <sys/device.h>
! 58: #include <sys/kernel.h>
! 59: #include <sys/malloc.h>
! 60: #include <sys/proc.h>
! 61: #include <sys/rwlock.h>
! 62:
! 63: #include <machine/bus.h>
! 64:
! 65: #include <scsi/scsi_all.h>
! 66: #include <scsi/scsi_disk.h>
! 67: #include <scsi/scsiconf.h>
! 68:
! 69: #include <dev/ic/amireg.h>
! 70: #include <dev/ic/amivar.h>
! 71:
! 72:
! 73: #if NBIO > 0
! 74: #include <dev/biovar.h>
! 75: #include <sys/sensors.h>
! 76: #endif
! 77:
! 78: #ifdef AMI_DEBUG
! 79: #define AMI_DPRINTF(m,a) do { if (ami_debug & (m)) printf a; } while (0)
! 80: #define AMI_D_CMD 0x0001
! 81: #define AMI_D_INTR 0x0002
! 82: #define AMI_D_MISC 0x0004
! 83: #define AMI_D_DMA 0x0008
! 84: #define AMI_D_IOCTL 0x0010
! 85: int ami_debug = 0
! 86: | AMI_D_CMD
! 87: | AMI_D_INTR
! 88: | AMI_D_MISC
! 89: /* | AMI_D_DMA */
! 90: /* | AMI_D_IOCTL */
! 91: ;
! 92: #else
! 93: #define AMI_DPRINTF(m,a) /* m, a */
! 94: #endif
! 95:
! 96: struct cfdriver ami_cd = {
! 97: NULL, "ami", DV_DULL
! 98: };
! 99:
! 100: int ami_scsi_cmd(struct scsi_xfer *);
! 101: int ami_scsi_ioctl(struct scsi_link *, u_long, caddr_t, int, struct proc *);
! 102: void amiminphys(struct buf *bp);
! 103:
! 104: struct scsi_adapter ami_switch = {
! 105: ami_scsi_cmd, amiminphys, 0, 0, ami_scsi_ioctl
! 106: };
! 107:
! 108: struct scsi_device ami_dev = {
! 109: NULL, NULL, NULL, NULL
! 110: };
! 111:
! 112: int ami_scsi_raw_cmd(struct scsi_xfer *);
! 113:
! 114: struct scsi_adapter ami_raw_switch = {
! 115: ami_scsi_raw_cmd, amiminphys, 0, 0,
! 116: };
! 117:
! 118: struct scsi_device ami_raw_dev = {
! 119: NULL, NULL, NULL, NULL
! 120: };
! 121:
! 122: struct ami_ccb *ami_get_ccb(struct ami_softc *);
! 123: void ami_put_ccb(struct ami_ccb *);
! 124:
! 125: u_int32_t ami_read(struct ami_softc *, bus_size_t);
! 126: void ami_write(struct ami_softc *, bus_size_t, u_int32_t);
! 127:
! 128: void ami_copyhds(struct ami_softc *, const u_int32_t *,
! 129: const u_int8_t *, const u_int8_t *);
! 130: struct ami_mem *ami_allocmem(struct ami_softc *, size_t);
! 131: void ami_freemem(struct ami_softc *, struct ami_mem *);
! 132: int ami_alloc_ccbs(struct ami_softc *, int);
! 133:
! 134: int ami_poll(struct ami_softc *, struct ami_ccb *);
! 135: void ami_start(struct ami_softc *, struct ami_ccb *);
! 136: void ami_complete(struct ami_softc *, struct ami_ccb *, int);
! 137: int ami_done(struct ami_softc *, int);
! 138: void ami_runqueue_tick(void *);
! 139: void ami_runqueue(struct ami_softc *);
! 140:
! 141: int ami_start_xs(struct ami_softc *sc, struct ami_ccb *,
! 142: struct scsi_xfer *);
! 143: void ami_done_xs(struct ami_softc *, struct ami_ccb *);
! 144: void ami_done_pt(struct ami_softc *, struct ami_ccb *);
! 145: void ami_done_flush(struct ami_softc *, struct ami_ccb *);
! 146: void ami_done_sysflush(struct ami_softc *, struct ami_ccb *);
! 147: void ami_stimeout(void *);
! 148:
! 149: void ami_done_ioctl(struct ami_softc *, struct ami_ccb *);
! 150: void ami_done_init(struct ami_softc *, struct ami_ccb *);
! 151:
! 152: void ami_copy_internal_data(struct scsi_xfer *, void *, size_t);
! 153:
! 154: int ami_load_ptmem(struct ami_softc*, struct ami_ccb *,
! 155: void *, size_t, int, int);
! 156:
! 157: #if NBIO > 0
! 158: int ami_mgmt(struct ami_softc *, u_int8_t, u_int8_t, u_int8_t,
! 159: u_int8_t, size_t, void *);
! 160: int ami_drv_inq(struct ami_softc *, u_int8_t, u_int8_t, u_int8_t,
! 161: void *);
! 162: int ami_ioctl(struct device *, u_long, caddr_t);
! 163: int ami_ioctl_inq(struct ami_softc *, struct bioc_inq *);
! 164: int ami_vol(struct ami_softc *, struct bioc_vol *,
! 165: struct ami_big_diskarray *);
! 166: int ami_disk(struct ami_softc *, struct bioc_disk *,
! 167: struct ami_big_diskarray *);
! 168: int ami_ioctl_vol(struct ami_softc *, struct bioc_vol *);
! 169: int ami_ioctl_disk(struct ami_softc *, struct bioc_disk *);
! 170: int ami_ioctl_alarm(struct ami_softc *, struct bioc_alarm *);
! 171: int ami_ioctl_setstate(struct ami_softc *, struct bioc_setstate *);
! 172:
! 173: #ifndef SMALL_KERNEL
! 174: int ami_create_sensors(struct ami_softc *);
! 175: void ami_refresh_sensors(void *);
! 176: #endif
! 177: #endif /* NBIO > 0 */
! 178:
! 179: #define DEVNAME(_s) ((_s)->sc_dev.dv_xname)
! 180:
! 181: struct ami_ccb *
! 182: ami_get_ccb(struct ami_softc *sc)
! 183: {
! 184: struct ami_ccb *ccb;
! 185:
! 186: ccb = TAILQ_FIRST(&sc->sc_ccb_freeq);
! 187: if (ccb) {
! 188: TAILQ_REMOVE(&sc->sc_ccb_freeq, ccb, ccb_link);
! 189: ccb->ccb_state = AMI_CCB_READY;
! 190: }
! 191:
! 192: return (ccb);
! 193: }
! 194:
! 195: void
! 196: ami_put_ccb(struct ami_ccb *ccb)
! 197: {
! 198: struct ami_softc *sc = ccb->ccb_sc;
! 199:
! 200: ccb->ccb_state = AMI_CCB_FREE;
! 201: ccb->ccb_xs = NULL;
! 202: ccb->ccb_flags = 0;
! 203: ccb->ccb_done = NULL;
! 204: TAILQ_INSERT_TAIL(&sc->sc_ccb_freeq, ccb, ccb_link);
! 205: }
! 206:
! 207: u_int32_t
! 208: ami_read(struct ami_softc *sc, bus_size_t r)
! 209: {
! 210: u_int32_t rv;
! 211:
! 212: bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
! 213: BUS_SPACE_BARRIER_READ);
! 214: rv = bus_space_read_4(sc->sc_iot, sc->sc_ioh, r);
! 215:
! 216: AMI_DPRINTF(AMI_D_CMD, ("ari 0x%x 0x08%x ", r, rv));
! 217: return (rv);
! 218: }
! 219:
! 220: void
! 221: ami_write(struct ami_softc *sc, bus_size_t r, u_int32_t v)
! 222: {
! 223: AMI_DPRINTF(AMI_D_CMD, ("awo 0x%x 0x%08x ", r, v));
! 224:
! 225: bus_space_write_4(sc->sc_iot, sc->sc_ioh, r, v);
! 226: bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
! 227: BUS_SPACE_BARRIER_WRITE);
! 228: }
! 229:
! 230: struct ami_mem *
! 231: ami_allocmem(struct ami_softc *sc, size_t size)
! 232: {
! 233: struct ami_mem *am;
! 234: int nsegs;
! 235:
! 236: am = malloc(sizeof(struct ami_mem), M_DEVBUF, M_NOWAIT);
! 237: if (am == NULL)
! 238: return (NULL);
! 239:
! 240: memset(am, 0, sizeof(struct ami_mem));
! 241: am->am_size = size;
! 242:
! 243: if (bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
! 244: BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &am->am_map) != 0)
! 245: goto amfree;
! 246:
! 247: if (bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &am->am_seg, 1,
! 248: &nsegs, BUS_DMA_NOWAIT) != 0)
! 249: goto destroy;
! 250:
! 251: if (bus_dmamem_map(sc->sc_dmat, &am->am_seg, nsegs, size, &am->am_kva,
! 252: BUS_DMA_NOWAIT) != 0)
! 253: goto free;
! 254:
! 255: if (bus_dmamap_load(sc->sc_dmat, am->am_map, am->am_kva, size, NULL,
! 256: BUS_DMA_NOWAIT) != 0)
! 257: goto unmap;
! 258:
! 259: memset(am->am_kva, 0, size);
! 260: return (am);
! 261:
! 262: unmap:
! 263: bus_dmamem_unmap(sc->sc_dmat, am->am_kva, size);
! 264: free:
! 265: bus_dmamem_free(sc->sc_dmat, &am->am_seg, 1);
! 266: destroy:
! 267: bus_dmamap_destroy(sc->sc_dmat, am->am_map);
! 268: amfree:
! 269: free(am, M_DEVBUF);
! 270:
! 271: return (NULL);
! 272: }
! 273:
! 274: void
! 275: ami_freemem(struct ami_softc *sc, struct ami_mem *am)
! 276: {
! 277: bus_dmamap_unload(sc->sc_dmat, am->am_map);
! 278: bus_dmamem_unmap(sc->sc_dmat, am->am_kva, am->am_size);
! 279: bus_dmamem_free(sc->sc_dmat, &am->am_seg, 1);
! 280: bus_dmamap_destroy(sc->sc_dmat, am->am_map);
! 281: free(am, M_DEVBUF);
! 282: }
! 283:
! 284: void
! 285: ami_copyhds(struct ami_softc *sc, const u_int32_t *sizes,
! 286: const u_int8_t *props, const u_int8_t *stats)
! 287: {
! 288: int i;
! 289:
! 290: for (i = 0; i < sc->sc_nunits; i++) {
! 291: sc->sc_hdr[i].hd_present = 1;
! 292: sc->sc_hdr[i].hd_is_logdrv = 1;
! 293: sc->sc_hdr[i].hd_size = letoh32(sizes[i]);
! 294: sc->sc_hdr[i].hd_prop = props[i];
! 295: sc->sc_hdr[i].hd_stat = stats[i];
! 296: }
! 297: }
! 298:
! 299: int
! 300: ami_alloc_ccbs(struct ami_softc *sc, int nccbs)
! 301: {
! 302: struct ami_ccb *ccb;
! 303: struct ami_ccbmem *ccbmem, *mem;
! 304: int i, error;
! 305:
! 306: sc->sc_ccbs = malloc(sizeof(struct ami_ccb) * nccbs,
! 307: M_DEVBUF, M_NOWAIT);
! 308: if (sc->sc_ccbs == NULL) {
! 309: printf(": unable to allocate ccbs\n");
! 310: return (1);
! 311: }
! 312:
! 313: sc->sc_ccbmem_am = ami_allocmem(sc, sizeof(struct ami_ccbmem) * nccbs);
! 314: if (sc->sc_ccbmem_am == NULL) {
! 315: printf(": unable to allocate ccb dmamem\n");
! 316: goto free_ccbs;
! 317: }
! 318: ccbmem = AMIMEM_KVA(sc->sc_ccbmem_am);
! 319:
! 320: TAILQ_INIT(&sc->sc_ccb_freeq);
! 321: TAILQ_INIT(&sc->sc_ccb_preq);
! 322: TAILQ_INIT(&sc->sc_ccb_runq);
! 323: timeout_set(&sc->sc_run_tmo, ami_runqueue_tick, sc);
! 324:
! 325: for (i = 0; i < nccbs; i++) {
! 326: ccb = &sc->sc_ccbs[i];
! 327: mem = &ccbmem[i];
! 328:
! 329: error = bus_dmamap_create(sc->sc_dmat, AMI_MAXFER,
! 330: AMI_MAXOFFSETS, AMI_MAXFER, 0,
! 331: BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &ccb->ccb_dmamap);
! 332: if (error) {
! 333: printf(": cannot create ccb dmamap (%d)\n", error);
! 334: goto free_list;
! 335: }
! 336:
! 337: ccb->ccb_sc = sc;
! 338:
! 339: ccb->ccb_cmd.acc_id = i + 1;
! 340: ccb->ccb_offset = sizeof(struct ami_ccbmem) * i;
! 341:
! 342: ccb->ccb_pt = &mem->cd_pt;
! 343: ccb->ccb_ptpa = htole32(AMIMEM_DVA(sc->sc_ccbmem_am) +
! 344: ccb->ccb_offset);
! 345:
! 346: ccb->ccb_sglist = mem->cd_sg;
! 347: ccb->ccb_sglistpa = htole32(AMIMEM_DVA(sc->sc_ccbmem_am) +
! 348: ccb->ccb_offset + sizeof(struct ami_passthrough));
! 349:
! 350: ami_put_ccb(ccb);
! 351: }
! 352:
! 353: return (0);
! 354:
! 355: free_list:
! 356: while ((ccb = ami_get_ccb(sc)) != NULL)
! 357: bus_dmamap_destroy(sc->sc_dmat, ccb->ccb_dmamap);
! 358:
! 359: ami_freemem(sc, sc->sc_ccbmem_am);
! 360: free_ccbs:
! 361: free(sc->sc_ccbs, M_DEVBUF);
! 362:
! 363: return (1);
! 364: }
! 365:
! 366: int
! 367: ami_attach(struct ami_softc *sc)
! 368: {
! 369: struct scsibus_attach_args saa;
! 370: struct ami_rawsoftc *rsc;
! 371: struct ami_ccb iccb;
! 372: struct ami_iocmd *cmd;
! 373: struct ami_mem *am;
! 374: const char *p;
! 375: paddr_t pa;
! 376: int s;
! 377:
! 378: am = ami_allocmem(sc, NBPG);
! 379: if (am == NULL) {
! 380: printf(": unable to allocate init data\n");
! 381: return (1);
! 382: }
! 383: pa = htole32(AMIMEM_DVA(am));
! 384:
! 385: sc->sc_mbox_am = ami_allocmem(sc, sizeof(struct ami_iocmd));
! 386: if (sc->sc_mbox_am == NULL) {
! 387: printf(": unable to allocate mbox\n");
! 388: goto free_idata;
! 389: }
! 390: sc->sc_mbox = (volatile struct ami_iocmd *)AMIMEM_KVA(sc->sc_mbox_am);
! 391: sc->sc_mbox_pa = htole32(AMIMEM_DVA(sc->sc_mbox_am));
! 392: AMI_DPRINTF(AMI_D_CMD, ("mbox=%p ", sc->sc_mbox));
! 393: AMI_DPRINTF(AMI_D_CMD, ("mbox_pa=0x%llx ", (long long)sc->sc_mbox_pa));
! 394:
! 395: /* create a spartan ccb for use with ami_poll */
! 396: bzero(&iccb, sizeof(iccb));
! 397: iccb.ccb_sc = sc;
! 398: iccb.ccb_done = ami_done_init;
! 399: cmd = &iccb.ccb_cmd;
! 400:
! 401: (sc->sc_init)(sc);
! 402:
! 403: s = splbio();
! 404:
! 405: /* try FC inquiry first */
! 406: cmd->acc_cmd = AMI_FCOP;
! 407: cmd->acc_io.aio_channel = AMI_FC_EINQ3;
! 408: cmd->acc_io.aio_param = AMI_FC_EINQ3_SOLICITED_FULL;
! 409: cmd->acc_io.aio_data = pa;
! 410: if (ami_poll(sc, &iccb) == 0) {
! 411: struct ami_fc_einquiry *einq = AMIMEM_KVA(am);
! 412: struct ami_fc_prodinfo *pi = AMIMEM_KVA(am);
! 413:
! 414: sc->sc_nunits = einq->ain_nlogdrv;
! 415: ami_copyhds(sc, einq->ain_ldsize, einq->ain_ldprop,
! 416: einq->ain_ldstat);
! 417:
! 418: cmd->acc_cmd = AMI_FCOP;
! 419: cmd->acc_io.aio_channel = AMI_FC_PRODINF;
! 420: cmd->acc_io.aio_param = 0;
! 421: cmd->acc_io.aio_data = pa;
! 422: if (ami_poll(sc, &iccb) == 0) {
! 423: sc->sc_maxunits = AMI_BIG_MAX_LDRIVES;
! 424:
! 425: bcopy (pi->api_fwver, sc->sc_fwver, 16);
! 426: sc->sc_fwver[15] = '\0';
! 427: bcopy (pi->api_biosver, sc->sc_biosver, 16);
! 428: sc->sc_biosver[15] = '\0';
! 429: sc->sc_channels = pi->api_channels;
! 430: sc->sc_targets = pi->api_fcloops;
! 431: sc->sc_memory = letoh16(pi->api_ramsize);
! 432: sc->sc_maxcmds = pi->api_maxcmd;
! 433: p = "FC loop";
! 434: }
! 435: }
! 436:
! 437: if (sc->sc_maxunits == 0) {
! 438: struct ami_inquiry *inq = AMIMEM_KVA(am);
! 439:
! 440: cmd->acc_cmd = AMI_EINQUIRY;
! 441: cmd->acc_io.aio_channel = 0;
! 442: cmd->acc_io.aio_param = 0;
! 443: cmd->acc_io.aio_data = pa;
! 444: if (ami_poll(sc, &iccb) != 0) {
! 445: cmd->acc_cmd = AMI_INQUIRY;
! 446: cmd->acc_io.aio_channel = 0;
! 447: cmd->acc_io.aio_param = 0;
! 448: cmd->acc_io.aio_data = pa;
! 449: if (ami_poll(sc, &iccb) != 0) {
! 450: splx(s);
! 451: printf(": cannot do inquiry\n");
! 452: goto free_mbox;
! 453: }
! 454: }
! 455:
! 456: sc->sc_maxunits = AMI_MAX_LDRIVES;
! 457: sc->sc_nunits = inq->ain_nlogdrv;
! 458: ami_copyhds(sc, inq->ain_ldsize, inq->ain_ldprop,
! 459: inq->ain_ldstat);
! 460:
! 461: bcopy (inq->ain_fwver, sc->sc_fwver, 4);
! 462: sc->sc_fwver[4] = '\0';
! 463: bcopy (inq->ain_biosver, sc->sc_biosver, 4);
! 464: sc->sc_biosver[4] = '\0';
! 465: sc->sc_channels = inq->ain_channels;
! 466: sc->sc_targets = inq->ain_targets;
! 467: sc->sc_memory = inq->ain_ramsize;
! 468: sc->sc_maxcmds = inq->ain_maxcmd;
! 469: p = "target";
! 470: }
! 471:
! 472: if (sc->sc_flags & AMI_BROKEN) {
! 473: sc->sc_link.openings = 1;
! 474: sc->sc_maxcmds = 1;
! 475: sc->sc_maxunits = 1;
! 476: } else {
! 477: sc->sc_maxunits = AMI_BIG_MAX_LDRIVES;
! 478: if (sc->sc_maxcmds > AMI_MAXCMDS)
! 479: sc->sc_maxcmds = AMI_MAXCMDS;
! 480: /*
! 481: * Reserve ccb's for ioctl's and raw commands to
! 482: * processors/enclosures by lowering the number of
! 483: * openings available for logical units.
! 484: */
! 485: sc->sc_maxcmds -= AMI_MAXIOCTLCMDS + AMI_MAXPROCS *
! 486: AMI_MAXRAWCMDS * sc->sc_channels;
! 487:
! 488: if (sc->sc_nunits)
! 489: sc->sc_link.openings =
! 490: sc->sc_maxcmds / sc->sc_nunits;
! 491: else
! 492: sc->sc_link.openings = sc->sc_maxcmds;
! 493: }
! 494:
! 495: splx(s);
! 496:
! 497: ami_freemem(sc, am);
! 498:
! 499: if (ami_alloc_ccbs(sc, AMI_MAXCMDS) != 0) {
! 500: /* error already printed */
! 501: goto free_mbox;
! 502: }
! 503:
! 504: /* hack for hp netraid version encoding */
! 505: if ('A' <= sc->sc_fwver[2] && sc->sc_fwver[2] <= 'Z' &&
! 506: sc->sc_fwver[1] < ' ' && sc->sc_fwver[0] < ' ' &&
! 507: 'A' <= sc->sc_biosver[2] && sc->sc_biosver[2] <= 'Z' &&
! 508: sc->sc_biosver[1] < ' ' && sc->sc_biosver[0] < ' ') {
! 509:
! 510: snprintf(sc->sc_fwver, sizeof sc->sc_fwver, "%c.%02d.%02d",
! 511: sc->sc_fwver[2], sc->sc_fwver[1], sc->sc_fwver[0]);
! 512: snprintf(sc->sc_biosver, sizeof sc->sc_biosver, "%c.%02d.%02d",
! 513: sc->sc_biosver[2], sc->sc_biosver[1], sc->sc_biosver[0]);
! 514: }
! 515:
! 516: /* TODO: fetch & print cache strategy */
! 517: /* TODO: fetch & print scsi and raid info */
! 518:
! 519: sc->sc_link.device = &ami_dev;
! 520: sc->sc_link.adapter_softc = sc;
! 521: sc->sc_link.adapter = &ami_switch;
! 522: sc->sc_link.adapter_target = sc->sc_maxunits;
! 523: sc->sc_link.adapter_buswidth = sc->sc_maxunits;
! 524:
! 525: #ifdef AMI_DEBUG
! 526: printf(", FW %s, BIOS v%s, %dMB RAM\n"
! 527: "%s: %d channels, %d %ss, %d logical drives, "
! 528: "openings %d, max commands %d, quirks: %04x\n",
! 529: sc->sc_fwver, sc->sc_biosver, sc->sc_memory, DEVNAME(sc),
! 530: sc->sc_channels, sc->sc_targets, p, sc->sc_nunits,
! 531: sc->sc_link.openings, sc->sc_maxcmds, sc->sc_flags);
! 532: #else
! 533: printf(", FW %s, BIOS v%s, %dMB RAM\n"
! 534: "%s: %d channels, %d %ss, %d logical drives\n",
! 535: sc->sc_fwver, sc->sc_biosver, sc->sc_memory, DEVNAME(sc),
! 536: sc->sc_channels, sc->sc_targets, p, sc->sc_nunits);
! 537: #endif /* AMI_DEBUG */
! 538:
! 539: if (sc->sc_flags & AMI_BROKEN && sc->sc_nunits > 1)
! 540: printf("%s: firmware buggy, limiting access to first logical "
! 541: "disk\n", DEVNAME(sc));
! 542:
! 543: /* lock around ioctl requests */
! 544: rw_init(&sc->sc_lock, NULL);
! 545:
! 546: bzero(&saa, sizeof(saa));
! 547: saa.saa_sc_link = &sc->sc_link;
! 548:
! 549: config_found(&sc->sc_dev, &saa, scsiprint);
! 550:
! 551: /* can't do bioctls, sensors, or pass-through on broken devices */
! 552: if (sc->sc_flags & AMI_BROKEN)
! 553: return (0);
! 554:
! 555: #if NBIO > 0
! 556: if (bio_register(&sc->sc_dev, ami_ioctl) != 0)
! 557: printf("%s: controller registration failed\n", DEVNAME(sc));
! 558: else
! 559: sc->sc_ioctl = ami_ioctl;
! 560:
! 561: #ifndef SMALL_KERNEL
! 562: if (ami_create_sensors(sc) != 0)
! 563: printf("%s: unable to create sensors\n", DEVNAME(sc));
! 564: #endif
! 565: #endif
! 566:
! 567: rsc = malloc(sizeof(struct ami_rawsoftc) * sc->sc_channels,
! 568: M_DEVBUF, M_NOWAIT);
! 569: if (!rsc) {
! 570: printf("%s: no memory for raw interface\n", DEVNAME(sc));
! 571: return (0);
! 572: }
! 573:
! 574: bzero(rsc, sizeof(struct ami_rawsoftc) * sc->sc_channels);
! 575: for (sc->sc_rawsoftcs = rsc;
! 576: rsc < &sc->sc_rawsoftcs[sc->sc_channels]; rsc++) {
! 577:
! 578: rsc->sc_softc = sc;
! 579: rsc->sc_channel = rsc - sc->sc_rawsoftcs;
! 580: rsc->sc_link.device = &ami_raw_dev;
! 581: rsc->sc_link.openings = AMI_MAXRAWCMDS;
! 582: rsc->sc_link.adapter_softc = rsc;
! 583: rsc->sc_link.adapter = &ami_raw_switch;
! 584: rsc->sc_proctarget = -1;
! 585: /* TODO fetch it from the controller */
! 586: rsc->sc_link.adapter_target = 16;
! 587: rsc->sc_link.adapter_buswidth = 16;
! 588:
! 589: bzero(&saa, sizeof(saa));
! 590: saa.saa_sc_link = &rsc->sc_link;
! 591:
! 592: config_found(&sc->sc_dev, &saa, scsiprint);
! 593: }
! 594:
! 595: return (0);
! 596:
! 597: free_mbox:
! 598: ami_freemem(sc, sc->sc_mbox_am);
! 599: free_idata:
! 600: ami_freemem(sc, am);
! 601:
! 602: return (1);
! 603: }
! 604:
! 605: int
! 606: ami_quartz_init(struct ami_softc *sc)
! 607: {
! 608: ami_write(sc, AMI_QIDB, 0);
! 609:
! 610: return (0);
! 611: }
! 612:
! 613: int
! 614: ami_quartz_exec(struct ami_softc *sc, struct ami_iocmd *cmd)
! 615: {
! 616: if (sc->sc_mbox->acc_busy) {
! 617: AMI_DPRINTF(AMI_D_CMD, ("mbox_busy "));
! 618: return (EBUSY);
! 619: }
! 620:
! 621: memcpy((struct ami_iocmd *)sc->sc_mbox, cmd, 16);
! 622: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,
! 623: sizeof(struct ami_iocmd), BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
! 624:
! 625: sc->sc_mbox->acc_busy = 1;
! 626: sc->sc_mbox->acc_poll = 0;
! 627: sc->sc_mbox->acc_ack = 0;
! 628:
! 629: ami_write(sc, AMI_QIDB, sc->sc_mbox_pa | htole32(AMI_QIDB_EXEC));
! 630:
! 631: return (0);
! 632: }
! 633:
! 634: int
! 635: ami_quartz_done(struct ami_softc *sc, struct ami_iocmd *mbox)
! 636: {
! 637: u_int32_t i, n;
! 638: u_int8_t nstat, status;
! 639: u_int8_t completed[AMI_MAXSTATACK];
! 640:
! 641: if (ami_read(sc, AMI_QODB) != AMI_QODB_READY)
! 642: return (0); /* nothing to do */
! 643:
! 644: ami_write(sc, AMI_QODB, AMI_QODB_READY);
! 645:
! 646: /*
! 647: * The following sequence is not supposed to have a timeout clause
! 648: * since the firmware has a "guarantee" that all commands will
! 649: * complete. The choice is either panic or hoping for a miracle
! 650: * and that the IOs will complete much later.
! 651: */
! 652: i = 0;
! 653: while ((nstat = sc->sc_mbox->acc_nstat) == 0xff) {
! 654: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,
! 655: sizeof(struct ami_iocmd), BUS_DMASYNC_POSTREAD);
! 656: delay(1);
! 657: if (i++ > 1000000)
! 658: return (0); /* nothing to do */
! 659: }
! 660: sc->sc_mbox->acc_nstat = 0xff;
! 661: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,
! 662: sizeof(struct ami_iocmd), BUS_DMASYNC_POSTWRITE);
! 663:
! 664: /* wait until fw wrote out all completions */
! 665: i = 0;
! 666: AMI_DPRINTF(AMI_D_CMD, ("aqd %d ", nstat));
! 667: for (n = 0; n < nstat; n++) {
! 668: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,
! 669: sizeof(struct ami_iocmd), BUS_DMASYNC_PREREAD);
! 670: while ((completed[n] = sc->sc_mbox->acc_cmplidl[n]) == 0xff) {
! 671: delay(1);
! 672: if (i++ > 1000000)
! 673: return (0); /* nothing to do */
! 674: }
! 675: sc->sc_mbox->acc_cmplidl[n] = 0xff;
! 676: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,
! 677: sizeof(struct ami_iocmd), BUS_DMASYNC_POSTWRITE);
! 678: }
! 679:
! 680: /* this should never happen, someone screwed up the completion status */
! 681: if ((status = sc->sc_mbox->acc_status) == 0xff)
! 682: panic("%s: status 0xff from the firmware", DEVNAME(sc));
! 683:
! 684: sc->sc_mbox->acc_status = 0xff;
! 685:
! 686: /* copy mailbox to temporary one and fixup other changed values */
! 687: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0, 16,
! 688: BUS_DMASYNC_POSTWRITE);
! 689: memcpy(mbox, (struct ami_iocmd *)sc->sc_mbox, 16);
! 690: mbox->acc_nstat = nstat;
! 691: mbox->acc_status = status;
! 692: for (n = 0; n < nstat; n++)
! 693: mbox->acc_cmplidl[n] = completed[n];
! 694:
! 695: /* ack interrupt */
! 696: ami_write(sc, AMI_QIDB, AMI_QIDB_ACK);
! 697:
! 698: return (1); /* ready to complete all IOs in acc_cmplidl */
! 699: }
! 700:
! 701: int
! 702: ami_quartz_poll(struct ami_softc *sc, struct ami_iocmd *cmd)
! 703: {
! 704: /* struct scsi_xfer *xs = ccb->ccb_xs; */
! 705: u_int32_t i;
! 706: u_int8_t status;
! 707:
! 708: if (sc->sc_dis_poll)
! 709: return (1); /* fail */
! 710:
! 711: i = 0;
! 712: while (sc->sc_mbox->acc_busy && (i < AMI_MAX_BUSYWAIT)) {
! 713: delay(1);
! 714: i++;
! 715: }
! 716: if (sc->sc_mbox->acc_busy) {
! 717: AMI_DPRINTF(AMI_D_CMD, ("mbox_busy "));
! 718: return (EBUSY);
! 719: }
! 720:
! 721: memcpy((struct ami_iocmd *)sc->sc_mbox, cmd, 16);
! 722: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0, 16,
! 723: BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
! 724:
! 725: sc->sc_mbox->acc_id = 0xfe;
! 726: sc->sc_mbox->acc_busy = 1;
! 727: sc->sc_mbox->acc_poll = 0;
! 728: sc->sc_mbox->acc_ack = 0;
! 729:
! 730: sc->sc_mbox->acc_nstat = 0xff;
! 731: sc->sc_mbox->acc_status = 0xff;
! 732:
! 733: /* send command to firmware */
! 734: ami_write(sc, AMI_QIDB, sc->sc_mbox_pa | htole32(AMI_QIDB_EXEC));
! 735:
! 736: while ((sc->sc_mbox->acc_nstat == 0xff) && (i < AMI_MAX_POLLWAIT)) {
! 737: delay(1);
! 738: i++;
! 739: }
! 740: if (i >= AMI_MAX_POLLWAIT) {
! 741: printf("%s: command not accepted, polling disabled\n",
! 742: DEVNAME(sc));
! 743: sc->sc_dis_poll = 1;
! 744: return (1);
! 745: }
! 746:
! 747: sc->sc_mbox->acc_nstat = 0xff;
! 748:
! 749: while ((sc->sc_mbox->acc_status == 0xff) && (i < AMI_MAX_POLLWAIT)) {
! 750: delay(1);
! 751: i++;
! 752: }
! 753: if (i >= AMI_MAX_POLLWAIT) {
! 754: printf("%s: bad status, polling disabled\n", DEVNAME(sc));
! 755: sc->sc_dis_poll = 1;
! 756: return (1);
! 757: }
! 758: status = sc->sc_mbox->acc_status;
! 759: sc->sc_mbox->acc_status = 0xff;
! 760:
! 761: /* poll firmware */
! 762: while ((sc->sc_mbox->acc_poll != 0x77) && (i < AMI_MAX_POLLWAIT)) {
! 763: delay(1);
! 764: i++;
! 765: }
! 766: if (i >= AMI_MAX_POLLWAIT) {
! 767: printf("%s: firmware didn't reply, polling disabled\n",
! 768: DEVNAME(sc));
! 769: sc->sc_dis_poll = 1;
! 770: return 1;
! 771: }
! 772:
! 773: sc->sc_mbox->acc_poll = 0;
! 774: sc->sc_mbox->acc_ack = 0x77;
! 775:
! 776: /* ack */
! 777: ami_write(sc, AMI_QIDB, sc->sc_mbox_pa | htole32(AMI_QIDB_ACK));
! 778:
! 779: while((ami_read(sc, AMI_QIDB) & AMI_QIDB_ACK) &&
! 780: (i < AMI_MAX_POLLWAIT)) {
! 781: delay(1);
! 782: i++;
! 783: }
! 784: if (i >= AMI_MAX_POLLWAIT) {
! 785: printf("%s: firmware didn't ack the ack, polling disabled\n",
! 786: DEVNAME(sc));
! 787: sc->sc_dis_poll = 1;
! 788: return (1);
! 789: }
! 790:
! 791: for (i = 0; i < AMI_MAXSTATACK; i++)
! 792: sc->sc_mbox->acc_cmplidl[i] = 0xff;
! 793:
! 794: return (status);
! 795: }
! 796:
! 797: int
! 798: ami_schwartz_init(struct ami_softc *sc)
! 799: {
! 800: u_int32_t a = (u_int32_t)sc->sc_mbox_pa;
! 801:
! 802: bus_space_write_4(sc->sc_iot, sc->sc_ioh, AMI_SMBADDR, a);
! 803: /* XXX 40bit address ??? */
! 804: bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SMBENA, 0);
! 805:
! 806: bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD, AMI_SCMD_ACK);
! 807: bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SIEM, AMI_SEIM_ENA |
! 808: bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SIEM));
! 809:
! 810: return (0);
! 811: }
! 812:
! 813: int
! 814: ami_schwartz_exec(struct ami_softc *sc, struct ami_iocmd *cmd)
! 815: {
! 816: if (bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SMBSTAT) &
! 817: AMI_SMBST_BUSY) {
! 818: AMI_DPRINTF(AMI_D_CMD, ("mbox_busy "));
! 819: return (EBUSY);
! 820: }
! 821:
! 822: memcpy((struct ami_iocmd *)sc->sc_mbox, cmd, 16);
! 823: sc->sc_mbox->acc_busy = 1;
! 824: sc->sc_mbox->acc_poll = 0;
! 825: sc->sc_mbox->acc_ack = 0;
! 826:
! 827: bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD, AMI_SCMD_EXEC);
! 828: return (0);
! 829: }
! 830:
! 831: int
! 832: ami_schwartz_done(struct ami_softc *sc, struct ami_iocmd *mbox)
! 833: {
! 834: u_int8_t stat;
! 835:
! 836: #if 0
! 837: /* do not scramble the busy mailbox */
! 838: if (sc->sc_mbox->acc_busy)
! 839: return (0);
! 840: #endif
! 841: if (bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SMBSTAT) &
! 842: AMI_SMBST_BUSY)
! 843: return (0);
! 844:
! 845: stat = bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_ISTAT);
! 846: if (stat & AMI_ISTAT_PEND) {
! 847: bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_ISTAT, stat);
! 848:
! 849: *mbox = *sc->sc_mbox;
! 850: AMI_DPRINTF(AMI_D_CMD, ("asd %d ", mbox->acc_nstat));
! 851:
! 852: bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD,
! 853: AMI_SCMD_ACK);
! 854:
! 855: return (1);
! 856: }
! 857:
! 858: return (0);
! 859: }
! 860:
! 861: int
! 862: ami_schwartz_poll(struct ami_softc *sc, struct ami_iocmd *mbox)
! 863: {
! 864: u_int8_t status;
! 865: u_int32_t i;
! 866: int rv;
! 867:
! 868: if (sc->sc_dis_poll)
! 869: return (1); /* fail */
! 870:
! 871: for (i = 0; i < AMI_MAX_POLLWAIT; i++) {
! 872: if (!(bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SMBSTAT) &
! 873: AMI_SMBST_BUSY))
! 874: break;
! 875: delay(1);
! 876: }
! 877: if (i >= AMI_MAX_POLLWAIT) {
! 878: AMI_DPRINTF(AMI_D_CMD, ("mbox_busy "));
! 879: return (EBUSY);
! 880: }
! 881:
! 882: memcpy((struct ami_iocmd *)sc->sc_mbox, mbox, 16);
! 883: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0, 16,
! 884: BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
! 885:
! 886: sc->sc_mbox->acc_busy = 1;
! 887: sc->sc_mbox->acc_poll = 0;
! 888: sc->sc_mbox->acc_ack = 0;
! 889: /* send command to firmware */
! 890: bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD, AMI_SCMD_EXEC);
! 891:
! 892: /* wait until no longer busy */
! 893: for (i = 0; i < AMI_MAX_POLLWAIT; i++) {
! 894: if (!(bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SMBSTAT) &
! 895: AMI_SMBST_BUSY))
! 896: break;
! 897: delay(1);
! 898: }
! 899: if (i >= AMI_MAX_POLLWAIT) {
! 900: printf("%s: command not accepted, polling disabled\n",
! 901: DEVNAME(sc));
! 902: sc->sc_dis_poll = 1;
! 903: return (1); /* fail */
! 904: }
! 905:
! 906: /* wait for interrupt bit */
! 907: for (i = 0; i < AMI_MAX_POLLWAIT; i++) {
! 908: status = bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_ISTAT);
! 909: if (status & AMI_ISTAT_PEND)
! 910: break;
! 911: delay(1);
! 912: }
! 913: if (i >= AMI_MAX_POLLWAIT) {
! 914: printf("%s: interrupt didn't arrive, polling disabled\n",
! 915: DEVNAME(sc));
! 916: sc->sc_dis_poll = 1;
! 917: return (1); /* fail */
! 918: }
! 919:
! 920: /* write ststus back to firmware */
! 921: bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_ISTAT, status);
! 922:
! 923: /* copy mailbox and status back */
! 924: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,
! 925: sizeof(struct ami_iocmd), BUS_DMASYNC_PREREAD);
! 926: *mbox = *sc->sc_mbox;
! 927: rv = sc->sc_mbox->acc_status;
! 928:
! 929: /* ack interrupt */
! 930: bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD, AMI_SCMD_ACK);
! 931:
! 932: return (rv);
! 933: }
! 934:
! 935: int
! 936: ami_start_xs(struct ami_softc *sc, struct ami_ccb *ccb, struct scsi_xfer *xs)
! 937: {
! 938: timeout_set(&xs->stimeout, ami_stimeout, ccb);
! 939:
! 940: if (xs->flags & SCSI_POLL) {
! 941: ami_complete(sc, ccb, xs->timeout);
! 942: return (COMPLETE);
! 943: }
! 944:
! 945: timeout_add(&xs->stimeout, 61 * hz);
! 946: ami_start(sc, ccb);
! 947:
! 948: return (SUCCESSFULLY_QUEUED);
! 949: }
! 950:
! 951: void
! 952: ami_start(struct ami_softc *sc, struct ami_ccb *ccb)
! 953: {
! 954: int s;
! 955:
! 956: s = splbio();
! 957: ccb->ccb_state = AMI_CCB_PREQUEUED;
! 958: TAILQ_INSERT_TAIL(&sc->sc_ccb_preq, ccb, ccb_link);
! 959: ami_runqueue(sc);
! 960: splx(s);
! 961: }
! 962:
! 963: void
! 964: ami_runqueue_tick(void *arg)
! 965: {
! 966: struct ami_softc *sc = arg;
! 967: int s;
! 968:
! 969: s = splbio();
! 970: ami_runqueue(sc);
! 971: splx(s);
! 972: }
! 973:
! 974: void
! 975: ami_runqueue(struct ami_softc *sc)
! 976: {
! 977: struct ami_ccb *ccb;
! 978:
! 979: while ((ccb = TAILQ_FIRST(&sc->sc_ccb_preq)) != NULL) {
! 980: if (sc->sc_exec(sc, &ccb->ccb_cmd) != 0) {
! 981: /* this is now raceable too with other incomming io */
! 982: timeout_add(&sc->sc_run_tmo, 1);
! 983: break;
! 984: }
! 985:
! 986: TAILQ_REMOVE(&sc->sc_ccb_preq, ccb, ccb_link);
! 987: ccb->ccb_state = AMI_CCB_QUEUED;
! 988: TAILQ_INSERT_TAIL(&sc->sc_ccb_runq, ccb, ccb_link);
! 989: }
! 990: }
! 991:
! 992: int
! 993: ami_poll(struct ami_softc *sc, struct ami_ccb *ccb)
! 994: {
! 995: int error;
! 996: int s;
! 997:
! 998: /* XXX this is broken, shall drain IO or consider this
! 999: * a normal completion which can complete async and
! 1000: * polled commands until the polled commands completes
! 1001: */
! 1002:
! 1003: s = splbio();
! 1004: error = sc->sc_poll(sc, &ccb->ccb_cmd);
! 1005: if (error)
! 1006: ccb->ccb_flags |= AMI_CCB_F_ERR;
! 1007:
! 1008: ccb->ccb_done(sc, ccb);
! 1009: splx(s);
! 1010:
! 1011: return (error);
! 1012: }
! 1013:
! 1014: void
! 1015: ami_complete(struct ami_softc *sc, struct ami_ccb *ccb, int timeout)
! 1016: {
! 1017: struct ami_iocmd mbox;
! 1018: int i = 0, j, done = 0;
! 1019: int s;
! 1020:
! 1021: s = splbio();
! 1022:
! 1023: /*
! 1024: * since exec will return if the mbox is busy we have to busy wait
! 1025: * ourselves. once its in, jam it into the runq.
! 1026: */
! 1027: while (i < AMI_MAX_BUSYWAIT) {
! 1028: if (sc->sc_exec(sc, &ccb->ccb_cmd) == 0) {
! 1029: ccb->ccb_state = AMI_CCB_QUEUED;
! 1030: TAILQ_INSERT_TAIL(&sc->sc_ccb_runq, ccb, ccb_link);
! 1031: break;
! 1032: }
! 1033:
! 1034: DELAY(1000);
! 1035: i++;
! 1036: }
! 1037: if (ccb->ccb_state != AMI_CCB_QUEUED)
! 1038: goto err;
! 1039:
! 1040: i = 0;
! 1041: while (i < timeout) {
! 1042: if (sc->sc_done(sc, &mbox) != 0) {
! 1043: for (j = 0; j < mbox.acc_nstat; j++) {
! 1044: int ready = mbox.acc_cmplidl[j];
! 1045: ami_done(sc, ready);
! 1046: if (ready == ccb->ccb_cmd.acc_id)
! 1047: done = 1;
! 1048: }
! 1049: if (done)
! 1050: break;
! 1051: }
! 1052:
! 1053: DELAY(1000);
! 1054: i++;
! 1055: }
! 1056: if (!done) {
! 1057: printf("%s: timeout ccb %d\n", DEVNAME(sc),
! 1058: ccb->ccb_cmd.acc_id);
! 1059: TAILQ_REMOVE(&sc->sc_ccb_runq, ccb, ccb_link);
! 1060: goto err;
! 1061: }
! 1062:
! 1063: /* start the runqueue again */
! 1064: ami_runqueue(sc);
! 1065:
! 1066: splx(s);
! 1067:
! 1068: return;
! 1069:
! 1070: err:
! 1071: ccb->ccb_flags |= AMI_CCB_F_ERR;
! 1072: ccb->ccb_state = AMI_CCB_READY;
! 1073: ccb->ccb_done(sc, ccb);
! 1074: splx(s);
! 1075: }
! 1076:
! 1077: void
! 1078: ami_stimeout(void *v)
! 1079: {
! 1080: struct ami_ccb *ccb = v;
! 1081: struct ami_softc *sc = ccb->ccb_sc;
! 1082: struct ami_iocmd *cmd = &ccb->ccb_cmd;
! 1083: int s;
! 1084:
! 1085: s = splbio();
! 1086: switch (ccb->ccb_state) {
! 1087: case AMI_CCB_PREQUEUED:
! 1088: /* command never ran, cleanup is easy */
! 1089: TAILQ_REMOVE(&sc->sc_ccb_preq, ccb, ccb_link);
! 1090: ccb->ccb_flags |= AMI_CCB_F_ERR;
! 1091: ccb->ccb_done(sc, ccb);
! 1092: break;
! 1093:
! 1094: case AMI_CCB_QUEUED:
! 1095: /*
! 1096: * ccb has taken more than a minute to finish. we can't take
! 1097: * it off the hardware in case it finishes later, but we can
! 1098: * warn the user to look at what is happening.
! 1099: */
! 1100: AMI_DPRINTF(AMI_D_CMD, ("%s: stimeout ccb %d, check volume "
! 1101: "state\n", DEVNAME(sc), cmd->acc_id));
! 1102: break;
! 1103:
! 1104: default:
! 1105: panic("%s: ami_stimeout(%d) botch", DEVNAME(sc), cmd->acc_id);
! 1106: }
! 1107:
! 1108: splx(s);
! 1109: }
! 1110:
! 1111: int
! 1112: ami_done(struct ami_softc *sc, int idx)
! 1113: {
! 1114: struct ami_ccb *ccb = &sc->sc_ccbs[idx - 1];
! 1115:
! 1116: AMI_DPRINTF(AMI_D_CMD, ("done(%d) ", ccb->ccb_cmd.acc_id));
! 1117:
! 1118: if (ccb->ccb_state != AMI_CCB_QUEUED) {
! 1119: printf("%s: unqueued ccb %d ready, state = %d\n",
! 1120: DEVNAME(sc), idx, ccb->ccb_state);
! 1121: return (1);
! 1122: }
! 1123:
! 1124: ccb->ccb_state = AMI_CCB_READY;
! 1125: TAILQ_REMOVE(&sc->sc_ccb_runq, ccb, ccb_link);
! 1126:
! 1127: ccb->ccb_done(sc, ccb);
! 1128:
! 1129: return (0);
! 1130: }
! 1131:
! 1132: void
! 1133: ami_done_pt(struct ami_softc *sc, struct ami_ccb *ccb)
! 1134: {
! 1135: struct scsi_xfer *xs = ccb->ccb_xs;
! 1136: struct scsi_link *link = xs->sc_link;
! 1137: struct ami_rawsoftc *rsc = link->adapter_softc;
! 1138: u_int8_t target = link->target, type;
! 1139:
! 1140: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),
! 1141: ccb->ccb_offset, sizeof(struct ami_ccbmem),
! 1142: BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
! 1143:
! 1144: if (xs->data != NULL) {
! 1145: bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
! 1146: ccb->ccb_dmamap->dm_mapsize,
! 1147: (xs->flags & SCSI_DATA_IN) ?
! 1148: BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
! 1149:
! 1150: bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap);
! 1151: }
! 1152:
! 1153: timeout_del(&xs->stimeout);
! 1154: xs->resid = 0;
! 1155: xs->flags |= ITSDONE;
! 1156:
! 1157: if (ccb->ccb_flags & AMI_CCB_F_ERR)
! 1158: xs->error = XS_DRIVER_STUFFUP;
! 1159: else if (xs->flags & SCSI_POLL && xs->cmd->opcode == INQUIRY) {
! 1160: type = ((struct scsi_inquiry_data *)xs->data)->device &
! 1161: SID_TYPE;
! 1162: if (!(type == T_PROCESSOR || type == T_ENCLOSURE))
! 1163: xs->error = XS_DRIVER_STUFFUP;
! 1164: else
! 1165: rsc->sc_proctarget = target;
! 1166: }
! 1167:
! 1168: ami_put_ccb(ccb);
! 1169: scsi_done(xs);
! 1170: }
! 1171:
! 1172: void
! 1173: ami_done_xs(struct ami_softc *sc, struct ami_ccb *ccb)
! 1174: {
! 1175: struct scsi_xfer *xs = ccb->ccb_xs;
! 1176:
! 1177: if (xs->data != NULL) {
! 1178: bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
! 1179: ccb->ccb_dmamap->dm_mapsize,
! 1180: (xs->flags & SCSI_DATA_IN) ?
! 1181: BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
! 1182:
! 1183: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),
! 1184: ccb->ccb_offset, sizeof(struct ami_ccbmem),
! 1185: BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
! 1186:
! 1187: bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap);
! 1188: }
! 1189:
! 1190: timeout_del(&xs->stimeout);
! 1191: xs->resid = 0;
! 1192: xs->flags |= ITSDONE;
! 1193:
! 1194: if (ccb->ccb_flags & AMI_CCB_F_ERR)
! 1195: xs->error = XS_DRIVER_STUFFUP;
! 1196:
! 1197: ami_put_ccb(ccb);
! 1198: scsi_done(xs);
! 1199: }
! 1200:
! 1201: void
! 1202: ami_done_flush(struct ami_softc *sc, struct ami_ccb *ccb)
! 1203: {
! 1204: struct scsi_xfer *xs = ccb->ccb_xs;
! 1205: struct ami_iocmd *cmd = &ccb->ccb_cmd;
! 1206:
! 1207: timeout_del(&xs->stimeout);
! 1208: if (ccb->ccb_flags & AMI_CCB_F_ERR) {
! 1209: xs->error = XS_DRIVER_STUFFUP;
! 1210: xs->resid = 0;
! 1211: xs->flags |= ITSDONE;
! 1212:
! 1213: ami_put_ccb(ccb);
! 1214: scsi_done(xs);
! 1215: return;
! 1216: }
! 1217:
! 1218: /* reuse the ccb for the sysflush command */
! 1219: ccb->ccb_done = ami_done_sysflush;
! 1220: cmd->acc_cmd = AMI_SYSFLUSH;
! 1221:
! 1222: ami_start_xs(sc, ccb, xs);
! 1223: }
! 1224:
! 1225: void
! 1226: ami_done_sysflush(struct ami_softc *sc, struct ami_ccb *ccb)
! 1227: {
! 1228: struct scsi_xfer *xs = ccb->ccb_xs;
! 1229:
! 1230: timeout_del(&xs->stimeout);
! 1231: xs->resid = 0;
! 1232: xs->flags |= ITSDONE;
! 1233: if (ccb->ccb_flags & AMI_CCB_F_ERR)
! 1234: xs->error = XS_DRIVER_STUFFUP;
! 1235:
! 1236: ami_put_ccb(ccb);
! 1237: scsi_done(xs);
! 1238: }
! 1239:
! 1240: void
! 1241: ami_done_ioctl(struct ami_softc *sc, struct ami_ccb *ccb)
! 1242: {
! 1243: wakeup(ccb);
! 1244: }
! 1245:
! 1246: void
! 1247: ami_done_init(struct ami_softc *sc, struct ami_ccb *ccb)
! 1248: {
! 1249: /* the ccb is going to be reused, so do nothing with it */
! 1250: }
! 1251:
! 1252: void
! 1253: amiminphys(struct buf *bp)
! 1254: {
! 1255: if (bp->b_bcount > AMI_MAXFER)
! 1256: bp->b_bcount = AMI_MAXFER;
! 1257: minphys(bp);
! 1258: }
! 1259:
! 1260: void
! 1261: ami_copy_internal_data(struct scsi_xfer *xs, void *v, size_t size)
! 1262: {
! 1263: size_t copy_cnt;
! 1264:
! 1265: AMI_DPRINTF(AMI_D_MISC, ("ami_copy_internal_data "));
! 1266:
! 1267: if (!xs->datalen)
! 1268: printf("uio move not yet supported\n");
! 1269: else {
! 1270: copy_cnt = MIN(size, xs->datalen);
! 1271: bcopy(v, xs->data, copy_cnt);
! 1272: }
! 1273: }
! 1274:
! 1275: int
! 1276: ami_scsi_raw_cmd(struct scsi_xfer *xs)
! 1277: {
! 1278: struct scsi_link *link = xs->sc_link;
! 1279: struct ami_rawsoftc *rsc = link->adapter_softc;
! 1280: struct ami_softc *sc = rsc->sc_softc;
! 1281: u_int8_t channel = rsc->sc_channel, target = link->target;
! 1282: struct device *dev = link->device_softc;
! 1283: struct ami_ccb *ccb;
! 1284: int s;
! 1285:
! 1286: AMI_DPRINTF(AMI_D_CMD, ("ami_scsi_raw_cmd "));
! 1287:
! 1288: if (!cold && target == rsc->sc_proctarget)
! 1289: strlcpy(rsc->sc_procdev, dev->dv_xname,
! 1290: sizeof(rsc->sc_procdev));
! 1291:
! 1292: if (xs->cmdlen > AMI_MAX_CDB) {
! 1293: AMI_DPRINTF(AMI_D_CMD, ("CDB too big %p ", xs));
! 1294: bzero(&xs->sense, sizeof(xs->sense));
! 1295: xs->sense.error_code = SSD_ERRCODE_VALID | 0x70;
! 1296: xs->sense.flags = SKEY_ILLEGAL_REQUEST;
! 1297: xs->sense.add_sense_code = 0x20; /* illcmd, 0x24 illfield */
! 1298: xs->error = XS_SENSE;
! 1299: s = splbio();
! 1300: scsi_done(xs);
! 1301: splx(s);
! 1302: return (COMPLETE);
! 1303: }
! 1304:
! 1305: xs->error = XS_NOERROR;
! 1306:
! 1307: s = splbio();
! 1308: ccb = ami_get_ccb(sc);
! 1309: splx(s);
! 1310: if (ccb == NULL) {
! 1311: xs->error = XS_DRIVER_STUFFUP;
! 1312: s = splbio();
! 1313: scsi_done(xs);
! 1314: splx(s);
! 1315: return (COMPLETE);
! 1316: }
! 1317:
! 1318: memset(ccb->ccb_pt, 0, sizeof(struct ami_passthrough));
! 1319:
! 1320: ccb->ccb_xs = xs;
! 1321: ccb->ccb_done = ami_done_pt;
! 1322:
! 1323: ccb->ccb_cmd.acc_cmd = AMI_PASSTHRU;
! 1324: ccb->ccb_cmd.acc_passthru.apt_data = ccb->ccb_ptpa;
! 1325:
! 1326: ccb->ccb_pt->apt_param = AMI_PTPARAM(AMI_TIMEOUT_6,1,0);
! 1327: ccb->ccb_pt->apt_channel = channel;
! 1328: ccb->ccb_pt->apt_target = target;
! 1329: bcopy(xs->cmd, ccb->ccb_pt->apt_cdb, AMI_MAX_CDB);
! 1330: ccb->ccb_pt->apt_ncdb = xs->cmdlen;
! 1331: ccb->ccb_pt->apt_nsense = AMI_MAX_SENSE;
! 1332: ccb->ccb_pt->apt_datalen = xs->datalen;
! 1333: ccb->ccb_pt->apt_data = 0;
! 1334:
! 1335: if (ami_load_ptmem(sc, ccb, xs->data, xs->datalen,
! 1336: xs->flags & SCSI_DATA_IN, xs->flags & SCSI_NOSLEEP) != 0) {
! 1337: xs->error = XS_DRIVER_STUFFUP;
! 1338: s = splbio();
! 1339: ami_put_ccb(ccb);
! 1340: scsi_done(xs);
! 1341: splx(s);
! 1342: return (COMPLETE);
! 1343: }
! 1344:
! 1345: return (ami_start_xs(sc, ccb, xs));
! 1346: }
! 1347:
! 1348: int
! 1349: ami_load_ptmem(struct ami_softc *sc, struct ami_ccb *ccb, void *data,
! 1350: size_t len, int read, int nowait)
! 1351: {
! 1352: bus_dmamap_t dmap = ccb->ccb_dmamap;
! 1353: bus_dma_segment_t *sgd;
! 1354: int error, i;
! 1355:
! 1356: if (data != NULL) {
! 1357: error = bus_dmamap_load(sc->sc_dmat, dmap, data, len, NULL,
! 1358: nowait ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
! 1359: if (error) {
! 1360: if (error == EFBIG)
! 1361: printf("more than %d dma segs\n",
! 1362: AMI_MAXOFFSETS);
! 1363: else
! 1364: printf("error %d loading dma map\n", error);
! 1365:
! 1366: return (1);
! 1367: }
! 1368:
! 1369: sgd = dmap->dm_segs;
! 1370: if (dmap->dm_nsegs > 1) {
! 1371: struct ami_sgent *sgl = ccb->ccb_sglist;
! 1372:
! 1373: ccb->ccb_pt->apt_nsge = dmap->dm_nsegs;
! 1374: ccb->ccb_pt->apt_data = ccb->ccb_sglistpa;
! 1375:
! 1376: for (i = 0; i < dmap->dm_nsegs; i++) {
! 1377: sgl[i].asg_addr = htole32(sgd[i].ds_addr);
! 1378: sgl[i].asg_len = htole32(sgd[i].ds_len);
! 1379: }
! 1380: } else {
! 1381: ccb->ccb_pt->apt_nsge = 0;
! 1382: ccb->ccb_pt->apt_data = htole32(sgd->ds_addr);
! 1383: }
! 1384:
! 1385: bus_dmamap_sync(sc->sc_dmat, dmap, 0, dmap->dm_mapsize,
! 1386: read ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
! 1387: }
! 1388:
! 1389: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),
! 1390: ccb->ccb_offset, sizeof(struct ami_ccbmem),
! 1391: BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
! 1392:
! 1393: return (0);
! 1394: }
! 1395:
! 1396: int
! 1397: ami_scsi_cmd(struct scsi_xfer *xs)
! 1398: {
! 1399: struct scsi_link *link = xs->sc_link;
! 1400: struct ami_softc *sc = link->adapter_softc;
! 1401: struct device *dev = link->device_softc;
! 1402: struct ami_ccb *ccb;
! 1403: struct ami_iocmd *cmd;
! 1404: struct scsi_inquiry_data inq;
! 1405: struct scsi_sense_data sd;
! 1406: struct scsi_read_cap_data rcd;
! 1407: u_int8_t target = link->target;
! 1408: u_int32_t blockno, blockcnt;
! 1409: struct scsi_rw *rw;
! 1410: struct scsi_rw_big *rwb;
! 1411: bus_dma_segment_t *sgd;
! 1412: int error;
! 1413: int s;
! 1414: int i;
! 1415:
! 1416: AMI_DPRINTF(AMI_D_CMD, ("ami_scsi_cmd "));
! 1417:
! 1418: if (target >= sc->sc_nunits || !sc->sc_hdr[target].hd_present ||
! 1419: link->lun != 0) {
! 1420: AMI_DPRINTF(AMI_D_CMD, ("no target %d ", target));
! 1421: /* XXX should be XS_SENSE and sense filled out */
! 1422: xs->error = XS_DRIVER_STUFFUP;
! 1423: xs->flags |= ITSDONE;
! 1424: s = splbio();
! 1425: scsi_done(xs);
! 1426: splx(s);
! 1427: return (COMPLETE);
! 1428: }
! 1429:
! 1430: error = 0;
! 1431: xs->error = XS_NOERROR;
! 1432:
! 1433: switch (xs->cmd->opcode) {
! 1434: case READ_COMMAND:
! 1435: case READ_BIG:
! 1436: case WRITE_COMMAND:
! 1437: case WRITE_BIG:
! 1438: /* deal with io outside the switch */
! 1439: break;
! 1440:
! 1441: case SYNCHRONIZE_CACHE:
! 1442: s = splbio();
! 1443: ccb = ami_get_ccb(sc);
! 1444: splx(s);
! 1445: if (ccb == NULL) {
! 1446: xs->error = XS_DRIVER_STUFFUP;
! 1447: s = splbio();
! 1448: scsi_done(xs);
! 1449: splx(s);
! 1450: return (COMPLETE);
! 1451: }
! 1452:
! 1453: ccb->ccb_xs = xs;
! 1454: ccb->ccb_done = ami_done_flush;
! 1455: if (xs->timeout < 30000)
! 1456: xs->timeout = 30000; /* at least 30sec */
! 1457:
! 1458: cmd = &ccb->ccb_cmd;
! 1459: cmd->acc_cmd = AMI_FLUSH;
! 1460:
! 1461: return (ami_start_xs(sc, ccb, xs));
! 1462:
! 1463: case TEST_UNIT_READY:
! 1464: /* save off sd? after autoconf */
! 1465: if (!cold) /* XXX bogus */
! 1466: strlcpy(sc->sc_hdr[target].dev, dev->dv_xname,
! 1467: sizeof(sc->sc_hdr[target].dev));
! 1468: case START_STOP:
! 1469: #if 0
! 1470: case VERIFY:
! 1471: #endif
! 1472: case PREVENT_ALLOW:
! 1473: AMI_DPRINTF(AMI_D_CMD, ("opc %d tgt %d ", xs->cmd->opcode,
! 1474: target));
! 1475: return (COMPLETE);
! 1476:
! 1477: case REQUEST_SENSE:
! 1478: AMI_DPRINTF(AMI_D_CMD, ("REQUEST SENSE tgt %d ", target));
! 1479: bzero(&sd, sizeof(sd));
! 1480: sd.error_code = 0x70;
! 1481: sd.segment = 0;
! 1482: sd.flags = SKEY_NO_SENSE;
! 1483: *(u_int32_t*)sd.info = htole32(0);
! 1484: sd.extra_len = 0;
! 1485: ami_copy_internal_data(xs, &sd, sizeof(sd));
! 1486: s = splbio();
! 1487: scsi_done(xs);
! 1488: splx(s);
! 1489: return (COMPLETE);
! 1490:
! 1491: case INQUIRY:
! 1492: AMI_DPRINTF(AMI_D_CMD, ("INQUIRY tgt %d ", target));
! 1493: bzero(&inq, sizeof(inq));
! 1494: inq.device = T_DIRECT;
! 1495: inq.dev_qual2 = 0;
! 1496: inq.version = 2;
! 1497: inq.response_format = 2;
! 1498: inq.additional_length = 32;
! 1499: strlcpy(inq.vendor, "AMI ", sizeof(inq.vendor));
! 1500: snprintf(inq.product, sizeof(inq.product),
! 1501: "Host drive #%02d", target);
! 1502: strlcpy(inq.revision, " ", sizeof(inq.revision));
! 1503: ami_copy_internal_data(xs, &inq, sizeof(inq));
! 1504: s = splbio();
! 1505: scsi_done(xs);
! 1506: splx(s);
! 1507: return (COMPLETE);
! 1508:
! 1509: case READ_CAPACITY:
! 1510: AMI_DPRINTF(AMI_D_CMD, ("READ CAPACITY tgt %d ", target));
! 1511: bzero(&rcd, sizeof(rcd));
! 1512: _lto4b(sc->sc_hdr[target].hd_size - 1, rcd.addr);
! 1513: _lto4b(AMI_SECTOR_SIZE, rcd.length);
! 1514: ami_copy_internal_data(xs, &rcd, sizeof(rcd));
! 1515: s = splbio();
! 1516: scsi_done(xs);
! 1517: splx(s);
! 1518: return (COMPLETE);
! 1519:
! 1520: default:
! 1521: AMI_DPRINTF(AMI_D_CMD, ("unsupported scsi command %#x tgt %d ",
! 1522: xs->cmd->opcode, target));
! 1523: xs->error = XS_DRIVER_STUFFUP;
! 1524: s = splbio();
! 1525: scsi_done(xs);
! 1526: splx(s);
! 1527: return (COMPLETE);
! 1528: }
! 1529:
! 1530: /* A read or write operation. */
! 1531: if (xs->cmdlen == 6) {
! 1532: rw = (struct scsi_rw *)xs->cmd;
! 1533: blockno = _3btol(rw->addr) & (SRW_TOPADDR << 16 | 0xffff);
! 1534: blockcnt = rw->length ? rw->length : 0x100;
! 1535: } else {
! 1536: rwb = (struct scsi_rw_big *)xs->cmd;
! 1537: blockno = _4btol(rwb->addr);
! 1538: blockcnt = _2btol(rwb->length);
! 1539: }
! 1540:
! 1541: if (blockno >= sc->sc_hdr[target].hd_size ||
! 1542: blockno + blockcnt > sc->sc_hdr[target].hd_size) {
! 1543: printf("%s: out of bounds %u-%u >= %u\n", DEVNAME(sc),
! 1544: blockno, blockcnt, sc->sc_hdr[target].hd_size);
! 1545: xs->error = XS_DRIVER_STUFFUP;
! 1546: s = splbio();
! 1547: scsi_done(xs);
! 1548: splx(s);
! 1549: return (COMPLETE);
! 1550: }
! 1551:
! 1552: s = splbio();
! 1553: ccb = ami_get_ccb(sc);
! 1554: splx(s);
! 1555: if (ccb == NULL) {
! 1556: xs->error = XS_DRIVER_STUFFUP;
! 1557: s = splbio();
! 1558: scsi_done(xs);
! 1559: splx(s);
! 1560: return (COMPLETE);
! 1561: }
! 1562:
! 1563: ccb->ccb_xs = xs;
! 1564: ccb->ccb_done = ami_done_xs;
! 1565:
! 1566: cmd = &ccb->ccb_cmd;
! 1567: cmd->acc_cmd = (xs->flags & SCSI_DATA_IN) ? AMI_READ : AMI_WRITE;
! 1568: cmd->acc_mbox.amb_nsect = htole16(blockcnt);
! 1569: cmd->acc_mbox.amb_lba = htole32(blockno);
! 1570: cmd->acc_mbox.amb_ldn = target;
! 1571:
! 1572: error = bus_dmamap_load(sc->sc_dmat, ccb->ccb_dmamap,
! 1573: xs->data, xs->datalen, NULL,
! 1574: (xs->flags & SCSI_NOSLEEP) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
! 1575: if (error) {
! 1576: if (error == EFBIG)
! 1577: printf("more than %d dma segs\n", AMI_MAXOFFSETS);
! 1578: else
! 1579: printf("error %d loading dma map\n", error);
! 1580:
! 1581: xs->error = XS_DRIVER_STUFFUP;
! 1582: s = splbio();
! 1583: ami_put_ccb(ccb);
! 1584: scsi_done(xs);
! 1585: splx(s);
! 1586: return (COMPLETE);
! 1587: }
! 1588:
! 1589: sgd = ccb->ccb_dmamap->dm_segs;
! 1590: if (ccb->ccb_dmamap->dm_nsegs > 1) {
! 1591: struct ami_sgent *sgl = ccb->ccb_sglist;
! 1592:
! 1593: cmd->acc_mbox.amb_nsge = ccb->ccb_dmamap->dm_nsegs;
! 1594: cmd->acc_mbox.amb_data = ccb->ccb_sglistpa;
! 1595:
! 1596: for (i = 0; i < ccb->ccb_dmamap->dm_nsegs; i++) {
! 1597: sgl[i].asg_addr = htole32(sgd[i].ds_addr);
! 1598: sgl[i].asg_len = htole32(sgd[i].ds_len);
! 1599: }
! 1600: } else {
! 1601: cmd->acc_mbox.amb_nsge = 0;
! 1602: cmd->acc_mbox.amb_data = htole32(sgd->ds_addr);
! 1603: }
! 1604:
! 1605: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),
! 1606: ccb->ccb_offset, sizeof(struct ami_ccbmem),
! 1607: BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
! 1608:
! 1609: bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
! 1610: ccb->ccb_dmamap->dm_mapsize, (xs->flags & SCSI_DATA_IN) ?
! 1611: BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
! 1612:
! 1613: return (ami_start_xs(sc, ccb, xs));
! 1614: }
! 1615:
! 1616: int
! 1617: ami_intr(void *v)
! 1618: {
! 1619: struct ami_softc *sc = v;
! 1620: struct ami_iocmd mbox;
! 1621: int i, rv = 0;
! 1622:
! 1623: if (TAILQ_EMPTY(&sc->sc_ccb_runq))
! 1624: return (0);
! 1625:
! 1626: AMI_DPRINTF(AMI_D_INTR, ("intr "));
! 1627:
! 1628: while ((sc->sc_done)(sc, &mbox)) {
! 1629: AMI_DPRINTF(AMI_D_CMD, ("got#%d ", mbox.acc_nstat));
! 1630: for (i = 0; i < mbox.acc_nstat; i++ ) {
! 1631: int ready = mbox.acc_cmplidl[i];
! 1632:
! 1633: AMI_DPRINTF(AMI_D_CMD, ("ready=%d ", ready));
! 1634:
! 1635: if (!ami_done(sc, ready))
! 1636: rv |= 1;
! 1637: }
! 1638: }
! 1639:
! 1640: if (rv)
! 1641: ami_runqueue(sc);
! 1642:
! 1643: AMI_DPRINTF(AMI_D_INTR, ("exit "));
! 1644: return (rv);
! 1645: }
! 1646:
! 1647: int
! 1648: ami_scsi_ioctl(struct scsi_link *link, u_long cmd, caddr_t addr, int flag,
! 1649: struct proc *p)
! 1650: {
! 1651: struct ami_softc *sc = (struct ami_softc *)link->adapter_softc;
! 1652: /* struct device *dev = (struct device *)link->device_softc; */
! 1653: /* u_int8_t target = link->target; */
! 1654:
! 1655: if (sc->sc_ioctl)
! 1656: return (sc->sc_ioctl(link->adapter_softc, cmd, addr));
! 1657: else
! 1658: return (ENOTTY);
! 1659: }
! 1660:
! 1661: #if NBIO > 0
! 1662: int
! 1663: ami_ioctl(struct device *dev, u_long cmd, caddr_t addr)
! 1664: {
! 1665: struct ami_softc *sc = (struct ami_softc *)dev;
! 1666: int error = 0;
! 1667:
! 1668: AMI_DPRINTF(AMI_D_IOCTL, ("%s: ioctl ", DEVNAME(sc)));
! 1669:
! 1670: if (sc->sc_flags & AMI_BROKEN)
! 1671: return (ENODEV); /* can't do this to broken device for now */
! 1672:
! 1673: switch (cmd) {
! 1674: case BIOCINQ:
! 1675: AMI_DPRINTF(AMI_D_IOCTL, ("inq "));
! 1676: error = ami_ioctl_inq(sc, (struct bioc_inq *)addr);
! 1677: break;
! 1678:
! 1679: case BIOCVOL:
! 1680: AMI_DPRINTF(AMI_D_IOCTL, ("vol "));
! 1681: error = ami_ioctl_vol(sc, (struct bioc_vol *)addr);
! 1682: break;
! 1683:
! 1684: case BIOCDISK:
! 1685: AMI_DPRINTF(AMI_D_IOCTL, ("disk "));
! 1686: error = ami_ioctl_disk(sc, (struct bioc_disk *)addr);
! 1687: break;
! 1688:
! 1689: case BIOCALARM:
! 1690: AMI_DPRINTF(AMI_D_IOCTL, ("alarm "));
! 1691: error = ami_ioctl_alarm(sc, (struct bioc_alarm *)addr);
! 1692: break;
! 1693:
! 1694: case BIOCSETSTATE:
! 1695: AMI_DPRINTF(AMI_D_IOCTL, ("setstate "));
! 1696: error = ami_ioctl_setstate(sc, (struct bioc_setstate *)addr);
! 1697: break;
! 1698:
! 1699: default:
! 1700: AMI_DPRINTF(AMI_D_IOCTL, (" invalid ioctl\n"));
! 1701: error = EINVAL;
! 1702: }
! 1703:
! 1704: return (error);
! 1705: }
! 1706:
! 1707: int
! 1708: ami_drv_inq(struct ami_softc *sc, u_int8_t ch, u_int8_t tg, u_int8_t page,
! 1709: void *inqbuf)
! 1710: {
! 1711: struct ami_ccb *ccb;
! 1712: struct ami_passthrough *pt;
! 1713: struct scsi_inquiry_data *inq = inqbuf;
! 1714: int error = 0;
! 1715: int s;
! 1716:
! 1717: rw_enter_write(&sc->sc_lock);
! 1718:
! 1719: s = splbio();
! 1720: ccb = ami_get_ccb(sc);
! 1721: splx(s);
! 1722: if (ccb == NULL) {
! 1723: error = ENOMEM;
! 1724: goto err;
! 1725: }
! 1726:
! 1727: ccb->ccb_done = ami_done_ioctl;
! 1728:
! 1729: ccb->ccb_cmd.acc_cmd = AMI_PASSTHRU;
! 1730: ccb->ccb_cmd.acc_passthru.apt_data = ccb->ccb_ptpa;
! 1731:
! 1732: pt = ccb->ccb_pt;
! 1733: memset(pt, 0, sizeof(struct ami_passthrough));
! 1734: pt->apt_channel = ch;
! 1735: pt->apt_target = tg;
! 1736: pt->apt_ncdb = sizeof(struct scsi_inquiry);
! 1737: pt->apt_nsense = sizeof(struct scsi_sense_data);
! 1738: pt->apt_datalen = sizeof(struct scsi_inquiry_data);
! 1739: pt->apt_data = 0;
! 1740:
! 1741: pt->apt_cdb[0] = INQUIRY;
! 1742: pt->apt_cdb[1] = 0;
! 1743: pt->apt_cdb[2] = 0;
! 1744: pt->apt_cdb[3] = 0;
! 1745: pt->apt_cdb[4] = sizeof(struct scsi_inquiry_data); /* INQUIRY length */
! 1746: pt->apt_cdb[5] = 0;
! 1747:
! 1748: if (page != 0) {
! 1749: pt->apt_cdb[1] = SI_EVPD;
! 1750: pt->apt_cdb[2] = page;
! 1751: }
! 1752:
! 1753: if (ami_load_ptmem(sc, ccb, inqbuf, sizeof(struct scsi_inquiry_data),
! 1754: 1, 0) != 0) {
! 1755: error = ENOMEM;
! 1756: goto ptmemerr;
! 1757: }
! 1758:
! 1759: ami_start(sc, ccb);
! 1760:
! 1761: while (ccb->ccb_state != AMI_CCB_READY)
! 1762: tsleep(ccb, PRIBIO, "ami_drv_inq", 0);
! 1763:
! 1764: bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
! 1765: ccb->ccb_dmamap->dm_mapsize, BUS_DMASYNC_POSTREAD);
! 1766: bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),
! 1767: ccb->ccb_offset, sizeof(struct ami_ccbmem),
! 1768: BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
! 1769: bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap);
! 1770:
! 1771: if (ccb->ccb_flags & AMI_CCB_F_ERR)
! 1772: error = EIO;
! 1773: else if (pt->apt_scsistat != 0x00)
! 1774: error = EIO;
! 1775: else if ((inq->device & SID_TYPE) != T_DIRECT)
! 1776: error = EINVAL;
! 1777:
! 1778: ptmemerr:
! 1779: s = splbio();
! 1780: ami_put_ccb(ccb);
! 1781: splx(s);
! 1782:
! 1783: err:
! 1784: rw_exit_write(&sc->sc_lock);
! 1785: return (error);
! 1786: }
! 1787:
! 1788: int
! 1789: ami_mgmt(struct ami_softc *sc, u_int8_t opcode, u_int8_t par1, u_int8_t par2,
! 1790: u_int8_t par3, size_t size, void *buffer)
! 1791: {
! 1792: struct ami_ccb *ccb;
! 1793: struct ami_iocmd *cmd;
! 1794: struct ami_mem *am = NULL;
! 1795: char *idata = NULL;
! 1796: int error = 0;
! 1797: int s;
! 1798:
! 1799: rw_enter_write(&sc->sc_lock);
! 1800:
! 1801: s = splbio();
! 1802: ccb = ami_get_ccb(sc);
! 1803: splx(s);
! 1804: if (ccb == NULL) {
! 1805: error = ENOMEM;
! 1806: goto err;
! 1807: }
! 1808:
! 1809: if (size) {
! 1810: if ((am = ami_allocmem(sc, size)) == NULL) {
! 1811: error = ENOMEM;
! 1812: goto memerr;
! 1813: }
! 1814: idata = AMIMEM_KVA(am);
! 1815: }
! 1816:
! 1817: ccb->ccb_done = ami_done_ioctl;
! 1818: cmd = &ccb->ccb_cmd;
! 1819:
! 1820: cmd->acc_cmd = opcode;
! 1821:
! 1822: /*
! 1823: * some commands require data to be written to idata before sending
! 1824: * command to fw
! 1825: */
! 1826: switch (opcode) {
! 1827: case AMI_SPEAKER:
! 1828: *idata = par1;
! 1829: break;
! 1830: default:
! 1831: cmd->acc_io.aio_channel = par1;
! 1832: cmd->acc_io.aio_param = par2;
! 1833: cmd->acc_io.aio_pad[0] = par3;
! 1834: break;
! 1835: };
! 1836:
! 1837: cmd->acc_io.aio_data = am ? htole32(AMIMEM_DVA(am)) : 0;
! 1838:
! 1839: ami_start(sc, ccb);
! 1840: while (ccb->ccb_state != AMI_CCB_READY)
! 1841: tsleep(ccb, PRIBIO,"ami_mgmt", 0);
! 1842:
! 1843: if (ccb->ccb_flags & AMI_CCB_F_ERR)
! 1844: error = EIO;
! 1845: else if (buffer && size)
! 1846: memcpy(buffer, idata, size);
! 1847:
! 1848: if (am)
! 1849: ami_freemem(sc, am);
! 1850:
! 1851: memerr:
! 1852: s = splbio();
! 1853: ami_put_ccb(ccb);
! 1854: splx(s);
! 1855:
! 1856: err:
! 1857: rw_exit_write(&sc->sc_lock);
! 1858: return (error);
! 1859: }
! 1860:
! 1861: int
! 1862: ami_ioctl_inq(struct ami_softc *sc, struct bioc_inq *bi)
! 1863: {
! 1864: struct ami_big_diskarray *p; /* struct too large for stack */
! 1865: char *plist;
! 1866: int i, s, t;
! 1867: int off;
! 1868: int error = 0;
! 1869: struct scsi_inquiry_data inqbuf;
! 1870: u_int8_t ch, tg;
! 1871:
! 1872: p = malloc(sizeof *p, M_DEVBUF, M_NOWAIT);
! 1873: if (!p)
! 1874: return (ENOMEM);
! 1875:
! 1876: plist = malloc(AMI_BIG_MAX_PDRIVES, M_DEVBUF, M_NOWAIT);
! 1877: if (!plist) {
! 1878: error = ENOMEM;
! 1879: goto bail;
! 1880: }
! 1881:
! 1882: if ((error = ami_mgmt(sc, AMI_FCOP, AMI_FC_RDCONF, 0, 0, sizeof *p,
! 1883: p)))
! 1884: goto bail2;
! 1885:
! 1886: memset(plist, 0, AMI_BIG_MAX_PDRIVES);
! 1887:
! 1888: bi->bi_novol = p->ada_nld;
! 1889: bi->bi_nodisk = 0;
! 1890:
! 1891: strlcpy(bi->bi_dev, DEVNAME(sc), sizeof(bi->bi_dev));
! 1892:
! 1893: /* do we actually care how many disks we have at this point? */
! 1894: for (i = 0; i < p->ada_nld; i++)
! 1895: for (s = 0; s < p->ald[i].adl_spandepth; s++)
! 1896: for (t = 0; t < p->ald[i].adl_nstripes; t++) {
! 1897: off = p->ald[i].asp[s].adv[t].add_channel *
! 1898: AMI_MAX_TARGET +
! 1899: p->ald[i].asp[s].adv[t].add_target;
! 1900:
! 1901: if (!plist[off]) {
! 1902: plist[off] = 1;
! 1903: bi->bi_nodisk++;
! 1904: }
! 1905: }
! 1906:
! 1907: /*
! 1908: * hack warning!
! 1909: * Megaraid cards sometimes return a size in the PD structure
! 1910: * even though there is no disk in that slot. Work around
! 1911: * that by issuing an INQUIRY to determine if there is
! 1912: * an actual disk in the slot.
! 1913: */
! 1914: for(i = 0; i < ((sc->sc_flags & AMI_QUARTZ) ?
! 1915: AMI_BIG_MAX_PDRIVES : AMI_MAX_PDRIVES); i++) {
! 1916: /* skip claimed drives */
! 1917: if (plist[i])
! 1918: continue;
! 1919:
! 1920: /*
! 1921: * poke drive to make sure its there. If it is it is either
! 1922: * unused or a hot spare; at this point we dont care which it is
! 1923: */
! 1924: if (p->apd[i].adp_size) {
! 1925: ch = (i & 0xf0) >> 4;
! 1926: tg = i & 0x0f;
! 1927:
! 1928: if (!ami_drv_inq(sc, ch, tg, 0, &inqbuf)) {
! 1929: bi->bi_novol++;
! 1930: bi->bi_nodisk++;
! 1931: plist[i] = 1;
! 1932: }
! 1933: }
! 1934: }
! 1935:
! 1936: bail2:
! 1937: free(plist, M_DEVBUF);
! 1938: bail:
! 1939: free(p, M_DEVBUF);
! 1940:
! 1941: return (error);
! 1942: }
! 1943:
! 1944: int
! 1945: ami_vol(struct ami_softc *sc, struct bioc_vol *bv, struct ami_big_diskarray *p)
! 1946: {
! 1947: struct scsi_inquiry_data inqbuf;
! 1948: char *plist;
! 1949: int i, s, t, off;
! 1950: int ld = p->ada_nld, error = EINVAL;
! 1951: u_int8_t ch, tg;
! 1952:
! 1953: plist = malloc(AMI_BIG_MAX_PDRIVES, M_DEVBUF, M_NOWAIT);
! 1954: if (!plist)
! 1955: return (ENOMEM);
! 1956:
! 1957: memset(plist, 0, AMI_BIG_MAX_PDRIVES);
! 1958:
! 1959: /* setup plist */
! 1960: for (i = 0; i < p->ada_nld; i++)
! 1961: for (s = 0; s < p->ald[i].adl_spandepth; s++)
! 1962: for (t = 0; t < p->ald[i].adl_nstripes; t++) {
! 1963: off = p->ald[i].asp[s].adv[t].add_channel *
! 1964: AMI_MAX_TARGET +
! 1965: p->ald[i].asp[s].adv[t].add_target;
! 1966:
! 1967: if (!plist[off])
! 1968: plist[off] = 1;
! 1969: }
! 1970:
! 1971: for(i = 0; i < ((sc->sc_flags & AMI_QUARTZ) ?
! 1972: AMI_BIG_MAX_PDRIVES : AMI_MAX_PDRIVES); i++) {
! 1973: /* skip claimed drives */
! 1974: if (plist[i])
! 1975: continue;
! 1976:
! 1977: /*
! 1978: * poke drive to make sure its there. If it is it is either
! 1979: * unused or a hot spare; at this point we dont care which it is
! 1980: */
! 1981: if (p->apd[i].adp_size) {
! 1982: ch = (i & 0xf0) >> 4;
! 1983: tg = i & 0x0f;
! 1984:
! 1985: if (!ami_drv_inq(sc, ch, tg, 0, &inqbuf)) {
! 1986: if (ld != bv->bv_volid) {
! 1987: ld++;
! 1988: continue;
! 1989: }
! 1990:
! 1991: bv->bv_status = BIOC_SVONLINE;
! 1992: bv->bv_size = (u_quad_t)p->apd[i].adp_size *
! 1993: (u_quad_t)512;
! 1994: bv->bv_nodisk = 1;
! 1995: strlcpy(bv->bv_dev,
! 1996: sc->sc_hdr[bv->bv_volid].dev,
! 1997: sizeof(bv->bv_dev));
! 1998:
! 1999: if (p->apd[i].adp_ostatus == AMI_PD_HOTSPARE
! 2000: && p->apd[i].adp_type == 0)
! 2001: bv->bv_level = -1;
! 2002: else
! 2003: bv->bv_level = -2;
! 2004:
! 2005: error = 0;
! 2006: goto bail;
! 2007: }
! 2008: }
! 2009: }
! 2010:
! 2011: bail:
! 2012: free(plist, M_DEVBUF);
! 2013:
! 2014: return (error);
! 2015: }
! 2016:
! 2017: int
! 2018: ami_disk(struct ami_softc *sc, struct bioc_disk *bd,
! 2019: struct ami_big_diskarray *p)
! 2020: {
! 2021: struct scsi_inquiry_data inqbuf;
! 2022: struct scsi_inquiry_vpd vpdbuf;
! 2023: char *plist;
! 2024: int i, s, t, off;
! 2025: int ld = p->ada_nld, error = EINVAL;
! 2026: u_int8_t ch, tg;
! 2027:
! 2028: plist = malloc(AMI_BIG_MAX_PDRIVES, M_DEVBUF, M_NOWAIT);
! 2029: if (!plist)
! 2030: return (ENOMEM);
! 2031:
! 2032: memset(plist, 0, AMI_BIG_MAX_PDRIVES);
! 2033:
! 2034: /* setup plist */
! 2035: for (i = 0; i < p->ada_nld; i++)
! 2036: for (s = 0; s < p->ald[i].adl_spandepth; s++)
! 2037: for (t = 0; t < p->ald[i].adl_nstripes; t++) {
! 2038: off = p->ald[i].asp[s].adv[t].add_channel *
! 2039: AMI_MAX_TARGET +
! 2040: p->ald[i].asp[s].adv[t].add_target;
! 2041:
! 2042: if (!plist[off])
! 2043: plist[off] = 1;
! 2044: }
! 2045:
! 2046: for(i = 0; i < ((sc->sc_flags & AMI_QUARTZ) ?
! 2047: AMI_BIG_MAX_PDRIVES : AMI_MAX_PDRIVES); i++) {
! 2048: char vend[8+16+4+1];
! 2049:
! 2050: /* skip claimed drives */
! 2051: if (plist[i])
! 2052: continue;
! 2053:
! 2054: /* no size no disk, most of the times */
! 2055: if (!p->apd[i].adp_size)
! 2056: continue;
! 2057:
! 2058: ch = (i & 0xf0) >> 4;
! 2059: tg = i & 0x0f;
! 2060:
! 2061: /*
! 2062: * poke drive to make sure its there. If it is it is either
! 2063: * unused or a hot spare; at this point we dont care which it is
! 2064: */
! 2065: if (ami_drv_inq(sc, ch, tg, 0, &inqbuf))
! 2066: continue;
! 2067:
! 2068: if (ld != bd->bd_volid) {
! 2069: ld++;
! 2070: continue;
! 2071: }
! 2072:
! 2073: bcopy(inqbuf.vendor, vend, sizeof vend - 1);
! 2074:
! 2075: vend[sizeof vend - 1] = '\0';
! 2076: strlcpy(bd->bd_vendor, vend, sizeof(bd->bd_vendor));
! 2077:
! 2078: if (!ami_drv_inq(sc, ch, tg, 0x80, &vpdbuf)) {
! 2079: char ser[32 + 1];
! 2080:
! 2081: bcopy(vpdbuf.serial, ser, sizeof ser - 1);
! 2082:
! 2083: ser[sizeof ser - 1] = '\0';
! 2084: if (vpdbuf.page_length < sizeof ser)
! 2085: ser[vpdbuf.page_length] = '\0';
! 2086:
! 2087: strlcpy(bd->bd_serial, ser, sizeof(bd->bd_serial));
! 2088: }
! 2089:
! 2090: bd->bd_size = (u_quad_t)p->apd[i].adp_size * (u_quad_t)512;
! 2091:
! 2092: bd->bd_channel = ch;
! 2093: bd->bd_target = tg;
! 2094:
! 2095: strlcpy(bd->bd_procdev, sc->sc_rawsoftcs[ch].sc_procdev,
! 2096: sizeof(bd->bd_procdev));
! 2097:
! 2098: if (p->apd[i].adp_ostatus == AMI_PD_HOTSPARE)
! 2099: bd->bd_status = BIOC_SDHOTSPARE;
! 2100: else
! 2101: bd->bd_status = BIOC_SDUNUSED;
! 2102:
! 2103: #ifdef AMI_DEBUG
! 2104: if (p->apd[i].adp_type != 0)
! 2105: printf("invalid disk type: %d %d %x inquiry type: %x\n",
! 2106: ch, tg, p->apd[i].adp_type, inqbuf.device);
! 2107: #endif /* AMI_DEBUG */
! 2108:
! 2109: error = 0;
! 2110: goto bail;
! 2111: }
! 2112:
! 2113: bail:
! 2114: free(plist, M_DEVBUF);
! 2115:
! 2116: return (error);
! 2117: }
! 2118:
! 2119: int
! 2120: ami_ioctl_vol(struct ami_softc *sc, struct bioc_vol *bv)
! 2121: {
! 2122: struct ami_big_diskarray *p; /* struct too large for stack */
! 2123: int i, s, t, off;
! 2124: int error = 0;
! 2125: struct ami_progress perc;
! 2126: u_int8_t bgi[5]; /* 40 LD, 1 bit per LD if BGI is active */
! 2127:
! 2128: p = malloc(sizeof *p, M_DEVBUF, M_NOWAIT);
! 2129: if (!p)
! 2130: return (ENOMEM);
! 2131:
! 2132: if ((error = ami_mgmt(sc, AMI_FCOP, AMI_FC_RDCONF, 0, 0, sizeof *p, p)))
! 2133: goto bail;
! 2134:
! 2135: if (bv->bv_volid >= p->ada_nld) {
! 2136: error = ami_vol(sc, bv, p);
! 2137: goto bail;
! 2138: }
! 2139:
! 2140: i = bv->bv_volid;
! 2141:
! 2142: switch (p->ald[i].adl_status) {
! 2143: case AMI_RDRV_OFFLINE:
! 2144: bv->bv_status = BIOC_SVOFFLINE;
! 2145: break;
! 2146:
! 2147: case AMI_RDRV_DEGRADED:
! 2148: bv->bv_status = BIOC_SVDEGRADED;
! 2149: break;
! 2150:
! 2151: case AMI_RDRV_OPTIMAL:
! 2152: bv->bv_status = BIOC_SVONLINE;
! 2153: bv->bv_percent = -1;
! 2154:
! 2155: /* get BGI progress here and over-ride status if so */
! 2156: memset(bgi, 0, sizeof bgi);
! 2157: if (ami_mgmt(sc, AMI_MISC, AMI_GET_BGI, 0, 0, sizeof bgi, &bgi))
! 2158: break;
! 2159:
! 2160: if ((bgi[i / 8] & (1 << i % 8)) == 0)
! 2161: break;
! 2162:
! 2163: if (!ami_mgmt(sc, AMI_GCHECKPROGR, i, 0, 0, sizeof perc, &perc))
! 2164: if (perc.apr_progress < 100) {
! 2165: bv->bv_status = BIOC_SVSCRUB;
! 2166: bv->bv_percent = perc.apr_progress >= 100 ? -1 :
! 2167: perc.apr_progress;
! 2168: }
! 2169: break;
! 2170:
! 2171: default:
! 2172: bv->bv_status = BIOC_SVINVALID;
! 2173: }
! 2174:
! 2175: /* over-ride status if a pd is in rebuild status for this ld */
! 2176: for (s = 0; s < p->ald[i].adl_spandepth; s++)
! 2177: for (t = 0; t < p->ald[i].adl_nstripes; t++) {
! 2178: off = p->ald[i].asp[s].adv[t].add_channel *
! 2179: AMI_MAX_TARGET +
! 2180: p->ald[i].asp[s].adv[t].add_target;
! 2181:
! 2182: if (p->apd[off].adp_ostatus != AMI_PD_RBLD)
! 2183: continue;
! 2184:
! 2185: /* get rebuild progress here */
! 2186: bv->bv_status = BIOC_SVREBUILD;
! 2187: if (ami_mgmt(sc, AMI_GRBLDPROGR,
! 2188: p->ald[i].asp[s].adv[t].add_channel,
! 2189: p->ald[i].asp[s].adv[t].add_target, 0,
! 2190: sizeof perc, &perc))
! 2191: bv->bv_percent = -1;
! 2192: else
! 2193: bv->bv_percent = perc.apr_progress >= 100 ? -1 :
! 2194: perc.apr_progress;
! 2195:
! 2196: /* XXX fix this, we should either use lowest percentage
! 2197: * of all disks in rebuild state or an average
! 2198: */
! 2199: break;
! 2200: }
! 2201:
! 2202: bv->bv_size = 0;
! 2203: bv->bv_level = p->ald[i].adl_raidlvl;
! 2204: bv->bv_nodisk = 0;
! 2205:
! 2206: for (s = 0; s < p->ald[i].adl_spandepth; s++) {
! 2207: for (t = 0; t < p->ald[i].adl_nstripes; t++)
! 2208: bv->bv_nodisk++;
! 2209:
! 2210: switch (bv->bv_level) {
! 2211: case 0:
! 2212: bv->bv_size += p->ald[i].asp[s].ads_length *
! 2213: p->ald[i].adl_nstripes;
! 2214: break;
! 2215:
! 2216: case 1:
! 2217: bv->bv_size += p->ald[i].asp[s].ads_length;
! 2218: break;
! 2219:
! 2220: case 5:
! 2221: bv->bv_size += p->ald[i].asp[s].ads_length *
! 2222: (p->ald[i].adl_nstripes - 1);
! 2223: break;
! 2224: }
! 2225: }
! 2226:
! 2227: if (p->ald[i].adl_spandepth > 1)
! 2228: bv->bv_level *= 10;
! 2229:
! 2230: bv->bv_size *= (u_quad_t)512;
! 2231:
! 2232: strlcpy(bv->bv_dev, sc->sc_hdr[i].dev, sizeof(bv->bv_dev));
! 2233:
! 2234: bail:
! 2235: free(p, M_DEVBUF);
! 2236:
! 2237: return (error);
! 2238: }
! 2239:
! 2240: int
! 2241: ami_ioctl_disk(struct ami_softc *sc, struct bioc_disk *bd)
! 2242: {
! 2243: struct scsi_inquiry_data inqbuf;
! 2244: struct scsi_inquiry_vpd vpdbuf;
! 2245: struct ami_big_diskarray *p; /* struct too large for stack */
! 2246: int i, s, t, d;
! 2247: int off;
! 2248: int error = 0;
! 2249: u_int16_t ch, tg;
! 2250:
! 2251: p = malloc(sizeof *p, M_DEVBUF, M_NOWAIT);
! 2252: if (!p)
! 2253: return (ENOMEM);
! 2254:
! 2255: if ((error = ami_mgmt(sc, AMI_FCOP, AMI_FC_RDCONF, 0, 0, sizeof *p, p)))
! 2256: goto bail;
! 2257:
! 2258: if (bd->bd_volid >= p->ada_nld) {
! 2259: error = ami_disk(sc, bd, p);
! 2260: goto bail;
! 2261: }
! 2262:
! 2263: i = bd->bd_volid;
! 2264: error = EINVAL;
! 2265:
! 2266: for (s = 0, d = 0; s < p->ald[i].adl_spandepth; s++)
! 2267: for (t = 0; t < p->ald[i].adl_nstripes; t++) {
! 2268: if (d != bd->bd_diskid) {
! 2269: d++;
! 2270: continue;
! 2271: }
! 2272:
! 2273: off = p->ald[i].asp[s].adv[t].add_channel *
! 2274: AMI_MAX_TARGET +
! 2275: p->ald[i].asp[s].adv[t].add_target;
! 2276:
! 2277: switch (p->apd[off].adp_ostatus) {
! 2278: case AMI_PD_UNCNF:
! 2279: bd->bd_status = BIOC_SDUNUSED;
! 2280: break;
! 2281:
! 2282: case AMI_PD_ONLINE:
! 2283: bd->bd_status = BIOC_SDONLINE;
! 2284: break;
! 2285:
! 2286: case AMI_PD_FAILED:
! 2287: bd->bd_status = BIOC_SDFAILED;
! 2288: break;
! 2289:
! 2290: case AMI_PD_RBLD:
! 2291: bd->bd_status = BIOC_SDREBUILD;
! 2292: break;
! 2293:
! 2294: case AMI_PD_HOTSPARE:
! 2295: bd->bd_status = BIOC_SDHOTSPARE;
! 2296: break;
! 2297:
! 2298: default:
! 2299: bd->bd_status = BIOC_SDINVALID;
! 2300: }
! 2301:
! 2302: bd->bd_size = (u_quad_t)p->apd[off].adp_size *
! 2303: (u_quad_t)512;
! 2304:
! 2305: ch = p->ald[i].asp[s].adv[t].add_target >> 4;
! 2306: tg = p->ald[i].asp[s].adv[t].add_target & 0x0f;
! 2307:
! 2308: if (!ami_drv_inq(sc, ch, tg, 0, &inqbuf)) {
! 2309: char vend[8+16+4+1];
! 2310:
! 2311: bcopy(inqbuf.vendor, vend, sizeof vend - 1);
! 2312:
! 2313: vend[sizeof vend - 1] = '\0';
! 2314: strlcpy(bd->bd_vendor, vend,
! 2315: sizeof(bd->bd_vendor));
! 2316: }
! 2317:
! 2318: if (!ami_drv_inq(sc, ch, tg, 0x80, &vpdbuf)) {
! 2319: char ser[32 + 1];
! 2320:
! 2321: bcopy(vpdbuf.serial, ser, sizeof ser - 1);
! 2322:
! 2323: ser[sizeof ser - 1] = '\0';
! 2324: if (vpdbuf.page_length < sizeof ser)
! 2325: ser[vpdbuf.page_length] = '\0';
! 2326: strlcpy(bd->bd_serial, ser,
! 2327: sizeof(bd->bd_serial));
! 2328: }
! 2329:
! 2330: bd->bd_channel = ch;
! 2331: bd->bd_target = tg;
! 2332:
! 2333: strlcpy(bd->bd_procdev, sc->sc_rawsoftcs[ch].sc_procdev,
! 2334: sizeof(bd->bd_procdev));
! 2335:
! 2336: error = 0;
! 2337: goto bail;
! 2338: }
! 2339:
! 2340: /* XXX if we reach this do dedicated hotspare magic*/
! 2341: bail:
! 2342: free(p, M_DEVBUF);
! 2343:
! 2344: return (error);
! 2345: }
! 2346:
! 2347: int ami_ioctl_alarm(struct ami_softc *sc, struct bioc_alarm *ba)
! 2348: {
! 2349: int error = 0;
! 2350: u_int8_t func, ret;
! 2351:
! 2352: switch(ba->ba_opcode) {
! 2353: case BIOC_SADISABLE:
! 2354: func = AMI_SPKR_OFF;
! 2355: break;
! 2356:
! 2357: case BIOC_SAENABLE:
! 2358: func = AMI_SPKR_ON;
! 2359: break;
! 2360:
! 2361: case BIOC_SASILENCE:
! 2362: func = AMI_SPKR_SHUT;
! 2363: break;
! 2364:
! 2365: case BIOC_GASTATUS:
! 2366: func = AMI_SPKR_GVAL;
! 2367: break;
! 2368:
! 2369: case BIOC_SATEST:
! 2370: func = AMI_SPKR_TEST;
! 2371: break;
! 2372:
! 2373: default:
! 2374: AMI_DPRINTF(AMI_D_IOCTL, ("%s: biocalarm invalid opcode %x\n",
! 2375: DEVNAME(sc), ba->ba_opcode));
! 2376: return (EINVAL);
! 2377: }
! 2378:
! 2379: if (!(error = ami_mgmt(sc, AMI_SPEAKER, func, 0, 0, sizeof ret,
! 2380: &ret))) {
! 2381: if (ba->ba_opcode == BIOC_GASTATUS)
! 2382: ba->ba_status = ret;
! 2383: else
! 2384: ba->ba_status = 0;
! 2385: }
! 2386:
! 2387: return (error);
! 2388: }
! 2389:
! 2390: int
! 2391: ami_ioctl_setstate(struct ami_softc *sc, struct bioc_setstate *bs)
! 2392: {
! 2393: struct scsi_inquiry_data inqbuf;
! 2394: int func, off, error;
! 2395:
! 2396: switch (bs->bs_status) {
! 2397: case BIOC_SSONLINE:
! 2398: func = AMI_STATE_ON;
! 2399: break;
! 2400:
! 2401: case BIOC_SSOFFLINE:
! 2402: func = AMI_STATE_FAIL;
! 2403: break;
! 2404:
! 2405: case BIOC_SSHOTSPARE:
! 2406: off = bs->bs_channel * AMI_MAX_TARGET + bs->bs_target;
! 2407:
! 2408: if (ami_drv_inq(sc, bs->bs_channel, bs->bs_target, 0,
! 2409: &inqbuf))
! 2410: return (EINVAL);
! 2411:
! 2412: func = AMI_STATE_SPARE;
! 2413: break;
! 2414:
! 2415: default:
! 2416: AMI_DPRINTF(AMI_D_IOCTL, ("%s: biocsetstate invalid opcode %x\n"
! 2417: , DEVNAME(sc), bs->bs_status));
! 2418: return (EINVAL);
! 2419: }
! 2420:
! 2421: if ((error = ami_mgmt(sc, AMI_CHSTATE, bs->bs_channel, bs->bs_target,
! 2422: func, 0, NULL)))
! 2423: return (error);
! 2424:
! 2425: return (0);
! 2426: }
! 2427:
! 2428: #ifndef SMALL_KERNEL
! 2429: int
! 2430: ami_create_sensors(struct ami_softc *sc)
! 2431: {
! 2432: struct device *dev;
! 2433: struct scsibus_softc *ssc;
! 2434: int i;
! 2435:
! 2436: TAILQ_FOREACH(dev, &alldevs, dv_list) {
! 2437: if (dev->dv_parent != &sc->sc_dev)
! 2438: continue;
! 2439:
! 2440: /* check if this is the scsibus for the logical disks */
! 2441: ssc = (struct scsibus_softc *)dev;
! 2442: if (ssc->adapter_link == &sc->sc_link)
! 2443: break;
! 2444: }
! 2445:
! 2446: if (ssc == NULL)
! 2447: return (1);
! 2448:
! 2449: sc->sc_sensors = malloc(sizeof(struct ksensor) * sc->sc_nunits,
! 2450: M_DEVBUF, M_WAITOK);
! 2451: if (sc->sc_sensors == NULL)
! 2452: return (1);
! 2453: bzero(sc->sc_sensors, sizeof(struct ksensor) * sc->sc_nunits);
! 2454:
! 2455: strlcpy(sc->sc_sensordev.xname, DEVNAME(sc),
! 2456: sizeof(sc->sc_sensordev.xname));
! 2457:
! 2458: for (i = 0; i < sc->sc_nunits; i++) {
! 2459: if (ssc->sc_link[i][0] == NULL)
! 2460: goto bad;
! 2461:
! 2462: dev = ssc->sc_link[i][0]->device_softc;
! 2463:
! 2464: sc->sc_sensors[i].type = SENSOR_DRIVE;
! 2465: sc->sc_sensors[i].status = SENSOR_S_UNKNOWN;
! 2466:
! 2467: strlcpy(sc->sc_sensors[i].desc, dev->dv_xname,
! 2468: sizeof(sc->sc_sensors[i].desc));
! 2469:
! 2470: sensor_attach(&sc->sc_sensordev, &sc->sc_sensors[i]);
! 2471: }
! 2472:
! 2473: sc->sc_bd = malloc(sizeof(*sc->sc_bd), M_DEVBUF, M_WAITOK);
! 2474: if (sc->sc_bd == NULL)
! 2475: goto bad;
! 2476:
! 2477: if (sensor_task_register(sc, ami_refresh_sensors, 10) == NULL)
! 2478: goto freebd;
! 2479:
! 2480: sensordev_install(&sc->sc_sensordev);
! 2481:
! 2482: return (0);
! 2483:
! 2484: freebd:
! 2485: free(sc->sc_bd, M_DEVBUF);
! 2486: bad:
! 2487: free(sc->sc_sensors, M_DEVBUF);
! 2488:
! 2489: return (1);
! 2490: }
! 2491:
! 2492: void
! 2493: ami_refresh_sensors(void *arg)
! 2494: {
! 2495: struct ami_softc *sc = arg;
! 2496: int i;
! 2497:
! 2498: if (ami_mgmt(sc, AMI_FCOP, AMI_FC_RDCONF, 0, 0, sizeof(*sc->sc_bd),
! 2499: sc->sc_bd)) {
! 2500: for (i = 0; i < sc->sc_nunits; i++) {
! 2501: sc->sc_sensors[i].value = 0; /* unknown */
! 2502: sc->sc_sensors[i].status = SENSOR_S_UNKNOWN;
! 2503: }
! 2504: return;
! 2505: }
! 2506:
! 2507: for (i = 0; i < sc->sc_nunits; i++) {
! 2508: switch (sc->sc_bd->ald[i].adl_status) {
! 2509: case AMI_RDRV_OFFLINE:
! 2510: sc->sc_sensors[i].value = SENSOR_DRIVE_FAIL;
! 2511: sc->sc_sensors[i].status = SENSOR_S_CRIT;
! 2512: break;
! 2513:
! 2514: case AMI_RDRV_DEGRADED:
! 2515: sc->sc_sensors[i].value = SENSOR_DRIVE_PFAIL;
! 2516: sc->sc_sensors[i].status = SENSOR_S_WARN;
! 2517: break;
! 2518:
! 2519: case AMI_RDRV_OPTIMAL:
! 2520: sc->sc_sensors[i].value = SENSOR_DRIVE_ONLINE;
! 2521: sc->sc_sensors[i].status = SENSOR_S_OK;
! 2522: break;
! 2523:
! 2524: default:
! 2525: sc->sc_sensors[i].value = 0; /* unknown */
! 2526: sc->sc_sensors[i].status = SENSOR_S_UNKNOWN;
! 2527: }
! 2528: }
! 2529: }
! 2530: #endif /* SMALL_KERNEL */
! 2531: #endif /* NBIO > 0 */
! 2532:
! 2533: #ifdef AMI_DEBUG
! 2534: void
! 2535: ami_print_mbox(struct ami_iocmd *mbox)
! 2536: {
! 2537: int i;
! 2538:
! 2539: printf("acc_cmd: %d aac_id: %d acc_busy: %d acc_nstat: %d ",
! 2540: mbox->acc_cmd, mbox->acc_id, mbox->acc_busy, mbox->acc_nstat);
! 2541: printf("acc_status: %d acc_poll: %d acc_ack: %d\n",
! 2542: mbox->acc_status, mbox->acc_poll, mbox->acc_ack);
! 2543:
! 2544: printf("acc_cmplidl: ");
! 2545: for (i = 0; i < AMI_MAXSTATACK; i++) {
! 2546: printf("[%d] = %d ", i, mbox->acc_cmplidl[i]);
! 2547: }
! 2548:
! 2549: printf("\n");
! 2550: }
! 2551: #endif /* AMI_DEBUG */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ami.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic