Annotation of sys/arch/sparc/dev/xd.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: xd.c,v 1.41 2007/07/01 19:06:57 miod Exp $ */
2: /* $NetBSD: xd.c,v 1.37 1997/07/29 09:58:16 fair Exp $ */
3:
4: /*
5: *
6: * Copyright (c) 1995 Charles D. Cranor
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Charles D. Cranor.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33: */
34:
35: /*
36: *
37: * x d . c x y l o g i c s 7 5 3 / 7 0 5 3 v m e / s m d d r i v e r
38: *
39: * author: Chuck Cranor <chuck@ccrc.wustl.edu>
40: * id: $NetBSD: xd.c,v 1.37 1997/07/29 09:58:16 fair Exp $
41: * started: 27-Feb-95
42: * references: [1] Xylogics Model 753 User's Manual
43: * part number: 166-753-001, Revision B, May 21, 1988.
44: * "Your Partner For Performance"
45: * [2] other NetBSD disk device drivers
46: *
47: * Special thanks go to Scott E. Campbell of Xylogics, Inc. for taking
48: * the time to answer some of my questions about the 753/7053.
49: *
50: * note: the 753 and the 7053 are programmed the same way, but are
51: * different sizes. the 753 is a 6U VME card, while the 7053 is a 9U
52: * VME card (found in many VME based suns).
53: */
54:
55: #undef XDC_DEBUG /* full debug */
56: #define XDC_DIAG /* extra sanity checks */
57: #if defined(DIAGNOSTIC) && !defined(XDC_DIAG)
58: #define XDC_DIAG /* link in with master DIAG option */
59: #endif
60:
61: #include <sys/param.h>
62: #include <sys/proc.h>
63: #include <sys/systm.h>
64: #include <sys/kernel.h>
65: #include <sys/file.h>
66: #include <sys/stat.h>
67: #include <sys/ioctl.h>
68: #include <sys/buf.h>
69: #include <sys/uio.h>
70: #include <sys/malloc.h>
71: #include <sys/device.h>
72: #include <sys/disklabel.h>
73: #include <sys/disk.h>
74: #include <sys/syslog.h>
75: #include <sys/dkbad.h>
76: #include <sys/conf.h>
77: #include <sys/timeout.h>
78:
79: #include <uvm/uvm_extern.h>
80:
81: #include <machine/autoconf.h>
82: #include <dev/sun/disklabel.h>
83: #include <machine/conf.h>
84:
85: #include <sparc/dev/xdreg.h>
86: #include <sparc/dev/xdvar.h>
87: #include <sparc/dev/xio.h>
88: #include <sparc/sparc/vaddrs.h>
89: #include <sparc/sparc/cpuvar.h>
90:
91: /*
92: * macros
93: */
94:
95: /*
96: * XDC_TWAIT: add iorq "N" to tail of SC's wait queue
97: */
98: #define XDC_TWAIT(SC, N) { \
99: (SC)->waitq[(SC)->waitend] = (N); \
100: (SC)->waitend = ((SC)->waitend + 1) % XDC_MAXIOPB; \
101: (SC)->nwait++; \
102: }
103:
104: /*
105: * XDC_HWAIT: add iorq "N" to head of SC's wait queue
106: */
107: #define XDC_HWAIT(SC, N) { \
108: (SC)->waithead = ((SC)->waithead == 0) ? \
109: (XDC_MAXIOPB - 1) : ((SC)->waithead - 1); \
110: (SC)->waitq[(SC)->waithead] = (N); \
111: (SC)->nwait++; \
112: }
113:
114: /*
115: * XDC_GET_WAITER: gets the first request waiting on the waitq
116: * and removes it (so it can be submitted)
117: */
118: #define XDC_GET_WAITER(XDCSC, RQ) { \
119: (RQ) = (XDCSC)->waitq[(XDCSC)->waithead]; \
120: (XDCSC)->waithead = ((XDCSC)->waithead + 1) % XDC_MAXIOPB; \
121: xdcsc->nwait--; \
122: }
123:
124: /*
125: * XDC_FREE: add iorq "N" to SC's free list
126: */
127: #define XDC_FREE(SC, N) { \
128: (SC)->freereq[(SC)->nfree++] = (N); \
129: (SC)->reqs[N].mode = 0; \
130: if ((SC)->nfree == 1) wakeup(&(SC)->nfree); \
131: }
132:
133:
134: /*
135: * XDC_RQALLOC: allocate an iorq off the free list (assume nfree > 0).
136: */
137: #define XDC_RQALLOC(XDCSC) (XDCSC)->freereq[--((XDCSC)->nfree)]
138:
139: /*
140: * XDC_GO: start iopb ADDR (DVMA addr in a u_long) on XDC
141: */
142: #define XDC_GO(XDC, ADDR) { \
143: (XDC)->xdc_iopbaddr0 = ((ADDR) & 0xff); \
144: (ADDR) = ((ADDR) >> 8); \
145: (XDC)->xdc_iopbaddr1 = ((ADDR) & 0xff); \
146: (ADDR) = ((ADDR) >> 8); \
147: (XDC)->xdc_iopbaddr2 = ((ADDR) & 0xff); \
148: (ADDR) = ((ADDR) >> 8); \
149: (XDC)->xdc_iopbaddr3 = (ADDR); \
150: (XDC)->xdc_iopbamod = XDC_ADDRMOD; \
151: (XDC)->xdc_csr = XDC_ADDIOPB; /* go! */ \
152: }
153:
154: /*
155: * XDC_WAIT: wait for XDC's csr "BITS" to come on in "TIME".
156: * LCV is a counter. If it goes to zero then we timed out.
157: */
158: #define XDC_WAIT(XDC, LCV, TIME, BITS) { \
159: (LCV) = (TIME); \
160: while ((LCV) > 0) { \
161: if ((XDC)->xdc_csr & (BITS)) break; \
162: (LCV) = (LCV) - 1; \
163: DELAY(1); \
164: } \
165: }
166:
167: /*
168: * XDC_DONE: don't need IORQ, get error code and free (done after xdc_cmd)
169: */
170: #define XDC_DONE(SC,RQ,ER) { \
171: if ((RQ) == XD_ERR_FAIL) { \
172: (ER) = (RQ); \
173: } else { \
174: if ((SC)->ndone-- == XDC_SUBWAITLIM) \
175: wakeup(&(SC)->ndone); \
176: (ER) = (SC)->reqs[RQ].errno; \
177: XDC_FREE((SC), (RQ)); \
178: } \
179: }
180:
181: /*
182: * XDC_ADVANCE: advance iorq's pointers by a number of sectors
183: */
184: #define XDC_ADVANCE(IORQ, N) { \
185: if (N) { \
186: (IORQ)->sectcnt -= (N); \
187: (IORQ)->blockno += (N); \
188: (IORQ)->dbuf += ((N)*XDFM_BPS); \
189: } \
190: }
191:
192: /*
193: * note - addresses you can sleep on:
194: * [1] & of xd_softc's "state" (waiting for a chance to attach a drive)
195: * [2] & of xdc_softc's "nfree" (waiting for a free iorq/iopb)
196: * [3] & of xdc_softc's "ndone" (waiting for number of done iorq/iopb's
197: * to drop below XDC_SUBWAITLIM)
198: * [4] & an iorq (waiting for an XD_SUB_WAIT iorq to finish)
199: */
200:
201:
202: /*
203: * function prototypes
204: * "xdc_*" functions are internal, all others are external interfaces
205: */
206:
207: extern int pil_to_vme[]; /* from obio.c */
208:
209: /* internals */
210: int xdc_cmd(struct xdc_softc *, int, int, int, int, int, char *, int);
211: char *xdc_e2str(int);
212: int xdc_error(struct xdc_softc *, struct xd_iorq *,
213: struct xd_iopb *, int, int);
214: int xdc_ioctlcmd(struct xd_softc *, dev_t dev, struct xd_iocmd *);
215: void xdc_perror(struct xd_iorq *, struct xd_iopb *, int);
216: int xdc_piodriver(struct xdc_softc *, int, int);
217: int xdc_remove_iorq(struct xdc_softc *);
218: int xdc_reset(struct xdc_softc *, int, int, int, struct xd_softc *);
219: inline void xdc_rqinit(struct xd_iorq *, struct xdc_softc *,
220: struct xd_softc *, int, u_long, int,
221: caddr_t, struct buf *);
222: void xdc_rqtopb(struct xd_iorq *, struct xd_iopb *, int, int);
223: void xdc_start(struct xdc_softc *, int);
224: int xdc_startbuf(struct xdc_softc *, struct xd_softc *, struct buf *);
225: int xdc_submit_iorq(struct xdc_softc *, int, int);
226: void xdc_tick(void *);
227: void xdc_xdreset(struct xdc_softc *, struct xd_softc *);
228:
229: /* machine interrupt hook */
230: int xdcintr(void *);
231:
232: /* autoconf */
233: int xdcmatch(struct device *, void *, void *);
234: void xdcattach(struct device *, struct device *, void *);
235: int xdmatch(struct device *, void *, void *);
236: void xdattach(struct device *, struct device *, void *);
237:
238: static void xddummystrat(struct buf *);
239: int xdgetdisklabel(struct xd_softc *, void *);
240:
241: /*
242: * cfdrivers: device driver interface to autoconfig
243: */
244:
245: struct cfattach xdc_ca = {
246: sizeof(struct xdc_softc), xdcmatch, xdcattach
247: };
248:
249:
250: struct cfdriver xdc_cd = {
251: NULL, "xdc", DV_DULL
252: };
253:
254: struct cfattach xd_ca = {
255: sizeof(struct xd_softc), xdmatch, xdattach
256: };
257:
258: struct cfdriver xd_cd = {
259: NULL, "xd", DV_DISK
260: };
261:
262: struct xdc_attach_args { /* this is the "aux" args to xdattach */
263: int driveno; /* unit number */
264: char *buf; /* scratch buffer for reading disk label */
265: char *dvmabuf; /* DVMA address of above */
266: int fullmode; /* submit mode */
267: int booting; /* are we booting or not? */
268: };
269:
270: /*
271: * dkdriver
272: */
273:
274: struct dkdriver xddkdriver = {xdstrategy};
275:
276: /*
277: * start: disk label fix code (XXX)
278: */
279:
280: static void *xd_labeldata;
281:
282: static void
283: xddummystrat(bp)
284: struct buf *bp;
285: {
286: if (bp->b_bcount != XDFM_BPS)
287: panic("xddummystrat");
288: bcopy(xd_labeldata, bp->b_data, XDFM_BPS);
289: bp->b_flags |= B_DONE;
290: bp->b_flags &= ~B_BUSY;
291: }
292:
293: int
294: xdgetdisklabel(xd, b)
295: struct xd_softc *xd;
296: void *b;
297: {
298: struct disklabel *lp = xd->sc_dk.dk_label;
299: struct sun_disklabel *sl = b;
300: char *err;
301:
302: bzero(lp, sizeof(struct disklabel));
303: /* Required parameters for readdisklabel() */
304: lp->d_secsize = XDFM_BPS;
305: if (sl->sl_magic == SUN_DKMAGIC) {
306: lp->d_secpercyl = sl->sl_nsectors * sl->sl_ntracks;
307: DL_SETDSIZE(lp, (daddr64_t)lp->d_secpercyl * sl->sl_ncylinders);
308: } else {
309: lp->d_secpercyl = 1;
310: }
311:
312: /* We already have the label data in `b'; setup for dummy strategy */
313: xd_labeldata = b;
314:
315: err = readdisklabel(MAKEDISKDEV(0, xd->sc_dev.dv_unit, RAW_PART),
316: xddummystrat, lp, 0);
317: if (err) {
318: /*printf("%s: %s\n", xd->sc_dev.dv_xname, err);*/
319: return (XD_ERR_FAIL);
320: }
321:
322: /* Ok, we have the label; fill in `pcyl' if there's SunOS magic */
323: sl = b;
324: if (sl->sl_magic == SUN_DKMAGIC)
325: xd->pcyl = sl->sl_pcylinders;
326: else {
327: printf("%s: WARNING: no `pcyl' in disk label.\n",
328: xd->sc_dev.dv_xname);
329: xd->pcyl = lp->d_ncylinders +
330: lp->d_acylinders;
331: printf("%s: WARNING: guessing pcyl=%d (ncyl+acyl)\n",
332: xd->sc_dev.dv_xname, xd->pcyl);
333: }
334:
335: xd->ncyl = lp->d_ncylinders;
336: xd->acyl = lp->d_acylinders;
337: xd->nhead = lp->d_ntracks;
338: xd->nsect = lp->d_nsectors;
339: xd->sectpercyl = lp->d_secpercyl;
340: return (XD_ERR_AOK);
341: }
342:
343: /*
344: * end: disk label fix code (XXX)
345: */
346:
347: /*
348: * a u t o c o n f i g f u n c t i o n s
349: */
350:
351: /*
352: * xdcmatch: determine if xdc is present or not. we do a
353: * soft reset to detect the xdc.
354: */
355:
356: int xdcmatch(parent, vcf, aux)
357: struct device *parent;
358: void *vcf, *aux;
359: {
360: struct cfdata *cf = vcf;
361: struct confargs *ca = aux;
362: struct romaux *ra = &ca->ca_ra;
363: struct xdc *xdc;
364: int del = 0;
365:
366: if (strcmp(cf->cf_driver->cd_name, ra->ra_name))
367: return (0);
368:
369: switch (ca->ca_bustype) {
370: case BUS_OBIO:
371: case BUS_SBUS:
372: case BUS_VME16:
373: default:
374: return (0);
375: case BUS_VME32:
376: xdc = (struct xdc *) ra->ra_vaddr;
377: if (probeget((caddr_t) &xdc->xdc_csr, 1) == -1)
378: return (0);
379: xdc->xdc_csr = XDC_RESET;
380: XDC_WAIT(xdc, del, XDC_RESETUSEC, XDC_RESET);
381: if (del <= 0)
382: return (0);
383: return (1);
384: }
385: }
386:
387: /*
388: * xdcattach: attach controller
389: */
390: void
391: xdcattach(parent, self, aux)
392: struct device *parent, *self;
393: void *aux;
394:
395: {
396: struct xdc_softc *xdc = (void *) self;
397: struct confargs *ca = aux;
398: struct xdc_attach_args xa;
399: int lcv, rqno, err, pri;
400: struct xd_iopb_ctrl *ctl;
401:
402: /* get addressing and intr level stuff from autoconfig and load it
403: * into our xdc_softc. */
404:
405: ca->ca_ra.ra_vaddr = mapiodev(ca->ca_ra.ra_reg, 0, sizeof(struct xdc));
406:
407: xdc->xdc = (struct xdc *) ca->ca_ra.ra_vaddr;
408: pri = ca->ca_ra.ra_intr[0].int_pri;
409: xdc->ipl = pil_to_vme[pri];
410: xdc->vector = ca->ca_ra.ra_intr[0].int_vec;
411: printf(" pri %d", pri);
412:
413: for (lcv = 0; lcv < XDC_MAXDEV; lcv++)
414: xdc->sc_drives[lcv] = (struct xd_softc *) 0;
415:
416: /* allocate and zero buffers
417: *
418: * note: we simplify the code by allocating the max number of iopbs and
419: * iorq's up front. thus, we avoid linked lists and the costs
420: * associated with them in exchange for wasting a little memory. */
421:
422: xdc->dvmaiopb = (struct xd_iopb *)
423: dvma_malloc(XDC_MAXIOPB * sizeof(struct xd_iopb), &xdc->iopbase,
424: M_NOWAIT);
425: xdc->iopbase = xdc->dvmaiopb; /* XXX TMP HACK */
426: bzero(xdc->iopbase, XDC_MAXIOPB * sizeof(struct xd_iopb));
427: /* Setup device view of DVMA address */
428: xdc->dvmaiopb = (struct xd_iopb *) ((u_long) xdc->iopbase - DVMA_BASE);
429:
430: xdc->reqs = (struct xd_iorq *)
431: malloc(XDC_MAXIOPB * sizeof(struct xd_iorq), M_DEVBUF, M_NOWAIT);
432: if (xdc->reqs == NULL)
433: panic("xdc malloc");
434: bzero(xdc->reqs, XDC_MAXIOPB * sizeof(struct xd_iorq));
435:
436: /* init free list, iorq to iopb pointers, and non-zero fields in the
437: * iopb which never change. */
438:
439: for (lcv = 0; lcv < XDC_MAXIOPB; lcv++) {
440: xdc->reqs[lcv].iopb = &xdc->iopbase[lcv];
441: xdc->freereq[lcv] = lcv;
442: xdc->iopbase[lcv].fixd = 1; /* always the same */
443: xdc->iopbase[lcv].naddrmod = XDC_ADDRMOD; /* always the same */
444: xdc->iopbase[lcv].intr_vec = xdc->vector; /* always the same */
445: }
446: xdc->nfree = XDC_MAXIOPB;
447: xdc->nrun = 0;
448: xdc->waithead = xdc->waitend = xdc->nwait = 0;
449: xdc->ndone = 0;
450:
451: /* init queue of waiting bufs */
452:
453: xdc->sc_wq.b_active = 0;
454: xdc->sc_wq.b_actf = 0;
455: xdc->sc_wq.b_actb = &xdc->sc_wq.b_actf;
456:
457: /*
458: * section 7 of the manual tells us how to init the controller:
459: * - read controller parameters (6/0)
460: * - write controller parameters (5/0)
461: */
462:
463: /* read controller parameters and insure we have a 753/7053 */
464:
465: rqno = xdc_cmd(xdc, XDCMD_RDP, XDFUN_CTL, 0, 0, 0, 0, XD_SUB_POLL);
466: if (rqno == XD_ERR_FAIL) {
467: printf(": couldn't read controller params\n");
468: return; /* shouldn't ever happen */
469: }
470: ctl = (struct xd_iopb_ctrl *) & xdc->iopbase[rqno];
471: if (ctl->ctype != XDCT_753) {
472: if (xdc->reqs[rqno].errno)
473: printf(": %s: ", xdc_e2str(xdc->reqs[rqno].errno));
474: printf(": doesn't identify as a 753/7053\n");
475: XDC_DONE(xdc, rqno, err);
476: return;
477: }
478: printf(": Xylogics 753/7053, PROM=0x%x.%02x.%02x\n",
479: ctl->eprom_partno, ctl->eprom_lvl, ctl->eprom_rev);
480: XDC_DONE(xdc, rqno, err);
481:
482: /* now write controller parameters (xdc_cmd sets all params for us) */
483:
484: rqno = xdc_cmd(xdc, XDCMD_WRP, XDFUN_CTL, 0, 0, 0, 0, XD_SUB_POLL);
485: XDC_DONE(xdc, rqno, err);
486: if (err) {
487: printf("%s: controller config error: %s\n",
488: xdc->sc_dev.dv_xname, xdc_e2str(err));
489: return;
490: }
491: /* link in interrupt with higher level software */
492:
493: xdc->sc_ih.ih_fun = xdcintr;
494: xdc->sc_ih.ih_arg = xdc;
495: vmeintr_establish(ca->ca_ra.ra_intr[0].int_vec,
496: ca->ca_ra.ra_intr[0].int_pri, &xdc->sc_ih, IPL_BIO,
497: self->dv_xname);
498:
499: /* now we must look for disks using autoconfig */
500: xa.dvmabuf = (char *)dvma_malloc(XDFM_BPS, &xa.buf, M_NOWAIT);
501: xa.fullmode = XD_SUB_POLL;
502: xa.booting = 1;
503:
504: if (ca->ca_ra.ra_bp && ca->ca_ra.ra_bp->val[0] == -1 &&
505: ca->ca_ra.ra_bp->val[1] == xdc->sc_dev.dv_unit) {
506: bootpath_store(1, ca->ca_ra.ra_bp + 1); /* advance bootpath */
507: }
508:
509: for (xa.driveno = 0; xa.driveno < XDC_MAXDEV; xa.driveno++)
510: (void) config_found(self, (void *) &xa, NULL);
511:
512: dvma_free(xa.dvmabuf, XDFM_BPS, &xa.buf);
513: bootpath_store(1, NULL);
514:
515: /* start the watchdog clock */
516: timeout_set(&xdc->xdc_tick_tmo, xdc_tick, xdc);
517: timeout_add(&xdc->xdc_tick_tmo, XDC_TICKCNT);
518:
519: }
520:
521: /*
522: * xdmatch: probe for disk.
523: *
524: * note: we almost always say disk is present. this allows us to
525: * spin up and configure a disk after the system is booted (we can
526: * call xdattach!).
527: */
528: int
529: xdmatch(parent, vcf, aux)
530: struct device *parent;
531: void *vcf, *aux;
532: {
533: struct cfdata *cf = vcf;
534: struct xdc_attach_args *xa = aux;
535:
536: /* looking for autoconf wildcard or exact match */
537:
538: if (cf->cf_loc[0] != -1 && cf->cf_loc[0] != xa->driveno)
539: return 0;
540:
541: return 1;
542:
543: }
544:
545: /*
546: * xdattach: attach a disk. this can be called from autoconf and also
547: * from xdopen/xdstrategy.
548: */
549: void
550: xdattach(parent, self, aux)
551: struct device *parent, *self;
552: void *aux;
553:
554: {
555: struct xd_softc *xd = (void *) self;
556: struct xdc_softc *xdc = (void *) parent;
557: struct xdc_attach_args *xa = aux;
558: int rqno, err, spt = 0, mb, blk, lcv, fmode, s = 0, newstate;
559: struct xd_iopb_drive *driopb;
560: struct dkbad *dkb;
561: struct bootpath *bp;
562:
563: /*
564: * Always re-initialize the disk structure. We want statistics
565: * to start with a clean slate.
566: */
567: bzero(&xd->sc_dk, sizeof(xd->sc_dk));
568: xd->sc_dk.dk_driver = &xddkdriver;
569: xd->sc_dk.dk_name = xd->sc_dev.dv_xname;
570:
571: /* if booting, init the xd_softc */
572:
573: if (xa->booting) {
574: xd->state = XD_DRIVE_UNKNOWN; /* to start */
575: xd->flags = 0;
576: xd->parent = xdc;
577: }
578: xd->xd_drive = xa->driveno;
579: fmode = xa->fullmode;
580: xdc->sc_drives[xa->driveno] = xd;
581:
582: /* if not booting, make sure we are the only process in the attach for
583: * this drive. if locked out, sleep on it. */
584:
585: if (!xa->booting) {
586: s = splbio();
587: while (xd->state == XD_DRIVE_ATTACHING) {
588: if (tsleep(&xd->state, PRIBIO, "xdattach", 0)) {
589: splx(s);
590: return;
591: }
592: }
593: printf("%s at %s",
594: xd->sc_dev.dv_xname, xd->parent->sc_dev.dv_xname);
595: }
596: /* we now have control */
597:
598: xd->state = XD_DRIVE_ATTACHING;
599: newstate = XD_DRIVE_UNKNOWN;
600:
601: /* first try and reset the drive */
602:
603: rqno = xdc_cmd(xdc, XDCMD_RST, 0, xd->xd_drive, 0, 0, 0, fmode);
604: XDC_DONE(xdc, rqno, err);
605: if (err == XD_ERR_NRDY) {
606: printf(" drive %d: off-line\n", xa->driveno);
607: goto done;
608: }
609: if (err) {
610: printf(": ERROR 0x%02x (%s)\n", err, xdc_e2str(err));
611: goto done;
612: }
613: printf(" drive %d: ready\n", xa->driveno);
614:
615: /* now set format parameters */
616:
617: rqno = xdc_cmd(xdc, XDCMD_WRP, XDFUN_FMT, xd->xd_drive, 0, 0, 0, fmode);
618: XDC_DONE(xdc, rqno, err);
619: if (err) {
620: printf("%s: write format parameters failed: %s\n",
621: xd->sc_dev.dv_xname, xdc_e2str(err));
622: goto done;
623: }
624:
625: /* get drive parameters */
626: rqno = xdc_cmd(xdc, XDCMD_RDP, XDFUN_DRV, xd->xd_drive, 0, 0, 0, fmode);
627: if (rqno != XD_ERR_FAIL) {
628: driopb = (struct xd_iopb_drive *) & xdc->iopbase[rqno];
629: spt = driopb->sectpertrk;
630: }
631: XDC_DONE(xdc, rqno, err);
632: if (err) {
633: printf("%s: read drive parameters failed: %s\n",
634: xd->sc_dev.dv_xname, xdc_e2str(err));
635: goto done;
636: }
637:
638: /*
639: * now set drive parameters (to semi-bogus values) so we can read the
640: * disk label.
641: */
642: xd->pcyl = xd->ncyl = 1;
643: xd->acyl = 0;
644: xd->nhead = 1;
645: xd->nsect = 1;
646: xd->sectpercyl = 1;
647: for (lcv = 0; lcv < NBT_BAD; lcv++) /* init empty bad144 table */
648: xd->dkb.bt_bad[lcv].bt_cyl = xd->dkb.bt_bad[lcv].bt_trksec = 0xffff;
649: rqno = xdc_cmd(xdc, XDCMD_WRP, XDFUN_DRV, xd->xd_drive, 0, 0, 0, fmode);
650: XDC_DONE(xdc, rqno, err);
651: if (err) {
652: printf("%s: write drive parameters failed: %s\n",
653: xd->sc_dev.dv_xname, xdc_e2str(err));
654: goto done;
655: }
656:
657: /* read disk label */
658: rqno = xdc_cmd(xdc, XDCMD_RD, 0, xd->xd_drive, 0, 1, xa->dvmabuf, fmode);
659: XDC_DONE(xdc, rqno, err);
660: if (err) {
661: printf("%s: reading disk label failed: %s\n",
662: xd->sc_dev.dv_xname, xdc_e2str(err));
663: goto done;
664: }
665: newstate = XD_DRIVE_NOLABEL;
666:
667: xd->hw_spt = spt;
668: /* Attach the disk: must be before getdisklabel to malloc label */
669: disk_attach(&xd->sc_dk);
670:
671: if (xdgetdisklabel(xd, xa->buf) != XD_ERR_AOK)
672: goto done;
673:
674: /* inform the user of what is up */
675: printf("%s: <%s>, pcyl %d, hw_spt %d\n", xd->sc_dev.dv_xname,
676: xa->buf, xd->pcyl, spt);
677: mb = xd->ncyl * (xd->nhead * xd->nsect) / (1048576 / XDFM_BPS);
678: printf("%s: %dMB, %d cyl, %d head, %d sec, %d bytes/sec\n",
679: xd->sc_dev.dv_xname, mb, xd->ncyl, xd->nhead, xd->nsect,
680: XDFM_BPS);
681:
682: /* now set the real drive parameters! */
683:
684: rqno = xdc_cmd(xdc, XDCMD_WRP, XDFUN_DRV, xd->xd_drive, 0, 0, 0, fmode);
685: XDC_DONE(xdc, rqno, err);
686: if (err) {
687: printf("%s: write real drive parameters failed: %s\n",
688: xd->sc_dev.dv_xname, xdc_e2str(err));
689: goto done;
690: }
691: newstate = XD_DRIVE_ONLINE;
692:
693: /*
694: * read bad144 table. this table resides on the first sector of the
695: * last track of the disk (i.e. second cyl of "acyl" area).
696: */
697:
698: blk = (xd->ncyl + xd->acyl - 1) * (xd->nhead * xd->nsect) + /* last cyl */
699: (xd->nhead - 1) * xd->nsect; /* last head */
700: rqno = xdc_cmd(xdc, XDCMD_RD, 0, xd->xd_drive, blk, 1, xa->dvmabuf, fmode);
701: XDC_DONE(xdc, rqno, err);
702: if (err) {
703: printf("%s: reading bad144 failed: %s\n",
704: xd->sc_dev.dv_xname, xdc_e2str(err));
705: goto done;
706: }
707:
708: /* check dkbad for sanity */
709: dkb = (struct dkbad *) xa->buf;
710: for (lcv = 0; lcv < NBT_BAD; lcv++) {
711: if ((dkb->bt_bad[lcv].bt_cyl == 0xffff ||
712: dkb->bt_bad[lcv].bt_cyl == 0) &&
713: dkb->bt_bad[lcv].bt_trksec == 0xffff)
714: continue; /* blank */
715: if (dkb->bt_bad[lcv].bt_cyl >= xd->ncyl)
716: break;
717: if ((dkb->bt_bad[lcv].bt_trksec >> 8) >= xd->nhead)
718: break;
719: if ((dkb->bt_bad[lcv].bt_trksec & 0xff) >= xd->nsect)
720: break;
721: }
722: if (lcv != NBT_BAD) {
723: printf("%s: warning: invalid bad144 sector!\n",
724: xd->sc_dev.dv_xname);
725: } else {
726: bcopy(xa->buf, &xd->dkb, XDFM_BPS);
727: }
728:
729: if (xa->booting) {
730: /* restore bootpath! (do this via attach_args again?)*/
731: bp = bootpath_store(0, NULL);
732: if (bp && strcmp("xd", bp->name) == 0 &&
733: xd->xd_drive == bp->val[0])
734: bp->dev = &xd->sc_dev;
735: }
736:
737: done:
738: xd->state = newstate;
739: if (!xa->booting) {
740: wakeup(&xd->state);
741: splx(s);
742: }
743: }
744:
745: /*
746: * end of autoconfig functions
747: */
748:
749: /*
750: * { b , c } d e v s w f u n c t i o n s
751: */
752:
753: /*
754: * xdclose: close device
755: */
756: int
757: xdclose(dev, flag, fmt, p)
758: dev_t dev;
759: int flag, fmt;
760: struct proc *p;
761: {
762: struct xd_softc *xd = xd_cd.cd_devs[DISKUNIT(dev)];
763: int part = DISKPART(dev);
764:
765: /* clear mask bits */
766:
767: switch (fmt) {
768: case S_IFCHR:
769: xd->sc_dk.dk_copenmask &= ~(1 << part);
770: break;
771: case S_IFBLK:
772: xd->sc_dk.dk_bopenmask &= ~(1 << part);
773: break;
774: }
775: xd->sc_dk.dk_openmask = xd->sc_dk.dk_copenmask | xd->sc_dk.dk_bopenmask;
776:
777: return 0;
778: }
779:
780: /*
781: * xddump: crash dump system
782: */
783: int
784: xddump(dev, blkno, va, size)
785: dev_t dev;
786: daddr64_t blkno;
787: caddr_t va;
788: size_t size;
789: {
790: int unit, part;
791: struct xd_softc *xd;
792:
793: unit = DISKUNIT(dev);
794: if (unit >= xd_cd.cd_ndevs)
795: return ENXIO;
796: part = DISKPART(dev);
797:
798: xd = xd_cd.cd_devs[unit];
799:
800: printf("%s%c: crash dump not supported (yet)\n", xd->sc_dev.dv_xname,
801: 'a' + part);
802:
803: return ENXIO;
804:
805: /* outline: globals: "dumplo" == sector number of partition to start
806: * dump at (convert to physical sector with partition table)
807: * "dumpsize" == size of dump in clicks "physmem" == size of physical
808: * memory (clicks, ctob() to get bytes) (normal case: dumpsize ==
809: * physmem)
810: *
811: * dump a copy of physical memory to the dump device starting at sector
812: * "dumplo" in the swap partition (make sure > 0). map in pages as
813: * we go. use polled I/O.
814: *
815: * XXX how to handle NON_CONTIG? */
816:
817: }
818:
819: /*
820: * xdioctl: ioctls on XD drives. based on ioctl's of other netbsd disks.
821: */
822: int
823: xdioctl(dev, command, addr, flag, p)
824: dev_t dev;
825: u_long command;
826: caddr_t addr;
827: int flag;
828: struct proc *p;
829:
830: {
831: struct xd_softc *xd;
832: struct xd_iocmd *xio;
833: int error, s, unit;
834:
835: unit = DISKUNIT(dev);
836:
837: if (unit >= xd_cd.cd_ndevs || (xd = xd_cd.cd_devs[unit]) == NULL)
838: return (ENXIO);
839:
840: /* switch on ioctl type */
841:
842: switch (command) {
843: case DIOCSBAD: /* set bad144 info */
844: if ((flag & FWRITE) == 0)
845: return EBADF;
846: s = splbio();
847: bcopy(addr, &xd->dkb, sizeof(xd->dkb));
848: splx(s);
849: return 0;
850:
851: case DIOCGDINFO: /* get disk label */
852: bcopy(xd->sc_dk.dk_label, addr, sizeof(struct disklabel));
853: return 0;
854:
855: case DIOCGPART: /* get partition info */
856: ((struct partinfo *) addr)->disklab = xd->sc_dk.dk_label;
857: ((struct partinfo *) addr)->part =
858: &xd->sc_dk.dk_label->d_partitions[DISKPART(dev)];
859: return 0;
860:
861: case DIOCSDINFO: /* set disk label */
862: if ((flag & FWRITE) == 0)
863: return EBADF;
864: error = setdisklabel(xd->sc_dk.dk_label,
865: (struct disklabel *) addr, /* xd->sc_dk.dk_openmask : */ 0);
866: if (error == 0) {
867: if (xd->state == XD_DRIVE_NOLABEL)
868: xd->state = XD_DRIVE_ONLINE;
869: }
870: return error;
871:
872: case DIOCWLABEL: /* change write status of disk label */
873: if ((flag & FWRITE) == 0)
874: return EBADF;
875: if (*(int *) addr)
876: xd->flags |= XD_WLABEL;
877: else
878: xd->flags &= ~XD_WLABEL;
879: return 0;
880:
881: case DIOCWDINFO: /* write disk label */
882: if ((flag & FWRITE) == 0)
883: return EBADF;
884: error = setdisklabel(xd->sc_dk.dk_label,
885: (struct disklabel *) addr, /* xd->sc_dk.dk_openmask : */ 0);
886: if (error == 0) {
887: if (xd->state == XD_DRIVE_NOLABEL)
888: xd->state = XD_DRIVE_ONLINE;
889:
890: /* Simulate opening partition 0 so write succeeds. */
891: xd->sc_dk.dk_openmask |= (1 << 0);
892: error = writedisklabel(DISKLABELDEV(dev), xdstrategy,
893: xd->sc_dk.dk_label);
894: xd->sc_dk.dk_openmask =
895: xd->sc_dk.dk_copenmask | xd->sc_dk.dk_bopenmask;
896: }
897: return error;
898:
899: case DIOSXDCMD:
900: xio = (struct xd_iocmd *) addr;
901: if ((error = suser(p, 0)) != 0)
902: return (error);
903: return (xdc_ioctlcmd(xd, dev, xio));
904:
905: default:
906: return ENOTTY;
907: }
908: }
909: /*
910: * xdopen: open drive
911: */
912:
913: int
914: xdopen(dev, flag, fmt, p)
915: dev_t dev;
916: int flag, fmt;
917: struct proc *p;
918: {
919: int unit, part;
920: struct xd_softc *xd;
921: struct xdc_attach_args xa;
922:
923: /* first, could it be a valid target? */
924:
925: unit = DISKUNIT(dev);
926: if (unit >= xd_cd.cd_ndevs || (xd = xd_cd.cd_devs[unit]) == NULL)
927: return (ENXIO);
928: part = DISKPART(dev);
929:
930: /* do we need to attach the drive? */
931:
932: if (xd->state == XD_DRIVE_UNKNOWN) {
933: xa.driveno = xd->xd_drive;
934: xa.dvmabuf = (char *)dvma_malloc(XDFM_BPS, &xa.buf, M_NOWAIT);
935: xa.fullmode = XD_SUB_WAIT;
936: xa.booting = 0;
937: xdattach((struct device *) xd->parent, (struct device *) xd, &xa);
938: dvma_free(xa.dvmabuf, XDFM_BPS, &xa.buf);
939: if (xd->state == XD_DRIVE_UNKNOWN) {
940: return (EIO);
941: }
942: }
943: /* check for partition */
944:
945: if (part != RAW_PART &&
946: (part >= xd->sc_dk.dk_label->d_npartitions ||
947: xd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
948: return (ENXIO);
949: }
950: /* set open masks */
951:
952: switch (fmt) {
953: case S_IFCHR:
954: xd->sc_dk.dk_copenmask |= (1 << part);
955: break;
956: case S_IFBLK:
957: xd->sc_dk.dk_bopenmask |= (1 << part);
958: break;
959: }
960: xd->sc_dk.dk_openmask = xd->sc_dk.dk_copenmask | xd->sc_dk.dk_bopenmask;
961:
962: return 0;
963: }
964:
965: int
966: xdread(dev, uio, flags)
967: dev_t dev;
968: struct uio *uio;
969: int flags;
970: {
971:
972: return (physio(xdstrategy, NULL, dev, B_READ, minphys, uio));
973: }
974:
975: int
976: xdwrite(dev, uio, flags)
977: dev_t dev;
978: struct uio *uio;
979: int flags;
980: {
981:
982: return (physio(xdstrategy, NULL, dev, B_WRITE, minphys, uio));
983: }
984:
985:
986: /*
987: * xdsize: return size of a partition for a dump
988: */
989:
990: daddr64_t
991: xdsize(dev)
992: dev_t dev;
993:
994: {
995: struct xd_softc *xdsc;
996: int unit, part, size, omask;
997:
998: /* valid unit? */
999: unit = DISKUNIT(dev);
1000: if (unit >= xd_cd.cd_ndevs || (xdsc = xd_cd.cd_devs[unit]) == NULL)
1001: return (-1);
1002:
1003: part = DISKPART(dev);
1004: omask = xdsc->sc_dk.dk_openmask & (1 << part);
1005:
1006: if (omask == 0 && xdopen(dev, 0, S_IFBLK, NULL) != 0)
1007: return (-1);
1008:
1009: /* do it */
1010: if (xdsc->sc_dk.dk_label->d_partitions[part].p_fstype != FS_SWAP)
1011: size = -1; /* only give valid size for swap partitions */
1012: else
1013: size = DL_GETPSIZE(&xdsc->sc_dk.dk_label->d_partitions[part]) *
1014: (xdsc->sc_dk.dk_label->d_secsize / DEV_BSIZE);
1015: if (omask == 0 && xdclose(dev, 0, S_IFBLK, NULL) != 0)
1016: return (-1);
1017: return (size);
1018: }
1019: /*
1020: * xdstrategy: buffering system interface to xd.
1021: */
1022:
1023: void
1024: xdstrategy(bp)
1025: struct buf *bp;
1026:
1027: {
1028: struct xd_softc *xd;
1029: struct xdc_softc *parent;
1030: struct buf *wq;
1031: int s, unit;
1032: struct xdc_attach_args xa;
1033:
1034: unit = DISKUNIT(bp->b_dev);
1035:
1036: /* check for live device */
1037:
1038: if (unit >= xd_cd.cd_ndevs || (xd = xd_cd.cd_devs[unit]) == 0 ||
1039: bp->b_blkno < 0 ||
1040: (bp->b_bcount % xd->sc_dk.dk_label->d_secsize) != 0) {
1041: bp->b_error = EINVAL;
1042: goto bad;
1043: }
1044: /* do we need to attach the drive? */
1045:
1046: if (xd->state == XD_DRIVE_UNKNOWN) {
1047: xa.driveno = xd->xd_drive;
1048: xa.dvmabuf = (char *)dvma_malloc(XDFM_BPS, &xa.buf, M_NOWAIT);
1049: xa.fullmode = XD_SUB_WAIT;
1050: xa.booting = 0;
1051: xdattach((struct device *)xd->parent, (struct device *)xd, &xa);
1052: dvma_free(xa.dvmabuf, XDFM_BPS, &xa.buf);
1053: if (xd->state == XD_DRIVE_UNKNOWN) {
1054: bp->b_error = EIO;
1055: goto bad;
1056: }
1057: }
1058: if (xd->state != XD_DRIVE_ONLINE && DISKPART(bp->b_dev) != RAW_PART) {
1059: /* no I/O to unlabeled disks, unless raw partition */
1060: bp->b_error = EIO;
1061: goto bad;
1062: }
1063: /* short circuit zero length request */
1064:
1065: if (bp->b_bcount == 0)
1066: goto done;
1067:
1068: /* check bounds with label (disksubr.c). Determine the size of the
1069: * transfer, and make sure it is within the boundaries of the
1070: * partition. Adjust transfer if needed, and signal errors or early
1071: * completion. */
1072:
1073: if (bounds_check_with_label(bp, xd->sc_dk.dk_label,
1074: (xd->flags & XD_WLABEL) != 0) <= 0)
1075: goto done;
1076:
1077: /*
1078: * now we know we have a valid buf structure that we need to do I/O
1079: * on.
1080: *
1081: * note that we don't disksort because the controller has a sorting
1082: * algorithm built into the hardware.
1083: */
1084:
1085: s = splbio(); /* protect the queues */
1086:
1087: /* first, give jobs in front of us a chance */
1088: parent = xd->parent;
1089: while (parent->nfree > 0 && parent->sc_wq.b_actf)
1090: if (xdc_startbuf(parent, NULL, NULL) != XD_ERR_AOK)
1091: break;
1092:
1093: /* if there are no free iorq's, then we just queue and return. the
1094: * buffs will get picked up later by xdcintr().
1095: */
1096:
1097: if (parent->nfree == 0) {
1098: wq = &xd->parent->sc_wq;
1099: bp->b_actf = 0;
1100: bp->b_actb = wq->b_actb;
1101: *wq->b_actb = bp;
1102: wq->b_actb = &bp->b_actf;
1103: splx(s);
1104: return;
1105: }
1106:
1107: /* now we have free iopb's and we are at splbio... start 'em up */
1108: if (xdc_startbuf(parent, xd, bp) != XD_ERR_AOK) {
1109: splx(s);
1110: return;
1111: }
1112:
1113: /* done! */
1114:
1115: splx(s);
1116: return;
1117:
1118: bad: /* tells upper layers we have an error */
1119: bp->b_flags |= B_ERROR;
1120: done: /* tells upper layers we are done with this
1121: * buf */
1122: bp->b_resid = bp->b_bcount;
1123: s = splbio();
1124: biodone(bp);
1125: splx(s);
1126: }
1127: /*
1128: * end of {b,c}devsw functions
1129: */
1130:
1131: /*
1132: * i n t e r r u p t f u n c t i o n
1133: *
1134: * xdcintr: hardware interrupt.
1135: */
1136: int
1137: xdcintr(v)
1138: void *v;
1139:
1140: {
1141: struct xdc_softc *xdcsc = v;
1142:
1143: /* remove as many done IOPBs as possible */
1144:
1145: xdc_remove_iorq(xdcsc);
1146:
1147: /* start any iorq's already waiting */
1148:
1149: xdc_start(xdcsc, XDC_MAXIOPB);
1150:
1151: /* fill up any remaining iorq's with queue'd buffers */
1152:
1153: while (xdcsc->nfree > 0 && xdcsc->sc_wq.b_actf)
1154: if (xdc_startbuf(xdcsc, NULL, NULL) != XD_ERR_AOK)
1155: break;
1156:
1157: return (1);
1158: }
1159: /*
1160: * end of interrupt function
1161: */
1162:
1163: /*
1164: * i n t e r n a l f u n c t i o n s
1165: */
1166:
1167: /*
1168: * xdc_rqinit: fill out the fields of an I/O request
1169: */
1170:
1171: inline void
1172: xdc_rqinit(rq, xdc, xd, md, blk, cnt, db, bp)
1173: struct xd_iorq *rq;
1174: struct xdc_softc *xdc;
1175: struct xd_softc *xd;
1176: int md;
1177: u_long blk;
1178: int cnt;
1179: caddr_t db;
1180: struct buf *bp;
1181: {
1182: rq->xdc = xdc;
1183: rq->xd = xd;
1184: rq->ttl = XDC_MAXTTL + 10;
1185: rq->mode = md;
1186: rq->tries = rq->errno = rq->lasterror = 0;
1187: rq->blockno = blk;
1188: rq->sectcnt = cnt;
1189: rq->dbuf = rq->dbufbase = db;
1190: rq->buf = bp;
1191: }
1192: /*
1193: * xdc_rqtopb: load up an IOPB based on an iorq
1194: */
1195:
1196: void
1197: xdc_rqtopb(iorq, iopb, cmd, subfun)
1198: struct xd_iorq *iorq;
1199: struct xd_iopb *iopb;
1200: int cmd, subfun;
1201:
1202: {
1203: u_long block, dp;
1204:
1205: /* standard stuff */
1206:
1207: iopb->errs = iopb->done = 0;
1208: iopb->comm = cmd;
1209: iopb->errno = iopb->status = 0;
1210: iopb->subfun = subfun;
1211: if (iorq->xd)
1212: iopb->unit = iorq->xd->xd_drive;
1213: else
1214: iopb->unit = 0;
1215:
1216: /* check for alternate IOPB format */
1217:
1218: if (cmd == XDCMD_WRP) {
1219: switch (subfun) {
1220: case XDFUN_CTL:{
1221: struct xd_iopb_ctrl *ctrl =
1222: (struct xd_iopb_ctrl *) iopb;
1223: iopb->lll = 0;
1224: iopb->intl = (XD_STATE(iorq->mode) == XD_SUB_POLL)
1225: ? 0
1226: : iorq->xdc->ipl;
1227: ctrl->param_a = XDPA_TMOD | XDPA_DACF;
1228: ctrl->param_b = XDPB_ROR | XDPB_TDT_3_2USEC;
1229: ctrl->param_c = XDPC_OVS | XDPC_COP | XDPC_ASR |
1230: XDPC_RBC | XDPC_ECC2;
1231: ctrl->throttle = XDC_THROTTLE;
1232: #ifdef __sparc__
1233: if (CPU_ISSUN4 && cpuinfo.cpu_type == CPUTYP_4_300)
1234: ctrl->delay = XDC_DELAY_4_300;
1235: else
1236: ctrl->delay = XDC_DELAY_SPARC;
1237: #endif
1238: #ifdef sun3
1239: ctrl->delay = XDC_DELAY_SUN3;
1240: #endif
1241: break;
1242: }
1243: case XDFUN_DRV:{
1244: struct xd_iopb_drive *drv =
1245: (struct xd_iopb_drive *)iopb;
1246: /* we assume that the disk label has the right
1247: * info */
1248: if (XD_STATE(iorq->mode) == XD_SUB_POLL)
1249: drv->dparam_ipl = (XDC_DPARAM << 3);
1250: else
1251: drv->dparam_ipl = (XDC_DPARAM << 3) |
1252: iorq->xdc->ipl;
1253: drv->maxsect = iorq->xd->nsect - 1;
1254: drv->maxsector = drv->maxsect;
1255: /* note: maxsector != maxsect only if you are
1256: * doing cyl sparing */
1257: drv->headoff = 0;
1258: drv->maxcyl = iorq->xd->pcyl - 1;
1259: drv->maxhead = iorq->xd->nhead - 1;
1260: break;
1261: }
1262: case XDFUN_FMT:{
1263: struct xd_iopb_format *form =
1264: (struct xd_iopb_format *) iopb;
1265: if (XD_STATE(iorq->mode) == XD_SUB_POLL)
1266: form->interleave_ipl = (XDC_INTERLEAVE << 3);
1267: else
1268: form->interleave_ipl = (XDC_INTERLEAVE << 3) |
1269: iorq->xdc->ipl;
1270: form->field1 = XDFM_FIELD1;
1271: form->field2 = XDFM_FIELD2;
1272: form->field3 = XDFM_FIELD3;
1273: form->field4 = XDFM_FIELD4;
1274: form->bytespersec = XDFM_BPS;
1275: form->field6 = XDFM_FIELD6;
1276: form->field7 = XDFM_FIELD7;
1277: break;
1278: }
1279: }
1280: } else {
1281:
1282: /* normal IOPB case (harmless to RDP command) */
1283:
1284: iopb->lll = 0;
1285: iopb->intl = (XD_STATE(iorq->mode) == XD_SUB_POLL)
1286: ? 0
1287: : iorq->xdc->ipl;
1288: iopb->sectcnt = iorq->sectcnt;
1289: block = iorq->blockno;
1290: if (iorq->xd == NULL || block == 0) {
1291: iopb->sectno = iopb->headno = iopb->cylno = 0;
1292: } else {
1293: iopb->sectno = block % iorq->xd->nsect;
1294: block = block / iorq->xd->nsect;
1295: iopb->headno = block % iorq->xd->nhead;
1296: block = block / iorq->xd->nhead;
1297: iopb->cylno = block;
1298: }
1299: dp = (u_long) iorq->dbuf - DVMA_BASE;
1300: dp = iopb->daddr = (iorq->dbuf == NULL) ? 0 : dp;
1301: iopb->addrmod = ((dp + (XDFM_BPS * iorq->sectcnt)) > 0x1000000)
1302: ? XDC_ADDRMOD32
1303: : XDC_ADDRMOD;
1304: }
1305: }
1306:
1307: /*
1308: * xdc_cmd: front end for POLL'd and WAIT'd commands. Returns rqno.
1309: * If you've already got an IORQ, you can call submit directly (currently
1310: * there is no need to do this). NORM requests are handled separately.
1311: */
1312: int
1313: xdc_cmd(xdcsc, cmd, subfn, unit, block, scnt, dptr, fullmode)
1314: struct xdc_softc *xdcsc;
1315: int cmd, subfn, unit, block, scnt;
1316: char *dptr;
1317: int fullmode;
1318:
1319: {
1320: int rqno, submode = XD_STATE(fullmode), retry;
1321: struct xd_iorq *iorq;
1322: struct xd_iopb *iopb;
1323:
1324: /* get iorq/iopb */
1325: switch (submode) {
1326: case XD_SUB_POLL:
1327: while (xdcsc->nfree == 0) {
1328: if (xdc_piodriver(xdcsc, 0, 1) != XD_ERR_AOK)
1329: return (XD_ERR_FAIL);
1330: }
1331: break;
1332: case XD_SUB_WAIT:
1333: retry = 1;
1334: while (retry) {
1335: while (xdcsc->nfree == 0) {
1336: if (tsleep(&xdcsc->nfree, PRIBIO, "xdnfree", 0))
1337: return (XD_ERR_FAIL);
1338: }
1339: while (xdcsc->ndone > XDC_SUBWAITLIM) {
1340: if (tsleep(&xdcsc->ndone, PRIBIO, "xdsubwait", 0))
1341: return (XD_ERR_FAIL);
1342: }
1343: if (xdcsc->nfree)
1344: retry = 0; /* got it */
1345: }
1346: break;
1347: default:
1348: return (XD_ERR_FAIL); /* illegal */
1349: }
1350: if (xdcsc->nfree == 0)
1351: panic("xdcmd nfree");
1352: rqno = XDC_RQALLOC(xdcsc);
1353: iorq = &xdcsc->reqs[rqno];
1354: iopb = iorq->iopb;
1355:
1356:
1357: /* init iorq/iopb */
1358:
1359: xdc_rqinit(iorq, xdcsc,
1360: (unit == XDC_NOUNIT) ? NULL : xdcsc->sc_drives[unit],
1361: fullmode, block, scnt, dptr, NULL);
1362:
1363: /* load IOPB from iorq */
1364:
1365: xdc_rqtopb(iorq, iopb, cmd, subfn);
1366:
1367: /* submit it for processing */
1368:
1369: xdc_submit_iorq(xdcsc, rqno, fullmode); /* error code will be in iorq */
1370:
1371: return (rqno);
1372: }
1373: /*
1374: * xdc_startbuf
1375: * start a buffer running, assumes nfree > 0
1376: */
1377:
1378: int
1379: xdc_startbuf(xdcsc, xdsc, bp)
1380: struct xdc_softc *xdcsc;
1381: struct xd_softc *xdsc;
1382: struct buf *bp;
1383:
1384: {
1385: int rqno, partno;
1386: struct xd_iorq *iorq;
1387: struct xd_iopb *iopb;
1388: struct buf *wq;
1389: u_long block;
1390: caddr_t dbuf;
1391:
1392: if (!xdcsc->nfree)
1393: panic("xdc_startbuf free");
1394: rqno = XDC_RQALLOC(xdcsc);
1395: iorq = &xdcsc->reqs[rqno];
1396: iopb = iorq->iopb;
1397:
1398: /* get buf */
1399:
1400: if (bp == NULL) {
1401: bp = xdcsc->sc_wq.b_actf;
1402: if (!bp)
1403: panic("xdc_startbuf bp");
1404: wq = bp->b_actf;
1405: if (wq)
1406: wq->b_actb = bp->b_actb;
1407: else
1408: xdcsc->sc_wq.b_actb = bp->b_actb;
1409: *bp->b_actb = wq;
1410: xdsc = xdcsc->sc_drives[DISKUNIT(bp->b_dev)];
1411: }
1412: partno = DISKPART(bp->b_dev);
1413: #ifdef XDC_DEBUG
1414: printf("xdc_startbuf: %s%c: %s block %lld\n",
1415: xdsc->sc_dev.dv_xname, 'a' + partno,
1416: (bp->b_flags & B_READ) ? "read" : "write", bp->b_blkno);
1417: printf("xdc_startbuf: b_bcount %d, b_data 0x%x\n",
1418: bp->b_bcount, bp->b_data);
1419: #endif
1420:
1421: /*
1422: * load request. we have to calculate the correct block number based
1423: * on partition info.
1424: *
1425: * note that iorq points to the buffer as mapped into DVMA space,
1426: * where as the bp->b_data points to its non-DVMA mapping.
1427: */
1428:
1429: block = bp->b_blkno + ((partno == RAW_PART) ? 0 :
1430: DL_GETPOFFSET(&xdsc->sc_dk.dk_label->d_partitions[partno]));
1431:
1432: dbuf = kdvma_mapin(bp->b_data, bp->b_bcount, 0);
1433: if (dbuf == NULL) { /* out of DVMA space */
1434: printf("%s: warning: out of DVMA space\n",
1435: xdcsc->sc_dev.dv_xname);
1436: XDC_FREE(xdcsc, rqno);
1437: wq = &xdcsc->sc_wq; /* put at end of queue */
1438: bp->b_actf = 0;
1439: bp->b_actb = wq->b_actb;
1440: *wq->b_actb = bp;
1441: wq->b_actb = &bp->b_actf;
1442: return (XD_ERR_FAIL); /* XXX: need some sort of
1443: * call-back scheme here? */
1444: }
1445:
1446: /* init iorq and load iopb from it */
1447:
1448: xdc_rqinit(iorq, xdcsc, xdsc, XD_SUB_NORM | XD_MODE_VERBO, block,
1449: bp->b_bcount / XDFM_BPS, dbuf, bp);
1450:
1451: xdc_rqtopb(iorq, iopb, (bp->b_flags & B_READ) ? XDCMD_RD : XDCMD_WR, 0);
1452:
1453: /* Instrumentation. */
1454: disk_busy(&xdsc->sc_dk);
1455:
1456: /* now submit [note that xdc_submit_iorq can never fail on NORM reqs] */
1457:
1458: xdc_submit_iorq(xdcsc, rqno, XD_SUB_NORM);
1459: return (XD_ERR_AOK);
1460: }
1461:
1462:
1463: /*
1464: * xdc_submit_iorq: submit an iorq for processing. returns XD_ERR_AOK
1465: * if ok. if it fail returns an error code. type is XD_SUB_*.
1466: *
1467: * note: caller frees iorq in all cases except NORM
1468: *
1469: * return value:
1470: * NORM: XD_AOK (req pending), XD_FAIL (couldn't submit request)
1471: * WAIT: XD_AOK (success), <error-code> (failed)
1472: * POLL: <same as WAIT>
1473: * NOQ : <same as NORM>
1474: *
1475: * there are three sources for i/o requests:
1476: * [1] xdstrategy: normal block I/O, using "struct buf" system.
1477: * [2] autoconfig/crash dump: these are polled I/O requests, no interrupts.
1478: * [3] open/ioctl: these are I/O requests done in the context of a process,
1479: * and the process should block until they are done.
1480: *
1481: * software state is stored in the iorq structure. each iorq has an
1482: * iopb structure. the hardware understands the iopb structure.
1483: * every command must go through an iopb. a 7053 can only handle
1484: * XDC_MAXIOPB (31) active iopbs at one time. iopbs are allocated in
1485: * DVMA space at boot up time. what happens if we run out of iopb's?
1486: * for i/o type [1], the buffers are queued at the "buff" layer and
1487: * picked up later by the interrupt routine. for case [2] the
1488: * programmed i/o driver is called with a special flag that says
1489: * return when one iopb is free. for case [3] the process can sleep
1490: * on the iorq free list until some iopbs are available.
1491: */
1492:
1493:
1494: int
1495: xdc_submit_iorq(xdcsc, iorqno, type)
1496: struct xdc_softc *xdcsc;
1497: int iorqno;
1498: int type;
1499:
1500: {
1501: u_long iopbaddr;
1502: struct xd_iorq *iorq = &xdcsc->reqs[iorqno];
1503:
1504: #ifdef XDC_DEBUG
1505: printf("xdc_submit_iorq(%s, no=%d, type=%d)\n", xdcsc->sc_dev.dv_xname,
1506: iorqno, type);
1507: #endif
1508:
1509: /* first check and see if controller is busy */
1510: if (xdcsc->xdc->xdc_csr & XDC_ADDING) {
1511: #ifdef XDC_DEBUG
1512: printf("xdc_submit_iorq: XDC not ready (ADDING)\n");
1513: #endif
1514: if (type == XD_SUB_NOQ)
1515: return (XD_ERR_FAIL); /* failed */
1516: XDC_TWAIT(xdcsc, iorqno); /* put at end of waitq */
1517: switch (type) {
1518: case XD_SUB_NORM:
1519: return XD_ERR_AOK; /* success */
1520: case XD_SUB_WAIT:
1521: while (iorq->iopb->done == 0) {
1522: tsleep(iorq, PRIBIO, "xdiorq", 0);
1523: }
1524: return (iorq->errno);
1525: case XD_SUB_POLL:
1526: return (xdc_piodriver(xdcsc, iorqno, 0));
1527: default:
1528: panic("xdc_submit_iorq adding");
1529: }
1530: }
1531: #ifdef XDC_DEBUG
1532: {
1533: u_char *rio = (u_char *) iorq->iopb;
1534: int sz = sizeof(struct xd_iopb), lcv;
1535: printf("%s: aio #%d [",
1536: xdcsc->sc_dev.dv_xname, iorq - xdcsc->reqs);
1537: for (lcv = 0; lcv < sz; lcv++)
1538: printf(" %02x", rio[lcv]);
1539: printf("]\n");
1540: }
1541: #endif /* XDC_DEBUG */
1542:
1543: /* controller not busy, start command */
1544: iopbaddr = (u_long) iorq->iopb - (u_long) DVMA_BASE;
1545: XDC_GO(xdcsc->xdc, iopbaddr); /* go! */
1546: xdcsc->nrun++;
1547: /* command now running, wrap it up */
1548: switch (type) {
1549: case XD_SUB_NORM:
1550: case XD_SUB_NOQ:
1551: return (XD_ERR_AOK); /* success */
1552: case XD_SUB_WAIT:
1553: while (iorq->iopb->done == 0) {
1554: tsleep(iorq, PRIBIO, "xdiorq", 0);
1555: }
1556: return (iorq->errno);
1557: case XD_SUB_POLL:
1558: return (xdc_piodriver(xdcsc, iorqno, 0));
1559: default:
1560: panic("xdc_submit_iorq wrap up");
1561: }
1562: panic("xdc_submit_iorq");
1563: return 0; /* not reached */
1564: }
1565:
1566:
1567: /*
1568: * xdc_piodriver
1569: *
1570: * programmed i/o driver. this function takes over the computer
1571: * and drains off all i/o requests. it returns the status of the iorq
1572: * the caller is interesting in. if freeone is true, then it returns
1573: * when there is a free iorq.
1574: */
1575: int
1576: xdc_piodriver(xdcsc, iorqno, freeone)
1577: struct xdc_softc *xdcsc;
1578: int iorqno;
1579: int freeone;
1580:
1581: {
1582: int nreset = 0;
1583: int retval = 0;
1584: u_long count;
1585: struct xdc *xdc = xdcsc->xdc;
1586: #ifdef XDC_DEBUG
1587: printf("xdc_piodriver(%s, %d, freeone=%d)\n", xdcsc->sc_dev.dv_xname,
1588: iorqno, freeone);
1589: #endif
1590:
1591: while (xdcsc->nwait || xdcsc->nrun) {
1592: #ifdef XDC_DEBUG
1593: printf("xdc_piodriver: wait=%d, run=%d\n",
1594: xdcsc->nwait, xdcsc->nrun);
1595: #endif
1596: XDC_WAIT(xdc, count, XDC_MAXTIME, (XDC_REMIOPB | XDC_F_ERROR));
1597: #ifdef XDC_DEBUG
1598: printf("xdc_piodriver: done wait with count = %d\n", count);
1599: #endif
1600: /* we expect some progress soon */
1601: if (count == 0 && nreset >= 2) {
1602: xdc_reset(xdcsc, 0, XD_RSET_ALL, XD_ERR_FAIL, 0);
1603: #ifdef XDC_DEBUG
1604: printf("xdc_piodriver: timeout\n");
1605: #endif
1606: return (XD_ERR_FAIL);
1607: }
1608: if (count == 0) {
1609: if (xdc_reset(xdcsc, 0,
1610: (nreset++ == 0) ? XD_RSET_NONE : iorqno,
1611: XD_ERR_FAIL,
1612: 0) == XD_ERR_FAIL)
1613: return (XD_ERR_FAIL); /* flushes all but POLL
1614: * requests, resets */
1615: continue;
1616: }
1617: xdc_remove_iorq(xdcsc); /* could resubmit request */
1618: if (freeone) {
1619: if (xdcsc->nrun < XDC_MAXIOPB) {
1620: #ifdef XDC_DEBUG
1621: printf("xdc_piodriver: done: one free\n");
1622: #endif
1623: return (XD_ERR_AOK);
1624: }
1625: continue; /* don't xdc_start */
1626: }
1627: xdc_start(xdcsc, XDC_MAXIOPB);
1628: }
1629:
1630: /* get return value */
1631:
1632: retval = xdcsc->reqs[iorqno].errno;
1633:
1634: #ifdef XDC_DEBUG
1635: printf("xdc_piodriver: done, retval = 0x%x (%s)\n",
1636: xdcsc->reqs[iorqno].errno, xdc_e2str(xdcsc->reqs[iorqno].errno));
1637: #endif
1638:
1639: /* now that we've drained everything, start up any bufs that have
1640: * queued */
1641:
1642: while (xdcsc->nfree > 0 && xdcsc->sc_wq.b_actf)
1643: if (xdc_startbuf(xdcsc, NULL, NULL) != XD_ERR_AOK)
1644: break;
1645:
1646: return (retval);
1647: }
1648:
1649: /*
1650: * xdc_reset: reset one drive. NOTE: assumes xdc was just reset.
1651: * we steal iopb[0] for this, but we put it back when we are done.
1652: */
1653: void
1654: xdc_xdreset(xdcsc, xdsc)
1655: struct xdc_softc *xdcsc;
1656: struct xd_softc *xdsc;
1657:
1658: {
1659: struct xd_iopb tmpiopb;
1660: u_long addr;
1661: int del;
1662: bcopy(xdcsc->iopbase, &tmpiopb, sizeof(tmpiopb));
1663: bzero(xdcsc->iopbase, sizeof(tmpiopb));
1664: xdcsc->iopbase->comm = XDCMD_RST;
1665: xdcsc->iopbase->unit = xdsc->xd_drive;
1666: addr = (u_long) xdcsc->dvmaiopb;
1667: XDC_GO(xdcsc->xdc, addr); /* go! */
1668: XDC_WAIT(xdcsc->xdc, del, XDC_RESETUSEC, XDC_REMIOPB);
1669: if (del <= 0 || xdcsc->iopbase->errs) {
1670: printf("%s: off-line: %s\n", xdcsc->sc_dev.dv_xname,
1671: xdc_e2str(xdcsc->iopbase->errno));
1672: xdcsc->xdc->xdc_csr = XDC_RESET;
1673: XDC_WAIT(xdcsc->xdc, del, XDC_RESETUSEC, XDC_RESET);
1674: if (del <= 0)
1675: panic("xdc_reset");
1676: } else {
1677: xdcsc->xdc->xdc_csr = XDC_CLRRIO; /* clear RIO */
1678: }
1679: bcopy(&tmpiopb, xdcsc->iopbase, sizeof(tmpiopb));
1680: }
1681:
1682:
1683: /*
1684: * xdc_reset: reset everything: requests are marked as errors except
1685: * a polled request (which is resubmitted)
1686: */
1687: int
1688: xdc_reset(xdcsc, quiet, blastmode, error, xdsc)
1689: struct xdc_softc *xdcsc;
1690: int quiet, blastmode, error;
1691: struct xd_softc *xdsc;
1692:
1693: {
1694: int del = 0, lcv, retval = XD_ERR_AOK;
1695: int oldfree = xdcsc->nfree;
1696:
1697: /* soft reset hardware */
1698:
1699: if (!quiet)
1700: printf("%s: soft reset\n", xdcsc->sc_dev.dv_xname);
1701: xdcsc->xdc->xdc_csr = XDC_RESET;
1702: XDC_WAIT(xdcsc->xdc, del, XDC_RESETUSEC, XDC_RESET);
1703: if (del <= 0) {
1704: blastmode = XD_RSET_ALL; /* dead, flush all requests */
1705: retval = XD_ERR_FAIL;
1706: }
1707: if (xdsc)
1708: xdc_xdreset(xdcsc, xdsc);
1709:
1710: /* fix queues based on "blast-mode" */
1711:
1712: for (lcv = 0; lcv < XDC_MAXIOPB; lcv++) {
1713: struct xd_iorq *iorq = &xdcsc->reqs[lcv];
1714:
1715: if (XD_STATE(iorq->mode) != XD_SUB_POLL &&
1716: XD_STATE(iorq->mode) != XD_SUB_WAIT &&
1717: XD_STATE(iorq->mode) != XD_SUB_NORM)
1718: /* is it active? */
1719: continue;
1720:
1721: xdcsc->nrun--; /* it isn't running any more */
1722: if (blastmode == XD_RSET_ALL || blastmode != lcv) {
1723: /* failed */
1724: iorq->errno = error;
1725: xdcsc->iopbase[lcv].done = xdcsc->iopbase[lcv].errs = 1;
1726: switch (XD_STATE(xdcsc->reqs[lcv].mode)) {
1727: case XD_SUB_NORM:
1728: iorq->buf->b_error = EIO;
1729: iorq->buf->b_flags |= B_ERROR;
1730: iorq->buf->b_resid =
1731: iorq->sectcnt * XDFM_BPS;
1732: dvma_mapout((vaddr_t)iorq->dbufbase,
1733: (vaddr_t)iorq->buf->b_data,
1734: iorq->buf->b_bcount);
1735: disk_unbusy(&xdcsc->reqs[lcv].xd->sc_dk,
1736: (xdcsc->reqs[lcv].buf->b_bcount -
1737: xdcsc->reqs[lcv].buf->b_resid),
1738: (xdcsc->reqs[lcv].buf->b_flags & B_READ));
1739: biodone(iorq->buf);
1740: XDC_FREE(xdcsc, lcv); /* add to free list */
1741: break;
1742: case XD_SUB_WAIT:
1743: wakeup(iorq);
1744: case XD_SUB_POLL:
1745: xdcsc->ndone++;
1746: iorq->mode =
1747: XD_NEWSTATE(iorq->mode, XD_SUB_DONE);
1748: break;
1749: }
1750:
1751: } else {
1752:
1753: /* resubmit, put at front of wait queue */
1754: XDC_HWAIT(xdcsc, lcv);
1755: }
1756: }
1757:
1758: /*
1759: * now, if stuff is waiting, start it.
1760: * since we just reset it should go
1761: */
1762: xdc_start(xdcsc, XDC_MAXIOPB);
1763:
1764: /* ok, we did it */
1765: if (oldfree == 0 && xdcsc->nfree)
1766: wakeup(&xdcsc->nfree);
1767:
1768: #ifdef XDC_DIAG
1769: del = xdcsc->nwait + xdcsc->nrun + xdcsc->nfree + xdcsc->ndone;
1770: if (del != XDC_MAXIOPB)
1771: printf("%s: diag: xdc_reset miscount (%d should be %d)!\n",
1772: xdcsc->sc_dev.dv_xname, del, XDC_MAXIOPB);
1773: else
1774: if (xdcsc->ndone > XDC_MAXIOPB - XDC_SUBWAITLIM)
1775: printf("%s: diag: lots of done jobs (%d)\n",
1776: xdcsc->sc_dev.dv_xname, xdcsc->ndone);
1777: #endif
1778: printf("RESET DONE\n");
1779: return (retval);
1780: }
1781: /*
1782: * xdc_start: start all waiting buffers
1783: */
1784:
1785: void
1786: xdc_start(xdcsc, maxio)
1787: struct xdc_softc *xdcsc;
1788: int maxio;
1789:
1790: {
1791: int rqno;
1792: while (maxio && xdcsc->nwait &&
1793: (xdcsc->xdc->xdc_csr & XDC_ADDING) == 0) {
1794: XDC_GET_WAITER(xdcsc, rqno); /* note: rqno is an "out"
1795: * param */
1796: if (xdc_submit_iorq(xdcsc, rqno, XD_SUB_NOQ) != XD_ERR_AOK)
1797: panic("xdc_start"); /* should never happen */
1798: maxio--;
1799: }
1800: }
1801: /*
1802: * xdc_remove_iorq: remove "done" IOPB's.
1803: */
1804:
1805: int
1806: xdc_remove_iorq(xdcsc)
1807: struct xdc_softc *xdcsc;
1808:
1809: {
1810: int errno, rqno, comm, errs;
1811: struct xdc *xdc = xdcsc->xdc;
1812: struct xd_iopb *iopb;
1813: struct xd_iorq *iorq;
1814: struct buf *bp;
1815:
1816: if (xdc->xdc_csr & XDC_F_ERROR) {
1817: /*
1818: * FATAL ERROR: should never happen under normal use. This
1819: * error is so bad, you can't even tell which IOPB is bad, so
1820: * we dump them all.
1821: */
1822: errno = xdc->xdc_f_err;
1823: printf("%s: fatal error 0x%02x: %s\n", xdcsc->sc_dev.dv_xname,
1824: errno, xdc_e2str(errno));
1825: if (xdc_reset(xdcsc, 0, XD_RSET_ALL, errno, 0) != XD_ERR_AOK) {
1826: printf("%s: soft reset failed!\n",
1827: xdcsc->sc_dev.dv_xname);
1828: panic("xdc_remove_iorq: controller DEAD");
1829: }
1830: return (XD_ERR_AOK);
1831: }
1832:
1833: /*
1834: * get iopb that is done
1835: *
1836: * hmm... I used to read the address of the done IOPB off the VME
1837: * registers and calculate the rqno directly from that. that worked
1838: * until I started putting a load on the controller. when loaded, i
1839: * would get interrupts but neither the REMIOPB or F_ERROR bits would
1840: * be set, even after DELAY'ing a while! later on the timeout
1841: * routine would detect IOPBs that were marked "running" but their
1842: * "done" bit was set. rather than dealing directly with this
1843: * problem, it is just easier to look at all running IOPB's for the
1844: * done bit.
1845: */
1846: if (xdc->xdc_csr & XDC_REMIOPB) {
1847: xdc->xdc_csr = XDC_CLRRIO;
1848: }
1849:
1850: for (rqno = 0; rqno < XDC_MAXIOPB; rqno++) {
1851: iorq = &xdcsc->reqs[rqno];
1852: if (iorq->mode == 0 || XD_STATE(iorq->mode) == XD_SUB_DONE)
1853: continue; /* free, or done */
1854: iopb = &xdcsc->iopbase[rqno];
1855: if (iopb->done == 0)
1856: continue; /* not done yet */
1857:
1858: #ifdef XDC_DEBUG
1859: {
1860: u_char *rio = (u_char *) iopb;
1861: int sz = sizeof(struct xd_iopb), lcv;
1862: printf("%s: rio #%d [", xdcsc->sc_dev.dv_xname, rqno);
1863: for (lcv = 0; lcv < sz; lcv++)
1864: printf(" %02x", rio[lcv]);
1865: printf("]\n");
1866: }
1867: #endif /* XDC_DEBUG */
1868:
1869: xdcsc->nrun--;
1870:
1871: comm = iopb->comm;
1872: errs = iopb->errs;
1873:
1874: if (errs)
1875: iorq->errno = iopb->errno;
1876: else
1877: iorq->errno = 0;
1878:
1879: /* handle non-fatal errors */
1880:
1881: if (errs &&
1882: xdc_error(xdcsc, iorq, iopb, rqno, comm) == XD_ERR_AOK)
1883: continue; /* AOK: we resubmitted it */
1884:
1885:
1886: /* this iorq is now done (hasn't been restarted or anything) */
1887:
1888: if ((iorq->mode & XD_MODE_VERBO) && iorq->lasterror)
1889: xdc_perror(iorq, iopb, 0);
1890:
1891: /* now, if read/write check to make sure we got all the data
1892: * we needed. (this may not be the case if we got an error in
1893: * the middle of a multisector request). */
1894:
1895: if ((iorq->mode & XD_MODE_B144) != 0 && errs == 0 &&
1896: (comm == XDCMD_RD || comm == XDCMD_WR)) {
1897: /* we just successfully processed a bad144 sector
1898: * note: if we are in bad 144 mode, the pointers have
1899: * been advanced already (see above) and are pointing
1900: * at the bad144 sector. to exit bad144 mode, we
1901: * must advance the pointers 1 sector and issue a new
1902: * request if there are still sectors left to process
1903: *
1904: */
1905: XDC_ADVANCE(iorq, 1); /* advance 1 sector */
1906:
1907: /* exit b144 mode */
1908: iorq->mode = iorq->mode & (~XD_MODE_B144);
1909:
1910: if (iorq->sectcnt) { /* more to go! */
1911: iorq->lasterror = iorq->errno = iopb->errno = 0;
1912: iopb->errs = iopb->done = 0;
1913: iorq->tries = 0;
1914: iopb->sectcnt = iorq->sectcnt;
1915: iopb->cylno = iorq->blockno /
1916: iorq->xd->sectpercyl;
1917: iopb->headno =
1918: (iorq->blockno / iorq->xd->nhead) %
1919: iorq->xd->nhead;
1920: iopb->sectno = iorq->blockno % XDFM_BPS;
1921: iopb->daddr = (u_long) iorq->dbuf - DVMA_BASE;
1922: XDC_HWAIT(xdcsc, rqno);
1923: xdc_start(xdcsc, 1); /* resubmit */
1924: continue;
1925: }
1926: }
1927: /* final cleanup, totally done with this request */
1928:
1929: switch (XD_STATE(iorq->mode)) {
1930: case XD_SUB_NORM:
1931: bp = iorq->buf;
1932: if (errs) {
1933: bp->b_error = EIO;
1934: bp->b_flags |= B_ERROR;
1935: bp->b_resid = iorq->sectcnt * XDFM_BPS;
1936: } else {
1937: bp->b_resid = 0; /* done */
1938: }
1939: dvma_mapout((vaddr_t) iorq->dbufbase,
1940: (vaddr_t) bp->b_data,
1941: bp->b_bcount);
1942: disk_unbusy(&iorq->xd->sc_dk,
1943: (bp->b_bcount - bp->b_resid),
1944: (bp->b_flags & B_READ));
1945: XDC_FREE(xdcsc, rqno);
1946: biodone(bp);
1947: break;
1948: case XD_SUB_WAIT:
1949: iorq->mode = XD_NEWSTATE(iorq->mode, XD_SUB_DONE);
1950: xdcsc->ndone++;
1951: wakeup(iorq);
1952: break;
1953: case XD_SUB_POLL:
1954: iorq->mode = XD_NEWSTATE(iorq->mode, XD_SUB_DONE);
1955: xdcsc->ndone++;
1956: break;
1957: }
1958: }
1959:
1960: return (XD_ERR_AOK);
1961: }
1962:
1963: /*
1964: * xdc_perror: print error.
1965: * - if still_trying is true: we got an error, retried and got a
1966: * different error. in that case lasterror is the old error,
1967: * and errno is the new one.
1968: * - if still_trying is not true, then if we ever had an error it
1969: * is in lasterror. also, if iorq->errno == 0, then we recovered
1970: * from that error (otherwise iorq->errno == iorq->lasterror).
1971: */
1972: void
1973: xdc_perror(iorq, iopb, still_trying)
1974: struct xd_iorq *iorq;
1975: struct xd_iopb *iopb;
1976: int still_trying;
1977:
1978: {
1979:
1980: int error = iorq->lasterror;
1981:
1982: printf("%s", (iorq->xd) ? iorq->xd->sc_dev.dv_xname
1983: : iorq->xdc->sc_dev.dv_xname);
1984: if (iorq->buf)
1985: printf("%c: ", 'a' + DISKPART(iorq->buf->b_dev));
1986: if (iopb->comm == XDCMD_RD || iopb->comm == XDCMD_WR)
1987: printf("%s %d/%d/%d: ",
1988: (iopb->comm == XDCMD_RD) ? "read" : "write",
1989: iopb->cylno, iopb->headno, iopb->sectno);
1990: printf("%s", xdc_e2str(error));
1991:
1992: if (still_trying)
1993: printf(" [still trying, new error=%s]", xdc_e2str(iorq->errno));
1994: else
1995: if (iorq->errno == 0)
1996: printf(" [recovered in %d tries]", iorq->tries);
1997:
1998: printf("\n");
1999: }
2000:
2001: /*
2002: * xdc_error: non-fatal error encountered... recover.
2003: * return AOK if resubmitted, return FAIL if this iopb is done
2004: */
2005: int
2006: xdc_error(xdcsc, iorq, iopb, rqno, comm)
2007: struct xdc_softc *xdcsc;
2008: struct xd_iorq *iorq;
2009: struct xd_iopb *iopb;
2010: int rqno, comm;
2011:
2012: {
2013: int errno = iorq->errno;
2014: int erract = errno & XD_ERA_MASK;
2015: int oldmode, advance, i;
2016:
2017: if (erract == XD_ERA_RSET) { /* some errors require a reset */
2018: oldmode = iorq->mode;
2019: iorq->mode = XD_SUB_DONE | (~XD_SUB_MASK & oldmode);
2020: xdcsc->ndone++;
2021: /* make xdc_start ignore us */
2022: xdc_reset(xdcsc, 1, XD_RSET_NONE, errno, iorq->xd);
2023: iorq->mode = oldmode;
2024: xdcsc->ndone--;
2025: }
2026: /* check for read/write to a sector in bad144 table if bad: redirect
2027: * request to bad144 area */
2028:
2029: if ((comm == XDCMD_RD || comm == XDCMD_WR) &&
2030: (iorq->mode & XD_MODE_B144) == 0) {
2031: advance = iorq->sectcnt - iopb->sectcnt;
2032: XDC_ADVANCE(iorq, advance);
2033: if ((i = isbad(&iorq->xd->dkb, iorq->blockno / iorq->xd->sectpercyl,
2034: (iorq->blockno / iorq->xd->nsect) % iorq->xd->nhead,
2035: iorq->blockno % iorq->xd->nsect)) != -1) {
2036: iorq->mode |= XD_MODE_B144; /* enter bad144 mode &
2037: * redirect */
2038: iopb->errno = iopb->done = iopb->errs = 0;
2039: iopb->sectcnt = 1;
2040: iopb->cylno = (iorq->xd->ncyl + iorq->xd->acyl) - 2;
2041: /* second to last acyl */
2042: i = iorq->xd->sectpercyl - 1 - i; /* follow bad144
2043: * standard */
2044: iopb->headno = i / iorq->xd->nhead;
2045: iopb->sectno = i % iorq->xd->nhead;
2046: XDC_HWAIT(xdcsc, rqno);
2047: xdc_start(xdcsc, 1); /* resubmit */
2048: return (XD_ERR_AOK); /* recovered! */
2049: }
2050: }
2051:
2052: /*
2053: * it isn't a bad144 sector, must be real error! see if we can retry
2054: * it?
2055: */
2056: if ((iorq->mode & XD_MODE_VERBO) && iorq->lasterror)
2057: xdc_perror(iorq, iopb, 1); /* inform of error state
2058: * change */
2059: iorq->lasterror = errno;
2060:
2061: if ((erract == XD_ERA_RSET || erract == XD_ERA_HARD)
2062: && iorq->tries < XDC_MAXTRIES) { /* retry? */
2063: iorq->tries++;
2064: iorq->errno = iopb->errno = iopb->done = iopb->errs = 0;
2065: XDC_HWAIT(xdcsc, rqno);
2066: xdc_start(xdcsc, 1); /* restart */
2067: return (XD_ERR_AOK); /* recovered! */
2068: }
2069:
2070: /* failed to recover from this error */
2071: return (XD_ERR_FAIL);
2072: }
2073:
2074: /*
2075: * xdc_tick: make sure xd is still alive and ticking (err, kicking).
2076: */
2077: void
2078: xdc_tick(arg)
2079: void *arg;
2080:
2081: {
2082: struct xdc_softc *xdcsc = arg;
2083: int lcv, s, reset = 0;
2084: #ifdef XDC_DIAG
2085: int wait, run, free, done, whd = 0;
2086: u_char fqc[XDC_MAXIOPB], wqc[XDC_MAXIOPB], mark[XDC_MAXIOPB];
2087: s = splbio();
2088: wait = xdcsc->nwait;
2089: run = xdcsc->nrun;
2090: free = xdcsc->nfree;
2091: done = xdcsc->ndone;
2092: bcopy(xdcsc->waitq, wqc, sizeof(wqc));
2093: bcopy(xdcsc->freereq, fqc, sizeof(fqc));
2094: splx(s);
2095: if (wait + run + free + done != XDC_MAXIOPB) {
2096: printf("%s: diag: IOPB miscount (got w/f/r/d %d/%d/%d/%d, wanted %d)\n",
2097: xdcsc->sc_dev.dv_xname, wait, free, run, done, XDC_MAXIOPB);
2098: bzero(mark, sizeof(mark));
2099: printf("FREE: ");
2100: for (lcv = free; lcv > 0; lcv--) {
2101: printf("%d ", fqc[lcv - 1]);
2102: mark[fqc[lcv - 1]] = 1;
2103: }
2104: printf("\nWAIT: ");
2105: lcv = wait;
2106: while (lcv > 0) {
2107: printf("%d ", wqc[whd]);
2108: mark[wqc[whd]] = 1;
2109: whd = (whd + 1) % XDC_MAXIOPB;
2110: lcv--;
2111: }
2112: printf("\n");
2113: for (lcv = 0; lcv < XDC_MAXIOPB; lcv++) {
2114: if (mark[lcv] == 0)
2115: printf("MARK: running %d: mode %d done %d errs %d errno 0x%x ttl %d buf %p\n",
2116: lcv, xdcsc->reqs[lcv].mode,
2117: xdcsc->iopbase[lcv].done,
2118: xdcsc->iopbase[lcv].errs,
2119: xdcsc->iopbase[lcv].errno,
2120: xdcsc->reqs[lcv].ttl, xdcsc->reqs[lcv].buf);
2121: }
2122: } else
2123: if (done > XDC_MAXIOPB - XDC_SUBWAITLIM)
2124: printf("%s: diag: lots of done jobs (%d)\n",
2125: xdcsc->sc_dev.dv_xname, done);
2126:
2127: #endif
2128: #ifdef XDC_DEBUG
2129: printf("%s: tick: csr 0x%x, w/f/r/d %d/%d/%d/%d\n",
2130: xdcsc->sc_dev.dv_xname,
2131: xdcsc->xdc->xdc_csr, xdcsc->nwait, xdcsc->nfree, xdcsc->nrun,
2132: xdcsc->ndone);
2133: for (lcv = 0; lcv < XDC_MAXIOPB; lcv++) {
2134: if (xdcsc->reqs[lcv].mode)
2135: printf("running %d: mode %d done %d errs %d errno 0x%x\n",
2136: lcv,
2137: xdcsc->reqs[lcv].mode, xdcsc->iopbase[lcv].done,
2138: xdcsc->iopbase[lcv].errs, xdcsc->iopbase[lcv].errno);
2139: }
2140: #endif
2141:
2142: /* reduce ttl for each request if one goes to zero, reset xdc */
2143: s = splbio();
2144: for (lcv = 0; lcv < XDC_MAXIOPB; lcv++) {
2145: if (xdcsc->reqs[lcv].mode == 0 ||
2146: XD_STATE(xdcsc->reqs[lcv].mode) == XD_SUB_DONE)
2147: continue;
2148: xdcsc->reqs[lcv].ttl--;
2149: if (xdcsc->reqs[lcv].ttl == 0)
2150: reset = 1;
2151: }
2152: if (reset) {
2153: printf("%s: watchdog timeout\n", xdcsc->sc_dev.dv_xname);
2154: xdc_reset(xdcsc, 0, XD_RSET_NONE, XD_ERR_FAIL, NULL);
2155: }
2156: splx(s);
2157:
2158: /* until next time */
2159:
2160: timeout_add(&xdcsc->xdc_tick_tmo, XDC_TICKCNT);
2161: }
2162:
2163: /*
2164: * xdc_ioctlcmd: this function provides a user level interface to the
2165: * controller via ioctl. this allows "format" programs to be written
2166: * in user code, and is also useful for some debugging. we return
2167: * an error code. called at user priority.
2168: */
2169: int
2170: xdc_ioctlcmd(xd, dev, xio)
2171: struct xd_softc *xd;
2172: dev_t dev;
2173: struct xd_iocmd *xio;
2174:
2175: {
2176: int s, err, rqno, dummy;
2177: caddr_t dvmabuf = NULL, buf = NULL;
2178: struct xdc_softc *xdcsc;
2179:
2180: /* check sanity of requested command */
2181:
2182: switch (xio->cmd) {
2183:
2184: case XDCMD_NOP: /* no op: everything should be zero */
2185: if (xio->subfn || xio->dptr || xio->dlen ||
2186: xio->block || xio->sectcnt)
2187: return (EINVAL);
2188: break;
2189:
2190: case XDCMD_RD: /* read / write sectors (up to XD_IOCMD_MAXS) */
2191: case XDCMD_WR:
2192: if (xio->subfn || xio->sectcnt > XD_IOCMD_MAXS ||
2193: xio->sectcnt * XDFM_BPS != xio->dlen || xio->dptr == NULL)
2194: return (EINVAL);
2195: break;
2196:
2197: case XDCMD_SK: /* seek: doesn't seem useful to export this */
2198: return (EINVAL);
2199:
2200: case XDCMD_WRP: /* write parameters */
2201: return (EINVAL);/* not useful, except maybe drive
2202: * parameters... but drive parameters should
2203: * go via disklabel changes */
2204:
2205: case XDCMD_RDP: /* read parameters */
2206: if (xio->subfn != XDFUN_DRV ||
2207: xio->dlen || xio->block || xio->dptr)
2208: return (EINVAL); /* allow read drive params to
2209: * get hw_spt */
2210: xio->sectcnt = xd->hw_spt; /* we already know the answer */
2211: return (0);
2212: break;
2213:
2214: case XDCMD_XRD: /* extended read/write */
2215: case XDCMD_XWR:
2216:
2217: switch (xio->subfn) {
2218:
2219: case XDFUN_THD:/* track headers */
2220: if (xio->sectcnt != xd->hw_spt ||
2221: (xio->block % xd->nsect) != 0 ||
2222: xio->dlen != XD_IOCMD_HSZ * xd->hw_spt ||
2223: xio->dptr == NULL)
2224: return (EINVAL);
2225: xio->sectcnt = 0;
2226: break;
2227:
2228: case XDFUN_FMT:/* NOTE: also XDFUN_VFY */
2229: if (xio->cmd == XDCMD_XRD)
2230: return (EINVAL); /* no XDFUN_VFY */
2231: if (xio->sectcnt || xio->dlen ||
2232: (xio->block % xd->nsect) != 0 || xio->dptr)
2233: return (EINVAL);
2234: break;
2235:
2236: case XDFUN_HDR:/* header, header verify, data, data ECC */
2237: return (EINVAL); /* not yet */
2238:
2239: case XDFUN_DM: /* defect map */
2240: case XDFUN_DMX:/* defect map (alternate location) */
2241: if (xio->sectcnt || xio->dlen != XD_IOCMD_DMSZ ||
2242: (xio->block % xd->nsect) != 0 || xio->dptr == NULL)
2243: return (EINVAL);
2244: break;
2245:
2246: default:
2247: return (EINVAL);
2248: }
2249: break;
2250:
2251: case XDCMD_TST: /* diagnostics */
2252: return (EINVAL);
2253:
2254: default:
2255: return (EINVAL);/* ??? */
2256: }
2257:
2258: /* create DVMA buffer for request if needed */
2259:
2260: if (xio->dlen) {
2261: dvmabuf = dvma_malloc(xio->dlen, &buf, M_WAITOK);
2262: if (xio->cmd == XDCMD_WR || xio->cmd == XDCMD_XWR) {
2263: if ((err = copyin(xio->dptr, buf, xio->dlen)) != 0) {
2264: dvma_free(dvmabuf, xio->dlen, &buf);
2265: return (err);
2266: }
2267: }
2268: }
2269: /* do it! */
2270:
2271: err = 0;
2272: xdcsc = xd->parent;
2273: s = splbio();
2274: rqno = xdc_cmd(xdcsc, xio->cmd, xio->subfn, xd->xd_drive, xio->block,
2275: xio->sectcnt, dvmabuf, XD_SUB_WAIT);
2276: if (rqno == XD_ERR_FAIL) {
2277: err = EIO;
2278: goto done;
2279: }
2280: xio->errno = xdcsc->reqs[rqno].errno;
2281: xio->tries = xdcsc->reqs[rqno].tries;
2282: XDC_DONE(xdcsc, rqno, dummy);
2283:
2284: if (xio->cmd == XDCMD_RD || xio->cmd == XDCMD_XRD)
2285: err = copyout(buf, xio->dptr, xio->dlen);
2286:
2287: done:
2288: splx(s);
2289: if (dvmabuf)
2290: dvma_free(dvmabuf, xio->dlen, &buf);
2291: return (err);
2292: }
2293:
2294: /*
2295: * xdc_e2str: convert error code number into an error string
2296: */
2297: char *
2298: xdc_e2str(no)
2299: int no;
2300: {
2301: switch (no) {
2302: case XD_ERR_FAIL:
2303: return ("Software fatal error");
2304: case XD_ERR_AOK:
2305: return ("Successful completion");
2306: case XD_ERR_ICYL:
2307: return ("Illegal cylinder address");
2308: case XD_ERR_IHD:
2309: return ("Illegal head address");
2310: case XD_ERR_ISEC:
2311: return ("Illgal sector address");
2312: case XD_ERR_CZER:
2313: return ("Count zero");
2314: case XD_ERR_UIMP:
2315: return ("Unimplemented command");
2316: case XD_ERR_IF1:
2317: return ("Illegal field length 1");
2318: case XD_ERR_IF2:
2319: return ("Illegal field length 2");
2320: case XD_ERR_IF3:
2321: return ("Illegal field length 3");
2322: case XD_ERR_IF4:
2323: return ("Illegal field length 4");
2324: case XD_ERR_IF5:
2325: return ("Illegal field length 5");
2326: case XD_ERR_IF6:
2327: return ("Illegal field length 6");
2328: case XD_ERR_IF7:
2329: return ("Illegal field length 7");
2330: case XD_ERR_ISG:
2331: return ("Illegal scatter/gather length");
2332: case XD_ERR_ISPT:
2333: return ("Not enough sectors per track");
2334: case XD_ERR_ALGN:
2335: return ("Next IOPB address alignment error");
2336: case XD_ERR_SGAL:
2337: return ("Scatter/gather address alignment error");
2338: case XD_ERR_SGEC:
2339: return ("Scatter/gather with auto-ECC");
2340: case XD_ERR_SECC:
2341: return ("Soft ECC corrected");
2342: case XD_ERR_SIGN:
2343: return ("ECC ignored");
2344: case XD_ERR_ASEK:
2345: return ("Auto-seek retry recovered");
2346: case XD_ERR_RTRY:
2347: return ("Soft retry recovered");
2348: case XD_ERR_HECC:
2349: return ("Hard data ECC");
2350: case XD_ERR_NHDR:
2351: return ("Header not found");
2352: case XD_ERR_NRDY:
2353: return ("Drive not ready");
2354: case XD_ERR_TOUT:
2355: return ("Operation timeout");
2356: case XD_ERR_VTIM:
2357: return ("VMEDMA timeout");
2358: case XD_ERR_DSEQ:
2359: return ("Disk sequencer error");
2360: case XD_ERR_HDEC:
2361: return ("Header ECC error");
2362: case XD_ERR_RVFY:
2363: return ("Read verify");
2364: case XD_ERR_VFER:
2365: return ("Fatal VMEDMA error");
2366: case XD_ERR_VBUS:
2367: return ("VMEbus error");
2368: case XD_ERR_DFLT:
2369: return ("Drive faulted");
2370: case XD_ERR_HECY:
2371: return ("Header error/cylinder");
2372: case XD_ERR_HEHD:
2373: return ("Header error/head");
2374: case XD_ERR_NOCY:
2375: return ("Drive not on-cylinder");
2376: case XD_ERR_SEEK:
2377: return ("Seek error");
2378: case XD_ERR_ILSS:
2379: return ("Illegal sector size");
2380: case XD_ERR_SEC:
2381: return ("Soft ECC");
2382: case XD_ERR_WPER:
2383: return ("Write-protect error");
2384: case XD_ERR_IRAM:
2385: return ("IRAM self test failure");
2386: case XD_ERR_MT3:
2387: return ("Maintenance test 3 failure (DSKCEL RAM)");
2388: case XD_ERR_MT4:
2389: return ("Maintenance test 4 failure (header shift reg)");
2390: case XD_ERR_MT5:
2391: return ("Maintenance test 5 failure (VMEDMA regs)");
2392: case XD_ERR_MT6:
2393: return ("Maintenance test 6 failure (REGCEL chip)");
2394: case XD_ERR_MT7:
2395: return ("Maintenance test 7 failure (buffer parity)");
2396: case XD_ERR_MT8:
2397: return ("Maintenance test 8 failure (disk FIFO)");
2398: case XD_ERR_IOCK:
2399: return ("IOPB checksum miscompare");
2400: case XD_ERR_IODM:
2401: return ("IOPB DMA fatal");
2402: case XD_ERR_IOAL:
2403: return ("IOPB address alignment error");
2404: case XD_ERR_FIRM:
2405: return ("Firmware error");
2406: case XD_ERR_MMOD:
2407: return ("Illegal maintenance mode test number");
2408: case XD_ERR_ACFL:
2409: return ("ACFAIL asserted");
2410: default:
2411: return ("Unknown error");
2412: }
2413: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to xd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc / dev