Annotation of sys/dev/i2o/iopsp.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: iopsp.c,v 1.9 2006/11/28 23:59:45 dlg Exp $ */
! 2: /* $NetBSD$ */
! 3:
! 4: /*-
! 5: * Copyright (c) 2000, 2001 The NetBSD Foundation, Inc.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to The NetBSD Foundation
! 9: * by Andrew Doran.
! 10: *
! 11: * Redistribution and use in source and binary forms, with or without
! 12: * modification, are permitted provided that the following conditions
! 13: * are met:
! 14: * 1. Redistributions of source code must retain the above copyright
! 15: * notice, this list of conditions and the following disclaimer.
! 16: * 2. Redistributions in binary form must reproduce the above copyright
! 17: * notice, this list of conditions and the following disclaimer in the
! 18: * documentation and/or other materials provided with the distribution.
! 19: * 3. All advertising materials mentioning features or use of this software
! 20: * must display the following acknowledgement:
! 21: * This product includes software developed by the NetBSD
! 22: * Foundation, Inc. and its contributors.
! 23: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 24: * contributors may be used to endorse or promote products derived
! 25: * from this software without specific prior written permission.
! 26: *
! 27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 37: * POSSIBILITY OF SUCH DAMAGE.
! 38: */
! 39:
! 40: /*
! 41: * Raw SCSI device support for I2O. IOPs present SCSI devices individually;
! 42: * we group them by controlling port.
! 43: */
! 44:
! 45: #include <sys/param.h>
! 46: #include <sys/systm.h>
! 47: #include <sys/kernel.h>
! 48: #include <sys/device.h>
! 49: #include <sys/queue.h>
! 50: #include <sys/proc.h>
! 51: #include <sys/buf.h>
! 52: #include <sys/endian.h>
! 53: #include <sys/malloc.h>
! 54: #include <sys/scsiio.h>
! 55: #include <sys/lock.h>
! 56:
! 57: #include <machine/bus.h>
! 58:
! 59: #include <scsi/scsi_all.h>
! 60: #include <scsi/scsi_disk.h>
! 61: #include <scsi/scsi_all.h>
! 62: #include <scsi/scsiconf.h>
! 63: #include <scsi/scsi_message.h>
! 64:
! 65: #include <dev/i2o/i2o.h>
! 66: #include <dev/i2o/iopio.h>
! 67: #include <dev/i2o/iopvar.h>
! 68: #include <dev/i2o/iopspvar.h>
! 69:
! 70: struct cfdriver iopsp_cd = {
! 71: NULL, "iopsp", DV_DULL
! 72: };
! 73:
! 74: int iopsp_match(struct device *, void *, void *);
! 75: void iopsp_attach(struct device *, struct device *, void *);
! 76:
! 77: struct cfattach iopsp_ca = {
! 78: sizeof(struct iopsp_softc), iopsp_match, iopsp_attach
! 79: };
! 80:
! 81: int iopsp_scsi_cmd(struct scsi_xfer *);
! 82: void iopspminphys(struct buf *bp);
! 83:
! 84: struct scsi_adapter iopsp_switch = {
! 85: iopsp_scsi_cmd, iopspminphys, 0, 0,
! 86: };
! 87:
! 88: struct scsi_device iopsp_dev = {
! 89: NULL, NULL, NULL, NULL
! 90: };
! 91:
! 92: void iopsp_adjqparam(struct device *, int);
! 93: void iopsp_intr(struct device *, struct iop_msg *, void *);
! 94: int iopsp_rescan(struct iopsp_softc *);
! 95: int iopsp_reconfig(struct device *);
! 96:
! 97: /*
! 98: * Match a supported device.
! 99: */
! 100: int
! 101: iopsp_match(struct device *parent, void *match, void *aux)
! 102: {
! 103: struct iop_attach_args *ia = aux;
! 104: struct {
! 105: struct i2o_param_op_results pr;
! 106: struct i2o_param_read_results prr;
! 107: struct i2o_param_hba_ctlr_info ci;
! 108: } __attribute__ ((__packed__)) param;
! 109: int rv;
! 110:
! 111: if (ia->ia_class != I2O_CLASS_BUS_ADAPTER_PORT)
! 112: return (0);
! 113:
! 114: if ((rv = iop_param_op((struct iop_softc *)parent, ia->ia_tid, NULL, 0,
! 115: I2O_PARAM_HBA_CTLR_INFO, ¶m, sizeof(param)))) {
! 116: #ifdef I2ODEBUG
! 117: printf("iopsp_match: iop_param_op failed, status = %d\n", rv);
! 118: #endif
! 119: return (0);
! 120: }
! 121:
! 122: #ifdef I2ODEBUG
! 123: printf("iopsp_match: bustype = %d\n", param.ci.bustype);
! 124: #endif
! 125:
! 126: return (param.ci.bustype == I2O_HBA_BUS_SCSI ||
! 127: param.ci.bustype == I2O_HBA_BUS_FCA);
! 128: }
! 129:
! 130: /*
! 131: * Attach a supported device.
! 132: */
! 133: void
! 134: iopsp_attach(struct device *parent, struct device *self, void *aux)
! 135: {
! 136: struct iop_softc *iop = (struct iop_softc *)parent;
! 137: struct iopsp_softc *sc = (struct iopsp_softc *)self;
! 138: struct iop_attach_args *ia = (struct iop_attach_args *)aux;
! 139: struct scsibus_attach_args saa;
! 140: struct {
! 141: struct i2o_param_op_results pr;
! 142: struct i2o_param_read_results prr;
! 143: union {
! 144: struct i2o_param_hba_ctlr_info ci;
! 145: struct i2o_param_hba_scsi_ctlr_info sci;
! 146: struct i2o_param_hba_scsi_port_info spi;
! 147: } p;
! 148: } __attribute__ ((__packed__)) param;
! 149: int fcal, rv;
! 150: #ifdef I2OVERBOSE
! 151: int size;
! 152: #endif
! 153:
! 154: /* Register us as an initiator. */
! 155: sc->sc_ii.ii_dv = self;
! 156: sc->sc_ii.ii_intr = iopsp_intr;
! 157: sc->sc_ii.ii_flags = 0;
! 158: sc->sc_ii.ii_tid = ia->ia_tid;
! 159: sc->sc_ii.ii_reconfig = iopsp_reconfig;
! 160: sc->sc_ii.ii_adjqparam = iopsp_adjqparam;
! 161: iop_initiator_register(iop, &sc->sc_ii);
! 162:
! 163: rv = iop_param_op(iop, ia->ia_tid, NULL, 0, I2O_PARAM_HBA_CTLR_INFO,
! 164: ¶m, sizeof(param));
! 165: if (rv != 0) {
! 166: printf("%s: unable to get parameters (0x%04x; %d)\n",
! 167: sc->sc_dv.dv_xname, I2O_PARAM_HBA_CTLR_INFO, rv);
! 168: goto bad;
! 169: }
! 170:
! 171: fcal = (param.p.ci.bustype == I2O_HBA_BUS_FCA); /* XXX */
! 172:
! 173: /*
! 174: * Say what the device is. If we can find out what the controling
! 175: * device is, say what that is too.
! 176: */
! 177: printf(": SCSI port");
! 178: iop_print_ident(iop, ia->ia_tid);
! 179: printf("\n");
! 180:
! 181: rv = iop_param_op(iop, ia->ia_tid, NULL, 0,
! 182: I2O_PARAM_HBA_SCSI_CTLR_INFO, ¶m, sizeof(param));
! 183: if (rv != 0) {
! 184: printf("%s: unable to get parameters (0x%04x; %d)\n",
! 185: sc->sc_dv.dv_xname, I2O_PARAM_HBA_SCSI_CTLR_INFO, rv);
! 186: goto bad;
! 187: }
! 188:
! 189: #ifdef I2OVERBOSE
! 190: printf("%s: %d-bit, max sync rate %dMHz, initiator ID %d\n",
! 191: sc->sc_dv.dv_xname, param.p.sci.maxdatawidth,
! 192: (u_int32_t)letoh64(param.p.sci.maxsyncrate) / 1000,
! 193: letoh32(param.p.sci.initiatorid));
! 194: #endif
! 195:
! 196: sc->sc_link.adapter_softc = sc;
! 197: sc->sc_link.adapter = &iopsp_switch;
! 198: sc->sc_link.adapter_target = letoh32(param.p.sci.initiatorid);
! 199: sc->sc_link.device = &iopsp_dev;
! 200: sc->sc_link.openings = 1;
! 201: sc->sc_link.adapter_buswidth = fcal?
! 202: IOPSP_MAX_FCAL_TARGET : param.p.sci.maxdatawidth;
! 203: sc->sc_link.luns = IOPSP_MAX_LUN;
! 204:
! 205: #ifdef I2OVERBOSE
! 206: /*
! 207: * Allocate the target map. Currently used for informational
! 208: * purposes only.
! 209: */
! 210: size = sc->sc_link.adapter_buswidth * sizeof(struct iopsp_target);
! 211: sc->sc_targetmap = malloc(size, M_DEVBUF, M_NOWAIT);
! 212: bzero(sc->sc_targetmap, size);
! 213: #endif
! 214:
! 215: /* Build the two maps, and attach to scsi. */
! 216: if (iopsp_reconfig(self) != 0) {
! 217: printf("%s: configure failed\n", sc->sc_dv.dv_xname);
! 218: goto bad;
! 219: }
! 220:
! 221: bzero(&saa, sizeof(saa));
! 222: saa.saa_sc_link = &sc->sc_link;
! 223:
! 224: config_found(&sc->sc_dv, &saa, scsiprint);
! 225: return;
! 226:
! 227: bad:
! 228: iop_initiator_unregister(iop, &sc->sc_ii);
! 229: }
! 230:
! 231: /*
! 232: * Scan the LCT to determine which devices we control, and enter them into
! 233: * the maps.
! 234: */
! 235: int
! 236: iopsp_reconfig(struct device *dv)
! 237: {
! 238: struct iopsp_softc *sc = (struct iopsp_softc *)dv;
! 239: struct iop_softc *iop = (struct iop_softc *)sc->sc_dv.dv_parent;
! 240: struct i2o_lct_entry *le;
! 241: struct {
! 242: struct i2o_param_op_results pr;
! 243: struct i2o_param_read_results prr;
! 244: struct i2o_param_scsi_device_info sdi;
! 245: } __attribute__ ((__packed__)) param;
! 246: u_int tid, nent, i, targ, lun, size, s, rv, bptid;
! 247: u_short *tidmap;
! 248: #ifdef I2OVERBOSE
! 249: struct iopsp_target *it;
! 250: int syncrate;
! 251: #endif
! 252:
! 253: /* Anything to do? */
! 254: if (iop->sc_chgind == sc->sc_chgind)
! 255: return (0);
! 256:
! 257: /*
! 258: * Allocate memory for the target/LUN -> TID map. Use zero to
! 259: * denote absent targets (zero is the TID of the I2O executive,
! 260: * and we never address that here).
! 261: */
! 262: size = sc->sc_link.adapter_buswidth * IOPSP_MAX_LUN * sizeof(u_short);
! 263: if (!(tidmap = malloc(size, M_DEVBUF, M_NOWAIT)))
! 264: return (ENOMEM);
! 265: bzero(tidmap, size);
! 266:
! 267: #ifdef I2OVERBOSE
! 268: for (i = 0; i < sc->sc_link.adapter_buswidth; i++)
! 269: sc->sc_targetmap[i].it_flags &= ~IT_PRESENT;
! 270: #endif
! 271:
! 272: /*
! 273: * A quick hack to handle Intel's stacked bus port arrangement.
! 274: */
! 275: bptid = sc->sc_ii.ii_tid;
! 276: nent = iop->sc_nlctent;
! 277: for (le = iop->sc_lct->entry; nent != 0; nent--, le++)
! 278: if ((letoh16(le->classid) & 4095) ==
! 279: I2O_CLASS_BUS_ADAPTER_PORT &&
! 280: (letoh32(le->usertid) & 4095) == bptid) {
! 281: bptid = letoh16(le->localtid) & 4095;
! 282: break;
! 283: }
! 284:
! 285: nent = iop->sc_nlctent;
! 286: for (i = 0, le = iop->sc_lct->entry; i < nent; i++, le++) {
! 287: if ((letoh16(le->classid) & I2O_CLASS_MASK) !=
! 288: I2O_CLASS_SCSI_PERIPHERAL ||
! 289: ((letoh32(le->usertid) >> 12) & 4095) != bptid)
! 290: continue;
! 291: tid = letoh16(le->localtid) & I2O_LCT_ENTRY_TID_MASK;
! 292:
! 293: rv = iop_param_op(iop, tid, NULL, 0, I2O_PARAM_SCSI_DEVICE_INFO,
! 294: ¶m, sizeof(param));
! 295: if (rv != 0) {
! 296: printf("%s: unable to get parameters (0x%04x; %d)\n",
! 297: sc->sc_dv.dv_xname, I2O_PARAM_SCSI_DEVICE_INFO,
! 298: rv);
! 299: continue;
! 300: }
! 301: targ = letoh32(param.sdi.identifier);
! 302: lun = param.sdi.luninfo[1];
! 303: #if defined(DIAGNOSTIC) || defined(I2ODEBUG)
! 304: if (targ >= sc->sc_link.adapter_buswidth ||
! 305: lun >= sc->sc_link.adapter_buswidth) {
! 306: printf("%s: target %d,%d (tid %d): bad target/LUN\n",
! 307: sc->sc_dv.dv_xname, targ, lun, tid);
! 308: continue;
! 309: }
! 310: #endif
! 311:
! 312: #ifdef I2OVERBOSE
! 313: /*
! 314: * If we've already described this target, and nothing has
! 315: * changed, then don't describe it again.
! 316: */
! 317: it = &sc->sc_targetmap[targ];
! 318: it->it_flags |= IT_PRESENT;
! 319: syncrate = (int)((letoh64(param.sdi.negsyncrate) + 500) / 1000);
! 320: if (it->it_width == param.sdi.negdatawidth &&
! 321: it->it_offset == param.sdi.negoffset &&
! 322: it->it_syncrate == syncrate)
! 323: continue;
! 324:
! 325: it->it_width = param.sdi.negdatawidth;
! 326: it->it_offset = param.sdi.negoffset;
! 327: it->it_syncrate = syncrate;
! 328:
! 329: printf("%s: target %d (tid %d): %d-bit, ", sc->sc_dv.dv_xname,
! 330: targ, tid, it->it_width);
! 331: if (it->it_syncrate == 0)
! 332: printf("asynchronous\n");
! 333: else
! 334: printf("synchronous at %dMHz, offset 0x%x\n",
! 335: it->it_syncrate, it->it_offset);
! 336: #endif
! 337:
! 338: /* Ignore the device if it's in use by somebody else. */
! 339: if ((letoh32(le->usertid) & 4095) != I2O_TID_NONE) {
! 340: #ifdef I2OVERBOSE
! 341: if (sc->sc_tidmap == NULL ||
! 342: IOPSP_TIDMAP(sc->sc_tidmap, targ, lun) !=
! 343: IOPSP_TID_INUSE)
! 344: printf("%s: target %d,%d (tid %d): in use by"
! 345: " tid %d\n", sc->sc_dv.dv_xname,
! 346: targ, lun, tid,
! 347: letoh32(le->usertid) & 4095);
! 348: #endif
! 349: IOPSP_TIDMAP(tidmap, targ, lun) = IOPSP_TID_INUSE;
! 350: } else
! 351: IOPSP_TIDMAP(tidmap, targ, lun) = (u_short)tid;
! 352: }
! 353:
! 354: #ifdef I2OVERBOSE
! 355: for (i = 0; i < sc->sc_link.adapter_buswidth; i++)
! 356: if ((sc->sc_targetmap[i].it_flags & IT_PRESENT) == 0)
! 357: sc->sc_targetmap[i].it_width = 0;
! 358: #endif
! 359:
! 360: /* Swap in the new map and return. */
! 361: s = splbio();
! 362: if (sc->sc_tidmap != NULL)
! 363: free(sc->sc_tidmap, M_DEVBUF);
! 364: sc->sc_tidmap = tidmap;
! 365: splx(s);
! 366: sc->sc_chgind = iop->sc_chgind;
! 367: return (0);
! 368: }
! 369:
! 370: /*
! 371: * Re-scan the bus; to be called from a higher level (e.g. scsi).
! 372: */
! 373: int
! 374: iopsp_rescan(struct iopsp_softc *sc)
! 375: {
! 376: struct iop_softc *iop;
! 377: struct iop_msg *im;
! 378: struct i2o_hba_bus_scan mf;
! 379: int rv;
! 380:
! 381: iop = (struct iop_softc *)sc->sc_dv.dv_parent;
! 382:
! 383: rv = lockmgr(&iop->sc_conflock, LK_EXCLUSIVE, NULL);
! 384: if (rv != 0) {
! 385: #ifdef I2ODEBUG
! 386: printf("iopsp_rescan: unable to acquire lock\n");
! 387: #endif
! 388: return (rv);
! 389: }
! 390:
! 391: im = iop_msg_alloc(iop, &sc->sc_ii, IM_WAIT);
! 392:
! 393: mf.msgflags = I2O_MSGFLAGS(i2o_hba_bus_scan);
! 394: mf.msgfunc = I2O_MSGFUNC(sc->sc_ii.ii_tid, I2O_HBA_BUS_SCAN);
! 395: mf.msgictx = sc->sc_ii.ii_ictx;
! 396: mf.msgtctx = im->im_tctx;
! 397:
! 398: rv = iop_msg_post(iop, im, &mf, 5*60*1000);
! 399: iop_msg_free(iop, im);
! 400: if (rv != 0)
! 401: printf("%s: bus rescan failed (error %d)\n",
! 402: sc->sc_dv.dv_xname, rv);
! 403:
! 404: if ((rv = iop_lct_get(iop)) == 0)
! 405: rv = iopsp_reconfig(&sc->sc_dv);
! 406:
! 407: lockmgr(&iop->sc_conflock, LK_RELEASE, NULL);
! 408: return (rv);
! 409: }
! 410:
! 411: void
! 412: iopspminphys(bp)
! 413: struct buf *bp;
! 414: {
! 415: if (bp->b_bcount > IOP_MAX_XFER)
! 416: bp->b_bcount = IOP_MAX_XFER;
! 417: minphys(bp);
! 418: }
! 419:
! 420: /*
! 421: * Start a SCSI command.
! 422: */
! 423: int
! 424: iopsp_scsi_cmd(xs)
! 425: struct scsi_xfer *xs;
! 426: {
! 427: struct scsi_link *link = xs->sc_link;
! 428: struct iopsp_softc *sc = (struct iopsp_softc *)link->adapter_softc;
! 429: struct iop_softc *iop = (struct iop_softc *)sc->sc_dv.dv_parent;
! 430: struct iop_msg *im;
! 431: struct i2o_scsi_scb_exec *mf;
! 432: int error, tid, s;
! 433: u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
! 434:
! 435: tid = IOPSP_TIDMAP(sc->sc_tidmap, link->target, link->lun);
! 436: if (tid == IOPSP_TID_ABSENT || tid == IOPSP_TID_INUSE) {
! 437: xs->error = XS_SELTIMEOUT;
! 438: scsi_done(xs);
! 439: return (COMPLETE);
! 440: }
! 441:
! 442: SC_DEBUG(xs->sc_link, SDEV_DB2, ("iopsp_scsi_cmd: run_xfer\n"));
! 443:
! 444: /* Need to reset the target? */
! 445: if ((xs->flags & XS_RESET) != 0) {
! 446: if (iop_simple_cmd(iop, tid, I2O_SCSI_DEVICE_RESET,
! 447: sc->sc_ii.ii_ictx, 1, 30*1000) != 0) {
! 448: #ifdef I2ODEBUG
! 449: printf("%s: reset failed\n",
! 450: sc->sc_dv.dv_xname);
! 451: #endif
! 452: xs->error = XS_DRIVER_STUFFUP;
! 453: } else
! 454: xs->error = XS_NOERROR;
! 455:
! 456: scsi_done(xs);
! 457: return (COMPLETE);
! 458: }
! 459:
! 460: #if defined(I2ODEBUG) || defined(SCSIDEBUG)
! 461: if (xs->cmdlen > sizeof(mf->cdb))
! 462: panic("%s: CDB too large", sc->sc_dv.dv_xname);
! 463: #endif
! 464:
! 465: im = iop_msg_alloc(iop, &sc->sc_ii, IM_POLL_INTR |
! 466: IM_NOSTATUS | ((xs->flags & SCSI_POLL) != 0 ? IM_POLL : 0));
! 467: im->im_dvcontext = xs;
! 468:
! 469: mf = (struct i2o_scsi_scb_exec *)mb;
! 470: mf->msgflags = I2O_MSGFLAGS(i2o_scsi_scb_exec);
! 471: mf->msgfunc = I2O_MSGFUNC(tid, I2O_SCSI_SCB_EXEC);
! 472: mf->msgictx = sc->sc_ii.ii_ictx;
! 473: mf->msgtctx = im->im_tctx;
! 474: mf->flags = xs->cmdlen | I2O_SCB_FLAG_ENABLE_DISCONNECT |
! 475: I2O_SCB_FLAG_SENSE_DATA_IN_MESSAGE;
! 476: mf->datalen = xs->datalen;
! 477: memcpy(mf->cdb, xs->cmd, xs->cmdlen);
! 478:
! 479: #if 0
! 480: switch (xs->xs_tag_type) {
! 481: case MSG_ORDERED_Q_TAG:
! 482: mf->flags |= I2O_SCB_FLAG_ORDERED_QUEUE_TAG;
! 483: break;
! 484: case MSG_SIMPLE_Q_TAG:
! 485: mf->flags |= I2O_SCB_FLAG_SIMPLE_QUEUE_TAG;
! 486: break;
! 487: case MSG_HEAD_OF_Q_TAG:
! 488: mf->flags |= I2O_SCB_FLAG_HEAD_QUEUE_TAG;
! 489: break;
! 490: default:
! 491: break;
! 492: }
! 493: #endif
! 494:
! 495: if (xs->datalen != 0) {
! 496: error = iop_msg_map_bio(iop, im, mb, xs->data,
! 497: xs->datalen, (xs->flags & SCSI_DATA_OUT) == 0);
! 498: if (error) {
! 499: xs->error = XS_DRIVER_STUFFUP;
! 500: iop_msg_free(iop, im);
! 501: scsi_done(xs);
! 502: return (COMPLETE);
! 503: }
! 504: if ((xs->flags & SCSI_DATA_IN) == 0)
! 505: mf->flags |= I2O_SCB_FLAG_XFER_TO_DEVICE;
! 506: else
! 507: mf->flags |= I2O_SCB_FLAG_XFER_FROM_DEVICE;
! 508: }
! 509:
! 510: s = splbio();
! 511: sc->sc_curqd++;
! 512: splx(s);
! 513:
! 514: if (iop_msg_post(iop, im, mb, xs->timeout)) {
! 515: s = splbio();
! 516: sc->sc_curqd--;
! 517: splx(s);
! 518: if (xs->datalen != 0)
! 519: iop_msg_unmap(iop, im);
! 520: iop_msg_free(iop, im);
! 521: xs->error = XS_DRIVER_STUFFUP;
! 522: scsi_done(xs);
! 523: return (COMPLETE);
! 524: }
! 525:
! 526: return (xs->flags & SCSI_POLL? COMPLETE : SUCCESSFULLY_QUEUED);
! 527: }
! 528:
! 529: #ifdef notyet
! 530: /*
! 531: * Abort the specified I2O_SCSI_SCB_EXEC message and its associated SCB.
! 532: */
! 533: int
! 534: iopsp_scsi_abort(struct iopsp_softc *sc, int atid, struct iop_msg *aim)
! 535: {
! 536: struct iop_msg *im;
! 537: struct i2o_scsi_scb_abort mf;
! 538: struct iop_softc *iop;
! 539: int rv, s;
! 540:
! 541: iop = (struct iop_softc *)sc->sc_dv.dv_parent;
! 542: im = iop_msg_alloc(iop, &sc->sc_ii, IM_POLL);
! 543:
! 544: mf.msgflags = I2O_MSGFLAGS(i2o_scsi_scb_abort);
! 545: mf.msgfunc = I2O_MSGFUNC(atid, I2O_SCSI_SCB_ABORT);
! 546: mf.msgictx = sc->sc_ii.ii_ictx;
! 547: mf.msgtctx = im->im_tctx;
! 548: mf.tctxabort = aim->im_tctx;
! 549:
! 550: s = splbio();
! 551: rv = iop_msg_post(iop, im, &mf, 30000);
! 552: splx(s);
! 553: iop_msg_free(iop, im);
! 554: return (rv);
! 555: }
! 556: #endif
! 557:
! 558: /*
! 559: * We have a message which has been processed and replied to by the IOP -
! 560: * deal with it.
! 561: */
! 562: void
! 563: iopsp_intr(struct device *dv, struct iop_msg *im, void *reply)
! 564: {
! 565: struct scsi_xfer *xs;
! 566: struct iopsp_softc *sc;
! 567: struct i2o_scsi_reply *rb;
! 568: struct iop_softc *iop;
! 569: u_int sl;
! 570:
! 571: sc = (struct iopsp_softc *)dv;
! 572: xs = (struct scsi_xfer *)im->im_dvcontext;
! 573: iop = (struct iop_softc *)dv->dv_parent;
! 574: rb = reply;
! 575:
! 576: SC_DEBUG(xs->sc_link, SDEV_DB2, ("iopsp_intr\n"));
! 577:
! 578: if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0) {
! 579: xs->error = XS_DRIVER_STUFFUP;
! 580: xs->resid = xs->datalen;
! 581: } else {
! 582: if (rb->hbastatus != I2O_SCSI_DSC_SUCCESS) {
! 583: switch (rb->hbastatus) {
! 584: case I2O_SCSI_DSC_ADAPTER_BUSY:
! 585: case I2O_SCSI_DSC_SCSI_BUS_RESET:
! 586: case I2O_SCSI_DSC_BUS_BUSY:
! 587: xs->error = XS_BUSY;
! 588: break;
! 589: case I2O_SCSI_DSC_SELECTION_TIMEOUT:
! 590: xs->error = XS_SELTIMEOUT;
! 591: break;
! 592: case I2O_SCSI_DSC_COMMAND_TIMEOUT:
! 593: case I2O_SCSI_DSC_DEVICE_NOT_PRESENT:
! 594: case I2O_SCSI_DSC_LUN_INVALID:
! 595: case I2O_SCSI_DSC_SCSI_TID_INVALID:
! 596: xs->error = XS_TIMEOUT;
! 597: break;
! 598: default:
! 599: xs->error = XS_DRIVER_STUFFUP;
! 600: break;
! 601: }
! 602: printf("%s: HBA status 0x%02x\n", sc->sc_dv.dv_xname,
! 603: rb->hbastatus);
! 604: } else if (rb->scsistatus != SCSI_OK) {
! 605: switch (rb->scsistatus) {
! 606: case SCSI_CHECK:
! 607: xs->error = XS_SENSE;
! 608: sl = letoh32(rb->senselen);
! 609: if (sl > sizeof(xs->sense))
! 610: sl = sizeof(xs->sense);
! 611: bcopy(rb->sense, &xs->sense, sl);
! 612: break;
! 613: case SCSI_QUEUE_FULL:
! 614: case SCSI_BUSY:
! 615: xs->error = XS_BUSY;
! 616: break;
! 617: default:
! 618: xs->error = XS_DRIVER_STUFFUP;
! 619: break;
! 620: }
! 621: } else
! 622: xs->error = XS_NOERROR;
! 623:
! 624: xs->resid = xs->datalen - letoh32(rb->datalen);
! 625: xs->status = rb->scsistatus;
! 626: }
! 627:
! 628: /* Free the message wrapper and pass the news to scsi. */
! 629: if (xs->datalen != 0)
! 630: iop_msg_unmap(iop, im);
! 631: iop_msg_free(iop, im);
! 632:
! 633: if (--sc->sc_curqd == sc->sc_link.openings)
! 634: wakeup(&sc->sc_curqd);
! 635:
! 636: scsi_done(xs);
! 637: }
! 638:
! 639: /*
! 640: * The number of openings available to us has changed, so inform scsi.
! 641: */
! 642: void
! 643: iopsp_adjqparam(struct device *dv, int mpi)
! 644: {
! 645: struct iopsp_softc *sc = (struct iopsp_softc *)dv;
! 646: int s;
! 647:
! 648: s = splbio();
! 649: sc->sc_link.openings = mpi;
! 650: if (mpi < sc->sc_curqd)
! 651: tsleep(&sc->sc_curqd, PWAIT, "iopspdrn", 0);
! 652: splx(s);
! 653: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to iopsp.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / i2o