xref: /netbsd-src/sys/arch/sun3/dev/xy.c (revision 8ac07aec990b9d2e483062509d0a9fa5b4f57cf2)
1 /*	$NetBSD: xy.c,v 1.67 2008/02/06 12:13:47 elad Exp $	*/
2 
3 /*
4  *
5  * Copyright (c) 1995 Charles D. Cranor
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by Charles D. Cranor.
19  * 4. The name of the author may not be used to endorse or promote products
20  *    derived from this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33 
34 /*
35  *
36  * x y . c   x y l o g i c s   4 5 0 / 4 5 1   s m d   d r i v e r
37  *
38  * author: Chuck Cranor <chuck@ccrc.wustl.edu>
39  * id: &Id: xy.c,v 1.1 1995/09/25 20:35:14 chuck Exp &
40  * started: 14-Sep-95
41  * references: [1] Xylogics Model 753 User's Manual
42  *                 part number: 166-753-001, Revision B, May 21, 1988.
43  *                 "Your Partner For Performance"
44  *             [2] other NetBSD disk device drivers
45  *	       [3] Xylogics Model 450 User's Manual
46  *		   part number: 166-017-001, Revision B, 1983.
47  *	       [4] Addendum to Xylogics Model 450 Disk Controller User's
48  *			Manual, Jan. 1985.
49  *	       [5] The 451 Controller, Rev. B3, September 2, 1986.
50  *	       [6] David Jones <dej@achilles.net>'s unfinished 450/451 driver
51  *
52  */
53 
54 #include <sys/cdefs.h>
55 __KERNEL_RCSID(0, "$NetBSD: xy.c,v 1.67 2008/02/06 12:13:47 elad Exp $");
56 
57 #undef XYC_DEBUG		/* full debug */
58 #undef XYC_DIAG			/* extra sanity checks */
59 #if defined(DIAGNOSTIC) && !defined(XYC_DIAG)
60 #define XYC_DIAG		/* link in with master DIAG option */
61 #endif
62 
63 #include <sys/param.h>
64 #include <sys/proc.h>
65 #include <sys/systm.h>
66 #include <sys/kernel.h>
67 #include <sys/file.h>
68 #include <sys/stat.h>
69 #include <sys/ioctl.h>
70 #include <sys/buf.h>
71 #include <sys/bufq.h>
72 #include <sys/uio.h>
73 #include <sys/malloc.h>
74 #include <sys/device.h>
75 #include <sys/disklabel.h>
76 #include <sys/disk.h>
77 #include <sys/syslog.h>
78 #include <sys/dkbad.h>
79 #include <sys/conf.h>
80 #include <sys/kauth.h>
81 
82 #include <uvm/uvm_extern.h>
83 
84 #include <dev/sun/disklabel.h>
85 
86 #include <machine/autoconf.h>
87 #include <machine/dvma.h>
88 
89 #include <sun3/dev/xyreg.h>
90 #include <sun3/dev/xyvar.h>
91 #include <sun3/dev/xio.h>
92 
93 #include "locators.h"
94 
95 /*
96  * Print a complaint when no xy children were specified
97  * in the config file.  Better than a link error...
98  *
99  * XXX: Some folks say this driver should be split in two,
100  * but that seems pointless with ONLY one type of child.
101  */
102 #include "xy.h"
103 #if NXY == 0
104 #error "xyc but no xy?"
105 #endif
106 
107 /*
108  * macros
109  */
110 
111 /*
112  * XYC_GO: start iopb ADDR (DVMA addr in a u_long) on XYC
113  */
114 #define XYC_GO(XYC, ADDR) { \
115 	(XYC)->xyc_addr_lo = ((ADDR) & 0xff); \
116 	(ADDR) = ((ADDR) >> 8); \
117 	(XYC)->xyc_addr_hi = ((ADDR) & 0xff); \
118 	(ADDR) = ((ADDR) >> 8); \
119 	(XYC)->xyc_reloc_lo = ((ADDR) & 0xff); \
120 	(ADDR) = ((ADDR) >> 8); \
121 	(XYC)->xyc_reloc_hi = (ADDR); \
122 	(XYC)->xyc_csr = XYC_GBSY; /* go! */ \
123 }
124 
125 /*
126  * XYC_DONE: don't need IORQ, get error code and free (done after xyc_cmd)
127  */
128 
129 #define XYC_DONE(SC,ER) { \
130 	if ((ER) == XY_ERR_AOK) { \
131 		(ER) = (SC)->ciorq->errno; \
132 		(SC)->ciorq->mode = XY_SUB_FREE; \
133 		wakeup((SC)->ciorq); \
134 	} \
135 	}
136 
137 /*
138  * XYC_ADVANCE: advance iorq's pointers by a number of sectors
139  */
140 
141 #define XYC_ADVANCE(IORQ, N) { \
142 	if (N) { \
143 		(IORQ)->sectcnt -= (N); \
144 		(IORQ)->blockno += (N); \
145 		(IORQ)->dbuf += ((N)*XYFM_BPS); \
146 	} \
147 }
148 
149 /*
150  * note - addresses you can sleep on:
151  *   [1] & of xy_softc's "state" (waiting for a chance to attach a drive)
152  *   [2] & an iorq (waiting for an XY_SUB_WAIT iorq to finish)
153  */
154 
155 
156 /*
157  * function prototypes
158  * "xyc_*" functions are internal, all others are external interfaces
159  */
160 
161 /* internals */
162 struct xy_iopb *xyc_chain(struct xyc_softc *, struct xy_iorq *);
163 int	xyc_cmd(struct xyc_softc *, int, int, int, int, int, char *, int);
164 const char *xyc_e2str(int);
165 int	xyc_entoact(int);
166 int	xyc_error(struct xyc_softc *, struct xy_iorq *, struct xy_iopb *, int);
167 int	xyc_ioctlcmd(struct xy_softc *, dev_t dev, struct xd_iocmd *);
168 void	xyc_perror(struct xy_iorq *, struct xy_iopb *, int);
169 int	xyc_piodriver(struct xyc_softc *, struct xy_iorq *);
170 int	xyc_remove_iorq(struct xyc_softc *);
171 int	xyc_reset(struct xyc_softc *, int, struct xy_iorq *, int,
172 	    struct xy_softc *);
173 inline void xyc_rqinit(struct xy_iorq *, struct xyc_softc *, struct xy_softc *,
174 	    int, u_long, int, void *, struct buf *);
175 void	xyc_rqtopb(struct xy_iorq *, struct xy_iopb *, int, int);
176 void	xyc_start(struct xyc_softc *, struct xy_iorq *);
177 int	xyc_startbuf(struct xyc_softc *, struct xy_softc *, struct buf *);
178 int	xyc_submit_iorq(struct xyc_softc *, struct xy_iorq *, int);
179 void	xyc_tick(void *);
180 int	xyc_unbusy(struct xyc *, int);
181 void	xyc_xyreset(struct xyc_softc *, struct xy_softc *);
182 
183 /* machine interrupt hook */
184 int	xycintr(void *);
185 
186 /* autoconf */
187 static int	xycmatch(struct device *, struct cfdata *, void *);
188 static void	xycattach(struct device *, struct device *, void *);
189 static int	xyc_print(void *, const char *);
190 
191 static int	xymatch(struct device *, struct cfdata *, void *);
192 static void	xyattach(struct device *, struct device *, void *);
193 static void	xy_init(struct xy_softc *);
194 
195 static	void xydummystrat(struct buf *);
196 int	xygetdisklabel(struct xy_softc *, void *);
197 
198 /*
199  * cfattach's: device driver interface to autoconfig
200  */
201 
202 CFATTACH_DECL(xyc, sizeof(struct xyc_softc),
203     xycmatch, xycattach, NULL, NULL);
204 
205 CFATTACH_DECL(xy, sizeof(struct xy_softc),
206     xymatch, xyattach, NULL, NULL);
207 
208 extern struct cfdriver xy_cd;
209 
210 struct xyc_attach_args {	/* this is the "aux" args to xyattach */
211 	int	driveno;	/* unit number */
212 };
213 
214 dev_type_open(xyopen);
215 dev_type_close(xyclose);
216 dev_type_read(xyread);
217 dev_type_write(xywrite);
218 dev_type_ioctl(xyioctl);
219 dev_type_strategy(xystrategy);
220 dev_type_dump(xydump);
221 dev_type_size(xysize);
222 
223 const struct bdevsw xy_bdevsw = {
224 	xyopen, xyclose, xystrategy, xyioctl, xydump, xysize, D_DISK
225 };
226 
227 const struct cdevsw xy_cdevsw = {
228 	xyopen, xyclose, xyread, xywrite, xyioctl,
229 	nostop, notty, nopoll, nommap, nokqfilter, D_DISK
230 };
231 
232 /*
233  * dkdriver
234  */
235 
236 struct dkdriver xydkdriver = { xystrategy };
237 
238 /*
239  * start: disk label fix code (XXX)
240  */
241 
242 static void *xy_labeldata;
243 
244 static void
245 xydummystrat(struct buf *bp)
246 {
247 	if (bp->b_bcount != XYFM_BPS)
248 		panic("xydummystrat");
249 	memcpy(bp->b_data, xy_labeldata, XYFM_BPS);
250 	bp->b_oflags |= BO_DONE;
251 	bp->b_cflags &= ~BC_BUSY;
252 }
253 
254 int
255 xygetdisklabel(struct xy_softc *xy, void *b)
256 {
257 	const char *err;
258 	struct sun_disklabel *sdl;
259 
260 	/* We already have the label data in `b'; setup for dummy strategy */
261 	xy_labeldata = b;
262 
263 	/* Required parameter for readdisklabel() */
264 	xy->sc_dk.dk_label->d_secsize = XYFM_BPS;
265 
266 	err = readdisklabel(MAKEDISKDEV(0, device_unit(&xy->sc_dev), RAW_PART),
267 					xydummystrat,
268 				xy->sc_dk.dk_label, xy->sc_dk.dk_cpulabel);
269 	if (err) {
270 		printf("%s: %s\n", xy->sc_dev.dv_xname, err);
271 		return(XY_ERR_FAIL);
272 	}
273 
274 	/* Ok, we have the label; fill in `pcyl' if there's SunOS magic */
275 	sdl = (struct sun_disklabel *)xy->sc_dk.dk_cpulabel->cd_block;
276 	if (sdl->sl_magic == SUN_DKMAGIC)
277 		xy->pcyl = sdl->sl_pcyl;
278 	else {
279 		printf("%s: WARNING: no `pcyl' in disk label.\n",
280 			   xy->sc_dev.dv_xname);
281 		xy->pcyl = xy->sc_dk.dk_label->d_ncylinders +
282 			xy->sc_dk.dk_label->d_acylinders;
283 		printf("%s: WARNING: guessing pcyl=%d (ncyl+acyl)\n",
284 		xy->sc_dev.dv_xname, xy->pcyl);
285 	}
286 
287 	xy->ncyl = xy->sc_dk.dk_label->d_ncylinders;
288 	xy->acyl = xy->sc_dk.dk_label->d_acylinders;
289 	xy->nhead = xy->sc_dk.dk_label->d_ntracks;
290 	xy->nsect = xy->sc_dk.dk_label->d_nsectors;
291 	xy->sectpercyl = xy->nhead * xy->nsect;
292 	xy->sc_dk.dk_label->d_secsize = XYFM_BPS; /* not handled by
293                                           	  * sun->bsd */
294 	return(XY_ERR_AOK);
295 }
296 
297 /*
298  * end: disk label fix code (XXX)
299  */
300 
301 /*
302  * a u t o c o n f i g   f u n c t i o n s
303  */
304 
305 /*
306  * xycmatch: determine if xyc is present or not.   we do a
307  * soft reset to detect the xyc.
308  */
309 static int
310 xycmatch(struct device *parent, struct cfdata *cf, void *aux)
311 {
312 	struct confargs *ca = aux;
313 
314 	/* No default VME address. */
315 	if (ca->ca_paddr == -1)
316 		return (0);
317 
318 	/* Make sure something is there... */
319 	if (bus_peek(ca->ca_bustype, ca->ca_paddr + 5, 1) == -1)
320 		return (0);
321 
322 	/* Default interrupt priority. */
323 	if (ca->ca_intpri == -1)
324 		ca->ca_intpri = 2;
325 
326 	return (1);
327 }
328 
329 /*
330  * xycattach: attach controller
331  */
332 static void
333 xycattach(struct device *parent, struct device *self, void *aux)
334 {
335 	struct xyc_softc *xyc = (void *) self;
336 	struct confargs *ca = aux;
337 	struct xyc_attach_args xa;
338 	int     lcv, err, res, pbsz;
339 	void	*tmp, *tmp2;
340 	u_long	ultmp;
341 
342 	/* get addressing and intr level stuff from autoconfig and load it
343 	 * into our xyc_softc. */
344 
345 	xyc->xyc = (struct xyc *)
346 		bus_mapin(ca->ca_bustype, ca->ca_paddr, sizeof(struct xyc));
347 	xyc->bustype = ca->ca_bustype;
348 	xyc->ipl     = ca->ca_intpri;
349 	xyc->vector  = ca->ca_intvec;
350 	xyc->no_ols = 0; /* XXX should be from config */
351 
352 	for (lcv = 0; lcv < XYC_MAXDEV; lcv++)
353 		xyc->sc_drives[lcv] = (struct xy_softc *) 0;
354 
355 	/*
356 	 * allocate and zero buffers
357 	 * check boundaries of the KVA's ... all IOPBs must reside in
358  	 * the same 64K region.
359 	 */
360 
361 	pbsz = XYC_MAXIOPB * sizeof(struct xy_iopb);
362 	tmp = tmp2 = (struct xy_iopb *) dvma_malloc(pbsz);	/* KVA */
363 	ultmp = (u_long) tmp;
364 	if ((ultmp & 0xffff0000) != ((ultmp + pbsz) & 0xffff0000)) {
365 		tmp = (struct xy_iopb *) dvma_malloc(pbsz); /* retry! */
366 		dvma_free(tmp2, pbsz);
367 		ultmp = (u_long) tmp;
368 		if ((ultmp & 0xffff0000) != ((ultmp + pbsz) & 0xffff0000)) {
369 			printf("%s: can't alloc IOPB mem in 64K\n",
370 				xyc->sc_dev.dv_xname);
371 			return;
372 		}
373 	}
374 	memset(tmp, 0, pbsz);
375 	xyc->iopbase = tmp;
376 	xyc->dvmaiopb = (struct xy_iopb *)
377 		dvma_kvtopa(xyc->iopbase, xyc->bustype);
378 	xyc->reqs = (struct xy_iorq *)
379 	    malloc(XYC_MAXIOPB * sizeof(struct xy_iorq), M_DEVBUF, M_NOWAIT);
380 	if (xyc->reqs == NULL)
381 		panic("xyc malloc");
382 	memset(xyc->reqs, 0, XYC_MAXIOPB * sizeof(struct xy_iorq));
383 
384 	/*
385 	 * init iorq to iopb pointers, and non-zero fields in the
386 	 * iopb which never change.
387 	 */
388 
389 	for (lcv = 0; lcv < XYC_MAXIOPB; lcv++) {
390 		xyc->xy_chain[lcv] = NULL;
391 		xyc->reqs[lcv].iopb = &xyc->iopbase[lcv];
392 		xyc->iopbase[lcv].asr = 1;	/* always the same */
393 		xyc->iopbase[lcv].eef = 1;	/* always the same */
394 		xyc->iopbase[lcv].ecm = XY_ECM;	/* always the same */
395 		xyc->iopbase[lcv].aud = 1;	/* always the same */
396 		xyc->iopbase[lcv].relo = 1;	/* always the same */
397 		xyc->iopbase[lcv].thro = XY_THRO;/* always the same */
398 	}
399 	xyc->ciorq = &xyc->reqs[XYC_CTLIOPB];    /* short hand name */
400 	xyc->ciopb = &xyc->iopbase[XYC_CTLIOPB]; /* short hand name */
401 	xyc->xy_hand = 0;
402 
403 	/* read controller parameters and insure we have a 450/451 */
404 
405 	err = xyc_cmd(xyc, XYCMD_ST, 0, 0, 0, 0, 0, XY_SUB_POLL);
406 	res = xyc->ciopb->ctyp;
407 	XYC_DONE(xyc, err);
408 	if (res != XYCT_450) {
409 		if (err)
410 			printf(": %s: ", xyc_e2str(err));
411 		printf(": doesn't identify as a 450/451\n");
412 		return;
413 	}
414 	printf(": Xylogics 450/451");
415 	if (xyc->no_ols)
416 		printf(" [OLS disabled]"); /* 450 doesn't overlap seek right */
417 	printf("\n");
418 	if (err) {
419 		printf("%s: error: %s\n", xyc->sc_dev.dv_xname,
420 				xyc_e2str(err));
421 		return;
422 	}
423 	if ((xyc->xyc->xyc_csr & XYC_ADRM) == 0) {
424 		printf("%s: 24 bit addressing turned off\n",
425 			   xyc->sc_dev.dv_xname);
426 		printf("please set hardware jumpers JM1-JM2=in, JM3-JM4=out\n");
427 		printf("to enable 24 bit mode and this driver\n");
428 		return;
429 	}
430 
431 	/* link in interrupt with higher level software */
432 	isr_add_vectored(xycintr, (void *)xyc,
433 	                 ca->ca_intpri, ca->ca_intvec);
434 	evcnt_attach_dynamic(&xyc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
435 	    xyc->sc_dev.dv_xname, "intr");
436 
437 	callout_init(&xyc->sc_tick_ch, 0);
438 
439 	/* now we must look for disks using autoconfig */
440 	for (xa.driveno = 0; xa.driveno < XYC_MAXDEV; xa.driveno++)
441 		(void) config_found(self, (void *) &xa, xyc_print);
442 
443 	/* start the watchdog clock */
444 	callout_reset(&xyc->sc_tick_ch, XYC_TICKCNT, xyc_tick, xyc);
445 }
446 
447 static int
448 xyc_print(void *aux, const char *name)
449 {
450 	struct xyc_attach_args *xa = aux;
451 
452 	if (name != NULL)
453 		aprint_normal("%s: ", name);
454 
455 	if (xa->driveno != -1)
456 		aprint_normal(" drive %d", xa->driveno);
457 
458 	return UNCONF;
459 }
460 
461 /*
462  * xymatch: probe for disk.
463  *
464  * note: we almost always say disk is present.   this allows us to
465  * spin up and configure a disk after the system is booted (we can
466  * call xyattach!).  Also, wire down the relationship between the
467  * xy* and xyc* devices, to simplify boot device identification.
468  */
469 static int
470 xymatch(struct device *parent, struct cfdata *cf, void *aux)
471 {
472 	struct xyc_attach_args *xa = aux;
473 	int xy_unit;
474 
475 	/* Match only on the "wired-down" controller+disk. */
476 	xy_unit = device_unit(parent) * 2 + xa->driveno;
477 	if (cf->cf_unit != xy_unit)
478 		return (0);
479 
480 	return (1);
481 }
482 
483 /*
484  * xyattach: attach a disk.
485  */
486 static void
487 xyattach(struct device *parent, struct device *self, void *aux)
488 {
489 	struct xy_softc *xy = (void *) self;
490 	struct xyc_softc *xyc = (void *) parent;
491 	struct xyc_attach_args *xa = aux;
492 
493 	printf("\n");
494 
495 	/*
496 	 * Always re-initialize the disk structure.  We want statistics
497 	 * to start with a clean slate.
498 	 */
499 	memset(&xy->sc_dk, 0, sizeof(xy->sc_dk));
500 	disk_init(&xy->sc_dk, xy->sc_dev.dv_xname, &xydkdriver);
501 
502 	xy->state = XY_DRIVE_UNKNOWN;	/* to start */
503 	xy->flags = 0;
504 	xy->parent = xyc;
505 
506 	/* init queue of waiting bufs */
507 	bufq_alloc(&xy->xyq, "disksort", BUFQ_SORT_RAWBLOCK);
508 	xy->xyrq = &xyc->reqs[xa->driveno];
509 
510 	xy->xy_drive = xa->driveno;
511 	xyc->sc_drives[xa->driveno] = xy;
512 
513 	/* Do init work common to attach and open. */
514 	xy_init(xy);
515 }
516 
517 /*
518  * end of autoconfig functions
519  */
520 
521 /*
522  * Initialize a disk.  This can be called from both autoconf and
523  * also from xyopen/xystrategy.
524  */
525 static void
526 xy_init(struct xy_softc *xy)
527 {
528 	struct xyc_softc *xyc;
529 	struct dkbad *dkb;
530 	void *dvmabuf;
531 	int err, spt, mb, blk, lcv, fullmode, newstate;
532 
533 	xyc = xy->parent;
534 	xy->state = XY_DRIVE_ATTACHING;
535 	newstate = XY_DRIVE_UNKNOWN;
536 	fullmode = (cold) ? XY_SUB_POLL : XY_SUB_WAIT;
537 	dvmabuf  = dvma_malloc(XYFM_BPS);
538 
539 	/* first try and reset the drive */
540 
541 	err = xyc_cmd(xyc, XYCMD_RST, 0, xy->xy_drive, 0, 0, 0, fullmode);
542 	XYC_DONE(xyc, err);
543 	if (err == XY_ERR_DNRY) {
544 		printf("%s: drive %d: off-line\n",
545 			   xy->sc_dev.dv_xname, xy->xy_drive);
546 		goto done;
547 	}
548 	if (err) {
549 		printf("%s: ERROR 0x%02x (%s)\n",
550 			   xy->sc_dev.dv_xname, err, xyc_e2str(err));
551 		goto done;
552 	}
553 	printf("%s: drive %d ready",
554 		   xy->sc_dev.dv_xname, xy->xy_drive);
555 
556 	/*
557 	 * now set drive parameters (to semi-bogus values) so we can read the
558 	 * disk label.
559 	 */
560 	xy->pcyl = xy->ncyl = 1;
561 	xy->acyl = 0;
562 	xy->nhead = 1;
563 	xy->nsect = 1;
564 	xy->sectpercyl = 1;
565 	for (lcv = 0; lcv < 126; lcv++)	/* init empty bad144 table */
566 		xy->dkb.bt_bad[lcv].bt_cyl =
567 			xy->dkb.bt_bad[lcv].bt_trksec = 0xffff;
568 
569 	/* read disk label */
570 	for (xy->drive_type = 0 ; xy->drive_type <= XYC_MAXDT ;
571 						xy->drive_type++) {
572 		err = xyc_cmd(xyc, XYCMD_RD, 0, xy->xy_drive, 0, 1,
573 						dvmabuf, fullmode);
574 		XYC_DONE(xyc, err);
575 		if (err == XY_ERR_AOK) break;
576 	}
577 
578 	if (err != XY_ERR_AOK) {
579 		printf("%s: reading disk label failed: %s\n",
580 			xy->sc_dev.dv_xname, xyc_e2str(err));
581 		goto done;
582 	}
583 	printf("%s: drive type %d\n",
584 		   xy->sc_dev.dv_xname, xy->drive_type);
585 
586 	newstate = XY_DRIVE_NOLABEL;
587 
588 	xy->hw_spt = spt = 0; /* XXX needed ? */
589 	/* Attach the disk: must be before getdisklabel to malloc label */
590 	disk_attach(&xy->sc_dk);
591 
592 	if (xygetdisklabel(xy, dvmabuf) != XY_ERR_AOK)
593 		goto done;
594 
595 	/* inform the user of what is up */
596 	printf("%s: <%s>, pcyl %d\n",
597 		   xy->sc_dev.dv_xname,
598 		   (char *)dvmabuf, xy->pcyl);
599 	mb = xy->ncyl * (xy->nhead * xy->nsect) / (1048576 / XYFM_BPS);
600 	printf("%s: %dMB, %d cyl, %d head, %d sec\n",
601 		xy->sc_dev.dv_xname, mb,
602 		xy->ncyl, xy->nhead, xy->nsect);
603 
604 	/*
605 	 * 450/451 stupidity: the drive type is encoded into the format
606 	 * of the disk.   the drive type in the IOPB must match the drive
607 	 * type in the format, or you will not be able to do I/O to the
608 	 * disk (you get header not found errors).  if you have two drives
609 	 * of different sizes that have the same drive type in their
610 	 * formatting then you are out of luck.
611 	 *
612 	 * this problem was corrected in the 753/7053.
613 	 */
614 
615 	for (lcv = 0 ; lcv < XYC_MAXDEV ; lcv++) {
616 		struct xy_softc *oxy;
617 
618 		oxy = xyc->sc_drives[lcv];
619 		if (oxy == NULL || oxy == xy) continue;
620 		if (oxy->drive_type != xy->drive_type) continue;
621 		if (xy->nsect != oxy->nsect || xy->pcyl != oxy->pcyl ||
622 			xy->nhead != oxy->nhead) {
623 			printf("%s: %s and %s must be the same size!\n",
624 				xyc->sc_dev.dv_xname,
625 				xy ->sc_dev.dv_xname,
626 				oxy->sc_dev.dv_xname);
627 			panic("xy drive size mismatch");
628 		}
629 	}
630 
631 
632 	/* now set the real drive parameters! */
633 	blk = (xy->nsect - 1) +
634 		((xy->nhead - 1) * xy->nsect) +
635 		((xy->pcyl - 1) * xy->nsect * xy->nhead);
636 	err = xyc_cmd(xyc, XYCMD_SDS, 0, xy->xy_drive, blk, 0, 0, fullmode);
637 	XYC_DONE(xyc, err);
638 	if (err) {
639 		printf("%s: write drive size failed: %s\n",
640 			xy->sc_dev.dv_xname, xyc_e2str(err));
641 		goto done;
642 	}
643 	newstate = XY_DRIVE_ONLINE;
644 
645 	/*
646 	 * read bad144 table. this table resides on the first sector of the
647 	 * last track of the disk (i.e. second cyl of "acyl" area).
648 	 */
649 	blk = (xy->ncyl + xy->acyl - 1) * (xy->nhead * xy->nsect) +
650 								/* last cyl */
651 	    (xy->nhead - 1) * xy->nsect;	/* last head */
652 	err = xyc_cmd(xyc, XYCMD_RD, 0, xy->xy_drive, blk, 1,
653 						dvmabuf, fullmode);
654 	XYC_DONE(xyc, err);
655 	if (err) {
656 		printf("%s: reading bad144 failed: %s\n",
657 			xy->sc_dev.dv_xname, xyc_e2str(err));
658 		goto done;
659 	}
660 
661 	/* check dkbad for sanity */
662 	dkb = (struct dkbad *) dvmabuf;
663 	for (lcv = 0; lcv < 126; lcv++) {
664 		if ((dkb->bt_bad[lcv].bt_cyl == 0xffff ||
665 				dkb->bt_bad[lcv].bt_cyl == 0) &&
666 		     dkb->bt_bad[lcv].bt_trksec == 0xffff)
667 			continue;	/* blank */
668 		if (dkb->bt_bad[lcv].bt_cyl >= xy->ncyl)
669 			break;
670 		if ((dkb->bt_bad[lcv].bt_trksec >> 8) >= xy->nhead)
671 			break;
672 		if ((dkb->bt_bad[lcv].bt_trksec & 0xff) >= xy->nsect)
673 			break;
674 	}
675 	if (lcv != 126) {
676 		printf("%s: warning: invalid bad144 sector!\n",
677 			xy->sc_dev.dv_xname);
678 	} else {
679 		memcpy(&xy->dkb, dvmabuf, XYFM_BPS);
680 	}
681 
682 done:
683 	xy->state = newstate;
684 	dvma_free(dvmabuf, XYFM_BPS);
685 }
686 
687 /*
688  * { b , c } d e v s w   f u n c t i o n s
689  */
690 
691 /*
692  * xyclose: close device
693  */
694 int
695 xyclose(dev_t dev, int flag, int fmt, struct lwp *l)
696 {
697 	struct xy_softc *xy = xy_cd.cd_devs[DISKUNIT(dev)];
698 	int     part = DISKPART(dev);
699 
700 	/* clear mask bits */
701 
702 	switch (fmt) {
703 	case S_IFCHR:
704 		xy->sc_dk.dk_copenmask &= ~(1 << part);
705 		break;
706 	case S_IFBLK:
707 		xy->sc_dk.dk_bopenmask &= ~(1 << part);
708 		break;
709 	}
710 	xy->sc_dk.dk_openmask = xy->sc_dk.dk_copenmask | xy->sc_dk.dk_bopenmask;
711 
712 	return 0;
713 }
714 
715 /*
716  * xydump: crash dump system
717  */
718 int
719 xydump(dev_t dev, daddr_t blkno, void *va, size_t sz)
720 {
721 	int     unit, part;
722 	struct xy_softc *xy;
723 
724 	unit = DISKUNIT(dev);
725 	if (unit >= xy_cd.cd_ndevs)
726 		return ENXIO;
727 	part = DISKPART(dev);
728 
729 	xy = xy_cd.cd_devs[unit];
730 
731 	printf("%s%c: crash dump not supported (yet)\n", xy->sc_dev.dv_xname,
732 	    'a' + part);
733 
734 	return ENXIO;
735 
736 	/* outline: globals: "dumplo" == sector number of partition to start
737 	 * dump at (convert to physical sector with partition table)
738 	 * "dumpsize" == size of dump in clicks "physmem" == size of physical
739 	 * memory (clicks, ctob() to get bytes) (normal case: dumpsize ==
740 	 * physmem)
741 	 *
742 	 * dump a copy of physical memory to the dump device starting at sector
743 	 * "dumplo" in the swap partition (make sure > 0).   map in pages as
744 	 * we go.   use polled I/O.
745 	 *
746 	 * XXX how to handle NON_CONTIG?
747 	 */
748 }
749 
750 static enum kauth_device_req
751 xy_getkauthreq(u_char cmd)
752 {
753 	enum kauth_device_req req;
754 
755 	switch (cmd) {
756 	case XYCMD_WR:
757 	case XYCMD_WTH:
758 	case XYCMD_WFM:
759 	case XYCMD_WRH:
760 		req = KAUTH_REQ_DEVICE_RAWIO_PASSTHRU_WRITE;
761 		break;
762 
763 	case XYCMD_RD:
764 	case XYCMD_RTH:
765 	case XYCMD_RDH:
766 		req = KAUTH_REQ_DEVICE_RAWIO_PASSTHRU_READ;
767 		break;
768 
769 	case XYCMD_RDS:
770 	case XYCMD_MBD:
771 		req = KAUTH_REQ_DEVICE_RAWIO_PASSTHRU_READCONF;
772 		break;
773 
774 	case XYCMD_RST:
775 	case XYCMD_SDS:
776 	case XYCMD_MBL:
777 		req = KAUTH_REQ_DEVICE_RAWIO_PASSTHRU_WRITECONF;
778 		break;
779 
780 	case XYCMD_NOP:
781 	case XYCMD_SK:
782 	case XYCMD_ST:
783 	case XYCMD_R:
784 	default:
785 		req = 0;
786 		break;
787 	}
788 
789 	return (req);
790 }
791 
792 /*
793  * xyioctl: ioctls on XY drives.   based on ioctl's of other netbsd disks.
794  */
795 int
796 xyioctl(dev_t dev, u_long command, void *addr, int flag, struct lwp *l)
797 {
798 	struct xy_softc *xy;
799 	struct xd_iocmd *xio;
800 	int     error, s, unit;
801 
802 	unit = DISKUNIT(dev);
803 
804 	if (unit >= xy_cd.cd_ndevs || (xy = xy_cd.cd_devs[unit]) == NULL)
805 		return (ENXIO);
806 
807 	/* switch on ioctl type */
808 
809 	switch (command) {
810 	case DIOCSBAD:		/* set bad144 info */
811 		if ((flag & FWRITE) == 0)
812 			return EBADF;
813 		s = splbio();
814 		memcpy(&xy->dkb, addr, sizeof(xy->dkb));
815 		splx(s);
816 		return 0;
817 
818 	case DIOCGDINFO:	/* get disk label */
819 		memcpy(addr, xy->sc_dk.dk_label, sizeof(struct disklabel));
820 		return 0;
821 
822 	case DIOCGPART:	/* get partition info */
823 		((struct partinfo *) addr)->disklab = xy->sc_dk.dk_label;
824 		((struct partinfo *) addr)->part =
825 		    &xy->sc_dk.dk_label->d_partitions[DISKPART(dev)];
826 		return 0;
827 
828 	case DIOCSDINFO:	/* set disk label */
829 		if ((flag & FWRITE) == 0)
830 			return EBADF;
831 		error = setdisklabel(xy->sc_dk.dk_label,
832 		    (struct disklabel *) addr, /* xy->sc_dk.dk_openmask : */ 0,
833 		    xy->sc_dk.dk_cpulabel);
834 		if (error == 0) {
835 			if (xy->state == XY_DRIVE_NOLABEL)
836 				xy->state = XY_DRIVE_ONLINE;
837 		}
838 		return error;
839 
840 	case DIOCWLABEL:	/* change write status of disk label */
841 		if ((flag & FWRITE) == 0)
842 			return EBADF;
843 		if (*(int *) addr)
844 			xy->flags |= XY_WLABEL;
845 		else
846 			xy->flags &= ~XY_WLABEL;
847 		return 0;
848 
849 	case DIOCWDINFO:	/* write disk label */
850 		if ((flag & FWRITE) == 0)
851 			return EBADF;
852 		error = setdisklabel(xy->sc_dk.dk_label,
853 		    (struct disklabel *) addr, /* xy->sc_dk.dk_openmask : */ 0,
854 		    xy->sc_dk.dk_cpulabel);
855 		if (error == 0) {
856 			if (xy->state == XY_DRIVE_NOLABEL)
857 				xy->state = XY_DRIVE_ONLINE;
858 
859 			/* Simulate opening partition 0 so write succeeds. */
860 			xy->sc_dk.dk_openmask |= (1 << 0);
861 			error = writedisklabel(MAKEDISKDEV(major(dev), DISKUNIT(dev), RAW_PART),
862 			    xystrategy, xy->sc_dk.dk_label,
863 			    xy->sc_dk.dk_cpulabel);
864 			xy->sc_dk.dk_openmask =
865 			    xy->sc_dk.dk_copenmask | xy->sc_dk.dk_bopenmask;
866 		}
867 		return error;
868 
869 	case DIOSXDCMD: {
870 		enum kauth_device_req req;
871 
872 		xio = (struct xd_iocmd *) addr;
873 		req = xy_getkauthreq(xio->cmd);
874 		if ((error = kauth_authorize_device_passthru(l->l_cred,
875 		    dev, req, xio)) != 0)
876 			return (error);
877 		return (xyc_ioctlcmd(xy, dev, xio));
878 		}
879 
880 	default:
881 		return ENOTTY;
882 	}
883 }
884 
885 /*
886  * xyopen: open drive
887  */
888 int
889 xyopen(dev_t dev, int flag, int fmt, struct lwp *l)
890 {
891 	int err, unit, part, s;
892 	struct xy_softc *xy;
893 
894 	/* first, could it be a valid target? */
895 	unit = DISKUNIT(dev);
896 	if (unit >= xy_cd.cd_ndevs || (xy = xy_cd.cd_devs[unit]) == NULL)
897 		return (ENXIO);
898 	part = DISKPART(dev);
899 	err = 0;
900 
901 	/*
902 	 * If some other processing is doing init, sleep.
903 	 */
904 	s = splbio();
905 	while (xy->state == XY_DRIVE_ATTACHING) {
906 		if (tsleep(&xy->state, PRIBIO, "xyopen", 0)) {
907 			err = EINTR;
908 			goto done;
909 		}
910 	}
911 	/* Do we need to init the drive? */
912 	if (xy->state == XY_DRIVE_UNKNOWN) {
913 		xy_init(xy);
914 		wakeup(&xy->state);
915 	}
916 	/* Was the init successful? */
917 	if (xy->state == XY_DRIVE_UNKNOWN) {
918 		err = EIO;
919 		goto done;
920 	}
921 
922 	/* check for partition */
923 	if (part != RAW_PART &&
924 	    (part >= xy->sc_dk.dk_label->d_npartitions ||
925 		xy->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
926 		err = ENXIO;
927 		goto done;
928 	}
929 
930 	/* set open masks */
931 	switch (fmt) {
932 	case S_IFCHR:
933 		xy->sc_dk.dk_copenmask |= (1 << part);
934 		break;
935 	case S_IFBLK:
936 		xy->sc_dk.dk_bopenmask |= (1 << part);
937 		break;
938 	}
939 	xy->sc_dk.dk_openmask = xy->sc_dk.dk_copenmask | xy->sc_dk.dk_bopenmask;
940 
941 done:
942 	splx(s);
943 	return (err);
944 }
945 
946 int
947 xyread(dev_t dev, struct uio *uio, int flags)
948 {
949 
950 	return (physio(xystrategy, NULL, dev, B_READ, minphys, uio));
951 }
952 
953 int
954 xywrite(dev_t dev, struct uio *uio, int flags)
955 {
956 
957 	return (physio(xystrategy, NULL, dev, B_WRITE, minphys, uio));
958 }
959 
960 
961 /*
962  * xysize: return size of a partition for a dump
963  */
964 
965 int
966 xysize(dev_t dev)
967 {
968 	struct xy_softc *xysc;
969 	int     unit, part, size, omask;
970 
971 	/* valid unit? */
972 	unit = DISKUNIT(dev);
973 	if (unit >= xy_cd.cd_ndevs || (xysc = xy_cd.cd_devs[unit]) == NULL)
974 		return (-1);
975 
976 	part = DISKPART(dev);
977 	omask = xysc->sc_dk.dk_openmask & (1 << part);
978 
979 	if (omask == 0 && xyopen(dev, 0, S_IFBLK, NULL) != 0)
980 		return (-1);
981 
982 	/* do it */
983 	if (xysc->sc_dk.dk_label->d_partitions[part].p_fstype != FS_SWAP)
984 		size = -1;	/* only give valid size for swap partitions */
985 	else
986 		size = xysc->sc_dk.dk_label->d_partitions[part].p_size *
987 		    (xysc->sc_dk.dk_label->d_secsize / DEV_BSIZE);
988 	if (omask == 0 && xyclose(dev, 0, S_IFBLK, NULL) != 0)
989 		return (-1);
990 	return (size);
991 }
992 
993 /*
994  * xystrategy: buffering system interface to xy.
995  */
996 void
997 xystrategy(struct buf *bp)
998 {
999 	struct xy_softc *xy;
1000 	int     s, unit;
1001 	struct disklabel *lp;
1002 	daddr_t blkno;
1003 
1004 	unit = DISKUNIT(bp->b_dev);
1005 
1006 	/* check for live device */
1007 
1008 	if (unit >= xy_cd.cd_ndevs || (xy = xy_cd.cd_devs[unit]) == 0 ||
1009 	    bp->b_blkno < 0 ||
1010 	    (bp->b_bcount % xy->sc_dk.dk_label->d_secsize) != 0) {
1011 		bp->b_error = EINVAL;
1012 		goto done;
1013 	}
1014 
1015 	/* There should always be an open first. */
1016 	if (xy->state == XY_DRIVE_UNKNOWN) {
1017 		bp->b_error = EIO;
1018 		goto done;
1019 	}
1020 	if (xy->state != XY_DRIVE_ONLINE && DISKPART(bp->b_dev) != RAW_PART) {
1021 		/* no I/O to unlabeled disks, unless raw partition */
1022 		bp->b_error = EIO;
1023 		goto done;
1024 	}
1025 	/* short circuit zero length request */
1026 
1027 	if (bp->b_bcount == 0)
1028 		goto done;
1029 
1030 	/* check bounds with label (disksubr.c).  Determine the size of the
1031 	 * transfer, and make sure it is within the boundaries of the
1032 	 * partition. Adjust transfer if needed, and signal errors or early
1033 	 * completion. */
1034 
1035 	lp = xy->sc_dk.dk_label;
1036 
1037 	if (bounds_check_with_label(&xy->sc_dk, bp,
1038 		(xy->flags & XY_WLABEL) != 0) <= 0)
1039 		goto done;
1040 
1041 	/*
1042 	 * Now convert the block number to absolute and put it in
1043 	 * terms of the device's logical block size.
1044 	 */
1045 	blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);
1046 	if (DISKPART(bp->b_dev) != RAW_PART)
1047 		blkno += lp->d_partitions[DISKPART(bp->b_dev)].p_offset;
1048 
1049 	bp->b_rawblkno = blkno;
1050 
1051 	/*
1052 	 * now we know we have a valid buf structure that we need to do I/O
1053 	 * on.
1054 	 */
1055 
1056 	s = splbio();		/* protect the queues */
1057 
1058 	BUFQ_PUT(xy->xyq, bp);	 /* XXX disksort_cylinder */
1059 
1060 	/* start 'em up */
1061 
1062 	xyc_start(xy->parent, NULL);
1063 
1064 	/* done! */
1065 
1066 	splx(s);
1067 	return;
1068 
1069 done:				/* tells upper layers we are done with this
1070 				 * buf */
1071 	bp->b_resid = bp->b_bcount;
1072 	biodone(bp);
1073 }
1074 /*
1075  * end of {b,c}devsw functions
1076  */
1077 
1078 /*
1079  * i n t e r r u p t   f u n c t i o n
1080  *
1081  * xycintr: hardware interrupt.
1082  */
1083 int
1084 xycintr(void *v)
1085 {
1086 	struct xyc_softc *xycsc = v;
1087 
1088 	/* kick the event counter */
1089 	xycsc->sc_intrcnt.ev_count++;
1090 
1091 	/* remove as many done IOPBs as possible */
1092 	xyc_remove_iorq(xycsc);
1093 
1094 	/* start any iorq's already waiting */
1095 	xyc_start(xycsc, NULL);
1096 
1097 	return (1);
1098 }
1099 /*
1100  * end of interrupt function
1101  */
1102 
1103 /*
1104  * i n t e r n a l   f u n c t i o n s
1105  */
1106 
1107 /*
1108  * xyc_rqinit: fill out the fields of an I/O request
1109  */
1110 
1111 inline void
1112 xyc_rqinit(struct xy_iorq *rq, struct xyc_softc *xyc, struct xy_softc *xy,
1113     int md, u_long blk, int cnt, void *db, struct buf *bp)
1114 {
1115 	rq->xyc = xyc;
1116 	rq->xy = xy;
1117 	rq->ttl = XYC_MAXTTL + 10;
1118 	rq->mode = md;
1119 	rq->tries = rq->errno = rq->lasterror = 0;
1120 	rq->blockno = blk;
1121 	rq->sectcnt = cnt;
1122 	rq->dbuf = rq->dbufbase = db;
1123 	rq->buf = bp;
1124 }
1125 
1126 /*
1127  * xyc_rqtopb: load up an IOPB based on an iorq
1128  */
1129 
1130 void
1131 xyc_rqtopb(struct xy_iorq *iorq, struct xy_iopb *iopb, int cmd, int subfun)
1132 {
1133 	u_long  block, dp;
1134 
1135 	/* normal IOPB case, standard stuff */
1136 
1137 	/* chain bit handled later */
1138 	iopb->ien = (XY_STATE(iorq->mode) == XY_SUB_POLL) ? 0 : 1;
1139 	iopb->com = cmd;
1140 	iopb->errno = 0;
1141 	iopb->errs = 0;
1142 	iopb->done = 0;
1143 	if (iorq->xy) {
1144 		iopb->unit = iorq->xy->xy_drive;
1145 		iopb->dt = iorq->xy->drive_type;
1146 	} else {
1147 		iopb->unit = 0;
1148 		iopb->dt = 0;
1149 	}
1150 	block = iorq->blockno;
1151 	if (iorq->xy == NULL || block == 0) {
1152 		iopb->sect = iopb->head = iopb->cyl = 0;
1153 	} else {
1154 		iopb->sect = block % iorq->xy->nsect;
1155 		block = block / iorq->xy->nsect;
1156 		iopb->head = block % iorq->xy->nhead;
1157 		block = block / iorq->xy->nhead;
1158 		iopb->cyl = block;
1159 	}
1160 	iopb->scnt = iorq->sectcnt;
1161 	if (iorq->dbuf == NULL) {
1162 		iopb->dataa = 0;
1163 		iopb->datar = 0;
1164 	} else {
1165 		dp = dvma_kvtopa(iorq->dbuf, iorq->xyc->bustype);
1166 		iopb->dataa = (dp & 0xffff);
1167 		iopb->datar = ((dp & 0xff0000) >> 16);
1168 	}
1169 	iopb->subfn = subfun;
1170 }
1171 
1172 
1173 /*
1174  * xyc_unbusy: wait for the xyc to go unbusy, or timeout.
1175  */
1176 
1177 int
1178 xyc_unbusy(struct xyc *xyc, int del)
1179 {
1180 	while (del-- > 0) {
1181 		if ((xyc->xyc_csr & XYC_GBSY) == 0)
1182 			break;
1183 		DELAY(1);
1184 	}
1185 	return(del == 0 ? XY_ERR_FAIL : XY_ERR_AOK);
1186 }
1187 
1188 /*
1189  * xyc_cmd: front end for POLL'd and WAIT'd commands.  Returns 0 or error.
1190  * note that NORM requests are handled separately.
1191  */
1192 int
1193 xyc_cmd(struct xyc_softc *xycsc, int cmd, int subfn, int unit, int block,
1194     int scnt, char *dptr, int fullmode)
1195 {
1196 	struct xy_iorq *iorq = xycsc->ciorq;
1197 	struct xy_iopb *iopb = xycsc->ciopb;
1198 	int submode = XY_STATE(fullmode);
1199 
1200 	/*
1201 	 * is someone else using the control iopq wait for it if we can
1202 	 */
1203 start:
1204 	if (submode == XY_SUB_WAIT && XY_STATE(iorq->mode) != XY_SUB_FREE) {
1205 		if (tsleep(iorq, PRIBIO, "xyc_cmd", 0))
1206                                 return(XY_ERR_FAIL);
1207 		goto start;
1208 	}
1209 
1210 	if (XY_STATE(iorq->mode) != XY_SUB_FREE) {
1211 		DELAY(1000000);		/* XY_SUB_POLL: steal the iorq */
1212 		iorq->mode = XY_SUB_FREE;
1213 		printf("%s: stole control iopb\n", xycsc->sc_dev.dv_xname);
1214 	}
1215 
1216 	/* init iorq/iopb */
1217 
1218 	xyc_rqinit(iorq, xycsc,
1219 	    (unit == XYC_NOUNIT) ? NULL : xycsc->sc_drives[unit],
1220 	    fullmode, block, scnt, dptr, NULL);
1221 
1222 	/* load IOPB from iorq */
1223 
1224 	xyc_rqtopb(iorq, iopb, cmd, subfn);
1225 
1226 	/* submit it for processing */
1227 
1228 	xyc_submit_iorq(xycsc, iorq, fullmode);	/* error code will be in iorq */
1229 
1230 	return(XY_ERR_AOK);
1231 }
1232 
1233 /*
1234  * xyc_startbuf
1235  * start a buffer for running
1236  */
1237 
1238 int
1239 xyc_startbuf(struct xyc_softc *xycsc, struct xy_softc *xysc, struct buf *bp)
1240 {
1241 	int     partno;
1242 	struct xy_iorq *iorq;
1243 	struct xy_iopb *iopb;
1244 	u_long  block;
1245 	void *dbuf;
1246 
1247 	iorq = xysc->xyrq;
1248 	iopb = iorq->iopb;
1249 
1250 	/* get buf */
1251 
1252 	if (bp == NULL)
1253 		panic("xyc_startbuf null buf");
1254 
1255 	partno = DISKPART(bp->b_dev);
1256 #ifdef XYC_DEBUG
1257 	printf("xyc_startbuf: %s%c: %s block %d\n", xysc->sc_dev.dv_xname,
1258 	    'a' + partno, (bp->b_flags & B_READ) ? "read" : "write", bp->b_blkno);
1259 	printf("xyc_startbuf: b_bcount %d, b_data 0x%x\n",
1260 	    bp->b_bcount, bp->b_data);
1261 #endif
1262 
1263 	/*
1264 	 * load request.
1265 	 *
1266 	 * also, note that there are two kinds of buf structures, those with
1267 	 * B_PHYS set and those without B_PHYS.   if B_PHYS is set, then it is
1268 	 * a raw I/O (to a cdevsw) and we are doing I/O directly to the users'
1269 	 * buffer which has already been mapped into DVMA space. (Not on sun3)
1270 	 * However, if B_PHYS is not set, then the buffer is a normal system
1271 	 * buffer which does *not* live in DVMA space.  In that case we call
1272 	 * dvma_mapin to map it into DVMA space so we can do the DMA to it.
1273 	 *
1274 	 * in cases where we do a dvma_mapin, note that iorq points to the buffer
1275 	 * as mapped into DVMA space, where as the bp->b_data points to its
1276 	 * non-DVMA mapping.
1277 	 *
1278 	 * XXX - On the sun3, B_PHYS does NOT mean the buffer is mapped
1279 	 * into dvma space, only that it was remapped into the kernel.
1280 	 * We ALWAYS have to remap the kernel buf into DVMA space.
1281 	 * (It is done inexpensively, using whole segments!)
1282 	 */
1283 
1284 	block = bp->b_rawblkno;
1285 
1286 	dbuf = dvma_mapin(bp->b_data, bp->b_bcount, 0);
1287 	if (dbuf == NULL) {	/* out of DVMA space */
1288 		printf("%s: warning: out of DVMA space\n",
1289 			   xycsc->sc_dev.dv_xname);
1290 		return (XY_ERR_FAIL);	/* XXX: need some sort of
1291 		                         * call-back scheme here? */
1292 	}
1293 
1294 	/* init iorq and load iopb from it */
1295 
1296 	xyc_rqinit(iorq, xycsc, xysc, XY_SUB_NORM | XY_MODE_VERBO, block,
1297 	    bp->b_bcount / XYFM_BPS, dbuf, bp);
1298 
1299 	xyc_rqtopb(iorq, iopb, (bp->b_flags & B_READ) ? XYCMD_RD : XYCMD_WR, 0);
1300 
1301 	/* Instrumentation. */
1302 	disk_busy(&xysc->sc_dk);
1303 
1304 	return (XY_ERR_AOK);
1305 }
1306 
1307 
1308 /*
1309  * xyc_submit_iorq: submit an iorq for processing.  returns XY_ERR_AOK
1310  * if ok.  if it fail returns an error code.  type is XY_SUB_*.
1311  *
1312  * note: caller frees iorq in all cases except NORM
1313  *
1314  * return value:
1315  *   NORM: XY_AOK (req pending), XY_FAIL (couldn't submit request)
1316  *   WAIT: XY_AOK (success), <error-code> (failed)
1317  *   POLL: <same as WAIT>
1318  *   NOQ : <same as NORM>
1319  *
1320  * there are three sources for i/o requests:
1321  * [1] xystrategy: normal block I/O, using "struct buf" system.
1322  * [2] autoconfig/crash dump: these are polled I/O requests, no interrupts.
1323  * [3] open/ioctl: these are I/O requests done in the context of a process,
1324  *                 and the process should block until they are done.
1325  *
1326  * software state is stored in the iorq structure.  each iorq has an
1327  * iopb structure.  the hardware understands the iopb structure.
1328  * every command must go through an iopb.  a 450 handles one iopb at a
1329  * time, where as a 451 can take them in chains.  [the 450 claims it
1330  * can handle chains, but is appears to be buggy...]   iopb are allocated
1331  * in DVMA space at boot up time.  each disk gets one iopb, and the
1332  * controller gets one (for POLL and WAIT commands).  what happens if
1333  * the iopb is busy?  for i/o type [1], the buffers are queued at the
1334  * "buff" layer and * picked up later by the interrupt routine.  for case
1335  * [2] we can only be blocked if there is a WAIT type I/O request being
1336  * run.   since this can only happen when we are crashing, we wait a sec
1337  * and then steal the IOPB.  for case [3] the process can sleep
1338  * on the iorq free list until some iopbs are available.
1339  */
1340 
1341 int
1342 xyc_submit_iorq(struct xyc_softc *xycsc, struct xy_iorq *iorq, int type)
1343 {
1344 	struct xy_iopb *iopb;
1345 	u_long  iopbaddr;
1346 
1347 #ifdef XYC_DEBUG
1348 	printf("xyc_submit_iorq(%s, addr=0x%x, type=%d)\n",
1349 		xycsc->sc_dev.dv_xname, iorq, type);
1350 #endif
1351 
1352 	/* first check and see if controller is busy */
1353 	if ((xycsc->xyc->xyc_csr & XYC_GBSY) != 0) {
1354 #ifdef XYC_DEBUG
1355 		printf("xyc_submit_iorq: XYC not ready (BUSY)\n");
1356 #endif
1357 		if (type == XY_SUB_NOQ)
1358 			return (XY_ERR_FAIL);	/* failed */
1359 		switch (type) {
1360 		case XY_SUB_NORM:
1361 			return XY_ERR_AOK;	/* success */
1362 		case XY_SUB_WAIT:
1363 			while (iorq->iopb->done == 0) {
1364 				(void) tsleep(iorq, PRIBIO, "xyciorq", 0);
1365 			}
1366 			return (iorq->errno);
1367 		case XY_SUB_POLL:		/* steal controller */
1368 			iopbaddr = xycsc->xyc->xyc_rsetup; /* RESET */
1369 			if (xyc_unbusy(xycsc->xyc,XYC_RESETUSEC) == XY_ERR_FAIL)
1370 				panic("xyc_submit_iorq: stuck xyc");
1371 			printf("%s: stole controller\n",
1372 				xycsc->sc_dev.dv_xname);
1373 			break;
1374 		default:
1375 			panic("xyc_submit_iorq adding");
1376 		}
1377 	}
1378 
1379 	iopb = xyc_chain(xycsc, iorq);	 /* build chain */
1380 	if (iopb == NULL) { /* nothing doing? */
1381 		if (type == XY_SUB_NORM || type == XY_SUB_NOQ)
1382 			return(XY_ERR_AOK);
1383 		panic("xyc_submit_iorq: xyc_chain failed!");
1384 	}
1385 	iopbaddr = dvma_kvtopa(iopb, xycsc->bustype);
1386 
1387 	XYC_GO(xycsc->xyc, iopbaddr);
1388 
1389 	/* command now running, wrap it up */
1390 	switch (type) {
1391 	case XY_SUB_NORM:
1392 	case XY_SUB_NOQ:
1393 		return (XY_ERR_AOK);	/* success */
1394 	case XY_SUB_WAIT:
1395 		while (iorq->iopb->done == 0) {
1396 			(void) tsleep(iorq, PRIBIO, "xyciorq", 0);
1397 		}
1398 		return (iorq->errno);
1399 	case XY_SUB_POLL:
1400 		return (xyc_piodriver(xycsc, iorq));
1401 	default:
1402 		panic("xyc_submit_iorq wrap up");
1403 	}
1404 	panic("xyc_submit_iorq");
1405 	return 0;	/* not reached */
1406 }
1407 
1408 
1409 /*
1410  * xyc_chain: build a chain.  return dvma address of first element in
1411  * the chain.   iorq != NULL: means we only want that item on the chain.
1412  */
1413 
1414 struct xy_iopb *
1415 xyc_chain(struct xyc_softc *xycsc, struct xy_iorq *iorq)
1416 {
1417 	int togo, chain, hand;
1418 	struct xy_iopb *iopb, *prev_iopb;
1419 
1420 	memset(xycsc->xy_chain, 0, sizeof(xycsc->xy_chain));
1421 
1422 	/*
1423 	 * promote control IOPB to the top
1424 	 */
1425 	if (iorq == NULL) {
1426 		if ((XY_STATE(xycsc->reqs[XYC_CTLIOPB].mode) == XY_SUB_POLL ||
1427 			 XY_STATE(xycsc->reqs[XYC_CTLIOPB].mode) == XY_SUB_WAIT) &&
1428 			xycsc->iopbase[XYC_CTLIOPB].done == 0)
1429 		  iorq = &xycsc->reqs[XYC_CTLIOPB];
1430 	}
1431 
1432 	/*
1433 	 * special case: if iorq != NULL then we have a POLL or WAIT request.
1434 	 * we let these take priority and do them first.
1435 	 */
1436 	if (iorq) {
1437 		xycsc->xy_chain[0] = iorq;
1438 		iorq->iopb->chen = 0;
1439 		return(iorq->iopb);
1440 	}
1441 
1442 	/*
1443 	 * NORM case: do round robin and maybe chain (if allowed and possible)
1444 	 */
1445 
1446 	chain = 0;
1447 	hand = xycsc->xy_hand;
1448 	xycsc->xy_hand = (xycsc->xy_hand + 1) % XYC_MAXIOPB;
1449 
1450 	for (togo = XYC_MAXIOPB ;
1451 		 togo > 0 ;
1452 		 togo--, hand = (hand + 1) % XYC_MAXIOPB)
1453 	{
1454 
1455 		if (XY_STATE(xycsc->reqs[hand].mode) != XY_SUB_NORM ||
1456 			xycsc->iopbase[hand].done)
1457 			continue;   /* not ready-for-i/o */
1458 
1459 		xycsc->xy_chain[chain] = &xycsc->reqs[hand];
1460 		iopb = xycsc->xy_chain[chain]->iopb;
1461 		iopb->chen = 0;
1462 		if (chain != 0) {   /* adding a link to a chain? */
1463 			prev_iopb = xycsc->xy_chain[chain-1]->iopb;
1464 			prev_iopb->chen = 1;
1465 			prev_iopb->nxtiopb = 0xffff &
1466 			  dvma_kvtopa(iopb, xycsc->bustype);
1467 		} else {            /* head of chain */
1468 			iorq = xycsc->xy_chain[chain];
1469 		}
1470 		chain++;
1471 		if (xycsc->no_ols) break;   /* quit if chaining dis-allowed */
1472 	}
1473 	return(iorq ? iorq->iopb : NULL);
1474 }
1475 
1476 /*
1477  * xyc_piodriver
1478  *
1479  * programmed i/o driver.   this function takes over the computer
1480  * and drains off the polled i/o request.   it returns the status of the iorq
1481  * the caller is interesting in.
1482  */
1483 int
1484 xyc_piodriver(struct xyc_softc *xycsc, struct xy_iorq *iorq)
1485 {
1486 	int     nreset = 0;
1487 	int     retval = 0;
1488 	u_long  res;
1489 
1490 #ifdef XYC_DEBUG
1491 	printf("xyc_piodriver(%s, 0x%x)\n", xycsc->sc_dev.dv_xname, iorq);
1492 #endif
1493 
1494 	while (iorq->iopb->done == 0) {
1495 
1496 		res = xyc_unbusy(xycsc->xyc, XYC_MAXTIME);
1497 
1498 		/* we expect some progress soon */
1499 		if (res == XY_ERR_FAIL && nreset >= 2) {
1500 			xyc_reset(xycsc, 0, XY_RSET_ALL, XY_ERR_FAIL, 0);
1501 #ifdef XYC_DEBUG
1502 			printf("xyc_piodriver: timeout\n");
1503 #endif
1504 			return (XY_ERR_FAIL);
1505 		}
1506 		if (res == XY_ERR_FAIL) {
1507 			if (xyc_reset(xycsc, 0,
1508 				      (nreset++ == 0) ? XY_RSET_NONE : iorq,
1509 				      XY_ERR_FAIL,
1510 				      0) == XY_ERR_FAIL)
1511 				return (XY_ERR_FAIL);	/* flushes all but POLL
1512 							 * requests, resets */
1513 			continue;
1514 		}
1515 
1516 		xyc_remove_iorq(xycsc);	 /* may resubmit request */
1517 
1518 		if (iorq->iopb->done == 0)
1519 			xyc_start(xycsc, iorq);
1520 	}
1521 
1522 	/* get return value */
1523 
1524 	retval = iorq->errno;
1525 
1526 #ifdef XYC_DEBUG
1527 	printf("xyc_piodriver: done, retval = 0x%x (%s)\n",
1528 	    iorq->errno, xyc_e2str(iorq->errno));
1529 #endif
1530 
1531 	/* start up any bufs that have queued */
1532 
1533 	xyc_start(xycsc, NULL);
1534 
1535 	return (retval);
1536 }
1537 
1538 /*
1539  * xyc_xyreset: reset one drive.   NOTE: assumes xyc was just reset.
1540  * we steal iopb[XYC_CTLIOPB] for this, but we put it back when we are done.
1541  */
1542 void
1543 xyc_xyreset(struct xyc_softc *xycsc, struct xy_softc *xysc)
1544 {
1545 	struct xy_iopb tmpiopb;
1546 	u_long  addr;
1547 	int     del;
1548 	memcpy(&tmpiopb, xycsc->ciopb, sizeof(tmpiopb));
1549 	xycsc->ciopb->chen = xycsc->ciopb->done = xycsc->ciopb->errs = 0;
1550 	xycsc->ciopb->ien = 0;
1551 	xycsc->ciopb->com = XYCMD_RST;
1552 	xycsc->ciopb->unit = xysc->xy_drive;
1553 	addr = dvma_kvtopa(xycsc->ciopb, xycsc->bustype);
1554 
1555 	XYC_GO(xycsc->xyc, addr);
1556 
1557 	del = XYC_RESETUSEC;
1558 	while (del > 0) {
1559 		if ((xycsc->xyc->xyc_csr & XYC_GBSY) == 0) break;
1560 		DELAY(1);
1561 		del--;
1562 	}
1563 
1564 	if (del <= 0 || xycsc->ciopb->errs) {
1565 		printf("%s: off-line: %s\n", xycsc->sc_dev.dv_xname,
1566 		    xyc_e2str(xycsc->ciopb->errno));
1567 		del = xycsc->xyc->xyc_rsetup;
1568 		if (xyc_unbusy(xycsc->xyc, XYC_RESETUSEC) == XY_ERR_FAIL)
1569 			panic("xyc_reset");
1570 	} else {
1571 		xycsc->xyc->xyc_csr = XYC_IPND;	/* clear IPND */
1572 	}
1573 	memcpy(xycsc->ciopb, &tmpiopb, sizeof(tmpiopb));
1574 }
1575 
1576 
1577 /*
1578  * xyc_reset: reset everything: requests are marked as errors except
1579  * a polled request (which is resubmitted)
1580  */
1581 int
1582 xyc_reset(struct xyc_softc *xycsc, int quiet, struct xy_iorq *blastmode,
1583     int error, struct xy_softc *xysc)
1584 {
1585 	int     del = 0, lcv, retval = XY_ERR_AOK;
1586 	struct xy_iorq *iorq;
1587 
1588 	/* soft reset hardware */
1589 
1590 	if (!quiet)
1591 		printf("%s: soft reset\n", xycsc->sc_dev.dv_xname);
1592 	del = xycsc->xyc->xyc_rsetup;
1593 	del = xyc_unbusy(xycsc->xyc, XYC_RESETUSEC);
1594 	if (del == XY_ERR_FAIL) {
1595 		blastmode = XY_RSET_ALL;	/* dead, flush all requests */
1596 		retval = XY_ERR_FAIL;
1597 	}
1598 	if (xysc)
1599 		xyc_xyreset(xycsc, xysc);
1600 
1601 	/* fix queues based on "blast-mode" */
1602 
1603 	for (lcv = 0; lcv < XYC_MAXIOPB; lcv++) {
1604 		iorq = &xycsc->reqs[lcv];
1605 
1606 		if (XY_STATE(iorq->mode) != XY_SUB_POLL &&
1607 		    XY_STATE(iorq->mode) != XY_SUB_WAIT &&
1608 		    XY_STATE(iorq->mode) != XY_SUB_NORM)
1609 			/* is it active? */
1610 			continue;
1611 
1612 		if (blastmode == XY_RSET_ALL ||
1613 				blastmode != iorq) {
1614 			/* failed */
1615 			iorq->errno = error;
1616 			xycsc->iopbase[lcv].done = xycsc->iopbase[lcv].errs = 1;
1617 			switch (XY_STATE(iorq->mode)) {
1618 			case XY_SUB_NORM:
1619 			    iorq->buf->b_error = EIO;
1620 			    iorq->buf->b_resid =
1621 			       iorq->sectcnt * XYFM_BPS;
1622 				/* Sun3: map/unmap regardless of B_PHYS */
1623 				dvma_mapout(iorq->dbufbase,
1624 				            iorq->buf->b_bcount);
1625 			    (void)BUFQ_GET(iorq->xy->xyq);
1626 			    disk_unbusy(&iorq->xy->sc_dk,
1627 				(iorq->buf->b_bcount - iorq->buf->b_resid),
1628 				(iorq->buf->b_flags & B_READ));
1629 			    biodone(iorq->buf);
1630 			    iorq->mode = XY_SUB_FREE;
1631 			    break;
1632 			case XY_SUB_WAIT:
1633 			    wakeup(iorq);
1634 			case XY_SUB_POLL:
1635 			    iorq->mode =
1636 				XY_NEWSTATE(iorq->mode, XY_SUB_DONE);
1637 			    break;
1638 			}
1639 
1640 		} else {
1641 
1642 			/* resubmit, no need to do anything here */
1643 		}
1644 	}
1645 
1646 	/*
1647 	 * now, if stuff is waiting, start it.
1648 	 * since we just reset it should go
1649 	 */
1650 	xyc_start(xycsc, NULL);
1651 
1652 	return (retval);
1653 }
1654 
1655 /*
1656  * xyc_start: start waiting buffers
1657  */
1658 
1659 void
1660 xyc_start(struct xyc_softc *xycsc, struct xy_iorq *iorq)
1661 {
1662 	int lcv;
1663 	struct xy_softc *xy;
1664 
1665 	if (iorq == NULL) {
1666 		for (lcv = 0; lcv < XYC_MAXDEV ; lcv++) {
1667 			if ((xy = xycsc->sc_drives[lcv]) == NULL) continue;
1668 			if (BUFQ_PEEK(xy->xyq) == NULL) continue;
1669 			if (xy->xyrq->mode != XY_SUB_FREE) continue;
1670 			xyc_startbuf(xycsc, xy, BUFQ_PEEK(xy->xyq));
1671 		}
1672 	}
1673 	xyc_submit_iorq(xycsc, iorq, XY_SUB_NOQ);
1674 }
1675 
1676 /*
1677  * xyc_remove_iorq: remove "done" IOPB's.
1678  */
1679 
1680 int
1681 xyc_remove_iorq(struct xyc_softc *xycsc)
1682 {
1683 	int     errno, rq, comm, errs;
1684 	struct xyc *xyc = xycsc->xyc;
1685 	u_long  addr;
1686 	struct xy_iopb *iopb;
1687 	struct xy_iorq *iorq;
1688 	struct buf *bp;
1689 
1690 	if (xyc->xyc_csr & XYC_DERR) {
1691 		/*
1692 		 * DOUBLE ERROR: should never happen under normal use. This
1693 		 * error is so bad, you can't even tell which IOPB is bad, so
1694 		 * we dump them all.
1695 		 */
1696 		errno = XY_ERR_DERR;
1697 		printf("%s: DOUBLE ERROR!\n", xycsc->sc_dev.dv_xname);
1698 		if (xyc_reset(xycsc, 0, XY_RSET_ALL, errno, 0) != XY_ERR_AOK) {
1699 			printf("%s: soft reset failed!\n",
1700 				xycsc->sc_dev.dv_xname);
1701 			panic("xyc_remove_iorq: controller DEAD");
1702 		}
1703 		return (XY_ERR_AOK);
1704 	}
1705 
1706 	/*
1707 	 * get iopb that is done, loop down the chain
1708 	 */
1709 
1710 	if (xyc->xyc_csr & XYC_ERR) {
1711 		xyc->xyc_csr = XYC_ERR; /* clear error condition */
1712 	}
1713 	if (xyc->xyc_csr & XYC_IPND) {
1714 		xyc->xyc_csr = XYC_IPND; /* clear interrupt */
1715 	}
1716 
1717 	for (rq = 0; rq < XYC_MAXIOPB; rq++) {
1718 		iorq = xycsc->xy_chain[rq];
1719 		if (iorq == NULL) break; /* done ! */
1720 		if (iorq->mode == 0 || XY_STATE(iorq->mode) == XY_SUB_DONE)
1721 			continue;	/* free, or done */
1722 		iopb = iorq->iopb;
1723 		if (iopb->done == 0)
1724 			continue;	/* not done yet */
1725 
1726 		comm = iopb->com;
1727 		errs = iopb->errs;
1728 
1729 		if (errs)
1730 			iorq->errno = iopb->errno;
1731 		else
1732 			iorq->errno = 0;
1733 
1734 		/* handle non-fatal errors */
1735 
1736 		if (errs &&
1737 		    xyc_error(xycsc, iorq, iopb, comm) == XY_ERR_AOK)
1738 			continue;	/* AOK: we resubmitted it */
1739 
1740 
1741 		/* this iorq is now done (hasn't been restarted or anything) */
1742 
1743 		if ((iorq->mode & XY_MODE_VERBO) && iorq->lasterror)
1744 			xyc_perror(iorq, iopb, 0);
1745 
1746 		/* now, if read/write check to make sure we got all the data
1747 		 * we needed. (this may not be the case if we got an error in
1748 		 * the middle of a multisector request).   */
1749 
1750 		if ((iorq->mode & XY_MODE_B144) != 0 && errs == 0 &&
1751 		    (comm == XYCMD_RD || comm == XYCMD_WR)) {
1752 			/* we just successfully processed a bad144 sector
1753 			 * note: if we are in bad 144 mode, the pointers have
1754 			 * been advanced already (see above) and are pointing
1755 			 * at the bad144 sector.   to exit bad144 mode, we
1756 			 * must advance the pointers 1 sector and issue a new
1757 			 * request if there are still sectors left to process
1758 			 *
1759 			 */
1760 			XYC_ADVANCE(iorq, 1);	/* advance 1 sector */
1761 
1762 			/* exit b144 mode */
1763 			iorq->mode = iorq->mode & (~XY_MODE_B144);
1764 
1765 			if (iorq->sectcnt) {	/* more to go! */
1766 				iorq->lasterror = iorq->errno = iopb->errno = 0;
1767 				iopb->errs = iopb->done = 0;
1768 				iorq->tries = 0;
1769 				iopb->scnt = iorq->sectcnt;
1770 				iopb->cyl = iorq->blockno /
1771 						iorq->xy->sectpercyl;
1772 				iopb->head =
1773 					(iorq->blockno / iorq->xy->nhead) %
1774 						iorq->xy->nhead;
1775 				iopb->sect = iorq->blockno % XYFM_BPS;
1776 				addr = dvma_kvtopa(iorq->dbuf, xycsc->bustype);
1777 				iopb->dataa = (addr & 0xffff);
1778 				iopb->datar = ((addr & 0xff0000) >> 16);
1779 				/* will resubit at end */
1780 				continue;
1781 			}
1782 		}
1783 		/* final cleanup, totally done with this request */
1784 
1785 		switch (XY_STATE(iorq->mode)) {
1786 		case XY_SUB_NORM:
1787 			bp = iorq->buf;
1788 			if (errs) {
1789 				bp->b_error = EIO;
1790 				bp->b_resid = iorq->sectcnt * XYFM_BPS;
1791 			} else {
1792 				bp->b_resid = 0;	/* done */
1793 			}
1794 			/* Sun3: map/unmap regardless of B_PHYS */
1795 			dvma_mapout(iorq->dbufbase,
1796 					    iorq->buf->b_bcount);
1797 			(void)BUFQ_GET(iorq->xy->xyq);
1798 			disk_unbusy(&iorq->xy->sc_dk,
1799 			    (bp->b_bcount - bp->b_resid),
1800 			    (bp->b_flags & B_READ));
1801 			iorq->mode = XY_SUB_FREE;
1802 			biodone(bp);
1803 			break;
1804 		case XY_SUB_WAIT:
1805 			iorq->mode = XY_NEWSTATE(iorq->mode, XY_SUB_DONE);
1806 			wakeup(iorq);
1807 			break;
1808 		case XY_SUB_POLL:
1809 			iorq->mode = XY_NEWSTATE(iorq->mode, XY_SUB_DONE);
1810 			break;
1811 		}
1812 	}
1813 
1814 	return (XY_ERR_AOK);
1815 }
1816 
1817 /*
1818  * xyc_perror: print error.
1819  * - if still_trying is true: we got an error, retried and got a
1820  *   different error.  in that case lasterror is the old error,
1821  *   and errno is the new one.
1822  * - if still_trying is not true, then if we ever had an error it
1823  *   is in lasterror. also, if iorq->errno == 0, then we recovered
1824  *   from that error (otherwise iorq->errno == iorq->lasterror).
1825  */
1826 void
1827 xyc_perror(struct xy_iorq *iorq, struct xy_iopb *iopb, int still_trying)
1828 {
1829 
1830 	int     error = iorq->lasterror;
1831 
1832 	printf("%s", (iorq->xy) ? iorq->xy->sc_dev.dv_xname
1833 	    : iorq->xyc->sc_dev.dv_xname);
1834 	if (iorq->buf)
1835 		printf("%c: ", 'a' + DISKPART(iorq->buf->b_dev));
1836 	if (iopb->com == XYCMD_RD || iopb->com == XYCMD_WR)
1837 		printf("%s %d/%d/%d: ",
1838 			(iopb->com == XYCMD_RD) ? "read" : "write",
1839 			iopb->cyl, iopb->head, iopb->sect);
1840 	printf("%s", xyc_e2str(error));
1841 
1842 	if (still_trying)
1843 		printf(" [still trying, new error=%s]", xyc_e2str(iorq->errno));
1844 	else
1845 		if (iorq->errno == 0)
1846 			printf(" [recovered in %d tries]", iorq->tries);
1847 
1848 	printf("\n");
1849 }
1850 
1851 /*
1852  * xyc_error: non-fatal error encountered... recover.
1853  * return AOK if resubmitted, return FAIL if this iopb is done
1854  */
1855 int
1856 xyc_error(struct xyc_softc *xycsc, struct xy_iorq *iorq, struct xy_iopb *iopb,
1857     int comm)
1858 {
1859 	int     errno = iorq->errno;
1860 	int     erract = xyc_entoact(errno);
1861 	int     oldmode, advance, i;
1862 
1863 	if (erract == XY_ERA_RSET) {	/* some errors require a reset */
1864 		oldmode = iorq->mode;
1865 		iorq->mode = XY_SUB_DONE | (~XY_SUB_MASK & oldmode);
1866 		/* make xyc_start ignore us */
1867 		xyc_reset(xycsc, 1, XY_RSET_NONE, errno, iorq->xy);
1868 		iorq->mode = oldmode;
1869 	}
1870 	/* check for read/write to a sector in bad144 table if bad: redirect
1871 	 * request to bad144 area */
1872 
1873 	if ((comm == XYCMD_RD || comm == XYCMD_WR) &&
1874 	    (iorq->mode & XY_MODE_B144) == 0) {
1875 		advance = iorq->sectcnt - iopb->scnt;
1876 		XYC_ADVANCE(iorq, advance);
1877 		if ((i = isbad(&iorq->xy->dkb, iorq->blockno / iorq->xy->sectpercyl,
1878 			    (iorq->blockno / iorq->xy->nsect) % iorq->xy->nhead,
1879 			    iorq->blockno % iorq->xy->nsect)) != -1) {
1880 			iorq->mode |= XY_MODE_B144;	/* enter bad144 mode &
1881 							 * redirect */
1882 			iopb->errno = iopb->done = iopb->errs = 0;
1883 			iopb->scnt = 1;
1884 			iopb->cyl = (iorq->xy->ncyl + iorq->xy->acyl) - 2;
1885 			/* second to last acyl */
1886 			i = iorq->xy->sectpercyl - 1 - i;	/* follow bad144
1887 								 * standard */
1888 			iopb->head = i / iorq->xy->nhead;
1889 			iopb->sect = i % iorq->xy->nhead;
1890 			/* will resubmit when we come out of remove_iorq */
1891 			return (XY_ERR_AOK);	/* recovered! */
1892 		}
1893 	}
1894 
1895 	/*
1896 	 * it isn't a bad144 sector, must be real error! see if we can retry
1897 	 * it?
1898 	 */
1899 	if ((iorq->mode & XY_MODE_VERBO) && iorq->lasterror)
1900 		xyc_perror(iorq, iopb, 1);	/* inform of error state
1901 						 * change */
1902 	iorq->lasterror = errno;
1903 
1904 	if ((erract == XY_ERA_RSET || erract == XY_ERA_HARD)
1905 	    && iorq->tries < XYC_MAXTRIES) {	/* retry? */
1906 		iorq->tries++;
1907 		iorq->errno = iopb->errno = iopb->done = iopb->errs = 0;
1908 		/* will resubmit at end of remove_iorq */
1909 		return (XY_ERR_AOK);	/* recovered! */
1910 	}
1911 
1912 	/* failed to recover from this error */
1913 	return (XY_ERR_FAIL);
1914 }
1915 
1916 /*
1917  * xyc_tick: make sure xy is still alive and ticking (err, kicking).
1918  */
1919 void
1920 xyc_tick(void *arg)
1921 {
1922 	struct xyc_softc *xycsc = arg;
1923 	int     lcv, s, reset = 0;
1924 
1925 	/* reduce ttl for each request if one goes to zero, reset xyc */
1926 	s = splbio();
1927 	for (lcv = 0; lcv < XYC_MAXIOPB; lcv++) {
1928 		if (xycsc->reqs[lcv].mode == 0 ||
1929 		    XY_STATE(xycsc->reqs[lcv].mode) == XY_SUB_DONE)
1930 			continue;
1931 		xycsc->reqs[lcv].ttl--;
1932 		if (xycsc->reqs[lcv].ttl == 0)
1933 			reset = 1;
1934 	}
1935 	if (reset) {
1936 		printf("%s: watchdog timeout\n", xycsc->sc_dev.dv_xname);
1937 		xyc_reset(xycsc, 0, XY_RSET_NONE, XY_ERR_FAIL, NULL);
1938 	}
1939 	splx(s);
1940 
1941 	/* until next time */
1942 
1943 	callout_reset(&xycsc->sc_tick_ch, XYC_TICKCNT, xyc_tick, xycsc);
1944 }
1945 
1946 /*
1947  * xyc_ioctlcmd: this function provides a user level interface to the
1948  * controller via ioctl.   this allows "format" programs to be written
1949  * in user code, and is also useful for some debugging.   we return
1950  * an error code.   called at user priority.
1951  *
1952  * XXX missing a few commands (see the 7053 driver for ideas)
1953  */
1954 int
1955 xyc_ioctlcmd(struct xy_softc *xy, dev_t dev, struct xd_iocmd *xio)
1956 {
1957 	int     s, err, rqno;
1958 	void *dvmabuf = NULL;
1959 	struct xyc_softc *xycsc;
1960 
1961 	/* check sanity of requested command */
1962 
1963 	switch (xio->cmd) {
1964 
1965 	case XYCMD_NOP:	/* no op: everything should be zero */
1966 		if (xio->subfn || xio->dptr || xio->dlen ||
1967 		    xio->block || xio->sectcnt)
1968 			return (EINVAL);
1969 		break;
1970 
1971 	case XYCMD_RD:		/* read / write sectors (up to XD_IOCMD_MAXS) */
1972 	case XYCMD_WR:
1973 		if (xio->subfn || xio->sectcnt > XD_IOCMD_MAXS ||
1974 		    xio->sectcnt * XYFM_BPS != xio->dlen || xio->dptr == NULL)
1975 			return (EINVAL);
1976 		break;
1977 
1978 	case XYCMD_SK:		/* seek: doesn't seem useful to export this */
1979 		return (EINVAL);
1980 
1981 		break;
1982 
1983 	default:
1984 		return (EINVAL);/* ??? */
1985 	}
1986 
1987 	/* create DVMA buffer for request if needed */
1988 
1989 	if (xio->dlen) {
1990 		dvmabuf = dvma_malloc(xio->dlen);
1991 		if (xio->cmd == XYCMD_WR) {
1992 			err = copyin(xio->dptr, dvmabuf, xio->dlen);
1993 			if (err) {
1994 				dvma_free(dvmabuf, xio->dlen);
1995 				return (err);
1996 			}
1997 		}
1998 	}
1999 	/* do it! */
2000 
2001 	err = 0;
2002 	xycsc = xy->parent;
2003 	s = splbio();
2004 	rqno = xyc_cmd(xycsc, xio->cmd, xio->subfn, xy->xy_drive, xio->block,
2005 	    xio->sectcnt, dvmabuf, XY_SUB_WAIT);
2006 	if (rqno == XY_ERR_FAIL) {
2007 		err = EIO;
2008 		goto done;
2009 	}
2010 	xio->errno = xycsc->ciorq->errno;
2011 	xio->tries = xycsc->ciorq->tries;
2012 	XYC_DONE(xycsc, err);
2013 
2014 	if (xio->cmd == XYCMD_RD)
2015 		err = copyout(dvmabuf, xio->dptr, xio->dlen);
2016 
2017 done:
2018 	splx(s);
2019 	if (dvmabuf)
2020 		dvma_free(dvmabuf, xio->dlen);
2021 	return (err);
2022 }
2023 
2024 /*
2025  * xyc_e2str: convert error code number into an error string
2026  */
2027 const char *
2028 xyc_e2str(int no)
2029 {
2030 	switch (no) {
2031 	case XY_ERR_FAIL:
2032 		return ("Software fatal error");
2033 	case XY_ERR_DERR:
2034 		return ("DOUBLE ERROR");
2035 	case XY_ERR_AOK:
2036 		return ("Successful completion");
2037 	case XY_ERR_IPEN:
2038 		return("Interrupt pending");
2039 	case XY_ERR_BCFL:
2040 		return("Busy conflict");
2041 	case XY_ERR_TIMO:
2042 		return("Operation timeout");
2043 	case XY_ERR_NHDR:
2044 		return("Header not found");
2045 	case XY_ERR_HARD:
2046 		return("Hard ECC error");
2047 	case XY_ERR_ICYL:
2048 		return("Illegal cylinder address");
2049 	case XY_ERR_ISEC:
2050 		return("Illegal sector address");
2051 	case XY_ERR_SMAL:
2052 		return("Last sector too small");
2053 	case XY_ERR_SACK:
2054 		return("Slave ACK error (non-existent memory)");
2055 	case XY_ERR_CHER:
2056 		return("Cylinder and head/header error");
2057 	case XY_ERR_SRTR:
2058 		return("Auto-seek retry successful");
2059 	case XY_ERR_WPRO:
2060 		return("Write-protect error");
2061 	case XY_ERR_UIMP:
2062 		return("Unimplemented command");
2063 	case XY_ERR_DNRY:
2064 		return("Drive not ready");
2065 	case XY_ERR_SZER:
2066 		return("Sector count zero");
2067 	case XY_ERR_DFLT:
2068 		return("Drive faulted");
2069 	case XY_ERR_ISSZ:
2070 		return("Illegal sector size");
2071 	case XY_ERR_SLTA:
2072 		return("Self test A");
2073 	case XY_ERR_SLTB:
2074 		return("Self test B");
2075 	case XY_ERR_SLTC:
2076 		return("Self test C");
2077 	case XY_ERR_SOFT:
2078 		return("Soft ECC error");
2079 	case XY_ERR_SFOK:
2080 		return("Soft ECC error recovered");
2081 	case XY_ERR_IHED:
2082 		return("Illegal head");
2083 	case XY_ERR_DSEQ:
2084 		return("Disk sequencer error");
2085 	case XY_ERR_SEEK:
2086 		return("Seek error");
2087 	default:
2088 		return ("Unknown error");
2089 	}
2090 }
2091 
2092 int
2093 xyc_entoact(int errno)
2094 {
2095 	switch (errno) {
2096 	case XY_ERR_FAIL:	case XY_ERR_DERR:	case XY_ERR_IPEN:
2097 	case XY_ERR_BCFL:	case XY_ERR_ICYL:	case XY_ERR_ISEC:
2098 	case XY_ERR_UIMP:	case XY_ERR_SZER:	case XY_ERR_ISSZ:
2099 	case XY_ERR_SLTA:	case XY_ERR_SLTB:	case XY_ERR_SLTC:
2100 	case XY_ERR_IHED:	case XY_ERR_SACK:	case XY_ERR_SMAL:
2101 
2102 		return(XY_ERA_PROG); /* program error ! */
2103 
2104 	case XY_ERR_TIMO:	case XY_ERR_NHDR:	case XY_ERR_HARD:
2105 	case XY_ERR_DNRY:	case XY_ERR_CHER:	case XY_ERR_SEEK:
2106 	case XY_ERR_SOFT:
2107 
2108 		return(XY_ERA_HARD); /* hard error, retry */
2109 
2110 	case XY_ERR_DFLT:	case XY_ERR_DSEQ:
2111 
2112 		return(XY_ERA_RSET); /* hard error reset */
2113 
2114 	case XY_ERR_SRTR:	case XY_ERR_SFOK:	case XY_ERR_AOK:
2115 
2116 		return(XY_ERA_SOFT); /* an FYI error */
2117 
2118 	case XY_ERR_WPRO:
2119 
2120 		return(XY_ERA_WPRO); /* write protect */
2121 	}
2122 
2123 	return(XY_ERA_PROG); /* ??? */
2124 }
2125