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 	 * upto three 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 < 3);
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(&instance->cmd_pool)) {
327 		cmd = list_entry((&instance->cmd_pool)->next,
328 				 struct megasas_cmd, list);
329 		list_del_init(&cmd->list);
330 	} else {
331 		dev_err(&instance->pdev->dev, "Command pool empty!\n");
332 	}
333 
334 	spin_unlock_irqrestore(&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_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(&cmd->list, (&instance->cmd_pool)->next);
372 
373 	spin_unlock_irqrestore(&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(buffer, sizeof(buffer), "boot + %us", timestamp &
384 		0x00ffffff);
385 	else
386 		snprintf(buffer, sizeof(buffer), "%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(buffer, sizeof(buffer), "%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(0, &(regs)->outbound_intr_mask);
465 
466 	/* Dummy readl to force pci flush */
467 	readl(&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(mask, &regs->outbound_intr_mask);
482 	/* Dummy readl to force pci flush */
483 	readl(&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(&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(&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(status, &regs->outbound_intr_status);
522 
523 	/* Dummy readl to force pci flush */
524 	readl(&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((frame_phys_addr >> 3)|(frame_count),
546 	       &(regs)->inbound_queue_port);
547 	spin_unlock_irqrestore(&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, &regs->inbound_doorbell);
563 
564 	for (i = 0; i < 3; i++)
565 		msleep(1000); /* sleep for 3 secs */
566 	pcidata  = 0;
567 	pci_read_config_dword(instance->pdev, MFI_1068_PCSR_OFFSET, &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(instance->pdev,
573 				MFI_1068_PCSR_OFFSET, pcidata);
574 
575 		for (i = 0; i < 2; i++)
576 			msleep(1000); /* need to wait 2 secs again */
577 
578 		pcidata  = 0;
579 		pci_read_config_dword(instance->pdev,
580 				MFI_1068_FW_HANDSHAKE_OFFSET, &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(instance->pdev,
586 				MFI_1068_FW_HANDSHAKE_OFFSET, 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(&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(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
645 
646 	writel(~0x80000000, &(regs)->outbound_intr_mask);
647 
648 	/* Dummy readl to force pci flush */
649 	readl(&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(mask, &regs->outbound_intr_mask);
664 	/* Dummy readl to force pci flush */
665 	readl(&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(&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(&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(status, &regs->outbound_doorbell_clear);
704 
705 	/* Dummy readl to force pci flush */
706 	readl(&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((frame_phys_addr | (frame_count<<1))|1,
728 			&(regs)->inbound_queue_port);
729 	spin_unlock_irqrestore(&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(&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(0xFFFFFFFF, &(regs)->outbound_intr_mask);
774 
775 	writel(~MFI_SKINNY_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
776 
777 	/* Dummy readl to force pci flush */
778 	readl(&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(mask, &regs->outbound_intr_mask);
793 	/* Dummy readl to force pci flush */
794 	readl(&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(&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(&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(status, &regs->outbound_intr_status);
841 
842 	/*
843 	 * dummy read to flush PCI
844 	 */
845 	readl(&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 	       &(regs)->inbound_high_queue_port);
868 	writel((lower_32_bits(frame_phys_addr) | (frame_count<<1))|1,
869 	       &(regs)->inbound_low_queue_port);
870 	spin_unlock_irqrestore(&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(&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(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
921 
922 	/* write ~0x00000005 (4 & 1) to the intr mask*/
923 	writel(~MFI_GEN2_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
924 
925 	/* Dummy readl to force pci flush */
926 	readl(&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(mask, &regs->outbound_intr_mask);
941 	/* Dummy readl to force pci flush */
942 	readl(&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(&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(&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(status, &regs->outbound_doorbell_clear);
984 
985 	/* Dummy readl to force pci flush */
986 	readl(&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((frame_phys_addr | (frame_count<<1))|1,
1008 			&(regs)->inbound_queue_port);
1009 	spin_unlock_irqrestore(&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(0, seq_offset);
1032 	writel(4, seq_offset);
1033 	writel(0xb, seq_offset);
1034 	writel(2, seq_offset);
1035 	writel(7, seq_offset);
1036 	writel(0xd, seq_offset);
1037 
1038 	msleep(1000);
1039 
1040 	HostDiag = (u32)readl(hostdiag_offset);
1041 
1042 	while (!(HostDiag & DIAG_WRITE_ENABLE)) {
1043 		msleep(100);
1044 		HostDiag = (u32)readl(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((HostDiag | DIAG_RESET_ADAPTER), hostdiag_offset);
1056 
1057 	ssleep(10);
1058 
1059 	HostDiag = (u32)readl(hostdiag_offset);
1060 	while (HostDiag & DIAG_RESET_ADAPTER) {
1061 		msleep(100);
1062 		HostDiag = (u32)readl(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(&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(&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, 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(&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(&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(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(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(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(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 						      &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 						      &pthru->sgl);
1471 	} else
1472 		pthru->sge_count = megasas_make_sgl32(instance, scp,
1473 						      &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, 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 					      &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, &ldio->sgl);
1613 	} else
1614 		ldio->sge_count = megasas_make_sgl32(instance, scp, &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 			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->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(scmd) == READ_WRITE_LDIO)
1755 		frame_count = megasas_build_ldio(instance, scmd, cmd);
1756 	else
1757 		frame_count = megasas_build_dcdb(instance, scmd, cmd);
1758 
1759 	if (!frame_count)
1760 		goto out_return_cmd;
1761 
1762 	cmd->scmd = scmd;
1763 	megasas_priv(scmd)->cmd_priv = cmd;
1764 
1765 	/*
1766 	 * Issue the command to the FW
1767 	 */
1768 	atomic_inc(&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(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(&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(scmd);
1813 			return 0;
1814 		}
1815 	}
1816 
1817 	mr_device_priv_data = scmd->device->hostdata;
1818 	if (!mr_device_priv_data ||
1819 	    (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)) {
1820 		scmd->result = DID_NO_CONNECT << 16;
1821 		scsi_done(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(scmd);
1830 			return 0;
1831 		}
1832 	}
1833 
1834 	if (atomic_read(&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(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(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(device_id, local_map_ptr);
1914 		if (ld >= instance->fw_supported_vd_count)
1915 			return;
1916 		raid = MR_LdRaidGet(ld, 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, 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(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(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_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(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(&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(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(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(&mr_device_priv_data->r1_ldio_hint,
2150 		   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(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(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_mfi, 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_mfi, DID_OK);
2211 		}
2212 	}
2213 }
2214 
2215 
2216 void megaraid_sas_kill_hba(struct megasas_instance *instance)
2217 {
2218 	if (atomic_read(&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(&instance->adprecovery, MEGASAS_HW_CRITICAL_ERROR);
2226 	/* Wait 1 second to ensure IO or ioctls in build have posted */
2227 	msleep(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, &instance->reg_set->doorbell);
2233 			/* Flush */
2234 			readl(&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 			&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(&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(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(&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, 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(&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(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
2354 	instance->issuepend_done = 0;
2355 
2356 	atomic_set(&instance->fw_outstanding, 0);
2357 	megasas_internal_reset_defer_cmds(instance);
2358 	process_fw_state_change_wq(&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(&instance->pdev->dev,
2395 					   sizeof(struct MR_LD_VF_AFFILIATION_111),
2396 					   &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, 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(&instance->pdev->dev,
2457 				    sizeof(struct MR_LD_VF_AFFILIATION_111),
2458 				    new_affiliation_111,
2459 				    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(&instance->pdev->dev,
2502 					   (MAX_LOGICAL_DRIVES + 1) * sizeof(struct MR_LD_VF_AFFILIATION),
2503 					   &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, 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(&instance->pdev->dev,
2624 				    (MAX_LOGICAL_DRIVES + 1) *
2625 				    sizeof(struct MR_LD_VF_AFFILIATION),
2626 				    new_affiliation, 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(&instance->pdev->dev,
2667 					   sizeof(struct MR_CTRL_HB_HOST_MEM),
2668 					   &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, instance->hb_host_mem_h,
2692 				 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(&instance->sriov_heartbeat_timer,
2729 			  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(&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(&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(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
2762 
2763 		INIT_LIST_HEAD(&clist_local);
2764 		spin_lock_irqsave(&instance->hba_lock, flags);
2765 		list_splice_init(&instance->internal_reset_pending_q,
2766 				&clist_local);
2767 		spin_unlock_irqrestore(&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(1000);
2772 			if (atomic_read(&instance->adprecovery) == MEGASAS_HBA_OPERATIONAL)
2773 				break;
2774 		}
2775 
2776 		if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
2777 			dev_notice(&instance->pdev->dev, "reset: Stopping HBA.\n");
2778 			atomic_set(&instance->adprecovery, MEGASAS_HW_CRITICAL_ERROR);
2779 			return FAILED;
2780 		}
2781 
2782 		reset_index = 0;
2783 		while (!list_empty(&clist_local)) {
2784 			reset_cmd = list_entry((&clist_local)->next,
2785 						struct megasas_cmd, list);
2786 			list_del_init(&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(reset_cmd->scmd);
2794 				megasas_return_cmd(instance, 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(&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((unsigned long)instance);
2829 		}
2830 
2831 		msleep(1000);
2832 	}
2833 
2834 	i = 0;
2835 	outstanding = atomic_read(&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(&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(&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(500);
2862 
2863 			outstanding = atomic_read(&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(&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
2931 blk_eh_timer_return megasas_reset_timer(struct scsi_cmnd *scmd)
2932 {
2933 	struct megasas_instance *instance;
2934 	unsigned long flags;
2935 
2936 	if (time_after(jiffies, scmd->jiffies_at_alloc +
2937 				(scmd_timeout * 2) * HZ)) {
2938 		return BLK_EH_DONE;
2939 	}
2940 
2941 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
2942 	if (!(instance->flag & MEGASAS_FW_BUSY)) {
2943 		/* FW is busy, throttle IO */
2944 		spin_lock_irqsave(instance->host->host_lock, flags);
2945 
2946 		instance->host->can_queue = instance->throttlequeuedepth;
2947 		instance->last_time = jiffies;
2948 		instance->flag |= MEGASAS_FW_BUSY;
2949 
2950 		spin_unlock_irqrestore(instance->host->host_lock, flags);
2951 	}
2952 	return BLK_EH_RESET_TIMER;
2953 }
2954 
2955 /**
2956  * megasas_dump -	This function will print hexdump of provided buffer.
2957  * @buf:		Buffer to be dumped
2958  * @sz:		Size in bytes
2959  * @format:		Different formats of dumping e.g. format=n will
2960  *			cause only 'n' 32 bit words to be dumped in a single
2961  *			line.
2962  */
2963 inline void
2964 megasas_dump(void *buf, int sz, int format)
2965 {
2966 	int i;
2967 	__le32 *buf_loc = (__le32 *)buf;
2968 
2969 	for (i = 0; i < (sz / sizeof(__le32)); i++) {
2970 		if ((i % format) == 0) {
2971 			if (i != 0)
2972 				printk(KERN_CONT "\n");
2973 			printk(KERN_CONT "%08x: ", (i * 4));
2974 		}
2975 		printk(KERN_CONT "%08x ", le32_to_cpu(buf_loc[i]));
2976 	}
2977 	printk(KERN_CONT "\n");
2978 }
2979 
2980 /**
2981  * megasas_dump_reg_set -	This function will print hexdump of register set
2982  * @reg_set:	Register set to be dumped
2983  */
2984 inline void
2985 megasas_dump_reg_set(void __iomem *reg_set)
2986 {
2987 	unsigned int i, sz = 256;
2988 	u32 __iomem *reg = (u32 __iomem *)reg_set;
2989 
2990 	for (i = 0; i < (sz / sizeof(u32)); i++)
2991 		printk("%08x: %08x\n", (i * 4), readl(&reg[i]));
2992 }
2993 
2994 /**
2995  * megasas_dump_fusion_io -	This function will print key details
2996  *				of SCSI IO
2997  * @scmd:			SCSI command pointer of SCSI IO
2998  */
2999 void
3000 megasas_dump_fusion_io(struct scsi_cmnd *scmd)
3001 {
3002 	struct megasas_cmd_fusion *cmd = megasas_priv(scmd)->cmd_priv;
3003 	union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
3004 	struct megasas_instance *instance;
3005 
3006 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3007 
3008 	scmd_printk(KERN_INFO, scmd,
3009 		    "scmd: (0x%p)  retries: 0x%x  allowed: 0x%x\n",
3010 		    scmd, scmd->retries, scmd->allowed);
3011 	scsi_print_command(scmd);
3012 
3013 	if (cmd) {
3014 		req_desc = (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)cmd->request_desc;
3015 		scmd_printk(KERN_INFO, scmd, "Request descriptor details:\n");
3016 		scmd_printk(KERN_INFO, scmd,
3017 			    "RequestFlags:0x%x  MSIxIndex:0x%x  SMID:0x%x  LMID:0x%x  DevHandle:0x%x\n",
3018 			    req_desc->SCSIIO.RequestFlags,
3019 			    req_desc->SCSIIO.MSIxIndex, req_desc->SCSIIO.SMID,
3020 			    req_desc->SCSIIO.LMID, req_desc->SCSIIO.DevHandle);
3021 
3022 		printk(KERN_INFO "IO request frame:\n");
3023 		megasas_dump(cmd->io_request,
3024 			     MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE, 8);
3025 		printk(KERN_INFO "Chain frame:\n");
3026 		megasas_dump(cmd->sg_frame,
3027 			     instance->max_chain_frame_sz, 8);
3028 	}
3029 
3030 }
3031 
3032 /*
3033  * megasas_dump_sys_regs - This function will dump system registers through
3034  *			    sysfs.
3035  * @reg_set:		    Pointer to System register set.
3036  * @buf:		    Buffer to which output is to be written.
3037  * @return:		    Number of bytes written to buffer.
3038  */
3039 static inline ssize_t
3040 megasas_dump_sys_regs(void __iomem *reg_set, char *buf)
3041 {
3042 	unsigned int i, sz = 256;
3043 	int bytes_wrote = 0;
3044 	char *loc = (char *)buf;
3045 	u32 __iomem *reg = (u32 __iomem *)reg_set;
3046 
3047 	for (i = 0; i < sz / sizeof(u32); i++) {
3048 		bytes_wrote += scnprintf(loc + bytes_wrote,
3049 					 PAGE_SIZE - bytes_wrote,
3050 					 "%08x: %08x\n", (i * 4),
3051 					 readl(&reg[i]));
3052 	}
3053 	return bytes_wrote;
3054 }
3055 
3056 /**
3057  * megasas_reset_bus_host -	Bus & host reset handler entry point
3058  * @scmd:			Mid-layer SCSI command
3059  */
3060 static int megasas_reset_bus_host(struct scsi_cmnd *scmd)
3061 {
3062 	int ret;
3063 	struct megasas_instance *instance;
3064 
3065 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3066 
3067 	scmd_printk(KERN_INFO, scmd,
3068 		"OCR is requested due to IO timeout!!\n");
3069 
3070 	scmd_printk(KERN_INFO, scmd,
3071 		"SCSI host state: %d  SCSI host busy: %d  FW outstanding: %d\n",
3072 		scmd->device->host->shost_state,
3073 		scsi_host_busy(scmd->device->host),
3074 		atomic_read(&instance->fw_outstanding));
3075 	/*
3076 	 * First wait for all commands to complete
3077 	 */
3078 	if (instance->adapter_type == MFI_SERIES) {
3079 		ret = megasas_generic_reset(scmd);
3080 	} else {
3081 		megasas_dump_fusion_io(scmd);
3082 		ret = megasas_reset_fusion(scmd->device->host,
3083 				SCSIIO_TIMEOUT_OCR);
3084 	}
3085 
3086 	return ret;
3087 }
3088 
3089 /**
3090  * megasas_task_abort - Issues task abort request to firmware
3091  *			(supported only for fusion adapters)
3092  * @scmd:		SCSI command pointer
3093  */
3094 static int megasas_task_abort(struct scsi_cmnd *scmd)
3095 {
3096 	int ret;
3097 	struct megasas_instance *instance;
3098 
3099 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3100 
3101 	if (instance->adapter_type != MFI_SERIES)
3102 		ret = megasas_task_abort_fusion(scmd);
3103 	else {
3104 		sdev_printk(KERN_NOTICE, scmd->device, "TASK ABORT not supported\n");
3105 		ret = FAILED;
3106 	}
3107 
3108 	return ret;
3109 }
3110 
3111 /**
3112  * megasas_reset_target:  Issues target reset request to firmware
3113  *                        (supported only for fusion adapters)
3114  * @scmd:                 SCSI command pointer
3115  */
3116 static int megasas_reset_target(struct scsi_cmnd *scmd)
3117 {
3118 	int ret;
3119 	struct megasas_instance *instance;
3120 
3121 	instance = (struct megasas_instance *)scmd->device->host->hostdata;
3122 
3123 	if (instance->adapter_type != MFI_SERIES)
3124 		ret = megasas_reset_target_fusion(scmd);
3125 	else {
3126 		sdev_printk(KERN_NOTICE, scmd->device, "TARGET RESET not supported\n");
3127 		ret = FAILED;
3128 	}
3129 
3130 	return ret;
3131 }
3132 
3133 /**
3134  * megasas_bios_param - Returns disk geometry for a disk
3135  * @sdev:		device handle
3136  * @bdev:		block device
3137  * @capacity:		drive capacity
3138  * @geom:		geometry parameters
3139  */
3140 static int
3141 megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev,
3142 		 sector_t capacity, int geom[])
3143 {
3144 	int heads;
3145 	int sectors;
3146 	sector_t cylinders;
3147 	unsigned long tmp;
3148 
3149 	/* Default heads (64) & sectors (32) */
3150 	heads = 64;
3151 	sectors = 32;
3152 
3153 	tmp = heads * sectors;
3154 	cylinders = capacity;
3155 
3156 	sector_div(cylinders, tmp);
3157 
3158 	/*
3159 	 * Handle extended translation size for logical drives > 1Gb
3160 	 */
3161 
3162 	if (capacity >= 0x200000) {
3163 		heads = 255;
3164 		sectors = 63;
3165 		tmp = heads*sectors;
3166 		cylinders = capacity;
3167 		sector_div(cylinders, tmp);
3168 	}
3169 
3170 	geom[0] = heads;
3171 	geom[1] = sectors;
3172 	geom[2] = cylinders;
3173 
3174 	return 0;
3175 }
3176 
3177 static void megasas_map_queues(struct Scsi_Host *shost)
3178 {
3179 	struct megasas_instance *instance;
3180 	int qoff = 0, offset;
3181 	struct blk_mq_queue_map *map;
3182 
3183 	instance = (struct megasas_instance *)shost->hostdata;
3184 
3185 	if (shost->nr_hw_queues == 1)
3186 		return;
3187 
3188 	offset = instance->low_latency_index_start;
3189 
3190 	/* Setup Default hctx */
3191 	map = &shost->tag_set.map[HCTX_TYPE_DEFAULT];
3192 	map->nr_queues = instance->msix_vectors - offset;
3193 	map->queue_offset = 0;
3194 	blk_mq_pci_map_queues(map, instance->pdev, offset);
3195 	qoff += map->nr_queues;
3196 	offset += map->nr_queues;
3197 
3198 	/* we never use READ queue, so can't cheat blk-mq */
3199 	shost->tag_set.map[HCTX_TYPE_READ].nr_queues = 0;
3200 
3201 	/* Setup Poll hctx */
3202 	map = &shost->tag_set.map[HCTX_TYPE_POLL];
3203 	map->nr_queues = instance->iopoll_q_count;
3204 	if (map->nr_queues) {
3205 		/*
3206 		 * The poll queue(s) doesn't have an IRQ (and hence IRQ
3207 		 * affinity), so use the regular blk-mq cpu mapping
3208 		 */
3209 		map->queue_offset = qoff;
3210 		blk_mq_map_queues(map);
3211 	}
3212 }
3213 
3214 static void megasas_aen_polling(struct work_struct *work);
3215 
3216 /**
3217  * megasas_service_aen -	Processes an event notification
3218  * @instance:			Adapter soft state
3219  * @cmd:			AEN command completed by the ISR
3220  *
3221  * For AEN, driver sends a command down to FW that is held by the FW till an
3222  * event occurs. When an event of interest occurs, FW completes the command
3223  * that it was previously holding.
3224  *
3225  * This routines sends SIGIO signal to processes that have registered with the
3226  * driver for AEN.
3227  */
3228 static void
3229 megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
3230 {
3231 	unsigned long flags;
3232 
3233 	/*
3234 	 * Don't signal app if it is just an aborted previously registered aen
3235 	 */
3236 	if ((!cmd->abort_aen) && (instance->unload == 0)) {
3237 		spin_lock_irqsave(&poll_aen_lock, flags);
3238 		megasas_poll_wait_aen = 1;
3239 		spin_unlock_irqrestore(&poll_aen_lock, flags);
3240 		wake_up(&megasas_poll_wait);
3241 		kill_fasync(&megasas_async_queue, SIGIO, POLL_IN);
3242 	}
3243 	else
3244 		cmd->abort_aen = 0;
3245 
3246 	instance->aen_cmd = NULL;
3247 
3248 	megasas_return_cmd(instance, cmd);
3249 
3250 	if ((instance->unload == 0) &&
3251 		((instance->issuepend_done == 1))) {
3252 		struct megasas_aen_event *ev;
3253 
3254 		ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
3255 		if (!ev) {
3256 			dev_err(&instance->pdev->dev, "megasas_service_aen: out of memory\n");
3257 		} else {
3258 			ev->instance = instance;
3259 			instance->ev = ev;
3260 			INIT_DELAYED_WORK(&ev->hotplug_work,
3261 					  megasas_aen_polling);
3262 			schedule_delayed_work(&ev->hotplug_work, 0);
3263 		}
3264 	}
3265 }
3266 
3267 static ssize_t
3268 fw_crash_buffer_store(struct device *cdev,
3269 	struct device_attribute *attr, const char *buf, size_t count)
3270 {
3271 	struct Scsi_Host *shost = class_to_shost(cdev);
3272 	struct megasas_instance *instance =
3273 		(struct megasas_instance *) shost->hostdata;
3274 	int val = 0;
3275 	unsigned long flags;
3276 
3277 	if (kstrtoint(buf, 0, &val) != 0)
3278 		return -EINVAL;
3279 
3280 	spin_lock_irqsave(&instance->crashdump_lock, flags);
3281 	instance->fw_crash_buffer_offset = val;
3282 	spin_unlock_irqrestore(&instance->crashdump_lock, flags);
3283 	return strlen(buf);
3284 }
3285 
3286 static ssize_t
3287 fw_crash_buffer_show(struct device *cdev,
3288 	struct device_attribute *attr, char *buf)
3289 {
3290 	struct Scsi_Host *shost = class_to_shost(cdev);
3291 	struct megasas_instance *instance =
3292 		(struct megasas_instance *) shost->hostdata;
3293 	u32 size;
3294 	unsigned long dmachunk = CRASH_DMA_BUF_SIZE;
3295 	unsigned long chunk_left_bytes;
3296 	unsigned long src_addr;
3297 	unsigned long flags;
3298 	u32 buff_offset;
3299 
3300 	spin_lock_irqsave(&instance->crashdump_lock, flags);
3301 	buff_offset = instance->fw_crash_buffer_offset;
3302 	if (!instance->crash_dump_buf &&
3303 		!((instance->fw_crash_state == AVAILABLE) ||
3304 		(instance->fw_crash_state == COPYING))) {
3305 		dev_err(&instance->pdev->dev,
3306 			"Firmware crash dump is not available\n");
3307 		spin_unlock_irqrestore(&instance->crashdump_lock, flags);
3308 		return -EINVAL;
3309 	}
3310 
3311 	if (buff_offset > (instance->fw_crash_buffer_size * dmachunk)) {
3312 		dev_err(&instance->pdev->dev,
3313 			"Firmware crash dump offset is out of range\n");
3314 		spin_unlock_irqrestore(&instance->crashdump_lock, flags);
3315 		return 0;
3316 	}
3317 
3318 	size = (instance->fw_crash_buffer_size * dmachunk) - buff_offset;
3319 	chunk_left_bytes = dmachunk - (buff_offset % dmachunk);
3320 	size = (size > chunk_left_bytes) ? chunk_left_bytes : size;
3321 	size = (size >= PAGE_SIZE) ? (PAGE_SIZE - 1) : size;
3322 
3323 	src_addr = (unsigned long)instance->crash_buf[buff_offset / dmachunk] +
3324 		(buff_offset % dmachunk);
3325 	memcpy(buf, (void *)src_addr, size);
3326 	spin_unlock_irqrestore(&instance->crashdump_lock, flags);
3327 
3328 	return size;
3329 }
3330 
3331 static ssize_t
3332 fw_crash_buffer_size_show(struct device *cdev,
3333 	struct device_attribute *attr, char *buf)
3334 {
3335 	struct Scsi_Host *shost = class_to_shost(cdev);
3336 	struct megasas_instance *instance =
3337 		(struct megasas_instance *) shost->hostdata;
3338 
3339 	return snprintf(buf, PAGE_SIZE, "%ld\n", (unsigned long)
3340 		((instance->fw_crash_buffer_size) * 1024 * 1024)/PAGE_SIZE);
3341 }
3342 
3343 static ssize_t
3344 fw_crash_state_store(struct device *cdev,
3345 	struct device_attribute *attr, const char *buf, size_t count)
3346 {
3347 	struct Scsi_Host *shost = class_to_shost(cdev);
3348 	struct megasas_instance *instance =
3349 		(struct megasas_instance *) shost->hostdata;
3350 	int val = 0;
3351 	unsigned long flags;
3352 
3353 	if (kstrtoint(buf, 0, &val) != 0)
3354 		return -EINVAL;
3355 
3356 	if ((val <= AVAILABLE || val > COPY_ERROR)) {
3357 		dev_err(&instance->pdev->dev, "application updates invalid "
3358 			"firmware crash state\n");
3359 		return -EINVAL;
3360 	}
3361 
3362 	instance->fw_crash_state = val;
3363 
3364 	if ((val == COPIED) || (val == COPY_ERROR)) {
3365 		spin_lock_irqsave(&instance->crashdump_lock, flags);
3366 		megasas_free_host_crash_buffer(instance);
3367 		spin_unlock_irqrestore(&instance->crashdump_lock, flags);
3368 		if (val == COPY_ERROR)
3369 			dev_info(&instance->pdev->dev, "application failed to "
3370 				"copy Firmware crash dump\n");
3371 		else
3372 			dev_info(&instance->pdev->dev, "Firmware crash dump "
3373 				"copied successfully\n");
3374 	}
3375 	return strlen(buf);
3376 }
3377 
3378 static ssize_t
3379 fw_crash_state_show(struct device *cdev,
3380 	struct device_attribute *attr, char *buf)
3381 {
3382 	struct Scsi_Host *shost = class_to_shost(cdev);
3383 	struct megasas_instance *instance =
3384 		(struct megasas_instance *) shost->hostdata;
3385 
3386 	return snprintf(buf, PAGE_SIZE, "%d\n", instance->fw_crash_state);
3387 }
3388 
3389 static ssize_t
3390 page_size_show(struct device *cdev,
3391 	struct device_attribute *attr, char *buf)
3392 {
3393 	return snprintf(buf, PAGE_SIZE, "%ld\n", (unsigned long)PAGE_SIZE - 1);
3394 }
3395 
3396 static ssize_t
3397 ldio_outstanding_show(struct device *cdev, struct device_attribute *attr,
3398 	char *buf)
3399 {
3400 	struct Scsi_Host *shost = class_to_shost(cdev);
3401 	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3402 
3403 	return snprintf(buf, PAGE_SIZE, "%d\n", atomic_read(&instance->ldio_outstanding));
3404 }
3405 
3406 static ssize_t
3407 fw_cmds_outstanding_show(struct device *cdev,
3408 				 struct device_attribute *attr, char *buf)
3409 {
3410 	struct Scsi_Host *shost = class_to_shost(cdev);
3411 	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3412 
3413 	return snprintf(buf, PAGE_SIZE, "%d\n", atomic_read(&instance->fw_outstanding));
3414 }
3415 
3416 static ssize_t
3417 enable_sdev_max_qd_show(struct device *cdev,
3418 	struct device_attribute *attr, char *buf)
3419 {
3420 	struct Scsi_Host *shost = class_to_shost(cdev);
3421 	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3422 
3423 	return snprintf(buf, PAGE_SIZE, "%d\n", instance->enable_sdev_max_qd);
3424 }
3425 
3426 static ssize_t
3427 enable_sdev_max_qd_store(struct device *cdev,
3428 	struct device_attribute *attr, const char *buf, size_t count)
3429 {
3430 	struct Scsi_Host *shost = class_to_shost(cdev);
3431 	struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3432 	u32 val = 0;
3433 	bool is_target_prop;
3434 	int ret_target_prop = DCMD_FAILED;
3435 	struct scsi_device *sdev;
3436 
3437 	if (kstrtou32(buf, 0, &val) != 0) {
3438 		pr_err("megasas: could not set enable_sdev_max_qd\n");
3439 		return -EINVAL;
3440 	}
3441 
3442 	mutex_lock(&instance->reset_mutex);
3443 	if (val)
3444 		instance->enable_sdev_max_qd = true;
3445 	else
3446 		instance->enable_sdev_max_qd = false;
3447 
3448 	shost_for_each_device(sdev, shost) {
3449 		ret_target_prop = megasas_get_target_prop(instance, sdev);
3450 		is_target_prop = (ret_target_prop == DCMD_SUCCESS) ? true : false;
3451 		megasas_set_fw_assisted_qd(sdev, is_target_prop);
3452 	}
3453 	mutex_unlock(&instance->reset_mutex);
3454 
3455 	return strlen(buf);
3456 }
3457 
3458 static ssize_t
3459 dump_system_regs_show(struct device *cdev,
3460 			       struct device_attribute *attr, char *buf)
3461 {
3462 	struct Scsi_Host *shost = class_to_shost(cdev);
3463 	struct megasas_instance *instance =
3464 			(struct megasas_instance *)shost->hostdata;
3465 
3466 	return megasas_dump_sys_regs(instance->reg_set, buf);
3467 }
3468 
3469 static ssize_t
3470 raid_map_id_show(struct device *cdev, struct device_attribute *attr,
3471 			  char *buf)
3472 {
3473 	struct Scsi_Host *shost = class_to_shost(cdev);
3474 	struct megasas_instance *instance =
3475 			(struct megasas_instance *)shost->hostdata;
3476 
3477 	return snprintf(buf, PAGE_SIZE, "%ld\n",
3478 			(unsigned long)instance->map_id);
3479 }
3480 
3481 static DEVICE_ATTR_RW(fw_crash_buffer);
3482 static DEVICE_ATTR_RO(fw_crash_buffer_size);
3483 static DEVICE_ATTR_RW(fw_crash_state);
3484 static DEVICE_ATTR_RO(page_size);
3485 static DEVICE_ATTR_RO(ldio_outstanding);
3486 static DEVICE_ATTR_RO(fw_cmds_outstanding);
3487 static DEVICE_ATTR_RW(enable_sdev_max_qd);
3488 static DEVICE_ATTR_RO(dump_system_regs);
3489 static DEVICE_ATTR_RO(raid_map_id);
3490 
3491 static struct attribute *megaraid_host_attrs[] = {
3492 	&dev_attr_fw_crash_buffer_size.attr,
3493 	&dev_attr_fw_crash_buffer.attr,
3494 	&dev_attr_fw_crash_state.attr,
3495 	&dev_attr_page_size.attr,
3496 	&dev_attr_ldio_outstanding.attr,
3497 	&dev_attr_fw_cmds_outstanding.attr,
3498 	&dev_attr_enable_sdev_max_qd.attr,
3499 	&dev_attr_dump_system_regs.attr,
3500 	&dev_attr_raid_map_id.attr,
3501 	NULL,
3502 };
3503 
3504 ATTRIBUTE_GROUPS(megaraid_host);
3505 
3506 /*
3507  * Scsi host template for megaraid_sas driver
3508  */
3509 static struct scsi_host_template megasas_template = {
3510 
3511 	.module = THIS_MODULE,
3512 	.name = "Avago SAS based MegaRAID driver",
3513 	.proc_name = "megaraid_sas",
3514 	.slave_configure = megasas_slave_configure,
3515 	.slave_alloc = megasas_slave_alloc,
3516 	.slave_destroy = megasas_slave_destroy,
3517 	.queuecommand = megasas_queue_command,
3518 	.eh_target_reset_handler = megasas_reset_target,
3519 	.eh_abort_handler = megasas_task_abort,
3520 	.eh_host_reset_handler = megasas_reset_bus_host,
3521 	.eh_timed_out = megasas_reset_timer,
3522 	.shost_groups = megaraid_host_groups,
3523 	.bios_param = megasas_bios_param,
3524 	.map_queues = megasas_map_queues,
3525 	.mq_poll = megasas_blk_mq_poll,
3526 	.change_queue_depth = scsi_change_queue_depth,
3527 	.max_segment_size = 0xffffffff,
3528 	.cmd_size = sizeof(struct megasas_cmd_priv),
3529 };
3530 
3531 /**
3532  * megasas_complete_int_cmd -	Completes an internal command
3533  * @instance:			Adapter soft state
3534  * @cmd:			Command to be completed
3535  *
3536  * The megasas_issue_blocked_cmd() function waits for a command to complete
3537  * after it issues a command. This function wakes up that waiting routine by
3538  * calling wake_up() on the wait queue.
3539  */
3540 static void
3541 megasas_complete_int_cmd(struct megasas_instance *instance,
3542 			 struct megasas_cmd *cmd)
3543 {
3544 	if (cmd->cmd_status_drv == DCMD_INIT)
3545 		cmd->cmd_status_drv =
3546 		(cmd->frame->io.cmd_status == MFI_STAT_OK) ?
3547 		DCMD_SUCCESS : DCMD_FAILED;
3548 
3549 	wake_up(&instance->int_cmd_wait_q);
3550 }
3551 
3552 /**
3553  * megasas_complete_abort -	Completes aborting a command
3554  * @instance:			Adapter soft state
3555  * @cmd:			Cmd that was issued to abort another cmd
3556  *
3557  * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q
3558  * after it issues an abort on a previously issued command. This function
3559  * wakes up all functions waiting on the same wait queue.
3560  */
3561 static void
3562 megasas_complete_abort(struct megasas_instance *instance,
3563 		       struct megasas_cmd *cmd)
3564 {
3565 	if (cmd->sync_cmd) {
3566 		cmd->sync_cmd = 0;
3567 		cmd->cmd_status_drv = DCMD_SUCCESS;
3568 		wake_up(&instance->abort_cmd_wait_q);
3569 	}
3570 }
3571 
3572 static void
3573 megasas_set_ld_removed_by_fw(struct megasas_instance *instance)
3574 {
3575 	uint i;
3576 
3577 	for (i = 0; (i < MEGASAS_MAX_LD_IDS); i++) {
3578 		if (instance->ld_ids_prev[i] != 0xff &&
3579 		    instance->ld_ids_from_raidmap[i] == 0xff) {
3580 			if (megasas_dbg_lvl & LD_PD_DEBUG)
3581 				dev_info(&instance->pdev->dev,
3582 					 "LD target ID %d removed from RAID map\n", i);
3583 			instance->ld_tgtid_status[i] = LD_TARGET_ID_DELETED;
3584 		}
3585 	}
3586 }
3587 
3588 /**
3589  * megasas_complete_cmd -	Completes a command
3590  * @instance:			Adapter soft state
3591  * @cmd:			Command to be completed
3592  * @alt_status:			If non-zero, use this value as status to
3593  *				SCSI mid-layer instead of the value returned
3594  *				by the FW. This should be used if caller wants
3595  *				an alternate status (as in the case of aborted
3596  *				commands)
3597  */
3598 void
3599 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
3600 		     u8 alt_status)
3601 {
3602 	int exception = 0;
3603 	struct megasas_header *hdr = &cmd->frame->hdr;
3604 	unsigned long flags;
3605 	struct fusion_context *fusion = instance->ctrl_context;
3606 	u32 opcode, status;
3607 
3608 	/* flag for the retry reset */
3609 	cmd->retry_for_fw_reset = 0;
3610 
3611 	if (cmd->scmd)
3612 		megasas_priv(cmd->scmd)->cmd_priv = NULL;
3613 
3614 	switch (hdr->cmd) {
3615 	case MFI_CMD_INVALID:
3616 		/* Some older 1068 controller FW may keep a pended
3617 		   MR_DCMD_CTRL_EVENT_GET_INFO left over from the main kernel
3618 		   when booting the kdump kernel.  Ignore this command to
3619 		   prevent a kernel panic on shutdown of the kdump kernel. */
3620 		dev_warn(&instance->pdev->dev, "MFI_CMD_INVALID command "
3621 		       "completed\n");
3622 		dev_warn(&instance->pdev->dev, "If you have a controller "
3623 		       "other than PERC5, please upgrade your firmware\n");
3624 		break;
3625 	case MFI_CMD_PD_SCSI_IO:
3626 	case MFI_CMD_LD_SCSI_IO:
3627 
3628 		/*
3629 		 * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been
3630 		 * issued either through an IO path or an IOCTL path. If it
3631 		 * was via IOCTL, we will send it to internal completion.
3632 		 */
3633 		if (cmd->sync_cmd) {
3634 			cmd->sync_cmd = 0;
3635 			megasas_complete_int_cmd(instance, cmd);
3636 			break;
3637 		}
3638 		fallthrough;
3639 
3640 	case MFI_CMD_LD_READ:
3641 	case MFI_CMD_LD_WRITE:
3642 
3643 		if (alt_status) {
3644 			cmd->scmd->result = alt_status << 16;
3645 			exception = 1;
3646 		}
3647 
3648 		if (exception) {
3649 
3650 			atomic_dec(&instance->fw_outstanding);
3651 
3652 			scsi_dma_unmap(cmd->scmd);
3653 			scsi_done(cmd->scmd);
3654 			megasas_return_cmd(instance, cmd);
3655 
3656 			break;
3657 		}
3658 
3659 		switch (hdr->cmd_status) {
3660 
3661 		case MFI_STAT_OK:
3662 			cmd->scmd->result = DID_OK << 16;
3663 			break;
3664 
3665 		case MFI_STAT_SCSI_IO_FAILED:
3666 		case MFI_STAT_LD_INIT_IN_PROGRESS:
3667 			cmd->scmd->result =
3668 			    (DID_ERROR << 16) | hdr->scsi_status;
3669 			break;
3670 
3671 		case MFI_STAT_SCSI_DONE_WITH_ERROR:
3672 
3673 			cmd->scmd->result = (DID_OK << 16) | hdr->scsi_status;
3674 
3675 			if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) {
3676 				memset(cmd->scmd->sense_buffer, 0,
3677 				       SCSI_SENSE_BUFFERSIZE);
3678 				memcpy(cmd->scmd->sense_buffer, cmd->sense,
3679 				       hdr->sense_len);
3680 			}
3681 
3682 			break;
3683 
3684 		case MFI_STAT_LD_OFFLINE:
3685 		case MFI_STAT_DEVICE_NOT_FOUND:
3686 			cmd->scmd->result = DID_BAD_TARGET << 16;
3687 			break;
3688 
3689 		default:
3690 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "MFI FW status %#x\n",
3691 			       hdr->cmd_status);
3692 			cmd->scmd->result = DID_ERROR << 16;
3693 			break;
3694 		}
3695 
3696 		atomic_dec(&instance->fw_outstanding);
3697 
3698 		scsi_dma_unmap(cmd->scmd);
3699 		scsi_done(cmd->scmd);
3700 		megasas_return_cmd(instance, cmd);
3701 
3702 		break;
3703 
3704 	case MFI_CMD_SMP:
3705 	case MFI_CMD_STP:
3706 	case MFI_CMD_NVME:
3707 	case MFI_CMD_TOOLBOX:
3708 		megasas_complete_int_cmd(instance, cmd);
3709 		break;
3710 
3711 	case MFI_CMD_DCMD:
3712 		opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
3713 		/* Check for LD map update */
3714 		if ((opcode == MR_DCMD_LD_MAP_GET_INFO)
3715 			&& (cmd->frame->dcmd.mbox.b[1] == 1)) {
3716 			fusion->fast_path_io = 0;
3717 			spin_lock_irqsave(instance->host->host_lock, flags);
3718 			status = cmd->frame->hdr.cmd_status;
3719 			instance->map_update_cmd = NULL;
3720 			if (status != MFI_STAT_OK) {
3721 				if (status != MFI_STAT_NOT_FOUND)
3722 					dev_warn(&instance->pdev->dev, "map syncfailed, status = 0x%x\n",
3723 					       cmd->frame->hdr.cmd_status);
3724 				else {
3725 					megasas_return_cmd(instance, cmd);
3726 					spin_unlock_irqrestore(
3727 						instance->host->host_lock,
3728 						flags);
3729 					break;
3730 				}
3731 			}
3732 
3733 			megasas_return_cmd(instance, cmd);
3734 
3735 			/*
3736 			 * Set fast path IO to ZERO.
3737 			 * Validate Map will set proper value.
3738 			 * Meanwhile all IOs will go as LD IO.
3739 			 */
3740 			if (status == MFI_STAT_OK &&
3741 			    (MR_ValidateMapInfo(instance, (instance->map_id + 1)))) {
3742 				instance->map_id++;
3743 				fusion->fast_path_io = 1;
3744 			} else {
3745 				fusion->fast_path_io = 0;
3746 			}
3747 
3748 			if (instance->adapter_type >= INVADER_SERIES)
3749 				megasas_set_ld_removed_by_fw(instance);
3750 
3751 			megasas_sync_map_info(instance);
3752 			spin_unlock_irqrestore(instance->host->host_lock,
3753 					       flags);
3754 
3755 			break;
3756 		}
3757 		if (opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||
3758 		    opcode == MR_DCMD_CTRL_EVENT_GET) {
3759 			spin_lock_irqsave(&poll_aen_lock, flags);
3760 			megasas_poll_wait_aen = 0;
3761 			spin_unlock_irqrestore(&poll_aen_lock, flags);
3762 		}
3763 
3764 		/* FW has an updated PD sequence */
3765 		if ((opcode == MR_DCMD_SYSTEM_PD_MAP_GET_INFO) &&
3766 			(cmd->frame->dcmd.mbox.b[0] == 1)) {
3767 
3768 			spin_lock_irqsave(instance->host->host_lock, flags);
3769 			status = cmd->frame->hdr.cmd_status;
3770 			instance->jbod_seq_cmd = NULL;
3771 			megasas_return_cmd(instance, cmd);
3772 
3773 			if (status == MFI_STAT_OK) {
3774 				instance->pd_seq_map_id++;
3775 				/* Re-register a pd sync seq num cmd */
3776 				if (megasas_sync_pd_seq_num(instance, true))
3777 					instance->use_seqnum_jbod_fp = false;
3778 			} else
3779 				instance->use_seqnum_jbod_fp = false;
3780 
3781 			spin_unlock_irqrestore(instance->host->host_lock, flags);
3782 			break;
3783 		}
3784 
3785 		/*
3786 		 * See if got an event notification
3787 		 */
3788 		if (opcode == MR_DCMD_CTRL_EVENT_WAIT)
3789 			megasas_service_aen(instance, cmd);
3790 		else
3791 			megasas_complete_int_cmd(instance, cmd);
3792 
3793 		break;
3794 
3795 	case MFI_CMD_ABORT:
3796 		/*
3797 		 * Cmd issued to abort another cmd returned
3798 		 */
3799 		megasas_complete_abort(instance, cmd);
3800 		break;
3801 
3802 	default:
3803 		dev_info(&instance->pdev->dev, "Unknown command completed! [0x%X]\n",
3804 		       hdr->cmd);
3805 		megasas_complete_int_cmd(instance, cmd);
3806 		break;
3807 	}
3808 }
3809 
3810 /**
3811  * megasas_issue_pending_cmds_again -	issue all pending cmds
3812  *					in FW again because of the fw reset
3813  * @instance:				Adapter soft state
3814  */
3815 static inline void
3816 megasas_issue_pending_cmds_again(struct megasas_instance *instance)
3817 {
3818 	struct megasas_cmd *cmd;
3819 	struct list_head clist_local;
3820 	union megasas_evt_class_locale class_locale;
3821 	unsigned long flags;
3822 	u32 seq_num;
3823 
3824 	INIT_LIST_HEAD(&clist_local);
3825 	spin_lock_irqsave(&instance->hba_lock, flags);
3826 	list_splice_init(&instance->internal_reset_pending_q, &clist_local);
3827 	spin_unlock_irqrestore(&instance->hba_lock, flags);
3828 
3829 	while (!list_empty(&clist_local)) {
3830 		cmd = list_entry((&clist_local)->next,
3831 					struct megasas_cmd, list);
3832 		list_del_init(&cmd->list);
3833 
3834 		if (cmd->sync_cmd || cmd->scmd) {
3835 			dev_notice(&instance->pdev->dev, "command %p, %p:%d"
3836 				"detected to be pending while HBA reset\n",
3837 					cmd, cmd->scmd, cmd->sync_cmd);
3838 
3839 			cmd->retry_for_fw_reset++;
3840 
3841 			if (cmd->retry_for_fw_reset == 3) {
3842 				dev_notice(&instance->pdev->dev, "cmd %p, %p:%d"
3843 					"was tried multiple times during reset."
3844 					"Shutting down the HBA\n",
3845 					cmd, cmd->scmd, cmd->sync_cmd);
3846 				instance->instancet->disable_intr(instance);
3847 				atomic_set(&instance->fw_reset_no_pci_access, 1);
3848 				megaraid_sas_kill_hba(instance);
3849 				return;
3850 			}
3851 		}
3852 
3853 		if (cmd->sync_cmd == 1) {
3854 			if (cmd->scmd) {
3855 				dev_notice(&instance->pdev->dev, "unexpected"
3856 					"cmd attached to internal command!\n");
3857 			}
3858 			dev_notice(&instance->pdev->dev, "%p synchronous cmd"
3859 						"on the internal reset queue,"
3860 						"issue it again.\n", cmd);
3861 			cmd->cmd_status_drv = DCMD_INIT;
3862 			instance->instancet->fire_cmd(instance,
3863 							cmd->frame_phys_addr,
3864 							0, instance->reg_set);
3865 		} else if (cmd->scmd) {
3866 			dev_notice(&instance->pdev->dev, "%p scsi cmd [%02x]"
3867 			"detected on the internal queue, issue again.\n",
3868 			cmd, cmd->scmd->cmnd[0]);
3869 
3870 			atomic_inc(&instance->fw_outstanding);
3871 			instance->instancet->fire_cmd(instance,
3872 					cmd->frame_phys_addr,
3873 					cmd->frame_count-1, instance->reg_set);
3874 		} else {
3875 			dev_notice(&instance->pdev->dev, "%p unexpected cmd on the"
3876 				"internal reset defer list while re-issue!!\n",
3877 				cmd);
3878 		}
3879 	}
3880 
3881 	if (instance->aen_cmd) {
3882 		dev_notice(&instance->pdev->dev, "aen_cmd in def process\n");
3883 		megasas_return_cmd(instance, instance->aen_cmd);
3884 
3885 		instance->aen_cmd = NULL;
3886 	}
3887 
3888 	/*
3889 	 * Initiate AEN (Asynchronous Event Notification)
3890 	 */
3891 	seq_num = instance->last_seq_num;
3892 	class_locale.members.reserved = 0;
3893 	class_locale.members.locale = MR_EVT_LOCALE_ALL;
3894 	class_locale.members.class = MR_EVT_CLASS_DEBUG;
3895 
3896 	megasas_register_aen(instance, seq_num, class_locale.word);
3897 }
3898 
3899 /*
3900  * Move the internal reset pending commands to a deferred queue.
3901  *
3902  * We move the commands pending at internal reset time to a
3903  * pending queue. This queue would be flushed after successful
3904  * completion of the internal reset sequence. if the internal reset
3905  * did not complete in time, the kernel reset handler would flush
3906  * these commands.
3907  */
3908 static void
3909 megasas_internal_reset_defer_cmds(struct megasas_instance *instance)
3910 {
3911 	struct megasas_cmd *cmd;
3912 	int i;
3913 	u16 max_cmd = instance->max_fw_cmds;
3914 	u32 defer_index;
3915 	unsigned long flags;
3916 
3917 	defer_index = 0;
3918 	spin_lock_irqsave(&instance->mfi_pool_lock, flags);
3919 	for (i = 0; i < max_cmd; i++) {
3920 		cmd = instance->cmd_list[i];
3921 		if (cmd->sync_cmd == 1 || cmd->scmd) {
3922 			dev_notice(&instance->pdev->dev, "moving cmd[%d]:%p:%d:%p"
3923 					"on the defer queue as internal\n",
3924 				defer_index, cmd, cmd->sync_cmd, cmd->scmd);
3925 
3926 			if (!list_empty(&cmd->list)) {
3927 				dev_notice(&instance->pdev->dev, "ERROR while"
3928 					" moving this cmd:%p, %d %p, it was"
3929 					"discovered on some list?\n",
3930 					cmd, cmd->sync_cmd, cmd->scmd);
3931 
3932 				list_del_init(&cmd->list);
3933 			}
3934 			defer_index++;
3935 			list_add_tail(&cmd->list,
3936 				&instance->internal_reset_pending_q);
3937 		}
3938 	}
3939 	spin_unlock_irqrestore(&instance->mfi_pool_lock, flags);
3940 }
3941 
3942 
3943 static void
3944 process_fw_state_change_wq(struct work_struct *work)
3945 {
3946 	struct megasas_instance *instance =
3947 		container_of(work, struct megasas_instance, work_init);
3948 	u32 wait;
3949 	unsigned long flags;
3950 
3951 	if (atomic_read(&instance->adprecovery) != MEGASAS_ADPRESET_SM_INFAULT) {
3952 		dev_notice(&instance->pdev->dev, "error, recovery st %x\n",
3953 			   atomic_read(&instance->adprecovery));
3954 		return ;
3955 	}
3956 
3957 	if (atomic_read(&instance->adprecovery) == MEGASAS_ADPRESET_SM_INFAULT) {
3958 		dev_notice(&instance->pdev->dev, "FW detected to be in fault"
3959 					"state, restarting it...\n");
3960 
3961 		instance->instancet->disable_intr(instance);
3962 		atomic_set(&instance->fw_outstanding, 0);
3963 
3964 		atomic_set(&instance->fw_reset_no_pci_access, 1);
3965 		instance->instancet->adp_reset(instance, instance->reg_set);
3966 		atomic_set(&instance->fw_reset_no_pci_access, 0);
3967 
3968 		dev_notice(&instance->pdev->dev, "FW restarted successfully,"
3969 					"initiating next stage...\n");
3970 
3971 		dev_notice(&instance->pdev->dev, "HBA recovery state machine,"
3972 					"state 2 starting...\n");
3973 
3974 		/* waiting for about 20 second before start the second init */
3975 		for (wait = 0; wait < 30; wait++) {
3976 			msleep(1000);
3977 		}
3978 
3979 		if (megasas_transition_to_ready(instance, 1)) {
3980 			dev_notice(&instance->pdev->dev, "adapter not ready\n");
3981 
3982 			atomic_set(&instance->fw_reset_no_pci_access, 1);
3983 			megaraid_sas_kill_hba(instance);
3984 			return ;
3985 		}
3986 
3987 		if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
3988 			(instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
3989 			(instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)
3990 			) {
3991 			*instance->consumer = *instance->producer;
3992 		} else {
3993 			*instance->consumer = 0;
3994 			*instance->producer = 0;
3995 		}
3996 
3997 		megasas_issue_init_mfi(instance);
3998 
3999 		spin_lock_irqsave(&instance->hba_lock, flags);
4000 		atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
4001 		spin_unlock_irqrestore(&instance->hba_lock, flags);
4002 		instance->instancet->enable_intr(instance);
4003 
4004 		megasas_issue_pending_cmds_again(instance);
4005 		instance->issuepend_done = 1;
4006 	}
4007 }
4008 
4009 /**
4010  * megasas_deplete_reply_queue -	Processes all completed commands
4011  * @instance:				Adapter soft state
4012  * @alt_status:				Alternate status to be returned to
4013  *					SCSI mid-layer instead of the status
4014  *					returned by the FW
4015  * Note: this must be called with hba lock held
4016  */
4017 static int
4018 megasas_deplete_reply_queue(struct megasas_instance *instance,
4019 					u8 alt_status)
4020 {
4021 	u32 mfiStatus;
4022 	u32 fw_state;
4023 
4024 	if (instance->instancet->check_reset(instance, instance->reg_set) == 1)
4025 		return IRQ_HANDLED;
4026 
4027 	mfiStatus = instance->instancet->clear_intr(instance);
4028 	if (mfiStatus == 0) {
4029 		/* Hardware may not set outbound_intr_status in MSI-X mode */
4030 		if (!instance->msix_vectors)
4031 			return IRQ_NONE;
4032 	}
4033 
4034 	instance->mfiStatus = mfiStatus;
4035 
4036 	if ((mfiStatus & MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE)) {
4037 		fw_state = instance->instancet->read_fw_status_reg(
4038 				instance) & MFI_STATE_MASK;
4039 
4040 		if (fw_state != MFI_STATE_FAULT) {
4041 			dev_notice(&instance->pdev->dev, "fw state:%x\n",
4042 						fw_state);
4043 		}
4044 
4045 		if ((fw_state == MFI_STATE_FAULT) &&
4046 				(instance->disableOnlineCtrlReset == 0)) {
4047 			dev_notice(&instance->pdev->dev, "wait adp restart\n");
4048 
4049 			if ((instance->pdev->device ==
4050 					PCI_DEVICE_ID_LSI_SAS1064R) ||
4051 				(instance->pdev->device ==
4052 					PCI_DEVICE_ID_DELL_PERC5) ||
4053 				(instance->pdev->device ==
4054 					PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
4055 
4056 				*instance->consumer =
4057 					cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
4058 			}
4059 
4060 
4061 			instance->instancet->disable_intr(instance);
4062 			atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
4063 			instance->issuepend_done = 0;
4064 
4065 			atomic_set(&instance->fw_outstanding, 0);
4066 			megasas_internal_reset_defer_cmds(instance);
4067 
4068 			dev_notice(&instance->pdev->dev, "fwState=%x, stage:%d\n",
4069 					fw_state, atomic_read(&instance->adprecovery));
4070 
4071 			schedule_work(&instance->work_init);
4072 			return IRQ_HANDLED;
4073 
4074 		} else {
4075 			dev_notice(&instance->pdev->dev, "fwstate:%x, dis_OCR=%x\n",
4076 				fw_state, instance->disableOnlineCtrlReset);
4077 		}
4078 	}
4079 
4080 	tasklet_schedule(&instance->isr_tasklet);
4081 	return IRQ_HANDLED;
4082 }
4083 
4084 /**
4085  * megasas_isr - isr entry point
4086  * @irq:	IRQ number
4087  * @devp:	IRQ context address
4088  */
4089 static irqreturn_t megasas_isr(int irq, void *devp)
4090 {
4091 	struct megasas_irq_context *irq_context = devp;
4092 	struct megasas_instance *instance = irq_context->instance;
4093 	unsigned long flags;
4094 	irqreturn_t rc;
4095 
4096 	if (atomic_read(&instance->fw_reset_no_pci_access))
4097 		return IRQ_HANDLED;
4098 
4099 	spin_lock_irqsave(&instance->hba_lock, flags);
4100 	rc = megasas_deplete_reply_queue(instance, DID_OK);
4101 	spin_unlock_irqrestore(&instance->hba_lock, flags);
4102 
4103 	return rc;
4104 }
4105 
4106 /**
4107  * megasas_transition_to_ready -	Move the FW to READY state
4108  * @instance:				Adapter soft state
4109  * @ocr:				Adapter reset state
4110  *
4111  * During the initialization, FW passes can potentially be in any one of
4112  * several possible states. If the FW in operational, waiting-for-handshake
4113  * states, driver must take steps to bring it to ready state. Otherwise, it
4114  * has to wait for the ready state.
4115  */
4116 int
4117 megasas_transition_to_ready(struct megasas_instance *instance, int ocr)
4118 {
4119 	int i;
4120 	u8 max_wait;
4121 	u32 fw_state;
4122 	u32 abs_state, curr_abs_state;
4123 
4124 	abs_state = instance->instancet->read_fw_status_reg(instance);
4125 	fw_state = abs_state & MFI_STATE_MASK;
4126 
4127 	if (fw_state != MFI_STATE_READY)
4128 		dev_info(&instance->pdev->dev, "Waiting for FW to come to ready"
4129 		       " state\n");
4130 
4131 	while (fw_state != MFI_STATE_READY) {
4132 
4133 		switch (fw_state) {
4134 
4135 		case MFI_STATE_FAULT:
4136 			dev_printk(KERN_ERR, &instance->pdev->dev,
4137 				   "FW in FAULT state, Fault code:0x%x subcode:0x%x func:%s\n",
4138 				   abs_state & MFI_STATE_FAULT_CODE,
4139 				   abs_state & MFI_STATE_FAULT_SUBCODE, __func__);
4140 			if (ocr) {
4141 				max_wait = MEGASAS_RESET_WAIT_TIME;
4142 				break;
4143 			} else {
4144 				dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4145 				megasas_dump_reg_set(instance->reg_set);
4146 				return -ENODEV;
4147 			}
4148 
4149 		case MFI_STATE_WAIT_HANDSHAKE:
4150 			/*
4151 			 * Set the CLR bit in inbound doorbell
4152 			 */
4153 			if ((instance->pdev->device ==
4154 				PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
4155 				(instance->pdev->device ==
4156 				 PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
4157 				(instance->adapter_type != MFI_SERIES))
4158 				writel(
4159 				  MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
4160 				  &instance->reg_set->doorbell);
4161 			else
4162 				writel(
4163 				    MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
4164 					&instance->reg_set->inbound_doorbell);
4165 
4166 			max_wait = MEGASAS_RESET_WAIT_TIME;
4167 			break;
4168 
4169 		case MFI_STATE_BOOT_MESSAGE_PENDING:
4170 			if ((instance->pdev->device ==
4171 			     PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
4172 				(instance->pdev->device ==
4173 				 PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
4174 				(instance->adapter_type != MFI_SERIES))
4175 				writel(MFI_INIT_HOTPLUG,
4176 				       &instance->reg_set->doorbell);
4177 			else
4178 				writel(MFI_INIT_HOTPLUG,
4179 					&instance->reg_set->inbound_doorbell);
4180 
4181 			max_wait = MEGASAS_RESET_WAIT_TIME;
4182 			break;
4183 
4184 		case MFI_STATE_OPERATIONAL:
4185 			/*
4186 			 * Bring it to READY state; assuming max wait 10 secs
4187 			 */
4188 			instance->instancet->disable_intr(instance);
4189 			if ((instance->pdev->device ==
4190 				PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
4191 				(instance->pdev->device ==
4192 				PCI_DEVICE_ID_LSI_SAS0071SKINNY)  ||
4193 				(instance->adapter_type != MFI_SERIES)) {
4194 				writel(MFI_RESET_FLAGS,
4195 					&instance->reg_set->doorbell);
4196 
4197 				if (instance->adapter_type != MFI_SERIES) {
4198 					for (i = 0; i < (10 * 1000); i += 20) {
4199 						if (megasas_readl(
4200 							    instance,
4201 							    &instance->
4202 							    reg_set->
4203 							    doorbell) & 1)
4204 							msleep(20);
4205 						else
4206 							break;
4207 					}
4208 				}
4209 			} else
4210 				writel(MFI_RESET_FLAGS,
4211 					&instance->reg_set->inbound_doorbell);
4212 
4213 			max_wait = MEGASAS_RESET_WAIT_TIME;
4214 			break;
4215 
4216 		case MFI_STATE_UNDEFINED:
4217 			/*
4218 			 * This state should not last for more than 2 seconds
4219 			 */
4220 			max_wait = MEGASAS_RESET_WAIT_TIME;
4221 			break;
4222 
4223 		case MFI_STATE_BB_INIT:
4224 			max_wait = MEGASAS_RESET_WAIT_TIME;
4225 			break;
4226 
4227 		case MFI_STATE_FW_INIT:
4228 			max_wait = MEGASAS_RESET_WAIT_TIME;
4229 			break;
4230 
4231 		case MFI_STATE_FW_INIT_2:
4232 			max_wait = MEGASAS_RESET_WAIT_TIME;
4233 			break;
4234 
4235 		case MFI_STATE_DEVICE_SCAN:
4236 			max_wait = MEGASAS_RESET_WAIT_TIME;
4237 			break;
4238 
4239 		case MFI_STATE_FLUSH_CACHE:
4240 			max_wait = MEGASAS_RESET_WAIT_TIME;
4241 			break;
4242 
4243 		default:
4244 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "Unknown state 0x%x\n",
4245 			       fw_state);
4246 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4247 			megasas_dump_reg_set(instance->reg_set);
4248 			return -ENODEV;
4249 		}
4250 
4251 		/*
4252 		 * The cur_state should not last for more than max_wait secs
4253 		 */
4254 		for (i = 0; i < max_wait * 50; i++) {
4255 			curr_abs_state = instance->instancet->
4256 				read_fw_status_reg(instance);
4257 
4258 			if (abs_state == curr_abs_state) {
4259 				msleep(20);
4260 			} else
4261 				break;
4262 		}
4263 
4264 		/*
4265 		 * Return error if fw_state hasn't changed after max_wait
4266 		 */
4267 		if (curr_abs_state == abs_state) {
4268 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "FW state [%d] hasn't changed "
4269 			       "in %d secs\n", fw_state, max_wait);
4270 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4271 			megasas_dump_reg_set(instance->reg_set);
4272 			return -ENODEV;
4273 		}
4274 
4275 		abs_state = curr_abs_state;
4276 		fw_state = curr_abs_state & MFI_STATE_MASK;
4277 	}
4278 	dev_info(&instance->pdev->dev, "FW now in Ready state\n");
4279 
4280 	return 0;
4281 }
4282 
4283 /**
4284  * megasas_teardown_frame_pool -	Destroy the cmd frame DMA pool
4285  * @instance:				Adapter soft state
4286  */
4287 static void megasas_teardown_frame_pool(struct megasas_instance *instance)
4288 {
4289 	int i;
4290 	u16 max_cmd = instance->max_mfi_cmds;
4291 	struct megasas_cmd *cmd;
4292 
4293 	if (!instance->frame_dma_pool)
4294 		return;
4295 
4296 	/*
4297 	 * Return all frames to pool
4298 	 */
4299 	for (i = 0; i < max_cmd; i++) {
4300 
4301 		cmd = instance->cmd_list[i];
4302 
4303 		if (cmd->frame)
4304 			dma_pool_free(instance->frame_dma_pool, cmd->frame,
4305 				      cmd->frame_phys_addr);
4306 
4307 		if (cmd->sense)
4308 			dma_pool_free(instance->sense_dma_pool, cmd->sense,
4309 				      cmd->sense_phys_addr);
4310 	}
4311 
4312 	/*
4313 	 * Now destroy the pool itself
4314 	 */
4315 	dma_pool_destroy(instance->frame_dma_pool);
4316 	dma_pool_destroy(instance->sense_dma_pool);
4317 
4318 	instance->frame_dma_pool = NULL;
4319 	instance->sense_dma_pool = NULL;
4320 }
4321 
4322 /**
4323  * megasas_create_frame_pool -	Creates DMA pool for cmd frames
4324  * @instance:			Adapter soft state
4325  *
4326  * Each command packet has an embedded DMA memory buffer that is used for
4327  * filling MFI frame and the SG list that immediately follows the frame. This
4328  * function creates those DMA memory buffers for each command packet by using
4329  * PCI pool facility.
4330  */
4331 static int megasas_create_frame_pool(struct megasas_instance *instance)
4332 {
4333 	int i;
4334 	u16 max_cmd;
4335 	u32 frame_count;
4336 	struct megasas_cmd *cmd;
4337 
4338 	max_cmd = instance->max_mfi_cmds;
4339 
4340 	/*
4341 	 * For MFI controllers.
4342 	 * max_num_sge = 60
4343 	 * max_sge_sz  = 16 byte (sizeof megasas_sge_skinny)
4344 	 * Total 960 byte (15 MFI frame of 64 byte)
4345 	 *
4346 	 * Fusion adapter require only 3 extra frame.
4347 	 * max_num_sge = 16 (defined as MAX_IOCTL_SGE)
4348 	 * max_sge_sz  = 12 byte (sizeof  megasas_sge64)
4349 	 * Total 192 byte (3 MFI frame of 64 byte)
4350 	 */
4351 	frame_count = (instance->adapter_type == MFI_SERIES) ?
4352 			(15 + 1) : (3 + 1);
4353 	instance->mfi_frame_size = MEGAMFI_FRAME_SIZE * frame_count;
4354 	/*
4355 	 * Use DMA pool facility provided by PCI layer
4356 	 */
4357 	instance->frame_dma_pool = dma_pool_create("megasas frame pool",
4358 					&instance->pdev->dev,
4359 					instance->mfi_frame_size, 256, 0);
4360 
4361 	if (!instance->frame_dma_pool) {
4362 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup frame pool\n");
4363 		return -ENOMEM;
4364 	}
4365 
4366 	instance->sense_dma_pool = dma_pool_create("megasas sense pool",
4367 						   &instance->pdev->dev, 128,
4368 						   4, 0);
4369 
4370 	if (!instance->sense_dma_pool) {
4371 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup sense pool\n");
4372 
4373 		dma_pool_destroy(instance->frame_dma_pool);
4374 		instance->frame_dma_pool = NULL;
4375 
4376 		return -ENOMEM;
4377 	}
4378 
4379 	/*
4380 	 * Allocate and attach a frame to each of the commands in cmd_list.
4381 	 * By making cmd->index as the context instead of the &cmd, we can
4382 	 * always use 32bit context regardless of the architecture
4383 	 */
4384 	for (i = 0; i < max_cmd; i++) {
4385 
4386 		cmd = instance->cmd_list[i];
4387 
4388 		cmd->frame = dma_pool_zalloc(instance->frame_dma_pool,
4389 					    GFP_KERNEL, &cmd->frame_phys_addr);
4390 
4391 		cmd->sense = dma_pool_alloc(instance->sense_dma_pool,
4392 					    GFP_KERNEL, &cmd->sense_phys_addr);
4393 
4394 		/*
4395 		 * megasas_teardown_frame_pool() takes care of freeing
4396 		 * whatever has been allocated
4397 		 */
4398 		if (!cmd->frame || !cmd->sense) {
4399 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "dma_pool_alloc failed\n");
4400 			megasas_teardown_frame_pool(instance);
4401 			return -ENOMEM;
4402 		}
4403 
4404 		cmd->frame->io.context = cpu_to_le32(cmd->index);
4405 		cmd->frame->io.pad_0 = 0;
4406 		if ((instance->adapter_type == MFI_SERIES) && reset_devices)
4407 			cmd->frame->hdr.cmd = MFI_CMD_INVALID;
4408 	}
4409 
4410 	return 0;
4411 }
4412 
4413 /**
4414  * megasas_free_cmds -	Free all the cmds in the free cmd pool
4415  * @instance:		Adapter soft state
4416  */
4417 void megasas_free_cmds(struct megasas_instance *instance)
4418 {
4419 	int i;
4420 
4421 	/* First free the MFI frame pool */
4422 	megasas_teardown_frame_pool(instance);
4423 
4424 	/* Free all the commands in the cmd_list */
4425 	for (i = 0; i < instance->max_mfi_cmds; i++)
4426 
4427 		kfree(instance->cmd_list[i]);
4428 
4429 	/* Free the cmd_list buffer itself */
4430 	kfree(instance->cmd_list);
4431 	instance->cmd_list = NULL;
4432 
4433 	INIT_LIST_HEAD(&instance->cmd_pool);
4434 }
4435 
4436 /**
4437  * megasas_alloc_cmds -	Allocates the command packets
4438  * @instance:		Adapter soft state
4439  *
4440  * Each command that is issued to the FW, whether IO commands from the OS or
4441  * internal commands like IOCTLs, are wrapped in local data structure called
4442  * megasas_cmd. The frame embedded in this megasas_cmd is actually issued to
4443  * the FW.
4444  *
4445  * Each frame has a 32-bit field called context (tag). This context is used
4446  * to get back the megasas_cmd from the frame when a frame gets completed in
4447  * the ISR. Typically the address of the megasas_cmd itself would be used as
4448  * the context. But we wanted to keep the differences between 32 and 64 bit
4449  * systems to the mininum. We always use 32 bit integers for the context. In
4450  * this driver, the 32 bit values are the indices into an array cmd_list.
4451  * This array is used only to look up the megasas_cmd given the context. The
4452  * free commands themselves are maintained in a linked list called cmd_pool.
4453  */
4454 int megasas_alloc_cmds(struct megasas_instance *instance)
4455 {
4456 	int i;
4457 	int j;
4458 	u16 max_cmd;
4459 	struct megasas_cmd *cmd;
4460 
4461 	max_cmd = instance->max_mfi_cmds;
4462 
4463 	/*
4464 	 * instance->cmd_list is an array of struct megasas_cmd pointers.
4465 	 * Allocate the dynamic array first and then allocate individual
4466 	 * commands.
4467 	 */
4468 	instance->cmd_list = kcalloc(max_cmd, sizeof(struct megasas_cmd*), GFP_KERNEL);
4469 
4470 	if (!instance->cmd_list) {
4471 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "out of memory\n");
4472 		return -ENOMEM;
4473 	}
4474 
4475 	for (i = 0; i < max_cmd; i++) {
4476 		instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd),
4477 						GFP_KERNEL);
4478 
4479 		if (!instance->cmd_list[i]) {
4480 
4481 			for (j = 0; j < i; j++)
4482 				kfree(instance->cmd_list[j]);
4483 
4484 			kfree(instance->cmd_list);
4485 			instance->cmd_list = NULL;
4486 
4487 			return -ENOMEM;
4488 		}
4489 	}
4490 
4491 	for (i = 0; i < max_cmd; i++) {
4492 		cmd = instance->cmd_list[i];
4493 		memset(cmd, 0, sizeof(struct megasas_cmd));
4494 		cmd->index = i;
4495 		cmd->scmd = NULL;
4496 		cmd->instance = instance;
4497 
4498 		list_add_tail(&cmd->list, &instance->cmd_pool);
4499 	}
4500 
4501 	/*
4502 	 * Create a frame pool and assign one frame to each cmd
4503 	 */
4504 	if (megasas_create_frame_pool(instance)) {
4505 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Error creating frame DMA pool\n");
4506 		megasas_free_cmds(instance);
4507 		return -ENOMEM;
4508 	}
4509 
4510 	return 0;
4511 }
4512 
4513 /*
4514  * dcmd_timeout_ocr_possible -	Check if OCR is possible based on Driver/FW state.
4515  * @instance:				Adapter soft state
4516  *
4517  * Return 0 for only Fusion adapter, if driver load/unload is not in progress
4518  * or FW is not under OCR.
4519  */
4520 inline int
4521 dcmd_timeout_ocr_possible(struct megasas_instance *instance) {
4522 
4523 	if (instance->adapter_type == MFI_SERIES)
4524 		return KILL_ADAPTER;
4525 	else if (instance->unload ||
4526 			test_bit(MEGASAS_FUSION_OCR_NOT_POSSIBLE,
4527 				 &instance->reset_flags))
4528 		return IGNORE_TIMEOUT;
4529 	else
4530 		return INITIATE_OCR;
4531 }
4532 
4533 static void
4534 megasas_get_pd_info(struct megasas_instance *instance, struct scsi_device *sdev)
4535 {
4536 	int ret;
4537 	struct megasas_cmd *cmd;
4538 	struct megasas_dcmd_frame *dcmd;
4539 
4540 	struct MR_PRIV_DEVICE *mr_device_priv_data;
4541 	u16 device_id = 0;
4542 
4543 	device_id = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) + sdev->id;
4544 	cmd = megasas_get_cmd(instance);
4545 
4546 	if (!cmd) {
4547 		dev_err(&instance->pdev->dev, "Failed to get cmd %s\n", __func__);
4548 		return;
4549 	}
4550 
4551 	dcmd = &cmd->frame->dcmd;
4552 
4553 	memset(instance->pd_info, 0, sizeof(*instance->pd_info));
4554 	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4555 
4556 	dcmd->mbox.s[0] = cpu_to_le16(device_id);
4557 	dcmd->cmd = MFI_CMD_DCMD;
4558 	dcmd->cmd_status = 0xFF;
4559 	dcmd->sge_count = 1;
4560 	dcmd->flags = MFI_FRAME_DIR_READ;
4561 	dcmd->timeout = 0;
4562 	dcmd->pad_0 = 0;
4563 	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_PD_INFO));
4564 	dcmd->opcode = cpu_to_le32(MR_DCMD_PD_GET_INFO);
4565 
4566 	megasas_set_dma_settings(instance, dcmd, instance->pd_info_h,
4567 				 sizeof(struct MR_PD_INFO));
4568 
4569 	if ((instance->adapter_type != MFI_SERIES) &&
4570 	    !instance->mask_interrupts)
4571 		ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
4572 	else
4573 		ret = megasas_issue_polled(instance, cmd);
4574 
4575 	switch (ret) {
4576 	case DCMD_SUCCESS:
4577 		mr_device_priv_data = sdev->hostdata;
4578 		le16_to_cpus((u16 *)&instance->pd_info->state.ddf.pdType);
4579 		mr_device_priv_data->interface_type =
4580 				instance->pd_info->state.ddf.pdType.intf;
4581 		break;
4582 
4583 	case DCMD_TIMEOUT:
4584 
4585 		switch (dcmd_timeout_ocr_possible(instance)) {
4586 		case INITIATE_OCR:
4587 			cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4588 			mutex_unlock(&instance->reset_mutex);
4589 			megasas_reset_fusion(instance->host,
4590 				MFI_IO_TIMEOUT_OCR);
4591 			mutex_lock(&instance->reset_mutex);
4592 			break;
4593 		case KILL_ADAPTER:
4594 			megaraid_sas_kill_hba(instance);
4595 			break;
4596 		case IGNORE_TIMEOUT:
4597 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4598 				__func__, __LINE__);
4599 			break;
4600 		}
4601 
4602 		break;
4603 	}
4604 
4605 	if (ret != DCMD_TIMEOUT)
4606 		megasas_return_cmd(instance, cmd);
4607 
4608 	return;
4609 }
4610 /*
4611  * megasas_get_pd_list_info -	Returns FW's pd_list structure
4612  * @instance:				Adapter soft state
4613  * @pd_list:				pd_list structure
4614  *
4615  * Issues an internal command (DCMD) to get the FW's controller PD
4616  * list structure.  This information is mainly used to find out SYSTEM
4617  * supported by the FW.
4618  */
4619 static int
4620 megasas_get_pd_list(struct megasas_instance *instance)
4621 {
4622 	int ret = 0, pd_index = 0;
4623 	struct megasas_cmd *cmd;
4624 	struct megasas_dcmd_frame *dcmd;
4625 	struct MR_PD_LIST *ci;
4626 	struct MR_PD_ADDRESS *pd_addr;
4627 
4628 	if (instance->pd_list_not_supported) {
4629 		dev_info(&instance->pdev->dev, "MR_DCMD_PD_LIST_QUERY "
4630 		"not supported by firmware\n");
4631 		return ret;
4632 	}
4633 
4634 	ci = instance->pd_list_buf;
4635 
4636 	cmd = megasas_get_cmd(instance);
4637 
4638 	if (!cmd) {
4639 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "(get_pd_list): Failed to get cmd\n");
4640 		return -ENOMEM;
4641 	}
4642 
4643 	dcmd = &cmd->frame->dcmd;
4644 
4645 	memset(ci, 0, sizeof(*ci));
4646 	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4647 
4648 	dcmd->mbox.b[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST;
4649 	dcmd->mbox.b[1] = 0;
4650 	dcmd->cmd = MFI_CMD_DCMD;
4651 	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
4652 	dcmd->sge_count = 1;
4653 	dcmd->flags = MFI_FRAME_DIR_READ;
4654 	dcmd->timeout = 0;
4655 	dcmd->pad_0 = 0;
4656 	dcmd->data_xfer_len = cpu_to_le32(MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST));
4657 	dcmd->opcode = cpu_to_le32(MR_DCMD_PD_LIST_QUERY);
4658 
4659 	megasas_set_dma_settings(instance, dcmd, instance->pd_list_buf_h,
4660 				 (MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST)));
4661 
4662 	if ((instance->adapter_type != MFI_SERIES) &&
4663 	    !instance->mask_interrupts)
4664 		ret = megasas_issue_blocked_cmd(instance, cmd,
4665 			MFI_IO_TIMEOUT_SECS);
4666 	else
4667 		ret = megasas_issue_polled(instance, cmd);
4668 
4669 	switch (ret) {
4670 	case DCMD_FAILED:
4671 		dev_info(&instance->pdev->dev, "MR_DCMD_PD_LIST_QUERY "
4672 			"failed/not supported by firmware\n");
4673 
4674 		if (instance->adapter_type != MFI_SERIES)
4675 			megaraid_sas_kill_hba(instance);
4676 		else
4677 			instance->pd_list_not_supported = 1;
4678 		break;
4679 	case DCMD_TIMEOUT:
4680 
4681 		switch (dcmd_timeout_ocr_possible(instance)) {
4682 		case INITIATE_OCR:
4683 			cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4684 			/*
4685 			 * DCMD failed from AEN path.
4686 			 * AEN path already hold reset_mutex to avoid PCI access
4687 			 * while OCR is in progress.
4688 			 */
4689 			mutex_unlock(&instance->reset_mutex);
4690 			megasas_reset_fusion(instance->host,
4691 						MFI_IO_TIMEOUT_OCR);
4692 			mutex_lock(&instance->reset_mutex);
4693 			break;
4694 		case KILL_ADAPTER:
4695 			megaraid_sas_kill_hba(instance);
4696 			break;
4697 		case IGNORE_TIMEOUT:
4698 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d \n",
4699 				__func__, __LINE__);
4700 			break;
4701 		}
4702 
4703 		break;
4704 
4705 	case DCMD_SUCCESS:
4706 		pd_addr = ci->addr;
4707 		if (megasas_dbg_lvl & LD_PD_DEBUG)
4708 			dev_info(&instance->pdev->dev, "%s, sysPD count: 0x%x\n",
4709 				 __func__, le32_to_cpu(ci->count));
4710 
4711 		if ((le32_to_cpu(ci->count) >
4712 			(MEGASAS_MAX_PD_CHANNELS * MEGASAS_MAX_DEV_PER_CHANNEL)))
4713 			break;
4714 
4715 		memset(instance->local_pd_list, 0,
4716 				MEGASAS_MAX_PD * sizeof(struct megasas_pd_list));
4717 
4718 		for (pd_index = 0; pd_index < le32_to_cpu(ci->count); pd_index++) {
4719 			instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].tid	=
4720 					le16_to_cpu(pd_addr->deviceId);
4721 			instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveType	=
4722 					pd_addr->scsiDevType;
4723 			instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveState	=
4724 					MR_PD_STATE_SYSTEM;
4725 			if (megasas_dbg_lvl & LD_PD_DEBUG)
4726 				dev_info(&instance->pdev->dev,
4727 					 "PD%d: targetID: 0x%03x deviceType:0x%x\n",
4728 					 pd_index, le16_to_cpu(pd_addr->deviceId),
4729 					 pd_addr->scsiDevType);
4730 			pd_addr++;
4731 		}
4732 
4733 		memcpy(instance->pd_list, instance->local_pd_list,
4734 			sizeof(instance->pd_list));
4735 		break;
4736 
4737 	}
4738 
4739 	if (ret != DCMD_TIMEOUT)
4740 		megasas_return_cmd(instance, cmd);
4741 
4742 	return ret;
4743 }
4744 
4745 /*
4746  * megasas_get_ld_list_info -	Returns FW's ld_list structure
4747  * @instance:				Adapter soft state
4748  * @ld_list:				ld_list structure
4749  *
4750  * Issues an internal command (DCMD) to get the FW's controller PD
4751  * list structure.  This information is mainly used to find out SYSTEM
4752  * supported by the FW.
4753  */
4754 static int
4755 megasas_get_ld_list(struct megasas_instance *instance)
4756 {
4757 	int ret = 0, ld_index = 0, ids = 0;
4758 	struct megasas_cmd *cmd;
4759 	struct megasas_dcmd_frame *dcmd;
4760 	struct MR_LD_LIST *ci;
4761 	dma_addr_t ci_h = 0;
4762 	u32 ld_count;
4763 
4764 	ci = instance->ld_list_buf;
4765 	ci_h = instance->ld_list_buf_h;
4766 
4767 	cmd = megasas_get_cmd(instance);
4768 
4769 	if (!cmd) {
4770 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_list: Failed to get cmd\n");
4771 		return -ENOMEM;
4772 	}
4773 
4774 	dcmd = &cmd->frame->dcmd;
4775 
4776 	memset(ci, 0, sizeof(*ci));
4777 	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4778 
4779 	if (instance->supportmax256vd)
4780 		dcmd->mbox.b[0] = 1;
4781 	dcmd->cmd = MFI_CMD_DCMD;
4782 	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
4783 	dcmd->sge_count = 1;
4784 	dcmd->flags = MFI_FRAME_DIR_READ;
4785 	dcmd->timeout = 0;
4786 	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_LIST));
4787 	dcmd->opcode = cpu_to_le32(MR_DCMD_LD_GET_LIST);
4788 	dcmd->pad_0  = 0;
4789 
4790 	megasas_set_dma_settings(instance, dcmd, ci_h,
4791 				 sizeof(struct MR_LD_LIST));
4792 
4793 	if ((instance->adapter_type != MFI_SERIES) &&
4794 	    !instance->mask_interrupts)
4795 		ret = megasas_issue_blocked_cmd(instance, cmd,
4796 			MFI_IO_TIMEOUT_SECS);
4797 	else
4798 		ret = megasas_issue_polled(instance, cmd);
4799 
4800 	ld_count = le32_to_cpu(ci->ldCount);
4801 
4802 	switch (ret) {
4803 	case DCMD_FAILED:
4804 		megaraid_sas_kill_hba(instance);
4805 		break;
4806 	case DCMD_TIMEOUT:
4807 
4808 		switch (dcmd_timeout_ocr_possible(instance)) {
4809 		case INITIATE_OCR:
4810 			cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4811 			/*
4812 			 * DCMD failed from AEN path.
4813 			 * AEN path already hold reset_mutex to avoid PCI access
4814 			 * while OCR is in progress.
4815 			 */
4816 			mutex_unlock(&instance->reset_mutex);
4817 			megasas_reset_fusion(instance->host,
4818 						MFI_IO_TIMEOUT_OCR);
4819 			mutex_lock(&instance->reset_mutex);
4820 			break;
4821 		case KILL_ADAPTER:
4822 			megaraid_sas_kill_hba(instance);
4823 			break;
4824 		case IGNORE_TIMEOUT:
4825 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4826 				__func__, __LINE__);
4827 			break;
4828 		}
4829 
4830 		break;
4831 
4832 	case DCMD_SUCCESS:
4833 		if (megasas_dbg_lvl & LD_PD_DEBUG)
4834 			dev_info(&instance->pdev->dev, "%s, LD count: 0x%x\n",
4835 				 __func__, ld_count);
4836 
4837 		if (ld_count > instance->fw_supported_vd_count)
4838 			break;
4839 
4840 		memset(instance->ld_ids, 0xff, MAX_LOGICAL_DRIVES_EXT);
4841 
4842 		for (ld_index = 0; ld_index < ld_count; ld_index++) {
4843 			if (ci->ldList[ld_index].state != 0) {
4844 				ids = ci->ldList[ld_index].ref.targetId;
4845 				instance->ld_ids[ids] = ci->ldList[ld_index].ref.targetId;
4846 				if (megasas_dbg_lvl & LD_PD_DEBUG)
4847 					dev_info(&instance->pdev->dev,
4848 						 "LD%d: targetID: 0x%03x\n",
4849 						 ld_index, ids);
4850 			}
4851 		}
4852 
4853 		break;
4854 	}
4855 
4856 	if (ret != DCMD_TIMEOUT)
4857 		megasas_return_cmd(instance, cmd);
4858 
4859 	return ret;
4860 }
4861 
4862 /**
4863  * megasas_ld_list_query -	Returns FW's ld_list structure
4864  * @instance:				Adapter soft state
4865  * @query_type:				ld_list structure type
4866  *
4867  * Issues an internal command (DCMD) to get the FW's controller PD
4868  * list structure.  This information is mainly used to find out SYSTEM
4869  * supported by the FW.
4870  */
4871 static int
4872 megasas_ld_list_query(struct megasas_instance *instance, u8 query_type)
4873 {
4874 	int ret = 0, ld_index = 0, ids = 0;
4875 	struct megasas_cmd *cmd;
4876 	struct megasas_dcmd_frame *dcmd;
4877 	struct MR_LD_TARGETID_LIST *ci;
4878 	dma_addr_t ci_h = 0;
4879 	u32 tgtid_count;
4880 
4881 	ci = instance->ld_targetid_list_buf;
4882 	ci_h = instance->ld_targetid_list_buf_h;
4883 
4884 	cmd = megasas_get_cmd(instance);
4885 
4886 	if (!cmd) {
4887 		dev_warn(&instance->pdev->dev,
4888 		         "megasas_ld_list_query: Failed to get cmd\n");
4889 		return -ENOMEM;
4890 	}
4891 
4892 	dcmd = &cmd->frame->dcmd;
4893 
4894 	memset(ci, 0, sizeof(*ci));
4895 	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4896 
4897 	dcmd->mbox.b[0] = query_type;
4898 	if (instance->supportmax256vd)
4899 		dcmd->mbox.b[2] = 1;
4900 
4901 	dcmd->cmd = MFI_CMD_DCMD;
4902 	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
4903 	dcmd->sge_count = 1;
4904 	dcmd->flags = MFI_FRAME_DIR_READ;
4905 	dcmd->timeout = 0;
4906 	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_TARGETID_LIST));
4907 	dcmd->opcode = cpu_to_le32(MR_DCMD_LD_LIST_QUERY);
4908 	dcmd->pad_0  = 0;
4909 
4910 	megasas_set_dma_settings(instance, dcmd, ci_h,
4911 				 sizeof(struct MR_LD_TARGETID_LIST));
4912 
4913 	if ((instance->adapter_type != MFI_SERIES) &&
4914 	    !instance->mask_interrupts)
4915 		ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
4916 	else
4917 		ret = megasas_issue_polled(instance, cmd);
4918 
4919 	switch (ret) {
4920 	case DCMD_FAILED:
4921 		dev_info(&instance->pdev->dev,
4922 			"DCMD not supported by firmware - %s %d\n",
4923 				__func__, __LINE__);
4924 		ret = megasas_get_ld_list(instance);
4925 		break;
4926 	case DCMD_TIMEOUT:
4927 		switch (dcmd_timeout_ocr_possible(instance)) {
4928 		case INITIATE_OCR:
4929 			cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4930 			/*
4931 			 * DCMD failed from AEN path.
4932 			 * AEN path already hold reset_mutex to avoid PCI access
4933 			 * while OCR is in progress.
4934 			 */
4935 			mutex_unlock(&instance->reset_mutex);
4936 			megasas_reset_fusion(instance->host,
4937 						MFI_IO_TIMEOUT_OCR);
4938 			mutex_lock(&instance->reset_mutex);
4939 			break;
4940 		case KILL_ADAPTER:
4941 			megaraid_sas_kill_hba(instance);
4942 			break;
4943 		case IGNORE_TIMEOUT:
4944 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4945 				__func__, __LINE__);
4946 			break;
4947 		}
4948 
4949 		break;
4950 	case DCMD_SUCCESS:
4951 		tgtid_count = le32_to_cpu(ci->count);
4952 
4953 		if (megasas_dbg_lvl & LD_PD_DEBUG)
4954 			dev_info(&instance->pdev->dev, "%s, LD count: 0x%x\n",
4955 				 __func__, tgtid_count);
4956 
4957 		if ((tgtid_count > (instance->fw_supported_vd_count)))
4958 			break;
4959 
4960 		memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
4961 		for (ld_index = 0; ld_index < tgtid_count; ld_index++) {
4962 			ids = ci->targetId[ld_index];
4963 			instance->ld_ids[ids] = ci->targetId[ld_index];
4964 			if (megasas_dbg_lvl & LD_PD_DEBUG)
4965 				dev_info(&instance->pdev->dev, "LD%d: targetID: 0x%03x\n",
4966 					 ld_index, ci->targetId[ld_index]);
4967 		}
4968 
4969 		break;
4970 	}
4971 
4972 	if (ret != DCMD_TIMEOUT)
4973 		megasas_return_cmd(instance, cmd);
4974 
4975 	return ret;
4976 }
4977 
4978 /**
4979  * megasas_host_device_list_query
4980  * dcmd.opcode            - MR_DCMD_CTRL_DEVICE_LIST_GET
4981  * dcmd.mbox              - reserved
4982  * dcmd.sge IN            - ptr to return MR_HOST_DEVICE_LIST structure
4983  * Desc:    This DCMD will return the combined device list
4984  * Status:  MFI_STAT_OK - List returned successfully
4985  *          MFI_STAT_INVALID_CMD - Firmware support for the feature has been
4986  *                                 disabled
4987  * @instance:			Adapter soft state
4988  * @is_probe:			Driver probe check
4989  * Return:			0 if DCMD succeeded
4990  *				 non-zero if failed
4991  */
4992 static int
4993 megasas_host_device_list_query(struct megasas_instance *instance,
4994 			       bool is_probe)
4995 {
4996 	int ret, i, target_id;
4997 	struct megasas_cmd *cmd;
4998 	struct megasas_dcmd_frame *dcmd;
4999 	struct MR_HOST_DEVICE_LIST *ci;
5000 	u32 count;
5001 	dma_addr_t ci_h;
5002 
5003 	ci = instance->host_device_list_buf;
5004 	ci_h = instance->host_device_list_buf_h;
5005 
5006 	cmd = megasas_get_cmd(instance);
5007 
5008 	if (!cmd) {
5009 		dev_warn(&instance->pdev->dev,
5010 			 "%s: failed to get cmd\n",
5011 			 __func__);
5012 		return -ENOMEM;
5013 	}
5014 
5015 	dcmd = &cmd->frame->dcmd;
5016 
5017 	memset(ci, 0, sizeof(*ci));
5018 	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5019 
5020 	dcmd->mbox.b[0] = is_probe ? 0 : 1;
5021 	dcmd->cmd = MFI_CMD_DCMD;
5022 	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
5023 	dcmd->sge_count = 1;
5024 	dcmd->flags = MFI_FRAME_DIR_READ;
5025 	dcmd->timeout = 0;
5026 	dcmd->pad_0 = 0;
5027 	dcmd->data_xfer_len = cpu_to_le32(HOST_DEVICE_LIST_SZ);
5028 	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_DEVICE_LIST_GET);
5029 
5030 	megasas_set_dma_settings(instance, dcmd, ci_h, HOST_DEVICE_LIST_SZ);
5031 
5032 	if (!instance->mask_interrupts) {
5033 		ret = megasas_issue_blocked_cmd(instance, cmd,
5034 						MFI_IO_TIMEOUT_SECS);
5035 	} else {
5036 		ret = megasas_issue_polled(instance, cmd);
5037 		cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5038 	}
5039 
5040 	switch (ret) {
5041 	case DCMD_SUCCESS:
5042 		/* Fill the internal pd_list and ld_ids array based on
5043 		 * targetIds returned by FW
5044 		 */
5045 		count = le32_to_cpu(ci->count);
5046 
5047 		if (count > (MEGASAS_MAX_PD + MAX_LOGICAL_DRIVES_EXT))
5048 			break;
5049 
5050 		if (megasas_dbg_lvl & LD_PD_DEBUG)
5051 			dev_info(&instance->pdev->dev, "%s, Device count: 0x%x\n",
5052 				 __func__, count);
5053 
5054 		memset(instance->local_pd_list, 0,
5055 		       MEGASAS_MAX_PD * sizeof(struct megasas_pd_list));
5056 		memset(instance->ld_ids, 0xff, MAX_LOGICAL_DRIVES_EXT);
5057 		for (i = 0; i < count; i++) {
5058 			target_id = le16_to_cpu(ci->host_device_list[i].target_id);
5059 			if (ci->host_device_list[i].flags.u.bits.is_sys_pd) {
5060 				instance->local_pd_list[target_id].tid = target_id;
5061 				instance->local_pd_list[target_id].driveType =
5062 						ci->host_device_list[i].scsi_type;
5063 				instance->local_pd_list[target_id].driveState =
5064 						MR_PD_STATE_SYSTEM;
5065 				if (megasas_dbg_lvl & LD_PD_DEBUG)
5066 					dev_info(&instance->pdev->dev,
5067 						 "Device %d: PD targetID: 0x%03x deviceType:0x%x\n",
5068 						 i, target_id, ci->host_device_list[i].scsi_type);
5069 			} else {
5070 				instance->ld_ids[target_id] = target_id;
5071 				if (megasas_dbg_lvl & LD_PD_DEBUG)
5072 					dev_info(&instance->pdev->dev,
5073 						 "Device %d: LD targetID: 0x%03x\n",
5074 						 i, target_id);
5075 			}
5076 		}
5077 
5078 		memcpy(instance->pd_list, instance->local_pd_list,
5079 		       sizeof(instance->pd_list));
5080 		break;
5081 
5082 	case DCMD_TIMEOUT:
5083 		switch (dcmd_timeout_ocr_possible(instance)) {
5084 		case INITIATE_OCR:
5085 			cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5086 			mutex_unlock(&instance->reset_mutex);
5087 			megasas_reset_fusion(instance->host,
5088 				MFI_IO_TIMEOUT_OCR);
5089 			mutex_lock(&instance->reset_mutex);
5090 			break;
5091 		case KILL_ADAPTER:
5092 			megaraid_sas_kill_hba(instance);
5093 			break;
5094 		case IGNORE_TIMEOUT:
5095 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5096 				 __func__, __LINE__);
5097 			break;
5098 		}
5099 		break;
5100 	case DCMD_FAILED:
5101 		dev_err(&instance->pdev->dev,
5102 			"%s: MR_DCMD_CTRL_DEVICE_LIST_GET failed\n",
5103 			__func__);
5104 		break;
5105 	}
5106 
5107 	if (ret != DCMD_TIMEOUT)
5108 		megasas_return_cmd(instance, cmd);
5109 
5110 	return ret;
5111 }
5112 
5113 /*
5114  * megasas_update_ext_vd_details : Update details w.r.t Extended VD
5115  * instance			 : Controller's instance
5116 */
5117 static void megasas_update_ext_vd_details(struct megasas_instance *instance)
5118 {
5119 	struct fusion_context *fusion;
5120 	u32 ventura_map_sz = 0;
5121 
5122 	fusion = instance->ctrl_context;
5123 	/* For MFI based controllers return dummy success */
5124 	if (!fusion)
5125 		return;
5126 
5127 	instance->supportmax256vd =
5128 		instance->ctrl_info_buf->adapterOperations3.supportMaxExtLDs;
5129 	/* Below is additional check to address future FW enhancement */
5130 	if (instance->ctrl_info_buf->max_lds > 64)
5131 		instance->supportmax256vd = 1;
5132 
5133 	instance->drv_supported_vd_count = MEGASAS_MAX_LD_CHANNELS
5134 					* MEGASAS_MAX_DEV_PER_CHANNEL;
5135 	instance->drv_supported_pd_count = MEGASAS_MAX_PD_CHANNELS
5136 					* MEGASAS_MAX_DEV_PER_CHANNEL;
5137 	if (instance->supportmax256vd) {
5138 		instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES_EXT;
5139 		instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
5140 	} else {
5141 		instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
5142 		instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
5143 	}
5144 
5145 	dev_info(&instance->pdev->dev,
5146 		"FW provided supportMaxExtLDs: %d\tmax_lds: %d\n",
5147 		instance->ctrl_info_buf->adapterOperations3.supportMaxExtLDs ? 1 : 0,
5148 		instance->ctrl_info_buf->max_lds);
5149 
5150 	if (instance->max_raid_mapsize) {
5151 		ventura_map_sz = instance->max_raid_mapsize *
5152 						MR_MIN_MAP_SIZE; /* 64k */
5153 		fusion->current_map_sz = ventura_map_sz;
5154 		fusion->max_map_sz = ventura_map_sz;
5155 	} else {
5156 		fusion->old_map_sz =
5157 			struct_size((struct MR_FW_RAID_MAP *)0, ldSpanMap,
5158 				    instance->fw_supported_vd_count);
5159 		fusion->new_map_sz =  sizeof(struct MR_FW_RAID_MAP_EXT);
5160 
5161 		fusion->max_map_sz =
5162 			max(fusion->old_map_sz, fusion->new_map_sz);
5163 
5164 		if (instance->supportmax256vd)
5165 			fusion->current_map_sz = fusion->new_map_sz;
5166 		else
5167 			fusion->current_map_sz = fusion->old_map_sz;
5168 	}
5169 	/* irrespective of FW raid maps, driver raid map is constant */
5170 	fusion->drv_map_sz = sizeof(struct MR_DRV_RAID_MAP_ALL);
5171 }
5172 
5173 /*
5174  * dcmd.opcode                - MR_DCMD_CTRL_SNAPDUMP_GET_PROPERTIES
5175  * dcmd.hdr.length            - number of bytes to read
5176  * dcmd.sge                   - Ptr to MR_SNAPDUMP_PROPERTIES
5177  * Desc:			 Fill in snapdump properties
5178  * Status:			 MFI_STAT_OK- Command successful
5179  */
5180 void megasas_get_snapdump_properties(struct megasas_instance *instance)
5181 {
5182 	int ret = 0;
5183 	struct megasas_cmd *cmd;
5184 	struct megasas_dcmd_frame *dcmd;
5185 	struct MR_SNAPDUMP_PROPERTIES *ci;
5186 	dma_addr_t ci_h = 0;
5187 
5188 	ci = instance->snapdump_prop;
5189 	ci_h = instance->snapdump_prop_h;
5190 
5191 	if (!ci)
5192 		return;
5193 
5194 	cmd = megasas_get_cmd(instance);
5195 
5196 	if (!cmd) {
5197 		dev_dbg(&instance->pdev->dev, "Failed to get a free cmd\n");
5198 		return;
5199 	}
5200 
5201 	dcmd = &cmd->frame->dcmd;
5202 
5203 	memset(ci, 0, sizeof(*ci));
5204 	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5205 
5206 	dcmd->cmd = MFI_CMD_DCMD;
5207 	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
5208 	dcmd->sge_count = 1;
5209 	dcmd->flags = MFI_FRAME_DIR_READ;
5210 	dcmd->timeout = 0;
5211 	dcmd->pad_0 = 0;
5212 	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_SNAPDUMP_PROPERTIES));
5213 	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_SNAPDUMP_GET_PROPERTIES);
5214 
5215 	megasas_set_dma_settings(instance, dcmd, ci_h,
5216 				 sizeof(struct MR_SNAPDUMP_PROPERTIES));
5217 
5218 	if (!instance->mask_interrupts) {
5219 		ret = megasas_issue_blocked_cmd(instance, cmd,
5220 						MFI_IO_TIMEOUT_SECS);
5221 	} else {
5222 		ret = megasas_issue_polled(instance, cmd);
5223 		cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5224 	}
5225 
5226 	switch (ret) {
5227 	case DCMD_SUCCESS:
5228 		instance->snapdump_wait_time =
5229 			min_t(u8, ci->trigger_min_num_sec_before_ocr,
5230 				MEGASAS_MAX_SNAP_DUMP_WAIT_TIME);
5231 		break;
5232 
5233 	case DCMD_TIMEOUT:
5234 		switch (dcmd_timeout_ocr_possible(instance)) {
5235 		case INITIATE_OCR:
5236 			cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5237 			mutex_unlock(&instance->reset_mutex);
5238 			megasas_reset_fusion(instance->host,
5239 				MFI_IO_TIMEOUT_OCR);
5240 			mutex_lock(&instance->reset_mutex);
5241 			break;
5242 		case KILL_ADAPTER:
5243 			megaraid_sas_kill_hba(instance);
5244 			break;
5245 		case IGNORE_TIMEOUT:
5246 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5247 				__func__, __LINE__);
5248 			break;
5249 		}
5250 	}
5251 
5252 	if (ret != DCMD_TIMEOUT)
5253 		megasas_return_cmd(instance, cmd);
5254 }
5255 
5256 /**
5257  * megasas_get_ctrl_info -	Returns FW's controller structure
5258  * @instance:				Adapter soft state
5259  *
5260  * Issues an internal command (DCMD) to get the FW's controller structure.
5261  * This information is mainly used to find out the maximum IO transfer per
5262  * command supported by the FW.
5263  */
5264 int
5265 megasas_get_ctrl_info(struct megasas_instance *instance)
5266 {
5267 	int ret = 0;
5268 	struct megasas_cmd *cmd;
5269 	struct megasas_dcmd_frame *dcmd;
5270 	struct megasas_ctrl_info *ci;
5271 	dma_addr_t ci_h = 0;
5272 
5273 	ci = instance->ctrl_info_buf;
5274 	ci_h = instance->ctrl_info_buf_h;
5275 
5276 	cmd = megasas_get_cmd(instance);
5277 
5278 	if (!cmd) {
5279 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get a free cmd\n");
5280 		return -ENOMEM;
5281 	}
5282 
5283 	dcmd = &cmd->frame->dcmd;
5284 
5285 	memset(ci, 0, sizeof(*ci));
5286 	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5287 
5288 	dcmd->cmd = MFI_CMD_DCMD;
5289 	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
5290 	dcmd->sge_count = 1;
5291 	dcmd->flags = MFI_FRAME_DIR_READ;
5292 	dcmd->timeout = 0;
5293 	dcmd->pad_0 = 0;
5294 	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_ctrl_info));
5295 	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_GET_INFO);
5296 	dcmd->mbox.b[0] = 1;
5297 
5298 	megasas_set_dma_settings(instance, dcmd, ci_h,
5299 				 sizeof(struct megasas_ctrl_info));
5300 
5301 	if ((instance->adapter_type != MFI_SERIES) &&
5302 	    !instance->mask_interrupts) {
5303 		ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
5304 	} else {
5305 		ret = megasas_issue_polled(instance, cmd);
5306 		cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5307 	}
5308 
5309 	switch (ret) {
5310 	case DCMD_SUCCESS:
5311 		/* Save required controller information in
5312 		 * CPU endianness format.
5313 		 */
5314 		le32_to_cpus((u32 *)&ci->properties.OnOffProperties);
5315 		le16_to_cpus((u16 *)&ci->properties.on_off_properties2);
5316 		le32_to_cpus((u32 *)&ci->adapterOperations2);
5317 		le32_to_cpus((u32 *)&ci->adapterOperations3);
5318 		le16_to_cpus((u16 *)&ci->adapter_operations4);
5319 		le32_to_cpus((u32 *)&ci->adapter_operations5);
5320 
5321 		/* Update the latest Ext VD info.
5322 		 * From Init path, store current firmware details.
5323 		 * From OCR path, detect any firmware properties changes.
5324 		 * in case of Firmware upgrade without system reboot.
5325 		 */
5326 		megasas_update_ext_vd_details(instance);
5327 		instance->support_seqnum_jbod_fp =
5328 			ci->adapterOperations3.useSeqNumJbodFP;
5329 		instance->support_morethan256jbod =
5330 			ci->adapter_operations4.support_pd_map_target_id;
5331 		instance->support_nvme_passthru =
5332 			ci->adapter_operations4.support_nvme_passthru;
5333 		instance->support_pci_lane_margining =
5334 			ci->adapter_operations5.support_pci_lane_margining;
5335 		instance->task_abort_tmo = ci->TaskAbortTO;
5336 		instance->max_reset_tmo = ci->MaxResetTO;
5337 
5338 		/*Check whether controller is iMR or MR */
5339 		instance->is_imr = (ci->memory_size ? 0 : 1);
5340 
5341 		instance->snapdump_wait_time =
5342 			(ci->properties.on_off_properties2.enable_snap_dump ?
5343 			 MEGASAS_DEFAULT_SNAP_DUMP_WAIT_TIME : 0);
5344 
5345 		instance->enable_fw_dev_list =
5346 			ci->properties.on_off_properties2.enable_fw_dev_list;
5347 
5348 		dev_info(&instance->pdev->dev,
5349 			"controller type\t: %s(%dMB)\n",
5350 			instance->is_imr ? "iMR" : "MR",
5351 			le16_to_cpu(ci->memory_size));
5352 
5353 		instance->disableOnlineCtrlReset =
5354 			ci->properties.OnOffProperties.disableOnlineCtrlReset;
5355 		instance->secure_jbod_support =
5356 			ci->adapterOperations3.supportSecurityonJBOD;
5357 		dev_info(&instance->pdev->dev, "Online Controller Reset(OCR)\t: %s\n",
5358 			instance->disableOnlineCtrlReset ? "Disabled" : "Enabled");
5359 		dev_info(&instance->pdev->dev, "Secure JBOD support\t: %s\n",
5360 			instance->secure_jbod_support ? "Yes" : "No");
5361 		dev_info(&instance->pdev->dev, "NVMe passthru support\t: %s\n",
5362 			 instance->support_nvme_passthru ? "Yes" : "No");
5363 		dev_info(&instance->pdev->dev,
5364 			 "FW provided TM TaskAbort/Reset timeout\t: %d secs/%d secs\n",
5365 			 instance->task_abort_tmo, instance->max_reset_tmo);
5366 		dev_info(&instance->pdev->dev, "JBOD sequence map support\t: %s\n",
5367 			 instance->support_seqnum_jbod_fp ? "Yes" : "No");
5368 		dev_info(&instance->pdev->dev, "PCI Lane Margining support\t: %s\n",
5369 			 instance->support_pci_lane_margining ? "Yes" : "No");
5370 
5371 		break;
5372 
5373 	case DCMD_TIMEOUT:
5374 		switch (dcmd_timeout_ocr_possible(instance)) {
5375 		case INITIATE_OCR:
5376 			cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5377 			mutex_unlock(&instance->reset_mutex);
5378 			megasas_reset_fusion(instance->host,
5379 				MFI_IO_TIMEOUT_OCR);
5380 			mutex_lock(&instance->reset_mutex);
5381 			break;
5382 		case KILL_ADAPTER:
5383 			megaraid_sas_kill_hba(instance);
5384 			break;
5385 		case IGNORE_TIMEOUT:
5386 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5387 				__func__, __LINE__);
5388 			break;
5389 		}
5390 		break;
5391 	case DCMD_FAILED:
5392 		megaraid_sas_kill_hba(instance);
5393 		break;
5394 
5395 	}
5396 
5397 	if (ret != DCMD_TIMEOUT)
5398 		megasas_return_cmd(instance, cmd);
5399 
5400 	return ret;
5401 }
5402 
5403 /*
5404  * megasas_set_crash_dump_params -	Sends address of crash dump DMA buffer
5405  *					to firmware
5406  *
5407  * @instance:				Adapter soft state
5408  * @crash_buf_state		-	tell FW to turn ON/OFF crash dump feature
5409 					MR_CRASH_BUF_TURN_OFF = 0
5410 					MR_CRASH_BUF_TURN_ON = 1
5411  * @return 0 on success non-zero on failure.
5412  * Issues an internal command (DCMD) to set parameters for crash dump feature.
5413  * Driver will send address of crash dump DMA buffer and set mbox to tell FW
5414  * that driver supports crash dump feature. This DCMD will be sent only if
5415  * crash dump feature is supported by the FW.
5416  *
5417  */
5418 int megasas_set_crash_dump_params(struct megasas_instance *instance,
5419 	u8 crash_buf_state)
5420 {
5421 	int ret = 0;
5422 	struct megasas_cmd *cmd;
5423 	struct megasas_dcmd_frame *dcmd;
5424 
5425 	cmd = megasas_get_cmd(instance);
5426 
5427 	if (!cmd) {
5428 		dev_err(&instance->pdev->dev, "Failed to get a free cmd\n");
5429 		return -ENOMEM;
5430 	}
5431 
5432 
5433 	dcmd = &cmd->frame->dcmd;
5434 
5435 	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5436 	dcmd->mbox.b[0] = crash_buf_state;
5437 	dcmd->cmd = MFI_CMD_DCMD;
5438 	dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
5439 	dcmd->sge_count = 1;
5440 	dcmd->flags = MFI_FRAME_DIR_NONE;
5441 	dcmd->timeout = 0;
5442 	dcmd->pad_0 = 0;
5443 	dcmd->data_xfer_len = cpu_to_le32(CRASH_DMA_BUF_SIZE);
5444 	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_SET_CRASH_DUMP_PARAMS);
5445 
5446 	megasas_set_dma_settings(instance, dcmd, instance->crash_dump_h,
5447 				 CRASH_DMA_BUF_SIZE);
5448 
5449 	if ((instance->adapter_type != MFI_SERIES) &&
5450 	    !instance->mask_interrupts)
5451 		ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
5452 	else
5453 		ret = megasas_issue_polled(instance, cmd);
5454 
5455 	if (ret == DCMD_TIMEOUT) {
5456 		switch (dcmd_timeout_ocr_possible(instance)) {
5457 		case INITIATE_OCR:
5458 			cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5459 			megasas_reset_fusion(instance->host,
5460 					MFI_IO_TIMEOUT_OCR);
5461 			break;
5462 		case KILL_ADAPTER:
5463 			megaraid_sas_kill_hba(instance);
5464 			break;
5465 		case IGNORE_TIMEOUT:
5466 			dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5467 				__func__, __LINE__);
5468 			break;
5469 		}
5470 	} else
5471 		megasas_return_cmd(instance, cmd);
5472 
5473 	return ret;
5474 }
5475 
5476 /**
5477  * megasas_issue_init_mfi -	Initializes the FW
5478  * @instance:		Adapter soft state
5479  *
5480  * Issues the INIT MFI cmd
5481  */
5482 static int
5483 megasas_issue_init_mfi(struct megasas_instance *instance)
5484 {
5485 	__le32 context;
5486 	struct megasas_cmd *cmd;
5487 	struct megasas_init_frame *init_frame;
5488 	struct megasas_init_queue_info *initq_info;
5489 	dma_addr_t init_frame_h;
5490 	dma_addr_t initq_info_h;
5491 
5492 	/*
5493 	 * Prepare a init frame. Note the init frame points to queue info
5494 	 * structure. Each frame has SGL allocated after first 64 bytes. For
5495 	 * this frame - since we don't need any SGL - we use SGL's space as
5496 	 * queue info structure
5497 	 *
5498 	 * We will not get a NULL command below. We just created the pool.
5499 	 */
5500 	cmd = megasas_get_cmd(instance);
5501 
5502 	init_frame = (struct megasas_init_frame *)cmd->frame;
5503 	initq_info = (struct megasas_init_queue_info *)
5504 		((unsigned long)init_frame + 64);
5505 
5506 	init_frame_h = cmd->frame_phys_addr;
5507 	initq_info_h = init_frame_h + 64;
5508 
5509 	context = init_frame->context;
5510 	memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
5511 	memset(initq_info, 0, sizeof(struct megasas_init_queue_info));
5512 	init_frame->context = context;
5513 
5514 	initq_info->reply_queue_entries = cpu_to_le32(instance->max_fw_cmds + 1);
5515 	initq_info->reply_queue_start_phys_addr_lo = cpu_to_le32(instance->reply_queue_h);
5516 
5517 	initq_info->producer_index_phys_addr_lo = cpu_to_le32(instance->producer_h);
5518 	initq_info->consumer_index_phys_addr_lo = cpu_to_le32(instance->consumer_h);
5519 
5520 	init_frame->cmd = MFI_CMD_INIT;
5521 	init_frame->cmd_status = MFI_STAT_INVALID_STATUS;
5522 	init_frame->queue_info_new_phys_addr_lo =
5523 		cpu_to_le32(lower_32_bits(initq_info_h));
5524 	init_frame->queue_info_new_phys_addr_hi =
5525 		cpu_to_le32(upper_32_bits(initq_info_h));
5526 
5527 	init_frame->data_xfer_len = cpu_to_le32(sizeof(struct megasas_init_queue_info));
5528 
5529 	/*
5530 	 * disable the intr before firing the init frame to FW
5531 	 */
5532 	instance->instancet->disable_intr(instance);
5533 
5534 	/*
5535 	 * Issue the init frame in polled mode
5536 	 */
5537 
5538 	if (megasas_issue_polled(instance, cmd)) {
5539 		dev_err(&instance->pdev->dev, "Failed to init firmware\n");
5540 		megasas_return_cmd(instance, cmd);
5541 		goto fail_fw_init;
5542 	}
5543 
5544 	megasas_return_cmd(instance, cmd);
5545 
5546 	return 0;
5547 
5548 fail_fw_init:
5549 	return -EINVAL;
5550 }
5551 
5552 static u32
5553 megasas_init_adapter_mfi(struct megasas_instance *instance)
5554 {
5555 	u32 context_sz;
5556 	u32 reply_q_sz;
5557 
5558 	/*
5559 	 * Get various operational parameters from status register
5560 	 */
5561 	instance->max_fw_cmds = instance->instancet->read_fw_status_reg(instance) & 0x00FFFF;
5562 	/*
5563 	 * Reduce the max supported cmds by 1. This is to ensure that the
5564 	 * reply_q_sz (1 more than the max cmd that driver may send)
5565 	 * does not exceed max cmds that the FW can support
5566 	 */
5567 	instance->max_fw_cmds = instance->max_fw_cmds-1;
5568 	instance->max_mfi_cmds = instance->max_fw_cmds;
5569 	instance->max_num_sge = (instance->instancet->read_fw_status_reg(instance) & 0xFF0000) >>
5570 					0x10;
5571 	/*
5572 	 * For MFI skinny adapters, MEGASAS_SKINNY_INT_CMDS commands
5573 	 * are reserved for IOCTL + driver's internal DCMDs.
5574 	 */
5575 	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
5576 		(instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
5577 		instance->max_scsi_cmds = (instance->max_fw_cmds -
5578 			MEGASAS_SKINNY_INT_CMDS);
5579 		sema_init(&instance->ioctl_sem, MEGASAS_SKINNY_INT_CMDS);
5580 	} else {
5581 		instance->max_scsi_cmds = (instance->max_fw_cmds -
5582 			MEGASAS_INT_CMDS);
5583 		sema_init(&instance->ioctl_sem, (MEGASAS_MFI_IOCTL_CMDS));
5584 	}
5585 
5586 	instance->cur_can_queue = instance->max_scsi_cmds;
5587 	/*
5588 	 * Create a pool of commands
5589 	 */
5590 	if (megasas_alloc_cmds(instance))
5591 		goto fail_alloc_cmds;
5592 
5593 	/*
5594 	 * Allocate memory for reply queue. Length of reply queue should
5595 	 * be _one_ more than the maximum commands handled by the firmware.
5596 	 *
5597 	 * Note: When FW completes commands, it places corresponding contex
5598 	 * values in this circular reply queue. This circular queue is a fairly
5599 	 * typical producer-consumer queue. FW is the producer (of completed
5600 	 * commands) and the driver is the consumer.
5601 	 */
5602 	context_sz = sizeof(u32);
5603 	reply_q_sz = context_sz * (instance->max_fw_cmds + 1);
5604 
5605 	instance->reply_queue = dma_alloc_coherent(&instance->pdev->dev,
5606 			reply_q_sz, &instance->reply_queue_h, GFP_KERNEL);
5607 
5608 	if (!instance->reply_queue) {
5609 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Out of DMA mem for reply queue\n");
5610 		goto fail_reply_queue;
5611 	}
5612 
5613 	if (megasas_issue_init_mfi(instance))
5614 		goto fail_fw_init;
5615 
5616 	if (megasas_get_ctrl_info(instance)) {
5617 		dev_err(&instance->pdev->dev, "(%d): Could get controller info "
5618 			"Fail from %s %d\n", instance->unique_id,
5619 			__func__, __LINE__);
5620 		goto fail_fw_init;
5621 	}
5622 
5623 	instance->fw_support_ieee = 0;
5624 	instance->fw_support_ieee =
5625 		(instance->instancet->read_fw_status_reg(instance) &
5626 		0x04000000);
5627 
5628 	dev_notice(&instance->pdev->dev, "megasas_init_mfi: fw_support_ieee=%d",
5629 			instance->fw_support_ieee);
5630 
5631 	if (instance->fw_support_ieee)
5632 		instance->flag_ieee = 1;
5633 
5634 	return 0;
5635 
5636 fail_fw_init:
5637 
5638 	dma_free_coherent(&instance->pdev->dev, reply_q_sz,
5639 			    instance->reply_queue, instance->reply_queue_h);
5640 fail_reply_queue:
5641 	megasas_free_cmds(instance);
5642 
5643 fail_alloc_cmds:
5644 	return 1;
5645 }
5646 
5647 static
5648 void megasas_setup_irq_poll(struct megasas_instance *instance)
5649 {
5650 	struct megasas_irq_context *irq_ctx;
5651 	u32 count, i;
5652 
5653 	count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
5654 
5655 	/* Initialize IRQ poll */
5656 	for (i = 0; i < count; i++) {
5657 		irq_ctx = &instance->irq_context[i];
5658 		irq_ctx->os_irq = pci_irq_vector(instance->pdev, i);
5659 		irq_ctx->irq_poll_scheduled = false;
5660 		irq_poll_init(&irq_ctx->irqpoll,
5661 			      instance->threshold_reply_count,
5662 			      megasas_irqpoll);
5663 	}
5664 }
5665 
5666 /*
5667  * megasas_setup_irqs_ioapic -		register legacy interrupts.
5668  * @instance:				Adapter soft state
5669  *
5670  * Do not enable interrupt, only setup ISRs.
5671  *
5672  * Return 0 on success.
5673  */
5674 static int
5675 megasas_setup_irqs_ioapic(struct megasas_instance *instance)
5676 {
5677 	struct pci_dev *pdev;
5678 
5679 	pdev = instance->pdev;
5680 	instance->irq_context[0].instance = instance;
5681 	instance->irq_context[0].MSIxIndex = 0;
5682 	snprintf(instance->irq_context->name, MEGASAS_MSIX_NAME_LEN, "%s%u",
5683 		"megasas", instance->host->host_no);
5684 	if (request_irq(pci_irq_vector(pdev, 0),
5685 			instance->instancet->service_isr, IRQF_SHARED,
5686 			instance->irq_context->name, &instance->irq_context[0])) {
5687 		dev_err(&instance->pdev->dev,
5688 				"Failed to register IRQ from %s %d\n",
5689 				__func__, __LINE__);
5690 		return -1;
5691 	}
5692 	instance->perf_mode = MR_LATENCY_PERF_MODE;
5693 	instance->low_latency_index_start = 0;
5694 	return 0;
5695 }
5696 
5697 /**
5698  * megasas_setup_irqs_msix -		register MSI-x interrupts.
5699  * @instance:				Adapter soft state
5700  * @is_probe:				Driver probe check
5701  *
5702  * Do not enable interrupt, only setup ISRs.
5703  *
5704  * Return 0 on success.
5705  */
5706 static int
5707 megasas_setup_irqs_msix(struct megasas_instance *instance, u8 is_probe)
5708 {
5709 	int i, j;
5710 	struct pci_dev *pdev;
5711 
5712 	pdev = instance->pdev;
5713 
5714 	/* Try MSI-x */
5715 	for (i = 0; i < instance->msix_vectors; i++) {
5716 		instance->irq_context[i].instance = instance;
5717 		instance->irq_context[i].MSIxIndex = i;
5718 		snprintf(instance->irq_context[i].name, MEGASAS_MSIX_NAME_LEN, "%s%u-msix%u",
5719 			"megasas", instance->host->host_no, i);
5720 		if (request_irq(pci_irq_vector(pdev, i),
5721 			instance->instancet->service_isr, 0, instance->irq_context[i].name,
5722 			&instance->irq_context[i])) {
5723 			dev_err(&instance->pdev->dev,
5724 				"Failed to register IRQ for vector %d.\n", i);
5725 			for (j = 0; j < i; j++) {
5726 				if (j < instance->low_latency_index_start)
5727 					irq_update_affinity_hint(
5728 						pci_irq_vector(pdev, j), NULL);
5729 				free_irq(pci_irq_vector(pdev, j),
5730 					 &instance->irq_context[j]);
5731 			}
5732 			/* Retry irq register for IO_APIC*/
5733 			instance->msix_vectors = 0;
5734 			instance->msix_load_balance = false;
5735 			if (is_probe) {
5736 				pci_free_irq_vectors(instance->pdev);
5737 				return megasas_setup_irqs_ioapic(instance);
5738 			} else {
5739 				return -1;
5740 			}
5741 		}
5742 	}
5743 
5744 	return 0;
5745 }
5746 
5747 /*
5748  * megasas_destroy_irqs-		unregister interrupts.
5749  * @instance:				Adapter soft state
5750  * return:				void
5751  */
5752 static void
5753 megasas_destroy_irqs(struct megasas_instance *instance) {
5754 
5755 	int i;
5756 	int count;
5757 	struct megasas_irq_context *irq_ctx;
5758 
5759 	count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
5760 	if (instance->adapter_type != MFI_SERIES) {
5761 		for (i = 0; i < count; i++) {
5762 			irq_ctx = &instance->irq_context[i];
5763 			irq_poll_disable(&irq_ctx->irqpoll);
5764 		}
5765 	}
5766 
5767 	if (instance->msix_vectors)
5768 		for (i = 0; i < instance->msix_vectors; i++) {
5769 			if (i < instance->low_latency_index_start)
5770 				irq_update_affinity_hint(
5771 				    pci_irq_vector(instance->pdev, i), NULL);
5772 			free_irq(pci_irq_vector(instance->pdev, i),
5773 				 &instance->irq_context[i]);
5774 		}
5775 	else
5776 		free_irq(pci_irq_vector(instance->pdev, 0),
5777 			 &instance->irq_context[0]);
5778 }
5779 
5780 /**
5781  * megasas_setup_jbod_map -	setup jbod map for FP seq_number.
5782  * @instance:				Adapter soft state
5783  *
5784  * Return 0 on success.
5785  */
5786 void
5787 megasas_setup_jbod_map(struct megasas_instance *instance)
5788 {
5789 	int i;
5790 	struct fusion_context *fusion = instance->ctrl_context;
5791 	size_t pd_seq_map_sz;
5792 
5793 	pd_seq_map_sz = struct_size((struct MR_PD_CFG_SEQ_NUM_SYNC *)0, seq,
5794 				    MAX_PHYSICAL_DEVICES);
5795 
5796 	instance->use_seqnum_jbod_fp =
5797 		instance->support_seqnum_jbod_fp;
5798 	if (reset_devices || !fusion ||
5799 		!instance->support_seqnum_jbod_fp) {
5800 		dev_info(&instance->pdev->dev,
5801 			"JBOD sequence map is disabled %s %d\n",
5802 			__func__, __LINE__);
5803 		instance->use_seqnum_jbod_fp = false;
5804 		return;
5805 	}
5806 
5807 	if (fusion->pd_seq_sync[0])
5808 		goto skip_alloc;
5809 
5810 	for (i = 0; i < JBOD_MAPS_COUNT; i++) {
5811 		fusion->pd_seq_sync[i] = dma_alloc_coherent
5812 			(&instance->pdev->dev, pd_seq_map_sz,
5813 			&fusion->pd_seq_phys[i], GFP_KERNEL);
5814 		if (!fusion->pd_seq_sync[i]) {
5815 			dev_err(&instance->pdev->dev,
5816 				"Failed to allocate memory from %s %d\n",
5817 				__func__, __LINE__);
5818 			if (i == 1) {
5819 				dma_free_coherent(&instance->pdev->dev,
5820 					pd_seq_map_sz, fusion->pd_seq_sync[0],
5821 					fusion->pd_seq_phys[0]);
5822 				fusion->pd_seq_sync[0] = NULL;
5823 			}
5824 			instance->use_seqnum_jbod_fp = false;
5825 			return;
5826 		}
5827 	}
5828 
5829 skip_alloc:
5830 	if (!megasas_sync_pd_seq_num(instance, false) &&
5831 		!megasas_sync_pd_seq_num(instance, true))
5832 		instance->use_seqnum_jbod_fp = true;
5833 	else
5834 		instance->use_seqnum_jbod_fp = false;
5835 }
5836 
5837 static void megasas_setup_reply_map(struct megasas_instance *instance)
5838 {
5839 	const struct cpumask *mask;
5840 	unsigned int queue, cpu, low_latency_index_start;
5841 
5842 	low_latency_index_start = instance->low_latency_index_start;
5843 
5844 	for (queue = low_latency_index_start; queue < instance->msix_vectors; queue++) {
5845 		mask = pci_irq_get_affinity(instance->pdev, queue);
5846 		if (!mask)
5847 			goto fallback;
5848 
5849 		for_each_cpu(cpu, mask)
5850 			instance->reply_map[cpu] = queue;
5851 	}
5852 	return;
5853 
5854 fallback:
5855 	queue = low_latency_index_start;
5856 	for_each_possible_cpu(cpu) {
5857 		instance->reply_map[cpu] = queue;
5858 		if (queue == (instance->msix_vectors - 1))
5859 			queue = low_latency_index_start;
5860 		else
5861 			queue++;
5862 	}
5863 }
5864 
5865 /**
5866  * megasas_get_device_list -	Get the PD and LD device list from FW.
5867  * @instance:			Adapter soft state
5868  * @return:			Success or failure
5869  *
5870  * Issue DCMDs to Firmware to get the PD and LD list.
5871  * Based on the FW support, driver sends the HOST_DEVICE_LIST or combination
5872  * of PD_LIST/LD_LIST_QUERY DCMDs to get the device list.
5873  */
5874 static
5875 int megasas_get_device_list(struct megasas_instance *instance)
5876 {
5877 	if (instance->enable_fw_dev_list) {
5878 		if (megasas_host_device_list_query(instance, true))
5879 			return FAILED;
5880 	} else {
5881 		if (megasas_get_pd_list(instance) < 0) {
5882 			dev_err(&instance->pdev->dev, "failed to get PD list\n");
5883 			return FAILED;
5884 		}
5885 
5886 		if (megasas_ld_list_query(instance,
5887 					  MR_LD_QUERY_TYPE_EXPOSED_TO_HOST)) {
5888 			dev_err(&instance->pdev->dev, "failed to get LD list\n");
5889 			return FAILED;
5890 		}
5891 	}
5892 
5893 	return SUCCESS;
5894 }
5895 
5896 /**
5897  * megasas_set_high_iops_queue_affinity_and_hint -	Set affinity and hint
5898  *							for high IOPS queues
5899  * @instance:						Adapter soft state
5900  * return:						void
5901  */
5902 static inline void
5903 megasas_set_high_iops_queue_affinity_and_hint(struct megasas_instance *instance)
5904 {
5905 	int i;
5906 	unsigned int irq;
5907 	const struct cpumask *mask;
5908 
5909 	if (instance->perf_mode == MR_BALANCED_PERF_MODE) {
5910 		mask = cpumask_of_node(dev_to_node(&instance->pdev->dev));
5911 
5912 		for (i = 0; i < instance->low_latency_index_start; i++) {
5913 			irq = pci_irq_vector(instance->pdev, i);
5914 			irq_set_affinity_and_hint(irq, mask);
5915 		}
5916 	}
5917 }
5918 
5919 static int
5920 __megasas_alloc_irq_vectors(struct megasas_instance *instance)
5921 {
5922 	int i, irq_flags;
5923 	struct irq_affinity desc = { .pre_vectors = instance->low_latency_index_start };
5924 	struct irq_affinity *descp = &desc;
5925 
5926 	irq_flags = PCI_IRQ_MSIX;
5927 
5928 	if (instance->smp_affinity_enable)
5929 		irq_flags |= PCI_IRQ_AFFINITY | PCI_IRQ_ALL_TYPES;
5930 	else
5931 		descp = NULL;
5932 
5933 	/* Do not allocate msix vectors for poll_queues.
5934 	 * msix_vectors is always within a range of FW supported reply queue.
5935 	 */
5936 	i = pci_alloc_irq_vectors_affinity(instance->pdev,
5937 		instance->low_latency_index_start,
5938 		instance->msix_vectors - instance->iopoll_q_count, irq_flags, descp);
5939 
5940 	return i;
5941 }
5942 
5943 /**
5944  * megasas_alloc_irq_vectors -	Allocate IRQ vectors/enable MSI-x vectors
5945  * @instance:			Adapter soft state
5946  * return:			void
5947  */
5948 static void
5949 megasas_alloc_irq_vectors(struct megasas_instance *instance)
5950 {
5951 	int i;
5952 	unsigned int num_msix_req;
5953 
5954 	instance->iopoll_q_count = 0;
5955 	if ((instance->adapter_type != MFI_SERIES) &&
5956 		poll_queues) {
5957 
5958 		instance->perf_mode = MR_LATENCY_PERF_MODE;
5959 		instance->low_latency_index_start = 1;
5960 
5961 		/* reserve for default and non-mananged pre-vector. */
5962 		if (instance->msix_vectors > (poll_queues + 2))
5963 			instance->iopoll_q_count = poll_queues;
5964 		else
5965 			instance->iopoll_q_count = 0;
5966 
5967 		num_msix_req = num_online_cpus() + instance->low_latency_index_start;
5968 		instance->msix_vectors = min(num_msix_req,
5969 				instance->msix_vectors);
5970 
5971 	}
5972 
5973 	i = __megasas_alloc_irq_vectors(instance);
5974 
5975 	if (((instance->perf_mode == MR_BALANCED_PERF_MODE)
5976 		|| instance->iopoll_q_count) &&
5977 	    (i != (instance->msix_vectors - instance->iopoll_q_count))) {
5978 		if (instance->msix_vectors)
5979 			pci_free_irq_vectors(instance->pdev);
5980 		/* Disable Balanced IOPS mode and try realloc vectors */
5981 		instance->perf_mode = MR_LATENCY_PERF_MODE;
5982 		instance->low_latency_index_start = 1;
5983 		num_msix_req = num_online_cpus() + instance->low_latency_index_start;
5984 
5985 		instance->msix_vectors = min(num_msix_req,
5986 				instance->msix_vectors);
5987 
5988 		instance->iopoll_q_count = 0;
5989 		i = __megasas_alloc_irq_vectors(instance);
5990 
5991 	}
5992 
5993 	dev_info(&instance->pdev->dev,
5994 		"requested/available msix %d/%d poll_queue %d\n",
5995 			instance->msix_vectors - instance->iopoll_q_count,
5996 			i, instance->iopoll_q_count);
5997 
5998 	if (i > 0)
5999 		instance->msix_vectors = i;
6000 	else
6001 		instance->msix_vectors = 0;
6002 
6003 	if (instance->smp_affinity_enable)
6004 		megasas_set_high_iops_queue_affinity_and_hint(instance);
6005 }
6006 
6007 /**
6008  * megasas_init_fw -	Initializes the FW
6009  * @instance:		Adapter soft state
6010  *
6011  * This is the main function for initializing firmware
6012  */
6013 
6014 static int megasas_init_fw(struct megasas_instance *instance)
6015 {
6016 	u32 max_sectors_1;
6017 	u32 max_sectors_2, tmp_sectors, msix_enable;
6018 	u32 scratch_pad_1, scratch_pad_2, scratch_pad_3, status_reg;
6019 	resource_size_t base_addr;
6020 	void *base_addr_phys;
6021 	struct megasas_ctrl_info *ctrl_info = NULL;
6022 	unsigned long bar_list;
6023 	int i, j, loop;
6024 	struct IOV_111 *iovPtr;
6025 	struct fusion_context *fusion;
6026 	bool intr_coalescing;
6027 	unsigned int num_msix_req;
6028 	u16 lnksta, speed;
6029 
6030 	fusion = instance->ctrl_context;
6031 
6032 	/* Find first memory bar */
6033 	bar_list = pci_select_bars(instance->pdev, IORESOURCE_MEM);
6034 	instance->bar = find_first_bit(&bar_list, BITS_PER_LONG);
6035 	if (pci_request_selected_regions(instance->pdev, 1<<instance->bar,
6036 					 "megasas: LSI")) {
6037 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "IO memory region busy!\n");
6038 		return -EBUSY;
6039 	}
6040 
6041 	base_addr = pci_resource_start(instance->pdev, instance->bar);
6042 	instance->reg_set = ioremap(base_addr, 8192);
6043 
6044 	if (!instance->reg_set) {
6045 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to map IO mem\n");
6046 		goto fail_ioremap;
6047 	}
6048 
6049 	base_addr_phys = &base_addr;
6050 	dev_printk(KERN_DEBUG, &instance->pdev->dev,
6051 		   "BAR:0x%lx  BAR's base_addr(phys):%pa  mapped virt_addr:0x%p\n",
6052 		   instance->bar, base_addr_phys, instance->reg_set);
6053 
6054 	if (instance->adapter_type != MFI_SERIES)
6055 		instance->instancet = &megasas_instance_template_fusion;
6056 	else {
6057 		switch (instance->pdev->device) {
6058 		case PCI_DEVICE_ID_LSI_SAS1078R:
6059 		case PCI_DEVICE_ID_LSI_SAS1078DE:
6060 			instance->instancet = &megasas_instance_template_ppc;
6061 			break;
6062 		case PCI_DEVICE_ID_LSI_SAS1078GEN2:
6063 		case PCI_DEVICE_ID_LSI_SAS0079GEN2:
6064 			instance->instancet = &megasas_instance_template_gen2;
6065 			break;
6066 		case PCI_DEVICE_ID_LSI_SAS0073SKINNY:
6067 		case PCI_DEVICE_ID_LSI_SAS0071SKINNY:
6068 			instance->instancet = &megasas_instance_template_skinny;
6069 			break;
6070 		case PCI_DEVICE_ID_LSI_SAS1064R:
6071 		case PCI_DEVICE_ID_DELL_PERC5:
6072 		default:
6073 			instance->instancet = &megasas_instance_template_xscale;
6074 			instance->pd_list_not_supported = 1;
6075 			break;
6076 		}
6077 	}
6078 
6079 	if (megasas_transition_to_ready(instance, 0)) {
6080 		dev_info(&instance->pdev->dev,
6081 			 "Failed to transition controller to ready from %s!\n",
6082 			 __func__);
6083 		if (instance->adapter_type != MFI_SERIES) {
6084 			status_reg = instance->instancet->read_fw_status_reg(
6085 					instance);
6086 			if (status_reg & MFI_RESET_ADAPTER) {
6087 				if (megasas_adp_reset_wait_for_ready
6088 					(instance, true, 0) == FAILED)
6089 					goto fail_ready_state;
6090 			} else {
6091 				goto fail_ready_state;
6092 			}
6093 		} else {
6094 			atomic_set(&instance->fw_reset_no_pci_access, 1);
6095 			instance->instancet->adp_reset
6096 				(instance, instance->reg_set);
6097 			atomic_set(&instance->fw_reset_no_pci_access, 0);
6098 
6099 			/*waiting for about 30 second before retry*/
6100 			ssleep(30);
6101 
6102 			if (megasas_transition_to_ready(instance, 0))
6103 				goto fail_ready_state;
6104 		}
6105 
6106 		dev_info(&instance->pdev->dev,
6107 			 "FW restarted successfully from %s!\n",
6108 			 __func__);
6109 	}
6110 
6111 	megasas_init_ctrl_params(instance);
6112 
6113 	if (megasas_set_dma_mask(instance))
6114 		goto fail_ready_state;
6115 
6116 	if (megasas_alloc_ctrl_mem(instance))
6117 		goto fail_alloc_dma_buf;
6118 
6119 	if (megasas_alloc_ctrl_dma_buffers(instance))
6120 		goto fail_alloc_dma_buf;
6121 
6122 	fusion = instance->ctrl_context;
6123 
6124 	if (instance->adapter_type >= VENTURA_SERIES) {
6125 		scratch_pad_2 =
6126 			megasas_readl(instance,
6127 				      &instance->reg_set->outbound_scratch_pad_2);
6128 		instance->max_raid_mapsize = ((scratch_pad_2 >>
6129 			MR_MAX_RAID_MAP_SIZE_OFFSET_SHIFT) &
6130 			MR_MAX_RAID_MAP_SIZE_MASK);
6131 	}
6132 
6133 	instance->enable_sdev_max_qd = enable_sdev_max_qd;
6134 
6135 	switch (instance->adapter_type) {
6136 	case VENTURA_SERIES:
6137 		fusion->pcie_bw_limitation = true;
6138 		break;
6139 	case AERO_SERIES:
6140 		fusion->r56_div_offload = true;
6141 		break;
6142 	default:
6143 		break;
6144 	}
6145 
6146 	/* Check if MSI-X is supported while in ready state */
6147 	msix_enable = (instance->instancet->read_fw_status_reg(instance) &
6148 		       0x4000000) >> 0x1a;
6149 	if (msix_enable && !msix_disable) {
6150 
6151 		scratch_pad_1 = megasas_readl
6152 			(instance, &instance->reg_set->outbound_scratch_pad_1);
6153 		/* Check max MSI-X vectors */
6154 		if (fusion) {
6155 			if (instance->adapter_type == THUNDERBOLT_SERIES) {
6156 				/* Thunderbolt Series*/
6157 				instance->msix_vectors = (scratch_pad_1
6158 					& MR_MAX_REPLY_QUEUES_OFFSET) + 1;
6159 			} else {
6160 				instance->msix_vectors = ((scratch_pad_1
6161 					& MR_MAX_REPLY_QUEUES_EXT_OFFSET)
6162 					>> MR_MAX_REPLY_QUEUES_EXT_OFFSET_SHIFT) + 1;
6163 
6164 				/*
6165 				 * For Invader series, > 8 MSI-x vectors
6166 				 * supported by FW/HW implies combined
6167 				 * reply queue mode is enabled.
6168 				 * For Ventura series, > 16 MSI-x vectors
6169 				 * supported by FW/HW implies combined
6170 				 * reply queue mode is enabled.
6171 				 */
6172 				switch (instance->adapter_type) {
6173 				case INVADER_SERIES:
6174 					if (instance->msix_vectors > 8)
6175 						instance->msix_combined = true;
6176 					break;
6177 				case AERO_SERIES:
6178 				case VENTURA_SERIES:
6179 					if (instance->msix_vectors > 16)
6180 						instance->msix_combined = true;
6181 					break;
6182 				}
6183 
6184 				if (rdpq_enable)
6185 					instance->is_rdpq = (scratch_pad_1 & MR_RDPQ_MODE_OFFSET) ?
6186 								1 : 0;
6187 
6188 				if (instance->adapter_type >= INVADER_SERIES &&
6189 				    !instance->msix_combined) {
6190 					instance->msix_load_balance = true;
6191 					instance->smp_affinity_enable = false;
6192 				}
6193 
6194 				/* Save 1-15 reply post index address to local memory
6195 				 * Index 0 is already saved from reg offset
6196 				 * MPI2_REPLY_POST_HOST_INDEX_OFFSET
6197 				 */
6198 				for (loop = 1; loop < MR_MAX_MSIX_REG_ARRAY; loop++) {
6199 					instance->reply_post_host_index_addr[loop] =
6200 						(u32 __iomem *)
6201 						((u8 __iomem *)instance->reg_set +
6202 						MPI2_SUP_REPLY_POST_HOST_INDEX_OFFSET
6203 						+ (loop * 0x10));
6204 				}
6205 			}
6206 
6207 			dev_info(&instance->pdev->dev,
6208 				 "firmware supports msix\t: (%d)",
6209 				 instance->msix_vectors);
6210 			if (msix_vectors)
6211 				instance->msix_vectors = min(msix_vectors,
6212 					instance->msix_vectors);
6213 		} else /* MFI adapters */
6214 			instance->msix_vectors = 1;
6215 
6216 
6217 		/*
6218 		 * For Aero (if some conditions are met), driver will configure a
6219 		 * few additional reply queues with interrupt coalescing enabled.
6220 		 * These queues with interrupt coalescing enabled are called
6221 		 * High IOPS queues and rest of reply queues (based on number of
6222 		 * logical CPUs) are termed as Low latency queues.
6223 		 *
6224 		 * Total Number of reply queues = High IOPS queues + low latency queues
6225 		 *
6226 		 * For rest of fusion adapters, 1 additional reply queue will be
6227 		 * reserved for management commands, rest of reply queues
6228 		 * (based on number of logical CPUs) will be used for IOs and
6229 		 * referenced as IO queues.
6230 		 * Total Number of reply queues = 1 + IO queues
6231 		 *
6232 		 * MFI adapters supports single MSI-x so single reply queue
6233 		 * will be used for IO and management commands.
6234 		 */
6235 
6236 		intr_coalescing = (scratch_pad_1 & MR_INTR_COALESCING_SUPPORT_OFFSET) ?
6237 								true : false;
6238 		if (intr_coalescing &&
6239 			(num_online_cpus() >= MR_HIGH_IOPS_QUEUE_COUNT) &&
6240 			(instance->msix_vectors == MEGASAS_MAX_MSIX_QUEUES))
6241 			instance->perf_mode = MR_BALANCED_PERF_MODE;
6242 		else
6243 			instance->perf_mode = MR_LATENCY_PERF_MODE;
6244 
6245 
6246 		if (instance->adapter_type == AERO_SERIES) {
6247 			pcie_capability_read_word(instance->pdev, PCI_EXP_LNKSTA, &lnksta);
6248 			speed = lnksta & PCI_EXP_LNKSTA_CLS;
6249 
6250 			/*
6251 			 * For Aero, if PCIe link speed is <16 GT/s, then driver should operate
6252 			 * in latency perf mode and enable R1 PCI bandwidth algorithm
6253 			 */
6254 			if (speed < 0x4) {
6255 				instance->perf_mode = MR_LATENCY_PERF_MODE;
6256 				fusion->pcie_bw_limitation = true;
6257 			}
6258 
6259 			/*
6260 			 * Performance mode settings provided through module parameter-perf_mode will
6261 			 * take affect only for:
6262 			 * 1. Aero family of adapters.
6263 			 * 2. When user sets module parameter- perf_mode in range of 0-2.
6264 			 */
6265 			if ((perf_mode >= MR_BALANCED_PERF_MODE) &&
6266 				(perf_mode <= MR_LATENCY_PERF_MODE))
6267 				instance->perf_mode = perf_mode;
6268 			/*
6269 			 * If intr coalescing is not supported by controller FW, then IOPS
6270 			 * and Balanced modes are not feasible.
6271 			 */
6272 			if (!intr_coalescing)
6273 				instance->perf_mode = MR_LATENCY_PERF_MODE;
6274 
6275 		}
6276 
6277 		if (instance->perf_mode == MR_BALANCED_PERF_MODE)
6278 			instance->low_latency_index_start =
6279 				MR_HIGH_IOPS_QUEUE_COUNT;
6280 		else
6281 			instance->low_latency_index_start = 1;
6282 
6283 		num_msix_req = num_online_cpus() + instance->low_latency_index_start;
6284 
6285 		instance->msix_vectors = min(num_msix_req,
6286 				instance->msix_vectors);
6287 
6288 		megasas_alloc_irq_vectors(instance);
6289 		if (!instance->msix_vectors)
6290 			instance->msix_load_balance = false;
6291 	}
6292 	/*
6293 	 * MSI-X host index 0 is common for all adapter.
6294 	 * It is used for all MPT based Adapters.
6295 	 */
6296 	if (instance->msix_combined) {
6297 		instance->reply_post_host_index_addr[0] =
6298 				(u32 *)((u8 *)instance->reg_set +
6299 				MPI2_SUP_REPLY_POST_HOST_INDEX_OFFSET);
6300 	} else {
6301 		instance->reply_post_host_index_addr[0] =
6302 			(u32 *)((u8 *)instance->reg_set +
6303 			MPI2_REPLY_POST_HOST_INDEX_OFFSET);
6304 	}
6305 
6306 	if (!instance->msix_vectors) {
6307 		i = pci_alloc_irq_vectors(instance->pdev, 1, 1, PCI_IRQ_LEGACY);
6308 		if (i < 0)
6309 			goto fail_init_adapter;
6310 	}
6311 
6312 	megasas_setup_reply_map(instance);
6313 
6314 	dev_info(&instance->pdev->dev,
6315 		"current msix/online cpus\t: (%d/%d)\n",
6316 		instance->msix_vectors, (unsigned int)num_online_cpus());
6317 	dev_info(&instance->pdev->dev,
6318 		"RDPQ mode\t: (%s)\n", instance->is_rdpq ? "enabled" : "disabled");
6319 
6320 	tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
6321 		(unsigned long)instance);
6322 
6323 	/*
6324 	 * Below are default value for legacy Firmware.
6325 	 * non-fusion based controllers
6326 	 */
6327 	instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
6328 	instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
6329 	/* Get operational params, sge flags, send init cmd to controller */
6330 	if (instance->instancet->init_adapter(instance))
6331 		goto fail_init_adapter;
6332 
6333 	if (instance->adapter_type >= VENTURA_SERIES) {
6334 		scratch_pad_3 =
6335 			megasas_readl(instance,
6336 				      &instance->reg_set->outbound_scratch_pad_3);
6337 		if ((scratch_pad_3 & MR_NVME_PAGE_SIZE_MASK) >=
6338 			MR_DEFAULT_NVME_PAGE_SHIFT)
6339 			instance->nvme_page_size =
6340 				(1 << (scratch_pad_3 & MR_NVME_PAGE_SIZE_MASK));
6341 
6342 		dev_info(&instance->pdev->dev,
6343 			 "NVME page size\t: (%d)\n", instance->nvme_page_size);
6344 	}
6345 
6346 	if (instance->msix_vectors ?
6347 		megasas_setup_irqs_msix(instance, 1) :
6348 		megasas_setup_irqs_ioapic(instance))
6349 		goto fail_init_adapter;
6350 
6351 	if (instance->adapter_type != MFI_SERIES)
6352 		megasas_setup_irq_poll(instance);
6353 
6354 	instance->instancet->enable_intr(instance);
6355 
6356 	dev_info(&instance->pdev->dev, "INIT adapter done\n");
6357 
6358 	megasas_setup_jbod_map(instance);
6359 
6360 	if (megasas_get_device_list(instance) != SUCCESS) {
6361 		dev_err(&instance->pdev->dev,
6362 			"%s: megasas_get_device_list failed\n",
6363 			__func__);
6364 		goto fail_get_ld_pd_list;
6365 	}
6366 
6367 	/* stream detection initialization */
6368 	if (instance->adapter_type >= VENTURA_SERIES) {
6369 		fusion->stream_detect_by_ld =
6370 			kcalloc(MAX_LOGICAL_DRIVES_EXT,
6371 				sizeof(struct LD_STREAM_DETECT *),
6372 				GFP_KERNEL);
6373 		if (!fusion->stream_detect_by_ld) {
6374 			dev_err(&instance->pdev->dev,
6375 				"unable to allocate stream detection for pool of LDs\n");
6376 			goto fail_get_ld_pd_list;
6377 		}
6378 		for (i = 0; i < MAX_LOGICAL_DRIVES_EXT; ++i) {
6379 			fusion->stream_detect_by_ld[i] =
6380 				kzalloc(sizeof(struct LD_STREAM_DETECT),
6381 				GFP_KERNEL);
6382 			if (!fusion->stream_detect_by_ld[i]) {
6383 				dev_err(&instance->pdev->dev,
6384 					"unable to allocate stream detect by LD\n ");
6385 				for (j = 0; j < i; ++j)
6386 					kfree(fusion->stream_detect_by_ld[j]);
6387 				kfree(fusion->stream_detect_by_ld);
6388 				fusion->stream_detect_by_ld = NULL;
6389 				goto fail_get_ld_pd_list;
6390 			}
6391 			fusion->stream_detect_by_ld[i]->mru_bit_map
6392 				= MR_STREAM_BITMAP;
6393 		}
6394 	}
6395 
6396 	/*
6397 	 * Compute the max allowed sectors per IO: The controller info has two
6398 	 * limits on max sectors. Driver should use the minimum of these two.
6399 	 *
6400 	 * 1 << stripe_sz_ops.min = max sectors per strip
6401 	 *
6402 	 * Note that older firmwares ( < FW ver 30) didn't report information
6403 	 * to calculate max_sectors_1. So the number ended up as zero always.
6404 	 */
6405 	tmp_sectors = 0;
6406 	ctrl_info = instance->ctrl_info_buf;
6407 
6408 	max_sectors_1 = (1 << ctrl_info->stripe_sz_ops.min) *
6409 		le16_to_cpu(ctrl_info->max_strips_per_io);
6410 	max_sectors_2 = le32_to_cpu(ctrl_info->max_request_size);
6411 
6412 	tmp_sectors = min_t(u32, max_sectors_1, max_sectors_2);
6413 
6414 	instance->peerIsPresent = ctrl_info->cluster.peerIsPresent;
6415 	instance->passive = ctrl_info->cluster.passive;
6416 	memcpy(instance->clusterId, ctrl_info->clusterId, sizeof(instance->clusterId));
6417 	instance->UnevenSpanSupport =
6418 		ctrl_info->adapterOperations2.supportUnevenSpans;
6419 	if (instance->UnevenSpanSupport) {
6420 		struct fusion_context *fusion = instance->ctrl_context;
6421 		if (MR_ValidateMapInfo(instance, instance->map_id))
6422 			fusion->fast_path_io = 1;
6423 		else
6424 			fusion->fast_path_io = 0;
6425 
6426 	}
6427 	if (ctrl_info->host_interface.SRIOV) {
6428 		instance->requestorId = ctrl_info->iov.requestorId;
6429 		if (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) {
6430 			if (!ctrl_info->adapterOperations2.activePassive)
6431 			    instance->PlasmaFW111 = 1;
6432 
6433 			dev_info(&instance->pdev->dev, "SR-IOV: firmware type: %s\n",
6434 			    instance->PlasmaFW111 ? "1.11" : "new");
6435 
6436 			if (instance->PlasmaFW111) {
6437 			    iovPtr = (struct IOV_111 *)
6438 				((unsigned char *)ctrl_info + IOV_111_OFFSET);
6439 			    instance->requestorId = iovPtr->requestorId;
6440 			}
6441 		}
6442 		dev_info(&instance->pdev->dev, "SRIOV: VF requestorId %d\n",
6443 			instance->requestorId);
6444 	}
6445 
6446 	instance->crash_dump_fw_support =
6447 		ctrl_info->adapterOperations3.supportCrashDump;
6448 	instance->crash_dump_drv_support =
6449 		(instance->crash_dump_fw_support &&
6450 		instance->crash_dump_buf);
6451 	if (instance->crash_dump_drv_support)
6452 		megasas_set_crash_dump_params(instance,
6453 			MR_CRASH_BUF_TURN_OFF);
6454 
6455 	else {
6456 		if (instance->crash_dump_buf)
6457 			dma_free_coherent(&instance->pdev->dev,
6458 				CRASH_DMA_BUF_SIZE,
6459 				instance->crash_dump_buf,
6460 				instance->crash_dump_h);
6461 		instance->crash_dump_buf = NULL;
6462 	}
6463 
6464 	if (instance->snapdump_wait_time) {
6465 		megasas_get_snapdump_properties(instance);
6466 		dev_info(&instance->pdev->dev, "Snap dump wait time\t: %d\n",
6467 			 instance->snapdump_wait_time);
6468 	}
6469 
6470 	dev_info(&instance->pdev->dev,
6471 		"pci id\t\t: (0x%04x)/(0x%04x)/(0x%04x)/(0x%04x)\n",
6472 		le16_to_cpu(ctrl_info->pci.vendor_id),
6473 		le16_to_cpu(ctrl_info->pci.device_id),
6474 		le16_to_cpu(ctrl_info->pci.sub_vendor_id),
6475 		le16_to_cpu(ctrl_info->pci.sub_device_id));
6476 	dev_info(&instance->pdev->dev, "unevenspan support	: %s\n",
6477 		instance->UnevenSpanSupport ? "yes" : "no");
6478 	dev_info(&instance->pdev->dev, "firmware crash dump	: %s\n",
6479 		instance->crash_dump_drv_support ? "yes" : "no");
6480 	dev_info(&instance->pdev->dev, "JBOD sequence map	: %s\n",
6481 		instance->use_seqnum_jbod_fp ? "enabled" : "disabled");
6482 
6483 	instance->max_sectors_per_req = instance->max_num_sge *
6484 						SGE_BUFFER_SIZE / 512;
6485 	if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))
6486 		instance->max_sectors_per_req = tmp_sectors;
6487 
6488 	/* Check for valid throttlequeuedepth module parameter */
6489 	if (throttlequeuedepth &&
6490 			throttlequeuedepth <= instance->max_scsi_cmds)
6491 		instance->throttlequeuedepth = throttlequeuedepth;
6492 	else
6493 		instance->throttlequeuedepth =
6494 				MEGASAS_THROTTLE_QUEUE_DEPTH;
6495 
6496 	if ((resetwaittime < 1) ||
6497 	    (resetwaittime > MEGASAS_RESET_WAIT_TIME))
6498 		resetwaittime = MEGASAS_RESET_WAIT_TIME;
6499 
6500 	if ((scmd_timeout < 10) || (scmd_timeout > MEGASAS_DEFAULT_CMD_TIMEOUT))
6501 		scmd_timeout = MEGASAS_DEFAULT_CMD_TIMEOUT;
6502 
6503 	/* Launch SR-IOV heartbeat timer */
6504 	if (instance->requestorId) {
6505 		if (!megasas_sriov_start_heartbeat(instance, 1)) {
6506 			megasas_start_timer(instance);
6507 		} else {
6508 			instance->skip_heartbeat_timer_del = 1;
6509 			goto fail_get_ld_pd_list;
6510 		}
6511 	}
6512 
6513 	/*
6514 	 * Create and start watchdog thread which will monitor
6515 	 * controller state every 1 sec and trigger OCR when
6516 	 * it enters fault state
6517 	 */
6518 	if (instance->adapter_type != MFI_SERIES)
6519 		if (megasas_fusion_start_watchdog(instance) != SUCCESS)
6520 			goto fail_start_watchdog;
6521 
6522 	return 0;
6523 
6524 fail_start_watchdog:
6525 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
6526 		del_timer_sync(&instance->sriov_heartbeat_timer);
6527 fail_get_ld_pd_list:
6528 	instance->instancet->disable_intr(instance);
6529 	megasas_destroy_irqs(instance);
6530 fail_init_adapter:
6531 	if (instance->msix_vectors)
6532 		pci_free_irq_vectors(instance->pdev);
6533 	instance->msix_vectors = 0;
6534 fail_alloc_dma_buf:
6535 	megasas_free_ctrl_dma_buffers(instance);
6536 	megasas_free_ctrl_mem(instance);
6537 fail_ready_state:
6538 	iounmap(instance->reg_set);
6539 
6540 fail_ioremap:
6541 	pci_release_selected_regions(instance->pdev, 1<<instance->bar);
6542 
6543 	dev_err(&instance->pdev->dev, "Failed from %s %d\n",
6544 		__func__, __LINE__);
6545 	return -EINVAL;
6546 }
6547 
6548 /**
6549  * megasas_release_mfi -	Reverses the FW initialization
6550  * @instance:			Adapter soft state
6551  */
6552 static void megasas_release_mfi(struct megasas_instance *instance)
6553 {
6554 	u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1);
6555 
6556 	if (instance->reply_queue)
6557 		dma_free_coherent(&instance->pdev->dev, reply_q_sz,
6558 			    instance->reply_queue, instance->reply_queue_h);
6559 
6560 	megasas_free_cmds(instance);
6561 
6562 	iounmap(instance->reg_set);
6563 
6564 	pci_release_selected_regions(instance->pdev, 1<<instance->bar);
6565 }
6566 
6567 /**
6568  * megasas_get_seq_num -	Gets latest event sequence numbers
6569  * @instance:			Adapter soft state
6570  * @eli:			FW event log sequence numbers information
6571  *
6572  * FW maintains a log of all events in a non-volatile area. Upper layers would
6573  * usually find out the latest sequence number of the events, the seq number at
6574  * the boot etc. They would "read" all the events below the latest seq number
6575  * by issuing a direct fw cmd (DCMD). For the future events (beyond latest seq
6576  * number), they would subsribe to AEN (asynchronous event notification) and
6577  * wait for the events to happen.
6578  */
6579 static int
6580 megasas_get_seq_num(struct megasas_instance *instance,
6581 		    struct megasas_evt_log_info *eli)
6582 {
6583 	struct megasas_cmd *cmd;
6584 	struct megasas_dcmd_frame *dcmd;
6585 	struct megasas_evt_log_info *el_info;
6586 	dma_addr_t el_info_h = 0;
6587 	int ret;
6588 
6589 	cmd = megasas_get_cmd(instance);
6590 
6591 	if (!cmd) {
6592 		return -ENOMEM;
6593 	}
6594 
6595 	dcmd = &cmd->frame->dcmd;
6596 	el_info = dma_alloc_coherent(&instance->pdev->dev,
6597 				     sizeof(struct megasas_evt_log_info),
6598 				     &el_info_h, GFP_KERNEL);
6599 	if (!el_info) {
6600 		megasas_return_cmd(instance, cmd);
6601 		return -ENOMEM;
6602 	}
6603 
6604 	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
6605 
6606 	dcmd->cmd = MFI_CMD_DCMD;
6607 	dcmd->cmd_status = 0x0;
6608 	dcmd->sge_count = 1;
6609 	dcmd->flags = MFI_FRAME_DIR_READ;
6610 	dcmd->timeout = 0;
6611 	dcmd->pad_0 = 0;
6612 	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_log_info));
6613 	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_GET_INFO);
6614 
6615 	megasas_set_dma_settings(instance, dcmd, el_info_h,
6616 				 sizeof(struct megasas_evt_log_info));
6617 
6618 	ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
6619 	if (ret != DCMD_SUCCESS) {
6620 		dev_err(&instance->pdev->dev, "Failed from %s %d\n",
6621 			__func__, __LINE__);
6622 		goto dcmd_failed;
6623 	}
6624 
6625 	/*
6626 	 * Copy the data back into callers buffer
6627 	 */
6628 	eli->newest_seq_num = el_info->newest_seq_num;
6629 	eli->oldest_seq_num = el_info->oldest_seq_num;
6630 	eli->clear_seq_num = el_info->clear_seq_num;
6631 	eli->shutdown_seq_num = el_info->shutdown_seq_num;
6632 	eli->boot_seq_num = el_info->boot_seq_num;
6633 
6634 dcmd_failed:
6635 	dma_free_coherent(&instance->pdev->dev,
6636 			sizeof(struct megasas_evt_log_info),
6637 			el_info, el_info_h);
6638 
6639 	megasas_return_cmd(instance, cmd);
6640 
6641 	return ret;
6642 }
6643 
6644 /**
6645  * megasas_register_aen -	Registers for asynchronous event notification
6646  * @instance:			Adapter soft state
6647  * @seq_num:			The starting sequence number
6648  * @class_locale_word:		Class of the event
6649  *
6650  * This function subscribes for AEN for events beyond the @seq_num. It requests
6651  * to be notified if and only if the event is of type @class_locale
6652  */
6653 static int
6654 megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
6655 		     u32 class_locale_word)
6656 {
6657 	int ret_val;
6658 	struct megasas_cmd *cmd;
6659 	struct megasas_dcmd_frame *dcmd;
6660 	union megasas_evt_class_locale curr_aen;
6661 	union megasas_evt_class_locale prev_aen;
6662 
6663 	/*
6664 	 * If there an AEN pending already (aen_cmd), check if the
6665 	 * class_locale of that pending AEN is inclusive of the new
6666 	 * AEN request we currently have. If it is, then we don't have
6667 	 * to do anything. In other words, whichever events the current
6668 	 * AEN request is subscribing to, have already been subscribed
6669 	 * to.
6670 	 *
6671 	 * If the old_cmd is _not_ inclusive, then we have to abort
6672 	 * that command, form a class_locale that is superset of both
6673 	 * old and current and re-issue to the FW
6674 	 */
6675 
6676 	curr_aen.word = class_locale_word;
6677 
6678 	if (instance->aen_cmd) {
6679 
6680 		prev_aen.word =
6681 			le32_to_cpu(instance->aen_cmd->frame->dcmd.mbox.w[1]);
6682 
6683 		if ((curr_aen.members.class < MFI_EVT_CLASS_DEBUG) ||
6684 		    (curr_aen.members.class > MFI_EVT_CLASS_DEAD)) {
6685 			dev_info(&instance->pdev->dev,
6686 				 "%s %d out of range class %d send by application\n",
6687 				 __func__, __LINE__, curr_aen.members.class);
6688 			return 0;
6689 		}
6690 
6691 		/*
6692 		 * A class whose enum value is smaller is inclusive of all
6693 		 * higher values. If a PROGRESS (= -1) was previously
6694 		 * registered, then a new registration requests for higher
6695 		 * classes need not be sent to FW. They are automatically
6696 		 * included.
6697 		 *
6698 		 * Locale numbers don't have such hierarchy. They are bitmap
6699 		 * values
6700 		 */
6701 		if ((prev_aen.members.class <= curr_aen.members.class) &&
6702 		    !((prev_aen.members.locale & curr_aen.members.locale) ^
6703 		      curr_aen.members.locale)) {
6704 			/*
6705 			 * Previously issued event registration includes
6706 			 * current request. Nothing to do.
6707 			 */
6708 			return 0;
6709 		} else {
6710 			curr_aen.members.locale |= prev_aen.members.locale;
6711 
6712 			if (prev_aen.members.class < curr_aen.members.class)
6713 				curr_aen.members.class = prev_aen.members.class;
6714 
6715 			instance->aen_cmd->abort_aen = 1;
6716 			ret_val = megasas_issue_blocked_abort_cmd(instance,
6717 								  instance->
6718 								  aen_cmd, 30);
6719 
6720 			if (ret_val) {
6721 				dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to abort "
6722 				       "previous AEN command\n");
6723 				return ret_val;
6724 			}
6725 		}
6726 	}
6727 
6728 	cmd = megasas_get_cmd(instance);
6729 
6730 	if (!cmd)
6731 		return -ENOMEM;
6732 
6733 	dcmd = &cmd->frame->dcmd;
6734 
6735 	memset(instance->evt_detail, 0, sizeof(struct megasas_evt_detail));
6736 
6737 	/*
6738 	 * Prepare DCMD for aen registration
6739 	 */
6740 	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
6741 
6742 	dcmd->cmd = MFI_CMD_DCMD;
6743 	dcmd->cmd_status = 0x0;
6744 	dcmd->sge_count = 1;
6745 	dcmd->flags = MFI_FRAME_DIR_READ;
6746 	dcmd->timeout = 0;
6747 	dcmd->pad_0 = 0;
6748 	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_detail));
6749 	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_WAIT);
6750 	dcmd->mbox.w[0] = cpu_to_le32(seq_num);
6751 	instance->last_seq_num = seq_num;
6752 	dcmd->mbox.w[1] = cpu_to_le32(curr_aen.word);
6753 
6754 	megasas_set_dma_settings(instance, dcmd, instance->evt_detail_h,
6755 				 sizeof(struct megasas_evt_detail));
6756 
6757 	if (instance->aen_cmd != NULL) {
6758 		megasas_return_cmd(instance, cmd);
6759 		return 0;
6760 	}
6761 
6762 	/*
6763 	 * Store reference to the cmd used to register for AEN. When an
6764 	 * application wants us to register for AEN, we have to abort this
6765 	 * cmd and re-register with a new EVENT LOCALE supplied by that app
6766 	 */
6767 	instance->aen_cmd = cmd;
6768 
6769 	/*
6770 	 * Issue the aen registration frame
6771 	 */
6772 	instance->instancet->issue_dcmd(instance, cmd);
6773 
6774 	return 0;
6775 }
6776 
6777 /* megasas_get_target_prop - Send DCMD with below details to firmware.
6778  *
6779  * This DCMD will fetch few properties of LD/system PD defined
6780  * in MR_TARGET_DEV_PROPERTIES. eg. Queue Depth, MDTS value.
6781  *
6782  * DCMD send by drivers whenever new target is added to the OS.
6783  *
6784  * dcmd.opcode         - MR_DCMD_DEV_GET_TARGET_PROP
6785  * dcmd.mbox.b[0]      - DCMD is to be fired for LD or system PD.
6786  *                       0 = system PD, 1 = LD.
6787  * dcmd.mbox.s[1]      - TargetID for LD/system PD.
6788  * dcmd.sge IN         - Pointer to return MR_TARGET_DEV_PROPERTIES.
6789  *
6790  * @instance:		Adapter soft state
6791  * @sdev:		OS provided scsi device
6792  *
6793  * Returns 0 on success non-zero on failure.
6794  */
6795 int
6796 megasas_get_target_prop(struct megasas_instance *instance,
6797 			struct scsi_device *sdev)
6798 {
6799 	int ret;
6800 	struct megasas_cmd *cmd;
6801 	struct megasas_dcmd_frame *dcmd;
6802 	u16 targetId = ((sdev->channel % 2) * MEGASAS_MAX_DEV_PER_CHANNEL) +
6803 			sdev->id;
6804 
6805 	cmd = megasas_get_cmd(instance);
6806 
6807 	if (!cmd) {
6808 		dev_err(&instance->pdev->dev,
6809 			"Failed to get cmd %s\n", __func__);
6810 		return -ENOMEM;
6811 	}
6812 
6813 	dcmd = &cmd->frame->dcmd;
6814 
6815 	memset(instance->tgt_prop, 0, sizeof(*instance->tgt_prop));
6816 	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
6817 	dcmd->mbox.b[0] = MEGASAS_IS_LOGICAL(sdev);
6818 
6819 	dcmd->mbox.s[1] = cpu_to_le16(targetId);
6820 	dcmd->cmd = MFI_CMD_DCMD;
6821 	dcmd->cmd_status = 0xFF;
6822 	dcmd->sge_count = 1;
6823 	dcmd->flags = MFI_FRAME_DIR_READ;
6824 	dcmd->timeout = 0;
6825 	dcmd->pad_0 = 0;
6826 	dcmd->data_xfer_len =
6827 		cpu_to_le32(sizeof(struct MR_TARGET_PROPERTIES));
6828 	dcmd->opcode = cpu_to_le32(MR_DCMD_DRV_GET_TARGET_PROP);
6829 
6830 	megasas_set_dma_settings(instance, dcmd, instance->tgt_prop_h,
6831 				 sizeof(struct MR_TARGET_PROPERTIES));
6832 
6833 	if ((instance->adapter_type != MFI_SERIES) &&
6834 	    !instance->mask_interrupts)
6835 		ret = megasas_issue_blocked_cmd(instance,
6836 						cmd, MFI_IO_TIMEOUT_SECS);
6837 	else
6838 		ret = megasas_issue_polled(instance, cmd);
6839 
6840 	switch (ret) {
6841 	case DCMD_TIMEOUT:
6842 		switch (dcmd_timeout_ocr_possible(instance)) {
6843 		case INITIATE_OCR:
6844 			cmd->flags |= DRV_DCMD_SKIP_REFIRE;
6845 			mutex_unlock(&instance->reset_mutex);
6846 			megasas_reset_fusion(instance->host,
6847 					     MFI_IO_TIMEOUT_OCR);
6848 			mutex_lock(&instance->reset_mutex);
6849 			break;
6850 		case KILL_ADAPTER:
6851 			megaraid_sas_kill_hba(instance);
6852 			break;
6853 		case IGNORE_TIMEOUT:
6854 			dev_info(&instance->pdev->dev,
6855 				 "Ignore DCMD timeout: %s %d\n",
6856 				 __func__, __LINE__);
6857 			break;
6858 		}
6859 		break;
6860 
6861 	default:
6862 		megasas_return_cmd(instance, cmd);
6863 	}
6864 	if (ret != DCMD_SUCCESS)
6865 		dev_err(&instance->pdev->dev,
6866 			"return from %s %d return value %d\n",
6867 			__func__, __LINE__, ret);
6868 
6869 	return ret;
6870 }
6871 
6872 /**
6873  * megasas_start_aen -	Subscribes to AEN during driver load time
6874  * @instance:		Adapter soft state
6875  */
6876 static int megasas_start_aen(struct megasas_instance *instance)
6877 {
6878 	struct megasas_evt_log_info eli;
6879 	union megasas_evt_class_locale class_locale;
6880 
6881 	/*
6882 	 * Get the latest sequence number from FW
6883 	 */
6884 	memset(&eli, 0, sizeof(eli));
6885 
6886 	if (megasas_get_seq_num(instance, &eli))
6887 		return -1;
6888 
6889 	/*
6890 	 * Register AEN with FW for latest sequence number plus 1
6891 	 */
6892 	class_locale.members.reserved = 0;
6893 	class_locale.members.locale = MR_EVT_LOCALE_ALL;
6894 	class_locale.members.class = MR_EVT_CLASS_DEBUG;
6895 
6896 	return megasas_register_aen(instance,
6897 			le32_to_cpu(eli.newest_seq_num) + 1,
6898 			class_locale.word);
6899 }
6900 
6901 /**
6902  * megasas_io_attach -	Attaches this driver to SCSI mid-layer
6903  * @instance:		Adapter soft state
6904  */
6905 static int megasas_io_attach(struct megasas_instance *instance)
6906 {
6907 	struct Scsi_Host *host = instance->host;
6908 
6909 	/*
6910 	 * Export parameters required by SCSI mid-layer
6911 	 */
6912 	host->unique_id = instance->unique_id;
6913 	host->can_queue = instance->max_scsi_cmds;
6914 	host->this_id = instance->init_id;
6915 	host->sg_tablesize = instance->max_num_sge;
6916 
6917 	if (instance->fw_support_ieee)
6918 		instance->max_sectors_per_req = MEGASAS_MAX_SECTORS_IEEE;
6919 
6920 	/*
6921 	 * Check if the module parameter value for max_sectors can be used
6922 	 */
6923 	if (max_sectors && max_sectors < instance->max_sectors_per_req)
6924 		instance->max_sectors_per_req = max_sectors;
6925 	else {
6926 		if (max_sectors) {
6927 			if (((instance->pdev->device ==
6928 				PCI_DEVICE_ID_LSI_SAS1078GEN2) ||
6929 				(instance->pdev->device ==
6930 				PCI_DEVICE_ID_LSI_SAS0079GEN2)) &&
6931 				(max_sectors <= MEGASAS_MAX_SECTORS)) {
6932 				instance->max_sectors_per_req = max_sectors;
6933 			} else {
6934 			dev_info(&instance->pdev->dev, "max_sectors should be > 0"
6935 				"and <= %d (or < 1MB for GEN2 controller)\n",
6936 				instance->max_sectors_per_req);
6937 			}
6938 		}
6939 	}
6940 
6941 	host->max_sectors = instance->max_sectors_per_req;
6942 	host->cmd_per_lun = MEGASAS_DEFAULT_CMD_PER_LUN;
6943 	host->max_channel = MEGASAS_MAX_CHANNELS - 1;
6944 	host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL;
6945 	host->max_lun = MEGASAS_MAX_LUN;
6946 	host->max_cmd_len = 16;
6947 
6948 	/* Use shared host tagset only for fusion adaptors
6949 	 * if there are managed interrupts (smp affinity enabled case).
6950 	 * Single msix_vectors in kdump, so shared host tag is also disabled.
6951 	 */
6952 
6953 	host->host_tagset = 0;
6954 	host->nr_hw_queues = 1;
6955 
6956 	if ((instance->adapter_type != MFI_SERIES) &&
6957 		(instance->msix_vectors > instance->low_latency_index_start) &&
6958 		host_tagset_enable &&
6959 		instance->smp_affinity_enable) {
6960 		host->host_tagset = 1;
6961 		host->nr_hw_queues = instance->msix_vectors -
6962 			instance->low_latency_index_start + instance->iopoll_q_count;
6963 		if (instance->iopoll_q_count)
6964 			host->nr_maps = 3;
6965 	} else {
6966 		instance->iopoll_q_count = 0;
6967 	}
6968 
6969 	dev_info(&instance->pdev->dev,
6970 		"Max firmware commands: %d shared with default "
6971 		"hw_queues = %d poll_queues %d\n", instance->max_fw_cmds,
6972 		host->nr_hw_queues - instance->iopoll_q_count,
6973 		instance->iopoll_q_count);
6974 	/*
6975 	 * Notify the mid-layer about the new controller
6976 	 */
6977 	if (scsi_add_host(host, &instance->pdev->dev)) {
6978 		dev_err(&instance->pdev->dev,
6979 			"Failed to add host from %s %d\n",
6980 			__func__, __LINE__);
6981 		return -ENODEV;
6982 	}
6983 
6984 	return 0;
6985 }
6986 
6987 /**
6988  * megasas_set_dma_mask -	Set DMA mask for supported controllers
6989  *
6990  * @instance:		Adapter soft state
6991  * Description:
6992  *
6993  * For Ventura, driver/FW will operate in 63bit DMA addresses.
6994  *
6995  * For invader-
6996  *	By default, driver/FW will operate in 32bit DMA addresses
6997  *	for consistent DMA mapping but if 32 bit consistent
6998  *	DMA mask fails, driver will try with 63 bit consistent
6999  *	mask provided FW is true 63bit DMA capable
7000  *
7001  * For older controllers(Thunderbolt and MFI based adapters)-
7002  *	driver/FW will operate in 32 bit consistent DMA addresses.
7003  */
7004 static int
7005 megasas_set_dma_mask(struct megasas_instance *instance)
7006 {
7007 	u64 consistent_mask;
7008 	struct pci_dev *pdev;
7009 	u32 scratch_pad_1;
7010 
7011 	pdev = instance->pdev;
7012 	consistent_mask = (instance->adapter_type >= VENTURA_SERIES) ?
7013 				DMA_BIT_MASK(63) : DMA_BIT_MASK(32);
7014 
7015 	if (IS_DMA64) {
7016 		if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(63)) &&
7017 		    dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)))
7018 			goto fail_set_dma_mask;
7019 
7020 		if ((*pdev->dev.dma_mask == DMA_BIT_MASK(63)) &&
7021 		    (dma_set_coherent_mask(&pdev->dev, consistent_mask) &&
7022 		     dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)))) {
7023 			/*
7024 			 * If 32 bit DMA mask fails, then try for 64 bit mask
7025 			 * for FW capable of handling 64 bit DMA.
7026 			 */
7027 			scratch_pad_1 = megasas_readl
7028 				(instance, &instance->reg_set->outbound_scratch_pad_1);
7029 
7030 			if (!(scratch_pad_1 & MR_CAN_HANDLE_64_BIT_DMA_OFFSET))
7031 				goto fail_set_dma_mask;
7032 			else if (dma_set_mask_and_coherent(&pdev->dev,
7033 							   DMA_BIT_MASK(63)))
7034 				goto fail_set_dma_mask;
7035 		}
7036 	} else if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)))
7037 		goto fail_set_dma_mask;
7038 
7039 	if (pdev->dev.coherent_dma_mask == DMA_BIT_MASK(32))
7040 		instance->consistent_mask_64bit = false;
7041 	else
7042 		instance->consistent_mask_64bit = true;
7043 
7044 	dev_info(&pdev->dev, "%s bit DMA mask and %s bit consistent mask\n",
7045 		 ((*pdev->dev.dma_mask == DMA_BIT_MASK(63)) ? "63" : "32"),
7046 		 (instance->consistent_mask_64bit ? "63" : "32"));
7047 
7048 	return 0;
7049 
7050 fail_set_dma_mask:
7051 	dev_err(&pdev->dev, "Failed to set DMA mask\n");
7052 	return -1;
7053 
7054 }
7055 
7056 /*
7057  * megasas_set_adapter_type -	Set adapter type.
7058  *				Supported controllers can be divided in
7059  *				different categories-
7060  *					enum MR_ADAPTER_TYPE {
7061  *						MFI_SERIES = 1,
7062  *						THUNDERBOLT_SERIES = 2,
7063  *						INVADER_SERIES = 3,
7064  *						VENTURA_SERIES = 4,
7065  *						AERO_SERIES = 5,
7066  *					};
7067  * @instance:			Adapter soft state
7068  * return:			void
7069  */
7070 static inline void megasas_set_adapter_type(struct megasas_instance *instance)
7071 {
7072 	if ((instance->pdev->vendor == PCI_VENDOR_ID_DELL) &&
7073 	    (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5)) {
7074 		instance->adapter_type = MFI_SERIES;
7075 	} else {
7076 		switch (instance->pdev->device) {
7077 		case PCI_DEVICE_ID_LSI_AERO_10E1:
7078 		case PCI_DEVICE_ID_LSI_AERO_10E2:
7079 		case PCI_DEVICE_ID_LSI_AERO_10E5:
7080 		case PCI_DEVICE_ID_LSI_AERO_10E6:
7081 			instance->adapter_type = AERO_SERIES;
7082 			break;
7083 		case PCI_DEVICE_ID_LSI_VENTURA:
7084 		case PCI_DEVICE_ID_LSI_CRUSADER:
7085 		case PCI_DEVICE_ID_LSI_HARPOON:
7086 		case PCI_DEVICE_ID_LSI_TOMCAT:
7087 		case PCI_DEVICE_ID_LSI_VENTURA_4PORT:
7088 		case PCI_DEVICE_ID_LSI_CRUSADER_4PORT:
7089 			instance->adapter_type = VENTURA_SERIES;
7090 			break;
7091 		case PCI_DEVICE_ID_LSI_FUSION:
7092 		case PCI_DEVICE_ID_LSI_PLASMA:
7093 			instance->adapter_type = THUNDERBOLT_SERIES;
7094 			break;
7095 		case PCI_DEVICE_ID_LSI_INVADER:
7096 		case PCI_DEVICE_ID_LSI_INTRUDER:
7097 		case PCI_DEVICE_ID_LSI_INTRUDER_24:
7098 		case PCI_DEVICE_ID_LSI_CUTLASS_52:
7099 		case PCI_DEVICE_ID_LSI_CUTLASS_53:
7100 		case PCI_DEVICE_ID_LSI_FURY:
7101 			instance->adapter_type = INVADER_SERIES;
7102 			break;
7103 		default: /* For all other supported controllers */
7104 			instance->adapter_type = MFI_SERIES;
7105 			break;
7106 		}
7107 	}
7108 }
7109 
7110 static inline int megasas_alloc_mfi_ctrl_mem(struct megasas_instance *instance)
7111 {
7112 	instance->producer = dma_alloc_coherent(&instance->pdev->dev,
7113 			sizeof(u32), &instance->producer_h, GFP_KERNEL);
7114 	instance->consumer = dma_alloc_coherent(&instance->pdev->dev,
7115 			sizeof(u32), &instance->consumer_h, GFP_KERNEL);
7116 
7117 	if (!instance->producer || !instance->consumer) {
7118 		dev_err(&instance->pdev->dev,
7119 			"Failed to allocate memory for producer, consumer\n");
7120 		return -1;
7121 	}
7122 
7123 	*instance->producer = 0;
7124 	*instance->consumer = 0;
7125 	return 0;
7126 }
7127 
7128 /**
7129  * megasas_alloc_ctrl_mem -	Allocate per controller memory for core data
7130  *				structures which are not common across MFI
7131  *				adapters and fusion adapters.
7132  *				For MFI based adapters, allocate producer and
7133  *				consumer buffers. For fusion adapters, allocate
7134  *				memory for fusion context.
7135  * @instance:			Adapter soft state
7136  * return:			0 for SUCCESS
7137  */
7138 static int megasas_alloc_ctrl_mem(struct megasas_instance *instance)
7139 {
7140 	instance->reply_map = kcalloc(nr_cpu_ids, sizeof(unsigned int),
7141 				      GFP_KERNEL);
7142 	if (!instance->reply_map)
7143 		return -ENOMEM;
7144 
7145 	switch (instance->adapter_type) {
7146 	case MFI_SERIES:
7147 		if (megasas_alloc_mfi_ctrl_mem(instance))
7148 			return -ENOMEM;
7149 		break;
7150 	case AERO_SERIES:
7151 	case VENTURA_SERIES:
7152 	case THUNDERBOLT_SERIES:
7153 	case INVADER_SERIES:
7154 		if (megasas_alloc_fusion_context(instance))
7155 			return -ENOMEM;
7156 		break;
7157 	}
7158 
7159 	return 0;
7160 }
7161 
7162 /*
7163  * megasas_free_ctrl_mem -	Free fusion context for fusion adapters and
7164  *				producer, consumer buffers for MFI adapters
7165  *
7166  * @instance -			Adapter soft instance
7167  *
7168  */
7169 static inline void megasas_free_ctrl_mem(struct megasas_instance *instance)
7170 {
7171 	kfree(instance->reply_map);
7172 	if (instance->adapter_type == MFI_SERIES) {
7173 		if (instance->producer)
7174 			dma_free_coherent(&instance->pdev->dev, sizeof(u32),
7175 					    instance->producer,
7176 					    instance->producer_h);
7177 		if (instance->consumer)
7178 			dma_free_coherent(&instance->pdev->dev, sizeof(u32),
7179 					    instance->consumer,
7180 					    instance->consumer_h);
7181 	} else {
7182 		megasas_free_fusion_context(instance);
7183 	}
7184 }
7185 
7186 /**
7187  * megasas_alloc_ctrl_dma_buffers -	Allocate consistent DMA buffers during
7188  *					driver load time
7189  *
7190  * @instance:				Adapter soft instance
7191  *
7192  * @return:				O for SUCCESS
7193  */
7194 static inline
7195 int megasas_alloc_ctrl_dma_buffers(struct megasas_instance *instance)
7196 {
7197 	struct pci_dev *pdev = instance->pdev;
7198 	struct fusion_context *fusion = instance->ctrl_context;
7199 
7200 	instance->evt_detail = dma_alloc_coherent(&pdev->dev,
7201 			sizeof(struct megasas_evt_detail),
7202 			&instance->evt_detail_h, GFP_KERNEL);
7203 
7204 	if (!instance->evt_detail) {
7205 		dev_err(&instance->pdev->dev,
7206 			"Failed to allocate event detail buffer\n");
7207 		return -ENOMEM;
7208 	}
7209 
7210 	if (fusion) {
7211 		fusion->ioc_init_request =
7212 			dma_alloc_coherent(&pdev->dev,
7213 					   sizeof(struct MPI2_IOC_INIT_REQUEST),
7214 					   &fusion->ioc_init_request_phys,
7215 					   GFP_KERNEL);
7216 
7217 		if (!fusion->ioc_init_request) {
7218 			dev_err(&pdev->dev,
7219 				"Failed to allocate ioc init request\n");
7220 			return -ENOMEM;
7221 		}
7222 
7223 		instance->snapdump_prop = dma_alloc_coherent(&pdev->dev,
7224 				sizeof(struct MR_SNAPDUMP_PROPERTIES),
7225 				&instance->snapdump_prop_h, GFP_KERNEL);
7226 
7227 		if (!instance->snapdump_prop)
7228 			dev_err(&pdev->dev,
7229 				"Failed to allocate snapdump properties buffer\n");
7230 
7231 		instance->host_device_list_buf = dma_alloc_coherent(&pdev->dev,
7232 							HOST_DEVICE_LIST_SZ,
7233 							&instance->host_device_list_buf_h,
7234 							GFP_KERNEL);
7235 
7236 		if (!instance->host_device_list_buf) {
7237 			dev_err(&pdev->dev,
7238 				"Failed to allocate targetid list buffer\n");
7239 			return -ENOMEM;
7240 		}
7241 
7242 	}
7243 
7244 	instance->pd_list_buf =
7245 		dma_alloc_coherent(&pdev->dev,
7246 				     MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
7247 				     &instance->pd_list_buf_h, GFP_KERNEL);
7248 
7249 	if (!instance->pd_list_buf) {
7250 		dev_err(&pdev->dev, "Failed to allocate PD list buffer\n");
7251 		return -ENOMEM;
7252 	}
7253 
7254 	instance->ctrl_info_buf =
7255 		dma_alloc_coherent(&pdev->dev,
7256 				     sizeof(struct megasas_ctrl_info),
7257 				     &instance->ctrl_info_buf_h, GFP_KERNEL);
7258 
7259 	if (!instance->ctrl_info_buf) {
7260 		dev_err(&pdev->dev,
7261 			"Failed to allocate controller info buffer\n");
7262 		return -ENOMEM;
7263 	}
7264 
7265 	instance->ld_list_buf =
7266 		dma_alloc_coherent(&pdev->dev,
7267 				     sizeof(struct MR_LD_LIST),
7268 				     &instance->ld_list_buf_h, GFP_KERNEL);
7269 
7270 	if (!instance->ld_list_buf) {
7271 		dev_err(&pdev->dev, "Failed to allocate LD list buffer\n");
7272 		return -ENOMEM;
7273 	}
7274 
7275 	instance->ld_targetid_list_buf =
7276 		dma_alloc_coherent(&pdev->dev,
7277 				sizeof(struct MR_LD_TARGETID_LIST),
7278 				&instance->ld_targetid_list_buf_h, GFP_KERNEL);
7279 
7280 	if (!instance->ld_targetid_list_buf) {
7281 		dev_err(&pdev->dev,
7282 			"Failed to allocate LD targetid list buffer\n");
7283 		return -ENOMEM;
7284 	}
7285 
7286 	if (!reset_devices) {
7287 		instance->system_info_buf =
7288 			dma_alloc_coherent(&pdev->dev,
7289 					sizeof(struct MR_DRV_SYSTEM_INFO),
7290 					&instance->system_info_h, GFP_KERNEL);
7291 		instance->pd_info =
7292 			dma_alloc_coherent(&pdev->dev,
7293 					sizeof(struct MR_PD_INFO),
7294 					&instance->pd_info_h, GFP_KERNEL);
7295 		instance->tgt_prop =
7296 			dma_alloc_coherent(&pdev->dev,
7297 					sizeof(struct MR_TARGET_PROPERTIES),
7298 					&instance->tgt_prop_h, GFP_KERNEL);
7299 		instance->crash_dump_buf =
7300 			dma_alloc_coherent(&pdev->dev, CRASH_DMA_BUF_SIZE,
7301 					&instance->crash_dump_h, GFP_KERNEL);
7302 
7303 		if (!instance->system_info_buf)
7304 			dev_err(&instance->pdev->dev,
7305 				"Failed to allocate system info buffer\n");
7306 
7307 		if (!instance->pd_info)
7308 			dev_err(&instance->pdev->dev,
7309 				"Failed to allocate pd_info buffer\n");
7310 
7311 		if (!instance->tgt_prop)
7312 			dev_err(&instance->pdev->dev,
7313 				"Failed to allocate tgt_prop buffer\n");
7314 
7315 		if (!instance->crash_dump_buf)
7316 			dev_err(&instance->pdev->dev,
7317 				"Failed to allocate crash dump buffer\n");
7318 	}
7319 
7320 	return 0;
7321 }
7322 
7323 /*
7324  * megasas_free_ctrl_dma_buffers -	Free consistent DMA buffers allocated
7325  *					during driver load time
7326  *
7327  * @instance-				Adapter soft instance
7328  *
7329  */
7330 static inline
7331 void megasas_free_ctrl_dma_buffers(struct megasas_instance *instance)
7332 {
7333 	struct pci_dev *pdev = instance->pdev;
7334 	struct fusion_context *fusion = instance->ctrl_context;
7335 
7336 	if (instance->evt_detail)
7337 		dma_free_coherent(&pdev->dev, sizeof(struct megasas_evt_detail),
7338 				    instance->evt_detail,
7339 				    instance->evt_detail_h);
7340 
7341 	if (fusion && fusion->ioc_init_request)
7342 		dma_free_coherent(&pdev->dev,
7343 				  sizeof(struct MPI2_IOC_INIT_REQUEST),
7344 				  fusion->ioc_init_request,
7345 				  fusion->ioc_init_request_phys);
7346 
7347 	if (instance->pd_list_buf)
7348 		dma_free_coherent(&pdev->dev,
7349 				    MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
7350 				    instance->pd_list_buf,
7351 				    instance->pd_list_buf_h);
7352 
7353 	if (instance->ld_list_buf)
7354 		dma_free_coherent(&pdev->dev, sizeof(struct MR_LD_LIST),
7355 				    instance->ld_list_buf,
7356 				    instance->ld_list_buf_h);
7357 
7358 	if (instance->ld_targetid_list_buf)
7359 		dma_free_coherent(&pdev->dev, sizeof(struct MR_LD_TARGETID_LIST),
7360 				    instance->ld_targetid_list_buf,
7361 				    instance->ld_targetid_list_buf_h);
7362 
7363 	if (instance->ctrl_info_buf)
7364 		dma_free_coherent(&pdev->dev, sizeof(struct megasas_ctrl_info),
7365 				    instance->ctrl_info_buf,
7366 				    instance->ctrl_info_buf_h);
7367 
7368 	if (instance->system_info_buf)
7369 		dma_free_coherent(&pdev->dev, sizeof(struct MR_DRV_SYSTEM_INFO),
7370 				    instance->system_info_buf,
7371 				    instance->system_info_h);
7372 
7373 	if (instance->pd_info)
7374 		dma_free_coherent(&pdev->dev, sizeof(struct MR_PD_INFO),
7375 				    instance->pd_info, instance->pd_info_h);
7376 
7377 	if (instance->tgt_prop)
7378 		dma_free_coherent(&pdev->dev, sizeof(struct MR_TARGET_PROPERTIES),
7379 				    instance->tgt_prop, instance->tgt_prop_h);
7380 
7381 	if (instance->crash_dump_buf)
7382 		dma_free_coherent(&pdev->dev, CRASH_DMA_BUF_SIZE,
7383 				    instance->crash_dump_buf,
7384 				    instance->crash_dump_h);
7385 
7386 	if (instance->snapdump_prop)
7387 		dma_free_coherent(&pdev->dev,
7388 				  sizeof(struct MR_SNAPDUMP_PROPERTIES),
7389 				  instance->snapdump_prop,
7390 				  instance->snapdump_prop_h);
7391 
7392 	if (instance->host_device_list_buf)
7393 		dma_free_coherent(&pdev->dev,
7394 				  HOST_DEVICE_LIST_SZ,
7395 				  instance->host_device_list_buf,
7396 				  instance->host_device_list_buf_h);
7397 
7398 }
7399 
7400 /*
7401  * megasas_init_ctrl_params -		Initialize controller's instance
7402  *					parameters before FW init
7403  * @instance -				Adapter soft instance
7404  * @return -				void
7405  */
7406 static inline void megasas_init_ctrl_params(struct megasas_instance *instance)
7407 {
7408 	instance->fw_crash_state = UNAVAILABLE;
7409 
7410 	megasas_poll_wait_aen = 0;
7411 	instance->issuepend_done = 1;
7412 	atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
7413 
7414 	/*
7415 	 * Initialize locks and queues
7416 	 */
7417 	INIT_LIST_HEAD(&instance->cmd_pool);
7418 	INIT_LIST_HEAD(&instance->internal_reset_pending_q);
7419 
7420 	atomic_set(&instance->fw_outstanding, 0);
7421 	atomic64_set(&instance->total_io_count, 0);
7422 
7423 	init_waitqueue_head(&instance->int_cmd_wait_q);
7424 	init_waitqueue_head(&instance->abort_cmd_wait_q);
7425 
7426 	spin_lock_init(&instance->crashdump_lock);
7427 	spin_lock_init(&instance->mfi_pool_lock);
7428 	spin_lock_init(&instance->hba_lock);
7429 	spin_lock_init(&instance->stream_lock);
7430 	spin_lock_init(&instance->completion_lock);
7431 
7432 	mutex_init(&instance->reset_mutex);
7433 
7434 	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
7435 	    (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY))
7436 		instance->flag_ieee = 1;
7437 
7438 	instance->flag = 0;
7439 	instance->unload = 1;
7440 	instance->last_time = 0;
7441 	instance->disableOnlineCtrlReset = 1;
7442 	instance->UnevenSpanSupport = 0;
7443 	instance->smp_affinity_enable = smp_affinity_enable ? true : false;
7444 	instance->msix_load_balance = false;
7445 
7446 	if (instance->adapter_type != MFI_SERIES)
7447 		INIT_WORK(&instance->work_init, megasas_fusion_ocr_wq);
7448 	else
7449 		INIT_WORK(&instance->work_init, process_fw_state_change_wq);
7450 }
7451 
7452 /**
7453  * megasas_probe_one -	PCI hotplug entry point
7454  * @pdev:		PCI device structure
7455  * @id:			PCI ids of supported hotplugged adapter
7456  */
7457 static int megasas_probe_one(struct pci_dev *pdev,
7458 			     const struct pci_device_id *id)
7459 {
7460 	int rval, pos;
7461 	struct Scsi_Host *host;
7462 	struct megasas_instance *instance;
7463 	u16 control = 0;
7464 
7465 	switch (pdev->device) {
7466 	case PCI_DEVICE_ID_LSI_AERO_10E0:
7467 	case PCI_DEVICE_ID_LSI_AERO_10E3:
7468 	case PCI_DEVICE_ID_LSI_AERO_10E4:
7469 	case PCI_DEVICE_ID_LSI_AERO_10E7:
7470 		dev_err(&pdev->dev, "Adapter is in non secure mode\n");
7471 		return 1;
7472 	case PCI_DEVICE_ID_LSI_AERO_10E1:
7473 	case PCI_DEVICE_ID_LSI_AERO_10E5:
7474 		dev_info(&pdev->dev, "Adapter is in configurable secure mode\n");
7475 		break;
7476 	}
7477 
7478 	/* Reset MSI-X in the kdump kernel */
7479 	if (reset_devices) {
7480 		pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
7481 		if (pos) {
7482 			pci_read_config_word(pdev, pos + PCI_MSIX_FLAGS,
7483 					     &control);
7484 			if (control & PCI_MSIX_FLAGS_ENABLE) {
7485 				dev_info(&pdev->dev, "resetting MSI-X\n");
7486 				pci_write_config_word(pdev,
7487 						      pos + PCI_MSIX_FLAGS,
7488 						      control &
7489 						      ~PCI_MSIX_FLAGS_ENABLE);
7490 			}
7491 		}
7492 	}
7493 
7494 	/*
7495 	 * PCI prepping: enable device set bus mastering and dma mask
7496 	 */
7497 	rval = pci_enable_device_mem(pdev);
7498 
7499 	if (rval) {
7500 		return rval;
7501 	}
7502 
7503 	pci_set_master(pdev);
7504 
7505 	host = scsi_host_alloc(&megasas_template,
7506 			       sizeof(struct megasas_instance));
7507 
7508 	if (!host) {
7509 		dev_printk(KERN_DEBUG, &pdev->dev, "scsi_host_alloc failed\n");
7510 		goto fail_alloc_instance;
7511 	}
7512 
7513 	instance = (struct megasas_instance *)host->hostdata;
7514 	memset(instance, 0, sizeof(*instance));
7515 	atomic_set(&instance->fw_reset_no_pci_access, 0);
7516 
7517 	/*
7518 	 * Initialize PCI related and misc parameters
7519 	 */
7520 	instance->pdev = pdev;
7521 	instance->host = host;
7522 	instance->unique_id = pdev->bus->number << 8 | pdev->devfn;
7523 	instance->init_id = MEGASAS_DEFAULT_INIT_ID;
7524 
7525 	megasas_set_adapter_type(instance);
7526 
7527 	/*
7528 	 * Initialize MFI Firmware
7529 	 */
7530 	if (megasas_init_fw(instance))
7531 		goto fail_init_mfi;
7532 
7533 	if (instance->requestorId) {
7534 		if (instance->PlasmaFW111) {
7535 			instance->vf_affiliation_111 =
7536 				dma_alloc_coherent(&pdev->dev,
7537 					sizeof(struct MR_LD_VF_AFFILIATION_111),
7538 					&instance->vf_affiliation_111_h,
7539 					GFP_KERNEL);
7540 			if (!instance->vf_affiliation_111)
7541 				dev_warn(&pdev->dev, "Can't allocate "
7542 				       "memory for VF affiliation buffer\n");
7543 		} else {
7544 			instance->vf_affiliation =
7545 				dma_alloc_coherent(&pdev->dev,
7546 					(MAX_LOGICAL_DRIVES + 1) *
7547 					sizeof(struct MR_LD_VF_AFFILIATION),
7548 					&instance->vf_affiliation_h,
7549 					GFP_KERNEL);
7550 			if (!instance->vf_affiliation)
7551 				dev_warn(&pdev->dev, "Can't allocate "
7552 				       "memory for VF affiliation buffer\n");
7553 		}
7554 	}
7555 
7556 	/*
7557 	 * Store instance in PCI softstate
7558 	 */
7559 	pci_set_drvdata(pdev, instance);
7560 
7561 	/*
7562 	 * Add this controller to megasas_mgmt_info structure so that it
7563 	 * can be exported to management applications
7564 	 */
7565 	megasas_mgmt_info.count++;
7566 	megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance;
7567 	megasas_mgmt_info.max_index++;
7568 
7569 	/*
7570 	 * Register with SCSI mid-layer
7571 	 */
7572 	if (megasas_io_attach(instance))
7573 		goto fail_io_attach;
7574 
7575 	instance->unload = 0;
7576 	/*
7577 	 * Trigger SCSI to scan our drives
7578 	 */
7579 	if (!instance->enable_fw_dev_list ||
7580 	    (instance->host_device_list_buf->count > 0))
7581 		scsi_scan_host(host);
7582 
7583 	/*
7584 	 * Initiate AEN (Asynchronous Event Notification)
7585 	 */
7586 	if (megasas_start_aen(instance)) {
7587 		dev_printk(KERN_DEBUG, &pdev->dev, "start aen failed\n");
7588 		goto fail_start_aen;
7589 	}
7590 
7591 	megasas_setup_debugfs(instance);
7592 
7593 	/* Get current SR-IOV LD/VF affiliation */
7594 	if (instance->requestorId)
7595 		megasas_get_ld_vf_affiliation(instance, 1);
7596 
7597 	return 0;
7598 
7599 fail_start_aen:
7600 	instance->unload = 1;
7601 	scsi_remove_host(instance->host);
7602 fail_io_attach:
7603 	megasas_mgmt_info.count--;
7604 	megasas_mgmt_info.max_index--;
7605 	megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL;
7606 
7607 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7608 		del_timer_sync(&instance->sriov_heartbeat_timer);
7609 
7610 	instance->instancet->disable_intr(instance);
7611 	megasas_destroy_irqs(instance);
7612 
7613 	if (instance->adapter_type != MFI_SERIES)
7614 		megasas_release_fusion(instance);
7615 	else
7616 		megasas_release_mfi(instance);
7617 
7618 	if (instance->msix_vectors)
7619 		pci_free_irq_vectors(instance->pdev);
7620 	instance->msix_vectors = 0;
7621 
7622 	if (instance->fw_crash_state != UNAVAILABLE)
7623 		megasas_free_host_crash_buffer(instance);
7624 
7625 	if (instance->adapter_type != MFI_SERIES)
7626 		megasas_fusion_stop_watchdog(instance);
7627 fail_init_mfi:
7628 	scsi_host_put(host);
7629 fail_alloc_instance:
7630 	pci_disable_device(pdev);
7631 
7632 	return -ENODEV;
7633 }
7634 
7635 /**
7636  * megasas_flush_cache -	Requests FW to flush all its caches
7637  * @instance:			Adapter soft state
7638  */
7639 static void megasas_flush_cache(struct megasas_instance *instance)
7640 {
7641 	struct megasas_cmd *cmd;
7642 	struct megasas_dcmd_frame *dcmd;
7643 
7644 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
7645 		return;
7646 
7647 	cmd = megasas_get_cmd(instance);
7648 
7649 	if (!cmd)
7650 		return;
7651 
7652 	dcmd = &cmd->frame->dcmd;
7653 
7654 	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
7655 
7656 	dcmd->cmd = MFI_CMD_DCMD;
7657 	dcmd->cmd_status = 0x0;
7658 	dcmd->sge_count = 0;
7659 	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE);
7660 	dcmd->timeout = 0;
7661 	dcmd->pad_0 = 0;
7662 	dcmd->data_xfer_len = 0;
7663 	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_CACHE_FLUSH);
7664 	dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
7665 
7666 	if (megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS)
7667 			!= DCMD_SUCCESS) {
7668 		dev_err(&instance->pdev->dev,
7669 			"return from %s %d\n", __func__, __LINE__);
7670 		return;
7671 	}
7672 
7673 	megasas_return_cmd(instance, cmd);
7674 }
7675 
7676 /**
7677  * megasas_shutdown_controller -	Instructs FW to shutdown the controller
7678  * @instance:				Adapter soft state
7679  * @opcode:				Shutdown/Hibernate
7680  */
7681 static void megasas_shutdown_controller(struct megasas_instance *instance,
7682 					u32 opcode)
7683 {
7684 	struct megasas_cmd *cmd;
7685 	struct megasas_dcmd_frame *dcmd;
7686 
7687 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
7688 		return;
7689 
7690 	cmd = megasas_get_cmd(instance);
7691 
7692 	if (!cmd)
7693 		return;
7694 
7695 	if (instance->aen_cmd)
7696 		megasas_issue_blocked_abort_cmd(instance,
7697 			instance->aen_cmd, MFI_IO_TIMEOUT_SECS);
7698 	if (instance->map_update_cmd)
7699 		megasas_issue_blocked_abort_cmd(instance,
7700 			instance->map_update_cmd, MFI_IO_TIMEOUT_SECS);
7701 	if (instance->jbod_seq_cmd)
7702 		megasas_issue_blocked_abort_cmd(instance,
7703 			instance->jbod_seq_cmd, MFI_IO_TIMEOUT_SECS);
7704 
7705 	dcmd = &cmd->frame->dcmd;
7706 
7707 	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
7708 
7709 	dcmd->cmd = MFI_CMD_DCMD;
7710 	dcmd->cmd_status = 0x0;
7711 	dcmd->sge_count = 0;
7712 	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE);
7713 	dcmd->timeout = 0;
7714 	dcmd->pad_0 = 0;
7715 	dcmd->data_xfer_len = 0;
7716 	dcmd->opcode = cpu_to_le32(opcode);
7717 
7718 	if (megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS)
7719 			!= DCMD_SUCCESS) {
7720 		dev_err(&instance->pdev->dev,
7721 			"return from %s %d\n", __func__, __LINE__);
7722 		return;
7723 	}
7724 
7725 	megasas_return_cmd(instance, cmd);
7726 }
7727 
7728 /**
7729  * megasas_suspend -	driver suspend entry point
7730  * @dev:		Device structure
7731  */
7732 static int __maybe_unused
7733 megasas_suspend(struct device *dev)
7734 {
7735 	struct megasas_instance *instance;
7736 
7737 	instance = dev_get_drvdata(dev);
7738 
7739 	if (!instance)
7740 		return 0;
7741 
7742 	instance->unload = 1;
7743 
7744 	dev_info(dev, "%s is called\n", __func__);
7745 
7746 	/* Shutdown SR-IOV heartbeat timer */
7747 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7748 		del_timer_sync(&instance->sriov_heartbeat_timer);
7749 
7750 	/* Stop the FW fault detection watchdog */
7751 	if (instance->adapter_type != MFI_SERIES)
7752 		megasas_fusion_stop_watchdog(instance);
7753 
7754 	megasas_flush_cache(instance);
7755 	megasas_shutdown_controller(instance, MR_DCMD_HIBERNATE_SHUTDOWN);
7756 
7757 	/* cancel the delayed work if this work still in queue */
7758 	if (instance->ev != NULL) {
7759 		struct megasas_aen_event *ev = instance->ev;
7760 		cancel_delayed_work_sync(&ev->hotplug_work);
7761 		instance->ev = NULL;
7762 	}
7763 
7764 	tasklet_kill(&instance->isr_tasklet);
7765 
7766 	pci_set_drvdata(instance->pdev, instance);
7767 	instance->instancet->disable_intr(instance);
7768 
7769 	megasas_destroy_irqs(instance);
7770 
7771 	if (instance->msix_vectors)
7772 		pci_free_irq_vectors(instance->pdev);
7773 
7774 	return 0;
7775 }
7776 
7777 /**
7778  * megasas_resume-      driver resume entry point
7779  * @dev:		Device structure
7780  */
7781 static int __maybe_unused
7782 megasas_resume(struct device *dev)
7783 {
7784 	int rval;
7785 	struct Scsi_Host *host;
7786 	struct megasas_instance *instance;
7787 	u32 status_reg;
7788 
7789 	instance = dev_get_drvdata(dev);
7790 
7791 	if (!instance)
7792 		return 0;
7793 
7794 	host = instance->host;
7795 
7796 	dev_info(dev, "%s is called\n", __func__);
7797 
7798 	/*
7799 	 * We expect the FW state to be READY
7800 	 */
7801 
7802 	if (megasas_transition_to_ready(instance, 0)) {
7803 		dev_info(&instance->pdev->dev,
7804 			 "Failed to transition controller to ready from %s!\n",
7805 			 __func__);
7806 		if (instance->adapter_type != MFI_SERIES) {
7807 			status_reg =
7808 				instance->instancet->read_fw_status_reg(instance);
7809 			if (!(status_reg & MFI_RESET_ADAPTER) ||
7810 				((megasas_adp_reset_wait_for_ready
7811 				(instance, true, 0)) == FAILED))
7812 				goto fail_ready_state;
7813 		} else {
7814 			atomic_set(&instance->fw_reset_no_pci_access, 1);
7815 			instance->instancet->adp_reset
7816 				(instance, instance->reg_set);
7817 			atomic_set(&instance->fw_reset_no_pci_access, 0);
7818 
7819 			/* waiting for about 30 seconds before retry */
7820 			ssleep(30);
7821 
7822 			if (megasas_transition_to_ready(instance, 0))
7823 				goto fail_ready_state;
7824 		}
7825 
7826 		dev_info(&instance->pdev->dev,
7827 			 "FW restarted successfully from %s!\n",
7828 			 __func__);
7829 	}
7830 	if (megasas_set_dma_mask(instance))
7831 		goto fail_set_dma_mask;
7832 
7833 	/*
7834 	 * Initialize MFI Firmware
7835 	 */
7836 
7837 	atomic_set(&instance->fw_outstanding, 0);
7838 	atomic_set(&instance->ldio_outstanding, 0);
7839 
7840 	/* Now re-enable MSI-X */
7841 	if (instance->msix_vectors)
7842 		megasas_alloc_irq_vectors(instance);
7843 
7844 	if (!instance->msix_vectors) {
7845 		rval = pci_alloc_irq_vectors(instance->pdev, 1, 1,
7846 					     PCI_IRQ_LEGACY);
7847 		if (rval < 0)
7848 			goto fail_reenable_msix;
7849 	}
7850 
7851 	megasas_setup_reply_map(instance);
7852 
7853 	if (instance->adapter_type != MFI_SERIES) {
7854 		megasas_reset_reply_desc(instance);
7855 		if (megasas_ioc_init_fusion(instance)) {
7856 			megasas_free_cmds(instance);
7857 			megasas_free_cmds_fusion(instance);
7858 			goto fail_init_mfi;
7859 		}
7860 		if (!megasas_get_map_info(instance))
7861 			megasas_sync_map_info(instance);
7862 	} else {
7863 		*instance->producer = 0;
7864 		*instance->consumer = 0;
7865 		if (megasas_issue_init_mfi(instance))
7866 			goto fail_init_mfi;
7867 	}
7868 
7869 	if (megasas_get_ctrl_info(instance) != DCMD_SUCCESS)
7870 		goto fail_init_mfi;
7871 
7872 	tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
7873 		     (unsigned long)instance);
7874 
7875 	if (instance->msix_vectors ?
7876 			megasas_setup_irqs_msix(instance, 0) :
7877 			megasas_setup_irqs_ioapic(instance))
7878 		goto fail_init_mfi;
7879 
7880 	if (instance->adapter_type != MFI_SERIES)
7881 		megasas_setup_irq_poll(instance);
7882 
7883 	/* Re-launch SR-IOV heartbeat timer */
7884 	if (instance->requestorId) {
7885 		if (!megasas_sriov_start_heartbeat(instance, 0))
7886 			megasas_start_timer(instance);
7887 		else {
7888 			instance->skip_heartbeat_timer_del = 1;
7889 			goto fail_init_mfi;
7890 		}
7891 	}
7892 
7893 	instance->instancet->enable_intr(instance);
7894 	megasas_setup_jbod_map(instance);
7895 	instance->unload = 0;
7896 
7897 	/*
7898 	 * Initiate AEN (Asynchronous Event Notification)
7899 	 */
7900 	if (megasas_start_aen(instance))
7901 		dev_err(&instance->pdev->dev, "Start AEN failed\n");
7902 
7903 	/* Re-launch FW fault watchdog */
7904 	if (instance->adapter_type != MFI_SERIES)
7905 		if (megasas_fusion_start_watchdog(instance) != SUCCESS)
7906 			goto fail_start_watchdog;
7907 
7908 	return 0;
7909 
7910 fail_start_watchdog:
7911 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7912 		del_timer_sync(&instance->sriov_heartbeat_timer);
7913 fail_init_mfi:
7914 	megasas_free_ctrl_dma_buffers(instance);
7915 	megasas_free_ctrl_mem(instance);
7916 	scsi_host_put(host);
7917 
7918 fail_reenable_msix:
7919 fail_set_dma_mask:
7920 fail_ready_state:
7921 
7922 	return -ENODEV;
7923 }
7924 
7925 static inline int
7926 megasas_wait_for_adapter_operational(struct megasas_instance *instance)
7927 {
7928 	int wait_time = MEGASAS_RESET_WAIT_TIME * 2;
7929 	int i;
7930 	u8 adp_state;
7931 
7932 	for (i = 0; i < wait_time; i++) {
7933 		adp_state = atomic_read(&instance->adprecovery);
7934 		if ((adp_state == MEGASAS_HBA_OPERATIONAL) ||
7935 		    (adp_state == MEGASAS_HW_CRITICAL_ERROR))
7936 			break;
7937 
7938 		if (!(i % MEGASAS_RESET_NOTICE_INTERVAL))
7939 			dev_notice(&instance->pdev->dev, "waiting for controller reset to finish\n");
7940 
7941 		msleep(1000);
7942 	}
7943 
7944 	if (adp_state != MEGASAS_HBA_OPERATIONAL) {
7945 		dev_info(&instance->pdev->dev,
7946 			 "%s HBA failed to become operational, adp_state %d\n",
7947 			 __func__, adp_state);
7948 		return 1;
7949 	}
7950 
7951 	return 0;
7952 }
7953 
7954 /**
7955  * megasas_detach_one -	PCI hot"un"plug entry point
7956  * @pdev:		PCI device structure
7957  */
7958 static void megasas_detach_one(struct pci_dev *pdev)
7959 {
7960 	int i;
7961 	struct Scsi_Host *host;
7962 	struct megasas_instance *instance;
7963 	struct fusion_context *fusion;
7964 	size_t pd_seq_map_sz;
7965 
7966 	instance = pci_get_drvdata(pdev);
7967 
7968 	if (!instance)
7969 		return;
7970 
7971 	host = instance->host;
7972 	fusion = instance->ctrl_context;
7973 
7974 	/* Shutdown SR-IOV heartbeat timer */
7975 	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7976 		del_timer_sync(&instance->sriov_heartbeat_timer);
7977 
7978 	/* Stop the FW fault detection watchdog */
7979 	if (instance->adapter_type != MFI_SERIES)
7980 		megasas_fusion_stop_watchdog(instance);
7981 
7982 	if (instance->fw_crash_state != UNAVAILABLE)
7983 		megasas_free_host_crash_buffer(instance);
7984 	scsi_remove_host(instance->host);
7985 	instance->unload = 1;
7986 
7987 	if (megasas_wait_for_adapter_operational(instance))
7988 		goto skip_firing_dcmds;
7989 
7990 	megasas_flush_cache(instance);
7991 	megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
7992 
7993 skip_firing_dcmds:
7994 	/* cancel the delayed work if this work still in queue*/
7995 	if (instance->ev != NULL) {
7996 		struct megasas_aen_event *ev = instance->ev;
7997 		cancel_delayed_work_sync(&ev->hotplug_work);
7998 		instance->ev = NULL;
7999 	}
8000 
8001 	/* cancel all wait events */
8002 	wake_up_all(&instance->int_cmd_wait_q);
8003 
8004 	tasklet_kill(&instance->isr_tasklet);
8005 
8006 	/*
8007 	 * Take the instance off the instance array. Note that we will not
8008 	 * decrement the max_index. We let this array be sparse array
8009 	 */
8010 	for (i = 0; i < megasas_mgmt_info.max_index; i++) {
8011 		if (megasas_mgmt_info.instance[i] == instance) {
8012 			megasas_mgmt_info.count--;
8013 			megasas_mgmt_info.instance[i] = NULL;
8014 
8015 			break;
8016 		}
8017 	}
8018 
8019 	instance->instancet->disable_intr(instance);
8020 
8021 	megasas_destroy_irqs(instance);
8022 
8023 	if (instance->msix_vectors)
8024 		pci_free_irq_vectors(instance->pdev);
8025 
8026 	if (instance->adapter_type >= VENTURA_SERIES) {
8027 		for (i = 0; i < MAX_LOGICAL_DRIVES_EXT; ++i)
8028 			kfree(fusion->stream_detect_by_ld[i]);
8029 		kfree(fusion->stream_detect_by_ld);
8030 		fusion->stream_detect_by_ld = NULL;
8031 	}
8032 
8033 
8034 	if (instance->adapter_type != MFI_SERIES) {
8035 		megasas_release_fusion(instance);
8036 		pd_seq_map_sz =
8037 			struct_size((struct MR_PD_CFG_SEQ_NUM_SYNC *)0,
8038 				    seq, MAX_PHYSICAL_DEVICES);
8039 		for (i = 0; i < 2 ; i++) {
8040 			if (fusion->ld_map[i])
8041 				dma_free_coherent(&instance->pdev->dev,
8042 						  fusion->max_map_sz,
8043 						  fusion->ld_map[i],
8044 						  fusion->ld_map_phys[i]);
8045 			if (fusion->ld_drv_map[i]) {
8046 				if (is_vmalloc_addr(fusion->ld_drv_map[i]))
8047 					vfree(fusion->ld_drv_map[i]);
8048 				else
8049 					free_pages((ulong)fusion->ld_drv_map[i],
8050 						   fusion->drv_map_pages);
8051 			}
8052 
8053 			if (fusion->pd_seq_sync[i])
8054 				dma_free_coherent(&instance->pdev->dev,
8055 					pd_seq_map_sz,
8056 					fusion->pd_seq_sync[i],
8057 					fusion->pd_seq_phys[i]);
8058 		}
8059 	} else {
8060 		megasas_release_mfi(instance);
8061 	}
8062 
8063 	if (instance->vf_affiliation)
8064 		dma_free_coherent(&pdev->dev, (MAX_LOGICAL_DRIVES + 1) *
8065 				    sizeof(struct MR_LD_VF_AFFILIATION),
8066 				    instance->vf_affiliation,
8067 				    instance->vf_affiliation_h);
8068 
8069 	if (instance->vf_affiliation_111)
8070 		dma_free_coherent(&pdev->dev,
8071 				    sizeof(struct MR_LD_VF_AFFILIATION_111),
8072 				    instance->vf_affiliation_111,
8073 				    instance->vf_affiliation_111_h);
8074 
8075 	if (instance->hb_host_mem)
8076 		dma_free_coherent(&pdev->dev, sizeof(struct MR_CTRL_HB_HOST_MEM),
8077 				    instance->hb_host_mem,
8078 				    instance->hb_host_mem_h);
8079 
8080 	megasas_free_ctrl_dma_buffers(instance);
8081 
8082 	megasas_free_ctrl_mem(instance);
8083 
8084 	megasas_destroy_debugfs(instance);
8085 
8086 	scsi_host_put(host);
8087 
8088 	pci_disable_device(pdev);
8089 }
8090 
8091 /**
8092  * megasas_shutdown -	Shutdown entry point
8093  * @pdev:		PCI device structure
8094  */
8095 static void megasas_shutdown(struct pci_dev *pdev)
8096 {
8097 	struct megasas_instance *instance = pci_get_drvdata(pdev);
8098 
8099 	if (!instance)
8100 		return;
8101 
8102 	instance->unload = 1;
8103 
8104 	if (megasas_wait_for_adapter_operational(instance))
8105 		goto skip_firing_dcmds;
8106 
8107 	megasas_flush_cache(instance);
8108 	megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
8109 
8110 skip_firing_dcmds:
8111 	instance->instancet->disable_intr(instance);
8112 	megasas_destroy_irqs(instance);
8113 
8114 	if (instance->msix_vectors)
8115 		pci_free_irq_vectors(instance->pdev);
8116 }
8117 
8118 /*
8119  * megasas_mgmt_open -	char node "open" entry point
8120  * @inode:	char node inode
8121  * @filep:	char node file
8122  */
8123 static int megasas_mgmt_open(struct inode *inode, struct file *filep)
8124 {
8125 	/*
8126 	 * Allow only those users with admin rights
8127 	 */
8128 	if (!capable(CAP_SYS_ADMIN))
8129 		return -EACCES;
8130 
8131 	return 0;
8132 }
8133 
8134 /*
8135  * megasas_mgmt_fasync -	Async notifier registration from applications
8136  * @fd:		char node file descriptor number
8137  * @filep:	char node file
8138  * @mode:	notifier on/off
8139  *
8140  * This function adds the calling process to a driver global queue. When an
8141  * event occurs, SIGIO will be sent to all processes in this queue.
8142  */
8143 static int megasas_mgmt_fasync(int fd, struct file *filep, int mode)
8144 {
8145 	int rc;
8146 
8147 	mutex_lock(&megasas_async_queue_mutex);
8148 
8149 	rc = fasync_helper(fd, filep, mode, &megasas_async_queue);
8150 
8151 	mutex_unlock(&megasas_async_queue_mutex);
8152 
8153 	if (rc >= 0) {
8154 		/* For sanity check when we get ioctl */
8155 		filep->private_data = filep;
8156 		return 0;
8157 	}
8158 
8159 	printk(KERN_DEBUG "megasas: fasync_helper failed [%d]\n", rc);
8160 
8161 	return rc;
8162 }
8163 
8164 /*
8165  * megasas_mgmt_poll -  char node "poll" entry point
8166  * @filep:	char node file
8167  * @wait:	Events to poll for
8168  */
8169 static __poll_t megasas_mgmt_poll(struct file *file, poll_table *wait)
8170 {
8171 	__poll_t mask;
8172 	unsigned long flags;
8173 
8174 	poll_wait(file, &megasas_poll_wait, wait);
8175 	spin_lock_irqsave(&poll_aen_lock, flags);
8176 	if (megasas_poll_wait_aen)
8177 		mask = (EPOLLIN | EPOLLRDNORM);
8178 	else
8179 		mask = 0;
8180 	megasas_poll_wait_aen = 0;
8181 	spin_unlock_irqrestore(&poll_aen_lock, flags);
8182 	return mask;
8183 }
8184 
8185 /*
8186  * megasas_set_crash_dump_params_ioctl:
8187  *		Send CRASH_DUMP_MODE DCMD to all controllers
8188  * @cmd:	MFI command frame
8189  */
8190 
8191 static int megasas_set_crash_dump_params_ioctl(struct megasas_cmd *cmd)
8192 {
8193 	struct megasas_instance *local_instance;
8194 	int i, error = 0;
8195 	int crash_support;
8196 
8197 	crash_support = cmd->frame->dcmd.mbox.w[0];
8198 
8199 	for (i = 0; i < megasas_mgmt_info.max_index; i++) {
8200 		local_instance = megasas_mgmt_info.instance[i];
8201 		if (local_instance && local_instance->crash_dump_drv_support) {
8202 			if ((atomic_read(&local_instance->adprecovery) ==
8203 				MEGASAS_HBA_OPERATIONAL) &&
8204 				!megasas_set_crash_dump_params(local_instance,
8205 					crash_support)) {
8206 				local_instance->crash_dump_app_support =
8207 					crash_support;
8208 				dev_info(&local_instance->pdev->dev,
8209 					"Application firmware crash "
8210 					"dump mode set success\n");
8211 				error = 0;
8212 			} else {
8213 				dev_info(&local_instance->pdev->dev,
8214 					"Application firmware crash "
8215 					"dump mode set failed\n");
8216 				error = -1;
8217 			}
8218 		}
8219 	}
8220 	return error;
8221 }
8222 
8223 /**
8224  * megasas_mgmt_fw_ioctl -	Issues management ioctls to FW
8225  * @instance:			Adapter soft state
8226  * @user_ioc:			User's ioctl packet
8227  * @ioc:			ioctl packet
8228  */
8229 static int
8230 megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
8231 		      struct megasas_iocpacket __user * user_ioc,
8232 		      struct megasas_iocpacket *ioc)
8233 {
8234 	struct megasas_sge64 *kern_sge64 = NULL;
8235 	struct megasas_sge32 *kern_sge32 = NULL;
8236 	struct megasas_cmd *cmd;
8237 	void *kbuff_arr[MAX_IOCTL_SGE];
8238 	dma_addr_t buf_handle = 0;
8239 	int error = 0, i;
8240 	void *sense = NULL;
8241 	dma_addr_t sense_handle;
8242 	void *sense_ptr;
8243 	u32 opcode = 0;
8244 	int ret = DCMD_SUCCESS;
8245 
8246 	memset(kbuff_arr, 0, sizeof(kbuff_arr));
8247 
8248 	if (ioc->sge_count > MAX_IOCTL_SGE) {
8249 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "SGE count [%d] >  max limit [%d]\n",
8250 		       ioc->sge_count, MAX_IOCTL_SGE);
8251 		return -EINVAL;
8252 	}
8253 
8254 	if ((ioc->frame.hdr.cmd >= MFI_CMD_OP_COUNT) ||
8255 	    ((ioc->frame.hdr.cmd == MFI_CMD_NVME) &&
8256 	    !instance->support_nvme_passthru) ||
8257 	    ((ioc->frame.hdr.cmd == MFI_CMD_TOOLBOX) &&
8258 	    !instance->support_pci_lane_margining)) {
8259 		dev_err(&instance->pdev->dev,
8260 			"Received invalid ioctl command 0x%x\n",
8261 			ioc->frame.hdr.cmd);
8262 		return -ENOTSUPP;
8263 	}
8264 
8265 	cmd = megasas_get_cmd(instance);
8266 	if (!cmd) {
8267 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get a cmd packet\n");
8268 		return -ENOMEM;
8269 	}
8270 
8271 	/*
8272 	 * User's IOCTL packet has 2 frames (maximum). Copy those two
8273 	 * frames into our cmd's frames. cmd->frame's context will get
8274 	 * overwritten when we copy from user's frames. So set that value
8275 	 * alone separately
8276 	 */
8277 	memcpy(cmd->frame, ioc->frame.raw, 2 * MEGAMFI_FRAME_SIZE);
8278 	cmd->frame->hdr.context = cpu_to_le32(cmd->index);
8279 	cmd->frame->hdr.pad_0 = 0;
8280 
8281 	cmd->frame->hdr.flags &= (~MFI_FRAME_IEEE);
8282 
8283 	if (instance->consistent_mask_64bit)
8284 		cmd->frame->hdr.flags |= cpu_to_le16((MFI_FRAME_SGL64 |
8285 				       MFI_FRAME_SENSE64));
8286 	else
8287 		cmd->frame->hdr.flags &= cpu_to_le16(~(MFI_FRAME_SGL64 |
8288 					       MFI_FRAME_SENSE64));
8289 
8290 	if (cmd->frame->hdr.cmd == MFI_CMD_DCMD)
8291 		opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
8292 
8293 	if (opcode == MR_DCMD_CTRL_SHUTDOWN) {
8294 		mutex_lock(&instance->reset_mutex);
8295 		if (megasas_get_ctrl_info(instance) != DCMD_SUCCESS) {
8296 			megasas_return_cmd(instance, cmd);
8297 			mutex_unlock(&instance->reset_mutex);
8298 			return -1;
8299 		}
8300 		mutex_unlock(&instance->reset_mutex);
8301 	}
8302 
8303 	if (opcode == MR_DRIVER_SET_APP_CRASHDUMP_MODE) {
8304 		error = megasas_set_crash_dump_params_ioctl(cmd);
8305 		megasas_return_cmd(instance, cmd);
8306 		return error;
8307 	}
8308 
8309 	/*
8310 	 * The management interface between applications and the fw uses
8311 	 * MFI frames. E.g, RAID configuration changes, LD property changes
8312 	 * etc are accomplishes through different kinds of MFI frames. The
8313 	 * driver needs to care only about substituting user buffers with
8314 	 * kernel buffers in SGLs. The location of SGL is embedded in the
8315 	 * struct iocpacket itself.
8316 	 */
8317 	if (instance->consistent_mask_64bit)
8318 		kern_sge64 = (struct megasas_sge64 *)
8319 			((unsigned long)cmd->frame + ioc->sgl_off);
8320 	else
8321 		kern_sge32 = (struct megasas_sge32 *)
8322 			((unsigned long)cmd->frame + ioc->sgl_off);
8323 
8324 	/*
8325 	 * For each user buffer, create a mirror buffer and copy in
8326 	 */
8327 	for (i = 0; i < ioc->sge_count; i++) {
8328 		if (!ioc->sgl[i].iov_len)
8329 			continue;
8330 
8331 		kbuff_arr[i] = dma_alloc_coherent(&instance->pdev->dev,
8332 						    ioc->sgl[i].iov_len,
8333 						    &buf_handle, GFP_KERNEL);
8334 		if (!kbuff_arr[i]) {
8335 			dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc "
8336 			       "kernel SGL buffer for IOCTL\n");
8337 			error = -ENOMEM;
8338 			goto out;
8339 		}
8340 
8341 		/*
8342 		 * We don't change the dma_coherent_mask, so
8343 		 * dma_alloc_coherent only returns 32bit addresses
8344 		 */
8345 		if (instance->consistent_mask_64bit) {
8346 			kern_sge64[i].phys_addr = cpu_to_le64(buf_handle);
8347 			kern_sge64[i].length = cpu_to_le32(ioc->sgl[i].iov_len);
8348 		} else {
8349 			kern_sge32[i].phys_addr = cpu_to_le32(buf_handle);
8350 			kern_sge32[i].length = cpu_to_le32(ioc->sgl[i].iov_len);
8351 		}
8352 
8353 		/*
8354 		 * We created a kernel buffer corresponding to the
8355 		 * user buffer. Now copy in from the user buffer
8356 		 */
8357 		if (copy_from_user(kbuff_arr[i], ioc->sgl[i].iov_base,
8358 				   (u32) (ioc->sgl[i].iov_len))) {
8359 			error = -EFAULT;
8360 			goto out;
8361 		}
8362 	}
8363 
8364 	if (ioc->sense_len) {
8365 		/* make sure the pointer is part of the frame */
8366 		if (ioc->sense_off >
8367 		    (sizeof(union megasas_frame) - sizeof(__le64))) {
8368 			error = -EINVAL;
8369 			goto out;
8370 		}
8371 
8372 		sense = dma_alloc_coherent(&instance->pdev->dev, ioc->sense_len,
8373 					     &sense_handle, GFP_KERNEL);
8374 		if (!sense) {
8375 			error = -ENOMEM;
8376 			goto out;
8377 		}
8378 
8379 		/* always store 64 bits regardless of addressing */
8380 		sense_ptr = (void *)cmd->frame + ioc->sense_off;
8381 		put_unaligned_le64(sense_handle, sense_ptr);
8382 	}
8383 
8384 	/*
8385 	 * Set the sync_cmd flag so that the ISR knows not to complete this
8386 	 * cmd to the SCSI mid-layer
8387 	 */
8388 	cmd->sync_cmd = 1;
8389 
8390 	ret = megasas_issue_blocked_cmd(instance, cmd, 0);
8391 	switch (ret) {
8392 	case DCMD_INIT:
8393 	case DCMD_BUSY:
8394 		cmd->sync_cmd = 0;
8395 		dev_err(&instance->pdev->dev,
8396 			"return -EBUSY from %s %d cmd 0x%x opcode 0x%x cmd->cmd_status_drv 0x%x\n",
8397 			 __func__, __LINE__, cmd->frame->hdr.cmd, opcode,
8398 			 cmd->cmd_status_drv);
8399 		error = -EBUSY;
8400 		goto out;
8401 	}
8402 
8403 	cmd->sync_cmd = 0;
8404 
8405 	if (instance->unload == 1) {
8406 		dev_info(&instance->pdev->dev, "Driver unload is in progress "
8407 			"don't submit data to application\n");
8408 		goto out;
8409 	}
8410 	/*
8411 	 * copy out the kernel buffers to user buffers
8412 	 */
8413 	for (i = 0; i < ioc->sge_count; i++) {
8414 		if (copy_to_user(ioc->sgl[i].iov_base, kbuff_arr[i],
8415 				 ioc->sgl[i].iov_len)) {
8416 			error = -EFAULT;
8417 			goto out;
8418 		}
8419 	}
8420 
8421 	/*
8422 	 * copy out the sense
8423 	 */
8424 	if (ioc->sense_len) {
8425 		void __user *uptr;
8426 		/*
8427 		 * sense_ptr points to the location that has the user
8428 		 * sense buffer address
8429 		 */
8430 		sense_ptr = (void *)ioc->frame.raw + ioc->sense_off;
8431 		if (in_compat_syscall())
8432 			uptr = compat_ptr(get_unaligned((compat_uptr_t *)
8433 							sense_ptr));
8434 		else
8435 			uptr = get_unaligned((void __user **)sense_ptr);
8436 
8437 		if (copy_to_user(uptr, sense, ioc->sense_len)) {
8438 			dev_err(&instance->pdev->dev, "Failed to copy out to user "
8439 					"sense data\n");
8440 			error = -EFAULT;
8441 			goto out;
8442 		}
8443 	}
8444 
8445 	/*
8446 	 * copy the status codes returned by the fw
8447 	 */
8448 	if (copy_to_user(&user_ioc->frame.hdr.cmd_status,
8449 			 &cmd->frame->hdr.cmd_status, sizeof(u8))) {
8450 		dev_printk(KERN_DEBUG, &instance->pdev->dev, "Error copying out cmd_status\n");
8451 		error = -EFAULT;
8452 	}
8453 
8454 out:
8455 	if (sense) {
8456 		dma_free_coherent(&instance->pdev->dev, ioc->sense_len,
8457 				    sense, sense_handle);
8458 	}
8459 
8460 	for (i = 0; i < ioc->sge_count; i++) {
8461 		if (kbuff_arr[i]) {
8462 			if (instance->consistent_mask_64bit)
8463 				dma_free_coherent(&instance->pdev->dev,
8464 					le32_to_cpu(kern_sge64[i].length),
8465 					kbuff_arr[i],
8466 					le64_to_cpu(kern_sge64[i].phys_addr));
8467 			else
8468 				dma_free_coherent(&instance->pdev->dev,
8469 					le32_to_cpu(kern_sge32[i].length),
8470 					kbuff_arr[i],
8471 					le32_to_cpu(kern_sge32[i].phys_addr));
8472 			kbuff_arr[i] = NULL;
8473 		}
8474 	}
8475 
8476 	megasas_return_cmd(instance, cmd);
8477 	return error;
8478 }
8479 
8480 static struct megasas_iocpacket *
8481 megasas_compat_iocpacket_get_user(void __user *arg)
8482 {
8483 	struct megasas_iocpacket *ioc;
8484 	struct compat_megasas_iocpacket __user *cioc = arg;
8485 	size_t size;
8486 	int err = -EFAULT;
8487 	int i;
8488 
8489 	ioc = kzalloc(sizeof(*ioc), GFP_KERNEL);
8490 	if (!ioc)
8491 		return ERR_PTR(-ENOMEM);
8492 	size = offsetof(struct megasas_iocpacket, frame) + sizeof(ioc->frame);
8493 	if (copy_from_user(ioc, arg, size))
8494 		goto out;
8495 
8496 	for (i = 0; i < MAX_IOCTL_SGE; i++) {
8497 		compat_uptr_t iov_base;
8498 
8499 		if (get_user(iov_base, &cioc->sgl[i].iov_base) ||
8500 		    get_user(ioc->sgl[i].iov_len, &cioc->sgl[i].iov_len))
8501 			goto out;
8502 
8503 		ioc->sgl[i].iov_base = compat_ptr(iov_base);
8504 	}
8505 
8506 	return ioc;
8507 out:
8508 	kfree(ioc);
8509 	return ERR_PTR(err);
8510 }
8511 
8512 static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
8513 {
8514 	struct megasas_iocpacket __user *user_ioc =
8515 	    (struct megasas_iocpacket __user *)arg;
8516 	struct megasas_iocpacket *ioc;
8517 	struct megasas_instance *instance;
8518 	int error;
8519 
8520 	if (in_compat_syscall())
8521 		ioc = megasas_compat_iocpacket_get_user(user_ioc);
8522 	else
8523 		ioc = memdup_user(user_ioc, sizeof(struct megasas_iocpacket));
8524 
8525 	if (IS_ERR(ioc))
8526 		return PTR_ERR(ioc);
8527 
8528 	instance = megasas_lookup_instance(ioc->host_no);
8529 	if (!instance) {
8530 		error = -ENODEV;
8531 		goto out_kfree_ioc;
8532 	}
8533 
8534 	/* Block ioctls in VF mode */
8535 	if (instance->requestorId && !allow_vf_ioctls) {
8536 		error = -ENODEV;
8537 		goto out_kfree_ioc;
8538 	}
8539 
8540 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
8541 		dev_err(&instance->pdev->dev, "Controller in crit error\n");
8542 		error = -ENODEV;
8543 		goto out_kfree_ioc;
8544 	}
8545 
8546 	if (instance->unload == 1) {
8547 		error = -ENODEV;
8548 		goto out_kfree_ioc;
8549 	}
8550 
8551 	if (down_interruptible(&instance->ioctl_sem)) {
8552 		error = -ERESTARTSYS;
8553 		goto out_kfree_ioc;
8554 	}
8555 
8556 	if  (megasas_wait_for_adapter_operational(instance)) {
8557 		error = -ENODEV;
8558 		goto out_up;
8559 	}
8560 
8561 	error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc);
8562 out_up:
8563 	up(&instance->ioctl_sem);
8564 
8565 out_kfree_ioc:
8566 	kfree(ioc);
8567 	return error;
8568 }
8569 
8570 static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)
8571 {
8572 	struct megasas_instance *instance;
8573 	struct megasas_aen aen;
8574 	int error;
8575 
8576 	if (file->private_data != file) {
8577 		printk(KERN_DEBUG "megasas: fasync_helper was not "
8578 		       "called first\n");
8579 		return -EINVAL;
8580 	}
8581 
8582 	if (copy_from_user(&aen, (void __user *)arg, sizeof(aen)))
8583 		return -EFAULT;
8584 
8585 	instance = megasas_lookup_instance(aen.host_no);
8586 
8587 	if (!instance)
8588 		return -ENODEV;
8589 
8590 	if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
8591 		return -ENODEV;
8592 	}
8593 
8594 	if (instance->unload == 1) {
8595 		return -ENODEV;
8596 	}
8597 
8598 	if  (megasas_wait_for_adapter_operational(instance))
8599 		return -ENODEV;
8600 
8601 	mutex_lock(&instance->reset_mutex);
8602 	error = megasas_register_aen(instance, aen.seq_num,
8603 				     aen.class_locale_word);
8604 	mutex_unlock(&instance->reset_mutex);
8605 	return error;
8606 }
8607 
8608 /**
8609  * megasas_mgmt_ioctl -	char node ioctl entry point
8610  * @file:	char device file pointer
8611  * @cmd:	ioctl command
8612  * @arg:	ioctl command arguments address
8613  */
8614 static long
8615 megasas_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
8616 {
8617 	switch (cmd) {
8618 	case MEGASAS_IOC_FIRMWARE:
8619 		return megasas_mgmt_ioctl_fw(file, arg);
8620 
8621 	case MEGASAS_IOC_GET_AEN:
8622 		return megasas_mgmt_ioctl_aen(file, arg);
8623 	}
8624 
8625 	return -ENOTTY;
8626 }
8627 
8628 #ifdef CONFIG_COMPAT
8629 static long
8630 megasas_mgmt_compat_ioctl(struct file *file, unsigned int cmd,
8631 			  unsigned long arg)
8632 {
8633 	switch (cmd) {
8634 	case MEGASAS_IOC_FIRMWARE32:
8635 		return megasas_mgmt_ioctl_fw(file, arg);
8636 	case MEGASAS_IOC_GET_AEN:
8637 		return megasas_mgmt_ioctl_aen(file, arg);
8638 	}
8639 
8640 	return -ENOTTY;
8641 }
8642 #endif
8643 
8644 /*
8645  * File operations structure for management interface
8646  */
8647 static const struct file_operations megasas_mgmt_fops = {
8648 	.owner = THIS_MODULE,
8649 	.open = megasas_mgmt_open,
8650 	.fasync = megasas_mgmt_fasync,
8651 	.unlocked_ioctl = megasas_mgmt_ioctl,
8652 	.poll = megasas_mgmt_poll,
8653 #ifdef CONFIG_COMPAT
8654 	.compat_ioctl = megasas_mgmt_compat_ioctl,
8655 #endif
8656 	.llseek = noop_llseek,
8657 };
8658 
8659 static SIMPLE_DEV_PM_OPS(megasas_pm_ops, megasas_suspend, megasas_resume);
8660 
8661 /*
8662  * PCI hotplug support registration structure
8663  */
8664 static struct pci_driver megasas_pci_driver = {
8665 
8666 	.name = "megaraid_sas",
8667 	.id_table = megasas_pci_table,
8668 	.probe = megasas_probe_one,
8669 	.remove = megasas_detach_one,
8670 	.driver.pm = &megasas_pm_ops,
8671 	.shutdown = megasas_shutdown,
8672 };
8673 
8674 /*
8675  * Sysfs driver attributes
8676  */
8677 static ssize_t version_show(struct device_driver *dd, char *buf)
8678 {
8679 	return snprintf(buf, strlen(MEGASAS_VERSION) + 2, "%s\n",
8680 			MEGASAS_VERSION);
8681 }
8682 static DRIVER_ATTR_RO(version);
8683 
8684 static ssize_t release_date_show(struct device_driver *dd, char *buf)
8685 {
8686 	return snprintf(buf, strlen(MEGASAS_RELDATE) + 2, "%s\n",
8687 		MEGASAS_RELDATE);
8688 }
8689 static DRIVER_ATTR_RO(release_date);
8690 
8691 static ssize_t support_poll_for_event_show(struct device_driver *dd, char *buf)
8692 {
8693 	return sprintf(buf, "%u\n", support_poll_for_event);
8694 }
8695 static DRIVER_ATTR_RO(support_poll_for_event);
8696 
8697 static ssize_t support_device_change_show(struct device_driver *dd, char *buf)
8698 {
8699 	return sprintf(buf, "%u\n", support_device_change);
8700 }
8701 static DRIVER_ATTR_RO(support_device_change);
8702 
8703 static ssize_t dbg_lvl_show(struct device_driver *dd, char *buf)
8704 {
8705 	return sprintf(buf, "%u\n", megasas_dbg_lvl);
8706 }
8707 
8708 static ssize_t dbg_lvl_store(struct device_driver *dd, const char *buf,
8709 			     size_t count)
8710 {
8711 	int retval = count;
8712 
8713 	if (sscanf(buf, "%u", &megasas_dbg_lvl) < 1) {
8714 		printk(KERN_ERR "megasas: could not set dbg_lvl\n");
8715 		retval = -EINVAL;
8716 	}
8717 	return retval;
8718 }
8719 static DRIVER_ATTR_RW(dbg_lvl);
8720 
8721 static ssize_t
8722 support_nvme_encapsulation_show(struct device_driver *dd, char *buf)
8723 {
8724 	return sprintf(buf, "%u\n", support_nvme_encapsulation);
8725 }
8726 
8727 static DRIVER_ATTR_RO(support_nvme_encapsulation);
8728 
8729 static ssize_t
8730 support_pci_lane_margining_show(struct device_driver *dd, char *buf)
8731 {
8732 	return sprintf(buf, "%u\n", support_pci_lane_margining);
8733 }
8734 
8735 static DRIVER_ATTR_RO(support_pci_lane_margining);
8736 
8737 static inline void megasas_remove_scsi_device(struct scsi_device *sdev)
8738 {
8739 	sdev_printk(KERN_INFO, sdev, "SCSI device is removed\n");
8740 	scsi_remove_device(sdev);
8741 	scsi_device_put(sdev);
8742 }
8743 
8744 /**
8745  * megasas_update_device_list -	Update the PD and LD device list from FW
8746  *				after an AEN event notification
8747  * @instance:			Adapter soft state
8748  * @event_type:			Indicates type of event (PD or LD event)
8749  *
8750  * @return:			Success or failure
8751  *
8752  * Issue DCMDs to Firmware to update the internal device list in driver.
8753  * Based on the FW support, driver sends the HOST_DEVICE_LIST or combination
8754  * of PD_LIST/LD_LIST_QUERY DCMDs to get the device list.
8755  */
8756 static
8757 int megasas_update_device_list(struct megasas_instance *instance,
8758 			       int event_type)
8759 {
8760 	int dcmd_ret;
8761 
8762 	if (instance->enable_fw_dev_list) {
8763 		return megasas_host_device_list_query(instance, false);
8764 	} else {
8765 		if (event_type & SCAN_PD_CHANNEL) {
8766 			dcmd_ret = megasas_get_pd_list(instance);
8767 			if (dcmd_ret != DCMD_SUCCESS)
8768 				return dcmd_ret;
8769 		}
8770 
8771 		if (event_type & SCAN_VD_CHANNEL) {
8772 			if (!instance->requestorId ||
8773 			megasas_get_ld_vf_affiliation(instance, 0)) {
8774 				return megasas_ld_list_query(instance,
8775 						MR_LD_QUERY_TYPE_EXPOSED_TO_HOST);
8776 			}
8777 		}
8778 	}
8779 	return DCMD_SUCCESS;
8780 }
8781 
8782 /**
8783  * megasas_add_remove_devices -	Add/remove devices to SCSI mid-layer
8784  *				after an AEN event notification
8785  * @instance:			Adapter soft state
8786  * @scan_type:			Indicates type of devices (PD/LD) to add
8787  * @return			void
8788  */
8789 static
8790 void megasas_add_remove_devices(struct megasas_instance *instance,
8791 				int scan_type)
8792 {
8793 	int i, j;
8794 	u16 pd_index = 0;
8795 	u16 ld_index = 0;
8796 	u16 channel = 0, id = 0;
8797 	struct Scsi_Host *host;
8798 	struct scsi_device *sdev1;
8799 	struct MR_HOST_DEVICE_LIST *targetid_list = NULL;
8800 	struct MR_HOST_DEVICE_LIST_ENTRY *targetid_entry = NULL;
8801 
8802 	host = instance->host;
8803 
8804 	if (instance->enable_fw_dev_list) {
8805 		targetid_list = instance->host_device_list_buf;
8806 		for (i = 0; i < targetid_list->count; i++) {
8807 			targetid_entry = &targetid_list->host_device_list[i];
8808 			if (targetid_entry->flags.u.bits.is_sys_pd) {
8809 				channel = le16_to_cpu(targetid_entry->target_id) /
8810 						MEGASAS_MAX_DEV_PER_CHANNEL;
8811 				id = le16_to_cpu(targetid_entry->target_id) %
8812 						MEGASAS_MAX_DEV_PER_CHANNEL;
8813 			} else {
8814 				channel = MEGASAS_MAX_PD_CHANNELS +
8815 					  (le16_to_cpu(targetid_entry->target_id) /
8816 					   MEGASAS_MAX_DEV_PER_CHANNEL);
8817 				id = le16_to_cpu(targetid_entry->target_id) %
8818 						MEGASAS_MAX_DEV_PER_CHANNEL;
8819 			}
8820 			sdev1 = scsi_device_lookup(host, channel, id, 0);
8821 			if (!sdev1) {
8822 				scsi_add_device(host, channel, id, 0);
8823 			} else {
8824 				scsi_device_put(sdev1);
8825 			}
8826 		}
8827 	}
8828 
8829 	if (scan_type & SCAN_PD_CHANNEL) {
8830 		for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
8831 			for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
8832 				pd_index = i * MEGASAS_MAX_DEV_PER_CHANNEL + j;
8833 				sdev1 = scsi_device_lookup(host, i, j, 0);
8834 				if (instance->pd_list[pd_index].driveState ==
8835 							MR_PD_STATE_SYSTEM) {
8836 					if (!sdev1)
8837 						scsi_add_device(host, i, j, 0);
8838 					else
8839 						scsi_device_put(sdev1);
8840 				} else {
8841 					if (sdev1)
8842 						megasas_remove_scsi_device(sdev1);
8843 				}
8844 			}
8845 		}
8846 	}
8847 
8848 	if (scan_type & SCAN_VD_CHANNEL) {
8849 		for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
8850 			for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
8851 				ld_index = (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
8852 				sdev1 = scsi_device_lookup(host,
8853 						MEGASAS_MAX_PD_CHANNELS + i, j, 0);
8854 				if (instance->ld_ids[ld_index] != 0xff) {
8855 					if (!sdev1)
8856 						scsi_add_device(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0);
8857 					else
8858 						scsi_device_put(sdev1);
8859 				} else {
8860 					if (sdev1)
8861 						megasas_remove_scsi_device(sdev1);
8862 				}
8863 			}
8864 		}
8865 	}
8866 
8867 }
8868 
8869 static void
8870 megasas_aen_polling(struct work_struct *work)
8871 {
8872 	struct megasas_aen_event *ev =
8873 		container_of(work, struct megasas_aen_event, hotplug_work.work);
8874 	struct megasas_instance *instance = ev->instance;
8875 	union megasas_evt_class_locale class_locale;
8876 	int event_type = 0;
8877 	u32 seq_num;
8878 	u16 ld_target_id;
8879 	int error;
8880 	u8  dcmd_ret = DCMD_SUCCESS;
8881 	struct scsi_device *sdev1;
8882 
8883 	if (!instance) {
8884 		printk(KERN_ERR "invalid instance!\n");
8885 		kfree(ev);
8886 		return;
8887 	}
8888 
8889 	/* Don't run the event workqueue thread if OCR is running */
8890 	mutex_lock(&instance->reset_mutex);
8891 
8892 	instance->ev = NULL;
8893 	if (instance->evt_detail) {
8894 		megasas_decode_evt(instance);
8895 
8896 		switch (le32_to_cpu(instance->evt_detail->code)) {
8897 
8898 		case MR_EVT_PD_INSERTED:
8899 		case MR_EVT_PD_REMOVED:
8900 			event_type = SCAN_PD_CHANNEL;
8901 			break;
8902 
8903 		case MR_EVT_LD_OFFLINE:
8904 		case MR_EVT_LD_DELETED:
8905 			ld_target_id = instance->evt_detail->args.ld.target_id;
8906 			sdev1 = scsi_device_lookup(instance->host,
8907 						   MEGASAS_MAX_PD_CHANNELS +
8908 						   (ld_target_id / MEGASAS_MAX_DEV_PER_CHANNEL),
8909 						   (ld_target_id % MEGASAS_MAX_DEV_PER_CHANNEL),
8910 						   0);
8911 			if (sdev1)
8912 				megasas_remove_scsi_device(sdev1);
8913 
8914 			event_type = SCAN_VD_CHANNEL;
8915 			break;
8916 		case MR_EVT_LD_CREATED:
8917 			event_type = SCAN_VD_CHANNEL;
8918 			break;
8919 
8920 		case MR_EVT_CFG_CLEARED:
8921 		case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:
8922 		case MR_EVT_FOREIGN_CFG_IMPORTED:
8923 		case MR_EVT_LD_STATE_CHANGE:
8924 			event_type = SCAN_PD_CHANNEL | SCAN_VD_CHANNEL;
8925 			dev_info(&instance->pdev->dev, "scanning for scsi%d...\n",
8926 				instance->host->host_no);
8927 			break;
8928 
8929 		case MR_EVT_CTRL_PROP_CHANGED:
8930 			dcmd_ret = megasas_get_ctrl_info(instance);
8931 			if (dcmd_ret == DCMD_SUCCESS &&
8932 			    instance->snapdump_wait_time) {
8933 				megasas_get_snapdump_properties(instance);
8934 				dev_info(&instance->pdev->dev,
8935 					 "Snap dump wait time\t: %d\n",
8936 					 instance->snapdump_wait_time);
8937 			}
8938 			break;
8939 		default:
8940 			event_type = 0;
8941 			break;
8942 		}
8943 	} else {
8944 		dev_err(&instance->pdev->dev, "invalid evt_detail!\n");
8945 		mutex_unlock(&instance->reset_mutex);
8946 		kfree(ev);
8947 		return;
8948 	}
8949 
8950 	if (event_type)
8951 		dcmd_ret = megasas_update_device_list(instance, event_type);
8952 
8953 	mutex_unlock(&instance->reset_mutex);
8954 
8955 	if (event_type && dcmd_ret == DCMD_SUCCESS)
8956 		megasas_add_remove_devices(instance, event_type);
8957 
8958 	if (dcmd_ret == DCMD_SUCCESS)
8959 		seq_num = le32_to_cpu(instance->evt_detail->seq_num) + 1;
8960 	else
8961 		seq_num = instance->last_seq_num;
8962 
8963 	/* Register AEN with FW for latest sequence number plus 1 */
8964 	class_locale.members.reserved = 0;
8965 	class_locale.members.locale = MR_EVT_LOCALE_ALL;
8966 	class_locale.members.class = MR_EVT_CLASS_DEBUG;
8967 
8968 	if (instance->aen_cmd != NULL) {
8969 		kfree(ev);
8970 		return;
8971 	}
8972 
8973 	mutex_lock(&instance->reset_mutex);
8974 	error = megasas_register_aen(instance, seq_num,
8975 					class_locale.word);
8976 	if (error)
8977 		dev_err(&instance->pdev->dev,
8978 			"register aen failed error %x\n", error);
8979 
8980 	mutex_unlock(&instance->reset_mutex);
8981 	kfree(ev);
8982 }
8983 
8984 /**
8985  * megasas_init - Driver load entry point
8986  */
8987 static int __init megasas_init(void)
8988 {
8989 	int rval;
8990 
8991 	/*
8992 	 * Booted in kdump kernel, minimize memory footprints by
8993 	 * disabling few features
8994 	 */
8995 	if (reset_devices) {
8996 		msix_vectors = 1;
8997 		rdpq_enable = 0;
8998 		dual_qdepth_disable = 1;
8999 		poll_queues = 0;
9000 	}
9001 
9002 	/*
9003 	 * Announce driver version and other information
9004 	 */
9005 	pr_info("megasas: %s\n", MEGASAS_VERSION);
9006 
9007 	megasas_dbg_lvl = 0;
9008 	support_poll_for_event = 2;
9009 	support_device_change = 1;
9010 	support_nvme_encapsulation = true;
9011 	support_pci_lane_margining = true;
9012 
9013 	memset(&megasas_mgmt_info, 0, sizeof(megasas_mgmt_info));
9014 
9015 	/*
9016 	 * Register character device node
9017 	 */
9018 	rval = register_chrdev(0, "megaraid_sas_ioctl", &megasas_mgmt_fops);
9019 
9020 	if (rval < 0) {
9021 		printk(KERN_DEBUG "megasas: failed to open device node\n");
9022 		return rval;
9023 	}
9024 
9025 	megasas_mgmt_majorno = rval;
9026 
9027 	megasas_init_debugfs();
9028 
9029 	/*
9030 	 * Register ourselves as PCI hotplug module
9031 	 */
9032 	rval = pci_register_driver(&megasas_pci_driver);
9033 
9034 	if (rval) {
9035 		printk(KERN_DEBUG "megasas: PCI hotplug registration failed \n");
9036 		goto err_pcidrv;
9037 	}
9038 
9039 	if ((event_log_level < MFI_EVT_CLASS_DEBUG) ||
9040 	    (event_log_level > MFI_EVT_CLASS_DEAD)) {
9041 		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");
9042 		event_log_level = MFI_EVT_CLASS_CRITICAL;
9043 	}
9044 
9045 	rval = driver_create_file(&megasas_pci_driver.driver,
9046 				  &driver_attr_version);
9047 	if (rval)
9048 		goto err_dcf_attr_ver;
9049 
9050 	rval = driver_create_file(&megasas_pci_driver.driver,
9051 				  &driver_attr_release_date);
9052 	if (rval)
9053 		goto err_dcf_rel_date;
9054 
9055 	rval = driver_create_file(&megasas_pci_driver.driver,
9056 				&driver_attr_support_poll_for_event);
9057 	if (rval)
9058 		goto err_dcf_support_poll_for_event;
9059 
9060 	rval = driver_create_file(&megasas_pci_driver.driver,
9061 				  &driver_attr_dbg_lvl);
9062 	if (rval)
9063 		goto err_dcf_dbg_lvl;
9064 	rval = driver_create_file(&megasas_pci_driver.driver,
9065 				&driver_attr_support_device_change);
9066 	if (rval)
9067 		goto err_dcf_support_device_change;
9068 
9069 	rval = driver_create_file(&megasas_pci_driver.driver,
9070 				  &driver_attr_support_nvme_encapsulation);
9071 	if (rval)
9072 		goto err_dcf_support_nvme_encapsulation;
9073 
9074 	rval = driver_create_file(&megasas_pci_driver.driver,
9075 				  &driver_attr_support_pci_lane_margining);
9076 	if (rval)
9077 		goto err_dcf_support_pci_lane_margining;
9078 
9079 	return rval;
9080 
9081 err_dcf_support_pci_lane_margining:
9082 	driver_remove_file(&megasas_pci_driver.driver,
9083 			   &driver_attr_support_nvme_encapsulation);
9084 
9085 err_dcf_support_nvme_encapsulation:
9086 	driver_remove_file(&megasas_pci_driver.driver,
9087 			   &driver_attr_support_device_change);
9088 
9089 err_dcf_support_device_change:
9090 	driver_remove_file(&megasas_pci_driver.driver,
9091 			   &driver_attr_dbg_lvl);
9092 err_dcf_dbg_lvl:
9093 	driver_remove_file(&megasas_pci_driver.driver,
9094 			&driver_attr_support_poll_for_event);
9095 err_dcf_support_poll_for_event:
9096 	driver_remove_file(&megasas_pci_driver.driver,
9097 			   &driver_attr_release_date);
9098 err_dcf_rel_date:
9099 	driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
9100 err_dcf_attr_ver:
9101 	pci_unregister_driver(&megasas_pci_driver);
9102 err_pcidrv:
9103 	megasas_exit_debugfs();
9104 	unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
9105 	return rval;
9106 }
9107 
9108 /**
9109  * megasas_exit - Driver unload entry point
9110  */
9111 static void __exit megasas_exit(void)
9112 {
9113 	driver_remove_file(&megasas_pci_driver.driver,
9114 			   &driver_attr_dbg_lvl);
9115 	driver_remove_file(&megasas_pci_driver.driver,
9116 			&driver_attr_support_poll_for_event);
9117 	driver_remove_file(&megasas_pci_driver.driver,
9118 			&driver_attr_support_device_change);
9119 	driver_remove_file(&megasas_pci_driver.driver,
9120 			   &driver_attr_release_date);
9121 	driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
9122 	driver_remove_file(&megasas_pci_driver.driver,
9123 			   &driver_attr_support_nvme_encapsulation);
9124 	driver_remove_file(&megasas_pci_driver.driver,
9125 			   &driver_attr_support_pci_lane_margining);
9126 
9127 	pci_unregister_driver(&megasas_pci_driver);
9128 	megasas_exit_debugfs();
9129 	unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
9130 }
9131 
9132 module_init(megasas_init);
9133 module_exit(megasas_exit);
9134