Home | History | Annotate | Line # | Download | only in pci
twa.c revision 1.50
      1 /*	$NetBSD: twa.c,v 1.49 2014/03/29 19:28:25 christos Exp $ */
      2 /*	$wasabi: twa.c,v 1.27 2006/07/28 18:17:21 wrstuden Exp $	*/
      3 
      4 /*-
      5  * Copyright (c) 2004 The NetBSD Foundation, Inc.
      6  * All rights reserved.
      7  *
      8  * This code is derived from software contributed to The NetBSD Foundation
      9  * by Jordan Rhody of Wasabi Systems, Inc.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions and the following disclaimer.
     16  * 2. Redistributions in binary form must reproduce the above copyright
     17  *    notice, this list of conditions and the following disclaimer in the
     18  *    documentation and/or other materials provided with the distribution.
     19  *
     20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     30  * POSSIBILITY OF SUCH DAMAGE.
     31  */
     32 
     33 /*-
     34  * Copyright (c) 2003-04 3ware, Inc.
     35  * Copyright (c) 2000 Michael Smith
     36  * Copyright (c) 2000 BSDi
     37  * All rights reserved.
     38  *
     39  * Redistribution and use in source and binary forms, with or without
     40  * modification, are permitted provided that the following conditions
     41  * are met:
     42  * 1. Redistributions of source code must retain the above copyright
     43  *    notice, this list of conditions and the following disclaimer.
     44  * 2. Redistributions in binary form must reproduce the above copyright
     45  *    notice, this list of conditions and the following disclaimer in the
     46  *    documentation and/or other materials provided with the distribution.
     47  *
     48  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     49  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     50  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     51  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     52  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     53  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     54  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     55  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     56  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     57  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     58  * SUCH DAMAGE.
     59  *
     60  *	$FreeBSD: src/sys/dev/twa/twa.c,v 1.2 2004/04/02 15:09:57 des Exp $
     61  */
     62 
     63 /*
     64  * 3ware driver for 9000 series storage controllers.
     65  *
     66  * Author: Vinod Kashyap
     67  */
     68 
     69 #include <sys/cdefs.h>
     70 __KERNEL_RCSID(0, "$NetBSD: twa.c,v 1.49 2014/03/29 19:28:25 christos Exp $");
     71 
     72 //#define TWA_DEBUG
     73 
     74 #include <sys/param.h>
     75 #include <sys/systm.h>
     76 #include <sys/kernel.h>
     77 #include <sys/device.h>
     78 #include <sys/queue.h>
     79 #include <sys/proc.h>
     80 #include <sys/bswap.h>
     81 #include <sys/buf.h>
     82 #include <sys/bufq.h>
     83 #include <sys/endian.h>
     84 #include <sys/malloc.h>
     85 #include <sys/conf.h>
     86 #include <sys/disk.h>
     87 #include <sys/sysctl.h>
     88 #include <sys/syslog.h>
     89 
     90 #include <sys/bus.h>
     91 
     92 #include <dev/pci/pcireg.h>
     93 #include <dev/pci/pcivar.h>
     94 #include <dev/pci/pcidevs.h>
     95 #include <dev/pci/twareg.h>
     96 #include <dev/pci/twavar.h>
     97 #include <dev/pci/twaio.h>
     98 
     99 #include <dev/scsipi/scsipi_all.h>
    100 #include <dev/scsipi/scsipi_disk.h>
    101 #include <dev/scsipi/scsipiconf.h>
    102 #include <dev/scsipi/scsi_spc.h>
    103 
    104 #include <dev/ldvar.h>
    105 
    106 #include "locators.h"
    107 
    108 #define	PCI_CBIO	0x10
    109 
    110 static int	twa_fetch_aen(struct twa_softc *);
    111 static void	twa_aen_callback(struct twa_request *);
    112 static int	twa_find_aen(struct twa_softc *sc, uint16_t);
    113 static uint16_t	twa_enqueue_aen(struct twa_softc *sc,
    114 			struct twa_command_header *);
    115 
    116 static void	twa_attach(device_t, device_t, void *);
    117 static void	twa_shutdown(void *);
    118 static int	twa_init_connection(struct twa_softc *, uint16_t, uint32_t,
    119 				    uint16_t, uint16_t, uint16_t, uint16_t, uint16_t *,
    120 					uint16_t *, uint16_t *, uint16_t *, uint32_t *);
    121 static int	twa_intr(void *);
    122 static int 	twa_match(device_t, cfdata_t, void *);
    123 static int	twa_reset(struct twa_softc *);
    124 
    125 static int	twa_print(void *, const char *);
    126 static int	twa_soft_reset(struct twa_softc *);
    127 
    128 static int	twa_check_ctlr_state(struct twa_softc *, uint32_t);
    129 static int	twa_get_param(struct twa_softc *, int, int, size_t,
    130 				void (* callback)(struct twa_request *),
    131 				struct twa_param_9k **);
    132 static int 	twa_set_param(struct twa_softc *, int, int, int, void *,
    133 				void (* callback)(struct twa_request *));
    134 static void	twa_describe_controller(struct twa_softc *);
    135 static int	twa_wait_status(struct twa_softc *, uint32_t, uint32_t);
    136 static int	twa_done(struct twa_softc *);
    137 
    138 extern struct	cfdriver twa_cd;
    139 extern uint32_t twa_fw_img_size;
    140 extern uint8_t	twa_fw_img[];
    141 
    142 CFATTACH_DECL_NEW(twa, sizeof(struct twa_softc),
    143     twa_match, twa_attach, NULL, NULL);
    144 
    145 /* FreeBSD driver revision for sysctl expected by the 3ware cli */
    146 const char twaver[] = "1.50.01.002";
    147 
    148 /* AEN messages. */
    149 static const struct twa_message	twa_aen_table[] = {
    150 	{0x0000, "AEN queue empty"},
    151 	{0x0001, "Controller reset occurred"},
    152 	{0x0002, "Degraded unit detected"},
    153 	{0x0003, "Controller error occured"},
    154 	{0x0004, "Background rebuild failed"},
    155 	{0x0005, "Background rebuild done"},
    156 	{0x0006, "Incomplete unit detected"},
    157 	{0x0007, "Background initialize done"},
    158 	{0x0008, "Unclean shutdown detected"},
    159 	{0x0009, "Drive timeout detected"},
    160 	{0x000A, "Drive error detected"},
    161 	{0x000B, "Rebuild started"},
    162 	{0x000C, "Background initialize started"},
    163 	{0x000D, "Entire logical unit was deleted"},
    164 	{0x000E, "Background initialize failed"},
    165 	{0x000F, "SMART attribute exceeded threshold"},
    166 	{0x0010, "Power supply reported AC under range"},
    167 	{0x0011, "Power supply reported DC out of range"},
    168 	{0x0012, "Power supply reported a malfunction"},
    169 	{0x0013, "Power supply predicted malfunction"},
    170 	{0x0014, "Battery charge is below threshold"},
    171 	{0x0015, "Fan speed is below threshold"},
    172 	{0x0016, "Temperature sensor is above threshold"},
    173 	{0x0017, "Power supply was removed"},
    174 	{0x0018, "Power supply was inserted"},
    175 	{0x0019, "Drive was removed from a bay"},
    176 	{0x001A, "Drive was inserted into a bay"},
    177 	{0x001B, "Drive bay cover door was opened"},
    178 	{0x001C, "Drive bay cover door was closed"},
    179 	{0x001D, "Product case was opened"},
    180 	{0x0020, "Prepare for shutdown (power-off)"},
    181 	{0x0021, "Downgrade UDMA mode to lower speed"},
    182 	{0x0022, "Upgrade UDMA mode to higher speed"},
    183 	{0x0023, "Sector repair completed"},
    184 	{0x0024, "Sbuf memory test failed"},
    185 	{0x0025, "Error flushing cached write data to disk"},
    186 	{0x0026, "Drive reported data ECC error"},
    187 	{0x0027, "DCB has checksum error"},
    188 	{0x0028, "DCB version is unsupported"},
    189 	{0x0029, "Background verify started"},
    190 	{0x002A, "Background verify failed"},
    191 	{0x002B, "Background verify done"},
    192 	{0x002C, "Bad sector overwritten during rebuild"},
    193 	{0x002D, "Source drive error occurred"},
    194 	{0x002E, "Replace failed because replacement drive too small"},
    195 	{0x002F, "Verify failed because array was never initialized"},
    196 	{0x0030, "Unsupported ATA drive"},
    197 	{0x0031, "Synchronize host/controller time"},
    198 	{0x0032, "Spare capacity is inadequate for some units"},
    199 	{0x0033, "Background migration started"},
    200 	{0x0034, "Background migration failed"},
    201 	{0x0035, "Background migration done"},
    202 	{0x0036, "Verify detected and fixed data/parity mismatch"},
    203 	{0x0037, "SO-DIMM incompatible"},
    204 	{0x0038, "SO-DIMM not detected"},
    205 	{0x0039, "Corrected Sbuf ECC error"},
    206 	{0x003A, "Drive power on reset detected"},
    207 	{0x003B, "Background rebuild paused"},
    208 	{0x003C, "Background initialize paused"},
    209 	{0x003D, "Background verify paused"},
    210 	{0x003E, "Background migration paused"},
    211 	{0x003F, "Corrupt flash file system detected"},
    212 	{0x0040, "Flash file system repaired"},
    213 	{0x0041, "Unit number assignments were lost"},
    214 	{0x0042, "Error during read of primary DCB"},
    215 	{0x0043, "Latent error found in backup DCB"},
    216 	{0x0044, "Battery voltage is normal"},
    217 	{0x0045, "Battery voltage is low"},
    218 	{0x0046, "Battery voltage is high"},
    219 	{0x0047, "Battery voltage is too low"},
    220 	{0x0048, "Battery voltage is too high"},
    221 	{0x0049, "Battery temperature is normal"},
    222 	{0x004A, "Battery temperature is low"},
    223 	{0x004B, "Battery temperature is high"},
    224 	{0x004C, "Battery temperature is too low"},
    225 	{0x004D, "Battery temperature is too high"},
    226 	{0x004E, "Battery capacity test started"},
    227 	{0x004F, "Cache synchronization skipped"},
    228 	{0x0050, "Battery capacity test completed"},
    229 	{0x0051, "Battery health check started"},
    230 	{0x0052, "Battery health check completed"},
    231 	{0x0053, "Battery capacity test needed"},
    232 	{0x0054, "Battery charge termination voltage is at high level"},
    233 	{0x0055, "Battery charging started"},
    234 	{0x0056, "Battery charging completed"},
    235 	{0x0057, "Battery charging fault"},
    236 	{0x0058, "Battery capacity is below warning level"},
    237 	{0x0059, "Battery capacity is below error level"},
    238 	{0x005A, "Battery is present"},
    239 	{0x005B, "Battery is not present"},
    240 	{0x005C, "Battery is weak"},
    241 	{0x005D, "Battery health check failed"},
    242 	{0x005E, "Cache synchronized after power fail"},
    243 	{0x005F, "Cache synchronization failed; some data lost"},
    244 	{0x0060, "Bad cache meta data checksum"},
    245 	{0x0061, "Bad cache meta data signature"},
    246 	{0x0062, "Cache meta data restore failed"},
    247 	{0x0063, "BBU not found after power fail"},
    248 	{0x00FC, "Recovered/finished array membership update"},
    249 	{0x00FD, "Handler lockup"},
    250 	{0x00FE, "Retrying PCI transfer"},
    251 	{0x00FF, "AEN queue is full"},
    252 	{0xFFFFFFFF, NULL}
    253 };
    254 
    255 /* AEN severity table. */
    256 static const char	*twa_aen_severity_table[] = {
    257 	"None",
    258 	"ERROR",
    259 	"WARNING",
    260 	"INFO",
    261 	"DEBUG",
    262 	NULL
    263 };
    264 
    265 #if 0
    266 /* Error messages. */
    267 static const struct twa_message	twa_error_table[] = {
    268 	{0x0100, "SGL entry contains zero data"},
    269 	{0x0101, "Invalid command opcode"},
    270 	{0x0102, "SGL entry has unaligned address"},
    271 	{0x0103, "SGL size does not match command"},
    272 	{0x0104, "SGL entry has illegal length"},
    273 	{0x0105, "Command packet is not aligned"},
    274 	{0x0106, "Invalid request ID"},
    275 	{0x0107, "Duplicate request ID"},
    276 	{0x0108, "ID not locked"},
    277 	{0x0109, "LBA out of range"},
    278 	{0x010A, "Logical unit not supported"},
    279 	{0x010B, "Parameter table does not exist"},
    280 	{0x010C, "Parameter index does not exist"},
    281 	{0x010D, "Invalid field in CDB"},
    282 	{0x010E, "Specified port has invalid drive"},
    283 	{0x010F, "Parameter item size mismatch"},
    284 	{0x0110, "Failed memory allocation"},
    285 	{0x0111, "Memory request too large"},
    286 	{0x0112, "Out of memory segments"},
    287 	{0x0113, "Invalid address to deallocate"},
    288 	{0x0114, "Out of memory"},
    289 	{0x0115, "Out of heap"},
    290 	{0x0120, "Double degrade"},
    291 	{0x0121, "Drive not degraded"},
    292 	{0x0122, "Reconstruct error"},
    293 	{0x0123, "Replace not accepted"},
    294 	{0x0124, "Replace drive capacity too small"},
    295 	{0x0125, "Sector count not allowed"},
    296 	{0x0126, "No spares left"},
    297 	{0x0127, "Reconstruct error"},
    298 	{0x0128, "Unit is offline"},
    299 	{0x0129, "Cannot update status to DCB"},
    300 	{0x0130, "Invalid stripe handle"},
    301 	{0x0131, "Handle that was not locked"},
    302 	{0x0132, "Handle that was not empy"},
    303 	{0x0133, "Handle has different owner"},
    304 	{0x0140, "IPR has parent"},
    305 	{0x0150, "Illegal Pbuf address alignment"},
    306 	{0x0151, "Illegal Pbuf transfer length"},
    307 	{0x0152, "Illegal Sbuf address alignment"},
    308 	{0x0153, "Illegal Sbuf transfer length"},
    309 	{0x0160, "Command packet too large"},
    310 	{0x0161, "SGL exceeds maximum length"},
    311 	{0x0162, "SGL has too many entries"},
    312 	{0x0170, "Insufficient resources for rebuilder"},
    313 	{0x0171, "Verify error (data != parity)"},
    314 	{0x0180, "Requested segment not in directory of this DCB"},
    315 	{0x0181, "DCB segment has unsupported version"},
    316 	{0x0182, "DCB segment has checksum error"},
    317 	{0x0183, "DCB support (settings) segment invalid"},
    318 	{0x0184, "DCB UDB (unit descriptor block) segment invalid"},
    319 	{0x0185, "DCB GUID (globally unique identifier) segment invalid"},
    320 	{0x01A0, "Could not clear Sbuf"},
    321 	{0x01C0, "Flash identify failed"},
    322 	{0x01C1, "Flash out of bounds"},
    323 	{0x01C2, "Flash verify error"},
    324 	{0x01C3, "Flash file object not found"},
    325 	{0x01C4, "Flash file already present"},
    326 	{0x01C5, "Flash file system full"},
    327 	{0x01C6, "Flash file not present"},
    328 	{0x01C7, "Flash file size error"},
    329 	{0x01C8, "Bad flash file checksum"},
    330 	{0x01CA, "Corrupt flash file system detected"},
    331 	{0x01D0, "Invalid field in parameter list"},
    332 	{0x01D1, "Parameter list length error"},
    333 	{0x01D2, "Parameter item is not changeable"},
    334 	{0x01D3, "Parameter item is not saveable"},
    335 	{0x0200, "UDMA CRC error"},
    336 	{0x0201, "Internal CRC error"},
    337 	{0x0202, "Data ECC error"},
    338 	{0x0203, "ADP level 1 error"},
    339 	{0x0204, "Port timeout"},
    340 	{0x0205, "Drive power on reset"},
    341 	{0x0206, "ADP level 2 error"},
    342 	{0x0207, "Soft reset failed"},
    343 	{0x0208, "Drive not ready"},
    344 	{0x0209, "Unclassified port error"},
    345 	{0x020A, "Drive aborted command"},
    346 	{0x0210, "Internal CRC error"},
    347 	{0x0211, "Host PCI bus abort"},
    348 	{0x0212, "Host PCI parity error"},
    349 	{0x0213, "Port handler error"},
    350 	{0x0214, "Token interrupt count error"},
    351 	{0x0215, "Timeout waiting for PCI transfer"},
    352 	{0x0216, "Corrected buffer ECC"},
    353 	{0x0217, "Uncorrected buffer ECC"},
    354 	{0x0230, "Unsupported command during flash recovery"},
    355 	{0x0231, "Next image buffer expected"},
    356 	{0x0232, "Binary image architecture incompatible"},
    357 	{0x0233, "Binary image has no signature"},
    358 	{0x0234, "Binary image has bad checksum"},
    359 	{0x0235, "Image downloaded overflowed buffer"},
    360 	{0x0240, "I2C device not found"},
    361 	{0x0241, "I2C transaction aborted"},
    362 	{0x0242, "SO-DIMM parameter(s) incompatible using defaults"},
    363 	{0x0243, "SO-DIMM unsupported"},
    364 	{0x0248, "SPI transfer status error"},
    365 	{0x0249, "SPI transfer timeout error"},
    366 	{0x0250, "Invalid unit descriptor size in CreateUnit"},
    367 	{0x0251, "Unit descriptor size exceeds data buffer in CreateUnit"},
    368 	{0x0252, "Invalid value in CreateUnit descriptor"},
    369 	{0x0253, "Inadequate disk space to support descriptor in CreateUnit"},
    370 	{0x0254, "Unable to create data channel for this unit descriptor"},
    371 	{0x0255, "CreateUnit descriptor specifies a drive already in use"},
    372 	{0x0256, "Unable to write configuration to all disks during CreateUnit"},
    373 	{0x0257, "CreateUnit does not support this descriptor version"},
    374 	{0x0258, "Invalid subunit for RAID 0 or 5 in CreateUnit"},
    375 	{0x0259, "Too many descriptors in CreateUnit"},
    376 	{0x025A, "Invalid configuration specified in CreateUnit descriptor"},
    377 	{0x025B, "Invalid LBA offset specified in CreateUnit descriptor"},
    378 	{0x025C, "Invalid stripelet size specified in CreateUnit descriptor"},
    379 	{0x0260, "SMART attribute exceeded threshold"},
    380 	{0xFFFFFFFF, NULL}
    381 };
    382 #endif
    383 
    384 struct twa_pci_identity {
    385 	uint32_t	vendor_id;
    386 	uint32_t	product_id;
    387 	const char	*name;
    388 };
    389 
    390 static const struct twa_pci_identity twa_pci_products[] = {
    391 	{ PCI_VENDOR_3WARE,
    392 	  PCI_PRODUCT_3WARE_9000,
    393 	  "3ware 9000 series",
    394 	},
    395 	{ PCI_VENDOR_3WARE,
    396 	  PCI_PRODUCT_3WARE_9550,
    397 	  "3ware 9550SX series",
    398 	},
    399 	{ PCI_VENDOR_3WARE,
    400 	  PCI_PRODUCT_3WARE_9650,
    401 	  "3ware 9650SE series",
    402 	},
    403 	{ PCI_VENDOR_3WARE,
    404 	  PCI_PRODUCT_3WARE_9690,
    405 	  "3ware 9690 series",
    406 	},
    407 	{ 0,
    408 	  0,
    409 	  NULL,
    410 	},
    411 };
    412 
    413 
    414 static inline void
    415 twa_outl(struct twa_softc *sc, int off, uint32_t val)
    416 {
    417 
    418 	bus_space_write_4(sc->twa_bus_iot, sc->twa_bus_ioh, off, val);
    419 	bus_space_barrier(sc->twa_bus_iot, sc->twa_bus_ioh, off, 4,
    420 	    BUS_SPACE_BARRIER_WRITE);
    421 }
    422 
    423 static inline uint32_t	twa_inl(struct twa_softc *sc, int off)
    424 {
    425 
    426 	bus_space_barrier(sc->twa_bus_iot, sc->twa_bus_ioh, off, 4,
    427 	    BUS_SPACE_BARRIER_WRITE | BUS_SPACE_BARRIER_READ);
    428 	return (bus_space_read_4(sc->twa_bus_iot, sc->twa_bus_ioh, off));
    429 }
    430 
    431 void
    432 twa_request_wait_handler(struct twa_request *tr)
    433 {
    434 
    435 	wakeup(tr);
    436 }
    437 
    438 static const struct twa_pci_identity *
    439 twa_lookup(pcireg_t id)
    440 {
    441 	const struct twa_pci_identity *entry;
    442 	int i;
    443 
    444 	for (i = 0; i < __arraycount(twa_pci_products); i++) {
    445 		entry = &twa_pci_products[i];
    446 		if (entry->vendor_id == PCI_VENDOR(id) &&
    447 		    entry->product_id == PCI_PRODUCT(id)) {
    448 			return entry;
    449 		}
    450 	}
    451 	return NULL;
    452 }
    453 
    454 static int
    455 twa_match(device_t parent, cfdata_t cfdata, void *aux)
    456 {
    457 	struct pci_attach_args *pa = aux;
    458 	const struct twa_pci_identity *entry;
    459 
    460 	entry = twa_lookup(pa->pa_id);
    461 	if (entry != NULL) {
    462 		return 1;
    463 	}
    464 	return (0);
    465 }
    466 
    467 static const char *
    468 twa_find_msg_string(const struct twa_message *table, uint16_t code)
    469 {
    470 	int	i;
    471 
    472 	for (i = 0; table[i].message != NULL; i++)
    473 		if (table[i].code == code)
    474 			return(table[i].message);
    475 
    476 	return(table[i].message);
    477 }
    478 
    479 void
    480 twa_release_request(struct twa_request *tr)
    481 {
    482 	int s;
    483 	struct twa_softc *sc;
    484 
    485 	sc = tr->tr_sc;
    486 
    487 	if ((tr->tr_flags & TWA_CMD_AEN) == 0) {
    488 		s = splbio();
    489 		TAILQ_INSERT_TAIL(&tr->tr_sc->twa_free, tr, tr_link);
    490 		splx(s);
    491 		if (__predict_false((tr->tr_sc->twa_sc_flags &
    492 		    TWA_STATE_REQUEST_WAIT) != 0)) {
    493 			tr->tr_sc->twa_sc_flags &= ~TWA_STATE_REQUEST_WAIT;
    494 			wakeup(&sc->twa_free);
    495 		}
    496 	} else
    497 		tr->tr_flags &= ~TWA_CMD_AEN_BUSY;
    498 }
    499 
    500 static void
    501 twa_unmap_request(struct twa_request *tr)
    502 {
    503 	struct twa_softc	*sc = tr->tr_sc;
    504 	uint8_t			cmd_status;
    505 	int s;
    506 
    507 	/* If the command involved data, unmap that too. */
    508 	if (tr->tr_data != NULL) {
    509 		if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_9K)
    510 			cmd_status = tr->tr_command->command.cmd_pkt_9k.status;
    511 		else
    512 			cmd_status =
    513 			      tr->tr_command->command.cmd_pkt_7k.generic.status;
    514 
    515 		if (tr->tr_flags & TWA_CMD_DATA_OUT) {
    516 			bus_dmamap_sync(tr->tr_sc->twa_dma_tag, tr->tr_dma_map,
    517 				0, tr->tr_length, BUS_DMASYNC_POSTREAD);
    518 			/*
    519 			 * If we are using a bounce buffer, and we are reading
    520 			 * data, copy the real data in.
    521 			 */
    522 			if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED)
    523 				if (cmd_status == 0)
    524 					memcpy(tr->tr_real_data, tr->tr_data,
    525 						tr->tr_real_length);
    526 		}
    527 		if (tr->tr_flags & TWA_CMD_DATA_IN)
    528 			bus_dmamap_sync(tr->tr_sc->twa_dma_tag, tr->tr_dma_map,
    529 				0, tr->tr_length, BUS_DMASYNC_POSTWRITE);
    530 
    531 		bus_dmamap_unload(sc->twa_dma_tag, tr->tr_dma_map);
    532 	}
    533 
    534 	/* Free alignment buffer if it was used. */
    535 	if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED) {
    536 		s = splvm();
    537 		uvm_km_kmem_free(kmem_va_arena, (vaddr_t)tr->tr_data,
    538 		    tr->tr_length);
    539 		splx(s);
    540 		tr->tr_data = tr->tr_real_data;
    541 		tr->tr_length = tr->tr_real_length;
    542 	}
    543 }
    544 
    545 /*
    546  * Function name:	twa_wait_request
    547  * Description:		Sends down a firmware cmd, and waits for the completion,
    548  *			but NOT in a tight loop.
    549  *
    550  * Input:		tr	-- ptr to request pkt
    551  *			timeout -- max # of seconds to wait before giving up
    552  * Output:		None
    553  * Return value:	0	-- success
    554  *			non-zero-- failure
    555  */
    556 static int
    557 twa_wait_request(struct twa_request *tr, uint32_t timeout)
    558 {
    559 	time_t	end_time;
    560 	struct timeval	t1;
    561 	int	s, rv;
    562 
    563 	tr->tr_flags |= TWA_CMD_SLEEP_ON_REQUEST;
    564 	tr->tr_callback = twa_request_wait_handler;
    565 	tr->tr_status = TWA_CMD_BUSY;
    566 
    567 	rv = twa_map_request(tr);
    568 
    569 	if (rv != 0)
    570 		return (rv);
    571 
    572 	microtime(&t1);
    573 	end_time = t1.tv_usec +
    574 		(timeout * 1000 * 100);
    575 
    576 	while (tr->tr_status != TWA_CMD_COMPLETE) {
    577 		rv = tr->tr_error;
    578 		if (rv != 0)
    579 			return(rv);
    580 		if ((rv = tsleep(tr, PRIBIO, "twawait", timeout * hz)) == 0)
    581 			break;
    582 
    583 		if (rv == EWOULDBLOCK) {
    584 			/*
    585 			 * We will reset the controller only if the request has
    586 			 * already been submitted, so as to not lose the
    587 			 * request packet.  If a busy request timed out, the
    588 			 * reset will take care of freeing resources.  If a
    589 			 * pending request timed out, we will free resources
    590 			 * for that request, right here.  So, the caller is
    591 			 * expected to NOT cleanup when ETIMEDOUT is returned.
    592 			 */
    593 			if (tr->tr_status == TWA_CMD_BUSY)
    594 				twa_reset(tr->tr_sc);
    595 			else {
    596 				/* Request was never submitted.  Clean up. */
    597 				s = splbio();
    598 				TAILQ_REMOVE(&tr->tr_sc->twa_pending, tr,
    599 				    tr_link);
    600 				splx(s);
    601 
    602 				twa_unmap_request(tr);
    603 				if (tr->tr_data)
    604 					free(tr->tr_data, M_DEVBUF);
    605 
    606 				twa_release_request(tr);
    607 			}
    608 			return(ETIMEDOUT);
    609 		}
    610 		/*
    611 		 * Either the request got completed, or we were woken up by a
    612 		 * signal. Calculate the new timeout, in case it was the
    613 		 * latter.
    614 		 */
    615 		microtime(&t1);
    616 
    617 		timeout = (end_time - t1.tv_usec) / (1000 * 100);
    618 	}
    619 	return(rv);
    620 }
    621 
    622 /*
    623  * Function name:	twa_immediate_request
    624  * Description:		Sends down a firmware cmd, and waits for the completion
    625  *			in a tight loop.
    626  *
    627  * Input:		tr	-- ptr to request pkt
    628  *			timeout -- max # of seconds to wait before giving up
    629  * Output:		None
    630  * Return value:	0	-- success
    631  *			non-zero-- failure
    632  */
    633 static int
    634 twa_immediate_request(struct twa_request *tr, uint32_t timeout)
    635 {
    636 	struct timeval t1;
    637 	int	s = 0, rv = 0;
    638 
    639 	rv = twa_map_request(tr);
    640 
    641 	if (rv != 0)
    642 		return(rv);
    643 
    644 	timeout = (timeout * 10000 * 10);
    645 
    646 	microtime(&t1);
    647 
    648 	timeout += t1.tv_usec;
    649 
    650 	do {
    651 		rv = tr->tr_error;
    652 		if (rv != 0)
    653 			return(rv);
    654 		s = splbio();
    655 		twa_done(tr->tr_sc);
    656 		splx(s);
    657 		if (tr->tr_status == TWA_CMD_COMPLETE)
    658 			return(rv);
    659 		microtime(&t1);
    660 	} while (t1.tv_usec <= timeout);
    661 
    662 	/*
    663 	 * We will reset the controller only if the request has
    664 	 * already been submitted, so as to not lose the
    665 	 * request packet.  If a busy request timed out, the
    666 	 * reset will take care of freeing resources.  If a
    667 	 * pending request timed out, we will free resources
    668 	 * for that request, right here.  So, the caller is
    669 	 * expected to NOT cleanup when ETIMEDOUT is returned.
    670 	 */
    671 	rv = ETIMEDOUT;
    672 
    673 	if (tr->tr_status == TWA_CMD_BUSY)
    674 		twa_reset(tr->tr_sc);
    675 	else {
    676 		/* Request was never submitted.  Clean up. */
    677 		s = splbio();
    678 		TAILQ_REMOVE(&tr->tr_sc->twa_pending, tr, tr_link);
    679 		splx(s);
    680 		twa_unmap_request(tr);
    681 		if (tr->tr_data)
    682 			free(tr->tr_data, M_DEVBUF);
    683 
    684 		twa_release_request(tr);
    685 	}
    686 	return (rv);
    687 }
    688 
    689 static int
    690 twa_inquiry(struct twa_request *tr, int lunid)
    691 {
    692 	int error;
    693 	struct twa_command_9k *tr_9k_cmd;
    694 
    695 	if (tr->tr_data == NULL)
    696 		return (ENOMEM);
    697 
    698 	memset(tr->tr_data, 0, TWA_SECTOR_SIZE);
    699 
    700 	tr->tr_length = TWA_SECTOR_SIZE;
    701 	tr->tr_cmd_pkt_type = TWA_CMD_PKT_TYPE_9K;
    702 	tr->tr_flags |= TWA_CMD_DATA_IN | TWA_CMD_DATA_OUT;
    703 
    704 	tr_9k_cmd = &tr->tr_command->command.cmd_pkt_9k;
    705 
    706 	tr_9k_cmd->command.opcode = TWA_OP_EXECUTE_SCSI_COMMAND;
    707 	tr_9k_cmd->unit = lunid;
    708 	tr_9k_cmd->request_id = tr->tr_request_id;
    709 	tr_9k_cmd->status = 0;
    710 	tr_9k_cmd->sgl_offset = 16;
    711 	tr_9k_cmd->sgl_entries = 1;
    712 	/* create the CDB here */
    713 	tr_9k_cmd->cdb[0] = INQUIRY;
    714 	tr_9k_cmd->cdb[1] = ((lunid << 5) & 0x0e);
    715 	tr_9k_cmd->cdb[4] = 255;
    716 
    717 	/* XXXX setup page data no lun device
    718 	 * it seems 9000 series does not indicate
    719 	 * NOTPRESENT - need more investigation
    720 	 */
    721 	((struct scsipi_inquiry_data *)tr->tr_data)->device =
    722 		SID_QUAL_LU_NOTPRESENT;
    723 
    724 	error = twa_immediate_request(tr, TWA_REQUEST_TIMEOUT_PERIOD);
    725 	if (error != 0)
    726 		return (error);
    727 
    728 	if (((struct scsipi_inquiry_data *)tr->tr_data)->device ==
    729 		SID_QUAL_LU_NOTPRESENT)
    730 		error = 1;
    731 
    732 	return (error);
    733 }
    734 
    735 static int
    736 twa_print_inquiry_data(struct twa_softc *sc, struct scsipi_inquiry_data *scsipi)
    737 {
    738 
    739     printf("%s: %s\n", device_xname(sc->twa_dv), scsipi->vendor);
    740 
    741     return (1);
    742 }
    743 
    744 
    745 static uint64_t
    746 twa_read_capacity(struct twa_request *tr, int lunid)
    747 {
    748 	int error;
    749 	struct twa_command_9k *tr_9k_cmd;
    750 	uint64_t array_size = 0LL;
    751 
    752 	if (tr->tr_data == NULL)
    753 		return (ENOMEM);
    754 
    755 	memset(tr->tr_data, 0, TWA_SECTOR_SIZE);
    756 
    757 	tr->tr_length = TWA_SECTOR_SIZE;
    758 	tr->tr_cmd_pkt_type = TWA_CMD_PKT_TYPE_9K;
    759 	tr->tr_flags |= TWA_CMD_DATA_OUT;
    760 
    761 	tr_9k_cmd = &tr->tr_command->command.cmd_pkt_9k;
    762 
    763 	tr_9k_cmd->command.opcode = TWA_OP_EXECUTE_SCSI_COMMAND;
    764 	tr_9k_cmd->unit = lunid;
    765 	tr_9k_cmd->request_id = tr->tr_request_id;
    766 	tr_9k_cmd->status = 0;
    767 	tr_9k_cmd->sgl_offset = 16;
    768 	tr_9k_cmd->sgl_entries = 1;
    769 	/* create the CDB here */
    770 	tr_9k_cmd->cdb[0] = READ_CAPACITY_16;
    771 	tr_9k_cmd->cdb[1] = ((lunid << 5) & 0x0e) | SRC16_SERVICE_ACTION;
    772 
    773 	error = twa_immediate_request(tr, TWA_REQUEST_TIMEOUT_PERIOD);
    774 
    775 	if (error == 0) {
    776 #if BYTE_ORDER == BIG_ENDIAN
    777 		array_size = bswap64(_8btol(
    778 		    ((struct scsipi_read_capacity_16_data *)tr->tr_data->addr) + 1);
    779 #else
    780 		array_size = _8btol(((struct scsipi_read_capacity_16_data *)
    781 				tr->tr_data)->addr) + 1;
    782 #endif
    783 	}
    784 	return (array_size);
    785 }
    786 
    787 static int
    788 twa_request_sense(struct twa_request *tr, int lunid)
    789 {
    790 	int error = 1;
    791 	struct twa_command_9k *tr_9k_cmd;
    792 
    793 	if (tr->tr_data == NULL)
    794 		return (error);
    795 
    796 	memset(tr->tr_data, 0, TWA_SECTOR_SIZE);
    797 
    798 	tr->tr_length = TWA_SECTOR_SIZE;
    799 	tr->tr_cmd_pkt_type = TWA_CMD_PKT_TYPE_9K;
    800 	tr->tr_flags |= TWA_CMD_DATA_OUT;
    801 
    802 	tr_9k_cmd = &tr->tr_command->command.cmd_pkt_9k;
    803 
    804 	tr_9k_cmd->command.opcode = TWA_OP_EXECUTE_SCSI_COMMAND;
    805 	tr_9k_cmd->unit = lunid;
    806 	tr_9k_cmd->request_id = tr->tr_request_id;
    807 	tr_9k_cmd->status = 0;
    808 	tr_9k_cmd->sgl_offset = 16;
    809 	tr_9k_cmd->sgl_entries = 1;
    810 	/* create the CDB here */
    811 	tr_9k_cmd->cdb[0] = SCSI_REQUEST_SENSE;
    812 	tr_9k_cmd->cdb[1] = ((lunid << 5) & 0x0e);
    813 	tr_9k_cmd->cdb[4] = 255;
    814 
    815 	/*XXX AEN notification called in interrupt context
    816 	 * so just queue the request. Return as quickly
    817 	 * as possible from interrupt
    818 	 */
    819 	if ((tr->tr_flags & TWA_CMD_AEN) != 0)
    820 		error = twa_map_request(tr);
    821  	else
    822 		error = twa_immediate_request(tr, TWA_REQUEST_TIMEOUT_PERIOD);
    823 
    824 	return (error);
    825 }
    826 
    827 static int
    828 twa_alloc_req_pkts(struct twa_softc *sc, int num_reqs)
    829 {
    830 	struct twa_request	*tr;
    831 	struct twa_command_packet *tc;
    832 	bus_dma_segment_t	seg;
    833 	size_t max_segs, max_xfer;
    834 	int	i, rv, rseg, size;
    835 
    836 	if ((sc->sc_units = malloc(sc->sc_nunits *
    837 	    sizeof(struct twa_drive), M_DEVBUF, M_NOWAIT|M_ZERO)) == NULL)
    838 		return(ENOMEM);
    839 
    840 	if ((sc->twa_req_buf = malloc(num_reqs * sizeof(struct twa_request),
    841 					M_DEVBUF, M_NOWAIT)) == NULL)
    842 		return(ENOMEM);
    843 
    844 	size = num_reqs * sizeof(struct twa_command_packet);
    845 
    846 	/* Allocate memory for cmd pkts. */
    847 	if ((rv = bus_dmamem_alloc(sc->twa_dma_tag,
    848 		size, PAGE_SIZE, 0, &seg,
    849 		1, &rseg, BUS_DMA_NOWAIT)) != 0){
    850 			aprint_error_dev(sc->twa_dv, "unable to allocate "
    851 				"command packets, rv = %d\n", rv);
    852 			return (ENOMEM);
    853 	}
    854 
    855 	if ((rv = bus_dmamem_map(sc->twa_dma_tag,
    856 		&seg, rseg, size, (void **)&sc->twa_cmds,
    857 		BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) {
    858 			aprint_error_dev(sc->twa_dv, "unable to map commands, rv = %d\n", rv);
    859 			return (1);
    860 	}
    861 
    862 	if ((rv = bus_dmamap_create(sc->twa_dma_tag,
    863 		size, num_reqs, size,
    864 		0, BUS_DMA_NOWAIT, &sc->twa_cmd_map)) != 0) {
    865 			aprint_error_dev(sc->twa_dv, "unable to create command DMA map, "
    866 				"rv = %d\n", rv);
    867 			return (ENOMEM);
    868 	}
    869 
    870 	if ((rv = bus_dmamap_load(sc->twa_dma_tag, sc->twa_cmd_map,
    871 		sc->twa_cmds, size, NULL,
    872 		BUS_DMA_NOWAIT)) != 0) {
    873 			aprint_error_dev(sc->twa_dv, "unable to load command DMA map, "
    874 				"rv = %d\n", rv);
    875 			return (1);
    876 	}
    877 
    878 	if ((uintptr_t)sc->twa_cmds % TWA_ALIGNMENT) {
    879 		aprint_error_dev(sc->twa_dv, "DMA map memory not aligned on %d boundary\n", TWA_ALIGNMENT);
    880 
    881 		return (1);
    882 	}
    883 	tc = sc->twa_cmd_pkt_buf = (struct twa_command_packet *)sc->twa_cmds;
    884 	sc->twa_cmd_pkt_phys = sc->twa_cmd_map->dm_segs[0].ds_addr;
    885 
    886 	memset(sc->twa_req_buf, 0, num_reqs * sizeof(struct twa_request));
    887 	memset(sc->twa_cmd_pkt_buf, 0,
    888 		num_reqs * sizeof(struct twa_command_packet));
    889 
    890 	sc->sc_twa_request = sc->twa_req_buf;
    891 	max_segs = twa_get_maxsegs();
    892 	max_xfer = twa_get_maxxfer(max_segs);
    893 
    894 	for (i = 0; i < num_reqs; i++, tc++) {
    895 		tr = &(sc->twa_req_buf[i]);
    896 		tr->tr_command = tc;
    897 		tr->tr_cmd_phys = sc->twa_cmd_pkt_phys +
    898 				(i * sizeof(struct twa_command_packet));
    899 		tr->tr_request_id = i;
    900 		tr->tr_sc = sc;
    901 
    902 		/*
    903 		 * Create a map for data buffers.  maxsize (256 * 1024) used in
    904 		 * bus_dma_tag_create above should suffice the bounce page needs
    905 		 * for data buffers, since the max I/O size we support is 128KB.
    906 		 * If we supported I/O's bigger than 256KB, we would have to
    907 		 * create a second dma_tag, with the appropriate maxsize.
    908 		 */
    909 		if ((rv = bus_dmamap_create(sc->twa_dma_tag,
    910 			max_xfer, max_segs, 1, 0, BUS_DMA_NOWAIT,
    911 			&tr->tr_dma_map)) != 0) {
    912 				aprint_error_dev(sc->twa_dv, "unable to create command "
    913 					"DMA map, rv = %d\n", rv);
    914 				return (ENOMEM);
    915 		}
    916 		/* Insert request into the free queue. */
    917 		if (i != 0) {
    918 			sc->twa_lookup[i] = tr;
    919 			twa_release_request(tr);
    920 		} else
    921 			tr->tr_flags |= TWA_CMD_AEN;
    922 	}
    923 	return(0);
    924 }
    925 
    926 static void
    927 twa_recompute_openings(struct twa_softc *sc)
    928 {
    929 	struct twa_drive *td;
    930 	int unit;
    931 	int openings;
    932 	uint64_t total_size;
    933 
    934 	total_size = 0;
    935 	for (unit = 0; unit < sc->sc_nunits; unit++) {
    936 		td = &sc->sc_units[unit];
    937 		total_size += td->td_size;
    938 	}
    939 
    940 	for (unit = 0; unit < sc->sc_nunits; unit++) {
    941 		td = &sc->sc_units[unit];
    942 		/*
    943 		 * In theory, TWA_Q_LENGTH - 1 should be usable, but
    944 		 * keep one additional ccb for internal commands.
    945 		 * This makes the controller more reliable under load.
    946 		 */
    947 		if (total_size > 0) {
    948 			openings = (TWA_Q_LENGTH - 2) * td->td_size / total_size;
    949 		} else
    950 			openings = 0;
    951 
    952 		if (openings == td->td_openings)
    953 			continue;
    954 		td->td_openings = openings;
    955 
    956 #ifdef TWA_DEBUG
    957 		printf("%s: unit %d openings %d\n",
    958 				device_xname(sc->twa_dv), unit, openings);
    959 #endif
    960 		if (td->td_dev != NULL)
    961 			(*td->td_callbacks->tcb_openings)(td->td_dev, td->td_openings);
    962 	}
    963 }
    964 
    965 static int
    966 twa_request_bus_scan(struct twa_softc *sc)
    967 {
    968 	struct twa_drive *td;
    969 	struct twa_request *tr;
    970 	struct twa_attach_args twaa;
    971 	int locs[TWACF_NLOCS];
    972 	int s, unit;
    973 
    974 	s = splbio();
    975 	for (unit = 0; unit < sc->sc_nunits; unit++) {
    976 
    977 		if ((tr = twa_get_request(sc, 0)) == NULL) {
    978 			splx(s);
    979 			return (EIO);
    980 		}
    981 
    982 		tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_INTERNAL;
    983 
    984 		tr->tr_data = malloc(TWA_SECTOR_SIZE, M_DEVBUF, M_NOWAIT);
    985 
    986 		if (tr->tr_data == NULL) {
    987 			twa_release_request(tr);
    988 			splx(s);
    989 			return (ENOMEM);
    990 		}
    991 		td = &sc->sc_units[unit];
    992 
    993 		if (twa_inquiry(tr, unit) == 0) {
    994 			if (td->td_dev == NULL) {
    995 	    			twa_print_inquiry_data(sc,
    996 				   ((struct scsipi_inquiry_data *)tr->tr_data));
    997 
    998 				sc->sc_units[unit].td_size =
    999 					twa_read_capacity(tr, unit);
   1000 
   1001 				twaa.twaa_unit = unit;
   1002 
   1003 				twa_recompute_openings(sc);
   1004 
   1005 				locs[TWACF_UNIT] = unit;
   1006 
   1007 				sc->sc_units[unit].td_dev =
   1008 				    config_found_sm_loc(sc->twa_dv, "twa",
   1009 				    locs, &twaa, twa_print, config_stdsubmatch);
   1010 			}
   1011 		} else {
   1012 			if (td->td_dev != NULL) {
   1013 				(void) config_detach(td->td_dev, DETACH_FORCE);
   1014 				td->td_dev = NULL;
   1015 				td->td_size = 0;
   1016 
   1017 				twa_recompute_openings(sc);
   1018 			}
   1019 		}
   1020 		free(tr->tr_data, M_DEVBUF);
   1021 
   1022 		twa_release_request(tr);
   1023 	}
   1024 	splx(s);
   1025 
   1026 	return (0);
   1027 }
   1028 
   1029 
   1030 #ifdef	DIAGNOSTIC
   1031 static inline void
   1032 twa_check_busy_q(struct twa_request *tr)
   1033 {
   1034 	struct twa_request *rq;
   1035 	struct twa_softc *sc = tr->tr_sc;
   1036 
   1037 	TAILQ_FOREACH(rq, &sc->twa_busy, tr_link) {
   1038 		if (tr->tr_request_id == rq->tr_request_id) {
   1039 			panic("cannot submit same request more than once");
   1040 		} else if (tr->bp == rq->bp && tr->bp != 0) {
   1041 			/* XXX A check for 0 for the buf ptr is needed to
   1042 			 * guard against ioctl requests with a buf ptr of
   1043 			 * 0 and also aen notifications. Looking for
   1044 			 * external cmds only.
   1045 			 */
   1046 			panic("cannot submit same buf more than once");
   1047 		} else {
   1048 			/* Empty else statement */
   1049 		}
   1050 	}
   1051 }
   1052 #endif
   1053 
   1054 static int
   1055 twa_start(struct twa_request *tr)
   1056 {
   1057 	struct twa_softc	*sc = tr->tr_sc;
   1058 	uint32_t		status_reg;
   1059 	int			s;
   1060 	int			error;
   1061 
   1062 	s = splbio();
   1063 
   1064 	/*
   1065 	 * The 9650 and 9690 have a bug in the detection of the full queue
   1066 	 * condition.
   1067 	 *
   1068 	 * If a write operation has filled the queue and is directly followed
   1069 	 * by a status read, it sometimes doesn't return the correct result.
   1070 	 * To work around this, the upper 32bit are written first.
   1071 	 * This effectively serialises the hardware, but does not change
   1072 	 * the state of the queue.
   1073 	 */
   1074 	if (sc->sc_quirks & TWA_QUIRK_QUEUEFULL_BUG) {
   1075 		/* Write lower 32 bits of address */
   1076 		TWA_WRITE_COMMAND_QUEUE_LOW(sc, tr->tr_cmd_phys +
   1077 			sizeof(struct twa_command_header));
   1078 	}
   1079 
   1080 	/* Check to see if we can post a command. */
   1081 	status_reg = twa_inl(sc, TWA_STATUS_REGISTER_OFFSET);
   1082 	if ((error = twa_check_ctlr_state(sc, status_reg)))
   1083 		goto out;
   1084 
   1085 	if (status_reg & TWA_STATUS_COMMAND_QUEUE_FULL) {
   1086 			if (tr->tr_status != TWA_CMD_PENDING) {
   1087 				tr->tr_status = TWA_CMD_PENDING;
   1088 				TAILQ_INSERT_TAIL(&tr->tr_sc->twa_pending,
   1089 					tr, tr_link);
   1090 			}
   1091 			twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   1092 					TWA_CONTROL_UNMASK_COMMAND_INTERRUPT);
   1093 			error = EBUSY;
   1094 	} else {
   1095 	   	bus_dmamap_sync(sc->twa_dma_tag, sc->twa_cmd_map,
   1096 			(char *)tr->tr_command - (char *)sc->twa_cmds,
   1097 			sizeof(struct twa_command_packet),
   1098 			BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
   1099 
   1100 		if (sc->sc_quirks & TWA_QUIRK_QUEUEFULL_BUG) {
   1101 			/*
   1102 			 * Cmd queue is not full.  Post the command
   1103 			 * by writing upper 32 bits of address.
   1104 			 */
   1105 			TWA_WRITE_COMMAND_QUEUE_HIGH(sc, tr->tr_cmd_phys +
   1106 				sizeof(struct twa_command_header));
   1107 		} else {
   1108 			/* Cmd queue is not full.  Post the command. */
   1109 			TWA_WRITE_COMMAND_QUEUE(sc, tr->tr_cmd_phys +
   1110 				sizeof(struct twa_command_header));
   1111 		}
   1112 
   1113 		/* Mark the request as currently being processed. */
   1114 		tr->tr_status = TWA_CMD_BUSY;
   1115 
   1116 #ifdef	DIAGNOSTIC
   1117 		twa_check_busy_q(tr);
   1118 #endif
   1119 
   1120 		/* Move the request into the busy queue. */
   1121 		TAILQ_INSERT_TAIL(&tr->tr_sc->twa_busy, tr, tr_link);
   1122 	}
   1123 out:
   1124 	splx(s);
   1125 	return(error);
   1126 }
   1127 
   1128 static int
   1129 twa_drain_response_queue(struct twa_softc *sc)
   1130 {
   1131 	uint32_t			status_reg;
   1132 
   1133 	for (;;) {
   1134 		status_reg = twa_inl(sc, TWA_STATUS_REGISTER_OFFSET);
   1135 		if (twa_check_ctlr_state(sc, status_reg))
   1136 			return(1);
   1137 		if (status_reg & TWA_STATUS_RESPONSE_QUEUE_EMPTY)
   1138 			return(0); /* no more response queue entries */
   1139 		(void)twa_inl(sc, TWA_RESPONSE_QUEUE_OFFSET);
   1140 	}
   1141 }
   1142 
   1143 /*
   1144  * twa_drain_response_queue_large:
   1145  *
   1146  * specific to the 9550 and 9650 controller to remove requests.
   1147  *
   1148  * Removes all requests from "large" response queue on the 9550 controller.
   1149  * This procedure is called as part of the 9550 controller reset sequence.
   1150  */
   1151 static int
   1152 twa_drain_response_queue_large(struct twa_softc *sc, uint32_t timeout)
   1153 {
   1154 	uint32_t	start_time = 0, end_time;
   1155 	uint32_t	response = 0;
   1156 
   1157 	if (sc->sc_product_id == PCI_PRODUCT_3WARE_9550 ||
   1158 	    sc->sc_product_id == PCI_PRODUCT_3WARE_9650 ) {
   1159 	       start_time = 0;
   1160 	       end_time = (timeout * TWA_MICROSECOND);
   1161 
   1162 	       while ((response &
   1163 		   TWA_9550SX_DRAIN_COMPLETE) != TWA_9550SX_DRAIN_COMPLETE) {
   1164 			response = twa_inl(sc, TWA_RESPONSE_QUEUE_LARGE_OFFSET);
   1165 			if (start_time >= end_time)
   1166 			       return (1);
   1167 			DELAY(1);
   1168 			start_time++;
   1169 	       }
   1170 	       /* P-chip delay */
   1171 	       DELAY(500000);
   1172        }
   1173        return (0);
   1174 }
   1175 
   1176 static void
   1177 twa_drain_busy_queue(struct twa_softc *sc)
   1178 {
   1179 	struct twa_request	*tr;
   1180 
   1181 	/* Walk the busy queue. */
   1182 
   1183 	while ((tr = TAILQ_FIRST(&sc->twa_busy)) != NULL) {
   1184 		TAILQ_REMOVE(&sc->twa_busy, tr, tr_link);
   1185 
   1186 		twa_unmap_request(tr);
   1187 		if ((tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_INTERNAL) ||
   1188 			(tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_IOCTL)) {
   1189 			/* It's an internal/ioctl request.  Simply free it. */
   1190 			if (tr->tr_data)
   1191 				free(tr->tr_data, M_DEVBUF);
   1192 			twa_release_request(tr);
   1193 		} else {
   1194 			/* It's a SCSI request.  Complete it. */
   1195 			tr->tr_command->command.cmd_pkt_9k.status = EIO;
   1196 			if (tr->tr_callback)
   1197 				tr->tr_callback(tr);
   1198 		}
   1199 	}
   1200 }
   1201 
   1202 static int
   1203 twa_drain_pending_queue(struct twa_softc *sc)
   1204 {
   1205 	struct twa_request	*tr;
   1206 	int			s, error = 0;
   1207 
   1208 	/*
   1209 	 * Pull requests off the pending queue, and submit them.
   1210 	 */
   1211 	s = splbio();
   1212 	while ((tr = TAILQ_FIRST(&sc->twa_pending)) != NULL) {
   1213 		TAILQ_REMOVE(&sc->twa_pending, tr, tr_link);
   1214 
   1215 		if ((error = twa_start(tr))) {
   1216 			if (error == EBUSY) {
   1217 				tr->tr_status = TWA_CMD_PENDING;
   1218 
   1219 				/* queue at the head */
   1220 				TAILQ_INSERT_HEAD(&tr->tr_sc->twa_pending,
   1221 					tr, tr_link);
   1222 				error = 0;
   1223 				break;
   1224 			} else {
   1225 				if (tr->tr_flags & TWA_CMD_SLEEP_ON_REQUEST) {
   1226 					tr->tr_error = error;
   1227 					tr->tr_callback(tr);
   1228 					error = EIO;
   1229 				}
   1230 			}
   1231 		}
   1232 	}
   1233 	splx(s);
   1234 
   1235 	return(error);
   1236 }
   1237 
   1238 static int
   1239 twa_drain_aen_queue(struct twa_softc *sc)
   1240 {
   1241 	int				s, error = 0;
   1242 	struct twa_request		*tr;
   1243 	struct twa_command_header	*cmd_hdr;
   1244 	struct timeval	t1;
   1245 	uint32_t		timeout;
   1246 
   1247 	for (;;) {
   1248 		if ((tr = twa_get_request(sc, 0)) == NULL) {
   1249 			error = EIO;
   1250 			break;
   1251 		}
   1252 		tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_INTERNAL;
   1253 		tr->tr_callback = NULL;
   1254 
   1255 		tr->tr_data = malloc(TWA_SECTOR_SIZE, M_DEVBUF, M_NOWAIT);
   1256 
   1257 		if (tr->tr_data == NULL) {
   1258 			error = 1;
   1259 			goto out;
   1260 		}
   1261 
   1262 		if (twa_request_sense(tr, 0) != 0) {
   1263 			error = 1;
   1264 			break;
   1265 		}
   1266 
   1267 		timeout = (1000/*ms*/ * 100/*us*/ * TWA_REQUEST_TIMEOUT_PERIOD);
   1268 
   1269 		microtime(&t1);
   1270 
   1271 		timeout += t1.tv_usec;
   1272 
   1273 		do {
   1274 			s = splbio();
   1275 			twa_done(tr->tr_sc);
   1276 			splx(s);
   1277 			if (tr->tr_status != TWA_CMD_BUSY)
   1278 				break;
   1279 			microtime(&t1);
   1280 		} while (t1.tv_usec <= timeout);
   1281 
   1282 		if (tr->tr_status != TWA_CMD_COMPLETE) {
   1283 			error = ETIMEDOUT;
   1284 			break;
   1285 		}
   1286 
   1287 		if ((error = tr->tr_command->command.cmd_pkt_9k.status))
   1288 			break;
   1289 
   1290 		cmd_hdr = (struct twa_command_header *)(tr->tr_data);
   1291 		if ((cmd_hdr->status_block.error) /* aen_code */
   1292 				== TWA_AEN_QUEUE_EMPTY)
   1293 			break;
   1294 		(void)twa_enqueue_aen(sc, cmd_hdr);
   1295 
   1296 		free(tr->tr_data, M_DEVBUF);
   1297 		twa_release_request(tr);
   1298 	}
   1299 out:
   1300 	if (tr) {
   1301 		if (tr->tr_data)
   1302 			free(tr->tr_data, M_DEVBUF);
   1303 
   1304 		twa_release_request(tr);
   1305 	}
   1306 	return(error);
   1307 }
   1308 
   1309 
   1310 #if 0
   1311 static void
   1312 twa_check_response_q(struct twa_request *tr, int clear)
   1313 {
   1314 	int j;
   1315 	static int i = 0;
   1316 	static struct twa_request	*req = 0;
   1317 	static struct buf		*hist[255];
   1318 
   1319 
   1320 	if (clear) {
   1321 		i = 0;
   1322 		for (j = 0; j < 255; j++)
   1323 			hist[j] = 0;
   1324 		return;
   1325 	}
   1326 
   1327 	if (req == 0)
   1328 		req = tr;
   1329 
   1330 	if ((tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL) != 0) {
   1331 		/* XXX this is bogus ! req can't be anything else but tr ! */
   1332 		if (req->tr_request_id == tr->tr_request_id)
   1333 			panic("req id: %d on controller queue twice",
   1334 		    	    tr->tr_request_id);
   1335 
   1336 		for (j = 0; j < i; j++)
   1337 			if (tr->bp == hist[j])
   1338 				panic("req id: %d buf found twice",
   1339 		    	    	    tr->tr_request_id);
   1340 		}
   1341 	req = tr;
   1342 
   1343 	hist[i++] = req->bp;
   1344 }
   1345 #endif
   1346 
   1347 static int
   1348 twa_done(struct twa_softc *sc)
   1349 {
   1350 	union twa_response_queue	rq;
   1351 	struct twa_request		*tr;
   1352 	int				rv = 0;
   1353 	uint32_t			status_reg;
   1354 
   1355 	for (;;) {
   1356 		status_reg = twa_inl(sc, TWA_STATUS_REGISTER_OFFSET);
   1357 		if ((rv = twa_check_ctlr_state(sc, status_reg)))
   1358 			break;
   1359 		if (status_reg & TWA_STATUS_RESPONSE_QUEUE_EMPTY)
   1360 			break;
   1361 		/* Response queue is not empty. */
   1362 		rq.value = twa_inl(sc, TWA_RESPONSE_QUEUE_OFFSET);
   1363 		tr = sc->sc_twa_request + rq.u.response_id;
   1364 #if 0
   1365 		twa_check_response_q(tr, 0);
   1366 #endif
   1367 		/* Unmap the command packet, and any associated data buffer. */
   1368 		twa_unmap_request(tr);
   1369 
   1370 		tr->tr_status = TWA_CMD_COMPLETE;
   1371 		TAILQ_REMOVE(&tr->tr_sc->twa_busy, tr, tr_link);
   1372 
   1373 		if (tr->tr_callback)
   1374 			tr->tr_callback(tr);
   1375 	}
   1376 	(void)twa_drain_pending_queue(sc);
   1377 
   1378 #if 0
   1379 	twa_check_response_q(NULL, 1);
   1380 #endif
   1381 	return(rv);
   1382 }
   1383 
   1384 /*
   1385  * Function name:	twa_init_ctlr
   1386  * Description:		Establishes a logical connection with the controller.
   1387  *			If bundled with firmware, determines whether or not
   1388  *			the driver is compatible with the firmware on the
   1389  *			controller, before proceeding to work with it.
   1390  *
   1391  * Input:		sc	-- ptr to per ctlr structure
   1392  * Output:		None
   1393  * Return value:	0	-- success
   1394  *			non-zero-- failure
   1395  */
   1396 static int
   1397 twa_init_ctlr(struct twa_softc *sc)
   1398 {
   1399 	uint16_t	fw_on_ctlr_srl = 0;
   1400 	uint16_t	fw_on_ctlr_arch_id = 0;
   1401 	uint16_t	fw_on_ctlr_branch = 0;
   1402 	uint16_t	fw_on_ctlr_build = 0;
   1403 	uint32_t	init_connect_result = 0;
   1404 	int		error = 0;
   1405 
   1406 	/* Wait for the controller to become ready. */
   1407 	if (twa_wait_status(sc, TWA_STATUS_MICROCONTROLLER_READY,
   1408 					TWA_REQUEST_TIMEOUT_PERIOD)) {
   1409 		return(ENXIO);
   1410 	}
   1411 	/* Drain the response queue. */
   1412 	if (twa_drain_response_queue(sc))
   1413 		return(1);
   1414 
   1415 	/* Establish a logical connection with the controller. */
   1416 	if ((error = twa_init_connection(sc, TWA_INIT_MESSAGE_CREDITS,
   1417 			TWA_EXTENDED_INIT_CONNECT, TWA_CURRENT_FW_SRL,
   1418 			TWA_9000_ARCH_ID, TWA_CURRENT_FW_BRANCH,
   1419 			TWA_CURRENT_FW_BUILD, &fw_on_ctlr_srl,
   1420 			&fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
   1421 			&fw_on_ctlr_build, &init_connect_result))) {
   1422 		return(error);
   1423 	}
   1424 	twa_drain_aen_queue(sc);
   1425 
   1426 	/* Set controller state to initialized. */
   1427 	sc->twa_state &= ~TWA_STATE_SHUTDOWN;
   1428 	return(0);
   1429 }
   1430 
   1431 static int
   1432 twa_setup(struct twa_softc *sc)
   1433 {
   1434 	struct tw_cl_event_packet *aen_queue;
   1435 	uint32_t		i = 0;
   1436 	int			error = 0;
   1437 
   1438 	/* Initialize request queues. */
   1439 	TAILQ_INIT(&sc->twa_free);
   1440 	TAILQ_INIT(&sc->twa_busy);
   1441 	TAILQ_INIT(&sc->twa_pending);
   1442 
   1443 	sc->twa_sc_flags = 0;
   1444 
   1445 	if (twa_alloc_req_pkts(sc, TWA_Q_LENGTH)) {
   1446 
   1447 		return(ENOMEM);
   1448 	}
   1449 
   1450 	/* Allocate memory for the AEN queue. */
   1451 	if ((aen_queue = malloc(sizeof(struct tw_cl_event_packet) *
   1452 	    TWA_Q_LENGTH, M_DEVBUF, M_WAITOK)) == NULL) {
   1453 		/*
   1454 		 * This should not cause us to return error.  We will only be
   1455 		 * unable to support AEN's.  But then, we will have to check
   1456 		 * time and again to see if we can support AEN's, if we
   1457 		 * continue.  So, we will just return error.
   1458 		 */
   1459 		return (ENOMEM);
   1460 	}
   1461 	/* Initialize the aen queue. */
   1462 	memset(aen_queue, 0, sizeof(struct tw_cl_event_packet) * TWA_Q_LENGTH);
   1463 
   1464 	for (i = 0; i < TWA_Q_LENGTH; i++)
   1465 		sc->twa_aen_queue[i] = &(aen_queue[i]);
   1466 
   1467 	twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   1468 		TWA_CONTROL_DISABLE_INTERRUPTS);
   1469 
   1470 	/* Initialize the controller. */
   1471 	if ((error = twa_init_ctlr(sc))) {
   1472 		/* Soft reset the controller, and try one more time. */
   1473 
   1474 		printf("%s: controller initialization failed. "
   1475 		    "Retrying initialization\n", device_xname(sc->twa_dv));
   1476 
   1477 		if ((error = twa_soft_reset(sc)) == 0)
   1478 			error = twa_init_ctlr(sc);
   1479 	}
   1480 
   1481 	twa_describe_controller(sc);
   1482 
   1483 	error = twa_request_bus_scan(sc);
   1484 
   1485 	twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   1486 		TWA_CONTROL_CLEAR_ATTENTION_INTERRUPT |
   1487 		TWA_CONTROL_UNMASK_RESPONSE_INTERRUPT |
   1488 		TWA_CONTROL_ENABLE_INTERRUPTS);
   1489 
   1490 	return (error);
   1491 }
   1492 
   1493 void *twa_sdh;
   1494 
   1495 static void
   1496 twa_attach(device_t parent, device_t self, void *aux)
   1497 {
   1498 	struct pci_attach_args *pa;
   1499 	struct twa_softc *sc;
   1500 	pci_chipset_tag_t pc;
   1501 	pcireg_t csr;
   1502 	pci_intr_handle_t ih;
   1503 	const char *intrstr;
   1504 	const struct sysctlnode *node;
   1505 	const struct twa_pci_identity *entry;
   1506 	int i;
   1507 	bool use_64bit;
   1508 	char intrbuf[PCI_INTRSTR_LEN];
   1509 
   1510 	sc = device_private(self);
   1511 
   1512 	sc->twa_dv = self;
   1513 
   1514 	pa = aux;
   1515 	pc = pa->pa_pc;
   1516 	sc->pc = pa->pa_pc;
   1517 	sc->tag = pa->pa_tag;
   1518 
   1519 	entry = twa_lookup(pa->pa_id);
   1520 	pci_aprint_devinfo_fancy(pa, "RAID controller", entry->name, 1);
   1521 
   1522 	sc->sc_quirks = 0;
   1523 
   1524 	if (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_3WARE_9000) {
   1525 		sc->sc_nunits = TWA_MAX_UNITS;
   1526 		use_64bit = false;
   1527 		if (pci_mapreg_map(pa, PCI_MAPREG_START, PCI_MAPREG_TYPE_IO, 0,
   1528 	    	    &sc->twa_bus_iot, &sc->twa_bus_ioh, NULL, NULL)) {
   1529 			aprint_error_dev(sc->twa_dv, "can't map i/o space\n");
   1530 			return;
   1531 		}
   1532 	} else if (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_3WARE_9550) {
   1533 		sc->sc_nunits = TWA_MAX_UNITS;
   1534 		use_64bit = true;
   1535 		if (pci_mapreg_map(pa, PCI_MAPREG_START + 0x08,
   1536 	    	    PCI_MAPREG_MEM_TYPE_64BIT, 0, &sc->twa_bus_iot,
   1537 		    &sc->twa_bus_ioh, NULL, NULL)) {
   1538 			aprint_error_dev(sc->twa_dv, "can't map mem space\n");
   1539 			return;
   1540 		}
   1541 	} else if (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_3WARE_9650) {
   1542 		sc->sc_nunits = TWA_9650_MAX_UNITS;
   1543 		use_64bit = true;
   1544 		if (pci_mapreg_map(pa, PCI_MAPREG_START + 0x08,
   1545 	    	    PCI_MAPREG_MEM_TYPE_64BIT, 0, &sc->twa_bus_iot,
   1546 		    &sc->twa_bus_ioh, NULL, NULL)) {
   1547 			aprint_error_dev(sc->twa_dv, "can't map mem space\n");
   1548 			return;
   1549 		}
   1550 		sc->sc_quirks |= TWA_QUIRK_QUEUEFULL_BUG;
   1551 	} else if (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_3WARE_9690) {
   1552 		sc->sc_nunits = TWA_9690_MAX_UNITS;
   1553 		use_64bit = true;
   1554 		if (pci_mapreg_map(pa, PCI_MAPREG_START + 0x08,
   1555 	    	    PCI_MAPREG_MEM_TYPE_64BIT, 0, &sc->twa_bus_iot,
   1556 		    &sc->twa_bus_ioh, NULL, NULL)) {
   1557 			aprint_error_dev(sc->twa_dv, "can't map mem space\n");
   1558 			return;
   1559 		}
   1560 		sc->sc_quirks |= TWA_QUIRK_QUEUEFULL_BUG;
   1561 	} else {
   1562 		sc->sc_nunits = 0;
   1563 		use_64bit = false;
   1564 		aprint_error_dev(sc->twa_dv, "product id 0x%02x not recognized\n",
   1565 		    PCI_PRODUCT(pa->pa_id));
   1566 		return;
   1567 	}
   1568 
   1569 	if (pci_dma64_available(pa) && use_64bit) {
   1570 		aprint_verbose_dev(self, "64-bit DMA addressing active\n");
   1571 		sc->twa_dma_tag = pa->pa_dmat64;
   1572 	} else {
   1573 		sc->twa_dma_tag = pa->pa_dmat;
   1574 	}
   1575 
   1576  	sc->sc_product_id = PCI_PRODUCT(pa->pa_id);
   1577 	/* Enable the device. */
   1578 	csr = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
   1579 
   1580 	pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG,
   1581 	    csr | PCI_COMMAND_MASTER_ENABLE);
   1582 
   1583 	/* Map and establish the interrupt. */
   1584 	if (pci_intr_map(pa, &ih)) {
   1585 		aprint_error_dev(sc->twa_dv, "can't map interrupt\n");
   1586 		return;
   1587 	}
   1588 	intrstr = pci_intr_string(pc, ih, intrbuf, sizeof(intrbuf));
   1589 
   1590 	sc->twa_ih = pci_intr_establish(pc, ih, IPL_BIO, twa_intr, sc);
   1591 	if (sc->twa_ih == NULL) {
   1592 		aprint_error_dev(sc->twa_dv, "can't establish interrupt%s%s\n",
   1593 			(intrstr) ? " at " : "",
   1594 			(intrstr) ? intrstr : "");
   1595 		return;
   1596 	}
   1597 
   1598 	if (intrstr != NULL)
   1599 		aprint_normal_dev(sc->twa_dv, "interrupting at %s\n",
   1600 			intrstr);
   1601 
   1602 	twa_setup(sc);
   1603 
   1604 	if (twa_sdh == NULL)
   1605 		twa_sdh = shutdownhook_establish(twa_shutdown, NULL);
   1606 
   1607 	/* sysctl set-up for 3ware cli */
   1608 	if (sysctl_createv(NULL, 0, NULL, &node,
   1609 				0, CTLTYPE_NODE, device_xname(sc->twa_dv),
   1610 				SYSCTL_DESCR("twa driver information"),
   1611 				NULL, 0, NULL, 0,
   1612 				CTL_HW, CTL_CREATE, CTL_EOL) != 0) {
   1613 		aprint_error_dev(sc->twa_dv, "could not create %s.%s sysctl node\n",
   1614 			"hw",
   1615 			device_xname(sc->twa_dv));
   1616 		return;
   1617 	}
   1618 	if ((i = sysctl_createv(NULL, 0, NULL, NULL,
   1619 				0, CTLTYPE_STRING, "driver_version",
   1620 				SYSCTL_DESCR("twa driver version"),
   1621 				NULL, 0, __UNCONST(&twaver), 0,
   1622 				CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL))
   1623 				!= 0) {
   1624 		aprint_error_dev(sc->twa_dv, "could not create %s.%s.driver_version sysctl\n",
   1625 			"hw",
   1626 			device_xname(sc->twa_dv));
   1627 		return;
   1628 	}
   1629 
   1630 	return;
   1631 }
   1632 
   1633 static void
   1634 twa_shutdown(void *arg)
   1635 {
   1636 	extern struct cfdriver twa_cd;
   1637 	struct twa_softc *sc;
   1638 	int i, unit;
   1639 
   1640 	for (i = 0; i < twa_cd.cd_ndevs; i++) {
   1641 		if ((sc = device_lookup_private(&twa_cd, i)) == NULL)
   1642 			continue;
   1643 
   1644 		for (unit = 0; unit < sc->sc_nunits; unit++)
   1645 			if (sc->sc_units[unit].td_dev != NULL)
   1646 				(void) config_detach(sc->sc_units[unit].td_dev,
   1647 					DETACH_FORCE | DETACH_QUIET);
   1648 
   1649 		twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   1650 			TWA_CONTROL_DISABLE_INTERRUPTS);
   1651 
   1652 		/* Let the controller know that we are going down. */
   1653 		(void)twa_init_connection(sc, TWA_SHUTDOWN_MESSAGE_CREDITS,
   1654 				0, 0, 0, 0, 0,
   1655 				NULL, NULL, NULL, NULL, NULL);
   1656 	}
   1657 }
   1658 
   1659 void
   1660 twa_register_callbacks(struct twa_softc *sc, int unit,
   1661     const struct twa_callbacks *tcb)
   1662 {
   1663 
   1664 	sc->sc_units[unit].td_callbacks = tcb;
   1665 }
   1666 
   1667 /*
   1668  * Print autoconfiguration message for a sub-device
   1669  */
   1670 static int
   1671 twa_print(void *aux, const char *pnp)
   1672 {
   1673 	struct twa_attach_args *twaa;
   1674 
   1675 	twaa = aux;
   1676 
   1677 	if (pnp !=NULL)
   1678 		aprint_normal("block device at %s\n", pnp);
   1679 	aprint_normal(" unit %d\n", twaa->twaa_unit);
   1680 	return (UNCONF);
   1681 }
   1682 
   1683 static void
   1684 twa_fillin_sgl(struct twa_sg *sgl, bus_dma_segment_t *segs, int nsegments)
   1685 {
   1686 	int	i;
   1687 	for (i = 0; i < nsegments; i++) {
   1688 		sgl[i].address = segs[i].ds_addr;
   1689 		sgl[i].length = (uint32_t)(segs[i].ds_len);
   1690 	}
   1691 }
   1692 
   1693 static int
   1694 twa_submit_io(struct twa_request *tr)
   1695 {
   1696 	int	error;
   1697 
   1698 	if ((error = twa_start(tr))) {
   1699 		if (error == EBUSY)
   1700 			error = 0; /* request is in the pending queue */
   1701 		else {
   1702 			tr->tr_error = error;
   1703 		}
   1704 	}
   1705 	return(error);
   1706 }
   1707 
   1708 /*
   1709  * Function name:	twa_setup_data_dmamap
   1710  * Description:		Callback of bus_dmamap_load for the buffer associated
   1711  *			with data.  Updates the cmd pkt (size/sgl_entries
   1712  *			fields, as applicable) to reflect the number of sg
   1713  *			elements.
   1714  *
   1715  * Input:		arg	-- ptr to request pkt
   1716  *			segs	-- ptr to a list of segment descriptors
   1717  *			nsegments--# of segments
   1718  *			error	-- 0 if no errors encountered before callback,
   1719  *				   non-zero if errors were encountered
   1720  * Output:		None
   1721  * Return value:	None
   1722  */
   1723 static int
   1724 twa_setup_data_dmamap(void *arg, bus_dma_segment_t *segs, int nsegments)
   1725 {
   1726 	struct twa_request		*tr = (struct twa_request *)arg;
   1727 	struct twa_command_packet	*cmdpkt = tr->tr_command;
   1728 	struct twa_command_9k		*cmd9k;
   1729 	union twa_command_7k		*cmd7k;
   1730 	uint8_t				sgl_offset;
   1731 	int				error;
   1732 
   1733 	if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_9K) {
   1734 		cmd9k = &(cmdpkt->command.cmd_pkt_9k);
   1735 		twa_fillin_sgl(&(cmd9k->sg_list[0]), segs, nsegments);
   1736 		cmd9k->sgl_entries += nsegments - 1;
   1737 	} else {
   1738 		/* It's a 7000 command packet. */
   1739 		cmd7k = &(cmdpkt->command.cmd_pkt_7k);
   1740 		if ((sgl_offset = cmdpkt->command.cmd_pkt_7k.generic.sgl_offset))
   1741 			twa_fillin_sgl((struct twa_sg *)
   1742 					(((uint32_t *)cmd7k) + sgl_offset),
   1743 					segs, nsegments);
   1744 		/* Modify the size field, based on sg address size. */
   1745 		cmd7k->generic.size +=
   1746 			((TWA_64BIT_ADDRESSES ? 3 : 2) * nsegments);
   1747 	}
   1748 	if (tr->tr_flags & TWA_CMD_DATA_IN)
   1749 		bus_dmamap_sync(tr->tr_sc->twa_dma_tag, tr->tr_dma_map, 0,
   1750 			tr->tr_length, BUS_DMASYNC_PREWRITE);
   1751 	if (tr->tr_flags & TWA_CMD_DATA_OUT) {
   1752 		/*
   1753 		 * If we're using an alignment buffer, and we're
   1754 		 * writing data, copy the real data out.
   1755 		 */
   1756 		if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED)
   1757 			memcpy(tr->tr_data, tr->tr_real_data,
   1758 				tr->tr_real_length);
   1759 		bus_dmamap_sync(tr->tr_sc->twa_dma_tag, tr->tr_dma_map, 0,
   1760 			tr->tr_length, BUS_DMASYNC_PREREAD);
   1761 	}
   1762 	error = twa_submit_io(tr);
   1763 
   1764 	if (error) {
   1765 		twa_unmap_request(tr);
   1766 		/*
   1767 		 * If the caller had been returned EINPROGRESS, and he has
   1768 		 * registered a callback for handling completion, the callback
   1769 		 * will never get called because we were unable to submit the
   1770 		 * request.  So, free up the request right here.
   1771 		 */
   1772 		if (tr->tr_callback)
   1773 			twa_release_request(tr);
   1774 	}
   1775 	return (error);
   1776 }
   1777 
   1778 /*
   1779  * Function name:	twa_map_request
   1780  * Description:		Maps a cmd pkt and data associated with it, into
   1781  *			DMA'able memory.
   1782  *
   1783  * Input:		tr	-- ptr to request pkt
   1784  * Output:		None
   1785  * Return value:	0	-- success
   1786  *			non-zero-- failure
   1787  */
   1788 int
   1789 twa_map_request(struct twa_request *tr)
   1790 {
   1791 	struct twa_softc	*sc = tr->tr_sc;
   1792 	int			 s, rv, rc;
   1793 
   1794 	/* If the command involves data, map that too. */
   1795 	if (tr->tr_data != NULL) {
   1796 
   1797 		if (((u_long)tr->tr_data & (511)) != 0) {
   1798 			tr->tr_flags |= TWA_CMD_DATA_COPY_NEEDED;
   1799 			tr->tr_real_data = tr->tr_data;
   1800 			tr->tr_real_length = tr->tr_length;
   1801 			s = splvm();
   1802 			rc = uvm_km_kmem_alloc(kmem_va_arena,
   1803 			    tr->tr_length, (VM_NOSLEEP | VM_INSTANTFIT),
   1804 			    (vmem_addr_t *)&tr->tr_data);
   1805 			splx(s);
   1806 
   1807 			if (rc != 0) {
   1808 				tr->tr_data = tr->tr_real_data;
   1809 				tr->tr_length = tr->tr_real_length;
   1810 				return(ENOMEM);
   1811 			}
   1812 			if ((tr->tr_flags & TWA_CMD_DATA_IN) != 0)
   1813 				memcpy(tr->tr_data, tr->tr_real_data,
   1814 					tr->tr_length);
   1815 		}
   1816 
   1817 		/*
   1818 		 * Map the data buffer into bus space and build the S/G list.
   1819 		 */
   1820 		rv = bus_dmamap_load(sc->twa_dma_tag, tr->tr_dma_map,
   1821 			tr->tr_data, tr->tr_length, NULL,
   1822 			BUS_DMA_NOWAIT | BUS_DMA_STREAMING);
   1823 
   1824 		if (rv != 0) {
   1825 			if ((tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED) != 0) {
   1826 				s = splvm();
   1827 				uvm_km_kmem_free(kmem_va_arena,
   1828 				    (vaddr_t)tr->tr_data,
   1829 				    tr->tr_length);
   1830 				splx(s);
   1831 			}
   1832 			return (rv);
   1833 		}
   1834 
   1835 		if ((rv = twa_setup_data_dmamap(tr,
   1836 				tr->tr_dma_map->dm_segs,
   1837 				tr->tr_dma_map->dm_nsegs))) {
   1838 
   1839 			if (tr->tr_flags & TWA_CMD_DATA_COPY_NEEDED) {
   1840 				s = splvm();
   1841 				uvm_km_kmem_free(kmem_va_arena, (vaddr_t)tr->tr_data,
   1842 				    tr->tr_length);
   1843 				splx(s);
   1844 				tr->tr_data = tr->tr_real_data;
   1845 				tr->tr_length = tr->tr_real_length;
   1846 			}
   1847 		}
   1848 
   1849 	} else
   1850 		if ((rv = twa_submit_io(tr)))
   1851 			twa_unmap_request(tr);
   1852 
   1853 	return (rv);
   1854 }
   1855 
   1856 /*
   1857  * Function name:	twa_intr
   1858  * Description:		Interrupt handler.  Determines the kind of interrupt,
   1859  *			and calls the appropriate handler.
   1860  *
   1861  * Input:		sc	-- ptr to per ctlr structure
   1862  * Output:		None
   1863  * Return value:	None
   1864  */
   1865 
   1866 static int
   1867 twa_intr(void *arg)
   1868 {
   1869 	int	caught, s, rv __diagused;
   1870 	struct twa_softc *sc;
   1871 	uint32_t	status_reg;
   1872 	sc = (struct twa_softc *)arg;
   1873 
   1874 	caught = 0;
   1875 	/* Collect current interrupt status. */
   1876 	status_reg = twa_inl(sc, TWA_STATUS_REGISTER_OFFSET);
   1877 	if (twa_check_ctlr_state(sc, status_reg)) {
   1878 		caught = 1;
   1879 		goto bail;
   1880 	}
   1881 	/* Dispatch based on the kind of interrupt. */
   1882 	if (status_reg & TWA_STATUS_HOST_INTERRUPT) {
   1883 		twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   1884 			TWA_CONTROL_CLEAR_HOST_INTERRUPT);
   1885 		caught = 1;
   1886 	}
   1887 	if ((status_reg & TWA_STATUS_ATTENTION_INTERRUPT) != 0) {
   1888 		twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   1889 			TWA_CONTROL_CLEAR_ATTENTION_INTERRUPT);
   1890 		rv = twa_fetch_aen(sc);
   1891 #ifdef DIAGNOSTIC
   1892 		if (rv != 0)
   1893 			printf("%s: unable to retrieve AEN (%d)\n",
   1894 				device_xname(sc->twa_dv), rv);
   1895 #endif
   1896 		caught = 1;
   1897 	}
   1898 	if (status_reg & TWA_STATUS_COMMAND_INTERRUPT) {
   1899 		/* Start any requests that might be in the pending queue. */
   1900 		twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   1901 			TWA_CONTROL_MASK_COMMAND_INTERRUPT);
   1902 		(void)twa_drain_pending_queue(sc);
   1903 		caught = 1;
   1904 	}
   1905 	if (status_reg & TWA_STATUS_RESPONSE_INTERRUPT) {
   1906 		s = splbio();
   1907 		twa_done(sc);
   1908 		splx(s);
   1909 		caught = 1;
   1910 	}
   1911 bail:
   1912 	return (caught);
   1913 }
   1914 
   1915 /*
   1916  * Accept an open operation on the control device.
   1917  */
   1918 static int
   1919 twaopen(dev_t dev, int flag, int mode, struct lwp *l)
   1920 {
   1921 	struct twa_softc *twa;
   1922 
   1923 	if ((twa = device_lookup_private(&twa_cd, minor(dev))) == NULL)
   1924 		return (ENXIO);
   1925 	if ((twa->twa_sc_flags & TWA_STATE_OPEN) != 0)
   1926 		return (EBUSY);
   1927 
   1928 	twa->twa_sc_flags |= TWA_STATE_OPEN;
   1929 
   1930 	return (0);
   1931 }
   1932 
   1933 /*
   1934  * Accept the last close on the control device.
   1935  */
   1936 static int
   1937 twaclose(dev_t dev, int flag, int mode,
   1938     struct lwp *l)
   1939 {
   1940 	struct twa_softc *twa;
   1941 
   1942 	twa = device_lookup_private(&twa_cd, minor(dev));
   1943 	twa->twa_sc_flags &= ~TWA_STATE_OPEN;
   1944 	return (0);
   1945 }
   1946 
   1947 /*
   1948  * Function name:	twaioctl
   1949  * Description:		ioctl handler.
   1950  *
   1951  * Input:		sc	-- ptr to per ctlr structure
   1952  *			cmd	-- ioctl cmd
   1953  *			buf	-- ptr to buffer in kernel memory, which is
   1954  *				   a copy of the input buffer in user-space
   1955  * Output:		buf	-- ptr to buffer in kernel memory, which will
   1956  *				   be copied of the output buffer in user-space
   1957  * Return value:	0	-- success
   1958  *			non-zero-- failure
   1959  */
   1960 static int
   1961 twaioctl(dev_t dev, u_long cmd, void *data, int flag,
   1962     struct lwp *l)
   1963 {
   1964 	struct twa_softc *sc;
   1965 	struct twa_ioctl_9k	*user_buf = (struct twa_ioctl_9k *)data;
   1966 	struct tw_cl_event_packet event_buf;
   1967 	struct twa_request 	*tr = 0;
   1968 	int32_t			event_index = 0;
   1969 	int32_t			start_index;
   1970 	int			s, error = 0;
   1971 
   1972 	sc = device_lookup_private(&twa_cd, minor(dev));
   1973 
   1974 	switch (cmd) {
   1975 	case TW_OSL_IOCTL_FIRMWARE_PASS_THROUGH:
   1976 	{
   1977 		struct twa_command_packet	*cmdpkt;
   1978 		uint32_t			data_buf_size_adjusted;
   1979 
   1980 		/* Get a request packet */
   1981 		tr = twa_get_request_wait(sc, 0);
   1982 		KASSERT(tr != NULL);
   1983 		/*
   1984 		 * Make sure that the data buffer sent to firmware is a
   1985 		 * 512 byte multiple in size.
   1986 		 */
   1987 		data_buf_size_adjusted =
   1988 			(user_buf->twa_drvr_pkt.buffer_length + 511) & ~511;
   1989 
   1990 		if ((tr->tr_length = data_buf_size_adjusted)) {
   1991 			if ((tr->tr_data = malloc(data_buf_size_adjusted,
   1992 			    M_DEVBUF, M_WAITOK)) == NULL) {
   1993 				error = ENOMEM;
   1994 				goto fw_passthru_done;
   1995 			}
   1996 			/* Copy the payload. */
   1997 			if ((error = copyin((void *) (user_buf->pdata),
   1998 				(void *) (tr->tr_data),
   1999 				user_buf->twa_drvr_pkt.buffer_length)) != 0) {
   2000 					goto fw_passthru_done;
   2001 			}
   2002 			tr->tr_flags |= TWA_CMD_DATA_IN | TWA_CMD_DATA_OUT;
   2003 		}
   2004 		tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_IOCTL;
   2005 		cmdpkt = tr->tr_command;
   2006 
   2007 		/* Copy the command packet. */
   2008 		memcpy(cmdpkt, &(user_buf->twa_cmd_pkt),
   2009 			sizeof(struct twa_command_packet));
   2010 		cmdpkt->command.cmd_pkt_7k.generic.request_id =
   2011 			tr->tr_request_id;
   2012 
   2013 		/* Send down the request, and wait for it to complete. */
   2014 		if ((error = twa_wait_request(tr, TWA_REQUEST_TIMEOUT_PERIOD))) 		{
   2015 			if (error == ETIMEDOUT)
   2016 				break; /* clean-up done by twa_wait_request */
   2017 			goto fw_passthru_done;
   2018 		}
   2019 
   2020 		/* Copy the command packet back into user space. */
   2021 		memcpy(&user_buf->twa_cmd_pkt, cmdpkt,
   2022 			sizeof(struct twa_command_packet));
   2023 
   2024 		/* If there was a payload, copy it back too. */
   2025 		if (tr->tr_length)
   2026 			error = copyout(tr->tr_data, user_buf->pdata,
   2027 					user_buf->twa_drvr_pkt.buffer_length);
   2028 fw_passthru_done:
   2029 		/* Free resources. */
   2030 		if (tr->tr_data)
   2031 			free(tr->tr_data, M_DEVBUF);
   2032 
   2033 		if (tr)
   2034 			twa_release_request(tr);
   2035 		break;
   2036 	}
   2037 
   2038 	case TW_OSL_IOCTL_SCAN_BUS:
   2039 		twa_request_bus_scan(sc);
   2040 		break;
   2041 
   2042 	case TW_CL_IOCTL_GET_FIRST_EVENT:
   2043 		if (sc->twa_aen_queue_wrapped) {
   2044 			if (sc->twa_aen_queue_overflow) {
   2045 				/*
   2046 				 * The aen queue has wrapped, even before some
   2047 				 * events have been retrieved.  Let the caller
   2048 				 * know that he missed out on some AEN's.
   2049 				 */
   2050 				user_buf->twa_drvr_pkt.status =
   2051 					TWA_ERROR_AEN_OVERFLOW;
   2052 				sc->twa_aen_queue_overflow = FALSE;
   2053 			} else
   2054 				user_buf->twa_drvr_pkt.status = 0;
   2055 			event_index = sc->twa_aen_head;
   2056 		} else {
   2057 			if (sc->twa_aen_head == sc->twa_aen_tail) {
   2058 				user_buf->twa_drvr_pkt.status =
   2059 					TWA_ERROR_AEN_NO_EVENTS;
   2060 				break;
   2061 			}
   2062 			user_buf->twa_drvr_pkt.status = 0;
   2063 			event_index = sc->twa_aen_tail;	/* = 0 */
   2064 		}
   2065 		if ((error = copyout(sc->twa_aen_queue[event_index],
   2066 		    user_buf->pdata, sizeof(struct tw_cl_event_packet))) != 0)
   2067 			(sc->twa_aen_queue[event_index])->retrieved =
   2068 			    TWA_AEN_RETRIEVED;
   2069 		break;
   2070 
   2071 	case TW_CL_IOCTL_GET_LAST_EVENT:
   2072 		if (sc->twa_aen_queue_wrapped) {
   2073 			if (sc->twa_aen_queue_overflow) {
   2074 				/*
   2075 				 * The aen queue has wrapped, even before some
   2076 				 * events have been retrieved.  Let the caller
   2077 				 * know that he missed out on some AEN's.
   2078 				 */
   2079 				user_buf->twa_drvr_pkt.status =
   2080 					TWA_ERROR_AEN_OVERFLOW;
   2081 				sc->twa_aen_queue_overflow = FALSE;
   2082 			} else
   2083 				user_buf->twa_drvr_pkt.status = 0;
   2084 		} else {
   2085 			if (sc->twa_aen_head == sc->twa_aen_tail) {
   2086 				user_buf->twa_drvr_pkt.status =
   2087 					TWA_ERROR_AEN_NO_EVENTS;
   2088 				break;
   2089 			}
   2090 			user_buf->twa_drvr_pkt.status = 0;
   2091 		}
   2092 		event_index =
   2093 		    (sc->twa_aen_head - 1 + TWA_Q_LENGTH) % TWA_Q_LENGTH;
   2094 		if ((error = copyout(sc->twa_aen_queue[event_index],
   2095 		    user_buf->pdata, sizeof(struct tw_cl_event_packet))) != 0)
   2096 			(sc->twa_aen_queue[event_index])->retrieved =
   2097 			    TWA_AEN_RETRIEVED;
   2098 		break;
   2099 
   2100 	case TW_CL_IOCTL_GET_NEXT_EVENT:
   2101 		user_buf->twa_drvr_pkt.status = 0;
   2102 		if (sc->twa_aen_queue_wrapped) {
   2103 
   2104 			if (sc->twa_aen_queue_overflow) {
   2105 				/*
   2106 				 * The aen queue has wrapped, even before some
   2107 				 * events have been retrieved.  Let the caller
   2108 				 * know that he missed out on some AEN's.
   2109 				 */
   2110 				user_buf->twa_drvr_pkt.status =
   2111 					TWA_ERROR_AEN_OVERFLOW;
   2112 				sc->twa_aen_queue_overflow = FALSE;
   2113 			}
   2114 			start_index = sc->twa_aen_head;
   2115 		} else {
   2116 			if (sc->twa_aen_head == sc->twa_aen_tail) {
   2117 				user_buf->twa_drvr_pkt.status =
   2118 					TWA_ERROR_AEN_NO_EVENTS;
   2119 				break;
   2120 			}
   2121 			start_index = sc->twa_aen_tail;	/* = 0 */
   2122 		}
   2123 		error = copyin(user_buf->pdata, &event_buf,
   2124 				sizeof(struct tw_cl_event_packet));
   2125 
   2126 		event_index = (start_index + event_buf.sequence_id -
   2127 		    (sc->twa_aen_queue[start_index])->sequence_id + 1)
   2128 		    % TWA_Q_LENGTH;
   2129 
   2130 		if (!((sc->twa_aen_queue[event_index])->sequence_id >
   2131 		    event_buf.sequence_id)) {
   2132 			if (user_buf->twa_drvr_pkt.status ==
   2133 			    TWA_ERROR_AEN_OVERFLOW)
   2134 				/* so we report the overflow next time */
   2135 				sc->twa_aen_queue_overflow = TRUE;
   2136 			user_buf->twa_drvr_pkt.status = TWA_ERROR_AEN_NO_EVENTS;
   2137 			break;
   2138 		}
   2139 		if ((error = copyout(sc->twa_aen_queue[event_index],
   2140 		    user_buf->pdata, sizeof(struct tw_cl_event_packet))) != 0)
   2141 			(sc->twa_aen_queue[event_index])->retrieved =
   2142 			    TWA_AEN_RETRIEVED;
   2143 		break;
   2144 
   2145 	case TW_CL_IOCTL_GET_PREVIOUS_EVENT:
   2146 		user_buf->twa_drvr_pkt.status = 0;
   2147 		if (sc->twa_aen_queue_wrapped) {
   2148 			if (sc->twa_aen_queue_overflow) {
   2149 				/*
   2150 				 * The aen queue has wrapped, even before some
   2151 				 * events have been retrieved.  Let the caller
   2152 				 * know that he missed out on some AEN's.
   2153 				 */
   2154 				user_buf->twa_drvr_pkt.status =
   2155 					TWA_ERROR_AEN_OVERFLOW;
   2156 				sc->twa_aen_queue_overflow = FALSE;
   2157 			}
   2158 			start_index = sc->twa_aen_head;
   2159 		} else {
   2160 			if (sc->twa_aen_head == sc->twa_aen_tail) {
   2161 				user_buf->twa_drvr_pkt.status =
   2162 					TWA_ERROR_AEN_NO_EVENTS;
   2163 				break;
   2164 			}
   2165 			start_index = sc->twa_aen_tail;	/* = 0 */
   2166 		}
   2167 		if ((error = copyin(user_buf->pdata, &event_buf,
   2168 				sizeof(struct tw_cl_event_packet))) != 0)
   2169 
   2170 		event_index = (start_index + event_buf.sequence_id -
   2171 		    (sc->twa_aen_queue[start_index])->sequence_id - 1)
   2172 		    % TWA_Q_LENGTH;
   2173 		if (!((sc->twa_aen_queue[event_index])->sequence_id <
   2174 		    event_buf.sequence_id)) {
   2175 			if (user_buf->twa_drvr_pkt.status ==
   2176 			    TWA_ERROR_AEN_OVERFLOW)
   2177 				/* so we report the overflow next time */
   2178 				sc->twa_aen_queue_overflow = TRUE;
   2179 			user_buf->twa_drvr_pkt.status =
   2180 				TWA_ERROR_AEN_NO_EVENTS;
   2181 			break;
   2182 		}
   2183 		if ((error = copyout(sc->twa_aen_queue [event_index],
   2184 		    user_buf->pdata, sizeof(struct tw_cl_event_packet))) != 0)
   2185 			aprint_error_dev(sc->twa_dv, "get_previous: Could not copyout to "
   2186 			    "event_buf. error = %x\n",
   2187 			    error);
   2188 		(sc->twa_aen_queue[event_index])->retrieved = TWA_AEN_RETRIEVED;
   2189 		break;
   2190 
   2191 	case TW_CL_IOCTL_GET_LOCK:
   2192 	{
   2193 		struct tw_cl_lock_packet	twa_lock;
   2194 
   2195 		copyin(user_buf->pdata, &twa_lock,
   2196 				sizeof(struct tw_cl_lock_packet));
   2197 		s = splbio();
   2198 		if ((sc->twa_ioctl_lock.lock == TWA_LOCK_FREE) ||
   2199 			(twa_lock.force_flag) ||
   2200 			(time_second >= sc->twa_ioctl_lock.timeout)) {
   2201 
   2202 			sc->twa_ioctl_lock.lock = TWA_LOCK_HELD;
   2203 			sc->twa_ioctl_lock.timeout = time_second +
   2204 				(twa_lock.timeout_msec / 1000);
   2205 			twa_lock.time_remaining_msec = twa_lock.timeout_msec;
   2206 			user_buf->twa_drvr_pkt.status = 0;
   2207 		} else {
   2208 			twa_lock.time_remaining_msec =
   2209 				(sc->twa_ioctl_lock.timeout - time_second) *
   2210 				1000;
   2211 			user_buf->twa_drvr_pkt.status =
   2212 					TWA_ERROR_IOCTL_LOCK_ALREADY_HELD;
   2213 		}
   2214 		splx(s);
   2215 		copyout(&twa_lock, user_buf->pdata,
   2216 				sizeof(struct tw_cl_lock_packet));
   2217 		break;
   2218 	}
   2219 
   2220 	case TW_CL_IOCTL_RELEASE_LOCK:
   2221 		s = splbio();
   2222 		if (sc->twa_ioctl_lock.lock == TWA_LOCK_FREE) {
   2223 			user_buf->twa_drvr_pkt.status =
   2224 				TWA_ERROR_IOCTL_LOCK_NOT_HELD;
   2225 		} else {
   2226 			sc->twa_ioctl_lock.lock = TWA_LOCK_FREE;
   2227 			user_buf->twa_drvr_pkt.status = 0;
   2228 		}
   2229 		splx(s);
   2230 		break;
   2231 
   2232 	case TW_CL_IOCTL_GET_COMPATIBILITY_INFO:
   2233 	{
   2234 		struct tw_cl_compatibility_packet	comp_pkt;
   2235 
   2236 		memcpy(comp_pkt.driver_version, TWA_DRIVER_VERSION_STRING,
   2237 					sizeof(TWA_DRIVER_VERSION_STRING));
   2238 		comp_pkt.working_srl = sc->working_srl;
   2239 		comp_pkt.working_branch = sc->working_branch;
   2240 		comp_pkt.working_build = sc->working_build;
   2241 		user_buf->twa_drvr_pkt.status = 0;
   2242 
   2243 		/* Copy compatibility information to user space. */
   2244 		copyout(&comp_pkt, user_buf->pdata,
   2245 				min(sizeof(struct tw_cl_compatibility_packet),
   2246 					user_buf->twa_drvr_pkt.buffer_length));
   2247 		break;
   2248 	}
   2249 
   2250 	case TWA_IOCTL_GET_UNITNAME:	/* WASABI EXTENSION */
   2251 	{
   2252 		struct twa_unitname	*tn;
   2253 		struct twa_drive	*tdr;
   2254 
   2255 		tn = (struct twa_unitname *)data;
   2256 			/* XXX mutex */
   2257 		if (tn->tn_unit < 0 || tn->tn_unit >= sc->sc_nunits)
   2258 			return (EINVAL);
   2259 		tdr = &sc->sc_units[tn->tn_unit];
   2260 		if (tdr->td_dev == NULL)
   2261 			tn->tn_name[0] = '\0';
   2262 		else
   2263 			strlcpy(tn->tn_name, device_xname(tdr->td_dev),
   2264 			    sizeof(tn->tn_name));
   2265 		return (0);
   2266 	}
   2267 
   2268 	default:
   2269 		/* Unknown opcode. */
   2270 		error = ENOTTY;
   2271 	}
   2272 
   2273 	return(error);
   2274 }
   2275 
   2276 const struct cdevsw twa_cdevsw = {
   2277 	.d_open = twaopen,
   2278 	.d_close = twaclose,
   2279 	.d_read = noread,
   2280 	.d_write = nowrite,
   2281 	.d_ioctl = twaioctl,
   2282 	.d_stop = nostop,
   2283 	.d_tty = notty,
   2284 	.d_poll = nopoll,
   2285 	.d_mmap = nommap,
   2286 	.d_kqfilter = nokqfilter,
   2287 	.d_discard = nodiscard,
   2288 	.d_flag = D_OTHER
   2289 };
   2290 
   2291 /*
   2292  * Function name:	twa_get_param
   2293  * Description:		Get a firmware parameter.
   2294  *
   2295  * Input:		sc		-- ptr to per ctlr structure
   2296  *			table_id	-- parameter table #
   2297  *			param_id	-- index of the parameter in the table
   2298  *			param_size	-- size of the parameter in bytes
   2299  *			callback	-- ptr to function, if any, to be called
   2300  *					back on completion; NULL if no callback.
   2301  * Output:		None
   2302  * Return value:	ptr to param structure	-- success
   2303  *			NULL			-- failure
   2304  */
   2305 static int
   2306 twa_get_param(struct twa_softc *sc, int table_id, int param_id,
   2307     size_t param_size, void (* callback)(struct twa_request *tr),
   2308     struct twa_param_9k **param)
   2309 {
   2310 	int			rv = 0;
   2311 	struct twa_request	*tr;
   2312 	union twa_command_7k	*cmd;
   2313 
   2314 	/* Get a request packet. */
   2315 	if ((tr = twa_get_request(sc, 0)) == NULL) {
   2316 		rv = EAGAIN;
   2317 		goto out;
   2318 	}
   2319 
   2320 	tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_INTERNAL;
   2321 
   2322 	/* Allocate memory to read data into. */
   2323 	if ((*param = (struct twa_param_9k *)
   2324 		malloc(TWA_SECTOR_SIZE, M_DEVBUF, M_NOWAIT)) == NULL) {
   2325 		rv = ENOMEM;
   2326 		goto out;
   2327 	}
   2328 
   2329 	memset(*param, 0, sizeof(struct twa_param_9k) - 1 + param_size);
   2330 	tr->tr_data = *param;
   2331 	tr->tr_length = TWA_SECTOR_SIZE;
   2332 	tr->tr_flags = TWA_CMD_DATA_IN | TWA_CMD_DATA_OUT;
   2333 
   2334 	/* Build the cmd pkt. */
   2335 	cmd = &(tr->tr_command->command.cmd_pkt_7k);
   2336 
   2337 	tr->tr_command->cmd_hdr.header_desc.size_header = 128;
   2338 
   2339 	cmd->param.opcode = TWA_OP_GET_PARAM;
   2340 	cmd->param.sgl_offset = 2;
   2341 	cmd->param.size = 2;
   2342 	cmd->param.request_id = tr->tr_request_id;
   2343 	cmd->param.unit = 0;
   2344 	cmd->param.param_count = 1;
   2345 
   2346 	/* Specify which parameter we need. */
   2347 	(*param)->table_id = table_id | TWA_9K_PARAM_DESCRIPTOR;
   2348 	(*param)->parameter_id = param_id;
   2349 	(*param)->parameter_size_bytes = param_size;
   2350 
   2351 	/* Submit the command. */
   2352 	if (callback == NULL) {
   2353 		/* There's no call back; wait till the command completes. */
   2354 		rv = twa_immediate_request(tr, TWA_REQUEST_TIMEOUT_PERIOD);
   2355 
   2356 		if (rv != 0)
   2357 			goto out;
   2358 
   2359 		if ((rv = cmd->param.status) != 0) {
   2360 		     /* twa_drain_complete_queue will have done the unmapping */
   2361 		     goto out;
   2362 		}
   2363 		twa_release_request(tr);
   2364 		return (rv);
   2365 	} else {
   2366 		/* There's a call back.  Simply submit the command. */
   2367 		tr->tr_callback = callback;
   2368 		rv = twa_map_request(tr);
   2369 		return (rv);
   2370 	}
   2371 out:
   2372 	if (tr)
   2373 		twa_release_request(tr);
   2374 	return(rv);
   2375 }
   2376 
   2377 /*
   2378  * Function name:	twa_set_param
   2379  * Description:		Set a firmware parameter.
   2380  *
   2381  * Input:		sc		-- ptr to per ctlr structure
   2382  *			table_id	-- parameter table #
   2383  *			param_id	-- index of the parameter in the table
   2384  *			param_size	-- size of the parameter in bytes
   2385  *			callback	-- ptr to function, if any, to be called
   2386  *					back on completion; NULL if no callback.
   2387  * Output:		None
   2388  * Return value:	0	-- success
   2389  *			non-zero-- failure
   2390  */
   2391 static int
   2392 twa_set_param(struct twa_softc *sc, int table_id, int param_id, int param_size,
   2393     void *data, void (* callback)(struct twa_request *tr))
   2394 {
   2395 	struct twa_request	*tr;
   2396 	union twa_command_7k	*cmd;
   2397 	struct twa_param_9k	*param = NULL;
   2398 	int			error = ENOMEM;
   2399 
   2400 	tr = twa_get_request(sc, 0);
   2401 	if (tr == NULL)
   2402 		return (EAGAIN);
   2403 
   2404 	tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_INTERNAL;
   2405 
   2406 	/* Allocate memory to send data using. */
   2407 	if ((param = (struct twa_param_9k *)
   2408 			malloc(TWA_SECTOR_SIZE, M_DEVBUF, M_NOWAIT)) == NULL)
   2409 		goto out;
   2410 	memset(param, 0, sizeof(struct twa_param_9k) - 1 + param_size);
   2411 	tr->tr_data = param;
   2412 	tr->tr_length = TWA_SECTOR_SIZE;
   2413 	tr->tr_flags = TWA_CMD_DATA_IN | TWA_CMD_DATA_OUT;
   2414 
   2415 	/* Build the cmd pkt. */
   2416 	cmd = &(tr->tr_command->command.cmd_pkt_7k);
   2417 
   2418 	tr->tr_command->cmd_hdr.header_desc.size_header = 128;
   2419 
   2420 	cmd->param.opcode = TWA_OP_SET_PARAM;
   2421 	cmd->param.sgl_offset = 2;
   2422 	cmd->param.size = 2;
   2423 	cmd->param.request_id = tr->tr_request_id;
   2424 	cmd->param.unit = 0;
   2425 	cmd->param.param_count = 1;
   2426 
   2427 	/* Specify which parameter we want to set. */
   2428 	param->table_id = table_id | TWA_9K_PARAM_DESCRIPTOR;
   2429 	param->parameter_id = param_id;
   2430 	param->parameter_size_bytes = param_size;
   2431 	memcpy(param->data, data, param_size);
   2432 
   2433 	/* Submit the command. */
   2434 	if (callback == NULL) {
   2435 		/* There's no call back;  wait till the command completes. */
   2436 		error = twa_immediate_request(tr, TWA_REQUEST_TIMEOUT_PERIOD);
   2437 		if (error == ETIMEDOUT)
   2438 			/* clean-up done by twa_immediate_request */
   2439 			return(error);
   2440 		if (error)
   2441 			goto out;
   2442 		if ((error = cmd->param.status)) {
   2443 			/*
   2444 			 * twa_drain_complete_queue will have done the
   2445 			 * unmapping.
   2446 			 */
   2447 			goto out;
   2448 		}
   2449 		free(param, M_DEVBUF);
   2450 		twa_release_request(tr);
   2451 		return(error);
   2452 	} else {
   2453 		/* There's a call back.  Simply submit the command. */
   2454 		tr->tr_callback = callback;
   2455 		if ((error = twa_map_request(tr)))
   2456 			goto out;
   2457 
   2458 		return (0);
   2459 	}
   2460 out:
   2461 	if (param)
   2462 		free(param, M_DEVBUF);
   2463 	if (tr)
   2464 		twa_release_request(tr);
   2465 	return(error);
   2466 }
   2467 
   2468 /*
   2469  * Function name:	twa_init_connection
   2470  * Description:		Send init_connection cmd to firmware
   2471  *
   2472  * Input:		sc		-- ptr to per ctlr structure
   2473  *			message_credits	-- max # of requests that we might send
   2474  *					 down simultaneously.  This will be
   2475  *					 typically set to 256 at init-time or
   2476  *					after a reset, and to 1 at shutdown-time
   2477  *			set_features	-- indicates if we intend to use 64-bit
   2478  *					sg, also indicates if we want to do a
   2479  *					basic or an extended init_connection;
   2480  *
   2481  * Note: The following input/output parameters are valid, only in case of an
   2482  *		extended init_connection:
   2483  *
   2484  *			current_fw_srl		-- srl of fw we are bundled
   2485  *						with, if any; 0 otherwise
   2486  *			current_fw_arch_id	-- arch_id of fw we are bundled
   2487  *						with, if any; 0 otherwise
   2488  *			current_fw_branch	-- branch # of fw we are bundled
   2489  *						with, if any; 0 otherwise
   2490  *			current_fw_build	-- build # of fw we are bundled
   2491  *						with, if any; 0 otherwise
   2492  * Output:		fw_on_ctlr_srl		-- srl of fw on ctlr
   2493  *			fw_on_ctlr_arch_id	-- arch_id of fw on ctlr
   2494  *			fw_on_ctlr_branch	-- branch # of fw on ctlr
   2495  *			fw_on_ctlr_build	-- build # of fw on ctlr
   2496  *			init_connect_result	-- result bitmap of fw response
   2497  * Return value:	0	-- success
   2498  *			non-zero-- failure
   2499  */
   2500 static int
   2501 twa_init_connection(struct twa_softc *sc, uint16_t message_credits,
   2502     uint32_t set_features, uint16_t current_fw_srl,
   2503     uint16_t current_fw_arch_id, uint16_t current_fw_branch,
   2504     uint16_t current_fw_build, uint16_t *fw_on_ctlr_srl,
   2505     uint16_t *fw_on_ctlr_arch_id, uint16_t *fw_on_ctlr_branch,
   2506     uint16_t *fw_on_ctlr_build, uint32_t *init_connect_result)
   2507 {
   2508 	struct twa_request		*tr;
   2509 	struct twa_command_init_connect	*init_connect;
   2510 	int				error = 1;
   2511 
   2512 	/* Get a request packet. */
   2513 	if ((tr = twa_get_request(sc, 0)) == NULL)
   2514 		goto out;
   2515 	tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_INTERNAL;
   2516 	/* Build the cmd pkt. */
   2517 	init_connect = &(tr->tr_command->command.cmd_pkt_7k.init_connect);
   2518 
   2519 	tr->tr_command->cmd_hdr.header_desc.size_header = 128;
   2520 
   2521 	init_connect->opcode = TWA_OP_INIT_CONNECTION;
   2522    	init_connect->request_id = tr->tr_request_id;
   2523 	init_connect->message_credits = message_credits;
   2524 	init_connect->features = set_features;
   2525 	if (TWA_64BIT_ADDRESSES)
   2526 		init_connect->features |= TWA_64BIT_SG_ADDRESSES;
   2527 	if (set_features & TWA_EXTENDED_INIT_CONNECT) {
   2528 		/*
   2529 		 * Fill in the extra fields needed for
   2530 		 * an extended init_connect.
   2531 		 */
   2532 		init_connect->size = 6;
   2533 		init_connect->fw_srl = current_fw_srl;
   2534 		init_connect->fw_arch_id = current_fw_arch_id;
   2535 		init_connect->fw_branch = current_fw_branch;
   2536 	} else
   2537 		init_connect->size = 3;
   2538 
   2539 	/* Submit the command, and wait for it to complete. */
   2540 	error = twa_immediate_request(tr, TWA_REQUEST_TIMEOUT_PERIOD);
   2541 	if (error == ETIMEDOUT)
   2542 		return(error); /* clean-up done by twa_immediate_request */
   2543 	if (error)
   2544 		goto out;
   2545 	if ((error = init_connect->status)) {
   2546 		/* twa_drain_complete_queue will have done the unmapping */
   2547 		goto out;
   2548 	}
   2549 	if (set_features & TWA_EXTENDED_INIT_CONNECT) {
   2550 		*fw_on_ctlr_srl = init_connect->fw_srl;
   2551 		*fw_on_ctlr_arch_id = init_connect->fw_arch_id;
   2552 		*fw_on_ctlr_branch = init_connect->fw_branch;
   2553 		*fw_on_ctlr_build = init_connect->fw_build;
   2554 		*init_connect_result = init_connect->result;
   2555 	}
   2556 	twa_release_request(tr);
   2557 	return(error);
   2558 
   2559 out:
   2560 	if (tr)
   2561 		twa_release_request(tr);
   2562 	return(error);
   2563 }
   2564 
   2565 static int
   2566 twa_reset(struct twa_softc *sc)
   2567 {
   2568 	int	s;
   2569 	int	error = 0;
   2570 
   2571 	/* Set the 'in reset' flag. */
   2572 	sc->twa_sc_flags |= TWA_STATE_IN_RESET;
   2573 
   2574 	/*
   2575 	 * Disable interrupts from the controller, and mask any
   2576 	 * accidental entry into our interrupt handler.
   2577 	 */
   2578 	twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   2579 		TWA_CONTROL_DISABLE_INTERRUPTS);
   2580 
   2581 	s = splbio();
   2582 
   2583 	/* Soft reset the controller. */
   2584 	if ((error = twa_soft_reset(sc)))
   2585 		goto out;
   2586 
   2587 	/* Re-establish logical connection with the controller. */
   2588 	if ((error = twa_init_connection(sc, TWA_INIT_MESSAGE_CREDITS,
   2589 					0, 0, 0, 0, 0,
   2590 					NULL, NULL, NULL, NULL, NULL))) {
   2591 		goto out;
   2592 	}
   2593 	/*
   2594 	 * Complete all requests in the complete queue; error back all requests
   2595 	 * in the busy queue.  Any internal requests will be simply freed.
   2596 	 * Re-submit any requests in the pending queue.
   2597 	 */
   2598 	twa_drain_busy_queue(sc);
   2599 
   2600 out:
   2601 	splx(s);
   2602 	/*
   2603 	 * Enable interrupts, and also clear attention and response interrupts.
   2604 	 */
   2605 	twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   2606 		TWA_CONTROL_CLEAR_ATTENTION_INTERRUPT |
   2607 		TWA_CONTROL_UNMASK_RESPONSE_INTERRUPT |
   2608 		TWA_CONTROL_ENABLE_INTERRUPTS);
   2609 
   2610 	/* Clear the 'in reset' flag. */
   2611 	sc->twa_sc_flags &= ~TWA_STATE_IN_RESET;
   2612 
   2613 	return(error);
   2614 }
   2615 
   2616 static int
   2617 twa_soft_reset(struct twa_softc *sc)
   2618 {
   2619 	uint32_t	status_reg;
   2620 
   2621 	twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   2622 			TWA_CONTROL_ISSUE_SOFT_RESET |
   2623 			TWA_CONTROL_CLEAR_HOST_INTERRUPT |
   2624 			TWA_CONTROL_CLEAR_ATTENTION_INTERRUPT |
   2625 			TWA_CONTROL_MASK_COMMAND_INTERRUPT |
   2626 			TWA_CONTROL_MASK_RESPONSE_INTERRUPT |
   2627 			TWA_CONTROL_DISABLE_INTERRUPTS);
   2628 
   2629 	if (twa_drain_response_queue_large(sc, 30) != 0) {
   2630 		aprint_error_dev(sc->twa_dv,
   2631 		    "response queue not empty after reset.\n");
   2632 		return(1);
   2633 	}
   2634 	if (twa_wait_status(sc, TWA_STATUS_MICROCONTROLLER_READY |
   2635 				TWA_STATUS_ATTENTION_INTERRUPT, 30)) {
   2636 		aprint_error_dev(sc->twa_dv, "no attention interrupt after reset.\n");
   2637 		return(1);
   2638 	}
   2639 	twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   2640 		TWA_CONTROL_CLEAR_ATTENTION_INTERRUPT);
   2641 
   2642 	if (twa_drain_response_queue(sc)) {
   2643 		aprint_error_dev(sc->twa_dv, "cannot drain response queue.\n");
   2644 		return(1);
   2645 	}
   2646 	if (twa_drain_aen_queue(sc)) {
   2647 		aprint_error_dev(sc->twa_dv, "cannot drain AEN queue.\n");
   2648 		return(1);
   2649 	}
   2650 	if (twa_find_aen(sc, TWA_AEN_SOFT_RESET)) {
   2651 		aprint_error_dev(sc->twa_dv, "reset not reported by controller.\n");
   2652 		return(1);
   2653 	}
   2654 	status_reg = twa_inl(sc, TWA_STATUS_REGISTER_OFFSET);
   2655 	if (TWA_STATUS_ERRORS(status_reg) ||
   2656 	    twa_check_ctlr_state(sc, status_reg)) {
   2657 		aprint_error_dev(sc->twa_dv, "controller errors detected.\n");
   2658 		return(1);
   2659 	}
   2660 	return(0);
   2661 }
   2662 
   2663 static int
   2664 twa_wait_status(struct twa_softc *sc, uint32_t status, uint32_t timeout)
   2665 {
   2666 	struct timeval		t1;
   2667 	time_t		end_time;
   2668 	uint32_t	status_reg;
   2669 
   2670 	timeout = (timeout * 1000 * 100);
   2671 
   2672 	microtime(&t1);
   2673 
   2674 	end_time = t1.tv_usec + timeout;
   2675 
   2676 	do {
   2677 		status_reg = twa_inl(sc, TWA_STATUS_REGISTER_OFFSET);
   2678 		/* got the required bit(s)? */
   2679 		if ((status_reg & status) == status)
   2680 			return(0);
   2681 		DELAY(100000);
   2682 		microtime(&t1);
   2683 	} while (t1.tv_usec <= end_time);
   2684 
   2685 	return(1);
   2686 }
   2687 
   2688 static int
   2689 twa_fetch_aen(struct twa_softc *sc)
   2690 {
   2691 	struct twa_request	*tr;
   2692 	int			s, error = 0;
   2693 
   2694 	s = splbio();
   2695 
   2696 	if ((tr = twa_get_request(sc, TWA_CMD_AEN)) == NULL) {
   2697 		splx(s);
   2698 		return(EIO);
   2699 	}
   2700 	tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_INTERNAL;
   2701 	tr->tr_callback = twa_aen_callback;
   2702 	tr->tr_data = malloc(TWA_SECTOR_SIZE, M_DEVBUF, M_NOWAIT);
   2703 	if (twa_request_sense(tr, 0) != 0) {
   2704 		if (tr->tr_data)
   2705 			free(tr->tr_data, M_DEVBUF);
   2706 		twa_release_request(tr);
   2707 		error = 1;
   2708 	}
   2709 	splx(s);
   2710 
   2711 	return(error);
   2712 }
   2713 
   2714 /*
   2715  * Function name:	twa_aen_callback
   2716  * Description:		Callback for requests to fetch AEN's.
   2717  *
   2718  * Input:		tr	-- ptr to completed request pkt
   2719  * Output:		None
   2720  * Return value:	None
   2721  */
   2722 static void
   2723 twa_aen_callback(struct twa_request *tr)
   2724 {
   2725 	int i;
   2726 	int fetch_more_aens = 0;
   2727 	struct twa_softc		*sc = tr->tr_sc;
   2728 	struct twa_command_header	*cmd_hdr =
   2729 		(struct twa_command_header *)(tr->tr_data);
   2730 	struct twa_command_9k		*cmd =
   2731 		&(tr->tr_command->command.cmd_pkt_9k);
   2732 
   2733 	if (! cmd->status) {
   2734 		if ((tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_9K) &&
   2735 			(cmd->cdb[0] == 0x3 /* REQUEST_SENSE */))
   2736 			if (twa_enqueue_aen(sc, cmd_hdr)
   2737 				!= TWA_AEN_QUEUE_EMPTY)
   2738 				fetch_more_aens = 1;
   2739 	} else {
   2740 		cmd_hdr->err_specific_desc[sizeof(cmd_hdr->err_specific_desc) - 1] = '\0';
   2741 		for (i = 0; i < 18; i++)
   2742 			printf("%x\t", tr->tr_command->cmd_hdr.sense_data[i]);
   2743 
   2744 		printf(""); /* print new line */
   2745 
   2746 		for (i = 0; i < 128; i++)
   2747 			printf("%x\t", ((int8_t *)(tr->tr_data))[i]);
   2748 	}
   2749 	if (tr->tr_data)
   2750 		free(tr->tr_data, M_DEVBUF);
   2751 	twa_release_request(tr);
   2752 
   2753 	if (fetch_more_aens)
   2754 		twa_fetch_aen(sc);
   2755 }
   2756 
   2757 /*
   2758  * Function name:	twa_enqueue_aen
   2759  * Description:		Queues AEN's to be supplied to user-space tools on request.
   2760  *
   2761  * Input:		sc	-- ptr to per ctlr structure
   2762  *			cmd_hdr	-- ptr to hdr of fw cmd pkt, from where the AEN
   2763  *				   details can be retrieved.
   2764  * Output:		None
   2765  * Return value:	None
   2766  */
   2767 static uint16_t
   2768 twa_enqueue_aen(struct twa_softc *sc, struct twa_command_header *cmd_hdr)
   2769 {
   2770 	int			rv __diagused, s;
   2771 	struct tw_cl_event_packet *event;
   2772 	uint16_t		aen_code;
   2773 	unsigned long		sync_time;
   2774 
   2775 	s = splbio();
   2776 	aen_code = cmd_hdr->status_block.error;
   2777 
   2778 	switch (aen_code) {
   2779 	case TWA_AEN_SYNC_TIME_WITH_HOST:
   2780 
   2781 		sync_time = (time_second - (3 * 86400)) % 604800;
   2782 		rv = twa_set_param(sc, TWA_PARAM_TIME_TABLE,
   2783 				TWA_PARAM_TIME_SchedulerTime, 4,
   2784 				&sync_time, twa_aen_callback);
   2785 #ifdef DIAGNOSTIC
   2786 		if (rv != 0)
   2787 			aprint_error_dev(sc->twa_dv, "unable to sync time with ctlr\n");
   2788 #endif
   2789 		break;
   2790 
   2791 	case TWA_AEN_QUEUE_EMPTY:
   2792 		break;
   2793 
   2794 	default:
   2795 		/* Queue the event. */
   2796 		event = sc->twa_aen_queue[sc->twa_aen_head];
   2797 		if (event->retrieved == TWA_AEN_NOT_RETRIEVED)
   2798 			sc->twa_aen_queue_overflow = TRUE;
   2799 		event->severity =
   2800 			cmd_hdr->status_block.substatus_block.severity;
   2801 		event->time_stamp_sec = time_second;
   2802 		event->aen_code = aen_code;
   2803 		event->retrieved = TWA_AEN_NOT_RETRIEVED;
   2804 		event->sequence_id = ++(sc->twa_current_sequence_id);
   2805 		cmd_hdr->err_specific_desc[sizeof(cmd_hdr->err_specific_desc) - 1] = '\0';
   2806 		event->parameter_len = strlen(cmd_hdr->err_specific_desc);
   2807 		memcpy(event->parameter_data, cmd_hdr->err_specific_desc,
   2808 			event->parameter_len);
   2809 
   2810 		if (event->severity < TWA_AEN_SEVERITY_DEBUG) {
   2811 			printf("%s: AEN 0x%04X: %s: %s: %s\n",
   2812 				device_xname(sc->twa_dv),
   2813 				aen_code,
   2814 				twa_aen_severity_table[event->severity],
   2815 				twa_find_msg_string(twa_aen_table, aen_code),
   2816 				event->parameter_data);
   2817 		}
   2818 
   2819 		if ((sc->twa_aen_head + 1) == TWA_Q_LENGTH)
   2820 			sc->twa_aen_queue_wrapped = TRUE;
   2821 		sc->twa_aen_head = (sc->twa_aen_head + 1) % TWA_Q_LENGTH;
   2822 		break;
   2823 	} /* switch */
   2824 	splx(s);
   2825 
   2826 	return (aen_code);
   2827 }
   2828 
   2829 /*
   2830  * Function name:	twa_find_aen
   2831  * Description:		Reports whether a given AEN ever occurred.
   2832  *
   2833  * Input:		sc	-- ptr to per ctlr structure
   2834  *			aen_code-- AEN to look for
   2835  * Output:		None
   2836  * Return value:	0	-- success
   2837  *			non-zero-- failure
   2838  */
   2839 static int
   2840 twa_find_aen(struct twa_softc *sc, uint16_t aen_code)
   2841 {
   2842 	uint32_t	last_index;
   2843 	int		s;
   2844 	int		i;
   2845 
   2846 	s = splbio();
   2847 
   2848 	if (sc->twa_aen_queue_wrapped)
   2849 		last_index = sc->twa_aen_head;
   2850 	else
   2851 		last_index = 0;
   2852 
   2853 	i = sc->twa_aen_head;
   2854 	do {
   2855 		i = (i + TWA_Q_LENGTH - 1) % TWA_Q_LENGTH;
   2856 		if ((sc->twa_aen_queue[i])->aen_code == aen_code) {
   2857 			splx(s);
   2858 			return(0);
   2859 		}
   2860 	} while (i != last_index);
   2861 
   2862 	splx(s);
   2863 	return(1);
   2864 }
   2865 
   2866 static inline void
   2867 twa_request_init(struct twa_request *tr, int flags)
   2868 {
   2869 	tr->tr_data = NULL;
   2870 	tr->tr_real_data = NULL;
   2871 	tr->tr_length = 0;
   2872 	tr->tr_real_length = 0;
   2873 	tr->tr_status = TWA_CMD_SETUP;/* command is in setup phase */
   2874 	tr->tr_flags = flags;
   2875 	tr->tr_error = 0;
   2876 	tr->tr_callback = NULL;
   2877 	tr->tr_cmd_pkt_type = 0;
   2878 	tr->bp = 0;
   2879 
   2880 	/*
   2881 	 * Look at the status field in the command packet to see how
   2882 	 * it completed the last time it was used, and zero out only
   2883 	 * the portions that might have changed.  Note that we don't
   2884 	 * care to zero out the sglist.
   2885 	 */
   2886 	if (tr->tr_command->command.cmd_pkt_9k.status)
   2887 		memset(tr->tr_command, 0,
   2888 			sizeof(struct twa_command_header) + 28);
   2889 	else
   2890 		memset(&(tr->tr_command->command), 0, 28);
   2891 }
   2892 
   2893 struct twa_request *
   2894 twa_get_request_wait(struct twa_softc *sc, int flags)
   2895 {
   2896 	struct twa_request *tr;
   2897 	int s;
   2898 
   2899 	KASSERT((flags & TWA_CMD_AEN) == 0);
   2900 
   2901 	s = splbio();
   2902 	while ((tr = TAILQ_FIRST(&sc->twa_free)) == NULL) {
   2903 		sc->twa_sc_flags |= TWA_STATE_REQUEST_WAIT;
   2904 		(void) tsleep(&sc->twa_free, PRIBIO, "twaccb", hz);
   2905 	}
   2906 	TAILQ_REMOVE(&sc->twa_free, tr, tr_link);
   2907 
   2908 	splx(s);
   2909 
   2910 	twa_request_init(tr, flags);
   2911 
   2912 	return(tr);
   2913 }
   2914 
   2915 struct twa_request *
   2916 twa_get_request(struct twa_softc *sc, int flags)
   2917 {
   2918 	int s;
   2919 	struct twa_request *tr;
   2920 
   2921 	/* Get a free request packet. */
   2922 	s = splbio();
   2923 	if (__predict_false((flags & TWA_CMD_AEN) != 0)) {
   2924 
   2925 		if ((sc->sc_twa_request->tr_flags & TWA_CMD_AEN_BUSY) == 0) {
   2926 			tr = sc->sc_twa_request;
   2927 			flags |= TWA_CMD_AEN_BUSY;
   2928 		} else {
   2929 			splx(s);
   2930 			return (NULL);
   2931 		}
   2932 	} else {
   2933 		if (__predict_false((tr =
   2934 				TAILQ_FIRST(&sc->twa_free)) == NULL)) {
   2935 			splx(s);
   2936 			return (NULL);
   2937 		}
   2938 		TAILQ_REMOVE(&sc->twa_free, tr, tr_link);
   2939 	}
   2940 	splx(s);
   2941 
   2942 	twa_request_init(tr, flags);
   2943 
   2944 	return(tr);
   2945 }
   2946 
   2947 /*
   2948  * Print some information about the controller
   2949  */
   2950 static void
   2951 twa_describe_controller(struct twa_softc *sc)
   2952 {
   2953 	struct twa_param_9k	*p[10];
   2954 	int			i, rv = 0;
   2955 	uint32_t		dsize;
   2956 	uint8_t			ports;
   2957 
   2958 	memset(p, sizeof(struct twa_param_9k *), 10);
   2959 
   2960 	/* Get the port count. */
   2961 	rv |= twa_get_param(sc, TWA_PARAM_CONTROLLER,
   2962 		TWA_PARAM_CONTROLLER_PortCount, 1, NULL, &p[0]);
   2963 
   2964 	/* get version strings */
   2965 	rv |= twa_get_param(sc, TWA_PARAM_VERSION, TWA_PARAM_VERSION_FW,
   2966 		16, NULL, &p[1]);
   2967 	rv |= twa_get_param(sc, TWA_PARAM_VERSION, TWA_PARAM_VERSION_BIOS,
   2968 		16, NULL, &p[2]);
   2969 	rv |= twa_get_param(sc, TWA_PARAM_VERSION, TWA_PARAM_VERSION_Mon,
   2970 		16, NULL, &p[3]);
   2971 	rv |= twa_get_param(sc, TWA_PARAM_VERSION, TWA_PARAM_VERSION_PCBA,
   2972 		8, NULL, &p[4]);
   2973 	rv |= twa_get_param(sc, TWA_PARAM_VERSION, TWA_PARAM_VERSION_ATA,
   2974 		8, NULL, &p[5]);
   2975 	rv |= twa_get_param(sc, TWA_PARAM_VERSION, TWA_PARAM_VERSION_PCI,
   2976 		8, NULL, &p[6]);
   2977 	rv |= twa_get_param(sc, TWA_PARAM_DRIVESUMMARY, TWA_PARAM_DRIVESTATUS,
   2978 		16, NULL, &p[7]);
   2979 
   2980 	if (rv) {
   2981 		/* some error occurred */
   2982 		aprint_error_dev(sc->twa_dv, "failed to fetch version information\n");
   2983 		goto bail;
   2984 	}
   2985 
   2986 	ports = *(uint8_t *)(p[0]->data);
   2987 
   2988 	aprint_normal_dev(sc->twa_dv, "%d ports, Firmware %.16s, BIOS %.16s\n",
   2989 		ports, p[1]->data, p[2]->data);
   2990 
   2991 	aprint_verbose_dev(sc->twa_dv, "Monitor %.16s, PCB %.8s, Achip %.8s, Pchip %.8s\n",
   2992 		p[3]->data, p[4]->data,
   2993 		p[5]->data, p[6]->data);
   2994 
   2995 	for (i = 0; i < ports; i++) {
   2996 
   2997 		if ((*((char *)(p[7]->data + i)) & TWA_DRIVE_DETECTED) == 0)
   2998 			continue;
   2999 
   3000 		rv = twa_get_param(sc, TWA_PARAM_DRIVE_TABLE + i,
   3001 			TWA_PARAM_DRIVEMODELINDEX,
   3002 			TWA_PARAM_DRIVEMODEL_LENGTH, NULL, &p[8]);
   3003 
   3004 		if (rv != 0) {
   3005 			aprint_error_dev(sc->twa_dv, "unable to get drive model for port"
   3006 				" %d\n", i);
   3007 			continue;
   3008 		}
   3009 
   3010 		rv = twa_get_param(sc, TWA_PARAM_DRIVE_TABLE + i,
   3011 			TWA_PARAM_DRIVESIZEINDEX,
   3012 			TWA_PARAM_DRIVESIZE_LENGTH, NULL, &p[9]);
   3013 
   3014 		if (rv != 0) {
   3015 			aprint_error_dev(sc->twa_dv, "unable to get drive size"
   3016 				" for port %d\n", i);
   3017 			free(p[8], M_DEVBUF);
   3018 			continue;
   3019 		}
   3020 
   3021 		dsize = *(uint32_t *)(p[9]->data);
   3022 
   3023 		aprint_verbose_dev(sc->twa_dv, "port %d: %.40s %d MB\n",
   3024 		    i, p[8]->data, dsize / 2048);
   3025 
   3026 		if (p[8])
   3027 			free(p[8], M_DEVBUF);
   3028 		if (p[9])
   3029 			free(p[9], M_DEVBUF);
   3030 	}
   3031 bail:
   3032 	if (p[0])
   3033 		free(p[0], M_DEVBUF);
   3034 	if (p[1])
   3035 		free(p[1], M_DEVBUF);
   3036 	if (p[2])
   3037 		free(p[2], M_DEVBUF);
   3038 	if (p[3])
   3039 		free(p[3], M_DEVBUF);
   3040 	if (p[4])
   3041 		free(p[4], M_DEVBUF);
   3042 	if (p[5])
   3043 		free(p[5], M_DEVBUF);
   3044 	if (p[6])
   3045 		free(p[6], M_DEVBUF);
   3046 }
   3047 
   3048 /*
   3049  * Function name:	twa_check_ctlr_state
   3050  * Description:		Makes sure that the fw status register reports a
   3051  *			proper status.
   3052  *
   3053  * Input:		sc		-- ptr to per ctlr structure
   3054  *			status_reg	-- value in the status register
   3055  * Output:		None
   3056  * Return value:	0	-- no errors
   3057  *			non-zero-- errors
   3058  */
   3059 static int
   3060 twa_check_ctlr_state(struct twa_softc *sc, uint32_t status_reg)
   3061 {
   3062 	int		result = 0;
   3063 	struct timeval	t1;
   3064 	static time_t	last_warning[2] = {0, 0};
   3065 
   3066 	/* Check if the 'micro-controller ready' bit is not set. */
   3067 	if ((status_reg & TWA_STATUS_EXPECTED_BITS) !=
   3068 				TWA_STATUS_EXPECTED_BITS) {
   3069 
   3070 		microtime(&t1);
   3071 
   3072 		last_warning[0] += (5 * 1000 * 100);
   3073 
   3074 		if (t1.tv_usec > last_warning[0]) {
   3075 			microtime(&t1);
   3076 			last_warning[0] = t1.tv_usec;
   3077 		}
   3078 		result = 1;
   3079 	}
   3080 
   3081 	/* Check if any error bits are set. */
   3082 	if ((status_reg & TWA_STATUS_UNEXPECTED_BITS) != 0) {
   3083 
   3084 		microtime(&t1);
   3085 		last_warning[1] += (5 * 1000 * 100);
   3086 		if (t1.tv_usec > last_warning[1]) {
   3087 		     	microtime(&t1);
   3088 			last_warning[1] = t1.tv_usec;
   3089 		}
   3090 		if (status_reg & TWA_STATUS_PCI_PARITY_ERROR_INTERRUPT) {
   3091 			aprint_error_dev(sc->twa_dv, "clearing PCI parity error "
   3092 				"re-seat/move/replace card.\n");
   3093 			twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   3094 				TWA_CONTROL_CLEAR_PARITY_ERROR);
   3095 			pci_conf_write(sc->pc, sc->tag,
   3096 				PCI_COMMAND_STATUS_REG,
   3097 				TWA_PCI_CONFIG_CLEAR_PARITY_ERROR);
   3098 		}
   3099 		if (status_reg & TWA_STATUS_PCI_ABORT_INTERRUPT) {
   3100 			aprint_error_dev(sc->twa_dv, "clearing PCI abort\n");
   3101 			twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   3102 				TWA_CONTROL_CLEAR_PCI_ABORT);
   3103 			pci_conf_write(sc->pc, sc->tag,
   3104 				PCI_COMMAND_STATUS_REG,
   3105 				TWA_PCI_CONFIG_CLEAR_PCI_ABORT);
   3106 		}
   3107 		if (status_reg & TWA_STATUS_QUEUE_ERROR_INTERRUPT) {
   3108  			/*
   3109 			 * As documented by 3ware, the 9650 erroneously
   3110 			 * flags queue errors during resets.
   3111 			 * Just ignore them during the reset instead of
   3112 			 * bothering the console.
   3113  			 */
   3114  			if ((sc->sc_product_id != PCI_PRODUCT_3WARE_9650) ||
   3115  			    ((sc->twa_sc_flags & TWA_STATE_IN_RESET) == 0)) {
   3116  				aprint_error_dev(sc->twa_dv,
   3117  				    "clearing controller queue error\n");
   3118  			}
   3119 
   3120   			twa_outl(sc, TWA_CONTROL_REGISTER_OFFSET,
   3121  				TWA_CONTROL_CLEAR_QUEUE_ERROR);
   3122 		}
   3123 		if (status_reg & TWA_STATUS_MICROCONTROLLER_ERROR) {
   3124 			aprint_error_dev(sc->twa_dv, "micro-controller error\n");
   3125 			result = 1;
   3126 		}
   3127 	}
   3128 	return(result);
   3129 }
   3130