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