xref: /kernel/linux/linux-5.10/drivers/scsi/megaraid/megaraid_sas_base.c

126 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
127 static int megasas_get_pd_list(struct megasas_instance *instance);
128 static int megasas_ld_list_query(struct megasas_instance *instance,
130 static int megasas_issue_init_mfi(struct megasas_instance *instance);
131 static int megasas_register_aen(struct megasas_instance *instance,
133 static void megasas_get_pd_info(struct megasas_instance *instance,
136 megasas_set_ld_removed_by_fw(struct megasas_instance *instance);
214 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
217 megasas_read_fw_status_reg_gen2(struct megasas_instance *instance);
219 megasas_adp_reset_gen2(struct megasas_instance *instance,
223 megasas_init_adapter_mfi(struct megasas_instance *instance);
225 megasas_build_and_issue_cmd(struct megasas_instance *instance,
229 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
232 static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,
235 megasas_set_dma_mask(struct megasas_instance *instance);
237 megasas_alloc_ctrl_mem(struct megasas_instance *instance);
239 megasas_free_ctrl_mem(struct megasas_instance *instance);
241 megasas_alloc_ctrl_dma_buffers(struct megasas_instance *instance);
243 megasas_free_ctrl_dma_buffers(struct megasas_instance *instance);
245 megasas_init_ctrl_params(struct megasas_instance *instance);
247 u32 megasas_readl(struct megasas_instance *instance,
258 	if (instance->adapter_type == AERO_SERIES) {
271  * @instance:			Adapter soft state
277 void megasas_set_dma_settings(struct megasas_instance *instance,
281 	if (instance->consistent_mask_64bit) {
295 megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
297 	instance->instancet->fire_cmd(instance,
298 		cmd->frame_phys_addr, 0, instance->reg_set);
304  * @instance:		Adapter soft state
309 						  *instance)
314 	spin_lock_irqsave(&instance->mfi_pool_lock, flags);
316 	if (!list_empty(&instance->cmd_pool)) {
317 		cmd = list_entry((&instance->cmd_pool)->next,
321 		dev_err(&instance->pdev->dev, "Command pool empty!\n");
324 	spin_unlock_irqrestore(&instance->mfi_pool_lock, flags);
330  * @instance:		Adapter soft state
334 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
339 	struct fusion_context *fusion = instance->ctrl_context;
347 	spin_lock_irqsave(&instance->mfi_pool_lock, flags);
350 		blk_tags = instance->max_scsi_cmds + cmd->index;
352 		megasas_return_cmd_fusion(instance, cmd_fusion);
357 	memset(cmd->frame, 0, instance->mfi_frame_size);
361 	list_add(&cmd->list, (&instance->cmd_pool)->next);
363 	spin_unlock_irqrestore(&instance->mfi_pool_lock, flags);
409   * @instance:			Adapter soft state
412 megasas_decode_evt(struct megasas_instance *instance)
414 	struct megasas_evt_detail *evt_detail = instance->evt_detail;
425 		dev_info(&instance->pdev->dev, "%d (%s/0x%04x/%s) - %s\n",
433 		dev_info(&instance->pdev->dev,
446  * @instance:	Adapter soft state
449 megasas_enable_intr_xscale(struct megasas_instance *instance)
453 	regs = instance->reg_set;
462  * @instance:	Adapter soft state
465 megasas_disable_intr_xscale(struct megasas_instance *instance)
470 	regs = instance->reg_set;
478  * @instance:	Adapter soft state
481 megasas_read_fw_status_reg_xscale(struct megasas_instance *instance)
483 	return readl(&instance->reg_set->outbound_msg_0);
487  * @instance:	Adapter soft state
490 megasas_clear_intr_xscale(struct megasas_instance *instance)
495 	regs = instance->reg_set;
521  * @instance:		Adapter soft state
527 megasas_fire_cmd_xscale(struct megasas_instance *instance,
534 	spin_lock_irqsave(&instance->hba_lock, flags);
537 	spin_unlock_irqrestore(&instance->hba_lock, flags);
542  * @instance:	Adapter soft state
546 megasas_adp_reset_xscale(struct megasas_instance *instance,
557 	pci_read_config_dword(instance->pdev, MFI_1068_PCSR_OFFSET, &pcidata);
558 	dev_notice(&instance->pdev->dev, "pcidata = %x\n", pcidata);
560 		dev_notice(&instance->pdev->dev, "mfi 1068 offset read=%x\n", pcidata);
562 		pci_write_config_dword(instance->pdev,
569 		pci_read_config_dword(instance->pdev,
571 		dev_notice(&instance->pdev->dev, "1068 offset handshake read=%x\n", pcidata);
573 			dev_notice(&instance->pdev->dev, "1068 offset pcidt=%x\n", pcidata);
575 			pci_write_config_dword(instance->pdev,
584  * @instance:	Adapter soft state
588 megasas_check_reset_xscale(struct megasas_instance *instance,
591 	if ((atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) &&
592 	    (le32_to_cpu(*instance->consumer) ==
626  * @instance:	Adapter soft state
629 megasas_enable_intr_ppc(struct megasas_instance *instance)
633 	regs = instance->reg_set;
644  * @instance:	Adapter soft state
647 megasas_disable_intr_ppc(struct megasas_instance *instance)
652 	regs = instance->reg_set;
660  * @instance:	Adapter soft state
663 megasas_read_fw_status_reg_ppc(struct megasas_instance *instance)
665 	return readl(&instance->reg_set->outbound_scratch_pad_0);
670  * @instance:	Adapter soft state
673 megasas_clear_intr_ppc(struct megasas_instance *instance)
677 	regs = instance->reg_set;
703  * @instance:		Adapter soft state
709 megasas_fire_cmd_ppc(struct megasas_instance *instance,
716 	spin_lock_irqsave(&instance->hba_lock, flags);
719 	spin_unlock_irqrestore(&instance->hba_lock, flags);
724  * @instance:	Adapter soft state
728 megasas_check_reset_ppc(struct megasas_instance *instance,
731 	if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
755  * @instance:	Adapter soft state
758 megasas_enable_intr_skinny(struct megasas_instance *instance)
762 	regs = instance->reg_set;
773  * @instance:	Adapter soft state
776 megasas_disable_intr_skinny(struct megasas_instance *instance)
781 	regs = instance->reg_set;
789  * @instance:	Adapter soft state
792 megasas_read_fw_status_reg_skinny(struct megasas_instance *instance)
794 	return readl(&instance->reg_set->outbound_scratch_pad_0);
799  * @instance:	Adapter soft state
802 megasas_clear_intr_skinny(struct megasas_instance *instance)
807 	regs = instance->reg_set;
821 	if ((megasas_read_fw_status_reg_skinny(instance) & MFI_STATE_MASK) ==
842  * @instance:		Adapter soft state
848 megasas_fire_cmd_skinny(struct megasas_instance *instance,
855 	spin_lock_irqsave(&instance->hba_lock, flags);
860 	spin_unlock_irqrestore(&instance->hba_lock, flags);
865  * @instance:	Adapter soft state
869 megasas_check_reset_skinny(struct megasas_instance *instance,
872 	if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
902  * @instance:	Adapter soft state
905 megasas_enable_intr_gen2(struct megasas_instance *instance)
909 	regs = instance->reg_set;
921  * @instance:	Adapter soft state
924 megasas_disable_intr_gen2(struct megasas_instance *instance)
929 	regs = instance->reg_set;
937  * @instance:	Adapter soft state
940 megasas_read_fw_status_reg_gen2(struct megasas_instance *instance)
942 	return readl(&instance->reg_set->outbound_scratch_pad_0);
947  * @instance:	Adapter soft state
950 megasas_clear_intr_gen2(struct megasas_instance *instance)
955 	regs = instance->reg_set;
983  * @instance:		Adapter soft state
989 megasas_fire_cmd_gen2(struct megasas_instance *instance,
996 	spin_lock_irqsave(&instance->hba_lock, flags);
999 	spin_unlock_irqrestore(&instance->hba_lock, flags);
1004  * @instance:	Adapter soft state
1008 megasas_adp_reset_gen2(struct megasas_instance *instance,
1016 	if (instance->instancet == &megasas_instance_template_skinny) {
1035 		dev_notice(&instance->pdev->dev, "RESETGEN2: retry=%x, hostdiag=%x\n",
1043 	dev_notice(&instance->pdev->dev, "ADP_RESET_GEN2: HostDiag=%x\n", HostDiag);
1053 		dev_notice(&instance->pdev->dev, "RESET_GEN2: retry=%x, hostdiag=%x\n",
1065  * @instance:	Adapter soft state
1069 megasas_check_reset_gen2(struct megasas_instance *instance,
1072 	if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
1106  * @instance:			Adapter soft state
1112 megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
1119 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
1120 		dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1125 	instance->instancet->issue_dcmd(instance, cmd);
1127 	return wait_and_poll(instance, cmd, instance->requestorId ?
1133  * @instance:			Adapter soft state
1142 megasas_issue_blocked_cmd(struct megasas_instance *instance,
1148 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
1149 		dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1154 	instance->instancet->issue_dcmd(instance, cmd);
1157 		ret = wait_event_timeout(instance->int_cmd_wait_q,
1160 			dev_err(&instance->pdev->dev,
1166 		wait_event(instance->int_cmd_wait_q,
1174  * @instance:				Adapter soft state
1184 megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
1192 	cmd = megasas_get_cmd(instance);
1214 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
1215 		dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1220 	instance->instancet->issue_dcmd(instance, cmd);
1223 		ret = wait_event_timeout(instance->abort_cmd_wait_q,
1227 			dev_err(&instance->pdev->dev,
1233 		wait_event(instance->abort_cmd_wait_q,
1238 	megasas_return_cmd(instance, cmd);
1244  * @instance:		Adapter soft state
1252 megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp,
1273  * @instance:		Adapter soft state
1281 megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
1302  * @instance:           Adapter soft state
1310 megasas_make_sgl_skinny(struct megasas_instance *instance,
1339 static u32 megasas_get_frame_count(struct megasas_instance *instance,
1350 	if (instance->flag_ieee) {
1361 		if (instance->flag_ieee == 1) {
1368 		if (instance->flag_ieee == 1) {
1392  * @instance:		Adapter soft state
1400 megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
1419 	if (instance->flag_ieee == 1) {
1453 	if (instance->flag_ieee == 1) {
1455 		pthru->sge_count = megasas_make_sgl_skinny(instance, scp,
1459 		pthru->sge_count = megasas_make_sgl64(instance, scp,
1462 		pthru->sge_count = megasas_make_sgl32(instance, scp,
1465 	if (pthru->sge_count > instance->max_num_sge) {
1466 		dev_err(&instance->pdev->dev, "DCDB too many SGE NUM=%x\n",
1484 	cmd->frame_count = megasas_get_frame_count(instance, pthru->sge_count,
1492  * @instance:		Adapter soft state
1499 megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
1515 	if (instance->flag_ieee == 1) {
1596 	if (instance->flag_ieee) {
1598 		ldio->sge_count = megasas_make_sgl_skinny(instance, scp,
1602 		ldio->sge_count = megasas_make_sgl64(instance, scp, &ldio->sgl);
1604 		ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl);
1606 	if (ldio->sge_count > instance->max_num_sge) {
1607 		dev_err(&instance->pdev->dev, "build_ld_io: sge_count = %x\n",
1623 	cmd->frame_count = megasas_get_frame_count(instance,
1661  * @instance:				Adapter soft state
1664 megasas_dump_pending_frames(struct megasas_instance *instance)
1672 	u16 max_cmd = instance->max_fw_cmds;
1674 	dev_err(&instance->pdev->dev, "[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance->host->host_no);
1675 	dev_err(&instance->pdev->dev, "[%d]: Total OS Pending cmds : %d\n",instance->host->host_no,atomic_read(&instance->fw_outstanding));
1677 		dev_err(&instance->pdev->dev, "[%d]: 64 bit SGLs were sent to FW\n",instance->host->host_no);
1679 		dev_err(&instance->pdev->dev, "[%d]: 32 bit SGLs were sent to FW\n",instance->host->host_no);
1681 	dev_err(&instance->pdev->dev, "[%d]: Pending OS cmds in FW : \n",instance->host->host_no);
1683 		cmd = instance->cmd_list[i];
1686 		dev_err(&instance->pdev->dev, "[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);
1691 			dev_err(&instance->pdev->dev, "[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x,"
1693 			instance->host->host_no, cmd->frame_count, ldio->cmd, ldio->target_id,
1700 			dev_err(&instance->pdev->dev, "[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x, "
1702 			instance->host->host_no, cmd->frame_count, pthru->cmd, pthru->target_id,
1709 					dev_err(&instance->pdev->dev, "sgl len : 0x%x, sgl addr : 0x%llx\n",
1713 					dev_err(&instance->pdev->dev, "sgl len : 0x%x, sgl addr : 0x%x\n",
1719 	dev_err(&instance->pdev->dev, "[%d]: Pending Internal cmds in FW : \n",instance->host->host_no);
1722 		cmd = instance->cmd_list[i];
1725 			dev_err(&instance->pdev->dev, "0x%08lx : ", (unsigned long)cmd->frame_phys_addr);
1727 	dev_err(&instance->pdev->dev, "[%d]: Dumping Done\n\n",instance->host->host_no);
1731 megasas_build_and_issue_cmd(struct megasas_instance *instance,
1737 	cmd = megasas_get_cmd(instance);
1745 		frame_count = megasas_build_ldio(instance, scmd, cmd);
1747 		frame_count = megasas_build_dcdb(instance, scmd, cmd);
1758 	atomic_inc(&instance->fw_outstanding);
1760 	instance->instancet->fire_cmd(instance, cmd->frame_phys_addr,
1761 				cmd->frame_count-1, instance->reg_set);
1765 	megasas_return_cmd(instance, cmd);
1778 	struct megasas_instance *instance;
1782 	instance = (struct megasas_instance *)
1785 	if (instance->unload == 1) {
1791 	if (instance->issuepend_done == 0)
1796 	if (atomic_read(&instance->adprecovery) == MEGASAS_ADPRESET_SM_INFAULT) {
1797 		if (megasas_check_mpio_paths(instance, scmd) ==
1809 	    (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)) {
1817 		if (instance->ld_tgtid_status[ld_tgt_id] == LD_TARGET_ID_DELETED) {
1824 	if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
1834 	    (scmd->device->id >= instance->fw_supported_vd_count ||
1842 	    (!instance->fw_sync_cache_support)) {
1847 	return instance->instancet->build_and_issue_cmd(instance, scmd);
1860 		if ((megasas_mgmt_info.instance[i]) &&
1861 		    (megasas_mgmt_info.instance[i]->host->host_no == host_no))
1862 			return megasas_mgmt_info.instance[i];
1885 	struct megasas_instance *instance;
1892 	instance = megasas_lookup_instance(sdev->host->host_no);
1893 	fusion = instance->ctrl_context;
1902 		local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
1904 		if (ld >= instance->fw_supported_vd_count)
1917 	} else if (instance->use_seqnum_jbod_fp) {
1921 				[(instance->pd_seq_map_id - 1) & 1];
1926 	if (is_target_prop && instance->tgt_prop->reset_tmo) {
1932 			min_t(u8, instance->max_reset_tmo,
1933 			      instance->tgt_prop->reset_tmo);
1934 		mr_device_priv_data->task_abort_tmo = instance->task_abort_tmo;
1962 	struct megasas_instance *instance;
1965 	instance = (struct megasas_instance *)sdev->host->hostdata;
1966 	mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
1989 	struct megasas_instance *instance;
1992 	instance = megasas_lookup_instance(sdev->host->host_no);
2009 		tgt_device_qd = le32_to_cpu(instance->tgt_prop->device_qdepth);
2011 			device_qd = min(instance->host->can_queue,
2015 	if (instance->enable_sdev_max_qd && interface_type != UNKNOWN_DRIVE)
2016 		device_qd = instance->host->can_queue;
2037 	struct megasas_instance *instance;
2039 	instance = megasas_lookup_instance(sdev->host->host_no);
2050 		max_io_size_kb = le32_to_cpu(instance->tgt_prop->max_io_size_kb);
2052 	if (instance->nvme_page_size && max_io_size_kb)
2062 	struct megasas_instance *instance;
2066 	instance = megasas_lookup_instance(sdev->host->host_no);
2067 	if (instance->pd_list_not_supported) {
2071 			if (instance->pd_list[pd_index].driveState !=
2077 	mutex_lock(&instance->reset_mutex);
2079 	if ((instance->pd_info) && !MEGASAS_IS_LOGICAL(sdev))
2080 		megasas_get_pd_info(instance, sdev);
2082 	/* Some ventura firmware may not have instance->nvme_page_size set.
2085 	if ((instance->tgt_prop) && (instance->nvme_page_size))
2086 		ret_target_prop = megasas_get_target_prop(instance, sdev);
2094 	mutex_unlock(&instance->reset_mutex);
2102 	struct megasas_instance *instance ;
2105 	instance = megasas_lookup_instance(sdev->host->host_no);
2113 		if ((instance->pd_list_not_supported ||
2114 			instance->pd_list[pd_index].driveState ==
2132 		instance->ld_tgtid_status[ld_tgt_id] = LD_TARGET_ID_ACTIVE;
2140 		   instance->r1_ldio_hint_default);
2147 	struct megasas_instance *instance;
2149 	instance = megasas_lookup_instance(sdev->host->host_no);
2157 		instance->ld_tgtid_status[ld_tgt_id] = LD_TARGET_ID_DELETED;
2170 * @instance:				Adapter soft state
2173 static void megasas_complete_outstanding_ioctls(struct megasas_instance *instance)
2178 	struct fusion_context *fusion = instance->ctrl_context;
2182 		for (i = 0; i < instance->max_fw_cmds; i++) {
2185 				cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
2190 					megasas_complete_cmd(instance,
2196 		for (i = 0; i < instance->max_fw_cmds; i++) {
2197 			cmd_mfi = instance->cmd_list[i];
2200 				megasas_complete_cmd(instance, cmd_mfi, DID_OK);
2206 void megaraid_sas_kill_hba(struct megasas_instance *instance)
2208 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2209 		dev_warn(&instance->pdev->dev,
2215 	atomic_set(&instance->adprecovery, MEGASAS_HW_CRITICAL_ERROR);
2218 	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2219 		(instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
2220 		(instance->adapter_type != MFI_SERIES)) {
2221 		if (!instance->requestorId) {
2222 			writel(MFI_STOP_ADP, &instance->reg_set->doorbell);
2224 			readl(&instance->reg_set->doorbell);
2226 		if (instance->requestorId && instance->peerIsPresent)
2227 			memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
2230 			&instance->reg_set->inbound_doorbell);
2233 	megasas_complete_outstanding_ioctls(instance);
2239   * @instance:			Adapter soft state
2243 megasas_check_and_restore_queue_depth(struct megasas_instance *instance)
2247 	if (instance->flag & MEGASAS_FW_BUSY
2248 	    && time_after(jiffies, instance->last_time + 5 * HZ)
2249 	    && atomic_read(&instance->fw_outstanding) <
2250 	    instance->throttlequeuedepth + 1) {
2252 		spin_lock_irqsave(instance->host->host_lock, flags);
2253 		instance->flag &= ~MEGASAS_FW_BUSY;
2255 		instance->host->can_queue = instance->cur_can_queue;
2256 		spin_unlock_irqrestore(instance->host->host_lock, flags);
2272 	struct megasas_instance *instance =
2277 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
2280 	spin_lock_irqsave(&instance->completion_lock, flags);
2282 	producer = le32_to_cpu(*instance->producer);
2283 	consumer = le32_to_cpu(*instance->consumer);
2286 		context = le32_to_cpu(instance->reply_queue[consumer]);
2287 		if (context >= instance->max_fw_cmds) {
2288 			dev_err(&instance->pdev->dev, "Unexpected context value %x\n",
2293 		cmd = instance->cmd_list[context];
2295 		megasas_complete_cmd(instance, cmd, DID_OK);
2298 		if (consumer == (instance->max_fw_cmds + 1)) {
2303 	*instance->consumer = cpu_to_le32(producer);
2305 	spin_unlock_irqrestore(&instance->completion_lock, flags);
2310 	megasas_check_and_restore_queue_depth(instance);
2317  * @instance:		Adapter soft state
2320 void megasas_start_timer(struct megasas_instance *instance)
2322 	struct timer_list *timer = &instance->sriov_heartbeat_timer;
2330 megasas_internal_reset_defer_cmds(struct megasas_instance *instance);
2335 static void megasas_do_ocr(struct megasas_instance *instance)
2337 	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
2338 	(instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
2339 	(instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
2340 		*instance->consumer = cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
2342 	instance->instancet->disable_intr(instance);
2343 	atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
2344 	instance->issuepend_done = 0;
2346 	atomic_set(&instance->fw_outstanding, 0);
2347 	megasas_internal_reset_defer_cmds(instance);
2348 	process_fw_state_change_wq(&instance->work_init);
2351 static int megasas_get_ld_vf_affiliation_111(struct megasas_instance *instance,
2361 	cmd = megasas_get_cmd(instance);
2364 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_vf_affiliation_111:"
2366 			instance->host->host_no);
2372 	if (!instance->vf_affiliation_111) {
2373 		dev_warn(&instance->pdev->dev, "SR-IOV: Couldn't get LD/VF "
2374 		       "affiliation for scsi%d\n", instance->host->host_no);
2375 		megasas_return_cmd(instance, cmd);
2380 			memset(instance->vf_affiliation_111, 0,
2384 			dma_alloc_coherent(&instance->pdev->dev,
2388 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
2390 			       instance->host->host_no);
2391 			megasas_return_cmd(instance, cmd);
2410 			cpu_to_le32(instance->vf_affiliation_111_h);
2418 	dev_warn(&instance->pdev->dev, "SR-IOV: Getting LD/VF affiliation for "
2419 	       "scsi%d\n", instance->host->host_no);
2421 	if (megasas_issue_blocked_cmd(instance, cmd, 0) != DCMD_SUCCESS) {
2422 		dev_warn(&instance->pdev->dev, "SR-IOV: LD/VF affiliation DCMD"
2424 		       dcmd->cmd_status, instance->host->host_no);
2432 			if (instance->vf_affiliation_111->map[ld].policy[thisVf] !=
2434 				dev_warn(&instance->pdev->dev, "SR-IOV: "
2436 				       instance->host->host_no);
2437 				memcpy(instance->vf_affiliation_111,
2446 		dma_free_coherent(&instance->pdev->dev,
2452 	megasas_return_cmd(instance, cmd);
2457 static int megasas_get_ld_vf_affiliation_12(struct megasas_instance *instance,
2468 	cmd = megasas_get_cmd(instance);
2471 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_vf_affiliation12: "
2473 		       instance->host->host_no);
2479 	if (!instance->vf_affiliation) {
2480 		dev_warn(&instance->pdev->dev, "SR-IOV: Couldn't get LD/VF "
2481 		       "affiliation for scsi%d\n", instance->host->host_no);
2482 		megasas_return_cmd(instance, cmd);
2487 		memset(instance->vf_affiliation, 0, (MAX_LOGICAL_DRIVES + 1) *
2491 			dma_alloc_coherent(&instance->pdev->dev,
2495 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
2497 			       instance->host->host_no);
2498 			megasas_return_cmd(instance, cmd);
2517 			cpu_to_le32(instance->vf_affiliation_h);
2525 	dev_warn(&instance->pdev->dev, "SR-IOV: Getting LD/VF affiliation for "
2526 	       "scsi%d\n", instance->host->host_no);
2529 	if (megasas_issue_blocked_cmd(instance, cmd, 0) != DCMD_SUCCESS) {
2530 		dev_warn(&instance->pdev->dev, "SR-IOV: LD/VF affiliation DCMD"
2532 		       dcmd->cmd_status, instance->host->host_no);
2539 			dev_warn(&instance->pdev->dev, "SR-IOV: Got new LD/VF "
2541 			       instance->host->host_no);
2546 		savedmap = instance->vf_affiliation->map;
2550 			for (j = 0; j < instance->vf_affiliation->ldCount;
2575 		savedmap = instance->vf_affiliation->map;
2577 		for (i = 0 ; i < instance->vf_affiliation->ldCount; i++) {
2605 		dev_warn(&instance->pdev->dev, "SR-IOV: Got new LD/VF "
2606 		       "affiliation for scsi%d\n", instance->host->host_no);
2607 		memcpy(instance->vf_affiliation, new_affiliation,
2613 		dma_free_coherent(&instance->pdev->dev,
2617 	megasas_return_cmd(instance, cmd);
2623 static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,
2628 	if (instance->PlasmaFW111)
2629 		retval = megasas_get_ld_vf_affiliation_111(instance, initial);
2631 		retval = megasas_get_ld_vf_affiliation_12(instance, initial);
2636 int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
2643 	cmd = megasas_get_cmd(instance);
2646 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_sriov_start_heartbeat: "
2648 		       instance->host->host_no);
2655 		instance->hb_host_mem =
2656 			dma_alloc_coherent(&instance->pdev->dev,
2658 					   &instance->hb_host_mem_h,
2660 		if (!instance->hb_host_mem) {
2661 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate"
2663 			       instance->host->host_no);
2681 	megasas_set_dma_settings(instance, dcmd, instance->hb_host_mem_h,
2684 	dev_warn(&instance->pdev->dev, "SR-IOV: Starting heartbeat for scsi%d\n",
2685 	       instance->host->host_no);
2687 	if ((instance->adapter_type != MFI_SERIES) &&
2688 	    !instance->mask_interrupts)
2689 		retval = megasas_issue_blocked_cmd(instance, cmd,
2692 		retval = megasas_issue_polled(instance, cmd);
2695 		dev_warn(&instance->pdev->dev, "SR-IOV: MR_DCMD_CTRL_SHARED_HOST"
2698 			"timed out" : "failed", instance->host->host_no);
2703 	megasas_return_cmd(instance, cmd);
2711 	struct megasas_instance *instance =
2712 		from_timer(instance, t, sriov_heartbeat_timer);
2714 	if (instance->hb_host_mem->HB.fwCounter !=
2715 	    instance->hb_host_mem->HB.driverCounter) {
2716 		instance->hb_host_mem->HB.driverCounter =
2717 			instance->hb_host_mem->HB.fwCounter;
2718 		mod_timer(&instance->sriov_heartbeat_timer,
2721 		dev_warn(&instance->pdev->dev, "SR-IOV: Heartbeat never "
2722 		       "completed for scsi%d\n", instance->host->host_no);
2723 		schedule_work(&instance->work_init);
2729  * @instance:				Adapter soft state
2735 static int megasas_wait_for_outstanding(struct megasas_instance *instance)
2745 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2746 		dev_info(&instance->pdev->dev, "%s:%d HBA is killed.\n",
2751 	if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
2754 		spin_lock_irqsave(&instance->hba_lock, flags);
2755 		list_splice_init(&instance->internal_reset_pending_q,
2757 		spin_unlock_irqrestore(&instance->hba_lock, flags);
2759 		dev_notice(&instance->pdev->dev, "HBA reset wait ...\n");
2762 			if (atomic_read(&instance->adprecovery) == MEGASAS_HBA_OPERATIONAL)
2766 		if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
2767 			dev_notice(&instance->pdev->dev, "reset: Stopping HBA.\n");
2768 			atomic_set(&instance->adprecovery, MEGASAS_HW_CRITICAL_ERROR);
2779 				dev_notice(&instance->pdev->dev, "%d:%p reset [%02x]\n",
2784 				megasas_return_cmd(instance, reset_cmd);
2786 				dev_notice(&instance->pdev->dev, "%p synch cmds"
2791 				instance->instancet->fire_cmd(instance,
2793 						0, instance->reg_set);
2795 				dev_notice(&instance->pdev->dev, "%p unexpected"
2806 		outstanding = atomic_read(&instance->fw_outstanding);
2812 			dev_notice(&instance->pdev->dev, "[%2d]waiting for %d "
2818 			megasas_complete_cmd_dpc((unsigned long)instance);
2825 	outstanding = atomic_read(&instance->fw_outstanding);
2826 	fw_state = instance->instancet->read_fw_status_reg(instance) & MFI_STATE_MASK;
2831 	if (instance->disableOnlineCtrlReset)
2834 		if ((fw_state == MFI_STATE_FAULT) || atomic_read(&instance->fw_outstanding)) {
2835 			dev_info(&instance->pdev->dev,
2837 				__func__, __LINE__, fw_state, atomic_read(&instance->fw_outstanding));
2840 			megasas_do_ocr(instance);
2842 			if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2843 				dev_info(&instance->pdev->dev, "%s:%d OCR failed and HBA is killed.\n",
2847 			dev_info(&instance->pdev->dev, "%s:%d waiting_for_outstanding: after issue OCR.\n",
2853 			outstanding = atomic_read(&instance->fw_outstanding);
2855 			fw_state = instance->instancet->read_fw_status_reg(instance) & MFI_STATE_MASK;
2864 	dev_info(&instance->pdev->dev, "%s:%d no more pending commands remain after reset handling.\n",
2871 	dev_info(&instance->pdev->dev, "%s:%d killing adapter scsi%d"
2873 		__func__, __LINE__, instance->host->host_no, instance->disableOnlineCtrlReset,
2874 		atomic_read(&instance->fw_outstanding));
2875 	megasas_dump_pending_frames(instance);
2876 	megaraid_sas_kill_hba(instance);
2892 	struct megasas_instance *instance;
2894 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
2899 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2900 		dev_err(&instance->pdev->dev, "cannot recover from previous reset failures\n");
2904 	ret_val = megasas_wait_for_outstanding(instance);
2906 		dev_notice(&instance->pdev->dev, "reset successful\n");
2908 		dev_err(&instance->pdev->dev, "failed to do reset\n");
2923 	struct megasas_instance *instance;
2931 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
2932 	if (!(instance->flag & MEGASAS_FW_BUSY)) {
2934 		spin_lock_irqsave(instance->host->host_lock, flags);
2936 		instance->host->can_queue = instance->throttlequeuedepth;
2937 		instance->last_time = jiffies;
2938 		instance->flag |= MEGASAS_FW_BUSY;
2940 		spin_unlock_irqrestore(instance->host->host_lock, flags);
2994 	struct megasas_instance *instance;
2997 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3018 			     instance->max_chain_frame_sz, 8);
3054 	struct megasas_instance *instance;
3056 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3065 		atomic_read(&instance->fw_outstanding));
3069 	if (instance->adapter_type == MFI_SERIES) {
3088 	struct megasas_instance *instance;
3090 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3092 	if (instance->adapter_type != MFI_SERIES)
3110 	struct megasas_instance *instance;
3112 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3114 	if (instance->adapter_type != MFI_SERIES)
3170 	struct megasas_instance *instance;
3172 	instance = (struct megasas_instance *)shost->hostdata;
3178 			instance->pdev, instance->low_latency_index_start);
3185  * @instance:			Adapter soft state
3196 megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
3203 	if ((!cmd->abort_aen) && (instance->unload == 0)) {
3213 	instance->aen_cmd = NULL;
3215 	megasas_return_cmd(instance, cmd);
3217 	if ((instance->unload == 0) &&
3218 		((instance->issuepend_done == 1))) {
3223 			dev_err(&instance->pdev->dev, "megasas_service_aen: out of memory\n");
3225 			ev->instance = instance;
3226 			instance->ev = ev;
3239 	struct megasas_instance *instance =
3246 	mutex_lock(&instance->crashdump_lock);
3247 	instance->fw_crash_buffer_offset = val;
3248 	mutex_unlock(&instance->crashdump_lock);
3257 	struct megasas_instance *instance =
3265 	mutex_lock(&instance->crashdump_lock);
3266 	buff_offset = instance->fw_crash_buffer_offset;
3267 	if (!instance->crash_dump_buf ||
3268 		!((instance->fw_crash_state == AVAILABLE) ||
3269 		(instance->fw_crash_state == COPYING))) {
3270 		dev_err(&instance->pdev->dev,
3272 		mutex_unlock(&instance->crashdump_lock);
3276 	if (buff_offset > (instance->fw_crash_buffer_size * dmachunk)) {
3277 		dev_err(&instance->pdev->dev,
3279 		mutex_unlock(&instance->crashdump_lock);
3283 	size = (instance->fw_crash_buffer_size * dmachunk) - buff_offset;
3288 	src_addr = (unsigned long)instance->crash_buf[buff_offset / dmachunk] +
3291 	mutex_unlock(&instance->crashdump_lock);
3301 	struct megasas_instance *instance =
3305 		((instance->fw_crash_buffer_size) * 1024 * 1024)/PAGE_SIZE);
3313 	struct megasas_instance *instance =
3321 		dev_err(&instance->pdev->dev, "application updates invalid "
3326 	instance->fw_crash_state = val;
3329 		mutex_lock(&instance->crashdump_lock);
3330 		megasas_free_host_crash_buffer(instance);
3331 		mutex_unlock(&instance->crashdump_lock);
3333 			dev_info(&instance->pdev->dev, "application failed to "
3336 			dev_info(&instance->pdev->dev, "Firmware crash dump "
3347 	struct megasas_instance *instance =
3350 	return snprintf(buf, PAGE_SIZE, "%d\n", instance->fw_crash_state);
3365 	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3367 	return snprintf(buf, PAGE_SIZE, "%d\n", atomic_read(&instance->ldio_outstanding));
3375 	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3377 	return snprintf(buf, PAGE_SIZE, "%d\n", atomic_read(&instance->fw_outstanding));
3385 	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3387 	return snprintf(buf, PAGE_SIZE, "%d\n", instance->enable_sdev_max_qd);
3395 	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3406 	mutex_lock(&instance->reset_mutex);
3408 		instance->enable_sdev_max_qd = true;
3410 		instance->enable_sdev_max_qd = false;
3413 		ret_target_prop = megasas_get_target_prop(instance, sdev);
3417 	mutex_unlock(&instance->reset_mutex);
3427 	struct megasas_instance *instance =
3430 	return megasas_dump_sys_regs(instance->reg_set, buf);
3438 	struct megasas_instance *instance =
3442 			(unsigned long)instance->map_id);
3493  * @instance:			Adapter soft state
3501 megasas_complete_int_cmd(struct megasas_instance *instance,
3509 	wake_up(&instance->int_cmd_wait_q);
3514  * @instance:			Adapter soft state
3522 megasas_complete_abort(struct megasas_instance *instance,
3528 		wake_up(&instance->abort_cmd_wait_q);
3533 megasas_set_ld_removed_by_fw(struct megasas_instance *instance)
3538 		if (instance->ld_ids_prev[i] != 0xff &&
3539 		    instance->ld_ids_from_raidmap[i] == 0xff) {
3541 				dev_info(&instance->pdev->dev,
3543 			instance->ld_tgtid_status[i] = LD_TARGET_ID_DELETED;
3550  * @instance:			Adapter soft state
3559 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
3565 	struct fusion_context *fusion = instance->ctrl_context;
3580 		dev_warn(&instance->pdev->dev, "MFI_CMD_INVALID command "
3582 		dev_warn(&instance->pdev->dev, "If you have a controller "
3595 			megasas_complete_int_cmd(instance, cmd);
3610 			atomic_dec(&instance->fw_outstanding);
3614 			megasas_return_cmd(instance, cmd);
3652 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "MFI FW status %#x\n",
3658 		atomic_dec(&instance->fw_outstanding);
3662 		megasas_return_cmd(instance, cmd);
3670 		megasas_complete_int_cmd(instance, cmd);
3679 			spin_lock_irqsave(instance->host->host_lock, flags);
3681 			instance->map_update_cmd = NULL;
3684 					dev_warn(&instance->pdev->dev, "map syncfailed, status = 0x%x\n",
3687 					megasas_return_cmd(instance, cmd);
3689 						instance->host->host_lock,
3695 			megasas_return_cmd(instance, cmd);
3703 			    (MR_ValidateMapInfo(instance, (instance->map_id + 1)))) {
3704 				instance->map_id++;
3710 			if (instance->adapter_type >= INVADER_SERIES)
3711 				megasas_set_ld_removed_by_fw(instance);
3713 			megasas_sync_map_info(instance);
3714 			spin_unlock_irqrestore(instance->host->host_lock,
3730 			spin_lock_irqsave(instance->host->host_lock, flags);
3732 			instance->jbod_seq_cmd = NULL;
3733 			megasas_return_cmd(instance, cmd);
3736 				instance->pd_seq_map_id++;
3738 				if (megasas_sync_pd_seq_num(instance, true))
3739 					instance->use_seqnum_jbod_fp = false;
3741 				instance->use_seqnum_jbod_fp = false;
3743 			spin_unlock_irqrestore(instance->host->host_lock, flags);
3751 			megasas_service_aen(instance, cmd);
3753 			megasas_complete_int_cmd(instance, cmd);
3761 		megasas_complete_abort(instance, cmd);
3765 		dev_info(&instance->pdev->dev, "Unknown command completed! [0x%X]\n",
3767 		megasas_complete_int_cmd(instance, cmd);
3775  * @instance:				Adapter soft state
3778 megasas_issue_pending_cmds_again(struct megasas_instance *instance)
3787 	spin_lock_irqsave(&instance->hba_lock, flags);
3788 	list_splice_init(&instance->internal_reset_pending_q, &clist_local);
3789 	spin_unlock_irqrestore(&instance->hba_lock, flags);
3797 			dev_notice(&instance->pdev->dev, "command %p, %p:%d"
3804 				dev_notice(&instance->pdev->dev, "cmd %p, %p:%d"
3808 				instance->instancet->disable_intr(instance);
3809 				atomic_set(&instance->fw_reset_no_pci_access, 1);
3810 				megaraid_sas_kill_hba(instance);
3817 				dev_notice(&instance->pdev->dev, "unexpected"
3820 			dev_notice(&instance->pdev->dev, "%p synchronous cmd"
3824 			instance->instancet->fire_cmd(instance,
3826 							0, instance->reg_set);
3828 			dev_notice(&instance->pdev->dev, "%p scsi cmd [%02x]"
3832 			atomic_inc(&instance->fw_outstanding);
3833 			instance->instancet->fire_cmd(instance,
3835 					cmd->frame_count-1, instance->reg_set);
3837 			dev_notice(&instance->pdev->dev, "%p unexpected cmd on the"
3843 	if (instance->aen_cmd) {
3844 		dev_notice(&instance->pdev->dev, "aen_cmd in def process\n");
3845 		megasas_return_cmd(instance, instance->aen_cmd);
3847 		instance->aen_cmd = NULL;
3853 	seq_num = instance->last_seq_num;
3858 	megasas_register_aen(instance, seq_num, class_locale.word);
3871 megasas_internal_reset_defer_cmds(struct megasas_instance *instance)
3875 	u16 max_cmd = instance->max_fw_cmds;
3880 	spin_lock_irqsave(&instance->mfi_pool_lock, flags);
3882 		cmd = instance->cmd_list[i];
3884 			dev_notice(&instance->pdev->dev, "moving cmd[%d]:%p:%d:%p"
3889 				dev_notice(&instance->pdev->dev, "ERROR while"
3898 				&instance->internal_reset_pending_q);
3901 	spin_unlock_irqrestore(&instance->mfi_pool_lock, flags);
3908 	struct megasas_instance *instance =
3913     if (atomic_read(&instance->adprecovery) != MEGASAS_ADPRESET_SM_INFAULT) {
3914 		dev_notice(&instance->pdev->dev, "error, recovery st %x\n",
3915 				atomic_read(&instance->adprecovery));
3919 	if (atomic_read(&instance->adprecovery) == MEGASAS_ADPRESET_SM_INFAULT) {
3920 		dev_notice(&instance->pdev->dev, "FW detected to be in fault"
3923 		instance->instancet->disable_intr(instance);
3924 		atomic_set(&instance->fw_outstanding, 0);
3926 		atomic_set(&instance->fw_reset_no_pci_access, 1);
3927 		instance->instancet->adp_reset(instance, instance->reg_set);
3928 		atomic_set(&instance->fw_reset_no_pci_access, 0);
3930 		dev_notice(&instance->pdev->dev, "FW restarted successfully,"
3933 		dev_notice(&instance->pdev->dev, "HBA recovery state machine,"
3941 		if (megasas_transition_to_ready(instance, 1)) {
3942 			dev_notice(&instance->pdev->dev, "adapter not ready\n");
3944 			atomic_set(&instance->fw_reset_no_pci_access, 1);
3945 			megaraid_sas_kill_hba(instance);
3949 		if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
3950 			(instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
3951 			(instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)
3953 			*instance->consumer = *instance->producer;
3955 			*instance->consumer = 0;
3956 			*instance->producer = 0;
3959 		megasas_issue_init_mfi(instance);
3961 		spin_lock_irqsave(&instance->hba_lock, flags);
3962 		atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
3963 		spin_unlock_irqrestore(&instance->hba_lock, flags);
3964 		instance->instancet->enable_intr(instance);
3966 		megasas_issue_pending_cmds_again(instance);
3967 		instance->issuepend_done = 1;
3973  * @instance:				Adapter soft state
3980 megasas_deplete_reply_queue(struct megasas_instance *instance,
3986 	if ((mfiStatus = instance->instancet->check_reset(instance,
3987 					instance->reg_set)) == 1) {
3991 	mfiStatus = instance->instancet->clear_intr(instance);
3994 		if (!instance->msix_vectors)
3998 	instance->mfiStatus = mfiStatus;
4001 		fw_state = instance->instancet->read_fw_status_reg(
4002 				instance) & MFI_STATE_MASK;
4005 			dev_notice(&instance->pdev->dev, "fw state:%x\n",
4010 				(instance->disableOnlineCtrlReset == 0)) {
4011 			dev_notice(&instance->pdev->dev, "wait adp restart\n");
4013 			if ((instance->pdev->device ==
4015 				(instance->pdev->device ==
4017 				(instance->pdev->device ==
4020 				*instance->consumer =
4025 			instance->instancet->disable_intr(instance);
4026 			atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
4027 			instance->issuepend_done = 0;
4029 			atomic_set(&instance->fw_outstanding, 0);
4030 			megasas_internal_reset_defer_cmds(instance);
4032 			dev_notice(&instance->pdev->dev, "fwState=%x, stage:%d\n",
4033 					fw_state, atomic_read(&instance->adprecovery));
4035 			schedule_work(&instance->work_init);
4039 			dev_notice(&instance->pdev->dev, "fwstate:%x, dis_OCR=%x\n",
4040 				fw_state, instance->disableOnlineCtrlReset);
4044 	tasklet_schedule(&instance->isr_tasklet);
4056 	struct megasas_instance *instance = irq_context->instance;
4060 	if (atomic_read(&instance->fw_reset_no_pci_access))
4063 	spin_lock_irqsave(&instance->hba_lock, flags);
4064 	rc = megasas_deplete_reply_queue(instance, DID_OK);
4065 	spin_unlock_irqrestore(&instance->hba_lock, flags);
4072  * @instance:				Adapter soft state
4081 megasas_transition_to_ready(struct megasas_instance *instance, int ocr)
4088 	abs_state = instance->instancet->read_fw_status_reg(instance);
4092 		dev_info(&instance->pdev->dev, "Waiting for FW to come to ready"
4100 			dev_printk(KERN_ERR, &instance->pdev->dev,
4108 				dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4109 				megasas_dump_reg_set(instance->reg_set);
4117 			if ((instance->pdev->device ==
4119 				(instance->pdev->device ==
4121 				(instance->adapter_type != MFI_SERIES))
4124 				  &instance->reg_set->doorbell);
4128 					&instance->reg_set->inbound_doorbell);
4134 			if ((instance->pdev->device ==
4136 				(instance->pdev->device ==
4138 				(instance->adapter_type != MFI_SERIES))
4140 				       &instance->reg_set->doorbell);
4143 					&instance->reg_set->inbound_doorbell);
4152 			instance->instancet->disable_intr(instance);
4153 			if ((instance->pdev->device ==
4155 				(instance->pdev->device ==
4157 				(instance->adapter_type != MFI_SERIES)) {
4159 					&instance->reg_set->doorbell);
4161 				if (instance->adapter_type != MFI_SERIES) {
4164 							    instance,
4165 							    &instance->
4175 					&instance->reg_set->inbound_doorbell);
4208 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "Unknown state 0x%x\n",
4210 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4211 			megasas_dump_reg_set(instance->reg_set);
4219 			curr_abs_state = instance->instancet->
4220 				read_fw_status_reg(instance);
4232 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "FW state [%d] hasn't changed "
4234 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4235 			megasas_dump_reg_set(instance->reg_set);
4242 	dev_info(&instance->pdev->dev, "FW now in Ready state\n");
4249  * @instance:				Adapter soft state
4251 static void megasas_teardown_frame_pool(struct megasas_instance *instance)
4254 	u16 max_cmd = instance->max_mfi_cmds;
4257 	if (!instance->frame_dma_pool)
4265 		cmd = instance->cmd_list[i];
4268 			dma_pool_free(instance->frame_dma_pool, cmd->frame,
4272 			dma_pool_free(instance->sense_dma_pool, cmd->sense,
4279 	dma_pool_destroy(instance->frame_dma_pool);
4280 	dma_pool_destroy(instance->sense_dma_pool);
4282 	instance->frame_dma_pool = NULL;
4283 	instance->sense_dma_pool = NULL;
4288  * @instance:			Adapter soft state
4295 static int megasas_create_frame_pool(struct megasas_instance *instance)
4302 	max_cmd = instance->max_mfi_cmds;
4315 	frame_count = (instance->adapter_type == MFI_SERIES) ?
4317 	instance->mfi_frame_size = MEGAMFI_FRAME_SIZE * frame_count;
4321 	instance->frame_dma_pool = dma_pool_create("megasas frame pool",
4322 					&instance->pdev->dev,
4323 					instance->mfi_frame_size, 256, 0);
4325 	if (!instance->frame_dma_pool) {
4326 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup frame pool\n");
4330 	instance->sense_dma_pool = dma_pool_create("megasas sense pool",
4331 						   &instance->pdev->dev, 128,
4334 	if (!instance->sense_dma_pool) {
4335 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup sense pool\n");
4337 		dma_pool_destroy(instance->frame_dma_pool);
4338 		instance->frame_dma_pool = NULL;
4350 		cmd = instance->cmd_list[i];
4352 		cmd->frame = dma_pool_zalloc(instance->frame_dma_pool,
4355 		cmd->sense = dma_pool_alloc(instance->sense_dma_pool,
4363 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "dma_pool_alloc failed\n");
4364 			megasas_teardown_frame_pool(instance);
4370 		if ((instance->adapter_type == MFI_SERIES) && reset_devices)
4379  * @instance:		Adapter soft state
4381 void megasas_free_cmds(struct megasas_instance *instance)
4386 	megasas_teardown_frame_pool(instance);
4389 	for (i = 0; i < instance->max_mfi_cmds; i++)
4391 		kfree(instance->cmd_list[i]);
4394 	kfree(instance->cmd_list);
4395 	instance->cmd_list = NULL;
4397 	INIT_LIST_HEAD(&instance->cmd_pool);
4402  * @instance:		Adapter soft state
4418 int megasas_alloc_cmds(struct megasas_instance *instance)
4425 	max_cmd = instance->max_mfi_cmds;
4428 	 * instance->cmd_list is an array of struct megasas_cmd pointers.
4432 	instance->cmd_list = kcalloc(max_cmd, sizeof(struct megasas_cmd*), GFP_KERNEL);
4434 	if (!instance->cmd_list) {
4435 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "out of memory\n");
4439 	memset(instance->cmd_list, 0, sizeof(struct megasas_cmd *) *max_cmd);
4442 		instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd),
4445 		if (!instance->cmd_list[i]) {
4448 				kfree(instance->cmd_list[j]);
4450 			kfree(instance->cmd_list);
4451 			instance->cmd_list = NULL;
4458 		cmd = instance->cmd_list[i];
4462 		cmd->instance = instance;
4464 		list_add_tail(&cmd->list, &instance->cmd_pool);
4470 	if (megasas_create_frame_pool(instance)) {
4471 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Error creating frame DMA pool\n");
4472 		megasas_free_cmds(instance);
4481  * @instance:				Adapter soft state
4487 dcmd_timeout_ocr_possible(struct megasas_instance *instance) {
4489 	if (instance->adapter_type == MFI_SERIES)
4491 	else if (instance->unload ||
4493 				 &instance->reset_flags))
4500 megasas_get_pd_info(struct megasas_instance *instance, struct scsi_device *sdev)
4510 	cmd = megasas_get_cmd(instance);
4513 		dev_err(&instance->pdev->dev, "Failed to get cmd %s\n", __func__);
4519 	memset(instance->pd_info, 0, sizeof(*instance->pd_info));
4532 	megasas_set_dma_settings(instance, dcmd, instance->pd_info_h,
4535 	if ((instance->adapter_type != MFI_SERIES) &&
4536 	    !instance->mask_interrupts)
4537 		ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
4539 		ret = megasas_issue_polled(instance, cmd);
4544 		le16_to_cpus((u16 *)&instance->pd_info->state.ddf.pdType);
4546 				instance->pd_info->state.ddf.pdType.intf;
4551 		switch (dcmd_timeout_ocr_possible(instance)) {
4554 			mutex_unlock(&instance->reset_mutex);
4555 			megasas_reset_fusion(instance->host,
4557 			mutex_lock(&instance->reset_mutex);
4560 			megaraid_sas_kill_hba(instance);
4563 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4572 		megasas_return_cmd(instance, cmd);
4578  * @instance:				Adapter soft state
4586 megasas_get_pd_list(struct megasas_instance *instance)
4594 	if (instance->pd_list_not_supported) {
4595 		dev_info(&instance->pdev->dev, "MR_DCMD_PD_LIST_QUERY "
4600 	ci = instance->pd_list_buf;
4602 	cmd = megasas_get_cmd(instance);
4605 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "(get_pd_list): Failed to get cmd\n");
4625 	megasas_set_dma_settings(instance, dcmd, instance->pd_list_buf_h,
4628 	if ((instance->adapter_type != MFI_SERIES) &&
4629 	    !instance->mask_interrupts)
4630 		ret = megasas_issue_blocked_cmd(instance, cmd,
4633 		ret = megasas_issue_polled(instance, cmd);
4637 		dev_info(&instance->pdev->dev, "MR_DCMD_PD_LIST_QUERY "
4640 		if (instance->adapter_type != MFI_SERIES)
4641 			megaraid_sas_kill_hba(instance);
4643 			instance->pd_list_not_supported = 1;
4647 		switch (dcmd_timeout_ocr_possible(instance)) {
4655 			mutex_unlock(&instance->reset_mutex);
4656 			megasas_reset_fusion(instance->host,
4658 			mutex_lock(&instance->reset_mutex);
4661 			megaraid_sas_kill_hba(instance);
4664 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d \n",
4674 			dev_info(&instance->pdev->dev, "%s, sysPD count: 0x%x\n",
4681 		memset(instance->local_pd_list, 0,
4685 			instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].tid	=
4687 			instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveType	=
4689 			instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveState	=
4692 				dev_info(&instance->pdev->dev,
4699 		memcpy(instance->pd_list, instance->local_pd_list,
4700 			sizeof(instance->pd_list));
4706 		megasas_return_cmd(instance, cmd);
4713  * @instance:				Adapter soft state
4721 megasas_get_ld_list(struct megasas_instance *instance)
4730 	ci = instance->ld_list_buf;
4731 	ci_h = instance->ld_list_buf_h;
4733 	cmd = megasas_get_cmd(instance);
4736 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_list: Failed to get cmd\n");
4745 	if (instance->supportmax256vd)
4756 	megasas_set_dma_settings(instance, dcmd, ci_h,
4759 	if ((instance->adapter_type != MFI_SERIES) &&
4760 	    !instance->mask_interrupts)
4761 		ret = megasas_issue_blocked_cmd(instance, cmd,
4764 		ret = megasas_issue_polled(instance, cmd);
4770 		megaraid_sas_kill_hba(instance);
4774 		switch (dcmd_timeout_ocr_possible(instance)) {
4782 			mutex_unlock(&instance->reset_mutex);
4783 			megasas_reset_fusion(instance->host,
4785 			mutex_lock(&instance->reset_mutex);
4788 			megaraid_sas_kill_hba(instance);
4791 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4800 			dev_info(&instance->pdev->dev, "%s, LD count: 0x%x\n",
4803 		if (ld_count > instance->fw_supported_vd_count)
4806 		memset(instance->ld_ids, 0xff, MAX_LOGICAL_DRIVES_EXT);
4811 				instance->ld_ids[ids] = ci->ldList[ld_index].ref.targetId;
4813 					dev_info(&instance->pdev->dev,
4823 		megasas_return_cmd(instance, cmd);
4830  * @instance:				Adapter soft state
4838 megasas_ld_list_query(struct megasas_instance *instance, u8 query_type)
4847 	ci = instance->ld_targetid_list_buf;
4848 	ci_h = instance->ld_targetid_list_buf_h;
4850 	cmd = megasas_get_cmd(instance);
4853 		dev_warn(&instance->pdev->dev,
4864 	if (instance->supportmax256vd)
4876 	megasas_set_dma_settings(instance, dcmd, ci_h,
4879 	if ((instance->adapter_type != MFI_SERIES) &&
4880 	    !instance->mask_interrupts)
4881 		ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
4883 		ret = megasas_issue_polled(instance, cmd);
4887 		dev_info(&instance->pdev->dev,
4890 		ret = megasas_get_ld_list(instance);
4893 		switch (dcmd_timeout_ocr_possible(instance)) {
4901 			mutex_unlock(&instance->reset_mutex);
4902 			megasas_reset_fusion(instance->host,
4904 			mutex_lock(&instance->reset_mutex);
4907 			megaraid_sas_kill_hba(instance);
4910 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4920 			dev_info(&instance->pdev->dev, "%s, LD count: 0x%x\n",
4923 		if ((tgtid_count > (instance->fw_supported_vd_count)))
4926 		memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
4929 			instance->ld_ids[ids] = ci->targetId[ld_index];
4931 				dev_info(&instance->pdev->dev, "LD%d: targetID: 0x%03x\n",
4939 		megasas_return_cmd(instance, cmd);
4952  * @instance:			Adapter soft state
4958 megasas_host_device_list_query(struct megasas_instance *instance,
4968 	ci = instance->host_device_list_buf;
4969 	ci_h = instance->host_device_list_buf_h;
4971 	cmd = megasas_get_cmd(instance);
4974 		dev_warn(&instance->pdev->dev,
4995 	megasas_set_dma_settings(instance, dcmd, ci_h, HOST_DEVICE_LIST_SZ);
4997 	if (!instance->mask_interrupts) {
4998 		ret = megasas_issue_blocked_cmd(instance, cmd,
5001 		ret = megasas_issue_polled(instance, cmd);
5016 			dev_info(&instance->pdev->dev, "%s, Device count: 0x%x\n",
5019 		memset(instance->local_pd_list, 0,
5021 		memset(instance->ld_ids, 0xff, MAX_LOGICAL_DRIVES_EXT);
5025 				instance->local_pd_list[target_id].tid = target_id;
5026 				instance->local_pd_list[target_id].driveType =
5028 				instance->local_pd_list[target_id].driveState =
5031 					dev_info(&instance->pdev->dev,
5035 				instance->ld_ids[target_id] = target_id;
5037 					dev_info(&instance->pdev->dev,
5043 		memcpy(instance->pd_list, instance->local_pd_list,
5044 		       sizeof(instance->pd_list));
5048 		switch (dcmd_timeout_ocr_possible(instance)) {
5051 			mutex_unlock(&instance->reset_mutex);
5052 			megasas_reset_fusion(instance->host,
5054 			mutex_lock(&instance->reset_mutex);
5057 			megaraid_sas_kill_hba(instance);
5060 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5066 		dev_err(&instance->pdev->dev,
5073 		megasas_return_cmd(instance, cmd);
5080  * instance			 : Controller's instance
5082 static void megasas_update_ext_vd_details(struct megasas_instance *instance)
5087 	fusion = instance->ctrl_context;
5092 	instance->supportmax256vd =
5093 		instance->ctrl_info_buf->adapterOperations3.supportMaxExtLDs;
5095 	if (instance->ctrl_info_buf->max_lds > 64)
5096 		instance->supportmax256vd = 1;
5098 	instance->drv_supported_vd_count = MEGASAS_MAX_LD_CHANNELS
5100 	instance->drv_supported_pd_count = MEGASAS_MAX_PD_CHANNELS
5102 	if (instance->supportmax256vd) {
5103 		instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES_EXT;
5104 		instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
5106 		instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
5107 		instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
5110 	dev_info(&instance->pdev->dev,
5112 		instance->ctrl_info_buf->adapterOperations3.supportMaxExtLDs ? 1 : 0,
5113 		instance->ctrl_info_buf->max_lds);
5115 	if (instance->max_raid_mapsize) {
5116 		ventura_map_sz = instance->max_raid_mapsize *
5123 					(instance->fw_supported_vd_count - 1));
5129 		if (instance->supportmax256vd)
5145 void megasas_get_snapdump_properties(struct megasas_instance *instance)
5153 	ci = instance->snapdump_prop;
5154 	ci_h = instance->snapdump_prop_h;
5159 	cmd = megasas_get_cmd(instance);
5162 		dev_dbg(&instance->pdev->dev, "Failed to get a free cmd\n");
5180 	megasas_set_dma_settings(instance, dcmd, ci_h,
5183 	if (!instance->mask_interrupts) {
5184 		ret = megasas_issue_blocked_cmd(instance, cmd,
5187 		ret = megasas_issue_polled(instance, cmd);
5193 		instance->snapdump_wait_time =
5199 		switch (dcmd_timeout_ocr_possible(instance)) {
5202 			mutex_unlock(&instance->reset_mutex);
5203 			megasas_reset_fusion(instance->host,
5205 			mutex_lock(&instance->reset_mutex);
5208 			megaraid_sas_kill_hba(instance);
5211 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5218 		megasas_return_cmd(instance, cmd);
5223  * @instance:				Adapter soft state
5230 megasas_get_ctrl_info(struct megasas_instance *instance)
5238 	ci = instance->ctrl_info_buf;
5239 	ci_h = instance->ctrl_info_buf_h;
5241 	cmd = megasas_get_cmd(instance);
5244 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get a free cmd\n");
5263 	megasas_set_dma_settings(instance, dcmd, ci_h,
5266 	if ((instance->adapter_type != MFI_SERIES) &&
5267 	    !instance->mask_interrupts) {
5268 		ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
5270 		ret = megasas_issue_polled(instance, cmd);
5291 		megasas_update_ext_vd_details(instance);
5292 		instance->support_seqnum_jbod_fp =
5294 		instance->support_morethan256jbod =
5296 		instance->support_nvme_passthru =
5298 		instance->support_pci_lane_margining =
5300 		instance->task_abort_tmo = ci->TaskAbortTO;
5301 		instance->max_reset_tmo = ci->MaxResetTO;
5304 		instance->is_imr = (ci->memory_size ? 0 : 1);
5306 		instance->snapdump_wait_time =
5310 		instance->enable_fw_dev_list =
5313 		dev_info(&instance->pdev->dev,
5315 			instance->is_imr ? "iMR" : "MR",
5318 		instance->disableOnlineCtrlReset =
5320 		instance->secure_jbod_support =
5322 		dev_info(&instance->pdev->dev, "Online Controller Reset(OCR)\t: %s\n",
5323 			instance->disableOnlineCtrlReset ? "Disabled" : "Enabled");
5324 		dev_info(&instance->pdev->dev, "Secure JBOD support\t: %s\n",
5325 			instance->secure_jbod_support ? "Yes" : "No");
5326 		dev_info(&instance->pdev->dev, "NVMe passthru support\t: %s\n",
5327 			 instance->support_nvme_passthru ? "Yes" : "No");
5328 		dev_info(&instance->pdev->dev,
5330 			 instance->task_abort_tmo, instance->max_reset_tmo);
5331 		dev_info(&instance->pdev->dev, "JBOD sequence map support\t: %s\n",
5332 			 instance->support_seqnum_jbod_fp ? "Yes" : "No");
5333 		dev_info(&instance->pdev->dev, "PCI Lane Margining support\t: %s\n",
5334 			 instance->support_pci_lane_margining ? "Yes" : "No");
5339 		switch (dcmd_timeout_ocr_possible(instance)) {
5342 			mutex_unlock(&instance->reset_mutex);
5343 			megasas_reset_fusion(instance->host,
5345 			mutex_lock(&instance->reset_mutex);
5348 			megaraid_sas_kill_hba(instance);
5351 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5357 		megaraid_sas_kill_hba(instance);
5363 		megasas_return_cmd(instance, cmd);
5372  * @instance:				Adapter soft state
5383 int megasas_set_crash_dump_params(struct megasas_instance *instance,
5390 	cmd = megasas_get_cmd(instance);
5393 		dev_err(&instance->pdev->dev, "Failed to get a free cmd\n");
5411 	megasas_set_dma_settings(instance, dcmd, instance->crash_dump_h,
5414 	if ((instance->adapter_type != MFI_SERIES) &&
5415 	    !instance->mask_interrupts)
5416 		ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
5418 		ret = megasas_issue_polled(instance, cmd);
5421 		switch (dcmd_timeout_ocr_possible(instance)) {
5424 			megasas_reset_fusion(instance->host,
5428 			megaraid_sas_kill_hba(instance);
5431 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5436 		megasas_return_cmd(instance, cmd);
5443  * @instance:		Adapter soft state
5448 megasas_issue_init_mfi(struct megasas_instance *instance)
5465 	cmd = megasas_get_cmd(instance);
5479 	initq_info->reply_queue_entries = cpu_to_le32(instance->max_fw_cmds + 1);
5480 	initq_info->reply_queue_start_phys_addr_lo = cpu_to_le32(instance->reply_queue_h);
5482 	initq_info->producer_index_phys_addr_lo = cpu_to_le32(instance->producer_h);
5483 	initq_info->consumer_index_phys_addr_lo = cpu_to_le32(instance->consumer_h);
5497 	instance->instancet->disable_intr(instance);
5503 	if (megasas_issue_polled(instance, cmd)) {
5504 		dev_err(&instance->pdev->dev, "Failed to init firmware\n");
5505 		megasas_return_cmd(instance, cmd);
5509 	megasas_return_cmd(instance, cmd);
5518 megasas_init_adapter_mfi(struct megasas_instance *instance)
5526 	instance->max_fw_cmds = instance->instancet->read_fw_status_reg(instance) & 0x00FFFF;
5532 	instance->max_fw_cmds = instance->max_fw_cmds-1;
5533 	instance->max_mfi_cmds = instance->max_fw_cmds;
5534 	instance->max_num_sge = (instance->instancet->read_fw_status_reg(instance) & 0xFF0000) >>
5540 	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
5541 		(instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
5542 		instance->max_scsi_cmds = (instance->max_fw_cmds -
5544 		sema_init(&instance->ioctl_sem, MEGASAS_SKINNY_INT_CMDS);
5546 		instance->max_scsi_cmds = (instance->max_fw_cmds -
5548 		sema_init(&instance->ioctl_sem, (MEGASAS_MFI_IOCTL_CMDS));
5551 	instance->cur_can_queue = instance->max_scsi_cmds;
5555 	if (megasas_alloc_cmds(instance))
5568 	reply_q_sz = context_sz * (instance->max_fw_cmds + 1);
5570 	instance->reply_queue = dma_alloc_coherent(&instance->pdev->dev,
5571 			reply_q_sz, &instance->reply_queue_h, GFP_KERNEL);
5573 	if (!instance->reply_queue) {
5574 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Out of DMA mem for reply queue\n");
5578 	if (megasas_issue_init_mfi(instance))
5581 	if (megasas_get_ctrl_info(instance)) {
5582 		dev_err(&instance->pdev->dev, "(%d): Could get controller info "
5583 			"Fail from %s %d\n", instance->unique_id,
5588 	instance->fw_support_ieee = 0;
5589 	instance->fw_support_ieee =
5590 		(instance->instancet->read_fw_status_reg(instance) &
5593 	dev_notice(&instance->pdev->dev, "megasas_init_mfi: fw_support_ieee=%d",
5594 			instance->fw_support_ieee);
5596 	if (instance->fw_support_ieee)
5597 		instance->flag_ieee = 1;
5603 	dma_free_coherent(&instance->pdev->dev, reply_q_sz,
5604 			    instance->reply_queue, instance->reply_queue_h);
5606 	megasas_free_cmds(instance);
5613 void megasas_setup_irq_poll(struct megasas_instance *instance)
5618 	count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
5622 		irq_ctx = &instance->irq_context[i];
5623 		irq_ctx->os_irq = pci_irq_vector(instance->pdev, i);
5626 			      instance->threshold_reply_count,
5633  * @instance:				Adapter soft state
5640 megasas_setup_irqs_ioapic(struct megasas_instance *instance)
5644 	pdev = instance->pdev;
5645 	instance->irq_context[0].instance = instance;
5646 	instance->irq_context[0].MSIxIndex = 0;
5647 	snprintf(instance->irq_context->name, MEGASAS_MSIX_NAME_LEN, "%s%u",
5648 		"megasas", instance->host->host_no);
5650 			instance->instancet->service_isr, IRQF_SHARED,
5651 			instance->irq_context->name, &instance->irq_context[0])) {
5652 		dev_err(&instance->pdev->dev,
5657 	instance->perf_mode = MR_LATENCY_PERF_MODE;
5658 	instance->low_latency_index_start = 0;
5664  * @instance:				Adapter soft state
5672 megasas_setup_irqs_msix(struct megasas_instance *instance, u8 is_probe)
5677 	pdev = instance->pdev;
5680 	for (i = 0; i < instance->msix_vectors; i++) {
5681 		instance->irq_context[i].instance = instance;
5682 		instance->irq_context[i].MSIxIndex = i;
5683 		snprintf(instance->irq_context[i].name, MEGASAS_MSIX_NAME_LEN, "%s%u-msix%u",
5684 			"megasas", instance->host->host_no, i);
5686 			instance->instancet->service_isr, 0, instance->irq_context[i].name,
5687 			&instance->irq_context[i])) {
5688 			dev_err(&instance->pdev->dev,
5691 				if (j < instance->low_latency_index_start)
5695 					 &instance->irq_context[j]);
5698 			instance->msix_vectors = 0;
5699 			instance->msix_load_balance = false;
5701 				pci_free_irq_vectors(instance->pdev);
5702 				return megasas_setup_irqs_ioapic(instance);
5714  * @instance:				Adapter soft state
5718 megasas_destroy_irqs(struct megasas_instance *instance) {
5724 	count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
5725 	if (instance->adapter_type != MFI_SERIES) {
5727 			irq_ctx = &instance->irq_context[i];
5732 	if (instance->msix_vectors)
5733 		for (i = 0; i < instance->msix_vectors; i++) {
5734 			if (i < instance->low_latency_index_start)
5736 				    pci_irq_vector(instance->pdev, i), NULL);
5737 			free_irq(pci_irq_vector(instance->pdev, i),
5738 				 &instance->irq_context[i]);
5741 		free_irq(pci_irq_vector(instance->pdev, 0),
5742 			 &instance->irq_context[0]);
5747  * @instance:				Adapter soft state
5752 megasas_setup_jbod_map(struct megasas_instance *instance)
5755 	struct fusion_context *fusion = instance->ctrl_context;
5761 	instance->use_seqnum_jbod_fp =
5762 		instance->support_seqnum_jbod_fp;
5764 		!instance->support_seqnum_jbod_fp) {
5765 		dev_info(&instance->pdev->dev,
5768 		instance->use_seqnum_jbod_fp = false;
5777 			(&instance->pdev->dev, pd_seq_map_sz,
5780 			dev_err(&instance->pdev->dev,
5784 				dma_free_coherent(&instance->pdev->dev,
5789 			instance->use_seqnum_jbod_fp = false;
5795 	if (!megasas_sync_pd_seq_num(instance, false) &&
5796 		!megasas_sync_pd_seq_num(instance, true))
5797 		instance->use_seqnum_jbod_fp = true;
5799 		instance->use_seqnum_jbod_fp = false;
5802 static void megasas_setup_reply_map(struct megasas_instance *instance)
5807 	low_latency_index_start = instance->low_latency_index_start;
5809 	for (queue = low_latency_index_start; queue < instance->msix_vectors; queue++) {
5810 		mask = pci_irq_get_affinity(instance->pdev, queue);
5815 			instance->reply_map[cpu] = queue;
5822 		instance->reply_map[cpu] = queue;
5823 		if (queue == (instance->msix_vectors - 1))
5832  * @instance:			Adapter soft state
5840 int megasas_get_device_list(struct megasas_instance *instance)
5842 	memset(instance->pd_list, 0,
5844 	memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
5846 	if (instance->enable_fw_dev_list) {
5847 		if (megasas_host_device_list_query(instance, true))
5850 		if (megasas_get_pd_list(instance) < 0) {
5851 			dev_err(&instance->pdev->dev, "failed to get PD list\n");
5855 		if (megasas_ld_list_query(instance,
5857 			dev_err(&instance->pdev->dev, "failed to get LD list\n");
5867  * @instance:					Adapter soft state
5871 megasas_set_high_iops_queue_affinity_hint(struct megasas_instance *instance)
5876 	if (instance->perf_mode == MR_BALANCED_PERF_MODE) {
5877 		local_numa_node = dev_to_node(&instance->pdev->dev);
5879 		for (i = 0; i < instance->low_latency_index_start; i++)
5880 			irq_set_affinity_hint(pci_irq_vector(instance->pdev, i),
5886 __megasas_alloc_irq_vectors(struct megasas_instance *instance)
5889 	struct irq_affinity desc = { .pre_vectors = instance->low_latency_index_start };
5894 	if (instance->smp_affinity_enable)
5899 	i = pci_alloc_irq_vectors_affinity(instance->pdev,
5900 		instance->low_latency_index_start,
5901 		instance->msix_vectors, irq_flags, descp);
5908  * @instance:			Adapter soft state
5912 megasas_alloc_irq_vectors(struct megasas_instance *instance)
5917 	i = __megasas_alloc_irq_vectors(instance);
5919 	if ((instance->perf_mode == MR_BALANCED_PERF_MODE) &&
5920 	    (i != instance->msix_vectors)) {
5921 		if (instance->msix_vectors)
5922 			pci_free_irq_vectors(instance->pdev);
5924 		instance->perf_mode = MR_LATENCY_PERF_MODE;
5925 		instance->low_latency_index_start = 1;
5926 		num_msix_req = num_online_cpus() + instance->low_latency_index_start;
5928 		instance->msix_vectors = min(num_msix_req,
5929 				instance->msix_vectors);
5931 		i = __megasas_alloc_irq_vectors(instance);
5935 	dev_info(&instance->pdev->dev,
5936 		"requested/available msix %d/%d\n", instance->msix_vectors, i);
5939 		instance->msix_vectors = i;
5941 		instance->msix_vectors = 0;
5943 	if (instance->smp_affinity_enable)
5944 		megasas_set_high_iops_queue_affinity_hint(instance);
5949  * @instance:		Adapter soft state
5954 static int megasas_init_fw(struct megasas_instance *instance)
5970 	fusion = instance->ctrl_context;
5973 	bar_list = pci_select_bars(instance->pdev, IORESOURCE_MEM);
5974 	instance->bar = find_first_bit(&bar_list, BITS_PER_LONG);
5975 	if (pci_request_selected_regions(instance->pdev, 1<<instance->bar,
5977 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "IO memory region busy!\n");
5981 	base_addr = pci_resource_start(instance->pdev, instance->bar);
5982 	instance->reg_set = ioremap(base_addr, 8192);
5984 	if (!instance->reg_set) {
5985 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to map IO mem\n");
5990 	dev_printk(KERN_DEBUG, &instance->pdev->dev,
5992 		   instance->bar, base_addr_phys, instance->reg_set);
5994 	if (instance->adapter_type != MFI_SERIES)
5995 		instance->instancet = &megasas_instance_template_fusion;
5997 		switch (instance->pdev->device) {
6000 			instance->instancet = &megasas_instance_template_ppc;
6004 			instance->instancet = &megasas_instance_template_gen2;
6008 			instance->instancet = &megasas_instance_template_skinny;
6013 			instance->instancet = &megasas_instance_template_xscale;
6014 			instance->pd_list_not_supported = 1;
6019 	if (megasas_transition_to_ready(instance, 0)) {
6020 		dev_info(&instance->pdev->dev,
6023 		if (instance->adapter_type != MFI_SERIES) {
6024 			status_reg = instance->instancet->read_fw_status_reg(
6025 					instance);
6028 					(instance, true, 0) == FAILED)
6034 			atomic_set(&instance->fw_reset_no_pci_access, 1);
6035 			instance->instancet->adp_reset
6036 				(instance, instance->reg_set);
6037 			atomic_set(&instance->fw_reset_no_pci_access, 0);
6042 			if (megasas_transition_to_ready(instance, 0))
6046 		dev_info(&instance->pdev->dev,
6051 	megasas_init_ctrl_params(instance);
6053 	if (megasas_set_dma_mask(instance))
6056 	if (megasas_alloc_ctrl_mem(instance))
6059 	if (megasas_alloc_ctrl_dma_buffers(instance))
6062 	fusion = instance->ctrl_context;
6064 	if (instance->adapter_type >= VENTURA_SERIES) {
6066 			megasas_readl(instance,
6067 				      &instance->reg_set->outbound_scratch_pad_2);
6068 		instance->max_raid_mapsize = ((scratch_pad_2 >>
6073 	instance->enable_sdev_max_qd = enable_sdev_max_qd;
6075 	switch (instance->adapter_type) {
6087 	msix_enable = (instance->instancet->read_fw_status_reg(instance) &
6092 			(instance, &instance->reg_set->outbound_scratch_pad_1);
6095 			if (instance->adapter_type == THUNDERBOLT_SERIES) {
6097 				instance->msix_vectors = (scratch_pad_1
6100 				instance->msix_vectors = ((scratch_pad_1
6112 				switch (instance->adapter_type) {
6114 					if (instance->msix_vectors > 8)
6115 						instance->msix_combined = true;
6119 					if (instance->msix_vectors > 16)
6120 						instance->msix_combined = true;
6125 					instance->is_rdpq = (scratch_pad_1 & MR_RDPQ_MODE_OFFSET) ?
6128 				if (instance->adapter_type >= INVADER_SERIES &&
6129 				    !instance->msix_combined) {
6130 					instance->msix_load_balance = true;
6131 					instance->smp_affinity_enable = false;
6139 					instance->reply_post_host_index_addr[loop] =
6141 						((u8 __iomem *)instance->reg_set +
6147 			dev_info(&instance->pdev->dev,
6149 				 instance->msix_vectors);
6151 				instance->msix_vectors = min(msix_vectors,
6152 					instance->msix_vectors);
6154 			instance->msix_vectors = 1;
6180 			(instance->msix_vectors == MEGASAS_MAX_MSIX_QUEUES))
6181 			instance->perf_mode = MR_BALANCED_PERF_MODE;
6183 			instance->perf_mode = MR_LATENCY_PERF_MODE;
6186 		if (instance->adapter_type == AERO_SERIES) {
6187 			pcie_capability_read_word(instance->pdev, PCI_EXP_LNKSTA, &lnksta);
6195 				instance->perf_mode = MR_LATENCY_PERF_MODE;
6207 				instance->perf_mode = perf_mode;
6213 				instance->perf_mode = MR_LATENCY_PERF_MODE;
6217 		if (instance->perf_mode == MR_BALANCED_PERF_MODE)
6218 			instance->low_latency_index_start =
6221 			instance->low_latency_index_start = 1;
6223 		num_msix_req = num_online_cpus() + instance->low_latency_index_start;
6225 		instance->msix_vectors = min(num_msix_req,
6226 				instance->msix_vectors);
6228 		megasas_alloc_irq_vectors(instance);
6229 		if (!instance->msix_vectors)
6230 			instance->msix_load_balance = false;
6236 	if (instance->msix_combined) {
6237 		instance->reply_post_host_index_addr[0] =
6238 				(u32 *)((u8 *)instance->reg_set +
6241 		instance->reply_post_host_index_addr[0] =
6242 			(u32 *)((u8 *)instance->reg_set +
6246 	if (!instance->msix_vectors) {
6247 		i = pci_alloc_irq_vectors(instance->pdev, 1, 1, PCI_IRQ_LEGACY);
6252 	megasas_setup_reply_map(instance);
6254 	dev_info(&instance->pdev->dev,
6256 		instance->msix_vectors, (unsigned int)num_online_cpus());
6257 	dev_info(&instance->pdev->dev,
6258 		"RDPQ mode\t: (%s)\n", instance->is_rdpq ? "enabled" : "disabled");
6260 	tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
6261 		(unsigned long)instance);
6267 	instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
6268 	instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
6270 	if (instance->instancet->init_adapter(instance))
6273 	if (instance->adapter_type >= VENTURA_SERIES) {
6275 			megasas_readl(instance,
6276 				      &instance->reg_set->outbound_scratch_pad_3);
6279 			instance->nvme_page_size =
6282 		dev_info(&instance->pdev->dev,
6283 			 "NVME page size\t: (%d)\n", instance->nvme_page_size);
6286 	if (instance->msix_vectors ?
6287 		megasas_setup_irqs_msix(instance, 1) :
6288 		megasas_setup_irqs_ioapic(instance))
6291 	if (instance->adapter_type != MFI_SERIES)
6292 		megasas_setup_irq_poll(instance);
6294 	instance->instancet->enable_intr(instance);
6296 	dev_info(&instance->pdev->dev, "INIT adapter done\n");
6298 	megasas_setup_jbod_map(instance);
6300 	if (megasas_get_device_list(instance) != SUCCESS) {
6301 		dev_err(&instance->pdev->dev,
6308 	if (instance->adapter_type >= VENTURA_SERIES) {
6314 			dev_err(&instance->pdev->dev,
6323 				dev_err(&instance->pdev->dev,
6346 	ctrl_info = instance->ctrl_info_buf;
6354 	instance->peerIsPresent = ctrl_info->cluster.peerIsPresent;
6355 	instance->passive = ctrl_info->cluster.passive;
6356 	memcpy(instance->clusterId, ctrl_info->clusterId, sizeof(instance->clusterId));
6357 	instance->UnevenSpanSupport =
6359 	if (instance->UnevenSpanSupport) {
6360 		struct fusion_context *fusion = instance->ctrl_context;
6361 		if (MR_ValidateMapInfo(instance, instance->map_id))
6368 		instance->requestorId = ctrl_info->iov.requestorId;
6369 		if (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) {
6371 			    instance->PlasmaFW111 = 1;
6373 			dev_info(&instance->pdev->dev, "SR-IOV: firmware type: %s\n",
6374 			    instance->PlasmaFW111 ? "1.11" : "new");
6376 			if (instance->PlasmaFW111) {
6379 			    instance->requestorId = iovPtr->requestorId;
6382 		dev_info(&instance->pdev->dev, "SRIOV: VF requestorId %d\n",
6383 			instance->requestorId);
6386 	instance->crash_dump_fw_support =
6388 	instance->crash_dump_drv_support =
6389 		(instance->crash_dump_fw_support &&
6390 		instance->crash_dump_buf);
6391 	if (instance->crash_dump_drv_support)
6392 		megasas_set_crash_dump_params(instance,
6396 		if (instance->crash_dump_buf)
6397 			dma_free_coherent(&instance->pdev->dev,
6399 				instance->crash_dump_buf,
6400 				instance->crash_dump_h);
6401 		instance->crash_dump_buf = NULL;
6404 	if (instance->snapdump_wait_time) {
6405 		megasas_get_snapdump_properties(instance);
6406 		dev_info(&instance->pdev->dev, "Snap dump wait time\t: %d\n",
6407 			 instance->snapdump_wait_time);
6410 	dev_info(&instance->pdev->dev,
6416 	dev_info(&instance->pdev->dev, "unevenspan support	: %s\n",
6417 		instance->UnevenSpanSupport ? "yes" : "no");
6418 	dev_info(&instance->pdev->dev, "firmware crash dump	: %s\n",
6419 		instance->crash_dump_drv_support ? "yes" : "no");
6420 	dev_info(&instance->pdev->dev, "JBOD sequence map	: %s\n",
6421 		instance->use_seqnum_jbod_fp ? "enabled" : "disabled");
6423 	instance->max_sectors_per_req = instance->max_num_sge *
6425 	if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))
6426 		instance->max_sectors_per_req = tmp_sectors;
6430 			throttlequeuedepth <= instance->max_scsi_cmds)
6431 		instance->throttlequeuedepth = throttlequeuedepth;
6433 		instance->throttlequeuedepth =
6444 	if (instance->requestorId) {
6445 		if (!megasas_sriov_start_heartbeat(instance, 1)) {
6446 			megasas_start_timer(instance);
6448 			instance->skip_heartbeat_timer_del = 1;
6458 	if (instance->adapter_type != MFI_SERIES)
6459 		if (megasas_fusion_start_watchdog(instance) != SUCCESS)
6465 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
6466 		del_timer_sync(&instance->sriov_heartbeat_timer);
6468 	instance->instancet->disable_intr(instance);
6469 	megasas_destroy_irqs(instance);
6471 	if (instance->msix_vectors)
6472 		pci_free_irq_vectors(instance->pdev);
6473 	instance->msix_vectors = 0;
6475 	megasas_free_ctrl_dma_buffers(instance);
6476 	megasas_free_ctrl_mem(instance);
6478 	iounmap(instance->reg_set);
6481 	pci_release_selected_regions(instance->pdev, 1<<instance->bar);
6483 	dev_err(&instance->pdev->dev, "Failed from %s %d\n",
6490  * @instance:			Adapter soft state
6492 static void megasas_release_mfi(struct megasas_instance *instance)
6494 	u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1);
6496 	if (instance->reply_queue)
6497 		dma_free_coherent(&instance->pdev->dev, reply_q_sz,
6498 			    instance->reply_queue, instance->reply_queue_h);
6500 	megasas_free_cmds(instance);
6502 	iounmap(instance->reg_set);
6504 	pci_release_selected_regions(instance->pdev, 1<<instance->bar);
6509  * @instance:			Adapter soft state
6520 megasas_get_seq_num(struct megasas_instance *instance,
6529 	cmd = megasas_get_cmd(instance);
6536 	el_info = dma_alloc_coherent(&instance->pdev->dev,
6540 		megasas_return_cmd(instance, cmd);
6555 	megasas_set_dma_settings(instance, dcmd, el_info_h,
6558 	ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
6560 		dev_err(&instance->pdev->dev, "Failed from %s %d\n",
6575 	dma_free_coherent(&instance->pdev->dev,
6579 	megasas_return_cmd(instance, cmd);
6586  * @instance:			Adapter soft state
6594 megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
6618 	if (instance->aen_cmd) {
6621 			le32_to_cpu(instance->aen_cmd->frame->dcmd.mbox.w[1]);
6625 			dev_info(&instance->pdev->dev,
6655 			instance->aen_cmd->abort_aen = 1;
6656 			ret_val = megasas_issue_blocked_abort_cmd(instance,
6657 								  instance->
6661 				dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to abort "
6668 	cmd = megasas_get_cmd(instance);
6675 	memset(instance->evt_detail, 0, sizeof(struct megasas_evt_detail));
6691 	instance->last_seq_num = seq_num;
6694 	megasas_set_dma_settings(instance, dcmd, instance->evt_detail_h,
6697 	if (instance->aen_cmd != NULL) {
6698 		megasas_return_cmd(instance, cmd);
6707 	instance->aen_cmd = cmd;
6712 	instance->instancet->issue_dcmd(instance, cmd);
6730  * @instance:		Adapter soft state
6736 megasas_get_target_prop(struct megasas_instance *instance,
6745 	cmd = megasas_get_cmd(instance);
6748 		dev_err(&instance->pdev->dev,
6755 	memset(instance->tgt_prop, 0, sizeof(*instance->tgt_prop));
6770 	megasas_set_dma_settings(instance, dcmd, instance->tgt_prop_h,
6773 	if ((instance->adapter_type != MFI_SERIES) &&
6774 	    !instance->mask_interrupts)
6775 		ret = megasas_issue_blocked_cmd(instance,
6778 		ret = megasas_issue_polled(instance, cmd);
6782 		switch (dcmd_timeout_ocr_possible(instance)) {
6785 			mutex_unlock(&instance->reset_mutex);
6786 			megasas_reset_fusion(instance->host,
6788 			mutex_lock(&instance->reset_mutex);
6791 			megaraid_sas_kill_hba(instance);
6794 			dev_info(&instance->pdev->dev,
6802 		megasas_return_cmd(instance, cmd);
6805 		dev_err(&instance->pdev->dev,
6814  * @instance:		Adapter soft state
6816 static int megasas_start_aen(struct megasas_instance *instance)
6826 	if (megasas_get_seq_num(instance, &eli))
6836 	return megasas_register_aen(instance,
6843  * @instance:		Adapter soft state
6845 static int megasas_io_attach(struct megasas_instance *instance)
6847 	struct Scsi_Host *host = instance->host;
6852 	host->unique_id = instance->unique_id;
6853 	host->can_queue = instance->max_scsi_cmds;
6854 	host->this_id = instance->init_id;
6855 	host->sg_tablesize = instance->max_num_sge;
6857 	if (instance->fw_support_ieee)
6858 		instance->max_sectors_per_req = MEGASAS_MAX_SECTORS_IEEE;
6863 	if (max_sectors && max_sectors < instance->max_sectors_per_req)
6864 		instance->max_sectors_per_req = max_sectors;
6867 			if (((instance->pdev->device ==
6869 				(instance->pdev->device ==
6872 				instance->max_sectors_per_req = max_sectors;
6874 			dev_info(&instance->pdev->dev, "max_sectors should be > 0"
6876 				instance->max_sectors_per_req);
6881 	host->max_sectors = instance->max_sectors_per_req;
6896 	if ((instance->adapter_type != MFI_SERIES) &&
6897 		(instance->msix_vectors > instance->low_latency_index_start) &&
6899 		instance->smp_affinity_enable) {
6901 		host->nr_hw_queues = instance->msix_vectors -
6902 			instance->low_latency_index_start;
6905 	dev_info(&instance->pdev->dev,
6907 		instance->max_fw_cmds, host->nr_hw_queues);
6911 	if (scsi_add_host(host, &instance->pdev->dev)) {
6912 		dev_err(&instance->pdev->dev,
6924  * @instance:		Adapter soft state
6939 megasas_set_dma_mask(struct megasas_instance *instance)
6945 	pdev = instance->pdev;
6946 	consistent_mask = (instance->adapter_type >= VENTURA_SERIES) ?
6962 				(instance, &instance->reg_set->outbound_scratch_pad_1);
6974 		instance->consistent_mask_64bit = false;
6976 		instance->consistent_mask_64bit = true;
6980 		 (instance->consistent_mask_64bit ? "63" : "32"));
7001  * @instance:			Adapter soft state
7004 static inline void megasas_set_adapter_type(struct megasas_instance *instance)
7006 	if ((instance->pdev->vendor == PCI_VENDOR_ID_DELL) &&
7007 	    (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5)) {
7008 		instance->adapter_type = MFI_SERIES;
7010 		switch (instance->pdev->device) {
7015 			instance->adapter_type = AERO_SERIES;
7023 			instance->adapter_type = VENTURA_SERIES;
7027 			instance->adapter_type = THUNDERBOLT_SERIES;
7035 			instance->adapter_type = INVADER_SERIES;
7038 			instance->adapter_type = MFI_SERIES;
7044 static inline int megasas_alloc_mfi_ctrl_mem(struct megasas_instance *instance)
7046 	instance->producer = dma_alloc_coherent(&instance->pdev->dev,
7047 			sizeof(u32), &instance->producer_h, GFP_KERNEL);
7048 	instance->consumer = dma_alloc_coherent(&instance->pdev->dev,
7049 			sizeof(u32), &instance->consumer_h, GFP_KERNEL);
7051 	if (!instance->producer || !instance->consumer) {
7052 		dev_err(&instance->pdev->dev,
7057 	*instance->producer = 0;
7058 	*instance->consumer = 0;
7069  * @instance:			Adapter soft state
7072 static int megasas_alloc_ctrl_mem(struct megasas_instance *instance)
7074 	instance->reply_map = kcalloc(nr_cpu_ids, sizeof(unsigned int),
7076 	if (!instance->reply_map)
7079 	switch (instance->adapter_type) {
7081 		if (megasas_alloc_mfi_ctrl_mem(instance))
7088 		if (megasas_alloc_fusion_context(instance))
7095 	kfree(instance->reply_map);
7096 	instance->reply_map = NULL;
7104  * @instance -			Adapter soft instance
7107 static inline void megasas_free_ctrl_mem(struct megasas_instance *instance)
7109 	kfree(instance->reply_map);
7110 	if (instance->adapter_type == MFI_SERIES) {
7111 		if (instance->producer)
7112 			dma_free_coherent(&instance->pdev->dev, sizeof(u32),
7113 					    instance->producer,
7114 					    instance->producer_h);
7115 		if (instance->consumer)
7116 			dma_free_coherent(&instance->pdev->dev, sizeof(u32),
7117 					    instance->consumer,
7118 					    instance->consumer_h);
7120 		megasas_free_fusion_context(instance);
7128  * @instance:				Adapter soft instance
7133 int megasas_alloc_ctrl_dma_buffers(struct megasas_instance *instance)
7135 	struct pci_dev *pdev = instance->pdev;
7136 	struct fusion_context *fusion = instance->ctrl_context;
7138 	instance->evt_detail = dma_alloc_coherent(&pdev->dev,
7140 			&instance->evt_detail_h, GFP_KERNEL);
7142 	if (!instance->evt_detail) {
7143 		dev_err(&instance->pdev->dev,
7161 		instance->snapdump_prop = dma_alloc_coherent(&pdev->dev,
7163 				&instance->snapdump_prop_h, GFP_KERNEL);
7165 		if (!instance->snapdump_prop)
7169 		instance->host_device_list_buf = dma_alloc_coherent(&pdev->dev,
7171 							&instance->host_device_list_buf_h,
7174 		if (!instance->host_device_list_buf) {
7182 	instance->pd_list_buf =
7185 				     &instance->pd_list_buf_h, GFP_KERNEL);
7187 	if (!instance->pd_list_buf) {
7192 	instance->ctrl_info_buf =
7195 				     &instance->ctrl_info_buf_h, GFP_KERNEL);
7197 	if (!instance->ctrl_info_buf) {
7203 	instance->ld_list_buf =
7206 				     &instance->ld_list_buf_h, GFP_KERNEL);
7208 	if (!instance->ld_list_buf) {
7213 	instance->ld_targetid_list_buf =
7216 				&instance->ld_targetid_list_buf_h, GFP_KERNEL);
7218 	if (!instance->ld_targetid_list_buf) {
7225 		instance->system_info_buf =
7228 					&instance->system_info_h, GFP_KERNEL);
7229 		instance->pd_info =
7232 					&instance->pd_info_h, GFP_KERNEL);
7233 		instance->tgt_prop =
7236 					&instance->tgt_prop_h, GFP_KERNEL);
7237 		instance->crash_dump_buf =
7239 					&instance->crash_dump_h, GFP_KERNEL);
7241 		if (!instance->system_info_buf)
7242 			dev_err(&instance->pdev->dev,
7245 		if (!instance->pd_info)
7246 			dev_err(&instance->pdev->dev,
7249 		if (!instance->tgt_prop)
7250 			dev_err(&instance->pdev->dev,
7253 		if (!instance->crash_dump_buf)
7254 			dev_err(&instance->pdev->dev,
7265  * @instance-				Adapter soft instance
7269 void megasas_free_ctrl_dma_buffers(struct megasas_instance *instance)
7271 	struct pci_dev *pdev = instance->pdev;
7272 	struct fusion_context *fusion = instance->ctrl_context;
7274 	if (instance->evt_detail)
7276 				    instance->evt_detail,
7277 				    instance->evt_detail_h);
7285 	if (instance->pd_list_buf)
7288 				    instance->pd_list_buf,
7289 				    instance->pd_list_buf_h);
7291 	if (instance->ld_list_buf)
7293 				    instance->ld_list_buf,
7294 				    instance->ld_list_buf_h);
7296 	if (instance->ld_targetid_list_buf)
7298 				    instance->ld_targetid_list_buf,
7299 				    instance->ld_targetid_list_buf_h);
7301 	if (instance->ctrl_info_buf)
7303 				    instance->ctrl_info_buf,
7304 				    instance->ctrl_info_buf_h);
7306 	if (instance->system_info_buf)
7308 				    instance->system_info_buf,
7309 				    instance->system_info_h);
7311 	if (instance->pd_info)
7313 				    instance->pd_info, instance->pd_info_h);
7315 	if (instance->tgt_prop)
7317 				    instance->tgt_prop, instance->tgt_prop_h);
7319 	if (instance->crash_dump_buf)
7321 				    instance->crash_dump_buf,
7322 				    instance->crash_dump_h);
7324 	if (instance->snapdump_prop)
7327 				  instance->snapdump_prop,
7328 				  instance->snapdump_prop_h);
7330 	if (instance->host_device_list_buf)
7333 				  instance->host_device_list_buf,
7334 				  instance->host_device_list_buf_h);
7339  * megasas_init_ctrl_params -		Initialize controller's instance
7341  * @instance -				Adapter soft instance
7344 static inline void megasas_init_ctrl_params(struct megasas_instance *instance)
7346 	instance->fw_crash_state = UNAVAILABLE;
7349 	instance->issuepend_done = 1;
7350 	atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
7355 	INIT_LIST_HEAD(&instance->cmd_pool);
7356 	INIT_LIST_HEAD(&instance->internal_reset_pending_q);
7358 	atomic_set(&instance->fw_outstanding, 0);
7359 	atomic64_set(&instance->total_io_count, 0);
7361 	init_waitqueue_head(&instance->int_cmd_wait_q);
7362 	init_waitqueue_head(&instance->abort_cmd_wait_q);
7364 	mutex_init(&instance->crashdump_lock);
7365 	spin_lock_init(&instance->mfi_pool_lock);
7366 	spin_lock_init(&instance->hba_lock);
7367 	spin_lock_init(&instance->stream_lock);
7368 	spin_lock_init(&instance->completion_lock);
7370 	mutex_init(&instance->reset_mutex);
7372 	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
7373 	    (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY))
7374 		instance->flag_ieee = 1;
7377 	instance->flag = 0;
7378 	instance->unload = 1;
7379 	instance->last_time = 0;
7380 	instance->disableOnlineCtrlReset = 1;
7381 	instance->UnevenSpanSupport = 0;
7382 	instance->smp_affinity_enable = smp_affinity_enable ? true : false;
7383 	instance->msix_load_balance = false;
7385 	if (instance->adapter_type != MFI_SERIES)
7386 		INIT_WORK(&instance->work_init, megasas_fusion_ocr_wq);
7388 		INIT_WORK(&instance->work_init, process_fw_state_change_wq);
7401 	struct megasas_instance *instance;
7452 	instance = (struct megasas_instance *)host->hostdata;
7453 	memset(instance, 0, sizeof(*instance));
7454 	atomic_set(&instance->fw_reset_no_pci_access, 0);
7459 	instance->pdev = pdev;
7460 	instance->host = host;
7461 	instance->unique_id = pdev->bus->number << 8 | pdev->devfn;
7462 	instance->init_id = MEGASAS_DEFAULT_INIT_ID;
7464 	megasas_set_adapter_type(instance);
7469 	if (megasas_init_fw(instance))
7472 	if (instance->requestorId) {
7473 		if (instance->PlasmaFW111) {
7474 			instance->vf_affiliation_111 =
7477 					&instance->vf_affiliation_111_h,
7479 			if (!instance->vf_affiliation_111)
7483 			instance->vf_affiliation =
7487 					&instance->vf_affiliation_h,
7489 			if (!instance->vf_affiliation)
7496 	 * Store instance in PCI softstate
7498 	pci_set_drvdata(pdev, instance);
7505 	megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance;
7511 	if (megasas_io_attach(instance))
7514 	instance->unload = 0;
7518 	if (!instance->enable_fw_dev_list ||
7519 	    (instance->host_device_list_buf->count > 0))
7525 	if (megasas_start_aen(instance)) {
7530 	megasas_setup_debugfs(instance);
7533 	if (instance->requestorId)
7534 		megasas_get_ld_vf_affiliation(instance, 1);
7539 	instance->unload = 1;
7540 	scsi_remove_host(instance->host);
7544 	megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL;
7546 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7547 		del_timer_sync(&instance->sriov_heartbeat_timer);
7549 	instance->instancet->disable_intr(instance);
7550 	megasas_destroy_irqs(instance);
7552 	if (instance->adapter_type != MFI_SERIES)
7553 		megasas_release_fusion(instance);
7555 		megasas_release_mfi(instance);
7557 	if (instance->msix_vectors)
7558 		pci_free_irq_vectors(instance->pdev);
7559 	instance->msix_vectors = 0;
7561 	if (instance->fw_crash_state != UNAVAILABLE)
7562 		megasas_free_host_crash_buffer(instance);
7564 	if (instance->adapter_type != MFI_SERIES)
7565 		megasas_fusion_stop_watchdog(instance);
7576  * @instance:			Adapter soft state
7578 static void megasas_flush_cache(struct megasas_instance *instance)
7583 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
7586 	cmd = megasas_get_cmd(instance);
7605 	if (megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS)
7607 		dev_err(&instance->pdev->dev,
7612 	megasas_return_cmd(instance, cmd);
7617  * @instance:				Adapter soft state
7620 static void megasas_shutdown_controller(struct megasas_instance *instance,
7626 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
7629 	cmd = megasas_get_cmd(instance);
7634 	if (instance->aen_cmd)
7635 		megasas_issue_blocked_abort_cmd(instance,
7636 			instance->aen_cmd, MFI_IO_TIMEOUT_SECS);
7637 	if (instance->map_update_cmd)
7638 		megasas_issue_blocked_abort_cmd(instance,
7639 			instance->map_update_cmd, MFI_IO_TIMEOUT_SECS);
7640 	if (instance->jbod_seq_cmd)
7641 		megasas_issue_blocked_abort_cmd(instance,
7642 			instance->jbod_seq_cmd, MFI_IO_TIMEOUT_SECS);
7657 	if (megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS)
7659 		dev_err(&instance->pdev->dev,
7664 	megasas_return_cmd(instance, cmd);
7676 	struct megasas_instance *instance;
7678 	instance = pci_get_drvdata(pdev);
7680 	if (!instance)
7683 	instance->unload = 1;
7688 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7689 		del_timer_sync(&instance->sriov_heartbeat_timer);
7692 	if (instance->adapter_type != MFI_SERIES)
7693 		megasas_fusion_stop_watchdog(instance);
7695 	megasas_flush_cache(instance);
7696 	megasas_shutdown_controller(instance, MR_DCMD_HIBERNATE_SHUTDOWN);
7699 	if (instance->ev != NULL) {
7700 		struct megasas_aen_event *ev = instance->ev;
7702 		instance->ev = NULL;
7705 	tasklet_kill(&instance->isr_tasklet);
7707 	pci_set_drvdata(instance->pdev, instance);
7708 	instance->instancet->disable_intr(instance);
7710 	megasas_destroy_irqs(instance);
7712 	if (instance->msix_vectors)
7713 		pci_free_irq_vectors(instance->pdev);
7732 	struct megasas_instance *instance;
7735 	instance = pci_get_drvdata(pdev);
7737 	if (!instance)
7740 	host = instance->host;
7762 	if (megasas_transition_to_ready(instance, 0)) {
7763 		dev_info(&instance->pdev->dev,
7766 		if (instance->adapter_type != MFI_SERIES) {
7768 				instance->instancet->read_fw_status_reg(instance);
7771 				(instance, true, 0)) == FAILED))
7774 			atomic_set(&instance->fw_reset_no_pci_access, 1);
7775 			instance->instancet->adp_reset
7776 				(instance, instance->reg_set);
7777 			atomic_set(&instance->fw_reset_no_pci_access, 0);
7782 			if (megasas_transition_to_ready(instance, 0))
7786 		dev_info(&instance->pdev->dev,
7790 	if (megasas_set_dma_mask(instance))
7797 	atomic_set(&instance->fw_outstanding, 0);
7798 	atomic_set(&instance->ldio_outstanding, 0);
7801 	if (instance->msix_vectors)
7802 		megasas_alloc_irq_vectors(instance);
7804 	if (!instance->msix_vectors) {
7805 		rval = pci_alloc_irq_vectors(instance->pdev, 1, 1,
7811 	megasas_setup_reply_map(instance);
7813 	if (instance->adapter_type != MFI_SERIES) {
7814 		megasas_reset_reply_desc(instance);
7815 		if (megasas_ioc_init_fusion(instance)) {
7816 			megasas_free_cmds(instance);
7817 			megasas_free_cmds_fusion(instance);
7820 		if (!megasas_get_map_info(instance))
7821 			megasas_sync_map_info(instance);
7823 		*instance->producer = 0;
7824 		*instance->consumer = 0;
7825 		if (megasas_issue_init_mfi(instance))
7829 	if (megasas_get_ctrl_info(instance) != DCMD_SUCCESS)
7832 	tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
7833 		     (unsigned long)instance);
7835 	if (instance->msix_vectors ?
7836 			megasas_setup_irqs_msix(instance, 0) :
7837 			megasas_setup_irqs_ioapic(instance))
7840 	if (instance->adapter_type != MFI_SERIES)
7841 		megasas_setup_irq_poll(instance);
7844 	if (instance->requestorId) {
7845 		if (!megasas_sriov_start_heartbeat(instance, 0))
7846 			megasas_start_timer(instance);
7848 			instance->skip_heartbeat_timer_del = 1;
7853 	instance->instancet->enable_intr(instance);
7854 	megasas_setup_jbod_map(instance);
7855 	instance->unload = 0;
7860 	if (megasas_start_aen(instance))
7861 		dev_err(&instance->pdev->dev, "Start AEN failed\n");
7864 	if (instance->adapter_type != MFI_SERIES)
7865 		if (megasas_fusion_start_watchdog(instance) != SUCCESS)
7871 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7872 		del_timer_sync(&instance->sriov_heartbeat_timer);
7874 	megasas_free_ctrl_dma_buffers(instance);
7875 	megasas_free_ctrl_mem(instance);
7892 megasas_wait_for_adapter_operational(struct megasas_instance *instance)
7899 		adp_state = atomic_read(&instance->adprecovery);
7905 			dev_notice(&instance->pdev->dev, "waiting for controller reset to finish\n");
7911 		dev_info(&instance->pdev->dev,
7928 	struct megasas_instance *instance;
7932 	instance = pci_get_drvdata(pdev);
7934 	if (!instance)
7937 	host = instance->host;
7938 	fusion = instance->ctrl_context;
7941 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7942 		del_timer_sync(&instance->sriov_heartbeat_timer);
7945 	if (instance->adapter_type != MFI_SERIES)
7946 		megasas_fusion_stop_watchdog(instance);
7948 	if (instance->fw_crash_state != UNAVAILABLE)
7949 		megasas_free_host_crash_buffer(instance);
7950 	scsi_remove_host(instance->host);
7951 	instance->unload = 1;
7953 	if (megasas_wait_for_adapter_operational(instance))
7956 	megasas_flush_cache(instance);
7957 	megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
7961 	if (instance->ev != NULL) {
7962 		struct megasas_aen_event *ev = instance->ev;
7964 		instance->ev = NULL;
7968 	wake_up_all(&instance->int_cmd_wait_q);
7970 	tasklet_kill(&instance->isr_tasklet);
7973 	 * Take the instance off the instance array. Note that we will not
7977 		if (megasas_mgmt_info.instance[i] == instance) {
7979 			megasas_mgmt_info.instance[i] = NULL;
7985 	instance->instancet->disable_intr(instance);
7987 	megasas_destroy_irqs(instance);
7989 	if (instance->msix_vectors)
7990 		pci_free_irq_vectors(instance->pdev);
7992 	if (instance->adapter_type >= VENTURA_SERIES) {
8000 	if (instance->adapter_type != MFI_SERIES) {
8001 		megasas_release_fusion(instance);
8007 				dma_free_coherent(&instance->pdev->dev,
8020 				dma_free_coherent(&instance->pdev->dev,
8026 		megasas_release_mfi(instance);
8029 	if (instance->vf_affiliation)
8032 				    instance->vf_affiliation,
8033 				    instance->vf_affiliation_h);
8035 	if (instance->vf_affiliation_111)
8038 				    instance->vf_affiliation_111,
8039 				    instance->vf_affiliation_111_h);
8041 	if (instance->hb_host_mem)
8043 				    instance->hb_host_mem,
8044 				    instance->hb_host_mem_h);
8046 	megasas_free_ctrl_dma_buffers(instance);
8048 	megasas_free_ctrl_mem(instance);
8050 	megasas_destroy_debugfs(instance);
8063 	struct megasas_instance *instance = pci_get_drvdata(pdev);
8065 	if (!instance)
8068 	instance->unload = 1;
8070 	if (megasas_wait_for_adapter_operational(instance))
8073 	megasas_flush_cache(instance);
8074 	megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
8077 	instance->instancet->disable_intr(instance);
8078 	megasas_destroy_irqs(instance);
8080 	if (instance->msix_vectors)
8081 		pci_free_irq_vectors(instance->pdev);
8166 		local_instance = megasas_mgmt_info.instance[i];
8191  * @instance:			Adapter soft state
8196 megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
8215 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "SGE count [%d] >  max limit [%d]\n",
8222 	    !instance->support_nvme_passthru) ||
8224 	    !instance->support_pci_lane_margining)) {
8225 		dev_err(&instance->pdev->dev,
8231 	cmd = megasas_get_cmd(instance);
8233 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get a cmd packet\n");
8249 	if (instance->consistent_mask_64bit)
8260 		mutex_lock(&instance->reset_mutex);
8261 		if (megasas_get_ctrl_info(instance) != DCMD_SUCCESS) {
8262 			megasas_return_cmd(instance, cmd);
8263 			mutex_unlock(&instance->reset_mutex);
8266 		mutex_unlock(&instance->reset_mutex);
8271 		megasas_return_cmd(instance, cmd);
8283 	if (instance->consistent_mask_64bit)
8297 		kbuff_arr[i] = dma_alloc_coherent(&instance->pdev->dev,
8301 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc "
8311 		if (instance->consistent_mask_64bit) {
8338 		sense = dma_alloc_coherent(&instance->pdev->dev, ioc->sense_len,
8356 	ret = megasas_issue_blocked_cmd(instance, cmd, 0);
8361 		dev_err(&instance->pdev->dev,
8371 	if (instance->unload == 1) {
8372 		dev_info(&instance->pdev->dev, "Driver unload is in progress "
8401 			dev_err(&instance->pdev->dev, "Failed to copy out to user "
8413 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Error copying out cmd_status\n");
8419 		dma_free_coherent(&instance->pdev->dev, ioc->sense_len,
8425 			if (instance->consistent_mask_64bit)
8426 				dma_free_coherent(&instance->pdev->dev,
8431 				dma_free_coherent(&instance->pdev->dev,
8439 	megasas_return_cmd(instance, cmd);
8448 	struct megasas_instance *instance;
8455 	instance = megasas_lookup_instance(ioc->host_no);
8456 	if (!instance) {
8462 	if (instance->requestorId && !allow_vf_ioctls) {
8467 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
8468 		dev_err(&instance->pdev->dev, "Controller in crit error\n");
8473 	if (instance->unload == 1) {
8478 	if (down_interruptible(&instance->ioctl_sem)) {
8483 	if  (megasas_wait_for_adapter_operational(instance)) {
8488 	error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc);
8490 	up(&instance->ioctl_sem);
8499 	struct megasas_instance *instance;
8512 	instance = megasas_lookup_instance(aen.host_no);
8514 	if (!instance)
8517 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
8521 	if (instance->unload == 1) {
8525 	if  (megasas_wait_for_adapter_operational(instance))
8528 	mutex_lock(&instance->reset_mutex);
8529 	error = megasas_register_aen(instance, aen.seq_num,
8531 	mutex_unlock(&instance->reset_mutex);
8738  * @instance:			Adapter soft state
8748 int megasas_update_device_list(struct megasas_instance *instance,
8753 	if (instance->enable_fw_dev_list) {
8754 		dcmd_ret = megasas_host_device_list_query(instance, false);
8759 			dcmd_ret = megasas_get_pd_list(instance);
8766 			if (!instance->requestorId ||
8767 			    (instance->requestorId &&
8768 			     megasas_get_ld_vf_affiliation(instance, 0))) {
8769 				dcmd_ret = megasas_ld_list_query(instance,
8784  * @instance:			Adapter soft state
8789 void megasas_add_remove_devices(struct megasas_instance *instance,
8801 	host = instance->host;
8803 	if (instance->enable_fw_dev_list) {
8804 		targetid_list = instance->host_device_list_buf;
8833 				if (instance->pd_list[pd_index].driveState ==
8853 				if (instance->ld_ids[ld_index] != 0xff) {
8873 	struct megasas_instance *instance = ev->instance;
8882 	if (!instance) {
8883 		printk(KERN_ERR "invalid instance!\n");
8889 	mutex_lock(&instance->reset_mutex);
8891 	instance->ev = NULL;
8892 	if (instance->evt_detail) {
8893 		megasas_decode_evt(instance);
8895 		switch (le32_to_cpu(instance->evt_detail->code)) {
8904 			ld_target_id = instance->evt_detail->args.ld.target_id;
8905 			sdev1 = scsi_device_lookup(instance->host,
8924 			dev_info(&instance->pdev->dev, "scanning for scsi%d...\n",
8925 				instance->host->host_no);
8929 			dcmd_ret = megasas_get_ctrl_info(instance);
8931 			    instance->snapdump_wait_time) {
8932 				megasas_get_snapdump_properties(instance);
8933 				dev_info(&instance->pdev->dev,
8935 					 instance->snapdump_wait_time);
8943 		dev_err(&instance->pdev->dev, "invalid evt_detail!\n");
8944 		mutex_unlock(&instance->reset_mutex);
8950 		dcmd_ret = megasas_update_device_list(instance, event_type);
8952 	mutex_unlock(&instance->reset_mutex);
8955 		megasas_add_remove_devices(instance, event_type);
8958 		seq_num = le32_to_cpu(instance->evt_detail->seq_num) + 1;
8960 		seq_num = instance->last_seq_num;
8967 	if (instance->aen_cmd != NULL) {
8972 	mutex_lock(&instance->reset_mutex);
8973 	error = megasas_register_aen(instance, seq_num,
8976 		dev_err(&instance->pdev->dev,
8979 	mutex_unlock(&instance->reset_mutex);

Indexes created Thu Nov 07 10:32:03 CST 2024