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