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