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