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