Annotation of sys/arch/vax/mscp/mscp_subr.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: mscp_subr.c,v 1.9 2005/11/24 04:54:49 brad Exp $ */
! 2: /* $NetBSD: mscp_subr.c,v 1.18 2001/11/13 07:38:28 lukem Exp $ */
! 3: /*
! 4: * Copyright (c) 1996 Ludd, University of Lule}, Sweden.
! 5: * Copyright (c) 1988 Regents of the University of California.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to Berkeley by
! 9: * Chris Torek.
! 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. Neither the name of the University nor the names of its contributors
! 20: * may be used to endorse or promote products derived from this software
! 21: * without specific prior written permission.
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 26: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 33: * SUCH DAMAGE.
! 34: *
! 35: * @(#)mscp.c 7.5 (Berkeley) 12/16/90
! 36: */
! 37:
! 38: /*
! 39: * MSCP generic driver routines
! 40: */
! 41:
! 42: #include <sys/cdefs.h>
! 43:
! 44: #include <sys/param.h>
! 45: #include <sys/device.h>
! 46: #include <sys/buf.h>
! 47: #include <sys/systm.h>
! 48: #include <sys/proc.h>
! 49:
! 50: #include <machine/bus.h>
! 51: #include <machine/sid.h>
! 52:
! 53: #include <arch/vax/mscp/mscp.h>
! 54: #include <arch/vax/mscp/mscpreg.h>
! 55: #include <arch/vax/mscp/mscpvar.h>
! 56:
! 57: #include "ra.h"
! 58: #include "mt.h"
! 59:
! 60: #define b_forw b_hash.le_next
! 61:
! 62: int mscp_match(struct device *, struct cfdata *, void *);
! 63: void mscp_attach(struct device *, struct device *, void *);
! 64: void mscp_start(struct mscp_softc *);
! 65: int mscp_init(struct mscp_softc *);
! 66: void mscp_initds(struct mscp_softc *);
! 67: int mscp_waitstep(struct mscp_softc *, int, int);
! 68:
! 69: struct cfattach mscpbus_ca = {
! 70: sizeof(struct mscp_softc), (cfmatch_t)mscp_match, mscp_attach
! 71: };
! 72:
! 73: struct cfdriver mscpbus_cd = {
! 74: NULL, "mscpbus", DV_DULL
! 75: };
! 76:
! 77: #define READ_SA (bus_space_read_2(mi->mi_iot, mi->mi_sah, 0))
! 78: #define READ_IP (bus_space_read_2(mi->mi_iot, mi->mi_iph, 0))
! 79: #define WRITE_IP(x) bus_space_write_2(mi->mi_iot, mi->mi_iph, 0, (x))
! 80: #define WRITE_SW(x) bus_space_write_2(mi->mi_iot, mi->mi_swh, 0, (x))
! 81:
! 82: struct mscp slavereply;
! 83:
! 84: /*
! 85: * This function is for delay during init. Some MSCP clone card (Dilog)
! 86: * can't handle fast read from its registers, and therefore need
! 87: * a delay between them.
! 88: */
! 89:
! 90: #define DELAYTEN 1000
! 91: int
! 92: mscp_waitstep(mi, mask, result)
! 93: struct mscp_softc *mi;
! 94: int mask, result;
! 95: {
! 96: int status = 1;
! 97:
! 98: if ((READ_SA & mask) != result) {
! 99: volatile int count = 0;
! 100: while ((READ_SA & mask) != result) {
! 101: DELAY(10000);
! 102: count += 1;
! 103: if (count > DELAYTEN)
! 104: break;
! 105: }
! 106: if (count > DELAYTEN)
! 107: status = 0;
! 108: }
! 109: return status;
! 110: }
! 111:
! 112: int
! 113: mscp_match(parent, match, aux)
! 114: struct device *parent;
! 115: struct cfdata *match;
! 116: void *aux;
! 117: {
! 118: struct mscp_attach_args *ma = aux;
! 119:
! 120: #if NRA || NRX
! 121: if (ma->ma_type & MSCPBUS_DISK)
! 122: return 1;
! 123: #endif
! 124: #if NMT
! 125: if (ma->ma_type & MSCPBUS_TAPE)
! 126: return 1;
! 127: #endif
! 128: return 0;
! 129: };
! 130:
! 131: void
! 132: mscp_attach(parent, self, aux)
! 133: struct device *parent, *self;
! 134: void *aux;
! 135: {
! 136: struct mscp_attach_args *ma = aux;
! 137: struct mscp_softc *mi = (void *)self;
! 138: volatile struct mscp *mp;
! 139: volatile int i;
! 140: int timeout, next = 0;
! 141:
! 142: mi->mi_mc = ma->ma_mc;
! 143: mi->mi_me = NULL;
! 144: mi->mi_type = ma->ma_type;
! 145: mi->mi_uda = ma->ma_uda;
! 146: mi->mi_dmat = ma->ma_dmat;
! 147: mi->mi_dmam = ma->ma_dmam;
! 148: mi->mi_iot = ma->ma_iot;
! 149: mi->mi_iph = ma->ma_iph;
! 150: mi->mi_sah = ma->ma_sah;
! 151: mi->mi_swh = ma->ma_swh;
! 152: mi->mi_ivec = ma->ma_ivec;
! 153: mi->mi_adapnr = ma->ma_adapnr;
! 154: mi->mi_ctlrnr = ma->ma_ctlrnr;
! 155: *ma->ma_softc = mi;
! 156: /*
! 157: * Go out to init the bus, so that we can give commands
! 158: * to its devices.
! 159: */
! 160: mi->mi_cmd.mri_size = NCMD;
! 161: mi->mi_cmd.mri_desc = mi->mi_uda->mp_ca.ca_cmddsc;
! 162: mi->mi_cmd.mri_ring = mi->mi_uda->mp_cmd;
! 163: mi->mi_rsp.mri_size = NRSP;
! 164: mi->mi_rsp.mri_desc = mi->mi_uda->mp_ca.ca_rspdsc;
! 165: mi->mi_rsp.mri_ring = mi->mi_uda->mp_rsp;
! 166: SIMPLEQ_INIT(&mi->mi_resq);
! 167:
! 168: if (mscp_init(mi)) {
! 169: printf("%s: can't init, controller hung\n",
! 170: mi->mi_dev.dv_xname);
! 171: return;
! 172: }
! 173: for (i = 0; i < NCMD; i++) {
! 174: mi->mi_mxiuse |= (1 << i);
! 175: if (bus_dmamap_create(mi->mi_dmat, (64*1024), 16, (64*1024),
! 176: 0, BUS_DMA_NOWAIT, &mi->mi_xi[i].mxi_dmam)) {
! 177: printf("Couldn't alloc dmamap %d\n", i);
! 178: return;
! 179: }
! 180: }
! 181:
! 182:
! 183: #if NRA
! 184: if (ma->ma_type & MSCPBUS_DISK) {
! 185: extern struct mscp_device ra_device;
! 186:
! 187: mi->mi_me = &ra_device;
! 188: }
! 189: #endif
! 190: #if NMT
! 191: if (ma->ma_type & MSCPBUS_TAPE) {
! 192: extern struct mscp_device mt_device;
! 193:
! 194: mi->mi_me = &mt_device;
! 195: }
! 196: #endif
! 197: /*
! 198: * Go out and search for sub-units on this MSCP bus,
! 199: * and call config_found for each found.
! 200: */
! 201: findunit:
! 202: mp = mscp_getcp(mi, MSCP_DONTWAIT);
! 203: if (mp == NULL)
! 204: panic("mscpattach: no packets");
! 205: mp->mscp_opcode = M_OP_GETUNITST;
! 206: mp->mscp_unit = next;
! 207: mp->mscp_modifier = M_GUM_NEXTUNIT;
! 208: *mp->mscp_addr |= MSCP_OWN | MSCP_INT;
! 209: slavereply.mscp_opcode = 0;
! 210:
! 211: i = bus_space_read_2(mi->mi_iot, mi->mi_iph, 0);
! 212: mp = &slavereply;
! 213: timeout = 1000;
! 214: while (timeout-- > 0) {
! 215: DELAY(10000);
! 216: if (mp->mscp_opcode)
! 217: goto gotit;
! 218: }
! 219: printf("%s: no response to Get Unit Status request\n",
! 220: mi->mi_dev.dv_xname);
! 221: return;
! 222:
! 223: gotit: /*
! 224: * Got a slave response. If the unit is there, use it.
! 225: */
! 226: switch (mp->mscp_status & M_ST_MASK) {
! 227:
! 228: case M_ST_SUCCESS: /* worked */
! 229: case M_ST_AVAILABLE: /* found another drive */
! 230: break; /* use it */
! 231:
! 232: case M_ST_OFFLINE:
! 233: /*
! 234: * Figure out why it is off line. It may be because
! 235: * it is nonexistent, or because it is spun down, or
! 236: * for some other reason.
! 237: */
! 238: switch (mp->mscp_status & ~M_ST_MASK) {
! 239:
! 240: case M_OFFLINE_UNKNOWN:
! 241: /*
! 242: * No such drive, and there are none with
! 243: * higher unit numbers either, if we are
! 244: * using M_GUM_NEXTUNIT.
! 245: */
! 246: mi->mi_ierr = 3;
! 247: return;
! 248:
! 249: case M_OFFLINE_UNMOUNTED:
! 250: /*
! 251: * The drive is not spun up. Use it anyway.
! 252: *
! 253: * N.B.: this seems to be a common occurrance
! 254: * after a power failure. The first attempt
! 255: * to bring it on line seems to spin it up
! 256: * (and thus takes several minutes). Perhaps
! 257: * we should note here that the on-line may
! 258: * take longer than usual.
! 259: */
! 260: break;
! 261:
! 262: default:
! 263: /*
! 264: * In service, or something else equally unusable.
! 265: */
! 266: printf("%s: unit %d off line: ", mi->mi_dev.dv_xname,
! 267: mp->mscp_unit);
! 268: mscp_printevent((struct mscp *)mp);
! 269: next++;
! 270: goto findunit;
! 271: }
! 272: break;
! 273:
! 274: default:
! 275: printf("%s: unable to get unit status: ", mi->mi_dev.dv_xname);
! 276: mscp_printevent((struct mscp *)mp);
! 277: return;
! 278: }
! 279:
! 280: /*
! 281: * If we get a lower number, we have circulated around all
! 282: * devices and are finished, otherwise try to find next unit.
! 283: * We shouldn't ever get this, it's a workaround.
! 284: */
! 285: if (mp->mscp_unit < next)
! 286: return;
! 287:
! 288: next = mp->mscp_unit + 1;
! 289: goto findunit;
! 290: }
! 291:
! 292:
! 293: /*
! 294: * The ctlr gets initialised, normally after boot but may also be
! 295: * done if the ctlr gets in an unknown state. Returns 1 if init
! 296: * fails, 0 otherwise.
! 297: */
! 298: int
! 299: mscp_init(mi)
! 300: struct mscp_softc *mi;
! 301: {
! 302: struct mscp *mp;
! 303: volatile int i;
! 304: int status, count;
! 305: unsigned int j = 0;
! 306:
! 307: /*
! 308: * While we are thinking about it, reset the next command
! 309: * and response indices.
! 310: */
! 311: mi->mi_cmd.mri_next = 0;
! 312: mi->mi_rsp.mri_next = 0;
! 313:
! 314: mi->mi_flags |= MSC_IGNOREINTR;
! 315:
! 316: if ((mi->mi_type & MSCPBUS_KDB) == 0)
! 317: WRITE_IP(0); /* Kick off */;
! 318:
! 319: status = mscp_waitstep(mi, MP_STEP1, MP_STEP1);/* Wait to it wakes up */
! 320: if (status == 0)
! 321: return 1; /* Init failed */
! 322: if (READ_SA & MP_ERR) {
! 323: (*mi->mi_mc->mc_saerror)(mi->mi_dev.dv_parent, 0);
! 324: return 1;
! 325: }
! 326:
! 327: /* step1 */
! 328: WRITE_SW(MP_ERR | (NCMDL2 << 11) | (NRSPL2 << 8) |
! 329: MP_IE | (mi->mi_ivec >> 2));
! 330: status = mscp_waitstep(mi, STEP1MASK, STEP1GOOD);
! 331: if (status == 0) {
! 332: (*mi->mi_mc->mc_saerror)(mi->mi_dev.dv_parent, 0);
! 333: return 1;
! 334: }
! 335:
! 336: /* step2 */
! 337: WRITE_SW(((mi->mi_dmam->dm_segs[0].ds_addr & 0xffff) +
! 338: offsetof(struct mscp_pack, mp_ca.ca_rspdsc[0])) |
! 339: (vax_cputype == VAX_780 || vax_cputype == VAX_8600 ? MP_PI : 0));
! 340: status = mscp_waitstep(mi, STEP2MASK, STEP2GOOD(mi->mi_ivec >> 2));
! 341: if (status == 0) {
! 342: (*mi->mi_mc->mc_saerror)(mi->mi_dev.dv_parent, 0);
! 343: return 1;
! 344: }
! 345:
! 346: /* step3 */
! 347: WRITE_SW((mi->mi_dmam->dm_segs[0].ds_addr >> 16));
! 348: status = mscp_waitstep(mi, STEP3MASK, STEP3GOOD);
! 349: if (status == 0) {
! 350: (*mi->mi_mc->mc_saerror)(mi->mi_dev.dv_parent, 0);
! 351: return 1;
! 352: }
! 353: i = READ_SA & 0377;
! 354: printf(": version %d model %d\n", i & 15, i >> 4);
! 355:
! 356: #define BURST 4 /* XXX */
! 357: if (mi->mi_type & MSCPBUS_UDA) {
! 358: WRITE_SW(MP_GO | (BURST - 1) << 2);
! 359: printf("%s: DMA burst size set to %d\n",
! 360: mi->mi_dev.dv_xname, BURST);
! 361: }
! 362: WRITE_SW(MP_GO);
! 363:
! 364: mscp_initds(mi);
! 365: mi->mi_flags &= ~MSC_IGNOREINTR;
! 366:
! 367: /*
! 368: * Set up all necessary info in the bus softc struct, get a
! 369: * mscp packet and set characteristics for this controller.
! 370: */
! 371: mi->mi_credits = MSCP_MINCREDITS + 1;
! 372: mp = mscp_getcp(mi, MSCP_DONTWAIT);
! 373:
! 374: mi->mi_credits = 0;
! 375: mp->mscp_opcode = M_OP_SETCTLRC;
! 376: mp->mscp_unit = mp->mscp_modifier = mp->mscp_flags =
! 377: mp->mscp_sccc.sccc_version = mp->mscp_sccc.sccc_hosttimo =
! 378: mp->mscp_sccc.sccc_time = mp->mscp_sccc.sccc_time1 =
! 379: mp->mscp_sccc.sccc_errlgfl = 0;
! 380: mp->mscp_sccc.sccc_ctlrflags = M_CF_ATTN | M_CF_MISC | M_CF_THIS;
! 381: *mp->mscp_addr |= MSCP_OWN | MSCP_INT;
! 382: i = READ_IP;
! 383:
! 384: count = 0;
! 385: while (count < DELAYTEN) {
! 386: if (((volatile int)mi->mi_flags & MSC_READY) != 0)
! 387: break;
! 388: if ((j = READ_SA) & MP_ERR)
! 389: goto out;
! 390: DELAY(10000);
! 391: count += 1;
! 392: }
! 393: if (count == DELAYTEN) {
! 394: out:
! 395: printf("%s: couldn't set ctlr characteristics, sa=%x\n",
! 396: mi->mi_dev.dv_xname, j);
! 397: return 1;
! 398: }
! 399: return 0;
! 400: }
! 401:
! 402: /*
! 403: * Initialise the various data structures that control the mscp protocol.
! 404: */
! 405: void
! 406: mscp_initds(mi)
! 407: struct mscp_softc *mi;
! 408: {
! 409: struct mscp_pack *ud = mi->mi_uda;
! 410: struct mscp *mp;
! 411: int i;
! 412:
! 413: for (i = 0, mp = ud->mp_rsp; i < NRSP; i++, mp++) {
! 414: ud->mp_ca.ca_rspdsc[i] = MSCP_OWN | MSCP_INT |
! 415: (mi->mi_dmam->dm_segs[0].ds_addr +
! 416: offsetof(struct mscp_pack, mp_rsp[i].mscp_cmdref));
! 417: mp->mscp_addr = &ud->mp_ca.ca_rspdsc[i];
! 418: mp->mscp_msglen = MSCP_MSGLEN;
! 419: }
! 420: for (i = 0, mp = ud->mp_cmd; i < NCMD; i++, mp++) {
! 421: ud->mp_ca.ca_cmddsc[i] = MSCP_INT |
! 422: (mi->mi_dmam->dm_segs[0].ds_addr +
! 423: offsetof(struct mscp_pack, mp_cmd[i].mscp_cmdref));
! 424: mp->mscp_addr = &ud->mp_ca.ca_cmddsc[i];
! 425: mp->mscp_msglen = MSCP_MSGLEN;
! 426: if (mi->mi_type & MSCPBUS_TAPE)
! 427: mp->mscp_vcid = 1;
! 428: }
! 429: }
! 430:
! 431: static void mscp_kickaway(struct mscp_softc *);
! 432:
! 433: void
! 434: mscp_intr(mi)
! 435: struct mscp_softc *mi;
! 436: {
! 437: struct mscp_pack *ud = mi->mi_uda;
! 438:
! 439: if (mi->mi_flags & MSC_IGNOREINTR)
! 440: return;
! 441: /*
! 442: * Check for response and command ring transitions.
! 443: */
! 444: if (ud->mp_ca.ca_rspint) {
! 445: ud->mp_ca.ca_rspint = 0;
! 446: mscp_dorsp(mi);
! 447: }
! 448: if (ud->mp_ca.ca_cmdint) {
! 449: ud->mp_ca.ca_cmdint = 0;
! 450: MSCP_DOCMD(mi);
! 451: }
! 452:
! 453: /*
! 454: * If there are any not-yet-handled request, try them now.
! 455: */
! 456: if (SIMPLEQ_FIRST(&mi->mi_resq))
! 457: mscp_kickaway(mi);
! 458: }
! 459:
! 460: int
! 461: mscp_print(aux, name)
! 462: void *aux;
! 463: const char *name;
! 464: {
! 465: struct drive_attach_args *da = aux;
! 466: struct mscp *mp = da->da_mp;
! 467: int type = mp->mscp_guse.guse_mediaid;
! 468:
! 469: if (name) {
! 470: printf("%c%c", MSCP_MID_CHAR(2, type), MSCP_MID_CHAR(1, type));
! 471: if (MSCP_MID_ECH(0, type))
! 472: printf("%c", MSCP_MID_CHAR(0, type));
! 473: printf("%d at %s drive %d", MSCP_MID_NUM(type), name,
! 474: mp->mscp_unit);
! 475: }
! 476: return UNCONF;
! 477: }
! 478:
! 479: /*
! 480: * common strategy routine for all types of MSCP devices.
! 481: */
! 482: void
! 483: mscp_strategy(bp, usc)
! 484: struct buf *bp;
! 485: struct device *usc;
! 486: {
! 487: struct mscp_softc *mi = (void *)usc;
! 488: int s = spl6();
! 489:
! 490: /* SIMPLEQ_INSERT_TAIL(&mi->mi_resq, bp, xxx) */
! 491: bp->b_actf = NULL;
! 492: *mi->mi_resq.sqh_last = bp;
! 493: mi->mi_resq.sqh_last = &bp->b_actf;
! 494: mscp_kickaway(mi);
! 495: splx(s);
! 496: }
! 497:
! 498:
! 499: void
! 500: mscp_kickaway(mi)
! 501: struct mscp_softc *mi;
! 502: {
! 503: struct buf *bp;
! 504: struct mscp *mp;
! 505: int next;
! 506:
! 507: while ((bp = SIMPLEQ_FIRST(&mi->mi_resq))) {
! 508: /*
! 509: * Ok; we are ready to try to start a xfer. Get a MSCP packet
! 510: * and try to start...
! 511: */
! 512: if ((mp = mscp_getcp(mi, MSCP_DONTWAIT)) == NULL) {
! 513: if (mi->mi_credits > MSCP_MINCREDITS)
! 514: printf("%s: command ring too small\n",
! 515: mi->mi_dev.dv_parent->dv_xname);
! 516: /*
! 517: * By some (strange) reason we didn't get a MSCP packet.
! 518: * Just return and wait for free packets.
! 519: */
! 520: return;
! 521: }
! 522:
! 523: if ((next = (ffs(mi->mi_mxiuse) - 1)) < 0)
! 524: panic("no mxi buffers");
! 525: mi->mi_mxiuse &= ~(1 << next);
! 526: if (mi->mi_xi[next].mxi_inuse)
! 527: panic("mxi inuse");
! 528: /*
! 529: * Set up the MSCP packet and ask the ctlr to start.
! 530: */
! 531: mp->mscp_opcode =
! 532: (bp->b_flags & B_READ) ? M_OP_READ : M_OP_WRITE;
! 533: mp->mscp_cmdref = next;
! 534: mi->mi_xi[next].mxi_bp = bp;
! 535: mi->mi_xi[next].mxi_mp = mp;
! 536: mi->mi_xi[next].mxi_inuse = 1;
! 537: bp->b_resid = next;
! 538: (*mi->mi_me->me_fillin)(bp, mp);
! 539: (*mi->mi_mc->mc_go)(mi->mi_dev.dv_parent, &mi->mi_xi[next]);
! 540: if ((mi->mi_resq.sqh_first = bp->b_actf) == NULL)
! 541: mi->mi_resq.sqh_last = &mi->mi_resq.sqh_first;
! 542: #if 0
! 543: mi->mi_w = bp->b_actf;
! 544: #endif
! 545: }
! 546: }
! 547:
! 548: void
! 549: mscp_dgo(mi, mxi)
! 550: struct mscp_softc *mi;
! 551: struct mscp_xi *mxi;
! 552: {
! 553: volatile int i;
! 554: struct mscp *mp;
! 555:
! 556: /*
! 557: * Fill in the MSCP packet and move the buffer to the I/O wait queue.
! 558: */
! 559: mp = mxi->mxi_mp;
! 560: mp->mscp_seq.seq_buffer = mxi->mxi_dmam->dm_segs[0].ds_addr;
! 561:
! 562: *mp->mscp_addr |= MSCP_OWN | MSCP_INT;
! 563: i = READ_IP;
! 564: }
! 565:
! 566: #ifdef DIAGNOSTIC
! 567: /*
! 568: * Dump the entire contents of an MSCP packet in hex. Mainly useful
! 569: * for debugging....
! 570: */
! 571: void
! 572: mscp_hexdump(mp)
! 573: struct mscp *mp;
! 574: {
! 575: long *p = (long *) mp;
! 576: int i = mp->mscp_msglen;
! 577:
! 578: if (i > 256) /* sanity */
! 579: i = 256;
! 580: i /= sizeof (*p); /* ASSUMES MULTIPLE OF sizeof(long) */
! 581: while (--i >= 0)
! 582: printf("0x%x ", (int)*p++);
! 583: printf("\n");
! 584: }
! 585: #endif
! 586:
! 587: /*
! 588: * MSCP error reporting
! 589: */
! 590:
! 591: /*
! 592: * Messages for the various subcodes.
! 593: */
! 594: static char unknown_msg[] = "unknown subcode";
! 595:
! 596: /*
! 597: * Subcodes for Success (0)
! 598: */
! 599: static char *succ_msgs[] = {
! 600: "normal", /* 0 */
! 601: "spin down ignored", /* 1 = Spin-Down Ignored */
! 602: "still connected", /* 2 = Still Connected */
! 603: unknown_msg,
! 604: "dup. unit #", /* 4 = Duplicate Unit Number */
! 605: unknown_msg,
! 606: unknown_msg,
! 607: unknown_msg,
! 608: "already online", /* 8 = Already Online */
! 609: unknown_msg,
! 610: unknown_msg,
! 611: unknown_msg,
! 612: unknown_msg,
! 613: unknown_msg,
! 614: unknown_msg,
! 615: unknown_msg,
! 616: "still online", /* 16 = Still Online */
! 617: };
! 618:
! 619: /*
! 620: * Subcodes for Invalid Command (1)
! 621: */
! 622: static char *icmd_msgs[] = {
! 623: "invalid msg length", /* 0 = Invalid Message Length */
! 624: };
! 625:
! 626: /*
! 627: * Subcodes for Command Aborted (2)
! 628: */
! 629: /* none known */
! 630:
! 631: /*
! 632: * Subcodes for Unit Offline (3)
! 633: */
! 634: static char *offl_msgs[] = {
! 635: "unknown drive", /* 0 = Unknown, or online to other ctlr */
! 636: "not mounted", /* 1 = Unmounted, or RUN/STOP at STOP */
! 637: "inoperative", /* 2 = Unit Inoperative */
! 638: unknown_msg,
! 639: "duplicate", /* 4 = Duplicate Unit Number */
! 640: unknown_msg,
! 641: unknown_msg,
! 642: unknown_msg,
! 643: "in diagnosis", /* 8 = Disabled by FS or diagnostic */
! 644: };
! 645:
! 646: /*
! 647: * Subcodes for Unit Available (4)
! 648: */
! 649: /* none known */
! 650:
! 651: /*
! 652: * Subcodes for Media Format Error (5)
! 653: */
! 654: static char *media_fmt_msgs[] = {
! 655: "fct unread - edc", /* 0 = FCT unreadable */
! 656: "invalid sector header",/* 1 = Invalid Sector Header */
! 657: "not 512 sectors", /* 2 = Not 512 Byte Sectors */
! 658: "not formatted", /* 3 = Not Formatted */
! 659: "fct ecc", /* 4 = FCT ECC */
! 660: };
! 661:
! 662: /*
! 663: * Subcodes for Write Protected (6)
! 664: * N.B.: Code 6 subcodes are 7 bits higher than other subcodes
! 665: * (i.e., bits 12-15).
! 666: */
! 667: static char *wrprot_msgs[] = {
! 668: unknown_msg,
! 669: "software", /* 1 = Software Write Protect */
! 670: "hardware", /* 2 = Hardware Write Protect */
! 671: };
! 672:
! 673: /*
! 674: * Subcodes for Compare Error (7)
! 675: */
! 676: /* none known */
! 677:
! 678: /*
! 679: * Subcodes for Data Error (8)
! 680: */
! 681: static char *data_msgs[] = {
! 682: "forced error", /* 0 = Forced Error (software) */
! 683: unknown_msg,
! 684: "header compare", /* 2 = Header Compare Error */
! 685: "sync timeout", /* 3 = Sync Timeout Error */
! 686: unknown_msg,
! 687: unknown_msg,
! 688: unknown_msg,
! 689: "uncorrectable ecc", /* 7 = Uncorrectable ECC */
! 690: "1 symbol ecc", /* 8 = 1 bit ECC */
! 691: "2 symbol ecc", /* 9 = 2 bit ECC */
! 692: "3 symbol ecc", /* 10 = 3 bit ECC */
! 693: "4 symbol ecc", /* 11 = 4 bit ECC */
! 694: "5 symbol ecc", /* 12 = 5 bit ECC */
! 695: "6 symbol ecc", /* 13 = 6 bit ECC */
! 696: "7 symbol ecc", /* 14 = 7 bit ECC */
! 697: "8 symbol ecc", /* 15 = 8 bit ECC */
! 698: };
! 699:
! 700: /*
! 701: * Subcodes for Host Buffer Access Error (9)
! 702: */
! 703: static char *host_buffer_msgs[] = {
! 704: unknown_msg,
! 705: "odd xfer addr", /* 1 = Odd Transfer Address */
! 706: "odd xfer count", /* 2 = Odd Transfer Count */
! 707: "non-exist. memory", /* 3 = Non-Existent Memory */
! 708: "memory parity", /* 4 = Memory Parity Error */
! 709: };
! 710:
! 711: /*
! 712: * Subcodes for Controller Error (10)
! 713: */
! 714: static char *cntlr_msgs[] = {
! 715: unknown_msg,
! 716: "serdes overrun", /* 1 = Serialiser/Deserialiser Overrun */
! 717: "edc", /* 2 = Error Detection Code? */
! 718: "inconsistent internal data struct",/* 3 = Internal Error */
! 719: };
! 720:
! 721: /*
! 722: * Subcodes for Drive Error (11)
! 723: */
! 724: static char *drive_msgs[] = {
! 725: unknown_msg,
! 726: "sdi command timeout", /* 1 = SDI Command Timeout */
! 727: "ctlr detected protocol",/* 2 = Controller Detected Protocol Error */
! 728: "positioner", /* 3 = Positioner Error */
! 729: "lost rd/wr ready", /* 4 = Lost R/W Ready Error */
! 730: "drive clock dropout", /* 5 = Lost Drive Clock */
! 731: "lost recvr ready", /* 6 = Lost Receiver Ready */
! 732: "drive detected error", /* 7 = Drive Error */
! 733: "ctlr detected pulse or parity",/* 8 = Pulse or Parity Error */
! 734: };
! 735:
! 736: /*
! 737: * The following table correlates message codes with the
! 738: * decoding strings.
! 739: */
! 740: struct code_decode {
! 741: char *cdc_msg;
! 742: int cdc_nsubcodes;
! 743: char **cdc_submsgs;
! 744: } code_decode[] = {
! 745: #define SC(m) sizeof (m) / sizeof (m[0]), m
! 746: {"success", SC(succ_msgs)},
! 747: {"invalid command", SC(icmd_msgs)},
! 748: {"command aborted", 0, 0},
! 749: {"unit offline", SC(offl_msgs)},
! 750: {"unit available", 0, 0},
! 751: {"media format error", SC(media_fmt_msgs)},
! 752: {"write protected", SC(wrprot_msgs)},
! 753: {"compare error", 0, 0},
! 754: {"data error", SC(data_msgs)},
! 755: {"host buffer access error", SC(host_buffer_msgs)},
! 756: {"controller error", SC(cntlr_msgs)},
! 757: {"drive error", SC(drive_msgs)},
! 758: #undef SC
! 759: };
! 760:
! 761: /*
! 762: * Print the decoded error event from an MSCP error datagram.
! 763: */
! 764: void
! 765: mscp_printevent(mp)
! 766: struct mscp *mp;
! 767: {
! 768: int event = mp->mscp_event;
! 769: struct code_decode *cdc;
! 770: int c, sc;
! 771: char *cm, *scm;
! 772:
! 773: /*
! 774: * The code is the lower six bits of the event number (aka
! 775: * status). If that is 6 (write protect), the subcode is in
! 776: * bits 12-15; otherwise, it is in bits 5-11.
! 777: * I WONDER WHAT THE OTHER BITS ARE FOR. IT SURE WOULD BE
! 778: * NICE IF DEC SOLD DOCUMENTATION FOR THEIR OWN CONTROLLERS.
! 779: */
! 780: c = event & M_ST_MASK;
! 781: sc = (c != 6 ? event >> 5 : event >> 12) & 0x7ff;
! 782: if (c >= sizeof code_decode / sizeof code_decode[0])
! 783: cm = "- unknown code", scm = "??";
! 784: else {
! 785: cdc = &code_decode[c];
! 786: cm = cdc->cdc_msg;
! 787: if (sc >= cdc->cdc_nsubcodes)
! 788: scm = unknown_msg;
! 789: else
! 790: scm = cdc->cdc_submsgs[sc];
! 791: }
! 792: printf(" %s (%s) (code %d, subcode %d)\n", cm, scm, c, sc);
! 793: }
! 794:
! 795: static char *codemsg[16] = {
! 796: "lbn", "code 1", "code 2", "code 3",
! 797: "code 4", "code 5", "rbn", "code 7",
! 798: "code 8", "code 9", "code 10", "code 11",
! 799: "code 12", "code 13", "code 14", "code 15"
! 800: };
! 801: /*
! 802: * Print the code and logical block number for an error packet.
! 803: * THIS IS PROBABLY PECULIAR TO DISK DRIVES. IT SURE WOULD BE
! 804: * NICE IF DEC SOLD DOCUMENTATION FOR THEIR OWN CONTROLLERS.
! 805: */
! 806: int
! 807: mscp_decodeerror(name, mp, mi)
! 808: char *name;
! 809: struct mscp *mp;
! 810: struct mscp_softc *mi;
! 811: {
! 812: int issoft;
! 813: /*
! 814: * We will get three sdi errors of type 11 after autoconfig
! 815: * is finished; depending of searching for non-existing units.
! 816: * How can we avoid this???
! 817: */
! 818: if (((mp->mscp_event & M_ST_MASK) == 11) && (mi->mi_ierr++ < 3))
! 819: return 1;
! 820: /*
! 821: * For bad blocks, mp->mscp_erd.erd_hdr identifies a code and
! 822: * the logical block number. Code 0 is a regular block; code 6
! 823: * is a replacement block. The remaining codes are currently
! 824: * undefined. The code is in the upper four bits of the header
! 825: * (bits 0-27 are the lbn).
! 826: */
! 827: issoft = mp->mscp_flags & (M_LF_SUCC | M_LF_CONT);
! 828: #define BADCODE(h) (codemsg[(unsigned)(h) >> 28])
! 829: #define BADLBN(h) ((h) & 0xfffffff)
! 830:
! 831: printf("%s: drive %d %s error datagram%s:", name, mp->mscp_unit,
! 832: issoft ? "soft" : "hard",
! 833: mp->mscp_flags & M_LF_CONT ? " (continuing)" : "");
! 834: switch (mp->mscp_format & 0377) {
! 835:
! 836: case M_FM_CTLRERR: /* controller error */
! 837: break;
! 838:
! 839: case M_FM_BUSADDR: /* host memory access error */
! 840: printf(" memory addr 0x%x:", (int)mp->mscp_erd.erd_busaddr);
! 841: break;
! 842:
! 843: case M_FM_DISKTRN:
! 844: printf(" unit %d: level %d retry %d, %s %d:",
! 845: mp->mscp_unit,
! 846: mp->mscp_erd.erd_level, mp->mscp_erd.erd_retry,
! 847: BADCODE(mp->mscp_erd.erd_hdr),
! 848: (int)BADLBN(mp->mscp_erd.erd_hdr));
! 849: break;
! 850:
! 851: case M_FM_SDI:
! 852: printf(" unit %d: %s %d:", mp->mscp_unit,
! 853: BADCODE(mp->mscp_erd.erd_hdr),
! 854: (int)BADLBN(mp->mscp_erd.erd_hdr));
! 855: break;
! 856:
! 857: case M_FM_SMLDSK:
! 858: printf(" unit %d: small disk error, cyl %d:",
! 859: mp->mscp_unit, mp->mscp_erd.erd_sdecyl);
! 860: break;
! 861:
! 862: case M_FM_TAPETRN:
! 863: printf(" unit %d: tape transfer error, grp 0x%x event 0%o:",
! 864: mp->mscp_unit, mp->mscp_erd.erd_sdecyl, mp->mscp_event);
! 865: break;
! 866:
! 867: case M_FM_STIERR:
! 868: printf(" unit %d: STI error, event 0%o:", mp->mscp_unit,
! 869: mp->mscp_event);
! 870: break;
! 871:
! 872: default:
! 873: printf(" unit %d: unknown error, format 0x%x:",
! 874: mp->mscp_unit, mp->mscp_format);
! 875: }
! 876: mscp_printevent(mp);
! 877: return 0;
! 878: #undef BADCODE
! 879: #undef BADLBN
! 880: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to mscp_subr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / vax / mscp