1 /* 2 * Copyright (c) 2015, AVAGO Tech. All rights reserved. Author: Marian Choy 3 * Copyright (c) 2014, LSI Corp. All rights reserved. Author: Marian Choy 4 * Support: freebsdraid@avagotech.com 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are 8 * met: 9 * 10 * 1. Redistributions of source code must retain the above copyright notice, 11 * this list of conditions and the following disclaimer. 2. Redistributions 12 * in binary form must reproduce the above copyright notice, this list of 13 * conditions and the following disclaimer in the documentation and/or other 14 * materials provided with the distribution. 3. Neither the name of the 15 * <ORGANIZATION> nor the names of its contributors may be used to endorse or 16 * promote products derived from this software without specific prior written 17 * permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 * 31 * The views and conclusions contained in the software and documentation are 32 * those of the authors and should not be interpreted as representing 33 * official policies,either expressed or implied, of the FreeBSD Project. 34 * 35 * Send feedback to: <megaraidfbsd@avagotech.com> Mail to: AVAGO TECHNOLOGIES 1621 36 * Barber Lane, Milpitas, CA 95035 ATTN: MegaRaid FreeBSD 37 * 38 */ 39 40 #include <sys/cdefs.h> 41 __FBSDID("$FreeBSD$"); 42 43 #include <dev/mrsas/mrsas.h> 44 #include <dev/mrsas/mrsas_ioctl.h> 45 46 #include <cam/cam.h> 47 #include <cam/cam_ccb.h> 48 49 #include <sys/sysctl.h> 50 #include <sys/types.h> 51 #include <sys/sysent.h> 52 #include <sys/kthread.h> 53 #include <sys/taskqueue.h> 54 #include <sys/smp.h> 55 56 57 /* 58 * Function prototypes 59 */ 60 static d_open_t mrsas_open; 61 static d_close_t mrsas_close; 62 static d_read_t mrsas_read; 63 static d_write_t mrsas_write; 64 static d_ioctl_t mrsas_ioctl; 65 static d_poll_t mrsas_poll; 66 67 static void mrsas_ich_startup(void *arg); 68 static struct mrsas_mgmt_info mrsas_mgmt_info; 69 static struct mrsas_ident *mrsas_find_ident(device_t); 70 static int mrsas_setup_msix(struct mrsas_softc *sc); 71 static int mrsas_allocate_msix(struct mrsas_softc *sc); 72 static void mrsas_shutdown_ctlr(struct mrsas_softc *sc, u_int32_t opcode); 73 static void mrsas_flush_cache(struct mrsas_softc *sc); 74 static void mrsas_reset_reply_desc(struct mrsas_softc *sc); 75 static void mrsas_ocr_thread(void *arg); 76 static int mrsas_get_map_info(struct mrsas_softc *sc); 77 static int mrsas_get_ld_map_info(struct mrsas_softc *sc); 78 static int mrsas_sync_map_info(struct mrsas_softc *sc); 79 static int mrsas_get_pd_list(struct mrsas_softc *sc); 80 static int mrsas_get_ld_list(struct mrsas_softc *sc); 81 static int mrsas_setup_irq(struct mrsas_softc *sc); 82 static int mrsas_alloc_mem(struct mrsas_softc *sc); 83 static int mrsas_init_fw(struct mrsas_softc *sc); 84 static int mrsas_setup_raidmap(struct mrsas_softc *sc); 85 static void megasas_setup_jbod_map(struct mrsas_softc *sc); 86 static int megasas_sync_pd_seq_num(struct mrsas_softc *sc, boolean_t pend); 87 static int mrsas_clear_intr(struct mrsas_softc *sc); 88 static int mrsas_get_ctrl_info(struct mrsas_softc *sc); 89 static void mrsas_update_ext_vd_details(struct mrsas_softc *sc); 90 static int 91 mrsas_issue_blocked_abort_cmd(struct mrsas_softc *sc, 92 struct mrsas_mfi_cmd *cmd_to_abort); 93 static struct mrsas_softc * 94 mrsas_get_softc_instance(struct cdev *dev, 95 u_long cmd, caddr_t arg); 96 u_int32_t mrsas_read_reg(struct mrsas_softc *sc, int offset); 97 u_int8_t 98 mrsas_build_mptmfi_passthru(struct mrsas_softc *sc, 99 struct mrsas_mfi_cmd *mfi_cmd); 100 void mrsas_complete_outstanding_ioctls(struct mrsas_softc *sc); 101 int mrsas_transition_to_ready(struct mrsas_softc *sc, int ocr); 102 int mrsas_init_adapter(struct mrsas_softc *sc); 103 int mrsas_alloc_mpt_cmds(struct mrsas_softc *sc); 104 int mrsas_alloc_ioc_cmd(struct mrsas_softc *sc); 105 int mrsas_alloc_ctlr_info_cmd(struct mrsas_softc *sc); 106 int mrsas_ioc_init(struct mrsas_softc *sc); 107 int mrsas_bus_scan(struct mrsas_softc *sc); 108 int mrsas_issue_dcmd(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd); 109 int mrsas_issue_polled(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd); 110 int mrsas_reset_ctrl(struct mrsas_softc *sc, u_int8_t reset_reason); 111 int mrsas_wait_for_outstanding(struct mrsas_softc *sc, u_int8_t check_reason); 112 int mrsas_complete_cmd(struct mrsas_softc *sc, u_int32_t MSIxIndex); 113 int mrsas_reset_targets(struct mrsas_softc *sc); 114 int 115 mrsas_issue_blocked_cmd(struct mrsas_softc *sc, 116 struct mrsas_mfi_cmd *cmd); 117 int 118 mrsas_alloc_tmp_dcmd(struct mrsas_softc *sc, struct mrsas_tmp_dcmd *tcmd, 119 int size); 120 void mrsas_release_mfi_cmd(struct mrsas_mfi_cmd *cmd); 121 void mrsas_wakeup(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd); 122 void mrsas_complete_aen(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd); 123 void mrsas_complete_abort(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd); 124 void mrsas_disable_intr(struct mrsas_softc *sc); 125 void mrsas_enable_intr(struct mrsas_softc *sc); 126 void mrsas_free_ioc_cmd(struct mrsas_softc *sc); 127 void mrsas_free_mem(struct mrsas_softc *sc); 128 void mrsas_free_tmp_dcmd(struct mrsas_tmp_dcmd *tmp); 129 void mrsas_isr(void *arg); 130 void mrsas_teardown_intr(struct mrsas_softc *sc); 131 void mrsas_addr_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error); 132 void mrsas_kill_hba(struct mrsas_softc *sc); 133 void mrsas_aen_handler(struct mrsas_softc *sc); 134 void 135 mrsas_write_reg(struct mrsas_softc *sc, int offset, 136 u_int32_t value); 137 void 138 mrsas_fire_cmd(struct mrsas_softc *sc, u_int32_t req_desc_lo, 139 u_int32_t req_desc_hi); 140 void mrsas_free_ctlr_info_cmd(struct mrsas_softc *sc); 141 void 142 mrsas_complete_mptmfi_passthru(struct mrsas_softc *sc, 143 struct mrsas_mfi_cmd *cmd, u_int8_t status); 144 void 145 mrsas_map_mpt_cmd_status(struct mrsas_mpt_cmd *cmd, u_int8_t status, 146 u_int8_t extStatus); 147 struct mrsas_mfi_cmd *mrsas_get_mfi_cmd(struct mrsas_softc *sc); 148 149 MRSAS_REQUEST_DESCRIPTOR_UNION *mrsas_build_mpt_cmd 150 (struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd); 151 152 extern int mrsas_cam_attach(struct mrsas_softc *sc); 153 extern void mrsas_cam_detach(struct mrsas_softc *sc); 154 extern void mrsas_cmd_done(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd); 155 extern void mrsas_free_frame(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd); 156 extern int mrsas_alloc_mfi_cmds(struct mrsas_softc *sc); 157 extern struct mrsas_mpt_cmd *mrsas_get_mpt_cmd(struct mrsas_softc *sc); 158 extern int mrsas_passthru(struct mrsas_softc *sc, void *arg, u_long ioctlCmd); 159 extern uint8_t MR_ValidateMapInfo(struct mrsas_softc *sc); 160 extern u_int16_t MR_GetLDTgtId(u_int32_t ld, MR_DRV_RAID_MAP_ALL * map); 161 extern MR_LD_RAID *MR_LdRaidGet(u_int32_t ld, MR_DRV_RAID_MAP_ALL * map); 162 extern void mrsas_xpt_freeze(struct mrsas_softc *sc); 163 extern void mrsas_xpt_release(struct mrsas_softc *sc); 164 extern MRSAS_REQUEST_DESCRIPTOR_UNION * 165 mrsas_get_request_desc(struct mrsas_softc *sc, 166 u_int16_t index); 167 extern int mrsas_bus_scan_sim(struct mrsas_softc *sc, struct cam_sim *sim); 168 static int mrsas_alloc_evt_log_info_cmd(struct mrsas_softc *sc); 169 static void mrsas_free_evt_log_info_cmd(struct mrsas_softc *sc); 170 171 SYSCTL_NODE(_hw, OID_AUTO, mrsas, CTLFLAG_RD, 0, "MRSAS Driver Parameters"); 172 173 /* 174 * PCI device struct and table 175 * 176 */ 177 typedef struct mrsas_ident { 178 uint16_t vendor; 179 uint16_t device; 180 uint16_t subvendor; 181 uint16_t subdevice; 182 const char *desc; 183 } MRSAS_CTLR_ID; 184 185 MRSAS_CTLR_ID device_table[] = { 186 {0x1000, MRSAS_TBOLT, 0xffff, 0xffff, "AVAGO Thunderbolt SAS Controller"}, 187 {0x1000, MRSAS_INVADER, 0xffff, 0xffff, "AVAGO Invader SAS Controller"}, 188 {0x1000, MRSAS_FURY, 0xffff, 0xffff, "AVAGO Fury SAS Controller"}, 189 {0x1000, MRSAS_INTRUDER, 0xffff, 0xffff, "AVAGO Intruder SAS Controller"}, 190 {0x1000, MRSAS_INTRUDER_24, 0xffff, 0xffff, "AVAGO Intruder_24 SAS Controller"}, 191 {0x1000, MRSAS_CUTLASS_52, 0xffff, 0xffff, "AVAGO Cutlass_52 SAS Controller"}, 192 {0x1000, MRSAS_CUTLASS_53, 0xffff, 0xffff, "AVAGO Cutlass_53 SAS Controller"}, 193 {0, 0, 0, 0, NULL} 194 }; 195 196 /* 197 * Character device entry points 198 * 199 */ 200 static struct cdevsw mrsas_cdevsw = { 201 .d_version = D_VERSION, 202 .d_open = mrsas_open, 203 .d_close = mrsas_close, 204 .d_read = mrsas_read, 205 .d_write = mrsas_write, 206 .d_ioctl = mrsas_ioctl, 207 .d_poll = mrsas_poll, 208 .d_name = "mrsas", 209 }; 210 211 MALLOC_DEFINE(M_MRSAS, "mrsasbuf", "Buffers for the MRSAS driver"); 212 213 /* 214 * In the cdevsw routines, we find our softc by using the si_drv1 member of 215 * struct cdev. We set this variable to point to our softc in our attach 216 * routine when we create the /dev entry. 217 */ 218 int 219 mrsas_open(struct cdev *dev, int oflags, int devtype, struct thread *td) 220 { 221 struct mrsas_softc *sc; 222 223 sc = dev->si_drv1; 224 return (0); 225 } 226 227 int 228 mrsas_close(struct cdev *dev, int fflag, int devtype, struct thread *td) 229 { 230 struct mrsas_softc *sc; 231 232 sc = dev->si_drv1; 233 return (0); 234 } 235 236 int 237 mrsas_read(struct cdev *dev, struct uio *uio, int ioflag) 238 { 239 struct mrsas_softc *sc; 240 241 sc = dev->si_drv1; 242 return (0); 243 } 244 int 245 mrsas_write(struct cdev *dev, struct uio *uio, int ioflag) 246 { 247 struct mrsas_softc *sc; 248 249 sc = dev->si_drv1; 250 return (0); 251 } 252 253 /* 254 * Register Read/Write Functions 255 * 256 */ 257 void 258 mrsas_write_reg(struct mrsas_softc *sc, int offset, 259 u_int32_t value) 260 { 261 bus_space_tag_t bus_tag = sc->bus_tag; 262 bus_space_handle_t bus_handle = sc->bus_handle; 263 264 bus_space_write_4(bus_tag, bus_handle, offset, value); 265 } 266 267 u_int32_t 268 mrsas_read_reg(struct mrsas_softc *sc, int offset) 269 { 270 bus_space_tag_t bus_tag = sc->bus_tag; 271 bus_space_handle_t bus_handle = sc->bus_handle; 272 273 return ((u_int32_t)bus_space_read_4(bus_tag, bus_handle, offset)); 274 } 275 276 277 /* 278 * Interrupt Disable/Enable/Clear Functions 279 * 280 */ 281 void 282 mrsas_disable_intr(struct mrsas_softc *sc) 283 { 284 u_int32_t mask = 0xFFFFFFFF; 285 u_int32_t status; 286 287 sc->mask_interrupts = 1; 288 mrsas_write_reg(sc, offsetof(mrsas_reg_set, outbound_intr_mask), mask); 289 /* Dummy read to force pci flush */ 290 status = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_intr_mask)); 291 } 292 293 void 294 mrsas_enable_intr(struct mrsas_softc *sc) 295 { 296 u_int32_t mask = MFI_FUSION_ENABLE_INTERRUPT_MASK; 297 u_int32_t status; 298 299 sc->mask_interrupts = 0; 300 mrsas_write_reg(sc, offsetof(mrsas_reg_set, outbound_intr_status), ~0); 301 status = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_intr_status)); 302 303 mrsas_write_reg(sc, offsetof(mrsas_reg_set, outbound_intr_mask), ~mask); 304 status = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_intr_mask)); 305 } 306 307 static int 308 mrsas_clear_intr(struct mrsas_softc *sc) 309 { 310 u_int32_t status; 311 312 /* Read received interrupt */ 313 status = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_intr_status)); 314 315 /* Not our interrupt, so just return */ 316 if (!(status & MFI_FUSION_ENABLE_INTERRUPT_MASK)) 317 return (0); 318 319 /* We got a reply interrupt */ 320 return (1); 321 } 322 323 /* 324 * PCI Support Functions 325 * 326 */ 327 static struct mrsas_ident * 328 mrsas_find_ident(device_t dev) 329 { 330 struct mrsas_ident *pci_device; 331 332 for (pci_device = device_table; pci_device->vendor != 0; pci_device++) { 333 if ((pci_device->vendor == pci_get_vendor(dev)) && 334 (pci_device->device == pci_get_device(dev)) && 335 ((pci_device->subvendor == pci_get_subvendor(dev)) || 336 (pci_device->subvendor == 0xffff)) && 337 ((pci_device->subdevice == pci_get_subdevice(dev)) || 338 (pci_device->subdevice == 0xffff))) 339 return (pci_device); 340 } 341 return (NULL); 342 } 343 344 static int 345 mrsas_probe(device_t dev) 346 { 347 static u_int8_t first_ctrl = 1; 348 struct mrsas_ident *id; 349 350 if ((id = mrsas_find_ident(dev)) != NULL) { 351 if (first_ctrl) { 352 printf("AVAGO MegaRAID SAS FreeBSD mrsas driver version: %s\n", 353 MRSAS_VERSION); 354 first_ctrl = 0; 355 } 356 device_set_desc(dev, id->desc); 357 /* between BUS_PROBE_DEFAULT and BUS_PROBE_LOW_PRIORITY */ 358 return (-30); 359 } 360 return (ENXIO); 361 } 362 363 /* 364 * mrsas_setup_sysctl: setup sysctl values for mrsas 365 * input: Adapter instance soft state 366 * 367 * Setup sysctl entries for mrsas driver. 368 */ 369 static void 370 mrsas_setup_sysctl(struct mrsas_softc *sc) 371 { 372 struct sysctl_ctx_list *sysctl_ctx = NULL; 373 struct sysctl_oid *sysctl_tree = NULL; 374 char tmpstr[80], tmpstr2[80]; 375 376 /* 377 * Setup the sysctl variable so the user can change the debug level 378 * on the fly. 379 */ 380 snprintf(tmpstr, sizeof(tmpstr), "MRSAS controller %d", 381 device_get_unit(sc->mrsas_dev)); 382 snprintf(tmpstr2, sizeof(tmpstr2), "%d", device_get_unit(sc->mrsas_dev)); 383 384 sysctl_ctx = device_get_sysctl_ctx(sc->mrsas_dev); 385 if (sysctl_ctx != NULL) 386 sysctl_tree = device_get_sysctl_tree(sc->mrsas_dev); 387 388 if (sysctl_tree == NULL) { 389 sysctl_ctx_init(&sc->sysctl_ctx); 390 sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx, 391 SYSCTL_STATIC_CHILDREN(_hw_mrsas), OID_AUTO, tmpstr2, 392 CTLFLAG_RD, 0, tmpstr); 393 if (sc->sysctl_tree == NULL) 394 return; 395 sysctl_ctx = &sc->sysctl_ctx; 396 sysctl_tree = sc->sysctl_tree; 397 } 398 SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), 399 OID_AUTO, "disable_ocr", CTLFLAG_RW, &sc->disableOnlineCtrlReset, 0, 400 "Disable the use of OCR"); 401 402 SYSCTL_ADD_STRING(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), 403 OID_AUTO, "driver_version", CTLFLAG_RD, MRSAS_VERSION, 404 strlen(MRSAS_VERSION), "driver version"); 405 406 SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), 407 OID_AUTO, "reset_count", CTLFLAG_RD, 408 &sc->reset_count, 0, "number of ocr from start of the day"); 409 410 SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), 411 OID_AUTO, "fw_outstanding", CTLFLAG_RD, 412 &sc->fw_outstanding.val_rdonly, 0, "FW outstanding commands"); 413 414 SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), 415 OID_AUTO, "io_cmds_highwater", CTLFLAG_RD, 416 &sc->io_cmds_highwater, 0, "Max FW outstanding commands"); 417 418 SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), 419 OID_AUTO, "mrsas_debug", CTLFLAG_RW, &sc->mrsas_debug, 0, 420 "Driver debug level"); 421 422 SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), 423 OID_AUTO, "mrsas_io_timeout", CTLFLAG_RW, &sc->mrsas_io_timeout, 424 0, "Driver IO timeout value in mili-second."); 425 426 SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), 427 OID_AUTO, "mrsas_fw_fault_check_delay", CTLFLAG_RW, 428 &sc->mrsas_fw_fault_check_delay, 429 0, "FW fault check thread delay in seconds. <default is 1 sec>"); 430 431 SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), 432 OID_AUTO, "reset_in_progress", CTLFLAG_RD, 433 &sc->reset_in_progress, 0, "ocr in progress status"); 434 435 SYSCTL_ADD_UINT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), 436 OID_AUTO, "block_sync_cache", CTLFLAG_RW, 437 &sc->block_sync_cache, 0, 438 "Block SYNC CACHE at driver. <default: 0, send it to FW>"); 439 440 } 441 442 /* 443 * mrsas_get_tunables: get tunable parameters. 444 * input: Adapter instance soft state 445 * 446 * Get tunable parameters. This will help to debug driver at boot time. 447 */ 448 static void 449 mrsas_get_tunables(struct mrsas_softc *sc) 450 { 451 char tmpstr[80]; 452 453 /* XXX default to some debugging for now */ 454 sc->mrsas_debug = MRSAS_FAULT; 455 sc->mrsas_io_timeout = MRSAS_IO_TIMEOUT; 456 sc->mrsas_fw_fault_check_delay = 1; 457 sc->reset_count = 0; 458 sc->reset_in_progress = 0; 459 sc->block_sync_cache = 0; 460 461 /* 462 * Grab the global variables. 463 */ 464 TUNABLE_INT_FETCH("hw.mrsas.debug_level", &sc->mrsas_debug); 465 466 /* 467 * Grab the global variables. 468 */ 469 TUNABLE_INT_FETCH("hw.mrsas.lb_pending_cmds", &sc->lb_pending_cmds); 470 471 /* Grab the unit-instance variables */ 472 snprintf(tmpstr, sizeof(tmpstr), "dev.mrsas.%d.debug_level", 473 device_get_unit(sc->mrsas_dev)); 474 TUNABLE_INT_FETCH(tmpstr, &sc->mrsas_debug); 475 } 476 477 /* 478 * mrsas_alloc_evt_log_info cmd: Allocates memory to get event log information. 479 * Used to get sequence number at driver load time. 480 * input: Adapter soft state 481 * 482 * Allocates DMAable memory for the event log info internal command. 483 */ 484 int 485 mrsas_alloc_evt_log_info_cmd(struct mrsas_softc *sc) 486 { 487 int el_info_size; 488 489 /* Allocate get event log info command */ 490 el_info_size = sizeof(struct mrsas_evt_log_info); 491 if (bus_dma_tag_create(sc->mrsas_parent_tag, 492 1, 0, 493 BUS_SPACE_MAXADDR_32BIT, 494 BUS_SPACE_MAXADDR, 495 NULL, NULL, 496 el_info_size, 497 1, 498 el_info_size, 499 BUS_DMA_ALLOCNOW, 500 NULL, NULL, 501 &sc->el_info_tag)) { 502 device_printf(sc->mrsas_dev, "Cannot allocate event log info tag\n"); 503 return (ENOMEM); 504 } 505 if (bus_dmamem_alloc(sc->el_info_tag, (void **)&sc->el_info_mem, 506 BUS_DMA_NOWAIT, &sc->el_info_dmamap)) { 507 device_printf(sc->mrsas_dev, "Cannot allocate event log info cmd mem\n"); 508 return (ENOMEM); 509 } 510 if (bus_dmamap_load(sc->el_info_tag, sc->el_info_dmamap, 511 sc->el_info_mem, el_info_size, mrsas_addr_cb, 512 &sc->el_info_phys_addr, BUS_DMA_NOWAIT)) { 513 device_printf(sc->mrsas_dev, "Cannot load event log info cmd mem\n"); 514 return (ENOMEM); 515 } 516 memset(sc->el_info_mem, 0, el_info_size); 517 return (0); 518 } 519 520 /* 521 * mrsas_free_evt_info_cmd: Free memory for Event log info command 522 * input: Adapter soft state 523 * 524 * Deallocates memory for the event log info internal command. 525 */ 526 void 527 mrsas_free_evt_log_info_cmd(struct mrsas_softc *sc) 528 { 529 if (sc->el_info_phys_addr) 530 bus_dmamap_unload(sc->el_info_tag, sc->el_info_dmamap); 531 if (sc->el_info_mem != NULL) 532 bus_dmamem_free(sc->el_info_tag, sc->el_info_mem, sc->el_info_dmamap); 533 if (sc->el_info_tag != NULL) 534 bus_dma_tag_destroy(sc->el_info_tag); 535 } 536 537 /* 538 * mrsas_get_seq_num: Get latest event sequence number 539 * @sc: Adapter soft state 540 * @eli: Firmware event log sequence number information. 541 * 542 * Firmware maintains a log of all events in a non-volatile area. 543 * Driver get the sequence number using DCMD 544 * "MR_DCMD_CTRL_EVENT_GET_INFO" at driver load time. 545 */ 546 547 static int 548 mrsas_get_seq_num(struct mrsas_softc *sc, 549 struct mrsas_evt_log_info *eli) 550 { 551 struct mrsas_mfi_cmd *cmd; 552 struct mrsas_dcmd_frame *dcmd; 553 u_int8_t do_ocr = 1, retcode = 0; 554 555 cmd = mrsas_get_mfi_cmd(sc); 556 557 if (!cmd) { 558 device_printf(sc->mrsas_dev, "Failed to get a free cmd\n"); 559 return -ENOMEM; 560 } 561 dcmd = &cmd->frame->dcmd; 562 563 if (mrsas_alloc_evt_log_info_cmd(sc) != SUCCESS) { 564 device_printf(sc->mrsas_dev, "Cannot allocate evt log info cmd\n"); 565 mrsas_release_mfi_cmd(cmd); 566 return -ENOMEM; 567 } 568 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 569 570 dcmd->cmd = MFI_CMD_DCMD; 571 dcmd->cmd_status = 0x0; 572 dcmd->sge_count = 1; 573 dcmd->flags = MFI_FRAME_DIR_READ; 574 dcmd->timeout = 0; 575 dcmd->pad_0 = 0; 576 dcmd->data_xfer_len = sizeof(struct mrsas_evt_log_info); 577 dcmd->opcode = MR_DCMD_CTRL_EVENT_GET_INFO; 578 dcmd->sgl.sge32[0].phys_addr = sc->el_info_phys_addr; 579 dcmd->sgl.sge32[0].length = sizeof(struct mrsas_evt_log_info); 580 581 retcode = mrsas_issue_blocked_cmd(sc, cmd); 582 if (retcode == ETIMEDOUT) 583 goto dcmd_timeout; 584 585 do_ocr = 0; 586 /* 587 * Copy the data back into callers buffer 588 */ 589 memcpy(eli, sc->el_info_mem, sizeof(struct mrsas_evt_log_info)); 590 mrsas_free_evt_log_info_cmd(sc); 591 592 dcmd_timeout: 593 if (do_ocr) 594 sc->do_timedout_reset = MFI_DCMD_TIMEOUT_OCR; 595 else 596 mrsas_release_mfi_cmd(cmd); 597 598 return retcode; 599 } 600 601 602 /* 603 * mrsas_register_aen: Register for asynchronous event notification 604 * @sc: Adapter soft state 605 * @seq_num: Starting sequence number 606 * @class_locale: Class of the event 607 * 608 * This function subscribes for events beyond the @seq_num 609 * and type @class_locale. 610 * 611 */ 612 static int 613 mrsas_register_aen(struct mrsas_softc *sc, u_int32_t seq_num, 614 u_int32_t class_locale_word) 615 { 616 int ret_val; 617 struct mrsas_mfi_cmd *cmd; 618 struct mrsas_dcmd_frame *dcmd; 619 union mrsas_evt_class_locale curr_aen; 620 union mrsas_evt_class_locale prev_aen; 621 622 /* 623 * If there an AEN pending already (aen_cmd), check if the 624 * class_locale of that pending AEN is inclusive of the new AEN 625 * request we currently have. If it is, then we don't have to do 626 * anything. In other words, whichever events the current AEN request 627 * is subscribing to, have already been subscribed to. If the old_cmd 628 * is _not_ inclusive, then we have to abort that command, form a 629 * class_locale that is superset of both old and current and re-issue 630 * to the FW 631 */ 632 633 curr_aen.word = class_locale_word; 634 635 if (sc->aen_cmd) { 636 637 prev_aen.word = sc->aen_cmd->frame->dcmd.mbox.w[1]; 638 639 /* 640 * A class whose enum value is smaller is inclusive of all 641 * higher values. If a PROGRESS (= -1) was previously 642 * registered, then a new registration requests for higher 643 * classes need not be sent to FW. They are automatically 644 * included. Locale numbers don't have such hierarchy. They 645 * are bitmap values 646 */ 647 if ((prev_aen.members.class <= curr_aen.members.class) && 648 !((prev_aen.members.locale & curr_aen.members.locale) ^ 649 curr_aen.members.locale)) { 650 /* 651 * Previously issued event registration includes 652 * current request. Nothing to do. 653 */ 654 return 0; 655 } else { 656 curr_aen.members.locale |= prev_aen.members.locale; 657 658 if (prev_aen.members.class < curr_aen.members.class) 659 curr_aen.members.class = prev_aen.members.class; 660 661 sc->aen_cmd->abort_aen = 1; 662 ret_val = mrsas_issue_blocked_abort_cmd(sc, 663 sc->aen_cmd); 664 665 if (ret_val) { 666 printf("mrsas: Failed to abort previous AEN command\n"); 667 return ret_val; 668 } else 669 sc->aen_cmd = NULL; 670 } 671 } 672 cmd = mrsas_get_mfi_cmd(sc); 673 if (!cmd) 674 return ENOMEM; 675 676 dcmd = &cmd->frame->dcmd; 677 678 memset(sc->evt_detail_mem, 0, sizeof(struct mrsas_evt_detail)); 679 680 /* 681 * Prepare DCMD for aen registration 682 */ 683 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 684 685 dcmd->cmd = MFI_CMD_DCMD; 686 dcmd->cmd_status = 0x0; 687 dcmd->sge_count = 1; 688 dcmd->flags = MFI_FRAME_DIR_READ; 689 dcmd->timeout = 0; 690 dcmd->pad_0 = 0; 691 dcmd->data_xfer_len = sizeof(struct mrsas_evt_detail); 692 dcmd->opcode = MR_DCMD_CTRL_EVENT_WAIT; 693 dcmd->mbox.w[0] = seq_num; 694 sc->last_seq_num = seq_num; 695 dcmd->mbox.w[1] = curr_aen.word; 696 dcmd->sgl.sge32[0].phys_addr = (u_int32_t)sc->evt_detail_phys_addr; 697 dcmd->sgl.sge32[0].length = sizeof(struct mrsas_evt_detail); 698 699 if (sc->aen_cmd != NULL) { 700 mrsas_release_mfi_cmd(cmd); 701 return 0; 702 } 703 /* 704 * Store reference to the cmd used to register for AEN. When an 705 * application wants us to register for AEN, we have to abort this 706 * cmd and re-register with a new EVENT LOCALE supplied by that app 707 */ 708 sc->aen_cmd = cmd; 709 710 /* 711 * Issue the aen registration frame 712 */ 713 if (mrsas_issue_dcmd(sc, cmd)) { 714 device_printf(sc->mrsas_dev, "Cannot issue AEN DCMD command.\n"); 715 return (1); 716 } 717 return 0; 718 } 719 720 /* 721 * mrsas_start_aen: Subscribes to AEN during driver load time 722 * @instance: Adapter soft state 723 */ 724 static int 725 mrsas_start_aen(struct mrsas_softc *sc) 726 { 727 struct mrsas_evt_log_info eli; 728 union mrsas_evt_class_locale class_locale; 729 730 731 /* Get the latest sequence number from FW */ 732 733 memset(&eli, 0, sizeof(eli)); 734 735 if (mrsas_get_seq_num(sc, &eli)) 736 return -1; 737 738 /* Register AEN with FW for latest sequence number plus 1 */ 739 class_locale.members.reserved = 0; 740 class_locale.members.locale = MR_EVT_LOCALE_ALL; 741 class_locale.members.class = MR_EVT_CLASS_DEBUG; 742 743 return mrsas_register_aen(sc, eli.newest_seq_num + 1, 744 class_locale.word); 745 746 } 747 748 /* 749 * mrsas_setup_msix: Allocate MSI-x vectors 750 * @sc: adapter soft state 751 */ 752 static int 753 mrsas_setup_msix(struct mrsas_softc *sc) 754 { 755 int i; 756 757 for (i = 0; i < sc->msix_vectors; i++) { 758 sc->irq_context[i].sc = sc; 759 sc->irq_context[i].MSIxIndex = i; 760 sc->irq_id[i] = i + 1; 761 sc->mrsas_irq[i] = bus_alloc_resource_any 762 (sc->mrsas_dev, SYS_RES_IRQ, &sc->irq_id[i] 763 ,RF_ACTIVE); 764 if (sc->mrsas_irq[i] == NULL) { 765 device_printf(sc->mrsas_dev, "Can't allocate MSI-x\n"); 766 goto irq_alloc_failed; 767 } 768 if (bus_setup_intr(sc->mrsas_dev, 769 sc->mrsas_irq[i], 770 INTR_MPSAFE | INTR_TYPE_CAM, 771 NULL, mrsas_isr, &sc->irq_context[i], 772 &sc->intr_handle[i])) { 773 device_printf(sc->mrsas_dev, 774 "Cannot set up MSI-x interrupt handler\n"); 775 goto irq_alloc_failed; 776 } 777 } 778 return SUCCESS; 779 780 irq_alloc_failed: 781 mrsas_teardown_intr(sc); 782 return (FAIL); 783 } 784 785 /* 786 * mrsas_allocate_msix: Setup MSI-x vectors 787 * @sc: adapter soft state 788 */ 789 static int 790 mrsas_allocate_msix(struct mrsas_softc *sc) 791 { 792 if (pci_alloc_msix(sc->mrsas_dev, &sc->msix_vectors) == 0) { 793 device_printf(sc->mrsas_dev, "Using MSI-X with %d number" 794 " of vectors\n", sc->msix_vectors); 795 } else { 796 device_printf(sc->mrsas_dev, "MSI-x setup failed\n"); 797 goto irq_alloc_failed; 798 } 799 return SUCCESS; 800 801 irq_alloc_failed: 802 mrsas_teardown_intr(sc); 803 return (FAIL); 804 } 805 806 /* 807 * mrsas_attach: PCI entry point 808 * input: pointer to device struct 809 * 810 * Performs setup of PCI and registers, initializes mutexes and linked lists, 811 * registers interrupts and CAM, and initializes the adapter/controller to 812 * its proper state. 813 */ 814 static int 815 mrsas_attach(device_t dev) 816 { 817 struct mrsas_softc *sc = device_get_softc(dev); 818 uint32_t cmd, bar, error; 819 820 memset(sc, 0, sizeof(struct mrsas_softc)); 821 822 /* Look up our softc and initialize its fields. */ 823 sc->mrsas_dev = dev; 824 sc->device_id = pci_get_device(dev); 825 826 if ((sc->device_id == MRSAS_INVADER) || 827 (sc->device_id == MRSAS_FURY) || 828 (sc->device_id == MRSAS_INTRUDER) || 829 (sc->device_id == MRSAS_INTRUDER_24) || 830 (sc->device_id == MRSAS_CUTLASS_52) || 831 (sc->device_id == MRSAS_CUTLASS_53)) { 832 sc->mrsas_gen3_ctrl = 1; 833 } 834 835 mrsas_get_tunables(sc); 836 837 /* 838 * Set up PCI and registers 839 */ 840 cmd = pci_read_config(dev, PCIR_COMMAND, 2); 841 if ((cmd & PCIM_CMD_PORTEN) == 0) { 842 return (ENXIO); 843 } 844 /* Force the busmaster enable bit on. */ 845 cmd |= PCIM_CMD_BUSMASTEREN; 846 pci_write_config(dev, PCIR_COMMAND, cmd, 2); 847 848 bar = pci_read_config(dev, MRSAS_PCI_BAR1, 4); 849 850 sc->reg_res_id = MRSAS_PCI_BAR1;/* BAR1 offset */ 851 if ((sc->reg_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 852 &(sc->reg_res_id), RF_ACTIVE)) 853 == NULL) { 854 device_printf(dev, "Cannot allocate PCI registers\n"); 855 goto attach_fail; 856 } 857 sc->bus_tag = rman_get_bustag(sc->reg_res); 858 sc->bus_handle = rman_get_bushandle(sc->reg_res); 859 860 /* Intialize mutexes */ 861 mtx_init(&sc->sim_lock, "mrsas_sim_lock", NULL, MTX_DEF); 862 mtx_init(&sc->pci_lock, "mrsas_pci_lock", NULL, MTX_DEF); 863 mtx_init(&sc->io_lock, "mrsas_io_lock", NULL, MTX_DEF); 864 mtx_init(&sc->aen_lock, "mrsas_aen_lock", NULL, MTX_DEF); 865 mtx_init(&sc->ioctl_lock, "mrsas_ioctl_lock", NULL, MTX_SPIN); 866 mtx_init(&sc->mpt_cmd_pool_lock, "mrsas_mpt_cmd_pool_lock", NULL, MTX_DEF); 867 mtx_init(&sc->mfi_cmd_pool_lock, "mrsas_mfi_cmd_pool_lock", NULL, MTX_DEF); 868 mtx_init(&sc->raidmap_lock, "mrsas_raidmap_lock", NULL, MTX_DEF); 869 870 /* Intialize linked list */ 871 TAILQ_INIT(&sc->mrsas_mpt_cmd_list_head); 872 TAILQ_INIT(&sc->mrsas_mfi_cmd_list_head); 873 874 mrsas_atomic_set(&sc->fw_outstanding, 0); 875 mrsas_atomic_set(&sc->target_reset_outstanding, 0); 876 877 sc->io_cmds_highwater = 0; 878 879 sc->adprecovery = MRSAS_HBA_OPERATIONAL; 880 sc->UnevenSpanSupport = 0; 881 882 sc->msix_enable = 0; 883 884 /* Initialize Firmware */ 885 if (mrsas_init_fw(sc) != SUCCESS) { 886 goto attach_fail_fw; 887 } 888 /* Register mrsas to CAM layer */ 889 if ((mrsas_cam_attach(sc) != SUCCESS)) { 890 goto attach_fail_cam; 891 } 892 /* Register IRQs */ 893 if (mrsas_setup_irq(sc) != SUCCESS) { 894 goto attach_fail_irq; 895 } 896 error = mrsas_kproc_create(mrsas_ocr_thread, sc, 897 &sc->ocr_thread, 0, 0, "mrsas_ocr%d", 898 device_get_unit(sc->mrsas_dev)); 899 if (error) { 900 device_printf(sc->mrsas_dev, "Error %d starting OCR thread\n", error); 901 goto attach_fail_ocr_thread; 902 } 903 /* 904 * After FW initialization and OCR thread creation 905 * we will defer the cdev creation, AEN setup on ICH callback 906 */ 907 sc->mrsas_ich.ich_func = mrsas_ich_startup; 908 sc->mrsas_ich.ich_arg = sc; 909 if (config_intrhook_establish(&sc->mrsas_ich) != 0) { 910 device_printf(sc->mrsas_dev, "Config hook is already established\n"); 911 } 912 mrsas_setup_sysctl(sc); 913 return SUCCESS; 914 915 attach_fail_ocr_thread: 916 if (sc->ocr_thread_active) 917 wakeup(&sc->ocr_chan); 918 attach_fail_irq: 919 mrsas_teardown_intr(sc); 920 attach_fail_cam: 921 mrsas_cam_detach(sc); 922 attach_fail_fw: 923 /* if MSIX vector is allocated and FW Init FAILED then release MSIX */ 924 if (sc->msix_enable == 1) 925 pci_release_msi(sc->mrsas_dev); 926 mrsas_free_mem(sc); 927 mtx_destroy(&sc->sim_lock); 928 mtx_destroy(&sc->aen_lock); 929 mtx_destroy(&sc->pci_lock); 930 mtx_destroy(&sc->io_lock); 931 mtx_destroy(&sc->ioctl_lock); 932 mtx_destroy(&sc->mpt_cmd_pool_lock); 933 mtx_destroy(&sc->mfi_cmd_pool_lock); 934 mtx_destroy(&sc->raidmap_lock); 935 attach_fail: 936 if (sc->reg_res) { 937 bus_release_resource(sc->mrsas_dev, SYS_RES_MEMORY, 938 sc->reg_res_id, sc->reg_res); 939 } 940 return (ENXIO); 941 } 942 943 /* 944 * Interrupt config hook 945 */ 946 static void 947 mrsas_ich_startup(void *arg) 948 { 949 struct mrsas_softc *sc = (struct mrsas_softc *)arg; 950 951 /* 952 * Intialize a counting Semaphore to take care no. of concurrent IOCTLs 953 */ 954 sema_init(&sc->ioctl_count_sema, MRSAS_MAX_IOCTL_CMDS, 955 IOCTL_SEMA_DESCRIPTION); 956 957 /* Create a /dev entry for mrsas controller. */ 958 sc->mrsas_cdev = make_dev(&mrsas_cdevsw, device_get_unit(sc->mrsas_dev), UID_ROOT, 959 GID_OPERATOR, (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP), "mrsas%u", 960 device_get_unit(sc->mrsas_dev)); 961 962 if (device_get_unit(sc->mrsas_dev) == 0) { 963 make_dev_alias_p(MAKEDEV_CHECKNAME, 964 &sc->mrsas_linux_emulator_cdev, sc->mrsas_cdev, 965 "megaraid_sas_ioctl_node"); 966 } 967 if (sc->mrsas_cdev) 968 sc->mrsas_cdev->si_drv1 = sc; 969 970 /* 971 * Add this controller to mrsas_mgmt_info structure so that it can be 972 * exported to management applications 973 */ 974 if (device_get_unit(sc->mrsas_dev) == 0) 975 memset(&mrsas_mgmt_info, 0, sizeof(mrsas_mgmt_info)); 976 977 mrsas_mgmt_info.count++; 978 mrsas_mgmt_info.sc_ptr[mrsas_mgmt_info.max_index] = sc; 979 mrsas_mgmt_info.max_index++; 980 981 /* Enable Interrupts */ 982 mrsas_enable_intr(sc); 983 984 /* Initiate AEN (Asynchronous Event Notification) */ 985 if (mrsas_start_aen(sc)) { 986 device_printf(sc->mrsas_dev, "Error: AEN registration FAILED !!! " 987 "Further events from the controller will not be communicated.\n" 988 "Either there is some problem in the controller" 989 "or the controller does not support AEN.\n" 990 "Please contact to the SUPPORT TEAM if the problem persists\n"); 991 } 992 if (sc->mrsas_ich.ich_arg != NULL) { 993 device_printf(sc->mrsas_dev, "Disestablish mrsas intr hook\n"); 994 config_intrhook_disestablish(&sc->mrsas_ich); 995 sc->mrsas_ich.ich_arg = NULL; 996 } 997 } 998 999 /* 1000 * mrsas_detach: De-allocates and teardown resources 1001 * input: pointer to device struct 1002 * 1003 * This function is the entry point for device disconnect and detach. 1004 * It performs memory de-allocations, shutdown of the controller and various 1005 * teardown and destroy resource functions. 1006 */ 1007 static int 1008 mrsas_detach(device_t dev) 1009 { 1010 struct mrsas_softc *sc; 1011 int i = 0; 1012 1013 sc = device_get_softc(dev); 1014 sc->remove_in_progress = 1; 1015 1016 /* Destroy the character device so no other IOCTL will be handled */ 1017 if ((device_get_unit(dev) == 0) && sc->mrsas_linux_emulator_cdev) 1018 destroy_dev(sc->mrsas_linux_emulator_cdev); 1019 destroy_dev(sc->mrsas_cdev); 1020 1021 /* 1022 * Take the instance off the instance array. Note that we will not 1023 * decrement the max_index. We let this array be sparse array 1024 */ 1025 for (i = 0; i < mrsas_mgmt_info.max_index; i++) { 1026 if (mrsas_mgmt_info.sc_ptr[i] == sc) { 1027 mrsas_mgmt_info.count--; 1028 mrsas_mgmt_info.sc_ptr[i] = NULL; 1029 break; 1030 } 1031 } 1032 1033 if (sc->ocr_thread_active) 1034 wakeup(&sc->ocr_chan); 1035 while (sc->reset_in_progress) { 1036 i++; 1037 if (!(i % MRSAS_RESET_NOTICE_INTERVAL)) { 1038 mrsas_dprint(sc, MRSAS_INFO, 1039 "[%2d]waiting for OCR to be finished from %s\n", i, __func__); 1040 } 1041 pause("mr_shutdown", hz); 1042 } 1043 i = 0; 1044 while (sc->ocr_thread_active) { 1045 i++; 1046 if (!(i % MRSAS_RESET_NOTICE_INTERVAL)) { 1047 mrsas_dprint(sc, MRSAS_INFO, 1048 "[%2d]waiting for " 1049 "mrsas_ocr thread to quit ocr %d\n", i, 1050 sc->ocr_thread_active); 1051 } 1052 pause("mr_shutdown", hz); 1053 } 1054 mrsas_flush_cache(sc); 1055 mrsas_shutdown_ctlr(sc, MR_DCMD_CTRL_SHUTDOWN); 1056 mrsas_disable_intr(sc); 1057 mrsas_cam_detach(sc); 1058 mrsas_teardown_intr(sc); 1059 mrsas_free_mem(sc); 1060 mtx_destroy(&sc->sim_lock); 1061 mtx_destroy(&sc->aen_lock); 1062 mtx_destroy(&sc->pci_lock); 1063 mtx_destroy(&sc->io_lock); 1064 mtx_destroy(&sc->ioctl_lock); 1065 mtx_destroy(&sc->mpt_cmd_pool_lock); 1066 mtx_destroy(&sc->mfi_cmd_pool_lock); 1067 mtx_destroy(&sc->raidmap_lock); 1068 1069 /* Wait for all the semaphores to be released */ 1070 while (sema_value(&sc->ioctl_count_sema) != MRSAS_MAX_IOCTL_CMDS) 1071 pause("mr_shutdown", hz); 1072 1073 /* Destroy the counting semaphore created for Ioctl */ 1074 sema_destroy(&sc->ioctl_count_sema); 1075 1076 if (sc->reg_res) { 1077 bus_release_resource(sc->mrsas_dev, 1078 SYS_RES_MEMORY, sc->reg_res_id, sc->reg_res); 1079 } 1080 if (sc->sysctl_tree != NULL) 1081 sysctl_ctx_free(&sc->sysctl_ctx); 1082 1083 return (0); 1084 } 1085 1086 /* 1087 * mrsas_free_mem: Frees allocated memory 1088 * input: Adapter instance soft state 1089 * 1090 * This function is called from mrsas_detach() to free previously allocated 1091 * memory. 1092 */ 1093 void 1094 mrsas_free_mem(struct mrsas_softc *sc) 1095 { 1096 int i; 1097 u_int32_t max_cmd; 1098 struct mrsas_mfi_cmd *mfi_cmd; 1099 struct mrsas_mpt_cmd *mpt_cmd; 1100 1101 /* 1102 * Free RAID map memory 1103 */ 1104 for (i = 0; i < 2; i++) { 1105 if (sc->raidmap_phys_addr[i]) 1106 bus_dmamap_unload(sc->raidmap_tag[i], sc->raidmap_dmamap[i]); 1107 if (sc->raidmap_mem[i] != NULL) 1108 bus_dmamem_free(sc->raidmap_tag[i], sc->raidmap_mem[i], sc->raidmap_dmamap[i]); 1109 if (sc->raidmap_tag[i] != NULL) 1110 bus_dma_tag_destroy(sc->raidmap_tag[i]); 1111 1112 if (sc->ld_drv_map[i] != NULL) 1113 free(sc->ld_drv_map[i], M_MRSAS); 1114 } 1115 for (i = 0; i < 2; i++) { 1116 if (sc->jbodmap_phys_addr[i]) 1117 bus_dmamap_unload(sc->jbodmap_tag[i], sc->jbodmap_dmamap[i]); 1118 if (sc->jbodmap_mem[i] != NULL) 1119 bus_dmamem_free(sc->jbodmap_tag[i], sc->jbodmap_mem[i], sc->jbodmap_dmamap[i]); 1120 if (sc->jbodmap_tag[i] != NULL) 1121 bus_dma_tag_destroy(sc->jbodmap_tag[i]); 1122 } 1123 /* 1124 * Free version buffer memory 1125 */ 1126 if (sc->verbuf_phys_addr) 1127 bus_dmamap_unload(sc->verbuf_tag, sc->verbuf_dmamap); 1128 if (sc->verbuf_mem != NULL) 1129 bus_dmamem_free(sc->verbuf_tag, sc->verbuf_mem, sc->verbuf_dmamap); 1130 if (sc->verbuf_tag != NULL) 1131 bus_dma_tag_destroy(sc->verbuf_tag); 1132 1133 1134 /* 1135 * Free sense buffer memory 1136 */ 1137 if (sc->sense_phys_addr) 1138 bus_dmamap_unload(sc->sense_tag, sc->sense_dmamap); 1139 if (sc->sense_mem != NULL) 1140 bus_dmamem_free(sc->sense_tag, sc->sense_mem, sc->sense_dmamap); 1141 if (sc->sense_tag != NULL) 1142 bus_dma_tag_destroy(sc->sense_tag); 1143 1144 /* 1145 * Free chain frame memory 1146 */ 1147 if (sc->chain_frame_phys_addr) 1148 bus_dmamap_unload(sc->chain_frame_tag, sc->chain_frame_dmamap); 1149 if (sc->chain_frame_mem != NULL) 1150 bus_dmamem_free(sc->chain_frame_tag, sc->chain_frame_mem, sc->chain_frame_dmamap); 1151 if (sc->chain_frame_tag != NULL) 1152 bus_dma_tag_destroy(sc->chain_frame_tag); 1153 1154 /* 1155 * Free IO Request memory 1156 */ 1157 if (sc->io_request_phys_addr) 1158 bus_dmamap_unload(sc->io_request_tag, sc->io_request_dmamap); 1159 if (sc->io_request_mem != NULL) 1160 bus_dmamem_free(sc->io_request_tag, sc->io_request_mem, sc->io_request_dmamap); 1161 if (sc->io_request_tag != NULL) 1162 bus_dma_tag_destroy(sc->io_request_tag); 1163 1164 /* 1165 * Free Reply Descriptor memory 1166 */ 1167 if (sc->reply_desc_phys_addr) 1168 bus_dmamap_unload(sc->reply_desc_tag, sc->reply_desc_dmamap); 1169 if (sc->reply_desc_mem != NULL) 1170 bus_dmamem_free(sc->reply_desc_tag, sc->reply_desc_mem, sc->reply_desc_dmamap); 1171 if (sc->reply_desc_tag != NULL) 1172 bus_dma_tag_destroy(sc->reply_desc_tag); 1173 1174 /* 1175 * Free event detail memory 1176 */ 1177 if (sc->evt_detail_phys_addr) 1178 bus_dmamap_unload(sc->evt_detail_tag, sc->evt_detail_dmamap); 1179 if (sc->evt_detail_mem != NULL) 1180 bus_dmamem_free(sc->evt_detail_tag, sc->evt_detail_mem, sc->evt_detail_dmamap); 1181 if (sc->evt_detail_tag != NULL) 1182 bus_dma_tag_destroy(sc->evt_detail_tag); 1183 1184 /* 1185 * Free MFI frames 1186 */ 1187 if (sc->mfi_cmd_list) { 1188 for (i = 0; i < MRSAS_MAX_MFI_CMDS; i++) { 1189 mfi_cmd = sc->mfi_cmd_list[i]; 1190 mrsas_free_frame(sc, mfi_cmd); 1191 } 1192 } 1193 if (sc->mficmd_frame_tag != NULL) 1194 bus_dma_tag_destroy(sc->mficmd_frame_tag); 1195 1196 /* 1197 * Free MPT internal command list 1198 */ 1199 max_cmd = sc->max_fw_cmds; 1200 if (sc->mpt_cmd_list) { 1201 for (i = 0; i < max_cmd; i++) { 1202 mpt_cmd = sc->mpt_cmd_list[i]; 1203 bus_dmamap_destroy(sc->data_tag, mpt_cmd->data_dmamap); 1204 free(sc->mpt_cmd_list[i], M_MRSAS); 1205 } 1206 free(sc->mpt_cmd_list, M_MRSAS); 1207 sc->mpt_cmd_list = NULL; 1208 } 1209 /* 1210 * Free MFI internal command list 1211 */ 1212 1213 if (sc->mfi_cmd_list) { 1214 for (i = 0; i < MRSAS_MAX_MFI_CMDS; i++) { 1215 free(sc->mfi_cmd_list[i], M_MRSAS); 1216 } 1217 free(sc->mfi_cmd_list, M_MRSAS); 1218 sc->mfi_cmd_list = NULL; 1219 } 1220 /* 1221 * Free request descriptor memory 1222 */ 1223 free(sc->req_desc, M_MRSAS); 1224 sc->req_desc = NULL; 1225 1226 /* 1227 * Destroy parent tag 1228 */ 1229 if (sc->mrsas_parent_tag != NULL) 1230 bus_dma_tag_destroy(sc->mrsas_parent_tag); 1231 1232 /* 1233 * Free ctrl_info memory 1234 */ 1235 if (sc->ctrl_info != NULL) 1236 free(sc->ctrl_info, M_MRSAS); 1237 } 1238 1239 /* 1240 * mrsas_teardown_intr: Teardown interrupt 1241 * input: Adapter instance soft state 1242 * 1243 * This function is called from mrsas_detach() to teardown and release bus 1244 * interrupt resourse. 1245 */ 1246 void 1247 mrsas_teardown_intr(struct mrsas_softc *sc) 1248 { 1249 int i; 1250 1251 if (!sc->msix_enable) { 1252 if (sc->intr_handle[0]) 1253 bus_teardown_intr(sc->mrsas_dev, sc->mrsas_irq[0], sc->intr_handle[0]); 1254 if (sc->mrsas_irq[0] != NULL) 1255 bus_release_resource(sc->mrsas_dev, SYS_RES_IRQ, 1256 sc->irq_id[0], sc->mrsas_irq[0]); 1257 sc->intr_handle[0] = NULL; 1258 } else { 1259 for (i = 0; i < sc->msix_vectors; i++) { 1260 if (sc->intr_handle[i]) 1261 bus_teardown_intr(sc->mrsas_dev, sc->mrsas_irq[i], 1262 sc->intr_handle[i]); 1263 1264 if (sc->mrsas_irq[i] != NULL) 1265 bus_release_resource(sc->mrsas_dev, SYS_RES_IRQ, 1266 sc->irq_id[i], sc->mrsas_irq[i]); 1267 1268 sc->intr_handle[i] = NULL; 1269 } 1270 pci_release_msi(sc->mrsas_dev); 1271 } 1272 1273 } 1274 1275 /* 1276 * mrsas_suspend: Suspend entry point 1277 * input: Device struct pointer 1278 * 1279 * This function is the entry point for system suspend from the OS. 1280 */ 1281 static int 1282 mrsas_suspend(device_t dev) 1283 { 1284 /* This will be filled when the driver will have hibernation support */ 1285 return (0); 1286 } 1287 1288 /* 1289 * mrsas_resume: Resume entry point 1290 * input: Device struct pointer 1291 * 1292 * This function is the entry point for system resume from the OS. 1293 */ 1294 static int 1295 mrsas_resume(device_t dev) 1296 { 1297 /* This will be filled when the driver will have hibernation support */ 1298 return (0); 1299 } 1300 1301 /** 1302 * mrsas_get_softc_instance: Find softc instance based on cmd type 1303 * 1304 * This function will return softc instance based on cmd type. 1305 * In some case, application fire ioctl on required management instance and 1306 * do not provide host_no. Use cdev->si_drv1 to get softc instance for those 1307 * case, else get the softc instance from host_no provided by application in 1308 * user data. 1309 */ 1310 1311 static struct mrsas_softc * 1312 mrsas_get_softc_instance(struct cdev *dev, u_long cmd, caddr_t arg) 1313 { 1314 struct mrsas_softc *sc = NULL; 1315 struct mrsas_iocpacket *user_ioc = (struct mrsas_iocpacket *)arg; 1316 1317 if (cmd == MRSAS_IOC_GET_PCI_INFO) { 1318 sc = dev->si_drv1; 1319 } else { 1320 /* 1321 * get the Host number & the softc from data sent by the 1322 * Application 1323 */ 1324 sc = mrsas_mgmt_info.sc_ptr[user_ioc->host_no]; 1325 if (sc == NULL) 1326 printf("There is no Controller number %d\n", 1327 user_ioc->host_no); 1328 else if (user_ioc->host_no >= mrsas_mgmt_info.max_index) 1329 mrsas_dprint(sc, MRSAS_FAULT, 1330 "Invalid Controller number %d\n", user_ioc->host_no); 1331 } 1332 1333 return sc; 1334 } 1335 1336 /* 1337 * mrsas_ioctl: IOCtl commands entry point. 1338 * 1339 * This function is the entry point for IOCtls from the OS. It calls the 1340 * appropriate function for processing depending on the command received. 1341 */ 1342 static int 1343 mrsas_ioctl(struct cdev *dev, u_long cmd, caddr_t arg, int flag, 1344 struct thread *td) 1345 { 1346 struct mrsas_softc *sc; 1347 int ret = 0, i = 0; 1348 MRSAS_DRV_PCI_INFORMATION *pciDrvInfo; 1349 1350 sc = mrsas_get_softc_instance(dev, cmd, arg); 1351 if (!sc) 1352 return ENOENT; 1353 1354 if (sc->remove_in_progress || 1355 (sc->adprecovery == MRSAS_HW_CRITICAL_ERROR)) { 1356 mrsas_dprint(sc, MRSAS_INFO, 1357 "Either driver remove or shutdown called or " 1358 "HW is in unrecoverable critical error state.\n"); 1359 return ENOENT; 1360 } 1361 mtx_lock_spin(&sc->ioctl_lock); 1362 if (!sc->reset_in_progress) { 1363 mtx_unlock_spin(&sc->ioctl_lock); 1364 goto do_ioctl; 1365 } 1366 mtx_unlock_spin(&sc->ioctl_lock); 1367 while (sc->reset_in_progress) { 1368 i++; 1369 if (!(i % MRSAS_RESET_NOTICE_INTERVAL)) { 1370 mrsas_dprint(sc, MRSAS_INFO, 1371 "[%2d]waiting for OCR to be finished from %s\n", i, __func__); 1372 } 1373 pause("mr_ioctl", hz); 1374 } 1375 1376 do_ioctl: 1377 switch (cmd) { 1378 case MRSAS_IOC_FIRMWARE_PASS_THROUGH64: 1379 #ifdef COMPAT_FREEBSD32 1380 case MRSAS_IOC_FIRMWARE_PASS_THROUGH32: 1381 #endif 1382 /* 1383 * Decrement the Ioctl counting Semaphore before getting an 1384 * mfi command 1385 */ 1386 sema_wait(&sc->ioctl_count_sema); 1387 1388 ret = mrsas_passthru(sc, (void *)arg, cmd); 1389 1390 /* Increment the Ioctl counting semaphore value */ 1391 sema_post(&sc->ioctl_count_sema); 1392 1393 break; 1394 case MRSAS_IOC_SCAN_BUS: 1395 ret = mrsas_bus_scan(sc); 1396 break; 1397 1398 case MRSAS_IOC_GET_PCI_INFO: 1399 pciDrvInfo = (MRSAS_DRV_PCI_INFORMATION *) arg; 1400 memset(pciDrvInfo, 0, sizeof(MRSAS_DRV_PCI_INFORMATION)); 1401 pciDrvInfo->busNumber = pci_get_bus(sc->mrsas_dev); 1402 pciDrvInfo->deviceNumber = pci_get_slot(sc->mrsas_dev); 1403 pciDrvInfo->functionNumber = pci_get_function(sc->mrsas_dev); 1404 pciDrvInfo->domainID = pci_get_domain(sc->mrsas_dev); 1405 mrsas_dprint(sc, MRSAS_INFO, "pci bus no: %d," 1406 "pci device no: %d, pci function no: %d," 1407 "pci domain ID: %d\n", 1408 pciDrvInfo->busNumber, pciDrvInfo->deviceNumber, 1409 pciDrvInfo->functionNumber, pciDrvInfo->domainID); 1410 ret = 0; 1411 break; 1412 1413 default: 1414 mrsas_dprint(sc, MRSAS_TRACE, "IOCTL command 0x%lx is not handled\n", cmd); 1415 ret = ENOENT; 1416 } 1417 1418 return (ret); 1419 } 1420 1421 /* 1422 * mrsas_poll: poll entry point for mrsas driver fd 1423 * 1424 * This function is the entry point for poll from the OS. It waits for some AEN 1425 * events to be triggered from the controller and notifies back. 1426 */ 1427 static int 1428 mrsas_poll(struct cdev *dev, int poll_events, struct thread *td) 1429 { 1430 struct mrsas_softc *sc; 1431 int revents = 0; 1432 1433 sc = dev->si_drv1; 1434 1435 if (poll_events & (POLLIN | POLLRDNORM)) { 1436 if (sc->mrsas_aen_triggered) { 1437 revents |= poll_events & (POLLIN | POLLRDNORM); 1438 } 1439 } 1440 if (revents == 0) { 1441 if (poll_events & (POLLIN | POLLRDNORM)) { 1442 mtx_lock(&sc->aen_lock); 1443 sc->mrsas_poll_waiting = 1; 1444 selrecord(td, &sc->mrsas_select); 1445 mtx_unlock(&sc->aen_lock); 1446 } 1447 } 1448 return revents; 1449 } 1450 1451 /* 1452 * mrsas_setup_irq: Set up interrupt 1453 * input: Adapter instance soft state 1454 * 1455 * This function sets up interrupts as a bus resource, with flags indicating 1456 * resource permitting contemporaneous sharing and for resource to activate 1457 * atomically. 1458 */ 1459 static int 1460 mrsas_setup_irq(struct mrsas_softc *sc) 1461 { 1462 if (sc->msix_enable && (mrsas_setup_msix(sc) == SUCCESS)) 1463 device_printf(sc->mrsas_dev, "MSI-x interrupts setup success\n"); 1464 1465 else { 1466 device_printf(sc->mrsas_dev, "Fall back to legacy interrupt\n"); 1467 sc->irq_context[0].sc = sc; 1468 sc->irq_context[0].MSIxIndex = 0; 1469 sc->irq_id[0] = 0; 1470 sc->mrsas_irq[0] = bus_alloc_resource_any(sc->mrsas_dev, 1471 SYS_RES_IRQ, &sc->irq_id[0], RF_SHAREABLE | RF_ACTIVE); 1472 if (sc->mrsas_irq[0] == NULL) { 1473 device_printf(sc->mrsas_dev, "Cannot allocate legcay" 1474 "interrupt\n"); 1475 return (FAIL); 1476 } 1477 if (bus_setup_intr(sc->mrsas_dev, sc->mrsas_irq[0], 1478 INTR_MPSAFE | INTR_TYPE_CAM, NULL, mrsas_isr, 1479 &sc->irq_context[0], &sc->intr_handle[0])) { 1480 device_printf(sc->mrsas_dev, "Cannot set up legacy" 1481 "interrupt\n"); 1482 return (FAIL); 1483 } 1484 } 1485 return (0); 1486 } 1487 1488 /* 1489 * mrsas_isr: ISR entry point 1490 * input: argument pointer 1491 * 1492 * This function is the interrupt service routine entry point. There are two 1493 * types of interrupts, state change interrupt and response interrupt. If an 1494 * interrupt is not ours, we just return. 1495 */ 1496 void 1497 mrsas_isr(void *arg) 1498 { 1499 struct mrsas_irq_context *irq_context = (struct mrsas_irq_context *)arg; 1500 struct mrsas_softc *sc = irq_context->sc; 1501 int status = 0; 1502 1503 if (sc->mask_interrupts) 1504 return; 1505 1506 if (!sc->msix_vectors) { 1507 status = mrsas_clear_intr(sc); 1508 if (!status) 1509 return; 1510 } 1511 /* If we are resetting, bail */ 1512 if (mrsas_test_bit(MRSAS_FUSION_IN_RESET, &sc->reset_flags)) { 1513 printf(" Entered into ISR when OCR is going active. \n"); 1514 mrsas_clear_intr(sc); 1515 return; 1516 } 1517 /* Process for reply request and clear response interrupt */ 1518 if (mrsas_complete_cmd(sc, irq_context->MSIxIndex) != SUCCESS) 1519 mrsas_clear_intr(sc); 1520 1521 return; 1522 } 1523 1524 /* 1525 * mrsas_complete_cmd: Process reply request 1526 * input: Adapter instance soft state 1527 * 1528 * This function is called from mrsas_isr() to process reply request and clear 1529 * response interrupt. Processing of the reply request entails walking 1530 * through the reply descriptor array for the command request pended from 1531 * Firmware. We look at the Function field to determine the command type and 1532 * perform the appropriate action. Before we return, we clear the response 1533 * interrupt. 1534 */ 1535 int 1536 mrsas_complete_cmd(struct mrsas_softc *sc, u_int32_t MSIxIndex) 1537 { 1538 Mpi2ReplyDescriptorsUnion_t *desc; 1539 MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *reply_desc; 1540 MRSAS_RAID_SCSI_IO_REQUEST *scsi_io_req; 1541 struct mrsas_mpt_cmd *cmd_mpt; 1542 struct mrsas_mfi_cmd *cmd_mfi; 1543 u_int8_t reply_descript_type; 1544 u_int16_t smid, num_completed; 1545 u_int8_t status, extStatus; 1546 union desc_value desc_val; 1547 PLD_LOAD_BALANCE_INFO lbinfo; 1548 u_int32_t device_id; 1549 int threshold_reply_count = 0; 1550 #if TM_DEBUG 1551 MR_TASK_MANAGE_REQUEST *mr_tm_req; 1552 MPI2_SCSI_TASK_MANAGE_REQUEST *mpi_tm_req; 1553 #endif 1554 1555 /* If we have a hardware error, not need to continue */ 1556 if (sc->adprecovery == MRSAS_HW_CRITICAL_ERROR) 1557 return (DONE); 1558 1559 desc = sc->reply_desc_mem; 1560 desc += ((MSIxIndex * sc->reply_alloc_sz) / sizeof(MPI2_REPLY_DESCRIPTORS_UNION)) 1561 + sc->last_reply_idx[MSIxIndex]; 1562 1563 reply_desc = (MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *) desc; 1564 1565 desc_val.word = desc->Words; 1566 num_completed = 0; 1567 1568 reply_descript_type = reply_desc->ReplyFlags & MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK; 1569 1570 /* Find our reply descriptor for the command and process */ 1571 while ((desc_val.u.low != 0xFFFFFFFF) && (desc_val.u.high != 0xFFFFFFFF)) { 1572 smid = reply_desc->SMID; 1573 cmd_mpt = sc->mpt_cmd_list[smid - 1]; 1574 scsi_io_req = (MRSAS_RAID_SCSI_IO_REQUEST *) cmd_mpt->io_request; 1575 1576 status = scsi_io_req->RaidContext.status; 1577 extStatus = scsi_io_req->RaidContext.exStatus; 1578 1579 switch (scsi_io_req->Function) { 1580 case MPI2_FUNCTION_SCSI_TASK_MGMT: 1581 #if TM_DEBUG 1582 mr_tm_req = (MR_TASK_MANAGE_REQUEST *) cmd_mpt->io_request; 1583 mpi_tm_req = (MPI2_SCSI_TASK_MANAGE_REQUEST *) 1584 &mr_tm_req->TmRequest; 1585 device_printf(sc->mrsas_dev, "TM completion type 0x%X, " 1586 "TaskMID: 0x%X", mpi_tm_req->TaskType, mpi_tm_req->TaskMID); 1587 #endif 1588 wakeup_one((void *)&sc->ocr_chan); 1589 break; 1590 case MPI2_FUNCTION_SCSI_IO_REQUEST: /* Fast Path IO. */ 1591 device_id = cmd_mpt->ccb_ptr->ccb_h.target_id; 1592 lbinfo = &sc->load_balance_info[device_id]; 1593 if (cmd_mpt->load_balance == MRSAS_LOAD_BALANCE_FLAG) { 1594 mrsas_atomic_dec(&lbinfo->scsi_pending_cmds[cmd_mpt->pd_r1_lb]); 1595 cmd_mpt->load_balance &= ~MRSAS_LOAD_BALANCE_FLAG; 1596 } 1597 /* Fall thru and complete IO */ 1598 case MRSAS_MPI2_FUNCTION_LD_IO_REQUEST: 1599 mrsas_map_mpt_cmd_status(cmd_mpt, status, extStatus); 1600 mrsas_cmd_done(sc, cmd_mpt); 1601 scsi_io_req->RaidContext.status = 0; 1602 scsi_io_req->RaidContext.exStatus = 0; 1603 mrsas_atomic_dec(&sc->fw_outstanding); 1604 break; 1605 case MRSAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST: /* MFI command */ 1606 cmd_mfi = sc->mfi_cmd_list[cmd_mpt->sync_cmd_idx]; 1607 /* 1608 * Make sure NOT TO release the mfi command from the called 1609 * function's context if it is fired with issue_polled call. 1610 * And also make sure that the issue_polled call should only be 1611 * used if INTERRUPT IS DISABLED. 1612 */ 1613 if (cmd_mfi->frame->hdr.flags & MFI_FRAME_DONT_POST_IN_REPLY_QUEUE) 1614 mrsas_release_mfi_cmd(cmd_mfi); 1615 else 1616 mrsas_complete_mptmfi_passthru(sc, cmd_mfi, status); 1617 break; 1618 } 1619 1620 sc->last_reply_idx[MSIxIndex]++; 1621 if (sc->last_reply_idx[MSIxIndex] >= sc->reply_q_depth) 1622 sc->last_reply_idx[MSIxIndex] = 0; 1623 1624 desc->Words = ~((uint64_t)0x00); /* set it back to all 1625 * 0xFFFFFFFFs */ 1626 num_completed++; 1627 threshold_reply_count++; 1628 1629 /* Get the next reply descriptor */ 1630 if (!sc->last_reply_idx[MSIxIndex]) { 1631 desc = sc->reply_desc_mem; 1632 desc += ((MSIxIndex * sc->reply_alloc_sz) / sizeof(MPI2_REPLY_DESCRIPTORS_UNION)); 1633 } else 1634 desc++; 1635 1636 reply_desc = (MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *) desc; 1637 desc_val.word = desc->Words; 1638 1639 reply_descript_type = reply_desc->ReplyFlags & MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK; 1640 1641 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED) 1642 break; 1643 1644 /* 1645 * Write to reply post index after completing threshold reply 1646 * count and still there are more replies in reply queue 1647 * pending to be completed. 1648 */ 1649 if (threshold_reply_count >= THRESHOLD_REPLY_COUNT) { 1650 if (sc->msix_enable) { 1651 if (sc->mrsas_gen3_ctrl) 1652 mrsas_write_reg(sc, sc->msix_reg_offset[MSIxIndex / 8], 1653 ((MSIxIndex & 0x7) << 24) | 1654 sc->last_reply_idx[MSIxIndex]); 1655 else 1656 mrsas_write_reg(sc, sc->msix_reg_offset[0], (MSIxIndex << 24) | 1657 sc->last_reply_idx[MSIxIndex]); 1658 } else 1659 mrsas_write_reg(sc, offsetof(mrsas_reg_set, 1660 reply_post_host_index), sc->last_reply_idx[0]); 1661 1662 threshold_reply_count = 0; 1663 } 1664 } 1665 1666 /* No match, just return */ 1667 if (num_completed == 0) 1668 return (DONE); 1669 1670 /* Clear response interrupt */ 1671 if (sc->msix_enable) { 1672 if (sc->mrsas_gen3_ctrl) { 1673 mrsas_write_reg(sc, sc->msix_reg_offset[MSIxIndex / 8], 1674 ((MSIxIndex & 0x7) << 24) | 1675 sc->last_reply_idx[MSIxIndex]); 1676 } else 1677 mrsas_write_reg(sc, sc->msix_reg_offset[0], (MSIxIndex << 24) | 1678 sc->last_reply_idx[MSIxIndex]); 1679 } else 1680 mrsas_write_reg(sc, offsetof(mrsas_reg_set, 1681 reply_post_host_index), sc->last_reply_idx[0]); 1682 1683 return (0); 1684 } 1685 1686 /* 1687 * mrsas_map_mpt_cmd_status: Allocate DMAable memory. 1688 * input: Adapter instance soft state 1689 * 1690 * This function is called from mrsas_complete_cmd(), for LD IO and FastPath IO. 1691 * It checks the command status and maps the appropriate CAM status for the 1692 * CCB. 1693 */ 1694 void 1695 mrsas_map_mpt_cmd_status(struct mrsas_mpt_cmd *cmd, u_int8_t status, u_int8_t extStatus) 1696 { 1697 struct mrsas_softc *sc = cmd->sc; 1698 u_int8_t *sense_data; 1699 1700 switch (status) { 1701 case MFI_STAT_OK: 1702 cmd->ccb_ptr->ccb_h.status = CAM_REQ_CMP; 1703 break; 1704 case MFI_STAT_SCSI_IO_FAILED: 1705 case MFI_STAT_SCSI_DONE_WITH_ERROR: 1706 cmd->ccb_ptr->ccb_h.status = CAM_SCSI_STATUS_ERROR; 1707 sense_data = (u_int8_t *)&cmd->ccb_ptr->csio.sense_data; 1708 if (sense_data) { 1709 /* For now just copy 18 bytes back */ 1710 memcpy(sense_data, cmd->sense, 18); 1711 cmd->ccb_ptr->csio.sense_len = 18; 1712 cmd->ccb_ptr->ccb_h.status |= CAM_AUTOSNS_VALID; 1713 } 1714 break; 1715 case MFI_STAT_LD_OFFLINE: 1716 case MFI_STAT_DEVICE_NOT_FOUND: 1717 if (cmd->ccb_ptr->ccb_h.target_lun) 1718 cmd->ccb_ptr->ccb_h.status |= CAM_LUN_INVALID; 1719 else 1720 cmd->ccb_ptr->ccb_h.status |= CAM_DEV_NOT_THERE; 1721 break; 1722 case MFI_STAT_CONFIG_SEQ_MISMATCH: 1723 cmd->ccb_ptr->ccb_h.status |= CAM_REQUEUE_REQ; 1724 break; 1725 default: 1726 device_printf(sc->mrsas_dev, "FW cmd complete status %x\n", status); 1727 cmd->ccb_ptr->ccb_h.status = CAM_REQ_CMP_ERR; 1728 cmd->ccb_ptr->csio.scsi_status = status; 1729 } 1730 return; 1731 } 1732 1733 /* 1734 * mrsas_alloc_mem: Allocate DMAable memory 1735 * input: Adapter instance soft state 1736 * 1737 * This function creates the parent DMA tag and allocates DMAable memory. DMA 1738 * tag describes constraints of DMA mapping. Memory allocated is mapped into 1739 * Kernel virtual address. Callback argument is physical memory address. 1740 */ 1741 static int 1742 mrsas_alloc_mem(struct mrsas_softc *sc) 1743 { 1744 u_int32_t verbuf_size, io_req_size, reply_desc_size, sense_size, 1745 chain_frame_size, evt_detail_size, count; 1746 1747 /* 1748 * Allocate parent DMA tag 1749 */ 1750 if (bus_dma_tag_create(NULL, /* parent */ 1751 1, /* alignment */ 1752 0, /* boundary */ 1753 BUS_SPACE_MAXADDR, /* lowaddr */ 1754 BUS_SPACE_MAXADDR, /* highaddr */ 1755 NULL, NULL, /* filter, filterarg */ 1756 MAXPHYS, /* maxsize */ 1757 sc->max_num_sge, /* nsegments */ 1758 MAXPHYS, /* maxsegsize */ 1759 0, /* flags */ 1760 NULL, NULL, /* lockfunc, lockarg */ 1761 &sc->mrsas_parent_tag /* tag */ 1762 )) { 1763 device_printf(sc->mrsas_dev, "Cannot allocate parent DMA tag\n"); 1764 return (ENOMEM); 1765 } 1766 /* 1767 * Allocate for version buffer 1768 */ 1769 verbuf_size = MRSAS_MAX_NAME_LENGTH * (sizeof(bus_addr_t)); 1770 if (bus_dma_tag_create(sc->mrsas_parent_tag, 1771 1, 0, 1772 BUS_SPACE_MAXADDR_32BIT, 1773 BUS_SPACE_MAXADDR, 1774 NULL, NULL, 1775 verbuf_size, 1776 1, 1777 verbuf_size, 1778 BUS_DMA_ALLOCNOW, 1779 NULL, NULL, 1780 &sc->verbuf_tag)) { 1781 device_printf(sc->mrsas_dev, "Cannot allocate verbuf DMA tag\n"); 1782 return (ENOMEM); 1783 } 1784 if (bus_dmamem_alloc(sc->verbuf_tag, (void **)&sc->verbuf_mem, 1785 BUS_DMA_NOWAIT, &sc->verbuf_dmamap)) { 1786 device_printf(sc->mrsas_dev, "Cannot allocate verbuf memory\n"); 1787 return (ENOMEM); 1788 } 1789 bzero(sc->verbuf_mem, verbuf_size); 1790 if (bus_dmamap_load(sc->verbuf_tag, sc->verbuf_dmamap, sc->verbuf_mem, 1791 verbuf_size, mrsas_addr_cb, &sc->verbuf_phys_addr, 1792 BUS_DMA_NOWAIT)) { 1793 device_printf(sc->mrsas_dev, "Cannot load verbuf DMA map\n"); 1794 return (ENOMEM); 1795 } 1796 /* 1797 * Allocate IO Request Frames 1798 */ 1799 io_req_size = sc->io_frames_alloc_sz; 1800 if (bus_dma_tag_create(sc->mrsas_parent_tag, 1801 16, 0, 1802 BUS_SPACE_MAXADDR_32BIT, 1803 BUS_SPACE_MAXADDR, 1804 NULL, NULL, 1805 io_req_size, 1806 1, 1807 io_req_size, 1808 BUS_DMA_ALLOCNOW, 1809 NULL, NULL, 1810 &sc->io_request_tag)) { 1811 device_printf(sc->mrsas_dev, "Cannot create IO request tag\n"); 1812 return (ENOMEM); 1813 } 1814 if (bus_dmamem_alloc(sc->io_request_tag, (void **)&sc->io_request_mem, 1815 BUS_DMA_NOWAIT, &sc->io_request_dmamap)) { 1816 device_printf(sc->mrsas_dev, "Cannot alloc IO request memory\n"); 1817 return (ENOMEM); 1818 } 1819 bzero(sc->io_request_mem, io_req_size); 1820 if (bus_dmamap_load(sc->io_request_tag, sc->io_request_dmamap, 1821 sc->io_request_mem, io_req_size, mrsas_addr_cb, 1822 &sc->io_request_phys_addr, BUS_DMA_NOWAIT)) { 1823 device_printf(sc->mrsas_dev, "Cannot load IO request memory\n"); 1824 return (ENOMEM); 1825 } 1826 /* 1827 * Allocate Chain Frames 1828 */ 1829 chain_frame_size = sc->chain_frames_alloc_sz; 1830 if (bus_dma_tag_create(sc->mrsas_parent_tag, 1831 4, 0, 1832 BUS_SPACE_MAXADDR_32BIT, 1833 BUS_SPACE_MAXADDR, 1834 NULL, NULL, 1835 chain_frame_size, 1836 1, 1837 chain_frame_size, 1838 BUS_DMA_ALLOCNOW, 1839 NULL, NULL, 1840 &sc->chain_frame_tag)) { 1841 device_printf(sc->mrsas_dev, "Cannot create chain frame tag\n"); 1842 return (ENOMEM); 1843 } 1844 if (bus_dmamem_alloc(sc->chain_frame_tag, (void **)&sc->chain_frame_mem, 1845 BUS_DMA_NOWAIT, &sc->chain_frame_dmamap)) { 1846 device_printf(sc->mrsas_dev, "Cannot alloc chain frame memory\n"); 1847 return (ENOMEM); 1848 } 1849 bzero(sc->chain_frame_mem, chain_frame_size); 1850 if (bus_dmamap_load(sc->chain_frame_tag, sc->chain_frame_dmamap, 1851 sc->chain_frame_mem, chain_frame_size, mrsas_addr_cb, 1852 &sc->chain_frame_phys_addr, BUS_DMA_NOWAIT)) { 1853 device_printf(sc->mrsas_dev, "Cannot load chain frame memory\n"); 1854 return (ENOMEM); 1855 } 1856 count = sc->msix_vectors > 0 ? sc->msix_vectors : 1; 1857 /* 1858 * Allocate Reply Descriptor Array 1859 */ 1860 reply_desc_size = sc->reply_alloc_sz * count; 1861 if (bus_dma_tag_create(sc->mrsas_parent_tag, 1862 16, 0, 1863 BUS_SPACE_MAXADDR_32BIT, 1864 BUS_SPACE_MAXADDR, 1865 NULL, NULL, 1866 reply_desc_size, 1867 1, 1868 reply_desc_size, 1869 BUS_DMA_ALLOCNOW, 1870 NULL, NULL, 1871 &sc->reply_desc_tag)) { 1872 device_printf(sc->mrsas_dev, "Cannot create reply descriptor tag\n"); 1873 return (ENOMEM); 1874 } 1875 if (bus_dmamem_alloc(sc->reply_desc_tag, (void **)&sc->reply_desc_mem, 1876 BUS_DMA_NOWAIT, &sc->reply_desc_dmamap)) { 1877 device_printf(sc->mrsas_dev, "Cannot alloc reply descriptor memory\n"); 1878 return (ENOMEM); 1879 } 1880 if (bus_dmamap_load(sc->reply_desc_tag, sc->reply_desc_dmamap, 1881 sc->reply_desc_mem, reply_desc_size, mrsas_addr_cb, 1882 &sc->reply_desc_phys_addr, BUS_DMA_NOWAIT)) { 1883 device_printf(sc->mrsas_dev, "Cannot load reply descriptor memory\n"); 1884 return (ENOMEM); 1885 } 1886 /* 1887 * Allocate Sense Buffer Array. Keep in lower 4GB 1888 */ 1889 sense_size = sc->max_fw_cmds * MRSAS_SENSE_LEN; 1890 if (bus_dma_tag_create(sc->mrsas_parent_tag, 1891 64, 0, 1892 BUS_SPACE_MAXADDR_32BIT, 1893 BUS_SPACE_MAXADDR, 1894 NULL, NULL, 1895 sense_size, 1896 1, 1897 sense_size, 1898 BUS_DMA_ALLOCNOW, 1899 NULL, NULL, 1900 &sc->sense_tag)) { 1901 device_printf(sc->mrsas_dev, "Cannot allocate sense buf tag\n"); 1902 return (ENOMEM); 1903 } 1904 if (bus_dmamem_alloc(sc->sense_tag, (void **)&sc->sense_mem, 1905 BUS_DMA_NOWAIT, &sc->sense_dmamap)) { 1906 device_printf(sc->mrsas_dev, "Cannot allocate sense buf memory\n"); 1907 return (ENOMEM); 1908 } 1909 if (bus_dmamap_load(sc->sense_tag, sc->sense_dmamap, 1910 sc->sense_mem, sense_size, mrsas_addr_cb, &sc->sense_phys_addr, 1911 BUS_DMA_NOWAIT)) { 1912 device_printf(sc->mrsas_dev, "Cannot load sense buf memory\n"); 1913 return (ENOMEM); 1914 } 1915 /* 1916 * Allocate for Event detail structure 1917 */ 1918 evt_detail_size = sizeof(struct mrsas_evt_detail); 1919 if (bus_dma_tag_create(sc->mrsas_parent_tag, 1920 1, 0, 1921 BUS_SPACE_MAXADDR_32BIT, 1922 BUS_SPACE_MAXADDR, 1923 NULL, NULL, 1924 evt_detail_size, 1925 1, 1926 evt_detail_size, 1927 BUS_DMA_ALLOCNOW, 1928 NULL, NULL, 1929 &sc->evt_detail_tag)) { 1930 device_printf(sc->mrsas_dev, "Cannot create Event detail tag\n"); 1931 return (ENOMEM); 1932 } 1933 if (bus_dmamem_alloc(sc->evt_detail_tag, (void **)&sc->evt_detail_mem, 1934 BUS_DMA_NOWAIT, &sc->evt_detail_dmamap)) { 1935 device_printf(sc->mrsas_dev, "Cannot alloc Event detail buffer memory\n"); 1936 return (ENOMEM); 1937 } 1938 bzero(sc->evt_detail_mem, evt_detail_size); 1939 if (bus_dmamap_load(sc->evt_detail_tag, sc->evt_detail_dmamap, 1940 sc->evt_detail_mem, evt_detail_size, mrsas_addr_cb, 1941 &sc->evt_detail_phys_addr, BUS_DMA_NOWAIT)) { 1942 device_printf(sc->mrsas_dev, "Cannot load Event detail buffer memory\n"); 1943 return (ENOMEM); 1944 } 1945 /* 1946 * Create a dma tag for data buffers; size will be the maximum 1947 * possible I/O size (280kB). 1948 */ 1949 if (bus_dma_tag_create(sc->mrsas_parent_tag, 1950 1, 1951 0, 1952 BUS_SPACE_MAXADDR, 1953 BUS_SPACE_MAXADDR, 1954 NULL, NULL, 1955 MAXPHYS, 1956 sc->max_num_sge, /* nsegments */ 1957 MAXPHYS, 1958 BUS_DMA_ALLOCNOW, 1959 busdma_lock_mutex, 1960 &sc->io_lock, 1961 &sc->data_tag)) { 1962 device_printf(sc->mrsas_dev, "Cannot create data dma tag\n"); 1963 return (ENOMEM); 1964 } 1965 return (0); 1966 } 1967 1968 /* 1969 * mrsas_addr_cb: Callback function of bus_dmamap_load() 1970 * input: callback argument, machine dependent type 1971 * that describes DMA segments, number of segments, error code 1972 * 1973 * This function is for the driver to receive mapping information resultant of 1974 * the bus_dmamap_load(). The information is actually not being used, but the 1975 * address is saved anyway. 1976 */ 1977 void 1978 mrsas_addr_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 1979 { 1980 bus_addr_t *addr; 1981 1982 addr = arg; 1983 *addr = segs[0].ds_addr; 1984 } 1985 1986 /* 1987 * mrsas_setup_raidmap: Set up RAID map. 1988 * input: Adapter instance soft state 1989 * 1990 * Allocate DMA memory for the RAID maps and perform setup. 1991 */ 1992 static int 1993 mrsas_setup_raidmap(struct mrsas_softc *sc) 1994 { 1995 int i; 1996 1997 for (i = 0; i < 2; i++) { 1998 sc->ld_drv_map[i] = 1999 (void *)malloc(sc->drv_map_sz, M_MRSAS, M_NOWAIT); 2000 /* Do Error handling */ 2001 if (!sc->ld_drv_map[i]) { 2002 device_printf(sc->mrsas_dev, "Could not allocate memory for local map"); 2003 2004 if (i == 1) 2005 free(sc->ld_drv_map[0], M_MRSAS); 2006 /* ABORT driver initialization */ 2007 goto ABORT; 2008 } 2009 } 2010 2011 for (int i = 0; i < 2; i++) { 2012 if (bus_dma_tag_create(sc->mrsas_parent_tag, 2013 4, 0, 2014 BUS_SPACE_MAXADDR_32BIT, 2015 BUS_SPACE_MAXADDR, 2016 NULL, NULL, 2017 sc->max_map_sz, 2018 1, 2019 sc->max_map_sz, 2020 BUS_DMA_ALLOCNOW, 2021 NULL, NULL, 2022 &sc->raidmap_tag[i])) { 2023 device_printf(sc->mrsas_dev, 2024 "Cannot allocate raid map tag.\n"); 2025 return (ENOMEM); 2026 } 2027 if (bus_dmamem_alloc(sc->raidmap_tag[i], 2028 (void **)&sc->raidmap_mem[i], 2029 BUS_DMA_NOWAIT, &sc->raidmap_dmamap[i])) { 2030 device_printf(sc->mrsas_dev, 2031 "Cannot allocate raidmap memory.\n"); 2032 return (ENOMEM); 2033 } 2034 bzero(sc->raidmap_mem[i], sc->max_map_sz); 2035 2036 if (bus_dmamap_load(sc->raidmap_tag[i], sc->raidmap_dmamap[i], 2037 sc->raidmap_mem[i], sc->max_map_sz, 2038 mrsas_addr_cb, &sc->raidmap_phys_addr[i], 2039 BUS_DMA_NOWAIT)) { 2040 device_printf(sc->mrsas_dev, "Cannot load raidmap memory.\n"); 2041 return (ENOMEM); 2042 } 2043 if (!sc->raidmap_mem[i]) { 2044 device_printf(sc->mrsas_dev, 2045 "Cannot allocate memory for raid map.\n"); 2046 return (ENOMEM); 2047 } 2048 } 2049 2050 if (!mrsas_get_map_info(sc)) 2051 mrsas_sync_map_info(sc); 2052 2053 return (0); 2054 2055 ABORT: 2056 return (1); 2057 } 2058 2059 /** 2060 * megasas_setup_jbod_map - setup jbod map for FP seq_number. 2061 * @sc: Adapter soft state 2062 * 2063 * Return 0 on success. 2064 */ 2065 void 2066 megasas_setup_jbod_map(struct mrsas_softc *sc) 2067 { 2068 int i; 2069 uint32_t pd_seq_map_sz; 2070 2071 pd_seq_map_sz = sizeof(struct MR_PD_CFG_SEQ_NUM_SYNC) + 2072 (sizeof(struct MR_PD_CFG_SEQ) * (MAX_PHYSICAL_DEVICES - 1)); 2073 2074 if (!sc->ctrl_info->adapterOperations3.useSeqNumJbodFP) { 2075 sc->use_seqnum_jbod_fp = 0; 2076 return; 2077 } 2078 if (sc->jbodmap_mem[0]) 2079 goto skip_alloc; 2080 2081 for (i = 0; i < 2; i++) { 2082 if (bus_dma_tag_create(sc->mrsas_parent_tag, 2083 4, 0, 2084 BUS_SPACE_MAXADDR_32BIT, 2085 BUS_SPACE_MAXADDR, 2086 NULL, NULL, 2087 pd_seq_map_sz, 2088 1, 2089 pd_seq_map_sz, 2090 BUS_DMA_ALLOCNOW, 2091 NULL, NULL, 2092 &sc->jbodmap_tag[i])) { 2093 device_printf(sc->mrsas_dev, 2094 "Cannot allocate jbod map tag.\n"); 2095 return; 2096 } 2097 if (bus_dmamem_alloc(sc->jbodmap_tag[i], 2098 (void **)&sc->jbodmap_mem[i], 2099 BUS_DMA_NOWAIT, &sc->jbodmap_dmamap[i])) { 2100 device_printf(sc->mrsas_dev, 2101 "Cannot allocate jbod map memory.\n"); 2102 return; 2103 } 2104 bzero(sc->jbodmap_mem[i], pd_seq_map_sz); 2105 2106 if (bus_dmamap_load(sc->jbodmap_tag[i], sc->jbodmap_dmamap[i], 2107 sc->jbodmap_mem[i], pd_seq_map_sz, 2108 mrsas_addr_cb, &sc->jbodmap_phys_addr[i], 2109 BUS_DMA_NOWAIT)) { 2110 device_printf(sc->mrsas_dev, "Cannot load jbod map memory.\n"); 2111 return; 2112 } 2113 if (!sc->jbodmap_mem[i]) { 2114 device_printf(sc->mrsas_dev, 2115 "Cannot allocate memory for jbod map.\n"); 2116 sc->use_seqnum_jbod_fp = 0; 2117 return; 2118 } 2119 } 2120 2121 skip_alloc: 2122 if (!megasas_sync_pd_seq_num(sc, false) && 2123 !megasas_sync_pd_seq_num(sc, true)) 2124 sc->use_seqnum_jbod_fp = 1; 2125 else 2126 sc->use_seqnum_jbod_fp = 0; 2127 2128 device_printf(sc->mrsas_dev, "Jbod map is supported\n"); 2129 } 2130 2131 /* 2132 * mrsas_init_fw: Initialize Firmware 2133 * input: Adapter soft state 2134 * 2135 * Calls transition_to_ready() to make sure Firmware is in operational state and 2136 * calls mrsas_init_adapter() to send IOC_INIT command to Firmware. It 2137 * issues internal commands to get the controller info after the IOC_INIT 2138 * command response is received by Firmware. Note: code relating to 2139 * get_pdlist, get_ld_list and max_sectors are currently not being used, it 2140 * is left here as placeholder. 2141 */ 2142 static int 2143 mrsas_init_fw(struct mrsas_softc *sc) 2144 { 2145 2146 int ret, loop, ocr = 0; 2147 u_int32_t max_sectors_1; 2148 u_int32_t max_sectors_2; 2149 u_int32_t tmp_sectors; 2150 u_int32_t scratch_pad_2; 2151 int msix_enable = 0; 2152 int fw_msix_count = 0; 2153 2154 /* Make sure Firmware is ready */ 2155 ret = mrsas_transition_to_ready(sc, ocr); 2156 if (ret != SUCCESS) { 2157 return (ret); 2158 } 2159 /* MSI-x index 0- reply post host index register */ 2160 sc->msix_reg_offset[0] = MPI2_REPLY_POST_HOST_INDEX_OFFSET; 2161 /* Check if MSI-X is supported while in ready state */ 2162 msix_enable = (mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_scratch_pad)) & 0x4000000) >> 0x1a; 2163 2164 if (msix_enable) { 2165 scratch_pad_2 = mrsas_read_reg(sc, offsetof(mrsas_reg_set, 2166 outbound_scratch_pad_2)); 2167 2168 /* Check max MSI-X vectors */ 2169 if (sc->device_id == MRSAS_TBOLT) { 2170 sc->msix_vectors = (scratch_pad_2 2171 & MR_MAX_REPLY_QUEUES_OFFSET) + 1; 2172 fw_msix_count = sc->msix_vectors; 2173 } else { 2174 /* Invader/Fury supports 96 MSI-X vectors */ 2175 sc->msix_vectors = ((scratch_pad_2 2176 & MR_MAX_REPLY_QUEUES_EXT_OFFSET) 2177 >> MR_MAX_REPLY_QUEUES_EXT_OFFSET_SHIFT) + 1; 2178 fw_msix_count = sc->msix_vectors; 2179 2180 for (loop = 1; loop < MR_MAX_MSIX_REG_ARRAY; 2181 loop++) { 2182 sc->msix_reg_offset[loop] = 2183 MPI2_SUP_REPLY_POST_HOST_INDEX_OFFSET + 2184 (loop * 0x10); 2185 } 2186 } 2187 2188 /* Don't bother allocating more MSI-X vectors than cpus */ 2189 sc->msix_vectors = min(sc->msix_vectors, 2190 mp_ncpus); 2191 2192 /* Allocate MSI-x vectors */ 2193 if (mrsas_allocate_msix(sc) == SUCCESS) 2194 sc->msix_enable = 1; 2195 else 2196 sc->msix_enable = 0; 2197 2198 device_printf(sc->mrsas_dev, "FW supports <%d> MSIX vector," 2199 "Online CPU %d Current MSIX <%d>\n", 2200 fw_msix_count, mp_ncpus, sc->msix_vectors); 2201 } 2202 if (mrsas_init_adapter(sc) != SUCCESS) { 2203 device_printf(sc->mrsas_dev, "Adapter initialize Fail.\n"); 2204 return (1); 2205 } 2206 /* Allocate internal commands for pass-thru */ 2207 if (mrsas_alloc_mfi_cmds(sc) != SUCCESS) { 2208 device_printf(sc->mrsas_dev, "Allocate MFI cmd failed.\n"); 2209 return (1); 2210 } 2211 sc->ctrl_info = malloc(sizeof(struct mrsas_ctrl_info), M_MRSAS, M_NOWAIT); 2212 if (!sc->ctrl_info) { 2213 device_printf(sc->mrsas_dev, "Malloc for ctrl_info failed.\n"); 2214 return (1); 2215 } 2216 /* 2217 * Get the controller info from FW, so that the MAX VD support 2218 * availability can be decided. 2219 */ 2220 if (mrsas_get_ctrl_info(sc)) { 2221 device_printf(sc->mrsas_dev, "Unable to get FW ctrl_info.\n"); 2222 return (1); 2223 } 2224 sc->secure_jbod_support = 2225 (u_int8_t)sc->ctrl_info->adapterOperations3.supportSecurityonJBOD; 2226 2227 if (sc->secure_jbod_support) 2228 device_printf(sc->mrsas_dev, "FW supports SED \n"); 2229 2230 if (sc->use_seqnum_jbod_fp) 2231 device_printf(sc->mrsas_dev, "FW supports JBOD Map \n"); 2232 2233 if (mrsas_setup_raidmap(sc) != SUCCESS) { 2234 device_printf(sc->mrsas_dev, "Error: RAID map setup FAILED !!! " 2235 "There seems to be some problem in the controller\n" 2236 "Please contact to the SUPPORT TEAM if the problem persists\n"); 2237 } 2238 megasas_setup_jbod_map(sc); 2239 2240 /* For pass-thru, get PD/LD list and controller info */ 2241 memset(sc->pd_list, 0, 2242 MRSAS_MAX_PD * sizeof(struct mrsas_pd_list)); 2243 if (mrsas_get_pd_list(sc) != SUCCESS) { 2244 device_printf(sc->mrsas_dev, "Get PD list failed.\n"); 2245 return (1); 2246 } 2247 memset(sc->ld_ids, 0xff, MRSAS_MAX_LD_IDS); 2248 if (mrsas_get_ld_list(sc) != SUCCESS) { 2249 device_printf(sc->mrsas_dev, "Get LD lsit failed.\n"); 2250 return (1); 2251 } 2252 /* 2253 * Compute the max allowed sectors per IO: The controller info has 2254 * two limits on max sectors. Driver should use the minimum of these 2255 * two. 2256 * 2257 * 1 << stripe_sz_ops.min = max sectors per strip 2258 * 2259 * Note that older firmwares ( < FW ver 30) didn't report information to 2260 * calculate max_sectors_1. So the number ended up as zero always. 2261 */ 2262 tmp_sectors = 0; 2263 max_sectors_1 = (1 << sc->ctrl_info->stripe_sz_ops.min) * 2264 sc->ctrl_info->max_strips_per_io; 2265 max_sectors_2 = sc->ctrl_info->max_request_size; 2266 tmp_sectors = min(max_sectors_1, max_sectors_2); 2267 sc->max_sectors_per_req = sc->max_num_sge * MRSAS_PAGE_SIZE / 512; 2268 2269 if (tmp_sectors && (sc->max_sectors_per_req > tmp_sectors)) 2270 sc->max_sectors_per_req = tmp_sectors; 2271 2272 sc->disableOnlineCtrlReset = 2273 sc->ctrl_info->properties.OnOffProperties.disableOnlineCtrlReset; 2274 sc->UnevenSpanSupport = 2275 sc->ctrl_info->adapterOperations2.supportUnevenSpans; 2276 if (sc->UnevenSpanSupport) { 2277 device_printf(sc->mrsas_dev, "FW supports: UnevenSpanSupport=%x\n\n", 2278 sc->UnevenSpanSupport); 2279 2280 if (MR_ValidateMapInfo(sc)) 2281 sc->fast_path_io = 1; 2282 else 2283 sc->fast_path_io = 0; 2284 } 2285 return (0); 2286 } 2287 2288 /* 2289 * mrsas_init_adapter: Initializes the adapter/controller 2290 * input: Adapter soft state 2291 * 2292 * Prepares for the issuing of the IOC Init cmd to FW for initializing the 2293 * ROC/controller. The FW register is read to determined the number of 2294 * commands that is supported. All memory allocations for IO is based on 2295 * max_cmd. Appropriate calculations are performed in this function. 2296 */ 2297 int 2298 mrsas_init_adapter(struct mrsas_softc *sc) 2299 { 2300 uint32_t status; 2301 u_int32_t max_cmd, scratch_pad_2; 2302 int ret; 2303 int i = 0; 2304 2305 /* Read FW status register */ 2306 status = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_scratch_pad)); 2307 2308 /* Get operational params from status register */ 2309 sc->max_fw_cmds = status & MRSAS_FWSTATE_MAXCMD_MASK; 2310 2311 /* Decrement the max supported by 1, to correlate with FW */ 2312 sc->max_fw_cmds = sc->max_fw_cmds - 1; 2313 max_cmd = sc->max_fw_cmds; 2314 2315 /* Determine allocation size of command frames */ 2316 sc->reply_q_depth = ((max_cmd + 1 + 15) / 16 * 16) * 2; 2317 sc->request_alloc_sz = sizeof(MRSAS_REQUEST_DESCRIPTOR_UNION) * max_cmd; 2318 sc->reply_alloc_sz = sizeof(MPI2_REPLY_DESCRIPTORS_UNION) * (sc->reply_q_depth); 2319 sc->io_frames_alloc_sz = MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE + (MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE * (max_cmd + 1)); 2320 scratch_pad_2 = mrsas_read_reg(sc, offsetof(mrsas_reg_set, 2321 outbound_scratch_pad_2)); 2322 /* 2323 * If scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_UNITS_MASK is set, 2324 * Firmware support extended IO chain frame which is 4 time more 2325 * than legacy Firmware. Legacy Firmware - Frame size is (8 * 128) = 2326 * 1K 1M IO Firmware - Frame size is (8 * 128 * 4) = 4K 2327 */ 2328 if (scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_UNITS_MASK) 2329 sc->max_chain_frame_sz = 2330 ((scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_MASK) >> 5) 2331 * MEGASAS_1MB_IO; 2332 else 2333 sc->max_chain_frame_sz = 2334 ((scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_MASK) >> 5) 2335 * MEGASAS_256K_IO; 2336 2337 sc->chain_frames_alloc_sz = sc->max_chain_frame_sz * max_cmd; 2338 sc->max_sge_in_main_msg = (MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE - 2339 offsetof(MRSAS_RAID_SCSI_IO_REQUEST, SGL)) / 16; 2340 2341 sc->max_sge_in_chain = sc->max_chain_frame_sz / sizeof(MPI2_SGE_IO_UNION); 2342 sc->max_num_sge = sc->max_sge_in_main_msg + sc->max_sge_in_chain - 2; 2343 2344 mrsas_dprint(sc, MRSAS_INFO, "Avago Debug: MAX sge 0x%X MAX chain frame size 0x%X \n", 2345 sc->max_num_sge, sc->max_chain_frame_sz); 2346 2347 /* Used for pass thru MFI frame (DCMD) */ 2348 sc->chain_offset_mfi_pthru = offsetof(MRSAS_RAID_SCSI_IO_REQUEST, SGL) / 16; 2349 2350 sc->chain_offset_io_request = (MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE - 2351 sizeof(MPI2_SGE_IO_UNION)) / 16; 2352 2353 int count = sc->msix_vectors > 0 ? sc->msix_vectors : 1; 2354 2355 for (i = 0; i < count; i++) 2356 sc->last_reply_idx[i] = 0; 2357 2358 ret = mrsas_alloc_mem(sc); 2359 if (ret != SUCCESS) 2360 return (ret); 2361 2362 ret = mrsas_alloc_mpt_cmds(sc); 2363 if (ret != SUCCESS) 2364 return (ret); 2365 2366 ret = mrsas_ioc_init(sc); 2367 if (ret != SUCCESS) 2368 return (ret); 2369 2370 return (0); 2371 } 2372 2373 /* 2374 * mrsas_alloc_ioc_cmd: Allocates memory for IOC Init command 2375 * input: Adapter soft state 2376 * 2377 * Allocates for the IOC Init cmd to FW to initialize the ROC/controller. 2378 */ 2379 int 2380 mrsas_alloc_ioc_cmd(struct mrsas_softc *sc) 2381 { 2382 int ioc_init_size; 2383 2384 /* Allocate IOC INIT command */ 2385 ioc_init_size = 1024 + sizeof(MPI2_IOC_INIT_REQUEST); 2386 if (bus_dma_tag_create(sc->mrsas_parent_tag, 2387 1, 0, 2388 BUS_SPACE_MAXADDR_32BIT, 2389 BUS_SPACE_MAXADDR, 2390 NULL, NULL, 2391 ioc_init_size, 2392 1, 2393 ioc_init_size, 2394 BUS_DMA_ALLOCNOW, 2395 NULL, NULL, 2396 &sc->ioc_init_tag)) { 2397 device_printf(sc->mrsas_dev, "Cannot allocate ioc init tag\n"); 2398 return (ENOMEM); 2399 } 2400 if (bus_dmamem_alloc(sc->ioc_init_tag, (void **)&sc->ioc_init_mem, 2401 BUS_DMA_NOWAIT, &sc->ioc_init_dmamap)) { 2402 device_printf(sc->mrsas_dev, "Cannot allocate ioc init cmd mem\n"); 2403 return (ENOMEM); 2404 } 2405 bzero(sc->ioc_init_mem, ioc_init_size); 2406 if (bus_dmamap_load(sc->ioc_init_tag, sc->ioc_init_dmamap, 2407 sc->ioc_init_mem, ioc_init_size, mrsas_addr_cb, 2408 &sc->ioc_init_phys_mem, BUS_DMA_NOWAIT)) { 2409 device_printf(sc->mrsas_dev, "Cannot load ioc init cmd mem\n"); 2410 return (ENOMEM); 2411 } 2412 return (0); 2413 } 2414 2415 /* 2416 * mrsas_free_ioc_cmd: Allocates memory for IOC Init command 2417 * input: Adapter soft state 2418 * 2419 * Deallocates memory of the IOC Init cmd. 2420 */ 2421 void 2422 mrsas_free_ioc_cmd(struct mrsas_softc *sc) 2423 { 2424 if (sc->ioc_init_phys_mem) 2425 bus_dmamap_unload(sc->ioc_init_tag, sc->ioc_init_dmamap); 2426 if (sc->ioc_init_mem != NULL) 2427 bus_dmamem_free(sc->ioc_init_tag, sc->ioc_init_mem, sc->ioc_init_dmamap); 2428 if (sc->ioc_init_tag != NULL) 2429 bus_dma_tag_destroy(sc->ioc_init_tag); 2430 } 2431 2432 /* 2433 * mrsas_ioc_init: Sends IOC Init command to FW 2434 * input: Adapter soft state 2435 * 2436 * Issues the IOC Init cmd to FW to initialize the ROC/controller. 2437 */ 2438 int 2439 mrsas_ioc_init(struct mrsas_softc *sc) 2440 { 2441 struct mrsas_init_frame *init_frame; 2442 pMpi2IOCInitRequest_t IOCInitMsg; 2443 MRSAS_REQUEST_DESCRIPTOR_UNION req_desc; 2444 u_int8_t max_wait = MRSAS_IOC_INIT_WAIT_TIME; 2445 bus_addr_t phys_addr; 2446 int i, retcode = 0; 2447 u_int32_t scratch_pad_2; 2448 2449 /* Allocate memory for the IOC INIT command */ 2450 if (mrsas_alloc_ioc_cmd(sc)) { 2451 device_printf(sc->mrsas_dev, "Cannot allocate IOC command.\n"); 2452 return (1); 2453 } 2454 2455 if (!sc->block_sync_cache) { 2456 scratch_pad_2 = mrsas_read_reg(sc, offsetof(mrsas_reg_set, 2457 outbound_scratch_pad_2)); 2458 sc->fw_sync_cache_support = (scratch_pad_2 & 2459 MR_CAN_HANDLE_SYNC_CACHE_OFFSET) ? 1 : 0; 2460 } 2461 2462 IOCInitMsg = (pMpi2IOCInitRequest_t)(((char *)sc->ioc_init_mem) + 1024); 2463 IOCInitMsg->Function = MPI2_FUNCTION_IOC_INIT; 2464 IOCInitMsg->WhoInit = MPI2_WHOINIT_HOST_DRIVER; 2465 IOCInitMsg->MsgVersion = MPI2_VERSION; 2466 IOCInitMsg->HeaderVersion = MPI2_HEADER_VERSION; 2467 IOCInitMsg->SystemRequestFrameSize = MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE / 4; 2468 IOCInitMsg->ReplyDescriptorPostQueueDepth = sc->reply_q_depth; 2469 IOCInitMsg->ReplyDescriptorPostQueueAddress = sc->reply_desc_phys_addr; 2470 IOCInitMsg->SystemRequestFrameBaseAddress = sc->io_request_phys_addr; 2471 IOCInitMsg->HostMSIxVectors = (sc->msix_vectors > 0 ? sc->msix_vectors : 0); 2472 2473 init_frame = (struct mrsas_init_frame *)sc->ioc_init_mem; 2474 init_frame->cmd = MFI_CMD_INIT; 2475 init_frame->cmd_status = 0xFF; 2476 init_frame->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE; 2477 2478 /* driver support Extended MSIX */ 2479 if (sc->mrsas_gen3_ctrl) { 2480 init_frame->driver_operations. 2481 mfi_capabilities.support_additional_msix = 1; 2482 } 2483 if (sc->verbuf_mem) { 2484 snprintf((char *)sc->verbuf_mem, strlen(MRSAS_VERSION) + 2, "%s\n", 2485 MRSAS_VERSION); 2486 init_frame->driver_ver_lo = (bus_addr_t)sc->verbuf_phys_addr; 2487 init_frame->driver_ver_hi = 0; 2488 } 2489 init_frame->driver_operations.mfi_capabilities.support_ndrive_r1_lb = 1; 2490 init_frame->driver_operations.mfi_capabilities.support_max_255lds = 1; 2491 init_frame->driver_operations.mfi_capabilities.security_protocol_cmds_fw = 1; 2492 if (sc->max_chain_frame_sz > MEGASAS_CHAIN_FRAME_SZ_MIN) 2493 init_frame->driver_operations.mfi_capabilities.support_ext_io_size = 1; 2494 phys_addr = (bus_addr_t)sc->ioc_init_phys_mem + 1024; 2495 init_frame->queue_info_new_phys_addr_lo = phys_addr; 2496 init_frame->data_xfer_len = sizeof(Mpi2IOCInitRequest_t); 2497 2498 req_desc.addr.Words = (bus_addr_t)sc->ioc_init_phys_mem; 2499 req_desc.MFAIo.RequestFlags = 2500 (MRSAS_REQ_DESCRIPT_FLAGS_MFA << MRSAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 2501 2502 mrsas_disable_intr(sc); 2503 mrsas_dprint(sc, MRSAS_OCR, "Issuing IOC INIT command to FW.\n"); 2504 mrsas_fire_cmd(sc, req_desc.addr.u.low, req_desc.addr.u.high); 2505 2506 /* 2507 * Poll response timer to wait for Firmware response. While this 2508 * timer with the DELAY call could block CPU, the time interval for 2509 * this is only 1 millisecond. 2510 */ 2511 if (init_frame->cmd_status == 0xFF) { 2512 for (i = 0; i < (max_wait * 1000); i++) { 2513 if (init_frame->cmd_status == 0xFF) 2514 DELAY(1000); 2515 else 2516 break; 2517 } 2518 } 2519 if (init_frame->cmd_status == 0) 2520 mrsas_dprint(sc, MRSAS_OCR, 2521 "IOC INIT response received from FW.\n"); 2522 else { 2523 if (init_frame->cmd_status == 0xFF) 2524 device_printf(sc->mrsas_dev, "IOC Init timed out after %d seconds.\n", max_wait); 2525 else 2526 device_printf(sc->mrsas_dev, "IOC Init failed, status = 0x%x\n", init_frame->cmd_status); 2527 retcode = 1; 2528 } 2529 2530 mrsas_free_ioc_cmd(sc); 2531 return (retcode); 2532 } 2533 2534 /* 2535 * mrsas_alloc_mpt_cmds: Allocates the command packets 2536 * input: Adapter instance soft state 2537 * 2538 * This function allocates the internal commands for IOs. Each command that is 2539 * issued to FW is wrapped in a local data structure called mrsas_mpt_cmd. An 2540 * array is allocated with mrsas_mpt_cmd context. The free commands are 2541 * maintained in a linked list (cmd pool). SMID value range is from 1 to 2542 * max_fw_cmds. 2543 */ 2544 int 2545 mrsas_alloc_mpt_cmds(struct mrsas_softc *sc) 2546 { 2547 int i, j; 2548 u_int32_t max_cmd, count; 2549 struct mrsas_mpt_cmd *cmd; 2550 pMpi2ReplyDescriptorsUnion_t reply_desc; 2551 u_int32_t offset, chain_offset, sense_offset; 2552 bus_addr_t io_req_base_phys, chain_frame_base_phys, sense_base_phys; 2553 u_int8_t *io_req_base, *chain_frame_base, *sense_base; 2554 2555 max_cmd = sc->max_fw_cmds; 2556 2557 sc->req_desc = malloc(sc->request_alloc_sz, M_MRSAS, M_NOWAIT); 2558 if (!sc->req_desc) { 2559 device_printf(sc->mrsas_dev, "Out of memory, cannot alloc req desc\n"); 2560 return (ENOMEM); 2561 } 2562 memset(sc->req_desc, 0, sc->request_alloc_sz); 2563 2564 /* 2565 * sc->mpt_cmd_list is an array of struct mrsas_mpt_cmd pointers. 2566 * Allocate the dynamic array first and then allocate individual 2567 * commands. 2568 */ 2569 sc->mpt_cmd_list = malloc(sizeof(struct mrsas_mpt_cmd *) * max_cmd, M_MRSAS, M_NOWAIT); 2570 if (!sc->mpt_cmd_list) { 2571 device_printf(sc->mrsas_dev, "Cannot alloc memory for mpt_cmd_list.\n"); 2572 return (ENOMEM); 2573 } 2574 memset(sc->mpt_cmd_list, 0, sizeof(struct mrsas_mpt_cmd *) * max_cmd); 2575 for (i = 0; i < max_cmd; i++) { 2576 sc->mpt_cmd_list[i] = malloc(sizeof(struct mrsas_mpt_cmd), 2577 M_MRSAS, M_NOWAIT); 2578 if (!sc->mpt_cmd_list[i]) { 2579 for (j = 0; j < i; j++) 2580 free(sc->mpt_cmd_list[j], M_MRSAS); 2581 free(sc->mpt_cmd_list, M_MRSAS); 2582 sc->mpt_cmd_list = NULL; 2583 return (ENOMEM); 2584 } 2585 } 2586 2587 io_req_base = (u_int8_t *)sc->io_request_mem + MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE; 2588 io_req_base_phys = (bus_addr_t)sc->io_request_phys_addr + MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE; 2589 chain_frame_base = (u_int8_t *)sc->chain_frame_mem; 2590 chain_frame_base_phys = (bus_addr_t)sc->chain_frame_phys_addr; 2591 sense_base = (u_int8_t *)sc->sense_mem; 2592 sense_base_phys = (bus_addr_t)sc->sense_phys_addr; 2593 for (i = 0; i < max_cmd; i++) { 2594 cmd = sc->mpt_cmd_list[i]; 2595 offset = MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE * i; 2596 chain_offset = sc->max_chain_frame_sz * i; 2597 sense_offset = MRSAS_SENSE_LEN * i; 2598 memset(cmd, 0, sizeof(struct mrsas_mpt_cmd)); 2599 cmd->index = i + 1; 2600 cmd->ccb_ptr = NULL; 2601 callout_init_mtx(&cmd->cm_callout, &sc->sim_lock, 0); 2602 cmd->sync_cmd_idx = (u_int32_t)MRSAS_ULONG_MAX; 2603 cmd->sc = sc; 2604 cmd->io_request = (MRSAS_RAID_SCSI_IO_REQUEST *) (io_req_base + offset); 2605 memset(cmd->io_request, 0, sizeof(MRSAS_RAID_SCSI_IO_REQUEST)); 2606 cmd->io_request_phys_addr = io_req_base_phys + offset; 2607 cmd->chain_frame = (MPI2_SGE_IO_UNION *) (chain_frame_base + chain_offset); 2608 cmd->chain_frame_phys_addr = chain_frame_base_phys + chain_offset; 2609 cmd->sense = sense_base + sense_offset; 2610 cmd->sense_phys_addr = sense_base_phys + sense_offset; 2611 if (bus_dmamap_create(sc->data_tag, 0, &cmd->data_dmamap)) { 2612 return (FAIL); 2613 } 2614 TAILQ_INSERT_TAIL(&(sc->mrsas_mpt_cmd_list_head), cmd, next); 2615 } 2616 2617 /* Initialize reply descriptor array to 0xFFFFFFFF */ 2618 reply_desc = sc->reply_desc_mem; 2619 count = sc->msix_vectors > 0 ? sc->msix_vectors : 1; 2620 for (i = 0; i < sc->reply_q_depth * count; i++, reply_desc++) { 2621 reply_desc->Words = MRSAS_ULONG_MAX; 2622 } 2623 return (0); 2624 } 2625 2626 /* 2627 * mrsas_fire_cmd: Sends command to FW 2628 * input: Adapter softstate 2629 * request descriptor address low 2630 * request descriptor address high 2631 * 2632 * This functions fires the command to Firmware by writing to the 2633 * inbound_low_queue_port and inbound_high_queue_port. 2634 */ 2635 void 2636 mrsas_fire_cmd(struct mrsas_softc *sc, u_int32_t req_desc_lo, 2637 u_int32_t req_desc_hi) 2638 { 2639 mtx_lock(&sc->pci_lock); 2640 mrsas_write_reg(sc, offsetof(mrsas_reg_set, inbound_low_queue_port), 2641 req_desc_lo); 2642 mrsas_write_reg(sc, offsetof(mrsas_reg_set, inbound_high_queue_port), 2643 req_desc_hi); 2644 mtx_unlock(&sc->pci_lock); 2645 } 2646 2647 /* 2648 * mrsas_transition_to_ready: Move FW to Ready state input: 2649 * Adapter instance soft state 2650 * 2651 * During the initialization, FW passes can potentially be in any one of several 2652 * possible states. If the FW in operational, waiting-for-handshake states, 2653 * driver must take steps to bring it to ready state. Otherwise, it has to 2654 * wait for the ready state. 2655 */ 2656 int 2657 mrsas_transition_to_ready(struct mrsas_softc *sc, int ocr) 2658 { 2659 int i; 2660 u_int8_t max_wait; 2661 u_int32_t val, fw_state; 2662 u_int32_t cur_state; 2663 u_int32_t abs_state, curr_abs_state; 2664 2665 val = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_scratch_pad)); 2666 fw_state = val & MFI_STATE_MASK; 2667 max_wait = MRSAS_RESET_WAIT_TIME; 2668 2669 if (fw_state != MFI_STATE_READY) 2670 device_printf(sc->mrsas_dev, "Waiting for FW to come to ready state\n"); 2671 2672 while (fw_state != MFI_STATE_READY) { 2673 abs_state = mrsas_read_reg(sc, offsetof(mrsas_reg_set, outbound_scratch_pad)); 2674 switch (fw_state) { 2675 case MFI_STATE_FAULT: 2676 device_printf(sc->mrsas_dev, "FW is in FAULT state!!\n"); 2677 if (ocr) { 2678 cur_state = MFI_STATE_FAULT; 2679 break; 2680 } else 2681 return -ENODEV; 2682 case MFI_STATE_WAIT_HANDSHAKE: 2683 /* Set the CLR bit in inbound doorbell */ 2684 mrsas_write_reg(sc, offsetof(mrsas_reg_set, doorbell), 2685 MFI_INIT_CLEAR_HANDSHAKE | MFI_INIT_HOTPLUG); 2686 cur_state = MFI_STATE_WAIT_HANDSHAKE; 2687 break; 2688 case MFI_STATE_BOOT_MESSAGE_PENDING: 2689 mrsas_write_reg(sc, offsetof(mrsas_reg_set, doorbell), 2690 MFI_INIT_HOTPLUG); 2691 cur_state = MFI_STATE_BOOT_MESSAGE_PENDING; 2692 break; 2693 case MFI_STATE_OPERATIONAL: 2694 /* 2695 * Bring it to READY state; assuming max wait 10 2696 * secs 2697 */ 2698 mrsas_disable_intr(sc); 2699 mrsas_write_reg(sc, offsetof(mrsas_reg_set, doorbell), MFI_RESET_FLAGS); 2700 for (i = 0; i < max_wait * 1000; i++) { 2701 if (mrsas_read_reg(sc, offsetof(mrsas_reg_set, doorbell)) & 1) 2702 DELAY(1000); 2703 else 2704 break; 2705 } 2706 cur_state = MFI_STATE_OPERATIONAL; 2707 break; 2708 case MFI_STATE_UNDEFINED: 2709 /* 2710 * This state should not last for more than 2 2711 * seconds 2712 */ 2713 cur_state = MFI_STATE_UNDEFINED; 2714 break; 2715 case MFI_STATE_BB_INIT: 2716 cur_state = MFI_STATE_BB_INIT; 2717 break; 2718 case MFI_STATE_FW_INIT: 2719 cur_state = MFI_STATE_FW_INIT; 2720 break; 2721 case MFI_STATE_FW_INIT_2: 2722 cur_state = MFI_STATE_FW_INIT_2; 2723 break; 2724 case MFI_STATE_DEVICE_SCAN: 2725 cur_state = MFI_STATE_DEVICE_SCAN; 2726 break; 2727 case MFI_STATE_FLUSH_CACHE: 2728 cur_state = MFI_STATE_FLUSH_CACHE; 2729 break; 2730 default: 2731 device_printf(sc->mrsas_dev, "Unknown state 0x%x\n", fw_state); 2732 return -ENODEV; 2733 } 2734 2735 /* 2736 * The cur_state should not last for more than max_wait secs 2737 */ 2738 for (i = 0; i < (max_wait * 1000); i++) { 2739 fw_state = (mrsas_read_reg(sc, offsetof(mrsas_reg_set, 2740 outbound_scratch_pad)) & MFI_STATE_MASK); 2741 curr_abs_state = mrsas_read_reg(sc, offsetof(mrsas_reg_set, 2742 outbound_scratch_pad)); 2743 if (abs_state == curr_abs_state) 2744 DELAY(1000); 2745 else 2746 break; 2747 } 2748 2749 /* 2750 * Return error if fw_state hasn't changed after max_wait 2751 */ 2752 if (curr_abs_state == abs_state) { 2753 device_printf(sc->mrsas_dev, "FW state [%d] hasn't changed " 2754 "in %d secs\n", fw_state, max_wait); 2755 return -ENODEV; 2756 } 2757 } 2758 mrsas_dprint(sc, MRSAS_OCR, "FW now in Ready state\n"); 2759 return 0; 2760 } 2761 2762 /* 2763 * mrsas_get_mfi_cmd: Get a cmd from free command pool 2764 * input: Adapter soft state 2765 * 2766 * This function removes an MFI command from the command list. 2767 */ 2768 struct mrsas_mfi_cmd * 2769 mrsas_get_mfi_cmd(struct mrsas_softc *sc) 2770 { 2771 struct mrsas_mfi_cmd *cmd = NULL; 2772 2773 mtx_lock(&sc->mfi_cmd_pool_lock); 2774 if (!TAILQ_EMPTY(&sc->mrsas_mfi_cmd_list_head)) { 2775 cmd = TAILQ_FIRST(&sc->mrsas_mfi_cmd_list_head); 2776 TAILQ_REMOVE(&sc->mrsas_mfi_cmd_list_head, cmd, next); 2777 } 2778 mtx_unlock(&sc->mfi_cmd_pool_lock); 2779 2780 return cmd; 2781 } 2782 2783 /* 2784 * mrsas_ocr_thread: Thread to handle OCR/Kill Adapter. 2785 * input: Adapter Context. 2786 * 2787 * This function will check FW status register and flag do_timeout_reset flag. 2788 * It will do OCR/Kill adapter if FW is in fault state or IO timed out has 2789 * trigger reset. 2790 */ 2791 static void 2792 mrsas_ocr_thread(void *arg) 2793 { 2794 struct mrsas_softc *sc; 2795 u_int32_t fw_status, fw_state; 2796 u_int8_t tm_target_reset_failed = 0; 2797 2798 sc = (struct mrsas_softc *)arg; 2799 2800 mrsas_dprint(sc, MRSAS_TRACE, "%s\n", __func__); 2801 2802 sc->ocr_thread_active = 1; 2803 mtx_lock(&sc->sim_lock); 2804 for (;;) { 2805 /* Sleep for 1 second and check the queue status */ 2806 msleep(&sc->ocr_chan, &sc->sim_lock, PRIBIO, 2807 "mrsas_ocr", sc->mrsas_fw_fault_check_delay * hz); 2808 if (sc->remove_in_progress || 2809 sc->adprecovery == MRSAS_HW_CRITICAL_ERROR) { 2810 mrsas_dprint(sc, MRSAS_OCR, 2811 "Exit due to %s from %s\n", 2812 sc->remove_in_progress ? "Shutdown" : 2813 "Hardware critical error", __func__); 2814 break; 2815 } 2816 fw_status = mrsas_read_reg(sc, 2817 offsetof(mrsas_reg_set, outbound_scratch_pad)); 2818 fw_state = fw_status & MFI_STATE_MASK; 2819 if (fw_state == MFI_STATE_FAULT || sc->do_timedout_reset || 2820 mrsas_atomic_read(&sc->target_reset_outstanding)) { 2821 2822 /* First, freeze further IOs to come to the SIM */ 2823 mrsas_xpt_freeze(sc); 2824 2825 /* If this is an IO timeout then go for target reset */ 2826 if (mrsas_atomic_read(&sc->target_reset_outstanding)) { 2827 device_printf(sc->mrsas_dev, "Initiating Target RESET " 2828 "because of SCSI IO timeout!\n"); 2829 2830 /* Let the remaining IOs to complete */ 2831 msleep(&sc->ocr_chan, &sc->sim_lock, PRIBIO, 2832 "mrsas_reset_targets", 5 * hz); 2833 2834 /* Try to reset the target device */ 2835 if (mrsas_reset_targets(sc) == FAIL) 2836 tm_target_reset_failed = 1; 2837 } 2838 2839 /* If this is a DCMD timeout or FW fault, 2840 * then go for controller reset 2841 */ 2842 if (fw_state == MFI_STATE_FAULT || tm_target_reset_failed || 2843 (sc->do_timedout_reset == MFI_DCMD_TIMEOUT_OCR)) { 2844 if (tm_target_reset_failed) 2845 device_printf(sc->mrsas_dev, "Initiaiting OCR because of " 2846 "TM FAILURE!\n"); 2847 else 2848 device_printf(sc->mrsas_dev, "Initiaiting OCR " 2849 "because of %s!\n", sc->do_timedout_reset ? 2850 "DCMD IO Timeout" : "FW fault"); 2851 2852 mtx_lock_spin(&sc->ioctl_lock); 2853 sc->reset_in_progress = 1; 2854 mtx_unlock_spin(&sc->ioctl_lock); 2855 sc->reset_count++; 2856 2857 /* 2858 * Wait for the AEN task to be completed if it is running. 2859 */ 2860 mtx_unlock(&sc->sim_lock); 2861 taskqueue_drain(sc->ev_tq, &sc->ev_task); 2862 mtx_lock(&sc->sim_lock); 2863 2864 taskqueue_block(sc->ev_tq); 2865 /* Try to reset the controller */ 2866 mrsas_reset_ctrl(sc, sc->do_timedout_reset); 2867 2868 sc->do_timedout_reset = 0; 2869 sc->reset_in_progress = 0; 2870 tm_target_reset_failed = 0; 2871 mrsas_atomic_set(&sc->target_reset_outstanding, 0); 2872 memset(sc->target_reset_pool, 0, 2873 sizeof(sc->target_reset_pool)); 2874 taskqueue_unblock(sc->ev_tq); 2875 } 2876 2877 /* Now allow IOs to come to the SIM */ 2878 mrsas_xpt_release(sc); 2879 } 2880 } 2881 mtx_unlock(&sc->sim_lock); 2882 sc->ocr_thread_active = 0; 2883 mrsas_kproc_exit(0); 2884 } 2885 2886 /* 2887 * mrsas_reset_reply_desc: Reset Reply descriptor as part of OCR. 2888 * input: Adapter Context. 2889 * 2890 * This function will clear reply descriptor so that post OCR driver and FW will 2891 * lost old history. 2892 */ 2893 void 2894 mrsas_reset_reply_desc(struct mrsas_softc *sc) 2895 { 2896 int i, count; 2897 pMpi2ReplyDescriptorsUnion_t reply_desc; 2898 2899 count = sc->msix_vectors > 0 ? sc->msix_vectors : 1; 2900 for (i = 0; i < count; i++) 2901 sc->last_reply_idx[i] = 0; 2902 2903 reply_desc = sc->reply_desc_mem; 2904 for (i = 0; i < sc->reply_q_depth; i++, reply_desc++) { 2905 reply_desc->Words = MRSAS_ULONG_MAX; 2906 } 2907 } 2908 2909 /* 2910 * mrsas_reset_ctrl: Core function to OCR/Kill adapter. 2911 * input: Adapter Context. 2912 * 2913 * This function will run from thread context so that it can sleep. 1. Do not 2914 * handle OCR if FW is in HW critical error. 2. Wait for outstanding command 2915 * to complete for 180 seconds. 3. If #2 does not find any outstanding 2916 * command Controller is in working state, so skip OCR. Otherwise, do 2917 * OCR/kill Adapter based on flag disableOnlineCtrlReset. 4. Start of the 2918 * OCR, return all SCSI command back to CAM layer which has ccb_ptr. 5. Post 2919 * OCR, Re-fire Management command and move Controller to Operation state. 2920 */ 2921 int 2922 mrsas_reset_ctrl(struct mrsas_softc *sc, u_int8_t reset_reason) 2923 { 2924 int retval = SUCCESS, i, j, retry = 0; 2925 u_int32_t host_diag, abs_state, status_reg, reset_adapter; 2926 union ccb *ccb; 2927 struct mrsas_mfi_cmd *mfi_cmd; 2928 struct mrsas_mpt_cmd *mpt_cmd; 2929 union mrsas_evt_class_locale class_locale; 2930 MRSAS_REQUEST_DESCRIPTOR_UNION *req_desc; 2931 2932 if (sc->adprecovery == MRSAS_HW_CRITICAL_ERROR) { 2933 device_printf(sc->mrsas_dev, 2934 "mrsas: Hardware critical error, returning FAIL.\n"); 2935 return FAIL; 2936 } 2937 mrsas_set_bit(MRSAS_FUSION_IN_RESET, &sc->reset_flags); 2938 sc->adprecovery = MRSAS_ADPRESET_SM_INFAULT; 2939 mrsas_disable_intr(sc); 2940 msleep(&sc->ocr_chan, &sc->sim_lock, PRIBIO, "mrsas_ocr", 2941 sc->mrsas_fw_fault_check_delay * hz); 2942 2943 /* First try waiting for commands to complete */ 2944 if (mrsas_wait_for_outstanding(sc, reset_reason)) { 2945 mrsas_dprint(sc, MRSAS_OCR, 2946 "resetting adapter from %s.\n", 2947 __func__); 2948 /* Now return commands back to the CAM layer */ 2949 mtx_unlock(&sc->sim_lock); 2950 for (i = 0; i < sc->max_fw_cmds; i++) { 2951 mpt_cmd = sc->mpt_cmd_list[i]; 2952 if (mpt_cmd->ccb_ptr) { 2953 ccb = (union ccb *)(mpt_cmd->ccb_ptr); 2954 ccb->ccb_h.status = CAM_SCSI_BUS_RESET; 2955 mrsas_cmd_done(sc, mpt_cmd); 2956 mrsas_atomic_dec(&sc->fw_outstanding); 2957 } 2958 } 2959 mtx_lock(&sc->sim_lock); 2960 2961 status_reg = mrsas_read_reg(sc, offsetof(mrsas_reg_set, 2962 outbound_scratch_pad)); 2963 abs_state = status_reg & MFI_STATE_MASK; 2964 reset_adapter = status_reg & MFI_RESET_ADAPTER; 2965 if (sc->disableOnlineCtrlReset || 2966 (abs_state == MFI_STATE_FAULT && !reset_adapter)) { 2967 /* Reset not supported, kill adapter */ 2968 mrsas_dprint(sc, MRSAS_OCR, "Reset not supported, killing adapter.\n"); 2969 mrsas_kill_hba(sc); 2970 retval = FAIL; 2971 goto out; 2972 } 2973 /* Now try to reset the chip */ 2974 for (i = 0; i < MRSAS_FUSION_MAX_RESET_TRIES; i++) { 2975 mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset), 2976 MPI2_WRSEQ_FLUSH_KEY_VALUE); 2977 mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset), 2978 MPI2_WRSEQ_1ST_KEY_VALUE); 2979 mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset), 2980 MPI2_WRSEQ_2ND_KEY_VALUE); 2981 mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset), 2982 MPI2_WRSEQ_3RD_KEY_VALUE); 2983 mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset), 2984 MPI2_WRSEQ_4TH_KEY_VALUE); 2985 mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset), 2986 MPI2_WRSEQ_5TH_KEY_VALUE); 2987 mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_seq_offset), 2988 MPI2_WRSEQ_6TH_KEY_VALUE); 2989 2990 /* Check that the diag write enable (DRWE) bit is on */ 2991 host_diag = mrsas_read_reg(sc, offsetof(mrsas_reg_set, 2992 fusion_host_diag)); 2993 retry = 0; 2994 while (!(host_diag & HOST_DIAG_WRITE_ENABLE)) { 2995 DELAY(100 * 1000); 2996 host_diag = mrsas_read_reg(sc, offsetof(mrsas_reg_set, 2997 fusion_host_diag)); 2998 if (retry++ == 100) { 2999 mrsas_dprint(sc, MRSAS_OCR, 3000 "Host diag unlock failed!\n"); 3001 break; 3002 } 3003 } 3004 if (!(host_diag & HOST_DIAG_WRITE_ENABLE)) 3005 continue; 3006 3007 /* Send chip reset command */ 3008 mrsas_write_reg(sc, offsetof(mrsas_reg_set, fusion_host_diag), 3009 host_diag | HOST_DIAG_RESET_ADAPTER); 3010 DELAY(3000 * 1000); 3011 3012 /* Make sure reset adapter bit is cleared */ 3013 host_diag = mrsas_read_reg(sc, offsetof(mrsas_reg_set, 3014 fusion_host_diag)); 3015 retry = 0; 3016 while (host_diag & HOST_DIAG_RESET_ADAPTER) { 3017 DELAY(100 * 1000); 3018 host_diag = mrsas_read_reg(sc, offsetof(mrsas_reg_set, 3019 fusion_host_diag)); 3020 if (retry++ == 1000) { 3021 mrsas_dprint(sc, MRSAS_OCR, 3022 "Diag reset adapter never cleared!\n"); 3023 break; 3024 } 3025 } 3026 if (host_diag & HOST_DIAG_RESET_ADAPTER) 3027 continue; 3028 3029 abs_state = mrsas_read_reg(sc, offsetof(mrsas_reg_set, 3030 outbound_scratch_pad)) & MFI_STATE_MASK; 3031 retry = 0; 3032 3033 while ((abs_state <= MFI_STATE_FW_INIT) && (retry++ < 1000)) { 3034 DELAY(100 * 1000); 3035 abs_state = mrsas_read_reg(sc, offsetof(mrsas_reg_set, 3036 outbound_scratch_pad)) & MFI_STATE_MASK; 3037 } 3038 if (abs_state <= MFI_STATE_FW_INIT) { 3039 mrsas_dprint(sc, MRSAS_OCR, "firmware state < MFI_STATE_FW_INIT," 3040 " state = 0x%x\n", abs_state); 3041 continue; 3042 } 3043 /* Wait for FW to become ready */ 3044 if (mrsas_transition_to_ready(sc, 1)) { 3045 mrsas_dprint(sc, MRSAS_OCR, 3046 "mrsas: Failed to transition controller to ready.\n"); 3047 continue; 3048 } 3049 mrsas_reset_reply_desc(sc); 3050 if (mrsas_ioc_init(sc)) { 3051 mrsas_dprint(sc, MRSAS_OCR, "mrsas_ioc_init() failed!\n"); 3052 continue; 3053 } 3054 for (j = 0; j < sc->max_fw_cmds; j++) { 3055 mpt_cmd = sc->mpt_cmd_list[j]; 3056 if (mpt_cmd->sync_cmd_idx != (u_int32_t)MRSAS_ULONG_MAX) { 3057 mfi_cmd = sc->mfi_cmd_list[mpt_cmd->sync_cmd_idx]; 3058 /* If not an IOCTL then release the command else re-fire */ 3059 if (!mfi_cmd->sync_cmd) { 3060 mrsas_release_mfi_cmd(mfi_cmd); 3061 } else { 3062 req_desc = mrsas_get_request_desc(sc, 3063 mfi_cmd->cmd_id.context.smid - 1); 3064 mrsas_dprint(sc, MRSAS_OCR, 3065 "Re-fire command DCMD opcode 0x%x index %d\n ", 3066 mfi_cmd->frame->dcmd.opcode, j); 3067 if (!req_desc) 3068 device_printf(sc->mrsas_dev, 3069 "Cannot build MPT cmd.\n"); 3070 else 3071 mrsas_fire_cmd(sc, req_desc->addr.u.low, 3072 req_desc->addr.u.high); 3073 } 3074 } 3075 } 3076 3077 /* Reset load balance info */ 3078 memset(sc->load_balance_info, 0, 3079 sizeof(LD_LOAD_BALANCE_INFO) * MAX_LOGICAL_DRIVES_EXT); 3080 3081 if (mrsas_get_ctrl_info(sc)) { 3082 mrsas_kill_hba(sc); 3083 retval = FAIL; 3084 goto out; 3085 } 3086 if (!mrsas_get_map_info(sc)) 3087 mrsas_sync_map_info(sc); 3088 3089 megasas_setup_jbod_map(sc); 3090 3091 mrsas_clear_bit(MRSAS_FUSION_IN_RESET, &sc->reset_flags); 3092 mrsas_enable_intr(sc); 3093 sc->adprecovery = MRSAS_HBA_OPERATIONAL; 3094 3095 /* Register AEN with FW for last sequence number */ 3096 class_locale.members.reserved = 0; 3097 class_locale.members.locale = MR_EVT_LOCALE_ALL; 3098 class_locale.members.class = MR_EVT_CLASS_DEBUG; 3099 3100 mtx_unlock(&sc->sim_lock); 3101 if (mrsas_register_aen(sc, sc->last_seq_num, 3102 class_locale.word)) { 3103 device_printf(sc->mrsas_dev, 3104 "ERROR: AEN registration FAILED from OCR !!! " 3105 "Further events from the controller cannot be notified." 3106 "Either there is some problem in the controller" 3107 "or the controller does not support AEN.\n" 3108 "Please contact to the SUPPORT TEAM if the problem persists\n"); 3109 } 3110 mtx_lock(&sc->sim_lock); 3111 3112 /* Adapter reset completed successfully */ 3113 device_printf(sc->mrsas_dev, "Reset successful\n"); 3114 retval = SUCCESS; 3115 goto out; 3116 } 3117 /* Reset failed, kill the adapter */ 3118 device_printf(sc->mrsas_dev, "Reset failed, killing adapter.\n"); 3119 mrsas_kill_hba(sc); 3120 retval = FAIL; 3121 } else { 3122 mrsas_clear_bit(MRSAS_FUSION_IN_RESET, &sc->reset_flags); 3123 mrsas_enable_intr(sc); 3124 sc->adprecovery = MRSAS_HBA_OPERATIONAL; 3125 } 3126 out: 3127 mrsas_clear_bit(MRSAS_FUSION_IN_RESET, &sc->reset_flags); 3128 mrsas_dprint(sc, MRSAS_OCR, 3129 "Reset Exit with %d.\n", retval); 3130 return retval; 3131 } 3132 3133 /* 3134 * mrsas_kill_hba: Kill HBA when OCR is not supported 3135 * input: Adapter Context. 3136 * 3137 * This function will kill HBA when OCR is not supported. 3138 */ 3139 void 3140 mrsas_kill_hba(struct mrsas_softc *sc) 3141 { 3142 sc->adprecovery = MRSAS_HW_CRITICAL_ERROR; 3143 DELAY(1000 * 1000); 3144 mrsas_dprint(sc, MRSAS_OCR, "%s\n", __func__); 3145 mrsas_write_reg(sc, offsetof(mrsas_reg_set, doorbell), 3146 MFI_STOP_ADP); 3147 /* Flush */ 3148 mrsas_read_reg(sc, offsetof(mrsas_reg_set, doorbell)); 3149 mrsas_complete_outstanding_ioctls(sc); 3150 } 3151 3152 /** 3153 * mrsas_complete_outstanding_ioctls Complete pending IOCTLS after kill_hba 3154 * input: Controller softc 3155 * 3156 * Returns void 3157 */ 3158 void 3159 mrsas_complete_outstanding_ioctls(struct mrsas_softc *sc) 3160 { 3161 int i; 3162 struct mrsas_mpt_cmd *cmd_mpt; 3163 struct mrsas_mfi_cmd *cmd_mfi; 3164 u_int32_t count, MSIxIndex; 3165 3166 count = sc->msix_vectors > 0 ? sc->msix_vectors : 1; 3167 for (i = 0; i < sc->max_fw_cmds; i++) { 3168 cmd_mpt = sc->mpt_cmd_list[i]; 3169 3170 if (cmd_mpt->sync_cmd_idx != (u_int32_t)MRSAS_ULONG_MAX) { 3171 cmd_mfi = sc->mfi_cmd_list[cmd_mpt->sync_cmd_idx]; 3172 if (cmd_mfi->sync_cmd && cmd_mfi->frame->hdr.cmd != MFI_CMD_ABORT) { 3173 for (MSIxIndex = 0; MSIxIndex < count; MSIxIndex++) 3174 mrsas_complete_mptmfi_passthru(sc, cmd_mfi, 3175 cmd_mpt->io_request->RaidContext.status); 3176 } 3177 } 3178 } 3179 } 3180 3181 /* 3182 * mrsas_wait_for_outstanding: Wait for outstanding commands 3183 * input: Adapter Context. 3184 * 3185 * This function will wait for 180 seconds for outstanding commands to be 3186 * completed. 3187 */ 3188 int 3189 mrsas_wait_for_outstanding(struct mrsas_softc *sc, u_int8_t check_reason) 3190 { 3191 int i, outstanding, retval = 0; 3192 u_int32_t fw_state, count, MSIxIndex; 3193 3194 3195 for (i = 0; i < MRSAS_RESET_WAIT_TIME; i++) { 3196 if (sc->remove_in_progress) { 3197 mrsas_dprint(sc, MRSAS_OCR, 3198 "Driver remove or shutdown called.\n"); 3199 retval = 1; 3200 goto out; 3201 } 3202 /* Check if firmware is in fault state */ 3203 fw_state = mrsas_read_reg(sc, offsetof(mrsas_reg_set, 3204 outbound_scratch_pad)) & MFI_STATE_MASK; 3205 if (fw_state == MFI_STATE_FAULT) { 3206 mrsas_dprint(sc, MRSAS_OCR, 3207 "Found FW in FAULT state, will reset adapter.\n"); 3208 count = sc->msix_vectors > 0 ? sc->msix_vectors : 1; 3209 mtx_unlock(&sc->sim_lock); 3210 for (MSIxIndex = 0; MSIxIndex < count; MSIxIndex++) 3211 mrsas_complete_cmd(sc, MSIxIndex); 3212 mtx_lock(&sc->sim_lock); 3213 retval = 1; 3214 goto out; 3215 } 3216 if (check_reason == MFI_DCMD_TIMEOUT_OCR) { 3217 mrsas_dprint(sc, MRSAS_OCR, 3218 "DCMD IO TIMEOUT detected, will reset adapter.\n"); 3219 retval = 1; 3220 goto out; 3221 } 3222 outstanding = mrsas_atomic_read(&sc->fw_outstanding); 3223 if (!outstanding) 3224 goto out; 3225 3226 if (!(i % MRSAS_RESET_NOTICE_INTERVAL)) { 3227 mrsas_dprint(sc, MRSAS_OCR, "[%2d]waiting for %d " 3228 "commands to complete\n", i, outstanding); 3229 count = sc->msix_vectors > 0 ? sc->msix_vectors : 1; 3230 mtx_unlock(&sc->sim_lock); 3231 for (MSIxIndex = 0; MSIxIndex < count; MSIxIndex++) 3232 mrsas_complete_cmd(sc, MSIxIndex); 3233 mtx_lock(&sc->sim_lock); 3234 } 3235 DELAY(1000 * 1000); 3236 } 3237 3238 if (mrsas_atomic_read(&sc->fw_outstanding)) { 3239 mrsas_dprint(sc, MRSAS_OCR, 3240 " pending commands remain after waiting," 3241 " will reset adapter.\n"); 3242 retval = 1; 3243 } 3244 out: 3245 return retval; 3246 } 3247 3248 /* 3249 * mrsas_release_mfi_cmd: Return a cmd to free command pool 3250 * input: Command packet for return to free cmd pool 3251 * 3252 * This function returns the MFI & MPT command to the command list. 3253 */ 3254 void 3255 mrsas_release_mfi_cmd(struct mrsas_mfi_cmd *cmd_mfi) 3256 { 3257 struct mrsas_softc *sc = cmd_mfi->sc; 3258 struct mrsas_mpt_cmd *cmd_mpt; 3259 3260 3261 mtx_lock(&sc->mfi_cmd_pool_lock); 3262 /* 3263 * Release the mpt command (if at all it is allocated 3264 * associated with the mfi command 3265 */ 3266 if (cmd_mfi->cmd_id.context.smid) { 3267 mtx_lock(&sc->mpt_cmd_pool_lock); 3268 /* Get the mpt cmd from mfi cmd frame's smid value */ 3269 cmd_mpt = sc->mpt_cmd_list[cmd_mfi->cmd_id.context.smid-1]; 3270 cmd_mpt->flags = 0; 3271 cmd_mpt->sync_cmd_idx = (u_int32_t)MRSAS_ULONG_MAX; 3272 TAILQ_INSERT_HEAD(&(sc->mrsas_mpt_cmd_list_head), cmd_mpt, next); 3273 mtx_unlock(&sc->mpt_cmd_pool_lock); 3274 } 3275 /* Release the mfi command */ 3276 cmd_mfi->ccb_ptr = NULL; 3277 cmd_mfi->cmd_id.frame_count = 0; 3278 TAILQ_INSERT_HEAD(&(sc->mrsas_mfi_cmd_list_head), cmd_mfi, next); 3279 mtx_unlock(&sc->mfi_cmd_pool_lock); 3280 3281 return; 3282 } 3283 3284 /* 3285 * mrsas_get_controller_info: Returns FW's controller structure 3286 * input: Adapter soft state 3287 * Controller information structure 3288 * 3289 * Issues an internal command (DCMD) to get the FW's controller structure. This 3290 * information is mainly used to find out the maximum IO transfer per command 3291 * supported by the FW. 3292 */ 3293 static int 3294 mrsas_get_ctrl_info(struct mrsas_softc *sc) 3295 { 3296 int retcode = 0; 3297 u_int8_t do_ocr = 1; 3298 struct mrsas_mfi_cmd *cmd; 3299 struct mrsas_dcmd_frame *dcmd; 3300 3301 cmd = mrsas_get_mfi_cmd(sc); 3302 3303 if (!cmd) { 3304 device_printf(sc->mrsas_dev, "Failed to get a free cmd\n"); 3305 return -ENOMEM; 3306 } 3307 dcmd = &cmd->frame->dcmd; 3308 3309 if (mrsas_alloc_ctlr_info_cmd(sc) != SUCCESS) { 3310 device_printf(sc->mrsas_dev, "Cannot allocate get ctlr info cmd\n"); 3311 mrsas_release_mfi_cmd(cmd); 3312 return -ENOMEM; 3313 } 3314 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 3315 3316 dcmd->cmd = MFI_CMD_DCMD; 3317 dcmd->cmd_status = 0xFF; 3318 dcmd->sge_count = 1; 3319 dcmd->flags = MFI_FRAME_DIR_READ; 3320 dcmd->timeout = 0; 3321 dcmd->pad_0 = 0; 3322 dcmd->data_xfer_len = sizeof(struct mrsas_ctrl_info); 3323 dcmd->opcode = MR_DCMD_CTRL_GET_INFO; 3324 dcmd->sgl.sge32[0].phys_addr = sc->ctlr_info_phys_addr; 3325 dcmd->sgl.sge32[0].length = sizeof(struct mrsas_ctrl_info); 3326 3327 if (!sc->mask_interrupts) 3328 retcode = mrsas_issue_blocked_cmd(sc, cmd); 3329 else 3330 retcode = mrsas_issue_polled(sc, cmd); 3331 3332 if (retcode == ETIMEDOUT) 3333 goto dcmd_timeout; 3334 else 3335 memcpy(sc->ctrl_info, sc->ctlr_info_mem, sizeof(struct mrsas_ctrl_info)); 3336 3337 do_ocr = 0; 3338 mrsas_update_ext_vd_details(sc); 3339 3340 sc->use_seqnum_jbod_fp = 3341 sc->ctrl_info->adapterOperations3.useSeqNumJbodFP; 3342 sc->disableOnlineCtrlReset = 3343 sc->ctrl_info->properties.OnOffProperties.disableOnlineCtrlReset; 3344 3345 dcmd_timeout: 3346 mrsas_free_ctlr_info_cmd(sc); 3347 3348 if (do_ocr) 3349 sc->do_timedout_reset = MFI_DCMD_TIMEOUT_OCR; 3350 3351 if (!sc->mask_interrupts) 3352 mrsas_release_mfi_cmd(cmd); 3353 3354 return (retcode); 3355 } 3356 3357 /* 3358 * mrsas_update_ext_vd_details : Update details w.r.t Extended VD 3359 * input: 3360 * sc - Controller's softc 3361 */ 3362 static void 3363 mrsas_update_ext_vd_details(struct mrsas_softc *sc) 3364 { 3365 sc->max256vdSupport = 3366 sc->ctrl_info->adapterOperations3.supportMaxExtLDs; 3367 /* Below is additional check to address future FW enhancement */ 3368 if (sc->ctrl_info->max_lds > 64) 3369 sc->max256vdSupport = 1; 3370 3371 sc->drv_supported_vd_count = MRSAS_MAX_LD_CHANNELS 3372 * MRSAS_MAX_DEV_PER_CHANNEL; 3373 sc->drv_supported_pd_count = MRSAS_MAX_PD_CHANNELS 3374 * MRSAS_MAX_DEV_PER_CHANNEL; 3375 if (sc->max256vdSupport) { 3376 sc->fw_supported_vd_count = MAX_LOGICAL_DRIVES_EXT; 3377 sc->fw_supported_pd_count = MAX_PHYSICAL_DEVICES; 3378 } else { 3379 sc->fw_supported_vd_count = MAX_LOGICAL_DRIVES; 3380 sc->fw_supported_pd_count = MAX_PHYSICAL_DEVICES; 3381 } 3382 3383 sc->old_map_sz = sizeof(MR_FW_RAID_MAP) + 3384 (sizeof(MR_LD_SPAN_MAP) * 3385 (sc->fw_supported_vd_count - 1)); 3386 sc->new_map_sz = sizeof(MR_FW_RAID_MAP_EXT); 3387 sc->drv_map_sz = sizeof(MR_DRV_RAID_MAP) + 3388 (sizeof(MR_LD_SPAN_MAP) * 3389 (sc->drv_supported_vd_count - 1)); 3390 3391 sc->max_map_sz = max(sc->old_map_sz, sc->new_map_sz); 3392 3393 if (sc->max256vdSupport) 3394 sc->current_map_sz = sc->new_map_sz; 3395 else 3396 sc->current_map_sz = sc->old_map_sz; 3397 } 3398 3399 /* 3400 * mrsas_alloc_ctlr_info_cmd: Allocates memory for controller info command 3401 * input: Adapter soft state 3402 * 3403 * Allocates DMAable memory for the controller info internal command. 3404 */ 3405 int 3406 mrsas_alloc_ctlr_info_cmd(struct mrsas_softc *sc) 3407 { 3408 int ctlr_info_size; 3409 3410 /* Allocate get controller info command */ 3411 ctlr_info_size = sizeof(struct mrsas_ctrl_info); 3412 if (bus_dma_tag_create(sc->mrsas_parent_tag, 3413 1, 0, 3414 BUS_SPACE_MAXADDR_32BIT, 3415 BUS_SPACE_MAXADDR, 3416 NULL, NULL, 3417 ctlr_info_size, 3418 1, 3419 ctlr_info_size, 3420 BUS_DMA_ALLOCNOW, 3421 NULL, NULL, 3422 &sc->ctlr_info_tag)) { 3423 device_printf(sc->mrsas_dev, "Cannot allocate ctlr info tag\n"); 3424 return (ENOMEM); 3425 } 3426 if (bus_dmamem_alloc(sc->ctlr_info_tag, (void **)&sc->ctlr_info_mem, 3427 BUS_DMA_NOWAIT, &sc->ctlr_info_dmamap)) { 3428 device_printf(sc->mrsas_dev, "Cannot allocate ctlr info cmd mem\n"); 3429 return (ENOMEM); 3430 } 3431 if (bus_dmamap_load(sc->ctlr_info_tag, sc->ctlr_info_dmamap, 3432 sc->ctlr_info_mem, ctlr_info_size, mrsas_addr_cb, 3433 &sc->ctlr_info_phys_addr, BUS_DMA_NOWAIT)) { 3434 device_printf(sc->mrsas_dev, "Cannot load ctlr info cmd mem\n"); 3435 return (ENOMEM); 3436 } 3437 memset(sc->ctlr_info_mem, 0, ctlr_info_size); 3438 return (0); 3439 } 3440 3441 /* 3442 * mrsas_free_ctlr_info_cmd: Free memory for controller info command 3443 * input: Adapter soft state 3444 * 3445 * Deallocates memory of the get controller info cmd. 3446 */ 3447 void 3448 mrsas_free_ctlr_info_cmd(struct mrsas_softc *sc) 3449 { 3450 if (sc->ctlr_info_phys_addr) 3451 bus_dmamap_unload(sc->ctlr_info_tag, sc->ctlr_info_dmamap); 3452 if (sc->ctlr_info_mem != NULL) 3453 bus_dmamem_free(sc->ctlr_info_tag, sc->ctlr_info_mem, sc->ctlr_info_dmamap); 3454 if (sc->ctlr_info_tag != NULL) 3455 bus_dma_tag_destroy(sc->ctlr_info_tag); 3456 } 3457 3458 /* 3459 * mrsas_issue_polled: Issues a polling command 3460 * inputs: Adapter soft state 3461 * Command packet to be issued 3462 * 3463 * This function is for posting of internal commands to Firmware. MFI requires 3464 * the cmd_status to be set to 0xFF before posting. The maximun wait time of 3465 * the poll response timer is 180 seconds. 3466 */ 3467 int 3468 mrsas_issue_polled(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd) 3469 { 3470 struct mrsas_header *frame_hdr = &cmd->frame->hdr; 3471 u_int8_t max_wait = MRSAS_INTERNAL_CMD_WAIT_TIME; 3472 int i, retcode = SUCCESS; 3473 3474 frame_hdr->cmd_status = 0xFF; 3475 frame_hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE; 3476 3477 /* Issue the frame using inbound queue port */ 3478 if (mrsas_issue_dcmd(sc, cmd)) { 3479 device_printf(sc->mrsas_dev, "Cannot issue DCMD internal command.\n"); 3480 return (1); 3481 } 3482 /* 3483 * Poll response timer to wait for Firmware response. While this 3484 * timer with the DELAY call could block CPU, the time interval for 3485 * this is only 1 millisecond. 3486 */ 3487 if (frame_hdr->cmd_status == 0xFF) { 3488 for (i = 0; i < (max_wait * 1000); i++) { 3489 if (frame_hdr->cmd_status == 0xFF) 3490 DELAY(1000); 3491 else 3492 break; 3493 } 3494 } 3495 if (frame_hdr->cmd_status == 0xFF) { 3496 device_printf(sc->mrsas_dev, "DCMD timed out after %d " 3497 "seconds from %s\n", max_wait, __func__); 3498 device_printf(sc->mrsas_dev, "DCMD opcode 0x%X\n", 3499 cmd->frame->dcmd.opcode); 3500 retcode = ETIMEDOUT; 3501 } 3502 return (retcode); 3503 } 3504 3505 /* 3506 * mrsas_issue_dcmd: Issues a MFI Pass thru cmd 3507 * input: Adapter soft state mfi cmd pointer 3508 * 3509 * This function is called by mrsas_issued_blocked_cmd() and 3510 * mrsas_issued_polled(), to build the MPT command and then fire the command 3511 * to Firmware. 3512 */ 3513 int 3514 mrsas_issue_dcmd(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd) 3515 { 3516 MRSAS_REQUEST_DESCRIPTOR_UNION *req_desc; 3517 3518 req_desc = mrsas_build_mpt_cmd(sc, cmd); 3519 if (!req_desc) { 3520 device_printf(sc->mrsas_dev, "Cannot build MPT cmd.\n"); 3521 return (1); 3522 } 3523 mrsas_fire_cmd(sc, req_desc->addr.u.low, req_desc->addr.u.high); 3524 3525 return (0); 3526 } 3527 3528 /* 3529 * mrsas_build_mpt_cmd: Calls helper function to build Passthru cmd 3530 * input: Adapter soft state mfi cmd to build 3531 * 3532 * This function is called by mrsas_issue_cmd() to build the MPT-MFI passthru 3533 * command and prepares the MPT command to send to Firmware. 3534 */ 3535 MRSAS_REQUEST_DESCRIPTOR_UNION * 3536 mrsas_build_mpt_cmd(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd) 3537 { 3538 MRSAS_REQUEST_DESCRIPTOR_UNION *req_desc; 3539 u_int16_t index; 3540 3541 if (mrsas_build_mptmfi_passthru(sc, cmd)) { 3542 device_printf(sc->mrsas_dev, "Cannot build MPT-MFI passthru cmd.\n"); 3543 return NULL; 3544 } 3545 index = cmd->cmd_id.context.smid; 3546 3547 req_desc = mrsas_get_request_desc(sc, index - 1); 3548 if (!req_desc) 3549 return NULL; 3550 3551 req_desc->addr.Words = 0; 3552 req_desc->SCSIIO.RequestFlags = (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO << MRSAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 3553 3554 req_desc->SCSIIO.SMID = index; 3555 3556 return (req_desc); 3557 } 3558 3559 /* 3560 * mrsas_build_mptmfi_passthru: Builds a MPT MFI Passthru command 3561 * input: Adapter soft state mfi cmd pointer 3562 * 3563 * The MPT command and the io_request are setup as a passthru command. The SGE 3564 * chain address is set to frame_phys_addr of the MFI command. 3565 */ 3566 u_int8_t 3567 mrsas_build_mptmfi_passthru(struct mrsas_softc *sc, struct mrsas_mfi_cmd *mfi_cmd) 3568 { 3569 MPI25_IEEE_SGE_CHAIN64 *mpi25_ieee_chain; 3570 PTR_MRSAS_RAID_SCSI_IO_REQUEST io_req; 3571 struct mrsas_mpt_cmd *mpt_cmd; 3572 struct mrsas_header *frame_hdr = &mfi_cmd->frame->hdr; 3573 3574 mpt_cmd = mrsas_get_mpt_cmd(sc); 3575 if (!mpt_cmd) 3576 return (1); 3577 3578 /* Save the smid. To be used for returning the cmd */ 3579 mfi_cmd->cmd_id.context.smid = mpt_cmd->index; 3580 3581 mpt_cmd->sync_cmd_idx = mfi_cmd->index; 3582 3583 /* 3584 * For cmds where the flag is set, store the flag and check on 3585 * completion. For cmds with this flag, don't call 3586 * mrsas_complete_cmd. 3587 */ 3588 3589 if (frame_hdr->flags & MFI_FRAME_DONT_POST_IN_REPLY_QUEUE) 3590 mpt_cmd->flags = MFI_FRAME_DONT_POST_IN_REPLY_QUEUE; 3591 3592 io_req = mpt_cmd->io_request; 3593 3594 if (sc->mrsas_gen3_ctrl) { 3595 pMpi25IeeeSgeChain64_t sgl_ptr_end = (pMpi25IeeeSgeChain64_t)&io_req->SGL; 3596 3597 sgl_ptr_end += sc->max_sge_in_main_msg - 1; 3598 sgl_ptr_end->Flags = 0; 3599 } 3600 mpi25_ieee_chain = (MPI25_IEEE_SGE_CHAIN64 *) & io_req->SGL.IeeeChain; 3601 3602 io_req->Function = MRSAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST; 3603 io_req->SGLOffset0 = offsetof(MRSAS_RAID_SCSI_IO_REQUEST, SGL) / 4; 3604 io_req->ChainOffset = sc->chain_offset_mfi_pthru; 3605 3606 mpi25_ieee_chain->Address = mfi_cmd->frame_phys_addr; 3607 3608 mpi25_ieee_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT | 3609 MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR; 3610 3611 mpi25_ieee_chain->Length = sc->max_chain_frame_sz; 3612 3613 return (0); 3614 } 3615 3616 /* 3617 * mrsas_issue_blocked_cmd: Synchronous wrapper around regular FW cmds 3618 * input: Adapter soft state Command to be issued 3619 * 3620 * This function waits on an event for the command to be returned from the ISR. 3621 * Max wait time is MRSAS_INTERNAL_CMD_WAIT_TIME secs. Used for issuing 3622 * internal and ioctl commands. 3623 */ 3624 int 3625 mrsas_issue_blocked_cmd(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd) 3626 { 3627 u_int8_t max_wait = MRSAS_INTERNAL_CMD_WAIT_TIME; 3628 unsigned long total_time = 0; 3629 int retcode = SUCCESS; 3630 3631 /* Initialize cmd_status */ 3632 cmd->cmd_status = 0xFF; 3633 3634 /* Build MPT-MFI command for issue to FW */ 3635 if (mrsas_issue_dcmd(sc, cmd)) { 3636 device_printf(sc->mrsas_dev, "Cannot issue DCMD internal command.\n"); 3637 return (1); 3638 } 3639 sc->chan = (void *)&cmd; 3640 3641 while (1) { 3642 if (cmd->cmd_status == 0xFF) { 3643 tsleep((void *)&sc->chan, 0, "mrsas_sleep", hz); 3644 } else 3645 break; 3646 3647 if (!cmd->sync_cmd) { /* cmd->sync will be set for an IOCTL 3648 * command */ 3649 total_time++; 3650 if (total_time >= max_wait) { 3651 device_printf(sc->mrsas_dev, 3652 "Internal command timed out after %d seconds.\n", max_wait); 3653 retcode = 1; 3654 break; 3655 } 3656 } 3657 } 3658 3659 if (cmd->cmd_status == 0xFF) { 3660 device_printf(sc->mrsas_dev, "DCMD timed out after %d " 3661 "seconds from %s\n", max_wait, __func__); 3662 device_printf(sc->mrsas_dev, "DCMD opcode 0x%X\n", 3663 cmd->frame->dcmd.opcode); 3664 retcode = ETIMEDOUT; 3665 } 3666 return (retcode); 3667 } 3668 3669 /* 3670 * mrsas_complete_mptmfi_passthru: Completes a command 3671 * input: @sc: Adapter soft state 3672 * @cmd: Command to be completed 3673 * @status: cmd completion status 3674 * 3675 * This function is called from mrsas_complete_cmd() after an interrupt is 3676 * received from Firmware, and io_request->Function is 3677 * MRSAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST. 3678 */ 3679 void 3680 mrsas_complete_mptmfi_passthru(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd, 3681 u_int8_t status) 3682 { 3683 struct mrsas_header *hdr = &cmd->frame->hdr; 3684 u_int8_t cmd_status = cmd->frame->hdr.cmd_status; 3685 3686 /* Reset the retry counter for future re-tries */ 3687 cmd->retry_for_fw_reset = 0; 3688 3689 if (cmd->ccb_ptr) 3690 cmd->ccb_ptr = NULL; 3691 3692 switch (hdr->cmd) { 3693 case MFI_CMD_INVALID: 3694 device_printf(sc->mrsas_dev, "MFI_CMD_INVALID command.\n"); 3695 break; 3696 case MFI_CMD_PD_SCSI_IO: 3697 case MFI_CMD_LD_SCSI_IO: 3698 /* 3699 * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been 3700 * issued either through an IO path or an IOCTL path. If it 3701 * was via IOCTL, we will send it to internal completion. 3702 */ 3703 if (cmd->sync_cmd) { 3704 cmd->sync_cmd = 0; 3705 mrsas_wakeup(sc, cmd); 3706 break; 3707 } 3708 case MFI_CMD_SMP: 3709 case MFI_CMD_STP: 3710 case MFI_CMD_DCMD: 3711 /* Check for LD map update */ 3712 if ((cmd->frame->dcmd.opcode == MR_DCMD_LD_MAP_GET_INFO) && 3713 (cmd->frame->dcmd.mbox.b[1] == 1)) { 3714 sc->fast_path_io = 0; 3715 mtx_lock(&sc->raidmap_lock); 3716 sc->map_update_cmd = NULL; 3717 if (cmd_status != 0) { 3718 if (cmd_status != MFI_STAT_NOT_FOUND) 3719 device_printf(sc->mrsas_dev, "map sync failed, status=%x\n", cmd_status); 3720 else { 3721 mrsas_release_mfi_cmd(cmd); 3722 mtx_unlock(&sc->raidmap_lock); 3723 break; 3724 } 3725 } else 3726 sc->map_id++; 3727 mrsas_release_mfi_cmd(cmd); 3728 if (MR_ValidateMapInfo(sc)) 3729 sc->fast_path_io = 0; 3730 else 3731 sc->fast_path_io = 1; 3732 mrsas_sync_map_info(sc); 3733 mtx_unlock(&sc->raidmap_lock); 3734 break; 3735 } 3736 if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET_INFO || 3737 cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET) { 3738 sc->mrsas_aen_triggered = 0; 3739 } 3740 /* FW has an updated PD sequence */ 3741 if ((cmd->frame->dcmd.opcode == 3742 MR_DCMD_SYSTEM_PD_MAP_GET_INFO) && 3743 (cmd->frame->dcmd.mbox.b[0] == 1)) { 3744 3745 mtx_lock(&sc->raidmap_lock); 3746 sc->jbod_seq_cmd = NULL; 3747 mrsas_release_mfi_cmd(cmd); 3748 3749 if (cmd_status == MFI_STAT_OK) { 3750 sc->pd_seq_map_id++; 3751 /* Re-register a pd sync seq num cmd */ 3752 if (megasas_sync_pd_seq_num(sc, true)) 3753 sc->use_seqnum_jbod_fp = 0; 3754 } else { 3755 sc->use_seqnum_jbod_fp = 0; 3756 device_printf(sc->mrsas_dev, 3757 "Jbod map sync failed, status=%x\n", cmd_status); 3758 } 3759 mtx_unlock(&sc->raidmap_lock); 3760 break; 3761 } 3762 /* See if got an event notification */ 3763 if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_WAIT) 3764 mrsas_complete_aen(sc, cmd); 3765 else 3766 mrsas_wakeup(sc, cmd); 3767 break; 3768 case MFI_CMD_ABORT: 3769 /* Command issued to abort another cmd return */ 3770 mrsas_complete_abort(sc, cmd); 3771 break; 3772 default: 3773 device_printf(sc->mrsas_dev, "Unknown command completed! [0x%X]\n", hdr->cmd); 3774 break; 3775 } 3776 } 3777 3778 /* 3779 * mrsas_wakeup: Completes an internal command 3780 * input: Adapter soft state 3781 * Command to be completed 3782 * 3783 * In mrsas_issue_blocked_cmd(), after a command is issued to Firmware, a wait 3784 * timer is started. This function is called from 3785 * mrsas_complete_mptmfi_passthru() as it completes the command, to wake up 3786 * from the command wait. 3787 */ 3788 void 3789 mrsas_wakeup(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd) 3790 { 3791 cmd->cmd_status = cmd->frame->io.cmd_status; 3792 3793 if (cmd->cmd_status == 0xFF) 3794 cmd->cmd_status = 0; 3795 3796 sc->chan = (void *)&cmd; 3797 wakeup_one((void *)&sc->chan); 3798 return; 3799 } 3800 3801 /* 3802 * mrsas_shutdown_ctlr: Instructs FW to shutdown the controller input: 3803 * Adapter soft state Shutdown/Hibernate 3804 * 3805 * This function issues a DCMD internal command to Firmware to initiate shutdown 3806 * of the controller. 3807 */ 3808 static void 3809 mrsas_shutdown_ctlr(struct mrsas_softc *sc, u_int32_t opcode) 3810 { 3811 struct mrsas_mfi_cmd *cmd; 3812 struct mrsas_dcmd_frame *dcmd; 3813 3814 if (sc->adprecovery == MRSAS_HW_CRITICAL_ERROR) 3815 return; 3816 3817 cmd = mrsas_get_mfi_cmd(sc); 3818 if (!cmd) { 3819 device_printf(sc->mrsas_dev, "Cannot allocate for shutdown cmd.\n"); 3820 return; 3821 } 3822 if (sc->aen_cmd) 3823 mrsas_issue_blocked_abort_cmd(sc, sc->aen_cmd); 3824 if (sc->map_update_cmd) 3825 mrsas_issue_blocked_abort_cmd(sc, sc->map_update_cmd); 3826 if (sc->jbod_seq_cmd) 3827 mrsas_issue_blocked_abort_cmd(sc, sc->jbod_seq_cmd); 3828 3829 dcmd = &cmd->frame->dcmd; 3830 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 3831 3832 dcmd->cmd = MFI_CMD_DCMD; 3833 dcmd->cmd_status = 0x0; 3834 dcmd->sge_count = 0; 3835 dcmd->flags = MFI_FRAME_DIR_NONE; 3836 dcmd->timeout = 0; 3837 dcmd->pad_0 = 0; 3838 dcmd->data_xfer_len = 0; 3839 dcmd->opcode = opcode; 3840 3841 device_printf(sc->mrsas_dev, "Preparing to shut down controller.\n"); 3842 3843 mrsas_issue_blocked_cmd(sc, cmd); 3844 mrsas_release_mfi_cmd(cmd); 3845 3846 return; 3847 } 3848 3849 /* 3850 * mrsas_flush_cache: Requests FW to flush all its caches input: 3851 * Adapter soft state 3852 * 3853 * This function is issues a DCMD internal command to Firmware to initiate 3854 * flushing of all caches. 3855 */ 3856 static void 3857 mrsas_flush_cache(struct mrsas_softc *sc) 3858 { 3859 struct mrsas_mfi_cmd *cmd; 3860 struct mrsas_dcmd_frame *dcmd; 3861 3862 if (sc->adprecovery == MRSAS_HW_CRITICAL_ERROR) 3863 return; 3864 3865 cmd = mrsas_get_mfi_cmd(sc); 3866 if (!cmd) { 3867 device_printf(sc->mrsas_dev, "Cannot allocate for flush cache cmd.\n"); 3868 return; 3869 } 3870 dcmd = &cmd->frame->dcmd; 3871 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 3872 3873 dcmd->cmd = MFI_CMD_DCMD; 3874 dcmd->cmd_status = 0x0; 3875 dcmd->sge_count = 0; 3876 dcmd->flags = MFI_FRAME_DIR_NONE; 3877 dcmd->timeout = 0; 3878 dcmd->pad_0 = 0; 3879 dcmd->data_xfer_len = 0; 3880 dcmd->opcode = MR_DCMD_CTRL_CACHE_FLUSH; 3881 dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE; 3882 3883 mrsas_issue_blocked_cmd(sc, cmd); 3884 mrsas_release_mfi_cmd(cmd); 3885 3886 return; 3887 } 3888 3889 int 3890 megasas_sync_pd_seq_num(struct mrsas_softc *sc, boolean_t pend) 3891 { 3892 int retcode = 0; 3893 u_int8_t do_ocr = 1; 3894 struct mrsas_mfi_cmd *cmd; 3895 struct mrsas_dcmd_frame *dcmd; 3896 uint32_t pd_seq_map_sz; 3897 struct MR_PD_CFG_SEQ_NUM_SYNC *pd_sync; 3898 bus_addr_t pd_seq_h; 3899 3900 pd_seq_map_sz = sizeof(struct MR_PD_CFG_SEQ_NUM_SYNC) + 3901 (sizeof(struct MR_PD_CFG_SEQ) * 3902 (MAX_PHYSICAL_DEVICES - 1)); 3903 3904 cmd = mrsas_get_mfi_cmd(sc); 3905 if (!cmd) { 3906 device_printf(sc->mrsas_dev, 3907 "Cannot alloc for ld map info cmd.\n"); 3908 return 1; 3909 } 3910 dcmd = &cmd->frame->dcmd; 3911 3912 pd_sync = (void *)sc->jbodmap_mem[(sc->pd_seq_map_id & 1)]; 3913 pd_seq_h = sc->jbodmap_phys_addr[(sc->pd_seq_map_id & 1)]; 3914 if (!pd_sync) { 3915 device_printf(sc->mrsas_dev, 3916 "Failed to alloc mem for jbod map info.\n"); 3917 mrsas_release_mfi_cmd(cmd); 3918 return (ENOMEM); 3919 } 3920 memset(pd_sync, 0, pd_seq_map_sz); 3921 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 3922 dcmd->cmd = MFI_CMD_DCMD; 3923 dcmd->cmd_status = 0xFF; 3924 dcmd->sge_count = 1; 3925 dcmd->timeout = 0; 3926 dcmd->pad_0 = 0; 3927 dcmd->data_xfer_len = (pd_seq_map_sz); 3928 dcmd->opcode = (MR_DCMD_SYSTEM_PD_MAP_GET_INFO); 3929 dcmd->sgl.sge32[0].phys_addr = (pd_seq_h); 3930 dcmd->sgl.sge32[0].length = (pd_seq_map_sz); 3931 3932 if (pend) { 3933 dcmd->mbox.b[0] = MRSAS_DCMD_MBOX_PEND_FLAG; 3934 dcmd->flags = (MFI_FRAME_DIR_WRITE); 3935 sc->jbod_seq_cmd = cmd; 3936 if (mrsas_issue_dcmd(sc, cmd)) { 3937 device_printf(sc->mrsas_dev, 3938 "Fail to send sync map info command.\n"); 3939 return 1; 3940 } else 3941 return 0; 3942 } else 3943 dcmd->flags = MFI_FRAME_DIR_READ; 3944 3945 retcode = mrsas_issue_polled(sc, cmd); 3946 if (retcode == ETIMEDOUT) 3947 goto dcmd_timeout; 3948 3949 if (pd_sync->count > MAX_PHYSICAL_DEVICES) { 3950 device_printf(sc->mrsas_dev, 3951 "driver supports max %d JBOD, but FW reports %d\n", 3952 MAX_PHYSICAL_DEVICES, pd_sync->count); 3953 retcode = -EINVAL; 3954 } 3955 if (!retcode) 3956 sc->pd_seq_map_id++; 3957 do_ocr = 0; 3958 3959 dcmd_timeout: 3960 if (do_ocr) 3961 sc->do_timedout_reset = MFI_DCMD_TIMEOUT_OCR; 3962 3963 return (retcode); 3964 } 3965 3966 /* 3967 * mrsas_get_map_info: Load and validate RAID map input: 3968 * Adapter instance soft state 3969 * 3970 * This function calls mrsas_get_ld_map_info() and MR_ValidateMapInfo() to load 3971 * and validate RAID map. It returns 0 if successful, 1 other- wise. 3972 */ 3973 static int 3974 mrsas_get_map_info(struct mrsas_softc *sc) 3975 { 3976 uint8_t retcode = 0; 3977 3978 sc->fast_path_io = 0; 3979 if (!mrsas_get_ld_map_info(sc)) { 3980 retcode = MR_ValidateMapInfo(sc); 3981 if (retcode == 0) { 3982 sc->fast_path_io = 1; 3983 return 0; 3984 } 3985 } 3986 return 1; 3987 } 3988 3989 /* 3990 * mrsas_get_ld_map_info: Get FW's ld_map structure input: 3991 * Adapter instance soft state 3992 * 3993 * Issues an internal command (DCMD) to get the FW's controller PD list 3994 * structure. 3995 */ 3996 static int 3997 mrsas_get_ld_map_info(struct mrsas_softc *sc) 3998 { 3999 int retcode = 0; 4000 struct mrsas_mfi_cmd *cmd; 4001 struct mrsas_dcmd_frame *dcmd; 4002 void *map; 4003 bus_addr_t map_phys_addr = 0; 4004 4005 cmd = mrsas_get_mfi_cmd(sc); 4006 if (!cmd) { 4007 device_printf(sc->mrsas_dev, 4008 "Cannot alloc for ld map info cmd.\n"); 4009 return 1; 4010 } 4011 dcmd = &cmd->frame->dcmd; 4012 4013 map = (void *)sc->raidmap_mem[(sc->map_id & 1)]; 4014 map_phys_addr = sc->raidmap_phys_addr[(sc->map_id & 1)]; 4015 if (!map) { 4016 device_printf(sc->mrsas_dev, 4017 "Failed to alloc mem for ld map info.\n"); 4018 mrsas_release_mfi_cmd(cmd); 4019 return (ENOMEM); 4020 } 4021 memset(map, 0, sizeof(sc->max_map_sz)); 4022 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 4023 4024 dcmd->cmd = MFI_CMD_DCMD; 4025 dcmd->cmd_status = 0xFF; 4026 dcmd->sge_count = 1; 4027 dcmd->flags = MFI_FRAME_DIR_READ; 4028 dcmd->timeout = 0; 4029 dcmd->pad_0 = 0; 4030 dcmd->data_xfer_len = sc->current_map_sz; 4031 dcmd->opcode = MR_DCMD_LD_MAP_GET_INFO; 4032 dcmd->sgl.sge32[0].phys_addr = map_phys_addr; 4033 dcmd->sgl.sge32[0].length = sc->current_map_sz; 4034 4035 retcode = mrsas_issue_polled(sc, cmd); 4036 if (retcode == ETIMEDOUT) 4037 sc->do_timedout_reset = MFI_DCMD_TIMEOUT_OCR; 4038 4039 return (retcode); 4040 } 4041 4042 /* 4043 * mrsas_sync_map_info: Get FW's ld_map structure input: 4044 * Adapter instance soft state 4045 * 4046 * Issues an internal command (DCMD) to get the FW's controller PD list 4047 * structure. 4048 */ 4049 static int 4050 mrsas_sync_map_info(struct mrsas_softc *sc) 4051 { 4052 int retcode = 0, i; 4053 struct mrsas_mfi_cmd *cmd; 4054 struct mrsas_dcmd_frame *dcmd; 4055 uint32_t size_sync_info, num_lds; 4056 MR_LD_TARGET_SYNC *target_map = NULL; 4057 MR_DRV_RAID_MAP_ALL *map; 4058 MR_LD_RAID *raid; 4059 MR_LD_TARGET_SYNC *ld_sync; 4060 bus_addr_t map_phys_addr = 0; 4061 4062 cmd = mrsas_get_mfi_cmd(sc); 4063 if (!cmd) { 4064 device_printf(sc->mrsas_dev, "Cannot alloc for sync map info cmd\n"); 4065 return ENOMEM; 4066 } 4067 map = sc->ld_drv_map[sc->map_id & 1]; 4068 num_lds = map->raidMap.ldCount; 4069 4070 dcmd = &cmd->frame->dcmd; 4071 size_sync_info = sizeof(MR_LD_TARGET_SYNC) * num_lds; 4072 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 4073 4074 target_map = (MR_LD_TARGET_SYNC *) sc->raidmap_mem[(sc->map_id - 1) & 1]; 4075 memset(target_map, 0, sc->max_map_sz); 4076 4077 map_phys_addr = sc->raidmap_phys_addr[(sc->map_id - 1) & 1]; 4078 4079 ld_sync = (MR_LD_TARGET_SYNC *) target_map; 4080 4081 for (i = 0; i < num_lds; i++, ld_sync++) { 4082 raid = MR_LdRaidGet(i, map); 4083 ld_sync->targetId = MR_GetLDTgtId(i, map); 4084 ld_sync->seqNum = raid->seqNum; 4085 } 4086 4087 dcmd->cmd = MFI_CMD_DCMD; 4088 dcmd->cmd_status = 0xFF; 4089 dcmd->sge_count = 1; 4090 dcmd->flags = MFI_FRAME_DIR_WRITE; 4091 dcmd->timeout = 0; 4092 dcmd->pad_0 = 0; 4093 dcmd->data_xfer_len = sc->current_map_sz; 4094 dcmd->mbox.b[0] = num_lds; 4095 dcmd->mbox.b[1] = MRSAS_DCMD_MBOX_PEND_FLAG; 4096 dcmd->opcode = MR_DCMD_LD_MAP_GET_INFO; 4097 dcmd->sgl.sge32[0].phys_addr = map_phys_addr; 4098 dcmd->sgl.sge32[0].length = sc->current_map_sz; 4099 4100 sc->map_update_cmd = cmd; 4101 if (mrsas_issue_dcmd(sc, cmd)) { 4102 device_printf(sc->mrsas_dev, 4103 "Fail to send sync map info command.\n"); 4104 return (1); 4105 } 4106 return (retcode); 4107 } 4108 4109 /* 4110 * mrsas_get_pd_list: Returns FW's PD list structure input: 4111 * Adapter soft state 4112 * 4113 * Issues an internal command (DCMD) to get the FW's controller PD list 4114 * structure. This information is mainly used to find out about system 4115 * supported by Firmware. 4116 */ 4117 static int 4118 mrsas_get_pd_list(struct mrsas_softc *sc) 4119 { 4120 int retcode = 0, pd_index = 0, pd_count = 0, pd_list_size; 4121 u_int8_t do_ocr = 1; 4122 struct mrsas_mfi_cmd *cmd; 4123 struct mrsas_dcmd_frame *dcmd; 4124 struct MR_PD_LIST *pd_list_mem; 4125 struct MR_PD_ADDRESS *pd_addr; 4126 bus_addr_t pd_list_phys_addr = 0; 4127 struct mrsas_tmp_dcmd *tcmd; 4128 4129 cmd = mrsas_get_mfi_cmd(sc); 4130 if (!cmd) { 4131 device_printf(sc->mrsas_dev, 4132 "Cannot alloc for get PD list cmd\n"); 4133 return 1; 4134 } 4135 dcmd = &cmd->frame->dcmd; 4136 4137 tcmd = malloc(sizeof(struct mrsas_tmp_dcmd), M_MRSAS, M_NOWAIT); 4138 pd_list_size = MRSAS_MAX_PD * sizeof(struct MR_PD_LIST); 4139 if (mrsas_alloc_tmp_dcmd(sc, tcmd, pd_list_size) != SUCCESS) { 4140 device_printf(sc->mrsas_dev, 4141 "Cannot alloc dmamap for get PD list cmd\n"); 4142 mrsas_release_mfi_cmd(cmd); 4143 mrsas_free_tmp_dcmd(tcmd); 4144 free(tcmd, M_MRSAS); 4145 return (ENOMEM); 4146 } else { 4147 pd_list_mem = tcmd->tmp_dcmd_mem; 4148 pd_list_phys_addr = tcmd->tmp_dcmd_phys_addr; 4149 } 4150 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 4151 4152 dcmd->mbox.b[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST; 4153 dcmd->mbox.b[1] = 0; 4154 dcmd->cmd = MFI_CMD_DCMD; 4155 dcmd->cmd_status = 0xFF; 4156 dcmd->sge_count = 1; 4157 dcmd->flags = MFI_FRAME_DIR_READ; 4158 dcmd->timeout = 0; 4159 dcmd->pad_0 = 0; 4160 dcmd->data_xfer_len = MRSAS_MAX_PD * sizeof(struct MR_PD_LIST); 4161 dcmd->opcode = MR_DCMD_PD_LIST_QUERY; 4162 dcmd->sgl.sge32[0].phys_addr = pd_list_phys_addr; 4163 dcmd->sgl.sge32[0].length = MRSAS_MAX_PD * sizeof(struct MR_PD_LIST); 4164 4165 if (!sc->mask_interrupts) 4166 retcode = mrsas_issue_blocked_cmd(sc, cmd); 4167 else 4168 retcode = mrsas_issue_polled(sc, cmd); 4169 4170 if (retcode == ETIMEDOUT) 4171 goto dcmd_timeout; 4172 4173 /* Get the instance PD list */ 4174 pd_count = MRSAS_MAX_PD; 4175 pd_addr = pd_list_mem->addr; 4176 if (pd_list_mem->count < pd_count) { 4177 memset(sc->local_pd_list, 0, 4178 MRSAS_MAX_PD * sizeof(struct mrsas_pd_list)); 4179 for (pd_index = 0; pd_index < pd_list_mem->count; pd_index++) { 4180 sc->local_pd_list[pd_addr->deviceId].tid = pd_addr->deviceId; 4181 sc->local_pd_list[pd_addr->deviceId].driveType = 4182 pd_addr->scsiDevType; 4183 sc->local_pd_list[pd_addr->deviceId].driveState = 4184 MR_PD_STATE_SYSTEM; 4185 pd_addr++; 4186 } 4187 /* 4188 * Use mutext/spinlock if pd_list component size increase more than 4189 * 32 bit. 4190 */ 4191 memcpy(sc->pd_list, sc->local_pd_list, sizeof(sc->local_pd_list)); 4192 do_ocr = 0; 4193 } 4194 dcmd_timeout: 4195 mrsas_free_tmp_dcmd(tcmd); 4196 free(tcmd, M_MRSAS); 4197 4198 if (do_ocr) 4199 sc->do_timedout_reset = MFI_DCMD_TIMEOUT_OCR; 4200 4201 if (!sc->mask_interrupts) 4202 mrsas_release_mfi_cmd(cmd); 4203 4204 return (retcode); 4205 } 4206 4207 /* 4208 * mrsas_get_ld_list: Returns FW's LD list structure input: 4209 * Adapter soft state 4210 * 4211 * Issues an internal command (DCMD) to get the FW's controller PD list 4212 * structure. This information is mainly used to find out about supported by 4213 * the FW. 4214 */ 4215 static int 4216 mrsas_get_ld_list(struct mrsas_softc *sc) 4217 { 4218 int ld_list_size, retcode = 0, ld_index = 0, ids = 0; 4219 u_int8_t do_ocr = 1; 4220 struct mrsas_mfi_cmd *cmd; 4221 struct mrsas_dcmd_frame *dcmd; 4222 struct MR_LD_LIST *ld_list_mem; 4223 bus_addr_t ld_list_phys_addr = 0; 4224 struct mrsas_tmp_dcmd *tcmd; 4225 4226 cmd = mrsas_get_mfi_cmd(sc); 4227 if (!cmd) { 4228 device_printf(sc->mrsas_dev, 4229 "Cannot alloc for get LD list cmd\n"); 4230 return 1; 4231 } 4232 dcmd = &cmd->frame->dcmd; 4233 4234 tcmd = malloc(sizeof(struct mrsas_tmp_dcmd), M_MRSAS, M_NOWAIT); 4235 ld_list_size = sizeof(struct MR_LD_LIST); 4236 if (mrsas_alloc_tmp_dcmd(sc, tcmd, ld_list_size) != SUCCESS) { 4237 device_printf(sc->mrsas_dev, 4238 "Cannot alloc dmamap for get LD list cmd\n"); 4239 mrsas_release_mfi_cmd(cmd); 4240 mrsas_free_tmp_dcmd(tcmd); 4241 free(tcmd, M_MRSAS); 4242 return (ENOMEM); 4243 } else { 4244 ld_list_mem = tcmd->tmp_dcmd_mem; 4245 ld_list_phys_addr = tcmd->tmp_dcmd_phys_addr; 4246 } 4247 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 4248 4249 if (sc->max256vdSupport) 4250 dcmd->mbox.b[0] = 1; 4251 4252 dcmd->cmd = MFI_CMD_DCMD; 4253 dcmd->cmd_status = 0xFF; 4254 dcmd->sge_count = 1; 4255 dcmd->flags = MFI_FRAME_DIR_READ; 4256 dcmd->timeout = 0; 4257 dcmd->data_xfer_len = sizeof(struct MR_LD_LIST); 4258 dcmd->opcode = MR_DCMD_LD_GET_LIST; 4259 dcmd->sgl.sge32[0].phys_addr = ld_list_phys_addr; 4260 dcmd->sgl.sge32[0].length = sizeof(struct MR_LD_LIST); 4261 dcmd->pad_0 = 0; 4262 4263 if (!sc->mask_interrupts) 4264 retcode = mrsas_issue_blocked_cmd(sc, cmd); 4265 else 4266 retcode = mrsas_issue_polled(sc, cmd); 4267 4268 if (retcode == ETIMEDOUT) 4269 goto dcmd_timeout; 4270 4271 #if VD_EXT_DEBUG 4272 printf("Number of LDs %d\n", ld_list_mem->ldCount); 4273 #endif 4274 4275 /* Get the instance LD list */ 4276 if (ld_list_mem->ldCount <= sc->fw_supported_vd_count) { 4277 sc->CurLdCount = ld_list_mem->ldCount; 4278 memset(sc->ld_ids, 0xff, MAX_LOGICAL_DRIVES_EXT); 4279 for (ld_index = 0; ld_index < ld_list_mem->ldCount; ld_index++) { 4280 if (ld_list_mem->ldList[ld_index].state != 0) { 4281 ids = ld_list_mem->ldList[ld_index].ref.ld_context.targetId; 4282 sc->ld_ids[ids] = ld_list_mem->ldList[ld_index].ref.ld_context.targetId; 4283 } 4284 } 4285 do_ocr = 0; 4286 } 4287 dcmd_timeout: 4288 mrsas_free_tmp_dcmd(tcmd); 4289 free(tcmd, M_MRSAS); 4290 4291 if (do_ocr) 4292 sc->do_timedout_reset = MFI_DCMD_TIMEOUT_OCR; 4293 if (!sc->mask_interrupts) 4294 mrsas_release_mfi_cmd(cmd); 4295 4296 return (retcode); 4297 } 4298 4299 /* 4300 * mrsas_alloc_tmp_dcmd: Allocates memory for temporary command input: 4301 * Adapter soft state Temp command Size of alloction 4302 * 4303 * Allocates DMAable memory for a temporary internal command. The allocated 4304 * memory is initialized to all zeros upon successful loading of the dma 4305 * mapped memory. 4306 */ 4307 int 4308 mrsas_alloc_tmp_dcmd(struct mrsas_softc *sc, 4309 struct mrsas_tmp_dcmd *tcmd, int size) 4310 { 4311 if (bus_dma_tag_create(sc->mrsas_parent_tag, 4312 1, 0, 4313 BUS_SPACE_MAXADDR_32BIT, 4314 BUS_SPACE_MAXADDR, 4315 NULL, NULL, 4316 size, 4317 1, 4318 size, 4319 BUS_DMA_ALLOCNOW, 4320 NULL, NULL, 4321 &tcmd->tmp_dcmd_tag)) { 4322 device_printf(sc->mrsas_dev, "Cannot allocate tmp dcmd tag\n"); 4323 return (ENOMEM); 4324 } 4325 if (bus_dmamem_alloc(tcmd->tmp_dcmd_tag, (void **)&tcmd->tmp_dcmd_mem, 4326 BUS_DMA_NOWAIT, &tcmd->tmp_dcmd_dmamap)) { 4327 device_printf(sc->mrsas_dev, "Cannot allocate tmp dcmd mem\n"); 4328 return (ENOMEM); 4329 } 4330 if (bus_dmamap_load(tcmd->tmp_dcmd_tag, tcmd->tmp_dcmd_dmamap, 4331 tcmd->tmp_dcmd_mem, size, mrsas_addr_cb, 4332 &tcmd->tmp_dcmd_phys_addr, BUS_DMA_NOWAIT)) { 4333 device_printf(sc->mrsas_dev, "Cannot load tmp dcmd mem\n"); 4334 return (ENOMEM); 4335 } 4336 memset(tcmd->tmp_dcmd_mem, 0, size); 4337 return (0); 4338 } 4339 4340 /* 4341 * mrsas_free_tmp_dcmd: Free memory for temporary command input: 4342 * temporary dcmd pointer 4343 * 4344 * Deallocates memory of the temporary command for use in the construction of 4345 * the internal DCMD. 4346 */ 4347 void 4348 mrsas_free_tmp_dcmd(struct mrsas_tmp_dcmd *tmp) 4349 { 4350 if (tmp->tmp_dcmd_phys_addr) 4351 bus_dmamap_unload(tmp->tmp_dcmd_tag, tmp->tmp_dcmd_dmamap); 4352 if (tmp->tmp_dcmd_mem != NULL) 4353 bus_dmamem_free(tmp->tmp_dcmd_tag, tmp->tmp_dcmd_mem, tmp->tmp_dcmd_dmamap); 4354 if (tmp->tmp_dcmd_tag != NULL) 4355 bus_dma_tag_destroy(tmp->tmp_dcmd_tag); 4356 } 4357 4358 /* 4359 * mrsas_issue_blocked_abort_cmd: Aborts previously issued cmd input: 4360 * Adapter soft state Previously issued cmd to be aborted 4361 * 4362 * This function is used to abort previously issued commands, such as AEN and 4363 * RAID map sync map commands. The abort command is sent as a DCMD internal 4364 * command and subsequently the driver will wait for a return status. The 4365 * max wait time is MRSAS_INTERNAL_CMD_WAIT_TIME seconds. 4366 */ 4367 static int 4368 mrsas_issue_blocked_abort_cmd(struct mrsas_softc *sc, 4369 struct mrsas_mfi_cmd *cmd_to_abort) 4370 { 4371 struct mrsas_mfi_cmd *cmd; 4372 struct mrsas_abort_frame *abort_fr; 4373 u_int8_t retcode = 0; 4374 unsigned long total_time = 0; 4375 u_int8_t max_wait = MRSAS_INTERNAL_CMD_WAIT_TIME; 4376 4377 cmd = mrsas_get_mfi_cmd(sc); 4378 if (!cmd) { 4379 device_printf(sc->mrsas_dev, "Cannot alloc for abort cmd\n"); 4380 return (1); 4381 } 4382 abort_fr = &cmd->frame->abort; 4383 4384 /* Prepare and issue the abort frame */ 4385 abort_fr->cmd = MFI_CMD_ABORT; 4386 abort_fr->cmd_status = 0xFF; 4387 abort_fr->flags = 0; 4388 abort_fr->abort_context = cmd_to_abort->index; 4389 abort_fr->abort_mfi_phys_addr_lo = cmd_to_abort->frame_phys_addr; 4390 abort_fr->abort_mfi_phys_addr_hi = 0; 4391 4392 cmd->sync_cmd = 1; 4393 cmd->cmd_status = 0xFF; 4394 4395 if (mrsas_issue_dcmd(sc, cmd)) { 4396 device_printf(sc->mrsas_dev, "Fail to send abort command.\n"); 4397 return (1); 4398 } 4399 /* Wait for this cmd to complete */ 4400 sc->chan = (void *)&cmd; 4401 while (1) { 4402 if (cmd->cmd_status == 0xFF) { 4403 tsleep((void *)&sc->chan, 0, "mrsas_sleep", hz); 4404 } else 4405 break; 4406 total_time++; 4407 if (total_time >= max_wait) { 4408 device_printf(sc->mrsas_dev, "Abort cmd timed out after %d sec.\n", max_wait); 4409 retcode = 1; 4410 break; 4411 } 4412 } 4413 4414 cmd->sync_cmd = 0; 4415 mrsas_release_mfi_cmd(cmd); 4416 return (retcode); 4417 } 4418 4419 /* 4420 * mrsas_complete_abort: Completes aborting a command input: 4421 * Adapter soft state Cmd that was issued to abort another cmd 4422 * 4423 * The mrsas_issue_blocked_abort_cmd() function waits for the command status to 4424 * change after sending the command. This function is called from 4425 * mrsas_complete_mptmfi_passthru() to wake up the sleep thread associated. 4426 */ 4427 void 4428 mrsas_complete_abort(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd) 4429 { 4430 if (cmd->sync_cmd) { 4431 cmd->sync_cmd = 0; 4432 cmd->cmd_status = 0; 4433 sc->chan = (void *)&cmd; 4434 wakeup_one((void *)&sc->chan); 4435 } 4436 return; 4437 } 4438 4439 /* 4440 * mrsas_aen_handler: AEN processing callback function from thread context 4441 * input: Adapter soft state 4442 * 4443 * Asynchronous event handler 4444 */ 4445 void 4446 mrsas_aen_handler(struct mrsas_softc *sc) 4447 { 4448 union mrsas_evt_class_locale class_locale; 4449 int doscan = 0; 4450 u_int32_t seq_num; 4451 int error, fail_aen = 0; 4452 4453 if (sc == NULL) { 4454 printf("invalid instance!\n"); 4455 return; 4456 } 4457 if (sc->remove_in_progress || sc->reset_in_progress) { 4458 device_printf(sc->mrsas_dev, "Returning from %s, line no %d\n", 4459 __func__, __LINE__); 4460 return; 4461 } 4462 if (sc->evt_detail_mem) { 4463 switch (sc->evt_detail_mem->code) { 4464 case MR_EVT_PD_INSERTED: 4465 fail_aen = mrsas_get_pd_list(sc); 4466 if (!fail_aen) 4467 mrsas_bus_scan_sim(sc, sc->sim_1); 4468 else 4469 goto skip_register_aen; 4470 break; 4471 case MR_EVT_PD_REMOVED: 4472 fail_aen = mrsas_get_pd_list(sc); 4473 if (!fail_aen) 4474 mrsas_bus_scan_sim(sc, sc->sim_1); 4475 else 4476 goto skip_register_aen; 4477 break; 4478 case MR_EVT_LD_OFFLINE: 4479 case MR_EVT_CFG_CLEARED: 4480 case MR_EVT_LD_DELETED: 4481 mrsas_bus_scan_sim(sc, sc->sim_0); 4482 break; 4483 case MR_EVT_LD_CREATED: 4484 fail_aen = mrsas_get_ld_list(sc); 4485 if (!fail_aen) 4486 mrsas_bus_scan_sim(sc, sc->sim_0); 4487 else 4488 goto skip_register_aen; 4489 break; 4490 case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED: 4491 case MR_EVT_FOREIGN_CFG_IMPORTED: 4492 case MR_EVT_LD_STATE_CHANGE: 4493 doscan = 1; 4494 break; 4495 case MR_EVT_CTRL_PROP_CHANGED: 4496 fail_aen = mrsas_get_ctrl_info(sc); 4497 if (fail_aen) 4498 goto skip_register_aen; 4499 break; 4500 default: 4501 break; 4502 } 4503 } else { 4504 device_printf(sc->mrsas_dev, "invalid evt_detail\n"); 4505 return; 4506 } 4507 if (doscan) { 4508 fail_aen = mrsas_get_pd_list(sc); 4509 if (!fail_aen) { 4510 mrsas_dprint(sc, MRSAS_AEN, "scanning ...sim 1\n"); 4511 mrsas_bus_scan_sim(sc, sc->sim_1); 4512 } else 4513 goto skip_register_aen; 4514 4515 fail_aen = mrsas_get_ld_list(sc); 4516 if (!fail_aen) { 4517 mrsas_dprint(sc, MRSAS_AEN, "scanning ...sim 0\n"); 4518 mrsas_bus_scan_sim(sc, sc->sim_0); 4519 } else 4520 goto skip_register_aen; 4521 } 4522 seq_num = sc->evt_detail_mem->seq_num + 1; 4523 4524 /* Register AEN with FW for latest sequence number plus 1 */ 4525 class_locale.members.reserved = 0; 4526 class_locale.members.locale = MR_EVT_LOCALE_ALL; 4527 class_locale.members.class = MR_EVT_CLASS_DEBUG; 4528 4529 if (sc->aen_cmd != NULL) 4530 return; 4531 4532 mtx_lock(&sc->aen_lock); 4533 error = mrsas_register_aen(sc, seq_num, 4534 class_locale.word); 4535 mtx_unlock(&sc->aen_lock); 4536 4537 if (error) 4538 device_printf(sc->mrsas_dev, "register aen failed error %x\n", error); 4539 4540 skip_register_aen: 4541 return; 4542 4543 } 4544 4545 4546 /* 4547 * mrsas_complete_aen: Completes AEN command 4548 * input: Adapter soft state 4549 * Cmd that was issued to abort another cmd 4550 * 4551 * This function will be called from ISR and will continue event processing from 4552 * thread context by enqueuing task in ev_tq (callback function 4553 * "mrsas_aen_handler"). 4554 */ 4555 void 4556 mrsas_complete_aen(struct mrsas_softc *sc, struct mrsas_mfi_cmd *cmd) 4557 { 4558 /* 4559 * Don't signal app if it is just an aborted previously registered 4560 * aen 4561 */ 4562 if ((!cmd->abort_aen) && (sc->remove_in_progress == 0)) { 4563 sc->mrsas_aen_triggered = 1; 4564 mtx_lock(&sc->aen_lock); 4565 if (sc->mrsas_poll_waiting) { 4566 sc->mrsas_poll_waiting = 0; 4567 selwakeup(&sc->mrsas_select); 4568 } 4569 mtx_unlock(&sc->aen_lock); 4570 } else 4571 cmd->abort_aen = 0; 4572 4573 sc->aen_cmd = NULL; 4574 mrsas_release_mfi_cmd(cmd); 4575 4576 taskqueue_enqueue(sc->ev_tq, &sc->ev_task); 4577 4578 return; 4579 } 4580 4581 static device_method_t mrsas_methods[] = { 4582 DEVMETHOD(device_probe, mrsas_probe), 4583 DEVMETHOD(device_attach, mrsas_attach), 4584 DEVMETHOD(device_detach, mrsas_detach), 4585 DEVMETHOD(device_suspend, mrsas_suspend), 4586 DEVMETHOD(device_resume, mrsas_resume), 4587 DEVMETHOD(bus_print_child, bus_generic_print_child), 4588 DEVMETHOD(bus_driver_added, bus_generic_driver_added), 4589 {0, 0} 4590 }; 4591 4592 static driver_t mrsas_driver = { 4593 "mrsas", 4594 mrsas_methods, 4595 sizeof(struct mrsas_softc) 4596 }; 4597 4598 static devclass_t mrsas_devclass; 4599 4600 DRIVER_MODULE(mrsas, pci, mrsas_driver, mrsas_devclass, 0, 0); 4601 MODULE_DEPEND(mrsas, cam, 1, 1, 1); 4602