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