1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD AND BSD-2-Clause 3 * 4 * Copyright (c) 2006 IronPort Systems 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 /*- 29 * Copyright (c) 2007 LSI Corp. 30 * Copyright (c) 2007 Rajesh Prabhakaran. 31 * All rights reserved. 32 * 33 * Redistribution and use in source and binary forms, with or without 34 * modification, are permitted provided that the following conditions 35 * are met: 36 * 1. Redistributions of source code must retain the above copyright 37 * notice, this list of conditions and the following disclaimer. 38 * 2. Redistributions in binary form must reproduce the above copyright 39 * notice, this list of conditions and the following disclaimer in the 40 * documentation and/or other materials provided with the distribution. 41 * 42 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 43 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 44 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 45 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 46 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 47 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 48 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 49 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 50 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 51 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 52 * SUCH DAMAGE. 53 */ 54 55 #include <sys/cdefs.h> 56 __FBSDID("$FreeBSD$"); 57 58 #include "opt_mfi.h" 59 60 #include <sys/param.h> 61 #include <sys/systm.h> 62 #include <sys/sysctl.h> 63 #include <sys/malloc.h> 64 #include <sys/kernel.h> 65 #include <sys/poll.h> 66 #include <sys/selinfo.h> 67 #include <sys/bus.h> 68 #include <sys/conf.h> 69 #include <sys/eventhandler.h> 70 #include <sys/rman.h> 71 #include <sys/bio.h> 72 #include <sys/ioccom.h> 73 #include <sys/uio.h> 74 #include <sys/proc.h> 75 #include <sys/signalvar.h> 76 #include <sys/sysent.h> 77 #include <sys/taskqueue.h> 78 79 #include <machine/bus.h> 80 #include <machine/resource.h> 81 82 #include <dev/mfi/mfireg.h> 83 #include <dev/mfi/mfi_ioctl.h> 84 #include <dev/mfi/mfivar.h> 85 #include <sys/interrupt.h> 86 #include <sys/priority.h> 87 88 static int mfi_alloc_commands(struct mfi_softc *); 89 static int mfi_comms_init(struct mfi_softc *); 90 static int mfi_get_controller_info(struct mfi_softc *); 91 static int mfi_get_log_state(struct mfi_softc *, 92 struct mfi_evt_log_state **); 93 static int mfi_parse_entries(struct mfi_softc *, int, int); 94 static void mfi_data_cb(void *, bus_dma_segment_t *, int, int); 95 static void mfi_startup(void *arg); 96 static void mfi_intr(void *arg); 97 static void mfi_ldprobe(struct mfi_softc *sc); 98 static void mfi_syspdprobe(struct mfi_softc *sc); 99 static void mfi_handle_evt(void *context, int pending); 100 static int mfi_aen_register(struct mfi_softc *sc, int seq, int locale); 101 static void mfi_aen_complete(struct mfi_command *); 102 static int mfi_add_ld(struct mfi_softc *sc, int); 103 static void mfi_add_ld_complete(struct mfi_command *); 104 static int mfi_add_sys_pd(struct mfi_softc *sc, int); 105 static void mfi_add_sys_pd_complete(struct mfi_command *); 106 static struct mfi_command * mfi_bio_command(struct mfi_softc *); 107 static void mfi_bio_complete(struct mfi_command *); 108 static struct mfi_command *mfi_build_ldio(struct mfi_softc *,struct bio*); 109 static struct mfi_command *mfi_build_syspdio(struct mfi_softc *,struct bio*); 110 static int mfi_send_frame(struct mfi_softc *, struct mfi_command *); 111 static int mfi_std_send_frame(struct mfi_softc *, struct mfi_command *); 112 static int mfi_abort(struct mfi_softc *, struct mfi_command **); 113 static int mfi_linux_ioctl_int(struct cdev *, u_long, caddr_t, int, struct thread *); 114 static void mfi_timeout(void *); 115 static int mfi_user_command(struct mfi_softc *, 116 struct mfi_ioc_passthru *); 117 static void mfi_enable_intr_xscale(struct mfi_softc *sc); 118 static void mfi_enable_intr_ppc(struct mfi_softc *sc); 119 static int32_t mfi_read_fw_status_xscale(struct mfi_softc *sc); 120 static int32_t mfi_read_fw_status_ppc(struct mfi_softc *sc); 121 static int mfi_check_clear_intr_xscale(struct mfi_softc *sc); 122 static int mfi_check_clear_intr_ppc(struct mfi_softc *sc); 123 static void mfi_issue_cmd_xscale(struct mfi_softc *sc, bus_addr_t bus_add, 124 uint32_t frame_cnt); 125 static void mfi_issue_cmd_ppc(struct mfi_softc *sc, bus_addr_t bus_add, 126 uint32_t frame_cnt); 127 static int mfi_config_lock(struct mfi_softc *sc, uint32_t opcode); 128 static void mfi_config_unlock(struct mfi_softc *sc, int locked); 129 static int mfi_check_command_pre(struct mfi_softc *sc, struct mfi_command *cm); 130 static void mfi_check_command_post(struct mfi_softc *sc, struct mfi_command *cm); 131 static int mfi_check_for_sscd(struct mfi_softc *sc, struct mfi_command *cm); 132 133 SYSCTL_NODE(_hw, OID_AUTO, mfi, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, 134 "MFI driver parameters"); 135 static int mfi_event_locale = MFI_EVT_LOCALE_ALL; 136 SYSCTL_INT(_hw_mfi, OID_AUTO, event_locale, CTLFLAG_RWTUN, &mfi_event_locale, 137 0, "event message locale"); 138 139 static int mfi_event_class = MFI_EVT_CLASS_INFO; 140 SYSCTL_INT(_hw_mfi, OID_AUTO, event_class, CTLFLAG_RWTUN, &mfi_event_class, 141 0, "event message class"); 142 143 static int mfi_max_cmds = 128; 144 SYSCTL_INT(_hw_mfi, OID_AUTO, max_cmds, CTLFLAG_RDTUN, &mfi_max_cmds, 145 0, "Max commands limit (-1 = controller limit)"); 146 147 static int mfi_detect_jbod_change = 1; 148 SYSCTL_INT(_hw_mfi, OID_AUTO, detect_jbod_change, CTLFLAG_RWTUN, 149 &mfi_detect_jbod_change, 0, "Detect a change to a JBOD"); 150 151 int mfi_polled_cmd_timeout = MFI_POLL_TIMEOUT_SECS; 152 SYSCTL_INT(_hw_mfi, OID_AUTO, polled_cmd_timeout, CTLFLAG_RWTUN, 153 &mfi_polled_cmd_timeout, 0, 154 "Polled command timeout - used for firmware flash etc (in seconds)"); 155 156 static int mfi_cmd_timeout = MFI_CMD_TIMEOUT; 157 SYSCTL_INT(_hw_mfi, OID_AUTO, cmd_timeout, CTLFLAG_RWTUN, &mfi_cmd_timeout, 158 0, "Command timeout (in seconds)"); 159 160 /* Management interface */ 161 static d_open_t mfi_open; 162 static d_close_t mfi_close; 163 static d_ioctl_t mfi_ioctl; 164 static d_poll_t mfi_poll; 165 166 static struct cdevsw mfi_cdevsw = { 167 .d_version = D_VERSION, 168 .d_flags = 0, 169 .d_open = mfi_open, 170 .d_close = mfi_close, 171 .d_ioctl = mfi_ioctl, 172 .d_poll = mfi_poll, 173 .d_name = "mfi", 174 }; 175 176 MALLOC_DEFINE(M_MFIBUF, "mfibuf", "Buffers for the MFI driver"); 177 178 #define MFI_INQ_LENGTH SHORT_INQUIRY_LENGTH 179 struct mfi_skinny_dma_info mfi_skinny; 180 181 static void 182 mfi_enable_intr_xscale(struct mfi_softc *sc) 183 { 184 MFI_WRITE4(sc, MFI_OMSK, 0x01); 185 } 186 187 static void 188 mfi_enable_intr_ppc(struct mfi_softc *sc) 189 { 190 if (sc->mfi_flags & MFI_FLAGS_1078) { 191 MFI_WRITE4(sc, MFI_ODCR0, 0xFFFFFFFF); 192 MFI_WRITE4(sc, MFI_OMSK, ~MFI_1078_EIM); 193 } 194 else if (sc->mfi_flags & MFI_FLAGS_GEN2) { 195 MFI_WRITE4(sc, MFI_ODCR0, 0xFFFFFFFF); 196 MFI_WRITE4(sc, MFI_OMSK, ~MFI_GEN2_EIM); 197 } 198 else if (sc->mfi_flags & MFI_FLAGS_SKINNY) { 199 MFI_WRITE4(sc, MFI_OMSK, ~0x00000001); 200 } 201 } 202 203 static int32_t 204 mfi_read_fw_status_xscale(struct mfi_softc *sc) 205 { 206 return MFI_READ4(sc, MFI_OMSG0); 207 } 208 209 static int32_t 210 mfi_read_fw_status_ppc(struct mfi_softc *sc) 211 { 212 return MFI_READ4(sc, MFI_OSP0); 213 } 214 215 static int 216 mfi_check_clear_intr_xscale(struct mfi_softc *sc) 217 { 218 int32_t status; 219 220 status = MFI_READ4(sc, MFI_OSTS); 221 if ((status & MFI_OSTS_INTR_VALID) == 0) 222 return 1; 223 224 MFI_WRITE4(sc, MFI_OSTS, status); 225 return 0; 226 } 227 228 static int 229 mfi_check_clear_intr_ppc(struct mfi_softc *sc) 230 { 231 int32_t status; 232 233 status = MFI_READ4(sc, MFI_OSTS); 234 if (sc->mfi_flags & MFI_FLAGS_1078) { 235 if (!(status & MFI_1078_RM)) { 236 return 1; 237 } 238 } 239 else if (sc->mfi_flags & MFI_FLAGS_GEN2) { 240 if (!(status & MFI_GEN2_RM)) { 241 return 1; 242 } 243 } 244 else if (sc->mfi_flags & MFI_FLAGS_SKINNY) { 245 if (!(status & MFI_SKINNY_RM)) { 246 return 1; 247 } 248 } 249 if (sc->mfi_flags & MFI_FLAGS_SKINNY) 250 MFI_WRITE4(sc, MFI_OSTS, status); 251 else 252 MFI_WRITE4(sc, MFI_ODCR0, status); 253 return 0; 254 } 255 256 static void 257 mfi_issue_cmd_xscale(struct mfi_softc *sc, bus_addr_t bus_add, uint32_t frame_cnt) 258 { 259 MFI_WRITE4(sc, MFI_IQP,(bus_add >>3)|frame_cnt); 260 } 261 262 static void 263 mfi_issue_cmd_ppc(struct mfi_softc *sc, bus_addr_t bus_add, uint32_t frame_cnt) 264 { 265 if (sc->mfi_flags & MFI_FLAGS_SKINNY) { 266 MFI_WRITE4(sc, MFI_IQPL, (bus_add | frame_cnt <<1)|1 ); 267 MFI_WRITE4(sc, MFI_IQPH, 0x00000000); 268 } else { 269 MFI_WRITE4(sc, MFI_IQP, (bus_add | frame_cnt <<1)|1 ); 270 } 271 } 272 273 int 274 mfi_transition_firmware(struct mfi_softc *sc) 275 { 276 uint32_t fw_state, cur_state; 277 int max_wait, i; 278 uint32_t cur_abs_reg_val = 0; 279 uint32_t prev_abs_reg_val = 0; 280 281 cur_abs_reg_val = sc->mfi_read_fw_status(sc); 282 fw_state = cur_abs_reg_val & MFI_FWSTATE_MASK; 283 while (fw_state != MFI_FWSTATE_READY) { 284 if (bootverbose) 285 device_printf(sc->mfi_dev, "Waiting for firmware to " 286 "become ready\n"); 287 cur_state = fw_state; 288 switch (fw_state) { 289 case MFI_FWSTATE_FAULT: 290 device_printf(sc->mfi_dev, "Firmware fault\n"); 291 return (ENXIO); 292 case MFI_FWSTATE_WAIT_HANDSHAKE: 293 if (sc->mfi_flags & MFI_FLAGS_SKINNY || sc->mfi_flags & MFI_FLAGS_TBOLT) 294 MFI_WRITE4(sc, MFI_SKINNY_IDB, MFI_FWINIT_CLEAR_HANDSHAKE); 295 else 296 MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_CLEAR_HANDSHAKE); 297 max_wait = MFI_RESET_WAIT_TIME; 298 break; 299 case MFI_FWSTATE_OPERATIONAL: 300 if (sc->mfi_flags & MFI_FLAGS_SKINNY || sc->mfi_flags & MFI_FLAGS_TBOLT) 301 MFI_WRITE4(sc, MFI_SKINNY_IDB, 7); 302 else 303 MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_READY); 304 max_wait = MFI_RESET_WAIT_TIME; 305 break; 306 case MFI_FWSTATE_UNDEFINED: 307 case MFI_FWSTATE_BB_INIT: 308 max_wait = MFI_RESET_WAIT_TIME; 309 break; 310 case MFI_FWSTATE_FW_INIT_2: 311 max_wait = MFI_RESET_WAIT_TIME; 312 break; 313 case MFI_FWSTATE_FW_INIT: 314 case MFI_FWSTATE_FLUSH_CACHE: 315 max_wait = MFI_RESET_WAIT_TIME; 316 break; 317 case MFI_FWSTATE_DEVICE_SCAN: 318 max_wait = MFI_RESET_WAIT_TIME; /* wait for 180 seconds */ 319 prev_abs_reg_val = cur_abs_reg_val; 320 break; 321 case MFI_FWSTATE_BOOT_MESSAGE_PENDING: 322 if (sc->mfi_flags & MFI_FLAGS_SKINNY || sc->mfi_flags & MFI_FLAGS_TBOLT) 323 MFI_WRITE4(sc, MFI_SKINNY_IDB, MFI_FWINIT_HOTPLUG); 324 else 325 MFI_WRITE4(sc, MFI_IDB, MFI_FWINIT_HOTPLUG); 326 max_wait = MFI_RESET_WAIT_TIME; 327 break; 328 default: 329 device_printf(sc->mfi_dev, "Unknown firmware state %#x\n", 330 fw_state); 331 return (ENXIO); 332 } 333 for (i = 0; i < (max_wait * 10); i++) { 334 cur_abs_reg_val = sc->mfi_read_fw_status(sc); 335 fw_state = cur_abs_reg_val & MFI_FWSTATE_MASK; 336 if (fw_state == cur_state) 337 DELAY(100000); 338 else 339 break; 340 } 341 if (fw_state == MFI_FWSTATE_DEVICE_SCAN) { 342 /* Check the device scanning progress */ 343 if (prev_abs_reg_val != cur_abs_reg_val) { 344 continue; 345 } 346 } 347 if (fw_state == cur_state) { 348 device_printf(sc->mfi_dev, "Firmware stuck in state " 349 "%#x\n", fw_state); 350 return (ENXIO); 351 } 352 } 353 return (0); 354 } 355 356 static void 357 mfi_addr_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 358 { 359 bus_addr_t *addr; 360 361 addr = arg; 362 *addr = segs[0].ds_addr; 363 } 364 365 366 int 367 mfi_attach(struct mfi_softc *sc) 368 { 369 uint32_t status; 370 int error, commsz, framessz, sensesz; 371 int frames, unit, max_fw_sge, max_fw_cmds; 372 uint32_t tb_mem_size = 0; 373 struct cdev *dev_t; 374 375 if (sc == NULL) 376 return EINVAL; 377 378 device_printf(sc->mfi_dev, "Megaraid SAS driver Ver %s \n", 379 MEGASAS_VERSION); 380 381 mtx_init(&sc->mfi_io_lock, "MFI I/O lock", NULL, MTX_DEF); 382 sx_init(&sc->mfi_config_lock, "MFI config"); 383 TAILQ_INIT(&sc->mfi_ld_tqh); 384 TAILQ_INIT(&sc->mfi_syspd_tqh); 385 TAILQ_INIT(&sc->mfi_ld_pend_tqh); 386 TAILQ_INIT(&sc->mfi_syspd_pend_tqh); 387 TAILQ_INIT(&sc->mfi_evt_queue); 388 TASK_INIT(&sc->mfi_evt_task, 0, mfi_handle_evt, sc); 389 TASK_INIT(&sc->mfi_map_sync_task, 0, mfi_handle_map_sync, sc); 390 TAILQ_INIT(&sc->mfi_aen_pids); 391 TAILQ_INIT(&sc->mfi_cam_ccbq); 392 393 mfi_initq_free(sc); 394 mfi_initq_ready(sc); 395 mfi_initq_busy(sc); 396 mfi_initq_bio(sc); 397 398 sc->adpreset = 0; 399 sc->last_seq_num = 0; 400 sc->disableOnlineCtrlReset = 1; 401 sc->issuepend_done = 1; 402 sc->hw_crit_error = 0; 403 404 if (sc->mfi_flags & MFI_FLAGS_1064R) { 405 sc->mfi_enable_intr = mfi_enable_intr_xscale; 406 sc->mfi_read_fw_status = mfi_read_fw_status_xscale; 407 sc->mfi_check_clear_intr = mfi_check_clear_intr_xscale; 408 sc->mfi_issue_cmd = mfi_issue_cmd_xscale; 409 } else if (sc->mfi_flags & MFI_FLAGS_TBOLT) { 410 sc->mfi_enable_intr = mfi_tbolt_enable_intr_ppc; 411 sc->mfi_disable_intr = mfi_tbolt_disable_intr_ppc; 412 sc->mfi_read_fw_status = mfi_tbolt_read_fw_status_ppc; 413 sc->mfi_check_clear_intr = mfi_tbolt_check_clear_intr_ppc; 414 sc->mfi_issue_cmd = mfi_tbolt_issue_cmd_ppc; 415 sc->mfi_adp_reset = mfi_tbolt_adp_reset; 416 sc->mfi_tbolt = 1; 417 TAILQ_INIT(&sc->mfi_cmd_tbolt_tqh); 418 } else { 419 sc->mfi_enable_intr = mfi_enable_intr_ppc; 420 sc->mfi_read_fw_status = mfi_read_fw_status_ppc; 421 sc->mfi_check_clear_intr = mfi_check_clear_intr_ppc; 422 sc->mfi_issue_cmd = mfi_issue_cmd_ppc; 423 } 424 425 426 /* Before we get too far, see if the firmware is working */ 427 if ((error = mfi_transition_firmware(sc)) != 0) { 428 device_printf(sc->mfi_dev, "Firmware not in READY state, " 429 "error %d\n", error); 430 return (ENXIO); 431 } 432 433 /* Start: LSIP200113393 */ 434 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */ 435 1, 0, /* algnmnt, boundary */ 436 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */ 437 BUS_SPACE_MAXADDR, /* highaddr */ 438 NULL, NULL, /* filter, filterarg */ 439 MEGASAS_MAX_NAME*sizeof(bus_addr_t), /* maxsize */ 440 1, /* msegments */ 441 MEGASAS_MAX_NAME*sizeof(bus_addr_t), /* maxsegsize */ 442 0, /* flags */ 443 NULL, NULL, /* lockfunc, lockarg */ 444 &sc->verbuf_h_dmat)) { 445 device_printf(sc->mfi_dev, "Cannot allocate verbuf_h_dmat DMA tag\n"); 446 return (ENOMEM); 447 } 448 if (bus_dmamem_alloc(sc->verbuf_h_dmat, (void **)&sc->verbuf, 449 BUS_DMA_NOWAIT, &sc->verbuf_h_dmamap)) { 450 device_printf(sc->mfi_dev, "Cannot allocate verbuf_h_dmamap memory\n"); 451 return (ENOMEM); 452 } 453 bzero(sc->verbuf, MEGASAS_MAX_NAME*sizeof(bus_addr_t)); 454 bus_dmamap_load(sc->verbuf_h_dmat, sc->verbuf_h_dmamap, 455 sc->verbuf, MEGASAS_MAX_NAME*sizeof(bus_addr_t), 456 mfi_addr_cb, &sc->verbuf_h_busaddr, 0); 457 /* End: LSIP200113393 */ 458 459 /* 460 * Get information needed for sizing the contiguous memory for the 461 * frame pool. Size down the sgl parameter since we know that 462 * we will never need more than what's required for MAXPHYS. 463 * It would be nice if these constants were available at runtime 464 * instead of compile time. 465 */ 466 status = sc->mfi_read_fw_status(sc); 467 max_fw_cmds = status & MFI_FWSTATE_MAXCMD_MASK; 468 if (mfi_max_cmds > 0 && mfi_max_cmds < max_fw_cmds) { 469 device_printf(sc->mfi_dev, "FW MaxCmds = %d, limiting to %d\n", 470 max_fw_cmds, mfi_max_cmds); 471 sc->mfi_max_fw_cmds = mfi_max_cmds; 472 } else { 473 sc->mfi_max_fw_cmds = max_fw_cmds; 474 } 475 max_fw_sge = (status & MFI_FWSTATE_MAXSGL_MASK) >> 16; 476 sc->mfi_max_sge = min(max_fw_sge, ((MFI_MAXPHYS / PAGE_SIZE) + 1)); 477 478 /* ThunderBolt Support get the contiguous memory */ 479 480 if (sc->mfi_flags & MFI_FLAGS_TBOLT) { 481 mfi_tbolt_init_globals(sc); 482 device_printf(sc->mfi_dev, "MaxCmd = %d, Drv MaxCmd = %d, " 483 "MaxSgl = %d, state = %#x\n", max_fw_cmds, 484 sc->mfi_max_fw_cmds, sc->mfi_max_sge, status); 485 tb_mem_size = mfi_tbolt_get_memory_requirement(sc); 486 487 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */ 488 1, 0, /* algnmnt, boundary */ 489 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */ 490 BUS_SPACE_MAXADDR, /* highaddr */ 491 NULL, NULL, /* filter, filterarg */ 492 tb_mem_size, /* maxsize */ 493 1, /* msegments */ 494 tb_mem_size, /* maxsegsize */ 495 0, /* flags */ 496 NULL, NULL, /* lockfunc, lockarg */ 497 &sc->mfi_tb_dmat)) { 498 device_printf(sc->mfi_dev, "Cannot allocate comms DMA tag\n"); 499 return (ENOMEM); 500 } 501 if (bus_dmamem_alloc(sc->mfi_tb_dmat, (void **)&sc->request_message_pool, 502 BUS_DMA_NOWAIT, &sc->mfi_tb_dmamap)) { 503 device_printf(sc->mfi_dev, "Cannot allocate comms memory\n"); 504 return (ENOMEM); 505 } 506 bzero(sc->request_message_pool, tb_mem_size); 507 bus_dmamap_load(sc->mfi_tb_dmat, sc->mfi_tb_dmamap, 508 sc->request_message_pool, tb_mem_size, mfi_addr_cb, &sc->mfi_tb_busaddr, 0); 509 510 /* For ThunderBolt memory init */ 511 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */ 512 0x100, 0, /* alignmnt, boundary */ 513 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */ 514 BUS_SPACE_MAXADDR, /* highaddr */ 515 NULL, NULL, /* filter, filterarg */ 516 MFI_FRAME_SIZE, /* maxsize */ 517 1, /* msegments */ 518 MFI_FRAME_SIZE, /* maxsegsize */ 519 0, /* flags */ 520 NULL, NULL, /* lockfunc, lockarg */ 521 &sc->mfi_tb_init_dmat)) { 522 device_printf(sc->mfi_dev, "Cannot allocate init DMA tag\n"); 523 return (ENOMEM); 524 } 525 if (bus_dmamem_alloc(sc->mfi_tb_init_dmat, (void **)&sc->mfi_tb_init, 526 BUS_DMA_NOWAIT, &sc->mfi_tb_init_dmamap)) { 527 device_printf(sc->mfi_dev, "Cannot allocate init memory\n"); 528 return (ENOMEM); 529 } 530 bzero(sc->mfi_tb_init, MFI_FRAME_SIZE); 531 bus_dmamap_load(sc->mfi_tb_init_dmat, sc->mfi_tb_init_dmamap, 532 sc->mfi_tb_init, MFI_FRAME_SIZE, mfi_addr_cb, 533 &sc->mfi_tb_init_busaddr, 0); 534 if (mfi_tbolt_init_desc_pool(sc, sc->request_message_pool, 535 tb_mem_size)) { 536 device_printf(sc->mfi_dev, 537 "Thunderbolt pool preparation error\n"); 538 return 0; 539 } 540 541 /* 542 Allocate DMA memory mapping for MPI2 IOC Init descriptor, 543 we are taking it different from what we have allocated for Request 544 and reply descriptors to avoid confusion later 545 */ 546 tb_mem_size = sizeof(struct MPI2_IOC_INIT_REQUEST); 547 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */ 548 1, 0, /* algnmnt, boundary */ 549 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */ 550 BUS_SPACE_MAXADDR, /* highaddr */ 551 NULL, NULL, /* filter, filterarg */ 552 tb_mem_size, /* maxsize */ 553 1, /* msegments */ 554 tb_mem_size, /* maxsegsize */ 555 0, /* flags */ 556 NULL, NULL, /* lockfunc, lockarg */ 557 &sc->mfi_tb_ioc_init_dmat)) { 558 device_printf(sc->mfi_dev, 559 "Cannot allocate comms DMA tag\n"); 560 return (ENOMEM); 561 } 562 if (bus_dmamem_alloc(sc->mfi_tb_ioc_init_dmat, 563 (void **)&sc->mfi_tb_ioc_init_desc, 564 BUS_DMA_NOWAIT, &sc->mfi_tb_ioc_init_dmamap)) { 565 device_printf(sc->mfi_dev, "Cannot allocate comms memory\n"); 566 return (ENOMEM); 567 } 568 bzero(sc->mfi_tb_ioc_init_desc, tb_mem_size); 569 bus_dmamap_load(sc->mfi_tb_ioc_init_dmat, sc->mfi_tb_ioc_init_dmamap, 570 sc->mfi_tb_ioc_init_desc, tb_mem_size, mfi_addr_cb, 571 &sc->mfi_tb_ioc_init_busaddr, 0); 572 } 573 /* 574 * Create the dma tag for data buffers. Used both for block I/O 575 * and for various internal data queries. 576 */ 577 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */ 578 1, 0, /* algnmnt, boundary */ 579 BUS_SPACE_MAXADDR, /* lowaddr */ 580 BUS_SPACE_MAXADDR, /* highaddr */ 581 NULL, NULL, /* filter, filterarg */ 582 BUS_SPACE_MAXSIZE_32BIT,/* maxsize */ 583 sc->mfi_max_sge, /* nsegments */ 584 BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */ 585 BUS_DMA_ALLOCNOW, /* flags */ 586 busdma_lock_mutex, /* lockfunc */ 587 &sc->mfi_io_lock, /* lockfuncarg */ 588 &sc->mfi_buffer_dmat)) { 589 device_printf(sc->mfi_dev, "Cannot allocate buffer DMA tag\n"); 590 return (ENOMEM); 591 } 592 593 /* 594 * Allocate DMA memory for the comms queues. Keep it under 4GB for 595 * efficiency. The mfi_hwcomms struct includes space for 1 reply queue 596 * entry, so the calculated size here will be will be 1 more than 597 * mfi_max_fw_cmds. This is apparently a requirement of the hardware. 598 */ 599 commsz = (sizeof(uint32_t) * sc->mfi_max_fw_cmds) + 600 sizeof(struct mfi_hwcomms); 601 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */ 602 1, 0, /* algnmnt, boundary */ 603 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */ 604 BUS_SPACE_MAXADDR, /* highaddr */ 605 NULL, NULL, /* filter, filterarg */ 606 commsz, /* maxsize */ 607 1, /* msegments */ 608 commsz, /* maxsegsize */ 609 0, /* flags */ 610 NULL, NULL, /* lockfunc, lockarg */ 611 &sc->mfi_comms_dmat)) { 612 device_printf(sc->mfi_dev, "Cannot allocate comms DMA tag\n"); 613 return (ENOMEM); 614 } 615 if (bus_dmamem_alloc(sc->mfi_comms_dmat, (void **)&sc->mfi_comms, 616 BUS_DMA_NOWAIT, &sc->mfi_comms_dmamap)) { 617 device_printf(sc->mfi_dev, "Cannot allocate comms memory\n"); 618 return (ENOMEM); 619 } 620 bzero(sc->mfi_comms, commsz); 621 bus_dmamap_load(sc->mfi_comms_dmat, sc->mfi_comms_dmamap, 622 sc->mfi_comms, commsz, mfi_addr_cb, &sc->mfi_comms_busaddr, 0); 623 /* 624 * Allocate DMA memory for the command frames. Keep them in the 625 * lower 4GB for efficiency. Calculate the size of the commands at 626 * the same time; each command is one 64 byte frame plus a set of 627 * additional frames for holding sg lists or other data. 628 * The assumption here is that the SG list will start at the second 629 * frame and not use the unused bytes in the first frame. While this 630 * isn't technically correct, it simplifies the calculation and allows 631 * for command frames that might be larger than an mfi_io_frame. 632 */ 633 if (sizeof(bus_addr_t) == 8) { 634 sc->mfi_sge_size = sizeof(struct mfi_sg64); 635 sc->mfi_flags |= MFI_FLAGS_SG64; 636 } else { 637 sc->mfi_sge_size = sizeof(struct mfi_sg32); 638 } 639 if (sc->mfi_flags & MFI_FLAGS_SKINNY) 640 sc->mfi_sge_size = sizeof(struct mfi_sg_skinny); 641 frames = (sc->mfi_sge_size * sc->mfi_max_sge - 1) / MFI_FRAME_SIZE + 2; 642 sc->mfi_cmd_size = frames * MFI_FRAME_SIZE; 643 framessz = sc->mfi_cmd_size * sc->mfi_max_fw_cmds; 644 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */ 645 64, 0, /* algnmnt, boundary */ 646 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */ 647 BUS_SPACE_MAXADDR, /* highaddr */ 648 NULL, NULL, /* filter, filterarg */ 649 framessz, /* maxsize */ 650 1, /* nsegments */ 651 framessz, /* maxsegsize */ 652 0, /* flags */ 653 NULL, NULL, /* lockfunc, lockarg */ 654 &sc->mfi_frames_dmat)) { 655 device_printf(sc->mfi_dev, "Cannot allocate frame DMA tag\n"); 656 return (ENOMEM); 657 } 658 if (bus_dmamem_alloc(sc->mfi_frames_dmat, (void **)&sc->mfi_frames, 659 BUS_DMA_NOWAIT, &sc->mfi_frames_dmamap)) { 660 device_printf(sc->mfi_dev, "Cannot allocate frames memory\n"); 661 return (ENOMEM); 662 } 663 bzero(sc->mfi_frames, framessz); 664 bus_dmamap_load(sc->mfi_frames_dmat, sc->mfi_frames_dmamap, 665 sc->mfi_frames, framessz, mfi_addr_cb, &sc->mfi_frames_busaddr,0); 666 /* 667 * Allocate DMA memory for the frame sense data. Keep them in the 668 * lower 4GB for efficiency 669 */ 670 sensesz = sc->mfi_max_fw_cmds * MFI_SENSE_LEN; 671 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */ 672 4, 0, /* algnmnt, boundary */ 673 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */ 674 BUS_SPACE_MAXADDR, /* highaddr */ 675 NULL, NULL, /* filter, filterarg */ 676 sensesz, /* maxsize */ 677 1, /* nsegments */ 678 sensesz, /* maxsegsize */ 679 0, /* flags */ 680 NULL, NULL, /* lockfunc, lockarg */ 681 &sc->mfi_sense_dmat)) { 682 device_printf(sc->mfi_dev, "Cannot allocate sense DMA tag\n"); 683 return (ENOMEM); 684 } 685 if (bus_dmamem_alloc(sc->mfi_sense_dmat, (void **)&sc->mfi_sense, 686 BUS_DMA_NOWAIT, &sc->mfi_sense_dmamap)) { 687 device_printf(sc->mfi_dev, "Cannot allocate sense memory\n"); 688 return (ENOMEM); 689 } 690 bus_dmamap_load(sc->mfi_sense_dmat, sc->mfi_sense_dmamap, 691 sc->mfi_sense, sensesz, mfi_addr_cb, &sc->mfi_sense_busaddr, 0); 692 if ((error = mfi_alloc_commands(sc)) != 0) 693 return (error); 694 695 /* Before moving the FW to operational state, check whether 696 * hostmemory is required by the FW or not 697 */ 698 699 /* ThunderBolt MFI_IOC2 INIT */ 700 if (sc->mfi_flags & MFI_FLAGS_TBOLT) { 701 sc->mfi_disable_intr(sc); 702 mtx_lock(&sc->mfi_io_lock); 703 if ((error = mfi_tbolt_init_MFI_queue(sc)) != 0) { 704 device_printf(sc->mfi_dev, 705 "TB Init has failed with error %d\n",error); 706 mtx_unlock(&sc->mfi_io_lock); 707 return error; 708 } 709 mtx_unlock(&sc->mfi_io_lock); 710 711 if ((error = mfi_tbolt_alloc_cmd(sc)) != 0) 712 return error; 713 if (bus_setup_intr(sc->mfi_dev, sc->mfi_irq, 714 INTR_MPSAFE|INTR_TYPE_BIO, NULL, mfi_intr_tbolt, sc, 715 &sc->mfi_intr)) { 716 device_printf(sc->mfi_dev, "Cannot set up interrupt\n"); 717 return (EINVAL); 718 } 719 sc->mfi_intr_ptr = mfi_intr_tbolt; 720 sc->mfi_enable_intr(sc); 721 } else { 722 if ((error = mfi_comms_init(sc)) != 0) 723 return (error); 724 725 if (bus_setup_intr(sc->mfi_dev, sc->mfi_irq, 726 INTR_MPSAFE|INTR_TYPE_BIO, NULL, mfi_intr, sc, &sc->mfi_intr)) { 727 device_printf(sc->mfi_dev, "Cannot set up interrupt\n"); 728 return (EINVAL); 729 } 730 sc->mfi_intr_ptr = mfi_intr; 731 sc->mfi_enable_intr(sc); 732 } 733 if ((error = mfi_get_controller_info(sc)) != 0) 734 return (error); 735 sc->disableOnlineCtrlReset = 0; 736 737 /* Register a config hook to probe the bus for arrays */ 738 sc->mfi_ich.ich_func = mfi_startup; 739 sc->mfi_ich.ich_arg = sc; 740 if (config_intrhook_establish(&sc->mfi_ich) != 0) { 741 device_printf(sc->mfi_dev, "Cannot establish configuration " 742 "hook\n"); 743 return (EINVAL); 744 } 745 mtx_lock(&sc->mfi_io_lock); 746 if ((error = mfi_aen_setup(sc, 0), 0) != 0) { 747 mtx_unlock(&sc->mfi_io_lock); 748 return (error); 749 } 750 mtx_unlock(&sc->mfi_io_lock); 751 752 /* 753 * Register a shutdown handler. 754 */ 755 if ((sc->mfi_eh = EVENTHANDLER_REGISTER(shutdown_final, mfi_shutdown, 756 sc, SHUTDOWN_PRI_DEFAULT)) == NULL) { 757 device_printf(sc->mfi_dev, "Warning: shutdown event " 758 "registration failed\n"); 759 } 760 761 /* 762 * Create the control device for doing management 763 */ 764 unit = device_get_unit(sc->mfi_dev); 765 sc->mfi_cdev = make_dev(&mfi_cdevsw, unit, UID_ROOT, GID_OPERATOR, 766 0640, "mfi%d", unit); 767 if (unit == 0) 768 make_dev_alias_p(MAKEDEV_CHECKNAME | MAKEDEV_WAITOK, &dev_t, 769 sc->mfi_cdev, "%s", "megaraid_sas_ioctl_node"); 770 if (sc->mfi_cdev != NULL) 771 sc->mfi_cdev->si_drv1 = sc; 772 SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->mfi_dev), 773 SYSCTL_CHILDREN(device_get_sysctl_tree(sc->mfi_dev)), 774 OID_AUTO, "delete_busy_volumes", CTLFLAG_RW, 775 &sc->mfi_delete_busy_volumes, 0, "Allow removal of busy volumes"); 776 SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->mfi_dev), 777 SYSCTL_CHILDREN(device_get_sysctl_tree(sc->mfi_dev)), 778 OID_AUTO, "keep_deleted_volumes", CTLFLAG_RW, 779 &sc->mfi_keep_deleted_volumes, 0, 780 "Don't detach the mfid device for a busy volume that is deleted"); 781 782 device_add_child(sc->mfi_dev, "mfip", -1); 783 bus_generic_attach(sc->mfi_dev); 784 785 /* Start the timeout watchdog */ 786 callout_init(&sc->mfi_watchdog_callout, 1); 787 callout_reset(&sc->mfi_watchdog_callout, mfi_cmd_timeout * hz, 788 mfi_timeout, sc); 789 790 if (sc->mfi_flags & MFI_FLAGS_TBOLT) { 791 mtx_lock(&sc->mfi_io_lock); 792 mfi_tbolt_sync_map_info(sc); 793 mtx_unlock(&sc->mfi_io_lock); 794 } 795 796 return (0); 797 } 798 799 static int 800 mfi_alloc_commands(struct mfi_softc *sc) 801 { 802 struct mfi_command *cm; 803 int i, j; 804 805 /* 806 * XXX Should we allocate all the commands up front, or allocate on 807 * demand later like 'aac' does? 808 */ 809 sc->mfi_commands = malloc(sizeof(sc->mfi_commands[0]) * 810 sc->mfi_max_fw_cmds, M_MFIBUF, M_WAITOK | M_ZERO); 811 812 for (i = 0; i < sc->mfi_max_fw_cmds; i++) { 813 cm = &sc->mfi_commands[i]; 814 cm->cm_frame = (union mfi_frame *)((uintptr_t)sc->mfi_frames + 815 sc->mfi_cmd_size * i); 816 cm->cm_frame_busaddr = sc->mfi_frames_busaddr + 817 sc->mfi_cmd_size * i; 818 cm->cm_frame->header.context = i; 819 cm->cm_sense = &sc->mfi_sense[i]; 820 cm->cm_sense_busaddr= sc->mfi_sense_busaddr + MFI_SENSE_LEN * i; 821 cm->cm_sc = sc; 822 cm->cm_index = i; 823 if (bus_dmamap_create(sc->mfi_buffer_dmat, 0, 824 &cm->cm_dmamap) == 0) { 825 mtx_lock(&sc->mfi_io_lock); 826 mfi_release_command(cm); 827 mtx_unlock(&sc->mfi_io_lock); 828 } else { 829 device_printf(sc->mfi_dev, "Failed to allocate %d " 830 "command blocks, only allocated %d\n", 831 sc->mfi_max_fw_cmds, i - 1); 832 for (j = 0; j < i; j++) { 833 cm = &sc->mfi_commands[i]; 834 bus_dmamap_destroy(sc->mfi_buffer_dmat, 835 cm->cm_dmamap); 836 } 837 free(sc->mfi_commands, M_MFIBUF); 838 sc->mfi_commands = NULL; 839 840 return (ENOMEM); 841 } 842 } 843 844 return (0); 845 } 846 847 void 848 mfi_release_command(struct mfi_command *cm) 849 { 850 struct mfi_frame_header *hdr; 851 uint32_t *hdr_data; 852 853 mtx_assert(&cm->cm_sc->mfi_io_lock, MA_OWNED); 854 855 /* 856 * Zero out the important fields of the frame, but make sure the 857 * context field is preserved. For efficiency, handle the fields 858 * as 32 bit words. Clear out the first S/G entry too for safety. 859 */ 860 hdr = &cm->cm_frame->header; 861 if (cm->cm_data != NULL && hdr->sg_count) { 862 cm->cm_sg->sg32[0].len = 0; 863 cm->cm_sg->sg32[0].addr = 0; 864 } 865 866 /* 867 * Command may be on other queues e.g. busy queue depending on the 868 * flow of a previous call to mfi_mapcmd, so ensure its dequeued 869 * properly 870 */ 871 if ((cm->cm_flags & MFI_ON_MFIQ_BUSY) != 0) 872 mfi_remove_busy(cm); 873 if ((cm->cm_flags & MFI_ON_MFIQ_READY) != 0) 874 mfi_remove_ready(cm); 875 876 /* We're not expecting it to be on any other queue but check */ 877 if ((cm->cm_flags & MFI_ON_MFIQ_MASK) != 0) { 878 panic("Command %p is still on another queue, flags = %#x", 879 cm, cm->cm_flags); 880 } 881 882 /* tbolt cleanup */ 883 if ((cm->cm_flags & MFI_CMD_TBOLT) != 0) { 884 mfi_tbolt_return_cmd(cm->cm_sc, 885 cm->cm_sc->mfi_cmd_pool_tbolt[cm->cm_extra_frames - 1], 886 cm); 887 } 888 889 hdr_data = (uint32_t *)cm->cm_frame; 890 hdr_data[0] = 0; /* cmd, sense_len, cmd_status, scsi_status */ 891 hdr_data[1] = 0; /* target_id, lun_id, cdb_len, sg_count */ 892 hdr_data[4] = 0; /* flags, timeout */ 893 hdr_data[5] = 0; /* data_len */ 894 895 cm->cm_extra_frames = 0; 896 cm->cm_flags = 0; 897 cm->cm_complete = NULL; 898 cm->cm_private = NULL; 899 cm->cm_data = NULL; 900 cm->cm_sg = 0; 901 cm->cm_total_frame_size = 0; 902 cm->retry_for_fw_reset = 0; 903 904 mfi_enqueue_free(cm); 905 } 906 907 int 908 mfi_dcmd_command(struct mfi_softc *sc, struct mfi_command **cmp, 909 uint32_t opcode, void **bufp, size_t bufsize) 910 { 911 struct mfi_command *cm; 912 struct mfi_dcmd_frame *dcmd; 913 void *buf = NULL; 914 uint32_t context = 0; 915 916 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 917 918 cm = mfi_dequeue_free(sc); 919 if (cm == NULL) 920 return (EBUSY); 921 922 /* Zero out the MFI frame */ 923 context = cm->cm_frame->header.context; 924 bzero(cm->cm_frame, sizeof(union mfi_frame)); 925 cm->cm_frame->header.context = context; 926 927 if ((bufsize > 0) && (bufp != NULL)) { 928 if (*bufp == NULL) { 929 buf = malloc(bufsize, M_MFIBUF, M_NOWAIT|M_ZERO); 930 if (buf == NULL) { 931 mfi_release_command(cm); 932 return (ENOMEM); 933 } 934 *bufp = buf; 935 } else { 936 buf = *bufp; 937 } 938 } 939 940 dcmd = &cm->cm_frame->dcmd; 941 bzero(dcmd->mbox, MFI_MBOX_SIZE); 942 dcmd->header.cmd = MFI_CMD_DCMD; 943 dcmd->header.timeout = 0; 944 dcmd->header.flags = 0; 945 dcmd->header.data_len = bufsize; 946 dcmd->header.scsi_status = 0; 947 dcmd->opcode = opcode; 948 cm->cm_sg = &dcmd->sgl; 949 cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE; 950 cm->cm_flags = 0; 951 cm->cm_data = buf; 952 cm->cm_private = buf; 953 cm->cm_len = bufsize; 954 955 *cmp = cm; 956 if ((bufp != NULL) && (*bufp == NULL) && (buf != NULL)) 957 *bufp = buf; 958 return (0); 959 } 960 961 static int 962 mfi_comms_init(struct mfi_softc *sc) 963 { 964 struct mfi_command *cm; 965 struct mfi_init_frame *init; 966 struct mfi_init_qinfo *qinfo; 967 int error; 968 uint32_t context = 0; 969 970 mtx_lock(&sc->mfi_io_lock); 971 if ((cm = mfi_dequeue_free(sc)) == NULL) { 972 mtx_unlock(&sc->mfi_io_lock); 973 return (EBUSY); 974 } 975 976 /* Zero out the MFI frame */ 977 context = cm->cm_frame->header.context; 978 bzero(cm->cm_frame, sizeof(union mfi_frame)); 979 cm->cm_frame->header.context = context; 980 981 /* 982 * Abuse the SG list area of the frame to hold the init_qinfo 983 * object; 984 */ 985 init = &cm->cm_frame->init; 986 qinfo = (struct mfi_init_qinfo *)((uintptr_t)init + MFI_FRAME_SIZE); 987 988 bzero(qinfo, sizeof(struct mfi_init_qinfo)); 989 qinfo->rq_entries = sc->mfi_max_fw_cmds + 1; 990 qinfo->rq_addr_lo = sc->mfi_comms_busaddr + 991 offsetof(struct mfi_hwcomms, hw_reply_q); 992 qinfo->pi_addr_lo = sc->mfi_comms_busaddr + 993 offsetof(struct mfi_hwcomms, hw_pi); 994 qinfo->ci_addr_lo = sc->mfi_comms_busaddr + 995 offsetof(struct mfi_hwcomms, hw_ci); 996 997 init->header.cmd = MFI_CMD_INIT; 998 init->header.data_len = sizeof(struct mfi_init_qinfo); 999 init->qinfo_new_addr_lo = cm->cm_frame_busaddr + MFI_FRAME_SIZE; 1000 cm->cm_data = NULL; 1001 cm->cm_flags = MFI_CMD_POLLED; 1002 1003 if ((error = mfi_mapcmd(sc, cm)) != 0) 1004 device_printf(sc->mfi_dev, "failed to send init command\n"); 1005 mfi_release_command(cm); 1006 mtx_unlock(&sc->mfi_io_lock); 1007 1008 return (error); 1009 } 1010 1011 static int 1012 mfi_get_controller_info(struct mfi_softc *sc) 1013 { 1014 struct mfi_command *cm = NULL; 1015 struct mfi_ctrl_info *ci = NULL; 1016 uint32_t max_sectors_1, max_sectors_2; 1017 int error; 1018 1019 mtx_lock(&sc->mfi_io_lock); 1020 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_GETINFO, 1021 (void **)&ci, sizeof(*ci)); 1022 if (error) 1023 goto out; 1024 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED; 1025 1026 if ((error = mfi_mapcmd(sc, cm)) != 0) { 1027 device_printf(sc->mfi_dev, "Failed to get controller info\n"); 1028 sc->mfi_max_io = (sc->mfi_max_sge - 1) * PAGE_SIZE / 1029 MFI_SECTOR_LEN; 1030 error = 0; 1031 goto out; 1032 } 1033 1034 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, 1035 BUS_DMASYNC_POSTREAD); 1036 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 1037 1038 max_sectors_1 = (1 << ci->stripe_sz_ops.max) * ci->max_strips_per_io; 1039 max_sectors_2 = ci->max_request_size; 1040 sc->mfi_max_io = min(max_sectors_1, max_sectors_2); 1041 sc->disableOnlineCtrlReset = 1042 ci->properties.OnOffProperties.disableOnlineCtrlReset; 1043 1044 out: 1045 if (ci) 1046 free(ci, M_MFIBUF); 1047 if (cm) 1048 mfi_release_command(cm); 1049 mtx_unlock(&sc->mfi_io_lock); 1050 return (error); 1051 } 1052 1053 static int 1054 mfi_get_log_state(struct mfi_softc *sc, struct mfi_evt_log_state **log_state) 1055 { 1056 struct mfi_command *cm = NULL; 1057 int error; 1058 1059 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1060 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_EVENT_GETINFO, 1061 (void **)log_state, sizeof(**log_state)); 1062 if (error) 1063 goto out; 1064 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED; 1065 1066 if ((error = mfi_mapcmd(sc, cm)) != 0) { 1067 device_printf(sc->mfi_dev, "Failed to get log state\n"); 1068 goto out; 1069 } 1070 1071 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, 1072 BUS_DMASYNC_POSTREAD); 1073 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 1074 1075 out: 1076 if (cm) 1077 mfi_release_command(cm); 1078 1079 return (error); 1080 } 1081 1082 int 1083 mfi_aen_setup(struct mfi_softc *sc, uint32_t seq_start) 1084 { 1085 struct mfi_evt_log_state *log_state = NULL; 1086 union mfi_evt class_locale; 1087 int error = 0; 1088 uint32_t seq; 1089 1090 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1091 1092 class_locale.members.reserved = 0; 1093 class_locale.members.locale = mfi_event_locale; 1094 class_locale.members.evt_class = mfi_event_class; 1095 1096 if (seq_start == 0) { 1097 if ((error = mfi_get_log_state(sc, &log_state)) != 0) 1098 goto out; 1099 sc->mfi_boot_seq_num = log_state->boot_seq_num; 1100 1101 /* 1102 * Walk through any events that fired since the last 1103 * shutdown. 1104 */ 1105 if ((error = mfi_parse_entries(sc, log_state->shutdown_seq_num, 1106 log_state->newest_seq_num)) != 0) 1107 goto out; 1108 seq = log_state->newest_seq_num; 1109 } else 1110 seq = seq_start; 1111 error = mfi_aen_register(sc, seq, class_locale.word); 1112 out: 1113 free(log_state, M_MFIBUF); 1114 1115 return (error); 1116 } 1117 1118 int 1119 mfi_wait_command(struct mfi_softc *sc, struct mfi_command *cm) 1120 { 1121 1122 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1123 cm->cm_complete = NULL; 1124 1125 /* 1126 * MegaCli can issue a DCMD of 0. In this case do nothing 1127 * and return 0 to it as status 1128 */ 1129 if (cm->cm_frame->dcmd.opcode == 0) { 1130 cm->cm_frame->header.cmd_status = MFI_STAT_OK; 1131 cm->cm_error = 0; 1132 return (cm->cm_error); 1133 } 1134 mfi_enqueue_ready(cm); 1135 mfi_startio(sc); 1136 if ((cm->cm_flags & MFI_CMD_COMPLETED) == 0) 1137 msleep(cm, &sc->mfi_io_lock, PRIBIO, "mfiwait", 0); 1138 return (cm->cm_error); 1139 } 1140 1141 void 1142 mfi_free(struct mfi_softc *sc) 1143 { 1144 struct mfi_command *cm; 1145 int i; 1146 1147 callout_drain(&sc->mfi_watchdog_callout); 1148 1149 if (sc->mfi_cdev != NULL) 1150 destroy_dev(sc->mfi_cdev); 1151 1152 if (sc->mfi_commands != NULL) { 1153 for (i = 0; i < sc->mfi_max_fw_cmds; i++) { 1154 cm = &sc->mfi_commands[i]; 1155 bus_dmamap_destroy(sc->mfi_buffer_dmat, cm->cm_dmamap); 1156 } 1157 free(sc->mfi_commands, M_MFIBUF); 1158 sc->mfi_commands = NULL; 1159 } 1160 1161 if (sc->mfi_intr) 1162 bus_teardown_intr(sc->mfi_dev, sc->mfi_irq, sc->mfi_intr); 1163 if (sc->mfi_irq != NULL) 1164 bus_release_resource(sc->mfi_dev, SYS_RES_IRQ, sc->mfi_irq_rid, 1165 sc->mfi_irq); 1166 1167 if (sc->mfi_sense_busaddr != 0) 1168 bus_dmamap_unload(sc->mfi_sense_dmat, sc->mfi_sense_dmamap); 1169 if (sc->mfi_sense != NULL) 1170 bus_dmamem_free(sc->mfi_sense_dmat, sc->mfi_sense, 1171 sc->mfi_sense_dmamap); 1172 if (sc->mfi_sense_dmat != NULL) 1173 bus_dma_tag_destroy(sc->mfi_sense_dmat); 1174 1175 if (sc->mfi_frames_busaddr != 0) 1176 bus_dmamap_unload(sc->mfi_frames_dmat, sc->mfi_frames_dmamap); 1177 if (sc->mfi_frames != NULL) 1178 bus_dmamem_free(sc->mfi_frames_dmat, sc->mfi_frames, 1179 sc->mfi_frames_dmamap); 1180 if (sc->mfi_frames_dmat != NULL) 1181 bus_dma_tag_destroy(sc->mfi_frames_dmat); 1182 1183 if (sc->mfi_comms_busaddr != 0) 1184 bus_dmamap_unload(sc->mfi_comms_dmat, sc->mfi_comms_dmamap); 1185 if (sc->mfi_comms != NULL) 1186 bus_dmamem_free(sc->mfi_comms_dmat, sc->mfi_comms, 1187 sc->mfi_comms_dmamap); 1188 if (sc->mfi_comms_dmat != NULL) 1189 bus_dma_tag_destroy(sc->mfi_comms_dmat); 1190 1191 /* ThunderBolt contiguous memory free here */ 1192 if (sc->mfi_flags & MFI_FLAGS_TBOLT) { 1193 if (sc->mfi_tb_busaddr != 0) 1194 bus_dmamap_unload(sc->mfi_tb_dmat, sc->mfi_tb_dmamap); 1195 if (sc->request_message_pool != NULL) 1196 bus_dmamem_free(sc->mfi_tb_dmat, sc->request_message_pool, 1197 sc->mfi_tb_dmamap); 1198 if (sc->mfi_tb_dmat != NULL) 1199 bus_dma_tag_destroy(sc->mfi_tb_dmat); 1200 1201 /* Version buffer memory free */ 1202 /* Start LSIP200113393 */ 1203 if (sc->verbuf_h_busaddr != 0) 1204 bus_dmamap_unload(sc->verbuf_h_dmat, sc->verbuf_h_dmamap); 1205 if (sc->verbuf != NULL) 1206 bus_dmamem_free(sc->verbuf_h_dmat, sc->verbuf, 1207 sc->verbuf_h_dmamap); 1208 if (sc->verbuf_h_dmat != NULL) 1209 bus_dma_tag_destroy(sc->verbuf_h_dmat); 1210 1211 /* End LSIP200113393 */ 1212 /* ThunderBolt INIT packet memory Free */ 1213 if (sc->mfi_tb_init_busaddr != 0) 1214 bus_dmamap_unload(sc->mfi_tb_init_dmat, 1215 sc->mfi_tb_init_dmamap); 1216 if (sc->mfi_tb_init != NULL) 1217 bus_dmamem_free(sc->mfi_tb_init_dmat, sc->mfi_tb_init, 1218 sc->mfi_tb_init_dmamap); 1219 if (sc->mfi_tb_init_dmat != NULL) 1220 bus_dma_tag_destroy(sc->mfi_tb_init_dmat); 1221 1222 /* ThunderBolt IOC Init Desc memory free here */ 1223 if (sc->mfi_tb_ioc_init_busaddr != 0) 1224 bus_dmamap_unload(sc->mfi_tb_ioc_init_dmat, 1225 sc->mfi_tb_ioc_init_dmamap); 1226 if (sc->mfi_tb_ioc_init_desc != NULL) 1227 bus_dmamem_free(sc->mfi_tb_ioc_init_dmat, 1228 sc->mfi_tb_ioc_init_desc, 1229 sc->mfi_tb_ioc_init_dmamap); 1230 if (sc->mfi_tb_ioc_init_dmat != NULL) 1231 bus_dma_tag_destroy(sc->mfi_tb_ioc_init_dmat); 1232 if (sc->mfi_cmd_pool_tbolt != NULL) { 1233 for (int i = 0; i < sc->mfi_max_fw_cmds; i++) { 1234 if (sc->mfi_cmd_pool_tbolt[i] != NULL) { 1235 free(sc->mfi_cmd_pool_tbolt[i], 1236 M_MFIBUF); 1237 sc->mfi_cmd_pool_tbolt[i] = NULL; 1238 } 1239 } 1240 free(sc->mfi_cmd_pool_tbolt, M_MFIBUF); 1241 sc->mfi_cmd_pool_tbolt = NULL; 1242 } 1243 if (sc->request_desc_pool != NULL) { 1244 free(sc->request_desc_pool, M_MFIBUF); 1245 sc->request_desc_pool = NULL; 1246 } 1247 } 1248 if (sc->mfi_buffer_dmat != NULL) 1249 bus_dma_tag_destroy(sc->mfi_buffer_dmat); 1250 if (sc->mfi_parent_dmat != NULL) 1251 bus_dma_tag_destroy(sc->mfi_parent_dmat); 1252 1253 if (mtx_initialized(&sc->mfi_io_lock)) { 1254 mtx_destroy(&sc->mfi_io_lock); 1255 sx_destroy(&sc->mfi_config_lock); 1256 } 1257 1258 return; 1259 } 1260 1261 static void 1262 mfi_startup(void *arg) 1263 { 1264 struct mfi_softc *sc; 1265 1266 sc = (struct mfi_softc *)arg; 1267 1268 sc->mfi_enable_intr(sc); 1269 sx_xlock(&sc->mfi_config_lock); 1270 mtx_lock(&sc->mfi_io_lock); 1271 mfi_ldprobe(sc); 1272 if (sc->mfi_flags & MFI_FLAGS_SKINNY) 1273 mfi_syspdprobe(sc); 1274 mtx_unlock(&sc->mfi_io_lock); 1275 sx_xunlock(&sc->mfi_config_lock); 1276 1277 config_intrhook_disestablish(&sc->mfi_ich); 1278 } 1279 1280 static void 1281 mfi_intr(void *arg) 1282 { 1283 struct mfi_softc *sc; 1284 struct mfi_command *cm; 1285 uint32_t pi, ci, context; 1286 1287 sc = (struct mfi_softc *)arg; 1288 1289 if (sc->mfi_check_clear_intr(sc)) 1290 return; 1291 1292 restart: 1293 pi = sc->mfi_comms->hw_pi; 1294 ci = sc->mfi_comms->hw_ci; 1295 mtx_lock(&sc->mfi_io_lock); 1296 while (ci != pi) { 1297 context = sc->mfi_comms->hw_reply_q[ci]; 1298 if (context < sc->mfi_max_fw_cmds) { 1299 cm = &sc->mfi_commands[context]; 1300 mfi_remove_busy(cm); 1301 cm->cm_error = 0; 1302 mfi_complete(sc, cm); 1303 } 1304 if (++ci == (sc->mfi_max_fw_cmds + 1)) 1305 ci = 0; 1306 } 1307 1308 sc->mfi_comms->hw_ci = ci; 1309 1310 /* Give defered I/O a chance to run */ 1311 sc->mfi_flags &= ~MFI_FLAGS_QFRZN; 1312 mfi_startio(sc); 1313 mtx_unlock(&sc->mfi_io_lock); 1314 1315 /* 1316 * Dummy read to flush the bus; this ensures that the indexes are up 1317 * to date. Restart processing if more commands have come it. 1318 */ 1319 (void)sc->mfi_read_fw_status(sc); 1320 if (pi != sc->mfi_comms->hw_pi) 1321 goto restart; 1322 1323 return; 1324 } 1325 1326 int 1327 mfi_shutdown(struct mfi_softc *sc) 1328 { 1329 struct mfi_dcmd_frame *dcmd; 1330 struct mfi_command *cm; 1331 int error; 1332 1333 1334 if (sc->mfi_aen_cm != NULL) { 1335 sc->cm_aen_abort = 1; 1336 mfi_abort(sc, &sc->mfi_aen_cm); 1337 } 1338 1339 if (sc->mfi_map_sync_cm != NULL) { 1340 sc->cm_map_abort = 1; 1341 mfi_abort(sc, &sc->mfi_map_sync_cm); 1342 } 1343 1344 mtx_lock(&sc->mfi_io_lock); 1345 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_SHUTDOWN, NULL, 0); 1346 if (error) { 1347 mtx_unlock(&sc->mfi_io_lock); 1348 return (error); 1349 } 1350 1351 dcmd = &cm->cm_frame->dcmd; 1352 dcmd->header.flags = MFI_FRAME_DIR_NONE; 1353 cm->cm_flags = MFI_CMD_POLLED; 1354 cm->cm_data = NULL; 1355 1356 if ((error = mfi_mapcmd(sc, cm)) != 0) 1357 device_printf(sc->mfi_dev, "Failed to shutdown controller\n"); 1358 1359 mfi_release_command(cm); 1360 mtx_unlock(&sc->mfi_io_lock); 1361 return (error); 1362 } 1363 1364 static void 1365 mfi_syspdprobe(struct mfi_softc *sc) 1366 { 1367 struct mfi_frame_header *hdr; 1368 struct mfi_command *cm = NULL; 1369 struct mfi_pd_list *pdlist = NULL; 1370 struct mfi_system_pd *syspd, *tmp; 1371 struct mfi_system_pending *syspd_pend; 1372 int error, i, found; 1373 1374 sx_assert(&sc->mfi_config_lock, SA_XLOCKED); 1375 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1376 /* Add SYSTEM PD's */ 1377 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_PD_LIST_QUERY, 1378 (void **)&pdlist, sizeof(*pdlist)); 1379 if (error) { 1380 device_printf(sc->mfi_dev, 1381 "Error while forming SYSTEM PD list\n"); 1382 goto out; 1383 } 1384 1385 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED; 1386 cm->cm_frame->dcmd.mbox[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST; 1387 cm->cm_frame->dcmd.mbox[1] = 0; 1388 if (mfi_mapcmd(sc, cm) != 0) { 1389 device_printf(sc->mfi_dev, 1390 "Failed to get syspd device listing\n"); 1391 goto out; 1392 } 1393 bus_dmamap_sync(sc->mfi_buffer_dmat,cm->cm_dmamap, 1394 BUS_DMASYNC_POSTREAD); 1395 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 1396 hdr = &cm->cm_frame->header; 1397 if (hdr->cmd_status != MFI_STAT_OK) { 1398 device_printf(sc->mfi_dev, 1399 "MFI_DCMD_PD_LIST_QUERY failed %x\n", hdr->cmd_status); 1400 goto out; 1401 } 1402 /* Get each PD and add it to the system */ 1403 for (i = 0; i < pdlist->count; i++) { 1404 if (pdlist->addr[i].device_id == 1405 pdlist->addr[i].encl_device_id) 1406 continue; 1407 found = 0; 1408 TAILQ_FOREACH(syspd, &sc->mfi_syspd_tqh, pd_link) { 1409 if (syspd->pd_id == pdlist->addr[i].device_id) 1410 found = 1; 1411 } 1412 TAILQ_FOREACH(syspd_pend, &sc->mfi_syspd_pend_tqh, pd_link) { 1413 if (syspd_pend->pd_id == pdlist->addr[i].device_id) 1414 found = 1; 1415 } 1416 if (found == 0) 1417 mfi_add_sys_pd(sc, pdlist->addr[i].device_id); 1418 } 1419 /* Delete SYSPD's whose state has been changed */ 1420 TAILQ_FOREACH_SAFE(syspd, &sc->mfi_syspd_tqh, pd_link, tmp) { 1421 found = 0; 1422 for (i = 0; i < pdlist->count; i++) { 1423 if (syspd->pd_id == pdlist->addr[i].device_id) { 1424 found = 1; 1425 break; 1426 } 1427 } 1428 if (found == 0) { 1429 printf("DELETE\n"); 1430 mtx_unlock(&sc->mfi_io_lock); 1431 mtx_lock(&Giant); 1432 device_delete_child(sc->mfi_dev, syspd->pd_dev); 1433 mtx_unlock(&Giant); 1434 mtx_lock(&sc->mfi_io_lock); 1435 } 1436 } 1437 out: 1438 if (pdlist) 1439 free(pdlist, M_MFIBUF); 1440 if (cm) 1441 mfi_release_command(cm); 1442 1443 return; 1444 } 1445 1446 static void 1447 mfi_ldprobe(struct mfi_softc *sc) 1448 { 1449 struct mfi_frame_header *hdr; 1450 struct mfi_command *cm = NULL; 1451 struct mfi_ld_list *list = NULL; 1452 struct mfi_disk *ld; 1453 struct mfi_disk_pending *ld_pend; 1454 int error, i; 1455 1456 sx_assert(&sc->mfi_config_lock, SA_XLOCKED); 1457 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1458 1459 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_LD_GET_LIST, 1460 (void **)&list, sizeof(*list)); 1461 if (error) 1462 goto out; 1463 1464 cm->cm_flags = MFI_CMD_DATAIN; 1465 if (mfi_wait_command(sc, cm) != 0) { 1466 device_printf(sc->mfi_dev, "Failed to get device listing\n"); 1467 goto out; 1468 } 1469 1470 hdr = &cm->cm_frame->header; 1471 if (hdr->cmd_status != MFI_STAT_OK) { 1472 device_printf(sc->mfi_dev, "MFI_DCMD_LD_GET_LIST failed %x\n", 1473 hdr->cmd_status); 1474 goto out; 1475 } 1476 1477 for (i = 0; i < list->ld_count; i++) { 1478 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) { 1479 if (ld->ld_id == list->ld_list[i].ld.v.target_id) 1480 goto skip_add; 1481 } 1482 TAILQ_FOREACH(ld_pend, &sc->mfi_ld_pend_tqh, ld_link) { 1483 if (ld_pend->ld_id == list->ld_list[i].ld.v.target_id) 1484 goto skip_add; 1485 } 1486 mfi_add_ld(sc, list->ld_list[i].ld.v.target_id); 1487 skip_add:; 1488 } 1489 out: 1490 if (list) 1491 free(list, M_MFIBUF); 1492 if (cm) 1493 mfi_release_command(cm); 1494 1495 return; 1496 } 1497 1498 /* 1499 * The timestamp is the number of seconds since 00:00 Jan 1, 2000. If 1500 * the bits in 24-31 are all set, then it is the number of seconds since 1501 * boot. 1502 */ 1503 static const char * 1504 format_timestamp(uint32_t timestamp) 1505 { 1506 static char buffer[32]; 1507 1508 if ((timestamp & 0xff000000) == 0xff000000) 1509 snprintf(buffer, sizeof(buffer), "boot + %us", timestamp & 1510 0x00ffffff); 1511 else 1512 snprintf(buffer, sizeof(buffer), "%us", timestamp); 1513 return (buffer); 1514 } 1515 1516 static const char * 1517 format_class(int8_t class) 1518 { 1519 static char buffer[6]; 1520 1521 switch (class) { 1522 case MFI_EVT_CLASS_DEBUG: 1523 return ("debug"); 1524 case MFI_EVT_CLASS_PROGRESS: 1525 return ("progress"); 1526 case MFI_EVT_CLASS_INFO: 1527 return ("info"); 1528 case MFI_EVT_CLASS_WARNING: 1529 return ("WARN"); 1530 case MFI_EVT_CLASS_CRITICAL: 1531 return ("CRIT"); 1532 case MFI_EVT_CLASS_FATAL: 1533 return ("FATAL"); 1534 case MFI_EVT_CLASS_DEAD: 1535 return ("DEAD"); 1536 default: 1537 snprintf(buffer, sizeof(buffer), "%d", class); 1538 return (buffer); 1539 } 1540 } 1541 1542 static void 1543 mfi_decode_evt(struct mfi_softc *sc, struct mfi_evt_detail *detail) 1544 { 1545 struct mfi_system_pd *syspd = NULL; 1546 1547 device_printf(sc->mfi_dev, "%d (%s/0x%04x/%s) - %s\n", detail->seq, 1548 format_timestamp(detail->time), detail->evt_class.members.locale, 1549 format_class(detail->evt_class.members.evt_class), 1550 detail->description); 1551 1552 /* Don't act on old AEN's or while shutting down */ 1553 if (detail->seq < sc->mfi_boot_seq_num || sc->mfi_detaching) 1554 return; 1555 1556 switch (detail->arg_type) { 1557 case MR_EVT_ARGS_NONE: 1558 if (detail->code == MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED) { 1559 device_printf(sc->mfi_dev, "HostBus scan raised\n"); 1560 if (mfi_detect_jbod_change) { 1561 /* 1562 * Probe for new SYSPD's and Delete 1563 * invalid SYSPD's 1564 */ 1565 sx_xlock(&sc->mfi_config_lock); 1566 mtx_lock(&sc->mfi_io_lock); 1567 mfi_syspdprobe(sc); 1568 mtx_unlock(&sc->mfi_io_lock); 1569 sx_xunlock(&sc->mfi_config_lock); 1570 } 1571 } 1572 break; 1573 case MR_EVT_ARGS_LD_STATE: 1574 /* During load time driver reads all the events starting 1575 * from the one that has been logged after shutdown. Avoid 1576 * these old events. 1577 */ 1578 if (detail->args.ld_state.new_state == MFI_LD_STATE_OFFLINE ) { 1579 /* Remove the LD */ 1580 struct mfi_disk *ld; 1581 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) { 1582 if (ld->ld_id == 1583 detail->args.ld_state.ld.target_id) 1584 break; 1585 } 1586 /* 1587 Fix: for kernel panics when SSCD is removed 1588 KASSERT(ld != NULL, ("volume dissappeared")); 1589 */ 1590 if (ld != NULL) { 1591 mtx_lock(&Giant); 1592 device_delete_child(sc->mfi_dev, ld->ld_dev); 1593 mtx_unlock(&Giant); 1594 } 1595 } 1596 break; 1597 case MR_EVT_ARGS_PD: 1598 if (detail->code == MR_EVT_PD_REMOVED) { 1599 if (mfi_detect_jbod_change) { 1600 /* 1601 * If the removed device is a SYSPD then 1602 * delete it 1603 */ 1604 TAILQ_FOREACH(syspd, &sc->mfi_syspd_tqh, 1605 pd_link) { 1606 if (syspd->pd_id == 1607 detail->args.pd.device_id) { 1608 mtx_lock(&Giant); 1609 device_delete_child( 1610 sc->mfi_dev, 1611 syspd->pd_dev); 1612 mtx_unlock(&Giant); 1613 break; 1614 } 1615 } 1616 } 1617 } 1618 if (detail->code == MR_EVT_PD_INSERTED) { 1619 if (mfi_detect_jbod_change) { 1620 /* Probe for new SYSPD's */ 1621 sx_xlock(&sc->mfi_config_lock); 1622 mtx_lock(&sc->mfi_io_lock); 1623 mfi_syspdprobe(sc); 1624 mtx_unlock(&sc->mfi_io_lock); 1625 sx_xunlock(&sc->mfi_config_lock); 1626 } 1627 } 1628 if (sc->mfi_cam_rescan_cb != NULL && 1629 (detail->code == MR_EVT_PD_INSERTED || 1630 detail->code == MR_EVT_PD_REMOVED)) { 1631 sc->mfi_cam_rescan_cb(sc, detail->args.pd.device_id); 1632 } 1633 break; 1634 } 1635 } 1636 1637 static void 1638 mfi_queue_evt(struct mfi_softc *sc, struct mfi_evt_detail *detail) 1639 { 1640 struct mfi_evt_queue_elm *elm; 1641 1642 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1643 elm = malloc(sizeof(*elm), M_MFIBUF, M_NOWAIT|M_ZERO); 1644 if (elm == NULL) 1645 return; 1646 memcpy(&elm->detail, detail, sizeof(*detail)); 1647 TAILQ_INSERT_TAIL(&sc->mfi_evt_queue, elm, link); 1648 taskqueue_enqueue(taskqueue_swi, &sc->mfi_evt_task); 1649 } 1650 1651 static void 1652 mfi_handle_evt(void *context, int pending) 1653 { 1654 TAILQ_HEAD(,mfi_evt_queue_elm) queue; 1655 struct mfi_softc *sc; 1656 struct mfi_evt_queue_elm *elm; 1657 1658 sc = context; 1659 TAILQ_INIT(&queue); 1660 mtx_lock(&sc->mfi_io_lock); 1661 TAILQ_CONCAT(&queue, &sc->mfi_evt_queue, link); 1662 mtx_unlock(&sc->mfi_io_lock); 1663 while ((elm = TAILQ_FIRST(&queue)) != NULL) { 1664 TAILQ_REMOVE(&queue, elm, link); 1665 mfi_decode_evt(sc, &elm->detail); 1666 free(elm, M_MFIBUF); 1667 } 1668 } 1669 1670 static int 1671 mfi_aen_register(struct mfi_softc *sc, int seq, int locale) 1672 { 1673 struct mfi_command *cm; 1674 struct mfi_dcmd_frame *dcmd; 1675 union mfi_evt current_aen, prior_aen; 1676 struct mfi_evt_detail *ed = NULL; 1677 int error = 0; 1678 1679 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1680 1681 current_aen.word = locale; 1682 if (sc->mfi_aen_cm != NULL) { 1683 prior_aen.word = 1684 ((uint32_t *)&sc->mfi_aen_cm->cm_frame->dcmd.mbox)[1]; 1685 if (prior_aen.members.evt_class <= current_aen.members.evt_class && 1686 !((prior_aen.members.locale & current_aen.members.locale) 1687 ^current_aen.members.locale)) { 1688 return (0); 1689 } else { 1690 prior_aen.members.locale |= current_aen.members.locale; 1691 if (prior_aen.members.evt_class 1692 < current_aen.members.evt_class) 1693 current_aen.members.evt_class = 1694 prior_aen.members.evt_class; 1695 mfi_abort(sc, &sc->mfi_aen_cm); 1696 } 1697 } 1698 1699 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_CTRL_EVENT_WAIT, 1700 (void **)&ed, sizeof(*ed)); 1701 if (error) 1702 goto out; 1703 1704 dcmd = &cm->cm_frame->dcmd; 1705 ((uint32_t *)&dcmd->mbox)[0] = seq; 1706 ((uint32_t *)&dcmd->mbox)[1] = locale; 1707 cm->cm_flags = MFI_CMD_DATAIN; 1708 cm->cm_complete = mfi_aen_complete; 1709 1710 sc->last_seq_num = seq; 1711 sc->mfi_aen_cm = cm; 1712 1713 mfi_enqueue_ready(cm); 1714 mfi_startio(sc); 1715 1716 out: 1717 return (error); 1718 } 1719 1720 static void 1721 mfi_aen_complete(struct mfi_command *cm) 1722 { 1723 struct mfi_frame_header *hdr; 1724 struct mfi_softc *sc; 1725 struct mfi_evt_detail *detail; 1726 struct mfi_aen *mfi_aen_entry, *tmp; 1727 int seq = 0, aborted = 0; 1728 1729 sc = cm->cm_sc; 1730 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1731 1732 if (sc->mfi_aen_cm == NULL) 1733 return; 1734 1735 hdr = &cm->cm_frame->header; 1736 1737 if (sc->cm_aen_abort || 1738 hdr->cmd_status == MFI_STAT_INVALID_STATUS) { 1739 sc->cm_aen_abort = 0; 1740 aborted = 1; 1741 } else { 1742 sc->mfi_aen_triggered = 1; 1743 if (sc->mfi_poll_waiting) { 1744 sc->mfi_poll_waiting = 0; 1745 selwakeup(&sc->mfi_select); 1746 } 1747 detail = cm->cm_data; 1748 mfi_queue_evt(sc, detail); 1749 seq = detail->seq + 1; 1750 TAILQ_FOREACH_SAFE(mfi_aen_entry, &sc->mfi_aen_pids, aen_link, 1751 tmp) { 1752 TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry, 1753 aen_link); 1754 PROC_LOCK(mfi_aen_entry->p); 1755 kern_psignal(mfi_aen_entry->p, SIGIO); 1756 PROC_UNLOCK(mfi_aen_entry->p); 1757 free(mfi_aen_entry, M_MFIBUF); 1758 } 1759 } 1760 1761 free(cm->cm_data, M_MFIBUF); 1762 wakeup(&sc->mfi_aen_cm); 1763 sc->mfi_aen_cm = NULL; 1764 mfi_release_command(cm); 1765 1766 /* set it up again so the driver can catch more events */ 1767 if (!aborted) 1768 mfi_aen_setup(sc, seq); 1769 } 1770 1771 #define MAX_EVENTS 15 1772 1773 static int 1774 mfi_parse_entries(struct mfi_softc *sc, int start_seq, int stop_seq) 1775 { 1776 struct mfi_command *cm; 1777 struct mfi_dcmd_frame *dcmd; 1778 struct mfi_evt_list *el; 1779 union mfi_evt class_locale; 1780 int error, i, seq, size; 1781 1782 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1783 1784 class_locale.members.reserved = 0; 1785 class_locale.members.locale = mfi_event_locale; 1786 class_locale.members.evt_class = mfi_event_class; 1787 1788 size = sizeof(struct mfi_evt_list) + sizeof(struct mfi_evt_detail) 1789 * (MAX_EVENTS - 1); 1790 el = malloc(size, M_MFIBUF, M_NOWAIT | M_ZERO); 1791 if (el == NULL) 1792 return (ENOMEM); 1793 1794 for (seq = start_seq;;) { 1795 if ((cm = mfi_dequeue_free(sc)) == NULL) { 1796 free(el, M_MFIBUF); 1797 return (EBUSY); 1798 } 1799 1800 dcmd = &cm->cm_frame->dcmd; 1801 bzero(dcmd->mbox, MFI_MBOX_SIZE); 1802 dcmd->header.cmd = MFI_CMD_DCMD; 1803 dcmd->header.timeout = 0; 1804 dcmd->header.data_len = size; 1805 dcmd->opcode = MFI_DCMD_CTRL_EVENT_GET; 1806 ((uint32_t *)&dcmd->mbox)[0] = seq; 1807 ((uint32_t *)&dcmd->mbox)[1] = class_locale.word; 1808 cm->cm_sg = &dcmd->sgl; 1809 cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE; 1810 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED; 1811 cm->cm_data = el; 1812 cm->cm_len = size; 1813 1814 if ((error = mfi_mapcmd(sc, cm)) != 0) { 1815 device_printf(sc->mfi_dev, 1816 "Failed to get controller entries\n"); 1817 mfi_release_command(cm); 1818 break; 1819 } 1820 1821 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, 1822 BUS_DMASYNC_POSTREAD); 1823 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 1824 1825 if (dcmd->header.cmd_status == MFI_STAT_NOT_FOUND) { 1826 mfi_release_command(cm); 1827 break; 1828 } 1829 if (dcmd->header.cmd_status != MFI_STAT_OK) { 1830 device_printf(sc->mfi_dev, 1831 "Error %d fetching controller entries\n", 1832 dcmd->header.cmd_status); 1833 mfi_release_command(cm); 1834 error = EIO; 1835 break; 1836 } 1837 mfi_release_command(cm); 1838 1839 for (i = 0; i < el->count; i++) { 1840 /* 1841 * If this event is newer than 'stop_seq' then 1842 * break out of the loop. Note that the log 1843 * is a circular buffer so we have to handle 1844 * the case that our stop point is earlier in 1845 * the buffer than our start point. 1846 */ 1847 if (el->event[i].seq >= stop_seq) { 1848 if (start_seq <= stop_seq) 1849 break; 1850 else if (el->event[i].seq < start_seq) 1851 break; 1852 } 1853 mfi_queue_evt(sc, &el->event[i]); 1854 } 1855 seq = el->event[el->count - 1].seq + 1; 1856 } 1857 1858 free(el, M_MFIBUF); 1859 return (error); 1860 } 1861 1862 static int 1863 mfi_add_ld(struct mfi_softc *sc, int id) 1864 { 1865 struct mfi_command *cm; 1866 struct mfi_dcmd_frame *dcmd = NULL; 1867 struct mfi_ld_info *ld_info = NULL; 1868 struct mfi_disk_pending *ld_pend; 1869 int error; 1870 1871 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1872 1873 ld_pend = malloc(sizeof(*ld_pend), M_MFIBUF, M_NOWAIT | M_ZERO); 1874 if (ld_pend != NULL) { 1875 ld_pend->ld_id = id; 1876 TAILQ_INSERT_TAIL(&sc->mfi_ld_pend_tqh, ld_pend, ld_link); 1877 } 1878 1879 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_LD_GET_INFO, 1880 (void **)&ld_info, sizeof(*ld_info)); 1881 if (error) { 1882 device_printf(sc->mfi_dev, 1883 "Failed to allocate for MFI_DCMD_LD_GET_INFO %d\n", error); 1884 if (ld_info) 1885 free(ld_info, M_MFIBUF); 1886 return (error); 1887 } 1888 cm->cm_flags = MFI_CMD_DATAIN; 1889 dcmd = &cm->cm_frame->dcmd; 1890 dcmd->mbox[0] = id; 1891 if (mfi_wait_command(sc, cm) != 0) { 1892 device_printf(sc->mfi_dev, 1893 "Failed to get logical drive: %d\n", id); 1894 free(ld_info, M_MFIBUF); 1895 return (0); 1896 } 1897 if (ld_info->ld_config.params.isSSCD != 1) 1898 mfi_add_ld_complete(cm); 1899 else { 1900 mfi_release_command(cm); 1901 if (ld_info) /* SSCD drives ld_info free here */ 1902 free(ld_info, M_MFIBUF); 1903 } 1904 return (0); 1905 } 1906 1907 static void 1908 mfi_add_ld_complete(struct mfi_command *cm) 1909 { 1910 struct mfi_frame_header *hdr; 1911 struct mfi_ld_info *ld_info; 1912 struct mfi_softc *sc; 1913 device_t child; 1914 1915 sc = cm->cm_sc; 1916 hdr = &cm->cm_frame->header; 1917 ld_info = cm->cm_private; 1918 1919 if (sc->cm_map_abort || hdr->cmd_status != MFI_STAT_OK) { 1920 free(ld_info, M_MFIBUF); 1921 wakeup(&sc->mfi_map_sync_cm); 1922 mfi_release_command(cm); 1923 return; 1924 } 1925 wakeup(&sc->mfi_map_sync_cm); 1926 mfi_release_command(cm); 1927 1928 mtx_unlock(&sc->mfi_io_lock); 1929 mtx_lock(&Giant); 1930 if ((child = device_add_child(sc->mfi_dev, "mfid", -1)) == NULL) { 1931 device_printf(sc->mfi_dev, "Failed to add logical disk\n"); 1932 free(ld_info, M_MFIBUF); 1933 mtx_unlock(&Giant); 1934 mtx_lock(&sc->mfi_io_lock); 1935 return; 1936 } 1937 1938 device_set_ivars(child, ld_info); 1939 device_set_desc(child, "MFI Logical Disk"); 1940 bus_generic_attach(sc->mfi_dev); 1941 mtx_unlock(&Giant); 1942 mtx_lock(&sc->mfi_io_lock); 1943 } 1944 1945 static int mfi_add_sys_pd(struct mfi_softc *sc, int id) 1946 { 1947 struct mfi_command *cm; 1948 struct mfi_dcmd_frame *dcmd = NULL; 1949 struct mfi_pd_info *pd_info = NULL; 1950 struct mfi_system_pending *syspd_pend; 1951 int error; 1952 1953 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1954 1955 syspd_pend = malloc(sizeof(*syspd_pend), M_MFIBUF, M_NOWAIT | M_ZERO); 1956 if (syspd_pend != NULL) { 1957 syspd_pend->pd_id = id; 1958 TAILQ_INSERT_TAIL(&sc->mfi_syspd_pend_tqh, syspd_pend, pd_link); 1959 } 1960 1961 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_PD_GET_INFO, 1962 (void **)&pd_info, sizeof(*pd_info)); 1963 if (error) { 1964 device_printf(sc->mfi_dev, 1965 "Failed to allocated for MFI_DCMD_PD_GET_INFO %d\n", 1966 error); 1967 if (pd_info) 1968 free(pd_info, M_MFIBUF); 1969 return (error); 1970 } 1971 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_POLLED; 1972 dcmd = &cm->cm_frame->dcmd; 1973 dcmd->mbox[0]=id; 1974 dcmd->header.scsi_status = 0; 1975 dcmd->header.pad0 = 0; 1976 if ((error = mfi_mapcmd(sc, cm)) != 0) { 1977 device_printf(sc->mfi_dev, 1978 "Failed to get physical drive info %d\n", id); 1979 free(pd_info, M_MFIBUF); 1980 mfi_release_command(cm); 1981 return (error); 1982 } 1983 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, 1984 BUS_DMASYNC_POSTREAD); 1985 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 1986 mfi_add_sys_pd_complete(cm); 1987 return (0); 1988 } 1989 1990 static void 1991 mfi_add_sys_pd_complete(struct mfi_command *cm) 1992 { 1993 struct mfi_frame_header *hdr; 1994 struct mfi_pd_info *pd_info; 1995 struct mfi_softc *sc; 1996 device_t child; 1997 1998 sc = cm->cm_sc; 1999 hdr = &cm->cm_frame->header; 2000 pd_info = cm->cm_private; 2001 2002 if (hdr->cmd_status != MFI_STAT_OK) { 2003 free(pd_info, M_MFIBUF); 2004 mfi_release_command(cm); 2005 return; 2006 } 2007 if (pd_info->fw_state != MFI_PD_STATE_SYSTEM) { 2008 device_printf(sc->mfi_dev, "PD=%x is not SYSTEM PD\n", 2009 pd_info->ref.v.device_id); 2010 free(pd_info, M_MFIBUF); 2011 mfi_release_command(cm); 2012 return; 2013 } 2014 mfi_release_command(cm); 2015 2016 mtx_unlock(&sc->mfi_io_lock); 2017 mtx_lock(&Giant); 2018 if ((child = device_add_child(sc->mfi_dev, "mfisyspd", -1)) == NULL) { 2019 device_printf(sc->mfi_dev, "Failed to add system pd\n"); 2020 free(pd_info, M_MFIBUF); 2021 mtx_unlock(&Giant); 2022 mtx_lock(&sc->mfi_io_lock); 2023 return; 2024 } 2025 2026 device_set_ivars(child, pd_info); 2027 device_set_desc(child, "MFI System PD"); 2028 bus_generic_attach(sc->mfi_dev); 2029 mtx_unlock(&Giant); 2030 mtx_lock(&sc->mfi_io_lock); 2031 } 2032 2033 static struct mfi_command * 2034 mfi_bio_command(struct mfi_softc *sc) 2035 { 2036 struct bio *bio; 2037 struct mfi_command *cm = NULL; 2038 2039 /*reserving two commands to avoid starvation for IOCTL*/ 2040 if (sc->mfi_qstat[MFIQ_FREE].q_length < 2) { 2041 return (NULL); 2042 } 2043 if ((bio = mfi_dequeue_bio(sc)) == NULL) { 2044 return (NULL); 2045 } 2046 if ((uintptr_t)bio->bio_driver2 == MFI_LD_IO) { 2047 cm = mfi_build_ldio(sc, bio); 2048 } else if ((uintptr_t) bio->bio_driver2 == MFI_SYS_PD_IO) { 2049 cm = mfi_build_syspdio(sc, bio); 2050 } 2051 if (!cm) 2052 mfi_enqueue_bio(sc, bio); 2053 return cm; 2054 } 2055 2056 /* 2057 * mostly copied from cam/scsi/scsi_all.c:scsi_read_write 2058 */ 2059 2060 int 2061 mfi_build_cdb(int readop, uint8_t byte2, u_int64_t lba, u_int32_t block_count, uint8_t *cdb) 2062 { 2063 int cdb_len; 2064 2065 if (((lba & 0x1fffff) == lba) 2066 && ((block_count & 0xff) == block_count) 2067 && (byte2 == 0)) { 2068 /* We can fit in a 6 byte cdb */ 2069 struct scsi_rw_6 *scsi_cmd; 2070 2071 scsi_cmd = (struct scsi_rw_6 *)cdb; 2072 scsi_cmd->opcode = readop ? READ_6 : WRITE_6; 2073 scsi_ulto3b(lba, scsi_cmd->addr); 2074 scsi_cmd->length = block_count & 0xff; 2075 scsi_cmd->control = 0; 2076 cdb_len = sizeof(*scsi_cmd); 2077 } else if (((block_count & 0xffff) == block_count) && ((lba & 0xffffffff) == lba)) { 2078 /* Need a 10 byte CDB */ 2079 struct scsi_rw_10 *scsi_cmd; 2080 2081 scsi_cmd = (struct scsi_rw_10 *)cdb; 2082 scsi_cmd->opcode = readop ? READ_10 : WRITE_10; 2083 scsi_cmd->byte2 = byte2; 2084 scsi_ulto4b(lba, scsi_cmd->addr); 2085 scsi_cmd->reserved = 0; 2086 scsi_ulto2b(block_count, scsi_cmd->length); 2087 scsi_cmd->control = 0; 2088 cdb_len = sizeof(*scsi_cmd); 2089 } else if (((block_count & 0xffffffff) == block_count) && 2090 ((lba & 0xffffffff) == lba)) { 2091 /* Block count is too big for 10 byte CDB use a 12 byte CDB */ 2092 struct scsi_rw_12 *scsi_cmd; 2093 2094 scsi_cmd = (struct scsi_rw_12 *)cdb; 2095 scsi_cmd->opcode = readop ? READ_12 : WRITE_12; 2096 scsi_cmd->byte2 = byte2; 2097 scsi_ulto4b(lba, scsi_cmd->addr); 2098 scsi_cmd->reserved = 0; 2099 scsi_ulto4b(block_count, scsi_cmd->length); 2100 scsi_cmd->control = 0; 2101 cdb_len = sizeof(*scsi_cmd); 2102 } else { 2103 /* 2104 * 16 byte CDB. We'll only get here if the LBA is larger 2105 * than 2^32 2106 */ 2107 struct scsi_rw_16 *scsi_cmd; 2108 2109 scsi_cmd = (struct scsi_rw_16 *)cdb; 2110 scsi_cmd->opcode = readop ? READ_16 : WRITE_16; 2111 scsi_cmd->byte2 = byte2; 2112 scsi_u64to8b(lba, scsi_cmd->addr); 2113 scsi_cmd->reserved = 0; 2114 scsi_ulto4b(block_count, scsi_cmd->length); 2115 scsi_cmd->control = 0; 2116 cdb_len = sizeof(*scsi_cmd); 2117 } 2118 2119 return cdb_len; 2120 } 2121 2122 extern char *unmapped_buf; 2123 2124 static struct mfi_command * 2125 mfi_build_syspdio(struct mfi_softc *sc, struct bio *bio) 2126 { 2127 struct mfi_command *cm; 2128 struct mfi_pass_frame *pass; 2129 uint32_t context = 0; 2130 int flags = 0, blkcount = 0, readop; 2131 uint8_t cdb_len; 2132 2133 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 2134 2135 if ((cm = mfi_dequeue_free(sc)) == NULL) 2136 return (NULL); 2137 2138 /* Zero out the MFI frame */ 2139 context = cm->cm_frame->header.context; 2140 bzero(cm->cm_frame, sizeof(union mfi_frame)); 2141 cm->cm_frame->header.context = context; 2142 pass = &cm->cm_frame->pass; 2143 bzero(pass->cdb, 16); 2144 pass->header.cmd = MFI_CMD_PD_SCSI_IO; 2145 switch (bio->bio_cmd) { 2146 case BIO_READ: 2147 flags = MFI_CMD_DATAIN | MFI_CMD_BIO; 2148 readop = 1; 2149 break; 2150 case BIO_WRITE: 2151 flags = MFI_CMD_DATAOUT | MFI_CMD_BIO; 2152 readop = 0; 2153 break; 2154 default: 2155 /* TODO: what about BIO_DELETE??? */ 2156 biofinish(bio, NULL, EOPNOTSUPP); 2157 mfi_enqueue_free(cm); 2158 return (NULL); 2159 } 2160 2161 /* Cheat with the sector length to avoid a non-constant division */ 2162 blkcount = howmany(bio->bio_bcount, MFI_SECTOR_LEN); 2163 /* Fill the LBA and Transfer length in CDB */ 2164 cdb_len = mfi_build_cdb(readop, 0, bio->bio_pblkno, blkcount, 2165 pass->cdb); 2166 pass->header.target_id = (uintptr_t)bio->bio_driver1; 2167 pass->header.lun_id = 0; 2168 pass->header.timeout = 0; 2169 pass->header.flags = 0; 2170 pass->header.scsi_status = 0; 2171 pass->header.sense_len = MFI_SENSE_LEN; 2172 pass->header.data_len = bio->bio_bcount; 2173 pass->header.cdb_len = cdb_len; 2174 pass->sense_addr_lo = (uint32_t)cm->cm_sense_busaddr; 2175 pass->sense_addr_hi = (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32); 2176 cm->cm_complete = mfi_bio_complete; 2177 cm->cm_private = bio; 2178 cm->cm_data = unmapped_buf; 2179 cm->cm_len = bio->bio_bcount; 2180 cm->cm_sg = &pass->sgl; 2181 cm->cm_total_frame_size = MFI_PASS_FRAME_SIZE; 2182 cm->cm_flags = flags; 2183 2184 return (cm); 2185 } 2186 2187 static struct mfi_command * 2188 mfi_build_ldio(struct mfi_softc *sc, struct bio *bio) 2189 { 2190 struct mfi_io_frame *io; 2191 struct mfi_command *cm; 2192 int flags; 2193 uint32_t blkcount; 2194 uint32_t context = 0; 2195 2196 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 2197 2198 if ((cm = mfi_dequeue_free(sc)) == NULL) 2199 return (NULL); 2200 2201 /* Zero out the MFI frame */ 2202 context = cm->cm_frame->header.context; 2203 bzero(cm->cm_frame, sizeof(union mfi_frame)); 2204 cm->cm_frame->header.context = context; 2205 io = &cm->cm_frame->io; 2206 switch (bio->bio_cmd) { 2207 case BIO_READ: 2208 io->header.cmd = MFI_CMD_LD_READ; 2209 flags = MFI_CMD_DATAIN | MFI_CMD_BIO; 2210 break; 2211 case BIO_WRITE: 2212 io->header.cmd = MFI_CMD_LD_WRITE; 2213 flags = MFI_CMD_DATAOUT | MFI_CMD_BIO; 2214 break; 2215 default: 2216 /* TODO: what about BIO_DELETE??? */ 2217 biofinish(bio, NULL, EOPNOTSUPP); 2218 mfi_enqueue_free(cm); 2219 return (NULL); 2220 } 2221 2222 /* Cheat with the sector length to avoid a non-constant division */ 2223 blkcount = howmany(bio->bio_bcount, MFI_SECTOR_LEN); 2224 io->header.target_id = (uintptr_t)bio->bio_driver1; 2225 io->header.timeout = 0; 2226 io->header.flags = 0; 2227 io->header.scsi_status = 0; 2228 io->header.sense_len = MFI_SENSE_LEN; 2229 io->header.data_len = blkcount; 2230 io->sense_addr_lo = (uint32_t)cm->cm_sense_busaddr; 2231 io->sense_addr_hi = (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32); 2232 io->lba_hi = (bio->bio_pblkno & 0xffffffff00000000) >> 32; 2233 io->lba_lo = bio->bio_pblkno & 0xffffffff; 2234 cm->cm_complete = mfi_bio_complete; 2235 cm->cm_private = bio; 2236 cm->cm_data = unmapped_buf; 2237 cm->cm_len = bio->bio_bcount; 2238 cm->cm_sg = &io->sgl; 2239 cm->cm_total_frame_size = MFI_IO_FRAME_SIZE; 2240 cm->cm_flags = flags; 2241 2242 return (cm); 2243 } 2244 2245 static void 2246 mfi_bio_complete(struct mfi_command *cm) 2247 { 2248 struct bio *bio; 2249 struct mfi_frame_header *hdr; 2250 struct mfi_softc *sc; 2251 2252 bio = cm->cm_private; 2253 hdr = &cm->cm_frame->header; 2254 sc = cm->cm_sc; 2255 2256 if ((hdr->cmd_status != MFI_STAT_OK) || (hdr->scsi_status != 0)) { 2257 bio->bio_flags |= BIO_ERROR; 2258 bio->bio_error = EIO; 2259 device_printf(sc->mfi_dev, "I/O error, cmd=%p, status=%#x, " 2260 "scsi_status=%#x\n", cm, hdr->cmd_status, hdr->scsi_status); 2261 mfi_print_sense(cm->cm_sc, cm->cm_sense); 2262 } else if (cm->cm_error != 0) { 2263 bio->bio_flags |= BIO_ERROR; 2264 bio->bio_error = cm->cm_error; 2265 device_printf(sc->mfi_dev, "I/O error, cmd=%p, error=%#x\n", 2266 cm, cm->cm_error); 2267 } 2268 2269 mfi_release_command(cm); 2270 mfi_disk_complete(bio); 2271 } 2272 2273 void 2274 mfi_startio(struct mfi_softc *sc) 2275 { 2276 struct mfi_command *cm; 2277 struct ccb_hdr *ccbh; 2278 2279 for (;;) { 2280 /* Don't bother if we're short on resources */ 2281 if (sc->mfi_flags & MFI_FLAGS_QFRZN) 2282 break; 2283 2284 /* Try a command that has already been prepared */ 2285 cm = mfi_dequeue_ready(sc); 2286 2287 if (cm == NULL) { 2288 if ((ccbh = TAILQ_FIRST(&sc->mfi_cam_ccbq)) != NULL) 2289 cm = sc->mfi_cam_start(ccbh); 2290 } 2291 2292 /* Nope, so look for work on the bioq */ 2293 if (cm == NULL) 2294 cm = mfi_bio_command(sc); 2295 2296 /* No work available, so exit */ 2297 if (cm == NULL) 2298 break; 2299 2300 /* Send the command to the controller */ 2301 if (mfi_mapcmd(sc, cm) != 0) { 2302 device_printf(sc->mfi_dev, "Failed to startio\n"); 2303 mfi_requeue_ready(cm); 2304 break; 2305 } 2306 } 2307 } 2308 2309 int 2310 mfi_mapcmd(struct mfi_softc *sc, struct mfi_command *cm) 2311 { 2312 int error, polled; 2313 2314 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 2315 2316 if ((cm->cm_data != NULL) && (cm->cm_frame->header.cmd != MFI_CMD_STP )) { 2317 polled = (cm->cm_flags & MFI_CMD_POLLED) ? BUS_DMA_NOWAIT : 0; 2318 if (cm->cm_flags & MFI_CMD_CCB) 2319 error = bus_dmamap_load_ccb(sc->mfi_buffer_dmat, 2320 cm->cm_dmamap, cm->cm_data, mfi_data_cb, cm, 2321 polled); 2322 else if (cm->cm_flags & MFI_CMD_BIO) 2323 error = bus_dmamap_load_bio(sc->mfi_buffer_dmat, 2324 cm->cm_dmamap, cm->cm_private, mfi_data_cb, cm, 2325 polled); 2326 else 2327 error = bus_dmamap_load(sc->mfi_buffer_dmat, 2328 cm->cm_dmamap, cm->cm_data, cm->cm_len, 2329 mfi_data_cb, cm, polled); 2330 if (error == EINPROGRESS) { 2331 sc->mfi_flags |= MFI_FLAGS_QFRZN; 2332 return (0); 2333 } 2334 } else { 2335 error = mfi_send_frame(sc, cm); 2336 } 2337 2338 return (error); 2339 } 2340 2341 static void 2342 mfi_data_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 2343 { 2344 struct mfi_frame_header *hdr; 2345 struct mfi_command *cm; 2346 union mfi_sgl *sgl; 2347 struct mfi_softc *sc; 2348 int i, j, first, dir; 2349 int sge_size, locked; 2350 2351 cm = (struct mfi_command *)arg; 2352 sc = cm->cm_sc; 2353 hdr = &cm->cm_frame->header; 2354 sgl = cm->cm_sg; 2355 2356 /* 2357 * We need to check if we have the lock as this is async 2358 * callback so even though our caller mfi_mapcmd asserts 2359 * it has the lock, there is no guarantee that hasn't been 2360 * dropped if bus_dmamap_load returned prior to our 2361 * completion. 2362 */ 2363 if ((locked = mtx_owned(&sc->mfi_io_lock)) == 0) 2364 mtx_lock(&sc->mfi_io_lock); 2365 2366 if (error) { 2367 printf("error %d in callback\n", error); 2368 cm->cm_error = error; 2369 mfi_complete(sc, cm); 2370 goto out; 2371 } 2372 /* Use IEEE sgl only for IO's on a SKINNY controller 2373 * For other commands on a SKINNY controller use either 2374 * sg32 or sg64 based on the sizeof(bus_addr_t). 2375 * Also calculate the total frame size based on the type 2376 * of SGL used. 2377 */ 2378 if (((cm->cm_frame->header.cmd == MFI_CMD_PD_SCSI_IO) || 2379 (cm->cm_frame->header.cmd == MFI_CMD_LD_READ) || 2380 (cm->cm_frame->header.cmd == MFI_CMD_LD_WRITE)) && 2381 (sc->mfi_flags & MFI_FLAGS_SKINNY)) { 2382 for (i = 0; i < nsegs; i++) { 2383 sgl->sg_skinny[i].addr = segs[i].ds_addr; 2384 sgl->sg_skinny[i].len = segs[i].ds_len; 2385 sgl->sg_skinny[i].flag = 0; 2386 } 2387 hdr->flags |= MFI_FRAME_IEEE_SGL | MFI_FRAME_SGL64; 2388 sge_size = sizeof(struct mfi_sg_skinny); 2389 hdr->sg_count = nsegs; 2390 } else { 2391 j = 0; 2392 if (cm->cm_frame->header.cmd == MFI_CMD_STP) { 2393 first = cm->cm_stp_len; 2394 if ((sc->mfi_flags & MFI_FLAGS_SG64) == 0) { 2395 sgl->sg32[j].addr = segs[0].ds_addr; 2396 sgl->sg32[j++].len = first; 2397 } else { 2398 sgl->sg64[j].addr = segs[0].ds_addr; 2399 sgl->sg64[j++].len = first; 2400 } 2401 } else 2402 first = 0; 2403 if ((sc->mfi_flags & MFI_FLAGS_SG64) == 0) { 2404 for (i = 0; i < nsegs; i++) { 2405 sgl->sg32[j].addr = segs[i].ds_addr + first; 2406 sgl->sg32[j++].len = segs[i].ds_len - first; 2407 first = 0; 2408 } 2409 } else { 2410 for (i = 0; i < nsegs; i++) { 2411 sgl->sg64[j].addr = segs[i].ds_addr + first; 2412 sgl->sg64[j++].len = segs[i].ds_len - first; 2413 first = 0; 2414 } 2415 hdr->flags |= MFI_FRAME_SGL64; 2416 } 2417 hdr->sg_count = j; 2418 sge_size = sc->mfi_sge_size; 2419 } 2420 2421 dir = 0; 2422 if (cm->cm_flags & MFI_CMD_DATAIN) { 2423 dir |= BUS_DMASYNC_PREREAD; 2424 hdr->flags |= MFI_FRAME_DIR_READ; 2425 } 2426 if (cm->cm_flags & MFI_CMD_DATAOUT) { 2427 dir |= BUS_DMASYNC_PREWRITE; 2428 hdr->flags |= MFI_FRAME_DIR_WRITE; 2429 } 2430 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, dir); 2431 cm->cm_flags |= MFI_CMD_MAPPED; 2432 2433 /* 2434 * Instead of calculating the total number of frames in the 2435 * compound frame, it's already assumed that there will be at 2436 * least 1 frame, so don't compensate for the modulo of the 2437 * following division. 2438 */ 2439 cm->cm_total_frame_size += (sc->mfi_sge_size * nsegs); 2440 cm->cm_extra_frames = (cm->cm_total_frame_size - 1) / MFI_FRAME_SIZE; 2441 2442 if ((error = mfi_send_frame(sc, cm)) != 0) { 2443 printf("error %d in callback from mfi_send_frame\n", error); 2444 cm->cm_error = error; 2445 mfi_complete(sc, cm); 2446 goto out; 2447 } 2448 2449 out: 2450 /* leave the lock in the state we found it */ 2451 if (locked == 0) 2452 mtx_unlock(&sc->mfi_io_lock); 2453 2454 return; 2455 } 2456 2457 static int 2458 mfi_send_frame(struct mfi_softc *sc, struct mfi_command *cm) 2459 { 2460 int error; 2461 2462 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 2463 2464 if (sc->MFA_enabled) 2465 error = mfi_tbolt_send_frame(sc, cm); 2466 else 2467 error = mfi_std_send_frame(sc, cm); 2468 2469 if (error != 0 && (cm->cm_flags & MFI_ON_MFIQ_BUSY) != 0) 2470 mfi_remove_busy(cm); 2471 2472 return (error); 2473 } 2474 2475 static int 2476 mfi_std_send_frame(struct mfi_softc *sc, struct mfi_command *cm) 2477 { 2478 struct mfi_frame_header *hdr; 2479 int tm = mfi_polled_cmd_timeout * 1000; 2480 2481 hdr = &cm->cm_frame->header; 2482 2483 if ((cm->cm_flags & MFI_CMD_POLLED) == 0) { 2484 cm->cm_timestamp = time_uptime; 2485 mfi_enqueue_busy(cm); 2486 } else { 2487 hdr->cmd_status = MFI_STAT_INVALID_STATUS; 2488 hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE; 2489 } 2490 2491 /* 2492 * The bus address of the command is aligned on a 64 byte boundary, 2493 * leaving the least 6 bits as zero. For whatever reason, the 2494 * hardware wants the address shifted right by three, leaving just 2495 * 3 zero bits. These three bits are then used as a prefetching 2496 * hint for the hardware to predict how many frames need to be 2497 * fetched across the bus. If a command has more than 8 frames 2498 * then the 3 bits are set to 0x7 and the firmware uses other 2499 * information in the command to determine the total amount to fetch. 2500 * However, FreeBSD doesn't support I/O larger than 128K, so 8 frames 2501 * is enough for both 32bit and 64bit systems. 2502 */ 2503 if (cm->cm_extra_frames > 7) 2504 cm->cm_extra_frames = 7; 2505 2506 sc->mfi_issue_cmd(sc, cm->cm_frame_busaddr, cm->cm_extra_frames); 2507 2508 if ((cm->cm_flags & MFI_CMD_POLLED) == 0) 2509 return (0); 2510 2511 /* This is a polled command, so busy-wait for it to complete. */ 2512 while (hdr->cmd_status == MFI_STAT_INVALID_STATUS) { 2513 DELAY(1000); 2514 tm -= 1; 2515 if (tm <= 0) 2516 break; 2517 } 2518 2519 if (hdr->cmd_status == MFI_STAT_INVALID_STATUS) { 2520 device_printf(sc->mfi_dev, "Frame %p timed out " 2521 "command 0x%X\n", hdr, cm->cm_frame->dcmd.opcode); 2522 return (ETIMEDOUT); 2523 } 2524 2525 return (0); 2526 } 2527 2528 2529 void 2530 mfi_complete(struct mfi_softc *sc, struct mfi_command *cm) 2531 { 2532 int dir; 2533 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 2534 2535 if ((cm->cm_flags & MFI_CMD_MAPPED) != 0) { 2536 dir = 0; 2537 if ((cm->cm_flags & MFI_CMD_DATAIN) || 2538 (cm->cm_frame->header.cmd == MFI_CMD_STP)) 2539 dir |= BUS_DMASYNC_POSTREAD; 2540 if (cm->cm_flags & MFI_CMD_DATAOUT) 2541 dir |= BUS_DMASYNC_POSTWRITE; 2542 2543 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, dir); 2544 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 2545 cm->cm_flags &= ~MFI_CMD_MAPPED; 2546 } 2547 2548 cm->cm_flags |= MFI_CMD_COMPLETED; 2549 2550 if (cm->cm_complete != NULL) 2551 cm->cm_complete(cm); 2552 else 2553 wakeup(cm); 2554 } 2555 2556 static int 2557 mfi_abort(struct mfi_softc *sc, struct mfi_command **cm_abort) 2558 { 2559 struct mfi_command *cm; 2560 struct mfi_abort_frame *abort; 2561 int i = 0, error; 2562 uint32_t context = 0; 2563 2564 mtx_lock(&sc->mfi_io_lock); 2565 if ((cm = mfi_dequeue_free(sc)) == NULL) { 2566 mtx_unlock(&sc->mfi_io_lock); 2567 return (EBUSY); 2568 } 2569 2570 /* Zero out the MFI frame */ 2571 context = cm->cm_frame->header.context; 2572 bzero(cm->cm_frame, sizeof(union mfi_frame)); 2573 cm->cm_frame->header.context = context; 2574 2575 abort = &cm->cm_frame->abort; 2576 abort->header.cmd = MFI_CMD_ABORT; 2577 abort->header.flags = 0; 2578 abort->header.scsi_status = 0; 2579 abort->abort_context = (*cm_abort)->cm_frame->header.context; 2580 abort->abort_mfi_addr_lo = (uint32_t)(*cm_abort)->cm_frame_busaddr; 2581 abort->abort_mfi_addr_hi = 2582 (uint32_t)((uint64_t)(*cm_abort)->cm_frame_busaddr >> 32); 2583 cm->cm_data = NULL; 2584 cm->cm_flags = MFI_CMD_POLLED; 2585 2586 if ((error = mfi_mapcmd(sc, cm)) != 0) 2587 device_printf(sc->mfi_dev, "failed to abort command\n"); 2588 mfi_release_command(cm); 2589 2590 mtx_unlock(&sc->mfi_io_lock); 2591 while (i < 5 && *cm_abort != NULL) { 2592 tsleep(cm_abort, 0, "mfiabort", 2593 5 * hz); 2594 i++; 2595 } 2596 if (*cm_abort != NULL) { 2597 /* Force a complete if command didn't abort */ 2598 mtx_lock(&sc->mfi_io_lock); 2599 (*cm_abort)->cm_complete(*cm_abort); 2600 mtx_unlock(&sc->mfi_io_lock); 2601 } 2602 2603 return (error); 2604 } 2605 2606 int 2607 mfi_dump_blocks(struct mfi_softc *sc, int id, uint64_t lba, void *virt, 2608 int len) 2609 { 2610 struct mfi_command *cm; 2611 struct mfi_io_frame *io; 2612 int error; 2613 uint32_t context = 0; 2614 2615 if ((cm = mfi_dequeue_free(sc)) == NULL) 2616 return (EBUSY); 2617 2618 /* Zero out the MFI frame */ 2619 context = cm->cm_frame->header.context; 2620 bzero(cm->cm_frame, sizeof(union mfi_frame)); 2621 cm->cm_frame->header.context = context; 2622 2623 io = &cm->cm_frame->io; 2624 io->header.cmd = MFI_CMD_LD_WRITE; 2625 io->header.target_id = id; 2626 io->header.timeout = 0; 2627 io->header.flags = 0; 2628 io->header.scsi_status = 0; 2629 io->header.sense_len = MFI_SENSE_LEN; 2630 io->header.data_len = howmany(len, MFI_SECTOR_LEN); 2631 io->sense_addr_lo = (uint32_t)cm->cm_sense_busaddr; 2632 io->sense_addr_hi = (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32); 2633 io->lba_hi = (lba & 0xffffffff00000000) >> 32; 2634 io->lba_lo = lba & 0xffffffff; 2635 cm->cm_data = virt; 2636 cm->cm_len = len; 2637 cm->cm_sg = &io->sgl; 2638 cm->cm_total_frame_size = MFI_IO_FRAME_SIZE; 2639 cm->cm_flags = MFI_CMD_POLLED | MFI_CMD_DATAOUT; 2640 2641 if ((error = mfi_mapcmd(sc, cm)) != 0) 2642 device_printf(sc->mfi_dev, "failed dump blocks\n"); 2643 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, 2644 BUS_DMASYNC_POSTWRITE); 2645 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 2646 mfi_release_command(cm); 2647 2648 return (error); 2649 } 2650 2651 int 2652 mfi_dump_syspd_blocks(struct mfi_softc *sc, int id, uint64_t lba, void *virt, 2653 int len) 2654 { 2655 struct mfi_command *cm; 2656 struct mfi_pass_frame *pass; 2657 int error, readop, cdb_len; 2658 uint32_t blkcount; 2659 2660 if ((cm = mfi_dequeue_free(sc)) == NULL) 2661 return (EBUSY); 2662 2663 pass = &cm->cm_frame->pass; 2664 bzero(pass->cdb, 16); 2665 pass->header.cmd = MFI_CMD_PD_SCSI_IO; 2666 2667 readop = 0; 2668 blkcount = howmany(len, MFI_SECTOR_LEN); 2669 cdb_len = mfi_build_cdb(readop, 0, lba, blkcount, pass->cdb); 2670 pass->header.target_id = id; 2671 pass->header.timeout = 0; 2672 pass->header.flags = 0; 2673 pass->header.scsi_status = 0; 2674 pass->header.sense_len = MFI_SENSE_LEN; 2675 pass->header.data_len = len; 2676 pass->header.cdb_len = cdb_len; 2677 pass->sense_addr_lo = (uint32_t)cm->cm_sense_busaddr; 2678 pass->sense_addr_hi = (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32); 2679 cm->cm_data = virt; 2680 cm->cm_len = len; 2681 cm->cm_sg = &pass->sgl; 2682 cm->cm_total_frame_size = MFI_PASS_FRAME_SIZE; 2683 cm->cm_flags = MFI_CMD_POLLED | MFI_CMD_DATAOUT | MFI_CMD_SCSI; 2684 2685 if ((error = mfi_mapcmd(sc, cm)) != 0) 2686 device_printf(sc->mfi_dev, "failed dump blocks\n"); 2687 bus_dmamap_sync(sc->mfi_buffer_dmat, cm->cm_dmamap, 2688 BUS_DMASYNC_POSTWRITE); 2689 bus_dmamap_unload(sc->mfi_buffer_dmat, cm->cm_dmamap); 2690 mfi_release_command(cm); 2691 2692 return (error); 2693 } 2694 2695 static int 2696 mfi_open(struct cdev *dev, int flags, int fmt, struct thread *td) 2697 { 2698 struct mfi_softc *sc; 2699 int error; 2700 2701 sc = dev->si_drv1; 2702 2703 mtx_lock(&sc->mfi_io_lock); 2704 if (sc->mfi_detaching) 2705 error = ENXIO; 2706 else { 2707 sc->mfi_flags |= MFI_FLAGS_OPEN; 2708 error = 0; 2709 } 2710 mtx_unlock(&sc->mfi_io_lock); 2711 2712 return (error); 2713 } 2714 2715 static int 2716 mfi_close(struct cdev *dev, int flags, int fmt, struct thread *td) 2717 { 2718 struct mfi_softc *sc; 2719 struct mfi_aen *mfi_aen_entry, *tmp; 2720 2721 sc = dev->si_drv1; 2722 2723 mtx_lock(&sc->mfi_io_lock); 2724 sc->mfi_flags &= ~MFI_FLAGS_OPEN; 2725 2726 TAILQ_FOREACH_SAFE(mfi_aen_entry, &sc->mfi_aen_pids, aen_link, tmp) { 2727 if (mfi_aen_entry->p == curproc) { 2728 TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry, 2729 aen_link); 2730 free(mfi_aen_entry, M_MFIBUF); 2731 } 2732 } 2733 mtx_unlock(&sc->mfi_io_lock); 2734 return (0); 2735 } 2736 2737 static int 2738 mfi_config_lock(struct mfi_softc *sc, uint32_t opcode) 2739 { 2740 2741 switch (opcode) { 2742 case MFI_DCMD_LD_DELETE: 2743 case MFI_DCMD_CFG_ADD: 2744 case MFI_DCMD_CFG_CLEAR: 2745 case MFI_DCMD_CFG_FOREIGN_IMPORT: 2746 sx_xlock(&sc->mfi_config_lock); 2747 return (1); 2748 default: 2749 return (0); 2750 } 2751 } 2752 2753 static void 2754 mfi_config_unlock(struct mfi_softc *sc, int locked) 2755 { 2756 2757 if (locked) 2758 sx_xunlock(&sc->mfi_config_lock); 2759 } 2760 2761 /* 2762 * Perform pre-issue checks on commands from userland and possibly veto 2763 * them. 2764 */ 2765 static int 2766 mfi_check_command_pre(struct mfi_softc *sc, struct mfi_command *cm) 2767 { 2768 struct mfi_disk *ld, *ld2; 2769 int error; 2770 struct mfi_system_pd *syspd = NULL; 2771 uint16_t syspd_id; 2772 uint16_t *mbox; 2773 2774 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 2775 error = 0; 2776 switch (cm->cm_frame->dcmd.opcode) { 2777 case MFI_DCMD_LD_DELETE: 2778 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) { 2779 if (ld->ld_id == cm->cm_frame->dcmd.mbox[0]) 2780 break; 2781 } 2782 if (ld == NULL) 2783 error = ENOENT; 2784 else 2785 error = mfi_disk_disable(ld); 2786 break; 2787 case MFI_DCMD_CFG_CLEAR: 2788 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) { 2789 error = mfi_disk_disable(ld); 2790 if (error) 2791 break; 2792 } 2793 if (error) { 2794 TAILQ_FOREACH(ld2, &sc->mfi_ld_tqh, ld_link) { 2795 if (ld2 == ld) 2796 break; 2797 mfi_disk_enable(ld2); 2798 } 2799 } 2800 break; 2801 case MFI_DCMD_PD_STATE_SET: 2802 mbox = (uint16_t *) cm->cm_frame->dcmd.mbox; 2803 syspd_id = mbox[0]; 2804 if (mbox[2] == MFI_PD_STATE_UNCONFIGURED_GOOD) { 2805 TAILQ_FOREACH(syspd, &sc->mfi_syspd_tqh, pd_link) { 2806 if (syspd->pd_id == syspd_id) 2807 break; 2808 } 2809 } 2810 else 2811 break; 2812 if (syspd) 2813 error = mfi_syspd_disable(syspd); 2814 break; 2815 default: 2816 break; 2817 } 2818 return (error); 2819 } 2820 2821 /* Perform post-issue checks on commands from userland. */ 2822 static void 2823 mfi_check_command_post(struct mfi_softc *sc, struct mfi_command *cm) 2824 { 2825 struct mfi_disk *ld, *ldn; 2826 struct mfi_system_pd *syspd = NULL; 2827 uint16_t syspd_id; 2828 uint16_t *mbox; 2829 2830 switch (cm->cm_frame->dcmd.opcode) { 2831 case MFI_DCMD_LD_DELETE: 2832 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) { 2833 if (ld->ld_id == cm->cm_frame->dcmd.mbox[0]) 2834 break; 2835 } 2836 KASSERT(ld != NULL, ("volume dissappeared")); 2837 if (cm->cm_frame->header.cmd_status == MFI_STAT_OK) { 2838 mtx_unlock(&sc->mfi_io_lock); 2839 mtx_lock(&Giant); 2840 device_delete_child(sc->mfi_dev, ld->ld_dev); 2841 mtx_unlock(&Giant); 2842 mtx_lock(&sc->mfi_io_lock); 2843 } else 2844 mfi_disk_enable(ld); 2845 break; 2846 case MFI_DCMD_CFG_CLEAR: 2847 if (cm->cm_frame->header.cmd_status == MFI_STAT_OK) { 2848 mtx_unlock(&sc->mfi_io_lock); 2849 mtx_lock(&Giant); 2850 TAILQ_FOREACH_SAFE(ld, &sc->mfi_ld_tqh, ld_link, ldn) { 2851 device_delete_child(sc->mfi_dev, ld->ld_dev); 2852 } 2853 mtx_unlock(&Giant); 2854 mtx_lock(&sc->mfi_io_lock); 2855 } else { 2856 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) 2857 mfi_disk_enable(ld); 2858 } 2859 break; 2860 case MFI_DCMD_CFG_ADD: 2861 mfi_ldprobe(sc); 2862 break; 2863 case MFI_DCMD_CFG_FOREIGN_IMPORT: 2864 mfi_ldprobe(sc); 2865 break; 2866 case MFI_DCMD_PD_STATE_SET: 2867 mbox = (uint16_t *) cm->cm_frame->dcmd.mbox; 2868 syspd_id = mbox[0]; 2869 if (mbox[2] == MFI_PD_STATE_UNCONFIGURED_GOOD) { 2870 TAILQ_FOREACH(syspd, &sc->mfi_syspd_tqh,pd_link) { 2871 if (syspd->pd_id == syspd_id) 2872 break; 2873 } 2874 } 2875 else 2876 break; 2877 /* If the transition fails then enable the syspd again */ 2878 if (syspd && cm->cm_frame->header.cmd_status != MFI_STAT_OK) 2879 mfi_syspd_enable(syspd); 2880 break; 2881 } 2882 } 2883 2884 static int 2885 mfi_check_for_sscd(struct mfi_softc *sc, struct mfi_command *cm) 2886 { 2887 struct mfi_config_data *conf_data; 2888 struct mfi_command *ld_cm = NULL; 2889 struct mfi_ld_info *ld_info = NULL; 2890 struct mfi_ld_config *ld; 2891 char *p; 2892 int error = 0; 2893 2894 conf_data = (struct mfi_config_data *)cm->cm_data; 2895 2896 if (cm->cm_frame->dcmd.opcode == MFI_DCMD_CFG_ADD) { 2897 p = (char *)conf_data->array; 2898 p += conf_data->array_size * conf_data->array_count; 2899 ld = (struct mfi_ld_config *)p; 2900 if (ld->params.isSSCD == 1) 2901 error = 1; 2902 } else if (cm->cm_frame->dcmd.opcode == MFI_DCMD_LD_DELETE) { 2903 error = mfi_dcmd_command (sc, &ld_cm, MFI_DCMD_LD_GET_INFO, 2904 (void **)&ld_info, sizeof(*ld_info)); 2905 if (error) { 2906 device_printf(sc->mfi_dev, "Failed to allocate" 2907 "MFI_DCMD_LD_GET_INFO %d", error); 2908 if (ld_info) 2909 free(ld_info, M_MFIBUF); 2910 return 0; 2911 } 2912 ld_cm->cm_flags = MFI_CMD_DATAIN; 2913 ld_cm->cm_frame->dcmd.mbox[0]= cm->cm_frame->dcmd.mbox[0]; 2914 ld_cm->cm_frame->header.target_id = cm->cm_frame->dcmd.mbox[0]; 2915 if (mfi_wait_command(sc, ld_cm) != 0) { 2916 device_printf(sc->mfi_dev, "failed to get log drv\n"); 2917 mfi_release_command(ld_cm); 2918 free(ld_info, M_MFIBUF); 2919 return 0; 2920 } 2921 2922 if (ld_cm->cm_frame->header.cmd_status != MFI_STAT_OK) { 2923 free(ld_info, M_MFIBUF); 2924 mfi_release_command(ld_cm); 2925 return 0; 2926 } 2927 else 2928 ld_info = (struct mfi_ld_info *)ld_cm->cm_private; 2929 2930 if (ld_info->ld_config.params.isSSCD == 1) 2931 error = 1; 2932 2933 mfi_release_command(ld_cm); 2934 free(ld_info, M_MFIBUF); 2935 2936 } 2937 return error; 2938 } 2939 2940 static int 2941 mfi_stp_cmd(struct mfi_softc *sc, struct mfi_command *cm,caddr_t arg) 2942 { 2943 uint8_t i; 2944 struct mfi_ioc_packet *ioc; 2945 ioc = (struct mfi_ioc_packet *)arg; 2946 int sge_size, error; 2947 struct megasas_sge *kern_sge; 2948 2949 memset(sc->kbuff_arr, 0, sizeof(sc->kbuff_arr)); 2950 kern_sge =(struct megasas_sge *) ((uintptr_t)cm->cm_frame + ioc->mfi_sgl_off); 2951 cm->cm_frame->header.sg_count = ioc->mfi_sge_count; 2952 2953 if (sizeof(bus_addr_t) == 8) { 2954 cm->cm_frame->header.flags |= MFI_FRAME_SGL64; 2955 cm->cm_extra_frames = 2; 2956 sge_size = sizeof(struct mfi_sg64); 2957 } else { 2958 cm->cm_extra_frames = (cm->cm_total_frame_size - 1) / MFI_FRAME_SIZE; 2959 sge_size = sizeof(struct mfi_sg32); 2960 } 2961 2962 cm->cm_total_frame_size += (sge_size * ioc->mfi_sge_count); 2963 for (i = 0; i < ioc->mfi_sge_count; i++) { 2964 if (bus_dma_tag_create( sc->mfi_parent_dmat, /* parent */ 2965 1, 0, /* algnmnt, boundary */ 2966 BUS_SPACE_MAXADDR_32BIT,/* lowaddr */ 2967 BUS_SPACE_MAXADDR, /* highaddr */ 2968 NULL, NULL, /* filter, filterarg */ 2969 ioc->mfi_sgl[i].iov_len,/* maxsize */ 2970 2, /* nsegments */ 2971 ioc->mfi_sgl[i].iov_len,/* maxsegsize */ 2972 BUS_DMA_ALLOCNOW, /* flags */ 2973 NULL, NULL, /* lockfunc, lockarg */ 2974 &sc->mfi_kbuff_arr_dmat[i])) { 2975 device_printf(sc->mfi_dev, 2976 "Cannot allocate mfi_kbuff_arr_dmat tag\n"); 2977 return (ENOMEM); 2978 } 2979 2980 if (bus_dmamem_alloc(sc->mfi_kbuff_arr_dmat[i], 2981 (void **)&sc->kbuff_arr[i], BUS_DMA_NOWAIT, 2982 &sc->mfi_kbuff_arr_dmamap[i])) { 2983 device_printf(sc->mfi_dev, 2984 "Cannot allocate mfi_kbuff_arr_dmamap memory\n"); 2985 return (ENOMEM); 2986 } 2987 2988 bus_dmamap_load(sc->mfi_kbuff_arr_dmat[i], 2989 sc->mfi_kbuff_arr_dmamap[i], sc->kbuff_arr[i], 2990 ioc->mfi_sgl[i].iov_len, mfi_addr_cb, 2991 &sc->mfi_kbuff_arr_busaddr[i], 0); 2992 2993 if (!sc->kbuff_arr[i]) { 2994 device_printf(sc->mfi_dev, 2995 "Could not allocate memory for kbuff_arr info\n"); 2996 return -1; 2997 } 2998 kern_sge[i].phys_addr = sc->mfi_kbuff_arr_busaddr[i]; 2999 kern_sge[i].length = ioc->mfi_sgl[i].iov_len; 3000 3001 if (sizeof(bus_addr_t) == 8) { 3002 cm->cm_frame->stp.sgl.sg64[i].addr = 3003 kern_sge[i].phys_addr; 3004 cm->cm_frame->stp.sgl.sg64[i].len = 3005 ioc->mfi_sgl[i].iov_len; 3006 } else { 3007 cm->cm_frame->stp.sgl.sg32[i].addr = 3008 kern_sge[i].phys_addr; 3009 cm->cm_frame->stp.sgl.sg32[i].len = 3010 ioc->mfi_sgl[i].iov_len; 3011 } 3012 3013 error = copyin(ioc->mfi_sgl[i].iov_base, 3014 sc->kbuff_arr[i], 3015 ioc->mfi_sgl[i].iov_len); 3016 if (error != 0) { 3017 device_printf(sc->mfi_dev, "Copy in failed\n"); 3018 return error; 3019 } 3020 } 3021 3022 cm->cm_flags |=MFI_CMD_MAPPED; 3023 return 0; 3024 } 3025 3026 static int 3027 mfi_user_command(struct mfi_softc *sc, struct mfi_ioc_passthru *ioc) 3028 { 3029 struct mfi_command *cm; 3030 struct mfi_dcmd_frame *dcmd; 3031 void *ioc_buf = NULL; 3032 uint32_t context; 3033 int error = 0, locked; 3034 3035 3036 if (ioc->buf_size > 0) { 3037 if (ioc->buf_size > 1024 * 1024) 3038 return (ENOMEM); 3039 ioc_buf = malloc(ioc->buf_size, M_MFIBUF, M_WAITOK); 3040 error = copyin(ioc->buf, ioc_buf, ioc->buf_size); 3041 if (error) { 3042 device_printf(sc->mfi_dev, "failed to copyin\n"); 3043 free(ioc_buf, M_MFIBUF); 3044 return (error); 3045 } 3046 } 3047 3048 locked = mfi_config_lock(sc, ioc->ioc_frame.opcode); 3049 3050 mtx_lock(&sc->mfi_io_lock); 3051 while ((cm = mfi_dequeue_free(sc)) == NULL) 3052 msleep(mfi_user_command, &sc->mfi_io_lock, 0, "mfiioc", hz); 3053 3054 /* Save context for later */ 3055 context = cm->cm_frame->header.context; 3056 3057 dcmd = &cm->cm_frame->dcmd; 3058 bcopy(&ioc->ioc_frame, dcmd, sizeof(struct mfi_dcmd_frame)); 3059 3060 cm->cm_sg = &dcmd->sgl; 3061 cm->cm_total_frame_size = MFI_DCMD_FRAME_SIZE; 3062 cm->cm_data = ioc_buf; 3063 cm->cm_len = ioc->buf_size; 3064 3065 /* restore context */ 3066 cm->cm_frame->header.context = context; 3067 3068 /* Cheat since we don't know if we're writing or reading */ 3069 cm->cm_flags = MFI_CMD_DATAIN | MFI_CMD_DATAOUT; 3070 3071 error = mfi_check_command_pre(sc, cm); 3072 if (error) 3073 goto out; 3074 3075 error = mfi_wait_command(sc, cm); 3076 if (error) { 3077 device_printf(sc->mfi_dev, "ioctl failed %d\n", error); 3078 goto out; 3079 } 3080 bcopy(dcmd, &ioc->ioc_frame, sizeof(struct mfi_dcmd_frame)); 3081 mfi_check_command_post(sc, cm); 3082 out: 3083 mfi_release_command(cm); 3084 mtx_unlock(&sc->mfi_io_lock); 3085 mfi_config_unlock(sc, locked); 3086 if (ioc->buf_size > 0) 3087 error = copyout(ioc_buf, ioc->buf, ioc->buf_size); 3088 if (ioc_buf) 3089 free(ioc_buf, M_MFIBUF); 3090 return (error); 3091 } 3092 3093 #define PTRIN(p) ((void *)(uintptr_t)(p)) 3094 3095 static int 3096 mfi_ioctl(struct cdev *dev, u_long cmd, caddr_t arg, int flag, struct thread *td) 3097 { 3098 struct mfi_softc *sc; 3099 union mfi_statrequest *ms; 3100 struct mfi_ioc_packet *ioc; 3101 #ifdef COMPAT_FREEBSD32 3102 struct mfi_ioc_packet32 *ioc32; 3103 #endif 3104 struct mfi_ioc_aen *aen; 3105 struct mfi_command *cm = NULL; 3106 uint32_t context = 0; 3107 union mfi_sense_ptr sense_ptr; 3108 uint8_t *data = NULL, *temp, *addr, skip_pre_post = 0; 3109 size_t len; 3110 int i, res; 3111 struct mfi_ioc_passthru *iop = (struct mfi_ioc_passthru *)arg; 3112 #ifdef COMPAT_FREEBSD32 3113 struct mfi_ioc_passthru32 *iop32 = (struct mfi_ioc_passthru32 *)arg; 3114 struct mfi_ioc_passthru iop_swab; 3115 #endif 3116 int error, locked; 3117 union mfi_sgl *sgl; 3118 sc = dev->si_drv1; 3119 error = 0; 3120 3121 if (sc->adpreset) 3122 return EBUSY; 3123 3124 if (sc->hw_crit_error) 3125 return EBUSY; 3126 3127 if (sc->issuepend_done == 0) 3128 return EBUSY; 3129 3130 switch (cmd) { 3131 case MFIIO_STATS: 3132 ms = (union mfi_statrequest *)arg; 3133 switch (ms->ms_item) { 3134 case MFIQ_FREE: 3135 case MFIQ_BIO: 3136 case MFIQ_READY: 3137 case MFIQ_BUSY: 3138 bcopy(&sc->mfi_qstat[ms->ms_item], &ms->ms_qstat, 3139 sizeof(struct mfi_qstat)); 3140 break; 3141 default: 3142 error = ENOIOCTL; 3143 break; 3144 } 3145 break; 3146 case MFIIO_QUERY_DISK: 3147 { 3148 struct mfi_query_disk *qd; 3149 struct mfi_disk *ld; 3150 3151 qd = (struct mfi_query_disk *)arg; 3152 mtx_lock(&sc->mfi_io_lock); 3153 TAILQ_FOREACH(ld, &sc->mfi_ld_tqh, ld_link) { 3154 if (ld->ld_id == qd->array_id) 3155 break; 3156 } 3157 if (ld == NULL) { 3158 qd->present = 0; 3159 mtx_unlock(&sc->mfi_io_lock); 3160 return (0); 3161 } 3162 qd->present = 1; 3163 if (ld->ld_flags & MFI_DISK_FLAGS_OPEN) 3164 qd->open = 1; 3165 bzero(qd->devname, SPECNAMELEN + 1); 3166 snprintf(qd->devname, SPECNAMELEN, "mfid%d", ld->ld_unit); 3167 mtx_unlock(&sc->mfi_io_lock); 3168 break; 3169 } 3170 case MFI_CMD: 3171 #ifdef COMPAT_FREEBSD32 3172 case MFI_CMD32: 3173 #endif 3174 { 3175 devclass_t devclass; 3176 ioc = (struct mfi_ioc_packet *)arg; 3177 int adapter; 3178 3179 adapter = ioc->mfi_adapter_no; 3180 if (device_get_unit(sc->mfi_dev) == 0 && adapter != 0) { 3181 devclass = devclass_find("mfi"); 3182 sc = devclass_get_softc(devclass, adapter); 3183 } 3184 mtx_lock(&sc->mfi_io_lock); 3185 if ((cm = mfi_dequeue_free(sc)) == NULL) { 3186 mtx_unlock(&sc->mfi_io_lock); 3187 return (EBUSY); 3188 } 3189 mtx_unlock(&sc->mfi_io_lock); 3190 locked = 0; 3191 3192 /* 3193 * save off original context since copying from user 3194 * will clobber some data 3195 */ 3196 context = cm->cm_frame->header.context; 3197 cm->cm_frame->header.context = cm->cm_index; 3198 3199 bcopy(ioc->mfi_frame.raw, cm->cm_frame, 3200 2 * MEGAMFI_FRAME_SIZE); 3201 cm->cm_total_frame_size = (sizeof(union mfi_sgl) 3202 * ioc->mfi_sge_count) + ioc->mfi_sgl_off; 3203 cm->cm_frame->header.scsi_status = 0; 3204 cm->cm_frame->header.pad0 = 0; 3205 if (ioc->mfi_sge_count) { 3206 cm->cm_sg = 3207 (union mfi_sgl *)&cm->cm_frame->bytes[ioc->mfi_sgl_off]; 3208 } 3209 sgl = cm->cm_sg; 3210 cm->cm_flags = 0; 3211 if (cm->cm_frame->header.flags & MFI_FRAME_DATAIN) 3212 cm->cm_flags |= MFI_CMD_DATAIN; 3213 if (cm->cm_frame->header.flags & MFI_FRAME_DATAOUT) 3214 cm->cm_flags |= MFI_CMD_DATAOUT; 3215 /* Legacy app shim */ 3216 if (cm->cm_flags == 0) 3217 cm->cm_flags |= MFI_CMD_DATAIN | MFI_CMD_DATAOUT; 3218 cm->cm_len = cm->cm_frame->header.data_len; 3219 if (cm->cm_frame->header.cmd == MFI_CMD_STP) { 3220 #ifdef COMPAT_FREEBSD32 3221 if (cmd == MFI_CMD) { 3222 #endif 3223 /* Native */ 3224 cm->cm_stp_len = ioc->mfi_sgl[0].iov_len; 3225 #ifdef COMPAT_FREEBSD32 3226 } else { 3227 /* 32bit on 64bit */ 3228 ioc32 = (struct mfi_ioc_packet32 *)ioc; 3229 cm->cm_stp_len = ioc32->mfi_sgl[0].iov_len; 3230 } 3231 #endif 3232 cm->cm_len += cm->cm_stp_len; 3233 } 3234 if (cm->cm_len && 3235 (cm->cm_flags & (MFI_CMD_DATAIN | MFI_CMD_DATAOUT))) { 3236 cm->cm_data = data = malloc(cm->cm_len, M_MFIBUF, 3237 M_WAITOK | M_ZERO); 3238 } else { 3239 cm->cm_data = 0; 3240 } 3241 3242 /* restore header context */ 3243 cm->cm_frame->header.context = context; 3244 3245 if (cm->cm_frame->header.cmd == MFI_CMD_STP) { 3246 res = mfi_stp_cmd(sc, cm, arg); 3247 if (res != 0) 3248 goto out; 3249 } else { 3250 temp = data; 3251 if ((cm->cm_flags & MFI_CMD_DATAOUT) || 3252 (cm->cm_frame->header.cmd == MFI_CMD_STP)) { 3253 for (i = 0; i < ioc->mfi_sge_count; i++) { 3254 #ifdef COMPAT_FREEBSD32 3255 if (cmd == MFI_CMD) { 3256 #endif 3257 /* Native */ 3258 addr = ioc->mfi_sgl[i].iov_base; 3259 len = ioc->mfi_sgl[i].iov_len; 3260 #ifdef COMPAT_FREEBSD32 3261 } else { 3262 /* 32bit on 64bit */ 3263 ioc32 = (struct mfi_ioc_packet32 *)ioc; 3264 addr = PTRIN(ioc32->mfi_sgl[i].iov_base); 3265 len = ioc32->mfi_sgl[i].iov_len; 3266 } 3267 #endif 3268 error = copyin(addr, temp, len); 3269 if (error != 0) { 3270 device_printf(sc->mfi_dev, 3271 "Copy in failed\n"); 3272 goto out; 3273 } 3274 temp = &temp[len]; 3275 } 3276 } 3277 } 3278 3279 if (cm->cm_frame->header.cmd == MFI_CMD_DCMD) 3280 locked = mfi_config_lock(sc, 3281 cm->cm_frame->dcmd.opcode); 3282 3283 if (cm->cm_frame->header.cmd == MFI_CMD_PD_SCSI_IO) { 3284 cm->cm_frame->pass.sense_addr_lo = 3285 (uint32_t)cm->cm_sense_busaddr; 3286 cm->cm_frame->pass.sense_addr_hi = 3287 (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32); 3288 } 3289 mtx_lock(&sc->mfi_io_lock); 3290 skip_pre_post = mfi_check_for_sscd (sc, cm); 3291 if (!skip_pre_post) { 3292 error = mfi_check_command_pre(sc, cm); 3293 if (error) { 3294 mtx_unlock(&sc->mfi_io_lock); 3295 goto out; 3296 } 3297 } 3298 if ((error = mfi_wait_command(sc, cm)) != 0) { 3299 device_printf(sc->mfi_dev, 3300 "Controller polled failed\n"); 3301 mtx_unlock(&sc->mfi_io_lock); 3302 goto out; 3303 } 3304 if (!skip_pre_post) { 3305 mfi_check_command_post(sc, cm); 3306 } 3307 mtx_unlock(&sc->mfi_io_lock); 3308 3309 if (cm->cm_frame->header.cmd != MFI_CMD_STP) { 3310 temp = data; 3311 if ((cm->cm_flags & MFI_CMD_DATAIN) || 3312 (cm->cm_frame->header.cmd == MFI_CMD_STP)) { 3313 for (i = 0; i < ioc->mfi_sge_count; i++) { 3314 #ifdef COMPAT_FREEBSD32 3315 if (cmd == MFI_CMD) { 3316 #endif 3317 /* Native */ 3318 addr = ioc->mfi_sgl[i].iov_base; 3319 len = ioc->mfi_sgl[i].iov_len; 3320 #ifdef COMPAT_FREEBSD32 3321 } else { 3322 /* 32bit on 64bit */ 3323 ioc32 = (struct mfi_ioc_packet32 *)ioc; 3324 addr = PTRIN(ioc32->mfi_sgl[i].iov_base); 3325 len = ioc32->mfi_sgl[i].iov_len; 3326 } 3327 #endif 3328 error = copyout(temp, addr, len); 3329 if (error != 0) { 3330 device_printf(sc->mfi_dev, 3331 "Copy out failed\n"); 3332 goto out; 3333 } 3334 temp = &temp[len]; 3335 } 3336 } 3337 } 3338 3339 if (ioc->mfi_sense_len) { 3340 /* get user-space sense ptr then copy out sense */ 3341 bcopy(&ioc->mfi_frame.raw[ioc->mfi_sense_off], 3342 &sense_ptr.sense_ptr_data[0], 3343 sizeof(sense_ptr.sense_ptr_data)); 3344 #ifdef COMPAT_FREEBSD32 3345 if (cmd != MFI_CMD) { 3346 /* 3347 * not 64bit native so zero out any address 3348 * over 32bit */ 3349 sense_ptr.addr.high = 0; 3350 } 3351 #endif 3352 error = copyout(cm->cm_sense, sense_ptr.user_space, 3353 ioc->mfi_sense_len); 3354 if (error != 0) { 3355 device_printf(sc->mfi_dev, 3356 "Copy out failed\n"); 3357 goto out; 3358 } 3359 } 3360 3361 ioc->mfi_frame.hdr.cmd_status = cm->cm_frame->header.cmd_status; 3362 out: 3363 mfi_config_unlock(sc, locked); 3364 if (data) 3365 free(data, M_MFIBUF); 3366 if (cm->cm_frame->header.cmd == MFI_CMD_STP) { 3367 for (i = 0; i < 2; i++) { 3368 if (sc->kbuff_arr[i]) { 3369 if (sc->mfi_kbuff_arr_busaddr[i] != 0) 3370 bus_dmamap_unload( 3371 sc->mfi_kbuff_arr_dmat[i], 3372 sc->mfi_kbuff_arr_dmamap[i] 3373 ); 3374 if (sc->kbuff_arr[i] != NULL) 3375 bus_dmamem_free( 3376 sc->mfi_kbuff_arr_dmat[i], 3377 sc->kbuff_arr[i], 3378 sc->mfi_kbuff_arr_dmamap[i] 3379 ); 3380 if (sc->mfi_kbuff_arr_dmat[i] != NULL) 3381 bus_dma_tag_destroy( 3382 sc->mfi_kbuff_arr_dmat[i]); 3383 } 3384 } 3385 } 3386 if (cm) { 3387 mtx_lock(&sc->mfi_io_lock); 3388 mfi_release_command(cm); 3389 mtx_unlock(&sc->mfi_io_lock); 3390 } 3391 3392 break; 3393 } 3394 case MFI_SET_AEN: 3395 aen = (struct mfi_ioc_aen *)arg; 3396 mtx_lock(&sc->mfi_io_lock); 3397 error = mfi_aen_register(sc, aen->aen_seq_num, 3398 aen->aen_class_locale); 3399 mtx_unlock(&sc->mfi_io_lock); 3400 3401 break; 3402 case MFI_LINUX_CMD_2: /* Firmware Linux ioctl shim */ 3403 { 3404 devclass_t devclass; 3405 struct mfi_linux_ioc_packet l_ioc; 3406 int adapter; 3407 3408 devclass = devclass_find("mfi"); 3409 if (devclass == NULL) 3410 return (ENOENT); 3411 3412 error = copyin(arg, &l_ioc, sizeof(l_ioc)); 3413 if (error) 3414 return (error); 3415 adapter = l_ioc.lioc_adapter_no; 3416 sc = devclass_get_softc(devclass, adapter); 3417 if (sc == NULL) 3418 return (ENOENT); 3419 return (mfi_linux_ioctl_int(sc->mfi_cdev, 3420 cmd, arg, flag, td)); 3421 break; 3422 } 3423 case MFI_LINUX_SET_AEN_2: /* AEN Linux ioctl shim */ 3424 { 3425 devclass_t devclass; 3426 struct mfi_linux_ioc_aen l_aen; 3427 int adapter; 3428 3429 devclass = devclass_find("mfi"); 3430 if (devclass == NULL) 3431 return (ENOENT); 3432 3433 error = copyin(arg, &l_aen, sizeof(l_aen)); 3434 if (error) 3435 return (error); 3436 adapter = l_aen.laen_adapter_no; 3437 sc = devclass_get_softc(devclass, adapter); 3438 if (sc == NULL) 3439 return (ENOENT); 3440 return (mfi_linux_ioctl_int(sc->mfi_cdev, 3441 cmd, arg, flag, td)); 3442 break; 3443 } 3444 #ifdef COMPAT_FREEBSD32 3445 case MFIIO_PASSTHRU32: 3446 if (!SV_CURPROC_FLAG(SV_ILP32)) { 3447 error = ENOTTY; 3448 break; 3449 } 3450 iop_swab.ioc_frame = iop32->ioc_frame; 3451 iop_swab.buf_size = iop32->buf_size; 3452 iop_swab.buf = PTRIN(iop32->buf); 3453 iop = &iop_swab; 3454 /* FALLTHROUGH */ 3455 #endif 3456 case MFIIO_PASSTHRU: 3457 error = mfi_user_command(sc, iop); 3458 #ifdef COMPAT_FREEBSD32 3459 if (cmd == MFIIO_PASSTHRU32) 3460 iop32->ioc_frame = iop_swab.ioc_frame; 3461 #endif 3462 break; 3463 default: 3464 device_printf(sc->mfi_dev, "IOCTL 0x%lx not handled\n", cmd); 3465 error = ENOTTY; 3466 break; 3467 } 3468 3469 return (error); 3470 } 3471 3472 static int 3473 mfi_linux_ioctl_int(struct cdev *dev, u_long cmd, caddr_t arg, int flag, struct thread *td) 3474 { 3475 struct mfi_softc *sc; 3476 struct mfi_linux_ioc_packet l_ioc; 3477 struct mfi_linux_ioc_aen l_aen; 3478 struct mfi_command *cm = NULL; 3479 struct mfi_aen *mfi_aen_entry; 3480 union mfi_sense_ptr sense_ptr; 3481 uint32_t context = 0; 3482 uint8_t *data = NULL, *temp; 3483 int i; 3484 int error, locked; 3485 3486 sc = dev->si_drv1; 3487 error = 0; 3488 switch (cmd) { 3489 case MFI_LINUX_CMD_2: /* Firmware Linux ioctl shim */ 3490 error = copyin(arg, &l_ioc, sizeof(l_ioc)); 3491 if (error != 0) 3492 return (error); 3493 3494 if (l_ioc.lioc_sge_count > MAX_LINUX_IOCTL_SGE) { 3495 return (EINVAL); 3496 } 3497 3498 mtx_lock(&sc->mfi_io_lock); 3499 if ((cm = mfi_dequeue_free(sc)) == NULL) { 3500 mtx_unlock(&sc->mfi_io_lock); 3501 return (EBUSY); 3502 } 3503 mtx_unlock(&sc->mfi_io_lock); 3504 locked = 0; 3505 3506 /* 3507 * save off original context since copying from user 3508 * will clobber some data 3509 */ 3510 context = cm->cm_frame->header.context; 3511 3512 bcopy(l_ioc.lioc_frame.raw, cm->cm_frame, 3513 2 * MFI_DCMD_FRAME_SIZE); /* this isn't quite right */ 3514 cm->cm_total_frame_size = (sizeof(union mfi_sgl) 3515 * l_ioc.lioc_sge_count) + l_ioc.lioc_sgl_off; 3516 cm->cm_frame->header.scsi_status = 0; 3517 cm->cm_frame->header.pad0 = 0; 3518 if (l_ioc.lioc_sge_count) 3519 cm->cm_sg = 3520 (union mfi_sgl *)&cm->cm_frame->bytes[l_ioc.lioc_sgl_off]; 3521 cm->cm_flags = 0; 3522 if (cm->cm_frame->header.flags & MFI_FRAME_DATAIN) 3523 cm->cm_flags |= MFI_CMD_DATAIN; 3524 if (cm->cm_frame->header.flags & MFI_FRAME_DATAOUT) 3525 cm->cm_flags |= MFI_CMD_DATAOUT; 3526 cm->cm_len = cm->cm_frame->header.data_len; 3527 if (cm->cm_len && 3528 (cm->cm_flags & (MFI_CMD_DATAIN | MFI_CMD_DATAOUT))) { 3529 cm->cm_data = data = malloc(cm->cm_len, M_MFIBUF, 3530 M_WAITOK | M_ZERO); 3531 } else { 3532 cm->cm_data = 0; 3533 } 3534 3535 /* restore header context */ 3536 cm->cm_frame->header.context = context; 3537 3538 temp = data; 3539 if (cm->cm_flags & MFI_CMD_DATAOUT) { 3540 for (i = 0; i < l_ioc.lioc_sge_count; i++) { 3541 error = copyin(PTRIN(l_ioc.lioc_sgl[i].iov_base), 3542 temp, 3543 l_ioc.lioc_sgl[i].iov_len); 3544 if (error != 0) { 3545 device_printf(sc->mfi_dev, 3546 "Copy in failed\n"); 3547 goto out; 3548 } 3549 temp = &temp[l_ioc.lioc_sgl[i].iov_len]; 3550 } 3551 } 3552 3553 if (cm->cm_frame->header.cmd == MFI_CMD_DCMD) 3554 locked = mfi_config_lock(sc, cm->cm_frame->dcmd.opcode); 3555 3556 if (cm->cm_frame->header.cmd == MFI_CMD_PD_SCSI_IO) { 3557 cm->cm_frame->pass.sense_addr_lo = 3558 (uint32_t)cm->cm_sense_busaddr; 3559 cm->cm_frame->pass.sense_addr_hi = 3560 (uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32); 3561 } 3562 3563 mtx_lock(&sc->mfi_io_lock); 3564 error = mfi_check_command_pre(sc, cm); 3565 if (error) { 3566 mtx_unlock(&sc->mfi_io_lock); 3567 goto out; 3568 } 3569 3570 if ((error = mfi_wait_command(sc, cm)) != 0) { 3571 device_printf(sc->mfi_dev, 3572 "Controller polled failed\n"); 3573 mtx_unlock(&sc->mfi_io_lock); 3574 goto out; 3575 } 3576 3577 mfi_check_command_post(sc, cm); 3578 mtx_unlock(&sc->mfi_io_lock); 3579 3580 temp = data; 3581 if (cm->cm_flags & MFI_CMD_DATAIN) { 3582 for (i = 0; i < l_ioc.lioc_sge_count; i++) { 3583 error = copyout(temp, 3584 PTRIN(l_ioc.lioc_sgl[i].iov_base), 3585 l_ioc.lioc_sgl[i].iov_len); 3586 if (error != 0) { 3587 device_printf(sc->mfi_dev, 3588 "Copy out failed\n"); 3589 goto out; 3590 } 3591 temp = &temp[l_ioc.lioc_sgl[i].iov_len]; 3592 } 3593 } 3594 3595 if (l_ioc.lioc_sense_len) { 3596 /* get user-space sense ptr then copy out sense */ 3597 bcopy(&((struct mfi_linux_ioc_packet*)arg) 3598 ->lioc_frame.raw[l_ioc.lioc_sense_off], 3599 &sense_ptr.sense_ptr_data[0], 3600 sizeof(sense_ptr.sense_ptr_data)); 3601 #ifdef __amd64__ 3602 /* 3603 * only 32bit Linux support so zero out any 3604 * address over 32bit 3605 */ 3606 sense_ptr.addr.high = 0; 3607 #endif 3608 error = copyout(cm->cm_sense, sense_ptr.user_space, 3609 l_ioc.lioc_sense_len); 3610 if (error != 0) { 3611 device_printf(sc->mfi_dev, 3612 "Copy out failed\n"); 3613 goto out; 3614 } 3615 } 3616 3617 error = copyout(&cm->cm_frame->header.cmd_status, 3618 &((struct mfi_linux_ioc_packet*)arg) 3619 ->lioc_frame.hdr.cmd_status, 3620 1); 3621 if (error != 0) { 3622 device_printf(sc->mfi_dev, 3623 "Copy out failed\n"); 3624 goto out; 3625 } 3626 3627 out: 3628 mfi_config_unlock(sc, locked); 3629 if (data) 3630 free(data, M_MFIBUF); 3631 if (cm) { 3632 mtx_lock(&sc->mfi_io_lock); 3633 mfi_release_command(cm); 3634 mtx_unlock(&sc->mfi_io_lock); 3635 } 3636 3637 return (error); 3638 case MFI_LINUX_SET_AEN_2: /* AEN Linux ioctl shim */ 3639 error = copyin(arg, &l_aen, sizeof(l_aen)); 3640 if (error != 0) 3641 return (error); 3642 printf("AEN IMPLEMENTED for pid %d\n", curproc->p_pid); 3643 mfi_aen_entry = malloc(sizeof(struct mfi_aen), M_MFIBUF, 3644 M_WAITOK); 3645 mtx_lock(&sc->mfi_io_lock); 3646 if (mfi_aen_entry != NULL) { 3647 mfi_aen_entry->p = curproc; 3648 TAILQ_INSERT_TAIL(&sc->mfi_aen_pids, mfi_aen_entry, 3649 aen_link); 3650 } 3651 error = mfi_aen_register(sc, l_aen.laen_seq_num, 3652 l_aen.laen_class_locale); 3653 3654 if (error != 0) { 3655 TAILQ_REMOVE(&sc->mfi_aen_pids, mfi_aen_entry, 3656 aen_link); 3657 free(mfi_aen_entry, M_MFIBUF); 3658 } 3659 mtx_unlock(&sc->mfi_io_lock); 3660 3661 return (error); 3662 default: 3663 device_printf(sc->mfi_dev, "IOCTL 0x%lx not handled\n", cmd); 3664 error = ENOENT; 3665 break; 3666 } 3667 3668 return (error); 3669 } 3670 3671 static int 3672 mfi_poll(struct cdev *dev, int poll_events, struct thread *td) 3673 { 3674 struct mfi_softc *sc; 3675 int revents = 0; 3676 3677 sc = dev->si_drv1; 3678 3679 if (poll_events & (POLLIN | POLLRDNORM)) { 3680 if (sc->mfi_aen_triggered != 0) { 3681 revents |= poll_events & (POLLIN | POLLRDNORM); 3682 sc->mfi_aen_triggered = 0; 3683 } 3684 if (sc->mfi_aen_triggered == 0 && sc->mfi_aen_cm == NULL) { 3685 revents |= POLLERR; 3686 } 3687 } 3688 3689 if (revents == 0) { 3690 if (poll_events & (POLLIN | POLLRDNORM)) { 3691 sc->mfi_poll_waiting = 1; 3692 selrecord(td, &sc->mfi_select); 3693 } 3694 } 3695 3696 return revents; 3697 } 3698 3699 static void 3700 mfi_dump_all(void) 3701 { 3702 struct mfi_softc *sc; 3703 struct mfi_command *cm; 3704 devclass_t dc; 3705 time_t deadline; 3706 int timedout; 3707 int i; 3708 3709 dc = devclass_find("mfi"); 3710 if (dc == NULL) { 3711 printf("No mfi dev class\n"); 3712 return; 3713 } 3714 3715 for (i = 0; ; i++) { 3716 sc = devclass_get_softc(dc, i); 3717 if (sc == NULL) 3718 break; 3719 device_printf(sc->mfi_dev, "Dumping\n\n"); 3720 timedout = 0; 3721 deadline = time_uptime - mfi_cmd_timeout; 3722 mtx_lock(&sc->mfi_io_lock); 3723 TAILQ_FOREACH(cm, &sc->mfi_busy, cm_link) { 3724 if (cm->cm_timestamp <= deadline) { 3725 device_printf(sc->mfi_dev, 3726 "COMMAND %p TIMEOUT AFTER %d SECONDS\n", 3727 cm, (int)(time_uptime - cm->cm_timestamp)); 3728 MFI_PRINT_CMD(cm); 3729 timedout++; 3730 } 3731 } 3732 3733 #if 0 3734 if (timedout) 3735 MFI_DUMP_CMDS(sc); 3736 #endif 3737 3738 mtx_unlock(&sc->mfi_io_lock); 3739 } 3740 3741 return; 3742 } 3743 3744 static void 3745 mfi_timeout(void *data) 3746 { 3747 struct mfi_softc *sc = (struct mfi_softc *)data; 3748 struct mfi_command *cm, *tmp; 3749 time_t deadline; 3750 int timedout = 0; 3751 3752 deadline = time_uptime - mfi_cmd_timeout; 3753 if (sc->adpreset == 0) { 3754 if (!mfi_tbolt_reset(sc)) { 3755 callout_reset(&sc->mfi_watchdog_callout, 3756 mfi_cmd_timeout * hz, mfi_timeout, sc); 3757 return; 3758 } 3759 } 3760 mtx_lock(&sc->mfi_io_lock); 3761 TAILQ_FOREACH_SAFE(cm, &sc->mfi_busy, cm_link, tmp) { 3762 if (sc->mfi_aen_cm == cm || sc->mfi_map_sync_cm == cm) 3763 continue; 3764 if (cm->cm_timestamp <= deadline) { 3765 if (sc->adpreset != 0 && sc->issuepend_done == 0) { 3766 cm->cm_timestamp = time_uptime; 3767 } else { 3768 device_printf(sc->mfi_dev, 3769 "COMMAND %p TIMEOUT AFTER %d SECONDS\n", 3770 cm, (int)(time_uptime - cm->cm_timestamp) 3771 ); 3772 MFI_PRINT_CMD(cm); 3773 MFI_VALIDATE_CMD(sc, cm); 3774 /* 3775 * While commands can get stuck forever we do 3776 * not fail them as there is no way to tell if 3777 * the controller has actually processed them 3778 * or not. 3779 * 3780 * In addition its very likely that force 3781 * failing a command here would cause a panic 3782 * e.g. in UFS. 3783 */ 3784 timedout++; 3785 } 3786 } 3787 } 3788 3789 #if 0 3790 if (timedout) 3791 MFI_DUMP_CMDS(sc); 3792 #endif 3793 3794 mtx_unlock(&sc->mfi_io_lock); 3795 3796 callout_reset(&sc->mfi_watchdog_callout, mfi_cmd_timeout * hz, 3797 mfi_timeout, sc); 3798 3799 if (0) 3800 mfi_dump_all(); 3801 return; 3802 } 3803