135 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
136 static int megasas_get_pd_list(struct megasas_instance *instance);
137 static int megasas_ld_list_query(struct megasas_instance *instance,
139 static int megasas_issue_init_mfi(struct megasas_instance *instance);
140 static int megasas_register_aen(struct megasas_instance *instance,
142 static void megasas_get_pd_info(struct megasas_instance *instance,
145 megasas_set_ld_removed_by_fw(struct megasas_instance *instance);
224 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
227 megasas_read_fw_status_reg_gen2(struct megasas_instance *instance);
229 megasas_adp_reset_gen2(struct megasas_instance *instance,
233 megasas_init_adapter_mfi(struct megasas_instance *instance);
235 megasas_build_and_issue_cmd(struct megasas_instance *instance,
239 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
242 static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,
245 megasas_set_dma_mask(struct megasas_instance *instance);
247 megasas_alloc_ctrl_mem(struct megasas_instance *instance);
249 megasas_free_ctrl_mem(struct megasas_instance *instance);
251 megasas_alloc_ctrl_dma_buffers(struct megasas_instance *instance);
253 megasas_free_ctrl_dma_buffers(struct megasas_instance *instance);
255 megasas_init_ctrl_params(struct megasas_instance *instance);
257 u32 megasas_readl(struct megasas_instance *instance,
268 	if (instance->adapter_type == AERO_SERIES) {
281  * @instance:			Adapter soft state
287 void megasas_set_dma_settings(struct megasas_instance *instance,
291 	if (instance->consistent_mask_64bit) {
305 megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
307 	instance->instancet->fire_cmd(instance,
308 		cmd->frame_phys_addr, 0, instance->reg_set);
314  * @instance:		Adapter soft state
319 						  *instance)
324 	spin_lock_irqsave(&instance->mfi_pool_lock, flags);
326 	if (!list_empty(&instance->cmd_pool)) {
327 		cmd = list_entry((&instance->cmd_pool)->next,
331 		dev_err(&instance->pdev->dev, "Command pool empty!\n");
334 	spin_unlock_irqrestore(&instance->mfi_pool_lock, flags);
340  * @instance:		Adapter soft state
344 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
349 	struct fusion_context *fusion = instance->ctrl_context;
357 	spin_lock_irqsave(&instance->mfi_pool_lock, flags);
360 		blk_tags = instance->max_scsi_cmds + cmd->index;
362 		megasas_return_cmd_fusion(instance, cmd_fusion);
367 	memset(cmd->frame, 0, instance->mfi_frame_size);
371 	list_add(&cmd->list, (&instance->cmd_pool)->next);
373 	spin_unlock_irqrestore(&instance->mfi_pool_lock, flags);
419   * @instance:			Adapter soft state
422 megasas_decode_evt(struct megasas_instance *instance)
424 	struct megasas_evt_detail *evt_detail = instance->evt_detail;
435 		dev_info(&instance->pdev->dev, "%d (%s/0x%04x/%s) - %s\n",
443 		dev_info(&instance->pdev->dev,
456  * @instance:	Adapter soft state
459 megasas_enable_intr_xscale(struct megasas_instance *instance)
463 	regs = instance->reg_set;
472  * @instance:	Adapter soft state
475 megasas_disable_intr_xscale(struct megasas_instance *instance)
480 	regs = instance->reg_set;
488  * @instance:	Adapter soft state
491 megasas_read_fw_status_reg_xscale(struct megasas_instance *instance)
493 	return readl(&instance->reg_set->outbound_msg_0);
497  * @instance:	Adapter soft state
500 megasas_clear_intr_xscale(struct megasas_instance *instance)
505 	regs = instance->reg_set;
531  * @instance:		Adapter soft state
537 megasas_fire_cmd_xscale(struct megasas_instance *instance,
544 	spin_lock_irqsave(&instance->hba_lock, flags);
547 	spin_unlock_irqrestore(&instance->hba_lock, flags);
552  * @instance:	Adapter soft state
556 megasas_adp_reset_xscale(struct megasas_instance *instance,
567 	pci_read_config_dword(instance->pdev, MFI_1068_PCSR_OFFSET, &pcidata);
568 	dev_notice(&instance->pdev->dev, "pcidata = %x\n", pcidata);
570 		dev_notice(&instance->pdev->dev, "mfi 1068 offset read=%x\n", pcidata);
572 		pci_write_config_dword(instance->pdev,
579 		pci_read_config_dword(instance->pdev,
581 		dev_notice(&instance->pdev->dev, "1068 offset handshake read=%x\n", pcidata);
583 			dev_notice(&instance->pdev->dev, "1068 offset pcidt=%x\n", pcidata);
585 			pci_write_config_dword(instance->pdev,
594  * @instance:	Adapter soft state
598 megasas_check_reset_xscale(struct megasas_instance *instance,
601 	if ((atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) &&
602 	    (le32_to_cpu(*instance->consumer) ==
636  * @instance:	Adapter soft state
639 megasas_enable_intr_ppc(struct megasas_instance *instance)
643 	regs = instance->reg_set;
654  * @instance:	Adapter soft state
657 megasas_disable_intr_ppc(struct megasas_instance *instance)
662 	regs = instance->reg_set;
670  * @instance:	Adapter soft state
673 megasas_read_fw_status_reg_ppc(struct megasas_instance *instance)
675 	return readl(&instance->reg_set->outbound_scratch_pad_0);
680  * @instance:	Adapter soft state
683 megasas_clear_intr_ppc(struct megasas_instance *instance)
687 	regs = instance->reg_set;
713  * @instance:		Adapter soft state
719 megasas_fire_cmd_ppc(struct megasas_instance *instance,
726 	spin_lock_irqsave(&instance->hba_lock, flags);
729 	spin_unlock_irqrestore(&instance->hba_lock, flags);
734  * @instance:	Adapter soft state
738 megasas_check_reset_ppc(struct megasas_instance *instance,
741 	if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
765  * @instance:	Adapter soft state
768 megasas_enable_intr_skinny(struct megasas_instance *instance)
772 	regs = instance->reg_set;
783  * @instance:	Adapter soft state
786 megasas_disable_intr_skinny(struct megasas_instance *instance)
791 	regs = instance->reg_set;
799  * @instance:	Adapter soft state
802 megasas_read_fw_status_reg_skinny(struct megasas_instance *instance)
804 	return readl(&instance->reg_set->outbound_scratch_pad_0);
809  * @instance:	Adapter soft state
812 megasas_clear_intr_skinny(struct megasas_instance *instance)
817 	regs = instance->reg_set;
831 	if ((megasas_read_fw_status_reg_skinny(instance) & MFI_STATE_MASK) ==
852  * @instance:		Adapter soft state
858 megasas_fire_cmd_skinny(struct megasas_instance *instance,
865 	spin_lock_irqsave(&instance->hba_lock, flags);
870 	spin_unlock_irqrestore(&instance->hba_lock, flags);
875  * @instance:	Adapter soft state
879 megasas_check_reset_skinny(struct megasas_instance *instance,
882 	if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
912  * @instance:	Adapter soft state
915 megasas_enable_intr_gen2(struct megasas_instance *instance)
919 	regs = instance->reg_set;
931  * @instance:	Adapter soft state
934 megasas_disable_intr_gen2(struct megasas_instance *instance)
939 	regs = instance->reg_set;
947  * @instance:	Adapter soft state
950 megasas_read_fw_status_reg_gen2(struct megasas_instance *instance)
952 	return readl(&instance->reg_set->outbound_scratch_pad_0);
957  * @instance:	Adapter soft state
960 megasas_clear_intr_gen2(struct megasas_instance *instance)
965 	regs = instance->reg_set;
993  * @instance:		Adapter soft state
999 megasas_fire_cmd_gen2(struct megasas_instance *instance,
1006 	spin_lock_irqsave(&instance->hba_lock, flags);
1009 	spin_unlock_irqrestore(&instance->hba_lock, flags);
1014  * @instance:	Adapter soft state
1018 megasas_adp_reset_gen2(struct megasas_instance *instance,
1026 	if (instance->instancet == &megasas_instance_template_skinny) {
1045 		dev_notice(&instance->pdev->dev, "RESETGEN2: retry=%x, hostdiag=%x\n",
1053 	dev_notice(&instance->pdev->dev, "ADP_RESET_GEN2: HostDiag=%x\n", HostDiag);
1063 		dev_notice(&instance->pdev->dev, "RESET_GEN2: retry=%x, hostdiag=%x\n",
1075  * @instance:	Adapter soft state
1079 megasas_check_reset_gen2(struct megasas_instance *instance,
1082 	if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
1116  * @instance:			Adapter soft state
1122 megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
1129 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
1130 		dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1135 	instance->instancet->issue_dcmd(instance, cmd);
1137 	return wait_and_poll(instance, cmd, instance->requestorId ?
1143  * @instance:			Adapter soft state
1152 megasas_issue_blocked_cmd(struct megasas_instance *instance,
1158 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
1159 		dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1164 	instance->instancet->issue_dcmd(instance, cmd);
1167 		ret = wait_event_timeout(instance->int_cmd_wait_q,
1170 			dev_err(&instance->pdev->dev,
1176 		wait_event(instance->int_cmd_wait_q,
1184  * @instance:				Adapter soft state
1194 megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
1202 	cmd = megasas_get_cmd(instance);
1224 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
1225 		dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1230 	instance->instancet->issue_dcmd(instance, cmd);
1233 		ret = wait_event_timeout(instance->abort_cmd_wait_q,
1237 			dev_err(&instance->pdev->dev,
1243 		wait_event(instance->abort_cmd_wait_q,
1248 	megasas_return_cmd(instance, cmd);
1254  * @instance:		Adapter soft state
1262 megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp,
1283  * @instance:		Adapter soft state
1291 megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
1312  * @instance:           Adapter soft state
1320 megasas_make_sgl_skinny(struct megasas_instance *instance,
1349 static u32 megasas_get_frame_count(struct megasas_instance *instance,
1360 	if (instance->flag_ieee) {
1371 		if (instance->flag_ieee == 1) {
1378 		if (instance->flag_ieee == 1) {
1402  * @instance:		Adapter soft state
1410 megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
1429 	if (instance->flag_ieee == 1) {
1463 	if (instance->flag_ieee == 1) {
1465 		pthru->sge_count = megasas_make_sgl_skinny(instance, scp,
1469 		pthru->sge_count = megasas_make_sgl64(instance, scp,
1472 		pthru->sge_count = megasas_make_sgl32(instance, scp,
1475 	if (pthru->sge_count > instance->max_num_sge) {
1476 		dev_err(&instance->pdev->dev, "DCDB too many SGE NUM=%x\n",
1494 	cmd->frame_count = megasas_get_frame_count(instance, pthru->sge_count,
1502  * @instance:		Adapter soft state
1509 megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
1525 	if (instance->flag_ieee == 1) {
1606 	if (instance->flag_ieee) {
1608 		ldio->sge_count = megasas_make_sgl_skinny(instance, scp,
1612 		ldio->sge_count = megasas_make_sgl64(instance, scp, &ldio->sgl);
1614 		ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl);
1616 	if (ldio->sge_count > instance->max_num_sge) {
1617 		dev_err(&instance->pdev->dev, "build_ld_io: sge_count = %x\n",
1633 	cmd->frame_count = megasas_get_frame_count(instance,
1671  * @instance:				Adapter soft state
1674 megasas_dump_pending_frames(struct megasas_instance *instance)
1682 	u16 max_cmd = instance->max_fw_cmds;
1684 	dev_err(&instance->pdev->dev, "[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance->host->host_no);
1685 	dev_err(&instance->pdev->dev, "[%d]: Total OS Pending cmds : %d\n",instance->host->host_no,atomic_read(&instance->fw_outstanding));
1687 		dev_err(&instance->pdev->dev, "[%d]: 64 bit SGLs were sent to FW\n",instance->host->host_no);
1689 		dev_err(&instance->pdev->dev, "[%d]: 32 bit SGLs were sent to FW\n",instance->host->host_no);
1691 	dev_err(&instance->pdev->dev, "[%d]: Pending OS cmds in FW : \n",instance->host->host_no);
1693 		cmd = instance->cmd_list[i];
1696 		dev_err(&instance->pdev->dev, "[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);
1701 			dev_err(&instance->pdev->dev, "[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x,"
1703 			instance->host->host_no, cmd->frame_count, ldio->cmd, ldio->target_id,
1710 			dev_err(&instance->pdev->dev, "[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x, "
1712 			instance->host->host_no, cmd->frame_count, pthru->cmd, pthru->target_id,
1719 					dev_err(&instance->pdev->dev, "sgl len : 0x%x, sgl addr : 0x%llx\n",
1723 					dev_err(&instance->pdev->dev, "sgl len : 0x%x, sgl addr : 0x%x\n",
1729 	dev_err(&instance->pdev->dev, "[%d]: Pending Internal cmds in FW : \n",instance->host->host_no);
1732 		cmd = instance->cmd_list[i];
1735 			dev_err(&instance->pdev->dev, "0x%08lx : ", (unsigned long)cmd->frame_phys_addr);
1737 	dev_err(&instance->pdev->dev, "[%d]: Dumping Done\n\n",instance->host->host_no);
1741 megasas_build_and_issue_cmd(struct megasas_instance *instance,
1747 	cmd = megasas_get_cmd(instance);
1755 		frame_count = megasas_build_ldio(instance, scmd, cmd);
1757 		frame_count = megasas_build_dcdb(instance, scmd, cmd);
1768 	atomic_inc(&instance->fw_outstanding);
1770 	instance->instancet->fire_cmd(instance, cmd->frame_phys_addr,
1771 				cmd->frame_count-1, instance->reg_set);
1775 	megasas_return_cmd(instance, cmd);
1788 	struct megasas_instance *instance;
1792 	instance = (struct megasas_instance *)
1795 	if (instance->unload == 1) {
1801 	if (instance->issuepend_done == 0)
1806 	if (atomic_read(&instance->adprecovery) == MEGASAS_ADPRESET_SM_INFAULT) {
1807 		if (megasas_check_mpio_paths(instance, scmd) ==
1819 	    (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)) {
1827 		if (instance->ld_tgtid_status[ld_tgt_id] == LD_TARGET_ID_DELETED) {
1834 	if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
1844 	    (scmd->device->id >= instance->fw_supported_vd_count ||
1852 	    (!instance->fw_sync_cache_support)) {
1857 	return instance->instancet->build_and_issue_cmd(instance, scmd);
1870 		if ((megasas_mgmt_info.instance[i]) &&
1871 		    (megasas_mgmt_info.instance[i]->host->host_no == host_no))
1872 			return megasas_mgmt_info.instance[i];
1895 	struct megasas_instance *instance;
1902 	instance = megasas_lookup_instance(sdev->host->host_no);
1903 	fusion = instance->ctrl_context;
1912 		local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
1914 		if (ld >= instance->fw_supported_vd_count)
1927 	} else if (instance->use_seqnum_jbod_fp) {
1931 				[(instance->pd_seq_map_id - 1) & 1];
1936 	if (is_target_prop && instance->tgt_prop->reset_tmo) {
1942 			min_t(u8, instance->max_reset_tmo,
1943 			      instance->tgt_prop->reset_tmo);
1944 		mr_device_priv_data->task_abort_tmo = instance->task_abort_tmo;
1972 	struct megasas_instance *instance;
1975 	instance = (struct megasas_instance *)sdev->host->hostdata;
1976 	mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
1999 	struct megasas_instance *instance;
2002 	instance = megasas_lookup_instance(sdev->host->host_no);
2019 		tgt_device_qd = le32_to_cpu(instance->tgt_prop->device_qdepth);
2021 			device_qd = min(instance->host->can_queue,
2025 	if (instance->enable_sdev_max_qd && interface_type != UNKNOWN_DRIVE)
2026 		device_qd = instance->host->can_queue;
2047 	struct megasas_instance *instance;
2049 	instance = megasas_lookup_instance(sdev->host->host_no);
2060 		max_io_size_kb = le32_to_cpu(instance->tgt_prop->max_io_size_kb);
2062 	if (instance->nvme_page_size && max_io_size_kb)
2072 	struct megasas_instance *instance;
2076 	instance = megasas_lookup_instance(sdev->host->host_no);
2077 	if (instance->pd_list_not_supported) {
2081 			if (instance->pd_list[pd_index].driveState !=
2087 	mutex_lock(&instance->reset_mutex);
2089 	if ((instance->pd_info) && !MEGASAS_IS_LOGICAL(sdev))
2090 		megasas_get_pd_info(instance, sdev);
2092 	/* Some ventura firmware may not have instance->nvme_page_size set.
2095 	if ((instance->tgt_prop) && (instance->nvme_page_size))
2096 		ret_target_prop = megasas_get_target_prop(instance, sdev);
2104 	mutex_unlock(&instance->reset_mutex);
2112 	struct megasas_instance *instance ;
2115 	instance = megasas_lookup_instance(sdev->host->host_no);
2123 		if ((instance->pd_list_not_supported ||
2124 			instance->pd_list[pd_index].driveState ==
2142 		instance->ld_tgtid_status[ld_tgt_id] = LD_TARGET_ID_ACTIVE;
2150 		   instance->r1_ldio_hint_default);
2157 	struct megasas_instance *instance;
2159 	instance = megasas_lookup_instance(sdev->host->host_no);
2167 		instance->ld_tgtid_status[ld_tgt_id] = LD_TARGET_ID_DELETED;
2180 * @instance:				Adapter soft state
2183 static void megasas_complete_outstanding_ioctls(struct megasas_instance *instance)
2188 	struct fusion_context *fusion = instance->ctrl_context;
2192 		for (i = 0; i < instance->max_fw_cmds; i++) {
2195 				cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
2200 					megasas_complete_cmd(instance,
2206 		for (i = 0; i < instance->max_fw_cmds; i++) {
2207 			cmd_mfi = instance->cmd_list[i];
2210 				megasas_complete_cmd(instance, cmd_mfi, DID_OK);
2216 void megaraid_sas_kill_hba(struct megasas_instance *instance)
2218 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2219 		dev_warn(&instance->pdev->dev,
2225 	atomic_set(&instance->adprecovery, MEGASAS_HW_CRITICAL_ERROR);
2228 	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2229 		(instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
2230 		(instance->adapter_type != MFI_SERIES)) {
2231 		if (!instance->requestorId) {
2232 			writel(MFI_STOP_ADP, &instance->reg_set->doorbell);
2234 			readl(&instance->reg_set->doorbell);
2236 		if (instance->requestorId && instance->peerIsPresent)
2237 			memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
2240 			&instance->reg_set->inbound_doorbell);
2243 	megasas_complete_outstanding_ioctls(instance);
2249   * @instance:			Adapter soft state
2253 megasas_check_and_restore_queue_depth(struct megasas_instance *instance)
2257 	if (instance->flag & MEGASAS_FW_BUSY
2258 	    && time_after(jiffies, instance->last_time + 5 * HZ)
2259 	    && atomic_read(&instance->fw_outstanding) <
2260 	    instance->throttlequeuedepth + 1) {
2262 		spin_lock_irqsave(instance->host->host_lock, flags);
2263 		instance->flag &= ~MEGASAS_FW_BUSY;
2265 		instance->host->can_queue = instance->cur_can_queue;
2266 		spin_unlock_irqrestore(instance->host->host_lock, flags);
2282 	struct megasas_instance *instance =
2287 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
2290 	spin_lock_irqsave(&instance->completion_lock, flags);
2292 	producer = le32_to_cpu(*instance->producer);
2293 	consumer = le32_to_cpu(*instance->consumer);
2296 		context = le32_to_cpu(instance->reply_queue[consumer]);
2297 		if (context >= instance->max_fw_cmds) {
2298 			dev_err(&instance->pdev->dev, "Unexpected context value %x\n",
2303 		cmd = instance->cmd_list[context];
2305 		megasas_complete_cmd(instance, cmd, DID_OK);
2308 		if (consumer == (instance->max_fw_cmds + 1)) {
2313 	*instance->consumer = cpu_to_le32(producer);
2315 	spin_unlock_irqrestore(&instance->completion_lock, flags);
2320 	megasas_check_and_restore_queue_depth(instance);
2327  * @instance:		Adapter soft state
2330 void megasas_start_timer(struct megasas_instance *instance)
2332 	struct timer_list *timer = &instance->sriov_heartbeat_timer;
2340 megasas_internal_reset_defer_cmds(struct megasas_instance *instance);
2345 static void megasas_do_ocr(struct megasas_instance *instance)
2347 	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
2348 	(instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
2349 	(instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
2350 		*instance->consumer = cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
2352 	instance->instancet->disable_intr(instance);
2353 	atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
2354 	instance->issuepend_done = 0;
2356 	atomic_set(&instance->fw_outstanding, 0);
2357 	megasas_internal_reset_defer_cmds(instance);
2358 	process_fw_state_change_wq(&instance->work_init);
2361 static int megasas_get_ld_vf_affiliation_111(struct megasas_instance *instance,
2371 	cmd = megasas_get_cmd(instance);
2374 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_vf_affiliation_111:"
2376 			instance->host->host_no);
2382 	if (!instance->vf_affiliation_111) {
2383 		dev_warn(&instance->pdev->dev, "SR-IOV: Couldn't get LD/VF "
2384 		       "affiliation for scsi%d\n", instance->host->host_no);
2385 		megasas_return_cmd(instance, cmd);
2390 			memset(instance->vf_affiliation_111, 0,
2394 			dma_alloc_coherent(&instance->pdev->dev,
2398 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
2400 			       instance->host->host_no);
2401 			megasas_return_cmd(instance, cmd);
2420 			cpu_to_le32(instance->vf_affiliation_111_h);
2428 	dev_warn(&instance->pdev->dev, "SR-IOV: Getting LD/VF affiliation for "
2429 	       "scsi%d\n", instance->host->host_no);
2431 	if (megasas_issue_blocked_cmd(instance, cmd, 0) != DCMD_SUCCESS) {
2432 		dev_warn(&instance->pdev->dev, "SR-IOV: LD/VF affiliation DCMD"
2434 		       dcmd->cmd_status, instance->host->host_no);
2442 			if (instance->vf_affiliation_111->map[ld].policy[thisVf] !=
2444 				dev_warn(&instance->pdev->dev, "SR-IOV: "
2446 				       instance->host->host_no);
2447 				memcpy(instance->vf_affiliation_111,
2456 		dma_free_coherent(&instance->pdev->dev,
2462 	megasas_return_cmd(instance, cmd);
2467 static int megasas_get_ld_vf_affiliation_12(struct megasas_instance *instance,
2478 	cmd = megasas_get_cmd(instance);
2481 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_vf_affiliation12: "
2483 		       instance->host->host_no);
2489 	if (!instance->vf_affiliation) {
2490 		dev_warn(&instance->pdev->dev, "SR-IOV: Couldn't get LD/VF "
2491 		       "affiliation for scsi%d\n", instance->host->host_no);
2492 		megasas_return_cmd(instance, cmd);
2497 		memset(instance->vf_affiliation, 0, (MAX_LOGICAL_DRIVES + 1) *
2501 			dma_alloc_coherent(&instance->pdev->dev,
2505 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
2507 			       instance->host->host_no);
2508 			megasas_return_cmd(instance, cmd);
2527 			cpu_to_le32(instance->vf_affiliation_h);
2535 	dev_warn(&instance->pdev->dev, "SR-IOV: Getting LD/VF affiliation for "
2536 	       "scsi%d\n", instance->host->host_no);
2539 	if (megasas_issue_blocked_cmd(instance, cmd, 0) != DCMD_SUCCESS) {
2540 		dev_warn(&instance->pdev->dev, "SR-IOV: LD/VF affiliation DCMD"
2542 		       dcmd->cmd_status, instance->host->host_no);
2549 			dev_warn(&instance->pdev->dev, "SR-IOV: Got new LD/VF "
2551 			       instance->host->host_no);
2556 		savedmap = instance->vf_affiliation->map;
2560 			for (j = 0; j < instance->vf_affiliation->ldCount;
2585 		savedmap = instance->vf_affiliation->map;
2587 		for (i = 0 ; i < instance->vf_affiliation->ldCount; i++) {
2615 		dev_warn(&instance->pdev->dev, "SR-IOV: Got new LD/VF "
2616 		       "affiliation for scsi%d\n", instance->host->host_no);
2617 		memcpy(instance->vf_affiliation, new_affiliation,
2623 		dma_free_coherent(&instance->pdev->dev,
2627 	megasas_return_cmd(instance, cmd);
2633 static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,
2638 	if (instance->PlasmaFW111)
2639 		retval = megasas_get_ld_vf_affiliation_111(instance, initial);
2641 		retval = megasas_get_ld_vf_affiliation_12(instance, initial);
2646 int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
2653 	cmd = megasas_get_cmd(instance);
2656 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_sriov_start_heartbeat: "
2658 		       instance->host->host_no);
2665 		instance->hb_host_mem =
2666 			dma_alloc_coherent(&instance->pdev->dev,
2668 					   &instance->hb_host_mem_h,
2670 		if (!instance->hb_host_mem) {
2671 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate"
2673 			       instance->host->host_no);
2691 	megasas_set_dma_settings(instance, dcmd, instance->hb_host_mem_h,
2694 	dev_warn(&instance->pdev->dev, "SR-IOV: Starting heartbeat for scsi%d\n",
2695 	       instance->host->host_no);
2697 	if ((instance->adapter_type != MFI_SERIES) &&
2698 	    !instance->mask_interrupts)
2699 		retval = megasas_issue_blocked_cmd(instance, cmd,
2702 		retval = megasas_issue_polled(instance, cmd);
2705 		dev_warn(&instance->pdev->dev, "SR-IOV: MR_DCMD_CTRL_SHARED_HOST"
2708 			"timed out" : "failed", instance->host->host_no);
2713 	megasas_return_cmd(instance, cmd);
2721 	struct megasas_instance *instance =
2722 		from_timer(instance, t, sriov_heartbeat_timer);
2724 	if (instance->hb_host_mem->HB.fwCounter !=
2725 	    instance->hb_host_mem->HB.driverCounter) {
2726 		instance->hb_host_mem->HB.driverCounter =
2727 			instance->hb_host_mem->HB.fwCounter;
2728 		mod_timer(&instance->sriov_heartbeat_timer,
2731 		dev_warn(&instance->pdev->dev, "SR-IOV: Heartbeat never "
2732 		       "completed for scsi%d\n", instance->host->host_no);
2733 		schedule_work(&instance->work_init);
2739  * @instance:				Adapter soft state
2745 static int megasas_wait_for_outstanding(struct megasas_instance *instance)
2755 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2756 		dev_info(&instance->pdev->dev, "%s:%d HBA is killed.\n",
2761 	if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
2764 		spin_lock_irqsave(&instance->hba_lock, flags);
2765 		list_splice_init(&instance->internal_reset_pending_q,
2767 		spin_unlock_irqrestore(&instance->hba_lock, flags);
2769 		dev_notice(&instance->pdev->dev, "HBA reset wait ...\n");
2772 			if (atomic_read(&instance->adprecovery) == MEGASAS_HBA_OPERATIONAL)
2776 		if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
2777 			dev_notice(&instance->pdev->dev, "reset: Stopping HBA.\n");
2778 			atomic_set(&instance->adprecovery, MEGASAS_HW_CRITICAL_ERROR);
2789 				dev_notice(&instance->pdev->dev, "%d:%p reset [%02x]\n",
2794 				megasas_return_cmd(instance, reset_cmd);
2796 				dev_notice(&instance->pdev->dev, "%p synch cmds"
2801 				instance->instancet->fire_cmd(instance,
2803 						0, instance->reg_set);
2805 				dev_notice(&instance->pdev->dev, "%p unexpected"
2816 		outstanding = atomic_read(&instance->fw_outstanding);
2822 			dev_notice(&instance->pdev->dev, "[%2d]waiting for %d "
2828 			megasas_complete_cmd_dpc((unsigned long)instance);
2835 	outstanding = atomic_read(&instance->fw_outstanding);
2836 	fw_state = instance->instancet->read_fw_status_reg(instance) & MFI_STATE_MASK;
2841 	if (instance->disableOnlineCtrlReset)
2844 		if ((fw_state == MFI_STATE_FAULT) || atomic_read(&instance->fw_outstanding)) {
2845 			dev_info(&instance->pdev->dev,
2847 				__func__, __LINE__, fw_state, atomic_read(&instance->fw_outstanding));
2850 			megasas_do_ocr(instance);
2852 			if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2853 				dev_info(&instance->pdev->dev, "%s:%d OCR failed and HBA is killed.\n",
2857 			dev_info(&instance->pdev->dev, "%s:%d waiting_for_outstanding: after issue OCR.\n",
2863 			outstanding = atomic_read(&instance->fw_outstanding);
2865 			fw_state = instance->instancet->read_fw_status_reg(instance) & MFI_STATE_MASK;
2874 	dev_info(&instance->pdev->dev, "%s:%d no more pending commands remain after reset handling.\n",
2881 	dev_info(&instance->pdev->dev, "%s:%d killing adapter scsi%d"
2883 		__func__, __LINE__, instance->host->host_no, instance->disableOnlineCtrlReset,
2884 		atomic_read(&instance->fw_outstanding));
2885 	megasas_dump_pending_frames(instance);
2886 	megaraid_sas_kill_hba(instance);
2902 	struct megasas_instance *instance;
2904 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
2909 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2910 		dev_err(&instance->pdev->dev, "cannot recover from previous reset failures\n");
2914 	ret_val = megasas_wait_for_outstanding(instance);
2916 		dev_notice(&instance->pdev->dev, "reset successful\n");
2918 		dev_err(&instance->pdev->dev, "failed to do reset\n");
2932 	struct megasas_instance *instance;
2940 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
2941 	if (!(instance->flag & MEGASAS_FW_BUSY)) {
2943 		spin_lock_irqsave(instance->host->host_lock, flags);
2945 		instance->host->can_queue = instance->throttlequeuedepth;
2946 		instance->last_time = jiffies;
2947 		instance->flag |= MEGASAS_FW_BUSY;
2949 		spin_unlock_irqrestore(instance->host->host_lock, flags);
3003 	struct megasas_instance *instance;
3005 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3026 			     instance->max_chain_frame_sz, 8);
3062 	struct megasas_instance *instance;
3064 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3073 		atomic_read(&instance->fw_outstanding));
3077 	if (instance->adapter_type == MFI_SERIES) {
3096 	struct megasas_instance *instance;
3098 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3100 	if (instance->adapter_type != MFI_SERIES)
3118 	struct megasas_instance *instance;
3120 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3122 	if (instance->adapter_type != MFI_SERIES)
3178 	struct megasas_instance *instance;
3182 	instance = (struct megasas_instance *)shost->hostdata;
3187 	offset = instance->low_latency_index_start;
3191 	map->nr_queues = instance->msix_vectors - offset;
3193 	blk_mq_pci_map_queues(map, instance->pdev, offset);
3202 	map->nr_queues = instance->iopoll_q_count;
3217  * @instance:			Adapter soft state
3228 megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
3235 	if ((!cmd->abort_aen) && (instance->unload == 0)) {
3245 	instance->aen_cmd = NULL;
3247 	megasas_return_cmd(instance, cmd);
3249 	if ((instance->unload == 0) &&
3250 		((instance->issuepend_done == 1))) {
3255 			dev_err(&instance->pdev->dev, "megasas_service_aen: out of memory\n");
3257 			ev->instance = instance;
3258 			instance->ev = ev;
3271 	struct megasas_instance *instance =
3278 	mutex_lock(&instance->crashdump_lock);
3279 	instance->fw_crash_buffer_offset = val;
3280 	mutex_unlock(&instance->crashdump_lock);
3289 	struct megasas_instance *instance =
3297 	mutex_lock(&instance->crashdump_lock);
3298 	buff_offset = instance->fw_crash_buffer_offset;
3299 	if (!instance->crash_dump_buf ||
3300 		!((instance->fw_crash_state == AVAILABLE) ||
3301 		(instance->fw_crash_state == COPYING))) {
3302 		dev_err(&instance->pdev->dev,
3304 		mutex_unlock(&instance->crashdump_lock);
3308 	if (buff_offset > (instance->fw_crash_buffer_size * dmachunk)) {
3309 		dev_err(&instance->pdev->dev,
3311 		mutex_unlock(&instance->crashdump_lock);
3315 	size = (instance->fw_crash_buffer_size * dmachunk) - buff_offset;
3320 	src_addr = (unsigned long)instance->crash_buf[buff_offset / dmachunk] +
3323 	mutex_unlock(&instance->crashdump_lock);
3333 	struct megasas_instance *instance =
3337 		((instance->fw_crash_buffer_size) * 1024 * 1024)/PAGE_SIZE);
3345 	struct megasas_instance *instance =
3353 		dev_err(&instance->pdev->dev, "application updates invalid "
3358 	instance->fw_crash_state = val;
3361 		mutex_lock(&instance->crashdump_lock);
3362 		megasas_free_host_crash_buffer(instance);
3363 		mutex_unlock(&instance->crashdump_lock);
3365 			dev_info(&instance->pdev->dev, "application failed to "
3368 			dev_info(&instance->pdev->dev, "Firmware crash dump "
3379 	struct megasas_instance *instance =
3382 	return snprintf(buf, PAGE_SIZE, "%d\n", instance->fw_crash_state);
3397 	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3399 	return snprintf(buf, PAGE_SIZE, "%d\n", atomic_read(&instance->ldio_outstanding));
3407 	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3409 	return snprintf(buf, PAGE_SIZE, "%d\n", atomic_read(&instance->fw_outstanding));
3417 	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3419 	return snprintf(buf, PAGE_SIZE, "%d\n", instance->enable_sdev_max_qd);
3427 	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3438 	mutex_lock(&instance->reset_mutex);
3440 		instance->enable_sdev_max_qd = true;
3442 		instance->enable_sdev_max_qd = false;
3445 		ret_target_prop = megasas_get_target_prop(instance, sdev);
3449 	mutex_unlock(&instance->reset_mutex);
3459 	struct megasas_instance *instance =
3462 	return megasas_dump_sys_regs(instance->reg_set, buf);
3470 	struct megasas_instance *instance =
3474 			(unsigned long)instance->map_id);
3529  * @instance:			Adapter soft state
3537 megasas_complete_int_cmd(struct megasas_instance *instance,
3545 	wake_up(&instance->int_cmd_wait_q);
3550  * @instance:			Adapter soft state
3558 megasas_complete_abort(struct megasas_instance *instance,
3564 		wake_up(&instance->abort_cmd_wait_q);
3569 megasas_set_ld_removed_by_fw(struct megasas_instance *instance)
3574 		if (instance->ld_ids_prev[i] != 0xff &&
3575 		    instance->ld_ids_from_raidmap[i] == 0xff) {
3577 				dev_info(&instance->pdev->dev,
3579 			instance->ld_tgtid_status[i] = LD_TARGET_ID_DELETED;
3586  * @instance:			Adapter soft state
3595 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
3601 	struct fusion_context *fusion = instance->ctrl_context;
3616 		dev_warn(&instance->pdev->dev, "MFI_CMD_INVALID command "
3618 		dev_warn(&instance->pdev->dev, "If you have a controller "
3631 			megasas_complete_int_cmd(instance, cmd);
3646 			atomic_dec(&instance->fw_outstanding);
3650 			megasas_return_cmd(instance, cmd);
3686 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "MFI FW status %#x\n",
3692 		atomic_dec(&instance->fw_outstanding);
3696 		megasas_return_cmd(instance, cmd);
3704 		megasas_complete_int_cmd(instance, cmd);
3713 			spin_lock_irqsave(instance->host->host_lock, flags);
3715 			instance->map_update_cmd = NULL;
3718 					dev_warn(&instance->pdev->dev, "map syncfailed, status = 0x%x\n",
3721 					megasas_return_cmd(instance, cmd);
3723 						instance->host->host_lock,
3729 			megasas_return_cmd(instance, cmd);
3737 			    (MR_ValidateMapInfo(instance, (instance->map_id + 1)))) {
3738 				instance->map_id++;
3744 			if (instance->adapter_type >= INVADER_SERIES)
3745 				megasas_set_ld_removed_by_fw(instance);
3747 			megasas_sync_map_info(instance);
3748 			spin_unlock_irqrestore(instance->host->host_lock,
3764 			spin_lock_irqsave(instance->host->host_lock, flags);
3766 			instance->jbod_seq_cmd = NULL;
3767 			megasas_return_cmd(instance, cmd);
3770 				instance->pd_seq_map_id++;
3772 				if (megasas_sync_pd_seq_num(instance, true))
3773 					instance->use_seqnum_jbod_fp = false;
3775 				instance->use_seqnum_jbod_fp = false;
3777 			spin_unlock_irqrestore(instance->host->host_lock, flags);
3785 			megasas_service_aen(instance, cmd);
3787 			megasas_complete_int_cmd(instance, cmd);
3795 		megasas_complete_abort(instance, cmd);
3799 		dev_info(&instance->pdev->dev, "Unknown command completed! [0x%X]\n",
3801 		megasas_complete_int_cmd(instance, cmd);
3809  * @instance:				Adapter soft state
3812 megasas_issue_pending_cmds_again(struct megasas_instance *instance)
3821 	spin_lock_irqsave(&instance->hba_lock, flags);
3822 	list_splice_init(&instance->internal_reset_pending_q, &clist_local);
3823 	spin_unlock_irqrestore(&instance->hba_lock, flags);
3831 			dev_notice(&instance->pdev->dev, "command %p, %p:%d"
3838 				dev_notice(&instance->pdev->dev, "cmd %p, %p:%d"
3842 				instance->instancet->disable_intr(instance);
3843 				atomic_set(&instance->fw_reset_no_pci_access, 1);
3844 				megaraid_sas_kill_hba(instance);
3851 				dev_notice(&instance->pdev->dev, "unexpected"
3854 			dev_notice(&instance->pdev->dev, "%p synchronous cmd"
3858 			instance->instancet->fire_cmd(instance,
3860 							0, instance->reg_set);
3862 			dev_notice(&instance->pdev->dev, "%p scsi cmd [%02x]"
3866 			atomic_inc(&instance->fw_outstanding);
3867 			instance->instancet->fire_cmd(instance,
3869 					cmd->frame_count-1, instance->reg_set);
3871 			dev_notice(&instance->pdev->dev, "%p unexpected cmd on the"
3877 	if (instance->aen_cmd) {
3878 		dev_notice(&instance->pdev->dev, "aen_cmd in def process\n");
3879 		megasas_return_cmd(instance, instance->aen_cmd);
3881 		instance->aen_cmd = NULL;
3887 	seq_num = instance->last_seq_num;
3892 	megasas_register_aen(instance, seq_num, class_locale.word);
3905 megasas_internal_reset_defer_cmds(struct megasas_instance *instance)
3909 	u16 max_cmd = instance->max_fw_cmds;
3914 	spin_lock_irqsave(&instance->mfi_pool_lock, flags);
3916 		cmd = instance->cmd_list[i];
3918 			dev_notice(&instance->pdev->dev, "moving cmd[%d]:%p:%d:%p"
3923 				dev_notice(&instance->pdev->dev, "ERROR while"
3932 				&instance->internal_reset_pending_q);
3935 	spin_unlock_irqrestore(&instance->mfi_pool_lock, flags);
3942 	struct megasas_instance *instance =
3947 	if (atomic_read(&instance->adprecovery) != MEGASAS_ADPRESET_SM_INFAULT) {
3948 		dev_notice(&instance->pdev->dev, "error, recovery st %x\n",
3949 			   atomic_read(&instance->adprecovery));
3953 	if (atomic_read(&instance->adprecovery) == MEGASAS_ADPRESET_SM_INFAULT) {
3954 		dev_notice(&instance->pdev->dev, "FW detected to be in fault"
3957 		instance->instancet->disable_intr(instance);
3958 		atomic_set(&instance->fw_outstanding, 0);
3960 		atomic_set(&instance->fw_reset_no_pci_access, 1);
3961 		instance->instancet->adp_reset(instance, instance->reg_set);
3962 		atomic_set(&instance->fw_reset_no_pci_access, 0);
3964 		dev_notice(&instance->pdev->dev, "FW restarted successfully,"
3967 		dev_notice(&instance->pdev->dev, "HBA recovery state machine,"
3975 		if (megasas_transition_to_ready(instance, 1)) {
3976 			dev_notice(&instance->pdev->dev, "adapter not ready\n");
3978 			atomic_set(&instance->fw_reset_no_pci_access, 1);
3979 			megaraid_sas_kill_hba(instance);
3983 		if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
3984 			(instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
3985 			(instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)
3987 			*instance->consumer = *instance->producer;
3989 			*instance->consumer = 0;
3990 			*instance->producer = 0;
3993 		megasas_issue_init_mfi(instance);
3995 		spin_lock_irqsave(&instance->hba_lock, flags);
3996 		atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
3997 		spin_unlock_irqrestore(&instance->hba_lock, flags);
3998 		instance->instancet->enable_intr(instance);
4000 		megasas_issue_pending_cmds_again(instance);
4001 		instance->issuepend_done = 1;
4007  * @instance:				Adapter soft state
4014 megasas_deplete_reply_queue(struct megasas_instance *instance,
4020 	if (instance->instancet->check_reset(instance, instance->reg_set) == 1)
4023 	mfiStatus = instance->instancet->clear_intr(instance);
4026 		if (!instance->msix_vectors)
4030 	instance->mfiStatus = mfiStatus;
4033 		fw_state = instance->instancet->read_fw_status_reg(
4034 				instance) & MFI_STATE_MASK;
4037 			dev_notice(&instance->pdev->dev, "fw state:%x\n",
4042 				(instance->disableOnlineCtrlReset == 0)) {
4043 			dev_notice(&instance->pdev->dev, "wait adp restart\n");
4045 			if ((instance->pdev->device ==
4047 				(instance->pdev->device ==
4049 				(instance->pdev->device ==
4052 				*instance->consumer =
4057 			instance->instancet->disable_intr(instance);
4058 			atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
4059 			instance->issuepend_done = 0;
4061 			atomic_set(&instance->fw_outstanding, 0);
4062 			megasas_internal_reset_defer_cmds(instance);
4064 			dev_notice(&instance->pdev->dev, "fwState=%x, stage:%d\n",
4065 					fw_state, atomic_read(&instance->adprecovery));
4067 			schedule_work(&instance->work_init);
4071 			dev_notice(&instance->pdev->dev, "fwstate:%x, dis_OCR=%x\n",
4072 				fw_state, instance->disableOnlineCtrlReset);
4076 	tasklet_schedule(&instance->isr_tasklet);
4088 	struct megasas_instance *instance = irq_context->instance;
4092 	if (atomic_read(&instance->fw_reset_no_pci_access))
4095 	spin_lock_irqsave(&instance->hba_lock, flags);
4096 	rc = megasas_deplete_reply_queue(instance, DID_OK);
4097 	spin_unlock_irqrestore(&instance->hba_lock, flags);
4104  * @instance:				Adapter soft state
4113 megasas_transition_to_ready(struct megasas_instance *instance, int ocr)
4120 	abs_state = instance->instancet->read_fw_status_reg(instance);
4124 		dev_info(&instance->pdev->dev, "Waiting for FW to come to ready"
4132 			dev_printk(KERN_ERR, &instance->pdev->dev,
4140 				dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4141 				megasas_dump_reg_set(instance->reg_set);
4149 			if ((instance->pdev->device ==
4151 				(instance->pdev->device ==
4153 				(instance->adapter_type != MFI_SERIES))
4156 				  &instance->reg_set->doorbell);
4160 					&instance->reg_set->inbound_doorbell);
4166 			if ((instance->pdev->device ==
4168 				(instance->pdev->device ==
4170 				(instance->adapter_type != MFI_SERIES))
4172 				       &instance->reg_set->doorbell);
4175 					&instance->reg_set->inbound_doorbell);
4184 			instance->instancet->disable_intr(instance);
4185 			if ((instance->pdev->device ==
4187 				(instance->pdev->device ==
4189 				(instance->adapter_type != MFI_SERIES)) {
4191 					&instance->reg_set->doorbell);
4193 				if (instance->adapter_type != MFI_SERIES) {
4196 							    instance,
4197 							    &instance->
4207 					&instance->reg_set->inbound_doorbell);
4240 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "Unknown state 0x%x\n",
4242 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4243 			megasas_dump_reg_set(instance->reg_set);
4251 			curr_abs_state = instance->instancet->
4252 				read_fw_status_reg(instance);
4264 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "FW state [%d] hasn't changed "
4266 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4267 			megasas_dump_reg_set(instance->reg_set);
4274 	dev_info(&instance->pdev->dev, "FW now in Ready state\n");
4281  * @instance:				Adapter soft state
4283 static void megasas_teardown_frame_pool(struct megasas_instance *instance)
4286 	u16 max_cmd = instance->max_mfi_cmds;
4289 	if (!instance->frame_dma_pool)
4297 		cmd = instance->cmd_list[i];
4300 			dma_pool_free(instance->frame_dma_pool, cmd->frame,
4304 			dma_pool_free(instance->sense_dma_pool, cmd->sense,
4311 	dma_pool_destroy(instance->frame_dma_pool);
4312 	dma_pool_destroy(instance->sense_dma_pool);
4314 	instance->frame_dma_pool = NULL;
4315 	instance->sense_dma_pool = NULL;
4320  * @instance:			Adapter soft state
4327 static int megasas_create_frame_pool(struct megasas_instance *instance)
4334 	max_cmd = instance->max_mfi_cmds;
4347 	frame_count = (instance->adapter_type == MFI_SERIES) ?
4349 	instance->mfi_frame_size = MEGAMFI_FRAME_SIZE * frame_count;
4353 	instance->frame_dma_pool = dma_pool_create("megasas frame pool",
4354 					&instance->pdev->dev,
4355 					instance->mfi_frame_size, 256, 0);
4357 	if (!instance->frame_dma_pool) {
4358 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup frame pool\n");
4362 	instance->sense_dma_pool = dma_pool_create("megasas sense pool",
4363 						   &instance->pdev->dev, 128,
4366 	if (!instance->sense_dma_pool) {
4367 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup sense pool\n");
4369 		dma_pool_destroy(instance->frame_dma_pool);
4370 		instance->frame_dma_pool = NULL;
4382 		cmd = instance->cmd_list[i];
4384 		cmd->frame = dma_pool_zalloc(instance->frame_dma_pool,
4387 		cmd->sense = dma_pool_alloc(instance->sense_dma_pool,
4395 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "dma_pool_alloc failed\n");
4396 			megasas_teardown_frame_pool(instance);
4402 		if ((instance->adapter_type == MFI_SERIES) && reset_devices)
4411  * @instance:		Adapter soft state
4413 void megasas_free_cmds(struct megasas_instance *instance)
4418 	megasas_teardown_frame_pool(instance);
4421 	for (i = 0; i < instance->max_mfi_cmds; i++)
4423 		kfree(instance->cmd_list[i]);
4426 	kfree(instance->cmd_list);
4427 	instance->cmd_list = NULL;
4429 	INIT_LIST_HEAD(&instance->cmd_pool);
4434  * @instance:		Adapter soft state
4450 int megasas_alloc_cmds(struct megasas_instance *instance)
4457 	max_cmd = instance->max_mfi_cmds;
4460 	 * instance->cmd_list is an array of struct megasas_cmd pointers.
4464 	instance->cmd_list = kcalloc(max_cmd, sizeof(struct megasas_cmd*), GFP_KERNEL);
4466 	if (!instance->cmd_list) {
4467 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "out of memory\n");
4472 		instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd),
4475 		if (!instance->cmd_list[i]) {
4478 				kfree(instance->cmd_list[j]);
4480 			kfree(instance->cmd_list);
4481 			instance->cmd_list = NULL;
4488 		cmd = instance->cmd_list[i];
4492 		cmd->instance = instance;
4494 		list_add_tail(&cmd->list, &instance->cmd_pool);
4500 	if (megasas_create_frame_pool(instance)) {
4501 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Error creating frame DMA pool\n");
4502 		megasas_free_cmds(instance);
4511  * @instance:				Adapter soft state
4517 dcmd_timeout_ocr_possible(struct megasas_instance *instance) {
4519 	if (instance->adapter_type == MFI_SERIES)
4521 	else if (instance->unload ||
4523 				 &instance->reset_flags))
4530 megasas_get_pd_info(struct megasas_instance *instance, struct scsi_device *sdev)
4540 	cmd = megasas_get_cmd(instance);
4543 		dev_err(&instance->pdev->dev, "Failed to get cmd %s\n", __func__);
4549 	memset(instance->pd_info, 0, sizeof(*instance->pd_info));
4562 	megasas_set_dma_settings(instance, dcmd, instance->pd_info_h,
4565 	if ((instance->adapter_type != MFI_SERIES) &&
4566 	    !instance->mask_interrupts)
4567 		ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
4569 		ret = megasas_issue_polled(instance, cmd);
4574 		le16_to_cpus((u16 *)&instance->pd_info->state.ddf.pdType);
4576 				instance->pd_info->state.ddf.pdType.intf;
4581 		switch (dcmd_timeout_ocr_possible(instance)) {
4584 			mutex_unlock(&instance->reset_mutex);
4585 			megasas_reset_fusion(instance->host,
4587 			mutex_lock(&instance->reset_mutex);
4590 			megaraid_sas_kill_hba(instance);
4593 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4602 		megasas_return_cmd(instance, cmd);
4608  * @instance:				Adapter soft state
4616 megasas_get_pd_list(struct megasas_instance *instance)
4624 	if (instance->pd_list_not_supported) {
4625 		dev_info(&instance->pdev->dev, "MR_DCMD_PD_LIST_QUERY "
4630 	ci = instance->pd_list_buf;
4632 	cmd = megasas_get_cmd(instance);
4635 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "(get_pd_list): Failed to get cmd\n");
4655 	megasas_set_dma_settings(instance, dcmd, instance->pd_list_buf_h,
4658 	if ((instance->adapter_type != MFI_SERIES) &&
4659 	    !instance->mask_interrupts)
4660 		ret = megasas_issue_blocked_cmd(instance, cmd,
4663 		ret = megasas_issue_polled(instance, cmd);
4667 		dev_info(&instance->pdev->dev, "MR_DCMD_PD_LIST_QUERY "
4670 		if (instance->adapter_type != MFI_SERIES)
4671 			megaraid_sas_kill_hba(instance);
4673 			instance->pd_list_not_supported = 1;
4677 		switch (dcmd_timeout_ocr_possible(instance)) {
4685 			mutex_unlock(&instance->reset_mutex);
4686 			megasas_reset_fusion(instance->host,
4688 			mutex_lock(&instance->reset_mutex);
4691 			megaraid_sas_kill_hba(instance);
4694 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d \n",
4704 			dev_info(&instance->pdev->dev, "%s, sysPD count: 0x%x\n",
4711 		memset(instance->local_pd_list, 0,
4715 			instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].tid	=
4717 			instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveType	=
4719 			instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveState	=
4722 				dev_info(&instance->pdev->dev,
4729 		memcpy(instance->pd_list, instance->local_pd_list,
4730 			sizeof(instance->pd_list));
4736 		megasas_return_cmd(instance, cmd);
4743  * @instance:				Adapter soft state
4751 megasas_get_ld_list(struct megasas_instance *instance)
4760 	ci = instance->ld_list_buf;
4761 	ci_h = instance->ld_list_buf_h;
4763 	cmd = megasas_get_cmd(instance);
4766 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_list: Failed to get cmd\n");
4775 	if (instance->supportmax256vd)
4786 	megasas_set_dma_settings(instance, dcmd, ci_h,
4789 	if ((instance->adapter_type != MFI_SERIES) &&
4790 	    !instance->mask_interrupts)
4791 		ret = megasas_issue_blocked_cmd(instance, cmd,
4794 		ret = megasas_issue_polled(instance, cmd);
4800 		megaraid_sas_kill_hba(instance);
4804 		switch (dcmd_timeout_ocr_possible(instance)) {
4812 			mutex_unlock(&instance->reset_mutex);
4813 			megasas_reset_fusion(instance->host,
4815 			mutex_lock(&instance->reset_mutex);
4818 			megaraid_sas_kill_hba(instance);
4821 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4830 			dev_info(&instance->pdev->dev, "%s, LD count: 0x%x\n",
4833 		if (ld_count > instance->fw_supported_vd_count)
4836 		memset(instance->ld_ids, 0xff, MAX_LOGICAL_DRIVES_EXT);
4841 				instance->ld_ids[ids] = ci->ldList[ld_index].ref.targetId;
4843 					dev_info(&instance->pdev->dev,
4853 		megasas_return_cmd(instance, cmd);
4860  * @instance:				Adapter soft state
4868 megasas_ld_list_query(struct megasas_instance *instance, u8 query_type)
4877 	ci = instance->ld_targetid_list_buf;
4878 	ci_h = instance->ld_targetid_list_buf_h;
4880 	cmd = megasas_get_cmd(instance);
4883 		dev_warn(&instance->pdev->dev,
4894 	if (instance->supportmax256vd)
4906 	megasas_set_dma_settings(instance, dcmd, ci_h,
4909 	if ((instance->adapter_type != MFI_SERIES) &&
4910 	    !instance->mask_interrupts)
4911 		ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
4913 		ret = megasas_issue_polled(instance, cmd);
4917 		dev_info(&instance->pdev->dev,
4920 		ret = megasas_get_ld_list(instance);
4923 		switch (dcmd_timeout_ocr_possible(instance)) {
4931 			mutex_unlock(&instance->reset_mutex);
4932 			megasas_reset_fusion(instance->host,
4934 			mutex_lock(&instance->reset_mutex);
4937 			megaraid_sas_kill_hba(instance);
4940 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4950 			dev_info(&instance->pdev->dev, "%s, LD count: 0x%x\n",
4953 		if ((tgtid_count > (instance->fw_supported_vd_count)))
4956 		memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
4959 			instance->ld_ids[ids] = ci->targetId[ld_index];
4961 				dev_info(&instance->pdev->dev, "LD%d: targetID: 0x%03x\n",
4969 		megasas_return_cmd(instance, cmd);
4983  * @instance:			Adapter soft state
4989 megasas_host_device_list_query(struct megasas_instance *instance,
4999 	ci = instance->host_device_list_buf;
5000 	ci_h = instance->host_device_list_buf_h;
5002 	cmd = megasas_get_cmd(instance);
5005 		dev_warn(&instance->pdev->dev,
5026 	megasas_set_dma_settings(instance, dcmd, ci_h, HOST_DEVICE_LIST_SZ);
5028 	if (!instance->mask_interrupts) {
5029 		ret = megasas_issue_blocked_cmd(instance, cmd,
5032 		ret = megasas_issue_polled(instance, cmd);
5047 			dev_info(&instance->pdev->dev, "%s, Device count: 0x%x\n",
5050 		memset(instance->local_pd_list, 0,
5052 		memset(instance->ld_ids, 0xff, MAX_LOGICAL_DRIVES_EXT);
5056 				instance->local_pd_list[target_id].tid = target_id;
5057 				instance->local_pd_list[target_id].driveType =
5059 				instance->local_pd_list[target_id].driveState =
5062 					dev_info(&instance->pdev->dev,
5066 				instance->ld_ids[target_id] = target_id;
5068 					dev_info(&instance->pdev->dev,
5074 		memcpy(instance->pd_list, instance->local_pd_list,
5075 		       sizeof(instance->pd_list));
5079 		switch (dcmd_timeout_ocr_possible(instance)) {
5082 			mutex_unlock(&instance->reset_mutex);
5083 			megasas_reset_fusion(instance->host,
5085 			mutex_lock(&instance->reset_mutex);
5088 			megaraid_sas_kill_hba(instance);
5091 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5097 		dev_err(&instance->pdev->dev,
5104 		megasas_return_cmd(instance, cmd);
5111  * instance			 : Controller's instance
5113 static void megasas_update_ext_vd_details(struct megasas_instance *instance)
5118 	fusion = instance->ctrl_context;
5123 	instance->supportmax256vd =
5124 		instance->ctrl_info_buf->adapterOperations3.supportMaxExtLDs;
5126 	if (instance->ctrl_info_buf->max_lds > 64)
5127 		instance->supportmax256vd = 1;
5129 	instance->drv_supported_vd_count = MEGASAS_MAX_LD_CHANNELS
5131 	instance->drv_supported_pd_count = MEGASAS_MAX_PD_CHANNELS
5133 	if (instance->supportmax256vd) {
5134 		instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES_EXT;
5135 		instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
5137 		instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
5138 		instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
5141 	dev_info(&instance->pdev->dev,
5143 		instance->ctrl_info_buf->adapterOperations3.supportMaxExtLDs ? 1 : 0,
5144 		instance->ctrl_info_buf->max_lds);
5146 	if (instance->max_raid_mapsize) {
5147 		ventura_map_sz = instance->max_raid_mapsize *
5154 				      instance->fw_supported_vd_count);
5160 		if (instance->supportmax256vd)
5176 void megasas_get_snapdump_properties(struct megasas_instance *instance)
5184 	ci = instance->snapdump_prop;
5185 	ci_h = instance->snapdump_prop_h;
5190 	cmd = megasas_get_cmd(instance);
5193 		dev_dbg(&instance->pdev->dev, "Failed to get a free cmd\n");
5211 	megasas_set_dma_settings(instance, dcmd, ci_h,
5214 	if (!instance->mask_interrupts) {
5215 		ret = megasas_issue_blocked_cmd(instance, cmd,
5218 		ret = megasas_issue_polled(instance, cmd);
5224 		instance->snapdump_wait_time =
5230 		switch (dcmd_timeout_ocr_possible(instance)) {
5233 			mutex_unlock(&instance->reset_mutex);
5234 			megasas_reset_fusion(instance->host,
5236 			mutex_lock(&instance->reset_mutex);
5239 			megaraid_sas_kill_hba(instance);
5242 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5249 		megasas_return_cmd(instance, cmd);
5254  * @instance:				Adapter soft state
5261 megasas_get_ctrl_info(struct megasas_instance *instance)
5269 	ci = instance->ctrl_info_buf;
5270 	ci_h = instance->ctrl_info_buf_h;
5272 	cmd = megasas_get_cmd(instance);
5275 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get a free cmd\n");
5294 	megasas_set_dma_settings(instance, dcmd, ci_h,
5297 	if ((instance->adapter_type != MFI_SERIES) &&
5298 	    !instance->mask_interrupts) {
5299 		ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
5301 		ret = megasas_issue_polled(instance, cmd);
5322 		megasas_update_ext_vd_details(instance);
5323 		instance->support_seqnum_jbod_fp =
5325 		instance->support_morethan256jbod =
5327 		instance->support_nvme_passthru =
5329 		instance->support_pci_lane_margining =
5331 		instance->task_abort_tmo = ci->TaskAbortTO;
5332 		instance->max_reset_tmo = ci->MaxResetTO;
5335 		instance->is_imr = (ci->memory_size ? 0 : 1);
5337 		instance->snapdump_wait_time =
5341 		instance->enable_fw_dev_list =
5344 		dev_info(&instance->pdev->dev,
5346 			instance->is_imr ? "iMR" : "MR",
5349 		instance->disableOnlineCtrlReset =
5351 		instance->secure_jbod_support =
5353 		dev_info(&instance->pdev->dev, "Online Controller Reset(OCR)\t: %s\n",
5354 			instance->disableOnlineCtrlReset ? "Disabled" : "Enabled");
5355 		dev_info(&instance->pdev->dev, "Secure JBOD support\t: %s\n",
5356 			instance->secure_jbod_support ? "Yes" : "No");
5357 		dev_info(&instance->pdev->dev, "NVMe passthru support\t: %s\n",
5358 			 instance->support_nvme_passthru ? "Yes" : "No");
5359 		dev_info(&instance->pdev->dev,
5361 			 instance->task_abort_tmo, instance->max_reset_tmo);
5362 		dev_info(&instance->pdev->dev, "JBOD sequence map support\t: %s\n",
5363 			 instance->support_seqnum_jbod_fp ? "Yes" : "No");
5364 		dev_info(&instance->pdev->dev, "PCI Lane Margining support\t: %s\n",
5365 			 instance->support_pci_lane_margining ? "Yes" : "No");
5370 		switch (dcmd_timeout_ocr_possible(instance)) {
5373 			mutex_unlock(&instance->reset_mutex);
5374 			megasas_reset_fusion(instance->host,
5376 			mutex_lock(&instance->reset_mutex);
5379 			megaraid_sas_kill_hba(instance);
5382 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5388 		megaraid_sas_kill_hba(instance);
5394 		megasas_return_cmd(instance, cmd);
5403  * @instance:				Adapter soft state
5414 int megasas_set_crash_dump_params(struct megasas_instance *instance,
5421 	cmd = megasas_get_cmd(instance);
5424 		dev_err(&instance->pdev->dev, "Failed to get a free cmd\n");
5442 	megasas_set_dma_settings(instance, dcmd, instance->crash_dump_h,
5445 	if ((instance->adapter_type != MFI_SERIES) &&
5446 	    !instance->mask_interrupts)
5447 		ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
5449 		ret = megasas_issue_polled(instance, cmd);
5452 		switch (dcmd_timeout_ocr_possible(instance)) {
5455 			megasas_reset_fusion(instance->host,
5459 			megaraid_sas_kill_hba(instance);
5462 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5467 		megasas_return_cmd(instance, cmd);
5474  * @instance:		Adapter soft state
5479 megasas_issue_init_mfi(struct megasas_instance *instance)
5496 	cmd = megasas_get_cmd(instance);
5510 	initq_info->reply_queue_entries = cpu_to_le32(instance->max_fw_cmds + 1);
5511 	initq_info->reply_queue_start_phys_addr_lo = cpu_to_le32(instance->reply_queue_h);
5513 	initq_info->producer_index_phys_addr_lo = cpu_to_le32(instance->producer_h);
5514 	initq_info->consumer_index_phys_addr_lo = cpu_to_le32(instance->consumer_h);
5528 	instance->instancet->disable_intr(instance);
5534 	if (megasas_issue_polled(instance, cmd)) {
5535 		dev_err(&instance->pdev->dev, "Failed to init firmware\n");
5536 		megasas_return_cmd(instance, cmd);
5540 	megasas_return_cmd(instance, cmd);
5549 megasas_init_adapter_mfi(struct megasas_instance *instance)
5557 	instance->max_fw_cmds = instance->instancet->read_fw_status_reg(instance) & 0x00FFFF;
5563 	instance->max_fw_cmds = instance->max_fw_cmds-1;
5564 	instance->max_mfi_cmds = instance->max_fw_cmds;
5565 	instance->max_num_sge = (instance->instancet->read_fw_status_reg(instance) & 0xFF0000) >>
5571 	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
5572 		(instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
5573 		instance->max_scsi_cmds = (instance->max_fw_cmds -
5575 		sema_init(&instance->ioctl_sem, MEGASAS_SKINNY_INT_CMDS);
5577 		instance->max_scsi_cmds = (instance->max_fw_cmds -
5579 		sema_init(&instance->ioctl_sem, (MEGASAS_MFI_IOCTL_CMDS));
5582 	instance->cur_can_queue = instance->max_scsi_cmds;
5586 	if (megasas_alloc_cmds(instance))
5599 	reply_q_sz = context_sz * (instance->max_fw_cmds + 1);
5601 	instance->reply_queue = dma_alloc_coherent(&instance->pdev->dev,
5602 			reply_q_sz, &instance->reply_queue_h, GFP_KERNEL);
5604 	if (!instance->reply_queue) {
5605 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Out of DMA mem for reply queue\n");
5609 	if (megasas_issue_init_mfi(instance))
5612 	if (megasas_get_ctrl_info(instance)) {
5613 		dev_err(&instance->pdev->dev, "(%d): Could get controller info "
5614 			"Fail from %s %d\n", instance->unique_id,
5619 	instance->fw_support_ieee = 0;
5620 	instance->fw_support_ieee =
5621 		(instance->instancet->read_fw_status_reg(instance) &
5624 	dev_notice(&instance->pdev->dev, "megasas_init_mfi: fw_support_ieee=%d",
5625 			instance->fw_support_ieee);
5627 	if (instance->fw_support_ieee)
5628 		instance->flag_ieee = 1;
5634 	dma_free_coherent(&instance->pdev->dev, reply_q_sz,
5635 			    instance->reply_queue, instance->reply_queue_h);
5637 	megasas_free_cmds(instance);
5644 void megasas_setup_irq_poll(struct megasas_instance *instance)
5649 	count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
5653 		irq_ctx = &instance->irq_context[i];
5654 		irq_ctx->os_irq = pci_irq_vector(instance->pdev, i);
5657 			      instance->threshold_reply_count,
5664  * @instance:				Adapter soft state
5671 megasas_setup_irqs_ioapic(struct megasas_instance *instance)
5675 	pdev = instance->pdev;
5676 	instance->irq_context[0].instance = instance;
5677 	instance->irq_context[0].MSIxIndex = 0;
5678 	snprintf(instance->irq_context->name, MEGASAS_MSIX_NAME_LEN, "%s%u",
5679 		"megasas", instance->host->host_no);
5681 			instance->instancet->service_isr, IRQF_SHARED,
5682 			instance->irq_context->name, &instance->irq_context[0])) {
5683 		dev_err(&instance->pdev->dev,
5688 	instance->perf_mode = MR_LATENCY_PERF_MODE;
5689 	instance->low_latency_index_start = 0;
5695  * @instance:				Adapter soft state
5703 megasas_setup_irqs_msix(struct megasas_instance *instance, u8 is_probe)
5708 	pdev = instance->pdev;
5711 	for (i = 0; i < instance->msix_vectors; i++) {
5712 		instance->irq_context[i].instance = instance;
5713 		instance->irq_context[i].MSIxIndex = i;
5714 		snprintf(instance->irq_context[i].name, MEGASAS_MSIX_NAME_LEN, "%s%u-msix%u",
5715 			"megasas", instance->host->host_no, i);
5717 			instance->instancet->service_isr, 0, instance->irq_context[i].name,
5718 			&instance->irq_context[i])) {
5719 			dev_err(&instance->pdev->dev,
5722 				if (j < instance->low_latency_index_start)
5726 					 &instance->irq_context[j]);
5729 			instance->msix_vectors = 0;
5730 			instance->msix_load_balance = false;
5732 				pci_free_irq_vectors(instance->pdev);
5733 				return megasas_setup_irqs_ioapic(instance);
5745  * @instance:				Adapter soft state
5749 megasas_destroy_irqs(struct megasas_instance *instance) {
5755 	count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
5756 	if (instance->adapter_type != MFI_SERIES) {
5758 			irq_ctx = &instance->irq_context[i];
5763 	if (instance->msix_vectors)
5764 		for (i = 0; i < instance->msix_vectors; i++) {
5765 			if (i < instance->low_latency_index_start)
5767 				    pci_irq_vector(instance->pdev, i), NULL);
5768 			free_irq(pci_irq_vector(instance->pdev, i),
5769 				 &instance->irq_context[i]);
5772 		free_irq(pci_irq_vector(instance->pdev, 0),
5773 			 &instance->irq_context[0]);
5778  * @instance:				Adapter soft state
5783 megasas_setup_jbod_map(struct megasas_instance *instance)
5786 	struct fusion_context *fusion = instance->ctrl_context;
5792 	instance->use_seqnum_jbod_fp =
5793 		instance->support_seqnum_jbod_fp;
5795 		!instance->support_seqnum_jbod_fp) {
5796 		dev_info(&instance->pdev->dev,
5799 		instance->use_seqnum_jbod_fp = false;
5808 			(&instance->pdev->dev, pd_seq_map_sz,
5811 			dev_err(&instance->pdev->dev,
5815 				dma_free_coherent(&instance->pdev->dev,
5820 			instance->use_seqnum_jbod_fp = false;
5826 	if (!megasas_sync_pd_seq_num(instance, false) &&
5827 		!megasas_sync_pd_seq_num(instance, true))
5828 		instance->use_seqnum_jbod_fp = true;
5830 		instance->use_seqnum_jbod_fp = false;
5833 static void megasas_setup_reply_map(struct megasas_instance *instance)
5838 	low_latency_index_start = instance->low_latency_index_start;
5840 	for (queue = low_latency_index_start; queue < instance->msix_vectors; queue++) {
5841 		mask = pci_irq_get_affinity(instance->pdev, queue);
5846 			instance->reply_map[cpu] = queue;
5853 		instance->reply_map[cpu] = queue;
5854 		if (queue == (instance->msix_vectors - 1))
5863  * @instance:			Adapter soft state
5871 int megasas_get_device_list(struct megasas_instance *instance)
5873 	if (instance->enable_fw_dev_list) {
5874 		if (megasas_host_device_list_query(instance, true))
5877 		if (megasas_get_pd_list(instance) < 0) {
5878 			dev_err(&instance->pdev->dev, "failed to get PD list\n");
5882 		if (megasas_ld_list_query(instance,
5884 			dev_err(&instance->pdev->dev, "failed to get LD list\n");
5895  * @instance:						Adapter soft state
5899 megasas_set_high_iops_queue_affinity_and_hint(struct megasas_instance *instance)
5905 	if (instance->perf_mode == MR_BALANCED_PERF_MODE) {
5906 		mask = cpumask_of_node(dev_to_node(&instance->pdev->dev));
5908 		for (i = 0; i < instance->low_latency_index_start; i++) {
5909 			irq = pci_irq_vector(instance->pdev, i);
5916 __megasas_alloc_irq_vectors(struct megasas_instance *instance)
5919 	struct irq_affinity desc = { .pre_vectors = instance->low_latency_index_start };
5924 	if (instance->smp_affinity_enable)
5932 	i = pci_alloc_irq_vectors_affinity(instance->pdev,
5933 		instance->low_latency_index_start,
5934 		instance->msix_vectors - instance->iopoll_q_count, irq_flags, descp);
5941  * @instance:			Adapter soft state
5945 megasas_alloc_irq_vectors(struct megasas_instance *instance)
5950 	instance->iopoll_q_count = 0;
5951 	if ((instance->adapter_type != MFI_SERIES) &&
5954 		instance->perf_mode = MR_LATENCY_PERF_MODE;
5955 		instance->low_latency_index_start = 1;
5958 		if (instance->msix_vectors > (poll_queues + 2))
5959 			instance->iopoll_q_count = poll_queues;
5961 			instance->iopoll_q_count = 0;
5963 		num_msix_req = num_online_cpus() + instance->low_latency_index_start;
5964 		instance->msix_vectors = min(num_msix_req,
5965 				instance->msix_vectors);
5969 	i = __megasas_alloc_irq_vectors(instance);
5971 	if (((instance->perf_mode == MR_BALANCED_PERF_MODE)
5972 		|| instance->iopoll_q_count) &&
5973 	    (i != (instance->msix_vectors - instance->iopoll_q_count))) {
5974 		if (instance->msix_vectors)
5975 			pci_free_irq_vectors(instance->pdev);
5977 		instance->perf_mode = MR_LATENCY_PERF_MODE;
5978 		instance->low_latency_index_start = 1;
5979 		num_msix_req = num_online_cpus() + instance->low_latency_index_start;
5981 		instance->msix_vectors = min(num_msix_req,
5982 				instance->msix_vectors);
5984 		instance->iopoll_q_count = 0;
5985 		i = __megasas_alloc_irq_vectors(instance);
5989 	dev_info(&instance->pdev->dev,
5991 			instance->msix_vectors - instance->iopoll_q_count,
5992 			i, instance->iopoll_q_count);
5995 		instance->msix_vectors = i;
5997 		instance->msix_vectors = 0;
5999 	if (instance->smp_affinity_enable)
6000 		megasas_set_high_iops_queue_affinity_and_hint(instance);
6005  * @instance:		Adapter soft state
6010 static int megasas_init_fw(struct megasas_instance *instance)
6026 	fusion = instance->ctrl_context;
6029 	bar_list = pci_select_bars(instance->pdev, IORESOURCE_MEM);
6030 	instance->bar = find_first_bit(&bar_list, BITS_PER_LONG);
6031 	if (pci_request_selected_regions(instance->pdev, 1<<instance->bar,
6033 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "IO memory region busy!\n");
6037 	base_addr = pci_resource_start(instance->pdev, instance->bar);
6038 	instance->reg_set = ioremap(base_addr, 8192);
6040 	if (!instance->reg_set) {
6041 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to map IO mem\n");
6046 	dev_printk(KERN_DEBUG, &instance->pdev->dev,
6048 		   instance->bar, base_addr_phys, instance->reg_set);
6050 	if (instance->adapter_type != MFI_SERIES)
6051 		instance->instancet = &megasas_instance_template_fusion;
6053 		switch (instance->pdev->device) {
6056 			instance->instancet = &megasas_instance_template_ppc;
6060 			instance->instancet = &megasas_instance_template_gen2;
6064 			instance->instancet = &megasas_instance_template_skinny;
6069 			instance->instancet = &megasas_instance_template_xscale;
6070 			instance->pd_list_not_supported = 1;
6075 	if (megasas_transition_to_ready(instance, 0)) {
6076 		dev_info(&instance->pdev->dev,
6079 		if (instance->adapter_type != MFI_SERIES) {
6080 			status_reg = instance->instancet->read_fw_status_reg(
6081 					instance);
6084 					(instance, true, 0) == FAILED)
6090 			atomic_set(&instance->fw_reset_no_pci_access, 1);
6091 			instance->instancet->adp_reset
6092 				(instance, instance->reg_set);
6093 			atomic_set(&instance->fw_reset_no_pci_access, 0);
6098 			if (megasas_transition_to_ready(instance, 0))
6102 		dev_info(&instance->pdev->dev,
6107 	megasas_init_ctrl_params(instance);
6109 	if (megasas_set_dma_mask(instance))
6112 	if (megasas_alloc_ctrl_mem(instance))
6115 	if (megasas_alloc_ctrl_dma_buffers(instance))
6118 	fusion = instance->ctrl_context;
6120 	if (instance->adapter_type >= VENTURA_SERIES) {
6122 			megasas_readl(instance,
6123 				      &instance->reg_set->outbound_scratch_pad_2);
6124 		instance->max_raid_mapsize = ((scratch_pad_2 >>
6129 	instance->enable_sdev_max_qd = enable_sdev_max_qd;
6131 	switch (instance->adapter_type) {
6143 	msix_enable = (instance->instancet->read_fw_status_reg(instance) &
6148 			(instance, &instance->reg_set->outbound_scratch_pad_1);
6151 			if (instance->adapter_type == THUNDERBOLT_SERIES) {
6153 				instance->msix_vectors = (scratch_pad_1
6156 				instance->msix_vectors = ((scratch_pad_1
6168 				switch (instance->adapter_type) {
6170 					if (instance->msix_vectors > 8)
6171 						instance->msix_combined = true;
6175 					if (instance->msix_vectors > 16)
6176 						instance->msix_combined = true;
6181 					instance->is_rdpq = (scratch_pad_1 & MR_RDPQ_MODE_OFFSET) ?
6184 				if (instance->adapter_type >= INVADER_SERIES &&
6185 				    !instance->msix_combined) {
6186 					instance->msix_load_balance = true;
6187 					instance->smp_affinity_enable = false;
6195 					instance->reply_post_host_index_addr[loop] =
6197 						((u8 __iomem *)instance->reg_set +
6203 			dev_info(&instance->pdev->dev,
6205 				 instance->msix_vectors);
6207 				instance->msix_vectors = min(msix_vectors,
6208 					instance->msix_vectors);
6210 			instance->msix_vectors = 1;
6236 			(instance->msix_vectors == MEGASAS_MAX_MSIX_QUEUES))
6237 			instance->perf_mode = MR_BALANCED_PERF_MODE;
6239 			instance->perf_mode = MR_LATENCY_PERF_MODE;
6242 		if (instance->adapter_type == AERO_SERIES) {
6243 			pcie_capability_read_word(instance->pdev, PCI_EXP_LNKSTA, &lnksta);
6251 				instance->perf_mode = MR_LATENCY_PERF_MODE;
6263 				instance->perf_mode = perf_mode;
6269 				instance->perf_mode = MR_LATENCY_PERF_MODE;
6273 		if (instance->perf_mode == MR_BALANCED_PERF_MODE)
6274 			instance->low_latency_index_start =
6277 			instance->low_latency_index_start = 1;
6279 		num_msix_req = num_online_cpus() + instance->low_latency_index_start;
6281 		instance->msix_vectors = min(num_msix_req,
6282 				instance->msix_vectors);
6284 		megasas_alloc_irq_vectors(instance);
6285 		if (!instance->msix_vectors)
6286 			instance->msix_load_balance = false;
6292 	if (instance->msix_combined) {
6293 		instance->reply_post_host_index_addr[0] =
6294 				(u32 *)((u8 *)instance->reg_set +
6297 		instance->reply_post_host_index_addr[0] =
6298 			(u32 *)((u8 *)instance->reg_set +
6302 	if (!instance->msix_vectors) {
6303 		i = pci_alloc_irq_vectors(instance->pdev, 1, 1, PCI_IRQ_LEGACY);
6308 	megasas_setup_reply_map(instance);
6310 	dev_info(&instance->pdev->dev,
6312 		instance->msix_vectors, (unsigned int)num_online_cpus());
6313 	dev_info(&instance->pdev->dev,
6314 		"RDPQ mode\t: (%s)\n", instance->is_rdpq ? "enabled" : "disabled");
6316 	tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
6317 		(unsigned long)instance);
6323 	instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
6324 	instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
6326 	if (instance->instancet->init_adapter(instance))
6329 	if (instance->adapter_type >= VENTURA_SERIES) {
6331 			megasas_readl(instance,
6332 				      &instance->reg_set->outbound_scratch_pad_3);
6335 			instance->nvme_page_size =
6338 		dev_info(&instance->pdev->dev,
6339 			 "NVME page size\t: (%d)\n", instance->nvme_page_size);
6342 	if (instance->msix_vectors ?
6343 		megasas_setup_irqs_msix(instance, 1) :
6344 		megasas_setup_irqs_ioapic(instance))
6347 	if (instance->adapter_type != MFI_SERIES)
6348 		megasas_setup_irq_poll(instance);
6350 	instance->instancet->enable_intr(instance);
6352 	dev_info(&instance->pdev->dev, "INIT adapter done\n");
6354 	megasas_setup_jbod_map(instance);
6356 	if (megasas_get_device_list(instance) != SUCCESS) {
6357 		dev_err(&instance->pdev->dev,
6364 	if (instance->adapter_type >= VENTURA_SERIES) {
6370 			dev_err(&instance->pdev->dev,
6379 				dev_err(&instance->pdev->dev,
6402 	ctrl_info = instance->ctrl_info_buf;
6410 	instance->peerIsPresent = ctrl_info->cluster.peerIsPresent;
6411 	instance->passive = ctrl_info->cluster.passive;
6412 	memcpy(instance->clusterId, ctrl_info->clusterId, sizeof(instance->clusterId));
6413 	instance->UnevenSpanSupport =
6415 	if (instance->UnevenSpanSupport) {
6416 		struct fusion_context *fusion = instance->ctrl_context;
6417 		if (MR_ValidateMapInfo(instance, instance->map_id))
6424 		instance->requestorId = ctrl_info->iov.requestorId;
6425 		if (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) {
6427 			    instance->PlasmaFW111 = 1;
6429 			dev_info(&instance->pdev->dev, "SR-IOV: firmware type: %s\n",
6430 			    instance->PlasmaFW111 ? "1.11" : "new");
6432 			if (instance->PlasmaFW111) {
6435 			    instance->requestorId = iovPtr->requestorId;
6438 		dev_info(&instance->pdev->dev, "SRIOV: VF requestorId %d\n",
6439 			instance->requestorId);
6442 	instance->crash_dump_fw_support =
6444 	instance->crash_dump_drv_support =
6445 		(instance->crash_dump_fw_support &&
6446 		instance->crash_dump_buf);
6447 	if (instance->crash_dump_drv_support)
6448 		megasas_set_crash_dump_params(instance,
6452 		if (instance->crash_dump_buf)
6453 			dma_free_coherent(&instance->pdev->dev,
6455 				instance->crash_dump_buf,
6456 				instance->crash_dump_h);
6457 		instance->crash_dump_buf = NULL;
6460 	if (instance->snapdump_wait_time) {
6461 		megasas_get_snapdump_properties(instance);
6462 		dev_info(&instance->pdev->dev, "Snap dump wait time\t: %d\n",
6463 			 instance->snapdump_wait_time);
6466 	dev_info(&instance->pdev->dev,
6472 	dev_info(&instance->pdev->dev, "unevenspan support	: %s\n",
6473 		instance->UnevenSpanSupport ? "yes" : "no");
6474 	dev_info(&instance->pdev->dev, "firmware crash dump	: %s\n",
6475 		instance->crash_dump_drv_support ? "yes" : "no");
6476 	dev_info(&instance->pdev->dev, "JBOD sequence map	: %s\n",
6477 		instance->use_seqnum_jbod_fp ? "enabled" : "disabled");
6479 	instance->max_sectors_per_req = instance->max_num_sge *
6481 	if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))
6482 		instance->max_sectors_per_req = tmp_sectors;
6486 			throttlequeuedepth <= instance->max_scsi_cmds)
6487 		instance->throttlequeuedepth = throttlequeuedepth;
6489 		instance->throttlequeuedepth =
6500 	if (instance->requestorId) {
6501 		if (!megasas_sriov_start_heartbeat(instance, 1)) {
6502 			megasas_start_timer(instance);
6504 			instance->skip_heartbeat_timer_del = 1;
6514 	if (instance->adapter_type != MFI_SERIES)
6515 		if (megasas_fusion_start_watchdog(instance) != SUCCESS)
6521 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
6522 		del_timer_sync(&instance->sriov_heartbeat_timer);
6524 	instance->instancet->disable_intr(instance);
6525 	megasas_destroy_irqs(instance);
6527 	if (instance->msix_vectors)
6528 		pci_free_irq_vectors(instance->pdev);
6529 	instance->msix_vectors = 0;
6531 	megasas_free_ctrl_dma_buffers(instance);
6532 	megasas_free_ctrl_mem(instance);
6534 	iounmap(instance->reg_set);
6537 	pci_release_selected_regions(instance->pdev, 1<<instance->bar);
6539 	dev_err(&instance->pdev->dev, "Failed from %s %d\n",
6546  * @instance:			Adapter soft state
6548 static void megasas_release_mfi(struct megasas_instance *instance)
6550 	u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1);
6552 	if (instance->reply_queue)
6553 		dma_free_coherent(&instance->pdev->dev, reply_q_sz,
6554 			    instance->reply_queue, instance->reply_queue_h);
6556 	megasas_free_cmds(instance);
6558 	iounmap(instance->reg_set);
6560 	pci_release_selected_regions(instance->pdev, 1<<instance->bar);
6565  * @instance:			Adapter soft state
6576 megasas_get_seq_num(struct megasas_instance *instance,
6585 	cmd = megasas_get_cmd(instance);
6592 	el_info = dma_alloc_coherent(&instance->pdev->dev,
6596 		megasas_return_cmd(instance, cmd);
6611 	megasas_set_dma_settings(instance, dcmd, el_info_h,
6614 	ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
6616 		dev_err(&instance->pdev->dev, "Failed from %s %d\n",
6631 	dma_free_coherent(&instance->pdev->dev,
6635 	megasas_return_cmd(instance, cmd);
6642  * @instance:			Adapter soft state
6650 megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
6674 	if (instance->aen_cmd) {
6677 			le32_to_cpu(instance->aen_cmd->frame->dcmd.mbox.w[1]);
6681 			dev_info(&instance->pdev->dev,
6711 			instance->aen_cmd->abort_aen = 1;
6712 			ret_val = megasas_issue_blocked_abort_cmd(instance,
6713 								  instance->
6717 				dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to abort "
6724 	cmd = megasas_get_cmd(instance);
6731 	memset(instance->evt_detail, 0, sizeof(struct megasas_evt_detail));
6747 	instance->last_seq_num = seq_num;
6750 	megasas_set_dma_settings(instance, dcmd, instance->evt_detail_h,
6753 	if (instance->aen_cmd != NULL) {
6754 		megasas_return_cmd(instance, cmd);
6763 	instance->aen_cmd = cmd;
6768 	instance->instancet->issue_dcmd(instance, cmd);
6786  * @instance:		Adapter soft state
6792 megasas_get_target_prop(struct megasas_instance *instance,
6801 	cmd = megasas_get_cmd(instance);
6804 		dev_err(&instance->pdev->dev,
6811 	memset(instance->tgt_prop, 0, sizeof(*instance->tgt_prop));
6826 	megasas_set_dma_settings(instance, dcmd, instance->tgt_prop_h,
6829 	if ((instance->adapter_type != MFI_SERIES) &&
6830 	    !instance->mask_interrupts)
6831 		ret = megasas_issue_blocked_cmd(instance,
6834 		ret = megasas_issue_polled(instance, cmd);
6838 		switch (dcmd_timeout_ocr_possible(instance)) {
6841 			mutex_unlock(&instance->reset_mutex);
6842 			megasas_reset_fusion(instance->host,
6844 			mutex_lock(&instance->reset_mutex);
6847 			megaraid_sas_kill_hba(instance);
6850 			dev_info(&instance->pdev->dev,
6858 		megasas_return_cmd(instance, cmd);
6861 		dev_err(&instance->pdev->dev,
6870  * @instance:		Adapter soft state
6872 static int megasas_start_aen(struct megasas_instance *instance)
6882 	if (megasas_get_seq_num(instance, &eli))
6892 	return megasas_register_aen(instance,
6899  * @instance:		Adapter soft state
6901 static int megasas_io_attach(struct megasas_instance *instance)
6903 	struct Scsi_Host *host = instance->host;
6908 	host->unique_id = instance->unique_id;
6909 	host->can_queue = instance->max_scsi_cmds;
6910 	host->this_id = instance->init_id;
6911 	host->sg_tablesize = instance->max_num_sge;
6913 	if (instance->fw_support_ieee)
6914 		instance->max_sectors_per_req = MEGASAS_MAX_SECTORS_IEEE;
6919 	if (max_sectors && max_sectors < instance->max_sectors_per_req)
6920 		instance->max_sectors_per_req = max_sectors;
6923 			if (((instance->pdev->device ==
6925 				(instance->pdev->device ==
6928 				instance->max_sectors_per_req = max_sectors;
6930 			dev_info(&instance->pdev->dev, "max_sectors should be > 0"
6932 				instance->max_sectors_per_req);
6937 	host->max_sectors = instance->max_sectors_per_req;
6952 	if ((instance->adapter_type != MFI_SERIES) &&
6953 		(instance->msix_vectors > instance->low_latency_index_start) &&
6955 		instance->smp_affinity_enable) {
6957 		host->nr_hw_queues = instance->msix_vectors -
6958 			instance->low_latency_index_start + instance->iopoll_q_count;
6959 		if (instance->iopoll_q_count)
6962 		instance->iopoll_q_count = 0;
6965 	dev_info(&instance->pdev->dev,
6967 		"hw_queues = %d poll_queues %d\n", instance->max_fw_cmds,
6968 		host->nr_hw_queues - instance->iopoll_q_count,
6969 		instance->iopoll_q_count);
6973 	if (scsi_add_host(host, &instance->pdev->dev)) {
6974 		dev_err(&instance->pdev->dev,
6986  * @instance:		Adapter soft state
7001 megasas_set_dma_mask(struct megasas_instance *instance)
7007 	pdev = instance->pdev;
7008 	consistent_mask = (instance->adapter_type >= VENTURA_SERIES) ?
7024 				(instance, &instance->reg_set->outbound_scratch_pad_1);
7036 		instance->consistent_mask_64bit = false;
7038 		instance->consistent_mask_64bit = true;
7042 		 (instance->consistent_mask_64bit ? "63" : "32"));
7063  * @instance:			Adapter soft state
7066 static inline void megasas_set_adapter_type(struct megasas_instance *instance)
7068 	if ((instance->pdev->vendor == PCI_VENDOR_ID_DELL) &&
7069 	    (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5)) {
7070 		instance->adapter_type = MFI_SERIES;
7072 		switch (instance->pdev->device) {
7077 			instance->adapter_type = AERO_SERIES;
7085 			instance->adapter_type = VENTURA_SERIES;
7089 			instance->adapter_type = THUNDERBOLT_SERIES;
7097 			instance->adapter_type = INVADER_SERIES;
7100 			instance->adapter_type = MFI_SERIES;
7106 static inline int megasas_alloc_mfi_ctrl_mem(struct megasas_instance *instance)
7108 	instance->producer = dma_alloc_coherent(&instance->pdev->dev,
7109 			sizeof(u32), &instance->producer_h, GFP_KERNEL);
7110 	instance->consumer = dma_alloc_coherent(&instance->pdev->dev,
7111 			sizeof(u32), &instance->consumer_h, GFP_KERNEL);
7113 	if (!instance->producer || !instance->consumer) {
7114 		dev_err(&instance->pdev->dev,
7119 	*instance->producer = 0;
7120 	*instance->consumer = 0;
7131  * @instance:			Adapter soft state
7134 static int megasas_alloc_ctrl_mem(struct megasas_instance *instance)
7136 	instance->reply_map = kcalloc(nr_cpu_ids, sizeof(unsigned int),
7138 	if (!instance->reply_map)
7141 	switch (instance->adapter_type) {
7143 		if (megasas_alloc_mfi_ctrl_mem(instance))
7150 		if (megasas_alloc_fusion_context(instance))
7162  * @instance -			Adapter soft instance
7165 static inline void megasas_free_ctrl_mem(struct megasas_instance *instance)
7167 	kfree(instance->reply_map);
7168 	if (instance->adapter_type == MFI_SERIES) {
7169 		if (instance->producer)
7170 			dma_free_coherent(&instance->pdev->dev, sizeof(u32),
7171 					    instance->producer,
7172 					    instance->producer_h);
7173 		if (instance->consumer)
7174 			dma_free_coherent(&instance->pdev->dev, sizeof(u32),
7175 					    instance->consumer,
7176 					    instance->consumer_h);
7178 		megasas_free_fusion_context(instance);
7186  * @instance:				Adapter soft instance
7191 int megasas_alloc_ctrl_dma_buffers(struct megasas_instance *instance)
7193 	struct pci_dev *pdev = instance->pdev;
7194 	struct fusion_context *fusion = instance->ctrl_context;
7196 	instance->evt_detail = dma_alloc_coherent(&pdev->dev,
7198 			&instance->evt_detail_h, GFP_KERNEL);
7200 	if (!instance->evt_detail) {
7201 		dev_err(&instance->pdev->dev,
7219 		instance->snapdump_prop = dma_alloc_coherent(&pdev->dev,
7221 				&instance->snapdump_prop_h, GFP_KERNEL);
7223 		if (!instance->snapdump_prop)
7227 		instance->host_device_list_buf = dma_alloc_coherent(&pdev->dev,
7229 							&instance->host_device_list_buf_h,
7232 		if (!instance->host_device_list_buf) {
7240 	instance->pd_list_buf =
7243 				     &instance->pd_list_buf_h, GFP_KERNEL);
7245 	if (!instance->pd_list_buf) {
7250 	instance->ctrl_info_buf =
7253 				     &instance->ctrl_info_buf_h, GFP_KERNEL);
7255 	if (!instance->ctrl_info_buf) {
7261 	instance->ld_list_buf =
7264 				     &instance->ld_list_buf_h, GFP_KERNEL);
7266 	if (!instance->ld_list_buf) {
7271 	instance->ld_targetid_list_buf =
7274 				&instance->ld_targetid_list_buf_h, GFP_KERNEL);
7276 	if (!instance->ld_targetid_list_buf) {
7283 		instance->system_info_buf =
7286 					&instance->system_info_h, GFP_KERNEL);
7287 		instance->pd_info =
7290 					&instance->pd_info_h, GFP_KERNEL);
7291 		instance->tgt_prop =
7294 					&instance->tgt_prop_h, GFP_KERNEL);
7295 		instance->crash_dump_buf =
7297 					&instance->crash_dump_h, GFP_KERNEL);
7299 		if (!instance->system_info_buf)
7300 			dev_err(&instance->pdev->dev,
7303 		if (!instance->pd_info)
7304 			dev_err(&instance->pdev->dev,
7307 		if (!instance->tgt_prop)
7308 			dev_err(&instance->pdev->dev,
7311 		if (!instance->crash_dump_buf)
7312 			dev_err(&instance->pdev->dev,
7323  * @instance-				Adapter soft instance
7327 void megasas_free_ctrl_dma_buffers(struct megasas_instance *instance)
7329 	struct pci_dev *pdev = instance->pdev;
7330 	struct fusion_context *fusion = instance->ctrl_context;
7332 	if (instance->evt_detail)
7334 				    instance->evt_detail,
7335 				    instance->evt_detail_h);
7343 	if (instance->pd_list_buf)
7346 				    instance->pd_list_buf,
7347 				    instance->pd_list_buf_h);
7349 	if (instance->ld_list_buf)
7351 				    instance->ld_list_buf,
7352 				    instance->ld_list_buf_h);
7354 	if (instance->ld_targetid_list_buf)
7356 				    instance->ld_targetid_list_buf,
7357 				    instance->ld_targetid_list_buf_h);
7359 	if (instance->ctrl_info_buf)
7361 				    instance->ctrl_info_buf,
7362 				    instance->ctrl_info_buf_h);
7364 	if (instance->system_info_buf)
7366 				    instance->system_info_buf,
7367 				    instance->system_info_h);
7369 	if (instance->pd_info)
7371 				    instance->pd_info, instance->pd_info_h);
7373 	if (instance->tgt_prop)
7375 				    instance->tgt_prop, instance->tgt_prop_h);
7377 	if (instance->crash_dump_buf)
7379 				    instance->crash_dump_buf,
7380 				    instance->crash_dump_h);
7382 	if (instance->snapdump_prop)
7385 				  instance->snapdump_prop,
7386 				  instance->snapdump_prop_h);
7388 	if (instance->host_device_list_buf)
7391 				  instance->host_device_list_buf,
7392 				  instance->host_device_list_buf_h);
7397  * megasas_init_ctrl_params -		Initialize controller's instance
7399  * @instance -				Adapter soft instance
7402 static inline void megasas_init_ctrl_params(struct megasas_instance *instance)
7404 	instance->fw_crash_state = UNAVAILABLE;
7407 	instance->issuepend_done = 1;
7408 	atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
7413 	INIT_LIST_HEAD(&instance->cmd_pool);
7414 	INIT_LIST_HEAD(&instance->internal_reset_pending_q);
7416 	atomic_set(&instance->fw_outstanding, 0);
7417 	atomic64_set(&instance->total_io_count, 0);
7419 	init_waitqueue_head(&instance->int_cmd_wait_q);
7420 	init_waitqueue_head(&instance->abort_cmd_wait_q);
7422 	mutex_init(&instance->crashdump_lock);
7423 	spin_lock_init(&instance->mfi_pool_lock);
7424 	spin_lock_init(&instance->hba_lock);
7425 	spin_lock_init(&instance->stream_lock);
7426 	spin_lock_init(&instance->completion_lock);
7428 	mutex_init(&instance->reset_mutex);
7430 	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
7431 	    (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY))
7432 		instance->flag_ieee = 1;
7434 	instance->flag = 0;
7435 	instance->unload = 1;
7436 	instance->last_time = 0;
7437 	instance->disableOnlineCtrlReset = 1;
7438 	instance->UnevenSpanSupport = 0;
7439 	instance->smp_affinity_enable = smp_affinity_enable ? true : false;
7440 	instance->msix_load_balance = false;
7442 	if (instance->adapter_type != MFI_SERIES)
7443 		INIT_WORK(&instance->work_init, megasas_fusion_ocr_wq);
7445 		INIT_WORK(&instance->work_init, process_fw_state_change_wq);
7458 	struct megasas_instance *instance;
7509 	instance = (struct megasas_instance *)host->hostdata;
7510 	memset(instance, 0, sizeof(*instance));
7511 	atomic_set(&instance->fw_reset_no_pci_access, 0);
7516 	instance->pdev = pdev;
7517 	instance->host = host;
7518 	instance->unique_id = pci_dev_id(pdev);
7519 	instance->init_id = MEGASAS_DEFAULT_INIT_ID;
7521 	megasas_set_adapter_type(instance);
7526 	if (megasas_init_fw(instance))
7529 	if (instance->requestorId) {
7530 		if (instance->PlasmaFW111) {
7531 			instance->vf_affiliation_111 =
7534 					&instance->vf_affiliation_111_h,
7536 			if (!instance->vf_affiliation_111)
7540 			instance->vf_affiliation =
7544 					&instance->vf_affiliation_h,
7546 			if (!instance->vf_affiliation)
7553 	 * Store instance in PCI softstate
7555 	pci_set_drvdata(pdev, instance);
7562 	megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance;
7568 	if (megasas_io_attach(instance))
7571 	instance->unload = 0;
7575 	if (!instance->enable_fw_dev_list ||
7576 	    (instance->host_device_list_buf->count > 0))
7582 	if (megasas_start_aen(instance)) {
7587 	megasas_setup_debugfs(instance);
7590 	if (instance->requestorId)
7591 		megasas_get_ld_vf_affiliation(instance, 1);
7596 	instance->unload = 1;
7597 	scsi_remove_host(instance->host);
7601 	megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL;
7603 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7604 		del_timer_sync(&instance->sriov_heartbeat_timer);
7606 	instance->instancet->disable_intr(instance);
7607 	megasas_destroy_irqs(instance);
7609 	if (instance->adapter_type != MFI_SERIES)
7610 		megasas_release_fusion(instance);
7612 		megasas_release_mfi(instance);
7614 	if (instance->msix_vectors)
7615 		pci_free_irq_vectors(instance->pdev);
7616 	instance->msix_vectors = 0;
7618 	if (instance->fw_crash_state != UNAVAILABLE)
7619 		megasas_free_host_crash_buffer(instance);
7621 	if (instance->adapter_type != MFI_SERIES)
7622 		megasas_fusion_stop_watchdog(instance);
7633  * @instance:			Adapter soft state
7635 static void megasas_flush_cache(struct megasas_instance *instance)
7640 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
7643 	cmd = megasas_get_cmd(instance);
7662 	if (megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS)
7664 		dev_err(&instance->pdev->dev,
7669 	megasas_return_cmd(instance, cmd);
7674  * @instance:				Adapter soft state
7677 static void megasas_shutdown_controller(struct megasas_instance *instance,
7683 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
7686 	cmd = megasas_get_cmd(instance);
7691 	if (instance->aen_cmd)
7692 		megasas_issue_blocked_abort_cmd(instance,
7693 			instance->aen_cmd, MFI_IO_TIMEOUT_SECS);
7694 	if (instance->map_update_cmd)
7695 		megasas_issue_blocked_abort_cmd(instance,
7696 			instance->map_update_cmd, MFI_IO_TIMEOUT_SECS);
7697 	if (instance->jbod_seq_cmd)
7698 		megasas_issue_blocked_abort_cmd(instance,
7699 			instance->jbod_seq_cmd, MFI_IO_TIMEOUT_SECS);
7714 	if (megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS)
7716 		dev_err(&instance->pdev->dev,
7721 	megasas_return_cmd(instance, cmd);
7731 	struct megasas_instance *instance;
7733 	instance = dev_get_drvdata(dev);
7735 	if (!instance)
7738 	instance->unload = 1;
7743 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7744 		del_timer_sync(&instance->sriov_heartbeat_timer);
7747 	if (instance->adapter_type != MFI_SERIES)
7748 		megasas_fusion_stop_watchdog(instance);
7750 	megasas_flush_cache(instance);
7751 	megasas_shutdown_controller(instance, MR_DCMD_HIBERNATE_SHUTDOWN);
7754 	if (instance->ev != NULL) {
7755 		struct megasas_aen_event *ev = instance->ev;
7757 		instance->ev = NULL;
7760 	tasklet_kill(&instance->isr_tasklet);
7762 	pci_set_drvdata(instance->pdev, instance);
7763 	instance->instancet->disable_intr(instance);
7765 	megasas_destroy_irqs(instance);
7767 	if (instance->msix_vectors)
7768 		pci_free_irq_vectors(instance->pdev);
7782 	struct megasas_instance *instance;
7785 	instance = dev_get_drvdata(dev);
7787 	if (!instance)
7790 	host = instance->host;
7798 	if (megasas_transition_to_ready(instance, 0)) {
7799 		dev_info(&instance->pdev->dev,
7802 		if (instance->adapter_type != MFI_SERIES) {
7804 				instance->instancet->read_fw_status_reg(instance);
7807 				(instance, true, 0)) == FAILED))
7810 			atomic_set(&instance->fw_reset_no_pci_access, 1);
7811 			instance->instancet->adp_reset
7812 				(instance, instance->reg_set);
7813 			atomic_set(&instance->fw_reset_no_pci_access, 0);
7818 			if (megasas_transition_to_ready(instance, 0))
7822 		dev_info(&instance->pdev->dev,
7826 	if (megasas_set_dma_mask(instance))
7833 	atomic_set(&instance->fw_outstanding, 0);
7834 	atomic_set(&instance->ldio_outstanding, 0);
7837 	if (instance->msix_vectors)
7838 		megasas_alloc_irq_vectors(instance);
7840 	if (!instance->msix_vectors) {
7841 		rval = pci_alloc_irq_vectors(instance->pdev, 1, 1,
7847 	megasas_setup_reply_map(instance);
7849 	if (instance->adapter_type != MFI_SERIES) {
7850 		megasas_reset_reply_desc(instance);
7851 		if (megasas_ioc_init_fusion(instance)) {
7852 			megasas_free_cmds(instance);
7853 			megasas_free_cmds_fusion(instance);
7856 		if (!megasas_get_map_info(instance))
7857 			megasas_sync_map_info(instance);
7859 		*instance->producer = 0;
7860 		*instance->consumer = 0;
7861 		if (megasas_issue_init_mfi(instance))
7865 	if (megasas_get_ctrl_info(instance) != DCMD_SUCCESS)
7868 	tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
7869 		     (unsigned long)instance);
7871 	if (instance->msix_vectors ?
7872 			megasas_setup_irqs_msix(instance, 0) :
7873 			megasas_setup_irqs_ioapic(instance))
7876 	if (instance->adapter_type != MFI_SERIES)
7877 		megasas_setup_irq_poll(instance);
7880 	if (instance->requestorId) {
7881 		if (!megasas_sriov_start_heartbeat(instance, 0))
7882 			megasas_start_timer(instance);
7884 			instance->skip_heartbeat_timer_del = 1;
7889 	instance->instancet->enable_intr(instance);
7890 	megasas_setup_jbod_map(instance);
7891 	instance->unload = 0;
7896 	if (megasas_start_aen(instance))
7897 		dev_err(&instance->pdev->dev, "Start AEN failed\n");
7900 	if (instance->adapter_type != MFI_SERIES)
7901 		if (megasas_fusion_start_watchdog(instance) != SUCCESS)
7907 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7908 		del_timer_sync(&instance->sriov_heartbeat_timer);
7910 	megasas_free_ctrl_dma_buffers(instance);
7911 	megasas_free_ctrl_mem(instance);
7922 megasas_wait_for_adapter_operational(struct megasas_instance *instance)
7929 		adp_state = atomic_read(&instance->adprecovery);
7935 			dev_notice(&instance->pdev->dev, "waiting for controller reset to finish\n");
7941 		dev_info(&instance->pdev->dev,
7958 	struct megasas_instance *instance;
7962 	instance = pci_get_drvdata(pdev);
7964 	if (!instance)
7967 	host = instance->host;
7968 	fusion = instance->ctrl_context;
7971 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7972 		del_timer_sync(&instance->sriov_heartbeat_timer);
7975 	if (instance->adapter_type != MFI_SERIES)
7976 		megasas_fusion_stop_watchdog(instance);
7978 	if (instance->fw_crash_state != UNAVAILABLE)
7979 		megasas_free_host_crash_buffer(instance);
7980 	scsi_remove_host(instance->host);
7981 	instance->unload = 1;
7983 	if (megasas_wait_for_adapter_operational(instance))
7986 	megasas_flush_cache(instance);
7987 	megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
7991 	if (instance->ev != NULL) {
7992 		struct megasas_aen_event *ev = instance->ev;
7994 		instance->ev = NULL;
7998 	wake_up_all(&instance->int_cmd_wait_q);
8000 	tasklet_kill(&instance->isr_tasklet);
8003 	 * Take the instance off the instance array. Note that we will not
8007 		if (megasas_mgmt_info.instance[i] == instance) {
8009 			megasas_mgmt_info.instance[i] = NULL;
8015 	instance->instancet->disable_intr(instance);
8017 	megasas_destroy_irqs(instance);
8019 	if (instance->msix_vectors)
8020 		pci_free_irq_vectors(instance->pdev);
8022 	if (instance->adapter_type >= VENTURA_SERIES) {
8030 	if (instance->adapter_type != MFI_SERIES) {
8031 		megasas_release_fusion(instance);
8037 				dma_free_coherent(&instance->pdev->dev,
8050 				dma_free_coherent(&instance->pdev->dev,
8056 		megasas_release_mfi(instance);
8059 	if (instance->vf_affiliation)
8062 				    instance->vf_affiliation,
8063 				    instance->vf_affiliation_h);
8065 	if (instance->vf_affiliation_111)
8068 				    instance->vf_affiliation_111,
8069 				    instance->vf_affiliation_111_h);
8071 	if (instance->hb_host_mem)
8073 				    instance->hb_host_mem,
8074 				    instance->hb_host_mem_h);
8076 	megasas_free_ctrl_dma_buffers(instance);
8078 	megasas_free_ctrl_mem(instance);
8080 	megasas_destroy_debugfs(instance);
8093 	struct megasas_instance *instance = pci_get_drvdata(pdev);
8095 	if (!instance)
8098 	instance->unload = 1;
8100 	if (megasas_wait_for_adapter_operational(instance))
8103 	megasas_flush_cache(instance);
8104 	megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
8107 	instance->instancet->disable_intr(instance);
8108 	megasas_destroy_irqs(instance);
8110 	if (instance->msix_vectors)
8111 		pci_free_irq_vectors(instance->pdev);
8196 		local_instance = megasas_mgmt_info.instance[i];
8221  * @instance:			Adapter soft state
8226 megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
8245 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "SGE count [%d] >  max limit [%d]\n",
8252 	    !instance->support_nvme_passthru) ||
8254 	    !instance->support_pci_lane_margining)) {
8255 		dev_err(&instance->pdev->dev,
8261 	cmd = megasas_get_cmd(instance);
8263 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get a cmd packet\n");
8279 	if (instance->consistent_mask_64bit)
8290 		mutex_lock(&instance->reset_mutex);
8291 		if (megasas_get_ctrl_info(instance) != DCMD_SUCCESS) {
8292 			megasas_return_cmd(instance, cmd);
8293 			mutex_unlock(&instance->reset_mutex);
8296 		mutex_unlock(&instance->reset_mutex);
8301 		megasas_return_cmd(instance, cmd);
8313 	if (instance->consistent_mask_64bit)
8327 		kbuff_arr[i] = dma_alloc_coherent(&instance->pdev->dev,
8331 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc "
8341 		if (instance->consistent_mask_64bit) {
8368 		sense = dma_alloc_coherent(&instance->pdev->dev, ioc->sense_len,
8386 	ret = megasas_issue_blocked_cmd(instance, cmd, 0);
8391 		dev_err(&instance->pdev->dev,
8401 	if (instance->unload == 1) {
8402 		dev_info(&instance->pdev->dev, "Driver unload is in progress "
8434 			dev_err(&instance->pdev->dev, "Failed to copy out to user "
8446 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Error copying out cmd_status\n");
8452 		dma_free_coherent(&instance->pdev->dev, ioc->sense_len,
8458 			if (instance->consistent_mask_64bit)
8459 				dma_free_coherent(&instance->pdev->dev,
8464 				dma_free_coherent(&instance->pdev->dev,
8472 	megasas_return_cmd(instance, cmd);
8513 	struct megasas_instance *instance;
8524 	instance = megasas_lookup_instance(ioc->host_no);
8525 	if (!instance) {
8531 	if (instance->requestorId && !allow_vf_ioctls) {
8536 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
8537 		dev_err(&instance->pdev->dev, "Controller in crit error\n");
8542 	if (instance->unload == 1) {
8547 	if (down_interruptible(&instance->ioctl_sem)) {
8552 	if  (megasas_wait_for_adapter_operational(instance)) {
8557 	error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc);
8559 	up(&instance->ioctl_sem);
8568 	struct megasas_instance *instance;
8581 	instance = megasas_lookup_instance(aen.host_no);
8583 	if (!instance)
8586 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
8590 	if (instance->unload == 1) {
8594 	if  (megasas_wait_for_adapter_operational(instance))
8597 	mutex_lock(&instance->reset_mutex);
8598 	error = megasas_register_aen(instance, aen.seq_num,
8600 	mutex_unlock(&instance->reset_mutex);
8743  * @instance:			Adapter soft state
8753 int megasas_update_device_list(struct megasas_instance *instance,
8758 	if (instance->enable_fw_dev_list) {
8759 		return megasas_host_device_list_query(instance, false);
8762 			dcmd_ret = megasas_get_pd_list(instance);
8768 			if (!instance->requestorId ||
8769 			megasas_get_ld_vf_affiliation(instance, 0)) {
8770 				return megasas_ld_list_query(instance,
8781  * @instance:			Adapter soft state
8786 void megasas_add_remove_devices(struct megasas_instance *instance,
8798 	host = instance->host;
8800 	if (instance->enable_fw_dev_list) {
8801 		targetid_list = instance->host_device_list_buf;
8830 				if (instance->pd_list[pd_index].driveState ==
8850 				if (instance->ld_ids[ld_index] != 0xff) {
8870 	struct megasas_instance *instance = ev->instance;
8879 	if (!instance) {
8880 		printk(KERN_ERR "invalid instance!\n");
8886 	mutex_lock(&instance->reset_mutex);
8888 	instance->ev = NULL;
8889 	if (instance->evt_detail) {
8890 		megasas_decode_evt(instance);
8892 		switch (le32_to_cpu(instance->evt_detail->code)) {
8901 			ld_target_id = instance->evt_detail->args.ld.target_id;
8902 			sdev1 = scsi_device_lookup(instance->host,
8921 			dev_info(&instance->pdev->dev, "scanning for scsi%d...\n",
8922 				instance->host->host_no);
8926 			dcmd_ret = megasas_get_ctrl_info(instance);
8928 			    instance->snapdump_wait_time) {
8929 				megasas_get_snapdump_properties(instance);
8930 				dev_info(&instance->pdev->dev,
8932 					 instance->snapdump_wait_time);
8940 		dev_err(&instance->pdev->dev, "invalid evt_detail!\n");
8941 		mutex_unlock(&instance->reset_mutex);
8947 		dcmd_ret = megasas_update_device_list(instance, event_type);
8949 	mutex_unlock(&instance->reset_mutex);
8952 		megasas_add_remove_devices(instance, event_type);
8955 		seq_num = le32_to_cpu(instance->evt_detail->seq_num) + 1;
8957 		seq_num = instance->last_seq_num;
8964 	if (instance->aen_cmd != NULL) {
8969 	mutex_lock(&instance->reset_mutex);
8970 	error = megasas_register_aen(instance, seq_num,
8973 		dev_err(&instance->pdev->dev,
8976 	mutex_unlock(&instance->reset_mutex);

Indexes created Wed May 08 10:03:12 MDT 2024