mly.c revision 251874
1/*-
2 * Copyright (c) 2000, 2001 Michael Smith
3 * Copyright (c) 2000 BSDi
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 *	$FreeBSD: stable/9/sys/dev/mly/mly.c 251874 2013-06-18 00:36:53Z scottl $
28 */
29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/malloc.h>
33#include <sys/kernel.h>
34#include <sys/bus.h>
35#include <sys/conf.h>
36#include <sys/ctype.h>
37#include <sys/ioccom.h>
38#include <sys/stat.h>
39
40#include <machine/bus.h>
41#include <machine/resource.h>
42#include <sys/rman.h>
43
44#include <cam/cam.h>
45#include <cam/cam_ccb.h>
46#include <cam/cam_periph.h>
47#include <cam/cam_sim.h>
48#include <cam/cam_xpt_sim.h>
49#include <cam/scsi/scsi_all.h>
50#include <cam/scsi/scsi_message.h>
51
52#include <dev/pci/pcireg.h>
53#include <dev/pci/pcivar.h>
54
55#include <dev/mly/mlyreg.h>
56#include <dev/mly/mlyio.h>
57#include <dev/mly/mlyvar.h>
58#include <dev/mly/mly_tables.h>
59
60static int	mly_probe(device_t dev);
61static int	mly_attach(device_t dev);
62static int	mly_pci_attach(struct mly_softc *sc);
63static int	mly_detach(device_t dev);
64static int	mly_shutdown(device_t dev);
65static void	mly_intr(void *arg);
66
67static int	mly_sg_map(struct mly_softc *sc);
68static void	mly_sg_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error);
69static int	mly_mmbox_map(struct mly_softc *sc);
70static void	mly_mmbox_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error);
71static void	mly_free(struct mly_softc *sc);
72
73static int	mly_get_controllerinfo(struct mly_softc *sc);
74static void	mly_scan_devices(struct mly_softc *sc);
75static void	mly_rescan_btl(struct mly_softc *sc, int bus, int target);
76static void	mly_complete_rescan(struct mly_command *mc);
77static int	mly_get_eventstatus(struct mly_softc *sc);
78static int	mly_enable_mmbox(struct mly_softc *sc);
79static int	mly_flush(struct mly_softc *sc);
80static int	mly_ioctl(struct mly_softc *sc, struct mly_command_ioctl *ioctl, void **data,
81			  size_t datasize, u_int8_t *status, void *sense_buffer, size_t *sense_length);
82static void	mly_check_event(struct mly_softc *sc);
83static void	mly_fetch_event(struct mly_softc *sc);
84static void	mly_complete_event(struct mly_command *mc);
85static void	mly_process_event(struct mly_softc *sc, struct mly_event *me);
86static void	mly_periodic(void *data);
87
88static int	mly_immediate_command(struct mly_command *mc);
89static int	mly_start(struct mly_command *mc);
90static void	mly_done(struct mly_softc *sc);
91static void	mly_complete(void *context, int pending);
92
93static int	mly_alloc_command(struct mly_softc *sc, struct mly_command **mcp);
94static void	mly_release_command(struct mly_command *mc);
95static void	mly_alloc_commands_map(void *arg, bus_dma_segment_t *segs, int nseg, int error);
96static int	mly_alloc_commands(struct mly_softc *sc);
97static void	mly_release_commands(struct mly_softc *sc);
98static void	mly_map_command(struct mly_command *mc);
99static void	mly_unmap_command(struct mly_command *mc);
100
101static int	mly_cam_attach(struct mly_softc *sc);
102static void	mly_cam_detach(struct mly_softc *sc);
103static void	mly_cam_rescan_btl(struct mly_softc *sc, int bus, int target);
104static void	mly_cam_action(struct cam_sim *sim, union ccb *ccb);
105static int	mly_cam_action_io(struct cam_sim *sim, struct ccb_scsiio *csio);
106static void	mly_cam_poll(struct cam_sim *sim);
107static void	mly_cam_complete(struct mly_command *mc);
108static struct cam_periph *mly_find_periph(struct mly_softc *sc, int bus, int target);
109static int	mly_name_device(struct mly_softc *sc, int bus, int target);
110
111static int	mly_fwhandshake(struct mly_softc *sc);
112
113static void	mly_describe_controller(struct mly_softc *sc);
114#ifdef MLY_DEBUG
115static void	mly_printstate(struct mly_softc *sc);
116static void	mly_print_command(struct mly_command *mc);
117static void	mly_print_packet(struct mly_command *mc);
118static void	mly_panic(struct mly_softc *sc, char *reason);
119static int	mly_timeout(struct mly_softc *sc);
120#endif
121void		mly_print_controller(int controller);
122
123
124static d_open_t		mly_user_open;
125static d_close_t	mly_user_close;
126static d_ioctl_t	mly_user_ioctl;
127static int	mly_user_command(struct mly_softc *sc, struct mly_user_command *uc);
128static int	mly_user_health(struct mly_softc *sc, struct mly_user_health *uh);
129
130#define MLY_CMD_TIMEOUT		20
131
132static device_method_t mly_methods[] = {
133    /* Device interface */
134    DEVMETHOD(device_probe,	mly_probe),
135    DEVMETHOD(device_attach,	mly_attach),
136    DEVMETHOD(device_detach,	mly_detach),
137    DEVMETHOD(device_shutdown,	mly_shutdown),
138    { 0, 0 }
139};
140
141static driver_t mly_pci_driver = {
142	"mly",
143	mly_methods,
144	sizeof(struct mly_softc)
145};
146
147static devclass_t	mly_devclass;
148DRIVER_MODULE(mly, pci, mly_pci_driver, mly_devclass, 0, 0);
149MODULE_DEPEND(mly, pci, 1, 1, 1);
150MODULE_DEPEND(mly, cam, 1, 1, 1);
151
152static struct cdevsw mly_cdevsw = {
153	.d_version =	D_VERSION,
154	.d_flags =	D_NEEDGIANT,
155	.d_open =	mly_user_open,
156	.d_close =	mly_user_close,
157	.d_ioctl =	mly_user_ioctl,
158	.d_name =	"mly",
159};
160
161/********************************************************************************
162 ********************************************************************************
163                                                                 Device Interface
164 ********************************************************************************
165 ********************************************************************************/
166
167static struct mly_ident
168{
169    u_int16_t		vendor;
170    u_int16_t		device;
171    u_int16_t		subvendor;
172    u_int16_t		subdevice;
173    int			hwif;
174    char		*desc;
175} mly_identifiers[] = {
176    {0x1069, 0xba56, 0x1069, 0x0040, MLY_HWIF_STRONGARM, "Mylex eXtremeRAID 2000"},
177    {0x1069, 0xba56, 0x1069, 0x0030, MLY_HWIF_STRONGARM, "Mylex eXtremeRAID 3000"},
178    {0x1069, 0x0050, 0x1069, 0x0050, MLY_HWIF_I960RX,    "Mylex AcceleRAID 352"},
179    {0x1069, 0x0050, 0x1069, 0x0052, MLY_HWIF_I960RX,    "Mylex AcceleRAID 170"},
180    {0x1069, 0x0050, 0x1069, 0x0054, MLY_HWIF_I960RX,    "Mylex AcceleRAID 160"},
181    {0, 0, 0, 0, 0, 0}
182};
183
184/********************************************************************************
185 * Compare the provided PCI device with the list we support.
186 */
187static int
188mly_probe(device_t dev)
189{
190    struct mly_ident	*m;
191
192    debug_called(1);
193
194    for (m = mly_identifiers; m->vendor != 0; m++) {
195	if ((m->vendor == pci_get_vendor(dev)) &&
196	    (m->device == pci_get_device(dev)) &&
197	    ((m->subvendor == 0) || ((m->subvendor == pci_get_subvendor(dev)) &&
198				     (m->subdevice == pci_get_subdevice(dev))))) {
199
200	    device_set_desc(dev, m->desc);
201	    return(BUS_PROBE_DEFAULT);	/* allow room to be overridden */
202	}
203    }
204    return(ENXIO);
205}
206
207/********************************************************************************
208 * Initialise the controller and softc
209 */
210static int
211mly_attach(device_t dev)
212{
213    struct mly_softc	*sc = device_get_softc(dev);
214    int			error;
215
216    debug_called(1);
217
218    sc->mly_dev = dev;
219
220#ifdef MLY_DEBUG
221    if (device_get_unit(sc->mly_dev) == 0)
222	mly_softc0 = sc;
223#endif
224
225    /*
226     * Do PCI-specific initialisation.
227     */
228    if ((error = mly_pci_attach(sc)) != 0)
229	goto out;
230
231    /*
232     * Initialise per-controller queues.
233     */
234    mly_initq_free(sc);
235    mly_initq_busy(sc);
236    mly_initq_complete(sc);
237
238    /*
239     * Initialise command-completion task.
240     */
241    TASK_INIT(&sc->mly_task_complete, 0, mly_complete, sc);
242
243    /* disable interrupts before we start talking to the controller */
244    MLY_MASK_INTERRUPTS(sc);
245
246    /*
247     * Wait for the controller to come ready, handshake with the firmware if required.
248     * This is typically only necessary on platforms where the controller BIOS does not
249     * run.
250     */
251    if ((error = mly_fwhandshake(sc)))
252	goto out;
253
254    /*
255     * Allocate initial command buffers.
256     */
257    if ((error = mly_alloc_commands(sc)))
258	goto out;
259
260    /*
261     * Obtain controller feature information
262     */
263    if ((error = mly_get_controllerinfo(sc)))
264	goto out;
265
266    /*
267     * Reallocate command buffers now we know how many we want.
268     */
269    mly_release_commands(sc);
270    if ((error = mly_alloc_commands(sc)))
271	goto out;
272
273    /*
274     * Get the current event counter for health purposes, populate the initial
275     * health status buffer.
276     */
277    if ((error = mly_get_eventstatus(sc)))
278	goto out;
279
280    /*
281     * Enable memory-mailbox mode.
282     */
283    if ((error = mly_enable_mmbox(sc)))
284	goto out;
285
286    /*
287     * Attach to CAM.
288     */
289    if ((error = mly_cam_attach(sc)))
290	goto out;
291
292    /*
293     * Print a little information about the controller
294     */
295    mly_describe_controller(sc);
296
297    /*
298     * Mark all attached devices for rescan.
299     */
300    mly_scan_devices(sc);
301
302    /*
303     * Instigate the first status poll immediately.  Rescan completions won't
304     * happen until interrupts are enabled, which should still be before
305     * the SCSI subsystem gets to us, courtesy of the "SCSI settling delay".
306     */
307    mly_periodic((void *)sc);
308
309    /*
310     * Create the control device.
311     */
312    sc->mly_dev_t = make_dev(&mly_cdevsw, 0, UID_ROOT, GID_OPERATOR,
313			     S_IRUSR | S_IWUSR, "mly%d", device_get_unit(sc->mly_dev));
314    sc->mly_dev_t->si_drv1 = sc;
315
316    /* enable interrupts now */
317    MLY_UNMASK_INTERRUPTS(sc);
318
319#ifdef MLY_DEBUG
320    timeout((timeout_t *)mly_timeout, sc, MLY_CMD_TIMEOUT * hz);
321#endif
322
323 out:
324    if (error != 0)
325	mly_free(sc);
326    return(error);
327}
328
329/********************************************************************************
330 * Perform PCI-specific initialisation.
331 */
332static int
333mly_pci_attach(struct mly_softc *sc)
334{
335    int			i, error;
336    u_int32_t		command;
337
338    debug_called(1);
339
340    /* assume failure is 'not configured' */
341    error = ENXIO;
342
343    /*
344     * Verify that the adapter is correctly set up in PCI space.
345     *
346     * XXX we shouldn't do this; the PCI code should.
347     */
348    command = pci_read_config(sc->mly_dev, PCIR_COMMAND, 2);
349    command |= PCIM_CMD_BUSMASTEREN;
350    pci_write_config(sc->mly_dev, PCIR_COMMAND, command, 2);
351    command = pci_read_config(sc->mly_dev, PCIR_COMMAND, 2);
352    if (!(command & PCIM_CMD_BUSMASTEREN)) {
353	mly_printf(sc, "can't enable busmaster feature\n");
354	goto fail;
355    }
356    if ((command & PCIM_CMD_MEMEN) == 0) {
357	mly_printf(sc, "memory window not available\n");
358	goto fail;
359    }
360
361    /*
362     * Allocate the PCI register window.
363     */
364    sc->mly_regs_rid = PCIR_BAR(0);	/* first base address register */
365    if ((sc->mly_regs_resource = bus_alloc_resource_any(sc->mly_dev,
366	    SYS_RES_MEMORY, &sc->mly_regs_rid, RF_ACTIVE)) == NULL) {
367	mly_printf(sc, "can't allocate register window\n");
368	goto fail;
369    }
370    sc->mly_btag = rman_get_bustag(sc->mly_regs_resource);
371    sc->mly_bhandle = rman_get_bushandle(sc->mly_regs_resource);
372
373    /*
374     * Allocate and connect our interrupt.
375     */
376    sc->mly_irq_rid = 0;
377    if ((sc->mly_irq = bus_alloc_resource_any(sc->mly_dev, SYS_RES_IRQ,
378		    &sc->mly_irq_rid, RF_SHAREABLE | RF_ACTIVE)) == NULL) {
379	mly_printf(sc, "can't allocate interrupt\n");
380	goto fail;
381    }
382    if (bus_setup_intr(sc->mly_dev, sc->mly_irq, INTR_TYPE_CAM | INTR_ENTROPY, NULL, mly_intr, sc, &sc->mly_intr)) {
383	mly_printf(sc, "can't set up interrupt\n");
384	goto fail;
385    }
386
387    /* assume failure is 'out of memory' */
388    error = ENOMEM;
389
390    /*
391     * Allocate the parent bus DMA tag appropriate for our PCI interface.
392     *
393     * Note that all of these controllers are 64-bit capable.
394     */
395    if (bus_dma_tag_create(bus_get_dma_tag(sc->mly_dev),/* PCI parent */
396			   1, 0, 			/* alignment, boundary */
397			   BUS_SPACE_MAXADDR_32BIT,	/* lowaddr */
398			   BUS_SPACE_MAXADDR, 		/* highaddr */
399			   NULL, NULL, 			/* filter, filterarg */
400			   MAXBSIZE, MLY_MAX_SGENTRIES,	/* maxsize, nsegments */
401			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
402			   BUS_DMA_ALLOCNOW,		/* flags */
403			   NULL,			/* lockfunc */
404			   NULL,			/* lockarg */
405			   &sc->mly_parent_dmat)) {
406	mly_printf(sc, "can't allocate parent DMA tag\n");
407	goto fail;
408    }
409
410    /*
411     * Create DMA tag for mapping buffers into controller-addressable space.
412     */
413    if (bus_dma_tag_create(sc->mly_parent_dmat, 	/* parent */
414			   1, 0, 			/* alignment, boundary */
415			   BUS_SPACE_MAXADDR,		/* lowaddr */
416			   BUS_SPACE_MAXADDR, 		/* highaddr */
417			   NULL, NULL, 			/* filter, filterarg */
418			   MAXBSIZE, MLY_MAX_SGENTRIES,	/* maxsize, nsegments */
419			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
420			   0,				/* flags */
421			   busdma_lock_mutex,		/* lockfunc */
422			   &Giant,			/* lockarg */
423			   &sc->mly_buffer_dmat)) {
424	mly_printf(sc, "can't allocate buffer DMA tag\n");
425	goto fail;
426    }
427
428    /*
429     * Initialise the DMA tag for command packets.
430     */
431    if (bus_dma_tag_create(sc->mly_parent_dmat,		/* parent */
432			   1, 0, 			/* alignment, boundary */
433			   BUS_SPACE_MAXADDR,		/* lowaddr */
434			   BUS_SPACE_MAXADDR, 		/* highaddr */
435			   NULL, NULL, 			/* filter, filterarg */
436			   sizeof(union mly_command_packet) * MLY_MAX_COMMANDS, 1,	/* maxsize, nsegments */
437			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
438			   BUS_DMA_ALLOCNOW,		/* flags */
439			   NULL, NULL,			/* lockfunc, lockarg */
440			   &sc->mly_packet_dmat)) {
441	mly_printf(sc, "can't allocate command packet DMA tag\n");
442	goto fail;
443    }
444
445    /*
446     * Detect the hardware interface version
447     */
448    for (i = 0; mly_identifiers[i].vendor != 0; i++) {
449	if ((mly_identifiers[i].vendor == pci_get_vendor(sc->mly_dev)) &&
450	    (mly_identifiers[i].device == pci_get_device(sc->mly_dev))) {
451	    sc->mly_hwif = mly_identifiers[i].hwif;
452	    switch(sc->mly_hwif) {
453	    case MLY_HWIF_I960RX:
454		debug(1, "set hardware up for i960RX");
455		sc->mly_doorbell_true = 0x00;
456		sc->mly_command_mailbox =  MLY_I960RX_COMMAND_MAILBOX;
457		sc->mly_status_mailbox =   MLY_I960RX_STATUS_MAILBOX;
458		sc->mly_idbr =             MLY_I960RX_IDBR;
459		sc->mly_odbr =             MLY_I960RX_ODBR;
460		sc->mly_error_status =     MLY_I960RX_ERROR_STATUS;
461		sc->mly_interrupt_status = MLY_I960RX_INTERRUPT_STATUS;
462		sc->mly_interrupt_mask =   MLY_I960RX_INTERRUPT_MASK;
463		break;
464	    case MLY_HWIF_STRONGARM:
465		debug(1, "set hardware up for StrongARM");
466		sc->mly_doorbell_true = 0xff;		/* doorbell 'true' is 0 */
467		sc->mly_command_mailbox =  MLY_STRONGARM_COMMAND_MAILBOX;
468		sc->mly_status_mailbox =   MLY_STRONGARM_STATUS_MAILBOX;
469		sc->mly_idbr =             MLY_STRONGARM_IDBR;
470		sc->mly_odbr =             MLY_STRONGARM_ODBR;
471		sc->mly_error_status =     MLY_STRONGARM_ERROR_STATUS;
472		sc->mly_interrupt_status = MLY_STRONGARM_INTERRUPT_STATUS;
473		sc->mly_interrupt_mask =   MLY_STRONGARM_INTERRUPT_MASK;
474		break;
475	    }
476	    break;
477	}
478    }
479
480    /*
481     * Create the scatter/gather mappings.
482     */
483    if ((error = mly_sg_map(sc)))
484	goto fail;
485
486    /*
487     * Allocate and map the memory mailbox
488     */
489    if ((error = mly_mmbox_map(sc)))
490	goto fail;
491
492    error = 0;
493
494fail:
495    return(error);
496}
497
498/********************************************************************************
499 * Shut the controller down and detach all our resources.
500 */
501static int
502mly_detach(device_t dev)
503{
504    int			error;
505
506    if ((error = mly_shutdown(dev)) != 0)
507	return(error);
508
509    mly_free(device_get_softc(dev));
510    return(0);
511}
512
513/********************************************************************************
514 * Bring the controller to a state where it can be safely left alone.
515 *
516 * Note that it should not be necessary to wait for any outstanding commands,
517 * as they should be completed prior to calling here.
518 *
519 * XXX this applies for I/O, but not status polls; we should beware of
520 *     the case where a status command is running while we detach.
521 */
522static int
523mly_shutdown(device_t dev)
524{
525    struct mly_softc	*sc = device_get_softc(dev);
526
527    debug_called(1);
528
529    if (sc->mly_state & MLY_STATE_OPEN)
530	return(EBUSY);
531
532    /* kill the periodic event */
533    untimeout(mly_periodic, sc, sc->mly_periodic);
534
535    /* flush controller */
536    mly_printf(sc, "flushing cache...");
537    printf("%s\n", mly_flush(sc) ? "failed" : "done");
538
539    MLY_MASK_INTERRUPTS(sc);
540
541    return(0);
542}
543
544/*******************************************************************************
545 * Take an interrupt, or be poked by other code to look for interrupt-worthy
546 * status.
547 */
548static void
549mly_intr(void *arg)
550{
551    struct mly_softc	*sc = (struct mly_softc *)arg;
552
553    debug_called(2);
554
555    mly_done(sc);
556};
557
558/********************************************************************************
559 ********************************************************************************
560                                                Bus-dependant Resource Management
561 ********************************************************************************
562 ********************************************************************************/
563
564/********************************************************************************
565 * Allocate memory for the scatter/gather tables
566 */
567static int
568mly_sg_map(struct mly_softc *sc)
569{
570    size_t	segsize;
571
572    debug_called(1);
573
574    /*
575     * Create a single tag describing a region large enough to hold all of
576     * the s/g lists we will need.
577     */
578    segsize = sizeof(struct mly_sg_entry) * MLY_MAX_COMMANDS *MLY_MAX_SGENTRIES;
579    if (bus_dma_tag_create(sc->mly_parent_dmat,		/* parent */
580			   1, 0, 			/* alignment,boundary */
581			   BUS_SPACE_MAXADDR,		/* lowaddr */
582			   BUS_SPACE_MAXADDR, 		/* highaddr */
583			   NULL, NULL, 			/* filter, filterarg */
584			   segsize, 1,			/* maxsize, nsegments */
585			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
586			   BUS_DMA_ALLOCNOW,		/* flags */
587			   NULL, NULL,			/* lockfunc, lockarg */
588			   &sc->mly_sg_dmat)) {
589	mly_printf(sc, "can't allocate scatter/gather DMA tag\n");
590	return(ENOMEM);
591    }
592
593    /*
594     * Allocate enough s/g maps for all commands and permanently map them into
595     * controller-visible space.
596     *
597     * XXX this assumes we can get enough space for all the s/g maps in one
598     * contiguous slab.
599     */
600    if (bus_dmamem_alloc(sc->mly_sg_dmat, (void **)&sc->mly_sg_table,
601			 BUS_DMA_NOWAIT, &sc->mly_sg_dmamap)) {
602	mly_printf(sc, "can't allocate s/g table\n");
603	return(ENOMEM);
604    }
605    if (bus_dmamap_load(sc->mly_sg_dmat, sc->mly_sg_dmamap, sc->mly_sg_table,
606			segsize, mly_sg_map_helper, sc, BUS_DMA_NOWAIT) != 0)
607	return (ENOMEM);
608    return(0);
609}
610
611/********************************************************************************
612 * Save the physical address of the base of the s/g table.
613 */
614static void
615mly_sg_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
616{
617    struct mly_softc	*sc = (struct mly_softc *)arg;
618
619    debug_called(1);
620
621    /* save base of s/g table's address in bus space */
622    sc->mly_sg_busaddr = segs->ds_addr;
623}
624
625/********************************************************************************
626 * Allocate memory for the memory-mailbox interface
627 */
628static int
629mly_mmbox_map(struct mly_softc *sc)
630{
631
632    /*
633     * Create a DMA tag for a single contiguous region large enough for the
634     * memory mailbox structure.
635     */
636    if (bus_dma_tag_create(sc->mly_parent_dmat,		/* parent */
637			   1, 0, 			/* alignment,boundary */
638			   BUS_SPACE_MAXADDR,		/* lowaddr */
639			   BUS_SPACE_MAXADDR, 		/* highaddr */
640			   NULL, NULL, 			/* filter, filterarg */
641			   sizeof(struct mly_mmbox), 1,	/* maxsize, nsegments */
642			   BUS_SPACE_MAXSIZE_32BIT,	/* maxsegsize */
643			   BUS_DMA_ALLOCNOW,		/* flags */
644			   NULL, NULL,			/* lockfunc, lockarg */
645			   &sc->mly_mmbox_dmat)) {
646	mly_printf(sc, "can't allocate memory mailbox DMA tag\n");
647	return(ENOMEM);
648    }
649
650    /*
651     * Allocate the buffer
652     */
653    if (bus_dmamem_alloc(sc->mly_mmbox_dmat, (void **)&sc->mly_mmbox, BUS_DMA_NOWAIT, &sc->mly_mmbox_dmamap)) {
654	mly_printf(sc, "can't allocate memory mailbox\n");
655	return(ENOMEM);
656    }
657    if (bus_dmamap_load(sc->mly_mmbox_dmat, sc->mly_mmbox_dmamap, sc->mly_mmbox,
658			sizeof(struct mly_mmbox), mly_mmbox_map_helper, sc,
659			BUS_DMA_NOWAIT) != 0)
660	return (ENOMEM);
661    bzero(sc->mly_mmbox, sizeof(*sc->mly_mmbox));
662    return(0);
663
664}
665
666/********************************************************************************
667 * Save the physical address of the memory mailbox
668 */
669static void
670mly_mmbox_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
671{
672    struct mly_softc	*sc = (struct mly_softc *)arg;
673
674    debug_called(1);
675
676    sc->mly_mmbox_busaddr = segs->ds_addr;
677}
678
679/********************************************************************************
680 * Free all of the resources associated with (sc)
681 *
682 * Should not be called if the controller is active.
683 */
684static void
685mly_free(struct mly_softc *sc)
686{
687
688    debug_called(1);
689
690    /* Remove the management device */
691    destroy_dev(sc->mly_dev_t);
692
693    /* detach from CAM */
694    mly_cam_detach(sc);
695
696    /* release command memory */
697    mly_release_commands(sc);
698
699    /* throw away the controllerinfo structure */
700    if (sc->mly_controllerinfo != NULL)
701	free(sc->mly_controllerinfo, M_DEVBUF);
702
703    /* throw away the controllerparam structure */
704    if (sc->mly_controllerparam != NULL)
705	free(sc->mly_controllerparam, M_DEVBUF);
706
707    /* destroy data-transfer DMA tag */
708    if (sc->mly_buffer_dmat)
709	bus_dma_tag_destroy(sc->mly_buffer_dmat);
710
711    /* free and destroy DMA memory and tag for s/g lists */
712    if (sc->mly_sg_table) {
713	bus_dmamap_unload(sc->mly_sg_dmat, sc->mly_sg_dmamap);
714	bus_dmamem_free(sc->mly_sg_dmat, sc->mly_sg_table, sc->mly_sg_dmamap);
715    }
716    if (sc->mly_sg_dmat)
717	bus_dma_tag_destroy(sc->mly_sg_dmat);
718
719    /* free and destroy DMA memory and tag for memory mailbox */
720    if (sc->mly_mmbox) {
721	bus_dmamap_unload(sc->mly_mmbox_dmat, sc->mly_mmbox_dmamap);
722	bus_dmamem_free(sc->mly_mmbox_dmat, sc->mly_mmbox, sc->mly_mmbox_dmamap);
723    }
724    if (sc->mly_mmbox_dmat)
725	bus_dma_tag_destroy(sc->mly_mmbox_dmat);
726
727    /* disconnect the interrupt handler */
728    if (sc->mly_intr)
729	bus_teardown_intr(sc->mly_dev, sc->mly_irq, sc->mly_intr);
730    if (sc->mly_irq != NULL)
731	bus_release_resource(sc->mly_dev, SYS_RES_IRQ, sc->mly_irq_rid, sc->mly_irq);
732
733    /* destroy the parent DMA tag */
734    if (sc->mly_parent_dmat)
735	bus_dma_tag_destroy(sc->mly_parent_dmat);
736
737    /* release the register window mapping */
738    if (sc->mly_regs_resource != NULL)
739	bus_release_resource(sc->mly_dev, SYS_RES_MEMORY, sc->mly_regs_rid, sc->mly_regs_resource);
740}
741
742/********************************************************************************
743 ********************************************************************************
744                                                                 Command Wrappers
745 ********************************************************************************
746 ********************************************************************************/
747
748/********************************************************************************
749 * Fill in the mly_controllerinfo and mly_controllerparam fields in the softc.
750 */
751static int
752mly_get_controllerinfo(struct mly_softc *sc)
753{
754    struct mly_command_ioctl	mci;
755    u_int8_t			status;
756    int				error;
757
758    debug_called(1);
759
760    if (sc->mly_controllerinfo != NULL)
761	free(sc->mly_controllerinfo, M_DEVBUF);
762
763    /* build the getcontrollerinfo ioctl and send it */
764    bzero(&mci, sizeof(mci));
765    sc->mly_controllerinfo = NULL;
766    mci.sub_ioctl = MDACIOCTL_GETCONTROLLERINFO;
767    if ((error = mly_ioctl(sc, &mci, (void **)&sc->mly_controllerinfo, sizeof(*sc->mly_controllerinfo),
768			   &status, NULL, NULL)))
769	return(error);
770    if (status != 0)
771	return(EIO);
772
773    if (sc->mly_controllerparam != NULL)
774	free(sc->mly_controllerparam, M_DEVBUF);
775
776    /* build the getcontrollerparameter ioctl and send it */
777    bzero(&mci, sizeof(mci));
778    sc->mly_controllerparam = NULL;
779    mci.sub_ioctl = MDACIOCTL_GETCONTROLLERPARAMETER;
780    if ((error = mly_ioctl(sc, &mci, (void **)&sc->mly_controllerparam, sizeof(*sc->mly_controllerparam),
781			   &status, NULL, NULL)))
782	return(error);
783    if (status != 0)
784	return(EIO);
785
786    return(0);
787}
788
789/********************************************************************************
790 * Schedule all possible devices for a rescan.
791 *
792 */
793static void
794mly_scan_devices(struct mly_softc *sc)
795{
796    int		bus, target;
797
798    debug_called(1);
799
800    /*
801     * Clear any previous BTL information.
802     */
803    bzero(&sc->mly_btl, sizeof(sc->mly_btl));
804
805    /*
806     * Mark all devices as requiring a rescan, and let the next
807     * periodic scan collect them.
808     */
809    for (bus = 0; bus < sc->mly_cam_channels; bus++)
810	if (MLY_BUS_IS_VALID(sc, bus))
811	    for (target = 0; target < MLY_MAX_TARGETS; target++)
812		sc->mly_btl[bus][target].mb_flags = MLY_BTL_RESCAN;
813
814}
815
816/********************************************************************************
817 * Rescan a device, possibly as a consequence of getting an event which suggests
818 * that it may have changed.
819 *
820 * If we suffer resource starvation, we can abandon the rescan as we'll be
821 * retried.
822 */
823static void
824mly_rescan_btl(struct mly_softc *sc, int bus, int target)
825{
826    struct mly_command		*mc;
827    struct mly_command_ioctl	*mci;
828
829    debug_called(1);
830
831    /* check that this bus is valid */
832    if (!MLY_BUS_IS_VALID(sc, bus))
833	return;
834
835    /* get a command */
836    if (mly_alloc_command(sc, &mc))
837	return;
838
839    /* set up the data buffer */
840    if ((mc->mc_data = malloc(sizeof(union mly_devinfo), M_DEVBUF, M_NOWAIT | M_ZERO)) == NULL) {
841	mly_release_command(mc);
842	return;
843    }
844    mc->mc_flags |= MLY_CMD_DATAIN;
845    mc->mc_complete = mly_complete_rescan;
846
847    /*
848     * Build the ioctl.
849     */
850    mci = (struct mly_command_ioctl *)&mc->mc_packet->ioctl;
851    mci->opcode = MDACMD_IOCTL;
852    mci->addr.phys.controller = 0;
853    mci->timeout.value = 30;
854    mci->timeout.scale = MLY_TIMEOUT_SECONDS;
855    if (MLY_BUS_IS_VIRTUAL(sc, bus)) {
856	mc->mc_length = mci->data_size = sizeof(struct mly_ioctl_getlogdevinfovalid);
857	mci->sub_ioctl = MDACIOCTL_GETLOGDEVINFOVALID;
858	mci->addr.log.logdev = MLY_LOGDEV_ID(sc, bus, target);
859	debug(1, "logical device %d", mci->addr.log.logdev);
860    } else {
861	mc->mc_length = mci->data_size = sizeof(struct mly_ioctl_getphysdevinfovalid);
862	mci->sub_ioctl = MDACIOCTL_GETPHYSDEVINFOVALID;
863	mci->addr.phys.lun = 0;
864	mci->addr.phys.target = target;
865	mci->addr.phys.channel = bus;
866	debug(1, "physical device %d:%d", mci->addr.phys.channel, mci->addr.phys.target);
867    }
868
869    /*
870     * Dispatch the command.  If we successfully send the command, clear the rescan
871     * bit.
872     */
873    if (mly_start(mc) != 0) {
874	mly_release_command(mc);
875    } else {
876	sc->mly_btl[bus][target].mb_flags &= ~MLY_BTL_RESCAN;	/* success */
877    }
878}
879
880/********************************************************************************
881 * Handle the completion of a rescan operation
882 */
883static void
884mly_complete_rescan(struct mly_command *mc)
885{
886    struct mly_softc				*sc = mc->mc_sc;
887    struct mly_ioctl_getlogdevinfovalid		*ldi;
888    struct mly_ioctl_getphysdevinfovalid	*pdi;
889    struct mly_command_ioctl			*mci;
890    struct mly_btl				btl, *btlp;
891    int						bus, target, rescan;
892
893    debug_called(1);
894
895    /*
896     * Recover the bus and target from the command.  We need these even in
897     * the case where we don't have a useful response.
898     */
899    mci = (struct mly_command_ioctl *)&mc->mc_packet->ioctl;
900    if (mci->sub_ioctl == MDACIOCTL_GETLOGDEVINFOVALID) {
901	bus = MLY_LOGDEV_BUS(sc, mci->addr.log.logdev);
902	target = MLY_LOGDEV_TARGET(sc, mci->addr.log.logdev);
903    } else {
904	bus = mci->addr.phys.channel;
905	target = mci->addr.phys.target;
906    }
907    /* XXX validate bus/target? */
908
909    /* the default result is 'no device' */
910    bzero(&btl, sizeof(btl));
911
912    /* if the rescan completed OK, we have possibly-new BTL data */
913    if (mc->mc_status == 0) {
914	if (mc->mc_length == sizeof(*ldi)) {
915	    ldi = (struct mly_ioctl_getlogdevinfovalid *)mc->mc_data;
916	    if ((MLY_LOGDEV_BUS(sc, ldi->logical_device_number) != bus) ||
917		(MLY_LOGDEV_TARGET(sc, ldi->logical_device_number) != target)) {
918		mly_printf(sc, "WARNING: BTL rescan for %d:%d returned data for %d:%d instead\n",
919			   bus, target, MLY_LOGDEV_BUS(sc, ldi->logical_device_number),
920			   MLY_LOGDEV_TARGET(sc, ldi->logical_device_number));
921		/* XXX what can we do about this? */
922	    }
923	    btl.mb_flags = MLY_BTL_LOGICAL;
924	    btl.mb_type = ldi->raid_level;
925	    btl.mb_state = ldi->state;
926	    debug(1, "BTL rescan for %d returns %s, %s", ldi->logical_device_number,
927		  mly_describe_code(mly_table_device_type, ldi->raid_level),
928		  mly_describe_code(mly_table_device_state, ldi->state));
929	} else if (mc->mc_length == sizeof(*pdi)) {
930	    pdi = (struct mly_ioctl_getphysdevinfovalid *)mc->mc_data;
931	    if ((pdi->channel != bus) || (pdi->target != target)) {
932		mly_printf(sc, "WARNING: BTL rescan for %d:%d returned data for %d:%d instead\n",
933			   bus, target, pdi->channel, pdi->target);
934		/* XXX what can we do about this? */
935	    }
936	    btl.mb_flags = MLY_BTL_PHYSICAL;
937	    btl.mb_type = MLY_DEVICE_TYPE_PHYSICAL;
938	    btl.mb_state = pdi->state;
939	    btl.mb_speed = pdi->speed;
940	    btl.mb_width = pdi->width;
941	    if (pdi->state != MLY_DEVICE_STATE_UNCONFIGURED)
942		sc->mly_btl[bus][target].mb_flags |= MLY_BTL_PROTECTED;
943	    debug(1, "BTL rescan for %d:%d returns %s", bus, target,
944		  mly_describe_code(mly_table_device_state, pdi->state));
945	} else {
946	    mly_printf(sc, "BTL rescan result invalid\n");
947	}
948    }
949
950    free(mc->mc_data, M_DEVBUF);
951    mly_release_command(mc);
952
953    /*
954     * Decide whether we need to rescan the device.
955     */
956    rescan = 0;
957
958    /* device type changes (usually between 'nothing' and 'something') */
959    btlp = &sc->mly_btl[bus][target];
960    if (btl.mb_flags != btlp->mb_flags) {
961	debug(1, "flags changed, rescanning");
962	rescan = 1;
963    }
964
965    /* XXX other reasons? */
966
967    /*
968     * Update BTL information.
969     */
970    *btlp = btl;
971
972    /*
973     * Perform CAM rescan if required.
974     */
975    if (rescan)
976	mly_cam_rescan_btl(sc, bus, target);
977}
978
979/********************************************************************************
980 * Get the current health status and set the 'next event' counter to suit.
981 */
982static int
983mly_get_eventstatus(struct mly_softc *sc)
984{
985    struct mly_command_ioctl	mci;
986    struct mly_health_status	*mh;
987    u_int8_t			status;
988    int				error;
989
990    /* build the gethealthstatus ioctl and send it */
991    bzero(&mci, sizeof(mci));
992    mh = NULL;
993    mci.sub_ioctl = MDACIOCTL_GETHEALTHSTATUS;
994
995    if ((error = mly_ioctl(sc, &mci, (void **)&mh, sizeof(*mh), &status, NULL, NULL)))
996	return(error);
997    if (status != 0)
998	return(EIO);
999
1000    /* get the event counter */
1001    sc->mly_event_change = mh->change_counter;
1002    sc->mly_event_waiting = mh->next_event;
1003    sc->mly_event_counter = mh->next_event;
1004
1005    /* save the health status into the memory mailbox */
1006    bcopy(mh, &sc->mly_mmbox->mmm_health.status, sizeof(*mh));
1007
1008    debug(1, "initial change counter %d, event counter %d", mh->change_counter, mh->next_event);
1009
1010    free(mh, M_DEVBUF);
1011    return(0);
1012}
1013
1014/********************************************************************************
1015 * Enable the memory mailbox mode.
1016 */
1017static int
1018mly_enable_mmbox(struct mly_softc *sc)
1019{
1020    struct mly_command_ioctl	mci;
1021    u_int8_t			*sp, status;
1022    int				error;
1023
1024    debug_called(1);
1025
1026    /* build the ioctl and send it */
1027    bzero(&mci, sizeof(mci));
1028    mci.sub_ioctl = MDACIOCTL_SETMEMORYMAILBOX;
1029    /* set buffer addresses */
1030    mci.param.setmemorymailbox.command_mailbox_physaddr =
1031	sc->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_command);
1032    mci.param.setmemorymailbox.status_mailbox_physaddr =
1033	sc->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_status);
1034    mci.param.setmemorymailbox.health_buffer_physaddr =
1035	sc->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_health);
1036
1037    /* set buffer sizes - abuse of data_size field is revolting */
1038    sp = (u_int8_t *)&mci.data_size;
1039    sp[0] = ((sizeof(union mly_command_packet) * MLY_MMBOX_COMMANDS) / 1024);
1040    sp[1] = (sizeof(union mly_status_packet) * MLY_MMBOX_STATUS) / 1024;
1041    mci.param.setmemorymailbox.health_buffer_size = sizeof(union mly_health_region) / 1024;
1042
1043    debug(1, "memory mailbox at %p (0x%llx/%d 0x%llx/%d 0x%llx/%d", sc->mly_mmbox,
1044	  mci.param.setmemorymailbox.command_mailbox_physaddr, sp[0],
1045	  mci.param.setmemorymailbox.status_mailbox_physaddr, sp[1],
1046	  mci.param.setmemorymailbox.health_buffer_physaddr,
1047	  mci.param.setmemorymailbox.health_buffer_size);
1048
1049    if ((error = mly_ioctl(sc, &mci, NULL, 0, &status, NULL, NULL)))
1050	return(error);
1051    if (status != 0)
1052	return(EIO);
1053    sc->mly_state |= MLY_STATE_MMBOX_ACTIVE;
1054    debug(1, "memory mailbox active");
1055    return(0);
1056}
1057
1058/********************************************************************************
1059 * Flush all pending I/O from the controller.
1060 */
1061static int
1062mly_flush(struct mly_softc *sc)
1063{
1064    struct mly_command_ioctl	mci;
1065    u_int8_t			status;
1066    int				error;
1067
1068    debug_called(1);
1069
1070    /* build the ioctl */
1071    bzero(&mci, sizeof(mci));
1072    mci.sub_ioctl = MDACIOCTL_FLUSHDEVICEDATA;
1073    mci.param.deviceoperation.operation_device = MLY_OPDEVICE_PHYSICAL_CONTROLLER;
1074
1075    /* pass it off to the controller */
1076    if ((error = mly_ioctl(sc, &mci, NULL, 0, &status, NULL, NULL)))
1077	return(error);
1078
1079    return((status == 0) ? 0 : EIO);
1080}
1081
1082/********************************************************************************
1083 * Perform an ioctl command.
1084 *
1085 * If (data) is not NULL, the command requires data transfer.  If (*data) is NULL
1086 * the command requires data transfer from the controller, and we will allocate
1087 * a buffer for it.  If (*data) is not NULL, the command requires data transfer
1088 * to the controller.
1089 *
1090 * XXX passing in the whole ioctl structure is ugly.  Better ideas?
1091 *
1092 * XXX we don't even try to handle the case where datasize > 4k.  We should.
1093 */
1094static int
1095mly_ioctl(struct mly_softc *sc, struct mly_command_ioctl *ioctl, void **data, size_t datasize,
1096	  u_int8_t *status, void *sense_buffer, size_t *sense_length)
1097{
1098    struct mly_command		*mc;
1099    struct mly_command_ioctl	*mci;
1100    int				error;
1101
1102    debug_called(1);
1103
1104    mc = NULL;
1105    if (mly_alloc_command(sc, &mc)) {
1106	error = ENOMEM;
1107	goto out;
1108    }
1109
1110    /* copy the ioctl structure, but save some important fields and then fixup */
1111    mci = &mc->mc_packet->ioctl;
1112    ioctl->sense_buffer_address = mci->sense_buffer_address;
1113    ioctl->maximum_sense_size = mci->maximum_sense_size;
1114    *mci = *ioctl;
1115    mci->opcode = MDACMD_IOCTL;
1116    mci->timeout.value = 30;
1117    mci->timeout.scale = MLY_TIMEOUT_SECONDS;
1118
1119    /* handle the data buffer */
1120    if (data != NULL) {
1121	if (*data == NULL) {
1122	    /* allocate data buffer */
1123	    if ((mc->mc_data = malloc(datasize, M_DEVBUF, M_NOWAIT)) == NULL) {
1124		error = ENOMEM;
1125		goto out;
1126	    }
1127	    mc->mc_flags |= MLY_CMD_DATAIN;
1128	} else {
1129	    mc->mc_data = *data;
1130	    mc->mc_flags |= MLY_CMD_DATAOUT;
1131	}
1132	mc->mc_length = datasize;
1133	mc->mc_packet->generic.data_size = datasize;
1134    }
1135
1136    /* run the command */
1137    if ((error = mly_immediate_command(mc)))
1138	goto out;
1139
1140    /* clean up and return any data */
1141    *status = mc->mc_status;
1142    if ((mc->mc_sense > 0) && (sense_buffer != NULL)) {
1143	bcopy(mc->mc_packet, sense_buffer, mc->mc_sense);
1144	*sense_length = mc->mc_sense;
1145	goto out;
1146    }
1147
1148    /* should we return a data pointer? */
1149    if ((data != NULL) && (*data == NULL))
1150	*data = mc->mc_data;
1151
1152    /* command completed OK */
1153    error = 0;
1154
1155out:
1156    if (mc != NULL) {
1157	/* do we need to free a data buffer we allocated? */
1158	if (error && (mc->mc_data != NULL) && (*data == NULL))
1159	    free(mc->mc_data, M_DEVBUF);
1160	mly_release_command(mc);
1161    }
1162    return(error);
1163}
1164
1165/********************************************************************************
1166 * Check for event(s) outstanding in the controller.
1167 */
1168static void
1169mly_check_event(struct mly_softc *sc)
1170{
1171
1172    /*
1173     * The controller may have updated the health status information,
1174     * so check for it here.  Note that the counters are all in host memory,
1175     * so this check is very cheap.  Also note that we depend on checking on
1176     * completion
1177     */
1178    if (sc->mly_mmbox->mmm_health.status.change_counter != sc->mly_event_change) {
1179	sc->mly_event_change = sc->mly_mmbox->mmm_health.status.change_counter;
1180	debug(1, "event change %d, event status update, %d -> %d", sc->mly_event_change,
1181	      sc->mly_event_waiting, sc->mly_mmbox->mmm_health.status.next_event);
1182	sc->mly_event_waiting = sc->mly_mmbox->mmm_health.status.next_event;
1183
1184	/* wake up anyone that might be interested in this */
1185	wakeup(&sc->mly_event_change);
1186    }
1187    if (sc->mly_event_counter != sc->mly_event_waiting)
1188    mly_fetch_event(sc);
1189}
1190
1191/********************************************************************************
1192 * Fetch one event from the controller.
1193 *
1194 * If we fail due to resource starvation, we'll be retried the next time a
1195 * command completes.
1196 */
1197static void
1198mly_fetch_event(struct mly_softc *sc)
1199{
1200    struct mly_command		*mc;
1201    struct mly_command_ioctl	*mci;
1202    int				s;
1203    u_int32_t			event;
1204
1205    debug_called(1);
1206
1207    /* get a command */
1208    if (mly_alloc_command(sc, &mc))
1209	return;
1210
1211    /* set up the data buffer */
1212    if ((mc->mc_data = malloc(sizeof(struct mly_event), M_DEVBUF, M_NOWAIT | M_ZERO)) == NULL) {
1213	mly_release_command(mc);
1214	return;
1215    }
1216    mc->mc_length = sizeof(struct mly_event);
1217    mc->mc_flags |= MLY_CMD_DATAIN;
1218    mc->mc_complete = mly_complete_event;
1219
1220    /*
1221     * Get an event number to fetch.  It's possible that we've raced with another
1222     * context for the last event, in which case there will be no more events.
1223     */
1224    s = splcam();
1225    if (sc->mly_event_counter == sc->mly_event_waiting) {
1226	mly_release_command(mc);
1227	splx(s);
1228	return;
1229    }
1230    event = sc->mly_event_counter++;
1231    splx(s);
1232
1233    /*
1234     * Build the ioctl.
1235     *
1236     * At this point we are committed to sending this request, as it
1237     * will be the only one constructed for this particular event number.
1238     */
1239    mci = (struct mly_command_ioctl *)&mc->mc_packet->ioctl;
1240    mci->opcode = MDACMD_IOCTL;
1241    mci->data_size = sizeof(struct mly_event);
1242    mci->addr.phys.lun = (event >> 16) & 0xff;
1243    mci->addr.phys.target = (event >> 24) & 0xff;
1244    mci->addr.phys.channel = 0;
1245    mci->addr.phys.controller = 0;
1246    mci->timeout.value = 30;
1247    mci->timeout.scale = MLY_TIMEOUT_SECONDS;
1248    mci->sub_ioctl = MDACIOCTL_GETEVENT;
1249    mci->param.getevent.sequence_number_low = event & 0xffff;
1250
1251    debug(1, "fetch event %u", event);
1252
1253    /*
1254     * Submit the command.
1255     *
1256     * Note that failure of mly_start() will result in this event never being
1257     * fetched.
1258     */
1259    if (mly_start(mc) != 0) {
1260	mly_printf(sc, "couldn't fetch event %u\n", event);
1261	mly_release_command(mc);
1262    }
1263}
1264
1265/********************************************************************************
1266 * Handle the completion of an event poll.
1267 */
1268static void
1269mly_complete_event(struct mly_command *mc)
1270{
1271    struct mly_softc	*sc = mc->mc_sc;
1272    struct mly_event	*me = (struct mly_event *)mc->mc_data;
1273
1274    debug_called(1);
1275
1276    /*
1277     * If the event was successfully fetched, process it.
1278     */
1279    if (mc->mc_status == SCSI_STATUS_OK) {
1280	mly_process_event(sc, me);
1281	free(me, M_DEVBUF);
1282    }
1283    mly_release_command(mc);
1284
1285    /*
1286     * Check for another event.
1287     */
1288    mly_check_event(sc);
1289}
1290
1291/********************************************************************************
1292 * Process a controller event.
1293 */
1294static void
1295mly_process_event(struct mly_softc *sc, struct mly_event *me)
1296{
1297    struct scsi_sense_data_fixed *ssd;
1298    char			 *fp, *tp;
1299    int				 bus, target, event, class, action;
1300
1301    ssd = (struct scsi_sense_data_fixed *)&me->sense[0];
1302
1303    /*
1304     * Errors can be reported using vendor-unique sense data.  In this case, the
1305     * event code will be 0x1c (Request sense data present), the sense key will
1306     * be 0x09 (vendor specific), the MSB of the ASC will be set, and the
1307     * actual event code will be a 16-bit value comprised of the ASCQ (low byte)
1308     * and low seven bits of the ASC (low seven bits of the high byte).
1309     */
1310    if ((me->code == 0x1c) &&
1311	((ssd->flags & SSD_KEY) == SSD_KEY_Vendor_Specific) &&
1312	(ssd->add_sense_code & 0x80)) {
1313	event = ((int)(ssd->add_sense_code & ~0x80) << 8) + ssd->add_sense_code_qual;
1314    } else {
1315	event = me->code;
1316    }
1317
1318    /* look up event, get codes */
1319    fp = mly_describe_code(mly_table_event, event);
1320
1321    debug(1, "Event %d  code 0x%x", me->sequence_number, me->code);
1322
1323    /* quiet event? */
1324    class = fp[0];
1325    if (isupper(class) && bootverbose)
1326	class = tolower(class);
1327
1328    /* get action code, text string */
1329    action = fp[1];
1330    tp = &fp[2];
1331
1332    /*
1333     * Print some information about the event.
1334     *
1335     * This code uses a table derived from the corresponding portion of the Linux
1336     * driver, and thus the parser is very similar.
1337     */
1338    switch(class) {
1339    case 'p':		/* error on physical device */
1340	mly_printf(sc, "physical device %d:%d %s\n", me->channel, me->target, tp);
1341	if (action == 'r')
1342	    sc->mly_btl[me->channel][me->target].mb_flags |= MLY_BTL_RESCAN;
1343	break;
1344    case 'l':		/* error on logical unit */
1345    case 'm':		/* message about logical unit */
1346	bus = MLY_LOGDEV_BUS(sc, me->lun);
1347	target = MLY_LOGDEV_TARGET(sc, me->lun);
1348	mly_name_device(sc, bus, target);
1349	mly_printf(sc, "logical device %d (%s) %s\n", me->lun, sc->mly_btl[bus][target].mb_name, tp);
1350	if (action == 'r')
1351	    sc->mly_btl[bus][target].mb_flags |= MLY_BTL_RESCAN;
1352	break;
1353      break;
1354    case 's':		/* report of sense data */
1355	if (((ssd->flags & SSD_KEY) == SSD_KEY_NO_SENSE) ||
1356	    (((ssd->flags & SSD_KEY) == SSD_KEY_NOT_READY) &&
1357	     (ssd->add_sense_code == 0x04) &&
1358	     ((ssd->add_sense_code_qual == 0x01) || (ssd->add_sense_code_qual == 0x02))))
1359	    break;	/* ignore NO_SENSE or NOT_READY in one case */
1360
1361	mly_printf(sc, "physical device %d:%d %s\n", me->channel, me->target, tp);
1362	mly_printf(sc, "  sense key %d  asc %02x  ascq %02x\n",
1363		      ssd->flags & SSD_KEY, ssd->add_sense_code, ssd->add_sense_code_qual);
1364	mly_printf(sc, "  info %4D  csi %4D\n", ssd->info, "", ssd->cmd_spec_info, "");
1365	if (action == 'r')
1366	    sc->mly_btl[me->channel][me->target].mb_flags |= MLY_BTL_RESCAN;
1367	break;
1368    case 'e':
1369	mly_printf(sc, tp, me->target, me->lun);
1370	printf("\n");
1371	break;
1372    case 'c':
1373	mly_printf(sc, "controller %s\n", tp);
1374	break;
1375    case '?':
1376	mly_printf(sc, "%s - %d\n", tp, me->code);
1377	break;
1378    default:	/* probably a 'noisy' event being ignored */
1379	break;
1380    }
1381}
1382
1383/********************************************************************************
1384 * Perform periodic activities.
1385 */
1386static void
1387mly_periodic(void *data)
1388{
1389    struct mly_softc	*sc = (struct mly_softc *)data;
1390    int			bus, target;
1391
1392    debug_called(2);
1393
1394    /*
1395     * Scan devices.
1396     */
1397    for (bus = 0; bus < sc->mly_cam_channels; bus++) {
1398	if (MLY_BUS_IS_VALID(sc, bus)) {
1399	    for (target = 0; target < MLY_MAX_TARGETS; target++) {
1400
1401		/* ignore the controller in this scan */
1402		if (target == sc->mly_controllerparam->initiator_id)
1403		    continue;
1404
1405		/* perform device rescan? */
1406		if (sc->mly_btl[bus][target].mb_flags & MLY_BTL_RESCAN)
1407		    mly_rescan_btl(sc, bus, target);
1408	    }
1409	}
1410    }
1411
1412    /* check for controller events */
1413    mly_check_event(sc);
1414
1415    /* reschedule ourselves */
1416    sc->mly_periodic = timeout(mly_periodic, sc, MLY_PERIODIC_INTERVAL * hz);
1417}
1418
1419/********************************************************************************
1420 ********************************************************************************
1421                                                               Command Processing
1422 ********************************************************************************
1423 ********************************************************************************/
1424
1425/********************************************************************************
1426 * Run a command and wait for it to complete.
1427 *
1428 */
1429static int
1430mly_immediate_command(struct mly_command *mc)
1431{
1432    struct mly_softc	*sc = mc->mc_sc;
1433    int			error, s;
1434
1435    debug_called(1);
1436
1437    /* spinning at splcam is ugly, but we're only used during controller init */
1438    s = splcam();
1439    if ((error = mly_start(mc))) {
1440	splx(s);
1441	return(error);
1442    }
1443
1444    if (sc->mly_state & MLY_STATE_INTERRUPTS_ON) {
1445	/* sleep on the command */
1446	while(!(mc->mc_flags & MLY_CMD_COMPLETE)) {
1447	    tsleep(mc, PRIBIO, "mlywait", 0);
1448	}
1449    } else {
1450	/* spin and collect status while we do */
1451	while(!(mc->mc_flags & MLY_CMD_COMPLETE)) {
1452	    mly_done(mc->mc_sc);
1453	}
1454    }
1455    splx(s);
1456    return(0);
1457}
1458
1459/********************************************************************************
1460 * Deliver a command to the controller.
1461 *
1462 * XXX it would be good to just queue commands that we can't submit immediately
1463 *     and send them later, but we probably want a wrapper for that so that
1464 *     we don't hang on a failed submission for an immediate command.
1465 */
1466static int
1467mly_start(struct mly_command *mc)
1468{
1469    struct mly_softc		*sc = mc->mc_sc;
1470    union mly_command_packet	*pkt;
1471    int				s;
1472
1473    debug_called(2);
1474
1475    /*
1476     * Set the command up for delivery to the controller.
1477     */
1478    mly_map_command(mc);
1479    mc->mc_packet->generic.command_id = mc->mc_slot;
1480
1481#ifdef MLY_DEBUG
1482    mc->mc_timestamp = time_second;
1483#endif
1484
1485    s = splcam();
1486
1487    /*
1488     * Do we have to use the hardware mailbox?
1489     */
1490    if (!(sc->mly_state & MLY_STATE_MMBOX_ACTIVE)) {
1491	/*
1492	 * Check to see if the controller is ready for us.
1493	 */
1494	if (MLY_IDBR_TRUE(sc, MLY_HM_CMDSENT)) {
1495	    splx(s);
1496	    return(EBUSY);
1497	}
1498	mc->mc_flags |= MLY_CMD_BUSY;
1499
1500	/*
1501	 * It's ready, send the command.
1502	 */
1503	MLY_SET_MBOX(sc, sc->mly_command_mailbox, &mc->mc_packetphys);
1504	MLY_SET_REG(sc, sc->mly_idbr, MLY_HM_CMDSENT);
1505
1506    } else {	/* use memory-mailbox mode */
1507
1508	pkt = &sc->mly_mmbox->mmm_command[sc->mly_mmbox_command_index];
1509
1510	/* check to see if the next index is free yet */
1511	if (pkt->mmbox.flag != 0) {
1512	    splx(s);
1513	    return(EBUSY);
1514	}
1515	mc->mc_flags |= MLY_CMD_BUSY;
1516
1517	/* copy in new command */
1518	bcopy(mc->mc_packet->mmbox.data, pkt->mmbox.data, sizeof(pkt->mmbox.data));
1519	/* barrier to ensure completion of previous write before we write the flag */
1520	bus_space_barrier(sc->mly_btag, sc->mly_bhandle, 0, 0,
1521	    BUS_SPACE_BARRIER_WRITE);
1522	/* copy flag last */
1523	pkt->mmbox.flag = mc->mc_packet->mmbox.flag;
1524	/* barrier to ensure completion of previous write before we notify the controller */
1525	bus_space_barrier(sc->mly_btag, sc->mly_bhandle, 0, 0,
1526	    BUS_SPACE_BARRIER_WRITE);
1527
1528	/* signal controller, update index */
1529	MLY_SET_REG(sc, sc->mly_idbr, MLY_AM_CMDSENT);
1530	sc->mly_mmbox_command_index = (sc->mly_mmbox_command_index + 1) % MLY_MMBOX_COMMANDS;
1531    }
1532
1533    mly_enqueue_busy(mc);
1534    splx(s);
1535    return(0);
1536}
1537
1538/********************************************************************************
1539 * Pick up command status from the controller, schedule a completion event
1540 */
1541static void
1542mly_done(struct mly_softc *sc)
1543{
1544    struct mly_command		*mc;
1545    union mly_status_packet	*sp;
1546    u_int16_t			slot;
1547    int				s, worked;
1548
1549    s = splcam();
1550    worked = 0;
1551
1552    /* pick up hardware-mailbox commands */
1553    if (MLY_ODBR_TRUE(sc, MLY_HM_STSREADY)) {
1554	slot = MLY_GET_REG2(sc, sc->mly_status_mailbox);
1555	if (slot < MLY_SLOT_MAX) {
1556	    mc = &sc->mly_command[slot - MLY_SLOT_START];
1557	    mc->mc_status = MLY_GET_REG(sc, sc->mly_status_mailbox + 2);
1558	    mc->mc_sense = MLY_GET_REG(sc, sc->mly_status_mailbox + 3);
1559	    mc->mc_resid = MLY_GET_REG4(sc, sc->mly_status_mailbox + 4);
1560	    mly_remove_busy(mc);
1561	    mc->mc_flags &= ~MLY_CMD_BUSY;
1562	    mly_enqueue_complete(mc);
1563	    worked = 1;
1564	} else {
1565	    /* slot 0xffff may mean "extremely bogus command" */
1566	    mly_printf(sc, "got HM completion for illegal slot %u\n", slot);
1567	}
1568	/* unconditionally acknowledge status */
1569	MLY_SET_REG(sc, sc->mly_odbr, MLY_HM_STSREADY);
1570	MLY_SET_REG(sc, sc->mly_idbr, MLY_HM_STSACK);
1571    }
1572
1573    /* pick up memory-mailbox commands */
1574    if (MLY_ODBR_TRUE(sc, MLY_AM_STSREADY)) {
1575	for (;;) {
1576	    sp = &sc->mly_mmbox->mmm_status[sc->mly_mmbox_status_index];
1577
1578	    /* check for more status */
1579	    if (sp->mmbox.flag == 0)
1580		break;
1581
1582	    /* get slot number */
1583	    slot = sp->status.command_id;
1584	    if (slot < MLY_SLOT_MAX) {
1585		mc = &sc->mly_command[slot - MLY_SLOT_START];
1586		mc->mc_status = sp->status.status;
1587		mc->mc_sense = sp->status.sense_length;
1588		mc->mc_resid = sp->status.residue;
1589		mly_remove_busy(mc);
1590		mc->mc_flags &= ~MLY_CMD_BUSY;
1591		mly_enqueue_complete(mc);
1592		worked = 1;
1593	    } else {
1594		/* slot 0xffff may mean "extremely bogus command" */
1595		mly_printf(sc, "got AM completion for illegal slot %u at %d\n",
1596			   slot, sc->mly_mmbox_status_index);
1597	    }
1598
1599	    /* clear and move to next index */
1600	    sp->mmbox.flag = 0;
1601	    sc->mly_mmbox_status_index = (sc->mly_mmbox_status_index + 1) % MLY_MMBOX_STATUS;
1602	}
1603	/* acknowledge that we have collected status value(s) */
1604	MLY_SET_REG(sc, sc->mly_odbr, MLY_AM_STSREADY);
1605    }
1606
1607    splx(s);
1608    if (worked) {
1609	if (sc->mly_state & MLY_STATE_INTERRUPTS_ON)
1610	    taskqueue_enqueue(taskqueue_swi_giant, &sc->mly_task_complete);
1611	else
1612	    mly_complete(sc, 0);
1613    }
1614}
1615
1616/********************************************************************************
1617 * Process completed commands
1618 */
1619static void
1620mly_complete(void *context, int pending)
1621{
1622    struct mly_softc	*sc = (struct mly_softc *)context;
1623    struct mly_command	*mc;
1624    void	        (* mc_complete)(struct mly_command *mc);
1625
1626
1627    debug_called(2);
1628
1629    /*
1630     * Spin pulling commands off the completed queue and processing them.
1631     */
1632    while ((mc = mly_dequeue_complete(sc)) != NULL) {
1633
1634	/*
1635	 * Free controller resources, mark command complete.
1636	 *
1637	 * Note that as soon as we mark the command complete, it may be freed
1638	 * out from under us, so we need to save the mc_complete field in
1639	 * order to later avoid dereferencing mc.  (We would not expect to
1640	 * have a polling/sleeping consumer with mc_complete != NULL).
1641	 */
1642	mly_unmap_command(mc);
1643	mc_complete = mc->mc_complete;
1644	mc->mc_flags |= MLY_CMD_COMPLETE;
1645
1646	/*
1647	 * Call completion handler or wake up sleeping consumer.
1648	 */
1649	if (mc_complete != NULL) {
1650	    mc_complete(mc);
1651	} else {
1652	    wakeup(mc);
1653	}
1654    }
1655
1656    /*
1657     * XXX if we are deferring commands due to controller-busy status, we should
1658     *     retry submitting them here.
1659     */
1660}
1661
1662/********************************************************************************
1663 ********************************************************************************
1664                                                        Command Buffer Management
1665 ********************************************************************************
1666 ********************************************************************************/
1667
1668/********************************************************************************
1669 * Allocate a command.
1670 */
1671static int
1672mly_alloc_command(struct mly_softc *sc, struct mly_command **mcp)
1673{
1674    struct mly_command	*mc;
1675
1676    debug_called(3);
1677
1678    if ((mc = mly_dequeue_free(sc)) == NULL)
1679	return(ENOMEM);
1680
1681    *mcp = mc;
1682    return(0);
1683}
1684
1685/********************************************************************************
1686 * Release a command back to the freelist.
1687 */
1688static void
1689mly_release_command(struct mly_command *mc)
1690{
1691    debug_called(3);
1692
1693    /*
1694     * Fill in parts of the command that may cause confusion if
1695     * a consumer doesn't when we are later allocated.
1696     */
1697    mc->mc_data = NULL;
1698    mc->mc_flags = 0;
1699    mc->mc_complete = NULL;
1700    mc->mc_private = NULL;
1701
1702    /*
1703     * By default, we set up to overwrite the command packet with
1704     * sense information.
1705     */
1706    mc->mc_packet->generic.sense_buffer_address = mc->mc_packetphys;
1707    mc->mc_packet->generic.maximum_sense_size = sizeof(union mly_command_packet);
1708
1709    mly_enqueue_free(mc);
1710}
1711
1712/********************************************************************************
1713 * Map helper for command allocation.
1714 */
1715static void
1716mly_alloc_commands_map(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1717{
1718    struct mly_softc	*sc = (struct mly_softc *)arg;
1719
1720    debug_called(1);
1721
1722    sc->mly_packetphys = segs[0].ds_addr;
1723}
1724
1725/********************************************************************************
1726 * Allocate and initialise command and packet structures.
1727 *
1728 * If the controller supports fewer than MLY_MAX_COMMANDS commands, limit our
1729 * allocation to that number.  If we don't yet know how many commands the
1730 * controller supports, allocate a very small set (suitable for initialisation
1731 * purposes only).
1732 */
1733static int
1734mly_alloc_commands(struct mly_softc *sc)
1735{
1736    struct mly_command		*mc;
1737    int				i, ncmd;
1738
1739    if (sc->mly_controllerinfo == NULL) {
1740	ncmd = 4;
1741    } else {
1742	ncmd = min(MLY_MAX_COMMANDS, sc->mly_controllerinfo->maximum_parallel_commands);
1743    }
1744
1745    /*
1746     * Allocate enough space for all the command packets in one chunk and
1747     * map them permanently into controller-visible space.
1748     */
1749    if (bus_dmamem_alloc(sc->mly_packet_dmat, (void **)&sc->mly_packet,
1750			 BUS_DMA_NOWAIT, &sc->mly_packetmap)) {
1751	return(ENOMEM);
1752    }
1753    if (bus_dmamap_load(sc->mly_packet_dmat, sc->mly_packetmap, sc->mly_packet,
1754			ncmd * sizeof(union mly_command_packet),
1755			mly_alloc_commands_map, sc, BUS_DMA_NOWAIT) != 0)
1756	return (ENOMEM);
1757
1758    for (i = 0; i < ncmd; i++) {
1759	mc = &sc->mly_command[i];
1760	bzero(mc, sizeof(*mc));
1761	mc->mc_sc = sc;
1762	mc->mc_slot = MLY_SLOT_START + i;
1763	mc->mc_packet = sc->mly_packet + i;
1764	mc->mc_packetphys = sc->mly_packetphys + (i * sizeof(union mly_command_packet));
1765	if (!bus_dmamap_create(sc->mly_buffer_dmat, 0, &mc->mc_datamap))
1766	    mly_release_command(mc);
1767    }
1768    return(0);
1769}
1770
1771/********************************************************************************
1772 * Free all the storage held by commands.
1773 *
1774 * Must be called with all commands on the free list.
1775 */
1776static void
1777mly_release_commands(struct mly_softc *sc)
1778{
1779    struct mly_command	*mc;
1780
1781    /* throw away command buffer DMA maps */
1782    while (mly_alloc_command(sc, &mc) == 0)
1783	bus_dmamap_destroy(sc->mly_buffer_dmat, mc->mc_datamap);
1784
1785    /* release the packet storage */
1786    if (sc->mly_packet != NULL) {
1787	bus_dmamap_unload(sc->mly_packet_dmat, sc->mly_packetmap);
1788	bus_dmamem_free(sc->mly_packet_dmat, sc->mly_packet, sc->mly_packetmap);
1789	sc->mly_packet = NULL;
1790    }
1791}
1792
1793
1794/********************************************************************************
1795 * Command-mapping helper function - populate this command's s/g table
1796 * with the s/g entries for its data.
1797 */
1798static void
1799mly_map_command_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1800{
1801    struct mly_command		*mc = (struct mly_command *)arg;
1802    struct mly_softc		*sc = mc->mc_sc;
1803    struct mly_command_generic	*gen = &(mc->mc_packet->generic);
1804    struct mly_sg_entry		*sg;
1805    int				i, tabofs;
1806
1807    debug_called(2);
1808
1809    /* can we use the transfer structure directly? */
1810    if (nseg <= 2) {
1811	sg = &gen->transfer.direct.sg[0];
1812	gen->command_control.extended_sg_table = 0;
1813    } else {
1814	tabofs = ((mc->mc_slot - MLY_SLOT_START) * MLY_MAX_SGENTRIES);
1815	sg = sc->mly_sg_table + tabofs;
1816	gen->transfer.indirect.entries[0] = nseg;
1817	gen->transfer.indirect.table_physaddr[0] = sc->mly_sg_busaddr + (tabofs * sizeof(struct mly_sg_entry));
1818	gen->command_control.extended_sg_table = 1;
1819    }
1820
1821    /* copy the s/g table */
1822    for (i = 0; i < nseg; i++) {
1823	sg[i].physaddr = segs[i].ds_addr;
1824	sg[i].length = segs[i].ds_len;
1825    }
1826
1827}
1828
1829#if 0
1830/********************************************************************************
1831 * Command-mapping helper function - save the cdb's physical address.
1832 *
1833 * We don't support 'large' SCSI commands at this time, so this is unused.
1834 */
1835static void
1836mly_map_command_cdb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1837{
1838    struct mly_command			*mc = (struct mly_command *)arg;
1839
1840    debug_called(2);
1841
1842    /* XXX can we safely assume that a CDB will never cross a page boundary? */
1843    if ((segs[0].ds_addr % PAGE_SIZE) >
1844	((segs[0].ds_addr + mc->mc_packet->scsi_large.cdb_length) % PAGE_SIZE))
1845	panic("cdb crosses page boundary");
1846
1847    /* fix up fields in the command packet */
1848    mc->mc_packet->scsi_large.cdb_physaddr = segs[0].ds_addr;
1849}
1850#endif
1851
1852/********************************************************************************
1853 * Map a command into controller-visible space
1854 */
1855static void
1856mly_map_command(struct mly_command *mc)
1857{
1858    struct mly_softc	*sc = mc->mc_sc;
1859
1860    debug_called(2);
1861
1862    /* don't map more than once */
1863    if (mc->mc_flags & MLY_CMD_MAPPED)
1864	return;
1865
1866    /* does the command have a data buffer? */
1867    if (mc->mc_data != NULL) {
1868	if (mc->mc_flags & MLY_CMD_CCB)
1869		bus_dmamap_load_ccb(sc->mly_buffer_dmat, mc->mc_datamap,
1870				mc->mc_data, mly_map_command_sg, mc, 0);
1871	else
1872		bus_dmamap_load(sc->mly_buffer_dmat, mc->mc_datamap,
1873				mc->mc_data, mc->mc_length,
1874				mly_map_command_sg, mc, 0);
1875	if (mc->mc_flags & MLY_CMD_DATAIN)
1876	    bus_dmamap_sync(sc->mly_buffer_dmat, mc->mc_datamap, BUS_DMASYNC_PREREAD);
1877	if (mc->mc_flags & MLY_CMD_DATAOUT)
1878	    bus_dmamap_sync(sc->mly_buffer_dmat, mc->mc_datamap, BUS_DMASYNC_PREWRITE);
1879    }
1880    mc->mc_flags |= MLY_CMD_MAPPED;
1881}
1882
1883/********************************************************************************
1884 * Unmap a command from controller-visible space
1885 */
1886static void
1887mly_unmap_command(struct mly_command *mc)
1888{
1889    struct mly_softc	*sc = mc->mc_sc;
1890
1891    debug_called(2);
1892
1893    if (!(mc->mc_flags & MLY_CMD_MAPPED))
1894	return;
1895
1896    /* does the command have a data buffer? */
1897    if (mc->mc_data != NULL) {
1898	if (mc->mc_flags & MLY_CMD_DATAIN)
1899	    bus_dmamap_sync(sc->mly_buffer_dmat, mc->mc_datamap, BUS_DMASYNC_POSTREAD);
1900	if (mc->mc_flags & MLY_CMD_DATAOUT)
1901	    bus_dmamap_sync(sc->mly_buffer_dmat, mc->mc_datamap, BUS_DMASYNC_POSTWRITE);
1902
1903	bus_dmamap_unload(sc->mly_buffer_dmat, mc->mc_datamap);
1904    }
1905    mc->mc_flags &= ~MLY_CMD_MAPPED;
1906}
1907
1908
1909/********************************************************************************
1910 ********************************************************************************
1911                                                                    CAM interface
1912 ********************************************************************************
1913 ********************************************************************************/
1914
1915/********************************************************************************
1916 * Attach the physical and virtual SCSI busses to CAM.
1917 *
1918 * Physical bus numbering starts from 0, virtual bus numbering from one greater
1919 * than the highest physical bus.  Physical busses are only registered if
1920 * the kernel environment variable "hw.mly.register_physical_channels" is set.
1921 *
1922 * When we refer to a "bus", we are referring to the bus number registered with
1923 * the SIM, wheras a "channel" is a channel number given to the adapter.  In order
1924 * to keep things simple, we map these 1:1, so "bus" and "channel" may be used
1925 * interchangeably.
1926 */
1927static int
1928mly_cam_attach(struct mly_softc *sc)
1929{
1930    struct cam_devq	*devq;
1931    int			chn, i;
1932
1933    debug_called(1);
1934
1935    /*
1936     * Allocate a devq for all our channels combined.
1937     */
1938    if ((devq = cam_simq_alloc(sc->mly_controllerinfo->maximum_parallel_commands)) == NULL) {
1939	mly_printf(sc, "can't allocate CAM SIM queue\n");
1940	return(ENOMEM);
1941    }
1942
1943    /*
1944     * If physical channel registration has been requested, register these first.
1945     * Note that we enable tagged command queueing for physical channels.
1946     */
1947    if (testenv("hw.mly.register_physical_channels")) {
1948	chn = 0;
1949	for (i = 0; i < sc->mly_controllerinfo->physical_channels_present; i++, chn++) {
1950
1951	    if ((sc->mly_cam_sim[chn] = cam_sim_alloc(mly_cam_action, mly_cam_poll, "mly", sc,
1952						      device_get_unit(sc->mly_dev),
1953						      &Giant,
1954						      sc->mly_controllerinfo->maximum_parallel_commands,
1955						      1, devq)) == NULL) {
1956		return(ENOMEM);
1957	    }
1958	    if (xpt_bus_register(sc->mly_cam_sim[chn], sc->mly_dev, chn)) {
1959		mly_printf(sc, "CAM XPT phsyical channel registration failed\n");
1960		return(ENXIO);
1961	    }
1962	    debug(1, "registered physical channel %d", chn);
1963	}
1964    }
1965
1966    /*
1967     * Register our virtual channels, with bus numbers matching channel numbers.
1968     */
1969    chn = sc->mly_controllerinfo->physical_channels_present;
1970    for (i = 0; i < sc->mly_controllerinfo->virtual_channels_present; i++, chn++) {
1971	if ((sc->mly_cam_sim[chn] = cam_sim_alloc(mly_cam_action, mly_cam_poll, "mly", sc,
1972						  device_get_unit(sc->mly_dev),
1973						  &Giant,
1974						  sc->mly_controllerinfo->maximum_parallel_commands,
1975						  0, devq)) == NULL) {
1976	    return(ENOMEM);
1977	}
1978	if (xpt_bus_register(sc->mly_cam_sim[chn], sc->mly_dev, chn)) {
1979	    mly_printf(sc, "CAM XPT virtual channel registration failed\n");
1980	    return(ENXIO);
1981	}
1982	debug(1, "registered virtual channel %d", chn);
1983    }
1984
1985    /*
1986     * This is the total number of channels that (might have been) registered with
1987     * CAM.  Some may not have been; check the mly_cam_sim array to be certain.
1988     */
1989    sc->mly_cam_channels = sc->mly_controllerinfo->physical_channels_present +
1990	sc->mly_controllerinfo->virtual_channels_present;
1991
1992    return(0);
1993}
1994
1995/********************************************************************************
1996 * Detach from CAM
1997 */
1998static void
1999mly_cam_detach(struct mly_softc *sc)
2000{
2001    int		i;
2002
2003    debug_called(1);
2004
2005    for (i = 0; i < sc->mly_cam_channels; i++) {
2006	if (sc->mly_cam_sim[i] != NULL) {
2007	    xpt_bus_deregister(cam_sim_path(sc->mly_cam_sim[i]));
2008	    cam_sim_free(sc->mly_cam_sim[i], 0);
2009	}
2010    }
2011    if (sc->mly_cam_devq != NULL)
2012	cam_simq_free(sc->mly_cam_devq);
2013}
2014
2015/************************************************************************
2016 * Rescan a device.
2017 */
2018static void
2019mly_cam_rescan_btl(struct mly_softc *sc, int bus, int target)
2020{
2021    union ccb	*ccb;
2022
2023    debug_called(1);
2024
2025    if ((ccb = xpt_alloc_ccb()) == NULL) {
2026	mly_printf(sc, "rescan failed (can't allocate CCB)\n");
2027	return;
2028    }
2029    if (xpt_create_path(&ccb->ccb_h.path, xpt_periph,
2030	    cam_sim_path(sc->mly_cam_sim[bus]), target, 0) != CAM_REQ_CMP) {
2031	mly_printf(sc, "rescan failed (can't create path)\n");
2032	xpt_free_ccb(ccb);
2033	return;
2034    }
2035    debug(1, "rescan target %d:%d", bus, target);
2036    xpt_rescan(ccb);
2037}
2038
2039/********************************************************************************
2040 * Handle an action requested by CAM
2041 */
2042static void
2043mly_cam_action(struct cam_sim *sim, union ccb *ccb)
2044{
2045    struct mly_softc	*sc = cam_sim_softc(sim);
2046
2047    debug_called(2);
2048
2049    switch (ccb->ccb_h.func_code) {
2050
2051	/* perform SCSI I/O */
2052    case XPT_SCSI_IO:
2053	if (!mly_cam_action_io(sim, (struct ccb_scsiio *)&ccb->csio))
2054	    return;
2055	break;
2056
2057	/* perform geometry calculations */
2058    case XPT_CALC_GEOMETRY:
2059    {
2060	struct ccb_calc_geometry	*ccg = &ccb->ccg;
2061        u_int32_t			secs_per_cylinder;
2062
2063	debug(2, "XPT_CALC_GEOMETRY %d:%d:%d", cam_sim_bus(sim), ccb->ccb_h.target_id, ccb->ccb_h.target_lun);
2064
2065	if (sc->mly_controllerparam->bios_geometry == MLY_BIOSGEOM_8G) {
2066	    ccg->heads = 255;
2067            ccg->secs_per_track = 63;
2068	} else {				/* MLY_BIOSGEOM_2G */
2069	    ccg->heads = 128;
2070            ccg->secs_per_track = 32;
2071	}
2072	secs_per_cylinder = ccg->heads * ccg->secs_per_track;
2073        ccg->cylinders = ccg->volume_size / secs_per_cylinder;
2074        ccb->ccb_h.status = CAM_REQ_CMP;
2075        break;
2076    }
2077
2078	/* handle path attribute inquiry */
2079    case XPT_PATH_INQ:
2080    {
2081	struct ccb_pathinq	*cpi = &ccb->cpi;
2082
2083	debug(2, "XPT_PATH_INQ %d:%d:%d", cam_sim_bus(sim), ccb->ccb_h.target_id, ccb->ccb_h.target_lun);
2084
2085	cpi->version_num = 1;
2086	cpi->hba_inquiry = PI_TAG_ABLE;		/* XXX extra flags for physical channels? */
2087	cpi->target_sprt = 0;
2088	cpi->hba_misc = 0;
2089	cpi->max_target = MLY_MAX_TARGETS - 1;
2090	cpi->max_lun = MLY_MAX_LUNS - 1;
2091	cpi->initiator_id = sc->mly_controllerparam->initiator_id;
2092	strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
2093        strncpy(cpi->hba_vid, "FreeBSD", HBA_IDLEN);
2094        strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
2095        cpi->unit_number = cam_sim_unit(sim);
2096        cpi->bus_id = cam_sim_bus(sim);
2097	cpi->base_transfer_speed = 132 * 1024;	/* XXX what to set this to? */
2098	cpi->transport = XPORT_SPI;
2099	cpi->transport_version = 2;
2100	cpi->protocol = PROTO_SCSI;
2101	cpi->protocol_version = SCSI_REV_2;
2102	ccb->ccb_h.status = CAM_REQ_CMP;
2103	break;
2104    }
2105
2106    case XPT_GET_TRAN_SETTINGS:
2107    {
2108	struct ccb_trans_settings	*cts = &ccb->cts;
2109	int				bus, target;
2110	struct ccb_trans_settings_scsi *scsi = &cts->proto_specific.scsi;
2111	struct ccb_trans_settings_spi *spi = &cts->xport_specific.spi;
2112
2113	cts->protocol = PROTO_SCSI;
2114	cts->protocol_version = SCSI_REV_2;
2115	cts->transport = XPORT_SPI;
2116	cts->transport_version = 2;
2117
2118	scsi->flags = 0;
2119	scsi->valid = 0;
2120	spi->flags = 0;
2121	spi->valid = 0;
2122
2123	bus = cam_sim_bus(sim);
2124	target = cts->ccb_h.target_id;
2125	debug(2, "XPT_GET_TRAN_SETTINGS %d:%d", bus, target);
2126	/* logical device? */
2127	if (sc->mly_btl[bus][target].mb_flags & MLY_BTL_LOGICAL) {
2128	    /* nothing special for these */
2129	/* physical device? */
2130	} else if (sc->mly_btl[bus][target].mb_flags & MLY_BTL_PHYSICAL) {
2131	    /* allow CAM to try tagged transactions */
2132	    scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB;
2133	    scsi->valid |= CTS_SCSI_VALID_TQ;
2134
2135	    /* convert speed (MHz) to usec */
2136	    if (sc->mly_btl[bus][target].mb_speed == 0) {
2137		spi->sync_period = 1000000 / 5;
2138	    } else {
2139		spi->sync_period = 1000000 / sc->mly_btl[bus][target].mb_speed;
2140	    }
2141
2142	    /* convert bus width to CAM internal encoding */
2143	    switch (sc->mly_btl[bus][target].mb_width) {
2144	    case 32:
2145		spi->bus_width = MSG_EXT_WDTR_BUS_32_BIT;
2146		break;
2147	    case 16:
2148		spi->bus_width = MSG_EXT_WDTR_BUS_16_BIT;
2149		break;
2150	    case 8:
2151	    default:
2152		spi->bus_width = MSG_EXT_WDTR_BUS_8_BIT;
2153		break;
2154	    }
2155	    spi->valid |= CTS_SPI_VALID_SYNC_RATE | CTS_SPI_VALID_BUS_WIDTH;
2156
2157	    /* not a device, bail out */
2158	} else {
2159	    cts->ccb_h.status = CAM_REQ_CMP_ERR;
2160	    break;
2161	}
2162
2163	/* disconnect always OK */
2164	spi->flags |= CTS_SPI_FLAGS_DISC_ENB;
2165	spi->valid |= CTS_SPI_VALID_DISC;
2166
2167	cts->ccb_h.status = CAM_REQ_CMP;
2168	break;
2169    }
2170
2171    default:		/* we can't do this */
2172	debug(2, "unspported func_code = 0x%x", ccb->ccb_h.func_code);
2173	ccb->ccb_h.status = CAM_REQ_INVALID;
2174	break;
2175    }
2176
2177    xpt_done(ccb);
2178}
2179
2180/********************************************************************************
2181 * Handle an I/O operation requested by CAM
2182 */
2183static int
2184mly_cam_action_io(struct cam_sim *sim, struct ccb_scsiio *csio)
2185{
2186    struct mly_softc			*sc = cam_sim_softc(sim);
2187    struct mly_command			*mc;
2188    struct mly_command_scsi_small	*ss;
2189    int					bus, target;
2190    int					error;
2191    int					s;
2192
2193    bus = cam_sim_bus(sim);
2194    target = csio->ccb_h.target_id;
2195
2196    debug(2, "XPT_SCSI_IO %d:%d:%d", bus, target, csio->ccb_h.target_lun);
2197
2198    /* validate bus number */
2199    if (!MLY_BUS_IS_VALID(sc, bus)) {
2200	debug(0, " invalid bus %d", bus);
2201	csio->ccb_h.status = CAM_REQ_CMP_ERR;
2202    }
2203
2204    /*  check for I/O attempt to a protected device */
2205    if (sc->mly_btl[bus][target].mb_flags & MLY_BTL_PROTECTED) {
2206	debug(2, "  device protected");
2207	csio->ccb_h.status = CAM_REQ_CMP_ERR;
2208    }
2209
2210    /* check for I/O attempt to nonexistent device */
2211    if (!(sc->mly_btl[bus][target].mb_flags & (MLY_BTL_LOGICAL | MLY_BTL_PHYSICAL))) {
2212	debug(2, "  device %d:%d does not exist", bus, target);
2213	csio->ccb_h.status = CAM_REQ_CMP_ERR;
2214    }
2215
2216    /* XXX increase if/when we support large SCSI commands */
2217    if (csio->cdb_len > MLY_CMD_SCSI_SMALL_CDB) {
2218	debug(0, "  command too large (%d > %d)", csio->cdb_len, MLY_CMD_SCSI_SMALL_CDB);
2219	csio->ccb_h.status = CAM_REQ_CMP_ERR;
2220    }
2221
2222    /* check that the CDB pointer is not to a physical address */
2223    if ((csio->ccb_h.flags & CAM_CDB_POINTER) && (csio->ccb_h.flags & CAM_CDB_PHYS)) {
2224	debug(0, "  CDB pointer is to physical address");
2225	csio->ccb_h.status = CAM_REQ_CMP_ERR;
2226    }
2227
2228    /* abandon aborted ccbs or those that have failed validation */
2229    if ((csio->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_INPROG) {
2230	debug(2, "abandoning CCB due to abort/validation failure");
2231	return(EINVAL);
2232    }
2233
2234    /*
2235     * Get a command, or push the ccb back to CAM and freeze the queue.
2236     */
2237    if ((error = mly_alloc_command(sc, &mc))) {
2238	s = splcam();
2239	xpt_freeze_simq(sim, 1);
2240	csio->ccb_h.status |= CAM_REQUEUE_REQ;
2241	sc->mly_qfrzn_cnt++;
2242	splx(s);
2243	return(error);
2244    }
2245
2246    /* build the command */
2247    mc->mc_data = csio;
2248    mc->mc_length = csio->dxfer_len;
2249    mc->mc_complete = mly_cam_complete;
2250    mc->mc_private = csio;
2251    mc->mc_flags |= MLY_CMD_CCB;
2252    /* XXX This code doesn't set the data direction in mc_flags. */
2253
2254    /* save the bus number in the ccb for later recovery XXX should be a better way */
2255     csio->ccb_h.sim_priv.entries[0].field = bus;
2256
2257    /* build the packet for the controller */
2258    ss = &mc->mc_packet->scsi_small;
2259    ss->opcode = MDACMD_SCSI;
2260    if (csio->ccb_h.flags & CAM_DIS_DISCONNECT)
2261	ss->command_control.disable_disconnect = 1;
2262    if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT)
2263	ss->command_control.data_direction = MLY_CCB_WRITE;
2264    ss->data_size = csio->dxfer_len;
2265    ss->addr.phys.lun = csio->ccb_h.target_lun;
2266    ss->addr.phys.target = csio->ccb_h.target_id;
2267    ss->addr.phys.channel = bus;
2268    if (csio->ccb_h.timeout < (60 * 1000)) {
2269	ss->timeout.value = csio->ccb_h.timeout / 1000;
2270	ss->timeout.scale = MLY_TIMEOUT_SECONDS;
2271    } else if (csio->ccb_h.timeout < (60 * 60 * 1000)) {
2272	ss->timeout.value = csio->ccb_h.timeout / (60 * 1000);
2273	ss->timeout.scale = MLY_TIMEOUT_MINUTES;
2274    } else {
2275	ss->timeout.value = csio->ccb_h.timeout / (60 * 60 * 1000);	/* overflow? */
2276	ss->timeout.scale = MLY_TIMEOUT_HOURS;
2277    }
2278    ss->maximum_sense_size = csio->sense_len;
2279    ss->cdb_length = csio->cdb_len;
2280    if (csio->ccb_h.flags & CAM_CDB_POINTER) {
2281	bcopy(csio->cdb_io.cdb_ptr, ss->cdb, csio->cdb_len);
2282    } else {
2283	bcopy(csio->cdb_io.cdb_bytes, ss->cdb, csio->cdb_len);
2284    }
2285
2286    /* give the command to the controller */
2287    if ((error = mly_start(mc))) {
2288	s = splcam();
2289	xpt_freeze_simq(sim, 1);
2290	csio->ccb_h.status |= CAM_REQUEUE_REQ;
2291	sc->mly_qfrzn_cnt++;
2292	splx(s);
2293	return(error);
2294    }
2295
2296    return(0);
2297}
2298
2299/********************************************************************************
2300 * Check for possibly-completed commands.
2301 */
2302static void
2303mly_cam_poll(struct cam_sim *sim)
2304{
2305    struct mly_softc	*sc = cam_sim_softc(sim);
2306
2307    debug_called(2);
2308
2309    mly_done(sc);
2310}
2311
2312/********************************************************************************
2313 * Handle completion of a command - pass results back through the CCB
2314 */
2315static void
2316mly_cam_complete(struct mly_command *mc)
2317{
2318    struct mly_softc		*sc = mc->mc_sc;
2319    struct ccb_scsiio		*csio = (struct ccb_scsiio *)mc->mc_private;
2320    struct scsi_inquiry_data	*inq = (struct scsi_inquiry_data *)csio->data_ptr;
2321    struct mly_btl		*btl;
2322    u_int8_t			cmd;
2323    int				bus, target;
2324    int				s;
2325
2326    debug_called(2);
2327
2328    csio->scsi_status = mc->mc_status;
2329    switch(mc->mc_status) {
2330    case SCSI_STATUS_OK:
2331	/*
2332	 * In order to report logical device type and status, we overwrite
2333	 * the result of the INQUIRY command to logical devices.
2334	 */
2335	bus = csio->ccb_h.sim_priv.entries[0].field;
2336	target = csio->ccb_h.target_id;
2337	/* XXX validate bus/target? */
2338	if (sc->mly_btl[bus][target].mb_flags & MLY_BTL_LOGICAL) {
2339	    if (csio->ccb_h.flags & CAM_CDB_POINTER) {
2340		cmd = *csio->cdb_io.cdb_ptr;
2341	    } else {
2342		cmd = csio->cdb_io.cdb_bytes[0];
2343	    }
2344	    if (cmd == INQUIRY) {
2345		btl = &sc->mly_btl[bus][target];
2346		padstr(inq->vendor, mly_describe_code(mly_table_device_type, btl->mb_type), 8);
2347		padstr(inq->product, mly_describe_code(mly_table_device_state, btl->mb_state), 16);
2348		padstr(inq->revision, "", 4);
2349	    }
2350	}
2351
2352	debug(2, "SCSI_STATUS_OK");
2353	csio->ccb_h.status = CAM_REQ_CMP;
2354	break;
2355
2356    case SCSI_STATUS_CHECK_COND:
2357	debug(1, "SCSI_STATUS_CHECK_COND  sense %d  resid %d", mc->mc_sense, mc->mc_resid);
2358	csio->ccb_h.status = CAM_SCSI_STATUS_ERROR;
2359	bzero(&csio->sense_data, SSD_FULL_SIZE);
2360	bcopy(mc->mc_packet, &csio->sense_data, mc->mc_sense);
2361	csio->sense_len = mc->mc_sense;
2362	csio->ccb_h.status |= CAM_AUTOSNS_VALID;
2363	csio->resid = mc->mc_resid;	/* XXX this is a signed value... */
2364	break;
2365
2366    case SCSI_STATUS_BUSY:
2367	debug(1, "SCSI_STATUS_BUSY");
2368	csio->ccb_h.status = CAM_SCSI_BUSY;
2369	break;
2370
2371    default:
2372	debug(1, "unknown status 0x%x", csio->scsi_status);
2373	csio->ccb_h.status = CAM_REQ_CMP_ERR;
2374	break;
2375    }
2376
2377    s = splcam();
2378    if (sc->mly_qfrzn_cnt) {
2379	csio->ccb_h.status |= CAM_RELEASE_SIMQ;
2380	sc->mly_qfrzn_cnt--;
2381    }
2382    splx(s);
2383
2384    xpt_done((union ccb *)csio);
2385    mly_release_command(mc);
2386}
2387
2388/********************************************************************************
2389 * Find a peripheral attahed at (bus),(target)
2390 */
2391static struct cam_periph *
2392mly_find_periph(struct mly_softc *sc, int bus, int target)
2393{
2394    struct cam_periph	*periph;
2395    struct cam_path	*path;
2396    int			status;
2397
2398    status = xpt_create_path(&path, NULL, cam_sim_path(sc->mly_cam_sim[bus]), target, 0);
2399    if (status == CAM_REQ_CMP) {
2400	periph = cam_periph_find(path, NULL);
2401	xpt_free_path(path);
2402    } else {
2403	periph = NULL;
2404    }
2405    return(periph);
2406}
2407
2408/********************************************************************************
2409 * Name the device at (bus)(target)
2410 */
2411static int
2412mly_name_device(struct mly_softc *sc, int bus, int target)
2413{
2414    struct cam_periph	*periph;
2415
2416    if ((periph = mly_find_periph(sc, bus, target)) != NULL) {
2417	sprintf(sc->mly_btl[bus][target].mb_name, "%s%d", periph->periph_name, periph->unit_number);
2418	return(0);
2419    }
2420    sc->mly_btl[bus][target].mb_name[0] = 0;
2421    return(ENOENT);
2422}
2423
2424/********************************************************************************
2425 ********************************************************************************
2426                                                                 Hardware Control
2427 ********************************************************************************
2428 ********************************************************************************/
2429
2430/********************************************************************************
2431 * Handshake with the firmware while the card is being initialised.
2432 */
2433static int
2434mly_fwhandshake(struct mly_softc *sc)
2435{
2436    u_int8_t	error, param0, param1;
2437    int		spinup = 0;
2438
2439    debug_called(1);
2440
2441    /* set HM_STSACK and let the firmware initialise */
2442    MLY_SET_REG(sc, sc->mly_idbr, MLY_HM_STSACK);
2443    DELAY(1000);	/* too short? */
2444
2445    /* if HM_STSACK is still true, the controller is initialising */
2446    if (!MLY_IDBR_TRUE(sc, MLY_HM_STSACK))
2447	return(0);
2448    mly_printf(sc, "controller initialisation started\n");
2449
2450    /* spin waiting for initialisation to finish, or for a message to be delivered */
2451    while (MLY_IDBR_TRUE(sc, MLY_HM_STSACK)) {
2452	/* check for a message */
2453	if (MLY_ERROR_VALID(sc)) {
2454	    error = MLY_GET_REG(sc, sc->mly_error_status) & ~MLY_MSG_EMPTY;
2455	    param0 = MLY_GET_REG(sc, sc->mly_command_mailbox);
2456	    param1 = MLY_GET_REG(sc, sc->mly_command_mailbox + 1);
2457
2458	    switch(error) {
2459	    case MLY_MSG_SPINUP:
2460		if (!spinup) {
2461		    mly_printf(sc, "drive spinup in progress\n");
2462		    spinup = 1;			/* only print this once (should print drive being spun?) */
2463		}
2464		break;
2465	    case MLY_MSG_RACE_RECOVERY_FAIL:
2466		mly_printf(sc, "mirror race recovery failed, one or more drives offline\n");
2467		break;
2468	    case MLY_MSG_RACE_IN_PROGRESS:
2469		mly_printf(sc, "mirror race recovery in progress\n");
2470		break;
2471	    case MLY_MSG_RACE_ON_CRITICAL:
2472		mly_printf(sc, "mirror race recovery on a critical drive\n");
2473		break;
2474	    case MLY_MSG_PARITY_ERROR:
2475		mly_printf(sc, "FATAL MEMORY PARITY ERROR\n");
2476		return(ENXIO);
2477	    default:
2478		mly_printf(sc, "unknown initialisation code 0x%x\n", error);
2479	    }
2480	}
2481    }
2482    return(0);
2483}
2484
2485/********************************************************************************
2486 ********************************************************************************
2487                                                        Debugging and Diagnostics
2488 ********************************************************************************
2489 ********************************************************************************/
2490
2491/********************************************************************************
2492 * Print some information about the controller.
2493 */
2494static void
2495mly_describe_controller(struct mly_softc *sc)
2496{
2497    struct mly_ioctl_getcontrollerinfo	*mi = sc->mly_controllerinfo;
2498
2499    mly_printf(sc, "%16s, %d channel%s, firmware %d.%02d-%d-%02d (%02d%02d%02d%02d), %dMB RAM\n",
2500	       mi->controller_name, mi->physical_channels_present, (mi->physical_channels_present) > 1 ? "s" : "",
2501	       mi->fw_major, mi->fw_minor, mi->fw_turn, mi->fw_build,	/* XXX turn encoding? */
2502	       mi->fw_century, mi->fw_year, mi->fw_month, mi->fw_day,
2503	       mi->memory_size);
2504
2505    if (bootverbose) {
2506	mly_printf(sc, "%s %s (%x), %dMHz %d-bit %.16s\n",
2507		   mly_describe_code(mly_table_oemname, mi->oem_information),
2508		   mly_describe_code(mly_table_controllertype, mi->controller_type), mi->controller_type,
2509		   mi->interface_speed, mi->interface_width, mi->interface_name);
2510	mly_printf(sc, "%dMB %dMHz %d-bit %s%s%s, cache %dMB\n",
2511		   mi->memory_size, mi->memory_speed, mi->memory_width,
2512		   mly_describe_code(mly_table_memorytype, mi->memory_type),
2513		   mi->memory_parity ? "+parity": "",mi->memory_ecc ? "+ECC": "",
2514		   mi->cache_size);
2515	mly_printf(sc, "CPU: %s @ %dMHz\n",
2516		   mly_describe_code(mly_table_cputype, mi->cpu[0].type), mi->cpu[0].speed);
2517	if (mi->l2cache_size != 0)
2518	    mly_printf(sc, "%dKB L2 cache\n", mi->l2cache_size);
2519	if (mi->exmemory_size != 0)
2520	    mly_printf(sc, "%dMB %dMHz %d-bit private %s%s%s\n",
2521		       mi->exmemory_size, mi->exmemory_speed, mi->exmemory_width,
2522		       mly_describe_code(mly_table_memorytype, mi->exmemory_type),
2523		       mi->exmemory_parity ? "+parity": "",mi->exmemory_ecc ? "+ECC": "");
2524	mly_printf(sc, "battery backup %s\n", mi->bbu_present ? "present" : "not installed");
2525	mly_printf(sc, "maximum data transfer %d blocks, maximum sg entries/command %d\n",
2526		   mi->maximum_block_count, mi->maximum_sg_entries);
2527	mly_printf(sc, "logical devices present/critical/offline %d/%d/%d\n",
2528		   mi->logical_devices_present, mi->logical_devices_critical, mi->logical_devices_offline);
2529	mly_printf(sc, "physical devices present %d\n",
2530		   mi->physical_devices_present);
2531	mly_printf(sc, "physical disks present/offline %d/%d\n",
2532		   mi->physical_disks_present, mi->physical_disks_offline);
2533	mly_printf(sc, "%d physical channel%s, %d virtual channel%s of %d possible\n",
2534		   mi->physical_channels_present, mi->physical_channels_present == 1 ? "" : "s",
2535		   mi->virtual_channels_present, mi->virtual_channels_present == 1 ? "" : "s",
2536		   mi->virtual_channels_possible);
2537	mly_printf(sc, "%d parallel commands supported\n", mi->maximum_parallel_commands);
2538	mly_printf(sc, "%dMB flash ROM, %d of %d maximum cycles\n",
2539		   mi->flash_size, mi->flash_age, mi->flash_maximum_age);
2540    }
2541}
2542
2543#ifdef MLY_DEBUG
2544/********************************************************************************
2545 * Print some controller state
2546 */
2547static void
2548mly_printstate(struct mly_softc *sc)
2549{
2550    mly_printf(sc, "IDBR %02x  ODBR %02x  ERROR %02x  (%x %x %x)\n",
2551		  MLY_GET_REG(sc, sc->mly_idbr),
2552		  MLY_GET_REG(sc, sc->mly_odbr),
2553		  MLY_GET_REG(sc, sc->mly_error_status),
2554		  sc->mly_idbr,
2555		  sc->mly_odbr,
2556		  sc->mly_error_status);
2557    mly_printf(sc, "IMASK %02x  ISTATUS %02x\n",
2558		  MLY_GET_REG(sc, sc->mly_interrupt_mask),
2559		  MLY_GET_REG(sc, sc->mly_interrupt_status));
2560    mly_printf(sc, "COMMAND %02x %02x %02x %02x %02x %02x %02x %02x\n",
2561		  MLY_GET_REG(sc, sc->mly_command_mailbox),
2562		  MLY_GET_REG(sc, sc->mly_command_mailbox + 1),
2563		  MLY_GET_REG(sc, sc->mly_command_mailbox + 2),
2564		  MLY_GET_REG(sc, sc->mly_command_mailbox + 3),
2565		  MLY_GET_REG(sc, sc->mly_command_mailbox + 4),
2566		  MLY_GET_REG(sc, sc->mly_command_mailbox + 5),
2567		  MLY_GET_REG(sc, sc->mly_command_mailbox + 6),
2568		  MLY_GET_REG(sc, sc->mly_command_mailbox + 7));
2569    mly_printf(sc, "STATUS  %02x %02x %02x %02x %02x %02x %02x %02x\n",
2570		  MLY_GET_REG(sc, sc->mly_status_mailbox),
2571		  MLY_GET_REG(sc, sc->mly_status_mailbox + 1),
2572		  MLY_GET_REG(sc, sc->mly_status_mailbox + 2),
2573		  MLY_GET_REG(sc, sc->mly_status_mailbox + 3),
2574		  MLY_GET_REG(sc, sc->mly_status_mailbox + 4),
2575		  MLY_GET_REG(sc, sc->mly_status_mailbox + 5),
2576		  MLY_GET_REG(sc, sc->mly_status_mailbox + 6),
2577		  MLY_GET_REG(sc, sc->mly_status_mailbox + 7));
2578    mly_printf(sc, "        %04x        %08x\n",
2579		  MLY_GET_REG2(sc, sc->mly_status_mailbox),
2580		  MLY_GET_REG4(sc, sc->mly_status_mailbox + 4));
2581}
2582
2583struct mly_softc	*mly_softc0 = NULL;
2584void
2585mly_printstate0(void)
2586{
2587    if (mly_softc0 != NULL)
2588	mly_printstate(mly_softc0);
2589}
2590
2591/********************************************************************************
2592 * Print a command
2593 */
2594static void
2595mly_print_command(struct mly_command *mc)
2596{
2597    struct mly_softc	*sc = mc->mc_sc;
2598
2599    mly_printf(sc, "COMMAND @ %p\n", mc);
2600    mly_printf(sc, "  slot      %d\n", mc->mc_slot);
2601    mly_printf(sc, "  status    0x%x\n", mc->mc_status);
2602    mly_printf(sc, "  sense len %d\n", mc->mc_sense);
2603    mly_printf(sc, "  resid     %d\n", mc->mc_resid);
2604    mly_printf(sc, "  packet    %p/0x%llx\n", mc->mc_packet, mc->mc_packetphys);
2605    if (mc->mc_packet != NULL)
2606	mly_print_packet(mc);
2607    mly_printf(sc, "  data      %p/%d\n", mc->mc_data, mc->mc_length);
2608    mly_printf(sc, "  flags     %b\n", mc->mc_flags, "\20\1busy\2complete\3slotted\4mapped\5datain\6dataout\n");
2609    mly_printf(sc, "  complete  %p\n", mc->mc_complete);
2610    mly_printf(sc, "  private   %p\n", mc->mc_private);
2611}
2612
2613/********************************************************************************
2614 * Print a command packet
2615 */
2616static void
2617mly_print_packet(struct mly_command *mc)
2618{
2619    struct mly_softc			*sc = mc->mc_sc;
2620    struct mly_command_generic		*ge = (struct mly_command_generic *)mc->mc_packet;
2621    struct mly_command_scsi_small	*ss = (struct mly_command_scsi_small *)mc->mc_packet;
2622    struct mly_command_scsi_large	*sl = (struct mly_command_scsi_large *)mc->mc_packet;
2623    struct mly_command_ioctl		*io = (struct mly_command_ioctl *)mc->mc_packet;
2624    int					transfer;
2625
2626    mly_printf(sc, "   command_id           %d\n", ge->command_id);
2627    mly_printf(sc, "   opcode               %d\n", ge->opcode);
2628    mly_printf(sc, "   command_control      fua %d  dpo %d  est %d  dd %s  nas %d ddis %d\n",
2629		  ge->command_control.force_unit_access,
2630		  ge->command_control.disable_page_out,
2631		  ge->command_control.extended_sg_table,
2632		  (ge->command_control.data_direction == MLY_CCB_WRITE) ? "WRITE" : "READ",
2633		  ge->command_control.no_auto_sense,
2634		  ge->command_control.disable_disconnect);
2635    mly_printf(sc, "   data_size            %d\n", ge->data_size);
2636    mly_printf(sc, "   sense_buffer_address 0x%llx\n", ge->sense_buffer_address);
2637    mly_printf(sc, "   lun                  %d\n", ge->addr.phys.lun);
2638    mly_printf(sc, "   target               %d\n", ge->addr.phys.target);
2639    mly_printf(sc, "   channel              %d\n", ge->addr.phys.channel);
2640    mly_printf(sc, "   logical device       %d\n", ge->addr.log.logdev);
2641    mly_printf(sc, "   controller           %d\n", ge->addr.phys.controller);
2642    mly_printf(sc, "   timeout              %d %s\n",
2643		  ge->timeout.value,
2644		  (ge->timeout.scale == MLY_TIMEOUT_SECONDS) ? "seconds" :
2645		  ((ge->timeout.scale == MLY_TIMEOUT_MINUTES) ? "minutes" : "hours"));
2646    mly_printf(sc, "   maximum_sense_size   %d\n", ge->maximum_sense_size);
2647    switch(ge->opcode) {
2648    case MDACMD_SCSIPT:
2649    case MDACMD_SCSI:
2650	mly_printf(sc, "   cdb length           %d\n", ss->cdb_length);
2651	mly_printf(sc, "   cdb                  %*D\n", ss->cdb_length, ss->cdb, " ");
2652	transfer = 1;
2653	break;
2654    case MDACMD_SCSILC:
2655    case MDACMD_SCSILCPT:
2656	mly_printf(sc, "   cdb length           %d\n", sl->cdb_length);
2657	mly_printf(sc, "   cdb                  0x%llx\n", sl->cdb_physaddr);
2658	transfer = 1;
2659	break;
2660    case MDACMD_IOCTL:
2661	mly_printf(sc, "   sub_ioctl            0x%x\n", io->sub_ioctl);
2662	switch(io->sub_ioctl) {
2663	case MDACIOCTL_SETMEMORYMAILBOX:
2664	    mly_printf(sc, "   health_buffer_size   %d\n",
2665			  io->param.setmemorymailbox.health_buffer_size);
2666	    mly_printf(sc, "   health_buffer_phys   0x%llx\n",
2667			  io->param.setmemorymailbox.health_buffer_physaddr);
2668	    mly_printf(sc, "   command_mailbox      0x%llx\n",
2669			  io->param.setmemorymailbox.command_mailbox_physaddr);
2670	    mly_printf(sc, "   status_mailbox       0x%llx\n",
2671			  io->param.setmemorymailbox.status_mailbox_physaddr);
2672	    transfer = 0;
2673	    break;
2674
2675	case MDACIOCTL_SETREALTIMECLOCK:
2676	case MDACIOCTL_GETHEALTHSTATUS:
2677	case MDACIOCTL_GETCONTROLLERINFO:
2678	case MDACIOCTL_GETLOGDEVINFOVALID:
2679	case MDACIOCTL_GETPHYSDEVINFOVALID:
2680	case MDACIOCTL_GETPHYSDEVSTATISTICS:
2681	case MDACIOCTL_GETLOGDEVSTATISTICS:
2682	case MDACIOCTL_GETCONTROLLERSTATISTICS:
2683	case MDACIOCTL_GETBDT_FOR_SYSDRIVE:
2684	case MDACIOCTL_CREATENEWCONF:
2685	case MDACIOCTL_ADDNEWCONF:
2686	case MDACIOCTL_GETDEVCONFINFO:
2687	case MDACIOCTL_GETFREESPACELIST:
2688	case MDACIOCTL_MORE:
2689	case MDACIOCTL_SETPHYSDEVPARAMETER:
2690	case MDACIOCTL_GETPHYSDEVPARAMETER:
2691	case MDACIOCTL_GETLOGDEVPARAMETER:
2692	case MDACIOCTL_SETLOGDEVPARAMETER:
2693	    mly_printf(sc, "   param                %10D\n", io->param.data.param, " ");
2694	    transfer = 1;
2695	    break;
2696
2697	case MDACIOCTL_GETEVENT:
2698	    mly_printf(sc, "   event                %d\n",
2699		       io->param.getevent.sequence_number_low + ((u_int32_t)io->addr.log.logdev << 16));
2700	    transfer = 1;
2701	    break;
2702
2703	case MDACIOCTL_SETRAIDDEVSTATE:
2704	    mly_printf(sc, "   state                %d\n", io->param.setraiddevstate.state);
2705	    transfer = 0;
2706	    break;
2707
2708	case MDACIOCTL_XLATEPHYSDEVTORAIDDEV:
2709	    mly_printf(sc, "   raid_device          %d\n", io->param.xlatephysdevtoraiddev.raid_device);
2710	    mly_printf(sc, "   controller           %d\n", io->param.xlatephysdevtoraiddev.controller);
2711	    mly_printf(sc, "   channel              %d\n", io->param.xlatephysdevtoraiddev.channel);
2712	    mly_printf(sc, "   target               %d\n", io->param.xlatephysdevtoraiddev.target);
2713	    mly_printf(sc, "   lun                  %d\n", io->param.xlatephysdevtoraiddev.lun);
2714	    transfer = 0;
2715	    break;
2716
2717	case MDACIOCTL_GETGROUPCONFINFO:
2718	    mly_printf(sc, "   group                %d\n", io->param.getgroupconfinfo.group);
2719	    transfer = 1;
2720	    break;
2721
2722	case MDACIOCTL_GET_SUBSYSTEM_DATA:
2723	case MDACIOCTL_SET_SUBSYSTEM_DATA:
2724	case MDACIOCTL_STARTDISOCVERY:
2725	case MDACIOCTL_INITPHYSDEVSTART:
2726	case MDACIOCTL_INITPHYSDEVSTOP:
2727	case MDACIOCTL_INITRAIDDEVSTART:
2728	case MDACIOCTL_INITRAIDDEVSTOP:
2729	case MDACIOCTL_REBUILDRAIDDEVSTART:
2730	case MDACIOCTL_REBUILDRAIDDEVSTOP:
2731	case MDACIOCTL_MAKECONSISTENTDATASTART:
2732	case MDACIOCTL_MAKECONSISTENTDATASTOP:
2733	case MDACIOCTL_CONSISTENCYCHECKSTART:
2734	case MDACIOCTL_CONSISTENCYCHECKSTOP:
2735	case MDACIOCTL_RESETDEVICE:
2736	case MDACIOCTL_FLUSHDEVICEDATA:
2737	case MDACIOCTL_PAUSEDEVICE:
2738	case MDACIOCTL_UNPAUSEDEVICE:
2739	case MDACIOCTL_LOCATEDEVICE:
2740	case MDACIOCTL_SETMASTERSLAVEMODE:
2741	case MDACIOCTL_DELETERAIDDEV:
2742	case MDACIOCTL_REPLACEINTERNALDEV:
2743	case MDACIOCTL_CLEARCONF:
2744	case MDACIOCTL_GETCONTROLLERPARAMETER:
2745	case MDACIOCTL_SETCONTRLLERPARAMETER:
2746	case MDACIOCTL_CLEARCONFSUSPMODE:
2747	case MDACIOCTL_STOREIMAGE:
2748	case MDACIOCTL_READIMAGE:
2749	case MDACIOCTL_FLASHIMAGES:
2750	case MDACIOCTL_RENAMERAIDDEV:
2751	default:			/* no idea what to print */
2752	    transfer = 0;
2753	    break;
2754	}
2755	break;
2756
2757    case MDACMD_IOCTLCHECK:
2758    case MDACMD_MEMCOPY:
2759    default:
2760	transfer = 0;
2761	break;	/* print nothing */
2762    }
2763    if (transfer) {
2764	if (ge->command_control.extended_sg_table) {
2765	    mly_printf(sc, "   sg table             0x%llx/%d\n",
2766			  ge->transfer.indirect.table_physaddr[0], ge->transfer.indirect.entries[0]);
2767	} else {
2768	    mly_printf(sc, "   0000                 0x%llx/%lld\n",
2769			  ge->transfer.direct.sg[0].physaddr, ge->transfer.direct.sg[0].length);
2770	    mly_printf(sc, "   0001                 0x%llx/%lld\n",
2771			  ge->transfer.direct.sg[1].physaddr, ge->transfer.direct.sg[1].length);
2772	}
2773    }
2774}
2775
2776/********************************************************************************
2777 * Panic in a slightly informative fashion
2778 */
2779static void
2780mly_panic(struct mly_softc *sc, char *reason)
2781{
2782    mly_printstate(sc);
2783    panic(reason);
2784}
2785
2786/********************************************************************************
2787 * Print queue statistics, callable from DDB.
2788 */
2789void
2790mly_print_controller(int controller)
2791{
2792    struct mly_softc	*sc;
2793
2794    if ((sc = devclass_get_softc(devclass_find("mly"), controller)) == NULL) {
2795	printf("mly: controller %d invalid\n", controller);
2796    } else {
2797	device_printf(sc->mly_dev, "queue    curr max\n");
2798	device_printf(sc->mly_dev, "free     %04d/%04d\n",
2799		      sc->mly_qstat[MLYQ_FREE].q_length, sc->mly_qstat[MLYQ_FREE].q_max);
2800	device_printf(sc->mly_dev, "busy     %04d/%04d\n",
2801		      sc->mly_qstat[MLYQ_BUSY].q_length, sc->mly_qstat[MLYQ_BUSY].q_max);
2802	device_printf(sc->mly_dev, "complete %04d/%04d\n",
2803		      sc->mly_qstat[MLYQ_COMPLETE].q_length, sc->mly_qstat[MLYQ_COMPLETE].q_max);
2804    }
2805}
2806#endif
2807
2808
2809/********************************************************************************
2810 ********************************************************************************
2811                                                         Control device interface
2812 ********************************************************************************
2813 ********************************************************************************/
2814
2815/********************************************************************************
2816 * Accept an open operation on the control device.
2817 */
2818static int
2819mly_user_open(struct cdev *dev, int flags, int fmt, struct thread *td)
2820{
2821    struct mly_softc	*sc = dev->si_drv1;
2822
2823    sc->mly_state |= MLY_STATE_OPEN;
2824    return(0);
2825}
2826
2827/********************************************************************************
2828 * Accept the last close on the control device.
2829 */
2830static int
2831mly_user_close(struct cdev *dev, int flags, int fmt, struct thread *td)
2832{
2833    struct mly_softc	*sc = dev->si_drv1;
2834
2835    sc->mly_state &= ~MLY_STATE_OPEN;
2836    return (0);
2837}
2838
2839/********************************************************************************
2840 * Handle controller-specific control operations.
2841 */
2842static int
2843mly_user_ioctl(struct cdev *dev, u_long cmd, caddr_t addr,
2844				int32_t flag, struct thread *td)
2845{
2846    struct mly_softc		*sc = (struct mly_softc *)dev->si_drv1;
2847    struct mly_user_command	*uc = (struct mly_user_command *)addr;
2848    struct mly_user_health	*uh = (struct mly_user_health *)addr;
2849
2850    switch(cmd) {
2851    case MLYIO_COMMAND:
2852	return(mly_user_command(sc, uc));
2853    case MLYIO_HEALTH:
2854	return(mly_user_health(sc, uh));
2855    default:
2856	return(ENOIOCTL);
2857    }
2858}
2859
2860/********************************************************************************
2861 * Execute a command passed in from userspace.
2862 *
2863 * The control structure contains the actual command for the controller, as well
2864 * as the user-space data pointer and data size, and an optional sense buffer
2865 * size/pointer.  On completion, the data size is adjusted to the command
2866 * residual, and the sense buffer size to the size of the returned sense data.
2867 *
2868 */
2869static int
2870mly_user_command(struct mly_softc *sc, struct mly_user_command *uc)
2871{
2872    struct mly_command	*mc;
2873    int			error, s;
2874
2875    /* allocate a command */
2876    if (mly_alloc_command(sc, &mc)) {
2877	error = ENOMEM;
2878	goto out;		/* XXX Linux version will wait for a command */
2879    }
2880
2881    /* handle data size/direction */
2882    mc->mc_length = (uc->DataTransferLength >= 0) ? uc->DataTransferLength : -uc->DataTransferLength;
2883    if (mc->mc_length > 0) {
2884	if ((mc->mc_data = malloc(mc->mc_length, M_DEVBUF, M_NOWAIT)) == NULL) {
2885	    error = ENOMEM;
2886	    goto out;
2887	}
2888    }
2889    if (uc->DataTransferLength > 0) {
2890	mc->mc_flags |= MLY_CMD_DATAIN;
2891	bzero(mc->mc_data, mc->mc_length);
2892    }
2893    if (uc->DataTransferLength < 0) {
2894	mc->mc_flags |= MLY_CMD_DATAOUT;
2895	if ((error = copyin(uc->DataTransferBuffer, mc->mc_data, mc->mc_length)) != 0)
2896	    goto out;
2897    }
2898
2899    /* copy the controller command */
2900    bcopy(&uc->CommandMailbox, mc->mc_packet, sizeof(uc->CommandMailbox));
2901
2902    /* clear command completion handler so that we get woken up */
2903    mc->mc_complete = NULL;
2904
2905    /* execute the command */
2906    if ((error = mly_start(mc)) != 0)
2907	goto out;
2908    s = splcam();
2909    while (!(mc->mc_flags & MLY_CMD_COMPLETE))
2910	tsleep(mc, PRIBIO, "mlyioctl", 0);
2911    splx(s);
2912
2913    /* return the data to userspace */
2914    if (uc->DataTransferLength > 0)
2915	if ((error = copyout(mc->mc_data, uc->DataTransferBuffer, mc->mc_length)) != 0)
2916	    goto out;
2917
2918    /* return the sense buffer to userspace */
2919    if ((uc->RequestSenseLength > 0) && (mc->mc_sense > 0)) {
2920	if ((error = copyout(mc->mc_packet, uc->RequestSenseBuffer,
2921			     min(uc->RequestSenseLength, mc->mc_sense))) != 0)
2922	    goto out;
2923    }
2924
2925    /* return command results to userspace (caller will copy out) */
2926    uc->DataTransferLength = mc->mc_resid;
2927    uc->RequestSenseLength = min(uc->RequestSenseLength, mc->mc_sense);
2928    uc->CommandStatus = mc->mc_status;
2929    error = 0;
2930
2931 out:
2932    if (mc->mc_data != NULL)
2933	free(mc->mc_data, M_DEVBUF);
2934    if (mc != NULL)
2935	mly_release_command(mc);
2936    return(error);
2937}
2938
2939/********************************************************************************
2940 * Return health status to userspace.  If the health change index in the user
2941 * structure does not match that currently exported by the controller, we
2942 * return the current status immediately.  Otherwise, we block until either
2943 * interrupted or new status is delivered.
2944 */
2945static int
2946mly_user_health(struct mly_softc *sc, struct mly_user_health *uh)
2947{
2948    struct mly_health_status		mh;
2949    int					error, s;
2950
2951    /* fetch the current health status from userspace */
2952    if ((error = copyin(uh->HealthStatusBuffer, &mh, sizeof(mh))) != 0)
2953	return(error);
2954
2955    /* spin waiting for a status update */
2956    s = splcam();
2957    error = EWOULDBLOCK;
2958    while ((error != 0) && (sc->mly_event_change == mh.change_counter))
2959	error = tsleep(&sc->mly_event_change, PRIBIO | PCATCH, "mlyhealth", 0);
2960    splx(s);
2961
2962    /* copy the controller's health status buffer out (there is a race here if it changes again) */
2963    error = copyout(&sc->mly_mmbox->mmm_health.status, uh->HealthStatusBuffer,
2964		    sizeof(uh->HealthStatusBuffer));
2965    return(error);
2966}
2967
2968#ifdef MLY_DEBUG
2969static int
2970mly_timeout(struct mly_softc *sc)
2971{
2972	struct mly_command *mc;
2973	int deadline;
2974
2975	deadline = time_second - MLY_CMD_TIMEOUT;
2976	TAILQ_FOREACH(mc, &sc->mly_busy, mc_link) {
2977		if ((mc->mc_timestamp < deadline)) {
2978			device_printf(sc->mly_dev,
2979			    "COMMAND %p TIMEOUT AFTER %d SECONDS\n", mc,
2980			    (int)(time_second - mc->mc_timestamp));
2981		}
2982	}
2983
2984	timeout((timeout_t *)mly_timeout, sc, MLY_CMD_TIMEOUT * hz);
2985
2986	return (0);
2987}
2988#endif
2989