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