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