~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,34 +1,20 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/*
2	3	* Linux MegaRAID driver for SAS based RAID controllers
3	4	*
4	5	* Copyright (c) 2009-2013 LSI Corporation
5		- * Copyright (c) 2013-2014 Avago Technologies
6		- *
7		- * This program is free software; you can redistribute it and/or
8		- * modify it under the terms of the GNU General Public License
9		- * as published by the Free Software Foundation; either version 2
10		- * of the License, or (at your option) any later version.
11		- *
12		- * This program is distributed in the hope that it will be useful,
13		- * but WITHOUT ANY WARRANTY; without even the implied warranty of
14		- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15		- * GNU General Public License for more details.
16		- *
17		- * You should have received a copy of the GNU General Public License
18		- * along with this program. If not, see <http://www.gnu.org/licenses/>.
	6	+ * Copyright (c) 2013-2016 Avago Technologies
	7	+ * Copyright (c) 2016-2018 Broadcom Inc.
19	8	*
20	9	* FILE: megaraid_sas_fusion.c
21	10	*
22		- * Authors: Avago Technologies
	11	+ * Authors: Broadcom Inc.
23	12	* Sumant Patro
24	13	* Adam Radford
25		- * Kashyap Desai <kashyap.desai@avagotech.com>
26		- * Sumit Saxena <sumit.saxena@avagotech.com>
	14	+ * Kashyap Desai <kashyap.desai@broadcom.com>
	15	+ * Sumit Saxena <sumit.saxena@broadcom.com>
27	16	*
28		- * Send feedback to: megaraidlinux.pdl@avagotech.com
29		- *
30		- * Mail to: Avago Technologies, 350 West Trimble Road, Building 90,
31		- * San Jose, California 95131
	17	+ * Send feedback to: megaraidlinux.pdl@broadcom.com
32	18	*/
33	19
34	20	#include <linux/kernel.h>
..	..	@@ -48,6 +34,8 @@
48	34	#include <linux/mutex.h>
49	35	#include <linux/poll.h>
50	36	#include <linux/vmalloc.h>
	37	+#include <linux/workqueue.h>
	38	+#include <linux/irq_poll.h>
51	39
52	40	#include <scsi/scsi.h>
53	41	#include <scsi/scsi_cmnd.h>
..	..	@@ -60,9 +48,6 @@
60	48	#include "megaraid_sas.h"
61	49
62	50
63		-extern void megasas_free_cmds(struct megasas_instance *instance);
64		-extern struct megasas_cmd *megasas_get_cmd(struct megasas_instance
65		- *instance);
66	51	extern void
67	52	megasas_complete_cmd(struct megasas_instance *instance,
68	53	struct megasas_cmd *cmd, u8 alt_status);
..	..	@@ -70,24 +55,14 @@
70	55	wait_and_poll(struct megasas_instance instance, struct megasas_cmd cmd,
71	56	int seconds);
72	57
73		-void
74		-megasas_return_cmd(struct megasas_instance instance, struct megasas_cmd cmd);
75		-int megasas_alloc_cmds(struct megasas_instance *instance);
76	58	int
77		-megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs);
78		-int
79		-megasas_issue_polled(struct megasas_instance *instance,
80		- struct megasas_cmd *cmd);
81		-void
82		-megasas_check_and_restore_queue_depth(struct megasas_instance *instance);
	59	+megasas_clear_intr_fusion(struct megasas_instance *instance);
83	60
84	61	int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
85		-void megaraid_sas_kill_hba(struct megasas_instance *instance);
86	62
87	63	extern u32 megasas_dbg_lvl;
88	64	int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
89	65	int initial);
90		-void megasas_start_timer(struct megasas_instance *instance);
91	66	extern struct megasas_mgmt_info megasas_mgmt_info;
92	67	extern unsigned int resetwaittime;
93	68	extern unsigned int dual_qdepth_disable;
..	..	@@ -95,14 +70,71 @@
95	70	static void megasas_free_reply_fusion(struct megasas_instance *instance);
96	71	static inline
97	72	void megasas_configure_queue_sizes(struct megasas_instance *instance);
	73	+static void megasas_fusion_crash_dump(struct megasas_instance *instance);
	74	+
	75	+/**
	76	+ * megasas_adp_reset_wait_for_ready - initiate chip reset and wait for
	77	+ * controller to come to ready state
	78	+ * @instance: adapter's soft state
	79	+ * @do_adp_reset: If true, do a chip reset
	80	+ * @ocr_context: If called from OCR context this will
	81	+ * be set to 1, else 0
	82	+ *
	83	+ * This function initates a chip reset followed by a wait for controller to
	84	+ * transition to ready state.
	85	+ * During this, driver will block all access to PCI config space from userspace
	86	+ */
	87	+int
	88	+megasas_adp_reset_wait_for_ready(struct megasas_instance *instance,
	89	+ bool do_adp_reset,
	90	+ int ocr_context)
	91	+{
	92	+ int ret = FAILED;
	93	+
	94	+ /*
	95	+ * Block access to PCI config space from userspace
	96	+ * when diag reset is initiated from driver
	97	+ */
	98	+ if (megasas_dbg_lvl & OCR_DEBUG)
	99	+ dev_info(&instance->pdev->dev,
	100	+ "Block access to PCI config space %s %d\n",
	101	+ __func__, __LINE__);
	102	+
	103	+ pci_cfg_access_lock(instance->pdev);
	104	+
	105	+ if (do_adp_reset) {
	106	+ if (instance->instancet->adp_reset
	107	+ (instance, instance->reg_set))
	108	+ goto out;
	109	+ }
	110	+
	111	+ /* Wait for FW to become ready */
	112	+ if (megasas_transition_to_ready(instance, ocr_context)) {
	113	+ dev_warn(&instance->pdev->dev,
	114	+ "Failed to transition controller to ready for scsi%d.\n",
	115	+ instance->host->host_no);
	116	+ goto out;
	117	+ }
	118	+
	119	+ ret = SUCCESS;
	120	+out:
	121	+ if (megasas_dbg_lvl & OCR_DEBUG)
	122	+ dev_info(&instance->pdev->dev,
	123	+ "Unlock access to PCI config space %s %d\n",
	124	+ __func__, __LINE__);
	125	+
	126	+ pci_cfg_access_unlock(instance->pdev);
	127	+
	128	+ return ret;
	129	+}
98	130
99	131	/**
100	132	* megasas_check_same_4gb_region - check if allocation
101	133	* crosses same 4GB boundary or not
102		- * @instance - adapter's soft instance
103		- * start_addr - start address of DMA allocation
104		- * size - size of allocation in bytes
105		- * return - true : allocation does not cross same
	134	+ * @instance: adapter's soft instance
	135	+ * @start_addr: start address of DMA allocation
	136	+ * @size: size of allocation in bytes
	137	+ * @return: true : allocation does not cross same
106	138	* 4GB boundary
107	139	* false: allocation crosses same
108	140	* 4GB boundary
..	..	@@ -127,9 +159,9 @@
127	159
128	160	/**
129	161	* megasas_enable_intr_fusion - Enables interrupts
130		- * @regs: MFI register set
	162	+ * @instance: adapter's soft instance
131	163	*/
132		-void
	164	+static void
133	165	megasas_enable_intr_fusion(struct megasas_instance *instance)
134	166	{
135	167	struct megasas_register_set __iomem *regs;
..	..	@@ -143,35 +175,39 @@
143	175	writel(~MFI_FUSION_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
144	176
145	177	/* Dummy readl to force pci flush */
146		- readl(&regs->outbound_intr_mask);
	178	+ dev_info(&instance->pdev->dev, "%s is called outbound_intr_mask:0x%08x\n",
	179	+ __func__, readl(&regs->outbound_intr_mask));
147	180	}
148	181
149	182	/**
150	183	* megasas_disable_intr_fusion - Disables interrupt
151		- * @regs: MFI register set
	184	+ * @instance: adapter's soft instance
152	185	*/
153		-void
	186	+static void
154	187	megasas_disable_intr_fusion(struct megasas_instance *instance)
155	188	{
156	189	u32 mask = 0xFFFFFFFF;
157		- u32 status;
158	190	struct megasas_register_set __iomem *regs;
159	191	regs = instance->reg_set;
160	192	instance->mask_interrupts = 1;
161	193
162	194	writel(mask, &regs->outbound_intr_mask);
163	195	/* Dummy readl to force pci flush */
164		- status = readl(&regs->outbound_intr_mask);
	196	+ dev_info(&instance->pdev->dev, "%s is called outbound_intr_mask:0x%08x\n",
	197	+ __func__, readl(&regs->outbound_intr_mask));
165	198	}
166	199
167	200	int
168		-megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs)
	201	+megasas_clear_intr_fusion(struct megasas_instance *instance)
169	202	{
170	203	u32 status;
	204	+ struct megasas_register_set __iomem *regs;
	205	+ regs = instance->reg_set;
171	206	/*
172	207	* Check if it is our interrupt
173	208	*/
174		- status = readl(&regs->outbound_intr_status);
	209	+ status = megasas_readl(instance,
	210	+ &regs->outbound_intr_status);
175	211
176	212	if (status & 1) {
177	213	writel(status, &regs->outbound_intr_status);
..	..	@@ -187,6 +223,7 @@
187	223	/**
188	224	* megasas_get_cmd_fusion - Get a command from the free pool
189	225	* @instance: Adapter soft state
	226	+ * @blk_tag: Command tag
190	227	*
191	228	* Returns a blk_tag indexed mpt frame
192	229	*/
..	..	@@ -214,21 +251,17 @@
214	251	}
215	252
216	253	/**
217		- * megasas_fire_cmd_fusion - Sends command to the FW
218		- * @instance: Adapter soft state
219		- * @req_desc: 64bit Request descriptor
220		- *
221		- * Perform PCI Write.
	254	+ * megasas_write_64bit_req_desc - PCI writes 64bit request descriptor
	255	+ * @instance: Adapter soft state
	256	+ * @req_desc: 64bit Request descriptor
222	257	*/
223		-
224	258	static void
225		-megasas_fire_cmd_fusion(struct megasas_instance *instance,
	259	+megasas_write_64bit_req_desc(struct megasas_instance *instance,
226	260	union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc)
227	261	{
228	262	#if defined(writeq) && defined(CONFIG_64BIT)
229	263	u64 req_data = (((u64)le32_to_cpu(req_desc->u.high) << 32) \|
230	264	le32_to_cpu(req_desc->u.low));
231		-
232	265	writeq(req_data, &instance->reg_set->inbound_low_queue_port);
233	266	#else
234	267	unsigned long flags;
..	..	@@ -237,15 +270,33 @@
237	270	&instance->reg_set->inbound_low_queue_port);
238	271	writel(le32_to_cpu(req_desc->u.high),
239	272	&instance->reg_set->inbound_high_queue_port);
240		- mmiowb();
241	273	spin_unlock_irqrestore(&instance->hba_lock, flags);
242	274	#endif
243	275	}
244	276
245	277	/**
	278	+ * megasas_fire_cmd_fusion - Sends command to the FW
	279	+ * @instance: Adapter soft state
	280	+ * @req_desc: 32bit or 64bit Request descriptor
	281	+ *
	282	+ * Perform PCI Write. AERO SERIES supports 32 bit Descriptor.
	283	+ * Prior to AERO_SERIES support 64 bit Descriptor.
	284	+ */
	285	+static void
	286	+megasas_fire_cmd_fusion(struct megasas_instance *instance,
	287	+ union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc)
	288	+{
	289	+ if (instance->atomic_desc_support)
	290	+ writel(le32_to_cpu(req_desc->u.low),
	291	+ &instance->reg_set->inbound_single_queue_port);
	292	+ else
	293	+ megasas_write_64bit_req_desc(instance, req_desc);
	294	+}
	295	+
	296	+/**
246	297	* megasas_fusion_update_can_queue - Do all Adapter Queue depth related calculations here
247		- * @instance: Adapter soft state
248		- * fw_boot_context: Whether this function called during probe or after OCR
	298	+ * @instance: Adapter soft state
	299	+ * @fw_boot_context: Whether this function called during probe or after OCR
249	300	*
250	301	* This function is only for fusion controllers.
251	302	* Update host can queue, if firmware downgrade max supported firmware commands.
..	..	@@ -258,20 +309,18 @@
258	309	{
259	310	u16 cur_max_fw_cmds = 0;
260	311	u16 ldio_threshold = 0;
261		- struct megasas_register_set __iomem *reg_set;
262	312
263		- reg_set = instance->reg_set;
264		-
265		- /* ventura FW does not fill outbound_scratch_pad_3 with queue depth */
	313	+ /* ventura FW does not fill outbound_scratch_pad_2 with queue depth */
266	314	if (instance->adapter_type < VENTURA_SERIES)
267	315	cur_max_fw_cmds =
268		- readl(&instance->reg_set->outbound_scratch_pad_3) & 0x00FFFF;
	316	+ megasas_readl(instance,
	317	+ &instance->reg_set->outbound_scratch_pad_2) & 0x00FFFF;
269	318
270	319	if (dual_qdepth_disable \|\| !cur_max_fw_cmds)
271		- cur_max_fw_cmds = instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF;
	320	+ cur_max_fw_cmds = instance->instancet->read_fw_status_reg(instance) & 0x00FFFF;
272	321	else
273	322	ldio_threshold =
274		- (instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF) - MEGASAS_FUSION_IOCTL_CMDS;
	323	+ (instance->instancet->read_fw_status_reg(instance) & 0x00FFFF) - MEGASAS_FUSION_IOCTL_CMDS;
275	324
276	325	dev_info(&instance->pdev->dev,
277	326	"Current firmware supports maximum commands: %d\t LDIO threshold: %d\n",
..	..	@@ -301,6 +350,35 @@
301	350	instance->max_fw_cmds = instance->max_fw_cmds-1;
302	351	}
303	352	}
	353	+
	354	+static inline void
	355	+megasas_get_msix_index(struct megasas_instance *instance,
	356	+ struct scsi_cmnd *scmd,
	357	+ struct megasas_cmd_fusion *cmd,
	358	+ u8 data_arms)
	359	+{
	360	+ int sdev_busy;
	361	+
	362	+ /* nr_hw_queue = 1 for MegaRAID */
	363	+ struct blk_mq_hw_ctx *hctx =
	364	+ scmd->device->request_queue->queue_hw_ctx[0];
	365	+
	366	+ sdev_busy = atomic_read(&hctx->nr_active);
	367	+
	368	+ if (instance->perf_mode == MR_BALANCED_PERF_MODE &&
	369	+ sdev_busy > (data_arms * MR_DEVICE_HIGH_IOPS_DEPTH))
	370	+ cmd->request_desc->SCSIIO.MSIxIndex =
	371	+ mega_mod64((atomic64_add_return(1, &instance->high_iops_outstanding) /
	372	+ MR_HIGH_IOPS_BATCH_COUNT), instance->low_latency_index_start);
	373	+ else if (instance->msix_load_balance)
	374	+ cmd->request_desc->SCSIIO.MSIxIndex =
	375	+ (mega_mod64(atomic64_add_return(1, &instance->total_io_count),
	376	+ instance->msix_vectors));
	377	+ else
	378	+ cmd->request_desc->SCSIIO.MSIxIndex =
	379	+ instance->reply_map[raw_smp_processor_id()];
	380	+}
	381	+
