Lines Matching refs:instance
52 megasas_complete_cmd(struct megasas_instance *instance,
55 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
59 megasas_clear_intr_fusion(struct megasas_instance *instance);
61 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
64 int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
69 static void megasas_free_rdpq_fusion(struct megasas_instance *instance);
70 static void megasas_free_reply_fusion(struct megasas_instance *instance);
72 void megasas_configure_queue_sizes(struct megasas_instance *instance);
73 static void megasas_fusion_crash_dump(struct megasas_instance *instance);
78 * @instance: adapter's soft state
88 megasas_adp_reset_wait_for_ready(struct megasas_instance *instance,
99 dev_info(&instance->pdev->dev,
103 pci_cfg_access_lock(instance->pdev);
106 if (instance->instancet->adp_reset
107 (instance, instance->reg_set))
112 if (megasas_transition_to_ready(instance, ocr_context)) {
113 dev_warn(&instance->pdev->dev,
115 instance->host->host_no);
122 dev_info(&instance->pdev->dev,
126 pci_cfg_access_unlock(instance->pdev);
134 * @instance: adapter's soft instance
143 (struct megasas_instance *instance, dma_addr_t start_addr, size_t size)
150 dev_err(&instance->pdev->dev,
162 * @instance: adapter's soft instance
165 megasas_enable_intr_fusion(struct megasas_instance *instance)
168 regs = instance->reg_set;
170 instance->mask_interrupts = 0;
178 dev_info(&instance->pdev->dev, "%s is called outbound_intr_mask:0x%08x\n",
184 * @instance: adapter's soft instance
187 megasas_disable_intr_fusion(struct megasas_instance *instance)
191 regs = instance->reg_set;
192 instance->mask_interrupts = 1;
196 dev_info(&instance->pdev->dev, "%s is called outbound_intr_mask:0x%08x\n",
201 megasas_clear_intr_fusion(struct megasas_instance *instance)
205 regs = instance->reg_set;
209 status = megasas_readl(instance,
224 megasas_sdev_busy_inc(struct megasas_instance *instance,
227 if (instance->perf_mode == MR_BALANCED_PERF_MODE) {
235 megasas_sdev_busy_dec(struct megasas_instance *instance,
238 if (instance->perf_mode == MR_BALANCED_PERF_MODE) {
246 megasas_sdev_busy_read(struct megasas_instance *instance,
249 if (instance->perf_mode == MR_BALANCED_PERF_MODE) {
259 * @instance: Adapter soft state
265 *instance, u32 blk_tag)
269 fusion = instance->ctrl_context;
275 * @instance: Adapter soft state
278 inline void megasas_return_cmd_fusion(struct megasas_instance *instance,
289 * @instance: Adapter soft state
293 megasas_write_64bit_req_desc(struct megasas_instance *instance,
299 writeq(req_data, &instance->reg_set->inbound_low_queue_port);
302 spin_lock_irqsave(&instance->hba_lock, flags);
304 &instance->reg_set->inbound_low_queue_port);
306 &instance->reg_set->inbound_high_queue_port);
307 spin_unlock_irqrestore(&instance->hba_lock, flags);
313 * @instance: Adapter soft state
320 megasas_fire_cmd_fusion(struct megasas_instance *instance,
323 if (instance->atomic_desc_support)
325 &instance->reg_set->inbound_single_queue_port);
327 megasas_write_64bit_req_desc(instance, req_desc);
332 * @instance: Adapter soft state
342 megasas_fusion_update_can_queue(struct megasas_instance *instance, int fw_boot_context)
348 if (instance->adapter_type < VENTURA_SERIES)
350 megasas_readl(instance,
351 &instance->reg_set->outbound_scratch_pad_2) & 0x00FFFF;
354 cur_max_fw_cmds = instance->instancet->read_fw_status_reg(instance) & 0x00FFFF;
357 (instance->instancet->read_fw_status_reg(instance) & 0x00FFFF) - MEGASAS_FUSION_IOCTL_CMDS;
359 dev_info(&instance->pdev->dev,
365 if (cur_max_fw_cmds < instance->max_fw_cmds) {
366 instance->cur_can_queue =
369 instance->host->can_queue = instance->cur_can_queue;
370 instance->ldio_threshold = ldio_threshold;
373 instance->max_fw_cmds = cur_max_fw_cmds;
374 instance->ldio_threshold = ldio_threshold;
377 instance->max_fw_cmds = min(instance->max_fw_cmds,
384 instance->max_fw_cmds = instance->max_fw_cmds-1;
389 megasas_get_msix_index(struct megasas_instance *instance,
394 if (instance->perf_mode == MR_BALANCED_PERF_MODE &&
395 (megasas_sdev_busy_read(instance, scmd) >
398 mega_mod64((atomic64_add_return(1, &instance->high_iops_outstanding) /
399 MR_HIGH_IOPS_BATCH_COUNT), instance->low_latency_index_start);
400 } else if (instance->msix_load_balance) {
402 (mega_mod64(atomic64_add_return(1, &instance->total_io_count),
403 instance->msix_vectors));
404 } else if (instance->host->nr_hw_queues > 1) {
408 instance->low_latency_index_start;
411 instance->reply_map[raw_smp_processor_id()];
417 * @instance: Adapter soft state
420 megasas_free_cmds_fusion(struct megasas_instance *instance)
423 struct fusion_context *fusion = instance->ctrl_context;
432 for (i = 0; i < instance->max_mpt_cmds; i++) {
456 if (instance->is_rdpq)
457 megasas_free_rdpq_fusion(instance);
459 megasas_free_reply_fusion(instance);
463 dma_free_coherent(&instance->pdev->dev,
478 * @instance: Adapter soft state
481 static int megasas_create_sg_sense_fusion(struct megasas_instance *instance)
490 fusion = instance->ctrl_context;
491 max_cmd = instance->max_fw_cmds;
492 sense_sz = instance->max_mpt_cmds * SCSI_SENSE_BUFFERSIZE;
495 dma_pool_create("mr_sg", &instance->pdev->dev,
496 instance->max_chain_frame_sz,
500 dma_pool_create("mr_sense", &instance->pdev->dev,
504 dev_err(&instance->pdev->dev,
512 dev_err(&instance->pdev->dev,
528 if (!megasas_check_same_4gb_region(instance, fusion->sense_phys_addr,
536 dma_pool_create("mr_sense_align", &instance->pdev->dev,
540 dev_err(&instance->pdev->dev,
548 dev_err(&instance->pdev->dev,
567 dev_err(&instance->pdev->dev,
574 for (i = max_cmd; i < instance->max_mpt_cmds; i++) {
586 megasas_alloc_cmdlist_fusion(struct megasas_instance *instance)
591 fusion = instance->ctrl_context;
593 max_mpt_cmd = instance->max_mpt_cmds;
604 dev_err(&instance->pdev->dev,
616 dev_err(&instance->pdev->dev,
626 megasas_alloc_request_fusion(struct megasas_instance *instance)
630 fusion = instance->ctrl_context;
634 dma_pool_create("mr_ioreq", &instance->pdev->dev,
638 dev_err(&instance->pdev->dev,
648 if (instance->max_fw_cmds >= (MEGASAS_REDUCE_QD_COUNT * 2)) {
649 instance->max_fw_cmds -= MEGASAS_REDUCE_QD_COUNT;
651 megasas_configure_queue_sizes(instance);
654 dev_err(&instance->pdev->dev,
660 if (!megasas_check_same_4gb_region(instance,
671 &instance->pdev->dev,
677 dev_err(&instance->pdev->dev,
688 dev_err(&instance->pdev->dev,
695 dma_alloc_coherent(&instance->pdev->dev,
699 dev_err(&instance->pdev->dev,
708 megasas_alloc_reply_fusion(struct megasas_instance *instance)
713 fusion = instance->ctrl_context;
715 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
716 count += instance->iopoll_q_count;
719 dma_pool_create("mr_reply", &instance->pdev->dev,
723 dev_err(&instance->pdev->dev,
732 dev_err(&instance->pdev->dev,
737 if (!megasas_check_same_4gb_region(instance,
748 &instance->pdev->dev,
754 dev_err(&instance->pdev->dev,
765 dev_err(&instance->pdev->dev,
787 megasas_alloc_rdpq_fusion(struct megasas_instance *instance)
797 fusion = instance->ctrl_context;
802 fusion->rdpq_virt = dma_alloc_coherent(&instance->pdev->dev,
806 dev_err(&instance->pdev->dev,
811 msix_count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
812 msix_count += instance->iopoll_q_count;
815 &instance->pdev->dev,
819 &instance->pdev->dev,
826 dev_err(&instance->pdev->dev,
846 dev_err(&instance->pdev->dev,
862 if (!megasas_check_same_4gb_region(instance, rdpq_chunk_phys[i],
872 dev_err(&instance->pdev->dev,
912 megasas_free_rdpq_fusion(struct megasas_instance *instance) {
917 fusion = instance->ctrl_context;
931 dma_free_coherent(&instance->pdev->dev,
937 megasas_free_reply_fusion(struct megasas_instance *instance) {
941 fusion = instance->ctrl_context;
955 * @instance: Adapter soft state
970 megasas_alloc_cmds_fusion(struct megasas_instance *instance)
980 fusion = instance->ctrl_context;
982 if (megasas_alloc_request_fusion(instance))
985 if (instance->is_rdpq) {
986 if (megasas_alloc_rdpq_fusion(instance))
989 if (megasas_alloc_reply_fusion(instance))
992 if (megasas_alloc_cmdlist_fusion(instance))
1004 for (i = 0; i < instance->max_mpt_cmds; i++) {
1011 (i >= instance->max_scsi_cmds && i < instance->max_fw_cmds) ?
1012 (i - instance->max_scsi_cmds) :
1014 cmd->instance = instance;
1024 if (megasas_create_sg_sense_fusion(instance))
1030 megasas_free_cmds_fusion(instance);
1036 * @instance: Adapter soft state
1043 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
1059 status_reg = instance->instancet->read_fw_status_reg(instance)
1076 * @instance: Adapter soft state
1081 megasas_ioc_init_fusion(struct megasas_instance *instance)
1099 fusion = instance->ctrl_context;
1107 (instance, &instance->reg_set->outbound_scratch_pad_1);
1111 if (instance->adapter_type == INVADER_SERIES) {
1115 if (instance->consistent_mask_64bit && !cur_fw_64bit_dma_capable) {
1116 dev_err(&instance->pdev->dev, "Driver was operating on 64bit "
1118 megaraid_sas_kill_hba(instance);
1124 if (instance->is_rdpq && !cur_rdpq_mode) {
1125 dev_err(&instance->pdev->dev, "Firmware downgrade *NOT SUPPORTED*"
1134 if ((instance->low_latency_index_start ==
1136 instance->perf_mode = MR_BALANCED_PERF_MODE;
1138 dev_info(&instance->pdev->dev, "Performance mode :%s (latency index = %d)\n",
1139 MEGASAS_PERF_MODE_2STR(instance->perf_mode),
1140 instance->low_latency_index_start);
1142 instance->fw_sync_cache_support = (scratch_pad_1 &
1144 dev_info(&instance->pdev->dev, "FW supports sync cache\t: %s\n",
1145 instance->fw_sync_cache_support ? "Yes" : "No");
1156 IOCInitMessage->ReplyDescriptorPostQueueAddress = instance->is_rdpq ?
1159 IOCInitMessage->MsgFlags = instance->is_rdpq ?
1163 IOCInitMessage->HostMSIxVectors = instance->msix_vectors + instance->iopoll_q_count;
1183 if (instance->adapter_type >= INVADER_SERIES)
1192 if (instance->max_chain_frame_sz > MEGASAS_CHAIN_FRAME_SZ_MIN)
1207 if (instance->consistent_mask_64bit)
1214 if (instance->system_info_buf && sys_info) {
1215 memcpy(instance->system_info_buf->systemId, sys_info,
1217 instance->system_info_buf->systemIdLength =
1219 init_frame->system_info_lo = cpu_to_le32(lower_32_bits(instance->system_info_h));
1220 init_frame->system_info_hi = cpu_to_le32(upper_32_bits(instance->system_info_h));
1233 switch (instance->perf_mode) {
1236 cpu_to_le16(~(~0 << instance->low_latency_index_start/8));
1240 cpu_to_le16(~(~0 << instance->msix_vectors/8));
1254 instance->instancet->disable_intr(instance);
1257 if (megasas_readl(instance, &instance->reg_set->doorbell) & 1)
1264 megasas_write_64bit_req_desc(instance, &req_desc);
1266 wait_and_poll(instance, cmd, MFI_IO_TIMEOUT_SECS);
1274 if (instance->adapter_type >= AERO_SERIES) {
1276 (instance, &instance->reg_set->outbound_scratch_pad_1);
1278 instance->atomic_desc_support =
1281 dev_info(&instance->pdev->dev, "FW supports atomic descriptor\t: %s\n",
1282 instance->atomic_desc_support ? "Yes" : "No");
1288 dev_err(&instance->pdev->dev,
1290 instance->host->host_no);
1297 * @instance: Adapter soft state
1301 * issue command and return. If it is first instance of jbod map
1305 megasas_sync_pd_seq_num(struct megasas_instance *instance, bool pend) {
1310 struct fusion_context *fusion = instance->ctrl_context;
1314 pd_sync = (void *)fusion->pd_seq_sync[(instance->pd_seq_map_id & 1)];
1315 pd_seq_h = fusion->pd_seq_phys[(instance->pd_seq_map_id & 1)];
1318 cmd = megasas_get_cmd(instance);
1320 dev_err(&instance->pdev->dev,
1334 instance->jbod_seq_cmd = cmd;
1347 megasas_set_dma_settings(instance, dcmd, pd_seq_h, pd_seq_map_sz);
1350 instance->instancet->issue_dcmd(instance, cmd);
1355 if (!instance->mask_interrupts)
1356 ret = megasas_issue_blocked_cmd(instance, cmd,
1359 ret = megasas_issue_polled(instance, cmd);
1362 dev_warn(&instance->pdev->dev,
1369 dev_warn(&instance->pdev->dev,
1374 instance->pd_seq_map_id++;
1376 megasas_return_cmd(instance, cmd);
1382 * @instance: Adapter soft state
1396 megasas_get_ld_map_info(struct megasas_instance *instance)
1406 cmd = megasas_get_cmd(instance);
1409 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get cmd for map info\n");
1413 fusion = instance->ctrl_context;
1416 megasas_return_cmd(instance, cmd);
1424 ci = (void *) fusion->ld_map[(instance->map_id & 1)];
1425 ci_h = fusion->ld_map_phys[(instance->map_id & 1)];
1428 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc mem for ld_map_info\n");
1429 megasas_return_cmd(instance, cmd);
1444 megasas_set_dma_settings(instance, dcmd, ci_h, size_map_info);
1446 if (!instance->mask_interrupts)
1447 ret = megasas_issue_blocked_cmd(instance, cmd,
1450 ret = megasas_issue_polled(instance, cmd);
1453 dev_warn(&instance->pdev->dev,
1457 megasas_return_cmd(instance, cmd);
1463 megasas_get_map_info(struct megasas_instance *instance)
1465 struct fusion_context *fusion = instance->ctrl_context;
1468 if (!megasas_get_ld_map_info(instance)) {
1469 if (MR_ValidateMapInfo(instance, instance->map_id)) {
1479 * @instance: Adapter soft state
1486 megasas_sync_map_info(struct megasas_instance *instance)
1500 cmd = megasas_get_cmd(instance);
1503 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get cmd for sync info\n");
1507 fusion = instance->ctrl_context;
1510 megasas_return_cmd(instance, cmd);
1514 map = fusion->ld_drv_map[instance->map_id & 1];
1523 fusion->ld_map[(instance->map_id - 1) & 1];
1526 ci_h = fusion->ld_map_phys[(instance->map_id - 1) & 1];
1549 megasas_set_dma_settings(instance, dcmd, ci_h, size_map_info);
1551 instance->map_update_cmd = cmd;
1553 instance->instancet->issue_dcmd(instance, cmd);
1560 * @instance: per adapter object
1565 megasas_display_intel_branding(struct megasas_instance *instance)
1567 if (instance->pdev->subsystem_vendor != PCI_VENDOR_ID_INTEL)
1570 switch (instance->pdev->device) {
1572 switch (instance->pdev->subsystem_device) {
1574 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1575 instance->host->host_no,
1579 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1580 instance->host->host_no,
1584 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1585 instance->host->host_no,
1589 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1590 instance->host->host_no,
1598 switch (instance->pdev->subsystem_device) {
1600 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1601 instance->host->host_no,
1605 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1606 instance->host->host_no,
1615 switch (instance->pdev->subsystem_device) {
1617 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1618 instance->host->host_no,
1632 * @instance: Adapter soft state
1637 static inline int megasas_allocate_raid_maps(struct megasas_instance *instance)
1642 fusion = instance->ctrl_context;
1657 dev_err(&instance->pdev->dev,
1667 fusion->ld_map[i] = dma_alloc_coherent(&instance->pdev->dev,
1672 dev_err(&instance->pdev->dev,
1684 dma_free_coherent(&instance->pdev->dev,
1708 * @instance: Adapter soft state
1712 void megasas_configure_queue_sizes(struct megasas_instance *instance)
1717 fusion = instance->ctrl_context;
1718 max_cmd = instance->max_fw_cmds;
1720 if (instance->adapter_type >= VENTURA_SERIES)
1721 instance->max_mpt_cmds = instance->max_fw_cmds * RAID_1_PEER_CMDS;
1723 instance->max_mpt_cmds = instance->max_fw_cmds;
1725 instance->max_scsi_cmds = instance->max_fw_cmds - instance->max_mfi_cmds;
1726 instance->cur_can_queue = instance->max_scsi_cmds;
1727 instance->host->can_queue = instance->cur_can_queue;
1732 instance->max_mpt_cmds;
1737 * (instance->max_mpt_cmds + 1)); /* Extra 1 for SMID 0 */
1740 static int megasas_alloc_ioc_init_frame(struct megasas_instance *instance)
1745 fusion = instance->ctrl_context;
1750 dev_err(&instance->pdev->dev, "Failed from func: %s line: %d\n",
1755 cmd->frame = dma_alloc_coherent(&instance->pdev->dev,
1760 dev_err(&instance->pdev->dev, "Failed from func: %s line: %d\n",
1772 * @instance: Adapter soft state
1774 static inline void megasas_free_ioc_init_cmd(struct megasas_instance *instance)
1778 fusion = instance->ctrl_context;
1781 dma_free_coherent(&instance->pdev->dev,
1791 * @instance: Adapter soft state
1796 megasas_init_adapter_fusion(struct megasas_instance *instance)
1803 fusion = instance->ctrl_context;
1805 megasas_fusion_update_can_queue(instance, PROBE_CONTEXT);
1810 instance->max_mfi_cmds =
1813 megasas_configure_queue_sizes(instance);
1815 scratch_pad_1 = megasas_readl(instance,
1816 &instance->reg_set->outbound_scratch_pad_1);
1824 instance->max_chain_frame_sz =
1828 instance->max_chain_frame_sz =
1832 if (instance->max_chain_frame_sz < MEGASAS_CHAIN_FRAME_SZ_MIN) {
1833 dev_warn(&instance->pdev->dev, "frame size %d invalid, fall back to legacy max frame size %d\n",
1834 instance->max_chain_frame_sz,
1836 instance->max_chain_frame_sz = MEGASAS_CHAIN_FRAME_SZ_MIN;
1844 instance->max_chain_frame_sz
1847 instance->max_num_sge =
1859 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
1860 count += instance->iopoll_q_count;
1869 instance->max_scsi_cmds = instance->max_fw_cmds -
1872 sema_init(&instance->ioctl_sem, MEGASAS_FUSION_IOCTL_CMDS);
1877 if (megasas_alloc_ioc_init_frame(instance))
1884 if (megasas_alloc_cmds(instance))
1886 if (megasas_alloc_cmds_fusion(instance))
1889 if (megasas_ioc_init_fusion(instance)) {
1890 status_reg = instance->instancet->read_fw_status_reg(instance);
1895 (instance, true, 0) == FAILED)
1898 if (megasas_ioc_init_fusion(instance))
1905 megasas_display_intel_branding(instance);
1906 if (megasas_get_ctrl_info(instance)) {
1907 dev_err(&instance->pdev->dev,
1913 instance->flag_ieee = 1;
1914 instance->r1_ldio_hint_default = MR_R1_LDIO_PIGGYBACK_DEFAULT;
1915 instance->threshold_reply_count = instance->max_fw_cmds / 4;
1918 if (megasas_allocate_raid_maps(instance))
1921 if (!megasas_get_map_info(instance))
1922 megasas_sync_map_info(instance);
1927 megasas_free_cmds_fusion(instance);
1929 megasas_free_cmds(instance);
1931 megasas_free_ioc_init_cmd(instance);
1943 struct megasas_instance *instance =
1949 fw_state = instance->instancet->read_fw_status_reg(instance) &
1953 dma_state = instance->instancet->read_fw_status_reg(instance) &
1956 if (instance->crash_dump_drv_support &&
1957 instance->crash_dump_app_support && dma_state) {
1958 megasas_fusion_crash_dump(instance);
1960 if (instance->unload == 0) {
1961 status = megasas_reset_fusion(instance->host, 0);
1963 dev_err(&instance->pdev->dev,
1972 if (instance->fw_fault_work_q)
1973 queue_delayed_work(instance->fw_fault_work_q,
1974 &instance->fw_fault_work,
1979 megasas_fusion_start_watchdog(struct megasas_instance *instance)
1982 if (instance->fw_fault_work_q)
1985 INIT_DELAYED_WORK(&instance->fw_fault_work, megasas_fault_detect_work);
1987 snprintf(instance->fault_handler_work_q_name,
1988 sizeof(instance->fault_handler_work_q_name),
1989 "poll_megasas%d_status", instance->host->host_no);
1991 instance->fw_fault_work_q = alloc_ordered_workqueue(
1992 "%s", WQ_MEM_RECLAIM, instance->fault_handler_work_q_name);
1993 if (!instance->fw_fault_work_q) {
1994 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1999 queue_delayed_work(instance->fw_fault_work_q,
2000 &instance->fw_fault_work,
2007 megasas_fusion_stop_watchdog(struct megasas_instance *instance)
2011 if (instance->fw_fault_work_q) {
2012 wq = instance->fw_fault_work_q;
2013 instance->fw_fault_work_q = NULL;
2014 if (!cancel_delayed_work_sync(&instance->fw_fault_work))
2094 * @instance: Adapter soft state
2102 megasas_is_prp_possible(struct megasas_instance *instance,
2110 mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
2140 * @instance: Adapter soft state
2150 megasas_make_prp_nvme(struct megasas_instance *instance, struct scsi_cmnd *scmd,
2164 u32 mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
2167 build_prp = megasas_is_prp_possible(instance, scmd, sge_count);
2187 memset(ptr_sgl, 0, instance->max_chain_frame_sz);
2265 * @instance: Adapter soft state
2273 megasas_make_sgl_fusion(struct megasas_instance *instance,
2282 fusion = instance->ctrl_context;
2284 if (instance->adapter_type >= INVADER_SERIES) {
2294 if (instance->adapter_type >= INVADER_SERIES)
2304 if (instance->adapter_type >= INVADER_SERIES) {
2320 if (instance->adapter_type >= INVADER_SERIES)
2331 memset(sgl_ptr, 0, instance->max_chain_frame_sz);
2339 * @instance: Soft instance of controller
2350 int megasas_make_sgl(struct megasas_instance *instance, struct scsi_cmnd *scp,
2359 if ((sge_count > instance->max_num_sge) || (sge_count <= 0))
2366 build_prp = megasas_make_prp_nvme(instance, scp, sgl_chain64,
2370 megasas_make_sgl_fusion(instance, scp, sgl_chain64,
2558 * @instance: Adapter soft state
2565 static void megasas_stream_detect(struct megasas_instance *instance,
2569 struct fusion_context *fusion = instance->ctrl_context;
2721 * @instance: Adapter soft state
2729 megasas_build_ldio_fusion(struct megasas_instance *instance,
2750 fusion = instance->ctrl_context;
2826 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
2829 if (ld < instance->fw_supported_vd_count)
2836 if (MR_BuildRaidContext(instance, &io_info, rctx,
2841 megasas_get_msix_index(instance, scp, cmd, io_info.data_arms);
2843 if (instance->adapter_type >= VENTURA_SERIES) {
2855 if (atomic_inc_return(&instance->fw_outstanding) >
2856 (instance->host->can_queue)) {
2858 atomic_dec(&instance->fw_outstanding);
2863 atomic_dec(&instance->fw_outstanding);
2866 instance->r1_ldio_hint_default);
2872 spin_lock_irqsave(&instance->stream_lock,
2874 megasas_stream_detect(instance, cmd, &io_info);
2875 spin_unlock_irqrestore(&instance->stream_lock,
2901 if (instance->adapter_type == INVADER_SERIES) {
2908 } else if (instance->adapter_type >= VENTURA_SERIES) {
2919 get_updated_dev_handle(instance,
2924 if (instance->adapter_type >= VENTURA_SERIES)
2932 if (instance->adapter_type >= VENTURA_SERIES)
2939 instance->dev_handle = !(instance->dev_handle);
2941 local_map_ptr->raidMap.devHndlInfo[io_info.pd_after_lb].devHandle[instance->dev_handle];
2955 if (instance->adapter_type == INVADER_SERIES) {
2966 } else if (instance->adapter_type >= VENTURA_SERIES) {
2979 * @instance: Adapter soft state
2985 static void megasas_build_ld_nonrw_fusion(struct megasas_instance *instance,
2992 struct fusion_context *fusion = instance->ctrl_context;
3002 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
3012 device_id < instance->fw_supported_vd_count)) {
3015 if (ld >= instance->fw_supported_vd_count - 1)
3038 if (instance->adapter_type < VENTURA_SERIES)
3067 * @instance: Adapter soft state
3075 megasas_build_syspd_fusion(struct megasas_instance *instance,
3088 struct fusion_context *fusion = instance->ctrl_context;
3089 pd_sync = (void *)fusion->pd_seq_sync[(instance->pd_seq_map_id - 1) & 1];
3109 if (instance->support_seqnum_jbod_fp) {
3110 if (instance->use_seqnum_jbod_fp &&
3111 instance->pd_list[pd_index].driveType == TYPE_DISK) {
3114 if (instance->support_morethan256jbod)
3125 if (instance->adapter_type >= VENTURA_SERIES) {
3152 fusion->ld_drv_map[(instance->map_id & 1)];
3162 megasas_get_msix_index(instance, scmd, cmd, 1);
3183 if (instance->adapter_type >= INVADER_SERIES)
3195 * @instance: Adapter soft state
3203 megasas_build_io_fusion(struct megasas_instance *instance,
3235 megasas_build_ldio_fusion(instance, scp, cmd);
3238 megasas_build_ld_nonrw_fusion(instance, scp, cmd);
3241 megasas_build_syspd_fusion(instance, scp, cmd, true);
3245 drive_type = instance->pd_list[pd_index].driveType;
3246 if ((instance->secure_jbod_support ||
3248 (instance->adapter_type >= VENTURA_SERIES &&
3250 megasas_build_syspd_fusion(instance, scp, cmd, false);
3252 megasas_build_syspd_fusion(instance, scp, cmd, true);
3262 sge_count = megasas_make_sgl(instance, scp, cmd);
3264 if (sge_count > instance->max_num_sge || (sge_count < 0)) {
3265 dev_err(&instance->pdev->dev,
3267 __func__, __LINE__, sge_count, instance->max_num_sge);
3271 if (instance->adapter_type >= VENTURA_SERIES) {
3305 megasas_get_request_descriptor(struct megasas_instance *instance, u16 index)
3310 fusion = instance->ctrl_context;
3321 static void megasas_prepare_secondRaid1_IO(struct megasas_instance *instance,
3327 fusion = instance->ctrl_context;
3338 req_desc2 = megasas_get_request_descriptor(instance,
3362 * @instance: Adapter soft state
3366 megasas_build_and_issue_cmd_fusion(struct megasas_instance *instance,
3374 instance->ldio_threshold &&
3375 (atomic_inc_return(&instance->ldio_outstanding) >
3376 instance->ldio_threshold)) {
3377 atomic_dec(&instance->ldio_outstanding);
3381 if (atomic_inc_return(&instance->fw_outstanding) >
3382 instance->host->can_queue) {
3383 atomic_dec(&instance->fw_outstanding);
3387 cmd = megasas_get_cmd_fusion(instance, scsi_cmd_to_rq(scmd)->tag);
3390 atomic_dec(&instance->fw_outstanding);
3396 req_desc = megasas_get_request_descriptor(instance, index-1);
3401 if (megasas_build_io_fusion(instance, scmd, cmd)) {
3402 megasas_return_cmd_fusion(instance, cmd);
3403 dev_err(&instance->pdev->dev, "Error building command\n");
3405 atomic_dec(&instance->fw_outstanding);
3414 dev_err(&instance->pdev->dev, "The chain offset value is not "
3427 r1_cmd = megasas_get_cmd_fusion(instance,
3428 scsi_cmd_to_rq(scmd)->tag + instance->max_fw_cmds);
3429 megasas_prepare_secondRaid1_IO(instance, cmd, r1_cmd);
3437 megasas_sdev_busy_inc(instance, scmd);
3438 megasas_fire_cmd_fusion(instance, req_desc);
3441 megasas_fire_cmd_fusion(instance, r1_cmd->request_desc);
3450 * @instance: Adapter soft state
3455 megasas_complete_r1_command(struct megasas_instance *instance,
3467 fusion = instance->ctrl_context;
3489 megasas_return_cmd_fusion(instance, r1_cmd);
3492 if (instance->ldio_threshold &&
3494 atomic_dec(&instance->ldio_outstanding);
3496 megasas_return_cmd_fusion(instance, cmd);
3498 megasas_sdev_busy_dec(instance, scmd_local);
3540 * @instance: Adapter soft state
3547 complete_cmd_fusion(struct megasas_instance *instance, u32 MSIxIndex,
3566 fusion = instance->ctrl_context;
3568 if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
3611 dev_dbg(&instance->pdev->dev, "TM completion:"
3629 atomic_dec(&instance->fw_outstanding);
3634 if (instance->ldio_threshold &&
3636 atomic_dec(&instance->ldio_outstanding);
3638 megasas_return_cmd_fusion(instance, cmd_fusion);
3640 megasas_sdev_busy_dec(instance, scmd_local);
3643 megasas_complete_r1_command(instance, cmd_fusion);
3646 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
3652 megasas_return_cmd(instance, cmd_mfi);
3654 megasas_complete_cmd(instance, cmd_mfi, DID_OK);
3688 if (threshold_reply_count >= instance->threshold_reply_count) {
3689 if (instance->msix_combined)
3692 instance->reply_post_host_index_addr[MSIxIndex/8]);
3696 instance->reply_post_host_index_addr[0]);
3712 if (instance->msix_combined)
3715 instance->reply_post_host_index_addr[MSIxIndex/8]);
3719 instance->reply_post_host_index_addr[0]);
3720 megasas_check_and_restore_queue_depth(instance);
3731 struct megasas_instance *instance;
3735 instance = (struct megasas_instance *)shost->hostdata;
3737 fusion = instance->ctrl_context;
3739 queue_num = queue_num + instance->low_latency_index_start;
3744 num_entries = complete_cmd_fusion(instance, queue_num, NULL);
3752 * @instance: Adapter soft state
3754 static void megasas_enable_irq_poll(struct megasas_instance *instance)
3759 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3762 irq_ctx = &instance->irq_context[i];
3774 struct megasas_instance *instance =
3778 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3781 synchronize_irq(pci_irq_vector(instance->pdev, i));
3782 irq_ctx = &instance->irq_context[i];
3787 complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx);
3803 struct megasas_instance *instance;
3807 instance = irq_ctx->instance;
3814 num_entries = complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx);
3819 complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx);
3834 struct megasas_instance *instance =
3839 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3842 if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
3846 irq_ctx = &instance->irq_context[MSIxIndex];
3847 complete_cmd_fusion(instance, MSIxIndex, irq_ctx);
3859 struct megasas_instance *instance = irq_context->instance;
3862 if (instance->mask_interrupts)
3868 if (!instance->msix_vectors) {
3869 mfiStatus = instance->instancet->clear_intr(instance);
3875 if (test_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags)) {
3876 instance->instancet->clear_intr(instance);
3880 return complete_cmd_fusion(instance, irq_context->MSIxIndex, irq_context)
3886 * @instance: Adapter soft state
3891 build_mpt_mfi_pass_thru(struct megasas_instance *instance,
3900 fusion = instance->ctrl_context;
3902 cmd = megasas_get_cmd_fusion(instance,
3903 instance->max_scsi_cmds + mfi_cmd->index);
3919 if (instance->adapter_type >= INVADER_SERIES) {
3939 mpi25_ieee_chain->Length = cpu_to_le32(instance->mfi_frame_size);
3944 * @instance: Adapter soft state
3949 build_mpt_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
3954 build_mpt_mfi_pass_thru(instance, cmd);
3957 req_desc = megasas_get_request_descriptor(instance, index - 1);
3970 * @instance: Adapter soft state
3975 megasas_issue_dcmd_fusion(struct megasas_instance *instance,
3980 req_desc = build_mpt_cmd(instance, cmd);
3982 megasas_fire_cmd_fusion(instance, req_desc);
3988 * @instance: Adapter soft state
3991 megasas_release_fusion(struct megasas_instance *instance)
3993 megasas_free_ioc_init_cmd(instance);
3994 megasas_free_cmds(instance);
3995 megasas_free_cmds_fusion(instance);
3997 iounmap(instance->reg_set);
3999 pci_release_selected_regions(instance->pdev, 1<<instance->bar);
4004 * @instance: Adapter soft state
4007 megasas_read_fw_status_reg_fusion(struct megasas_instance *instance)
4009 return megasas_readl(instance, &instance->reg_set->outbound_scratch_pad_0);
4014 * @instance: Controller's soft instance
4018 megasas_alloc_host_crash_buffer(struct megasas_instance *instance)
4023 instance->crash_buf[i] = vzalloc(CRASH_DMA_BUF_SIZE);
4024 if (!instance->crash_buf[i]) {
4025 dev_info(&instance->pdev->dev, "Firmware crash dump "
4030 instance->drv_buf_alloc = i;
4035 * @instance: Controller's soft instance
4038 megasas_free_host_crash_buffer(struct megasas_instance *instance)
4041 for (i = 0; i < instance->drv_buf_alloc; i++) {
4042 vfree(instance->crash_buf[i]);
4044 instance->drv_buf_index = 0;
4045 instance->drv_buf_alloc = 0;
4046 instance->fw_crash_state = UNAVAILABLE;
4047 instance->fw_crash_buffer_size = 0;
4052 * @instance: Controller's soft instance
4056 megasas_adp_reset_fusion(struct megasas_instance *instance,
4062 writel(MPI2_WRSEQ_FLUSH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
4063 writel(MPI2_WRSEQ_1ST_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
4064 writel(MPI2_WRSEQ_2ND_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
4065 writel(MPI2_WRSEQ_3RD_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
4066 writel(MPI2_WRSEQ_4TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
4067 writel(MPI2_WRSEQ_5TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
4068 writel(MPI2_WRSEQ_6TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
4071 host_diag = megasas_readl(instance, &instance->reg_set->fusion_host_diag);
4075 host_diag = megasas_readl(instance,
4076 &instance->reg_set->fusion_host_diag);
4078 dev_warn(&instance->pdev->dev,
4089 &instance->reg_set->fusion_host_diag);
4093 host_diag = megasas_readl(instance, &instance->reg_set->fusion_host_diag);
4097 host_diag = megasas_readl(instance,
4098 &instance->reg_set->fusion_host_diag);
4100 dev_warn(&instance->pdev->dev,
4109 abs_state = instance->instancet->read_fw_status_reg(instance)
4115 abs_state = instance->instancet->
4116 read_fw_status_reg(instance) & MFI_STATE_MASK;
4119 dev_warn(&instance->pdev->dev,
4130 * @instance: Controller's soft instance
4134 megasas_check_reset_fusion(struct megasas_instance *instance,
4142 * @instance: Soft instance of adapter
4144 static inline void megasas_trigger_snap_dump(struct megasas_instance *instance)
4149 if (!instance->disableOnlineCtrlReset) {
4150 dev_info(&instance->pdev->dev, "Trigger snap dump\n");
4152 &instance->reg_set->doorbell);
4153 readl(&instance->reg_set->doorbell);
4156 for (j = 0; j < instance->snapdump_wait_time; j++) {
4157 abs_state = instance->instancet->read_fw_status_reg(instance);
4160 dev_printk(KERN_ERR, &instance->pdev->dev,
4172 megasas_wait_for_outstanding_fusion(struct megasas_instance *instance,
4181 (resetwaittime - instance->snapdump_wait_time));
4184 dev_info(&instance->pdev->dev,
4186 megasas_complete_cmd_dpc_fusion((unsigned long)instance);
4187 if (instance->snapdump_wait_time)
4188 megasas_trigger_snap_dump(instance);
4195 abs_state = instance->instancet->read_fw_status_reg(instance);
4198 dev_printk(KERN_ERR, &instance->pdev->dev,
4202 megasas_complete_cmd_dpc_fusion((unsigned long)instance);
4203 if (instance->requestorId && reason) {
4204 dev_warn(&instance->pdev->dev, "SR-IOV Found FW in FAULT"
4207 instance->host->host_no);
4217 if (instance->requestorId && !reason) {
4223 if (instance->requestorId && (reason == SCSIIO_TIMEOUT_OCR)) {
4224 if (instance->hb_host_mem->HB.fwCounter !=
4225 instance->hb_host_mem->HB.driverCounter) {
4226 instance->hb_host_mem->HB.driverCounter =
4227 instance->hb_host_mem->HB.fwCounter;
4233 dev_warn(&instance->pdev->dev, "SR-IOV:"
4238 instance->host->host_no);
4246 megasas_complete_cmd_dpc_fusion((unsigned long)instance);
4247 outstanding = atomic_read(&instance->fw_outstanding);
4252 dev_notice(&instance->pdev->dev, "[%2d]waiting for %d "
4254 outstanding, instance->host->host_no);
4259 if (instance->snapdump_wait_time) {
4260 megasas_trigger_snap_dump(instance);
4265 if (atomic_read(&instance->fw_outstanding)) {
4266 dev_err(&instance->pdev->dev, "pending commands remain after waiting, "
4268 instance->host->host_no);
4275 dev_info(&instance->pdev->dev, "IO is completed, no OCR is required\n");
4280 void megasas_reset_reply_desc(struct megasas_instance *instance)
4286 fusion = instance->ctrl_context;
4287 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
4288 count += instance->iopoll_q_count;
4300 * @instance: Controller's soft instance
4302 static void megasas_refire_mgmt_cmd(struct megasas_instance *instance,
4316 fusion = instance->ctrl_context;
4321 for (j = instance->max_scsi_cmds ; j < instance->max_fw_cmds; j++) {
4323 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
4330 req_desc = megasas_get_request_descriptor(instance, smid - 1);
4351 if (!instance->support_nvme_passthru) {
4358 if (!instance->support_pci_lane_margining) {
4370 dev_err(&instance->pdev->dev,
4385 megasas_fire_cmd_fusion(instance, req_desc);
4388 megasas_return_cmd(instance, cmd_mfi);
4391 megasas_complete_cmd(instance, cmd_mfi, DID_OK);
4400 * @instance: Controller's soft instance
4403 megasas_return_polled_cmds(struct megasas_instance *instance)
4410 fusion = instance->ctrl_context;
4412 for (i = instance->max_scsi_cmds; i < instance->max_fw_cmds; i++) {
4414 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
4418 dev_info(&instance->pdev->dev,
4423 megasas_return_cmd(instance, cmd_mfi);
4430 * @instance: per adapter struct
4437 static int megasas_track_scsiio(struct megasas_instance *instance,
4443 fusion = instance->ctrl_context;
4445 for (i = 0 ; i < instance->max_scsi_cmds; i++) {
4450 dev_info(&instance->pdev->dev,
4465 * @instance: Controller's soft instance
4471 megasas_tm_response_code(struct megasas_instance *instance,
4505 dev_dbg(&instance->pdev->dev, "response_code(%01x): %s\n",
4507 dev_dbg(&instance->pdev->dev,
4517 * @instance: per adapter struct
4532 megasas_issue_tm(struct megasas_instance *instance, u16 device_handle,
4548 fusion = instance->ctrl_context;
4550 cmd_mfi = megasas_get_cmd(instance);
4553 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
4558 cmd_fusion = megasas_get_cmd_fusion(instance,
4559 instance->max_scsi_cmds + cmd_mfi->index);
4564 req_desc = megasas_get_request_descriptor(instance,
4595 megasas_fire_cmd_fusion(instance, req_desc);
4609 dev_err(&instance->pdev->dev,
4611 mutex_unlock(&instance->reset_mutex);
4612 rc = megasas_reset_fusion(instance->host, MFI_IO_TIMEOUT_OCR);
4613 mutex_lock(&instance->reset_mutex);
4618 megasas_tm_response_code(instance, mpi_reply);
4620 megasas_return_cmd(instance, cmd_mfi);
4629 instance->instancet->disable_intr(instance);
4630 megasas_sync_irqs((unsigned long)instance);
4631 instance->instancet->enable_intr(instance);
4632 megasas_enable_irq_poll(instance);
4642 instance->instancet->disable_intr(instance);
4643 megasas_sync_irqs((unsigned long)instance);
4644 rc = megasas_track_scsiio(instance, id, channel);
4645 instance->instancet->enable_intr(instance);
4646 megasas_enable_irq_poll(instance);
4663 * @instance: per adapter struct
4670 struct megasas_instance *instance;
4674 instance = (struct megasas_instance *)scmd->device->host->hostdata;
4676 fusion = instance->ctrl_context;
4678 for (i = 0; i < instance->max_scsi_cmds; i++) {
4701 struct megasas_instance *instance;
4706 instance = (struct megasas_instance *)sdev->host->hostdata;
4707 fusion = instance->ctrl_context;
4710 if (instance->use_seqnum_jbod_fp) {
4714 [(instance->pd_seq_map_id - 1) & 1];
4737 struct megasas_instance *instance;
4743 instance = (struct megasas_instance *)scmd->device->host->hostdata;
4745 if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
4746 dev_err(&instance->pdev->dev, "Controller is not OPERATIONAL,"
4747 "SCSI host:%d\n", instance->host->host_no);
4765 mutex_lock(&instance->reset_mutex);
4773 mutex_unlock(&instance->reset_mutex);
4783 mutex_unlock(&instance->reset_mutex);
4791 ret = megasas_issue_tm(instance, devhandle,
4797 mutex_unlock(&instance->reset_mutex);
4818 struct megasas_instance *instance;
4824 instance = (struct megasas_instance *)scmd->device->host->hostdata;
4826 if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
4827 dev_err(&instance->pdev->dev, "Controller is not OPERATIONAL,"
4828 "SCSI host:%d\n", instance->host->host_no);
4846 mutex_lock(&instance->reset_mutex);
4853 mutex_unlock(&instance->reset_mutex);
4861 ret = megasas_issue_tm(instance, devhandle,
4866 mutex_unlock(&instance->reset_mutex);
4874 /*SRIOV get other instance in cluster if any*/
4876 megasas_instance *megasas_get_peer_instance(struct megasas_instance *instance)
4881 if (megasas_mgmt_info.instance[i] &&
4882 (megasas_mgmt_info.instance[i] != instance) &&
4883 megasas_mgmt_info.instance[i]->requestorId &&
4884 megasas_mgmt_info.instance[i]->peerIsPresent &&
4885 (memcmp((megasas_mgmt_info.instance[i]->clusterId),
4886 instance->clusterId, MEGASAS_CLUSTER_ID_SIZE) == 0))
4887 return megasas_mgmt_info.instance[i];
4893 int megasas_check_mpio_paths(struct megasas_instance *instance,
4899 if (instance->peerIsPresent) {
4900 peer_instance = megasas_get_peer_instance(instance);
4913 struct megasas_instance *instance;
4925 instance = (struct megasas_instance *)shost->hostdata;
4926 fusion = instance->ctrl_context;
4928 mutex_lock(&instance->reset_mutex);
4930 if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
4931 dev_warn(&instance->pdev->dev, "Hardware critical error, "
4933 instance->host->host_no);
4934 mutex_unlock(&instance->reset_mutex);
4937 status_reg = instance->instancet->read_fw_status_reg(instance);
4941 if (abs_state != MFI_STATE_FAULT && instance->crash_dump_buf &&
4942 instance->crash_dump_app_support && reason) {
4943 dev_info(&instance->pdev->dev, "IO/DCMD timeout is detected, "
4945 atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
4946 status_reg = megasas_readl(instance, &instance->reg_set->doorbell);
4948 &instance->reg_set->doorbell);
4949 readl(&instance->reg_set->doorbell);
4950 mutex_unlock(&instance->reset_mutex);
4954 dev_dbg(&instance->pdev->dev, "waiting for [%d] "
4957 } while ((atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) &&
4960 if (atomic_read(&instance->adprecovery) == MEGASAS_HBA_OPERATIONAL) {
4961 dev_info(&instance->pdev->dev, "OCR done for IO "
4965 dev_info(&instance->pdev->dev, "Controller is not "
4974 if (instance->requestorId && !instance->skip_heartbeat_timer_del)
4975 timer_delete_sync(&instance->sriov_heartbeat_timer);
4976 set_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
4977 set_bit(MEGASAS_FUSION_OCR_NOT_POSSIBLE, &instance->reset_flags);
4978 atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_POLLING);
4979 instance->instancet->disable_intr(instance);
4980 megasas_sync_irqs((unsigned long)instance);
4983 if (megasas_wait_for_outstanding_fusion(instance, reason,
4985 atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
4986 dev_warn(&instance->pdev->dev, "resetting fusion "
4987 "adapter scsi%d.\n", instance->host->host_no);
4992 dev_info(&instance->pdev->dev, "\nPending SCSI commands:\n");
4995 for (i = 0 ; i < instance->max_scsi_cmds; i++) {
4998 if (instance->adapter_type >= VENTURA_SERIES) {
4999 r1_cmd = fusion->cmd_list[i + instance->max_fw_cmds];
5000 megasas_return_cmd_fusion(instance, r1_cmd);
5016 megasas_check_mpio_paths(instance,
5018 if (instance->ldio_threshold &&
5020 atomic_dec(&instance->ldio_outstanding);
5021 megasas_return_cmd_fusion(instance, cmd_fusion);
5027 dev_info(&instance->pdev->dev, "Outstanding fastpath IOs: %d\n",
5030 atomic_set(&instance->fw_outstanding, 0);
5032 status_reg = instance->instancet->read_fw_status_reg(instance);
5035 if (instance->disableOnlineCtrlReset ||
5038 dev_warn(&instance->pdev->dev, "Reset not supported"
5040 instance->host->host_no);
5045 if (instance->requestorId && !reason) {
5057 if (megasas_adp_reset_wait_for_ready(instance,
5062 if (megasas_transition_to_ready(instance, 1)) {
5063 dev_warn(&instance->pdev->dev,
5065 "scsi%d.\n", instance->host->host_no);
5068 megasas_reset_reply_desc(instance);
5069 megasas_fusion_update_can_queue(instance, OCR_CONTEXT);
5071 if (megasas_ioc_init_fusion(instance)) {
5075 if (megasas_get_ctrl_info(instance)) {
5076 dev_info(&instance->pdev->dev,
5082 megasas_refire_mgmt_cmd(instance,
5092 if (!megasas_get_map_info(instance)) {
5093 megasas_sync_map_info(instance);
5099 megasas_return_polled_cmds(instance);
5103 megasas_setup_jbod_map(instance);
5106 if (instance->adapter_type >= VENTURA_SERIES) {
5116 &instance->reset_flags);
5117 instance->instancet->enable_intr(instance);
5118 megasas_enable_irq_poll(instance);
5120 if ((instance->tgt_prop) &&
5121 (instance->nvme_page_size))
5122 ret_target_prop = megasas_get_target_prop(instance, sdev);
5129 status_reg = instance->instancet->read_fw_status_reg
5130 (instance);
5133 dev_info(&instance->pdev->dev,
5135 abs_state, instance->host->host_no);
5138 atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
5140 dev_info(&instance->pdev->dev,
5142 instance->host->host_no);
5145 if (instance->requestorId) {
5146 if (!megasas_sriov_start_heartbeat(instance, 0))
5147 megasas_start_timer(instance);
5149 instance->skip_heartbeat_timer_del = 1;
5152 if (instance->crash_dump_drv_support &&
5153 instance->crash_dump_app_support)
5154 megasas_set_crash_dump_params(instance,
5157 megasas_set_crash_dump_params(instance,
5160 if (instance->snapdump_wait_time) {
5161 megasas_get_snapdump_properties(instance);
5162 dev_info(&instance->pdev->dev,
5164 instance->snapdump_wait_time);
5170 dev_warn(&instance->pdev->dev,
5172 instance->host->host_no);
5177 dev_warn(&instance->pdev->dev, "Reset failed, killing "
5178 "adapter scsi%d.\n", instance->host->host_no);
5182 if (instance->requestorId) {
5183 megasas_start_timer(instance);
5185 clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
5186 instance->instancet->enable_intr(instance);
5187 megasas_enable_irq_poll(instance);
5188 atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
5192 megaraid_sas_kill_hba(instance);
5193 megasas_enable_irq_poll(instance);
5194 instance->skip_heartbeat_timer_del = 1;
5197 clear_bit(MEGASAS_FUSION_OCR_NOT_POSSIBLE, &instance->reset_flags);
5198 mutex_unlock(&instance->reset_mutex);
5203 static void megasas_fusion_crash_dump(struct megasas_instance *instance)
5210 status_reg = instance->instancet->read_fw_status_reg(instance);
5216 if (instance->drv_buf_index == 0) {
5220 if (instance->drv_buf_alloc) {
5221 dev_info(&instance->pdev->dev, "earlier crash dump is "
5226 &instance->reg_set->outbound_scratch_pad_0);
5227 readl(&instance->reg_set->outbound_scratch_pad_0);
5230 megasas_alloc_host_crash_buffer(instance);
5231 dev_info(&instance->pdev->dev, "Number of host crash buffers "
5232 "allocated: %d\n", instance->drv_buf_alloc);
5245 status_reg = instance->instancet->read_fw_status_reg(
5246 instance);
5251 if (instance->drv_buf_index >= instance->drv_buf_alloc) {
5252 dev_info(&instance->pdev->dev,
5254 instance->drv_buf_alloc);
5259 memcpy(instance->crash_buf[instance->drv_buf_index],
5260 instance->crash_dump_buf, CRASH_DMA_BUF_SIZE);
5261 instance->drv_buf_index++;
5265 writel(status_reg, &instance->reg_set->outbound_scratch_pad_0);
5266 readl(&instance->reg_set->outbound_scratch_pad_0);
5269 status_reg = instance->instancet->read_fw_status_reg(instance);
5273 dev_info(&instance->pdev->dev, "Crash Dump is available,number "
5274 "of copied buffers: %d\n", instance->drv_buf_index);
5275 instance->fw_crash_buffer_size = instance->drv_buf_index;
5276 instance->fw_crash_state = AVAILABLE;
5277 instance->drv_buf_index = 0;
5278 writel(status_reg, &instance->reg_set->outbound_scratch_pad_0);
5279 readl(&instance->reg_set->outbound_scratch_pad_0);
5281 megasas_reset_fusion(instance->host, 0);
5289 struct megasas_instance *instance =
5292 megasas_reset_fusion(instance->host, 0);
5297 megasas_alloc_fusion_context(struct megasas_instance *instance)
5301 instance->ctrl_context = kzalloc(sizeof(struct fusion_context),
5303 if (!instance->ctrl_context) {
5304 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
5309 fusion = instance->ctrl_context;
5321 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
5337 dev_err(&instance->pdev->dev, "Failed to allocate load_balance_info, "
5345 megasas_free_fusion_context(struct megasas_instance *instance)
5347 struct fusion_context *fusion = instance->ctrl_context;