1 /*- 2 * Redistribution and use in source and binary forms, with or without 3 * modification, are permitted provided that the following conditions 4 * are met: 5 * 6 * Copyright 1994-2009 The FreeBSD Project. 7 * All rights reserved. 8 * 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE FREEBSD PROJECT``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 17 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FREEBSD PROJECT OR 19 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 20 * EXEMPLARY,OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 22 * PROFITS; OR BUSINESS INTERRUPTION)HOWEVER CAUSED AND ON ANY THEORY 23 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 24 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 * 27 * The views and conclusions contained in the software and documentation 28 * are those of the authors and should not be interpreted as representing 29 * official policies,either expressed or implied, of the FreeBSD Project. 30 */ 31 32 33 #include <sys/cdefs.h> 34 __FBSDID("$FreeBSD$"); 35 36 #include "opt_mfi.h" 37 38 #include <sys/param.h> 39 #include <sys/types.h> 40 #include <sys/kernel.h> 41 #include <sys/selinfo.h> 42 #include <sys/bus.h> 43 #include <sys/conf.h> 44 #include <sys/bio.h> 45 #include <sys/ioccom.h> 46 #include <sys/eventhandler.h> 47 #include <sys/callout.h> 48 #include <sys/uio.h> 49 #include <machine/bus.h> 50 #include <sys/sysctl.h> 51 #include <sys/systm.h> 52 #include <sys/malloc.h> 53 54 #include <dev/mfi/mfireg.h> 55 #include <dev/mfi/mfi_ioctl.h> 56 #include <dev/mfi/mfivar.h> 57 58 struct mfi_cmd_tbolt *mfi_tbolt_get_cmd(struct mfi_softc *sc); 59 union mfi_mpi2_request_descriptor * 60 mfi_tbolt_get_request_descriptor(struct mfi_softc *sc, uint16_t index); 61 void mfi_tbolt_complete_cmd(struct mfi_softc *sc); 62 int mfi_tbolt_build_io(struct mfi_softc *sc, struct mfi_command *mfi_cmd, 63 struct mfi_cmd_tbolt *cmd); 64 static inline void mfi_tbolt_return_cmd(struct mfi_softc *sc, 65 struct mfi_cmd_tbolt *cmd); 66 union mfi_mpi2_request_descriptor *mfi_tbolt_build_mpt_cmd(struct mfi_softc 67 *sc, struct mfi_command *cmd); 68 uint8_t 69 mfi_build_mpt_pass_thru(struct mfi_softc *sc, struct mfi_command *mfi_cmd); 70 union mfi_mpi2_request_descriptor *mfi_build_and_issue_cmd(struct mfi_softc 71 *sc, struct mfi_command *mfi_cmd); 72 int mfi_tbolt_is_ldio(struct mfi_command *mfi_cmd); 73 void mfi_tbolt_build_ldio(struct mfi_softc *sc, struct mfi_command *mfi_cmd, 74 struct mfi_cmd_tbolt *cmd); 75 static int mfi_tbolt_make_sgl(struct mfi_softc *sc, struct mfi_command 76 *mfi_cmd, pMpi25IeeeSgeChain64_t sgl_ptr, struct mfi_cmd_tbolt *cmd); 77 static int mfi_tbolt_build_cdb(struct mfi_softc *sc, struct mfi_command 78 *mfi_cmd, uint8_t *cdb); 79 void 80 map_tbolt_cmd_status(struct mfi_command *mfi_cmd, uint8_t status, 81 uint8_t ext_status); 82 static void mfi_issue_pending_cmds_again (struct mfi_softc *sc); 83 static void mfi_kill_hba (struct mfi_softc *sc); 84 static void mfi_process_fw_state_chg_isr(void *arg); 85 static void mfi_sync_map_complete(struct mfi_command *); 86 static void mfi_queue_map_sync(struct mfi_softc *sc); 87 88 #define MFI_FUSION_ENABLE_INTERRUPT_MASK (0x00000008) 89 90 void 91 mfi_tbolt_enable_intr_ppc(struct mfi_softc *sc) 92 { 93 MFI_WRITE4(sc, MFI_OMSK, ~MFI_FUSION_ENABLE_INTERRUPT_MASK); 94 MFI_READ4(sc, MFI_OMSK); 95 } 96 97 void 98 mfi_tbolt_disable_intr_ppc(struct mfi_softc *sc) 99 { 100 MFI_WRITE4(sc, MFI_OMSK, 0xFFFFFFFF); 101 MFI_READ4(sc, MFI_OMSK); 102 } 103 104 int32_t 105 mfi_tbolt_read_fw_status_ppc(struct mfi_softc *sc) 106 { 107 return MFI_READ4(sc, MFI_OSP0); 108 } 109 110 int32_t 111 mfi_tbolt_check_clear_intr_ppc(struct mfi_softc *sc) 112 { 113 int32_t status, mfi_status = 0; 114 115 status = MFI_READ4(sc, MFI_OSTS); 116 117 if (status & 1) { 118 MFI_WRITE4(sc, MFI_OSTS, status); 119 MFI_READ4(sc, MFI_OSTS); 120 if (status & MFI_STATE_CHANGE_INTERRUPT) { 121 mfi_status |= MFI_FIRMWARE_STATE_CHANGE; 122 } 123 124 return mfi_status; 125 } 126 if (!(status & MFI_FUSION_ENABLE_INTERRUPT_MASK)) 127 return 1; 128 129 MFI_READ4(sc, MFI_OSTS); 130 return 0; 131 } 132 133 134 void 135 mfi_tbolt_issue_cmd_ppc(struct mfi_softc *sc, bus_addr_t bus_add, 136 uint32_t frame_cnt) 137 { 138 bus_add |= (MFI_REQ_DESCRIPT_FLAGS_MFA 139 << MFI_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 140 MFI_WRITE4(sc, MFI_IQPL, (uint32_t)bus_add); 141 MFI_WRITE4(sc, MFI_IQPH, (uint32_t)((uint64_t)bus_add >> 32)); 142 } 143 144 /* 145 * mfi_tbolt_adp_reset - For controller reset 146 * @regs: MFI register set 147 */ 148 int 149 mfi_tbolt_adp_reset(struct mfi_softc *sc) 150 { 151 int retry = 0, i = 0; 152 int HostDiag; 153 154 MFI_WRITE4(sc, MFI_WSR, 0xF); 155 MFI_WRITE4(sc, MFI_WSR, 4); 156 MFI_WRITE4(sc, MFI_WSR, 0xB); 157 MFI_WRITE4(sc, MFI_WSR, 2); 158 MFI_WRITE4(sc, MFI_WSR, 7); 159 MFI_WRITE4(sc, MFI_WSR, 0xD); 160 161 for (i = 0; i < 10000; i++) ; 162 163 HostDiag = (uint32_t)MFI_READ4(sc, MFI_HDR); 164 165 while (!( HostDiag & DIAG_WRITE_ENABLE)) { 166 for (i = 0; i < 1000; i++); 167 HostDiag = (uint32_t)MFI_READ4(sc, MFI_HDR); 168 device_printf(sc->mfi_dev, "ADP_RESET_TBOLT: retry time=%x, " 169 "hostdiag=%x\n", retry, HostDiag); 170 171 if (retry++ >= 100) 172 return 1; 173 } 174 175 device_printf(sc->mfi_dev, "ADP_RESET_TBOLT: HostDiag=%x\n", HostDiag); 176 177 MFI_WRITE4(sc, MFI_HDR, (HostDiag | DIAG_RESET_ADAPTER)); 178 179 for (i=0; i < 10; i++) { 180 for (i = 0; i < 10000; i++); 181 } 182 183 HostDiag = (uint32_t)MFI_READ4(sc, MFI_RSR); 184 while (HostDiag & DIAG_RESET_ADAPTER) { 185 for (i = 0; i < 1000; i++) ; 186 HostDiag = (uint32_t)MFI_READ4(sc, MFI_RSR); 187 device_printf(sc->mfi_dev, "ADP_RESET_TBOLT: retry time=%x, " 188 "hostdiag=%x\n", retry, HostDiag); 189 190 if (retry++ >= 1000) 191 return 1; 192 } 193 return 0; 194 } 195 196 /* 197 * This routine initialize Thunderbolt specific device information 198 */ 199 void 200 mfi_tbolt_init_globals(struct mfi_softc *sc) 201 { 202 /* Initialize single reply size and Message size */ 203 sc->reply_size = MEGASAS_THUNDERBOLT_REPLY_SIZE; 204 sc->raid_io_msg_size = MEGASAS_THUNDERBOLT_NEW_MSG_SIZE; 205 206 /* 207 * Calculating how many SGEs allowed in a allocated main message 208 * (size of the Message - Raid SCSI IO message size(except SGE)) 209 * / size of SGE 210 * (0x100 - (0x90 - 0x10)) / 0x10 = 8 211 */ 212 sc->max_SGEs_in_main_message = 213 (uint8_t)((sc->raid_io_msg_size 214 - (sizeof(struct mfi_mpi2_request_raid_scsi_io) 215 - sizeof(MPI2_SGE_IO_UNION))) / sizeof(MPI2_SGE_IO_UNION)); 216 /* 217 * (Command frame size allocaed in SRB ext - Raid SCSI IO message size) 218 * / size of SGL ; 219 * (1280 - 256) / 16 = 64 220 */ 221 sc->max_SGEs_in_chain_message = (MR_COMMAND_SIZE 222 - sc->raid_io_msg_size) / sizeof(MPI2_SGE_IO_UNION); 223 /* 224 * (0x08-1) + 0x40 = 0x47 - 0x01 = 0x46 one is left for command 225 * colscing 226 */ 227 sc->mfi_max_sge = (sc->max_SGEs_in_main_message - 1) 228 + sc->max_SGEs_in_chain_message - 1; 229 /* 230 * This is the offset in number of 4 * 32bit words to the next chain 231 * (0x100 - 0x10)/0x10 = 0xF(15) 232 */ 233 sc->chain_offset_value_for_main_message = (sc->raid_io_msg_size 234 - sizeof(MPI2_SGE_IO_UNION))/16; 235 sc->chain_offset_value_for_mpt_ptmsg 236 = offsetof(struct mfi_mpi2_request_raid_scsi_io, SGL)/16; 237 sc->mfi_cmd_pool_tbolt = NULL; 238 sc->request_desc_pool = NULL; 239 } 240 241 /* 242 * This function calculates the memory requirement for Thunderbolt 243 * controller, returns the total required memory in bytes 244 */ 245 246 uint32_t 247 mfi_tbolt_get_memory_requirement(struct mfi_softc *sc) 248 { 249 uint32_t size; 250 size = MEGASAS_THUNDERBOLT_MSG_ALLIGNMENT; /* for Alignment */ 251 size += sc->raid_io_msg_size * (sc->mfi_max_fw_cmds + 1); 252 size += sc->reply_size * sc->mfi_max_fw_cmds; 253 /* this is for SGL's */ 254 size += MEGASAS_MAX_SZ_CHAIN_FRAME * sc->mfi_max_fw_cmds; 255 return size; 256 } 257 258 /* 259 * Description: 260 * This function will prepare message pools for the Thunderbolt controller 261 * Arguments: 262 * DevExt - HBA miniport driver's adapter data storage structure 263 * pMemLocation - start of the memory allocated for Thunderbolt. 264 * Return Value: 265 * TRUE if successful 266 * FALSE if failed 267 */ 268 int 269 mfi_tbolt_init_desc_pool(struct mfi_softc *sc, uint8_t* mem_location, 270 uint32_t tbolt_contg_length) 271 { 272 uint32_t offset = 0; 273 uint8_t *addr = mem_location; 274 275 /* Request Descriptor Base physical Address */ 276 277 /* For Request Decriptors Virtual Memory */ 278 /* Initialise the aligned IO Frames Virtual Memory Pointer */ 279 if (((uintptr_t)addr) & (0xFF)) { 280 addr = &addr[sc->raid_io_msg_size]; 281 addr = (uint8_t *)((uintptr_t)addr & (~0xFF)); 282 sc->request_message_pool_align = addr; 283 } else 284 sc->request_message_pool_align = addr; 285 286 offset = sc->request_message_pool_align - sc->request_message_pool; 287 sc->request_msg_busaddr = sc->mfi_tb_busaddr + offset; 288 289 /* DJA XXX should this be bus dma ??? */ 290 /* Skip request message pool */ 291 addr = &addr[sc->raid_io_msg_size * (sc->mfi_max_fw_cmds + 1)]; 292 /* Reply Frame Pool is initialized */ 293 sc->reply_frame_pool = (struct mfi_mpi2_reply_header *) addr; 294 if (((uintptr_t)addr) & (0xFF)) { 295 addr = &addr[sc->reply_size]; 296 addr = (uint8_t *)((uintptr_t)addr & (~0xFF)); 297 } 298 sc->reply_frame_pool_align 299 = (struct mfi_mpi2_reply_header *)addr; 300 301 offset = (uintptr_t)sc->reply_frame_pool_align 302 - (uintptr_t)sc->request_message_pool; 303 sc->reply_frame_busaddr = sc->mfi_tb_busaddr + offset; 304 305 /* Skip Reply Frame Pool */ 306 addr += sc->reply_size * sc->mfi_max_fw_cmds; 307 sc->reply_pool_limit = addr; 308 309 /* initializing reply address to 0xFFFFFFFF */ 310 memset((uint8_t *)sc->reply_frame_pool, 0xFF, 311 (sc->reply_size * sc->mfi_max_fw_cmds)); 312 313 offset = sc->reply_size * sc->mfi_max_fw_cmds; 314 sc->sg_frame_busaddr = sc->reply_frame_busaddr + offset; 315 /* initialize the last_reply_idx to 0 */ 316 sc->last_reply_idx = 0; 317 offset = (sc->sg_frame_busaddr + (MEGASAS_MAX_SZ_CHAIN_FRAME * 318 sc->mfi_max_fw_cmds)) - sc->mfi_tb_busaddr; 319 if (offset > tbolt_contg_length) 320 device_printf(sc->mfi_dev, "Error:Initialized more than " 321 "allocated\n"); 322 return 0; 323 } 324 325 /* 326 * This routine prepare and issue INIT2 frame to the Firmware 327 */ 328 329 int 330 mfi_tbolt_init_MFI_queue(struct mfi_softc *sc) 331 { 332 struct MPI2_IOC_INIT_REQUEST *mpi2IocInit; 333 struct mfi_init_frame *mfi_init; 334 uintptr_t offset = 0; 335 bus_addr_t phyAddress; 336 MFI_ADDRESS *mfiAddressTemp; 337 struct mfi_command *cm; 338 int error; 339 340 mpi2IocInit = (struct MPI2_IOC_INIT_REQUEST *)sc->mfi_tb_ioc_init_desc; 341 /* Check if initialization is already completed */ 342 if (sc->MFA_enabled) { 343 return 1; 344 } 345 346 mtx_lock(&sc->mfi_io_lock); 347 if ((cm = mfi_dequeue_free(sc)) == NULL) { 348 mtx_unlock(&sc->mfi_io_lock); 349 return (EBUSY); 350 } 351 cm->cm_frame = (union mfi_frame *)((uintptr_t)sc->mfi_tb_init); 352 cm->cm_frame_busaddr = sc->mfi_tb_init_busaddr; 353 cm->cm_dmamap = sc->mfi_tb_init_dmamap; 354 cm->cm_frame->header.context = 0; 355 cm->cm_sc = sc; 356 cm->cm_index = 0; 357 358 /* 359 * Abuse the SG list area of the frame to hold the init_qinfo 360 * object; 361 */ 362 mfi_init = &cm->cm_frame->init; 363 364 bzero(mpi2IocInit, sizeof(struct MPI2_IOC_INIT_REQUEST)); 365 mpi2IocInit->Function = MPI2_FUNCTION_IOC_INIT; 366 mpi2IocInit->WhoInit = MPI2_WHOINIT_HOST_DRIVER; 367 368 /* set MsgVersion and HeaderVersion host driver was built with */ 369 mpi2IocInit->MsgVersion = MPI2_VERSION; 370 mpi2IocInit->HeaderVersion = MPI2_HEADER_VERSION; 371 mpi2IocInit->SystemRequestFrameSize = sc->raid_io_msg_size/4; 372 mpi2IocInit->ReplyDescriptorPostQueueDepth 373 = (uint16_t)sc->mfi_max_fw_cmds; 374 mpi2IocInit->ReplyFreeQueueDepth = 0; /* Not supported by MR. */ 375 376 /* Get physical address of reply frame pool */ 377 offset = (uintptr_t) sc->reply_frame_pool_align 378 - (uintptr_t)sc->request_message_pool; 379 phyAddress = sc->mfi_tb_busaddr + offset; 380 mfiAddressTemp = 381 (MFI_ADDRESS *)&mpi2IocInit->ReplyDescriptorPostQueueAddress; 382 mfiAddressTemp->u.addressLow = (uint32_t)phyAddress; 383 mfiAddressTemp->u.addressHigh = (uint32_t)((uint64_t)phyAddress >> 32); 384 385 /* Get physical address of request message pool */ 386 offset = sc->request_message_pool_align - sc->request_message_pool; 387 phyAddress = sc->mfi_tb_busaddr + offset; 388 mfiAddressTemp = (MFI_ADDRESS *)&mpi2IocInit->SystemRequestFrameBaseAddress; 389 mfiAddressTemp->u.addressLow = (uint32_t)phyAddress; 390 mfiAddressTemp->u.addressHigh = (uint32_t)((uint64_t)phyAddress >> 32); 391 mpi2IocInit->ReplyFreeQueueAddress = 0; /* Not supported by MR. */ 392 mpi2IocInit->TimeStamp = time_uptime; 393 394 if (sc->verbuf) { 395 snprintf((char *)sc->verbuf, strlen(MEGASAS_VERSION) + 2, "%s\n", 396 MEGASAS_VERSION); 397 mfi_init->driver_ver_lo = (uint32_t)sc->verbuf_h_busaddr; 398 mfi_init->driver_ver_hi = 399 (uint32_t)((uint64_t)sc->verbuf_h_busaddr >> 32); 400 } 401 /* Get the physical address of the mpi2 ioc init command */ 402 phyAddress = sc->mfi_tb_ioc_init_busaddr; 403 mfi_init->qinfo_new_addr_lo = (uint32_t)phyAddress; 404 mfi_init->qinfo_new_addr_hi = (uint32_t)((uint64_t)phyAddress >> 32); 405 mfi_init->header.flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE; 406 407 mfi_init->header.cmd = MFI_CMD_INIT; 408 mfi_init->header.data_len = sizeof(struct MPI2_IOC_INIT_REQUEST); 409 mfi_init->header.cmd_status = MFI_STAT_INVALID_STATUS; 410 411 cm->cm_data = NULL; 412 cm->cm_flags |= MFI_CMD_POLLED; 413 cm->cm_timestamp = time_uptime; 414 if ((error = mfi_mapcmd(sc, cm)) != 0) { 415 device_printf(sc->mfi_dev, "failed to send IOC init2 " 416 "command %d at %lx\n", error, (long)cm->cm_frame_busaddr); 417 mfi_release_command(cm); 418 mtx_unlock(&sc->mfi_io_lock); 419 return (error); 420 } 421 mfi_release_command(cm); 422 mtx_unlock(&sc->mfi_io_lock); 423 424 if (mfi_init->header.cmd_status == 0) { 425 sc->MFA_enabled = 1; 426 } 427 else { 428 device_printf(sc->mfi_dev, "Init command Failed %x\n", 429 mfi_init->header.cmd_status); 430 return 1; 431 } 432 433 return 0; 434 435 } 436 437 int 438 mfi_tbolt_alloc_cmd(struct mfi_softc *sc) 439 { 440 struct mfi_cmd_tbolt *cmd; 441 bus_addr_t io_req_base_phys; 442 uint8_t *io_req_base; 443 int i = 0, j = 0, offset = 0; 444 445 /* 446 * sc->mfi_cmd_pool_tbolt is an array of struct mfi_cmd_tbolt pointers. 447 * Allocate the dynamic array first and then allocate individual 448 * commands. 449 */ 450 sc->request_desc_pool = malloc(sizeof( 451 union mfi_mpi2_request_descriptor) * sc->mfi_max_fw_cmds, 452 M_MFIBUF, M_NOWAIT|M_ZERO); 453 sc->mfi_cmd_pool_tbolt = malloc(sizeof(struct mfi_cmd_tbolt*) 454 * sc->mfi_max_fw_cmds, M_MFIBUF, M_NOWAIT|M_ZERO); 455 456 if (!sc->mfi_cmd_pool_tbolt) { 457 device_printf(sc->mfi_dev, "out of memory. Could not alloc " 458 "memory for cmd_list_fusion\n"); 459 return 1; 460 } 461 462 for (i = 0; i < sc->mfi_max_fw_cmds; i++) { 463 sc->mfi_cmd_pool_tbolt[i] = malloc(sizeof( 464 struct mfi_cmd_tbolt),M_MFIBUF, M_NOWAIT|M_ZERO); 465 466 if (!sc->mfi_cmd_pool_tbolt[i]) { 467 device_printf(sc->mfi_dev, "Could not alloc cmd list " 468 "fusion\n"); 469 470 for (j = 0; j < i; j++) 471 free(sc->mfi_cmd_pool_tbolt[j], M_MFIBUF); 472 473 free(sc->mfi_cmd_pool_tbolt, M_MFIBUF); 474 sc->mfi_cmd_pool_tbolt = NULL; 475 } 476 } 477 478 /* 479 * The first 256 bytes (SMID 0) is not used. Don't add to the cmd 480 *list 481 */ 482 io_req_base = sc->request_message_pool_align 483 + MEGASAS_THUNDERBOLT_NEW_MSG_SIZE; 484 io_req_base_phys = sc->request_msg_busaddr 485 + MEGASAS_THUNDERBOLT_NEW_MSG_SIZE; 486 487 /* 488 * Add all the commands to command pool (instance->cmd_pool) 489 */ 490 /* SMID 0 is reserved. Set SMID/index from 1 */ 491 492 for (i = 0; i < sc->mfi_max_fw_cmds; i++) { 493 cmd = sc->mfi_cmd_pool_tbolt[i]; 494 offset = MEGASAS_THUNDERBOLT_NEW_MSG_SIZE * i; 495 cmd->index = i + 1; 496 cmd->request_desc = (union mfi_mpi2_request_descriptor *) 497 (sc->request_desc_pool + i); 498 cmd->io_request = (struct mfi_mpi2_request_raid_scsi_io *) 499 (io_req_base + offset); 500 cmd->io_request_phys_addr = io_req_base_phys + offset; 501 cmd->sg_frame = (MPI2_SGE_IO_UNION *)(sc->reply_pool_limit 502 + i * MEGASAS_MAX_SZ_CHAIN_FRAME); 503 cmd->sg_frame_phys_addr = sc->sg_frame_busaddr + i 504 * MEGASAS_MAX_SZ_CHAIN_FRAME; 505 506 TAILQ_INSERT_TAIL(&(sc->mfi_cmd_tbolt_tqh), cmd, next); 507 } 508 return 0; 509 } 510 511 int 512 mfi_tbolt_reset(struct mfi_softc *sc) 513 { 514 uint32_t fw_state; 515 516 mtx_lock(&sc->mfi_io_lock); 517 if (sc->hw_crit_error) { 518 device_printf(sc->mfi_dev, "HW CRITICAL ERROR\n"); 519 mtx_unlock(&sc->mfi_io_lock); 520 return 1; 521 } 522 523 if (sc->mfi_flags & MFI_FLAGS_TBOLT) { 524 fw_state = sc->mfi_read_fw_status(sc); 525 if ((fw_state & MFI_FWSTATE_FAULT) == MFI_FWSTATE_FAULT) { 526 if ((sc->disableOnlineCtrlReset == 0) 527 && (sc->adpreset == 0)) { 528 device_printf(sc->mfi_dev, "Adapter RESET " 529 "condition is detected\n"); 530 sc->adpreset = 1; 531 sc->issuepend_done = 0; 532 sc->MFA_enabled = 0; 533 sc->last_reply_idx = 0; 534 mfi_process_fw_state_chg_isr((void *) sc); 535 } 536 mtx_unlock(&sc->mfi_io_lock); 537 return 0; 538 } 539 } 540 mtx_unlock(&sc->mfi_io_lock); 541 return 1; 542 } 543 544 /* 545 * mfi_intr_tbolt - isr entry point 546 */ 547 void 548 mfi_intr_tbolt(void *arg) 549 { 550 struct mfi_softc *sc = (struct mfi_softc *)arg; 551 552 if (sc->mfi_check_clear_intr(sc) == 1) { 553 return; 554 } 555 if (sc->mfi_detaching) 556 return; 557 mtx_lock(&sc->mfi_io_lock); 558 mfi_tbolt_complete_cmd(sc); 559 if (sc->mfi_flags & MFI_FLAGS_QFRZN) 560 sc->mfi_flags &= ~MFI_FLAGS_QFRZN; 561 mfi_startio(sc); 562 mtx_unlock(&sc->mfi_io_lock); 563 return; 564 } 565 566 /* 567 * map_cmd_status - Maps FW cmd status to OS cmd status 568 * @cmd : Pointer to cmd 569 * @status : status of cmd returned by FW 570 * @ext_status : ext status of cmd returned by FW 571 */ 572 573 void 574 map_tbolt_cmd_status(struct mfi_command *mfi_cmd, uint8_t status, 575 uint8_t ext_status) 576 { 577 578 switch (status) { 579 case MFI_STAT_OK: 580 mfi_cmd->cm_frame->header.cmd_status = 0; 581 mfi_cmd->cm_frame->dcmd.header.cmd_status = 0; 582 break; 583 584 case MFI_STAT_SCSI_IO_FAILED: 585 case MFI_STAT_LD_INIT_IN_PROGRESS: 586 mfi_cmd->cm_frame->header.cmd_status = status; 587 mfi_cmd->cm_frame->header.scsi_status = ext_status; 588 mfi_cmd->cm_frame->dcmd.header.cmd_status = status; 589 mfi_cmd->cm_frame->dcmd.header.scsi_status 590 = ext_status; 591 break; 592 593 case MFI_STAT_SCSI_DONE_WITH_ERROR: 594 mfi_cmd->cm_frame->header.cmd_status = ext_status; 595 mfi_cmd->cm_frame->dcmd.header.cmd_status = ext_status; 596 break; 597 598 case MFI_STAT_LD_OFFLINE: 599 case MFI_STAT_DEVICE_NOT_FOUND: 600 mfi_cmd->cm_frame->header.cmd_status = status; 601 mfi_cmd->cm_frame->dcmd.header.cmd_status = status; 602 break; 603 604 default: 605 mfi_cmd->cm_frame->header.cmd_status = status; 606 mfi_cmd->cm_frame->dcmd.header.cmd_status = status; 607 break; 608 } 609 } 610 611 /* 612 * mfi_tbolt_return_cmd - Return a cmd to free command pool 613 * @instance: Adapter soft state 614 * @cmd: Command packet to be returned to free command pool 615 */ 616 static inline void 617 mfi_tbolt_return_cmd(struct mfi_softc *sc, struct mfi_cmd_tbolt *cmd) 618 { 619 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 620 621 TAILQ_INSERT_TAIL(&sc->mfi_cmd_tbolt_tqh, cmd, next); 622 } 623 624 void 625 mfi_tbolt_complete_cmd(struct mfi_softc *sc) 626 { 627 struct mfi_mpi2_reply_header *desc, *reply_desc; 628 struct mfi_command *cmd_mfi, *cmd_mfi_check; /* For MFA Cmds */ 629 struct mfi_cmd_tbolt *cmd_tbolt; 630 uint16_t smid; 631 uint8_t reply_descript_type; 632 struct mfi_mpi2_request_raid_scsi_io *scsi_io_req; 633 uint32_t status, extStatus; 634 uint16_t num_completed; 635 union desc_value val; 636 637 desc = (struct mfi_mpi2_reply_header *) 638 ((uintptr_t)sc->reply_frame_pool_align 639 + sc->last_reply_idx * sc->reply_size); 640 reply_desc = desc; 641 642 if (!reply_desc) 643 device_printf(sc->mfi_dev, "reply desc is NULL!!\n"); 644 645 reply_descript_type = reply_desc->ReplyFlags 646 & MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK; 647 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED) 648 return; 649 650 num_completed = 0; 651 val.word = ((union mfi_mpi2_reply_descriptor *)desc)->words; 652 653 /* Read Reply descriptor */ 654 while ((val.u.low != 0xFFFFFFFF) && (val.u.high != 0xFFFFFFFF)) { 655 smid = reply_desc->SMID; 656 if (!smid || smid > sc->mfi_max_fw_cmds + 1) { 657 device_printf(sc->mfi_dev, "smid is %x. Cannot " 658 "proceed. Returning \n", smid); 659 return; 660 } 661 662 cmd_tbolt = sc->mfi_cmd_pool_tbolt[smid - 1]; 663 cmd_mfi = &sc->mfi_commands[cmd_tbolt->sync_cmd_idx]; 664 scsi_io_req = cmd_tbolt->io_request; 665 666 status = cmd_mfi->cm_frame->dcmd.header.cmd_status; 667 extStatus = cmd_mfi->cm_frame->dcmd.header.scsi_status; 668 map_tbolt_cmd_status(cmd_mfi, status, extStatus); 669 670 /* remove command from busy queue if not polled */ 671 TAILQ_FOREACH(cmd_mfi_check, &sc->mfi_busy, cm_link) { 672 if (cmd_mfi_check == cmd_mfi) { 673 mfi_remove_busy(cmd_mfi); 674 break; 675 } 676 } 677 cmd_mfi->cm_error = 0; 678 mfi_complete(sc, cmd_mfi); 679 mfi_tbolt_return_cmd(sc, cmd_tbolt); 680 681 sc->last_reply_idx++; 682 if (sc->last_reply_idx >= sc->mfi_max_fw_cmds) { 683 MFI_WRITE4(sc, MFI_RPI, sc->last_reply_idx); 684 sc->last_reply_idx = 0; 685 } 686 /*set it back to all 0xfff.*/ 687 ((union mfi_mpi2_reply_descriptor*)desc)->words = 688 ~((uint64_t)0x00); 689 690 num_completed++; 691 692 /* Get the next reply descriptor */ 693 desc = (struct mfi_mpi2_reply_header *) 694 ((uintptr_t)sc->reply_frame_pool_align 695 + sc->last_reply_idx * sc->reply_size); 696 reply_desc = desc; 697 val.word = ((union mfi_mpi2_reply_descriptor*)desc)->words; 698 reply_descript_type = reply_desc->ReplyFlags 699 & MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK; 700 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED) 701 break; 702 } 703 704 if (!num_completed) 705 return; 706 707 /* update replyIndex to FW */ 708 if (sc->last_reply_idx) 709 MFI_WRITE4(sc, MFI_RPI, sc->last_reply_idx); 710 711 return; 712 } 713 714 /* 715 * mfi_get_cmd - Get a command from the free pool 716 * @instance: Adapter soft state 717 * 718 * Returns a free command from the pool 719 */ 720 721 struct mfi_cmd_tbolt * 722 mfi_tbolt_get_cmd(struct mfi_softc *sc) 723 { 724 struct mfi_cmd_tbolt *cmd = NULL; 725 726 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 727 728 cmd = TAILQ_FIRST(&sc->mfi_cmd_tbolt_tqh); 729 TAILQ_REMOVE(&sc->mfi_cmd_tbolt_tqh, cmd, next); 730 memset((uint8_t *)cmd->sg_frame, 0, MEGASAS_MAX_SZ_CHAIN_FRAME); 731 memset((uint8_t *)cmd->io_request, 0, 732 MEGASAS_THUNDERBOLT_NEW_MSG_SIZE); 733 return cmd; 734 } 735 736 union mfi_mpi2_request_descriptor * 737 mfi_tbolt_get_request_descriptor(struct mfi_softc *sc, uint16_t index) 738 { 739 uint8_t *p; 740 741 if (index >= sc->mfi_max_fw_cmds) { 742 device_printf(sc->mfi_dev, "Invalid SMID (0x%x)request " 743 "for descriptor\n", index); 744 return NULL; 745 } 746 p = sc->request_desc_pool + sizeof(union mfi_mpi2_request_descriptor) 747 * index; 748 memset(p, 0, sizeof(union mfi_mpi2_request_descriptor)); 749 return (union mfi_mpi2_request_descriptor *)p; 750 } 751 752 753 /* Used to build IOCTL cmd */ 754 uint8_t 755 mfi_build_mpt_pass_thru(struct mfi_softc *sc, struct mfi_command *mfi_cmd) 756 { 757 MPI25_IEEE_SGE_CHAIN64 *mpi25_ieee_chain; 758 struct mfi_mpi2_request_raid_scsi_io *io_req; 759 struct mfi_cmd_tbolt *cmd; 760 761 cmd = mfi_tbolt_get_cmd(sc); 762 if (!cmd) 763 return EBUSY; 764 mfi_cmd->cm_extra_frames = cmd->index; /* Frame count used as SMID */ 765 cmd->sync_cmd_idx = mfi_cmd->cm_index; 766 io_req = cmd->io_request; 767 mpi25_ieee_chain = (MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL.IeeeChain; 768 769 io_req->Function = MPI2_FUNCTION_PASSTHRU_IO_REQUEST; 770 io_req->SGLOffset0 = offsetof(struct mfi_mpi2_request_raid_scsi_io, 771 SGL) / 4; 772 io_req->ChainOffset = sc->chain_offset_value_for_mpt_ptmsg; 773 774 mpi25_ieee_chain->Address = mfi_cmd->cm_frame_busaddr; 775 776 /* 777 In MFI pass thru, nextChainOffset will always be zero to 778 indicate the end of the chain. 779 */ 780 mpi25_ieee_chain->Flags= MPI2_IEEE_SGE_FLAGS_CHAIN_ELEMENT 781 | MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR; 782 783 /* setting the length to the maximum length */ 784 mpi25_ieee_chain->Length = 1024; 785 786 return 0; 787 } 788 789 void 790 mfi_tbolt_build_ldio(struct mfi_softc *sc, struct mfi_command *mfi_cmd, 791 struct mfi_cmd_tbolt *cmd) 792 { 793 uint32_t start_lba_lo = 0, start_lba_hi = 0, device_id; 794 struct mfi_mpi2_request_raid_scsi_io *io_request; 795 struct IO_REQUEST_INFO io_info; 796 797 device_id = mfi_cmd->cm_frame->io.header.target_id; 798 io_request = cmd->io_request; 799 io_request->RaidContext.TargetID = device_id; 800 io_request->RaidContext.Status = 0; 801 io_request->RaidContext.exStatus =0; 802 803 start_lba_lo = mfi_cmd->cm_frame->io.lba_lo; 804 start_lba_hi = mfi_cmd->cm_frame->io.lba_hi; 805 806 memset(&io_info, 0, sizeof(struct IO_REQUEST_INFO)); 807 io_info.ldStartBlock = ((uint64_t)start_lba_hi << 32) | start_lba_lo; 808 io_info.numBlocks = mfi_cmd->cm_frame->io.header.data_len; 809 io_info.ldTgtId = device_id; 810 if ((mfi_cmd->cm_frame->header.flags & MFI_FRAME_DIR_READ) == 811 MFI_FRAME_DIR_READ) 812 io_info.isRead = 1; 813 814 io_request->RaidContext.timeoutValue 815 = MFI_FUSION_FP_DEFAULT_TIMEOUT; 816 io_request->Function = MPI2_FUNCTION_LD_IO_REQUEST; 817 io_request->DevHandle = device_id; 818 cmd->request_desc->header.RequestFlags 819 = (MFI_REQ_DESCRIPT_FLAGS_LD_IO 820 << MFI_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 821 if ((io_request->IoFlags == 6) && (io_info.numBlocks == 0)) 822 io_request->RaidContext.RegLockLength = 0x100; 823 io_request->DataLength = mfi_cmd->cm_frame->io.header.data_len 824 * MFI_SECTOR_LEN; 825 } 826 827 int 828 mfi_tbolt_is_ldio(struct mfi_command *mfi_cmd) 829 { 830 if (mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_READ 831 || mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_WRITE) 832 return 1; 833 else 834 return 0; 835 } 836 837 int 838 mfi_tbolt_build_io(struct mfi_softc *sc, struct mfi_command *mfi_cmd, 839 struct mfi_cmd_tbolt *cmd) 840 { 841 uint32_t device_id; 842 uint32_t sge_count; 843 uint8_t cdb[32], cdb_len; 844 845 memset(cdb, 0, 32); 846 struct mfi_mpi2_request_raid_scsi_io *io_request = cmd->io_request; 847 848 device_id = mfi_cmd->cm_frame->header.target_id; 849 850 /* Have to build CDB here for TB as BSD don't have a scsi layer */ 851 if ((cdb_len = mfi_tbolt_build_cdb(sc, mfi_cmd, cdb)) == 1) 852 return 1; 853 854 /* Just the CDB length,rest of the Flags are zero */ 855 io_request->IoFlags = cdb_len; 856 memcpy(io_request->CDB.CDB32, cdb, 32); 857 858 if (mfi_tbolt_is_ldio(mfi_cmd)) 859 mfi_tbolt_build_ldio(sc, mfi_cmd , cmd); 860 else 861 return 1; 862 863 /* 864 * Construct SGL 865 */ 866 sge_count = mfi_tbolt_make_sgl(sc, mfi_cmd, 867 (pMpi25IeeeSgeChain64_t) &io_request->SGL, cmd); 868 if (sge_count > sc->mfi_max_sge) { 869 device_printf(sc->mfi_dev, "Error. sge_count (0x%x) exceeds " 870 "max (0x%x) allowed\n", sge_count, sc->mfi_max_sge); 871 return 1; 872 } 873 io_request->RaidContext.numSGE = sge_count; 874 io_request->SGLFlags = MPI2_SGE_FLAGS_64_BIT_ADDRESSING; 875 876 if (mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_WRITE) 877 io_request->Control = MPI2_SCSIIO_CONTROL_WRITE; 878 else 879 io_request->Control = MPI2_SCSIIO_CONTROL_READ; 880 881 io_request->SGLOffset0 = offsetof( 882 struct mfi_mpi2_request_raid_scsi_io, SGL)/4; 883 884 io_request->SenseBufferLowAddress = mfi_cmd->cm_sense_busaddr; 885 io_request->SenseBufferLength = MFI_SENSE_LEN; 886 return 0; 887 } 888 889 static int 890 mfi_tbolt_build_cdb(struct mfi_softc *sc, struct mfi_command *mfi_cmd, 891 uint8_t *cdb) 892 { 893 uint32_t lba_lo, lba_hi, num_lba; 894 uint8_t cdb_len; 895 896 if (mfi_cmd == NULL || cdb == NULL) 897 return 1; 898 num_lba = mfi_cmd->cm_frame->io.header.data_len; 899 lba_lo = mfi_cmd->cm_frame->io.lba_lo; 900 lba_hi = mfi_cmd->cm_frame->io.lba_hi; 901 902 if (lba_hi == 0 && (num_lba <= 0xFF) && (lba_lo <= 0x1FFFFF)) { 903 if (mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_WRITE) 904 /* Read 6 or Write 6 */ 905 cdb[0] = (uint8_t) (0x0A); 906 else 907 cdb[0] = (uint8_t) (0x08); 908 909 cdb[4] = (uint8_t) num_lba; 910 cdb[3] = (uint8_t) (lba_lo & 0xFF); 911 cdb[2] = (uint8_t) (lba_lo >> 8); 912 cdb[1] = (uint8_t) ((lba_lo >> 16) & 0x1F); 913 cdb_len = 6; 914 } 915 else if (lba_hi == 0 && (num_lba <= 0xFFFF) && (lba_lo <= 0xFFFFFFFF)) { 916 if (mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_WRITE) 917 /* Read 10 or Write 10 */ 918 cdb[0] = (uint8_t) (0x2A); 919 else 920 cdb[0] = (uint8_t) (0x28); 921 cdb[8] = (uint8_t) (num_lba & 0xFF); 922 cdb[7] = (uint8_t) (num_lba >> 8); 923 cdb[5] = (uint8_t) (lba_lo & 0xFF); 924 cdb[4] = (uint8_t) (lba_lo >> 8); 925 cdb[3] = (uint8_t) (lba_lo >> 16); 926 cdb[2] = (uint8_t) (lba_lo >> 24); 927 cdb_len = 10; 928 } else if ((num_lba > 0xFFFF) && (lba_hi == 0)) { 929 if (mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_WRITE) 930 /* Read 12 or Write 12 */ 931 cdb[0] = (uint8_t) (0xAA); 932 else 933 cdb[0] = (uint8_t) (0xA8); 934 cdb[9] = (uint8_t) (num_lba & 0xFF); 935 cdb[8] = (uint8_t) (num_lba >> 8); 936 cdb[7] = (uint8_t) (num_lba >> 16); 937 cdb[6] = (uint8_t) (num_lba >> 24); 938 cdb[5] = (uint8_t) (lba_lo & 0xFF); 939 cdb[4] = (uint8_t) (lba_lo >> 8); 940 cdb[3] = (uint8_t) (lba_lo >> 16); 941 cdb[2] = (uint8_t) (lba_lo >> 24); 942 cdb_len = 12; 943 } else { 944 if (mfi_cmd->cm_frame->header.cmd == MFI_CMD_LD_WRITE) 945 cdb[0] = (uint8_t) (0x8A); 946 else 947 cdb[0] = (uint8_t) (0x88); 948 cdb[13] = (uint8_t) (num_lba & 0xFF); 949 cdb[12] = (uint8_t) (num_lba >> 8); 950 cdb[11] = (uint8_t) (num_lba >> 16); 951 cdb[10] = (uint8_t) (num_lba >> 24); 952 cdb[9] = (uint8_t) (lba_lo & 0xFF); 953 cdb[8] = (uint8_t) (lba_lo >> 8); 954 cdb[7] = (uint8_t) (lba_lo >> 16); 955 cdb[6] = (uint8_t) (lba_lo >> 24); 956 cdb[5] = (uint8_t) (lba_hi & 0xFF); 957 cdb[4] = (uint8_t) (lba_hi >> 8); 958 cdb[3] = (uint8_t) (lba_hi >> 16); 959 cdb[2] = (uint8_t) (lba_hi >> 24); 960 cdb_len = 16; 961 } 962 return cdb_len; 963 } 964 965 static int 966 mfi_tbolt_make_sgl(struct mfi_softc *sc, struct mfi_command *mfi_cmd, 967 pMpi25IeeeSgeChain64_t sgl_ptr, struct mfi_cmd_tbolt *cmd) 968 { 969 uint8_t i, sg_processed, sg_to_process; 970 uint8_t sge_count, sge_idx; 971 union mfi_sgl *os_sgl; 972 973 /* 974 * Return 0 if there is no data transfer 975 */ 976 if (!mfi_cmd->cm_sg || !mfi_cmd->cm_len) { 977 device_printf(sc->mfi_dev, "Buffer empty \n"); 978 return 0; 979 } 980 os_sgl = mfi_cmd->cm_sg; 981 sge_count = mfi_cmd->cm_frame->header.sg_count; 982 983 if (sge_count > sc->mfi_max_sge) { 984 device_printf(sc->mfi_dev, "sgl ptr %p sg_cnt %d \n", 985 os_sgl, sge_count); 986 return sge_count; 987 } 988 989 if (sge_count > sc->max_SGEs_in_main_message) 990 /* One element to store the chain info */ 991 sge_idx = sc->max_SGEs_in_main_message - 1; 992 else 993 sge_idx = sge_count; 994 995 for (i = 0; i < sge_idx; i++) { 996 /* 997 * For 32bit BSD we are getting 32 bit SGL's from OS 998 * but FW only take 64 bit SGL's so copying from 32 bit 999 * SGL's to 64. 1000 */ 1001 if (sc->mfi_flags & MFI_FLAGS_SKINNY) { 1002 sgl_ptr->Length = os_sgl->sg_skinny[i].len; 1003 sgl_ptr->Address = os_sgl->sg_skinny[i].addr; 1004 } else { 1005 sgl_ptr->Length = os_sgl->sg32[i].len; 1006 sgl_ptr->Address = os_sgl->sg32[i].addr; 1007 } 1008 sgl_ptr->Flags = 0; 1009 sgl_ptr++; 1010 cmd->io_request->ChainOffset = 0; 1011 } 1012 1013 sg_processed = i; 1014 1015 if (sg_processed < sge_count) { 1016 pMpi25IeeeSgeChain64_t sg_chain; 1017 sg_to_process = sge_count - sg_processed; 1018 cmd->io_request->ChainOffset = 1019 sc->chain_offset_value_for_main_message; 1020 sg_chain = sgl_ptr; 1021 /* Prepare chain element */ 1022 sg_chain->NextChainOffset = 0; 1023 sg_chain->Flags = (MPI2_IEEE_SGE_FLAGS_CHAIN_ELEMENT | 1024 MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR); 1025 sg_chain->Length = (sizeof(MPI2_SGE_IO_UNION) * 1026 (sge_count - sg_processed)); 1027 sg_chain->Address = cmd->sg_frame_phys_addr; 1028 sgl_ptr = (pMpi25IeeeSgeChain64_t)cmd->sg_frame; 1029 for (; i < sge_count; i++) { 1030 if (sc->mfi_flags & MFI_FLAGS_SKINNY) { 1031 sgl_ptr->Length = os_sgl->sg_skinny[i].len; 1032 sgl_ptr->Address = os_sgl->sg_skinny[i].addr; 1033 } else { 1034 sgl_ptr->Length = os_sgl->sg32[i].len; 1035 sgl_ptr->Address = os_sgl->sg32[i].addr; 1036 } 1037 sgl_ptr->Flags = 0; 1038 sgl_ptr++; 1039 } 1040 } 1041 return sge_count; 1042 } 1043 1044 union mfi_mpi2_request_descriptor * 1045 mfi_build_and_issue_cmd(struct mfi_softc *sc, struct mfi_command *mfi_cmd) 1046 { 1047 struct mfi_cmd_tbolt *cmd; 1048 union mfi_mpi2_request_descriptor *req_desc = NULL; 1049 uint16_t index; 1050 cmd = mfi_tbolt_get_cmd(sc); 1051 if (!cmd) 1052 return NULL; 1053 mfi_cmd->cm_extra_frames = cmd->index; 1054 cmd->sync_cmd_idx = mfi_cmd->cm_index; 1055 1056 index = cmd->index; 1057 req_desc = mfi_tbolt_get_request_descriptor(sc, index-1); 1058 if (mfi_tbolt_build_io(sc, mfi_cmd, cmd)) 1059 return NULL; 1060 req_desc->header.SMID = index; 1061 return req_desc; 1062 } 1063 1064 union mfi_mpi2_request_descriptor * 1065 mfi_tbolt_build_mpt_cmd(struct mfi_softc *sc, struct mfi_command *cmd) 1066 { 1067 union mfi_mpi2_request_descriptor *req_desc = NULL; 1068 uint16_t index; 1069 if (mfi_build_mpt_pass_thru(sc, cmd)) { 1070 device_printf(sc->mfi_dev, "Couldn't build MFI pass thru " 1071 "cmd\n"); 1072 return NULL; 1073 } 1074 /* For fusion the frame_count variable is used for SMID */ 1075 index = cmd->cm_extra_frames; 1076 1077 req_desc = mfi_tbolt_get_request_descriptor(sc, index - 1); 1078 if (!req_desc) 1079 return NULL; 1080 1081 bzero(req_desc, sizeof(*req_desc)); 1082 req_desc->header.RequestFlags = (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO << 1083 MFI_REQ_DESCRIPT_FLAGS_TYPE_SHIFT); 1084 req_desc->header.SMID = index; 1085 return req_desc; 1086 } 1087 1088 int 1089 mfi_tbolt_send_frame(struct mfi_softc *sc, struct mfi_command *cm) 1090 { 1091 struct mfi_frame_header *hdr; 1092 uint8_t *cdb; 1093 union mfi_mpi2_request_descriptor *req_desc = NULL; 1094 int tm = MFI_POLL_TIMEOUT_SECS * 1000; 1095 1096 hdr = &cm->cm_frame->header; 1097 cdb = cm->cm_frame->pass.cdb; 1098 if (sc->adpreset) 1099 return 1; 1100 if ((cm->cm_flags & MFI_CMD_POLLED) == 0) { 1101 cm->cm_timestamp = time_uptime; 1102 mfi_enqueue_busy(cm); 1103 } 1104 else { /* still get interrupts for it */ 1105 hdr->cmd_status = MFI_STAT_INVALID_STATUS; 1106 hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE; 1107 } 1108 1109 if (hdr->cmd == MFI_CMD_PD_SCSI_IO) { 1110 /* check for inquiry commands coming from CLI */ 1111 if (cdb[0] != 0x28 || cdb[0] != 0x2A) { 1112 if ((req_desc = mfi_tbolt_build_mpt_cmd(sc, cm)) == 1113 NULL) { 1114 device_printf(sc->mfi_dev, "Mapping from MFI " 1115 "to MPT Failed \n"); 1116 return 1; 1117 } 1118 } 1119 else 1120 device_printf(sc->mfi_dev, "DJA NA XXX SYSPDIO\n"); 1121 } 1122 else if (hdr->cmd == MFI_CMD_LD_SCSI_IO || 1123 hdr->cmd == MFI_CMD_LD_READ || hdr->cmd == MFI_CMD_LD_WRITE) { 1124 if ((req_desc = mfi_build_and_issue_cmd(sc, cm)) == NULL) { 1125 device_printf(sc->mfi_dev, "LDIO Failed \n"); 1126 return 1; 1127 } 1128 } else 1129 if ((req_desc = mfi_tbolt_build_mpt_cmd(sc, cm)) == NULL) { 1130 device_printf(sc->mfi_dev, "Mapping from MFI to MPT " 1131 "Failed\n"); 1132 return 1; 1133 } 1134 MFI_WRITE4(sc, MFI_ILQP, (req_desc->words & 0xFFFFFFFF)); 1135 MFI_WRITE4(sc, MFI_IHQP, (req_desc->words >>0x20)); 1136 1137 if ((cm->cm_flags & MFI_CMD_POLLED) == 0) 1138 return 0; 1139 1140 /* This is a polled command, so busy-wait for it to complete. */ 1141 while (hdr->cmd_status == MFI_STAT_INVALID_STATUS) { 1142 DELAY(1000); 1143 tm -= 1; 1144 if (tm <= 0) 1145 break; 1146 } 1147 1148 if (hdr->cmd_status == MFI_STAT_INVALID_STATUS) { 1149 device_printf(sc->mfi_dev, "Frame %p timed out " 1150 "command 0x%X\n", hdr, cm->cm_frame->dcmd.opcode); 1151 return (ETIMEDOUT); 1152 } 1153 return 0; 1154 } 1155 1156 static void 1157 mfi_issue_pending_cmds_again (struct mfi_softc *sc) 1158 { 1159 struct mfi_command *cm, *tmp; 1160 1161 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1162 TAILQ_FOREACH_REVERSE_SAFE(cm, &sc->mfi_busy, BUSYQ, cm_link, tmp) { 1163 1164 cm->retry_for_fw_reset++; 1165 1166 /* 1167 * If a command has continuously been tried multiple times 1168 * and causing a FW reset condition, no further recoveries 1169 * should be performed on the controller 1170 */ 1171 if (cm->retry_for_fw_reset == 3) { 1172 device_printf(sc->mfi_dev, "megaraid_sas: command %d " 1173 "was tried multiple times during adapter reset" 1174 "Shutting down the HBA\n", cm->cm_index); 1175 mfi_kill_hba(sc); 1176 sc->hw_crit_error = 1; 1177 return; 1178 } 1179 1180 if ((cm->cm_flags & MFI_ON_MFIQ_BUSY) != 0) { 1181 struct mfi_cmd_tbolt *cmd; 1182 mfi_remove_busy(cm); 1183 cmd = sc->mfi_cmd_pool_tbolt[cm->cm_extra_frames - 1184 1 ]; 1185 mfi_tbolt_return_cmd(sc, cmd); 1186 if ((cm->cm_flags & MFI_ON_MFIQ_MASK) == 0) { 1187 if (cm->cm_frame->dcmd.opcode != 1188 MFI_DCMD_CTRL_EVENT_WAIT) { 1189 device_printf(sc->mfi_dev, 1190 "APJ ****requeue command %d \n", 1191 cm->cm_index); 1192 mfi_requeue_ready(cm); 1193 } 1194 } 1195 else 1196 mfi_release_command(cm); 1197 } 1198 } 1199 mfi_startio(sc); 1200 } 1201 1202 static void 1203 mfi_kill_hba (struct mfi_softc *sc) 1204 { 1205 if (sc->mfi_flags & MFI_FLAGS_TBOLT) 1206 MFI_WRITE4 (sc, 0x00,MFI_STOP_ADP); 1207 else 1208 MFI_WRITE4 (sc, MFI_IDB,MFI_STOP_ADP); 1209 } 1210 1211 static void 1212 mfi_process_fw_state_chg_isr(void *arg) 1213 { 1214 struct mfi_softc *sc= (struct mfi_softc *)arg; 1215 struct mfi_cmd_tbolt *cmd; 1216 int error, status; 1217 1218 if (sc->adpreset == 1) { 1219 device_printf(sc->mfi_dev, "First stage of FW reset " 1220 "initiated...\n"); 1221 1222 sc->mfi_adp_reset(sc); 1223 sc->mfi_enable_intr(sc); 1224 1225 device_printf(sc->mfi_dev, "First stage of reset complete, " 1226 "second stage initiated...\n"); 1227 1228 sc->adpreset = 2; 1229 1230 /* waiting for about 20 second before start the second init */ 1231 for (int wait = 0; wait < 20000; wait++) 1232 DELAY(1000); 1233 device_printf(sc->mfi_dev, "Second stage of FW reset " 1234 "initiated...\n"); 1235 while ((status = MFI_READ4(sc, MFI_RSR)) & 0x04); 1236 1237 sc->mfi_disable_intr(sc); 1238 1239 /* We expect the FW state to be READY */ 1240 if (mfi_transition_firmware(sc)) { 1241 device_printf(sc->mfi_dev, "controller is not in " 1242 "ready state\n"); 1243 mfi_kill_hba(sc); 1244 sc->hw_crit_error= 1; 1245 return ; 1246 } 1247 if ((error = mfi_tbolt_init_MFI_queue(sc)) != 0) 1248 return; 1249 1250 mtx_lock(&sc->mfi_io_lock); 1251 1252 sc->mfi_enable_intr(sc); 1253 sc->adpreset = 0; 1254 free(sc->mfi_aen_cm->cm_data, M_MFIBUF); 1255 mfi_remove_busy(sc->mfi_aen_cm); 1256 cmd = sc->mfi_cmd_pool_tbolt[sc->mfi_aen_cm->cm_extra_frames 1257 - 1]; 1258 mfi_tbolt_return_cmd(sc, cmd); 1259 if (sc->mfi_aen_cm) { 1260 mfi_release_command(sc->mfi_aen_cm); 1261 sc->mfi_aen_cm = NULL; 1262 } 1263 if (sc->mfi_map_sync_cm) { 1264 mfi_release_command(sc->mfi_map_sync_cm); 1265 sc->mfi_map_sync_cm = NULL; 1266 } 1267 mfi_issue_pending_cmds_again(sc); 1268 1269 /* 1270 * Issue pending command can result in adapter being marked 1271 * dead because of too many re-tries. Check for that 1272 * condition before clearing the reset condition on the FW 1273 */ 1274 if (!sc->hw_crit_error) { 1275 /* 1276 * Initiate AEN (Asynchronous Event Notification) 1277 */ 1278 mfi_aen_setup(sc, sc->last_seq_num); 1279 sc->issuepend_done = 1; 1280 device_printf(sc->mfi_dev, "second stage of reset " 1281 "complete, FW is ready now.\n"); 1282 } else { 1283 device_printf(sc->mfi_dev, "second stage of reset " 1284 "never completed, hba was marked offline.\n"); 1285 } 1286 } else { 1287 device_printf(sc->mfi_dev, "mfi_process_fw_state_chg_isr " 1288 "called with unhandled value:%d\n", sc->adpreset); 1289 } 1290 mtx_unlock(&sc->mfi_io_lock); 1291 } 1292 1293 /* 1294 * The ThunderBolt HW has an option for the driver to directly 1295 * access the underlying disks and operate on the RAID. To 1296 * do this there needs to be a capability to keep the RAID controller 1297 * and driver in sync. The FreeBSD driver does not take advantage 1298 * of this feature since it adds a lot of complexity and slows down 1299 * performance. Performance is gained by using the controller's 1300 * cache etc. 1301 * 1302 * Even though this driver doesn't access the disks directly, an 1303 * AEN like command is used to inform the RAID firmware to "sync" 1304 * with all LD's via the MFI_DCMD_LD_MAP_GET_INFO command. This 1305 * command in write mode will return when the RAID firmware has 1306 * detected a change to the RAID state. Examples of this type 1307 * of change are removing a disk. Once the command returns then 1308 * the driver needs to acknowledge this and "sync" all LD's again. 1309 * This repeats until we shutdown. Then we need to cancel this 1310 * pending command. 1311 * 1312 * If this is not done right the RAID firmware will not remove a 1313 * pulled drive and the RAID won't go degraded etc. Effectively, 1314 * stopping any RAID mangement to functions. 1315 * 1316 * Doing another LD sync, requires the use of an event since the 1317 * driver needs to do a mfi_wait_command and can't do that in an 1318 * interrupt thread. 1319 * 1320 * The driver could get the RAID state via the MFI_DCMD_LD_MAP_GET_INFO 1321 * That requires a bunch of structure and it is simplier to just do 1322 * the MFI_DCMD_LD_GET_LIST versus walking the RAID map. 1323 */ 1324 1325 void 1326 mfi_tbolt_sync_map_info(struct mfi_softc *sc) 1327 { 1328 int error = 0, i; 1329 struct mfi_command *cmd; 1330 struct mfi_dcmd_frame *dcmd; 1331 uint32_t context = 0; 1332 union mfi_ld_ref *ld_sync; 1333 size_t ld_size; 1334 struct mfi_frame_header *hdr; 1335 struct mfi_command *cm = NULL; 1336 struct mfi_ld_list *list = NULL; 1337 1338 if (sc->mfi_map_sync_cm != NULL || sc->cm_map_abort) 1339 return; 1340 1341 mtx_lock(&sc->mfi_io_lock); 1342 error = mfi_dcmd_command(sc, &cm, MFI_DCMD_LD_GET_LIST, 1343 (void **)&list, sizeof(*list)); 1344 if (error) 1345 goto out; 1346 1347 cm->cm_flags = MFI_CMD_POLLED | MFI_CMD_DATAIN; 1348 if (mfi_wait_command(sc, cm) != 0) { 1349 device_printf(sc->mfi_dev, "Failed to get device listing\n"); 1350 goto out; 1351 } 1352 1353 hdr = &cm->cm_frame->header; 1354 if (hdr->cmd_status != MFI_STAT_OK) { 1355 device_printf(sc->mfi_dev, "MFI_DCMD_LD_GET_LIST failed %x\n", 1356 hdr->cmd_status); 1357 goto out; 1358 } 1359 1360 ld_size = sizeof(*ld_sync) * list->ld_count; 1361 mtx_unlock(&sc->mfi_io_lock); 1362 ld_sync = (union mfi_ld_ref *) malloc(ld_size, M_MFIBUF, 1363 M_WAITOK | M_ZERO); 1364 if (ld_sync == NULL) { 1365 device_printf(sc->mfi_dev, "Failed to allocate sync\n"); 1366 goto out; 1367 } 1368 for (i = 0; i < list->ld_count; i++) { 1369 ld_sync[i].ref = list->ld_list[i].ld.ref; 1370 } 1371 1372 mtx_lock(&sc->mfi_io_lock); 1373 if ((cmd = mfi_dequeue_free(sc)) == NULL) { 1374 device_printf(sc->mfi_dev, "Failed to get command\n"); 1375 free(ld_sync, M_MFIBUF); 1376 goto out; 1377 } 1378 1379 context = cmd->cm_frame->header.context; 1380 bzero(cmd->cm_frame, sizeof(union mfi_frame)); 1381 cmd->cm_frame->header.context = context; 1382 1383 dcmd = &cmd->cm_frame->dcmd; 1384 bzero(dcmd->mbox, MFI_MBOX_SIZE); 1385 dcmd->header.cmd = MFI_CMD_DCMD; 1386 dcmd->header.flags = MFI_FRAME_DIR_WRITE; 1387 dcmd->header.timeout = 0; 1388 dcmd->header.data_len = ld_size; 1389 dcmd->header.scsi_status = 0; 1390 dcmd->opcode = MFI_DCMD_LD_MAP_GET_INFO; 1391 cmd->cm_sg = &dcmd->sgl; 1392 cmd->cm_total_frame_size = MFI_DCMD_FRAME_SIZE; 1393 cmd->cm_data = ld_sync; 1394 cmd->cm_private = ld_sync; 1395 1396 cmd->cm_len = ld_size; 1397 cmd->cm_complete = mfi_sync_map_complete; 1398 sc->mfi_map_sync_cm = cmd; 1399 1400 cmd->cm_flags = MFI_CMD_DATAOUT; 1401 cmd->cm_frame->dcmd.mbox[0] = list->ld_count; 1402 cmd->cm_frame->dcmd.mbox[1] = MFI_DCMD_MBOX_PEND_FLAG; 1403 1404 if ((error = mfi_mapcmd(sc, cmd)) != 0) { 1405 device_printf(sc->mfi_dev, "failed to send map sync\n"); 1406 free(ld_sync, M_MFIBUF); 1407 sc->mfi_map_sync_cm = NULL; 1408 mfi_requeue_ready(cmd); 1409 goto out; 1410 } 1411 1412 out: 1413 if (list) 1414 free(list, M_MFIBUF); 1415 if (cm) 1416 mfi_release_command(cm); 1417 mtx_unlock(&sc->mfi_io_lock); 1418 } 1419 1420 static void 1421 mfi_sync_map_complete(struct mfi_command *cm) 1422 { 1423 struct mfi_frame_header *hdr; 1424 struct mfi_softc *sc; 1425 int aborted = 0; 1426 1427 sc = cm->cm_sc; 1428 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1429 1430 hdr = &cm->cm_frame->header; 1431 1432 if (sc->mfi_map_sync_cm == NULL) 1433 return; 1434 1435 if (sc->cm_map_abort || 1436 hdr->cmd_status == MFI_STAT_INVALID_STATUS) { 1437 sc->cm_map_abort = 0; 1438 aborted = 1; 1439 } 1440 1441 free(cm->cm_data, M_MFIBUF); 1442 sc->mfi_map_sync_cm = NULL; 1443 wakeup(&sc->mfi_map_sync_cm); 1444 mfi_release_command(cm); 1445 1446 /* set it up again so the driver can catch more events */ 1447 if (!aborted) { 1448 mfi_queue_map_sync(sc); 1449 } 1450 } 1451 1452 static void 1453 mfi_queue_map_sync(struct mfi_softc *sc) 1454 { 1455 mtx_assert(&sc->mfi_io_lock, MA_OWNED); 1456 taskqueue_enqueue(taskqueue_swi, &sc->mfi_map_sync_task); 1457 } 1458 1459 void 1460 mfi_handle_map_sync(void *context, int pending) 1461 { 1462 struct mfi_softc *sc; 1463 1464 sc = context; 1465 mfi_tbolt_sync_map_info(sc); 1466 } 1467