1 /*- 2 * Copyright (c) 2006 IronPort Systems 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include "opt_mfi.h" 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/sysctl.h> 35 #include <sys/malloc.h> 36 #include <sys/kernel.h> 37 #include <sys/poll.h> 38 #include <sys/selinfo.h> 39 #include <sys/bus.h> 40 #include <sys/conf.h> 41 #include <sys/eventhandler.h> 42 #include <sys/rman.h> 43 #include <sys/bus_dma.h> 44 #include <sys/bio.h> 45 #include <sys/ioccom.h> 46 #include <sys/uio.h> 47 #include <sys/proc.h> 48 #include <sys/signalvar.h> 49 50 #include <machine/bus.h> 51 #include <machine/resource.h> 52 53 #include <dev/mfi/mfireg.h> 54 #include <dev/mfi/mfi_ioctl.h> 55 #include <dev/mfi/mfivar.h> 56 57 static int mfi_alloc_commands(struct mfi_softc *); 58 static void mfi_release_command(struct mfi_command *cm); 59 static int mfi_comms_init(struct mfi_softc *); 60 static int mfi_wait_command(struct mfi_softc *, struct mfi_command *); 61 static int mfi_get_controller_info(struct mfi_softc *); 62 static int mfi_get_log_state(struct mfi_softc *, 63 struct mfi_evt_log_state **); 64 static int mfi_get_entry(struct mfi_softc *, int); 65 static int mfi_dcmd_command(struct mfi_softc *, struct mfi_command **, 66 uint32_t, void **, size_t); 67 static void mfi_data_cb(void *, bus_dma_segment_t *, int, int); 68 static void mfi_startup(void *arg); 69 static void mfi_intr(void *arg); 70 static void mfi_enable_intr(struct mfi_softc *sc); 71 static void mfi_ldprobe(struct mfi_softc *sc); 72 static int mfi_aen_register(struct mfi_softc *sc, int seq, int locale); 73 static void mfi_aen_complete(struct mfi_command *); 74 static int mfi_aen_setup(struct mfi_softc *, uint32_t); 75 static int mfi_add_ld(struct mfi_softc *sc, int); 76 static void mfi_add_ld_complete(struct mfi_command *); 77 static struct mfi_command * mfi_bio_command(struct mfi_softc *); 78 static void mfi_bio_complete(struct mfi_command *); 79 static int mfi_mapcmd(struct mfi_softc *, struct mfi_command *); 80 static int mfi_send_frame(struct mfi_softc *, struct mfi_command *); 81 static void mfi_complete(struct mfi_softc *, struct mfi_command *); 82 static int mfi_abort(struct mfi_softc *, struct mfi_command *); 83 static int mfi_linux_ioctl_int(struct cdev *, u_long, caddr_t, int, d_thread_t *); 84 static void mfi_timeout(void *); 85 86 87 SYSCTL_NODE(_hw, OID_AUTO, mfi, CTLFLAG_RD, 0, "MFI driver parameters"); 88 static int mfi_event_locale = MFI_EVT_LOCALE_ALL; 89 TUNABLE_INT("hw.mfi.event_locale", &mfi_event_locale); 90 SYSCTL_INT(_hw_mfi, OID_AUTO, event_locale, CTLFLAG_RW, &mfi_event_locale, 91 0, "event message locale"); 92 93 static int mfi_event_class = 10; 94 TUNABLE_INT("hw.mfi.event_class", &mfi_event_class); 95 SYSCTL_INT(_hw_mfi, OID_AUTO, event_class, CTLFLAG_RW, &mfi_event_class, 96 0, "event message class"); 97 98 /* Management interface */ 99 static d_open_t mfi_open; 100 static d_close_t mfi_close; 101 static d_ioctl_t mfi_ioctl; 102 static d_poll_t mfi_poll; 103 104 static struct cdevsw mfi_cdevsw = { 105 .d_version = D_VERSION, 106 .d_flags = 0, 107 .d_open = mfi_open, 108 .d_close = mfi_close, 109 .d_ioctl = mfi_ioctl, 110 .d_poll = mfi_poll, 111 .d_name = "mfi", 112 }; 113 114 MALLOC_DEFINE(M_MFIBUF, "mfibuf", "Buffers for the MFI driver"); 115 116 #define MFI_INQ_LENGTH SHORT_INQUIRY_LENGTH 117 118 static int 119 mfi_transition_firmware(struct mfi_softc *sc) 120 { 121 int32_t fw_state, cur_state; 122 int max_wait, i; 123 124 fw_state = MFI_READ4(sc, MFI_OMSG0) & MFI_FWSTATE_MASK; 125 while (fw_state != MFI_FWSTATE_READY) { 126 if (bootverbose) 127 device_printf(sc->mfi_dev, "Waiting for firmware to " 128 "become ready\n"); 129 cur_state = fw_state; 130 switch (fw_state) { 131 case MFI_FWSTATE_FAULT: 132 device_printf(sc->mfi_dev, "Firmware fault\n"); 133 return (ENXIO); 134 case MFI_FWSTATE_WAIT_HANDSHAKE: 135 MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_CLEAR_HANDSHAKE); 136 max_wait = 2; 137 break; 138 case MFI_FWSTATE_OPERATIONAL: 139 MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_READY); 140 max_wait = 10; 141 break; 142 case MFI_FWSTATE_UNDEFINED: 143 case MFI_FWSTATE_BB_INIT: 144 max_wait = 2; 145 break; 146 case MFI_FWSTATE_FW_INIT: 147 case MFI_FWSTATE_DEVICE_SCAN: 148 case MFI_FWSTATE_FLUSH_CACHE: 149 max_wait = 20; 150 break; 151 default: 152 device_printf(sc->mfi_dev,"Unknown firmware state %d\n", 153 fw_state); 154 return (ENXIO); 155 } 156 for (i = 0; i < (max_wait * 10); i++) { 157 fw_state = MFI_READ4(sc, MFI_OMSG0) & MFI_FWSTATE_MASK; 158 if (fw_state == cur_state) 159 DELAY(100000); 160 else 161 break; 162 } 163 if (fw_state == cur_state) { 164 device_printf(sc->mfi_dev, "firmware stuck in state " 165 "%#x\n", fw_state); 166 return (ENXIO); 167 } 168 } 169 return (0); 170 } 171 172 static void 173 mfi_addr32_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 174 { 175 uint32_t *addr; 176 177 addr = arg; 178 *addr = segs[0].ds_addr; 179 } 180 181 int 182 mfi_attach(struct mfi_softc *sc) 183 { 184 uint32_t status; 185 int error, commsz, framessz, sensesz; 186 int frames, unit, max_fw_sge; 187 188 mtx_init(&sc->mfi_io_lock, "MFI I/O lock", NULL, MTX_DEF); 189 TAILQ_INIT(&sc->mfi_ld_tqh); 190 TAILQ_INIT(&sc->mfi_aen_pids); 191 192 mfi_initq_free(sc); 193 mfi_initq_ready(sc); 194 mfi_initq_busy(sc); 195 mfi_initq_bio(sc); 196 197 /* Before we get too far, see if the firmware is working */ 198 if ((error = mfi_transition_firmware(sc)) != 0) { 199 device_printf(sc->mfi_dev, "Firmware not in READY state, " 200 "error %d\n", error); 201 return (ENXIO); 202 } 203 204 /* 205 * Get information needed for sizing the contiguous memory for the 206 * frame pool. Size down the sgl parameter since we know that 207 * we will never need more than what's required for MAXPHYS. 208 * It would be nice if these constants were available at runtime 209 * instead of compile time. 210 */ 211 status = MFI_READ4(sc, MFI_OMSG0); 212 sc->mfi_max_fw_cmds = status & MFI_FWSTATE_MAXCMD_MASK; 213 max_fw_sge = (status & MFI_FWSTATE_MAXSGL_MASK) >> 16; 214 sc->mfi_max_sge = min(max_fw_sge, ((MAXPHYS / PAGE_SIZE) + 1)); 215 216 /* 217 * Create the dma tag for data buffers. Used both for block I/O 218 * and for various internal data queries. 219 */ 220 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */ 221 1, 0, /* algnmnt, boundary */ 222 BUS_SPACE_MAXADDR, /* lowaddr */ 223 BUS_SPACE_MAXADDR, /* highaddr */ 224 NULL, NULL, /* filter, filterarg */ 225 BUS_SPACE_MAXSIZE_32BIT,/* maxsize */ 226 sc->mfi_max_sge, /* nsegments */ 227 BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */ 228 BUS_DMA_ALLOCNOW, /* flags */ 229 busdma_lock_mutex, /* lockfunc */ 230 &sc->mfi_io_lock, /* lockfuncarg */ 231 &sc->mfi_buffer_dmat)) { 232 device_printf(sc->mfi_dev, "Cannot allocate buffer DMA tag\n"); 233 return (ENOMEM); 234 } 235 236 /* 237 * Allocate DMA memory for the comms queues. Keep it under 4GB for 238 * efficiency. The mfi_hwcomms struct includes space for 1 reply queue 239 * entry, so the calculated size here will be will be 1 more than 240 * mfi_max_fw_cmds. This is apparently a requirement of the hardware. 241 */ 242 commsz = (sizeof(uint32_t) * sc->mfi_max_fw_cmds) + 243 sizeof(struct mfi_hwcomms); 244 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */ 245 1, 0, /* algnmnt, boundary */ 246 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */ 247 BUS_SPACE_MAXADDR, /* highaddr */ 248 NULL, NULL, /* filter, filterarg */ 249 commsz, /* maxsize */ 250 1, /* msegments */ 251 commsz, /* maxsegsize */ 252 0, /* flags */ 253 NULL, NULL, /* lockfunc, lockarg */ 254 &sc->mfi_comms_dmat)) { 255 device_printf(sc->mfi_dev, "Cannot allocate comms DMA tag\n"); 256 return (ENOMEM); 257 } 258 if (bus_dmamem_alloc(sc->mfi_comms_dmat, (void **)&sc->mfi_comms, 259 BUS_DMA_NOWAIT, &sc->mfi_comms_dmamap)) { 260 device_printf(sc->mfi_dev, "Cannot allocate comms memory\n"); 261 return (ENOMEM); 262 } 263 bzero(sc->mfi_comms, commsz); 264 bus_dmamap_load(sc->mfi_comms_dmat, sc->mfi_comms_dmamap, 265 sc->mfi_comms, commsz, mfi_addr32_cb, &sc->mfi_comms_busaddr, 0); 266 267 /* 268 * Allocate DMA memory for the command frames. Keep them in the 269 * lower 4GB for efficiency. Calculate the size of the commands at 270 * the same time; each command is one 64 byte frame plus a set of 271 * additional frames for holding sg lists or other data. 272 * The assumption here is that the SG list will start at the second 273 * frame and not use the unused bytes in the first frame. While this 274 * isn't technically correct, it simplifies the calculation and allows 275 * for command frames that might be larger than an mfi_io_frame. 276 */ 277 if (sizeof(bus_addr_t) == 8) { 278 sc->mfi_sge_size = sizeof(struct mfi_sg64); 279 sc->mfi_flags |= MFI_FLAGS_SG64; 280 } else { 281 sc->mfi_sge_size = sizeof(struct mfi_sg32); 282 } 283 frames = (sc->mfi_sge_size * sc->mfi_max_sge - 1) / MFI_FRAME_SIZE + 2; 284 sc->mfi_cmd_size = frames * MFI_FRAME_SIZE; 285 framessz = sc->mfi_cmd_size * sc->mfi_max_fw_cmds; 286 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */ 287 64, 0, /* algnmnt, boundary */ 288 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */ 289 BUS_SPACE_MAXADDR, /* highaddr */ 290 NULL, NULL, /* filter, filterarg */ 291 framessz, /* maxsize */ 292 1, /* nsegments */ 293 framessz, /* maxsegsize */ 294 0, /* flags */ 295 NULL, NULL, /* lockfunc, lockarg */ 296 &sc->mfi_frames_dmat)) { 297 device_printf(sc->mfi_dev, "Cannot allocate frame DMA tag\n"); 298 return (ENOMEM); 299 } 300 if (bus_dmamem_alloc(sc->mfi_frames_dmat, (void **)&sc->mfi_frames, 301 BUS_DMA_NOWAIT, &sc->mfi_frames_dmamap)) { 302 device_printf(sc->mfi_dev, "Cannot allocate frames memory\n"); 303 return (ENOMEM); 304 } 305 bzero(sc->mfi_frames, framessz); 306 bus_dmamap_load(sc->mfi_frames_dmat, sc->mfi_frames_dmamap, 307 sc->mfi_frames, framessz, mfi_addr32_cb, &sc->mfi_frames_busaddr,0); 308 309 /* 310 * Allocate DMA memory for the frame sense data. Keep them in the 311 * lower 4GB for efficiency 312 */ 313 sensesz = sc->mfi_max_fw_cmds * MFI_SENSE_LEN; 314 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */ 315 4, 0, /* algnmnt, boundary */ 316 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */ 317 BUS_SPACE_MAXADDR, /* highaddr */ 318 NULL, NULL, /* filter, filterarg */ 319 sensesz, /* maxsize */ 320 1, /* nsegments */ 321 sensesz, /* maxsegsize */ 322 0, /* flags */ 323 NULL, NULL, /* lockfunc, lockarg */ 324 &sc->mfi_sense_dmat)) { 325 device_printf(sc->mfi_dev, "Cannot allocate sense DMA tag\n"); 326 return (ENOMEM); 327 } 328 if (bus_dmamem_alloc(sc->mfi_sense_dmat, (void **)&sc->mfi_sense, 329 BUS_DMA_NOWAIT, &sc->mfi_sense_dmamap)) { 330 device_printf(sc->mfi_dev, "Cannot allocate sense memory\n"); 331 return (ENOMEM); 332 } 333 bus_dmamap_load(sc->mfi_sense_dmat, sc->mfi_sense_dmamap, 334 sc->mfi_sense, sensesz, mfi_addr32_cb, &sc->mfi_sense_busaddr, 0); 335 336 if ((error = mfi_alloc_commands(sc)) != 0) 337 return (error); 338 339 if ((error = mfi_comms_init(sc)) != 0) 340 return (error); 341 342 if ((error = mfi_get_controller_info(sc)) != 0) 343 return (error); 344 345 mtx_lock(&sc->mfi_io_lock); 346 if ((error = mfi_aen_setup(sc, 0), 0) != 0) { 347 mtx_unlock(&sc->mfi_io_lock); 348 return (error); 349 } 350 mtx_unlock(&sc->mfi_io_lock); 351 352 /* 353 * Set up the interrupt handler. XXX This should happen in 354 * mfi_pci.c 355 */ 356 sc->mfi_irq_rid = 0; 357 if ((sc->mfi_irq = bus_alloc_resource_any(sc->mfi_dev, SYS_RES_IRQ, 358 &sc->mfi_irq_rid, RF_SHAREABLE | RF_ACTIVE)) == NULL) { 359 device_printf(sc->mfi_dev, "Cannot allocate interrupt\n"); 360 return (EINVAL); 361 } 362 if (bus_setup_intr(sc->mfi_dev, sc->mfi_irq, INTR_MPSAFE|INTR_TYPE_BIO, 363 mfi_intr, sc, &sc->mfi_intr)) { 364 device_printf(sc->mfi_dev, "Cannot set up interrupt\n"); 365 return (EINVAL); 366 } 367 368 /* Register a config hook to probe the bus for arrays */ 369 sc->mfi_ich.ich_func = mfi_startup; 370 sc->mfi_ich.ich_arg = sc; 371 if (config_intrhook_establish(&sc->mfi_ich) != 0) { 372 device_printf(sc->mfi_dev, "Cannot establish configuration " 373 "hook\n"); 374 return (EINVAL); 375 } 376 377 /* 378 * Register a shutdown handler. 379 */ 380 if ((sc->mfi_eh = EVENTHANDLER_REGISTER(shutdown_final, mfi_shutdown, 381 sc, SHUTDOWN_PRI_DEFAULT)) == NULL) { 382 device_printf(sc->mfi_dev, "Warning: shutdown event " 383 "registration failed\n"); 384 } 385 386 /* 387 * Create the control device for doing management 388 */ 389 unit = device_get_unit(sc->mfi_dev); 390 sc->mfi_cdev = make_dev(&mfi_cdevsw, unit, UID_ROOT, GID_OPERATOR, 391 0640, "mfi%d", unit); 392 if (unit == 0) 393 make_dev_alias(sc->mfi_cdev, "megaraid_sas_ioctl_node"); 394 if (sc->mfi_cdev != NULL) 395 sc->mfi_cdev->si_drv1 = sc; 396 397 /* Start the timeout watchdog */ 398 callout_init(&sc->mfi_watchdog_callout, 1); 399 callout_reset(&sc->mfi_watchdog_callout, MFI_CMD_TIMEOUT * hz, 400 mfi_timeout, sc); 401 402 return (0); 403 } 404 405 static int 406 mfi_alloc_commands(struct mfi_softc *sc) 407 { 408 struct mfi_command *cm; 409 int i, ncmds; 410 411 /* 412 * XXX Should we allocate all the commands up front, or allocate on 413 * demand later like 'aac' does? 414 */ 415 ncmds = sc->mfi_max_fw_cmds; 416 sc->mfi_commands = malloc(sizeof(struct mfi_command) * ncmds, M_MFIBUF, 417 M_WAITOK | M_ZERO); 418 419 for (i = 0; i < ncmds; i++) { 420 cm = &sc->mfi_commands[i]; 421 cm->cm_frame = (union mfi_frame *)((uintptr_t)sc->mfi_frames + 422 sc->mfi_cmd_size * i); 423 cm->cm_frame_busaddr = sc->mfi_frames_busaddr + 424 sc->mfi_cmd_size * i; 425 cm->cm_frame->header.context = i; 426 cm->cm_sense = &sc->mfi_sense[i]; 427 cm->cm_sense_busaddr= sc->mfi_sense_busaddr + MFI_SENSE_LEN * i; 428 cm->cm_sc = sc; 429 cm->cm_index = i; 430 if (bus_dmamap_create(sc->mfi_buffer_dmat, 0, 431 &cm->cm_dmamap) == 0) 432 mfi_release_command(cm); 433 else 434 break; 435 sc->mfi_total_cmds++; 436 } 437 438 return (0); 439 } 440 441 static void 442 mfi_release_command(struct mfi_command *cm) 443 { 444 struct mfi_frame_header *hdr; 445 uint32_t *hdr_data; 446 447 /* 448 * Zero out the important fields of the frame, but make sure the 449 * context field is preserved 450 */ 451 hdr_data = (uint32_t *)cm->cm_frame; 452 hdr_data[0] = 0; 453 hdr_data[1] = 0; 454 455 hdr = &cm->cm_frame->header; 456 if (hdr->sg_count) { 457 cm->cm_sg->sg32[0].len = 0; 458 cm->cm_sg->sg32[0].addr = 0; 459 } 460 cm->cm_extra_frames = 0; 461 cm->cm_flags = 0; 462 cm->cm_complete = NULL; 463 cm->cm_private = NULL; 464 cm->cm_sg = 0; 465 cm->cm_total_frame_size = 0; 466 467 mfi_enqueue_free(cm); 468 } 469 470 static int 471 mfi_dcmd_command(struct mfi_softc *sc, struct mfi_command **cmp, uint32_t opcode, 472 void **bufp, size_t bufsize) 473 { 474 struct mfi_command *cm; 475 struct mfi_dcmd_frame *dcmd; 476 void *buf = NULL; 477 478 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 479 480 cm = mfi_dequeue_free(sc); 481 if (cm == NULL) 482 return (EBUSY); 483 484 if ((bufsize > 0) && (bufp != NULL)) { 485 if (*bufp == NULL) { 486 buf = malloc(bufsize, M_MFIBUF, M_NOWAIT|M_ZERO); 487 if (buf == NULL) { 488 mfi_release_command(cm); 489 return (ENOMEM); 490 } 491 *bufp = buf; 492 } else { 493 buf = *bufp; 494 } 495 } 496 497 dcmd = &cm->cm_frame->dcmd; 498 bzero(dcmd->mbox, MFI_MBOX_SIZE); 499 dcmd->header.cmd = MFI_CMD_DCMD; 500 dcmd->header.timeout = 0; 501 dcmd->header.flags = 0; 502 dcmd->header.data_len = bufsize; 503 dcmd->opcode = opcode; 504 cm->cm_sg = &dcmd->sgl; 505 cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE; 506 cm->cm_flags = 0; 507 cm->cm_data = buf; 508 cm->cm_private = buf; 509 cm->cm_len = bufsize; 510 511 *cmp = cm; 512 if ((bufp != NULL) && (*bufp == NULL) && (buf != NULL)) 513 *bufp = buf; 514 return (0); 515 } 516 517 static int 518 mfi_comms_init(struct mfi_softc *sc) 519 { 520 struct mfi_command *cm; 521 struct mfi_init_frame *init; 522 struct mfi_init_qinfo *qinfo; 523 int error; 524 525 mtx_lock(&sc->mfi_io_lock); 526 if ((cm = mfi_dequeue_free(sc)) == NULL) 527 return (EBUSY); 528 529 /* 530 * Abuse the SG list area of the frame to hold the init_qinfo 531 * object; 532 */ 533 init = &cm->cm_frame->init; 534 qinfo = (struct mfi_init_qinfo *)((uintptr_t)init + MFI_FRAME_SIZE); 535 536 bzero(qinfo, sizeof(struct mfi_init_qinfo)); 537 qinfo->rq_entries = sc->mfi_max_fw_cmds + 1; 538 qinfo->rq_addr_lo = sc->mfi_comms_busaddr + 539 offsetof(struct mfi_hwcomms, hw_reply_q); 540 qinfo->pi_addr_lo = sc->mfi_comms_busaddr + 541 offsetof(struct mfi_hwcomms, hw_pi); 542 qinfo->ci_addr_lo = sc->mfi_comms_busaddr + 543 offsetof(struct mfi_hwcomms, hw_ci); 544 545 init->header.cmd = MFI_CMD_INIT; 546 init->header.data_len = sizeof(struct mfi_init_qinfo); 547 init->qinfo_new_addr_lo = cm->cm_frame_busaddr + MFI_FRAME_SIZE; 548 cm->cm_data = NULL; 549 cm->cm_flags = MFI_CMD_POLLED; 550 551 if ((error = mfi_mapcmd(sc, cm)) != 0) { 552 device_printf(sc->mfi_dev, "failed to send init command\n"); 553 mtx_unlock(&sc->mfi_io_lock); 554 return (error); 555 } 556 mfi_release_command(cm); 557 mtx_unlock(&sc->mfi_io_lock); 558 559 return (0); 560 } 561 562 static int 563 mfi_get_controller_info(struct mfi_softc *sc) 564 { 565 struct mfi_command *cm = NULL; 566 struct mfi_ctrl_info *ci = NULL; 567 uint32_t max_sectors_1, max_sectors_2; 568 int error; 569 570 mtx_lock(&sc->mfi_io_lock); 571 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_GETINFO, 572 (void **)&ci, sizeof(*ci)); 573 if (error) 574 goto out; 575 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED; 576 577 if ((error = mfi_mapcmd(sc, cm)) != 0) { 578 device_printf(sc->mfi_dev, "Failed to get controller info\n"); 579 sc->mfi_max_io = (sc->mfi_max_sge - 1) * PAGE_SIZE / 580 MFI_SECTOR_LEN; 581 error = 0; 582 goto out; 583 } 584 585 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, 586 BUS_DMASYNC_POSTREAD); 587 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 588 589 max_sectors_1 = (1 << ci->stripe_sz_ops.min) * ci->max_strips_per_io; 590 max_sectors_2 = ci->max_request_size; 591 sc->mfi_max_io = min(max_sectors_1, max_sectors_2); 592 593 out: 594 if (ci) 595 free(ci, M_MFIBUF); 596 if (cm) 597 mfi_release_command(cm); 598 mtx_unlock(&sc->mfi_io_lock); 599 return (error); 600 } 601 602 static int 603 mfi_get_log_state(struct mfi_softc *sc, struct mfi_evt_log_state **log_state) 604 { 605 struct mfi_command *cm = NULL; 606 int error; 607 608 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_EVENT_GETINFO, 609 (void **)log_state, sizeof(**log_state)); 610 if (error) 611 goto out; 612 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED; 613 614 if ((error = mfi_mapcmd(sc, cm)) != 0) { 615 device_printf(sc->mfi_dev, "Failed to get log state\n"); 616 goto out; 617 } 618 619 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, 620 BUS_DMASYNC_POSTREAD); 621 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 622 623 out: 624 if (cm) 625 mfi_release_command(cm); 626 627 return (error); 628 } 629 630 static int 631 mfi_aen_setup(struct mfi_softc *sc, uint32_t seq_start) 632 { 633 struct mfi_evt_log_state *log_state = NULL; 634 union mfi_evt class_locale; 635 int error = 0; 636 uint32_t seq; 637 638 class_locale.members.reserved = 0; 639 class_locale.members.locale = mfi_event_locale; 640 class_locale.members.class = mfi_event_class; 641 642 if (seq_start == 0) { 643 error = mfi_get_log_state(sc, &log_state); 644 if (error) { 645 if (log_state) 646 free(log_state, M_MFIBUF); 647 return (error); 648 } 649 /* 650 * Don't run them yet since we can't parse them. 651 * We can indirectly get the contents from 652 * the AEN mechanism via setting it lower then 653 * current. The firmware will iterate through them. 654 */ 655 for (seq = log_state->shutdown_seq_num; 656 seq <= log_state->newest_seq_num; seq++) { 657 mfi_get_entry(sc, seq); 658 } 659 } else 660 seq = seq_start; 661 mfi_aen_register(sc, seq, class_locale.word); 662 free(log_state, M_MFIBUF); 663 664 return 0; 665 } 666 667 static int 668 mfi_wait_command(struct mfi_softc *sc, struct mfi_command *cm) 669 { 670 671 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 672 cm->cm_complete = NULL; 673 674 mfi_enqueue_ready(cm); 675 mfi_startio(sc); 676 return (msleep(cm, &sc->mfi_io_lock, PRIBIO, "mfiwait", 0)); 677 } 678 679 void 680 mfi_free(struct mfi_softc *sc) 681 { 682 struct mfi_command *cm; 683 int i; 684 685 callout_drain(&sc->mfi_watchdog_callout); 686 687 if (sc->mfi_cdev != NULL) 688 destroy_dev(sc->mfi_cdev); 689 690 if (sc->mfi_total_cmds != 0) { 691 for (i = 0; i < sc->mfi_total_cmds; i++) { 692 cm = &sc->mfi_commands[i]; 693 bus_dmamap_destroy(sc->mfi_buffer_dmat, cm->cm_dmamap); 694 } 695 free(sc->mfi_commands, M_MFIBUF); 696 } 697 698 if (sc->mfi_intr) 699 bus_teardown_intr(sc->mfi_dev, sc->mfi_irq, sc->mfi_intr); 700 if (sc->mfi_irq != NULL) 701 bus_release_resource(sc->mfi_dev, SYS_RES_IRQ, sc->mfi_irq_rid, 702 sc->mfi_irq); 703 704 if (sc->mfi_sense_busaddr != 0) 705 bus_dmamap_unload(sc->mfi_sense_dmat, sc->mfi_sense_dmamap); 706 if (sc->mfi_sense != NULL) 707 bus_dmamem_free(sc->mfi_sense_dmat, sc->mfi_sense, 708 sc->mfi_sense_dmamap); 709 if (sc->mfi_sense_dmat != NULL) 710 bus_dma_tag_destroy(sc->mfi_sense_dmat); 711 712 if (sc->mfi_frames_busaddr != 0) 713 bus_dmamap_unload(sc->mfi_frames_dmat, sc->mfi_frames_dmamap); 714 if (sc->mfi_frames != NULL) 715 bus_dmamem_free(sc->mfi_frames_dmat, sc->mfi_frames, 716 sc->mfi_frames_dmamap); 717 if (sc->mfi_frames_dmat != NULL) 718 bus_dma_tag_destroy(sc->mfi_frames_dmat); 719 720 if (sc->mfi_comms_busaddr != 0) 721 bus_dmamap_unload(sc->mfi_comms_dmat, sc->mfi_comms_dmamap); 722 if (sc->mfi_comms != NULL) 723 bus_dmamem_free(sc->mfi_comms_dmat, sc->mfi_comms, 724 sc->mfi_comms_dmamap); 725 if (sc->mfi_comms_dmat != NULL) 726 bus_dma_tag_destroy(sc->mfi_comms_dmat); 727 728 if (sc->mfi_buffer_dmat != NULL) 729 bus_dma_tag_destroy(sc->mfi_buffer_dmat); 730 if (sc->mfi_parent_dmat != NULL) 731 bus_dma_tag_destroy(sc->mfi_parent_dmat); 732 733 if (mtx_initialized(&sc->mfi_io_lock)) 734 mtx_destroy(&sc->mfi_io_lock); 735 736 return; 737 } 738 739 static void 740 mfi_startup(void *arg) 741 { 742 struct mfi_softc *sc; 743 744 sc = (struct mfi_softc *)arg; 745 746 config_intrhook_disestablish(&sc->mfi_ich); 747 748 mfi_enable_intr(sc); 749 mtx_lock(&sc->mfi_io_lock); 750 mfi_ldprobe(sc); 751 mtx_unlock(&sc->mfi_io_lock); 752 } 753 754 static void 755 mfi_intr(void *arg) 756 { 757 struct mfi_softc *sc; 758 struct mfi_command *cm; 759 uint32_t status, pi, ci, context; 760 761 sc = (struct mfi_softc *)arg; 762 763 status = MFI_READ4(sc, MFI_OSTS); 764 if ((status & MFI_OSTS_INTR_VALID) == 0) 765 return; 766 767 MFI_WRITE4(sc, MFI_OSTS, status); 768 769 pi = sc->mfi_comms->hw_pi; 770 ci = sc->mfi_comms->hw_ci; 771 mtx_lock(&sc->mfi_io_lock); 772 while (ci != pi) { 773 context = sc->mfi_comms->hw_reply_q[ci]; 774 cm = &sc->mfi_commands[context]; 775 mfi_remove_busy(cm); 776 mfi_complete(sc, cm); 777 if (++ci == (sc->mfi_max_fw_cmds + 1)) { 778 ci = 0; 779 } 780 } 781 782 sc->mfi_comms->hw_ci = ci; 783 784 /* Give defered I/O a chance to run */ 785 if (sc->mfi_flags & MFI_FLAGS_QFRZN) 786 sc->mfi_flags &= ~MFI_FLAGS_QFRZN; 787 mfi_startio(sc); 788 mtx_unlock(&sc->mfi_io_lock); 789 790 return; 791 } 792 793 int 794 mfi_shutdown(struct mfi_softc *sc) 795 { 796 struct mfi_dcmd_frame *dcmd; 797 struct mfi_command *cm; 798 int error; 799 800 mtx_lock(&sc->mfi_io_lock); 801 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_SHUTDOWN, NULL, 0); 802 if (error) { 803 mtx_unlock(&sc->mfi_io_lock); 804 return (error); 805 } 806 807 if (sc->mfi_aen_cm != NULL) 808 mfi_abort(sc, sc->mfi_aen_cm); 809 810 dcmd = &cm->cm_frame->dcmd; 811 dcmd->header.flags = MFI_FRAME_DIR_NONE; 812 cm->cm_flags = MFI_CMD_POLLED; 813 cm->cm_data = NULL; 814 815 if ((error = mfi_mapcmd(sc, cm)) != 0) { 816 device_printf(sc->mfi_dev, "Failed to shutdown controller\n"); 817 } 818 819 mfi_release_command(cm); 820 mtx_unlock(&sc->mfi_io_lock); 821 return (error); 822 } 823 824 static void 825 mfi_enable_intr(struct mfi_softc *sc) 826 { 827 828 MFI_WRITE4(sc, MFI_OMSK, 0x01); 829 } 830 831 static void 832 mfi_ldprobe(struct mfi_softc *sc) 833 { 834 struct mfi_frame_header *hdr; 835 struct mfi_command *cm = NULL; 836 struct mfi_ld_list *list = NULL; 837 int error, i; 838 839 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 840 841 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_LD_GET_LIST, 842 (void **)&list, sizeof(*list)); 843 if (error) 844 goto out; 845 846 cm->cm_flags = MFI_CMD_DATAIN; 847 if (mfi_wait_command(sc, cm) != 0) { 848 device_printf(sc->mfi_dev, "Failed to get device listing\n"); 849 goto out; 850 } 851 852 hdr = &cm->cm_frame->header; 853 if (hdr->cmd_status != MFI_STAT_OK) { 854 device_printf(sc->mfi_dev, "MFI_DCMD_LD_GET_LIST failed %x\n", 855 hdr->cmd_status); 856 goto out; 857 } 858 859 for (i = 0; i < list->ld_count; i++) 860 mfi_add_ld(sc, list->ld_list[i].ld.v.target_id); 861 out: 862 if (list) 863 free(list, M_MFIBUF); 864 if (cm) 865 mfi_release_command(cm); 866 867 return; 868 } 869 870 static void 871 mfi_decode_evt(struct mfi_softc *sc, struct mfi_evt_detail *detail) 872 { 873 switch (detail->arg_type) { 874 case MR_EVT_ARGS_NONE: 875 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - %s\n", 876 detail->seq, 877 detail->time, 878 detail->class.members.locale, 879 detail->class.members.class, 880 detail->description 881 ); 882 break; 883 case MR_EVT_ARGS_CDB_SENSE: 884 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - PD %02d(e%d/s%d) CDB %*D" 885 "Sense %*D\n: %s\n", 886 detail->seq, 887 detail->time, 888 detail->class.members.locale, 889 detail->class.members.class, 890 detail->args.cdb_sense.pd.device_id, 891 detail->args.cdb_sense.pd.enclosure_index, 892 detail->args.cdb_sense.pd.slot_number, 893 detail->args.cdb_sense.cdb_len, 894 detail->args.cdb_sense.cdb, 895 ":", 896 detail->args.cdb_sense.sense_len, 897 detail->args.cdb_sense.sense, 898 ":", 899 detail->description 900 ); 901 break; 902 case MR_EVT_ARGS_LD: 903 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - VD %02d/%d " 904 "event: %s\n", 905 detail->seq, 906 detail->time, 907 detail->class.members.locale, 908 detail->class.members.class, 909 detail->args.ld.ld_index, 910 detail->args.ld.target_id, 911 detail->description 912 ); 913 break; 914 case MR_EVT_ARGS_LD_COUNT: 915 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - VD %02d/%d " 916 "count %lld: %s\n", 917 detail->seq, 918 detail->time, 919 detail->class.members.locale, 920 detail->class.members.class, 921 detail->args.ld_count.ld.ld_index, 922 detail->args.ld_count.ld.target_id, 923 (long long)detail->args.ld_count.count, 924 detail->description 925 ); 926 break; 927 case MR_EVT_ARGS_LD_LBA: 928 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - VD %02d/%d " 929 "lba %lld: %s\n", 930 detail->seq, 931 detail->time, 932 detail->class.members.locale, 933 detail->class.members.class, 934 detail->args.ld_lba.ld.ld_index, 935 detail->args.ld_lba.ld.target_id, 936 (long long)detail->args.ld_lba.lba, 937 detail->description 938 ); 939 break; 940 case MR_EVT_ARGS_LD_OWNER: 941 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - VD %02d/%d " 942 "owner changed: prior %d, new %d: %s\n", 943 detail->seq, 944 detail->time, 945 detail->class.members.locale, 946 detail->class.members.class, 947 detail->args.ld_owner.ld.ld_index, 948 detail->args.ld_owner.ld.target_id, 949 detail->args.ld_owner.pre_owner, 950 detail->args.ld_owner.new_owner, 951 detail->description 952 ); 953 break; 954 case MR_EVT_ARGS_LD_LBA_PD_LBA: 955 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - VD %02d/%d " 956 "lba %lld, physical drive PD %02d(e%d/s%d) lba %lld: %s\n", 957 detail->seq, 958 detail->time, 959 detail->class.members.locale, 960 detail->class.members.class, 961 detail->args.ld_lba_pd_lba.ld.ld_index, 962 detail->args.ld_lba_pd_lba.ld.target_id, 963 (long long)detail->args.ld_lba_pd_lba.ld_lba, 964 detail->args.ld_lba_pd_lba.pd.device_id, 965 detail->args.ld_lba_pd_lba.pd.enclosure_index, 966 detail->args.ld_lba_pd_lba.pd.slot_number, 967 (long long)detail->args.ld_lba_pd_lba.pd_lba, 968 detail->description 969 ); 970 break; 971 case MR_EVT_ARGS_LD_PROG: 972 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - VD %02d/%d " 973 "progress %d%% in %ds: %s\n", 974 detail->seq, 975 detail->time, 976 detail->class.members.locale, 977 detail->class.members.class, 978 detail->args.ld_prog.ld.ld_index, 979 detail->args.ld_prog.ld.target_id, 980 detail->args.ld_prog.prog.progress/655, 981 detail->args.ld_prog.prog.elapsed_seconds, 982 detail->description 983 ); 984 break; 985 case MR_EVT_ARGS_LD_STATE: 986 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - VD %02d/%d " 987 "state prior %d new %d: %s\n", 988 detail->seq, 989 detail->time, 990 detail->class.members.locale, 991 detail->class.members.class, 992 detail->args.ld_state.ld.ld_index, 993 detail->args.ld_state.ld.target_id, 994 detail->args.ld_state.prev_state, 995 detail->args.ld_state.new_state, 996 detail->description 997 ); 998 break; 999 case MR_EVT_ARGS_LD_STRIP: 1000 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - VD %02d/%d " 1001 "strip %lld: %s\n", 1002 detail->seq, 1003 detail->time, 1004 detail->class.members.locale, 1005 detail->class.members.class, 1006 detail->args.ld_strip.ld.ld_index, 1007 detail->args.ld_strip.ld.target_id, 1008 (long long)detail->args.ld_strip.strip, 1009 detail->description 1010 ); 1011 break; 1012 case MR_EVT_ARGS_PD: 1013 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - PD %02d(e%d/s%d) " 1014 "event: %s\n", 1015 detail->seq, 1016 detail->time, 1017 detail->class.members.locale, 1018 detail->class.members.class, 1019 detail->args.pd.device_id, 1020 detail->args.pd.enclosure_index, 1021 detail->args.pd.slot_number, 1022 detail->description 1023 ); 1024 break; 1025 case MR_EVT_ARGS_PD_ERR: 1026 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - PD %02d(e%d/s%d) " 1027 "err %d: %s\n", 1028 detail->seq, 1029 detail->time, 1030 detail->class.members.locale, 1031 detail->class.members.class, 1032 detail->args.pd_err.pd.device_id, 1033 detail->args.pd_err.pd.enclosure_index, 1034 detail->args.pd_err.pd.slot_number, 1035 detail->args.pd_err.err, 1036 detail->description 1037 ); 1038 break; 1039 case MR_EVT_ARGS_PD_LBA: 1040 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - PD %02d(e%d/s%d) " 1041 "lba %lld: %s\n", 1042 detail->seq, 1043 detail->time, 1044 detail->class.members.locale, 1045 detail->class.members.class, 1046 detail->args.pd_lba.pd.device_id, 1047 detail->args.pd_lba.pd.enclosure_index, 1048 detail->args.pd_lba.pd.slot_number, 1049 (long long)detail->args.pd_lba.lba, 1050 detail->description 1051 ); 1052 break; 1053 case MR_EVT_ARGS_PD_LBA_LD: 1054 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - PD %02d(e%d/s%d) " 1055 "lba %lld VD %02d/%d: %s\n", 1056 detail->seq, 1057 detail->time, 1058 detail->class.members.locale, 1059 detail->class.members.class, 1060 detail->args.pd_lba_ld.pd.device_id, 1061 detail->args.pd_lba_ld.pd.enclosure_index, 1062 detail->args.pd_lba_ld.pd.slot_number, 1063 (long long)detail->args.pd_lba.lba, 1064 detail->args.pd_lba_ld.ld.ld_index, 1065 detail->args.pd_lba_ld.ld.target_id, 1066 detail->description 1067 ); 1068 break; 1069 case MR_EVT_ARGS_PD_PROG: 1070 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - PD %02d(e%d/s%d) " 1071 "progress %d%% seconds %ds: %s\n", 1072 detail->seq, 1073 detail->time, 1074 detail->class.members.locale, 1075 detail->class.members.class, 1076 detail->args.pd_prog.pd.device_id, 1077 detail->args.pd_prog.pd.enclosure_index, 1078 detail->args.pd_prog.pd.slot_number, 1079 detail->args.pd_prog.prog.progress/655, 1080 detail->args.pd_prog.prog.elapsed_seconds, 1081 detail->description 1082 ); 1083 break; 1084 case MR_EVT_ARGS_PD_STATE: 1085 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - PD %02d(e%d/s%d) " 1086 "state prior %d new %d: %s\n", 1087 detail->seq, 1088 detail->time, 1089 detail->class.members.locale, 1090 detail->class.members.class, 1091 detail->args.pd_prog.pd.device_id, 1092 detail->args.pd_prog.pd.enclosure_index, 1093 detail->args.pd_prog.pd.slot_number, 1094 detail->args.pd_state.prev_state, 1095 detail->args.pd_state.new_state, 1096 detail->description 1097 ); 1098 break; 1099 case MR_EVT_ARGS_PCI: 1100 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - PCI 0x04%x 0x04%x " 1101 "0x04%x 0x04%x: %s\n", 1102 detail->seq, 1103 detail->time, 1104 detail->class.members.locale, 1105 detail->class.members.class, 1106 detail->args.pci.venderId, 1107 detail->args.pci.deviceId, 1108 detail->args.pci.subVenderId, 1109 detail->args.pci.subDeviceId, 1110 detail->description 1111 ); 1112 break; 1113 case MR_EVT_ARGS_RATE: 1114 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - Rebuild rate %d: %s\n", 1115 detail->seq, 1116 detail->time, 1117 detail->class.members.locale, 1118 detail->class.members.class, 1119 detail->args.rate, 1120 detail->description 1121 ); 1122 break; 1123 case MR_EVT_ARGS_TIME: 1124 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - Adapter ticks %d " 1125 "elapsed %ds: %s\n", 1126 detail->seq, 1127 detail->time, 1128 detail->class.members.locale, 1129 detail->class.members.class, 1130 detail->args.time.rtc, 1131 detail->args.time.elapsedSeconds, 1132 detail->description 1133 ); 1134 break; 1135 case MR_EVT_ARGS_ECC: 1136 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - Adapter ECC %x,%x: %s: %s\n", 1137 detail->seq, 1138 detail->time, 1139 detail->class.members.locale, 1140 detail->class.members.class, 1141 detail->args.ecc.ecar, 1142 detail->args.ecc.elog, 1143 detail->args.ecc.str, 1144 detail->description 1145 ); 1146 break; 1147 default: 1148 device_printf(sc->mfi_dev, "%d (%us/0x%04x/%d) - Type %d: %s\n", 1149 detail->seq, 1150 detail->time, 1151 detail->class.members.locale, 1152 detail->class.members.class, 1153 detail->arg_type, detail->description 1154 ); 1155 } 1156 } 1157 1158 static int 1159 mfi_aen_register(struct mfi_softc *sc, int seq, int locale) 1160 { 1161 struct mfi_command *cm; 1162 struct mfi_dcmd_frame *dcmd; 1163 union mfi_evt current_aen, prior_aen; 1164 struct mfi_evt_detail *ed = NULL; 1165 int error = 0; 1166 1167 current_aen.word = locale; 1168 if (sc->mfi_aen_cm != NULL) { 1169 prior_aen.word = 1170 ((uint32_t *)&sc->mfi_aen_cm->cm_frame->dcmd.mbox)[1]; 1171 if (prior_aen.members.class <= current_aen.members.class && 1172 !((prior_aen.members.locale & current_aen.members.locale) 1173 ^current_aen.members.locale)) { 1174 return (0); 1175 } else { 1176 prior_aen.members.locale |= current_aen.members.locale; 1177 if (prior_aen.members.class 1178 < current_aen.members.class) 1179 current_aen.members.class = 1180 prior_aen.members.class; 1181 mfi_abort(sc, sc->mfi_aen_cm); 1182 } 1183 } 1184 1185 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_EVENT_WAIT, 1186 (void **)&ed, sizeof(*ed)); 1187 if (error) { 1188 goto out; 1189 } 1190 1191 dcmd = &cm->cm_frame->dcmd; 1192 ((uint32_t *)&dcmd->mbox)[0] = seq; 1193 ((uint32_t *)&dcmd->mbox)[1] = locale; 1194 cm->cm_flags = MFI_CMD_DATAIN; 1195 cm->cm_complete = mfi_aen_complete; 1196 1197 sc->mfi_aen_cm = cm; 1198 1199 mfi_enqueue_ready(cm); 1200 mfi_startio(sc); 1201 1202 out: 1203 return (error); 1204 } 1205 1206 static void 1207 mfi_aen_complete(struct mfi_command *cm) 1208 { 1209 struct mfi_frame_header *hdr; 1210 struct mfi_softc *sc; 1211 struct mfi_evt_detail *detail; 1212 struct mfi_aen *mfi_aen_entry, *tmp; 1213 int seq = 0, aborted = 0; 1214 1215 sc = cm->cm_sc; 1216 hdr = &cm->cm_frame->header; 1217 1218 if (sc->mfi_aen_cm == NULL) 1219 return; 1220 1221 if (sc->mfi_aen_cm->cm_aen_abort || hdr->cmd_status == 0xff) { 1222 sc->mfi_aen_cm->cm_aen_abort = 0; 1223 aborted = 1; 1224 } else { 1225 sc->mfi_aen_triggered = 1; 1226 if (sc->mfi_poll_waiting) { 1227 sc->mfi_poll_waiting = 0; 1228 selwakeup(&sc->mfi_select); 1229 } 1230 detail = cm->cm_data; 1231 /* 1232 * XXX If this function is too expensive or is recursive, then 1233 * events should be put onto a queue and processed later. 1234 */ 1235 mtx_unlock(&sc->mfi_io_lock); 1236 mfi_decode_evt(sc, detail); 1237 mtx_lock(&sc->mfi_io_lock); 1238 seq = detail->seq + 1; 1239 TAILQ_FOREACH_SAFE(mfi_aen_entry, &sc->mfi_aen_pids, aen_link, tmp) { 1240 TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry, 1241 aen_link); 1242 PROC_LOCK(mfi_aen_entry->p); 1243 psignal(mfi_aen_entry->p, SIGIO); 1244 PROC_UNLOCK(mfi_aen_entry->p); 1245 free(mfi_aen_entry, M_MFIBUF); 1246 } 1247 } 1248 1249 free(cm->cm_data, M_MFIBUF); 1250 sc->mfi_aen_cm = NULL; 1251 wakeup(&sc->mfi_aen_cm); 1252 mfi_release_command(cm); 1253 1254 /* set it up again so the driver can catch more events */ 1255 if (!aborted) { 1256 mfi_aen_setup(sc, seq); 1257 } 1258 } 1259 1260 /* Only do one event for now so we can easily iterate through them */ 1261 #define MAX_EVENTS 1 1262 static int 1263 mfi_get_entry(struct mfi_softc *sc, int seq) 1264 { 1265 struct mfi_command *cm; 1266 struct mfi_dcmd_frame *dcmd; 1267 struct mfi_evt_list *el; 1268 int error; 1269 int i; 1270 int size; 1271 1272 if ((cm = mfi_dequeue_free(sc)) == NULL) { 1273 return (EBUSY); 1274 } 1275 1276 size = sizeof(struct mfi_evt_list) + sizeof(struct mfi_evt_detail) 1277 * (MAX_EVENTS - 1); 1278 el = malloc(size, M_MFIBUF, M_NOWAIT | M_ZERO); 1279 if (el == NULL) { 1280 mfi_release_command(cm); 1281 return (ENOMEM); 1282 } 1283 1284 dcmd = &cm->cm_frame->dcmd; 1285 bzero(dcmd->mbox, MFI_MBOX_SIZE); 1286 dcmd->header.cmd = MFI_CMD_DCMD; 1287 dcmd->header.timeout = 0; 1288 dcmd->header.data_len = size; 1289 dcmd->opcode = MFI_DCMD_CTRL_EVENT_GET; 1290 ((uint32_t *)&dcmd->mbox)[0] = seq; 1291 ((uint32_t *)&dcmd->mbox)[1] = MFI_EVT_LOCALE_ALL; 1292 cm->cm_sg = &dcmd->sgl; 1293 cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE; 1294 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED; 1295 cm->cm_data = el; 1296 cm->cm_len = size; 1297 1298 if ((error = mfi_mapcmd(sc, cm)) != 0) { 1299 device_printf(sc->mfi_dev, "Failed to get controller entry\n"); 1300 sc->mfi_max_io = (sc->mfi_max_sge - 1) * PAGE_SIZE / 1301 MFI_SECTOR_LEN; 1302 free(el, M_MFIBUF); 1303 mfi_release_command(cm); 1304 return (0); 1305 } 1306 1307 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, 1308 BUS_DMASYNC_POSTREAD); 1309 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 1310 1311 if (dcmd->header.cmd_status != MFI_STAT_NOT_FOUND) { 1312 for (i = 0; i < el->count; i++) { 1313 if (seq + i == el->event[i].seq) 1314 mfi_decode_evt(sc, &el->event[i]); 1315 } 1316 } 1317 1318 free(cm->cm_data, M_MFIBUF); 1319 mfi_release_command(cm); 1320 return (0); 1321 } 1322 1323 static int 1324 mfi_add_ld(struct mfi_softc *sc, int id) 1325 { 1326 struct mfi_command *cm; 1327 struct mfi_dcmd_frame *dcmd = NULL; 1328 struct mfi_ld_info *ld_info = NULL; 1329 int error; 1330 1331 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1332 1333 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_LD_GET_INFO, 1334 (void **)&ld_info, sizeof(*ld_info)); 1335 if (error) { 1336 device_printf(sc->mfi_dev, 1337 "Failed to allocate for MFI_DCMD_LD_GET_INFO %d\n", error); 1338 if (ld_info) 1339 free(ld_info, M_MFIBUF); 1340 return (error); 1341 } 1342 cm->cm_flags = MFI_CMD_DATAIN; 1343 dcmd = &cm->cm_frame->dcmd; 1344 dcmd->mbox[0] = id; 1345 if (mfi_wait_command(sc, cm) != 0) { 1346 device_printf(sc->mfi_dev, 1347 "Failed to get logical drive: %d\n", id); 1348 free(ld_info, M_MFIBUF); 1349 return (0); 1350 } 1351 1352 mfi_add_ld_complete(cm); 1353 return (0); 1354 } 1355 1356 static void 1357 mfi_add_ld_complete(struct mfi_command *cm) 1358 { 1359 struct mfi_frame_header *hdr; 1360 struct mfi_ld_info *ld_info; 1361 struct mfi_softc *sc; 1362 struct mfi_ld *ld; 1363 device_t child; 1364 1365 sc = cm->cm_sc; 1366 hdr = &cm->cm_frame->header; 1367 ld_info = cm->cm_private; 1368 1369 if (hdr->cmd_status != MFI_STAT_OK) { 1370 free(ld_info, M_MFIBUF); 1371 mfi_release_command(cm); 1372 return; 1373 } 1374 mfi_release_command(cm); 1375 1376 ld = malloc(sizeof(struct mfi_ld), M_MFIBUF, M_NOWAIT|M_ZERO); 1377 if (ld == NULL) { 1378 device_printf(sc->mfi_dev, "Cannot allocate ld\n"); 1379 free(ld_info, M_MFIBUF); 1380 return; 1381 } 1382 1383 if ((child = device_add_child(sc->mfi_dev, "mfid", -1)) == NULL) { 1384 device_printf(sc->mfi_dev, "Failed to add logical disk\n"); 1385 free(ld, M_MFIBUF); 1386 free(ld_info, M_MFIBUF); 1387 return; 1388 } 1389 1390 ld->ld_id = ld_info->ld_config.properties.ld.v.target_id; 1391 ld->ld_disk = child; 1392 ld->ld_info = ld_info; 1393 1394 device_set_ivars(child, ld); 1395 device_set_desc(child, "MFI Logical Disk"); 1396 mtx_unlock(&sc->mfi_io_lock); 1397 mtx_lock(&Giant); 1398 bus_generic_attach(sc->mfi_dev); 1399 mtx_unlock(&Giant); 1400 mtx_lock(&sc->mfi_io_lock); 1401 } 1402 1403 static struct mfi_command * 1404 mfi_bio_command(struct mfi_softc *sc) 1405 { 1406 struct mfi_io_frame *io; 1407 struct mfi_command *cm; 1408 struct bio *bio; 1409 int flags, blkcount; 1410 1411 if ((cm = mfi_dequeue_free(sc)) == NULL) 1412 return (NULL); 1413 1414 if ((bio = mfi_dequeue_bio(sc)) == NULL) { 1415 mfi_release_command(cm); 1416 return (NULL); 1417 } 1418 1419 io = &cm->cm_frame->io; 1420 switch (bio->bio_cmd & 0x03) { 1421 case BIO_READ: 1422 io->header.cmd = MFI_CMD_LD_READ; 1423 flags = MFI_CMD_DATAIN; 1424 break; 1425 case BIO_WRITE: 1426 io->header.cmd = MFI_CMD_LD_WRITE; 1427 flags = MFI_CMD_DATAOUT; 1428 break; 1429 default: 1430 panic("Invalid bio command"); 1431 } 1432 1433 /* Cheat with the sector length to avoid a non-constant division */ 1434 blkcount = (bio->bio_bcount + MFI_SECTOR_LEN - 1) / MFI_SECTOR_LEN; 1435 io->header.target_id = (uintptr_t)bio->bio_driver1; 1436 io->header.timeout = 0; 1437 io->header.flags = 0; 1438 io->header.sense_len = MFI_SENSE_LEN; 1439 io->header.data_len = blkcount; 1440 io->sense_addr_lo = cm->cm_sense_busaddr; 1441 io->sense_addr_hi = 0; 1442 io->lba_hi = (bio->bio_pblkno & 0xffffffff00000000) >> 32; 1443 io->lba_lo = bio->bio_pblkno & 0xffffffff; 1444 cm->cm_complete = mfi_bio_complete; 1445 cm->cm_private = bio; 1446 cm->cm_data = bio->bio_data; 1447 cm->cm_len = bio->bio_bcount; 1448 cm->cm_sg = &io->sgl; 1449 cm->cm_total_frame_size = MFI_IO_FRAME_SIZE; 1450 cm->cm_flags = flags; 1451 return (cm); 1452 } 1453 1454 static void 1455 mfi_bio_complete(struct mfi_command *cm) 1456 { 1457 struct bio *bio; 1458 struct mfi_frame_header *hdr; 1459 struct mfi_softc *sc; 1460 1461 bio = cm->cm_private; 1462 hdr = &cm->cm_frame->header; 1463 sc = cm->cm_sc; 1464 1465 if ((hdr->cmd_status != 0) || (hdr->scsi_status != 0)) { 1466 bio->bio_flags |= BIO_ERROR; 1467 bio->bio_error = EIO; 1468 device_printf(sc->mfi_dev, "I/O error, status= %d " 1469 "scsi_status= %d\n", hdr->cmd_status, hdr->scsi_status); 1470 mfi_print_sense(cm->cm_sc, cm->cm_sense); 1471 } 1472 1473 mfi_release_command(cm); 1474 mfi_disk_complete(bio); 1475 } 1476 1477 void 1478 mfi_startio(struct mfi_softc *sc) 1479 { 1480 struct mfi_command *cm; 1481 1482 for (;;) { 1483 /* Don't bother if we're short on resources */ 1484 if (sc->mfi_flags & MFI_FLAGS_QFRZN) 1485 break; 1486 1487 /* Try a command that has already been prepared */ 1488 cm = mfi_dequeue_ready(sc); 1489 1490 /* Nope, so look for work on the bioq */ 1491 if (cm == NULL) 1492 cm = mfi_bio_command(sc); 1493 1494 /* No work available, so exit */ 1495 if (cm == NULL) 1496 break; 1497 1498 /* Send the command to the controller */ 1499 if (mfi_mapcmd(sc, cm) != 0) { 1500 mfi_requeue_ready(cm); 1501 break; 1502 } 1503 } 1504 } 1505 1506 static int 1507 mfi_mapcmd(struct mfi_softc *sc, struct mfi_command *cm) 1508 { 1509 int error, polled; 1510 1511 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1512 1513 if (cm->cm_data != NULL) { 1514 polled = (cm->cm_flags & MFI_CMD_POLLED) ? BUS_DMA_NOWAIT : 0; 1515 error = bus_dmamap_load(sc->mfi_buffer_dmat, cm->cm_dmamap, 1516 cm->cm_data, cm->cm_len, mfi_data_cb, cm, polled); 1517 if (error == EINPROGRESS) { 1518 sc->mfi_flags |= MFI_FLAGS_QFRZN; 1519 return (0); 1520 } 1521 } else { 1522 error = mfi_send_frame(sc, cm); 1523 } 1524 1525 return (error); 1526 } 1527 1528 static void 1529 mfi_data_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 1530 { 1531 struct mfi_frame_header *hdr; 1532 struct mfi_command *cm; 1533 union mfi_sgl *sgl; 1534 struct mfi_softc *sc; 1535 int i, dir; 1536 1537 if (error) 1538 return; 1539 1540 cm = (struct mfi_command *)arg; 1541 sc = cm->cm_sc; 1542 hdr = &cm->cm_frame->header; 1543 sgl = cm->cm_sg; 1544 1545 if ((sc->mfi_flags & MFI_FLAGS_SG64) == 0) { 1546 for (i = 0; i < nsegs; i++) { 1547 sgl->sg32[i].addr = segs[i].ds_addr; 1548 sgl->sg32[i].len = segs[i].ds_len; 1549 } 1550 } else { 1551 for (i = 0; i < nsegs; i++) { 1552 sgl->sg64[i].addr = segs[i].ds_addr; 1553 sgl->sg64[i].len = segs[i].ds_len; 1554 } 1555 hdr->flags |= MFI_FRAME_SGL64; 1556 } 1557 hdr->sg_count = nsegs; 1558 1559 dir = 0; 1560 if (cm->cm_flags & MFI_CMD_DATAIN) { 1561 dir |= BUS_DMASYNC_PREREAD; 1562 hdr->flags |= MFI_FRAME_DIR_READ; 1563 } 1564 if (cm->cm_flags & MFI_CMD_DATAOUT) { 1565 dir |= BUS_DMASYNC_PREWRITE; 1566 hdr->flags |= MFI_FRAME_DIR_WRITE; 1567 } 1568 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, dir); 1569 cm->cm_flags |= MFI_CMD_MAPPED; 1570 1571 /* 1572 * Instead of calculating the total number of frames in the 1573 * compound frame, it's already assumed that there will be at 1574 * least 1 frame, so don't compensate for the modulo of the 1575 * following division. 1576 */ 1577 cm->cm_total_frame_size += (sc->mfi_sge_size * nsegs); 1578 cm->cm_extra_frames = (cm->cm_total_frame_size - 1) / MFI_FRAME_SIZE; 1579 1580 mfi_send_frame(sc, cm); 1581 1582 return; 1583 } 1584 1585 static int 1586 mfi_send_frame(struct mfi_softc *sc, struct mfi_command *cm) 1587 { 1588 struct mfi_frame_header *hdr; 1589 int tm = MFI_POLL_TIMEOUT_SECS * 1000; 1590 1591 hdr = &cm->cm_frame->header; 1592 1593 if ((cm->cm_flags & MFI_CMD_POLLED) == 0) { 1594 cm->cm_timestamp = time_uptime; 1595 mfi_enqueue_busy(cm); 1596 } else { 1597 hdr->cmd_status = 0xff; 1598 hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE; 1599 } 1600 1601 /* 1602 * The bus address of the command is aligned on a 64 byte boundary, 1603 * leaving the least 6 bits as zero. For whatever reason, the 1604 * hardware wants the address shifted right by three, leaving just 1605 * 3 zero bits. These three bits are then used as a prefetching 1606 * hint for the hardware to predict how many frames need to be 1607 * fetched across the bus. If a command has more than 8 frames 1608 * then the 3 bits are set to 0x7 and the firmware uses other 1609 * information in the command to determine the total amount to fetch. 1610 * However, FreeBSD doesn't support I/O larger than 128K, so 8 frames 1611 * is enough for both 32bit and 64bit systems. 1612 */ 1613 if (cm->cm_extra_frames > 7) 1614 cm->cm_extra_frames = 7; 1615 1616 MFI_WRITE4(sc, MFI_IQP, (cm->cm_frame_busaddr >> 3) | 1617 cm->cm_extra_frames); 1618 1619 if ((cm->cm_flags & MFI_CMD_POLLED) == 0) 1620 return (0); 1621 1622 /* This is a polled command, so busy-wait for it to complete. */ 1623 while (hdr->cmd_status == 0xff) { 1624 DELAY(1000); 1625 tm -= 1; 1626 if (tm <= 0) 1627 break; 1628 } 1629 1630 if (hdr->cmd_status == 0xff) { 1631 device_printf(sc->mfi_dev, "Frame %p timed out " 1632 "command 0x%X\n", hdr, cm->cm_frame->dcmd.opcode); 1633 return (ETIMEDOUT); 1634 } 1635 1636 return (0); 1637 } 1638 1639 static void 1640 mfi_complete(struct mfi_softc *sc, struct mfi_command *cm) 1641 { 1642 int dir; 1643 1644 if ((cm->cm_flags & MFI_CMD_MAPPED) != 0) { 1645 dir = 0; 1646 if (cm->cm_flags & MFI_CMD_DATAIN) 1647 dir |= BUS_DMASYNC_POSTREAD; 1648 if (cm->cm_flags & MFI_CMD_DATAOUT) 1649 dir |= BUS_DMASYNC_POSTWRITE; 1650 1651 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, dir); 1652 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 1653 cm->cm_flags &= ~MFI_CMD_MAPPED; 1654 } 1655 1656 if (cm->cm_complete != NULL) 1657 cm->cm_complete(cm); 1658 else 1659 wakeup(cm); 1660 } 1661 1662 static int 1663 mfi_abort(struct mfi_softc *sc, struct mfi_command *cm_abort) 1664 { 1665 struct mfi_command *cm; 1666 struct mfi_abort_frame *abort; 1667 int i = 0; 1668 1669 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1670 1671 if ((cm = mfi_dequeue_free(sc)) == NULL) { 1672 return (EBUSY); 1673 } 1674 1675 abort = &cm->cm_frame->abort; 1676 abort->header.cmd = MFI_CMD_ABORT; 1677 abort->header.flags = 0; 1678 abort->abort_context = cm_abort->cm_frame->header.context; 1679 abort->abort_mfi_addr_lo = cm_abort->cm_frame_busaddr; 1680 abort->abort_mfi_addr_hi = 0; 1681 cm->cm_data = NULL; 1682 cm->cm_flags = MFI_CMD_POLLED; 1683 1684 sc->mfi_aen_cm->cm_aen_abort = 1; 1685 mfi_mapcmd(sc, cm); 1686 mfi_release_command(cm); 1687 1688 while (i < 5 && sc->mfi_aen_cm != NULL) { 1689 msleep(&sc->mfi_aen_cm, &sc->mfi_io_lock, 0, "mfiabort", 5 * hz); 1690 i++; 1691 } 1692 1693 return (0); 1694 } 1695 1696 int 1697 mfi_dump_blocks(struct mfi_softc *sc, int id, uint64_t lba, void *virt, int len) 1698 { 1699 struct mfi_command *cm; 1700 struct mfi_io_frame *io; 1701 int error; 1702 1703 if ((cm = mfi_dequeue_free(sc)) == NULL) 1704 return (EBUSY); 1705 1706 io = &cm->cm_frame->io; 1707 io->header.cmd = MFI_CMD_LD_WRITE; 1708 io->header.target_id = id; 1709 io->header.timeout = 0; 1710 io->header.flags = 0; 1711 io->header.sense_len = MFI_SENSE_LEN; 1712 io->header.data_len = (len + MFI_SECTOR_LEN - 1) / MFI_SECTOR_LEN; 1713 io->sense_addr_lo = cm->cm_sense_busaddr; 1714 io->sense_addr_hi = 0; 1715 io->lba_hi = (lba & 0xffffffff00000000) >> 32; 1716 io->lba_lo = lba & 0xffffffff; 1717 cm->cm_data = virt; 1718 cm->cm_len = len; 1719 cm->cm_sg = &io->sgl; 1720 cm->cm_total_frame_size = MFI_IO_FRAME_SIZE; 1721 cm->cm_flags = MFI_CMD_POLLED | MFI_CMD_DATAOUT; 1722 1723 error = mfi_mapcmd(sc, cm); 1724 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, 1725 BUS_DMASYNC_POSTWRITE); 1726 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 1727 mfi_release_command(cm); 1728 1729 return (error); 1730 } 1731 1732 static int 1733 mfi_open(struct cdev *dev, int flags, int fmt, d_thread_t *td) 1734 { 1735 struct mfi_softc *sc; 1736 1737 sc = dev->si_drv1; 1738 1739 mtx_lock(&sc->mfi_io_lock); 1740 sc->mfi_flags |= MFI_FLAGS_OPEN; 1741 mtx_unlock(&sc->mfi_io_lock); 1742 1743 return (0); 1744 } 1745 1746 static int 1747 mfi_close(struct cdev *dev, int flags, int fmt, d_thread_t *td) 1748 { 1749 struct mfi_softc *sc; 1750 struct mfi_aen *mfi_aen_entry, *tmp; 1751 1752 sc = dev->si_drv1; 1753 1754 mtx_lock(&sc->mfi_io_lock); 1755 sc->mfi_flags &= ~MFI_FLAGS_OPEN; 1756 1757 TAILQ_FOREACH_SAFE(mfi_aen_entry, &sc->mfi_aen_pids, aen_link, tmp) { 1758 if (mfi_aen_entry->p == curproc) { 1759 TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry, 1760 aen_link); 1761 free(mfi_aen_entry, M_MFIBUF); 1762 } 1763 } 1764 mtx_unlock(&sc->mfi_io_lock); 1765 return (0); 1766 } 1767 1768 static int 1769 mfi_ioctl(struct cdev *dev, u_long cmd, caddr_t arg, int flag, d_thread_t *td) 1770 { 1771 struct mfi_softc *sc; 1772 union mfi_statrequest *ms; 1773 struct mfi_ioc_packet *ioc; 1774 struct mfi_ioc_aen *aen; 1775 struct mfi_command *cm = NULL; 1776 uint32_t context; 1777 uint8_t *sense_ptr; 1778 uint8_t *data = NULL, *temp; 1779 int i; 1780 int error; 1781 1782 sc = dev->si_drv1; 1783 error = 0; 1784 1785 switch (cmd) { 1786 case MFIIO_STATS: 1787 ms = (union mfi_statrequest *)arg; 1788 switch (ms->ms_item) { 1789 case MFIQ_FREE: 1790 case MFIQ_BIO: 1791 case MFIQ_READY: 1792 case MFIQ_BUSY: 1793 bcopy(&sc->mfi_qstat[ms->ms_item], &ms->ms_qstat, 1794 sizeof(struct mfi_qstat)); 1795 break; 1796 default: 1797 error = ENOIOCTL; 1798 break; 1799 } 1800 break; 1801 case MFI_CMD: 1802 ioc = (struct mfi_ioc_packet *)arg; 1803 1804 mtx_lock(&sc->mfi_io_lock); 1805 if ((cm = mfi_dequeue_free(sc)) == NULL) { 1806 mtx_unlock(&sc->mfi_io_lock); 1807 return (EBUSY); 1808 } 1809 mtx_unlock(&sc->mfi_io_lock); 1810 1811 /* 1812 * save off original context since copying from user 1813 * will clobber some data 1814 */ 1815 context = cm->cm_frame->header.context; 1816 1817 bcopy(ioc->mfi_frame.raw, cm->cm_frame, 1818 ioc->mfi_sgl_off); /* Linux can do 2 frames ? */ 1819 cm->cm_total_frame_size = ioc->mfi_sgl_off; 1820 cm->cm_sg = 1821 (union mfi_sgl *)&cm->cm_frame->bytes[ioc->mfi_sgl_off]; 1822 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_DATAOUT 1823 | MFI_CMD_POLLED; 1824 cm->cm_len = cm->cm_frame->header.data_len; 1825 cm->cm_data = data = malloc(cm->cm_len, M_MFIBUF, 1826 M_WAITOK | M_ZERO); 1827 if (cm->cm_data == NULL) { 1828 device_printf(sc->mfi_dev, "Malloc failed\n"); 1829 goto out; 1830 } 1831 1832 /* restore header context */ 1833 cm->cm_frame->header.context = context; 1834 1835 temp = data; 1836 for (i = 0; i < ioc->mfi_sge_count; i++) { 1837 error = copyin(ioc->mfi_sgl[i].iov_base, 1838 temp, 1839 ioc->mfi_sgl[i].iov_len); 1840 if (error != 0) { 1841 device_printf(sc->mfi_dev, 1842 "Copy in failed\n"); 1843 goto out; 1844 } 1845 temp = &temp[ioc->mfi_sgl[i].iov_len]; 1846 } 1847 1848 mtx_lock(&sc->mfi_io_lock); 1849 if ((error = mfi_mapcmd(sc, cm)) != 0) { 1850 device_printf(sc->mfi_dev, 1851 "Controller polled failed\n"); 1852 mtx_unlock(&sc->mfi_io_lock); 1853 goto out; 1854 } 1855 1856 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, 1857 BUS_DMASYNC_POSTREAD); 1858 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 1859 mtx_unlock(&sc->mfi_io_lock); 1860 1861 temp = data; 1862 for (i = 0; i < ioc->mfi_sge_count; i++) { 1863 error = copyout(temp, 1864 ioc->mfi_sgl[i].iov_base, 1865 ioc->mfi_sgl[i].iov_len); 1866 if (error != 0) { 1867 device_printf(sc->mfi_dev, 1868 "Copy out failed\n"); 1869 goto out; 1870 } 1871 temp = &temp[ioc->mfi_sgl[i].iov_len]; 1872 } 1873 1874 if (ioc->mfi_sense_len) { 1875 /* copy out sense */ 1876 sense_ptr = &((struct mfi_ioc_packet*)arg) 1877 ->mfi_frame.raw[0]; 1878 error = copyout(cm->cm_sense, sense_ptr, 1879 ioc->mfi_sense_len); 1880 if (error != 0) { 1881 device_printf(sc->mfi_dev, 1882 "Copy out failed\n"); 1883 goto out; 1884 } 1885 } 1886 1887 ioc->mfi_frame.hdr.cmd_status = cm->cm_frame->header.cmd_status; 1888 if (cm->cm_frame->header.cmd_status == MFI_STAT_OK) { 1889 switch (cm->cm_frame->dcmd.opcode) { 1890 case MFI_DCMD_CFG_CLEAR: 1891 case MFI_DCMD_CFG_ADD: 1892 /* 1893 mfi_ldrescan(sc); 1894 */ 1895 break; 1896 } 1897 } 1898 out: 1899 if (data) 1900 free(data, M_MFIBUF); 1901 if (cm) { 1902 mtx_lock(&sc->mfi_io_lock); 1903 mfi_release_command(cm); 1904 mtx_unlock(&sc->mfi_io_lock); 1905 } 1906 1907 break; 1908 case MFI_SET_AEN: 1909 aen = (struct mfi_ioc_aen *)arg; 1910 error = mfi_aen_register(sc, aen->aen_seq_num, 1911 aen->aen_class_locale); 1912 1913 break; 1914 case MFI_LINUX_CMD_2: /* Firmware Linux ioctl shim */ 1915 { 1916 devclass_t devclass; 1917 struct mfi_linux_ioc_packet l_ioc; 1918 int adapter; 1919 1920 devclass = devclass_find("mfi"); 1921 if (devclass == NULL) 1922 return (ENOENT); 1923 1924 error = copyin(arg, &l_ioc, sizeof(l_ioc)); 1925 if (error) 1926 return (error); 1927 adapter = l_ioc.lioc_adapter_no; 1928 sc = devclass_get_softc(devclass, adapter); 1929 if (sc == NULL) 1930 return (ENOENT); 1931 return (mfi_linux_ioctl_int(sc->mfi_cdev, 1932 cmd, arg, flag, td)); 1933 break; 1934 } 1935 case MFI_LINUX_SET_AEN_2: /* AEN Linux ioctl shim */ 1936 { 1937 devclass_t devclass; 1938 struct mfi_linux_ioc_aen l_aen; 1939 int adapter; 1940 1941 devclass = devclass_find("mfi"); 1942 if (devclass == NULL) 1943 return (ENOENT); 1944 1945 error = copyin(arg, &l_aen, sizeof(l_aen)); 1946 if (error) 1947 return (error); 1948 adapter = l_aen.laen_adapter_no; 1949 sc = devclass_get_softc(devclass, adapter); 1950 if (sc == NULL) 1951 return (ENOENT); 1952 return (mfi_linux_ioctl_int(sc->mfi_cdev, 1953 cmd, arg, flag, td)); 1954 break; 1955 } 1956 default: 1957 device_printf(sc->mfi_dev, "IOCTL 0x%lx not handled\n", cmd); 1958 error = ENOENT; 1959 break; 1960 } 1961 1962 return (error); 1963 } 1964 1965 static int 1966 mfi_linux_ioctl_int(struct cdev *dev, u_long cmd, caddr_t arg, int flag, d_thread_t *td) 1967 { 1968 struct mfi_softc *sc; 1969 struct mfi_linux_ioc_packet l_ioc; 1970 struct mfi_linux_ioc_aen l_aen; 1971 struct mfi_command *cm = NULL; 1972 struct mfi_aen *mfi_aen_entry; 1973 uint8_t *sense_ptr; 1974 uint32_t context; 1975 uint8_t *data = NULL, *temp; 1976 void *temp_convert; 1977 int i; 1978 int error; 1979 1980 sc = dev->si_drv1; 1981 error = 0; 1982 switch (cmd) { 1983 case MFI_LINUX_CMD_2: /* Firmware Linux ioctl shim */ 1984 error = copyin(arg, &l_ioc, sizeof(l_ioc)); 1985 if (error != 0) 1986 return (error); 1987 1988 if (l_ioc.lioc_sge_count > MAX_LINUX_IOCTL_SGE) { 1989 return (EINVAL); 1990 } 1991 1992 mtx_lock(&sc->mfi_io_lock); 1993 if ((cm = mfi_dequeue_free(sc)) == NULL) { 1994 mtx_unlock(&sc->mfi_io_lock); 1995 return (EBUSY); 1996 } 1997 mtx_unlock(&sc->mfi_io_lock); 1998 1999 /* 2000 * save off original context since copying from user 2001 * will clobber some data 2002 */ 2003 context = cm->cm_frame->header.context; 2004 2005 bcopy(l_ioc.lioc_frame.raw, cm->cm_frame, 2006 l_ioc.lioc_sgl_off); /* Linux can do 2 frames ? */ 2007 cm->cm_total_frame_size = l_ioc.lioc_sgl_off; 2008 cm->cm_sg = 2009 (union mfi_sgl *)&cm->cm_frame->bytes[l_ioc.lioc_sgl_off]; 2010 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_DATAOUT 2011 | MFI_CMD_POLLED; 2012 cm->cm_len = cm->cm_frame->header.data_len; 2013 cm->cm_data = data = malloc(cm->cm_len, M_MFIBUF, 2014 M_WAITOK | M_ZERO); 2015 2016 /* restore header context */ 2017 cm->cm_frame->header.context = context; 2018 2019 temp = data; 2020 for (i = 0; i < l_ioc.lioc_sge_count; i++) { 2021 temp_convert = 2022 (void *)(uintptr_t)l_ioc.lioc_sgl[i].iov_base; 2023 error = copyin(temp_convert, 2024 temp, 2025 l_ioc.lioc_sgl[i].iov_len); 2026 if (error != 0) { 2027 device_printf(sc->mfi_dev, 2028 "Copy in failed\n"); 2029 goto out; 2030 } 2031 temp = &temp[l_ioc.lioc_sgl[i].iov_len]; 2032 } 2033 2034 mtx_lock(&sc->mfi_io_lock); 2035 if ((error = mfi_mapcmd(sc, cm)) != 0) { 2036 device_printf(sc->mfi_dev, 2037 "Controller polled failed\n"); 2038 mtx_unlock(&sc->mfi_io_lock); 2039 goto out; 2040 } 2041 2042 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, 2043 BUS_DMASYNC_POSTREAD); 2044 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 2045 mtx_unlock(&sc->mfi_io_lock); 2046 2047 temp = data; 2048 for (i = 0; i < l_ioc.lioc_sge_count; i++) { 2049 temp_convert = 2050 (void *)(uintptr_t)l_ioc.lioc_sgl[i].iov_base; 2051 error = copyout(temp, 2052 temp_convert, 2053 l_ioc.lioc_sgl[i].iov_len); 2054 if (error != 0) { 2055 device_printf(sc->mfi_dev, 2056 "Copy out failed\n"); 2057 goto out; 2058 } 2059 temp = &temp[l_ioc.lioc_sgl[i].iov_len]; 2060 } 2061 2062 if (l_ioc.lioc_sense_len) { 2063 /* copy out sense */ 2064 sense_ptr = &((struct mfi_linux_ioc_packet*)arg) 2065 ->lioc_frame.raw[0]; 2066 error = copyout(cm->cm_sense, sense_ptr, 2067 l_ioc.lioc_sense_len); 2068 if (error != 0) { 2069 device_printf(sc->mfi_dev, 2070 "Copy out failed\n"); 2071 goto out; 2072 } 2073 } 2074 2075 error = copyout(&cm->cm_frame->header.cmd_status, 2076 &((struct mfi_linux_ioc_packet*)arg) 2077 ->lioc_frame.hdr.cmd_status, 2078 1); 2079 if (error != 0) { 2080 device_printf(sc->mfi_dev, 2081 "Copy out failed\n"); 2082 goto out; 2083 } 2084 2085 if (cm->cm_frame->header.cmd_status == MFI_STAT_OK) { 2086 switch (cm->cm_frame->dcmd.opcode) { 2087 case MFI_DCMD_CFG_CLEAR: 2088 case MFI_DCMD_CFG_ADD: 2089 /* mfi_ldrescan(sc); */ 2090 break; 2091 } 2092 } 2093 out: 2094 if (data) 2095 free(data, M_MFIBUF); 2096 if (cm) { 2097 mtx_lock(&sc->mfi_io_lock); 2098 mfi_release_command(cm); 2099 mtx_unlock(&sc->mfi_io_lock); 2100 } 2101 2102 return (error); 2103 case MFI_LINUX_SET_AEN_2: /* AEN Linux ioctl shim */ 2104 error = copyin(arg, &l_aen, sizeof(l_aen)); 2105 if (error != 0) 2106 return (error); 2107 printf("AEN IMPLEMENTED for pid %d\n", curproc->p_pid); 2108 mfi_aen_entry = malloc(sizeof(struct mfi_aen), M_MFIBUF, 2109 M_WAITOK); 2110 mtx_lock(&sc->mfi_io_lock); 2111 if (mfi_aen_entry != NULL) { 2112 mfi_aen_entry->p = curproc; 2113 TAILQ_INSERT_TAIL(&sc->mfi_aen_pids, mfi_aen_entry, 2114 aen_link); 2115 } 2116 error = mfi_aen_register(sc, l_aen.laen_seq_num, 2117 l_aen.laen_class_locale); 2118 2119 if (error != 0) { 2120 TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry, 2121 aen_link); 2122 free(mfi_aen_entry, M_MFIBUF); 2123 } 2124 mtx_unlock(&sc->mfi_io_lock); 2125 2126 return (error); 2127 default: 2128 device_printf(sc->mfi_dev, "IOCTL 0x%lx not handled\n", cmd); 2129 error = ENOENT; 2130 break; 2131 } 2132 2133 return (error); 2134 } 2135 2136 static int 2137 mfi_poll(struct cdev *dev, int poll_events, struct thread *td) 2138 { 2139 struct mfi_softc *sc; 2140 int revents = 0; 2141 2142 sc = dev->si_drv1; 2143 2144 if (poll_events & (POLLIN | POLLRDNORM)) { 2145 if (sc->mfi_aen_triggered != 0) { 2146 revents |= poll_events & (POLLIN | POLLRDNORM); 2147 sc->mfi_aen_triggered = 0; 2148 } 2149 if (sc->mfi_aen_triggered == 0 && sc->mfi_aen_cm == NULL) { 2150 revents |= POLLERR; 2151 } 2152 } 2153 2154 if (revents == 0) { 2155 if (poll_events & (POLLIN | POLLRDNORM)) { 2156 sc->mfi_poll_waiting = 1; 2157 selrecord(td, &sc->mfi_select); 2158 } 2159 } 2160 2161 return revents; 2162 } 2163 2164 2165 static void 2166 mfi_dump_all(void) 2167 { 2168 struct mfi_softc *sc; 2169 struct mfi_command *cm; 2170 devclass_t dc; 2171 time_t deadline; 2172 int timedout; 2173 int i; 2174 2175 dc = devclass_find("mfi"); 2176 if (dc == NULL) { 2177 printf("No mfi dev class\n"); 2178 return; 2179 } 2180 2181 for (i = 0; ; i++) { 2182 sc = devclass_get_softc(dc, i); 2183 if (sc == NULL) 2184 break; 2185 device_printf(sc->mfi_dev, "Dumping\n\n"); 2186 timedout = 0; 2187 deadline = time_uptime - MFI_CMD_TIMEOUT; 2188 mtx_lock(&sc->mfi_io_lock); 2189 TAILQ_FOREACH(cm, &sc->mfi_busy, cm_link) { 2190 if (cm->cm_timestamp < deadline) { 2191 device_printf(sc->mfi_dev, 2192 "COMMAND %p TIMEOUT AFTER %d SECONDS\n", cm, 2193 (int)(time_uptime - cm->cm_timestamp)); 2194 MFI_PRINT_CMD(cm); 2195 timedout++; 2196 } 2197 } 2198 2199 #if 0 2200 if (timedout) 2201 MFI_DUMP_CMDS(SC); 2202 #endif 2203 2204 mtx_unlock(&sc->mfi_io_lock); 2205 } 2206 2207 return; 2208 } 2209 2210 static void 2211 mfi_timeout(void *data) 2212 { 2213 struct mfi_softc *sc = (struct mfi_softc *)data; 2214 struct mfi_command *cm; 2215 time_t deadline; 2216 int timedout = 0; 2217 2218 deadline = time_uptime - MFI_CMD_TIMEOUT; 2219 mtx_lock(&sc->mfi_io_lock); 2220 TAILQ_FOREACH(cm, &sc->mfi_busy, cm_link) { 2221 if (sc->mfi_aen_cm == cm) 2222 continue; 2223 if ((sc->mfi_aen_cm != cm) && (cm->cm_timestamp < deadline)) { 2224 device_printf(sc->mfi_dev, 2225 "COMMAND %p TIMEOUT AFTER %d SECONDS\n", cm, 2226 (int)(time_uptime - cm->cm_timestamp)); 2227 MFI_PRINT_CMD(cm); 2228 MFI_VALIDATE_CMD(sc, cm); 2229 timedout++; 2230 } 2231 } 2232 2233 #if 0 2234 if (timedout) 2235 MFI_DUMP_CMDS(SC); 2236 #endif 2237 2238 mtx_unlock(&sc->mfi_io_lock); 2239 2240 callout_reset(&sc->mfi_watchdog_callout, MFI_CMD_TIMEOUT * hz, 2241 mfi_timeout, sc); 2242 2243 if (0) 2244 mfi_dump_all(); 2245 return; 2246 } 2247