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