304	382	/**
305	383	* megasas_free_cmds_fusion - Free all the cmds in the free cmd pool
306	384	* @instance: Adapter soft state
..	..	@@ -471,7 +549,7 @@
471	549	return 0;
472	550	}
473	551
474		-int
	552	+static int
475	553	megasas_alloc_cmdlist_fusion(struct megasas_instance *instance)
476	554	{
477	555	u32 max_mpt_cmd, i, j;
..	..	@@ -510,7 +588,8 @@
510	588
511	589	return 0;
512	590	}
513		-int
	591	+
	592	+static int
514	593	megasas_alloc_request_fusion(struct megasas_instance *instance)
515	594	{
516	595	struct fusion_context *fusion;
..	..	@@ -592,7 +671,7 @@
592	671	return 0;
593	672	}
594	673
595		-int
	674	+static int
596	675	megasas_alloc_reply_fusion(struct megasas_instance *instance)
597	676	{
598	677	int i, count;
..	..	@@ -669,7 +748,7 @@
669	748	return 0;
670	749	}
671	750
672		-int
	751	+static int
673	752	megasas_alloc_rdpq_fusion(struct megasas_instance *instance)
674	753	{
675	754	int i, j, k, msix_count;
..	..	@@ -685,8 +764,9 @@
685	764	array_size = sizeof(struct MPI2_IOC_INIT_RDPQ_ARRAY_ENTRY) *
686	765	MAX_MSIX_QUEUES_FUSION;
687	766
688		- fusion->rdpq_virt = pci_zalloc_consistent(instance->pdev, array_size,
689		- &fusion->rdpq_phys);
	767	+ fusion->rdpq_virt = dma_alloc_coherent(&instance->pdev->dev,
	768	+ array_size, &fusion->rdpq_phys,
	769	+ GFP_KERNEL);
690	770	if (!fusion->rdpq_virt) {
691	771	dev_err(&instance->pdev->dev,
692	772	"Failed from %s %d\n", __func__, __LINE__);
..	..	@@ -808,13 +888,11 @@
808	888
809	889	}
810	890
811		- if (fusion->reply_frames_desc_pool)
812		- dma_pool_destroy(fusion->reply_frames_desc_pool);
813		- if (fusion->reply_frames_desc_pool_align)
814		- dma_pool_destroy(fusion->reply_frames_desc_pool_align);
	891	+ dma_pool_destroy(fusion->reply_frames_desc_pool);
	892	+ dma_pool_destroy(fusion->reply_frames_desc_pool_align);
815	893
816	894	if (fusion->rdpq_virt)
817		- pci_free_consistent(instance->pdev,
	895	+ dma_free_coherent(&instance->pdev->dev,
818	896	sizeof(struct MPI2_IOC_INIT_RDPQ_ARRAY_ENTRY) * MAX_MSIX_QUEUES_FUSION,
819	897	fusion->rdpq_virt, fusion->rdpq_phys);
820	898	}
..	..	@@ -831,8 +909,7 @@
831	909	fusion->reply_frames_desc[0],
832	910	fusion->reply_frames_desc_phys[0]);
833	911
834		- if (fusion->reply_frames_desc_pool)
835		- dma_pool_destroy(fusion->reply_frames_desc_pool);
	912	+ dma_pool_destroy(fusion->reply_frames_desc_pool);
836	913
837	914	}
838	915
..	..	@@ -853,7 +930,7 @@
853	930	* and is used as SMID of the cmd.
854	931	* SMID value range is from 1 to max_fw_cmds.
855	932	*/
856		-int
	933	+static int
