xref: /openbsd-src/sys/dev/ic/ami.c (revision a28daedfc357b214be5c701aa8ba8adb29a7f1c2)
1 /*	$OpenBSD: ami.c,v 1.192 2009/02/16 21:19:06 miod Exp $	*/
2 
3 /*
4  * Copyright (c) 2001 Michael Shalayeff
5  * Copyright (c) 2005 Marco Peereboom
6  * Copyright (c) 2006 David Gwynne
7  * All rights reserved.
8  *
9  * The SCSI emulation layer is derived from gdt(4) driver,
10  * Copyright (c) 1999, 2000 Niklas Hallqvist. All rights reserved.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  * 2. Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24  * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
25  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27  * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
30  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31  * THE POSSIBILITY OF SUCH DAMAGE.
32  */
33 /*
34  * American Megatrends Inc. MegaRAID controllers driver
35  *
36  * This driver was made because these ppl and organizations
37  * donated hardware and provided documentation:
38  *
39  * - 428 model card
40  *	John Kerbawy, Stephan Matis, Mark Stovall;
41  *
42  * - 467 and 475 model cards, docs
43  *	American Megatrends Inc.;
44  *
45  * - uninterruptable electric power for cvs
46  *	Theo de Raadt.
47  */
48 
49 #include "bio.h"
50 
51 /* #define	AMI_DEBUG */
52 
53 #include <sys/param.h>
54 #include <sys/systm.h>
55 #include <sys/buf.h>
56 #include <sys/ioctl.h>
57 #include <sys/device.h>
58 #include <sys/kernel.h>
59 #include <sys/malloc.h>
60 #include <sys/proc.h>
61 #include <sys/rwlock.h>
62 
63 #include <machine/bus.h>
64 
65 #include <scsi/scsi_all.h>
66 #include <scsi/scsi_disk.h>
67 #include <scsi/scsiconf.h>
68 
69 #include <dev/biovar.h>
70 #include <dev/ic/amireg.h>
71 #include <dev/ic/amivar.h>
72 
73 #ifdef AMI_DEBUG
74 #define	AMI_DPRINTF(m,a)	do { if (ami_debug & (m)) printf a; } while (0)
75 #define	AMI_D_CMD	0x0001
76 #define	AMI_D_INTR	0x0002
77 #define	AMI_D_MISC	0x0004
78 #define	AMI_D_DMA	0x0008
79 #define	AMI_D_IOCTL	0x0010
80 int ami_debug = 0
81 /*	| AMI_D_CMD */
82 /*	| AMI_D_INTR */
83 /*	| AMI_D_MISC */
84 /*	| AMI_D_DMA */
85 /*	| AMI_D_IOCTL */
86 	;
87 #else
88 #define	AMI_DPRINTF(m,a)	/* m, a */
89 #endif
90 
91 struct cfdriver ami_cd = {
92 	NULL, "ami", DV_DULL
93 };
94 
95 int	ami_scsi_cmd(struct scsi_xfer *);
96 int	ami_scsi_ioctl(struct scsi_link *, u_long, caddr_t, int, struct proc *);
97 void	amiminphys(struct buf *bp, struct scsi_link *sl);
98 
99 struct scsi_adapter ami_switch = {
100 	ami_scsi_cmd, amiminphys, 0, 0, ami_scsi_ioctl
101 };
102 
103 struct scsi_device ami_dev = {
104 	NULL, NULL, NULL, NULL
105 };
106 
107 int	ami_scsi_raw_cmd(struct scsi_xfer *);
108 
109 struct scsi_adapter ami_raw_switch = {
110 	ami_scsi_raw_cmd, amiminphys, 0, 0,
111 };
112 
113 struct scsi_device ami_raw_dev = {
114 	NULL, NULL, NULL, NULL
115 };
116 
117 void		ami_remove_runq(struct ami_ccb *);
118 void		ami_insert_runq(struct ami_ccb *);
119 struct ami_ccb	*ami_get_ccb(struct ami_softc *);
120 void		ami_put_ccb(struct ami_ccb *);
121 
122 u_int32_t	ami_read(struct ami_softc *, bus_size_t);
123 void		ami_write(struct ami_softc *, bus_size_t, u_int32_t);
124 
125 void		ami_copyhds(struct ami_softc *, const u_int32_t *,
126 		    const u_int8_t *, const u_int8_t *);
127 struct ami_mem	*ami_allocmem(struct ami_softc *, size_t);
128 void		ami_freemem(struct ami_softc *, struct ami_mem *);
129 int		ami_alloc_ccbs(struct ami_softc *, int);
130 
131 int		ami_poll(struct ami_softc *, struct ami_ccb *);
132 void		ami_start(struct ami_softc *, struct ami_ccb *);
133 void		ami_complete(struct ami_softc *, struct ami_ccb *, int);
134 int		ami_done(struct ami_softc *, int, int);
135 void		ami_runqueue_tick(void *);
136 void		ami_runqueue(struct ami_softc *);
137 
138 int 		ami_start_xs(struct ami_softc *sc, struct ami_ccb *,
139 		    struct scsi_xfer *);
140 void		ami_done_xs(struct ami_softc *, struct ami_ccb *);
141 void		ami_done_pt(struct ami_softc *, struct ami_ccb *);
142 void		ami_done_flush(struct ami_softc *, struct ami_ccb *);
143 void		ami_done_sysflush(struct ami_softc *, struct ami_ccb *);
144 void		ami_stimeout(void *);
145 
146 void		ami_done_dummy(struct ami_softc *, struct ami_ccb *);
147 void		ami_done_ioctl(struct ami_softc *, struct ami_ccb *);
148 void		ami_done_init(struct ami_softc *, struct ami_ccb *);
149 
150 void		ami_copy_internal_data(struct scsi_xfer *, void *, size_t);
151 
152 int		ami_load_ptmem(struct ami_softc*, struct ami_ccb *,
153 		    void *, size_t, int, int);
154 
155 #if NBIO > 0
156 int		ami_mgmt(struct ami_softc *, u_int8_t, u_int8_t, u_int8_t,
157 		    u_int8_t, size_t, void *);
158 int		ami_drv_pt(struct ami_softc *, u_int8_t, u_int8_t, u_int8_t *,
159 		    int, int, void *);
160 int		ami_drv_readcap(struct ami_softc *, u_int8_t, u_int8_t,
161 		    daddr64_t *);
162 int		ami_drv_inq(struct ami_softc *, u_int8_t, u_int8_t, u_int8_t,
163 		    void *);
164 int		ami_ioctl(struct device *, u_long, caddr_t);
165 int		ami_ioctl_inq(struct ami_softc *, struct bioc_inq *);
166 int		ami_vol(struct ami_softc *, struct bioc_vol *,
167 		    struct ami_big_diskarray *);
168 int		ami_disk(struct ami_softc *, struct bioc_disk *,
169 		    struct ami_big_diskarray *);
170 int		ami_ioctl_vol(struct ami_softc *, struct bioc_vol *);
171 int		ami_ioctl_disk(struct ami_softc *, struct bioc_disk *);
172 int		ami_ioctl_alarm(struct ami_softc *, struct bioc_alarm *);
173 int		ami_ioctl_setstate(struct ami_softc *, struct bioc_setstate *);
174 
175 #ifndef SMALL_KERNEL
176 int		ami_create_sensors(struct ami_softc *);
177 void		ami_refresh_sensors(void *);
178 #endif
179 #endif /* NBIO > 0 */
180 
181 #define DEVNAME(_s)	((_s)->sc_dev.dv_xname)
182 
183 void
184 ami_remove_runq(struct ami_ccb *ccb)
185 {
186 	splassert(IPL_BIO);
187 
188 	TAILQ_REMOVE(&ccb->ccb_sc->sc_ccb_runq, ccb, ccb_link);
189 	if (TAILQ_EMPTY(&ccb->ccb_sc->sc_ccb_runq)) {
190 		ccb->ccb_sc->sc_drained = 1;
191 		if (ccb->ccb_sc->sc_drainio)
192 			wakeup(ccb->ccb_sc);
193 	}
194 }
195 
196 void
197 ami_insert_runq(struct ami_ccb *ccb)
198 {
199 	splassert(IPL_BIO);
200 
201 	ccb->ccb_sc->sc_drained = 0;
202 	TAILQ_INSERT_TAIL(&ccb->ccb_sc->sc_ccb_runq, ccb, ccb_link);
203 }
204 
205 struct ami_ccb *
206 ami_get_ccb(struct ami_softc *sc)
207 {
208 	struct ami_ccb *ccb;
209 
210 	splassert(IPL_BIO);
211 
212 	ccb = TAILQ_FIRST(&sc->sc_ccb_freeq);
213 	if (ccb) {
214 		TAILQ_REMOVE(&sc->sc_ccb_freeq, ccb, ccb_link);
215 		ccb->ccb_state = AMI_CCB_READY;
216 	}
217 
218 	return (ccb);
219 }
220 
221 void
222 ami_put_ccb(struct ami_ccb *ccb)
223 {
224 	struct ami_softc *sc = ccb->ccb_sc;
225 
226 	splassert(IPL_BIO);
227 
228 	ccb->ccb_state = AMI_CCB_FREE;
229 	ccb->ccb_xs = NULL;
230 	ccb->ccb_flags = 0;
231 	ccb->ccb_done = NULL;
232 	TAILQ_INSERT_TAIL(&sc->sc_ccb_freeq, ccb, ccb_link);
233 }
234 
235 u_int32_t
236 ami_read(struct ami_softc *sc, bus_size_t r)
237 {
238 	u_int32_t rv;
239 
240 	bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
241 	    BUS_SPACE_BARRIER_READ);
242 	rv = bus_space_read_4(sc->sc_iot, sc->sc_ioh, r);
243 
244 	AMI_DPRINTF(AMI_D_CMD, ("ari 0x%x 0x08%x ", r, rv));
245 	return (rv);
246 }
247 
248 void
249 ami_write(struct ami_softc *sc, bus_size_t r, u_int32_t v)
250 {
251 	AMI_DPRINTF(AMI_D_CMD, ("awo 0x%x 0x%08x ", r, v));
252 
253 	bus_space_write_4(sc->sc_iot, sc->sc_ioh, r, v);
254 	bus_space_barrier(sc->sc_iot, sc->sc_ioh, r, 4,
255 	    BUS_SPACE_BARRIER_WRITE);
256 }
257 
258 struct ami_mem *
259 ami_allocmem(struct ami_softc *sc, size_t size)
260 {
261 	struct ami_mem		*am;
262 	int			nsegs;
263 
264 	am = malloc(sizeof(struct ami_mem), M_DEVBUF, M_NOWAIT|M_ZERO);
265 	if (am == NULL)
266 		return (NULL);
267 
268 	am->am_size = size;
269 
270 	if (bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
271 	    BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &am->am_map) != 0)
272 		goto amfree;
273 
274 	if (bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &am->am_seg, 1,
275 	    &nsegs, BUS_DMA_NOWAIT) != 0)
276 		goto destroy;
277 
278 	if (bus_dmamem_map(sc->sc_dmat, &am->am_seg, nsegs, size, &am->am_kva,
279 	    BUS_DMA_NOWAIT) != 0)
280 		goto free;
281 
282 	if (bus_dmamap_load(sc->sc_dmat, am->am_map, am->am_kva, size, NULL,
283 	    BUS_DMA_NOWAIT) != 0)
284 		goto unmap;
285 
286 	memset(am->am_kva, 0, size);
287 	return (am);
288 
289 unmap:
290 	bus_dmamem_unmap(sc->sc_dmat, am->am_kva, size);
291 free:
292 	bus_dmamem_free(sc->sc_dmat, &am->am_seg, 1);
293 destroy:
294 	bus_dmamap_destroy(sc->sc_dmat, am->am_map);
295 amfree:
296 	free(am, M_DEVBUF);
297 
298 	return (NULL);
299 }
300 
301 void
302 ami_freemem(struct ami_softc *sc, struct ami_mem *am)
303 {
304 	bus_dmamap_unload(sc->sc_dmat, am->am_map);
305 	bus_dmamem_unmap(sc->sc_dmat, am->am_kva, am->am_size);
306 	bus_dmamem_free(sc->sc_dmat, &am->am_seg, 1);
307 	bus_dmamap_destroy(sc->sc_dmat, am->am_map);
308 	free(am, M_DEVBUF);
309 }
310 
311 void
312 ami_copyhds(struct ami_softc *sc, const u_int32_t *sizes,
313     const u_int8_t *props, const u_int8_t *stats)
314 {
315 	int i;
316 
317 	for (i = 0; i < sc->sc_nunits; i++) {
318 		sc->sc_hdr[i].hd_present = 1;
319 		sc->sc_hdr[i].hd_is_logdrv = 1;
320 		sc->sc_hdr[i].hd_size = letoh32(sizes[i]);
321 		sc->sc_hdr[i].hd_prop = props[i];
322 		sc->sc_hdr[i].hd_stat = stats[i];
323 	}
324 }
325 
326 int
327 ami_alloc_ccbs(struct ami_softc *sc, int nccbs)
328 {
329 	struct ami_ccb *ccb;
330 	struct ami_ccbmem *ccbmem, *mem;
331 	int i, s, error;
332 
333 	sc->sc_ccbs = malloc(sizeof(struct ami_ccb) * nccbs,
334 	    M_DEVBUF, M_NOWAIT);
335 	if (sc->sc_ccbs == NULL) {
336 		printf(": unable to allocate ccbs\n");
337 		return (1);
338 	}
339 
340 	sc->sc_ccbmem_am = ami_allocmem(sc, sizeof(struct ami_ccbmem) * nccbs);
341 	if (sc->sc_ccbmem_am == NULL) {
342 		printf(": unable to allocate ccb dmamem\n");
343 		goto free_ccbs;
344 	}
345 	ccbmem = AMIMEM_KVA(sc->sc_ccbmem_am);
346 
347 	TAILQ_INIT(&sc->sc_ccb_freeq);
348 	TAILQ_INIT(&sc->sc_ccb_preq);
349 	TAILQ_INIT(&sc->sc_ccb_runq);
350 	timeout_set(&sc->sc_run_tmo, ami_runqueue_tick, sc);
351 
352 	for (i = 0; i < nccbs; i++) {
353 		ccb = &sc->sc_ccbs[i];
354 		mem = &ccbmem[i];
355 
356 		error = bus_dmamap_create(sc->sc_dmat, AMI_MAXFER,
357 		    AMI_MAXOFFSETS, AMI_MAXFER, 0,
358 		    BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &ccb->ccb_dmamap);
359 		if (error) {
360 			printf(": cannot create ccb dmamap (%d)\n", error);
361 			goto free_list;
362 		}
363 
364 		ccb->ccb_sc = sc;
365 
366 		ccb->ccb_cmd.acc_id = i + 1;
367 		ccb->ccb_offset = sizeof(struct ami_ccbmem) * i;
368 
369 		ccb->ccb_pt = &mem->cd_pt;
370 		ccb->ccb_ptpa = htole32(AMIMEM_DVA(sc->sc_ccbmem_am) +
371 		    ccb->ccb_offset);
372 
373 		ccb->ccb_sglist = mem->cd_sg;
374 		ccb->ccb_sglistpa = htole32(AMIMEM_DVA(sc->sc_ccbmem_am) +
375 		    ccb->ccb_offset + sizeof(struct ami_passthrough));
376 
377 		/* override last command for management */
378 		if (i == nccbs - 1) {
379 			ccb->ccb_cmd.acc_id = 0xfe;
380 			sc->sc_mgmtccb = ccb;
381 		} else {
382 			s = splbio();
383 			ami_put_ccb(ccb);
384 			splx(s);
385 		}
386 	}
387 
388 	return (0);
389 
390 free_list:
391 	while ((ccb = ami_get_ccb(sc)) != NULL)
392 		bus_dmamap_destroy(sc->sc_dmat, ccb->ccb_dmamap);
393 
394 	ami_freemem(sc, sc->sc_ccbmem_am);
395 free_ccbs:
396 	free(sc->sc_ccbs, M_DEVBUF);
397 
398 	return (1);
399 }
400 
401 int
402 ami_attach(struct ami_softc *sc)
403 {
404 	struct scsibus_attach_args saa;
405 	struct ami_rawsoftc *rsc;
406 	struct ami_ccb iccb;
407 	struct ami_iocmd *cmd;
408 	struct ami_mem *am;
409 	struct ami_inquiry *inq;
410 	struct ami_fc_einquiry *einq;
411 	struct ami_fc_prodinfo *pi;
412 	const char *p;
413 	paddr_t	pa;
414 	int s;
415 
416 	am = ami_allocmem(sc, NBPG);
417 	if (am == NULL) {
418 		printf(": unable to allocate init data\n");
419 		return (1);
420 	}
421 	pa = htole32(AMIMEM_DVA(am));
422 
423 	sc->sc_mbox_am = ami_allocmem(sc, sizeof(struct ami_iocmd));
424 	if (sc->sc_mbox_am == NULL) {
425 		printf(": unable to allocate mbox\n");
426 		goto free_idata;
427 	}
428 	sc->sc_mbox = (volatile struct ami_iocmd *)AMIMEM_KVA(sc->sc_mbox_am);
429 	sc->sc_mbox_pa = htole32(AMIMEM_DVA(sc->sc_mbox_am));
430 	AMI_DPRINTF(AMI_D_CMD, ("mbox=%p ", sc->sc_mbox));
431 	AMI_DPRINTF(AMI_D_CMD, ("mbox_pa=0x%llx ", (long long)sc->sc_mbox_pa));
432 
433 	/* create a spartan ccb for use with ami_poll */
434 	bzero(&iccb, sizeof(iccb));
435 	iccb.ccb_sc = sc;
436 	iccb.ccb_done = ami_done_init;
437 	cmd = &iccb.ccb_cmd;
438 
439 	(sc->sc_init)(sc);
440 
441 	s = splbio();
442 
443 	/* try FC inquiry first */
444 	cmd->acc_cmd = AMI_FCOP;
445 	cmd->acc_io.aio_channel = AMI_FC_EINQ3;
446 	cmd->acc_io.aio_param = AMI_FC_EINQ3_SOLICITED_FULL;
447 	cmd->acc_io.aio_data = pa;
448 	if (ami_poll(sc, &iccb) == 0) {
449 		einq = AMIMEM_KVA(am);
450 		pi = AMIMEM_KVA(am);
451 
452 		sc->sc_nunits = einq->ain_nlogdrv;
453 		sc->sc_drvinscnt = einq->ain_drvinscnt + 1; /* force scan */
454 		ami_copyhds(sc, einq->ain_ldsize, einq->ain_ldprop,
455 		    einq->ain_ldstat);
456 
457 		cmd->acc_cmd = AMI_FCOP;
458 		cmd->acc_io.aio_channel = AMI_FC_PRODINF;
459 		cmd->acc_io.aio_param = 0;
460 		cmd->acc_io.aio_data = pa;
461 		if (ami_poll(sc, &iccb) == 0) {
462 			sc->sc_maxunits = AMI_BIG_MAX_LDRIVES;
463 
464 			bcopy (pi->api_fwver, sc->sc_fwver, 16);
465 			sc->sc_fwver[15] = '\0';
466 			bcopy (pi->api_biosver, sc->sc_biosver, 16);
467 			sc->sc_biosver[15] = '\0';
468 			sc->sc_channels = pi->api_channels;
469 			sc->sc_targets = pi->api_fcloops;
470 			sc->sc_memory = letoh16(pi->api_ramsize);
471 			sc->sc_maxcmds = pi->api_maxcmd;
472 			p = "FC loop";
473 		}
474 	}
475 
476 	if (sc->sc_maxunits == 0) {
477 		inq = AMIMEM_KVA(am);
478 
479 		cmd->acc_cmd = AMI_EINQUIRY;
480 		cmd->acc_io.aio_channel = 0;
481 		cmd->acc_io.aio_param = 0;
482 		cmd->acc_io.aio_data = pa;
483 		if (ami_poll(sc, &iccb) != 0) {
484 			cmd->acc_cmd = AMI_INQUIRY;
485 			cmd->acc_io.aio_channel = 0;
486 			cmd->acc_io.aio_param = 0;
487 			cmd->acc_io.aio_data = pa;
488 			if (ami_poll(sc, &iccb) != 0) {
489 				splx(s);
490 				printf(": cannot do inquiry\n");
491 				goto free_mbox;
492 			}
493 		}
494 
495 		sc->sc_maxunits = AMI_MAX_LDRIVES;
496 		sc->sc_nunits = inq->ain_nlogdrv;
497 		ami_copyhds(sc, inq->ain_ldsize, inq->ain_ldprop,
498 		    inq->ain_ldstat);
499 
500 		bcopy (inq->ain_fwver, sc->sc_fwver, 4);
501 		sc->sc_fwver[4] = '\0';
502 		bcopy (inq->ain_biosver, sc->sc_biosver, 4);
503 		sc->sc_biosver[4] = '\0';
504 		sc->sc_channels = inq->ain_channels;
505 		sc->sc_targets = inq->ain_targets;
506 		sc->sc_memory = inq->ain_ramsize;
507 		sc->sc_maxcmds = inq->ain_maxcmd;
508 		sc->sc_drvinscnt = inq->ain_drvinscnt + 1; /* force scan */
509 		p = "target";
510 	}
511 
512 	if (sc->sc_flags & AMI_BROKEN) {
513 		sc->sc_link.openings = 1;
514 		sc->sc_maxcmds = 1;
515 		sc->sc_maxunits = 1;
516 	} else {
517 		sc->sc_maxunits = AMI_BIG_MAX_LDRIVES;
518 		if (sc->sc_maxcmds > AMI_MAXCMDS)
519 			sc->sc_maxcmds = AMI_MAXCMDS;
520 		/*
521 		 * Reserve ccb's for ioctl's and raw commands to
522 		 * processors/enclosures by lowering the number of
523 		 * openings available for logical units.
524 		 */
525 		sc->sc_maxcmds -= AMI_MAXIOCTLCMDS + AMI_MAXPROCS *
526 		    AMI_MAXRAWCMDS * sc->sc_channels;
527 
528 		if (sc->sc_nunits)
529 			sc->sc_link.openings =
530 			    sc->sc_maxcmds / sc->sc_nunits;
531 		else
532 			sc->sc_link.openings = sc->sc_maxcmds;
533 	}
534 
535 	splx(s);
536 
537 	ami_freemem(sc, am);
538 
539 	if (ami_alloc_ccbs(sc, AMI_MAXCMDS + 1) != 0) {
540 		/* error already printed */
541 		goto free_mbox;
542 	}
543 	sc->sc_drained = 1;
544 
545 	/* hack for hp netraid version encoding */
546 	if ('A' <= sc->sc_fwver[2] && sc->sc_fwver[2] <= 'Z' &&
547 	    sc->sc_fwver[1] < ' ' && sc->sc_fwver[0] < ' ' &&
548 	    'A' <= sc->sc_biosver[2] && sc->sc_biosver[2] <= 'Z' &&
549 	    sc->sc_biosver[1] < ' ' && sc->sc_biosver[0] < ' ') {
550 
551 		snprintf(sc->sc_fwver, sizeof sc->sc_fwver, "%c.%02d.%02d",
552 		    sc->sc_fwver[2], sc->sc_fwver[1], sc->sc_fwver[0]);
553 		snprintf(sc->sc_biosver, sizeof sc->sc_biosver, "%c.%02d.%02d",
554 		    sc->sc_biosver[2], sc->sc_biosver[1], sc->sc_biosver[0]);
555 	}
556 
557 	/* TODO: fetch & print cache strategy */
558 	/* TODO: fetch & print scsi and raid info */
559 
560 	sc->sc_link.device = &ami_dev;
561 	sc->sc_link.adapter_softc = sc;
562 	sc->sc_link.adapter = &ami_switch;
563 	sc->sc_link.adapter_target = sc->sc_maxunits;
564 	sc->sc_link.adapter_buswidth = sc->sc_maxunits;
565 
566 #ifdef AMI_DEBUG
567 	printf(", FW %s, BIOS v%s, %dMB RAM\n"
568 	    "%s: %d channels, %d %ss, %d logical drives, "
569 	    "openings %d, max commands %d, quirks: %04x\n",
570 	    sc->sc_fwver, sc->sc_biosver, sc->sc_memory, DEVNAME(sc),
571 	    sc->sc_channels, sc->sc_targets, p, sc->sc_nunits,
572 	    sc->sc_link.openings, sc->sc_maxcmds, sc->sc_flags);
573 #else
574 	printf(", FW %s, BIOS v%s, %dMB RAM\n"
575 	    "%s: %d channels, %d %ss, %d logical drives\n",
576 	    sc->sc_fwver, sc->sc_biosver, sc->sc_memory, DEVNAME(sc),
577 	    sc->sc_channels, sc->sc_targets, p, sc->sc_nunits);
578 #endif /* AMI_DEBUG */
579 
580 	if (sc->sc_flags & AMI_BROKEN && sc->sc_nunits > 1)
581 		printf("%s: firmware buggy, limiting access to first logical "
582 		    "disk\n", DEVNAME(sc));
583 
584 	/* lock around ioctl requests */
585 	rw_init(&sc->sc_lock, NULL);
586 
587 	bzero(&saa, sizeof(saa));
588 	saa.saa_sc_link = &sc->sc_link;
589 
590 	config_found(&sc->sc_dev, &saa, scsiprint);
591 
592 	/* can't do bioctls, sensors, or pass-through on broken devices */
593 	if (sc->sc_flags & AMI_BROKEN)
594 		return (0);
595 
596 #if NBIO > 0
597 	if (bio_register(&sc->sc_dev, ami_ioctl) != 0)
598 		printf("%s: controller registration failed\n", DEVNAME(sc));
599 	else
600 		sc->sc_ioctl = ami_ioctl;
601 
602 #ifndef SMALL_KERNEL
603 	if (ami_create_sensors(sc) != 0)
604 		printf("%s: unable to create sensors\n", DEVNAME(sc));
605 #endif
606 #endif
607 
608 	rsc = malloc(sizeof(struct ami_rawsoftc) * sc->sc_channels,
609 	    M_DEVBUF, M_NOWAIT|M_ZERO);
610 	if (!rsc) {
611 		printf("%s: no memory for raw interface\n", DEVNAME(sc));
612 		return (0);
613 	}
614 
615 	for (sc->sc_rawsoftcs = rsc;
616 	     rsc < &sc->sc_rawsoftcs[sc->sc_channels]; rsc++) {
617 
618 		rsc->sc_softc = sc;
619 		rsc->sc_channel = rsc - sc->sc_rawsoftcs;
620 		rsc->sc_link.device = &ami_raw_dev;
621 		rsc->sc_link.openings = AMI_MAXRAWCMDS;
622 		rsc->sc_link.adapter_softc = rsc;
623 		rsc->sc_link.adapter = &ami_raw_switch;
624 		rsc->sc_proctarget = -1;
625 		/* TODO fetch it from the controller */
626 		rsc->sc_link.adapter_target = 16;
627 		rsc->sc_link.adapter_buswidth = 16;
628 
629 		bzero(&saa, sizeof(saa));
630 		saa.saa_sc_link = &rsc->sc_link;
631 
632 		config_found(&sc->sc_dev, &saa, scsiprint);
633 	}
634 
635 	return (0);
636 
637 free_mbox:
638 	ami_freemem(sc, sc->sc_mbox_am);
639 free_idata:
640 	ami_freemem(sc, am);
641 
642 	return (1);
643 }
644 
645 int
646 ami_quartz_init(struct ami_softc *sc)
647 {
648 	ami_write(sc, AMI_QIDB, 0);
649 
650 	return (0);
651 }
652 
653 int
654 ami_quartz_exec(struct ami_softc *sc, struct ami_iocmd *cmd)
655 {
656 	if (sc->sc_mbox->acc_busy) {
657 		AMI_DPRINTF(AMI_D_CMD, ("mbox_busy "));
658 		return (EBUSY);
659 	}
660 
661 	memcpy((struct ami_iocmd *)sc->sc_mbox, cmd, 16);
662 	bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,
663 	    sizeof(struct ami_iocmd), BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
664 
665 	sc->sc_mbox->acc_busy = 1;
666 	sc->sc_mbox->acc_poll = 0;
667 	sc->sc_mbox->acc_ack = 0;
668 
669 	ami_write(sc, AMI_QIDB, sc->sc_mbox_pa | htole32(AMI_QIDB_EXEC));
670 
671 	return (0);
672 }
673 
674 int
675 ami_quartz_done(struct ami_softc *sc, struct ami_iocmd *mbox)
676 {
677 	u_int32_t i, n;
678 	u_int8_t nstat, status;
679 	u_int8_t completed[AMI_MAXSTATACK];
680 
681 	if (ami_read(sc, AMI_QODB) != AMI_QODB_READY)
682 		return (0); /* nothing to do */
683 
684 	ami_write(sc, AMI_QODB, AMI_QODB_READY);
685 
686 	/*
687 	 * The following sequence is not supposed to have a timeout clause
688 	 * since the firmware has a "guarantee" that all commands will
689 	 * complete.  The choice is either panic or hoping for a miracle
690 	 * and that the IOs will complete much later.
691 	 */
692 	i = 0;
693 	while ((nstat = sc->sc_mbox->acc_nstat) == 0xff) {
694 		bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,
695 		    sizeof(struct ami_iocmd), BUS_DMASYNC_POSTREAD);
696 		delay(1);
697 		if (i++ > 1000000)
698 			return (0); /* nothing to do */
699 	}
700 	sc->sc_mbox->acc_nstat = 0xff;
701 	bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,
702 	    sizeof(struct ami_iocmd), BUS_DMASYNC_POSTWRITE);
703 
704 	/* wait until fw wrote out all completions */
705 	i = 0;
706 	AMI_DPRINTF(AMI_D_CMD, ("aqd %d ", nstat));
707 	for (n = 0; n < nstat; n++) {
708 		bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,
709 		    sizeof(struct ami_iocmd), BUS_DMASYNC_PREREAD);
710 		while ((completed[n] = sc->sc_mbox->acc_cmplidl[n]) == 0xff) {
711 			delay(1);
712 			if (i++ > 1000000)
713 				return (0); /* nothing to do */
714 		}
715 		sc->sc_mbox->acc_cmplidl[n] = 0xff;
716 		bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,
717 		    sizeof(struct ami_iocmd), BUS_DMASYNC_POSTWRITE);
718 	}
719 
720 	/* this should never happen, someone screwed up the completion status */
721 	if ((status = sc->sc_mbox->acc_status) == 0xff)
722 		panic("%s: status 0xff from the firmware", DEVNAME(sc));
723 
724 	sc->sc_mbox->acc_status = 0xff;
725 
726 	/* copy mailbox to temporary one and fixup other changed values */
727 	bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0, 16,
728 	    BUS_DMASYNC_POSTWRITE);
729 	memcpy(mbox, (struct ami_iocmd *)sc->sc_mbox, 16);
730 	mbox->acc_nstat = nstat;
731 	mbox->acc_status = status;
732 	for (n = 0; n < nstat; n++)
733 		mbox->acc_cmplidl[n] = completed[n];
734 
735 	/* ack interrupt */
736 	ami_write(sc, AMI_QIDB, AMI_QIDB_ACK);
737 
738 	return (1);	/* ready to complete all IOs in acc_cmplidl */
739 }
740 
741 int
742 ami_quartz_poll(struct ami_softc *sc, struct ami_iocmd *cmd)
743 {
744 	/* struct scsi_xfer *xs = ccb->ccb_xs; */
745 	u_int32_t i;
746 	u_int8_t status;
747 
748 	splassert(IPL_BIO);
749 
750 	if (sc->sc_dis_poll)
751 		return (-1); /* fail */
752 
753 	i = 0;
754 	while (sc->sc_mbox->acc_busy && (i < AMI_MAX_BUSYWAIT)) {
755 		delay(1);
756 		i++;
757 	}
758 	if (sc->sc_mbox->acc_busy) {
759 		AMI_DPRINTF(AMI_D_CMD, ("mbox_busy "));
760 		return (-1);
761 	}
762 
763 	memcpy((struct ami_iocmd *)sc->sc_mbox, cmd, 16);
764 	bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0, 16,
765 	    BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
766 
767 	sc->sc_mbox->acc_id = 0xfe;
768 	sc->sc_mbox->acc_busy = 1;
769 	sc->sc_mbox->acc_poll = 0;
770 	sc->sc_mbox->acc_ack = 0;
771 	sc->sc_mbox->acc_nstat = 0xff;
772 	sc->sc_mbox->acc_status = 0xff;
773 
774 	/* send command to firmware */
775 	ami_write(sc, AMI_QIDB, sc->sc_mbox_pa | htole32(AMI_QIDB_EXEC));
776 
777 	i = 0;
778 	while ((sc->sc_mbox->acc_nstat == 0xff) && (i < AMI_MAX_POLLWAIT)) {
779 		delay(1);
780 		i++;
781 	}
782 	if (i >= AMI_MAX_POLLWAIT) {
783 		printf("%s: command not accepted, polling disabled\n",
784 		    DEVNAME(sc));
785 		sc->sc_dis_poll = 1;
786 		return (-1);
787 	}
788 
789 	/* poll firmware */
790 	i = 0;
791 	while ((sc->sc_mbox->acc_poll != 0x77) && (i < AMI_MAX_POLLWAIT)) {
792 		delay(1);
793 		i++;
794 	}
795 	if (i >= AMI_MAX_POLLWAIT) {
796 		printf("%s: firmware didn't reply, polling disabled\n",
797 		    DEVNAME(sc));
798 		sc->sc_dis_poll = 1;
799 		return (-1);
800 	}
801 
802 	/* ack */
803 	ami_write(sc, AMI_QIDB, sc->sc_mbox_pa | htole32(AMI_QIDB_ACK));
804 
805 	i = 0;
806 	while((ami_read(sc, AMI_QIDB) & AMI_QIDB_ACK) &&
807 	    (i < AMI_MAX_POLLWAIT)) {
808 		delay(1);
809 		i++;
810 	}
811 	if (i >= AMI_MAX_POLLWAIT) {
812 		printf("%s: firmware didn't ack the ack, polling disabled\n",
813 		    DEVNAME(sc));
814 		sc->sc_dis_poll = 1;
815 		return (-1);
816 	}
817 
818 	sc->sc_mbox->acc_poll = 0;
819 	sc->sc_mbox->acc_ack = 0x77;
820 	status = sc->sc_mbox->acc_status;
821 	sc->sc_mbox->acc_nstat = 0xff;
822 	sc->sc_mbox->acc_status = 0xff;
823 
824 	for (i = 0; i < AMI_MAXSTATACK; i++)
825 		sc->sc_mbox->acc_cmplidl[i] = 0xff;
826 
827 	return (status);
828 }
829 
830 int
831 ami_schwartz_init(struct ami_softc *sc)
832 {
833 	u_int32_t a = (u_int32_t)sc->sc_mbox_pa;
834 
835 	bus_space_write_4(sc->sc_iot, sc->sc_ioh, AMI_SMBADDR, a);
836 	/* XXX 40bit address ??? */
837 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SMBENA, 0);
838 
839 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD, AMI_SCMD_ACK);
840 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SIEM, AMI_SEIM_ENA |
841 	    bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SIEM));
842 
843 	return (0);
844 }
845 
846 int
847 ami_schwartz_exec(struct ami_softc *sc, struct ami_iocmd *cmd)
848 {
849 	if (bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SMBSTAT) &
850 	    AMI_SMBST_BUSY) {
851 		AMI_DPRINTF(AMI_D_CMD, ("mbox_busy "));
852 		return (EBUSY);
853 	}
854 
855 	memcpy((struct ami_iocmd *)sc->sc_mbox, cmd, 16);
856 	sc->sc_mbox->acc_busy = 1;
857 	sc->sc_mbox->acc_poll = 0;
858 	sc->sc_mbox->acc_ack = 0;
859 
860 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD, AMI_SCMD_EXEC);
861 	return (0);
862 }
863 
864 int
865 ami_schwartz_done(struct ami_softc *sc, struct ami_iocmd *mbox)
866 {
867 	u_int8_t stat;
868 
869 #if 0
870 	/* do not scramble the busy mailbox */
871 	if (sc->sc_mbox->acc_busy)
872 		return (0);
873 #endif
874 	if (bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SMBSTAT) &
875 	    AMI_SMBST_BUSY)
876 		return (0);
877 
878 	stat = bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_ISTAT);
879 	if (stat & AMI_ISTAT_PEND) {
880 		bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_ISTAT, stat);
881 
882 		*mbox = *sc->sc_mbox;
883 		AMI_DPRINTF(AMI_D_CMD, ("asd %d ", mbox->acc_nstat));
884 
885 		bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD,
886 		    AMI_SCMD_ACK);
887 
888 		return (1);
889 	}
890 
891 	return (0);
892 }
893 
894 int
895 ami_schwartz_poll(struct ami_softc *sc, struct ami_iocmd *mbox)
896 {
897 	u_int8_t status;
898 	u_int32_t i;
899 	int rv;
900 
901 	splassert(IPL_BIO);
902 
903 	if (sc->sc_dis_poll)
904 		return (-1); /* fail */
905 
906 	for (i = 0; i < AMI_MAX_POLLWAIT; i++) {
907 		if (!(bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SMBSTAT) &
908 		    AMI_SMBST_BUSY))
909 			break;
910 		delay(1);
911 	}
912 	if (i >= AMI_MAX_POLLWAIT) {
913 		AMI_DPRINTF(AMI_D_CMD, ("mbox_busy "));
914 		return (-1);
915 	}
916 
917 	memcpy((struct ami_iocmd *)sc->sc_mbox, mbox, 16);
918 	bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0, 16,
919 	    BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
920 
921 	sc->sc_mbox->acc_busy = 1;
922 	sc->sc_mbox->acc_poll = 0;
923 	sc->sc_mbox->acc_ack = 0;
924 	/* send command to firmware */
925 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD, AMI_SCMD_EXEC);
926 
927 	/* wait until no longer busy */
928 	for (i = 0; i < AMI_MAX_POLLWAIT; i++) {
929 		if (!(bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_SMBSTAT) &
930 		    AMI_SMBST_BUSY))
931 			break;
932 		delay(1);
933 	}
934 	if (i >= AMI_MAX_POLLWAIT) {
935 		printf("%s: command not accepted, polling disabled\n",
936 		    DEVNAME(sc));
937 		sc->sc_dis_poll = 1;
938 		return (-1);
939 	}
940 
941 	/* wait for interrupt bit */
942 	for (i = 0; i < AMI_MAX_POLLWAIT; i++) {
943 		status = bus_space_read_1(sc->sc_iot, sc->sc_ioh, AMI_ISTAT);
944 		if (status & AMI_ISTAT_PEND)
945 			break;
946 		delay(1);
947 	}
948 	if (i >= AMI_MAX_POLLWAIT) {
949 		printf("%s: interrupt didn't arrive, polling disabled\n",
950 		    DEVNAME(sc));
951 		sc->sc_dis_poll = 1;
952 		return (-1);
953 	}
954 
955 	/* write ststus back to firmware */
956 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_ISTAT, status);
957 
958 	/* copy mailbox and status back */
959 	bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_mbox_am), 0,
960 	    sizeof(struct ami_iocmd), BUS_DMASYNC_PREREAD);
961 	*mbox = *sc->sc_mbox;
962 	rv = sc->sc_mbox->acc_status;
963 
964 	/* ack interrupt */
965 	bus_space_write_1(sc->sc_iot, sc->sc_ioh, AMI_SCMD, AMI_SCMD_ACK);
966 
967 	return (rv);
968 }
969 
970 int
971 ami_start_xs(struct ami_softc *sc, struct ami_ccb *ccb, struct scsi_xfer *xs)
972 {
973 	timeout_set(&xs->stimeout, ami_stimeout, ccb);
974 
975 	if (xs->flags & SCSI_POLL) {
976 		ami_complete(sc, ccb, xs->timeout);
977 		return (COMPLETE);
978 	}
979 
980 	/* XXX way wrong, this timeout needs to be set later */
981 	timeout_add_sec(&xs->stimeout, 61);
982 	ami_start(sc, ccb);
983 
984 	return (SUCCESSFULLY_QUEUED);
985 }
986 
987 void
988 ami_start(struct ami_softc *sc, struct ami_ccb *ccb)
989 {
990 	int s;
991 
992 	s = splbio();
993 	ccb->ccb_state = AMI_CCB_PREQUEUED;
994 	TAILQ_INSERT_TAIL(&sc->sc_ccb_preq, ccb, ccb_link);
995 	ami_runqueue(sc);
996 	splx(s);
997 }
998 
999 void
1000 ami_runqueue_tick(void *arg)
1001 {
1002 	struct ami_softc *sc = arg;
1003 	int s;
1004 
1005 	s = splbio();
1006 	ami_runqueue(sc);
1007 	splx(s);
1008 }
1009 
1010 void
1011 ami_runqueue(struct ami_softc *sc)
1012 {
1013 	struct ami_ccb *ccb;
1014 
1015 	splassert(IPL_BIO);
1016 
1017 	if (sc->sc_drainio)
1018 		return;
1019 
1020 	while ((ccb = TAILQ_FIRST(&sc->sc_ccb_preq)) != NULL) {
1021 		if (sc->sc_exec(sc, &ccb->ccb_cmd) != 0) {
1022 			/* this is now raceable too with other incomming io */
1023 			timeout_add(&sc->sc_run_tmo, 1);
1024 			break;
1025 		}
1026 
1027 		TAILQ_REMOVE(&sc->sc_ccb_preq, ccb, ccb_link);
1028 		ccb->ccb_state = AMI_CCB_QUEUED;
1029 		ami_insert_runq(ccb);
1030 	}
1031 }
1032 
1033 int
1034 ami_poll(struct ami_softc *sc, struct ami_ccb *ccb)
1035 {
1036 	int error;
1037 	int s;
1038 
1039 	s = splbio();
1040 	error = sc->sc_poll(sc, &ccb->ccb_cmd);
1041 	if (error == -1)
1042 		ccb->ccb_flags |= AMI_CCB_F_ERR;
1043 
1044 	ccb->ccb_done(sc, ccb);
1045 	splx(s);
1046 
1047 	return (error);
1048 }
1049 
1050 void
1051 ami_complete(struct ami_softc *sc, struct ami_ccb *ccb, int timeout)
1052 {
1053 	struct ami_iocmd mbox;
1054 	int i = 0, j, done = 0;
1055 	int s, ready;
1056 
1057 	s = splbio();
1058 
1059 	/*
1060 	 * since exec will return if the mbox is busy we have to busy wait
1061 	 * ourselves. once its in, jam it into the runq.
1062 	 */
1063 	while (i < AMI_MAX_BUSYWAIT) {
1064 		if (sc->sc_exec(sc, &ccb->ccb_cmd) == 0) {
1065 			ccb->ccb_state = AMI_CCB_QUEUED;
1066 			ami_insert_runq(ccb);
1067 			break;
1068 		}
1069 		DELAY(1000);
1070 		i++;
1071 	}
1072 	if (ccb->ccb_state != AMI_CCB_QUEUED)
1073 		goto err;
1074 
1075 	/*
1076 	 * Override timeout for PERC3.  The first command triggers a chip
1077 	 * reset on the QL12160 chip which causes the firmware to reload.
1078 	 * 30000 is slightly less than double of how long it takes for the
1079 	 * firmware to be up again.  After the first two commands the
1080 	 * timeouts are as expected.
1081 	 */
1082 	i = 0;
1083 	while (i < 30000 /* timeout */) {
1084 		if (sc->sc_done(sc, &mbox) != 0) {
1085 			for (j = 0; j < mbox.acc_nstat; j++) {
1086 				ready = mbox.acc_cmplidl[j];
1087 				ami_done(sc, ready, mbox.acc_status);
1088 				if (ready == ccb->ccb_cmd.acc_id)
1089 					done = 1;
1090 			}
1091 			if (done)
1092 				break;
1093 		}
1094 
1095 		DELAY(1000);
1096 		i++;
1097 	}
1098 	if (!done) {
1099 		printf("%s: timeout ccb %d\n", DEVNAME(sc),
1100 		    ccb->ccb_cmd.acc_id);
1101 		ami_remove_runq(ccb);
1102 		goto err;
1103 	}
1104 
1105 	/* start the runqueue again */
1106 	ami_runqueue(sc);
1107 
1108 	splx(s);
1109 
1110 	return;
1111 
1112 err:
1113 	ccb->ccb_flags |= AMI_CCB_F_ERR;
1114 	ccb->ccb_state = AMI_CCB_READY;
1115 	ccb->ccb_done(sc, ccb);
1116 	splx(s);
1117 }
1118 
1119 void
1120 ami_stimeout(void *v)
1121 {
1122 	struct ami_ccb *ccb = v;
1123 	struct ami_softc *sc = ccb->ccb_sc;
1124 	struct ami_iocmd *cmd = &ccb->ccb_cmd;
1125 	int s;
1126 
1127 	s = splbio();
1128 	switch (ccb->ccb_state) {
1129 	case AMI_CCB_PREQUEUED:
1130 		/* command never ran, cleanup is easy */
1131 		TAILQ_REMOVE(&sc->sc_ccb_preq, ccb, ccb_link);
1132 		ccb->ccb_flags |= AMI_CCB_F_ERR;
1133 		ccb->ccb_done(sc, ccb);
1134 		break;
1135 
1136 	case AMI_CCB_QUEUED:
1137 		/*
1138 		 * ccb has taken more than a minute to finish. we can't take
1139 		 * it off the hardware in case it finishes later, but we can
1140 		 * warn the user to look at what is happening.
1141 		 */
1142 		AMI_DPRINTF(AMI_D_CMD, ("%s: stimeout ccb %d, check volume "
1143 		    "state\n", DEVNAME(sc), cmd->acc_id));
1144 		break;
1145 
1146 	default:
1147 		panic("%s: ami_stimeout(%d) botch", DEVNAME(sc), cmd->acc_id);
1148 	}
1149 
1150 	splx(s);
1151 }
1152 
1153 int
1154 ami_done(struct ami_softc *sc, int idx, int status)
1155 {
1156 	struct ami_ccb *ccb = &sc->sc_ccbs[idx - 1];
1157 
1158 	AMI_DPRINTF(AMI_D_CMD, ("done(%d) ", ccb->ccb_cmd.acc_id));
1159 
1160 	if (ccb->ccb_state != AMI_CCB_QUEUED) {
1161 		printf("%s: unqueued ccb %d ready, state = %d\n",
1162 		    DEVNAME(sc), idx, ccb->ccb_state);
1163 		return (1);
1164 	}
1165 
1166 	ccb->ccb_state = AMI_CCB_READY;
1167 	ccb->ccb_status = status;
1168 	ami_remove_runq(ccb);
1169 
1170 	ccb->ccb_done(sc, ccb);
1171 
1172 	return (0);
1173 }
1174 
1175 void
1176 ami_done_pt(struct ami_softc *sc, struct ami_ccb *ccb)
1177 {
1178 	struct scsi_xfer *xs = ccb->ccb_xs;
1179 	struct scsi_link *link = xs->sc_link;
1180 	struct ami_rawsoftc *rsc = link->adapter_softc;
1181 	u_int8_t target = link->target, type;
1182 
1183 	bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),
1184 	    ccb->ccb_offset, sizeof(struct ami_ccbmem),
1185 	    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1186 
1187 	if (xs->data != NULL) {
1188 		bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
1189 		    ccb->ccb_dmamap->dm_mapsize,
1190 		    (xs->flags & SCSI_DATA_IN) ?
1191 		    BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
1192 
1193 		bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap);
1194 	}
1195 
1196 	timeout_del(&xs->stimeout);
1197 	xs->resid = 0;
1198 	xs->flags |= ITSDONE;
1199 
1200 	if (ccb->ccb_flags & AMI_CCB_F_ERR)
1201 		xs->error = XS_DRIVER_STUFFUP;
1202  	else if (ccb->ccb_status != 0x00)
1203 		xs->error = XS_DRIVER_STUFFUP;
1204 	else if (xs->flags & SCSI_POLL && xs->cmd->opcode == INQUIRY) {
1205 		type = ((struct scsi_inquiry_data *)xs->data)->device &
1206 		    SID_TYPE;
1207 		if (!(type == T_PROCESSOR || type == T_ENCLOSURE))
1208 			xs->error = XS_DRIVER_STUFFUP;
1209 		else
1210 			rsc->sc_proctarget = target;
1211 	}
1212 
1213 	ami_put_ccb(ccb);
1214 	scsi_done(xs);
1215 }
1216 
1217 void
1218 ami_done_xs(struct ami_softc *sc, struct ami_ccb *ccb)
1219 {
1220 	struct scsi_xfer *xs = ccb->ccb_xs;
1221 
1222 	if (xs->data != NULL) {
1223 		bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
1224 		    ccb->ccb_dmamap->dm_mapsize,
1225 		    (xs->flags & SCSI_DATA_IN) ?
1226 		    BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
1227 
1228 		bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),
1229 		    ccb->ccb_offset, sizeof(struct ami_ccbmem),
1230 		    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1231 
1232 		bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap);
1233 	}
1234 
1235 	timeout_del(&xs->stimeout);
1236 	xs->resid = 0;
1237 	xs->flags |= ITSDONE;
1238 
1239 	if (ccb->ccb_flags & AMI_CCB_F_ERR)
1240 		xs->error = XS_DRIVER_STUFFUP;
1241 
1242 	ami_put_ccb(ccb);
1243 	scsi_done(xs);
1244 }
1245 
1246 void
1247 ami_done_flush(struct ami_softc *sc, struct ami_ccb *ccb)
1248 {
1249 	struct scsi_xfer *xs = ccb->ccb_xs;
1250 	struct ami_iocmd *cmd = &ccb->ccb_cmd;
1251 
1252 	timeout_del(&xs->stimeout);
1253 	if (ccb->ccb_flags & AMI_CCB_F_ERR) {
1254 		xs->error = XS_DRIVER_STUFFUP;
1255 		xs->resid = 0;
1256 		xs->flags |= ITSDONE;
1257 
1258 		ami_put_ccb(ccb);
1259 		scsi_done(xs);
1260 		return;
1261 	}
1262 
1263 	/* reuse the ccb for the sysflush command */
1264 	ccb->ccb_done = ami_done_sysflush;
1265 	cmd->acc_cmd = AMI_SYSFLUSH;
1266 
1267 	ami_start_xs(sc, ccb, xs);
1268 }
1269 
1270 void
1271 ami_done_sysflush(struct ami_softc *sc, struct ami_ccb *ccb)
1272 {
1273 	struct scsi_xfer *xs = ccb->ccb_xs;
1274 
1275 	timeout_del(&xs->stimeout);
1276 	xs->resid = 0;
1277 	xs->flags |= ITSDONE;
1278 	if (ccb->ccb_flags & AMI_CCB_F_ERR)
1279 		xs->error = XS_DRIVER_STUFFUP;
1280 
1281 	ami_put_ccb(ccb);
1282 	scsi_done(xs);
1283 }
1284 
1285 void
1286 ami_done_dummy(struct ami_softc *sc, struct ami_ccb *ccb)
1287 {
1288 }
1289 
1290 void
1291 ami_done_ioctl(struct ami_softc *sc, struct ami_ccb *ccb)
1292 {
1293 	wakeup(ccb);
1294 }
1295 
1296 void
1297 ami_done_init(struct ami_softc *sc, struct ami_ccb *ccb)
1298 {
1299 	/* the ccb is going to be reused, so do nothing with it */
1300 }
1301 
1302 void
1303 amiminphys(struct buf *bp, struct scsi_link *sl)
1304 {
1305 	if (bp->b_bcount > AMI_MAXFER)
1306 		bp->b_bcount = AMI_MAXFER;
1307 	minphys(bp);
1308 }
1309 
1310 void
1311 ami_copy_internal_data(struct scsi_xfer *xs, void *v, size_t size)
1312 {
1313 	size_t copy_cnt;
1314 
1315 	AMI_DPRINTF(AMI_D_MISC, ("ami_copy_internal_data "));
1316 
1317 	if (!xs->datalen)
1318 		printf("uio move not yet supported\n");
1319 	else {
1320 		copy_cnt = MIN(size, xs->datalen);
1321 		bcopy(v, xs->data, copy_cnt);
1322 	}
1323 }
1324 
1325 int
1326 ami_scsi_raw_cmd(struct scsi_xfer *xs)
1327 {
1328 	struct scsi_link *link = xs->sc_link;
1329 	struct ami_rawsoftc *rsc = link->adapter_softc;
1330 	struct ami_softc *sc = rsc->sc_softc;
1331 	u_int8_t channel = rsc->sc_channel, target = link->target;
1332 	struct device *dev = link->device_softc;
1333 	struct ami_ccb *ccb;
1334 	int s;
1335 
1336 	AMI_DPRINTF(AMI_D_CMD, ("ami_scsi_raw_cmd "));
1337 
1338 	if (!cold && target == rsc->sc_proctarget)
1339 		strlcpy(rsc->sc_procdev, dev->dv_xname,
1340 		    sizeof(rsc->sc_procdev));
1341 
1342 	if (xs->cmdlen > AMI_MAX_CDB) {
1343 		AMI_DPRINTF(AMI_D_CMD, ("CDB too big %p ", xs));
1344 		bzero(&xs->sense, sizeof(xs->sense));
1345 		xs->sense.error_code = SSD_ERRCODE_VALID | 0x70;
1346 		xs->sense.flags = SKEY_ILLEGAL_REQUEST;
1347 		xs->sense.add_sense_code = 0x20; /* illcmd, 0x24 illfield */
1348 		xs->error = XS_SENSE;
1349 		s = splbio();
1350 		scsi_done(xs);
1351 		splx(s);
1352 		return (COMPLETE);
1353 	}
1354 
1355 	xs->error = XS_NOERROR;
1356 
1357 	s = splbio();
1358 	ccb = ami_get_ccb(sc);
1359 	splx(s);
1360 	if (ccb == NULL) {
1361 		xs->error = XS_DRIVER_STUFFUP;
1362 		s = splbio();
1363 		scsi_done(xs);
1364 		splx(s);
1365 		return (COMPLETE);
1366 	}
1367 
1368 	memset(ccb->ccb_pt, 0, sizeof(struct ami_passthrough));
1369 
1370 	ccb->ccb_xs = xs;
1371 	ccb->ccb_done = ami_done_pt;
1372 
1373 	ccb->ccb_cmd.acc_cmd = AMI_PASSTHRU;
1374 	ccb->ccb_cmd.acc_passthru.apt_data = ccb->ccb_ptpa;
1375 
1376 	ccb->ccb_pt->apt_param = AMI_PTPARAM(AMI_TIMEOUT_6,1,0);
1377 	ccb->ccb_pt->apt_channel = channel;
1378 	ccb->ccb_pt->apt_target = target;
1379 	bcopy(xs->cmd, ccb->ccb_pt->apt_cdb, AMI_MAX_CDB);
1380 	ccb->ccb_pt->apt_ncdb = xs->cmdlen;
1381 	ccb->ccb_pt->apt_nsense = AMI_MAX_SENSE;
1382 	ccb->ccb_pt->apt_datalen = xs->datalen;
1383 	ccb->ccb_pt->apt_data = 0;
1384 
1385 	if (ami_load_ptmem(sc, ccb, xs->data, xs->datalen,
1386 	    xs->flags & SCSI_DATA_IN, xs->flags & SCSI_NOSLEEP) != 0) {
1387 		xs->error = XS_DRIVER_STUFFUP;
1388 		s = splbio();
1389 		ami_put_ccb(ccb);
1390 		scsi_done(xs);
1391 		splx(s);
1392 		return (COMPLETE);
1393 	}
1394 
1395 	return (ami_start_xs(sc, ccb, xs));
1396 }
1397 
1398 int
1399 ami_load_ptmem(struct ami_softc *sc, struct ami_ccb *ccb, void *data,
1400     size_t len, int read, int nowait)
1401 {
1402 	bus_dmamap_t dmap = ccb->ccb_dmamap;
1403 	bus_dma_segment_t *sgd;
1404 	int error, i;
1405 
1406 	if (data != NULL) {
1407 		error = bus_dmamap_load(sc->sc_dmat, dmap, data, len, NULL,
1408 		    nowait ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
1409 		if (error) {
1410 			if (error == EFBIG)
1411 				printf("more than %d dma segs\n",
1412 				    AMI_MAXOFFSETS);
1413 			else
1414 				printf("error %d loading dma map\n", error);
1415 
1416 			return (1);
1417 		}
1418 
1419 		sgd = dmap->dm_segs;
1420 		if (dmap->dm_nsegs > 1) {
1421 			struct ami_sgent *sgl = ccb->ccb_sglist;
1422 
1423 			ccb->ccb_pt->apt_nsge = dmap->dm_nsegs;
1424 			ccb->ccb_pt->apt_data = ccb->ccb_sglistpa;
1425 
1426 			for (i = 0; i < dmap->dm_nsegs; i++) {
1427 				sgl[i].asg_addr = htole32(sgd[i].ds_addr);
1428 				sgl[i].asg_len = htole32(sgd[i].ds_len);
1429 			}
1430 		} else {
1431 			ccb->ccb_pt->apt_nsge = 0;
1432 			ccb->ccb_pt->apt_data = htole32(sgd->ds_addr);
1433 		}
1434 
1435 		bus_dmamap_sync(sc->sc_dmat, dmap, 0, dmap->dm_mapsize,
1436 		    read ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
1437 	}
1438 
1439 	bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),
1440 	    ccb->ccb_offset, sizeof(struct ami_ccbmem),
1441 	    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1442 
1443 	return (0);
1444 }
1445 
1446 int
1447 ami_scsi_cmd(struct scsi_xfer *xs)
1448 {
1449 	struct scsi_link *link = xs->sc_link;
1450 	struct ami_softc *sc = link->adapter_softc;
1451 	struct device *dev = link->device_softc;
1452 	struct ami_ccb *ccb;
1453 	struct ami_iocmd *cmd;
1454 	struct scsi_inquiry_data inq;
1455 	struct scsi_sense_data sd;
1456 	struct scsi_read_cap_data rcd;
1457 	u_int8_t target = link->target;
1458 	u_int32_t blockno, blockcnt;
1459 	struct scsi_rw *rw;
1460 	struct scsi_rw_big *rwb;
1461 	bus_dma_segment_t *sgd;
1462 	int error;
1463 	int s;
1464 	int i;
1465 
1466 	AMI_DPRINTF(AMI_D_CMD, ("ami_scsi_cmd "));
1467 
1468 	if (target >= sc->sc_nunits || !sc->sc_hdr[target].hd_present ||
1469 	    link->lun != 0) {
1470 		AMI_DPRINTF(AMI_D_CMD, ("no target %d ", target));
1471 		/* XXX should be XS_SENSE and sense filled out */
1472 		xs->error = XS_DRIVER_STUFFUP;
1473 		xs->flags |= ITSDONE;
1474 		s = splbio();
1475 		scsi_done(xs);
1476 		splx(s);
1477 		return (COMPLETE);
1478 	}
1479 
1480 	error = 0;
1481 	xs->error = XS_NOERROR;
1482 
1483 	switch (xs->cmd->opcode) {
1484 	case READ_COMMAND:
1485 	case READ_BIG:
1486 	case WRITE_COMMAND:
1487 	case WRITE_BIG:
1488 		/* deal with io outside the switch */
1489 		break;
1490 
1491 	case SYNCHRONIZE_CACHE:
1492 		s = splbio();
1493 		ccb = ami_get_ccb(sc);
1494 		splx(s);
1495 		if (ccb == NULL) {
1496 			xs->error = XS_DRIVER_STUFFUP;
1497 			s = splbio();
1498 			scsi_done(xs);
1499 			splx(s);
1500 			return (COMPLETE);
1501 		}
1502 
1503 		ccb->ccb_xs = xs;
1504 		ccb->ccb_done = ami_done_flush;
1505 		if (xs->timeout < 30000)
1506 			xs->timeout = 30000;	/* at least 30sec */
1507 
1508 		cmd = &ccb->ccb_cmd;
1509 		cmd->acc_cmd = AMI_FLUSH;
1510 
1511 		return (ami_start_xs(sc, ccb, xs));
1512 
1513 	case TEST_UNIT_READY:
1514 		/* save off sd? after autoconf */
1515 		if (!cold)	/* XXX bogus */
1516 			strlcpy(sc->sc_hdr[target].dev, dev->dv_xname,
1517 			    sizeof(sc->sc_hdr[target].dev));
1518 	case START_STOP:
1519 #if 0
1520 	case VERIFY:
1521 #endif
1522 	case PREVENT_ALLOW:
1523 		AMI_DPRINTF(AMI_D_CMD, ("opc %d tgt %d ", xs->cmd->opcode,
1524 		    target));
1525 		return (COMPLETE);
1526 
1527 	case REQUEST_SENSE:
1528 		AMI_DPRINTF(AMI_D_CMD, ("REQUEST SENSE tgt %d ", target));
1529 		bzero(&sd, sizeof(sd));
1530 		sd.error_code = 0x70;
1531 		sd.segment = 0;
1532 		sd.flags = SKEY_NO_SENSE;
1533 		*(u_int32_t*)sd.info = htole32(0);
1534 		sd.extra_len = 0;
1535 		ami_copy_internal_data(xs, &sd, sizeof(sd));
1536 		s = splbio();
1537 		scsi_done(xs);
1538 		splx(s);
1539 		return (COMPLETE);
1540 
1541 	case INQUIRY:
1542 		AMI_DPRINTF(AMI_D_CMD, ("INQUIRY tgt %d ", target));
1543 		bzero(&inq, sizeof(inq));
1544 		inq.device = T_DIRECT;
1545 		inq.dev_qual2 = 0;
1546 		inq.version = 2;
1547 		inq.response_format = 2;
1548 		inq.additional_length = 32;
1549 		strlcpy(inq.vendor, "AMI    ", sizeof(inq.vendor));
1550 		snprintf(inq.product, sizeof(inq.product),
1551 		    "Host drive  #%02d", target);
1552 		strlcpy(inq.revision, "   ", sizeof(inq.revision));
1553 		ami_copy_internal_data(xs, &inq, sizeof(inq));
1554 		s = splbio();
1555 		scsi_done(xs);
1556 		splx(s);
1557 		return (COMPLETE);
1558 
1559 	case READ_CAPACITY:
1560 		AMI_DPRINTF(AMI_D_CMD, ("READ CAPACITY tgt %d ", target));
1561 		bzero(&rcd, sizeof(rcd));
1562 		_lto4b(sc->sc_hdr[target].hd_size - 1, rcd.addr);
1563 		_lto4b(AMI_SECTOR_SIZE, rcd.length);
1564 		ami_copy_internal_data(xs, &rcd, sizeof(rcd));
1565 		s = splbio();
1566 		scsi_done(xs);
1567 		splx(s);
1568 		return (COMPLETE);
1569 
1570 	default:
1571 		AMI_DPRINTF(AMI_D_CMD, ("unsupported scsi command %#x tgt %d ",
1572 		    xs->cmd->opcode, target));
1573 		xs->error = XS_DRIVER_STUFFUP;
1574 		s = splbio();
1575 		scsi_done(xs);
1576 		splx(s);
1577 		return (COMPLETE);
1578 	}
1579 
1580 	/* A read or write operation. */
1581 	if (xs->cmdlen == 6) {
1582 		rw = (struct scsi_rw *)xs->cmd;
1583 		blockno = _3btol(rw->addr) & (SRW_TOPADDR << 16 | 0xffff);
1584 		blockcnt = rw->length ? rw->length : 0x100;
1585 	} else {
1586 		rwb = (struct scsi_rw_big *)xs->cmd;
1587 		blockno = _4btol(rwb->addr);
1588 		blockcnt = _2btol(rwb->length);
1589 	}
1590 
1591 	if (blockno >= sc->sc_hdr[target].hd_size ||
1592 	    blockno + blockcnt > sc->sc_hdr[target].hd_size) {
1593 		printf("%s: out of bounds %u-%u >= %u\n", DEVNAME(sc),
1594 		    blockno, blockcnt, sc->sc_hdr[target].hd_size);
1595 		xs->error = XS_DRIVER_STUFFUP;
1596 		s = splbio();
1597 		scsi_done(xs);
1598 		splx(s);
1599 		return (COMPLETE);
1600 	}
1601 
1602 	s = splbio();
1603 	ccb = ami_get_ccb(sc);
1604 	splx(s);
1605 	if (ccb == NULL) {
1606 		xs->error = XS_DRIVER_STUFFUP;
1607 		s = splbio();
1608 		scsi_done(xs);
1609 		splx(s);
1610 		return (COMPLETE);
1611 	}
1612 
1613 	ccb->ccb_xs = xs;
1614 	ccb->ccb_done = ami_done_xs;
1615 
1616 	cmd = &ccb->ccb_cmd;
1617 	cmd->acc_cmd = (xs->flags & SCSI_DATA_IN) ? AMI_READ : AMI_WRITE;
1618 	cmd->acc_mbox.amb_nsect = htole16(blockcnt);
1619 	cmd->acc_mbox.amb_lba = htole32(blockno);
1620 	cmd->acc_mbox.amb_ldn = target;
1621 
1622 	error = bus_dmamap_load(sc->sc_dmat, ccb->ccb_dmamap,
1623 	    xs->data, xs->datalen, NULL,
1624 	    (xs->flags & SCSI_NOSLEEP) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
1625 	if (error) {
1626 		if (error == EFBIG)
1627 			printf("more than %d dma segs\n", AMI_MAXOFFSETS);
1628 		else
1629 			printf("error %d loading dma map\n", error);
1630 
1631 		xs->error = XS_DRIVER_STUFFUP;
1632 		s = splbio();
1633 		ami_put_ccb(ccb);
1634 		scsi_done(xs);
1635 		splx(s);
1636 		return (COMPLETE);
1637 	}
1638 
1639 	sgd = ccb->ccb_dmamap->dm_segs;
1640 	if (ccb->ccb_dmamap->dm_nsegs > 1) {
1641 		struct ami_sgent *sgl = ccb->ccb_sglist;
1642 
1643 		cmd->acc_mbox.amb_nsge = ccb->ccb_dmamap->dm_nsegs;
1644 		cmd->acc_mbox.amb_data = ccb->ccb_sglistpa;
1645 
1646 		for (i = 0; i < ccb->ccb_dmamap->dm_nsegs; i++) {
1647 			sgl[i].asg_addr = htole32(sgd[i].ds_addr);
1648 			sgl[i].asg_len = htole32(sgd[i].ds_len);
1649 		}
1650 	} else {
1651 		cmd->acc_mbox.amb_nsge = 0;
1652 		cmd->acc_mbox.amb_data = htole32(sgd->ds_addr);
1653 	}
1654 
1655 	bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),
1656 	    ccb->ccb_offset, sizeof(struct ami_ccbmem),
1657 	    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1658 
1659 	bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
1660 	    ccb->ccb_dmamap->dm_mapsize, (xs->flags & SCSI_DATA_IN) ?
1661 	    BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
1662 
1663 	return (ami_start_xs(sc, ccb, xs));
1664 }
1665 
1666 int
1667 ami_intr(void *v)
1668 {
1669 	struct ami_softc *sc = v;
1670 	struct ami_iocmd mbox;
1671 	int i, rv = 0, ready;
1672 
1673 	splassert(IPL_BIO);
1674 
1675 	if (TAILQ_EMPTY(&sc->sc_ccb_runq))
1676 		return (0);
1677 
1678 	AMI_DPRINTF(AMI_D_INTR, ("intr "));
1679 
1680 	while ((sc->sc_done)(sc, &mbox)) {
1681 		AMI_DPRINTF(AMI_D_CMD, ("got#%d ", mbox.acc_nstat));
1682 		for (i = 0; i < mbox.acc_nstat; i++ ) {
1683 			ready = mbox.acc_cmplidl[i];
1684 			AMI_DPRINTF(AMI_D_CMD, ("ready=%d ", ready));
1685 			if (!ami_done(sc, ready, mbox.acc_status))
1686 				rv |= 1;
1687 		}
1688 	}
1689 
1690 	if (rv)
1691 		ami_runqueue(sc);
1692 
1693 	AMI_DPRINTF(AMI_D_INTR, ("exit "));
1694 	return (rv);
1695 }
1696 
1697 int
1698 ami_scsi_ioctl(struct scsi_link *link, u_long cmd, caddr_t addr, int flag,
1699     struct proc *p)
1700 {
1701 	struct ami_softc *sc = (struct ami_softc *)link->adapter_softc;
1702 	/* struct device *dev = (struct device *)link->device_softc; */
1703 	/* u_int8_t target = link->target; */
1704 
1705 	if (sc->sc_ioctl)
1706 		return (sc->sc_ioctl(link->adapter_softc, cmd, addr));
1707 	else
1708 		return (ENOTTY);
1709 }
1710 
1711 #if NBIO > 0
1712 int
1713 ami_ioctl(struct device *dev, u_long cmd, caddr_t addr)
1714 {
1715 	struct ami_softc *sc = (struct ami_softc *)dev;
1716 	int error = 0;
1717 
1718 	AMI_DPRINTF(AMI_D_IOCTL, ("%s: ioctl ", DEVNAME(sc)));
1719 
1720 	if (sc->sc_flags & AMI_BROKEN)
1721 		return (ENODEV); /* can't do this to broken device for now */
1722 
1723 	switch (cmd) {
1724 	case BIOCINQ:
1725 		AMI_DPRINTF(AMI_D_IOCTL, ("inq "));
1726 		error = ami_ioctl_inq(sc, (struct bioc_inq *)addr);
1727 		break;
1728 
1729 	case BIOCVOL:
1730 		AMI_DPRINTF(AMI_D_IOCTL, ("vol "));
1731 		error = ami_ioctl_vol(sc, (struct bioc_vol *)addr);
1732 		break;
1733 
1734 	case BIOCDISK:
1735 		AMI_DPRINTF(AMI_D_IOCTL, ("disk "));
1736 		error = ami_ioctl_disk(sc, (struct bioc_disk *)addr);
1737 		break;
1738 
1739 	case BIOCALARM:
1740 		AMI_DPRINTF(AMI_D_IOCTL, ("alarm "));
1741 		error = ami_ioctl_alarm(sc, (struct bioc_alarm *)addr);
1742 		break;
1743 
1744 	case BIOCSETSTATE:
1745 		AMI_DPRINTF(AMI_D_IOCTL, ("setstate "));
1746 		error = ami_ioctl_setstate(sc, (struct bioc_setstate *)addr);
1747 		break;
1748 
1749 	default:
1750 		AMI_DPRINTF(AMI_D_IOCTL, (" invalid ioctl\n"));
1751 		error = EINVAL;
1752 	}
1753 
1754 	return (error);
1755 }
1756 
1757 int
1758 ami_drv_pt(struct ami_softc *sc, u_int8_t ch, u_int8_t tg, u_int8_t *cmd,
1759     int clen, int blen, void *buf)
1760 {
1761 	struct ami_ccb *ccb;
1762 	struct ami_passthrough *pt;
1763 	int error = 0;
1764 	int s;
1765 
1766 	rw_enter_write(&sc->sc_lock);
1767 
1768 	s = splbio();
1769 	ccb = ami_get_ccb(sc);
1770 	splx(s);
1771 	if (ccb == NULL) {
1772 		error = ENOMEM;
1773 		goto err;
1774 	}
1775 
1776 	ccb->ccb_done = ami_done_ioctl;
1777 
1778 	ccb->ccb_cmd.acc_cmd = AMI_PASSTHRU;
1779 	ccb->ccb_cmd.acc_passthru.apt_data = ccb->ccb_ptpa;
1780 
1781 	pt = ccb->ccb_pt;
1782 	memset(pt, 0, sizeof *pt);
1783 	pt->apt_channel = ch;
1784 	pt->apt_target = tg;
1785 	pt->apt_ncdb = clen;
1786 	pt->apt_nsense = sizeof(struct scsi_sense_data);
1787 	pt->apt_datalen = blen;
1788 	pt->apt_data = 0;
1789 
1790 	bcopy(cmd, pt->apt_cdb, clen);
1791 
1792 	if (ami_load_ptmem(sc, ccb, buf, blen, 1, 0) != 0) {
1793 		error = ENOMEM;
1794 		goto ptmemerr;
1795 	}
1796 
1797 	ami_start(sc, ccb);
1798 
1799 	while (ccb->ccb_state != AMI_CCB_READY)
1800 		tsleep(ccb, PRIBIO, "ami_drv_pt", 0);
1801 
1802 	bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap, 0,
1803 	    ccb->ccb_dmamap->dm_mapsize, BUS_DMASYNC_POSTREAD);
1804 	bus_dmamap_sync(sc->sc_dmat, AMIMEM_MAP(sc->sc_ccbmem_am),
1805 	    ccb->ccb_offset, sizeof(struct ami_ccbmem),
1806 	    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1807 	bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap);
1808 
1809 	if (ccb->ccb_flags & AMI_CCB_F_ERR)
1810 		error = EIO;
1811 	else if (pt->apt_scsistat != 0x00)
1812 		error = EIO;
1813 
1814 ptmemerr:
1815 	s = splbio();
1816 	ami_put_ccb(ccb);
1817 	splx(s);
1818 
1819 err:
1820 	rw_exit_write(&sc->sc_lock);
1821 	return (error);
1822 }
1823 
1824 int
1825 ami_drv_inq(struct ami_softc *sc, u_int8_t ch, u_int8_t tg, u_int8_t page,
1826     void *inqbuf)
1827 {
1828 	struct scsi_inquiry_data *inq = inqbuf;
1829 	u_int8_t cdb[6];
1830 	int error = 0;
1831 
1832 	bzero(&cdb, sizeof cdb);
1833 
1834 	cdb[0] = INQUIRY;
1835 	cdb[1] = 0;
1836 	cdb[2] = 0;
1837 	cdb[3] = 0;
1838 	cdb[4] = sizeof(struct scsi_inquiry_data);
1839 	cdb[5] = 0;
1840 	if (page != 0) {
1841 		cdb[1] = SI_EVPD;
1842 		cdb[2] = page;
1843 	}
1844 
1845 	error = ami_drv_pt(sc, ch, tg, cdb, 6, sizeof *inq, inqbuf);
1846 	if (error)
1847 		return (error);
1848 
1849 	if ((inq->device & SID_TYPE) != T_DIRECT)
1850 		error = EINVAL;
1851 
1852 	return (error);
1853 }
1854 
1855 int
1856 ami_drv_readcap(struct ami_softc *sc, u_int8_t ch, u_int8_t tg, daddr64_t *sz)
1857 {
1858 	struct scsi_read_cap_data rcd;
1859 	struct scsi_read_cap_data_16 rcd16;
1860 	u_int8_t cdb[16];
1861 	u_int32_t blksz;
1862 	daddr64_t noblk;
1863 	int error = 0;
1864 
1865 	bzero(&rcd, sizeof rcd);
1866 	bzero(&cdb, sizeof cdb);
1867 	cdb[0] = READ_CAPACITY;
1868 
1869 	error = ami_drv_pt(sc, ch, tg, cdb, 10, sizeof rcd, &rcd);
1870 	if (error)
1871 		return (error);
1872 
1873 	noblk = _4btol(rcd.addr);
1874 	if (noblk == 0xffffffffllu) {
1875 		/* huge disk */
1876 		bzero(&rcd16, sizeof rcd16);
1877 		bzero(&cdb, sizeof cdb);
1878 		cdb[0] = READ_CAPACITY_16;
1879 
1880 		error = ami_drv_pt(sc, ch, tg, cdb, 16, sizeof rcd16, &rcd16);
1881 		if (error)
1882 			return (error);
1883 
1884 		noblk = _8btol(rcd16.addr);
1885 		blksz = _4btol(rcd16.length);
1886 	} else
1887 		blksz = _4btol(rcd.length);
1888 
1889 	if (blksz == 0)
1890 		blksz = 512;
1891 	*sz = noblk * blksz;
1892 
1893 	return (error);
1894 }
1895 
1896 int
1897 ami_mgmt(struct ami_softc *sc, u_int8_t opcode, u_int8_t par1, u_int8_t par2,
1898     u_int8_t par3, size_t size, void *buffer)
1899 {
1900 	struct ami_ccb *ccb;
1901 	struct ami_iocmd *cmd;
1902 	struct ami_mem *am = NULL;
1903 	char *idata = NULL;
1904 	int s, error = 0;
1905 
1906 	rw_enter_write(&sc->sc_lock);
1907 
1908 	if (opcode != AMI_CHSTATE) {
1909 		s = splbio();
1910 		ccb = ami_get_ccb(sc);
1911 		splx(s);
1912 		if (ccb == NULL) {
1913 			error = ENOMEM;
1914 			goto err;
1915 		}
1916 		ccb->ccb_done = ami_done_ioctl;
1917 	} else {
1918 		ccb = sc->sc_mgmtccb;
1919 		ccb->ccb_done = ami_done_dummy;
1920 	}
1921 
1922 	if (size) {
1923 		if ((am = ami_allocmem(sc, size)) == NULL) {
1924 			error = ENOMEM;
1925 			goto memerr;
1926 		}
1927 		idata = AMIMEM_KVA(am);
1928 	}
1929 
1930 	cmd = &ccb->ccb_cmd;
1931 	cmd->acc_cmd = opcode;
1932 
1933 	/*
1934 	 * some commands require data to be written to idata before sending
1935 	 * command to fw
1936 	 */
1937 	switch (opcode) {
1938 	case AMI_SPEAKER:
1939 		*idata = par1;
1940 		break;
1941 	default:
1942 		cmd->acc_io.aio_channel = par1;
1943 		cmd->acc_io.aio_param = par2;
1944 		cmd->acc_io.aio_pad[0] = par3;
1945 		break;
1946 	};
1947 
1948 	cmd->acc_io.aio_data = am ? htole32(AMIMEM_DVA(am)) : 0;
1949 
1950 	if (opcode != AMI_CHSTATE) {
1951 		ami_start(sc, ccb);
1952 		while (ccb->ccb_state != AMI_CCB_READY)
1953 			tsleep(ccb, PRIBIO,"ami_mgmt", 0);
1954 	} else {
1955 		/* change state must be run with id 0xfe and MUST be polled */
1956 		sc->sc_drainio = 1;
1957 		while (sc->sc_drained != 1)
1958 			if (tsleep(sc, PRIBIO, "ami_mgmt_drain", hz * 60) ==
1959 			    EWOULDBLOCK) {
1960 				printf("%s: drain io timeout\n");
1961 				ccb->ccb_flags |= AMI_CCB_F_ERR;
1962 				goto restartio;
1963 			}
1964 		ami_poll(sc, ccb);
1965 restartio:
1966 		/* restart io */
1967 		s = splbio();
1968 		sc->sc_drainio = 0;
1969 		ami_runqueue(sc);
1970 		splx(s);
1971 	}
1972 
1973 	if (ccb->ccb_flags & AMI_CCB_F_ERR)
1974 		error = EIO;
1975 	else if (buffer && size)
1976 		memcpy(buffer, idata, size);
1977 
1978 	if (am)
1979 		ami_freemem(sc, am);
1980 memerr:
1981 	if (opcode != AMI_CHSTATE) {
1982 		s = splbio();
1983 		ami_put_ccb(ccb);
1984 		splx(s);
1985 	} else {
1986 		ccb->ccb_flags = 0;
1987 		ccb->ccb_state = AMI_CCB_FREE;
1988 		ccb->ccb_done = NULL;
1989 	}
1990 
1991 err:
1992 	rw_exit_write(&sc->sc_lock);
1993 	return (error);
1994 }
1995 
1996 int
1997 ami_ioctl_inq(struct ami_softc *sc, struct bioc_inq *bi)
1998 {
1999 	struct ami_big_diskarray *p; /* struct too large for stack */
2000 	struct scsi_inquiry_data inqbuf;
2001 	struct ami_fc_einquiry einq;
2002 	int ch, tg;
2003 	int i, s, t, off;
2004 	int error = 0, changes = 0;
2005 
2006 	if ((error = ami_mgmt(sc, AMI_FCOP, AMI_FC_EINQ3,
2007 	    AMI_FC_EINQ3_SOLICITED_FULL, 0, sizeof einq, &einq)))
2008 		return (EINVAL);
2009 
2010 	if (einq.ain_drvinscnt == sc->sc_drvinscnt) {
2011 		/* poke existing known drives to make sure they aren't gone */
2012 		for(i = 0; i < sc->sc_channels * 16; i++) {
2013 			if (sc->sc_plist[i] == 0)
2014 				continue;
2015 
2016 			ch = (i & 0xf0) >> 4;
2017 			tg = i & 0x0f;
2018 			if (ami_drv_inq(sc, ch, tg, 0, &inqbuf)) {
2019 				/* drive is gone, force rescan */
2020 				changes = 1;
2021 				break;
2022 			}
2023 		}
2024 		if (changes == 0) {
2025 			bcopy(&sc->sc_bi, bi, sizeof *bi);
2026 			return (0);
2027 		}
2028 	}
2029 
2030 	sc->sc_drvinscnt = einq.ain_drvinscnt;
2031 
2032 	p = malloc(sizeof *p, M_DEVBUF, M_NOWAIT);
2033 	if (!p)
2034 		return (ENOMEM);
2035 
2036 	if ((error = ami_mgmt(sc, AMI_FCOP, AMI_FC_RDCONF, 0, 0, sizeof *p,
2037 	    p))) {
2038 		error = EINVAL;
2039 		goto bail;
2040 	}
2041 
2042 	bzero(sc->sc_plist, sizeof sc->sc_plist);
2043 
2044 	bi->bi_novol = p->ada_nld;
2045 	bi->bi_nodisk = 0;
2046 	strlcpy(bi->bi_dev, DEVNAME(sc), sizeof(bi->bi_dev));
2047 
2048 	/* count used disks, including failed ones */
2049 	for (i = 0; i < p->ada_nld; i++)
2050 		for (s = 0; s < p->ald[i].adl_spandepth; s++)
2051 			for (t = 0; t < p->ald[i].adl_nstripes; t++) {
2052 				off = p->ald[i].asp[s].adv[t].add_channel *
2053 				    AMI_MAX_TARGET +
2054 				    p->ald[i].asp[s].adv[t].add_target;
2055 
2056 				/* account for multi raid vol on same disk */
2057 				if (!sc->sc_plist[off]) {
2058 					sc->sc_plist[off] = 1;
2059 					bi->bi_nodisk++;
2060 				}
2061 			}
2062 
2063 	/* count unsued disks */
2064 	for(i = 0; i < sc->sc_channels * 16; i++) {
2065 	    	if (sc->sc_plist[i])
2066 			continue; /* skip claimed drives */
2067 
2068 		/*
2069 		 * hack to invalidate device type, needed for initiator id
2070 		 * on an unconnected channel.
2071 		 * XXX find out if we can determine this differently
2072 		 */
2073 		memset(&inqbuf, 0xff, sizeof inqbuf);
2074 
2075 		ch = (i & 0xf0) >> 4;
2076 		tg = i & 0x0f;
2077 		if (!ami_drv_inq(sc, ch, tg, 0, &inqbuf)) {
2078 			if ((inqbuf.device & SID_TYPE) != T_DIRECT)
2079 				continue;
2080 			bi->bi_novol++;
2081 			bi->bi_nodisk++;
2082 			sc->sc_plist[i] = 2;
2083 		} else
2084 			sc->sc_plist[i] = 0;
2085 	}
2086 
2087 	bcopy(bi, &sc->sc_bi, sizeof sc->sc_bi);
2088 	error = 0;
2089 bail:
2090 	free(p, M_DEVBUF);
2091 	return (error);
2092 }
2093 
2094 int
2095 ami_vol(struct ami_softc *sc, struct bioc_vol *bv, struct ami_big_diskarray *p)
2096 {
2097 	int i, ld = p->ada_nld, error = EINVAL;
2098 
2099 	for(i = 0; i < sc->sc_channels * 16; i++) {
2100 	    	/* skip claimed/unused drives */
2101 	    	if (sc->sc_plist[i] != 2)
2102 			continue;
2103 
2104 		/* are we it? */
2105 		if (ld != bv->bv_volid) {
2106 			ld++;
2107 			continue;
2108 		}
2109 
2110 		bv->bv_status = BIOC_SVONLINE;
2111 		bv->bv_size = (u_quad_t)p->apd[i].adp_size *
2112 		    (u_quad_t)512;
2113 		bv->bv_nodisk = 1;
2114 		strlcpy(bv->bv_dev,
2115 		    sc->sc_hdr[bv->bv_volid].dev,
2116 		    sizeof(bv->bv_dev));
2117 
2118 		if (p->apd[i].adp_ostatus == AMI_PD_HOTSPARE
2119 		    && p->apd[i].adp_type == 0)
2120 			bv->bv_level = -1;
2121 		else
2122 			bv->bv_level = -2;
2123 
2124 		error = 0;
2125 		goto bail;
2126 	}
2127 
2128 bail:
2129 	return (error);
2130 }
2131 
2132 int
2133 ami_disk(struct ami_softc *sc, struct bioc_disk *bd,
2134     struct ami_big_diskarray *p)
2135 {
2136 	char vend[8+16+4+1];
2137 	char ser[32 + 1];
2138 	struct scsi_inquiry_data inqbuf;
2139 	struct scsi_vpd_serial vpdbuf;
2140 	int i, ld = p->ada_nld, error = EINVAL;
2141 	u_int8_t ch, tg;
2142 	daddr64_t sz = 0;
2143 
2144 	for(i = 0; i < sc->sc_channels * 16; i++) {
2145 	    	/* skip claimed/unused drives */
2146 	    	if (sc->sc_plist[i] != 2)
2147 			continue;
2148 
2149 		/* are we it? */
2150 		if (ld != bd->bd_volid) {
2151 			ld++;
2152 			continue;
2153 		}
2154 
2155 		ch = (i & 0xf0) >> 4;
2156 		tg = i & 0x0f;
2157 		if (ami_drv_inq(sc, ch, tg, 0, &inqbuf))
2158 			goto bail;
2159 
2160 		bcopy(inqbuf.vendor, vend, sizeof vend - 1);
2161 
2162 		vend[sizeof vend - 1] = '\0';
2163 		strlcpy(bd->bd_vendor, vend, sizeof(bd->bd_vendor));
2164 
2165 		if (!ami_drv_inq(sc, ch, tg, 0x80, &vpdbuf)) {
2166 			bcopy(vpdbuf.serial, ser, sizeof ser - 1);
2167 			ser[sizeof ser - 1] = '\0';
2168 			if (vpdbuf.hdr.page_length < sizeof ser)
2169 				ser[vpdbuf.hdr.page_length] = '\0';
2170 			strlcpy(bd->bd_serial, ser, sizeof(bd->bd_serial));
2171 		}
2172 
2173 		error = ami_drv_readcap(sc, ch, tg, &sz);
2174 		if (error)
2175 			goto bail;
2176 
2177 		bd->bd_size = sz;
2178 		bd->bd_channel = ch;
2179 		bd->bd_target = tg;
2180 
2181 		strlcpy(bd->bd_procdev, sc->sc_rawsoftcs[ch].sc_procdev,
2182 		    sizeof(bd->bd_procdev));
2183 
2184 		if (p->apd[i].adp_ostatus == AMI_PD_HOTSPARE)
2185 			bd->bd_status = BIOC_SDHOTSPARE;
2186 		else
2187 			bd->bd_status = BIOC_SDUNUSED;
2188 
2189 #ifdef AMI_DEBUG
2190 		if (p->apd[i].adp_type != 0)
2191 			printf("invalid disk type: %d %d %x inquiry type: %x\n",
2192 			    ch, tg, p->apd[i].adp_type, inqbuf.device);
2193 #endif /* AMI_DEBUG */
2194 
2195 		error = 0;
2196 		goto bail;
2197 	}
2198 
2199 bail:
2200 	return (error);
2201 }
2202 
2203 int
2204 ami_ioctl_vol(struct ami_softc *sc, struct bioc_vol *bv)
2205 {
2206 	struct ami_big_diskarray *p; /* struct too large for stack */
2207 	int i, s, t, off;
2208 	int error = 0;
2209 	struct ami_progress perc;
2210 	u_int8_t bgi[5]; /* 40 LD, 1 bit per LD if BGI is active */
2211 
2212 	p = malloc(sizeof *p, M_DEVBUF, M_NOWAIT);
2213 	if (!p)
2214 		return (ENOMEM);
2215 
2216 	if ((error = ami_mgmt(sc, AMI_FCOP, AMI_FC_RDCONF, 0, 0, sizeof *p, p)))
2217 		goto bail;
2218 
2219 	if (bv->bv_volid >= p->ada_nld) {
2220 		error = ami_vol(sc, bv, p);
2221 		goto bail;
2222 	}
2223 
2224 	i = bv->bv_volid;
2225 
2226 	switch (p->ald[i].adl_status) {
2227 	case AMI_RDRV_OFFLINE:
2228 		bv->bv_status = BIOC_SVOFFLINE;
2229 		break;
2230 
2231 	case AMI_RDRV_DEGRADED:
2232 		bv->bv_status = BIOC_SVDEGRADED;
2233 		break;
2234 
2235 	case AMI_RDRV_OPTIMAL:
2236 		bv->bv_status = BIOC_SVONLINE;
2237 		bv->bv_percent = -1;
2238 
2239 		/* get BGI progress here and over-ride status if so */
2240 		memset(bgi, 0, sizeof bgi);
2241 		if (ami_mgmt(sc, AMI_MISC, AMI_GET_BGI, 0, 0, sizeof bgi, &bgi))
2242 			break;
2243 
2244 		if ((bgi[i / 8] & (1 << i % 8)) == 0)
2245 			break;
2246 
2247 		if (!ami_mgmt(sc, AMI_GCHECKPROGR, i, 0, 0, sizeof perc, &perc))
2248 		    	if (perc.apr_progress < 100) {
2249 				bv->bv_status = BIOC_SVSCRUB;
2250 				bv->bv_percent = perc.apr_progress >= 100 ? -1 :
2251 				    perc.apr_progress;
2252 			}
2253 		break;
2254 
2255 	default:
2256 		bv->bv_status = BIOC_SVINVALID;
2257 	}
2258 
2259 	/* over-ride status if a pd is in rebuild status for this ld */
2260 	for (s = 0; s < p->ald[i].adl_spandepth; s++)
2261 		for (t = 0; t < p->ald[i].adl_nstripes; t++) {
2262 			off = p->ald[i].asp[s].adv[t].add_channel *
2263 			    AMI_MAX_TARGET +
2264 			    p->ald[i].asp[s].adv[t].add_target;
2265 
2266 			if (p->apd[off].adp_ostatus != AMI_PD_RBLD)
2267 				continue;
2268 
2269 			/* get rebuild progress from pd 0 */
2270 			bv->bv_status = BIOC_SVREBUILD;
2271 			if (ami_mgmt(sc, AMI_GRBLDPROGR,
2272 			    p->ald[i].asp[s].adv[t].add_channel,
2273 			    p->ald[i].asp[s].adv[t].add_target, 0,
2274 			    sizeof perc, &perc))
2275 				bv->bv_percent = -1;
2276 			else
2277 				bv->bv_percent = perc.apr_progress >= 100 ? -1 :
2278 				    perc.apr_progress;
2279 			break;
2280 		}
2281 
2282 	bv->bv_size = 0;
2283 	bv->bv_level = p->ald[i].adl_raidlvl;
2284 	bv->bv_nodisk = 0;
2285 
2286 	for (s = 0; s < p->ald[i].adl_spandepth; s++) {
2287 		for (t = 0; t < p->ald[i].adl_nstripes; t++)
2288 			bv->bv_nodisk++;
2289 
2290 		switch (bv->bv_level) {
2291 		case 0:
2292 			bv->bv_size += p->ald[i].asp[s].ads_length *
2293 			    p->ald[i].adl_nstripes;
2294 			break;
2295 
2296 		case 1:
2297 			bv->bv_size += p->ald[i].asp[s].ads_length;
2298 			break;
2299 
2300 		case 5:
2301 			bv->bv_size += p->ald[i].asp[s].ads_length *
2302 			    (p->ald[i].adl_nstripes - 1);
2303 			break;
2304 		}
2305 	}
2306 
2307 	if (p->ald[i].adl_spandepth > 1)
2308 		bv->bv_level *= 10;
2309 
2310 	bv->bv_size *= (u_quad_t)512;
2311 
2312 	strlcpy(bv->bv_dev, sc->sc_hdr[i].dev, sizeof(bv->bv_dev));
2313 
2314 bail:
2315 	free(p, M_DEVBUF);
2316 
2317 	return (error);
2318 }
2319 
2320 int
2321 ami_ioctl_disk(struct ami_softc *sc, struct bioc_disk *bd)
2322 {
2323 	struct scsi_inquiry_data inqbuf;
2324 	struct scsi_vpd_serial vpdbuf;
2325 	struct ami_big_diskarray *p; /* struct too large for stack */
2326 	int i, s, t, d;
2327 	int off;
2328 	int error = EINVAL;
2329 	u_int16_t ch, tg;
2330 	char vend[8+16+4+1];
2331 	char ser[32 + 1];
2332 
2333 	p = malloc(sizeof *p, M_DEVBUF, M_NOWAIT);
2334 	if (!p)
2335 		return (ENOMEM);
2336 
2337 	if ((error = ami_mgmt(sc, AMI_FCOP, AMI_FC_RDCONF, 0, 0, sizeof *p, p)))
2338 		goto bail;
2339 
2340 	if (bd->bd_volid >= p->ada_nld) {
2341 		error = ami_disk(sc, bd, p);
2342 		goto bail;
2343 	}
2344 
2345 	i = bd->bd_volid;
2346 	for (s = 0, d = 0; s < p->ald[i].adl_spandepth; s++)
2347 		for (t = 0; t < p->ald[i].adl_nstripes; t++) {
2348 			if (d != bd->bd_diskid) {
2349 				d++;
2350 				continue;
2351 			}
2352 
2353 			off = p->ald[i].asp[s].adv[t].add_channel *
2354 			    AMI_MAX_TARGET +
2355 			    p->ald[i].asp[s].adv[t].add_target;
2356 
2357 			bd->bd_size = (u_quad_t)p->apd[off].adp_size *
2358 			    (u_quad_t)512;
2359 
2360 			switch (p->apd[off].adp_ostatus) {
2361 			case AMI_PD_UNCNF:
2362 				bd->bd_status = BIOC_SDUNUSED;
2363 				break;
2364 
2365 			case AMI_PD_ONLINE:
2366 				bd->bd_status = BIOC_SDONLINE;
2367 				break;
2368 
2369 			case AMI_PD_FAILED:
2370 				bd->bd_status = BIOC_SDFAILED;
2371 				bd->bd_size = 0;
2372 				break;
2373 
2374 			case AMI_PD_RBLD:
2375 				bd->bd_status = BIOC_SDREBUILD;
2376 				break;
2377 
2378 			case AMI_PD_HOTSPARE:
2379 				bd->bd_status = BIOC_SDHOTSPARE;
2380 				break;
2381 
2382 			default:
2383 				bd->bd_status = BIOC_SDINVALID;
2384 				bd->bd_size = 0;
2385 			}
2386 
2387 
2388 			ch = p->ald[i].asp[s].adv[t].add_target >> 4;
2389 			tg = p->ald[i].asp[s].adv[t].add_target & 0x0f;
2390 
2391 			bd->bd_channel = ch;
2392 			bd->bd_target = tg;
2393 			strlcpy(bd->bd_procdev, sc->sc_rawsoftcs[ch].sc_procdev,
2394 			    sizeof(bd->bd_procdev));
2395 
2396 			/* if we are failed don't query drive */
2397 			if (bd->bd_size == 0) {
2398 				bzero(&bd->bd_vendor, sizeof(bd->bd_vendor));
2399 				bzero(&bd->bd_serial, sizeof(bd->bd_serial));
2400 				goto done;
2401 			}
2402 
2403 			if (!ami_drv_inq(sc, ch, tg, 0, &inqbuf)) {
2404 				bcopy(inqbuf.vendor, vend, sizeof vend - 1);
2405 				vend[sizeof vend - 1] = '\0';
2406 				strlcpy(bd->bd_vendor, vend,
2407 				    sizeof(bd->bd_vendor));
2408 			}
2409 
2410 			if (!ami_drv_inq(sc, ch, tg, 0x80, &vpdbuf)) {
2411 				bcopy(vpdbuf.serial, ser, sizeof ser - 1);
2412 				ser[sizeof ser - 1] = '\0';
2413 				if (vpdbuf.hdr.page_length < sizeof ser)
2414 					ser[vpdbuf.hdr.page_length] = '\0';
2415 				strlcpy(bd->bd_serial, ser,
2416 				    sizeof(bd->bd_serial));
2417 			}
2418 			goto done;
2419 		}
2420 
2421 done:
2422 	error = 0;
2423 bail:
2424 	free(p, M_DEVBUF);
2425 
2426 	return (error);
2427 }
2428 
2429 int ami_ioctl_alarm(struct ami_softc *sc, struct bioc_alarm *ba)
2430 {
2431 	int error = 0;
2432 	u_int8_t func, ret;
2433 
2434 	switch(ba->ba_opcode) {
2435 	case BIOC_SADISABLE:
2436 		func = AMI_SPKR_OFF;
2437 		break;
2438 
2439 	case BIOC_SAENABLE:
2440 		func = AMI_SPKR_ON;
2441 		break;
2442 
2443 	case BIOC_SASILENCE:
2444 		func = AMI_SPKR_SHUT;
2445 		break;
2446 
2447 	case BIOC_GASTATUS:
2448 		func = AMI_SPKR_GVAL;
2449 		break;
2450 
2451 	case BIOC_SATEST:
2452 		func = AMI_SPKR_TEST;
2453 		break;
2454 
2455 	default:
2456 		AMI_DPRINTF(AMI_D_IOCTL, ("%s: biocalarm invalid opcode %x\n",
2457 		    DEVNAME(sc), ba->ba_opcode));
2458 		return (EINVAL);
2459 	}
2460 
2461 	if (!(error = ami_mgmt(sc, AMI_SPEAKER, func, 0, 0, sizeof ret,
2462 	    &ret))) {
2463 		if (ba->ba_opcode == BIOC_GASTATUS)
2464 			ba->ba_status = ret;
2465 		else
2466 			ba->ba_status = 0;
2467 	}
2468 
2469 	return (error);
2470 }
2471 
2472 int
2473 ami_ioctl_setstate(struct ami_softc *sc, struct bioc_setstate *bs)
2474 {
2475 	struct scsi_inquiry_data inqbuf;
2476 	int func, off, error;
2477 
2478 	switch (bs->bs_status) {
2479 	case BIOC_SSONLINE:
2480 		func = AMI_STATE_ON;
2481 		break;
2482 
2483 	case BIOC_SSOFFLINE:
2484 		func = AMI_STATE_FAIL;
2485 		break;
2486 
2487 	case BIOC_SSHOTSPARE:
2488 		off = bs->bs_channel * AMI_MAX_TARGET + bs->bs_target;
2489 
2490 		if (ami_drv_inq(sc, bs->bs_channel, bs->bs_target, 0,
2491 		    &inqbuf))
2492 			return (EINVAL);
2493 
2494 		func = AMI_STATE_SPARE;
2495 		break;
2496 
2497 	default:
2498 		AMI_DPRINTF(AMI_D_IOCTL, ("%s: biocsetstate invalid opcode %x\n"
2499 		    , DEVNAME(sc), bs->bs_status));
2500 		return (EINVAL);
2501 	}
2502 
2503 	if ((error = ami_mgmt(sc, AMI_CHSTATE, bs->bs_channel, bs->bs_target,
2504 	    func, 0, NULL)))
2505 		return (error);
2506 
2507 	return (0);
2508 }
2509 
2510 #ifndef SMALL_KERNEL
2511 int
2512 ami_create_sensors(struct ami_softc *sc)
2513 {
2514 	struct device *dev;
2515 	struct scsibus_softc *ssc;
2516 	int i;
2517 
2518 	TAILQ_FOREACH(dev, &alldevs, dv_list) {
2519 		if (dev->dv_parent != &sc->sc_dev)
2520 			continue;
2521 
2522 		/* check if this is the scsibus for the logical disks */
2523 		ssc = (struct scsibus_softc *)dev;
2524 		if (ssc->adapter_link == &sc->sc_link)
2525 			break;
2526 	}
2527 
2528 	if (ssc == NULL)
2529 		return (1);
2530 
2531 	sc->sc_sensors = malloc(sizeof(struct ksensor) * sc->sc_nunits,
2532 	    M_DEVBUF, M_WAITOK|M_ZERO);
2533 	if (sc->sc_sensors == NULL)
2534 		return (1);
2535 
2536 	strlcpy(sc->sc_sensordev.xname, DEVNAME(sc),
2537 	    sizeof(sc->sc_sensordev.xname));
2538 
2539 	for (i = 0; i < sc->sc_nunits; i++) {
2540 		if (ssc->sc_link[i][0] == NULL)
2541 			goto bad;
2542 
2543 		dev = ssc->sc_link[i][0]->device_softc;
2544 
2545 		sc->sc_sensors[i].type = SENSOR_DRIVE;
2546 		sc->sc_sensors[i].status = SENSOR_S_UNKNOWN;
2547 
2548 		strlcpy(sc->sc_sensors[i].desc, dev->dv_xname,
2549 		    sizeof(sc->sc_sensors[i].desc));
2550 
2551 		sensor_attach(&sc->sc_sensordev, &sc->sc_sensors[i]);
2552 	}
2553 
2554 	sc->sc_bd = malloc(sizeof(*sc->sc_bd), M_DEVBUF, M_WAITOK);
2555 	if (sc->sc_bd == NULL)
2556 		goto bad;
2557 
2558 	if (sensor_task_register(sc, ami_refresh_sensors, 10) == NULL)
2559 		goto freebd;
2560 
2561 	sensordev_install(&sc->sc_sensordev);
2562 
2563 	return (0);
2564 
2565 freebd:
2566 	free(sc->sc_bd, M_DEVBUF);
2567 bad:
2568 	free(sc->sc_sensors, M_DEVBUF);
2569 
2570 	return (1);
2571 }
2572 
2573 void
2574 ami_refresh_sensors(void *arg)
2575 {
2576 	struct ami_softc *sc = arg;
2577 	int i;
2578 
2579 	if (ami_mgmt(sc, AMI_FCOP, AMI_FC_RDCONF, 0, 0, sizeof(*sc->sc_bd),
2580 	    sc->sc_bd)) {
2581 		for (i = 0; i < sc->sc_nunits; i++) {
2582 			sc->sc_sensors[i].value = 0; /* unknown */
2583 			sc->sc_sensors[i].status = SENSOR_S_UNKNOWN;
2584 		}
2585 		return;
2586 	}
2587 
2588 	for (i = 0; i < sc->sc_nunits; i++) {
2589 		switch (sc->sc_bd->ald[i].adl_status) {
2590 		case AMI_RDRV_OFFLINE:
2591 			sc->sc_sensors[i].value = SENSOR_DRIVE_FAIL;
2592 			sc->sc_sensors[i].status = SENSOR_S_CRIT;
2593 			break;
2594 
2595 		case AMI_RDRV_DEGRADED:
2596 			sc->sc_sensors[i].value = SENSOR_DRIVE_PFAIL;
2597 			sc->sc_sensors[i].status = SENSOR_S_WARN;
2598 			break;
2599 
2600 		case AMI_RDRV_OPTIMAL:
2601 			sc->sc_sensors[i].value = SENSOR_DRIVE_ONLINE;
2602 			sc->sc_sensors[i].status = SENSOR_S_OK;
2603 			break;
2604 
2605 		default:
2606 			sc->sc_sensors[i].value = 0; /* unknown */
2607 			sc->sc_sensors[i].status = SENSOR_S_UNKNOWN;
2608 		}
2609 	}
2610 }
2611 #endif /* SMALL_KERNEL */
2612 #endif /* NBIO > 0 */
2613 
2614 #ifdef AMI_DEBUG
2615 void
2616 ami_print_mbox(struct ami_iocmd *mbox)
2617 {
2618 	int i;
2619 
2620 	printf("acc_cmd: %d  aac_id: %d  acc_busy: %d  acc_nstat: %d  ",
2621 	    mbox->acc_cmd, mbox->acc_id, mbox->acc_busy, mbox->acc_nstat);
2622 	printf("acc_status: %d  acc_poll: %d  acc_ack: %d\n",
2623 	    mbox->acc_status, mbox->acc_poll, mbox->acc_ack);
2624 
2625 	printf("acc_cmplidl: ");
2626 	for (i = 0; i < AMI_MAXSTATACK; i++) {
2627 		printf("[%d] = %d  ", i, mbox->acc_cmplidl[i]);
2628 	}
2629 
2630 	printf("\n");
2631 }
2632 #endif /* AMI_DEBUG */
2633