1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* Linux MegaRAID driver for SAS based RAID controllers
4	*
5	* Copyright (c) 2003-2013 LSI Corporation
6	* Copyright (c) 2013-2016 Avago Technologies
7	* Copyright (c) 2016-2018 Broadcom Inc.
8	*
9	* Authors: Broadcom Inc.
10	* Sreenivas Bagalkote
11	* Sumant Patro
12	* Bo Yang
13	* Adam Radford
14	* Kashyap Desai <kashyap.desai@broadcom.com>
15	* Sumit Saxena <sumit.saxena@broadcom.com>
16	*
17	* Send feedback to: megaraidlinux.pdl@broadcom.com
18	*/
19
20	#include <linux/kernel.h>
21	#include <linux/types.h>
22	#include <linux/pci.h>
23	#include <linux/list.h>
24	#include <linux/moduleparam.h>
25	#include <linux/module.h>
26	#include <linux/spinlock.h>
27	#include <linux/interrupt.h>
28	#include <linux/delay.h>
29	#include <linux/uio.h>
30	#include <linux/slab.h>
31	#include <linux/uaccess.h>
32	#include <asm/unaligned.h>
33	#include <linux/fs.h>
34	#include <linux/compat.h>
35	#include <linux/blkdev.h>
36	#include <linux/mutex.h>
37	#include <linux/poll.h>
38	#include <linux/vmalloc.h>
39	#include <linux/irq_poll.h>
40	#include <linux/blk-mq-pci.h>
41
42	#include <scsi/scsi.h>
43	#include <scsi/scsi_cmnd.h>
44	#include <scsi/scsi_device.h>
45	#include <scsi/scsi_host.h>
46	#include <scsi/scsi_tcq.h>
47	#include <scsi/scsi_dbg.h>
48	#include "megaraid_sas_fusion.h"
49	#include "megaraid_sas.h"
50
51	/*
52	* Number of sectors per IO command
53	* Will be set in megasas_init_mfi if user does not provide
54	*/
55	static unsigned int max_sectors;
56	module_param_named(max_sectors, max_sectors, int, 0444);
57	MODULE_PARM_DESC(max_sectors,
58	"Maximum number of sectors per IO command");
59
60	static int msix_disable;
61	module_param(msix_disable, int, 0444);
62	MODULE_PARM_DESC(msix_disable, "Disable MSI-X interrupt handling. Default: 0");
63
64	static unsigned int msix_vectors;
65	module_param(msix_vectors, int, 0444);
66	MODULE_PARM_DESC(msix_vectors, "MSI-X max vector count. Default: Set by FW");
67
68	static int allow_vf_ioctls;
69	module_param(allow_vf_ioctls, int, 0444);
70	MODULE_PARM_DESC(allow_vf_ioctls, "Allow ioctls in SR-IOV VF mode. Default: 0");
71
72	static unsigned int throttlequeuedepth = MEGASAS_THROTTLE_QUEUE_DEPTH;
73	module_param(throttlequeuedepth, int, 0444);
74	MODULE_PARM_DESC(throttlequeuedepth,
75	"Adapter queue depth when throttled due to I/O timeout. Default: 16");
76
77	unsigned int resetwaittime = MEGASAS_RESET_WAIT_TIME;
78	module_param(resetwaittime, int, 0444);
79	MODULE_PARM_DESC(resetwaittime, "Wait time in (1-180s) after I/O timeout before resetting adapter. Default: 180s");
80
81	static int smp_affinity_enable = 1;
82	module_param(smp_affinity_enable, int, 0444);
83	MODULE_PARM_DESC(smp_affinity_enable, "SMP affinity feature enable/disable Default: enable(1)");
84
85	static int rdpq_enable = 1;
86	module_param(rdpq_enable, int, 0444);
87	MODULE_PARM_DESC(rdpq_enable, "Allocate reply queue in chunks for large queue depth enable/disable Default: enable(1)");
88
89	unsigned int dual_qdepth_disable;
90	module_param(dual_qdepth_disable, int, 0444);
91	MODULE_PARM_DESC(dual_qdepth_disable, "Disable dual queue depth feature. Default: 0");
92
93	static unsigned int scmd_timeout = MEGASAS_DEFAULT_CMD_TIMEOUT;
94	module_param(scmd_timeout, int, 0444);
95	MODULE_PARM_DESC(scmd_timeout, "scsi command timeout (10-90s), default 90s. See megasas_reset_timer.");
96
97	int perf_mode = -1;
98	module_param(perf_mode, int, 0444);
99	MODULE_PARM_DESC(perf_mode, "Performance mode (only for Aero adapters), options:\n\t\t"
100	"0 - balanced: High iops and low latency queues are allocated &\n\t\t"
101	"interrupt coalescing is enabled only on high iops queues\n\t\t"
102	"1 - iops: High iops queues are not allocated &\n\t\t"
103	"interrupt coalescing is enabled on all queues\n\t\t"
104	"2 - latency: High iops queues are not allocated &\n\t\t"
105	"interrupt coalescing is disabled on all queues\n\t\t"
106	"default mode is 'balanced'"
107	);
108
109	int event_log_level = MFI_EVT_CLASS_CRITICAL;
110	module_param(event_log_level, int, 0644);
111	MODULE_PARM_DESC(event_log_level, "Asynchronous event logging level- range is: -2(CLASS_DEBUG) to 4(CLASS_DEAD), Default: 2(CLASS_CRITICAL)");
112
113	unsigned int enable_sdev_max_qd;
114	module_param(enable_sdev_max_qd, int, 0444);
115	MODULE_PARM_DESC(enable_sdev_max_qd, "Enable sdev max qd as can_queue. Default: 0");
116
117	int poll_queues;
118	module_param(poll_queues, int, 0444);
119	MODULE_PARM_DESC(poll_queues, "Number of queues to be use for io_uring poll mode.\n\t\t"
120	"This parameter is effective only if host_tagset_enable=1 &\n\t\t"
121	"It is not applicable for MFI_SERIES. &\n\t\t"
122	"Driver will work in latency mode. &\n\t\t"
123	"High iops queues are not allocated &\n\t\t"
124	);
125
126	int host_tagset_enable = 1;
127	module_param(host_tagset_enable, int, 0444);
128	MODULE_PARM_DESC(host_tagset_enable, "Shared host tagset enable/disable Default: enable(1)");
129
130	MODULE_LICENSE("GPL");
131	MODULE_VERSION(MEGASAS_VERSION);
132	MODULE_AUTHOR("megaraidlinux.pdl@broadcom.com");
133	MODULE_DESCRIPTION("Broadcom MegaRAID SAS Driver");
134
135	int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
136	static int megasas_get_pd_list(struct megasas_instance *instance);
137	static int megasas_ld_list_query(struct megasas_instance *instance,
138	u8 query_type);
139	static int megasas_issue_init_mfi(struct megasas_instance *instance);
140	static int megasas_register_aen(struct megasas_instance *instance,
141	u32 seq_num, u32 class_locale_word);
142	static void megasas_get_pd_info(struct megasas_instance *instance,
143	struct scsi_device *sdev);
144	static void
145	megasas_set_ld_removed_by_fw(struct megasas_instance *instance);
146
147	/*
148	* PCI ID table for all supported controllers
149	*/
150	static struct pci_device_id megasas_pci_table[] = {
151
152	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064R)},
153	/* xscale IOP */
154	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078R)},
155	/* ppc IOP */
156	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078DE)},
157	/* ppc IOP */
158	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078GEN2)},
159	/* gen2*/
160	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0079GEN2)},
161	/* gen2*/
162	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0073SKINNY)},
163	/* skinny*/
164	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0071SKINNY)},
165	/* skinny*/
166	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VERDE_ZCR)},
167	/* xscale IOP, vega */
168	{PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)},
169	/* xscale IOP */
170	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FUSION)},
171	/* Fusion */
172	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_PLASMA)},
173	/* Plasma */
174	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_INVADER)},
175	/* Invader */
176	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FURY)},
177	/* Fury */
178	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_INTRUDER)},
179	/* Intruder */
180	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_INTRUDER_24)},
181	/* Intruder 24 port*/
182	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_CUTLASS_52)},
183	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_CUTLASS_53)},
184	/* VENTURA */
185	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VENTURA)},
186	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_CRUSADER)},
187	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_HARPOON)},
188	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_TOMCAT)},
189	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VENTURA_4PORT)},
190	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_CRUSADER_4PORT)},
191	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E1)},
192	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E2)},
193	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E5)},
194	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E6)},
195	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E0)},
196	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E3)},
197	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E4)},
198	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E7)},
199	{}
200	};
201
202	MODULE_DEVICE_TABLE(pci, megasas_pci_table);
203
204	static int megasas_mgmt_majorno;
205	struct megasas_mgmt_info megasas_mgmt_info;
206	static struct fasync_struct *megasas_async_queue;
207	static DEFINE_MUTEX(megasas_async_queue_mutex);
208
209	static int megasas_poll_wait_aen;
210	static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait);
211	static u32 support_poll_for_event;
212	u32 megasas_dbg_lvl;
213	static u32 support_device_change;
214	static bool support_nvme_encapsulation;
215	static bool support_pci_lane_margining;
216
217	/* define lock for aen poll */
218	static DEFINE_SPINLOCK(poll_aen_lock);
219
220	extern struct dentry *megasas_debugfs_root;
221	extern int megasas_blk_mq_poll(struct Scsi_Host *shost, unsigned int queue_num);
222
223	void
224	megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
225	u8 alt_status);
226	static u32
227	megasas_read_fw_status_reg_gen2(struct megasas_instance *instance);
228	static int
229	megasas_adp_reset_gen2(struct megasas_instance *instance,
230	struct megasas_register_set __iomem *reg_set);
231	static irqreturn_t megasas_isr(int irq, void *devp);
232	static u32
233	megasas_init_adapter_mfi(struct megasas_instance *instance);
234	u32
235	megasas_build_and_issue_cmd(struct megasas_instance *instance,
236	struct scsi_cmnd *scmd);
237	static void megasas_complete_cmd_dpc(unsigned long instance_addr);
238	int
239	wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
240	int seconds);
241	void megasas_fusion_ocr_wq(struct work_struct *work);
242	static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,
243	int initial);
244	static int
245	megasas_set_dma_mask(struct megasas_instance *instance);
246	static int
247	megasas_alloc_ctrl_mem(struct megasas_instance *instance);
248	static inline void
249	megasas_free_ctrl_mem(struct megasas_instance *instance);
250	static inline int
251	megasas_alloc_ctrl_dma_buffers(struct megasas_instance *instance);
252	static inline void
253	megasas_free_ctrl_dma_buffers(struct megasas_instance *instance);
254	static inline void
255	megasas_init_ctrl_params(struct megasas_instance *instance);
256
257	u32 megasas_readl(struct megasas_instance *instance,
258	const volatile void __iomem *addr)
259	{
260	u32 i = 0, ret_val;
261	/*
262	* Due to a HW errata in Aero controllers, reads to certain
263	* Fusion registers could intermittently return all zeroes.
264	* This behavior is transient in nature and subsequent reads will
265	* return valid value. As a workaround in driver, retry readl for
266	* up to thirty times until a non-zero value is read.
267	*/
268	if (instance->adapter_type == AERO_SERIES) {
269	do {
270	ret_val = readl(addr);
271	i++;
272	} while (ret_val == 0 && i < 30);
273	return ret_val;
274	} else {
275	return readl(addr);
276	}
277	}
278
279	/**
280	* megasas_set_dma_settings - Populate DMA address, length and flags for DCMDs
281	* @instance: Adapter soft state
282	* @dcmd: DCMD frame inside MFI command
283	* @dma_addr: DMA address of buffer to be passed to FW
284	* @dma_len: Length of DMA buffer to be passed to FW
285	* @return: void
286	*/
287	void megasas_set_dma_settings(struct megasas_instance *instance,
288	struct megasas_dcmd_frame *dcmd,
289	dma_addr_t dma_addr, u32 dma_len)
290	{
291	if (instance->consistent_mask_64bit) {
292	dcmd->sgl.sge64[0].phys_addr = cpu_to_le64(dma_addr);
293	dcmd->sgl.sge64[0].length = cpu_to_le32(dma_len);
294	dcmd->flags = cpu_to_le16(dcmd->flags | MFI_FRAME_SGL64);
295
296	} else {
297	dcmd->sgl.sge32[0].phys_addr =
298	cpu_to_le32(lower_32_bits(dma_addr));
299	dcmd->sgl.sge32[0].length = cpu_to_le32(dma_len);
300	dcmd->flags = cpu_to_le16(dcmd->flags);
301	}
302	}
303
304	static void
305	megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
306	{
307	instance->instancet->fire_cmd(instance,
308	cmd->frame_phys_addr, 0, instance->reg_set);
309	return;
310	}
311
312	/**
313	* megasas_get_cmd - Get a command from the free pool
314	* @instance: Adapter soft state
315	*
316	* Returns a free command from the pool
317	*/
318	struct megasas_cmd *megasas_get_cmd(struct megasas_instance
319	*instance)
320	{
321	unsigned long flags;
322	struct megasas_cmd *cmd = NULL;
323
324	spin_lock_irqsave(&instance->mfi_pool_lock, flags);
325
326	if (!list_empty(head: &instance->cmd_pool)) {
327	cmd = list_entry((&instance->cmd_pool)->next,
328	struct megasas_cmd, list);
329	list_del_init(entry: &cmd->list);
330	} else {
331	dev_err(&instance->pdev->dev, "Command pool empty!\n");
332	}
333
334	spin_unlock_irqrestore(lock: &instance->mfi_pool_lock, flags);
335	return cmd;
336	}
337
338	/**
339	* megasas_return_cmd - Return a cmd to free command pool
340	* @instance: Adapter soft state
341	* @cmd: Command packet to be returned to free command pool
342	*/
343	void
344	megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
345	{
346	unsigned long flags;
347	u32 blk_tags;
348	struct megasas_cmd_fusion *cmd_fusion;
349	struct fusion_context *fusion = instance->ctrl_context;
350
351	/* This flag is used only for fusion adapter.
352	* Wait for Interrupt for Polled mode DCMD
353	*/
354	if (cmd->flags & DRV_DCMD_POLLED_MODE)
355	return;
356
357	spin_lock_irqsave(&instance->mfi_pool_lock, flags);
358
359	if (fusion) {
360	blk_tags = instance->max_scsi_cmds + cmd->index;
361	cmd_fusion = fusion->cmd_list[blk_tags];
362	megasas_return_cmd_fusion(instance, cmd: cmd_fusion);
363	}
364	cmd->scmd = NULL;
365	cmd->frame_count = 0;
366	cmd->flags = 0;
367	memset(cmd->frame, 0, instance->mfi_frame_size);
368	cmd->frame->io.context = cpu_to_le32(cmd->index);
369	if (!fusion && reset_devices)
370	cmd->frame->hdr.cmd = MFI_CMD_INVALID;
371	list_add(new: &cmd->list, head: (&instance->cmd_pool)->next);
372
373	spin_unlock_irqrestore(lock: &instance->mfi_pool_lock, flags);
374
375	}
376
377	static const char *
378	format_timestamp(uint32_t timestamp)
379	{
380	static char buffer[32];
381
382	if ((timestamp & 0xff000000) == 0xff000000)
383	snprintf(buf: buffer, size: sizeof(buffer), fmt: "boot + %us", timestamp &
384	0x00ffffff);
385	else
386	snprintf(buf: buffer, size: sizeof(buffer), fmt: "%us", timestamp);
387	return buffer;
388	}
389
390	static const char *
391	format_class(int8_t class)
392	{
393	static char buffer[6];
394
395	switch (class) {
396	case MFI_EVT_CLASS_DEBUG:
397	return "debug";
398	case MFI_EVT_CLASS_PROGRESS:
399	return "progress";
400	case MFI_EVT_CLASS_INFO:
401	return "info";
402	case MFI_EVT_CLASS_WARNING:
403	return "WARN";
404	case MFI_EVT_CLASS_CRITICAL:
405	return "CRIT";
406	case MFI_EVT_CLASS_FATAL:
407	return "FATAL";
408	case MFI_EVT_CLASS_DEAD:
409	return "DEAD";
410	default:
411	snprintf(buf: buffer, size: sizeof(buffer), fmt: "%d", class);
412	return buffer;
413	}
414	}
415
416	/**
417	* megasas_decode_evt: Decode FW AEN event and print critical event
418	* for information.
419	* @instance: Adapter soft state
420	*/
421	static void
422	megasas_decode_evt(struct megasas_instance *instance)
423	{
424	struct megasas_evt_detail *evt_detail = instance->evt_detail;
425	union megasas_evt_class_locale class_locale;
426	class_locale.word = le32_to_cpu(evt_detail->cl.word);
427
428	if ((event_log_level < MFI_EVT_CLASS_DEBUG) ||
429	(event_log_level > MFI_EVT_CLASS_DEAD)) {
430	printk(KERN_WARNING "megaraid_sas: provided event log level is out of range, setting it to default 2(CLASS_CRITICAL), permissible range is: -2 to 4\n");
431	event_log_level = MFI_EVT_CLASS_CRITICAL;
432	}
433
434	if (class_locale.members.class >= event_log_level)
435	dev_info(&instance->pdev->dev, "%d (%s/0x%04x/%s) - %s\n",
436	le32_to_cpu(evt_detail->seq_num),
437	format_timestamp(le32_to_cpu(evt_detail->time_stamp)),
438	(class_locale.members.locale),
439	format_class(class_locale.members.class),
440	evt_detail->description);
441
442	if (megasas_dbg_lvl & LD_PD_DEBUG)
443	dev_info(&instance->pdev->dev,
444	"evt_detail.args.ld.target_id/index %d/%d\n",
445	evt_detail->args.ld.target_id, evt_detail->args.ld.ld_index);
446
447	}
448
449	/*
450	* The following functions are defined for xscale
451	* (deviceid : 1064R, PERC5) controllers
452	*/
453
454	/**
455	* megasas_enable_intr_xscale - Enables interrupts
456	* @instance: Adapter soft state
457	*/
458	static inline void
459	megasas_enable_intr_xscale(struct megasas_instance *instance)
460	{
461	struct megasas_register_set __iomem *regs;
462
463	regs = instance->reg_set;
464	writel(val: 0, addr: &(regs)->outbound_intr_mask);
465
466	/* Dummy readl to force pci flush */
467	readl(addr: &regs->outbound_intr_mask);
468	}
469
470	/**
471	* megasas_disable_intr_xscale -Disables interrupt
472	* @instance: Adapter soft state
473	*/
474	static inline void
475	megasas_disable_intr_xscale(struct megasas_instance *instance)
476	{
477	struct megasas_register_set __iomem *regs;
478	u32 mask = 0x1f;
479
480	regs = instance->reg_set;
481	writel(val: mask, addr: &regs->outbound_intr_mask);
482	/* Dummy readl to force pci flush */
483	readl(addr: &regs->outbound_intr_mask);
484	}
485
486	/**
487	* megasas_read_fw_status_reg_xscale - returns the current FW status value
488	* @instance: Adapter soft state
489	*/
490	static u32
491	megasas_read_fw_status_reg_xscale(struct megasas_instance *instance)
492	{
493	return readl(addr: &instance->reg_set->outbound_msg_0);
494	}
495	/**
496	* megasas_clear_intr_xscale - Check & clear interrupt
497	* @instance: Adapter soft state
498	*/
499	static int
500	megasas_clear_intr_xscale(struct megasas_instance *instance)
501	{
502	u32 status;
503	u32 mfiStatus = 0;
504	struct megasas_register_set __iomem *regs;
505	regs = instance->reg_set;
506
507	/*
508	* Check if it is our interrupt
509	*/
510	status = readl(addr: &regs->outbound_intr_status);
511
512	if (status & MFI_OB_INTR_STATUS_MASK)
513	mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
514	if (status & MFI_XSCALE_OMR0_CHANGE_INTERRUPT)
515	mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
516
517	/*
518	* Clear the interrupt by writing back the same value
519	*/
520	if (mfiStatus)
521	writel(val: status, addr: &regs->outbound_intr_status);
522
523	/* Dummy readl to force pci flush */
524	readl(addr: &regs->outbound_intr_status);
525
526	return mfiStatus;
527	}
528
529	/**
530	* megasas_fire_cmd_xscale - Sends command to the FW
531	* @instance: Adapter soft state
532	* @frame_phys_addr : Physical address of cmd
533	* @frame_count : Number of frames for the command
534	* @regs : MFI register set
535	*/
536	static inline void
537	megasas_fire_cmd_xscale(struct megasas_instance *instance,
538	dma_addr_t frame_phys_addr,
539	u32 frame_count,
540	struct megasas_register_set __iomem *regs)
541	{
542	unsigned long flags;
543
544	spin_lock_irqsave(&instance->hba_lock, flags);
545	writel(val: (frame_phys_addr >> 3)|(frame_count),
546	addr: &(regs)->inbound_queue_port);
547	spin_unlock_irqrestore(lock: &instance->hba_lock, flags);
548	}
549
550	/**
551	* megasas_adp_reset_xscale - For controller reset
552	* @instance: Adapter soft state
553	* @regs: MFI register set
554	*/
555	static int
556	megasas_adp_reset_xscale(struct megasas_instance *instance,
557	struct megasas_register_set __iomem *regs)
558	{
559	u32 i;
560	u32 pcidata;
561
562	writel(MFI_ADP_RESET, addr: &regs->inbound_doorbell);
563
564	for (i = 0; i < 3; i++)
565	msleep(msecs: 1000); /* sleep for 3 secs */
566	pcidata = 0;
567	pci_read_config_dword(dev: instance->pdev, MFI_1068_PCSR_OFFSET, val: &pcidata);
568	dev_notice(&instance->pdev->dev, "pcidata = %x\n", pcidata);
569	if (pcidata & 0x2) {
570	dev_notice(&instance->pdev->dev, "mfi 1068 offset read=%x\n", pcidata);
571	pcidata &= ~0x2;
572	pci_write_config_dword(dev: instance->pdev,
573	MFI_1068_PCSR_OFFSET, val: pcidata);
574
575	for (i = 0; i < 2; i++)
576	msleep(msecs: 1000); /* need to wait 2 secs again */
577
578	pcidata = 0;
579	pci_read_config_dword(dev: instance->pdev,
580	MFI_1068_FW_HANDSHAKE_OFFSET, val: &pcidata);
581	dev_notice(&instance->pdev->dev, "1068 offset handshake read=%x\n", pcidata);
582	if ((pcidata & 0xffff0000) == MFI_1068_FW_READY) {
583	dev_notice(&instance->pdev->dev, "1068 offset pcidt=%x\n", pcidata);
584	pcidata = 0;
585	pci_write_config_dword(dev: instance->pdev,
586	MFI_1068_FW_HANDSHAKE_OFFSET, val: pcidata);
587	}
588	}
589	return 0;
590	}
591
592	/**
593	* megasas_check_reset_xscale - For controller reset check
594	* @instance: Adapter soft state
595	* @regs: MFI register set
596	*/
597	static int
598	megasas_check_reset_xscale(struct megasas_instance *instance,
599	struct megasas_register_set __iomem *regs)
600	{
601	if ((atomic_read(v: &instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) &&
602	(le32_to_cpu(*instance->consumer) ==
603	MEGASAS_ADPRESET_INPROG_SIGN))
604	return 1;
605	return 0;
606	}
607
608	static struct megasas_instance_template megasas_instance_template_xscale = {
609
610	.fire_cmd = megasas_fire_cmd_xscale,
611	.enable_intr = megasas_enable_intr_xscale,
612	.disable_intr = megasas_disable_intr_xscale,
613	.clear_intr = megasas_clear_intr_xscale,
614	.read_fw_status_reg = megasas_read_fw_status_reg_xscale,
615	.adp_reset = megasas_adp_reset_xscale,
616	.check_reset = megasas_check_reset_xscale,
617	.service_isr = megasas_isr,
618	.tasklet = megasas_complete_cmd_dpc,
619	.init_adapter = megasas_init_adapter_mfi,
620	.build_and_issue_cmd = megasas_build_and_issue_cmd,
621	.issue_dcmd = megasas_issue_dcmd,
622	};
623
624	/*
625	* This is the end of set of functions & definitions specific
626	* to xscale (deviceid : 1064R, PERC5) controllers
627	*/
628
629	/*
630	* The following functions are defined for ppc (deviceid : 0x60)
631	* controllers
632	*/
633
634	/**
635	* megasas_enable_intr_ppc - Enables interrupts
636	* @instance: Adapter soft state
637	*/
638	static inline void
639	megasas_enable_intr_ppc(struct megasas_instance *instance)
640	{
641	struct megasas_register_set __iomem *regs;
642
643	regs = instance->reg_set;
644	writel(val: 0xFFFFFFFF, addr: &(regs)->outbound_doorbell_clear);
645
646	writel(val: ~0x80000000, addr: &(regs)->outbound_intr_mask);
647
648	/* Dummy readl to force pci flush */
649	readl(addr: &regs->outbound_intr_mask);
650	}
651
652	/**
653	* megasas_disable_intr_ppc - Disable interrupt
654	* @instance: Adapter soft state
655	*/
656	static inline void
657	megasas_disable_intr_ppc(struct megasas_instance *instance)
658	{
659	struct megasas_register_set __iomem *regs;
660	u32 mask = 0xFFFFFFFF;
661
662	regs = instance->reg_set;
663	writel(val: mask, addr: &regs->outbound_intr_mask);
664	/* Dummy readl to force pci flush */
665	readl(addr: &regs->outbound_intr_mask);
666	}
667
668	/**
669	* megasas_read_fw_status_reg_ppc - returns the current FW status value
670	* @instance: Adapter soft state
671	*/
672	static u32
673	megasas_read_fw_status_reg_ppc(struct megasas_instance *instance)
674	{
675	return readl(addr: &instance->reg_set->outbound_scratch_pad_0);
676	}
677
678	/**
679	* megasas_clear_intr_ppc - Check & clear interrupt
680	* @instance: Adapter soft state
681	*/
682	static int
683	megasas_clear_intr_ppc(struct megasas_instance *instance)
684	{
685	u32 status, mfiStatus = 0;
686	struct megasas_register_set __iomem *regs;
687	regs = instance->reg_set;
688
689	/*
690	* Check if it is our interrupt
691	*/
692	status = readl(addr: &regs->outbound_intr_status);
693
694	if (status & MFI_REPLY_1078_MESSAGE_INTERRUPT)
695	mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
696
697	if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT)
698	mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
699
700	/*
701	* Clear the interrupt by writing back the same value
702	*/
703	writel(val: status, addr: &regs->outbound_doorbell_clear);
704
705	/* Dummy readl to force pci flush */
706	readl(addr: &regs->outbound_doorbell_clear);
707
708	return mfiStatus;
709	}
710
711	/**
712	* megasas_fire_cmd_ppc - Sends command to the FW
713	* @instance: Adapter soft state
714	* @frame_phys_addr: Physical address of cmd
715	* @frame_count: Number of frames for the command
716	* @regs: MFI register set
717	*/
718	static inline void
719	megasas_fire_cmd_ppc(struct megasas_instance *instance,
720	dma_addr_t frame_phys_addr,
721	u32 frame_count,
722	struct megasas_register_set __iomem *regs)
723	{
724	unsigned long flags;
725
726	spin_lock_irqsave(&instance->hba_lock, flags);
727	writel(val: (frame_phys_addr | (frame_count<<1))|1,
728	addr: &(regs)->inbound_queue_port);
729	spin_unlock_irqrestore(lock: &instance->hba_lock, flags);
730	}
731
732	/**
733	* megasas_check_reset_ppc - For controller reset check
734	* @instance: Adapter soft state
735	* @regs: MFI register set
736	*/
737	static int
738	megasas_check_reset_ppc(struct megasas_instance *instance,
739	struct megasas_register_set __iomem *regs)
740	{
741	if (atomic_read(v: &instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
742	return 1;
743
744	return 0;
745	}
746
747	static struct megasas_instance_template megasas_instance_template_ppc = {
748
749	.fire_cmd = megasas_fire_cmd_ppc,
750	.enable_intr = megasas_enable_intr_ppc,
751	.disable_intr = megasas_disable_intr_ppc,
752	.clear_intr = megasas_clear_intr_ppc,
753	.read_fw_status_reg = megasas_read_fw_status_reg_ppc,
754	.adp_reset = megasas_adp_reset_xscale,
755	.check_reset = megasas_check_reset_ppc,
756	.service_isr = megasas_isr,
757	.tasklet = megasas_complete_cmd_dpc,
758	.init_adapter = megasas_init_adapter_mfi,
759	.build_and_issue_cmd = megasas_build_and_issue_cmd,
760	.issue_dcmd = megasas_issue_dcmd,
761	};
762
763	/**
764	* megasas_enable_intr_skinny - Enables interrupts
765	* @instance: Adapter soft state
766	*/
767	static inline void
768	megasas_enable_intr_skinny(struct megasas_instance *instance)
769	{
770	struct megasas_register_set __iomem *regs;
771
772	regs = instance->reg_set;
773	writel(val: 0xFFFFFFFF, addr: &(regs)->outbound_intr_mask);
774
775	writel(val: ~MFI_SKINNY_ENABLE_INTERRUPT_MASK, addr: &(regs)->outbound_intr_mask);
776
777	/* Dummy readl to force pci flush */
778	readl(addr: &regs->outbound_intr_mask);
779	}
780
781	/**
782	* megasas_disable_intr_skinny - Disables interrupt
783	* @instance: Adapter soft state
784	*/
785	static inline void
786	megasas_disable_intr_skinny(struct megasas_instance *instance)
787	{
788	struct megasas_register_set __iomem *regs;
789	u32 mask = 0xFFFFFFFF;
790
791	regs = instance->reg_set;
792	writel(val: mask, addr: &regs->outbound_intr_mask);
793	/* Dummy readl to force pci flush */
794	readl(addr: &regs->outbound_intr_mask);
795	}
796
797	/**
798	* megasas_read_fw_status_reg_skinny - returns the current FW status value
799	* @instance: Adapter soft state
800	*/
801	static u32
802	megasas_read_fw_status_reg_skinny(struct megasas_instance *instance)
803	{
804	return readl(addr: &instance->reg_set->outbound_scratch_pad_0);
805	}
806
807	/**
808	* megasas_clear_intr_skinny - Check & clear interrupt
809	* @instance: Adapter soft state
810	*/
811	static int
812	megasas_clear_intr_skinny(struct megasas_instance *instance)
813	{
814	u32 status;
815	u32 mfiStatus = 0;
816	struct megasas_register_set __iomem *regs;
817	regs = instance->reg_set;
818
819	/*
820	* Check if it is our interrupt
821	*/
822	status = readl(addr: &regs->outbound_intr_status);
823
824	if (!(status & MFI_SKINNY_ENABLE_INTERRUPT_MASK)) {
825	return 0;
826	}
827
828	/*
829	* Check if it is our interrupt
830	*/
831	if ((megasas_read_fw_status_reg_skinny(instance) & MFI_STATE_MASK) ==
832	MFI_STATE_FAULT) {
833	mfiStatus = MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
834	} else
835	mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
836
837	/*
838	* Clear the interrupt by writing back the same value
839	*/
840	writel(val: status, addr: &regs->outbound_intr_status);
841
842	/*
843	* dummy read to flush PCI
844	*/
845	readl(addr: &regs->outbound_intr_status);
846
847	return mfiStatus;
848	}
849
850	/**
851	* megasas_fire_cmd_skinny - Sends command to the FW
852	* @instance: Adapter soft state
853	* @frame_phys_addr: Physical address of cmd
854	* @frame_count: Number of frames for the command
855	* @regs: MFI register set
856	*/
857	static inline void
858	megasas_fire_cmd_skinny(struct megasas_instance *instance,
859	dma_addr_t frame_phys_addr,
860	u32 frame_count,
861	struct megasas_register_set __iomem *regs)
862	{
863	unsigned long flags;
864
865	spin_lock_irqsave(&instance->hba_lock, flags);
866	writel(upper_32_bits(frame_phys_addr),
867	addr: &(regs)->inbound_high_queue_port);
868	writel(val: (lower_32_bits(frame_phys_addr) | (frame_count<<1))|1,
869	addr: &(regs)->inbound_low_queue_port);
870	spin_unlock_irqrestore(lock: &instance->hba_lock, flags);
871	}
872
873	/**
874	* megasas_check_reset_skinny - For controller reset check
875	* @instance: Adapter soft state
876	* @regs: MFI register set
877	*/
878	static int
879	megasas_check_reset_skinny(struct megasas_instance *instance,
880	struct megasas_register_set __iomem *regs)
881	{
882	if (atomic_read(v: &instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
883	return 1;
884
885	return 0;
886	}
887
888	static struct megasas_instance_template megasas_instance_template_skinny = {
889
890	.fire_cmd = megasas_fire_cmd_skinny,
891	.enable_intr = megasas_enable_intr_skinny,
892	.disable_intr = megasas_disable_intr_skinny,
893	.clear_intr = megasas_clear_intr_skinny,
894	.read_fw_status_reg = megasas_read_fw_status_reg_skinny,
895	.adp_reset = megasas_adp_reset_gen2,
896	.check_reset = megasas_check_reset_skinny,
897	.service_isr = megasas_isr,
898	.tasklet = megasas_complete_cmd_dpc,
899	.init_adapter = megasas_init_adapter_mfi,
900	.build_and_issue_cmd = megasas_build_and_issue_cmd,
901	.issue_dcmd = megasas_issue_dcmd,
902	};
903
904
905	/*
906	* The following functions are defined for gen2 (deviceid : 0x78 0x79)
907	* controllers
908	*/
909
910	/**
911	* megasas_enable_intr_gen2 - Enables interrupts
912	* @instance: Adapter soft state
913	*/
914	static inline void
915	megasas_enable_intr_gen2(struct megasas_instance *instance)
916	{
917	struct megasas_register_set __iomem *regs;
918
919	regs = instance->reg_set;
920	writel(val: 0xFFFFFFFF, addr: &(regs)->outbound_doorbell_clear);
921
922	/* write ~0x00000005 (4 & 1) to the intr mask*/
923	writel(val: ~MFI_GEN2_ENABLE_INTERRUPT_MASK, addr: &(regs)->outbound_intr_mask);
924
925	/* Dummy readl to force pci flush */
926	readl(addr: &regs->outbound_intr_mask);
927	}
928
929	/**
930	* megasas_disable_intr_gen2 - Disables interrupt
931	* @instance: Adapter soft state
932	*/
933	static inline void
934	megasas_disable_intr_gen2(struct megasas_instance *instance)
935	{
936	struct megasas_register_set __iomem *regs;
937	u32 mask = 0xFFFFFFFF;
938
939	regs = instance->reg_set;
940	writel(val: mask, addr: &regs->outbound_intr_mask);
941	/* Dummy readl to force pci flush */
942	readl(addr: &regs->outbound_intr_mask);
943	}
944
945	/**
946	* megasas_read_fw_status_reg_gen2 - returns the current FW status value
947	* @instance: Adapter soft state
948	*/
949	static u32
950	megasas_read_fw_status_reg_gen2(struct megasas_instance *instance)
951	{
952	return readl(addr: &instance->reg_set->outbound_scratch_pad_0);
953	}
954
955	/**
956	* megasas_clear_intr_gen2 - Check & clear interrupt
957	* @instance: Adapter soft state
958	*/
959	static int
960	megasas_clear_intr_gen2(struct megasas_instance *instance)
961	{
962	u32 status;
963	u32 mfiStatus = 0;
964	struct megasas_register_set __iomem *regs;
965	regs = instance->reg_set;
966
967	/*
968	* Check if it is our interrupt
969	*/
970	status = readl(addr: &regs->outbound_intr_status);
971
972	if (status & MFI_INTR_FLAG_REPLY_MESSAGE) {
973	mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
974	}
975	if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT) {
976	mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
977	}
978
979	/*
980	* Clear the interrupt by writing back the same value
981	*/
982	if (mfiStatus)
983	writel(val: status, addr: &regs->outbound_doorbell_clear);
984
985	/* Dummy readl to force pci flush */
986	readl(addr: &regs->outbound_intr_status);
987
988	return mfiStatus;
989	}
990
991	/**
992	* megasas_fire_cmd_gen2 - Sends command to the FW
993	* @instance: Adapter soft state
994	* @frame_phys_addr: Physical address of cmd
995	* @frame_count: Number of frames for the command
996	* @regs: MFI register set
997	*/
998	static inline void
999	megasas_fire_cmd_gen2(struct megasas_instance *instance,
1000	dma_addr_t frame_phys_addr,
1001	u32 frame_count,
1002	struct megasas_register_set __iomem *regs)
1003	{
1004	unsigned long flags;
1005
1006	spin_lock_irqsave(&instance->hba_lock, flags);
1007	writel(val: (frame_phys_addr | (frame_count<<1))|1,
1008	addr: &(regs)->inbound_queue_port);
1009	spin_unlock_irqrestore(lock: &instance->hba_lock, flags);
1010	}
1011
1012	/**
1013	* megasas_adp_reset_gen2 - For controller reset
1014	* @instance: Adapter soft state
1015	* @reg_set: MFI register set
1016	*/
1017	static int
1018	megasas_adp_reset_gen2(struct megasas_instance *instance,
1019	struct megasas_register_set __iomem *reg_set)
1020	{
1021	u32 retry = 0 ;
1022	u32 HostDiag;
1023	u32 __iomem *seq_offset = &reg_set->seq_offset;
1024	u32 __iomem *hostdiag_offset = &reg_set->host_diag;
1025
1026	if (instance->instancet == &megasas_instance_template_skinny) {
1027	seq_offset = &reg_set->fusion_seq_offset;
1028	hostdiag_offset = &reg_set->fusion_host_diag;
1029	}
1030
1031	writel(val: 0, addr: seq_offset);
1032	writel(val: 4, addr: seq_offset);
1033	writel(val: 0xb, addr: seq_offset);
1034	writel(val: 2, addr: seq_offset);
1035	writel(val: 7, addr: seq_offset);
1036	writel(val: 0xd, addr: seq_offset);
1037
1038	msleep(msecs: 1000);
1039
1040	HostDiag = (u32)readl(addr: hostdiag_offset);
1041
1042	while (!(HostDiag & DIAG_WRITE_ENABLE)) {
1043	msleep(msecs: 100);
1044	HostDiag = (u32)readl(addr: hostdiag_offset);
1045	dev_notice(&instance->pdev->dev, "RESETGEN2: retry=%x, hostdiag=%x\n",
1046	retry, HostDiag);
1047
1048	if (retry++ >= 100)
1049	return 1;
1050
1051	}
1052
1053	dev_notice(&instance->pdev->dev, "ADP_RESET_GEN2: HostDiag=%x\n", HostDiag);
1054
1055	writel(val: (HostDiag | DIAG_RESET_ADAPTER), addr: hostdiag_offset);
1056
1057	ssleep(seconds: 10);
1058
1059	HostDiag = (u32)readl(addr: hostdiag_offset);
1060	while (HostDiag & DIAG_RESET_ADAPTER) {
1061	msleep(msecs: 100);
1062	HostDiag = (u32)readl(addr: hostdiag_offset);
1063	dev_notice(&instance->pdev->dev, "RESET_GEN2: retry=%x, hostdiag=%x\n",
1064	retry, HostDiag);
1065
1066	if (retry++ >= 1000)
1067	return 1;
1068
1069	}
1070	return 0;
1071	}
1072
1073	/**
1074	* megasas_check_reset_gen2 - For controller reset check
1075	* @instance: Adapter soft state
1076	* @regs: MFI register set
1077	*/
1078	static int
1079	megasas_check_reset_gen2(struct megasas_instance *instance,
1080	struct megasas_register_set __iomem *regs)
1081	{
1082	if (atomic_read(v: &instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
1083	return 1;
1084
1085	return 0;
1086	}
1087
1088	static struct megasas_instance_template megasas_instance_template_gen2 = {
1089
1090	.fire_cmd = megasas_fire_cmd_gen2,
1091	.enable_intr = megasas_enable_intr_gen2,
1092	.disable_intr = megasas_disable_intr_gen2,
1093	.clear_intr = megasas_clear_intr_gen2,
1094	.read_fw_status_reg = megasas_read_fw_status_reg_gen2,
1095	.adp_reset = megasas_adp_reset_gen2,
1096	.check_reset = megasas_check_reset_gen2,
1097	.service_isr = megasas_isr,
1098	.tasklet = megasas_complete_cmd_dpc,
1099	.init_adapter = megasas_init_adapter_mfi,
1100	.build_and_issue_cmd = megasas_build_and_issue_cmd,
1101	.issue_dcmd = megasas_issue_dcmd,
1102	};
1103
1104	/*
1105	* This is the end of set of functions & definitions
1106	* specific to gen2 (deviceid : 0x78, 0x79) controllers
1107	*/
1108
1109	/*
1110	* Template added for TB (Fusion)
1111	*/
1112	extern struct megasas_instance_template megasas_instance_template_fusion;
1113
1114	/**
1115	* megasas_issue_polled - Issues a polling command
1116	* @instance: Adapter soft state
1117	* @cmd: Command packet to be issued
1118	*
1119	* For polling, MFI requires the cmd_status to be set to MFI_STAT_INVALID_STATUS before posting.
1120	*/
1121	int
1122	megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
1123	{
1124	struct megasas_header *frame_hdr = &cmd->frame->hdr;
1125
1126	frame_hdr->cmd_status = MFI_STAT_INVALID_STATUS;
1127	frame_hdr->flags |= cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE);
1128
1129	if (atomic_read(v: &instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
1130	dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1131	__func__, __LINE__);
1132	return DCMD_INIT;
1133	}
1134
1135	instance->instancet->issue_dcmd(instance, cmd);
1136
1137	return wait_and_poll(instance, cmd, seconds: instance->requestorId ?
1138	MEGASAS_ROUTINE_WAIT_TIME_VF : MFI_IO_TIMEOUT_SECS);
1139	}
1140
1141	/**
1142	* megasas_issue_blocked_cmd - Synchronous wrapper around regular FW cmds
1143	* @instance: Adapter soft state
1144	* @cmd: Command to be issued
1145	* @timeout: Timeout in seconds
1146	*
1147	* This function waits on an event for the command to be returned from ISR.
1148	* Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
1149	* Used to issue ioctl commands.
1150	*/
1151	int
1152	megasas_issue_blocked_cmd(struct megasas_instance *instance,
1153	struct megasas_cmd *cmd, int timeout)
1154	{
1155	int ret = 0;
1156	cmd->cmd_status_drv = DCMD_INIT;
1157
1158	if (atomic_read(v: &instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
1159	dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1160	__func__, __LINE__);
1161	return DCMD_INIT;
1162	}
1163
1164	instance->instancet->issue_dcmd(instance, cmd);
1165
1166	if (timeout) {
1167	ret = wait_event_timeout(instance->int_cmd_wait_q,
1168	cmd->cmd_status_drv != DCMD_INIT, timeout * HZ);
1169	if (!ret) {
1170	dev_err(&instance->pdev->dev,
1171	"DCMD(opcode: 0x%x) is timed out, func:%s\n",
1172	cmd->frame->dcmd.opcode, __func__);
1173	return DCMD_TIMEOUT;
1174	}
1175	} else
1176	wait_event(instance->int_cmd_wait_q,
1177	cmd->cmd_status_drv != DCMD_INIT);
1178
1179	return cmd->cmd_status_drv;
1180	}
1181
1182	/**
1183	* megasas_issue_blocked_abort_cmd - Aborts previously issued cmd
1184	* @instance: Adapter soft state
1185	* @cmd_to_abort: Previously issued cmd to be aborted
1186	* @timeout: Timeout in seconds
1187	*
1188	* MFI firmware can abort previously issued AEN comamnd (automatic event
1189	* notification). The megasas_issue_blocked_abort_cmd() issues such abort
1190	* cmd and waits for return status.
1191	* Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
1192	*/
1193	static int
1194	megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
1195	struct megasas_cmd *cmd_to_abort, int timeout)
1196	{
1197	struct megasas_cmd *cmd;
1198	struct megasas_abort_frame *abort_fr;
1199	int ret = 0;
1200	u32 opcode;
1201
1202	cmd = megasas_get_cmd(instance);
1203
1204	if (!cmd)
1205	return -1;
1206
1207	abort_fr = &cmd->frame->abort;
1208
1209	/*
1210	* Prepare and issue the abort frame
1211	*/
1212	abort_fr->cmd = MFI_CMD_ABORT;
1213	abort_fr->cmd_status = MFI_STAT_INVALID_STATUS;
1214	abort_fr->flags = cpu_to_le16(0);
1215	abort_fr->abort_context = cpu_to_le32(cmd_to_abort->index);
1216	abort_fr->abort_mfi_phys_addr_lo =
1217	cpu_to_le32(lower_32_bits(cmd_to_abort->frame_phys_addr));
1218	abort_fr->abort_mfi_phys_addr_hi =
1219	cpu_to_le32(upper_32_bits(cmd_to_abort->frame_phys_addr));
1220
1221	cmd->sync_cmd = 1;
1222	cmd->cmd_status_drv = DCMD_INIT;
1223
1224	if (atomic_read(v: &instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
1225	dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1226	__func__, __LINE__);
1227	return DCMD_INIT;
1228	}
1229
1230	instance->instancet->issue_dcmd(instance, cmd);
1231
1232	if (timeout) {
1233	ret = wait_event_timeout(instance->abort_cmd_wait_q,
1234	cmd->cmd_status_drv != DCMD_INIT, timeout * HZ);
1235	if (!ret) {
1236	opcode = cmd_to_abort->frame->dcmd.opcode;
1237	dev_err(&instance->pdev->dev,
1238	"Abort(to be aborted DCMD opcode: 0x%x) is timed out func:%s\n",
1239	opcode, __func__);
1240	return DCMD_TIMEOUT;
1241	}
1242	} else
1243	wait_event(instance->abort_cmd_wait_q,
1244	cmd->cmd_status_drv != DCMD_INIT);
1245
1246	cmd->sync_cmd = 0;
1247
1248	megasas_return_cmd(instance, cmd);
1249	return cmd->cmd_status_drv;
1250	}
1251
1252	/**
1253	* megasas_make_sgl32 - Prepares 32-bit SGL
1254	* @instance: Adapter soft state
1255	* @scp: SCSI command from the mid-layer
1256	* @mfi_sgl: SGL to be filled in
1257	*
1258	* If successful, this function returns the number of SG elements. Otherwise,
1259	* it returnes -1.
1260	*/
1261	static int
1262	megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp,
1263	union megasas_sgl *mfi_sgl)
1264	{
1265	int i;
1266	int sge_count;
1267	struct scatterlist *os_sgl;
1268
1269	sge_count = scsi_dma_map(cmd: scp);
1270	BUG_ON(sge_count < 0);
1271
1272	if (sge_count) {
1273	scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1274	mfi_sgl->sge32[i].length = cpu_to_le32(sg_dma_len(os_sgl));
1275	mfi_sgl->sge32[i].phys_addr = cpu_to_le32(sg_dma_address(os_sgl));
1276	}
1277	}
1278	return sge_count;
1279	}
1280
1281	/**
1282	* megasas_make_sgl64 - Prepares 64-bit SGL
1283	* @instance: Adapter soft state
1284	* @scp: SCSI command from the mid-layer
1285	* @mfi_sgl: SGL to be filled in
1286	*
1287	* If successful, this function returns the number of SG elements. Otherwise,
1288	* it returnes -1.
1289	*/
1290	static int
1291	megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
1292	union megasas_sgl *mfi_sgl)
1293	{
1294	int i;
1295	int sge_count;
1296	struct scatterlist *os_sgl;
1297
1298	sge_count = scsi_dma_map(cmd: scp);
1299	BUG_ON(sge_count < 0);
1300
1301	if (sge_count) {
1302	scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1303	mfi_sgl->sge64[i].length = cpu_to_le32(sg_dma_len(os_sgl));
1304	mfi_sgl->sge64[i].phys_addr = cpu_to_le64(sg_dma_address(os_sgl));
1305	}
1306	}
1307	return sge_count;
1308	}
1309
1310	/**
1311	* megasas_make_sgl_skinny - Prepares IEEE SGL
1312	* @instance: Adapter soft state
1313	* @scp: SCSI command from the mid-layer
1314	* @mfi_sgl: SGL to be filled in
1315	*
1316	* If successful, this function returns the number of SG elements. Otherwise,
1317	* it returnes -1.
1318	*/
1319	static int
1320	megasas_make_sgl_skinny(struct megasas_instance *instance,
1321	struct scsi_cmnd *scp, union megasas_sgl *mfi_sgl)
1322	{
1323	int i;
1324	int sge_count;
1325	struct scatterlist *os_sgl;
1326
1327	sge_count = scsi_dma_map(cmd: scp);
1328
1329	if (sge_count) {
1330	scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1331	mfi_sgl->sge_skinny[i].length =
1332	cpu_to_le32(sg_dma_len(os_sgl));
1333	mfi_sgl->sge_skinny[i].phys_addr =
1334	cpu_to_le64(sg_dma_address(os_sgl));
1335	mfi_sgl->sge_skinny[i].flag = cpu_to_le32(0);
1336	}
1337	}
1338	return sge_count;
1339	}
1340
1341	/**
1342	* megasas_get_frame_count - Computes the number of frames
1343	* @frame_type : type of frame- io or pthru frame
1344	* @sge_count : number of sg elements
1345	*
1346	* Returns the number of frames required for numnber of sge's (sge_count)
1347	*/
1348
1349	static u32 megasas_get_frame_count(struct megasas_instance *instance,
1350	u8 sge_count, u8 frame_type)
1351	{
1352	int num_cnt;
1353	int sge_bytes;
1354	u32 sge_sz;
1355	u32 frame_count = 0;
1356
1357	sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
1358	sizeof(struct megasas_sge32);
1359
1360	if (instance->flag_ieee) {
1361	sge_sz = sizeof(struct megasas_sge_skinny);
1362	}
1363
1364	/*
1365	* Main frame can contain 2 SGEs for 64-bit SGLs and
1366	* 3 SGEs for 32-bit SGLs for ldio &
1367	* 1 SGEs for 64-bit SGLs and
1368	* 2 SGEs for 32-bit SGLs for pthru frame
1369	*/
1370	if (unlikely(frame_type == PTHRU_FRAME)) {
1371	if (instance->flag_ieee == 1) {
1372	num_cnt = sge_count - 1;
1373	} else if (IS_DMA64)
1374	num_cnt = sge_count - 1;
1375	else
1376	num_cnt = sge_count - 2;
1377	} else {
1378	if (instance->flag_ieee == 1) {
1379	num_cnt = sge_count - 1;
1380	} else if (IS_DMA64)
1381	num_cnt = sge_count - 2;
1382	else
1383	num_cnt = sge_count - 3;
1384	}
1385
1386	if (num_cnt > 0) {
1387	sge_bytes = sge_sz * num_cnt;
1388
1389	frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) +
1390	((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) ;
1391	}
1392	/* Main frame */
1393	frame_count += 1;
1394
1395	if (frame_count > 7)
1396	frame_count = 8;
1397	return frame_count;
1398	}
1399
1400	/**
1401	* megasas_build_dcdb - Prepares a direct cdb (DCDB) command
1402	* @instance: Adapter soft state
1403	* @scp: SCSI command
1404	* @cmd: Command to be prepared in
1405	*
1406	* This function prepares CDB commands. These are typcially pass-through
1407	* commands to the devices.
1408	*/
1409	static int
1410	megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
1411	struct megasas_cmd *cmd)
1412	{
1413	u32 is_logical;
1414	u32 device_id;
1415	u16 flags = 0;
1416	struct megasas_pthru_frame *pthru;
1417
1418	is_logical = MEGASAS_IS_LOGICAL(scp->device);
1419	device_id = MEGASAS_DEV_INDEX(scp);
1420	pthru = (struct megasas_pthru_frame *)cmd->frame;
1421
1422	if (scp->sc_data_direction == DMA_TO_DEVICE)
1423	flags = MFI_FRAME_DIR_WRITE;
1424	else if (scp->sc_data_direction == DMA_FROM_DEVICE)
1425	flags = MFI_FRAME_DIR_READ;
1426	else if (scp->sc_data_direction == DMA_NONE)
1427	flags = MFI_FRAME_DIR_NONE;
1428
1429	if (instance->flag_ieee == 1) {
1430	flags |= MFI_FRAME_IEEE;
1431	}
1432
1433	/*
1434	* Prepare the DCDB frame
1435	*/
1436	pthru->cmd = (is_logical) ? MFI_CMD_LD_SCSI_IO : MFI_CMD_PD_SCSI_IO;
1437	pthru->cmd_status = 0x0;
1438	pthru->scsi_status = 0x0;
1439	pthru->target_id = device_id;
1440	pthru->lun = scp->device->lun;
1441	pthru->cdb_len = scp->cmd_len;
1442	pthru->timeout = 0;
1443	pthru->pad_0 = 0;
1444	pthru->flags = cpu_to_le16(flags);
1445	pthru->data_xfer_len = cpu_to_le32(scsi_bufflen(scp));
1446
1447	memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);
1448
1449	/*
1450	* If the command is for the tape device, set the
1451	* pthru timeout to the os layer timeout value.
1452	*/
1453	if (scp->device->type == TYPE_TAPE) {
1454	if (scsi_cmd_to_rq(scmd: scp)->timeout / HZ > 0xFFFF)
1455	pthru->timeout = cpu_to_le16(0xFFFF);
1456	else
1457	pthru->timeout = cpu_to_le16(scsi_cmd_to_rq(scp)->timeout / HZ);
1458	}
1459
1460	/*
1461	* Construct SGL
1462	*/
1463	if (instance->flag_ieee == 1) {
1464	pthru->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1465	pthru->sge_count = megasas_make_sgl_skinny(instance, scp,
1466	mfi_sgl: &pthru->sgl);
1467	} else if (IS_DMA64) {
1468	pthru->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1469	pthru->sge_count = megasas_make_sgl64(instance, scp,
1470	mfi_sgl: &pthru->sgl);
1471	} else
1472	pthru->sge_count = megasas_make_sgl32(instance, scp,
1473	mfi_sgl: &pthru->sgl);
1474
1475	if (pthru->sge_count > instance->max_num_sge) {
1476	dev_err(&instance->pdev->dev, "DCDB too many SGE NUM=%x\n",
1477	pthru->sge_count);
1478	return 0;
1479	}
1480
1481	/*
1482	* Sense info specific
1483	*/
1484	pthru->sense_len = SCSI_SENSE_BUFFERSIZE;
1485	pthru->sense_buf_phys_addr_hi =
1486	cpu_to_le32(upper_32_bits(cmd->sense_phys_addr));
1487	pthru->sense_buf_phys_addr_lo =
1488	cpu_to_le32(lower_32_bits(cmd->sense_phys_addr));
1489
1490	/*
1491	* Compute the total number of frames this command consumes. FW uses
1492	* this number to pull sufficient number of frames from host memory.
1493	*/
1494	cmd->frame_count = megasas_get_frame_count(instance, sge_count: pthru->sge_count,
1495	PTHRU_FRAME);
1496
1497	return cmd->frame_count;
1498	}
1499
1500	/**
1501	* megasas_build_ldio - Prepares IOs to logical devices
1502	* @instance: Adapter soft state
1503	* @scp: SCSI command
1504	* @cmd: Command to be prepared
1505	*
1506	* Frames (and accompanying SGLs) for regular SCSI IOs use this function.
1507	*/
1508	static int
1509	megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
1510	struct megasas_cmd *cmd)
1511	{
1512	u32 device_id;
1513	u8 sc = scp->cmnd[0];
1514	u16 flags = 0;
1515	struct megasas_io_frame *ldio;
1516
1517	device_id = MEGASAS_DEV_INDEX(scp);
1518	ldio = (struct megasas_io_frame *)cmd->frame;
1519
1520	if (scp->sc_data_direction == DMA_TO_DEVICE)
1521	flags = MFI_FRAME_DIR_WRITE;
1522	else if (scp->sc_data_direction == DMA_FROM_DEVICE)
1523	flags = MFI_FRAME_DIR_READ;
1524
1525	if (instance->flag_ieee == 1) {
1526	flags |= MFI_FRAME_IEEE;
1527	}
1528
1529	/*
1530	* Prepare the Logical IO frame: 2nd bit is zero for all read cmds
1531	*/
1532	ldio->cmd = (sc & 0x02) ? MFI_CMD_LD_WRITE : MFI_CMD_LD_READ;
1533	ldio->cmd_status = 0x0;
1534	ldio->scsi_status = 0x0;
1535	ldio->target_id = device_id;
1536	ldio->timeout = 0;
1537	ldio->reserved_0 = 0;
1538	ldio->pad_0 = 0;
1539	ldio->flags = cpu_to_le16(flags);
1540	ldio->start_lba_hi = 0;
1541	ldio->access_byte = (scp->cmd_len != 6) ? scp->cmnd[1] : 0;
1542
1543	/*
1544	* 6-byte READ(0x08) or WRITE(0x0A) cdb
1545	*/
1546	if (scp->cmd_len == 6) {
1547	ldio->lba_count = cpu_to_le32((u32) scp->cmnd[4]);
1548	ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[1] << 16) |
1549	((u32) scp->cmnd[2] << 8) |
1550	(u32) scp->cmnd[3]);
1551
1552	ldio->start_lba_lo &= cpu_to_le32(0x1FFFFF);
1553	}
1554
1555	/*
1556	* 10-byte READ(0x28) or WRITE(0x2A) cdb
1557	*/
1558	else if (scp->cmd_len == 10) {
1559	ldio->lba_count = cpu_to_le32((u32) scp->cmnd[8] |
1560	((u32) scp->cmnd[7] << 8));
1561	ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1562	((u32) scp->cmnd[3] << 16) |
1563	((u32) scp->cmnd[4] << 8) |
1564	(u32) scp->cmnd[5]);
1565	}
1566
1567	/*
1568	* 12-byte READ(0xA8) or WRITE(0xAA) cdb
1569	*/
1570	else if (scp->cmd_len == 12) {
1571	ldio->lba_count = cpu_to_le32(((u32) scp->cmnd[6] << 24) |
1572	((u32) scp->cmnd[7] << 16) |
1573	((u32) scp->cmnd[8] << 8) |
1574	(u32) scp->cmnd[9]);
1575
1576	ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1577	((u32) scp->cmnd[3] << 16) |
1578	((u32) scp->cmnd[4] << 8) |
1579	(u32) scp->cmnd[5]);
1580	}
1581
1582	/*
1583	* 16-byte READ(0x88) or WRITE(0x8A) cdb
1584	*/
1585	else if (scp->cmd_len == 16) {
1586	ldio->lba_count = cpu_to_le32(((u32) scp->cmnd[10] << 24) |
1587	((u32) scp->cmnd[11] << 16) |
1588	((u32) scp->cmnd[12] << 8) |
1589	(u32) scp->cmnd[13]);
1590
1591	ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[6] << 24) |
1592	((u32) scp->cmnd[7] << 16) |
1593	((u32) scp->cmnd[8] << 8) |
1594	(u32) scp->cmnd[9]);
1595
1596	ldio->start_lba_hi = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1597	((u32) scp->cmnd[3] << 16) |
1598	((u32) scp->cmnd[4] << 8) |
1599	(u32) scp->cmnd[5]);
1600
1601	}
1602
1603	/*
1604	* Construct SGL
1605	*/
1606	if (instance->flag_ieee) {
1607	ldio->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1608	ldio->sge_count = megasas_make_sgl_skinny(instance, scp,
1609	mfi_sgl: &ldio->sgl);
1610	} else if (IS_DMA64) {
1611	ldio->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1612	ldio->sge_count = megasas_make_sgl64(instance, scp, mfi_sgl: &ldio->sgl);
1613	} else
1614	ldio->sge_count = megasas_make_sgl32(instance, scp, mfi_sgl: &ldio->sgl);
1615
1616	if (ldio->sge_count > instance->max_num_sge) {
1617	dev_err(&instance->pdev->dev, "build_ld_io: sge_count = %x\n",
1618	ldio->sge_count);
1619	return 0;
1620	}
1621
1622	/*
1623	* Sense info specific
1624	*/
1625	ldio->sense_len = SCSI_SENSE_BUFFERSIZE;
1626	ldio->sense_buf_phys_addr_hi = 0;
1627	ldio->sense_buf_phys_addr_lo = cpu_to_le32(cmd->sense_phys_addr);
1628
1629	/*
1630	* Compute the total number of frames this command consumes. FW uses
1631	* this number to pull sufficient number of frames from host memory.
1632	*/
1633	cmd->frame_count = megasas_get_frame_count(instance,
1634	sge_count: ldio->sge_count, IO_FRAME);
1635
1636	return cmd->frame_count;
1637	}
1638
1639	/**
1640	* megasas_cmd_type - Checks if the cmd is for logical drive/sysPD
1641	* and whether it's RW or non RW
1642	* @cmd: SCSI command
1643	*
1644	*/
1645	inline int megasas_cmd_type(struct scsi_cmnd *cmd)
1646	{
1647	int ret;
1648
1649	switch (cmd->cmnd[0]) {
1650	case READ_10:
1651	case WRITE_10:
1652	case READ_12:
1653	case WRITE_12:
1654	case READ_6:
1655	case WRITE_6:
1656	case READ_16:
1657	case WRITE_16:
1658	ret = (MEGASAS_IS_LOGICAL(cmd->device)) ?
1659	READ_WRITE_LDIO : READ_WRITE_SYSPDIO;
1660	break;
1661	default:
1662	ret = (MEGASAS_IS_LOGICAL(cmd->device)) ?
1663	NON_READ_WRITE_LDIO : NON_READ_WRITE_SYSPDIO;
1664	}
1665	return ret;
1666	}
1667
1668	/**
1669	* megasas_dump_pending_frames - Dumps the frame address of all pending cmds
1670	* in FW
1671	* @instance: Adapter soft state
1672	*/
1673	static inline void
1674	megasas_dump_pending_frames(struct megasas_instance *instance)
1675	{
1676	struct megasas_cmd *cmd;
1677	int i,n;
1678	union megasas_sgl *mfi_sgl;
1679	struct megasas_io_frame *ldio;
1680	struct megasas_pthru_frame *pthru;
1681	u32 sgcount;
1682	u16 max_cmd = instance->max_fw_cmds;
1683
1684	dev_err(&instance->pdev->dev, "[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance->host->host_no);
1685	dev_err(&instance->pdev->dev, "[%d]: Total OS Pending cmds : %d\n",instance->host->host_no,atomic_read(&instance->fw_outstanding));
1686	if (IS_DMA64)
1687	dev_err(&instance->pdev->dev, "[%d]: 64 bit SGLs were sent to FW\n",instance->host->host_no);
1688	else
1689	dev_err(&instance->pdev->dev, "[%d]: 32 bit SGLs were sent to FW\n",instance->host->host_no);
1690
1691	dev_err(&instance->pdev->dev, "[%d]: Pending OS cmds in FW : \n",instance->host->host_no);
1692	for (i = 0; i < max_cmd; i++) {
1693	cmd = instance->cmd_list[i];
1694	if (!cmd->scmd)
1695	continue;
1696	dev_err(&instance->pdev->dev, "[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);
1697	if (megasas_cmd_type(cmd: cmd->scmd) == READ_WRITE_LDIO) {
1698	ldio = (struct megasas_io_frame *)cmd->frame;
1699	mfi_sgl = &ldio->sgl;
1700	sgcount = ldio->sge_count;
1701	dev_err(&instance->pdev->dev, "[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x,"
1702	" lba lo : 0x%x, lba_hi : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",
1703	instance->host->host_no, cmd->frame_count, ldio->cmd, ldio->target_id,
1704	le32_to_cpu(ldio->start_lba_lo), le32_to_cpu(ldio->start_lba_hi),
1705	le32_to_cpu(ldio->sense_buf_phys_addr_lo), sgcount);
1706	} else {
1707	pthru = (struct megasas_pthru_frame *) cmd->frame;
1708	mfi_sgl = &pthru->sgl;
1709	sgcount = pthru->sge_count;
1710	dev_err(&instance->pdev->dev, "[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x, "
1711	"lun : 0x%x, cdb_len : 0x%x, data xfer len : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",
1712	instance->host->host_no, cmd->frame_count, pthru->cmd, pthru->target_id,
1713	pthru->lun, pthru->cdb_len, le32_to_cpu(pthru->data_xfer_len),
1714	le32_to_cpu(pthru->sense_buf_phys_addr_lo), sgcount);
1715	}
1716	if (megasas_dbg_lvl & MEGASAS_DBG_LVL) {
1717	for (n = 0; n < sgcount; n++) {
1718	if (IS_DMA64)
1719	dev_err(&instance->pdev->dev, "sgl len : 0x%x, sgl addr : 0x%llx\n",
1720	le32_to_cpu(mfi_sgl->sge64[n].length),
1721	le64_to_cpu(mfi_sgl->sge64[n].phys_addr));
1722	else
1723	dev_err(&instance->pdev->dev, "sgl len : 0x%x, sgl addr : 0x%x\n",
1724	le32_to_cpu(mfi_sgl->sge32[n].length),
1725	le32_to_cpu(mfi_sgl->sge32[n].phys_addr));
1726	}
1727	}
1728	} /*for max_cmd*/
1729	dev_err(&instance->pdev->dev, "[%d]: Pending Internal cmds in FW : \n",instance->host->host_no);
1730	for (i = 0; i < max_cmd; i++) {
1731
1732	cmd = instance->cmd_list[i];
1733
1734	if (cmd->sync_cmd == 1)
1735	dev_err(&instance->pdev->dev, "0x%08lx : ", (unsigned long)cmd->frame_phys_addr);
1736	}
1737	dev_err(&instance->pdev->dev, "[%d]: Dumping Done\n\n",instance->host->host_no);
1738	}
1739
1740	u32
1741	megasas_build_and_issue_cmd(struct megasas_instance *instance,
1742	struct scsi_cmnd *scmd)
1743	{
1744	struct megasas_cmd *cmd;
1745	u32 frame_count;
1746
1747	cmd = megasas_get_cmd(instance);
1748	if (!cmd)
1749	return SCSI_MLQUEUE_HOST_BUSY;
1750
1751	/*
1752	* Logical drive command
1753	*/
1754	if (megasas_cmd_type(cmd: scmd) == READ_WRITE_LDIO)
1755	frame_count = megasas_build_ldio(instance, scp: scmd, cmd);
1756	else
1757	frame_count = megasas_build_dcdb(instance, scp: scmd, cmd);
1758
1759	if (!frame_count)
1760	goto out_return_cmd;
1761
1762	cmd->scmd = scmd;
1763	megasas_priv(cmd: scmd)->cmd_priv = cmd;
1764
1765	/*
1766	* Issue the command to the FW
1767	*/
1768	atomic_inc(v: &instance->fw_outstanding);
1769
1770	instance->instancet->fire_cmd(instance, cmd->frame_phys_addr,
1771	cmd->frame_count-1, instance->reg_set);
1772
1773	return 0;
1774	out_return_cmd:
1775	megasas_return_cmd(instance, cmd);
1776	return SCSI_MLQUEUE_HOST_BUSY;
1777	}
1778
1779
1780	/**
1781	* megasas_queue_command - Queue entry point
1782	* @shost: adapter SCSI host
1783	* @scmd: SCSI command to be queued
1784	*/
1785	static int
1786	megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
1787	{
1788	struct megasas_instance *instance;
1789	struct MR_PRIV_DEVICE *mr_device_priv_data;
1790	u32 ld_tgt_id;
1791
1792	instance = (struct megasas_instance *)
1793	scmd->device->host->hostdata;
1794
1795	if (instance->unload == 1) {
1796	scmd->result = DID_NO_CONNECT << 16;
1797	scsi_done(cmd: scmd);
1798	return 0;
1799	}
1800
1801	if (instance->issuepend_done == 0)
1802	return SCSI_MLQUEUE_HOST_BUSY;
1803
1804
1805	/* Check for an mpio path and adjust behavior */
1806	if (atomic_read(v: &instance->adprecovery) == MEGASAS_ADPRESET_SM_INFAULT) {
1807	if (megasas_check_mpio_paths(instance, scmd) ==
1808	(DID_REQUEUE << 16)) {
1809	return SCSI_MLQUEUE_HOST_BUSY;
1810	} else {
1811	scmd->result = DID_NO_CONNECT << 16;
1812	scsi_done(cmd: scmd);
1813	return 0;
1814	}
1815	}
1816
1817	mr_device_priv_data = scmd->device->hostdata;
1818	if (!mr_device_priv_data ||
1819	(atomic_read(v: &instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)) {
1820	scmd->result = DID_NO_CONNECT << 16;
1821	scsi_done(cmd: scmd);
1822	return 0;
1823	}
1824
1825	if (MEGASAS_IS_LOGICAL(scmd->device)) {
1826	ld_tgt_id = MEGASAS_TARGET_ID(scmd->device);
1827	if (instance->ld_tgtid_status[ld_tgt_id] == LD_TARGET_ID_DELETED) {
1828	scmd->result = DID_NO_CONNECT << 16;
1829	scsi_done(cmd: scmd);
1830	return 0;
1831	}
1832	}
1833
1834	if (atomic_read(v: &instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
1835	return SCSI_MLQUEUE_HOST_BUSY;
1836
1837	if (mr_device_priv_data->tm_busy)
1838	return SCSI_MLQUEUE_DEVICE_BUSY;
1839
1840
1841	scmd->result = 0;
1842
1843	if (MEGASAS_IS_LOGICAL(scmd->device) &&
1844	(scmd->device->id >= instance->fw_supported_vd_count ||
1845	scmd->device->lun)) {
1846	scmd->result = DID_BAD_TARGET << 16;
1847	goto out_done;
1848	}
1849
1850	if ((scmd->cmnd[0] == SYNCHRONIZE_CACHE) &&
1851	MEGASAS_IS_LOGICAL(scmd->device) &&
1852	(!instance->fw_sync_cache_support)) {
1853	scmd->result = DID_OK << 16;
1854	goto out_done;
1855	}
1856
1857	return instance->instancet->build_and_issue_cmd(instance, scmd);
1858
1859	out_done:
1860	scsi_done(cmd: scmd);
1861	return 0;
1862	}
1863
1864	static struct megasas_instance *megasas_lookup_instance(u16 host_no)
1865	{
1866	int i;
1867
1868	for (i = 0; i < megasas_mgmt_info.max_index; i++) {
1869
1870	if ((megasas_mgmt_info.instance[i]) &&
1871	(megasas_mgmt_info.instance[i]->host->host_no == host_no))
1872	return megasas_mgmt_info.instance[i];
1873	}
1874
1875	return NULL;
1876	}
1877
1878	/*
1879	* megasas_set_dynamic_target_properties -
1880	* Device property set by driver may not be static and it is required to be
1881	* updated after OCR
1882	*
1883	* set tm_capable.
1884	* set dma alignment (only for eedp protection enable vd).
1885	*
1886	* @sdev: OS provided scsi device
1887	*
1888	* Returns void
1889	*/
1890	void megasas_set_dynamic_target_properties(struct scsi_device *sdev,
1891	bool is_target_prop)
1892	{
1893	u16 pd_index = 0, ld;
1894	u32 device_id;
1895	struct megasas_instance *instance;
1896	struct fusion_context *fusion;
1897	struct MR_PRIV_DEVICE *mr_device_priv_data;
1898	struct MR_PD_CFG_SEQ_NUM_SYNC *pd_sync;
1899	struct MR_LD_RAID *raid;
1900	struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
1901
1902	instance = megasas_lookup_instance(host_no: sdev->host->host_no);
1903	fusion = instance->ctrl_context;
1904	mr_device_priv_data = sdev->hostdata;
1905
1906	if (!fusion || !mr_device_priv_data)
1907	return;
1908
1909	if (MEGASAS_IS_LOGICAL(sdev)) {
1910	device_id = ((sdev->channel % 2) * MEGASAS_MAX_DEV_PER_CHANNEL)
1911	+ sdev->id;
1912	local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
1913	ld = MR_TargetIdToLdGet(ldTgtId: device_id, map: local_map_ptr);
1914	if (ld >= instance->fw_supported_vd_count)
1915	return;
1916	raid = MR_LdRaidGet(ld, map: local_map_ptr);
1917
1918	if (raid->capability.ldPiMode == MR_PROT_INFO_TYPE_CONTROLLER)
1919	blk_queue_update_dma_alignment(sdev->request_queue, 0x7);
1920
1921	mr_device_priv_data->is_tm_capable =
1922	raid->capability.tmCapable;
1923
1924	if (!raid->flags.isEPD)
1925	sdev->no_write_same = 1;
1926
1927	} else if (instance->use_seqnum_jbod_fp) {
1928	pd_index = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
1929	sdev->id;
1930	pd_sync = (void *)fusion->pd_seq_sync
1931	[(instance->pd_seq_map_id - 1) & 1];
1932	mr_device_priv_data->is_tm_capable =
1933	pd_sync->seq[pd_index].capability.tmCapable;
1934	}
1935
1936	if (is_target_prop && instance->tgt_prop->reset_tmo) {
1937	/*
1938	* If FW provides a target reset timeout value, driver will use
1939	* it. If not set, fallback to default values.
1940	*/
1941	mr_device_priv_data->target_reset_tmo =
1942	min_t(u8, instance->max_reset_tmo,
1943	instance->tgt_prop->reset_tmo);
1944	mr_device_priv_data->task_abort_tmo = instance->task_abort_tmo;
1945	} else {
1946	mr_device_priv_data->target_reset_tmo =
1947	MEGASAS_DEFAULT_TM_TIMEOUT;
1948	mr_device_priv_data->task_abort_tmo =
1949	MEGASAS_DEFAULT_TM_TIMEOUT;
1950	}
1951	}
1952
1953	/*
1954	* megasas_set_nvme_device_properties -
1955	* set nomerges=2
1956	* set virtual page boundary = 4K (current mr_nvme_pg_size is 4K).
1957	* set maximum io transfer = MDTS of NVME device provided by MR firmware.
1958	*
1959	* MR firmware provides value in KB. Caller of this function converts
1960	* kb into bytes.
1961	*
1962	* e.a MDTS=5 means 2^5 * nvme page size. (In case of 4K page size,
1963	* MR firmware provides value 128 as (32 * 4K) = 128K.
1964	*
1965	* @sdev: scsi device
1966	* @max_io_size: maximum io transfer size
1967	*
1968	*/
1969	static inline void
1970	megasas_set_nvme_device_properties(struct scsi_device *sdev, u32 max_io_size)
1971	{
1972	struct megasas_instance *instance;
1973	u32 mr_nvme_pg_size;
1974
1975	instance = (struct megasas_instance *)sdev->host->hostdata;
1976	mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
1977	MR_DEFAULT_NVME_PAGE_SIZE);
1978
1979	blk_queue_max_hw_sectors(sdev->request_queue, (max_io_size / 512));
1980
1981	blk_queue_flag_set(QUEUE_FLAG_NOMERGES, q: sdev->request_queue);
1982	blk_queue_virt_boundary(sdev->request_queue, mr_nvme_pg_size - 1);
1983	}
1984
1985	/*
1986	* megasas_set_fw_assisted_qd -
1987	* set device queue depth to can_queue
1988	* set device queue depth to fw assisted qd
1989	*
1990	* @sdev: scsi device
1991	* @is_target_prop true, if fw provided target properties.
1992	*/
1993	static void megasas_set_fw_assisted_qd(struct scsi_device *sdev,
1994	bool is_target_prop)
1995	{
1996	u8 interface_type;
1997	u32 device_qd = MEGASAS_DEFAULT_CMD_PER_LUN;
1998	u32 tgt_device_qd;
1999	struct megasas_instance *instance;
2000	struct MR_PRIV_DEVICE *mr_device_priv_data;
2001
2002	instance = megasas_lookup_instance(host_no: sdev->host->host_no);
2003	mr_device_priv_data = sdev->hostdata;
2004	interface_type = mr_device_priv_data->interface_type;
2005
2006	switch (interface_type) {
2007	case SAS_PD:
2008	device_qd = MEGASAS_SAS_QD;
2009	break;
2010	case SATA_PD:
2011	device_qd = MEGASAS_SATA_QD;
2012	break;
2013	case NVME_PD:
2014	device_qd = MEGASAS_NVME_QD;
2015	break;
2016	}
2017
2018	if (is_target_prop) {
2019	tgt_device_qd = le32_to_cpu(instance->tgt_prop->device_qdepth);
2020	if (tgt_device_qd)
2021	device_qd = min(instance->host->can_queue,
2022	(int)tgt_device_qd);
2023	}
2024
2025	if (instance->enable_sdev_max_qd && interface_type != UNKNOWN_DRIVE)
2026	device_qd = instance->host->can_queue;
2027
2028	scsi_change_queue_depth(sdev, device_qd);
2029	}
2030
2031	/*
2032	* megasas_set_static_target_properties -
2033	* Device property set by driver are static and it is not required to be
2034	* updated after OCR.
2035	*
2036	* set io timeout
2037	* set device queue depth
2038	* set nvme device properties. see - megasas_set_nvme_device_properties
2039	*
2040	* @sdev: scsi device
2041	* @is_target_prop true, if fw provided target properties.
2042	*/
2043	static void megasas_set_static_target_properties(struct scsi_device *sdev,
2044	bool is_target_prop)
2045	{
2046	u32 max_io_size_kb = MR_DEFAULT_NVME_MDTS_KB;
2047	struct megasas_instance *instance;
2048
2049	instance = megasas_lookup_instance(host_no: sdev->host->host_no);
2050
2051	/*
2052	* The RAID firmware may require extended timeouts.
2053	*/
2054	blk_queue_rq_timeout(sdev->request_queue, scmd_timeout * HZ);
2055
2056	/* max_io_size_kb will be set to non zero for
2057	* nvme based vd and syspd.
2058	*/
2059	if (is_target_prop)
2060	max_io_size_kb = le32_to_cpu(instance->tgt_prop->max_io_size_kb);
2061
2062	if (instance->nvme_page_size && max_io_size_kb)
2063	megasas_set_nvme_device_properties(sdev, max_io_size: (max_io_size_kb << 10));
2064
2065	megasas_set_fw_assisted_qd(sdev, is_target_prop);
2066	}
2067
2068
2069	static int megasas_slave_configure(struct scsi_device *sdev)
2070	{
2071	u16 pd_index = 0;
2072	struct megasas_instance *instance;
2073	int ret_target_prop = DCMD_FAILED;
2074	bool is_target_prop = false;
2075
2076	instance = megasas_lookup_instance(host_no: sdev->host->host_no);
2077	if (instance->pd_list_not_supported) {
2078	if (!MEGASAS_IS_LOGICAL(sdev) && sdev->type == TYPE_DISK) {
2079	pd_index = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
2080	sdev->id;
2081	if (instance->pd_list[pd_index].driveState !=
2082	MR_PD_STATE_SYSTEM)
2083	return -ENXIO;
2084	}
2085	}
2086
2087	mutex_lock(&instance->reset_mutex);
2088	/* Send DCMD to Firmware and cache the information */
2089	if ((instance->pd_info) && !MEGASAS_IS_LOGICAL(sdev))
2090	megasas_get_pd_info(instance, sdev);
2091
2092	/* Some ventura firmware may not have instance->nvme_page_size set.
2093	* Do not send MR_DCMD_DRV_GET_TARGET_PROP
2094	*/
2095	if ((instance->tgt_prop) && (instance->nvme_page_size))
2096	ret_target_prop = megasas_get_target_prop(instance, sdev);
2097
2098	is_target_prop = (ret_target_prop == DCMD_SUCCESS) ? true : false;
2099	megasas_set_static_target_properties(sdev, is_target_prop);
2100
2101	/* This sdev property may change post OCR */
2102	megasas_set_dynamic_target_properties(sdev, is_target_prop);
2103
2104	mutex_unlock(lock: &instance->reset_mutex);
2105
2106	return 0;
2107	}
2108
2109	static int megasas_slave_alloc(struct scsi_device *sdev)
2110	{
2111	u16 pd_index = 0, ld_tgt_id;
2112	struct megasas_instance *instance ;
2113	struct MR_PRIV_DEVICE *mr_device_priv_data;
2114
2115	instance = megasas_lookup_instance(host_no: sdev->host->host_no);
2116	if (!MEGASAS_IS_LOGICAL(sdev)) {
2117	/*
2118	* Open the OS scan to the SYSTEM PD
2119	*/
2120	pd_index =
2121	(sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
2122	sdev->id;
2123	if ((instance->pd_list_not_supported ||
2124	instance->pd_list[pd_index].driveState ==
2125	MR_PD_STATE_SYSTEM)) {
2126	goto scan_target;
2127	}
2128	return -ENXIO;
2129	} else if (!MEGASAS_IS_LUN_VALID(sdev)) {
2130	sdev_printk(KERN_INFO, sdev, "%s: invalid LUN\n", __func__);
2131	return -ENXIO;
2132	}
2133
2134	scan_target:
2135	mr_device_priv_data = kzalloc(size: sizeof(*mr_device_priv_data),
2136	GFP_KERNEL);
2137	if (!mr_device_priv_data)
2138	return -ENOMEM;
2139
2140	if (MEGASAS_IS_LOGICAL(sdev)) {
2141	ld_tgt_id = MEGASAS_TARGET_ID(sdev);
2142	instance->ld_tgtid_status[ld_tgt_id] = LD_TARGET_ID_ACTIVE;
2143	if (megasas_dbg_lvl & LD_PD_DEBUG)
2144	sdev_printk(KERN_INFO, sdev, "LD target ID %d created.\n", ld_tgt_id);
2145	}
2146
2147	sdev->hostdata = mr_device_priv_data;
2148
2149	atomic_set(v: &mr_device_priv_data->r1_ldio_hint,
2150	i: instance->r1_ldio_hint_default);
2151	return 0;
2152	}
2153
2154	static void megasas_slave_destroy(struct scsi_device *sdev)
2155	{
2156	u16 ld_tgt_id;
2157	struct megasas_instance *instance;
2158
2159	instance = megasas_lookup_instance(host_no: sdev->host->host_no);
2160
2161	if (MEGASAS_IS_LOGICAL(sdev)) {
2162	if (!MEGASAS_IS_LUN_VALID(sdev)) {
2163	sdev_printk(KERN_INFO, sdev, "%s: invalid LUN\n", __func__);
2164	return;
2165	}
2166	ld_tgt_id = MEGASAS_TARGET_ID(sdev);
2167	instance->ld_tgtid_status[ld_tgt_id] = LD_TARGET_ID_DELETED;
2168	if (megasas_dbg_lvl & LD_PD_DEBUG)
2169	sdev_printk(KERN_INFO, sdev,
2170	"LD target ID %d removed from OS stack\n", ld_tgt_id);
2171	}
2172
2173	kfree(objp: sdev->hostdata);
2174	sdev->hostdata = NULL;
2175	}
2176
2177	/*
2178	* megasas_complete_outstanding_ioctls - Complete outstanding ioctls after a
2179	* kill adapter
2180	* @instance: Adapter soft state
2181	*
2182	*/
2183	static void megasas_complete_outstanding_ioctls(struct megasas_instance *instance)
2184	{
2185	int i;
2186	struct megasas_cmd *cmd_mfi;
2187	struct megasas_cmd_fusion *cmd_fusion;
2188	struct fusion_context *fusion = instance->ctrl_context;
2189
2190	/* Find all outstanding ioctls */
2191	if (fusion) {
2192	for (i = 0; i < instance->max_fw_cmds; i++) {
2193	cmd_fusion = fusion->cmd_list[i];
2194	if (cmd_fusion->sync_cmd_idx != (u32)ULONG_MAX) {
2195	cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
2196	if (cmd_mfi->sync_cmd &&
2197	(cmd_mfi->frame->hdr.cmd != MFI_CMD_ABORT)) {
2198	cmd_mfi->frame->hdr.cmd_status =
2199	MFI_STAT_WRONG_STATE;
2200	megasas_complete_cmd(instance,
2201	cmd: cmd_mfi, alt_status: DID_OK);
2202	}
2203	}
2204	}
2205	} else {
2206	for (i = 0; i < instance->max_fw_cmds; i++) {
2207	cmd_mfi = instance->cmd_list[i];
2208	if (cmd_mfi->sync_cmd && cmd_mfi->frame->hdr.cmd !=
2209	MFI_CMD_ABORT)
2210	megasas_complete_cmd(instance, cmd: cmd_mfi, alt_status: DID_OK);
2211	}
2212	}
2213	}
2214
2215
2216	void megaraid_sas_kill_hba(struct megasas_instance *instance)
2217	{
2218	if (atomic_read(v: &instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2219	dev_warn(&instance->pdev->dev,
2220	"Adapter already dead, skipping kill HBA\n");
2221	return;
2222	}
2223
2224	/* Set critical error to block I/O & ioctls in case caller didn't */
2225	atomic_set(v: &instance->adprecovery, i: MEGASAS_HW_CRITICAL_ERROR);
2226	/* Wait 1 second to ensure IO or ioctls in build have posted */
2227	msleep(msecs: 1000);
2228	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2229	(instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
2230	(instance->adapter_type != MFI_SERIES)) {
2231	if (!instance->requestorId) {
2232	writel(MFI_STOP_ADP, addr: &instance->reg_set->doorbell);
2233	/* Flush */
2234	readl(addr: &instance->reg_set->doorbell);
2235	}
2236	if (instance->requestorId && instance->peerIsPresent)
2237	memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
2238	} else {
2239	writel(MFI_STOP_ADP,
2240	addr: &instance->reg_set->inbound_doorbell);
2241	}
2242	/* Complete outstanding ioctls when adapter is killed */
2243	megasas_complete_outstanding_ioctls(instance);
2244	}
2245
2246	/**
2247	* megasas_check_and_restore_queue_depth - Check if queue depth needs to be
2248	* restored to max value
2249	* @instance: Adapter soft state
2250	*
2251	*/
2252	void
2253	megasas_check_and_restore_queue_depth(struct megasas_instance *instance)
2254	{
2255	unsigned long flags;
2256
2257	if (instance->flag & MEGASAS_FW_BUSY
2258	&& time_after(jiffies, instance->last_time + 5 * HZ)
2259	&& atomic_read(v: &instance->fw_outstanding) <
2260	instance->throttlequeuedepth + 1) {
2261
2262	spin_lock_irqsave(instance->host->host_lock, flags);
2263	instance->flag &= ~MEGASAS_FW_BUSY;
2264
2265	instance->host->can_queue = instance->cur_can_queue;
2266	spin_unlock_irqrestore(lock: instance->host->host_lock, flags);
2267	}
2268	}
2269
2270	/**
2271	* megasas_complete_cmd_dpc - Returns FW's controller structure
2272	* @instance_addr: Address of adapter soft state
2273	*
2274	* Tasklet to complete cmds
2275	*/
2276	static void megasas_complete_cmd_dpc(unsigned long instance_addr)
2277	{
2278	u32 producer;
2279	u32 consumer;
2280	u32 context;
2281	struct megasas_cmd *cmd;
2282	struct megasas_instance *instance =
2283	(struct megasas_instance *)instance_addr;
2284	unsigned long flags;
2285
2286	/* If we have already declared adapter dead, donot complete cmds */
2287	if (atomic_read(v: &instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
2288	return;
2289
2290	spin_lock_irqsave(&instance->completion_lock, flags);
2291
2292	producer = le32_to_cpu(*instance->producer);
2293	consumer = le32_to_cpu(*instance->consumer);
2294
2295	while (consumer != producer) {
2296	context = le32_to_cpu(instance->reply_queue[consumer]);
2297	if (context >= instance->max_fw_cmds) {
2298	dev_err(&instance->pdev->dev, "Unexpected context value %x\n",
2299	context);
2300	BUG();
2301	}
2302
2303	cmd = instance->cmd_list[context];
2304
2305	megasas_complete_cmd(instance, cmd, alt_status: DID_OK);
2306
2307	consumer++;
2308	if (consumer == (instance->max_fw_cmds + 1)) {
2309	consumer = 0;
2310	}
2311	}
2312
2313	*instance->consumer = cpu_to_le32(producer);
2314
2315	spin_unlock_irqrestore(lock: &instance->completion_lock, flags);
2316
2317	/*
2318	* Check if we can restore can_queue
2319	*/
2320	megasas_check_and_restore_queue_depth(instance);
2321	}
2322
2323	static void megasas_sriov_heartbeat_handler(struct timer_list *t);
2324
2325	/**
2326	* megasas_start_timer - Initializes sriov heartbeat timer object
2327	* @instance: Adapter soft state
2328	*
2329	*/
2330	void megasas_start_timer(struct megasas_instance *instance)
2331	{
2332	struct timer_list *timer = &instance->sriov_heartbeat_timer;
2333
2334	timer_setup(timer, megasas_sriov_heartbeat_handler, 0);
2335	timer->expires = jiffies + MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF;
2336	add_timer(timer);
2337	}
2338
2339	static void
2340	megasas_internal_reset_defer_cmds(struct megasas_instance *instance);
2341
2342	static void
2343	process_fw_state_change_wq(struct work_struct *work);
2344
2345	static void megasas_do_ocr(struct megasas_instance *instance)
2346	{
2347	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
2348	(instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
2349	(instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
2350	*instance->consumer = cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
2351	}
2352	instance->instancet->disable_intr(instance);
2353	atomic_set(v: &instance->adprecovery, i: MEGASAS_ADPRESET_SM_INFAULT);
2354	instance->issuepend_done = 0;
2355
2356	atomic_set(v: &instance->fw_outstanding, i: 0);
2357	megasas_internal_reset_defer_cmds(instance);
2358	process_fw_state_change_wq(work: &instance->work_init);
2359	}
2360
2361	static int megasas_get_ld_vf_affiliation_111(struct megasas_instance *instance,
2362	int initial)
2363	{
2364	struct megasas_cmd *cmd;
2365	struct megasas_dcmd_frame *dcmd;
2366	struct MR_LD_VF_AFFILIATION_111 *new_affiliation_111 = NULL;
2367	dma_addr_t new_affiliation_111_h;
2368	int ld, retval = 0;
2369	u8 thisVf;
2370
2371	cmd = megasas_get_cmd(instance);
2372
2373	if (!cmd) {
2374	dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_vf_affiliation_111:"
2375	"Failed to get cmd for scsi%d\n",
2376	instance->host->host_no);
2377	return -ENOMEM;
2378	}
2379
2380	dcmd = &cmd->frame->dcmd;
2381
2382	if (!instance->vf_affiliation_111) {
2383	dev_warn(&instance->pdev->dev, "SR-IOV: Couldn't get LD/VF "
2384	"affiliation for scsi%d\n", instance->host->host_no);
2385	megasas_return_cmd(instance, cmd);
2386	return -ENOMEM;
2387	}
2388
2389	if (initial)
2390	memset(instance->vf_affiliation_111, 0,
2391	sizeof(struct MR_LD_VF_AFFILIATION_111));
2392	else {
2393	new_affiliation_111 =
2394	dma_alloc_coherent(dev: &instance->pdev->dev,
2395	size: sizeof(struct MR_LD_VF_AFFILIATION_111),
2396	dma_handle: &new_affiliation_111_h, GFP_KERNEL);
2397	if (!new_affiliation_111) {
2398	dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
2399	"memory for new affiliation for scsi%d\n",
2400	instance->host->host_no);
2401	megasas_return_cmd(instance, cmd);
2402	return -ENOMEM;
2403	}
2404	}
2405
2406	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2407
2408	dcmd->cmd = MFI_CMD_DCMD;
2409	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
2410	dcmd->sge_count = 1;
2411	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_BOTH);
2412	dcmd->timeout = 0;
2413	dcmd->pad_0 = 0;
2414	dcmd->data_xfer_len =
2415	cpu_to_le32(sizeof(struct MR_LD_VF_AFFILIATION_111));
2416	dcmd->opcode = cpu_to_le32(MR_DCMD_LD_VF_MAP_GET_ALL_LDS_111);
2417
2418	if (initial)
2419	dcmd->sgl.sge32[0].phys_addr =
2420	cpu_to_le32(instance->vf_affiliation_111_h);
2421	else
2422	dcmd->sgl.sge32[0].phys_addr =
2423	cpu_to_le32(new_affiliation_111_h);
2424
2425	dcmd->sgl.sge32[0].length = cpu_to_le32(
2426	sizeof(struct MR_LD_VF_AFFILIATION_111));
2427
2428	dev_warn(&instance->pdev->dev, "SR-IOV: Getting LD/VF affiliation for "
2429	"scsi%d\n", instance->host->host_no);
2430
2431	if (megasas_issue_blocked_cmd(instance, cmd, timeout: 0) != DCMD_SUCCESS) {
2432	dev_warn(&instance->pdev->dev, "SR-IOV: LD/VF affiliation DCMD"
2433	" failed with status 0x%x for scsi%d\n",
2434	dcmd->cmd_status, instance->host->host_no);
2435	retval = 1; /* Do a scan if we couldn't get affiliation */
2436	goto out;
2437	}
2438
2439	if (!initial) {
2440	thisVf = new_affiliation_111->thisVf;
2441	for (ld = 0 ; ld < new_affiliation_111->vdCount; ld++)
2442	if (instance->vf_affiliation_111->map[ld].policy[thisVf] !=
2443	new_affiliation_111->map[ld].policy[thisVf]) {
2444	dev_warn(&instance->pdev->dev, "SR-IOV: "
2445	"Got new LD/VF affiliation for scsi%d\n",
2446	instance->host->host_no);
2447	memcpy(instance->vf_affiliation_111,
2448	new_affiliation_111,
2449	sizeof(struct MR_LD_VF_AFFILIATION_111));
2450	retval = 1;
2451	goto out;
2452	}
2453	}
2454	out:
2455	if (new_affiliation_111) {
2456	dma_free_coherent(dev: &instance->pdev->dev,
2457	size: sizeof(struct MR_LD_VF_AFFILIATION_111),
2458	cpu_addr: new_affiliation_111,
2459	dma_handle: new_affiliation_111_h);
2460	}
2461
2462	megasas_return_cmd(instance, cmd);
2463
2464	return retval;
2465	}
2466
2467	static int megasas_get_ld_vf_affiliation_12(struct megasas_instance *instance,
2468	int initial)
2469	{
2470	struct megasas_cmd *cmd;
2471	struct megasas_dcmd_frame *dcmd;
2472	struct MR_LD_VF_AFFILIATION *new_affiliation = NULL;
2473	struct MR_LD_VF_MAP *newmap = NULL, *savedmap = NULL;
2474	dma_addr_t new_affiliation_h;
2475	int i, j, retval = 0, found = 0, doscan = 0;
2476	u8 thisVf;
2477
2478	cmd = megasas_get_cmd(instance);
2479
2480	if (!cmd) {
2481	dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_vf_affiliation12: "
2482	"Failed to get cmd for scsi%d\n",
2483	instance->host->host_no);
2484	return -ENOMEM;
2485	}
2486
2487	dcmd = &cmd->frame->dcmd;
2488
2489	if (!instance->vf_affiliation) {
2490	dev_warn(&instance->pdev->dev, "SR-IOV: Couldn't get LD/VF "
2491	"affiliation for scsi%d\n", instance->host->host_no);
2492	megasas_return_cmd(instance, cmd);
2493	return -ENOMEM;
2494	}
2495
2496	if (initial)
2497	memset(instance->vf_affiliation, 0, (MAX_LOGICAL_DRIVES + 1) *
2498	sizeof(struct MR_LD_VF_AFFILIATION));
2499	else {
2500	new_affiliation =
2501	dma_alloc_coherent(dev: &instance->pdev->dev,
2502	size: (MAX_LOGICAL_DRIVES + 1) * sizeof(struct MR_LD_VF_AFFILIATION),
2503	dma_handle: &new_affiliation_h, GFP_KERNEL);
2504	if (!new_affiliation) {
2505	dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
2506	"memory for new affiliation for scsi%d\n",
2507	instance->host->host_no);
2508	megasas_return_cmd(instance, cmd);
2509	return -ENOMEM;
2510	}
2511	}
2512
2513	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2514
2515	dcmd->cmd = MFI_CMD_DCMD;
2516	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
2517	dcmd->sge_count = 1;
2518	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_BOTH);
2519	dcmd->timeout = 0;
2520	dcmd->pad_0 = 0;
2521	dcmd->data_xfer_len = cpu_to_le32((MAX_LOGICAL_DRIVES + 1) *
2522	sizeof(struct MR_LD_VF_AFFILIATION));
2523	dcmd->opcode = cpu_to_le32(MR_DCMD_LD_VF_MAP_GET_ALL_LDS);
2524
2525	if (initial)
2526	dcmd->sgl.sge32[0].phys_addr =
2527	cpu_to_le32(instance->vf_affiliation_h);
2528	else
2529	dcmd->sgl.sge32[0].phys_addr =
2530	cpu_to_le32(new_affiliation_h);
2531
2532	dcmd->sgl.sge32[0].length = cpu_to_le32((MAX_LOGICAL_DRIVES + 1) *
2533	sizeof(struct MR_LD_VF_AFFILIATION));
2534
2535	dev_warn(&instance->pdev->dev, "SR-IOV: Getting LD/VF affiliation for "
2536	"scsi%d\n", instance->host->host_no);
2537
2538
2539	if (megasas_issue_blocked_cmd(instance, cmd, timeout: 0) != DCMD_SUCCESS) {
2540	dev_warn(&instance->pdev->dev, "SR-IOV: LD/VF affiliation DCMD"
2541	" failed with status 0x%x for scsi%d\n",
2542	dcmd->cmd_status, instance->host->host_no);
2543	retval = 1; /* Do a scan if we couldn't get affiliation */
2544	goto out;
2545	}
2546
2547	if (!initial) {
2548	if (!new_affiliation->ldCount) {
2549	dev_warn(&instance->pdev->dev, "SR-IOV: Got new LD/VF "
2550	"affiliation for passive path for scsi%d\n",
2551	instance->host->host_no);
2552	retval = 1;
2553	goto out;
2554	}
2555	newmap = new_affiliation->map;
2556	savedmap = instance->vf_affiliation->map;
2557	thisVf = new_affiliation->thisVf;
2558	for (i = 0 ; i < new_affiliation->ldCount; i++) {
2559	found = 0;
2560	for (j = 0; j < instance->vf_affiliation->ldCount;
2561	j++) {
2562	if (newmap->ref.targetId ==
2563	savedmap->ref.targetId) {
2564	found = 1;
2565	if (newmap->policy[thisVf] !=
2566	savedmap->policy[thisVf]) {
2567	doscan = 1;
2568	goto out;
2569	}
2570	}
2571	savedmap = (struct MR_LD_VF_MAP *)
2572	((unsigned char *)savedmap +
2573	savedmap->size);
2574	}
2575	if (!found && newmap->policy[thisVf] !=
2576	MR_LD_ACCESS_HIDDEN) {
2577	doscan = 1;
2578	goto out;
2579	}
2580	newmap = (struct MR_LD_VF_MAP *)
2581	((unsigned char *)newmap + newmap->size);
2582	}
2583
2584	newmap = new_affiliation->map;
2585	savedmap = instance->vf_affiliation->map;
2586
2587	for (i = 0 ; i < instance->vf_affiliation->ldCount; i++) {
2588	found = 0;
2589	for (j = 0 ; j < new_affiliation->ldCount; j++) {
2590	if (savedmap->ref.targetId ==
2591	newmap->ref.targetId) {
2592	found = 1;
2593	if (savedmap->policy[thisVf] !=
2594	newmap->policy[thisVf]) {
2595	doscan = 1;
2596	goto out;
2597	}
2598	}
2599	newmap = (struct MR_LD_VF_MAP *)
2600	((unsigned char *)newmap +
2601	newmap->size);
2602	}
2603	if (!found && savedmap->policy[thisVf] !=
2604	MR_LD_ACCESS_HIDDEN) {
2605	doscan = 1;
2606	goto out;
2607	}
2608	savedmap = (struct MR_LD_VF_MAP *)
2609	((unsigned char *)savedmap +
2610	savedmap->size);
2611	}
2612	}
2613	out:
2614	if (doscan) {
2615	dev_warn(&instance->pdev->dev, "SR-IOV: Got new LD/VF "
2616	"affiliation for scsi%d\n", instance->host->host_no);
2617	memcpy(instance->vf_affiliation, new_affiliation,
2618	new_affiliation->size);
2619	retval = 1;
2620	}
2621
2622	if (new_affiliation)
2623	dma_free_coherent(dev: &instance->pdev->dev,
2624	size: (MAX_LOGICAL_DRIVES + 1) *
2625	sizeof(struct MR_LD_VF_AFFILIATION),
2626	cpu_addr: new_affiliation, dma_handle: new_affiliation_h);
2627	megasas_return_cmd(instance, cmd);
2628
2629	return retval;
2630	}
2631
2632	/* This function will get the current SR-IOV LD/VF affiliation */
2633	static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,
2634	int initial)
2635	{
2636	int retval;
2637
2638	if (instance->PlasmaFW111)
2639	retval = megasas_get_ld_vf_affiliation_111(instance, initial);
2640	else
2641	retval = megasas_get_ld_vf_affiliation_12(instance, initial);
2642	return retval;
2643	}
2644
2645	/* This function will tell FW to start the SR-IOV heartbeat */
2646	int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
2647	int initial)
2648	{
2649	struct megasas_cmd *cmd;
2650	struct megasas_dcmd_frame *dcmd;
2651	int retval = 0;
2652
2653	cmd = megasas_get_cmd(instance);
2654
2655	if (!cmd) {
2656	dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_sriov_start_heartbeat: "
2657	"Failed to get cmd for scsi%d\n",
2658	instance->host->host_no);
2659	return -ENOMEM;
2660	}
2661
2662	dcmd = &cmd->frame->dcmd;
2663
2664	if (initial) {
2665	instance->hb_host_mem =
2666	dma_alloc_coherent(dev: &instance->pdev->dev,
2667	size: sizeof(struct MR_CTRL_HB_HOST_MEM),
2668	dma_handle: &instance->hb_host_mem_h,
2669	GFP_KERNEL);
2670	if (!instance->hb_host_mem) {
2671	dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate"
2672	" memory for heartbeat host memory for scsi%d\n",
2673	instance->host->host_no);
2674	retval = -ENOMEM;
2675	goto out;
2676	}
2677	}
2678
2679	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2680
2681	dcmd->mbox.s[0] = cpu_to_le16(sizeof(struct MR_CTRL_HB_HOST_MEM));
2682	dcmd->cmd = MFI_CMD_DCMD;
2683	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
2684	dcmd->sge_count = 1;
2685	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_BOTH);
2686	dcmd->timeout = 0;
2687	dcmd->pad_0 = 0;
2688	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_CTRL_HB_HOST_MEM));
2689	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_SHARED_HOST_MEM_ALLOC);
2690
2691	megasas_set_dma_settings(instance, dcmd, dma_addr: instance->hb_host_mem_h,
2692	dma_len: sizeof(struct MR_CTRL_HB_HOST_MEM));
2693
2694	dev_warn(&instance->pdev->dev, "SR-IOV: Starting heartbeat for scsi%d\n",
2695	instance->host->host_no);
2696
2697	if ((instance->adapter_type != MFI_SERIES) &&
2698	!instance->mask_interrupts)
2699	retval = megasas_issue_blocked_cmd(instance, cmd,
2700	MEGASAS_ROUTINE_WAIT_TIME_VF);
2701	else
2702	retval = megasas_issue_polled(instance, cmd);
2703
2704	if (retval) {
2705	dev_warn(&instance->pdev->dev, "SR-IOV: MR_DCMD_CTRL_SHARED_HOST"
2706	"_MEM_ALLOC DCMD %s for scsi%d\n",
2707	(dcmd->cmd_status == MFI_STAT_INVALID_STATUS) ?
2708	"timed out" : "failed", instance->host->host_no);
2709	retval = 1;
2710	}
2711
2712	out:
2713	megasas_return_cmd(instance, cmd);
2714
2715	return retval;
2716	}
2717
2718	/* Handler for SR-IOV heartbeat */
2719	static void megasas_sriov_heartbeat_handler(struct timer_list *t)
2720	{
2721	struct megasas_instance *instance =
2722	from_timer(instance, t, sriov_heartbeat_timer);
2723
2724	if (instance->hb_host_mem->HB.fwCounter !=
2725	instance->hb_host_mem->HB.driverCounter) {
2726	instance->hb_host_mem->HB.driverCounter =
2727	instance->hb_host_mem->HB.fwCounter;
2728	mod_timer(timer: &instance->sriov_heartbeat_timer,
2729	expires: jiffies + MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF);
2730	} else {
2731	dev_warn(&instance->pdev->dev, "SR-IOV: Heartbeat never "
2732	"completed for scsi%d\n", instance->host->host_no);
2733	schedule_work(work: &instance->work_init);
2734	}
2735	}
2736
2737	/**
2738	* megasas_wait_for_outstanding - Wait for all outstanding cmds
2739	* @instance: Adapter soft state
2740	*
2741	* This function waits for up to MEGASAS_RESET_WAIT_TIME seconds for FW to
2742	* complete all its outstanding commands. Returns error if one or more IOs
2743	* are pending after this time period. It also marks the controller dead.
2744	*/
2745	static int megasas_wait_for_outstanding(struct megasas_instance *instance)
2746	{
2747	int i, sl, outstanding;
2748	u32 reset_index;
2749	u32 wait_time = MEGASAS_RESET_WAIT_TIME;
2750	unsigned long flags;
2751	struct list_head clist_local;
2752	struct megasas_cmd *reset_cmd;
2753	u32 fw_state;
2754
2755	if (atomic_read(v: &instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2756	dev_info(&instance->pdev->dev, "%s:%d HBA is killed.\n",
2757	__func__, __LINE__);
2758	return FAILED;
2759	}
2760
2761	if (atomic_read(v: &instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
2762
2763	INIT_LIST_HEAD(list: &clist_local);
2764	spin_lock_irqsave(&instance->hba_lock, flags);
2765	list_splice_init(list: &instance->internal_reset_pending_q,
2766	head: &clist_local);
2767	spin_unlock_irqrestore(lock: &instance->hba_lock, flags);
2768
2769	dev_notice(&instance->pdev->dev, "HBA reset wait ...\n");
2770	for (i = 0; i < wait_time; i++) {
2771	msleep(msecs: 1000);
2772	if (atomic_read(v: &instance->adprecovery) == MEGASAS_HBA_OPERATIONAL)
2773	break;
2774	}
2775
2776	if (atomic_read(v: &instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
2777	dev_notice(&instance->pdev->dev, "reset: Stopping HBA.\n");
2778	atomic_set(v: &instance->adprecovery, i: MEGASAS_HW_CRITICAL_ERROR);
2779	return FAILED;
2780	}
2781
2782	reset_index = 0;
2783	while (!list_empty(head: &clist_local)) {
2784	reset_cmd = list_entry((&clist_local)->next,
2785	struct megasas_cmd, list);
2786	list_del_init(entry: &reset_cmd->list);
2787	if (reset_cmd->scmd) {
2788	reset_cmd->scmd->result = DID_REQUEUE << 16;
2789	dev_notice(&instance->pdev->dev, "%d:%p reset [%02x]\n",
2790	reset_index, reset_cmd,
2791	reset_cmd->scmd->cmnd[0]);
2792
2793	scsi_done(cmd: reset_cmd->scmd);
2794	megasas_return_cmd(instance, cmd: reset_cmd);
2795	} else if (reset_cmd->sync_cmd) {
2796	dev_notice(&instance->pdev->dev, "%p synch cmds"
2797	"reset queue\n",
2798	reset_cmd);
2799
2800	reset_cmd->cmd_status_drv = DCMD_INIT;
2801	instance->instancet->fire_cmd(instance,
2802	reset_cmd->frame_phys_addr,
2803	0, instance->reg_set);
2804	} else {
2805	dev_notice(&instance->pdev->dev, "%p unexpected"
2806	"cmds lst\n",
2807	reset_cmd);
2808	}
2809	reset_index++;
2810	}
2811
2812	return SUCCESS;
2813	}
2814
2815	for (i = 0; i < resetwaittime; i++) {
2816	outstanding = atomic_read(v: &instance->fw_outstanding);
2817
2818	if (!outstanding)
2819	break;
2820
2821	if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
2822	dev_notice(&instance->pdev->dev, "[%2d]waiting for %d "
2823	"commands to complete\n",i,outstanding);
2824	/*
2825	* Call cmd completion routine. Cmd to be
2826	* be completed directly without depending on isr.
2827	*/
2828	megasas_complete_cmd_dpc(instance_addr: (unsigned long)instance);
2829	}
2830
2831	msleep(msecs: 1000);
2832	}
2833
2834	i = 0;
2835	outstanding = atomic_read(v: &instance->fw_outstanding);
2836	fw_state = instance->instancet->read_fw_status_reg(instance) & MFI_STATE_MASK;
2837
2838	if ((!outstanding && (fw_state == MFI_STATE_OPERATIONAL)))
2839	goto no_outstanding;
2840
2841	if (instance->disableOnlineCtrlReset)
2842	goto kill_hba_and_failed;
2843	do {
2844	if ((fw_state == MFI_STATE_FAULT) || atomic_read(v: &instance->fw_outstanding)) {
2845	dev_info(&instance->pdev->dev,
2846	"%s:%d waiting_for_outstanding: before issue OCR. FW state = 0x%x, outstanding 0x%x\n",
2847	__func__, __LINE__, fw_state, atomic_read(&instance->fw_outstanding));
2848	if (i == 3)
2849	goto kill_hba_and_failed;
2850	megasas_do_ocr(instance);
2851
2852	if (atomic_read(v: &instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2853	dev_info(&instance->pdev->dev, "%s:%d OCR failed and HBA is killed.\n",
2854	__func__, __LINE__);
2855	return FAILED;
2856	}
2857	dev_info(&instance->pdev->dev, "%s:%d waiting_for_outstanding: after issue OCR.\n",
2858	__func__, __LINE__);
2859
2860	for (sl = 0; sl < 10; sl++)
2861	msleep(msecs: 500);
2862
2863	outstanding = atomic_read(v: &instance->fw_outstanding);
2864
2865	fw_state = instance->instancet->read_fw_status_reg(instance) & MFI_STATE_MASK;
2866	if ((!outstanding && (fw_state == MFI_STATE_OPERATIONAL)))
2867	goto no_outstanding;
2868	}
2869	i++;
2870	} while (i <= 3);
2871
2872	no_outstanding:
2873
2874	dev_info(&instance->pdev->dev, "%s:%d no more pending commands remain after reset handling.\n",
2875	__func__, __LINE__);
2876	return SUCCESS;
2877
2878	kill_hba_and_failed:
2879
2880	/* Reset not supported, kill adapter */
2881	dev_info(&instance->pdev->dev, "%s:%d killing adapter scsi%d"
2882	" disableOnlineCtrlReset %d fw_outstanding %d \n",
2883	__func__, __LINE__, instance->host->host_no, instance->disableOnlineCtrlReset,
2884	atomic_read(&instance->fw_outstanding));
2885	megasas_dump_pending_frames(instance);
2886	megaraid_sas_kill_hba(instance);
2887
2888	return FAILED;
2889	}
2890
2891	/**
2892	* megasas_generic_reset - Generic reset routine
2893	* @scmd: Mid-layer SCSI command
2894	*
2895	* This routine implements a generic reset handler for device, bus and host
2896	* reset requests. Device, bus and host specific reset handlers can use this
2897	* function after they do their specific tasks.
2898	*/
2899	static int megasas_generic_reset(struct scsi_cmnd *scmd)
2900	{
2901	int ret_val;
2902	struct megasas_instance *instance;
2903
2904	instance = (struct megasas_instance *)scmd->device->host->hostdata;
2905
2906	scmd_printk(KERN_NOTICE, scmd, "megasas: RESET cmd=%x retries=%x\n",
2907	scmd->cmnd[0], scmd->retries);
2908
2909	if (atomic_read(v: &instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2910	dev_err(&instance->pdev->dev, "cannot recover from previous reset failures\n");
2911	return FAILED;
2912	}
2913
2914	ret_val = megasas_wait_for_outstanding(instance);
2915	if (ret_val == SUCCESS)
2916	dev_notice(&instance->pdev->dev, "reset successful\n");
2917	else
2918	dev_err(&instance->pdev->dev, "failed to do reset\n");
2919
2920	return ret_val;
2921	}
2922
2923	/**
2924	* megasas_reset_timer - quiesce the adapter if required
2925	* @scmd: scsi cmnd
2926	*
2927	* Sets the FW busy flag and reduces the host->can_queue if the
2928	* cmd has not been completed within the timeout period.
2929	*/
2930	static enum scsi_timeout_action megasas_reset_timer(struct scsi_cmnd *scmd)
2931	{
2932	struct megasas_instance *instance;
2933	unsigned long flags;
2934
2935	if (time_after(jiffies, scmd->jiffies_at_alloc +
2936	(scmd_timeout * 2) * HZ)) {
2937	return SCSI_EH_NOT_HANDLED;
2938	}
2939
2940	instance = (struct megasas_instance *)scmd->device->host->hostdata;
2941	if (!(instance->flag & MEGASAS_FW_BUSY)) {
2942	/* FW is busy, throttle IO */
2943	spin_lock_irqsave(instance->host->host_lock, flags);
2944
2945	instance->host->can_queue = instance->throttlequeuedepth;
2946	instance->last_time = jiffies;
2947	instance->flag |= MEGASAS_FW_BUSY;
2948
2949	spin_unlock_irqrestore(lock: instance->host->host_lock, flags);
2950	}
2951	return SCSI_EH_RESET_TIMER;
2952	}
2953
2954	/**
2955	* megasas_dump - This function will print hexdump of provided buffer.
2956	* @buf: Buffer to be dumped
2957	* @sz: Size in bytes
2958	* @format: Different formats of dumping e.g. format=n will
2959	* cause only 'n' 32 bit words to be dumped in a single
2960	* line.
2961	*/
2962	inline void
2963	megasas_dump(void *buf, int sz, int format)
2964	{
2965	int i;
2966	__le32 *buf_loc = (__le32 *)buf;
2967
2968	for (i = 0; i < (sz / sizeof(__le32)); i++) {
2969	if ((i % format) == 0) {
2970	if (i != 0)
2971	printk(KERN_CONT "\n");
2972	printk(KERN_CONT "%08x: ", (i * 4));
2973	}
2974	printk(KERN_CONT "%08x ", le32_to_cpu(buf_loc[i]));
2975	}
2976	printk(KERN_CONT "\n");
2977	}
2978
2979	/**
2980	* megasas_dump_reg_set - This function will print hexdump of register set
2981	* @reg_set: Register set to be dumped
2982	*/
2983	inline void
2984	megasas_dump_reg_set(void __iomem *reg_set)
2985	{
2986	unsigned int i, sz = 256;
2987	u32 __iomem *reg = (u32 __iomem *)reg_set;
2988
2989	for (i = 0; i < (sz / sizeof(u32)); i++)
2990	printk("%08x: %08x\n", (i * 4), readl(&reg[i]));
2991	}
2992
2993	/**
2994	* megasas_dump_fusion_io - This function will print key details
2995	* of SCSI IO
2996	* @scmd: SCSI command pointer of SCSI IO
2997	*/
2998	void
2999	megasas_dump_fusion_io(struct scsi_cmnd *scmd)
3000	{
3001	struct megasas_cmd_fusion *cmd = megasas_priv(cmd: scmd)->cmd_priv;
3002	union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
3003	struct megasas_instance *instance;
3004
3005	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3006
3007	scmd_printk(KERN_INFO, scmd,
3008	"scmd: (0x%p) retries: 0x%x allowed: 0x%x\n",
3009	scmd, scmd->retries, scmd->allowed);
3010	scsi_print_command(scmd);
3011
3012	if (cmd) {
3013	req_desc = (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)cmd->request_desc;
3014	scmd_printk(KERN_INFO, scmd, "Request descriptor details:\n");
3015	scmd_printk(KERN_INFO, scmd,
3016	"RequestFlags:0x%x MSIxIndex:0x%x SMID:0x%x LMID:0x%x DevHandle:0x%x\n",
3017	req_desc->SCSIIO.RequestFlags,
3018	req_desc->SCSIIO.MSIxIndex, req_desc->SCSIIO.SMID,
3019	req_desc->SCSIIO.LMID, req_desc->SCSIIO.DevHandle);
3020
3021	printk(KERN_INFO "IO request frame:\n");
3022	megasas_dump(buf: cmd->io_request,
3023	MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE, format: 8);
3024	printk(KERN_INFO "Chain frame:\n");
3025	megasas_dump(buf: cmd->sg_frame,
3026	sz: instance->max_chain_frame_sz, format: 8);
3027	}
3028
3029	}
3030
3031	/*
3032	* megasas_dump_sys_regs - This function will dump system registers through
3033	* sysfs.
3034	* @reg_set: Pointer to System register set.
3035	* @buf: Buffer to which output is to be written.
3036	* @return: Number of bytes written to buffer.
3037	*/
3038	static inline ssize_t
3039	megasas_dump_sys_regs(void __iomem *reg_set, char *buf)
3040	{
3041	unsigned int i, sz = 256;
3042	int bytes_wrote = 0;
3043	char *loc = (char *)buf;
3044	u32 __iomem *reg = (u32 __iomem *)reg_set;
3045
3046	for (i = 0; i < sz / sizeof(u32); i++) {
3047	bytes_wrote += scnprintf(buf: loc + bytes_wrote,
3048	PAGE_SIZE - bytes_wrote,
3049	fmt: "%08x: %08x\n", (i * 4),
3050	readl(addr: &reg[i]));
3051	}
3052	return bytes_wrote;
3053	}
3054
3055	/**
3056	* megasas_reset_bus_host - Bus & host reset handler entry point
3057	* @scmd: Mid-layer SCSI command
3058	*/
3059	static int megasas_reset_bus_host(struct scsi_cmnd *scmd)
3060	{
3061	int ret;
3062	struct megasas_instance *instance;
3063
3064	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3065
3066	scmd_printk(KERN_INFO, scmd,
3067	"OCR is requested due to IO timeout!!\n");
3068
3069	scmd_printk(KERN_INFO, scmd,
3070	"SCSI host state: %d SCSI host busy: %d FW outstanding: %d\n",
3071	scmd->device->host->shost_state,
3072	scsi_host_busy(shost: scmd->device->host),
3073	atomic_read(v: &instance->fw_outstanding));
3074	/*
3075	* First wait for all commands to complete
3076	*/
3077	if (instance->adapter_type == MFI_SERIES) {
3078	ret = megasas_generic_reset(scmd);
3079	} else {
3080	megasas_dump_fusion_io(scmd);
3081	ret = megasas_reset_fusion(shost: scmd->device->host,
3082	reason: SCSIIO_TIMEOUT_OCR);
3083	}
3084
3085	return ret;
3086	}
3087
3088	/**
3089	* megasas_task_abort - Issues task abort request to firmware
3090	* (supported only for fusion adapters)
3091	* @scmd: SCSI command pointer
3092	*/
3093	static int megasas_task_abort(struct scsi_cmnd *scmd)
3094	{
3095	int ret;
3096	struct megasas_instance *instance;
3097
3098	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3099
3100	if (instance->adapter_type != MFI_SERIES)
3101	ret = megasas_task_abort_fusion(scmd);
3102	else {
3103	sdev_printk(KERN_NOTICE, scmd->device, "TASK ABORT not supported\n");
3104	ret = FAILED;
3105	}
3106
3107	return ret;
3108	}
3109
3110	/**
3111	* megasas_reset_target: Issues target reset request to firmware
3112	* (supported only for fusion adapters)
3113	* @scmd: SCSI command pointer
3114	*/
3115	static int megasas_reset_target(struct scsi_cmnd *scmd)
3116	{
3117	int ret;
3118	struct megasas_instance *instance;
3119
3120	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3121
3122	if (instance->adapter_type != MFI_SERIES)
3123	ret = megasas_reset_target_fusion(scmd);
3124	else {
3125	sdev_printk(KERN_NOTICE, scmd->device, "TARGET RESET not supported\n");
3126	ret = FAILED;
3127	}
3128
3129	return ret;
3130	}
3131
3132	/**
3133	* megasas_bios_param - Returns disk geometry for a disk
3134	* @sdev: device handle
3135	* @bdev: block device
3136	* @capacity: drive capacity
3137	* @geom: geometry parameters
3138	*/
3139	static int
3140	megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev,
3141	sector_t capacity, int geom[])
3142	{
3143	int heads;
3144	int sectors;
3145	sector_t cylinders;
3146	unsigned long tmp;
3147
3148	/* Default heads (64) & sectors (32) */
3149	heads = 64;
3150	sectors = 32;
3151
3152	tmp = heads * sectors;
3153	cylinders = capacity;
3154
3155	sector_div(cylinders, tmp);
3156
3157	/*
3158	* Handle extended translation size for logical drives > 1Gb
3159	*/
3160
3161	if (capacity >= 0x200000) {
3162	heads = 255;
3163	sectors = 63;
3164	tmp = heads*sectors;
3165	cylinders = capacity;
3166	sector_div(cylinders, tmp);
3167	}
3168
3169	geom[0] = heads;
3170	geom[1] = sectors;
3171	geom[2] = cylinders;
3172
3173	return 0;
3174	}
3175
3176	static void megasas_map_queues(struct Scsi_Host *shost)
3177	{
3178	struct megasas_instance *instance;
3179	int qoff = 0, offset;
3180	struct blk_mq_queue_map *map;
3181
3182	instance = (struct megasas_instance *)shost->hostdata;
3183
3184	if (shost->nr_hw_queues == 1)
3185	return;
3186
3187	offset = instance->low_latency_index_start;
3188
3189	/* Setup Default hctx */
3190	map = &shost->tag_set.map[HCTX_TYPE_DEFAULT];
3191	map->nr_queues = instance->msix_vectors - offset;
3192	map->queue_offset = 0;
3193	blk_mq_pci_map_queues(qmap: map, pdev: instance->pdev, offset);
3194	qoff += map->nr_queues;
3195	offset += map->nr_queues;
3196
3197	/* we never use READ queue, so can't cheat blk-mq */
3198	shost->tag_set.map[HCTX_TYPE_READ].nr_queues = 0;
3199
3200	/* Setup Poll hctx */
3201	map = &shost->tag_set.map[HCTX_TYPE_POLL];
3202	map->nr_queues = instance->iopoll_q_count;
3203	if (map->nr_queues) {
3204	/*
3205	* The poll queue(s) doesn't have an IRQ (and hence IRQ
3206	* affinity), so use the regular blk-mq cpu mapping
3207	*/
3208	map->queue_offset = qoff;
3209	blk_mq_map_queues(qmap: map);
3210	}
3211	}
3212
3213	static void megasas_aen_polling(struct work_struct *work);
3214
3215	/**
3216	* megasas_service_aen - Processes an event notification
3217	* @instance: Adapter soft state
3218	* @cmd: AEN command completed by the ISR
3219	*
3220	* For AEN, driver sends a command down to FW that is held by the FW till an
3221	* event occurs. When an event of interest occurs, FW completes the command
3222	* that it was previously holding.
3223	*
3224	* This routines sends SIGIO signal to processes that have registered with the
3225	* driver for AEN.
3226	*/
3227	static void
3228	megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
3229	{
3230	unsigned long flags;
3231
3232	/*
3233	* Don't signal app if it is just an aborted previously registered aen
3234	*/
3235	if ((!cmd->abort_aen) && (instance->unload == 0)) {
3236	spin_lock_irqsave(&poll_aen_lock, flags);
3237	megasas_poll_wait_aen = 1;
3238	spin_unlock_irqrestore(lock: &poll_aen_lock, flags);
3239	wake_up(&megasas_poll_wait);
3240	kill_fasync(&megasas_async_queue, SIGIO, POLL_IN);
3241	}
3242	else
3243	cmd->abort_aen = 0;
3244
3245	instance->aen_cmd = NULL;
3246
3247	megasas_return_cmd(instance, cmd);
3248
3249	if ((instance->unload == 0) &&
3250	((instance->issuepend_done == 1))) {
3251	struct megasas_aen_event *ev;
3252
3253	ev = kzalloc(size: sizeof(*ev), GFP_ATOMIC);
3254	if (!ev) {
3255	dev_err(&instance->pdev->dev, "megasas_service_aen: out of memory\n");
3256	} else {
3257	ev->instance = instance;
3258	instance->ev = ev;
3259	INIT_DELAYED_WORK(&ev->hotplug_work,
3260	megasas_aen_polling);
3261	schedule_delayed_work(dwork: &ev->hotplug_work, delay: 0);
3262	}
3263	}
3264	}
3265
3266	static ssize_t
3267	fw_crash_buffer_store(struct device *cdev,
3268	struct device_attribute *attr, const char *buf, size_t count)
3269	{
3270	struct Scsi_Host *shost = class_to_shost(cdev);
3271	struct megasas_instance *instance =
3272	(struct megasas_instance *) shost->hostdata;
3273	int val = 0;
3274
3275	if (kstrtoint(s: buf, base: 0, res: &val) != 0)
3276	return -EINVAL;
3277
3278	mutex_lock(&instance->crashdump_lock);
3279	instance->fw_crash_buffer_offset = val;
3280	mutex_unlock(lock: &instance->crashdump_lock);
3281	return strlen(buf);
3282	}
3283
3284	static ssize_t
3285	fw_crash_buffer_show(struct device *cdev,
3286	struct device_attribute *attr, char *buf)
3287	{
3288	struct Scsi_Host *shost = class_to_shost(cdev);
3289	struct megasas_instance *instance =
3290	(struct megasas_instance *) shost->hostdata;
3291	u32 size;
3292	unsigned long dmachunk = CRASH_DMA_BUF_SIZE;
3293	unsigned long chunk_left_bytes;
3294	unsigned long src_addr;
3295	u32 buff_offset;
3296
3297	mutex_lock(&instance->crashdump_lock);
3298	buff_offset = instance->fw_crash_buffer_offset;
3299	if (!instance->crash_dump_buf ||
3300	!((instance->fw_crash_state == AVAILABLE) ||
3301	(instance->fw_crash_state == COPYING))) {
3302	dev_err(&instance->pdev->dev,
3303	"Firmware crash dump is not available\n");
3304	mutex_unlock(lock: &instance->crashdump_lock);
3305	return -EINVAL;
3306	}
3307
3308	if (buff_offset > (instance->fw_crash_buffer_size * dmachunk)) {
3309	dev_err(&instance->pdev->dev,
3310	"Firmware crash dump offset is out of range\n");
3311	mutex_unlock(lock: &instance->crashdump_lock);
3312	return 0;
3313	}
3314
3315	size = (instance->fw_crash_buffer_size * dmachunk) - buff_offset;
3316	chunk_left_bytes = dmachunk - (buff_offset % dmachunk);
3317	size = (size > chunk_left_bytes) ? chunk_left_bytes : size;
3318	size = (size >= PAGE_SIZE) ? (PAGE_SIZE - 1) : size;
3319
3320	src_addr = (unsigned long)instance->crash_buf[buff_offset / dmachunk] +
3321	(buff_offset % dmachunk);
3322	memcpy(buf, (void *)src_addr, size);
3323	mutex_unlock(lock: &instance->crashdump_lock);
3324
3325	return size;
3326	}
3327
3328	static ssize_t
3329	fw_crash_buffer_size_show(struct device *cdev,
3330	struct device_attribute *attr, char *buf)
3331	{
3332	struct Scsi_Host *shost = class_to_shost(cdev);
3333	struct megasas_instance *instance =
3334	(struct megasas_instance *) shost->hostdata;
3335
3336	return snprintf(buf, PAGE_SIZE, fmt: "%ld\n", (unsigned long)
3337	((instance->fw_crash_buffer_size) * 1024 * 1024)/PAGE_SIZE);
3338	}
3339
3340	static ssize_t
3341	fw_crash_state_store(struct device *cdev,
3342	struct device_attribute *attr, const char *buf, size_t count)
3343	{
3344	struct Scsi_Host *shost = class_to_shost(cdev);
3345	struct megasas_instance *instance =
3346	(struct megasas_instance *) shost->hostdata;
3347	int val = 0;
3348
3349	if (kstrtoint(s: buf, base: 0, res: &val) != 0)
3350	return -EINVAL;
3351
3352	if ((val <= AVAILABLE || val > COPY_ERROR)) {
3353	dev_err(&instance->pdev->dev, "application updates invalid "
3354	"firmware crash state\n");
3355	return -EINVAL;
3356	}
3357
3358	instance->fw_crash_state = val;
3359
3360	if ((val == COPIED) || (val == COPY_ERROR)) {
3361	mutex_lock(&instance->crashdump_lock);
3362	megasas_free_host_crash_buffer(instance);
3363	mutex_unlock(lock: &instance->crashdump_lock);
3364	if (val == COPY_ERROR)
3365	dev_info(&instance->pdev->dev, "application failed to "
3366	"copy Firmware crash dump\n");
3367	else
3368	dev_info(&instance->pdev->dev, "Firmware crash dump "
3369	"copied successfully\n");
3370	}
3371	return strlen(buf);
3372	}
3373
3374	static ssize_t
3375	fw_crash_state_show(struct device *cdev,
3376	struct device_attribute *attr, char *buf)
3377	{
3378	struct Scsi_Host *shost = class_to_shost(cdev);
3379	struct megasas_instance *instance =
3380	(struct megasas_instance *) shost->hostdata;
3381
3382	return snprintf(buf, PAGE_SIZE, fmt: "%d\n", instance->fw_crash_state);
3383	}
3384
3385	static ssize_t
3386	page_size_show(struct device *cdev,
3387	struct device_attribute *attr, char *buf)
3388	{
3389	return snprintf(buf, PAGE_SIZE, fmt: "%ld\n", (unsigned long)PAGE_SIZE - 1);
3390	}
3391
3392	static ssize_t
3393	ldio_outstanding_show(struct device *cdev, struct device_attribute *attr,
3394	char *buf)
3395	{
3396	struct Scsi_Host *shost = class_to_shost(cdev);
3397	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3398
3399	return snprintf(buf, PAGE_SIZE, fmt: "%d\n", atomic_read(v: &instance->ldio_outstanding));
3400	}
3401
3402	static ssize_t
3403	fw_cmds_outstanding_show(struct device *cdev,
3404	struct device_attribute *attr, char *buf)
3405	{
3406	struct Scsi_Host *shost = class_to_shost(cdev);
3407	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3408
3409	return snprintf(buf, PAGE_SIZE, fmt: "%d\n", atomic_read(v: &instance->fw_outstanding));
3410	}
3411
3412	static ssize_t
3413	enable_sdev_max_qd_show(struct device *cdev,
3414	struct device_attribute *attr, char *buf)
3415	{
3416	struct Scsi_Host *shost = class_to_shost(cdev);
3417	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3418
3419	return snprintf(buf, PAGE_SIZE, fmt: "%d\n", instance->enable_sdev_max_qd);
3420	}
3421
3422	static ssize_t
3423	enable_sdev_max_qd_store(struct device *cdev,
3424	struct device_attribute *attr, const char *buf, size_t count)
3425	{
3426	struct Scsi_Host *shost = class_to_shost(cdev);
3427	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3428	u32 val = 0;
3429	bool is_target_prop;
3430	int ret_target_prop = DCMD_FAILED;
3431	struct scsi_device *sdev;
3432
3433	if (kstrtou32(s: buf, base: 0, res: &val) != 0) {
3434	pr_err("megasas: could not set enable_sdev_max_qd\n");
3435	return -EINVAL;
3436	}
3437
3438	mutex_lock(&instance->reset_mutex);
3439	if (val)
3440	instance->enable_sdev_max_qd = true;
3441	else
3442	instance->enable_sdev_max_qd = false;
3443
3444	shost_for_each_device(sdev, shost) {
3445	ret_target_prop = megasas_get_target_prop(instance, sdev);
3446	is_target_prop = (ret_target_prop == DCMD_SUCCESS) ? true : false;
3447	megasas_set_fw_assisted_qd(sdev, is_target_prop);
3448	}
3449	mutex_unlock(lock: &instance->reset_mutex);
3450
3451	return strlen(buf);
3452	}
3453
3454	static ssize_t
3455	dump_system_regs_show(struct device *cdev,
3456	struct device_attribute *attr, char *buf)
3457	{
3458	struct Scsi_Host *shost = class_to_shost(cdev);
3459	struct megasas_instance *instance =
3460	(struct megasas_instance *)shost->hostdata;
3461
3462	return megasas_dump_sys_regs(reg_set: instance->reg_set, buf);
3463	}
3464
3465	static ssize_t
3466	raid_map_id_show(struct device *cdev, struct device_attribute *attr,
3467	char *buf)
3468	{
3469	struct Scsi_Host *shost = class_to_shost(cdev);
3470	struct megasas_instance *instance =
3471	(struct megasas_instance *)shost->hostdata;
3472
3473	return snprintf(buf, PAGE_SIZE, fmt: "%ld\n",
3474	(unsigned long)instance->map_id);
3475	}
3476
3477	static DEVICE_ATTR_RW(fw_crash_buffer);
3478	static DEVICE_ATTR_RO(fw_crash_buffer_size);
3479	static DEVICE_ATTR_RW(fw_crash_state);
3480	static DEVICE_ATTR_RO(page_size);
3481	static DEVICE_ATTR_RO(ldio_outstanding);
3482	static DEVICE_ATTR_RO(fw_cmds_outstanding);
3483	static DEVICE_ATTR_RW(enable_sdev_max_qd);
3484	static DEVICE_ATTR_RO(dump_system_regs);
3485	static DEVICE_ATTR_RO(raid_map_id);
3486
3487	static struct attribute *megaraid_host_attrs[] = {
3488	&dev_attr_fw_crash_buffer_size.attr,
3489	&dev_attr_fw_crash_buffer.attr,
3490	&dev_attr_fw_crash_state.attr,
3491	&dev_attr_page_size.attr,
3492	&dev_attr_ldio_outstanding.attr,
3493	&dev_attr_fw_cmds_outstanding.attr,
3494	&dev_attr_enable_sdev_max_qd.attr,
3495	&dev_attr_dump_system_regs.attr,
3496	&dev_attr_raid_map_id.attr,
3497	NULL,
3498	};
3499
3500	ATTRIBUTE_GROUPS(megaraid_host);
3501
3502	/*
3503	* Scsi host template for megaraid_sas driver
3504	*/
3505	static const struct scsi_host_template megasas_template = {
3506
3507	.module = THIS_MODULE,
3508	.name = "Avago SAS based MegaRAID driver",
3509	.proc_name = "megaraid_sas",
3510	.slave_configure = megasas_slave_configure,
3511	.slave_alloc = megasas_slave_alloc,
3512	.slave_destroy = megasas_slave_destroy,
3513	.queuecommand = megasas_queue_command,
3514	.eh_target_reset_handler = megasas_reset_target,
3515	.eh_abort_handler = megasas_task_abort,
3516	.eh_host_reset_handler = megasas_reset_bus_host,
3517	.eh_timed_out = megasas_reset_timer,
3518	.shost_groups = megaraid_host_groups,
3519	.bios_param = megasas_bios_param,
3520	.map_queues = megasas_map_queues,
3521	.mq_poll = megasas_blk_mq_poll,
3522	.change_queue_depth = scsi_change_queue_depth,
3523	.max_segment_size = 0xffffffff,
3524	.cmd_size = sizeof(struct megasas_cmd_priv),
3525	};
3526
3527	/**
3528	* megasas_complete_int_cmd - Completes an internal command
3529	* @instance: Adapter soft state
3530	* @cmd: Command to be completed
3531	*
3532	* The megasas_issue_blocked_cmd() function waits for a command to complete
3533	* after it issues a command. This function wakes up that waiting routine by
3534	* calling wake_up() on the wait queue.
3535	*/
3536	static void
3537	megasas_complete_int_cmd(struct megasas_instance *instance,
3538	struct megasas_cmd *cmd)
3539	{
3540	if (cmd->cmd_status_drv == DCMD_INIT)
3541	cmd->cmd_status_drv =
3542	(cmd->frame->io.cmd_status == MFI_STAT_OK) ?
3543	DCMD_SUCCESS : DCMD_FAILED;
3544
3545	wake_up(&instance->int_cmd_wait_q);
3546	}
3547
3548	/**
3549	* megasas_complete_abort - Completes aborting a command
3550	* @instance: Adapter soft state
3551	* @cmd: Cmd that was issued to abort another cmd
3552	*
3553	* The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q
3554	* after it issues an abort on a previously issued command. This function
3555	* wakes up all functions waiting on the same wait queue.
3556	*/
3557	static void
3558	megasas_complete_abort(struct megasas_instance *instance,
3559	struct megasas_cmd *cmd)
3560	{
3561	if (cmd->sync_cmd) {
3562	cmd->sync_cmd = 0;
3563	cmd->cmd_status_drv = DCMD_SUCCESS;
3564	wake_up(&instance->abort_cmd_wait_q);
3565	}
3566	}
3567
3568	static void
3569	megasas_set_ld_removed_by_fw(struct megasas_instance *instance)
3570	{
3571	uint i;
3572
3573	for (i = 0; (i < MEGASAS_MAX_LD_IDS); i++) {
3574	if (instance->ld_ids_prev[i] != 0xff &&
3575	instance->ld_ids_from_raidmap[i] == 0xff) {
3576	if (megasas_dbg_lvl & LD_PD_DEBUG)
3577	dev_info(&instance->pdev->dev,
3578	"LD target ID %d removed from RAID map\n", i);
3579	instance->ld_tgtid_status[i] = LD_TARGET_ID_DELETED;
3580	}
3581	}
3582	}
3583
3584	/**
3585	* megasas_complete_cmd - Completes a command
3586	* @instance: Adapter soft state
3587	* @cmd: Command to be completed
3588	* @alt_status: If non-zero, use this value as status to
3589	* SCSI mid-layer instead of the value returned
3590	* by the FW. This should be used if caller wants
3591	* an alternate status (as in the case of aborted
3592	* commands)
3593	*/
3594	void
3595	megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
3596	u8 alt_status)
3597	{
3598	int exception = 0;
3599	struct megasas_header *hdr = &cmd->frame->hdr;
3600	unsigned long flags;
3601	struct fusion_context *fusion = instance->ctrl_context;
3602	u32 opcode, status;
3603
3604	/* flag for the retry reset */
3605	cmd->retry_for_fw_reset = 0;
3606
3607	if (cmd->scmd)
3608	megasas_priv(cmd: cmd->scmd)->cmd_priv = NULL;
3609
3610	switch (hdr->cmd) {
3611	case MFI_CMD_INVALID:
3612	/* Some older 1068 controller FW may keep a pended
3613	MR_DCMD_CTRL_EVENT_GET_INFO left over from the main kernel
3614	when booting the kdump kernel. Ignore this command to
3615	prevent a kernel panic on shutdown of the kdump kernel. */
3616	dev_warn(&instance->pdev->dev, "MFI_CMD_INVALID command "
3617	"completed\n");
3618	dev_warn(&instance->pdev->dev, "If you have a controller "
3619	"other than PERC5, please upgrade your firmware\n");
3620	break;
3621	case MFI_CMD_PD_SCSI_IO:
3622	case MFI_CMD_LD_SCSI_IO:
3623
3624	/*
3625	* MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been
3626	* issued either through an IO path or an IOCTL path. If it
3627	* was via IOCTL, we will send it to internal completion.
3628	*/
3629	if (cmd->sync_cmd) {
3630	cmd->sync_cmd = 0;
3631	megasas_complete_int_cmd(instance, cmd);
3632	break;
3633	}
3634	fallthrough;
3635
3636	case MFI_CMD_LD_READ:
3637	case MFI_CMD_LD_WRITE:
3638
3639	if (alt_status) {
3640	cmd->scmd->result = alt_status << 16;
3641	exception = 1;
3642	}
3643
3644	if (exception) {
3645
3646	atomic_dec(v: &instance->fw_outstanding);
3647
3648	scsi_dma_unmap(cmd: cmd->scmd);
3649	scsi_done(cmd: cmd->scmd);
3650	megasas_return_cmd(instance, cmd);
3651
3652	break;
3653	}
3654
3655	switch (hdr->cmd_status) {
3656
3657	case MFI_STAT_OK:
3658	cmd->scmd->result = DID_OK << 16;
3659	break;
3660
3661	case MFI_STAT_SCSI_IO_FAILED:
3662	case MFI_STAT_LD_INIT_IN_PROGRESS:
3663	cmd->scmd->result =
3664	(DID_ERROR << 16) | hdr->scsi_status;
3665	break;
3666
3667	case MFI_STAT_SCSI_DONE_WITH_ERROR:
3668
3669	cmd->scmd->result = (DID_OK << 16) | hdr->scsi_status;
3670
3671	if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) {
3672	memset(cmd->scmd->sense_buffer, 0,
3673	SCSI_SENSE_BUFFERSIZE);
3674	memcpy(cmd->scmd->sense_buffer, cmd->sense,
3675	hdr->sense_len);
3676	}
3677
3678	break;
3679
3680	case MFI_STAT_LD_OFFLINE:
3681	case MFI_STAT_DEVICE_NOT_FOUND:
3682	cmd->scmd->result = DID_BAD_TARGET << 16;
3683	break;
3684
3685	default:
3686	dev_printk(KERN_DEBUG, &instance->pdev->dev, "MFI FW status %#x\n",
3687	hdr->cmd_status);
3688	cmd->scmd->result = DID_ERROR << 16;
3689	break;
3690	}
3691
3692	atomic_dec(v: &instance->fw_outstanding);
3693
3694	scsi_dma_unmap(cmd: cmd->scmd);
3695	scsi_done(cmd: cmd->scmd);
3696	megasas_return_cmd(instance, cmd);
3697
3698	break;
3699
3700	case MFI_CMD_SMP:
3701	case MFI_CMD_STP:
3702	case MFI_CMD_NVME:
3703	case MFI_CMD_TOOLBOX:
3704	megasas_complete_int_cmd(instance, cmd);
3705	break;
3706
3707	case MFI_CMD_DCMD:
3708	opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
3709	/* Check for LD map update */
3710	if ((opcode == MR_DCMD_LD_MAP_GET_INFO)
3711	&& (cmd->frame->dcmd.mbox.b[1] == 1)) {
3712	fusion->fast_path_io = 0;
3713	spin_lock_irqsave(instance->host->host_lock, flags);
3714	status = cmd->frame->hdr.cmd_status;
3715	instance->map_update_cmd = NULL;
3716	if (status != MFI_STAT_OK) {
3717	if (status != MFI_STAT_NOT_FOUND)
3718	dev_warn(&instance->pdev->dev, "map syncfailed, status = 0x%x\n",
3719	cmd->frame->hdr.cmd_status);
3720	else {
3721	megasas_return_cmd(instance, cmd);
3722	spin_unlock_irqrestore(
3723	lock: instance->host->host_lock,
3724	flags);
3725	break;
3726	}
3727	}
3728
3729	megasas_return_cmd(instance, cmd);
3730
3731	/*
3732	* Set fast path IO to ZERO.
3733	* Validate Map will set proper value.
3734	* Meanwhile all IOs will go as LD IO.
3735	*/
3736	if (status == MFI_STAT_OK &&
3737	(MR_ValidateMapInfo(instance, map_id: (instance->map_id + 1)))) {
3738	instance->map_id++;
3739	fusion->fast_path_io = 1;
3740	} else {
3741	fusion->fast_path_io = 0;
3742	}
3743
3744	if (instance->adapter_type >= INVADER_SERIES)
3745	megasas_set_ld_removed_by_fw(instance);
3746
3747	megasas_sync_map_info(instance);
3748	spin_unlock_irqrestore(lock: instance->host->host_lock,
3749	flags);
3750
3751	break;
3752	}
3753	if (opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||
3754	opcode == MR_DCMD_CTRL_EVENT_GET) {
3755	spin_lock_irqsave(&poll_aen_lock, flags);
3756	megasas_poll_wait_aen = 0;
3757	spin_unlock_irqrestore(lock: &poll_aen_lock, flags);
3758	}
3759
3760	/* FW has an updated PD sequence */
3761	if ((opcode == MR_DCMD_SYSTEM_PD_MAP_GET_INFO) &&
3762	(cmd->frame->dcmd.mbox.b[0] == 1)) {
3763
3764	spin_lock_irqsave(instance->host->host_lock, flags);
3765	status = cmd->frame->hdr.cmd_status;
3766	instance->jbod_seq_cmd = NULL;
3767	megasas_return_cmd(instance, cmd);
3768
3769	if (status == MFI_STAT_OK) {
3770	instance->pd_seq_map_id++;
3771	/* Re-register a pd sync seq num cmd */
3772	if (megasas_sync_pd_seq_num(instance, pend: true))
3773	instance->use_seqnum_jbod_fp = false;
3774	} else
3775	instance->use_seqnum_jbod_fp = false;
3776
3777	spin_unlock_irqrestore(lock: instance->host->host_lock, flags);
3778	break;
3779	}
3780
3781	/*
3782	* See if got an event notification
3783	*/
3784	if (opcode == MR_DCMD_CTRL_EVENT_WAIT)
3785	megasas_service_aen(instance, cmd);
3786	else
3787	megasas_complete_int_cmd(instance, cmd);
3788
3789	break;
3790
3791	case MFI_CMD_ABORT:
3792	/*
3793	* Cmd issued to abort another cmd returned
3794	*/
3795	megasas_complete_abort(instance, cmd);
3796	break;
3797
3798	default:
3799	dev_info(&instance->pdev->dev, "Unknown command completed! [0x%X]\n",
3800	hdr->cmd);
3801	megasas_complete_int_cmd(instance, cmd);
3802	break;
3803	}
3804	}
3805
3806	/**
3807	* megasas_issue_pending_cmds_again - issue all pending cmds
3808	* in FW again because of the fw reset
3809	* @instance: Adapter soft state
3810	*/
3811	static inline void
3812	megasas_issue_pending_cmds_again(struct megasas_instance *instance)
3813	{
3814	struct megasas_cmd *cmd;
3815	struct list_head clist_local;
3816	union megasas_evt_class_locale class_locale;
3817	unsigned long flags;
3818	u32 seq_num;
3819
3820	INIT_LIST_HEAD(list: &clist_local);
3821	spin_lock_irqsave(&instance->hba_lock, flags);
3822	list_splice_init(list: &instance->internal_reset_pending_q, head: &clist_local);
3823	spin_unlock_irqrestore(lock: &instance->hba_lock, flags);
3824
3825	while (!list_empty(head: &clist_local)) {
3826	cmd = list_entry((&clist_local)->next,
3827	struct megasas_cmd, list);
3828	list_del_init(entry: &cmd->list);
3829
3830	if (cmd->sync_cmd || cmd->scmd) {
3831	dev_notice(&instance->pdev->dev, "command %p, %p:%d"
3832	"detected to be pending while HBA reset\n",
3833	cmd, cmd->scmd, cmd->sync_cmd);
3834
3835	cmd->retry_for_fw_reset++;
3836
3837	if (cmd->retry_for_fw_reset == 3) {
3838	dev_notice(&instance->pdev->dev, "cmd %p, %p:%d"
3839	"was tried multiple times during reset."
3840	"Shutting down the HBA\n",
3841	cmd, cmd->scmd, cmd->sync_cmd);
3842	instance->instancet->disable_intr(instance);
3843	atomic_set(v: &instance->fw_reset_no_pci_access, i: 1);
3844	megaraid_sas_kill_hba(instance);
3845	return;
3846	}
3847	}
3848
3849	if (cmd->sync_cmd == 1) {
3850	if (cmd->scmd) {
3851	dev_notice(&instance->pdev->dev, "unexpected"
3852	"cmd attached to internal command!\n");
3853	}
3854	dev_notice(&instance->pdev->dev, "%p synchronous cmd"
3855	"on the internal reset queue,"
3856	"issue it again.\n", cmd);
3857	cmd->cmd_status_drv = DCMD_INIT;
3858	instance->instancet->fire_cmd(instance,
3859	cmd->frame_phys_addr,
3860	0, instance->reg_set);
3861	} else if (cmd->scmd) {
3862	dev_notice(&instance->pdev->dev, "%p scsi cmd [%02x]"
3863	"detected on the internal queue, issue again.\n",
3864	cmd, cmd->scmd->cmnd[0]);
3865
3866	atomic_inc(v: &instance->fw_outstanding);
3867	instance->instancet->fire_cmd(instance,
3868	cmd->frame_phys_addr,
3869	cmd->frame_count-1, instance->reg_set);
3870	} else {
3871	dev_notice(&instance->pdev->dev, "%p unexpected cmd on the"
3872	"internal reset defer list while re-issue!!\n",
3873	cmd);
3874	}
3875	}
3876
3877	if (instance->aen_cmd) {
3878	dev_notice(&instance->pdev->dev, "aen_cmd in def process\n");
3879	megasas_return_cmd(instance, cmd: instance->aen_cmd);
3880
3881	instance->aen_cmd = NULL;
3882	}
3883
3884	/*
3885	* Initiate AEN (Asynchronous Event Notification)
3886	*/
3887	seq_num = instance->last_seq_num;
3888	class_locale.members.reserved = 0;
3889	class_locale.members.locale = MR_EVT_LOCALE_ALL;
3890	class_locale.members.class = MR_EVT_CLASS_DEBUG;
3891
3892	megasas_register_aen(instance, seq_num, class_locale_word: class_locale.word);
3893	}
3894
3895	/*
3896	* Move the internal reset pending commands to a deferred queue.
3897	*
3898	* We move the commands pending at internal reset time to a
3899	* pending queue. This queue would be flushed after successful
3900	* completion of the internal reset sequence. if the internal reset
3901	* did not complete in time, the kernel reset handler would flush
3902	* these commands.
3903	*/
3904	static void
3905	megasas_internal_reset_defer_cmds(struct megasas_instance *instance)
3906	{
3907	struct megasas_cmd *cmd;
3908	int i;
3909	u16 max_cmd = instance->max_fw_cmds;
3910	u32 defer_index;
3911	unsigned long flags;
3912
3913	defer_index = 0;
3914	spin_lock_irqsave(&instance->mfi_pool_lock, flags);
3915	for (i = 0; i < max_cmd; i++) {
3916	cmd = instance->cmd_list[i];
3917	if (cmd->sync_cmd == 1 || cmd->scmd) {
3918	dev_notice(&instance->pdev->dev, "moving cmd[%d]:%p:%d:%p"
3919	"on the defer queue as internal\n",
3920	defer_index, cmd, cmd->sync_cmd, cmd->scmd);
3921
3922	if (!list_empty(head: &cmd->list)) {
3923	dev_notice(&instance->pdev->dev, "ERROR while"
3924	" moving this cmd:%p, %d %p, it was"
3925	"discovered on some list?\n",
3926	cmd, cmd->sync_cmd, cmd->scmd);
3927
3928	list_del_init(entry: &cmd->list);
3929	}
3930	defer_index++;
3931	list_add_tail(new: &cmd->list,
3932	head: &instance->internal_reset_pending_q);
3933	}
3934	}
3935	spin_unlock_irqrestore(lock: &instance->mfi_pool_lock, flags);
3936	}
3937
3938
3939	static void
3940	process_fw_state_change_wq(struct work_struct *work)
3941	{
3942	struct megasas_instance *instance =
3943	container_of(work, struct megasas_instance, work_init);
3944	u32 wait;
3945	unsigned long flags;
3946
3947	if (atomic_read(v: &instance->adprecovery) != MEGASAS_ADPRESET_SM_INFAULT) {
3948	dev_notice(&instance->pdev->dev, "error, recovery st %x\n",
3949	atomic_read(&instance->adprecovery));
3950	return ;
3951	}
3952
3953	if (atomic_read(v: &instance->adprecovery) == MEGASAS_ADPRESET_SM_INFAULT) {
3954	dev_notice(&instance->pdev->dev, "FW detected to be in fault"
3955	"state, restarting it...\n");
3956
3957	instance->instancet->disable_intr(instance);
3958	atomic_set(v: &instance->fw_outstanding, i: 0);
3959
3960	atomic_set(v: &instance->fw_reset_no_pci_access, i: 1);
3961	instance->instancet->adp_reset(instance, instance->reg_set);
3962	atomic_set(v: &instance->fw_reset_no_pci_access, i: 0);
3963
3964	dev_notice(&instance->pdev->dev, "FW restarted successfully,"
3965	"initiating next stage...\n");
3966
3967	dev_notice(&instance->pdev->dev, "HBA recovery state machine,"
3968	"state 2 starting...\n");
3969
3970	/* waiting for about 20 second before start the second init */
3971	for (wait = 0; wait < 30; wait++) {
3972	msleep(msecs: 1000);
3973	}
3974
3975	if (megasas_transition_to_ready(instance, ocr: 1)) {
3976	dev_notice(&instance->pdev->dev, "adapter not ready\n");
3977
3978	atomic_set(v: &instance->fw_reset_no_pci_access, i: 1);
3979	megaraid_sas_kill_hba(instance);
3980	return ;
3981	}
3982
3983	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
3984	(instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
3985	(instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)
3986	) {
3987	*instance->consumer = *instance->producer;
3988	} else {
3989	*instance->consumer = 0;
3990	*instance->producer = 0;
3991	}
3992
3993	megasas_issue_init_mfi(instance);
3994
3995	spin_lock_irqsave(&instance->hba_lock, flags);
3996	atomic_set(v: &instance->adprecovery, i: MEGASAS_HBA_OPERATIONAL);
3997	spin_unlock_irqrestore(lock: &instance->hba_lock, flags);
3998	instance->instancet->enable_intr(instance);
3999
4000	megasas_issue_pending_cmds_again(instance);
4001	instance->issuepend_done = 1;
4002	}
4003	}
4004
4005	/**
4006	* megasas_deplete_reply_queue - Processes all completed commands
4007	* @instance: Adapter soft state
4008	* @alt_status: Alternate status to be returned to
4009	* SCSI mid-layer instead of the status
4010	* returned by the FW
4011	* Note: this must be called with hba lock held
4012	*/
4013	static int
4014	megasas_deplete_reply_queue(struct megasas_instance *instance,
4015	u8 alt_status)
4016	{
4017	u32 mfiStatus;
4018	u32 fw_state;
4019
4020	if (instance->instancet->check_reset(instance, instance->reg_set) == 1)
4021	return IRQ_HANDLED;
4022
4023	mfiStatus = instance->instancet->clear_intr(instance);
4024	if (mfiStatus == 0) {
4025	/* Hardware may not set outbound_intr_status in MSI-X mode */
4026	if (!instance->msix_vectors)
4027	return IRQ_NONE;
4028	}
4029
4030	instance->mfiStatus = mfiStatus;
4031
4032	if ((mfiStatus & MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE)) {
4033	fw_state = instance->instancet->read_fw_status_reg(
4034	instance) & MFI_STATE_MASK;
4035
4036	if (fw_state != MFI_STATE_FAULT) {
4037	dev_notice(&instance->pdev->dev, "fw state:%x\n",
4038	fw_state);
4039	}
4040
4041	if ((fw_state == MFI_STATE_FAULT) &&
4042	(instance->disableOnlineCtrlReset == 0)) {
4043	dev_notice(&instance->pdev->dev, "wait adp restart\n");
4044
4045	if ((instance->pdev->device ==
4046	PCI_DEVICE_ID_LSI_SAS1064R) ||
4047	(instance->pdev->device ==
4048	PCI_DEVICE_ID_DELL_PERC5) ||
4049	(instance->pdev->device ==
4050	PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
4051
4052	*instance->consumer =
4053	cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
4054	}
4055
4056
4057	instance->instancet->disable_intr(instance);
4058	atomic_set(v: &instance->adprecovery, i: MEGASAS_ADPRESET_SM_INFAULT);
4059	instance->issuepend_done = 0;
4060
4061	atomic_set(v: &instance->fw_outstanding, i: 0);
4062	megasas_internal_reset_defer_cmds(instance);
4063
4064	dev_notice(&instance->pdev->dev, "fwState=%x, stage:%d\n",
4065	fw_state, atomic_read(&instance->adprecovery));
4066
4067	schedule_work(work: &instance->work_init);
4068	return IRQ_HANDLED;
4069
4070	} else {
4071	dev_notice(&instance->pdev->dev, "fwstate:%x, dis_OCR=%x\n",
4072	fw_state, instance->disableOnlineCtrlReset);
4073	}
4074	}
4075
4076	tasklet_schedule(t: &instance->isr_tasklet);
4077	return IRQ_HANDLED;
4078	}
4079
4080	/**
4081	* megasas_isr - isr entry point
4082	* @irq: IRQ number
4083	* @devp: IRQ context address
4084	*/
4085	static irqreturn_t megasas_isr(int irq, void *devp)
4086	{
4087	struct megasas_irq_context *irq_context = devp;
4088	struct megasas_instance *instance = irq_context->instance;
4089	unsigned long flags;
4090	irqreturn_t rc;
4091
4092	if (atomic_read(v: &instance->fw_reset_no_pci_access))
4093	return IRQ_HANDLED;
4094
4095	spin_lock_irqsave(&instance->hba_lock, flags);
4096	rc = megasas_deplete_reply_queue(instance, alt_status: DID_OK);
4097	spin_unlock_irqrestore(lock: &instance->hba_lock, flags);
4098
4099	return rc;
4100	}
4101
4102	/**
4103	* megasas_transition_to_ready - Move the FW to READY state
4104	* @instance: Adapter soft state
4105	* @ocr: Adapter reset state
4106	*
4107	* During the initialization, FW passes can potentially be in any one of
4108	* several possible states. If the FW in operational, waiting-for-handshake
4109	* states, driver must take steps to bring it to ready state. Otherwise, it
4110	* has to wait for the ready state.
4111	*/
4112	int
4113	megasas_transition_to_ready(struct megasas_instance *instance, int ocr)
4114	{
4115	int i;
4116	u8 max_wait;
4117	u32 fw_state;
4118	u32 abs_state, curr_abs_state;
4119
4120	abs_state = instance->instancet->read_fw_status_reg(instance);
4121	fw_state = abs_state & MFI_STATE_MASK;
4122
4123	if (fw_state != MFI_STATE_READY)
4124	dev_info(&instance->pdev->dev, "Waiting for FW to come to ready"
4125	" state\n");
4126
4127	while (fw_state != MFI_STATE_READY) {
4128
4129	switch (fw_state) {
4130
4131	case MFI_STATE_FAULT:
4132	dev_printk(KERN_ERR, &instance->pdev->dev,
4133	"FW in FAULT state, Fault code:0x%x subcode:0x%x func:%s\n",
4134	abs_state & MFI_STATE_FAULT_CODE,
4135	abs_state & MFI_STATE_FAULT_SUBCODE, __func__);
4136	if (ocr) {
4137	max_wait = MEGASAS_RESET_WAIT_TIME;
4138	break;
4139	} else {
4140	dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4141	megasas_dump_reg_set(reg_set: instance->reg_set);
4142	return -ENODEV;
4143	}
4144
4145	case MFI_STATE_WAIT_HANDSHAKE:
4146	/*
4147	* Set the CLR bit in inbound doorbell
4148	*/
4149	if ((instance->pdev->device ==
4150	PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
4151	(instance->pdev->device ==
4152	PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
4153	(instance->adapter_type != MFI_SERIES))
4154	writel(
4155	MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
4156	addr: &instance->reg_set->doorbell);
4157	else
4158	writel(
4159	MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
4160	addr: &instance->reg_set->inbound_doorbell);
4161
4162	max_wait = MEGASAS_RESET_WAIT_TIME;
4163	break;
4164
4165	case MFI_STATE_BOOT_MESSAGE_PENDING:
4166	if ((instance->pdev->device ==
4167	PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
4168	(instance->pdev->device ==
4169	PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
4170	(instance->adapter_type != MFI_SERIES))
4171	writel(MFI_INIT_HOTPLUG,
4172	addr: &instance->reg_set->doorbell);
4173	else
4174	writel(MFI_INIT_HOTPLUG,
4175	addr: &instance->reg_set->inbound_doorbell);
4176
4177	max_wait = MEGASAS_RESET_WAIT_TIME;
4178	break;
4179
4180	case MFI_STATE_OPERATIONAL:
4181	/*
4182	* Bring it to READY state; assuming max wait 10 secs
4183	*/
4184	instance->instancet->disable_intr(instance);
4185	if ((instance->pdev->device ==
4186	PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
4187	(instance->pdev->device ==
4188	PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
4189	(instance->adapter_type != MFI_SERIES)) {
4190	writel(MFI_RESET_FLAGS,
4191	addr: &instance->reg_set->doorbell);
4192
4193	if (instance->adapter_type != MFI_SERIES) {
4194	for (i = 0; i < (10 * 1000); i += 20) {
4195	if (megasas_readl(
4196	instance,
4197	addr: &instance->
4198	reg_set->
4199	doorbell) & 1)
4200	msleep(msecs: 20);
4201	else
4202	break;
4203	}
4204	}
4205	} else
4206	writel(MFI_RESET_FLAGS,
4207	addr: &instance->reg_set->inbound_doorbell);
4208
4209	max_wait = MEGASAS_RESET_WAIT_TIME;
4210	break;
4211
4212	case MFI_STATE_UNDEFINED:
4213	/*
4214	* This state should not last for more than 2 seconds
4215	*/
4216	max_wait = MEGASAS_RESET_WAIT_TIME;
4217	break;
4218
4219	case MFI_STATE_BB_INIT:
4220	max_wait = MEGASAS_RESET_WAIT_TIME;
4221	break;
4222
4223	case MFI_STATE_FW_INIT:
4224	max_wait = MEGASAS_RESET_WAIT_TIME;
4225	break;
4226
4227	case MFI_STATE_FW_INIT_2:
4228	max_wait = MEGASAS_RESET_WAIT_TIME;
4229	break;
4230
4231	case MFI_STATE_DEVICE_SCAN:
4232	max_wait = MEGASAS_RESET_WAIT_TIME;
4233	break;
4234
4235	case MFI_STATE_FLUSH_CACHE:
4236	max_wait = MEGASAS_RESET_WAIT_TIME;
4237	break;
4238
4239	default:
4240	dev_printk(KERN_DEBUG, &instance->pdev->dev, "Unknown state 0x%x\n",
4241	fw_state);
4242	dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4243	megasas_dump_reg_set(reg_set: instance->reg_set);
4244	return -ENODEV;
4245	}
4246
4247	/*
4248	* The cur_state should not last for more than max_wait secs
4249	*/
4250	for (i = 0; i < max_wait * 50; i++) {
4251	curr_abs_state = instance->instancet->
4252	read_fw_status_reg(instance);
4253
4254	if (abs_state == curr_abs_state) {
4255	msleep(msecs: 20);
4256	} else
4257	break;
4258	}
4259
4260	/*
4261	* Return error if fw_state hasn't changed after max_wait
4262	*/
4263	if (curr_abs_state == abs_state) {
4264	dev_printk(KERN_DEBUG, &instance->pdev->dev, "FW state [%d] hasn't changed "
4265	"in %d secs\n", fw_state, max_wait);
4266	dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4267	megasas_dump_reg_set(reg_set: instance->reg_set);
4268	return -ENODEV;
4269	}
4270
4271	abs_state = curr_abs_state;
4272	fw_state = curr_abs_state & MFI_STATE_MASK;
4273	}
4274	dev_info(&instance->pdev->dev, "FW now in Ready state\n");
4275
4276	return 0;
4277	}
4278
4279	/**
4280	* megasas_teardown_frame_pool - Destroy the cmd frame DMA pool
4281	* @instance: Adapter soft state
4282	*/
4283	static void megasas_teardown_frame_pool(struct megasas_instance *instance)
4284	{
4285	int i;
4286	u16 max_cmd = instance->max_mfi_cmds;
4287	struct megasas_cmd *cmd;
4288
4289	if (!instance->frame_dma_pool)
4290	return;
4291
4292	/*
4293	* Return all frames to pool
4294	*/
4295	for (i = 0; i < max_cmd; i++) {
4296
4297	cmd = instance->cmd_list[i];
4298
4299	if (cmd->frame)
4300	dma_pool_free(pool: instance->frame_dma_pool, vaddr: cmd->frame,
4301	addr: cmd->frame_phys_addr);
4302
4303	if (cmd->sense)
4304	dma_pool_free(pool: instance->sense_dma_pool, vaddr: cmd->sense,
4305	addr: cmd->sense_phys_addr);
4306	}
4307
4308	/*
4309	* Now destroy the pool itself
4310	*/
4311	dma_pool_destroy(pool: instance->frame_dma_pool);
4312	dma_pool_destroy(pool: instance->sense_dma_pool);
4313
4314	instance->frame_dma_pool = NULL;
4315	instance->sense_dma_pool = NULL;
4316	}
4317
4318	/**
4319	* megasas_create_frame_pool - Creates DMA pool for cmd frames
4320	* @instance: Adapter soft state
4321	*
4322	* Each command packet has an embedded DMA memory buffer that is used for
4323	* filling MFI frame and the SG list that immediately follows the frame. This
4324	* function creates those DMA memory buffers for each command packet by using
4325	* PCI pool facility.
4326	*/
4327	static int megasas_create_frame_pool(struct megasas_instance *instance)
4328	{
4329	int i;
4330	u16 max_cmd;
4331	u32 frame_count;
4332	struct megasas_cmd *cmd;
4333
4334	max_cmd = instance->max_mfi_cmds;
4335
4336	/*
4337	* For MFI controllers.
4338	* max_num_sge = 60
4339	* max_sge_sz = 16 byte (sizeof megasas_sge_skinny)
4340	* Total 960 byte (15 MFI frame of 64 byte)
4341	*
4342	* Fusion adapter require only 3 extra frame.
4343	* max_num_sge = 16 (defined as MAX_IOCTL_SGE)
4344	* max_sge_sz = 12 byte (sizeof megasas_sge64)
4345	* Total 192 byte (3 MFI frame of 64 byte)
4346	*/
4347	frame_count = (instance->adapter_type == MFI_SERIES) ?
4348	(15 + 1) : (3 + 1);
4349	instance->mfi_frame_size = MEGAMFI_FRAME_SIZE * frame_count;
4350	/*
4351	* Use DMA pool facility provided by PCI layer
4352	*/
4353	instance->frame_dma_pool = dma_pool_create(name: "megasas frame pool",
4354	dev: &instance->pdev->dev,
4355	size: instance->mfi_frame_size, align: 256, allocation: 0);
4356
4357	if (!instance->frame_dma_pool) {
4358	dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup frame pool\n");
4359	return -ENOMEM;
4360	}
4361
4362	instance->sense_dma_pool = dma_pool_create(name: "megasas sense pool",
4363	dev: &instance->pdev->dev, size: 128,
4364	align: 4, allocation: 0);
4365
4366	if (!instance->sense_dma_pool) {
4367	dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup sense pool\n");
4368
4369	dma_pool_destroy(pool: instance->frame_dma_pool);
4370	instance->frame_dma_pool = NULL;
4371
4372	return -ENOMEM;
4373	}
4374
4375	/*
4376	* Allocate and attach a frame to each of the commands in cmd_list.
4377	* By making cmd->index as the context instead of the &cmd, we can
4378	* always use 32bit context regardless of the architecture
4379	*/
4380	for (i = 0; i < max_cmd; i++) {
4381
4382	cmd = instance->cmd_list[i];
4383
4384	cmd->frame = dma_pool_zalloc(pool: instance->frame_dma_pool,
4385	GFP_KERNEL, handle: &cmd->frame_phys_addr);
4386
4387	cmd->sense = dma_pool_alloc(pool: instance->sense_dma_pool,
4388	GFP_KERNEL, handle: &cmd->sense_phys_addr);
4389
4390	/*
4391	* megasas_teardown_frame_pool() takes care of freeing
4392	* whatever has been allocated
4393	*/
4394	if (!cmd->frame || !cmd->sense) {
4395	dev_printk(KERN_DEBUG, &instance->pdev->dev, "dma_pool_alloc failed\n");
4396	megasas_teardown_frame_pool(instance);
4397	return -ENOMEM;
4398	}
4399
4400	cmd->frame->io.context = cpu_to_le32(cmd->index);
4401	cmd->frame->io.pad_0 = 0;
4402	if ((instance->adapter_type == MFI_SERIES) && reset_devices)
4403	cmd->frame->hdr.cmd = MFI_CMD_INVALID;
4404	}
4405
4406	return 0;
4407	}
4408
4409	/**
4410	* megasas_free_cmds - Free all the cmds in the free cmd pool
4411	* @instance: Adapter soft state
4412	*/
4413	void megasas_free_cmds(struct megasas_instance *instance)
4414	{
4415	int i;
4416
4417	/* First free the MFI frame pool */
4418	megasas_teardown_frame_pool(instance);
4419
4420	/* Free all the commands in the cmd_list */
4421	for (i = 0; i < instance->max_mfi_cmds; i++)
4422
4423	kfree(objp: instance->cmd_list[i]);
4424
4425	/* Free the cmd_list buffer itself */
4426	kfree(objp: instance->cmd_list);
4427	instance->cmd_list = NULL;
4428
4429	INIT_LIST_HEAD(list: &instance->cmd_pool);
4430	}
4431
4432	/**
4433	* megasas_alloc_cmds - Allocates the command packets
4434	* @instance: Adapter soft state
4435	*
4436	* Each command that is issued to the FW, whether IO commands from the OS or
4437	* internal commands like IOCTLs, are wrapped in local data structure called
4438	* megasas_cmd. The frame embedded in this megasas_cmd is actually issued to
4439	* the FW.
4440	*
4441	* Each frame has a 32-bit field called context (tag). This context is used
4442	* to get back the megasas_cmd from the frame when a frame gets completed in
4443	* the ISR. Typically the address of the megasas_cmd itself would be used as
4444	* the context. But we wanted to keep the differences between 32 and 64 bit
4445	* systems to the mininum. We always use 32 bit integers for the context. In
4446	* this driver, the 32 bit values are the indices into an array cmd_list.
4447	* This array is used only to look up the megasas_cmd given the context. The
4448	* free commands themselves are maintained in a linked list called cmd_pool.
4449	*/
4450	int megasas_alloc_cmds(struct megasas_instance *instance)
4451	{
4452	int i;
4453	int j;
4454	u16 max_cmd;
4455	struct megasas_cmd *cmd;
4456
4457	max_cmd = instance->max_mfi_cmds;
4458
4459	/*
4460	* instance->cmd_list is an array of struct megasas_cmd pointers.
4461	* Allocate the dynamic array first and then allocate individual
4462	* commands.
4463	*/
4464	instance->cmd_list = kcalloc(n: max_cmd, size: sizeof(struct megasas_cmd*), GFP_KERNEL);
4465
4466	if (!instance->cmd_list) {
4467	dev_printk(KERN_DEBUG, &instance->pdev->dev, "out of memory\n");
4468	return -ENOMEM;
4469	}
4470
4471	for (i = 0; i < max_cmd; i++) {
4472	instance->cmd_list[i] = kmalloc(size: sizeof(struct megasas_cmd),
4473	GFP_KERNEL);
4474
4475	if (!instance->cmd_list[i]) {
4476
4477	for (j = 0; j < i; j++)
4478	kfree(objp: instance->cmd_list[j]);
4479
4480	kfree(objp: instance->cmd_list);
4481	instance->cmd_list = NULL;
4482
4483	return -ENOMEM;
4484	}
4485	}
4486
4487	for (i = 0; i < max_cmd; i++) {
4488	cmd = instance->cmd_list[i];
4489	memset(cmd, 0, sizeof(struct megasas_cmd));
4490	cmd->index = i;
4491	cmd->scmd = NULL;
4492	cmd->instance = instance;
4493
4494	list_add_tail(new: &cmd->list, head: &instance->cmd_pool);
4495	}
4496
4497	/*
4498	* Create a frame pool and assign one frame to each cmd
4499	*/
4500	if (megasas_create_frame_pool(instance)) {
4501	dev_printk(KERN_DEBUG, &instance->pdev->dev, "Error creating frame DMA pool\n");
4502	megasas_free_cmds(instance);
4503	return -ENOMEM;
4504	}
4505
4506	return 0;
4507	}
4508
4509	/*
4510	* dcmd_timeout_ocr_possible - Check if OCR is possible based on Driver/FW state.
4511	* @instance: Adapter soft state
4512	*
4513	* Return 0 for only Fusion adapter, if driver load/unload is not in progress
4514	* or FW is not under OCR.
4515	*/
4516	inline int
4517	dcmd_timeout_ocr_possible(struct megasas_instance *instance) {
4518
4519	if (instance->adapter_type == MFI_SERIES)
4520	return KILL_ADAPTER;
4521	else if (instance->unload ||
4522	test_bit(MEGASAS_FUSION_OCR_NOT_POSSIBLE,
4523	&instance->reset_flags))
4524	return IGNORE_TIMEOUT;
4525	else
4526	return INITIATE_OCR;
4527	}
4528
4529	static void
4530	megasas_get_pd_info(struct megasas_instance *instance, struct scsi_device *sdev)
4531	{
4532	int ret;
4533	struct megasas_cmd *cmd;
4534	struct megasas_dcmd_frame *dcmd;
4535
4536	struct MR_PRIV_DEVICE *mr_device_priv_data;
4537	u16 device_id = 0;
4538
4539	device_id = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) + sdev->id;
4540	cmd = megasas_get_cmd(instance);
4541
4542	if (!cmd) {
4543	dev_err(&instance->pdev->dev, "Failed to get cmd %s\n", __func__);
4544	return;
4545	}
4546
4547	dcmd = &cmd->frame->dcmd;
4548
4549	memset(instance->pd_info, 0, sizeof(*instance->pd_info));
4550	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4551
4552	dcmd->mbox.s[0] = cpu_to_le16(device_id);
4553	dcmd->cmd = MFI_CMD_DCMD;
4554	dcmd->cmd_status = 0xFF;
4555	dcmd->sge_count = 1;
4556	dcmd->flags = MFI_FRAME_DIR_READ;
4557	dcmd->timeout = 0;
4558	dcmd->pad_0 = 0;
4559	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_PD_INFO));
4560	dcmd->opcode = cpu_to_le32(MR_DCMD_PD_GET_INFO);
4561
4562	megasas_set_dma_settings(instance, dcmd, dma_addr: instance->pd_info_h,
4563	dma_len: sizeof(struct MR_PD_INFO));
4564
4565	if ((instance->adapter_type != MFI_SERIES) &&
4566	!instance->mask_interrupts)
4567	ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
4568	else
4569	ret = megasas_issue_polled(instance, cmd);
4570
4571	switch (ret) {
4572	case DCMD_SUCCESS:
4573	mr_device_priv_data = sdev->hostdata;
4574	le16_to_cpus((u16 *)&instance->pd_info->state.ddf.pdType);
4575	mr_device_priv_data->interface_type =
4576	instance->pd_info->state.ddf.pdType.intf;
4577	break;
4578
4579	case DCMD_TIMEOUT:
4580
4581	switch (dcmd_timeout_ocr_possible(instance)) {
4582	case INITIATE_OCR:
4583	cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4584	mutex_unlock(lock: &instance->reset_mutex);
4585	megasas_reset_fusion(shost: instance->host,
4586	reason: MFI_IO_TIMEOUT_OCR);
4587	mutex_lock(&instance->reset_mutex);
4588	break;
4589	case KILL_ADAPTER:
4590	megaraid_sas_kill_hba(instance);
4591	break;
4592	case IGNORE_TIMEOUT:
4593	dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4594	__func__, __LINE__);
4595	break;
4596	}
4597
4598	break;
4599	}
4600
4601	if (ret != DCMD_TIMEOUT)
4602	megasas_return_cmd(instance, cmd);
4603
4604	return;
4605	}
4606	/*
4607	* megasas_get_pd_list_info - Returns FW's pd_list structure
4608	* @instance: Adapter soft state
4609	* @pd_list: pd_list structure
4610	*
4611	* Issues an internal command (DCMD) to get the FW's controller PD
4612	* list structure. This information is mainly used to find out SYSTEM
4613	* supported by the FW.
4614	*/
4615	static int
4616	megasas_get_pd_list(struct megasas_instance *instance)
4617	{
4618	int ret = 0, pd_index = 0;
4619	struct megasas_cmd *cmd;
4620	struct megasas_dcmd_frame *dcmd;
4621	struct MR_PD_LIST *ci;
4622	struct MR_PD_ADDRESS *pd_addr;
4623
4624	if (instance->pd_list_not_supported) {
4625	dev_info(&instance->pdev->dev, "MR_DCMD_PD_LIST_QUERY "
4626	"not supported by firmware\n");
4627	return ret;
4628	}
4629
4630	ci = instance->pd_list_buf;
4631
4632	cmd = megasas_get_cmd(instance);
4633
4634	if (!cmd) {
4635	dev_printk(KERN_DEBUG, &instance->pdev->dev, "(get_pd_list): Failed to get cmd\n");
4636	return -ENOMEM;
4637	}
4638
4639	dcmd = &cmd->frame->dcmd;
4640
4641	memset(ci, 0, sizeof(*ci));
4642	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4643
4644	dcmd->mbox.b[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST;
4645	dcmd->mbox.b[1] = 0;
4646	dcmd->cmd = MFI_CMD_DCMD;
4647	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
4648	dcmd->sge_count = 1;
4649	dcmd->flags = MFI_FRAME_DIR_READ;
4650	dcmd->timeout = 0;
4651	dcmd->pad_0 = 0;
4652	dcmd->data_xfer_len = cpu_to_le32(MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST));
4653	dcmd->opcode = cpu_to_le32(MR_DCMD_PD_LIST_QUERY);
4654
4655	megasas_set_dma_settings(instance, dcmd, dma_addr: instance->pd_list_buf_h,
4656	dma_len: (MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST)));
4657
4658	if ((instance->adapter_type != MFI_SERIES) &&
4659	!instance->mask_interrupts)
4660	ret = megasas_issue_blocked_cmd(instance, cmd,
4661	MFI_IO_TIMEOUT_SECS);
4662	else
4663	ret = megasas_issue_polled(instance, cmd);
4664
4665	switch (ret) {
4666	case DCMD_FAILED:
4667	dev_info(&instance->pdev->dev, "MR_DCMD_PD_LIST_QUERY "
4668	"failed/not supported by firmware\n");
4669
4670	if (instance->adapter_type != MFI_SERIES)
4671	megaraid_sas_kill_hba(instance);
4672	else
4673	instance->pd_list_not_supported = 1;
4674	break;
4675	case DCMD_TIMEOUT:
4676
4677	switch (dcmd_timeout_ocr_possible(instance)) {
4678	case INITIATE_OCR:
4679	cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4680	/*
4681	* DCMD failed from AEN path.
4682	* AEN path already hold reset_mutex to avoid PCI access
4683	* while OCR is in progress.
4684	*/
4685	mutex_unlock(lock: &instance->reset_mutex);
4686	megasas_reset_fusion(shost: instance->host,
4687	reason: MFI_IO_TIMEOUT_OCR);
4688	mutex_lock(&instance->reset_mutex);
4689	break;
4690	case KILL_ADAPTER:
4691	megaraid_sas_kill_hba(instance);
4692	break;
4693	case IGNORE_TIMEOUT:
4694	dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d \n",
4695	__func__, __LINE__);
4696	break;
4697	}
4698
4699	break;
4700
4701	case DCMD_SUCCESS:
4702	pd_addr = ci->addr;
4703	if (megasas_dbg_lvl & LD_PD_DEBUG)
4704	dev_info(&instance->pdev->dev, "%s, sysPD count: 0x%x\n",
4705	__func__, le32_to_cpu(ci->count));
4706
4707	if ((le32_to_cpu(ci->count) >
4708	(MEGASAS_MAX_PD_CHANNELS * MEGASAS_MAX_DEV_PER_CHANNEL)))
4709	break;
4710
4711	memset(instance->local_pd_list, 0,
4712	MEGASAS_MAX_PD * sizeof(struct megasas_pd_list));
4713
4714	for (pd_index = 0; pd_index < le32_to_cpu(ci->count); pd_index++) {
4715	instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].tid =
4716	le16_to_cpu(pd_addr->deviceId);
4717	instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveType =
4718	pd_addr->scsiDevType;
4719	instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveState =
4720	MR_PD_STATE_SYSTEM;
4721	if (megasas_dbg_lvl & LD_PD_DEBUG)
4722	dev_info(&instance->pdev->dev,
4723	"PD%d: targetID: 0x%03x deviceType:0x%x\n",
4724	pd_index, le16_to_cpu(pd_addr->deviceId),
4725	pd_addr->scsiDevType);
4726	pd_addr++;
4727	}
4728
4729	memcpy(instance->pd_list, instance->local_pd_list,
4730	sizeof(instance->pd_list));
4731	break;
4732
4733	}
4734
4735	if (ret != DCMD_TIMEOUT)
4736	megasas_return_cmd(instance, cmd);
4737
4738	return ret;
4739	}
4740
4741	/*
4742	* megasas_get_ld_list_info - Returns FW's ld_list structure
4743	* @instance: Adapter soft state
4744	* @ld_list: ld_list structure
4745	*
4746	* Issues an internal command (DCMD) to get the FW's controller PD
4747	* list structure. This information is mainly used to find out SYSTEM
4748	* supported by the FW.
4749	*/
4750	static int
4751	megasas_get_ld_list(struct megasas_instance *instance)
4752	{
4753	int ret = 0, ld_index = 0, ids = 0;
4754	struct megasas_cmd *cmd;
4755	struct megasas_dcmd_frame *dcmd;
4756	struct MR_LD_LIST *ci;
4757	dma_addr_t ci_h = 0;
4758	u32 ld_count;
4759
4760	ci = instance->ld_list_buf;
4761	ci_h = instance->ld_list_buf_h;
4762
4763	cmd = megasas_get_cmd(instance);
4764
4765	if (!cmd) {
4766	dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_list: Failed to get cmd\n");
4767	return -ENOMEM;
4768	}
4769
4770	dcmd = &cmd->frame->dcmd;
4771
4772	memset(ci, 0, sizeof(*ci));
4773	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4774
4775	if (instance->supportmax256vd)
4776	dcmd->mbox.b[0] = 1;
4777	dcmd->cmd = MFI_CMD_DCMD;
4778	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
4779	dcmd->sge_count = 1;
4780	dcmd->flags = MFI_FRAME_DIR_READ;
4781	dcmd->timeout = 0;
4782	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_LIST));
4783	dcmd->opcode = cpu_to_le32(MR_DCMD_LD_GET_LIST);
4784	dcmd->pad_0 = 0;
4785
4786	megasas_set_dma_settings(instance, dcmd, dma_addr: ci_h,
4787	dma_len: sizeof(struct MR_LD_LIST));
4788
4789	if ((instance->adapter_type != MFI_SERIES) &&
4790	!instance->mask_interrupts)
4791	ret = megasas_issue_blocked_cmd(instance, cmd,
4792	MFI_IO_TIMEOUT_SECS);
4793	else
4794	ret = megasas_issue_polled(instance, cmd);
4795
4796	ld_count = le32_to_cpu(ci->ldCount);
4797
4798	switch (ret) {
4799	case DCMD_FAILED:
4800	megaraid_sas_kill_hba(instance);
4801	break;
4802	case DCMD_TIMEOUT:
4803
4804	switch (dcmd_timeout_ocr_possible(instance)) {
4805	case INITIATE_OCR:
4806	cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4807	/*
4808	* DCMD failed from AEN path.
4809	* AEN path already hold reset_mutex to avoid PCI access
4810	* while OCR is in progress.
4811	*/
4812	mutex_unlock(lock: &instance->reset_mutex);
4813	megasas_reset_fusion(shost: instance->host,
4814	reason: MFI_IO_TIMEOUT_OCR);
4815	mutex_lock(&instance->reset_mutex);
4816	break;
4817	case KILL_ADAPTER:
4818	megaraid_sas_kill_hba(instance);
4819	break;
4820	case IGNORE_TIMEOUT:
4821	dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4822	__func__, __LINE__);
4823	break;
4824	}
4825
4826	break;
4827
4828	case DCMD_SUCCESS:
4829	if (megasas_dbg_lvl & LD_PD_DEBUG)
4830	dev_info(&instance->pdev->dev, "%s, LD count: 0x%x\n",
4831	__func__, ld_count);
4832
4833	if (ld_count > instance->fw_supported_vd_count)
4834	break;
4835
4836	memset(instance->ld_ids, 0xff, MAX_LOGICAL_DRIVES_EXT);
4837
4838	for (ld_index = 0; ld_index < ld_count; ld_index++) {
4839	if (ci->ldList[ld_index].state != 0) {
4840	ids = ci->ldList[ld_index].ref.targetId;
4841	instance->ld_ids[ids] = ci->ldList[ld_index].ref.targetId;
4842	if (megasas_dbg_lvl & LD_PD_DEBUG)
4843	dev_info(&instance->pdev->dev,
4844	"LD%d: targetID: 0x%03x\n",
4845	ld_index, ids);
4846	}
4847	}
4848
4849	break;
4850	}
4851
4852	if (ret != DCMD_TIMEOUT)
4853	megasas_return_cmd(instance, cmd);
4854
4855	return ret;
4856	}
4857
4858	/**
4859	* megasas_ld_list_query - Returns FW's ld_list structure
4860	* @instance: Adapter soft state
4861	* @query_type: ld_list structure type
4862	*
4863	* Issues an internal command (DCMD) to get the FW's controller PD
4864	* list structure. This information is mainly used to find out SYSTEM
4865	* supported by the FW.
4866	*/
4867	static int
4868	megasas_ld_list_query(struct megasas_instance *instance, u8 query_type)
4869	{
4870	int ret = 0, ld_index = 0, ids = 0;
4871	struct megasas_cmd *cmd;
4872	struct megasas_dcmd_frame *dcmd;
4873	struct MR_LD_TARGETID_LIST *ci;
4874	dma_addr_t ci_h = 0;
4875	u32 tgtid_count;
4876
4877	ci = instance->ld_targetid_list_buf;
4878	ci_h = instance->ld_targetid_list_buf_h;
4879
4880	cmd = megasas_get_cmd(instance);
4881
4882	if (!cmd) {
4883	dev_warn(&instance->pdev->dev,
4884	"megasas_ld_list_query: Failed to get cmd\n");
4885	return -ENOMEM;
4886	}
4887
4888	dcmd = &cmd->frame->dcmd;
4889
4890	memset(ci, 0, sizeof(*ci));
4891	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4892
4893	dcmd->mbox.b[0] = query_type;
4894	if (instance->supportmax256vd)
4895	dcmd->mbox.b[2] = 1;
4896
4897	dcmd->cmd = MFI_CMD_DCMD;
4898	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
4899	dcmd->sge_count = 1;
4900	dcmd->flags = MFI_FRAME_DIR_READ;
4901	dcmd->timeout = 0;
4902	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_TARGETID_LIST));
4903	dcmd->opcode = cpu_to_le32(MR_DCMD_LD_LIST_QUERY);
4904	dcmd->pad_0 = 0;
4905
4906	megasas_set_dma_settings(instance, dcmd, dma_addr: ci_h,
4907	dma_len: sizeof(struct MR_LD_TARGETID_LIST));
4908
4909	if ((instance->adapter_type != MFI_SERIES) &&
4910	!instance->mask_interrupts)
4911	ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
4912	else
4913	ret = megasas_issue_polled(instance, cmd);
4914
4915	switch (ret) {
4916	case DCMD_FAILED:
4917	dev_info(&instance->pdev->dev,
4918	"DCMD not supported by firmware - %s %d\n",
4919	__func__, __LINE__);
4920	ret = megasas_get_ld_list(instance);
4921	break;
4922	case DCMD_TIMEOUT:
4923	switch (dcmd_timeout_ocr_possible(instance)) {
4924	case INITIATE_OCR:
4925	cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4926	/*
4927	* DCMD failed from AEN path.
4928	* AEN path already hold reset_mutex to avoid PCI access
4929	* while OCR is in progress.
4930	*/
4931	mutex_unlock(lock: &instance->reset_mutex);
4932	megasas_reset_fusion(shost: instance->host,
4933	reason: MFI_IO_TIMEOUT_OCR);
4934	mutex_lock(&instance->reset_mutex);
4935	break;
4936	case KILL_ADAPTER:
4937	megaraid_sas_kill_hba(instance);
4938	break;
4939	case IGNORE_TIMEOUT:
4940	dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4941	__func__, __LINE__);
4942	break;
4943	}
4944
4945	break;
4946	case DCMD_SUCCESS:
4947	tgtid_count = le32_to_cpu(ci->count);
4948
4949	if (megasas_dbg_lvl & LD_PD_DEBUG)
4950	dev_info(&instance->pdev->dev, "%s, LD count: 0x%x\n",
4951	__func__, tgtid_count);
4952
4953	if ((tgtid_count > (instance->fw_supported_vd_count)))
4954	break;
4955
4956	memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
4957	for (ld_index = 0; ld_index < tgtid_count; ld_index++) {
4958	ids = ci->targetId[ld_index];
4959	instance->ld_ids[ids] = ci->targetId[ld_index];
4960	if (megasas_dbg_lvl & LD_PD_DEBUG)
4961	dev_info(&instance->pdev->dev, "LD%d: targetID: 0x%03x\n",
4962	ld_index, ci->targetId[ld_index]);
4963	}
4964
4965	break;
4966	}
4967
4968	if (ret != DCMD_TIMEOUT)
4969	megasas_return_cmd(instance, cmd);
4970
4971	return ret;
4972	}
4973
4974	/**
4975	* megasas_host_device_list_query
4976	* dcmd.opcode - MR_DCMD_CTRL_DEVICE_LIST_GET
4977	* dcmd.mbox - reserved
4978	* dcmd.sge IN - ptr to return MR_HOST_DEVICE_LIST structure
4979	* Desc: This DCMD will return the combined device list
4980	* Status: MFI_STAT_OK - List returned successfully
4981	* MFI_STAT_INVALID_CMD - Firmware support for the feature has been
4982	* disabled
4983	* @instance: Adapter soft state
4984	* @is_probe: Driver probe check
4985	* Return: 0 if DCMD succeeded
4986	* non-zero if failed
4987	*/
4988	static int
4989	megasas_host_device_list_query(struct megasas_instance *instance,
4990	bool is_probe)
4991	{
4992	int ret, i, target_id;
4993	struct megasas_cmd *cmd;
4994	struct megasas_dcmd_frame *dcmd;
4995	struct MR_HOST_DEVICE_LIST *ci;
4996	u32 count;
4997	dma_addr_t ci_h;
4998
4999	ci = instance->host_device_list_buf;
5000	ci_h = instance->host_device_list_buf_h;
5001
5002	cmd = megasas_get_cmd(instance);
5003
5004	if (!cmd) {
5005	dev_warn(&instance->pdev->dev,
5006	"%s: failed to get cmd\n",
5007	__func__);
5008	return -ENOMEM;
5009	}
5010
5011	dcmd = &cmd->frame->dcmd;
5012
5013	memset(ci, 0, sizeof(*ci));
5014	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5015
5016	dcmd->mbox.b[0] = is_probe ? 0 : 1;
5017	dcmd->cmd = MFI_CMD_DCMD;
5018	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
5019	dcmd->sge_count = 1;
5020	dcmd->flags = MFI_FRAME_DIR_READ;
5021	dcmd->timeout = 0;
5022	dcmd->pad_0 = 0;
5023	dcmd->data_xfer_len = cpu_to_le32(HOST_DEVICE_LIST_SZ);
5024	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_DEVICE_LIST_GET);
5025
5026	megasas_set_dma_settings(instance, dcmd, dma_addr: ci_h, HOST_DEVICE_LIST_SZ);
5027
5028	if (!instance->mask_interrupts) {
5029	ret = megasas_issue_blocked_cmd(instance, cmd,
5030	MFI_IO_TIMEOUT_SECS);
5031	} else {
5032	ret = megasas_issue_polled(instance, cmd);
5033	cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5034	}
5035
5036	switch (ret) {
5037	case DCMD_SUCCESS:
5038	/* Fill the internal pd_list and ld_ids array based on
5039	* targetIds returned by FW
5040	*/
5041	count = le32_to_cpu(ci->count);
5042
5043	if (count > (MEGASAS_MAX_PD + MAX_LOGICAL_DRIVES_EXT))
5044	break;
5045
5046	if (megasas_dbg_lvl & LD_PD_DEBUG)
5047	dev_info(&instance->pdev->dev, "%s, Device count: 0x%x\n",
5048	__func__, count);
5049
5050	memset(instance->local_pd_list, 0,
5051	MEGASAS_MAX_PD * sizeof(struct megasas_pd_list));
5052	memset(instance->ld_ids, 0xff, MAX_LOGICAL_DRIVES_EXT);
5053	for (i = 0; i < count; i++) {
5054	target_id = le16_to_cpu(ci->host_device_list[i].target_id);
5055	if (ci->host_device_list[i].flags.u.bits.is_sys_pd) {
5056	instance->local_pd_list[target_id].tid = target_id;
5057	instance->local_pd_list[target_id].driveType =
5058	ci->host_device_list[i].scsi_type;
5059	instance->local_pd_list[target_id].driveState =
5060	MR_PD_STATE_SYSTEM;
5061	if (megasas_dbg_lvl & LD_PD_DEBUG)
5062	dev_info(&instance->pdev->dev,
5063	"Device %d: PD targetID: 0x%03x deviceType:0x%x\n",
5064	i, target_id, ci->host_device_list[i].scsi_type);
5065	} else {
5066	instance->ld_ids[target_id] = target_id;
5067	if (megasas_dbg_lvl & LD_PD_DEBUG)
5068	dev_info(&instance->pdev->dev,
5069	"Device %d: LD targetID: 0x%03x\n",
5070	i, target_id);
5071	}
5072	}
5073
5074	memcpy(instance->pd_list, instance->local_pd_list,
5075	sizeof(instance->pd_list));
5076	break;
5077
5078	case DCMD_TIMEOUT:
5079	switch (dcmd_timeout_ocr_possible(instance)) {
5080	case INITIATE_OCR:
5081	cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5082	mutex_unlock(lock: &instance->reset_mutex);
5083	megasas_reset_fusion(shost: instance->host,
5084	reason: MFI_IO_TIMEOUT_OCR);
5085	mutex_lock(&instance->reset_mutex);
5086	break;
5087	case KILL_ADAPTER:
5088	megaraid_sas_kill_hba(instance);
5089	break;
5090	case IGNORE_TIMEOUT:
5091	dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5092	__func__, __LINE__);
5093	break;
5094	}
5095	break;
5096	case DCMD_FAILED:
5097	dev_err(&instance->pdev->dev,
5098	"%s: MR_DCMD_CTRL_DEVICE_LIST_GET failed\n",
5099	__func__);
5100	break;
5101	}
5102
5103	if (ret != DCMD_TIMEOUT)
5104	megasas_return_cmd(instance, cmd);
5105
5106	return ret;
5107	}
5108
5109	/*
5110	* megasas_update_ext_vd_details : Update details w.r.t Extended VD
5111	* instance : Controller's instance
5112	*/
5113	static void megasas_update_ext_vd_details(struct megasas_instance *instance)
5114	{
5115	struct fusion_context *fusion;
5116	u32 ventura_map_sz = 0;
5117
5118	fusion = instance->ctrl_context;
5119	/* For MFI based controllers return dummy success */
5120	if (!fusion)
5121	return;
5122
5123	instance->supportmax256vd =
5124	instance->ctrl_info_buf->adapterOperations3.supportMaxExtLDs;
5125	/* Below is additional check to address future FW enhancement */
5126	if (instance->ctrl_info_buf->max_lds > 64)
5127	instance->supportmax256vd = 1;
5128
5129	instance->drv_supported_vd_count = MEGASAS_MAX_LD_CHANNELS
5130	* MEGASAS_MAX_DEV_PER_CHANNEL;
5131	instance->drv_supported_pd_count = MEGASAS_MAX_PD_CHANNELS
5132	* MEGASAS_MAX_DEV_PER_CHANNEL;
5133	if (instance->supportmax256vd) {
5134	instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES_EXT;
5135	instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
5136	} else {
5137	instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
5138	instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
5139	}
5140
5141	dev_info(&instance->pdev->dev,
5142	"FW provided supportMaxExtLDs: %d\tmax_lds: %d\n",
5143	instance->ctrl_info_buf->adapterOperations3.supportMaxExtLDs ? 1 : 0,
5144	instance->ctrl_info_buf->max_lds);
5145
5146	if (instance->max_raid_mapsize) {
5147	ventura_map_sz = instance->max_raid_mapsize *
5148	MR_MIN_MAP_SIZE; /* 64k */
5149	fusion->current_map_sz = ventura_map_sz;
5150	fusion->max_map_sz = ventura_map_sz;
5151	} else {
5152	fusion->old_map_sz =
5153	struct_size_t(struct MR_FW_RAID_MAP, ldSpanMap,
5154	instance->fw_supported_vd_count);
5155	fusion->new_map_sz = sizeof(struct MR_FW_RAID_MAP_EXT);
5156
5157	fusion->max_map_sz =
5158	max(fusion->old_map_sz, fusion->new_map_sz);
5159
5160	if (instance->supportmax256vd)
5161	fusion->current_map_sz = fusion->new_map_sz;
5162	else
5163	fusion->current_map_sz = fusion->old_map_sz;
5164	}
5165	/* irrespective of FW raid maps, driver raid map is constant */
5166	fusion->drv_map_sz = sizeof(struct MR_DRV_RAID_MAP_ALL);
5167	}
5168
5169	/*
5170	* dcmd.opcode - MR_DCMD_CTRL_SNAPDUMP_GET_PROPERTIES
5171	* dcmd.hdr.length - number of bytes to read
5172	* dcmd.sge - Ptr to MR_SNAPDUMP_PROPERTIES
5173	* Desc: Fill in snapdump properties
5174	* Status: MFI_STAT_OK- Command successful
5175	*/
5176	void megasas_get_snapdump_properties(struct megasas_instance *instance)
5177	{
5178	int ret = 0;
5179	struct megasas_cmd *cmd;
5180	struct megasas_dcmd_frame *dcmd;
5181	struct MR_SNAPDUMP_PROPERTIES *ci;
5182	dma_addr_t ci_h = 0;
5183
5184	ci = instance->snapdump_prop;
5185	ci_h = instance->snapdump_prop_h;
5186
5187	if (!ci)
5188	return;
5189
5190	cmd = megasas_get_cmd(instance);
5191
5192	if (!cmd) {
5193	dev_dbg(&instance->pdev->dev, "Failed to get a free cmd\n");
5194	return;
5195	}
5196
5197	dcmd = &cmd->frame->dcmd;
5198
5199	memset(ci, 0, sizeof(*ci));
5200	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5201
5202	dcmd->cmd = MFI_CMD_DCMD;
5203	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
5204	dcmd->sge_count = 1;
5205	dcmd->flags = MFI_FRAME_DIR_READ;
5206	dcmd->timeout = 0;
5207	dcmd->pad_0 = 0;
5208	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_SNAPDUMP_PROPERTIES));
5209	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_SNAPDUMP_GET_PROPERTIES);
5210
5211	megasas_set_dma_settings(instance, dcmd, dma_addr: ci_h,
5212	dma_len: sizeof(struct MR_SNAPDUMP_PROPERTIES));
5213
5214	if (!instance->mask_interrupts) {
5215	ret = megasas_issue_blocked_cmd(instance, cmd,
5216	MFI_IO_TIMEOUT_SECS);
5217	} else {
5218	ret = megasas_issue_polled(instance, cmd);
5219	cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5220	}
5221
5222	switch (ret) {
5223	case DCMD_SUCCESS:
5224	instance->snapdump_wait_time =
5225	min_t(u8, ci->trigger_min_num_sec_before_ocr,
5226	MEGASAS_MAX_SNAP_DUMP_WAIT_TIME);
5227	break;
5228
5229	case DCMD_TIMEOUT:
5230	switch (dcmd_timeout_ocr_possible(instance)) {
5231	case INITIATE_OCR:
5232	cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5233	mutex_unlock(lock: &instance->reset_mutex);
5234	megasas_reset_fusion(shost: instance->host,
5235	reason: MFI_IO_TIMEOUT_OCR);
5236	mutex_lock(&instance->reset_mutex);
5237	break;
5238	case KILL_ADAPTER:
5239	megaraid_sas_kill_hba(instance);
5240	break;
5241	case IGNORE_TIMEOUT:
5242	dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5243	__func__, __LINE__);
5244	break;
5245	}
5246	}
5247
5248	if (ret != DCMD_TIMEOUT)
5249	megasas_return_cmd(instance, cmd);
5250	}
5251
5252	/**
5253	* megasas_get_ctrl_info - Returns FW's controller structure
5254	* @instance: Adapter soft state
5255	*
5256	* Issues an internal command (DCMD) to get the FW's controller structure.
5257	* This information is mainly used to find out the maximum IO transfer per
5258	* command supported by the FW.
5259	*/
5260	int
5261	megasas_get_ctrl_info(struct megasas_instance *instance)
5262	{
5263	int ret = 0;
5264	struct megasas_cmd *cmd;
5265	struct megasas_dcmd_frame *dcmd;
5266	struct megasas_ctrl_info *ci;
5267	dma_addr_t ci_h = 0;
5268
5269	ci = instance->ctrl_info_buf;
5270	ci_h = instance->ctrl_info_buf_h;
5271
5272	cmd = megasas_get_cmd(instance);
5273
5274	if (!cmd) {
5275	dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get a free cmd\n");
5276	return -ENOMEM;
5277	}
5278
5279	dcmd = &cmd->frame->dcmd;
5280
5281	memset(ci, 0, sizeof(*ci));
5282	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5283
5284	dcmd->cmd = MFI_CMD_DCMD;
5285	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
5286	dcmd->sge_count = 1;
5287	dcmd->flags = MFI_FRAME_DIR_READ;
5288	dcmd->timeout = 0;
5289	dcmd->pad_0 = 0;
5290	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_ctrl_info));
5291	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_GET_INFO);
5292	dcmd->mbox.b[0] = 1;
5293
5294	megasas_set_dma_settings(instance, dcmd, dma_addr: ci_h,
5295	dma_len: sizeof(struct megasas_ctrl_info));
5296
5297	if ((instance->adapter_type != MFI_SERIES) &&
5298	!instance->mask_interrupts) {
5299	ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
5300	} else {
5301	ret = megasas_issue_polled(instance, cmd);
5302	cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5303	}
5304
5305	switch (ret) {
5306	case DCMD_SUCCESS:
5307	/* Save required controller information in
5308	* CPU endianness format.
5309	*/
5310	le32_to_cpus((u32 *)&ci->properties.OnOffProperties);
5311	le16_to_cpus((u16 *)&ci->properties.on_off_properties2);
5312	le32_to_cpus((u32 *)&ci->adapterOperations2);
5313	le32_to_cpus((u32 *)&ci->adapterOperations3);
5314	le16_to_cpus((u16 *)&ci->adapter_operations4);
5315	le32_to_cpus((u32 *)&ci->adapter_operations5);
5316
5317	/* Update the latest Ext VD info.
5318	* From Init path, store current firmware details.
5319	* From OCR path, detect any firmware properties changes.
5320	* in case of Firmware upgrade without system reboot.
5321	*/
5322	megasas_update_ext_vd_details(instance);
5323	instance->support_seqnum_jbod_fp =
5324	ci->adapterOperations3.useSeqNumJbodFP;
5325	instance->support_morethan256jbod =
5326	ci->adapter_operations4.support_pd_map_target_id;
5327	instance->support_nvme_passthru =
5328	ci->adapter_operations4.support_nvme_passthru;
5329	instance->support_pci_lane_margining =
5330	ci->adapter_operations5.support_pci_lane_margining;
5331	instance->task_abort_tmo = ci->TaskAbortTO;
5332	instance->max_reset_tmo = ci->MaxResetTO;
5333
5334	/*Check whether controller is iMR or MR */
5335	instance->is_imr = (ci->memory_size ? 0 : 1);
5336
5337	instance->snapdump_wait_time =
5338	(ci->properties.on_off_properties2.enable_snap_dump ?
5339	MEGASAS_DEFAULT_SNAP_DUMP_WAIT_TIME : 0);
5340
5341	instance->enable_fw_dev_list =
5342	ci->properties.on_off_properties2.enable_fw_dev_list;
5343
5344	dev_info(&instance->pdev->dev,
5345	"controller type\t: %s(%dMB)\n",
5346	instance->is_imr ? "iMR" : "MR",
5347	le16_to_cpu(ci->memory_size));
5348
5349	instance->disableOnlineCtrlReset =
5350	ci->properties.OnOffProperties.disableOnlineCtrlReset;
5351	instance->secure_jbod_support =
5352	ci->adapterOperations3.supportSecurityonJBOD;
5353	dev_info(&instance->pdev->dev, "Online Controller Reset(OCR)\t: %s\n",
5354	instance->disableOnlineCtrlReset ? "Disabled" : "Enabled");
5355	dev_info(&instance->pdev->dev, "Secure JBOD support\t: %s\n",
5356	instance->secure_jbod_support ? "Yes" : "No");
5357	dev_info(&instance->pdev->dev, "NVMe passthru support\t: %s\n",
5358	instance->support_nvme_passthru ? "Yes" : "No");
5359	dev_info(&instance->pdev->dev,
5360	"FW provided TM TaskAbort/Reset timeout\t: %d secs/%d secs\n",
5361	instance->task_abort_tmo, instance->max_reset_tmo);
5362	dev_info(&instance->pdev->dev, "JBOD sequence map support\t: %s\n",
5363	instance->support_seqnum_jbod_fp ? "Yes" : "No");
5364	dev_info(&instance->pdev->dev, "PCI Lane Margining support\t: %s\n",
5365	instance->support_pci_lane_margining ? "Yes" : "No");
5366
5367	break;
5368
5369	case DCMD_TIMEOUT:
5370	switch (dcmd_timeout_ocr_possible(instance)) {
5371	case INITIATE_OCR:
5372	cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5373	mutex_unlock(lock: &instance->reset_mutex);
5374	megasas_reset_fusion(shost: instance->host,
5375	reason: MFI_IO_TIMEOUT_OCR);
5376	mutex_lock(&instance->reset_mutex);
5377	break;
5378	case KILL_ADAPTER:
5379	megaraid_sas_kill_hba(instance);
5380	break;
5381	case IGNORE_TIMEOUT:
5382	dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5383	__func__, __LINE__);
5384	break;
5385	}
5386	break;
5387	case DCMD_FAILED:
5388	megaraid_sas_kill_hba(instance);
5389	break;
5390
5391	}
5392
5393	if (ret != DCMD_TIMEOUT)
5394	megasas_return_cmd(instance, cmd);
5395
5396	return ret;
5397	}
5398
5399	/*
5400	* megasas_set_crash_dump_params - Sends address of crash dump DMA buffer
5401	* to firmware
5402	*
5403	* @instance: Adapter soft state
5404	* @crash_buf_state - tell FW to turn ON/OFF crash dump feature
5405	MR_CRASH_BUF_TURN_OFF = 0
5406	MR_CRASH_BUF_TURN_ON = 1
5407	* @return 0 on success non-zero on failure.
5408	* Issues an internal command (DCMD) to set parameters for crash dump feature.
5409	* Driver will send address of crash dump DMA buffer and set mbox to tell FW
5410	* that driver supports crash dump feature. This DCMD will be sent only if
5411	* crash dump feature is supported by the FW.
5412	*
5413	*/
5414	int megasas_set_crash_dump_params(struct megasas_instance *instance,
5415	u8 crash_buf_state)
5416	{
5417	int ret = 0;
5418	struct megasas_cmd *cmd;
5419	struct megasas_dcmd_frame *dcmd;
5420
5421	cmd = megasas_get_cmd(instance);
5422
5423	if (!cmd) {
5424	dev_err(&instance->pdev->dev, "Failed to get a free cmd\n");
5425	return -ENOMEM;
5426	}
5427
5428
5429	dcmd = &cmd->frame->dcmd;
5430
5431	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5432	dcmd->mbox.b[0] = crash_buf_state;
5433	dcmd->cmd = MFI_CMD_DCMD;
5434	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
5435	dcmd->sge_count = 1;
5436	dcmd->flags = MFI_FRAME_DIR_NONE;
5437	dcmd->timeout = 0;
5438	dcmd->pad_0 = 0;
5439	dcmd->data_xfer_len = cpu_to_le32(CRASH_DMA_BUF_SIZE);
5440	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_SET_CRASH_DUMP_PARAMS);
5441
5442	megasas_set_dma_settings(instance, dcmd, dma_addr: instance->crash_dump_h,
5443	CRASH_DMA_BUF_SIZE);
5444
5445	if ((instance->adapter_type != MFI_SERIES) &&
5446	!instance->mask_interrupts)
5447	ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
5448	else
5449	ret = megasas_issue_polled(instance, cmd);
5450
5451	if (ret == DCMD_TIMEOUT) {
5452	switch (dcmd_timeout_ocr_possible(instance)) {
5453	case INITIATE_OCR:
5454	cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5455	megasas_reset_fusion(shost: instance->host,
5456	reason: MFI_IO_TIMEOUT_OCR);
5457	break;
5458	case KILL_ADAPTER:
5459	megaraid_sas_kill_hba(instance);
5460	break;
5461	case IGNORE_TIMEOUT:
5462	dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5463	__func__, __LINE__);
5464	break;
5465	}
5466	} else
5467	megasas_return_cmd(instance, cmd);
5468
5469	return ret;
5470	}
5471
5472	/**
5473	* megasas_issue_init_mfi - Initializes the FW
5474	* @instance: Adapter soft state
5475	*
5476	* Issues the INIT MFI cmd
5477	*/
5478	static int
5479	megasas_issue_init_mfi(struct megasas_instance *instance)
5480	{
5481	__le32 context;
5482	struct megasas_cmd *cmd;
5483	struct megasas_init_frame *init_frame;
5484	struct megasas_init_queue_info *initq_info;
5485	dma_addr_t init_frame_h;
5486	dma_addr_t initq_info_h;
5487
5488	/*
5489	* Prepare a init frame. Note the init frame points to queue info
5490	* structure. Each frame has SGL allocated after first 64 bytes. For
5491	* this frame - since we don't need any SGL - we use SGL's space as
5492	* queue info structure
5493	*
5494	* We will not get a NULL command below. We just created the pool.
5495	*/
5496	cmd = megasas_get_cmd(instance);
5497
5498	init_frame = (struct megasas_init_frame *)cmd->frame;
5499	initq_info = (struct megasas_init_queue_info *)
5500	((unsigned long)init_frame + 64);
5501
5502	init_frame_h = cmd->frame_phys_addr;
5503	initq_info_h = init_frame_h + 64;
5504
5505	context = init_frame->context;
5506	memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
5507	memset(initq_info, 0, sizeof(struct megasas_init_queue_info));
5508	init_frame->context = context;
5509
5510	initq_info->reply_queue_entries = cpu_to_le32(instance->max_fw_cmds + 1);
5511	initq_info->reply_queue_start_phys_addr_lo = cpu_to_le32(instance->reply_queue_h);
5512
5513	initq_info->producer_index_phys_addr_lo = cpu_to_le32(instance->producer_h);
5514	initq_info->consumer_index_phys_addr_lo = cpu_to_le32(instance->consumer_h);
5515
5516	init_frame->cmd = MFI_CMD_INIT;
5517	init_frame->cmd_status = MFI_STAT_INVALID_STATUS;
5518	init_frame->queue_info_new_phys_addr_lo =
5519	cpu_to_le32(lower_32_bits(initq_info_h));
5520	init_frame->queue_info_new_phys_addr_hi =
5521	cpu_to_le32(upper_32_bits(initq_info_h));
5522
5523	init_frame->data_xfer_len = cpu_to_le32(sizeof(struct megasas_init_queue_info));
5524
5525	/*
5526	* disable the intr before firing the init frame to FW
5527	*/
5528	instance->instancet->disable_intr(instance);
5529
5530	/*
5531	* Issue the init frame in polled mode
5532	*/
5533
5534	if (megasas_issue_polled(instance, cmd)) {
5535	dev_err(&instance->pdev->dev, "Failed to init firmware\n");
5536	megasas_return_cmd(instance, cmd);
5537	goto fail_fw_init;
5538	}
5539
5540	megasas_return_cmd(instance, cmd);
5541
5542	return 0;
5543
5544	fail_fw_init:
5545	return -EINVAL;
5546	}
5547
5548	static u32
5549	megasas_init_adapter_mfi(struct megasas_instance *instance)
5550	{
5551	u32 context_sz;
5552	u32 reply_q_sz;
5553
5554	/*
5555	* Get various operational parameters from status register
5556	*/
5557	instance->max_fw_cmds = instance->instancet->read_fw_status_reg(instance) & 0x00FFFF;
5558	/*
5559	* Reduce the max supported cmds by 1. This is to ensure that the
5560	* reply_q_sz (1 more than the max cmd that driver may send)
5561	* does not exceed max cmds that the FW can support
5562	*/
5563	instance->max_fw_cmds = instance->max_fw_cmds-1;
5564	instance->max_mfi_cmds = instance->max_fw_cmds;
5565	instance->max_num_sge = (instance->instancet->read_fw_status_reg(instance) & 0xFF0000) >>
5566	0x10;
5567	/*
5568	* For MFI skinny adapters, MEGASAS_SKINNY_INT_CMDS commands
5569	* are reserved for IOCTL + driver's internal DCMDs.
5570	*/
5571	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
5572	(instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
5573	instance->max_scsi_cmds = (instance->max_fw_cmds -
5574	MEGASAS_SKINNY_INT_CMDS);
5575	sema_init(sem: &instance->ioctl_sem, MEGASAS_SKINNY_INT_CMDS);
5576	} else {
5577	instance->max_scsi_cmds = (instance->max_fw_cmds -
5578	MEGASAS_INT_CMDS);
5579	sema_init(sem: &instance->ioctl_sem, val: (MEGASAS_MFI_IOCTL_CMDS));
5580	}
5581
5582	instance->cur_can_queue = instance->max_scsi_cmds;
5583	/*
5584	* Create a pool of commands
5585	*/
5586	if (megasas_alloc_cmds(instance))
5587	goto fail_alloc_cmds;
5588
5589	/*
5590	* Allocate memory for reply queue. Length of reply queue should
5591	* be _one_ more than the maximum commands handled by the firmware.
5592	*
5593	* Note: When FW completes commands, it places corresponding contex
5594	* values in this circular reply queue. This circular queue is a fairly
5595	* typical producer-consumer queue. FW is the producer (of completed
5596	* commands) and the driver is the consumer.
5597	*/
5598	context_sz = sizeof(u32);
5599	reply_q_sz = context_sz * (instance->max_fw_cmds + 1);
5600
5601	instance->reply_queue = dma_alloc_coherent(dev: &instance->pdev->dev,
5602	size: reply_q_sz, dma_handle: &instance->reply_queue_h, GFP_KERNEL);
5603
5604	if (!instance->reply_queue) {
5605	dev_printk(KERN_DEBUG, &instance->pdev->dev, "Out of DMA mem for reply queue\n");
5606	goto fail_reply_queue;
5607	}
5608
5609	if (megasas_issue_init_mfi(instance))
5610	goto fail_fw_init;
5611
5612	if (megasas_get_ctrl_info(instance)) {
5613	dev_err(&instance->pdev->dev, "(%d): Could get controller info "
5614	"Fail from %s %d\n", instance->unique_id,
5615	__func__, __LINE__);
5616	goto fail_fw_init;
5617	}
5618
5619	instance->fw_support_ieee = 0;
5620	instance->fw_support_ieee =
5621	(instance->instancet->read_fw_status_reg(instance) &
5622	0x04000000);
5623
5624	dev_notice(&instance->pdev->dev, "megasas_init_mfi: fw_support_ieee=%d",
5625	instance->fw_support_ieee);
5626
5627	if (instance->fw_support_ieee)
5628	instance->flag_ieee = 1;
5629
5630	return 0;
5631
5632	fail_fw_init:
5633
5634	dma_free_coherent(dev: &instance->pdev->dev, size: reply_q_sz,
5635	cpu_addr: instance->reply_queue, dma_handle: instance->reply_queue_h);
5636	fail_reply_queue:
5637	megasas_free_cmds(instance);
5638
5639	fail_alloc_cmds:
5640	return 1;
5641	}
5642
5643	static
5644	void megasas_setup_irq_poll(struct megasas_instance *instance)
5645	{
5646	struct megasas_irq_context *irq_ctx;
5647	u32 count, i;
5648
5649	count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
5650
5651	/* Initialize IRQ poll */
5652	for (i = 0; i < count; i++) {
5653	irq_ctx = &instance->irq_context[i];
5654	irq_ctx->os_irq = pci_irq_vector(dev: instance->pdev, nr: i);
5655	irq_ctx->irq_poll_scheduled = false;
5656	irq_poll_init(&irq_ctx->irqpoll,
5657	instance->threshold_reply_count,
5658	megasas_irqpoll);
5659	}
5660	}
5661
5662	/*
5663	* megasas_setup_irqs_ioapic - register legacy interrupts.
5664	* @instance: Adapter soft state
5665	*
5666	* Do not enable interrupt, only setup ISRs.
5667	*
5668	* Return 0 on success.
5669	*/
5670	static int
5671	megasas_setup_irqs_ioapic(struct megasas_instance *instance)
5672	{
5673	struct pci_dev *pdev;
5674
5675	pdev = instance->pdev;
5676	instance->irq_context[0].instance = instance;
5677	instance->irq_context[0].MSIxIndex = 0;
5678	snprintf(buf: instance->irq_context->name, MEGASAS_MSIX_NAME_LEN, fmt: "%s%u",
5679	"megasas", instance->host->host_no);
5680	if (request_irq(irq: pci_irq_vector(dev: pdev, nr: 0),
5681	handler: instance->instancet->service_isr, IRQF_SHARED,
5682	name: instance->irq_context->name, dev: &instance->irq_context[0])) {
5683	dev_err(&instance->pdev->dev,
5684	"Failed to register IRQ from %s %d\n",
5685	__func__, __LINE__);
5686	return -1;
5687	}
5688	instance->perf_mode = MR_LATENCY_PERF_MODE;
5689	instance->low_latency_index_start = 0;
5690	return 0;
5691	}
5692
5693	/**
5694	* megasas_setup_irqs_msix - register MSI-x interrupts.
5695	* @instance: Adapter soft state
5696	* @is_probe: Driver probe check
5697	*
5698	* Do not enable interrupt, only setup ISRs.
5699	*
5700	* Return 0 on success.
5701	*/
5702	static int
5703	megasas_setup_irqs_msix(struct megasas_instance *instance, u8 is_probe)
5704	{
5705	int i, j;
5706	struct pci_dev *pdev;
5707
5708	pdev = instance->pdev;
5709
5710	/* Try MSI-x */
5711	for (i = 0; i < instance->msix_vectors; i++) {
5712	instance->irq_context[i].instance = instance;
5713	instance->irq_context[i].MSIxIndex = i;
5714	snprintf(buf: instance->irq_context[i].name, MEGASAS_MSIX_NAME_LEN, fmt: "%s%u-msix%u",
5715	"megasas", instance->host->host_no, i);
5716	if (request_irq(irq: pci_irq_vector(dev: pdev, nr: i),
5717	handler: instance->instancet->service_isr, flags: 0, name: instance->irq_context[i].name,
5718	dev: &instance->irq_context[i])) {
5719	dev_err(&instance->pdev->dev,
5720	"Failed to register IRQ for vector %d.\n", i);
5721	for (j = 0; j < i; j++) {
5722	if (j < instance->low_latency_index_start)
5723	irq_update_affinity_hint(
5724	irq: pci_irq_vector(dev: pdev, nr: j), NULL);
5725	free_irq(pci_irq_vector(dev: pdev, nr: j),
5726	&instance->irq_context[j]);
5727	}
5728	/* Retry irq register for IO_APIC*/
5729	instance->msix_vectors = 0;
5730	instance->msix_load_balance = false;
5731	if (is_probe) {
5732	pci_free_irq_vectors(dev: instance->pdev);
5733	return megasas_setup_irqs_ioapic(instance);
5734	} else {
5735	return -1;
5736	}
5737	}
5738	}
5739
5740	return 0;
5741	}
5742
5743	/*
5744	* megasas_destroy_irqs- unregister interrupts.
5745	* @instance: Adapter soft state
5746	* return: void
5747	*/
5748	static void
5749	megasas_destroy_irqs(struct megasas_instance *instance) {
5750
5751	int i;
5752	int count;
5753	struct megasas_irq_context *irq_ctx;
5754
5755	count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
5756	if (instance->adapter_type != MFI_SERIES) {
5757	for (i = 0; i < count; i++) {
5758	irq_ctx = &instance->irq_context[i];
5759	irq_poll_disable(&irq_ctx->irqpoll);
5760	}
5761	}
5762
5763	if (instance->msix_vectors)
5764	for (i = 0; i < instance->msix_vectors; i++) {
5765	if (i < instance->low_latency_index_start)
5766	irq_update_affinity_hint(
5767	irq: pci_irq_vector(dev: instance->pdev, nr: i), NULL);
5768	free_irq(pci_irq_vector(dev: instance->pdev, nr: i),
5769	&instance->irq_context[i]);
5770	}
5771	else
5772	free_irq(pci_irq_vector(dev: instance->pdev, nr: 0),
5773	&instance->irq_context[0]);
5774	}
5775
5776	/**
5777	* megasas_setup_jbod_map - setup jbod map for FP seq_number.
5778	* @instance: Adapter soft state
5779	*
5780	* Return 0 on success.
5781	*/
5782	void
5783	megasas_setup_jbod_map(struct megasas_instance *instance)
5784	{
5785	int i;
5786	struct fusion_context *fusion = instance->ctrl_context;
5787	size_t pd_seq_map_sz;
5788
5789	pd_seq_map_sz = struct_size_t(struct MR_PD_CFG_SEQ_NUM_SYNC, seq,
5790	MAX_PHYSICAL_DEVICES);
5791
5792	instance->use_seqnum_jbod_fp =
5793	instance->support_seqnum_jbod_fp;
5794	if (reset_devices || !fusion ||
5795	!instance->support_seqnum_jbod_fp) {
5796	dev_info(&instance->pdev->dev,
5797	"JBOD sequence map is disabled %s %d\n",
5798	__func__, __LINE__);
5799	instance->use_seqnum_jbod_fp = false;
5800	return;
5801	}
5802
5803	if (fusion->pd_seq_sync[0])
5804	goto skip_alloc;
5805
5806	for (i = 0; i < JBOD_MAPS_COUNT; i++) {
5807	fusion->pd_seq_sync[i] = dma_alloc_coherent
5808	(dev: &instance->pdev->dev, size: pd_seq_map_sz,
5809	dma_handle: &fusion->pd_seq_phys[i], GFP_KERNEL);
5810	if (!fusion->pd_seq_sync[i]) {
5811	dev_err(&instance->pdev->dev,
5812	"Failed to allocate memory from %s %d\n",
5813	__func__, __LINE__);
5814	if (i == 1) {
5815	dma_free_coherent(dev: &instance->pdev->dev,
5816	size: pd_seq_map_sz, cpu_addr: fusion->pd_seq_sync[0],
5817	dma_handle: fusion->pd_seq_phys[0]);
5818	fusion->pd_seq_sync[0] = NULL;
5819	}
5820	instance->use_seqnum_jbod_fp = false;
5821	return;
5822	}
5823	}
5824
5825	skip_alloc:
5826	if (!megasas_sync_pd_seq_num(instance, pend: false) &&
5827	!megasas_sync_pd_seq_num(instance, pend: true))
5828	instance->use_seqnum_jbod_fp = true;
5829	else
5830	instance->use_seqnum_jbod_fp = false;
5831	}
5832
5833	static void megasas_setup_reply_map(struct megasas_instance *instance)
5834	{
5835	const struct cpumask *mask;
5836	unsigned int queue, cpu, low_latency_index_start;
5837
5838	low_latency_index_start = instance->low_latency_index_start;
5839
5840	for (queue = low_latency_index_start; queue < instance->msix_vectors; queue++) {
5841	mask = pci_irq_get_affinity(pdev: instance->pdev, vec: queue);
5842	if (!mask)
5843	goto fallback;
5844
5845	for_each_cpu(cpu, mask)
5846	instance->reply_map[cpu] = queue;
5847	}
5848	return;
5849
5850	fallback:
5851	queue = low_latency_index_start;
5852	for_each_possible_cpu(cpu) {
5853	instance->reply_map[cpu] = queue;
5854	if (queue == (instance->msix_vectors - 1))
5855	queue = low_latency_index_start;
5856	else
5857	queue++;
5858	}
5859	}
5860
5861	/**
5862	* megasas_get_device_list - Get the PD and LD device list from FW.
5863	* @instance: Adapter soft state
5864	* @return: Success or failure
5865	*
5866	* Issue DCMDs to Firmware to get the PD and LD list.
5867	* Based on the FW support, driver sends the HOST_DEVICE_LIST or combination
5868	* of PD_LIST/LD_LIST_QUERY DCMDs to get the device list.
5869	*/
5870	static
5871	int megasas_get_device_list(struct megasas_instance *instance)
5872	{
5873	if (instance->enable_fw_dev_list) {
5874	if (megasas_host_device_list_query(instance, is_probe: true))
5875	return FAILED;
5876	} else {
5877	if (megasas_get_pd_list(instance) < 0) {
5878	dev_err(&instance->pdev->dev, "failed to get PD list\n");
5879	return FAILED;
5880	}
5881
5882	if (megasas_ld_list_query(instance,
5883	query_type: MR_LD_QUERY_TYPE_EXPOSED_TO_HOST)) {
5884	dev_err(&instance->pdev->dev, "failed to get LD list\n");
5885	return FAILED;
5886	}
5887	}
5888
5889	return SUCCESS;
5890	}
5891
5892	/**
5893	* megasas_set_high_iops_queue_affinity_and_hint - Set affinity and hint
5894	* for high IOPS queues
5895	* @instance: Adapter soft state
5896	* return: void
5897	*/
5898	static inline void
5899	megasas_set_high_iops_queue_affinity_and_hint(struct megasas_instance *instance)
5900	{
5901	int i;
5902	unsigned int irq;
5903	const struct cpumask *mask;
5904
5905	if (instance->perf_mode == MR_BALANCED_PERF_MODE) {
5906	mask = cpumask_of_node(node: dev_to_node(dev: &instance->pdev->dev));
5907
5908	for (i = 0; i < instance->low_latency_index_start; i++) {
5909	irq = pci_irq_vector(dev: instance->pdev, nr: i);
5910	irq_set_affinity_and_hint(irq, m: mask);
5911	}
5912	}
5913	}
5914
5915	static int
5916	__megasas_alloc_irq_vectors(struct megasas_instance *instance)
5917	{
5918	int i, irq_flags;
5919	struct irq_affinity desc = { .pre_vectors = instance->low_latency_index_start };
5920	struct irq_affinity *descp = &desc;
5921
5922	irq_flags = PCI_IRQ_MSIX;
5923
5924	if (instance->smp_affinity_enable)
5925	irq_flags |= PCI_IRQ_AFFINITY | PCI_IRQ_ALL_TYPES;
5926	else
5927	descp = NULL;
5928
5929	/* Do not allocate msix vectors for poll_queues.
5930	* msix_vectors is always within a range of FW supported reply queue.
5931	*/
5932	i = pci_alloc_irq_vectors_affinity(dev: instance->pdev,
5933	min_vecs: instance->low_latency_index_start,
5934	max_vecs: instance->msix_vectors - instance->iopoll_q_count, flags: irq_flags, affd: descp);
5935
5936	return i;
5937	}
5938
5939	/**
5940	* megasas_alloc_irq_vectors - Allocate IRQ vectors/enable MSI-x vectors
5941	* @instance: Adapter soft state
5942	* return: void
5943	*/
5944	static void
5945	megasas_alloc_irq_vectors(struct megasas_instance *instance)
5946	{
5947	int i;
5948	unsigned int num_msix_req;
5949
5950	instance->iopoll_q_count = 0;
5951	if ((instance->adapter_type != MFI_SERIES) &&
5952	poll_queues) {
5953
5954	instance->perf_mode = MR_LATENCY_PERF_MODE;
5955	instance->low_latency_index_start = 1;
5956
5957	/* reserve for default and non-mananged pre-vector. */
5958	if (instance->msix_vectors > (poll_queues + 2))
5959	instance->iopoll_q_count = poll_queues;
5960	else
5961	instance->iopoll_q_count = 0;
5962
5963	num_msix_req = num_online_cpus() + instance->low_latency_index_start;
5964	instance->msix_vectors = min(num_msix_req,
5965	instance->msix_vectors);
5966
5967	}
5968
5969	i = __megasas_alloc_irq_vectors(instance);
5970
5971	if (((instance->perf_mode == MR_BALANCED_PERF_MODE)
5972	|| instance->iopoll_q_count) &&
5973	(i != (instance->msix_vectors - instance->iopoll_q_count))) {
5974	if (instance->msix_vectors)
5975	pci_free_irq_vectors(dev: instance->pdev);
5976	/* Disable Balanced IOPS mode and try realloc vectors */
5977	instance->perf_mode = MR_LATENCY_PERF_MODE;
5978	instance->low_latency_index_start = 1;
5979	num_msix_req = num_online_cpus() + instance->low_latency_index_start;
5980
5981	instance->msix_vectors = min(num_msix_req,
5982	instance->msix_vectors);
5983
5984	instance->iopoll_q_count = 0;
5985	i = __megasas_alloc_irq_vectors(instance);
5986
5987	}
5988
5989	dev_info(&instance->pdev->dev,
5990	"requested/available msix %d/%d poll_queue %d\n",
5991	instance->msix_vectors - instance->iopoll_q_count,
5992	i, instance->iopoll_q_count);
5993
5994	if (i > 0)
5995	instance->msix_vectors = i;
5996	else
5997	instance->msix_vectors = 0;
5998
5999	if (instance->smp_affinity_enable)
6000	megasas_set_high_iops_queue_affinity_and_hint(instance);
6001	}
6002
6003	/**
6004	* megasas_init_fw - Initializes the FW
6005	* @instance: Adapter soft state
6006	*
6007	* This is the main function for initializing firmware
6008	*/
6009
6010	static int megasas_init_fw(struct megasas_instance *instance)
6011	{
6012	u32 max_sectors_1;
6013	u32 max_sectors_2, tmp_sectors, msix_enable;
6014	u32 scratch_pad_1, scratch_pad_2, scratch_pad_3, status_reg;
6015	resource_size_t base_addr;
6016	void *base_addr_phys;
6017	struct megasas_ctrl_info *ctrl_info = NULL;
6018	unsigned long bar_list;
6019	int i, j, loop;
6020	struct IOV_111 *iovPtr;
6021	struct fusion_context *fusion;
6022	bool intr_coalescing;
6023	unsigned int num_msix_req;
6024	u16 lnksta, speed;
6025
6026	fusion = instance->ctrl_context;
6027
6028	/* Find first memory bar */
6029	bar_list = pci_select_bars(dev: instance->pdev, IORESOURCE_MEM);
6030	instance->bar = find_first_bit(addr: &bar_list, BITS_PER_LONG);
6031	if (pci_request_selected_regions(instance->pdev, 1<<instance->bar,
6032	"megasas: LSI")) {
6033	dev_printk(KERN_DEBUG, &instance->pdev->dev, "IO memory region busy!\n");
6034	return -EBUSY;
6035	}
6036
6037	base_addr = pci_resource_start(instance->pdev, instance->bar);
6038	instance->reg_set = ioremap(offset: base_addr, size: 8192);
6039
6040	if (!instance->reg_set) {
6041	dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to map IO mem\n");
6042	goto fail_ioremap;
6043	}
6044
6045	base_addr_phys = &base_addr;
6046	dev_printk(KERN_DEBUG, &instance->pdev->dev,
6047	"BAR:0x%lx BAR's base_addr(phys):%pa mapped virt_addr:0x%p\n",
6048	instance->bar, base_addr_phys, instance->reg_set);
6049
6050	if (instance->adapter_type != MFI_SERIES)
6051	instance->instancet = &megasas_instance_template_fusion;
6052	else {
6053	switch (instance->pdev->device) {
6054	case PCI_DEVICE_ID_LSI_SAS1078R:
6055	case PCI_DEVICE_ID_LSI_SAS1078DE:
6056	instance->instancet = &megasas_instance_template_ppc;
6057	break;
6058	case PCI_DEVICE_ID_LSI_SAS1078GEN2:
6059	case PCI_DEVICE_ID_LSI_SAS0079GEN2:
6060	instance->instancet = &megasas_instance_template_gen2;
6061	break;
6062	case PCI_DEVICE_ID_LSI_SAS0073SKINNY:
6063	case PCI_DEVICE_ID_LSI_SAS0071SKINNY:
6064	instance->instancet = &megasas_instance_template_skinny;
6065	break;
6066	case PCI_DEVICE_ID_LSI_SAS1064R:
6067	case PCI_DEVICE_ID_DELL_PERC5:
6068	default:
6069	instance->instancet = &megasas_instance_template_xscale;
6070	instance->pd_list_not_supported = 1;
6071	break;
6072	}
6073	}
6074
6075	if (megasas_transition_to_ready(instance, ocr: 0)) {
6076	dev_info(&instance->pdev->dev,
6077	"Failed to transition controller to ready from %s!\n",
6078	__func__);
6079	if (instance->adapter_type != MFI_SERIES) {
6080	status_reg = instance->instancet->read_fw_status_reg(
6081	instance);
6082	if (status_reg & MFI_RESET_ADAPTER) {
6083	if (megasas_adp_reset_wait_for_ready
6084	(instance, do_adp_reset: true, ocr_context: 0) == FAILED)
6085	goto fail_ready_state;
6086	} else {
6087	goto fail_ready_state;
6088	}
6089	} else {
6090	atomic_set(v: &instance->fw_reset_no_pci_access, i: 1);
6091	instance->instancet->adp_reset
6092	(instance, instance->reg_set);
6093	atomic_set(v: &instance->fw_reset_no_pci_access, i: 0);
6094
6095	/*waiting for about 30 second before retry*/
6096	ssleep(seconds: 30);
6097
6098	if (megasas_transition_to_ready(instance, ocr: 0))
6099	goto fail_ready_state;
6100	}
6101
6102	dev_info(&instance->pdev->dev,
6103	"FW restarted successfully from %s!\n",
6104	__func__);
6105	}
6106
6107	megasas_init_ctrl_params(instance);
6108
6109	if (megasas_set_dma_mask(instance))
6110	goto fail_ready_state;
6111
6112	if (megasas_alloc_ctrl_mem(instance))
6113	goto fail_alloc_dma_buf;
6114
6115	if (megasas_alloc_ctrl_dma_buffers(instance))
6116	goto fail_alloc_dma_buf;
6117
6118	fusion = instance->ctrl_context;
6119
6120	if (instance->adapter_type >= VENTURA_SERIES) {
6121	scratch_pad_2 =
6122	megasas_readl(instance,
6123	addr: &instance->reg_set->outbound_scratch_pad_2);
6124	instance->max_raid_mapsize = ((scratch_pad_2 >>
6125	MR_MAX_RAID_MAP_SIZE_OFFSET_SHIFT) &
6126	MR_MAX_RAID_MAP_SIZE_MASK);
6127	}
6128
6129	instance->enable_sdev_max_qd = enable_sdev_max_qd;
6130
6131	switch (instance->adapter_type) {
6132	case VENTURA_SERIES:
6133	fusion->pcie_bw_limitation = true;
6134	break;
6135	case AERO_SERIES:
6136	fusion->r56_div_offload = true;
6137	break;
6138	default:
6139	break;
6140	}
6141
6142	/* Check if MSI-X is supported while in ready state */
6143	msix_enable = (instance->instancet->read_fw_status_reg(instance) &
6144	0x4000000) >> 0x1a;
6145	if (msix_enable && !msix_disable) {
6146
6147	scratch_pad_1 = megasas_readl
6148	(instance, addr: &instance->reg_set->outbound_scratch_pad_1);
6149	/* Check max MSI-X vectors */
6150	if (fusion) {
6151	if (instance->adapter_type == THUNDERBOLT_SERIES) {
6152	/* Thunderbolt Series*/
6153	instance->msix_vectors = (scratch_pad_1
6154	& MR_MAX_REPLY_QUEUES_OFFSET) + 1;
6155	} else {
6156	instance->msix_vectors = ((scratch_pad_1
6157	& MR_MAX_REPLY_QUEUES_EXT_OFFSET)
6158	>> MR_MAX_REPLY_QUEUES_EXT_OFFSET_SHIFT) + 1;
6159
6160	/*
6161	* For Invader series, > 8 MSI-x vectors
6162	* supported by FW/HW implies combined
6163	* reply queue mode is enabled.
6164	* For Ventura series, > 16 MSI-x vectors
6165	* supported by FW/HW implies combined
6166	* reply queue mode is enabled.
6167	*/
6168	switch (instance->adapter_type) {
6169	case INVADER_SERIES:
6170	if (instance->msix_vectors > 8)
6171	instance->msix_combined = true;
6172	break;
6173	case AERO_SERIES:
6174	case VENTURA_SERIES:
6175	if (instance->msix_vectors > 16)
6176	instance->msix_combined = true;
6177	break;
6178	}
6179
6180	if (rdpq_enable)
6181	instance->is_rdpq = (scratch_pad_1 & MR_RDPQ_MODE_OFFSET) ?
6182	1 : 0;
6183
6184	if (instance->adapter_type >= INVADER_SERIES &&
6185	!instance->msix_combined) {
6186	instance->msix_load_balance = true;
6187	instance->smp_affinity_enable = false;
6188	}
6189
6190	/* Save 1-15 reply post index address to local memory
6191	* Index 0 is already saved from reg offset
6192	* MPI2_REPLY_POST_HOST_INDEX_OFFSET
6193	*/
6194	for (loop = 1; loop < MR_MAX_MSIX_REG_ARRAY; loop++) {
6195	instance->reply_post_host_index_addr[loop] =
6196	(u32 __iomem *)
6197	((u8 __iomem *)instance->reg_set +
6198	MPI2_SUP_REPLY_POST_HOST_INDEX_OFFSET
6199	+ (loop * 0x10));
6200	}
6201	}
6202
6203	dev_info(&instance->pdev->dev,
6204	"firmware supports msix\t: (%d)",
6205	instance->msix_vectors);
6206	if (msix_vectors)
6207	instance->msix_vectors = min(msix_vectors,
6208	instance->msix_vectors);
6209	} else /* MFI adapters */
6210	instance->msix_vectors = 1;
6211
6212
6213	/*
6214	* For Aero (if some conditions are met), driver will configure a
6215	* few additional reply queues with interrupt coalescing enabled.
6216	* These queues with interrupt coalescing enabled are called
6217	* High IOPS queues and rest of reply queues (based on number of
6218	* logical CPUs) are termed as Low latency queues.
6219	*
6220	* Total Number of reply queues = High IOPS queues + low latency queues
6221	*
6222	* For rest of fusion adapters, 1 additional reply queue will be
6223	* reserved for management commands, rest of reply queues
6224	* (based on number of logical CPUs) will be used for IOs and
6225	* referenced as IO queues.
6226	* Total Number of reply queues = 1 + IO queues
6227	*
6228	* MFI adapters supports single MSI-x so single reply queue
6229	* will be used for IO and management commands.
6230	*/
6231
6232	intr_coalescing = (scratch_pad_1 & MR_INTR_COALESCING_SUPPORT_OFFSET) ?
6233	true : false;
6234	if (intr_coalescing &&
6235	(num_online_cpus() >= MR_HIGH_IOPS_QUEUE_COUNT) &&
6236	(instance->msix_vectors == MEGASAS_MAX_MSIX_QUEUES))
6237	instance->perf_mode = MR_BALANCED_PERF_MODE;
6238	else
6239	instance->perf_mode = MR_LATENCY_PERF_MODE;
6240
6241
6242	if (instance->adapter_type == AERO_SERIES) {
6243	pcie_capability_read_word(dev: instance->pdev, PCI_EXP_LNKSTA, val: &lnksta);
6244	speed = lnksta & PCI_EXP_LNKSTA_CLS;
6245
6246	/*
6247	* For Aero, if PCIe link speed is <16 GT/s, then driver should operate
6248	* in latency perf mode and enable R1 PCI bandwidth algorithm
6249	*/
6250	if (speed < 0x4) {
6251	instance->perf_mode = MR_LATENCY_PERF_MODE;
6252	fusion->pcie_bw_limitation = true;
6253	}
6254
6255	/*
6256	* Performance mode settings provided through module parameter-perf_mode will
6257	* take affect only for:
6258	* 1. Aero family of adapters.
6259	* 2. When user sets module parameter- perf_mode in range of 0-2.
6260	*/
6261	if ((perf_mode >= MR_BALANCED_PERF_MODE) &&
6262	(perf_mode <= MR_LATENCY_PERF_MODE))
6263	instance->perf_mode = perf_mode;
6264	/*
6265	* If intr coalescing is not supported by controller FW, then IOPS
6266	* and Balanced modes are not feasible.
6267	*/
6268	if (!intr_coalescing)
6269	instance->perf_mode = MR_LATENCY_PERF_MODE;
6270
6271	}
6272
6273	if (instance->perf_mode == MR_BALANCED_PERF_MODE)
6274	instance->low_latency_index_start =
6275	MR_HIGH_IOPS_QUEUE_COUNT;
6276	else
6277	instance->low_latency_index_start = 1;
6278
6279	num_msix_req = num_online_cpus() + instance->low_latency_index_start;
6280
6281	instance->msix_vectors = min(num_msix_req,
6282	instance->msix_vectors);
6283
6284	megasas_alloc_irq_vectors(instance);
6285	if (!instance->msix_vectors)
6286	instance->msix_load_balance = false;
6287	}
6288	/*
6289	* MSI-X host index 0 is common for all adapter.
6290	* It is used for all MPT based Adapters.
6291	*/
6292	if (instance->msix_combined) {
6293	instance->reply_post_host_index_addr[0] =
6294	(u32 *)((u8 *)instance->reg_set +
6295	MPI2_SUP_REPLY_POST_HOST_INDEX_OFFSET);
6296	} else {
6297	instance->reply_post_host_index_addr[0] =
6298	(u32 *)((u8 *)instance->reg_set +
6299	MPI2_REPLY_POST_HOST_INDEX_OFFSET);
6300	}
6301
6302	if (!instance->msix_vectors) {
6303	i = pci_alloc_irq_vectors(dev: instance->pdev, min_vecs: 1, max_vecs: 1, PCI_IRQ_LEGACY);
6304	if (i < 0)
6305	goto fail_init_adapter;
6306	}
6307
6308	megasas_setup_reply_map(instance);
6309
6310	dev_info(&instance->pdev->dev,
6311	"current msix/online cpus\t: (%d/%d)\n",
6312	instance->msix_vectors, (unsigned int)num_online_cpus());
6313	dev_info(&instance->pdev->dev,
6314	"RDPQ mode\t: (%s)\n", instance->is_rdpq ? "enabled" : "disabled");
6315
6316	tasklet_init(t: &instance->isr_tasklet, func: instance->instancet->tasklet,
6317	data: (unsigned long)instance);
6318
6319	/*
6320	* Below are default value for legacy Firmware.
6321	* non-fusion based controllers
6322	*/
6323	instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
6324	instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
6325	/* Get operational params, sge flags, send init cmd to controller */
6326	if (instance->instancet->init_adapter(instance))
6327	goto fail_init_adapter;
6328
6329	if (instance->adapter_type >= VENTURA_SERIES) {
6330	scratch_pad_3 =
6331	megasas_readl(instance,
6332	addr: &instance->reg_set->outbound_scratch_pad_3);
6333	if ((scratch_pad_3 & MR_NVME_PAGE_SIZE_MASK) >=
6334	MR_DEFAULT_NVME_PAGE_SHIFT)
6335	instance->nvme_page_size =
6336	(1 << (scratch_pad_3 & MR_NVME_PAGE_SIZE_MASK));
6337
6338	dev_info(&instance->pdev->dev,
6339	"NVME page size\t: (%d)\n", instance->nvme_page_size);
6340	}
6341
6342	if (instance->msix_vectors ?
6343	megasas_setup_irqs_msix(instance, is_probe: 1) :
6344	megasas_setup_irqs_ioapic(instance))
6345	goto fail_init_adapter;
6346
6347	if (instance->adapter_type != MFI_SERIES)
6348	megasas_setup_irq_poll(instance);
6349
6350	instance->instancet->enable_intr(instance);
6351
6352	dev_info(&instance->pdev->dev, "INIT adapter done\n");
6353
6354	megasas_setup_jbod_map(instance);
6355
6356	if (megasas_get_device_list(instance) != SUCCESS) {
6357	dev_err(&instance->pdev->dev,
6358	"%s: megasas_get_device_list failed\n",
6359	__func__);
6360	goto fail_get_ld_pd_list;
6361	}
6362
6363	/* stream detection initialization */
6364	if (instance->adapter_type >= VENTURA_SERIES) {
6365	fusion->stream_detect_by_ld =
6366	kcalloc(MAX_LOGICAL_DRIVES_EXT,
6367	size: sizeof(struct LD_STREAM_DETECT *),
6368	GFP_KERNEL);
6369	if (!fusion->stream_detect_by_ld) {
6370	dev_err(&instance->pdev->dev,
6371	"unable to allocate stream detection for pool of LDs\n");
6372	goto fail_get_ld_pd_list;
6373	}
6374	for (i = 0; i < MAX_LOGICAL_DRIVES_EXT; ++i) {
6375	fusion->stream_detect_by_ld[i] =
6376	kzalloc(size: sizeof(struct LD_STREAM_DETECT),
6377	GFP_KERNEL);
6378	if (!fusion->stream_detect_by_ld[i]) {
6379	dev_err(&instance->pdev->dev,
6380	"unable to allocate stream detect by LD\n ");
6381	for (j = 0; j < i; ++j)
6382	kfree(objp: fusion->stream_detect_by_ld[j]);
6383	kfree(objp: fusion->stream_detect_by_ld);
6384	fusion->stream_detect_by_ld = NULL;
6385	goto fail_get_ld_pd_list;
6386	}
6387	fusion->stream_detect_by_ld[i]->mru_bit_map
6388	= MR_STREAM_BITMAP;
6389	}
6390	}
6391
6392	/*
6393	* Compute the max allowed sectors per IO: The controller info has two
6394	* limits on max sectors. Driver should use the minimum of these two.
6395	*
6396	* 1 << stripe_sz_ops.min = max sectors per strip
6397	*
6398	* Note that older firmwares ( < FW ver 30) didn't report information
6399	* to calculate max_sectors_1. So the number ended up as zero always.
6400	*/
6401	tmp_sectors = 0;
6402	ctrl_info = instance->ctrl_info_buf;
6403
6404	max_sectors_1 = (1 << ctrl_info->stripe_sz_ops.min) *
6405	le16_to_cpu(ctrl_info->max_strips_per_io);
6406	max_sectors_2 = le32_to_cpu(ctrl_info->max_request_size);
6407
6408	tmp_sectors = min_t(u32, max_sectors_1, max_sectors_2);
6409
6410	instance->peerIsPresent = ctrl_info->cluster.peerIsPresent;
6411	instance->passive = ctrl_info->cluster.passive;
6412	memcpy(instance->clusterId, ctrl_info->clusterId, sizeof(instance->clusterId));
6413	instance->UnevenSpanSupport =
6414	ctrl_info->adapterOperations2.supportUnevenSpans;
6415	if (instance->UnevenSpanSupport) {
6416	struct fusion_context *fusion = instance->ctrl_context;
6417	if (MR_ValidateMapInfo(instance, map_id: instance->map_id))
6418	fusion->fast_path_io = 1;
6419	else
6420	fusion->fast_path_io = 0;
6421
6422	}
6423	if (ctrl_info->host_interface.SRIOV) {
6424	instance->requestorId = ctrl_info->iov.requestorId;
6425	if (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) {
6426	if (!ctrl_info->adapterOperations2.activePassive)
6427	instance->PlasmaFW111 = 1;
6428
6429	dev_info(&instance->pdev->dev, "SR-IOV: firmware type: %s\n",
6430	instance->PlasmaFW111 ? "1.11" : "new");
6431
6432	if (instance->PlasmaFW111) {
6433	iovPtr = (struct IOV_111 *)
6434	((unsigned char *)ctrl_info + IOV_111_OFFSET);
6435	instance->requestorId = iovPtr->requestorId;
6436	}
6437	}
6438	dev_info(&instance->pdev->dev, "SRIOV: VF requestorId %d\n",
6439	instance->requestorId);
6440	}
6441
6442	instance->crash_dump_fw_support =
6443	ctrl_info->adapterOperations3.supportCrashDump;
6444	instance->crash_dump_drv_support =
6445	(instance->crash_dump_fw_support &&
6446	instance->crash_dump_buf);
6447	if (instance->crash_dump_drv_support)
6448	megasas_set_crash_dump_params(instance,
6449	crash_buf_state: MR_CRASH_BUF_TURN_OFF);
6450
6451	else {
6452	if (instance->crash_dump_buf)
6453	dma_free_coherent(dev: &instance->pdev->dev,
6454	CRASH_DMA_BUF_SIZE,
6455	cpu_addr: instance->crash_dump_buf,
6456	dma_handle: instance->crash_dump_h);
6457	instance->crash_dump_buf = NULL;
6458	}
6459
6460	if (instance->snapdump_wait_time) {
6461	megasas_get_snapdump_properties(instance);
6462	dev_info(&instance->pdev->dev, "Snap dump wait time\t: %d\n",
6463	instance->snapdump_wait_time);
6464	}
6465
6466	dev_info(&instance->pdev->dev,
6467	"pci id\t\t: (0x%04x)/(0x%04x)/(0x%04x)/(0x%04x)\n",
6468	le16_to_cpu(ctrl_info->pci.vendor_id),
6469	le16_to_cpu(ctrl_info->pci.device_id),
6470	le16_to_cpu(ctrl_info->pci.sub_vendor_id),
6471	le16_to_cpu(ctrl_info->pci.sub_device_id));
6472	dev_info(&instance->pdev->dev, "unevenspan support : %s\n",
6473	instance->UnevenSpanSupport ? "yes" : "no");
6474	dev_info(&instance->pdev->dev, "firmware crash dump : %s\n",
6475	instance->crash_dump_drv_support ? "yes" : "no");
6476	dev_info(&instance->pdev->dev, "JBOD sequence map : %s\n",
6477	instance->use_seqnum_jbod_fp ? "enabled" : "disabled");
6478
6479	instance->max_sectors_per_req = instance->max_num_sge *
6480	SGE_BUFFER_SIZE / 512;
6481	if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))
6482	instance->max_sectors_per_req = tmp_sectors;
6483
6484	/* Check for valid throttlequeuedepth module parameter */
6485	if (throttlequeuedepth &&
6486	throttlequeuedepth <= instance->max_scsi_cmds)
6487	instance->throttlequeuedepth = throttlequeuedepth;
6488	else
6489	instance->throttlequeuedepth =
6490	MEGASAS_THROTTLE_QUEUE_DEPTH;
6491
6492	if ((resetwaittime < 1) ||
6493	(resetwaittime > MEGASAS_RESET_WAIT_TIME))
6494	resetwaittime = MEGASAS_RESET_WAIT_TIME;
6495
6496	if ((scmd_timeout < 10) || (scmd_timeout > MEGASAS_DEFAULT_CMD_TIMEOUT))
6497	scmd_timeout = MEGASAS_DEFAULT_CMD_TIMEOUT;
6498
6499	/* Launch SR-IOV heartbeat timer */
6500	if (instance->requestorId) {
6501	if (!megasas_sriov_start_heartbeat(instance, initial: 1)) {
6502	megasas_start_timer(instance);
6503	} else {
6504	instance->skip_heartbeat_timer_del = 1;
6505	goto fail_get_ld_pd_list;
6506	}
6507	}
6508
6509	/*
6510	* Create and start watchdog thread which will monitor
6511	* controller state every 1 sec and trigger OCR when
6512	* it enters fault state
6513	*/
6514	if (instance->adapter_type != MFI_SERIES)
6515	if (megasas_fusion_start_watchdog(instance) != SUCCESS)
6516	goto fail_start_watchdog;
6517
6518	return 0;
6519
6520	fail_start_watchdog:
6521	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
6522	del_timer_sync(timer: &instance->sriov_heartbeat_timer);
6523	fail_get_ld_pd_list:
6524	instance->instancet->disable_intr(instance);
6525	megasas_destroy_irqs(instance);
6526	fail_init_adapter:
6527	if (instance->msix_vectors)
6528	pci_free_irq_vectors(dev: instance->pdev);
6529	instance->msix_vectors = 0;
6530	fail_alloc_dma_buf:
6531	megasas_free_ctrl_dma_buffers(instance);
6532	megasas_free_ctrl_mem(instance);
6533	fail_ready_state:
6534	iounmap(addr: instance->reg_set);
6535
6536	fail_ioremap:
6537	pci_release_selected_regions(instance->pdev, 1<<instance->bar);
6538
6539	dev_err(&instance->pdev->dev, "Failed from %s %d\n",
6540	__func__, __LINE__);
6541	return -EINVAL;
6542	}
6543
6544	/**
6545	* megasas_release_mfi - Reverses the FW initialization
6546	* @instance: Adapter soft state
6547	*/
6548	static void megasas_release_mfi(struct megasas_instance *instance)
6549	{
6550	u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1);
6551
6552	if (instance->reply_queue)
6553	dma_free_coherent(dev: &instance->pdev->dev, size: reply_q_sz,
6554	cpu_addr: instance->reply_queue, dma_handle: instance->reply_queue_h);
6555
6556	megasas_free_cmds(instance);
6557
6558	iounmap(addr: instance->reg_set);
6559
6560	pci_release_selected_regions(instance->pdev, 1<<instance->bar);
6561	}
6562
6563	/**
6564	* megasas_get_seq_num - Gets latest event sequence numbers
6565	* @instance: Adapter soft state
6566	* @eli: FW event log sequence numbers information
6567	*
6568	* FW maintains a log of all events in a non-volatile area. Upper layers would
6569	* usually find out the latest sequence number of the events, the seq number at
6570	* the boot etc. They would "read" all the events below the latest seq number
6571	* by issuing a direct fw cmd (DCMD). For the future events (beyond latest seq
6572	* number), they would subsribe to AEN (asynchronous event notification) and
6573	* wait for the events to happen.
6574	*/
6575	static int
6576	megasas_get_seq_num(struct megasas_instance *instance,
6577	struct megasas_evt_log_info *eli)
6578	{
6579	struct megasas_cmd *cmd;
6580	struct megasas_dcmd_frame *dcmd;
6581	struct megasas_evt_log_info *el_info;
6582	dma_addr_t el_info_h = 0;
6583	int ret;
6584
6585	cmd = megasas_get_cmd(instance);
6586
6587	if (!cmd) {
6588	return -ENOMEM;
6589	}
6590
6591	dcmd = &cmd->frame->dcmd;
6592	el_info = dma_alloc_coherent(dev: &instance->pdev->dev,
6593	size: sizeof(struct megasas_evt_log_info),
6594	dma_handle: &el_info_h, GFP_KERNEL);
6595	if (!el_info) {
6596	megasas_return_cmd(instance, cmd);
6597	return -ENOMEM;
6598	}
6599
6600	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
6601
6602	dcmd->cmd = MFI_CMD_DCMD;
6603	dcmd->cmd_status = 0x0;
6604	dcmd->sge_count = 1;
6605	dcmd->flags = MFI_FRAME_DIR_READ;
6606	dcmd->timeout = 0;
6607	dcmd->pad_0 = 0;
6608	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_log_info));
6609	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_GET_INFO);
6610
6611	megasas_set_dma_settings(instance, dcmd, dma_addr: el_info_h,
6612	dma_len: sizeof(struct megasas_evt_log_info));
6613
6614	ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
6615	if (ret != DCMD_SUCCESS) {
6616	dev_err(&instance->pdev->dev, "Failed from %s %d\n",
6617	__func__, __LINE__);
6618	goto dcmd_failed;
6619	}
6620
6621	/*
6622	* Copy the data back into callers buffer
6623	*/
6624	eli->newest_seq_num = el_info->newest_seq_num;
6625	eli->oldest_seq_num = el_info->oldest_seq_num;
6626	eli->clear_seq_num = el_info->clear_seq_num;
6627	eli->shutdown_seq_num = el_info->shutdown_seq_num;
6628	eli->boot_seq_num = el_info->boot_seq_num;
6629
6630	dcmd_failed:
6631	dma_free_coherent(dev: &instance->pdev->dev,
6632	size: sizeof(struct megasas_evt_log_info),
6633	cpu_addr: el_info, dma_handle: el_info_h);
6634
6635	megasas_return_cmd(instance, cmd);
6636
6637	return ret;
6638	}
6639
6640	/**
6641	* megasas_register_aen - Registers for asynchronous event notification
6642	* @instance: Adapter soft state
6643	* @seq_num: The starting sequence number
6644	* @class_locale_word: Class of the event
6645	*
6646	* This function subscribes for AEN for events beyond the @seq_num. It requests
6647	* to be notified if and only if the event is of type @class_locale
6648	*/
6649	static int
6650	megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
6651	u32 class_locale_word)
6652	{
6653	int ret_val;
6654	struct megasas_cmd *cmd;
6655	struct megasas_dcmd_frame *dcmd;
6656	union megasas_evt_class_locale curr_aen;
6657	union megasas_evt_class_locale prev_aen;
6658
6659	/*
6660	* If there an AEN pending already (aen_cmd), check if the
6661	* class_locale of that pending AEN is inclusive of the new
6662	* AEN request we currently have. If it is, then we don't have
6663	* to do anything. In other words, whichever events the current
6664	* AEN request is subscribing to, have already been subscribed
6665	* to.
6666	*
6667	* If the old_cmd is _not_ inclusive, then we have to abort
6668	* that command, form a class_locale that is superset of both
6669	* old and current and re-issue to the FW
6670	*/
6671
6672	curr_aen.word = class_locale_word;
6673
6674	if (instance->aen_cmd) {
6675
6676	prev_aen.word =
6677	le32_to_cpu(instance->aen_cmd->frame->dcmd.mbox.w[1]);
6678
6679	if ((curr_aen.members.class < MFI_EVT_CLASS_DEBUG) ||
6680	(curr_aen.members.class > MFI_EVT_CLASS_DEAD)) {
6681	dev_info(&instance->pdev->dev,
6682	"%s %d out of range class %d send by application\n",
6683	__func__, __LINE__, curr_aen.members.class);
6684	return 0;
6685	}
6686
6687	/*
6688	* A class whose enum value is smaller is inclusive of all
6689	* higher values. If a PROGRESS (= -1) was previously
6690	* registered, then a new registration requests for higher
6691	* classes need not be sent to FW. They are automatically
6692	* included.
6693	*
6694	* Locale numbers don't have such hierarchy. They are bitmap
6695	* values
6696	*/
6697	if ((prev_aen.members.class <= curr_aen.members.class) &&
6698	!((prev_aen.members.locale & curr_aen.members.locale) ^
6699	curr_aen.members.locale)) {
6700	/*
6701	* Previously issued event registration includes
6702	* current request. Nothing to do.
6703	*/
6704	return 0;
6705	} else {
6706	curr_aen.members.locale |= prev_aen.members.locale;
6707
6708	if (prev_aen.members.class < curr_aen.members.class)
6709	curr_aen.members.class = prev_aen.members.class;
6710
6711	instance->aen_cmd->abort_aen = 1;
6712	ret_val = megasas_issue_blocked_abort_cmd(instance,
6713	cmd_to_abort: instance->
6714	aen_cmd, timeout: 30);
6715
6716	if (ret_val) {
6717	dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to abort "
6718	"previous AEN command\n");
6719	return ret_val;
6720	}
6721	}
6722	}
6723
6724	cmd = megasas_get_cmd(instance);
6725
6726	if (!cmd)
6727	return -ENOMEM;
6728
6729	dcmd = &cmd->frame->dcmd;
6730
6731	memset(instance->evt_detail, 0, sizeof(struct megasas_evt_detail));
6732
6733	/*
6734	* Prepare DCMD for aen registration
6735	*/
6736	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
6737
6738	dcmd->cmd = MFI_CMD_DCMD;
6739	dcmd->cmd_status = 0x0;
6740	dcmd->sge_count = 1;
6741	dcmd->flags = MFI_FRAME_DIR_READ;
6742	dcmd->timeout = 0;
6743	dcmd->pad_0 = 0;
6744	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_detail));
6745	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_WAIT);
6746	dcmd->mbox.w[0] = cpu_to_le32(seq_num);
6747	instance->last_seq_num = seq_num;
6748	dcmd->mbox.w[1] = cpu_to_le32(curr_aen.word);
6749
6750	megasas_set_dma_settings(instance, dcmd, dma_addr: instance->evt_detail_h,
6751	dma_len: sizeof(struct megasas_evt_detail));
6752
6753	if (instance->aen_cmd != NULL) {
6754	megasas_return_cmd(instance, cmd);
6755	return 0;
6756	}
6757
6758	/*
6759	* Store reference to the cmd used to register for AEN. When an
6760	* application wants us to register for AEN, we have to abort this
6761	* cmd and re-register with a new EVENT LOCALE supplied by that app
6762	*/
6763	instance->aen_cmd = cmd;
6764
6765	/*
6766	* Issue the aen registration frame
6767	*/
6768	instance->instancet->issue_dcmd(instance, cmd);
6769
6770	return 0;
6771	}
6772
6773	/* megasas_get_target_prop - Send DCMD with below details to firmware.
6774	*
6775	* This DCMD will fetch few properties of LD/system PD defined
6776	* in MR_TARGET_DEV_PROPERTIES. eg. Queue Depth, MDTS value.
6777	*
6778	* DCMD send by drivers whenever new target is added to the OS.
6779	*
6780	* dcmd.opcode - MR_DCMD_DEV_GET_TARGET_PROP
6781	* dcmd.mbox.b[0] - DCMD is to be fired for LD or system PD.
6782	* 0 = system PD, 1 = LD.
6783	* dcmd.mbox.s[1] - TargetID for LD/system PD.
6784	* dcmd.sge IN - Pointer to return MR_TARGET_DEV_PROPERTIES.
6785	*
6786	* @instance: Adapter soft state
6787	* @sdev: OS provided scsi device
6788	*
6789	* Returns 0 on success non-zero on failure.
6790	*/
6791	int
6792	megasas_get_target_prop(struct megasas_instance *instance,
6793	struct scsi_device *sdev)
6794	{
6795	int ret;
6796	struct megasas_cmd *cmd;
6797	struct megasas_dcmd_frame *dcmd;
6798	u16 targetId = ((sdev->channel % 2) * MEGASAS_MAX_DEV_PER_CHANNEL) +
6799	sdev->id;
6800
6801	cmd = megasas_get_cmd(instance);
6802
6803	if (!cmd) {
6804	dev_err(&instance->pdev->dev,
6805	"Failed to get cmd %s\n", __func__);
6806	return -ENOMEM;
6807	}
6808
6809	dcmd = &cmd->frame->dcmd;
6810
6811	memset(instance->tgt_prop, 0, sizeof(*instance->tgt_prop));
6812	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
6813	dcmd->mbox.b[0] = MEGASAS_IS_LOGICAL(sdev);
6814
6815	dcmd->mbox.s[1] = cpu_to_le16(targetId);
6816	dcmd->cmd = MFI_CMD_DCMD;
6817	dcmd->cmd_status = 0xFF;
6818	dcmd->sge_count = 1;
6819	dcmd->flags = MFI_FRAME_DIR_READ;
6820	dcmd->timeout = 0;
6821	dcmd->pad_0 = 0;
6822	dcmd->data_xfer_len =
6823	cpu_to_le32(sizeof(struct MR_TARGET_PROPERTIES));
6824	dcmd->opcode = cpu_to_le32(MR_DCMD_DRV_GET_TARGET_PROP);
6825
6826	megasas_set_dma_settings(instance, dcmd, dma_addr: instance->tgt_prop_h,
6827	dma_len: sizeof(struct MR_TARGET_PROPERTIES));
6828
6829	if ((instance->adapter_type != MFI_SERIES) &&
6830	!instance->mask_interrupts)
6831	ret = megasas_issue_blocked_cmd(instance,
6832	cmd, MFI_IO_TIMEOUT_SECS);
6833	else
6834	ret = megasas_issue_polled(instance, cmd);
6835
6836	switch (ret) {
6837	case DCMD_TIMEOUT:
6838	switch (dcmd_timeout_ocr_possible(instance)) {
6839	case INITIATE_OCR:
6840	cmd->flags |= DRV_DCMD_SKIP_REFIRE;
6841	mutex_unlock(lock: &instance->reset_mutex);
6842	megasas_reset_fusion(shost: instance->host,
6843	reason: MFI_IO_TIMEOUT_OCR);
6844	mutex_lock(&instance->reset_mutex);
6845	break;
6846	case KILL_ADAPTER:
6847	megaraid_sas_kill_hba(instance);
6848	break;
6849	case IGNORE_TIMEOUT:
6850	dev_info(&instance->pdev->dev,
6851	"Ignore DCMD timeout: %s %d\n",
6852	__func__, __LINE__);
6853	break;
6854	}
6855	break;
6856
6857	default:
6858	megasas_return_cmd(instance, cmd);
6859	}
6860	if (ret != DCMD_SUCCESS)
6861	dev_err(&instance->pdev->dev,
6862	"return from %s %d return value %d\n",
6863	__func__, __LINE__, ret);
6864
6865	return ret;
6866	}
6867
6868	/**
6869	* megasas_start_aen - Subscribes to AEN during driver load time
6870	* @instance: Adapter soft state
6871	*/
6872	static int megasas_start_aen(struct megasas_instance *instance)
6873	{
6874	struct megasas_evt_log_info eli;
6875	union megasas_evt_class_locale class_locale;
6876
6877	/*
6878	* Get the latest sequence number from FW
6879	*/
6880	memset(&eli, 0, sizeof(eli));
6881
6882	if (megasas_get_seq_num(instance, eli: &eli))
6883	return -1;
6884
6885	/*
6886	* Register AEN with FW for latest sequence number plus 1
6887	*/
6888	class_locale.members.reserved = 0;
6889	class_locale.members.locale = MR_EVT_LOCALE_ALL;
6890	class_locale.members.class = MR_EVT_CLASS_DEBUG;
6891
6892	return megasas_register_aen(instance,
6893	le32_to_cpu(eli.newest_seq_num) + 1,
6894	class_locale_word: class_locale.word);
6895	}
6896
6897	/**
6898	* megasas_io_attach - Attaches this driver to SCSI mid-layer
6899	* @instance: Adapter soft state
6900	*/
6901	static int megasas_io_attach(struct megasas_instance *instance)
6902	{
6903	struct Scsi_Host *host = instance->host;
6904
6905	/*
6906	* Export parameters required by SCSI mid-layer
6907	*/
6908	host->unique_id = instance->unique_id;
6909	host->can_queue = instance->max_scsi_cmds;
6910	host->this_id = instance->init_id;
6911	host->sg_tablesize = instance->max_num_sge;
6912
6913	if (instance->fw_support_ieee)
6914	instance->max_sectors_per_req = MEGASAS_MAX_SECTORS_IEEE;
6915
6916	/*
6917	* Check if the module parameter value for max_sectors can be used
6918	*/
6919	if (max_sectors && max_sectors < instance->max_sectors_per_req)
6920	instance->max_sectors_per_req = max_sectors;
6921	else {
6922	if (max_sectors) {
6923	if (((instance->pdev->device ==
6924	PCI_DEVICE_ID_LSI_SAS1078GEN2) ||
6925	(instance->pdev->device ==
6926	PCI_DEVICE_ID_LSI_SAS0079GEN2)) &&
6927	(max_sectors <= MEGASAS_MAX_SECTORS)) {
6928	instance->max_sectors_per_req = max_sectors;
6929	} else {
6930	dev_info(&instance->pdev->dev, "max_sectors should be > 0"
6931	"and <= %d (or < 1MB for GEN2 controller)\n",
6932	instance->max_sectors_per_req);
6933	}
6934	}
6935	}
6936
6937	host->max_sectors = instance->max_sectors_per_req;
6938	host->cmd_per_lun = MEGASAS_DEFAULT_CMD_PER_LUN;
6939	host->max_channel = MEGASAS_MAX_CHANNELS - 1;
6940	host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL;
6941	host->max_lun = MEGASAS_MAX_LUN;
6942	host->max_cmd_len = 16;
6943
6944	/* Use shared host tagset only for fusion adaptors
6945	* if there are managed interrupts (smp affinity enabled case).
6946	* Single msix_vectors in kdump, so shared host tag is also disabled.
6947	*/
6948
6949	host->host_tagset = 0;
6950	host->nr_hw_queues = 1;
6951
6952	if ((instance->adapter_type != MFI_SERIES) &&
6953	(instance->msix_vectors > instance->low_latency_index_start) &&
6954	host_tagset_enable &&
6955	instance->smp_affinity_enable) {
6956	host->host_tagset = 1;
6957	host->nr_hw_queues = instance->msix_vectors -
6958	instance->low_latency_index_start + instance->iopoll_q_count;
6959	if (instance->iopoll_q_count)
6960	host->nr_maps = 3;
6961	} else {
6962	instance->iopoll_q_count = 0;
6963	}
6964
6965	dev_info(&instance->pdev->dev,
6966	"Max firmware commands: %d shared with default "
6967	"hw_queues = %d poll_queues %d\n", instance->max_fw_cmds,
6968	host->nr_hw_queues - instance->iopoll_q_count,
6969	instance->iopoll_q_count);
6970	/*
6971	* Notify the mid-layer about the new controller
6972	*/
6973	if (scsi_add_host(host, dev: &instance->pdev->dev)) {
6974	dev_err(&instance->pdev->dev,
6975	"Failed to add host from %s %d\n",
6976	__func__, __LINE__);
6977	return -ENODEV;
6978	}
6979
6980	return 0;
6981	}
6982
6983	/**
6984	* megasas_set_dma_mask - Set DMA mask for supported controllers
6985	*
6986	* @instance: Adapter soft state
6987	* Description:
6988	*
6989	* For Ventura, driver/FW will operate in 63bit DMA addresses.
6990	*
6991	* For invader-
6992	* By default, driver/FW will operate in 32bit DMA addresses
6993	* for consistent DMA mapping but if 32 bit consistent
6994	* DMA mask fails, driver will try with 63 bit consistent
6995	* mask provided FW is true 63bit DMA capable
6996	*
6997	* For older controllers(Thunderbolt and MFI based adapters)-
6998	* driver/FW will operate in 32 bit consistent DMA addresses.
6999	*/
7000	static int
7001	megasas_set_dma_mask(struct megasas_instance *instance)
7002	{
7003	u64 consistent_mask;
7004	struct pci_dev *pdev;
7005	u32 scratch_pad_1;
7006
7007	pdev = instance->pdev;
7008	consistent_mask = (instance->adapter_type >= VENTURA_SERIES) ?
7009	DMA_BIT_MASK(63) : DMA_BIT_MASK(32);
7010
7011	if (IS_DMA64) {
7012	if (dma_set_mask(dev: &pdev->dev, DMA_BIT_MASK(63)) &&
7013	dma_set_mask_and_coherent(dev: &pdev->dev, DMA_BIT_MASK(32)))
7014	goto fail_set_dma_mask;
7015
7016	if ((*pdev->dev.dma_mask == DMA_BIT_MASK(63)) &&
7017	(dma_set_coherent_mask(dev: &pdev->dev, mask: consistent_mask) &&
7018	dma_set_mask_and_coherent(dev: &pdev->dev, DMA_BIT_MASK(32)))) {
7019	/*
7020	* If 32 bit DMA mask fails, then try for 64 bit mask
7021	* for FW capable of handling 64 bit DMA.
7022	*/
7023	scratch_pad_1 = megasas_readl
7024	(instance, addr: &instance->reg_set->outbound_scratch_pad_1);
7025
7026	if (!(scratch_pad_1 & MR_CAN_HANDLE_64_BIT_DMA_OFFSET))
7027	goto fail_set_dma_mask;
7028	else if (dma_set_mask_and_coherent(dev: &pdev->dev,
7029	DMA_BIT_MASK(63)))
7030	goto fail_set_dma_mask;
7031	}
7032	} else if (dma_set_mask_and_coherent(dev: &pdev->dev, DMA_BIT_MASK(32)))
7033	goto fail_set_dma_mask;
7034
7035	if (pdev->dev.coherent_dma_mask == DMA_BIT_MASK(32))
7036	instance->consistent_mask_64bit = false;
7037	else
7038	instance->consistent_mask_64bit = true;
7039
7040	dev_info(&pdev->dev, "%s bit DMA mask and %s bit consistent mask\n",
7041	((*pdev->dev.dma_mask == DMA_BIT_MASK(63)) ? "63" : "32"),
7042	(instance->consistent_mask_64bit ? "63" : "32"));
7043
7044	return 0;
7045
7046	fail_set_dma_mask:
7047	dev_err(&pdev->dev, "Failed to set DMA mask\n");
7048	return -1;
7049
7050	}
7051
7052	/*
7053	* megasas_set_adapter_type - Set adapter type.
7054	* Supported controllers can be divided in
7055	* different categories-
7056	* enum MR_ADAPTER_TYPE {
7057	* MFI_SERIES = 1,
7058	* THUNDERBOLT_SERIES = 2,
7059	* INVADER_SERIES = 3,
7060	* VENTURA_SERIES = 4,
7061	* AERO_SERIES = 5,
7062	* };
7063	* @instance: Adapter soft state
7064	* return: void
7065	*/
7066	static inline void megasas_set_adapter_type(struct megasas_instance *instance)
7067	{
7068	if ((instance->pdev->vendor == PCI_VENDOR_ID_DELL) &&
7069	(instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5)) {
7070	instance->adapter_type = MFI_SERIES;
7071	} else {
7072	switch (instance->pdev->device) {
7073	case PCI_DEVICE_ID_LSI_AERO_10E1:
7074	case PCI_DEVICE_ID_LSI_AERO_10E2:
7075	case PCI_DEVICE_ID_LSI_AERO_10E5:
7076	case PCI_DEVICE_ID_LSI_AERO_10E6:
7077	instance->adapter_type = AERO_SERIES;
7078	break;
7079	case PCI_DEVICE_ID_LSI_VENTURA:
7080	case PCI_DEVICE_ID_LSI_CRUSADER:
7081	case PCI_DEVICE_ID_LSI_HARPOON:
7082	case PCI_DEVICE_ID_LSI_TOMCAT:
7083	case PCI_DEVICE_ID_LSI_VENTURA_4PORT:
7084	case PCI_DEVICE_ID_LSI_CRUSADER_4PORT:
7085	instance->adapter_type = VENTURA_SERIES;
7086	break;
7087	case PCI_DEVICE_ID_LSI_FUSION:
7088	case PCI_DEVICE_ID_LSI_PLASMA:
7089	instance->adapter_type = THUNDERBOLT_SERIES;
7090	break;
7091	case PCI_DEVICE_ID_LSI_INVADER:
7092	case PCI_DEVICE_ID_LSI_INTRUDER:
7093	case PCI_DEVICE_ID_LSI_INTRUDER_24:
7094	case PCI_DEVICE_ID_LSI_CUTLASS_52:
7095	case PCI_DEVICE_ID_LSI_CUTLASS_53:
7096	case PCI_DEVICE_ID_LSI_FURY:
7097	instance->adapter_type = INVADER_SERIES;
7098	break;
7099	default: /* For all other supported controllers */
7100	instance->adapter_type = MFI_SERIES;
7101	break;
7102	}
7103	}
7104	}
7105
7106	static inline int megasas_alloc_mfi_ctrl_mem(struct megasas_instance *instance)
7107	{
7108	instance->producer = dma_alloc_coherent(dev: &instance->pdev->dev,
7109	size: sizeof(u32), dma_handle: &instance->producer_h, GFP_KERNEL);
7110	instance->consumer = dma_alloc_coherent(dev: &instance->pdev->dev,
7111	size: sizeof(u32), dma_handle: &instance->consumer_h, GFP_KERNEL);
7112
7113	if (!instance->producer || !instance->consumer) {
7114	dev_err(&instance->pdev->dev,
7115	"Failed to allocate memory for producer, consumer\n");
7116	return -1;
7117	}
7118
7119	*instance->producer = 0;
7120	*instance->consumer = 0;
7121	return 0;
7122	}
7123
7124	/**
7125	* megasas_alloc_ctrl_mem - Allocate per controller memory for core data
7126	* structures which are not common across MFI
7127	* adapters and fusion adapters.
7128	* For MFI based adapters, allocate producer and
7129	* consumer buffers. For fusion adapters, allocate
7130	* memory for fusion context.
7131	* @instance: Adapter soft state
7132	* return: 0 for SUCCESS
7133	*/
7134	static int megasas_alloc_ctrl_mem(struct megasas_instance *instance)
7135	{
7136	instance->reply_map = kcalloc(n: nr_cpu_ids, size: sizeof(unsigned int),
7137	GFP_KERNEL);
7138	if (!instance->reply_map)
7139	return -ENOMEM;
7140
7141	switch (instance->adapter_type) {
7142	case MFI_SERIES:
7143	if (megasas_alloc_mfi_ctrl_mem(instance))
7144	return -ENOMEM;
7145	break;
7146	case AERO_SERIES:
7147	case VENTURA_SERIES:
7148	case THUNDERBOLT_SERIES:
7149	case INVADER_SERIES:
7150	if (megasas_alloc_fusion_context(instance))
7151	return -ENOMEM;
7152	break;
7153	}
7154
7155	return 0;
7156	}
7157
7158	/*
7159	* megasas_free_ctrl_mem - Free fusion context for fusion adapters and
7160	* producer, consumer buffers for MFI adapters
7161	*
7162	* @instance - Adapter soft instance
7163	*
7164	*/
7165	static inline void megasas_free_ctrl_mem(struct megasas_instance *instance)
7166	{
7167	kfree(objp: instance->reply_map);
7168	if (instance->adapter_type == MFI_SERIES) {
7169	if (instance->producer)
7170	dma_free_coherent(dev: &instance->pdev->dev, size: sizeof(u32),
7171	cpu_addr: instance->producer,
7172	dma_handle: instance->producer_h);
7173	if (instance->consumer)
7174	dma_free_coherent(dev: &instance->pdev->dev, size: sizeof(u32),
7175	cpu_addr: instance->consumer,
7176	dma_handle: instance->consumer_h);
7177	} else {
7178	megasas_free_fusion_context(instance);
7179	}
7180	}
7181
7182	/**
7183	* megasas_alloc_ctrl_dma_buffers - Allocate consistent DMA buffers during
7184	* driver load time
7185	*
7186	* @instance: Adapter soft instance
7187	*
7188	* @return: O for SUCCESS
7189	*/
7190	static inline
7191	int megasas_alloc_ctrl_dma_buffers(struct megasas_instance *instance)
7192	{
7193	struct pci_dev *pdev = instance->pdev;
7194	struct fusion_context *fusion = instance->ctrl_context;
7195
7196	instance->evt_detail = dma_alloc_coherent(dev: &pdev->dev,
7197	size: sizeof(struct megasas_evt_detail),
7198	dma_handle: &instance->evt_detail_h, GFP_KERNEL);
7199
7200	if (!instance->evt_detail) {
7201	dev_err(&instance->pdev->dev,
7202	"Failed to allocate event detail buffer\n");
7203	return -ENOMEM;
7204	}
7205
7206	if (fusion) {
7207	fusion->ioc_init_request =
7208	dma_alloc_coherent(dev: &pdev->dev,
7209	size: sizeof(struct MPI2_IOC_INIT_REQUEST),
7210	dma_handle: &fusion->ioc_init_request_phys,
7211	GFP_KERNEL);
7212
7213	if (!fusion->ioc_init_request) {
7214	dev_err(&pdev->dev,
7215	"Failed to allocate ioc init request\n");
7216	return -ENOMEM;
7217	}
7218
7219	instance->snapdump_prop = dma_alloc_coherent(dev: &pdev->dev,
7220	size: sizeof(struct MR_SNAPDUMP_PROPERTIES),
7221	dma_handle: &instance->snapdump_prop_h, GFP_KERNEL);
7222
7223	if (!instance->snapdump_prop)
7224	dev_err(&pdev->dev,
7225	"Failed to allocate snapdump properties buffer\n");
7226
7227	instance->host_device_list_buf = dma_alloc_coherent(dev: &pdev->dev,
7228	HOST_DEVICE_LIST_SZ,
7229	dma_handle: &instance->host_device_list_buf_h,
7230	GFP_KERNEL);
7231
7232	if (!instance->host_device_list_buf) {
7233	dev_err(&pdev->dev,
7234	"Failed to allocate targetid list buffer\n");
7235	return -ENOMEM;
7236	}
7237
7238	}
7239
7240	instance->pd_list_buf =
7241	dma_alloc_coherent(dev: &pdev->dev,
7242	MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
7243	dma_handle: &instance->pd_list_buf_h, GFP_KERNEL);
7244
7245	if (!instance->pd_list_buf) {
7246	dev_err(&pdev->dev, "Failed to allocate PD list buffer\n");
7247	return -ENOMEM;
7248	}
7249
7250	instance->ctrl_info_buf =
7251	dma_alloc_coherent(dev: &pdev->dev,
7252	size: sizeof(struct megasas_ctrl_info),
7253	dma_handle: &instance->ctrl_info_buf_h, GFP_KERNEL);
7254
7255	if (!instance->ctrl_info_buf) {
7256	dev_err(&pdev->dev,
7257	"Failed to allocate controller info buffer\n");
7258	return -ENOMEM;
7259	}
7260
7261	instance->ld_list_buf =
7262	dma_alloc_coherent(dev: &pdev->dev,
7263	size: sizeof(struct MR_LD_LIST),
7264	dma_handle: &instance->ld_list_buf_h, GFP_KERNEL);
7265
7266	if (!instance->ld_list_buf) {
7267	dev_err(&pdev->dev, "Failed to allocate LD list buffer\n");
7268	return -ENOMEM;
7269	}
7270
7271	instance->ld_targetid_list_buf =
7272	dma_alloc_coherent(dev: &pdev->dev,
7273	size: sizeof(struct MR_LD_TARGETID_LIST),
7274	dma_handle: &instance->ld_targetid_list_buf_h, GFP_KERNEL);
7275
7276	if (!instance->ld_targetid_list_buf) {
7277	dev_err(&pdev->dev,
7278	"Failed to allocate LD targetid list buffer\n");
7279	return -ENOMEM;
7280	}
7281
7282	if (!reset_devices) {
7283	instance->system_info_buf =
7284	dma_alloc_coherent(dev: &pdev->dev,
7285	size: sizeof(struct MR_DRV_SYSTEM_INFO),
7286	dma_handle: &instance->system_info_h, GFP_KERNEL);
7287	instance->pd_info =
7288	dma_alloc_coherent(dev: &pdev->dev,
7289	size: sizeof(struct MR_PD_INFO),
7290	dma_handle: &instance->pd_info_h, GFP_KERNEL);
7291	instance->tgt_prop =
7292	dma_alloc_coherent(dev: &pdev->dev,
7293	size: sizeof(struct MR_TARGET_PROPERTIES),
7294	dma_handle: &instance->tgt_prop_h, GFP_KERNEL);
7295	instance->crash_dump_buf =
7296	dma_alloc_coherent(dev: &pdev->dev, CRASH_DMA_BUF_SIZE,
7297	dma_handle: &instance->crash_dump_h, GFP_KERNEL);
7298
7299	if (!instance->system_info_buf)
7300	dev_err(&instance->pdev->dev,
7301	"Failed to allocate system info buffer\n");
7302
7303	if (!instance->pd_info)
7304	dev_err(&instance->pdev->dev,
7305	"Failed to allocate pd_info buffer\n");
7306
7307	if (!instance->tgt_prop)
7308	dev_err(&instance->pdev->dev,
7309	"Failed to allocate tgt_prop buffer\n");
7310
7311	if (!instance->crash_dump_buf)
7312	dev_err(&instance->pdev->dev,
7313	"Failed to allocate crash dump buffer\n");
7314	}
7315
7316	return 0;
7317	}
7318
7319	/*
7320	* megasas_free_ctrl_dma_buffers - Free consistent DMA buffers allocated
7321	* during driver load time
7322	*
7323	* @instance- Adapter soft instance
7324	*
7325	*/
7326	static inline
7327	void megasas_free_ctrl_dma_buffers(struct megasas_instance *instance)
7328	{
7329	struct pci_dev *pdev = instance->pdev;
7330	struct fusion_context *fusion = instance->ctrl_context;
7331
7332	if (instance->evt_detail)
7333	dma_free_coherent(dev: &pdev->dev, size: sizeof(struct megasas_evt_detail),
7334	cpu_addr: instance->evt_detail,
7335	dma_handle: instance->evt_detail_h);
7336
7337	if (fusion && fusion->ioc_init_request)
7338	dma_free_coherent(dev: &pdev->dev,
7339	size: sizeof(struct MPI2_IOC_INIT_REQUEST),
7340	cpu_addr: fusion->ioc_init_request,
7341	dma_handle: fusion->ioc_init_request_phys);
7342
7343	if (instance->pd_list_buf)
7344	dma_free_coherent(dev: &pdev->dev,
7345	MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
7346	cpu_addr: instance->pd_list_buf,
7347	dma_handle: instance->pd_list_buf_h);
7348
7349	if (instance->ld_list_buf)
7350	dma_free_coherent(dev: &pdev->dev, size: sizeof(struct MR_LD_LIST),
7351	cpu_addr: instance->ld_list_buf,
7352	dma_handle: instance->ld_list_buf_h);
7353
7354	if (instance->ld_targetid_list_buf)
7355	dma_free_coherent(dev: &pdev->dev, size: sizeof(struct MR_LD_TARGETID_LIST),
7356	cpu_addr: instance->ld_targetid_list_buf,
7357	dma_handle: instance->ld_targetid_list_buf_h);
7358
7359	if (instance->ctrl_info_buf)
7360	dma_free_coherent(dev: &pdev->dev, size: sizeof(struct megasas_ctrl_info),
7361	cpu_addr: instance->ctrl_info_buf,
7362	dma_handle: instance->ctrl_info_buf_h);
7363
7364	if (instance->system_info_buf)
7365	dma_free_coherent(dev: &pdev->dev, size: sizeof(struct MR_DRV_SYSTEM_INFO),
7366	cpu_addr: instance->system_info_buf,
7367	dma_handle: instance->system_info_h);
7368
7369	if (instance->pd_info)
7370	dma_free_coherent(dev: &pdev->dev, size: sizeof(struct MR_PD_INFO),
7371	cpu_addr: instance->pd_info, dma_handle: instance->pd_info_h);
7372
7373	if (instance->tgt_prop)
7374	dma_free_coherent(dev: &pdev->dev, size: sizeof(struct MR_TARGET_PROPERTIES),
7375	cpu_addr: instance->tgt_prop, dma_handle: instance->tgt_prop_h);
7376
7377	if (instance->crash_dump_buf)
7378	dma_free_coherent(dev: &pdev->dev, CRASH_DMA_BUF_SIZE,
7379	cpu_addr: instance->crash_dump_buf,
7380	dma_handle: instance->crash_dump_h);
7381
7382	if (instance->snapdump_prop)
7383	dma_free_coherent(dev: &pdev->dev,
7384	size: sizeof(struct MR_SNAPDUMP_PROPERTIES),
7385	cpu_addr: instance->snapdump_prop,
7386	dma_handle: instance->snapdump_prop_h);
7387
7388	if (instance->host_device_list_buf)
7389	dma_free_coherent(dev: &pdev->dev,
7390	HOST_DEVICE_LIST_SZ,
7391	cpu_addr: instance->host_device_list_buf,
7392	dma_handle: instance->host_device_list_buf_h);
7393
7394	}
7395
7396	/*
7397	* megasas_init_ctrl_params - Initialize controller's instance
7398	* parameters before FW init
7399	* @instance - Adapter soft instance
7400	* @return - void
7401	*/
7402	static inline void megasas_init_ctrl_params(struct megasas_instance *instance)
7403	{
7404	instance->fw_crash_state = UNAVAILABLE;
7405
7406	megasas_poll_wait_aen = 0;
7407	instance->issuepend_done = 1;
7408	atomic_set(v: &instance->adprecovery, i: MEGASAS_HBA_OPERATIONAL);
7409
7410	/*
7411	* Initialize locks and queues
7412	*/
7413	INIT_LIST_HEAD(list: &instance->cmd_pool);
7414	INIT_LIST_HEAD(list: &instance->internal_reset_pending_q);
7415
7416	atomic_set(v: &instance->fw_outstanding, i: 0);
7417	atomic64_set(v: &instance->total_io_count, i: 0);
7418
7419	init_waitqueue_head(&instance->int_cmd_wait_q);
7420	init_waitqueue_head(&instance->abort_cmd_wait_q);
7421
7422	mutex_init(&instance->crashdump_lock);
7423	spin_lock_init(&instance->mfi_pool_lock);
7424	spin_lock_init(&instance->hba_lock);
7425	spin_lock_init(&instance->stream_lock);
7426	spin_lock_init(&instance->completion_lock);
7427
7428	mutex_init(&instance->reset_mutex);
7429
7430	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
7431	(instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY))
7432	instance->flag_ieee = 1;
7433
7434	instance->flag = 0;
7435	instance->unload = 1;
7436	instance->last_time = 0;
7437	instance->disableOnlineCtrlReset = 1;
7438	instance->UnevenSpanSupport = 0;
7439	instance->smp_affinity_enable = smp_affinity_enable ? true : false;
7440	instance->msix_load_balance = false;
7441
7442	if (instance->adapter_type != MFI_SERIES)
7443	INIT_WORK(&instance->work_init, megasas_fusion_ocr_wq);
7444	else
7445	INIT_WORK(&instance->work_init, process_fw_state_change_wq);
7446	}
7447
7448	/**
7449	* megasas_probe_one - PCI hotplug entry point
7450	* @pdev: PCI device structure
7451	* @id: PCI ids of supported hotplugged adapter
7452	*/
7453	static int megasas_probe_one(struct pci_dev *pdev,
7454	const struct pci_device_id *id)
7455	{
7456	int rval, pos;
7457	struct Scsi_Host *host;
7458	struct megasas_instance *instance;
7459	u16 control = 0;
7460
7461	switch (pdev->device) {
7462	case PCI_DEVICE_ID_LSI_AERO_10E0:
7463	case PCI_DEVICE_ID_LSI_AERO_10E3:
7464	case PCI_DEVICE_ID_LSI_AERO_10E4:
7465	case PCI_DEVICE_ID_LSI_AERO_10E7:
7466	dev_err(&pdev->dev, "Adapter is in non secure mode\n");
7467	return 1;
7468	case PCI_DEVICE_ID_LSI_AERO_10E1:
7469	case PCI_DEVICE_ID_LSI_AERO_10E5:
7470	dev_info(&pdev->dev, "Adapter is in configurable secure mode\n");
7471	break;
7472	}
7473
7474	/* Reset MSI-X in the kdump kernel */
7475	if (reset_devices) {
7476	pos = pci_find_capability(dev: pdev, PCI_CAP_ID_MSIX);
7477	if (pos) {
7478	pci_read_config_word(dev: pdev, where: pos + PCI_MSIX_FLAGS,
7479	val: &control);
7480	if (control & PCI_MSIX_FLAGS_ENABLE) {
7481	dev_info(&pdev->dev, "resetting MSI-X\n");
7482	pci_write_config_word(dev: pdev,
7483	where: pos + PCI_MSIX_FLAGS,
7484	val: control &
7485	~PCI_MSIX_FLAGS_ENABLE);
7486	}
7487	}
7488	}
7489
7490	/*
7491	* PCI prepping: enable device set bus mastering and dma mask
7492	*/
7493	rval = pci_enable_device_mem(dev: pdev);
7494
7495	if (rval) {
7496	return rval;
7497	}
7498
7499	pci_set_master(dev: pdev);
7500
7501	host = scsi_host_alloc(&megasas_template,
7502	sizeof(struct megasas_instance));
7503
7504	if (!host) {
7505	dev_printk(KERN_DEBUG, &pdev->dev, "scsi_host_alloc failed\n");
7506	goto fail_alloc_instance;
7507	}
7508
7509	instance = (struct megasas_instance *)host->hostdata;
7510	memset(instance, 0, sizeof(*instance));
7511	atomic_set(v: &instance->fw_reset_no_pci_access, i: 0);
7512
7513	/*
7514	* Initialize PCI related and misc parameters
7515	*/
7516	instance->pdev = pdev;
7517	instance->host = host;
7518	instance->unique_id = pci_dev_id(dev: pdev);
7519	instance->init_id = MEGASAS_DEFAULT_INIT_ID;
7520
7521	megasas_set_adapter_type(instance);
7522
7523	/*
7524	* Initialize MFI Firmware
7525	*/
7526	if (megasas_init_fw(instance))
7527	goto fail_init_mfi;
7528
7529	if (instance->requestorId) {
7530	if (instance->PlasmaFW111) {
7531	instance->vf_affiliation_111 =
7532	dma_alloc_coherent(dev: &pdev->dev,
7533	size: sizeof(struct MR_LD_VF_AFFILIATION_111),
7534	dma_handle: &instance->vf_affiliation_111_h,
7535	GFP_KERNEL);
7536	if (!instance->vf_affiliation_111)
7537	dev_warn(&pdev->dev, "Can't allocate "
7538	"memory for VF affiliation buffer\n");
7539	} else {
7540	instance->vf_affiliation =
7541	dma_alloc_coherent(dev: &pdev->dev,
7542	size: (MAX_LOGICAL_DRIVES + 1) *
7543	sizeof(struct MR_LD_VF_AFFILIATION),
7544	dma_handle: &instance->vf_affiliation_h,
7545	GFP_KERNEL);
7546	if (!instance->vf_affiliation)
7547	dev_warn(&pdev->dev, "Can't allocate "
7548	"memory for VF affiliation buffer\n");
7549	}
7550	}
7551
7552	/*
7553	* Store instance in PCI softstate
7554	*/
7555	pci_set_drvdata(pdev, data: instance);
7556
7557	/*
7558	* Add this controller to megasas_mgmt_info structure so that it
7559	* can be exported to management applications
7560	*/
7561	megasas_mgmt_info.count++;
7562	megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance;
7563	megasas_mgmt_info.max_index++;
7564
7565	/*
7566	* Register with SCSI mid-layer
7567	*/
7568	if (megasas_io_attach(instance))
7569	goto fail_io_attach;
7570
7571	instance->unload = 0;
7572	/*
7573	* Trigger SCSI to scan our drives
7574	*/
7575	if (!instance->enable_fw_dev_list ||
7576	(instance->host_device_list_buf->count > 0))
7577	scsi_scan_host(host);
7578
7579	/*
7580	* Initiate AEN (Asynchronous Event Notification)
7581	*/
7582	if (megasas_start_aen(instance)) {
7583	dev_printk(KERN_DEBUG, &pdev->dev, "start aen failed\n");
7584	goto fail_start_aen;
7585	}
7586
7587	megasas_setup_debugfs(instance);
7588
7589	/* Get current SR-IOV LD/VF affiliation */
7590	if (instance->requestorId)
7591	megasas_get_ld_vf_affiliation(instance, initial: 1);
7592
7593	return 0;
7594
7595	fail_start_aen:
7596	instance->unload = 1;
7597	scsi_remove_host(instance->host);
7598	fail_io_attach:
7599	megasas_mgmt_info.count--;
7600	megasas_mgmt_info.max_index--;
7601	megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL;
7602
7603	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7604	del_timer_sync(timer: &instance->sriov_heartbeat_timer);
7605
7606	instance->instancet->disable_intr(instance);
7607	megasas_destroy_irqs(instance);
7608
7609	if (instance->adapter_type != MFI_SERIES)
7610	megasas_release_fusion(instance);
7611	else
7612	megasas_release_mfi(instance);
7613
7614	if (instance->msix_vectors)
7615	pci_free_irq_vectors(dev: instance->pdev);
7616	instance->msix_vectors = 0;
7617
7618	if (instance->fw_crash_state != UNAVAILABLE)
7619	megasas_free_host_crash_buffer(instance);
7620
7621	if (instance->adapter_type != MFI_SERIES)
7622	megasas_fusion_stop_watchdog(instance);
7623	fail_init_mfi:
7624	scsi_host_put(t: host);
7625	fail_alloc_instance:
7626	pci_disable_device(dev: pdev);
7627
7628	return -ENODEV;
7629	}
7630
7631	/**
7632	* megasas_flush_cache - Requests FW to flush all its caches
7633	* @instance: Adapter soft state
7634	*/
7635	static void megasas_flush_cache(struct megasas_instance *instance)
7636	{
7637	struct megasas_cmd *cmd;
7638	struct megasas_dcmd_frame *dcmd;
7639
7640	if (atomic_read(v: &instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
7641	return;
7642
7643	cmd = megasas_get_cmd(instance);
7644
7645	if (!cmd)
7646	return;
7647
7648	dcmd = &cmd->frame->dcmd;
7649
7650	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
7651
7652	dcmd->cmd = MFI_CMD_DCMD;
7653	dcmd->cmd_status = 0x0;
7654	dcmd->sge_count = 0;
7655	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE);
7656	dcmd->timeout = 0;
7657	dcmd->pad_0 = 0;
7658	dcmd->data_xfer_len = 0;
7659	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_CACHE_FLUSH);
7660	dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
7661
7662	if (megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS)
7663	!= DCMD_SUCCESS) {
7664	dev_err(&instance->pdev->dev,
7665	"return from %s %d\n", __func__, __LINE__);
7666	return;
7667	}
7668
7669	megasas_return_cmd(instance, cmd);
7670	}
7671
7672	/**
7673	* megasas_shutdown_controller - Instructs FW to shutdown the controller
7674	* @instance: Adapter soft state
7675	* @opcode: Shutdown/Hibernate
7676	*/
7677	static void megasas_shutdown_controller(struct megasas_instance *instance,
7678	u32 opcode)
7679	{
7680	struct megasas_cmd *cmd;
7681	struct megasas_dcmd_frame *dcmd;
7682
7683	if (atomic_read(v: &instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
7684	return;
7685
7686	cmd = megasas_get_cmd(instance);
7687
7688	if (!cmd)
7689	return;
7690
7691	if (instance->aen_cmd)
7692	megasas_issue_blocked_abort_cmd(instance,
7693	cmd_to_abort: instance->aen_cmd, MFI_IO_TIMEOUT_SECS);
7694	if (instance->map_update_cmd)
7695	megasas_issue_blocked_abort_cmd(instance,
7696	cmd_to_abort: instance->map_update_cmd, MFI_IO_TIMEOUT_SECS);
7697	if (instance->jbod_seq_cmd)
7698	megasas_issue_blocked_abort_cmd(instance,
7699	cmd_to_abort: instance->jbod_seq_cmd, MFI_IO_TIMEOUT_SECS);
7700
7701	dcmd = &cmd->frame->dcmd;
7702
7703	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
7704
7705	dcmd->cmd = MFI_CMD_DCMD;
7706	dcmd->cmd_status = 0x0;
7707	dcmd->sge_count = 0;
7708	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE);
7709	dcmd->timeout = 0;
7710	dcmd->pad_0 = 0;
7711	dcmd->data_xfer_len = 0;
7712	dcmd->opcode = cpu_to_le32(opcode);
7713
7714	if (megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS)
7715	!= DCMD_SUCCESS) {
7716	dev_err(&instance->pdev->dev,
7717	"return from %s %d\n", __func__, __LINE__);
7718	return;
7719	}
7720
7721	megasas_return_cmd(instance, cmd);
7722	}
7723
7724	/**
7725	* megasas_suspend - driver suspend entry point
7726	* @dev: Device structure
7727	*/
7728	static int __maybe_unused
7729	megasas_suspend(struct device *dev)
7730	{
7731	struct megasas_instance *instance;
7732
7733	instance = dev_get_drvdata(dev);
7734
7735	if (!instance)
7736	return 0;
7737
7738	instance->unload = 1;
7739
7740	dev_info(dev, "%s is called\n", __func__);
7741
7742	/* Shutdown SR-IOV heartbeat timer */
7743	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7744	del_timer_sync(timer: &instance->sriov_heartbeat_timer);
7745
7746	/* Stop the FW fault detection watchdog */
7747	if (instance->adapter_type != MFI_SERIES)
7748	megasas_fusion_stop_watchdog(instance);
7749
7750	megasas_flush_cache(instance);
7751	megasas_shutdown_controller(instance, MR_DCMD_HIBERNATE_SHUTDOWN);
7752
7753	/* cancel the delayed work if this work still in queue */
7754	if (instance->ev != NULL) {
7755	struct megasas_aen_event *ev = instance->ev;
7756	cancel_delayed_work_sync(dwork: &ev->hotplug_work);
7757	instance->ev = NULL;
7758	}
7759
7760	tasklet_kill(t: &instance->isr_tasklet);
7761
7762	pci_set_drvdata(pdev: instance->pdev, data: instance);
7763	instance->instancet->disable_intr(instance);
7764
7765	megasas_destroy_irqs(instance);
7766
7767	if (instance->msix_vectors)
7768	pci_free_irq_vectors(dev: instance->pdev);
7769
7770	return 0;
7771	}
7772
7773	/**
7774	* megasas_resume- driver resume entry point
7775	* @dev: Device structure
7776	*/
7777	static int __maybe_unused
7778	megasas_resume(struct device *dev)
7779	{
7780	int rval;
7781	struct Scsi_Host *host;
7782	struct megasas_instance *instance;
7783	u32 status_reg;
7784
7785	instance = dev_get_drvdata(dev);
7786
7787	if (!instance)
7788	return 0;
7789
7790	host = instance->host;
7791
7792	dev_info(dev, "%s is called\n", __func__);
7793
7794	/*
7795	* We expect the FW state to be READY
7796	*/
7797
7798	if (megasas_transition_to_ready(instance, ocr: 0)) {
7799	dev_info(&instance->pdev->dev,
7800	"Failed to transition controller to ready from %s!\n",
7801	__func__);
7802	if (instance->adapter_type != MFI_SERIES) {
7803	status_reg =
7804	instance->instancet->read_fw_status_reg(instance);
7805	if (!(status_reg & MFI_RESET_ADAPTER) ||
7806	((megasas_adp_reset_wait_for_ready
7807	(instance, do_adp_reset: true, ocr_context: 0)) == FAILED))
7808	goto fail_ready_state;
7809	} else {
7810	atomic_set(v: &instance->fw_reset_no_pci_access, i: 1);
7811	instance->instancet->adp_reset
7812	(instance, instance->reg_set);
7813	atomic_set(v: &instance->fw_reset_no_pci_access, i: 0);
7814
7815	/* waiting for about 30 seconds before retry */
7816	ssleep(seconds: 30);
7817
7818	if (megasas_transition_to_ready(instance, ocr: 0))
7819	goto fail_ready_state;
7820	}
7821
7822	dev_info(&instance->pdev->dev,
7823	"FW restarted successfully from %s!\n",
7824	__func__);
7825	}
7826	if (megasas_set_dma_mask(instance))
7827	goto fail_set_dma_mask;
7828
7829	/*
7830	* Initialize MFI Firmware
7831	*/
7832
7833	atomic_set(v: &instance->fw_outstanding, i: 0);
7834	atomic_set(v: &instance->ldio_outstanding, i: 0);
7835
7836	/* Now re-enable MSI-X */
7837	if (instance->msix_vectors)
7838	megasas_alloc_irq_vectors(instance);
7839
7840	if (!instance->msix_vectors) {
7841	rval = pci_alloc_irq_vectors(dev: instance->pdev, min_vecs: 1, max_vecs: 1,
7842	PCI_IRQ_LEGACY);
7843	if (rval < 0)
7844	goto fail_reenable_msix;
7845	}
7846
7847	megasas_setup_reply_map(instance);
7848
7849	if (instance->adapter_type != MFI_SERIES) {
7850	megasas_reset_reply_desc(instance);
7851	if (megasas_ioc_init_fusion(instance)) {
7852	megasas_free_cmds(instance);
7853	megasas_free_cmds_fusion(instance);
7854	goto fail_init_mfi;
7855	}
7856	if (!megasas_get_map_info(instance))
7857	megasas_sync_map_info(instance);
7858	} else {
7859	*instance->producer = 0;
7860	*instance->consumer = 0;
7861	if (megasas_issue_init_mfi(instance))
7862	goto fail_init_mfi;
7863	}
7864
7865	if (megasas_get_ctrl_info(instance) != DCMD_SUCCESS)
7866	goto fail_init_mfi;
7867
7868	tasklet_init(t: &instance->isr_tasklet, func: instance->instancet->tasklet,
7869	data: (unsigned long)instance);
7870
7871	if (instance->msix_vectors ?
7872	megasas_setup_irqs_msix(instance, is_probe: 0) :
7873	megasas_setup_irqs_ioapic(instance))
7874	goto fail_init_mfi;
7875
7876	if (instance->adapter_type != MFI_SERIES)
7877	megasas_setup_irq_poll(instance);
7878
7879	/* Re-launch SR-IOV heartbeat timer */
7880	if (instance->requestorId) {
7881	if (!megasas_sriov_start_heartbeat(instance, initial: 0))
7882	megasas_start_timer(instance);
7883	else {
7884	instance->skip_heartbeat_timer_del = 1;
7885	goto fail_init_mfi;
7886	}
7887	}
7888
7889	instance->instancet->enable_intr(instance);
7890	megasas_setup_jbod_map(instance);
7891	instance->unload = 0;
7892
7893	/*
7894	* Initiate AEN (Asynchronous Event Notification)
7895	*/
7896	if (megasas_start_aen(instance))
7897	dev_err(&instance->pdev->dev, "Start AEN failed\n");
7898
7899	/* Re-launch FW fault watchdog */
7900	if (instance->adapter_type != MFI_SERIES)
7901	if (megasas_fusion_start_watchdog(instance) != SUCCESS)
7902	goto fail_start_watchdog;
7903
7904	return 0;
7905
7906	fail_start_watchdog:
7907	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7908	del_timer_sync(timer: &instance->sriov_heartbeat_timer);
7909	fail_init_mfi:
7910	megasas_free_ctrl_dma_buffers(instance);
7911	megasas_free_ctrl_mem(instance);
7912	scsi_host_put(t: host);
7913
7914	fail_reenable_msix:
7915	fail_set_dma_mask:
7916	fail_ready_state:
7917
7918	return -ENODEV;
7919	}
7920
7921	static inline int
7922	megasas_wait_for_adapter_operational(struct megasas_instance *instance)
7923	{
7924	int wait_time = MEGASAS_RESET_WAIT_TIME * 2;
7925	int i;
7926	u8 adp_state;
7927
7928	for (i = 0; i < wait_time; i++) {
7929	adp_state = atomic_read(v: &instance->adprecovery);
7930	if ((adp_state == MEGASAS_HBA_OPERATIONAL) ||
7931	(adp_state == MEGASAS_HW_CRITICAL_ERROR))
7932	break;
7933
7934	if (!(i % MEGASAS_RESET_NOTICE_INTERVAL))
7935	dev_notice(&instance->pdev->dev, "waiting for controller reset to finish\n");
7936
7937	msleep(msecs: 1000);
7938	}
7939
7940	if (adp_state != MEGASAS_HBA_OPERATIONAL) {
7941	dev_info(&instance->pdev->dev,
7942	"%s HBA failed to become operational, adp_state %d\n",
7943	__func__, adp_state);
7944	return 1;
7945	}
7946
7947	return 0;
7948	}
7949
7950	/**
7951	* megasas_detach_one - PCI hot"un"plug entry point
7952	* @pdev: PCI device structure
7953	*/
7954	static void megasas_detach_one(struct pci_dev *pdev)
7955	{
7956	int i;
7957	struct Scsi_Host *host;
7958	struct megasas_instance *instance;
7959	struct fusion_context *fusion;
7960	size_t pd_seq_map_sz;
7961
7962	instance = pci_get_drvdata(pdev);
7963
7964	if (!instance)
7965	return;
7966
7967	host = instance->host;
7968	fusion = instance->ctrl_context;
7969
7970	/* Shutdown SR-IOV heartbeat timer */
7971	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7972	del_timer_sync(timer: &instance->sriov_heartbeat_timer);
7973
7974	/* Stop the FW fault detection watchdog */
7975	if (instance->adapter_type != MFI_SERIES)
7976	megasas_fusion_stop_watchdog(instance);
7977
7978	if (instance->fw_crash_state != UNAVAILABLE)
7979	megasas_free_host_crash_buffer(instance);
7980	scsi_remove_host(instance->host);
7981	instance->unload = 1;
7982
7983	if (megasas_wait_for_adapter_operational(instance))
7984	goto skip_firing_dcmds;
7985
7986	megasas_flush_cache(instance);
7987	megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
7988
7989	skip_firing_dcmds:
7990	/* cancel the delayed work if this work still in queue*/
7991	if (instance->ev != NULL) {
7992	struct megasas_aen_event *ev = instance->ev;
7993	cancel_delayed_work_sync(dwork: &ev->hotplug_work);
7994	instance->ev = NULL;
7995	}
7996
7997	/* cancel all wait events */
7998	wake_up_all(&instance->int_cmd_wait_q);
7999
8000	tasklet_kill(t: &instance->isr_tasklet);
8001
8002	/*
8003	* Take the instance off the instance array. Note that we will not
8004	* decrement the max_index. We let this array be sparse array
8005	*/
8006	for (i = 0; i < megasas_mgmt_info.max_index; i++) {
8007	if (megasas_mgmt_info.instance[i] == instance) {
8008	megasas_mgmt_info.count--;
8009	megasas_mgmt_info.instance[i] = NULL;
8010
8011	break;
8012	}
8013	}
8014
8015	instance->instancet->disable_intr(instance);
8016
8017	megasas_destroy_irqs(instance);
8018
8019	if (instance->msix_vectors)
8020	pci_free_irq_vectors(dev: instance->pdev);
8021
8022	if (instance->adapter_type >= VENTURA_SERIES) {
8023	for (i = 0; i < MAX_LOGICAL_DRIVES_EXT; ++i)
8024	kfree(objp: fusion->stream_detect_by_ld[i]);
8025	kfree(objp: fusion->stream_detect_by_ld);
8026	fusion->stream_detect_by_ld = NULL;
8027	}
8028
8029
8030	if (instance->adapter_type != MFI_SERIES) {
8031	megasas_release_fusion(instance);
8032	pd_seq_map_sz =
8033	struct_size_t(struct MR_PD_CFG_SEQ_NUM_SYNC,
8034	seq, MAX_PHYSICAL_DEVICES);
8035	for (i = 0; i < 2 ; i++) {
8036	if (fusion->ld_map[i])
8037	dma_free_coherent(dev: &instance->pdev->dev,
8038	size: fusion->max_map_sz,
8039	cpu_addr: fusion->ld_map[i],
8040	dma_handle: fusion->ld_map_phys[i]);
8041	if (fusion->ld_drv_map[i]) {
8042	if (is_vmalloc_addr(x: fusion->ld_drv_map[i]))
8043	vfree(addr: fusion->ld_drv_map[i]);
8044	else
8045	free_pages(addr: (ulong)fusion->ld_drv_map[i],
8046	order: fusion->drv_map_pages);
8047	}
8048
8049	if (fusion->pd_seq_sync[i])
8050	dma_free_coherent(dev: &instance->pdev->dev,
8051	size: pd_seq_map_sz,
8052	cpu_addr: fusion->pd_seq_sync[i],
8053	dma_handle: fusion->pd_seq_phys[i]);
8054	}
8055	} else {
8056	megasas_release_mfi(instance);
8057	}
8058
8059	if (instance->vf_affiliation)
8060	dma_free_coherent(dev: &pdev->dev, size: (MAX_LOGICAL_DRIVES + 1) *
8061	sizeof(struct MR_LD_VF_AFFILIATION),
8062	cpu_addr: instance->vf_affiliation,
8063	dma_handle: instance->vf_affiliation_h);
8064
8065	if (instance->vf_affiliation_111)
8066	dma_free_coherent(dev: &pdev->dev,
8067	size: sizeof(struct MR_LD_VF_AFFILIATION_111),
8068	cpu_addr: instance->vf_affiliation_111,
8069	dma_handle: instance->vf_affiliation_111_h);
8070
8071	if (instance->hb_host_mem)
8072	dma_free_coherent(dev: &pdev->dev, size: sizeof(struct MR_CTRL_HB_HOST_MEM),
8073	cpu_addr: instance->hb_host_mem,
8074	dma_handle: instance->hb_host_mem_h);
8075
8076	megasas_free_ctrl_dma_buffers(instance);
8077
8078	megasas_free_ctrl_mem(instance);
8079
8080	megasas_destroy_debugfs(instance);
8081
8082	scsi_host_put(t: host);
8083
8084	pci_disable_device(dev: pdev);
8085	}
8086
8087	/**
8088	* megasas_shutdown - Shutdown entry point
8089	* @pdev: PCI device structure
8090	*/
8091	static void megasas_shutdown(struct pci_dev *pdev)
8092	{
8093	struct megasas_instance *instance = pci_get_drvdata(pdev);
8094
8095	if (!instance)
8096	return;
8097
8098	instance->unload = 1;
8099
8100	if (megasas_wait_for_adapter_operational(instance))
8101	goto skip_firing_dcmds;
8102
8103	megasas_flush_cache(instance);
8104	megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
8105
8106	skip_firing_dcmds:
8107	instance->instancet->disable_intr(instance);
8108	megasas_destroy_irqs(instance);
8109
8110	if (instance->msix_vectors)
8111	pci_free_irq_vectors(dev: instance->pdev);
8112	}
8113
8114	/*
8115	* megasas_mgmt_open - char node "open" entry point
8116	* @inode: char node inode
8117	* @filep: char node file
8118	*/
8119	static int megasas_mgmt_open(struct inode *inode, struct file *filep)
8120	{
8121	/*
8122	* Allow only those users with admin rights
8123	*/
8124	if (!capable(CAP_SYS_ADMIN))
8125	return -EACCES;
8126
8127	return 0;
8128	}
8129
8130	/*
8131	* megasas_mgmt_fasync - Async notifier registration from applications
8132	* @fd: char node file descriptor number
8133	* @filep: char node file
8134	* @mode: notifier on/off
8135	*
8136	* This function adds the calling process to a driver global queue. When an
8137	* event occurs, SIGIO will be sent to all processes in this queue.
8138	*/
8139	static int megasas_mgmt_fasync(int fd, struct file *filep, int mode)
8140	{
8141	int rc;
8142
8143	mutex_lock(&megasas_async_queue_mutex);
8144
8145	rc = fasync_helper(fd, filep, mode, &megasas_async_queue);
8146
8147	mutex_unlock(lock: &megasas_async_queue_mutex);
8148
8149	if (rc >= 0) {
8150	/* For sanity check when we get ioctl */
8151	filep->private_data = filep;
8152	return 0;
8153	}
8154
8155	printk(KERN_DEBUG "megasas: fasync_helper failed [%d]\n", rc);
8156
8157	return rc;
8158	}
8159
8160	/*
8161	* megasas_mgmt_poll - char node "poll" entry point
8162	* @filep: char node file
8163	* @wait: Events to poll for
8164	*/
8165	static __poll_t megasas_mgmt_poll(struct file *file, poll_table *wait)
8166	{
8167	__poll_t mask;
8168	unsigned long flags;
8169
8170	poll_wait(filp: file, wait_address: &megasas_poll_wait, p: wait);
8171	spin_lock_irqsave(&poll_aen_lock, flags);
8172	if (megasas_poll_wait_aen)
8173	mask = (EPOLLIN | EPOLLRDNORM);
8174	else
8175	mask = 0;
8176	megasas_poll_wait_aen = 0;
8177	spin_unlock_irqrestore(lock: &poll_aen_lock, flags);
8178	return mask;
8179	}
8180
8181	/*
8182	* megasas_set_crash_dump_params_ioctl:
8183	* Send CRASH_DUMP_MODE DCMD to all controllers
8184	* @cmd: MFI command frame
8185	*/
8186
8187	static int megasas_set_crash_dump_params_ioctl(struct megasas_cmd *cmd)
8188	{
8189	struct megasas_instance *local_instance;
8190	int i, error = 0;
8191	int crash_support;
8192
8193	crash_support = cmd->frame->dcmd.mbox.w[0];
8194
8195	for (i = 0; i < megasas_mgmt_info.max_index; i++) {
8196	local_instance = megasas_mgmt_info.instance[i];
8197	if (local_instance && local_instance->crash_dump_drv_support) {
8198	if ((atomic_read(v: &local_instance->adprecovery) ==
8199	MEGASAS_HBA_OPERATIONAL) &&
8200	!megasas_set_crash_dump_params(instance: local_instance,
8201	crash_buf_state: crash_support)) {
8202	local_instance->crash_dump_app_support =
8203	crash_support;
8204	dev_info(&local_instance->pdev->dev,
8205	"Application firmware crash "
8206	"dump mode set success\n");
8207	error = 0;
8208	} else {
8209	dev_info(&local_instance->pdev->dev,
8210	"Application firmware crash "
8211	"dump mode set failed\n");
8212	error = -1;
8213	}
8214	}
8215	}
8216	return error;
8217	}
8218
8219	/**
8220	* megasas_mgmt_fw_ioctl - Issues management ioctls to FW
8221	* @instance: Adapter soft state
8222	* @user_ioc: User's ioctl packet
8223	* @ioc: ioctl packet
8224	*/
8225	static int
8226	megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
8227	struct megasas_iocpacket __user * user_ioc,
8228	struct megasas_iocpacket *ioc)
8229	{
8230	struct megasas_sge64 *kern_sge64 = NULL;
8231	struct megasas_sge32 *kern_sge32 = NULL;
8232	struct megasas_cmd *cmd;
8233	void *kbuff_arr[MAX_IOCTL_SGE];
8234	dma_addr_t buf_handle = 0;
8235	int error = 0, i;
8236	void *sense = NULL;
8237	dma_addr_t sense_handle;
8238	void *sense_ptr;
8239	u32 opcode = 0;
8240	int ret = DCMD_SUCCESS;
8241
8242	memset(kbuff_arr, 0, sizeof(kbuff_arr));
8243
8244	if (ioc->sge_count > MAX_IOCTL_SGE) {
8245	dev_printk(KERN_DEBUG, &instance->pdev->dev, "SGE count [%d] > max limit [%d]\n",
8246	ioc->sge_count, MAX_IOCTL_SGE);
8247	return -EINVAL;
8248	}
8249
8250	if ((ioc->frame.hdr.cmd >= MFI_CMD_OP_COUNT) ||
8251	((ioc->frame.hdr.cmd == MFI_CMD_NVME) &&
8252	!instance->support_nvme_passthru) ||
8253	((ioc->frame.hdr.cmd == MFI_CMD_TOOLBOX) &&
8254	!instance->support_pci_lane_margining)) {
8255	dev_err(&instance->pdev->dev,
8256	"Received invalid ioctl command 0x%x\n",
8257	ioc->frame.hdr.cmd);
8258	return -ENOTSUPP;
8259	}
8260
8261	cmd = megasas_get_cmd(instance);
8262	if (!cmd) {
8263	dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get a cmd packet\n");
8264	return -ENOMEM;
8265	}
8266
8267	/*
8268	* User's IOCTL packet has 2 frames (maximum). Copy those two
8269	* frames into our cmd's frames. cmd->frame's context will get
8270	* overwritten when we copy from user's frames. So set that value
8271	* alone separately
8272	*/
8273	memcpy(cmd->frame, ioc->frame.raw, 2 * MEGAMFI_FRAME_SIZE);
8274	cmd->frame->hdr.context = cpu_to_le32(cmd->index);
8275	cmd->frame->hdr.pad_0 = 0;
8276
8277	cmd->frame->hdr.flags &= (~MFI_FRAME_IEEE);
8278
8279	if (instance->consistent_mask_64bit)
8280	cmd->frame->hdr.flags |= cpu_to_le16((MFI_FRAME_SGL64 |
8281	MFI_FRAME_SENSE64));
8282	else
8283	cmd->frame->hdr.flags &= cpu_to_le16(~(MFI_FRAME_SGL64 |
8284	MFI_FRAME_SENSE64));
8285
8286	if (cmd->frame->hdr.cmd == MFI_CMD_DCMD)
8287	opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
8288
8289	if (opcode == MR_DCMD_CTRL_SHUTDOWN) {
8290	mutex_lock(&instance->reset_mutex);
8291	if (megasas_get_ctrl_info(instance) != DCMD_SUCCESS) {
8292	megasas_return_cmd(instance, cmd);
8293	mutex_unlock(lock: &instance->reset_mutex);
8294	return -1;
8295	}
8296	mutex_unlock(lock: &instance->reset_mutex);
8297	}
8298
8299	if (opcode == MR_DRIVER_SET_APP_CRASHDUMP_MODE) {
8300	error = megasas_set_crash_dump_params_ioctl(cmd);
8301	megasas_return_cmd(instance, cmd);
8302	return error;
8303	}
8304
8305	/*
8306	* The management interface between applications and the fw uses
8307	* MFI frames. E.g, RAID configuration changes, LD property changes
8308	* etc are accomplishes through different kinds of MFI frames. The
8309	* driver needs to care only about substituting user buffers with
8310	* kernel buffers in SGLs. The location of SGL is embedded in the
8311	* struct iocpacket itself.
8312	*/
8313	if (instance->consistent_mask_64bit)
8314	kern_sge64 = (struct megasas_sge64 *)
8315	((unsigned long)cmd->frame + ioc->sgl_off);
8316	else
8317	kern_sge32 = (struct megasas_sge32 *)
8318	((unsigned long)cmd->frame + ioc->sgl_off);
8319
8320	/*
8321	* For each user buffer, create a mirror buffer and copy in
8322	*/
8323	for (i = 0; i < ioc->sge_count; i++) {
8324	if (!ioc->sgl[i].iov_len)
8325	continue;
8326
8327	kbuff_arr[i] = dma_alloc_coherent(dev: &instance->pdev->dev,
8328	size: ioc->sgl[i].iov_len,
8329	dma_handle: &buf_handle, GFP_KERNEL);
8330	if (!kbuff_arr[i]) {
8331	dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc "
8332	"kernel SGL buffer for IOCTL\n");
8333	error = -ENOMEM;
8334	goto out;
8335	}
8336
8337	/*
8338	* We don't change the dma_coherent_mask, so
8339	* dma_alloc_coherent only returns 32bit addresses
8340	*/
8341	if (instance->consistent_mask_64bit) {
8342	kern_sge64[i].phys_addr = cpu_to_le64(buf_handle);
8343	kern_sge64[i].length = cpu_to_le32(ioc->sgl[i].iov_len);
8344	} else {
8345	kern_sge32[i].phys_addr = cpu_to_le32(buf_handle);
8346	kern_sge32[i].length = cpu_to_le32(ioc->sgl[i].iov_len);
8347	}
8348
8349	/*
8350	* We created a kernel buffer corresponding to the
8351	* user buffer. Now copy in from the user buffer
8352	*/
8353	if (copy_from_user(to: kbuff_arr[i], from: ioc->sgl[i].iov_base,
8354	n: (u32) (ioc->sgl[i].iov_len))) {
8355	error = -EFAULT;
8356	goto out;
8357	}
8358	}
8359
8360	if (ioc->sense_len) {
8361	/* make sure the pointer is part of the frame */
8362	if (ioc->sense_off >
8363	(sizeof(union megasas_frame) - sizeof(__le64))) {
8364	error = -EINVAL;
8365	goto out;
8366	}
8367
8368	sense = dma_alloc_coherent(dev: &instance->pdev->dev, size: ioc->sense_len,
8369	dma_handle: &sense_handle, GFP_KERNEL);
8370	if (!sense) {
8371	error = -ENOMEM;
8372	goto out;
8373	}
8374
8375	/* always store 64 bits regardless of addressing */
8376	sense_ptr = (void *)cmd->frame + ioc->sense_off;
8377	put_unaligned_le64(val: sense_handle, p: sense_ptr);
8378	}
8379
8380	/*
8381	* Set the sync_cmd flag so that the ISR knows not to complete this
8382	* cmd to the SCSI mid-layer
8383	*/
8384	cmd->sync_cmd = 1;
8385
8386	ret = megasas_issue_blocked_cmd(instance, cmd, timeout: 0);
8387	switch (ret) {
8388	case DCMD_INIT:
8389	case DCMD_BUSY:
8390	cmd->sync_cmd = 0;
8391	dev_err(&instance->pdev->dev,
8392	"return -EBUSY from %s %d cmd 0x%x opcode 0x%x cmd->cmd_status_drv 0x%x\n",
8393	__func__, __LINE__, cmd->frame->hdr.cmd, opcode,
8394	cmd->cmd_status_drv);
8395	error = -EBUSY;
8396	goto out;
8397	}
8398
8399	cmd->sync_cmd = 0;
8400
8401	if (instance->unload == 1) {
8402	dev_info(&instance->pdev->dev, "Driver unload is in progress "
8403	"don't submit data to application\n");
8404	goto out;
8405	}
8406	/*
8407	* copy out the kernel buffers to user buffers
8408	*/
8409	for (i = 0; i < ioc->sge_count; i++) {
8410	if (copy_to_user(to: ioc->sgl[i].iov_base, from: kbuff_arr[i],
8411	n: ioc->sgl[i].iov_len)) {
8412	error = -EFAULT;
8413	goto out;
8414	}
8415	}
8416
8417	/*
8418	* copy out the sense
8419	*/
8420	if (ioc->sense_len) {
8421	void __user *uptr;
8422	/*
8423	* sense_ptr points to the location that has the user
8424	* sense buffer address
8425	*/
8426	sense_ptr = (void *)ioc->frame.raw + ioc->sense_off;
8427	if (in_compat_syscall())
8428	uptr = compat_ptr(get_unaligned((compat_uptr_t *)
8429	sense_ptr));
8430	else
8431	uptr = get_unaligned((void __user **)sense_ptr);
8432
8433	if (copy_to_user(to: uptr, from: sense, n: ioc->sense_len)) {
8434	dev_err(&instance->pdev->dev, "Failed to copy out to user "
8435	"sense data\n");
8436	error = -EFAULT;
8437	goto out;
8438	}
8439	}
8440
8441	/*
8442	* copy the status codes returned by the fw
8443	*/
8444	if (copy_to_user(to: &user_ioc->frame.hdr.cmd_status,
8445	from: &cmd->frame->hdr.cmd_status, n: sizeof(u8))) {
8446	dev_printk(KERN_DEBUG, &instance->pdev->dev, "Error copying out cmd_status\n");
8447	error = -EFAULT;
8448	}
8449
8450	out:
8451	if (sense) {
8452	dma_free_coherent(dev: &instance->pdev->dev, size: ioc->sense_len,
8453	cpu_addr: sense, dma_handle: sense_handle);
8454	}
8455
8456	for (i = 0; i < ioc->sge_count; i++) {
8457	if (kbuff_arr[i]) {
8458	if (instance->consistent_mask_64bit)
8459	dma_free_coherent(dev: &instance->pdev->dev,
8460	le32_to_cpu(kern_sge64[i].length),
8461	cpu_addr: kbuff_arr[i],
8462	le64_to_cpu(kern_sge64[i].phys_addr));
8463	else
8464	dma_free_coherent(dev: &instance->pdev->dev,
8465	le32_to_cpu(kern_sge32[i].length),
8466	cpu_addr: kbuff_arr[i],
8467	le32_to_cpu(kern_sge32[i].phys_addr));
8468	kbuff_arr[i] = NULL;
8469	}
8470	}
8471
8472	megasas_return_cmd(instance, cmd);
8473	return error;
8474	}
8475
8476	static struct megasas_iocpacket *
8477	megasas_compat_iocpacket_get_user(void __user *arg)
8478	{
8479	struct megasas_iocpacket *ioc;
8480	struct compat_megasas_iocpacket __user *cioc = arg;
8481	size_t size;
8482	int err = -EFAULT;
8483	int i;
8484
8485	ioc = kzalloc(size: sizeof(*ioc), GFP_KERNEL);
8486	if (!ioc)
8487	return ERR_PTR(error: -ENOMEM);
8488	size = offsetof(struct megasas_iocpacket, frame) + sizeof(ioc->frame);
8489	if (copy_from_user(to: ioc, from: arg, n: size))
8490	goto out;
8491
8492	for (i = 0; i < MAX_IOCTL_SGE; i++) {
8493	compat_uptr_t iov_base;
8494
8495	if (get_user(iov_base, &cioc->sgl[i].iov_base) ||
8496	get_user(ioc->sgl[i].iov_len, &cioc->sgl[i].iov_len))
8497	goto out;
8498
8499	ioc->sgl[i].iov_base = compat_ptr(uptr: iov_base);
8500	}
8501
8502	return ioc;
8503	out:
8504	kfree(objp: ioc);
8505	return ERR_PTR(error: err);
8506	}
8507
8508	static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
8509	{
8510	struct megasas_iocpacket __user *user_ioc =
8511	(struct megasas_iocpacket __user *)arg;
8512	struct megasas_iocpacket *ioc;
8513	struct megasas_instance *instance;
8514	int error;
8515
8516	if (in_compat_syscall())
8517	ioc = megasas_compat_iocpacket_get_user(arg: user_ioc);
8518	else
8519	ioc = memdup_user(user_ioc, sizeof(struct megasas_iocpacket));
8520
8521	if (IS_ERR(ptr: ioc))
8522	return PTR_ERR(ptr: ioc);
8523
8524	instance = megasas_lookup_instance(host_no: ioc->host_no);
8525	if (!instance) {
8526	error = -ENODEV;
8527	goto out_kfree_ioc;
8528	}
8529
8530	/* Block ioctls in VF mode */
8531	if (instance->requestorId && !allow_vf_ioctls) {
8532	error = -ENODEV;
8533	goto out_kfree_ioc;
8534	}
8535
8536	if (atomic_read(v: &instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
8537	dev_err(&instance->pdev->dev, "Controller in crit error\n");
8538	error = -ENODEV;
8539	goto out_kfree_ioc;
8540	}
8541
8542	if (instance->unload == 1) {
8543	error = -ENODEV;
8544	goto out_kfree_ioc;
8545	}
8546
8547	if (down_interruptible(sem: &instance->ioctl_sem)) {
8548	error = -ERESTARTSYS;
8549	goto out_kfree_ioc;
8550	}
8551
8552	if (megasas_wait_for_adapter_operational(instance)) {
8553	error = -ENODEV;
8554	goto out_up;
8555	}
8556
8557	error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc);
8558	out_up:
8559	up(sem: &instance->ioctl_sem);
8560
8561	out_kfree_ioc:
8562	kfree(objp: ioc);
8563	return error;
8564	}
8565
8566	static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)
8567	{
8568	struct megasas_instance *instance;
8569	struct megasas_aen aen;
8570	int error;
8571
8572	if (file->private_data != file) {
8573	printk(KERN_DEBUG "megasas: fasync_helper was not "
8574	"called first\n");
8575	return -EINVAL;
8576	}
8577
8578	if (copy_from_user(to: &aen, from: (void __user *)arg, n: sizeof(aen)))
8579	return -EFAULT;
8580
8581	instance = megasas_lookup_instance(host_no: aen.host_no);
8582
8583	if (!instance)
8584	return -ENODEV;
8585
8586	if (atomic_read(v: &instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
8587	return -ENODEV;
8588	}
8589
8590	if (instance->unload == 1) {
8591	return -ENODEV;
8592	}
8593
8594	if (megasas_wait_for_adapter_operational(instance))
8595	return -ENODEV;
8596
8597	mutex_lock(&instance->reset_mutex);
8598	error = megasas_register_aen(instance, seq_num: aen.seq_num,
8599	class_locale_word: aen.class_locale_word);
8600	mutex_unlock(lock: &instance->reset_mutex);
8601	return error;
8602	}
8603
8604	/**
8605	* megasas_mgmt_ioctl - char node ioctl entry point
8606	* @file: char device file pointer
8607	* @cmd: ioctl command
8608	* @arg: ioctl command arguments address
8609	*/
8610	static long
8611	megasas_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
8612	{
8613	switch (cmd) {
8614	case MEGASAS_IOC_FIRMWARE:
8615	return megasas_mgmt_ioctl_fw(file, arg);
8616
8617	case MEGASAS_IOC_GET_AEN:
8618	return megasas_mgmt_ioctl_aen(file, arg);
8619	}
8620
8621	return -ENOTTY;
8622	}
8623
8624	#ifdef CONFIG_COMPAT
8625	static long
8626	megasas_mgmt_compat_ioctl(struct file *file, unsigned int cmd,
8627	unsigned long arg)
8628	{
8629	switch (cmd) {
8630	case MEGASAS_IOC_FIRMWARE32:
8631	return megasas_mgmt_ioctl_fw(file, arg);
8632	case MEGASAS_IOC_GET_AEN:
8633	return megasas_mgmt_ioctl_aen(file, arg);
8634	}
8635
8636	return -ENOTTY;
8637	}
8638	#endif
8639
8640	/*
8641	* File operations structure for management interface
8642	*/
8643	static const struct file_operations megasas_mgmt_fops = {
8644	.owner = THIS_MODULE,
8645	.open = megasas_mgmt_open,
8646	.fasync = megasas_mgmt_fasync,
8647	.unlocked_ioctl = megasas_mgmt_ioctl,
8648	.poll = megasas_mgmt_poll,
8649	#ifdef CONFIG_COMPAT
8650	.compat_ioctl = megasas_mgmt_compat_ioctl,
8651	#endif
8652	.llseek = noop_llseek,
8653	};
8654
8655	static SIMPLE_DEV_PM_OPS(megasas_pm_ops, megasas_suspend, megasas_resume);
8656
8657	/*
8658	* PCI hotplug support registration structure
8659	*/
8660	static struct pci_driver megasas_pci_driver = {
8661
8662	.name = "megaraid_sas",
8663	.id_table = megasas_pci_table,
8664	.probe = megasas_probe_one,
8665	.remove = megasas_detach_one,
8666	.driver.pm = &megasas_pm_ops,
8667	.shutdown = megasas_shutdown,
8668	};
8669
8670	/*
8671	* Sysfs driver attributes
8672	*/
8673	static ssize_t version_show(struct device_driver *dd, char *buf)
8674	{
8675	return snprintf(buf, strlen(MEGASAS_VERSION) + 2, fmt: "%s\n",
8676	MEGASAS_VERSION);
8677	}
8678	static DRIVER_ATTR_RO(version);
8679
8680	static ssize_t release_date_show(struct device_driver *dd, char *buf)
8681	{
8682	return snprintf(buf, strlen(MEGASAS_RELDATE) + 2, fmt: "%s\n",
8683	MEGASAS_RELDATE);
8684	}
8685	static DRIVER_ATTR_RO(release_date);
8686
8687	static ssize_t support_poll_for_event_show(struct device_driver *dd, char *buf)
8688	{
8689	return sprintf(buf, fmt: "%u\n", support_poll_for_event);
8690	}
8691	static DRIVER_ATTR_RO(support_poll_for_event);
8692
8693	static ssize_t support_device_change_show(struct device_driver *dd, char *buf)
8694	{
8695	return sprintf(buf, fmt: "%u\n", support_device_change);
8696	}
8697	static DRIVER_ATTR_RO(support_device_change);
8698
8699	static ssize_t dbg_lvl_show(struct device_driver *dd, char *buf)
8700	{
8701	return sprintf(buf, fmt: "%u\n", megasas_dbg_lvl);
8702	}
8703
8704	static ssize_t dbg_lvl_store(struct device_driver *dd, const char *buf,
8705	size_t count)
8706	{
8707	int retval = count;
8708
8709	if (sscanf(buf, "%u", &megasas_dbg_lvl) < 1) {
8710	printk(KERN_ERR "megasas: could not set dbg_lvl\n");
8711	retval = -EINVAL;
8712	}
8713	return retval;
8714	}
8715	static DRIVER_ATTR_RW(dbg_lvl);
8716
8717	static ssize_t
8718	support_nvme_encapsulation_show(struct device_driver *dd, char *buf)
8719	{
8720	return sprintf(buf, fmt: "%u\n", support_nvme_encapsulation);
8721	}
8722
8723	static DRIVER_ATTR_RO(support_nvme_encapsulation);
8724
8725	static ssize_t
8726	support_pci_lane_margining_show(struct device_driver *dd, char *buf)
8727	{
8728	return sprintf(buf, fmt: "%u\n", support_pci_lane_margining);
8729	}
8730
8731	static DRIVER_ATTR_RO(support_pci_lane_margining);
8732
8733	static inline void megasas_remove_scsi_device(struct scsi_device *sdev)
8734	{
8735	sdev_printk(KERN_INFO, sdev, "SCSI device is removed\n");
8736	scsi_remove_device(sdev);
8737	scsi_device_put(sdev);
8738	}
8739
8740	/**
8741	* megasas_update_device_list - Update the PD and LD device list from FW
8742	* after an AEN event notification
8743	* @instance: Adapter soft state
8744	* @event_type: Indicates type of event (PD or LD event)
8745	*
8746	* @return: Success or failure
8747	*
8748	* Issue DCMDs to Firmware to update the internal device list in driver.
8749	* Based on the FW support, driver sends the HOST_DEVICE_LIST or combination
8750	* of PD_LIST/LD_LIST_QUERY DCMDs to get the device list.
8751	*/
8752	static
8753	int megasas_update_device_list(struct megasas_instance *instance,
8754	int event_type)
8755	{
8756	int dcmd_ret;
8757
8758	if (instance->enable_fw_dev_list) {
8759	return megasas_host_device_list_query(instance, is_probe: false);
8760	} else {
8761	if (event_type & SCAN_PD_CHANNEL) {
8762	dcmd_ret = megasas_get_pd_list(instance);
8763	if (dcmd_ret != DCMD_SUCCESS)
8764	return dcmd_ret;
8765	}
8766
8767	if (event_type & SCAN_VD_CHANNEL) {
8768	if (!instance->requestorId ||
8769	megasas_get_ld_vf_affiliation(instance, initial: 0)) {
8770	return megasas_ld_list_query(instance,
8771	query_type: MR_LD_QUERY_TYPE_EXPOSED_TO_HOST);
8772	}
8773	}
8774	}
8775	return DCMD_SUCCESS;
8776	}
8777
8778	/**
8779	* megasas_add_remove_devices - Add/remove devices to SCSI mid-layer
8780	* after an AEN event notification
8781	* @instance: Adapter soft state
8782	* @scan_type: Indicates type of devices (PD/LD) to add
8783	* @return void
8784	*/
8785	static
8786	void megasas_add_remove_devices(struct megasas_instance *instance,
8787	int scan_type)
8788	{
8789	int i, j;
8790	u16 pd_index = 0;
8791	u16 ld_index = 0;
8792	u16 channel = 0, id = 0;
8793	struct Scsi_Host *host;
8794	struct scsi_device *sdev1;
8795	struct MR_HOST_DEVICE_LIST *targetid_list = NULL;
8796	struct MR_HOST_DEVICE_LIST_ENTRY *targetid_entry = NULL;
8797
8798	host = instance->host;
8799
8800	if (instance->enable_fw_dev_list) {
8801	targetid_list = instance->host_device_list_buf;
8802	for (i = 0; i < targetid_list->count; i++) {
8803	targetid_entry = &targetid_list->host_device_list[i];
8804	if (targetid_entry->flags.u.bits.is_sys_pd) {
8805	channel = le16_to_cpu(targetid_entry->target_id) /
8806	MEGASAS_MAX_DEV_PER_CHANNEL;
8807	id = le16_to_cpu(targetid_entry->target_id) %
8808	MEGASAS_MAX_DEV_PER_CHANNEL;
8809	} else {
8810	channel = MEGASAS_MAX_PD_CHANNELS +
8811	(le16_to_cpu(targetid_entry->target_id) /
8812	MEGASAS_MAX_DEV_PER_CHANNEL);
8813	id = le16_to_cpu(targetid_entry->target_id) %
8814	MEGASAS_MAX_DEV_PER_CHANNEL;
8815	}
8816	sdev1 = scsi_device_lookup(host, channel, id, 0);
8817	if (!sdev1) {
8818	scsi_add_device(host, channel, target: id, lun: 0);
8819	} else {
8820	scsi_device_put(sdev1);
8821	}
8822	}
8823	}
8824
8825	if (scan_type & SCAN_PD_CHANNEL) {
8826	for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
8827	for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
8828	pd_index = i * MEGASAS_MAX_DEV_PER_CHANNEL + j;
8829	sdev1 = scsi_device_lookup(host, i, j, 0);
8830	if (instance->pd_list[pd_index].driveState ==
8831	MR_PD_STATE_SYSTEM) {
8832	if (!sdev1)
8833	scsi_add_device(host, channel: i, target: j, lun: 0);
8834	else
8835	scsi_device_put(sdev1);
8836	} else {
8837	if (sdev1)
8838	megasas_remove_scsi_device(sdev: sdev1);
8839	}
8840	}
8841	}
8842	}
8843
8844	if (scan_type & SCAN_VD_CHANNEL) {
8845	for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
8846	for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
8847	ld_index = (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
8848	sdev1 = scsi_device_lookup(host,
8849	MEGASAS_MAX_PD_CHANNELS + i, j, 0);
8850	if (instance->ld_ids[ld_index] != 0xff) {
8851	if (!sdev1)
8852	scsi_add_device(host, MEGASAS_MAX_PD_CHANNELS + i, target: j, lun: 0);
8853	else
8854	scsi_device_put(sdev1);
8855	} else {
8856	if (sdev1)
8857	megasas_remove_scsi_device(sdev: sdev1);
8858	}
8859	}
8860	}
8861	}
8862
8863	}
8864
8865	static void
8866	megasas_aen_polling(struct work_struct *work)
8867	{
8868	struct megasas_aen_event *ev =
8869	container_of(work, struct megasas_aen_event, hotplug_work.work);
8870	struct megasas_instance *instance = ev->instance;
8871	union megasas_evt_class_locale class_locale;
8872	int event_type = 0;
8873	u32 seq_num;
8874	u16 ld_target_id;
8875	int error;
8876	u8 dcmd_ret = DCMD_SUCCESS;
8877	struct scsi_device *sdev1;
8878
8879	if (!instance) {
8880	printk(KERN_ERR "invalid instance!\n");
8881	kfree(objp: ev);
8882	return;
8883	}
8884
8885	/* Don't run the event workqueue thread if OCR is running */
8886	mutex_lock(&instance->reset_mutex);
8887
8888	instance->ev = NULL;
8889	if (instance->evt_detail) {
8890	megasas_decode_evt(instance);
8891
8892	switch (le32_to_cpu(instance->evt_detail->code)) {
8893
8894	case MR_EVT_PD_INSERTED:
8895	case MR_EVT_PD_REMOVED:
8896	event_type = SCAN_PD_CHANNEL;
8897	break;
8898
8899	case MR_EVT_LD_OFFLINE:
8900	case MR_EVT_LD_DELETED:
8901	ld_target_id = instance->evt_detail->args.ld.target_id;
8902	sdev1 = scsi_device_lookup(instance->host,
8903	MEGASAS_MAX_PD_CHANNELS +
8904	(ld_target_id / MEGASAS_MAX_DEV_PER_CHANNEL),
8905	(ld_target_id % MEGASAS_MAX_DEV_PER_CHANNEL),
8906	0);
8907	if (sdev1)
8908	megasas_remove_scsi_device(sdev: sdev1);
8909
8910	event_type = SCAN_VD_CHANNEL;
8911	break;
8912	case MR_EVT_LD_CREATED:
8913	event_type = SCAN_VD_CHANNEL;
8914	break;
8915
8916	case MR_EVT_CFG_CLEARED:
8917	case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:
8918	case MR_EVT_FOREIGN_CFG_IMPORTED:
8919	case MR_EVT_LD_STATE_CHANGE:
8920	event_type = SCAN_PD_CHANNEL | SCAN_VD_CHANNEL;
8921	dev_info(&instance->pdev->dev, "scanning for scsi%d...\n",
8922	instance->host->host_no);
8923	break;
8924
8925	case MR_EVT_CTRL_PROP_CHANGED:
8926	dcmd_ret = megasas_get_ctrl_info(instance);
8927	if (dcmd_ret == DCMD_SUCCESS &&
8928	instance->snapdump_wait_time) {
8929	megasas_get_snapdump_properties(instance);
8930	dev_info(&instance->pdev->dev,
8931	"Snap dump wait time\t: %d\n",
8932	instance->snapdump_wait_time);
8933	}
8934	break;
8935	default:
8936	event_type = 0;
8937	break;
8938	}
8939	} else {
8940	dev_err(&instance->pdev->dev, "invalid evt_detail!\n");
8941	mutex_unlock(lock: &instance->reset_mutex);
8942	kfree(objp: ev);
8943	return;
8944	}
8945
8946	if (event_type)
8947	dcmd_ret = megasas_update_device_list(instance, event_type);
8948
8949	mutex_unlock(lock: &instance->reset_mutex);
8950
8951	if (event_type && dcmd_ret == DCMD_SUCCESS)
8952	megasas_add_remove_devices(instance, scan_type: event_type);
8953
8954	if (dcmd_ret == DCMD_SUCCESS)
8955	seq_num = le32_to_cpu(instance->evt_detail->seq_num) + 1;
8956	else
8957	seq_num = instance->last_seq_num;
8958
8959	/* Register AEN with FW for latest sequence number plus 1 */
8960	class_locale.members.reserved = 0;
8961	class_locale.members.locale = MR_EVT_LOCALE_ALL;
8962	class_locale.members.class = MR_EVT_CLASS_DEBUG;
8963
8964	if (instance->aen_cmd != NULL) {
8965	kfree(objp: ev);
8966	return;
8967	}
8968
8969	mutex_lock(&instance->reset_mutex);
8970	error = megasas_register_aen(instance, seq_num,
8971	class_locale_word: class_locale.word);
8972	if (error)
8973	dev_err(&instance->pdev->dev,
8974	"register aen failed error %x\n", error);
8975
8976	mutex_unlock(lock: &instance->reset_mutex);
8977	kfree(objp: ev);
8978	}
8979
8980	/**
8981	* megasas_init - Driver load entry point
8982	*/
8983	static int __init megasas_init(void)
8984	{
8985	int rval;
8986
8987	/*
8988	* Booted in kdump kernel, minimize memory footprints by
8989	* disabling few features
8990	*/
8991	if (reset_devices) {
8992	msix_vectors = 1;
8993	rdpq_enable = 0;
8994	dual_qdepth_disable = 1;
8995	poll_queues = 0;
8996	}
8997
8998	/*
8999	* Announce driver version and other information
9000	*/
9001	pr_info("megasas: %s\n", MEGASAS_VERSION);
9002
9003	megasas_dbg_lvl = 0;
9004	support_poll_for_event = 2;
9005	support_device_change = 1;
9006	support_nvme_encapsulation = true;
9007	support_pci_lane_margining = true;
9008
9009	memset(&megasas_mgmt_info, 0, sizeof(megasas_mgmt_info));
9010
9011	/*
9012	* Register character device node
9013	*/
9014	rval = register_chrdev(major: 0, name: "megaraid_sas_ioctl", fops: &megasas_mgmt_fops);
9015
9016	if (rval < 0) {
9017	printk(KERN_DEBUG "megasas: failed to open device node\n");
9018	return rval;
9019	}
9020
9021	megasas_mgmt_majorno = rval;
9022
9023	megasas_init_debugfs();
9024
9025	/*
9026	* Register ourselves as PCI hotplug module
9027	*/
9028	rval = pci_register_driver(&megasas_pci_driver);
9029
9030	if (rval) {
9031	printk(KERN_DEBUG "megasas: PCI hotplug registration failed \n");
9032	goto err_pcidrv;
9033	}
9034
9035	if ((event_log_level < MFI_EVT_CLASS_DEBUG) ||
9036	(event_log_level > MFI_EVT_CLASS_DEAD)) {
9037	pr_warn("megaraid_sas: provided event log level is out of range, setting it to default 2(CLASS_CRITICAL), permissible range is: -2 to 4\n");
9038	event_log_level = MFI_EVT_CLASS_CRITICAL;
9039	}
9040
9041	rval = driver_create_file(driver: &megasas_pci_driver.driver,
9042	attr: &driver_attr_version);
9043	if (rval)
9044	goto err_dcf_attr_ver;
9045
9046	rval = driver_create_file(driver: &megasas_pci_driver.driver,
9047	attr: &driver_attr_release_date);
9048	if (rval)
9049	goto err_dcf_rel_date;
9050
9051	rval = driver_create_file(driver: &megasas_pci_driver.driver,
9052	attr: &driver_attr_support_poll_for_event);
9053	if (rval)
9054	goto err_dcf_support_poll_for_event;
9055
9056	rval = driver_create_file(driver: &megasas_pci_driver.driver,
9057	attr: &driver_attr_dbg_lvl);
9058	if (rval)
9059	goto err_dcf_dbg_lvl;
9060	rval = driver_create_file(driver: &megasas_pci_driver.driver,
9061	attr: &driver_attr_support_device_change);
9062	if (rval)
9063	goto err_dcf_support_device_change;
9064
9065	rval = driver_create_file(driver: &megasas_pci_driver.driver,
9066	attr: &driver_attr_support_nvme_encapsulation);
9067	if (rval)
9068	goto err_dcf_support_nvme_encapsulation;
9069
9070	rval = driver_create_file(driver: &megasas_pci_driver.driver,
9071	attr: &driver_attr_support_pci_lane_margining);
9072	if (rval)
9073	goto err_dcf_support_pci_lane_margining;
9074
9075	return rval;
9076
9077	err_dcf_support_pci_lane_margining:
9078	driver_remove_file(driver: &megasas_pci_driver.driver,
9079	attr: &driver_attr_support_nvme_encapsulation);
9080
9081	err_dcf_support_nvme_encapsulation:
9082	driver_remove_file(driver: &megasas_pci_driver.driver,
9083	attr: &driver_attr_support_device_change);
9084
9085	err_dcf_support_device_change:
9086	driver_remove_file(driver: &megasas_pci_driver.driver,
9087	attr: &driver_attr_dbg_lvl);
9088	err_dcf_dbg_lvl:
9089	driver_remove_file(driver: &megasas_pci_driver.driver,
9090	attr: &driver_attr_support_poll_for_event);
9091	err_dcf_support_poll_for_event:
9092	driver_remove_file(driver: &megasas_pci_driver.driver,
9093	attr: &driver_attr_release_date);
9094	err_dcf_rel_date:
9095	driver_remove_file(driver: &megasas_pci_driver.driver, attr: &driver_attr_version);
9096	err_dcf_attr_ver:
9097	pci_unregister_driver(dev: &megasas_pci_driver);
9098	err_pcidrv:
9099	megasas_exit_debugfs();
9100	unregister_chrdev(major: megasas_mgmt_majorno, name: "megaraid_sas_ioctl");
9101	return rval;
9102	}
9103
9104	/**
9105	* megasas_exit - Driver unload entry point
9106	*/
9107	static void __exit megasas_exit(void)
9108	{
9109	driver_remove_file(driver: &megasas_pci_driver.driver,
9110	attr: &driver_attr_dbg_lvl);
9111	driver_remove_file(driver: &megasas_pci_driver.driver,
9112	attr: &driver_attr_support_poll_for_event);
9113	driver_remove_file(driver: &megasas_pci_driver.driver,
9114	attr: &driver_attr_support_device_change);
9115	driver_remove_file(driver: &megasas_pci_driver.driver,
9116	attr: &driver_attr_release_date);
9117	driver_remove_file(driver: &megasas_pci_driver.driver, attr: &driver_attr_version);
9118	driver_remove_file(driver: &megasas_pci_driver.driver,
9119	attr: &driver_attr_support_nvme_encapsulation);
9120	driver_remove_file(driver: &megasas_pci_driver.driver,
9121	attr: &driver_attr_support_pci_lane_margining);
9122
9123	pci_unregister_driver(dev: &megasas_pci_driver);
9124	megasas_exit_debugfs();
9125	unregister_chrdev(major: megasas_mgmt_majorno, name: "megaraid_sas_ioctl");
9126	}
9127
9128	module_init(megasas_init);
9129	module_exit(megasas_exit);
9130