1/*
2 *  Linux MegaRAID driver for SAS based RAID controllers
3 *
4 *  Copyright (c) 2003-2013  LSI Corporation
5 *  Copyright (c) 2013-2014  Avago Technologies
6 *
7 *  This program is free software; you can redistribute it and/or
8 *  modify it under the terms of the GNU General Public License
9 *  as published by the Free Software Foundation; either version 2
10 *  of the License, or (at your option) any later version.
11 *
12 *  This program is distributed in the hope that it will be useful,
13 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 *  GNU General Public License for more details.
16 *
17 *  You should have received a copy of the GNU General Public License
18 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 *
20 *  Authors: Avago Technologies
21 *           Sreenivas Bagalkote
22 *           Sumant Patro
23 *           Bo Yang
24 *           Adam Radford
25 *           Kashyap Desai <kashyap.desai@avagotech.com>
26 *           Sumit Saxena <sumit.saxena@avagotech.com>
27 *
28 *  Send feedback to: megaraidlinux.pdl@avagotech.com
29 *
30 *  Mail to: Avago Technologies, 350 West Trimble Road, Building 90,
31 *  San Jose, California 95131
32 */
33
34#include <linux/kernel.h>
35#include <linux/types.h>
36#include <linux/pci.h>
37#include <linux/list.h>
38#include <linux/moduleparam.h>
39#include <linux/module.h>
40#include <linux/spinlock.h>
41#include <linux/interrupt.h>
42#include <linux/delay.h>
43#include <linux/uio.h>
44#include <linux/slab.h>
45#include <asm/uaccess.h>
46#include <linux/fs.h>
47#include <linux/compat.h>
48#include <linux/blkdev.h>
49#include <linux/mutex.h>
50#include <linux/poll.h>
51
52#include <scsi/scsi.h>
53#include <scsi/scsi_cmnd.h>
54#include <scsi/scsi_device.h>
55#include <scsi/scsi_host.h>
56#include <scsi/scsi_tcq.h>
57#include "megaraid_sas_fusion.h"
58#include "megaraid_sas.h"
59
60/*
61 * Number of sectors per IO command
62 * Will be set in megasas_init_mfi if user does not provide
63 */
64static unsigned int max_sectors;
65module_param_named(max_sectors, max_sectors, int, 0);
66MODULE_PARM_DESC(max_sectors,
67	"Maximum number of sectors per IO command");
68
69static int msix_disable;
70module_param(msix_disable, int, S_IRUGO);
71MODULE_PARM_DESC(msix_disable, "Disable MSI-X interrupt handling. Default: 0");
72
73static unsigned int msix_vectors;
74module_param(msix_vectors, int, S_IRUGO);
75MODULE_PARM_DESC(msix_vectors, "MSI-X max vector count. Default: Set by FW");
76
77static int allow_vf_ioctls;
78module_param(allow_vf_ioctls, int, S_IRUGO);
79MODULE_PARM_DESC(allow_vf_ioctls, "Allow ioctls in SR-IOV VF mode. Default: 0");
80
81static unsigned int throttlequeuedepth = MEGASAS_THROTTLE_QUEUE_DEPTH;
82module_param(throttlequeuedepth, int, S_IRUGO);
83MODULE_PARM_DESC(throttlequeuedepth,
84	"Adapter queue depth when throttled due to I/O timeout. Default: 16");
85
86int resetwaittime = MEGASAS_RESET_WAIT_TIME;
87module_param(resetwaittime, int, S_IRUGO);
88MODULE_PARM_DESC(resetwaittime, "Wait time in seconds after I/O timeout "
89		 "before resetting adapter. Default: 180");
90
91int smp_affinity_enable = 1;
92module_param(smp_affinity_enable, int, S_IRUGO);
93MODULE_PARM_DESC(smp_affinity_enable, "SMP affinity feature enable/disbale Default: enable(1)");
94
95MODULE_LICENSE("GPL");
96MODULE_VERSION(MEGASAS_VERSION);
97MODULE_AUTHOR("megaraidlinux@lsi.com");
98MODULE_DESCRIPTION("LSI MegaRAID SAS Driver");
99
100int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
101static int megasas_get_pd_list(struct megasas_instance *instance);
102static int megasas_ld_list_query(struct megasas_instance *instance,
103				 u8 query_type);
104static int megasas_issue_init_mfi(struct megasas_instance *instance);
105static int megasas_register_aen(struct megasas_instance *instance,
106				u32 seq_num, u32 class_locale_word);
107/*
108 * PCI ID table for all supported controllers
109 */
110static struct pci_device_id megasas_pci_table[] = {
111
112	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064R)},
113	/* xscale IOP */
114	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078R)},
115	/* ppc IOP */
116	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078DE)},
117	/* ppc IOP */
118	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078GEN2)},
119	/* gen2*/
120	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0079GEN2)},
121	/* gen2*/
122	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0073SKINNY)},
123	/* skinny*/
124	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0071SKINNY)},
125	/* skinny*/
126	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VERDE_ZCR)},
127	/* xscale IOP, vega */
128	{PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)},
129	/* xscale IOP */
130	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FUSION)},
131	/* Fusion */
132	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_PLASMA)},
133	/* Plasma */
134	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_INVADER)},
135	/* Invader */
136	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FURY)},
137	/* Fury */
138	{}
139};
140
141MODULE_DEVICE_TABLE(pci, megasas_pci_table);
142
143static int megasas_mgmt_majorno;
144struct megasas_mgmt_info megasas_mgmt_info;
145static struct fasync_struct *megasas_async_queue;
146static DEFINE_MUTEX(megasas_async_queue_mutex);
147
148static int megasas_poll_wait_aen;
149static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait);
150static u32 support_poll_for_event;
151u32 megasas_dbg_lvl;
152static u32 support_device_change;
153
154/* define lock for aen poll */
155spinlock_t poll_aen_lock;
156
157void
158megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
159		     u8 alt_status);
160static u32
161megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem *regs);
162static int
163megasas_adp_reset_gen2(struct megasas_instance *instance,
164		       struct megasas_register_set __iomem *reg_set);
165static irqreturn_t megasas_isr(int irq, void *devp);
166static u32
167megasas_init_adapter_mfi(struct megasas_instance *instance);
168u32
169megasas_build_and_issue_cmd(struct megasas_instance *instance,
170			    struct scsi_cmnd *scmd);
171static void megasas_complete_cmd_dpc(unsigned long instance_addr);
172void
173megasas_release_fusion(struct megasas_instance *instance);
174int
175megasas_ioc_init_fusion(struct megasas_instance *instance);
176void
177megasas_free_cmds_fusion(struct megasas_instance *instance);
178u8
179megasas_get_map_info(struct megasas_instance *instance);
180int
181megasas_sync_map_info(struct megasas_instance *instance);
182int
183wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
184	int seconds);
185void megasas_reset_reply_desc(struct megasas_instance *instance);
186int megasas_reset_fusion(struct Scsi_Host *shost, int iotimeout);
187void megasas_fusion_ocr_wq(struct work_struct *work);
188static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,
189					 int initial);
190int megasas_check_mpio_paths(struct megasas_instance *instance,
191			     struct scsi_cmnd *scmd);
192
193void
194megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
195{
196	instance->instancet->fire_cmd(instance,
197		cmd->frame_phys_addr, 0, instance->reg_set);
198}
199
200/**
201 * megasas_get_cmd -	Get a command from the free pool
202 * @instance:		Adapter soft state
203 *
204 * Returns a free command from the pool
205 */
206struct megasas_cmd *megasas_get_cmd(struct megasas_instance
207						  *instance)
208{
209	unsigned long flags;
210	struct megasas_cmd *cmd = NULL;
211
212	spin_lock_irqsave(&instance->mfi_pool_lock, flags);
213
214	if (!list_empty(&instance->cmd_pool)) {
215		cmd = list_entry((&instance->cmd_pool)->next,
216				 struct megasas_cmd, list);
217		list_del_init(&cmd->list);
218		atomic_set(&cmd->mfi_mpt_pthr, MFI_MPT_DETACHED);
219	} else {
220		printk(KERN_ERR "megasas: Command pool empty!\n");
221	}
222
223	spin_unlock_irqrestore(&instance->mfi_pool_lock, flags);
224	return cmd;
225}
226
227/**
228 * __megasas_return_cmd -	Return a cmd to free command pool
229 * @instance:		Adapter soft state
230 * @cmd:		Command packet to be returned to free command pool
231 */
232inline void
233__megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
234{
235	/*
236	 * Don't go ahead and free the MFI frame, if corresponding
237	 * MPT frame is not freed(valid for only fusion adapters).
238	 * In case of MFI adapters, anyways for any allocated MFI
239	 * frame will have cmd->mfi_mpt_mpthr set to MFI_MPT_DETACHED
240	 */
241	if (atomic_read(&cmd->mfi_mpt_pthr) != MFI_MPT_DETACHED)
242		return;
243
244	cmd->scmd = NULL;
245	cmd->frame_count = 0;
246	cmd->is_wait_event = 0;
247	cmd->mpt_pthr_cmd_blocked = NULL;
248
249	if ((instance->pdev->device != PCI_DEVICE_ID_LSI_FUSION) &&
250	    (instance->pdev->device != PCI_DEVICE_ID_LSI_INVADER) &&
251	    (instance->pdev->device != PCI_DEVICE_ID_LSI_FURY) &&
252	    (reset_devices))
253		cmd->frame->hdr.cmd = MFI_CMD_INVALID;
254
255	atomic_set(&cmd->mfi_mpt_pthr, MFI_LIST_ADDED);
256	list_add(&cmd->list, (&instance->cmd_pool)->next);
257}
258
259/**
260 * megasas_return_cmd -	Return a cmd to free command pool
261 * @instance:		Adapter soft state
262 * @cmd:		Command packet to be returned to free command pool
263 */
264inline void
265megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
266{
267	unsigned long flags;
268
269	spin_lock_irqsave(&instance->mfi_pool_lock, flags);
270	__megasas_return_cmd(instance, cmd);
271	spin_unlock_irqrestore(&instance->mfi_pool_lock, flags);
272}
273
274
275/**
276*	The following functions are defined for xscale
277*	(deviceid : 1064R, PERC5) controllers
278*/
279
280/**
281 * megasas_enable_intr_xscale -	Enables interrupts
282 * @regs:			MFI register set
283 */
284static inline void
285megasas_enable_intr_xscale(struct megasas_instance *instance)
286{
287	struct megasas_register_set __iomem *regs;
288	regs = instance->reg_set;
289	writel(0, &(regs)->outbound_intr_mask);
290
291	/* Dummy readl to force pci flush */
292	readl(&regs->outbound_intr_mask);
293}
294
295/**
296 * megasas_disable_intr_xscale -Disables interrupt
297 * @regs:			MFI register set
298 */
299static inline void
300megasas_disable_intr_xscale(struct megasas_instance *instance)
301{
302	struct megasas_register_set __iomem *regs;
303	u32 mask = 0x1f;
304	regs = instance->reg_set;
305	writel(mask, &regs->outbound_intr_mask);
306	/* Dummy readl to force pci flush */
307	readl(&regs->outbound_intr_mask);
308}
309
310/**
311 * megasas_read_fw_status_reg_xscale - returns the current FW status value
312 * @regs:			MFI register set
313 */
314static u32
315megasas_read_fw_status_reg_xscale(struct megasas_register_set __iomem * regs)
316{
317	return readl(&(regs)->outbound_msg_0);
318}
319/**
320 * megasas_clear_interrupt_xscale -	Check & clear interrupt
321 * @regs:				MFI register set
322 */
323static int
324megasas_clear_intr_xscale(struct megasas_register_set __iomem * regs)
325{
326	u32 status;
327	u32 mfiStatus = 0;
328	/*
329	 * Check if it is our interrupt
330	 */
331	status = readl(&regs->outbound_intr_status);
332
333	if (status & MFI_OB_INTR_STATUS_MASK)
334		mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
335	if (status & MFI_XSCALE_OMR0_CHANGE_INTERRUPT)
336		mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
337
338	/*
339	 * Clear the interrupt by writing back the same value
340	 */
341	if (mfiStatus)
342		writel(status, &regs->outbound_intr_status);
343
344	/* Dummy readl to force pci flush */
345	readl(&regs->outbound_intr_status);
346
347	return mfiStatus;
348}
349
350/**
351 * megasas_fire_cmd_xscale -	Sends command to the FW
352 * @frame_phys_addr :		Physical address of cmd
353 * @frame_count :		Number of frames for the command
354 * @regs :			MFI register set
355 */
356static inline void
357megasas_fire_cmd_xscale(struct megasas_instance *instance,
358		dma_addr_t frame_phys_addr,
359		u32 frame_count,
360		struct megasas_register_set __iomem *regs)
361{
362	unsigned long flags;
363	spin_lock_irqsave(&instance->hba_lock, flags);
364	writel((frame_phys_addr >> 3)|(frame_count),
365	       &(regs)->inbound_queue_port);
366	spin_unlock_irqrestore(&instance->hba_lock, flags);
367}
368
369/**
370 * megasas_adp_reset_xscale -  For controller reset
371 * @regs:                              MFI register set
372 */
373static int
374megasas_adp_reset_xscale(struct megasas_instance *instance,
375	struct megasas_register_set __iomem *regs)
376{
377	u32 i;
378	u32 pcidata;
379	writel(MFI_ADP_RESET, &regs->inbound_doorbell);
380
381	for (i = 0; i < 3; i++)
382		msleep(1000); /* sleep for 3 secs */
383	pcidata  = 0;
384	pci_read_config_dword(instance->pdev, MFI_1068_PCSR_OFFSET, &pcidata);
385	printk(KERN_NOTICE "pcidata = %x\n", pcidata);
386	if (pcidata & 0x2) {
387		printk(KERN_NOTICE "mfi 1068 offset read=%x\n", pcidata);
388		pcidata &= ~0x2;
389		pci_write_config_dword(instance->pdev,
390				MFI_1068_PCSR_OFFSET, pcidata);
391
392		for (i = 0; i < 2; i++)
393			msleep(1000); /* need to wait 2 secs again */
394
395		pcidata  = 0;
396		pci_read_config_dword(instance->pdev,
397				MFI_1068_FW_HANDSHAKE_OFFSET, &pcidata);
398		printk(KERN_NOTICE "1068 offset handshake read=%x\n", pcidata);
399		if ((pcidata & 0xffff0000) == MFI_1068_FW_READY) {
400			printk(KERN_NOTICE "1068 offset pcidt=%x\n", pcidata);
401			pcidata = 0;
402			pci_write_config_dword(instance->pdev,
403				MFI_1068_FW_HANDSHAKE_OFFSET, pcidata);
404		}
405	}
406	return 0;
407}
408
409/**
410 * megasas_check_reset_xscale -	For controller reset check
411 * @regs:				MFI register set
412 */
413static int
414megasas_check_reset_xscale(struct megasas_instance *instance,
415		struct megasas_register_set __iomem *regs)
416{
417
418	if ((instance->adprecovery != MEGASAS_HBA_OPERATIONAL) &&
419	    (le32_to_cpu(*instance->consumer) ==
420		MEGASAS_ADPRESET_INPROG_SIGN))
421		return 1;
422	return 0;
423}
424
425static struct megasas_instance_template megasas_instance_template_xscale = {
426
427	.fire_cmd = megasas_fire_cmd_xscale,
428	.enable_intr = megasas_enable_intr_xscale,
429	.disable_intr = megasas_disable_intr_xscale,
430	.clear_intr = megasas_clear_intr_xscale,
431	.read_fw_status_reg = megasas_read_fw_status_reg_xscale,
432	.adp_reset = megasas_adp_reset_xscale,
433	.check_reset = megasas_check_reset_xscale,
434	.service_isr = megasas_isr,
435	.tasklet = megasas_complete_cmd_dpc,
436	.init_adapter = megasas_init_adapter_mfi,
437	.build_and_issue_cmd = megasas_build_and_issue_cmd,
438	.issue_dcmd = megasas_issue_dcmd,
439};
440
441/**
442*	This is the end of set of functions & definitions specific
443*	to xscale (deviceid : 1064R, PERC5) controllers
444*/
445
446/**
447*	The following functions are defined for ppc (deviceid : 0x60)
448* 	controllers
449*/
450
451/**
452 * megasas_enable_intr_ppc -	Enables interrupts
453 * @regs:			MFI register set
454 */
455static inline void
456megasas_enable_intr_ppc(struct megasas_instance *instance)
457{
458	struct megasas_register_set __iomem *regs;
459	regs = instance->reg_set;
460	writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
461
462	writel(~0x80000000, &(regs)->outbound_intr_mask);
463
464	/* Dummy readl to force pci flush */
465	readl(&regs->outbound_intr_mask);
466}
467
468/**
469 * megasas_disable_intr_ppc -	Disable interrupt
470 * @regs:			MFI register set
471 */
472static inline void
473megasas_disable_intr_ppc(struct megasas_instance *instance)
474{
475	struct megasas_register_set __iomem *regs;
476	u32 mask = 0xFFFFFFFF;
477	regs = instance->reg_set;
478	writel(mask, &regs->outbound_intr_mask);
479	/* Dummy readl to force pci flush */
480	readl(&regs->outbound_intr_mask);
481}
482
483/**
484 * megasas_read_fw_status_reg_ppc - returns the current FW status value
485 * @regs:			MFI register set
486 */
487static u32
488megasas_read_fw_status_reg_ppc(struct megasas_register_set __iomem * regs)
489{
490	return readl(&(regs)->outbound_scratch_pad);
491}
492
493/**
494 * megasas_clear_interrupt_ppc -	Check & clear interrupt
495 * @regs:				MFI register set
496 */
497static int
498megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs)
499{
500	u32 status, mfiStatus = 0;
501
502	/*
503	 * Check if it is our interrupt
504	 */
505	status = readl(&regs->outbound_intr_status);
506
507	if (status & MFI_REPLY_1078_MESSAGE_INTERRUPT)
508		mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
509
510	if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT)
511		mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
512
513	/*
514	 * Clear the interrupt by writing back the same value
515	 */
516	writel(status, &regs->outbound_doorbell_clear);
517
518	/* Dummy readl to force pci flush */
519	readl(&regs->outbound_doorbell_clear);
520
521	return mfiStatus;
522}
523
524/**
525 * megasas_fire_cmd_ppc -	Sends command to the FW
526 * @frame_phys_addr :		Physical address of cmd
527 * @frame_count :		Number of frames for the command
528 * @regs :			MFI register set
529 */
530static inline void
531megasas_fire_cmd_ppc(struct megasas_instance *instance,
532		dma_addr_t frame_phys_addr,
533		u32 frame_count,
534		struct megasas_register_set __iomem *regs)
535{
536	unsigned long flags;
537	spin_lock_irqsave(&instance->hba_lock, flags);
538	writel((frame_phys_addr | (frame_count<<1))|1,
539			&(regs)->inbound_queue_port);
540	spin_unlock_irqrestore(&instance->hba_lock, flags);
541}
542
543/**
544 * megasas_check_reset_ppc -	For controller reset check
545 * @regs:				MFI register set
546 */
547static int
548megasas_check_reset_ppc(struct megasas_instance *instance,
549			struct megasas_register_set __iomem *regs)
550{
551	if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
552		return 1;
553
554	return 0;
555}
556
557static struct megasas_instance_template megasas_instance_template_ppc = {
558
559	.fire_cmd = megasas_fire_cmd_ppc,
560	.enable_intr = megasas_enable_intr_ppc,
561	.disable_intr = megasas_disable_intr_ppc,
562	.clear_intr = megasas_clear_intr_ppc,
563	.read_fw_status_reg = megasas_read_fw_status_reg_ppc,
564	.adp_reset = megasas_adp_reset_xscale,
565	.check_reset = megasas_check_reset_ppc,
566	.service_isr = megasas_isr,
567	.tasklet = megasas_complete_cmd_dpc,
568	.init_adapter = megasas_init_adapter_mfi,
569	.build_and_issue_cmd = megasas_build_and_issue_cmd,
570	.issue_dcmd = megasas_issue_dcmd,
571};
572
573/**
574 * megasas_enable_intr_skinny -	Enables interrupts
575 * @regs:			MFI register set
576 */
577static inline void
578megasas_enable_intr_skinny(struct megasas_instance *instance)
579{
580	struct megasas_register_set __iomem *regs;
581	regs = instance->reg_set;
582	writel(0xFFFFFFFF, &(regs)->outbound_intr_mask);
583
584	writel(~MFI_SKINNY_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
585
586	/* Dummy readl to force pci flush */
587	readl(&regs->outbound_intr_mask);
588}
589
590/**
591 * megasas_disable_intr_skinny -	Disables interrupt
592 * @regs:			MFI register set
593 */
594static inline void
595megasas_disable_intr_skinny(struct megasas_instance *instance)
596{
597	struct megasas_register_set __iomem *regs;
598	u32 mask = 0xFFFFFFFF;
599	regs = instance->reg_set;
600	writel(mask, &regs->outbound_intr_mask);
601	/* Dummy readl to force pci flush */
602	readl(&regs->outbound_intr_mask);
603}
604
605/**
606 * megasas_read_fw_status_reg_skinny - returns the current FW status value
607 * @regs:			MFI register set
608 */
609static u32
610megasas_read_fw_status_reg_skinny(struct megasas_register_set __iomem *regs)
611{
612	return readl(&(regs)->outbound_scratch_pad);
613}
614
615/**
616 * megasas_clear_interrupt_skinny -	Check & clear interrupt
617 * @regs:				MFI register set
618 */
619static int
620megasas_clear_intr_skinny(struct megasas_register_set __iomem *regs)
621{
622	u32 status;
623	u32 mfiStatus = 0;
624
625	/*
626	 * Check if it is our interrupt
627	 */
628	status = readl(&regs->outbound_intr_status);
629
630	if (!(status & MFI_SKINNY_ENABLE_INTERRUPT_MASK)) {
631		return 0;
632	}
633
634	/*
635	 * Check if it is our interrupt
636	 */
637	if ((megasas_read_fw_status_reg_skinny(regs) & MFI_STATE_MASK) ==
638	    MFI_STATE_FAULT) {
639		mfiStatus = MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
640	} else
641		mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
642
643	/*
644	 * Clear the interrupt by writing back the same value
645	 */
646	writel(status, &regs->outbound_intr_status);
647
648	/*
649	* dummy read to flush PCI
650	*/
651	readl(&regs->outbound_intr_status);
652
653	return mfiStatus;
654}
655
656/**
657 * megasas_fire_cmd_skinny -	Sends command to the FW
658 * @frame_phys_addr :		Physical address of cmd
659 * @frame_count :		Number of frames for the command
660 * @regs :			MFI register set
661 */
662static inline void
663megasas_fire_cmd_skinny(struct megasas_instance *instance,
664			dma_addr_t frame_phys_addr,
665			u32 frame_count,
666			struct megasas_register_set __iomem *regs)
667{
668	unsigned long flags;
669	spin_lock_irqsave(&instance->hba_lock, flags);
670	writel(upper_32_bits(frame_phys_addr),
671	       &(regs)->inbound_high_queue_port);
672	writel((lower_32_bits(frame_phys_addr) | (frame_count<<1))|1,
673	       &(regs)->inbound_low_queue_port);
674	spin_unlock_irqrestore(&instance->hba_lock, flags);
675}
676
677/**
678 * megasas_check_reset_skinny -	For controller reset check
679 * @regs:				MFI register set
680 */
681static int
682megasas_check_reset_skinny(struct megasas_instance *instance,
683				struct megasas_register_set __iomem *regs)
684{
685	if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
686		return 1;
687
688	return 0;
689}
690
691static struct megasas_instance_template megasas_instance_template_skinny = {
692
693	.fire_cmd = megasas_fire_cmd_skinny,
694	.enable_intr = megasas_enable_intr_skinny,
695	.disable_intr = megasas_disable_intr_skinny,
696	.clear_intr = megasas_clear_intr_skinny,
697	.read_fw_status_reg = megasas_read_fw_status_reg_skinny,
698	.adp_reset = megasas_adp_reset_gen2,
699	.check_reset = megasas_check_reset_skinny,
700	.service_isr = megasas_isr,
701	.tasklet = megasas_complete_cmd_dpc,
702	.init_adapter = megasas_init_adapter_mfi,
703	.build_and_issue_cmd = megasas_build_and_issue_cmd,
704	.issue_dcmd = megasas_issue_dcmd,
705};
706
707
708/**
709*	The following functions are defined for gen2 (deviceid : 0x78 0x79)
710*	controllers
711*/
712
713/**
714 * megasas_enable_intr_gen2 -  Enables interrupts
715 * @regs:                      MFI register set
716 */
717static inline void
718megasas_enable_intr_gen2(struct megasas_instance *instance)
719{
720	struct megasas_register_set __iomem *regs;
721	regs = instance->reg_set;
722	writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
723
724	/* write ~0x00000005 (4 & 1) to the intr mask*/
725	writel(~MFI_GEN2_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
726
727	/* Dummy readl to force pci flush */
728	readl(&regs->outbound_intr_mask);
729}
730
731/**
732 * megasas_disable_intr_gen2 - Disables interrupt
733 * @regs:                      MFI register set
734 */
735static inline void
736megasas_disable_intr_gen2(struct megasas_instance *instance)
737{
738	struct megasas_register_set __iomem *regs;
739	u32 mask = 0xFFFFFFFF;
740	regs = instance->reg_set;
741	writel(mask, &regs->outbound_intr_mask);
742	/* Dummy readl to force pci flush */
743	readl(&regs->outbound_intr_mask);
744}
745
746/**
747 * megasas_read_fw_status_reg_gen2 - returns the current FW status value
748 * @regs:                      MFI register set
749 */
750static u32
751megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem *regs)
752{
753	return readl(&(regs)->outbound_scratch_pad);
754}
755
756/**
757 * megasas_clear_interrupt_gen2 -      Check & clear interrupt
758 * @regs:                              MFI register set
759 */
760static int
761megasas_clear_intr_gen2(struct megasas_register_set __iomem *regs)
762{
763	u32 status;
764	u32 mfiStatus = 0;
765	/*
766	 * Check if it is our interrupt
767	 */
768	status = readl(&regs->outbound_intr_status);
769
770	if (status & MFI_INTR_FLAG_REPLY_MESSAGE) {
771		mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
772	}
773	if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT) {
774		mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
775	}
776
777	/*
778	 * Clear the interrupt by writing back the same value
779	 */
780	if (mfiStatus)
781		writel(status, &regs->outbound_doorbell_clear);
782
783	/* Dummy readl to force pci flush */
784	readl(&regs->outbound_intr_status);
785
786	return mfiStatus;
787}
788/**
789 * megasas_fire_cmd_gen2 -     Sends command to the FW
790 * @frame_phys_addr :          Physical address of cmd
791 * @frame_count :              Number of frames for the command
792 * @regs :                     MFI register set
793 */
794static inline void
795megasas_fire_cmd_gen2(struct megasas_instance *instance,
796			dma_addr_t frame_phys_addr,
797			u32 frame_count,
798			struct megasas_register_set __iomem *regs)
799{
800	unsigned long flags;
801	spin_lock_irqsave(&instance->hba_lock, flags);
802	writel((frame_phys_addr | (frame_count<<1))|1,
803			&(regs)->inbound_queue_port);
804	spin_unlock_irqrestore(&instance->hba_lock, flags);
805}
806
807/**
808 * megasas_adp_reset_gen2 -	For controller reset
809 * @regs:				MFI register set
810 */
811static int
812megasas_adp_reset_gen2(struct megasas_instance *instance,
813			struct megasas_register_set __iomem *reg_set)
814{
815	u32			retry = 0 ;
816	u32			HostDiag;
817	u32			*seq_offset = &reg_set->seq_offset;
818	u32			*hostdiag_offset = &reg_set->host_diag;
819
820	if (instance->instancet == &megasas_instance_template_skinny) {
821		seq_offset = &reg_set->fusion_seq_offset;
822		hostdiag_offset = &reg_set->fusion_host_diag;
823	}
824
825	writel(0, seq_offset);
826	writel(4, seq_offset);
827	writel(0xb, seq_offset);
828	writel(2, seq_offset);
829	writel(7, seq_offset);
830	writel(0xd, seq_offset);
831
832	msleep(1000);
833
834	HostDiag = (u32)readl(hostdiag_offset);
835
836	while ( !( HostDiag & DIAG_WRITE_ENABLE) ) {
837		msleep(100);
838		HostDiag = (u32)readl(hostdiag_offset);
839		printk(KERN_NOTICE "RESETGEN2: retry=%x, hostdiag=%x\n",
840					retry, HostDiag);
841
842		if (retry++ >= 100)
843			return 1;
844
845	}
846
847	printk(KERN_NOTICE "ADP_RESET_GEN2: HostDiag=%x\n", HostDiag);
848
849	writel((HostDiag | DIAG_RESET_ADAPTER), hostdiag_offset);
850
851	ssleep(10);
852
853	HostDiag = (u32)readl(hostdiag_offset);
854	while ( ( HostDiag & DIAG_RESET_ADAPTER) ) {
855		msleep(100);
856		HostDiag = (u32)readl(hostdiag_offset);
857		printk(KERN_NOTICE "RESET_GEN2: retry=%x, hostdiag=%x\n",
858				retry, HostDiag);
859
860		if (retry++ >= 1000)
861			return 1;
862
863	}
864	return 0;
865}
866
867/**
868 * megasas_check_reset_gen2 -	For controller reset check
869 * @regs:				MFI register set
870 */
871static int
872megasas_check_reset_gen2(struct megasas_instance *instance,
873		struct megasas_register_set __iomem *regs)
874{
875	if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
876		return 1;
877	}
878
879	return 0;
880}
881
882static struct megasas_instance_template megasas_instance_template_gen2 = {
883
884	.fire_cmd = megasas_fire_cmd_gen2,
885	.enable_intr = megasas_enable_intr_gen2,
886	.disable_intr = megasas_disable_intr_gen2,
887	.clear_intr = megasas_clear_intr_gen2,
888	.read_fw_status_reg = megasas_read_fw_status_reg_gen2,
889	.adp_reset = megasas_adp_reset_gen2,
890	.check_reset = megasas_check_reset_gen2,
891	.service_isr = megasas_isr,
892	.tasklet = megasas_complete_cmd_dpc,
893	.init_adapter = megasas_init_adapter_mfi,
894	.build_and_issue_cmd = megasas_build_and_issue_cmd,
895	.issue_dcmd = megasas_issue_dcmd,
896};
897
898/**
899*	This is the end of set of functions & definitions
900*       specific to gen2 (deviceid : 0x78, 0x79) controllers
901*/
902
903/*
904 * Template added for TB (Fusion)
905 */
906extern struct megasas_instance_template megasas_instance_template_fusion;
907
908/**
909 * megasas_issue_polled -	Issues a polling command
910 * @instance:			Adapter soft state
911 * @cmd:			Command packet to be issued
912 *
913 * For polling, MFI requires the cmd_status to be set to 0xFF before posting.
914 */
915int
916megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
917{
918	int seconds;
919
920	struct megasas_header *frame_hdr = &cmd->frame->hdr;
921
922	frame_hdr->cmd_status = MFI_CMD_STATUS_POLL_MODE;
923	frame_hdr->flags |= cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE);
924
925	/*
926	 * Issue the frame using inbound queue port
927	 */
928	instance->instancet->issue_dcmd(instance, cmd);
929
930	/*
931	 * Wait for cmd_status to change
932	 */
933	if (instance->requestorId)
934		seconds = MEGASAS_ROUTINE_WAIT_TIME_VF;
935	else
936		seconds = MFI_POLL_TIMEOUT_SECS;
937	return wait_and_poll(instance, cmd, seconds);
938}
939
940/**
941 * megasas_issue_blocked_cmd -	Synchronous wrapper around regular FW cmds
942 * @instance:			Adapter soft state
943 * @cmd:			Command to be issued
944 * @timeout:			Timeout in seconds
945 *
946 * This function waits on an event for the command to be returned from ISR.
947 * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
948 * Used to issue ioctl commands.
949 */
950int
951megasas_issue_blocked_cmd(struct megasas_instance *instance,
952			  struct megasas_cmd *cmd, int timeout)
953{
954	int ret = 0;
955	cmd->cmd_status = ENODATA;
956
957	cmd->is_wait_event = 1;
958	instance->instancet->issue_dcmd(instance, cmd);
959	if (timeout) {
960		ret = wait_event_timeout(instance->int_cmd_wait_q,
961				cmd->cmd_status != ENODATA, timeout * HZ);
962		if (!ret)
963			return 1;
964	} else
965		wait_event(instance->int_cmd_wait_q,
966				cmd->cmd_status != ENODATA);
967
968	return 0;
969}
970
971/**
972 * megasas_issue_blocked_abort_cmd -	Aborts previously issued cmd
973 * @instance:				Adapter soft state
974 * @cmd_to_abort:			Previously issued cmd to be aborted
975 * @timeout:				Timeout in seconds
976 *
977 * MFI firmware can abort previously issued AEN comamnd (automatic event
978 * notification). The megasas_issue_blocked_abort_cmd() issues such abort
979 * cmd and waits for return status.
980 * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
981 */
982static int
983megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
984				struct megasas_cmd *cmd_to_abort, int timeout)
985{
986	struct megasas_cmd *cmd;
987	struct megasas_abort_frame *abort_fr;
988	int ret = 0;
989
990	cmd = megasas_get_cmd(instance);
991
992	if (!cmd)
993		return -1;
994
995	abort_fr = &cmd->frame->abort;
996
997	/*
998	 * Prepare and issue the abort frame
999	 */
1000	abort_fr->cmd = MFI_CMD_ABORT;
1001	abort_fr->cmd_status = 0xFF;
1002	abort_fr->flags = cpu_to_le16(0);
1003	abort_fr->abort_context = cpu_to_le32(cmd_to_abort->index);
1004	abort_fr->abort_mfi_phys_addr_lo =
1005		cpu_to_le32(lower_32_bits(cmd_to_abort->frame_phys_addr));
1006	abort_fr->abort_mfi_phys_addr_hi =
1007		cpu_to_le32(upper_32_bits(cmd_to_abort->frame_phys_addr));
1008
1009	cmd->sync_cmd = 1;
1010	cmd->cmd_status = ENODATA;
1011
1012	instance->instancet->issue_dcmd(instance, cmd);
1013
1014	if (timeout) {
1015		ret = wait_event_timeout(instance->abort_cmd_wait_q,
1016				cmd->cmd_status != ENODATA, timeout * HZ);
1017		if (!ret) {
1018			dev_err(&instance->pdev->dev, "Command timedout"
1019				"from %s\n", __func__);
1020			return 1;
1021		}
1022	} else
1023		wait_event(instance->abort_cmd_wait_q,
1024				cmd->cmd_status != ENODATA);
1025
1026	cmd->sync_cmd = 0;
1027
1028	megasas_return_cmd(instance, cmd);
1029	return 0;
1030}
1031
1032/**
1033 * megasas_make_sgl32 -	Prepares 32-bit SGL
1034 * @instance:		Adapter soft state
1035 * @scp:		SCSI command from the mid-layer
1036 * @mfi_sgl:		SGL to be filled in
1037 *
1038 * If successful, this function returns the number of SG elements. Otherwise,
1039 * it returnes -1.
1040 */
1041static int
1042megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp,
1043		   union megasas_sgl *mfi_sgl)
1044{
1045	int i;
1046	int sge_count;
1047	struct scatterlist *os_sgl;
1048
1049	sge_count = scsi_dma_map(scp);
1050	BUG_ON(sge_count < 0);
1051
1052	if (sge_count) {
1053		scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1054			mfi_sgl->sge32[i].length = cpu_to_le32(sg_dma_len(os_sgl));
1055			mfi_sgl->sge32[i].phys_addr = cpu_to_le32(sg_dma_address(os_sgl));
1056		}
1057	}
1058	return sge_count;
1059}
1060
1061/**
1062 * megasas_make_sgl64 -	Prepares 64-bit SGL
1063 * @instance:		Adapter soft state
1064 * @scp:		SCSI command from the mid-layer
1065 * @mfi_sgl:		SGL to be filled in
1066 *
1067 * If successful, this function returns the number of SG elements. Otherwise,
1068 * it returnes -1.
1069 */
1070static int
1071megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
1072		   union megasas_sgl *mfi_sgl)
1073{
1074	int i;
1075	int sge_count;
1076	struct scatterlist *os_sgl;
1077
1078	sge_count = scsi_dma_map(scp);
1079	BUG_ON(sge_count < 0);
1080
1081	if (sge_count) {
1082		scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1083			mfi_sgl->sge64[i].length = cpu_to_le32(sg_dma_len(os_sgl));
1084			mfi_sgl->sge64[i].phys_addr = cpu_to_le64(sg_dma_address(os_sgl));
1085		}
1086	}
1087	return sge_count;
1088}
1089
1090/**
1091 * megasas_make_sgl_skinny - Prepares IEEE SGL
1092 * @instance:           Adapter soft state
1093 * @scp:                SCSI command from the mid-layer
1094 * @mfi_sgl:            SGL to be filled in
1095 *
1096 * If successful, this function returns the number of SG elements. Otherwise,
1097 * it returnes -1.
1098 */
1099static int
1100megasas_make_sgl_skinny(struct megasas_instance *instance,
1101		struct scsi_cmnd *scp, union megasas_sgl *mfi_sgl)
1102{
1103	int i;
1104	int sge_count;
1105	struct scatterlist *os_sgl;
1106
1107	sge_count = scsi_dma_map(scp);
1108
1109	if (sge_count) {
1110		scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1111			mfi_sgl->sge_skinny[i].length =
1112				cpu_to_le32(sg_dma_len(os_sgl));
1113			mfi_sgl->sge_skinny[i].phys_addr =
1114				cpu_to_le64(sg_dma_address(os_sgl));
1115			mfi_sgl->sge_skinny[i].flag = cpu_to_le32(0);
1116		}
1117	}
1118	return sge_count;
1119}
1120
1121 /**
1122 * megasas_get_frame_count - Computes the number of frames
1123 * @frame_type		: type of frame- io or pthru frame
1124 * @sge_count		: number of sg elements
1125 *
1126 * Returns the number of frames required for numnber of sge's (sge_count)
1127 */
1128
1129static u32 megasas_get_frame_count(struct megasas_instance *instance,
1130			u8 sge_count, u8 frame_type)
1131{
1132	int num_cnt;
1133	int sge_bytes;
1134	u32 sge_sz;
1135	u32 frame_count=0;
1136
1137	sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
1138	    sizeof(struct megasas_sge32);
1139
1140	if (instance->flag_ieee) {
1141		sge_sz = sizeof(struct megasas_sge_skinny);
1142	}
1143
1144	/*
1145	 * Main frame can contain 2 SGEs for 64-bit SGLs and
1146	 * 3 SGEs for 32-bit SGLs for ldio &
1147	 * 1 SGEs for 64-bit SGLs and
1148	 * 2 SGEs for 32-bit SGLs for pthru frame
1149	 */
1150	if (unlikely(frame_type == PTHRU_FRAME)) {
1151		if (instance->flag_ieee == 1) {
1152			num_cnt = sge_count - 1;
1153		} else if (IS_DMA64)
1154			num_cnt = sge_count - 1;
1155		else
1156			num_cnt = sge_count - 2;
1157	} else {
1158		if (instance->flag_ieee == 1) {
1159			num_cnt = sge_count - 1;
1160		} else if (IS_DMA64)
1161			num_cnt = sge_count - 2;
1162		else
1163			num_cnt = sge_count - 3;
1164	}
1165
1166	if(num_cnt>0){
1167		sge_bytes = sge_sz * num_cnt;
1168
1169		frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) +
1170		    ((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) ;
1171	}
1172	/* Main frame */
1173	frame_count +=1;
1174
1175	if (frame_count > 7)
1176		frame_count = 8;
1177	return frame_count;
1178}
1179
1180/**
1181 * megasas_build_dcdb -	Prepares a direct cdb (DCDB) command
1182 * @instance:		Adapter soft state
1183 * @scp:		SCSI command
1184 * @cmd:		Command to be prepared in
1185 *
1186 * This function prepares CDB commands. These are typcially pass-through
1187 * commands to the devices.
1188 */
1189static int
1190megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
1191		   struct megasas_cmd *cmd)
1192{
1193	u32 is_logical;
1194	u32 device_id;
1195	u16 flags = 0;
1196	struct megasas_pthru_frame *pthru;
1197
1198	is_logical = MEGASAS_IS_LOGICAL(scp);
1199	device_id = MEGASAS_DEV_INDEX(instance, scp);
1200	pthru = (struct megasas_pthru_frame *)cmd->frame;
1201
1202	if (scp->sc_data_direction == PCI_DMA_TODEVICE)
1203		flags = MFI_FRAME_DIR_WRITE;
1204	else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1205		flags = MFI_FRAME_DIR_READ;
1206	else if (scp->sc_data_direction == PCI_DMA_NONE)
1207		flags = MFI_FRAME_DIR_NONE;
1208
1209	if (instance->flag_ieee == 1) {
1210		flags |= MFI_FRAME_IEEE;
1211	}
1212
1213	/*
1214	 * Prepare the DCDB frame
1215	 */
1216	pthru->cmd = (is_logical) ? MFI_CMD_LD_SCSI_IO : MFI_CMD_PD_SCSI_IO;
1217	pthru->cmd_status = 0x0;
1218	pthru->scsi_status = 0x0;
1219	pthru->target_id = device_id;
1220	pthru->lun = scp->device->lun;
1221	pthru->cdb_len = scp->cmd_len;
1222	pthru->timeout = 0;
1223	pthru->pad_0 = 0;
1224	pthru->flags = cpu_to_le16(flags);
1225	pthru->data_xfer_len = cpu_to_le32(scsi_bufflen(scp));
1226
1227	memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);
1228
1229	/*
1230	* If the command is for the tape device, set the
1231	* pthru timeout to the os layer timeout value.
1232	*/
1233	if (scp->device->type == TYPE_TAPE) {
1234		if ((scp->request->timeout / HZ) > 0xFFFF)
1235			pthru->timeout = 0xFFFF;
1236		else
1237			pthru->timeout = cpu_to_le16(scp->request->timeout / HZ);
1238	}
1239
1240	/*
1241	 * Construct SGL
1242	 */
1243	if (instance->flag_ieee == 1) {
1244		pthru->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1245		pthru->sge_count = megasas_make_sgl_skinny(instance, scp,
1246						      &pthru->sgl);
1247	} else if (IS_DMA64) {
1248		pthru->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1249		pthru->sge_count = megasas_make_sgl64(instance, scp,
1250						      &pthru->sgl);
1251	} else
1252		pthru->sge_count = megasas_make_sgl32(instance, scp,
1253						      &pthru->sgl);
1254
1255	if (pthru->sge_count > instance->max_num_sge) {
1256		printk(KERN_ERR "megasas: DCDB two many SGE NUM=%x\n",
1257			pthru->sge_count);
1258		return 0;
1259	}
1260
1261	/*
1262	 * Sense info specific
1263	 */
1264	pthru->sense_len = SCSI_SENSE_BUFFERSIZE;
1265	pthru->sense_buf_phys_addr_hi =
1266		cpu_to_le32(upper_32_bits(cmd->sense_phys_addr));
1267	pthru->sense_buf_phys_addr_lo =
1268		cpu_to_le32(lower_32_bits(cmd->sense_phys_addr));
1269
1270	/*
1271	 * Compute the total number of frames this command consumes. FW uses
1272	 * this number to pull sufficient number of frames from host memory.
1273	 */
1274	cmd->frame_count = megasas_get_frame_count(instance, pthru->sge_count,
1275							PTHRU_FRAME);
1276
1277	return cmd->frame_count;
1278}
1279
1280/**
1281 * megasas_build_ldio -	Prepares IOs to logical devices
1282 * @instance:		Adapter soft state
1283 * @scp:		SCSI command
1284 * @cmd:		Command to be prepared
1285 *
1286 * Frames (and accompanying SGLs) for regular SCSI IOs use this function.
1287 */
1288static int
1289megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
1290		   struct megasas_cmd *cmd)
1291{
1292	u32 device_id;
1293	u8 sc = scp->cmnd[0];
1294	u16 flags = 0;
1295	struct megasas_io_frame *ldio;
1296
1297	device_id = MEGASAS_DEV_INDEX(instance, scp);
1298	ldio = (struct megasas_io_frame *)cmd->frame;
1299
1300	if (scp->sc_data_direction == PCI_DMA_TODEVICE)
1301		flags = MFI_FRAME_DIR_WRITE;
1302	else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1303		flags = MFI_FRAME_DIR_READ;
1304
1305	if (instance->flag_ieee == 1) {
1306		flags |= MFI_FRAME_IEEE;
1307	}
1308
1309	/*
1310	 * Prepare the Logical IO frame: 2nd bit is zero for all read cmds
1311	 */
1312	ldio->cmd = (sc & 0x02) ? MFI_CMD_LD_WRITE : MFI_CMD_LD_READ;
1313	ldio->cmd_status = 0x0;
1314	ldio->scsi_status = 0x0;
1315	ldio->target_id = device_id;
1316	ldio->timeout = 0;
1317	ldio->reserved_0 = 0;
1318	ldio->pad_0 = 0;
1319	ldio->flags = cpu_to_le16(flags);
1320	ldio->start_lba_hi = 0;
1321	ldio->access_byte = (scp->cmd_len != 6) ? scp->cmnd[1] : 0;
1322
1323	/*
1324	 * 6-byte READ(0x08) or WRITE(0x0A) cdb
1325	 */
1326	if (scp->cmd_len == 6) {
1327		ldio->lba_count = cpu_to_le32((u32) scp->cmnd[4]);
1328		ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[1] << 16) |
1329						 ((u32) scp->cmnd[2] << 8) |
1330						 (u32) scp->cmnd[3]);
1331
1332		ldio->start_lba_lo &= cpu_to_le32(0x1FFFFF);
1333	}
1334
1335	/*
1336	 * 10-byte READ(0x28) or WRITE(0x2A) cdb
1337	 */
1338	else if (scp->cmd_len == 10) {
1339		ldio->lba_count = cpu_to_le32((u32) scp->cmnd[8] |
1340					      ((u32) scp->cmnd[7] << 8));
1341		ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1342						 ((u32) scp->cmnd[3] << 16) |
1343						 ((u32) scp->cmnd[4] << 8) |
1344						 (u32) scp->cmnd[5]);
1345	}
1346
1347	/*
1348	 * 12-byte READ(0xA8) or WRITE(0xAA) cdb
1349	 */
1350	else if (scp->cmd_len == 12) {
1351		ldio->lba_count = cpu_to_le32(((u32) scp->cmnd[6] << 24) |
1352					      ((u32) scp->cmnd[7] << 16) |
1353					      ((u32) scp->cmnd[8] << 8) |
1354					      (u32) scp->cmnd[9]);
1355
1356		ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1357						 ((u32) scp->cmnd[3] << 16) |
1358						 ((u32) scp->cmnd[4] << 8) |
1359						 (u32) scp->cmnd[5]);
1360	}
1361
1362	/*
1363	 * 16-byte READ(0x88) or WRITE(0x8A) cdb
1364	 */
1365	else if (scp->cmd_len == 16) {
1366		ldio->lba_count = cpu_to_le32(((u32) scp->cmnd[10] << 24) |
1367					      ((u32) scp->cmnd[11] << 16) |
1368					      ((u32) scp->cmnd[12] << 8) |
1369					      (u32) scp->cmnd[13]);
1370
1371		ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[6] << 24) |
1372						 ((u32) scp->cmnd[7] << 16) |
1373						 ((u32) scp->cmnd[8] << 8) |
1374						 (u32) scp->cmnd[9]);
1375
1376		ldio->start_lba_hi = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1377						 ((u32) scp->cmnd[3] << 16) |
1378						 ((u32) scp->cmnd[4] << 8) |
1379						 (u32) scp->cmnd[5]);
1380
1381	}
1382
1383	/*
1384	 * Construct SGL
1385	 */
1386	if (instance->flag_ieee) {
1387		ldio->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1388		ldio->sge_count = megasas_make_sgl_skinny(instance, scp,
1389					      &ldio->sgl);
1390	} else if (IS_DMA64) {
1391		ldio->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1392		ldio->sge_count = megasas_make_sgl64(instance, scp, &ldio->sgl);
1393	} else
1394		ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl);
1395
1396	if (ldio->sge_count > instance->max_num_sge) {
1397		printk(KERN_ERR "megasas: build_ld_io: sge_count = %x\n",
1398			ldio->sge_count);
1399		return 0;
1400	}
1401
1402	/*
1403	 * Sense info specific
1404	 */
1405	ldio->sense_len = SCSI_SENSE_BUFFERSIZE;
1406	ldio->sense_buf_phys_addr_hi = 0;
1407	ldio->sense_buf_phys_addr_lo = cpu_to_le32(cmd->sense_phys_addr);
1408
1409	/*
1410	 * Compute the total number of frames this command consumes. FW uses
1411	 * this number to pull sufficient number of frames from host memory.
1412	 */
1413	cmd->frame_count = megasas_get_frame_count(instance,
1414			ldio->sge_count, IO_FRAME);
1415
1416	return cmd->frame_count;
1417}
1418
1419/**
1420 * megasas_cmd_type -		Checks if the cmd is for logical drive/sysPD
1421 *				and whether it's RW or non RW
1422 * @scmd:			SCSI command
1423 *
1424 */
1425inline int megasas_cmd_type(struct scsi_cmnd *cmd)
1426{
1427	int ret;
1428
1429	switch (cmd->cmnd[0]) {
1430	case READ_10:
1431	case WRITE_10:
1432	case READ_12:
1433	case WRITE_12:
1434	case READ_6:
1435	case WRITE_6:
1436	case READ_16:
1437	case WRITE_16:
1438		ret = (MEGASAS_IS_LOGICAL(cmd)) ?
1439			READ_WRITE_LDIO : READ_WRITE_SYSPDIO;
1440		break;
1441	default:
1442		ret = (MEGASAS_IS_LOGICAL(cmd)) ?
1443			NON_READ_WRITE_LDIO : NON_READ_WRITE_SYSPDIO;
1444	}
1445	return ret;
1446}
1447
1448 /**
1449 * megasas_dump_pending_frames -	Dumps the frame address of all pending cmds
1450 *                              	in FW
1451 * @instance:				Adapter soft state
1452 */
1453static inline void
1454megasas_dump_pending_frames(struct megasas_instance *instance)
1455{
1456	struct megasas_cmd *cmd;
1457	int i,n;
1458	union megasas_sgl *mfi_sgl;
1459	struct megasas_io_frame *ldio;
1460	struct megasas_pthru_frame *pthru;
1461	u32 sgcount;
1462	u32 max_cmd = instance->max_fw_cmds;
1463
1464	printk(KERN_ERR "\nmegasas[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance->host->host_no);
1465	printk(KERN_ERR "megasas[%d]: Total OS Pending cmds : %d\n",instance->host->host_no,atomic_read(&instance->fw_outstanding));
1466	if (IS_DMA64)
1467		printk(KERN_ERR "\nmegasas[%d]: 64 bit SGLs were sent to FW\n",instance->host->host_no);
1468	else
1469		printk(KERN_ERR "\nmegasas[%d]: 32 bit SGLs were sent to FW\n",instance->host->host_no);
1470
1471	printk(KERN_ERR "megasas[%d]: Pending OS cmds in FW : \n",instance->host->host_no);
1472	for (i = 0; i < max_cmd; i++) {
1473		cmd = instance->cmd_list[i];
1474		if(!cmd->scmd)
1475			continue;
1476		printk(KERN_ERR "megasas[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);
1477		if (megasas_cmd_type(cmd->scmd) == READ_WRITE_LDIO) {
1478			ldio = (struct megasas_io_frame *)cmd->frame;
1479			mfi_sgl = &ldio->sgl;
1480			sgcount = ldio->sge_count;
1481			printk(KERN_ERR "megasas[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x,"
1482			" lba lo : 0x%x, lba_hi : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",
1483			instance->host->host_no, cmd->frame_count, ldio->cmd, ldio->target_id,
1484			le32_to_cpu(ldio->start_lba_lo), le32_to_cpu(ldio->start_lba_hi),
1485			le32_to_cpu(ldio->sense_buf_phys_addr_lo), sgcount);
1486		}
1487		else {
1488			pthru = (struct megasas_pthru_frame *) cmd->frame;
1489			mfi_sgl = &pthru->sgl;
1490			sgcount = pthru->sge_count;
1491			printk(KERN_ERR "megasas[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x, "
1492			"lun : 0x%x, cdb_len : 0x%x, data xfer len : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",
1493			instance->host->host_no, cmd->frame_count, pthru->cmd, pthru->target_id,
1494			pthru->lun, pthru->cdb_len, le32_to_cpu(pthru->data_xfer_len),
1495			le32_to_cpu(pthru->sense_buf_phys_addr_lo), sgcount);
1496		}
1497	if(megasas_dbg_lvl & MEGASAS_DBG_LVL){
1498		for (n = 0; n < sgcount; n++){
1499			if (IS_DMA64)
1500				printk(KERN_ERR "megasas: sgl len : 0x%x, sgl addr : 0x%llx ",
1501					le32_to_cpu(mfi_sgl->sge64[n].length),
1502					le64_to_cpu(mfi_sgl->sge64[n].phys_addr));
1503			else
1504				printk(KERN_ERR "megasas: sgl len : 0x%x, sgl addr : 0x%x ",
1505					le32_to_cpu(mfi_sgl->sge32[n].length),
1506					le32_to_cpu(mfi_sgl->sge32[n].phys_addr));
1507			}
1508		}
1509		printk(KERN_ERR "\n");
1510	} /*for max_cmd*/
1511	printk(KERN_ERR "\nmegasas[%d]: Pending Internal cmds in FW : \n",instance->host->host_no);
1512	for (i = 0; i < max_cmd; i++) {
1513
1514		cmd = instance->cmd_list[i];
1515
1516		if(cmd->sync_cmd == 1){
1517			printk(KERN_ERR "0x%08lx : ", (unsigned long)cmd->frame_phys_addr);
1518		}
1519	}
1520	printk(KERN_ERR "megasas[%d]: Dumping Done.\n\n",instance->host->host_no);
1521}
1522
1523u32
1524megasas_build_and_issue_cmd(struct megasas_instance *instance,
1525			    struct scsi_cmnd *scmd)
1526{
1527	struct megasas_cmd *cmd;
1528	u32 frame_count;
1529
1530	cmd = megasas_get_cmd(instance);
1531	if (!cmd)
1532		return SCSI_MLQUEUE_HOST_BUSY;
1533
1534	/*
1535	 * Logical drive command
1536	 */
1537	if (megasas_cmd_type(scmd) == READ_WRITE_LDIO)
1538		frame_count = megasas_build_ldio(instance, scmd, cmd);
1539	else
1540		frame_count = megasas_build_dcdb(instance, scmd, cmd);
1541
1542	if (!frame_count)
1543		goto out_return_cmd;
1544
1545	cmd->scmd = scmd;
1546	scmd->SCp.ptr = (char *)cmd;
1547
1548	/*
1549	 * Issue the command to the FW
1550	 */
1551	atomic_inc(&instance->fw_outstanding);
1552
1553	instance->instancet->fire_cmd(instance, cmd->frame_phys_addr,
1554				cmd->frame_count-1, instance->reg_set);
1555
1556	return 0;
1557out_return_cmd:
1558	megasas_return_cmd(instance, cmd);
1559	return 1;
1560}
1561
1562
1563/**
1564 * megasas_queue_command -	Queue entry point
1565 * @scmd:			SCSI command to be queued
1566 * @done:			Callback entry point
1567 */
1568static int
1569megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
1570{
1571	struct megasas_instance *instance;
1572	unsigned long flags;
1573
1574	instance = (struct megasas_instance *)
1575	    scmd->device->host->hostdata;
1576
1577	if (instance->unload == 1) {
1578		scmd->result = DID_NO_CONNECT << 16;
1579		scmd->scsi_done(scmd);
1580		return 0;
1581	}
1582
1583	if (instance->issuepend_done == 0)
1584		return SCSI_MLQUEUE_HOST_BUSY;
1585
1586	spin_lock_irqsave(&instance->hba_lock, flags);
1587
1588	/* Check for an mpio path and adjust behavior */
1589	if (instance->adprecovery == MEGASAS_ADPRESET_SM_INFAULT) {
1590		if (megasas_check_mpio_paths(instance, scmd) ==
1591		    (DID_RESET << 16)) {
1592			spin_unlock_irqrestore(&instance->hba_lock, flags);
1593			return SCSI_MLQUEUE_HOST_BUSY;
1594		} else {
1595			spin_unlock_irqrestore(&instance->hba_lock, flags);
1596			scmd->result = DID_NO_CONNECT << 16;
1597			scmd->scsi_done(scmd);
1598			return 0;
1599		}
1600	}
1601
1602	if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
1603		spin_unlock_irqrestore(&instance->hba_lock, flags);
1604		scmd->result = DID_NO_CONNECT << 16;
1605		scmd->scsi_done(scmd);
1606		return 0;
1607	}
1608
1609	if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
1610		spin_unlock_irqrestore(&instance->hba_lock, flags);
1611		return SCSI_MLQUEUE_HOST_BUSY;
1612	}
1613
1614	spin_unlock_irqrestore(&instance->hba_lock, flags);
1615
1616	scmd->result = 0;
1617
1618	if (MEGASAS_IS_LOGICAL(scmd) &&
1619	    (scmd->device->id >= instance->fw_supported_vd_count ||
1620		scmd->device->lun)) {
1621		scmd->result = DID_BAD_TARGET << 16;
1622		goto out_done;
1623	}
1624
1625	switch (scmd->cmnd[0]) {
1626	case SYNCHRONIZE_CACHE:
1627		/*
1628		 * FW takes care of flush cache on its own
1629		 * No need to send it down
1630		 */
1631		scmd->result = DID_OK << 16;
1632		goto out_done;
1633	default:
1634		break;
1635	}
1636
1637	if (instance->instancet->build_and_issue_cmd(instance, scmd)) {
1638		printk(KERN_ERR "megasas: Err returned from build_and_issue_cmd\n");
1639		return SCSI_MLQUEUE_HOST_BUSY;
1640	}
1641
1642	return 0;
1643
1644 out_done:
1645	scmd->scsi_done(scmd);
1646	return 0;
1647}
1648
1649static struct megasas_instance *megasas_lookup_instance(u16 host_no)
1650{
1651	int i;
1652
1653	for (i = 0; i < megasas_mgmt_info.max_index; i++) {
1654
1655		if ((megasas_mgmt_info.instance[i]) &&
1656		    (megasas_mgmt_info.instance[i]->host->host_no == host_no))
1657			return megasas_mgmt_info.instance[i];
1658	}
1659
1660	return NULL;
1661}
1662
1663static int megasas_slave_configure(struct scsi_device *sdev)
1664{
1665	/*
1666	* The RAID firmware may require extended timeouts.
1667	*/
1668	blk_queue_rq_timeout(sdev->request_queue,
1669		MEGASAS_DEFAULT_CMD_TIMEOUT * HZ);
1670
1671	return 0;
1672}
1673
1674static int megasas_slave_alloc(struct scsi_device *sdev)
1675{
1676	u16             pd_index = 0;
1677	struct megasas_instance *instance ;
1678	instance = megasas_lookup_instance(sdev->host->host_no);
1679	if (sdev->channel < MEGASAS_MAX_PD_CHANNELS) {
1680		/*
1681		 * Open the OS scan to the SYSTEM PD
1682		 */
1683		pd_index =
1684			(sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
1685			sdev->id;
1686		if (instance->pd_list[pd_index].driveState ==
1687					MR_PD_STATE_SYSTEM) {
1688			return 0;
1689		}
1690		return -ENXIO;
1691	}
1692	return 0;
1693}
1694
1695/*
1696* megasas_complete_outstanding_ioctls - Complete outstanding ioctls after a
1697*                                       kill adapter
1698* @instance:				Adapter soft state
1699*
1700*/
1701void megasas_complete_outstanding_ioctls(struct megasas_instance *instance)
1702{
1703	int i;
1704	struct megasas_cmd *cmd_mfi;
1705	struct megasas_cmd_fusion *cmd_fusion;
1706	struct fusion_context *fusion = instance->ctrl_context;
1707
1708	/* Find all outstanding ioctls */
1709	if (fusion) {
1710		for (i = 0; i < instance->max_fw_cmds; i++) {
1711			cmd_fusion = fusion->cmd_list[i];
1712			if (cmd_fusion->sync_cmd_idx != (u32)ULONG_MAX) {
1713				cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
1714				if (cmd_mfi->sync_cmd &&
1715					cmd_mfi->frame->hdr.cmd != MFI_CMD_ABORT)
1716					megasas_complete_cmd(instance,
1717							     cmd_mfi, DID_OK);
1718			}
1719		}
1720	} else {
1721		for (i = 0; i < instance->max_fw_cmds; i++) {
1722			cmd_mfi = instance->cmd_list[i];
1723			if (cmd_mfi->sync_cmd && cmd_mfi->frame->hdr.cmd !=
1724				MFI_CMD_ABORT)
1725				megasas_complete_cmd(instance, cmd_mfi, DID_OK);
1726		}
1727	}
1728}
1729
1730
1731void megaraid_sas_kill_hba(struct megasas_instance *instance)
1732{
1733	/* Set critical error to block I/O & ioctls in case caller didn't */
1734	instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR;
1735	/* Wait 1 second to ensure IO or ioctls in build have posted */
1736	msleep(1000);
1737	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
1738		(instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
1739		(instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
1740		(instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) ||
1741		(instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
1742		(instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) {
1743		writel(MFI_STOP_ADP,
1744			&instance->reg_set->doorbell);
1745		/* Flush */
1746		readl(&instance->reg_set->doorbell);
1747		if (instance->mpio && instance->requestorId)
1748			memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
1749	} else {
1750		writel(MFI_STOP_ADP,
1751			&instance->reg_set->inbound_doorbell);
1752	}
1753	/* Complete outstanding ioctls when adapter is killed */
1754	megasas_complete_outstanding_ioctls(instance);
1755}
1756
1757 /**
1758  * megasas_check_and_restore_queue_depth - Check if queue depth needs to be
1759  *					restored to max value
1760  * @instance:			Adapter soft state
1761  *
1762  */
1763void
1764megasas_check_and_restore_queue_depth(struct megasas_instance *instance)
1765{
1766	unsigned long flags;
1767
1768	if (instance->flag & MEGASAS_FW_BUSY
1769	    && time_after(jiffies, instance->last_time + 5 * HZ)
1770	    && atomic_read(&instance->fw_outstanding) <
1771	    instance->throttlequeuedepth + 1) {
1772
1773		spin_lock_irqsave(instance->host->host_lock, flags);
1774		instance->flag &= ~MEGASAS_FW_BUSY;
1775
1776		instance->host->can_queue = instance->max_scsi_cmds;
1777		spin_unlock_irqrestore(instance->host->host_lock, flags);
1778	}
1779}
1780
1781/**
1782 * megasas_complete_cmd_dpc	 -	Returns FW's controller structure
1783 * @instance_addr:			Address of adapter soft state
1784 *
1785 * Tasklet to complete cmds
1786 */
1787static void megasas_complete_cmd_dpc(unsigned long instance_addr)
1788{
1789	u32 producer;
1790	u32 consumer;
1791	u32 context;
1792	struct megasas_cmd *cmd;
1793	struct megasas_instance *instance =
1794				(struct megasas_instance *)instance_addr;
1795	unsigned long flags;
1796
1797	/* If we have already declared adapter dead, donot complete cmds */
1798	if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR )
1799		return;
1800
1801	spin_lock_irqsave(&instance->completion_lock, flags);
1802
1803	producer = le32_to_cpu(*instance->producer);
1804	consumer = le32_to_cpu(*instance->consumer);
1805
1806	while (consumer != producer) {
1807		context = le32_to_cpu(instance->reply_queue[consumer]);
1808		if (context >= instance->max_fw_cmds) {
1809			printk(KERN_ERR "Unexpected context value %x\n",
1810				context);
1811			BUG();
1812		}
1813
1814		cmd = instance->cmd_list[context];
1815
1816		megasas_complete_cmd(instance, cmd, DID_OK);
1817
1818		consumer++;
1819		if (consumer == (instance->max_fw_cmds + 1)) {
1820			consumer = 0;
1821		}
1822	}
1823
1824	*instance->consumer = cpu_to_le32(producer);
1825
1826	spin_unlock_irqrestore(&instance->completion_lock, flags);
1827
1828	/*
1829	 * Check if we can restore can_queue
1830	 */
1831	megasas_check_and_restore_queue_depth(instance);
1832}
1833
1834/**
1835 * megasas_start_timer - Initializes a timer object
1836 * @instance:		Adapter soft state
1837 * @timer:		timer object to be initialized
1838 * @fn:			timer function
1839 * @interval:		time interval between timer function call
1840 *
1841 */
1842void megasas_start_timer(struct megasas_instance *instance,
1843			struct timer_list *timer,
1844			void *fn, unsigned long interval)
1845{
1846	init_timer(timer);
1847	timer->expires = jiffies + interval;
1848	timer->data = (unsigned long)instance;
1849	timer->function = fn;
1850	add_timer(timer);
1851}
1852
1853static void
1854megasas_internal_reset_defer_cmds(struct megasas_instance *instance);
1855
1856static void
1857process_fw_state_change_wq(struct work_struct *work);
1858
1859void megasas_do_ocr(struct megasas_instance *instance)
1860{
1861	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
1862	(instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
1863	(instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
1864		*instance->consumer = cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
1865	}
1866	instance->instancet->disable_intr(instance);
1867	instance->adprecovery   = MEGASAS_ADPRESET_SM_INFAULT;
1868	instance->issuepend_done = 0;
1869
1870	atomic_set(&instance->fw_outstanding, 0);
1871	megasas_internal_reset_defer_cmds(instance);
1872	process_fw_state_change_wq(&instance->work_init);
1873}
1874
1875static int megasas_get_ld_vf_affiliation_111(struct megasas_instance *instance,
1876					    int initial)
1877{
1878	struct megasas_cmd *cmd;
1879	struct megasas_dcmd_frame *dcmd;
1880	struct MR_LD_VF_AFFILIATION_111 *new_affiliation_111 = NULL;
1881	dma_addr_t new_affiliation_111_h;
1882	int ld, retval = 0;
1883	u8 thisVf;
1884
1885	cmd = megasas_get_cmd(instance);
1886
1887	if (!cmd) {
1888		printk(KERN_DEBUG "megasas: megasas_get_ld_vf_affiliation_111:"
1889		       "Failed to get cmd for scsi%d.\n",
1890			instance->host->host_no);
1891		return -ENOMEM;
1892	}
1893
1894	dcmd = &cmd->frame->dcmd;
1895
1896	if (!instance->vf_affiliation_111) {
1897		printk(KERN_WARNING "megasas: SR-IOV: Couldn't get LD/VF "
1898		       "affiliation for scsi%d.\n", instance->host->host_no);
1899		megasas_return_cmd(instance, cmd);
1900		return -ENOMEM;
1901	}
1902
1903	if (initial)
1904			memset(instance->vf_affiliation_111, 0,
1905			       sizeof(struct MR_LD_VF_AFFILIATION_111));
1906	else {
1907		new_affiliation_111 =
1908			pci_alloc_consistent(instance->pdev,
1909					     sizeof(struct MR_LD_VF_AFFILIATION_111),
1910					     &new_affiliation_111_h);
1911		if (!new_affiliation_111) {
1912			printk(KERN_DEBUG "megasas: SR-IOV: Couldn't allocate "
1913			       "memory for new affiliation for scsi%d.\n",
1914			       instance->host->host_no);
1915			megasas_return_cmd(instance, cmd);
1916			return -ENOMEM;
1917		}
1918		memset(new_affiliation_111, 0,
1919		       sizeof(struct MR_LD_VF_AFFILIATION_111));
1920	}
1921
1922	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
1923
1924	dcmd->cmd = MFI_CMD_DCMD;
1925	dcmd->cmd_status = 0xFF;
1926	dcmd->sge_count = 1;
1927	dcmd->flags = MFI_FRAME_DIR_BOTH;
1928	dcmd->timeout = 0;
1929	dcmd->pad_0 = 0;
1930	dcmd->data_xfer_len = sizeof(struct MR_LD_VF_AFFILIATION_111);
1931	dcmd->opcode = MR_DCMD_LD_VF_MAP_GET_ALL_LDS_111;
1932
1933	if (initial)
1934		dcmd->sgl.sge32[0].phys_addr =
1935			instance->vf_affiliation_111_h;
1936	else
1937		dcmd->sgl.sge32[0].phys_addr = new_affiliation_111_h;
1938
1939	dcmd->sgl.sge32[0].length =
1940		sizeof(struct MR_LD_VF_AFFILIATION_111);
1941
1942	printk(KERN_WARNING "megasas: SR-IOV: Getting LD/VF affiliation for "
1943	       "scsi%d\n", instance->host->host_no);
1944
1945	megasas_issue_blocked_cmd(instance, cmd, 0);
1946
1947	if (dcmd->cmd_status) {
1948		printk(KERN_WARNING "megasas: SR-IOV: LD/VF affiliation DCMD"
1949		       " failed with status 0x%x for scsi%d.\n",
1950		       dcmd->cmd_status, instance->host->host_no);
1951		retval = 1; /* Do a scan if we couldn't get affiliation */
1952		goto out;
1953	}
1954
1955	if (!initial) {
1956		thisVf = new_affiliation_111->thisVf;
1957		for (ld = 0 ; ld < new_affiliation_111->vdCount; ld++)
1958			if (instance->vf_affiliation_111->map[ld].policy[thisVf] !=
1959			    new_affiliation_111->map[ld].policy[thisVf]) {
1960				printk(KERN_WARNING "megasas: SR-IOV: "
1961				       "Got new LD/VF affiliation "
1962				       "for scsi%d.\n",
1963				       instance->host->host_no);
1964				memcpy(instance->vf_affiliation_111,
1965				       new_affiliation_111,
1966				       sizeof(struct MR_LD_VF_AFFILIATION_111));
1967				retval = 1;
1968				goto out;
1969			}
1970	}
1971out:
1972	if (new_affiliation_111) {
1973		pci_free_consistent(instance->pdev,
1974				    sizeof(struct MR_LD_VF_AFFILIATION_111),
1975				    new_affiliation_111,
1976				    new_affiliation_111_h);
1977	}
1978
1979	if (instance->ctrl_context && cmd->mpt_pthr_cmd_blocked)
1980		megasas_return_mfi_mpt_pthr(instance, cmd,
1981			cmd->mpt_pthr_cmd_blocked);
1982	else
1983		megasas_return_cmd(instance, cmd);
1984
1985	return retval;
1986}
1987
1988static int megasas_get_ld_vf_affiliation_12(struct megasas_instance *instance,
1989					    int initial)
1990{
1991	struct megasas_cmd *cmd;
1992	struct megasas_dcmd_frame *dcmd;
1993	struct MR_LD_VF_AFFILIATION *new_affiliation = NULL;
1994	struct MR_LD_VF_MAP *newmap = NULL, *savedmap = NULL;
1995	dma_addr_t new_affiliation_h;
1996	int i, j, retval = 0, found = 0, doscan = 0;
1997	u8 thisVf;
1998
1999	cmd = megasas_get_cmd(instance);
2000
2001	if (!cmd) {
2002		printk(KERN_DEBUG "megasas: megasas_get_ld_vf_affiliation12: "
2003		       "Failed to get cmd for scsi%d.\n",
2004		       instance->host->host_no);
2005		return -ENOMEM;
2006	}
2007
2008	dcmd = &cmd->frame->dcmd;
2009
2010	if (!instance->vf_affiliation) {
2011		printk(KERN_WARNING "megasas: SR-IOV: Couldn't get LD/VF "
2012		       "affiliation for scsi%d.\n", instance->host->host_no);
2013		megasas_return_cmd(instance, cmd);
2014		return -ENOMEM;
2015	}
2016
2017	if (initial)
2018		memset(instance->vf_affiliation, 0, (MAX_LOGICAL_DRIVES + 1) *
2019		       sizeof(struct MR_LD_VF_AFFILIATION));
2020	else {
2021		new_affiliation =
2022			pci_alloc_consistent(instance->pdev,
2023					     (MAX_LOGICAL_DRIVES + 1) *
2024					     sizeof(struct MR_LD_VF_AFFILIATION),
2025					     &new_affiliation_h);
2026		if (!new_affiliation) {
2027			printk(KERN_DEBUG "megasas: SR-IOV: Couldn't allocate "
2028			       "memory for new affiliation for scsi%d.\n",
2029			       instance->host->host_no);
2030			megasas_return_cmd(instance, cmd);
2031			return -ENOMEM;
2032		}
2033		memset(new_affiliation, 0, (MAX_LOGICAL_DRIVES + 1) *
2034		       sizeof(struct MR_LD_VF_AFFILIATION));
2035	}
2036
2037	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2038
2039	dcmd->cmd = MFI_CMD_DCMD;
2040	dcmd->cmd_status = 0xFF;
2041	dcmd->sge_count = 1;
2042	dcmd->flags = MFI_FRAME_DIR_BOTH;
2043	dcmd->timeout = 0;
2044	dcmd->pad_0 = 0;
2045	dcmd->data_xfer_len = (MAX_LOGICAL_DRIVES + 1) *
2046		sizeof(struct MR_LD_VF_AFFILIATION);
2047	dcmd->opcode = MR_DCMD_LD_VF_MAP_GET_ALL_LDS;
2048
2049	if (initial)
2050		dcmd->sgl.sge32[0].phys_addr = instance->vf_affiliation_h;
2051	else
2052		dcmd->sgl.sge32[0].phys_addr = new_affiliation_h;
2053
2054	dcmd->sgl.sge32[0].length = (MAX_LOGICAL_DRIVES + 1) *
2055		sizeof(struct MR_LD_VF_AFFILIATION);
2056
2057	printk(KERN_WARNING "megasas: SR-IOV: Getting LD/VF affiliation for "
2058	       "scsi%d\n", instance->host->host_no);
2059
2060	megasas_issue_blocked_cmd(instance, cmd, 0);
2061
2062	if (dcmd->cmd_status) {
2063		printk(KERN_WARNING "megasas: SR-IOV: LD/VF affiliation DCMD"
2064		       " failed with status 0x%x for scsi%d.\n",
2065		       dcmd->cmd_status, instance->host->host_no);
2066		retval = 1; /* Do a scan if we couldn't get affiliation */
2067		goto out;
2068	}
2069
2070	if (!initial) {
2071		if (!new_affiliation->ldCount) {
2072			printk(KERN_WARNING "megasas: SR-IOV: Got new LD/VF "
2073			       "affiliation for passive path for scsi%d.\n",
2074			       instance->host->host_no);
2075			retval = 1;
2076			goto out;
2077		}
2078		newmap = new_affiliation->map;
2079		savedmap = instance->vf_affiliation->map;
2080		thisVf = new_affiliation->thisVf;
2081		for (i = 0 ; i < new_affiliation->ldCount; i++) {
2082			found = 0;
2083			for (j = 0; j < instance->vf_affiliation->ldCount;
2084			     j++) {
2085				if (newmap->ref.targetId ==
2086				    savedmap->ref.targetId) {
2087					found = 1;
2088					if (newmap->policy[thisVf] !=
2089					    savedmap->policy[thisVf]) {
2090						doscan = 1;
2091						goto out;
2092					}
2093				}
2094				savedmap = (struct MR_LD_VF_MAP *)
2095					((unsigned char *)savedmap +
2096					 savedmap->size);
2097			}
2098			if (!found && newmap->policy[thisVf] !=
2099			    MR_LD_ACCESS_HIDDEN) {
2100				doscan = 1;
2101				goto out;
2102			}
2103			newmap = (struct MR_LD_VF_MAP *)
2104				((unsigned char *)newmap + newmap->size);
2105		}
2106
2107		newmap = new_affiliation->map;
2108		savedmap = instance->vf_affiliation->map;
2109
2110		for (i = 0 ; i < instance->vf_affiliation->ldCount; i++) {
2111			found = 0;
2112			for (j = 0 ; j < new_affiliation->ldCount; j++) {
2113				if (savedmap->ref.targetId ==
2114				    newmap->ref.targetId) {
2115					found = 1;
2116					if (savedmap->policy[thisVf] !=
2117					    newmap->policy[thisVf]) {
2118						doscan = 1;
2119						goto out;
2120					}
2121				}
2122				newmap = (struct MR_LD_VF_MAP *)
2123					((unsigned char *)newmap +
2124					 newmap->size);
2125			}
2126			if (!found && savedmap->policy[thisVf] !=
2127			    MR_LD_ACCESS_HIDDEN) {
2128				doscan = 1;
2129				goto out;
2130			}
2131			savedmap = (struct MR_LD_VF_MAP *)
2132				((unsigned char *)savedmap +
2133				 savedmap->size);
2134		}
2135	}
2136out:
2137	if (doscan) {
2138		printk(KERN_WARNING "megasas: SR-IOV: Got new LD/VF "
2139		       "affiliation for scsi%d.\n", instance->host->host_no);
2140		memcpy(instance->vf_affiliation, new_affiliation,
2141		       new_affiliation->size);
2142		retval = 1;
2143	}
2144
2145	if (new_affiliation)
2146		pci_free_consistent(instance->pdev,
2147				    (MAX_LOGICAL_DRIVES + 1) *
2148				    sizeof(struct MR_LD_VF_AFFILIATION),
2149				    new_affiliation, new_affiliation_h);
2150	if (instance->ctrl_context && cmd->mpt_pthr_cmd_blocked)
2151		megasas_return_mfi_mpt_pthr(instance, cmd,
2152			cmd->mpt_pthr_cmd_blocked);
2153	else
2154		megasas_return_cmd(instance, cmd);
2155
2156	return retval;
2157}
2158
2159/* This function will get the current SR-IOV LD/VF affiliation */
2160static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,
2161	int initial)
2162{
2163	int retval;
2164
2165	if (instance->PlasmaFW111)
2166		retval = megasas_get_ld_vf_affiliation_111(instance, initial);
2167	else
2168		retval = megasas_get_ld_vf_affiliation_12(instance, initial);
2169	return retval;
2170}
2171
2172/* This function will tell FW to start the SR-IOV heartbeat */
2173int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
2174					 int initial)
2175{
2176	struct megasas_cmd *cmd;
2177	struct megasas_dcmd_frame *dcmd;
2178	int retval = 0;
2179
2180	cmd = megasas_get_cmd(instance);
2181
2182	if (!cmd) {
2183		printk(KERN_DEBUG "megasas: megasas_sriov_start_heartbeat: "
2184		       "Failed to get cmd for scsi%d.\n",
2185		       instance->host->host_no);
2186		return -ENOMEM;
2187	}
2188
2189	dcmd = &cmd->frame->dcmd;
2190
2191	if (initial) {
2192		instance->hb_host_mem =
2193			pci_zalloc_consistent(instance->pdev,
2194					      sizeof(struct MR_CTRL_HB_HOST_MEM),
2195					      &instance->hb_host_mem_h);
2196		if (!instance->hb_host_mem) {
2197			printk(KERN_DEBUG "megasas: SR-IOV: Couldn't allocate"
2198			       " memory for heartbeat host memory for "
2199			       "scsi%d.\n", instance->host->host_no);
2200			retval = -ENOMEM;
2201			goto out;
2202		}
2203	}
2204
2205	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2206
2207	dcmd->mbox.s[0] = sizeof(struct MR_CTRL_HB_HOST_MEM);
2208	dcmd->cmd = MFI_CMD_DCMD;
2209	dcmd->cmd_status = 0xFF;
2210	dcmd->sge_count = 1;
2211	dcmd->flags = MFI_FRAME_DIR_BOTH;
2212	dcmd->timeout = 0;
2213	dcmd->pad_0 = 0;
2214	dcmd->data_xfer_len = sizeof(struct MR_CTRL_HB_HOST_MEM);
2215	dcmd->opcode = MR_DCMD_CTRL_SHARED_HOST_MEM_ALLOC;
2216	dcmd->sgl.sge32[0].phys_addr = instance->hb_host_mem_h;
2217	dcmd->sgl.sge32[0].length = sizeof(struct MR_CTRL_HB_HOST_MEM);
2218
2219	printk(KERN_WARNING "megasas: SR-IOV: Starting heartbeat for scsi%d\n",
2220	       instance->host->host_no);
2221
2222	if (!megasas_issue_polled(instance, cmd)) {
2223		retval = 0;
2224	} else {
2225		printk(KERN_WARNING "megasas: SR-IOV: MR_DCMD_CTRL_SHARED_HOST"
2226		       "_MEM_ALLOC DCMD timed out for scsi%d\n",
2227		       instance->host->host_no);
2228		retval = 1;
2229		goto out;
2230	}
2231
2232
2233	if (dcmd->cmd_status) {
2234		printk(KERN_WARNING "megasas: SR-IOV: MR_DCMD_CTRL_SHARED_HOST"
2235		       "_MEM_ALLOC DCMD failed with status 0x%x for scsi%d\n",
2236		       dcmd->cmd_status,
2237		       instance->host->host_no);
2238		retval = 1;
2239		goto out;
2240	}
2241
2242out:
2243	megasas_return_cmd(instance, cmd);
2244
2245	return retval;
2246}
2247
2248/* Handler for SR-IOV heartbeat */
2249void megasas_sriov_heartbeat_handler(unsigned long instance_addr)
2250{
2251	struct megasas_instance *instance =
2252		(struct megasas_instance *)instance_addr;
2253
2254	if (instance->hb_host_mem->HB.fwCounter !=
2255	    instance->hb_host_mem->HB.driverCounter) {
2256		instance->hb_host_mem->HB.driverCounter =
2257			instance->hb_host_mem->HB.fwCounter;
2258		mod_timer(&instance->sriov_heartbeat_timer,
2259			  jiffies + MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF);
2260	} else {
2261		printk(KERN_WARNING "megasas: SR-IOV: Heartbeat never "
2262		       "completed for scsi%d\n", instance->host->host_no);
2263		schedule_work(&instance->work_init);
2264	}
2265}
2266
2267/**
2268 * megasas_wait_for_outstanding -	Wait for all outstanding cmds
2269 * @instance:				Adapter soft state
2270 *
2271 * This function waits for up to MEGASAS_RESET_WAIT_TIME seconds for FW to
2272 * complete all its outstanding commands. Returns error if one or more IOs
2273 * are pending after this time period. It also marks the controller dead.
2274 */
2275static int megasas_wait_for_outstanding(struct megasas_instance *instance)
2276{
2277	int i;
2278	u32 reset_index;
2279	u32 wait_time = MEGASAS_RESET_WAIT_TIME;
2280	u8 adprecovery;
2281	unsigned long flags;
2282	struct list_head clist_local;
2283	struct megasas_cmd *reset_cmd;
2284	u32 fw_state;
2285	u8 kill_adapter_flag;
2286
2287	spin_lock_irqsave(&instance->hba_lock, flags);
2288	adprecovery = instance->adprecovery;
2289	spin_unlock_irqrestore(&instance->hba_lock, flags);
2290
2291	if (adprecovery != MEGASAS_HBA_OPERATIONAL) {
2292
2293		INIT_LIST_HEAD(&clist_local);
2294		spin_lock_irqsave(&instance->hba_lock, flags);
2295		list_splice_init(&instance->internal_reset_pending_q,
2296				&clist_local);
2297		spin_unlock_irqrestore(&instance->hba_lock, flags);
2298
2299		printk(KERN_NOTICE "megasas: HBA reset wait ...\n");
2300		for (i = 0; i < wait_time; i++) {
2301			msleep(1000);
2302			spin_lock_irqsave(&instance->hba_lock, flags);
2303			adprecovery = instance->adprecovery;
2304			spin_unlock_irqrestore(&instance->hba_lock, flags);
2305			if (adprecovery == MEGASAS_HBA_OPERATIONAL)
2306				break;
2307		}
2308
2309		if (adprecovery != MEGASAS_HBA_OPERATIONAL) {
2310			printk(KERN_NOTICE "megasas: reset: Stopping HBA.\n");
2311			spin_lock_irqsave(&instance->hba_lock, flags);
2312			instance->adprecovery	= MEGASAS_HW_CRITICAL_ERROR;
2313			spin_unlock_irqrestore(&instance->hba_lock, flags);
2314			return FAILED;
2315		}
2316
2317		reset_index	= 0;
2318		while (!list_empty(&clist_local)) {
2319			reset_cmd	= list_entry((&clist_local)->next,
2320						struct megasas_cmd, list);
2321			list_del_init(&reset_cmd->list);
2322			if (reset_cmd->scmd) {
2323				reset_cmd->scmd->result = DID_RESET << 16;
2324				printk(KERN_NOTICE "%d:%p reset [%02x]\n",
2325					reset_index, reset_cmd,
2326					reset_cmd->scmd->cmnd[0]);
2327
2328				reset_cmd->scmd->scsi_done(reset_cmd->scmd);
2329				megasas_return_cmd(instance, reset_cmd);
2330			} else if (reset_cmd->sync_cmd) {
2331				printk(KERN_NOTICE "megasas:%p synch cmds"
2332						"reset queue\n",
2333						reset_cmd);
2334
2335				reset_cmd->cmd_status = ENODATA;
2336				instance->instancet->fire_cmd(instance,
2337						reset_cmd->frame_phys_addr,
2338						0, instance->reg_set);
2339			} else {
2340				printk(KERN_NOTICE "megasas: %p unexpected"
2341					"cmds lst\n",
2342					reset_cmd);
2343			}
2344			reset_index++;
2345		}
2346
2347		return SUCCESS;
2348	}
2349
2350	for (i = 0; i < resetwaittime; i++) {
2351
2352		int outstanding = atomic_read(&instance->fw_outstanding);
2353
2354		if (!outstanding)
2355			break;
2356
2357		if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
2358			printk(KERN_NOTICE "megasas: [%2d]waiting for %d "
2359			       "commands to complete\n",i,outstanding);
2360			/*
2361			 * Call cmd completion routine. Cmd to be
2362			 * be completed directly without depending on isr.
2363			 */
2364			megasas_complete_cmd_dpc((unsigned long)instance);
2365		}
2366
2367		msleep(1000);
2368	}
2369
2370	i = 0;
2371	kill_adapter_flag = 0;
2372	do {
2373		fw_state = instance->instancet->read_fw_status_reg(
2374					instance->reg_set) & MFI_STATE_MASK;
2375		if ((fw_state == MFI_STATE_FAULT) &&
2376			(instance->disableOnlineCtrlReset == 0)) {
2377			if (i == 3) {
2378				kill_adapter_flag = 2;
2379				break;
2380			}
2381			megasas_do_ocr(instance);
2382			kill_adapter_flag = 1;
2383
2384			/* wait for 1 secs to let FW finish the pending cmds */
2385			msleep(1000);
2386		}
2387		i++;
2388	} while (i <= 3);
2389
2390	if (atomic_read(&instance->fw_outstanding) &&
2391					!kill_adapter_flag) {
2392		if (instance->disableOnlineCtrlReset == 0) {
2393
2394			megasas_do_ocr(instance);
2395
2396			/* wait for 5 secs to let FW finish the pending cmds */
2397			for (i = 0; i < wait_time; i++) {
2398				int outstanding =
2399					atomic_read(&instance->fw_outstanding);
2400				if (!outstanding)
2401					return SUCCESS;
2402				msleep(1000);
2403			}
2404		}
2405	}
2406
2407	if (atomic_read(&instance->fw_outstanding) ||
2408					(kill_adapter_flag == 2)) {
2409		printk(KERN_NOTICE "megaraid_sas: pending cmds after reset\n");
2410		/*
2411		* Send signal to FW to stop processing any pending cmds.
2412		* The controller will be taken offline by the OS now.
2413		*/
2414		if ((instance->pdev->device ==
2415			PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2416			(instance->pdev->device ==
2417			PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
2418			writel(MFI_STOP_ADP,
2419				&instance->reg_set->doorbell);
2420		} else {
2421			writel(MFI_STOP_ADP,
2422				&instance->reg_set->inbound_doorbell);
2423		}
2424		megasas_dump_pending_frames(instance);
2425		spin_lock_irqsave(&instance->hba_lock, flags);
2426		instance->adprecovery	= MEGASAS_HW_CRITICAL_ERROR;
2427		spin_unlock_irqrestore(&instance->hba_lock, flags);
2428		return FAILED;
2429	}
2430
2431	printk(KERN_NOTICE "megaraid_sas: no pending cmds after reset\n");
2432
2433	return SUCCESS;
2434}
2435
2436/**
2437 * megasas_generic_reset -	Generic reset routine
2438 * @scmd:			Mid-layer SCSI command
2439 *
2440 * This routine implements a generic reset handler for device, bus and host
2441 * reset requests. Device, bus and host specific reset handlers can use this
2442 * function after they do their specific tasks.
2443 */
2444static int megasas_generic_reset(struct scsi_cmnd *scmd)
2445{
2446	int ret_val;
2447	struct megasas_instance *instance;
2448
2449	instance = (struct megasas_instance *)scmd->device->host->hostdata;
2450
2451	scmd_printk(KERN_NOTICE, scmd, "megasas: RESET cmd=%x retries=%x\n",
2452		 scmd->cmnd[0], scmd->retries);
2453
2454	if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
2455		printk(KERN_ERR "megasas: cannot recover from previous reset "
2456		       "failures\n");
2457		return FAILED;
2458	}
2459
2460	ret_val = megasas_wait_for_outstanding(instance);
2461	if (ret_val == SUCCESS)
2462		printk(KERN_NOTICE "megasas: reset successful \n");
2463	else
2464		printk(KERN_ERR "megasas: failed to do reset\n");
2465
2466	return ret_val;
2467}
2468
2469/**
2470 * megasas_reset_timer - quiesce the adapter if required
2471 * @scmd:		scsi cmnd
2472 *
2473 * Sets the FW busy flag and reduces the host->can_queue if the
2474 * cmd has not been completed within the timeout period.
2475 */
2476static enum
2477blk_eh_timer_return megasas_reset_timer(struct scsi_cmnd *scmd)
2478{
2479	struct megasas_instance *instance;
2480	unsigned long flags;
2481
2482	if (time_after(jiffies, scmd->jiffies_at_alloc +
2483				(MEGASAS_DEFAULT_CMD_TIMEOUT * 2) * HZ)) {
2484		return BLK_EH_NOT_HANDLED;
2485	}
2486
2487	instance = (struct megasas_instance *)scmd->device->host->hostdata;
2488	if (!(instance->flag & MEGASAS_FW_BUSY)) {
2489		/* FW is busy, throttle IO */
2490		spin_lock_irqsave(instance->host->host_lock, flags);
2491
2492		instance->host->can_queue = instance->throttlequeuedepth;
2493		instance->last_time = jiffies;
2494		instance->flag |= MEGASAS_FW_BUSY;
2495
2496		spin_unlock_irqrestore(instance->host->host_lock, flags);
2497	}
2498	return BLK_EH_RESET_TIMER;
2499}
2500
2501/**
2502 * megasas_reset_device -	Device reset handler entry point
2503 */
2504static int megasas_reset_device(struct scsi_cmnd *scmd)
2505{
2506	int ret;
2507
2508	/*
2509	 * First wait for all commands to complete
2510	 */
2511	ret = megasas_generic_reset(scmd);
2512
2513	return ret;
2514}
2515
2516/**
2517 * megasas_reset_bus_host -	Bus & host reset handler entry point
2518 */
2519static int megasas_reset_bus_host(struct scsi_cmnd *scmd)
2520{
2521	int ret;
2522	struct megasas_instance *instance;
2523	instance = (struct megasas_instance *)scmd->device->host->hostdata;
2524
2525	/*
2526	 * First wait for all commands to complete
2527	 */
2528	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
2529	    (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) ||
2530	    (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
2531	    (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY))
2532		ret = megasas_reset_fusion(scmd->device->host, 1);
2533	else
2534		ret = megasas_generic_reset(scmd);
2535
2536	return ret;
2537}
2538
2539/**
2540 * megasas_bios_param - Returns disk geometry for a disk
2541 * @sdev: 		device handle
2542 * @bdev:		block device
2543 * @capacity:		drive capacity
2544 * @geom:		geometry parameters
2545 */
2546static int
2547megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev,
2548		 sector_t capacity, int geom[])
2549{
2550	int heads;
2551	int sectors;
2552	sector_t cylinders;
2553	unsigned long tmp;
2554	/* Default heads (64) & sectors (32) */
2555	heads = 64;
2556	sectors = 32;
2557
2558	tmp = heads * sectors;
2559	cylinders = capacity;
2560
2561	sector_div(cylinders, tmp);
2562
2563	/*
2564	 * Handle extended translation size for logical drives > 1Gb
2565	 */
2566
2567	if (capacity >= 0x200000) {
2568		heads = 255;
2569		sectors = 63;
2570		tmp = heads*sectors;
2571		cylinders = capacity;
2572		sector_div(cylinders, tmp);
2573	}
2574
2575	geom[0] = heads;
2576	geom[1] = sectors;
2577	geom[2] = cylinders;
2578
2579	return 0;
2580}
2581
2582static void megasas_aen_polling(struct work_struct *work);
2583
2584/**
2585 * megasas_service_aen -	Processes an event notification
2586 * @instance:			Adapter soft state
2587 * @cmd:			AEN command completed by the ISR
2588 *
2589 * For AEN, driver sends a command down to FW that is held by the FW till an
2590 * event occurs. When an event of interest occurs, FW completes the command
2591 * that it was previously holding.
2592 *
2593 * This routines sends SIGIO signal to processes that have registered with the
2594 * driver for AEN.
2595 */
2596static void
2597megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
2598{
2599	unsigned long flags;
2600	/*
2601	 * Don't signal app if it is just an aborted previously registered aen
2602	 */
2603	if ((!cmd->abort_aen) && (instance->unload == 0)) {
2604		spin_lock_irqsave(&poll_aen_lock, flags);
2605		megasas_poll_wait_aen = 1;
2606		spin_unlock_irqrestore(&poll_aen_lock, flags);
2607		wake_up(&megasas_poll_wait);
2608		kill_fasync(&megasas_async_queue, SIGIO, POLL_IN);
2609	}
2610	else
2611		cmd->abort_aen = 0;
2612
2613	instance->aen_cmd = NULL;
2614
2615	if (instance->ctrl_context && cmd->mpt_pthr_cmd_blocked)
2616		megasas_return_mfi_mpt_pthr(instance, cmd,
2617			cmd->mpt_pthr_cmd_blocked);
2618	else
2619		megasas_return_cmd(instance, cmd);
2620
2621	if ((instance->unload == 0) &&
2622		((instance->issuepend_done == 1))) {
2623		struct megasas_aen_event *ev;
2624		ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2625		if (!ev) {
2626			printk(KERN_ERR "megasas_service_aen: out of memory\n");
2627		} else {
2628			ev->instance = instance;
2629			instance->ev = ev;
2630			INIT_DELAYED_WORK(&ev->hotplug_work,
2631					  megasas_aen_polling);
2632			schedule_delayed_work(&ev->hotplug_work, 0);
2633		}
2634	}
2635}
2636
2637static ssize_t
2638megasas_fw_crash_buffer_store(struct device *cdev,
2639	struct device_attribute *attr, const char *buf, size_t count)
2640{
2641	struct Scsi_Host *shost = class_to_shost(cdev);
2642	struct megasas_instance *instance =
2643		(struct megasas_instance *) shost->hostdata;
2644	int val = 0;
2645	unsigned long flags;
2646
2647	if (kstrtoint(buf, 0, &val) != 0)
2648		return -EINVAL;
2649
2650	spin_lock_irqsave(&instance->crashdump_lock, flags);
2651	instance->fw_crash_buffer_offset = val;
2652	spin_unlock_irqrestore(&instance->crashdump_lock, flags);
2653	return strlen(buf);
2654}
2655
2656static ssize_t
2657megasas_fw_crash_buffer_show(struct device *cdev,
2658	struct device_attribute *attr, char *buf)
2659{
2660	struct Scsi_Host *shost = class_to_shost(cdev);
2661	struct megasas_instance *instance =
2662		(struct megasas_instance *) shost->hostdata;
2663	u32 size;
2664	unsigned long buff_addr;
2665	unsigned long dmachunk = CRASH_DMA_BUF_SIZE;
2666	unsigned long src_addr;
2667	unsigned long flags;
2668	u32 buff_offset;
2669
2670	spin_lock_irqsave(&instance->crashdump_lock, flags);
2671	buff_offset = instance->fw_crash_buffer_offset;
2672	if (!instance->crash_dump_buf &&
2673		!((instance->fw_crash_state == AVAILABLE) ||
2674		(instance->fw_crash_state == COPYING))) {
2675		dev_err(&instance->pdev->dev,
2676			"Firmware crash dump is not available\n");
2677		spin_unlock_irqrestore(&instance->crashdump_lock, flags);
2678		return -EINVAL;
2679	}
2680
2681	buff_addr = (unsigned long) buf;
2682
2683	if (buff_offset >
2684		(instance->fw_crash_buffer_size * dmachunk)) {
2685		dev_err(&instance->pdev->dev,
2686			"Firmware crash dump offset is out of range\n");
2687		spin_unlock_irqrestore(&instance->crashdump_lock, flags);
2688		return 0;
2689	}
2690
2691	size = (instance->fw_crash_buffer_size * dmachunk) - buff_offset;
2692	size = (size >= PAGE_SIZE) ? (PAGE_SIZE - 1) : size;
2693
2694	src_addr = (unsigned long)instance->crash_buf[buff_offset / dmachunk] +
2695		(buff_offset % dmachunk);
2696	memcpy(buf, (void *)src_addr,  size);
2697	spin_unlock_irqrestore(&instance->crashdump_lock, flags);
2698
2699	return size;
2700}
2701
2702static ssize_t
2703megasas_fw_crash_buffer_size_show(struct device *cdev,
2704	struct device_attribute *attr, char *buf)
2705{
2706	struct Scsi_Host *shost = class_to_shost(cdev);
2707	struct megasas_instance *instance =
2708		(struct megasas_instance *) shost->hostdata;
2709
2710	return snprintf(buf, PAGE_SIZE, "%ld\n", (unsigned long)
2711		((instance->fw_crash_buffer_size) * 1024 * 1024)/PAGE_SIZE);
2712}
2713
2714static ssize_t
2715megasas_fw_crash_state_store(struct device *cdev,
2716	struct device_attribute *attr, const char *buf, size_t count)
2717{
2718	struct Scsi_Host *shost = class_to_shost(cdev);
2719	struct megasas_instance *instance =
2720		(struct megasas_instance *) shost->hostdata;
2721	int val = 0;
2722	unsigned long flags;
2723
2724	if (kstrtoint(buf, 0, &val) != 0)
2725		return -EINVAL;
2726
2727	if ((val <= AVAILABLE || val > COPY_ERROR)) {
2728		dev_err(&instance->pdev->dev, "application updates invalid "
2729			"firmware crash state\n");
2730		return -EINVAL;
2731	}
2732
2733	instance->fw_crash_state = val;
2734
2735	if ((val == COPIED) || (val == COPY_ERROR)) {
2736		spin_lock_irqsave(&instance->crashdump_lock, flags);
2737		megasas_free_host_crash_buffer(instance);
2738		spin_unlock_irqrestore(&instance->crashdump_lock, flags);
2739		if (val == COPY_ERROR)
2740			dev_info(&instance->pdev->dev, "application failed to "
2741				"copy Firmware crash dump\n");
2742		else
2743			dev_info(&instance->pdev->dev, "Firmware crash dump "
2744				"copied successfully\n");
2745	}
2746	return strlen(buf);
2747}
2748
2749static ssize_t
2750megasas_fw_crash_state_show(struct device *cdev,
2751	struct device_attribute *attr, char *buf)
2752{
2753	struct Scsi_Host *shost = class_to_shost(cdev);
2754	struct megasas_instance *instance =
2755		(struct megasas_instance *) shost->hostdata;
2756	return snprintf(buf, PAGE_SIZE, "%d\n", instance->fw_crash_state);
2757}
2758
2759static ssize_t
2760megasas_page_size_show(struct device *cdev,
2761	struct device_attribute *attr, char *buf)
2762{
2763	return snprintf(buf, PAGE_SIZE, "%ld\n", (unsigned long)PAGE_SIZE - 1);
2764}
2765
2766static DEVICE_ATTR(fw_crash_buffer, S_IRUGO | S_IWUSR,
2767	megasas_fw_crash_buffer_show, megasas_fw_crash_buffer_store);
2768static DEVICE_ATTR(fw_crash_buffer_size, S_IRUGO,
2769	megasas_fw_crash_buffer_size_show, NULL);
2770static DEVICE_ATTR(fw_crash_state, S_IRUGO | S_IWUSR,
2771	megasas_fw_crash_state_show, megasas_fw_crash_state_store);
2772static DEVICE_ATTR(page_size, S_IRUGO,
2773	megasas_page_size_show, NULL);
2774
2775struct device_attribute *megaraid_host_attrs[] = {
2776	&dev_attr_fw_crash_buffer_size,
2777	&dev_attr_fw_crash_buffer,
2778	&dev_attr_fw_crash_state,
2779	&dev_attr_page_size,
2780	NULL,
2781};
2782
2783/*
2784 * Scsi host template for megaraid_sas driver
2785 */
2786static struct scsi_host_template megasas_template = {
2787
2788	.module = THIS_MODULE,
2789	.name = "LSI SAS based MegaRAID driver",
2790	.proc_name = "megaraid_sas",
2791	.slave_configure = megasas_slave_configure,
2792	.slave_alloc = megasas_slave_alloc,
2793	.queuecommand = megasas_queue_command,
2794	.eh_device_reset_handler = megasas_reset_device,
2795	.eh_bus_reset_handler = megasas_reset_bus_host,
2796	.eh_host_reset_handler = megasas_reset_bus_host,
2797	.eh_timed_out = megasas_reset_timer,
2798	.shost_attrs = megaraid_host_attrs,
2799	.bios_param = megasas_bios_param,
2800	.use_clustering = ENABLE_CLUSTERING,
2801	.change_queue_depth = scsi_change_queue_depth,
2802	.no_write_same = 1,
2803};
2804
2805/**
2806 * megasas_complete_int_cmd -	Completes an internal command
2807 * @instance:			Adapter soft state
2808 * @cmd:			Command to be completed
2809 *
2810 * The megasas_issue_blocked_cmd() function waits for a command to complete
2811 * after it issues a command. This function wakes up that waiting routine by
2812 * calling wake_up() on the wait queue.
2813 */
2814static void
2815megasas_complete_int_cmd(struct megasas_instance *instance,
2816			 struct megasas_cmd *cmd)
2817{
2818	cmd->cmd_status = cmd->frame->io.cmd_status;
2819
2820	if (cmd->cmd_status == ENODATA) {
2821		cmd->cmd_status = 0;
2822	}
2823	wake_up(&instance->int_cmd_wait_q);
2824}
2825
2826/**
2827 * megasas_complete_abort -	Completes aborting a command
2828 * @instance:			Adapter soft state
2829 * @cmd:			Cmd that was issued to abort another cmd
2830 *
2831 * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q
2832 * after it issues an abort on a previously issued command. This function
2833 * wakes up all functions waiting on the same wait queue.
2834 */
2835static void
2836megasas_complete_abort(struct megasas_instance *instance,
2837		       struct megasas_cmd *cmd)
2838{
2839	if (cmd->sync_cmd) {
2840		cmd->sync_cmd = 0;
2841		cmd->cmd_status = 0;
2842		wake_up(&instance->abort_cmd_wait_q);
2843	}
2844
2845	return;
2846}
2847
2848/**
2849 * megasas_complete_cmd -	Completes a command
2850 * @instance:			Adapter soft state
2851 * @cmd:			Command to be completed
2852 * @alt_status:			If non-zero, use this value as status to
2853 * 				SCSI mid-layer instead of the value returned
2854 * 				by the FW. This should be used if caller wants
2855 * 				an alternate status (as in the case of aborted
2856 * 				commands)
2857 */
2858void
2859megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
2860		     u8 alt_status)
2861{
2862	int exception = 0;
2863	struct megasas_header *hdr = &cmd->frame->hdr;
2864	unsigned long flags;
2865	struct fusion_context *fusion = instance->ctrl_context;
2866	u32 opcode;
2867
2868	/* flag for the retry reset */
2869	cmd->retry_for_fw_reset = 0;
2870
2871	if (cmd->scmd)
2872		cmd->scmd->SCp.ptr = NULL;
2873
2874	switch (hdr->cmd) {
2875	case MFI_CMD_INVALID:
2876		/* Some older 1068 controller FW may keep a pended
2877		   MR_DCMD_CTRL_EVENT_GET_INFO left over from the main kernel
2878		   when booting the kdump kernel.  Ignore this command to
2879		   prevent a kernel panic on shutdown of the kdump kernel. */
2880		printk(KERN_WARNING "megaraid_sas: MFI_CMD_INVALID command "
2881		       "completed.\n");
2882		printk(KERN_WARNING "megaraid_sas: If you have a controller "
2883		       "other than PERC5, please upgrade your firmware.\n");
2884		break;
2885	case MFI_CMD_PD_SCSI_IO:
2886	case MFI_CMD_LD_SCSI_IO:
2887
2888		/*
2889		 * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been
2890		 * issued either through an IO path or an IOCTL path. If it
2891		 * was via IOCTL, we will send it to internal completion.
2892		 */
2893		if (cmd->sync_cmd) {
2894			cmd->sync_cmd = 0;
2895			megasas_complete_int_cmd(instance, cmd);
2896			break;
2897		}
2898
2899	case MFI_CMD_LD_READ:
2900	case MFI_CMD_LD_WRITE:
2901
2902		if (alt_status) {
2903			cmd->scmd->result = alt_status << 16;
2904			exception = 1;
2905		}
2906
2907		if (exception) {
2908
2909			atomic_dec(&instance->fw_outstanding);
2910
2911			scsi_dma_unmap(cmd->scmd);
2912			cmd->scmd->scsi_done(cmd->scmd);
2913			megasas_return_cmd(instance, cmd);
2914
2915			break;
2916		}
2917
2918		switch (hdr->cmd_status) {
2919
2920		case MFI_STAT_OK:
2921			cmd->scmd->result = DID_OK << 16;
2922			break;
2923
2924		case MFI_STAT_SCSI_IO_FAILED:
2925		case MFI_STAT_LD_INIT_IN_PROGRESS:
2926			cmd->scmd->result =
2927			    (DID_ERROR << 16) | hdr->scsi_status;
2928			break;
2929
2930		case MFI_STAT_SCSI_DONE_WITH_ERROR:
2931
2932			cmd->scmd->result = (DID_OK << 16) | hdr->scsi_status;
2933
2934			if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) {
2935				memset(cmd->scmd->sense_buffer, 0,
2936				       SCSI_SENSE_BUFFERSIZE);
2937				memcpy(cmd->scmd->sense_buffer, cmd->sense,
2938				       hdr->sense_len);
2939
2940				cmd->scmd->result |= DRIVER_SENSE << 24;
2941			}
2942
2943			break;
2944
2945		case MFI_STAT_LD_OFFLINE:
2946		case MFI_STAT_DEVICE_NOT_FOUND:
2947			cmd->scmd->result = DID_BAD_TARGET << 16;
2948			break;
2949
2950		default:
2951			printk(KERN_DEBUG "megasas: MFI FW status %#x\n",
2952			       hdr->cmd_status);
2953			cmd->scmd->result = DID_ERROR << 16;
2954			break;
2955		}
2956
2957		atomic_dec(&instance->fw_outstanding);
2958
2959		scsi_dma_unmap(cmd->scmd);
2960		cmd->scmd->scsi_done(cmd->scmd);
2961		megasas_return_cmd(instance, cmd);
2962
2963		break;
2964
2965	case MFI_CMD_SMP:
2966	case MFI_CMD_STP:
2967	case MFI_CMD_DCMD:
2968		opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
2969		/* Check for LD map update */
2970		if ((opcode == MR_DCMD_LD_MAP_GET_INFO)
2971			&& (cmd->frame->dcmd.mbox.b[1] == 1)) {
2972			fusion->fast_path_io = 0;
2973			spin_lock_irqsave(instance->host->host_lock, flags);
2974			if (cmd->frame->hdr.cmd_status != 0) {
2975				if (cmd->frame->hdr.cmd_status !=
2976				    MFI_STAT_NOT_FOUND)
2977					printk(KERN_WARNING "megasas: map sync"
2978					       "failed, status = 0x%x.\n",
2979					       cmd->frame->hdr.cmd_status);
2980				else {
2981					megasas_return_mfi_mpt_pthr(instance,
2982						cmd, cmd->mpt_pthr_cmd_blocked);
2983					spin_unlock_irqrestore(
2984						instance->host->host_lock,
2985						flags);
2986					break;
2987				}
2988			} else
2989				instance->map_id++;
2990			megasas_return_mfi_mpt_pthr(instance, cmd,
2991				cmd->mpt_pthr_cmd_blocked);
2992
2993			/*
2994			 * Set fast path IO to ZERO.
2995			 * Validate Map will set proper value.
2996			 * Meanwhile all IOs will go as LD IO.
2997			 */
2998			if (MR_ValidateMapInfo(instance))
2999				fusion->fast_path_io = 1;
3000			else
3001				fusion->fast_path_io = 0;
3002			megasas_sync_map_info(instance);
3003			spin_unlock_irqrestore(instance->host->host_lock,
3004					       flags);
3005			break;
3006		}
3007		if (opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||
3008		    opcode == MR_DCMD_CTRL_EVENT_GET) {
3009			spin_lock_irqsave(&poll_aen_lock, flags);
3010			megasas_poll_wait_aen = 0;
3011			spin_unlock_irqrestore(&poll_aen_lock, flags);
3012		}
3013
3014		/*
3015		 * See if got an event notification
3016		 */
3017		if (opcode == MR_DCMD_CTRL_EVENT_WAIT)
3018			megasas_service_aen(instance, cmd);
3019		else
3020			megasas_complete_int_cmd(instance, cmd);
3021
3022		break;
3023
3024	case MFI_CMD_ABORT:
3025		/*
3026		 * Cmd issued to abort another cmd returned
3027		 */
3028		megasas_complete_abort(instance, cmd);
3029		break;
3030
3031	default:
3032		printk("megasas: Unknown command completed! [0x%X]\n",
3033		       hdr->cmd);
3034		break;
3035	}
3036}
3037
3038/**
3039 * megasas_issue_pending_cmds_again -	issue all pending cmds
3040 *                              	in FW again because of the fw reset
3041 * @instance:				Adapter soft state
3042 */
3043static inline void
3044megasas_issue_pending_cmds_again(struct megasas_instance *instance)
3045{
3046	struct megasas_cmd *cmd;
3047	struct list_head clist_local;
3048	union megasas_evt_class_locale class_locale;
3049	unsigned long flags;
3050	u32 seq_num;
3051
3052	INIT_LIST_HEAD(&clist_local);
3053	spin_lock_irqsave(&instance->hba_lock, flags);
3054	list_splice_init(&instance->internal_reset_pending_q, &clist_local);
3055	spin_unlock_irqrestore(&instance->hba_lock, flags);
3056
3057	while (!list_empty(&clist_local)) {
3058		cmd	= list_entry((&clist_local)->next,
3059					struct megasas_cmd, list);
3060		list_del_init(&cmd->list);
3061
3062		if (cmd->sync_cmd || cmd->scmd) {
3063			printk(KERN_NOTICE "megaraid_sas: command %p, %p:%d"
3064				"detected to be pending while HBA reset.\n",
3065					cmd, cmd->scmd, cmd->sync_cmd);
3066
3067			cmd->retry_for_fw_reset++;
3068
3069			if (cmd->retry_for_fw_reset == 3) {
3070				printk(KERN_NOTICE "megaraid_sas: cmd %p, %p:%d"
3071					"was tried multiple times during reset."
3072					"Shutting down the HBA\n",
3073					cmd, cmd->scmd, cmd->sync_cmd);
3074				instance->instancet->disable_intr(instance);
3075				atomic_set(&instance->fw_reset_no_pci_access, 1);
3076				megaraid_sas_kill_hba(instance);
3077				return;
3078			}
3079		}
3080
3081		if (cmd->sync_cmd == 1) {
3082			if (cmd->scmd) {
3083				printk(KERN_NOTICE "megaraid_sas: unexpected"
3084					"cmd attached to internal command!\n");
3085			}
3086			printk(KERN_NOTICE "megasas: %p synchronous cmd"
3087						"on the internal reset queue,"
3088						"issue it again.\n", cmd);
3089			cmd->cmd_status = ENODATA;
3090			instance->instancet->fire_cmd(instance,
3091							cmd->frame_phys_addr ,
3092							0, instance->reg_set);
3093		} else if (cmd->scmd) {
3094			printk(KERN_NOTICE "megasas: %p scsi cmd [%02x]"
3095			"detected on the internal queue, issue again.\n",
3096			cmd, cmd->scmd->cmnd[0]);
3097
3098			atomic_inc(&instance->fw_outstanding);
3099			instance->instancet->fire_cmd(instance,
3100					cmd->frame_phys_addr,
3101					cmd->frame_count-1, instance->reg_set);
3102		} else {
3103			printk(KERN_NOTICE "megasas: %p unexpected cmd on the"
3104				"internal reset defer list while re-issue!!\n",
3105				cmd);
3106		}
3107	}
3108
3109	if (instance->aen_cmd) {
3110		printk(KERN_NOTICE "megaraid_sas: aen_cmd in def process\n");
3111		megasas_return_cmd(instance, instance->aen_cmd);
3112
3113		instance->aen_cmd	= NULL;
3114	}
3115
3116	/*
3117	* Initiate AEN (Asynchronous Event Notification)
3118	*/
3119	seq_num = instance->last_seq_num;
3120	class_locale.members.reserved = 0;
3121	class_locale.members.locale = MR_EVT_LOCALE_ALL;
3122	class_locale.members.class = MR_EVT_CLASS_DEBUG;
3123
3124	megasas_register_aen(instance, seq_num, class_locale.word);
3125}
3126
3127/**
3128 * Move the internal reset pending commands to a deferred queue.
3129 *
3130 * We move the commands pending at internal reset time to a
3131 * pending queue. This queue would be flushed after successful
3132 * completion of the internal reset sequence. if the internal reset
3133 * did not complete in time, the kernel reset handler would flush
3134 * these commands.
3135 **/
3136static void
3137megasas_internal_reset_defer_cmds(struct megasas_instance *instance)
3138{
3139	struct megasas_cmd *cmd;
3140	int i;
3141	u32 max_cmd = instance->max_fw_cmds;
3142	u32 defer_index;
3143	unsigned long flags;
3144
3145	defer_index     = 0;
3146	spin_lock_irqsave(&instance->mfi_pool_lock, flags);
3147	for (i = 0; i < max_cmd; i++) {
3148		cmd = instance->cmd_list[i];
3149		if (cmd->sync_cmd == 1 || cmd->scmd) {
3150			printk(KERN_NOTICE "megasas: moving cmd[%d]:%p:%d:%p"
3151					"on the defer queue as internal\n",
3152				defer_index, cmd, cmd->sync_cmd, cmd->scmd);
3153
3154			if (!list_empty(&cmd->list)) {
3155				printk(KERN_NOTICE "megaraid_sas: ERROR while"
3156					" moving this cmd:%p, %d %p, it was"
3157					"discovered on some list?\n",
3158					cmd, cmd->sync_cmd, cmd->scmd);
3159
3160				list_del_init(&cmd->list);
3161			}
3162			defer_index++;
3163			list_add_tail(&cmd->list,
3164				&instance->internal_reset_pending_q);
3165		}
3166	}
3167	spin_unlock_irqrestore(&instance->mfi_pool_lock, flags);
3168}
3169
3170
3171static void
3172process_fw_state_change_wq(struct work_struct *work)
3173{
3174	struct megasas_instance *instance =
3175		container_of(work, struct megasas_instance, work_init);
3176	u32 wait;
3177	unsigned long flags;
3178
3179	if (instance->adprecovery != MEGASAS_ADPRESET_SM_INFAULT) {
3180		printk(KERN_NOTICE "megaraid_sas: error, recovery st %x \n",
3181				instance->adprecovery);
3182		return ;
3183	}
3184
3185	if (instance->adprecovery == MEGASAS_ADPRESET_SM_INFAULT) {
3186		printk(KERN_NOTICE "megaraid_sas: FW detected to be in fault"
3187					"state, restarting it...\n");
3188
3189		instance->instancet->disable_intr(instance);
3190		atomic_set(&instance->fw_outstanding, 0);
3191
3192		atomic_set(&instance->fw_reset_no_pci_access, 1);
3193		instance->instancet->adp_reset(instance, instance->reg_set);
3194		atomic_set(&instance->fw_reset_no_pci_access, 0 );
3195
3196		printk(KERN_NOTICE "megaraid_sas: FW restarted successfully,"
3197					"initiating next stage...\n");
3198
3199		printk(KERN_NOTICE "megaraid_sas: HBA recovery state machine,"
3200					"state 2 starting...\n");
3201
3202		/*waitting for about 20 second before start the second init*/
3203		for (wait = 0; wait < 30; wait++) {
3204			msleep(1000);
3205		}
3206
3207		if (megasas_transition_to_ready(instance, 1)) {
3208			printk(KERN_NOTICE "megaraid_sas:adapter not ready\n");
3209
3210			atomic_set(&instance->fw_reset_no_pci_access, 1);
3211			megaraid_sas_kill_hba(instance);
3212			return ;
3213		}
3214
3215		if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
3216			(instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
3217			(instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)
3218			) {
3219			*instance->consumer = *instance->producer;
3220		} else {
3221			*instance->consumer = 0;
3222			*instance->producer = 0;
3223		}
3224
3225		megasas_issue_init_mfi(instance);
3226
3227		spin_lock_irqsave(&instance->hba_lock, flags);
3228		instance->adprecovery	= MEGASAS_HBA_OPERATIONAL;
3229		spin_unlock_irqrestore(&instance->hba_lock, flags);
3230		instance->instancet->enable_intr(instance);
3231
3232		megasas_issue_pending_cmds_again(instance);
3233		instance->issuepend_done = 1;
3234	}
3235	return ;
3236}
3237
3238/**
3239 * megasas_deplete_reply_queue -	Processes all completed commands
3240 * @instance:				Adapter soft state
3241 * @alt_status:				Alternate status to be returned to
3242 * 					SCSI mid-layer instead of the status
3243 * 					returned by the FW
3244 * Note: this must be called with hba lock held
3245 */
3246static int
3247megasas_deplete_reply_queue(struct megasas_instance *instance,
3248					u8 alt_status)
3249{
3250	u32 mfiStatus;
3251	u32 fw_state;
3252
3253	if ((mfiStatus = instance->instancet->check_reset(instance,
3254					instance->reg_set)) == 1) {
3255		return IRQ_HANDLED;
3256	}
3257
3258	if ((mfiStatus = instance->instancet->clear_intr(
3259						instance->reg_set)
3260						) == 0) {
3261		/* Hardware may not set outbound_intr_status in MSI-X mode */
3262		if (!instance->msix_vectors)
3263			return IRQ_NONE;
3264	}
3265
3266	instance->mfiStatus = mfiStatus;
3267
3268	if ((mfiStatus & MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE)) {
3269		fw_state = instance->instancet->read_fw_status_reg(
3270				instance->reg_set) & MFI_STATE_MASK;
3271
3272		if (fw_state != MFI_STATE_FAULT) {
3273			printk(KERN_NOTICE "megaraid_sas: fw state:%x\n",
3274						fw_state);
3275		}
3276
3277		if ((fw_state == MFI_STATE_FAULT) &&
3278				(instance->disableOnlineCtrlReset == 0)) {
3279			printk(KERN_NOTICE "megaraid_sas: wait adp restart\n");
3280
3281			if ((instance->pdev->device ==
3282					PCI_DEVICE_ID_LSI_SAS1064R) ||
3283				(instance->pdev->device ==
3284					PCI_DEVICE_ID_DELL_PERC5) ||
3285				(instance->pdev->device ==
3286					PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
3287
3288				*instance->consumer =
3289					cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
3290			}
3291
3292
3293			instance->instancet->disable_intr(instance);
3294			instance->adprecovery	= MEGASAS_ADPRESET_SM_INFAULT;
3295			instance->issuepend_done = 0;
3296
3297			atomic_set(&instance->fw_outstanding, 0);
3298			megasas_internal_reset_defer_cmds(instance);
3299
3300			printk(KERN_NOTICE "megasas: fwState=%x, stage:%d\n",
3301					fw_state, instance->adprecovery);
3302
3303			schedule_work(&instance->work_init);
3304			return IRQ_HANDLED;
3305
3306		} else {
3307			printk(KERN_NOTICE "megasas: fwstate:%x, dis_OCR=%x\n",
3308				fw_state, instance->disableOnlineCtrlReset);
3309		}
3310	}
3311
3312	tasklet_schedule(&instance->isr_tasklet);
3313	return IRQ_HANDLED;
3314}
3315/**
3316 * megasas_isr - isr entry point
3317 */
3318static irqreturn_t megasas_isr(int irq, void *devp)
3319{
3320	struct megasas_irq_context *irq_context = devp;
3321	struct megasas_instance *instance = irq_context->instance;
3322	unsigned long flags;
3323	irqreturn_t	rc;
3324
3325	if (atomic_read(&instance->fw_reset_no_pci_access))
3326		return IRQ_HANDLED;
3327
3328	spin_lock_irqsave(&instance->hba_lock, flags);
3329	rc =  megasas_deplete_reply_queue(instance, DID_OK);
3330	spin_unlock_irqrestore(&instance->hba_lock, flags);
3331
3332	return rc;
3333}
3334
3335/**
3336 * megasas_transition_to_ready -	Move the FW to READY state
3337 * @instance:				Adapter soft state
3338 *
3339 * During the initialization, FW passes can potentially be in any one of
3340 * several possible states. If the FW in operational, waiting-for-handshake
3341 * states, driver must take steps to bring it to ready state. Otherwise, it
3342 * has to wait for the ready state.
3343 */
3344int
3345megasas_transition_to_ready(struct megasas_instance *instance, int ocr)
3346{
3347	int i;
3348	u8 max_wait;
3349	u32 fw_state;
3350	u32 cur_state;
3351	u32 abs_state, curr_abs_state;
3352
3353	abs_state = instance->instancet->read_fw_status_reg(instance->reg_set);
3354	fw_state = abs_state & MFI_STATE_MASK;
3355
3356	if (fw_state != MFI_STATE_READY)
3357		printk(KERN_INFO "megasas: Waiting for FW to come to ready"
3358		       " state\n");
3359
3360	while (fw_state != MFI_STATE_READY) {
3361
3362		switch (fw_state) {
3363
3364		case MFI_STATE_FAULT:
3365			printk(KERN_DEBUG "megasas: FW in FAULT state!!\n");
3366			if (ocr) {
3367				max_wait = MEGASAS_RESET_WAIT_TIME;
3368				cur_state = MFI_STATE_FAULT;
3369				break;
3370			} else
3371				return -ENODEV;
3372
3373		case MFI_STATE_WAIT_HANDSHAKE:
3374			/*
3375			 * Set the CLR bit in inbound doorbell
3376			 */
3377			if ((instance->pdev->device ==
3378				PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
3379				(instance->pdev->device ==
3380				 PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
3381				(instance->pdev->device ==
3382				PCI_DEVICE_ID_LSI_FUSION) ||
3383				(instance->pdev->device ==
3384				PCI_DEVICE_ID_LSI_PLASMA) ||
3385				(instance->pdev->device ==
3386				PCI_DEVICE_ID_LSI_INVADER) ||
3387				(instance->pdev->device ==
3388				PCI_DEVICE_ID_LSI_FURY)) {
3389				writel(
3390				  MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
3391				  &instance->reg_set->doorbell);
3392			} else {
3393				writel(
3394				    MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
3395					&instance->reg_set->inbound_doorbell);
3396			}
3397
3398			max_wait = MEGASAS_RESET_WAIT_TIME;
3399			cur_state = MFI_STATE_WAIT_HANDSHAKE;
3400			break;
3401
3402		case MFI_STATE_BOOT_MESSAGE_PENDING:
3403			if ((instance->pdev->device ==
3404			     PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
3405				(instance->pdev->device ==
3406				 PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
3407			    (instance->pdev->device ==
3408			     PCI_DEVICE_ID_LSI_FUSION) ||
3409			    (instance->pdev->device ==
3410			     PCI_DEVICE_ID_LSI_PLASMA) ||
3411			    (instance->pdev->device ==
3412			     PCI_DEVICE_ID_LSI_INVADER) ||
3413			    (instance->pdev->device ==
3414			     PCI_DEVICE_ID_LSI_FURY)) {
3415				writel(MFI_INIT_HOTPLUG,
3416				       &instance->reg_set->doorbell);
3417			} else
3418				writel(MFI_INIT_HOTPLUG,
3419					&instance->reg_set->inbound_doorbell);
3420
3421			max_wait = MEGASAS_RESET_WAIT_TIME;
3422			cur_state = MFI_STATE_BOOT_MESSAGE_PENDING;
3423			break;
3424
3425		case MFI_STATE_OPERATIONAL:
3426			/*
3427			 * Bring it to READY state; assuming max wait 10 secs
3428			 */
3429			instance->instancet->disable_intr(instance);
3430			if ((instance->pdev->device ==
3431				PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
3432				(instance->pdev->device ==
3433				PCI_DEVICE_ID_LSI_SAS0071SKINNY)  ||
3434				(instance->pdev->device
3435					== PCI_DEVICE_ID_LSI_FUSION) ||
3436				(instance->pdev->device
3437					== PCI_DEVICE_ID_LSI_PLASMA) ||
3438				(instance->pdev->device
3439					== PCI_DEVICE_ID_LSI_INVADER) ||
3440				(instance->pdev->device
3441					== PCI_DEVICE_ID_LSI_FURY)) {
3442				writel(MFI_RESET_FLAGS,
3443					&instance->reg_set->doorbell);
3444				if ((instance->pdev->device ==
3445					PCI_DEVICE_ID_LSI_FUSION) ||
3446					(instance->pdev->device ==
3447					PCI_DEVICE_ID_LSI_PLASMA) ||
3448					(instance->pdev->device ==
3449					PCI_DEVICE_ID_LSI_INVADER) ||
3450					(instance->pdev->device ==
3451					PCI_DEVICE_ID_LSI_FURY)) {
3452					for (i = 0; i < (10 * 1000); i += 20) {
3453						if (readl(
3454							    &instance->
3455							    reg_set->
3456							    doorbell) & 1)
3457							msleep(20);
3458						else
3459							break;
3460					}
3461				}
3462			} else
3463				writel(MFI_RESET_FLAGS,
3464					&instance->reg_set->inbound_doorbell);
3465
3466			max_wait = MEGASAS_RESET_WAIT_TIME;
3467			cur_state = MFI_STATE_OPERATIONAL;
3468			break;
3469
3470		case MFI_STATE_UNDEFINED:
3471			/*
3472			 * This state should not last for more than 2 seconds
3473			 */
3474			max_wait = MEGASAS_RESET_WAIT_TIME;
3475			cur_state = MFI_STATE_UNDEFINED;
3476			break;
3477
3478		case MFI_STATE_BB_INIT:
3479			max_wait = MEGASAS_RESET_WAIT_TIME;
3480			cur_state = MFI_STATE_BB_INIT;
3481			break;
3482
3483		case MFI_STATE_FW_INIT:
3484			max_wait = MEGASAS_RESET_WAIT_TIME;
3485			cur_state = MFI_STATE_FW_INIT;
3486			break;
3487
3488		case MFI_STATE_FW_INIT_2:
3489			max_wait = MEGASAS_RESET_WAIT_TIME;
3490			cur_state = MFI_STATE_FW_INIT_2;
3491			break;
3492
3493		case MFI_STATE_DEVICE_SCAN:
3494			max_wait = MEGASAS_RESET_WAIT_TIME;
3495			cur_state = MFI_STATE_DEVICE_SCAN;
3496			break;
3497
3498		case MFI_STATE_FLUSH_CACHE:
3499			max_wait = MEGASAS_RESET_WAIT_TIME;
3500			cur_state = MFI_STATE_FLUSH_CACHE;
3501			break;
3502
3503		default:
3504			printk(KERN_DEBUG "megasas: Unknown state 0x%x\n",
3505			       fw_state);
3506			return -ENODEV;
3507		}
3508
3509		/*
3510		 * The cur_state should not last for more than max_wait secs
3511		 */
3512		for (i = 0; i < (max_wait * 1000); i++) {
3513			curr_abs_state = instance->instancet->
3514				read_fw_status_reg(instance->reg_set);
3515
3516			if (abs_state == curr_abs_state) {
3517				msleep(1);
3518			} else
3519				break;
3520		}
3521
3522		/*
3523		 * Return error if fw_state hasn't changed after max_wait
3524		 */
3525		if (curr_abs_state == abs_state) {
3526			printk(KERN_DEBUG "FW state [%d] hasn't changed "
3527			       "in %d secs\n", fw_state, max_wait);
3528			return -ENODEV;
3529		}
3530
3531		abs_state = curr_abs_state;
3532		fw_state = curr_abs_state & MFI_STATE_MASK;
3533	}
3534	printk(KERN_INFO "megasas: FW now in Ready state\n");
3535
3536	return 0;
3537}
3538
3539/**
3540 * megasas_teardown_frame_pool -	Destroy the cmd frame DMA pool
3541 * @instance:				Adapter soft state
3542 */
3543static void megasas_teardown_frame_pool(struct megasas_instance *instance)
3544{
3545	int i;
3546	u32 max_cmd = instance->max_mfi_cmds;
3547	struct megasas_cmd *cmd;
3548
3549	if (!instance->frame_dma_pool)
3550		return;
3551
3552	/*
3553	 * Return all frames to pool
3554	 */
3555	for (i = 0; i < max_cmd; i++) {
3556
3557		cmd = instance->cmd_list[i];
3558
3559		if (cmd->frame)
3560			pci_pool_free(instance->frame_dma_pool, cmd->frame,
3561				      cmd->frame_phys_addr);
3562
3563		if (cmd->sense)
3564			pci_pool_free(instance->sense_dma_pool, cmd->sense,
3565				      cmd->sense_phys_addr);
3566	}
3567
3568	/*
3569	 * Now destroy the pool itself
3570	 */
3571	pci_pool_destroy(instance->frame_dma_pool);
3572	pci_pool_destroy(instance->sense_dma_pool);
3573
3574	instance->frame_dma_pool = NULL;
3575	instance->sense_dma_pool = NULL;
3576}
3577
3578/**
3579 * megasas_create_frame_pool -	Creates DMA pool for cmd frames
3580 * @instance:			Adapter soft state
3581 *
3582 * Each command packet has an embedded DMA memory buffer that is used for
3583 * filling MFI frame and the SG list that immediately follows the frame. This
3584 * function creates those DMA memory buffers for each command packet by using
3585 * PCI pool facility.
3586 */
3587static int megasas_create_frame_pool(struct megasas_instance *instance)
3588{
3589	int i;
3590	u32 max_cmd;
3591	u32 sge_sz;
3592	u32 total_sz;
3593	u32 frame_count;
3594	struct megasas_cmd *cmd;
3595
3596	max_cmd = instance->max_mfi_cmds;
3597
3598	/*
3599	 * Size of our frame is 64 bytes for MFI frame, followed by max SG
3600	 * elements and finally SCSI_SENSE_BUFFERSIZE bytes for sense buffer
3601	 */
3602	sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
3603	    sizeof(struct megasas_sge32);
3604
3605	if (instance->flag_ieee) {
3606		sge_sz = sizeof(struct megasas_sge_skinny);
3607	}
3608
3609	/*
3610	 * For MFI controllers.
3611	 * max_num_sge = 60
3612	 * max_sge_sz  = 16 byte (sizeof megasas_sge_skinny)
3613	 * Total 960 byte (15 MFI frame of 64 byte)
3614	 *
3615	 * Fusion adapter require only 3 extra frame.
3616	 * max_num_sge = 16 (defined as MAX_IOCTL_SGE)
3617	 * max_sge_sz  = 12 byte (sizeof  megasas_sge64)
3618	 * Total 192 byte (3 MFI frame of 64 byte)
3619	 */
3620	frame_count = instance->ctrl_context ? (3 + 1) : (15 + 1);
3621	total_sz = MEGAMFI_FRAME_SIZE * frame_count;
3622	/*
3623	 * Use DMA pool facility provided by PCI layer
3624	 */
3625	instance->frame_dma_pool = pci_pool_create("megasas frame pool",
3626					instance->pdev, total_sz, 256, 0);
3627
3628	if (!instance->frame_dma_pool) {
3629		printk(KERN_DEBUG "megasas: failed to setup frame pool\n");
3630		return -ENOMEM;
3631	}
3632
3633	instance->sense_dma_pool = pci_pool_create("megasas sense pool",
3634						   instance->pdev, 128, 4, 0);
3635
3636	if (!instance->sense_dma_pool) {
3637		printk(KERN_DEBUG "megasas: failed to setup sense pool\n");
3638
3639		pci_pool_destroy(instance->frame_dma_pool);
3640		instance->frame_dma_pool = NULL;
3641
3642		return -ENOMEM;
3643	}
3644
3645	/*
3646	 * Allocate and attach a frame to each of the commands in cmd_list.
3647	 * By making cmd->index as the context instead of the &cmd, we can
3648	 * always use 32bit context regardless of the architecture
3649	 */
3650	for (i = 0; i < max_cmd; i++) {
3651
3652		cmd = instance->cmd_list[i];
3653
3654		cmd->frame = pci_pool_alloc(instance->frame_dma_pool,
3655					    GFP_KERNEL, &cmd->frame_phys_addr);
3656
3657		cmd->sense = pci_pool_alloc(instance->sense_dma_pool,
3658					    GFP_KERNEL, &cmd->sense_phys_addr);
3659
3660		/*
3661		 * megasas_teardown_frame_pool() takes care of freeing
3662		 * whatever has been allocated
3663		 */
3664		if (!cmd->frame || !cmd->sense) {
3665			printk(KERN_DEBUG "megasas: pci_pool_alloc failed \n");
3666			megasas_teardown_frame_pool(instance);
3667			return -ENOMEM;
3668		}
3669
3670		memset(cmd->frame, 0, total_sz);
3671		cmd->frame->io.context = cpu_to_le32(cmd->index);
3672		cmd->frame->io.pad_0 = 0;
3673		if ((instance->pdev->device != PCI_DEVICE_ID_LSI_FUSION) &&
3674		    (instance->pdev->device != PCI_DEVICE_ID_LSI_PLASMA) &&
3675		    (instance->pdev->device != PCI_DEVICE_ID_LSI_INVADER) &&
3676			(instance->pdev->device != PCI_DEVICE_ID_LSI_FURY) &&
3677		    (reset_devices))
3678			cmd->frame->hdr.cmd = MFI_CMD_INVALID;
3679	}
3680
3681	return 0;
3682}
3683
3684/**
3685 * megasas_free_cmds -	Free all the cmds in the free cmd pool
3686 * @instance:		Adapter soft state
3687 */
3688void megasas_free_cmds(struct megasas_instance *instance)
3689{
3690	int i;
3691	/* First free the MFI frame pool */
3692	megasas_teardown_frame_pool(instance);
3693
3694	/* Free all the commands in the cmd_list */
3695	for (i = 0; i < instance->max_mfi_cmds; i++)
3696
3697		kfree(instance->cmd_list[i]);
3698
3699	/* Free the cmd_list buffer itself */
3700	kfree(instance->cmd_list);
3701	instance->cmd_list = NULL;
3702
3703	INIT_LIST_HEAD(&instance->cmd_pool);
3704}
3705
3706/**
3707 * megasas_alloc_cmds -	Allocates the command packets
3708 * @instance:		Adapter soft state
3709 *
3710 * Each command that is issued to the FW, whether IO commands from the OS or
3711 * internal commands like IOCTLs, are wrapped in local data structure called
3712 * megasas_cmd. The frame embedded in this megasas_cmd is actually issued to
3713 * the FW.
3714 *
3715 * Each frame has a 32-bit field called context (tag). This context is used
3716 * to get back the megasas_cmd from the frame when a frame gets completed in
3717 * the ISR. Typically the address of the megasas_cmd itself would be used as
3718 * the context. But we wanted to keep the differences between 32 and 64 bit
3719 * systems to the mininum. We always use 32 bit integers for the context. In
3720 * this driver, the 32 bit values are the indices into an array cmd_list.
3721 * This array is used only to look up the megasas_cmd given the context. The
3722 * free commands themselves are maintained in a linked list called cmd_pool.
3723 */
3724int megasas_alloc_cmds(struct megasas_instance *instance)
3725{
3726	int i;
3727	int j;
3728	u32 max_cmd;
3729	struct megasas_cmd *cmd;
3730	struct fusion_context *fusion;
3731
3732	fusion = instance->ctrl_context;
3733	max_cmd = instance->max_mfi_cmds;
3734
3735	/*
3736	 * instance->cmd_list is an array of struct megasas_cmd pointers.
3737	 * Allocate the dynamic array first and then allocate individual
3738	 * commands.
3739	 */
3740	instance->cmd_list = kcalloc(max_cmd, sizeof(struct megasas_cmd*), GFP_KERNEL);
3741
3742	if (!instance->cmd_list) {
3743		printk(KERN_DEBUG "megasas: out of memory\n");
3744		return -ENOMEM;
3745	}
3746
3747	memset(instance->cmd_list, 0, sizeof(struct megasas_cmd *) *max_cmd);
3748
3749	for (i = 0; i < max_cmd; i++) {
3750		instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd),
3751						GFP_KERNEL);
3752
3753		if (!instance->cmd_list[i]) {
3754
3755			for (j = 0; j < i; j++)
3756				kfree(instance->cmd_list[j]);
3757
3758			kfree(instance->cmd_list);
3759			instance->cmd_list = NULL;
3760
3761			return -ENOMEM;
3762		}
3763	}
3764
3765	for (i = 0; i < max_cmd; i++) {
3766		cmd = instance->cmd_list[i];
3767		memset(cmd, 0, sizeof(struct megasas_cmd));
3768		cmd->index = i;
3769		atomic_set(&cmd->mfi_mpt_pthr, MFI_LIST_ADDED);
3770		cmd->scmd = NULL;
3771		cmd->instance = instance;
3772
3773		list_add_tail(&cmd->list, &instance->cmd_pool);
3774	}
3775
3776	/*
3777	 * Create a frame pool and assign one frame to each cmd
3778	 */
3779	if (megasas_create_frame_pool(instance)) {
3780		printk(KERN_DEBUG "megasas: Error creating frame DMA pool\n");
3781		megasas_free_cmds(instance);
3782	}
3783
3784	return 0;
3785}
3786
3787/*
3788 * megasas_get_pd_list_info -	Returns FW's pd_list structure
3789 * @instance:				Adapter soft state
3790 * @pd_list:				pd_list structure
3791 *
3792 * Issues an internal command (DCMD) to get the FW's controller PD
3793 * list structure.  This information is mainly used to find out SYSTEM
3794 * supported by the FW.
3795 */
3796static int
3797megasas_get_pd_list(struct megasas_instance *instance)
3798{
3799	int ret = 0, pd_index = 0;
3800	struct megasas_cmd *cmd;
3801	struct megasas_dcmd_frame *dcmd;
3802	struct MR_PD_LIST *ci;
3803	struct MR_PD_ADDRESS *pd_addr;
3804	dma_addr_t ci_h = 0;
3805
3806	cmd = megasas_get_cmd(instance);
3807
3808	if (!cmd) {
3809		printk(KERN_DEBUG "megasas (get_pd_list): Failed to get cmd\n");
3810		return -ENOMEM;
3811	}
3812
3813	dcmd = &cmd->frame->dcmd;
3814
3815	ci = pci_alloc_consistent(instance->pdev,
3816		  MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST), &ci_h);
3817
3818	if (!ci) {
3819		printk(KERN_DEBUG "Failed to alloc mem for pd_list\n");
3820		megasas_return_cmd(instance, cmd);
3821		return -ENOMEM;
3822	}
3823
3824	memset(ci, 0, sizeof(*ci));
3825	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3826
3827	dcmd->mbox.b[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST;
3828	dcmd->mbox.b[1] = 0;
3829	dcmd->cmd = MFI_CMD_DCMD;
3830	dcmd->cmd_status = 0xFF;
3831	dcmd->sge_count = 1;
3832	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
3833	dcmd->timeout = 0;
3834	dcmd->pad_0 = 0;
3835	dcmd->data_xfer_len = cpu_to_le32(MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST));
3836	dcmd->opcode = cpu_to_le32(MR_DCMD_PD_LIST_QUERY);
3837	dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
3838	dcmd->sgl.sge32[0].length = cpu_to_le32(MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST));
3839
3840	if (instance->ctrl_context && !instance->mask_interrupts)
3841		ret = megasas_issue_blocked_cmd(instance, cmd,
3842			MEGASAS_BLOCKED_CMD_TIMEOUT);
3843	else
3844		ret = megasas_issue_polled(instance, cmd);
3845
3846	/*
3847	* the following function will get the instance PD LIST.
3848	*/
3849
3850	pd_addr = ci->addr;
3851
3852	if ( ret == 0 &&
3853	     (le32_to_cpu(ci->count) <
3854		  (MEGASAS_MAX_PD_CHANNELS * MEGASAS_MAX_DEV_PER_CHANNEL))) {
3855
3856		memset(instance->local_pd_list, 0,
3857			MEGASAS_MAX_PD * sizeof(struct megasas_pd_list));
3858
3859		for (pd_index = 0; pd_index < le32_to_cpu(ci->count); pd_index++) {
3860
3861			instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].tid	=
3862				le16_to_cpu(pd_addr->deviceId);
3863			instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveType	=
3864							pd_addr->scsiDevType;
3865			instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveState	=
3866							MR_PD_STATE_SYSTEM;
3867			pd_addr++;
3868		}
3869		memcpy(instance->pd_list, instance->local_pd_list,
3870			sizeof(instance->pd_list));
3871	}
3872
3873	pci_free_consistent(instance->pdev,
3874				MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
3875				ci, ci_h);
3876
3877	if (instance->ctrl_context && cmd->mpt_pthr_cmd_blocked)
3878		megasas_return_mfi_mpt_pthr(instance, cmd,
3879			cmd->mpt_pthr_cmd_blocked);
3880	else
3881		megasas_return_cmd(instance, cmd);
3882
3883	return ret;
3884}
3885
3886/*
3887 * megasas_get_ld_list_info -	Returns FW's ld_list structure
3888 * @instance:				Adapter soft state
3889 * @ld_list:				ld_list structure
3890 *
3891 * Issues an internal command (DCMD) to get the FW's controller PD
3892 * list structure.  This information is mainly used to find out SYSTEM
3893 * supported by the FW.
3894 */
3895static int
3896megasas_get_ld_list(struct megasas_instance *instance)
3897{
3898	int ret = 0, ld_index = 0, ids = 0;
3899	struct megasas_cmd *cmd;
3900	struct megasas_dcmd_frame *dcmd;
3901	struct MR_LD_LIST *ci;
3902	dma_addr_t ci_h = 0;
3903	u32 ld_count;
3904
3905	cmd = megasas_get_cmd(instance);
3906
3907	if (!cmd) {
3908		printk(KERN_DEBUG "megasas_get_ld_list: Failed to get cmd\n");
3909		return -ENOMEM;
3910	}
3911
3912	dcmd = &cmd->frame->dcmd;
3913
3914	ci = pci_alloc_consistent(instance->pdev,
3915				sizeof(struct MR_LD_LIST),
3916				&ci_h);
3917
3918	if (!ci) {
3919		printk(KERN_DEBUG "Failed to alloc mem in get_ld_list\n");
3920		megasas_return_cmd(instance, cmd);
3921		return -ENOMEM;
3922	}
3923
3924	memset(ci, 0, sizeof(*ci));
3925	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3926
3927	if (instance->supportmax256vd)
3928		dcmd->mbox.b[0] = 1;
3929	dcmd->cmd = MFI_CMD_DCMD;
3930	dcmd->cmd_status = 0xFF;
3931	dcmd->sge_count = 1;
3932	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
3933	dcmd->timeout = 0;
3934	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_LIST));
3935	dcmd->opcode = cpu_to_le32(MR_DCMD_LD_GET_LIST);
3936	dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
3937	dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct MR_LD_LIST));
3938	dcmd->pad_0  = 0;
3939
3940	if (instance->ctrl_context && !instance->mask_interrupts)
3941		ret = megasas_issue_blocked_cmd(instance, cmd,
3942			MEGASAS_BLOCKED_CMD_TIMEOUT);
3943	else
3944		ret = megasas_issue_polled(instance, cmd);
3945
3946
3947	ld_count = le32_to_cpu(ci->ldCount);
3948
3949	/* the following function will get the instance PD LIST */
3950
3951	if ((ret == 0) && (ld_count <= instance->fw_supported_vd_count)) {
3952		memset(instance->ld_ids, 0xff, MAX_LOGICAL_DRIVES_EXT);
3953
3954		for (ld_index = 0; ld_index < ld_count; ld_index++) {
3955			if (ci->ldList[ld_index].state != 0) {
3956				ids = ci->ldList[ld_index].ref.targetId;
3957				instance->ld_ids[ids] =
3958					ci->ldList[ld_index].ref.targetId;
3959			}
3960		}
3961	}
3962
3963	pci_free_consistent(instance->pdev,
3964				sizeof(struct MR_LD_LIST),
3965				ci,
3966				ci_h);
3967
3968	if (instance->ctrl_context && cmd->mpt_pthr_cmd_blocked)
3969		megasas_return_mfi_mpt_pthr(instance, cmd,
3970			cmd->mpt_pthr_cmd_blocked);
3971	else
3972		megasas_return_cmd(instance, cmd);
3973	return ret;
3974}
3975
3976/**
3977 * megasas_ld_list_query -	Returns FW's ld_list structure
3978 * @instance:				Adapter soft state
3979 * @ld_list:				ld_list structure
3980 *
3981 * Issues an internal command (DCMD) to get the FW's controller PD
3982 * list structure.  This information is mainly used to find out SYSTEM
3983 * supported by the FW.
3984 */
3985static int
3986megasas_ld_list_query(struct megasas_instance *instance, u8 query_type)
3987{
3988	int ret = 0, ld_index = 0, ids = 0;
3989	struct megasas_cmd *cmd;
3990	struct megasas_dcmd_frame *dcmd;
3991	struct MR_LD_TARGETID_LIST *ci;
3992	dma_addr_t ci_h = 0;
3993	u32 tgtid_count;
3994
3995	cmd = megasas_get_cmd(instance);
3996
3997	if (!cmd) {
3998		printk(KERN_WARNING
3999		       "megasas:(megasas_ld_list_query): Failed to get cmd\n");
4000		return -ENOMEM;
4001	}
4002
4003	dcmd = &cmd->frame->dcmd;
4004
4005	ci = pci_alloc_consistent(instance->pdev,
4006				  sizeof(struct MR_LD_TARGETID_LIST), &ci_h);
4007
4008	if (!ci) {
4009		printk(KERN_WARNING
4010		       "megasas: Failed to alloc mem for ld_list_query\n");
4011		megasas_return_cmd(instance, cmd);
4012		return -ENOMEM;
4013	}
4014
4015	memset(ci, 0, sizeof(*ci));
4016	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4017
4018	dcmd->mbox.b[0] = query_type;
4019	if (instance->supportmax256vd)
4020		dcmd->mbox.b[2] = 1;
4021
4022	dcmd->cmd = MFI_CMD_DCMD;
4023	dcmd->cmd_status = 0xFF;
4024	dcmd->sge_count = 1;
4025	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
4026	dcmd->timeout = 0;
4027	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_TARGETID_LIST));
4028	dcmd->opcode = cpu_to_le32(MR_DCMD_LD_LIST_QUERY);
4029	dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
4030	dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct MR_LD_TARGETID_LIST));
4031	dcmd->pad_0  = 0;
4032
4033	if (instance->ctrl_context && !instance->mask_interrupts)
4034		ret = megasas_issue_blocked_cmd(instance, cmd,
4035			MEGASAS_BLOCKED_CMD_TIMEOUT);
4036	else
4037		ret = megasas_issue_polled(instance, cmd);
4038
4039	tgtid_count = le32_to_cpu(ci->count);
4040
4041	if ((ret == 0) && (tgtid_count <= (instance->fw_supported_vd_count))) {
4042		memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
4043		for (ld_index = 0; ld_index < tgtid_count; ld_index++) {
4044			ids = ci->targetId[ld_index];
4045			instance->ld_ids[ids] = ci->targetId[ld_index];
4046		}
4047
4048	}
4049
4050	pci_free_consistent(instance->pdev, sizeof(struct MR_LD_TARGETID_LIST),
4051			    ci, ci_h);
4052
4053	if (instance->ctrl_context && cmd->mpt_pthr_cmd_blocked)
4054		megasas_return_mfi_mpt_pthr(instance, cmd,
4055			cmd->mpt_pthr_cmd_blocked);
4056	else
4057		megasas_return_cmd(instance, cmd);
4058
4059	return ret;
4060}
4061
4062/*
4063 * megasas_update_ext_vd_details : Update details w.r.t Extended VD
4064 * instance			 : Controller's instance
4065*/
4066static void megasas_update_ext_vd_details(struct megasas_instance *instance)
4067{
4068	struct fusion_context *fusion;
4069	u32 old_map_sz;
4070	u32 new_map_sz;
4071
4072	fusion = instance->ctrl_context;
4073	/* For MFI based controllers return dummy success */
4074	if (!fusion)
4075		return;
4076
4077	instance->supportmax256vd =
4078		instance->ctrl_info->adapterOperations3.supportMaxExtLDs;
4079	/* Below is additional check to address future FW enhancement */
4080	if (instance->ctrl_info->max_lds > 64)
4081		instance->supportmax256vd = 1;
4082
4083	instance->drv_supported_vd_count = MEGASAS_MAX_LD_CHANNELS
4084					* MEGASAS_MAX_DEV_PER_CHANNEL;
4085	instance->drv_supported_pd_count = MEGASAS_MAX_PD_CHANNELS
4086					* MEGASAS_MAX_DEV_PER_CHANNEL;
4087	if (instance->supportmax256vd) {
4088		instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES_EXT;
4089		instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
4090	} else {
4091		instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
4092		instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
4093	}
4094	dev_info(&instance->pdev->dev, "Firmware supports %d VD %d PD\n",
4095		instance->fw_supported_vd_count,
4096		instance->fw_supported_pd_count);
4097	dev_info(&instance->pdev->dev, "Driver supports %d VD  %d PD\n",
4098		instance->drv_supported_vd_count,
4099		instance->drv_supported_pd_count);
4100
4101	old_map_sz =  sizeof(struct MR_FW_RAID_MAP) +
4102				(sizeof(struct MR_LD_SPAN_MAP) *
4103				(instance->fw_supported_vd_count - 1));
4104	new_map_sz =  sizeof(struct MR_FW_RAID_MAP_EXT);
4105	fusion->drv_map_sz =  sizeof(struct MR_DRV_RAID_MAP) +
4106				(sizeof(struct MR_LD_SPAN_MAP) *
4107				(instance->drv_supported_vd_count - 1));
4108
4109	fusion->max_map_sz = max(old_map_sz, new_map_sz);
4110
4111
4112	if (instance->supportmax256vd)
4113		fusion->current_map_sz = new_map_sz;
4114	else
4115		fusion->current_map_sz = old_map_sz;
4116
4117}
4118
4119/**
4120 * megasas_get_controller_info -	Returns FW's controller structure
4121 * @instance:				Adapter soft state
4122 *
4123 * Issues an internal command (DCMD) to get the FW's controller structure.
4124 * This information is mainly used to find out the maximum IO transfer per
4125 * command supported by the FW.
4126 */
4127int
4128megasas_get_ctrl_info(struct megasas_instance *instance)
4129{
4130	int ret = 0;
4131	struct megasas_cmd *cmd;
4132	struct megasas_dcmd_frame *dcmd;
4133	struct megasas_ctrl_info *ci;
4134	struct megasas_ctrl_info *ctrl_info;
4135	dma_addr_t ci_h = 0;
4136
4137	ctrl_info = instance->ctrl_info;
4138
4139	cmd = megasas_get_cmd(instance);
4140
4141	if (!cmd) {
4142		printk(KERN_DEBUG "megasas: Failed to get a free cmd\n");
4143		return -ENOMEM;
4144	}
4145
4146	dcmd = &cmd->frame->dcmd;
4147
4148	ci = pci_alloc_consistent(instance->pdev,
4149				  sizeof(struct megasas_ctrl_info), &ci_h);
4150
4151	if (!ci) {
4152		printk(KERN_DEBUG "Failed to alloc mem for ctrl info\n");
4153		megasas_return_cmd(instance, cmd);
4154		return -ENOMEM;
4155	}
4156
4157	memset(ci, 0, sizeof(*ci));
4158	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4159
4160	dcmd->cmd = MFI_CMD_DCMD;
4161	dcmd->cmd_status = 0xFF;
4162	dcmd->sge_count = 1;
4163	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
4164	dcmd->timeout = 0;
4165	dcmd->pad_0 = 0;
4166	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_ctrl_info));
4167	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_GET_INFO);
4168	dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
4169	dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct megasas_ctrl_info));
4170	dcmd->mbox.b[0] = 1;
4171
4172	if (instance->ctrl_context && !instance->mask_interrupts)
4173		ret = megasas_issue_blocked_cmd(instance, cmd,
4174			MEGASAS_BLOCKED_CMD_TIMEOUT);
4175	else
4176		ret = megasas_issue_polled(instance, cmd);
4177
4178	if (!ret) {
4179		memcpy(ctrl_info, ci, sizeof(struct megasas_ctrl_info));
4180		le32_to_cpus((u32 *)&ctrl_info->properties.OnOffProperties);
4181		le32_to_cpus((u32 *)&ctrl_info->adapterOperations2);
4182		le32_to_cpus((u32 *)&ctrl_info->adapterOperations3);
4183		megasas_update_ext_vd_details(instance);
4184	}
4185
4186	pci_free_consistent(instance->pdev, sizeof(struct megasas_ctrl_info),
4187			    ci, ci_h);
4188
4189	if (instance->ctrl_context && cmd->mpt_pthr_cmd_blocked)
4190		megasas_return_mfi_mpt_pthr(instance, cmd,
4191			cmd->mpt_pthr_cmd_blocked);
4192	else
4193		megasas_return_cmd(instance, cmd);
4194	return ret;
4195}
4196
4197/*
4198 * megasas_set_crash_dump_params -	Sends address of crash dump DMA buffer
4199 *					to firmware
4200 *
4201 * @instance:				Adapter soft state
4202 * @crash_buf_state		-	tell FW to turn ON/OFF crash dump feature
4203					MR_CRASH_BUF_TURN_OFF = 0
4204					MR_CRASH_BUF_TURN_ON = 1
4205 * @return 0 on success non-zero on failure.
4206 * Issues an internal command (DCMD) to set parameters for crash dump feature.
4207 * Driver will send address of crash dump DMA buffer and set mbox to tell FW
4208 * that driver supports crash dump feature. This DCMD will be sent only if
4209 * crash dump feature is supported by the FW.
4210 *
4211 */
4212int megasas_set_crash_dump_params(struct megasas_instance *instance,
4213	u8 crash_buf_state)
4214{
4215	int ret = 0;
4216	struct megasas_cmd *cmd;
4217	struct megasas_dcmd_frame *dcmd;
4218
4219	cmd = megasas_get_cmd(instance);
4220
4221	if (!cmd) {
4222		dev_err(&instance->pdev->dev, "Failed to get a free cmd\n");
4223		return -ENOMEM;
4224	}
4225
4226
4227	dcmd = &cmd->frame->dcmd;
4228
4229	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4230	dcmd->mbox.b[0] = crash_buf_state;
4231	dcmd->cmd = MFI_CMD_DCMD;
4232	dcmd->cmd_status = 0xFF;
4233	dcmd->sge_count = 1;
4234	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE);
4235	dcmd->timeout = 0;
4236	dcmd->pad_0 = 0;
4237	dcmd->data_xfer_len = cpu_to_le32(CRASH_DMA_BUF_SIZE);
4238	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_SET_CRASH_DUMP_PARAMS);
4239	dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(instance->crash_dump_h);
4240	dcmd->sgl.sge32[0].length = cpu_to_le32(CRASH_DMA_BUF_SIZE);
4241
4242	if (instance->ctrl_context && !instance->mask_interrupts)
4243		ret = megasas_issue_blocked_cmd(instance, cmd,
4244			MEGASAS_BLOCKED_CMD_TIMEOUT);
4245	else
4246		ret = megasas_issue_polled(instance, cmd);
4247
4248	if (instance->ctrl_context && cmd->mpt_pthr_cmd_blocked)
4249		megasas_return_mfi_mpt_pthr(instance, cmd,
4250			cmd->mpt_pthr_cmd_blocked);
4251	else
4252		megasas_return_cmd(instance, cmd);
4253	return ret;
4254}
4255
4256/**
4257 * megasas_issue_init_mfi -	Initializes the FW
4258 * @instance:		Adapter soft state
4259 *
4260 * Issues the INIT MFI cmd
4261 */
4262static int
4263megasas_issue_init_mfi(struct megasas_instance *instance)
4264{
4265	u32 context;
4266
4267	struct megasas_cmd *cmd;
4268
4269	struct megasas_init_frame *init_frame;
4270	struct megasas_init_queue_info *initq_info;
4271	dma_addr_t init_frame_h;
4272	dma_addr_t initq_info_h;
4273
4274	/*
4275	 * Prepare a init frame. Note the init frame points to queue info
4276	 * structure. Each frame has SGL allocated after first 64 bytes. For
4277	 * this frame - since we don't need any SGL - we use SGL's space as
4278	 * queue info structure
4279	 *
4280	 * We will not get a NULL command below. We just created the pool.
4281	 */
4282	cmd = megasas_get_cmd(instance);
4283
4284	init_frame = (struct megasas_init_frame *)cmd->frame;
4285	initq_info = (struct megasas_init_queue_info *)
4286		((unsigned long)init_frame + 64);
4287
4288	init_frame_h = cmd->frame_phys_addr;
4289	initq_info_h = init_frame_h + 64;
4290
4291	context = init_frame->context;
4292	memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
4293	memset(initq_info, 0, sizeof(struct megasas_init_queue_info));
4294	init_frame->context = context;
4295
4296	initq_info->reply_queue_entries = cpu_to_le32(instance->max_fw_cmds + 1);
4297	initq_info->reply_queue_start_phys_addr_lo = cpu_to_le32(instance->reply_queue_h);
4298
4299	initq_info->producer_index_phys_addr_lo = cpu_to_le32(instance->producer_h);
4300	initq_info->consumer_index_phys_addr_lo = cpu_to_le32(instance->consumer_h);
4301
4302	init_frame->cmd = MFI_CMD_INIT;
4303	init_frame->cmd_status = 0xFF;
4304	init_frame->queue_info_new_phys_addr_lo =
4305		cpu_to_le32(lower_32_bits(initq_info_h));
4306	init_frame->queue_info_new_phys_addr_hi =
4307		cpu_to_le32(upper_32_bits(initq_info_h));
4308
4309	init_frame->data_xfer_len = cpu_to_le32(sizeof(struct megasas_init_queue_info));
4310
4311	/*
4312	 * disable the intr before firing the init frame to FW
4313	 */
4314	instance->instancet->disable_intr(instance);
4315
4316	/*
4317	 * Issue the init frame in polled mode
4318	 */
4319
4320	if (megasas_issue_polled(instance, cmd)) {
4321		printk(KERN_ERR "megasas: Failed to init firmware\n");
4322		megasas_return_cmd(instance, cmd);
4323		goto fail_fw_init;
4324	}
4325
4326	megasas_return_cmd(instance, cmd);
4327
4328	return 0;
4329
4330fail_fw_init:
4331	return -EINVAL;
4332}
4333
4334static u32
4335megasas_init_adapter_mfi(struct megasas_instance *instance)
4336{
4337	struct megasas_register_set __iomem *reg_set;
4338	u32 context_sz;
4339	u32 reply_q_sz;
4340
4341	reg_set = instance->reg_set;
4342
4343	/*
4344	 * Get various operational parameters from status register
4345	 */
4346	instance->max_fw_cmds = instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF;
4347	/*
4348	 * Reduce the max supported cmds by 1. This is to ensure that the
4349	 * reply_q_sz (1 more than the max cmd that driver may send)
4350	 * does not exceed max cmds that the FW can support
4351	 */
4352	instance->max_fw_cmds = instance->max_fw_cmds-1;
4353	instance->max_mfi_cmds = instance->max_fw_cmds;
4354	instance->max_num_sge = (instance->instancet->read_fw_status_reg(reg_set) & 0xFF0000) >>
4355					0x10;
4356	/*
4357	 * Create a pool of commands
4358	 */
4359	if (megasas_alloc_cmds(instance))
4360		goto fail_alloc_cmds;
4361
4362	/*
4363	 * Allocate memory for reply queue. Length of reply queue should
4364	 * be _one_ more than the maximum commands handled by the firmware.
4365	 *
4366	 * Note: When FW completes commands, it places corresponding contex
4367	 * values in this circular reply queue. This circular queue is a fairly
4368	 * typical producer-consumer queue. FW is the producer (of completed
4369	 * commands) and the driver is the consumer.
4370	 */
4371	context_sz = sizeof(u32);
4372	reply_q_sz = context_sz * (instance->max_fw_cmds + 1);
4373
4374	instance->reply_queue = pci_alloc_consistent(instance->pdev,
4375						     reply_q_sz,
4376						     &instance->reply_queue_h);
4377
4378	if (!instance->reply_queue) {
4379		printk(KERN_DEBUG "megasas: Out of DMA mem for reply queue\n");
4380		goto fail_reply_queue;
4381	}
4382
4383	if (megasas_issue_init_mfi(instance))
4384		goto fail_fw_init;
4385
4386	if (megasas_get_ctrl_info(instance)) {
4387		dev_err(&instance->pdev->dev, "(%d): Could get controller info "
4388			"Fail from %s %d\n", instance->unique_id,
4389			__func__, __LINE__);
4390		goto fail_fw_init;
4391	}
4392
4393	instance->fw_support_ieee = 0;
4394	instance->fw_support_ieee =
4395		(instance->instancet->read_fw_status_reg(reg_set) &
4396		0x04000000);
4397
4398	printk(KERN_NOTICE "megasas_init_mfi: fw_support_ieee=%d",
4399			instance->fw_support_ieee);
4400
4401	if (instance->fw_support_ieee)
4402		instance->flag_ieee = 1;
4403
4404	return 0;
4405
4406fail_fw_init:
4407
4408	pci_free_consistent(instance->pdev, reply_q_sz,
4409			    instance->reply_queue, instance->reply_queue_h);
4410fail_reply_queue:
4411	megasas_free_cmds(instance);
4412
4413fail_alloc_cmds:
4414	return 1;
4415}
4416
4417/**
4418 * megasas_init_fw -	Initializes the FW
4419 * @instance:		Adapter soft state
4420 *
4421 * This is the main function for initializing firmware
4422 */
4423
4424static int megasas_init_fw(struct megasas_instance *instance)
4425{
4426	u32 max_sectors_1;
4427	u32 max_sectors_2;
4428	u32 tmp_sectors, msix_enable, scratch_pad_2;
4429	resource_size_t base_addr;
4430	struct megasas_register_set __iomem *reg_set;
4431	struct megasas_ctrl_info *ctrl_info = NULL;
4432	unsigned long bar_list;
4433	int i, loop, fw_msix_count = 0;
4434	struct IOV_111 *iovPtr;
4435
4436	/* Find first memory bar */
4437	bar_list = pci_select_bars(instance->pdev, IORESOURCE_MEM);
4438	instance->bar = find_first_bit(&bar_list, sizeof(unsigned long));
4439	if (pci_request_selected_regions(instance->pdev, instance->bar,
4440					 "megasas: LSI")) {
4441		printk(KERN_DEBUG "megasas: IO memory region busy!\n");
4442		return -EBUSY;
4443	}
4444
4445	base_addr = pci_resource_start(instance->pdev, instance->bar);
4446	instance->reg_set = ioremap_nocache(base_addr, 8192);
4447
4448	if (!instance->reg_set) {
4449		printk(KERN_DEBUG "megasas: Failed to map IO mem\n");
4450		goto fail_ioremap;
4451	}
4452
4453	reg_set = instance->reg_set;
4454
4455	switch (instance->pdev->device) {
4456	case PCI_DEVICE_ID_LSI_FUSION:
4457	case PCI_DEVICE_ID_LSI_PLASMA:
4458	case PCI_DEVICE_ID_LSI_INVADER:
4459	case PCI_DEVICE_ID_LSI_FURY:
4460		instance->instancet = &megasas_instance_template_fusion;
4461		break;
4462	case PCI_DEVICE_ID_LSI_SAS1078R:
4463	case PCI_DEVICE_ID_LSI_SAS1078DE:
4464		instance->instancet = &megasas_instance_template_ppc;
4465		break;
4466	case PCI_DEVICE_ID_LSI_SAS1078GEN2:
4467	case PCI_DEVICE_ID_LSI_SAS0079GEN2:
4468		instance->instancet = &megasas_instance_template_gen2;
4469		break;
4470	case PCI_DEVICE_ID_LSI_SAS0073SKINNY:
4471	case PCI_DEVICE_ID_LSI_SAS0071SKINNY:
4472		instance->instancet = &megasas_instance_template_skinny;
4473		break;
4474	case PCI_DEVICE_ID_LSI_SAS1064R:
4475	case PCI_DEVICE_ID_DELL_PERC5:
4476	default:
4477		instance->instancet = &megasas_instance_template_xscale;
4478		break;
4479	}
4480
4481	if (megasas_transition_to_ready(instance, 0)) {
4482		atomic_set(&instance->fw_reset_no_pci_access, 1);
4483		instance->instancet->adp_reset
4484			(instance, instance->reg_set);
4485		atomic_set(&instance->fw_reset_no_pci_access, 0);
4486		dev_info(&instance->pdev->dev,
4487			"megasas: FW restarted successfully from %s!\n",
4488			__func__);
4489
4490		/*waitting for about 30 second before retry*/
4491		ssleep(30);
4492
4493		if (megasas_transition_to_ready(instance, 0))
4494			goto fail_ready_state;
4495	}
4496
4497	/*
4498	 * MSI-X host index 0 is common for all adapter.
4499	 * It is used for all MPT based Adapters.
4500	 */
4501	instance->reply_post_host_index_addr[0] =
4502		(u32 *)((u8 *)instance->reg_set +
4503		MPI2_REPLY_POST_HOST_INDEX_OFFSET);
4504
4505	/* Check if MSI-X is supported while in ready state */
4506	msix_enable = (instance->instancet->read_fw_status_reg(reg_set) &
4507		       0x4000000) >> 0x1a;
4508	if (msix_enable && !msix_disable) {
4509		scratch_pad_2 = readl
4510			(&instance->reg_set->outbound_scratch_pad_2);
4511		/* Check max MSI-X vectors */
4512		if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
4513		    (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA)) {
4514			instance->msix_vectors = (scratch_pad_2
4515				& MR_MAX_REPLY_QUEUES_OFFSET) + 1;
4516			fw_msix_count = instance->msix_vectors;
4517			if (msix_vectors)
4518				instance->msix_vectors =
4519					min(msix_vectors,
4520					    instance->msix_vectors);
4521		} else if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER)
4522			|| (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) {
4523			/* Invader/Fury supports more than 8 MSI-X */
4524			instance->msix_vectors = ((scratch_pad_2
4525				& MR_MAX_REPLY_QUEUES_EXT_OFFSET)
4526				>> MR_MAX_REPLY_QUEUES_EXT_OFFSET_SHIFT) + 1;
4527			fw_msix_count = instance->msix_vectors;
4528			/* Save 1-15 reply post index address to local memory
4529			 * Index 0 is already saved from reg offset
4530			 * MPI2_REPLY_POST_HOST_INDEX_OFFSET
4531			 */
4532			for (loop = 1; loop < MR_MAX_MSIX_REG_ARRAY; loop++) {
4533				instance->reply_post_host_index_addr[loop] =
4534					(u32 *)((u8 *)instance->reg_set +
4535					MPI2_SUP_REPLY_POST_HOST_INDEX_OFFSET
4536					+ (loop * 0x10));
4537			}
4538			if (msix_vectors)
4539				instance->msix_vectors = min(msix_vectors,
4540					instance->msix_vectors);
4541		} else
4542			instance->msix_vectors = 1;
4543		/* Don't bother allocating more MSI-X vectors than cpus */
4544		instance->msix_vectors = min(instance->msix_vectors,
4545					     (unsigned int)num_online_cpus());
4546		for (i = 0; i < instance->msix_vectors; i++)
4547			instance->msixentry[i].entry = i;
4548		i = pci_enable_msix_range(instance->pdev, instance->msixentry,
4549					  1, instance->msix_vectors);
4550		if (i > 0)
4551			instance->msix_vectors = i;
4552		else
4553			instance->msix_vectors = 0;
4554
4555		dev_info(&instance->pdev->dev, "[scsi%d]: FW supports"
4556			"<%d> MSIX vector,Online CPUs: <%d>,"
4557			"Current MSIX <%d>\n", instance->host->host_no,
4558			fw_msix_count, (unsigned int)num_online_cpus(),
4559			instance->msix_vectors);
4560	}
4561
4562	instance->ctrl_info = kzalloc(sizeof(struct megasas_ctrl_info),
4563				GFP_KERNEL);
4564	if (instance->ctrl_info == NULL)
4565		goto fail_init_adapter;
4566
4567	/*
4568	 * Below are default value for legacy Firmware.
4569	 * non-fusion based controllers
4570	 */
4571	instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
4572	instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
4573	/* Get operational params, sge flags, send init cmd to controller */
4574	if (instance->instancet->init_adapter(instance))
4575		goto fail_init_adapter;
4576
4577	printk(KERN_ERR "megasas: INIT adapter done\n");
4578
4579	/** for passthrough
4580	* the following function will get the PD LIST.
4581	*/
4582
4583	memset(instance->pd_list, 0 ,
4584		(MEGASAS_MAX_PD * sizeof(struct megasas_pd_list)));
4585	if (megasas_get_pd_list(instance) < 0) {
4586		printk(KERN_ERR "megasas: failed to get PD list\n");
4587		goto fail_init_adapter;
4588	}
4589
4590	memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
4591	if (megasas_ld_list_query(instance,
4592				  MR_LD_QUERY_TYPE_EXPOSED_TO_HOST))
4593		megasas_get_ld_list(instance);
4594
4595	/*
4596	 * Compute the max allowed sectors per IO: The controller info has two
4597	 * limits on max sectors. Driver should use the minimum of these two.
4598	 *
4599	 * 1 << stripe_sz_ops.min = max sectors per strip
4600	 *
4601	 * Note that older firmwares ( < FW ver 30) didn't report information
4602	 * to calculate max_sectors_1. So the number ended up as zero always.
4603	 */
4604	tmp_sectors = 0;
4605	ctrl_info = instance->ctrl_info;
4606
4607	max_sectors_1 = (1 << ctrl_info->stripe_sz_ops.min) *
4608		le16_to_cpu(ctrl_info->max_strips_per_io);
4609	max_sectors_2 = le32_to_cpu(ctrl_info->max_request_size);
4610
4611	tmp_sectors = min_t(u32, max_sectors_1 , max_sectors_2);
4612
4613	/*Check whether controller is iMR or MR */
4614	if (ctrl_info->memory_size) {
4615		instance->is_imr = 0;
4616		dev_info(&instance->pdev->dev, "Controller type: MR,"
4617			"Memory size is: %dMB\n",
4618			le16_to_cpu(ctrl_info->memory_size));
4619	} else {
4620		instance->is_imr = 1;
4621		dev_info(&instance->pdev->dev,
4622			"Controller type: iMR\n");
4623	}
4624	instance->disableOnlineCtrlReset =
4625	ctrl_info->properties.OnOffProperties.disableOnlineCtrlReset;
4626	instance->mpio = ctrl_info->adapterOperations2.mpio;
4627	instance->UnevenSpanSupport =
4628		ctrl_info->adapterOperations2.supportUnevenSpans;
4629	if (instance->UnevenSpanSupport) {
4630		struct fusion_context *fusion = instance->ctrl_context;
4631
4632		dev_info(&instance->pdev->dev, "FW supports: "
4633		"UnevenSpanSupport=%x\n", instance->UnevenSpanSupport);
4634		if (MR_ValidateMapInfo(instance))
4635			fusion->fast_path_io = 1;
4636		else
4637			fusion->fast_path_io = 0;
4638
4639	}
4640	if (ctrl_info->host_interface.SRIOV) {
4641		if (!ctrl_info->adapterOperations2.activePassive)
4642			instance->PlasmaFW111 = 1;
4643
4644		if (!instance->PlasmaFW111)
4645			instance->requestorId =
4646				ctrl_info->iov.requestorId;
4647		else {
4648			iovPtr = (struct IOV_111 *)((unsigned char *)ctrl_info + IOV_111_OFFSET);
4649			instance->requestorId = iovPtr->requestorId;
4650		}
4651		dev_warn(&instance->pdev->dev, "I am VF "
4652		       "requestorId %d\n", instance->requestorId);
4653	}
4654
4655	instance->crash_dump_fw_support =
4656		ctrl_info->adapterOperations3.supportCrashDump;
4657	instance->crash_dump_drv_support =
4658		(instance->crash_dump_fw_support &&
4659		instance->crash_dump_buf);
4660	if (instance->crash_dump_drv_support) {
4661		dev_info(&instance->pdev->dev, "Firmware Crash dump "
4662			"feature is supported\n");
4663		megasas_set_crash_dump_params(instance,
4664			MR_CRASH_BUF_TURN_OFF);
4665
4666	} else {
4667		if (instance->crash_dump_buf)
4668			pci_free_consistent(instance->pdev,
4669				CRASH_DMA_BUF_SIZE,
4670				instance->crash_dump_buf,
4671				instance->crash_dump_h);
4672		instance->crash_dump_buf = NULL;
4673	}
4674
4675	instance->secure_jbod_support =
4676		ctrl_info->adapterOperations3.supportSecurityonJBOD;
4677	if (instance->secure_jbod_support)
4678		dev_info(&instance->pdev->dev, "Firmware supports Secure JBOD\n");
4679	instance->max_sectors_per_req = instance->max_num_sge *
4680						PAGE_SIZE / 512;
4681	if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))
4682		instance->max_sectors_per_req = tmp_sectors;
4683
4684	/*
4685	 * 1. For fusion adapters, 3 commands for IOCTL and 5 commands
4686	 *    for driver's internal DCMDs.
4687	 * 2. For MFI skinny adapters, 5 commands for IOCTL + driver's
4688	 *    internal DCMDs.
4689	 * 3. For rest of MFI adapters, 27 commands reserved for IOCTLs
4690	 *    and 5 commands for drivers's internal DCMD.
4691	 */
4692	if (instance->ctrl_context) {
4693		instance->max_scsi_cmds = instance->max_fw_cmds -
4694					(MEGASAS_FUSION_INTERNAL_CMDS +
4695					MEGASAS_FUSION_IOCTL_CMDS);
4696		sema_init(&instance->ioctl_sem, MEGASAS_FUSION_IOCTL_CMDS);
4697	} else if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
4698		(instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
4699		instance->max_scsi_cmds = instance->max_fw_cmds -
4700						MEGASAS_SKINNY_INT_CMDS;
4701		sema_init(&instance->ioctl_sem, MEGASAS_SKINNY_INT_CMDS);
4702	} else {
4703		instance->max_scsi_cmds = instance->max_fw_cmds -
4704						MEGASAS_INT_CMDS;
4705		sema_init(&instance->ioctl_sem, (MEGASAS_INT_CMDS - 5));
4706	}
4707
4708	/* Check for valid throttlequeuedepth module parameter */
4709	if (throttlequeuedepth &&
4710			throttlequeuedepth <= instance->max_scsi_cmds)
4711		instance->throttlequeuedepth = throttlequeuedepth;
4712	else
4713		instance->throttlequeuedepth =
4714				MEGASAS_THROTTLE_QUEUE_DEPTH;
4715
4716        /*
4717	* Setup tasklet for cmd completion
4718	*/
4719
4720	tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
4721		(unsigned long)instance);
4722
4723	/* Launch SR-IOV heartbeat timer */
4724	if (instance->requestorId) {
4725		if (!megasas_sriov_start_heartbeat(instance, 1))
4726			megasas_start_timer(instance,
4727					    &instance->sriov_heartbeat_timer,
4728					    megasas_sriov_heartbeat_handler,
4729					    MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF);
4730		else
4731			instance->skip_heartbeat_timer_del = 1;
4732	}
4733
4734	return 0;
4735
4736fail_init_adapter:
4737fail_ready_state:
4738	kfree(instance->ctrl_info);
4739	instance->ctrl_info = NULL;
4740	iounmap(instance->reg_set);
4741
4742      fail_ioremap:
4743	pci_release_selected_regions(instance->pdev, instance->bar);
4744
4745	return -EINVAL;
4746}
4747
4748/**
4749 * megasas_release_mfi -	Reverses the FW initialization
4750 * @intance:			Adapter soft state
4751 */
4752static void megasas_release_mfi(struct megasas_instance *instance)
4753{
4754	u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1);
4755
4756	if (instance->reply_queue)
4757		pci_free_consistent(instance->pdev, reply_q_sz,
4758			    instance->reply_queue, instance->reply_queue_h);
4759
4760	megasas_free_cmds(instance);
4761
4762	iounmap(instance->reg_set);
4763
4764	pci_release_selected_regions(instance->pdev, instance->bar);
4765}
4766
4767/**
4768 * megasas_get_seq_num -	Gets latest event sequence numbers
4769 * @instance:			Adapter soft state
4770 * @eli:			FW event log sequence numbers information
4771 *
4772 * FW maintains a log of all events in a non-volatile area. Upper layers would
4773 * usually find out the latest sequence number of the events, the seq number at
4774 * the boot etc. They would "read" all the events below the latest seq number
4775 * by issuing a direct fw cmd (DCMD). For the future events (beyond latest seq
4776 * number), they would subsribe to AEN (asynchronous event notification) and
4777 * wait for the events to happen.
4778 */
4779static int
4780megasas_get_seq_num(struct megasas_instance *instance,
4781		    struct megasas_evt_log_info *eli)
4782{
4783	struct megasas_cmd *cmd;
4784	struct megasas_dcmd_frame *dcmd;
4785	struct megasas_evt_log_info *el_info;
4786	dma_addr_t el_info_h = 0;
4787
4788	cmd = megasas_get_cmd(instance);
4789
4790	if (!cmd) {
4791		return -ENOMEM;
4792	}
4793
4794	dcmd = &cmd->frame->dcmd;
4795	el_info = pci_alloc_consistent(instance->pdev,
4796				       sizeof(struct megasas_evt_log_info),
4797				       &el_info_h);
4798
4799	if (!el_info) {
4800		megasas_return_cmd(instance, cmd);
4801		return -ENOMEM;
4802	}
4803
4804	memset(el_info, 0, sizeof(*el_info));
4805	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4806
4807	dcmd->cmd = MFI_CMD_DCMD;
4808	dcmd->cmd_status = 0x0;
4809	dcmd->sge_count = 1;
4810	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
4811	dcmd->timeout = 0;
4812	dcmd->pad_0 = 0;
4813	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_log_info));
4814	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_GET_INFO);
4815	dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(el_info_h);
4816	dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct megasas_evt_log_info));
4817
4818	if (megasas_issue_blocked_cmd(instance, cmd, 30))
4819		dev_err(&instance->pdev->dev, "Command timedout"
4820			"from %s\n", __func__);
4821	else {
4822		/*
4823		 * Copy the data back into callers buffer
4824		 */
4825		eli->newest_seq_num = le32_to_cpu(el_info->newest_seq_num);
4826		eli->oldest_seq_num = le32_to_cpu(el_info->oldest_seq_num);
4827		eli->clear_seq_num = le32_to_cpu(el_info->clear_seq_num);
4828		eli->shutdown_seq_num = le32_to_cpu(el_info->shutdown_seq_num);
4829		eli->boot_seq_num = le32_to_cpu(el_info->boot_seq_num);
4830	}
4831
4832	pci_free_consistent(instance->pdev, sizeof(struct megasas_evt_log_info),
4833			    el_info, el_info_h);
4834
4835	if (instance->ctrl_context && cmd->mpt_pthr_cmd_blocked)
4836		megasas_return_mfi_mpt_pthr(instance, cmd,
4837			cmd->mpt_pthr_cmd_blocked);
4838	else
4839		megasas_return_cmd(instance, cmd);
4840
4841	return 0;
4842}
4843
4844/**
4845 * megasas_register_aen -	Registers for asynchronous event notification
4846 * @instance:			Adapter soft state
4847 * @seq_num:			The starting sequence number
4848 * @class_locale:		Class of the event
4849 *
4850 * This function subscribes for AEN for events beyond the @seq_num. It requests
4851 * to be notified if and only if the event is of type @class_locale
4852 */
4853static int
4854megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
4855		     u32 class_locale_word)
4856{
4857	int ret_val;
4858	struct megasas_cmd *cmd;
4859	struct megasas_dcmd_frame *dcmd;
4860	union megasas_evt_class_locale curr_aen;
4861	union megasas_evt_class_locale prev_aen;
4862
4863	/*
4864	 * If there an AEN pending already (aen_cmd), check if the
4865	 * class_locale of that pending AEN is inclusive of the new
4866	 * AEN request we currently have. If it is, then we don't have
4867	 * to do anything. In other words, whichever events the current
4868	 * AEN request is subscribing to, have already been subscribed
4869	 * to.
4870	 *
4871	 * If the old_cmd is _not_ inclusive, then we have to abort
4872	 * that command, form a class_locale that is superset of both
4873	 * old and current and re-issue to the FW
4874	 */
4875
4876	curr_aen.word = class_locale_word;
4877
4878	if (instance->aen_cmd) {
4879
4880		prev_aen.word = instance->aen_cmd->frame->dcmd.mbox.w[1];
4881		prev_aen.members.locale = le16_to_cpu(prev_aen.members.locale);
4882
4883		/*
4884		 * A class whose enum value is smaller is inclusive of all
4885		 * higher values. If a PROGRESS (= -1) was previously
4886		 * registered, then a new registration requests for higher
4887		 * classes need not be sent to FW. They are automatically
4888		 * included.
4889		 *
4890		 * Locale numbers don't have such hierarchy. They are bitmap
4891		 * values
4892		 */
4893		if ((prev_aen.members.class <= curr_aen.members.class) &&
4894		    !((prev_aen.members.locale & curr_aen.members.locale) ^
4895		      curr_aen.members.locale)) {
4896			/*
4897			 * Previously issued event registration includes
4898			 * current request. Nothing to do.
4899			 */
4900			return 0;
4901		} else {
4902			curr_aen.members.locale |= prev_aen.members.locale;
4903
4904			if (prev_aen.members.class < curr_aen.members.class)
4905				curr_aen.members.class = prev_aen.members.class;
4906
4907			instance->aen_cmd->abort_aen = 1;
4908			ret_val = megasas_issue_blocked_abort_cmd(instance,
4909								  instance->
4910								  aen_cmd, 30);
4911
4912			if (ret_val) {
4913				printk(KERN_DEBUG "megasas: Failed to abort "
4914				       "previous AEN command\n");
4915				return ret_val;
4916			}
4917		}
4918	}
4919
4920	cmd = megasas_get_cmd(instance);
4921
4922	if (!cmd)
4923		return -ENOMEM;
4924
4925	dcmd = &cmd->frame->dcmd;
4926
4927	memset(instance->evt_detail, 0, sizeof(struct megasas_evt_detail));
4928
4929	/*
4930	 * Prepare DCMD for aen registration
4931	 */
4932	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4933
4934	dcmd->cmd = MFI_CMD_DCMD;
4935	dcmd->cmd_status = 0x0;
4936	dcmd->sge_count = 1;
4937	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
4938	dcmd->timeout = 0;
4939	dcmd->pad_0 = 0;
4940	dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_detail));
4941	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_WAIT);
4942	dcmd->mbox.w[0] = cpu_to_le32(seq_num);
4943	instance->last_seq_num = seq_num;
4944	dcmd->mbox.w[1] = cpu_to_le32(curr_aen.word);
4945	dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(instance->evt_detail_h);
4946	dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct megasas_evt_detail));
4947
4948	if (instance->aen_cmd != NULL) {
4949		megasas_return_cmd(instance, cmd);
4950		return 0;
4951	}
4952
4953	/*
4954	 * Store reference to the cmd used to register for AEN. When an
4955	 * application wants us to register for AEN, we have to abort this
4956	 * cmd and re-register with a new EVENT LOCALE supplied by that app
4957	 */
4958	instance->aen_cmd = cmd;
4959
4960	/*
4961	 * Issue the aen registration frame
4962	 */
4963	instance->instancet->issue_dcmd(instance, cmd);
4964
4965	return 0;
4966}
4967
4968/**
4969 * megasas_start_aen -	Subscribes to AEN during driver load time
4970 * @instance:		Adapter soft state
4971 */
4972static int megasas_start_aen(struct megasas_instance *instance)
4973{
4974	struct megasas_evt_log_info eli;
4975	union megasas_evt_class_locale class_locale;
4976
4977	/*
4978	 * Get the latest sequence number from FW
4979	 */
4980	memset(&eli, 0, sizeof(eli));
4981
4982	if (megasas_get_seq_num(instance, &eli))
4983		return -1;
4984
4985	/*
4986	 * Register AEN with FW for latest sequence number plus 1
4987	 */
4988	class_locale.members.reserved = 0;
4989	class_locale.members.locale = MR_EVT_LOCALE_ALL;
4990	class_locale.members.class = MR_EVT_CLASS_DEBUG;
4991
4992	return megasas_register_aen(instance,
4993			eli.newest_seq_num + 1,
4994			class_locale.word);
4995}
4996
4997/**
4998 * megasas_io_attach -	Attaches this driver to SCSI mid-layer
4999 * @instance:		Adapter soft state
5000 */
5001static int megasas_io_attach(struct megasas_instance *instance)
5002{
5003	struct Scsi_Host *host = instance->host;
5004
5005	/*
5006	 * Export parameters required by SCSI mid-layer
5007	 */
5008	host->irq = instance->pdev->irq;
5009	host->unique_id = instance->unique_id;
5010	host->can_queue = instance->max_scsi_cmds;
5011	host->this_id = instance->init_id;
5012	host->sg_tablesize = instance->max_num_sge;
5013
5014	if (instance->fw_support_ieee)
5015		instance->max_sectors_per_req = MEGASAS_MAX_SECTORS_IEEE;
5016
5017	/*
5018	 * Check if the module parameter value for max_sectors can be used
5019	 */
5020	if (max_sectors && max_sectors < instance->max_sectors_per_req)
5021		instance->max_sectors_per_req = max_sectors;
5022	else {
5023		if (max_sectors) {
5024			if (((instance->pdev->device ==
5025				PCI_DEVICE_ID_LSI_SAS1078GEN2) ||
5026				(instance->pdev->device ==
5027				PCI_DEVICE_ID_LSI_SAS0079GEN2)) &&
5028				(max_sectors <= MEGASAS_MAX_SECTORS)) {
5029				instance->max_sectors_per_req = max_sectors;
5030			} else {
5031			printk(KERN_INFO "megasas: max_sectors should be > 0"
5032				"and <= %d (or < 1MB for GEN2 controller)\n",
5033				instance->max_sectors_per_req);
5034			}
5035		}
5036	}
5037
5038	host->max_sectors = instance->max_sectors_per_req;
5039	host->cmd_per_lun = MEGASAS_DEFAULT_CMD_PER_LUN;
5040	host->max_channel = MEGASAS_MAX_CHANNELS - 1;
5041	host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL;
5042	host->max_lun = MEGASAS_MAX_LUN;
5043	host->max_cmd_len = 16;
5044
5045	/* Fusion only supports host reset */
5046	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
5047	    (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) ||
5048	    (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
5049	    (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) {
5050		host->hostt->eh_device_reset_handler = NULL;
5051		host->hostt->eh_bus_reset_handler = NULL;
5052	}
5053
5054	/*
5055	 * Notify the mid-layer about the new controller
5056	 */
5057	if (scsi_add_host(host, &instance->pdev->dev)) {
5058		printk(KERN_DEBUG "megasas: scsi_add_host failed\n");
5059		return -ENODEV;
5060	}
5061
5062	return 0;
5063}
5064
5065static int
5066megasas_set_dma_mask(struct pci_dev *pdev)
5067{
5068	/*
5069	 * All our contollers are capable of performing 64-bit DMA
5070	 */
5071	if (IS_DMA64) {
5072		if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0) {
5073
5074			if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)
5075				goto fail_set_dma_mask;
5076		}
5077	} else {
5078		if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)
5079			goto fail_set_dma_mask;
5080	}
5081	/*
5082	 * Ensure that all data structures are allocated in 32-bit
5083	 * memory.
5084	 */
5085	if (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) {
5086		/* Try 32bit DMA mask and 32 bit Consistent dma mask */
5087		if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
5088			&& !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))
5089			dev_info(&pdev->dev, "set 32bit DMA mask"
5090				"and 32 bit consistent mask\n");
5091		else
5092			goto fail_set_dma_mask;
5093	}
5094
5095	return 0;
5096
5097fail_set_dma_mask:
5098	return 1;
5099}
5100
5101/**
5102 * megasas_probe_one -	PCI hotplug entry point
5103 * @pdev:		PCI device structure
5104 * @id:			PCI ids of supported hotplugged adapter
5105 */
5106static int megasas_probe_one(struct pci_dev *pdev,
5107			     const struct pci_device_id *id)
5108{
5109	int rval, pos, i, j, cpu;
5110	struct Scsi_Host *host;
5111	struct megasas_instance *instance;
5112	u16 control = 0;
5113	struct fusion_context *fusion = NULL;
5114
5115	/* Reset MSI-X in the kdump kernel */
5116	if (reset_devices) {
5117		pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
5118		if (pos) {
5119			pci_read_config_word(pdev, pos + PCI_MSIX_FLAGS,
5120					     &control);
5121			if (control & PCI_MSIX_FLAGS_ENABLE) {
5122				dev_info(&pdev->dev, "resetting MSI-X\n");
5123				pci_write_config_word(pdev,
5124						      pos + PCI_MSIX_FLAGS,
5125						      control &
5126						      ~PCI_MSIX_FLAGS_ENABLE);
5127			}
5128		}
5129	}
5130
5131	/*
5132	 * Announce PCI information
5133	 */
5134	printk(KERN_INFO "megasas: %#4.04x:%#4.04x:%#4.04x:%#4.04x: ",
5135	       pdev->vendor, pdev->device, pdev->subsystem_vendor,
5136	       pdev->subsystem_device);
5137
5138	printk("bus %d:slot %d:func %d\n",
5139	       pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
5140
5141	/*
5142	 * PCI prepping: enable device set bus mastering and dma mask
5143	 */
5144	rval = pci_enable_device_mem(pdev);
5145
5146	if (rval) {
5147		return rval;
5148	}
5149
5150	pci_set_master(pdev);
5151
5152	if (megasas_set_dma_mask(pdev))
5153		goto fail_set_dma_mask;
5154
5155	host = scsi_host_alloc(&megasas_template,
5156			       sizeof(struct megasas_instance));
5157
5158	if (!host) {
5159		printk(KERN_DEBUG "megasas: scsi_host_alloc failed\n");
5160		goto fail_alloc_instance;
5161	}
5162
5163	instance = (struct megasas_instance *)host->hostdata;
5164	memset(instance, 0, sizeof(*instance));
5165	atomic_set( &instance->fw_reset_no_pci_access, 0 );
5166	instance->pdev = pdev;
5167
5168	switch (instance->pdev->device) {
5169	case PCI_DEVICE_ID_LSI_FUSION:
5170	case PCI_DEVICE_ID_LSI_PLASMA:
5171	case PCI_DEVICE_ID_LSI_INVADER:
5172	case PCI_DEVICE_ID_LSI_FURY:
5173	{
5174		instance->ctrl_context_pages =
5175			get_order(sizeof(struct fusion_context));
5176		instance->ctrl_context = (void *)__get_free_pages(GFP_KERNEL,
5177				instance->ctrl_context_pages);
5178		if (!instance->ctrl_context) {
5179			printk(KERN_DEBUG "megasas: Failed to allocate "
5180			       "memory for Fusion context info\n");
5181			goto fail_alloc_dma_buf;
5182		}
5183		fusion = instance->ctrl_context;
5184		memset(fusion, 0,
5185			((1 << PAGE_SHIFT) << instance->ctrl_context_pages));
5186		INIT_LIST_HEAD(&fusion->cmd_pool);
5187		spin_lock_init(&fusion->mpt_pool_lock);
5188	}
5189	break;
5190	default: /* For all other supported controllers */
5191
5192		instance->producer =
5193			pci_alloc_consistent(pdev, sizeof(u32),
5194					     &instance->producer_h);
5195		instance->consumer =
5196			pci_alloc_consistent(pdev, sizeof(u32),
5197					     &instance->consumer_h);
5198
5199		if (!instance->producer || !instance->consumer) {
5200			printk(KERN_DEBUG "megasas: Failed to allocate"
5201			       "memory for producer, consumer\n");
5202			goto fail_alloc_dma_buf;
5203		}
5204
5205		*instance->producer = 0;
5206		*instance->consumer = 0;
5207		break;
5208	}
5209
5210	/* Crash dump feature related initialisation*/
5211	instance->drv_buf_index = 0;
5212	instance->drv_buf_alloc = 0;
5213	instance->crash_dump_fw_support = 0;
5214	instance->crash_dump_app_support = 0;
5215	instance->fw_crash_state = UNAVAILABLE;
5216	spin_lock_init(&instance->crashdump_lock);
5217	instance->crash_dump_buf = NULL;
5218
5219	if (!reset_devices)
5220		instance->crash_dump_buf = pci_alloc_consistent(pdev,
5221						CRASH_DMA_BUF_SIZE,
5222						&instance->crash_dump_h);
5223	if (!instance->crash_dump_buf)
5224		dev_err(&instance->pdev->dev, "Can't allocate Firmware "
5225			"crash dump DMA buffer\n");
5226
5227	megasas_poll_wait_aen = 0;
5228	instance->flag_ieee = 0;
5229	instance->ev = NULL;
5230	instance->issuepend_done = 1;
5231	instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
5232	instance->is_imr = 0;
5233
5234	instance->evt_detail = pci_alloc_consistent(pdev,
5235						    sizeof(struct
5236							   megasas_evt_detail),
5237						    &instance->evt_detail_h);
5238
5239	if (!instance->evt_detail) {
5240		printk(KERN_DEBUG "megasas: Failed to allocate memory for "
5241		       "event detail structure\n");
5242		goto fail_alloc_dma_buf;
5243	}
5244
5245	/*
5246	 * Initialize locks and queues
5247	 */
5248	INIT_LIST_HEAD(&instance->cmd_pool);
5249	INIT_LIST_HEAD(&instance->internal_reset_pending_q);
5250
5251	atomic_set(&instance->fw_outstanding,0);
5252
5253	init_waitqueue_head(&instance->int_cmd_wait_q);
5254	init_waitqueue_head(&instance->abort_cmd_wait_q);
5255
5256	spin_lock_init(&instance->mfi_pool_lock);
5257	spin_lock_init(&instance->hba_lock);
5258	spin_lock_init(&instance->completion_lock);
5259
5260	mutex_init(&instance->aen_mutex);
5261	mutex_init(&instance->reset_mutex);
5262
5263	/*
5264	 * Initialize PCI related and misc parameters
5265	 */
5266	instance->host = host;
5267	instance->unique_id = pdev->bus->number << 8 | pdev->devfn;
5268	instance->init_id = MEGASAS_DEFAULT_INIT_ID;
5269	instance->ctrl_info = NULL;
5270
5271
5272	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
5273		(instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY))
5274		instance->flag_ieee = 1;
5275
5276	megasas_dbg_lvl = 0;
5277	instance->flag = 0;
5278	instance->unload = 1;
5279	instance->last_time = 0;
5280	instance->disableOnlineCtrlReset = 1;
5281	instance->UnevenSpanSupport = 0;
5282
5283	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
5284	    (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) ||
5285	    (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
5286	    (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) {
5287		INIT_WORK(&instance->work_init, megasas_fusion_ocr_wq);
5288		INIT_WORK(&instance->crash_init, megasas_fusion_crash_dump_wq);
5289	} else
5290		INIT_WORK(&instance->work_init, process_fw_state_change_wq);
5291
5292	/*
5293	 * Initialize MFI Firmware
5294	 */
5295	if (megasas_init_fw(instance))
5296		goto fail_init_mfi;
5297
5298	if (instance->requestorId) {
5299		if (instance->PlasmaFW111) {
5300			instance->vf_affiliation_111 =
5301				pci_alloc_consistent(pdev, sizeof(struct MR_LD_VF_AFFILIATION_111),
5302						     &instance->vf_affiliation_111_h);
5303			if (!instance->vf_affiliation_111)
5304				printk(KERN_WARNING "megasas: Can't allocate "
5305				       "memory for VF affiliation buffer\n");
5306		} else {
5307			instance->vf_affiliation =
5308				pci_alloc_consistent(pdev,
5309						     (MAX_LOGICAL_DRIVES + 1) *
5310						     sizeof(struct MR_LD_VF_AFFILIATION),
5311						     &instance->vf_affiliation_h);
5312			if (!instance->vf_affiliation)
5313				printk(KERN_WARNING "megasas: Can't allocate "
5314				       "memory for VF affiliation buffer\n");
5315		}
5316	}
5317
5318retry_irq_register:
5319	/*
5320	 * Register IRQ
5321	 */
5322	if (instance->msix_vectors) {
5323		cpu = cpumask_first(cpu_online_mask);
5324		for (i = 0; i < instance->msix_vectors; i++) {
5325			instance->irq_context[i].instance = instance;
5326			instance->irq_context[i].MSIxIndex = i;
5327			if (request_irq(instance->msixentry[i].vector,
5328					instance->instancet->service_isr, 0,
5329					"megasas",
5330					&instance->irq_context[i])) {
5331				printk(KERN_DEBUG "megasas: Failed to "
5332				       "register IRQ for vector %d.\n", i);
5333				for (j = 0; j < i; j++) {
5334					if (smp_affinity_enable)
5335						irq_set_affinity_hint(
5336							instance->msixentry[j].vector, NULL);
5337					free_irq(
5338						instance->msixentry[j].vector,
5339						&instance->irq_context[j]);
5340				}
5341				/* Retry irq register for IO_APIC */
5342				instance->msix_vectors = 0;
5343				goto retry_irq_register;
5344			}
5345			if (smp_affinity_enable) {
5346				if (irq_set_affinity_hint(instance->msixentry[i].vector,
5347					get_cpu_mask(cpu)))
5348					dev_err(&instance->pdev->dev,
5349						"Error setting affinity hint "
5350						"for cpu %d\n", cpu);
5351				cpu = cpumask_next(cpu, cpu_online_mask);
5352			}
5353		}
5354	} else {
5355		instance->irq_context[0].instance = instance;
5356		instance->irq_context[0].MSIxIndex = 0;
5357		if (request_irq(pdev->irq, instance->instancet->service_isr,
5358				IRQF_SHARED, "megasas",
5359				&instance->irq_context[0])) {
5360			printk(KERN_DEBUG "megasas: Failed to register IRQ\n");
5361			goto fail_irq;
5362		}
5363	}
5364
5365	instance->instancet->enable_intr(instance);
5366
5367	/*
5368	 * Store instance in PCI softstate
5369	 */
5370	pci_set_drvdata(pdev, instance);
5371
5372	/*
5373	 * Add this controller to megasas_mgmt_info structure so that it
5374	 * can be exported to management applications
5375	 */
5376	megasas_mgmt_info.count++;
5377	megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance;
5378	megasas_mgmt_info.max_index++;
5379
5380	/*
5381	 * Register with SCSI mid-layer
5382	 */
5383	if (megasas_io_attach(instance))
5384		goto fail_io_attach;
5385
5386	instance->unload = 0;
5387	/*
5388	 * Trigger SCSI to scan our drives
5389	 */
5390	scsi_scan_host(host);
5391
5392	/*
5393	 * Initiate AEN (Asynchronous Event Notification)
5394	 */
5395	if (megasas_start_aen(instance)) {
5396		printk(KERN_DEBUG "megasas: start aen failed\n");
5397		goto fail_start_aen;
5398	}
5399
5400	/* Get current SR-IOV LD/VF affiliation */
5401	if (instance->requestorId)
5402		megasas_get_ld_vf_affiliation(instance, 1);
5403
5404	return 0;
5405
5406      fail_start_aen:
5407      fail_io_attach:
5408	megasas_mgmt_info.count--;
5409	megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL;
5410	megasas_mgmt_info.max_index--;
5411
5412	instance->instancet->disable_intr(instance);
5413	if (instance->msix_vectors)
5414		for (i = 0; i < instance->msix_vectors; i++) {
5415			if (smp_affinity_enable)
5416				irq_set_affinity_hint(
5417					instance->msixentry[i].vector, NULL);
5418			free_irq(instance->msixentry[i].vector,
5419				 &instance->irq_context[i]);
5420		}
5421	else
5422		free_irq(instance->pdev->irq, &instance->irq_context[0]);
5423fail_irq:
5424	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
5425	    (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) ||
5426	    (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
5427	    (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY))
5428		megasas_release_fusion(instance);
5429	else
5430		megasas_release_mfi(instance);
5431      fail_init_mfi:
5432	if (instance->msix_vectors)
5433		pci_disable_msix(instance->pdev);
5434      fail_alloc_dma_buf:
5435	if (instance->evt_detail)
5436		pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
5437				    instance->evt_detail,
5438				    instance->evt_detail_h);
5439
5440	if (instance->producer)
5441		pci_free_consistent(pdev, sizeof(u32), instance->producer,
5442				    instance->producer_h);
5443	if (instance->consumer)
5444		pci_free_consistent(pdev, sizeof(u32), instance->consumer,
5445				    instance->consumer_h);
5446	scsi_host_put(host);
5447
5448      fail_alloc_instance:
5449      fail_set_dma_mask:
5450	pci_disable_device(pdev);
5451
5452	return -ENODEV;
5453}
5454
5455/**
5456 * megasas_flush_cache -	Requests FW to flush all its caches
5457 * @instance:			Adapter soft state
5458 */
5459static void megasas_flush_cache(struct megasas_instance *instance)
5460{
5461	struct megasas_cmd *cmd;
5462	struct megasas_dcmd_frame *dcmd;
5463
5464	if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
5465		return;
5466
5467	cmd = megasas_get_cmd(instance);
5468
5469	if (!cmd)
5470		return;
5471
5472	dcmd = &cmd->frame->dcmd;
5473
5474	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5475
5476	dcmd->cmd = MFI_CMD_DCMD;
5477	dcmd->cmd_status = 0x0;
5478	dcmd->sge_count = 0;
5479	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE);
5480	dcmd->timeout = 0;
5481	dcmd->pad_0 = 0;
5482	dcmd->data_xfer_len = 0;
5483	dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_CACHE_FLUSH);
5484	dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
5485
5486	if (megasas_issue_blocked_cmd(instance, cmd, 30))
5487		dev_err(&instance->pdev->dev, "Command timedout"
5488			" from %s\n", __func__);
5489
5490	if (instance->ctrl_context && cmd->mpt_pthr_cmd_blocked)
5491		megasas_return_mfi_mpt_pthr(instance, cmd,
5492			cmd->mpt_pthr_cmd_blocked);
5493	else
5494		megasas_return_cmd(instance, cmd);
5495
5496	return;
5497}
5498
5499/**
5500 * megasas_shutdown_controller -	Instructs FW to shutdown the controller
5501 * @instance:				Adapter soft state
5502 * @opcode:				Shutdown/Hibernate
5503 */
5504static void megasas_shutdown_controller(struct megasas_instance *instance,
5505					u32 opcode)
5506{
5507	struct megasas_cmd *cmd;
5508	struct megasas_dcmd_frame *dcmd;
5509
5510	if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
5511		return;
5512
5513	cmd = megasas_get_cmd(instance);
5514
5515	if (!cmd)
5516		return;
5517
5518	if (instance->aen_cmd)
5519		megasas_issue_blocked_abort_cmd(instance,
5520			instance->aen_cmd, 30);
5521	if (instance->map_update_cmd)
5522		megasas_issue_blocked_abort_cmd(instance,
5523			instance->map_update_cmd, 30);
5524	dcmd = &cmd->frame->dcmd;
5525
5526	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5527
5528	dcmd->cmd = MFI_CMD_DCMD;
5529	dcmd->cmd_status = 0x0;
5530	dcmd->sge_count = 0;
5531	dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE);
5532	dcmd->timeout = 0;
5533	dcmd->pad_0 = 0;
5534	dcmd->data_xfer_len = 0;
5535	dcmd->opcode = cpu_to_le32(opcode);
5536
5537	if (megasas_issue_blocked_cmd(instance, cmd, 30))
5538		dev_err(&instance->pdev->dev, "Command timedout"
5539			"from %s\n", __func__);
5540
5541	if (instance->ctrl_context && cmd->mpt_pthr_cmd_blocked)
5542		megasas_return_mfi_mpt_pthr(instance, cmd,
5543			cmd->mpt_pthr_cmd_blocked);
5544	else
5545		megasas_return_cmd(instance, cmd);
5546
5547	return;
5548}
5549
5550#ifdef CONFIG_PM
5551/**
5552 * megasas_suspend -	driver suspend entry point
5553 * @pdev:		PCI device structure
5554 * @state:		PCI power state to suspend routine
5555 */
5556static int
5557megasas_suspend(struct pci_dev *pdev, pm_message_t state)
5558{
5559	struct Scsi_Host *host;
5560	struct megasas_instance *instance;
5561	int i;
5562
5563	instance = pci_get_drvdata(pdev);
5564	host = instance->host;
5565	instance->unload = 1;
5566
5567	/* Shutdown SR-IOV heartbeat timer */
5568	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
5569		del_timer_sync(&instance->sriov_heartbeat_timer);
5570
5571	megasas_flush_cache(instance);
5572	megasas_shutdown_controller(instance, MR_DCMD_HIBERNATE_SHUTDOWN);
5573
5574	/* cancel the delayed work if this work still in queue */
5575	if (instance->ev != NULL) {
5576		struct megasas_aen_event *ev = instance->ev;
5577		cancel_delayed_work_sync(&ev->hotplug_work);
5578		instance->ev = NULL;
5579	}
5580
5581	tasklet_kill(&instance->isr_tasklet);
5582
5583	pci_set_drvdata(instance->pdev, instance);
5584	instance->instancet->disable_intr(instance);
5585
5586	if (instance->msix_vectors)
5587		for (i = 0; i < instance->msix_vectors; i++) {
5588			if (smp_affinity_enable)
5589				irq_set_affinity_hint(
5590					instance->msixentry[i].vector, NULL);
5591			free_irq(instance->msixentry[i].vector,
5592				 &instance->irq_context[i]);
5593		}
5594	else
5595		free_irq(instance->pdev->irq, &instance->irq_context[0]);
5596	if (instance->msix_vectors)
5597		pci_disable_msix(instance->pdev);
5598
5599	pci_save_state(pdev);
5600	pci_disable_device(pdev);
5601
5602	pci_set_power_state(pdev, pci_choose_state(pdev, state));
5603
5604	return 0;
5605}
5606
5607/**
5608 * megasas_resume-      driver resume entry point
5609 * @pdev:               PCI device structure
5610 */
5611static int
5612megasas_resume(struct pci_dev *pdev)
5613{
5614	int rval, i, j, cpu;
5615	struct Scsi_Host *host;
5616	struct megasas_instance *instance;
5617
5618	instance = pci_get_drvdata(pdev);
5619	host = instance->host;
5620	pci_set_power_state(pdev, PCI_D0);
5621	pci_enable_wake(pdev, PCI_D0, 0);
5622	pci_restore_state(pdev);
5623
5624	/*
5625	 * PCI prepping: enable device set bus mastering and dma mask
5626	 */
5627	rval = pci_enable_device_mem(pdev);
5628
5629	if (rval) {
5630		printk(KERN_ERR "megasas: Enable device failed\n");
5631		return rval;
5632	}
5633
5634	pci_set_master(pdev);
5635
5636	if (megasas_set_dma_mask(pdev))
5637		goto fail_set_dma_mask;
5638
5639	/*
5640	 * Initialize MFI Firmware
5641	 */
5642
5643	atomic_set(&instance->fw_outstanding, 0);
5644
5645	/*
5646	 * We expect the FW state to be READY
5647	 */
5648	if (megasas_transition_to_ready(instance, 0))
5649		goto fail_ready_state;
5650
5651	/* Now re-enable MSI-X */
5652	if (instance->msix_vectors &&
5653	    pci_enable_msix_exact(instance->pdev, instance->msixentry,
5654				  instance->msix_vectors))
5655		goto fail_reenable_msix;
5656
5657	switch (instance->pdev->device) {
5658	case PCI_DEVICE_ID_LSI_FUSION:
5659	case PCI_DEVICE_ID_LSI_PLASMA:
5660	case PCI_DEVICE_ID_LSI_INVADER:
5661	case PCI_DEVICE_ID_LSI_FURY:
5662	{
5663		megasas_reset_reply_desc(instance);
5664		if (megasas_ioc_init_fusion(instance)) {
5665			megasas_free_cmds(instance);
5666			megasas_free_cmds_fusion(instance);
5667			goto fail_init_mfi;
5668		}
5669		if (!megasas_get_map_info(instance))
5670			megasas_sync_map_info(instance);
5671	}
5672	break;
5673	default:
5674		*instance->producer = 0;
5675		*instance->consumer = 0;
5676		if (megasas_issue_init_mfi(instance))
5677			goto fail_init_mfi;
5678		break;
5679	}
5680
5681	tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
5682		     (unsigned long)instance);
5683
5684	/*
5685	 * Register IRQ
5686	 */
5687	if (instance->msix_vectors) {
5688		cpu = cpumask_first(cpu_online_mask);
5689		for (i = 0 ; i < instance->msix_vectors; i++) {
5690			instance->irq_context[i].instance = instance;
5691			instance->irq_context[i].MSIxIndex = i;
5692			if (request_irq(instance->msixentry[i].vector,
5693					instance->instancet->service_isr, 0,
5694					"megasas",
5695					&instance->irq_context[i])) {
5696				printk(KERN_DEBUG "megasas: Failed to "
5697				       "register IRQ for vector %d.\n", i);
5698				for (j = 0; j < i; j++) {
5699					if (smp_affinity_enable)
5700						irq_set_affinity_hint(
5701							instance->msixentry[j].vector, NULL);
5702					free_irq(
5703						instance->msixentry[j].vector,
5704						&instance->irq_context[j]);
5705				}
5706				goto fail_irq;
5707			}
5708
5709			if (smp_affinity_enable) {
5710				if (irq_set_affinity_hint(instance->msixentry[i].vector,
5711					get_cpu_mask(cpu)))
5712					dev_err(&instance->pdev->dev, "Error "
5713						"setting affinity hint for cpu "
5714						"%d\n", cpu);
5715				cpu = cpumask_next(cpu, cpu_online_mask);
5716			}
5717		}
5718	} else {
5719		instance->irq_context[0].instance = instance;
5720		instance->irq_context[0].MSIxIndex = 0;
5721		if (request_irq(pdev->irq, instance->instancet->service_isr,
5722				IRQF_SHARED, "megasas",
5723				&instance->irq_context[0])) {
5724			printk(KERN_DEBUG "megasas: Failed to register IRQ\n");
5725			goto fail_irq;
5726		}
5727	}
5728
5729	/* Re-launch SR-IOV heartbeat timer */
5730	if (instance->requestorId) {
5731		if (!megasas_sriov_start_heartbeat(instance, 0))
5732			megasas_start_timer(instance,
5733					    &instance->sriov_heartbeat_timer,
5734					    megasas_sriov_heartbeat_handler,
5735					    MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF);
5736		else
5737			instance->skip_heartbeat_timer_del = 1;
5738	}
5739
5740	instance->instancet->enable_intr(instance);
5741	instance->unload = 0;
5742
5743	/*
5744	 * Initiate AEN (Asynchronous Event Notification)
5745	 */
5746	if (megasas_start_aen(instance))
5747		printk(KERN_ERR "megasas: Start AEN failed\n");
5748
5749	return 0;
5750
5751fail_irq:
5752fail_init_mfi:
5753	if (instance->evt_detail)
5754		pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
5755				instance->evt_detail,
5756				instance->evt_detail_h);
5757
5758	if (instance->producer)
5759		pci_free_consistent(pdev, sizeof(u32), instance->producer,
5760				instance->producer_h);
5761	if (instance->consumer)
5762		pci_free_consistent(pdev, sizeof(u32), instance->consumer,
5763				instance->consumer_h);
5764	scsi_host_put(host);
5765
5766fail_set_dma_mask:
5767fail_ready_state:
5768fail_reenable_msix:
5769
5770	pci_disable_device(pdev);
5771
5772	return -ENODEV;
5773}
5774#else
5775#define megasas_suspend	NULL
5776#define megasas_resume	NULL
5777#endif
5778
5779/**
5780 * megasas_detach_one -	PCI hot"un"plug entry point
5781 * @pdev:		PCI device structure
5782 */
5783static void megasas_detach_one(struct pci_dev *pdev)
5784{
5785	int i;
5786	struct Scsi_Host *host;
5787	struct megasas_instance *instance;
5788	struct fusion_context *fusion;
5789
5790	instance = pci_get_drvdata(pdev);
5791	instance->unload = 1;
5792	host = instance->host;
5793	fusion = instance->ctrl_context;
5794
5795	/* Shutdown SR-IOV heartbeat timer */
5796	if (instance->requestorId && !instance->skip_heartbeat_timer_del)
5797		del_timer_sync(&instance->sriov_heartbeat_timer);
5798
5799	if (instance->fw_crash_state != UNAVAILABLE)
5800		megasas_free_host_crash_buffer(instance);
5801	scsi_remove_host(instance->host);
5802	megasas_flush_cache(instance);
5803	megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
5804
5805	/* cancel the delayed work if this work still in queue*/
5806	if (instance->ev != NULL) {
5807		struct megasas_aen_event *ev = instance->ev;
5808		cancel_delayed_work_sync(&ev->hotplug_work);
5809		instance->ev = NULL;
5810	}
5811
5812	/* cancel all wait events */
5813	wake_up_all(&instance->int_cmd_wait_q);
5814
5815	tasklet_kill(&instance->isr_tasklet);
5816
5817	/*
5818	 * Take the instance off the instance array. Note that we will not
5819	 * decrement the max_index. We let this array be sparse array
5820	 */
5821	for (i = 0; i < megasas_mgmt_info.max_index; i++) {
5822		if (megasas_mgmt_info.instance[i] == instance) {
5823			megasas_mgmt_info.count--;
5824			megasas_mgmt_info.instance[i] = NULL;
5825
5826			break;
5827		}
5828	}
5829
5830	instance->instancet->disable_intr(instance);
5831
5832	if (instance->msix_vectors)
5833		for (i = 0; i < instance->msix_vectors; i++) {
5834			if (smp_affinity_enable)
5835				irq_set_affinity_hint(
5836					instance->msixentry[i].vector, NULL);
5837			free_irq(instance->msixentry[i].vector,
5838				 &instance->irq_context[i]);
5839		}
5840	else
5841		free_irq(instance->pdev->irq, &instance->irq_context[0]);
5842	if (instance->msix_vectors)
5843		pci_disable_msix(instance->pdev);
5844
5845	switch (instance->pdev->device) {
5846	case PCI_DEVICE_ID_LSI_FUSION:
5847	case PCI_DEVICE_ID_LSI_PLASMA:
5848	case PCI_DEVICE_ID_LSI_INVADER:
5849	case PCI_DEVICE_ID_LSI_FURY:
5850		megasas_release_fusion(instance);
5851		for (i = 0; i < 2 ; i++) {
5852			if (fusion->ld_map[i])
5853				dma_free_coherent(&instance->pdev->dev,
5854						  fusion->max_map_sz,
5855						  fusion->ld_map[i],
5856						  fusion->ld_map_phys[i]);
5857			if (fusion->ld_drv_map[i])
5858				free_pages((ulong)fusion->ld_drv_map[i],
5859					fusion->drv_map_pages);
5860		}
5861		free_pages((ulong)instance->ctrl_context,
5862			instance->ctrl_context_pages);
5863		break;
5864	default:
5865		megasas_release_mfi(instance);
5866		pci_free_consistent(pdev, sizeof(u32),
5867				    instance->producer,
5868				    instance->producer_h);
5869		pci_free_consistent(pdev, sizeof(u32),
5870				    instance->consumer,
5871				    instance->consumer_h);
5872		break;
5873	}
5874
5875	kfree(instance->ctrl_info);
5876
5877	if (instance->evt_detail)
5878		pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
5879				instance->evt_detail, instance->evt_detail_h);
5880
5881	if (instance->vf_affiliation)
5882		pci_free_consistent(pdev, (MAX_LOGICAL_DRIVES + 1) *
5883				    sizeof(struct MR_LD_VF_AFFILIATION),
5884				    instance->vf_affiliation,
5885				    instance->vf_affiliation_h);
5886
5887	if (instance->vf_affiliation_111)
5888		pci_free_consistent(pdev,
5889				    sizeof(struct MR_LD_VF_AFFILIATION_111),
5890				    instance->vf_affiliation_111,
5891				    instance->vf_affiliation_111_h);
5892
5893	if (instance->hb_host_mem)
5894		pci_free_consistent(pdev, sizeof(struct MR_CTRL_HB_HOST_MEM),
5895				    instance->hb_host_mem,
5896				    instance->hb_host_mem_h);
5897
5898	if (instance->crash_dump_buf)
5899		pci_free_consistent(pdev, CRASH_DMA_BUF_SIZE,
5900			    instance->crash_dump_buf, instance->crash_dump_h);
5901
5902	scsi_host_put(host);
5903
5904	pci_disable_device(pdev);
5905
5906	return;
5907}
5908
5909/**
5910 * megasas_shutdown -	Shutdown entry point
5911 * @device:		Generic device structure
5912 */
5913static void megasas_shutdown(struct pci_dev *pdev)
5914{
5915	int i;
5916	struct megasas_instance *instance = pci_get_drvdata(pdev);
5917
5918	instance->unload = 1;
5919	megasas_flush_cache(instance);
5920	megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
5921	instance->instancet->disable_intr(instance);
5922	if (instance->msix_vectors)
5923		for (i = 0; i < instance->msix_vectors; i++) {
5924			if (smp_affinity_enable)
5925				irq_set_affinity_hint(
5926					instance->msixentry[i].vector, NULL);
5927			free_irq(instance->msixentry[i].vector,
5928				 &instance->irq_context[i]);
5929		}
5930	else
5931		free_irq(instance->pdev->irq, &instance->irq_context[0]);
5932	if (instance->msix_vectors)
5933		pci_disable_msix(instance->pdev);
5934}
5935
5936/**
5937 * megasas_mgmt_open -	char node "open" entry point
5938 */
5939static int megasas_mgmt_open(struct inode *inode, struct file *filep)
5940{
5941	/*
5942	 * Allow only those users with admin rights
5943	 */
5944	if (!capable(CAP_SYS_ADMIN))
5945		return -EACCES;
5946
5947	return 0;
5948}
5949
5950/**
5951 * megasas_mgmt_fasync -	Async notifier registration from applications
5952 *
5953 * This function adds the calling process to a driver global queue. When an
5954 * event occurs, SIGIO will be sent to all processes in this queue.
5955 */
5956static int megasas_mgmt_fasync(int fd, struct file *filep, int mode)
5957{
5958	int rc;
5959
5960	mutex_lock(&megasas_async_queue_mutex);
5961
5962	rc = fasync_helper(fd, filep, mode, &megasas_async_queue);
5963
5964	mutex_unlock(&megasas_async_queue_mutex);
5965
5966	if (rc >= 0) {
5967		/* For sanity check when we get ioctl */
5968		filep->private_data = filep;
5969		return 0;
5970	}
5971
5972	printk(KERN_DEBUG "megasas: fasync_helper failed [%d]\n", rc);
5973
5974	return rc;
5975}
5976
5977/**
5978 * megasas_mgmt_poll -  char node "poll" entry point
5979 * */
5980static unsigned int megasas_mgmt_poll(struct file *file, poll_table *wait)
5981{
5982	unsigned int mask;
5983	unsigned long flags;
5984	poll_wait(file, &megasas_poll_wait, wait);
5985	spin_lock_irqsave(&poll_aen_lock, flags);
5986	if (megasas_poll_wait_aen)
5987		mask =   (POLLIN | POLLRDNORM);
5988
5989	else
5990		mask = 0;
5991	megasas_poll_wait_aen = 0;
5992	spin_unlock_irqrestore(&poll_aen_lock, flags);
5993	return mask;
5994}
5995
5996/*
5997 * megasas_set_crash_dump_params_ioctl:
5998 *		Send CRASH_DUMP_MODE DCMD to all controllers
5999 * @cmd:	MFI command frame
6000 */
6001
6002static int megasas_set_crash_dump_params_ioctl(
6003	struct megasas_cmd *cmd)
6004{
6005	struct megasas_instance *local_instance;
6006	int i, error = 0;
6007	int crash_support;
6008
6009	crash_support = cmd->frame->dcmd.mbox.w[0];
6010
6011	for (i = 0; i < megasas_mgmt_info.max_index; i++) {
6012		local_instance = megasas_mgmt_info.instance[i];
6013		if (local_instance && local_instance->crash_dump_drv_support) {
6014			if ((local_instance->adprecovery ==
6015				MEGASAS_HBA_OPERATIONAL) &&
6016				!megasas_set_crash_dump_params(local_instance,
6017					crash_support)) {
6018				local_instance->crash_dump_app_support =
6019					crash_support;
6020				dev_info(&local_instance->pdev->dev,
6021					"Application firmware crash "
6022					"dump mode set success\n");
6023				error = 0;
6024			} else {
6025				dev_info(&local_instance->pdev->dev,
6026					"Application firmware crash "
6027					"dump mode set failed\n");
6028				error = -1;
6029			}
6030		}
6031	}
6032	return error;
6033}
6034
6035/**
6036 * megasas_mgmt_fw_ioctl -	Issues management ioctls to FW
6037 * @instance:			Adapter soft state
6038 * @argp:			User's ioctl packet
6039 */
6040static int
6041megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
6042		      struct megasas_iocpacket __user * user_ioc,
6043		      struct megasas_iocpacket *ioc)
6044{
6045	struct megasas_sge32 *kern_sge32;
6046	struct megasas_cmd *cmd;
6047	void *kbuff_arr[MAX_IOCTL_SGE];
6048	dma_addr_t buf_handle = 0;
6049	int error = 0, i;
6050	void *sense = NULL;
6051	dma_addr_t sense_handle;
6052	unsigned long *sense_ptr;
6053
6054	memset(kbuff_arr, 0, sizeof(kbuff_arr));
6055
6056	if (ioc->sge_count > MAX_IOCTL_SGE) {
6057		printk(KERN_DEBUG "megasas: SGE count [%d] >  max limit [%d]\n",
6058		       ioc->sge_count, MAX_IOCTL_SGE);
6059		return -EINVAL;
6060	}
6061
6062	cmd = megasas_get_cmd(instance);
6063	if (!cmd) {
6064		printk(KERN_DEBUG "megasas: Failed to get a cmd packet\n");
6065		return -ENOMEM;
6066	}
6067
6068	/*
6069	 * User's IOCTL packet has 2 frames (maximum). Copy those two
6070	 * frames into our cmd's frames. cmd->frame's context will get
6071	 * overwritten when we copy from user's frames. So set that value
6072	 * alone separately
6073	 */
6074	memcpy(cmd->frame, ioc->frame.raw, 2 * MEGAMFI_FRAME_SIZE);
6075	cmd->frame->hdr.context = cpu_to_le32(cmd->index);
6076	cmd->frame->hdr.pad_0 = 0;
6077	cmd->frame->hdr.flags &= cpu_to_le16(~(MFI_FRAME_IEEE |
6078					       MFI_FRAME_SGL64 |
6079					       MFI_FRAME_SENSE64));
6080
6081	if (cmd->frame->dcmd.opcode == MR_DRIVER_SET_APP_CRASHDUMP_MODE) {
6082		error = megasas_set_crash_dump_params_ioctl(cmd);
6083		megasas_return_cmd(instance, cmd);
6084		return error;
6085	}
6086
6087	/*
6088	 * The management interface between applications and the fw uses
6089	 * MFI frames. E.g, RAID configuration changes, LD property changes
6090	 * etc are accomplishes through different kinds of MFI frames. The
6091	 * driver needs to care only about substituting user buffers with
6092	 * kernel buffers in SGLs. The location of SGL is embedded in the
6093	 * struct iocpacket itself.
6094	 */
6095	kern_sge32 = (struct megasas_sge32 *)
6096	    ((unsigned long)cmd->frame + ioc->sgl_off);
6097
6098	/*
6099	 * For each user buffer, create a mirror buffer and copy in
6100	 */
6101	for (i = 0; i < ioc->sge_count; i++) {
6102		if (!ioc->sgl[i].iov_len)
6103			continue;
6104
6105		kbuff_arr[i] = dma_alloc_coherent(&instance->pdev->dev,
6106						    ioc->sgl[i].iov_len,
6107						    &buf_handle, GFP_KERNEL);
6108		if (!kbuff_arr[i]) {
6109			printk(KERN_DEBUG "megasas: Failed to alloc "
6110			       "kernel SGL buffer for IOCTL \n");
6111			error = -ENOMEM;
6112			goto out;
6113		}
6114
6115		/*
6116		 * We don't change the dma_coherent_mask, so
6117		 * pci_alloc_consistent only returns 32bit addresses
6118		 */
6119		kern_sge32[i].phys_addr = cpu_to_le32(buf_handle);
6120		kern_sge32[i].length = cpu_to_le32(ioc->sgl[i].iov_len);
6121
6122		/*
6123		 * We created a kernel buffer corresponding to the
6124		 * user buffer. Now copy in from the user buffer
6125		 */
6126		if (copy_from_user(kbuff_arr[i], ioc->sgl[i].iov_base,
6127				   (u32) (ioc->sgl[i].iov_len))) {
6128			error = -EFAULT;
6129			goto out;
6130		}
6131	}
6132
6133	if (ioc->sense_len) {
6134		sense = dma_alloc_coherent(&instance->pdev->dev, ioc->sense_len,
6135					     &sense_handle, GFP_KERNEL);
6136		if (!sense) {
6137			error = -ENOMEM;
6138			goto out;
6139		}
6140
6141		sense_ptr =
6142		(unsigned long *) ((unsigned long)cmd->frame + ioc->sense_off);
6143		*sense_ptr = cpu_to_le32(sense_handle);
6144	}
6145
6146	/*
6147	 * Set the sync_cmd flag so that the ISR knows not to complete this
6148	 * cmd to the SCSI mid-layer
6149	 */
6150	cmd->sync_cmd = 1;
6151	megasas_issue_blocked_cmd(instance, cmd, 0);
6152	cmd->sync_cmd = 0;
6153
6154	if (instance->unload == 1) {
6155		dev_info(&instance->pdev->dev, "Driver unload is in progress "
6156			"don't submit data to application\n");
6157		goto out;
6158	}
6159	/*
6160	 * copy out the kernel buffers to user buffers
6161	 */
6162	for (i = 0; i < ioc->sge_count; i++) {
6163		if (copy_to_user(ioc->sgl[i].iov_base, kbuff_arr[i],
6164				 ioc->sgl[i].iov_len)) {
6165			error = -EFAULT;
6166			goto out;
6167		}
6168	}
6169
6170	/*
6171	 * copy out the sense
6172	 */
6173	if (ioc->sense_len) {
6174		/*
6175		 * sense_ptr points to the location that has the user
6176		 * sense buffer address
6177		 */
6178		sense_ptr = (unsigned long *) ((unsigned long)ioc->frame.raw +
6179				ioc->sense_off);
6180
6181		if (copy_to_user((void __user *)((unsigned long)(*sense_ptr)),
6182				 sense, ioc->sense_len)) {
6183			printk(KERN_ERR "megasas: Failed to copy out to user "
6184					"sense data\n");
6185			error = -EFAULT;
6186			goto out;
6187		}
6188	}
6189
6190	/*
6191	 * copy the status codes returned by the fw
6192	 */
6193	if (copy_to_user(&user_ioc->frame.hdr.cmd_status,
6194			 &cmd->frame->hdr.cmd_status, sizeof(u8))) {
6195		printk(KERN_DEBUG "megasas: Error copying out cmd_status\n");
6196		error = -EFAULT;
6197	}
6198
6199      out:
6200	if (sense) {
6201		dma_free_coherent(&instance->pdev->dev, ioc->sense_len,
6202				    sense, sense_handle);
6203	}
6204
6205	for (i = 0; i < ioc->sge_count; i++) {
6206		if (kbuff_arr[i])
6207			dma_free_coherent(&instance->pdev->dev,
6208					  le32_to_cpu(kern_sge32[i].length),
6209					  kbuff_arr[i],
6210					  le32_to_cpu(kern_sge32[i].phys_addr));
6211			kbuff_arr[i] = NULL;
6212	}
6213
6214	if (instance->ctrl_context && cmd->mpt_pthr_cmd_blocked)
6215		megasas_return_mfi_mpt_pthr(instance, cmd,
6216			cmd->mpt_pthr_cmd_blocked);
6217	else
6218		megasas_return_cmd(instance, cmd);
6219	return error;
6220}
6221
6222static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
6223{
6224	struct megasas_iocpacket __user *user_ioc =
6225	    (struct megasas_iocpacket __user *)arg;
6226	struct megasas_iocpacket *ioc;
6227	struct megasas_instance *instance;
6228	int error;
6229	int i;
6230	unsigned long flags;
6231	u32 wait_time = MEGASAS_RESET_WAIT_TIME;
6232
6233	ioc = kmalloc(sizeof(*ioc), GFP_KERNEL);
6234	if (!ioc)
6235		return -ENOMEM;
6236
6237	if (copy_from_user(ioc, user_ioc, sizeof(*ioc))) {
6238		error = -EFAULT;
6239		goto out_kfree_ioc;
6240	}
6241
6242	instance = megasas_lookup_instance(ioc->host_no);
6243	if (!instance) {
6244		error = -ENODEV;
6245		goto out_kfree_ioc;
6246	}
6247
6248	/* Adjust ioctl wait time for VF mode */
6249	if (instance->requestorId)
6250		wait_time = MEGASAS_ROUTINE_WAIT_TIME_VF;
6251
6252	/* Block ioctls in VF mode */
6253	if (instance->requestorId && !allow_vf_ioctls) {
6254		error = -ENODEV;
6255		goto out_kfree_ioc;
6256	}
6257
6258	if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
6259		printk(KERN_ERR "Controller in crit error\n");
6260		error = -ENODEV;
6261		goto out_kfree_ioc;
6262	}
6263
6264	if (instance->unload == 1) {
6265		error = -ENODEV;
6266		goto out_kfree_ioc;
6267	}
6268
6269	if (down_interruptible(&instance->ioctl_sem)) {
6270		error = -ERESTARTSYS;
6271		goto out_kfree_ioc;
6272	}
6273
6274	for (i = 0; i < wait_time; i++) {
6275
6276		spin_lock_irqsave(&instance->hba_lock, flags);
6277		if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) {
6278			spin_unlock_irqrestore(&instance->hba_lock, flags);
6279			break;
6280		}
6281		spin_unlock_irqrestore(&instance->hba_lock, flags);
6282
6283		if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
6284			printk(KERN_NOTICE "megasas: waiting"
6285				"for controller reset to finish\n");
6286		}
6287
6288		msleep(1000);
6289	}
6290
6291	spin_lock_irqsave(&instance->hba_lock, flags);
6292	if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
6293		spin_unlock_irqrestore(&instance->hba_lock, flags);
6294
6295		printk(KERN_ERR "megaraid_sas: timed out while"
6296			"waiting for HBA to recover\n");
6297		error = -ENODEV;
6298		goto out_up;
6299	}
6300	spin_unlock_irqrestore(&instance->hba_lock, flags);
6301
6302	error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc);
6303      out_up:
6304	up(&instance->ioctl_sem);
6305
6306      out_kfree_ioc:
6307	kfree(ioc);
6308	return error;
6309}
6310
6311static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)
6312{
6313	struct megasas_instance *instance;
6314	struct megasas_aen aen;
6315	int error;
6316	int i;
6317	unsigned long flags;
6318	u32 wait_time = MEGASAS_RESET_WAIT_TIME;
6319
6320	if (file->private_data != file) {
6321		printk(KERN_DEBUG "megasas: fasync_helper was not "
6322		       "called first\n");
6323		return -EINVAL;
6324	}
6325
6326	if (copy_from_user(&aen, (void __user *)arg, sizeof(aen)))
6327		return -EFAULT;
6328
6329	instance = megasas_lookup_instance(aen.host_no);
6330
6331	if (!instance)
6332		return -ENODEV;
6333
6334	if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
6335		return -ENODEV;
6336	}
6337
6338	if (instance->unload == 1) {
6339		return -ENODEV;
6340	}
6341
6342	for (i = 0; i < wait_time; i++) {
6343
6344		spin_lock_irqsave(&instance->hba_lock, flags);
6345		if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) {
6346			spin_unlock_irqrestore(&instance->hba_lock,
6347						flags);
6348			break;
6349		}
6350
6351		spin_unlock_irqrestore(&instance->hba_lock, flags);
6352
6353		if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
6354			printk(KERN_NOTICE "megasas: waiting for"
6355				"controller reset to finish\n");
6356		}
6357
6358		msleep(1000);
6359	}
6360
6361	spin_lock_irqsave(&instance->hba_lock, flags);
6362	if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
6363		spin_unlock_irqrestore(&instance->hba_lock, flags);
6364		printk(KERN_ERR "megaraid_sas: timed out while waiting"
6365				"for HBA to recover.\n");
6366		return -ENODEV;
6367	}
6368	spin_unlock_irqrestore(&instance->hba_lock, flags);
6369
6370	mutex_lock(&instance->aen_mutex);
6371	error = megasas_register_aen(instance, aen.seq_num,
6372				     aen.class_locale_word);
6373	mutex_unlock(&instance->aen_mutex);
6374	return error;
6375}
6376
6377/**
6378 * megasas_mgmt_ioctl -	char node ioctl entry point
6379 */
6380static long
6381megasas_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
6382{
6383	switch (cmd) {
6384	case MEGASAS_IOC_FIRMWARE:
6385		return megasas_mgmt_ioctl_fw(file, arg);
6386
6387	case MEGASAS_IOC_GET_AEN:
6388		return megasas_mgmt_ioctl_aen(file, arg);
6389	}
6390
6391	return -ENOTTY;
6392}
6393
6394#ifdef CONFIG_COMPAT
6395static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
6396{
6397	struct compat_megasas_iocpacket __user *cioc =
6398	    (struct compat_megasas_iocpacket __user *)arg;
6399	struct megasas_iocpacket __user *ioc =
6400	    compat_alloc_user_space(sizeof(struct megasas_iocpacket));
6401	int i;
6402	int error = 0;
6403	compat_uptr_t ptr;
6404
6405	if (clear_user(ioc, sizeof(*ioc)))
6406		return -EFAULT;
6407
6408	if (copy_in_user(&ioc->host_no, &cioc->host_no, sizeof(u16)) ||
6409	    copy_in_user(&ioc->sgl_off, &cioc->sgl_off, sizeof(u32)) ||
6410	    copy_in_user(&ioc->sense_off, &cioc->sense_off, sizeof(u32)) ||
6411	    copy_in_user(&ioc->sense_len, &cioc->sense_len, sizeof(u32)) ||
6412	    copy_in_user(ioc->frame.raw, cioc->frame.raw, 128) ||
6413	    copy_in_user(&ioc->sge_count, &cioc->sge_count, sizeof(u32)))
6414		return -EFAULT;
6415
6416	/*
6417	 * The sense_ptr is used in megasas_mgmt_fw_ioctl only when
6418	 * sense_len is not null, so prepare the 64bit value under
6419	 * the same condition.
6420	 */
6421	if (ioc->sense_len) {
6422		void __user **sense_ioc_ptr =
6423			(void __user **)(ioc->frame.raw + ioc->sense_off);
6424		compat_uptr_t *sense_cioc_ptr =
6425			(compat_uptr_t *)(cioc->frame.raw + cioc->sense_off);
6426		if (get_user(ptr, sense_cioc_ptr) ||
6427		    put_user(compat_ptr(ptr), sense_ioc_ptr))
6428			return -EFAULT;
6429	}
6430
6431	for (i = 0; i < MAX_IOCTL_SGE; i++) {
6432		if (get_user(ptr, &cioc->sgl[i].iov_base) ||
6433		    put_user(compat_ptr(ptr), &ioc->sgl[i].iov_base) ||
6434		    copy_in_user(&ioc->sgl[i].iov_len,
6435				 &cioc->sgl[i].iov_len, sizeof(compat_size_t)))
6436			return -EFAULT;
6437	}
6438
6439	error = megasas_mgmt_ioctl_fw(file, (unsigned long)ioc);
6440
6441	if (copy_in_user(&cioc->frame.hdr.cmd_status,
6442			 &ioc->frame.hdr.cmd_status, sizeof(u8))) {
6443		printk(KERN_DEBUG "megasas: error copy_in_user cmd_status\n");
6444		return -EFAULT;
6445	}
6446	return error;
6447}
6448
6449static long
6450megasas_mgmt_compat_ioctl(struct file *file, unsigned int cmd,
6451			  unsigned long arg)
6452{
6453	switch (cmd) {
6454	case MEGASAS_IOC_FIRMWARE32:
6455		return megasas_mgmt_compat_ioctl_fw(file, arg);
6456	case MEGASAS_IOC_GET_AEN:
6457		return megasas_mgmt_ioctl_aen(file, arg);
6458	}
6459
6460	return -ENOTTY;
6461}
6462#endif
6463
6464/*
6465 * File operations structure for management interface
6466 */
6467static const struct file_operations megasas_mgmt_fops = {
6468	.owner = THIS_MODULE,
6469	.open = megasas_mgmt_open,
6470	.fasync = megasas_mgmt_fasync,
6471	.unlocked_ioctl = megasas_mgmt_ioctl,
6472	.poll = megasas_mgmt_poll,
6473#ifdef CONFIG_COMPAT
6474	.compat_ioctl = megasas_mgmt_compat_ioctl,
6475#endif
6476	.llseek = noop_llseek,
6477};
6478
6479/*
6480 * PCI hotplug support registration structure
6481 */
6482static struct pci_driver megasas_pci_driver = {
6483
6484	.name = "megaraid_sas",
6485	.id_table = megasas_pci_table,
6486	.probe = megasas_probe_one,
6487	.remove = megasas_detach_one,
6488	.suspend = megasas_suspend,
6489	.resume = megasas_resume,
6490	.shutdown = megasas_shutdown,
6491};
6492
6493/*
6494 * Sysfs driver attributes
6495 */
6496static ssize_t megasas_sysfs_show_version(struct device_driver *dd, char *buf)
6497{
6498	return snprintf(buf, strlen(MEGASAS_VERSION) + 2, "%s\n",
6499			MEGASAS_VERSION);
6500}
6501
6502static DRIVER_ATTR(version, S_IRUGO, megasas_sysfs_show_version, NULL);
6503
6504static ssize_t
6505megasas_sysfs_show_support_poll_for_event(struct device_driver *dd, char *buf)
6506{
6507	return sprintf(buf, "%u\n", support_poll_for_event);
6508}
6509
6510static DRIVER_ATTR(support_poll_for_event, S_IRUGO,
6511			megasas_sysfs_show_support_poll_for_event, NULL);
6512
6513 static ssize_t
6514megasas_sysfs_show_support_device_change(struct device_driver *dd, char *buf)
6515{
6516	return sprintf(buf, "%u\n", support_device_change);
6517}
6518
6519static DRIVER_ATTR(support_device_change, S_IRUGO,
6520			megasas_sysfs_show_support_device_change, NULL);
6521
6522static ssize_t
6523megasas_sysfs_show_dbg_lvl(struct device_driver *dd, char *buf)
6524{
6525	return sprintf(buf, "%u\n", megasas_dbg_lvl);
6526}
6527
6528static ssize_t
6529megasas_sysfs_set_dbg_lvl(struct device_driver *dd, const char *buf, size_t count)
6530{
6531	int retval = count;
6532	if(sscanf(buf,"%u",&megasas_dbg_lvl)<1){
6533		printk(KERN_ERR "megasas: could not set dbg_lvl\n");
6534		retval = -EINVAL;
6535	}
6536	return retval;
6537}
6538
6539static DRIVER_ATTR(dbg_lvl, S_IRUGO|S_IWUSR, megasas_sysfs_show_dbg_lvl,
6540		megasas_sysfs_set_dbg_lvl);
6541
6542static void
6543megasas_aen_polling(struct work_struct *work)
6544{
6545	struct megasas_aen_event *ev =
6546		container_of(work, struct megasas_aen_event, hotplug_work.work);
6547	struct megasas_instance *instance = ev->instance;
6548	union megasas_evt_class_locale class_locale;
6549	struct  Scsi_Host *host;
6550	struct  scsi_device *sdev1;
6551	u16     pd_index = 0;
6552	u16	ld_index = 0;
6553	int     i, j, doscan = 0;
6554	u32 seq_num, wait_time = MEGASAS_RESET_WAIT_TIME;
6555	int error;
6556
6557	if (!instance) {
6558		printk(KERN_ERR "invalid instance!\n");
6559		kfree(ev);
6560		return;
6561	}
6562
6563	/* Adjust event workqueue thread wait time for VF mode */
6564	if (instance->requestorId)
6565		wait_time = MEGASAS_ROUTINE_WAIT_TIME_VF;
6566
6567	/* Don't run the event workqueue thread if OCR is running */
6568	for (i = 0; i < wait_time; i++) {
6569		if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL)
6570			break;
6571		if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
6572			printk(KERN_NOTICE "megasas: %s waiting for "
6573			       "controller reset to finish for scsi%d\n",
6574			       __func__, instance->host->host_no);
6575		}
6576		msleep(1000);
6577	}
6578
6579	instance->ev = NULL;
6580	host = instance->host;
6581	if (instance->evt_detail) {
6582
6583		switch (le32_to_cpu(instance->evt_detail->code)) {
6584		case MR_EVT_PD_INSERTED:
6585			if (megasas_get_pd_list(instance) == 0) {
6586			for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
6587				for (j = 0;
6588				j < MEGASAS_MAX_DEV_PER_CHANNEL;
6589				j++) {
6590
6591				pd_index =
6592				(i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
6593
6594				sdev1 =
6595				scsi_device_lookup(host, i, j, 0);
6596
6597				if (instance->pd_list[pd_index].driveState
6598						== MR_PD_STATE_SYSTEM) {
6599						if (!sdev1) {
6600						scsi_add_device(host, i, j, 0);
6601						}
6602
6603					if (sdev1)
6604						scsi_device_put(sdev1);
6605					}
6606				}
6607			}
6608			}
6609			doscan = 0;
6610			break;
6611
6612		case MR_EVT_PD_REMOVED:
6613			if (megasas_get_pd_list(instance) == 0) {
6614			for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
6615				for (j = 0;
6616				j < MEGASAS_MAX_DEV_PER_CHANNEL;
6617				j++) {
6618
6619				pd_index =
6620				(i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
6621
6622				sdev1 =
6623				scsi_device_lookup(host, i, j, 0);
6624
6625				if (instance->pd_list[pd_index].driveState
6626					== MR_PD_STATE_SYSTEM) {
6627					if (sdev1) {
6628						scsi_device_put(sdev1);
6629					}
6630				} else {
6631					if (sdev1) {
6632						scsi_remove_device(sdev1);
6633						scsi_device_put(sdev1);
6634					}
6635				}
6636				}
6637			}
6638			}
6639			doscan = 0;
6640			break;
6641
6642		case MR_EVT_LD_OFFLINE:
6643		case MR_EVT_CFG_CLEARED:
6644		case MR_EVT_LD_DELETED:
6645			if (!instance->requestorId ||
6646			    (instance->requestorId &&
6647			     megasas_get_ld_vf_affiliation(instance, 0))) {
6648				if (megasas_ld_list_query(instance,
6649							  MR_LD_QUERY_TYPE_EXPOSED_TO_HOST))
6650					megasas_get_ld_list(instance);
6651				for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
6652					for (j = 0;
6653					     j < MEGASAS_MAX_DEV_PER_CHANNEL;
6654					     j++) {
6655
6656						ld_index =
6657							(i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
6658
6659						sdev1 = scsi_device_lookup(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0);
6660
6661						if (instance->ld_ids[ld_index]
6662						    != 0xff) {
6663							if (sdev1)
6664								scsi_device_put(sdev1);
6665						} else {
6666							if (sdev1) {
6667								scsi_remove_device(sdev1);
6668								scsi_device_put(sdev1);
6669							}
6670						}
6671					}
6672				}
6673				doscan = 0;
6674			}
6675			break;
6676		case MR_EVT_LD_CREATED:
6677			if (!instance->requestorId ||
6678			    (instance->requestorId &&
6679			     megasas_get_ld_vf_affiliation(instance, 0))) {
6680				if (megasas_ld_list_query(instance,
6681							  MR_LD_QUERY_TYPE_EXPOSED_TO_HOST))
6682					megasas_get_ld_list(instance);
6683				for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
6684					for (j = 0;
6685					     j < MEGASAS_MAX_DEV_PER_CHANNEL;
6686					     j++) {
6687						ld_index =
6688							(i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
6689
6690						sdev1 = scsi_device_lookup(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0);
6691
6692						if (instance->ld_ids[ld_index]
6693						    != 0xff) {
6694							if (!sdev1)
6695								scsi_add_device(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0);
6696						}
6697						if (sdev1)
6698							scsi_device_put(sdev1);
6699					}
6700				}
6701				doscan = 0;
6702			}
6703			break;
6704		case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:
6705		case MR_EVT_FOREIGN_CFG_IMPORTED:
6706		case MR_EVT_LD_STATE_CHANGE:
6707			doscan = 1;
6708			break;
6709		default:
6710			doscan = 0;
6711			break;
6712		}
6713	} else {
6714		printk(KERN_ERR "invalid evt_detail!\n");
6715		kfree(ev);
6716		return;
6717	}
6718
6719	if (doscan) {
6720		printk(KERN_INFO "megaraid_sas: scanning for scsi%d...\n",
6721		       instance->host->host_no);
6722		if (megasas_get_pd_list(instance) == 0) {
6723			for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
6724				for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
6725					pd_index = i*MEGASAS_MAX_DEV_PER_CHANNEL + j;
6726					sdev1 = scsi_device_lookup(host, i, j, 0);
6727					if (instance->pd_list[pd_index].driveState ==
6728					    MR_PD_STATE_SYSTEM) {
6729						if (!sdev1) {
6730							scsi_add_device(host, i, j, 0);
6731						}
6732						if (sdev1)
6733							scsi_device_put(sdev1);
6734					} else {
6735						if (sdev1) {
6736							scsi_remove_device(sdev1);
6737							scsi_device_put(sdev1);
6738						}
6739					}
6740				}
6741			}
6742		}
6743
6744		if (!instance->requestorId ||
6745		    (instance->requestorId &&
6746		     megasas_get_ld_vf_affiliation(instance, 0))) {
6747			if (megasas_ld_list_query(instance,
6748						  MR_LD_QUERY_TYPE_EXPOSED_TO_HOST))
6749				megasas_get_ld_list(instance);
6750			for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
6751				for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL;
6752				     j++) {
6753					ld_index =
6754						(i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
6755
6756					sdev1 = scsi_device_lookup(host,
6757								   MEGASAS_MAX_PD_CHANNELS + i, j, 0);
6758					if (instance->ld_ids[ld_index]
6759					    != 0xff) {
6760						if (!sdev1)
6761							scsi_add_device(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0);
6762						else
6763							scsi_device_put(sdev1);
6764					} else {
6765						if (sdev1) {
6766							scsi_remove_device(sdev1);
6767							scsi_device_put(sdev1);
6768						}
6769					}
6770				}
6771			}
6772		}
6773	}
6774
6775	if ( instance->aen_cmd != NULL ) {
6776		kfree(ev);
6777		return ;
6778	}
6779
6780	seq_num = le32_to_cpu(instance->evt_detail->seq_num) + 1;
6781
6782	/* Register AEN with FW for latest sequence number plus 1 */
6783	class_locale.members.reserved = 0;
6784	class_locale.members.locale = MR_EVT_LOCALE_ALL;
6785	class_locale.members.class = MR_EVT_CLASS_DEBUG;
6786	mutex_lock(&instance->aen_mutex);
6787	error = megasas_register_aen(instance, seq_num,
6788					class_locale.word);
6789	mutex_unlock(&instance->aen_mutex);
6790
6791	if (error)
6792		printk(KERN_ERR "register aen failed error %x\n", error);
6793
6794	kfree(ev);
6795}
6796
6797/**
6798 * megasas_init - Driver load entry point
6799 */
6800static int __init megasas_init(void)
6801{
6802	int rval;
6803
6804	/*
6805	 * Announce driver version and other information
6806	 */
6807	pr_info("megasas: %s\n", MEGASAS_VERSION);
6808
6809	spin_lock_init(&poll_aen_lock);
6810
6811	support_poll_for_event = 2;
6812	support_device_change = 1;
6813
6814	memset(&megasas_mgmt_info, 0, sizeof(megasas_mgmt_info));
6815
6816	/*
6817	 * Register character device node
6818	 */
6819	rval = register_chrdev(0, "megaraid_sas_ioctl", &megasas_mgmt_fops);
6820
6821	if (rval < 0) {
6822		printk(KERN_DEBUG "megasas: failed to open device node\n");
6823		return rval;
6824	}
6825
6826	megasas_mgmt_majorno = rval;
6827
6828	/*
6829	 * Register ourselves as PCI hotplug module
6830	 */
6831	rval = pci_register_driver(&megasas_pci_driver);
6832
6833	if (rval) {
6834		printk(KERN_DEBUG "megasas: PCI hotplug registration failed \n");
6835		goto err_pcidrv;
6836	}
6837
6838	rval = driver_create_file(&megasas_pci_driver.driver,
6839				  &driver_attr_version);
6840	if (rval)
6841		goto err_dcf_attr_ver;
6842
6843	rval = driver_create_file(&megasas_pci_driver.driver,
6844				&driver_attr_support_poll_for_event);
6845	if (rval)
6846		goto err_dcf_support_poll_for_event;
6847
6848	rval = driver_create_file(&megasas_pci_driver.driver,
6849				  &driver_attr_dbg_lvl);
6850	if (rval)
6851		goto err_dcf_dbg_lvl;
6852	rval = driver_create_file(&megasas_pci_driver.driver,
6853				&driver_attr_support_device_change);
6854	if (rval)
6855		goto err_dcf_support_device_change;
6856
6857	return rval;
6858
6859err_dcf_support_device_change:
6860	driver_remove_file(&megasas_pci_driver.driver,
6861			   &driver_attr_dbg_lvl);
6862err_dcf_dbg_lvl:
6863	driver_remove_file(&megasas_pci_driver.driver,
6864			&driver_attr_support_poll_for_event);
6865err_dcf_support_poll_for_event:
6866	driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
6867err_dcf_attr_ver:
6868	pci_unregister_driver(&megasas_pci_driver);
6869err_pcidrv:
6870	unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
6871	return rval;
6872}
6873
6874/**
6875 * megasas_exit - Driver unload entry point
6876 */
6877static void __exit megasas_exit(void)
6878{
6879	driver_remove_file(&megasas_pci_driver.driver,
6880			   &driver_attr_dbg_lvl);
6881	driver_remove_file(&megasas_pci_driver.driver,
6882			&driver_attr_support_poll_for_event);
6883	driver_remove_file(&megasas_pci_driver.driver,
6884			&driver_attr_support_device_change);
6885	driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
6886
6887	pci_unregister_driver(&megasas_pci_driver);
6888	unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
6889}
6890
6891module_init(megasas_init);
6892module_exit(megasas_exit);
6893