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/event.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 <sys/mplock2.h> 60 61 #include <bus/pci/pcireg.h> 62 #include <bus/pci/pcivar.h> 63 64 #include "aacreg.h" 65 #include "aac_ioctl.h" 66 #include "aacvar.h" 67 #include "aac_tables.h" 68 69 static void aac_startup(void *arg); 70 static void aac_add_container(struct aac_softc *sc, 71 struct aac_mntinforesp *mir, int f); 72 static void aac_get_bus_info(struct aac_softc *sc); 73 static int aac_shutdown(device_t dev); 74 75 /* Command Processing */ 76 static void aac_timeout(void *ssc); 77 static int aac_map_command(struct aac_command *cm); 78 static void aac_complete(void *context, int pending); 79 static int aac_bio_command(struct aac_softc *sc, struct aac_command **cmp); 80 static void aac_bio_complete(struct aac_command *cm); 81 static int aac_wait_command(struct aac_command *cm); 82 static void aac_command_thread(void *arg); 83 84 /* Command Buffer Management */ 85 static void aac_map_command_sg(void *arg, bus_dma_segment_t *segs, 86 int nseg, int error); 87 static void aac_map_command_helper(void *arg, bus_dma_segment_t *segs, 88 int nseg, int error); 89 static int aac_alloc_commands(struct aac_softc *sc); 90 static void aac_free_commands(struct aac_softc *sc); 91 static void aac_unmap_command(struct aac_command *cm); 92 93 /* Hardware Interface */ 94 static void aac_common_map(void *arg, bus_dma_segment_t *segs, int nseg, 95 int error); 96 static int aac_check_firmware(struct aac_softc *sc); 97 static int aac_init(struct aac_softc *sc); 98 static int aac_sync_command(struct aac_softc *sc, u_int32_t command, 99 u_int32_t arg0, u_int32_t arg1, u_int32_t arg2, 100 u_int32_t arg3, u_int32_t *sp); 101 static int aac_enqueue_fib(struct aac_softc *sc, int queue, 102 struct aac_command *cm); 103 static int aac_dequeue_fib(struct aac_softc *sc, int queue, 104 u_int32_t *fib_size, struct aac_fib **fib_addr); 105 static int aac_enqueue_response(struct aac_softc *sc, int queue, 106 struct aac_fib *fib); 107 108 /* Falcon/PPC interface */ 109 static int aac_fa_get_fwstatus(struct aac_softc *sc); 110 static void aac_fa_qnotify(struct aac_softc *sc, int qbit); 111 static int aac_fa_get_istatus(struct aac_softc *sc); 112 static void aac_fa_clear_istatus(struct aac_softc *sc, int mask); 113 static void aac_fa_set_mailbox(struct aac_softc *sc, u_int32_t command, 114 u_int32_t arg0, u_int32_t arg1, 115 u_int32_t arg2, u_int32_t arg3); 116 static int aac_fa_get_mailbox(struct aac_softc *sc, int mb); 117 static void aac_fa_set_interrupts(struct aac_softc *sc, int enable); 118 119 struct aac_interface aac_fa_interface = { 120 aac_fa_get_fwstatus, 121 aac_fa_qnotify, 122 aac_fa_get_istatus, 123 aac_fa_clear_istatus, 124 aac_fa_set_mailbox, 125 aac_fa_get_mailbox, 126 aac_fa_set_interrupts, 127 NULL, NULL, NULL 128 }; 129 130 /* StrongARM interface */ 131 static int aac_sa_get_fwstatus(struct aac_softc *sc); 132 static void aac_sa_qnotify(struct aac_softc *sc, int qbit); 133 static int aac_sa_get_istatus(struct aac_softc *sc); 134 static void aac_sa_clear_istatus(struct aac_softc *sc, int mask); 135 static void aac_sa_set_mailbox(struct aac_softc *sc, u_int32_t command, 136 u_int32_t arg0, u_int32_t arg1, 137 u_int32_t arg2, u_int32_t arg3); 138 static int aac_sa_get_mailbox(struct aac_softc *sc, int mb); 139 static void aac_sa_set_interrupts(struct aac_softc *sc, int enable); 140 141 struct aac_interface aac_sa_interface = { 142 aac_sa_get_fwstatus, 143 aac_sa_qnotify, 144 aac_sa_get_istatus, 145 aac_sa_clear_istatus, 146 aac_sa_set_mailbox, 147 aac_sa_get_mailbox, 148 aac_sa_set_interrupts, 149 NULL, NULL, NULL 150 }; 151 152 /* i960Rx interface */ 153 static int aac_rx_get_fwstatus(struct aac_softc *sc); 154 static void aac_rx_qnotify(struct aac_softc *sc, int qbit); 155 static int aac_rx_get_istatus(struct aac_softc *sc); 156 static void aac_rx_clear_istatus(struct aac_softc *sc, int mask); 157 static void aac_rx_set_mailbox(struct aac_softc *sc, u_int32_t command, 158 u_int32_t arg0, u_int32_t arg1, 159 u_int32_t arg2, u_int32_t arg3); 160 static int aac_rx_get_mailbox(struct aac_softc *sc, int mb); 161 static void aac_rx_set_interrupts(struct aac_softc *sc, int enable); 162 static int aac_rx_send_command(struct aac_softc *sc, struct aac_command *cm); 163 static int aac_rx_get_outb_queue(struct aac_softc *sc); 164 static void aac_rx_set_outb_queue(struct aac_softc *sc, int index); 165 166 struct aac_interface aac_rx_interface = { 167 aac_rx_get_fwstatus, 168 aac_rx_qnotify, 169 aac_rx_get_istatus, 170 aac_rx_clear_istatus, 171 aac_rx_set_mailbox, 172 aac_rx_get_mailbox, 173 aac_rx_set_interrupts, 174 aac_rx_send_command, 175 aac_rx_get_outb_queue, 176 aac_rx_set_outb_queue 177 }; 178 179 /* Rocket/MIPS interface */ 180 static int aac_rkt_get_fwstatus(struct aac_softc *sc); 181 static void aac_rkt_qnotify(struct aac_softc *sc, int qbit); 182 static int aac_rkt_get_istatus(struct aac_softc *sc); 183 static void aac_rkt_clear_istatus(struct aac_softc *sc, int mask); 184 static void aac_rkt_set_mailbox(struct aac_softc *sc, u_int32_t command, 185 u_int32_t arg0, u_int32_t arg1, 186 u_int32_t arg2, u_int32_t arg3); 187 static int aac_rkt_get_mailbox(struct aac_softc *sc, int mb); 188 static void aac_rkt_set_interrupts(struct aac_softc *sc, int enable); 189 static int aac_rkt_send_command(struct aac_softc *sc, struct aac_command *cm); 190 static int aac_rkt_get_outb_queue(struct aac_softc *sc); 191 static void aac_rkt_set_outb_queue(struct aac_softc *sc, int index); 192 193 struct aac_interface aac_rkt_interface = { 194 aac_rkt_get_fwstatus, 195 aac_rkt_qnotify, 196 aac_rkt_get_istatus, 197 aac_rkt_clear_istatus, 198 aac_rkt_set_mailbox, 199 aac_rkt_get_mailbox, 200 aac_rkt_set_interrupts, 201 aac_rkt_send_command, 202 aac_rkt_get_outb_queue, 203 aac_rkt_set_outb_queue 204 }; 205 206 /* Debugging and Diagnostics */ 207 static void aac_describe_controller(struct aac_softc *sc); 208 static char *aac_describe_code(struct aac_code_lookup *table, 209 u_int32_t code); 210 211 /* Management Interface */ 212 static d_open_t aac_open; 213 static d_close_t aac_close; 214 static d_ioctl_t aac_ioctl; 215 static d_kqfilter_t aac_kqfilter; 216 static void aac_filter_detach(struct knote *kn); 217 static int aac_filter(struct knote *kn, long hint); 218 static int aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib) __unused; 219 static void aac_handle_aif(struct aac_softc *sc, 220 struct aac_fib *fib); 221 static int aac_rev_check(struct aac_softc *sc, caddr_t udata); 222 static int aac_getnext_aif(struct aac_softc *sc, caddr_t arg); 223 static int aac_return_aif(struct aac_softc *sc, caddr_t uptr); 224 static int aac_query_disk(struct aac_softc *sc, caddr_t uptr); 225 static int aac_get_pci_info(struct aac_softc *sc, caddr_t uptr); 226 static void aac_ioctl_event(struct aac_softc *sc, 227 struct aac_event *event, void *arg); 228 229 #define AAC_CDEV_MAJOR 150 230 231 static struct dev_ops aac_ops = { 232 { "aac", AAC_CDEV_MAJOR, 0 }, 233 .d_open = aac_open, 234 .d_close = aac_close, 235 .d_ioctl = aac_ioctl, 236 .d_kqfilter = aac_kqfilter 237 }; 238 239 DECLARE_DUMMY_MODULE(aac); 240 241 MALLOC_DEFINE(M_AACBUF, "aacbuf", "Buffers for the AAC driver"); 242 243 /* sysctl node */ 244 SYSCTL_NODE(_hw, OID_AUTO, aac, CTLFLAG_RD, 0, "AAC driver parameters"); 245 246 /* 247 * Device Interface 248 */ 249 250 /* 251 * Initialise the controller and softc 252 */ 253 int 254 aac_attach(struct aac_softc *sc) 255 { 256 int error, unit; 257 258 debug_called(1); 259 callout_init(&sc->aac_watchdog); 260 261 /* 262 * Initialise per-controller queues. 263 */ 264 aac_initq_free(sc); 265 aac_initq_ready(sc); 266 aac_initq_busy(sc); 267 aac_initq_complete(sc); 268 aac_initq_bio(sc); 269 270 /* 271 * Initialise command-completion task. 272 */ 273 TASK_INIT(&sc->aac_task_complete, 0, aac_complete, sc); 274 275 /* mark controller as suspended until we get ourselves organised */ 276 sc->aac_state |= AAC_STATE_SUSPEND; 277 278 /* 279 * Check that the firmware on the card is supported. 280 */ 281 if ((error = aac_check_firmware(sc)) != 0) 282 return(error); 283 284 /* 285 * Initialize locks 286 */ 287 AAC_LOCK_INIT(&sc->aac_aifq_lock, "AAC AIF lock"); 288 AAC_LOCK_INIT(&sc->aac_io_lock, "AAC I/O lock"); 289 AAC_LOCK_INIT(&sc->aac_container_lock, "AAC container lock"); 290 TAILQ_INIT(&sc->aac_container_tqh); 291 TAILQ_INIT(&sc->aac_ev_cmfree); 292 293 294 /* Initialize the local AIF queue pointers */ 295 sc->aac_aifq_head = sc->aac_aifq_tail = AAC_AIFQ_LENGTH; 296 297 /* 298 * Initialise the adapter. 299 */ 300 if ((error = aac_init(sc)) != 0) 301 return(error); 302 303 /* 304 * Allocate and connect our interrupt. 305 */ 306 sc->aac_irq_rid = 0; 307 if ((sc->aac_irq = bus_alloc_resource_any(sc->aac_dev, SYS_RES_IRQ, 308 &sc->aac_irq_rid, 309 RF_SHAREABLE | 310 RF_ACTIVE)) == NULL) { 311 device_printf(sc->aac_dev, "can't allocate interrupt\n"); 312 return (EINVAL); 313 } 314 if (sc->flags & AAC_FLAGS_NEW_COMM) { 315 if (bus_setup_intr(sc->aac_dev, sc->aac_irq, 316 0, aac_new_intr, 317 sc, &sc->aac_intr, NULL)) { 318 device_printf(sc->aac_dev, "can't set up interrupt\n"); 319 return (EINVAL); 320 } 321 } else { 322 if (bus_setup_intr(sc->aac_dev, sc->aac_irq, 0, 323 aac_fast_intr, sc, &sc->aac_intr, NULL)) { 324 device_printf(sc->aac_dev, 325 "can't set up FAST interrupt\n"); 326 if (bus_setup_intr(sc->aac_dev, sc->aac_irq, 327 0, aac_fast_intr, 328 sc, &sc->aac_intr, NULL)) { 329 device_printf(sc->aac_dev, 330 "can't set up MPSAFE interrupt\n"); 331 return (EINVAL); 332 } 333 } 334 } 335 336 /* 337 * Print a little information about the controller. 338 */ 339 aac_describe_controller(sc); 340 341 /* 342 * Register to probe our containers later. 343 */ 344 sc->aac_ich.ich_func = aac_startup; 345 sc->aac_ich.ich_arg = sc; 346 sc->aac_ich.ich_desc = "aac"; 347 if (config_intrhook_establish(&sc->aac_ich) != 0) { 348 device_printf(sc->aac_dev, 349 "can't establish configuration hook\n"); 350 return(ENXIO); 351 } 352 353 /* 354 * Make the control device. 355 */ 356 unit = device_get_unit(sc->aac_dev); 357 sc->aac_dev_t = make_dev(&aac_ops, unit, UID_ROOT, GID_OPERATOR, 358 0640, "aac%d", unit); 359 sc->aac_dev_t->si_drv1 = sc; 360 reference_dev(sc->aac_dev_t); 361 362 /* Create the AIF thread */ 363 if (kthread_create(aac_command_thread, sc, 364 &sc->aifthread, "aac%daif", unit)) 365 panic("Could not create AIF thread\n"); 366 367 /* Register the shutdown method to only be called post-dump */ 368 if ((sc->eh = EVENTHANDLER_REGISTER(shutdown_post_sync, aac_shutdown, 369 sc->aac_dev, SHUTDOWN_PRI_DRIVER)) == NULL) 370 device_printf(sc->aac_dev, 371 "shutdown event registration failed\n"); 372 373 /* Register with CAM for the non-DASD devices */ 374 if ((sc->flags & AAC_FLAGS_ENABLE_CAM) != 0) { 375 TAILQ_INIT(&sc->aac_sim_tqh); 376 aac_get_bus_info(sc); 377 } 378 379 return(0); 380 } 381 382 void 383 aac_add_event(struct aac_softc *sc, struct aac_event *event) 384 { 385 386 switch (event->ev_type & AAC_EVENT_MASK) { 387 case AAC_EVENT_CMFREE: 388 TAILQ_INSERT_TAIL(&sc->aac_ev_cmfree, event, ev_links); 389 break; 390 default: 391 device_printf(sc->aac_dev, "aac_add event: unknown event %d\n", 392 event->ev_type); 393 break; 394 } 395 396 return; 397 } 398 399 /* 400 * Probe for containers, create disks. 401 */ 402 static void 403 aac_startup(void *arg) 404 { 405 struct aac_softc *sc; 406 struct aac_fib *fib; 407 struct aac_mntinfo *mi; 408 struct aac_mntinforesp *mir = NULL; 409 int count = 0, i = 0; 410 411 debug_called(1); 412 413 sc = (struct aac_softc *)arg; 414 415 /* disconnect ourselves from the intrhook chain */ 416 config_intrhook_disestablish(&sc->aac_ich); 417 418 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 419 aac_alloc_sync_fib(sc, &fib); 420 mi = (struct aac_mntinfo *)&fib->data[0]; 421 422 /* loop over possible containers */ 423 do { 424 /* request information on this container */ 425 bzero(mi, sizeof(struct aac_mntinfo)); 426 mi->Command = VM_NameServe; 427 mi->MntType = FT_FILESYS; 428 mi->MntCount = i; 429 if (aac_sync_fib(sc, ContainerCommand, 0, fib, 430 sizeof(struct aac_mntinfo))) { 431 device_printf(sc->aac_dev, 432 "error probing container %d", i); 433 434 continue; 435 } 436 437 mir = (struct aac_mntinforesp *)&fib->data[0]; 438 /* XXX Need to check if count changed */ 439 count = mir->MntRespCount; 440 aac_add_container(sc, mir, 0); 441 i++; 442 } while ((i < count) && (i < AAC_MAX_CONTAINERS)); 443 444 aac_release_sync_fib(sc); 445 AAC_LOCK_RELEASE(&sc->aac_io_lock); 446 447 /* poke the bus to actually attach the child devices */ 448 if (bus_generic_attach(sc->aac_dev)) 449 device_printf(sc->aac_dev, "bus_generic_attach failed\n"); 450 451 /* mark the controller up */ 452 sc->aac_state &= ~AAC_STATE_SUSPEND; 453 454 /* enable interrupts now */ 455 AAC_UNMASK_INTERRUPTS(sc); 456 } 457 458 /* 459 * Create a device to respresent a new container 460 */ 461 static void 462 aac_add_container(struct aac_softc *sc, struct aac_mntinforesp *mir, int f) 463 { 464 struct aac_container *co; 465 device_t child; 466 467 /* 468 * Check container volume type for validity. Note that many of 469 * the possible types may never show up. 470 */ 471 if ((mir->Status == ST_OK) && (mir->MntTable[0].VolType != CT_NONE)) { 472 co = (struct aac_container *)kmalloc(sizeof *co, M_AACBUF, 473 M_INTWAIT | M_ZERO); 474 debug(1, "id %x name '%.16s' size %u type %d", 475 mir->MntTable[0].ObjectId, 476 mir->MntTable[0].FileSystemName, 477 mir->MntTable[0].Capacity, mir->MntTable[0].VolType); 478 479 if ((child = device_add_child(sc->aac_dev, "aacd", -1)) == NULL) 480 device_printf(sc->aac_dev, "device_add_child failed\n"); 481 else 482 device_set_ivars(child, co); 483 device_set_desc(child, aac_describe_code(aac_container_types, 484 mir->MntTable[0].VolType)); 485 co->co_disk = child; 486 co->co_found = f; 487 bcopy(&mir->MntTable[0], &co->co_mntobj, 488 sizeof(struct aac_mntobj)); 489 AAC_LOCK_ACQUIRE(&sc->aac_container_lock); 490 TAILQ_INSERT_TAIL(&sc->aac_container_tqh, co, co_link); 491 AAC_LOCK_RELEASE(&sc->aac_container_lock); 492 } 493 } 494 495 /* 496 * Free all of the resources associated with (sc) 497 * 498 * Should not be called if the controller is active. 499 */ 500 void 501 aac_free(struct aac_softc *sc) 502 { 503 504 debug_called(1); 505 506 /* remove the control device */ 507 if (sc->aac_dev_t != NULL) 508 destroy_dev(sc->aac_dev_t); 509 510 /* throw away any FIB buffers, discard the FIB DMA tag */ 511 aac_free_commands(sc); 512 if (sc->aac_fib_dmat) 513 bus_dma_tag_destroy(sc->aac_fib_dmat); 514 515 kfree(sc->aac_commands, M_AACBUF); 516 517 /* destroy the common area */ 518 if (sc->aac_common) { 519 bus_dmamap_unload(sc->aac_common_dmat, sc->aac_common_dmamap); 520 bus_dmamem_free(sc->aac_common_dmat, sc->aac_common, 521 sc->aac_common_dmamap); 522 } 523 if (sc->aac_common_dmat) 524 bus_dma_tag_destroy(sc->aac_common_dmat); 525 526 /* disconnect the interrupt handler */ 527 if (sc->aac_intr) 528 bus_teardown_intr(sc->aac_dev, sc->aac_irq, sc->aac_intr); 529 if (sc->aac_irq != NULL) 530 bus_release_resource(sc->aac_dev, SYS_RES_IRQ, sc->aac_irq_rid, 531 sc->aac_irq); 532 533 /* destroy data-transfer DMA tag */ 534 if (sc->aac_buffer_dmat) 535 bus_dma_tag_destroy(sc->aac_buffer_dmat); 536 537 /* destroy the parent DMA tag */ 538 if (sc->aac_parent_dmat) 539 bus_dma_tag_destroy(sc->aac_parent_dmat); 540 541 /* release the register window mapping */ 542 if (sc->aac_regs_resource != NULL) { 543 bus_release_resource(sc->aac_dev, SYS_RES_MEMORY, 544 sc->aac_regs_rid, sc->aac_regs_resource); 545 } 546 dev_ops_remove_minor(&aac_ops, device_get_unit(sc->aac_dev)); 547 } 548 549 /* 550 * Disconnect from the controller completely, in preparation for unload. 551 */ 552 int 553 aac_detach(device_t dev) 554 { 555 struct aac_softc *sc; 556 struct aac_container *co; 557 struct aac_sim *sim; 558 int error; 559 560 debug_called(1); 561 562 sc = device_get_softc(dev); 563 564 callout_stop(&sc->aac_watchdog); 565 566 if (sc->aac_state & AAC_STATE_OPEN) 567 return(EBUSY); 568 569 /* Remove the child containers */ 570 while ((co = TAILQ_FIRST(&sc->aac_container_tqh)) != NULL) { 571 error = device_delete_child(dev, co->co_disk); 572 if (error) 573 return (error); 574 TAILQ_REMOVE(&sc->aac_container_tqh, co, co_link); 575 kfree(co, M_AACBUF); 576 } 577 578 /* Remove the CAM SIMs */ 579 while ((sim = TAILQ_FIRST(&sc->aac_sim_tqh)) != NULL) { 580 TAILQ_REMOVE(&sc->aac_sim_tqh, sim, sim_link); 581 error = device_delete_child(dev, sim->sim_dev); 582 if (error) 583 return (error); 584 kfree(sim, M_AACBUF); 585 } 586 587 if (sc->aifflags & AAC_AIFFLAGS_RUNNING) { 588 sc->aifflags |= AAC_AIFFLAGS_EXIT; 589 wakeup(sc->aifthread); 590 tsleep(sc->aac_dev, PCATCH, "aacdch", 30 * hz); 591 } 592 593 if (sc->aifflags & AAC_AIFFLAGS_RUNNING) 594 panic("Cannot shutdown AIF thread\n"); 595 596 if ((error = aac_shutdown(dev))) 597 return(error); 598 599 EVENTHANDLER_DEREGISTER(shutdown_post_sync, sc->eh); 600 601 aac_free(sc); 602 603 lockuninit(&sc->aac_aifq_lock); 604 lockuninit(&sc->aac_io_lock); 605 lockuninit(&sc->aac_container_lock); 606 607 return(0); 608 } 609 610 /* 611 * Bring the controller down to a dormant state and detach all child devices. 612 * 613 * This function is called before detach or system shutdown. 614 * 615 * Note that we can assume that the bioq on the controller is empty, as we won't 616 * allow shutdown if any device is open. 617 */ 618 static int 619 aac_shutdown(device_t dev) 620 { 621 struct aac_softc *sc; 622 struct aac_fib *fib; 623 struct aac_close_command *cc; 624 625 debug_called(1); 626 627 sc = device_get_softc(dev); 628 629 sc->aac_state |= AAC_STATE_SUSPEND; 630 631 /* 632 * Send a Container shutdown followed by a HostShutdown FIB to the 633 * controller to convince it that we don't want to talk to it anymore. 634 * We've been closed and all I/O completed already 635 */ 636 device_printf(sc->aac_dev, "shutting down controller..."); 637 638 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 639 aac_alloc_sync_fib(sc, &fib); 640 cc = (struct aac_close_command *)&fib->data[0]; 641 642 bzero(cc, sizeof(struct aac_close_command)); 643 cc->Command = VM_CloseAll; 644 cc->ContainerId = 0xffffffff; 645 if (aac_sync_fib(sc, ContainerCommand, 0, fib, 646 sizeof(struct aac_close_command))) 647 kprintf("FAILED.\n"); 648 else 649 kprintf("done\n"); 650 #if 0 651 else { 652 fib->data[0] = 0; 653 /* 654 * XXX Issuing this command to the controller makes it shut down 655 * but also keeps it from coming back up without a reset of the 656 * PCI bus. This is not desirable if you are just unloading the 657 * driver module with the intent to reload it later. 658 */ 659 if (aac_sync_fib(sc, FsaHostShutdown, AAC_FIBSTATE_SHUTDOWN, 660 fib, 1)) { 661 kprintf("FAILED.\n"); 662 } else { 663 kprintf("done.\n"); 664 } 665 } 666 #endif 667 668 AAC_MASK_INTERRUPTS(sc); 669 aac_release_sync_fib(sc); 670 AAC_LOCK_RELEASE(&sc->aac_io_lock); 671 672 return(0); 673 } 674 675 /* 676 * Bring the controller to a quiescent state, ready for system suspend. 677 */ 678 int 679 aac_suspend(device_t dev) 680 { 681 struct aac_softc *sc; 682 683 debug_called(1); 684 685 sc = device_get_softc(dev); 686 687 sc->aac_state |= AAC_STATE_SUSPEND; 688 689 AAC_MASK_INTERRUPTS(sc); 690 return(0); 691 } 692 693 /* 694 * Bring the controller back to a state ready for operation. 695 */ 696 int 697 aac_resume(device_t dev) 698 { 699 struct aac_softc *sc; 700 701 debug_called(1); 702 703 sc = device_get_softc(dev); 704 705 sc->aac_state &= ~AAC_STATE_SUSPEND; 706 AAC_UNMASK_INTERRUPTS(sc); 707 return(0); 708 } 709 710 /* 711 * Interrupt handler for NEW_COMM interface. 712 */ 713 void 714 aac_new_intr(void *arg) 715 { 716 struct aac_softc *sc; 717 u_int32_t index, fast; 718 struct aac_command *cm; 719 struct aac_fib *fib; 720 int i; 721 722 debug_called(2); 723 724 sc = (struct aac_softc *)arg; 725 726 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 727 while (1) { 728 index = AAC_GET_OUTB_QUEUE(sc); 729 if (index == 0xffffffff) 730 index = AAC_GET_OUTB_QUEUE(sc); 731 if (index == 0xffffffff) 732 break; 733 if (index & 2) { 734 if (index == 0xfffffffe) { 735 /* XXX This means that the controller wants 736 * more work. Ignore it for now. 737 */ 738 continue; 739 } 740 /* AIF */ 741 fib = (struct aac_fib *)kmalloc(sizeof *fib, M_AACBUF, 742 M_INTWAIT | M_ZERO); 743 index &= ~2; 744 for (i = 0; i < sizeof(struct aac_fib)/4; ++i) 745 ((u_int32_t *)fib)[i] = AAC_GETREG4(sc, index + i*4); 746 aac_handle_aif(sc, fib); 747 kfree(fib, M_AACBUF); 748 749 /* 750 * AIF memory is owned by the adapter, so let it 751 * know that we are done with it. 752 */ 753 AAC_SET_OUTB_QUEUE(sc, index); 754 AAC_CLEAR_ISTATUS(sc, AAC_DB_RESPONSE_READY); 755 } else { 756 fast = index & 1; 757 cm = sc->aac_commands + (index >> 2); 758 fib = cm->cm_fib; 759 if (fast) { 760 fib->Header.XferState |= AAC_FIBSTATE_DONEADAP; 761 *((u_int32_t *)(fib->data)) = AAC_ERROR_NORMAL; 762 } 763 aac_remove_busy(cm); 764 aac_unmap_command(cm); 765 cm->cm_flags |= AAC_CMD_COMPLETED; 766 767 /* is there a completion handler? */ 768 if (cm->cm_complete != NULL) { 769 cm->cm_complete(cm); 770 } else { 771 /* assume that someone is sleeping on this 772 * command 773 */ 774 wakeup(cm); 775 } 776 sc->flags &= ~AAC_QUEUE_FRZN; 777 } 778 } 779 /* see if we can start some more I/O */ 780 if ((sc->flags & AAC_QUEUE_FRZN) == 0) 781 aac_startio(sc); 782 783 AAC_LOCK_RELEASE(&sc->aac_io_lock); 784 } 785 786 void 787 aac_fast_intr(void *arg) 788 { 789 struct aac_softc *sc; 790 u_int16_t reason; 791 792 debug_called(2); 793 794 sc = (struct aac_softc *)arg; 795 796 /* 797 * Read the status register directly. This is faster than taking the 798 * driver lock and reading the queues directly. It also saves having 799 * to turn parts of the driver lock into a spin mutex, which would be 800 * ugly. 801 */ 802 reason = AAC_GET_ISTATUS(sc); 803 AAC_CLEAR_ISTATUS(sc, reason); 804 805 /* handle completion processing */ 806 if (reason & AAC_DB_RESPONSE_READY) 807 taskqueue_enqueue(taskqueue_swi, &sc->aac_task_complete); 808 809 /* controller wants to talk to us */ 810 if (reason & (AAC_DB_PRINTF | AAC_DB_COMMAND_READY)) { 811 /* 812 * XXX Make sure that we don't get fooled by strange messages 813 * that start with a NULL. 814 */ 815 if ((reason & AAC_DB_PRINTF) && 816 (sc->aac_common->ac_printf[0] == 0)) 817 sc->aac_common->ac_printf[0] = 32; 818 819 /* 820 * This might miss doing the actual wakeup. However, the 821 * ssleep that this is waking up has a timeout, so it will 822 * wake up eventually. AIFs and printfs are low enough 823 * priority that they can handle hanging out for a few seconds 824 * if needed. 825 */ 826 wakeup(sc->aifthread); 827 } 828 } 829 830 /* 831 * Command Processing 832 */ 833 834 /* 835 * Start as much queued I/O as possible on the controller 836 */ 837 void 838 aac_startio(struct aac_softc *sc) 839 { 840 struct aac_command *cm; 841 842 debug_called(2); 843 844 if (sc->flags & AAC_QUEUE_FRZN) 845 return; 846 847 for (;;) { 848 /* 849 * Try to get a command that's been put off for lack of 850 * resources 851 */ 852 cm = aac_dequeue_ready(sc); 853 854 /* 855 * Try to build a command off the bio queue (ignore error 856 * return) 857 */ 858 if (cm == NULL) 859 aac_bio_command(sc, &cm); 860 861 /* nothing to do? */ 862 if (cm == NULL) 863 break; 864 865 /* 866 * Try to give the command to the controller. Any error is 867 * catastrophic since it means that bus_dmamap_load() failed. 868 */ 869 if (aac_map_command(cm) != 0) 870 panic("aac: error mapping command %p\n", cm); 871 } 872 } 873 874 /* 875 * Deliver a command to the controller; allocate controller resources at the 876 * last moment when possible. 877 */ 878 static int 879 aac_map_command(struct aac_command *cm) 880 { 881 struct aac_softc *sc; 882 int error; 883 884 debug_called(2); 885 886 sc = cm->cm_sc; 887 error = 0; 888 889 /* don't map more than once */ 890 if (cm->cm_flags & AAC_CMD_MAPPED) 891 panic("aac: command %p already mapped", cm); 892 893 if (cm->cm_datalen != 0) { 894 error = bus_dmamap_load(sc->aac_buffer_dmat, cm->cm_datamap, 895 cm->cm_data, cm->cm_datalen, 896 aac_map_command_sg, cm, 0); 897 if (error == EINPROGRESS) { 898 debug(1, "freezing queue\n"); 899 sc->flags |= AAC_QUEUE_FRZN; 900 error = 0; 901 } 902 } else { 903 aac_map_command_sg(cm, NULL, 0, 0); 904 } 905 return (error); 906 } 907 908 /* 909 * Handle notification of one or more FIBs coming from the controller. 910 */ 911 static void 912 aac_command_thread(void *arg) 913 { 914 struct aac_softc *sc = arg; 915 struct aac_fib *fib; 916 u_int32_t fib_size; 917 int size, retval; 918 919 get_mplock(); 920 debug_called(2); 921 922 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 923 sc->aifflags = AAC_AIFFLAGS_RUNNING; 924 925 while ((sc->aifflags & AAC_AIFFLAGS_EXIT) == 0) { 926 retval = 0; 927 if ((sc->aifflags & AAC_AIFFLAGS_PENDING) == 0) { 928 tsleep_interlock(sc->aifthread, 0); 929 AAC_LOCK_RELEASE(&sc->aac_io_lock); 930 retval = tsleep(sc->aifthread, PINTERLOCKED, 931 "aifthd", AAC_PERIODIC_INTERVAL * hz); 932 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 933 } 934 /* 935 * First see if any FIBs need to be allocated. This needs 936 * to be called without the driver lock because contigmalloc 937 * will grab Giant, and would result in an LOR. 938 */ 939 if ((sc->aifflags & AAC_AIFFLAGS_ALLOCFIBS) != 0) { 940 AAC_LOCK_RELEASE(&sc->aac_io_lock); 941 aac_alloc_commands(sc); 942 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 943 sc->aifflags &= ~AAC_AIFFLAGS_ALLOCFIBS; 944 aac_startio(sc); 945 } 946 947 /* 948 * While we're here, check to see if any commands are stuck. 949 * This is pretty low-priority, so it's ok if it doesn't 950 * always fire. 951 */ 952 if (retval == EWOULDBLOCK) 953 aac_timeout(sc); 954 955 /* Check the hardware printf message buffer */ 956 if (sc->aac_common->ac_printf[0] != 0) 957 aac_print_printf(sc); 958 959 /* Also check to see if the adapter has a command for us. */ 960 if (sc->flags & AAC_FLAGS_NEW_COMM) 961 continue; 962 for (;;) { 963 if (aac_dequeue_fib(sc, AAC_HOST_NORM_CMD_QUEUE, 964 &fib_size, &fib)) 965 break; 966 967 AAC_PRINT_FIB(sc, fib); 968 969 switch (fib->Header.Command) { 970 case AifRequest: 971 aac_handle_aif(sc, fib); 972 break; 973 default: 974 device_printf(sc->aac_dev, "unknown command " 975 "from controller\n"); 976 break; 977 } 978 979 if ((fib->Header.XferState == 0) || 980 (fib->Header.StructType != AAC_FIBTYPE_TFIB)) { 981 break; 982 } 983 984 /* Return the AIF to the controller. */ 985 if (fib->Header.XferState & AAC_FIBSTATE_FROMADAP) { 986 fib->Header.XferState |= AAC_FIBSTATE_DONEHOST; 987 *(AAC_FSAStatus*)fib->data = ST_OK; 988 989 /* XXX Compute the Size field? */ 990 size = fib->Header.Size; 991 if (size > sizeof(struct aac_fib)) { 992 size = sizeof(struct aac_fib); 993 fib->Header.Size = size; 994 } 995 /* 996 * Since we did not generate this command, it 997 * cannot go through the normal 998 * enqueue->startio chain. 999 */ 1000 aac_enqueue_response(sc, 1001 AAC_ADAP_NORM_RESP_QUEUE, 1002 fib); 1003 } 1004 } 1005 } 1006 sc->aifflags &= ~AAC_AIFFLAGS_RUNNING; 1007 AAC_LOCK_RELEASE(&sc->aac_io_lock); 1008 wakeup(sc->aac_dev); 1009 1010 rel_mplock(); 1011 } 1012 1013 /* 1014 * Process completed commands. 1015 */ 1016 static void 1017 aac_complete(void *context, int pending) 1018 { 1019 struct aac_softc *sc; 1020 struct aac_command *cm; 1021 struct aac_fib *fib; 1022 u_int32_t fib_size; 1023 1024 debug_called(2); 1025 1026 sc = (struct aac_softc *)context; 1027 1028 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 1029 1030 /* pull completed commands off the queue */ 1031 for (;;) { 1032 /* look for completed FIBs on our queue */ 1033 if (aac_dequeue_fib(sc, AAC_HOST_NORM_RESP_QUEUE, &fib_size, 1034 &fib)) 1035 break; /* nothing to do */ 1036 1037 /* get the command, unmap and queue for later processing */ 1038 cm = sc->aac_commands + fib->Header.SenderData; 1039 if (cm == NULL) { 1040 AAC_PRINT_FIB(sc, fib); 1041 break; 1042 } 1043 aac_remove_busy(cm); 1044 aac_unmap_command(cm); /* XXX defer? */ 1045 cm->cm_flags |= AAC_CMD_COMPLETED; 1046 1047 /* is there a completion handler? */ 1048 if (cm->cm_complete != NULL) { 1049 cm->cm_complete(cm); 1050 } else { 1051 /* assume that someone is sleeping on this command */ 1052 wakeup(cm); 1053 } 1054 } 1055 1056 /* see if we can start some more I/O */ 1057 sc->flags &= ~AAC_QUEUE_FRZN; 1058 aac_startio(sc); 1059 1060 AAC_LOCK_RELEASE(&sc->aac_io_lock); 1061 } 1062 1063 /* 1064 * Handle a bio submitted from a disk device. 1065 */ 1066 void 1067 aac_submit_bio(struct aac_disk *ad, struct bio *bio) 1068 { 1069 struct aac_softc *sc; 1070 1071 debug_called(2); 1072 1073 bio->bio_driver_info = ad; 1074 sc = ad->ad_controller; 1075 1076 /* queue the BIO and try to get some work done */ 1077 aac_enqueue_bio(sc, bio); 1078 aac_startio(sc); 1079 } 1080 1081 /* 1082 * Get a bio and build a command to go with it. 1083 */ 1084 static int 1085 aac_bio_command(struct aac_softc *sc, struct aac_command **cmp) 1086 { 1087 struct aac_command *cm; 1088 struct aac_fib *fib; 1089 struct aac_disk *ad; 1090 struct bio *bio; 1091 struct buf *bp; 1092 1093 debug_called(2); 1094 1095 /* get the resources we will need */ 1096 cm = NULL; 1097 bio = NULL; 1098 if (aac_alloc_command(sc, &cm)) /* get a command */ 1099 goto fail; 1100 if ((bio = aac_dequeue_bio(sc)) == NULL) 1101 goto fail; 1102 1103 /* fill out the command */ 1104 bp = bio->bio_buf; 1105 cm->cm_data = (void *)bp->b_data; 1106 cm->cm_datalen = bp->b_bcount; 1107 cm->cm_complete = aac_bio_complete; 1108 cm->cm_private = bio; 1109 cm->cm_timestamp = time_second; 1110 cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE; 1111 1112 /* build the FIB */ 1113 fib = cm->cm_fib; 1114 fib->Header.Size = sizeof(struct aac_fib_header); 1115 fib->Header.XferState = 1116 AAC_FIBSTATE_HOSTOWNED | 1117 AAC_FIBSTATE_INITIALISED | 1118 AAC_FIBSTATE_EMPTY | 1119 AAC_FIBSTATE_FROMHOST | 1120 AAC_FIBSTATE_REXPECTED | 1121 AAC_FIBSTATE_NORM | 1122 AAC_FIBSTATE_ASYNC | 1123 AAC_FIBSTATE_FAST_RESPONSE; 1124 1125 /* build the read/write request */ 1126 ad = (struct aac_disk *)bio->bio_driver_info; 1127 1128 if (sc->flags & AAC_FLAGS_RAW_IO) { 1129 struct aac_raw_io *raw; 1130 raw = (struct aac_raw_io *)&fib->data[0]; 1131 fib->Header.Command = RawIo; 1132 raw->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE; 1133 raw->ByteCount = bp->b_bcount; 1134 raw->ContainerId = ad->ad_container->co_mntobj.ObjectId; 1135 raw->BpTotal = 0; 1136 raw->BpComplete = 0; 1137 fib->Header.Size += sizeof(struct aac_raw_io); 1138 cm->cm_sgtable = (struct aac_sg_table *)&raw->SgMapRaw; 1139 if (bp->b_cmd == BUF_CMD_READ) { 1140 raw->Flags = 1; 1141 cm->cm_flags |= AAC_CMD_DATAIN; 1142 } else { 1143 raw->Flags = 0; 1144 cm->cm_flags |= AAC_CMD_DATAOUT; 1145 } 1146 } else if ((sc->flags & AAC_FLAGS_SG_64BIT) == 0) { 1147 fib->Header.Command = ContainerCommand; 1148 if (bp->b_cmd == BUF_CMD_READ) { 1149 struct aac_blockread *br; 1150 br = (struct aac_blockread *)&fib->data[0]; 1151 br->Command = VM_CtBlockRead; 1152 br->ContainerId = ad->ad_container->co_mntobj.ObjectId; 1153 br->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE; 1154 br->ByteCount = bp->b_bcount; 1155 fib->Header.Size += sizeof(struct aac_blockread); 1156 cm->cm_sgtable = &br->SgMap; 1157 cm->cm_flags |= AAC_CMD_DATAIN; 1158 } else { 1159 struct aac_blockwrite *bw; 1160 bw = (struct aac_blockwrite *)&fib->data[0]; 1161 bw->Command = VM_CtBlockWrite; 1162 bw->ContainerId = ad->ad_container->co_mntobj.ObjectId; 1163 bw->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE; 1164 bw->ByteCount = bp->b_bcount; 1165 bw->Stable = CUNSTABLE; 1166 fib->Header.Size += sizeof(struct aac_blockwrite); 1167 cm->cm_flags |= AAC_CMD_DATAOUT; 1168 cm->cm_sgtable = &bw->SgMap; 1169 } 1170 } else { 1171 fib->Header.Command = ContainerCommand64; 1172 if (bp->b_cmd == BUF_CMD_READ) { 1173 struct aac_blockread64 *br; 1174 br = (struct aac_blockread64 *)&fib->data[0]; 1175 br->Command = VM_CtHostRead64; 1176 br->ContainerId = ad->ad_container->co_mntobj.ObjectId; 1177 br->SectorCount = bp->b_bcount / AAC_BLOCK_SIZE; 1178 br->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE; 1179 br->Pad = 0; 1180 br->Flags = 0; 1181 fib->Header.Size += sizeof(struct aac_blockread64); 1182 cm->cm_flags |= AAC_CMD_DATAOUT; 1183 cm->cm_sgtable = (struct aac_sg_table *)&br->SgMap64; 1184 } else { 1185 struct aac_blockwrite64 *bw; 1186 bw = (struct aac_blockwrite64 *)&fib->data[0]; 1187 bw->Command = VM_CtHostWrite64; 1188 bw->ContainerId = ad->ad_container->co_mntobj.ObjectId; 1189 bw->SectorCount = bp->b_bcount / AAC_BLOCK_SIZE; 1190 bw->BlockNumber = bio->bio_offset / AAC_BLOCK_SIZE; 1191 bw->Pad = 0; 1192 bw->Flags = 0; 1193 fib->Header.Size += sizeof(struct aac_blockwrite64); 1194 cm->cm_flags |= AAC_CMD_DATAIN; 1195 cm->cm_sgtable = (struct aac_sg_table *)&bw->SgMap64; 1196 } 1197 } 1198 1199 *cmp = cm; 1200 return(0); 1201 1202 fail: 1203 if (bio != NULL) 1204 aac_enqueue_bio(sc, bio); 1205 if (cm != NULL) 1206 aac_release_command(cm); 1207 return(ENOMEM); 1208 } 1209 1210 /* 1211 * Handle a bio-instigated command that has been completed. 1212 */ 1213 static void 1214 aac_bio_complete(struct aac_command *cm) 1215 { 1216 struct aac_blockread_response *brr; 1217 struct aac_blockwrite_response *bwr; 1218 struct bio *bio; 1219 struct buf *bp; 1220 const char *code; 1221 AAC_FSAStatus status; 1222 1223 /* fetch relevant status and then release the command */ 1224 bio = (struct bio *)cm->cm_private; 1225 bp = bio->bio_buf; 1226 if (bp->b_cmd == BUF_CMD_READ) { 1227 brr = (struct aac_blockread_response *)&cm->cm_fib->data[0]; 1228 status = brr->Status; 1229 } else { 1230 bwr = (struct aac_blockwrite_response *)&cm->cm_fib->data[0]; 1231 status = bwr->Status; 1232 } 1233 aac_release_command(cm); 1234 1235 /* fix up the bio based on status */ 1236 if (status == ST_OK) { 1237 bp->b_resid = 0; 1238 code = 0; 1239 } else { 1240 bp->b_error = EIO; 1241 bp->b_flags |= B_ERROR; 1242 /* pass an error string out to the disk layer */ 1243 code = aac_describe_code(aac_command_status_table, status); 1244 } 1245 aac_biodone(bio, code); 1246 } 1247 1248 /* 1249 * Dump a block of data to the controller. If the queue is full, tell the 1250 * caller to hold off and wait for the queue to drain. 1251 */ 1252 int 1253 aac_dump_enqueue(struct aac_disk *ad, u_int64_t lba, void *data, int dumppages) 1254 { 1255 struct aac_softc *sc; 1256 struct aac_command *cm; 1257 struct aac_fib *fib; 1258 struct aac_blockwrite *bw; 1259 1260 sc = ad->ad_controller; 1261 cm = NULL; 1262 1263 KKASSERT(lba <= 0x100000000ULL); 1264 1265 if (aac_alloc_command(sc, &cm)) 1266 return (EBUSY); 1267 1268 /* fill out the command */ 1269 cm->cm_data = data; 1270 cm->cm_datalen = dumppages * PAGE_SIZE; 1271 cm->cm_complete = NULL; 1272 cm->cm_private = NULL; 1273 cm->cm_timestamp = time_second; 1274 cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE; 1275 1276 /* build the FIB */ 1277 fib = cm->cm_fib; 1278 fib->Header.XferState = 1279 AAC_FIBSTATE_HOSTOWNED | 1280 AAC_FIBSTATE_INITIALISED | 1281 AAC_FIBSTATE_FROMHOST | 1282 AAC_FIBSTATE_REXPECTED | 1283 AAC_FIBSTATE_NORM; 1284 fib->Header.Command = ContainerCommand; 1285 fib->Header.Size = sizeof(struct aac_fib_header); 1286 1287 bw = (struct aac_blockwrite *)&fib->data[0]; 1288 bw->Command = VM_CtBlockWrite; 1289 bw->ContainerId = ad->ad_container->co_mntobj.ObjectId; 1290 bw->BlockNumber = lba; 1291 bw->ByteCount = dumppages * PAGE_SIZE; 1292 bw->Stable = CUNSTABLE; /* XXX what's appropriate here? */ 1293 fib->Header.Size += sizeof(struct aac_blockwrite); 1294 cm->cm_flags |= AAC_CMD_DATAOUT; 1295 cm->cm_sgtable = &bw->SgMap; 1296 1297 return (aac_map_command(cm)); 1298 } 1299 1300 /* 1301 * Wait for the card's queue to drain when dumping. Also check for monitor 1302 * kprintf's 1303 */ 1304 void 1305 aac_dump_complete(struct aac_softc *sc) 1306 { 1307 struct aac_fib *fib; 1308 struct aac_command *cm; 1309 u_int16_t reason; 1310 u_int32_t pi, ci, fib_size; 1311 1312 do { 1313 reason = AAC_GET_ISTATUS(sc); 1314 if (reason & AAC_DB_RESPONSE_READY) { 1315 AAC_CLEAR_ISTATUS(sc, AAC_DB_RESPONSE_READY); 1316 for (;;) { 1317 if (aac_dequeue_fib(sc, 1318 AAC_HOST_NORM_RESP_QUEUE, 1319 &fib_size, &fib)) 1320 break; 1321 cm = (struct aac_command *) 1322 fib->Header.SenderData; 1323 if (cm == NULL) 1324 AAC_PRINT_FIB(sc, fib); 1325 else { 1326 aac_remove_busy(cm); 1327 aac_unmap_command(cm); 1328 aac_enqueue_complete(cm); 1329 aac_release_command(cm); 1330 } 1331 } 1332 } 1333 if (reason & AAC_DB_PRINTF) { 1334 AAC_CLEAR_ISTATUS(sc, AAC_DB_PRINTF); 1335 aac_print_printf(sc); 1336 } 1337 pi = sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][ 1338 AAC_PRODUCER_INDEX]; 1339 ci = sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][ 1340 AAC_CONSUMER_INDEX]; 1341 } while (ci != pi); 1342 1343 return; 1344 } 1345 1346 /* 1347 * Submit a command to the controller, return when it completes. 1348 * XXX This is very dangerous! If the card has gone out to lunch, we could 1349 * be stuck here forever. At the same time, signals are not caught 1350 * because there is a risk that a signal could wakeup the sleep before 1351 * the card has a chance to complete the command. Since there is no way 1352 * to cancel a command that is in progress, we can't protect against the 1353 * card completing a command late and spamming the command and data 1354 * memory. So, we are held hostage until the command completes. 1355 */ 1356 static int 1357 aac_wait_command(struct aac_command *cm) 1358 { 1359 struct aac_softc *sc; 1360 int error; 1361 1362 debug_called(2); 1363 1364 sc = cm->cm_sc; 1365 1366 /* Put the command on the ready queue and get things going */ 1367 cm->cm_queue = AAC_ADAP_NORM_CMD_QUEUE; 1368 aac_enqueue_ready(cm); 1369 aac_startio(sc); 1370 /* Lock is held */ 1371 KKASSERT(lockstatus(&sc->aac_io_lock, curthread) != 0); 1372 tsleep_interlock(cm, 0); 1373 AAC_LOCK_RELEASE(&sc->aac_io_lock); 1374 error = tsleep(cm, PINTERLOCKED, "aacwait", 0); 1375 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 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 struct filterops aac_filterops = 3067 { FILTEROP_ISFD, NULL, aac_filter_detach, aac_filter }; 3068 3069 static int 3070 aac_kqfilter(struct dev_kqfilter_args *ap) 3071 { 3072 cdev_t dev = ap->a_head.a_dev; 3073 struct aac_softc *sc = dev->si_drv1; 3074 struct knote *kn = ap->a_kn; 3075 struct klist *klist; 3076 3077 ap->a_result = 0; 3078 3079 switch (kn->kn_filter) { 3080 case EVFILT_READ: 3081 kn->kn_fop = &aac_filterops; 3082 kn->kn_hook = (caddr_t)sc; 3083 break; 3084 default: 3085 ap->a_result = EOPNOTSUPP; 3086 return (0); 3087 } 3088 3089 klist = &sc->rcv_kq.ki_note; 3090 knote_insert(klist, kn); 3091 3092 return (0); 3093 } 3094 3095 static void 3096 aac_filter_detach(struct knote *kn) 3097 { 3098 struct aac_softc *sc = (struct aac_softc *)kn->kn_hook; 3099 struct klist *klist; 3100 3101 klist = &sc->rcv_kq.ki_note; 3102 knote_remove(klist, kn); 3103 } 3104 3105 static int 3106 aac_filter(struct knote *kn, long hint) 3107 { 3108 struct aac_softc *sc = (struct aac_softc *)kn->kn_hook; 3109 int ready = 0; 3110 3111 AAC_LOCK_ACQUIRE(&sc->aac_aifq_lock); 3112 if (sc->aac_aifq_tail != sc->aac_aifq_head) 3113 ready = 1; 3114 AAC_LOCK_RELEASE(&sc->aac_aifq_lock); 3115 3116 return (ready); 3117 } 3118 3119 3120 static void 3121 aac_ioctl_event(struct aac_softc *sc, struct aac_event *event, void *arg) 3122 { 3123 3124 switch (event->ev_type) { 3125 case AAC_EVENT_CMFREE: 3126 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 3127 if (aac_alloc_command(sc, (struct aac_command **)arg)) { 3128 aac_add_event(sc, event); 3129 AAC_LOCK_RELEASE(&sc->aac_io_lock); 3130 return; 3131 } 3132 kfree(event, M_AACBUF); 3133 wakeup(arg); 3134 AAC_LOCK_RELEASE(&sc->aac_io_lock); 3135 break; 3136 default: 3137 break; 3138 } 3139 } 3140 3141 /* 3142 * Send a FIB supplied from userspace 3143 */ 3144 static int 3145 aac_ioctl_sendfib(struct aac_softc *sc, caddr_t ufib) 3146 { 3147 struct aac_command *cm; 3148 int size, error; 3149 3150 debug_called(2); 3151 3152 cm = NULL; 3153 3154 /* 3155 * Get a command 3156 */ 3157 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 3158 if (aac_alloc_command(sc, &cm)) { 3159 struct aac_event *event; 3160 3161 event = kmalloc(sizeof(struct aac_event), M_AACBUF, 3162 M_INTWAIT | M_ZERO); 3163 event->ev_type = AAC_EVENT_CMFREE; 3164 event->ev_callback = aac_ioctl_event; 3165 event->ev_arg = &cm; 3166 aac_add_event(sc, event); 3167 tsleep_interlock(&cm, 0); 3168 AAC_LOCK_RELEASE(&sc->aac_io_lock); 3169 tsleep(&cm, PINTERLOCKED, "sendfib", 0); 3170 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 3171 } 3172 AAC_LOCK_RELEASE(&sc->aac_io_lock); 3173 3174 /* 3175 * Fetch the FIB header, then re-copy to get data as well. 3176 */ 3177 if ((error = copyin(ufib, cm->cm_fib, 3178 sizeof(struct aac_fib_header))) != 0) 3179 goto out; 3180 size = cm->cm_fib->Header.Size + sizeof(struct aac_fib_header); 3181 if (size > sizeof(struct aac_fib)) { 3182 device_printf(sc->aac_dev, "incoming FIB oversized (%d > %zd)\n", 3183 size, sizeof(struct aac_fib)); 3184 size = sizeof(struct aac_fib); 3185 } 3186 if ((error = copyin(ufib, cm->cm_fib, size)) != 0) 3187 goto out; 3188 cm->cm_fib->Header.Size = size; 3189 cm->cm_timestamp = time_second; 3190 3191 /* 3192 * Pass the FIB to the controller, wait for it to complete. 3193 */ 3194 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 3195 if ((error = aac_wait_command(cm)) != 0) { 3196 device_printf(sc->aac_dev, 3197 "aac_wait_command return %d\n", error); 3198 goto out; 3199 } 3200 AAC_LOCK_RELEASE(&sc->aac_io_lock); 3201 3202 /* 3203 * Copy the FIB and data back out to the caller. 3204 */ 3205 size = cm->cm_fib->Header.Size; 3206 if (size > sizeof(struct aac_fib)) { 3207 device_printf(sc->aac_dev, "outbound FIB oversized (%d > %zd)\n", 3208 size, sizeof(struct aac_fib)); 3209 size = sizeof(struct aac_fib); 3210 } 3211 error = copyout(cm->cm_fib, ufib, size); 3212 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 3213 3214 out: 3215 if (cm != NULL) { 3216 aac_release_command(cm); 3217 } 3218 3219 AAC_LOCK_RELEASE(&sc->aac_io_lock); 3220 return(error); 3221 } 3222 3223 /* 3224 * Handle an AIF sent to us by the controller; queue it for later reference. 3225 * If the queue fills up, then drop the older entries. 3226 */ 3227 static void 3228 aac_handle_aif(struct aac_softc *sc, struct aac_fib *fib) 3229 { 3230 struct aac_aif_command *aif; 3231 struct aac_container *co, *co_next; 3232 struct aac_mntinfo *mi; 3233 struct aac_mntinforesp *mir = NULL; 3234 u_int16_t rsize; 3235 int next, found; 3236 int count = 0, added = 0, i = 0; 3237 3238 debug_called(2); 3239 3240 aif = (struct aac_aif_command*)&fib->data[0]; 3241 aac_print_aif(sc, aif); 3242 3243 /* Is it an event that we should care about? */ 3244 switch (aif->command) { 3245 case AifCmdEventNotify: 3246 switch (aif->data.EN.type) { 3247 case AifEnAddContainer: 3248 case AifEnDeleteContainer: 3249 /* 3250 * A container was added or deleted, but the message 3251 * doesn't tell us anything else! Re-enumerate the 3252 * containers and sort things out. 3253 */ 3254 aac_alloc_sync_fib(sc, &fib); 3255 mi = (struct aac_mntinfo *)&fib->data[0]; 3256 do { 3257 /* 3258 * Ask the controller for its containers one at 3259 * a time. 3260 * XXX What if the controller's list changes 3261 * midway through this enumaration? 3262 * XXX This should be done async. 3263 */ 3264 bzero(mi, sizeof(struct aac_mntinfo)); 3265 mi->Command = VM_NameServe; 3266 mi->MntType = FT_FILESYS; 3267 mi->MntCount = i; 3268 rsize = sizeof(mir); 3269 if (aac_sync_fib(sc, ContainerCommand, 0, fib, 3270 sizeof(struct aac_mntinfo))) { 3271 device_printf(sc->aac_dev, 3272 "Error probing container %d\n", i); 3273 3274 continue; 3275 } 3276 mir = (struct aac_mntinforesp *)&fib->data[0]; 3277 /* XXX Need to check if count changed */ 3278 count = mir->MntRespCount; 3279 3280 /* 3281 * Check the container against our list. 3282 * co->co_found was already set to 0 in a 3283 * previous run. 3284 */ 3285 if ((mir->Status == ST_OK) && 3286 (mir->MntTable[0].VolType != CT_NONE)) { 3287 found = 0; 3288 TAILQ_FOREACH(co, 3289 &sc->aac_container_tqh, 3290 co_link) { 3291 if (co->co_mntobj.ObjectId == 3292 mir->MntTable[0].ObjectId) { 3293 co->co_found = 1; 3294 found = 1; 3295 break; 3296 } 3297 } 3298 /* 3299 * If the container matched, continue 3300 * in the list. 3301 */ 3302 if (found) { 3303 i++; 3304 continue; 3305 } 3306 3307 /* 3308 * This is a new container. Do all the 3309 * appropriate things to set it up. 3310 */ 3311 aac_add_container(sc, mir, 1); 3312 added = 1; 3313 } 3314 i++; 3315 } while ((i < count) && (i < AAC_MAX_CONTAINERS)); 3316 aac_release_sync_fib(sc); 3317 3318 /* 3319 * Go through our list of containers and see which ones 3320 * were not marked 'found'. Since the controller didn't 3321 * list them they must have been deleted. Do the 3322 * appropriate steps to destroy the device. Also reset 3323 * the co->co_found field. 3324 */ 3325 co = TAILQ_FIRST(&sc->aac_container_tqh); 3326 while (co != NULL) { 3327 if (co->co_found == 0) { 3328 AAC_LOCK_RELEASE(&sc->aac_io_lock); 3329 get_mplock(); 3330 device_delete_child(sc->aac_dev, 3331 co->co_disk); 3332 rel_mplock(); 3333 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 3334 co_next = TAILQ_NEXT(co, co_link); 3335 AAC_LOCK_ACQUIRE(&sc-> 3336 aac_container_lock); 3337 TAILQ_REMOVE(&sc->aac_container_tqh, co, 3338 co_link); 3339 AAC_LOCK_RELEASE(&sc-> 3340 aac_container_lock); 3341 kfree(co, M_AACBUF); 3342 co = co_next; 3343 } else { 3344 co->co_found = 0; 3345 co = TAILQ_NEXT(co, co_link); 3346 } 3347 } 3348 3349 /* Attach the newly created containers */ 3350 if (added) { 3351 AAC_LOCK_RELEASE(&sc->aac_io_lock); 3352 get_mplock(); 3353 bus_generic_attach(sc->aac_dev); 3354 rel_mplock(); 3355 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 3356 } 3357 3358 break; 3359 3360 default: 3361 break; 3362 } 3363 3364 default: 3365 break; 3366 } 3367 3368 /* Copy the AIF data to the AIF queue for ioctl retrieval */ 3369 AAC_LOCK_ACQUIRE(&sc->aac_aifq_lock); 3370 next = (sc->aac_aifq_head + 1) % AAC_AIFQ_LENGTH; 3371 if (next != sc->aac_aifq_tail) { 3372 bcopy(aif, &sc->aac_aifq[next], sizeof(struct aac_aif_command)); 3373 sc->aac_aifq_head = next; 3374 3375 /* On the off chance that someone is sleeping for an aif... */ 3376 if (sc->aac_state & AAC_STATE_AIF_SLEEPER) 3377 wakeup(sc->aac_aifq); 3378 /* token may have been lost */ 3379 /* Wakeup any poll()ers */ 3380 KNOTE(&sc->rcv_kq.ki_note, 0); 3381 /* token may have been lost */ 3382 } 3383 AAC_LOCK_RELEASE(&sc->aac_aifq_lock); 3384 3385 return; 3386 } 3387 3388 /* 3389 * Return the Revision of the driver to userspace and check to see if the 3390 * userspace app is possibly compatible. This is extremely bogus since 3391 * our driver doesn't follow Adaptec's versioning system. Cheat by just 3392 * returning what the card reported. 3393 */ 3394 static int 3395 aac_rev_check(struct aac_softc *sc, caddr_t udata) 3396 { 3397 struct aac_rev_check rev_check; 3398 struct aac_rev_check_resp rev_check_resp; 3399 int error = 0; 3400 3401 debug_called(2); 3402 3403 /* 3404 * Copyin the revision struct from userspace 3405 */ 3406 if ((error = copyin(udata, (caddr_t)&rev_check, 3407 sizeof(struct aac_rev_check))) != 0) { 3408 return error; 3409 } 3410 3411 debug(2, "Userland revision= %d\n", 3412 rev_check.callingRevision.buildNumber); 3413 3414 /* 3415 * Doctor up the response struct. 3416 */ 3417 rev_check_resp.possiblyCompatible = 1; 3418 rev_check_resp.adapterSWRevision.external.ul = 3419 sc->aac_revision.external.ul; 3420 rev_check_resp.adapterSWRevision.buildNumber = 3421 sc->aac_revision.buildNumber; 3422 3423 return(copyout((caddr_t)&rev_check_resp, udata, 3424 sizeof(struct aac_rev_check_resp))); 3425 } 3426 3427 /* 3428 * Pass the caller the next AIF in their queue 3429 */ 3430 static int 3431 aac_getnext_aif(struct aac_softc *sc, caddr_t arg) 3432 { 3433 struct get_adapter_fib_ioctl agf; 3434 int error; 3435 3436 debug_called(2); 3437 3438 if ((error = copyin(arg, &agf, sizeof(agf))) == 0) { 3439 3440 /* 3441 * Check the magic number that we gave the caller. 3442 */ 3443 if (agf.AdapterFibContext != (int)(uintptr_t)sc->aifthread) { 3444 error = EFAULT; 3445 } else { 3446 3447 error = aac_return_aif(sc, agf.AifFib); 3448 3449 if ((error == EAGAIN) && (agf.Wait)) { 3450 sc->aac_state |= AAC_STATE_AIF_SLEEPER; 3451 while (error == EAGAIN) { 3452 error = tsleep(sc->aac_aifq, 3453 PCATCH, "aacaif", 0); 3454 if (error == 0) 3455 error = aac_return_aif(sc, 3456 agf.AifFib); 3457 } 3458 sc->aac_state &= ~AAC_STATE_AIF_SLEEPER; 3459 } 3460 } 3461 } 3462 return(error); 3463 } 3464 3465 /* 3466 * Hand the next AIF off the top of the queue out to userspace. 3467 * 3468 * YYY token could be lost during copyout 3469 */ 3470 static int 3471 aac_return_aif(struct aac_softc *sc, caddr_t uptr) 3472 { 3473 int next, error; 3474 3475 debug_called(2); 3476 3477 AAC_LOCK_ACQUIRE(&sc->aac_aifq_lock); 3478 if (sc->aac_aifq_tail == sc->aac_aifq_head) { 3479 AAC_LOCK_RELEASE(&sc->aac_aifq_lock); 3480 return (EAGAIN); 3481 } 3482 3483 next = (sc->aac_aifq_tail + 1) % AAC_AIFQ_LENGTH; 3484 error = copyout(&sc->aac_aifq[next], uptr, 3485 sizeof(struct aac_aif_command)); 3486 if (error) 3487 device_printf(sc->aac_dev, 3488 "aac_return_aif: copyout returned %d\n", error); 3489 else 3490 sc->aac_aifq_tail = next; 3491 3492 AAC_LOCK_RELEASE(&sc->aac_aifq_lock); 3493 return(error); 3494 } 3495 3496 static int 3497 aac_get_pci_info(struct aac_softc *sc, caddr_t uptr) 3498 { 3499 struct aac_pci_info { 3500 u_int32_t bus; 3501 u_int32_t slot; 3502 } pciinf; 3503 int error; 3504 3505 debug_called(2); 3506 3507 pciinf.bus = pci_get_bus(sc->aac_dev); 3508 pciinf.slot = pci_get_slot(sc->aac_dev); 3509 3510 error = copyout((caddr_t)&pciinf, uptr, 3511 sizeof(struct aac_pci_info)); 3512 3513 return (error); 3514 } 3515 3516 /* 3517 * Give the userland some information about the container. The AAC arch 3518 * expects the driver to be a SCSI passthrough type driver, so it expects 3519 * the containers to have b:t:l numbers. Fake it. 3520 */ 3521 static int 3522 aac_query_disk(struct aac_softc *sc, caddr_t uptr) 3523 { 3524 struct aac_query_disk query_disk; 3525 struct aac_container *co; 3526 struct aac_disk *disk; 3527 int error, id; 3528 3529 debug_called(2); 3530 3531 disk = NULL; 3532 3533 error = copyin(uptr, (caddr_t)&query_disk, 3534 sizeof(struct aac_query_disk)); 3535 if (error) 3536 return (error); 3537 3538 id = query_disk.ContainerNumber; 3539 if (id == -1) 3540 return (EINVAL); 3541 3542 AAC_LOCK_ACQUIRE(&sc->aac_container_lock); 3543 TAILQ_FOREACH(co, &sc->aac_container_tqh, co_link) { 3544 if (co->co_mntobj.ObjectId == id) 3545 break; 3546 } 3547 3548 if (co == NULL) { 3549 query_disk.Valid = 0; 3550 query_disk.Locked = 0; 3551 query_disk.Deleted = 1; /* XXX is this right? */ 3552 } else { 3553 disk = device_get_softc(co->co_disk); 3554 query_disk.Valid = 1; 3555 query_disk.Locked = 3556 (disk->ad_flags & AAC_DISK_OPEN) ? 1 : 0; 3557 query_disk.Deleted = 0; 3558 query_disk.Bus = device_get_unit(sc->aac_dev); 3559 query_disk.Target = disk->unit; 3560 query_disk.Lun = 0; 3561 query_disk.UnMapped = 0; 3562 bcopy(disk->ad_dev_t->si_name, 3563 &query_disk.diskDeviceName[0], 10); 3564 } 3565 AAC_LOCK_RELEASE(&sc->aac_container_lock); 3566 3567 error = copyout((caddr_t)&query_disk, uptr, 3568 sizeof(struct aac_query_disk)); 3569 3570 return (error); 3571 } 3572 3573 static void 3574 aac_get_bus_info(struct aac_softc *sc) 3575 { 3576 struct aac_fib *fib; 3577 struct aac_ctcfg *c_cmd; 3578 struct aac_ctcfg_resp *c_resp; 3579 struct aac_vmioctl *vmi; 3580 struct aac_vmi_businf_resp *vmi_resp; 3581 struct aac_getbusinf businfo; 3582 struct aac_sim *caminf; 3583 device_t child; 3584 int i, found, error; 3585 3586 AAC_LOCK_ACQUIRE(&sc->aac_io_lock); 3587 aac_alloc_sync_fib(sc, &fib); 3588 c_cmd = (struct aac_ctcfg *)&fib->data[0]; 3589 bzero(c_cmd, sizeof(struct aac_ctcfg)); 3590 3591 c_cmd->Command = VM_ContainerConfig; 3592 c_cmd->cmd = CT_GET_SCSI_METHOD; 3593 c_cmd->param = 0; 3594 3595 error = aac_sync_fib(sc, ContainerCommand, 0, fib, 3596 sizeof(struct aac_ctcfg)); 3597 if (error) { 3598 device_printf(sc->aac_dev, "Error %d sending " 3599 "VM_ContainerConfig command\n", error); 3600 aac_release_sync_fib(sc); 3601 AAC_LOCK_RELEASE(&sc->aac_io_lock); 3602 return; 3603 } 3604 3605 c_resp = (struct aac_ctcfg_resp *)&fib->data[0]; 3606 if (c_resp->Status != ST_OK) { 3607 device_printf(sc->aac_dev, "VM_ContainerConfig returned 0x%x\n", 3608 c_resp->Status); 3609 aac_release_sync_fib(sc); 3610 AAC_LOCK_RELEASE(&sc->aac_io_lock); 3611 return; 3612 } 3613 3614 sc->scsi_method_id = c_resp->param; 3615 3616 vmi = (struct aac_vmioctl *)&fib->data[0]; 3617 bzero(vmi, sizeof(struct aac_vmioctl)); 3618 3619 vmi->Command = VM_Ioctl; 3620 vmi->ObjType = FT_DRIVE; 3621 vmi->MethId = sc->scsi_method_id; 3622 vmi->ObjId = 0; 3623 vmi->IoctlCmd = GetBusInfo; 3624 3625 error = aac_sync_fib(sc, ContainerCommand, 0, fib, 3626 sizeof(struct aac_vmioctl)); 3627 if (error) { 3628 device_printf(sc->aac_dev, "Error %d sending VMIoctl command\n", 3629 error); 3630 aac_release_sync_fib(sc); 3631 AAC_LOCK_RELEASE(&sc->aac_io_lock); 3632 return; 3633 } 3634 3635 vmi_resp = (struct aac_vmi_businf_resp *)&fib->data[0]; 3636 if (vmi_resp->Status != ST_OK) { 3637 debug(1, "VM_Ioctl returned %d\n", vmi_resp->Status); 3638 aac_release_sync_fib(sc); 3639 AAC_LOCK_RELEASE(&sc->aac_io_lock); 3640 return; 3641 } 3642 3643 bcopy(&vmi_resp->BusInf, &businfo, sizeof(struct aac_getbusinf)); 3644 aac_release_sync_fib(sc); 3645 AAC_LOCK_RELEASE(&sc->aac_io_lock); 3646 3647 found = 0; 3648 for (i = 0; i < businfo.BusCount; i++) { 3649 if (businfo.BusValid[i] != AAC_BUS_VALID) 3650 continue; 3651 3652 caminf = (struct aac_sim *)kmalloc(sizeof(struct aac_sim), 3653 M_AACBUF, M_INTWAIT | M_ZERO); 3654 3655 child = device_add_child(sc->aac_dev, "aacp", -1); 3656 if (child == NULL) { 3657 device_printf(sc->aac_dev, 3658 "device_add_child failed for passthrough bus %d\n", 3659 i); 3660 kfree(caminf, M_AACBUF); 3661 break; 3662 }; 3663 3664 caminf->TargetsPerBus = businfo.TargetsPerBus; 3665 caminf->BusNumber = i; 3666 caminf->InitiatorBusId = businfo.InitiatorBusId[i]; 3667 caminf->aac_sc = sc; 3668 caminf->sim_dev = child; 3669 3670 device_set_ivars(child, caminf); 3671 device_set_desc(child, "SCSI Passthrough Bus"); 3672 TAILQ_INSERT_TAIL(&sc->aac_sim_tqh, caminf, sim_link); 3673 3674 found = 1; 3675 } 3676 3677 if (found) 3678 bus_generic_attach(sc->aac_dev); 3679 3680 return; 3681 } 3682