xref: /freebsd/sys/dev/mlx/mlx.c (revision 732a02b4e77866604a120a275c082bb6221bd2ff)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 1999 Michael Smith
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  *
28  *	$FreeBSD$
29  */
30 
31 /*
32  * Driver for the Mylex DAC960 family of RAID controllers.
33  */
34 
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/bio.h>
38 #include <sys/lock.h>
39 #include <sys/malloc.h>
40 #include <sys/mutex.h>
41 #include <sys/kernel.h>
42 #include <sys/sx.h>
43 
44 #include <sys/bus.h>
45 #include <sys/conf.h>
46 #include <sys/stat.h>
47 
48 #include <machine/resource.h>
49 #include <machine/bus.h>
50 #include <machine/clock.h>
51 #include <sys/rman.h>
52 
53 #include <geom/geom_disk.h>
54 
55 #include <dev/mlx/mlxio.h>
56 #include <dev/mlx/mlxvar.h>
57 #include <dev/mlx/mlxreg.h>
58 
59 static struct cdevsw mlx_cdevsw = {
60 	.d_version =	D_VERSION,
61 	.d_open =	mlx_open,
62 	.d_close =	mlx_close,
63 	.d_ioctl =	mlx_ioctl,
64 	.d_name =	"mlx",
65 };
66 
67 devclass_t	mlx_devclass;
68 
69 /*
70  * Per-interface accessor methods
71  */
72 static int			mlx_v3_tryqueue(struct mlx_softc *sc, struct mlx_command *mc);
73 static int			mlx_v3_findcomplete(struct mlx_softc *sc, u_int8_t *slot, u_int16_t *status);
74 static void			mlx_v3_intaction(struct mlx_softc *sc, int action);
75 static int			mlx_v3_fw_handshake(struct mlx_softc *sc, int *error, int *param1, int *param2, int first);
76 
77 static int			mlx_v4_tryqueue(struct mlx_softc *sc, struct mlx_command *mc);
78 static int			mlx_v4_findcomplete(struct mlx_softc *sc, u_int8_t *slot, u_int16_t *status);
79 static void			mlx_v4_intaction(struct mlx_softc *sc, int action);
80 static int			mlx_v4_fw_handshake(struct mlx_softc *sc, int *error, int *param1, int *param2, int first);
81 
82 static int			mlx_v5_tryqueue(struct mlx_softc *sc, struct mlx_command *mc);
83 static int			mlx_v5_findcomplete(struct mlx_softc *sc, u_int8_t *slot, u_int16_t *status);
84 static void			mlx_v5_intaction(struct mlx_softc *sc, int action);
85 static int			mlx_v5_fw_handshake(struct mlx_softc *sc, int *error, int *param1, int *param2, int first);
86 
87 /*
88  * Status monitoring
89  */
90 static void			mlx_periodic(void *data);
91 static void			mlx_periodic_enquiry(struct mlx_command *mc);
92 static void			mlx_periodic_eventlog_poll(struct mlx_softc *sc);
93 static void			mlx_periodic_eventlog_respond(struct mlx_command *mc);
94 static void			mlx_periodic_rebuild(struct mlx_command *mc);
95 
96 /*
97  * Channel Pause
98  */
99 static void			mlx_pause_action(struct mlx_softc *sc);
100 static void			mlx_pause_done(struct mlx_command *mc);
101 
102 /*
103  * Command submission.
104  */
105 static void			*mlx_enquire(struct mlx_softc *sc, int command, size_t bufsize,
106 					     void (*complete)(struct mlx_command *mc));
107 static int			mlx_flush(struct mlx_softc *sc);
108 static int			mlx_check(struct mlx_softc *sc, int drive);
109 static int			mlx_rebuild(struct mlx_softc *sc, int channel, int target);
110 static int			mlx_wait_command(struct mlx_command *mc);
111 static int			mlx_poll_command(struct mlx_command *mc);
112 void				mlx_startio_cb(void *arg,
113 					       bus_dma_segment_t *segs,
114 					       int nsegments, int error);
115 static void			mlx_startio(struct mlx_softc *sc);
116 static void			mlx_completeio(struct mlx_command *mc);
117 static int			mlx_user_command(struct mlx_softc *sc,
118 						 struct mlx_usercommand *mu);
119 void				mlx_user_cb(void *arg, bus_dma_segment_t *segs,
120 					    int nsegments, int error);
121 
122 /*
123  * Command buffer allocation.
124  */
125 static struct mlx_command	*mlx_alloccmd(struct mlx_softc *sc);
126 static void			mlx_releasecmd(struct mlx_command *mc);
127 static void			mlx_freecmd(struct mlx_command *mc);
128 
129 /*
130  * Command management.
131  */
132 static int			mlx_getslot(struct mlx_command *mc);
133 static void			mlx_setup_dmamap(struct mlx_command *mc,
134 						 bus_dma_segment_t *segs,
135 						 int nsegments, int error);
136 static void			mlx_unmapcmd(struct mlx_command *mc);
137 static int			mlx_shutdown_locked(struct mlx_softc *sc);
138 static int			mlx_start(struct mlx_command *mc);
139 static int			mlx_done(struct mlx_softc *sc, int startio);
140 static void			mlx_complete(struct mlx_softc *sc);
141 
142 /*
143  * Debugging.
144  */
145 static char			*mlx_diagnose_command(struct mlx_command *mc);
146 static void			mlx_describe_controller(struct mlx_softc *sc);
147 static int			mlx_fw_message(struct mlx_softc *sc, int status, int param1, int param2);
148 
149 /*
150  * Utility functions.
151  */
152 static struct mlx_sysdrive	*mlx_findunit(struct mlx_softc *sc, int unit);
153 
154 /********************************************************************************
155  ********************************************************************************
156                                                                 Public Interfaces
157  ********************************************************************************
158  ********************************************************************************/
159 
160 /********************************************************************************
161  * Free all of the resources associated with (sc)
162  *
163  * Should not be called if the controller is active.
164  */
165 void
166 mlx_free(struct mlx_softc *sc)
167 {
168     struct mlx_command	*mc;
169 
170     debug_called(1);
171 
172     /* destroy control device */
173     if (sc->mlx_dev_t != NULL)
174 	destroy_dev(sc->mlx_dev_t);
175 
176     if (sc->mlx_intr)
177 	bus_teardown_intr(sc->mlx_dev, sc->mlx_irq, sc->mlx_intr);
178 
179     /* cancel status timeout */
180     MLX_IO_LOCK(sc);
181     callout_stop(&sc->mlx_timeout);
182 
183     /* throw away any command buffers */
184     while ((mc = TAILQ_FIRST(&sc->mlx_freecmds)) != NULL) {
185 	TAILQ_REMOVE(&sc->mlx_freecmds, mc, mc_link);
186 	mlx_freecmd(mc);
187     }
188     MLX_IO_UNLOCK(sc);
189     callout_drain(&sc->mlx_timeout);
190 
191     /* destroy data-transfer DMA tag */
192     if (sc->mlx_buffer_dmat)
193 	bus_dma_tag_destroy(sc->mlx_buffer_dmat);
194 
195     /* free and destroy DMA memory and tag for s/g lists */
196     if (sc->mlx_sgbusaddr)
197 	bus_dmamap_unload(sc->mlx_sg_dmat, sc->mlx_sg_dmamap);
198     if (sc->mlx_sgtable)
199 	bus_dmamem_free(sc->mlx_sg_dmat, sc->mlx_sgtable, sc->mlx_sg_dmamap);
200     if (sc->mlx_sg_dmat)
201 	bus_dma_tag_destroy(sc->mlx_sg_dmat);
202 
203     /* disconnect the interrupt handler */
204     if (sc->mlx_irq != NULL)
205 	bus_release_resource(sc->mlx_dev, SYS_RES_IRQ, 0, sc->mlx_irq);
206 
207     /* destroy the parent DMA tag */
208     if (sc->mlx_parent_dmat)
209 	bus_dma_tag_destroy(sc->mlx_parent_dmat);
210 
211     /* release the register window mapping */
212     if (sc->mlx_mem != NULL)
213 	bus_release_resource(sc->mlx_dev, sc->mlx_mem_type, sc->mlx_mem_rid, sc->mlx_mem);
214 
215     /* free controller enquiry data */
216     if (sc->mlx_enq2 != NULL)
217 	free(sc->mlx_enq2, M_DEVBUF);
218 
219     sx_destroy(&sc->mlx_config_lock);
220     mtx_destroy(&sc->mlx_io_lock);
221 }
222 
223 /********************************************************************************
224  * Map the scatter/gather table into bus space
225  */
226 static void
227 mlx_dma_map_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error)
228 {
229     struct mlx_softc	*sc = (struct mlx_softc *)arg;
230 
231     debug_called(1);
232 
233     /* save base of s/g table's address in bus space */
234     sc->mlx_sgbusaddr = segs->ds_addr;
235 }
236 
237 static int
238 mlx_sglist_map(struct mlx_softc *sc)
239 {
240     size_t	segsize;
241     int		error, ncmd;
242 
243     debug_called(1);
244 
245     /* destroy any existing mappings */
246     if (sc->mlx_sgbusaddr)
247 	bus_dmamap_unload(sc->mlx_sg_dmat, sc->mlx_sg_dmamap);
248     if (sc->mlx_sgtable)
249 	bus_dmamem_free(sc->mlx_sg_dmat, sc->mlx_sgtable, sc->mlx_sg_dmamap);
250     if (sc->mlx_sg_dmat)
251 	bus_dma_tag_destroy(sc->mlx_sg_dmat);
252     sc->mlx_sgbusaddr = 0;
253     sc->mlx_sgtable = NULL;
254     sc->mlx_sg_dmat = NULL;
255 
256     /*
257      * Create a single tag describing a region large enough to hold all of
258      * the s/g lists we will need.  If we're called early on, we don't know how
259      * many commands we're going to be asked to support, so only allocate enough
260      * for a couple.
261      */
262     if (sc->mlx_enq2 == NULL) {
263 	ncmd = 2;
264     } else {
265 	ncmd = sc->mlx_enq2->me_max_commands;
266     }
267     segsize = sizeof(struct mlx_sgentry) * MLX_NSEG * ncmd;
268     error = bus_dma_tag_create(sc->mlx_parent_dmat, 	/* parent */
269 			       1, 0, 			/* alignment,boundary */
270 			       BUS_SPACE_MAXADDR,	/* lowaddr */
271 			       BUS_SPACE_MAXADDR, 	/* highaddr */
272 			       NULL, NULL, 		/* filter, filterarg */
273 			       segsize, 1,		/* maxsize, nsegments */
274 			       BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
275 			       0,			/* flags */
276 			       NULL, NULL,		/* lockfunc, lockarg */
277 			       &sc->mlx_sg_dmat);
278     if (error != 0) {
279 	device_printf(sc->mlx_dev, "can't allocate scatter/gather DMA tag\n");
280 	return(ENOMEM);
281     }
282 
283     /*
284      * Allocate enough s/g maps for all commands and permanently map them into
285      * controller-visible space.
286      *
287      * XXX this assumes we can get enough space for all the s/g maps in one
288      * contiguous slab.  We may need to switch to a more complex arrangement
289      * where we allocate in smaller chunks and keep a lookup table from slot
290      * to bus address.
291      */
292     error = bus_dmamem_alloc(sc->mlx_sg_dmat, (void **)&sc->mlx_sgtable,
293 			     BUS_DMA_NOWAIT, &sc->mlx_sg_dmamap);
294     if (error) {
295 	device_printf(sc->mlx_dev, "can't allocate s/g table\n");
296 	return(ENOMEM);
297     }
298     (void)bus_dmamap_load(sc->mlx_sg_dmat, sc->mlx_sg_dmamap, sc->mlx_sgtable,
299 			  segsize, mlx_dma_map_sg, sc, 0);
300     return(0);
301 }
302 
303 /********************************************************************************
304  * Initialise the controller and softc
305  */
306 int
307 mlx_attach(struct mlx_softc *sc)
308 {
309     struct mlx_enquiry_old	*meo;
310     int				rid, error, fwminor, hscode, hserror, hsparam1, hsparam2, hsmsg;
311 
312     debug_called(1);
313 
314     /*
315      * Initialise per-controller queues.
316      */
317     TAILQ_INIT(&sc->mlx_work);
318     TAILQ_INIT(&sc->mlx_freecmds);
319     bioq_init(&sc->mlx_bioq);
320 
321     /*
322      * Select accessor methods based on controller interface type.
323      */
324     switch(sc->mlx_iftype) {
325     case MLX_IFTYPE_2:
326     case MLX_IFTYPE_3:
327 	sc->mlx_tryqueue	= mlx_v3_tryqueue;
328 	sc->mlx_findcomplete	= mlx_v3_findcomplete;
329 	sc->mlx_intaction	= mlx_v3_intaction;
330 	sc->mlx_fw_handshake	= mlx_v3_fw_handshake;
331 	break;
332     case MLX_IFTYPE_4:
333 	sc->mlx_tryqueue	= mlx_v4_tryqueue;
334 	sc->mlx_findcomplete	= mlx_v4_findcomplete;
335 	sc->mlx_intaction	= mlx_v4_intaction;
336 	sc->mlx_fw_handshake	= mlx_v4_fw_handshake;
337 	break;
338     case MLX_IFTYPE_5:
339 	sc->mlx_tryqueue	= mlx_v5_tryqueue;
340 	sc->mlx_findcomplete	= mlx_v5_findcomplete;
341 	sc->mlx_intaction	= mlx_v5_intaction;
342 	sc->mlx_fw_handshake	= mlx_v5_fw_handshake;
343 	break;
344     default:
345 	return(ENXIO);		/* should never happen */
346     }
347 
348     /* disable interrupts before we start talking to the controller */
349     MLX_IO_LOCK(sc);
350     sc->mlx_intaction(sc, MLX_INTACTION_DISABLE);
351     MLX_IO_UNLOCK(sc);
352 
353     /*
354      * Wait for the controller to come ready, handshake with the firmware if required.
355      * This is typically only necessary on platforms where the controller BIOS does not
356      * run.
357      */
358     hsmsg = 0;
359     DELAY(1000);
360     while ((hscode = sc->mlx_fw_handshake(sc, &hserror, &hsparam1, &hsparam2,
361 	hsmsg == 0)) != 0) {
362 	/* report first time around... */
363 	if (hsmsg == 0) {
364 	    device_printf(sc->mlx_dev, "controller initialisation in progress...\n");
365 	    hsmsg = 1;
366 	}
367 	/* did we get a real message? */
368 	if (hscode == 2) {
369 	    hscode = mlx_fw_message(sc, hserror, hsparam1, hsparam2);
370 	    /* fatal initialisation error? */
371 	    if (hscode != 0) {
372 		return(ENXIO);
373 	    }
374 	}
375     }
376     if (hsmsg == 1)
377 	device_printf(sc->mlx_dev, "initialisation complete.\n");
378 
379     /*
380      * Allocate and connect our interrupt.
381      */
382     rid = 0;
383     sc->mlx_irq = bus_alloc_resource_any(sc->mlx_dev, SYS_RES_IRQ, &rid,
384         RF_SHAREABLE | RF_ACTIVE);
385     if (sc->mlx_irq == NULL) {
386 	device_printf(sc->mlx_dev, "can't allocate interrupt\n");
387 	return(ENXIO);
388     }
389     error = bus_setup_intr(sc->mlx_dev, sc->mlx_irq, INTR_TYPE_BIO |
390 	INTR_ENTROPY | INTR_MPSAFE, NULL, mlx_intr, sc, &sc->mlx_intr);
391     if (error) {
392 	device_printf(sc->mlx_dev, "can't set up interrupt\n");
393 	return(ENXIO);
394     }
395 
396     /*
397      * Create DMA tag for mapping buffers into controller-addressable space.
398      */
399     error = bus_dma_tag_create(sc->mlx_parent_dmat, 	/* parent */
400 			       1, 0, 			/* align, boundary */
401 			       BUS_SPACE_MAXADDR,	/* lowaddr */
402 			       BUS_SPACE_MAXADDR, 	/* highaddr */
403 			       NULL, NULL, 		/* filter, filterarg */
404 			       MLX_MAXPHYS,		/* maxsize */
405 			       MLX_NSEG,		/* nsegments */
406 			       BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
407 			       0,			/* flags */
408 			       busdma_lock_mutex,	/* lockfunc */
409 			       &sc->mlx_io_lock,	/* lockarg */
410 			       &sc->mlx_buffer_dmat);
411     if (error != 0) {
412 	device_printf(sc->mlx_dev, "can't allocate buffer DMA tag\n");
413 	return(ENOMEM);
414     }
415 
416     /*
417      * Create some initial scatter/gather mappings so we can run the probe
418      * commands.
419      */
420     error = mlx_sglist_map(sc);
421     if (error != 0) {
422 	device_printf(sc->mlx_dev, "can't make initial s/g list mapping\n");
423 	return(error);
424     }
425 
426     /*
427      * We don't (yet) know where the event log is up to.
428      */
429     sc->mlx_currevent = -1;
430 
431     /*
432      * Obtain controller feature information
433      */
434     MLX_IO_LOCK(sc);
435     if ((sc->mlx_enq2 = mlx_enquire(sc, MLX_CMD_ENQUIRY2, sizeof(struct mlx_enquiry2), NULL)) == NULL) {
436 	MLX_IO_UNLOCK(sc);
437 	device_printf(sc->mlx_dev, "ENQUIRY2 failed\n");
438 	return(ENXIO);
439     }
440 
441     /*
442      * Do quirk/feature related things.
443      */
444     fwminor = (sc->mlx_enq2->me_firmware_id >> 8) & 0xff;
445     switch(sc->mlx_iftype) {
446     case MLX_IFTYPE_2:
447 	/* These controllers don't report the firmware version in the ENQUIRY2 response */
448 	if ((meo = mlx_enquire(sc, MLX_CMD_ENQUIRY_OLD, sizeof(struct mlx_enquiry_old), NULL)) == NULL) {
449 	    MLX_IO_UNLOCK(sc);
450 	    device_printf(sc->mlx_dev, "ENQUIRY_OLD failed\n");
451 	    return(ENXIO);
452 	}
453 	sc->mlx_enq2->me_firmware_id = ('0' << 24) | (0 << 16) | (meo->me_fwminor << 8) | meo->me_fwmajor;
454 
455 	/* XXX require 2.42 or better (PCI) */
456 	if (meo->me_fwminor < 42) {
457 	    device_printf(sc->mlx_dev, " *** WARNING *** This firmware revision is not recommended\n");
458 	    device_printf(sc->mlx_dev, " *** WARNING *** Use revision 2.42 or later\n");
459 	}
460 	free(meo, M_DEVBUF);
461 	break;
462     case MLX_IFTYPE_3:
463 	/* XXX certify 3.52? */
464 	if (fwminor < 51) {
465 	    device_printf(sc->mlx_dev, " *** WARNING *** This firmware revision is not recommended\n");
466 	    device_printf(sc->mlx_dev, " *** WARNING *** Use revision 3.51 or later\n");
467 	}
468 	break;
469     case MLX_IFTYPE_4:
470 	/* XXX certify firmware versions? */
471 	if (fwminor < 6) {
472 	    device_printf(sc->mlx_dev, " *** WARNING *** This firmware revision is not recommended\n");
473 	    device_printf(sc->mlx_dev, " *** WARNING *** Use revision 4.06 or later\n");
474 	}
475 	break;
476     case MLX_IFTYPE_5:
477 	if (fwminor < 7) {
478 	    device_printf(sc->mlx_dev, " *** WARNING *** This firmware revision is not recommended\n");
479 	    device_printf(sc->mlx_dev, " *** WARNING *** Use revision 5.07 or later\n");
480 	}
481 	break;
482     default:
483 	MLX_IO_UNLOCK(sc);
484 	return(ENXIO);		/* should never happen */
485     }
486     MLX_IO_UNLOCK(sc);
487 
488     /*
489      * Create the final scatter/gather mappings now that we have characterised the controller.
490      */
491     error = mlx_sglist_map(sc);
492     if (error != 0) {
493 	device_printf(sc->mlx_dev, "can't make final s/g list mapping\n");
494 	return(error);
495     }
496 
497     /*
498      * No user-requested background operation is in progress.
499      */
500     sc->mlx_background = 0;
501     sc->mlx_rebuildstat.rs_code = MLX_REBUILDSTAT_IDLE;
502 
503     /*
504      * Create the control device.
505      */
506     sc->mlx_dev_t = make_dev(&mlx_cdevsw, 0, UID_ROOT, GID_OPERATOR,
507 			     S_IRUSR | S_IWUSR, "mlx%d", device_get_unit(sc->mlx_dev));
508     sc->mlx_dev_t->si_drv1 = sc;
509 
510     /*
511      * Start the timeout routine.
512      */
513     callout_reset(&sc->mlx_timeout, hz, mlx_periodic, sc);
514 
515     /* print a little information about the controller */
516     mlx_describe_controller(sc);
517 
518     return(0);
519 }
520 
521 /********************************************************************************
522  * Locate disk resources and attach children to them.
523  */
524 void
525 mlx_startup(struct mlx_softc *sc)
526 {
527     struct mlx_enq_sys_drive	*mes;
528     struct mlx_sysdrive		*dr;
529     int				i, error;
530 
531     debug_called(1);
532 
533     /*
534      * Scan all the system drives and attach children for those that
535      * don't currently have them.
536      */
537     MLX_IO_LOCK(sc);
538     mes = mlx_enquire(sc, MLX_CMD_ENQSYSDRIVE, sizeof(*mes) * MLX_MAXDRIVES, NULL);
539     MLX_IO_UNLOCK(sc);
540     if (mes == NULL) {
541 	device_printf(sc->mlx_dev, "error fetching drive status\n");
542 	return;
543     }
544 
545     /* iterate over drives returned */
546     MLX_CONFIG_LOCK(sc);
547     for (i = 0, dr = &sc->mlx_sysdrive[0];
548 	 (i < MLX_MAXDRIVES) && (mes[i].sd_size != 0xffffffff);
549 	 i++, dr++) {
550 	/* are we already attached to this drive? */
551     	if (dr->ms_disk == 0) {
552 	    /* pick up drive information */
553 	    dr->ms_size = mes[i].sd_size;
554 	    dr->ms_raidlevel = mes[i].sd_raidlevel & 0xf;
555 	    dr->ms_state = mes[i].sd_state;
556 
557 	    /* generate geometry information */
558 	    if (sc->mlx_geom == MLX_GEOM_128_32) {
559 		dr->ms_heads = 128;
560 		dr->ms_sectors = 32;
561 		dr->ms_cylinders = dr->ms_size / (128 * 32);
562 	    } else {        /* MLX_GEOM_255/63 */
563 		dr->ms_heads = 255;
564 		dr->ms_sectors = 63;
565 		dr->ms_cylinders = dr->ms_size / (255 * 63);
566 	    }
567 	    dr->ms_disk =  device_add_child(sc->mlx_dev, /*"mlxd"*/NULL, -1);
568 	    if (dr->ms_disk == 0)
569 		device_printf(sc->mlx_dev, "device_add_child failed\n");
570 	    device_set_ivars(dr->ms_disk, dr);
571 	}
572     }
573     free(mes, M_DEVBUF);
574     if ((error = bus_generic_attach(sc->mlx_dev)) != 0)
575 	device_printf(sc->mlx_dev, "bus_generic_attach returned %d", error);
576 
577     /* mark controller back up */
578     MLX_IO_LOCK(sc);
579     sc->mlx_state &= ~MLX_STATE_SHUTDOWN;
580 
581     /* enable interrupts */
582     sc->mlx_intaction(sc, MLX_INTACTION_ENABLE);
583     MLX_IO_UNLOCK(sc);
584     MLX_CONFIG_UNLOCK(sc);
585 }
586 
587 /********************************************************************************
588  * Disconnect from the controller completely, in preparation for unload.
589  */
590 int
591 mlx_detach(device_t dev)
592 {
593     struct mlx_softc	*sc = device_get_softc(dev);
594     struct mlxd_softc	*mlxd;
595     int			i, error;
596 
597     debug_called(1);
598 
599     error = EBUSY;
600     MLX_CONFIG_LOCK(sc);
601     if (sc->mlx_state & MLX_STATE_OPEN)
602 	goto out;
603 
604     for (i = 0; i < MLX_MAXDRIVES; i++) {
605 	if (sc->mlx_sysdrive[i].ms_disk != 0) {
606 	    mlxd = device_get_softc(sc->mlx_sysdrive[i].ms_disk);
607 	    if (mlxd->mlxd_flags & MLXD_OPEN) {		/* drive is mounted, abort detach */
608 		device_printf(sc->mlx_sysdrive[i].ms_disk, "still open, can't detach\n");
609 		goto out;
610 	    }
611 	}
612     }
613     if ((error = mlx_shutdown(dev)))
614 	goto out;
615     MLX_CONFIG_UNLOCK(sc);
616 
617     mlx_free(sc);
618 
619     return (0);
620  out:
621     MLX_CONFIG_UNLOCK(sc);
622     return(error);
623 }
624 
625 /********************************************************************************
626  * Bring the controller down to a dormant state and detach all child devices.
627  *
628  * This function is called before detach, system shutdown, or before performing
629  * an operation which may add or delete system disks.  (Call mlx_startup to
630  * resume normal operation.)
631  *
632  * Note that we can assume that the bioq on the controller is empty, as we won't
633  * allow shutdown if any device is open.
634  */
635 int
636 mlx_shutdown(device_t dev)
637 {
638     struct mlx_softc	*sc = device_get_softc(dev);
639     int			error;
640 
641     MLX_CONFIG_LOCK(sc);
642     error = mlx_shutdown_locked(sc);
643     MLX_CONFIG_UNLOCK(sc);
644     return (error);
645 }
646 
647 static int
648 mlx_shutdown_locked(struct mlx_softc *sc)
649 {
650     int			i, error;
651 
652     debug_called(1);
653 
654     MLX_CONFIG_ASSERT_LOCKED(sc);
655 
656     MLX_IO_LOCK(sc);
657     sc->mlx_state |= MLX_STATE_SHUTDOWN;
658     sc->mlx_intaction(sc, MLX_INTACTION_DISABLE);
659 
660     /* flush controller */
661     device_printf(sc->mlx_dev, "flushing cache...");
662     if (mlx_flush(sc)) {
663 	printf("failed\n");
664     } else {
665 	printf("done\n");
666     }
667     MLX_IO_UNLOCK(sc);
668 
669     /* delete all our child devices */
670     for (i = 0; i < MLX_MAXDRIVES; i++) {
671 	if (sc->mlx_sysdrive[i].ms_disk != 0) {
672 	    if ((error = device_delete_child(sc->mlx_dev, sc->mlx_sysdrive[i].ms_disk)) != 0)
673 		return (error);
674 	    sc->mlx_sysdrive[i].ms_disk = 0;
675 	}
676     }
677 
678     return (0);
679 }
680 
681 /********************************************************************************
682  * Bring the controller to a quiescent state, ready for system suspend.
683  */
684 int
685 mlx_suspend(device_t dev)
686 {
687     struct mlx_softc	*sc = device_get_softc(dev);
688 
689     debug_called(1);
690 
691     MLX_IO_LOCK(sc);
692     sc->mlx_state |= MLX_STATE_SUSPEND;
693 
694     /* flush controller */
695     device_printf(sc->mlx_dev, "flushing cache...");
696     printf("%s\n", mlx_flush(sc) ? "failed" : "done");
697 
698     sc->mlx_intaction(sc, MLX_INTACTION_DISABLE);
699     MLX_IO_UNLOCK(sc);
700 
701     return(0);
702 }
703 
704 /********************************************************************************
705  * Bring the controller back to a state ready for operation.
706  */
707 int
708 mlx_resume(device_t dev)
709 {
710     struct mlx_softc	*sc = device_get_softc(dev);
711 
712     debug_called(1);
713 
714     MLX_IO_LOCK(sc);
715     sc->mlx_state &= ~MLX_STATE_SUSPEND;
716     sc->mlx_intaction(sc, MLX_INTACTION_ENABLE);
717     MLX_IO_UNLOCK(sc);
718 
719     return(0);
720 }
721 
722 /*******************************************************************************
723  * Take an interrupt, or be poked by other code to look for interrupt-worthy
724  * status.
725  */
726 void
727 mlx_intr(void *arg)
728 {
729     struct mlx_softc	*sc = (struct mlx_softc *)arg;
730 
731     debug_called(1);
732 
733     /* collect finished commands, queue anything waiting */
734     MLX_IO_LOCK(sc);
735     mlx_done(sc, 1);
736     MLX_IO_UNLOCK(sc);
737 };
738 
739 /*******************************************************************************
740  * Receive a buf structure from a child device and queue it on a particular
741  * disk resource, then poke the disk resource to start as much work as it can.
742  */
743 int
744 mlx_submit_buf(struct mlx_softc *sc, struct bio *bp)
745 {
746 
747     debug_called(1);
748 
749     MLX_IO_ASSERT_LOCKED(sc);
750     bioq_insert_tail(&sc->mlx_bioq, bp);
751     sc->mlx_waitbufs++;
752     mlx_startio(sc);
753     return(0);
754 }
755 
756 /********************************************************************************
757  * Accept an open operation on the control device.
758  */
759 int
760 mlx_open(struct cdev *dev, int flags, int fmt, struct thread *td)
761 {
762     struct mlx_softc	*sc = dev->si_drv1;
763 
764     MLX_CONFIG_LOCK(sc);
765     MLX_IO_LOCK(sc);
766     sc->mlx_state |= MLX_STATE_OPEN;
767     MLX_IO_UNLOCK(sc);
768     MLX_CONFIG_UNLOCK(sc);
769     return(0);
770 }
771 
772 /********************************************************************************
773  * Accept the last close on the control device.
774  */
775 int
776 mlx_close(struct cdev *dev, int flags, int fmt, struct thread *td)
777 {
778     struct mlx_softc	*sc = dev->si_drv1;
779 
780     MLX_CONFIG_LOCK(sc);
781     MLX_IO_LOCK(sc);
782     sc->mlx_state &= ~MLX_STATE_OPEN;
783     MLX_IO_UNLOCK(sc);
784     MLX_CONFIG_UNLOCK(sc);
785     return (0);
786 }
787 
788 /********************************************************************************
789  * Handle controller-specific control operations.
790  */
791 int
792 mlx_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int32_t flag, struct thread *td)
793 {
794     struct mlx_softc		*sc = dev->si_drv1;
795     struct mlx_rebuild_request	*rb = (struct mlx_rebuild_request *)addr;
796     struct mlx_rebuild_status	*rs = (struct mlx_rebuild_status *)addr;
797     int				*arg = (int *)addr;
798     struct mlx_pause		*mp;
799     struct mlx_sysdrive		*dr;
800     struct mlxd_softc		*mlxd;
801     int				i, error;
802 
803     switch(cmd) {
804 	/*
805 	 * Enumerate connected system drives; returns the first system drive's
806 	 * unit number if *arg is -1, or the next unit after *arg if it's
807 	 * a valid unit on this controller.
808 	 */
809     case MLX_NEXT_CHILD:
810 	/* search system drives */
811 	MLX_CONFIG_LOCK(sc);
812 	for (i = 0; i < MLX_MAXDRIVES; i++) {
813 	    /* is this one attached? */
814 	    if (sc->mlx_sysdrive[i].ms_disk != 0) {
815 		/* looking for the next one we come across? */
816 		if (*arg == -1) {
817 		    *arg = device_get_unit(sc->mlx_sysdrive[i].ms_disk);
818 		    MLX_CONFIG_UNLOCK(sc);
819 		    return(0);
820 		}
821 		/* we want the one after this one */
822 		if (*arg == device_get_unit(sc->mlx_sysdrive[i].ms_disk))
823 		    *arg = -1;
824 	    }
825 	}
826 	MLX_CONFIG_UNLOCK(sc);
827 	return(ENOENT);
828 
829 	/*
830 	 * Scan the controller to see whether new drives have appeared.
831 	 */
832     case MLX_RESCAN_DRIVES:
833 	mtx_lock(&Giant);
834 	mlx_startup(sc);
835 	mtx_unlock(&Giant);
836 	return(0);
837 
838 	/*
839 	 * Disconnect from the specified drive; it may be about to go
840 	 * away.
841 	 */
842     case MLX_DETACH_DRIVE:			/* detach one drive */
843 	MLX_CONFIG_LOCK(sc);
844 	if (((dr = mlx_findunit(sc, *arg)) == NULL) ||
845 	    ((mlxd = device_get_softc(dr->ms_disk)) == NULL)) {
846 	    MLX_CONFIG_UNLOCK(sc);
847 	    return(ENOENT);
848 	}
849 
850 	device_printf(dr->ms_disk, "detaching...");
851 	error = 0;
852 	if (mlxd->mlxd_flags & MLXD_OPEN) {
853 	    error = EBUSY;
854 	    goto detach_out;
855 	}
856 
857 	/* flush controller */
858 	MLX_IO_LOCK(sc);
859 	if (mlx_flush(sc)) {
860 	    MLX_IO_UNLOCK(sc);
861 	    error = EBUSY;
862 	    goto detach_out;
863 	}
864 	MLX_IO_UNLOCK(sc);
865 
866 	/* nuke drive */
867 	if ((error = device_delete_child(sc->mlx_dev, dr->ms_disk)) != 0)
868 	    goto detach_out;
869 	dr->ms_disk = 0;
870 
871     detach_out:
872 	MLX_CONFIG_UNLOCK(sc);
873 	if (error) {
874 	    printf("failed\n");
875 	} else {
876 	    printf("done\n");
877 	}
878 	return(error);
879 
880 	/*
881 	 * Pause one or more SCSI channels for a period of time, to assist
882 	 * in the process of hot-swapping devices.
883 	 *
884 	 * Note that at least the 3.51 firmware on the DAC960PL doesn't seem
885 	 * to do this right.
886 	 */
887     case MLX_PAUSE_CHANNEL:			/* schedule a channel pause */
888 	/* Does this command work on this firmware? */
889 	if (!(sc->mlx_feature & MLX_FEAT_PAUSEWORKS))
890 	    return(EOPNOTSUPP);
891 
892 	/* check time values */
893 	mp = (struct mlx_pause *)addr;
894 	if ((mp->mp_when < 0) || (mp->mp_when > 3600))
895 	    return(EINVAL);
896 	if ((mp->mp_howlong < 1) || (mp->mp_howlong > (0xf * 30)))
897 	    return(EINVAL);
898 
899 	MLX_IO_LOCK(sc);
900 	if ((mp->mp_which == MLX_PAUSE_CANCEL) && (sc->mlx_pause.mp_when != 0)) {
901 	    /* cancel a pending pause operation */
902 	    sc->mlx_pause.mp_which = 0;
903 	} else {
904 	    /* fix for legal channels */
905 	    mp->mp_which &= ((1 << sc->mlx_enq2->me_actual_channels) -1);
906 
907 	    /* check for a pause currently running */
908 	    if ((sc->mlx_pause.mp_which != 0) && (sc->mlx_pause.mp_when == 0)) {
909 		MLX_IO_UNLOCK(sc);
910 		return(EBUSY);
911 	    }
912 
913 	    /* looks ok, go with it */
914 	    sc->mlx_pause.mp_which = mp->mp_which;
915 	    sc->mlx_pause.mp_when = time_second + mp->mp_when;
916 	    sc->mlx_pause.mp_howlong = sc->mlx_pause.mp_when + mp->mp_howlong;
917 	}
918 	MLX_IO_UNLOCK(sc);
919 	return(0);
920 
921 	/*
922 	 * Accept a command passthrough-style.
923 	 */
924     case MLX_COMMAND:
925 	return(mlx_user_command(sc, (struct mlx_usercommand *)addr));
926 
927 	/*
928 	 * Start a rebuild on a given SCSI disk
929 	 */
930     case MLX_REBUILDASYNC:
931 	MLX_IO_LOCK(sc);
932 	if (sc->mlx_background != 0) {
933 	    MLX_IO_UNLOCK(sc);
934 	    rb->rr_status = 0x0106;
935 	    return(EBUSY);
936 	}
937 	rb->rr_status = mlx_rebuild(sc, rb->rr_channel, rb->rr_target);
938 	switch (rb->rr_status) {
939 	case 0:
940 	    error = 0;
941 	    break;
942 	case 0x10000:
943 	    error = ENOMEM;		/* couldn't set up the command */
944 	    break;
945 	case 0x0002:
946 	    error = EBUSY;
947 	    break;
948 	case 0x0104:
949 	    error = EIO;
950 	    break;
951 	case 0x0105:
952 	    error = ERANGE;
953 	    break;
954 	case 0x0106:
955 	    error = EBUSY;
956 	    break;
957 	default:
958 	    error = EINVAL;
959 	    break;
960 	}
961 	if (error == 0)
962 	    sc->mlx_background = MLX_BACKGROUND_REBUILD;
963 	MLX_IO_UNLOCK(sc);
964 	return(error);
965 
966 	/*
967 	 * Get the status of the current rebuild or consistency check.
968 	 */
969     case MLX_REBUILDSTAT:
970 	MLX_IO_LOCK(sc);
971 	*rs = sc->mlx_rebuildstat;
972 	MLX_IO_UNLOCK(sc);
973 	return(0);
974 
975 	/*
976 	 * Return the per-controller system drive number matching the
977 	 * disk device number in (arg), if it happens to belong to us.
978 	 */
979     case MLX_GET_SYSDRIVE:
980 	error = ENOENT;
981 	MLX_CONFIG_LOCK(sc);
982 	mtx_lock(&Giant);
983 	mlxd = (struct mlxd_softc *)devclass_get_softc(mlxd_devclass, *arg);
984 	mtx_unlock(&Giant);
985 	if ((mlxd != NULL) && (mlxd->mlxd_drive >= sc->mlx_sysdrive) &&
986 	    (mlxd->mlxd_drive < (sc->mlx_sysdrive + MLX_MAXDRIVES))) {
987 	    error = 0;
988 	    *arg = mlxd->mlxd_drive - sc->mlx_sysdrive;
989 	}
990 	MLX_CONFIG_UNLOCK(sc);
991 	return(error);
992 
993     default:
994 	return(ENOTTY);
995     }
996 }
997 
998 /********************************************************************************
999  * Handle operations requested by a System Drive connected to this controller.
1000  */
1001 int
1002 mlx_submit_ioctl(struct mlx_softc *sc, struct mlx_sysdrive *drive, u_long cmd,
1003 		caddr_t addr, int32_t flag, struct thread *td)
1004 {
1005     int				*arg = (int *)addr;
1006     int				error, result;
1007 
1008     switch(cmd) {
1009 	/*
1010 	 * Return the current status of this drive.
1011 	 */
1012     case MLXD_STATUS:
1013 	MLX_IO_LOCK(sc);
1014 	*arg = drive->ms_state;
1015 	MLX_IO_UNLOCK(sc);
1016 	return(0);
1017 
1018 	/*
1019 	 * Start a background consistency check on this drive.
1020 	 */
1021     case MLXD_CHECKASYNC:		/* start a background consistency check */
1022 	MLX_IO_LOCK(sc);
1023 	if (sc->mlx_background != 0) {
1024 	    MLX_IO_UNLOCK(sc);
1025 	    *arg = 0x0106;
1026 	    return(EBUSY);
1027 	}
1028 	result = mlx_check(sc, drive - &sc->mlx_sysdrive[0]);
1029 	switch (result) {
1030 	case 0:
1031 	    error = 0;
1032 	    break;
1033 	case 0x10000:
1034 	    error = ENOMEM;		/* couldn't set up the command */
1035 	    break;
1036 	case 0x0002:
1037 	    error = EIO;
1038 	    break;
1039 	case 0x0105:
1040 	    error = ERANGE;
1041 	    break;
1042 	case 0x0106:
1043 	    error = EBUSY;
1044 	    break;
1045 	default:
1046 	    error = EINVAL;
1047 	    break;
1048 	}
1049 	if (error == 0)
1050 	    sc->mlx_background = MLX_BACKGROUND_CHECK;
1051 	MLX_IO_UNLOCK(sc);
1052 	*arg = result;
1053 	return(error);
1054 
1055     }
1056     return(ENOIOCTL);
1057 }
1058 
1059 
1060 /********************************************************************************
1061  ********************************************************************************
1062                                                                 Status Monitoring
1063  ********************************************************************************
1064  ********************************************************************************/
1065 
1066 /********************************************************************************
1067  * Fire off commands to periodically check the status of connected drives.
1068  */
1069 static void
1070 mlx_periodic(void *data)
1071 {
1072     struct mlx_softc *sc = (struct mlx_softc *)data;
1073 
1074     debug_called(1);
1075     MLX_IO_ASSERT_LOCKED(sc);
1076 
1077     /*
1078      * Run a bus pause?
1079      */
1080     if ((sc->mlx_pause.mp_which != 0) &&
1081 	(sc->mlx_pause.mp_when > 0) &&
1082 	(time_second >= sc->mlx_pause.mp_when)){
1083 
1084 	mlx_pause_action(sc);		/* pause is running */
1085 	sc->mlx_pause.mp_when = 0;
1086 	sysbeep(500, hz);
1087 
1088 	/*
1089 	 * Bus pause still running?
1090 	 */
1091     } else if ((sc->mlx_pause.mp_which != 0) &&
1092 	       (sc->mlx_pause.mp_when == 0)) {
1093 
1094 	/* time to stop bus pause? */
1095 	if (time_second >= sc->mlx_pause.mp_howlong) {
1096 	    mlx_pause_action(sc);
1097 	    sc->mlx_pause.mp_which = 0;	/* pause is complete */
1098 	    sysbeep(500, hz);
1099 	} else {
1100 	    sysbeep((time_second % 5) * 100 + 500, hz/8);
1101 	}
1102 
1103 	/*
1104 	 * Run normal periodic activities?
1105 	 */
1106     } else if (time_second > (sc->mlx_lastpoll + 10)) {
1107 	sc->mlx_lastpoll = time_second;
1108 
1109 	/*
1110 	 * Check controller status.
1111 	 *
1112 	 * XXX Note that this may not actually launch a command in situations of high load.
1113 	 */
1114 	mlx_enquire(sc, (sc->mlx_iftype == MLX_IFTYPE_2) ? MLX_CMD_ENQUIRY_OLD : MLX_CMD_ENQUIRY,
1115 		    imax(sizeof(struct mlx_enquiry), sizeof(struct mlx_enquiry_old)), mlx_periodic_enquiry);
1116 
1117 	/*
1118 	 * Check system drive status.
1119 	 *
1120 	 * XXX This might be better left to event-driven detection, eg. I/O to an offline
1121 	 *     drive will detect it's offline, rebuilds etc. should detect the drive is back
1122 	 *     online.
1123 	 */
1124 	mlx_enquire(sc, MLX_CMD_ENQSYSDRIVE, sizeof(struct mlx_enq_sys_drive) * MLX_MAXDRIVES,
1125 			mlx_periodic_enquiry);
1126 
1127     }
1128 
1129     /* get drive rebuild/check status */
1130     /* XXX should check sc->mlx_background if this is only valid while in progress */
1131     mlx_enquire(sc, MLX_CMD_REBUILDSTAT, sizeof(struct mlx_rebuild_stat), mlx_periodic_rebuild);
1132 
1133     /* deal with possibly-missed interrupts and timed-out commands */
1134     mlx_done(sc, 1);
1135 
1136     /* reschedule another poll next second or so */
1137     callout_reset(&sc->mlx_timeout, hz, mlx_periodic, sc);
1138 }
1139 
1140 /********************************************************************************
1141  * Handle the result of an ENQUIRY command instigated by periodic status polling.
1142  */
1143 static void
1144 mlx_periodic_enquiry(struct mlx_command *mc)
1145 {
1146     struct mlx_softc		*sc = mc->mc_sc;
1147 
1148     debug_called(1);
1149     MLX_IO_ASSERT_LOCKED(sc);
1150 
1151     /* Command completed OK? */
1152     if (mc->mc_status != 0) {
1153 	device_printf(sc->mlx_dev, "periodic enquiry failed - %s\n", mlx_diagnose_command(mc));
1154 	goto out;
1155     }
1156 
1157     /* respond to command */
1158     switch(mc->mc_mailbox[0]) {
1159 	/*
1160 	 * This is currently a bit fruitless, as we don't know how to extract the eventlog
1161 	 * pointer yet.
1162 	 */
1163     case MLX_CMD_ENQUIRY_OLD:
1164     {
1165 	struct mlx_enquiry		*me = (struct mlx_enquiry *)mc->mc_data;
1166 	struct mlx_enquiry_old		*meo = (struct mlx_enquiry_old *)mc->mc_data;
1167 	int				i;
1168 
1169 	/* convert data in-place to new format */
1170 	for (i = (sizeof(me->me_dead) / sizeof(me->me_dead[0])) - 1; i >= 0; i--) {
1171 	    me->me_dead[i].dd_chan = meo->me_dead[i].dd_chan;
1172 	    me->me_dead[i].dd_targ = meo->me_dead[i].dd_targ;
1173 	}
1174 	me->me_misc_flags        = 0;
1175 	me->me_rebuild_count     = meo->me_rebuild_count;
1176 	me->me_dead_count        = meo->me_dead_count;
1177 	me->me_critical_sd_count = meo->me_critical_sd_count;
1178 	me->me_event_log_seq_num = 0;
1179 	me->me_offline_sd_count  = meo->me_offline_sd_count;
1180 	me->me_max_commands      = meo->me_max_commands;
1181 	me->me_rebuild_flag      = meo->me_rebuild_flag;
1182 	me->me_fwmajor           = meo->me_fwmajor;
1183 	me->me_fwminor           = meo->me_fwminor;
1184 	me->me_status_flags      = meo->me_status_flags;
1185 	me->me_flash_age         = meo->me_flash_age;
1186 	for (i = (sizeof(me->me_drvsize) / sizeof(me->me_drvsize[0])) - 1; i >= 0; i--) {
1187 	    if (i > ((sizeof(meo->me_drvsize) / sizeof(meo->me_drvsize[0])) - 1)) {
1188 		me->me_drvsize[i] = 0;		/* drive beyond supported range */
1189 	    } else {
1190 		me->me_drvsize[i] = meo->me_drvsize[i];
1191 	    }
1192 	}
1193 	me->me_num_sys_drvs = meo->me_num_sys_drvs;
1194     }
1195     /* FALLTHROUGH */
1196 
1197 	/*
1198 	 * Generic controller status update.  We could do more with this than just
1199 	 * checking the event log.
1200 	 */
1201     case MLX_CMD_ENQUIRY:
1202     {
1203 	struct mlx_enquiry		*me = (struct mlx_enquiry *)mc->mc_data;
1204 
1205 	if (sc->mlx_currevent == -1) {
1206 	    /* initialise our view of the event log */
1207 	    sc->mlx_currevent = sc->mlx_lastevent = me->me_event_log_seq_num;
1208 	} else if ((me->me_event_log_seq_num != sc->mlx_lastevent) && !(sc->mlx_flags & MLX_EVENTLOG_BUSY)) {
1209 	    /* record where current events are up to */
1210 	    sc->mlx_currevent = me->me_event_log_seq_num;
1211 	    debug(1, "event log pointer was %d, now %d\n", sc->mlx_lastevent, sc->mlx_currevent);
1212 
1213 	    /* mark the event log as busy */
1214 	    sc->mlx_flags |= MLX_EVENTLOG_BUSY;
1215 
1216 	    /* drain new eventlog entries */
1217 	    mlx_periodic_eventlog_poll(sc);
1218 	}
1219 	break;
1220     }
1221     case MLX_CMD_ENQSYSDRIVE:
1222     {
1223 	struct mlx_enq_sys_drive	*mes = (struct mlx_enq_sys_drive *)mc->mc_data;
1224 	struct mlx_sysdrive		*dr;
1225 	int				i;
1226 
1227 	for (i = 0, dr = &sc->mlx_sysdrive[0];
1228 	     (i < MLX_MAXDRIVES) && (mes[i].sd_size != 0xffffffff);
1229 	     i++) {
1230 
1231 	    /* has state been changed by controller? */
1232 	    if (dr->ms_state != mes[i].sd_state) {
1233 		switch(mes[i].sd_state) {
1234 		case MLX_SYSD_OFFLINE:
1235 		    device_printf(dr->ms_disk, "drive offline\n");
1236 		    break;
1237 		case MLX_SYSD_ONLINE:
1238 		    device_printf(dr->ms_disk, "drive online\n");
1239 		    break;
1240 		case MLX_SYSD_CRITICAL:
1241 		    device_printf(dr->ms_disk, "drive critical\n");
1242 		    break;
1243 		}
1244 		/* save new state */
1245 		dr->ms_state = mes[i].sd_state;
1246 	    }
1247 	}
1248 	break;
1249     }
1250     default:
1251 	device_printf(sc->mlx_dev, "%s: unknown command 0x%x", __func__, mc->mc_mailbox[0]);
1252 	break;
1253     }
1254 
1255  out:
1256     free(mc->mc_data, M_DEVBUF);
1257     mlx_releasecmd(mc);
1258 }
1259 
1260 static void
1261 mlx_eventlog_cb(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
1262 {
1263     struct mlx_command *mc;
1264 
1265     mc = (struct mlx_command *)arg;
1266     mlx_setup_dmamap(mc, segs, nsegments, error);
1267 
1268     /* build the command to get one entry */
1269     mlx_make_type3(mc, MLX_CMD_LOGOP, MLX_LOGOP_GET, 1,
1270 		   mc->mc_sc->mlx_lastevent, 0, 0, mc->mc_dataphys, 0);
1271     mc->mc_complete = mlx_periodic_eventlog_respond;
1272     mc->mc_private = mc;
1273 
1274     /* start the command */
1275     if (mlx_start(mc) != 0) {
1276 	mlx_releasecmd(mc);
1277 	free(mc->mc_data, M_DEVBUF);
1278 	mc->mc_data = NULL;
1279     }
1280 
1281 }
1282 
1283 /********************************************************************************
1284  * Instigate a poll for one event log message on (sc).
1285  * We only poll for one message at a time, to keep our command usage down.
1286  */
1287 static void
1288 mlx_periodic_eventlog_poll(struct mlx_softc *sc)
1289 {
1290     struct mlx_command	*mc;
1291     void		*result = NULL;
1292     int			error = 0;
1293 
1294     debug_called(1);
1295     MLX_IO_ASSERT_LOCKED(sc);
1296 
1297     /* get ourselves a command buffer */
1298     error = 1;
1299     if ((mc = mlx_alloccmd(sc)) == NULL)
1300 	goto out;
1301 
1302     /* allocate the response structure */
1303     if ((result = malloc(/*sizeof(struct mlx_eventlog_entry)*/1024, M_DEVBUF,
1304 			 M_NOWAIT)) == NULL)
1305 	goto out;
1306 
1307     /* get a command slot */
1308     if (mlx_getslot(mc))
1309 	goto out;
1310 
1311     /* map the command so the controller can see it */
1312     mc->mc_data = result;
1313     mc->mc_length = /*sizeof(struct mlx_eventlog_entry)*/1024;
1314     error = bus_dmamap_load(sc->mlx_buffer_dmat, mc->mc_dmamap, mc->mc_data,
1315 			    mc->mc_length, mlx_eventlog_cb, mc, BUS_DMA_NOWAIT);
1316 
1317  out:
1318     if (error != 0) {
1319 	if (mc != NULL)
1320 	    mlx_releasecmd(mc);
1321 	if ((result != NULL) && (mc->mc_data != NULL))
1322 	    free(result, M_DEVBUF);
1323     }
1324 }
1325 
1326 /********************************************************************************
1327  * Handle the result of polling for a log message, generate diagnostic output.
1328  * If this wasn't the last message waiting for us, we'll go collect another.
1329  */
1330 static char *mlx_sense_messages[] = {
1331     "because write recovery failed",
1332     "because of SCSI bus reset failure",
1333     "because of double check condition",
1334     "because it was removed",
1335     "because of gross error on SCSI chip",
1336     "because of bad tag returned from drive",
1337     "because of timeout on SCSI command",
1338     "because of reset SCSI command issued from system",
1339     "because busy or parity error count exceeded limit",
1340     "because of 'kill drive' command from system",
1341     "because of selection timeout",
1342     "due to SCSI phase sequence error",
1343     "due to unknown status"
1344 };
1345 
1346 static void
1347 mlx_periodic_eventlog_respond(struct mlx_command *mc)
1348 {
1349     struct mlx_softc		*sc = mc->mc_sc;
1350     struct mlx_eventlog_entry	*el = (struct mlx_eventlog_entry *)mc->mc_data;
1351     char			*reason;
1352 
1353     debug_called(1);
1354     MLX_IO_ASSERT_LOCKED(sc);
1355 
1356     sc->mlx_lastevent++;		/* next message... */
1357     if (mc->mc_status == 0) {
1358 
1359 	/* handle event log message */
1360 	switch(el->el_type) {
1361 	    /*
1362 	     * This is the only sort of message we understand at the moment.
1363 	     * The tests here are probably incomplete.
1364 	     */
1365 	case MLX_LOGMSG_SENSE:	/* sense data */
1366 	    /* Mylex vendor-specific message indicating a drive was killed? */
1367 	    if ((el->el_sensekey == 9) &&
1368 		(el->el_asc == 0x80)) {
1369 		if (el->el_asq < nitems(mlx_sense_messages)) {
1370 		    reason = mlx_sense_messages[el->el_asq];
1371 		} else {
1372 		    reason = "for unknown reason";
1373 		}
1374 		device_printf(sc->mlx_dev, "physical drive %d:%d killed %s\n",
1375 			      el->el_channel, el->el_target, reason);
1376 	    }
1377 	    /* SCSI drive was reset? */
1378 	    if ((el->el_sensekey == 6) && (el->el_asc == 0x29)) {
1379 		device_printf(sc->mlx_dev, "physical drive %d:%d reset\n",
1380 			      el->el_channel, el->el_target);
1381 	    }
1382 	    /* SCSI drive error? */
1383 	    if (!((el->el_sensekey == 0) ||
1384 		  ((el->el_sensekey == 2) &&
1385 		   (el->el_asc == 0x04) &&
1386 		   ((el->el_asq == 0x01) ||
1387 		    (el->el_asq == 0x02))))) {
1388 		device_printf(sc->mlx_dev, "physical drive %d:%d error log: sense = %d asc = %x asq = %x\n",
1389 			      el->el_channel, el->el_target, el->el_sensekey, el->el_asc, el->el_asq);
1390 		device_printf(sc->mlx_dev, "  info %4D csi %4D\n", el->el_information, ":", el->el_csi, ":");
1391 	    }
1392 	    break;
1393 
1394 	default:
1395 	    device_printf(sc->mlx_dev, "unknown log message type 0x%x\n", el->el_type);
1396 	    break;
1397 	}
1398     } else {
1399 	device_printf(sc->mlx_dev, "error reading message log - %s\n", mlx_diagnose_command(mc));
1400 	/* give up on all the outstanding messages, as we may have come unsynched */
1401 	sc->mlx_lastevent = sc->mlx_currevent;
1402     }
1403 
1404     /* dispose of command and data */
1405     free(mc->mc_data, M_DEVBUF);
1406     mlx_releasecmd(mc);
1407 
1408     /* is there another message to obtain? */
1409     if (sc->mlx_lastevent != sc->mlx_currevent) {
1410 	mlx_periodic_eventlog_poll(sc);
1411     } else {
1412 	/* clear log-busy status */
1413 	sc->mlx_flags &= ~MLX_EVENTLOG_BUSY;
1414     }
1415 }
1416 
1417 /********************************************************************************
1418  * Handle check/rebuild operations in progress.
1419  */
1420 static void
1421 mlx_periodic_rebuild(struct mlx_command *mc)
1422 {
1423     struct mlx_softc		*sc = mc->mc_sc;
1424     struct mlx_rebuild_status	*mr = (struct mlx_rebuild_status *)mc->mc_data;
1425 
1426     MLX_IO_ASSERT_LOCKED(sc);
1427     switch(mc->mc_status) {
1428     case 0:				/* operation running, update stats */
1429 	sc->mlx_rebuildstat = *mr;
1430 
1431 	/* spontaneous rebuild/check? */
1432 	if (sc->mlx_background == 0) {
1433 	    sc->mlx_background = MLX_BACKGROUND_SPONTANEOUS;
1434 	    device_printf(sc->mlx_dev, "background check/rebuild operation started\n");
1435 	}
1436 	break;
1437 
1438     case 0x0105:			/* nothing running, finalise stats and report */
1439 	switch(sc->mlx_background) {
1440 	case MLX_BACKGROUND_CHECK:
1441 	    device_printf(sc->mlx_dev, "consistency check completed\n");	/* XXX print drive? */
1442 	    break;
1443 	case MLX_BACKGROUND_REBUILD:
1444 	    device_printf(sc->mlx_dev, "drive rebuild completed\n");	/* XXX print channel/target? */
1445 	    break;
1446 	case MLX_BACKGROUND_SPONTANEOUS:
1447 	default:
1448 	    /* if we have previously been non-idle, report the transition */
1449 	    if (sc->mlx_rebuildstat.rs_code != MLX_REBUILDSTAT_IDLE) {
1450 		device_printf(sc->mlx_dev, "background check/rebuild operation completed\n");
1451 	    }
1452 	}
1453 	sc->mlx_background = 0;
1454 	sc->mlx_rebuildstat.rs_code = MLX_REBUILDSTAT_IDLE;
1455 	break;
1456     }
1457     free(mc->mc_data, M_DEVBUF);
1458     mlx_releasecmd(mc);
1459 }
1460 
1461 /********************************************************************************
1462  ********************************************************************************
1463                                                                     Channel Pause
1464  ********************************************************************************
1465  ********************************************************************************/
1466 
1467 /********************************************************************************
1468  * It's time to perform a channel pause action for (sc), either start or stop
1469  * the pause.
1470  */
1471 static void
1472 mlx_pause_action(struct mlx_softc *sc)
1473 {
1474     struct mlx_command	*mc;
1475     int			failsafe, i, command;
1476 
1477     MLX_IO_ASSERT_LOCKED(sc);
1478 
1479     /* What are we doing here? */
1480     if (sc->mlx_pause.mp_when == 0) {
1481 	command = MLX_CMD_STARTCHANNEL;
1482 	failsafe = 0;
1483 
1484     } else {
1485 	command = MLX_CMD_STOPCHANNEL;
1486 
1487 	/*
1488 	 * Channels will always start again after the failsafe period,
1489 	 * which is specified in multiples of 30 seconds.
1490 	 * This constrains us to a maximum pause of 450 seconds.
1491 	 */
1492 	failsafe = ((sc->mlx_pause.mp_howlong - time_second) + 5) / 30;
1493 	if (failsafe > 0xf) {
1494 	    failsafe = 0xf;
1495 	    sc->mlx_pause.mp_howlong = time_second + (0xf * 30) - 5;
1496 	}
1497     }
1498 
1499     /* build commands for every channel requested */
1500     for (i = 0; i < sc->mlx_enq2->me_actual_channels; i++) {
1501 	if ((1 << i) & sc->mlx_pause.mp_which) {
1502 
1503 	    /* get ourselves a command buffer */
1504 	    if ((mc = mlx_alloccmd(sc)) == NULL)
1505 		goto fail;
1506 	    /* get a command slot */
1507 	    mc->mc_flags |= MLX_CMD_PRIORITY;
1508 	    if (mlx_getslot(mc))
1509 		goto fail;
1510 
1511 	    /* build the command */
1512 	    mlx_make_type2(mc, command, (failsafe << 4) | i, 0, 0, 0, 0, 0, 0, 0);
1513 	    mc->mc_complete = mlx_pause_done;
1514 	    mc->mc_private = sc;		/* XXX not needed */
1515 	    if (mlx_start(mc))
1516 		goto fail;
1517 	    /* command submitted OK */
1518 	    return;
1519 
1520 	fail:
1521 	    device_printf(sc->mlx_dev, "%s failed for channel %d\n",
1522 			  command == MLX_CMD_STOPCHANNEL ? "pause" : "resume", i);
1523 	    if (mc != NULL)
1524 		mlx_releasecmd(mc);
1525 	}
1526     }
1527 }
1528 
1529 static void
1530 mlx_pause_done(struct mlx_command *mc)
1531 {
1532     struct mlx_softc	*sc = mc->mc_sc;
1533     int			command = mc->mc_mailbox[0];
1534     int			channel = mc->mc_mailbox[2] & 0xf;
1535 
1536     MLX_IO_ASSERT_LOCKED(sc);
1537     if (mc->mc_status != 0) {
1538 	device_printf(sc->mlx_dev, "%s command failed - %s\n",
1539 		      command == MLX_CMD_STOPCHANNEL ? "pause" : "resume", mlx_diagnose_command(mc));
1540     } else if (command == MLX_CMD_STOPCHANNEL) {
1541 	device_printf(sc->mlx_dev, "channel %d pausing for %ld seconds\n",
1542 		      channel, (long)(sc->mlx_pause.mp_howlong - time_second));
1543     } else {
1544 	device_printf(sc->mlx_dev, "channel %d resuming\n", channel);
1545     }
1546     mlx_releasecmd(mc);
1547 }
1548 
1549 /********************************************************************************
1550  ********************************************************************************
1551                                                                Command Submission
1552  ********************************************************************************
1553  ********************************************************************************/
1554 
1555 static void
1556 mlx_enquire_cb(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
1557 {
1558     struct mlx_softc *sc;
1559     struct mlx_command *mc;
1560 
1561     mc = (struct mlx_command *)arg;
1562     if (error)
1563 	return;
1564 
1565     mlx_setup_dmamap(mc, segs, nsegments, error);
1566 
1567     /* build an enquiry command */
1568     sc = mc->mc_sc;
1569     mlx_make_type2(mc, mc->mc_command, 0, 0, 0, 0, 0, 0, mc->mc_dataphys, 0);
1570 
1571     /* do we want a completion callback? */
1572     if (mc->mc_complete != NULL) {
1573 	if ((error = mlx_start(mc)) != 0)
1574 	    return;
1575     } else {
1576 	/* run the command in either polled or wait mode */
1577 	if ((sc->mlx_state & MLX_STATE_INTEN) ? mlx_wait_command(mc) :
1578 						mlx_poll_command(mc))
1579 	    return;
1580 
1581 	/* command completed OK? */
1582 	if (mc->mc_status != 0) {
1583 	    device_printf(sc->mlx_dev, "ENQUIRY failed - %s\n",
1584 			  mlx_diagnose_command(mc));
1585 	    return;
1586 	}
1587     }
1588 }
1589 
1590 /********************************************************************************
1591  * Perform an Enquiry command using a type-3 command buffer and a return a single
1592  * linear result buffer.  If the completion function is specified, it will
1593  * be called with the completed command (and the result response will not be
1594  * valid until that point).  Otherwise, the command will either be busy-waited
1595  * for (interrupts not enabled), or slept for.
1596  */
1597 static void *
1598 mlx_enquire(struct mlx_softc *sc, int command, size_t bufsize, void (* complete)(struct mlx_command *mc))
1599 {
1600     struct mlx_command	*mc;
1601     void		*result;
1602     int			error;
1603 
1604     debug_called(1);
1605     MLX_IO_ASSERT_LOCKED(sc);
1606 
1607     /* get ourselves a command buffer */
1608     error = 1;
1609     result = NULL;
1610     if ((mc = mlx_alloccmd(sc)) == NULL)
1611 	goto out;
1612     /* allocate the response structure */
1613     if ((result = malloc(bufsize, M_DEVBUF, M_NOWAIT)) == NULL)
1614 	goto out;
1615     /* get a command slot */
1616     mc->mc_flags |= MLX_CMD_PRIORITY | MLX_CMD_DATAOUT;
1617     if (mlx_getslot(mc))
1618 	goto out;
1619 
1620     /* map the command so the controller can see it */
1621     mc->mc_data = result;
1622     mc->mc_length = bufsize;
1623     mc->mc_command = command;
1624 
1625     if (complete != NULL) {
1626 	mc->mc_complete = complete;
1627 	mc->mc_private = mc;
1628     }
1629 
1630     error = bus_dmamap_load(sc->mlx_buffer_dmat, mc->mc_dmamap, mc->mc_data,
1631 			    mc->mc_length, mlx_enquire_cb, mc, BUS_DMA_NOWAIT);
1632 
1633  out:
1634     /* we got a command, but nobody else will free it */
1635     if ((mc != NULL) && (mc->mc_complete == NULL))
1636 	mlx_releasecmd(mc);
1637     /* we got an error, and we allocated a result */
1638     if ((error != 0) && (result != NULL)) {
1639 	free(result, M_DEVBUF);
1640 	result = NULL;
1641     }
1642     return(result);
1643 }
1644 
1645 
1646 /********************************************************************************
1647  * Perform a Flush command on the nominated controller.
1648  *
1649  * May be called with interrupts enabled or disabled; will not return until
1650  * the flush operation completes or fails.
1651  */
1652 static int
1653 mlx_flush(struct mlx_softc *sc)
1654 {
1655     struct mlx_command	*mc;
1656     int			error;
1657 
1658     debug_called(1);
1659     MLX_IO_ASSERT_LOCKED(sc);
1660 
1661     /* get ourselves a command buffer */
1662     error = 1;
1663     if ((mc = mlx_alloccmd(sc)) == NULL)
1664 	goto out;
1665     /* get a command slot */
1666     if (mlx_getslot(mc))
1667 	goto out;
1668 
1669     /* build a flush command */
1670     mlx_make_type2(mc, MLX_CMD_FLUSH, 0, 0, 0, 0, 0, 0, 0, 0);
1671 
1672     /* can't assume that interrupts are going to work here, so play it safe */
1673     if (mlx_poll_command(mc))
1674 	goto out;
1675 
1676     /* command completed OK? */
1677     if (mc->mc_status != 0) {
1678 	device_printf(sc->mlx_dev, "FLUSH failed - %s\n", mlx_diagnose_command(mc));
1679 	goto out;
1680     }
1681 
1682     error = 0;			/* success */
1683  out:
1684     if (mc != NULL)
1685 	mlx_releasecmd(mc);
1686     return(error);
1687 }
1688 
1689 /********************************************************************************
1690  * Start a background consistency check on (drive).
1691  *
1692  * May be called with interrupts enabled or disabled; will return as soon as the
1693  * operation has started or been refused.
1694  */
1695 static int
1696 mlx_check(struct mlx_softc *sc, int drive)
1697 {
1698     struct mlx_command	*mc;
1699     int			error;
1700 
1701     debug_called(1);
1702     MLX_IO_ASSERT_LOCKED(sc);
1703 
1704     /* get ourselves a command buffer */
1705     error = 0x10000;
1706     if ((mc = mlx_alloccmd(sc)) == NULL)
1707 	goto out;
1708     /* get a command slot */
1709     if (mlx_getslot(mc))
1710 	goto out;
1711 
1712     /* build a checkasync command, set the "fix it" flag */
1713     mlx_make_type2(mc, MLX_CMD_CHECKASYNC, 0, 0, 0, 0, 0, drive | 0x80, 0, 0);
1714 
1715     /* start the command and wait for it to be returned */
1716     if (mlx_wait_command(mc))
1717 	goto out;
1718 
1719     /* command completed OK? */
1720     if (mc->mc_status != 0) {
1721 	device_printf(sc->mlx_dev, "CHECK ASYNC failed - %s\n", mlx_diagnose_command(mc));
1722     } else {
1723 	device_printf(sc->mlx_sysdrive[drive].ms_disk, "consistency check started");
1724     }
1725     error = mc->mc_status;
1726 
1727  out:
1728     if (mc != NULL)
1729 	mlx_releasecmd(mc);
1730     return(error);
1731 }
1732 
1733 /********************************************************************************
1734  * Start a background rebuild of the physical drive at (channel),(target).
1735  *
1736  * May be called with interrupts enabled or disabled; will return as soon as the
1737  * operation has started or been refused.
1738  */
1739 static int
1740 mlx_rebuild(struct mlx_softc *sc, int channel, int target)
1741 {
1742     struct mlx_command	*mc;
1743     int			error;
1744 
1745     debug_called(1);
1746     MLX_IO_ASSERT_LOCKED(sc);
1747 
1748     /* get ourselves a command buffer */
1749     error = 0x10000;
1750     if ((mc = mlx_alloccmd(sc)) == NULL)
1751 	goto out;
1752     /* get a command slot */
1753     if (mlx_getslot(mc))
1754 	goto out;
1755 
1756     /* build a checkasync command, set the "fix it" flag */
1757     mlx_make_type2(mc, MLX_CMD_REBUILDASYNC, channel, target, 0, 0, 0, 0, 0, 0);
1758 
1759     /* start the command and wait for it to be returned */
1760     if (mlx_wait_command(mc))
1761 	goto out;
1762 
1763     /* command completed OK? */
1764     if (mc->mc_status != 0) {
1765 	device_printf(sc->mlx_dev, "REBUILD ASYNC failed - %s\n", mlx_diagnose_command(mc));
1766     } else {
1767 	device_printf(sc->mlx_dev, "drive rebuild started for %d:%d\n", channel, target);
1768     }
1769     error = mc->mc_status;
1770 
1771  out:
1772     if (mc != NULL)
1773 	mlx_releasecmd(mc);
1774     return(error);
1775 }
1776 
1777 /********************************************************************************
1778  * Run the command (mc) and return when it completes.
1779  *
1780  * Interrupts need to be enabled; returns nonzero on error.
1781  */
1782 static int
1783 mlx_wait_command(struct mlx_command *mc)
1784 {
1785     struct mlx_softc	*sc = mc->mc_sc;
1786     int			error, count;
1787 
1788     debug_called(1);
1789     MLX_IO_ASSERT_LOCKED(sc);
1790 
1791     mc->mc_complete = NULL;
1792     mc->mc_private = mc;		/* wake us when you're done */
1793     if ((error = mlx_start(mc)) != 0)
1794 	return(error);
1795 
1796     count = 0;
1797     /* XXX better timeout? */
1798     while ((mc->mc_status == MLX_STATUS_BUSY) && (count < 30)) {
1799 	mtx_sleep(mc->mc_private, &sc->mlx_io_lock, PRIBIO | PCATCH, "mlxwcmd", hz);
1800     }
1801 
1802     if (mc->mc_status != 0) {
1803 	device_printf(sc->mlx_dev, "command failed - %s\n", mlx_diagnose_command(mc));
1804 	return(EIO);
1805     }
1806     return(0);
1807 }
1808 
1809 
1810 /********************************************************************************
1811  * Start the command (mc) and busy-wait for it to complete.
1812  *
1813  * Should only be used when interrupts can't be relied upon. Returns 0 on
1814  * success, nonzero on error.
1815  * Successfully completed commands are dequeued.
1816  */
1817 static int
1818 mlx_poll_command(struct mlx_command *mc)
1819 {
1820     struct mlx_softc	*sc = mc->mc_sc;
1821     int			error, count;
1822 
1823     debug_called(1);
1824     MLX_IO_ASSERT_LOCKED(sc);
1825 
1826     mc->mc_complete = NULL;
1827     mc->mc_private = NULL;	/* we will poll for it */
1828     if ((error = mlx_start(mc)) != 0)
1829 	return(error);
1830 
1831     count = 0;
1832     do {
1833 	/* poll for completion */
1834 	mlx_done(mc->mc_sc, 1);
1835 
1836     } while ((mc->mc_status == MLX_STATUS_BUSY) && (count++ < 15000000));
1837     if (mc->mc_status != MLX_STATUS_BUSY) {
1838 	TAILQ_REMOVE(&sc->mlx_work, mc, mc_link);
1839 	return(0);
1840     }
1841     device_printf(sc->mlx_dev, "command failed - %s\n", mlx_diagnose_command(mc));
1842     return(EIO);
1843 }
1844 
1845 void
1846 mlx_startio_cb(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
1847 {
1848     struct mlx_command	*mc;
1849     struct mlxd_softc	*mlxd;
1850     struct mlx_softc	*sc;
1851     struct bio		*bp;
1852     int			blkcount;
1853     int			driveno;
1854     int			cmd;
1855 
1856     mc = (struct mlx_command *)arg;
1857     mlx_setup_dmamap(mc, segs, nsegments, error);
1858 
1859     sc = mc->mc_sc;
1860     bp = mc->mc_private;
1861 
1862     if (bp->bio_cmd == BIO_READ) {
1863 	mc->mc_flags |= MLX_CMD_DATAIN;
1864 	cmd = MLX_CMD_READSG;
1865     } else {
1866 	mc->mc_flags |= MLX_CMD_DATAOUT;
1867 	cmd = MLX_CMD_WRITESG;
1868     }
1869 
1870     /* build a suitable I/O command (assumes 512-byte rounded transfers) */
1871     mlxd = bp->bio_disk->d_drv1;
1872     driveno = mlxd->mlxd_drive - sc->mlx_sysdrive;
1873     blkcount = howmany(bp->bio_bcount, MLX_BLKSIZE);
1874 
1875     if ((bp->bio_pblkno + blkcount) > sc->mlx_sysdrive[driveno].ms_size)
1876 	device_printf(sc->mlx_dev,
1877 		      "I/O beyond end of unit (%lld,%d > %lu)\n",
1878 		      (long long)bp->bio_pblkno, blkcount,
1879 		      (u_long)sc->mlx_sysdrive[driveno].ms_size);
1880 
1881     /*
1882      * Build the I/O command.  Note that the SG list type bits are set to zero,
1883      * denoting the format of SG list that we are using.
1884      */
1885     if (sc->mlx_iftype == MLX_IFTYPE_2) {
1886 	mlx_make_type1(mc, (cmd == MLX_CMD_WRITESG) ? MLX_CMD_WRITESG_OLD :
1887 						      MLX_CMD_READSG_OLD,
1888 		       blkcount & 0xff, 	/* xfer length low byte */
1889 		       bp->bio_pblkno,		/* physical block number */
1890 		       driveno,			/* target drive number */
1891 		       mc->mc_sgphys,		/* location of SG list */
1892 		       mc->mc_nsgent & 0x3f);	/* size of SG list */
1893 	} else {
1894 	mlx_make_type5(mc, cmd,
1895 		       blkcount & 0xff, 	/* xfer length low byte */
1896 		       (driveno << 3) | ((blkcount >> 8) & 0x07),
1897 						/* target+length high 3 bits */
1898 		       bp->bio_pblkno,		/* physical block number */
1899 		       mc->mc_sgphys,		/* location of SG list */
1900 		       mc->mc_nsgent & 0x3f);	/* size of SG list */
1901     }
1902 
1903     /* try to give command to controller */
1904     if (mlx_start(mc) != 0) {
1905 	/* fail the command */
1906 	mc->mc_status = MLX_STATUS_WEDGED;
1907 	mlx_completeio(mc);
1908     }
1909 
1910     sc->mlx_state &= ~MLX_STATE_QFROZEN;
1911 }
1912 
1913 /********************************************************************************
1914  * Pull as much work off the softc's work queue as possible and give it to the
1915  * controller.  Leave a couple of slots free for emergencies.
1916  */
1917 static void
1918 mlx_startio(struct mlx_softc *sc)
1919 {
1920     struct mlx_command	*mc;
1921     struct bio		*bp;
1922     int			error;
1923 
1924     MLX_IO_ASSERT_LOCKED(sc);
1925 
1926     /* spin until something prevents us from doing any work */
1927     for (;;) {
1928 	if (sc->mlx_state & MLX_STATE_QFROZEN)
1929 	    break;
1930 
1931 	/* see if there's work to be done */
1932 	if ((bp = bioq_first(&sc->mlx_bioq)) == NULL)
1933 	    break;
1934 	/* get a command */
1935 	if ((mc = mlx_alloccmd(sc)) == NULL)
1936 	    break;
1937 	/* get a slot for the command */
1938 	if (mlx_getslot(mc) != 0) {
1939 	    mlx_releasecmd(mc);
1940 	    break;
1941 	}
1942 	/* get the buf containing our work */
1943 	bioq_remove(&sc->mlx_bioq, bp);
1944 	sc->mlx_waitbufs--;
1945 
1946 	/* connect the buf to the command */
1947 	mc->mc_complete = mlx_completeio;
1948 	mc->mc_private = bp;
1949 	mc->mc_data = bp->bio_data;
1950 	mc->mc_length = bp->bio_bcount;
1951 
1952 	/* map the command so the controller can work with it */
1953 	error = bus_dmamap_load(sc->mlx_buffer_dmat, mc->mc_dmamap, mc->mc_data,
1954 				mc->mc_length, mlx_startio_cb, mc, 0);
1955 	if (error == EINPROGRESS) {
1956 	    sc->mlx_state |= MLX_STATE_QFROZEN;
1957 	    break;
1958 	}
1959     }
1960 }
1961 
1962 /********************************************************************************
1963  * Handle completion of an I/O command.
1964  */
1965 static void
1966 mlx_completeio(struct mlx_command *mc)
1967 {
1968     struct mlx_softc	*sc = mc->mc_sc;
1969     struct bio		*bp = mc->mc_private;
1970     struct mlxd_softc	*mlxd = bp->bio_disk->d_drv1;
1971 
1972     MLX_IO_ASSERT_LOCKED(sc);
1973     if (mc->mc_status != MLX_STATUS_OK) {	/* could be more verbose here? */
1974 	bp->bio_error = EIO;
1975 	bp->bio_flags |= BIO_ERROR;
1976 
1977 	switch(mc->mc_status) {
1978 	case MLX_STATUS_RDWROFFLINE:		/* system drive has gone offline */
1979 	    device_printf(mlxd->mlxd_dev, "drive offline\n");
1980 	    /* should signal this with a return code */
1981 	    mlxd->mlxd_drive->ms_state = MLX_SYSD_OFFLINE;
1982 	    break;
1983 
1984 	default:				/* other I/O error */
1985 	    device_printf(sc->mlx_dev, "I/O error - %s\n", mlx_diagnose_command(mc));
1986 #if 0
1987 	    device_printf(sc->mlx_dev, "  b_bcount %ld  blkcount %ld  b_pblkno %d\n",
1988 			  bp->bio_bcount, bp->bio_bcount / MLX_BLKSIZE, bp->bio_pblkno);
1989 	    device_printf(sc->mlx_dev, "  %13D\n", mc->mc_mailbox, " ");
1990 #endif
1991 	    break;
1992 	}
1993     }
1994     mlx_releasecmd(mc);
1995     mlxd_intr(bp);
1996 }
1997 
1998 void
1999 mlx_user_cb(void *arg, bus_dma_segment_t *segs, int nsegments, int error)
2000 {
2001     struct mlx_usercommand *mu;
2002     struct mlx_command *mc;
2003     struct mlx_dcdb	*dcdb;
2004 
2005     mc = (struct mlx_command *)arg;
2006     if (error)
2007 	return;
2008 
2009     mlx_setup_dmamap(mc, segs, nsegments, error);
2010 
2011     mu = (struct mlx_usercommand *)mc->mc_private;
2012     dcdb = NULL;
2013 
2014     /*
2015      * If this is a passthrough SCSI command, the DCDB is packed at the
2016      * beginning of the data area.  Fix up the DCDB to point to the correct
2017      * physical address and override any bufptr supplied by the caller since
2018      * we know what it's meant to be.
2019      */
2020     if (mc->mc_mailbox[0] == MLX_CMD_DIRECT_CDB) {
2021 	dcdb = (struct mlx_dcdb *)mc->mc_data;
2022 	dcdb->dcdb_physaddr = mc->mc_dataphys + sizeof(*dcdb);
2023 	mu->mu_bufptr = 8;
2024     }
2025 
2026     /*
2027      * If there's a data buffer, fix up the command's buffer pointer.
2028      */
2029     if (mu->mu_datasize > 0) {
2030 	mc->mc_mailbox[mu->mu_bufptr    ] =  mc->mc_dataphys        & 0xff;
2031 	mc->mc_mailbox[mu->mu_bufptr + 1] = (mc->mc_dataphys >> 8)  & 0xff;
2032 	mc->mc_mailbox[mu->mu_bufptr + 2] = (mc->mc_dataphys >> 16) & 0xff;
2033 	mc->mc_mailbox[mu->mu_bufptr + 3] = (mc->mc_dataphys >> 24) & 0xff;
2034     }
2035     debug(0, "command fixup");
2036 
2037     /* submit the command and wait */
2038     if (mlx_wait_command(mc) != 0)
2039 	return;
2040 
2041 }
2042 
2043 /********************************************************************************
2044  * Take a command from user-space and try to run it.
2045  *
2046  * XXX Note that this can't perform very much in the way of error checking, and
2047  *     as such, applications _must_ be considered trustworthy.
2048  * XXX Commands using S/G for data are not supported.
2049  */
2050 static int
2051 mlx_user_command(struct mlx_softc *sc, struct mlx_usercommand *mu)
2052 {
2053     struct mlx_command	*mc;
2054     void		*kbuf;
2055     int			error;
2056 
2057     debug_called(0);
2058 
2059     kbuf = NULL;
2060     mc = NULL;
2061     error = ENOMEM;
2062 
2063     /* get ourselves a command and copy in from user space */
2064     MLX_IO_LOCK(sc);
2065     if ((mc = mlx_alloccmd(sc)) == NULL) {
2066 	MLX_IO_UNLOCK(sc);
2067 	return(error);
2068     }
2069     bcopy(mu->mu_command, mc->mc_mailbox, sizeof(mc->mc_mailbox));
2070     debug(0, "got command buffer");
2071 
2072     /*
2073      * if we need a buffer for data transfer, allocate one and copy in its
2074      * initial contents
2075      */
2076     if (mu->mu_datasize > 0) {
2077 	if (mu->mu_datasize > MLX_MAXPHYS) {
2078 	    error = EINVAL;
2079 	    goto out;
2080 	}
2081 	MLX_IO_UNLOCK(sc);
2082 	if (((kbuf = malloc(mu->mu_datasize, M_DEVBUF, M_WAITOK)) == NULL) ||
2083 	    (error = copyin(mu->mu_buf, kbuf, mu->mu_datasize))) {
2084 	    MLX_IO_LOCK(sc);
2085 	    goto out;
2086 	}
2087 	MLX_IO_LOCK(sc);
2088 	debug(0, "got kernel buffer");
2089     }
2090 
2091     /* get a command slot */
2092     if (mlx_getslot(mc))
2093 	goto out;
2094     debug(0, "got a slot");
2095 
2096     if (mu->mu_datasize > 0) {
2097 
2098 	/* range check the pointer to physical buffer address */
2099 	if ((mu->mu_bufptr < 0) || (mu->mu_bufptr > (sizeof(mu->mu_command) -
2100 						     sizeof(u_int32_t)))) {
2101 	    error = EINVAL;
2102 	    goto out;
2103 	}
2104     }
2105 
2106     /* map the command so the controller can see it */
2107     mc->mc_data = kbuf;
2108     mc->mc_length = mu->mu_datasize;
2109     mc->mc_private = mu;
2110     error = bus_dmamap_load(sc->mlx_buffer_dmat, mc->mc_dmamap, mc->mc_data,
2111 			    mc->mc_length, mlx_user_cb, mc, BUS_DMA_NOWAIT);
2112     if (error)
2113 	goto out;
2114 
2115     /* copy out status and data */
2116     mu->mu_status = mc->mc_status;
2117     if (mu->mu_datasize > 0) {
2118 	MLX_IO_UNLOCK(sc);
2119 	error = copyout(kbuf, mu->mu_buf, mu->mu_datasize);
2120 	MLX_IO_LOCK(sc);
2121     }
2122 
2123  out:
2124     mlx_releasecmd(mc);
2125     MLX_IO_UNLOCK(sc);
2126     if (kbuf != NULL)
2127 	free(kbuf, M_DEVBUF);
2128     return(error);
2129 }
2130 
2131 /********************************************************************************
2132  ********************************************************************************
2133                                                         Command I/O to Controller
2134  ********************************************************************************
2135  ********************************************************************************/
2136 
2137 /********************************************************************************
2138  * Find a free command slot for (mc).
2139  *
2140  * Don't hand out a slot to a normal-priority command unless there are at least
2141  * 4 slots free for priority commands.
2142  */
2143 static int
2144 mlx_getslot(struct mlx_command *mc)
2145 {
2146     struct mlx_softc	*sc = mc->mc_sc;
2147     int			slot, limit;
2148 
2149     debug_called(1);
2150 
2151     MLX_IO_ASSERT_LOCKED(sc);
2152 
2153     /*
2154      * Enforce slot-usage limit, if we have the required information.
2155      */
2156     if (sc->mlx_enq2 != NULL) {
2157 	limit = sc->mlx_enq2->me_max_commands;
2158     } else {
2159 	limit = 2;
2160     }
2161     if (sc->mlx_busycmds >= ((mc->mc_flags & MLX_CMD_PRIORITY) ? limit : limit - 4))
2162 	return(EBUSY);
2163 
2164     /*
2165      * Allocate an outstanding command slot
2166      *
2167      * XXX linear search is slow
2168      */
2169     for (slot = 0; slot < limit; slot++) {
2170 	debug(2, "try slot %d", slot);
2171 	if (sc->mlx_busycmd[slot] == NULL)
2172 	    break;
2173     }
2174     if (slot < limit) {
2175 	sc->mlx_busycmd[slot] = mc;
2176 	sc->mlx_busycmds++;
2177     }
2178 
2179     /* out of slots? */
2180     if (slot >= limit)
2181 	return(EBUSY);
2182 
2183     debug(2, "got slot %d", slot);
2184     mc->mc_slot = slot;
2185     return(0);
2186 }
2187 
2188 /********************************************************************************
2189  * Map/unmap (mc)'s data in the controller's addressable space.
2190  */
2191 static void
2192 mlx_setup_dmamap(struct mlx_command *mc, bus_dma_segment_t *segs, int nsegments,
2193 		 int error)
2194 {
2195     struct mlx_softc	*sc = mc->mc_sc;
2196     struct mlx_sgentry	*sg;
2197     int			i;
2198 
2199     debug_called(1);
2200 
2201     /* XXX should be unnecessary */
2202     if (sc->mlx_enq2 && (nsegments > sc->mlx_enq2->me_max_sg))
2203 	panic("MLX: too many s/g segments (%d, max %d)", nsegments,
2204 	      sc->mlx_enq2->me_max_sg);
2205 
2206     /* get base address of s/g table */
2207     sg = sc->mlx_sgtable + (mc->mc_slot * MLX_NSEG);
2208 
2209     /* save s/g table information in command */
2210     mc->mc_nsgent = nsegments;
2211     mc->mc_sgphys = sc->mlx_sgbusaddr +
2212 		   (mc->mc_slot * MLX_NSEG * sizeof(struct mlx_sgentry));
2213     mc->mc_dataphys = segs[0].ds_addr;
2214 
2215     /* populate s/g table */
2216     for (i = 0; i < nsegments; i++, sg++) {
2217 	sg->sg_addr = segs[i].ds_addr;
2218 	sg->sg_count = segs[i].ds_len;
2219     }
2220 
2221     /* Make sure the buffers are visible on the bus. */
2222     if (mc->mc_flags & MLX_CMD_DATAIN)
2223 	bus_dmamap_sync(sc->mlx_buffer_dmat, mc->mc_dmamap,
2224 			BUS_DMASYNC_PREREAD);
2225     if (mc->mc_flags & MLX_CMD_DATAOUT)
2226 	bus_dmamap_sync(sc->mlx_buffer_dmat, mc->mc_dmamap,
2227 			BUS_DMASYNC_PREWRITE);
2228 }
2229 
2230 static void
2231 mlx_unmapcmd(struct mlx_command *mc)
2232 {
2233     struct mlx_softc	*sc = mc->mc_sc;
2234 
2235     debug_called(1);
2236 
2237     /* if the command involved data at all */
2238     if (mc->mc_data != NULL) {
2239 
2240 	if (mc->mc_flags & MLX_CMD_DATAIN)
2241 	    bus_dmamap_sync(sc->mlx_buffer_dmat, mc->mc_dmamap, BUS_DMASYNC_POSTREAD);
2242 	if (mc->mc_flags & MLX_CMD_DATAOUT)
2243 	    bus_dmamap_sync(sc->mlx_buffer_dmat, mc->mc_dmamap, BUS_DMASYNC_POSTWRITE);
2244 
2245 	bus_dmamap_unload(sc->mlx_buffer_dmat, mc->mc_dmamap);
2246     }
2247 }
2248 
2249 /********************************************************************************
2250  * Try to deliver (mc) to the controller.
2251  *
2252  * Can be called at any interrupt level, with or without interrupts enabled.
2253  */
2254 static int
2255 mlx_start(struct mlx_command *mc)
2256 {
2257     struct mlx_softc	*sc = mc->mc_sc;
2258     int			i;
2259 
2260     debug_called(1);
2261 
2262     /* save the slot number as ident so we can handle this command when complete */
2263     mc->mc_mailbox[0x1] = mc->mc_slot;
2264 
2265     /* mark the command as currently being processed */
2266     mc->mc_status = MLX_STATUS_BUSY;
2267 
2268     /* set a default 60-second timeout  XXX tunable?  XXX not currently used */
2269     mc->mc_timeout = time_second + 60;
2270 
2271     /* spin waiting for the mailbox */
2272     for (i = 100000; i > 0; i--) {
2273 	if (sc->mlx_tryqueue(sc, mc)) {
2274 	    /* move command to work queue */
2275 	    TAILQ_INSERT_TAIL(&sc->mlx_work, mc, mc_link);
2276 	    return (0);
2277 	} else if (i > 1)
2278 	    mlx_done(sc, 0);
2279     }
2280 
2281     /*
2282      * We couldn't get the controller to take the command.  Revoke the slot
2283      * that the command was given and return it with a bad status.
2284      */
2285     sc->mlx_busycmd[mc->mc_slot] = NULL;
2286     device_printf(sc->mlx_dev, "controller wedged (not taking commands)\n");
2287     mc->mc_status = MLX_STATUS_WEDGED;
2288     mlx_complete(sc);
2289     return(EIO);
2290 }
2291 
2292 /********************************************************************************
2293  * Poll the controller (sc) for completed commands.
2294  * Update command status and free slots for reuse.  If any slots were freed,
2295  * new commands may be posted.
2296  *
2297  * Returns nonzero if one or more commands were completed.
2298  */
2299 static int
2300 mlx_done(struct mlx_softc *sc, int startio)
2301 {
2302     struct mlx_command	*mc;
2303     int			result;
2304     u_int8_t		slot;
2305     u_int16_t		status;
2306 
2307     debug_called(2);
2308     MLX_IO_ASSERT_LOCKED(sc);
2309 
2310     result = 0;
2311 
2312     /* loop collecting completed commands */
2313     for (;;) {
2314 	/* poll for a completed command's identifier and status */
2315 	if (sc->mlx_findcomplete(sc, &slot, &status)) {
2316 	    result = 1;
2317 	    mc = sc->mlx_busycmd[slot];			/* find command */
2318 	    if (mc != NULL) {				/* paranoia */
2319 		if (mc->mc_status == MLX_STATUS_BUSY) {
2320 		    mc->mc_status = status;		/* save status */
2321 
2322 		    /* free slot for reuse */
2323 		    sc->mlx_busycmd[slot] = NULL;
2324 		    sc->mlx_busycmds--;
2325 		} else {
2326 		    device_printf(sc->mlx_dev, "duplicate done event for slot %d\n", slot);
2327 		}
2328 	    } else {
2329 		device_printf(sc->mlx_dev, "done event for nonbusy slot %d\n", slot);
2330 	    }
2331 	} else {
2332 	    break;
2333 	}
2334     }
2335 
2336     /* if we've completed any commands, try posting some more */
2337     if (result && startio)
2338 	mlx_startio(sc);
2339 
2340     /* handle completion and timeouts */
2341     mlx_complete(sc);
2342 
2343     return(result);
2344 }
2345 
2346 /********************************************************************************
2347  * Perform post-completion processing for commands on (sc).
2348  */
2349 static void
2350 mlx_complete(struct mlx_softc *sc)
2351 {
2352     struct mlx_command	*mc, *nc;
2353 
2354     debug_called(2);
2355     MLX_IO_ASSERT_LOCKED(sc);
2356 
2357     /* scan the list of busy/done commands */
2358     mc = TAILQ_FIRST(&sc->mlx_work);
2359     while (mc != NULL) {
2360 	nc = TAILQ_NEXT(mc, mc_link);
2361 
2362 	/* Command has been completed in some fashion */
2363 	if (mc->mc_status != MLX_STATUS_BUSY) {
2364 
2365 	    /* unmap the command's data buffer */
2366 	    mlx_unmapcmd(mc);
2367 	    /*
2368 	     * Does the command have a completion handler?
2369 	     */
2370 	    if (mc->mc_complete != NULL) {
2371 		/* remove from list and give to handler */
2372 		TAILQ_REMOVE(&sc->mlx_work, mc, mc_link);
2373 		mc->mc_complete(mc);
2374 
2375 		/*
2376 		 * Is there a sleeper waiting on this command?
2377 		 */
2378 	    } else if (mc->mc_private != NULL) {	/* sleeping caller wants to know about it */
2379 
2380 		/* remove from list and wake up sleeper */
2381 		TAILQ_REMOVE(&sc->mlx_work, mc, mc_link);
2382 		wakeup_one(mc->mc_private);
2383 
2384 		/*
2385 		 * Leave the command for a caller that's polling for it.
2386 		 */
2387 	    } else {
2388 	    }
2389 	}
2390 	mc = nc;
2391     }
2392 }
2393 
2394 /********************************************************************************
2395  ********************************************************************************
2396                                                         Command Buffer Management
2397  ********************************************************************************
2398  ********************************************************************************/
2399 
2400 /********************************************************************************
2401  * Get a new command buffer.
2402  *
2403  * This may return NULL in low-memory cases.
2404  *
2405  * Note that using malloc() is expensive (the command buffer is << 1 page) but
2406  * necessary if we are to be a loadable module before the zone allocator is fixed.
2407  *
2408  * If possible, we recycle a command buffer that's been used before.
2409  *
2410  * XXX Note that command buffers are not cleaned out - it is the caller's
2411  *     responsibility to ensure that all required fields are filled in before
2412  *     using a buffer.
2413  */
2414 static struct mlx_command *
2415 mlx_alloccmd(struct mlx_softc *sc)
2416 {
2417     struct mlx_command	*mc;
2418     int			error;
2419 
2420     debug_called(1);
2421 
2422     MLX_IO_ASSERT_LOCKED(sc);
2423     if ((mc = TAILQ_FIRST(&sc->mlx_freecmds)) != NULL)
2424 	TAILQ_REMOVE(&sc->mlx_freecmds, mc, mc_link);
2425 
2426     /* allocate a new command buffer? */
2427     if (mc == NULL) {
2428 	mc = (struct mlx_command *)malloc(sizeof(*mc), M_DEVBUF, M_NOWAIT | M_ZERO);
2429 	if (mc != NULL) {
2430 	    mc->mc_sc = sc;
2431 	    error = bus_dmamap_create(sc->mlx_buffer_dmat, 0, &mc->mc_dmamap);
2432 	    if (error) {
2433 		free(mc, M_DEVBUF);
2434 		return(NULL);
2435 	    }
2436 	}
2437     }
2438     return(mc);
2439 }
2440 
2441 /********************************************************************************
2442  * Release a command buffer for recycling.
2443  *
2444  * XXX It might be a good idea to limit the number of commands we save for reuse
2445  *     if it's shown that this list bloats out massively.
2446  */
2447 static void
2448 mlx_releasecmd(struct mlx_command *mc)
2449 {
2450 
2451     debug_called(1);
2452 
2453     MLX_IO_ASSERT_LOCKED(mc->mc_sc);
2454     TAILQ_INSERT_HEAD(&mc->mc_sc->mlx_freecmds, mc, mc_link);
2455 }
2456 
2457 /********************************************************************************
2458  * Permanently discard a command buffer.
2459  */
2460 static void
2461 mlx_freecmd(struct mlx_command *mc)
2462 {
2463     struct mlx_softc	*sc = mc->mc_sc;
2464 
2465     debug_called(1);
2466     bus_dmamap_destroy(sc->mlx_buffer_dmat, mc->mc_dmamap);
2467     free(mc, M_DEVBUF);
2468 }
2469 
2470 
2471 /********************************************************************************
2472  ********************************************************************************
2473                                                 Type 3 interface accessor methods
2474  ********************************************************************************
2475  ********************************************************************************/
2476 
2477 /********************************************************************************
2478  * Try to give (mc) to the controller.  Returns 1 if successful, 0 on failure
2479  * (the controller is not ready to take a command).
2480  */
2481 static int
2482 mlx_v3_tryqueue(struct mlx_softc *sc, struct mlx_command *mc)
2483 {
2484     int		i;
2485 
2486     debug_called(2);
2487     MLX_IO_ASSERT_LOCKED(sc);
2488 
2489     /* ready for our command? */
2490     if (!(MLX_V3_GET_IDBR(sc) & MLX_V3_IDB_FULL)) {
2491 	/* copy mailbox data to window */
2492 	for (i = 0; i < 13; i++)
2493 	    MLX_V3_PUT_MAILBOX(sc, i, mc->mc_mailbox[i]);
2494 
2495 	/* post command */
2496 	MLX_V3_PUT_IDBR(sc, MLX_V3_IDB_FULL);
2497 	return(1);
2498     }
2499     return(0);
2500 }
2501 
2502 /********************************************************************************
2503  * See if a command has been completed, if so acknowledge its completion
2504  * and recover the slot number and status code.
2505  */
2506 static int
2507 mlx_v3_findcomplete(struct mlx_softc *sc, u_int8_t *slot, u_int16_t *status)
2508 {
2509 
2510     debug_called(2);
2511     MLX_IO_ASSERT_LOCKED(sc);
2512 
2513     /* status available? */
2514     if (MLX_V3_GET_ODBR(sc) & MLX_V3_ODB_SAVAIL) {
2515 	*slot = MLX_V3_GET_STATUS_IDENT(sc);		/* get command identifier */
2516 	*status = MLX_V3_GET_STATUS(sc);		/* get status */
2517 
2518 	/* acknowledge completion */
2519 	MLX_V3_PUT_ODBR(sc, MLX_V3_ODB_SAVAIL);
2520 	MLX_V3_PUT_IDBR(sc, MLX_V3_IDB_SACK);
2521 	return(1);
2522     }
2523     return(0);
2524 }
2525 
2526 /********************************************************************************
2527  * Enable/disable interrupts as requested. (No acknowledge required)
2528  */
2529 static void
2530 mlx_v3_intaction(struct mlx_softc *sc, int action)
2531 {
2532     debug_called(1);
2533     MLX_IO_ASSERT_LOCKED(sc);
2534 
2535     switch(action) {
2536     case MLX_INTACTION_DISABLE:
2537 	MLX_V3_PUT_IER(sc, 0);
2538 	sc->mlx_state &= ~MLX_STATE_INTEN;
2539 	break;
2540     case MLX_INTACTION_ENABLE:
2541 	MLX_V3_PUT_IER(sc, 1);
2542 	sc->mlx_state |= MLX_STATE_INTEN;
2543 	break;
2544     }
2545 }
2546 
2547 /********************************************************************************
2548  * Poll for firmware error codes during controller initialisation.
2549  * Returns 0 if initialisation is complete, 1 if still in progress but no
2550  * error has been fetched, 2 if an error has been retrieved.
2551  */
2552 static int
2553 mlx_v3_fw_handshake(struct mlx_softc *sc, int *error, int *param1, int *param2,
2554     int first)
2555 {
2556     u_int8_t	fwerror;
2557 
2558     debug_called(2);
2559 
2560     /* first time around, clear any hardware completion status */
2561     if (first) {
2562 	MLX_V3_PUT_IDBR(sc, MLX_V3_IDB_SACK);
2563 	DELAY(1000);
2564     }
2565 
2566     /* init in progress? */
2567     if (!(MLX_V3_GET_IDBR(sc) & MLX_V3_IDB_INIT_BUSY))
2568 	return(0);
2569 
2570     /* test error value */
2571     fwerror = MLX_V3_GET_FWERROR(sc);
2572     if (!(fwerror & MLX_V3_FWERROR_PEND))
2573 	return(1);
2574 
2575     /* mask status pending bit, fetch status */
2576     *error = fwerror & ~MLX_V3_FWERROR_PEND;
2577     *param1 = MLX_V3_GET_FWERROR_PARAM1(sc);
2578     *param2 = MLX_V3_GET_FWERROR_PARAM2(sc);
2579 
2580     /* acknowledge */
2581     MLX_V3_PUT_FWERROR(sc, 0);
2582 
2583     return(2);
2584 }
2585 
2586 /********************************************************************************
2587  ********************************************************************************
2588                                                 Type 4 interface accessor methods
2589  ********************************************************************************
2590  ********************************************************************************/
2591 
2592 /********************************************************************************
2593  * Try to give (mc) to the controller.  Returns 1 if successful, 0 on failure
2594  * (the controller is not ready to take a command).
2595  */
2596 static int
2597 mlx_v4_tryqueue(struct mlx_softc *sc, struct mlx_command *mc)
2598 {
2599     int		i;
2600 
2601     debug_called(2);
2602     MLX_IO_ASSERT_LOCKED(sc);
2603 
2604     /* ready for our command? */
2605     if (!(MLX_V4_GET_IDBR(sc) & MLX_V4_IDB_FULL)) {
2606 	/* copy mailbox data to window */
2607 	for (i = 0; i < 13; i++)
2608 	    MLX_V4_PUT_MAILBOX(sc, i, mc->mc_mailbox[i]);
2609 
2610 	/* memory-mapped controller, so issue a write barrier to ensure the mailbox is filled */
2611 	bus_barrier(sc->mlx_mem, MLX_V4_MAILBOX, MLX_V4_MAILBOX_LENGTH,
2612 			  BUS_SPACE_BARRIER_WRITE);
2613 
2614 	/* post command */
2615 	MLX_V4_PUT_IDBR(sc, MLX_V4_IDB_HWMBOX_CMD);
2616 	return(1);
2617     }
2618     return(0);
2619 }
2620 
2621 /********************************************************************************
2622  * See if a command has been completed, if so acknowledge its completion
2623  * and recover the slot number and status code.
2624  */
2625 static int
2626 mlx_v4_findcomplete(struct mlx_softc *sc, u_int8_t *slot, u_int16_t *status)
2627 {
2628 
2629     debug_called(2);
2630     MLX_IO_ASSERT_LOCKED(sc);
2631 
2632     /* status available? */
2633     if (MLX_V4_GET_ODBR(sc) & MLX_V4_ODB_HWSAVAIL) {
2634 	*slot = MLX_V4_GET_STATUS_IDENT(sc);		/* get command identifier */
2635 	*status = MLX_V4_GET_STATUS(sc);		/* get status */
2636 
2637 	/* acknowledge completion */
2638 	MLX_V4_PUT_ODBR(sc, MLX_V4_ODB_HWMBOX_ACK);
2639 	MLX_V4_PUT_IDBR(sc, MLX_V4_IDB_SACK);
2640 	return(1);
2641     }
2642     return(0);
2643 }
2644 
2645 /********************************************************************************
2646  * Enable/disable interrupts as requested.
2647  */
2648 static void
2649 mlx_v4_intaction(struct mlx_softc *sc, int action)
2650 {
2651     debug_called(1);
2652     MLX_IO_ASSERT_LOCKED(sc);
2653 
2654     switch(action) {
2655     case MLX_INTACTION_DISABLE:
2656 	MLX_V4_PUT_IER(sc, MLX_V4_IER_MASK | MLX_V4_IER_DISINT);
2657 	sc->mlx_state &= ~MLX_STATE_INTEN;
2658 	break;
2659     case MLX_INTACTION_ENABLE:
2660 	MLX_V4_PUT_IER(sc, MLX_V4_IER_MASK & ~MLX_V4_IER_DISINT);
2661 	sc->mlx_state |= MLX_STATE_INTEN;
2662 	break;
2663     }
2664 }
2665 
2666 /********************************************************************************
2667  * Poll for firmware error codes during controller initialisation.
2668  * Returns 0 if initialisation is complete, 1 if still in progress but no
2669  * error has been fetched, 2 if an error has been retrieved.
2670  */
2671 static int
2672 mlx_v4_fw_handshake(struct mlx_softc *sc, int *error, int *param1, int *param2,
2673     int first)
2674 {
2675     u_int8_t	fwerror;
2676 
2677     debug_called(2);
2678 
2679     /* first time around, clear any hardware completion status */
2680     if (first) {
2681 	MLX_V4_PUT_IDBR(sc, MLX_V4_IDB_SACK);
2682 	DELAY(1000);
2683     }
2684 
2685     /* init in progress? */
2686     if (!(MLX_V4_GET_IDBR(sc) & MLX_V4_IDB_INIT_BUSY))
2687 	return(0);
2688 
2689     /* test error value */
2690     fwerror = MLX_V4_GET_FWERROR(sc);
2691     if (!(fwerror & MLX_V4_FWERROR_PEND))
2692 	return(1);
2693 
2694     /* mask status pending bit, fetch status */
2695     *error = fwerror & ~MLX_V4_FWERROR_PEND;
2696     *param1 = MLX_V4_GET_FWERROR_PARAM1(sc);
2697     *param2 = MLX_V4_GET_FWERROR_PARAM2(sc);
2698 
2699     /* acknowledge */
2700     MLX_V4_PUT_FWERROR(sc, 0);
2701 
2702     return(2);
2703 }
2704 
2705 /********************************************************************************
2706  ********************************************************************************
2707                                                 Type 5 interface accessor methods
2708  ********************************************************************************
2709  ********************************************************************************/
2710 
2711 /********************************************************************************
2712  * Try to give (mc) to the controller.  Returns 1 if successful, 0 on failure
2713  * (the controller is not ready to take a command).
2714  */
2715 static int
2716 mlx_v5_tryqueue(struct mlx_softc *sc, struct mlx_command *mc)
2717 {
2718     int		i;
2719 
2720     debug_called(2);
2721     MLX_IO_ASSERT_LOCKED(sc);
2722 
2723     /* ready for our command? */
2724     if (MLX_V5_GET_IDBR(sc) & MLX_V5_IDB_EMPTY) {
2725 	/* copy mailbox data to window */
2726 	for (i = 0; i < 13; i++)
2727 	    MLX_V5_PUT_MAILBOX(sc, i, mc->mc_mailbox[i]);
2728 
2729 	/* post command */
2730 	MLX_V5_PUT_IDBR(sc, MLX_V5_IDB_HWMBOX_CMD);
2731 	return(1);
2732     }
2733     return(0);
2734 }
2735 
2736 /********************************************************************************
2737  * See if a command has been completed, if so acknowledge its completion
2738  * and recover the slot number and status code.
2739  */
2740 static int
2741 mlx_v5_findcomplete(struct mlx_softc *sc, u_int8_t *slot, u_int16_t *status)
2742 {
2743 
2744     debug_called(2);
2745     MLX_IO_ASSERT_LOCKED(sc);
2746 
2747     /* status available? */
2748     if (MLX_V5_GET_ODBR(sc) & MLX_V5_ODB_HWSAVAIL) {
2749 	*slot = MLX_V5_GET_STATUS_IDENT(sc);		/* get command identifier */
2750 	*status = MLX_V5_GET_STATUS(sc);		/* get status */
2751 
2752 	/* acknowledge completion */
2753 	MLX_V5_PUT_ODBR(sc, MLX_V5_ODB_HWMBOX_ACK);
2754 	MLX_V5_PUT_IDBR(sc, MLX_V5_IDB_SACK);
2755 	return(1);
2756     }
2757     return(0);
2758 }
2759 
2760 /********************************************************************************
2761  * Enable/disable interrupts as requested.
2762  */
2763 static void
2764 mlx_v5_intaction(struct mlx_softc *sc, int action)
2765 {
2766     debug_called(1);
2767     MLX_IO_ASSERT_LOCKED(sc);
2768 
2769     switch(action) {
2770     case MLX_INTACTION_DISABLE:
2771 	MLX_V5_PUT_IER(sc, 0xff & MLX_V5_IER_DISINT);
2772 	sc->mlx_state &= ~MLX_STATE_INTEN;
2773 	break;
2774     case MLX_INTACTION_ENABLE:
2775 	MLX_V5_PUT_IER(sc, 0xff & ~MLX_V5_IER_DISINT);
2776 	sc->mlx_state |= MLX_STATE_INTEN;
2777 	break;
2778     }
2779 }
2780 
2781 /********************************************************************************
2782  * Poll for firmware error codes during controller initialisation.
2783  * Returns 0 if initialisation is complete, 1 if still in progress but no
2784  * error has been fetched, 2 if an error has been retrieved.
2785  */
2786 static int
2787 mlx_v5_fw_handshake(struct mlx_softc *sc, int *error, int *param1, int *param2,
2788     int first)
2789 {
2790     u_int8_t	fwerror;
2791 
2792     debug_called(2);
2793 
2794     /* first time around, clear any hardware completion status */
2795     if (first) {
2796 	MLX_V5_PUT_IDBR(sc, MLX_V5_IDB_SACK);
2797 	DELAY(1000);
2798     }
2799 
2800     /* init in progress? */
2801     if (MLX_V5_GET_IDBR(sc) & MLX_V5_IDB_INIT_DONE)
2802 	return(0);
2803 
2804     /* test for error value */
2805     fwerror = MLX_V5_GET_FWERROR(sc);
2806     if (!(fwerror & MLX_V5_FWERROR_PEND))
2807 	return(1);
2808 
2809     /* mask status pending bit, fetch status */
2810     *error = fwerror & ~MLX_V5_FWERROR_PEND;
2811     *param1 = MLX_V5_GET_FWERROR_PARAM1(sc);
2812     *param2 = MLX_V5_GET_FWERROR_PARAM2(sc);
2813 
2814     /* acknowledge */
2815     MLX_V5_PUT_FWERROR(sc, 0xff);
2816 
2817     return(2);
2818 }
2819 
2820 /********************************************************************************
2821  ********************************************************************************
2822                                                                         Debugging
2823  ********************************************************************************
2824  ********************************************************************************/
2825 
2826 /********************************************************************************
2827  * Return a status message describing (mc)
2828  */
2829 static char *mlx_status_messages[] = {
2830     "normal completion",			/* 00 */
2831     "irrecoverable data error",			/* 01 */
2832     "drive does not exist, or is offline",	/* 02 */
2833     "attempt to write beyond end of drive",	/* 03 */
2834     "bad data encountered",			/* 04 */
2835     "invalid log entry request",		/* 05 */
2836     "attempt to rebuild online drive",		/* 06 */
2837     "new disk failed during rebuild",		/* 07 */
2838     "invalid channel/target",			/* 08 */
2839     "rebuild/check already in progress",	/* 09 */
2840     "one or more disks are dead",		/* 10 */
2841     "invalid or non-redundant drive",		/* 11 */
2842     "channel is busy",				/* 12 */
2843     "channel is not stopped",			/* 13 */
2844     "rebuild successfully terminated",		/* 14 */
2845     "unsupported command",			/* 15 */
2846     "check condition received",			/* 16 */
2847     "device is busy",				/* 17 */
2848     "selection or command timeout",		/* 18 */
2849     "command terminated abnormally",		/* 19 */
2850     ""
2851 };
2852 
2853 static struct
2854 {
2855     int		command;
2856     u_int16_t	status;
2857     int		msg;
2858 } mlx_messages[] = {
2859     {MLX_CMD_READSG,		0x0001,	 1},
2860     {MLX_CMD_READSG,		0x0002,	 1},
2861     {MLX_CMD_READSG,		0x0105,	 3},
2862     {MLX_CMD_READSG,		0x010c,	 4},
2863     {MLX_CMD_WRITESG,		0x0001,	 1},
2864     {MLX_CMD_WRITESG,		0x0002,	 1},
2865     {MLX_CMD_WRITESG,		0x0105,	 3},
2866     {MLX_CMD_READSG_OLD,	0x0001,	 1},
2867     {MLX_CMD_READSG_OLD,	0x0002,	 1},
2868     {MLX_CMD_READSG_OLD,	0x0105,	 3},
2869     {MLX_CMD_WRITESG_OLD,	0x0001,	 1},
2870     {MLX_CMD_WRITESG_OLD,	0x0002,	 1},
2871     {MLX_CMD_WRITESG_OLD,	0x0105,	 3},
2872     {MLX_CMD_LOGOP,		0x0105,	 5},
2873     {MLX_CMD_REBUILDASYNC,	0x0002,  6},
2874     {MLX_CMD_REBUILDASYNC,	0x0004,  7},
2875     {MLX_CMD_REBUILDASYNC,	0x0105,  8},
2876     {MLX_CMD_REBUILDASYNC,	0x0106,  9},
2877     {MLX_CMD_REBUILDASYNC,	0x0107, 14},
2878     {MLX_CMD_CHECKASYNC,	0x0002, 10},
2879     {MLX_CMD_CHECKASYNC,	0x0105, 11},
2880     {MLX_CMD_CHECKASYNC,	0x0106,  9},
2881     {MLX_CMD_STOPCHANNEL,	0x0106, 12},
2882     {MLX_CMD_STOPCHANNEL,	0x0105,  8},
2883     {MLX_CMD_STARTCHANNEL,	0x0005, 13},
2884     {MLX_CMD_STARTCHANNEL,	0x0105,  8},
2885     {MLX_CMD_DIRECT_CDB,	0x0002, 16},
2886     {MLX_CMD_DIRECT_CDB,	0x0008, 17},
2887     {MLX_CMD_DIRECT_CDB,	0x000e, 18},
2888     {MLX_CMD_DIRECT_CDB,	0x000f, 19},
2889     {MLX_CMD_DIRECT_CDB,	0x0105,  8},
2890 
2891     {0,				0x0104, 14},
2892     {-1, 0, 0}
2893 };
2894 
2895 static char *
2896 mlx_diagnose_command(struct mlx_command *mc)
2897 {
2898     static char	unkmsg[80];
2899     int		i;
2900 
2901     /* look up message in table */
2902     for (i = 0; mlx_messages[i].command != -1; i++)
2903 	if (((mc->mc_mailbox[0] == mlx_messages[i].command) || (mlx_messages[i].command == 0)) &&
2904 	    (mc->mc_status == mlx_messages[i].status))
2905 	    return(mlx_status_messages[mlx_messages[i].msg]);
2906 
2907     sprintf(unkmsg, "unknown response 0x%x for command 0x%x", (int)mc->mc_status, (int)mc->mc_mailbox[0]);
2908     return(unkmsg);
2909 }
2910 
2911 /*******************************************************************************
2912  * Print a string describing the controller (sc)
2913  */
2914 static struct
2915 {
2916     int		hwid;
2917     char	*name;
2918 } mlx_controller_names[] = {
2919     {0x01,	"960P/PD"},
2920     {0x02,	"960PL"},
2921     {0x10,	"960PG"},
2922     {0x11,	"960PJ"},
2923     {0x12,	"960PR"},
2924     {0x13,	"960PT"},
2925     {0x14,	"960PTL0"},
2926     {0x15,	"960PRL"},
2927     {0x16,	"960PTL1"},
2928     {0x20,	"1164PVX"},
2929     {-1, NULL}
2930 };
2931 
2932 static void
2933 mlx_describe_controller(struct mlx_softc *sc)
2934 {
2935     static char		buf[80];
2936     char		*model;
2937     int			i;
2938 
2939     for (i = 0, model = NULL; mlx_controller_names[i].name != NULL; i++) {
2940 	if ((sc->mlx_enq2->me_hardware_id & 0xff) == mlx_controller_names[i].hwid) {
2941 	    model = mlx_controller_names[i].name;
2942 	    break;
2943 	}
2944     }
2945     if (model == NULL) {
2946 	sprintf(buf, " model 0x%x", sc->mlx_enq2->me_hardware_id & 0xff);
2947 	model = buf;
2948     }
2949     device_printf(sc->mlx_dev, "DAC%s, %d channel%s, firmware %d.%02d-%c-%02d, %dMB RAM\n",
2950 		  model,
2951 		  sc->mlx_enq2->me_actual_channels,
2952 		  sc->mlx_enq2->me_actual_channels > 1 ? "s" : "",
2953 		  sc->mlx_enq2->me_firmware_id & 0xff,
2954 		  (sc->mlx_enq2->me_firmware_id >> 8) & 0xff,
2955 		  (sc->mlx_enq2->me_firmware_id >> 24) & 0xff,
2956 		  (sc->mlx_enq2->me_firmware_id >> 16) & 0xff,
2957 		  sc->mlx_enq2->me_mem_size / (1024 * 1024));
2958 
2959     if (bootverbose) {
2960 	device_printf(sc->mlx_dev, "  Hardware ID                 0x%08x\n", sc->mlx_enq2->me_hardware_id);
2961 	device_printf(sc->mlx_dev, "  Firmware ID                 0x%08x\n", sc->mlx_enq2->me_firmware_id);
2962 	device_printf(sc->mlx_dev, "  Configured/Actual channels  %d/%d\n", sc->mlx_enq2->me_configured_channels,
2963 		      sc->mlx_enq2->me_actual_channels);
2964 	device_printf(sc->mlx_dev, "  Max Targets                 %d\n", sc->mlx_enq2->me_max_targets);
2965 	device_printf(sc->mlx_dev, "  Max Tags                    %d\n", sc->mlx_enq2->me_max_tags);
2966 	device_printf(sc->mlx_dev, "  Max System Drives           %d\n", sc->mlx_enq2->me_max_sys_drives);
2967 	device_printf(sc->mlx_dev, "  Max Arms                    %d\n", sc->mlx_enq2->me_max_arms);
2968 	device_printf(sc->mlx_dev, "  Max Spans                   %d\n", sc->mlx_enq2->me_max_spans);
2969 	device_printf(sc->mlx_dev, "  DRAM/cache/flash/NVRAM size %d/%d/%d/%d\n", sc->mlx_enq2->me_mem_size,
2970 		      sc->mlx_enq2->me_cache_size, sc->mlx_enq2->me_flash_size, sc->mlx_enq2->me_nvram_size);
2971 	device_printf(sc->mlx_dev, "  DRAM type                   %d\n", sc->mlx_enq2->me_mem_type);
2972 	device_printf(sc->mlx_dev, "  Clock Speed                 %dns\n", sc->mlx_enq2->me_clock_speed);
2973 	device_printf(sc->mlx_dev, "  Hardware Speed              %dns\n", sc->mlx_enq2->me_hardware_speed);
2974 	device_printf(sc->mlx_dev, "  Max Commands                %d\n", sc->mlx_enq2->me_max_commands);
2975 	device_printf(sc->mlx_dev, "  Max SG Entries              %d\n", sc->mlx_enq2->me_max_sg);
2976 	device_printf(sc->mlx_dev, "  Max DP                      %d\n", sc->mlx_enq2->me_max_dp);
2977 	device_printf(sc->mlx_dev, "  Max IOD                     %d\n", sc->mlx_enq2->me_max_iod);
2978 	device_printf(sc->mlx_dev, "  Max Comb                    %d\n", sc->mlx_enq2->me_max_comb);
2979 	device_printf(sc->mlx_dev, "  Latency                     %ds\n", sc->mlx_enq2->me_latency);
2980 	device_printf(sc->mlx_dev, "  SCSI Timeout                %ds\n", sc->mlx_enq2->me_scsi_timeout);
2981 	device_printf(sc->mlx_dev, "  Min Free Lines              %d\n", sc->mlx_enq2->me_min_freelines);
2982 	device_printf(sc->mlx_dev, "  Rate Constant               %d\n", sc->mlx_enq2->me_rate_const);
2983 	device_printf(sc->mlx_dev, "  MAXBLK                      %d\n", sc->mlx_enq2->me_maxblk);
2984 	device_printf(sc->mlx_dev, "  Blocking Factor             %d sectors\n", sc->mlx_enq2->me_blocking_factor);
2985 	device_printf(sc->mlx_dev, "  Cache Line Size             %d blocks\n", sc->mlx_enq2->me_cacheline);
2986 	device_printf(sc->mlx_dev, "  SCSI Capability             %s%dMHz, %d bit\n",
2987 		      sc->mlx_enq2->me_scsi_cap & (1<<4) ? "differential " : "",
2988 		      (1 << ((sc->mlx_enq2->me_scsi_cap >> 2) & 3)) * 10,
2989 		      8 << (sc->mlx_enq2->me_scsi_cap & 0x3));
2990 	device_printf(sc->mlx_dev, "  Firmware Build Number       %d\n", sc->mlx_enq2->me_firmware_build);
2991 	device_printf(sc->mlx_dev, "  Fault Management Type       %d\n", sc->mlx_enq2->me_fault_mgmt_type);
2992 	device_printf(sc->mlx_dev, "  Features                    %b\n", sc->mlx_enq2->me_firmware_features,
2993 		      "\20\4Background Init\3Read Ahead\2MORE\1Cluster\n");
2994 
2995     }
2996 }
2997 
2998 /*******************************************************************************
2999  * Emit a string describing the firmware handshake status code, and return a flag
3000  * indicating whether the code represents a fatal error.
3001  *
3002  * Error code interpretations are from the Linux driver, and don't directly match
3003  * the messages printed by Mylex's BIOS.  This may change if documentation on the
3004  * codes is forthcoming.
3005  */
3006 static int
3007 mlx_fw_message(struct mlx_softc *sc, int error, int param1, int param2)
3008 {
3009     switch(error) {
3010     case 0x00:
3011 	device_printf(sc->mlx_dev, "physical drive %d:%d not responding\n", param2, param1);
3012 	break;
3013     case 0x08:
3014 	/* we could be neater about this and give some indication when we receive more of them */
3015 	if (!(sc->mlx_flags & MLX_SPINUP_REPORTED)) {
3016 	    device_printf(sc->mlx_dev, "spinning up drives...\n");
3017 	    sc->mlx_flags |= MLX_SPINUP_REPORTED;
3018 	}
3019 	break;
3020     case 0x30:
3021 	device_printf(sc->mlx_dev, "configuration checksum error\n");
3022 	break;
3023     case 0x60:
3024 	device_printf(sc->mlx_dev, "mirror race recovery failed\n");
3025 	break;
3026     case 0x70:
3027 	device_printf(sc->mlx_dev, "mirror race recovery in progress\n");
3028 	break;
3029     case 0x90:
3030 	device_printf(sc->mlx_dev, "physical drive %d:%d COD mismatch\n", param2, param1);
3031 	break;
3032     case 0xa0:
3033 	device_printf(sc->mlx_dev, "logical drive installation aborted\n");
3034 	break;
3035     case 0xb0:
3036 	device_printf(sc->mlx_dev, "mirror race on a critical system drive\n");
3037 	break;
3038     case 0xd0:
3039 	device_printf(sc->mlx_dev, "new controller configuration found\n");
3040 	break;
3041     case 0xf0:
3042 	device_printf(sc->mlx_dev, "FATAL MEMORY PARITY ERROR\n");
3043 	return(1);
3044     default:
3045 	device_printf(sc->mlx_dev, "unknown firmware initialisation error %02x:%02x:%02x\n", error, param1, param2);
3046 	break;
3047     }
3048     return(0);
3049 }
3050 
3051 /********************************************************************************
3052  ********************************************************************************
3053                                                                 Utility Functions
3054  ********************************************************************************
3055  ********************************************************************************/
3056 
3057 /********************************************************************************
3058  * Find the disk whose unit number is (unit) on this controller
3059  */
3060 static struct mlx_sysdrive *
3061 mlx_findunit(struct mlx_softc *sc, int unit)
3062 {
3063     int		i;
3064 
3065     /* search system drives */
3066     MLX_CONFIG_ASSERT_LOCKED(sc);
3067     for (i = 0; i < MLX_MAXDRIVES; i++) {
3068 	/* is this one attached? */
3069 	if (sc->mlx_sysdrive[i].ms_disk != 0) {
3070 	    /* is this the one? */
3071 	    if (unit == device_get_unit(sc->mlx_sysdrive[i].ms_disk))
3072 		return(&sc->mlx_sysdrive[i]);
3073 	}
3074     }
3075     return(NULL);
3076 }
3077