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