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,
225 * @instance: Adapter soft state
231 *instance, u32 blk_tag)
235 fusion = instance->ctrl_context;
241 * @instance: Adapter soft state
244 inline void megasas_return_cmd_fusion(struct megasas_instance *instance,
255 * @instance: Adapter soft state
259 megasas_write_64bit_req_desc(struct megasas_instance *instance,
265 writeq(req_data, &instance->reg_set->inbound_low_queue_port);
268 spin_lock_irqsave(&instance->hba_lock, flags);
270 &instance->reg_set->inbound_low_queue_port);
272 &instance->reg_set->inbound_high_queue_port);
273 spin_unlock_irqrestore(&instance->hba_lock, flags);
279 * @instance: Adapter soft state
286 megasas_fire_cmd_fusion(struct megasas_instance *instance,
289 if (instance->atomic_desc_support)
291 &instance->reg_set->inbound_single_queue_port);
293 megasas_write_64bit_req_desc(instance, req_desc);
298 * @instance: Adapter soft state
308 megasas_fusion_update_can_queue(struct megasas_instance *instance, int fw_boot_context)
314 if (instance->adapter_type < VENTURA_SERIES)
316 megasas_readl(instance,
317 &instance->reg_set->outbound_scratch_pad_2) & 0x00FFFF;
320 cur_max_fw_cmds = instance->instancet->read_fw_status_reg(instance) & 0x00FFFF;
323 (instance->instancet->read_fw_status_reg(instance) & 0x00FFFF) - MEGASAS_FUSION_IOCTL_CMDS;
325 dev_info(&instance->pdev->dev,
331 if (cur_max_fw_cmds < instance->max_fw_cmds) {
332 instance->cur_can_queue =
335 instance->host->can_queue = instance->cur_can_queue;
336 instance->ldio_threshold = ldio_threshold;
339 instance->max_fw_cmds = cur_max_fw_cmds;
340 instance->ldio_threshold = ldio_threshold;
343 instance->max_fw_cmds = min(instance->max_fw_cmds,
350 instance->max_fw_cmds = instance->max_fw_cmds-1;
355 megasas_get_msix_index(struct megasas_instance *instance,
367 if (instance->perf_mode == MR_BALANCED_PERF_MODE &&
370 mega_mod64((atomic64_add_return(1, &instance->high_iops_outstanding) /
371 MR_HIGH_IOPS_BATCH_COUNT), instance->low_latency_index_start);
372 } else if (instance->msix_load_balance) {
374 (mega_mod64(atomic64_add_return(1, &instance->total_io_count),
375 instance->msix_vectors));
376 } else if (instance->host->nr_hw_queues > 1) {
380 instance->low_latency_index_start;
383 instance->reply_map[raw_smp_processor_id()];
389 * @instance: Adapter soft state
392 megasas_free_cmds_fusion(struct megasas_instance *instance)
395 struct fusion_context *fusion = instance->ctrl_context;
404 for (i = 0; i < instance->max_mpt_cmds; i++) {
428 if (instance->is_rdpq)
429 megasas_free_rdpq_fusion(instance);
431 megasas_free_reply_fusion(instance);
435 dma_free_coherent(&instance->pdev->dev,
450 * @instance: Adapter soft state
453 static int megasas_create_sg_sense_fusion(struct megasas_instance *instance)
462 fusion = instance->ctrl_context;
463 max_cmd = instance->max_fw_cmds;
464 sense_sz = instance->max_mpt_cmds * SCSI_SENSE_BUFFERSIZE;
467 dma_pool_create("mr_sg", &instance->pdev->dev,
468 instance->max_chain_frame_sz,
472 dma_pool_create("mr_sense", &instance->pdev->dev,
476 dev_err(&instance->pdev->dev,
484 dev_err(&instance->pdev->dev,
500 if (!megasas_check_same_4gb_region(instance, fusion->sense_phys_addr,
508 dma_pool_create("mr_sense_align", &instance->pdev->dev,
512 dev_err(&instance->pdev->dev,
520 dev_err(&instance->pdev->dev,
539 dev_err(&instance->pdev->dev,
546 for (i = max_cmd; i < instance->max_mpt_cmds; i++) {
558 megasas_alloc_cmdlist_fusion(struct megasas_instance *instance)
563 fusion = instance->ctrl_context;
565 max_mpt_cmd = instance->max_mpt_cmds;
576 dev_err(&instance->pdev->dev,
588 dev_err(&instance->pdev->dev,
598 megasas_alloc_request_fusion(struct megasas_instance *instance)
602 fusion = instance->ctrl_context;
606 dma_pool_create("mr_ioreq", &instance->pdev->dev,
610 dev_err(&instance->pdev->dev,
620 if (instance->max_fw_cmds >= (MEGASAS_REDUCE_QD_COUNT * 2)) {
621 instance->max_fw_cmds -= MEGASAS_REDUCE_QD_COUNT;
623 megasas_configure_queue_sizes(instance);
626 dev_err(&instance->pdev->dev,
632 if (!megasas_check_same_4gb_region(instance,
643 &instance->pdev->dev,
649 dev_err(&instance->pdev->dev,
660 dev_err(&instance->pdev->dev,
667 dma_alloc_coherent(&instance->pdev->dev,
671 dev_err(&instance->pdev->dev,
680 megasas_alloc_reply_fusion(struct megasas_instance *instance)
685 fusion = instance->ctrl_context;
687 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
689 dma_pool_create("mr_reply", &instance->pdev->dev,
693 dev_err(&instance->pdev->dev,
702 dev_err(&instance->pdev->dev,
707 if (!megasas_check_same_4gb_region(instance,
718 &instance->pdev->dev,
724 dev_err(&instance->pdev->dev,
735 dev_err(&instance->pdev->dev,
757 megasas_alloc_rdpq_fusion(struct megasas_instance *instance)
767 fusion = instance->ctrl_context;
772 fusion->rdpq_virt = dma_alloc_coherent(&instance->pdev->dev,
776 dev_err(&instance->pdev->dev,
781 msix_count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
784 &instance->pdev->dev,
788 &instance->pdev->dev,
795 dev_err(&instance->pdev->dev,
815 dev_err(&instance->pdev->dev,
831 if (!megasas_check_same_4gb_region(instance, rdpq_chunk_phys[i],
841 dev_err(&instance->pdev->dev,
881 megasas_free_rdpq_fusion(struct megasas_instance *instance) {
886 fusion = instance->ctrl_context;
900 dma_free_coherent(&instance->pdev->dev,
906 megasas_free_reply_fusion(struct megasas_instance *instance) {
910 fusion = instance->ctrl_context;
924 * @instance: Adapter soft state
939 megasas_alloc_cmds_fusion(struct megasas_instance *instance)
949 fusion = instance->ctrl_context;
951 if (megasas_alloc_request_fusion(instance))
954 if (instance->is_rdpq) {
955 if (megasas_alloc_rdpq_fusion(instance))
958 if (megasas_alloc_reply_fusion(instance))
961 if (megasas_alloc_cmdlist_fusion(instance))
973 for (i = 0; i < instance->max_mpt_cmds; i++) {
980 (i >= instance->max_scsi_cmds && i < instance->max_fw_cmds) ?
981 (i - instance->max_scsi_cmds) :
983 cmd->instance = instance;
993 if (megasas_create_sg_sense_fusion(instance))
999 megasas_free_cmds_fusion(instance);
1005 * @instance: Adapter soft state
1012 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
1028 status_reg = instance->instancet->read_fw_status_reg(instance)
1045 * @instance: Adapter soft state
1050 megasas_ioc_init_fusion(struct megasas_instance *instance)
1068 fusion = instance->ctrl_context;
1076 (instance, &instance->reg_set->outbound_scratch_pad_1);
1080 if (instance->adapter_type == INVADER_SERIES) {
1084 if (instance->consistent_mask_64bit && !cur_fw_64bit_dma_capable) {
1085 dev_err(&instance->pdev->dev, "Driver was operating on 64bit "
1087 megaraid_sas_kill_hba(instance);
1093 if (instance->is_rdpq && !cur_rdpq_mode) {
1094 dev_err(&instance->pdev->dev, "Firmware downgrade *NOT SUPPORTED*"
1103 if ((instance->low_latency_index_start ==
1105 instance->perf_mode = MR_BALANCED_PERF_MODE;
1107 dev_info(&instance->pdev->dev, "Performance mode :%s (latency index = %d)\n",
1108 MEGASAS_PERF_MODE_2STR(instance->perf_mode),
1109 instance->low_latency_index_start);
1111 instance->fw_sync_cache_support = (scratch_pad_1 &
1113 dev_info(&instance->pdev->dev, "FW supports sync cache\t: %s\n",
1114 instance->fw_sync_cache_support ? "Yes" : "No");
1125 IOCInitMessage->ReplyDescriptorPostQueueAddress = instance->is_rdpq ?
1128 IOCInitMessage->MsgFlags = instance->is_rdpq ?
1132 IOCInitMessage->HostMSIxVectors = instance->msix_vectors;
1152 if (instance->adapter_type >= INVADER_SERIES)
1161 if (instance->max_chain_frame_sz > MEGASAS_CHAIN_FRAME_SZ_MIN)
1173 if (instance->consistent_mask_64bit)
1180 if (instance->system_info_buf && sys_info) {
1181 memcpy(instance->system_info_buf->systemId, sys_info,
1183 instance->system_info_buf->systemIdLength =
1185 init_frame->system_info_lo = cpu_to_le32(lower_32_bits(instance->system_info_h));
1186 init_frame->system_info_hi = cpu_to_le32(upper_32_bits(instance->system_info_h));
1199 switch (instance->perf_mode) {
1202 cpu_to_le16(~(~0 << instance->low_latency_index_start/8));
1206 cpu_to_le16(~(~0 << instance->msix_vectors/8));
1220 instance->instancet->disable_intr(instance);
1223 if (megasas_readl(instance, &instance->reg_set->doorbell) & 1)
1230 megasas_write_64bit_req_desc(instance, &req_desc);
1232 wait_and_poll(instance, cmd, MFI_IO_TIMEOUT_SECS);
1240 if (instance->adapter_type >= AERO_SERIES) {
1242 (instance, &instance->reg_set->outbound_scratch_pad_1);
1244 instance->atomic_desc_support =
1247 dev_info(&instance->pdev->dev, "FW supports atomic descriptor\t: %s\n",
1248 instance->atomic_desc_support ? "Yes" : "No");
1254 dev_err(&instance->pdev->dev,
1256 instance->host->host_no);
1263 * @instance: Adapter soft state
1267 * issue command and return. If it is first instance of jbod map
1271 megasas_sync_pd_seq_num(struct megasas_instance *instance, bool pend) {
1276 struct fusion_context *fusion = instance->ctrl_context;
1280 pd_sync = (void *)fusion->pd_seq_sync[(instance->pd_seq_map_id & 1)];
1281 pd_seq_h = fusion->pd_seq_phys[(instance->pd_seq_map_id & 1)];
1284 cmd = megasas_get_cmd(instance);
1286 dev_err(&instance->pdev->dev,
1300 instance->jbod_seq_cmd = cmd;
1313 megasas_set_dma_settings(instance, dcmd, pd_seq_h, pd_seq_map_sz);
1316 instance->instancet->issue_dcmd(instance, cmd);
1321 if (!instance->mask_interrupts)
1322 ret = megasas_issue_blocked_cmd(instance, cmd,
1325 ret = megasas_issue_polled(instance, cmd);
1328 dev_warn(&instance->pdev->dev,
1335 dev_warn(&instance->pdev->dev,
1340 instance->pd_seq_map_id++;
1342 megasas_return_cmd(instance, cmd);
1348 * @instance: Adapter soft state
1362 megasas_get_ld_map_info(struct megasas_instance *instance)
1372 cmd = megasas_get_cmd(instance);
1375 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get cmd for map info\n");
1379 fusion = instance->ctrl_context;
1382 megasas_return_cmd(instance, cmd);
1390 ci = (void *) fusion->ld_map[(instance->map_id & 1)];
1391 ci_h = fusion->ld_map_phys[(instance->map_id & 1)];
1394 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc mem for ld_map_info\n");
1395 megasas_return_cmd(instance, cmd);
1410 megasas_set_dma_settings(instance, dcmd, ci_h, size_map_info);
1412 if (!instance->mask_interrupts)
1413 ret = megasas_issue_blocked_cmd(instance, cmd,
1416 ret = megasas_issue_polled(instance, cmd);
1419 dev_warn(&instance->pdev->dev,
1423 megasas_return_cmd(instance, cmd);
1429 megasas_get_map_info(struct megasas_instance *instance)
1431 struct fusion_context *fusion = instance->ctrl_context;
1434 if (!megasas_get_ld_map_info(instance)) {
1435 if (MR_ValidateMapInfo(instance, instance->map_id)) {
1445 * @instance: Adapter soft state
1452 megasas_sync_map_info(struct megasas_instance *instance)
1466 cmd = megasas_get_cmd(instance);
1469 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get cmd for sync info\n");
1473 fusion = instance->ctrl_context;
1476 megasas_return_cmd(instance, cmd);
1480 map = fusion->ld_drv_map[instance->map_id & 1];
1489 fusion->ld_map[(instance->map_id - 1) & 1];
1492 ci_h = fusion->ld_map_phys[(instance->map_id - 1) & 1];
1515 megasas_set_dma_settings(instance, dcmd, ci_h, size_map_info);
1517 instance->map_update_cmd = cmd;
1519 instance->instancet->issue_dcmd(instance, cmd);
1526 * @instance: per adapter object
1531 megasas_display_intel_branding(struct megasas_instance *instance)
1533 if (instance->pdev->subsystem_vendor != PCI_VENDOR_ID_INTEL)
1536 switch (instance->pdev->device) {
1538 switch (instance->pdev->subsystem_device) {
1540 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1541 instance->host->host_no,
1545 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1546 instance->host->host_no,
1550 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1551 instance->host->host_no,
1555 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1556 instance->host->host_no,
1564 switch (instance->pdev->subsystem_device) {
1566 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1567 instance->host->host_no,
1571 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1572 instance->host->host_no,
1581 switch (instance->pdev->subsystem_device) {
1583 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1584 instance->host->host_no,
1598 * @instance: Adapter soft state
1603 static inline int megasas_allocate_raid_maps(struct megasas_instance *instance)
1608 fusion = instance->ctrl_context;
1623 dev_err(&instance->pdev->dev,
1633 fusion->ld_map[i] = dma_alloc_coherent(&instance->pdev->dev,
1638 dev_err(&instance->pdev->dev,
1650 dma_free_coherent(&instance->pdev->dev,
1674 * @instance: Adapter soft state
1678 void megasas_configure_queue_sizes(struct megasas_instance *instance)
1683 fusion = instance->ctrl_context;
1684 max_cmd = instance->max_fw_cmds;
1686 if (instance->adapter_type >= VENTURA_SERIES)
1687 instance->max_mpt_cmds = instance->max_fw_cmds * RAID_1_PEER_CMDS;
1689 instance->max_mpt_cmds = instance->max_fw_cmds;
1691 instance->max_scsi_cmds = instance->max_fw_cmds - instance->max_mfi_cmds;
1692 instance->cur_can_queue = instance->max_scsi_cmds;
1693 instance->host->can_queue = instance->cur_can_queue;
1698 instance->max_mpt_cmds;
1703 * (instance->max_mpt_cmds + 1)); /* Extra 1 for SMID 0 */
1706 static int megasas_alloc_ioc_init_frame(struct megasas_instance *instance)
1711 fusion = instance->ctrl_context;
1716 dev_err(&instance->pdev->dev, "Failed from func: %s line: %d\n",
1721 cmd->frame = dma_alloc_coherent(&instance->pdev->dev,
1726 dev_err(&instance->pdev->dev, "Failed from func: %s line: %d\n",
1738 * @instance: Adapter soft state
1740 static inline void megasas_free_ioc_init_cmd(struct megasas_instance *instance)
1744 fusion = instance->ctrl_context;
1747 dma_free_coherent(&instance->pdev->dev,
1757 * @instance: Adapter soft state
1762 megasas_init_adapter_fusion(struct megasas_instance *instance)
1769 fusion = instance->ctrl_context;
1771 megasas_fusion_update_can_queue(instance, PROBE_CONTEXT);
1776 instance->max_mfi_cmds =
1779 megasas_configure_queue_sizes(instance);
1781 scratch_pad_1 = megasas_readl(instance,
1782 &instance->reg_set->outbound_scratch_pad_1);
1790 instance->max_chain_frame_sz =
1794 instance->max_chain_frame_sz =
1798 if (instance->max_chain_frame_sz < MEGASAS_CHAIN_FRAME_SZ_MIN) {
1799 dev_warn(&instance->pdev->dev, "frame size %d invalid, fall back to legacy max frame size %d\n",
1800 instance->max_chain_frame_sz,
1802 instance->max_chain_frame_sz = MEGASAS_CHAIN_FRAME_SZ_MIN;
1810 instance->max_chain_frame_sz
1813 instance->max_num_sge =
1825 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
1833 instance->max_scsi_cmds = instance->max_fw_cmds -
1836 sema_init(&instance->ioctl_sem, MEGASAS_FUSION_IOCTL_CMDS);
1838 if (megasas_alloc_ioc_init_frame(instance))
1845 if (megasas_alloc_cmds(instance))
1847 if (megasas_alloc_cmds_fusion(instance))
1850 if (megasas_ioc_init_fusion(instance)) {
1851 status_reg = instance->instancet->read_fw_status_reg(instance);
1856 (instance, true, 0) == FAILED)
1859 if (megasas_ioc_init_fusion(instance))
1866 megasas_display_intel_branding(instance);
1867 if (megasas_get_ctrl_info(instance)) {
1868 dev_err(&instance->pdev->dev,
1874 instance->flag_ieee = 1;
1875 instance->r1_ldio_hint_default = MR_R1_LDIO_PIGGYBACK_DEFAULT;
1876 instance->threshold_reply_count = instance->max_fw_cmds / 4;
1879 if (megasas_allocate_raid_maps(instance))
1882 if (!megasas_get_map_info(instance))
1883 megasas_sync_map_info(instance);
1888 megasas_free_cmds_fusion(instance);
1890 megasas_free_cmds(instance);
1892 megasas_free_ioc_init_cmd(instance);
1904 struct megasas_instance *instance =
1910 fw_state = instance->instancet->read_fw_status_reg(instance) &
1914 dma_state = instance->instancet->read_fw_status_reg(instance) &
1917 if (instance->crash_dump_drv_support &&
1918 instance->crash_dump_app_support && dma_state) {
1919 megasas_fusion_crash_dump(instance);
1921 if (instance->unload == 0) {
1922 status = megasas_reset_fusion(instance->host, 0);
1924 dev_err(&instance->pdev->dev,
1933 if (instance->fw_fault_work_q)
1934 queue_delayed_work(instance->fw_fault_work_q,
1935 &instance->fw_fault_work,
1940 megasas_fusion_start_watchdog(struct megasas_instance *instance)
1943 if (instance->fw_fault_work_q)
1946 INIT_DELAYED_WORK(&instance->fw_fault_work, megasas_fault_detect_work);
1948 snprintf(instance->fault_handler_work_q_name,
1949 sizeof(instance->fault_handler_work_q_name),
1950 "poll_megasas%d_status", instance->host->host_no);
1952 instance->fw_fault_work_q =
1953 create_singlethread_workqueue(instance->fault_handler_work_q_name);
1954 if (!instance->fw_fault_work_q) {
1955 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1960 queue_delayed_work(instance->fw_fault_work_q,
1961 &instance->fw_fault_work,
1968 megasas_fusion_stop_watchdog(struct megasas_instance *instance)
1972 if (instance->fw_fault_work_q) {
1973 wq = instance->fw_fault_work_q;
1974 instance->fw_fault_work_q = NULL;
1975 if (!cancel_delayed_work_sync(&instance->fw_fault_work))
2055 * @instance: Adapter soft state
2063 megasas_is_prp_possible(struct megasas_instance *instance,
2071 mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
2101 * @instance: Adapter soft state
2111 megasas_make_prp_nvme(struct megasas_instance *instance, struct scsi_cmnd *scmd,
2125 u32 mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
2128 build_prp = megasas_is_prp_possible(instance, scmd, sge_count);
2148 memset(ptr_sgl, 0, instance->max_chain_frame_sz);
2226 * @instance: Adapter soft state
2234 megasas_make_sgl_fusion(struct megasas_instance *instance,
2243 fusion = instance->ctrl_context;
2245 if (instance->adapter_type >= INVADER_SERIES) {
2255 if (instance->adapter_type >= INVADER_SERIES)
2265 if (instance->adapter_type >= INVADER_SERIES) {
2281 if (instance->adapter_type >= INVADER_SERIES)
2292 memset(sgl_ptr, 0, instance->max_chain_frame_sz);
2300 * @instance: Soft instance of controller
2311 int megasas_make_sgl(struct megasas_instance *instance, struct scsi_cmnd *scp,
2320 if ((sge_count > instance->max_num_sge) || (sge_count <= 0))
2327 build_prp = megasas_make_prp_nvme(instance, scp, sgl_chain64,
2331 megasas_make_sgl_fusion(instance, scp, sgl_chain64,
2519 * @instance: Adapter soft state
2526 static void megasas_stream_detect(struct megasas_instance *instance,
2530 struct fusion_context *fusion = instance->ctrl_context;
2682 * @instance: Adapter soft state
2690 megasas_build_ldio_fusion(struct megasas_instance *instance,
2711 fusion = instance->ctrl_context;
2787 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
2790 if (ld < instance->fw_supported_vd_count)
2797 if (MR_BuildRaidContext(instance, &io_info, rctx,
2802 megasas_get_msix_index(instance, scp, cmd, io_info.data_arms);
2804 if (instance->adapter_type >= VENTURA_SERIES) {
2816 if (atomic_inc_return(&instance->fw_outstanding) >
2817 (instance->host->can_queue)) {
2819 atomic_dec(&instance->fw_outstanding);
2824 atomic_dec(&instance->fw_outstanding);
2827 instance->r1_ldio_hint_default);
2833 spin_lock_irqsave(&instance->stream_lock,
2835 megasas_stream_detect(instance, cmd, &io_info);
2836 spin_unlock_irqrestore(&instance->stream_lock,
2862 if (instance->adapter_type == INVADER_SERIES) {
2869 } else if (instance->adapter_type >= VENTURA_SERIES) {
2880 get_updated_dev_handle(instance,
2885 if (instance->adapter_type >= VENTURA_SERIES)
2893 if (instance->adapter_type >= VENTURA_SERIES)
2900 instance->dev_handle = !(instance->dev_handle);
2902 local_map_ptr->raidMap.devHndlInfo[io_info.pd_after_lb].devHandle[instance->dev_handle];
2916 if (instance->adapter_type == INVADER_SERIES) {
2927 } else if (instance->adapter_type >= VENTURA_SERIES) {
2940 * @instance: Adapter soft state
2946 static void megasas_build_ld_nonrw_fusion(struct megasas_instance *instance,
2953 struct fusion_context *fusion = instance->ctrl_context;
2963 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
2973 device_id < instance->fw_supported_vd_count)) {
2976 if (ld >= instance->fw_supported_vd_count - 1)
2999 if (instance->adapter_type < VENTURA_SERIES)
3028 * @instance: Adapter soft state
3036 megasas_build_syspd_fusion(struct megasas_instance *instance,
3049 struct fusion_context *fusion = instance->ctrl_context;
3050 pd_sync = (void *)fusion->pd_seq_sync[(instance->pd_seq_map_id - 1) & 1];
3070 if (instance->support_seqnum_jbod_fp) {
3071 if (instance->use_seqnum_jbod_fp &&
3072 instance->pd_list[pd_index].driveType == TYPE_DISK) {
3075 if (instance->support_morethan256jbod)
3086 if (instance->adapter_type >= VENTURA_SERIES) {
3113 fusion->ld_drv_map[(instance->map_id & 1)];
3123 megasas_get_msix_index(instance, scmd, cmd, 1);
3144 if (instance->adapter_type >= INVADER_SERIES)
3156 * @instance: Adapter soft state
3164 megasas_build_io_fusion(struct megasas_instance *instance,
3195 megasas_build_ldio_fusion(instance, scp, cmd);
3198 megasas_build_ld_nonrw_fusion(instance, scp, cmd);
3201 megasas_build_syspd_fusion(instance, scp, cmd, true);
3204 if (instance->secure_jbod_support ||
3206 megasas_build_syspd_fusion(instance, scp, cmd, false);
3208 megasas_build_syspd_fusion(instance, scp, cmd, true);
3218 sge_count = megasas_make_sgl(instance, scp, cmd);
3220 if (sge_count > instance->max_num_sge || (sge_count < 0)) {
3221 dev_err(&instance->pdev->dev,
3223 __func__, __LINE__, sge_count, instance->max_num_sge);
3227 if (instance->adapter_type >= VENTURA_SERIES) {
3261 megasas_get_request_descriptor(struct megasas_instance *instance, u16 index)
3266 fusion = instance->ctrl_context;
3277 static void megasas_prepare_secondRaid1_IO(struct megasas_instance *instance,
3283 fusion = instance->ctrl_context;
3294 req_desc2 = megasas_get_request_descriptor(instance,
3318 * @instance: Adapter soft state
3322 megasas_build_and_issue_cmd_fusion(struct megasas_instance *instance,
3330 instance->ldio_threshold &&
3331 (atomic_inc_return(&instance->ldio_outstanding) >
3332 instance->ldio_threshold)) {
3333 atomic_dec(&instance->ldio_outstanding);
3337 if (atomic_inc_return(&instance->fw_outstanding) >
3338 instance->host->can_queue) {
3339 atomic_dec(&instance->fw_outstanding);
3343 cmd = megasas_get_cmd_fusion(instance, scmd->request->tag);
3346 atomic_dec(&instance->fw_outstanding);
3352 req_desc = megasas_get_request_descriptor(instance, index-1);
3357 if (megasas_build_io_fusion(instance, scmd, cmd)) {
3358 megasas_return_cmd_fusion(instance, cmd);
3359 dev_err(&instance->pdev->dev, "Error building command\n");
3361 atomic_dec(&instance->fw_outstanding);
3370 dev_err(&instance->pdev->dev, "The chain offset value is not "
3383 r1_cmd = megasas_get_cmd_fusion(instance,
3384 (scmd->request->tag + instance->max_fw_cmds));
3385 megasas_prepare_secondRaid1_IO(instance, cmd, r1_cmd);
3393 megasas_fire_cmd_fusion(instance, req_desc);
3396 megasas_fire_cmd_fusion(instance, r1_cmd->request_desc);
3405 * @instance: Adapter soft state
3410 megasas_complete_r1_command(struct megasas_instance *instance,
3422 fusion = instance->ctrl_context;
3444 megasas_return_cmd_fusion(instance, r1_cmd);
3447 if (instance->ldio_threshold &&
3449 atomic_dec(&instance->ldio_outstanding);
3451 megasas_return_cmd_fusion(instance, cmd);
3459 * @instance: Adapter soft state
3466 complete_cmd_fusion(struct megasas_instance *instance, u32 MSIxIndex,
3485 fusion = instance->ctrl_context;
3487 if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
3525 dev_dbg(&instance->pdev->dev, "TM completion:"
3542 atomic_dec(&instance->fw_outstanding);
3547 if (instance->ldio_threshold &&
3549 atomic_dec(&instance->ldio_outstanding);
3551 megasas_return_cmd_fusion(instance, cmd_fusion);
3555 megasas_complete_r1_command(instance, cmd_fusion);
3558 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
3564 megasas_return_cmd(instance, cmd_mfi);
3566 megasas_complete_cmd(instance, cmd_mfi, DID_OK);
3600 if (threshold_reply_count >= instance->threshold_reply_count) {
3601 if (instance->msix_combined)
3604 instance->reply_post_host_index_addr[MSIxIndex/8]);
3608 instance->reply_post_host_index_addr[0]);
3623 if (instance->msix_combined)
3626 instance->reply_post_host_index_addr[MSIxIndex/8]);
3630 instance->reply_post_host_index_addr[0]);
3631 megasas_check_and_restore_queue_depth(instance);
3638 * @instance: Adapter soft state
3640 static void megasas_enable_irq_poll(struct megasas_instance *instance)
3645 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3648 irq_ctx = &instance->irq_context[i];
3660 struct megasas_instance *instance =
3664 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3667 synchronize_irq(pci_irq_vector(instance->pdev, i));
3668 irq_ctx = &instance->irq_context[i];
3673 complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx);
3689 struct megasas_instance *instance;
3693 instance = irq_ctx->instance;
3700 num_entries = complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx);
3705 complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx);
3720 struct megasas_instance *instance =
3725 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3728 if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
3732 irq_ctx = &instance->irq_context[MSIxIndex];
3733 complete_cmd_fusion(instance, MSIxIndex, irq_ctx);
3745 struct megasas_instance *instance = irq_context->instance;
3748 if (instance->mask_interrupts)
3754 if (!instance->msix_vectors) {
3755 mfiStatus = instance->instancet->clear_intr(instance);
3761 if (test_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags)) {
3762 instance->instancet->clear_intr(instance);
3766 return complete_cmd_fusion(instance, irq_context->MSIxIndex, irq_context)
3772 * @instance: Adapter soft state
3777 build_mpt_mfi_pass_thru(struct megasas_instance *instance,
3786 fusion = instance->ctrl_context;
3788 cmd = megasas_get_cmd_fusion(instance,
3789 instance->max_scsi_cmds + mfi_cmd->index);
3805 if (instance->adapter_type >= INVADER_SERIES) {
3825 mpi25_ieee_chain->Length = cpu_to_le32(instance->mfi_frame_size);
3830 * @instance: Adapter soft state
3835 build_mpt_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
3840 build_mpt_mfi_pass_thru(instance, cmd);
3843 req_desc = megasas_get_request_descriptor(instance, index - 1);
3856 * @instance: Adapter soft state
3861 megasas_issue_dcmd_fusion(struct megasas_instance *instance,
3866 req_desc = build_mpt_cmd(instance, cmd);
3868 megasas_fire_cmd_fusion(instance, req_desc);
3874 * @instance: Adapter soft state
3877 megasas_release_fusion(struct megasas_instance *instance)
3879 megasas_free_ioc_init_cmd(instance);
3880 megasas_free_cmds(instance);
3881 megasas_free_cmds_fusion(instance);
3883 iounmap(instance->reg_set);
3885 pci_release_selected_regions(instance->pdev, 1<<instance->bar);
3890 * @instance: Adapter soft state
3893 megasas_read_fw_status_reg_fusion(struct megasas_instance *instance)
3895 return megasas_readl(instance, &instance->reg_set->outbound_scratch_pad_0);
3900 * @instance: Controller's soft instance
3904 megasas_alloc_host_crash_buffer(struct megasas_instance *instance)
3909 instance->crash_buf[i] = vzalloc(CRASH_DMA_BUF_SIZE);
3910 if (!instance->crash_buf[i]) {
3911 dev_info(&instance->pdev->dev, "Firmware crash dump "
3916 instance->drv_buf_alloc = i;
3921 * @instance: Controller's soft instance
3924 megasas_free_host_crash_buffer(struct megasas_instance *instance)
3927 for (i = 0; i < instance->drv_buf_alloc; i++) {
3928 if (instance->crash_buf[i])
3929 vfree(instance->crash_buf[i]);
3931 instance->drv_buf_index = 0;
3932 instance->drv_buf_alloc = 0;
3933 instance->fw_crash_state = UNAVAILABLE;
3934 instance->fw_crash_buffer_size = 0;
3939 * @instance: Controller's soft instance
3943 megasas_adp_reset_fusion(struct megasas_instance *instance,
3949 writel(MPI2_WRSEQ_FLUSH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3950 writel(MPI2_WRSEQ_1ST_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3951 writel(MPI2_WRSEQ_2ND_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3952 writel(MPI2_WRSEQ_3RD_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3953 writel(MPI2_WRSEQ_4TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3954 writel(MPI2_WRSEQ_5TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3955 writel(MPI2_WRSEQ_6TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3958 host_diag = megasas_readl(instance, &instance->reg_set->fusion_host_diag);
3962 host_diag = megasas_readl(instance,
3963 &instance->reg_set->fusion_host_diag);
3965 dev_warn(&instance->pdev->dev,
3976 &instance->reg_set->fusion_host_diag);
3980 host_diag = megasas_readl(instance, &instance->reg_set->fusion_host_diag);
3984 host_diag = megasas_readl(instance,
3985 &instance->reg_set->fusion_host_diag);
3987 dev_warn(&instance->pdev->dev,
3996 abs_state = instance->instancet->read_fw_status_reg(instance)
4002 abs_state = instance->instancet->
4003 read_fw_status_reg(instance) & MFI_STATE_MASK;
4006 dev_warn(&instance->pdev->dev,
4017 * @instance: Controller's soft instance
4021 megasas_check_reset_fusion(struct megasas_instance *instance,
4029 * @instance: Soft instance of adapter
4031 static inline void megasas_trigger_snap_dump(struct megasas_instance *instance)
4036 if (!instance->disableOnlineCtrlReset) {
4037 dev_info(&instance->pdev->dev, "Trigger snap dump\n");
4039 &instance->reg_set->doorbell);
4040 readl(&instance->reg_set->doorbell);
4043 for (j = 0; j < instance->snapdump_wait_time; j++) {
4044 abs_state = instance->instancet->read_fw_status_reg(instance);
4047 dev_printk(KERN_ERR, &instance->pdev->dev,
4059 megasas_wait_for_outstanding_fusion(struct megasas_instance *instance,
4068 (resetwaittime - instance->snapdump_wait_time));
4071 dev_info(&instance->pdev->dev,
4073 megasas_complete_cmd_dpc_fusion((unsigned long)instance);
4074 if (instance->snapdump_wait_time)
4075 megasas_trigger_snap_dump(instance);
4082 abs_state = instance->instancet->read_fw_status_reg(instance);
4085 dev_printk(KERN_ERR, &instance->pdev->dev,
4089 megasas_complete_cmd_dpc_fusion((unsigned long)instance);
4090 if (instance->requestorId && reason) {
4091 dev_warn(&instance->pdev->dev, "SR-IOV Found FW in FAULT"
4094 instance->host->host_no);
4104 if (instance->requestorId && !reason) {
4110 if (instance->requestorId && (reason == SCSIIO_TIMEOUT_OCR)) {
4111 if (instance->hb_host_mem->HB.fwCounter !=
4112 instance->hb_host_mem->HB.driverCounter) {
4113 instance->hb_host_mem->HB.driverCounter =
4114 instance->hb_host_mem->HB.fwCounter;
4120 dev_warn(&instance->pdev->dev, "SR-IOV:"
4125 instance->host->host_no);
4133 megasas_complete_cmd_dpc_fusion((unsigned long)instance);
4134 outstanding = atomic_read(&instance->fw_outstanding);
4139 dev_notice(&instance->pdev->dev, "[%2d]waiting for %d "
4141 outstanding, instance->host->host_no);
4146 if (instance->snapdump_wait_time) {
4147 megasas_trigger_snap_dump(instance);
4152 if (atomic_read(&instance->fw_outstanding)) {
4153 dev_err(&instance->pdev->dev, "pending commands remain after waiting, "
4155 instance->host->host_no);
4164 void megasas_reset_reply_desc(struct megasas_instance *instance)
4170 fusion = instance->ctrl_context;
4171 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
4182 * @instance: Controller's soft instance
4184 static void megasas_refire_mgmt_cmd(struct megasas_instance *instance,
4198 fusion = instance->ctrl_context;
4203 for (j = instance->max_scsi_cmds ; j < instance->max_fw_cmds; j++) {
4205 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
4212 req_desc = megasas_get_request_descriptor(instance, smid - 1);
4233 if (!instance->support_nvme_passthru) {
4240 if (!instance->support_pci_lane_margining) {
4252 dev_err(&instance->pdev->dev,
4267 megasas_fire_cmd_fusion(instance, req_desc);
4270 megasas_return_cmd(instance, cmd_mfi);
4273 megasas_complete_cmd(instance, cmd_mfi, DID_OK);
4282 * @instance: Controller's soft instance
4285 megasas_return_polled_cmds(struct megasas_instance *instance)
4292 fusion = instance->ctrl_context;
4294 for (i = instance->max_scsi_cmds; i < instance->max_fw_cmds; i++) {
4296 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
4300 dev_info(&instance->pdev->dev,
4305 megasas_return_cmd(instance, cmd_mfi);
4312 * @instance: per adapter struct
4319 static int megasas_track_scsiio(struct megasas_instance *instance,
4325 fusion = instance->ctrl_context;
4327 for (i = 0 ; i < instance->max_scsi_cmds; i++) {
4332 dev_info(&instance->pdev->dev,
4347 * @instance: Controller's soft instance
4353 megasas_tm_response_code(struct megasas_instance *instance,
4387 dev_dbg(&instance->pdev->dev, "response_code(%01x): %s\n",
4389 dev_dbg(&instance->pdev->dev,
4399 * @instance: per adapter struct
4414 megasas_issue_tm(struct megasas_instance *instance, u16 device_handle,
4430 fusion = instance->ctrl_context;
4432 cmd_mfi = megasas_get_cmd(instance);
4435 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
4440 cmd_fusion = megasas_get_cmd_fusion(instance,
4441 instance->max_scsi_cmds + cmd_mfi->index);
4446 req_desc = megasas_get_request_descriptor(instance,
4477 megasas_fire_cmd_fusion(instance, req_desc);
4491 dev_err(&instance->pdev->dev,
4493 mutex_unlock(&instance->reset_mutex);
4494 rc = megasas_reset_fusion(instance->host, MFI_IO_TIMEOUT_OCR);
4495 mutex_lock(&instance->reset_mutex);
4500 megasas_tm_response_code(instance, mpi_reply);
4502 megasas_return_cmd(instance, cmd_mfi);
4511 instance->instancet->disable_intr(instance);
4512 megasas_sync_irqs((unsigned long)instance);
4513 instance->instancet->enable_intr(instance);
4514 megasas_enable_irq_poll(instance);
4524 instance->instancet->disable_intr(instance);
4525 megasas_sync_irqs((unsigned long)instance);
4526 rc = megasas_track_scsiio(instance, id, channel);
4527 instance->instancet->enable_intr(instance);
4528 megasas_enable_irq_poll(instance);
4545 * @instance: per adapter struct
4552 struct megasas_instance *instance;
4556 instance = (struct megasas_instance *)scmd->device->host->hostdata;
4558 fusion = instance->ctrl_context;
4560 for (i = 0; i < instance->max_scsi_cmds; i++) {
4583 struct megasas_instance *instance;
4588 instance = (struct megasas_instance *)sdev->host->hostdata;
4589 fusion = instance->ctrl_context;
4592 if (instance->use_seqnum_jbod_fp) {
4596 [(instance->pd_seq_map_id - 1) & 1];
4619 struct megasas_instance *instance;
4625 instance = (struct megasas_instance *)scmd->device->host->hostdata;
4627 if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
4628 dev_err(&instance->pdev->dev, "Controller is not OPERATIONAL,"
4629 "SCSI host:%d\n", instance->host->host_no);
4647 mutex_lock(&instance->reset_mutex);
4655 mutex_unlock(&instance->reset_mutex);
4665 mutex_unlock(&instance->reset_mutex);
4673 ret = megasas_issue_tm(instance, devhandle,
4679 mutex_unlock(&instance->reset_mutex);
4700 struct megasas_instance *instance;
4706 instance = (struct megasas_instance *)scmd->device->host->hostdata;
4708 if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
4709 dev_err(&instance->pdev->dev, "Controller is not OPERATIONAL,"
4710 "SCSI host:%d\n", instance->host->host_no);
4728 mutex_lock(&instance->reset_mutex);
4735 mutex_unlock(&instance->reset_mutex);
4743 ret = megasas_issue_tm(instance, devhandle,
4748 mutex_unlock(&instance->reset_mutex);
4756 /*SRIOV get other instance in cluster if any*/
4758 megasas_instance *megasas_get_peer_instance(struct megasas_instance *instance)
4763 if (megasas_mgmt_info.instance[i] &&
4764 (megasas_mgmt_info.instance[i] != instance) &&
4765 megasas_mgmt_info.instance[i]->requestorId &&
4766 megasas_mgmt_info.instance[i]->peerIsPresent &&
4767 (memcmp((megasas_mgmt_info.instance[i]->clusterId),
4768 instance->clusterId, MEGASAS_CLUSTER_ID_SIZE) == 0))
4769 return megasas_mgmt_info.instance[i];
4775 int megasas_check_mpio_paths(struct megasas_instance *instance,
4781 if (instance->peerIsPresent) {
4782 peer_instance = megasas_get_peer_instance(instance);
4795 struct megasas_instance *instance;
4807 instance = (struct megasas_instance *)shost->hostdata;
4808 fusion = instance->ctrl_context;
4810 mutex_lock(&instance->reset_mutex);
4812 if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
4813 dev_warn(&instance->pdev->dev, "Hardware critical error, "
4815 instance->host->host_no);
4816 mutex_unlock(&instance->reset_mutex);
4819 status_reg = instance->instancet->read_fw_status_reg(instance);
4823 if (abs_state != MFI_STATE_FAULT && instance->crash_dump_buf &&
4824 instance->crash_dump_app_support && reason) {
4825 dev_info(&instance->pdev->dev, "IO/DCMD timeout is detected, "
4827 atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
4828 status_reg = megasas_readl(instance, &instance->reg_set->doorbell);
4830 &instance->reg_set->doorbell);
4831 readl(&instance->reg_set->doorbell);
4832 mutex_unlock(&instance->reset_mutex);
4836 dev_dbg(&instance->pdev->dev, "waiting for [%d] "
4839 } while ((atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) &&
4842 if (atomic_read(&instance->adprecovery) == MEGASAS_HBA_OPERATIONAL) {
4843 dev_info(&instance->pdev->dev, "OCR done for IO "
4847 dev_info(&instance->pdev->dev, "Controller is not "
4856 if (instance->requestorId && !instance->skip_heartbeat_timer_del)
4857 del_timer_sync(&instance->sriov_heartbeat_timer);
4858 set_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
4859 set_bit(MEGASAS_FUSION_OCR_NOT_POSSIBLE, &instance->reset_flags);
4860 atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_POLLING);
4861 instance->instancet->disable_intr(instance);
4862 megasas_sync_irqs((unsigned long)instance);
4865 if (megasas_wait_for_outstanding_fusion(instance, reason,
4867 atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
4868 dev_warn(&instance->pdev->dev, "resetting fusion "
4869 "adapter scsi%d.\n", instance->host->host_no);
4874 dev_info(&instance->pdev->dev, "\nPending SCSI commands:\n");
4877 for (i = 0 ; i < instance->max_scsi_cmds; i++) {
4880 if (instance->adapter_type >= VENTURA_SERIES) {
4881 r1_cmd = fusion->cmd_list[i + instance->max_fw_cmds];
4882 megasas_return_cmd_fusion(instance, r1_cmd);
4898 megasas_check_mpio_paths(instance,
4900 if (instance->ldio_threshold &&
4902 atomic_dec(&instance->ldio_outstanding);
4903 megasas_return_cmd_fusion(instance, cmd_fusion);
4909 dev_info(&instance->pdev->dev, "Outstanding fastpath IOs: %d\n",
4912 atomic_set(&instance->fw_outstanding, 0);
4914 status_reg = instance->instancet->read_fw_status_reg(instance);
4917 if (instance->disableOnlineCtrlReset ||
4920 dev_warn(&instance->pdev->dev, "Reset not supported"
4922 instance->host->host_no);
4927 if (instance->requestorId && !reason) {
4939 if (megasas_adp_reset_wait_for_ready(instance,
4944 if (megasas_transition_to_ready(instance, 1)) {
4945 dev_warn(&instance->pdev->dev,
4947 "scsi%d.\n", instance->host->host_no);
4950 megasas_reset_reply_desc(instance);
4951 megasas_fusion_update_can_queue(instance, OCR_CONTEXT);
4953 if (megasas_ioc_init_fusion(instance)) {
4957 if (megasas_get_ctrl_info(instance)) {
4958 dev_info(&instance->pdev->dev,
4964 megasas_refire_mgmt_cmd(instance,
4974 if (!megasas_get_map_info(instance)) {
4975 megasas_sync_map_info(instance);
4981 megasas_return_polled_cmds(instance);
4985 megasas_setup_jbod_map(instance);
4988 if (instance->adapter_type >= VENTURA_SERIES) {
4998 &instance->reset_flags);
4999 instance->instancet->enable_intr(instance);
5000 megasas_enable_irq_poll(instance);
5002 if ((instance->tgt_prop) &&
5003 (instance->nvme_page_size))
5004 ret_target_prop = megasas_get_target_prop(instance, sdev);
5010 status_reg = instance->instancet->read_fw_status_reg
5011 (instance);
5014 dev_info(&instance->pdev->dev,
5016 abs_state, instance->host->host_no);
5019 atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
5021 dev_info(&instance->pdev->dev,
5023 instance->host->host_no);
5026 if (instance->requestorId) {
5027 if (!megasas_sriov_start_heartbeat(instance, 0))
5028 megasas_start_timer(instance);
5030 instance->skip_heartbeat_timer_del = 1;
5033 if (instance->crash_dump_drv_support &&
5034 instance->crash_dump_app_support)
5035 megasas_set_crash_dump_params(instance,
5038 megasas_set_crash_dump_params(instance,
5041 if (instance->snapdump_wait_time) {
5042 megasas_get_snapdump_properties(instance);
5043 dev_info(&instance->pdev->dev,
5045 instance->snapdump_wait_time);
5051 dev_warn(&instance->pdev->dev,
5053 instance->host->host_no);
5058 dev_warn(&instance->pdev->dev, "Reset failed, killing "
5059 "adapter scsi%d.\n", instance->host->host_no);
5063 if (instance->requestorId) {
5064 megasas_start_timer(instance);
5066 clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
5067 instance->instancet->enable_intr(instance);
5068 megasas_enable_irq_poll(instance);
5069 atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
5073 megaraid_sas_kill_hba(instance);
5074 megasas_enable_irq_poll(instance);
5075 instance->skip_heartbeat_timer_del = 1;
5078 clear_bit(MEGASAS_FUSION_OCR_NOT_POSSIBLE, &instance->reset_flags);
5079 mutex_unlock(&instance->reset_mutex);
5084 static void megasas_fusion_crash_dump(struct megasas_instance *instance)
5091 status_reg = instance->instancet->read_fw_status_reg(instance);
5097 if (instance->drv_buf_index == 0) {
5101 if (instance->drv_buf_alloc) {
5102 dev_info(&instance->pdev->dev, "earlier crash dump is "
5107 &instance->reg_set->outbound_scratch_pad_0);
5108 readl(&instance->reg_set->outbound_scratch_pad_0);
5111 megasas_alloc_host_crash_buffer(instance);
5112 dev_info(&instance->pdev->dev, "Number of host crash buffers "
5113 "allocated: %d\n", instance->drv_buf_alloc);
5126 status_reg = instance->instancet->read_fw_status_reg(
5127 instance);
5132 if (instance->drv_buf_index >= instance->drv_buf_alloc) {
5133 dev_info(&instance->pdev->dev,
5135 instance->drv_buf_alloc);
5140 memcpy(instance->crash_buf[instance->drv_buf_index],
5141 instance->crash_dump_buf, CRASH_DMA_BUF_SIZE);
5142 instance->drv_buf_index++;
5146 writel(status_reg, &instance->reg_set->outbound_scratch_pad_0);
5147 readl(&instance->reg_set->outbound_scratch_pad_0);
5150 status_reg = instance->instancet->read_fw_status_reg(instance);
5154 dev_info(&instance->pdev->dev, "Crash Dump is available,number "
5155 "of copied buffers: %d\n", instance->drv_buf_index);
5156 instance->fw_crash_buffer_size = instance->drv_buf_index;
5157 instance->fw_crash_state = AVAILABLE;
5158 instance->drv_buf_index = 0;
5159 writel(status_reg, &instance->reg_set->outbound_scratch_pad_0);
5160 readl(&instance->reg_set->outbound_scratch_pad_0);
5162 megasas_reset_fusion(instance->host, 0);
5170 struct megasas_instance *instance =
5173 megasas_reset_fusion(instance->host, 0);
5178 megasas_alloc_fusion_context(struct megasas_instance *instance)
5182 instance->ctrl_context = kzalloc(sizeof(struct fusion_context),
5184 if (!instance->ctrl_context) {
5185 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
5190 fusion = instance->ctrl_context;
5202 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
5218 dev_err(&instance->pdev->dev, "Failed to allocate load_balance_info, "
5226 megasas_free_fusion_context(struct megasas_instance *instance)
5228 struct fusion_context *fusion = instance->ctrl_context;