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