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