2 * Linux MegaRAID driver for SAS based RAID controllers
4 * Copyright (c) 2003-2012 LSI Corporation.
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * FILE: megaraid_sas_base.c
21 * Version : 06.805.06.00-rc1
23 * Authors: LSI Corporation
27 * Adam Radford <linuxraid@lsi.com>
29 * Send feedback to: <megaraidlinux@lsi.com>
31 * Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
35 #include <linux/kernel.h>
36 #include <linux/types.h>
37 #include <linux/pci.h>
38 #include <linux/list.h>
39 #include <linux/moduleparam.h>
40 #include <linux/module.h>
41 #include <linux/spinlock.h>
42 #include <linux/interrupt.h>
43 #include <linux/delay.h>
44 #include <linux/uio.h>
45 #include <linux/slab.h>
46 #include <asm/uaccess.h>
48 #include <linux/compat.h>
49 #include <linux/blkdev.h>
50 #include <linux/mutex.h>
51 #include <linux/poll.h>
53 #include <scsi/scsi.h>
54 #include <scsi/scsi_cmnd.h>
55 #include <scsi/scsi_device.h>
56 #include <scsi/scsi_host.h>
57 #include <scsi/scsi_tcq.h>
58 #include "megaraid_sas_fusion.h"
59 #include "megaraid_sas.h"
62 * Number of sectors per IO command
63 * Will be set in megasas_init_mfi if user does not provide
65 static unsigned int max_sectors
;
66 module_param_named(max_sectors
, max_sectors
, int, 0);
67 MODULE_PARM_DESC(max_sectors
,
68 "Maximum number of sectors per IO command");
70 static int msix_disable
;
71 module_param(msix_disable
, int, S_IRUGO
);
72 MODULE_PARM_DESC(msix_disable
, "Disable MSI-X interrupt handling. Default: 0");
74 static unsigned int msix_vectors
;
75 module_param(msix_vectors
, int, S_IRUGO
);
76 MODULE_PARM_DESC(msix_vectors
, "MSI-X max vector count. Default: Set by FW");
78 static int allow_vf_ioctls
;
79 module_param(allow_vf_ioctls
, int, S_IRUGO
);
80 MODULE_PARM_DESC(allow_vf_ioctls
, "Allow ioctls in SR-IOV VF mode. Default: 0");
82 static int throttlequeuedepth
= MEGASAS_THROTTLE_QUEUE_DEPTH
;
83 module_param(throttlequeuedepth
, int, S_IRUGO
);
84 MODULE_PARM_DESC(throttlequeuedepth
,
85 "Adapter queue depth when throttled due to I/O timeout. Default: 16");
87 int resetwaittime
= MEGASAS_RESET_WAIT_TIME
;
88 module_param(resetwaittime
, int, S_IRUGO
);
89 MODULE_PARM_DESC(resetwaittime
, "Wait time in seconds after I/O timeout "
90 "before resetting adapter. Default: 180");
92 int smp_affinity_enable
= 1;
93 module_param(smp_affinity_enable
, int, S_IRUGO
);
94 MODULE_PARM_DESC(smp_affinity_enable
, "SMP affinity feature enable/disbale Default: enable(1)");
96 MODULE_LICENSE("GPL");
97 MODULE_VERSION(MEGASAS_VERSION
);
98 MODULE_AUTHOR("megaraidlinux@lsi.com");
99 MODULE_DESCRIPTION("LSI MegaRAID SAS Driver");
101 int megasas_transition_to_ready(struct megasas_instance
*instance
, int ocr
);
102 static int megasas_get_pd_list(struct megasas_instance
*instance
);
103 static int megasas_ld_list_query(struct megasas_instance
*instance
,
105 static int megasas_issue_init_mfi(struct megasas_instance
*instance
);
106 static int megasas_register_aen(struct megasas_instance
*instance
,
107 u32 seq_num
, u32 class_locale_word
);
109 * PCI ID table for all supported controllers
111 static struct pci_device_id megasas_pci_table
[] = {
113 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_SAS1064R
)},
115 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_SAS1078R
)},
117 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_SAS1078DE
)},
119 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_SAS1078GEN2
)},
121 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_SAS0079GEN2
)},
123 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_SAS0073SKINNY
)},
125 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_SAS0071SKINNY
)},
127 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_VERDE_ZCR
)},
128 /* xscale IOP, vega */
129 {PCI_DEVICE(PCI_VENDOR_ID_DELL
, PCI_DEVICE_ID_DELL_PERC5
)},
131 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_FUSION
)},
133 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_PLASMA
)},
135 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_INVADER
)},
137 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC
, PCI_DEVICE_ID_LSI_FURY
)},
142 MODULE_DEVICE_TABLE(pci
, megasas_pci_table
);
144 static int megasas_mgmt_majorno
;
145 struct megasas_mgmt_info megasas_mgmt_info
;
146 static struct fasync_struct
*megasas_async_queue
;
147 static DEFINE_MUTEX(megasas_async_queue_mutex
);
149 static int megasas_poll_wait_aen
;
150 static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait
);
151 static u32 support_poll_for_event
;
153 static u32 support_device_change
;
155 /* define lock for aen poll */
156 spinlock_t poll_aen_lock
;
159 megasas_complete_cmd(struct megasas_instance
*instance
, struct megasas_cmd
*cmd
,
162 megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem
*regs
);
164 megasas_adp_reset_gen2(struct megasas_instance
*instance
,
165 struct megasas_register_set __iomem
*reg_set
);
166 static irqreturn_t
megasas_isr(int irq
, void *devp
);
168 megasas_init_adapter_mfi(struct megasas_instance
*instance
);
170 megasas_build_and_issue_cmd(struct megasas_instance
*instance
,
171 struct scsi_cmnd
*scmd
);
172 static void megasas_complete_cmd_dpc(unsigned long instance_addr
);
174 megasas_release_fusion(struct megasas_instance
*instance
);
176 megasas_ioc_init_fusion(struct megasas_instance
*instance
);
178 megasas_free_cmds_fusion(struct megasas_instance
*instance
);
180 megasas_get_map_info(struct megasas_instance
*instance
);
182 megasas_sync_map_info(struct megasas_instance
*instance
);
184 wait_and_poll(struct megasas_instance
*instance
, struct megasas_cmd
*cmd
,
186 void megasas_reset_reply_desc(struct megasas_instance
*instance
);
187 int megasas_reset_fusion(struct Scsi_Host
*shost
, int iotimeout
);
188 void megasas_fusion_ocr_wq(struct work_struct
*work
);
189 static int megasas_get_ld_vf_affiliation(struct megasas_instance
*instance
,
191 int megasas_check_mpio_paths(struct megasas_instance
*instance
,
192 struct scsi_cmnd
*scmd
);
195 megasas_issue_dcmd(struct megasas_instance
*instance
, struct megasas_cmd
*cmd
)
197 instance
->instancet
->fire_cmd(instance
,
198 cmd
->frame_phys_addr
, 0, instance
->reg_set
);
202 * megasas_get_cmd - Get a command from the free pool
203 * @instance: Adapter soft state
205 * Returns a free command from the pool
207 struct megasas_cmd
*megasas_get_cmd(struct megasas_instance
211 struct megasas_cmd
*cmd
= NULL
;
213 spin_lock_irqsave(&instance
->mfi_pool_lock
, flags
);
215 if (!list_empty(&instance
->cmd_pool
)) {
216 cmd
= list_entry((&instance
->cmd_pool
)->next
,
217 struct megasas_cmd
, list
);
218 list_del_init(&cmd
->list
);
219 atomic_set(&cmd
->mfi_mpt_pthr
, MFI_MPT_DETACHED
);
221 printk(KERN_ERR
"megasas: Command pool empty!\n");
224 spin_unlock_irqrestore(&instance
->mfi_pool_lock
, flags
);
229 * __megasas_return_cmd - Return a cmd to free command pool
230 * @instance: Adapter soft state
231 * @cmd: Command packet to be returned to free command pool
234 __megasas_return_cmd(struct megasas_instance
*instance
, struct megasas_cmd
*cmd
)
237 * Don't go ahead and free the MFI frame, if corresponding
238 * MPT frame is not freed(valid for only fusion adapters).
239 * In case of MFI adapters, anyways for any allocated MFI
240 * frame will have cmd->mfi_mpt_mpthr set to MFI_MPT_DETACHED
242 if (atomic_read(&cmd
->mfi_mpt_pthr
) != MFI_MPT_DETACHED
)
246 cmd
->frame_count
= 0;
247 cmd
->is_wait_event
= 0;
248 cmd
->mpt_pthr_cmd_blocked
= NULL
;
250 if ((instance
->pdev
->device
!= PCI_DEVICE_ID_LSI_FUSION
) &&
251 (instance
->pdev
->device
!= PCI_DEVICE_ID_LSI_INVADER
) &&
252 (instance
->pdev
->device
!= PCI_DEVICE_ID_LSI_FURY
) &&
254 cmd
->frame
->hdr
.cmd
= MFI_CMD_INVALID
;
256 atomic_set(&cmd
->mfi_mpt_pthr
, MFI_LIST_ADDED
);
257 list_add(&cmd
->list
, (&instance
->cmd_pool
)->next
);
261 * megasas_return_cmd - Return a cmd to free command pool
262 * @instance: Adapter soft state
263 * @cmd: Command packet to be returned to free command pool
266 megasas_return_cmd(struct megasas_instance
*instance
, struct megasas_cmd
*cmd
)
270 spin_lock_irqsave(&instance
->mfi_pool_lock
, flags
);
271 __megasas_return_cmd(instance
, cmd
);
272 spin_unlock_irqrestore(&instance
->mfi_pool_lock
, flags
);
277 * The following functions are defined for xscale
278 * (deviceid : 1064R, PERC5) controllers
282 * megasas_enable_intr_xscale - Enables interrupts
283 * @regs: MFI register set
286 megasas_enable_intr_xscale(struct megasas_instance
*instance
)
288 struct megasas_register_set __iomem
*regs
;
289 regs
= instance
->reg_set
;
290 writel(0, &(regs
)->outbound_intr_mask
);
292 /* Dummy readl to force pci flush */
293 readl(®s
->outbound_intr_mask
);
297 * megasas_disable_intr_xscale -Disables interrupt
298 * @regs: MFI register set
301 megasas_disable_intr_xscale(struct megasas_instance
*instance
)
303 struct megasas_register_set __iomem
*regs
;
305 regs
= instance
->reg_set
;
306 writel(mask
, ®s
->outbound_intr_mask
);
307 /* Dummy readl to force pci flush */
308 readl(®s
->outbound_intr_mask
);
312 * megasas_read_fw_status_reg_xscale - returns the current FW status value
313 * @regs: MFI register set
316 megasas_read_fw_status_reg_xscale(struct megasas_register_set __iomem
* regs
)
318 return readl(&(regs
)->outbound_msg_0
);
321 * megasas_clear_interrupt_xscale - Check & clear interrupt
322 * @regs: MFI register set
325 megasas_clear_intr_xscale(struct megasas_register_set __iomem
* regs
)
330 * Check if it is our interrupt
332 status
= readl(®s
->outbound_intr_status
);
334 if (status
& MFI_OB_INTR_STATUS_MASK
)
335 mfiStatus
= MFI_INTR_FLAG_REPLY_MESSAGE
;
336 if (status
& MFI_XSCALE_OMR0_CHANGE_INTERRUPT
)
337 mfiStatus
|= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE
;
340 * Clear the interrupt by writing back the same value
343 writel(status
, ®s
->outbound_intr_status
);
345 /* Dummy readl to force pci flush */
346 readl(®s
->outbound_intr_status
);
352 * megasas_fire_cmd_xscale - Sends command to the FW
353 * @frame_phys_addr : Physical address of cmd
354 * @frame_count : Number of frames for the command
355 * @regs : MFI register set
358 megasas_fire_cmd_xscale(struct megasas_instance
*instance
,
359 dma_addr_t frame_phys_addr
,
361 struct megasas_register_set __iomem
*regs
)
364 spin_lock_irqsave(&instance
->hba_lock
, flags
);
365 writel((frame_phys_addr
>> 3)|(frame_count
),
366 &(regs
)->inbound_queue_port
);
367 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
371 * megasas_adp_reset_xscale - For controller reset
372 * @regs: MFI register set
375 megasas_adp_reset_xscale(struct megasas_instance
*instance
,
376 struct megasas_register_set __iomem
*regs
)
380 writel(MFI_ADP_RESET
, ®s
->inbound_doorbell
);
382 for (i
= 0; i
< 3; i
++)
383 msleep(1000); /* sleep for 3 secs */
385 pci_read_config_dword(instance
->pdev
, MFI_1068_PCSR_OFFSET
, &pcidata
);
386 printk(KERN_NOTICE
"pcidata = %x\n", pcidata
);
388 printk(KERN_NOTICE
"mfi 1068 offset read=%x\n", pcidata
);
390 pci_write_config_dword(instance
->pdev
,
391 MFI_1068_PCSR_OFFSET
, pcidata
);
393 for (i
= 0; i
< 2; i
++)
394 msleep(1000); /* need to wait 2 secs again */
397 pci_read_config_dword(instance
->pdev
,
398 MFI_1068_FW_HANDSHAKE_OFFSET
, &pcidata
);
399 printk(KERN_NOTICE
"1068 offset handshake read=%x\n", pcidata
);
400 if ((pcidata
& 0xffff0000) == MFI_1068_FW_READY
) {
401 printk(KERN_NOTICE
"1068 offset pcidt=%x\n", pcidata
);
403 pci_write_config_dword(instance
->pdev
,
404 MFI_1068_FW_HANDSHAKE_OFFSET
, pcidata
);
411 * megasas_check_reset_xscale - For controller reset check
412 * @regs: MFI register set
415 megasas_check_reset_xscale(struct megasas_instance
*instance
,
416 struct megasas_register_set __iomem
*regs
)
419 if ((instance
->adprecovery
!= MEGASAS_HBA_OPERATIONAL
) &&
420 (le32_to_cpu(*instance
->consumer
) ==
421 MEGASAS_ADPRESET_INPROG_SIGN
))
426 static struct megasas_instance_template megasas_instance_template_xscale
= {
428 .fire_cmd
= megasas_fire_cmd_xscale
,
429 .enable_intr
= megasas_enable_intr_xscale
,
430 .disable_intr
= megasas_disable_intr_xscale
,
431 .clear_intr
= megasas_clear_intr_xscale
,
432 .read_fw_status_reg
= megasas_read_fw_status_reg_xscale
,
433 .adp_reset
= megasas_adp_reset_xscale
,
434 .check_reset
= megasas_check_reset_xscale
,
435 .service_isr
= megasas_isr
,
436 .tasklet
= megasas_complete_cmd_dpc
,
437 .init_adapter
= megasas_init_adapter_mfi
,
438 .build_and_issue_cmd
= megasas_build_and_issue_cmd
,
439 .issue_dcmd
= megasas_issue_dcmd
,
443 * This is the end of set of functions & definitions specific
444 * to xscale (deviceid : 1064R, PERC5) controllers
448 * The following functions are defined for ppc (deviceid : 0x60)
453 * megasas_enable_intr_ppc - Enables interrupts
454 * @regs: MFI register set
457 megasas_enable_intr_ppc(struct megasas_instance
*instance
)
459 struct megasas_register_set __iomem
*regs
;
460 regs
= instance
->reg_set
;
461 writel(0xFFFFFFFF, &(regs
)->outbound_doorbell_clear
);
463 writel(~0x80000000, &(regs
)->outbound_intr_mask
);
465 /* Dummy readl to force pci flush */
466 readl(®s
->outbound_intr_mask
);
470 * megasas_disable_intr_ppc - Disable interrupt
471 * @regs: MFI register set
474 megasas_disable_intr_ppc(struct megasas_instance
*instance
)
476 struct megasas_register_set __iomem
*regs
;
477 u32 mask
= 0xFFFFFFFF;
478 regs
= instance
->reg_set
;
479 writel(mask
, ®s
->outbound_intr_mask
);
480 /* Dummy readl to force pci flush */
481 readl(®s
->outbound_intr_mask
);
485 * megasas_read_fw_status_reg_ppc - returns the current FW status value
486 * @regs: MFI register set
489 megasas_read_fw_status_reg_ppc(struct megasas_register_set __iomem
* regs
)
491 return readl(&(regs
)->outbound_scratch_pad
);
495 * megasas_clear_interrupt_ppc - Check & clear interrupt
496 * @regs: MFI register set
499 megasas_clear_intr_ppc(struct megasas_register_set __iomem
* regs
)
501 u32 status
, mfiStatus
= 0;
504 * Check if it is our interrupt
506 status
= readl(®s
->outbound_intr_status
);
508 if (status
& MFI_REPLY_1078_MESSAGE_INTERRUPT
)
509 mfiStatus
= MFI_INTR_FLAG_REPLY_MESSAGE
;
511 if (status
& MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT
)
512 mfiStatus
|= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE
;
515 * Clear the interrupt by writing back the same value
517 writel(status
, ®s
->outbound_doorbell_clear
);
519 /* Dummy readl to force pci flush */
520 readl(®s
->outbound_doorbell_clear
);
526 * megasas_fire_cmd_ppc - Sends command to the FW
527 * @frame_phys_addr : Physical address of cmd
528 * @frame_count : Number of frames for the command
529 * @regs : MFI register set
532 megasas_fire_cmd_ppc(struct megasas_instance
*instance
,
533 dma_addr_t frame_phys_addr
,
535 struct megasas_register_set __iomem
*regs
)
538 spin_lock_irqsave(&instance
->hba_lock
, flags
);
539 writel((frame_phys_addr
| (frame_count
<<1))|1,
540 &(regs
)->inbound_queue_port
);
541 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
545 * megasas_check_reset_ppc - For controller reset check
546 * @regs: MFI register set
549 megasas_check_reset_ppc(struct megasas_instance
*instance
,
550 struct megasas_register_set __iomem
*regs
)
552 if (instance
->adprecovery
!= MEGASAS_HBA_OPERATIONAL
)
558 static struct megasas_instance_template megasas_instance_template_ppc
= {
560 .fire_cmd
= megasas_fire_cmd_ppc
,
561 .enable_intr
= megasas_enable_intr_ppc
,
562 .disable_intr
= megasas_disable_intr_ppc
,
563 .clear_intr
= megasas_clear_intr_ppc
,
564 .read_fw_status_reg
= megasas_read_fw_status_reg_ppc
,
565 .adp_reset
= megasas_adp_reset_xscale
,
566 .check_reset
= megasas_check_reset_ppc
,
567 .service_isr
= megasas_isr
,
568 .tasklet
= megasas_complete_cmd_dpc
,
569 .init_adapter
= megasas_init_adapter_mfi
,
570 .build_and_issue_cmd
= megasas_build_and_issue_cmd
,
571 .issue_dcmd
= megasas_issue_dcmd
,
575 * megasas_enable_intr_skinny - Enables interrupts
576 * @regs: MFI register set
579 megasas_enable_intr_skinny(struct megasas_instance
*instance
)
581 struct megasas_register_set __iomem
*regs
;
582 regs
= instance
->reg_set
;
583 writel(0xFFFFFFFF, &(regs
)->outbound_intr_mask
);
585 writel(~MFI_SKINNY_ENABLE_INTERRUPT_MASK
, &(regs
)->outbound_intr_mask
);
587 /* Dummy readl to force pci flush */
588 readl(®s
->outbound_intr_mask
);
592 * megasas_disable_intr_skinny - Disables interrupt
593 * @regs: MFI register set
596 megasas_disable_intr_skinny(struct megasas_instance
*instance
)
598 struct megasas_register_set __iomem
*regs
;
599 u32 mask
= 0xFFFFFFFF;
600 regs
= instance
->reg_set
;
601 writel(mask
, ®s
->outbound_intr_mask
);
602 /* Dummy readl to force pci flush */
603 readl(®s
->outbound_intr_mask
);
607 * megasas_read_fw_status_reg_skinny - returns the current FW status value
608 * @regs: MFI register set
611 megasas_read_fw_status_reg_skinny(struct megasas_register_set __iomem
*regs
)
613 return readl(&(regs
)->outbound_scratch_pad
);
617 * megasas_clear_interrupt_skinny - Check & clear interrupt
618 * @regs: MFI register set
621 megasas_clear_intr_skinny(struct megasas_register_set __iomem
*regs
)
627 * Check if it is our interrupt
629 status
= readl(®s
->outbound_intr_status
);
631 if (!(status
& MFI_SKINNY_ENABLE_INTERRUPT_MASK
)) {
636 * Check if it is our interrupt
638 if ((megasas_read_fw_status_reg_skinny(regs
) & MFI_STATE_MASK
) ==
640 mfiStatus
= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE
;
642 mfiStatus
= MFI_INTR_FLAG_REPLY_MESSAGE
;
645 * Clear the interrupt by writing back the same value
647 writel(status
, ®s
->outbound_intr_status
);
650 * dummy read to flush PCI
652 readl(®s
->outbound_intr_status
);
658 * megasas_fire_cmd_skinny - Sends command to the FW
659 * @frame_phys_addr : Physical address of cmd
660 * @frame_count : Number of frames for the command
661 * @regs : MFI register set
664 megasas_fire_cmd_skinny(struct megasas_instance
*instance
,
665 dma_addr_t frame_phys_addr
,
667 struct megasas_register_set __iomem
*regs
)
670 spin_lock_irqsave(&instance
->hba_lock
, flags
);
671 writel(upper_32_bits(frame_phys_addr
),
672 &(regs
)->inbound_high_queue_port
);
673 writel((lower_32_bits(frame_phys_addr
) | (frame_count
<<1))|1,
674 &(regs
)->inbound_low_queue_port
);
675 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
679 * megasas_check_reset_skinny - For controller reset check
680 * @regs: MFI register set
683 megasas_check_reset_skinny(struct megasas_instance
*instance
,
684 struct megasas_register_set __iomem
*regs
)
686 if (instance
->adprecovery
!= MEGASAS_HBA_OPERATIONAL
)
692 static struct megasas_instance_template megasas_instance_template_skinny
= {
694 .fire_cmd
= megasas_fire_cmd_skinny
,
695 .enable_intr
= megasas_enable_intr_skinny
,
696 .disable_intr
= megasas_disable_intr_skinny
,
697 .clear_intr
= megasas_clear_intr_skinny
,
698 .read_fw_status_reg
= megasas_read_fw_status_reg_skinny
,
699 .adp_reset
= megasas_adp_reset_gen2
,
700 .check_reset
= megasas_check_reset_skinny
,
701 .service_isr
= megasas_isr
,
702 .tasklet
= megasas_complete_cmd_dpc
,
703 .init_adapter
= megasas_init_adapter_mfi
,
704 .build_and_issue_cmd
= megasas_build_and_issue_cmd
,
705 .issue_dcmd
= megasas_issue_dcmd
,
710 * The following functions are defined for gen2 (deviceid : 0x78 0x79)
715 * megasas_enable_intr_gen2 - Enables interrupts
716 * @regs: MFI register set
719 megasas_enable_intr_gen2(struct megasas_instance
*instance
)
721 struct megasas_register_set __iomem
*regs
;
722 regs
= instance
->reg_set
;
723 writel(0xFFFFFFFF, &(regs
)->outbound_doorbell_clear
);
725 /* write ~0x00000005 (4 & 1) to the intr mask*/
726 writel(~MFI_GEN2_ENABLE_INTERRUPT_MASK
, &(regs
)->outbound_intr_mask
);
728 /* Dummy readl to force pci flush */
729 readl(®s
->outbound_intr_mask
);
733 * megasas_disable_intr_gen2 - Disables interrupt
734 * @regs: MFI register set
737 megasas_disable_intr_gen2(struct megasas_instance
*instance
)
739 struct megasas_register_set __iomem
*regs
;
740 u32 mask
= 0xFFFFFFFF;
741 regs
= instance
->reg_set
;
742 writel(mask
, ®s
->outbound_intr_mask
);
743 /* Dummy readl to force pci flush */
744 readl(®s
->outbound_intr_mask
);
748 * megasas_read_fw_status_reg_gen2 - returns the current FW status value
749 * @regs: MFI register set
752 megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem
*regs
)
754 return readl(&(regs
)->outbound_scratch_pad
);
758 * megasas_clear_interrupt_gen2 - Check & clear interrupt
759 * @regs: MFI register set
762 megasas_clear_intr_gen2(struct megasas_register_set __iomem
*regs
)
767 * Check if it is our interrupt
769 status
= readl(®s
->outbound_intr_status
);
771 if (status
& MFI_INTR_FLAG_REPLY_MESSAGE
) {
772 mfiStatus
= MFI_INTR_FLAG_REPLY_MESSAGE
;
774 if (status
& MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT
) {
775 mfiStatus
|= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE
;
779 * Clear the interrupt by writing back the same value
782 writel(status
, ®s
->outbound_doorbell_clear
);
784 /* Dummy readl to force pci flush */
785 readl(®s
->outbound_intr_status
);
790 * megasas_fire_cmd_gen2 - Sends command to the FW
791 * @frame_phys_addr : Physical address of cmd
792 * @frame_count : Number of frames for the command
793 * @regs : MFI register set
796 megasas_fire_cmd_gen2(struct megasas_instance
*instance
,
797 dma_addr_t frame_phys_addr
,
799 struct megasas_register_set __iomem
*regs
)
802 spin_lock_irqsave(&instance
->hba_lock
, flags
);
803 writel((frame_phys_addr
| (frame_count
<<1))|1,
804 &(regs
)->inbound_queue_port
);
805 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
809 * megasas_adp_reset_gen2 - For controller reset
810 * @regs: MFI register set
813 megasas_adp_reset_gen2(struct megasas_instance
*instance
,
814 struct megasas_register_set __iomem
*reg_set
)
818 u32
*seq_offset
= ®_set
->seq_offset
;
819 u32
*hostdiag_offset
= ®_set
->host_diag
;
821 if (instance
->instancet
== &megasas_instance_template_skinny
) {
822 seq_offset
= ®_set
->fusion_seq_offset
;
823 hostdiag_offset
= ®_set
->fusion_host_diag
;
826 writel(0, seq_offset
);
827 writel(4, seq_offset
);
828 writel(0xb, seq_offset
);
829 writel(2, seq_offset
);
830 writel(7, seq_offset
);
831 writel(0xd, seq_offset
);
835 HostDiag
= (u32
)readl(hostdiag_offset
);
837 while ( !( HostDiag
& DIAG_WRITE_ENABLE
) ) {
839 HostDiag
= (u32
)readl(hostdiag_offset
);
840 printk(KERN_NOTICE
"RESETGEN2: retry=%x, hostdiag=%x\n",
848 printk(KERN_NOTICE
"ADP_RESET_GEN2: HostDiag=%x\n", HostDiag
);
850 writel((HostDiag
| DIAG_RESET_ADAPTER
), hostdiag_offset
);
854 HostDiag
= (u32
)readl(hostdiag_offset
);
855 while ( ( HostDiag
& DIAG_RESET_ADAPTER
) ) {
857 HostDiag
= (u32
)readl(hostdiag_offset
);
858 printk(KERN_NOTICE
"RESET_GEN2: retry=%x, hostdiag=%x\n",
869 * megasas_check_reset_gen2 - For controller reset check
870 * @regs: MFI register set
873 megasas_check_reset_gen2(struct megasas_instance
*instance
,
874 struct megasas_register_set __iomem
*regs
)
876 if (instance
->adprecovery
!= MEGASAS_HBA_OPERATIONAL
) {
883 static struct megasas_instance_template megasas_instance_template_gen2
= {
885 .fire_cmd
= megasas_fire_cmd_gen2
,
886 .enable_intr
= megasas_enable_intr_gen2
,
887 .disable_intr
= megasas_disable_intr_gen2
,
888 .clear_intr
= megasas_clear_intr_gen2
,
889 .read_fw_status_reg
= megasas_read_fw_status_reg_gen2
,
890 .adp_reset
= megasas_adp_reset_gen2
,
891 .check_reset
= megasas_check_reset_gen2
,
892 .service_isr
= megasas_isr
,
893 .tasklet
= megasas_complete_cmd_dpc
,
894 .init_adapter
= megasas_init_adapter_mfi
,
895 .build_and_issue_cmd
= megasas_build_and_issue_cmd
,
896 .issue_dcmd
= megasas_issue_dcmd
,
900 * This is the end of set of functions & definitions
901 * specific to gen2 (deviceid : 0x78, 0x79) controllers
905 * Template added for TB (Fusion)
907 extern struct megasas_instance_template megasas_instance_template_fusion
;
910 * megasas_issue_polled - Issues a polling command
911 * @instance: Adapter soft state
912 * @cmd: Command packet to be issued
914 * For polling, MFI requires the cmd_status to be set to 0xFF before posting.
917 megasas_issue_polled(struct megasas_instance
*instance
, struct megasas_cmd
*cmd
)
921 struct megasas_header
*frame_hdr
= &cmd
->frame
->hdr
;
923 frame_hdr
->cmd_status
= MFI_CMD_STATUS_POLL_MODE
;
924 frame_hdr
->flags
|= cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE
);
927 * Issue the frame using inbound queue port
929 instance
->instancet
->issue_dcmd(instance
, cmd
);
932 * Wait for cmd_status to change
934 if (instance
->requestorId
)
935 seconds
= MEGASAS_ROUTINE_WAIT_TIME_VF
;
937 seconds
= MFI_POLL_TIMEOUT_SECS
;
938 return wait_and_poll(instance
, cmd
, seconds
);
942 * megasas_issue_blocked_cmd - Synchronous wrapper around regular FW cmds
943 * @instance: Adapter soft state
944 * @cmd: Command to be issued
945 * @timeout: Timeout in seconds
947 * This function waits on an event for the command to be returned from ISR.
948 * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
949 * Used to issue ioctl commands.
952 megasas_issue_blocked_cmd(struct megasas_instance
*instance
,
953 struct megasas_cmd
*cmd
, int timeout
)
956 cmd
->cmd_status
= ENODATA
;
958 cmd
->is_wait_event
= 1;
959 instance
->instancet
->issue_dcmd(instance
, cmd
);
961 ret
= wait_event_timeout(instance
->int_cmd_wait_q
,
962 cmd
->cmd_status
!= ENODATA
, timeout
* HZ
);
966 wait_event(instance
->int_cmd_wait_q
,
967 cmd
->cmd_status
!= ENODATA
);
973 * megasas_issue_blocked_abort_cmd - Aborts previously issued cmd
974 * @instance: Adapter soft state
975 * @cmd_to_abort: Previously issued cmd to be aborted
976 * @timeout: Timeout in seconds
978 * MFI firmware can abort previously issued AEN comamnd (automatic event
979 * notification). The megasas_issue_blocked_abort_cmd() issues such abort
980 * cmd and waits for return status.
981 * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
984 megasas_issue_blocked_abort_cmd(struct megasas_instance
*instance
,
985 struct megasas_cmd
*cmd_to_abort
, int timeout
)
987 struct megasas_cmd
*cmd
;
988 struct megasas_abort_frame
*abort_fr
;
991 cmd
= megasas_get_cmd(instance
);
996 abort_fr
= &cmd
->frame
->abort
;
999 * Prepare and issue the abort frame
1001 abort_fr
->cmd
= MFI_CMD_ABORT
;
1002 abort_fr
->cmd_status
= 0xFF;
1003 abort_fr
->flags
= cpu_to_le16(0);
1004 abort_fr
->abort_context
= cpu_to_le32(cmd_to_abort
->index
);
1005 abort_fr
->abort_mfi_phys_addr_lo
=
1006 cpu_to_le32(lower_32_bits(cmd_to_abort
->frame_phys_addr
));
1007 abort_fr
->abort_mfi_phys_addr_hi
=
1008 cpu_to_le32(upper_32_bits(cmd_to_abort
->frame_phys_addr
));
1011 cmd
->cmd_status
= 0xFF;
1013 instance
->instancet
->issue_dcmd(instance
, cmd
);
1016 ret
= wait_event_timeout(instance
->abort_cmd_wait_q
,
1017 cmd
->cmd_status
!= ENODATA
, timeout
* HZ
);
1019 dev_err(&instance
->pdev
->dev
, "Command timedout"
1020 "from %s\n", __func__
);
1024 wait_event(instance
->abort_cmd_wait_q
,
1025 cmd
->cmd_status
!= ENODATA
);
1029 megasas_return_cmd(instance
, cmd
);
1034 * megasas_make_sgl32 - Prepares 32-bit SGL
1035 * @instance: Adapter soft state
1036 * @scp: SCSI command from the mid-layer
1037 * @mfi_sgl: SGL to be filled in
1039 * If successful, this function returns the number of SG elements. Otherwise,
1043 megasas_make_sgl32(struct megasas_instance
*instance
, struct scsi_cmnd
*scp
,
1044 union megasas_sgl
*mfi_sgl
)
1048 struct scatterlist
*os_sgl
;
1050 sge_count
= scsi_dma_map(scp
);
1051 BUG_ON(sge_count
< 0);
1054 scsi_for_each_sg(scp
, os_sgl
, sge_count
, i
) {
1055 mfi_sgl
->sge32
[i
].length
= cpu_to_le32(sg_dma_len(os_sgl
));
1056 mfi_sgl
->sge32
[i
].phys_addr
= cpu_to_le32(sg_dma_address(os_sgl
));
1063 * megasas_make_sgl64 - Prepares 64-bit SGL
1064 * @instance: Adapter soft state
1065 * @scp: SCSI command from the mid-layer
1066 * @mfi_sgl: SGL to be filled in
1068 * If successful, this function returns the number of SG elements. Otherwise,
1072 megasas_make_sgl64(struct megasas_instance
*instance
, struct scsi_cmnd
*scp
,
1073 union megasas_sgl
*mfi_sgl
)
1077 struct scatterlist
*os_sgl
;
1079 sge_count
= scsi_dma_map(scp
);
1080 BUG_ON(sge_count
< 0);
1083 scsi_for_each_sg(scp
, os_sgl
, sge_count
, i
) {
1084 mfi_sgl
->sge64
[i
].length
= cpu_to_le32(sg_dma_len(os_sgl
));
1085 mfi_sgl
->sge64
[i
].phys_addr
= cpu_to_le64(sg_dma_address(os_sgl
));
1092 * megasas_make_sgl_skinny - Prepares IEEE SGL
1093 * @instance: Adapter soft state
1094 * @scp: SCSI command from the mid-layer
1095 * @mfi_sgl: SGL to be filled in
1097 * If successful, this function returns the number of SG elements. Otherwise,
1101 megasas_make_sgl_skinny(struct megasas_instance
*instance
,
1102 struct scsi_cmnd
*scp
, union megasas_sgl
*mfi_sgl
)
1106 struct scatterlist
*os_sgl
;
1108 sge_count
= scsi_dma_map(scp
);
1111 scsi_for_each_sg(scp
, os_sgl
, sge_count
, i
) {
1112 mfi_sgl
->sge_skinny
[i
].length
=
1113 cpu_to_le32(sg_dma_len(os_sgl
));
1114 mfi_sgl
->sge_skinny
[i
].phys_addr
=
1115 cpu_to_le64(sg_dma_address(os_sgl
));
1116 mfi_sgl
->sge_skinny
[i
].flag
= cpu_to_le32(0);
1123 * megasas_get_frame_count - Computes the number of frames
1124 * @frame_type : type of frame- io or pthru frame
1125 * @sge_count : number of sg elements
1127 * Returns the number of frames required for numnber of sge's (sge_count)
1130 static u32
megasas_get_frame_count(struct megasas_instance
*instance
,
1131 u8 sge_count
, u8 frame_type
)
1138 sge_sz
= (IS_DMA64
) ? sizeof(struct megasas_sge64
) :
1139 sizeof(struct megasas_sge32
);
1141 if (instance
->flag_ieee
) {
1142 sge_sz
= sizeof(struct megasas_sge_skinny
);
1146 * Main frame can contain 2 SGEs for 64-bit SGLs and
1147 * 3 SGEs for 32-bit SGLs for ldio &
1148 * 1 SGEs for 64-bit SGLs and
1149 * 2 SGEs for 32-bit SGLs for pthru frame
1151 if (unlikely(frame_type
== PTHRU_FRAME
)) {
1152 if (instance
->flag_ieee
== 1) {
1153 num_cnt
= sge_count
- 1;
1154 } else if (IS_DMA64
)
1155 num_cnt
= sge_count
- 1;
1157 num_cnt
= sge_count
- 2;
1159 if (instance
->flag_ieee
== 1) {
1160 num_cnt
= sge_count
- 1;
1161 } else if (IS_DMA64
)
1162 num_cnt
= sge_count
- 2;
1164 num_cnt
= sge_count
- 3;
1168 sge_bytes
= sge_sz
* num_cnt
;
1170 frame_count
= (sge_bytes
/ MEGAMFI_FRAME_SIZE
) +
1171 ((sge_bytes
% MEGAMFI_FRAME_SIZE
) ? 1 : 0) ;
1176 if (frame_count
> 7)
1182 * megasas_build_dcdb - Prepares a direct cdb (DCDB) command
1183 * @instance: Adapter soft state
1184 * @scp: SCSI command
1185 * @cmd: Command to be prepared in
1187 * This function prepares CDB commands. These are typcially pass-through
1188 * commands to the devices.
1191 megasas_build_dcdb(struct megasas_instance
*instance
, struct scsi_cmnd
*scp
,
1192 struct megasas_cmd
*cmd
)
1197 struct megasas_pthru_frame
*pthru
;
1199 is_logical
= MEGASAS_IS_LOGICAL(scp
);
1200 device_id
= MEGASAS_DEV_INDEX(instance
, scp
);
1201 pthru
= (struct megasas_pthru_frame
*)cmd
->frame
;
1203 if (scp
->sc_data_direction
== PCI_DMA_TODEVICE
)
1204 flags
= MFI_FRAME_DIR_WRITE
;
1205 else if (scp
->sc_data_direction
== PCI_DMA_FROMDEVICE
)
1206 flags
= MFI_FRAME_DIR_READ
;
1207 else if (scp
->sc_data_direction
== PCI_DMA_NONE
)
1208 flags
= MFI_FRAME_DIR_NONE
;
1210 if (instance
->flag_ieee
== 1) {
1211 flags
|= MFI_FRAME_IEEE
;
1215 * Prepare the DCDB frame
1217 pthru
->cmd
= (is_logical
) ? MFI_CMD_LD_SCSI_IO
: MFI_CMD_PD_SCSI_IO
;
1218 pthru
->cmd_status
= 0x0;
1219 pthru
->scsi_status
= 0x0;
1220 pthru
->target_id
= device_id
;
1221 pthru
->lun
= scp
->device
->lun
;
1222 pthru
->cdb_len
= scp
->cmd_len
;
1225 pthru
->flags
= cpu_to_le16(flags
);
1226 pthru
->data_xfer_len
= cpu_to_le32(scsi_bufflen(scp
));
1228 memcpy(pthru
->cdb
, scp
->cmnd
, scp
->cmd_len
);
1231 * If the command is for the tape device, set the
1232 * pthru timeout to the os layer timeout value.
1234 if (scp
->device
->type
== TYPE_TAPE
) {
1235 if ((scp
->request
->timeout
/ HZ
) > 0xFFFF)
1236 pthru
->timeout
= 0xFFFF;
1238 pthru
->timeout
= cpu_to_le16(scp
->request
->timeout
/ HZ
);
1244 if (instance
->flag_ieee
== 1) {
1245 pthru
->flags
|= cpu_to_le16(MFI_FRAME_SGL64
);
1246 pthru
->sge_count
= megasas_make_sgl_skinny(instance
, scp
,
1248 } else if (IS_DMA64
) {
1249 pthru
->flags
|= cpu_to_le16(MFI_FRAME_SGL64
);
1250 pthru
->sge_count
= megasas_make_sgl64(instance
, scp
,
1253 pthru
->sge_count
= megasas_make_sgl32(instance
, scp
,
1256 if (pthru
->sge_count
> instance
->max_num_sge
) {
1257 printk(KERN_ERR
"megasas: DCDB two many SGE NUM=%x\n",
1263 * Sense info specific
1265 pthru
->sense_len
= SCSI_SENSE_BUFFERSIZE
;
1266 pthru
->sense_buf_phys_addr_hi
=
1267 cpu_to_le32(upper_32_bits(cmd
->sense_phys_addr
));
1268 pthru
->sense_buf_phys_addr_lo
=
1269 cpu_to_le32(lower_32_bits(cmd
->sense_phys_addr
));
1272 * Compute the total number of frames this command consumes. FW uses
1273 * this number to pull sufficient number of frames from host memory.
1275 cmd
->frame_count
= megasas_get_frame_count(instance
, pthru
->sge_count
,
1278 return cmd
->frame_count
;
1282 * megasas_build_ldio - Prepares IOs to logical devices
1283 * @instance: Adapter soft state
1284 * @scp: SCSI command
1285 * @cmd: Command to be prepared
1287 * Frames (and accompanying SGLs) for regular SCSI IOs use this function.
1290 megasas_build_ldio(struct megasas_instance
*instance
, struct scsi_cmnd
*scp
,
1291 struct megasas_cmd
*cmd
)
1294 u8 sc
= scp
->cmnd
[0];
1296 struct megasas_io_frame
*ldio
;
1298 device_id
= MEGASAS_DEV_INDEX(instance
, scp
);
1299 ldio
= (struct megasas_io_frame
*)cmd
->frame
;
1301 if (scp
->sc_data_direction
== PCI_DMA_TODEVICE
)
1302 flags
= MFI_FRAME_DIR_WRITE
;
1303 else if (scp
->sc_data_direction
== PCI_DMA_FROMDEVICE
)
1304 flags
= MFI_FRAME_DIR_READ
;
1306 if (instance
->flag_ieee
== 1) {
1307 flags
|= MFI_FRAME_IEEE
;
1311 * Prepare the Logical IO frame: 2nd bit is zero for all read cmds
1313 ldio
->cmd
= (sc
& 0x02) ? MFI_CMD_LD_WRITE
: MFI_CMD_LD_READ
;
1314 ldio
->cmd_status
= 0x0;
1315 ldio
->scsi_status
= 0x0;
1316 ldio
->target_id
= device_id
;
1318 ldio
->reserved_0
= 0;
1320 ldio
->flags
= cpu_to_le16(flags
);
1321 ldio
->start_lba_hi
= 0;
1322 ldio
->access_byte
= (scp
->cmd_len
!= 6) ? scp
->cmnd
[1] : 0;
1325 * 6-byte READ(0x08) or WRITE(0x0A) cdb
1327 if (scp
->cmd_len
== 6) {
1328 ldio
->lba_count
= cpu_to_le32((u32
) scp
->cmnd
[4]);
1329 ldio
->start_lba_lo
= cpu_to_le32(((u32
) scp
->cmnd
[1] << 16) |
1330 ((u32
) scp
->cmnd
[2] << 8) |
1331 (u32
) scp
->cmnd
[3]);
1333 ldio
->start_lba_lo
&= cpu_to_le32(0x1FFFFF);
1337 * 10-byte READ(0x28) or WRITE(0x2A) cdb
1339 else if (scp
->cmd_len
== 10) {
1340 ldio
->lba_count
= cpu_to_le32((u32
) scp
->cmnd
[8] |
1341 ((u32
) scp
->cmnd
[7] << 8));
1342 ldio
->start_lba_lo
= cpu_to_le32(((u32
) scp
->cmnd
[2] << 24) |
1343 ((u32
) scp
->cmnd
[3] << 16) |
1344 ((u32
) scp
->cmnd
[4] << 8) |
1345 (u32
) scp
->cmnd
[5]);
1349 * 12-byte READ(0xA8) or WRITE(0xAA) cdb
1351 else if (scp
->cmd_len
== 12) {
1352 ldio
->lba_count
= cpu_to_le32(((u32
) scp
->cmnd
[6] << 24) |
1353 ((u32
) scp
->cmnd
[7] << 16) |
1354 ((u32
) scp
->cmnd
[8] << 8) |
1355 (u32
) scp
->cmnd
[9]);
1357 ldio
->start_lba_lo
= cpu_to_le32(((u32
) scp
->cmnd
[2] << 24) |
1358 ((u32
) scp
->cmnd
[3] << 16) |
1359 ((u32
) scp
->cmnd
[4] << 8) |
1360 (u32
) scp
->cmnd
[5]);
1364 * 16-byte READ(0x88) or WRITE(0x8A) cdb
1366 else if (scp
->cmd_len
== 16) {
1367 ldio
->lba_count
= cpu_to_le32(((u32
) scp
->cmnd
[10] << 24) |
1368 ((u32
) scp
->cmnd
[11] << 16) |
1369 ((u32
) scp
->cmnd
[12] << 8) |
1370 (u32
) scp
->cmnd
[13]);
1372 ldio
->start_lba_lo
= cpu_to_le32(((u32
) scp
->cmnd
[6] << 24) |
1373 ((u32
) scp
->cmnd
[7] << 16) |
1374 ((u32
) scp
->cmnd
[8] << 8) |
1375 (u32
) scp
->cmnd
[9]);
1377 ldio
->start_lba_hi
= cpu_to_le32(((u32
) scp
->cmnd
[2] << 24) |
1378 ((u32
) scp
->cmnd
[3] << 16) |
1379 ((u32
) scp
->cmnd
[4] << 8) |
1380 (u32
) scp
->cmnd
[5]);
1387 if (instance
->flag_ieee
) {
1388 ldio
->flags
|= cpu_to_le16(MFI_FRAME_SGL64
);
1389 ldio
->sge_count
= megasas_make_sgl_skinny(instance
, scp
,
1391 } else if (IS_DMA64
) {
1392 ldio
->flags
|= cpu_to_le16(MFI_FRAME_SGL64
);
1393 ldio
->sge_count
= megasas_make_sgl64(instance
, scp
, &ldio
->sgl
);
1395 ldio
->sge_count
= megasas_make_sgl32(instance
, scp
, &ldio
->sgl
);
1397 if (ldio
->sge_count
> instance
->max_num_sge
) {
1398 printk(KERN_ERR
"megasas: build_ld_io: sge_count = %x\n",
1404 * Sense info specific
1406 ldio
->sense_len
= SCSI_SENSE_BUFFERSIZE
;
1407 ldio
->sense_buf_phys_addr_hi
= 0;
1408 ldio
->sense_buf_phys_addr_lo
= cpu_to_le32(cmd
->sense_phys_addr
);
1411 * Compute the total number of frames this command consumes. FW uses
1412 * this number to pull sufficient number of frames from host memory.
1414 cmd
->frame_count
= megasas_get_frame_count(instance
,
1415 ldio
->sge_count
, IO_FRAME
);
1417 return cmd
->frame_count
;
1421 * megasas_is_ldio - Checks if the cmd is for logical drive
1422 * @scmd: SCSI command
1424 * Called by megasas_queue_command to find out if the command to be queued
1425 * is a logical drive command
1427 inline int megasas_is_ldio(struct scsi_cmnd
*cmd
)
1429 if (!MEGASAS_IS_LOGICAL(cmd
))
1431 switch (cmd
->cmnd
[0]) {
1447 * megasas_dump_pending_frames - Dumps the frame address of all pending cmds
1449 * @instance: Adapter soft state
1452 megasas_dump_pending_frames(struct megasas_instance
*instance
)
1454 struct megasas_cmd
*cmd
;
1456 union megasas_sgl
*mfi_sgl
;
1457 struct megasas_io_frame
*ldio
;
1458 struct megasas_pthru_frame
*pthru
;
1460 u32 max_cmd
= instance
->max_fw_cmds
;
1462 printk(KERN_ERR
"\nmegasas[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance
->host
->host_no
);
1463 printk(KERN_ERR
"megasas[%d]: Total OS Pending cmds : %d\n",instance
->host
->host_no
,atomic_read(&instance
->fw_outstanding
));
1465 printk(KERN_ERR
"\nmegasas[%d]: 64 bit SGLs were sent to FW\n",instance
->host
->host_no
);
1467 printk(KERN_ERR
"\nmegasas[%d]: 32 bit SGLs were sent to FW\n",instance
->host
->host_no
);
1469 printk(KERN_ERR
"megasas[%d]: Pending OS cmds in FW : \n",instance
->host
->host_no
);
1470 for (i
= 0; i
< max_cmd
; i
++) {
1471 cmd
= instance
->cmd_list
[i
];
1474 printk(KERN_ERR
"megasas[%d]: Frame addr :0x%08lx : ",instance
->host
->host_no
,(unsigned long)cmd
->frame_phys_addr
);
1475 if (megasas_is_ldio(cmd
->scmd
)){
1476 ldio
= (struct megasas_io_frame
*)cmd
->frame
;
1477 mfi_sgl
= &ldio
->sgl
;
1478 sgcount
= ldio
->sge_count
;
1479 printk(KERN_ERR
"megasas[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x,"
1480 " lba lo : 0x%x, lba_hi : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",
1481 instance
->host
->host_no
, cmd
->frame_count
, ldio
->cmd
, ldio
->target_id
,
1482 le32_to_cpu(ldio
->start_lba_lo
), le32_to_cpu(ldio
->start_lba_hi
),
1483 le32_to_cpu(ldio
->sense_buf_phys_addr_lo
), sgcount
);
1486 pthru
= (struct megasas_pthru_frame
*) cmd
->frame
;
1487 mfi_sgl
= &pthru
->sgl
;
1488 sgcount
= pthru
->sge_count
;
1489 printk(KERN_ERR
"megasas[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x, "
1490 "lun : 0x%x, cdb_len : 0x%x, data xfer len : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",
1491 instance
->host
->host_no
, cmd
->frame_count
, pthru
->cmd
, pthru
->target_id
,
1492 pthru
->lun
, pthru
->cdb_len
, le32_to_cpu(pthru
->data_xfer_len
),
1493 le32_to_cpu(pthru
->sense_buf_phys_addr_lo
), sgcount
);
1495 if(megasas_dbg_lvl
& MEGASAS_DBG_LVL
){
1496 for (n
= 0; n
< sgcount
; n
++){
1498 printk(KERN_ERR
"megasas: sgl len : 0x%x, sgl addr : 0x%llx ",
1499 le32_to_cpu(mfi_sgl
->sge64
[n
].length
),
1500 le64_to_cpu(mfi_sgl
->sge64
[n
].phys_addr
));
1502 printk(KERN_ERR
"megasas: sgl len : 0x%x, sgl addr : 0x%x ",
1503 le32_to_cpu(mfi_sgl
->sge32
[n
].length
),
1504 le32_to_cpu(mfi_sgl
->sge32
[n
].phys_addr
));
1507 printk(KERN_ERR
"\n");
1509 printk(KERN_ERR
"\nmegasas[%d]: Pending Internal cmds in FW : \n",instance
->host
->host_no
);
1510 for (i
= 0; i
< max_cmd
; i
++) {
1512 cmd
= instance
->cmd_list
[i
];
1514 if(cmd
->sync_cmd
== 1){
1515 printk(KERN_ERR
"0x%08lx : ", (unsigned long)cmd
->frame_phys_addr
);
1518 printk(KERN_ERR
"megasas[%d]: Dumping Done.\n\n",instance
->host
->host_no
);
1522 megasas_build_and_issue_cmd(struct megasas_instance
*instance
,
1523 struct scsi_cmnd
*scmd
)
1525 struct megasas_cmd
*cmd
;
1528 cmd
= megasas_get_cmd(instance
);
1530 return SCSI_MLQUEUE_HOST_BUSY
;
1533 * Logical drive command
1535 if (megasas_is_ldio(scmd
))
1536 frame_count
= megasas_build_ldio(instance
, scmd
, cmd
);
1538 frame_count
= megasas_build_dcdb(instance
, scmd
, cmd
);
1541 goto out_return_cmd
;
1544 scmd
->SCp
.ptr
= (char *)cmd
;
1547 * Issue the command to the FW
1549 atomic_inc(&instance
->fw_outstanding
);
1551 instance
->instancet
->fire_cmd(instance
, cmd
->frame_phys_addr
,
1552 cmd
->frame_count
-1, instance
->reg_set
);
1556 megasas_return_cmd(instance
, cmd
);
1562 * megasas_queue_command - Queue entry point
1563 * @scmd: SCSI command to be queued
1564 * @done: Callback entry point
1567 megasas_queue_command(struct Scsi_Host
*shost
, struct scsi_cmnd
*scmd
)
1569 struct megasas_instance
*instance
;
1570 unsigned long flags
;
1572 instance
= (struct megasas_instance
*)
1573 scmd
->device
->host
->hostdata
;
1575 if (instance
->issuepend_done
== 0)
1576 return SCSI_MLQUEUE_HOST_BUSY
;
1578 spin_lock_irqsave(&instance
->hba_lock
, flags
);
1580 /* Check for an mpio path and adjust behavior */
1581 if (instance
->adprecovery
== MEGASAS_ADPRESET_SM_INFAULT
) {
1582 if (megasas_check_mpio_paths(instance
, scmd
) ==
1583 (DID_RESET
<< 16)) {
1584 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
1585 return SCSI_MLQUEUE_HOST_BUSY
;
1587 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
1588 scmd
->result
= DID_NO_CONNECT
<< 16;
1589 scmd
->scsi_done(scmd
);
1594 if (instance
->adprecovery
== MEGASAS_HW_CRITICAL_ERROR
) {
1595 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
1596 scmd
->result
= DID_NO_CONNECT
<< 16;
1597 scmd
->scsi_done(scmd
);
1601 if (instance
->adprecovery
!= MEGASAS_HBA_OPERATIONAL
) {
1602 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
1603 return SCSI_MLQUEUE_HOST_BUSY
;
1606 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
1610 if (MEGASAS_IS_LOGICAL(scmd
) &&
1611 (scmd
->device
->id
>= instance
->fw_supported_vd_count
||
1612 scmd
->device
->lun
)) {
1613 scmd
->result
= DID_BAD_TARGET
<< 16;
1617 switch (scmd
->cmnd
[0]) {
1618 case SYNCHRONIZE_CACHE
:
1620 * FW takes care of flush cache on its own
1621 * No need to send it down
1623 scmd
->result
= DID_OK
<< 16;
1629 if (instance
->instancet
->build_and_issue_cmd(instance
, scmd
)) {
1630 printk(KERN_ERR
"megasas: Err returned from build_and_issue_cmd\n");
1631 return SCSI_MLQUEUE_HOST_BUSY
;
1637 scmd
->scsi_done(scmd
);
1641 static struct megasas_instance
*megasas_lookup_instance(u16 host_no
)
1645 for (i
= 0; i
< megasas_mgmt_info
.max_index
; i
++) {
1647 if ((megasas_mgmt_info
.instance
[i
]) &&
1648 (megasas_mgmt_info
.instance
[i
]->host
->host_no
== host_no
))
1649 return megasas_mgmt_info
.instance
[i
];
1655 static int megasas_slave_configure(struct scsi_device
*sdev
)
1658 * The RAID firmware may require extended timeouts.
1660 blk_queue_rq_timeout(sdev
->request_queue
,
1661 MEGASAS_DEFAULT_CMD_TIMEOUT
* HZ
);
1666 static int megasas_slave_alloc(struct scsi_device
*sdev
)
1669 struct megasas_instance
*instance
;
1670 instance
= megasas_lookup_instance(sdev
->host
->host_no
);
1671 if (sdev
->channel
< MEGASAS_MAX_PD_CHANNELS
) {
1673 * Open the OS scan to the SYSTEM PD
1676 (sdev
->channel
* MEGASAS_MAX_DEV_PER_CHANNEL
) +
1678 if (instance
->pd_list
[pd_index
].driveState
==
1679 MR_PD_STATE_SYSTEM
) {
1687 void megaraid_sas_kill_hba(struct megasas_instance
*instance
)
1689 if ((instance
->pdev
->device
== PCI_DEVICE_ID_LSI_SAS0073SKINNY
) ||
1690 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_SAS0071SKINNY
) ||
1691 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_FUSION
) ||
1692 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_PLASMA
) ||
1693 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_INVADER
) ||
1694 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_FURY
)) {
1695 writel(MFI_STOP_ADP
, &instance
->reg_set
->doorbell
);
1697 readl(&instance
->reg_set
->doorbell
);
1698 if (instance
->mpio
&& instance
->requestorId
)
1699 memset(instance
->ld_ids
, 0xff, MEGASAS_MAX_LD_IDS
);
1701 writel(MFI_STOP_ADP
, &instance
->reg_set
->inbound_doorbell
);
1706 * megasas_check_and_restore_queue_depth - Check if queue depth needs to be
1707 * restored to max value
1708 * @instance: Adapter soft state
1712 megasas_check_and_restore_queue_depth(struct megasas_instance
*instance
)
1714 unsigned long flags
;
1715 if (instance
->flag
& MEGASAS_FW_BUSY
1716 && time_after(jiffies
, instance
->last_time
+ 5 * HZ
)
1717 && atomic_read(&instance
->fw_outstanding
) <
1718 instance
->throttlequeuedepth
+ 1) {
1720 spin_lock_irqsave(instance
->host
->host_lock
, flags
);
1721 instance
->flag
&= ~MEGASAS_FW_BUSY
;
1722 if (instance
->is_imr
) {
1723 instance
->host
->can_queue
=
1724 instance
->max_fw_cmds
- MEGASAS_SKINNY_INT_CMDS
;
1726 instance
->host
->can_queue
=
1727 instance
->max_fw_cmds
- MEGASAS_INT_CMDS
;
1729 spin_unlock_irqrestore(instance
->host
->host_lock
, flags
);
1734 * megasas_complete_cmd_dpc - Returns FW's controller structure
1735 * @instance_addr: Address of adapter soft state
1737 * Tasklet to complete cmds
1739 static void megasas_complete_cmd_dpc(unsigned long instance_addr
)
1744 struct megasas_cmd
*cmd
;
1745 struct megasas_instance
*instance
=
1746 (struct megasas_instance
*)instance_addr
;
1747 unsigned long flags
;
1749 /* If we have already declared adapter dead, donot complete cmds */
1750 if (instance
->adprecovery
== MEGASAS_HW_CRITICAL_ERROR
)
1753 spin_lock_irqsave(&instance
->completion_lock
, flags
);
1755 producer
= le32_to_cpu(*instance
->producer
);
1756 consumer
= le32_to_cpu(*instance
->consumer
);
1758 while (consumer
!= producer
) {
1759 context
= le32_to_cpu(instance
->reply_queue
[consumer
]);
1760 if (context
>= instance
->max_fw_cmds
) {
1761 printk(KERN_ERR
"Unexpected context value %x\n",
1766 cmd
= instance
->cmd_list
[context
];
1768 megasas_complete_cmd(instance
, cmd
, DID_OK
);
1771 if (consumer
== (instance
->max_fw_cmds
+ 1)) {
1776 *instance
->consumer
= cpu_to_le32(producer
);
1778 spin_unlock_irqrestore(&instance
->completion_lock
, flags
);
1781 * Check if we can restore can_queue
1783 megasas_check_and_restore_queue_depth(instance
);
1787 * megasas_start_timer - Initializes a timer object
1788 * @instance: Adapter soft state
1789 * @timer: timer object to be initialized
1790 * @fn: timer function
1791 * @interval: time interval between timer function call
1794 void megasas_start_timer(struct megasas_instance
*instance
,
1795 struct timer_list
*timer
,
1796 void *fn
, unsigned long interval
)
1799 timer
->expires
= jiffies
+ interval
;
1800 timer
->data
= (unsigned long)instance
;
1801 timer
->function
= fn
;
1806 megasas_internal_reset_defer_cmds(struct megasas_instance
*instance
);
1809 process_fw_state_change_wq(struct work_struct
*work
);
1811 void megasas_do_ocr(struct megasas_instance
*instance
)
1813 if ((instance
->pdev
->device
== PCI_DEVICE_ID_LSI_SAS1064R
) ||
1814 (instance
->pdev
->device
== PCI_DEVICE_ID_DELL_PERC5
) ||
1815 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_VERDE_ZCR
)) {
1816 *instance
->consumer
= cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN
);
1818 instance
->instancet
->disable_intr(instance
);
1819 instance
->adprecovery
= MEGASAS_ADPRESET_SM_INFAULT
;
1820 instance
->issuepend_done
= 0;
1822 atomic_set(&instance
->fw_outstanding
, 0);
1823 megasas_internal_reset_defer_cmds(instance
);
1824 process_fw_state_change_wq(&instance
->work_init
);
1827 static int megasas_get_ld_vf_affiliation_111(struct megasas_instance
*instance
,
1830 struct megasas_cmd
*cmd
;
1831 struct megasas_dcmd_frame
*dcmd
;
1832 struct MR_LD_VF_AFFILIATION_111
*new_affiliation_111
= NULL
;
1833 dma_addr_t new_affiliation_111_h
;
1837 cmd
= megasas_get_cmd(instance
);
1840 printk(KERN_DEBUG
"megasas: megasas_get_ld_vf_affiliation_111:"
1841 "Failed to get cmd for scsi%d.\n",
1842 instance
->host
->host_no
);
1846 dcmd
= &cmd
->frame
->dcmd
;
1848 if (!instance
->vf_affiliation_111
) {
1849 printk(KERN_WARNING
"megasas: SR-IOV: Couldn't get LD/VF "
1850 "affiliation for scsi%d.\n", instance
->host
->host_no
);
1851 megasas_return_cmd(instance
, cmd
);
1856 memset(instance
->vf_affiliation_111
, 0,
1857 sizeof(struct MR_LD_VF_AFFILIATION_111
));
1859 new_affiliation_111
=
1860 pci_alloc_consistent(instance
->pdev
,
1861 sizeof(struct MR_LD_VF_AFFILIATION_111
),
1862 &new_affiliation_111_h
);
1863 if (!new_affiliation_111
) {
1864 printk(KERN_DEBUG
"megasas: SR-IOV: Couldn't allocate "
1865 "memory for new affiliation for scsi%d.\n",
1866 instance
->host
->host_no
);
1867 megasas_return_cmd(instance
, cmd
);
1870 memset(new_affiliation_111
, 0,
1871 sizeof(struct MR_LD_VF_AFFILIATION_111
));
1874 memset(dcmd
->mbox
.b
, 0, MFI_MBOX_SIZE
);
1876 dcmd
->cmd
= MFI_CMD_DCMD
;
1877 dcmd
->cmd_status
= 0xFF;
1878 dcmd
->sge_count
= 1;
1879 dcmd
->flags
= MFI_FRAME_DIR_BOTH
;
1882 dcmd
->data_xfer_len
= sizeof(struct MR_LD_VF_AFFILIATION_111
);
1883 dcmd
->opcode
= MR_DCMD_LD_VF_MAP_GET_ALL_LDS_111
;
1886 dcmd
->sgl
.sge32
[0].phys_addr
=
1887 instance
->vf_affiliation_111_h
;
1889 dcmd
->sgl
.sge32
[0].phys_addr
= new_affiliation_111_h
;
1891 dcmd
->sgl
.sge32
[0].length
=
1892 sizeof(struct MR_LD_VF_AFFILIATION_111
);
1894 printk(KERN_WARNING
"megasas: SR-IOV: Getting LD/VF affiliation for "
1895 "scsi%d\n", instance
->host
->host_no
);
1897 megasas_issue_blocked_cmd(instance
, cmd
, 0);
1899 if (dcmd
->cmd_status
) {
1900 printk(KERN_WARNING
"megasas: SR-IOV: LD/VF affiliation DCMD"
1901 " failed with status 0x%x for scsi%d.\n",
1902 dcmd
->cmd_status
, instance
->host
->host_no
);
1903 retval
= 1; /* Do a scan if we couldn't get affiliation */
1908 thisVf
= new_affiliation_111
->thisVf
;
1909 for (ld
= 0 ; ld
< new_affiliation_111
->vdCount
; ld
++)
1910 if (instance
->vf_affiliation_111
->map
[ld
].policy
[thisVf
] !=
1911 new_affiliation_111
->map
[ld
].policy
[thisVf
]) {
1912 printk(KERN_WARNING
"megasas: SR-IOV: "
1913 "Got new LD/VF affiliation "
1915 instance
->host
->host_no
);
1916 memcpy(instance
->vf_affiliation_111
,
1917 new_affiliation_111
,
1918 sizeof(struct MR_LD_VF_AFFILIATION_111
));
1924 if (new_affiliation_111
) {
1925 pci_free_consistent(instance
->pdev
,
1926 sizeof(struct MR_LD_VF_AFFILIATION_111
),
1927 new_affiliation_111
,
1928 new_affiliation_111_h
);
1931 if (instance
->ctrl_context
&& cmd
->mpt_pthr_cmd_blocked
)
1932 megasas_return_mfi_mpt_pthr(instance
, cmd
,
1933 cmd
->mpt_pthr_cmd_blocked
);
1935 megasas_return_cmd(instance
, cmd
);
1940 static int megasas_get_ld_vf_affiliation_12(struct megasas_instance
*instance
,
1943 struct megasas_cmd
*cmd
;
1944 struct megasas_dcmd_frame
*dcmd
;
1945 struct MR_LD_VF_AFFILIATION
*new_affiliation
= NULL
;
1946 struct MR_LD_VF_MAP
*newmap
= NULL
, *savedmap
= NULL
;
1947 dma_addr_t new_affiliation_h
;
1948 int i
, j
, retval
= 0, found
= 0, doscan
= 0;
1951 cmd
= megasas_get_cmd(instance
);
1954 printk(KERN_DEBUG
"megasas: megasas_get_ld_vf_affiliation12: "
1955 "Failed to get cmd for scsi%d.\n",
1956 instance
->host
->host_no
);
1960 dcmd
= &cmd
->frame
->dcmd
;
1962 if (!instance
->vf_affiliation
) {
1963 printk(KERN_WARNING
"megasas: SR-IOV: Couldn't get LD/VF "
1964 "affiliation for scsi%d.\n", instance
->host
->host_no
);
1965 megasas_return_cmd(instance
, cmd
);
1970 memset(instance
->vf_affiliation
, 0, (MAX_LOGICAL_DRIVES
+ 1) *
1971 sizeof(struct MR_LD_VF_AFFILIATION
));
1974 pci_alloc_consistent(instance
->pdev
,
1975 (MAX_LOGICAL_DRIVES
+ 1) *
1976 sizeof(struct MR_LD_VF_AFFILIATION
),
1977 &new_affiliation_h
);
1978 if (!new_affiliation
) {
1979 printk(KERN_DEBUG
"megasas: SR-IOV: Couldn't allocate "
1980 "memory for new affiliation for scsi%d.\n",
1981 instance
->host
->host_no
);
1982 megasas_return_cmd(instance
, cmd
);
1985 memset(new_affiliation
, 0, (MAX_LOGICAL_DRIVES
+ 1) *
1986 sizeof(struct MR_LD_VF_AFFILIATION
));
1989 memset(dcmd
->mbox
.b
, 0, MFI_MBOX_SIZE
);
1991 dcmd
->cmd
= MFI_CMD_DCMD
;
1992 dcmd
->cmd_status
= 0xFF;
1993 dcmd
->sge_count
= 1;
1994 dcmd
->flags
= MFI_FRAME_DIR_BOTH
;
1997 dcmd
->data_xfer_len
= (MAX_LOGICAL_DRIVES
+ 1) *
1998 sizeof(struct MR_LD_VF_AFFILIATION
);
1999 dcmd
->opcode
= MR_DCMD_LD_VF_MAP_GET_ALL_LDS
;
2002 dcmd
->sgl
.sge32
[0].phys_addr
= instance
->vf_affiliation_h
;
2004 dcmd
->sgl
.sge32
[0].phys_addr
= new_affiliation_h
;
2006 dcmd
->sgl
.sge32
[0].length
= (MAX_LOGICAL_DRIVES
+ 1) *
2007 sizeof(struct MR_LD_VF_AFFILIATION
);
2009 printk(KERN_WARNING
"megasas: SR-IOV: Getting LD/VF affiliation for "
2010 "scsi%d\n", instance
->host
->host_no
);
2012 megasas_issue_blocked_cmd(instance
, cmd
, 0);
2014 if (dcmd
->cmd_status
) {
2015 printk(KERN_WARNING
"megasas: SR-IOV: LD/VF affiliation DCMD"
2016 " failed with status 0x%x for scsi%d.\n",
2017 dcmd
->cmd_status
, instance
->host
->host_no
);
2018 retval
= 1; /* Do a scan if we couldn't get affiliation */
2023 if (!new_affiliation
->ldCount
) {
2024 printk(KERN_WARNING
"megasas: SR-IOV: Got new LD/VF "
2025 "affiliation for passive path for scsi%d.\n",
2026 instance
->host
->host_no
);
2030 newmap
= new_affiliation
->map
;
2031 savedmap
= instance
->vf_affiliation
->map
;
2032 thisVf
= new_affiliation
->thisVf
;
2033 for (i
= 0 ; i
< new_affiliation
->ldCount
; i
++) {
2035 for (j
= 0; j
< instance
->vf_affiliation
->ldCount
;
2037 if (newmap
->ref
.targetId
==
2038 savedmap
->ref
.targetId
) {
2040 if (newmap
->policy
[thisVf
] !=
2041 savedmap
->policy
[thisVf
]) {
2046 savedmap
= (struct MR_LD_VF_MAP
*)
2047 ((unsigned char *)savedmap
+
2050 if (!found
&& newmap
->policy
[thisVf
] !=
2051 MR_LD_ACCESS_HIDDEN
) {
2055 newmap
= (struct MR_LD_VF_MAP
*)
2056 ((unsigned char *)newmap
+ newmap
->size
);
2059 newmap
= new_affiliation
->map
;
2060 savedmap
= instance
->vf_affiliation
->map
;
2062 for (i
= 0 ; i
< instance
->vf_affiliation
->ldCount
; i
++) {
2064 for (j
= 0 ; j
< new_affiliation
->ldCount
; j
++) {
2065 if (savedmap
->ref
.targetId
==
2066 newmap
->ref
.targetId
) {
2068 if (savedmap
->policy
[thisVf
] !=
2069 newmap
->policy
[thisVf
]) {
2074 newmap
= (struct MR_LD_VF_MAP
*)
2075 ((unsigned char *)newmap
+
2078 if (!found
&& savedmap
->policy
[thisVf
] !=
2079 MR_LD_ACCESS_HIDDEN
) {
2083 savedmap
= (struct MR_LD_VF_MAP
*)
2084 ((unsigned char *)savedmap
+
2090 printk(KERN_WARNING
"megasas: SR-IOV: Got new LD/VF "
2091 "affiliation for scsi%d.\n", instance
->host
->host_no
);
2092 memcpy(instance
->vf_affiliation
, new_affiliation
,
2093 new_affiliation
->size
);
2097 if (new_affiliation
)
2098 pci_free_consistent(instance
->pdev
,
2099 (MAX_LOGICAL_DRIVES
+ 1) *
2100 sizeof(struct MR_LD_VF_AFFILIATION
),
2101 new_affiliation
, new_affiliation_h
);
2102 if (instance
->ctrl_context
&& cmd
->mpt_pthr_cmd_blocked
)
2103 megasas_return_mfi_mpt_pthr(instance
, cmd
,
2104 cmd
->mpt_pthr_cmd_blocked
);
2106 megasas_return_cmd(instance
, cmd
);
2111 /* This function will get the current SR-IOV LD/VF affiliation */
2112 static int megasas_get_ld_vf_affiliation(struct megasas_instance
*instance
,
2117 if (instance
->PlasmaFW111
)
2118 retval
= megasas_get_ld_vf_affiliation_111(instance
, initial
);
2120 retval
= megasas_get_ld_vf_affiliation_12(instance
, initial
);
2124 /* This function will tell FW to start the SR-IOV heartbeat */
2125 int megasas_sriov_start_heartbeat(struct megasas_instance
*instance
,
2128 struct megasas_cmd
*cmd
;
2129 struct megasas_dcmd_frame
*dcmd
;
2132 cmd
= megasas_get_cmd(instance
);
2135 printk(KERN_DEBUG
"megasas: megasas_sriov_start_heartbeat: "
2136 "Failed to get cmd for scsi%d.\n",
2137 instance
->host
->host_no
);
2141 dcmd
= &cmd
->frame
->dcmd
;
2144 instance
->hb_host_mem
=
2145 pci_zalloc_consistent(instance
->pdev
,
2146 sizeof(struct MR_CTRL_HB_HOST_MEM
),
2147 &instance
->hb_host_mem_h
);
2148 if (!instance
->hb_host_mem
) {
2149 printk(KERN_DEBUG
"megasas: SR-IOV: Couldn't allocate"
2150 " memory for heartbeat host memory for "
2151 "scsi%d.\n", instance
->host
->host_no
);
2157 memset(dcmd
->mbox
.b
, 0, MFI_MBOX_SIZE
);
2159 dcmd
->mbox
.s
[0] = sizeof(struct MR_CTRL_HB_HOST_MEM
);
2160 dcmd
->cmd
= MFI_CMD_DCMD
;
2161 dcmd
->cmd_status
= 0xFF;
2162 dcmd
->sge_count
= 1;
2163 dcmd
->flags
= MFI_FRAME_DIR_BOTH
;
2166 dcmd
->data_xfer_len
= sizeof(struct MR_CTRL_HB_HOST_MEM
);
2167 dcmd
->opcode
= MR_DCMD_CTRL_SHARED_HOST_MEM_ALLOC
;
2168 dcmd
->sgl
.sge32
[0].phys_addr
= instance
->hb_host_mem_h
;
2169 dcmd
->sgl
.sge32
[0].length
= sizeof(struct MR_CTRL_HB_HOST_MEM
);
2171 printk(KERN_WARNING
"megasas: SR-IOV: Starting heartbeat for scsi%d\n",
2172 instance
->host
->host_no
);
2174 if (!megasas_issue_polled(instance
, cmd
)) {
2177 printk(KERN_WARNING
"megasas: SR-IOV: MR_DCMD_CTRL_SHARED_HOST"
2178 "_MEM_ALLOC DCMD timed out for scsi%d\n",
2179 instance
->host
->host_no
);
2185 if (dcmd
->cmd_status
) {
2186 printk(KERN_WARNING
"megasas: SR-IOV: MR_DCMD_CTRL_SHARED_HOST"
2187 "_MEM_ALLOC DCMD failed with status 0x%x for scsi%d\n",
2189 instance
->host
->host_no
);
2195 megasas_return_cmd(instance
, cmd
);
2200 /* Handler for SR-IOV heartbeat */
2201 void megasas_sriov_heartbeat_handler(unsigned long instance_addr
)
2203 struct megasas_instance
*instance
=
2204 (struct megasas_instance
*)instance_addr
;
2206 if (instance
->hb_host_mem
->HB
.fwCounter
!=
2207 instance
->hb_host_mem
->HB
.driverCounter
) {
2208 instance
->hb_host_mem
->HB
.driverCounter
=
2209 instance
->hb_host_mem
->HB
.fwCounter
;
2210 mod_timer(&instance
->sriov_heartbeat_timer
,
2211 jiffies
+ MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF
);
2213 printk(KERN_WARNING
"megasas: SR-IOV: Heartbeat never "
2214 "completed for scsi%d\n", instance
->host
->host_no
);
2215 schedule_work(&instance
->work_init
);
2220 * megasas_wait_for_outstanding - Wait for all outstanding cmds
2221 * @instance: Adapter soft state
2223 * This function waits for up to MEGASAS_RESET_WAIT_TIME seconds for FW to
2224 * complete all its outstanding commands. Returns error if one or more IOs
2225 * are pending after this time period. It also marks the controller dead.
2227 static int megasas_wait_for_outstanding(struct megasas_instance
*instance
)
2231 u32 wait_time
= MEGASAS_RESET_WAIT_TIME
;
2233 unsigned long flags
;
2234 struct list_head clist_local
;
2235 struct megasas_cmd
*reset_cmd
;
2237 u8 kill_adapter_flag
;
2239 spin_lock_irqsave(&instance
->hba_lock
, flags
);
2240 adprecovery
= instance
->adprecovery
;
2241 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
2243 if (adprecovery
!= MEGASAS_HBA_OPERATIONAL
) {
2245 INIT_LIST_HEAD(&clist_local
);
2246 spin_lock_irqsave(&instance
->hba_lock
, flags
);
2247 list_splice_init(&instance
->internal_reset_pending_q
,
2249 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
2251 printk(KERN_NOTICE
"megasas: HBA reset wait ...\n");
2252 for (i
= 0; i
< wait_time
; i
++) {
2254 spin_lock_irqsave(&instance
->hba_lock
, flags
);
2255 adprecovery
= instance
->adprecovery
;
2256 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
2257 if (adprecovery
== MEGASAS_HBA_OPERATIONAL
)
2261 if (adprecovery
!= MEGASAS_HBA_OPERATIONAL
) {
2262 printk(KERN_NOTICE
"megasas: reset: Stopping HBA.\n");
2263 spin_lock_irqsave(&instance
->hba_lock
, flags
);
2264 instance
->adprecovery
= MEGASAS_HW_CRITICAL_ERROR
;
2265 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
2270 while (!list_empty(&clist_local
)) {
2271 reset_cmd
= list_entry((&clist_local
)->next
,
2272 struct megasas_cmd
, list
);
2273 list_del_init(&reset_cmd
->list
);
2274 if (reset_cmd
->scmd
) {
2275 reset_cmd
->scmd
->result
= DID_RESET
<< 16;
2276 printk(KERN_NOTICE
"%d:%p reset [%02x]\n",
2277 reset_index
, reset_cmd
,
2278 reset_cmd
->scmd
->cmnd
[0]);
2280 reset_cmd
->scmd
->scsi_done(reset_cmd
->scmd
);
2281 megasas_return_cmd(instance
, reset_cmd
);
2282 } else if (reset_cmd
->sync_cmd
) {
2283 printk(KERN_NOTICE
"megasas:%p synch cmds"
2287 reset_cmd
->cmd_status
= ENODATA
;
2288 instance
->instancet
->fire_cmd(instance
,
2289 reset_cmd
->frame_phys_addr
,
2290 0, instance
->reg_set
);
2292 printk(KERN_NOTICE
"megasas: %p unexpected"
2302 for (i
= 0; i
< resetwaittime
; i
++) {
2304 int outstanding
= atomic_read(&instance
->fw_outstanding
);
2309 if (!(i
% MEGASAS_RESET_NOTICE_INTERVAL
)) {
2310 printk(KERN_NOTICE
"megasas: [%2d]waiting for %d "
2311 "commands to complete\n",i
,outstanding
);
2313 * Call cmd completion routine. Cmd to be
2314 * be completed directly without depending on isr.
2316 megasas_complete_cmd_dpc((unsigned long)instance
);
2323 kill_adapter_flag
= 0;
2325 fw_state
= instance
->instancet
->read_fw_status_reg(
2326 instance
->reg_set
) & MFI_STATE_MASK
;
2327 if ((fw_state
== MFI_STATE_FAULT
) &&
2328 (instance
->disableOnlineCtrlReset
== 0)) {
2330 kill_adapter_flag
= 2;
2333 megasas_do_ocr(instance
);
2334 kill_adapter_flag
= 1;
2336 /* wait for 1 secs to let FW finish the pending cmds */
2342 if (atomic_read(&instance
->fw_outstanding
) &&
2343 !kill_adapter_flag
) {
2344 if (instance
->disableOnlineCtrlReset
== 0) {
2346 megasas_do_ocr(instance
);
2348 /* wait for 5 secs to let FW finish the pending cmds */
2349 for (i
= 0; i
< wait_time
; i
++) {
2351 atomic_read(&instance
->fw_outstanding
);
2359 if (atomic_read(&instance
->fw_outstanding
) ||
2360 (kill_adapter_flag
== 2)) {
2361 printk(KERN_NOTICE
"megaraid_sas: pending cmds after reset\n");
2363 * Send signal to FW to stop processing any pending cmds.
2364 * The controller will be taken offline by the OS now.
2366 if ((instance
->pdev
->device
==
2367 PCI_DEVICE_ID_LSI_SAS0073SKINNY
) ||
2368 (instance
->pdev
->device
==
2369 PCI_DEVICE_ID_LSI_SAS0071SKINNY
)) {
2370 writel(MFI_STOP_ADP
,
2371 &instance
->reg_set
->doorbell
);
2373 writel(MFI_STOP_ADP
,
2374 &instance
->reg_set
->inbound_doorbell
);
2376 megasas_dump_pending_frames(instance
);
2377 spin_lock_irqsave(&instance
->hba_lock
, flags
);
2378 instance
->adprecovery
= MEGASAS_HW_CRITICAL_ERROR
;
2379 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
2383 printk(KERN_NOTICE
"megaraid_sas: no pending cmds after reset\n");
2389 * megasas_generic_reset - Generic reset routine
2390 * @scmd: Mid-layer SCSI command
2392 * This routine implements a generic reset handler for device, bus and host
2393 * reset requests. Device, bus and host specific reset handlers can use this
2394 * function after they do their specific tasks.
2396 static int megasas_generic_reset(struct scsi_cmnd
*scmd
)
2399 struct megasas_instance
*instance
;
2401 instance
= (struct megasas_instance
*)scmd
->device
->host
->hostdata
;
2403 scmd_printk(KERN_NOTICE
, scmd
, "megasas: RESET cmd=%x retries=%x\n",
2404 scmd
->cmnd
[0], scmd
->retries
);
2406 if (instance
->adprecovery
== MEGASAS_HW_CRITICAL_ERROR
) {
2407 printk(KERN_ERR
"megasas: cannot recover from previous reset "
2412 ret_val
= megasas_wait_for_outstanding(instance
);
2413 if (ret_val
== SUCCESS
)
2414 printk(KERN_NOTICE
"megasas: reset successful \n");
2416 printk(KERN_ERR
"megasas: failed to do reset\n");
2422 * megasas_reset_timer - quiesce the adapter if required
2425 * Sets the FW busy flag and reduces the host->can_queue if the
2426 * cmd has not been completed within the timeout period.
2429 blk_eh_timer_return
megasas_reset_timer(struct scsi_cmnd
*scmd
)
2431 struct megasas_instance
*instance
;
2432 unsigned long flags
;
2434 if (time_after(jiffies
, scmd
->jiffies_at_alloc
+
2435 (MEGASAS_DEFAULT_CMD_TIMEOUT
* 2) * HZ
)) {
2436 return BLK_EH_NOT_HANDLED
;
2439 instance
= (struct megasas_instance
*)scmd
->device
->host
->hostdata
;
2440 if (!(instance
->flag
& MEGASAS_FW_BUSY
)) {
2441 /* FW is busy, throttle IO */
2442 spin_lock_irqsave(instance
->host
->host_lock
, flags
);
2444 instance
->host
->can_queue
= instance
->throttlequeuedepth
;
2445 instance
->last_time
= jiffies
;
2446 instance
->flag
|= MEGASAS_FW_BUSY
;
2448 spin_unlock_irqrestore(instance
->host
->host_lock
, flags
);
2450 return BLK_EH_RESET_TIMER
;
2454 * megasas_reset_device - Device reset handler entry point
2456 static int megasas_reset_device(struct scsi_cmnd
*scmd
)
2461 * First wait for all commands to complete
2463 ret
= megasas_generic_reset(scmd
);
2469 * megasas_reset_bus_host - Bus & host reset handler entry point
2471 static int megasas_reset_bus_host(struct scsi_cmnd
*scmd
)
2474 struct megasas_instance
*instance
;
2475 instance
= (struct megasas_instance
*)scmd
->device
->host
->hostdata
;
2478 * First wait for all commands to complete
2480 if ((instance
->pdev
->device
== PCI_DEVICE_ID_LSI_FUSION
) ||
2481 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_PLASMA
) ||
2482 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_INVADER
) ||
2483 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_FURY
))
2484 ret
= megasas_reset_fusion(scmd
->device
->host
, 1);
2486 ret
= megasas_generic_reset(scmd
);
2492 * megasas_bios_param - Returns disk geometry for a disk
2493 * @sdev: device handle
2494 * @bdev: block device
2495 * @capacity: drive capacity
2496 * @geom: geometry parameters
2499 megasas_bios_param(struct scsi_device
*sdev
, struct block_device
*bdev
,
2500 sector_t capacity
, int geom
[])
2506 /* Default heads (64) & sectors (32) */
2510 tmp
= heads
* sectors
;
2511 cylinders
= capacity
;
2513 sector_div(cylinders
, tmp
);
2516 * Handle extended translation size for logical drives > 1Gb
2519 if (capacity
>= 0x200000) {
2522 tmp
= heads
*sectors
;
2523 cylinders
= capacity
;
2524 sector_div(cylinders
, tmp
);
2529 geom
[2] = cylinders
;
2534 static void megasas_aen_polling(struct work_struct
*work
);
2537 * megasas_service_aen - Processes an event notification
2538 * @instance: Adapter soft state
2539 * @cmd: AEN command completed by the ISR
2541 * For AEN, driver sends a command down to FW that is held by the FW till an
2542 * event occurs. When an event of interest occurs, FW completes the command
2543 * that it was previously holding.
2545 * This routines sends SIGIO signal to processes that have registered with the
2549 megasas_service_aen(struct megasas_instance
*instance
, struct megasas_cmd
*cmd
)
2551 unsigned long flags
;
2553 * Don't signal app if it is just an aborted previously registered aen
2555 if ((!cmd
->abort_aen
) && (instance
->unload
== 0)) {
2556 spin_lock_irqsave(&poll_aen_lock
, flags
);
2557 megasas_poll_wait_aen
= 1;
2558 spin_unlock_irqrestore(&poll_aen_lock
, flags
);
2559 wake_up(&megasas_poll_wait
);
2560 kill_fasync(&megasas_async_queue
, SIGIO
, POLL_IN
);
2565 instance
->aen_cmd
= NULL
;
2567 if (instance
->ctrl_context
&& cmd
->mpt_pthr_cmd_blocked
)
2568 megasas_return_mfi_mpt_pthr(instance
, cmd
,
2569 cmd
->mpt_pthr_cmd_blocked
);
2571 megasas_return_cmd(instance
, cmd
);
2573 if ((instance
->unload
== 0) &&
2574 ((instance
->issuepend_done
== 1))) {
2575 struct megasas_aen_event
*ev
;
2576 ev
= kzalloc(sizeof(*ev
), GFP_ATOMIC
);
2578 printk(KERN_ERR
"megasas_service_aen: out of memory\n");
2580 ev
->instance
= instance
;
2582 INIT_DELAYED_WORK(&ev
->hotplug_work
,
2583 megasas_aen_polling
);
2584 schedule_delayed_work(&ev
->hotplug_work
, 0);
2589 static int megasas_change_queue_depth(struct scsi_device
*sdev
,
2590 int queue_depth
, int reason
)
2592 if (reason
!= SCSI_QDEPTH_DEFAULT
)
2595 if (queue_depth
> sdev
->host
->can_queue
)
2596 queue_depth
= sdev
->host
->can_queue
;
2597 scsi_adjust_queue_depth(sdev
, scsi_get_tag_type(sdev
),
2604 megasas_fw_crash_buffer_store(struct device
*cdev
,
2605 struct device_attribute
*attr
, const char *buf
, size_t count
)
2607 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2608 struct megasas_instance
*instance
=
2609 (struct megasas_instance
*) shost
->hostdata
;
2611 unsigned long flags
;
2613 if (kstrtoint(buf
, 0, &val
) != 0)
2616 spin_lock_irqsave(&instance
->crashdump_lock
, flags
);
2617 instance
->fw_crash_buffer_offset
= val
;
2618 spin_unlock_irqrestore(&instance
->crashdump_lock
, flags
);
2623 megasas_fw_crash_buffer_show(struct device
*cdev
,
2624 struct device_attribute
*attr
, char *buf
)
2626 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2627 struct megasas_instance
*instance
=
2628 (struct megasas_instance
*) shost
->hostdata
;
2630 unsigned long buff_addr
;
2631 unsigned long dmachunk
= CRASH_DMA_BUF_SIZE
;
2632 unsigned long src_addr
;
2633 unsigned long flags
;
2636 spin_lock_irqsave(&instance
->crashdump_lock
, flags
);
2637 buff_offset
= instance
->fw_crash_buffer_offset
;
2638 if (!instance
->crash_dump_buf
&&
2639 !((instance
->fw_crash_state
== AVAILABLE
) ||
2640 (instance
->fw_crash_state
== COPYING
))) {
2641 dev_err(&instance
->pdev
->dev
,
2642 "Firmware crash dump is not available\n");
2643 spin_unlock_irqrestore(&instance
->crashdump_lock
, flags
);
2647 buff_addr
= (unsigned long) buf
;
2650 (instance
->fw_crash_buffer_size
* dmachunk
)) {
2651 dev_err(&instance
->pdev
->dev
,
2652 "Firmware crash dump offset is out of range\n");
2653 spin_unlock_irqrestore(&instance
->crashdump_lock
, flags
);
2657 size
= (instance
->fw_crash_buffer_size
* dmachunk
) - buff_offset
;
2658 size
= (size
>= PAGE_SIZE
) ? (PAGE_SIZE
- 1) : size
;
2660 src_addr
= (unsigned long)instance
->crash_buf
[buff_offset
/ dmachunk
] +
2661 (buff_offset
% dmachunk
);
2662 memcpy(buf
, (void *)src_addr
, size
);
2663 spin_unlock_irqrestore(&instance
->crashdump_lock
, flags
);
2669 megasas_fw_crash_buffer_size_show(struct device
*cdev
,
2670 struct device_attribute
*attr
, char *buf
)
2672 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2673 struct megasas_instance
*instance
=
2674 (struct megasas_instance
*) shost
->hostdata
;
2676 return snprintf(buf
, PAGE_SIZE
, "%ld\n", (unsigned long)
2677 ((instance
->fw_crash_buffer_size
) * 1024 * 1024)/PAGE_SIZE
);
2681 megasas_fw_crash_state_store(struct device
*cdev
,
2682 struct device_attribute
*attr
, const char *buf
, size_t count
)
2684 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2685 struct megasas_instance
*instance
=
2686 (struct megasas_instance
*) shost
->hostdata
;
2688 unsigned long flags
;
2690 if (kstrtoint(buf
, 0, &val
) != 0)
2693 if ((val
<= AVAILABLE
|| val
> COPY_ERROR
)) {
2694 dev_err(&instance
->pdev
->dev
, "application updates invalid "
2695 "firmware crash state\n");
2699 instance
->fw_crash_state
= val
;
2701 if ((val
== COPIED
) || (val
== COPY_ERROR
)) {
2702 spin_lock_irqsave(&instance
->crashdump_lock
, flags
);
2703 megasas_free_host_crash_buffer(instance
);
2704 spin_unlock_irqrestore(&instance
->crashdump_lock
, flags
);
2705 if (val
== COPY_ERROR
)
2706 dev_info(&instance
->pdev
->dev
, "application failed to "
2707 "copy Firmware crash dump\n");
2709 dev_info(&instance
->pdev
->dev
, "Firmware crash dump "
2710 "copied successfully\n");
2716 megasas_fw_crash_state_show(struct device
*cdev
,
2717 struct device_attribute
*attr
, char *buf
)
2719 struct Scsi_Host
*shost
= class_to_shost(cdev
);
2720 struct megasas_instance
*instance
=
2721 (struct megasas_instance
*) shost
->hostdata
;
2722 return snprintf(buf
, PAGE_SIZE
, "%d\n", instance
->fw_crash_state
);
2726 megasas_page_size_show(struct device
*cdev
,
2727 struct device_attribute
*attr
, char *buf
)
2729 return snprintf(buf
, PAGE_SIZE
, "%ld\n", (unsigned long)PAGE_SIZE
- 1);
2732 static DEVICE_ATTR(fw_crash_buffer
, S_IRUGO
| S_IWUSR
,
2733 megasas_fw_crash_buffer_show
, megasas_fw_crash_buffer_store
);
2734 static DEVICE_ATTR(fw_crash_buffer_size
, S_IRUGO
,
2735 megasas_fw_crash_buffer_size_show
, NULL
);
2736 static DEVICE_ATTR(fw_crash_state
, S_IRUGO
| S_IWUSR
,
2737 megasas_fw_crash_state_show
, megasas_fw_crash_state_store
);
2738 static DEVICE_ATTR(page_size
, S_IRUGO
,
2739 megasas_page_size_show
, NULL
);
2741 struct device_attribute
*megaraid_host_attrs
[] = {
2742 &dev_attr_fw_crash_buffer_size
,
2743 &dev_attr_fw_crash_buffer
,
2744 &dev_attr_fw_crash_state
,
2745 &dev_attr_page_size
,
2750 * Scsi host template for megaraid_sas driver
2752 static struct scsi_host_template megasas_template
= {
2754 .module
= THIS_MODULE
,
2755 .name
= "LSI SAS based MegaRAID driver",
2756 .proc_name
= "megaraid_sas",
2757 .slave_configure
= megasas_slave_configure
,
2758 .slave_alloc
= megasas_slave_alloc
,
2759 .queuecommand
= megasas_queue_command
,
2760 .eh_device_reset_handler
= megasas_reset_device
,
2761 .eh_bus_reset_handler
= megasas_reset_bus_host
,
2762 .eh_host_reset_handler
= megasas_reset_bus_host
,
2763 .eh_timed_out
= megasas_reset_timer
,
2764 .shost_attrs
= megaraid_host_attrs
,
2765 .bios_param
= megasas_bios_param
,
2766 .use_clustering
= ENABLE_CLUSTERING
,
2767 .change_queue_depth
= megasas_change_queue_depth
,
2772 * megasas_complete_int_cmd - Completes an internal command
2773 * @instance: Adapter soft state
2774 * @cmd: Command to be completed
2776 * The megasas_issue_blocked_cmd() function waits for a command to complete
2777 * after it issues a command. This function wakes up that waiting routine by
2778 * calling wake_up() on the wait queue.
2781 megasas_complete_int_cmd(struct megasas_instance
*instance
,
2782 struct megasas_cmd
*cmd
)
2784 cmd
->cmd_status
= cmd
->frame
->io
.cmd_status
;
2786 if (cmd
->cmd_status
== ENODATA
) {
2787 cmd
->cmd_status
= 0;
2789 wake_up(&instance
->int_cmd_wait_q
);
2793 * megasas_complete_abort - Completes aborting a command
2794 * @instance: Adapter soft state
2795 * @cmd: Cmd that was issued to abort another cmd
2797 * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q
2798 * after it issues an abort on a previously issued command. This function
2799 * wakes up all functions waiting on the same wait queue.
2802 megasas_complete_abort(struct megasas_instance
*instance
,
2803 struct megasas_cmd
*cmd
)
2805 if (cmd
->sync_cmd
) {
2807 cmd
->cmd_status
= 0;
2808 wake_up(&instance
->abort_cmd_wait_q
);
2815 * megasas_complete_cmd - Completes a command
2816 * @instance: Adapter soft state
2817 * @cmd: Command to be completed
2818 * @alt_status: If non-zero, use this value as status to
2819 * SCSI mid-layer instead of the value returned
2820 * by the FW. This should be used if caller wants
2821 * an alternate status (as in the case of aborted
2825 megasas_complete_cmd(struct megasas_instance
*instance
, struct megasas_cmd
*cmd
,
2829 struct megasas_header
*hdr
= &cmd
->frame
->hdr
;
2830 unsigned long flags
;
2831 struct fusion_context
*fusion
= instance
->ctrl_context
;
2834 /* flag for the retry reset */
2835 cmd
->retry_for_fw_reset
= 0;
2838 cmd
->scmd
->SCp
.ptr
= NULL
;
2841 case MFI_CMD_INVALID
:
2842 /* Some older 1068 controller FW may keep a pended
2843 MR_DCMD_CTRL_EVENT_GET_INFO left over from the main kernel
2844 when booting the kdump kernel. Ignore this command to
2845 prevent a kernel panic on shutdown of the kdump kernel. */
2846 printk(KERN_WARNING
"megaraid_sas: MFI_CMD_INVALID command "
2848 printk(KERN_WARNING
"megaraid_sas: If you have a controller "
2849 "other than PERC5, please upgrade your firmware.\n");
2851 case MFI_CMD_PD_SCSI_IO
:
2852 case MFI_CMD_LD_SCSI_IO
:
2855 * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been
2856 * issued either through an IO path or an IOCTL path. If it
2857 * was via IOCTL, we will send it to internal completion.
2859 if (cmd
->sync_cmd
) {
2861 megasas_complete_int_cmd(instance
, cmd
);
2865 case MFI_CMD_LD_READ
:
2866 case MFI_CMD_LD_WRITE
:
2869 cmd
->scmd
->result
= alt_status
<< 16;
2875 atomic_dec(&instance
->fw_outstanding
);
2877 scsi_dma_unmap(cmd
->scmd
);
2878 cmd
->scmd
->scsi_done(cmd
->scmd
);
2879 megasas_return_cmd(instance
, cmd
);
2884 switch (hdr
->cmd_status
) {
2887 cmd
->scmd
->result
= DID_OK
<< 16;
2890 case MFI_STAT_SCSI_IO_FAILED
:
2891 case MFI_STAT_LD_INIT_IN_PROGRESS
:
2893 (DID_ERROR
<< 16) | hdr
->scsi_status
;
2896 case MFI_STAT_SCSI_DONE_WITH_ERROR
:
2898 cmd
->scmd
->result
= (DID_OK
<< 16) | hdr
->scsi_status
;
2900 if (hdr
->scsi_status
== SAM_STAT_CHECK_CONDITION
) {
2901 memset(cmd
->scmd
->sense_buffer
, 0,
2902 SCSI_SENSE_BUFFERSIZE
);
2903 memcpy(cmd
->scmd
->sense_buffer
, cmd
->sense
,
2906 cmd
->scmd
->result
|= DRIVER_SENSE
<< 24;
2911 case MFI_STAT_LD_OFFLINE
:
2912 case MFI_STAT_DEVICE_NOT_FOUND
:
2913 cmd
->scmd
->result
= DID_BAD_TARGET
<< 16;
2917 printk(KERN_DEBUG
"megasas: MFI FW status %#x\n",
2919 cmd
->scmd
->result
= DID_ERROR
<< 16;
2923 atomic_dec(&instance
->fw_outstanding
);
2925 scsi_dma_unmap(cmd
->scmd
);
2926 cmd
->scmd
->scsi_done(cmd
->scmd
);
2927 megasas_return_cmd(instance
, cmd
);
2934 opcode
= le32_to_cpu(cmd
->frame
->dcmd
.opcode
);
2935 /* Check for LD map update */
2936 if ((opcode
== MR_DCMD_LD_MAP_GET_INFO
)
2937 && (cmd
->frame
->dcmd
.mbox
.b
[1] == 1)) {
2938 fusion
->fast_path_io
= 0;
2939 spin_lock_irqsave(instance
->host
->host_lock
, flags
);
2940 if (cmd
->frame
->hdr
.cmd_status
!= 0) {
2941 if (cmd
->frame
->hdr
.cmd_status
!=
2943 printk(KERN_WARNING
"megasas: map sync"
2944 "failed, status = 0x%x.\n",
2945 cmd
->frame
->hdr
.cmd_status
);
2947 megasas_return_mfi_mpt_pthr(instance
,
2948 cmd
, cmd
->mpt_pthr_cmd_blocked
);
2949 spin_unlock_irqrestore(
2950 instance
->host
->host_lock
,
2956 megasas_return_mfi_mpt_pthr(instance
, cmd
,
2957 cmd
->mpt_pthr_cmd_blocked
);
2960 * Set fast path IO to ZERO.
2961 * Validate Map will set proper value.
2962 * Meanwhile all IOs will go as LD IO.
2964 if (MR_ValidateMapInfo(instance
))
2965 fusion
->fast_path_io
= 1;
2967 fusion
->fast_path_io
= 0;
2968 megasas_sync_map_info(instance
);
2969 spin_unlock_irqrestore(instance
->host
->host_lock
,
2973 if (opcode
== MR_DCMD_CTRL_EVENT_GET_INFO
||
2974 opcode
== MR_DCMD_CTRL_EVENT_GET
) {
2975 spin_lock_irqsave(&poll_aen_lock
, flags
);
2976 megasas_poll_wait_aen
= 0;
2977 spin_unlock_irqrestore(&poll_aen_lock
, flags
);
2981 * See if got an event notification
2983 if (opcode
== MR_DCMD_CTRL_EVENT_WAIT
)
2984 megasas_service_aen(instance
, cmd
);
2986 megasas_complete_int_cmd(instance
, cmd
);
2992 * Cmd issued to abort another cmd returned
2994 megasas_complete_abort(instance
, cmd
);
2998 printk("megasas: Unknown command completed! [0x%X]\n",
3005 * megasas_issue_pending_cmds_again - issue all pending cmds
3006 * in FW again because of the fw reset
3007 * @instance: Adapter soft state
3010 megasas_issue_pending_cmds_again(struct megasas_instance
*instance
)
3012 struct megasas_cmd
*cmd
;
3013 struct list_head clist_local
;
3014 union megasas_evt_class_locale class_locale
;
3015 unsigned long flags
;
3018 INIT_LIST_HEAD(&clist_local
);
3019 spin_lock_irqsave(&instance
->hba_lock
, flags
);
3020 list_splice_init(&instance
->internal_reset_pending_q
, &clist_local
);
3021 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
3023 while (!list_empty(&clist_local
)) {
3024 cmd
= list_entry((&clist_local
)->next
,
3025 struct megasas_cmd
, list
);
3026 list_del_init(&cmd
->list
);
3028 if (cmd
->sync_cmd
|| cmd
->scmd
) {
3029 printk(KERN_NOTICE
"megaraid_sas: command %p, %p:%d"
3030 "detected to be pending while HBA reset.\n",
3031 cmd
, cmd
->scmd
, cmd
->sync_cmd
);
3033 cmd
->retry_for_fw_reset
++;
3035 if (cmd
->retry_for_fw_reset
== 3) {
3036 printk(KERN_NOTICE
"megaraid_sas: cmd %p, %p:%d"
3037 "was tried multiple times during reset."
3038 "Shutting down the HBA\n",
3039 cmd
, cmd
->scmd
, cmd
->sync_cmd
);
3040 megaraid_sas_kill_hba(instance
);
3042 instance
->adprecovery
=
3043 MEGASAS_HW_CRITICAL_ERROR
;
3048 if (cmd
->sync_cmd
== 1) {
3050 printk(KERN_NOTICE
"megaraid_sas: unexpected"
3051 "cmd attached to internal command!\n");
3053 printk(KERN_NOTICE
"megasas: %p synchronous cmd"
3054 "on the internal reset queue,"
3055 "issue it again.\n", cmd
);
3056 cmd
->cmd_status
= ENODATA
;
3057 instance
->instancet
->fire_cmd(instance
,
3058 cmd
->frame_phys_addr
,
3059 0, instance
->reg_set
);
3060 } else if (cmd
->scmd
) {
3061 printk(KERN_NOTICE
"megasas: %p scsi cmd [%02x]"
3062 "detected on the internal queue, issue again.\n",
3063 cmd
, cmd
->scmd
->cmnd
[0]);
3065 atomic_inc(&instance
->fw_outstanding
);
3066 instance
->instancet
->fire_cmd(instance
,
3067 cmd
->frame_phys_addr
,
3068 cmd
->frame_count
-1, instance
->reg_set
);
3070 printk(KERN_NOTICE
"megasas: %p unexpected cmd on the"
3071 "internal reset defer list while re-issue!!\n",
3076 if (instance
->aen_cmd
) {
3077 printk(KERN_NOTICE
"megaraid_sas: aen_cmd in def process\n");
3078 megasas_return_cmd(instance
, instance
->aen_cmd
);
3080 instance
->aen_cmd
= NULL
;
3084 * Initiate AEN (Asynchronous Event Notification)
3086 seq_num
= instance
->last_seq_num
;
3087 class_locale
.members
.reserved
= 0;
3088 class_locale
.members
.locale
= MR_EVT_LOCALE_ALL
;
3089 class_locale
.members
.class = MR_EVT_CLASS_DEBUG
;
3091 megasas_register_aen(instance
, seq_num
, class_locale
.word
);
3095 * Move the internal reset pending commands to a deferred queue.
3097 * We move the commands pending at internal reset time to a
3098 * pending queue. This queue would be flushed after successful
3099 * completion of the internal reset sequence. if the internal reset
3100 * did not complete in time, the kernel reset handler would flush
3104 megasas_internal_reset_defer_cmds(struct megasas_instance
*instance
)
3106 struct megasas_cmd
*cmd
;
3108 u32 max_cmd
= instance
->max_fw_cmds
;
3110 unsigned long flags
;
3113 spin_lock_irqsave(&instance
->mfi_pool_lock
, flags
);
3114 for (i
= 0; i
< max_cmd
; i
++) {
3115 cmd
= instance
->cmd_list
[i
];
3116 if (cmd
->sync_cmd
== 1 || cmd
->scmd
) {
3117 printk(KERN_NOTICE
"megasas: moving cmd[%d]:%p:%d:%p"
3118 "on the defer queue as internal\n",
3119 defer_index
, cmd
, cmd
->sync_cmd
, cmd
->scmd
);
3121 if (!list_empty(&cmd
->list
)) {
3122 printk(KERN_NOTICE
"megaraid_sas: ERROR while"
3123 " moving this cmd:%p, %d %p, it was"
3124 "discovered on some list?\n",
3125 cmd
, cmd
->sync_cmd
, cmd
->scmd
);
3127 list_del_init(&cmd
->list
);
3130 list_add_tail(&cmd
->list
,
3131 &instance
->internal_reset_pending_q
);
3134 spin_unlock_irqrestore(&instance
->mfi_pool_lock
, flags
);
3139 process_fw_state_change_wq(struct work_struct
*work
)
3141 struct megasas_instance
*instance
=
3142 container_of(work
, struct megasas_instance
, work_init
);
3144 unsigned long flags
;
3146 if (instance
->adprecovery
!= MEGASAS_ADPRESET_SM_INFAULT
) {
3147 printk(KERN_NOTICE
"megaraid_sas: error, recovery st %x \n",
3148 instance
->adprecovery
);
3152 if (instance
->adprecovery
== MEGASAS_ADPRESET_SM_INFAULT
) {
3153 printk(KERN_NOTICE
"megaraid_sas: FW detected to be in fault"
3154 "state, restarting it...\n");
3156 instance
->instancet
->disable_intr(instance
);
3157 atomic_set(&instance
->fw_outstanding
, 0);
3159 atomic_set(&instance
->fw_reset_no_pci_access
, 1);
3160 instance
->instancet
->adp_reset(instance
, instance
->reg_set
);
3161 atomic_set(&instance
->fw_reset_no_pci_access
, 0 );
3163 printk(KERN_NOTICE
"megaraid_sas: FW restarted successfully,"
3164 "initiating next stage...\n");
3166 printk(KERN_NOTICE
"megaraid_sas: HBA recovery state machine,"
3167 "state 2 starting...\n");
3169 /*waitting for about 20 second before start the second init*/
3170 for (wait
= 0; wait
< 30; wait
++) {
3174 if (megasas_transition_to_ready(instance
, 1)) {
3175 printk(KERN_NOTICE
"megaraid_sas:adapter not ready\n");
3177 megaraid_sas_kill_hba(instance
);
3178 instance
->adprecovery
= MEGASAS_HW_CRITICAL_ERROR
;
3182 if ((instance
->pdev
->device
== PCI_DEVICE_ID_LSI_SAS1064R
) ||
3183 (instance
->pdev
->device
== PCI_DEVICE_ID_DELL_PERC5
) ||
3184 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_VERDE_ZCR
)
3186 *instance
->consumer
= *instance
->producer
;
3188 *instance
->consumer
= 0;
3189 *instance
->producer
= 0;
3192 megasas_issue_init_mfi(instance
);
3194 spin_lock_irqsave(&instance
->hba_lock
, flags
);
3195 instance
->adprecovery
= MEGASAS_HBA_OPERATIONAL
;
3196 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
3197 instance
->instancet
->enable_intr(instance
);
3199 megasas_issue_pending_cmds_again(instance
);
3200 instance
->issuepend_done
= 1;
3206 * megasas_deplete_reply_queue - Processes all completed commands
3207 * @instance: Adapter soft state
3208 * @alt_status: Alternate status to be returned to
3209 * SCSI mid-layer instead of the status
3210 * returned by the FW
3211 * Note: this must be called with hba lock held
3214 megasas_deplete_reply_queue(struct megasas_instance
*instance
,
3220 if ((mfiStatus
= instance
->instancet
->check_reset(instance
,
3221 instance
->reg_set
)) == 1) {
3225 if ((mfiStatus
= instance
->instancet
->clear_intr(
3228 /* Hardware may not set outbound_intr_status in MSI-X mode */
3229 if (!instance
->msix_vectors
)
3233 instance
->mfiStatus
= mfiStatus
;
3235 if ((mfiStatus
& MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE
)) {
3236 fw_state
= instance
->instancet
->read_fw_status_reg(
3237 instance
->reg_set
) & MFI_STATE_MASK
;
3239 if (fw_state
!= MFI_STATE_FAULT
) {
3240 printk(KERN_NOTICE
"megaraid_sas: fw state:%x\n",
3244 if ((fw_state
== MFI_STATE_FAULT
) &&
3245 (instance
->disableOnlineCtrlReset
== 0)) {
3246 printk(KERN_NOTICE
"megaraid_sas: wait adp restart\n");
3248 if ((instance
->pdev
->device
==
3249 PCI_DEVICE_ID_LSI_SAS1064R
) ||
3250 (instance
->pdev
->device
==
3251 PCI_DEVICE_ID_DELL_PERC5
) ||
3252 (instance
->pdev
->device
==
3253 PCI_DEVICE_ID_LSI_VERDE_ZCR
)) {
3255 *instance
->consumer
=
3256 cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN
);
3260 instance
->instancet
->disable_intr(instance
);
3261 instance
->adprecovery
= MEGASAS_ADPRESET_SM_INFAULT
;
3262 instance
->issuepend_done
= 0;
3264 atomic_set(&instance
->fw_outstanding
, 0);
3265 megasas_internal_reset_defer_cmds(instance
);
3267 printk(KERN_NOTICE
"megasas: fwState=%x, stage:%d\n",
3268 fw_state
, instance
->adprecovery
);
3270 schedule_work(&instance
->work_init
);
3274 printk(KERN_NOTICE
"megasas: fwstate:%x, dis_OCR=%x\n",
3275 fw_state
, instance
->disableOnlineCtrlReset
);
3279 tasklet_schedule(&instance
->isr_tasklet
);
3283 * megasas_isr - isr entry point
3285 static irqreturn_t
megasas_isr(int irq
, void *devp
)
3287 struct megasas_irq_context
*irq_context
= devp
;
3288 struct megasas_instance
*instance
= irq_context
->instance
;
3289 unsigned long flags
;
3292 if (atomic_read(&instance
->fw_reset_no_pci_access
))
3295 spin_lock_irqsave(&instance
->hba_lock
, flags
);
3296 rc
= megasas_deplete_reply_queue(instance
, DID_OK
);
3297 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
3303 * megasas_transition_to_ready - Move the FW to READY state
3304 * @instance: Adapter soft state
3306 * During the initialization, FW passes can potentially be in any one of
3307 * several possible states. If the FW in operational, waiting-for-handshake
3308 * states, driver must take steps to bring it to ready state. Otherwise, it
3309 * has to wait for the ready state.
3312 megasas_transition_to_ready(struct megasas_instance
*instance
, int ocr
)
3318 u32 abs_state
, curr_abs_state
;
3320 abs_state
= instance
->instancet
->read_fw_status_reg(instance
->reg_set
);
3321 fw_state
= abs_state
& MFI_STATE_MASK
;
3323 if (fw_state
!= MFI_STATE_READY
)
3324 printk(KERN_INFO
"megasas: Waiting for FW to come to ready"
3327 while (fw_state
!= MFI_STATE_READY
) {
3331 case MFI_STATE_FAULT
:
3332 printk(KERN_DEBUG
"megasas: FW in FAULT state!!\n");
3334 max_wait
= MEGASAS_RESET_WAIT_TIME
;
3335 cur_state
= MFI_STATE_FAULT
;
3340 case MFI_STATE_WAIT_HANDSHAKE
:
3342 * Set the CLR bit in inbound doorbell
3344 if ((instance
->pdev
->device
==
3345 PCI_DEVICE_ID_LSI_SAS0073SKINNY
) ||
3346 (instance
->pdev
->device
==
3347 PCI_DEVICE_ID_LSI_SAS0071SKINNY
) ||
3348 (instance
->pdev
->device
==
3349 PCI_DEVICE_ID_LSI_FUSION
) ||
3350 (instance
->pdev
->device
==
3351 PCI_DEVICE_ID_LSI_PLASMA
) ||
3352 (instance
->pdev
->device
==
3353 PCI_DEVICE_ID_LSI_INVADER
) ||
3354 (instance
->pdev
->device
==
3355 PCI_DEVICE_ID_LSI_FURY
)) {
3357 MFI_INIT_CLEAR_HANDSHAKE
|MFI_INIT_HOTPLUG
,
3358 &instance
->reg_set
->doorbell
);
3361 MFI_INIT_CLEAR_HANDSHAKE
|MFI_INIT_HOTPLUG
,
3362 &instance
->reg_set
->inbound_doorbell
);
3365 max_wait
= MEGASAS_RESET_WAIT_TIME
;
3366 cur_state
= MFI_STATE_WAIT_HANDSHAKE
;
3369 case MFI_STATE_BOOT_MESSAGE_PENDING
:
3370 if ((instance
->pdev
->device
==
3371 PCI_DEVICE_ID_LSI_SAS0073SKINNY
) ||
3372 (instance
->pdev
->device
==
3373 PCI_DEVICE_ID_LSI_SAS0071SKINNY
) ||
3374 (instance
->pdev
->device
==
3375 PCI_DEVICE_ID_LSI_FUSION
) ||
3376 (instance
->pdev
->device
==
3377 PCI_DEVICE_ID_LSI_PLASMA
) ||
3378 (instance
->pdev
->device
==
3379 PCI_DEVICE_ID_LSI_INVADER
) ||
3380 (instance
->pdev
->device
==
3381 PCI_DEVICE_ID_LSI_FURY
)) {
3382 writel(MFI_INIT_HOTPLUG
,
3383 &instance
->reg_set
->doorbell
);
3385 writel(MFI_INIT_HOTPLUG
,
3386 &instance
->reg_set
->inbound_doorbell
);
3388 max_wait
= MEGASAS_RESET_WAIT_TIME
;
3389 cur_state
= MFI_STATE_BOOT_MESSAGE_PENDING
;
3392 case MFI_STATE_OPERATIONAL
:
3394 * Bring it to READY state; assuming max wait 10 secs
3396 instance
->instancet
->disable_intr(instance
);
3397 if ((instance
->pdev
->device
==
3398 PCI_DEVICE_ID_LSI_SAS0073SKINNY
) ||
3399 (instance
->pdev
->device
==
3400 PCI_DEVICE_ID_LSI_SAS0071SKINNY
) ||
3401 (instance
->pdev
->device
3402 == PCI_DEVICE_ID_LSI_FUSION
) ||
3403 (instance
->pdev
->device
3404 == PCI_DEVICE_ID_LSI_PLASMA
) ||
3405 (instance
->pdev
->device
3406 == PCI_DEVICE_ID_LSI_INVADER
) ||
3407 (instance
->pdev
->device
3408 == PCI_DEVICE_ID_LSI_FURY
)) {
3409 writel(MFI_RESET_FLAGS
,
3410 &instance
->reg_set
->doorbell
);
3411 if ((instance
->pdev
->device
==
3412 PCI_DEVICE_ID_LSI_FUSION
) ||
3413 (instance
->pdev
->device
==
3414 PCI_DEVICE_ID_LSI_PLASMA
) ||
3415 (instance
->pdev
->device
==
3416 PCI_DEVICE_ID_LSI_INVADER
) ||
3417 (instance
->pdev
->device
==
3418 PCI_DEVICE_ID_LSI_FURY
)) {
3419 for (i
= 0; i
< (10 * 1000); i
+= 20) {
3430 writel(MFI_RESET_FLAGS
,
3431 &instance
->reg_set
->inbound_doorbell
);
3433 max_wait
= MEGASAS_RESET_WAIT_TIME
;
3434 cur_state
= MFI_STATE_OPERATIONAL
;
3437 case MFI_STATE_UNDEFINED
:
3439 * This state should not last for more than 2 seconds
3441 max_wait
= MEGASAS_RESET_WAIT_TIME
;
3442 cur_state
= MFI_STATE_UNDEFINED
;
3445 case MFI_STATE_BB_INIT
:
3446 max_wait
= MEGASAS_RESET_WAIT_TIME
;
3447 cur_state
= MFI_STATE_BB_INIT
;
3450 case MFI_STATE_FW_INIT
:
3451 max_wait
= MEGASAS_RESET_WAIT_TIME
;
3452 cur_state
= MFI_STATE_FW_INIT
;
3455 case MFI_STATE_FW_INIT_2
:
3456 max_wait
= MEGASAS_RESET_WAIT_TIME
;
3457 cur_state
= MFI_STATE_FW_INIT_2
;
3460 case MFI_STATE_DEVICE_SCAN
:
3461 max_wait
= MEGASAS_RESET_WAIT_TIME
;
3462 cur_state
= MFI_STATE_DEVICE_SCAN
;
3465 case MFI_STATE_FLUSH_CACHE
:
3466 max_wait
= MEGASAS_RESET_WAIT_TIME
;
3467 cur_state
= MFI_STATE_FLUSH_CACHE
;
3471 printk(KERN_DEBUG
"megasas: Unknown state 0x%x\n",
3477 * The cur_state should not last for more than max_wait secs
3479 for (i
= 0; i
< (max_wait
* 1000); i
++) {
3480 curr_abs_state
= instance
->instancet
->
3481 read_fw_status_reg(instance
->reg_set
);
3483 if (abs_state
== curr_abs_state
) {
3490 * Return error if fw_state hasn't changed after max_wait
3492 if (curr_abs_state
== abs_state
) {
3493 printk(KERN_DEBUG
"FW state [%d] hasn't changed "
3494 "in %d secs\n", fw_state
, max_wait
);
3498 abs_state
= curr_abs_state
;
3499 fw_state
= curr_abs_state
& MFI_STATE_MASK
;
3501 printk(KERN_INFO
"megasas: FW now in Ready state\n");
3507 * megasas_teardown_frame_pool - Destroy the cmd frame DMA pool
3508 * @instance: Adapter soft state
3510 static void megasas_teardown_frame_pool(struct megasas_instance
*instance
)
3513 u32 max_cmd
= instance
->max_mfi_cmds
;
3514 struct megasas_cmd
*cmd
;
3516 if (!instance
->frame_dma_pool
)
3520 * Return all frames to pool
3522 for (i
= 0; i
< max_cmd
; i
++) {
3524 cmd
= instance
->cmd_list
[i
];
3527 pci_pool_free(instance
->frame_dma_pool
, cmd
->frame
,
3528 cmd
->frame_phys_addr
);
3531 pci_pool_free(instance
->sense_dma_pool
, cmd
->sense
,
3532 cmd
->sense_phys_addr
);
3536 * Now destroy the pool itself
3538 pci_pool_destroy(instance
->frame_dma_pool
);
3539 pci_pool_destroy(instance
->sense_dma_pool
);
3541 instance
->frame_dma_pool
= NULL
;
3542 instance
->sense_dma_pool
= NULL
;
3546 * megasas_create_frame_pool - Creates DMA pool for cmd frames
3547 * @instance: Adapter soft state
3549 * Each command packet has an embedded DMA memory buffer that is used for
3550 * filling MFI frame and the SG list that immediately follows the frame. This
3551 * function creates those DMA memory buffers for each command packet by using
3552 * PCI pool facility.
3554 static int megasas_create_frame_pool(struct megasas_instance
*instance
)
3562 struct megasas_cmd
*cmd
;
3564 max_cmd
= instance
->max_mfi_cmds
;
3567 * Size of our frame is 64 bytes for MFI frame, followed by max SG
3568 * elements and finally SCSI_SENSE_BUFFERSIZE bytes for sense buffer
3570 sge_sz
= (IS_DMA64
) ? sizeof(struct megasas_sge64
) :
3571 sizeof(struct megasas_sge32
);
3573 if (instance
->flag_ieee
) {
3574 sge_sz
= sizeof(struct megasas_sge_skinny
);
3578 * Calculated the number of 64byte frames required for SGL
3580 sgl_sz
= sge_sz
* instance
->max_num_sge
;
3581 frame_count
= (sgl_sz
+ MEGAMFI_FRAME_SIZE
- 1) / MEGAMFI_FRAME_SIZE
;
3585 * We need one extra frame for the MFI command
3589 total_sz
= MEGAMFI_FRAME_SIZE
* frame_count
;
3591 * Use DMA pool facility provided by PCI layer
3593 instance
->frame_dma_pool
= pci_pool_create("megasas frame pool",
3594 instance
->pdev
, total_sz
, 64,
3597 if (!instance
->frame_dma_pool
) {
3598 printk(KERN_DEBUG
"megasas: failed to setup frame pool\n");
3602 instance
->sense_dma_pool
= pci_pool_create("megasas sense pool",
3603 instance
->pdev
, 128, 4, 0);
3605 if (!instance
->sense_dma_pool
) {
3606 printk(KERN_DEBUG
"megasas: failed to setup sense pool\n");
3608 pci_pool_destroy(instance
->frame_dma_pool
);
3609 instance
->frame_dma_pool
= NULL
;
3615 * Allocate and attach a frame to each of the commands in cmd_list.
3616 * By making cmd->index as the context instead of the &cmd, we can
3617 * always use 32bit context regardless of the architecture
3619 for (i
= 0; i
< max_cmd
; i
++) {
3621 cmd
= instance
->cmd_list
[i
];
3623 cmd
->frame
= pci_pool_alloc(instance
->frame_dma_pool
,
3624 GFP_KERNEL
, &cmd
->frame_phys_addr
);
3626 cmd
->sense
= pci_pool_alloc(instance
->sense_dma_pool
,
3627 GFP_KERNEL
, &cmd
->sense_phys_addr
);
3630 * megasas_teardown_frame_pool() takes care of freeing
3631 * whatever has been allocated
3633 if (!cmd
->frame
|| !cmd
->sense
) {
3634 printk(KERN_DEBUG
"megasas: pci_pool_alloc failed \n");
3635 megasas_teardown_frame_pool(instance
);
3639 memset(cmd
->frame
, 0, total_sz
);
3640 cmd
->frame
->io
.context
= cpu_to_le32(cmd
->index
);
3641 cmd
->frame
->io
.pad_0
= 0;
3642 if ((instance
->pdev
->device
!= PCI_DEVICE_ID_LSI_FUSION
) &&
3643 (instance
->pdev
->device
!= PCI_DEVICE_ID_LSI_PLASMA
) &&
3644 (instance
->pdev
->device
!= PCI_DEVICE_ID_LSI_INVADER
) &&
3645 (instance
->pdev
->device
!= PCI_DEVICE_ID_LSI_FURY
) &&
3647 cmd
->frame
->hdr
.cmd
= MFI_CMD_INVALID
;
3654 * megasas_free_cmds - Free all the cmds in the free cmd pool
3655 * @instance: Adapter soft state
3657 void megasas_free_cmds(struct megasas_instance
*instance
)
3660 /* First free the MFI frame pool */
3661 megasas_teardown_frame_pool(instance
);
3663 /* Free all the commands in the cmd_list */
3664 for (i
= 0; i
< instance
->max_mfi_cmds
; i
++)
3666 kfree(instance
->cmd_list
[i
]);
3668 /* Free the cmd_list buffer itself */
3669 kfree(instance
->cmd_list
);
3670 instance
->cmd_list
= NULL
;
3672 INIT_LIST_HEAD(&instance
->cmd_pool
);
3676 * megasas_alloc_cmds - Allocates the command packets
3677 * @instance: Adapter soft state
3679 * Each command that is issued to the FW, whether IO commands from the OS or
3680 * internal commands like IOCTLs, are wrapped in local data structure called
3681 * megasas_cmd. The frame embedded in this megasas_cmd is actually issued to
3684 * Each frame has a 32-bit field called context (tag). This context is used
3685 * to get back the megasas_cmd from the frame when a frame gets completed in
3686 * the ISR. Typically the address of the megasas_cmd itself would be used as
3687 * the context. But we wanted to keep the differences between 32 and 64 bit
3688 * systems to the mininum. We always use 32 bit integers for the context. In
3689 * this driver, the 32 bit values are the indices into an array cmd_list.
3690 * This array is used only to look up the megasas_cmd given the context. The
3691 * free commands themselves are maintained in a linked list called cmd_pool.
3693 int megasas_alloc_cmds(struct megasas_instance
*instance
)
3698 struct megasas_cmd
*cmd
;
3699 struct fusion_context
*fusion
;
3701 fusion
= instance
->ctrl_context
;
3702 max_cmd
= instance
->max_mfi_cmds
;
3705 * instance->cmd_list is an array of struct megasas_cmd pointers.
3706 * Allocate the dynamic array first and then allocate individual
3709 instance
->cmd_list
= kcalloc(max_cmd
, sizeof(struct megasas_cmd
*), GFP_KERNEL
);
3711 if (!instance
->cmd_list
) {
3712 printk(KERN_DEBUG
"megasas: out of memory\n");
3716 memset(instance
->cmd_list
, 0, sizeof(struct megasas_cmd
*) *max_cmd
);
3718 for (i
= 0; i
< max_cmd
; i
++) {
3719 instance
->cmd_list
[i
] = kmalloc(sizeof(struct megasas_cmd
),
3722 if (!instance
->cmd_list
[i
]) {
3724 for (j
= 0; j
< i
; j
++)
3725 kfree(instance
->cmd_list
[j
]);
3727 kfree(instance
->cmd_list
);
3728 instance
->cmd_list
= NULL
;
3734 for (i
= 0; i
< max_cmd
; i
++) {
3735 cmd
= instance
->cmd_list
[i
];
3736 memset(cmd
, 0, sizeof(struct megasas_cmd
));
3738 atomic_set(&cmd
->mfi_mpt_pthr
, MFI_LIST_ADDED
);
3740 cmd
->instance
= instance
;
3742 list_add_tail(&cmd
->list
, &instance
->cmd_pool
);
3746 * Create a frame pool and assign one frame to each cmd
3748 if (megasas_create_frame_pool(instance
)) {
3749 printk(KERN_DEBUG
"megasas: Error creating frame DMA pool\n");
3750 megasas_free_cmds(instance
);
3757 * megasas_get_pd_list_info - Returns FW's pd_list structure
3758 * @instance: Adapter soft state
3759 * @pd_list: pd_list structure
3761 * Issues an internal command (DCMD) to get the FW's controller PD
3762 * list structure. This information is mainly used to find out SYSTEM
3763 * supported by the FW.
3766 megasas_get_pd_list(struct megasas_instance
*instance
)
3768 int ret
= 0, pd_index
= 0;
3769 struct megasas_cmd
*cmd
;
3770 struct megasas_dcmd_frame
*dcmd
;
3771 struct MR_PD_LIST
*ci
;
3772 struct MR_PD_ADDRESS
*pd_addr
;
3773 dma_addr_t ci_h
= 0;
3775 cmd
= megasas_get_cmd(instance
);
3778 printk(KERN_DEBUG
"megasas (get_pd_list): Failed to get cmd\n");
3782 dcmd
= &cmd
->frame
->dcmd
;
3784 ci
= pci_alloc_consistent(instance
->pdev
,
3785 MEGASAS_MAX_PD
* sizeof(struct MR_PD_LIST
), &ci_h
);
3788 printk(KERN_DEBUG
"Failed to alloc mem for pd_list\n");
3789 megasas_return_cmd(instance
, cmd
);
3793 memset(ci
, 0, sizeof(*ci
));
3794 memset(dcmd
->mbox
.b
, 0, MFI_MBOX_SIZE
);
3796 dcmd
->mbox
.b
[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST
;
3797 dcmd
->mbox
.b
[1] = 0;
3798 dcmd
->cmd
= MFI_CMD_DCMD
;
3799 dcmd
->cmd_status
= 0xFF;
3800 dcmd
->sge_count
= 1;
3801 dcmd
->flags
= cpu_to_le16(MFI_FRAME_DIR_READ
);
3804 dcmd
->data_xfer_len
= cpu_to_le32(MEGASAS_MAX_PD
* sizeof(struct MR_PD_LIST
));
3805 dcmd
->opcode
= cpu_to_le32(MR_DCMD_PD_LIST_QUERY
);
3806 dcmd
->sgl
.sge32
[0].phys_addr
= cpu_to_le32(ci_h
);
3807 dcmd
->sgl
.sge32
[0].length
= cpu_to_le32(MEGASAS_MAX_PD
* sizeof(struct MR_PD_LIST
));
3809 if (instance
->ctrl_context
&& !instance
->mask_interrupts
)
3810 ret
= megasas_issue_blocked_cmd(instance
, cmd
,
3811 MEGASAS_BLOCKED_CMD_TIMEOUT
);
3813 ret
= megasas_issue_polled(instance
, cmd
);
3816 * the following function will get the instance PD LIST.
3822 (le32_to_cpu(ci
->count
) <
3823 (MEGASAS_MAX_PD_CHANNELS
* MEGASAS_MAX_DEV_PER_CHANNEL
))) {
3825 memset(instance
->local_pd_list
, 0,
3826 MEGASAS_MAX_PD
* sizeof(struct megasas_pd_list
));
3828 for (pd_index
= 0; pd_index
< le32_to_cpu(ci
->count
); pd_index
++) {
3830 instance
->local_pd_list
[le16_to_cpu(pd_addr
->deviceId
)].tid
=
3831 le16_to_cpu(pd_addr
->deviceId
);
3832 instance
->local_pd_list
[le16_to_cpu(pd_addr
->deviceId
)].driveType
=
3833 pd_addr
->scsiDevType
;
3834 instance
->local_pd_list
[le16_to_cpu(pd_addr
->deviceId
)].driveState
=
3838 memcpy(instance
->pd_list
, instance
->local_pd_list
,
3839 sizeof(instance
->pd_list
));
3842 pci_free_consistent(instance
->pdev
,
3843 MEGASAS_MAX_PD
* sizeof(struct MR_PD_LIST
),
3846 if (instance
->ctrl_context
&& cmd
->mpt_pthr_cmd_blocked
)
3847 megasas_return_mfi_mpt_pthr(instance
, cmd
,
3848 cmd
->mpt_pthr_cmd_blocked
);
3850 megasas_return_cmd(instance
, cmd
);
3856 * megasas_get_ld_list_info - Returns FW's ld_list structure
3857 * @instance: Adapter soft state
3858 * @ld_list: ld_list structure
3860 * Issues an internal command (DCMD) to get the FW's controller PD
3861 * list structure. This information is mainly used to find out SYSTEM
3862 * supported by the FW.
3865 megasas_get_ld_list(struct megasas_instance
*instance
)
3867 int ret
= 0, ld_index
= 0, ids
= 0;
3868 struct megasas_cmd
*cmd
;
3869 struct megasas_dcmd_frame
*dcmd
;
3870 struct MR_LD_LIST
*ci
;
3871 dma_addr_t ci_h
= 0;
3874 cmd
= megasas_get_cmd(instance
);
3877 printk(KERN_DEBUG
"megasas_get_ld_list: Failed to get cmd\n");
3881 dcmd
= &cmd
->frame
->dcmd
;
3883 ci
= pci_alloc_consistent(instance
->pdev
,
3884 sizeof(struct MR_LD_LIST
),
3888 printk(KERN_DEBUG
"Failed to alloc mem in get_ld_list\n");
3889 megasas_return_cmd(instance
, cmd
);
3893 memset(ci
, 0, sizeof(*ci
));
3894 memset(dcmd
->mbox
.b
, 0, MFI_MBOX_SIZE
);
3896 if (instance
->supportmax256vd
)
3897 dcmd
->mbox
.b
[0] = 1;
3898 dcmd
->cmd
= MFI_CMD_DCMD
;
3899 dcmd
->cmd_status
= 0xFF;
3900 dcmd
->sge_count
= 1;
3901 dcmd
->flags
= cpu_to_le16(MFI_FRAME_DIR_READ
);
3903 dcmd
->data_xfer_len
= cpu_to_le32(sizeof(struct MR_LD_LIST
));
3904 dcmd
->opcode
= cpu_to_le32(MR_DCMD_LD_GET_LIST
);
3905 dcmd
->sgl
.sge32
[0].phys_addr
= cpu_to_le32(ci_h
);
3906 dcmd
->sgl
.sge32
[0].length
= cpu_to_le32(sizeof(struct MR_LD_LIST
));
3909 if (instance
->ctrl_context
&& !instance
->mask_interrupts
)
3910 ret
= megasas_issue_blocked_cmd(instance
, cmd
,
3911 MEGASAS_BLOCKED_CMD_TIMEOUT
);
3913 ret
= megasas_issue_polled(instance
, cmd
);
3916 ld_count
= le32_to_cpu(ci
->ldCount
);
3918 /* the following function will get the instance PD LIST */
3920 if ((ret
== 0) && (ld_count
<= instance
->fw_supported_vd_count
)) {
3921 memset(instance
->ld_ids
, 0xff, MAX_LOGICAL_DRIVES_EXT
);
3923 for (ld_index
= 0; ld_index
< ld_count
; ld_index
++) {
3924 if (ci
->ldList
[ld_index
].state
!= 0) {
3925 ids
= ci
->ldList
[ld_index
].ref
.targetId
;
3926 instance
->ld_ids
[ids
] =
3927 ci
->ldList
[ld_index
].ref
.targetId
;
3932 pci_free_consistent(instance
->pdev
,
3933 sizeof(struct MR_LD_LIST
),
3937 if (instance
->ctrl_context
&& cmd
->mpt_pthr_cmd_blocked
)
3938 megasas_return_mfi_mpt_pthr(instance
, cmd
,
3939 cmd
->mpt_pthr_cmd_blocked
);
3941 megasas_return_cmd(instance
, cmd
);
3946 * megasas_ld_list_query - Returns FW's ld_list structure
3947 * @instance: Adapter soft state
3948 * @ld_list: ld_list structure
3950 * Issues an internal command (DCMD) to get the FW's controller PD
3951 * list structure. This information is mainly used to find out SYSTEM
3952 * supported by the FW.
3955 megasas_ld_list_query(struct megasas_instance
*instance
, u8 query_type
)
3957 int ret
= 0, ld_index
= 0, ids
= 0;
3958 struct megasas_cmd
*cmd
;
3959 struct megasas_dcmd_frame
*dcmd
;
3960 struct MR_LD_TARGETID_LIST
*ci
;
3961 dma_addr_t ci_h
= 0;
3964 cmd
= megasas_get_cmd(instance
);
3968 "megasas:(megasas_ld_list_query): Failed to get cmd\n");
3972 dcmd
= &cmd
->frame
->dcmd
;
3974 ci
= pci_alloc_consistent(instance
->pdev
,
3975 sizeof(struct MR_LD_TARGETID_LIST
), &ci_h
);
3979 "megasas: Failed to alloc mem for ld_list_query\n");
3980 megasas_return_cmd(instance
, cmd
);
3984 memset(ci
, 0, sizeof(*ci
));
3985 memset(dcmd
->mbox
.b
, 0, MFI_MBOX_SIZE
);
3987 dcmd
->mbox
.b
[0] = query_type
;
3988 if (instance
->supportmax256vd
)
3989 dcmd
->mbox
.b
[2] = 1;
3991 dcmd
->cmd
= MFI_CMD_DCMD
;
3992 dcmd
->cmd_status
= 0xFF;
3993 dcmd
->sge_count
= 1;
3994 dcmd
->flags
= cpu_to_le16(MFI_FRAME_DIR_READ
);
3996 dcmd
->data_xfer_len
= cpu_to_le32(sizeof(struct MR_LD_TARGETID_LIST
));
3997 dcmd
->opcode
= cpu_to_le32(MR_DCMD_LD_LIST_QUERY
);
3998 dcmd
->sgl
.sge32
[0].phys_addr
= cpu_to_le32(ci_h
);
3999 dcmd
->sgl
.sge32
[0].length
= cpu_to_le32(sizeof(struct MR_LD_TARGETID_LIST
));
4002 if (instance
->ctrl_context
&& !instance
->mask_interrupts
)
4003 ret
= megasas_issue_blocked_cmd(instance
, cmd
,
4004 MEGASAS_BLOCKED_CMD_TIMEOUT
);
4006 ret
= megasas_issue_polled(instance
, cmd
);
4008 tgtid_count
= le32_to_cpu(ci
->count
);
4010 if ((ret
== 0) && (tgtid_count
<= (instance
->fw_supported_vd_count
))) {
4011 memset(instance
->ld_ids
, 0xff, MEGASAS_MAX_LD_IDS
);
4012 for (ld_index
= 0; ld_index
< tgtid_count
; ld_index
++) {
4013 ids
= ci
->targetId
[ld_index
];
4014 instance
->ld_ids
[ids
] = ci
->targetId
[ld_index
];
4019 pci_free_consistent(instance
->pdev
, sizeof(struct MR_LD_TARGETID_LIST
),
4022 if (instance
->ctrl_context
&& cmd
->mpt_pthr_cmd_blocked
)
4023 megasas_return_mfi_mpt_pthr(instance
, cmd
,
4024 cmd
->mpt_pthr_cmd_blocked
);
4026 megasas_return_cmd(instance
, cmd
);
4032 * megasas_get_controller_info - Returns FW's controller structure
4033 * @instance: Adapter soft state
4034 * @ctrl_info: Controller information structure
4036 * Issues an internal command (DCMD) to get the FW's controller structure.
4037 * This information is mainly used to find out the maximum IO transfer per
4038 * command supported by the FW.
4041 megasas_get_ctrl_info(struct megasas_instance
*instance
,
4042 struct megasas_ctrl_info
*ctrl_info
)
4045 struct megasas_cmd
*cmd
;
4046 struct megasas_dcmd_frame
*dcmd
;
4047 struct megasas_ctrl_info
*ci
;
4048 dma_addr_t ci_h
= 0;
4050 cmd
= megasas_get_cmd(instance
);
4053 printk(KERN_DEBUG
"megasas: Failed to get a free cmd\n");
4057 dcmd
= &cmd
->frame
->dcmd
;
4059 ci
= pci_alloc_consistent(instance
->pdev
,
4060 sizeof(struct megasas_ctrl_info
), &ci_h
);
4063 printk(KERN_DEBUG
"Failed to alloc mem for ctrl info\n");
4064 megasas_return_cmd(instance
, cmd
);
4068 memset(ci
, 0, sizeof(*ci
));
4069 memset(dcmd
->mbox
.b
, 0, MFI_MBOX_SIZE
);
4071 dcmd
->cmd
= MFI_CMD_DCMD
;
4072 dcmd
->cmd_status
= 0xFF;
4073 dcmd
->sge_count
= 1;
4074 dcmd
->flags
= cpu_to_le16(MFI_FRAME_DIR_READ
);
4077 dcmd
->data_xfer_len
= cpu_to_le32(sizeof(struct megasas_ctrl_info
));
4078 dcmd
->opcode
= cpu_to_le32(MR_DCMD_CTRL_GET_INFO
);
4079 dcmd
->sgl
.sge32
[0].phys_addr
= cpu_to_le32(ci_h
);
4080 dcmd
->sgl
.sge32
[0].length
= cpu_to_le32(sizeof(struct megasas_ctrl_info
));
4081 dcmd
->mbox
.b
[0] = 1;
4083 if (instance
->ctrl_context
&& !instance
->mask_interrupts
)
4084 ret
= megasas_issue_blocked_cmd(instance
, cmd
,
4085 MEGASAS_BLOCKED_CMD_TIMEOUT
);
4087 ret
= megasas_issue_polled(instance
, cmd
);
4090 memcpy(ctrl_info
, ci
, sizeof(struct megasas_ctrl_info
));
4092 pci_free_consistent(instance
->pdev
, sizeof(struct megasas_ctrl_info
),
4095 if (instance
->ctrl_context
&& cmd
->mpt_pthr_cmd_blocked
)
4096 megasas_return_mfi_mpt_pthr(instance
, cmd
,
4097 cmd
->mpt_pthr_cmd_blocked
);
4099 megasas_return_cmd(instance
, cmd
);
4104 * megasas_set_crash_dump_params - Sends address of crash dump DMA buffer
4107 * @instance: Adapter soft state
4108 * @crash_buf_state - tell FW to turn ON/OFF crash dump feature
4109 MR_CRASH_BUF_TURN_OFF = 0
4110 MR_CRASH_BUF_TURN_ON = 1
4111 * @return 0 on success non-zero on failure.
4112 * Issues an internal command (DCMD) to set parameters for crash dump feature.
4113 * Driver will send address of crash dump DMA buffer and set mbox to tell FW
4114 * that driver supports crash dump feature. This DCMD will be sent only if
4115 * crash dump feature is supported by the FW.
4118 int megasas_set_crash_dump_params(struct megasas_instance
*instance
,
4122 struct megasas_cmd
*cmd
;
4123 struct megasas_dcmd_frame
*dcmd
;
4125 cmd
= megasas_get_cmd(instance
);
4128 dev_err(&instance
->pdev
->dev
, "Failed to get a free cmd\n");
4133 dcmd
= &cmd
->frame
->dcmd
;
4135 memset(dcmd
->mbox
.b
, 0, MFI_MBOX_SIZE
);
4136 dcmd
->mbox
.b
[0] = crash_buf_state
;
4137 dcmd
->cmd
= MFI_CMD_DCMD
;
4138 dcmd
->cmd_status
= 0xFF;
4139 dcmd
->sge_count
= 1;
4140 dcmd
->flags
= cpu_to_le16(MFI_FRAME_DIR_NONE
);
4143 dcmd
->data_xfer_len
= cpu_to_le32(CRASH_DMA_BUF_SIZE
);
4144 dcmd
->opcode
= cpu_to_le32(MR_DCMD_CTRL_SET_CRASH_DUMP_PARAMS
);
4145 dcmd
->sgl
.sge32
[0].phys_addr
= cpu_to_le32(instance
->crash_dump_h
);
4146 dcmd
->sgl
.sge32
[0].length
= cpu_to_le32(CRASH_DMA_BUF_SIZE
);
4148 if (instance
->ctrl_context
&& !instance
->mask_interrupts
)
4149 ret
= megasas_issue_blocked_cmd(instance
, cmd
,
4150 MEGASAS_BLOCKED_CMD_TIMEOUT
);
4152 ret
= megasas_issue_polled(instance
, cmd
);
4154 if (instance
->ctrl_context
&& cmd
->mpt_pthr_cmd_blocked
)
4155 megasas_return_mfi_mpt_pthr(instance
, cmd
,
4156 cmd
->mpt_pthr_cmd_blocked
);
4158 megasas_return_cmd(instance
, cmd
);
4163 * megasas_issue_init_mfi - Initializes the FW
4164 * @instance: Adapter soft state
4166 * Issues the INIT MFI cmd
4169 megasas_issue_init_mfi(struct megasas_instance
*instance
)
4173 struct megasas_cmd
*cmd
;
4175 struct megasas_init_frame
*init_frame
;
4176 struct megasas_init_queue_info
*initq_info
;
4177 dma_addr_t init_frame_h
;
4178 dma_addr_t initq_info_h
;
4181 * Prepare a init frame. Note the init frame points to queue info
4182 * structure. Each frame has SGL allocated after first 64 bytes. For
4183 * this frame - since we don't need any SGL - we use SGL's space as
4184 * queue info structure
4186 * We will not get a NULL command below. We just created the pool.
4188 cmd
= megasas_get_cmd(instance
);
4190 init_frame
= (struct megasas_init_frame
*)cmd
->frame
;
4191 initq_info
= (struct megasas_init_queue_info
*)
4192 ((unsigned long)init_frame
+ 64);
4194 init_frame_h
= cmd
->frame_phys_addr
;
4195 initq_info_h
= init_frame_h
+ 64;
4197 context
= init_frame
->context
;
4198 memset(init_frame
, 0, MEGAMFI_FRAME_SIZE
);
4199 memset(initq_info
, 0, sizeof(struct megasas_init_queue_info
));
4200 init_frame
->context
= context
;
4202 initq_info
->reply_queue_entries
= cpu_to_le32(instance
->max_fw_cmds
+ 1);
4203 initq_info
->reply_queue_start_phys_addr_lo
= cpu_to_le32(instance
->reply_queue_h
);
4205 initq_info
->producer_index_phys_addr_lo
= cpu_to_le32(instance
->producer_h
);
4206 initq_info
->consumer_index_phys_addr_lo
= cpu_to_le32(instance
->consumer_h
);
4208 init_frame
->cmd
= MFI_CMD_INIT
;
4209 init_frame
->cmd_status
= 0xFF;
4210 init_frame
->queue_info_new_phys_addr_lo
=
4211 cpu_to_le32(lower_32_bits(initq_info_h
));
4212 init_frame
->queue_info_new_phys_addr_hi
=
4213 cpu_to_le32(upper_32_bits(initq_info_h
));
4215 init_frame
->data_xfer_len
= cpu_to_le32(sizeof(struct megasas_init_queue_info
));
4218 * disable the intr before firing the init frame to FW
4220 instance
->instancet
->disable_intr(instance
);
4223 * Issue the init frame in polled mode
4226 if (megasas_issue_polled(instance
, cmd
)) {
4227 printk(KERN_ERR
"megasas: Failed to init firmware\n");
4228 megasas_return_cmd(instance
, cmd
);
4232 megasas_return_cmd(instance
, cmd
);
4241 megasas_init_adapter_mfi(struct megasas_instance
*instance
)
4243 struct megasas_register_set __iomem
*reg_set
;
4247 reg_set
= instance
->reg_set
;
4250 * Get various operational parameters from status register
4252 instance
->max_fw_cmds
= instance
->instancet
->read_fw_status_reg(reg_set
) & 0x00FFFF;
4254 * Reduce the max supported cmds by 1. This is to ensure that the
4255 * reply_q_sz (1 more than the max cmd that driver may send)
4256 * does not exceed max cmds that the FW can support
4258 instance
->max_fw_cmds
= instance
->max_fw_cmds
-1;
4259 instance
->max_mfi_cmds
= instance
->max_fw_cmds
;
4260 instance
->max_num_sge
= (instance
->instancet
->read_fw_status_reg(reg_set
) & 0xFF0000) >>
4263 * Create a pool of commands
4265 if (megasas_alloc_cmds(instance
))
4266 goto fail_alloc_cmds
;
4269 * Allocate memory for reply queue. Length of reply queue should
4270 * be _one_ more than the maximum commands handled by the firmware.
4272 * Note: When FW completes commands, it places corresponding contex
4273 * values in this circular reply queue. This circular queue is a fairly
4274 * typical producer-consumer queue. FW is the producer (of completed
4275 * commands) and the driver is the consumer.
4277 context_sz
= sizeof(u32
);
4278 reply_q_sz
= context_sz
* (instance
->max_fw_cmds
+ 1);
4280 instance
->reply_queue
= pci_alloc_consistent(instance
->pdev
,
4282 &instance
->reply_queue_h
);
4284 if (!instance
->reply_queue
) {
4285 printk(KERN_DEBUG
"megasas: Out of DMA mem for reply queue\n");
4286 goto fail_reply_queue
;
4289 if (megasas_issue_init_mfi(instance
))
4292 if (megasas_get_ctrl_info(instance
, instance
->ctrl_info
)) {
4293 dev_err(&instance
->pdev
->dev
, "(%d): Could get controller info "
4294 "Fail from %s %d\n", instance
->unique_id
,
4295 __func__
, __LINE__
);
4299 instance
->fw_support_ieee
= 0;
4300 instance
->fw_support_ieee
=
4301 (instance
->instancet
->read_fw_status_reg(reg_set
) &
4304 printk(KERN_NOTICE
"megasas_init_mfi: fw_support_ieee=%d",
4305 instance
->fw_support_ieee
);
4307 if (instance
->fw_support_ieee
)
4308 instance
->flag_ieee
= 1;
4314 pci_free_consistent(instance
->pdev
, reply_q_sz
,
4315 instance
->reply_queue
, instance
->reply_queue_h
);
4317 megasas_free_cmds(instance
);
4324 * megasas_init_fw - Initializes the FW
4325 * @instance: Adapter soft state
4327 * This is the main function for initializing firmware
4330 static int megasas_init_fw(struct megasas_instance
*instance
)
4334 u32 tmp_sectors
, msix_enable
, scratch_pad_2
;
4335 resource_size_t base_addr
;
4336 struct megasas_register_set __iomem
*reg_set
;
4337 struct megasas_ctrl_info
*ctrl_info
= NULL
;
4338 unsigned long bar_list
;
4339 int i
, loop
, fw_msix_count
= 0;
4340 struct IOV_111
*iovPtr
;
4342 /* Find first memory bar */
4343 bar_list
= pci_select_bars(instance
->pdev
, IORESOURCE_MEM
);
4344 instance
->bar
= find_first_bit(&bar_list
, sizeof(unsigned long));
4345 if (pci_request_selected_regions(instance
->pdev
, instance
->bar
,
4347 printk(KERN_DEBUG
"megasas: IO memory region busy!\n");
4351 base_addr
= pci_resource_start(instance
->pdev
, instance
->bar
);
4352 instance
->reg_set
= ioremap_nocache(base_addr
, 8192);
4354 if (!instance
->reg_set
) {
4355 printk(KERN_DEBUG
"megasas: Failed to map IO mem\n");
4359 reg_set
= instance
->reg_set
;
4361 switch (instance
->pdev
->device
) {
4362 case PCI_DEVICE_ID_LSI_FUSION
:
4363 case PCI_DEVICE_ID_LSI_PLASMA
:
4364 case PCI_DEVICE_ID_LSI_INVADER
:
4365 case PCI_DEVICE_ID_LSI_FURY
:
4366 instance
->instancet
= &megasas_instance_template_fusion
;
4368 case PCI_DEVICE_ID_LSI_SAS1078R
:
4369 case PCI_DEVICE_ID_LSI_SAS1078DE
:
4370 instance
->instancet
= &megasas_instance_template_ppc
;
4372 case PCI_DEVICE_ID_LSI_SAS1078GEN2
:
4373 case PCI_DEVICE_ID_LSI_SAS0079GEN2
:
4374 instance
->instancet
= &megasas_instance_template_gen2
;
4376 case PCI_DEVICE_ID_LSI_SAS0073SKINNY
:
4377 case PCI_DEVICE_ID_LSI_SAS0071SKINNY
:
4378 instance
->instancet
= &megasas_instance_template_skinny
;
4380 case PCI_DEVICE_ID_LSI_SAS1064R
:
4381 case PCI_DEVICE_ID_DELL_PERC5
:
4383 instance
->instancet
= &megasas_instance_template_xscale
;
4387 if (megasas_transition_to_ready(instance
, 0)) {
4388 atomic_set(&instance
->fw_reset_no_pci_access
, 1);
4389 instance
->instancet
->adp_reset
4390 (instance
, instance
->reg_set
);
4391 atomic_set(&instance
->fw_reset_no_pci_access
, 0);
4392 dev_info(&instance
->pdev
->dev
,
4393 "megasas: FW restarted successfully from %s!\n",
4396 /*waitting for about 30 second before retry*/
4399 if (megasas_transition_to_ready(instance
, 0))
4400 goto fail_ready_state
;
4404 * MSI-X host index 0 is common for all adapter.
4405 * It is used for all MPT based Adapters.
4407 instance
->reply_post_host_index_addr
[0] =
4408 (u32
*)((u8
*)instance
->reg_set
+
4409 MPI2_REPLY_POST_HOST_INDEX_OFFSET
);
4411 /* Check if MSI-X is supported while in ready state */
4412 msix_enable
= (instance
->instancet
->read_fw_status_reg(reg_set
) &
4414 if (msix_enable
&& !msix_disable
) {
4415 scratch_pad_2
= readl
4416 (&instance
->reg_set
->outbound_scratch_pad_2
);
4417 /* Check max MSI-X vectors */
4418 if ((instance
->pdev
->device
== PCI_DEVICE_ID_LSI_FUSION
) ||
4419 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_PLASMA
)) {
4420 instance
->msix_vectors
= (scratch_pad_2
4421 & MR_MAX_REPLY_QUEUES_OFFSET
) + 1;
4422 fw_msix_count
= instance
->msix_vectors
;
4424 instance
->msix_vectors
=
4426 instance
->msix_vectors
);
4427 } else if ((instance
->pdev
->device
== PCI_DEVICE_ID_LSI_INVADER
)
4428 || (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_FURY
)) {
4429 /* Invader/Fury supports more than 8 MSI-X */
4430 instance
->msix_vectors
= ((scratch_pad_2
4431 & MR_MAX_REPLY_QUEUES_EXT_OFFSET
)
4432 >> MR_MAX_REPLY_QUEUES_EXT_OFFSET_SHIFT
) + 1;
4433 fw_msix_count
= instance
->msix_vectors
;
4434 /* Save 1-15 reply post index address to local memory
4435 * Index 0 is already saved from reg offset
4436 * MPI2_REPLY_POST_HOST_INDEX_OFFSET
4438 for (loop
= 1; loop
< MR_MAX_MSIX_REG_ARRAY
; loop
++) {
4439 instance
->reply_post_host_index_addr
[loop
] =
4440 (u32
*)((u8
*)instance
->reg_set
+
4441 MPI2_SUP_REPLY_POST_HOST_INDEX_OFFSET
4445 instance
->msix_vectors
= min(msix_vectors
,
4446 instance
->msix_vectors
);
4448 instance
->msix_vectors
= 1;
4449 /* Don't bother allocating more MSI-X vectors than cpus */
4450 instance
->msix_vectors
= min(instance
->msix_vectors
,
4451 (unsigned int)num_online_cpus());
4452 for (i
= 0; i
< instance
->msix_vectors
; i
++)
4453 instance
->msixentry
[i
].entry
= i
;
4454 i
= pci_enable_msix_range(instance
->pdev
, instance
->msixentry
,
4455 1, instance
->msix_vectors
);
4457 instance
->msix_vectors
= i
;
4459 instance
->msix_vectors
= 0;
4461 dev_info(&instance
->pdev
->dev
, "[scsi%d]: FW supports"
4462 "<%d> MSIX vector,Online CPUs: <%d>,"
4463 "Current MSIX <%d>\n", instance
->host
->host_no
,
4464 fw_msix_count
, (unsigned int)num_online_cpus(),
4465 instance
->msix_vectors
);
4468 instance
->ctrl_info
= kzalloc(sizeof(struct megasas_ctrl_info
),
4470 if (instance
->ctrl_info
== NULL
)
4471 goto fail_init_adapter
;
4474 * Below are default value for legacy Firmware.
4475 * non-fusion based controllers
4477 instance
->fw_supported_vd_count
= MAX_LOGICAL_DRIVES
;
4478 instance
->fw_supported_pd_count
= MAX_PHYSICAL_DEVICES
;
4479 /* Get operational params, sge flags, send init cmd to controller */
4480 if (instance
->instancet
->init_adapter(instance
))
4481 goto fail_init_adapter
;
4483 printk(KERN_ERR
"megasas: INIT adapter done\n");
4486 * the following function will get the PD LIST.
4489 memset(instance
->pd_list
, 0 ,
4490 (MEGASAS_MAX_PD
* sizeof(struct megasas_pd_list
)));
4491 if (megasas_get_pd_list(instance
) < 0) {
4492 printk(KERN_ERR
"megasas: failed to get PD list\n");
4493 goto fail_init_adapter
;
4496 memset(instance
->ld_ids
, 0xff, MEGASAS_MAX_LD_IDS
);
4497 if (megasas_ld_list_query(instance
,
4498 MR_LD_QUERY_TYPE_EXPOSED_TO_HOST
))
4499 megasas_get_ld_list(instance
);
4502 * Compute the max allowed sectors per IO: The controller info has two
4503 * limits on max sectors. Driver should use the minimum of these two.
4505 * 1 << stripe_sz_ops.min = max sectors per strip
4507 * Note that older firmwares ( < FW ver 30) didn't report information
4508 * to calculate max_sectors_1. So the number ended up as zero always.
4511 ctrl_info
= instance
->ctrl_info
;
4513 max_sectors_1
= (1 << ctrl_info
->stripe_sz_ops
.min
) *
4514 le16_to_cpu(ctrl_info
->max_strips_per_io
);
4515 max_sectors_2
= le32_to_cpu(ctrl_info
->max_request_size
);
4517 tmp_sectors
= min_t(u32
, max_sectors_1
, max_sectors_2
);
4519 /*Check whether controller is iMR or MR */
4520 if (ctrl_info
->memory_size
) {
4521 instance
->is_imr
= 0;
4522 dev_info(&instance
->pdev
->dev
, "Controller type: MR,"
4523 "Memory size is: %dMB\n",
4524 le16_to_cpu(ctrl_info
->memory_size
));
4526 instance
->is_imr
= 1;
4527 dev_info(&instance
->pdev
->dev
,
4528 "Controller type: iMR\n");
4530 /* OnOffProperties are converted into CPU arch*/
4531 le32_to_cpus((u32
*)&ctrl_info
->properties
.OnOffProperties
);
4532 instance
->disableOnlineCtrlReset
=
4533 ctrl_info
->properties
.OnOffProperties
.disableOnlineCtrlReset
;
4534 /* adapterOperations2 are converted into CPU arch*/
4535 le32_to_cpus((u32
*)&ctrl_info
->adapterOperations2
);
4536 instance
->mpio
= ctrl_info
->adapterOperations2
.mpio
;
4537 instance
->UnevenSpanSupport
=
4538 ctrl_info
->adapterOperations2
.supportUnevenSpans
;
4539 if (instance
->UnevenSpanSupport
) {
4540 struct fusion_context
*fusion
= instance
->ctrl_context
;
4542 dev_info(&instance
->pdev
->dev
, "FW supports: "
4543 "UnevenSpanSupport=%x\n", instance
->UnevenSpanSupport
);
4544 if (MR_ValidateMapInfo(instance
))
4545 fusion
->fast_path_io
= 1;
4547 fusion
->fast_path_io
= 0;
4550 if (ctrl_info
->host_interface
.SRIOV
) {
4551 if (!ctrl_info
->adapterOperations2
.activePassive
)
4552 instance
->PlasmaFW111
= 1;
4554 if (!instance
->PlasmaFW111
)
4555 instance
->requestorId
=
4556 ctrl_info
->iov
.requestorId
;
4558 iovPtr
= (struct IOV_111
*)((unsigned char *)ctrl_info
+ IOV_111_OFFSET
);
4559 instance
->requestorId
= iovPtr
->requestorId
;
4561 dev_warn(&instance
->pdev
->dev
, "I am VF "
4562 "requestorId %d\n", instance
->requestorId
);
4565 le32_to_cpus((u32
*)&ctrl_info
->adapterOperations3
);
4566 instance
->crash_dump_fw_support
=
4567 ctrl_info
->adapterOperations3
.supportCrashDump
;
4568 instance
->crash_dump_drv_support
=
4569 (instance
->crash_dump_fw_support
&&
4570 instance
->crash_dump_buf
);
4571 if (instance
->crash_dump_drv_support
) {
4572 dev_info(&instance
->pdev
->dev
, "Firmware Crash dump "
4573 "feature is supported\n");
4574 megasas_set_crash_dump_params(instance
,
4575 MR_CRASH_BUF_TURN_OFF
);
4578 if (instance
->crash_dump_buf
)
4579 pci_free_consistent(instance
->pdev
,
4581 instance
->crash_dump_buf
,
4582 instance
->crash_dump_h
);
4583 instance
->crash_dump_buf
= NULL
;
4585 instance
->max_sectors_per_req
= instance
->max_num_sge
*
4587 if (tmp_sectors
&& (instance
->max_sectors_per_req
> tmp_sectors
))
4588 instance
->max_sectors_per_req
= tmp_sectors
;
4592 /* Check for valid throttlequeuedepth module parameter */
4593 if (instance
->is_imr
) {
4594 if (throttlequeuedepth
> (instance
->max_fw_cmds
-
4595 MEGASAS_SKINNY_INT_CMDS
))
4596 instance
->throttlequeuedepth
=
4597 MEGASAS_THROTTLE_QUEUE_DEPTH
;
4599 instance
->throttlequeuedepth
= throttlequeuedepth
;
4601 if (throttlequeuedepth
> (instance
->max_fw_cmds
-
4603 instance
->throttlequeuedepth
=
4604 MEGASAS_THROTTLE_QUEUE_DEPTH
;
4606 instance
->throttlequeuedepth
= throttlequeuedepth
;
4610 * Setup tasklet for cmd completion
4613 tasklet_init(&instance
->isr_tasklet
, instance
->instancet
->tasklet
,
4614 (unsigned long)instance
);
4616 /* Launch SR-IOV heartbeat timer */
4617 if (instance
->requestorId
) {
4618 if (!megasas_sriov_start_heartbeat(instance
, 1))
4619 megasas_start_timer(instance
,
4620 &instance
->sriov_heartbeat_timer
,
4621 megasas_sriov_heartbeat_handler
,
4622 MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF
);
4624 instance
->skip_heartbeat_timer_del
= 1;
4631 kfree(instance
->ctrl_info
);
4632 instance
->ctrl_info
= NULL
;
4633 iounmap(instance
->reg_set
);
4636 pci_release_selected_regions(instance
->pdev
, instance
->bar
);
4642 * megasas_release_mfi - Reverses the FW initialization
4643 * @instance: Adapter soft state
4645 static void megasas_release_mfi(struct megasas_instance
*instance
)
4647 u32 reply_q_sz
= sizeof(u32
) *(instance
->max_mfi_cmds
+ 1);
4649 if (instance
->reply_queue
)
4650 pci_free_consistent(instance
->pdev
, reply_q_sz
,
4651 instance
->reply_queue
, instance
->reply_queue_h
);
4653 megasas_free_cmds(instance
);
4655 iounmap(instance
->reg_set
);
4657 pci_release_selected_regions(instance
->pdev
, instance
->bar
);
4661 * megasas_get_seq_num - Gets latest event sequence numbers
4662 * @instance: Adapter soft state
4663 * @eli: FW event log sequence numbers information
4665 * FW maintains a log of all events in a non-volatile area. Upper layers would
4666 * usually find out the latest sequence number of the events, the seq number at
4667 * the boot etc. They would "read" all the events below the latest seq number
4668 * by issuing a direct fw cmd (DCMD). For the future events (beyond latest seq
4669 * number), they would subsribe to AEN (asynchronous event notification) and
4670 * wait for the events to happen.
4673 megasas_get_seq_num(struct megasas_instance
*instance
,
4674 struct megasas_evt_log_info
*eli
)
4676 struct megasas_cmd
*cmd
;
4677 struct megasas_dcmd_frame
*dcmd
;
4678 struct megasas_evt_log_info
*el_info
;
4679 dma_addr_t el_info_h
= 0;
4681 cmd
= megasas_get_cmd(instance
);
4687 dcmd
= &cmd
->frame
->dcmd
;
4688 el_info
= pci_alloc_consistent(instance
->pdev
,
4689 sizeof(struct megasas_evt_log_info
),
4693 megasas_return_cmd(instance
, cmd
);
4697 memset(el_info
, 0, sizeof(*el_info
));
4698 memset(dcmd
->mbox
.b
, 0, MFI_MBOX_SIZE
);
4700 dcmd
->cmd
= MFI_CMD_DCMD
;
4701 dcmd
->cmd_status
= 0x0;
4702 dcmd
->sge_count
= 1;
4703 dcmd
->flags
= cpu_to_le16(MFI_FRAME_DIR_READ
);
4706 dcmd
->data_xfer_len
= cpu_to_le32(sizeof(struct megasas_evt_log_info
));
4707 dcmd
->opcode
= cpu_to_le32(MR_DCMD_CTRL_EVENT_GET_INFO
);
4708 dcmd
->sgl
.sge32
[0].phys_addr
= cpu_to_le32(el_info_h
);
4709 dcmd
->sgl
.sge32
[0].length
= cpu_to_le32(sizeof(struct megasas_evt_log_info
));
4711 if (megasas_issue_blocked_cmd(instance
, cmd
, 30))
4712 dev_err(&instance
->pdev
->dev
, "Command timedout"
4713 "from %s\n", __func__
);
4716 * Copy the data back into callers buffer
4718 eli
->newest_seq_num
= le32_to_cpu(el_info
->newest_seq_num
);
4719 eli
->oldest_seq_num
= le32_to_cpu(el_info
->oldest_seq_num
);
4720 eli
->clear_seq_num
= le32_to_cpu(el_info
->clear_seq_num
);
4721 eli
->shutdown_seq_num
= le32_to_cpu(el_info
->shutdown_seq_num
);
4722 eli
->boot_seq_num
= le32_to_cpu(el_info
->boot_seq_num
);
4725 pci_free_consistent(instance
->pdev
, sizeof(struct megasas_evt_log_info
),
4726 el_info
, el_info_h
);
4728 if (instance
->ctrl_context
&& cmd
->mpt_pthr_cmd_blocked
)
4729 megasas_return_mfi_mpt_pthr(instance
, cmd
,
4730 cmd
->mpt_pthr_cmd_blocked
);
4732 megasas_return_cmd(instance
, cmd
);
4738 * megasas_register_aen - Registers for asynchronous event notification
4739 * @instance: Adapter soft state
4740 * @seq_num: The starting sequence number
4741 * @class_locale: Class of the event
4743 * This function subscribes for AEN for events beyond the @seq_num. It requests
4744 * to be notified if and only if the event is of type @class_locale
4747 megasas_register_aen(struct megasas_instance
*instance
, u32 seq_num
,
4748 u32 class_locale_word
)
4751 struct megasas_cmd
*cmd
;
4752 struct megasas_dcmd_frame
*dcmd
;
4753 union megasas_evt_class_locale curr_aen
;
4754 union megasas_evt_class_locale prev_aen
;
4757 * If there an AEN pending already (aen_cmd), check if the
4758 * class_locale of that pending AEN is inclusive of the new
4759 * AEN request we currently have. If it is, then we don't have
4760 * to do anything. In other words, whichever events the current
4761 * AEN request is subscribing to, have already been subscribed
4764 * If the old_cmd is _not_ inclusive, then we have to abort
4765 * that command, form a class_locale that is superset of both
4766 * old and current and re-issue to the FW
4769 curr_aen
.word
= class_locale_word
;
4771 if (instance
->aen_cmd
) {
4773 prev_aen
.word
= instance
->aen_cmd
->frame
->dcmd
.mbox
.w
[1];
4774 prev_aen
.members
.locale
= le16_to_cpu(prev_aen
.members
.locale
);
4777 * A class whose enum value is smaller is inclusive of all
4778 * higher values. If a PROGRESS (= -1) was previously
4779 * registered, then a new registration requests for higher
4780 * classes need not be sent to FW. They are automatically
4783 * Locale numbers don't have such hierarchy. They are bitmap
4786 if ((prev_aen
.members
.class <= curr_aen
.members
.class) &&
4787 !((prev_aen
.members
.locale
& curr_aen
.members
.locale
) ^
4788 curr_aen
.members
.locale
)) {
4790 * Previously issued event registration includes
4791 * current request. Nothing to do.
4795 curr_aen
.members
.locale
|= prev_aen
.members
.locale
;
4797 if (prev_aen
.members
.class < curr_aen
.members
.class)
4798 curr_aen
.members
.class = prev_aen
.members
.class;
4800 instance
->aen_cmd
->abort_aen
= 1;
4801 ret_val
= megasas_issue_blocked_abort_cmd(instance
,
4806 printk(KERN_DEBUG
"megasas: Failed to abort "
4807 "previous AEN command\n");
4813 cmd
= megasas_get_cmd(instance
);
4818 dcmd
= &cmd
->frame
->dcmd
;
4820 memset(instance
->evt_detail
, 0, sizeof(struct megasas_evt_detail
));
4823 * Prepare DCMD for aen registration
4825 memset(dcmd
->mbox
.b
, 0, MFI_MBOX_SIZE
);
4827 dcmd
->cmd
= MFI_CMD_DCMD
;
4828 dcmd
->cmd_status
= 0x0;
4829 dcmd
->sge_count
= 1;
4830 dcmd
->flags
= cpu_to_le16(MFI_FRAME_DIR_READ
);
4833 dcmd
->data_xfer_len
= cpu_to_le32(sizeof(struct megasas_evt_detail
));
4834 dcmd
->opcode
= cpu_to_le32(MR_DCMD_CTRL_EVENT_WAIT
);
4835 dcmd
->mbox
.w
[0] = cpu_to_le32(seq_num
);
4836 instance
->last_seq_num
= seq_num
;
4837 dcmd
->mbox
.w
[1] = cpu_to_le32(curr_aen
.word
);
4838 dcmd
->sgl
.sge32
[0].phys_addr
= cpu_to_le32(instance
->evt_detail_h
);
4839 dcmd
->sgl
.sge32
[0].length
= cpu_to_le32(sizeof(struct megasas_evt_detail
));
4841 if (instance
->aen_cmd
!= NULL
) {
4842 megasas_return_cmd(instance
, cmd
);
4847 * Store reference to the cmd used to register for AEN. When an
4848 * application wants us to register for AEN, we have to abort this
4849 * cmd and re-register with a new EVENT LOCALE supplied by that app
4851 instance
->aen_cmd
= cmd
;
4854 * Issue the aen registration frame
4856 instance
->instancet
->issue_dcmd(instance
, cmd
);
4862 * megasas_start_aen - Subscribes to AEN during driver load time
4863 * @instance: Adapter soft state
4865 static int megasas_start_aen(struct megasas_instance
*instance
)
4867 struct megasas_evt_log_info eli
;
4868 union megasas_evt_class_locale class_locale
;
4871 * Get the latest sequence number from FW
4873 memset(&eli
, 0, sizeof(eli
));
4875 if (megasas_get_seq_num(instance
, &eli
))
4879 * Register AEN with FW for latest sequence number plus 1
4881 class_locale
.members
.reserved
= 0;
4882 class_locale
.members
.locale
= MR_EVT_LOCALE_ALL
;
4883 class_locale
.members
.class = MR_EVT_CLASS_DEBUG
;
4885 return megasas_register_aen(instance
,
4886 eli
.newest_seq_num
+ 1,
4891 * megasas_io_attach - Attaches this driver to SCSI mid-layer
4892 * @instance: Adapter soft state
4894 static int megasas_io_attach(struct megasas_instance
*instance
)
4896 struct Scsi_Host
*host
= instance
->host
;
4899 * Export parameters required by SCSI mid-layer
4901 host
->irq
= instance
->pdev
->irq
;
4902 host
->unique_id
= instance
->unique_id
;
4903 if (instance
->is_imr
) {
4905 instance
->max_fw_cmds
- MEGASAS_SKINNY_INT_CMDS
;
4908 instance
->max_fw_cmds
- MEGASAS_INT_CMDS
;
4909 host
->this_id
= instance
->init_id
;
4910 host
->sg_tablesize
= instance
->max_num_sge
;
4912 if (instance
->fw_support_ieee
)
4913 instance
->max_sectors_per_req
= MEGASAS_MAX_SECTORS_IEEE
;
4916 * Check if the module parameter value for max_sectors can be used
4918 if (max_sectors
&& max_sectors
< instance
->max_sectors_per_req
)
4919 instance
->max_sectors_per_req
= max_sectors
;
4922 if (((instance
->pdev
->device
==
4923 PCI_DEVICE_ID_LSI_SAS1078GEN2
) ||
4924 (instance
->pdev
->device
==
4925 PCI_DEVICE_ID_LSI_SAS0079GEN2
)) &&
4926 (max_sectors
<= MEGASAS_MAX_SECTORS
)) {
4927 instance
->max_sectors_per_req
= max_sectors
;
4929 printk(KERN_INFO
"megasas: max_sectors should be > 0"
4930 "and <= %d (or < 1MB for GEN2 controller)\n",
4931 instance
->max_sectors_per_req
);
4936 host
->max_sectors
= instance
->max_sectors_per_req
;
4937 host
->cmd_per_lun
= MEGASAS_DEFAULT_CMD_PER_LUN
;
4938 host
->max_channel
= MEGASAS_MAX_CHANNELS
- 1;
4939 host
->max_id
= MEGASAS_MAX_DEV_PER_CHANNEL
;
4940 host
->max_lun
= MEGASAS_MAX_LUN
;
4941 host
->max_cmd_len
= 16;
4943 /* Fusion only supports host reset */
4944 if ((instance
->pdev
->device
== PCI_DEVICE_ID_LSI_FUSION
) ||
4945 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_PLASMA
) ||
4946 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_INVADER
) ||
4947 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_FURY
)) {
4948 host
->hostt
->eh_device_reset_handler
= NULL
;
4949 host
->hostt
->eh_bus_reset_handler
= NULL
;
4953 * Notify the mid-layer about the new controller
4955 if (scsi_add_host(host
, &instance
->pdev
->dev
)) {
4956 printk(KERN_DEBUG
"megasas: scsi_add_host failed\n");
4961 * Trigger SCSI to scan our drives
4963 scsi_scan_host(host
);
4968 megasas_set_dma_mask(struct pci_dev
*pdev
)
4971 * All our contollers are capable of performing 64-bit DMA
4974 if (pci_set_dma_mask(pdev
, DMA_BIT_MASK(64)) != 0) {
4976 if (pci_set_dma_mask(pdev
, DMA_BIT_MASK(32)) != 0)
4977 goto fail_set_dma_mask
;
4980 if (pci_set_dma_mask(pdev
, DMA_BIT_MASK(32)) != 0)
4981 goto fail_set_dma_mask
;
4984 * Ensure that all data structures are allocated in 32-bit
4987 if (pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32)) != 0) {
4988 /* Try 32bit DMA mask and 32 bit Consistent dma mask */
4989 if (!pci_set_dma_mask(pdev
, DMA_BIT_MASK(32))
4990 && !pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32)))
4991 dev_info(&pdev
->dev
, "set 32bit DMA mask"
4992 "and 32 bit consistent mask\n");
4994 goto fail_set_dma_mask
;
5004 * megasas_probe_one - PCI hotplug entry point
5005 * @pdev: PCI device structure
5006 * @id: PCI ids of supported hotplugged adapter
5008 static int megasas_probe_one(struct pci_dev
*pdev
,
5009 const struct pci_device_id
*id
)
5011 int rval
, pos
, i
, j
, cpu
;
5012 struct Scsi_Host
*host
;
5013 struct megasas_instance
*instance
;
5015 struct fusion_context
*fusion
= NULL
;
5017 /* Reset MSI-X in the kdump kernel */
5018 if (reset_devices
) {
5019 pos
= pci_find_capability(pdev
, PCI_CAP_ID_MSIX
);
5021 pci_read_config_word(pdev
, pos
+ PCI_MSIX_FLAGS
,
5023 if (control
& PCI_MSIX_FLAGS_ENABLE
) {
5024 dev_info(&pdev
->dev
, "resetting MSI-X\n");
5025 pci_write_config_word(pdev
,
5026 pos
+ PCI_MSIX_FLAGS
,
5028 ~PCI_MSIX_FLAGS_ENABLE
);
5034 * Announce PCI information
5036 printk(KERN_INFO
"megasas: %#4.04x:%#4.04x:%#4.04x:%#4.04x: ",
5037 pdev
->vendor
, pdev
->device
, pdev
->subsystem_vendor
,
5038 pdev
->subsystem_device
);
5040 printk("bus %d:slot %d:func %d\n",
5041 pdev
->bus
->number
, PCI_SLOT(pdev
->devfn
), PCI_FUNC(pdev
->devfn
));
5044 * PCI prepping: enable device set bus mastering and dma mask
5046 rval
= pci_enable_device_mem(pdev
);
5052 pci_set_master(pdev
);
5054 if (megasas_set_dma_mask(pdev
))
5055 goto fail_set_dma_mask
;
5057 host
= scsi_host_alloc(&megasas_template
,
5058 sizeof(struct megasas_instance
));
5061 printk(KERN_DEBUG
"megasas: scsi_host_alloc failed\n");
5062 goto fail_alloc_instance
;
5065 instance
= (struct megasas_instance
*)host
->hostdata
;
5066 memset(instance
, 0, sizeof(*instance
));
5067 atomic_set( &instance
->fw_reset_no_pci_access
, 0 );
5068 instance
->pdev
= pdev
;
5070 switch (instance
->pdev
->device
) {
5071 case PCI_DEVICE_ID_LSI_FUSION
:
5072 case PCI_DEVICE_ID_LSI_PLASMA
:
5073 case PCI_DEVICE_ID_LSI_INVADER
:
5074 case PCI_DEVICE_ID_LSI_FURY
:
5076 instance
->ctrl_context_pages
=
5077 get_order(sizeof(struct fusion_context
));
5078 instance
->ctrl_context
= (void *)__get_free_pages(GFP_KERNEL
,
5079 instance
->ctrl_context_pages
);
5080 if (!instance
->ctrl_context
) {
5081 printk(KERN_DEBUG
"megasas: Failed to allocate "
5082 "memory for Fusion context info\n");
5083 goto fail_alloc_dma_buf
;
5085 fusion
= instance
->ctrl_context
;
5086 INIT_LIST_HEAD(&fusion
->cmd_pool
);
5087 spin_lock_init(&fusion
->mpt_pool_lock
);
5088 memset(fusion
->load_balance_info
, 0,
5089 sizeof(struct LD_LOAD_BALANCE_INFO
) * MAX_LOGICAL_DRIVES_EXT
);
5092 default: /* For all other supported controllers */
5094 instance
->producer
=
5095 pci_alloc_consistent(pdev
, sizeof(u32
),
5096 &instance
->producer_h
);
5097 instance
->consumer
=
5098 pci_alloc_consistent(pdev
, sizeof(u32
),
5099 &instance
->consumer_h
);
5101 if (!instance
->producer
|| !instance
->consumer
) {
5102 printk(KERN_DEBUG
"megasas: Failed to allocate"
5103 "memory for producer, consumer\n");
5104 goto fail_alloc_dma_buf
;
5107 *instance
->producer
= 0;
5108 *instance
->consumer
= 0;
5112 /* Crash dump feature related initialisation*/
5113 instance
->drv_buf_index
= 0;
5114 instance
->drv_buf_alloc
= 0;
5115 instance
->crash_dump_fw_support
= 0;
5116 instance
->crash_dump_app_support
= 0;
5117 instance
->fw_crash_state
= UNAVAILABLE
;
5118 spin_lock_init(&instance
->crashdump_lock
);
5119 instance
->crash_dump_buf
= NULL
;
5122 instance
->crash_dump_buf
= pci_alloc_consistent(pdev
,
5124 &instance
->crash_dump_h
);
5125 if (!instance
->crash_dump_buf
)
5126 dev_err(&instance
->pdev
->dev
, "Can't allocate Firmware "
5127 "crash dump DMA buffer\n");
5129 megasas_poll_wait_aen
= 0;
5130 instance
->flag_ieee
= 0;
5131 instance
->ev
= NULL
;
5132 instance
->issuepend_done
= 1;
5133 instance
->adprecovery
= MEGASAS_HBA_OPERATIONAL
;
5134 instance
->is_imr
= 0;
5136 instance
->evt_detail
= pci_alloc_consistent(pdev
,
5138 megasas_evt_detail
),
5139 &instance
->evt_detail_h
);
5141 if (!instance
->evt_detail
) {
5142 printk(KERN_DEBUG
"megasas: Failed to allocate memory for "
5143 "event detail structure\n");
5144 goto fail_alloc_dma_buf
;
5148 * Initialize locks and queues
5150 INIT_LIST_HEAD(&instance
->cmd_pool
);
5151 INIT_LIST_HEAD(&instance
->internal_reset_pending_q
);
5153 atomic_set(&instance
->fw_outstanding
,0);
5155 init_waitqueue_head(&instance
->int_cmd_wait_q
);
5156 init_waitqueue_head(&instance
->abort_cmd_wait_q
);
5158 spin_lock_init(&instance
->mfi_pool_lock
);
5159 spin_lock_init(&instance
->hba_lock
);
5160 spin_lock_init(&instance
->completion_lock
);
5162 mutex_init(&instance
->aen_mutex
);
5163 mutex_init(&instance
->reset_mutex
);
5166 * Initialize PCI related and misc parameters
5168 instance
->host
= host
;
5169 instance
->unique_id
= pdev
->bus
->number
<< 8 | pdev
->devfn
;
5170 instance
->init_id
= MEGASAS_DEFAULT_INIT_ID
;
5171 instance
->ctrl_info
= NULL
;
5173 if ((instance
->pdev
->device
== PCI_DEVICE_ID_LSI_SAS0073SKINNY
) ||
5174 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_SAS0071SKINNY
)) {
5175 instance
->flag_ieee
= 1;
5176 sema_init(&instance
->ioctl_sem
, MEGASAS_SKINNY_INT_CMDS
);
5178 sema_init(&instance
->ioctl_sem
, (MEGASAS_INT_CMDS
- 5));
5180 megasas_dbg_lvl
= 0;
5182 instance
->unload
= 1;
5183 instance
->last_time
= 0;
5184 instance
->disableOnlineCtrlReset
= 1;
5185 instance
->UnevenSpanSupport
= 0;
5187 if ((instance
->pdev
->device
== PCI_DEVICE_ID_LSI_FUSION
) ||
5188 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_PLASMA
) ||
5189 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_INVADER
) ||
5190 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_FURY
)) {
5191 INIT_WORK(&instance
->work_init
, megasas_fusion_ocr_wq
);
5192 INIT_WORK(&instance
->crash_init
, megasas_fusion_crash_dump_wq
);
5194 INIT_WORK(&instance
->work_init
, process_fw_state_change_wq
);
5197 * Initialize MFI Firmware
5199 if (megasas_init_fw(instance
))
5202 if (instance
->requestorId
) {
5203 if (instance
->PlasmaFW111
) {
5204 instance
->vf_affiliation_111
=
5205 pci_alloc_consistent(pdev
, sizeof(struct MR_LD_VF_AFFILIATION_111
),
5206 &instance
->vf_affiliation_111_h
);
5207 if (!instance
->vf_affiliation_111
)
5208 printk(KERN_WARNING
"megasas: Can't allocate "
5209 "memory for VF affiliation buffer\n");
5211 instance
->vf_affiliation
=
5212 pci_alloc_consistent(pdev
,
5213 (MAX_LOGICAL_DRIVES
+ 1) *
5214 sizeof(struct MR_LD_VF_AFFILIATION
),
5215 &instance
->vf_affiliation_h
);
5216 if (!instance
->vf_affiliation
)
5217 printk(KERN_WARNING
"megasas: Can't allocate "
5218 "memory for VF affiliation buffer\n");
5226 if (instance
->msix_vectors
) {
5227 cpu
= cpumask_first(cpu_online_mask
);
5228 for (i
= 0; i
< instance
->msix_vectors
; i
++) {
5229 instance
->irq_context
[i
].instance
= instance
;
5230 instance
->irq_context
[i
].MSIxIndex
= i
;
5231 if (request_irq(instance
->msixentry
[i
].vector
,
5232 instance
->instancet
->service_isr
, 0,
5234 &instance
->irq_context
[i
])) {
5235 printk(KERN_DEBUG
"megasas: Failed to "
5236 "register IRQ for vector %d.\n", i
);
5237 for (j
= 0; j
< i
; j
++) {
5238 if (smp_affinity_enable
)
5239 irq_set_affinity_hint(
5240 instance
->msixentry
[j
].vector
, NULL
);
5242 instance
->msixentry
[j
].vector
,
5243 &instance
->irq_context
[j
]);
5245 /* Retry irq register for IO_APIC */
5246 instance
->msix_vectors
= 0;
5247 goto retry_irq_register
;
5249 if (smp_affinity_enable
) {
5250 if (irq_set_affinity_hint(instance
->msixentry
[i
].vector
,
5252 dev_err(&instance
->pdev
->dev
,
5253 "Error setting affinity hint "
5254 "for cpu %d\n", cpu
);
5255 cpu
= cpumask_next(cpu
, cpu_online_mask
);
5259 instance
->irq_context
[0].instance
= instance
;
5260 instance
->irq_context
[0].MSIxIndex
= 0;
5261 if (request_irq(pdev
->irq
, instance
->instancet
->service_isr
,
5262 IRQF_SHARED
, "megasas",
5263 &instance
->irq_context
[0])) {
5264 printk(KERN_DEBUG
"megasas: Failed to register IRQ\n");
5269 instance
->instancet
->enable_intr(instance
);
5272 * Store instance in PCI softstate
5274 pci_set_drvdata(pdev
, instance
);
5277 * Add this controller to megasas_mgmt_info structure so that it
5278 * can be exported to management applications
5280 megasas_mgmt_info
.count
++;
5281 megasas_mgmt_info
.instance
[megasas_mgmt_info
.max_index
] = instance
;
5282 megasas_mgmt_info
.max_index
++;
5285 * Register with SCSI mid-layer
5287 if (megasas_io_attach(instance
))
5288 goto fail_io_attach
;
5290 instance
->unload
= 0;
5293 * Initiate AEN (Asynchronous Event Notification)
5295 if (megasas_start_aen(instance
)) {
5296 printk(KERN_DEBUG
"megasas: start aen failed\n");
5297 goto fail_start_aen
;
5300 /* Get current SR-IOV LD/VF affiliation */
5301 if (instance
->requestorId
)
5302 megasas_get_ld_vf_affiliation(instance
, 1);
5308 megasas_mgmt_info
.count
--;
5309 megasas_mgmt_info
.instance
[megasas_mgmt_info
.max_index
] = NULL
;
5310 megasas_mgmt_info
.max_index
--;
5312 instance
->instancet
->disable_intr(instance
);
5313 if (instance
->msix_vectors
)
5314 for (i
= 0; i
< instance
->msix_vectors
; i
++) {
5315 if (smp_affinity_enable
)
5316 irq_set_affinity_hint(
5317 instance
->msixentry
[i
].vector
, NULL
);
5318 free_irq(instance
->msixentry
[i
].vector
,
5319 &instance
->irq_context
[i
]);
5322 free_irq(instance
->pdev
->irq
, &instance
->irq_context
[0]);
5324 if ((instance
->pdev
->device
== PCI_DEVICE_ID_LSI_FUSION
) ||
5325 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_PLASMA
) ||
5326 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_INVADER
) ||
5327 (instance
->pdev
->device
== PCI_DEVICE_ID_LSI_FURY
))
5328 megasas_release_fusion(instance
);
5330 megasas_release_mfi(instance
);
5332 if (instance
->msix_vectors
)
5333 pci_disable_msix(instance
->pdev
);
5335 if (instance
->evt_detail
)
5336 pci_free_consistent(pdev
, sizeof(struct megasas_evt_detail
),
5337 instance
->evt_detail
,
5338 instance
->evt_detail_h
);
5340 if (instance
->producer
)
5341 pci_free_consistent(pdev
, sizeof(u32
), instance
->producer
,
5342 instance
->producer_h
);
5343 if (instance
->consumer
)
5344 pci_free_consistent(pdev
, sizeof(u32
), instance
->consumer
,
5345 instance
->consumer_h
);
5346 scsi_host_put(host
);
5348 fail_alloc_instance
:
5350 pci_disable_device(pdev
);
5356 * megasas_flush_cache - Requests FW to flush all its caches
5357 * @instance: Adapter soft state
5359 static void megasas_flush_cache(struct megasas_instance
*instance
)
5361 struct megasas_cmd
*cmd
;
5362 struct megasas_dcmd_frame
*dcmd
;
5364 if (instance
->adprecovery
== MEGASAS_HW_CRITICAL_ERROR
)
5367 cmd
= megasas_get_cmd(instance
);
5372 dcmd
= &cmd
->frame
->dcmd
;
5374 memset(dcmd
->mbox
.b
, 0, MFI_MBOX_SIZE
);
5376 dcmd
->cmd
= MFI_CMD_DCMD
;
5377 dcmd
->cmd_status
= 0x0;
5378 dcmd
->sge_count
= 0;
5379 dcmd
->flags
= cpu_to_le16(MFI_FRAME_DIR_NONE
);
5382 dcmd
->data_xfer_len
= 0;
5383 dcmd
->opcode
= cpu_to_le32(MR_DCMD_CTRL_CACHE_FLUSH
);
5384 dcmd
->mbox
.b
[0] = MR_FLUSH_CTRL_CACHE
| MR_FLUSH_DISK_CACHE
;
5386 if (megasas_issue_blocked_cmd(instance
, cmd
, 30))
5387 dev_err(&instance
->pdev
->dev
, "Command timedout"
5388 " from %s\n", __func__
);
5390 if (instance
->ctrl_context
&& cmd
->mpt_pthr_cmd_blocked
)
5391 megasas_return_mfi_mpt_pthr(instance
, cmd
,
5392 cmd
->mpt_pthr_cmd_blocked
);
5394 megasas_return_cmd(instance
, cmd
);
5400 * megasas_shutdown_controller - Instructs FW to shutdown the controller
5401 * @instance: Adapter soft state
5402 * @opcode: Shutdown/Hibernate
5404 static void megasas_shutdown_controller(struct megasas_instance
*instance
,
5407 struct megasas_cmd
*cmd
;
5408 struct megasas_dcmd_frame
*dcmd
;
5410 if (instance
->adprecovery
== MEGASAS_HW_CRITICAL_ERROR
)
5413 cmd
= megasas_get_cmd(instance
);
5418 if (instance
->aen_cmd
)
5419 megasas_issue_blocked_abort_cmd(instance
,
5420 instance
->aen_cmd
, 30);
5421 if (instance
->map_update_cmd
)
5422 megasas_issue_blocked_abort_cmd(instance
,
5423 instance
->map_update_cmd
, 30);
5424 dcmd
= &cmd
->frame
->dcmd
;
5426 memset(dcmd
->mbox
.b
, 0, MFI_MBOX_SIZE
);
5428 dcmd
->cmd
= MFI_CMD_DCMD
;
5429 dcmd
->cmd_status
= 0x0;
5430 dcmd
->sge_count
= 0;
5431 dcmd
->flags
= cpu_to_le16(MFI_FRAME_DIR_NONE
);
5434 dcmd
->data_xfer_len
= 0;
5435 dcmd
->opcode
= cpu_to_le32(opcode
);
5437 if (megasas_issue_blocked_cmd(instance
, cmd
, 30))
5438 dev_err(&instance
->pdev
->dev
, "Command timedout"
5439 "from %s\n", __func__
);
5441 if (instance
->ctrl_context
&& cmd
->mpt_pthr_cmd_blocked
)
5442 megasas_return_mfi_mpt_pthr(instance
, cmd
,
5443 cmd
->mpt_pthr_cmd_blocked
);
5445 megasas_return_cmd(instance
, cmd
);
5452 * megasas_suspend - driver suspend entry point
5453 * @pdev: PCI device structure
5454 * @state: PCI power state to suspend routine
5457 megasas_suspend(struct pci_dev
*pdev
, pm_message_t state
)
5459 struct Scsi_Host
*host
;
5460 struct megasas_instance
*instance
;
5463 instance
= pci_get_drvdata(pdev
);
5464 host
= instance
->host
;
5465 instance
->unload
= 1;
5467 /* Shutdown SR-IOV heartbeat timer */
5468 if (instance
->requestorId
&& !instance
->skip_heartbeat_timer_del
)
5469 del_timer_sync(&instance
->sriov_heartbeat_timer
);
5471 megasas_flush_cache(instance
);
5472 megasas_shutdown_controller(instance
, MR_DCMD_HIBERNATE_SHUTDOWN
);
5474 /* cancel the delayed work if this work still in queue */
5475 if (instance
->ev
!= NULL
) {
5476 struct megasas_aen_event
*ev
= instance
->ev
;
5477 cancel_delayed_work_sync(&ev
->hotplug_work
);
5478 instance
->ev
= NULL
;
5481 tasklet_kill(&instance
->isr_tasklet
);
5483 pci_set_drvdata(instance
->pdev
, instance
);
5484 instance
->instancet
->disable_intr(instance
);
5486 if (instance
->msix_vectors
)
5487 for (i
= 0; i
< instance
->msix_vectors
; i
++) {
5488 if (smp_affinity_enable
)
5489 irq_set_affinity_hint(
5490 instance
->msixentry
[i
].vector
, NULL
);
5491 free_irq(instance
->msixentry
[i
].vector
,
5492 &instance
->irq_context
[i
]);
5495 free_irq(instance
->pdev
->irq
, &instance
->irq_context
[0]);
5496 if (instance
->msix_vectors
)
5497 pci_disable_msix(instance
->pdev
);
5499 pci_save_state(pdev
);
5500 pci_disable_device(pdev
);
5502 pci_set_power_state(pdev
, pci_choose_state(pdev
, state
));
5508 * megasas_resume- driver resume entry point
5509 * @pdev: PCI device structure
5512 megasas_resume(struct pci_dev
*pdev
)
5514 int rval
, i
, j
, cpu
;
5515 struct Scsi_Host
*host
;
5516 struct megasas_instance
*instance
;
5518 instance
= pci_get_drvdata(pdev
);
5519 host
= instance
->host
;
5520 pci_set_power_state(pdev
, PCI_D0
);
5521 pci_enable_wake(pdev
, PCI_D0
, 0);
5522 pci_restore_state(pdev
);
5525 * PCI prepping: enable device set bus mastering and dma mask
5527 rval
= pci_enable_device_mem(pdev
);
5530 printk(KERN_ERR
"megasas: Enable device failed\n");
5534 pci_set_master(pdev
);
5536 if (megasas_set_dma_mask(pdev
))
5537 goto fail_set_dma_mask
;
5540 * Initialize MFI Firmware
5543 atomic_set(&instance
->fw_outstanding
, 0);
5546 * We expect the FW state to be READY
5548 if (megasas_transition_to_ready(instance
, 0))
5549 goto fail_ready_state
;
5551 /* Now re-enable MSI-X */
5552 if (instance
->msix_vectors
&&
5553 pci_enable_msix_exact(instance
->pdev
, instance
->msixentry
,
5554 instance
->msix_vectors
))
5555 goto fail_reenable_msix
;
5557 switch (instance
->pdev
->device
) {
5558 case PCI_DEVICE_ID_LSI_FUSION
:
5559 case PCI_DEVICE_ID_LSI_PLASMA
:
5560 case PCI_DEVICE_ID_LSI_INVADER
:
5561 case PCI_DEVICE_ID_LSI_FURY
:
5563 megasas_reset_reply_desc(instance
);
5564 if (megasas_ioc_init_fusion(instance
)) {
5565 megasas_free_cmds(instance
);
5566 megasas_free_cmds_fusion(instance
);
5569 if (!megasas_get_map_info(instance
))
5570 megasas_sync_map_info(instance
);
5574 *instance
->producer
= 0;
5575 *instance
->consumer
= 0;
5576 if (megasas_issue_init_mfi(instance
))
5581 tasklet_init(&instance
->isr_tasklet
, instance
->instancet
->tasklet
,
5582 (unsigned long)instance
);
5587 if (instance
->msix_vectors
) {
5588 cpu
= cpumask_first(cpu_online_mask
);
5589 for (i
= 0 ; i
< instance
->msix_vectors
; i
++) {
5590 instance
->irq_context
[i
].instance
= instance
;
5591 instance
->irq_context
[i
].MSIxIndex
= i
;
5592 if (request_irq(instance
->msixentry
[i
].vector
,
5593 instance
->instancet
->service_isr
, 0,
5595 &instance
->irq_context
[i
])) {
5596 printk(KERN_DEBUG
"megasas: Failed to "
5597 "register IRQ for vector %d.\n", i
);
5598 for (j
= 0; j
< i
; j
++) {
5599 if (smp_affinity_enable
)
5600 irq_set_affinity_hint(
5601 instance
->msixentry
[j
].vector
, NULL
);
5603 instance
->msixentry
[j
].vector
,
5604 &instance
->irq_context
[j
]);
5609 if (smp_affinity_enable
) {
5610 if (irq_set_affinity_hint(instance
->msixentry
[i
].vector
,
5612 dev_err(&instance
->pdev
->dev
, "Error "
5613 "setting affinity hint for cpu "
5615 cpu
= cpumask_next(cpu
, cpu_online_mask
);
5619 instance
->irq_context
[0].instance
= instance
;
5620 instance
->irq_context
[0].MSIxIndex
= 0;
5621 if (request_irq(pdev
->irq
, instance
->instancet
->service_isr
,
5622 IRQF_SHARED
, "megasas",
5623 &instance
->irq_context
[0])) {
5624 printk(KERN_DEBUG
"megasas: Failed to register IRQ\n");
5629 /* Re-launch SR-IOV heartbeat timer */
5630 if (instance
->requestorId
) {
5631 if (!megasas_sriov_start_heartbeat(instance
, 0))
5632 megasas_start_timer(instance
,
5633 &instance
->sriov_heartbeat_timer
,
5634 megasas_sriov_heartbeat_handler
,
5635 MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF
);
5637 instance
->skip_heartbeat_timer_del
= 1;
5640 instance
->instancet
->enable_intr(instance
);
5641 instance
->unload
= 0;
5644 * Initiate AEN (Asynchronous Event Notification)
5646 if (megasas_start_aen(instance
))
5647 printk(KERN_ERR
"megasas: Start AEN failed\n");
5653 if (instance
->evt_detail
)
5654 pci_free_consistent(pdev
, sizeof(struct megasas_evt_detail
),
5655 instance
->evt_detail
,
5656 instance
->evt_detail_h
);
5658 if (instance
->producer
)
5659 pci_free_consistent(pdev
, sizeof(u32
), instance
->producer
,
5660 instance
->producer_h
);
5661 if (instance
->consumer
)
5662 pci_free_consistent(pdev
, sizeof(u32
), instance
->consumer
,
5663 instance
->consumer_h
);
5664 scsi_host_put(host
);
5670 pci_disable_device(pdev
);
5675 #define megasas_suspend NULL
5676 #define megasas_resume NULL
5680 * megasas_detach_one - PCI hot"un"plug entry point
5681 * @pdev: PCI device structure
5683 static void megasas_detach_one(struct pci_dev
*pdev
)
5686 struct Scsi_Host
*host
;
5687 struct megasas_instance
*instance
;
5688 struct fusion_context
*fusion
;
5690 instance
= pci_get_drvdata(pdev
);
5691 instance
->unload
= 1;
5692 host
= instance
->host
;
5693 fusion
= instance
->ctrl_context
;
5695 /* Shutdown SR-IOV heartbeat timer */
5696 if (instance
->requestorId
&& !instance
->skip_heartbeat_timer_del
)
5697 del_timer_sync(&instance
->sriov_heartbeat_timer
);
5699 if (instance
->fw_crash_state
!= UNAVAILABLE
)
5700 megasas_free_host_crash_buffer(instance
);
5701 scsi_remove_host(instance
->host
);
5702 megasas_flush_cache(instance
);
5703 megasas_shutdown_controller(instance
, MR_DCMD_CTRL_SHUTDOWN
);
5705 /* cancel the delayed work if this work still in queue*/
5706 if (instance
->ev
!= NULL
) {
5707 struct megasas_aen_event
*ev
= instance
->ev
;
5708 cancel_delayed_work_sync(&ev
->hotplug_work
);
5709 instance
->ev
= NULL
;
5712 /* cancel all wait events */
5713 wake_up_all(&instance
->int_cmd_wait_q
);
5715 tasklet_kill(&instance
->isr_tasklet
);
5718 * Take the instance off the instance array. Note that we will not
5719 * decrement the max_index. We let this array be sparse array
5721 for (i
= 0; i
< megasas_mgmt_info
.max_index
; i
++) {
5722 if (megasas_mgmt_info
.instance
[i
] == instance
) {
5723 megasas_mgmt_info
.count
--;
5724 megasas_mgmt_info
.instance
[i
] = NULL
;
5730 instance
->instancet
->disable_intr(instance
);
5732 if (instance
->msix_vectors
)
5733 for (i
= 0; i
< instance
->msix_vectors
; i
++) {
5734 if (smp_affinity_enable
)
5735 irq_set_affinity_hint(
5736 instance
->msixentry
[i
].vector
, NULL
);
5737 free_irq(instance
->msixentry
[i
].vector
,
5738 &instance
->irq_context
[i
]);
5741 free_irq(instance
->pdev
->irq
, &instance
->irq_context
[0]);
5742 if (instance
->msix_vectors
)
5743 pci_disable_msix(instance
->pdev
);
5745 switch (instance
->pdev
->device
) {
5746 case PCI_DEVICE_ID_LSI_FUSION
:
5747 case PCI_DEVICE_ID_LSI_PLASMA
:
5748 case PCI_DEVICE_ID_LSI_INVADER
:
5749 case PCI_DEVICE_ID_LSI_FURY
:
5750 megasas_release_fusion(instance
);
5751 for (i
= 0; i
< 2 ; i
++) {
5752 if (fusion
->ld_map
[i
])
5753 dma_free_coherent(&instance
->pdev
->dev
,
5756 fusion
->ld_map_phys
[i
]);
5757 if (fusion
->ld_drv_map
[i
])
5758 free_pages((ulong
)fusion
->ld_drv_map
[i
],
5759 fusion
->drv_map_pages
);
5761 free_pages((ulong
)instance
->ctrl_context
,
5762 instance
->ctrl_context_pages
);
5765 megasas_release_mfi(instance
);
5766 pci_free_consistent(pdev
, sizeof(u32
),
5768 instance
->producer_h
);
5769 pci_free_consistent(pdev
, sizeof(u32
),
5771 instance
->consumer_h
);
5775 kfree(instance
->ctrl_info
);
5777 if (instance
->evt_detail
)
5778 pci_free_consistent(pdev
, sizeof(struct megasas_evt_detail
),
5779 instance
->evt_detail
, instance
->evt_detail_h
);
5781 if (instance
->vf_affiliation
)
5782 pci_free_consistent(pdev
, (MAX_LOGICAL_DRIVES
+ 1) *
5783 sizeof(struct MR_LD_VF_AFFILIATION
),
5784 instance
->vf_affiliation
,
5785 instance
->vf_affiliation_h
);
5787 if (instance
->vf_affiliation_111
)
5788 pci_free_consistent(pdev
,
5789 sizeof(struct MR_LD_VF_AFFILIATION_111
),
5790 instance
->vf_affiliation_111
,
5791 instance
->vf_affiliation_111_h
);
5793 if (instance
->hb_host_mem
)
5794 pci_free_consistent(pdev
, sizeof(struct MR_CTRL_HB_HOST_MEM
),
5795 instance
->hb_host_mem
,
5796 instance
->hb_host_mem_h
);
5798 if (instance
->crash_dump_buf
)
5799 pci_free_consistent(pdev
, CRASH_DMA_BUF_SIZE
,
5800 instance
->crash_dump_buf
, instance
->crash_dump_h
);
5802 scsi_host_put(host
);
5804 pci_disable_device(pdev
);
5810 * megasas_shutdown - Shutdown entry point
5811 * @device: Generic device structure
5813 static void megasas_shutdown(struct pci_dev
*pdev
)
5816 struct megasas_instance
*instance
= pci_get_drvdata(pdev
);
5818 instance
->unload
= 1;
5819 megasas_flush_cache(instance
);
5820 megasas_shutdown_controller(instance
, MR_DCMD_CTRL_SHUTDOWN
);
5821 instance
->instancet
->disable_intr(instance
);
5822 if (instance
->msix_vectors
)
5823 for (i
= 0; i
< instance
->msix_vectors
; i
++) {
5824 if (smp_affinity_enable
)
5825 irq_set_affinity_hint(
5826 instance
->msixentry
[i
].vector
, NULL
);
5827 free_irq(instance
->msixentry
[i
].vector
,
5828 &instance
->irq_context
[i
]);
5831 free_irq(instance
->pdev
->irq
, &instance
->irq_context
[0]);
5832 if (instance
->msix_vectors
)
5833 pci_disable_msix(instance
->pdev
);
5837 * megasas_mgmt_open - char node "open" entry point
5839 static int megasas_mgmt_open(struct inode
*inode
, struct file
*filep
)
5842 * Allow only those users with admin rights
5844 if (!capable(CAP_SYS_ADMIN
))
5851 * megasas_mgmt_fasync - Async notifier registration from applications
5853 * This function adds the calling process to a driver global queue. When an
5854 * event occurs, SIGIO will be sent to all processes in this queue.
5856 static int megasas_mgmt_fasync(int fd
, struct file
*filep
, int mode
)
5860 mutex_lock(&megasas_async_queue_mutex
);
5862 rc
= fasync_helper(fd
, filep
, mode
, &megasas_async_queue
);
5864 mutex_unlock(&megasas_async_queue_mutex
);
5867 /* For sanity check when we get ioctl */
5868 filep
->private_data
= filep
;
5872 printk(KERN_DEBUG
"megasas: fasync_helper failed [%d]\n", rc
);
5878 * megasas_mgmt_poll - char node "poll" entry point
5880 static unsigned int megasas_mgmt_poll(struct file
*file
, poll_table
*wait
)
5883 unsigned long flags
;
5884 poll_wait(file
, &megasas_poll_wait
, wait
);
5885 spin_lock_irqsave(&poll_aen_lock
, flags
);
5886 if (megasas_poll_wait_aen
)
5887 mask
= (POLLIN
| POLLRDNORM
);
5891 megasas_poll_wait_aen
= 0;
5892 spin_unlock_irqrestore(&poll_aen_lock
, flags
);
5897 * megasas_set_crash_dump_params_ioctl:
5898 * Send CRASH_DUMP_MODE DCMD to all controllers
5899 * @cmd: MFI command frame
5902 static int megasas_set_crash_dump_params_ioctl(
5903 struct megasas_cmd
*cmd
)
5905 struct megasas_instance
*local_instance
;
5909 crash_support
= cmd
->frame
->dcmd
.mbox
.w
[0];
5911 for (i
= 0; i
< megasas_mgmt_info
.max_index
; i
++) {
5912 local_instance
= megasas_mgmt_info
.instance
[i
];
5913 if (local_instance
&& local_instance
->crash_dump_drv_support
) {
5914 if ((local_instance
->adprecovery
==
5915 MEGASAS_HBA_OPERATIONAL
) &&
5916 !megasas_set_crash_dump_params(local_instance
,
5918 local_instance
->crash_dump_app_support
=
5920 dev_info(&local_instance
->pdev
->dev
,
5921 "Application firmware crash "
5922 "dump mode set success\n");
5925 dev_info(&local_instance
->pdev
->dev
,
5926 "Application firmware crash "
5927 "dump mode set failed\n");
5936 * megasas_mgmt_fw_ioctl - Issues management ioctls to FW
5937 * @instance: Adapter soft state
5938 * @argp: User's ioctl packet
5941 megasas_mgmt_fw_ioctl(struct megasas_instance
*instance
,
5942 struct megasas_iocpacket __user
* user_ioc
,
5943 struct megasas_iocpacket
*ioc
)
5945 struct megasas_sge32
*kern_sge32
;
5946 struct megasas_cmd
*cmd
;
5947 void *kbuff_arr
[MAX_IOCTL_SGE
];
5948 dma_addr_t buf_handle
= 0;
5951 dma_addr_t sense_handle
;
5952 unsigned long *sense_ptr
;
5954 memset(kbuff_arr
, 0, sizeof(kbuff_arr
));
5956 if (ioc
->sge_count
> MAX_IOCTL_SGE
) {
5957 printk(KERN_DEBUG
"megasas: SGE count [%d] > max limit [%d]\n",
5958 ioc
->sge_count
, MAX_IOCTL_SGE
);
5962 cmd
= megasas_get_cmd(instance
);
5964 printk(KERN_DEBUG
"megasas: Failed to get a cmd packet\n");
5969 * User's IOCTL packet has 2 frames (maximum). Copy those two
5970 * frames into our cmd's frames. cmd->frame's context will get
5971 * overwritten when we copy from user's frames. So set that value
5974 memcpy(cmd
->frame
, ioc
->frame
.raw
, 2 * MEGAMFI_FRAME_SIZE
);
5975 cmd
->frame
->hdr
.context
= cpu_to_le32(cmd
->index
);
5976 cmd
->frame
->hdr
.pad_0
= 0;
5977 cmd
->frame
->hdr
.flags
&= cpu_to_le16(~(MFI_FRAME_IEEE
|
5979 MFI_FRAME_SENSE64
));
5981 if (cmd
->frame
->dcmd
.opcode
== MR_DRIVER_SET_APP_CRASHDUMP_MODE
) {
5982 error
= megasas_set_crash_dump_params_ioctl(cmd
);
5983 megasas_return_cmd(instance
, cmd
);
5988 * The management interface between applications and the fw uses
5989 * MFI frames. E.g, RAID configuration changes, LD property changes
5990 * etc are accomplishes through different kinds of MFI frames. The
5991 * driver needs to care only about substituting user buffers with
5992 * kernel buffers in SGLs. The location of SGL is embedded in the
5993 * struct iocpacket itself.
5995 kern_sge32
= (struct megasas_sge32
*)
5996 ((unsigned long)cmd
->frame
+ ioc
->sgl_off
);
5999 * For each user buffer, create a mirror buffer and copy in
6001 for (i
= 0; i
< ioc
->sge_count
; i
++) {
6002 if (!ioc
->sgl
[i
].iov_len
)
6005 kbuff_arr
[i
] = dma_alloc_coherent(&instance
->pdev
->dev
,
6006 ioc
->sgl
[i
].iov_len
,
6007 &buf_handle
, GFP_KERNEL
);
6008 if (!kbuff_arr
[i
]) {
6009 printk(KERN_DEBUG
"megasas: Failed to alloc "
6010 "kernel SGL buffer for IOCTL \n");
6016 * We don't change the dma_coherent_mask, so
6017 * pci_alloc_consistent only returns 32bit addresses
6019 kern_sge32
[i
].phys_addr
= cpu_to_le32(buf_handle
);
6020 kern_sge32
[i
].length
= cpu_to_le32(ioc
->sgl
[i
].iov_len
);
6023 * We created a kernel buffer corresponding to the
6024 * user buffer. Now copy in from the user buffer
6026 if (copy_from_user(kbuff_arr
[i
], ioc
->sgl
[i
].iov_base
,
6027 (u32
) (ioc
->sgl
[i
].iov_len
))) {
6033 if (ioc
->sense_len
) {
6034 sense
= dma_alloc_coherent(&instance
->pdev
->dev
, ioc
->sense_len
,
6035 &sense_handle
, GFP_KERNEL
);
6042 (unsigned long *) ((unsigned long)cmd
->frame
+ ioc
->sense_off
);
6043 *sense_ptr
= cpu_to_le32(sense_handle
);
6047 * Set the sync_cmd flag so that the ISR knows not to complete this
6048 * cmd to the SCSI mid-layer
6051 megasas_issue_blocked_cmd(instance
, cmd
, 0);
6055 * copy out the kernel buffers to user buffers
6057 for (i
= 0; i
< ioc
->sge_count
; i
++) {
6058 if (copy_to_user(ioc
->sgl
[i
].iov_base
, kbuff_arr
[i
],
6059 ioc
->sgl
[i
].iov_len
)) {
6066 * copy out the sense
6068 if (ioc
->sense_len
) {
6070 * sense_ptr points to the location that has the user
6071 * sense buffer address
6073 sense_ptr
= (unsigned long *) ((unsigned long)ioc
->frame
.raw
+
6076 if (copy_to_user((void __user
*)((unsigned long)(*sense_ptr
)),
6077 sense
, ioc
->sense_len
)) {
6078 printk(KERN_ERR
"megasas: Failed to copy out to user "
6086 * copy the status codes returned by the fw
6088 if (copy_to_user(&user_ioc
->frame
.hdr
.cmd_status
,
6089 &cmd
->frame
->hdr
.cmd_status
, sizeof(u8
))) {
6090 printk(KERN_DEBUG
"megasas: Error copying out cmd_status\n");
6096 dma_free_coherent(&instance
->pdev
->dev
, ioc
->sense_len
,
6097 sense
, sense_handle
);
6100 for (i
= 0; i
< ioc
->sge_count
; i
++) {
6102 dma_free_coherent(&instance
->pdev
->dev
,
6103 le32_to_cpu(kern_sge32
[i
].length
),
6105 le32_to_cpu(kern_sge32
[i
].phys_addr
));
6106 kbuff_arr
[i
] = NULL
;
6109 if (instance
->ctrl_context
&& cmd
->mpt_pthr_cmd_blocked
)
6110 megasas_return_mfi_mpt_pthr(instance
, cmd
,
6111 cmd
->mpt_pthr_cmd_blocked
);
6113 megasas_return_cmd(instance
, cmd
);
6117 static int megasas_mgmt_ioctl_fw(struct file
*file
, unsigned long arg
)
6119 struct megasas_iocpacket __user
*user_ioc
=
6120 (struct megasas_iocpacket __user
*)arg
;
6121 struct megasas_iocpacket
*ioc
;
6122 struct megasas_instance
*instance
;
6125 unsigned long flags
;
6126 u32 wait_time
= MEGASAS_RESET_WAIT_TIME
;
6128 ioc
= kmalloc(sizeof(*ioc
), GFP_KERNEL
);
6132 if (copy_from_user(ioc
, user_ioc
, sizeof(*ioc
))) {
6137 instance
= megasas_lookup_instance(ioc
->host_no
);
6143 /* Adjust ioctl wait time for VF mode */
6144 if (instance
->requestorId
)
6145 wait_time
= MEGASAS_ROUTINE_WAIT_TIME_VF
;
6147 /* Block ioctls in VF mode */
6148 if (instance
->requestorId
&& !allow_vf_ioctls
) {
6153 if (instance
->adprecovery
== MEGASAS_HW_CRITICAL_ERROR
) {
6154 printk(KERN_ERR
"Controller in crit error\n");
6159 if (instance
->unload
== 1) {
6165 * We will allow only MEGASAS_INT_CMDS number of parallel ioctl cmds
6167 if (down_interruptible(&instance
->ioctl_sem
)) {
6168 error
= -ERESTARTSYS
;
6172 for (i
= 0; i
< wait_time
; i
++) {
6174 spin_lock_irqsave(&instance
->hba_lock
, flags
);
6175 if (instance
->adprecovery
== MEGASAS_HBA_OPERATIONAL
) {
6176 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
6179 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
6181 if (!(i
% MEGASAS_RESET_NOTICE_INTERVAL
)) {
6182 printk(KERN_NOTICE
"megasas: waiting"
6183 "for controller reset to finish\n");
6189 spin_lock_irqsave(&instance
->hba_lock
, flags
);
6190 if (instance
->adprecovery
!= MEGASAS_HBA_OPERATIONAL
) {
6191 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
6193 printk(KERN_ERR
"megaraid_sas: timed out while"
6194 "waiting for HBA to recover\n");
6198 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
6200 error
= megasas_mgmt_fw_ioctl(instance
, user_ioc
, ioc
);
6202 up(&instance
->ioctl_sem
);
6209 static int megasas_mgmt_ioctl_aen(struct file
*file
, unsigned long arg
)
6211 struct megasas_instance
*instance
;
6212 struct megasas_aen aen
;
6215 unsigned long flags
;
6216 u32 wait_time
= MEGASAS_RESET_WAIT_TIME
;
6218 if (file
->private_data
!= file
) {
6219 printk(KERN_DEBUG
"megasas: fasync_helper was not "
6224 if (copy_from_user(&aen
, (void __user
*)arg
, sizeof(aen
)))
6227 instance
= megasas_lookup_instance(aen
.host_no
);
6232 if (instance
->adprecovery
== MEGASAS_HW_CRITICAL_ERROR
) {
6236 if (instance
->unload
== 1) {
6240 for (i
= 0; i
< wait_time
; i
++) {
6242 spin_lock_irqsave(&instance
->hba_lock
, flags
);
6243 if (instance
->adprecovery
== MEGASAS_HBA_OPERATIONAL
) {
6244 spin_unlock_irqrestore(&instance
->hba_lock
,
6249 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
6251 if (!(i
% MEGASAS_RESET_NOTICE_INTERVAL
)) {
6252 printk(KERN_NOTICE
"megasas: waiting for"
6253 "controller reset to finish\n");
6259 spin_lock_irqsave(&instance
->hba_lock
, flags
);
6260 if (instance
->adprecovery
!= MEGASAS_HBA_OPERATIONAL
) {
6261 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
6262 printk(KERN_ERR
"megaraid_sas: timed out while waiting"
6263 "for HBA to recover.\n");
6266 spin_unlock_irqrestore(&instance
->hba_lock
, flags
);
6268 mutex_lock(&instance
->aen_mutex
);
6269 error
= megasas_register_aen(instance
, aen
.seq_num
,
6270 aen
.class_locale_word
);
6271 mutex_unlock(&instance
->aen_mutex
);
6276 * megasas_mgmt_ioctl - char node ioctl entry point
6279 megasas_mgmt_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
6282 case MEGASAS_IOC_FIRMWARE
:
6283 return megasas_mgmt_ioctl_fw(file
, arg
);
6285 case MEGASAS_IOC_GET_AEN
:
6286 return megasas_mgmt_ioctl_aen(file
, arg
);
6292 #ifdef CONFIG_COMPAT
6293 static int megasas_mgmt_compat_ioctl_fw(struct file
*file
, unsigned long arg
)
6295 struct compat_megasas_iocpacket __user
*cioc
=
6296 (struct compat_megasas_iocpacket __user
*)arg
;
6297 struct megasas_iocpacket __user
*ioc
=
6298 compat_alloc_user_space(sizeof(struct megasas_iocpacket
));
6303 if (clear_user(ioc
, sizeof(*ioc
)))
6306 if (copy_in_user(&ioc
->host_no
, &cioc
->host_no
, sizeof(u16
)) ||
6307 copy_in_user(&ioc
->sgl_off
, &cioc
->sgl_off
, sizeof(u32
)) ||
6308 copy_in_user(&ioc
->sense_off
, &cioc
->sense_off
, sizeof(u32
)) ||
6309 copy_in_user(&ioc
->sense_len
, &cioc
->sense_len
, sizeof(u32
)) ||
6310 copy_in_user(ioc
->frame
.raw
, cioc
->frame
.raw
, 128) ||
6311 copy_in_user(&ioc
->sge_count
, &cioc
->sge_count
, sizeof(u32
)))
6315 * The sense_ptr is used in megasas_mgmt_fw_ioctl only when
6316 * sense_len is not null, so prepare the 64bit value under
6317 * the same condition.
6319 if (ioc
->sense_len
) {
6320 void __user
**sense_ioc_ptr
=
6321 (void __user
**)(ioc
->frame
.raw
+ ioc
->sense_off
);
6322 compat_uptr_t
*sense_cioc_ptr
=
6323 (compat_uptr_t
*)(cioc
->frame
.raw
+ cioc
->sense_off
);
6324 if (get_user(ptr
, sense_cioc_ptr
) ||
6325 put_user(compat_ptr(ptr
), sense_ioc_ptr
))
6329 for (i
= 0; i
< MAX_IOCTL_SGE
; i
++) {
6330 if (get_user(ptr
, &cioc
->sgl
[i
].iov_base
) ||
6331 put_user(compat_ptr(ptr
), &ioc
->sgl
[i
].iov_base
) ||
6332 copy_in_user(&ioc
->sgl
[i
].iov_len
,
6333 &cioc
->sgl
[i
].iov_len
, sizeof(compat_size_t
)))
6337 error
= megasas_mgmt_ioctl_fw(file
, (unsigned long)ioc
);
6339 if (copy_in_user(&cioc
->frame
.hdr
.cmd_status
,
6340 &ioc
->frame
.hdr
.cmd_status
, sizeof(u8
))) {
6341 printk(KERN_DEBUG
"megasas: error copy_in_user cmd_status\n");
6348 megasas_mgmt_compat_ioctl(struct file
*file
, unsigned int cmd
,
6352 case MEGASAS_IOC_FIRMWARE32
:
6353 return megasas_mgmt_compat_ioctl_fw(file
, arg
);
6354 case MEGASAS_IOC_GET_AEN
:
6355 return megasas_mgmt_ioctl_aen(file
, arg
);
6363 * File operations structure for management interface
6365 static const struct file_operations megasas_mgmt_fops
= {
6366 .owner
= THIS_MODULE
,
6367 .open
= megasas_mgmt_open
,
6368 .fasync
= megasas_mgmt_fasync
,
6369 .unlocked_ioctl
= megasas_mgmt_ioctl
,
6370 .poll
= megasas_mgmt_poll
,
6371 #ifdef CONFIG_COMPAT
6372 .compat_ioctl
= megasas_mgmt_compat_ioctl
,
6374 .llseek
= noop_llseek
,
6378 * PCI hotplug support registration structure
6380 static struct pci_driver megasas_pci_driver
= {
6382 .name
= "megaraid_sas",
6383 .id_table
= megasas_pci_table
,
6384 .probe
= megasas_probe_one
,
6385 .remove
= megasas_detach_one
,
6386 .suspend
= megasas_suspend
,
6387 .resume
= megasas_resume
,
6388 .shutdown
= megasas_shutdown
,
6392 * Sysfs driver attributes
6394 static ssize_t
megasas_sysfs_show_version(struct device_driver
*dd
, char *buf
)
6396 return snprintf(buf
, strlen(MEGASAS_VERSION
) + 2, "%s\n",
6400 static DRIVER_ATTR(version
, S_IRUGO
, megasas_sysfs_show_version
, NULL
);
6403 megasas_sysfs_show_release_date(struct device_driver
*dd
, char *buf
)
6405 return snprintf(buf
, strlen(MEGASAS_RELDATE
) + 2, "%s\n",
6409 static DRIVER_ATTR(release_date
, S_IRUGO
, megasas_sysfs_show_release_date
,
6413 megasas_sysfs_show_support_poll_for_event(struct device_driver
*dd
, char *buf
)
6415 return sprintf(buf
, "%u\n", support_poll_for_event
);
6418 static DRIVER_ATTR(support_poll_for_event
, S_IRUGO
,
6419 megasas_sysfs_show_support_poll_for_event
, NULL
);
6422 megasas_sysfs_show_support_device_change(struct device_driver
*dd
, char *buf
)
6424 return sprintf(buf
, "%u\n", support_device_change
);
6427 static DRIVER_ATTR(support_device_change
, S_IRUGO
,
6428 megasas_sysfs_show_support_device_change
, NULL
);
6431 megasas_sysfs_show_dbg_lvl(struct device_driver
*dd
, char *buf
)
6433 return sprintf(buf
, "%u\n", megasas_dbg_lvl
);
6437 megasas_sysfs_set_dbg_lvl(struct device_driver
*dd
, const char *buf
, size_t count
)
6440 if(sscanf(buf
,"%u",&megasas_dbg_lvl
)<1){
6441 printk(KERN_ERR
"megasas: could not set dbg_lvl\n");
6447 static DRIVER_ATTR(dbg_lvl
, S_IRUGO
|S_IWUSR
, megasas_sysfs_show_dbg_lvl
,
6448 megasas_sysfs_set_dbg_lvl
);
6451 megasas_aen_polling(struct work_struct
*work
)
6453 struct megasas_aen_event
*ev
=
6454 container_of(work
, struct megasas_aen_event
, hotplug_work
.work
);
6455 struct megasas_instance
*instance
= ev
->instance
;
6456 union megasas_evt_class_locale class_locale
;
6457 struct Scsi_Host
*host
;
6458 struct scsi_device
*sdev1
;
6461 int i
, j
, doscan
= 0;
6462 u32 seq_num
, wait_time
= MEGASAS_RESET_WAIT_TIME
;
6466 printk(KERN_ERR
"invalid instance!\n");
6471 /* Adjust event workqueue thread wait time for VF mode */
6472 if (instance
->requestorId
)
6473 wait_time
= MEGASAS_ROUTINE_WAIT_TIME_VF
;
6475 /* Don't run the event workqueue thread if OCR is running */
6476 for (i
= 0; i
< wait_time
; i
++) {
6477 if (instance
->adprecovery
== MEGASAS_HBA_OPERATIONAL
)
6479 if (!(i
% MEGASAS_RESET_NOTICE_INTERVAL
)) {
6480 printk(KERN_NOTICE
"megasas: %s waiting for "
6481 "controller reset to finish for scsi%d\n",
6482 __func__
, instance
->host
->host_no
);
6487 instance
->ev
= NULL
;
6488 host
= instance
->host
;
6489 if (instance
->evt_detail
) {
6491 switch (le32_to_cpu(instance
->evt_detail
->code
)) {
6492 case MR_EVT_PD_INSERTED
:
6493 if (megasas_get_pd_list(instance
) == 0) {
6494 for (i
= 0; i
< MEGASAS_MAX_PD_CHANNELS
; i
++) {
6496 j
< MEGASAS_MAX_DEV_PER_CHANNEL
;
6500 (i
* MEGASAS_MAX_DEV_PER_CHANNEL
) + j
;
6503 scsi_device_lookup(host
, i
, j
, 0);
6505 if (instance
->pd_list
[pd_index
].driveState
6506 == MR_PD_STATE_SYSTEM
) {
6508 scsi_add_device(host
, i
, j
, 0);
6512 scsi_device_put(sdev1
);
6520 case MR_EVT_PD_REMOVED
:
6521 if (megasas_get_pd_list(instance
) == 0) {
6522 for (i
= 0; i
< MEGASAS_MAX_PD_CHANNELS
; i
++) {
6524 j
< MEGASAS_MAX_DEV_PER_CHANNEL
;
6528 (i
* MEGASAS_MAX_DEV_PER_CHANNEL
) + j
;
6531 scsi_device_lookup(host
, i
, j
, 0);
6533 if (instance
->pd_list
[pd_index
].driveState
6534 == MR_PD_STATE_SYSTEM
) {
6536 scsi_device_put(sdev1
);
6540 scsi_remove_device(sdev1
);
6541 scsi_device_put(sdev1
);
6550 case MR_EVT_LD_OFFLINE
:
6551 case MR_EVT_CFG_CLEARED
:
6552 case MR_EVT_LD_DELETED
:
6553 if (!instance
->requestorId
||
6554 (instance
->requestorId
&&
6555 megasas_get_ld_vf_affiliation(instance
, 0))) {
6556 if (megasas_ld_list_query(instance
,
6557 MR_LD_QUERY_TYPE_EXPOSED_TO_HOST
))
6558 megasas_get_ld_list(instance
);
6559 for (i
= 0; i
< MEGASAS_MAX_LD_CHANNELS
; i
++) {
6561 j
< MEGASAS_MAX_DEV_PER_CHANNEL
;
6565 (i
* MEGASAS_MAX_DEV_PER_CHANNEL
) + j
;
6567 sdev1
= scsi_device_lookup(host
, MEGASAS_MAX_PD_CHANNELS
+ i
, j
, 0);
6569 if (instance
->ld_ids
[ld_index
]
6572 scsi_device_put(sdev1
);
6575 scsi_remove_device(sdev1
);
6576 scsi_device_put(sdev1
);
6584 case MR_EVT_LD_CREATED
:
6585 if (!instance
->requestorId
||
6586 (instance
->requestorId
&&
6587 megasas_get_ld_vf_affiliation(instance
, 0))) {
6588 if (megasas_ld_list_query(instance
,
6589 MR_LD_QUERY_TYPE_EXPOSED_TO_HOST
))
6590 megasas_get_ld_list(instance
);
6591 for (i
= 0; i
< MEGASAS_MAX_LD_CHANNELS
; i
++) {
6593 j
< MEGASAS_MAX_DEV_PER_CHANNEL
;
6596 (i
* MEGASAS_MAX_DEV_PER_CHANNEL
) + j
;
6598 sdev1
= scsi_device_lookup(host
, MEGASAS_MAX_PD_CHANNELS
+ i
, j
, 0);
6600 if (instance
->ld_ids
[ld_index
]
6603 scsi_add_device(host
, MEGASAS_MAX_PD_CHANNELS
+ i
, j
, 0);
6606 scsi_device_put(sdev1
);
6612 case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED
:
6613 case MR_EVT_FOREIGN_CFG_IMPORTED
:
6614 case MR_EVT_LD_STATE_CHANGE
:
6622 printk(KERN_ERR
"invalid evt_detail!\n");
6628 printk(KERN_INFO
"megaraid_sas: scanning for scsi%d...\n",
6629 instance
->host
->host_no
);
6630 if (megasas_get_pd_list(instance
) == 0) {
6631 for (i
= 0; i
< MEGASAS_MAX_PD_CHANNELS
; i
++) {
6632 for (j
= 0; j
< MEGASAS_MAX_DEV_PER_CHANNEL
; j
++) {
6633 pd_index
= i
*MEGASAS_MAX_DEV_PER_CHANNEL
+ j
;
6634 sdev1
= scsi_device_lookup(host
, i
, j
, 0);
6635 if (instance
->pd_list
[pd_index
].driveState
==
6636 MR_PD_STATE_SYSTEM
) {
6638 scsi_add_device(host
, i
, j
, 0);
6641 scsi_device_put(sdev1
);
6644 scsi_remove_device(sdev1
);
6645 scsi_device_put(sdev1
);
6652 if (!instance
->requestorId
||
6653 (instance
->requestorId
&&
6654 megasas_get_ld_vf_affiliation(instance
, 0))) {
6655 if (megasas_ld_list_query(instance
,
6656 MR_LD_QUERY_TYPE_EXPOSED_TO_HOST
))
6657 megasas_get_ld_list(instance
);
6658 for (i
= 0; i
< MEGASAS_MAX_LD_CHANNELS
; i
++) {
6659 for (j
= 0; j
< MEGASAS_MAX_DEV_PER_CHANNEL
;
6662 (i
* MEGASAS_MAX_DEV_PER_CHANNEL
) + j
;
6664 sdev1
= scsi_device_lookup(host
,
6665 MEGASAS_MAX_PD_CHANNELS
+ i
, j
, 0);
6666 if (instance
->ld_ids
[ld_index
]
6669 scsi_add_device(host
, MEGASAS_MAX_PD_CHANNELS
+ i
, j
, 0);
6671 scsi_device_put(sdev1
);
6674 scsi_remove_device(sdev1
);
6675 scsi_device_put(sdev1
);
6683 if ( instance
->aen_cmd
!= NULL
) {
6688 seq_num
= le32_to_cpu(instance
->evt_detail
->seq_num
) + 1;
6690 /* Register AEN with FW for latest sequence number plus 1 */
6691 class_locale
.members
.reserved
= 0;
6692 class_locale
.members
.locale
= MR_EVT_LOCALE_ALL
;
6693 class_locale
.members
.class = MR_EVT_CLASS_DEBUG
;
6694 mutex_lock(&instance
->aen_mutex
);
6695 error
= megasas_register_aen(instance
, seq_num
,
6697 mutex_unlock(&instance
->aen_mutex
);
6700 printk(KERN_ERR
"register aen failed error %x\n", error
);
6706 * megasas_init - Driver load entry point
6708 static int __init
megasas_init(void)
6713 * Announce driver version and other information
6715 printk(KERN_INFO
"megasas: %s %s\n", MEGASAS_VERSION
,
6716 MEGASAS_EXT_VERSION
);
6718 spin_lock_init(&poll_aen_lock
);
6720 support_poll_for_event
= 2;
6721 support_device_change
= 1;
6723 memset(&megasas_mgmt_info
, 0, sizeof(megasas_mgmt_info
));
6726 * Register character device node
6728 rval
= register_chrdev(0, "megaraid_sas_ioctl", &megasas_mgmt_fops
);
6731 printk(KERN_DEBUG
"megasas: failed to open device node\n");
6735 megasas_mgmt_majorno
= rval
;
6738 * Register ourselves as PCI hotplug module
6740 rval
= pci_register_driver(&megasas_pci_driver
);
6743 printk(KERN_DEBUG
"megasas: PCI hotplug registration failed \n");
6747 rval
= driver_create_file(&megasas_pci_driver
.driver
,
6748 &driver_attr_version
);
6750 goto err_dcf_attr_ver
;
6751 rval
= driver_create_file(&megasas_pci_driver
.driver
,
6752 &driver_attr_release_date
);
6754 goto err_dcf_rel_date
;
6756 rval
= driver_create_file(&megasas_pci_driver
.driver
,
6757 &driver_attr_support_poll_for_event
);
6759 goto err_dcf_support_poll_for_event
;
6761 rval
= driver_create_file(&megasas_pci_driver
.driver
,
6762 &driver_attr_dbg_lvl
);
6764 goto err_dcf_dbg_lvl
;
6765 rval
= driver_create_file(&megasas_pci_driver
.driver
,
6766 &driver_attr_support_device_change
);
6768 goto err_dcf_support_device_change
;
6772 err_dcf_support_device_change
:
6773 driver_remove_file(&megasas_pci_driver
.driver
,
6774 &driver_attr_dbg_lvl
);
6776 driver_remove_file(&megasas_pci_driver
.driver
,
6777 &driver_attr_support_poll_for_event
);
6779 err_dcf_support_poll_for_event
:
6780 driver_remove_file(&megasas_pci_driver
.driver
,
6781 &driver_attr_release_date
);
6784 driver_remove_file(&megasas_pci_driver
.driver
, &driver_attr_version
);
6786 pci_unregister_driver(&megasas_pci_driver
);
6788 unregister_chrdev(megasas_mgmt_majorno
, "megaraid_sas_ioctl");
6793 * megasas_exit - Driver unload entry point
6795 static void __exit
megasas_exit(void)
6797 driver_remove_file(&megasas_pci_driver
.driver
,
6798 &driver_attr_dbg_lvl
);
6799 driver_remove_file(&megasas_pci_driver
.driver
,
6800 &driver_attr_support_poll_for_event
);
6801 driver_remove_file(&megasas_pci_driver
.driver
,
6802 &driver_attr_support_device_change
);
6803 driver_remove_file(&megasas_pci_driver
.driver
,
6804 &driver_attr_release_date
);
6805 driver_remove_file(&megasas_pci_driver
.driver
, &driver_attr_version
);
6807 pci_unregister_driver(&megasas_pci_driver
);
6808 unregister_chrdev(megasas_mgmt_majorno
, "megaraid_sas_ioctl");
6811 module_init(megasas_init
);
6812 module_exit(megasas_exit
);