Home | History | Annotate | Line # | Download | only in pci
mly.c revision 1.43
      1 /*	$NetBSD: mly.c,v 1.43 2009/11/26 15:17:10 njoly Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2001 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Andrew Doran, Thor Lancelot Simon, and Eric Haszlakiewicz.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 /*-
     33  * Copyright (c) 2000, 2001 Michael Smith
     34  * Copyright (c) 2000 BSDi
     35  * All rights reserved.
     36  *
     37  * Redistribution and use in source and binary forms, with or without
     38  * modification, are permitted provided that the following conditions
     39  * are met:
     40  * 1. Redistributions of source code must retain the above copyright
     41  *    notice, this list of conditions and the following disclaimer.
     42  * 2. Redistributions in binary form must reproduce the above copyright
     43  *    notice, this list of conditions and the following disclaimer in the
     44  *    documentation and/or other materials provided with the distribution.
     45  *
     46  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     47  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     48  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     49  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     50  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     51  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     52  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     53  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     54  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     55  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     56  * SUCH DAMAGE.
     57  *
     58  * from FreeBSD: mly.c,v 1.8 2001/07/14 00:12:22 msmith Exp
     59  */
     60 
     61 /*
     62  * Driver for the Mylex AcceleRAID and eXtremeRAID family with v6 firmware.
     63  *
     64  * TODO:
     65  *
     66  * o Make mly->mly_btl a hash, then MLY_BTL_RESCAN becomes a SIMPLEQ.
     67  * o Handle FC and multiple LUNs.
     68  * o Fix mmbox usage.
     69  * o Fix transfer speed fudge.
     70  */
     71 
     72 #include <sys/cdefs.h>
     73 __KERNEL_RCSID(0, "$NetBSD: mly.c,v 1.43 2009/11/26 15:17:10 njoly Exp $");
     74 
     75 #include <sys/param.h>
     76 #include <sys/systm.h>
     77 #include <sys/device.h>
     78 #include <sys/kernel.h>
     79 #include <sys/queue.h>
     80 #include <sys/buf.h>
     81 #include <sys/endian.h>
     82 #include <sys/conf.h>
     83 #include <sys/malloc.h>
     84 #include <sys/ioctl.h>
     85 #include <sys/scsiio.h>
     86 #include <sys/kthread.h>
     87 #include <sys/kauth.h>
     88 
     89 #include <uvm/uvm_extern.h>
     90 
     91 #include <sys/bus.h>
     92 
     93 #include <dev/scsipi/scsi_all.h>
     94 #include <dev/scsipi/scsipi_all.h>
     95 #include <dev/scsipi/scsiconf.h>
     96 
     97 #include <dev/pci/pcireg.h>
     98 #include <dev/pci/pcivar.h>
     99 #include <dev/pci/pcidevs.h>
    100 
    101 #include <dev/pci/mlyreg.h>
    102 #include <dev/pci/mlyio.h>
    103 #include <dev/pci/mlyvar.h>
    104 #include <dev/pci/mly_tables.h>
    105 
    106 static void	mly_attach(device_t, device_t, void *);
    107 static int	mly_match(device_t, cfdata_t, void *);
    108 static const	struct mly_ident *mly_find_ident(struct pci_attach_args *);
    109 static int	mly_fwhandshake(struct mly_softc *);
    110 static int	mly_flush(struct mly_softc *);
    111 static int	mly_intr(void *);
    112 static void	mly_shutdown(void *);
    113 
    114 static int	mly_alloc_ccbs(struct mly_softc *);
    115 static void	mly_check_event(struct mly_softc *);
    116 static void	mly_complete_event(struct mly_softc *, struct mly_ccb *);
    117 static void	mly_complete_rescan(struct mly_softc *, struct mly_ccb *);
    118 static int	mly_dmamem_alloc(struct mly_softc *, int, bus_dmamap_t *,
    119 				 void **, bus_addr_t *, bus_dma_segment_t *);
    120 static void	mly_dmamem_free(struct mly_softc *, int, bus_dmamap_t,
    121 				void *, bus_dma_segment_t *);
    122 static int	mly_enable_mmbox(struct mly_softc *);
    123 static void	mly_fetch_event(struct mly_softc *);
    124 static int	mly_get_controllerinfo(struct mly_softc *);
    125 static int	mly_get_eventstatus(struct mly_softc *);
    126 static int	mly_ioctl(struct mly_softc *, struct mly_cmd_ioctl *,
    127 			  void **, size_t, void *, size_t *);
    128 static void	mly_padstr(char *, const char *, int);
    129 static void	mly_process_event(struct mly_softc *, struct mly_event *);
    130 static void	mly_release_ccbs(struct mly_softc *);
    131 static int	mly_scan_btl(struct mly_softc *, int, int);
    132 static void	mly_scan_channel(struct mly_softc *, int);
    133 static void	mly_thread(void *);
    134 
    135 static int	mly_ccb_alloc(struct mly_softc *, struct mly_ccb **);
    136 static void	mly_ccb_complete(struct mly_softc *, struct mly_ccb *);
    137 static void	mly_ccb_enqueue(struct mly_softc *, struct mly_ccb *);
    138 static void	mly_ccb_free(struct mly_softc *, struct mly_ccb *);
    139 static int	mly_ccb_map(struct mly_softc *, struct mly_ccb *);
    140 static int	mly_ccb_poll(struct mly_softc *, struct mly_ccb *, int);
    141 static int	mly_ccb_submit(struct mly_softc *, struct mly_ccb *);
    142 static void	mly_ccb_unmap(struct mly_softc *, struct mly_ccb *);
    143 static int	mly_ccb_wait(struct mly_softc *, struct mly_ccb *, int);
    144 
    145 static void	mly_get_xfer_mode(struct mly_softc *, int,
    146 				  struct scsipi_xfer_mode *);
    147 static void	mly_scsipi_complete(struct mly_softc *, struct mly_ccb *);
    148 static int	mly_scsipi_ioctl(struct scsipi_channel *, u_long, void *,
    149 				 int, struct proc *);
    150 static void	mly_scsipi_minphys(struct buf *);
    151 static void	mly_scsipi_request(struct scsipi_channel *,
    152 				   scsipi_adapter_req_t, void *);
    153 
    154 static int	mly_user_command(struct mly_softc *, struct mly_user_command *);
    155 static int	mly_user_health(struct mly_softc *, struct mly_user_health *);
    156 
    157 extern struct	cfdriver mly_cd;
    158 
    159 CFATTACH_DECL(mly, sizeof(struct mly_softc),
    160     mly_match, mly_attach, NULL, NULL);
    161 
    162 dev_type_open(mlyopen);
    163 dev_type_close(mlyclose);
    164 dev_type_ioctl(mlyioctl);
    165 
    166 const struct cdevsw mly_cdevsw = {
    167 	mlyopen, mlyclose, noread, nowrite, mlyioctl,
    168 	nostop, notty, nopoll, nommap, nokqfilter, D_OTHER,
    169 };
    170 
    171 static struct mly_ident {
    172 	u_short	vendor;
    173 	u_short	product;
    174 	u_short	subvendor;
    175 	u_short	subproduct;
    176 	int	hwif;
    177 	const char	*desc;
    178 } const mly_ident[] = {
    179 	{
    180 		PCI_VENDOR_MYLEX,
    181 		PCI_PRODUCT_MYLEX_EXTREMERAID,
    182 		PCI_VENDOR_MYLEX,
    183 		0x0040,
    184 		MLY_HWIF_STRONGARM,
    185 		"eXtremeRAID 2000"
    186 	},
    187 	{
    188 		PCI_VENDOR_MYLEX,
    189 		PCI_PRODUCT_MYLEX_EXTREMERAID,
    190 		PCI_VENDOR_MYLEX,
    191 		0x0030,
    192 		MLY_HWIF_STRONGARM,
    193 		"eXtremeRAID 3000"
    194 	},
    195 	{
    196 		PCI_VENDOR_MYLEX,
    197 		PCI_PRODUCT_MYLEX_ACCELERAID,
    198 		PCI_VENDOR_MYLEX,
    199 		0x0050,
    200 		MLY_HWIF_I960RX,
    201 		"AcceleRAID 352"
    202 	},
    203 	{
    204 		PCI_VENDOR_MYLEX,
    205 		PCI_PRODUCT_MYLEX_ACCELERAID,
    206 		PCI_VENDOR_MYLEX,
    207 		0x0052,
    208 		MLY_HWIF_I960RX,
    209 		"AcceleRAID 170"
    210 	},
    211 	{
    212 		PCI_VENDOR_MYLEX,
    213 		PCI_PRODUCT_MYLEX_ACCELERAID,
    214 		PCI_VENDOR_MYLEX,
    215 		0x0054,
    216 		MLY_HWIF_I960RX,
    217 		"AcceleRAID 160"
    218 	},
    219 };
    220 
    221 static void	*mly_sdh;
    222 
    223 /*
    224  * Try to find a `mly_ident' entry corresponding to this board.
    225  */
    226 static const struct mly_ident *
    227 mly_find_ident(struct pci_attach_args *pa)
    228 {
    229 	const struct mly_ident *mpi, *maxmpi;
    230 	pcireg_t reg;
    231 
    232 	mpi = mly_ident;
    233 	maxmpi = mpi + sizeof(mly_ident) / sizeof(mly_ident[0]);
    234 
    235 	if (PCI_CLASS(pa->pa_class) == PCI_CLASS_I2O)
    236 		return (NULL);
    237 
    238 	for (; mpi < maxmpi; mpi++) {
    239 		if (PCI_VENDOR(pa->pa_id) != mpi->vendor ||
    240 		    PCI_PRODUCT(pa->pa_id) != mpi->product)
    241 			continue;
    242 
    243 		if (mpi->subvendor == 0x0000)
    244 			return (mpi);
    245 
    246 		reg = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG);
    247 
    248 		if (PCI_VENDOR(reg) == mpi->subvendor &&
    249 		    PCI_PRODUCT(reg) == mpi->subproduct)
    250 			return (mpi);
    251 	}
    252 
    253 	return (NULL);
    254 }
    255 
    256 /*
    257  * Match a supported board.
    258  */
    259 static int
    260 mly_match(device_t parent, cfdata_t cfdata, void *aux)
    261 {
    262 
    263 	return (mly_find_ident(aux) != NULL);
    264 }
    265 
    266 /*
    267  * Attach a supported board.
    268  */
    269 static void
    270 mly_attach(device_t parent, device_t self, void *aux)
    271 {
    272 	struct pci_attach_args *pa;
    273 	struct mly_softc *mly;
    274 	struct mly_ioctl_getcontrollerinfo *mi;
    275 	const struct mly_ident *ident;
    276 	pci_chipset_tag_t pc;
    277 	pci_intr_handle_t ih;
    278 	bus_space_handle_t memh, ioh;
    279 	bus_space_tag_t memt, iot;
    280 	pcireg_t reg;
    281 	const char *intrstr;
    282 	int ior, memr, i, rv, state;
    283 	struct scsipi_adapter *adapt;
    284 	struct scsipi_channel *chan;
    285 
    286 	mly = device_private(self);
    287 	pa = aux;
    288 	pc = pa->pa_pc;
    289 	ident = mly_find_ident(pa);
    290 	state = 0;
    291 
    292 	mly->mly_dmat = pa->pa_dmat;
    293 	mly->mly_hwif = ident->hwif;
    294 
    295 	printf(": Mylex %s\n", ident->desc);
    296 
    297 	/*
    298 	 * Map the PCI register window.
    299 	 */
    300 	memr = -1;
    301 	ior = -1;
    302 
    303 	for (i = 0x10; i <= 0x14; i += 4) {
    304 		reg = pci_conf_read(pa->pa_pc, pa->pa_tag, i);
    305 
    306 		if (PCI_MAPREG_TYPE(reg) == PCI_MAPREG_TYPE_IO) {
    307 			if (ior == -1 && PCI_MAPREG_IO_SIZE(reg) != 0)
    308 				ior = i;
    309 		} else {
    310 			if (memr == -1 && PCI_MAPREG_MEM_SIZE(reg) != 0)
    311 				memr = i;
    312 		}
    313 	}
    314 
    315 	if (memr != -1)
    316 		if (pci_mapreg_map(pa, memr, PCI_MAPREG_TYPE_MEM, 0,
    317 		    &memt, &memh, NULL, NULL))
    318 			memr = -1;
    319 	if (ior != -1)
    320 		if (pci_mapreg_map(pa, ior, PCI_MAPREG_TYPE_IO, 0,
    321 		    &iot, &ioh, NULL, NULL))
    322 		    	ior = -1;
    323 
    324 	if (memr != -1) {
    325 		mly->mly_iot = memt;
    326 		mly->mly_ioh = memh;
    327 	} else if (ior != -1) {
    328 		mly->mly_iot = iot;
    329 		mly->mly_ioh = ioh;
    330 	} else {
    331 		aprint_error_dev(self, "can't map i/o or memory space\n");
    332 		return;
    333 	}
    334 
    335 	/*
    336 	 * Enable the device.
    337 	 */
    338 	reg = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
    339 	pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG,
    340 	    reg | PCI_COMMAND_MASTER_ENABLE);
    341 
    342 	/*
    343 	 * Map and establish the interrupt.
    344 	 */
    345 	if (pci_intr_map(pa, &ih)) {
    346 		aprint_error_dev(self, "can't map interrupt\n");
    347 		return;
    348 	}
    349 	intrstr = pci_intr_string(pc, ih);
    350 	mly->mly_ih = pci_intr_establish(pc, ih, IPL_BIO, mly_intr, mly);
    351 	if (mly->mly_ih == NULL) {
    352 		aprint_error_dev(self, "can't establish interrupt");
    353 		if (intrstr != NULL)
    354 			aprint_error(" at %s", intrstr);
    355 		aprint_error("\n");
    356 		return;
    357 	}
    358 
    359 	if (intrstr != NULL)
    360 		aprint_normal_dev(&mly->mly_dv, "interrupting at %s\n",
    361 		    intrstr);
    362 
    363 	/*
    364 	 * Take care of interface-specific tasks.
    365 	 */
    366 	switch (mly->mly_hwif) {
    367 	case MLY_HWIF_I960RX:
    368 		mly->mly_doorbell_true = 0x00;
    369 		mly->mly_cmd_mailbox = MLY_I960RX_COMMAND_MAILBOX;
    370 		mly->mly_status_mailbox = MLY_I960RX_STATUS_MAILBOX;
    371 		mly->mly_idbr = MLY_I960RX_IDBR;
    372 		mly->mly_odbr = MLY_I960RX_ODBR;
    373 		mly->mly_error_status = MLY_I960RX_ERROR_STATUS;
    374 		mly->mly_interrupt_status = MLY_I960RX_INTERRUPT_STATUS;
    375 		mly->mly_interrupt_mask = MLY_I960RX_INTERRUPT_MASK;
    376 		break;
    377 
    378 	case MLY_HWIF_STRONGARM:
    379 		mly->mly_doorbell_true = 0xff;
    380 		mly->mly_cmd_mailbox = MLY_STRONGARM_COMMAND_MAILBOX;
    381 		mly->mly_status_mailbox = MLY_STRONGARM_STATUS_MAILBOX;
    382 		mly->mly_idbr = MLY_STRONGARM_IDBR;
    383 		mly->mly_odbr = MLY_STRONGARM_ODBR;
    384 		mly->mly_error_status = MLY_STRONGARM_ERROR_STATUS;
    385 		mly->mly_interrupt_status = MLY_STRONGARM_INTERRUPT_STATUS;
    386 		mly->mly_interrupt_mask = MLY_STRONGARM_INTERRUPT_MASK;
    387 		break;
    388 	}
    389 
    390 	/*
    391 	 * Allocate and map the scatter/gather lists.
    392 	 */
    393 	rv = mly_dmamem_alloc(mly, MLY_SGL_SIZE * MLY_MAX_CCBS,
    394 	    &mly->mly_sg_dmamap, (void **)&mly->mly_sg,
    395 	    &mly->mly_sg_busaddr, &mly->mly_sg_seg);
    396 	if (rv) {
    397 		printf("%s: unable to allocate S/G maps\n",
    398 		    device_xname(&mly->mly_dv));
    399 		goto bad;
    400 	}
    401 	state++;
    402 
    403 	/*
    404 	 * Allocate and map the memory mailbox.
    405 	 */
    406 	rv = mly_dmamem_alloc(mly, sizeof(struct mly_mmbox),
    407 	    &mly->mly_mmbox_dmamap, (void **)&mly->mly_mmbox,
    408 	    &mly->mly_mmbox_busaddr, &mly->mly_mmbox_seg);
    409 	if (rv) {
    410 		aprint_error_dev(&mly->mly_dv, "unable to allocate mailboxes\n");
    411 		goto bad;
    412 	}
    413 	state++;
    414 
    415 	/*
    416 	 * Initialise per-controller queues.
    417 	 */
    418 	SLIST_INIT(&mly->mly_ccb_free);
    419 	SIMPLEQ_INIT(&mly->mly_ccb_queue);
    420 
    421 	/*
    422 	 * Disable interrupts before we start talking to the controller.
    423 	 */
    424 	mly_outb(mly, mly->mly_interrupt_mask, MLY_INTERRUPT_MASK_DISABLE);
    425 
    426 	/*
    427 	 * Wait for the controller to come ready, handshaking with the
    428 	 * firmware if required.  This is typically only necessary on
    429 	 * platforms where the controller BIOS does not run.
    430 	 */
    431 	if (mly_fwhandshake(mly)) {
    432 		aprint_error_dev(&mly->mly_dv, "unable to bring controller online\n");
    433 		goto bad;
    434 	}
    435 
    436 	/*
    437 	 * Allocate initial command buffers, obtain controller feature
    438 	 * information, and then reallocate command buffers, since we'll
    439 	 * know how many we want.
    440 	 */
    441 	if (mly_alloc_ccbs(mly)) {
    442 		aprint_error_dev(&mly->mly_dv, "unable to allocate CCBs\n");
    443 		goto bad;
    444 	}
    445 	state++;
    446 	if (mly_get_controllerinfo(mly)) {
    447 		aprint_error_dev(&mly->mly_dv, "unable to retrieve controller info\n");
    448 		goto bad;
    449 	}
    450 	mly_release_ccbs(mly);
    451 	if (mly_alloc_ccbs(mly)) {
    452 		aprint_error_dev(&mly->mly_dv, "unable to allocate CCBs\n");
    453 		state--;
    454 		goto bad;
    455 	}
    456 
    457 	/*
    458 	 * Get the current event counter for health purposes, populate the
    459 	 * initial health status buffer.
    460 	 */
    461 	if (mly_get_eventstatus(mly)) {
    462 		aprint_error_dev(&mly->mly_dv, "unable to retrieve event status\n");
    463 		goto bad;
    464 	}
    465 
    466 	/*
    467 	 * Enable memory-mailbox mode.
    468 	 */
    469 	if (mly_enable_mmbox(mly)) {
    470 		aprint_error_dev(&mly->mly_dv, "unable to enable memory mailbox\n");
    471 		goto bad;
    472 	}
    473 
    474 	/*
    475 	 * Print a little information about the controller.
    476 	 */
    477 	mi = mly->mly_controllerinfo;
    478 
    479 	printf("%s: %d physical channel%s, firmware %d.%02d-%d-%02d "
    480 	    "(%02d%02d%02d%02d), %dMB RAM\n", device_xname(&mly->mly_dv),
    481 	    mi->physical_channels_present,
    482 	    (mi->physical_channels_present) > 1 ? "s" : "",
    483 	    mi->fw_major, mi->fw_minor, mi->fw_turn, mi->fw_build,
    484 	    mi->fw_century, mi->fw_year, mi->fw_month, mi->fw_day,
    485 	    le16toh(mi->memory_size));
    486 
    487 	/*
    488 	 * Register our `shutdownhook'.
    489 	 */
    490 	if (mly_sdh == NULL)
    491 		shutdownhook_establish(mly_shutdown, NULL);
    492 
    493 	/*
    494 	 * Clear any previous BTL information.  For each bus that scsipi
    495 	 * wants to scan, we'll receive the SCBUSIOLLSCAN ioctl and retrieve
    496 	 * all BTL info at that point.
    497 	 */
    498 	memset(&mly->mly_btl, 0, sizeof(mly->mly_btl));
    499 
    500 	mly->mly_nchans = mly->mly_controllerinfo->physical_channels_present +
    501 	    mly->mly_controllerinfo->virtual_channels_present;
    502 
    503 	/*
    504 	 * Attach to scsipi.
    505 	 */
    506 	adapt = &mly->mly_adapt;
    507 	memset(adapt, 0, sizeof(*adapt));
    508 	adapt->adapt_dev = &mly->mly_dv;
    509 	adapt->adapt_nchannels = mly->mly_nchans;
    510 	adapt->adapt_openings = mly->mly_ncmds - MLY_CCBS_RESV;
    511 	adapt->adapt_max_periph = mly->mly_ncmds - MLY_CCBS_RESV;
    512 	adapt->adapt_request = mly_scsipi_request;
    513 	adapt->adapt_minphys = mly_scsipi_minphys;
    514 	adapt->adapt_ioctl = mly_scsipi_ioctl;
    515 
    516 	for (i = 0; i < mly->mly_nchans; i++) {
    517 		chan = &mly->mly_chans[i];
    518 		memset(chan, 0, sizeof(*chan));
    519 		chan->chan_adapter = adapt;
    520 		chan->chan_bustype = &scsi_bustype;
    521 		chan->chan_channel = i;
    522 		chan->chan_ntargets = MLY_MAX_TARGETS;
    523 		chan->chan_nluns = MLY_MAX_LUNS;
    524 		chan->chan_id = mly->mly_controllerparam->initiator_id;
    525 		chan->chan_flags = SCSIPI_CHAN_NOSETTLE;
    526 		config_found(&mly->mly_dv, chan, scsiprint);
    527 	}
    528 
    529 	/*
    530 	 * Now enable interrupts...
    531 	 */
    532 	mly_outb(mly, mly->mly_interrupt_mask, MLY_INTERRUPT_MASK_ENABLE);
    533 
    534 	/*
    535 	 * Finally, create our monitoring thread.
    536 	 */
    537 	mly->mly_state |= MLY_STATE_INITOK;
    538 	rv = kthread_create(PRI_NONE, 0, NULL, mly_thread, mly,
    539 	    &mly->mly_thread, "%s", device_xname(&mly->mly_dv));
    540  	if (rv != 0)
    541 		aprint_error_dev(&mly->mly_dv, "unable to create thread (%d)\n",
    542 		    rv);
    543 	return;
    544 
    545  bad:
    546 	if (state > 2)
    547 		mly_release_ccbs(mly);
    548 	if (state > 1)
    549 		mly_dmamem_free(mly, sizeof(struct mly_mmbox),
    550 		    mly->mly_mmbox_dmamap, (void *)mly->mly_mmbox,
    551 		    &mly->mly_mmbox_seg);
    552 	if (state > 0)
    553 		mly_dmamem_free(mly, MLY_SGL_SIZE * MLY_MAX_CCBS,
    554 		    mly->mly_sg_dmamap, (void *)mly->mly_sg,
    555 		    &mly->mly_sg_seg);
    556 }
    557 
    558 /*
    559  * Scan all possible devices on the specified channel.
    560  */
    561 static void
    562 mly_scan_channel(struct mly_softc *mly, int bus)
    563 {
    564 	int s, target;
    565 
    566 	for (target = 0; target < MLY_MAX_TARGETS; target++) {
    567 		s = splbio();
    568 		if (!mly_scan_btl(mly, bus, target)) {
    569 			tsleep(&mly->mly_btl[bus][target], PRIBIO, "mlyscan",
    570 			    0);
    571 		}
    572 		splx(s);
    573 	}
    574 }
    575 
    576 /*
    577  * Shut down all configured `mly' devices.
    578  */
    579 static void
    580 mly_shutdown(void *cookie)
    581 {
    582 	struct mly_softc *mly;
    583 	int i;
    584 
    585 	for (i = 0; i < mly_cd.cd_ndevs; i++) {
    586 		if ((mly = device_lookup_private(&mly_cd, i)) == NULL)
    587 			continue;
    588 
    589 		if (mly_flush(mly))
    590 			aprint_error_dev(&mly->mly_dv, "unable to flush cache\n");
    591 	}
    592 }
    593 
    594 /*
    595  * Fill in the mly_controllerinfo and mly_controllerparam fields in the
    596  * softc.
    597  */
    598 static int
    599 mly_get_controllerinfo(struct mly_softc *mly)
    600 {
    601 	struct mly_cmd_ioctl mci;
    602 	int rv;
    603 
    604 	/*
    605 	 * Build the getcontrollerinfo ioctl and send it.
    606 	 */
    607 	memset(&mci, 0, sizeof(mci));
    608 	mci.sub_ioctl = MDACIOCTL_GETCONTROLLERINFO;
    609 	rv = mly_ioctl(mly, &mci, (void **)&mly->mly_controllerinfo,
    610 	    sizeof(*mly->mly_controllerinfo), NULL, NULL);
    611 	if (rv != 0)
    612 		return (rv);
    613 
    614 	/*
    615 	 * Build the getcontrollerparameter ioctl and send it.
    616 	 */
    617 	memset(&mci, 0, sizeof(mci));
    618 	mci.sub_ioctl = MDACIOCTL_GETCONTROLLERPARAMETER;
    619 	rv = mly_ioctl(mly, &mci, (void **)&mly->mly_controllerparam,
    620 	    sizeof(*mly->mly_controllerparam), NULL, NULL);
    621 
    622 	return (rv);
    623 }
    624 
    625 /*
    626  * Rescan a device, possibly as a consequence of getting an event which
    627  * suggests that it may have changed.  Must be called with interrupts
    628  * blocked.
    629  */
    630 static int
    631 mly_scan_btl(struct mly_softc *mly, int bus, int target)
    632 {
    633 	struct mly_ccb *mc;
    634 	struct mly_cmd_ioctl *mci;
    635 	int rv;
    636 
    637 	if (target == mly->mly_controllerparam->initiator_id) {
    638 		mly->mly_btl[bus][target].mb_flags = MLY_BTL_PROTECTED;
    639 		return (EIO);
    640 	}
    641 
    642 	/* Don't re-scan if a scan is already in progress. */
    643 	if ((mly->mly_btl[bus][target].mb_flags & MLY_BTL_SCANNING) != 0)
    644 		return (EBUSY);
    645 
    646 	/* Get a command. */
    647 	if ((rv = mly_ccb_alloc(mly, &mc)) != 0)
    648 		return (rv);
    649 
    650 	/* Set up the data buffer. */
    651 	mc->mc_data = malloc(sizeof(union mly_devinfo),
    652 	    M_DEVBUF, M_NOWAIT|M_ZERO);
    653 
    654 	mc->mc_flags |= MLY_CCB_DATAIN;
    655 	mc->mc_complete = mly_complete_rescan;
    656 
    657 	/*
    658 	 * Build the ioctl.
    659 	 */
    660 	mci = (struct mly_cmd_ioctl *)&mc->mc_packet->ioctl;
    661 	mci->opcode = MDACMD_IOCTL;
    662 	mci->timeout = 30 | MLY_TIMEOUT_SECONDS;
    663 	memset(&mci->param, 0, sizeof(mci->param));
    664 
    665 	if (MLY_BUS_IS_VIRTUAL(mly, bus)) {
    666 		mc->mc_length = sizeof(struct mly_ioctl_getlogdevinfovalid);
    667 		mci->data_size = htole32(mc->mc_length);
    668 		mci->sub_ioctl = MDACIOCTL_GETLOGDEVINFOVALID;
    669 		_lto3l(MLY_LOGADDR(0, MLY_LOGDEV_ID(mly, bus, target)),
    670 		    mci->addr);
    671 	} else {
    672 		mc->mc_length = sizeof(struct mly_ioctl_getphysdevinfovalid);
    673 		mci->data_size = htole32(mc->mc_length);
    674 		mci->sub_ioctl = MDACIOCTL_GETPHYSDEVINFOVALID;
    675 		_lto3l(MLY_PHYADDR(0, bus, target, 0), mci->addr);
    676 	}
    677 
    678 	/*
    679 	 * Dispatch the command.
    680 	 */
    681 	if ((rv = mly_ccb_map(mly, mc)) != 0) {
    682 		free(mc->mc_data, M_DEVBUF);
    683 		mly_ccb_free(mly, mc);
    684 		return(rv);
    685 	}
    686 
    687 	mly->mly_btl[bus][target].mb_flags |= MLY_BTL_SCANNING;
    688 	mly_ccb_enqueue(mly, mc);
    689 	return (0);
    690 }
    691 
    692 /*
    693  * Handle the completion of a rescan operation.
    694  */
    695 static void
    696 mly_complete_rescan(struct mly_softc *mly, struct mly_ccb *mc)
    697 {
    698 	struct mly_ioctl_getlogdevinfovalid *ldi;
    699 	struct mly_ioctl_getphysdevinfovalid *pdi;
    700 	struct mly_cmd_ioctl *mci;
    701 	struct mly_btl btl, *btlp;
    702 	struct scsipi_xfer_mode xm;
    703 	int bus, target, rescan;
    704 	u_int tmp;
    705 
    706 	mly_ccb_unmap(mly, mc);
    707 
    708 	/*
    709 	 * Recover the bus and target from the command.  We need these even
    710 	 * in the case where we don't have a useful response.
    711 	 */
    712 	mci = (struct mly_cmd_ioctl *)&mc->mc_packet->ioctl;
    713 	tmp = _3ltol(mci->addr);
    714 	rescan = 0;
    715 
    716 	if (mci->sub_ioctl == MDACIOCTL_GETLOGDEVINFOVALID) {
    717 		bus = MLY_LOGDEV_BUS(mly, MLY_LOGADDR_DEV(tmp));
    718 		target = MLY_LOGDEV_TARGET(mly, MLY_LOGADDR_DEV(tmp));
    719 	} else {
    720 		bus = MLY_PHYADDR_CHANNEL(tmp);
    721 		target = MLY_PHYADDR_TARGET(tmp);
    722 	}
    723 
    724 	btlp = &mly->mly_btl[bus][target];
    725 
    726 	/* The default result is 'no device'. */
    727 	memset(&btl, 0, sizeof(btl));
    728 	btl.mb_flags = MLY_BTL_PROTECTED;
    729 
    730 	/* If the rescan completed OK, we have possibly-new BTL data. */
    731 	if (mc->mc_status != 0)
    732 		goto out;
    733 
    734 	if (mc->mc_length == sizeof(*ldi)) {
    735 		ldi = (struct mly_ioctl_getlogdevinfovalid *)mc->mc_data;
    736 		tmp = le32toh(ldi->logical_device_number);
    737 
    738 		if (MLY_LOGDEV_BUS(mly, tmp) != bus ||
    739 		    MLY_LOGDEV_TARGET(mly, tmp) != target) {
    740 #ifdef MLYDEBUG
    741 			printf("%s: WARNING: BTL rescan (logical) for %d:%d "
    742 			    "returned data for %d:%d instead\n",
    743 			   device_xname(&mly->mly_dv), bus, target,
    744 			   MLY_LOGDEV_BUS(mly, tmp),
    745 			   MLY_LOGDEV_TARGET(mly, tmp));
    746 #endif
    747 			goto out;
    748 		}
    749 
    750 		btl.mb_flags = MLY_BTL_LOGICAL | MLY_BTL_TQING;
    751 		btl.mb_type = ldi->raid_level;
    752 		btl.mb_state = ldi->state;
    753 	} else if (mc->mc_length == sizeof(*pdi)) {
    754 		pdi = (struct mly_ioctl_getphysdevinfovalid *)mc->mc_data;
    755 
    756 		if (pdi->channel != bus || pdi->target != target) {
    757 #ifdef MLYDEBUG
    758 			printf("%s: WARNING: BTL rescan (physical) for %d:%d "
    759 			    " returned data for %d:%d instead\n",
    760 			   device_xname(&mly->mly_dv),
    761 			   bus, target, pdi->channel, pdi->target);
    762 #endif
    763 			goto out;
    764 		}
    765 
    766 		btl.mb_flags = MLY_BTL_PHYSICAL;
    767 		btl.mb_type = MLY_DEVICE_TYPE_PHYSICAL;
    768 		btl.mb_state = pdi->state;
    769 		btl.mb_speed = pdi->speed;
    770 		btl.mb_width = pdi->width;
    771 
    772 		if (pdi->state != MLY_DEVICE_STATE_UNCONFIGURED)
    773 			btl.mb_flags |= MLY_BTL_PROTECTED;
    774 		if (pdi->command_tags != 0)
    775 			btl.mb_flags |= MLY_BTL_TQING;
    776 	} else {
    777 		printf("%s: BTL rescan result invalid\n", device_xname(&mly->mly_dv));
    778 		goto out;
    779 	}
    780 
    781 	/* Decide whether we need to rescan the device. */
    782 	if (btl.mb_flags != btlp->mb_flags ||
    783 	    btl.mb_speed != btlp->mb_speed ||
    784 	    btl.mb_width != btlp->mb_width)
    785 		rescan = 1;
    786 
    787  out:
    788 	*btlp = btl;
    789 
    790 	if (rescan && (btl.mb_flags & MLY_BTL_PROTECTED) == 0) {
    791 		xm.xm_target = target;
    792 		mly_get_xfer_mode(mly, bus, &xm);
    793 		/* XXX SCSI mid-layer rescan goes here. */
    794 	}
    795 
    796 	/* Wake anybody waiting on the device to be rescanned. */
    797 	wakeup(btlp);
    798 
    799 	free(mc->mc_data, M_DEVBUF);
    800 	mly_ccb_free(mly, mc);
    801 }
    802 
    803 /*
    804  * Get the current health status and set the 'next event' counter to suit.
    805  */
    806 static int
    807 mly_get_eventstatus(struct mly_softc *mly)
    808 {
    809 	struct mly_cmd_ioctl mci;
    810 	struct mly_health_status *mh;
    811 	int rv;
    812 
    813 	/* Build the gethealthstatus ioctl and send it. */
    814 	memset(&mci, 0, sizeof(mci));
    815 	mh = NULL;
    816 	mci.sub_ioctl = MDACIOCTL_GETHEALTHSTATUS;
    817 
    818 	rv = mly_ioctl(mly, &mci, (void *)&mh, sizeof(*mh), NULL, NULL);
    819 	if (rv)
    820 		return (rv);
    821 
    822 	/* Get the event counter. */
    823 	mly->mly_event_change = le32toh(mh->change_counter);
    824 	mly->mly_event_waiting = le32toh(mh->next_event);
    825 	mly->mly_event_counter = le32toh(mh->next_event);
    826 
    827 	/* Save the health status into the memory mailbox */
    828 	memcpy(&mly->mly_mmbox->mmm_health.status, mh, sizeof(*mh));
    829 
    830 	bus_dmamap_sync(mly->mly_dmat, mly->mly_mmbox_dmamap,
    831 	    offsetof(struct mly_mmbox, mmm_health),
    832 	    sizeof(mly->mly_mmbox->mmm_health),
    833 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
    834 
    835 	free(mh, M_DEVBUF);
    836 	return (0);
    837 }
    838 
    839 /*
    840  * Enable memory mailbox mode.
    841  */
    842 static int
    843 mly_enable_mmbox(struct mly_softc *mly)
    844 {
    845 	struct mly_cmd_ioctl mci;
    846 	u_int8_t *sp;
    847 	u_int64_t tmp;
    848 	int rv;
    849 
    850 	/* Build the ioctl and send it. */
    851 	memset(&mci, 0, sizeof(mci));
    852 	mci.sub_ioctl = MDACIOCTL_SETMEMORYMAILBOX;
    853 
    854 	/* Set buffer addresses. */
    855 	tmp = mly->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_command);
    856 	mci.param.setmemorymailbox.command_mailbox_physaddr = htole64(tmp);
    857 
    858 	tmp = mly->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_status);
    859 	mci.param.setmemorymailbox.status_mailbox_physaddr = htole64(tmp);
    860 
    861 	tmp = mly->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_health);
    862 	mci.param.setmemorymailbox.health_buffer_physaddr = htole64(tmp);
    863 
    864 	/* Set buffer sizes - abuse of data_size field is revolting. */
    865 	sp = (u_int8_t *)&mci.data_size;
    866 	sp[0] = (sizeof(union mly_cmd_packet) * MLY_MMBOX_COMMANDS) >> 10;
    867 	sp[1] = (sizeof(union mly_status_packet) * MLY_MMBOX_STATUS) >> 10;
    868 	mci.param.setmemorymailbox.health_buffer_size =
    869 	    sizeof(union mly_health_region) >> 10;
    870 
    871 	rv = mly_ioctl(mly, &mci, NULL, 0, NULL, NULL);
    872 	if (rv)
    873 		return (rv);
    874 
    875 	mly->mly_state |= MLY_STATE_MMBOX_ACTIVE;
    876 	return (0);
    877 }
    878 
    879 /*
    880  * Flush all pending I/O from the controller.
    881  */
    882 static int
    883 mly_flush(struct mly_softc *mly)
    884 {
    885 	struct mly_cmd_ioctl mci;
    886 
    887 	/* Build the ioctl */
    888 	memset(&mci, 0, sizeof(mci));
    889 	mci.sub_ioctl = MDACIOCTL_FLUSHDEVICEDATA;
    890 	mci.param.deviceoperation.operation_device =
    891 	    MLY_OPDEVICE_PHYSICAL_CONTROLLER;
    892 
    893 	/* Pass it off to the controller */
    894 	return (mly_ioctl(mly, &mci, NULL, 0, NULL, NULL));
    895 }
    896 
    897 /*
    898  * Perform an ioctl command.
    899  *
    900  * If (data) is not NULL, the command requires data transfer to the
    901  * controller.  If (*data) is NULL the command requires data transfer from
    902  * the controller, and we will allocate a buffer for it.
    903  */
    904 static int
    905 mly_ioctl(struct mly_softc *mly, struct mly_cmd_ioctl *ioctl, void **data,
    906 	  size_t datasize, void *sense_buffer,
    907 	  size_t *sense_length)
    908 {
    909 	struct mly_ccb *mc;
    910 	struct mly_cmd_ioctl *mci;
    911 	u_int8_t status;
    912 	int rv;
    913 
    914 	mc = NULL;
    915 	if ((rv = mly_ccb_alloc(mly, &mc)) != 0)
    916 		goto bad;
    917 
    918 	/*
    919 	 * Copy the ioctl structure, but save some important fields and then
    920 	 * fixup.
    921 	 */
    922 	mci = &mc->mc_packet->ioctl;
    923 	ioctl->sense_buffer_address = htole64(mci->sense_buffer_address);
    924 	ioctl->maximum_sense_size = mci->maximum_sense_size;
    925 	*mci = *ioctl;
    926 	mci->opcode = MDACMD_IOCTL;
    927 	mci->timeout = 30 | MLY_TIMEOUT_SECONDS;
    928 
    929 	/* Handle the data buffer. */
    930 	if (data != NULL) {
    931 		if (*data == NULL) {
    932 			/* Allocate data buffer */
    933 			mc->mc_data = malloc(datasize, M_DEVBUF, M_NOWAIT);
    934 			mc->mc_flags |= MLY_CCB_DATAIN;
    935 		} else {
    936 			mc->mc_data = *data;
    937 			mc->mc_flags |= MLY_CCB_DATAOUT;
    938 		}
    939 		mc->mc_length = datasize;
    940 		mc->mc_packet->generic.data_size = htole32(datasize);
    941 	}
    942 
    943 	/* Run the command. */
    944 	if (datasize > 0)
    945 		if ((rv = mly_ccb_map(mly, mc)) != 0)
    946 			goto bad;
    947 	rv = mly_ccb_poll(mly, mc, 30000);
    948 	if (datasize > 0)
    949 		mly_ccb_unmap(mly, mc);
    950 	if (rv != 0)
    951 		goto bad;
    952 
    953 	/* Clean up and return any data. */
    954 	status = mc->mc_status;
    955 
    956 	if (status != 0)
    957 		printf("mly_ioctl: command status %d\n", status);
    958 
    959 	if (mc->mc_sense > 0 && sense_buffer != NULL) {
    960 		memcpy(sense_buffer, mc->mc_packet, mc->mc_sense);
    961 		*sense_length = mc->mc_sense;
    962 		goto bad;
    963 	}
    964 
    965 	/* Should we return a data pointer? */
    966 	if (data != NULL && *data == NULL)
    967 		*data = mc->mc_data;
    968 
    969 	/* Command completed OK. */
    970 	rv = (status != 0 ? EIO : 0);
    971 
    972  bad:
    973 	if (mc != NULL) {
    974 		/* Do we need to free a data buffer we allocated? */
    975 		if (rv != 0 && mc->mc_data != NULL &&
    976 		    (data == NULL || *data == NULL))
    977 			free(mc->mc_data, M_DEVBUF);
    978 		mly_ccb_free(mly, mc);
    979 	}
    980 
    981 	return (rv);
    982 }
    983 
    984 /*
    985  * Check for event(s) outstanding in the controller.
    986  */
    987 static void
    988 mly_check_event(struct mly_softc *mly)
    989 {
    990 
    991 	bus_dmamap_sync(mly->mly_dmat, mly->mly_mmbox_dmamap,
    992 	    offsetof(struct mly_mmbox, mmm_health),
    993 	    sizeof(mly->mly_mmbox->mmm_health),
    994 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
    995 
    996 	/*
    997 	 * The controller may have updated the health status information, so
    998 	 * check for it here.  Note that the counters are all in host
    999 	 * memory, so this check is very cheap.  Also note that we depend on
   1000 	 * checking on completion
   1001 	 */
   1002 	if (le32toh(mly->mly_mmbox->mmm_health.status.change_counter) !=
   1003 	    mly->mly_event_change) {
   1004 		mly->mly_event_change =
   1005 		    le32toh(mly->mly_mmbox->mmm_health.status.change_counter);
   1006 		mly->mly_event_waiting =
   1007 		    le32toh(mly->mly_mmbox->mmm_health.status.next_event);
   1008 
   1009 		/* Wake up anyone that might be interested in this. */
   1010 		wakeup(&mly->mly_event_change);
   1011 	}
   1012 
   1013 	bus_dmamap_sync(mly->mly_dmat, mly->mly_mmbox_dmamap,
   1014 	    offsetof(struct mly_mmbox, mmm_health),
   1015 	    sizeof(mly->mly_mmbox->mmm_health),
   1016 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
   1017 
   1018 	if (mly->mly_event_counter != mly->mly_event_waiting)
   1019 		mly_fetch_event(mly);
   1020 }
   1021 
   1022 /*
   1023  * Fetch one event from the controller.  If we fail due to resource
   1024  * starvation, we'll be retried the next time a command completes.
   1025  */
   1026 static void
   1027 mly_fetch_event(struct mly_softc *mly)
   1028 {
   1029 	struct mly_ccb *mc;
   1030 	struct mly_cmd_ioctl *mci;
   1031 	int s;
   1032 	u_int32_t event;
   1033 
   1034 	/* Get a command. */
   1035 	if (mly_ccb_alloc(mly, &mc))
   1036 		return;
   1037 
   1038 	/* Set up the data buffer. */
   1039 	mc->mc_data = malloc(sizeof(struct mly_event), M_DEVBUF,
   1040 	    M_NOWAIT|M_ZERO);
   1041 
   1042 	mc->mc_length = sizeof(struct mly_event);
   1043 	mc->mc_flags |= MLY_CCB_DATAIN;
   1044 	mc->mc_complete = mly_complete_event;
   1045 
   1046 	/*
   1047 	 * Get an event number to fetch.  It's possible that we've raced
   1048 	 * with another context for the last event, in which case there will
   1049 	 * be no more events.
   1050 	 */
   1051 	s = splbio();
   1052 	if (mly->mly_event_counter == mly->mly_event_waiting) {
   1053 		splx(s);
   1054 		free(mc->mc_data, M_DEVBUF);
   1055 		mly_ccb_free(mly, mc);
   1056 		return;
   1057 	}
   1058 	event = mly->mly_event_counter++;
   1059 	splx(s);
   1060 
   1061 	/*
   1062 	 * Build the ioctl.
   1063 	 *
   1064 	 * At this point we are committed to sending this request, as it
   1065 	 * will be the only one constructed for this particular event
   1066 	 * number.
   1067 	 */
   1068 	mci = (struct mly_cmd_ioctl *)&mc->mc_packet->ioctl;
   1069 	mci->opcode = MDACMD_IOCTL;
   1070 	mci->data_size = htole32(sizeof(struct mly_event));
   1071 	_lto3l(MLY_PHYADDR(0, 0, (event >> 16) & 0xff, (event >> 24) & 0xff),
   1072 	    mci->addr);
   1073 	mci->timeout = 30 | MLY_TIMEOUT_SECONDS;
   1074 	mci->sub_ioctl = MDACIOCTL_GETEVENT;
   1075 	mci->param.getevent.sequence_number_low = htole16(event & 0xffff);
   1076 
   1077 	/*
   1078 	 * Submit the command.
   1079 	 */
   1080 	if (mly_ccb_map(mly, mc) != 0)
   1081 		goto bad;
   1082 	mly_ccb_enqueue(mly, mc);
   1083 	return;
   1084 
   1085  bad:
   1086 	printf("%s: couldn't fetch event %u\n", device_xname(&mly->mly_dv), event);
   1087 	free(mc->mc_data, M_DEVBUF);
   1088 	mly_ccb_free(mly, mc);
   1089 }
   1090 
   1091 /*
   1092  * Handle the completion of an event poll.
   1093  */
   1094 static void
   1095 mly_complete_event(struct mly_softc *mly, struct mly_ccb *mc)
   1096 {
   1097 	struct mly_event *me;
   1098 
   1099 	me = (struct mly_event *)mc->mc_data;
   1100 	mly_ccb_unmap(mly, mc);
   1101 	mly_ccb_free(mly, mc);
   1102 
   1103 	/* If the event was successfully fetched, process it. */
   1104 	if (mc->mc_status == SCSI_OK)
   1105 		mly_process_event(mly, me);
   1106 	else
   1107 		aprint_error_dev(&mly->mly_dv, "unable to fetch event; status = 0x%x\n",
   1108 		    mc->mc_status);
   1109 
   1110 	free(me, M_DEVBUF);
   1111 
   1112 	/* Check for another event. */
   1113 	mly_check_event(mly);
   1114 }
   1115 
   1116 /*
   1117  * Process a controller event.  Called with interrupts blocked (i.e., at
   1118  * interrupt time).
   1119  */
   1120 static void
   1121 mly_process_event(struct mly_softc *mly, struct mly_event *me)
   1122 {
   1123 	struct scsi_sense_data *ssd;
   1124 	int bus, target, event, class, action;
   1125 	const char *fp, *tp;
   1126 
   1127 	ssd = (struct scsi_sense_data *)&me->sense[0];
   1128 
   1129 	/*
   1130 	 * Errors can be reported using vendor-unique sense data.  In this
   1131 	 * case, the event code will be 0x1c (Request sense data present),
   1132 	 * the sense key will be 0x09 (vendor specific), the MSB of the ASC
   1133 	 * will be set, and the actual event code will be a 16-bit value
   1134 	 * comprised of the ASCQ (low byte) and low seven bits of the ASC
   1135 	 * (low seven bits of the high byte).
   1136 	 */
   1137 	if (le32toh(me->code) == 0x1c &&
   1138 	    SSD_SENSE_KEY(ssd->flags) == SKEY_VENDOR_SPECIFIC &&
   1139 	    (ssd->asc & 0x80) != 0) {
   1140 		event = ((int)(ssd->asc & ~0x80) << 8) +
   1141 		    ssd->ascq;
   1142 	} else
   1143 		event = le32toh(me->code);
   1144 
   1145 	/* Look up event, get codes. */
   1146 	fp = mly_describe_code(mly_table_event, event);
   1147 
   1148 	/* Quiet event? */
   1149 	class = fp[0];
   1150 #ifdef notyet
   1151 	if (isupper(class) && bootverbose)
   1152 		class = tolower(class);
   1153 #endif
   1154 
   1155 	/* Get action code, text string. */
   1156 	action = fp[1];
   1157 	tp = fp + 3;
   1158 
   1159 	/*
   1160 	 * Print some information about the event.
   1161 	 *
   1162 	 * This code uses a table derived from the corresponding portion of
   1163 	 * the Linux driver, and thus the parser is very similar.
   1164 	 */
   1165 	switch (class) {
   1166 	case 'p':
   1167 		/*
   1168 		 * Error on physical drive.
   1169 		 */
   1170 		printf("%s: physical device %d:%d %s\n", device_xname(&mly->mly_dv),
   1171 		    me->channel, me->target, tp);
   1172 		if (action == 'r')
   1173 			mly->mly_btl[me->channel][me->target].mb_flags |=
   1174 			    MLY_BTL_RESCAN;
   1175 		break;
   1176 
   1177 	case 'l':
   1178 	case 'm':
   1179 		/*
   1180 		 * Error on logical unit, or message about logical unit.
   1181 	 	 */
   1182 		bus = MLY_LOGDEV_BUS(mly, me->lun);
   1183 		target = MLY_LOGDEV_TARGET(mly, me->lun);
   1184 		printf("%s: logical device %d:%d %s\n", device_xname(&mly->mly_dv),
   1185 		    bus, target, tp);
   1186 		if (action == 'r')
   1187 			mly->mly_btl[bus][target].mb_flags |= MLY_BTL_RESCAN;
   1188 		break;
   1189 
   1190 	case 's':
   1191 		/*
   1192 		 * Report of sense data.
   1193 		 */
   1194 		if ((SSD_SENSE_KEY(ssd->flags) == SKEY_NO_SENSE ||
   1195 		     SSD_SENSE_KEY(ssd->flags) == SKEY_NOT_READY) &&
   1196 		    ssd->asc == 0x04 &&
   1197 		    (ssd->ascq == 0x01 ||
   1198 		     ssd->ascq == 0x02)) {
   1199 			/* Ignore NO_SENSE or NOT_READY in one case */
   1200 			break;
   1201 		}
   1202 
   1203 		/*
   1204 		 * XXX Should translate this if SCSIVERBOSE.
   1205 		 */
   1206 		printf("%s: physical device %d:%d %s\n", device_xname(&mly->mly_dv),
   1207 		    me->channel, me->target, tp);
   1208 		printf("%s:  sense key %d  asc %02x  ascq %02x\n",
   1209 		    device_xname(&mly->mly_dv), SSD_SENSE_KEY(ssd->flags),
   1210 		    ssd->asc, ssd->ascq);
   1211 		printf("%s:  info %x%x%x%x  csi %x%x%x%x\n",
   1212 		    device_xname(&mly->mly_dv), ssd->info[0], ssd->info[1],
   1213 		    ssd->info[2], ssd->info[3], ssd->csi[0],
   1214 		    ssd->csi[1], ssd->csi[2],
   1215 		    ssd->csi[3]);
   1216 		if (action == 'r')
   1217 			mly->mly_btl[me->channel][me->target].mb_flags |=
   1218 			    MLY_BTL_RESCAN;
   1219 		break;
   1220 
   1221 	case 'e':
   1222 		printf("%s: ", device_xname(&mly->mly_dv));
   1223 		printf(tp, me->target, me->lun);
   1224 		break;
   1225 
   1226 	case 'c':
   1227 		printf("%s: controller %s\n", device_xname(&mly->mly_dv), tp);
   1228 		break;
   1229 
   1230 	case '?':
   1231 		printf("%s: %s - %d\n", device_xname(&mly->mly_dv), tp, event);
   1232 		break;
   1233 
   1234 	default:
   1235 		/* Probably a 'noisy' event being ignored. */
   1236 		break;
   1237 	}
   1238 }
   1239 
   1240 /*
   1241  * Perform periodic activities.
   1242  */
   1243 static void
   1244 mly_thread(void *cookie)
   1245 {
   1246 	struct mly_softc *mly;
   1247 	struct mly_btl *btl;
   1248 	int s, bus, target, done;
   1249 
   1250 	mly = (struct mly_softc *)cookie;
   1251 
   1252 	for (;;) {
   1253 		/* Check for new events. */
   1254 		mly_check_event(mly);
   1255 
   1256 		/* Re-scan up to 1 device. */
   1257 		s = splbio();
   1258 		done = 0;
   1259 		for (bus = 0; bus < mly->mly_nchans && !done; bus++) {
   1260 			for (target = 0; target < MLY_MAX_TARGETS; target++) {
   1261 				/* Perform device rescan? */
   1262 				btl = &mly->mly_btl[bus][target];
   1263 				if ((btl->mb_flags & MLY_BTL_RESCAN) != 0) {
   1264 					btl->mb_flags ^= MLY_BTL_RESCAN;
   1265 					mly_scan_btl(mly, bus, target);
   1266 					done = 1;
   1267 					break;
   1268 				}
   1269 			}
   1270 		}
   1271 		splx(s);
   1272 
   1273 		/* Sleep for N seconds. */
   1274 		tsleep(mly_thread, PWAIT, "mlyzzz",
   1275 		    hz * MLY_PERIODIC_INTERVAL);
   1276 	}
   1277 }
   1278 
   1279 /*
   1280  * Submit a command to the controller and poll on completion.  Return
   1281  * non-zero on timeout.
   1282  */
   1283 static int
   1284 mly_ccb_poll(struct mly_softc *mly, struct mly_ccb *mc, int timo)
   1285 {
   1286 	int rv;
   1287 
   1288 	if ((rv = mly_ccb_submit(mly, mc)) != 0)
   1289 		return (rv);
   1290 
   1291 	for (timo *= 10; timo != 0; timo--) {
   1292 		if ((mc->mc_flags & MLY_CCB_COMPLETE) != 0)
   1293 			break;
   1294 		mly_intr(mly);
   1295 		DELAY(100);
   1296 	}
   1297 
   1298 	return (timo == 0);
   1299 }
   1300 
   1301 /*
   1302  * Submit a command to the controller and sleep on completion.  Return
   1303  * non-zero on timeout.
   1304  */
   1305 static int
   1306 mly_ccb_wait(struct mly_softc *mly, struct mly_ccb *mc, int timo)
   1307 {
   1308 	int rv, s;
   1309 
   1310 	mly_ccb_enqueue(mly, mc);
   1311 
   1312 	s = splbio();
   1313 	if ((mc->mc_flags & MLY_CCB_COMPLETE) != 0) {
   1314 		splx(s);
   1315 		return (0);
   1316 	}
   1317 	rv = tsleep(mc, PRIBIO, "mlywccb", timo * hz / 1000);
   1318 	splx(s);
   1319 
   1320 	return (rv);
   1321 }
   1322 
   1323 /*
   1324  * If a CCB is specified, enqueue it.  Pull CCBs off the software queue in
   1325  * the order that they were enqueued and try to submit their command blocks
   1326  * to the controller for execution.
   1327  */
   1328 void
   1329 mly_ccb_enqueue(struct mly_softc *mly, struct mly_ccb *mc)
   1330 {
   1331 	int s;
   1332 
   1333 	s = splbio();
   1334 
   1335 	if (mc != NULL)
   1336 		SIMPLEQ_INSERT_TAIL(&mly->mly_ccb_queue, mc, mc_link.simpleq);
   1337 
   1338 	while ((mc = SIMPLEQ_FIRST(&mly->mly_ccb_queue)) != NULL) {
   1339 		if (mly_ccb_submit(mly, mc))
   1340 			break;
   1341 		SIMPLEQ_REMOVE_HEAD(&mly->mly_ccb_queue, mc_link.simpleq);
   1342 	}
   1343 
   1344 	splx(s);
   1345 }
   1346 
   1347 /*
   1348  * Deliver a command to the controller.
   1349  */
   1350 static int
   1351 mly_ccb_submit(struct mly_softc *mly, struct mly_ccb *mc)
   1352 {
   1353 	union mly_cmd_packet *pkt;
   1354 	int s, off;
   1355 
   1356 	mc->mc_packet->generic.command_id = htole16(mc->mc_slot);
   1357 
   1358 	bus_dmamap_sync(mly->mly_dmat, mly->mly_pkt_dmamap,
   1359 	    mc->mc_packetphys - mly->mly_pkt_busaddr,
   1360 	    sizeof(union mly_cmd_packet),
   1361 	    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
   1362 
   1363 	s = splbio();
   1364 
   1365 	/*
   1366 	 * Do we have to use the hardware mailbox?
   1367 	 */
   1368 	if ((mly->mly_state & MLY_STATE_MMBOX_ACTIVE) == 0) {
   1369 		/*
   1370 		 * Check to see if the controller is ready for us.
   1371 		 */
   1372 		if (mly_idbr_true(mly, MLY_HM_CMDSENT)) {
   1373 			splx(s);
   1374 			return (EBUSY);
   1375 		}
   1376 
   1377 		/*
   1378 		 * It's ready, send the command.
   1379 		 */
   1380 		mly_outl(mly, mly->mly_cmd_mailbox,
   1381 		    (u_int64_t)mc->mc_packetphys & 0xffffffff);
   1382 		mly_outl(mly, mly->mly_cmd_mailbox + 4,
   1383 		    (u_int64_t)mc->mc_packetphys >> 32);
   1384 		mly_outb(mly, mly->mly_idbr, MLY_HM_CMDSENT);
   1385 	} else {
   1386 		pkt = &mly->mly_mmbox->mmm_command[mly->mly_mmbox_cmd_idx];
   1387 		off = (char *)pkt - (char *)mly->mly_mmbox;
   1388 
   1389 		bus_dmamap_sync(mly->mly_dmat, mly->mly_mmbox_dmamap,
   1390 		    off, sizeof(mly->mly_mmbox->mmm_command[0]),
   1391 		    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
   1392 
   1393 		/* Check to see if the next index is free yet. */
   1394 		if (pkt->mmbox.flag != 0) {
   1395 			splx(s);
   1396 			return (EBUSY);
   1397 		}
   1398 
   1399 		/* Copy in new command */
   1400 		memcpy(pkt->mmbox.data, mc->mc_packet->mmbox.data,
   1401 		    sizeof(pkt->mmbox.data));
   1402 
   1403 		/* Copy flag last. */
   1404 		pkt->mmbox.flag = mc->mc_packet->mmbox.flag;
   1405 
   1406 		bus_dmamap_sync(mly->mly_dmat, mly->mly_mmbox_dmamap,
   1407 		    off, sizeof(mly->mly_mmbox->mmm_command[0]),
   1408 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
   1409 
   1410 		/* Signal controller and update index. */
   1411 		mly_outb(mly, mly->mly_idbr, MLY_AM_CMDSENT);
   1412 		mly->mly_mmbox_cmd_idx =
   1413 		    (mly->mly_mmbox_cmd_idx + 1) % MLY_MMBOX_COMMANDS;
   1414 	}
   1415 
   1416 	splx(s);
   1417 	return (0);
   1418 }
   1419 
   1420 /*
   1421  * Pick up completed commands from the controller and handle accordingly.
   1422  */
   1423 int
   1424 mly_intr(void *cookie)
   1425 {
   1426 	struct mly_ccb *mc;
   1427 	union mly_status_packet	*sp;
   1428 	u_int16_t slot;
   1429 	int forus, off;
   1430 	struct mly_softc *mly;
   1431 
   1432 	mly = cookie;
   1433 	forus = 0;
   1434 
   1435 	/*
   1436 	 * Pick up hardware-mailbox commands.
   1437 	 */
   1438 	if (mly_odbr_true(mly, MLY_HM_STSREADY)) {
   1439 		slot = mly_inw(mly, mly->mly_status_mailbox);
   1440 
   1441 		if (slot < MLY_SLOT_MAX) {
   1442 			mc = mly->mly_ccbs + (slot - MLY_SLOT_START);
   1443 			mc->mc_status =
   1444 			    mly_inb(mly, mly->mly_status_mailbox + 2);
   1445 			mc->mc_sense =
   1446 			    mly_inb(mly, mly->mly_status_mailbox + 3);
   1447 			mc->mc_resid =
   1448 			    mly_inl(mly, mly->mly_status_mailbox + 4);
   1449 
   1450 			mly_ccb_complete(mly, mc);
   1451 		} else {
   1452 			/* Slot 0xffff may mean "extremely bogus command". */
   1453 			printf("%s: got HM completion for illegal slot %u\n",
   1454 			    device_xname(&mly->mly_dv), slot);
   1455 		}
   1456 
   1457 		/* Unconditionally acknowledge status. */
   1458 		mly_outb(mly, mly->mly_odbr, MLY_HM_STSREADY);
   1459 		mly_outb(mly, mly->mly_idbr, MLY_HM_STSACK);
   1460 		forus = 1;
   1461 	}
   1462 
   1463 	/*
   1464 	 * Pick up memory-mailbox commands.
   1465 	 */
   1466 	if (mly_odbr_true(mly, MLY_AM_STSREADY)) {
   1467 		for (;;) {
   1468 			sp = &mly->mly_mmbox->mmm_status[mly->mly_mmbox_sts_idx];
   1469 			off = (char *)sp - (char *)mly->mly_mmbox;
   1470 
   1471 			bus_dmamap_sync(mly->mly_dmat, mly->mly_mmbox_dmamap,
   1472 			    off, sizeof(mly->mly_mmbox->mmm_command[0]),
   1473 			    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
   1474 
   1475 			/* Check for more status. */
   1476 			if (sp->mmbox.flag == 0)
   1477 				break;
   1478 
   1479 			/* Get slot number. */
   1480 			slot = le16toh(sp->status.command_id);
   1481 			if (slot < MLY_SLOT_MAX) {
   1482 				mc = mly->mly_ccbs + (slot - MLY_SLOT_START);
   1483 				mc->mc_status = sp->status.status;
   1484 				mc->mc_sense = sp->status.sense_length;
   1485 				mc->mc_resid = le32toh(sp->status.residue);
   1486 				mly_ccb_complete(mly, mc);
   1487 			} else {
   1488 				/*
   1489 				 * Slot 0xffff may mean "extremely bogus
   1490 				 * command".
   1491 				 */
   1492 				printf("%s: got AM completion for illegal "
   1493 				    "slot %u at %d\n", device_xname(&mly->mly_dv),
   1494 				    slot, mly->mly_mmbox_sts_idx);
   1495 			}
   1496 
   1497 			/* Clear and move to next index. */
   1498 			sp->mmbox.flag = 0;
   1499 			mly->mly_mmbox_sts_idx =
   1500 			    (mly->mly_mmbox_sts_idx + 1) % MLY_MMBOX_STATUS;
   1501 		}
   1502 
   1503 		/* Acknowledge that we have collected status value(s). */
   1504 		mly_outb(mly, mly->mly_odbr, MLY_AM_STSREADY);
   1505 		forus = 1;
   1506 	}
   1507 
   1508 	/*
   1509 	 * Run the queue.
   1510 	 */
   1511 	if (forus && ! SIMPLEQ_EMPTY(&mly->mly_ccb_queue))
   1512 		mly_ccb_enqueue(mly, NULL);
   1513 
   1514 	return (forus);
   1515 }
   1516 
   1517 /*
   1518  * Process completed commands
   1519  */
   1520 static void
   1521 mly_ccb_complete(struct mly_softc *mly, struct mly_ccb *mc)
   1522 {
   1523 	void (*complete)(struct mly_softc *, struct mly_ccb *);
   1524 
   1525 	bus_dmamap_sync(mly->mly_dmat, mly->mly_pkt_dmamap,
   1526 	    mc->mc_packetphys - mly->mly_pkt_busaddr,
   1527 	    sizeof(union mly_cmd_packet),
   1528 	    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
   1529 
   1530 	complete = mc->mc_complete;
   1531 	mc->mc_flags |= MLY_CCB_COMPLETE;
   1532 
   1533 	/*
   1534 	 * Call completion handler or wake up sleeping consumer.
   1535 	 */
   1536 	if (complete != NULL)
   1537 		(*complete)(mly, mc);
   1538 	else
   1539 		wakeup(mc);
   1540 }
   1541 
   1542 /*
   1543  * Allocate a command.
   1544  */
   1545 int
   1546 mly_ccb_alloc(struct mly_softc *mly, struct mly_ccb **mcp)
   1547 {
   1548 	struct mly_ccb *mc;
   1549 	int s;
   1550 
   1551 	s = splbio();
   1552 	mc = SLIST_FIRST(&mly->mly_ccb_free);
   1553 	if (mc != NULL)
   1554 		SLIST_REMOVE_HEAD(&mly->mly_ccb_free, mc_link.slist);
   1555 	splx(s);
   1556 
   1557 	*mcp = mc;
   1558 	return (mc == NULL ? EAGAIN : 0);
   1559 }
   1560 
   1561 /*
   1562  * Release a command back to the freelist.
   1563  */
   1564 void
   1565 mly_ccb_free(struct mly_softc *mly, struct mly_ccb *mc)
   1566 {
   1567 	int s;
   1568 
   1569 	/*
   1570 	 * Fill in parts of the command that may cause confusion if a
   1571 	 * consumer doesn't when we are later allocated.
   1572 	 */
   1573 	mc->mc_data = NULL;
   1574 	mc->mc_flags = 0;
   1575 	mc->mc_complete = NULL;
   1576 	mc->mc_private = NULL;
   1577 	mc->mc_packet->generic.command_control = 0;
   1578 
   1579 	/*
   1580 	 * By default, we set up to overwrite the command packet with sense
   1581 	 * information.
   1582 	 */
   1583 	mc->mc_packet->generic.sense_buffer_address =
   1584 	    htole64(mc->mc_packetphys);
   1585 	mc->mc_packet->generic.maximum_sense_size =
   1586 	    sizeof(union mly_cmd_packet);
   1587 
   1588 	s = splbio();
   1589 	SLIST_INSERT_HEAD(&mly->mly_ccb_free, mc, mc_link.slist);
   1590 	splx(s);
   1591 }
   1592 
   1593 /*
   1594  * Allocate and initialize command and packet structures.
   1595  *
   1596  * If the controller supports fewer than MLY_MAX_CCBS commands, limit our
   1597  * allocation to that number.  If we don't yet know how many commands the
   1598  * controller supports, allocate a very small set (suitable for initialization
   1599  * purposes only).
   1600  */
   1601 static int
   1602 mly_alloc_ccbs(struct mly_softc *mly)
   1603 {
   1604 	struct mly_ccb *mc;
   1605 	int i, rv;
   1606 
   1607 	if (mly->mly_controllerinfo == NULL)
   1608 		mly->mly_ncmds = MLY_CCBS_RESV;
   1609 	else {
   1610 		i = le16toh(mly->mly_controllerinfo->maximum_parallel_commands);
   1611 		mly->mly_ncmds = min(MLY_MAX_CCBS, i);
   1612 	}
   1613 
   1614 	/*
   1615 	 * Allocate enough space for all the command packets in one chunk
   1616 	 * and map them permanently into controller-visible space.
   1617 	 */
   1618 	rv = mly_dmamem_alloc(mly,
   1619 	    mly->mly_ncmds * sizeof(union mly_cmd_packet),
   1620 	    &mly->mly_pkt_dmamap, (void **)&mly->mly_pkt,
   1621 	    &mly->mly_pkt_busaddr, &mly->mly_pkt_seg);
   1622 	if (rv)
   1623 		return (rv);
   1624 
   1625 	mly->mly_ccbs = malloc(sizeof(struct mly_ccb) * mly->mly_ncmds,
   1626 	    M_DEVBUF, M_NOWAIT|M_ZERO);
   1627 
   1628 	for (i = 0; i < mly->mly_ncmds; i++) {
   1629 		mc = mly->mly_ccbs + i;
   1630 		mc->mc_slot = MLY_SLOT_START + i;
   1631 		mc->mc_packet = mly->mly_pkt + i;
   1632 		mc->mc_packetphys = mly->mly_pkt_busaddr +
   1633 		    (i * sizeof(union mly_cmd_packet));
   1634 
   1635 		rv = bus_dmamap_create(mly->mly_dmat, MLY_MAX_XFER,
   1636 		    MLY_MAX_SEGS, MLY_MAX_XFER, 0,
   1637 		    BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
   1638 		    &mc->mc_datamap);
   1639 		if (rv) {
   1640 			mly_release_ccbs(mly);
   1641 			return (rv);
   1642 		}
   1643 
   1644 		mly_ccb_free(mly, mc);
   1645 	}
   1646 
   1647 	return (0);
   1648 }
   1649 
   1650 /*
   1651  * Free all the storage held by commands.
   1652  *
   1653  * Must be called with all commands on the free list.
   1654  */
   1655 static void
   1656 mly_release_ccbs(struct mly_softc *mly)
   1657 {
   1658 	struct mly_ccb *mc;
   1659 
   1660 	/* Throw away command buffer DMA maps. */
   1661 	while (mly_ccb_alloc(mly, &mc) == 0)
   1662 		bus_dmamap_destroy(mly->mly_dmat, mc->mc_datamap);
   1663 
   1664 	/* Release CCB storage. */
   1665 	free(mly->mly_ccbs, M_DEVBUF);
   1666 
   1667 	/* Release the packet storage. */
   1668 	mly_dmamem_free(mly, mly->mly_ncmds * sizeof(union mly_cmd_packet),
   1669 	    mly->mly_pkt_dmamap, (void *)mly->mly_pkt, &mly->mly_pkt_seg);
   1670 }
   1671 
   1672 /*
   1673  * Map a command into controller-visible space.
   1674  */
   1675 static int
   1676 mly_ccb_map(struct mly_softc *mly, struct mly_ccb *mc)
   1677 {
   1678 	struct mly_cmd_generic *gen;
   1679 	struct mly_sg_entry *sg;
   1680 	bus_dma_segment_t *ds;
   1681 	int flg, nseg, rv;
   1682 
   1683 #ifdef DIAGNOSTIC
   1684 	/* Don't map more than once. */
   1685 	if ((mc->mc_flags & MLY_CCB_MAPPED) != 0)
   1686 		panic("mly_ccb_map: already mapped");
   1687 	mc->mc_flags |= MLY_CCB_MAPPED;
   1688 
   1689 	/* Does the command have a data buffer? */
   1690 	if (mc->mc_data == NULL)
   1691 		panic("mly_ccb_map: no data buffer");
   1692 #endif
   1693 
   1694 	rv = bus_dmamap_load(mly->mly_dmat, mc->mc_datamap, mc->mc_data,
   1695 	    mc->mc_length, NULL, BUS_DMA_NOWAIT | BUS_DMA_STREAMING |
   1696 	    ((mc->mc_flags & MLY_CCB_DATAIN) != 0 ?
   1697 	    BUS_DMA_READ : BUS_DMA_WRITE));
   1698 	if (rv != 0)
   1699 		return (rv);
   1700 
   1701 	gen = &mc->mc_packet->generic;
   1702 
   1703 	/*
   1704 	 * Can we use the transfer structure directly?
   1705 	 */
   1706 	if ((nseg = mc->mc_datamap->dm_nsegs) <= 2) {
   1707 		mc->mc_sgoff = -1;
   1708 		sg = &gen->transfer.direct.sg[0];
   1709 	} else {
   1710 		mc->mc_sgoff = (mc->mc_slot - MLY_SLOT_START) *
   1711 		    MLY_MAX_SEGS;
   1712 		sg = mly->mly_sg + mc->mc_sgoff;
   1713 		gen->command_control |= MLY_CMDCTL_EXTENDED_SG_TABLE;
   1714 		gen->transfer.indirect.entries[0] = htole16(nseg);
   1715 		gen->transfer.indirect.table_physaddr[0] =
   1716 		    htole64(mly->mly_sg_busaddr +
   1717 		    (mc->mc_sgoff * sizeof(struct mly_sg_entry)));
   1718 	}
   1719 
   1720 	/*
   1721 	 * Fill the S/G table.
   1722 	 */
   1723 	for (ds = mc->mc_datamap->dm_segs; nseg != 0; nseg--, sg++, ds++) {
   1724 		sg->physaddr = htole64(ds->ds_addr);
   1725 		sg->length = htole64(ds->ds_len);
   1726 	}
   1727 
   1728 	/*
   1729 	 * Sync up the data map.
   1730 	 */
   1731 	if ((mc->mc_flags & MLY_CCB_DATAIN) != 0)
   1732 		flg = BUS_DMASYNC_PREREAD;
   1733 	else /* if ((mc->mc_flags & MLY_CCB_DATAOUT) != 0) */ {
   1734 		gen->command_control |= MLY_CMDCTL_DATA_DIRECTION;
   1735 		flg = BUS_DMASYNC_PREWRITE;
   1736 	}
   1737 
   1738 	bus_dmamap_sync(mly->mly_dmat, mc->mc_datamap, 0, mc->mc_length, flg);
   1739 
   1740 	/*
   1741 	 * Sync up the chained S/G table, if we're using one.
   1742 	 */
   1743 	if (mc->mc_sgoff == -1)
   1744 		return (0);
   1745 
   1746 	bus_dmamap_sync(mly->mly_dmat, mly->mly_sg_dmamap, mc->mc_sgoff,
   1747 	    MLY_SGL_SIZE, BUS_DMASYNC_PREWRITE);
   1748 
   1749 	return (0);
   1750 }
   1751 
   1752 /*
   1753  * Unmap a command from controller-visible space.
   1754  */
   1755 static void
   1756 mly_ccb_unmap(struct mly_softc *mly, struct mly_ccb *mc)
   1757 {
   1758 	int flg;
   1759 
   1760 #ifdef DIAGNOSTIC
   1761 	if ((mc->mc_flags & MLY_CCB_MAPPED) == 0)
   1762 		panic("mly_ccb_unmap: not mapped");
   1763 	mc->mc_flags &= ~MLY_CCB_MAPPED;
   1764 #endif
   1765 
   1766 	if ((mc->mc_flags & MLY_CCB_DATAIN) != 0)
   1767 		flg = BUS_DMASYNC_POSTREAD;
   1768 	else /* if ((mc->mc_flags & MLY_CCB_DATAOUT) != 0) */
   1769 		flg = BUS_DMASYNC_POSTWRITE;
   1770 
   1771 	bus_dmamap_sync(mly->mly_dmat, mc->mc_datamap, 0, mc->mc_length, flg);
   1772 	bus_dmamap_unload(mly->mly_dmat, mc->mc_datamap);
   1773 
   1774 	if (mc->mc_sgoff == -1)
   1775 		return;
   1776 
   1777 	bus_dmamap_sync(mly->mly_dmat, mly->mly_sg_dmamap, mc->mc_sgoff,
   1778 	    MLY_SGL_SIZE, BUS_DMASYNC_POSTWRITE);
   1779 }
   1780 
   1781 /*
   1782  * Adjust the size of each I/O before it passes to the SCSI layer.
   1783  */
   1784 static void
   1785 mly_scsipi_minphys(struct buf *bp)
   1786 {
   1787 
   1788 	if (bp->b_bcount > MLY_MAX_XFER)
   1789 		bp->b_bcount = MLY_MAX_XFER;
   1790 	minphys(bp);
   1791 }
   1792 
   1793 /*
   1794  * Start a SCSI command.
   1795  */
   1796 static void
   1797 mly_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req,
   1798 		   void *arg)
   1799 {
   1800 	struct mly_ccb *mc;
   1801 	struct mly_cmd_scsi_small *ss;
   1802 	struct scsipi_xfer *xs;
   1803 	struct scsipi_periph *periph;
   1804 	struct mly_softc *mly;
   1805 	struct mly_btl *btl;
   1806 	int s, tmp;
   1807 
   1808 	mly = device_private(chan->chan_adapter->adapt_dev);
   1809 
   1810 	switch (req) {
   1811 	case ADAPTER_REQ_RUN_XFER:
   1812 		xs = arg;
   1813 		periph = xs->xs_periph;
   1814 		btl = &mly->mly_btl[chan->chan_channel][periph->periph_target];
   1815 		s = splbio();
   1816 		tmp = btl->mb_flags;
   1817 		splx(s);
   1818 
   1819 		/*
   1820 		 * Check for I/O attempt to a protected or non-existant
   1821 		 * device.
   1822 		 */
   1823 		if ((tmp & MLY_BTL_PROTECTED) != 0) {
   1824 			xs->error = XS_SELTIMEOUT;
   1825 			scsipi_done(xs);
   1826 			break;
   1827 		}
   1828 
   1829 #ifdef DIAGNOSTIC
   1830 		/* XXX Increase if/when we support large SCSI commands. */
   1831 		if (xs->cmdlen > MLY_CMD_SCSI_SMALL_CDB) {
   1832 			printf("%s: cmd too large\n", device_xname(&mly->mly_dv));
   1833 			xs->error = XS_DRIVER_STUFFUP;
   1834 			scsipi_done(xs);
   1835 			break;
   1836 		}
   1837 #endif
   1838 
   1839 		if (mly_ccb_alloc(mly, &mc)) {
   1840 			xs->error = XS_RESOURCE_SHORTAGE;
   1841 			scsipi_done(xs);
   1842 			break;
   1843 		}
   1844 
   1845 		/* Build the command. */
   1846 		mc->mc_data = xs->data;
   1847 		mc->mc_length = xs->datalen;
   1848 		mc->mc_complete = mly_scsipi_complete;
   1849 		mc->mc_private = xs;
   1850 
   1851 		/* Build the packet for the controller. */
   1852 		ss = &mc->mc_packet->scsi_small;
   1853 		ss->opcode = MDACMD_SCSI;
   1854 #ifdef notdef
   1855 		/*
   1856 		 * XXX FreeBSD does this, but it doesn't fix anything,
   1857 		 * XXX and appears potentially harmful.
   1858 		 */
   1859 		ss->command_control |= MLY_CMDCTL_DISABLE_DISCONNECT;
   1860 #endif
   1861 
   1862 		ss->data_size = htole32(xs->datalen);
   1863 		_lto3l(MLY_PHYADDR(0, chan->chan_channel,
   1864 		    periph->periph_target, periph->periph_lun), ss->addr);
   1865 
   1866 		if (xs->timeout < 60 * 1000)
   1867 			ss->timeout = xs->timeout / 1000 |
   1868 			    MLY_TIMEOUT_SECONDS;
   1869 		else if (xs->timeout < 60 * 60 * 1000)
   1870 			ss->timeout = xs->timeout / (60 * 1000) |
   1871 			    MLY_TIMEOUT_MINUTES;
   1872 		else
   1873 			ss->timeout = xs->timeout / (60 * 60 * 1000) |
   1874 			    MLY_TIMEOUT_HOURS;
   1875 
   1876 		ss->maximum_sense_size = sizeof(xs->sense);
   1877 		ss->cdb_length = xs->cmdlen;
   1878 		memcpy(ss->cdb, xs->cmd, xs->cmdlen);
   1879 
   1880 		if (mc->mc_length != 0) {
   1881 			if ((xs->xs_control & XS_CTL_DATA_OUT) != 0)
   1882 				mc->mc_flags |= MLY_CCB_DATAOUT;
   1883 			else /* if ((xs->xs_control & XS_CTL_DATA_IN) != 0) */
   1884 				mc->mc_flags |= MLY_CCB_DATAIN;
   1885 
   1886 			if (mly_ccb_map(mly, mc) != 0) {
   1887 				xs->error = XS_DRIVER_STUFFUP;
   1888 				mly_ccb_free(mly, mc);
   1889 				scsipi_done(xs);
   1890 				break;
   1891 			}
   1892 		}
   1893 
   1894 		/*
   1895 		 * Give the command to the controller.
   1896 		 */
   1897 		if ((xs->xs_control & XS_CTL_POLL) != 0) {
   1898 			if (mly_ccb_poll(mly, mc, xs->timeout + 5000)) {
   1899 				xs->error = XS_REQUEUE;
   1900 				if (mc->mc_length != 0)
   1901 					mly_ccb_unmap(mly, mc);
   1902 				mly_ccb_free(mly, mc);
   1903 				scsipi_done(xs);
   1904 			}
   1905 		} else
   1906 			mly_ccb_enqueue(mly, mc);
   1907 
   1908 		break;
   1909 
   1910 	case ADAPTER_REQ_GROW_RESOURCES:
   1911 		/*
   1912 		 * Not supported.
   1913 		 */
   1914 		break;
   1915 
   1916 	case ADAPTER_REQ_SET_XFER_MODE:
   1917 		/*
   1918 		 * We can't change the transfer mode, but at least let
   1919 		 * scsipi know what the adapter has negotiated.
   1920 		 */
   1921 		mly_get_xfer_mode(mly, chan->chan_channel, arg);
   1922 		break;
   1923 	}
   1924 }
   1925 
   1926 /*
   1927  * Handle completion of a SCSI command.
   1928  */
   1929 static void
   1930 mly_scsipi_complete(struct mly_softc *mly, struct mly_ccb *mc)
   1931 {
   1932 	struct scsipi_xfer *xs;
   1933 	struct scsipi_channel *chan;
   1934 	struct scsipi_inquiry_data *inq;
   1935 	struct mly_btl *btl;
   1936 	int target, sl, s;
   1937 	const char *p;
   1938 
   1939 	xs = mc->mc_private;
   1940 	xs->status = mc->mc_status;
   1941 
   1942 	/*
   1943 	 * XXX The `resid' value as returned by the controller appears to be
   1944 	 * bogus, so we always set it to zero.  Is it perhaps the transfer
   1945 	 * count?
   1946 	 */
   1947 	xs->resid = 0; /* mc->mc_resid; */
   1948 
   1949 	if (mc->mc_length != 0)
   1950 		mly_ccb_unmap(mly, mc);
   1951 
   1952 	switch (mc->mc_status) {
   1953 	case SCSI_OK:
   1954 		/*
   1955 		 * In order to report logical device type and status, we
   1956 		 * overwrite the result of the INQUIRY command to logical
   1957 		 * devices.
   1958 		 */
   1959 		if (xs->cmd->opcode == INQUIRY) {
   1960 			chan = xs->xs_periph->periph_channel;
   1961 			target = xs->xs_periph->periph_target;
   1962 			btl = &mly->mly_btl[chan->chan_channel][target];
   1963 
   1964 			s = splbio();
   1965 			if ((btl->mb_flags & MLY_BTL_LOGICAL) != 0) {
   1966 				inq = (struct scsipi_inquiry_data *)xs->data;
   1967 				mly_padstr(inq->vendor, "MYLEX", 8);
   1968 				p = mly_describe_code(mly_table_device_type,
   1969 				    btl->mb_type);
   1970 				mly_padstr(inq->product, p, 16);
   1971 				p = mly_describe_code(mly_table_device_state,
   1972 				    btl->mb_state);
   1973 				mly_padstr(inq->revision, p, 4);
   1974 			}
   1975 			splx(s);
   1976 		}
   1977 
   1978 		xs->error = XS_NOERROR;
   1979 		break;
   1980 
   1981 	case SCSI_CHECK:
   1982 		sl = mc->mc_sense;
   1983 		if (sl > sizeof(xs->sense.scsi_sense))
   1984 			sl = sizeof(xs->sense.scsi_sense);
   1985 		memcpy(&xs->sense.scsi_sense, mc->mc_packet, sl);
   1986 		xs->error = XS_SENSE;
   1987 		break;
   1988 
   1989 	case SCSI_BUSY:
   1990 	case SCSI_QUEUE_FULL:
   1991 		xs->error = XS_BUSY;
   1992 		break;
   1993 
   1994 	default:
   1995 		printf("%s: unknown SCSI status 0x%x\n",
   1996 		    device_xname(&mly->mly_dv), xs->status);
   1997 		xs->error = XS_DRIVER_STUFFUP;
   1998 		break;
   1999 	}
   2000 
   2001 	mly_ccb_free(mly, mc);
   2002 	scsipi_done(xs);
   2003 }
   2004 
   2005 /*
   2006  * Notify scsipi about a target's transfer mode.
   2007  */
   2008 static void
   2009 mly_get_xfer_mode(struct mly_softc *mly, int bus, struct scsipi_xfer_mode *xm)
   2010 {
   2011 	struct mly_btl *btl;
   2012 	int s;
   2013 
   2014 	btl = &mly->mly_btl[bus][xm->xm_target];
   2015 	xm->xm_mode = 0;
   2016 
   2017 	s = splbio();
   2018 
   2019 	if ((btl->mb_flags & MLY_BTL_PHYSICAL) != 0) {
   2020 		if (btl->mb_speed == 0) {
   2021 			xm->xm_period = 0;
   2022 			xm->xm_offset = 0;
   2023 		} else {
   2024 			xm->xm_period = 12;			/* XXX */
   2025 			xm->xm_offset = 8;			/* XXX */
   2026 			xm->xm_mode |= PERIPH_CAP_SYNC;		/* XXX */
   2027 		}
   2028 
   2029 		switch (btl->mb_width) {
   2030 		case 32:
   2031 			xm->xm_mode = PERIPH_CAP_WIDE32;
   2032 			break;
   2033 		case 16:
   2034 			xm->xm_mode = PERIPH_CAP_WIDE16;
   2035 			break;
   2036 		default:
   2037 			xm->xm_mode = 0;
   2038 			break;
   2039 		}
   2040 	} else /* ((btl->mb_flags & MLY_BTL_LOGICAL) != 0) */ {
   2041 		xm->xm_mode = PERIPH_CAP_WIDE16 | PERIPH_CAP_SYNC;
   2042 		xm->xm_period = 12;
   2043 		xm->xm_offset = 8;
   2044 	}
   2045 
   2046 	if ((btl->mb_flags & MLY_BTL_TQING) != 0)
   2047 		xm->xm_mode |= PERIPH_CAP_TQING;
   2048 
   2049 	splx(s);
   2050 
   2051 	scsipi_async_event(&mly->mly_chans[bus], ASYNC_EVENT_XFER_MODE, xm);
   2052 }
   2053 
   2054 /*
   2055  * ioctl hook; used here only to initiate low-level rescans.
   2056  */
   2057 static int
   2058 mly_scsipi_ioctl(struct scsipi_channel *chan, u_long cmd, void *data,
   2059     int flag, struct proc *p)
   2060 {
   2061 	struct mly_softc *mly;
   2062 	int rv;
   2063 
   2064 	mly = device_private(chan->chan_adapter->adapt_dev);
   2065 
   2066 	switch (cmd) {
   2067 	case SCBUSIOLLSCAN:
   2068 		mly_scan_channel(mly, chan->chan_channel);
   2069 		rv = 0;
   2070 		break;
   2071 	default:
   2072 		rv = ENOTTY;
   2073 		break;
   2074 	}
   2075 
   2076 	return (rv);
   2077 }
   2078 
   2079 /*
   2080  * Handshake with the firmware while the card is being initialized.
   2081  */
   2082 static int
   2083 mly_fwhandshake(struct mly_softc *mly)
   2084 {
   2085 	u_int8_t error, param0, param1;
   2086 	int spinup;
   2087 
   2088 	spinup = 0;
   2089 
   2090 	/* Set HM_STSACK and let the firmware initialize. */
   2091 	mly_outb(mly, mly->mly_idbr, MLY_HM_STSACK);
   2092 	DELAY(1000);	/* too short? */
   2093 
   2094 	/* If HM_STSACK is still true, the controller is initializing. */
   2095 	if (!mly_idbr_true(mly, MLY_HM_STSACK))
   2096 		return (0);
   2097 
   2098 	printf("%s: controller initialization started\n",
   2099 	    device_xname(&mly->mly_dv));
   2100 
   2101 	/*
   2102 	 * Spin waiting for initialization to finish, or for a message to be
   2103 	 * delivered.
   2104 	 */
   2105 	while (mly_idbr_true(mly, MLY_HM_STSACK)) {
   2106 		/* Check for a message */
   2107 		if (!mly_error_valid(mly))
   2108 			continue;
   2109 
   2110 		error = mly_inb(mly, mly->mly_error_status) & ~MLY_MSG_EMPTY;
   2111 		param0 = mly_inb(mly, mly->mly_cmd_mailbox);
   2112 		param1 = mly_inb(mly, mly->mly_cmd_mailbox + 1);
   2113 
   2114 		switch (error) {
   2115 		case MLY_MSG_SPINUP:
   2116 			if (!spinup) {
   2117 				printf("%s: drive spinup in progress\n",
   2118 				    device_xname(&mly->mly_dv));
   2119 				spinup = 1;
   2120 			}
   2121 			break;
   2122 
   2123 		case MLY_MSG_RACE_RECOVERY_FAIL:
   2124 			printf("%s: mirror race recovery failed - \n",
   2125 			    device_xname(&mly->mly_dv));
   2126 			printf("%s: one or more drives offline\n",
   2127 			    device_xname(&mly->mly_dv));
   2128 			break;
   2129 
   2130 		case MLY_MSG_RACE_IN_PROGRESS:
   2131 			printf("%s: mirror race recovery in progress\n",
   2132 			    device_xname(&mly->mly_dv));
   2133 			break;
   2134 
   2135 		case MLY_MSG_RACE_ON_CRITICAL:
   2136 			printf("%s: mirror race recovery on critical drive\n",
   2137 			    device_xname(&mly->mly_dv));
   2138 			break;
   2139 
   2140 		case MLY_MSG_PARITY_ERROR:
   2141 			printf("%s: FATAL MEMORY PARITY ERROR\n",
   2142 			    device_xname(&mly->mly_dv));
   2143 			return (ENXIO);
   2144 
   2145 		default:
   2146 			printf("%s: unknown initialization code 0x%x\n",
   2147 			    device_xname(&mly->mly_dv), error);
   2148 			break;
   2149 		}
   2150 	}
   2151 
   2152 	return (0);
   2153 }
   2154 
   2155 /*
   2156  * Space-fill a character string
   2157  */
   2158 static void
   2159 mly_padstr(char *dst, const char *src, int len)
   2160 {
   2161 
   2162 	while (len-- > 0) {
   2163 		if (*src != '\0')
   2164 			*dst++ = *src++;
   2165 		else
   2166 			*dst++ = ' ';
   2167 	}
   2168 }
   2169 
   2170 /*
   2171  * Allocate DMA safe memory.
   2172  */
   2173 static int
   2174 mly_dmamem_alloc(struct mly_softc *mly, int size, bus_dmamap_t *dmamap,
   2175 		 void **kva, bus_addr_t *paddr, bus_dma_segment_t *seg)
   2176 {
   2177 	int rseg, rv, state;
   2178 
   2179 	state = 0;
   2180 
   2181 	if ((rv = bus_dmamem_alloc(mly->mly_dmat, size, PAGE_SIZE, 0,
   2182 	    seg, 1, &rseg, BUS_DMA_NOWAIT)) != 0) {
   2183 		aprint_error_dev(&mly->mly_dv, "dmamem_alloc = %d\n", rv);
   2184 		goto bad;
   2185 	}
   2186 
   2187 	state++;
   2188 
   2189 	if ((rv = bus_dmamem_map(mly->mly_dmat, seg, 1, size, kva,
   2190 	    BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) {
   2191 		aprint_error_dev(&mly->mly_dv, "dmamem_map = %d\n", rv);
   2192 		goto bad;
   2193 	}
   2194 
   2195 	state++;
   2196 
   2197 	if ((rv = bus_dmamap_create(mly->mly_dmat, size, size, 1, 0,
   2198 	    BUS_DMA_NOWAIT, dmamap)) != 0) {
   2199 		aprint_error_dev(&mly->mly_dv, "dmamap_create = %d\n", rv);
   2200 		goto bad;
   2201 	}
   2202 
   2203 	state++;
   2204 
   2205 	if ((rv = bus_dmamap_load(mly->mly_dmat, *dmamap, *kva, size,
   2206 	    NULL, BUS_DMA_NOWAIT)) != 0) {
   2207 		aprint_error_dev(&mly->mly_dv, "dmamap_load = %d\n", rv);
   2208 		goto bad;
   2209 	}
   2210 
   2211 	*paddr = (*dmamap)->dm_segs[0].ds_addr;
   2212 	memset(*kva, 0, size);
   2213 	return (0);
   2214 
   2215  bad:
   2216 	if (state > 2)
   2217 		bus_dmamap_destroy(mly->mly_dmat, *dmamap);
   2218 	if (state > 1)
   2219 		bus_dmamem_unmap(mly->mly_dmat, *kva, size);
   2220 	if (state > 0)
   2221 		bus_dmamem_free(mly->mly_dmat, seg, 1);
   2222 
   2223 	return (rv);
   2224 }
   2225 
   2226 /*
   2227  * Free DMA safe memory.
   2228  */
   2229 static void
   2230 mly_dmamem_free(struct mly_softc *mly, int size, bus_dmamap_t dmamap,
   2231 		void *kva, bus_dma_segment_t *seg)
   2232 {
   2233 
   2234 	bus_dmamap_unload(mly->mly_dmat, dmamap);
   2235 	bus_dmamap_destroy(mly->mly_dmat, dmamap);
   2236 	bus_dmamem_unmap(mly->mly_dmat, kva, size);
   2237 	bus_dmamem_free(mly->mly_dmat, seg, 1);
   2238 }
   2239 
   2240 
   2241 /*
   2242  * Accept an open operation on the control device.
   2243  */
   2244 int
   2245 mlyopen(dev_t dev, int flag, int mode, struct lwp *l)
   2246 {
   2247 	struct mly_softc *mly;
   2248 
   2249 	if ((mly = device_lookup_private(&mly_cd, minor(dev))) == NULL)
   2250 		return (ENXIO);
   2251 	if ((mly->mly_state & MLY_STATE_INITOK) == 0)
   2252 		return (ENXIO);
   2253 	if ((mly->mly_state & MLY_STATE_OPEN) != 0)
   2254 		return (EBUSY);
   2255 
   2256 	mly->mly_state |= MLY_STATE_OPEN;
   2257 	return (0);
   2258 }
   2259 
   2260 /*
   2261  * Accept the last close on the control device.
   2262  */
   2263 int
   2264 mlyclose(dev_t dev, int flag, int mode,
   2265     struct lwp *l)
   2266 {
   2267 	struct mly_softc *mly;
   2268 
   2269 	mly = device_lookup_private(&mly_cd, minor(dev));
   2270 	mly->mly_state &= ~MLY_STATE_OPEN;
   2271 	return (0);
   2272 }
   2273 
   2274 /*
   2275  * Handle control operations.
   2276  */
   2277 int
   2278 mlyioctl(dev_t dev, u_long cmd, void *data, int flag,
   2279     struct lwp *l)
   2280 {
   2281 	struct mly_softc *mly;
   2282 	int rv;
   2283 
   2284 	mly = device_lookup_private(&mly_cd, minor(dev));
   2285 
   2286 	switch (cmd) {
   2287 	case MLYIO_COMMAND:
   2288 		rv = kauth_authorize_device_passthru(l->l_cred, dev,
   2289 		    KAUTH_REQ_DEVICE_RAWIO_PASSTHRU_ALL, data);
   2290 		if (rv)
   2291 			break;
   2292 
   2293 		rv = mly_user_command(mly, (void *)data);
   2294 		break;
   2295 	case MLYIO_HEALTH:
   2296 		rv = mly_user_health(mly, (void *)data);
   2297 		break;
   2298 	default:
   2299 		rv = ENOTTY;
   2300 		break;
   2301 	}
   2302 
   2303 	return (rv);
   2304 }
   2305 
   2306 /*
   2307  * Execute a command passed in from userspace.
   2308  *
   2309  * The control structure contains the actual command for the controller, as
   2310  * well as the user-space data pointer and data size, and an optional sense
   2311  * buffer size/pointer.  On completion, the data size is adjusted to the
   2312  * command residual, and the sense buffer size to the size of the returned
   2313  * sense data.
   2314  */
   2315 static int
   2316 mly_user_command(struct mly_softc *mly, struct mly_user_command *uc)
   2317 {
   2318 	struct mly_ccb	*mc;
   2319 	int rv, mapped;
   2320 
   2321 	if ((rv = mly_ccb_alloc(mly, &mc)) != 0)
   2322 		return (rv);
   2323 
   2324 	mapped = 0;
   2325 	mc->mc_data = NULL;
   2326 
   2327 	/*
   2328 	 * Handle data size/direction.
   2329 	 */
   2330 	if ((mc->mc_length = abs(uc->DataTransferLength)) != 0) {
   2331 		if (mc->mc_length > MAXPHYS) {
   2332 			rv = EINVAL;
   2333 			goto out;
   2334 		}
   2335 
   2336 		mc->mc_data = malloc(mc->mc_length, M_DEVBUF, M_WAITOK);
   2337 		if (mc->mc_data == NULL) {
   2338 			rv = ENOMEM;
   2339 			goto out;
   2340 		}
   2341 
   2342 		if (uc->DataTransferLength > 0) {
   2343 			mc->mc_flags |= MLY_CCB_DATAIN;
   2344 			memset(mc->mc_data, 0, mc->mc_length);
   2345 		}
   2346 
   2347 		if (uc->DataTransferLength < 0) {
   2348 			mc->mc_flags |= MLY_CCB_DATAOUT;
   2349 			rv = copyin(uc->DataTransferBuffer, mc->mc_data,
   2350 			    mc->mc_length);
   2351 			if (rv != 0)
   2352 				goto out;
   2353 		}
   2354 
   2355 		if ((rv = mly_ccb_map(mly, mc)) != 0)
   2356 			goto out;
   2357 		mapped = 1;
   2358 	}
   2359 
   2360 	/* Copy in the command and execute it. */
   2361 	memcpy(mc->mc_packet, &uc->CommandMailbox, sizeof(uc->CommandMailbox));
   2362 
   2363 	if ((rv = mly_ccb_wait(mly, mc, 60000)) != 0)
   2364 		goto out;
   2365 
   2366 	/* Return the data to userspace. */
   2367 	if (uc->DataTransferLength > 0) {
   2368 		rv = copyout(mc->mc_data, uc->DataTransferBuffer,
   2369 		    mc->mc_length);
   2370 		if (rv != 0)
   2371 			goto out;
   2372 	}
   2373 
   2374 	/* Return the sense buffer to userspace. */
   2375 	if (uc->RequestSenseLength > 0 && mc->mc_sense > 0) {
   2376 		rv = copyout(mc->mc_packet, uc->RequestSenseBuffer,
   2377 		    min(uc->RequestSenseLength, mc->mc_sense));
   2378 		if (rv != 0)
   2379 			goto out;
   2380 	}
   2381 
   2382 	/* Return command results to userspace (caller will copy out). */
   2383 	uc->DataTransferLength = mc->mc_resid;
   2384 	uc->RequestSenseLength = min(uc->RequestSenseLength, mc->mc_sense);
   2385 	uc->CommandStatus = mc->mc_status;
   2386 	rv = 0;
   2387 
   2388  out:
   2389  	if (mapped)
   2390  		mly_ccb_unmap(mly, mc);
   2391 	if (mc->mc_data != NULL)
   2392 		free(mc->mc_data, M_DEVBUF);
   2393 	mly_ccb_free(mly, mc);
   2394 
   2395 	return (rv);
   2396 }
   2397 
   2398 /*
   2399  * Return health status to userspace.  If the health change index in the
   2400  * user structure does not match that currently exported by the controller,
   2401  * we return the current status immediately.  Otherwise, we block until
   2402  * either interrupted or new status is delivered.
   2403  */
   2404 static int
   2405 mly_user_health(struct mly_softc *mly, struct mly_user_health *uh)
   2406 {
   2407 	struct mly_health_status mh;
   2408 	int rv, s;
   2409 
   2410 	/* Fetch the current health status from userspace. */
   2411 	rv = copyin(uh->HealthStatusBuffer, &mh, sizeof(mh));
   2412 	if (rv != 0)
   2413 		return (rv);
   2414 
   2415 	/* spin waiting for a status update */
   2416 	s = splbio();
   2417 	if (mly->mly_event_change == mh.change_counter)
   2418 		rv = tsleep(&mly->mly_event_change, PRIBIO | PCATCH,
   2419 		    "mlyhealth", 0);
   2420 	splx(s);
   2421 
   2422 	if (rv == 0) {
   2423 		/*
   2424 		 * Copy the controller's health status buffer out (there is
   2425 		 * a race here if it changes again).
   2426 		 */
   2427 		rv = copyout(&mly->mly_mmbox->mmm_health.status,
   2428 		    uh->HealthStatusBuffer, sizeof(uh->HealthStatusBuffer));
   2429 	}
   2430 
   2431 	return (rv);
   2432 }
   2433