aac.c revision 157587
11573Srgrimes/*- 21573Srgrimes * Copyright (c) 2000 Michael Smith 31573Srgrimes * Copyright (c) 2001 Scott Long 41573Srgrimes * Copyright (c) 2000 BSDi 51573Srgrimes * Copyright (c) 2001 Adaptec, Inc. 61573Srgrimes * All rights reserved. 71573Srgrimes * 81573Srgrimes * Redistribution and use in source and binary forms, with or without 91573Srgrimes * modification, are permitted provided that the following conditions 101573Srgrimes * are met: 111573Srgrimes * 1. Redistributions of source code must retain the above copyright 121573Srgrimes * notice, this list of conditions and the following disclaimer. 131573Srgrimes * 2. Redistributions in binary form must reproduce the above copyright 141573Srgrimes * notice, this list of conditions and the following disclaimer in the 151573Srgrimes * documentation and/or other materials provided with the distribution. 161573Srgrimes * 171573Srgrimes * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 181573Srgrimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 191573Srgrimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 201573Srgrimes * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 211573Srgrimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 221573Srgrimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 231573Srgrimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 241573Srgrimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 251573Srgrimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 261573Srgrimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 271573Srgrimes * SUCH DAMAGE. 281573Srgrimes */ 291573Srgrimes 301573Srgrimes#include <sys/cdefs.h> 311573Srgrimes__FBSDID("$FreeBSD: head/sys/dev/aac/aac.c 157587 2006-04-08 06:05:29Z scottl $"); 321573Srgrimes 3392889Sobrien/* 3492889Sobrien * Driver for the Adaptec 'FSA' family of PCI/SCSI RAID adapters. 351573Srgrimes */ 361573Srgrimes#define AAC_DRIVER_VERSION 0x02000000 371573Srgrimes#define AAC_DRIVERNAME "aac" 38309636Sglebius 391573Srgrimes#include "opt_aac.h" 401573Srgrimes 411573Srgrimes/* #include <stddef.h> */ 421573Srgrimes#include <sys/param.h> 431573Srgrimes#include <sys/systm.h> 441573Srgrimes#include <sys/malloc.h> 451573Srgrimes#include <sys/kernel.h> 461573Srgrimes#include <sys/kthread.h> 471573Srgrimes#include <sys/sysctl.h> 481573Srgrimes#include <sys/poll.h> 491573Srgrimes#include <sys/ioccom.h> 501573Srgrimes 511573Srgrimes#include <sys/bus.h> 521573Srgrimes#include <sys/conf.h> 531573Srgrimes#include <sys/signalvar.h> 541573Srgrimes#include <sys/time.h> 5592889Sobrien#include <sys/eventhandler.h> 5692889Sobrien#include <sys/rman.h> 571573Srgrimes 5892889Sobrien#include <machine/bus.h> 591573Srgrimes#include <sys/bus_dma.h> 6092889Sobrien#include <machine/resource.h> 611573Srgrimes 621573Srgrimes#include <dev/pci/pcireg.h> 631573Srgrimes#include <dev/pci/pcivar.h> 641573Srgrimes 651573Srgrimes#include <dev/aac/aacreg.h> 661573Srgrimes#include <sys/aac_ioctl.h> 671573Srgrimes#include <dev/aac/aacvar.h> 681573Srgrimes#include <dev/aac/aac_tables.h> 691573Srgrimes 701573Srgrimesstatic void aac_startup(void *arg); 711573Srgrimesstatic void aac_add_container(struct aac_softc *sc, 721573Srgrimes struct aac_mntinforesp *mir, int f); 731573Srgrimesstatic void aac_get_bus_info(struct aac_softc *sc); 741573Srgrimes 751573Srgrimes/* Command Processing */ 761573Srgrimesstatic void aac_timeout(struct aac_softc *sc); 771573Srgrimesstatic void aac_complete(void *context, int pending); 781573Srgrimesstatic int aac_bio_command(struct aac_softc *sc, struct aac_command **cmp); 791573Srgrimesstatic void aac_bio_complete(struct aac_command *cm); 801573Srgrimesstatic int aac_wait_command(struct aac_command *cm); 811573Srgrimesstatic void aac_command_thread(struct aac_softc *sc); 821573Srgrimes 831573Srgrimes/* Command Buffer Management */ 841573Srgrimesstatic void aac_map_command_sg(void *arg, bus_dma_segment_t *segs, 851573Srgrimes int nseg, int error); 861573Srgrimesstatic void aac_map_command_helper(void *arg, bus_dma_segment_t *segs, 871573Srgrimes int nseg, int error); 881573Srgrimesstatic int aac_alloc_commands(struct aac_softc *sc); 891573Srgrimesstatic void aac_free_commands(struct aac_softc *sc); 901573Srgrimesstatic void aac_unmap_command(struct aac_command *cm); 911573Srgrimes 921573Srgrimes/* Hardware Interface */ 931573Srgrimesstatic void aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg, 941573Srgrimes int error); 951573Srgrimesstatic int aac_check_firmware(struct aac_softc *sc); 961573Srgrimesstatic int aac_init(struct aac_softc *sc); 971573Srgrimesstatic int aac_sync_command(struct aac_softc *sc, u_int32_t command, 981573Srgrimes u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, 991573Srgrimes u_int32_t arg3, u_int32_t *sp); 1001573Srgrimesstatic int aac_enqueue_fib(struct aac_softc *sc, int queue, 1011573Srgrimes struct aac_command *cm); 1021573Srgrimesstatic int aac_dequeue_fib(struct aac_softc *sc, int queue, 1031573Srgrimes u_int32_t *fib_size, struct aac_fib **fib_addr); 1041573Srgrimesstatic int aac_enqueue_response(struct aac_softc *sc, int queue, 1051573Srgrimes struct aac_fib *fib); 1061573Srgrimes 1071573Srgrimes/* Falcon/PPC interface */ 1081573Srgrimesstatic int aac_fa_get_fwstatus(struct aac_softc *sc); 1091573Srgrimesstatic void aac_fa_qnotify(struct aac_softc *sc, int qbit); 1101573Srgrimesstatic int aac_fa_get_istatus(struct aac_softc *sc); 1111573Srgrimesstatic void aac_fa_clear_istatus(struct aac_softc *sc, int mask); 1121573Srgrimesstatic void aac_fa_set_mailbox(struct aac_softc *sc, u_int32_t command, 1131573Srgrimes u_int32_t arg0, u_int32_t arg1, 1148870Srgrimes u_int32_t arg2, u_int32_t arg3); 1151573Srgrimesstatic int aac_fa_get_mailbox(struct aac_softc *sc, int mb); 1161573Srgrimesstatic void aac_fa_set_interrupts(struct aac_softc *sc, int enable); 1171573Srgrimes 1181573Srgrimesstruct aac_interface aac_fa_interface = { 1191573Srgrimes aac_fa_get_fwstatus, 1201573Srgrimes aac_fa_qnotify, 1211573Srgrimes aac_fa_get_istatus, 122270032Spfg aac_fa_clear_istatus, 1231573Srgrimes aac_fa_set_mailbox, 1241573Srgrimes aac_fa_get_mailbox, 1251573Srgrimes aac_fa_set_interrupts, 12692889Sobrien NULL, NULL, NULL 1271573Srgrimes}; 1281573Srgrimes 129309636Sglebius/* StrongARM interface */ 130309636Sglebiusstatic int aac_sa_get_fwstatus(struct aac_softc *sc); 131309696Sglebiusstatic void aac_sa_qnotify(struct aac_softc *sc, int qbit); 132309636Sglebiusstatic int aac_sa_get_istatus(struct aac_softc *sc); 1331573Srgrimesstatic void aac_sa_clear_istatus(struct aac_softc *sc, int mask); 134309636Sglebiusstatic void aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command, 135309636Sglebius u_int32_t arg0, u_int32_t arg1, 136309636Sglebius u_int32_t arg2, u_int32_t arg3); 137309636Sglebiusstatic int aac_sa_get_mailbox(struct aac_softc *sc, int mb); 138309636Sglebiusstatic void aac_sa_set_interrupts(struct aac_softc *sc, int enable); 139309636Sglebius 140309636Sglebiusstruct aac_interface aac_sa_interface = { 141309636Sglebius aac_sa_get_fwstatus, 142309636Sglebius aac_sa_qnotify, 1431573Srgrimes aac_sa_get_istatus, 144309636Sglebius aac_sa_clear_istatus, 145309636Sglebius aac_sa_set_mailbox, 1461573Srgrimes aac_sa_get_mailbox, 147309636Sglebius aac_sa_set_interrupts, 148309696Sglebius NULL, NULL, NULL 149309636Sglebius}; 150309636Sglebius 151309636Sglebius/* i960Rx interface */ 152309696Sglebiusstatic int aac_rx_get_fwstatus(struct aac_softc *sc); 1531573Srgrimesstatic void aac_rx_qnotify(struct aac_softc *sc, int qbit); 154309636Sglebiusstatic int aac_rx_get_istatus(struct aac_softc *sc); 155309636Sglebiusstatic void aac_rx_clear_istatus(struct aac_softc *sc, int mask); 1561573Srgrimesstatic void aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command, 1571573Srgrimes u_int32_t arg0, u_int32_t arg1, 158309636Sglebius u_int32_t arg2, u_int32_t arg3); 159309636Sglebiusstatic int aac_rx_get_mailbox(struct aac_softc *sc, int mb); 160309696Sglebiusstatic void aac_rx_set_interrupts(struct aac_softc *sc, int enable); 161309636Sglebiusstatic int aac_rx_send_command(struct aac_softc *sc, struct aac_command *cm); 162309636Sglebiusstatic int aac_rx_get_outb_queue(struct aac_softc *sc); 163309636Sglebiusstatic void aac_rx_set_outb_queue(struct aac_softc *sc, int index); 164309636Sglebius 165309636Sglebiusstruct aac_interface aac_rx_interface = { 166309636Sglebius aac_rx_get_fwstatus, 167309696Sglebius aac_rx_qnotify, 168309636Sglebius aac_rx_get_istatus, 1691573Srgrimes aac_rx_clear_istatus, 1701573Srgrimes aac_rx_set_mailbox, 1711573Srgrimes aac_rx_get_mailbox, 1721573Srgrimes aac_rx_set_interrupts, 173 aac_rx_send_command, 174 aac_rx_get_outb_queue, 175 aac_rx_set_outb_queue 176}; 177 178/* Rocket/MIPS interface */ 179static int aac_rkt_get_fwstatus(struct aac_softc *sc); 180static void aac_rkt_qnotify(struct aac_softc *sc, int qbit); 181static int aac_rkt_get_istatus(struct aac_softc *sc); 182static void aac_rkt_clear_istatus(struct aac_softc *sc, int mask); 183static void aac_rkt_set_mailbox(struct aac_softc *sc, u_int32_t command, 184 u_int32_t arg0, u_int32_t arg1, 185 u_int32_t arg2, u_int32_t arg3); 186static int aac_rkt_get_mailbox(struct aac_softc *sc, int mb); 187static void aac_rkt_set_interrupts(struct aac_softc *sc, int enable); 188static int aac_rkt_send_command(struct aac_softc *sc, struct aac_command *cm); 189static int aac_rkt_get_outb_queue(struct aac_softc *sc); 190static void aac_rkt_set_outb_queue(struct aac_softc *sc, int index); 191 192struct aac_interface aac_rkt_interface = { 193 aac_rkt_get_fwstatus, 194 aac_rkt_qnotify, 195 aac_rkt_get_istatus, 196 aac_rkt_clear_istatus, 197 aac_rkt_set_mailbox, 198 aac_rkt_get_mailbox, 199 aac_rkt_set_interrupts, 200 aac_rkt_send_command, 201 aac_rkt_get_outb_queue, 202 aac_rkt_set_outb_queue 203}; 204 205/* Debugging and Diagnostics */ 206static void aac_describe_controller(struct aac_softc *sc); 207static char *aac_describe_code(struct aac_code_lookup *table, 208 u_int32_t code); 209 210/* Management Interface */ 211static d_open_t aac_open; 212static d_close_t aac_close; 213static d_ioctl_t aac_ioctl; 214static d_poll_t aac_poll; 215static int aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib); 216static void aac_handle_aif(struct aac_softc *sc, 217 struct aac_fib *fib); 218static int aac_rev_check(struct aac_softc *sc, caddr_t udata); 219static int aac_getnext_aif(struct aac_softc *sc, caddr_t arg); 220static int aac_return_aif(struct aac_softc *sc, caddr_t uptr); 221static int aac_query_disk(struct aac_softc *sc, caddr_t uptr); 222static int aac_get_pci_info(struct aac_softc *sc, caddr_t uptr); 223static void aac_ioctl_event(struct aac_softc *sc, 224 struct aac_event *event, void *arg); 225 226static struct cdevsw aac_cdevsw = { 227 .d_version = D_VERSION, 228 .d_flags = D_NEEDGIANT, 229 .d_open = aac_open, 230 .d_close = aac_close, 231 .d_ioctl = aac_ioctl, 232 .d_poll = aac_poll, 233 .d_name = "aac", 234}; 235 236MALLOC_DEFINE(M_AACBUF, "aacbuf", "Buffers for the AAC driver"); 237 238/* sysctl node */ 239SYSCTL_NODE(_hw, OID_AUTO, aac, CTLFLAG_RD, 0, "AAC driver parameters"); 240 241/* 242 * Device Interface 243 */ 244 245/* 246 * Initialise the controller and softc 247 */ 248int 249aac_attach(struct aac_softc *sc) 250{ 251 int error, unit; 252 253 debug_called(1); 254 255 /* 256 * Initialise per-controller queues. 257 */ 258 aac_initq_free(sc); 259 aac_initq_ready(sc); 260 aac_initq_busy(sc); 261 aac_initq_bio(sc); 262 263 /* 264 * Initialise command-completion task. 265 */ 266 TASK_INIT(&sc->aac_task_complete, 0, aac_complete, sc); 267 268 /* mark controller as suspended until we get ourselves organised */ 269 sc->aac_state |= AAC_STATE_SUSPEND; 270 271 /* 272 * Check that the firmware on the card is supported. 273 */ 274 if ((error = aac_check_firmware(sc)) != 0) 275 return(error); 276 277 /* 278 * Initialize locks 279 */ 280 mtx_init(&sc->aac_aifq_lock, "AAC AIF lock", NULL, MTX_DEF); 281 mtx_init(&sc->aac_io_lock, "AAC I/O lock", NULL, MTX_DEF); 282 mtx_init(&sc->aac_container_lock, "AAC container lock", NULL, MTX_DEF); 283 TAILQ_INIT(&sc->aac_container_tqh); 284 TAILQ_INIT(&sc->aac_ev_cmfree); 285 286 /* Initialize the local AIF queue pointers */ 287 sc->aac_aifq_head = sc->aac_aifq_tail = AAC_AIFQ_LENGTH; 288 289 /* 290 * Initialise the adapter. 291 */ 292 if ((error = aac_init(sc)) != 0) 293 return(error); 294 295 /* 296 * Allocate and connect our interrupt. 297 */ 298 sc->aac_irq_rid = 0; 299 if ((sc->aac_irq = bus_alloc_resource_any(sc->aac_dev, SYS_RES_IRQ, 300 &sc->aac_irq_rid, 301 RF_SHAREABLE | 302 RF_ACTIVE)) == NULL) { 303 device_printf(sc->aac_dev, "can't allocate interrupt\n"); 304 return (EINVAL); 305 } 306 if (sc->flags & AAC_FLAGS_NEW_COMM) { 307 if (bus_setup_intr(sc->aac_dev, sc->aac_irq, 308 INTR_MPSAFE|INTR_TYPE_BIO, aac_new_intr, 309 sc, &sc->aac_intr)) { 310 device_printf(sc->aac_dev, "can't set up interrupt\n"); 311 return (EINVAL); 312 } 313 } else { 314 if (bus_setup_intr(sc->aac_dev, sc->aac_irq, 315 INTR_FAST|INTR_TYPE_BIO, aac_fast_intr, 316 sc, &sc->aac_intr)) { 317 device_printf(sc->aac_dev, 318 "can't set up FAST interrupt\n"); 319 if (bus_setup_intr(sc->aac_dev, sc->aac_irq, 320 INTR_MPSAFE|INTR_TYPE_BIO, 321 aac_fast_intr, sc, &sc->aac_intr)) { 322 device_printf(sc->aac_dev, 323 "can't set up MPSAFE interrupt\n"); 324 return (EINVAL); 325 } 326 } 327 } 328 329 /* 330 * Print a little information about the controller. 331 */ 332 aac_describe_controller(sc); 333 334 /* 335 * Register to probe our containers later. 336 */ 337 sc->aac_ich.ich_func = aac_startup; 338 sc->aac_ich.ich_arg = sc; 339 if (config_intrhook_establish(&sc->aac_ich) != 0) { 340 device_printf(sc->aac_dev, 341 "can't establish configuration hook\n"); 342 return(ENXIO); 343 } 344 345 /* 346 * Make the control device. 347 */ 348 unit = device_get_unit(sc->aac_dev); 349 sc->aac_dev_t = make_dev(&aac_cdevsw, unit, UID_ROOT, GID_OPERATOR, 350 0640, "aac%d", unit); 351 (void)make_dev_alias(sc->aac_dev_t, "afa%d", unit); 352 (void)make_dev_alias(sc->aac_dev_t, "hpn%d", unit); 353 sc->aac_dev_t->si_drv1 = sc; 354 355 /* Create the AIF thread */ 356 if (kthread_create((void(*)(void *))aac_command_thread, sc, 357 &sc->aifthread, 0, 0, "aac%daif", unit)) 358 panic("Could not create AIF thread\n"); 359 360 /* Register the shutdown method to only be called post-dump */ 361 if ((sc->eh = EVENTHANDLER_REGISTER(shutdown_final, aac_shutdown, 362 sc->aac_dev, SHUTDOWN_PRI_DEFAULT)) == NULL) 363 device_printf(sc->aac_dev, 364 "shutdown event registration failed\n"); 365 366 /* Register with CAM for the non-DASD devices */ 367 if ((sc->flags & AAC_FLAGS_ENABLE_CAM) != 0) { 368 TAILQ_INIT(&sc->aac_sim_tqh); 369 aac_get_bus_info(sc); 370 } 371 372 return(0); 373} 374 375void 376aac_add_event(struct aac_softc *sc, struct aac_event *event) 377{ 378 379 switch (event->ev_type & AAC_EVENT_MASK) { 380 case AAC_EVENT_CMFREE: 381 TAILQ_INSERT_TAIL(&sc->aac_ev_cmfree, event, ev_links); 382 break; 383 default: 384 device_printf(sc->aac_dev, "aac_add event: unknown event %d\n", 385 event->ev_type); 386 break; 387 } 388 389 return; 390} 391 392/* 393 * Probe for containers, create disks. 394 */ 395static void 396aac_startup(void *arg) 397{ 398 struct aac_softc *sc; 399 struct aac_fib *fib; 400 struct aac_mntinfo *mi; 401 struct aac_mntinforesp *mir = NULL; 402 int count = 0, i = 0; 403 404 debug_called(1); 405 406 sc = (struct aac_softc *)arg; 407 408 /* disconnect ourselves from the intrhook chain */ 409 config_intrhook_disestablish(&sc->aac_ich); 410 411 mtx_lock(&sc->aac_io_lock); 412 aac_alloc_sync_fib(sc, &fib); 413 mi = (struct aac_mntinfo *)&fib->data[0]; 414 415 /* loop over possible containers */ 416 do { 417 /* request information on this container */ 418 bzero(mi, sizeof(struct aac_mntinfo)); 419 mi->Command = VM_NameServe; 420 mi->MntType = FT_FILESYS; 421 mi->MntCount = i; 422 if (aac_sync_fib(sc, ContainerCommand, 0, fib, 423 sizeof(struct aac_mntinfo))) { 424 printf("error probing container %d", i); 425 continue; 426 } 427 428 mir = (struct aac_mntinforesp *)&fib->data[0]; 429 /* XXX Need to check if count changed */ 430 count = mir->MntRespCount; 431 aac_add_container(sc, mir, 0); 432 i++; 433 } while ((i < count) && (i < AAC_MAX_CONTAINERS)); 434 435 aac_release_sync_fib(sc); 436 mtx_unlock(&sc->aac_io_lock); 437 438 /* poke the bus to actually attach the child devices */ 439 if (bus_generic_attach(sc->aac_dev)) 440 device_printf(sc->aac_dev, "bus_generic_attach failed\n"); 441 442 /* mark the controller up */ 443 sc->aac_state &= ~AAC_STATE_SUSPEND; 444 445 /* enable interrupts now */ 446 AAC_UNMASK_INTERRUPTS(sc); 447} 448 449/* 450 * Create a device to respresent a new container 451 */ 452static void 453aac_add_container(struct aac_softc *sc, struct aac_mntinforesp *mir, int f) 454{ 455 struct aac_container *co; 456 device_t child; 457 458 /* 459 * Check container volume type for validity. Note that many of 460 * the possible types may never show up. 461 */ 462 if ((mir->Status == ST_OK) && (mir->MntTable[0].VolType != CT_NONE)) { 463 co = (struct aac_container *)malloc(sizeof *co, M_AACBUF, 464 M_NOWAIT | M_ZERO); 465 if (co == NULL) 466 panic("Out of memory?!\n"); 467 debug(1, "id %x name '%.16s' size %u type %d", 468 mir->MntTable[0].ObjectId, 469 mir->MntTable[0].FileSystemName, 470 mir->MntTable[0].Capacity, mir->MntTable[0].VolType); 471 472 if ((child = device_add_child(sc->aac_dev, "aacd", -1)) == NULL) 473 device_printf(sc->aac_dev, "device_add_child failed\n"); 474 else 475 device_set_ivars(child, co); 476 device_set_desc(child, aac_describe_code(aac_container_types, 477 mir->MntTable[0].VolType)); 478 co->co_disk = child; 479 co->co_found = f; 480 bcopy(&mir->MntTable[0], &co->co_mntobj, 481 sizeof(struct aac_mntobj)); 482 mtx_lock(&sc->aac_container_lock); 483 TAILQ_INSERT_TAIL(&sc->aac_container_tqh, co, co_link); 484 mtx_unlock(&sc->aac_container_lock); 485 } 486} 487 488/* 489 * Free all of the resources associated with (sc) 490 * 491 * Should not be called if the controller is active. 492 */ 493void 494aac_free(struct aac_softc *sc) 495{ 496 497 debug_called(1); 498 499 /* remove the control device */ 500 if (sc->aac_dev_t != NULL) 501 destroy_dev(sc->aac_dev_t); 502 503 /* throw away any FIB buffers, discard the FIB DMA tag */ 504 aac_free_commands(sc); 505 if (sc->aac_fib_dmat) 506 bus_dma_tag_destroy(sc->aac_fib_dmat); 507 508 free(sc->aac_commands, M_AACBUF); 509 510 /* destroy the common area */ 511 if (sc->aac_common) { 512 bus_dmamap_unload(sc->aac_common_dmat, sc->aac_common_dmamap); 513 bus_dmamem_free(sc->aac_common_dmat, sc->aac_common, 514 sc->aac_common_dmamap); 515 } 516 if (sc->aac_common_dmat) 517 bus_dma_tag_destroy(sc->aac_common_dmat); 518 519 /* disconnect the interrupt handler */ 520 if (sc->aac_intr) 521 bus_teardown_intr(sc->aac_dev, sc->aac_irq, sc->aac_intr); 522 if (sc->aac_irq != NULL) 523 bus_release_resource(sc->aac_dev, SYS_RES_IRQ, sc->aac_irq_rid, 524 sc->aac_irq); 525 526 /* destroy data-transfer DMA tag */ 527 if (sc->aac_buffer_dmat) 528 bus_dma_tag_destroy(sc->aac_buffer_dmat); 529 530 /* destroy the parent DMA tag */ 531 if (sc->aac_parent_dmat) 532 bus_dma_tag_destroy(sc->aac_parent_dmat); 533 534 /* release the register window mapping */ 535 if (sc->aac_regs_resource != NULL) 536 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY, 537 sc->aac_regs_rid, sc->aac_regs_resource); 538} 539 540/* 541 * Disconnect from the controller completely, in preparation for unload. 542 */ 543int 544aac_detach(device_t dev) 545{ 546 struct aac_softc *sc; 547 struct aac_container *co; 548 struct aac_sim *sim; 549 int error; 550 551 debug_called(1); 552 553 sc = device_get_softc(dev); 554 555 if (sc->aac_state & AAC_STATE_OPEN) 556 return(EBUSY); 557 558 /* Remove the child containers */ 559 while ((co = TAILQ_FIRST(&sc->aac_container_tqh)) != NULL) { 560 error = device_delete_child(dev, co->co_disk); 561 if (error) 562 return (error); 563 TAILQ_REMOVE(&sc->aac_container_tqh, co, co_link); 564 free(co, M_AACBUF); 565 } 566 567 /* Remove the CAM SIMs */ 568 while ((sim = TAILQ_FIRST(&sc->aac_sim_tqh)) != NULL) { 569 TAILQ_REMOVE(&sc->aac_sim_tqh, sim, sim_link); 570 error = device_delete_child(dev, sim->sim_dev); 571 if (error) 572 return (error); 573 free(sim, M_AACBUF); 574 } 575 576 if (sc->aifflags & AAC_AIFFLAGS_RUNNING) { 577 sc->aifflags |= AAC_AIFFLAGS_EXIT; 578 wakeup(sc->aifthread); 579 tsleep(sc->aac_dev, PUSER | PCATCH, "aacdch", 30 * hz); 580 } 581 582 if (sc->aifflags & AAC_AIFFLAGS_RUNNING) 583 panic("Cannot shutdown AIF thread\n"); 584 585 if ((error = aac_shutdown(dev))) 586 return(error); 587 588 EVENTHANDLER_DEREGISTER(shutdown_final, sc->eh); 589 590 aac_free(sc); 591 592 mtx_destroy(&sc->aac_aifq_lock); 593 mtx_destroy(&sc->aac_io_lock); 594 mtx_destroy(&sc->aac_container_lock); 595 596 return(0); 597} 598 599/* 600 * Bring the controller down to a dormant state and detach all child devices. 601 * 602 * This function is called before detach or system shutdown. 603 * 604 * Note that we can assume that the bioq on the controller is empty, as we won't 605 * allow shutdown if any device is open. 606 */ 607int 608aac_shutdown(device_t dev) 609{ 610 struct aac_softc *sc; 611 struct aac_fib *fib; 612 struct aac_close_command *cc; 613 614 debug_called(1); 615 616 sc = device_get_softc(dev); 617 618 sc->aac_state |= AAC_STATE_SUSPEND; 619 620 /* 621 * Send a Container shutdown followed by a HostShutdown FIB to the 622 * controller to convince it that we don't want to talk to it anymore. 623 * We've been closed and all I/O completed already 624 */ 625 device_printf(sc->aac_dev, "shutting down controller..."); 626 627 mtx_lock(&sc->aac_io_lock); 628 aac_alloc_sync_fib(sc, &fib); 629 cc = (struct aac_close_command *)&fib->data[0]; 630 631 bzero(cc, sizeof(struct aac_close_command)); 632 cc->Command = VM_CloseAll; 633 cc->ContainerId = 0xffffffff; 634 if (aac_sync_fib(sc, ContainerCommand, 0, fib, 635 sizeof(struct aac_close_command))) 636 printf("FAILED.\n"); 637 else 638 printf("done\n"); 639#if 0 640 else { 641 fib->data[0] = 0; 642 /* 643 * XXX Issuing this command to the controller makes it shut down 644 * but also keeps it from coming back up without a reset of the 645 * PCI bus. This is not desirable if you are just unloading the 646 * driver module with the intent to reload it later. 647 */ 648 if (aac_sync_fib(sc, FsaHostShutdown, AAC_FIBSTATE_SHUTDOWN, 649 fib, 1)) { 650 printf("FAILED.\n"); 651 } else { 652 printf("done.\n"); 653 } 654 } 655#endif 656 657 AAC_MASK_INTERRUPTS(sc); 658 aac_release_sync_fib(sc); 659 mtx_unlock(&sc->aac_io_lock); 660 661 return(0); 662} 663 664/* 665 * Bring the controller to a quiescent state, ready for system suspend. 666 */ 667int 668aac_suspend(device_t dev) 669{ 670 struct aac_softc *sc; 671 672 debug_called(1); 673 674 sc = device_get_softc(dev); 675 676 sc->aac_state |= AAC_STATE_SUSPEND; 677 678 AAC_MASK_INTERRUPTS(sc); 679 return(0); 680} 681 682/* 683 * Bring the controller back to a state ready for operation. 684 */ 685int 686aac_resume(device_t dev) 687{ 688 struct aac_softc *sc; 689 690 debug_called(1); 691 692 sc = device_get_softc(dev); 693 694 sc->aac_state &= ~AAC_STATE_SUSPEND; 695 AAC_UNMASK_INTERRUPTS(sc); 696 return(0); 697} 698 699/* 700 * Interrupt handler for NEW_COMM interface. 701 */ 702void 703aac_new_intr(void *arg) 704{ 705 struct aac_softc *sc; 706 u_int32_t index, fast; 707 struct aac_command *cm; 708 struct aac_fib *fib; 709 int i; 710 711 debug_called(2); 712 713 sc = (struct aac_softc *)arg; 714 715 mtx_lock(&sc->aac_io_lock); 716 while (1) { 717 index = AAC_GET_OUTB_QUEUE(sc); 718 if (index == 0xffffffff) 719 index = AAC_GET_OUTB_QUEUE(sc); 720 if (index == 0xffffffff) 721 break; 722 if (index & 2) { 723 if (index == 0xfffffffe) { 724 /* XXX This means that the controller wants 725 * more work. Ignore it for now. 726 */ 727 continue; 728 } 729 /* AIF */ 730 fib = (struct aac_fib *)malloc(sizeof *fib, M_AACBUF, 731 M_NOWAIT | M_ZERO); 732 if (fib == NULL) { 733 /* If we're really this short on memory, 734 * hopefully breaking out of the handler will 735 * allow something to get freed. This 736 * actually sucks a whole lot. 737 */ 738 break; 739 } 740 index &= ~2; 741 for (i = 0; i < sizeof(struct aac_fib)/4; ++i) 742 ((u_int32_t *)fib)[i] = AAC_GETREG4(sc, index + i*4); 743 aac_handle_aif(sc, fib); 744 free(fib, M_AACBUF); 745 746 /* 747 * AIF memory is owned by the adapter, so let it 748 * know that we are done with it. 749 */ 750 AAC_SET_OUTB_QUEUE(sc, index); 751 AAC_CLEAR_ISTATUS(sc, AAC_DB_RESPONSE_READY); 752 } else { 753 fast = index & 1; 754 cm = sc->aac_commands + (index >> 2); 755 fib = cm->cm_fib; 756 if (fast) { 757 fib->Header.XferState |= AAC_FIBSTATE_DONEADAP; 758 *((u_int32_t *)(fib->data)) = AAC_ERROR_NORMAL; 759 } 760 aac_remove_busy(cm); 761 aac_unmap_command(cm); 762 cm->cm_flags |= AAC_CMD_COMPLETED; 763 764 /* is there a completion handler? */ 765 if (cm->cm_complete != NULL) { 766 cm->cm_complete(cm); 767 } else { 768 /* assume that someone is sleeping on this 769 * command 770 */ 771 wakeup(cm); 772 } 773 sc->flags &= ~AAC_QUEUE_FRZN; 774 } 775 } 776 /* see if we can start some more I/O */ 777 if ((sc->flags & AAC_QUEUE_FRZN) == 0) 778 aac_startio(sc); 779 780 mtx_unlock(&sc->aac_io_lock); 781} 782 783void 784aac_fast_intr(void *arg) 785{ 786 struct aac_softc *sc; 787 u_int16_t reason; 788 789 debug_called(2); 790 791 sc = (struct aac_softc *)arg; 792 793 /* 794 * Read the status register directly. This is faster than taking the 795 * driver lock and reading the queues directly. It also saves having 796 * to turn parts of the driver lock into a spin mutex, which would be 797 * ugly. 798 */ 799 reason = AAC_GET_ISTATUS(sc); 800 AAC_CLEAR_ISTATUS(sc, reason); 801 802 /* handle completion processing */ 803 if (reason & AAC_DB_RESPONSE_READY) 804 taskqueue_enqueue_fast(taskqueue_fast, &sc->aac_task_complete); 805 806 /* controller wants to talk to us */ 807 if (reason & (AAC_DB_PRINTF | AAC_DB_COMMAND_READY)) { 808 /* 809 * XXX Make sure that we don't get fooled by strange messages 810 * that start with a NULL. 811 */ 812 if ((reason & AAC_DB_PRINTF) && 813 (sc->aac_common->ac_printf[0] == 0)) 814 sc->aac_common->ac_printf[0] = 32; 815 816 /* 817 * This might miss doing the actual wakeup. However, the 818 * msleep that this is waking up has a timeout, so it will 819 * wake up eventually. AIFs and printfs are low enough 820 * priority that they can handle hanging out for a few seconds 821 * if needed. 822 */ 823 wakeup(sc->aifthread); 824 } 825} 826 827/* 828 * Command Processing 829 */ 830 831/* 832 * Start as much queued I/O as possible on the controller 833 */ 834void 835aac_startio(struct aac_softc *sc) 836{ 837 struct aac_command *cm; 838 int error; 839 840 debug_called(2); 841 842 for (;;) { 843 /* 844 * This flag might be set if the card is out of resources. 845 * Checking it here prevents an infinite loop of deferrals. 846 */ 847 if (sc->flags & AAC_QUEUE_FRZN) 848 break; 849 850 /* 851 * Try to get a command that's been put off for lack of 852 * resources 853 */ 854 cm = aac_dequeue_ready(sc); 855 856 /* 857 * Try to build a command off the bio queue (ignore error 858 * return) 859 */ 860 if (cm == NULL) 861 aac_bio_command(sc, &cm); 862 863 /* nothing to do? */ 864 if (cm == NULL) 865 break; 866 867 /* don't map more than once */ 868 if (cm->cm_flags & AAC_CMD_MAPPED) 869 panic("aac: command %p already mapped", cm); 870 871 /* 872 * Set up the command to go to the controller. If there are no 873 * data buffers associated with the command then it can bypass 874 * busdma. 875 */ 876 if (cm->cm_datalen != 0) { 877 error = bus_dmamap_load(sc->aac_buffer_dmat, 878 cm->cm_datamap, cm->cm_data, 879 cm->cm_datalen, 880 aac_map_command_sg, cm, 0); 881 if (error == EINPROGRESS) { 882 debug(1, "freezing queue\n"); 883 sc->flags |= AAC_QUEUE_FRZN; 884 error = 0; 885 } else if (error != 0) 886 panic("aac_startio: unexpected error %d from " 887 "busdma\n", error); 888 } else 889 aac_map_command_sg(cm, NULL, 0, 0); 890 } 891} 892 893/* 894 * Handle notification of one or more FIBs coming from the controller. 895 */ 896static void 897aac_command_thread(struct aac_softc *sc) 898{ 899 struct aac_fib *fib; 900 u_int32_t fib_size; 901 int size, retval; 902 903 debug_called(2); 904 905 mtx_lock(&sc->aac_io_lock); 906 sc->aifflags = AAC_AIFFLAGS_RUNNING; 907 908 while ((sc->aifflags & AAC_AIFFLAGS_EXIT) == 0) { 909 910 retval = 0; 911 if ((sc->aifflags & AAC_AIFFLAGS_PENDING) == 0) 912 retval = msleep(sc->aifthread, &sc->aac_io_lock, PRIBIO, 913 "aifthd", AAC_PERIODIC_INTERVAL * hz); 914 915 /* 916 * First see if any FIBs need to be allocated. This needs 917 * to be called without the driver lock because contigmalloc 918 * will grab Giant, and would result in an LOR. 919 */ 920 if ((sc->aifflags & AAC_AIFFLAGS_ALLOCFIBS) != 0) { 921 mtx_unlock(&sc->aac_io_lock); 922 aac_alloc_commands(sc); 923 mtx_lock(&sc->aac_io_lock); 924 sc->aifflags &= ~AAC_AIFFLAGS_ALLOCFIBS; 925 aac_startio(sc); 926 } 927 928 /* 929 * While we're here, check to see if any commands are stuck. 930 * This is pretty low-priority, so it's ok if it doesn't 931 * always fire. 932 */ 933 if (retval == EWOULDBLOCK) 934 aac_timeout(sc); 935 936 /* Check the hardware printf message buffer */ 937 if (sc->aac_common->ac_printf[0] != 0) 938 aac_print_printf(sc); 939 940 /* Also check to see if the adapter has a command for us. */ 941 if (sc->flags & AAC_FLAGS_NEW_COMM) 942 continue; 943 for (;;) { 944 if (aac_dequeue_fib(sc, AAC_HOST_NORM_CMD_QUEUE, 945 &fib_size, &fib)) 946 break; 947 948 AAC_PRINT_FIB(sc, fib); 949 950 switch (fib->Header.Command) { 951 case AifRequest: 952 aac_handle_aif(sc, fib); 953 break; 954 default: 955 device_printf(sc->aac_dev, "unknown command " 956 "from controller\n"); 957 break; 958 } 959 960 if ((fib->Header.XferState == 0) || 961 (fib->Header.StructType != AAC_FIBTYPE_TFIB)) { 962 break; 963 } 964 965 /* Return the AIF to the controller. */ 966 if (fib->Header.XferState & AAC_FIBSTATE_FROMADAP) { 967 fib->Header.XferState |= AAC_FIBSTATE_DONEHOST; 968 *(AAC_FSAStatus*)fib->data = ST_OK; 969 970 /* XXX Compute the Size field? */ 971 size = fib->Header.Size; 972 if (size > sizeof(struct aac_fib)) { 973 size = sizeof(struct aac_fib); 974 fib->Header.Size = size; 975 } 976 /* 977 * Since we did not generate this command, it 978 * cannot go through the normal 979 * enqueue->startio chain. 980 */ 981 aac_enqueue_response(sc, 982 AAC_ADAP_NORM_RESP_QUEUE, 983 fib); 984 } 985 } 986 } 987 sc->aifflags &= ~AAC_AIFFLAGS_RUNNING; 988 mtx_unlock(&sc->aac_io_lock); 989 wakeup(sc->aac_dev); 990 991 kthread_exit(0); 992} 993 994/* 995 * Process completed commands. 996 */ 997static void 998aac_complete(void *context, int pending) 999{ 1000 struct aac_softc *sc; 1001 struct aac_command *cm; 1002 struct aac_fib *fib; 1003 u_int32_t fib_size; 1004 1005 debug_called(2); 1006 1007 sc = (struct aac_softc *)context; 1008 1009 mtx_lock(&sc->aac_io_lock); 1010 1011 /* pull completed commands off the queue */ 1012 for (;;) { 1013 /* look for completed FIBs on our queue */ 1014 if (aac_dequeue_fib(sc, AAC_HOST_NORM_RESP_QUEUE, &fib_size, 1015 &fib)) 1016 break; /* nothing to do */ 1017 1018 /* get the command, unmap and hand off for processing */ 1019 cm = sc->aac_commands + fib->Header.SenderData; 1020 if (cm == NULL) { 1021 AAC_PRINT_FIB(sc, fib); 1022 break; 1023 } 1024 aac_remove_busy(cm); 1025 1026 aac_unmap_command(cm); 1027 cm->cm_flags |= AAC_CMD_COMPLETED; 1028 1029 /* is there a completion handler? */ 1030 if (cm->cm_complete != NULL) { 1031 cm->cm_complete(cm); 1032 } else { 1033 /* assume that someone is sleeping on this command */ 1034 wakeup(cm); 1035 } 1036 } 1037 1038 /* see if we can start some more I/O */ 1039 sc->flags &= ~AAC_QUEUE_FRZN; 1040 aac_startio(sc); 1041 1042 mtx_unlock(&sc->aac_io_lock); 1043} 1044 1045/* 1046 * Handle a bio submitted from a disk device. 1047 */ 1048void 1049aac_submit_bio(struct bio *bp) 1050{ 1051 struct aac_disk *ad; 1052 struct aac_softc *sc; 1053 1054 debug_called(2); 1055 1056 ad = (struct aac_disk *)bp->bio_disk->d_drv1; 1057 sc = ad->ad_controller; 1058 1059 /* queue the BIO and try to get some work done */ 1060 aac_enqueue_bio(sc, bp); 1061 aac_startio(sc); 1062} 1063 1064/* 1065 * Get a bio and build a command to go with it. 1066 */ 1067static int 1068aac_bio_command(struct aac_softc *sc, struct aac_command **cmp) 1069{ 1070 struct aac_command *cm; 1071 struct aac_fib *fib; 1072 struct aac_disk *ad; 1073 struct bio *bp; 1074 1075 debug_called(2); 1076 1077 /* get the resources we will need */ 1078 cm = NULL; 1079 bp = NULL; 1080 if (aac_alloc_command(sc, &cm)) /* get a command */ 1081 goto fail; 1082 if ((bp = aac_dequeue_bio(sc)) == NULL) 1083 goto fail; 1084 1085 /* fill out the command */ 1086 cm->cm_data = (void *)bp->bio_data; 1087 cm->cm_datalen = bp->bio_bcount; 1088 cm->cm_complete = aac_bio_complete; 1089 cm->cm_private = bp; 1090 cm->cm_timestamp = time_uptime; 1091 cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE; 1092 1093 /* build the FIB */ 1094 fib = cm->cm_fib; 1095 fib->Header.Size = sizeof(struct aac_fib_header); 1096 fib->Header.XferState = 1097 AAC_FIBSTATE_HOSTOWNED | 1098 AAC_FIBSTATE_INITIALISED | 1099 AAC_FIBSTATE_EMPTY | 1100 AAC_FIBSTATE_FROMHOST | 1101 AAC_FIBSTATE_REXPECTED | 1102 AAC_FIBSTATE_NORM | 1103 AAC_FIBSTATE_ASYNC | 1104 AAC_FIBSTATE_FAST_RESPONSE; 1105 1106 /* build the read/write request */ 1107 ad = (struct aac_disk *)bp->bio_disk->d_drv1; 1108 1109 if (sc->flags & AAC_FLAGS_RAW_IO) { 1110 struct aac_raw_io *raw; 1111 raw = (struct aac_raw_io *)&fib->data[0]; 1112 fib->Header.Command = RawIo; 1113 raw->BlockNumber = (u_int64_t)bp->bio_pblkno; 1114 raw->ByteCount = bp->bio_bcount; 1115 raw->ContainerId = ad->ad_container->co_mntobj.ObjectId; 1116 raw->BpTotal = 0; 1117 raw->BpComplete = 0; 1118 fib->Header.Size += sizeof(struct aac_raw_io); 1119 cm->cm_sgtable = (struct aac_sg_table *)&raw->SgMapRaw; 1120 if (bp->bio_cmd == BIO_READ) { 1121 raw->Flags = 1; 1122 cm->cm_flags |= AAC_CMD_DATAIN; 1123 } else { 1124 raw->Flags = 0; 1125 cm->cm_flags |= AAC_CMD_DATAOUT; 1126 } 1127 } else if ((sc->flags & AAC_FLAGS_SG_64BIT) == 0) { 1128 fib->Header.Command = ContainerCommand; 1129 if (bp->bio_cmd == BIO_READ) { 1130 struct aac_blockread *br; 1131 br = (struct aac_blockread *)&fib->data[0]; 1132 br->Command = VM_CtBlockRead; 1133 br->ContainerId = ad->ad_container->co_mntobj.ObjectId; 1134 br->BlockNumber = bp->bio_pblkno; 1135 br->ByteCount = bp->bio_bcount; 1136 fib->Header.Size += sizeof(struct aac_blockread); 1137 cm->cm_sgtable = &br->SgMap; 1138 cm->cm_flags |= AAC_CMD_DATAIN; 1139 } else { 1140 struct aac_blockwrite *bw; 1141 bw = (struct aac_blockwrite *)&fib->data[0]; 1142 bw->Command = VM_CtBlockWrite; 1143 bw->ContainerId = ad->ad_container->co_mntobj.ObjectId; 1144 bw->BlockNumber = bp->bio_pblkno; 1145 bw->ByteCount = bp->bio_bcount; 1146 bw->Stable = CUNSTABLE; 1147 fib->Header.Size += sizeof(struct aac_blockwrite); 1148 cm->cm_flags |= AAC_CMD_DATAOUT; 1149 cm->cm_sgtable = &bw->SgMap; 1150 } 1151 } else { 1152 fib->Header.Command = ContainerCommand64; 1153 if (bp->bio_cmd == BIO_READ) { 1154 struct aac_blockread64 *br; 1155 br = (struct aac_blockread64 *)&fib->data[0]; 1156 br->Command = VM_CtHostRead64; 1157 br->ContainerId = ad->ad_container->co_mntobj.ObjectId; 1158 br->SectorCount = bp->bio_bcount / AAC_BLOCK_SIZE; 1159 br->BlockNumber = bp->bio_pblkno; 1160 br->Pad = 0; 1161 br->Flags = 0; 1162 fib->Header.Size += sizeof(struct aac_blockread64); 1163 cm->cm_flags |= AAC_CMD_DATAOUT; 1164 cm->cm_sgtable = (struct aac_sg_table *)&br->SgMap64; 1165 } else { 1166 struct aac_blockwrite64 *bw; 1167 bw = (struct aac_blockwrite64 *)&fib->data[0]; 1168 bw->Command = VM_CtHostWrite64; 1169 bw->ContainerId = ad->ad_container->co_mntobj.ObjectId; 1170 bw->SectorCount = bp->bio_bcount / AAC_BLOCK_SIZE; 1171 bw->BlockNumber = bp->bio_pblkno; 1172 bw->Pad = 0; 1173 bw->Flags = 0; 1174 fib->Header.Size += sizeof(struct aac_blockwrite64); 1175 cm->cm_flags |= AAC_CMD_DATAIN; 1176 cm->cm_sgtable = (struct aac_sg_table *)&bw->SgMap64; 1177 } 1178 } 1179 1180 *cmp = cm; 1181 return(0); 1182 1183fail: 1184 if (bp != NULL) 1185 aac_enqueue_bio(sc, bp); 1186 if (cm != NULL) 1187 aac_release_command(cm); 1188 return(ENOMEM); 1189} 1190 1191/* 1192 * Handle a bio-instigated command that has been completed. 1193 */ 1194static void 1195aac_bio_complete(struct aac_command *cm) 1196{ 1197 struct aac_blockread_response *brr; 1198 struct aac_blockwrite_response *bwr; 1199 struct bio *bp; 1200 AAC_FSAStatus status; 1201 1202 /* fetch relevant status and then release the command */ 1203 bp = (struct bio *)cm->cm_private; 1204 if (bp->bio_cmd == BIO_READ) { 1205 brr = (struct aac_blockread_response *)&cm->cm_fib->data[0]; 1206 status = brr->Status; 1207 } else { 1208 bwr = (struct aac_blockwrite_response *)&cm->cm_fib->data[0]; 1209 status = bwr->Status; 1210 } 1211 aac_release_command(cm); 1212 1213 /* fix up the bio based on status */ 1214 if (status == ST_OK) { 1215 bp->bio_resid = 0; 1216 } else { 1217 bp->bio_error = EIO; 1218 bp->bio_flags |= BIO_ERROR; 1219 /* pass an error string out to the disk layer */ 1220 bp->bio_driver1 = aac_describe_code(aac_command_status_table, 1221 status); 1222 } 1223 aac_biodone(bp); 1224} 1225 1226/* 1227 * Submit a command to the controller, return when it completes. 1228 * XXX This is very dangerous! If the card has gone out to lunch, we could 1229 * be stuck here forever. At the same time, signals are not caught 1230 * because there is a risk that a signal could wakeup the sleep before 1231 * the card has a chance to complete the command. Since there is no way 1232 * to cancel a command that is in progress, we can't protect against the 1233 * card completing a command late and spamming the command and data 1234 * memory. So, we are held hostage until the command completes. 1235 */ 1236static int 1237aac_wait_command(struct aac_command *cm) 1238{ 1239 struct aac_softc *sc; 1240 int error; 1241 1242 debug_called(2); 1243 1244 sc = cm->cm_sc; 1245 1246 /* Put the command on the ready queue and get things going */ 1247 cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE; 1248 aac_enqueue_ready(cm); 1249 aac_startio(sc); 1250 error = msleep(cm, &sc->aac_io_lock, PRIBIO, "aacwait", 0); 1251 return(error); 1252} 1253 1254/* 1255 *Command Buffer Management 1256 */ 1257 1258/* 1259 * Allocate a command. 1260 */ 1261int 1262aac_alloc_command(struct aac_softc *sc, struct aac_command **cmp) 1263{ 1264 struct aac_command *cm; 1265 1266 debug_called(3); 1267 1268 if ((cm = aac_dequeue_free(sc)) == NULL) { 1269 if (sc->total_fibs < sc->aac_max_fibs) { 1270 sc->aifflags |= AAC_AIFFLAGS_ALLOCFIBS; 1271 wakeup(sc->aifthread); 1272 } 1273 return (EBUSY); 1274 } 1275 1276 *cmp = cm; 1277 return(0); 1278} 1279 1280/* 1281 * Release a command back to the freelist. 1282 */ 1283void 1284aac_release_command(struct aac_command *cm) 1285{ 1286 struct aac_event *event; 1287 struct aac_softc *sc; 1288 1289 debug_called(3); 1290 1291 /* (re)initialise the command/FIB */ 1292 cm->cm_sgtable = NULL; 1293 cm->cm_flags = 0; 1294 cm->cm_complete = NULL; 1295 cm->cm_private = NULL; 1296 cm->cm_fib->Header.XferState = AAC_FIBSTATE_EMPTY; 1297 cm->cm_fib->Header.StructType = AAC_FIBTYPE_TFIB; 1298 cm->cm_fib->Header.Flags = 0; 1299 cm->cm_fib->Header.SenderSize = cm->cm_sc->aac_max_fib_size; 1300 1301 /* 1302 * These are duplicated in aac_start to cover the case where an 1303 * intermediate stage may have destroyed them. They're left 1304 * initialised here for debugging purposes only. 1305 */ 1306 cm->cm_fib->Header.ReceiverFibAddress = (u_int32_t)cm->cm_fibphys; 1307 cm->cm_fib->Header.SenderData = 0; 1308 1309 aac_enqueue_free(cm); 1310 1311 sc = cm->cm_sc; 1312 event = TAILQ_FIRST(&sc->aac_ev_cmfree); 1313 if (event != NULL) { 1314 TAILQ_REMOVE(&sc->aac_ev_cmfree, event, ev_links); 1315 event->ev_callback(sc, event, event->ev_arg); 1316 } 1317} 1318 1319/* 1320 * Map helper for command/FIB allocation. 1321 */ 1322static void 1323aac_map_command_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error) 1324{ 1325 uint64_t *fibphys; 1326 1327 fibphys = (uint64_t *)arg; 1328 1329 debug_called(3); 1330 1331 *fibphys = segs[0].ds_addr; 1332} 1333 1334/* 1335 * Allocate and initialise commands/FIBs for this adapter. 1336 */ 1337static int 1338aac_alloc_commands(struct aac_softc *sc) 1339{ 1340 struct aac_command *cm; 1341 struct aac_fibmap *fm; 1342 uint64_t fibphys; 1343 int i, error; 1344 1345 debug_called(2); 1346 1347 if (sc->total_fibs + sc->aac_max_fibs_alloc > sc->aac_max_fibs) 1348 return (ENOMEM); 1349 1350 fm = malloc(sizeof(struct aac_fibmap), M_AACBUF, M_NOWAIT|M_ZERO); 1351 if (fm == NULL) 1352 return (ENOMEM); 1353 1354 /* allocate the FIBs in DMAable memory and load them */ 1355 if (bus_dmamem_alloc(sc->aac_fib_dmat, (void **)&fm->aac_fibs, 1356 BUS_DMA_NOWAIT, &fm->aac_fibmap)) { 1357 device_printf(sc->aac_dev, 1358 "Not enough contiguous memory available.\n"); 1359 free(fm, M_AACBUF); 1360 return (ENOMEM); 1361 } 1362 1363 /* Ignore errors since this doesn't bounce */ 1364 (void)bus_dmamap_load(sc->aac_fib_dmat, fm->aac_fibmap, fm->aac_fibs, 1365 sc->aac_max_fibs_alloc * sc->aac_max_fib_size, 1366 aac_map_command_helper, &fibphys, 0); 1367 1368 /* initialise constant fields in the command structure */ 1369 bzero(fm->aac_fibs, sc->aac_max_fibs_alloc * sc->aac_max_fib_size); 1370 for (i = 0; i < sc->aac_max_fibs_alloc; i++) { 1371 cm = sc->aac_commands + sc->total_fibs; 1372 fm->aac_commands = cm; 1373 cm->cm_sc = sc; 1374 cm->cm_fib = (struct aac_fib *) 1375 ((u_int8_t *)fm->aac_fibs + i*sc->aac_max_fib_size); 1376 cm->cm_fibphys = fibphys + i*sc->aac_max_fib_size; 1377 cm->cm_index = sc->total_fibs; 1378 1379 if ((error = bus_dmamap_create(sc->aac_buffer_dmat, 0, 1380 &cm->cm_datamap)) != 0) 1381 break; 1382 mtx_lock(&sc->aac_io_lock); 1383 aac_release_command(cm); 1384 sc->total_fibs++; 1385 mtx_unlock(&sc->aac_io_lock); 1386 } 1387 1388 if (i > 0) { 1389 mtx_lock(&sc->aac_io_lock); 1390 TAILQ_INSERT_TAIL(&sc->aac_fibmap_tqh, fm, fm_link); 1391 debug(1, "total_fibs= %d\n", sc->total_fibs); 1392 mtx_unlock(&sc->aac_io_lock); 1393 return (0); 1394 } 1395 1396 bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap); 1397 bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap); 1398 free(fm, M_AACBUF); 1399 return (ENOMEM); 1400} 1401 1402/* 1403 * Free FIBs owned by this adapter. 1404 */ 1405static void 1406aac_free_commands(struct aac_softc *sc) 1407{ 1408 struct aac_fibmap *fm; 1409 struct aac_command *cm; 1410 int i; 1411 1412 debug_called(1); 1413 1414 while ((fm = TAILQ_FIRST(&sc->aac_fibmap_tqh)) != NULL) { 1415 1416 TAILQ_REMOVE(&sc->aac_fibmap_tqh, fm, fm_link); 1417 /* 1418 * We check against total_fibs to handle partially 1419 * allocated blocks. 1420 */ 1421 for (i = 0; i < sc->aac_max_fibs_alloc && sc->total_fibs--; i++) { 1422 cm = fm->aac_commands + i; 1423 bus_dmamap_destroy(sc->aac_buffer_dmat, cm->cm_datamap); 1424 } 1425 bus_dmamap_unload(sc->aac_fib_dmat, fm->aac_fibmap); 1426 bus_dmamem_free(sc->aac_fib_dmat, fm->aac_fibs, fm->aac_fibmap); 1427 free(fm, M_AACBUF); 1428 } 1429} 1430 1431/* 1432 * Command-mapping helper function - populate this command's s/g table. 1433 */ 1434static void 1435aac_map_command_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error) 1436{ 1437 struct aac_softc *sc; 1438 struct aac_command *cm; 1439 struct aac_fib *fib; 1440 int i; 1441 1442 debug_called(3); 1443 1444 cm = (struct aac_command *)arg; 1445 sc = cm->cm_sc; 1446 fib = cm->cm_fib; 1447 1448 /* copy into the FIB */ 1449 if (cm->cm_sgtable != NULL) { 1450 if (fib->Header.Command == RawIo) { 1451 struct aac_sg_tableraw *sg; 1452 sg = (struct aac_sg_tableraw *)cm->cm_sgtable; 1453 sg->SgCount = nseg; 1454 for (i = 0; i < nseg; i++) { 1455 sg->SgEntryRaw[i].SgAddress = segs[i].ds_addr; 1456 sg->SgEntryRaw[i].SgByteCount = segs[i].ds_len; 1457 sg->SgEntryRaw[i].Next = 0; 1458 sg->SgEntryRaw[i].Prev = 0; 1459 sg->SgEntryRaw[i].Flags = 0; 1460 } 1461 /* update the FIB size for the s/g count */ 1462 fib->Header.Size += nseg*sizeof(struct aac_sg_entryraw); 1463 } else if ((cm->cm_sc->flags & AAC_FLAGS_SG_64BIT) == 0) { 1464 struct aac_sg_table *sg; 1465 sg = cm->cm_sgtable; 1466 sg->SgCount = nseg; 1467 for (i = 0; i < nseg; i++) { 1468 sg->SgEntry[i].SgAddress = segs[i].ds_addr; 1469 sg->SgEntry[i].SgByteCount = segs[i].ds_len; 1470 } 1471 /* update the FIB size for the s/g count */ 1472 fib->Header.Size += nseg*sizeof(struct aac_sg_entry); 1473 } else { 1474 struct aac_sg_table64 *sg; 1475 sg = (struct aac_sg_table64 *)cm->cm_sgtable; 1476 sg->SgCount = nseg; 1477 for (i = 0; i < nseg; i++) { 1478 sg->SgEntry64[i].SgAddress = segs[i].ds_addr; 1479 sg->SgEntry64[i].SgByteCount = segs[i].ds_len; 1480 } 1481 /* update the FIB size for the s/g count */ 1482 fib->Header.Size += nseg*sizeof(struct aac_sg_entry64); 1483 } 1484 } 1485 1486 /* Fix up the address values in the FIB. Use the command array index 1487 * instead of a pointer since these fields are only 32 bits. Shift 1488 * the SenderFibAddress over to make room for the fast response bit 1489 * and for the AIF bit 1490 */ 1491 cm->cm_fib->Header.SenderFibAddress = (cm->cm_index << 2); 1492 cm->cm_fib->Header.ReceiverFibAddress = (u_int32_t)cm->cm_fibphys; 1493 1494 /* save a pointer to the command for speedy reverse-lookup */ 1495 cm->cm_fib->Header.SenderData = cm->cm_index; 1496 1497 if (cm->cm_flags & AAC_CMD_DATAIN) 1498 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap, 1499 BUS_DMASYNC_PREREAD); 1500 if (cm->cm_flags & AAC_CMD_DATAOUT) 1501 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap, 1502 BUS_DMASYNC_PREWRITE); 1503 cm->cm_flags |= AAC_CMD_MAPPED; 1504 1505 if (sc->flags & AAC_FLAGS_NEW_COMM) { 1506 int count = 10000000L; 1507 while (AAC_SEND_COMMAND(sc, cm) != 0) { 1508 if (--count == 0) { 1509 aac_unmap_command(cm); 1510 sc->flags |= AAC_QUEUE_FRZN; 1511 aac_requeue_ready(cm); 1512 } 1513 DELAY(5); /* wait 5 usec. */ 1514 } 1515 } else { 1516 /* Put the FIB on the outbound queue */ 1517 if (aac_enqueue_fib(sc, cm->cm_queue, cm) == EBUSY) { 1518 aac_unmap_command(cm); 1519 sc->flags |= AAC_QUEUE_FRZN; 1520 aac_requeue_ready(cm); 1521 } 1522 } 1523 1524 return; 1525} 1526 1527/* 1528 * Unmap a command from controller-visible space. 1529 */ 1530static void 1531aac_unmap_command(struct aac_command *cm) 1532{ 1533 struct aac_softc *sc; 1534 1535 debug_called(2); 1536 1537 sc = cm->cm_sc; 1538 1539 if (!(cm->cm_flags & AAC_CMD_MAPPED)) 1540 return; 1541 1542 if (cm->cm_datalen != 0) { 1543 if (cm->cm_flags & AAC_CMD_DATAIN) 1544 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap, 1545 BUS_DMASYNC_POSTREAD); 1546 if (cm->cm_flags & AAC_CMD_DATAOUT) 1547 bus_dmamap_sync(sc->aac_buffer_dmat, cm->cm_datamap, 1548 BUS_DMASYNC_POSTWRITE); 1549 1550 bus_dmamap_unload(sc->aac_buffer_dmat, cm->cm_datamap); 1551 } 1552 cm->cm_flags &= ~AAC_CMD_MAPPED; 1553} 1554 1555/* 1556 * Hardware Interface 1557 */ 1558 1559/* 1560 * Initialise the adapter. 1561 */ 1562static void 1563aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg, int error) 1564{ 1565 struct aac_softc *sc; 1566 1567 debug_called(1); 1568 1569 sc = (struct aac_softc *)arg; 1570 1571 sc->aac_common_busaddr = segs[0].ds_addr; 1572} 1573 1574static int 1575aac_check_firmware(struct aac_softc *sc) 1576{ 1577 u_int32_t major, minor, options = 0, atu_size = 0; 1578 int status; 1579 1580 debug_called(1); 1581 1582 /* 1583 * Retrieve the firmware version numbers. Dell PERC2/QC cards with 1584 * firmware version 1.x are not compatible with this driver. 1585 */ 1586 if (sc->flags & AAC_FLAGS_PERC2QC) { 1587 if (aac_sync_command(sc, AAC_MONKER_GETKERNVER, 0, 0, 0, 0, 1588 NULL)) { 1589 device_printf(sc->aac_dev, 1590 "Error reading firmware version\n"); 1591 return (EIO); 1592 } 1593 1594 /* These numbers are stored as ASCII! */ 1595 major = (AAC_GET_MAILBOX(sc, 1) & 0xff) - 0x30; 1596 minor = (AAC_GET_MAILBOX(sc, 2) & 0xff) - 0x30; 1597 if (major == 1) { 1598 device_printf(sc->aac_dev, 1599 "Firmware version %d.%d is not supported.\n", 1600 major, minor); 1601 return (EINVAL); 1602 } 1603 } 1604 1605 /* 1606 * Retrieve the capabilities/supported options word so we know what 1607 * work-arounds to enable. Some firmware revs don't support this 1608 * command. 1609 */ 1610 if (aac_sync_command(sc, AAC_MONKER_GETINFO, 0, 0, 0, 0, &status)) { 1611 if (status != AAC_SRB_STS_INVALID_REQUEST) { 1612 device_printf(sc->aac_dev, 1613 "RequestAdapterInfo failed\n"); 1614 return (EIO); 1615 } 1616 } else { 1617 options = AAC_GET_MAILBOX(sc, 1); 1618 atu_size = AAC_GET_MAILBOX(sc, 2); 1619 sc->supported_options = options; 1620 1621 if ((options & AAC_SUPPORTED_4GB_WINDOW) != 0 && 1622 (sc->flags & AAC_FLAGS_NO4GB) == 0) 1623 sc->flags |= AAC_FLAGS_4GB_WINDOW; 1624 if (options & AAC_SUPPORTED_NONDASD) 1625 sc->flags |= AAC_FLAGS_ENABLE_CAM; 1626 if ((options & AAC_SUPPORTED_SGMAP_HOST64) != 0 1627 && (sizeof(bus_addr_t) > 4)) { 1628 device_printf(sc->aac_dev, 1629 "Enabling 64-bit address support\n"); 1630 sc->flags |= AAC_FLAGS_SG_64BIT; 1631 } 1632 if ((options & AAC_SUPPORTED_NEW_COMM) 1633 && sc->aac_if.aif_send_command) 1634 sc->flags |= AAC_FLAGS_NEW_COMM; 1635 if (options & AAC_SUPPORTED_64BIT_ARRAYSIZE) 1636 sc->flags |= AAC_FLAGS_ARRAY_64BIT; 1637 } 1638 1639 /* Check for broken hardware that does a lower number of commands */ 1640 sc->aac_max_fibs = (sc->flags & AAC_FLAGS_256FIBS ? 256:512); 1641 1642 /* Remap mem. resource, if required */ 1643 if ((sc->flags & AAC_FLAGS_NEW_COMM) && 1644 atu_size > rman_get_size(sc->aac_regs_resource)) { 1645 bus_release_resource( 1646 sc->aac_dev, SYS_RES_MEMORY, 1647 sc->aac_regs_rid, sc->aac_regs_resource); 1648 sc->aac_regs_resource = bus_alloc_resource( 1649 sc->aac_dev, SYS_RES_MEMORY, &sc->aac_regs_rid, 1650 0ul, ~0ul, atu_size, RF_ACTIVE); 1651 if (sc->aac_regs_resource == NULL) { 1652 sc->aac_regs_resource = bus_alloc_resource_any( 1653 sc->aac_dev, SYS_RES_MEMORY, 1654 &sc->aac_regs_rid, RF_ACTIVE); 1655 if (sc->aac_regs_resource == NULL) { 1656 device_printf(sc->aac_dev, 1657 "couldn't allocate register window\n"); 1658 return (ENXIO); 1659 } 1660 sc->flags &= ~AAC_FLAGS_NEW_COMM; 1661 } 1662 sc->aac_btag = rman_get_bustag(sc->aac_regs_resource); 1663 sc->aac_bhandle = rman_get_bushandle(sc->aac_regs_resource); 1664 } 1665 1666 /* Read preferred settings */ 1667 sc->aac_max_fib_size = sizeof(struct aac_fib); 1668 sc->aac_max_sectors = 128; /* 64KB */ 1669 if (sc->flags & AAC_FLAGS_SG_64BIT) 1670 sc->aac_sg_tablesize = (AAC_FIB_DATASIZE 1671 - sizeof(struct aac_blockwrite64) 1672 + sizeof(struct aac_sg_table64)) 1673 / sizeof(struct aac_sg_table64); 1674 else 1675 sc->aac_sg_tablesize = (AAC_FIB_DATASIZE 1676 - sizeof(struct aac_blockwrite) 1677 + sizeof(struct aac_sg_table)) 1678 / sizeof(struct aac_sg_table); 1679 1680 if (!aac_sync_command(sc, AAC_MONKER_GETCOMMPREF, 0, 0, 0, 0, NULL)) { 1681 options = AAC_GET_MAILBOX(sc, 1); 1682 sc->aac_max_fib_size = (options & 0xFFFF); 1683 sc->aac_max_sectors = (options >> 16) << 1; 1684 options = AAC_GET_MAILBOX(sc, 2); 1685 sc->aac_sg_tablesize = (options >> 16); 1686 options = AAC_GET_MAILBOX(sc, 3); 1687 sc->aac_max_fibs = (options & 0xFFFF); 1688 } 1689 if (sc->aac_max_fib_size > PAGE_SIZE) 1690 sc->aac_max_fib_size = PAGE_SIZE; 1691 sc->aac_max_fibs_alloc = PAGE_SIZE / sc->aac_max_fib_size; 1692 1693 return (0); 1694} 1695 1696static int 1697aac_init(struct aac_softc *sc) 1698{ 1699 struct aac_adapter_init *ip; 1700 time_t then; 1701 u_int32_t code, qoffset; 1702 int error; 1703 1704 debug_called(1); 1705 1706 /* 1707 * First wait for the adapter to come ready. 1708 */ 1709 then = time_uptime; 1710 do { 1711 code = AAC_GET_FWSTATUS(sc); 1712 if (code & AAC_SELF_TEST_FAILED) { 1713 device_printf(sc->aac_dev, "FATAL: selftest failed\n"); 1714 return(ENXIO); 1715 } 1716 if (code & AAC_KERNEL_PANIC) { 1717 device_printf(sc->aac_dev, 1718 "FATAL: controller kernel panic\n"); 1719 return(ENXIO); 1720 } 1721 if (time_uptime > (then + AAC_BOOT_TIMEOUT)) { 1722 device_printf(sc->aac_dev, 1723 "FATAL: controller not coming ready, " 1724 "status %x\n", code); 1725 return(ENXIO); 1726 } 1727 } while (!(code & AAC_UP_AND_RUNNING)); 1728 1729 error = ENOMEM; 1730 /* 1731 * Create DMA tag for mapping buffers into controller-addressable space. 1732 */ 1733 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */ 1734 1, 0, /* algnmnt, boundary */ 1735 (sc->flags & AAC_FLAGS_SG_64BIT) ? 1736 BUS_SPACE_MAXADDR : 1737 BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ 1738 BUS_SPACE_MAXADDR, /* highaddr */ 1739 NULL, NULL, /* filter, filterarg */ 1740 MAXBSIZE, /* maxsize */ 1741 sc->aac_sg_tablesize, /* nsegments */ 1742 MAXBSIZE, /* maxsegsize */ 1743 BUS_DMA_ALLOCNOW, /* flags */ 1744 busdma_lock_mutex, /* lockfunc */ 1745 &sc->aac_io_lock, /* lockfuncarg */ 1746 &sc->aac_buffer_dmat)) { 1747 device_printf(sc->aac_dev, "can't allocate buffer DMA tag\n"); 1748 goto out; 1749 } 1750 1751 /* 1752 * Create DMA tag for mapping FIBs into controller-addressable space.. 1753 */ 1754 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */ 1755 1, 0, /* algnmnt, boundary */ 1756 (sc->flags & AAC_FLAGS_4GB_WINDOW) ? 1757 BUS_SPACE_MAXADDR_32BIT : 1758 0x7fffffff, /* lowaddr */ 1759 BUS_SPACE_MAXADDR, /* highaddr */ 1760 NULL, NULL, /* filter, filterarg */ 1761 sc->aac_max_fibs_alloc * 1762 sc->aac_max_fib_size, /* maxsize */ 1763 1, /* nsegments */ 1764 sc->aac_max_fibs_alloc * 1765 sc->aac_max_fib_size, /* maxsegsize */ 1766 0, /* flags */ 1767 NULL, NULL, /* No locking needed */ 1768 &sc->aac_fib_dmat)) { 1769 device_printf(sc->aac_dev, "can't allocate FIB DMA tag\n");; 1770 goto out; 1771 } 1772 1773 /* 1774 * Create DMA tag for the common structure and allocate it. 1775 */ 1776 if (bus_dma_tag_create(sc->aac_parent_dmat, /* parent */ 1777 1, 0, /* algnmnt, boundary */ 1778 (sc->flags & AAC_FLAGS_4GB_WINDOW) ? 1779 BUS_SPACE_MAXADDR_32BIT : 1780 0x7fffffff, /* lowaddr */ 1781 BUS_SPACE_MAXADDR, /* highaddr */ 1782 NULL, NULL, /* filter, filterarg */ 1783 8192 + sizeof(struct aac_common), /* maxsize */ 1784 1, /* nsegments */ 1785 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ 1786 0, /* flags */ 1787 NULL, NULL, /* No locking needed */ 1788 &sc->aac_common_dmat)) { 1789 device_printf(sc->aac_dev, 1790 "can't allocate common structure DMA tag\n"); 1791 goto out; 1792 } 1793 if (bus_dmamem_alloc(sc->aac_common_dmat, (void **)&sc->aac_common, 1794 BUS_DMA_NOWAIT, &sc->aac_common_dmamap)) { 1795 device_printf(sc->aac_dev, "can't allocate common structure\n"); 1796 goto out; 1797 } 1798 1799 /* 1800 * Work around a bug in the 2120 and 2200 that cannot DMA commands 1801 * below address 8192 in physical memory. 1802 * XXX If the padding is not needed, can it be put to use instead 1803 * of ignored? 1804 */ 1805 (void)bus_dmamap_load(sc->aac_common_dmat, sc->aac_common_dmamap, 1806 sc->aac_common, 8192 + sizeof(*sc->aac_common), 1807 aac_common_map, sc, 0); 1808 1809 if (sc->aac_common_busaddr < 8192) { 1810 sc->aac_common = (struct aac_common *) 1811 ((uint8_t *)sc->aac_common + 8192); 1812 sc->aac_common_busaddr += 8192; 1813 } 1814 bzero(sc->aac_common, sizeof(*sc->aac_common)); 1815 1816 /* Allocate some FIBs and associated command structs */ 1817 TAILQ_INIT(&sc->aac_fibmap_tqh); 1818 sc->aac_commands = malloc(sc->aac_max_fibs * sizeof(struct aac_command), 1819 M_AACBUF, M_WAITOK|M_ZERO); 1820 while (sc->total_fibs < AAC_PREALLOCATE_FIBS) { 1821 if (aac_alloc_commands(sc) != 0) 1822 break; 1823 } 1824 if (sc->total_fibs == 0) 1825 goto out; 1826 1827 /* 1828 * Fill in the init structure. This tells the adapter about the 1829 * physical location of various important shared data structures. 1830 */ 1831 ip = &sc->aac_common->ac_init; 1832 ip->InitStructRevision = AAC_INIT_STRUCT_REVISION; 1833 if (sc->aac_max_fib_size > sizeof(struct aac_fib)) { 1834 ip->InitStructRevision = AAC_INIT_STRUCT_REVISION_4; 1835 sc->flags |= AAC_FLAGS_RAW_IO; 1836 } 1837 ip->MiniPortRevision = AAC_INIT_STRUCT_MINIPORT_REVISION; 1838 1839 ip->AdapterFibsPhysicalAddress = sc->aac_common_busaddr + 1840 offsetof(struct aac_common, ac_fibs); 1841 ip->AdapterFibsVirtualAddress = 0; 1842 ip->AdapterFibsSize = AAC_ADAPTER_FIBS * sizeof(struct aac_fib); 1843 ip->AdapterFibAlign = sizeof(struct aac_fib); 1844 1845 ip->PrintfBufferAddress = sc->aac_common_busaddr + 1846 offsetof(struct aac_common, ac_printf); 1847 ip->PrintfBufferSize = AAC_PRINTF_BUFSIZE; 1848 1849 /* 1850 * The adapter assumes that pages are 4K in size, except on some 1851 * broken firmware versions that do the page->byte conversion twice, 1852 * therefore 'assuming' that this value is in 16MB units (2^24). 1853 * Round up since the granularity is so high. 1854 */ 1855 ip->HostPhysMemPages = ctob(physmem) / AAC_PAGE_SIZE; 1856 if (sc->flags & AAC_FLAGS_BROKEN_MEMMAP) { 1857 ip->HostPhysMemPages = 1858 (ip->HostPhysMemPages + AAC_PAGE_SIZE) / AAC_PAGE_SIZE; 1859 } 1860 ip->HostElapsedSeconds = time_uptime; /* reset later if invalid */ 1861 1862 ip->InitFlags = 0; 1863 if (sc->flags & AAC_FLAGS_NEW_COMM) { 1864 ip->InitFlags = INITFLAGS_NEW_COMM_SUPPORTED; 1865 device_printf(sc->aac_dev, "New comm. interface enabled\n"); 1866 } 1867 1868 ip->MaxIoCommands = sc->aac_max_fibs; 1869 ip->MaxIoSize = sc->aac_max_sectors << 9; 1870 ip->MaxFibSize = sc->aac_max_fib_size; 1871 1872 /* 1873 * Initialise FIB queues. Note that it appears that the layout of the 1874 * indexes and the segmentation of the entries may be mandated by the 1875 * adapter, which is only told about the base of the queue index fields. 1876 * 1877 * The initial values of the indices are assumed to inform the adapter 1878 * of the sizes of the respective queues, and theoretically it could 1879 * work out the entire layout of the queue structures from this. We 1880 * take the easy route and just lay this area out like everyone else 1881 * does. 1882 * 1883 * The Linux driver uses a much more complex scheme whereby several 1884 * header records are kept for each queue. We use a couple of generic 1885 * list manipulation functions which 'know' the size of each list by 1886 * virtue of a table. 1887 */ 1888 qoffset = offsetof(struct aac_common, ac_qbuf) + AAC_QUEUE_ALIGN; 1889 qoffset &= ~(AAC_QUEUE_ALIGN - 1); 1890 sc->aac_queues = 1891 (struct aac_queue_table *)((uintptr_t)sc->aac_common + qoffset); 1892 ip->CommHeaderAddress = sc->aac_common_busaddr + qoffset; 1893 1894 sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] = 1895 AAC_HOST_NORM_CMD_ENTRIES; 1896 sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] = 1897 AAC_HOST_NORM_CMD_ENTRIES; 1898 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] = 1899 AAC_HOST_HIGH_CMD_ENTRIES; 1900 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] = 1901 AAC_HOST_HIGH_CMD_ENTRIES; 1902 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_PRODUCER_INDEX] = 1903 AAC_ADAP_NORM_CMD_ENTRIES; 1904 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][AAC_CONSUMER_INDEX] = 1905 AAC_ADAP_NORM_CMD_ENTRIES; 1906 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_PRODUCER_INDEX] = 1907 AAC_ADAP_HIGH_CMD_ENTRIES; 1908 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][AAC_CONSUMER_INDEX] = 1909 AAC_ADAP_HIGH_CMD_ENTRIES; 1910 sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]= 1911 AAC_HOST_NORM_RESP_ENTRIES; 1912 sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]= 1913 AAC_HOST_NORM_RESP_ENTRIES; 1914 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]= 1915 AAC_HOST_HIGH_RESP_ENTRIES; 1916 sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]= 1917 AAC_HOST_HIGH_RESP_ENTRIES; 1918 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_PRODUCER_INDEX]= 1919 AAC_ADAP_NORM_RESP_ENTRIES; 1920 sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][AAC_CONSUMER_INDEX]= 1921 AAC_ADAP_NORM_RESP_ENTRIES; 1922 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_PRODUCER_INDEX]= 1923 AAC_ADAP_HIGH_RESP_ENTRIES; 1924 sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][AAC_CONSUMER_INDEX]= 1925 AAC_ADAP_HIGH_RESP_ENTRIES; 1926 sc->aac_qentries[AAC_HOST_NORM_CMD_QUEUE] = 1927 &sc->aac_queues->qt_HostNormCmdQueue[0]; 1928 sc->aac_qentries[AAC_HOST_HIGH_CMD_QUEUE] = 1929 &sc->aac_queues->qt_HostHighCmdQueue[0]; 1930 sc->aac_qentries[AAC_ADAP_NORM_CMD_QUEUE] = 1931 &sc->aac_queues->qt_AdapNormCmdQueue[0]; 1932 sc->aac_qentries[AAC_ADAP_HIGH_CMD_QUEUE] = 1933 &sc->aac_queues->qt_AdapHighCmdQueue[0]; 1934 sc->aac_qentries[AAC_HOST_NORM_RESP_QUEUE] = 1935 &sc->aac_queues->qt_HostNormRespQueue[0]; 1936 sc->aac_qentries[AAC_HOST_HIGH_RESP_QUEUE] = 1937 &sc->aac_queues->qt_HostHighRespQueue[0]; 1938 sc->aac_qentries[AAC_ADAP_NORM_RESP_QUEUE] = 1939 &sc->aac_queues->qt_AdapNormRespQueue[0]; 1940 sc->aac_qentries[AAC_ADAP_HIGH_RESP_QUEUE] = 1941 &sc->aac_queues->qt_AdapHighRespQueue[0]; 1942 1943 /* 1944 * Do controller-type-specific initialisation 1945 */ 1946 switch (sc->aac_hwif) { 1947 case AAC_HWIF_I960RX: 1948 AAC_SETREG4(sc, AAC_RX_ODBR, ~0); 1949 break; 1950 case AAC_HWIF_RKT: 1951 AAC_SETREG4(sc, AAC_RKT_ODBR, ~0); 1952 break; 1953 default: 1954 break; 1955 } 1956 1957 /* 1958 * Give the init structure to the controller. 1959 */ 1960 if (aac_sync_command(sc, AAC_MONKER_INITSTRUCT, 1961 sc->aac_common_busaddr + 1962 offsetof(struct aac_common, ac_init), 0, 0, 0, 1963 NULL)) { 1964 device_printf(sc->aac_dev, 1965 "error establishing init structure\n"); 1966 error = EIO; 1967 goto out; 1968 } 1969 1970 error = 0; 1971out: 1972 return(error); 1973} 1974 1975/* 1976 * Send a synchronous command to the controller and wait for a result. 1977 * Indicate if the controller completed the command with an error status. 1978 */ 1979static int 1980aac_sync_command(struct aac_softc *sc, u_int32_t command, 1981 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3, 1982 u_int32_t *sp) 1983{ 1984 time_t then; 1985 u_int32_t status; 1986 1987 debug_called(3); 1988 1989 /* populate the mailbox */ 1990 AAC_SET_MAILBOX(sc, command, arg0, arg1, arg2, arg3); 1991 1992 /* ensure the sync command doorbell flag is cleared */ 1993 AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND); 1994 1995 /* then set it to signal the adapter */ 1996 AAC_QNOTIFY(sc, AAC_DB_SYNC_COMMAND); 1997 1998 /* spin waiting for the command to complete */ 1999 then = time_uptime; 2000 do { 2001 if (time_uptime > (then + AAC_IMMEDIATE_TIMEOUT)) { 2002 debug(1, "timed out"); 2003 return(EIO); 2004 } 2005 } while (!(AAC_GET_ISTATUS(sc) & AAC_DB_SYNC_COMMAND)); 2006 2007 /* clear the completion flag */ 2008 AAC_CLEAR_ISTATUS(sc, AAC_DB_SYNC_COMMAND); 2009 2010 /* get the command status */ 2011 status = AAC_GET_MAILBOX(sc, 0); 2012 if (sp != NULL) 2013 *sp = status; 2014 2015 if (status != AAC_SRB_STS_SUCCESS) 2016 return (-1); 2017 return(0); 2018} 2019 2020int 2021aac_sync_fib(struct aac_softc *sc, u_int32_t command, u_int32_t xferstate, 2022 struct aac_fib *fib, u_int16_t datasize) 2023{ 2024 debug_called(3); 2025 mtx_assert(&sc->aac_io_lock, MA_OWNED); 2026 2027 if (datasize > AAC_FIB_DATASIZE) 2028 return(EINVAL); 2029 2030 /* 2031 * Set up the sync FIB 2032 */ 2033 fib->Header.XferState = AAC_FIBSTATE_HOSTOWNED | 2034 AAC_FIBSTATE_INITIALISED | 2035 AAC_FIBSTATE_EMPTY; 2036 fib->Header.XferState |= xferstate; 2037 fib->Header.Command = command; 2038 fib->Header.StructType = AAC_FIBTYPE_TFIB; 2039 fib->Header.Size = sizeof(struct aac_fib) + datasize; 2040 fib->Header.SenderSize = sizeof(struct aac_fib); 2041 fib->Header.SenderFibAddress = 0; /* Not needed */ 2042 fib->Header.ReceiverFibAddress = sc->aac_common_busaddr + 2043 offsetof(struct aac_common, 2044 ac_sync_fib); 2045 2046 /* 2047 * Give the FIB to the controller, wait for a response. 2048 */ 2049 if (aac_sync_command(sc, AAC_MONKER_SYNCFIB, 2050 fib->Header.ReceiverFibAddress, 0, 0, 0, NULL)) { 2051 debug(2, "IO error"); 2052 return(EIO); 2053 } 2054 2055 return (0); 2056} 2057 2058/* 2059 * Adapter-space FIB queue manipulation 2060 * 2061 * Note that the queue implementation here is a little funky; neither the PI or 2062 * CI will ever be zero. This behaviour is a controller feature. 2063 */ 2064static struct { 2065 int size; 2066 int notify; 2067} aac_qinfo[] = { 2068 {AAC_HOST_NORM_CMD_ENTRIES, AAC_DB_COMMAND_NOT_FULL}, 2069 {AAC_HOST_HIGH_CMD_ENTRIES, 0}, 2070 {AAC_ADAP_NORM_CMD_ENTRIES, AAC_DB_COMMAND_READY}, 2071 {AAC_ADAP_HIGH_CMD_ENTRIES, 0}, 2072 {AAC_HOST_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_NOT_FULL}, 2073 {AAC_HOST_HIGH_RESP_ENTRIES, 0}, 2074 {AAC_ADAP_NORM_RESP_ENTRIES, AAC_DB_RESPONSE_READY}, 2075 {AAC_ADAP_HIGH_RESP_ENTRIES, 0} 2076}; 2077 2078/* 2079 * Atomically insert an entry into the nominated queue, returns 0 on success or 2080 * EBUSY if the queue is full. 2081 * 2082 * Note: it would be more efficient to defer notifying the controller in 2083 * the case where we may be inserting several entries in rapid succession, 2084 * but implementing this usefully may be difficult (it would involve a 2085 * separate queue/notify interface). 2086 */ 2087static int 2088aac_enqueue_fib(struct aac_softc *sc, int queue, struct aac_command *cm) 2089{ 2090 u_int32_t pi, ci; 2091 int error; 2092 u_int32_t fib_size; 2093 u_int32_t fib_addr; 2094 2095 debug_called(3); 2096 2097 fib_size = cm->cm_fib->Header.Size; 2098 fib_addr = cm->cm_fib->Header.ReceiverFibAddress; 2099 2100 /* get the producer/consumer indices */ 2101 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX]; 2102 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX]; 2103 2104 /* wrap the queue? */ 2105 if (pi >= aac_qinfo[queue].size) 2106 pi = 0; 2107 2108 /* check for queue full */ 2109 if ((pi + 1) == ci) { 2110 error = EBUSY; 2111 goto out; 2112 } 2113 2114 /* 2115 * To avoid a race with its completion interrupt, place this command on 2116 * the busy queue prior to advertising it to the controller. 2117 */ 2118 aac_enqueue_busy(cm); 2119 2120 /* populate queue entry */ 2121 (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size; 2122 (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr; 2123 2124 /* update producer index */ 2125 sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1; 2126 2127 /* notify the adapter if we know how */ 2128 if (aac_qinfo[queue].notify != 0) 2129 AAC_QNOTIFY(sc, aac_qinfo[queue].notify); 2130 2131 error = 0; 2132 2133out: 2134 return(error); 2135} 2136 2137/* 2138 * Atomically remove one entry from the nominated queue, returns 0 on 2139 * success or ENOENT if the queue is empty. 2140 */ 2141static int 2142aac_dequeue_fib(struct aac_softc *sc, int queue, u_int32_t *fib_size, 2143 struct aac_fib **fib_addr) 2144{ 2145 u_int32_t pi, ci; 2146 u_int32_t fib_index; 2147 int error; 2148 int notify; 2149 2150 debug_called(3); 2151 2152 /* get the producer/consumer indices */ 2153 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX]; 2154 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX]; 2155 2156 /* check for queue empty */ 2157 if (ci == pi) { 2158 error = ENOENT; 2159 goto out; 2160 } 2161 2162 /* wrap the pi so the following test works */ 2163 if (pi >= aac_qinfo[queue].size) 2164 pi = 0; 2165 2166 notify = 0; 2167 if (ci == pi + 1) 2168 notify++; 2169 2170 /* wrap the queue? */ 2171 if (ci >= aac_qinfo[queue].size) 2172 ci = 0; 2173 2174 /* fetch the entry */ 2175 *fib_size = (sc->aac_qentries[queue] + ci)->aq_fib_size; 2176 2177 switch (queue) { 2178 case AAC_HOST_NORM_CMD_QUEUE: 2179 case AAC_HOST_HIGH_CMD_QUEUE: 2180 /* 2181 * The aq_fib_addr is only 32 bits wide so it can't be counted 2182 * on to hold an address. For AIF's, the adapter assumes 2183 * that it's giving us an address into the array of AIF fibs. 2184 * Therefore, we have to convert it to an index. 2185 */ 2186 fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr / 2187 sizeof(struct aac_fib); 2188 *fib_addr = &sc->aac_common->ac_fibs[fib_index]; 2189 break; 2190 2191 case AAC_HOST_NORM_RESP_QUEUE: 2192 case AAC_HOST_HIGH_RESP_QUEUE: 2193 { 2194 struct aac_command *cm; 2195 2196 /* 2197 * As above, an index is used instead of an actual address. 2198 * Gotta shift the index to account for the fast response 2199 * bit. No other correction is needed since this value was 2200 * originally provided by the driver via the SenderFibAddress 2201 * field. 2202 */ 2203 fib_index = (sc->aac_qentries[queue] + ci)->aq_fib_addr; 2204 cm = sc->aac_commands + (fib_index >> 2); 2205 *fib_addr = cm->cm_fib; 2206 2207 /* 2208 * Is this a fast response? If it is, update the fib fields in 2209 * local memory since the whole fib isn't DMA'd back up. 2210 */ 2211 if (fib_index & 0x01) { 2212 (*fib_addr)->Header.XferState |= AAC_FIBSTATE_DONEADAP; 2213 *((u_int32_t*)((*fib_addr)->data)) = AAC_ERROR_NORMAL; 2214 } 2215 break; 2216 } 2217 default: 2218 panic("Invalid queue in aac_dequeue_fib()"); 2219 break; 2220 } 2221 2222 /* update consumer index */ 2223 sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX] = ci + 1; 2224 2225 /* if we have made the queue un-full, notify the adapter */ 2226 if (notify && (aac_qinfo[queue].notify != 0)) 2227 AAC_QNOTIFY(sc, aac_qinfo[queue].notify); 2228 error = 0; 2229 2230out: 2231 return(error); 2232} 2233 2234/* 2235 * Put our response to an Adapter Initialed Fib on the response queue 2236 */ 2237static int 2238aac_enqueue_response(struct aac_softc *sc, int queue, struct aac_fib *fib) 2239{ 2240 u_int32_t pi, ci; 2241 int error; 2242 u_int32_t fib_size; 2243 u_int32_t fib_addr; 2244 2245 debug_called(1); 2246 2247 /* Tell the adapter where the FIB is */ 2248 fib_size = fib->Header.Size; 2249 fib_addr = fib->Header.SenderFibAddress; 2250 fib->Header.ReceiverFibAddress = fib_addr; 2251 2252 /* get the producer/consumer indices */ 2253 pi = sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX]; 2254 ci = sc->aac_queues->qt_qindex[queue][AAC_CONSUMER_INDEX]; 2255 2256 /* wrap the queue? */ 2257 if (pi >= aac_qinfo[queue].size) 2258 pi = 0; 2259 2260 /* check for queue full */ 2261 if ((pi + 1) == ci) { 2262 error = EBUSY; 2263 goto out; 2264 } 2265 2266 /* populate queue entry */ 2267 (sc->aac_qentries[queue] + pi)->aq_fib_size = fib_size; 2268 (sc->aac_qentries[queue] + pi)->aq_fib_addr = fib_addr; 2269 2270 /* update producer index */ 2271 sc->aac_queues->qt_qindex[queue][AAC_PRODUCER_INDEX] = pi + 1; 2272 2273 /* notify the adapter if we know how */ 2274 if (aac_qinfo[queue].notify != 0) 2275 AAC_QNOTIFY(sc, aac_qinfo[queue].notify); 2276 2277 error = 0; 2278 2279out: 2280 return(error); 2281} 2282 2283/* 2284 * Check for commands that have been outstanding for a suspiciously long time, 2285 * and complain about them. 2286 */ 2287static void 2288aac_timeout(struct aac_softc *sc) 2289{ 2290 struct aac_command *cm; 2291 time_t deadline; 2292 int timedout, code; 2293 2294 /* 2295 * Traverse the busy command list, bitch about late commands once 2296 * only. 2297 */ 2298 timedout = 0; 2299 deadline = time_uptime - AAC_CMD_TIMEOUT; 2300 TAILQ_FOREACH(cm, &sc->aac_busy, cm_link) { 2301 if ((cm->cm_timestamp < deadline) 2302 /* && !(cm->cm_flags & AAC_CMD_TIMEDOUT) */) { 2303 cm->cm_flags |= AAC_CMD_TIMEDOUT; 2304 device_printf(sc->aac_dev, 2305 "COMMAND %p TIMEOUT AFTER %d SECONDS\n", 2306 cm, (int)(time_uptime-cm->cm_timestamp)); 2307 AAC_PRINT_FIB(sc, cm->cm_fib); 2308 timedout++; 2309 } 2310 } 2311 2312 if (timedout) { 2313 code = AAC_GET_FWSTATUS(sc); 2314 if (code != AAC_UP_AND_RUNNING) { 2315 device_printf(sc->aac_dev, "WARNING! Controller is no " 2316 "longer running! code= 0x%x\n", code); 2317 } 2318 } 2319 return; 2320} 2321 2322/* 2323 * Interface Function Vectors 2324 */ 2325 2326/* 2327 * Read the current firmware status word. 2328 */ 2329static int 2330aac_sa_get_fwstatus(struct aac_softc *sc) 2331{ 2332 debug_called(3); 2333 2334 return(AAC_GETREG4(sc, AAC_SA_FWSTATUS)); 2335} 2336 2337static int 2338aac_rx_get_fwstatus(struct aac_softc *sc) 2339{ 2340 debug_called(3); 2341 2342 return(AAC_GETREG4(sc, AAC_RX_FWSTATUS)); 2343} 2344 2345static int 2346aac_fa_get_fwstatus(struct aac_softc *sc) 2347{ 2348 int val; 2349 2350 debug_called(3); 2351 2352 val = AAC_GETREG4(sc, AAC_FA_FWSTATUS); 2353 return (val); 2354} 2355 2356static int 2357aac_rkt_get_fwstatus(struct aac_softc *sc) 2358{ 2359 debug_called(3); 2360 2361 return(AAC_GETREG4(sc, AAC_RKT_FWSTATUS)); 2362} 2363 2364/* 2365 * Notify the controller of a change in a given queue 2366 */ 2367 2368static void 2369aac_sa_qnotify(struct aac_softc *sc, int qbit) 2370{ 2371 debug_called(3); 2372 2373 AAC_SETREG2(sc, AAC_SA_DOORBELL1_SET, qbit); 2374} 2375 2376static void 2377aac_rx_qnotify(struct aac_softc *sc, int qbit) 2378{ 2379 debug_called(3); 2380 2381 AAC_SETREG4(sc, AAC_RX_IDBR, qbit); 2382} 2383 2384static void 2385aac_fa_qnotify(struct aac_softc *sc, int qbit) 2386{ 2387 debug_called(3); 2388 2389 AAC_SETREG2(sc, AAC_FA_DOORBELL1, qbit); 2390 AAC_FA_HACK(sc); 2391} 2392 2393static void 2394aac_rkt_qnotify(struct aac_softc *sc, int qbit) 2395{ 2396 debug_called(3); 2397 2398 AAC_SETREG4(sc, AAC_RKT_IDBR, qbit); 2399} 2400 2401/* 2402 * Get the interrupt reason bits 2403 */ 2404static int 2405aac_sa_get_istatus(struct aac_softc *sc) 2406{ 2407 debug_called(3); 2408 2409 return(AAC_GETREG2(sc, AAC_SA_DOORBELL0)); 2410} 2411 2412static int 2413aac_rx_get_istatus(struct aac_softc *sc) 2414{ 2415 debug_called(3); 2416 2417 return(AAC_GETREG4(sc, AAC_RX_ODBR)); 2418} 2419 2420static int 2421aac_fa_get_istatus(struct aac_softc *sc) 2422{ 2423 int val; 2424 2425 debug_called(3); 2426 2427 val = AAC_GETREG2(sc, AAC_FA_DOORBELL0); 2428 return (val); 2429} 2430 2431static int 2432aac_rkt_get_istatus(struct aac_softc *sc) 2433{ 2434 debug_called(3); 2435 2436 return(AAC_GETREG4(sc, AAC_RKT_ODBR)); 2437} 2438 2439/* 2440 * Clear some interrupt reason bits 2441 */ 2442static void 2443aac_sa_clear_istatus(struct aac_softc *sc, int mask) 2444{ 2445 debug_called(3); 2446 2447 AAC_SETREG2(sc, AAC_SA_DOORBELL0_CLEAR, mask); 2448} 2449 2450static void 2451aac_rx_clear_istatus(struct aac_softc *sc, int mask) 2452{ 2453 debug_called(3); 2454 2455 AAC_SETREG4(sc, AAC_RX_ODBR, mask); 2456} 2457 2458static void 2459aac_fa_clear_istatus(struct aac_softc *sc, int mask) 2460{ 2461 debug_called(3); 2462 2463 AAC_SETREG2(sc, AAC_FA_DOORBELL0_CLEAR, mask); 2464 AAC_FA_HACK(sc); 2465} 2466 2467static void 2468aac_rkt_clear_istatus(struct aac_softc *sc, int mask) 2469{ 2470 debug_called(3); 2471 2472 AAC_SETREG4(sc, AAC_RKT_ODBR, mask); 2473} 2474 2475/* 2476 * Populate the mailbox and set the command word 2477 */ 2478static void 2479aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command, 2480 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3) 2481{ 2482 debug_called(4); 2483 2484 AAC_SETREG4(sc, AAC_SA_MAILBOX, command); 2485 AAC_SETREG4(sc, AAC_SA_MAILBOX + 4, arg0); 2486 AAC_SETREG4(sc, AAC_SA_MAILBOX + 8, arg1); 2487 AAC_SETREG4(sc, AAC_SA_MAILBOX + 12, arg2); 2488 AAC_SETREG4(sc, AAC_SA_MAILBOX + 16, arg3); 2489} 2490 2491static void 2492aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command, 2493 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3) 2494{ 2495 debug_called(4); 2496 2497 AAC_SETREG4(sc, AAC_RX_MAILBOX, command); 2498 AAC_SETREG4(sc, AAC_RX_MAILBOX + 4, arg0); 2499 AAC_SETREG4(sc, AAC_RX_MAILBOX + 8, arg1); 2500 AAC_SETREG4(sc, AAC_RX_MAILBOX + 12, arg2); 2501 AAC_SETREG4(sc, AAC_RX_MAILBOX + 16, arg3); 2502} 2503 2504static void 2505aac_fa_set_mailbox(struct aac_softc *sc, u_int32_t command, 2506 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, u_int32_t arg3) 2507{ 2508 debug_called(4); 2509 2510 AAC_SETREG4(sc, AAC_FA_MAILBOX, command); 2511 AAC_FA_HACK(sc); 2512 AAC_SETREG4(sc, AAC_FA_MAILBOX + 4, arg0); 2513 AAC_FA_HACK(sc); 2514 AAC_SETREG4(sc, AAC_FA_MAILBOX + 8, arg1); 2515 AAC_FA_HACK(sc); 2516 AAC_SETREG4(sc, AAC_FA_MAILBOX + 12, arg2); 2517 AAC_FA_HACK(sc); 2518 AAC_SETREG4(sc, AAC_FA_MAILBOX + 16, arg3); 2519 AAC_FA_HACK(sc); 2520} 2521 2522static void 2523aac_rkt_set_mailbox(struct aac_softc *sc, u_int32_t command, u_int32_t arg0, 2524 u_int32_t arg1, u_int32_t arg2, u_int32_t arg3) 2525{ 2526 debug_called(4); 2527 2528 AAC_SETREG4(sc, AAC_RKT_MAILBOX, command); 2529 AAC_SETREG4(sc, AAC_RKT_MAILBOX + 4, arg0); 2530 AAC_SETREG4(sc, AAC_RKT_MAILBOX + 8, arg1); 2531 AAC_SETREG4(sc, AAC_RKT_MAILBOX + 12, arg2); 2532 AAC_SETREG4(sc, AAC_RKT_MAILBOX + 16, arg3); 2533} 2534 2535/* 2536 * Fetch the immediate command status word 2537 */ 2538static int 2539aac_sa_get_mailbox(struct aac_softc *sc, int mb) 2540{ 2541 debug_called(4); 2542 2543 return(AAC_GETREG4(sc, AAC_SA_MAILBOX + (mb * 4))); 2544} 2545 2546static int 2547aac_rx_get_mailbox(struct aac_softc *sc, int mb) 2548{ 2549 debug_called(4); 2550 2551 return(AAC_GETREG4(sc, AAC_RX_MAILBOX + (mb * 4))); 2552} 2553 2554static int 2555aac_fa_get_mailbox(struct aac_softc *sc, int mb) 2556{ 2557 int val; 2558 2559 debug_called(4); 2560 2561 val = AAC_GETREG4(sc, AAC_FA_MAILBOX + (mb * 4)); 2562 return (val); 2563} 2564 2565static int 2566aac_rkt_get_mailbox(struct aac_softc *sc, int mb) 2567{ 2568 debug_called(4); 2569 2570 return(AAC_GETREG4(sc, AAC_RKT_MAILBOX + (mb * 4))); 2571} 2572 2573/* 2574 * Set/clear interrupt masks 2575 */ 2576static void 2577aac_sa_set_interrupts(struct aac_softc *sc, int enable) 2578{ 2579 debug(2, "%sable interrupts", enable ? "en" : "dis"); 2580 2581 if (enable) { 2582 AAC_SETREG2((sc), AAC_SA_MASK0_CLEAR, AAC_DB_INTERRUPTS); 2583 } else { 2584 AAC_SETREG2((sc), AAC_SA_MASK0_SET, ~0); 2585 } 2586} 2587 2588static void 2589aac_rx_set_interrupts(struct aac_softc *sc, int enable) 2590{ 2591 debug(2, "%sable interrupts", enable ? "en" : "dis"); 2592 2593 if (enable) { 2594 if (sc->flags & AAC_FLAGS_NEW_COMM) 2595 AAC_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INT_NEW_COMM); 2596 else 2597 AAC_SETREG4(sc, AAC_RX_OIMR, ~AAC_DB_INTERRUPTS); 2598 } else { 2599 AAC_SETREG4(sc, AAC_RX_OIMR, ~0); 2600 } 2601} 2602 2603static void 2604aac_fa_set_interrupts(struct aac_softc *sc, int enable) 2605{ 2606 debug(2, "%sable interrupts", enable ? "en" : "dis"); 2607 2608 if (enable) { 2609 AAC_SETREG2((sc), AAC_FA_MASK0_CLEAR, AAC_DB_INTERRUPTS); 2610 AAC_FA_HACK(sc); 2611 } else { 2612 AAC_SETREG2((sc), AAC_FA_MASK0, ~0); 2613 AAC_FA_HACK(sc); 2614 } 2615} 2616 2617static void 2618aac_rkt_set_interrupts(struct aac_softc *sc, int enable) 2619{ 2620 debug(2, "%sable interrupts", enable ? "en" : "dis"); 2621 2622 if (enable) { 2623 if (sc->flags & AAC_FLAGS_NEW_COMM) 2624 AAC_SETREG4(sc, AAC_RKT_OIMR, ~AAC_DB_INT_NEW_COMM); 2625 else 2626 AAC_SETREG4(sc, AAC_RKT_OIMR, ~AAC_DB_INTERRUPTS); 2627 } else { 2628 AAC_SETREG4(sc, AAC_RKT_OIMR, ~0); 2629 } 2630} 2631 2632/* 2633 * New comm. interface: Send command functions 2634 */ 2635static int 2636aac_rx_send_command(struct aac_softc *sc, struct aac_command *cm) 2637{ 2638 u_int32_t index, device; 2639 2640 debug(2, "send command (new comm.)"); 2641 2642 index = AAC_GETREG4(sc, AAC_RX_IQUE); 2643 if (index == 0xffffffffL) 2644 index = AAC_GETREG4(sc, AAC_RX_IQUE); 2645 if (index == 0xffffffffL) 2646 return index; 2647 aac_enqueue_busy(cm); 2648 device = index; 2649 AAC_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys & 0xffffffffUL)); 2650 device += 4; 2651 AAC_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys >> 32)); 2652 device += 4; 2653 AAC_SETREG4(sc, device, cm->cm_fib->Header.Size); 2654 AAC_SETREG4(sc, AAC_RX_IQUE, index); 2655 return 0; 2656} 2657 2658static int 2659aac_rkt_send_command(struct aac_softc *sc, struct aac_command *cm) 2660{ 2661 u_int32_t index, device; 2662 2663 debug(2, "send command (new comm.)"); 2664 2665 index = AAC_GETREG4(sc, AAC_RKT_IQUE); 2666 if (index == 0xffffffffL) 2667 index = AAC_GETREG4(sc, AAC_RKT_IQUE); 2668 if (index == 0xffffffffL) 2669 return index; 2670 aac_enqueue_busy(cm); 2671 device = index; 2672 AAC_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys & 0xffffffffUL)); 2673 device += 4; 2674 AAC_SETREG4(sc, device, (u_int32_t)(cm->cm_fibphys >> 32)); 2675 device += 4; 2676 AAC_SETREG4(sc, device, cm->cm_fib->Header.Size); 2677 AAC_SETREG4(sc, AAC_RKT_IQUE, index); 2678 return 0; 2679} 2680 2681/* 2682 * New comm. interface: get, set outbound queue index 2683 */ 2684static int 2685aac_rx_get_outb_queue(struct aac_softc *sc) 2686{ 2687 debug_called(3); 2688 2689 return(AAC_GETREG4(sc, AAC_RX_OQUE)); 2690} 2691 2692static int 2693aac_rkt_get_outb_queue(struct aac_softc *sc) 2694{ 2695 debug_called(3); 2696 2697 return(AAC_GETREG4(sc, AAC_RKT_OQUE)); 2698} 2699 2700static void 2701aac_rx_set_outb_queue(struct aac_softc *sc, int index) 2702{ 2703 debug_called(3); 2704 2705 AAC_SETREG4(sc, AAC_RX_OQUE, index); 2706} 2707 2708static void 2709aac_rkt_set_outb_queue(struct aac_softc *sc, int index) 2710{ 2711 debug_called(3); 2712 2713 AAC_SETREG4(sc, AAC_RKT_OQUE, index); 2714} 2715 2716/* 2717 * Debugging and Diagnostics 2718 */ 2719 2720/* 2721 * Print some information about the controller. 2722 */ 2723static void 2724aac_describe_controller(struct aac_softc *sc) 2725{ 2726 struct aac_fib *fib; 2727 struct aac_adapter_info *info; 2728 2729 debug_called(2); 2730 2731 mtx_lock(&sc->aac_io_lock); 2732 aac_alloc_sync_fib(sc, &fib); 2733 2734 fib->data[0] = 0; 2735 if (aac_sync_fib(sc, RequestAdapterInfo, 0, fib, 1)) { 2736 device_printf(sc->aac_dev, "RequestAdapterInfo failed\n"); 2737 aac_release_sync_fib(sc); 2738 mtx_unlock(&sc->aac_io_lock); 2739 return; 2740 } 2741 2742 /* save the kernel revision structure for later use */ 2743 info = (struct aac_adapter_info *)&fib->data[0]; 2744 sc->aac_revision = info->KernelRevision; 2745 2746 device_printf(sc->aac_dev, "Adaptec Raid Controller %d.%d.%d-%d\n", 2747 AAC_DRIVER_VERSION >> 24, 2748 (AAC_DRIVER_VERSION >> 16) & 0xFF, 2749 AAC_DRIVER_VERSION & 0xFF, 2750 AAC_DRIVER_BUILD); 2751 2752 if (bootverbose) { 2753 device_printf(sc->aac_dev, "%s %dMHz, %dMB memory " 2754 "(%dMB cache, %dMB execution), %s\n", 2755 aac_describe_code(aac_cpu_variant, info->CpuVariant), 2756 info->ClockSpeed, info->TotalMem / (1024 * 1024), 2757 info->BufferMem / (1024 * 1024), 2758 info->ExecutionMem / (1024 * 1024), 2759 aac_describe_code(aac_battery_platform, 2760 info->batteryPlatform)); 2761 2762 device_printf(sc->aac_dev, 2763 "Kernel %d.%d-%d, Build %d, S/N %6X\n", 2764 info->KernelRevision.external.comp.major, 2765 info->KernelRevision.external.comp.minor, 2766 info->KernelRevision.external.comp.dash, 2767 info->KernelRevision.buildNumber, 2768 (u_int32_t)(info->SerialNumber & 0xffffff)); 2769 2770 device_printf(sc->aac_dev, "Supported Options=%b\n", 2771 sc->supported_options, 2772 "\20" 2773 "\1SNAPSHOT" 2774 "\2CLUSTERS" 2775 "\3WCACHE" 2776 "\4DATA64" 2777 "\5HOSTTIME" 2778 "\6RAID50" 2779 "\7WINDOW4GB" 2780 "\10SCSIUPGD" 2781 "\11SOFTERR" 2782 "\12NORECOND" 2783 "\13SGMAP64" 2784 "\14ALARM" 2785 "\15NONDASD" 2786 "\16SCSIMGT" 2787 "\17RAIDSCSI" 2788 "\21ADPTINFO" 2789 "\22NEWCOMM" 2790 "\23ARRAY64BIT" 2791 "\24HEATSENSOR"); 2792 } 2793 aac_release_sync_fib(sc); 2794 mtx_unlock(&sc->aac_io_lock); 2795} 2796 2797/* 2798 * Look up a text description of a numeric error code and return a pointer to 2799 * same. 2800 */ 2801static char * 2802aac_describe_code(struct aac_code_lookup *table, u_int32_t code) 2803{ 2804 int i; 2805 2806 for (i = 0; table[i].string != NULL; i++) 2807 if (table[i].code == code) 2808 return(table[i].string); 2809 return(table[i + 1].string); 2810} 2811 2812/* 2813 * Management Interface 2814 */ 2815 2816static int 2817aac_open(struct cdev *dev, int flags, int fmt, d_thread_t *td) 2818{ 2819 struct aac_softc *sc; 2820 2821 debug_called(2); 2822 2823 sc = dev->si_drv1; 2824 2825 /* Check to make sure the device isn't already open */ 2826 if (sc->aac_state & AAC_STATE_OPEN) { 2827 return EBUSY; 2828 } 2829 sc->aac_state |= AAC_STATE_OPEN; 2830 2831 return 0; 2832} 2833 2834static int 2835aac_close(struct cdev *dev, int flags, int fmt, d_thread_t *td) 2836{ 2837 struct aac_softc *sc; 2838 2839 debug_called(2); 2840 2841 sc = dev->si_drv1; 2842 2843 /* Mark this unit as no longer open */ 2844 sc->aac_state &= ~AAC_STATE_OPEN; 2845 2846 return 0; 2847} 2848 2849static int 2850aac_ioctl(struct cdev *dev, u_long cmd, caddr_t arg, int flag, d_thread_t *td) 2851{ 2852 union aac_statrequest *as; 2853 struct aac_softc *sc; 2854 int error = 0; 2855 uint32_t cookie; 2856 2857 debug_called(2); 2858 2859 as = (union aac_statrequest *)arg; 2860 sc = dev->si_drv1; 2861 2862 switch (cmd) { 2863 case AACIO_STATS: 2864 switch (as->as_item) { 2865 case AACQ_FREE: 2866 case AACQ_BIO: 2867 case AACQ_READY: 2868 case AACQ_BUSY: 2869 bcopy(&sc->aac_qstat[as->as_item], &as->as_qstat, 2870 sizeof(struct aac_qstat)); 2871 break; 2872 default: 2873 error = ENOENT; 2874 break; 2875 } 2876 break; 2877 2878 case FSACTL_SENDFIB: 2879 arg = *(caddr_t*)arg; 2880 case FSACTL_LNX_SENDFIB: 2881 debug(1, "FSACTL_SENDFIB"); 2882 error = aac_ioctl_sendfib(sc, arg); 2883 break; 2884 case FSACTL_AIF_THREAD: 2885 case FSACTL_LNX_AIF_THREAD: 2886 debug(1, "FSACTL_AIF_THREAD"); 2887 error = EINVAL; 2888 break; 2889 case FSACTL_OPEN_GET_ADAPTER_FIB: 2890 arg = *(caddr_t*)arg; 2891 case FSACTL_LNX_OPEN_GET_ADAPTER_FIB: 2892 debug(1, "FSACTL_OPEN_GET_ADAPTER_FIB"); 2893 /* 2894 * Pass the caller out an AdapterFibContext. 2895 * 2896 * Note that because we only support one opener, we 2897 * basically ignore this. Set the caller's context to a magic 2898 * number just in case. 2899 * 2900 * The Linux code hands the driver a pointer into kernel space, 2901 * and then trusts it when the caller hands it back. Aiee! 2902 * Here, we give it the proc pointer of the per-adapter aif 2903 * thread. It's only used as a sanity check in other calls. 2904 */ 2905 cookie = (uint32_t)(uintptr_t)sc->aifthread; 2906 error = copyout(&cookie, arg, sizeof(cookie)); 2907 break; 2908 case FSACTL_GET_NEXT_ADAPTER_FIB: 2909 arg = *(caddr_t*)arg; 2910 case FSACTL_LNX_GET_NEXT_ADAPTER_FIB: 2911 debug(1, "FSACTL_GET_NEXT_ADAPTER_FIB"); 2912 error = aac_getnext_aif(sc, arg); 2913 break; 2914 case FSACTL_CLOSE_GET_ADAPTER_FIB: 2915 case FSACTL_LNX_CLOSE_GET_ADAPTER_FIB: 2916 debug(1, "FSACTL_CLOSE_GET_ADAPTER_FIB"); 2917 /* don't do anything here */ 2918 break; 2919 case FSACTL_MINIPORT_REV_CHECK: 2920 arg = *(caddr_t*)arg; 2921 case FSACTL_LNX_MINIPORT_REV_CHECK: 2922 debug(1, "FSACTL_MINIPORT_REV_CHECK"); 2923 error = aac_rev_check(sc, arg); 2924 break; 2925 case FSACTL_QUERY_DISK: 2926 arg = *(caddr_t*)arg; 2927 case FSACTL_LNX_QUERY_DISK: 2928 debug(1, "FSACTL_QUERY_DISK"); 2929 error = aac_query_disk(sc, arg); 2930 break; 2931 case FSACTL_DELETE_DISK: 2932 case FSACTL_LNX_DELETE_DISK: 2933 /* 2934 * We don't trust the underland to tell us when to delete a 2935 * container, rather we rely on an AIF coming from the 2936 * controller 2937 */ 2938 error = 0; 2939 break; 2940 case FSACTL_GET_PCI_INFO: 2941 arg = *(caddr_t*)arg; 2942 case FSACTL_LNX_GET_PCI_INFO: 2943 debug(1, "FSACTL_GET_PCI_INFO"); 2944 error = aac_get_pci_info(sc, arg); 2945 break; 2946 default: 2947 debug(1, "unsupported cmd 0x%lx\n", cmd); 2948 error = EINVAL; 2949 break; 2950 } 2951 return(error); 2952} 2953 2954static int 2955aac_poll(struct cdev *dev, int poll_events, d_thread_t *td) 2956{ 2957 struct aac_softc *sc; 2958 int revents; 2959 2960 sc = dev->si_drv1; 2961 revents = 0; 2962 2963 mtx_lock(&sc->aac_aifq_lock); 2964 if ((poll_events & (POLLRDNORM | POLLIN)) != 0) { 2965 if (sc->aac_aifq_tail != sc->aac_aifq_head) 2966 revents |= poll_events & (POLLIN | POLLRDNORM); 2967 } 2968 mtx_unlock(&sc->aac_aifq_lock); 2969 2970 if (revents == 0) { 2971 if (poll_events & (POLLIN | POLLRDNORM)) 2972 selrecord(td, &sc->rcv_select); 2973 } 2974 2975 return (revents); 2976} 2977 2978static void 2979aac_ioctl_event(struct aac_softc *sc, struct aac_event *event, void *arg) 2980{ 2981 2982 switch (event->ev_type) { 2983 case AAC_EVENT_CMFREE: 2984 mtx_lock(&sc->aac_io_lock); 2985 if (aac_alloc_command(sc, (struct aac_command **)arg) == 0) { 2986 aac_add_event(sc, event); 2987 mtx_unlock(&sc->aac_io_lock); 2988 return; 2989 } 2990 free(event, M_AACBUF); 2991 wakeup(arg); 2992 mtx_unlock(&sc->aac_io_lock); 2993 break; 2994 default: 2995 break; 2996 } 2997} 2998 2999/* 3000 * Send a FIB supplied from userspace 3001 */ 3002static int 3003aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib) 3004{ 3005 struct aac_command *cm; 3006 int size, error; 3007 3008 debug_called(2); 3009 3010 cm = NULL; 3011 3012 /* 3013 * Get a command 3014 */ 3015 mtx_lock(&sc->aac_io_lock); 3016 if (aac_alloc_command(sc, &cm)) { 3017 struct aac_event *event; 3018 3019 event = malloc(sizeof(struct aac_event), M_AACBUF, 3020 M_NOWAIT | M_ZERO); 3021 if (event == NULL) { 3022 error = EBUSY; 3023 goto out; 3024 } 3025 event->ev_type = AAC_EVENT_CMFREE; 3026 event->ev_callback = aac_ioctl_event; 3027 event->ev_arg = &cm; 3028 aac_add_event(sc, event); 3029 msleep(&cm, &sc->aac_io_lock, 0, "sendfib", 0); 3030 } 3031 mtx_unlock(&sc->aac_io_lock); 3032 3033 /* 3034 * Fetch the FIB header, then re-copy to get data as well. 3035 */ 3036 if ((error = copyin(ufib, cm->cm_fib, 3037 sizeof(struct aac_fib_header))) != 0) 3038 goto out; 3039 size = cm->cm_fib->Header.Size + sizeof(struct aac_fib_header); 3040 if (size > sizeof(struct aac_fib)) { 3041 device_printf(sc->aac_dev, "incoming FIB oversized (%d > %zd)\n", 3042 size, sizeof(struct aac_fib)); 3043 size = sizeof(struct aac_fib); 3044 } 3045 if ((error = copyin(ufib, cm->cm_fib, size)) != 0) 3046 goto out; 3047 cm->cm_fib->Header.Size = size; 3048 cm->cm_timestamp = time_uptime; 3049 3050 /* 3051 * Pass the FIB to the controller, wait for it to complete. 3052 */ 3053 mtx_lock(&sc->aac_io_lock); 3054 if ((error = aac_wait_command(cm)) != 0) { 3055 device_printf(sc->aac_dev, 3056 "aac_wait_command return %d\n", error); 3057 goto out; 3058 } 3059 mtx_unlock(&sc->aac_io_lock); 3060 3061 /* 3062 * Copy the FIB and data back out to the caller. 3063 */ 3064 size = cm->cm_fib->Header.Size; 3065 if (size > sizeof(struct aac_fib)) { 3066 device_printf(sc->aac_dev, "outbound FIB oversized (%d > %zd)\n", 3067 size, sizeof(struct aac_fib)); 3068 size = sizeof(struct aac_fib); 3069 } 3070 error = copyout(cm->cm_fib, ufib, size); 3071 mtx_lock(&sc->aac_io_lock); 3072 3073out: 3074 if (cm != NULL) { 3075 aac_release_command(cm); 3076 } 3077 3078 mtx_unlock(&sc->aac_io_lock); 3079 return(error); 3080} 3081 3082/* 3083 * Handle an AIF sent to us by the controller; queue it for later reference. 3084 * If the queue fills up, then drop the older entries. 3085 */ 3086static void 3087aac_handle_aif(struct aac_softc *sc, struct aac_fib *fib) 3088{ 3089 struct aac_aif_command *aif; 3090 struct aac_container *co, *co_next; 3091 struct aac_mntinfo *mi; 3092 struct aac_mntinforesp *mir = NULL; 3093 u_int16_t rsize; 3094 int next, found; 3095 int count = 0, added = 0, i = 0; 3096 3097 debug_called(2); 3098 3099 aif = (struct aac_aif_command*)&fib->data[0]; 3100 aac_print_aif(sc, aif); 3101 3102 /* Is it an event that we should care about? */ 3103 switch (aif->command) { 3104 case AifCmdEventNotify: 3105 switch (aif->data.EN.type) { 3106 case AifEnAddContainer: 3107 case AifEnDeleteContainer: 3108 /* 3109 * A container was added or deleted, but the message 3110 * doesn't tell us anything else! Re-enumerate the 3111 * containers and sort things out. 3112 */ 3113 aac_alloc_sync_fib(sc, &fib); 3114 mi = (struct aac_mntinfo *)&fib->data[0]; 3115 do { 3116 /* 3117 * Ask the controller for its containers one at 3118 * a time. 3119 * XXX What if the controller's list changes 3120 * midway through this enumaration? 3121 * XXX This should be done async. 3122 */ 3123 bzero(mi, sizeof(struct aac_mntinfo)); 3124 mi->Command = VM_NameServe; 3125 mi->MntType = FT_FILESYS; 3126 mi->MntCount = i; 3127 rsize = sizeof(mir); 3128 if (aac_sync_fib(sc, ContainerCommand, 0, fib, 3129 sizeof(struct aac_mntinfo))) { 3130 printf("Error probing container %d\n", 3131 i); 3132 continue; 3133 } 3134 mir = (struct aac_mntinforesp *)&fib->data[0]; 3135 /* XXX Need to check if count changed */ 3136 count = mir->MntRespCount; 3137 /* 3138 * Check the container against our list. 3139 * co->co_found was already set to 0 in a 3140 * previous run. 3141 */ 3142 if ((mir->Status == ST_OK) && 3143 (mir->MntTable[0].VolType != CT_NONE)) { 3144 found = 0; 3145 TAILQ_FOREACH(co, 3146 &sc->aac_container_tqh, 3147 co_link) { 3148 if (co->co_mntobj.ObjectId == 3149 mir->MntTable[0].ObjectId) { 3150 co->co_found = 1; 3151 found = 1; 3152 break; 3153 } 3154 } 3155 /* 3156 * If the container matched, continue 3157 * in the list. 3158 */ 3159 if (found) { 3160 i++; 3161 continue; 3162 } 3163 3164 /* 3165 * This is a new container. Do all the 3166 * appropriate things to set it up. 3167 */ 3168 aac_add_container(sc, mir, 1); 3169 added = 1; 3170 } 3171 i++; 3172 } while ((i < count) && (i < AAC_MAX_CONTAINERS)); 3173 aac_release_sync_fib(sc); 3174 3175 /* 3176 * Go through our list of containers and see which ones 3177 * were not marked 'found'. Since the controller didn't 3178 * list them they must have been deleted. Do the 3179 * appropriate steps to destroy the device. Also reset 3180 * the co->co_found field. 3181 */ 3182 co = TAILQ_FIRST(&sc->aac_container_tqh); 3183 while (co != NULL) { 3184 if (co->co_found == 0) { 3185 mtx_unlock(&sc->aac_io_lock); 3186 mtx_lock(&Giant); 3187 device_delete_child(sc->aac_dev, 3188 co->co_disk); 3189 mtx_unlock(&Giant); 3190 mtx_lock(&sc->aac_io_lock); 3191 co_next = TAILQ_NEXT(co, co_link); 3192 mtx_lock(&sc->aac_container_lock); 3193 TAILQ_REMOVE(&sc->aac_container_tqh, co, 3194 co_link); 3195 mtx_unlock(&sc->aac_container_lock); 3196 free(co, M_AACBUF); 3197 co = co_next; 3198 } else { 3199 co->co_found = 0; 3200 co = TAILQ_NEXT(co, co_link); 3201 } 3202 } 3203 3204 /* Attach the newly created containers */ 3205 if (added) { 3206 mtx_unlock(&sc->aac_io_lock); 3207 mtx_lock(&Giant); 3208 bus_generic_attach(sc->aac_dev); 3209 mtx_unlock(&Giant); 3210 mtx_lock(&sc->aac_io_lock); 3211 } 3212 3213 break; 3214 3215 default: 3216 break; 3217 } 3218 3219 default: 3220 break; 3221 } 3222 3223 /* Copy the AIF data to the AIF queue for ioctl retrieval */ 3224 mtx_lock(&sc->aac_aifq_lock); 3225 next = (sc->aac_aifq_head + 1) % AAC_AIFQ_LENGTH; 3226 if (next != sc->aac_aifq_tail) { 3227 bcopy(aif, &sc->aac_aifq[next], sizeof(struct aac_aif_command)); 3228 sc->aac_aifq_head = next; 3229 3230 /* On the off chance that someone is sleeping for an aif... */ 3231 if (sc->aac_state & AAC_STATE_AIF_SLEEPER) 3232 wakeup(sc->aac_aifq); 3233 /* Wakeup any poll()ers */ 3234 selwakeuppri(&sc->rcv_select, PRIBIO); 3235 } 3236 mtx_unlock(&sc->aac_aifq_lock); 3237 3238 return; 3239} 3240 3241/* 3242 * Return the Revision of the driver to userspace and check to see if the 3243 * userspace app is possibly compatible. This is extremely bogus since 3244 * our driver doesn't follow Adaptec's versioning system. Cheat by just 3245 * returning what the card reported. 3246 */ 3247static int 3248aac_rev_check(struct aac_softc *sc, caddr_t udata) 3249{ 3250 struct aac_rev_check rev_check; 3251 struct aac_rev_check_resp rev_check_resp; 3252 int error = 0; 3253 3254 debug_called(2); 3255 3256 /* 3257 * Copyin the revision struct from userspace 3258 */ 3259 if ((error = copyin(udata, (caddr_t)&rev_check, 3260 sizeof(struct aac_rev_check))) != 0) { 3261 return error; 3262 } 3263 3264 debug(2, "Userland revision= %d\n", 3265 rev_check.callingRevision.buildNumber); 3266 3267 /* 3268 * Doctor up the response struct. 3269 */ 3270 rev_check_resp.possiblyCompatible = 1; 3271 rev_check_resp.adapterSWRevision.external.ul = 3272 sc->aac_revision.external.ul; 3273 rev_check_resp.adapterSWRevision.buildNumber = 3274 sc->aac_revision.buildNumber; 3275 3276 return(copyout((caddr_t)&rev_check_resp, udata, 3277 sizeof(struct aac_rev_check_resp))); 3278} 3279 3280/* 3281 * Pass the caller the next AIF in their queue 3282 */ 3283static int 3284aac_getnext_aif(struct aac_softc *sc, caddr_t arg) 3285{ 3286 struct get_adapter_fib_ioctl agf; 3287 int error; 3288 3289 debug_called(2); 3290 3291 if ((error = copyin(arg, &agf, sizeof(agf))) == 0) { 3292 3293 /* 3294 * Check the magic number that we gave the caller. 3295 */ 3296 if (agf.AdapterFibContext != (int)(uintptr_t)sc->aifthread) { 3297 error = EFAULT; 3298 } else { 3299 error = aac_return_aif(sc, agf.AifFib); 3300 if ((error == EAGAIN) && (agf.Wait)) { 3301 sc->aac_state |= AAC_STATE_AIF_SLEEPER; 3302 while (error == EAGAIN) { 3303 error = tsleep(sc->aac_aifq, PRIBIO | 3304 PCATCH, "aacaif", 0); 3305 if (error == 0) 3306 error = aac_return_aif(sc, 3307 agf.AifFib); 3308 } 3309 sc->aac_state &= ~AAC_STATE_AIF_SLEEPER; 3310 } 3311 } 3312 } 3313 return(error); 3314} 3315 3316/* 3317 * Hand the next AIF off the top of the queue out to userspace. 3318 */ 3319static int 3320aac_return_aif(struct aac_softc *sc, caddr_t uptr) 3321{ 3322 int next, error; 3323 3324 debug_called(2); 3325 3326 mtx_lock(&sc->aac_aifq_lock); 3327 if (sc->aac_aifq_tail == sc->aac_aifq_head) { 3328 mtx_unlock(&sc->aac_aifq_lock); 3329 return (EAGAIN); 3330 } 3331 3332 next = (sc->aac_aifq_tail + 1) % AAC_AIFQ_LENGTH; 3333 error = copyout(&sc->aac_aifq[next], uptr, 3334 sizeof(struct aac_aif_command)); 3335 if (error) 3336 device_printf(sc->aac_dev, 3337 "aac_return_aif: copyout returned %d\n", error); 3338 else 3339 sc->aac_aifq_tail = next; 3340 3341 mtx_unlock(&sc->aac_aifq_lock); 3342 return(error); 3343} 3344 3345static int 3346aac_get_pci_info(struct aac_softc *sc, caddr_t uptr) 3347{ 3348 struct aac_pci_info { 3349 u_int32_t bus; 3350 u_int32_t slot; 3351 } pciinf; 3352 int error; 3353 3354 debug_called(2); 3355 3356 pciinf.bus = pci_get_bus(sc->aac_dev); 3357 pciinf.slot = pci_get_slot(sc->aac_dev); 3358 3359 error = copyout((caddr_t)&pciinf, uptr, 3360 sizeof(struct aac_pci_info)); 3361 3362 return (error); 3363} 3364 3365/* 3366 * Give the userland some information about the container. The AAC arch 3367 * expects the driver to be a SCSI passthrough type driver, so it expects 3368 * the containers to have b:t:l numbers. Fake it. 3369 */ 3370static int 3371aac_query_disk(struct aac_softc *sc, caddr_t uptr) 3372{ 3373 struct aac_query_disk query_disk; 3374 struct aac_container *co; 3375 struct aac_disk *disk; 3376 int error, id; 3377 3378 debug_called(2); 3379 3380 disk = NULL; 3381 3382 error = copyin(uptr, (caddr_t)&query_disk, 3383 sizeof(struct aac_query_disk)); 3384 if (error) 3385 return (error); 3386 3387 id = query_disk.ContainerNumber; 3388 if (id == -1) 3389 return (EINVAL); 3390 3391 mtx_lock(&sc->aac_container_lock); 3392 TAILQ_FOREACH(co, &sc->aac_container_tqh, co_link) { 3393 if (co->co_mntobj.ObjectId == id) 3394 break; 3395 } 3396 3397 if (co == NULL) { 3398 query_disk.Valid = 0; 3399 query_disk.Locked = 0; 3400 query_disk.Deleted = 1; /* XXX is this right? */ 3401 } else { 3402 disk = device_get_softc(co->co_disk); 3403 query_disk.Valid = 1; 3404 query_disk.Locked = 3405 (disk->ad_flags & AAC_DISK_OPEN) ? 1 : 0; 3406 query_disk.Deleted = 0; 3407 query_disk.Bus = device_get_unit(sc->aac_dev); 3408 query_disk.Target = disk->unit; 3409 query_disk.Lun = 0; 3410 query_disk.UnMapped = 0; 3411 sprintf(&query_disk.diskDeviceName[0], "%s%d", 3412 disk->ad_disk->d_name, disk->ad_disk->d_unit); 3413 } 3414 mtx_unlock(&sc->aac_container_lock); 3415 3416 error = copyout((caddr_t)&query_disk, uptr, 3417 sizeof(struct aac_query_disk)); 3418 3419 return (error); 3420} 3421 3422static void 3423aac_get_bus_info(struct aac_softc *sc) 3424{ 3425 struct aac_fib *fib; 3426 struct aac_ctcfg *c_cmd; 3427 struct aac_ctcfg_resp *c_resp; 3428 struct aac_vmioctl *vmi; 3429 struct aac_vmi_businf_resp *vmi_resp; 3430 struct aac_getbusinf businfo; 3431 struct aac_sim *caminf; 3432 device_t child; 3433 int i, found, error; 3434 3435 mtx_lock(&sc->aac_io_lock); 3436 aac_alloc_sync_fib(sc, &fib); 3437 c_cmd = (struct aac_ctcfg *)&fib->data[0]; 3438 bzero(c_cmd, sizeof(struct aac_ctcfg)); 3439 3440 c_cmd->Command = VM_ContainerConfig; 3441 c_cmd->cmd = CT_GET_SCSI_METHOD; 3442 c_cmd->param = 0; 3443 3444 error = aac_sync_fib(sc, ContainerCommand, 0, fib, 3445 sizeof(struct aac_ctcfg)); 3446 if (error) { 3447 device_printf(sc->aac_dev, "Error %d sending " 3448 "VM_ContainerConfig command\n", error); 3449 aac_release_sync_fib(sc); 3450 mtx_unlock(&sc->aac_io_lock); 3451 return; 3452 } 3453 3454 c_resp = (struct aac_ctcfg_resp *)&fib->data[0]; 3455 if (c_resp->Status != ST_OK) { 3456 device_printf(sc->aac_dev, "VM_ContainerConfig returned 0x%x\n", 3457 c_resp->Status); 3458 aac_release_sync_fib(sc); 3459 mtx_unlock(&sc->aac_io_lock); 3460 return; 3461 } 3462 3463 sc->scsi_method_id = c_resp->param; 3464 3465 vmi = (struct aac_vmioctl *)&fib->data[0]; 3466 bzero(vmi, sizeof(struct aac_vmioctl)); 3467 3468 vmi->Command = VM_Ioctl; 3469 vmi->ObjType = FT_DRIVE; 3470 vmi->MethId = sc->scsi_method_id; 3471 vmi->ObjId = 0; 3472 vmi->IoctlCmd = GetBusInfo; 3473 3474 error = aac_sync_fib(sc, ContainerCommand, 0, fib, 3475 sizeof(struct aac_vmioctl)); 3476 if (error) { 3477 device_printf(sc->aac_dev, "Error %d sending VMIoctl command\n", 3478 error); 3479 aac_release_sync_fib(sc); 3480 mtx_unlock(&sc->aac_io_lock); 3481 return; 3482 } 3483 3484 vmi_resp = (struct aac_vmi_businf_resp *)&fib->data[0]; 3485 if (vmi_resp->Status != ST_OK) { 3486 device_printf(sc->aac_dev, "VM_Ioctl returned %d\n", 3487 vmi_resp->Status); 3488 aac_release_sync_fib(sc); 3489 mtx_unlock(&sc->aac_io_lock); 3490 return; 3491 } 3492 3493 bcopy(&vmi_resp->BusInf, &businfo, sizeof(struct aac_getbusinf)); 3494 aac_release_sync_fib(sc); 3495 mtx_unlock(&sc->aac_io_lock); 3496 3497 found = 0; 3498 for (i = 0; i < businfo.BusCount; i++) { 3499 if (businfo.BusValid[i] != AAC_BUS_VALID) 3500 continue; 3501 3502 caminf = (struct aac_sim *)malloc( sizeof(struct aac_sim), 3503 M_AACBUF, M_NOWAIT | M_ZERO); 3504 if (caminf == NULL) { 3505 device_printf(sc->aac_dev, 3506 "No memory to add passthrough bus %d\n", i); 3507 break; 3508 }; 3509 3510 child = device_add_child(sc->aac_dev, "aacp", -1); 3511 if (child == NULL) { 3512 device_printf(sc->aac_dev, 3513 "device_add_child failed for passthrough bus %d\n", 3514 i); 3515 free(caminf, M_AACBUF); 3516 break; 3517 } 3518 3519 caminf->TargetsPerBus = businfo.TargetsPerBus; 3520 caminf->BusNumber = i; 3521 caminf->InitiatorBusId = businfo.InitiatorBusId[i]; 3522 caminf->aac_sc = sc; 3523 caminf->sim_dev = child; 3524 3525 device_set_ivars(child, caminf); 3526 device_set_desc(child, "SCSI Passthrough Bus"); 3527 TAILQ_INSERT_TAIL(&sc->aac_sim_tqh, caminf, sim_link); 3528 3529 found = 1; 3530 } 3531 3532 if (found) 3533 bus_generic_attach(sc->aac_dev); 3534 3535 return; 3536} 3537