857	934	megasas_alloc_cmds_fusion(struct megasas_instance *instance)
858	935	{
859	936	int i;
..	..	@@ -925,6 +1002,7 @@
925	1002	* wait_and_poll - Issues a polling command
926	1003	* @instance: Adapter soft state
927	1004	* @cmd: Command packet to be issued
	1005	+ * @seconds: Maximum poll time
928	1006	*
929	1007	* For polling, MFI requires the cmd_status to be set to 0xFF before posting.
930	1008	*/
..	..	@@ -934,17 +1012,22 @@
934	1012	{
935	1013	int i;
936	1014	struct megasas_header *frame_hdr = &cmd->frame->hdr;
937		- struct fusion_context *fusion;
	1015	+ u32 status_reg;
938	1016
939	1017	u32 msecs = seconds * 1000;
940	1018
941		- fusion = instance->ctrl_context;
942	1019	/*
943	1020	* Wait for cmd_status to change
944	1021	*/
945	1022	for (i = 0; (i < msecs) && (frame_hdr->cmd_status == 0xff); i += 20) {
946	1023	rmb();
947	1024	msleep(20);
	1025	+ if (!(i % 5000)) {
	1026	+ status_reg = instance->instancet->read_fw_status_reg(instance)
	1027	+ & MFI_STATE_MASK;
	1028	+ if (status_reg == MFI_STATE_FAULT)
	1029	+ break;
	1030	+ }
948	1031	}
949	1032
950	1033	if (frame_hdr->cmd_status == MFI_STAT_INVALID_STATUS)
..	..	@@ -975,9 +1058,10 @@
975	1058	struct megasas_header *frame_hdr;
976	1059	const char *sys_info;
977	1060	MFI_CAPABILITIES *drv_ops;
978		- u32 scratch_pad_2;
	1061	+ u32 scratch_pad_1;
979	1062	ktime_t time;
980	1063	bool cur_fw_64bit_dma_capable;
	1064	+ bool cur_intr_coalescing;
981	1065
982	1066	fusion = instance->ctrl_context;
983	1067
..	..	@@ -986,14 +1070,14 @@
986	1070
987	1071	cmd = fusion->ioc_init_cmd;
988	1072
989		- scratch_pad_2 = readl
990		- (&instance->reg_set->outbound_scratch_pad_2);
	1073	+ scratch_pad_1 = megasas_readl
	1074	+ (instance, &instance->reg_set->outbound_scratch_pad_1);
991	1075
992		- cur_rdpq_mode = (scratch_pad_2 & MR_RDPQ_MODE_OFFSET) ? 1 : 0;
	1076	+ cur_rdpq_mode = (scratch_pad_1 & MR_RDPQ_MODE_OFFSET) ? 1 : 0;
993	1077
994	1078	if (instance->adapter_type == INVADER_SERIES) {
995	1079	cur_fw_64bit_dma_capable =
996		- (scratch_pad_2 & MR_CAN_HANDLE_64_BIT_DMA_OFFSET) ? true : false;
	1080	+ (scratch_pad_1 & MR_CAN_HANDLE_64_BIT_DMA_OFFSET) ? true : false;
997	1081
998	1082	if (instance->consistent_mask_64bit && !cur_fw_64bit_dma_capable) {
999	1083	dev_err(&instance->pdev->dev, "Driver was operating on 64bit "
..	..	@@ -1011,7 +1095,17 @@
1011	1095	goto fail_fw_init;
1012	1096	}
1013	1097
1014		- instance->fw_sync_cache_support = (scratch_pad_2 &
	1098	+ cur_intr_coalescing = (scratch_pad_1 & MR_INTR_COALESCING_SUPPORT_OFFSET) ?
	1099	+ true : false;
	1100	+
	1101	+ if ((instance->low_latency_index_start ==
	1102	+ MR_HIGH_IOPS_QUEUE_COUNT) && cur_intr_coalescing)
	1103	+ instance->perf_mode = MR_BALANCED_PERF_MODE;
	1104	+
	1105	+ dev_info(&instance->pdev->dev, "Performance mode :%s\n",
	1106	+ MEGASAS_PERF_MODE_2STR(instance->perf_mode));
	1107	+
	1108	+ instance->fw_sync_cache_support = (scratch_pad_1 &
1015	1109	MR_CAN_HANDLE_SYNC_CACHE_OFFSET) ? 1 : 0;
1016	1110	dev_info(&instance->pdev->dev, "FW supports sync cache\t: %s\n",
1017	1111	instance->fw_sync_cache_support ? "Yes" : "No");
..	..	@@ -1044,9 +1138,7 @@
1044	1138
1045	1139	frame_hdr = &cmd->frame->hdr;
1046	1140	frame_hdr->cmd_status = 0xFF;
1047		- frame_hdr->flags = cpu_to_le16(
1048		- le16_to_cpu(frame_hdr->flags) \|
1049		- MFI_FRAME_DONT_POST_IN_REPLY_QUEUE);
	1141	+ frame_hdr->flags \|= cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE);
1050	1142
1051	1143	init_frame->cmd = MFI_CMD_INIT;
1052	1144	init_frame->cmd_status = 0xFF;
..	..	@@ -1073,6 +1165,7 @@
1073	1165	drv_ops->mfi_capabilities.support_qd_throttling = 1;
1074	1166	drv_ops->mfi_capabilities.support_pd_map_target_id = 1;
1075	1167	drv_ops->mfi_capabilities.support_nvme_passthru = 1;
	1168	+ drv_ops->mfi_capabilities.support_fw_exposed_dev_list = 1;
1076	1169
1077	1170	if (instance->consistent_mask_64bit)
1078	1171	drv_ops->mfi_capabilities.support_64bit_mode = 1;
..	..	@@ -1096,6 +1189,22 @@
1096	1189	cpu_to_le32(lower_32_bits(ioc_init_handle));
1097	1190	init_frame->data_xfer_len = cpu_to_le32(sizeof(struct MPI2_IOC_INIT_REQUEST));
1098	1191
	1192	+ /*
	1193	+ * Each bit in replyqueue_mask represents one group of MSI-x vectors
	1194	+ * (each group has 8 vectors)
	1195	+ */
	1196	+ switch (instance->perf_mode) {
	1197	+ case MR_BALANCED_PERF_MODE:
	1198	+ init_frame->replyqueue_mask =
	1199	+ cpu_to_le16(~(~0 << instance->low_latency_index_start/8));
	1200	+ break;
	1201	+ case MR_IOPS_PERF_MODE:
	1202	+ init_frame->replyqueue_mask =
	1203	+ cpu_to_le16(~(~0 << instance->msix_vectors/8));
	1204	+ break;
	1205	+ }
	1206	+
	1207	+
1099	1208	req_desc.u.low = cpu_to_le32(lower_32_bits(cmd->frame_phys_addr));
1100	1209	req_desc.u.high = cpu_to_le32(upper_32_bits(cmd->frame_phys_addr));
1101	1210	req_desc.MFAIo.RequestFlags =
..	..	@@ -1108,20 +1217,32 @@
1108	1217	instance->instancet->disable_intr(instance);
1109	1218
1110	1219	for (i = 0; i < (10 * 1000); i += 20) {
1111		- if (readl(&instance->reg_set->doorbell) & 1)
	1220	+ if (megasas_readl(instance, &instance->reg_set->doorbell) & 1)
1112	1221	msleep(20);
1113	1222	else
1114	1223	break;
1115	1224	}
1116	1225
1117		- megasas_fire_cmd_fusion(instance, &req_desc);
	1226	+ /* For AERO also, IOC_INIT requires 64 bit descriptor write */
	1227	+ megasas_write_64bit_req_desc(instance, &req_desc);
1118	1228
1119		- wait_and_poll(instance, cmd, MFI_POLL_TIMEOUT_SECS);
	1229	+ wait_and_poll(instance, cmd, MFI_IO_TIMEOUT_SECS);
1120	1230
1121	1231	frame_hdr = &cmd->frame->hdr;
1122	1232	if (frame_hdr->cmd_status != 0) {
1123	1233	ret = 1;
1124	1234	goto fail_fw_init;
	1235	+ }
	1236	+
	1237	+ if (instance->adapter_type >= AERO_SERIES) {
	1238	+ scratch_pad_1 = megasas_readl
	1239	+ (instance, &instance->reg_set->outbound_scratch_pad_1);
	1240	+
	1241	+ instance->atomic_desc_support =
	1242	+ (scratch_pad_1 & MR_ATOMIC_DESCRIPTOR_SUPPORT_OFFSET) ? 1 : 0;
	1243	+
	1244	+ dev_info(&instance->pdev->dev, "FW supports atomic descriptor\t: %s\n",
	1245	+ instance->atomic_desc_support ? "Yes" : "No");
1125	1246	}
1126	1247
1127	1248	return 0;
..	..	@@ -1146,7 +1267,7 @@
1146	1267	int
1147	1268	megasas_sync_pd_seq_num(struct megasas_instance *instance, bool pend) {
1148	1269	int ret = 0;
1149		- u32 pd_seq_map_sz;
	1270	+ size_t pd_seq_map_sz;
1150	1271	struct megasas_cmd *cmd;
1151	1272	struct megasas_dcmd_frame *dcmd;
1152	1273	struct fusion_context *fusion = instance->ctrl_context;
..	..	@@ -1155,9 +1276,7 @@
1155	1276
1156	1277	pd_sync = (void *)fusion->pd_seq_sync[(instance->pd_seq_map_id & 1)];
1157	1278	pd_seq_h = fusion->pd_seq_phys[(instance->pd_seq_map_id & 1)];
1158		- pd_seq_map_sz = sizeof(struct MR_PD_CFG_SEQ_NUM_SYNC) +
1159		- (sizeof(struct MR_PD_CFG_SEQ) *
1160		- (MAX_PHYSICAL_DEVICES - 1));
	1279	+ pd_seq_map_sz = struct_size(pd_sync, seq, MAX_PHYSICAL_DEVICES - 1);
1161	1280
1162	1281	cmd = megasas_get_cmd(instance);
1163	1282	if (!cmd) {
..	..	@@ -1210,7 +1329,9 @@
1210	1329	}
1211	1330
1212	1331	if (ret == DCMD_TIMEOUT)
1213		- megaraid_sas_kill_hba(instance);
	1332	+ dev_warn(&instance->pdev->dev,
	1333	+ "%s DCMD timed out, continue without JBOD sequence map\n",
	1334	+ __func__);
1214	1335
1215	1336	if (ret == DCMD_SUCCESS)
1216	1337	instance->pd_seq_map_id++;
..	..	@@ -1292,7 +1413,9 @@
1292	1413	ret = megasas_issue_polled(instance, cmd);
1293	1414
1294	1415	if (ret == DCMD_TIMEOUT)
1295		- megaraid_sas_kill_hba(instance);
	1416	+ dev_warn(&instance->pdev->dev,
	1417	+ "%s DCMD timed out, RAID map is disabled\n",
	1418	+ __func__);
1296	1419
1297	1420	megasas_return_cmd(instance, cmd);
1298	1421
..	..	@@ -1329,7 +1452,6 @@
1329	1452	struct megasas_cmd *cmd;
1330	1453	struct megasas_dcmd_frame *dcmd;
1331	1454	u16 num_lds;
1332		- u32 size_sync_info;
1333	1455	struct fusion_context *fusion;
1334	1456	struct MR_LD_TARGET_SYNC *ci = NULL;
1335	1457	struct MR_DRV_RAID_MAP_ALL *map;
..	..	@@ -1357,8 +1479,6 @@
1357	1479	num_lds = le16_to_cpu(map->raidMap.ldCount);
1358	1480
1359	1481	dcmd = &cmd->frame->dcmd;
1360		-
1361		- size_sync_info = sizeof(struct MR_LD_TARGET_SYNC) *num_lds;
1362	1482
1363	1483	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
1364	1484
..	..	@@ -1560,14 +1680,12 @@
1560	1680	fusion = instance->ctrl_context;
1561	1681	max_cmd = instance->max_fw_cmds;
1562	1682
1563		- if (instance->adapter_type == VENTURA_SERIES)
	1683	+ if (instance->adapter_type >= VENTURA_SERIES)
1564	1684	instance->max_mpt_cmds = instance->max_fw_cmds * RAID_1_PEER_CMDS;
1565	1685	else
1566	1686	instance->max_mpt_cmds = instance->max_fw_cmds;
1567	1687
1568		- instance->max_scsi_cmds = instance->max_fw_cmds -
1569		- (MEGASAS_FUSION_INTERNAL_CMDS +
1570		- MEGASAS_FUSION_IOCTL_CMDS);
	1688	+ instance->max_scsi_cmds = instance->max_fw_cmds - instance->max_mfi_cmds;
1571	1689	instance->cur_can_queue = instance->max_scsi_cmds;
1572	1690	instance->host->can_queue = instance->cur_can_queue;
1573	1691
..	..	@@ -1628,8 +1746,7 @@
1628	1746	fusion->ioc_init_cmd->frame,
1629	1747	fusion->ioc_init_cmd->frame_phys_addr);
1630	1748
1631		- if (fusion->ioc_init_cmd)
1632		- kfree(fusion->ioc_init_cmd);
	1749	+ kfree(fusion->ioc_init_cmd);
1633	1750	}
1634	1751
1635	1752	/**
..	..	@@ -1638,17 +1755,15 @@
1638	1755	*
1639	1756	* This is the main function for initializing firmware.
1640	1757	*/
1641		-u32
	1758	+static u32
1642	1759	megasas_init_adapter_fusion(struct megasas_instance *instance)
1643	1760	{
1644		- struct megasas_register_set __iomem *reg_set;
1645	1761	struct fusion_context *fusion;
1646		- u32 scratch_pad_2;
	1762	+ u32 scratch_pad_1;
1647	1763	int i = 0, count;
	1764	+ u32 status_reg;
1648	1765
1649	1766	fusion = instance->ctrl_context;
1650		-
1651		- reg_set = instance->reg_set;
1652	1767
1653	1768	megasas_fusion_update_can_queue(instance, PROBE_CONTEXT);
1654	1769
..	..	@@ -1660,20 +1775,21 @@
1660	1775
1661	1776	megasas_configure_queue_sizes(instance);
1662	1777
1663		- scratch_pad_2 = readl(&instance->reg_set->outbound_scratch_pad_2);
1664		- /* If scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_UNITS_MASK is set,
	1778	+ scratch_pad_1 = megasas_readl(instance,
	1779	+ &instance->reg_set->outbound_scratch_pad_1);
	1780	+ /* If scratch_pad_1 & MEGASAS_MAX_CHAIN_SIZE_UNITS_MASK is set,
1665	1781	* Firmware support extended IO chain frame which is 4 times more than
1666	1782	* legacy Firmware.
1667	1783	* Legacy Firmware - Frame size is (8 * 128) = 1K
1668	1784	* 1M IO Firmware - Frame size is (8 * 128 * 4) = 4K
1669	1785	*/
1670		- if (scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_UNITS_MASK)
	1786	+ if (scratch_pad_1 & MEGASAS_MAX_CHAIN_SIZE_UNITS_MASK)
1671	1787	instance->max_chain_frame_sz =
1672		- ((scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_MASK) >>
	1788	+ ((scratch_pad_1 & MEGASAS_MAX_CHAIN_SIZE_MASK) >>
1673	1789	MEGASAS_MAX_CHAIN_SHIFT) * MEGASAS_1MB_IO;
1674	1790	else
1675	1791	instance->max_chain_frame_sz =
1676		- ((scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_MASK) >>
	1792	+ ((scratch_pad_1 & MEGASAS_MAX_CHAIN_SIZE_MASK) >>
1677	1793	MEGASAS_MAX_CHAIN_SHIFT) * MEGASAS_256K_IO;
1678	1794
1679	1795	if (instance->max_chain_frame_sz < MEGASAS_CHAIN_FRAME_SZ_MIN) {
..	..	@@ -1728,8 +1844,21 @@
1728	1844	if (megasas_alloc_cmds_fusion(instance))
1729	1845	goto fail_alloc_cmds;
1730	1846
1731		- if (megasas_ioc_init_fusion(instance))
1732		- goto fail_ioc_init;
	1847	+ if (megasas_ioc_init_fusion(instance)) {
	1848	+ status_reg = instance->instancet->read_fw_status_reg(instance);
	1849	+ if (((status_reg & MFI_STATE_MASK) == MFI_STATE_FAULT) &&
	1850	+ (status_reg & MFI_RESET_ADAPTER)) {
	1851	+ /* Do a chip reset and then retry IOC INIT once */
	1852	+ if (megasas_adp_reset_wait_for_ready
	1853	+ (instance, true, 0) == FAILED)
	1854	+ goto fail_ioc_init;
	1855	+
	1856	+ if (megasas_ioc_init_fusion(instance))
	1857	+ goto fail_ioc_init;
	1858	+ } else {
	1859	+ goto fail_ioc_init;
	1860	+ }
	1861	+ }
1733	1862
1734	1863	megasas_display_intel_branding(instance);
1735	1864	if (megasas_get_ctrl_info(instance)) {
..	..	@@ -1741,6 +1870,7 @@
1741	1870
1742	1871	instance->flag_ieee = 1;
1743	1872	instance->r1_ldio_hint_default = MR_R1_LDIO_PIGGYBACK_DEFAULT;
	1873	+ instance->threshold_reply_count = instance->max_fw_cmds / 4;
1744	1874	fusion->fast_path_io = 0;
1745	1875
1746	1876	if (megasas_allocate_raid_maps(instance))
..	..	@@ -1761,13 +1891,100 @@
1761	1891	}
1762	1892
1763	1893	/**
1764		- * map_cmd_status - Maps FW cmd status to OS cmd status
1765		- * @cmd : Pointer to cmd
1766		- * @status : status of cmd returned by FW
1767		- * @ext_status : ext status of cmd returned by FW
	1894	+ * megasas_fault_detect_work - Worker function of
	1895	+ * FW fault handling workqueue.
	1896	+ * @work: FW fault work struct
1768	1897	*/
	1898	+static void
	1899	+megasas_fault_detect_work(struct work_struct *work)
	1900	+{
	1901	+ struct megasas_instance *instance =
	1902	+ container_of(work, struct megasas_instance,
	1903	+ fw_fault_work.work);
	1904	+ u32 fw_state, dma_state, status;
	1905	+
	1906	+ /* Check the fw state */
	1907	+ fw_state = instance->instancet->read_fw_status_reg(instance) &
	1908	+ MFI_STATE_MASK;
	1909	+
	1910	+ if (fw_state == MFI_STATE_FAULT) {
	1911	+ dma_state = instance->instancet->read_fw_status_reg(instance) &
	1912	+ MFI_STATE_DMADONE;
	1913	+ /* Start collecting crash, if DMA bit is done */
	1914	+ if (instance->crash_dump_drv_support &&
	1915	+ instance->crash_dump_app_support && dma_state) {
	1916	+ megasas_fusion_crash_dump(instance);
	1917	+ } else {
	1918	+ if (instance->unload == 0) {
	1919	+ status = megasas_reset_fusion(instance->host, 0);
	1920	+ if (status != SUCCESS) {
	1921	+ dev_err(&instance->pdev->dev,
	1922	+ "Failed from %s %d, do not re-arm timer\n",
	1923	+ __func__, __LINE__);
	1924	+ return;
	1925	+ }
	1926	+ }
	1927	+ }
	1928	+ }
	1929	+
	1930	+ if (instance->fw_fault_work_q)
	1931	+ queue_delayed_work(instance->fw_fault_work_q,
	1932	+ &instance->fw_fault_work,
	1933	+ msecs_to_jiffies(MEGASAS_WATCHDOG_THREAD_INTERVAL));
	1934	+}
	1935	+
	1936	+int
	1937	+megasas_fusion_start_watchdog(struct megasas_instance *instance)
	1938	+{
	1939	+ /* Check if the Fault WQ is already started */
	1940	+ if (instance->fw_fault_work_q)
	1941	+ return SUCCESS;
	1942	+
	1943	+ INIT_DELAYED_WORK(&instance->fw_fault_work, megasas_fault_detect_work);
	1944	+
	1945	+ snprintf(instance->fault_handler_work_q_name,
	1946	+ sizeof(instance->fault_handler_work_q_name),
	1947	+ "poll_megasas%d_status", instance->host->host_no);
	1948	+
	1949	+ instance->fw_fault_work_q =
	1950	+ create_singlethread_workqueue(instance->fault_handler_work_q_name);
	1951	+ if (!instance->fw_fault_work_q) {
	1952	+ dev_err(&instance->pdev->dev, "Failed from %s %d\n",
	1953	+ __func__, __LINE__);
	1954	+ return FAILED;
	1955	+ }
	1956	+
	1957	+ queue_delayed_work(instance->fw_fault_work_q,
	1958	+ &instance->fw_fault_work,
	1959	+ msecs_to_jiffies(MEGASAS_WATCHDOG_THREAD_INTERVAL));
	1960	+
	1961	+ return SUCCESS;
	1962	+}
1769	1963
1770	1964	void
	1965	+megasas_fusion_stop_watchdog(struct megasas_instance *instance)
	1966	+{
	1967	+ struct workqueue_struct *wq;
	1968	+
	1969	+ if (instance->fw_fault_work_q) {
	1970	+ wq = instance->fw_fault_work_q;
	1971	+ instance->fw_fault_work_q = NULL;
	1972	+ if (!cancel_delayed_work_sync(&instance->fw_fault_work))
	1973	+ flush_workqueue(wq);
	1974	+ destroy_workqueue(wq);
	1975	+ }
	1976	+}
	1977	+
	1978	+/**
	1979	+ * map_cmd_status - Maps FW cmd status to OS cmd status
	1980	+ * @fusion: fusion context
	1981	+ * @scmd: Pointer to cmd
	1982	+ * @status: status of cmd returned by FW
	1983	+ * @ext_status: ext status of cmd returned by FW
	1984	+ * @data_length: command data length
	1985	+ * @sense: command sense data
	1986	+ */
	1987	+static void
1771	1988	map_cmd_status(struct fusion_context *fusion,
1772	1989	struct scsi_cmnd *scmd, u8 status, u8 ext_status,
1773	1990	u32 data_length, u8 *sense)
..	..	@@ -1843,8 +2060,6 @@
1843	2060	megasas_is_prp_possible(struct megasas_instance *instance,
1844	2061	struct scsi_cmnd *scmd, int sge_count)
1845	2062	{
1846		- struct fusion_context *fusion;
1847		- int i;
1848	2063	u32 data_length = 0;
1849	2064	struct scatterlist *sg_scmd;
1850	2065	bool build_prp = false;
..	..	@@ -1852,7 +2067,6 @@
1852	2067
1853	2068	mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
1854	2069	MR_DEFAULT_NVME_PAGE_SIZE);
1855		- fusion = instance->ctrl_context;
1856	2070	data_length = scsi_bufflen(scmd);
1857	2071	sg_scmd = scsi_sglist(scmd);
1858	2072
..	..	@@ -1872,66 +2086,6 @@
1872	2086	/* check if 1st SG entry size is < residual beyond 4 pages */
1873	2087	if (sg_dma_len(sg_scmd) < (data_length - (mr_nvme_pg_size * 4)))
1874	2088	build_prp = true;
1875		- }
1876		-
1877		-/*
1878		- * Below code detects gaps/holes in IO data buffers.
1879		- * What does holes/gaps mean?
1880		- * Any SGE except first one in a SGL starts at non NVME page size
1881		- * aligned address OR Any SGE except last one in a SGL ends at
1882		- * non NVME page size boundary.
1883		- *
1884		- * Driver has already informed block layer by setting boundary rules for
1885		- * bio merging done at NVME page size boundary calling kernel API
1886		- * blk_queue_virt_boundary inside slave_config.
1887		- * Still there is possibility of IO coming with holes to driver because of
1888		- * IO merging done by IO scheduler.
1889		- *
1890		- * With SCSI BLK MQ enabled, there will be no IO with holes as there is no
1891		- * IO scheduling so no IO merging.
1892		- *
1893		- * With SCSI BLK MQ disabled, IO scheduler may attempt to merge IOs and
1894		- * then sending IOs with holes.
1895		- *
1896		- * Though driver can request block layer to disable IO merging by calling-
1897		- * blk_queue_flag_set(QUEUE_FLAG_NOMERGES, sdev->request_queue) but
1898		- * user may tune sysfs parameter- nomerges again to 0 or 1.
1899		- *
1900		- * If in future IO scheduling is enabled with SCSI BLK MQ,
1901		- * this algorithm to detect holes will be required in driver
1902		- * for SCSI BLK MQ enabled case as well.
1903		- *
1904		- *
1905		- */
1906		- scsi_for_each_sg(scmd, sg_scmd, sge_count, i) {
1907		- if ((i != 0) && (i != (sge_count - 1))) {
1908		- if (mega_mod64(sg_dma_len(sg_scmd), mr_nvme_pg_size) \|\|
1909		- mega_mod64(sg_dma_address(sg_scmd),
1910		- mr_nvme_pg_size)) {
1911		- build_prp = false;
1912		- atomic_inc(&instance->sge_holes_type1);
1913		- break;
1914		- }
1915		- }
1916		-
1917		- if ((sge_count > 1) && (i == 0)) {
1918		- if ((mega_mod64((sg_dma_address(sg_scmd) +
1919		- sg_dma_len(sg_scmd)),
1920		- mr_nvme_pg_size))) {
1921		- build_prp = false;
1922		- atomic_inc(&instance->sge_holes_type2);
1923		- break;
1924		- }
1925		- }
1926		-
1927		- if ((sge_count > 1) && (i == (sge_count - 1))) {
1928		- if (mega_mod64(sg_dma_address(sg_scmd),
1929		- mr_nvme_pg_size)) {
1930		- build_prp = false;
1931		- atomic_inc(&instance->sge_holes_type3);
1932		- break;
1933		- }
1934		- }
1935	2089	}
1936	2090
1937	2091	return build_prp;
..	..	@@ -1965,11 +2119,8 @@
1965	2119	u32 first_prp_len;
1966	2120	bool build_prp = false;
1967	2121	int data_len = scsi_bufflen(scmd);
1968		- struct fusion_context *fusion;
1969	2122	u32 mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
1970	2123	MR_DEFAULT_NVME_PAGE_SIZE);
1971		-
1972		- fusion = instance->ctrl_context;
1973	2124
1974	2125	build_prp = megasas_is_prp_possible(instance, scmd, sge_count);
1975	2126
..	..	@@ -2064,7 +2215,6 @@
2064	2215	main_chain_element->Length =
2065	2216	cpu_to_le32(num_prp_in_chain * sizeof(u64));
2066	2217
2067		- atomic_inc(&instance->prp_sgl);
2068	2218	return build_prp;
2069	2219	}
2070	2220
..	..	@@ -2074,7 +2224,7 @@
2074	2224	* @scp: SCSI command from the mid-layer
2075	2225	* @sgl_ptr: SGL to be filled in
2076	2226	* @cmd: cmd we are working on
2077		- * @sge_count sge count
	2227	+ * @sge_count: sge count
2078	2228	*
2079	2229	*/
2080	2230	static void
..	..	@@ -2139,7 +2289,6 @@
2139	2289	memset(sgl_ptr, 0, instance->max_chain_frame_sz);
2140	2290	}
2141	2291	}
2142		- atomic_inc(&instance->ieee_sgl);
2143	2292	}
2144	2293
2145	2294	/**
..	..	@@ -2184,13 +2333,16 @@
2184	2333
2185	2334	/**
2186	2335	* megasas_set_pd_lba - Sets PD LBA
2187		- * @cdb: CDB
	2336	+ * @io_request: IO request
2188	2337	* @cdb_len: cdb length
2189		- * @start_blk: Start block of IO
	2338	+ * @io_info: IO information
	2339	+ * @scp: SCSI command
	2340	+ * @local_map_ptr: Raid map
	2341	+ * @ref_tag: Primary reference tag
2190	2342	*
2191	2343	* Used to set the PD LBA in CDB for FP IOs
2192	2344	*/
2193		-void
	2345	+static void
2194	2346	megasas_set_pd_lba(struct MPI2_RAID_SCSI_IO_REQUEST *io_request, u8 cdb_len,
2195	2347	struct IO_REQUEST_INFO io_info, struct scsi_cmnd scp,
2196	2348	struct MR_DRV_RAID_MAP_ALL *local_map_ptr, u32 ref_tag)
..	..	@@ -2210,7 +2362,7 @@
2210	2362	cdb[0] = MEGASAS_SCSI_VARIABLE_LENGTH_CMD;
2211	2363	cdb[7] = MEGASAS_SCSI_ADDL_CDB_LEN;
2212	2364
2213		- if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
	2365	+ if (scp->sc_data_direction == DMA_FROM_DEVICE)
2214	2366	cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_READ32;
2215	2367	else
2216	2368	cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_WRITE32;
..	..	@@ -2239,7 +2391,7 @@
2239	2391	cdb[31] = (u8)(num_blocks & 0xff);
2240	2392
2241	2393	/* set SCSI IO EEDPFlags */
2242		- if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) {
	2394	+ if (scp->sc_data_direction == DMA_FROM_DEVICE) {
2243	2395	io_request->EEDPFlags = cpu_to_le16(
2244	2396	MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG \|
2245	2397	MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG \|
..	..	@@ -2444,16 +2596,19 @@
2444	2596	* affinity (cpu of the controller) and raid_flags in the raid context
2445	2597	* based on IO type.
2446	2598	*
	2599	+ * @fusion: Fusion context
2447	2600	* @praid_context: IO RAID context
2448	2601	* @raid: LD raid map
2449	2602	* @fp_possible: Is fast path possible?
2450	2603	* @is_read: Is read IO?
	2604	+ * @scsi_buff_len: SCSI command buffer length
2451	2605	*
2452	2606	*/
2453	2607	static void
2454		-megasas_set_raidflag_cpu_affinity(union RAID_CONTEXT_UNION *praid_context,
2455		- struct MR_LD_RAID *raid, bool fp_possible,
2456		- u8 is_read, u32 scsi_buff_len)
	2608	+megasas_set_raidflag_cpu_affinity(struct fusion_context *fusion,
	2609	+ union RAID_CONTEXT_UNION *praid_context,
	2610	+ struct MR_LD_RAID *raid, bool fp_possible,
	2611	+ u8 is_read, u32 scsi_buff_len)
2457	2612	{
2458	2613	u8 cpu_sel = MR_RAID_CTX_CPUSEL_0;
2459	2614	struct RAID_CONTEXT_G35 *rctx_g35;
..	..	@@ -2511,11 +2666,11 @@
2511	2666	* vs MR_RAID_FLAGS_IO_SUB_TYPE_CACHE_BYPASS.
2512	2667	* IO Subtype is not bitmap.
2513	2668	*/
2514		- if ((raid->level == 1) && (!is_read)) {
2515		- if (scsi_buff_len > MR_LARGE_IO_MIN_SIZE)
2516		- praid_context->raid_context_g35.raid_flags =
2517		- (MR_RAID_FLAGS_IO_SUB_TYPE_LDIO_BW_LIMIT
2518		- << MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT);
	2669	+ if ((fusion->pcie_bw_limitation) && (raid->level == 1) && (!is_read) &&
	2670	+ (scsi_buff_len > MR_LARGE_IO_MIN_SIZE)) {
	2671	+ praid_context->raid_context_g35.raid_flags =
	2672	+ (MR_RAID_FLAGS_IO_SUB_TYPE_LDIO_BW_LIMIT
	2673	+ << MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT);
2519	2674	}
2520	2675	}
2521	2676
..	..	@@ -2528,7 +2683,7 @@
2528	2683	* Prepares the io_request and chain elements (sg_frame) for IO
2529	2684	* The IO can be for PD (Fast Path) or LD
2530	2685	*/
2531		-void
	2686	+static void
2532	2687	megasas_build_ldio_fusion(struct megasas_instance *instance,
2533	2688	struct scsi_cmnd *scp,
2534	2689	struct megasas_cmd_fusion *cmd)
..	..	@@ -2538,27 +2693,27 @@
2538	2693	u32 start_lba_lo, start_lba_hi, device_id, datalength = 0;
2539	2694	u32 scsi_buff_len;
2540	2695	struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
2541		- union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
2542	2696	struct IO_REQUEST_INFO io_info;
2543	2697	struct fusion_context *fusion;
2544	2698	struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
2545	2699	u8 *raidLUN;
2546	2700	unsigned long spinlock_flags;
2547		- union RAID_CONTEXT_UNION *praid_context;
2548	2701	struct MR_LD_RAID *raid = NULL;
2549	2702	struct MR_PRIV_DEVICE *mrdev_priv;
	2703	+ struct RAID_CONTEXT *rctx;
	2704	+ struct RAID_CONTEXT_G35 *rctx_g35;
2550	2705
2551	2706	device_id = MEGASAS_DEV_INDEX(scp);
2552	2707
2553	2708	fusion = instance->ctrl_context;
2554	2709
2555	2710	io_request = cmd->io_request;
2556		- io_request->RaidContext.raid_context.virtual_disk_tgt_id =
2557		- cpu_to_le16(device_id);
2558		- io_request->RaidContext.raid_context.status = 0;
2559		- io_request->RaidContext.raid_context.ex_status = 0;
	2711	+ rctx = &io_request->RaidContext.raid_context;
	2712	+ rctx_g35 = &io_request->RaidContext.raid_context_g35;
2560	2713
2561		- req_desc = (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)cmd->request_desc;
	2714	+ rctx->virtual_disk_tgt_id = cpu_to_le16(device_id);
	2715	+ rctx->status = 0;
	2716	+ rctx->ex_status = 0;
2562	2717
2563	2718	start_lba_lo = 0;
2564	2719	start_lba_hi = 0;
..	..	@@ -2621,8 +2776,9 @@
2621	2776	io_info.r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
2622	2777	scsi_buff_len = scsi_bufflen(scp);
2623	2778	io_request->DataLength = cpu_to_le32(scsi_buff_len);
	2779	+ io_info.data_arms = 1;
2624	2780
2625		- if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
	2781	+ if (scp->sc_data_direction == DMA_FROM_DEVICE)
2626	2782	io_info.isRead = 1;
2627	2783
2628	2784	local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
..	..	@@ -2632,21 +2788,17 @@
2632	2788	raid = MR_LdRaidGet(ld, local_map_ptr);
2633	2789
2634	2790	if (!raid \|\| (!fusion->fast_path_io)) {
2635		- io_request->RaidContext.raid_context.reg_lock_flags = 0;
	2791	+ rctx->reg_lock_flags = 0;
2636	2792	fp_possible = false;
2637	2793	} else {
2638		- if (MR_BuildRaidContext(instance, &io_info,
2639		- &io_request->RaidContext.raid_context,
	2794	+ if (MR_BuildRaidContext(instance, &io_info, rctx,
2640	2795	local_map_ptr, &raidLUN))
2641	2796	fp_possible = (io_info.fpOkForIo > 0) ? true : false;
2642	2797	}
2643	2798
2644		- cmd->request_desc->SCSIIO.MSIxIndex =
2645		- instance->reply_map[raw_smp_processor_id()];
	2799	+ megasas_get_msix_index(instance, scp, cmd, io_info.data_arms);
2646	2800
2647		- praid_context = &io_request->RaidContext;
2648		-
2649		- if (instance->adapter_type == VENTURA_SERIES) {
	2801	+ if (instance->adapter_type >= VENTURA_SERIES) {
2650	2802	/* FP for Optimal raid level 1.
2651	2803	* All large RAID-1 writes (> 32 KiB, both WT and WB modes)
2652	2804	* are built by the driver as LD I/Os.
..	..	@@ -2662,8 +2814,9 @@
2662	2814	(instance->host->can_queue)) {
2663	2815	fp_possible = false;
2664	2816	atomic_dec(&instance->fw_outstanding);
2665		- } else if ((scsi_buff_len > MR_LARGE_IO_MIN_SIZE) \|\|
2666		- (atomic_dec_if_positive(&mrdev_priv->r1_ldio_hint) > 0)) {
	2817	+ } else if (fusion->pcie_bw_limitation &&
	2818	+ ((scsi_buff_len > MR_LARGE_IO_MIN_SIZE) \|\|
	2819	+ (atomic_dec_if_positive(&mrdev_priv->r1_ldio_hint) > 0))) {
2667	2820	fp_possible = false;
2668	2821	atomic_dec(&instance->fw_outstanding);
2669	2822	if (scsi_buff_len > MR_LARGE_IO_MIN_SIZE)
..	..	@@ -2682,17 +2835,17 @@
2682	2835	/* In ventura if stream detected for a read and it is
2683	2836	* read ahead capable make this IO as LDIO
2684	2837	*/
2685		- if (is_stream_detected(&io_request->RaidContext.raid_context_g35))
	2838	+ if (is_stream_detected(rctx_g35))
2686	2839	fp_possible = false;
2687	2840	}
2688	2841
2689	2842	/* If raid is NULL, set CPU affinity to default CPU0 */
2690	2843	if (raid)
2691		- megasas_set_raidflag_cpu_affinity(praid_context,
	2844	+ megasas_set_raidflag_cpu_affinity(fusion, &io_request->RaidContext,
2692	2845	raid, fp_possible, io_info.isRead,
2693	2846	scsi_buff_len);
2694	2847	else
2695		- praid_context->raid_context_g35.routing_flags \|=
	2848	+ rctx_g35->routing_flags \|=
2696	2849	(MR_RAID_CTX_CPUSEL_0 << MR_RAID_CTX_ROUTINGFLAGS_CPUSEL_SHIFT);
2697	2850	}
2698	2851
..	..	@@ -2704,25 +2857,16 @@
2704	2857	(MPI2_REQ_DESCRIPT_FLAGS_FP_IO
2705	2858	<< MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2706	2859	if (instance->adapter_type == INVADER_SERIES) {
2707		- if (io_request->RaidContext.raid_context.reg_lock_flags ==
2708		- REGION_TYPE_UNUSED)
2709		- cmd->request_desc->SCSIIO.RequestFlags =
2710		- (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK <<
2711		- MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2712		- io_request->RaidContext.raid_context.type
2713		- = MPI2_TYPE_CUDA;
2714		- io_request->RaidContext.raid_context.nseg = 0x1;
	2860	+ rctx->type = MPI2_TYPE_CUDA;
	2861	+ rctx->nseg = 0x1;
2715	2862	io_request->IoFlags \|= cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
2716		- io_request->RaidContext.raid_context.reg_lock_flags \|=
	2863	+ rctx->reg_lock_flags \|=
2717	2864	(MR_RL_FLAGS_GRANT_DESTINATION_CUDA \|
2718	2865	MR_RL_FLAGS_SEQ_NUM_ENABLE);
2719		- } else if (instance->adapter_type == VENTURA_SERIES) {
2720		- io_request->RaidContext.raid_context_g35.nseg_type \|=
2721		- (1 << RAID_CONTEXT_NSEG_SHIFT);
2722		- io_request->RaidContext.raid_context_g35.nseg_type \|=
2723		- (MPI2_TYPE_CUDA << RAID_CONTEXT_TYPE_SHIFT);
2724		- io_request->RaidContext.raid_context_g35.routing_flags \|=
2725		- (1 << MR_RAID_CTX_ROUTINGFLAGS_SQN_SHIFT);
	2866	+ } else if (instance->adapter_type >= VENTURA_SERIES) {
	2867	+ rctx_g35->nseg_type \|= (1 << RAID_CONTEXT_NSEG_SHIFT);
	2868	+ rctx_g35->nseg_type \|= (MPI2_TYPE_CUDA << RAID_CONTEXT_TYPE_SHIFT);
	2869	+ rctx_g35->routing_flags \|= (1 << MR_RAID_CTX_ROUTINGFLAGS_SQN_SHIFT);
2726	2870	io_request->IoFlags \|=
2727	2871	cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
2728	2872	}
..	..	@@ -2735,17 +2879,15 @@
2735	2879	&io_info, local_map_ptr);
2736	2880	scp->SCp.Status \|= MEGASAS_LOAD_BALANCE_FLAG;
2737	2881	cmd->pd_r1_lb = io_info.pd_after_lb;
2738		- if (instance->adapter_type == VENTURA_SERIES)
2739		- io_request->RaidContext.raid_context_g35.span_arm
2740		- = io_info.span_arm;
	2882	+ if (instance->adapter_type >= VENTURA_SERIES)
	2883	+ rctx_g35->span_arm = io_info.span_arm;
2741	2884	else
2742		- io_request->RaidContext.raid_context.span_arm
2743		- = io_info.span_arm;
	2885	+ rctx->span_arm = io_info.span_arm;
2744	2886
2745	2887	} else
2746	2888	scp->SCp.Status &= ~MEGASAS_LOAD_BALANCE_FLAG;
2747	2889
2748		- if (instance->adapter_type == VENTURA_SERIES)
	2890	+ if (instance->adapter_type >= VENTURA_SERIES)
2749	2891	cmd->r1_alt_dev_handle = io_info.r1_alt_dev_handle;
2750	2892	else
2751	2893	cmd->r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
..	..	@@ -2763,31 +2905,26 @@
2763	2905	/* populate the LUN field */
2764	2906	memcpy(io_request->LUN, raidLUN, 8);
2765	2907	} else {
2766		- io_request->RaidContext.raid_context.timeout_value =
	2908	+ rctx->timeout_value =
2767	2909	cpu_to_le16(local_map_ptr->raidMap.fpPdIoTimeoutSec);
2768	2910	cmd->request_desc->SCSIIO.RequestFlags =
2769	2911	(MEGASAS_REQ_DESCRIPT_FLAGS_LD_IO
2770	2912	<< MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2771	2913	if (instance->adapter_type == INVADER_SERIES) {
2772	2914	if (io_info.do_fp_rlbypass \|\|
2773		- (io_request->RaidContext.raid_context.reg_lock_flags
2774		- == REGION_TYPE_UNUSED))
	2915	+ (rctx->reg_lock_flags == REGION_TYPE_UNUSED))
2775	2916	cmd->request_desc->SCSIIO.RequestFlags =
2776	2917	(MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK <<
2777	2918	MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2778		- io_request->RaidContext.raid_context.type
2779		- = MPI2_TYPE_CUDA;
2780		- io_request->RaidContext.raid_context.reg_lock_flags \|=
	2919	+ rctx->type = MPI2_TYPE_CUDA;
	2920	+ rctx->reg_lock_flags \|=
2781	2921	(MR_RL_FLAGS_GRANT_DESTINATION_CPU0 \|
2782		- MR_RL_FLAGS_SEQ_NUM_ENABLE);
2783		- io_request->RaidContext.raid_context.nseg = 0x1;
2784		- } else if (instance->adapter_type == VENTURA_SERIES) {
2785		- io_request->RaidContext.raid_context_g35.routing_flags \|=
2786		- (1 << MR_RAID_CTX_ROUTINGFLAGS_SQN_SHIFT);
2787		- io_request->RaidContext.raid_context_g35.nseg_type \|=
2788		- (1 << RAID_CONTEXT_NSEG_SHIFT);
2789		- io_request->RaidContext.raid_context_g35.nseg_type \|=
2790		- (MPI2_TYPE_CUDA << RAID_CONTEXT_TYPE_SHIFT);
	2922	+ MR_RL_FLAGS_SEQ_NUM_ENABLE);
	2923	+ rctx->nseg = 0x1;
	2924	+ } else if (instance->adapter_type >= VENTURA_SERIES) {
	2925	+ rctx_g35->routing_flags \|= (1 << MR_RAID_CTX_ROUTINGFLAGS_SQN_SHIFT);
	2926	+ rctx_g35->nseg_type \|= (1 << RAID_CONTEXT_NSEG_SHIFT);
	2927	+ rctx_g35->nseg_type \|= (MPI2_TYPE_CUDA << RAID_CONTEXT_TYPE_SHIFT);
2791	2928	}
2792	2929	io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
2793	2930	io_request->DevHandle = cpu_to_le16(device_id);
..	..	@@ -2798,7 +2935,7 @@
2798	2935	/**
2799	2936	* megasas_build_ld_nonrw_fusion - prepares non rw ios for virtual disk
2800	2937	* @instance: Adapter soft state
2801		- * @scp: SCSI command
	2938	+ * @scmd: SCSI command
2802	2939	* @cmd: Command to be prepared
2803	2940	*
2804	2941	* Prepares the io_request frame for non-rw io cmds for vd.
..	..	@@ -2856,7 +2993,7 @@
2856	2993
2857	2994	/* set RAID context values */
2858	2995	pRAID_Context->config_seq_num = raid->seqNum;
2859		- if (instance->adapter_type != VENTURA_SERIES)
	2996	+ if (instance->adapter_type < VENTURA_SERIES)
2860	2997	pRAID_Context->reg_lock_flags = REGION_TYPE_SHARED_READ;
2861	2998	pRAID_Context->timeout_value =
2862	2999	cpu_to_le16(raid->fpIoTimeoutForLd);
..	..	@@ -2886,7 +3023,7 @@
2886	3023	/**
2887	3024	* megasas_build_syspd_fusion - prepares rw/non-rw ios for syspd
2888	3025	* @instance: Adapter soft state
2889		- * @scp: SCSI command
	3026	+ * @scmd: SCSI command
2890	3027	* @cmd: Command to be prepared
2891	3028	* @fp_possible: parameter to detect fast path or firmware path io.
2892	3029	*
..	..	@@ -2927,50 +3064,60 @@
2927	3064	<< MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;
2928	3065
2929	3066	/* If FW supports PD sequence number */
2930		- if (instance->use_seqnum_jbod_fp &&
2931		- instance->pd_list[pd_index].driveType == TYPE_DISK) {
2932		- /* TgtId must be incremented by 255 as jbod seq number is index
2933		- * below raid map
2934		- */
2935		- /* More than 256 PD/JBOD support for Ventura */
2936		- if (instance->support_morethan256jbod)
2937		- pRAID_Context->virtual_disk_tgt_id =
2938		- pd_sync->seq[pd_index].pd_target_id;
2939		- else
2940		- pRAID_Context->virtual_disk_tgt_id =
2941		- cpu_to_le16(device_id + (MAX_PHYSICAL_DEVICES - 1));
2942		- pRAID_Context->config_seq_num = pd_sync->seq[pd_index].seqNum;
2943		- io_request->DevHandle = pd_sync->seq[pd_index].devHandle;
2944		- if (instance->adapter_type == VENTURA_SERIES) {
2945		- io_request->RaidContext.raid_context_g35.routing_flags \|=
2946		- (1 << MR_RAID_CTX_ROUTINGFLAGS_SQN_SHIFT);
2947		- io_request->RaidContext.raid_context_g35.nseg_type \|=
2948		- (1 << RAID_CONTEXT_NSEG_SHIFT);
2949		- io_request->RaidContext.raid_context_g35.nseg_type \|=
2950		- (MPI2_TYPE_CUDA << RAID_CONTEXT_TYPE_SHIFT);
	3067	+ if (instance->support_seqnum_jbod_fp) {
	3068	+ if (instance->use_seqnum_jbod_fp &&
	3069	+ instance->pd_list[pd_index].driveType == TYPE_DISK) {
	3070	+
	3071	+ /* More than 256 PD/JBOD support for Ventura */
	3072	+ if (instance->support_morethan256jbod)
	3073	+ pRAID_Context->virtual_disk_tgt_id =
	3074	+ pd_sync->seq[pd_index].pd_target_id;
	3075	+ else
	3076	+ pRAID_Context->virtual_disk_tgt_id =
	3077	+ cpu_to_le16(device_id +
	3078	+ (MAX_PHYSICAL_DEVICES - 1));
	3079	+ pRAID_Context->config_seq_num =
	3080	+ pd_sync->seq[pd_index].seqNum;
	3081	+ io_request->DevHandle =
	3082	+ pd_sync->seq[pd_index].devHandle;
	3083	+ if (instance->adapter_type >= VENTURA_SERIES) {
	3084	+ io_request->RaidContext.raid_context_g35.routing_flags \|=
	3085	+ (1 << MR_RAID_CTX_ROUTINGFLAGS_SQN_SHIFT);
	3086	+ io_request->RaidContext.raid_context_g35.nseg_type \|=
	3087	+ (1 << RAID_CONTEXT_NSEG_SHIFT);
	3088	+ io_request->RaidContext.raid_context_g35.nseg_type \|=
	3089	+ (MPI2_TYPE_CUDA << RAID_CONTEXT_TYPE_SHIFT);
	3090	+ } else {
	3091	+ pRAID_Context->type = MPI2_TYPE_CUDA;
	3092	+ pRAID_Context->nseg = 0x1;
	3093	+ pRAID_Context->reg_lock_flags \|=
	3094	+ (MR_RL_FLAGS_SEQ_NUM_ENABLE \|
	3095	+ MR_RL_FLAGS_GRANT_DESTINATION_CUDA);
	3096	+ }
2951	3097	} else {
2952		- pRAID_Context->type = MPI2_TYPE_CUDA;
2953		- pRAID_Context->nseg = 0x1;
2954		- pRAID_Context->reg_lock_flags \|=
2955		- (MR_RL_FLAGS_SEQ_NUM_ENABLE\|MR_RL_FLAGS_GRANT_DESTINATION_CUDA);
	3098	+ pRAID_Context->virtual_disk_tgt_id =
	3099	+ cpu_to_le16(device_id +
	3100	+ (MAX_PHYSICAL_DEVICES - 1));
	3101	+ pRAID_Context->config_seq_num = 0;
	3102	+ io_request->DevHandle = cpu_to_le16(0xFFFF);
2956	3103	}
2957		- } else if (fusion->fast_path_io) {
2958		- pRAID_Context->virtual_disk_tgt_id = cpu_to_le16(device_id);
2959		- pRAID_Context->config_seq_num = 0;
2960		- local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
2961		- io_request->DevHandle =
2962		- local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
2963	3104	} else {
2964		- /* Want to send all IO via FW path */
2965	3105	pRAID_Context->virtual_disk_tgt_id = cpu_to_le16(device_id);
2966	3106	pRAID_Context->config_seq_num = 0;
2967		- io_request->DevHandle = cpu_to_le16(0xFFFF);
	3107	+
	3108	+ if (fusion->fast_path_io) {
	3109	+ local_map_ptr =
	3110	+ fusion->ld_drv_map[(instance->map_id & 1)];
	3111	+ io_request->DevHandle =
	3112	+ local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
	3113	+ } else {
	3114	+ io_request->DevHandle = cpu_to_le16(0xFFFF);
	3115	+ }
2968	3116	}
2969	3117
2970	3118	cmd->request_desc->SCSIIO.DevHandle = io_request->DevHandle;
2971	3119
2972		- cmd->request_desc->SCSIIO.MSIxIndex =
2973		- instance->reply_map[raw_smp_processor_id()];
	3120	+ megasas_get_msix_index(instance, scmd, cmd, 1);
2974	3121
2975	3122	if (!fp_possible) {
2976	3123	/* system pd firmware path */
..	..	@@ -3010,7 +3157,7 @@
3010	3157	* Invokes helper functions to prepare request frames
3011	3158	* and sets flags appropriate for IO/Non-IO cmd
3012	3159	*/
3013		-int
	3160	+static int
3014	3161	megasas_build_io_fusion(struct megasas_instance *instance,
3015	3162	struct scsi_cmnd *scp,
3016	3163	struct megasas_cmd_fusion *cmd)
..	..	@@ -3074,7 +3221,7 @@
3074	3221	return 1;
3075	3222	}
3076	3223
3077		- if (instance->adapter_type == VENTURA_SERIES) {
	3224	+ if (instance->adapter_type >= VENTURA_SERIES) {
3078	3225	set_num_sge(&io_request->RaidContext.raid_context_g35, sge_count);
3079	3226	cpu_to_le16s(&io_request->RaidContext.raid_context_g35.routing_flags);
3080	3227	cpu_to_le16s(&io_request->RaidContext.raid_context_g35.nseg_type);
..	..	@@ -3089,9 +3236,9 @@
3089	3236
3090	3237	io_request->SGLFlags = cpu_to_le16(MPI2_SGE_FLAGS_64_BIT_ADDRESSING);
3091	3238
3092		- if (scp->sc_data_direction == PCI_DMA_TODEVICE)
	3239	+ if (scp->sc_data_direction == DMA_TO_DEVICE)
3093	3240	io_request->Control \|= cpu_to_le32(MPI2_SCSIIO_CONTROL_WRITE);
3094		- else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
	3241	+ else if (scp->sc_data_direction == DMA_FROM_DEVICE)
3095	3242	io_request->Control \|= cpu_to_le32(MPI2_SCSIIO_CONTROL_READ);
3096	3243
3097	3244	io_request->SGLOffset0 =
..	..	@@ -3124,9 +3271,9 @@
3124	3271	/* megasas_prepate_secondRaid1_IO
3125	3272	* It prepares the raid 1 second IO
3126	3273	*/
3127		-void megasas_prepare_secondRaid1_IO(struct megasas_instance *instance,
3128		- struct megasas_cmd_fusion *cmd,
3129		- struct megasas_cmd_fusion *r1_cmd)
	3274	+static void megasas_prepare_secondRaid1_IO(struct megasas_instance *instance,
	3275	+ struct megasas_cmd_fusion *cmd,
	3276	+ struct megasas_cmd_fusion *r1_cmd)
3130	3277	{
3131	3278	union MEGASAS_REQUEST_DESCRIPTOR_UNION req_desc, req_desc2 = NULL;
3132	3279	struct fusion_context *fusion;
..	..	@@ -3150,9 +3297,9 @@
3150	3297	r1_cmd->request_desc->SCSIIO.DevHandle = cmd->r1_alt_dev_handle;
3151	3298	r1_cmd->io_request->DevHandle = cmd->r1_alt_dev_handle;
3152	3299	r1_cmd->r1_alt_dev_handle = cmd->io_request->DevHandle;
3153		- cmd->io_request->RaidContext.raid_context_g35.smid.peer_smid =
	3300	+ cmd->io_request->RaidContext.raid_context_g35.flow_specific.peer_smid =
3154	3301	cpu_to_le16(r1_cmd->index);
3155		- r1_cmd->io_request->RaidContext.raid_context_g35.smid.peer_smid =
	3302	+ r1_cmd->io_request->RaidContext.raid_context_g35.flow_specific.peer_smid =
3156	3303	cpu_to_le16(cmd->index);
3157	3304	/MSIxIndex of both commands request descriptors should be same/
3158	3305	r1_cmd->request_desc->SCSIIO.MSIxIndex =
..	..	@@ -3175,9 +3322,6 @@
3175	3322	struct megasas_cmd_fusion cmd, r1_cmd = NULL;
3176	3323	union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
3177	3324	u32 index;
3178		- struct fusion_context *fusion;
3179		-
3180		- fusion = instance->ctrl_context;
3181	3325
3182	3326	if ((megasas_cmd_type(scmd) == READ_WRITE_LDIO) &&
3183	3327	instance->ldio_threshold &&
..	..	@@ -3256,7 +3400,7 @@
3256	3400	* megasas_complete_r1_command -
3257	3401	* completes R1 FP write commands which has valid peer smid
3258	3402	* @instance: Adapter soft state
3259		- * @cmd_fusion: MPT command frame
	3403	+ * @cmd: MPT command frame
3260	3404	*
3261	3405	*/
3262	3406	static inline void
..	..	@@ -3273,7 +3417,7 @@
3273	3417
3274	3418	rctx_g35 = &cmd->io_request->RaidContext.raid_context_g35;
3275	3419	fusion = instance->ctrl_context;
3276		- peer_smid = le16_to_cpu(rctx_g35->smid.peer_smid);
	3420	+ peer_smid = le16_to_cpu(rctx_g35->flow_specific.peer_smid);
3277	3421
3278	3422	r1_cmd = fusion->cmd_list[peer_smid - 1];
3279	3423	scmd_local = cmd->scmd;
..	..	@@ -3310,10 +3454,14 @@
3310	3454	/**
3311	3455	* complete_cmd_fusion - Completes command
3312	3456	* @instance: Adapter soft state
	3457	+ * @MSIxIndex: MSI number
	3458	+ * @irq_context: IRQ context
	3459	+ *
3313	3460	* Completes all commands that is in reply descriptor queue
3314	3461	*/
3315		-int
3316		-complete_cmd_fusion(struct megasas_instance *instance, u32 MSIxIndex)
	3462	+static int
	3463	+complete_cmd_fusion(struct megasas_instance *instance, u32 MSIxIndex,
	3464	+ struct megasas_irq_context *irq_context)
3317	3465	{
3318	3466	union MPI2_REPLY_DESCRIPTORS_UNION *desc;
3319	3467	struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *reply_desc;
..	..	@@ -3386,7 +3534,7 @@
3386	3534	atomic_dec(&lbinfo->scsi_pending_cmds[cmd_fusion->pd_r1_lb]);
3387	3535	cmd_fusion->scmd->SCp.Status &= ~MEGASAS_LOAD_BALANCE_FLAG;
3388	3536	}
3389		- //Fall thru and complete IO
	3537	+ fallthrough; /* and complete IO */
3390	3538	case MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST: /* LD-IO Path */
3391	3539	atomic_dec(&instance->fw_outstanding);
3392	3540	if (cmd_fusion->r1_alt_dev_handle == MR_DEVHANDLE_INVALID) {
..	..	@@ -3446,7 +3594,7 @@
3446	3594	* number of reply counts and still there are more replies in reply queue
3447	3595	* pending to be completed
3448	3596	*/
3449		- if (threshold_reply_count >= THRESHOLD_REPLY_COUNT) {
	3597	+ if (threshold_reply_count >= instance->threshold_reply_count) {
3450	3598	if (instance->msix_combined)
3451	3599	writel(((MSIxIndex & 0x7) << 24) \|
3452	3600	fusion->last_reply_idx[MSIxIndex],
..	..	@@ -3456,127 +3604,173 @@
3456	3604	fusion->last_reply_idx[MSIxIndex],
3457	3605	instance->reply_post_host_index_addr[0]);
3458	3606	threshold_reply_count = 0;
	3607	+ if (irq_context) {
	3608	+ if (!irq_context->irq_poll_scheduled) {
	3609	+ irq_context->irq_poll_scheduled = true;
	3610	+ irq_context->irq_line_enable = true;
	3611	+ irq_poll_sched(&irq_context->irqpoll);
	3612	+ }
	3613	+ return num_completed;
	3614	+ }
3459	3615	}
3460	3616	}
3461	3617
3462		- if (!num_completed)
3463		- return IRQ_NONE;
	3618	+ if (num_completed) {
	3619	+ wmb();
	3620	+ if (instance->msix_combined)
	3621	+ writel(((MSIxIndex & 0x7) << 24) \|
	3622	+ fusion->last_reply_idx[MSIxIndex],
	3623	+ instance->reply_post_host_index_addr[MSIxIndex/8]);
	3624	+ else
	3625	+ writel((MSIxIndex << 24) \|
	3626	+ fusion->last_reply_idx[MSIxIndex],
	3627	+ instance->reply_post_host_index_addr[0]);
	3628	+ megasas_check_and_restore_queue_depth(instance);
	3629	+ }
	3630	+ return num_completed;
	3631	+}
3464	3632
3465		- wmb();
3466		- if (instance->msix_combined)
3467		- writel(((MSIxIndex & 0x7) << 24) \|
3468		- fusion->last_reply_idx[MSIxIndex],
3469		- instance->reply_post_host_index_addr[MSIxIndex/8]);
3470		- else
3471		- writel((MSIxIndex << 24) \|
3472		- fusion->last_reply_idx[MSIxIndex],
3473		- instance->reply_post_host_index_addr[0]);
3474		- megasas_check_and_restore_queue_depth(instance);
3475		- return IRQ_HANDLED;
	3633	+/**
	3634	+ * megasas_enable_irq_poll() - enable irqpoll
	3635	+ * @instance: Adapter soft state
	3636	+ */
	3637	+static void megasas_enable_irq_poll(struct megasas_instance *instance)
	3638	+{
	3639	+ u32 count, i;
	3640	+ struct megasas_irq_context *irq_ctx;
	3641	+
	3642	+ count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
	3643	+
	3644	+ for (i = 0; i < count; i++) {
	3645	+ irq_ctx = &instance->irq_context[i];
	3646	+ irq_poll_enable(&irq_ctx->irqpoll);
	3647	+ }
3476	3648	}
3477	3649
3478	3650	/**
3479	3651	* megasas_sync_irqs - Synchronizes all IRQs owned by adapter
3480		- * @instance: Adapter soft state
	3652	+ * @instance_addr: Adapter soft state address
3481	3653	*/
3482		-void megasas_sync_irqs(unsigned long instance_addr)
	3654	+static void megasas_sync_irqs(unsigned long instance_addr)
3483	3655	{
3484	3656	u32 count, i;
3485	3657	struct megasas_instance *instance =
3486	3658	(struct megasas_instance *)instance_addr;
	3659	+ struct megasas_irq_context *irq_ctx;
3487	3660
3488	3661	count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3489	3662
3490		- for (i = 0; i < count; i++)
	3663	+ for (i = 0; i < count; i++) {
3491	3664	synchronize_irq(pci_irq_vector(instance->pdev, i));
	3665	+ irq_ctx = &instance->irq_context[i];
	3666	+ irq_poll_disable(&irq_ctx->irqpoll);
	3667	+ if (irq_ctx->irq_poll_scheduled) {
	3668	+ irq_ctx->irq_poll_scheduled = false;
	3669	+ enable_irq(irq_ctx->os_irq);
	3670	+ complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx);
	3671	+ }
	3672	+ }
	3673	+}
	3674	+
	3675	+/**
	3676	+ * megasas_irqpoll() - process a queue for completed reply descriptors
	3677	+ * @irqpoll: IRQ poll structure associated with queue to poll.
	3678	+ * @budget: Threshold of reply descriptors to process per poll.
	3679	+ *
	3680	+ * Return: The number of entries processed.
	3681	+ */
	3682	+
	3683	+int megasas_irqpoll(struct irq_poll *irqpoll, int budget)
	3684	+{
	3685	+ struct megasas_irq_context *irq_ctx;
	3686	+ struct megasas_instance *instance;
	3687	+ int num_entries;
	3688	+
	3689	+ irq_ctx = container_of(irqpoll, struct megasas_irq_context, irqpoll);
	3690	+ instance = irq_ctx->instance;
	3691	+
	3692	+ if (irq_ctx->irq_line_enable) {
	3693	+ disable_irq_nosync(irq_ctx->os_irq);
	3694	+ irq_ctx->irq_line_enable = false;
	3695	+ }
	3696	+
	3697	+ num_entries = complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx);
	3698	+ if (num_entries < budget) {
	3699	+ irq_poll_complete(irqpoll);
	3700	+ irq_ctx->irq_poll_scheduled = false;
	3701	+ enable_irq(irq_ctx->os_irq);
	3702	+ complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx);
	3703	+ }
	3704	+
	3705	+ return num_entries;
3492	3706	}
3493	3707
3494	3708	/**
3495	3709	* megasas_complete_cmd_dpc_fusion - Completes command
3496		- * @instance: Adapter soft state
	3710	+ * @instance_addr: Adapter soft state address
3497	3711	*
3498	3712	* Tasklet to complete cmds
3499	3713	*/
3500		-void
	3714	+static void
3501	3715	megasas_complete_cmd_dpc_fusion(unsigned long instance_addr)
3502	3716	{
3503	3717	struct megasas_instance *instance =
3504	3718	(struct megasas_instance *)instance_addr;
3505		- unsigned long flags;
	3719	+ struct megasas_irq_context *irq_ctx = NULL;
3506	3720	u32 count, MSIxIndex;
3507	3721
3508	3722	count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3509	3723
3510	3724	/* If we have already declared adapter dead, donot complete cmds */
3511		- spin_lock_irqsave(&instance->hba_lock, flags);
3512		- if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
3513		- spin_unlock_irqrestore(&instance->hba_lock, flags);
	3725	+ if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
3514	3726	return;
3515		- }
3516		- spin_unlock_irqrestore(&instance->hba_lock, flags);
3517	3727
3518		- for (MSIxIndex = 0 ; MSIxIndex < count; MSIxIndex++)
3519		- complete_cmd_fusion(instance, MSIxIndex);
	3728	+ for (MSIxIndex = 0 ; MSIxIndex < count; MSIxIndex++) {
	3729	+ irq_ctx = &instance->irq_context[MSIxIndex];
	3730	+ complete_cmd_fusion(instance, MSIxIndex, irq_ctx);
	3731	+ }
3520	3732	}
3521	3733
3522	3734	/**
3523	3735	* megasas_isr_fusion - isr entry point
	3736	+ * @irq: IRQ number
	3737	+ * @devp: IRQ context
3524	3738	*/
3525		-irqreturn_t megasas_isr_fusion(int irq, void *devp)
	3739	+static irqreturn_t megasas_isr_fusion(int irq, void *devp)
3526	3740	{
3527	3741	struct megasas_irq_context *irq_context = devp;
3528	3742	struct megasas_instance *instance = irq_context->instance;
3529		- u32 mfiStatus, fw_state, dma_state;
	3743	+ u32 mfiStatus;
3530	3744
3531	3745	if (instance->mask_interrupts)
3532	3746	return IRQ_NONE;
3533	3747
	3748	+ if (irq_context->irq_poll_scheduled)
	3749	+ return IRQ_HANDLED;
	3750	+
3534	3751	if (!instance->msix_vectors) {
3535		- mfiStatus = instance->instancet->clear_intr(instance->reg_set);
	3752	+ mfiStatus = instance->instancet->clear_intr(instance);
3536	3753	if (!mfiStatus)
3537	3754	return IRQ_NONE;
3538	3755	}
3539	3756
3540	3757	/* If we are resetting, bail */
3541	3758	if (test_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags)) {
3542		- instance->instancet->clear_intr(instance->reg_set);
	3759	+ instance->instancet->clear_intr(instance);
3543	3760	return IRQ_HANDLED;
3544	3761	}
3545	3762
3546		- if (!complete_cmd_fusion(instance, irq_context->MSIxIndex)) {
3547		- instance->instancet->clear_intr(instance->reg_set);
3548		- /* If we didn't complete any commands, check for FW fault */
3549		- fw_state = instance->instancet->read_fw_status_reg(
3550		- instance->reg_set) & MFI_STATE_MASK;
3551		- dma_state = instance->instancet->read_fw_status_reg
3552		- (instance->reg_set) & MFI_STATE_DMADONE;
3553		- if (instance->crash_dump_drv_support &&
3554		- instance->crash_dump_app_support) {
3555		- /* Start collecting crash, if DMA bit is done */
3556		- if ((fw_state == MFI_STATE_FAULT) && dma_state)
3557		- schedule_work(&instance->crash_init);
3558		- else if (fw_state == MFI_STATE_FAULT) {
3559		- if (instance->unload == 0)
3560		- schedule_work(&instance->work_init);
3561		- }
3562		- } else if (fw_state == MFI_STATE_FAULT) {
3563		- dev_warn(&instance->pdev->dev, "Iop2SysDoorbellInt"
3564		- "for scsi%d\n", instance->host->host_no);
3565		- if (instance->unload == 0)
3566		- schedule_work(&instance->work_init);
3567		- }
3568		- }
3569		-
3570		- return IRQ_HANDLED;
	3763	+ return complete_cmd_fusion(instance, irq_context->MSIxIndex, irq_context)
	3764	+ ? IRQ_HANDLED : IRQ_NONE;
3571	3765	}
3572	3766
3573	3767	/**
3574	3768	* build_mpt_mfi_pass_thru - builds a cmd fo MFI Pass thru
3575	3769	* @instance: Adapter soft state
3576		- * mfi_cmd: megasas_cmd pointer
	3770	+ * @mfi_cmd: megasas_cmd pointer
3577	3771	*
3578	3772	*/
3579		-void
	3773	+static void
3580	3774	build_mpt_mfi_pass_thru(struct megasas_instance *instance,
3581	3775	struct megasas_cmd *mfi_cmd)
3582	3776	{
..	..	@@ -3634,7 +3828,7 @@
3634	3828	* @cmd: mfi cmd to build
3635	3829	*
3636	3830	*/
3637		-union MEGASAS_REQUEST_DESCRIPTOR_UNION *
	3831	+static union MEGASAS_REQUEST_DESCRIPTOR_UNION *
3638	3832	build_mpt_cmd(struct megasas_instance instance, struct megasas_cmd cmd)
3639	3833	{
3640	3834	union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc = NULL;
..	..	@@ -3660,7 +3854,7 @@
3660	3854	* @cmd: mfi cmd pointer
3661	3855	*
3662	3856	*/
3663		-void
	3857	+static void
3664	3858	megasas_issue_dcmd_fusion(struct megasas_instance *instance,
3665	3859	struct megasas_cmd *cmd)
3666	3860	{
..	..	@@ -3690,18 +3884,18 @@
3690	3884
3691	3885	/**
3692	3886	* megasas_read_fw_status_reg_fusion - returns the current FW status value
3693		- * @regs: MFI register set
	3887	+ * @instance: Adapter soft state
3694	3888	*/
3695	3889	static u32
3696		-megasas_read_fw_status_reg_fusion(struct megasas_register_set __iomem *regs)
	3890	+megasas_read_fw_status_reg_fusion(struct megasas_instance *instance)
3697	3891	{
3698		- return readl(&(regs)->outbound_scratch_pad);
	3892	+ return megasas_readl(instance, &instance->reg_set->outbound_scratch_pad_0);
3699	3893	}
3700	3894
3701	3895	/**
3702	3896	* megasas_alloc_host_crash_buffer - Host buffers for Crash dump collection from Firmware
3703	3897	* @instance: Controller's soft instance
3704		- * return: Number of allocated host crash buffers
	3898	+ * @return: Number of allocated host crash buffers
3705	3899	*/
3706	3900	static void
3707	3901	megasas_alloc_host_crash_buffer(struct megasas_instance *instance)
..	..	@@ -3739,6 +3933,7 @@
3739	3933
3740	3934	/**
3741	3935	* megasas_adp_reset_fusion - For controller reset
	3936	+ * @instance: Controller's soft instance
3742	3937	* @regs: MFI register set
3743	3938	*/
3744	3939	static int
..	..	@@ -3757,11 +3952,12 @@
3757	3952	writel(MPI2_WRSEQ_6TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3758	3953
3759	3954	/* Check that the diag write enable (DRWE) bit is on */
3760		- host_diag = readl(&instance->reg_set->fusion_host_diag);
	3955	+ host_diag = megasas_readl(instance, &instance->reg_set->fusion_host_diag);
3761	3956	retry = 0;
3762	3957	while (!(host_diag & HOST_DIAG_WRITE_ENABLE)) {
3763	3958	msleep(100);
3764		- host_diag = readl(&instance->reg_set->fusion_host_diag);
	3959	+ host_diag = megasas_readl(instance,
	3960	+ &instance->reg_set->fusion_host_diag);
3765	3961	if (retry++ == 100) {
3766	3962	dev_warn(&instance->pdev->dev,
3767	3963	"Host diag unlock failed from %s %d\n",
..	..	@@ -3778,11 +3974,12 @@
3778	3974	msleep(3000);
3779	3975
3780	3976	/* Make sure reset adapter bit is cleared */
3781		- host_diag = readl(&instance->reg_set->fusion_host_diag);
	3977	+ host_diag = megasas_readl(instance, &instance->reg_set->fusion_host_diag);
3782	3978	retry = 0;
3783	3979	while (host_diag & HOST_DIAG_RESET_ADAPTER) {
3784	3980	msleep(100);
3785		- host_diag = readl(&instance->reg_set->fusion_host_diag);
	3981	+ host_diag = megasas_readl(instance,
	3982	+ &instance->reg_set->fusion_host_diag);
3786	3983	if (retry++ == 1000) {
3787	3984	dev_warn(&instance->pdev->dev,
3788	3985	"Diag reset adapter never cleared %s %d\n",
..	..	@@ -3793,14 +3990,14 @@
3793	3990	if (host_diag & HOST_DIAG_RESET_ADAPTER)
3794	3991	return -1;
3795	3992
3796		- abs_state = instance->instancet->read_fw_status_reg(instance->reg_set)
	3993	+ abs_state = instance->instancet->read_fw_status_reg(instance)
3797	3994	& MFI_STATE_MASK;
3798	3995	retry = 0;
3799	3996
3800	3997	while ((abs_state <= MFI_STATE_FW_INIT) && (retry++ < 1000)) {
3801	3998	msleep(100);
3802	3999	abs_state = instance->instancet->
3803		- read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK;
	4000	+ read_fw_status_reg(instance) & MFI_STATE_MASK;
3804	4001	}
3805	4002	if (abs_state <= MFI_STATE_FW_INIT) {
3806	4003	dev_warn(&instance->pdev->dev,
..	..	@@ -3814,6 +4011,7 @@
3814	4011
3815	4012	/**
3816	4013	* megasas_check_reset_fusion - For controller reset check
	4014	+ * @instance: Controller's soft instance
3817	4015	* @regs: MFI register set
3818	4016	*/
3819	4017	static int
..	..	@@ -3823,21 +4021,68 @@
3823	4021	return 0;
3824	4022	}
3825	4023
	4024	+/**
	4025	+ * megasas_trigger_snap_dump - Trigger snap dump in FW
	4026	+ * @instance: Soft instance of adapter
	4027	+ */
	4028	+static inline void megasas_trigger_snap_dump(struct megasas_instance *instance)
	4029	+{
	4030	+ int j;
	4031	+ u32 fw_state, abs_state;
	4032	+
	4033	+ if (!instance->disableOnlineCtrlReset) {
	4034	+ dev_info(&instance->pdev->dev, "Trigger snap dump\n");
	4035	+ writel(MFI_ADP_TRIGGER_SNAP_DUMP,
	4036	+ &instance->reg_set->doorbell);
	4037	+ readl(&instance->reg_set->doorbell);
	4038	+ }
	4039	+
	4040	+ for (j = 0; j < instance->snapdump_wait_time; j++) {
	4041	+ abs_state = instance->instancet->read_fw_status_reg(instance);
	4042	+ fw_state = abs_state & MFI_STATE_MASK;
	4043	+ if (fw_state == MFI_STATE_FAULT) {
	4044	+ dev_printk(KERN_ERR, &instance->pdev->dev,
	4045	+ "FW in FAULT state Fault code:0x%x subcode:0x%x func:%s\n",
	4046	+ abs_state & MFI_STATE_FAULT_CODE,
	4047	+ abs_state & MFI_STATE_FAULT_SUBCODE, __func__);
	4048	+ return;
	4049	+ }
	4050	+ msleep(1000);
	4051	+ }
	4052	+}
	4053	+
3826	4054	/* This function waits for outstanding commands on fusion to complete */
3827		-int megasas_wait_for_outstanding_fusion(struct megasas_instance *instance,
3828		- int reason, int *convert)
	4055	+static int
	4056	+megasas_wait_for_outstanding_fusion(struct megasas_instance *instance,
	4057	+ int reason, int *convert)
3829	4058	{
3830	4059	int i, outstanding, retval = 0, hb_seconds_missed = 0;
3831		- u32 fw_state;
	4060	+ u32 fw_state, abs_state;
	4061	+ u32 waittime_for_io_completion;
3832	4062
3833		- for (i = 0; i < resetwaittime; i++) {
	4063	+ waittime_for_io_completion =
	4064	+ min_t(u32, resetwaittime,
	4065	+ (resetwaittime - instance->snapdump_wait_time));
	4066	+
	4067	+ if (reason == MFI_IO_TIMEOUT_OCR) {
	4068	+ dev_info(&instance->pdev->dev,
	4069	+ "MFI command is timed out\n");
	4070	+ megasas_complete_cmd_dpc_fusion((unsigned long)instance);
	4071	+ if (instance->snapdump_wait_time)
	4072	+ megasas_trigger_snap_dump(instance);
	4073	+ retval = 1;
	4074	+ goto out;
	4075	+ }
	4076	+
	4077	+ for (i = 0; i < waittime_for_io_completion; i++) {
3834	4078	/* Check if firmware is in fault state */
3835		- fw_state = instance->instancet->read_fw_status_reg(
3836		- instance->reg_set) & MFI_STATE_MASK;
	4079	+ abs_state = instance->instancet->read_fw_status_reg(instance);
	4080	+ fw_state = abs_state & MFI_STATE_MASK;
3837	4081	if (fw_state == MFI_STATE_FAULT) {
3838		- dev_warn(&instance->pdev->dev, "Found FW in FAULT state,"
3839		- " will reset adapter scsi%d.\n",
3840		- instance->host->host_no);
	4082	+ dev_printk(KERN_ERR, &instance->pdev->dev,
	4083	+ "FW in FAULT state Fault code:0x%x subcode:0x%x func:%s\n",
	4084	+ abs_state & MFI_STATE_FAULT_CODE,
	4085	+ abs_state & MFI_STATE_FAULT_SUBCODE, __func__);
3841	4086	megasas_complete_cmd_dpc_fusion((unsigned long)instance);
3842	4087	if (instance->requestorId && reason) {
3843	4088	dev_warn(&instance->pdev->dev, "SR-IOV Found FW in FAULT"
..	..	@@ -3851,13 +4096,6 @@
3851	4096	goto out;
3852	4097	}
3853	4098
3854		- if (reason == MFI_IO_TIMEOUT_OCR) {
3855		- dev_info(&instance->pdev->dev,
3856		- "MFI IO is timed out, initiating OCR\n");
3857		- megasas_complete_cmd_dpc_fusion((unsigned long)instance);
3858		- retval = 1;
3859		- goto out;
3860		- }
3861	4099
3862	4100	/* If SR-IOV VF mode & heartbeat timeout, don't wait */
3863	4101	if (instance->requestorId && !reason) {
..	..	@@ -3902,6 +4140,12 @@
3902	4140	msleep(1000);
3903	4141	}
3904	4142
	4143	+ if (instance->snapdump_wait_time) {
	4144	+ megasas_trigger_snap_dump(instance);
	4145	+ retval = 1;
	4146	+ goto out;
	4147	+ }
	4148	+
3905	4149	if (atomic_read(&instance->fw_outstanding)) {
3906	4150	dev_err(&instance->pdev->dev, "pending commands remain after waiting, "
3907	4151	"will reset adapter scsi%d.\n",
..	..	@@ -3909,6 +4153,7 @@
3909	4153	*convert = 1;
3910	4154	retval = 1;
3911	4155	}
	4156	+
3912	4157	out:
3913	4158	return retval;
3914	4159	}
..	..	@@ -3933,7 +4178,8 @@
3933	4178	* megasas_refire_mgmt_cmd : Re-fire management commands
3934	4179	* @instance: Controller's soft instance
3935	4180	*/
3936		-void megasas_refire_mgmt_cmd(struct megasas_instance *instance)
	4181	+static void megasas_refire_mgmt_cmd(struct megasas_instance *instance,
	4182	+ bool return_ioctl)
3937	4183	{
3938	4184	int j;
3939	4185	struct megasas_cmd_fusion *cmd_fusion;
..	..	@@ -3942,7 +4188,7 @@
3942	4188	union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
3943	4189	struct MPI2_RAID_SCSI_IO_REQUEST *scsi_io_req;
3944	4190	u16 smid;
3945		- bool refire_cmd = 0;
	4191	+ bool refire_cmd = false;
3946	4192	u8 result;
3947	4193	u32 opcode = 0;
3948	4194
..	..	@@ -3987,8 +4233,25 @@
3987	4233	}
3988	4234
3989	4235	break;
	4236	+ case MFI_CMD_TOOLBOX:
	4237	+ if (!instance->support_pci_lane_margining) {
	4238	+ cmd_mfi->frame->hdr.cmd_status = MFI_STAT_INVALID_CMD;
	4239	+ result = COMPLETE_CMD;
	4240	+ }
	4241	+
	4242	+ break;
3990	4243	default:
3991	4244	break;
	4245	+ }
	4246	+
	4247	+ if (return_ioctl && cmd_mfi->sync_cmd &&
	4248	+ cmd_mfi->frame->hdr.cmd != MFI_CMD_ABORT) {
	4249	+ dev_err(&instance->pdev->dev,
	4250	+ "return -EBUSY from %s %d cmd 0x%x opcode 0x%x\n",
	4251	+ __func__, __LINE__, cmd_mfi->frame->hdr.cmd,
	4252	+ le32_to_cpu(cmd_mfi->frame->dcmd.opcode));
	4253	+ cmd_mfi->cmd_status_drv = DCMD_BUSY;
	4254	+ result = COMPLETE_CMD;
3992	4255	}
3993	4256
3994	4257	scsi_io_req = (struct MPI2_RAID_SCSI_IO_REQUEST *)
..	..	@@ -4006,6 +4269,37 @@
4006	4269	case COMPLETE_CMD:
4007	4270	megasas_complete_cmd(instance, cmd_mfi, DID_OK);
4008	4271	break;
	4272	+ }
	4273	+ }
	4274	+}
	4275	+
	4276	+/*
	4277	+ * megasas_return_polled_cmds: Return polled mode commands back to the pool
	4278	+ * before initiating an OCR.
	4279	+ * @instance: Controller's soft instance
	4280	+ */
	4281	+static void
	4282	+megasas_return_polled_cmds(struct megasas_instance *instance)
	4283	+{
	4284	+ int i;
	4285	+ struct megasas_cmd_fusion *cmd_fusion;
	4286	+ struct fusion_context *fusion;
	4287	+ struct megasas_cmd *cmd_mfi;
	4288	+
	4289	+ fusion = instance->ctrl_context;
	4290	+
	4291	+ for (i = instance->max_scsi_cmds; i < instance->max_fw_cmds; i++) {
	4292	+ cmd_fusion = fusion->cmd_list[i];
	4293	+ cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
	4294	+
	4295	+ if (cmd_mfi->flags & DRV_DCMD_POLLED_MODE) {
	4296	+ if (megasas_dbg_lvl & OCR_DEBUG)
	4297	+ dev_info(&instance->pdev->dev,
	4298	+ "%s %d return cmd 0x%x opcode 0x%x\n",
	4299	+ __func__, __LINE__, cmd_mfi->frame->hdr.cmd,
	4300	+ le32_to_cpu(cmd_mfi->frame->dcmd.opcode));
	4301	+ cmd_mfi->flags &= ~DRV_DCMD_POLLED_MODE;
	4302	+ megasas_return_cmd(instance, cmd_mfi);
4009	4303	}
4010	4304	}
4011	4305	}
..	..	@@ -4047,8 +4341,8 @@
4047	4341
4048	4342	/**
4049	4343	* megasas_tm_response_code - translation of device response code
4050		- * @ioc: per adapter object
4051		- * @mpi_reply: MPI reply returned by firmware
	4344	+ * @instance: Controller's soft instance
	4345	+ * @mpi_reply: MPI reply returned by firmware
4052	4346	*
4053	4347	* Return nothing.
4054	4348	*/
..	..	@@ -4103,9 +4397,9 @@
4103	4397	* @device_handle: device handle
4104	4398	* @channel: the channel assigned by the OS
4105	4399	* @id: the id assigned by the OS
4106		- * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in megaraid_sas_fusion.c)
4107	4400	* @smid_task: smid assigned to the task
4108		- * @m_type: TM_MUTEX_ON or TM_MUTEX_OFF
	4401	+ * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in megaraid_sas_fusion.c)
	4402	+ * @mr_device_priv_data: private data
4109	4403	* Context: user
4110	4404	*
4111	4405	* MegaRaid use MPT interface for Task Magement request.
..	..	@@ -4214,6 +4508,7 @@
4214	4508	instance->instancet->disable_intr(instance);
4215	4509	megasas_sync_irqs((unsigned long)instance);
4216	4510	instance->instancet->enable_intr(instance);
	4511	+ megasas_enable_irq_poll(instance);
4217	4512	if (scsi_lookup->scmd == NULL)
4218	4513	break;
4219	4514	}
..	..	@@ -4227,6 +4522,7 @@
4227	4522	megasas_sync_irqs((unsigned long)instance);
4228	4523	rc = megasas_track_scsiio(instance, id, channel);
4229	4524	instance->instancet->enable_intr(instance);
	4525	+ megasas_enable_irq_poll(instance);
4230	4526
4231	4527	break;
4232	4528	case MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET:
..	..	@@ -4319,17 +4615,11 @@
4319	4615	{
4320	4616	struct megasas_instance *instance;
4321	4617	u16 smid, devhandle;
4322		- struct fusion_context *fusion;
4323	4618	int ret;
4324	4619	struct MR_PRIV_DEVICE *mr_device_priv_data;
4325	4620	mr_device_priv_data = scmd->device->hostdata;
4326	4621
4327		-
4328	4622	instance = (struct megasas_instance *)scmd->device->host->hostdata;
4329		- fusion = instance->ctrl_context;
4330		-
4331		- scmd_printk(KERN_INFO, scmd, "task abort called for scmd(%p)\n", scmd);
4332		- scsi_print_command(scmd);
4333	4623
4334	4624	if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
4335	4625	dev_err(&instance->pdev->dev, "Controller is not OPERATIONAL,"
..	..	@@ -4346,7 +4636,6 @@
4346	4636	goto out;
4347	4637	}
4348	4638
4349		-
4350	4639	if (!mr_device_priv_data->is_tm_capable) {
4351	4640	ret = FAILED;
4352	4641	goto out;
..	..	@@ -4359,7 +4648,7 @@
4359	4648	if (!smid) {
4360	4649	ret = SUCCESS;
4361	4650	scmd_printk(KERN_NOTICE, scmd, "Command for which abort is"
4362		- " issued is not found in oustanding commands\n");
	4651	+ " issued is not found in outstanding commands\n");
4363	4652	mutex_unlock(&instance->reset_mutex);
4364	4653	goto out;
4365	4654	}
..	..	@@ -4374,20 +4663,23 @@
4374	4663	goto out;
4375	4664	}
4376	4665	sdev_printk(KERN_INFO, scmd->device,
4377		- "attempting task abort! scmd(%p) tm_dev_handle 0x%x\n",
	4666	+ "attempting task abort! scmd(0x%p) tm_dev_handle 0x%x\n",
4378	4667	scmd, devhandle);
4379	4668
4380		- mr_device_priv_data->tm_busy = 1;
	4669	+ mr_device_priv_data->tm_busy = true;
4381	4670	ret = megasas_issue_tm(instance, devhandle,
4382	4671	scmd->device->channel, scmd->device->id, smid,
4383	4672	MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
4384	4673	mr_device_priv_data);
4385		- mr_device_priv_data->tm_busy = 0;
	4674	+ mr_device_priv_data->tm_busy = false;
4386	4675
4387	4676	mutex_unlock(&instance->reset_mutex);
4388		-out:
4389		- sdev_printk(KERN_INFO, scmd->device, "task abort: %s scmd(%p)\n",
	4677	+ scmd_printk(KERN_INFO, scmd, "task abort %s!! scmd(0x%p)\n",
4390	4678	((ret == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
	4679	+out:
	4680	+ scsi_print_command(scmd);
	4681	+ if (megasas_dbg_lvl & TM_DEBUG)
	4682	+ megasas_dump_fusion_io(scmd);
4391	4683
4392	4684	return ret;
4393	4685	}
..	..	@@ -4405,15 +4697,10 @@
4405	4697	struct megasas_instance *instance;
4406	4698	int ret = FAILED;
4407	4699	u16 devhandle;
4408		- struct fusion_context *fusion;
4409	4700	struct MR_PRIV_DEVICE *mr_device_priv_data;
4410	4701	mr_device_priv_data = scmd->device->hostdata;
4411	4702
4412	4703	instance = (struct megasas_instance *)scmd->device->host->hostdata;
4413		- fusion = instance->ctrl_context;
4414		-
4415		- sdev_printk(KERN_INFO, scmd->device,
4416		- "target reset called for scmd(%p)\n", scmd);
4417	4704
4418	4705	if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
4419	4706	dev_err(&instance->pdev->dev, "Controller is not OPERATIONAL,"
..	..	@@ -4423,13 +4710,12 @@
4423	4710	}
4424	4711
4425	4712	if (!mr_device_priv_data) {
4426		- sdev_printk(KERN_INFO, scmd->device, "device been deleted! "
4427		- "scmd(%p)\n", scmd);
	4713	+ sdev_printk(KERN_INFO, scmd->device,
	4714	+ "device been deleted! scmd: (0x%p)\n", scmd);
4428	4715	scmd->result = DID_NO_CONNECT << 16;
4429	4716	ret = SUCCESS;
4430	4717	goto out;
4431	4718	}
4432		-
4433	4719
4434	4720	if (!mr_device_priv_data->is_tm_capable) {
4435	4721	ret = FAILED;
..	..	@@ -4448,24 +4734,25 @@
4448	4734	}
4449	4735
4450	4736	sdev_printk(KERN_INFO, scmd->device,
4451		- "attempting target reset! scmd(%p) tm_dev_handle 0x%x\n",
	4737	+ "attempting target reset! scmd(0x%p) tm_dev_handle: 0x%x\n",
4452	4738	scmd, devhandle);
4453		- mr_device_priv_data->tm_busy = 1;
	4739	+ mr_device_priv_data->tm_busy = true;
4454	4740	ret = megasas_issue_tm(instance, devhandle,
4455	4741	scmd->device->channel, scmd->device->id, 0,
4456	4742	MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
4457	4743	mr_device_priv_data);
4458		- mr_device_priv_data->tm_busy = 0;
	4744	+ mr_device_priv_data->tm_busy = false;
4459	4745	mutex_unlock(&instance->reset_mutex);
4460		-out:
4461		- scmd_printk(KERN_NOTICE, scmd, "megasas: target reset %s!!\n",
	4746	+ scmd_printk(KERN_NOTICE, scmd, "target reset %s!!\n",
4462	4747	(ret == SUCCESS) ? "SUCCESS" : "FAILED");
4463	4748
	4749	+out:
4464	4750	return ret;
4465	4751	}
4466	4752
4467	4753	/SRIOV get other instance in cluster if any/
4468		-struct megasas_instance megasas_get_peer_instance(struct megasas_instance instance)
	4754	+static struct
	4755	+megasas_instance megasas_get_peer_instance(struct megasas_instance instance)
4469	4756	{
4470	4757	int i;
4471	4758
..	..	@@ -4505,12 +4792,14 @@
4505	4792	struct megasas_instance *instance;
4506	4793	struct megasas_cmd_fusion cmd_fusion, r1_cmd;
4507	4794	struct fusion_context *fusion;
4508		- u32 abs_state, status_reg, reset_adapter;
	4795	+ u32 abs_state, status_reg, reset_adapter, fpio_count = 0;
4509	4796	u32 io_timeout_in_crash_mode = 0;
4510	4797	struct scsi_cmnd *scmd_local = NULL;
4511	4798	struct scsi_device *sdev;
4512	4799	int ret_target_prop = DCMD_FAILED;
4513	4800	bool is_target_prop = false;
	4801	+ bool do_adp_reset = true;
	4802	+ int max_reset_tries = MEGASAS_FUSION_MAX_RESET_TRIES;
4514	4803
4515	4804	instance = (struct megasas_instance *)shost->hostdata;
4516	4805	fusion = instance->ctrl_context;
..	..	@@ -4524,7 +4813,7 @@
4524	4813	mutex_unlock(&instance->reset_mutex);
4525	4814	return FAILED;
4526	4815	}
4527		- status_reg = instance->instancet->read_fw_status_reg(instance->reg_set);
	4816	+ status_reg = instance->instancet->read_fw_status_reg(instance);
4528	4817	abs_state = status_reg & MFI_STATE_MASK;
4529	4818
4530	4819	/* IO timeout detected, forcibly put FW in FAULT state */
..	..	@@ -4533,7 +4822,7 @@
4533	4822	dev_info(&instance->pdev->dev, "IO/DCMD timeout is detected, "
4534	4823	"forcibly FAULT Firmware\n");
4535	4824	atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
4536		- status_reg = readl(&instance->reg_set->doorbell);
	4825	+ status_reg = megasas_readl(instance, &instance->reg_set->doorbell);
4537	4826	writel(status_reg \| MFI_STATE_FORCE_OCR,
4538	4827	&instance->reg_set->doorbell);
4539	4828	readl(&instance->reg_set->doorbell);
..	..	@@ -4578,25 +4867,29 @@
4578	4867	if (convert)
4579	4868	reason = 0;
4580	4869
4581		- if (megasas_dbg_lvl & OCR_LOGS)
	4870	+ if (megasas_dbg_lvl & OCR_DEBUG)
4582	4871	dev_info(&instance->pdev->dev, "\nPending SCSI commands:\n");
4583	4872
4584	4873	/* Now return commands back to the OS */
4585	4874	for (i = 0 ; i < instance->max_scsi_cmds; i++) {
4586	4875	cmd_fusion = fusion->cmd_list[i];
4587	4876	/check for extra commands issued by driver/
4588		- if (instance->adapter_type == VENTURA_SERIES) {
	4877	+ if (instance->adapter_type >= VENTURA_SERIES) {
4589	4878	r1_cmd = fusion->cmd_list[i + instance->max_fw_cmds];
4590	4879	megasas_return_cmd_fusion(instance, r1_cmd);
4591	4880	}
4592	4881	scmd_local = cmd_fusion->scmd;
4593	4882	if (cmd_fusion->scmd) {
4594		- if (megasas_dbg_lvl & OCR_LOGS) {
	4883	+ if (megasas_dbg_lvl & OCR_DEBUG) {
4595	4884	sdev_printk(KERN_INFO,
4596	4885	cmd_fusion->scmd->device, "SMID: 0x%x\n",
4597	4886	cmd_fusion->index);
4598		- scsi_print_command(cmd_fusion->scmd);
	4887	+ megasas_dump_fusion_io(cmd_fusion->scmd);
4599	4888	}
	4889	+
	4890	+ if (cmd_fusion->io_request->Function ==
	4891	+ MPI2_FUNCTION_SCSI_IO_REQUEST)
	4892	+ fpio_count++;
4600	4893
4601	4894	scmd_local->result =
4602	4895	megasas_check_mpio_paths(instance,
..	..	@@ -4610,10 +4903,12 @@
4610	4903	}
4611	4904	}
4612	4905
	4906	+ dev_info(&instance->pdev->dev, "Outstanding fastpath IOs: %d\n",
	4907	+ fpio_count);
	4908	+
4613	4909	atomic_set(&instance->fw_outstanding, 0);
4614	4910
4615		- status_reg = instance->instancet->read_fw_status_reg(
4616		- instance->reg_set);
	4911	+ status_reg = instance->instancet->read_fw_status_reg(instance);
4617	4912	abs_state = status_reg & MFI_STATE_MASK;
4618	4913	reset_adapter = status_reg & MFI_RESET_ADAPTER;
4619	4914	if (instance->disableOnlineCtrlReset \|\|
..	..	@@ -4622,55 +4917,50 @@
4622	4917	dev_warn(&instance->pdev->dev, "Reset not supported"
4623	4918	", killing adapter scsi%d.\n",
4624	4919	instance->host->host_no);
4625		- megaraid_sas_kill_hba(instance);
4626		- instance->skip_heartbeat_timer_del = 1;
4627		- retval = FAILED;
4628		- goto out;
	4920	+ goto kill_hba;
4629	4921	}
4630	4922
4631	4923	/* Let SR-IOV VF & PF sync up if there was a HB failure */
4632	4924	if (instance->requestorId && !reason) {
4633	4925	msleep(MEGASAS_OCR_SETTLE_TIME_VF);
4634		- goto transition_to_ready;
	4926	+ do_adp_reset = false;
	4927	+ max_reset_tries = MEGASAS_SRIOV_MAX_RESET_TRIES_VF;
4635	4928	}
4636	4929
4637	4930	/* Now try to reset the chip */
4638		- for (i = 0; i < MEGASAS_FUSION_MAX_RESET_TRIES; i++) {
4639		-
4640		- if (instance->instancet->adp_reset
4641		- (instance, instance->reg_set))
	4931	+ for (i = 0; i < max_reset_tries; i++) {
	4932	+ /*
	4933	+ * Do adp reset and wait for
	4934	+ * controller to transition to ready
	4935	+ */
	4936	+ if (megasas_adp_reset_wait_for_ready(instance,
	4937	+ do_adp_reset, 1) == FAILED)
4642	4938	continue;
4643		-transition_to_ready:
	4939	+
4644	4940	/* Wait for FW to become ready */
4645	4941	if (megasas_transition_to_ready(instance, 1)) {
4646	4942	dev_warn(&instance->pdev->dev,
4647	4943	"Failed to transition controller to ready for "
4648	4944	"scsi%d.\n", instance->host->host_no);
4649		- if (instance->requestorId && !reason)
4650		- goto fail_kill_adapter;
4651		- else
4652		- continue;
	4945	+ continue;
4653	4946	}
4654	4947	megasas_reset_reply_desc(instance);
4655	4948	megasas_fusion_update_can_queue(instance, OCR_CONTEXT);
4656	4949
4657	4950	if (megasas_ioc_init_fusion(instance)) {
4658		- if (instance->requestorId && !reason)
4659		- goto fail_kill_adapter;
4660		- else
4661		- continue;
	4951	+ continue;
4662	4952	}
4663	4953
4664	4954	if (megasas_get_ctrl_info(instance)) {
4665	4955	dev_info(&instance->pdev->dev,
4666	4956	"Failed from %s %d\n",
4667	4957	__func__, __LINE__);
4668		- megaraid_sas_kill_hba(instance);
4669		- retval = FAILED;
4670		- goto out;
	4958	+ goto kill_hba;
4671	4959	}
4672	4960
4673		- megasas_refire_mgmt_cmd(instance);
	4961	+ megasas_refire_mgmt_cmd(instance,
	4962	+ (i == (MEGASAS_FUSION_MAX_RESET_TRIES - 1)
	4963	+ ? 1 : 0));
4674	4964
4675	4965	/* Reset load balance info */
4676	4966	if (fusion->load_balance_info)
..	..	@@ -4678,13 +4968,21 @@
4678	4968	(sizeof(struct LD_LOAD_BALANCE_INFO) *
4679	4969	MAX_LOGICAL_DRIVES_EXT));
4680	4970
4681		- if (!megasas_get_map_info(instance))
	4971	+ if (!megasas_get_map_info(instance)) {
4682	4972	megasas_sync_map_info(instance);
	4973	+ } else {
	4974	+ /*
	4975	+ * Return pending polled mode cmds before
	4976	+ * retrying OCR
	4977	+ */
	4978	+ megasas_return_polled_cmds(instance);
	4979	+ continue;
	4980	+ }
4683	4981
4684	4982	megasas_setup_jbod_map(instance);
4685	4983
4686	4984	/* reset stream detection array */
4687		- if (instance->adapter_type == VENTURA_SERIES) {
	4985	+ if (instance->adapter_type >= VENTURA_SERIES) {
4688	4986	for (j = 0; j < MAX_LOGICAL_DRIVES_EXT; ++j) {
4689	4987	memset(fusion->stream_detect_by_ld[j],
4690	4988	0, sizeof(struct LD_STREAM_DETECT));
..	..	@@ -4696,7 +4994,7 @@
4696	4994	clear_bit(MEGASAS_FUSION_IN_RESET,
4697	4995	&instance->reset_flags);
4698	4996	instance->instancet->enable_intr(instance);
4699		-
	4997	+ megasas_enable_irq_poll(instance);
4700	4998	shost_for_each_device(sdev, shost) {
4701	4999	if ((instance->tgt_prop) &&
4702	5000	(instance->nvme_page_size))
..	..	@@ -4706,11 +5004,20 @@
4706	5004	megasas_set_dynamic_target_properties(sdev, is_target_prop);
4707	5005	}
4708	5006
	5007	+ status_reg = instance->instancet->read_fw_status_reg
	5008	+ (instance);
	5009	+ abs_state = status_reg & MFI_STATE_MASK;
	5010	+ if (abs_state != MFI_STATE_OPERATIONAL) {
	5011	+ dev_info(&instance->pdev->dev,
	5012	+ "Adapter is not OPERATIONAL, state 0x%x for scsi:%d\n",
	5013	+ abs_state, instance->host->host_no);
	5014	+ goto out;
	5015	+ }
4709	5016	atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
4710	5017
4711		- dev_info(&instance->pdev->dev, "Interrupts are enabled and"
4712		- " controller is OPERATIONAL for scsi:%d\n",
4713		- instance->host->host_no);
	5018	+ dev_info(&instance->pdev->dev,
	5019	+ "Adapter is OPERATIONAL for scsi:%d\n",
	5020	+ instance->host->host_no);
4714	5021
4715	5022	/* Restart SR-IOV heartbeat */
4716	5023	if (instance->requestorId) {
..	..	@@ -4728,6 +5035,13 @@
4728	5035	megasas_set_crash_dump_params(instance,
4729	5036	MR_CRASH_BUF_TURN_OFF);
4730	5037
	5038	+ if (instance->snapdump_wait_time) {
	5039	+ megasas_get_snapdump_properties(instance);
	5040	+ dev_info(&instance->pdev->dev,
	5041	+ "Snap dump wait time\t: %d\n",
	5042	+ instance->snapdump_wait_time);
	5043	+ }
	5044	+
4731	5045	retval = SUCCESS;
4732	5046
4733	5047	/* Adapter reset completed successfully */
..	..	@@ -4737,13 +5051,10 @@
4737	5051
4738	5052	goto out;
4739	5053	}
4740		-fail_kill_adapter:
4741	5054	/* Reset failed, kill the adapter */
4742	5055	dev_warn(&instance->pdev->dev, "Reset failed, killing "
4743	5056	"adapter scsi%d.\n", instance->host->host_no);
4744		- megaraid_sas_kill_hba(instance);
4745		- instance->skip_heartbeat_timer_del = 1;
4746		- retval = FAILED;
	5057	+ goto kill_hba;
4747	5058	} else {
4748	5059	/* For VF: Restart HB timer if we didn't OCR */
4749	5060	if (instance->requestorId) {
..	..	@@ -4751,24 +5062,30 @@
4751	5062	}
4752	5063	clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
4753	5064	instance->instancet->enable_intr(instance);
	5065	+ megasas_enable_irq_poll(instance);
4754	5066	atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
	5067	+ goto out;
4755	5068	}
	5069	+kill_hba:
	5070	+ megaraid_sas_kill_hba(instance);
	5071	+ megasas_enable_irq_poll(instance);
	5072	+ instance->skip_heartbeat_timer_del = 1;
	5073	+ retval = FAILED;
4756	5074	out:
4757	5075	clear_bit(MEGASAS_FUSION_OCR_NOT_POSSIBLE, &instance->reset_flags);
4758	5076	mutex_unlock(&instance->reset_mutex);
4759	5077	return retval;
4760	5078	}
4761	5079
4762		-/* Fusion Crash dump collection work queue */
4763		-void megasas_fusion_crash_dump_wq(struct work_struct *work)
	5080	+/* Fusion Crash dump collection */
	5081	+static void megasas_fusion_crash_dump(struct megasas_instance *instance)
4764	5082	{
4765		- struct megasas_instance *instance =
4766		- container_of(work, struct megasas_instance, crash_init);
4767	5083	u32 status_reg;
4768	5084	u8 partial_copy = 0;
	5085	+ int wait = 0;
4769	5086
4770	5087
4771		- status_reg = instance->instancet->read_fw_status_reg(instance->reg_set);
	5088	+ status_reg = instance->instancet->read_fw_status_reg(instance);
4772	5089
4773	5090	/*
4774	5091	* Allocate host crash buffers to copy data from 1 MB DMA crash buffer
..	..	@@ -4784,8 +5101,8 @@
4784	5101	"crash dump and initiating OCR\n");
4785	5102	status_reg \|= MFI_STATE_CRASH_DUMP_DONE;
4786	5103	writel(status_reg,
4787		- &instance->reg_set->outbound_scratch_pad);
4788		- readl(&instance->reg_set->outbound_scratch_pad);
	5104	+ &instance->reg_set->outbound_scratch_pad_0);
	5105	+ readl(&instance->reg_set->outbound_scratch_pad_0);
4789	5106	return;
4790	5107	}
4791	5108	megasas_alloc_host_crash_buffer(instance);
..	..	@@ -4793,21 +5110,41 @@
4793	5110	"allocated: %d\n", instance->drv_buf_alloc);
4794	5111	}
4795	5112
4796		- /*
4797		- * Driver has allocated max buffers, which can be allocated
4798		- * and FW has more crash dump data, then driver will
4799		- * ignore the data.
4800		- */
4801		- if (instance->drv_buf_index >= (instance->drv_buf_alloc)) {
4802		- dev_info(&instance->pdev->dev, "Driver is done copying "
4803		- "the buffer: %d\n", instance->drv_buf_alloc);
4804		- status_reg \|= MFI_STATE_CRASH_DUMP_DONE;
4805		- partial_copy = 1;
4806		- } else {
4807		- memcpy(instance->crash_buf[instance->drv_buf_index],
4808		- instance->crash_dump_buf, CRASH_DMA_BUF_SIZE);
4809		- instance->drv_buf_index++;
4810		- status_reg &= ~MFI_STATE_DMADONE;
	5113	+ while (!(status_reg & MFI_STATE_CRASH_DUMP_DONE) &&
	5114	+ (wait < MEGASAS_WATCHDOG_WAIT_COUNT)) {
	5115	+ if (!(status_reg & MFI_STATE_DMADONE)) {
	5116	+ /*
	5117	+ * Next crash dump buffer is not yet DMA'd by FW
	5118	+ * Check after 10ms. Wait for 1 second for FW to
	5119	+ * post the next buffer. If not bail out.
	5120	+ */
	5121	+ wait++;
	5122	+ msleep(MEGASAS_WAIT_FOR_NEXT_DMA_MSECS);
	5123	+ status_reg = instance->instancet->read_fw_status_reg(
	5124	+ instance);
	5125	+ continue;
	5126	+ }
	5127	+
	5128	+ wait = 0;
	5129	+ if (instance->drv_buf_index >= instance->drv_buf_alloc) {
	5130	+ dev_info(&instance->pdev->dev,
	5131	+ "Driver is done copying the buffer: %d\n",
	5132	+ instance->drv_buf_alloc);
	5133	+ status_reg \|= MFI_STATE_CRASH_DUMP_DONE;
	5134	+ partial_copy = 1;
	5135	+ break;
	5136	+ } else {
	5137	+ memcpy(instance->crash_buf[instance->drv_buf_index],
	5138	+ instance->crash_dump_buf, CRASH_DMA_BUF_SIZE);
	5139	+ instance->drv_buf_index++;
	5140	+ status_reg &= ~MFI_STATE_DMADONE;
	5141	+ }
	5142	+
	5143	+ writel(status_reg, &instance->reg_set->outbound_scratch_pad_0);
	5144	+ readl(&instance->reg_set->outbound_scratch_pad_0);
	5145	+
	5146	+ msleep(MEGASAS_WAIT_FOR_NEXT_DMA_MSECS);
	5147	+ status_reg = instance->instancet->read_fw_status_reg(instance);
4811	5148	}
4812	5149
4813	5150	if (status_reg & MFI_STATE_CRASH_DUMP_DONE) {
..	..	@@ -4816,13 +5153,10 @@
4816	5153	instance->fw_crash_buffer_size = instance->drv_buf_index;
4817	5154	instance->fw_crash_state = AVAILABLE;
4818	5155	instance->drv_buf_index = 0;
4819		- writel(status_reg, &instance->reg_set->outbound_scratch_pad);
4820		- readl(&instance->reg_set->outbound_scratch_pad);
	5156	+ writel(status_reg, &instance->reg_set->outbound_scratch_pad_0);
	5157	+ readl(&instance->reg_set->outbound_scratch_pad_0);
4821	5158	if (!partial_copy)
4822	5159	megasas_reset_fusion(instance->host, 0);
4823		- } else {
4824		- writel(status_reg, &instance->reg_set->outbound_scratch_pad);
4825		- readl(&instance->reg_set->outbound_scratch_pad);
4826	5160	}
4827	5161	}
4828	5162