Impressum megaraid_sas_base.c
Sprache: C
// SPDX-License-Identifier: GPL-2.0-or-later /* * Linux MegaRAID driver for SAS based RAID controllers * * Copyright ( c ) 2003 - 2013 LSI Corporation * Copyright ( c ) 2013 - 2016 Avago Technologies * Copyright ( c ) 2016 - 2018 Broadcom Inc . * * Authors : Broadcom Inc . * Sreenivas Bagalkote * Sumant Patro * Bo Yang * Adam Radford * Kashyap Desai < kashyap . desai @ broadcom . com > * Sumit Saxena < sumit . saxena @ broadcom . com > * * Send feedback to : megaraidlinux . pdl @ broadcom . com #include <linux/kernel.h>#include <linux/types.h>#include <linux/pci.h>#include <linux/list.h>#include <linux/moduleparam.h>#include <linux/module.h>#include <linux/spinlock.h>#include <linux/interrupt.h>#include <linux/delay.h>#include <linux/uio.h>#include <linux/slab.h>#include <linux/uaccess.h>#include <linux/unaligned.h>#include <linux/fs.h>#include <linux/compat.h>#include <linux/blkdev.h>#include <linux/mutex.h>#include <linux/poll.h>#include <linux/vmalloc.h>#include <linux/irq_poll.h>#include <scsi/scsi.h>#include <scsi/scsi_cmnd.h>#include <scsi/scsi_device.h>#include <scsi/scsi_host.h>#include <scsi/scsi_tcq.h>#include <scsi/scsi_dbg.h>#include "megaraid_sas_fusion.h" #include "megaraid_sas.h" /* * Number of sectors per IO command * Will be set in megasas_init_mfi if user does not provide static unsigned int max_sectors;int , 0444 );"Maximum number of sectors per IO command" );static int msix_disable;int , 0444 );"Disable MSI-X interrupt handling. Default: 0" );static unsigned int msix_vectors;int , 0444 );"MSI-X max vector count. Default: Set by FW" );static int allow_vf_ioctls;int , 0444 );"Allow ioctls in SR-IOV VF mode. Default: 0" );static unsigned int throttlequeuedepth = MEGASAS_THROTTLE_QUEUE_DEPTH;int , 0444 );"Adapter queue depth when throttled due to I/O timeout. Default: 16" );unsigned int resetwaittime = MEGASAS_RESET_WAIT_TIME;int , 0444 );"Wait time in (1-180s) after I/O timeout before resetting adapter. Default: 180s" );static int smp_affinity_enable = 1 ;int , 0444 );"SMP affinity feature enable/disable Default: enable(1)" );static int rdpq_enable = 1 ;int , 0444 );"Allocate reply queue in chunks for large queue depth enable/disable Default: enable(1)" );unsigned int dual_qdepth_disable;int , 0444 );"Disable dual queue depth feature. Default: 0" );static unsigned int scmd_timeout = MEGASAS_DEFAULT_CMD_TIMEOUT;int , 0444 );"scsi command timeout (10-90s), default 90s. See megasas_reset_timer." );static int perf_mode = -1 ;int , 0444 );"Performance mode (only for Aero adapters), options:\n\t\t" "0 - balanced: High iops and low latency queues are allocated &\n\t\t" "interrupt coalescing is enabled only on high iops queues\n\t\t" "1 - iops: High iops queues are not allocated &\n\t\t" "interrupt coalescing is enabled on all queues\n\t\t" "2 - latency: High iops queues are not allocated &\n\t\t" "interrupt coalescing is disabled on all queues\n\t\t" "default mode is 'balanced'" static int event_log_level = MFI_EVT_CLASS_CRITICAL;int , 0644 );"Asynchronous event logging level- range is: -2(CLASS_DEBUG) to 4(CLASS_DEAD), Default: 2(CLASS_CRITICAL)" );static unsigned int enable_sdev_max_qd;int , 0444 );"Enable sdev max qd as can_queue. Default: 0" );static int poll_queues;int , 0444 );"Number of queues to be use for io_uring poll mode.\n\t\t" "This parameter is effective only if host_tagset_enable=1 &\n\t\t" "It is not applicable for MFI_SERIES. &\n\t\t" "Driver will work in latency mode. &\n\t\t" "High iops queues are not allocated &\n\t\t" static int host_tagset_enable = 1 ;int , 0444 );"Shared host tagset enable/disable Default: enable(1)" );"GPL" );"megaraidlinux.pdl@broadcom.com" );"Broadcom MegaRAID SAS Driver" );int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);static int megasas_get_pd_list(struct megasas_instance *instance);static int megasas_ld_list_query(struct megasas_instance *instance,static int megasas_issue_init_mfi(struct megasas_instance *instance);static int megasas_register_aen(struct megasas_instance *instance,static void megasas_get_pd_info(struct megasas_instance *instance,struct scsi_device *sdev);static void struct megasas_instance *instance);/* * PCI ID table for all supported controllers static const struct pci_device_id megasas_pci_table[] = {/* xscale IOP */ /* ppc IOP */ /* ppc IOP */ /* gen2*/ /* gen2*/ /* skinny*/ /* skinny*/ /* xscale IOP, vega */ /* xscale IOP */ /* Fusion */ /* Plasma */ /* Invader */ /* Fury */ /* Intruder */ /* Intruder 24 port*/ /* VENTURA */ static int megasas_mgmt_majorno;struct megasas_mgmt_info megasas_mgmt_info;static struct fasync_struct *megasas_async_queue;static DEFINE_MUTEX(megasas_async_queue_mutex);static int megasas_poll_wait_aen;static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait);static u32 support_poll_for_event;static u32 support_device_change;static bool support_nvme_encapsulation;static bool support_pci_lane_margining;/* define lock for aen poll */ static DEFINE_SPINLOCK(poll_aen_lock);extern struct dentry *megasas_debugfs_root;extern int megasas_blk_mq_poll(struct Scsi_Host *shost, unsigned int queue_num);void struct megasas_instance *instance, struct megasas_cmd *cmd,static u32struct megasas_instance *instance);static int struct megasas_instance *instance,struct megasas_register_set __iomem *reg_set);static irqreturn_t megasas_isr(int irq, void *devp);static u32struct megasas_instance *instance);struct megasas_instance *instance,struct scsi_cmnd *scmd);static void megasas_complete_cmd_dpc(unsigned long instance_addr);int struct megasas_instance *instance, struct megasas_cmd *cmd,int seconds);void megasas_fusion_ocr_wq(struct work_struct *work);static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,int initial);static int struct megasas_instance *instance);static int struct megasas_instance *instance);static inline void struct megasas_instance *instance);static inline int struct megasas_instance *instance);static inline void struct megasas_instance *instance);static inline void struct megasas_instance *instance);struct megasas_instance *instance,const volatile void __iomem *addr)0 , ret_val;/* * Due to a HW errata in Aero controllers , reads to certain * Fusion registers could intermittently return all zeroes . * This behavior is transient in nature and subsequent reads will * return valid value . As a workaround in driver , retry readl for * up to thirty times until a non - zero value is read . if (instance->adapter_type == AERO_SERIES) {do {while (ret_val == 0 && i < 30 );return ret_val;else {return readl(addr);/** * megasas_set_dma_settings - Populate DMA address , length and flags for DCMDs * @ instance : Adapter soft state * @ dcmd : DCMD frame inside MFI command * @ dma_addr : DMA address of buffer to be passed to FW * @ dma_len : Length of DMA buffer to be passed to FW * @ return : void void megasas_set_dma_settings(struct megasas_instance *instance,struct megasas_dcmd_frame *dcmd,if (instance->consistent_mask_64bit) {0 ].phys_addr = cpu_to_le64(dma_addr);0 ].length = cpu_to_le32(dma_len);else {0 ].phys_addr =0 ].length = cpu_to_le32(dma_len);static void struct megasas_instance *instance, struct megasas_cmd *cmd)0 , instance->reg_set);return ;/** * megasas_get_cmd - Get a command from the free pool * @ instance : Adapter soft state * * Returns a free command from the pool struct megasas_cmd *megasas_get_cmd(struct megasas_instanceunsigned long flags;struct megasas_cmd *cmd = NULL;if (!list_empty(&instance->cmd_pool)) {struct megasas_cmd, list);else {"Command pool empty!\n" );return cmd;/** * megasas_return_cmd - Return a cmd to free command pool * @ instance : Adapter soft state * @ cmd : Command packet to be returned to free command pool void struct megasas_instance *instance, struct megasas_cmd *cmd)unsigned long flags;struct megasas_cmd_fusion *cmd_fusion;struct fusion_context *fusion = instance->ctrl_context;/* This flag is used only for fusion adapter. * Wait for Interrupt for Polled mode DCMD if (cmd->flags & DRV_DCMD_POLLED_MODE)return ;if (fusion) {0 ;0 ;0 , instance->mfi_frame_size);if (!fusion && reset_devices)static const char *static char buffer[32 ];if ((timestamp & 0 xff000000) == 0 xff000000)sizeof (buffer), "boot + %us" , timestamp &0 x00ffffff);else sizeof (buffer), "%us" , timestamp);return buffer;static const char *class )static char buffer[6 ];switch (class ) {case MFI_EVT_CLASS_DEBUG:return "debug" ;case MFI_EVT_CLASS_PROGRESS:return "progress" ;case MFI_EVT_CLASS_INFO:return "info" ;case MFI_EVT_CLASS_WARNING:return "WARN" ;case MFI_EVT_CLASS_CRITICAL:return "CRIT" ;case MFI_EVT_CLASS_FATAL:return "FATAL" ;case MFI_EVT_CLASS_DEAD:return "DEAD" ;default :sizeof (buffer), "%d" , class );return buffer;/** * megasas_decode_evt : Decode FW AEN event and print critical event * for information . * @ instance : Adapter soft state static void struct megasas_instance *instance)struct megasas_evt_detail *evt_detail = instance->evt_detail;union megasas_evt_class_locale class_locale;if ((event_log_level < MFI_EVT_CLASS_DEBUG) ||"megaraid_sas: provided event log level is out of range, setting it to default 2(CLASS_CRITICAL), permissible range is: -2 to 4\n" );if (class_locale.members.class >= event_log_level)"%d (%s/0x%04x/%s) - %s\n" ,class ),if (megasas_dbg_lvl & LD_PD_DEBUG)"evt_detail.args.ld.target_id/index %d/%d\n" ,/* * The following functions are defined for xscale * ( deviceid : 1064 R , PERC5 ) controllers /** * megasas_enable_intr_xscale - Enables interrupts * @ instance : Adapter soft state static inline void struct megasas_instance *instance)struct megasas_register_set __iomem *regs;0 , &(regs)->outbound_intr_mask);/* Dummy readl to force pci flush */ /** * megasas_disable_intr_xscale - Disables interrupt * @ instance : Adapter soft state static inline void struct megasas_instance *instance)struct megasas_register_set __iomem *regs;0 x1f;/* Dummy readl to force pci flush */ /** * megasas_read_fw_status_reg_xscale - returns the current FW status value * @ instance : Adapter soft state static u32struct megasas_instance *instance)return readl(&instance->reg_set->outbound_msg_0);/** * megasas_clear_intr_xscale - Check & clear interrupt * @ instance : Adapter soft state static int struct megasas_instance *instance)0 ;struct megasas_register_set __iomem *regs;/* * Check if it is our interrupt if (status & MFI_OB_INTR_STATUS_MASK)if (status & MFI_XSCALE_OMR0_CHANGE_INTERRUPT)/* * Clear the interrupt by writing back the same value if (mfiStatus)/* Dummy readl to force pci flush */ return mfiStatus;/** * megasas_fire_cmd_xscale - Sends command to the FW * @ instance : Adapter soft state * @ frame_phys_addr : Physical address of cmd * @ frame_count : Number of frames for the command * @ regs : MFI register set static inline void struct megasas_instance *instance,struct megasas_register_set __iomem *regs)unsigned long flags;3 )|(frame_count),/** * megasas_adp_reset_xscale - For controller reset * @ instance : Adapter soft state * @ regs : MFI register set static int struct megasas_instance *instance,struct megasas_register_set __iomem *regs)for (i = 0 ; i < 3 ; i++)1000 ); /* sleep for 3 secs */ 0 ;"pcidata = %x\n" , pcidata);if (pcidata & 0 x2) {"mfi 1068 offset read=%x\n" , pcidata);0 x2;for (i = 0 ; i < 2 ; i++)1000 ); /* need to wait 2 secs again */ 0 ;"1068 offset handshake read=%x\n" , pcidata);if ((pcidata & 0 xffff0000) == MFI_1068_FW_READY) {"1068 offset pcidt=%x\n" , pcidata);0 ;return 0 ;/** * megasas_check_reset_xscale - For controller reset check * @ instance : Adapter soft state * @ regs : MFI register set static int struct megasas_instance *instance,struct megasas_register_set __iomem *regs)if ((atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) &&return 1 ;return 0 ;static struct megasas_instance_template megasas_instance_template_xscale = {/* * This is the end of set of functions & definitions specific * to xscale ( deviceid : 1064 R , PERC5 ) controllers /* * The following functions are defined for ppc ( deviceid : 0 x60 ) * controllers /** * megasas_enable_intr_ppc - Enables interrupts * @ instance : Adapter soft state static inline void struct megasas_instance *instance)struct megasas_register_set __iomem *regs;0 xFFFFFFFF, &(regs)->outbound_doorbell_clear);0 x80000000, &(regs)->outbound_intr_mask);/* Dummy readl to force pci flush */ /** * megasas_disable_intr_ppc - Disable interrupt * @ instance : Adapter soft state static inline void struct megasas_instance *instance)struct megasas_register_set __iomem *regs;0 xFFFFFFFF;/* Dummy readl to force pci flush */ /** * megasas_read_fw_status_reg_ppc - returns the current FW status value * @ instance : Adapter soft state static u32struct megasas_instance *instance)return readl(&instance->reg_set->outbound_scratch_pad_0);/** * megasas_clear_intr_ppc - Check & clear interrupt * @ instance : Adapter soft state static int struct megasas_instance *instance)0 ;struct megasas_register_set __iomem *regs;/* * Check if it is our interrupt if (status & MFI_REPLY_1078_MESSAGE_INTERRUPT)if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT)/* * Clear the interrupt by writing back the same value /* Dummy readl to force pci flush */ return mfiStatus;/** * megasas_fire_cmd_ppc - Sends command to the FW * @ instance : Adapter soft state * @ frame_phys_addr : Physical address of cmd * @ frame_count : Number of frames for the command * @ regs : MFI register set static inline void struct megasas_instance *instance,struct megasas_register_set __iomem *regs)unsigned long flags;1 ))|1 ,/** * megasas_check_reset_ppc - For controller reset check * @ instance : Adapter soft state * @ regs : MFI register set static int struct megasas_instance *instance,struct megasas_register_set __iomem *regs)if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)return 1 ;return 0 ;static struct megasas_instance_template megasas_instance_template_ppc = {/** * megasas_enable_intr_skinny - Enables interrupts * @ instance : Adapter soft state static inline void struct megasas_instance *instance)struct megasas_register_set __iomem *regs;0 xFFFFFFFF, &(regs)->outbound_intr_mask);/* Dummy readl to force pci flush */ /** * megasas_disable_intr_skinny - Disables interrupt * @ instance : Adapter soft state static inline void struct megasas_instance *instance)struct megasas_register_set __iomem *regs;0 xFFFFFFFF;/* Dummy readl to force pci flush */ /** * megasas_read_fw_status_reg_skinny - returns the current FW status value * @ instance : Adapter soft state static u32struct megasas_instance *instance)return readl(&instance->reg_set->outbound_scratch_pad_0);/** * megasas_clear_intr_skinny - Check & clear interrupt * @ instance : Adapter soft state static int struct megasas_instance *instance)0 ;struct megasas_register_set __iomem *regs;/* * Check if it is our interrupt if (!(status & MFI_SKINNY_ENABLE_INTERRUPT_MASK)) {return 0 ;/* * Check if it is our interrupt if ((megasas_read_fw_status_reg_skinny(instance) & MFI_STATE_MASK) ==else /* * Clear the interrupt by writing back the same value /* * dummy read to flush PCI return mfiStatus;/** * megasas_fire_cmd_skinny - Sends command to the FW * @ instance : Adapter soft state * @ frame_phys_addr : Physical address of cmd * @ frame_count : Number of frames for the command * @ regs : MFI register set static inline void struct megasas_instance *instance,struct megasas_register_set __iomem *regs)unsigned long flags;1 ))|1 ,/** * megasas_check_reset_skinny - For controller reset check * @ instance : Adapter soft state * @ regs : MFI register set static int struct megasas_instance *instance,struct megasas_register_set __iomem *regs)if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)return 1 ;return 0 ;static struct megasas_instance_template megasas_instance_template_skinny = {/* * The following functions are defined for gen2 ( deviceid : 0 x78 0 x79 ) * controllers /** * megasas_enable_intr_gen2 - Enables interrupts * @ instance : Adapter soft state static inline void struct megasas_instance *instance)struct megasas_register_set __iomem *regs;0 xFFFFFFFF, &(regs)->outbound_doorbell_clear);/* write ~0x00000005 (4 & 1) to the intr mask*/ /* Dummy readl to force pci flush */ /** * megasas_disable_intr_gen2 - Disables interrupt * @ instance : Adapter soft state static inline void struct megasas_instance *instance)struct megasas_register_set __iomem *regs;0 xFFFFFFFF;/* Dummy readl to force pci flush */ /** * megasas_read_fw_status_reg_gen2 - returns the current FW status value * @ instance : Adapter soft state static u32struct megasas_instance *instance)return readl(&instance->reg_set->outbound_scratch_pad_0);/** * megasas_clear_intr_gen2 - Check & clear interrupt * @ instance : Adapter soft state static int struct megasas_instance *instance)0 ;struct megasas_register_set __iomem *regs;/* * Check if it is our interrupt if (status & MFI_INTR_FLAG_REPLY_MESSAGE) {if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT) {/* * Clear the interrupt by writing back the same value if (mfiStatus)/* Dummy readl to force pci flush */ return mfiStatus;/** * megasas_fire_cmd_gen2 - Sends command to the FW * @ instance : Adapter soft state * @ frame_phys_addr : Physical address of cmd * @ frame_count : Number of frames for the command * @ regs : MFI register set static inline void struct megasas_instance *instance,struct megasas_register_set __iomem *regs)unsigned long flags;1 ))|1 ,/** * megasas_adp_reset_gen2 - For controller reset * @ instance : Adapter soft state * @ reg_set : MFI register set static int struct megasas_instance *instance,struct megasas_register_set __iomem *reg_set)0 ;if (instance->instancet == &megasas_instance_template_skinny) {0 , seq_offset);4 , seq_offset);0 xb, seq_offset);2 , seq_offset);7 , seq_offset);0 xd, seq_offset);1000 );while (!(HostDiag & DIAG_WRITE_ENABLE)) {100 );"RESETGEN2: retry=%x, hostdiag=%x\n" ,if (retry++ >= 100 )return 1 ;"ADP_RESET_GEN2: HostDiag=%x\n" , HostDiag);10 );while (HostDiag & DIAG_RESET_ADAPTER) {100 );"RESET_GEN2: retry=%x, hostdiag=%x\n" ,if (retry++ >= 1000 )return 1 ;return 0 ;/** * megasas_check_reset_gen2 - For controller reset check * @ instance : Adapter soft state * @ regs : MFI register set static int struct megasas_instance *instance,struct megasas_register_set __iomem *regs)if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)return 1 ;return 0 ;static struct megasas_instance_template megasas_instance_template_gen2 = {/* * This is the end of set of functions & definitions * specific to gen2 ( deviceid : 0 x78 , 0 x79 ) controllers /* * Template added for TB ( Fusion ) extern struct megasas_instance_template megasas_instance_template_fusion;/** * megasas_issue_polled - Issues a polling command * @ instance : Adapter soft state * @ cmd : Command packet to be issued * * For polling , MFI requires the cmd_status to be set to MFI_STAT_INVALID_STATUS before posting . int struct megasas_instance *instance, struct megasas_cmd *cmd)struct megasas_header *frame_hdr = &cmd->frame->hdr;if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {"Failed from %s %d\n" ,return DCMD_INIT;return wait_and_poll(instance, cmd, instance->requestorId ?/** * megasas_issue_blocked_cmd - Synchronous wrapper around regular FW cmds * @ instance : Adapter soft state * @ cmd : Command to be issued * @ timeout : Timeout in seconds * * This function waits on an event for the command to be returned from ISR . * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs * Used to issue ioctl commands . int struct megasas_instance *instance,struct megasas_cmd *cmd, int timeout)int ret = 0 ;if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {"Failed from %s %d\n" ,return DCMD_INIT;if (timeout) {if (!ret) {"DCMD(opcode: 0x%x) is timed out, func:%s\n" ,return DCMD_TIMEOUT;else return cmd->cmd_status_drv;/** * megasas_issue_blocked_abort_cmd - Aborts previously issued cmd * @ instance : Adapter soft state * @ cmd_to_abort : Previously issued cmd to be aborted * @ timeout : Timeout in seconds * * MFI firmware can abort previously issued AEN comamnd ( automatic event * notification ) . The megasas_issue_blocked_abort_cmd ( ) issues such abort * cmd and waits for return status . * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs static int struct megasas_instance *instance,struct megasas_cmd *cmd_to_abort, int timeout)struct megasas_cmd *cmd;struct megasas_abort_frame *abort_fr;int ret = 0 ;if (!cmd)return -1 ;/* * Prepare and issue the abort frame 0 );1 ;if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {"Failed from %s %d\n" ,return DCMD_INIT;if (timeout) {if (!ret) {"Abort(to be aborted DCMD opcode: 0x%x) is timed out func:%s\n" ,return DCMD_TIMEOUT;else 0 ;return cmd->cmd_status_drv;/** * megasas_make_sgl32 - Prepares 32 - bit SGL * @ instance : Adapter soft state * @ scp : SCSI command from the mid - layer * @ mfi_sgl : SGL to be filled in * * If successful , this function returns the number of SG elements . Otherwise , * it returnes - 1 . static int struct megasas_instance *instance, struct scsi_cmnd *scp,union megasas_sgl *mfi_sgl)int i;int sge_count;struct scatterlist *os_sgl;0 );if (sge_count) {return sge_count;/** * megasas_make_sgl64 - Prepares 64 - bit SGL * @ instance : Adapter soft state * @ scp : SCSI command from the mid - layer * @ mfi_sgl : SGL to be filled in * * If successful , this function returns the number of SG elements . Otherwise , * it returnes - 1 . static int struct megasas_instance *instance, struct scsi_cmnd *scp,union megasas_sgl *mfi_sgl)int i;int sge_count;struct scatterlist *os_sgl;0 );if (sge_count) {return sge_count;/** * megasas_make_sgl_skinny - Prepares IEEE SGL * @ instance : Adapter soft state * @ scp : SCSI command from the mid - layer * @ mfi_sgl : SGL to be filled in * * If successful , this function returns the number of SG elements . Otherwise , * it returnes - 1 . static int struct megasas_instance *instance,struct scsi_cmnd *scp, union megasas_sgl *mfi_sgl)int i;int sge_count;struct scatterlist *os_sgl;if (sge_count) {0 );return sge_count;/** * megasas_get_frame_count - Computes the number of frames * @ frame_type : type of frame - io or pthru frame * @ sge_count : number of sg elements * * Returns the number of frames required for numnber of sge ' s ( sge_count ) static u32 megasas_get_frame_count(struct megasas_instance *instance,int num_cnt;int sge_bytes;0 ;sizeof (struct megasas_sge64) :sizeof (struct megasas_sge32);if (instance->flag_ieee) {sizeof (struct megasas_sge_skinny);/* * Main frame can contain 2 SGEs for 64 - bit SGLs and * 3 SGEs for 32 - bit SGLs for ldio & * 1 SGEs for 64 - bit SGLs and * 2 SGEs for 32 - bit SGLs for pthru frame if (unlikely(frame_type == PTHRU_FRAME)) {if (instance->flag_ieee == 1 ) {1 ;else if (IS_DMA64)1 ;else 2 ;else {if (instance->flag_ieee == 1 ) {1 ;else if (IS_DMA64)2 ;else 3 ;if (num_cnt > 0 ) {1 : 0 ) ;/* Main frame */ 1 ;if (frame_count > 7 )8 ;return frame_count;/** * megasas_build_dcdb - Prepares a direct cdb ( DCDB ) command * @ instance : Adapter soft state * @ scp : SCSI command * @ cmd : Command to be prepared in * * This function prepares CDB commands . These are typcially pass - through * commands to the devices . static int struct megasas_instance *instance, struct scsi_cmnd *scp,struct megasas_cmd *cmd)0 ;struct megasas_pthru_frame *pthru;struct megasas_pthru_frame *)cmd->frame;if (scp->sc_data_direction == DMA_TO_DEVICE)else if (scp->sc_data_direction == DMA_FROM_DEVICE)else if (scp->sc_data_direction == DMA_NONE)if (instance->flag_ieee == 1 ) {/* * Prepare the DCDB frame 0 x0;0 x0;0 ;0 ;/* * If the command is for the tape device , set the * pthru timeout to the os layer timeout value . if (scp->device->type == TYPE_TAPE) {if (scsi_cmd_to_rq(scp)->timeout / HZ > 0 xFFFF)0 xFFFF);else /* * Construct SGL if (instance->flag_ieee == 1 ) {else if (IS_DMA64) {else if (pthru->sge_count > instance->max_num_sge) {"DCDB too many SGE NUM=%x\n" ,return 0 ;/* * Sense info specific /* * Compute the total number of frames this command consumes . FW uses * this number to pull sufficient number of frames from host memory . return cmd->frame_count;/** * megasas_build_ldio - Prepares IOs to logical devices * @ instance : Adapter soft state * @ scp : SCSI command * @ cmd : Command to be prepared * * Frames ( and accompanying SGLs ) for regular SCSI IOs use this function . static int struct megasas_instance *instance, struct scsi_cmnd *scp,struct megasas_cmd *cmd)0 ];0 ;struct megasas_io_frame *ldio;struct megasas_io_frame *)cmd->frame;if (scp->sc_data_direction == DMA_TO_DEVICE)else if (scp->sc_data_direction == DMA_FROM_DEVICE)if (instance->flag_ieee == 1 ) {/* * Prepare the Logical IO frame : 2 nd bit is zero for all read cmds 0 x02) ? MFI_CMD_LD_WRITE : MFI_CMD_LD_READ;0 x0;0 x0;0 ;0 ;0 ;0 ;6 ) ? scp->cmnd[1 ] : 0 ;/* * 6 - byte READ ( 0 x08 ) or WRITE ( 0 x0A ) cdb if (scp->cmd_len == 6 ) {4 ]);1 ] << 16 ) |2 ] << 8 ) |3 ]);0 x1FFFFF);/* * 10 - byte READ ( 0 x28 ) or WRITE ( 0 x2A ) cdb else if (scp->cmd_len == 10 ) {8 ] |7 ] << 8 ));2 ] << 24 ) |3 ] << 16 ) |4 ] << 8 ) |5 ]);/* * 12 - byte READ ( 0 xA8 ) or WRITE ( 0 xAA ) cdb else if (scp->cmd_len == 12 ) {6 ] << 24 ) |7 ] << 16 ) |8 ] << 8 ) |9 ]);2 ] << 24 ) |3 ] << 16 ) |4 ] << 8 ) |5 ]);/* * 16 - byte READ ( 0 x88 ) or WRITE ( 0 x8A ) cdb else if (scp->cmd_len == 16 ) {10 ] << 24 ) |11 ] << 16 ) |12 ] << 8 ) |13 ]);6 ] << 24 ) |7 ] << 16 ) |8 ] << 8 ) |9 ]);2 ] << 24 ) |3 ] << 16 ) |4 ] << 8 ) |5 ]);/* * Construct SGL if (instance->flag_ieee) {else if (IS_DMA64) {else if (ldio->sge_count > instance->max_num_sge) {"build_ld_io: sge_count = %x\n" ,return 0 ;/* * Sense info specific 0 ;/* * Compute the total number of frames this command consumes . FW uses * this number to pull sufficient number of frames from host memory . return cmd->frame_count;/** * megasas_cmd_type - Checks if the cmd is for logical drive / sysPD * and whether it ' s RW or non RW * @ cmd : SCSI command * inline int megasas_cmd_type(struct scsi_cmnd *cmd)int ret;switch (cmd->cmnd[0 ]) {case READ_10:case WRITE_10:case READ_12:case WRITE_12:case READ_6:case WRITE_6:case READ_16:case WRITE_16:break ;default :return ret;/** * megasas_dump_pending_frames - Dumps the frame address of all pending cmds * in FW * @ instance : Adapter soft state static inline void struct megasas_instance *instance)struct megasas_cmd *cmd;int i,n;union megasas_sgl *mfi_sgl;struct megasas_io_frame *ldio;struct megasas_pthru_frame *pthru;"[%d]: Dumping Frame Phys Address of all pending cmds in FW\n" ,instance->host->host_no);"[%d]: Total OS Pending cmds : %d\n" ,instance->host->host_no,atomic_read(&instance->fw_outstanding));if (IS_DMA64)"[%d]: 64 bit SGLs were sent to FW\n" ,instance->host->host_no);else "[%d]: 32 bit SGLs were sent to FW\n" ,instance->host->host_no);"[%d]: Pending OS cmds in FW : \n" ,instance->host->host_no);for (i = 0 ; i < max_cmd; i++) {if (!cmd->scmd)continue ;"[%d]: Frame addr :0x%08lx : " ,instance->host->host_no,(unsigned long )cmd->frame_phys_addr);if (megasas_cmd_type(cmd->scmd) == READ_WRITE_LDIO) {struct megasas_io_frame *)cmd->frame;"[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x," " lba lo : 0x%x, lba_hi : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n" ,else {struct megasas_pthru_frame *) cmd->frame;"[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x, " "lun : 0x%x, cdb_len : 0x%x, data xfer len : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n" ,if (megasas_dbg_lvl & MEGASAS_DBG_LVL) {for (n = 0 ; n < sgcount; n++) {if (IS_DMA64)"sgl len : 0x%x, sgl addr : 0x%llx\n" ,else "sgl len : 0x%x, sgl addr : 0x%x\n" ,/*for max_cmd*/ "[%d]: Pending Internal cmds in FW : \n" ,instance->host->host_no);for (i = 0 ; i < max_cmd; i++) {if (cmd->sync_cmd == 1 )"0x%08lx : " , (unsigned long )cmd->frame_phys_addr);"[%d]: Dumping Done\n\n" ,instance->host->host_no);struct megasas_instance *instance,struct scsi_cmnd *scmd)struct megasas_cmd *cmd;if (!cmd)return SCSI_MLQUEUE_HOST_BUSY;/* * Logical drive command if (megasas_cmd_type(scmd) == READ_WRITE_LDIO)else if (!frame_count)goto out_return_cmd;/* * Issue the command to the FW 1 , instance->reg_set);return 0 ;return SCSI_MLQUEUE_HOST_BUSY;/** * megasas_queue_command - Queue entry point * @ shost : adapter SCSI host * @ scmd : SCSI command to be queued static int struct Scsi_Host *shost, struct scsi_cmnd *scmd)struct megasas_instance *instance;struct MR_PRIV_DEVICE *mr_device_priv_data;struct megasas_instance *)if (instance->unload == 1 ) {16 ;return 0 ;if (instance->issuepend_done == 0 )return SCSI_MLQUEUE_HOST_BUSY;/* Check for an mpio path and adjust behavior */ if (atomic_read(&instance->adprecovery) == MEGASAS_ADPRESET_SM_INFAULT) {if (megasas_check_mpio_paths(instance, scmd) ==16 )) {return SCSI_MLQUEUE_HOST_BUSY;else {16 ;return 0 ;if (!mr_device_priv_data ||16 ;return 0 ;if (MEGASAS_IS_LOGICAL(scmd->device)) {if (instance->ld_tgtid_status[ld_tgt_id] == LD_TARGET_ID_DELETED) {16 ;return 0 ;if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)return SCSI_MLQUEUE_HOST_BUSY;if (mr_device_priv_data->tm_busy)return SCSI_MLQUEUE_DEVICE_BUSY;0 ;if (MEGASAS_IS_LOGICAL(scmd->device) &&16 ;goto out_done;if ((scmd->cmnd[0 ] == SYNCHRONIZE_CACHE) &&16 ;goto out_done;return instance->instancet->build_and_issue_cmd(instance, scmd);return 0 ;static struct megasas_instance *megasas_lookup_instance(u16 host_no)int i;for (i = 0 ; i < megasas_mgmt_info.max_index; i++) {if ((megasas_mgmt_info.instance[i]) &&return megasas_mgmt_info.instance[i];return NULL;/** megasas_set_dynamic_target_properties - * Device property set by driver may not be static and it is required to be * updated after OCR * * set tm_capable . * set dma alignment ( only for eedp protection enable vd ) . * * @ sdev : OS provided scsi device * * Returns void void megasas_set_dynamic_target_properties(struct scsi_device *sdev,struct queue_limits *lim, bool is_target_prop)0 , ld;struct megasas_instance *instance;struct fusion_context *fusion;struct MR_PRIV_DEVICE *mr_device_priv_data;struct MR_PD_CFG_SEQ_NUM_SYNC *pd_sync;struct MR_LD_RAID *raid;struct MR_DRV_RAID_MAP_ALL *local_map_ptr;if (!fusion || !mr_device_priv_data)return ;if (MEGASAS_IS_LOGICAL(sdev)) {2 ) * MEGASAS_MAX_DEV_PER_CHANNEL)1 )];if (ld >= instance->fw_supported_vd_count)return ;if (raid->capability.ldPiMode == MR_PROT_INFO_TYPE_CONTROLLER) {if (lim)0 x7;if (!raid->flags.isEPD)1 ;else if (instance->use_seqnum_jbod_fp) {void *)fusion->pd_seq_sync1 ) & 1 ];if (is_target_prop && instance->tgt_prop->reset_tmo) {/* * If FW provides a target reset timeout value , driver will use * it . If not set , fallback to default values . else {/* * megasas_set_nvme_device_properties - * set nomerges = 2 * set virtual page boundary = 4 K ( current mr_nvme_pg_size is 4 K ) . * set maximum io transfer = MDTS of NVME device provided by MR firmware . * * MR firmware provides value in KB . Caller of this function converts * kb into bytes . * * e . a MDTS = 5 means 2 ^ 5 * nvme page size . ( In case of 4 K page size , * MR firmware provides value 128 as ( 32 * 4 K ) = 128 K . * * @ sdev : scsi device * @ max_io_size : maximum io transfer size * static inline void struct scsi_device *sdev,struct queue_limits *lim, u32 max_io_size)struct megasas_instance *instance;struct megasas_instance *)sdev->host->hostdata;512 ;1 ;/* * megasas_set_fw_assisted_qd - * set device queue depth to can_queue * set device queue depth to fw assisted qd * * @ sdev : scsi device * @ is_target_prop true , if fw provided target properties . static void megasas_set_fw_assisted_qd(struct scsi_device *sdev,bool is_target_prop)struct megasas_instance *instance;struct MR_PRIV_DEVICE *mr_device_priv_data;switch (interface_type) {case SAS_PD:break ;case SATA_PD:break ;case NVME_PD:break ;if (is_target_prop) {if (tgt_device_qd)int )tgt_device_qd);if (instance->enable_sdev_max_qd && interface_type != UNKNOWN_DRIVE)/* * megasas_set_static_target_properties - * Device property set by driver are static and it is not required to be * updated after OCR . * * set io timeout * set device queue depth * set nvme device properties . see - megasas_set_nvme_device_properties * * @ sdev : scsi device * @ is_target_prop true , if fw provided target properties . static void megasas_set_static_target_properties(struct scsi_device *sdev,struct queue_limits *lim, bool is_target_prop)struct megasas_instance *instance;/* * The RAID firmware may require extended timeouts . /* max_io_size_kb will be set to non zero for * nvme based vd and syspd . if (is_target_prop)if (instance->nvme_page_size && max_io_size_kb)10 );static int megasas_sdev_configure(struct scsi_device *sdev,struct queue_limits *lim)0 ;struct megasas_instance *instance;int ret_target_prop = DCMD_FAILED;bool is_target_prop = false ;if (instance->pd_list_not_supported) {if (!MEGASAS_IS_LOGICAL(sdev) && sdev->type == TYPE_DISK) {if (instance->pd_list[pd_index].driveState !=return -ENXIO;/* Send DCMD to Firmware and cache the information */ if ((instance->pd_info) && !MEGASAS_IS_LOGICAL(sdev))/* Some ventura firmware may not have instance->nvme_page_size set. * Do not send MR_DCMD_DRV_GET_TARGET_PROP if ((instance->tgt_prop) && (instance->nvme_page_size))true : false ;/* This sdev property may change post OCR */ if (!MEGASAS_IS_LOGICAL(sdev))1 ;return 0 ;static int megasas_sdev_init(struct scsi_device *sdev)0 , ld_tgt_id;struct megasas_instance *instance ;struct MR_PRIV_DEVICE *mr_device_priv_data;if (!MEGASAS_IS_LOGICAL(sdev)) {/* * Open the OS scan to the SYSTEM PD if ((instance->pd_list_not_supported ||goto scan_target;return -ENXIO;else if (!MEGASAS_IS_LUN_VALID(sdev)) {"%s: invalid LUN\n" , __func__);return -ENXIO;sizeof (*mr_device_priv_data),if (!mr_device_priv_data)return -ENOMEM;if (MEGASAS_IS_LOGICAL(sdev)) {if (megasas_dbg_lvl & LD_PD_DEBUG)"LD target ID %d created.\n" , ld_tgt_id);return 0 ;static void megasas_sdev_destroy(struct scsi_device *sdev)struct megasas_instance *instance;if (MEGASAS_IS_LOGICAL(sdev)) {if (!MEGASAS_IS_LUN_VALID(sdev)) {"%s: invalid LUN\n" , __func__);return ;if (megasas_dbg_lvl & LD_PD_DEBUG)"LD target ID %d removed from OS stack\n" , ld_tgt_id);/** megasas_complete_outstanding_ioctls - Complete outstanding ioctls after a * kill adapter * @ instance : Adapter soft state * static void megasas_complete_outstanding_ioctls(struct megasas_instance *instance)int i;struct megasas_cmd *cmd_mfi;struct megasas_cmd_fusion *cmd_fusion;struct fusion_context *fusion = instance->ctrl_context;/* Find all outstanding ioctls */ if (fusion) {for (i = 0 ; i < instance->max_fw_cmds; i++) {if (cmd_fusion->sync_cmd_idx != (u32)ULONG_MAX) {if (cmd_mfi->sync_cmd &&else {for (i = 0 ; i < instance->max_fw_cmds; i++) {if (cmd_mfi->sync_cmd && cmd_mfi->frame->hdr.cmd !=void megaraid_sas_kill_hba(struct megasas_instance *instance)if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {"Adapter already dead, skipping kill HBA\n" );return ;/* Set critical error to block I/O & ioctls in case caller didn't */ /* Wait 1 second to ensure IO or ioctls in build have posted */ 1000 );if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||if (!instance->requestorId) {/* Flush */ if (instance->requestorId && instance->peerIsPresent)0 xff, MEGASAS_MAX_LD_IDS);else {/* Complete outstanding ioctls when adapter is killed */ /** * megasas_check_and_restore_queue_depth - Check if queue depth needs to be * restored to max value * @ instance : Adapter soft state * void struct megasas_instance *instance)unsigned long flags;if (instance->flag & MEGASAS_FW_BUSY5 * HZ)1 ) {/** * megasas_complete_cmd_dpc - Returns FW ' s controller structure * @ instance_addr : Address of adapter soft state * * Tasklet to complete cmds static void megasas_complete_cmd_dpc(unsigned long instance_addr)struct megasas_cmd *cmd;struct megasas_instance *instance =struct megasas_instance *)instance_addr;unsigned long flags;/* If we have already declared adapter dead, donot complete cmds */ if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)return ;while (consumer != producer) {if (context >= instance->max_fw_cmds) {"Unexpected context value %x\n" ,if (consumer == (instance->max_fw_cmds + 1 )) {0 ;/* * Check if we can restore can_queue static void megasas_sriov_heartbeat_handler(struct timer_list *t);/** * megasas_start_timer - Initializes sriov heartbeat timer object * @ instance : Adapter soft state * void megasas_start_timer(struct megasas_instance *instance)struct timer_list *timer = &instance->sriov_heartbeat_timer;0 );static void struct megasas_instance *instance);static void struct work_struct *work);static void megasas_do_ocr(struct megasas_instance *instance)if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||0 ;0 );static int megasas_get_ld_vf_affiliation_111(struct megasas_instance *instance,int initial)struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;struct MR_LD_VF_AFFILIATION_111 *new_affiliation_111 = NULL;int ld, retval = 0 ;if (!cmd) {"megasas_get_ld_vf_affiliation_111:" "Failed to get cmd for scsi%d\n" ,return -ENOMEM;if (!instance->vf_affiliation_111) {"SR-IOV: Couldn't get LD/VF " "affiliation for scsi%d\n" , instance->host->host_no);return -ENOMEM;if (initial)0 ,sizeof (struct MR_LD_VF_AFFILIATION_111));else {sizeof (struct MR_LD_VF_AFFILIATION_111),if (!new_affiliation_111) {"SR-IOV: Couldn't allocate " "memory for new affiliation for scsi%d\n" ,return -ENOMEM;0 , MFI_MBOX_SIZE);1 ;0 ;0 ;sizeof (struct MR_LD_VF_AFFILIATION_111));if (initial)0 ].phys_addr =else 0 ].phys_addr =0 ].length = cpu_to_le32(sizeof (struct MR_LD_VF_AFFILIATION_111));"SR-IOV: Getting LD/VF affiliation for " "scsi%d\n" , instance->host->host_no);if (megasas_issue_blocked_cmd(instance, cmd, 0 ) != DCMD_SUCCESS) {"SR-IOV: LD/VF affiliation DCMD" " failed with status 0x%x for scsi%d\n" ,1 ; /* Do a scan if we couldn't get affiliation */ goto out;if (!initial) {for (ld = 0 ; ld < new_affiliation_111->vdCount; ld++)if (instance->vf_affiliation_111->map[ld].policy[thisVf] !="SR-IOV: " "Got new LD/VF affiliation for scsi%d\n" ,sizeof (struct MR_LD_VF_AFFILIATION_111));1 ;goto out;if (new_affiliation_111) {sizeof (struct MR_LD_VF_AFFILIATION_111),return retval;static int megasas_get_ld_vf_affiliation_12(struct megasas_instance *instance,int initial)struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;struct MR_LD_VF_AFFILIATION *new_affiliation = NULL;struct MR_LD_VF_MAP *newmap = NULL, *savedmap = NULL;int i, j, retval = 0 , found = 0 , doscan = 0 ;if (!cmd) {"megasas_get_ld_vf_affiliation12: " "Failed to get cmd for scsi%d\n" ,return -ENOMEM;if (!instance->vf_affiliation) {"SR-IOV: Couldn't get LD/VF " "affiliation for scsi%d\n" , instance->host->host_no);return -ENOMEM;if (initial)0 , (MAX_LOGICAL_DRIVES + 1 ) *sizeof (struct MR_LD_VF_AFFILIATION));else {1 ) * sizeof (struct MR_LD_VF_AFFILIATION),if (!new_affiliation) {"SR-IOV: Couldn't allocate " "memory for new affiliation for scsi%d\n" ,return -ENOMEM;0 , MFI_MBOX_SIZE);1 ;0 ;0 ;1 ) *sizeof (struct MR_LD_VF_AFFILIATION));if (initial)0 ].phys_addr =else 0 ].phys_addr =0 ].length = cpu_to_le32((MAX_LOGICAL_DRIVES + 1 ) *sizeof (struct MR_LD_VF_AFFILIATION));"SR-IOV: Getting LD/VF affiliation for " "scsi%d\n" , instance->host->host_no);if (megasas_issue_blocked_cmd(instance, cmd, 0 ) != DCMD_SUCCESS) {"SR-IOV: LD/VF affiliation DCMD" " failed with status 0x%x for scsi%d\n" ,1 ; /* Do a scan if we couldn't get affiliation */ goto out;if (!initial) {if (!new_affiliation->ldCount) {"SR-IOV: Got new LD/VF " "affiliation for passive path for scsi%d\n" ,1 ;goto out;for (i = 0 ; i < new_affiliation->ldCount; i++) {0 ;for (j = 0 ; j < instance->vf_affiliation->ldCount;if (newmap->ref.targetId ==1 ;if (newmap->policy[thisVf] !=1 ;goto out;struct MR_LD_VF_MAP *)unsigned char *)savedmap +if (!found && newmap->policy[thisVf] !=1 ;goto out;struct MR_LD_VF_MAP *)unsigned char *)newmap + newmap->size);for (i = 0 ; i < instance->vf_affiliation->ldCount; i++) {0 ;for (j = 0 ; j < new_affiliation->ldCount; j++) {if (savedmap->ref.targetId ==1 ;if (savedmap->policy[thisVf] !=1 ;goto out;struct MR_LD_VF_MAP *)unsigned char *)newmap +if (!found && savedmap->policy[thisVf] !=1 ;goto out;struct MR_LD_VF_MAP *)unsigned char *)savedmap +if (doscan) {"SR-IOV: Got new LD/VF " "affiliation for scsi%d\n" , instance->host->host_no);1 ;if (new_affiliation)1 ) *sizeof (struct MR_LD_VF_AFFILIATION),return retval;/* This function will get the current SR-IOV LD/VF affiliation */ static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,int initial)int retval;if (instance->PlasmaFW111)else return retval;/* This function will tell FW to start the SR-IOV heartbeat */ int megasas_sriov_start_heartbeat(struct megasas_instance *instance,int initial)struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;int retval = 0 ;if (!cmd) {"megasas_sriov_start_heartbeat: " "Failed to get cmd for scsi%d\n" ,return -ENOMEM;if (initial) {sizeof (struct MR_CTRL_HB_HOST_MEM),if (!instance->hb_host_mem) {"SR-IOV: Couldn't allocate" " memory for heartbeat host memory for scsi%d\n" ,goto out;0 , MFI_MBOX_SIZE);0 ] = cpu_to_le16(sizeof (struct MR_CTRL_HB_HOST_MEM));1 ;0 ;0 ;sizeof (struct MR_CTRL_HB_HOST_MEM));sizeof (struct MR_CTRL_HB_HOST_MEM));"SR-IOV: Starting heartbeat for scsi%d\n" ,if ((instance->adapter_type != MFI_SERIES) &&else if (retval) {"SR-IOV: MR_DCMD_CTRL_SHARED_HOST" "_MEM_ALLOC DCMD %s for scsi%d\n" ,"timed out" : "failed" , instance->host->host_no);1 ;return retval;/* Handler for SR-IOV heartbeat */ static void megasas_sriov_heartbeat_handler(struct timer_list *t)struct megasas_instance *instance =if (instance->hb_host_mem->HB.fwCounter !=else {"SR-IOV: Heartbeat never " "completed for scsi%d\n" , instance->host->host_no);/** * megasas_wait_for_outstanding - Wait for all outstanding cmds * @ instance : Adapter soft state * * This function waits for up to MEGASAS_RESET_WAIT_TIME seconds for FW to * complete all its outstanding commands . Returns error if one or more IOs * are pending after this time period . It also marks the controller dead . static int megasas_wait_for_outstanding(struct megasas_instance *instance)int i, sl, outstanding;unsigned long flags;struct list_head clist_local;struct megasas_cmd *reset_cmd;if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {"%s:%d HBA is killed.\n" ,return FAILED;if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {"HBA reset wait ...\n" );for (i = 0 ; i < wait_time; i++) {1000 );if (atomic_read(&instance->adprecovery) == MEGASAS_HBA_OPERATIONAL)break ;if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {"reset: Stopping HBA.\n" );return FAILED;0 ;while (!list_empty(&clist_local)) {struct megasas_cmd, list);if (reset_cmd->scmd) {16 ;"%d:%p reset [%02x]\n" ,0 ]);else if (reset_cmd->sync_cmd) {"%p synch cmds" "reset queue\n" ,0 , instance->reg_set);else {"%p unexpected" "cmds lst\n" ,return SUCCESS;for (i = 0 ; i < resetwaittime; i++) {if (!outstanding)break ;if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {"[%2d]waiting for %d " "commands to complete\n" ,i,outstanding);/* * Call cmd completion routine . Cmd to be * be completed directly without depending on isr . unsigned long )instance);1000 );0 ;if ((!outstanding && (fw_state == MFI_STATE_OPERATIONAL)))goto no_outstanding;if (instance->disableOnlineCtrlReset)goto kill_hba_and_failed;do {if ((fw_state == MFI_STATE_FAULT) || atomic_read(&instance->fw_outstanding)) {"%s:%d waiting_for_outstanding: before issue OCR. FW state = 0x%x, outstanding 0x%x\n" ,if (i == 3 )goto kill_hba_and_failed;if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {"%s:%d OCR failed and HBA is killed.\n" ,return FAILED;"%s:%d waiting_for_outstanding: after issue OCR.\n" ,for (sl = 0 ; sl < 10 ; sl++)500 );if ((!outstanding && (fw_state == MFI_STATE_OPERATIONAL)))goto no_outstanding;while (i <= 3 );"%s:%d no more pending commands remain after reset handling.\n" ,return SUCCESS;/* Reset not supported, kill adapter */ "%s:%d killing adapter scsi%d" " disableOnlineCtrlReset %d fw_outstanding %d \n" ,return FAILED;/** * megasas_generic_reset - Generic reset routine * @ scmd : Mid - layer SCSI command * * This routine implements a generic reset handler for device , bus and host * reset requests . Device , bus and host specific reset handlers can use this * function after they do their specific tasks . static int megasas_generic_reset(struct scsi_cmnd *scmd)int ret_val;struct megasas_instance *instance;struct megasas_instance *)scmd->device->host->hostdata;"megasas: RESET cmd=%x retries=%x\n" ,0 ], scmd->retries);if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {"cannot recover from previous reset failures\n" );return FAILED;if (ret_val == SUCCESS)"reset successful\n" );else "failed to do reset\n" );return ret_val;/** * megasas_reset_timer - quiesce the adapter if required * @ scmd : scsi cmnd * * Sets the FW busy flag and reduces the host - > can_queue if the * cmd has not been completed within the timeout period . static enum scsi_timeout_action megasas_reset_timer(struct scsi_cmnd *scmd)struct megasas_instance *instance;unsigned long flags;if (time_after(jiffies, scmd->jiffies_at_alloc +2 ) * HZ)) {return SCSI_EH_NOT_HANDLED;struct megasas_instance *)scmd->device->host->hostdata;if (!(instance->flag & MEGASAS_FW_BUSY)) {/* FW is busy, throttle IO */ return SCSI_EH_RESET_TIMER;/** * megasas_dump - This function will print hexdump of provided buffer . * @ buf : Buffer to be dumped * @ sz : Size in bytes * @ format : Different formats of dumping e . g . format = n will * cause only ' n ' 32 bit words to be dumped in a single * line . inline void void *buf, int sz, int format)int i;for (i = 0 ; i < (sz / sizeof (__le32)); i++) {if ((i % format) == 0 ) {if (i != 0 )"\n" );"%08x: " , (i * 4 ));"%08x " , le32_to_cpu(buf_loc[i]));"\n" );/** * megasas_dump_reg_set - This function will print hexdump of register set * @ reg_set : Register set to be dumped inline void void __iomem *reg_set)unsigned int i, sz = 256 ;for (i = 0 ; i < (sz / sizeof (u32)); i++)"%08x: %08x\n" , (i * 4 ), readl(®[i]));/** * megasas_dump_fusion_io - This function will print key details * of SCSI IO * @ scmd : SCSI command pointer of SCSI IO void struct scsi_cmnd *scmd)struct megasas_cmd_fusion *cmd = megasas_priv(scmd)->cmd_priv;union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;struct megasas_instance *instance;struct megasas_instance *)scmd->device->host->hostdata;"scmd: (0x%p) retries: 0x%x allowed: 0x%x\n" ,if (cmd) {union MEGASAS_REQUEST_DESCRIPTOR_UNION *)cmd->request_desc;"Request descriptor details:\n" );"RequestFlags:0x%x MSIxIndex:0x%x SMID:0x%x LMID:0x%x DevHandle:0x%x\n" ,"IO request frame:\n" );8 );"Chain frame:\n" );8 );/* * megasas_dump_sys_regs - This function will dump system registers through * sysfs . * @ reg_set : Pointer to System register set . * @ buf : Buffer to which output is to be written . * @ return : Number of bytes written to buffer . static inline ssize_tvoid __iomem *reg_set, char *buf)unsigned int i, sz = 256 ;int bytes_wrote = 0 ;char *loc = (char *)buf;for (i = 0 ; i < sz / sizeof (u32); i++) {"%08x: %08x\n" , (i * 4 ),return bytes_wrote;/** * megasas_reset_bus_host - Bus & host reset handler entry point * @ scmd : Mid - layer SCSI command static int megasas_reset_bus_host(struct scsi_cmnd *scmd)int ret;struct megasas_instance *instance;struct megasas_instance *)scmd->device->host->hostdata;"OCR is requested due to IO timeout!!\n" );"SCSI host state: %d SCSI host busy: %d FW outstanding: %d\n" ,/* * First wait for all commands to complete if (instance->adapter_type == MFI_SERIES) {else {return ret;/** * megasas_task_abort - Issues task abort request to firmware * ( supported only for fusion adapters ) * @ scmd : SCSI command pointer static int megasas_task_abort(struct scsi_cmnd *scmd)int ret;struct megasas_instance *instance;struct megasas_instance *)scmd->device->host->hostdata;if (instance->adapter_type != MFI_SERIES)else {"TASK ABORT not supported\n" );return ret;/** * megasas_reset_target : Issues target reset request to firmware * ( supported only for fusion adapters ) * @ scmd : SCSI command pointer static int megasas_reset_target(struct scsi_cmnd *scmd)int ret;struct megasas_instance *instance;struct megasas_instance *)scmd->device->host->hostdata;if (instance->adapter_type != MFI_SERIES)else {"TARGET RESET not supported\n" );return ret;/** * megasas_bios_param - Returns disk geometry for a disk * @ sdev : device handle * @ bdev : block device * @ capacity : drive capacity * @ geom : geometry parameters static int struct scsi_device *sdev, struct block_device *bdev,int geom[])int heads;int sectors;unsigned long tmp;/* Default heads (64) & sectors (32) */ 64 ;32 ;/* * Handle extended translation size for logical drives > 1 Gb if (capacity >= 0 x200000) {255 ;63 ;0 ] = heads;1 ] = sectors;2 ] = cylinders;return 0 ;static void megasas_map_queues(struct Scsi_Host *shost)struct megasas_instance *instance;int qoff = 0 , offset;struct blk_mq_queue_map *map;struct megasas_instance *)shost->hostdata;if (shost->nr_hw_queues == 1 )return ;/* Setup Default hctx */ 0 ;/* we never use READ queue, so can't cheat blk-mq */ 0 ;/* Setup Poll hctx */ if (map->nr_queues) {/* * The poll queue ( s ) doesn ' t have an IRQ ( and hence IRQ * affinity ) , so use the regular blk - mq cpu mapping static void megasas_aen_polling(struct work_struct *work);/** * megasas_service_aen - Processes an event notification * @ instance : Adapter soft state * @ cmd : AEN command completed by the ISR * * For AEN , driver sends a command down to FW that is held by the FW till an * event occurs . When an event of interest occurs , FW completes the command * that it was previously holding . * * This routines sends SIGIO signal to processes that have registered with the * driver for AEN . static void struct megasas_instance *instance, struct megasas_cmd *cmd)unsigned long flags;/* * Don ' t signal app if it is just an aborted previously registered aen if ((!cmd->abort_aen) && (instance->unload == 0 )) {1 ;else 0 ;if ((instance->unload == 0 ) &&1 ))) {struct megasas_aen_event *ev;sizeof (*ev), GFP_ATOMIC);if (!ev) {"megasas_service_aen: out of memory\n" );else {0 );static ssize_tstruct device *cdev,struct device_attribute *attr, const char *buf, size_t count)struct Scsi_Host *shost = class_to_shost(cdev);struct megasas_instance *instance =struct megasas_instance *) shost->hostdata;int val = 0 ;if (kstrtoint(buf, 0 , &val) != 0 )return -EINVAL;return strlen(buf);static ssize_tstruct device *cdev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(cdev);struct megasas_instance *instance =struct megasas_instance *) shost->hostdata;unsigned long dmachunk = CRASH_DMA_BUF_SIZE;unsigned long chunk_left_bytes;unsigned long src_addr;if (!instance->crash_dump_buf ||"Firmware crash dump is not available\n" );return -EINVAL;if (buff_offset > (instance->fw_crash_buffer_size * dmachunk)) {"Firmware crash dump offset is out of range\n" );return 0 ;1 ) : size;unsigned long )instance->crash_buf[buff_offset / dmachunk] +void *)src_addr, size);return size;static ssize_tstruct device *cdev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(cdev);struct megasas_instance *instance =struct megasas_instance *) shost->hostdata;return snprintf(buf, PAGE_SIZE, "%ld\n" , (unsigned long )1024 * 1024 )/PAGE_SIZE);static ssize_tstruct device *cdev,struct device_attribute *attr, const char *buf, size_t count)struct Scsi_Host *shost = class_to_shost(cdev);struct megasas_instance *instance =struct megasas_instance *) shost->hostdata;int val = 0 ;if (kstrtoint(buf, 0 , &val) != 0 )return -EINVAL;if ((val <= AVAILABLE || val > COPY_ERROR)) {"application updates invalid " "firmware crash state\n" );return -EINVAL;if ((val == COPIED) || (val == COPY_ERROR)) {if (val == COPY_ERROR)"application failed to " "copy Firmware crash dump\n" );else "Firmware crash dump " "copied successfully\n" );return strlen(buf);static ssize_tstruct device *cdev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(cdev);struct megasas_instance *instance =struct megasas_instance *) shost->hostdata;return snprintf(buf, PAGE_SIZE, "%d\n" , instance->fw_crash_state);static ssize_tstruct device *cdev,struct device_attribute *attr, char *buf)return snprintf(buf, PAGE_SIZE, "%ld\n" , (unsigned long )PAGE_SIZE - 1 );static ssize_tstruct device *cdev, struct device_attribute *attr,char *buf)struct Scsi_Host *shost = class_to_shost(cdev);struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;return snprintf(buf, PAGE_SIZE, "%d\n" , atomic_read(&instance->ldio_outstanding));static ssize_tstruct device *cdev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(cdev);struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;return snprintf(buf, PAGE_SIZE, "%d\n" , atomic_read(&instance->fw_outstanding));static ssize_tstruct device *cdev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(cdev);struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;return snprintf(buf, PAGE_SIZE, "%d\n" , instance->enable_sdev_max_qd);static ssize_tstruct device *cdev,struct device_attribute *attr, const char *buf, size_t count)struct Scsi_Host *shost = class_to_shost(cdev);struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;0 ;bool is_target_prop;int ret_target_prop = DCMD_FAILED;struct scsi_device *sdev;if (kstrtou32(buf, 0 , &val) != 0 ) {"megasas: could not set enable_sdev_max_qd\n" );return -EINVAL;if (val)true ;else false ;true : false ;return strlen(buf);static ssize_tstruct device *cdev,struct device_attribute *attr, char *buf)struct Scsi_Host *shost = class_to_shost(cdev);struct megasas_instance *instance =struct megasas_instance *)shost->hostdata;return megasas_dump_sys_regs(instance->reg_set, buf);static ssize_tstruct device *cdev, struct device_attribute *attr,char *buf)struct Scsi_Host *shost = class_to_shost(cdev);struct megasas_instance *instance =struct megasas_instance *)shost->hostdata;return snprintf(buf, PAGE_SIZE, "%ld\n" ,unsigned long )instance->map_id);static DEVICE_ATTR_RW(fw_crash_buffer);static DEVICE_ATTR_RO(fw_crash_buffer_size);static DEVICE_ATTR_RW(fw_crash_state);static DEVICE_ATTR_RO(page_size);static DEVICE_ATTR_RO(ldio_outstanding);static DEVICE_ATTR_RO(fw_cmds_outstanding);static DEVICE_ATTR_RW(enable_sdev_max_qd);static DEVICE_ATTR_RO(dump_system_regs);static DEVICE_ATTR_RO(raid_map_id);static struct attribute *megaraid_host_attrs[] = {/* * Scsi host template for megaraid_sas driver static const struct scsi_host_template megasas_template = {"Avago SAS based MegaRAID driver" ,"megaraid_sas" ,0 xffffffff,sizeof (struct megasas_cmd_priv),/** * megasas_complete_int_cmd - Completes an internal command * @ instance : Adapter soft state * @ cmd : Command to be completed * * The megasas_issue_blocked_cmd ( ) function waits for a command to complete * after it issues a command . This function wakes up that waiting routine by * calling wake_up ( ) on the wait queue . static void struct megasas_instance *instance,struct megasas_cmd *cmd)if (cmd->cmd_status_drv == DCMD_INIT)/** * megasas_complete_abort - Completes aborting a command * @ instance : Adapter soft state * @ cmd : Cmd that was issued to abort another cmd * * The megasas_issue_blocked_abort_cmd ( ) function waits on abort_cmd_wait_q * after it issues an abort on a previously issued command . This function * wakes up all functions waiting on the same wait queue . static void struct megasas_instance *instance,struct megasas_cmd *cmd)if (cmd->sync_cmd) {0 ;static void struct megasas_instance *instance)for (i = 0 ; (i < MEGASAS_MAX_LD_IDS); i++) {if (instance->ld_ids_prev[i] != 0 xff &&0 xff) {if (megasas_dbg_lvl & LD_PD_DEBUG)"LD target ID %d removed from RAID map\n" , i);/** * megasas_complete_cmd - Completes a command * @ instance : Adapter soft state * @ cmd : Command to be completed * @ alt_status : If non - zero , use this value as status to * SCSI mid - layer instead of the value returned * by the FW . This should be used if caller wants * an alternate status ( as in the case of aborted * commands ) void struct megasas_instance *instance, struct megasas_cmd *cmd,int exception = 0 ;struct megasas_header *hdr = &cmd->frame->hdr;unsigned long flags;struct fusion_context *fusion = instance->ctrl_context;/* flag for the retry reset */ 0 ;if (cmd->scmd)switch (hdr->cmd) {case MFI_CMD_INVALID:/* Some older 1068 controller FW may keep a pended MR_DCMD_CTRL_EVENT_GET_INFO left over from the main kernel when booting the kdump kernel . Ignore this command to "MFI_CMD_INVALID command " "completed\n" );"If you have a controller " "other than PERC5, please upgrade your firmware\n" );break ;case MFI_CMD_PD_SCSI_IO:case MFI_CMD_LD_SCSI_IO:/* * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been * issued either through an IO path or an IOCTL path . If it * was via IOCTL , we will send it to internal completion . if (cmd->sync_cmd) {0 ;break ;case MFI_CMD_LD_READ:case MFI_CMD_LD_WRITE:if (alt_status) {16 ;1 ;if (exception) {break ;switch (hdr->cmd_status) {case MFI_STAT_OK:16 ;break ;case MFI_STAT_SCSI_IO_FAILED:case MFI_STAT_LD_INIT_IN_PROGRESS:if (hdr->scsi_status == 0 xf0)16 ) | SAM_STAT_CHECK_CONDITION;else 16 ) | hdr->scsi_status;break ;case MFI_STAT_SCSI_DONE_WITH_ERROR:16 ) | hdr->scsi_status;if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) {0 ,break ;case MFI_STAT_LD_OFFLINE:case MFI_STAT_DEVICE_NOT_FOUND:16 ;break ;default :"MFI FW status %#x\n" ,16 ;break ;break ;case MFI_CMD_SMP:case MFI_CMD_STP:case MFI_CMD_NVME:case MFI_CMD_TOOLBOX:break ;case MFI_CMD_DCMD:/* Check for LD map update */ if ((opcode == MR_DCMD_LD_MAP_GET_INFO)1 ] == 1 )) {0 ;if (status != MFI_STAT_OK) {if (status != MFI_STAT_NOT_FOUND)"map syncfailed, status = 0x%x\n" ,else {break ;/* * Set fast path IO to ZERO . * Validate Map will set proper value . * Meanwhile all IOs will go as LD IO . if (status == MFI_STAT_OK &&1 )))) {1 ;else {0 ;if (instance->adapter_type >= INVADER_SERIES)break ;if (opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||0 ;/* FW has an updated PD sequence */ if ((opcode == MR_DCMD_SYSTEM_PD_MAP_GET_INFO) &&0 ] == 1 )) {if (status == MFI_STAT_OK) {/* Re-register a pd sync seq num cmd */ if (megasas_sync_pd_seq_num(instance, true ))false ;else false ;break ;/* * See if got an event notification if (opcode == MR_DCMD_CTRL_EVENT_WAIT)else break ;case MFI_CMD_ABORT:/* * Cmd issued to abort another cmd returned break ;default :"Unknown command completed! [0x%X]\n" ,break ;/** * megasas_issue_pending_cmds_again - issue all pending cmds * in FW again because of the fw reset * @ instance : Adapter soft state static inline void struct megasas_instance *instance)struct megasas_cmd *cmd;struct list_head clist_local;union megasas_evt_class_locale class_locale;unsigned long flags;while (!list_empty(&clist_local)) {struct megasas_cmd, list);if (cmd->sync_cmd || cmd->scmd) {"command %p, %p:%d" "detected to be pending while HBA reset\n" ,if (cmd->retry_for_fw_reset == 3 ) {"cmd %p, %p:%d" "was tried multiple times during reset." "Shutting down the HBA\n" ,1 );return ;if (cmd->sync_cmd == 1 ) {if (cmd->scmd) {"unexpected" "cmd attached to internal command!\n" );"%p synchronous cmd" "on the internal reset queue," "issue it again.\n" , cmd);0 , instance->reg_set);else if (cmd->scmd) {"%p scsi cmd [%02x]" "detected on the internal queue, issue again.\n" ,0 ]);1 , instance->reg_set);else {"%p unexpected cmd on the" "internal reset defer list while re-issue!!\n" ,if (instance->aen_cmd) {"aen_cmd in def process\n" );/* * Initiate AEN ( Asynchronous Event Notification ) 0 ;class = MR_EVT_CLASS_DEBUG;/* * Move the internal reset pending commands to a deferred queue . * * We move the commands pending at internal reset time to a * pending queue . This queue would be flushed after successful * completion of the internal reset sequence . if the internal reset * did not complete in time , the kernel reset handler would flush * these commands . static void struct megasas_instance *instance)struct megasas_cmd *cmd;int i;unsigned long flags;0 ;for (i = 0 ; i < max_cmd; i++) {if (cmd->sync_cmd == 1 || cmd->scmd) {"moving cmd[%d]:%p:%d:%p" "on the defer queue as internal\n" ,if (!list_empty(&cmd->list)) {"ERROR while" " moving this cmd:%p, %d %p, it was" "discovered on some list?\n" ,static void struct work_struct *work)struct megasas_instance *instance =struct megasas_instance, work_init);unsigned long flags;if (atomic_read(&instance->adprecovery) != MEGASAS_ADPRESET_SM_INFAULT) {"error, recovery st %x\n" ,return ;if (atomic_read(&instance->adprecovery) == MEGASAS_ADPRESET_SM_INFAULT) {"FW detected to be in fault" "state, restarting it...\n" );0 );1 );0 );"FW restarted successfully," "initiating next stage...\n" );"HBA recovery state machine," "state 2 starting...\n" );/* waiting for about 20 second before start the second init */ for (wait = 0 ; wait < 30 ; wait++) {1000 );if (megasas_transition_to_ready(instance, 1 )) {"adapter not ready\n" );1 );return ;if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||else {0 ;0 ;1 ;/** * megasas_deplete_reply_queue - Processes all completed commands * @ instance : Adapter soft state * @ alt_status : Alternate status to be returned to * SCSI mid - layer instead of the status * returned by the FW * Note : this must be called with hba lock held static int struct megasas_instance *instance,if (instance->instancet->check_reset(instance, instance->reg_set) == 1 )return IRQ_HANDLED;if (mfiStatus == 0 ) {/* Hardware may not set outbound_intr_status in MSI-X mode */ if (!instance->msix_vectors)return IRQ_NONE;if ((mfiStatus & MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE)) {if (fw_state != MFI_STATE_FAULT) {"fw state:%x\n" ,if ((fw_state == MFI_STATE_FAULT) &&0 )) {"wait adp restart\n" );if ((instance->pdev->device ==0 ;0 );"fwState=%x, stage:%d\n" ,return IRQ_HANDLED;else {"fwstate:%x, dis_OCR=%x\n" ,return IRQ_HANDLED;/** * megasas_isr - isr entry point * @ irq : IRQ number * @ devp : IRQ context address static irqreturn_t megasas_isr(int irq, void *devp)struct megasas_irq_context *irq_context = devp;struct megasas_instance *instance = irq_context->instance;unsigned long flags;if (atomic_read(&instance->fw_reset_no_pci_access))return IRQ_HANDLED;return rc;/** * megasas_transition_to_ready - Move the FW to READY state * @ instance : Adapter soft state * @ ocr : Adapter reset state * * During the initialization , FW passes can potentially be in any one of * several possible states . If the FW in operational , waiting - for - handshake * states , driver must take steps to bring it to ready state . Otherwise , it * has to wait for the ready state . int struct megasas_instance *instance, int ocr)int i;if (fw_state != MFI_STATE_READY)"Waiting for FW to come to ready" " state\n" );while (fw_state != MFI_STATE_READY) {switch (fw_state) {case MFI_STATE_FAULT:"FW in FAULT state, Fault code:0x%x subcode:0x%x func:%s\n" ,if (ocr) {break ;else {"System Register set:\n" );return -ENODEV;case MFI_STATE_WAIT_HANDSHAKE:/* * Set the CLR bit in inbound doorbell if ((instance->pdev->device ==else break ;case MFI_STATE_BOOT_MESSAGE_PENDING:if ((instance->pdev->device ==else break ;case MFI_STATE_OPERATIONAL:/* * Bring it to READY state ; assuming max wait 10 secs if ((instance->pdev->device ==if (instance->adapter_type != MFI_SERIES) {for (i = 0 ; i < (10 * 1000 ); i += 20 ) {if (megasas_readl(1 )20 );else break ;else break ;case MFI_STATE_UNDEFINED:/* * This state should not last for more than 2 seconds break ;case MFI_STATE_BB_INIT:break ;case MFI_STATE_FW_INIT:break ;case MFI_STATE_FW_INIT_2:break ;case MFI_STATE_DEVICE_SCAN:break ;case MFI_STATE_FLUSH_CACHE:break ;default :"Unknown state 0x%x\n" ,"System Register set:\n" );return -ENODEV;/* * The cur_state should not last for more than max_wait secs for (i = 0 ; i < max_wait * 50 ; i++) {if (abs_state == curr_abs_state) {20 );else break ;/* * Return error if fw_state hasn ' t changed after max_wait if (curr_abs_state == abs_state) {"FW state [%d] hasn't changed " "in %d secs\n" , fw_state, max_wait);"System Register set:\n" );return -ENODEV;"FW now in Ready state\n" );return 0 ;/** * megasas_teardown_frame_pool - Destroy the cmd frame DMA pool * @ instance : Adapter soft state static void megasas_teardown_frame_pool(struct megasas_instance *instance)int i;struct megasas_cmd *cmd;if (!instance->frame_dma_pool)return ;/* * Return all frames to pool for (i = 0 ; i < max_cmd; i++) {if (cmd->frame)if (cmd->sense)/* * Now destroy the pool itself /** * megasas_create_frame_pool - Creates DMA pool for cmd frames * @ instance : Adapter soft state * * Each command packet has an embedded DMA memory buffer that is used for * filling MFI frame and the SG list that immediately follows the frame . This * function creates those DMA memory buffers for each command packet by using * PCI pool facility . static int megasas_create_frame_pool(struct megasas_instance *instance)int i;struct megasas_cmd *cmd;/* * For MFI controllers . * max_num_sge = 60 * max_sge_sz = 16 byte ( sizeof megasas_sge_skinny ) * Total 960 byte ( 15 MFI frame of 64 byte ) * * Fusion adapter require only 3 extra frame . * max_num_sge = 16 ( defined as MAX_IOCTL_SGE ) * max_sge_sz = 12 byte ( sizeof megasas_sge64 ) * Total 192 byte ( 3 MFI frame of 64 byte ) 15 + 1 ) : (3 + 1 );/* * Use DMA pool facility provided by PCI layer "megasas frame pool" ,256 , 0 );if (!instance->frame_dma_pool) {"failed to setup frame pool\n" );return -ENOMEM;"megasas sense pool" ,128 ,4 , 0 );if (!instance->sense_dma_pool) {"failed to setup sense pool\n" );return -ENOMEM;/* * Allocate and attach a frame to each of the commands in cmd_list . * By making cmd - > index as the context instead of the & cmd , we can * always use 32 bit context regardless of the architecture for (i = 0 ; i < max_cmd; i++) {/* * megasas_teardown_frame_pool ( ) takes care of freeing * whatever has been allocated if (!cmd->frame || !cmd->sense) {"dma_pool_alloc failed\n" );return -ENOMEM;0 ;if ((instance->adapter_type == MFI_SERIES) && reset_devices)return 0 ;/** * megasas_free_cmds - Free all the cmds in the free cmd pool * @ instance : Adapter soft state void megasas_free_cmds(struct megasas_instance *instance)int i;/* First free the MFI frame pool */ /* Free all the commands in the cmd_list */ for (i = 0 ; i < instance->max_mfi_cmds; i++)/* Free the cmd_list buffer itself */ /** * megasas_alloc_cmds - Allocates the command packets * @ instance : Adapter soft state * * Each command that is issued to the FW , whether IO commands from the OS or * internal commands like IOCTLs , are wrapped in local data structure called * megasas_cmd . The frame embedded in this megasas_cmd is actually issued to * the FW . * * Each frame has a 32 - bit field called context ( tag ) . This context is used * to get back the megasas_cmd from the frame when a frame gets completed in * the ISR . Typically the address of the megasas_cmd itself would be used as * the context . But we wanted to keep the differences between 32 and 64 bit * systems to the mininum . We always use 32 bit integers for the context . In * this driver , the 32 bit values are the indices into an array cmd_list . * This array is used only to look up the megasas_cmd given the context . The * free commands themselves are maintained in a linked list called cmd_pool . int megasas_alloc_cmds(struct megasas_instance *instance)int i;int j;struct megasas_cmd *cmd;/* * instance - > cmd_list is an array of struct megasas_cmd pointers . * Allocate the dynamic array first and then allocate individual * commands . sizeof (struct megasas_cmd*), GFP_KERNEL);if (!instance->cmd_list) {"out of memory\n" );return -ENOMEM;for (i = 0 ; i < max_cmd; i++) {sizeof (struct megasas_cmd),if (!instance->cmd_list[i]) {for (j = 0 ; j < i; j++)return -ENOMEM;for (i = 0 ; i < max_cmd; i++) {0 , sizeof (struct megasas_cmd));/* * Create a frame pool and assign one frame to each cmd if (megasas_create_frame_pool(instance)) {"Error creating frame DMA pool\n" );return -ENOMEM;return 0 ;/* * dcmd_timeout_ocr_possible - Check if OCR is possible based on Driver / FW state . * @ instance : Adapter soft state * * Return 0 for only Fusion adapter , if driver load / unload is not in progress * or FW is not under OCR . inline int struct megasas_instance *instance) {if (instance->adapter_type == MFI_SERIES)return KILL_ADAPTER;else if (instance->unload ||return IGNORE_TIMEOUT;else return INITIATE_OCR;static void struct megasas_instance *instance, struct scsi_device *sdev)int ret;struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;struct MR_PRIV_DEVICE *mr_device_priv_data;0 ;if (!cmd) {"Failed to get cmd %s\n" , __func__);return ;0 , sizeof (*instance->pd_info));0 , MFI_MBOX_SIZE);0 ] = cpu_to_le16(device_id);0 xFF;1 ;0 ;0 ;sizeof (struct MR_PD_INFO));sizeof (struct MR_PD_INFO));if ((instance->adapter_type != MFI_SERIES) &&else switch (ret) {case DCMD_SUCCESS:break ;case DCMD_TIMEOUT:switch (dcmd_timeout_ocr_possible(instance)) {case INITIATE_OCR:break ;case KILL_ADAPTER:break ;case IGNORE_TIMEOUT:"Ignore DCMD timeout: %s %d\n" ,break ;break ;if (ret != DCMD_TIMEOUT)return ;/* * megasas_get_pd_list_info - Returns FW ' s pd_list structure * @ instance : Adapter soft state * @ pd_list : pd_list structure * * Issues an internal command ( DCMD ) to get the FW ' s controller PD * list structure . This information is mainly used to find out SYSTEM * supported by the FW . static int struct megasas_instance *instance)int ret = 0 , pd_index = 0 ;struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;struct MR_PD_LIST *ci;struct MR_PD_ADDRESS *pd_addr;if (instance->pd_list_not_supported) {"MR_DCMD_PD_LIST_QUERY " "not supported by firmware\n" );return ret;if (!cmd) {"(get_pd_list): Failed to get cmd\n" );return -ENOMEM;0 , sizeof (*ci));0 , MFI_MBOX_SIZE);0 ] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST;1 ] = 0 ;1 ;0 ;0 ;sizeof (struct MR_PD_LIST));sizeof (struct MR_PD_LIST)));if ((instance->adapter_type != MFI_SERIES) &&else switch (ret) {case DCMD_FAILED:"MR_DCMD_PD_LIST_QUERY " "failed/not supported by firmware\n" );if (instance->adapter_type != MFI_SERIES)else 1 ;break ;case DCMD_TIMEOUT:switch (dcmd_timeout_ocr_possible(instance)) {case INITIATE_OCR:/* * DCMD failed from AEN path . * AEN path already hold reset_mutex to avoid PCI access * while OCR is in progress . break ;case KILL_ADAPTER:break ;case IGNORE_TIMEOUT:"Ignore DCMD timeout: %s %d \n" ,break ;break ;case DCMD_SUCCESS:if (megasas_dbg_lvl & LD_PD_DEBUG)"%s, sysPD count: 0x%x\n" ,if ((le32_to_cpu(ci->count) >break ;0 ,sizeof (struct megasas_pd_list));for (pd_index = 0 ; pd_index < le32_to_cpu(ci->count); pd_index++) {if (megasas_dbg_lvl & LD_PD_DEBUG)"PD%d: targetID: 0x%03x deviceType:0x%x\n" ,sizeof (instance->pd_list));break ;if (ret != DCMD_TIMEOUT)return ret;/* * megasas_get_ld_list_info - Returns FW ' s ld_list structure * @ instance : Adapter soft state * @ ld_list : ld_list structure * * Issues an internal command ( DCMD ) to get the FW ' s controller PD * list structure . This information is mainly used to find out SYSTEM * supported by the FW . static int struct megasas_instance *instance)int ret = 0 , ld_index = 0 , ids = 0 ;struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;struct MR_LD_LIST *ci;0 ;if (!cmd) {"megasas_get_ld_list: Failed to get cmd\n" );return -ENOMEM;0 , sizeof (*ci));0 , MFI_MBOX_SIZE);if (instance->supportmax256vd)0 ] = 1 ;1 ;0 ;sizeof (struct MR_LD_LIST));0 ;sizeof (struct MR_LD_LIST));if ((instance->adapter_type != MFI_SERIES) &&else switch (ret) {case DCMD_FAILED:break ;case DCMD_TIMEOUT:switch (dcmd_timeout_ocr_possible(instance)) {case INITIATE_OCR:/* * DCMD failed from AEN path . * AEN path already hold reset_mutex to avoid PCI access * while OCR is in progress . break ;case KILL_ADAPTER:break ;case IGNORE_TIMEOUT:"Ignore DCMD timeout: %s %d\n" ,break ;break ;case DCMD_SUCCESS:if (megasas_dbg_lvl & LD_PD_DEBUG)"%s, LD count: 0x%x\n" ,if (ld_count > instance->fw_supported_vd_count)break ;0 xff, MAX_LOGICAL_DRIVES_EXT);for (ld_index = 0 ; ld_index < ld_count; ld_index++) {if (ci->ldList[ld_index].state != 0 ) {if (megasas_dbg_lvl & LD_PD_DEBUG)"LD%d: targetID: 0x%03x\n" ,break ;if (ret != DCMD_TIMEOUT)return ret;/** * megasas_ld_list_query - Returns FW ' s ld_list structure * @ instance : Adapter soft state * @ query_type : ld_list structure type * * Issues an internal command ( DCMD ) to get the FW ' s controller PD * list structure . This information is mainly used to find out SYSTEM * supported by the FW . static int struct megasas_instance *instance, u8 query_type)int ret = 0 , ld_index = 0 , ids = 0 ;struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;struct MR_LD_TARGETID_LIST *ci;0 ;if (!cmd) {"megasas_ld_list_query: Failed to get cmd\n" );return -ENOMEM;0 , sizeof (*ci));0 , MFI_MBOX_SIZE);0 ] = query_type;if (instance->supportmax256vd)2 ] = 1 ;1 ;0 ;sizeof (struct MR_LD_TARGETID_LIST));0 ;sizeof (struct MR_LD_TARGETID_LIST));if ((instance->adapter_type != MFI_SERIES) &&else switch (ret) {case DCMD_FAILED:"DCMD not supported by firmware - %s %d\n" ,break ;case DCMD_TIMEOUT:switch (dcmd_timeout_ocr_possible(instance)) {case INITIATE_OCR:/* * DCMD failed from AEN path . * AEN path already hold reset_mutex to avoid PCI access * while OCR is in progress . break ;case KILL_ADAPTER:break ;case IGNORE_TIMEOUT:"Ignore DCMD timeout: %s %d\n" ,break ;break ;case DCMD_SUCCESS:if (megasas_dbg_lvl & LD_PD_DEBUG)"%s, LD count: 0x%x\n" ,if ((tgtid_count > (instance->fw_supported_vd_count)))break ;0 xff, MEGASAS_MAX_LD_IDS);for (ld_index = 0 ; ld_index < tgtid_count; ld_index++) {if (megasas_dbg_lvl & LD_PD_DEBUG)"LD%d: targetID: 0x%03x\n" ,break ;if (ret != DCMD_TIMEOUT)return ret;/** * megasas_host_device_list_query * dcmd . opcode - MR_DCMD_CTRL_DEVICE_LIST_GET * dcmd . mbox - reserved * dcmd . sge IN - ptr to return MR_HOST_DEVICE_LIST structure * Desc : This DCMD will return the combined device list * Status : MFI_STAT_OK - List returned successfully * MFI_STAT_INVALID_CMD - Firmware support for the feature has been * disabled * @ instance : Adapter soft state * @ is_probe : Driver probe check * Return : 0 if DCMD succeeded * non - zero if failed static int struct megasas_instance *instance,bool is_probe)int ret, i, target_id;struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;struct MR_HOST_DEVICE_LIST *ci;if (!cmd) {"%s: failed to get cmd\n" ,return -ENOMEM;0 , sizeof (*ci));0 , MFI_MBOX_SIZE);0 ] = is_probe ? 0 : 1 ;1 ;0 ;0 ;if (!instance->mask_interrupts) {else {switch (ret) {case DCMD_SUCCESS:/* Fill the internal pd_list and ld_ids array based on * targetIds returned by FW if (count > (MEGASAS_MAX_PD + MAX_LOGICAL_DRIVES_EXT))break ;if (megasas_dbg_lvl & LD_PD_DEBUG)"%s, Device count: 0x%x\n" ,0 ,sizeof (struct megasas_pd_list));0 xff, MAX_LOGICAL_DRIVES_EXT);for (i = 0 ; i < count; i++) {if (ci->host_device_list[i].flags.u.bits.is_sys_pd) {if (megasas_dbg_lvl & LD_PD_DEBUG)"Device %d: PD targetID: 0x%03x deviceType:0x%x\n" ,else {if (megasas_dbg_lvl & LD_PD_DEBUG)"Device %d: LD targetID: 0x%03x\n" ,sizeof (instance->pd_list));break ;case DCMD_TIMEOUT:switch (dcmd_timeout_ocr_possible(instance)) {case INITIATE_OCR:break ;case KILL_ADAPTER:break ;case IGNORE_TIMEOUT:"Ignore DCMD timeout: %s %d\n" ,break ;break ;case DCMD_FAILED:"%s: MR_DCMD_CTRL_DEVICE_LIST_GET failed\n" ,break ;if (ret != DCMD_TIMEOUT)return ret;/* * megasas_update_ext_vd_details : Update details w . r . t Extended VD * instance : Controller ' s instance static void megasas_update_ext_vd_details(struct megasas_instance *instance)struct fusion_context *fusion;0 ;/* For MFI based controllers return dummy success */ if (!fusion)return ;/* Below is additional check to address future FW enhancement */ if (instance->ctrl_info_buf->max_lds > 64 )1 ;if (instance->supportmax256vd) {else {"FW provided supportMaxExtLDs: %d\tmax_lds: %d\n" ,1 : 0 ,if (instance->max_raid_mapsize) {/* 64k */ else {struct MR_FW_RAID_MAP, ldSpanMap,sizeof (struct MR_FW_RAID_MAP_EXT);if (instance->supportmax256vd)else /* irrespective of FW raid maps, driver raid map is constant */ sizeof (struct MR_DRV_RAID_MAP_ALL);/* * dcmd . opcode - MR_DCMD_CTRL_SNAPDUMP_GET_PROPERTIES * dcmd . hdr . length - number of bytes to read * dcmd . sge - Ptr to MR_SNAPDUMP_PROPERTIES * Desc : Fill in snapdump properties * Status : MFI_STAT_OK - Command successful void megasas_get_snapdump_properties(struct megasas_instance *instance)int ret = 0 ;struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;struct MR_SNAPDUMP_PROPERTIES *ci;0 ;if (!ci)return ;if (!cmd) {"Failed to get a free cmd\n" );return ;0 , sizeof (*ci));0 , MFI_MBOX_SIZE);1 ;0 ;0 ;sizeof (struct MR_SNAPDUMP_PROPERTIES));sizeof (struct MR_SNAPDUMP_PROPERTIES));if (!instance->mask_interrupts) {else {switch (ret) {case DCMD_SUCCESS:break ;case DCMD_TIMEOUT:switch (dcmd_timeout_ocr_possible(instance)) {case INITIATE_OCR:break ;case KILL_ADAPTER:break ;case IGNORE_TIMEOUT:"Ignore DCMD timeout: %s %d\n" ,break ;if (ret != DCMD_TIMEOUT)/** * megasas_get_ctrl_info - Returns FW ' s controller structure * @ instance : Adapter soft state * * Issues an internal command ( DCMD ) to get the FW ' s controller structure . * This information is mainly used to find out the maximum IO transfer per * command supported by the FW . int struct megasas_instance *instance)int ret = 0 ;struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;struct megasas_ctrl_info *ci;0 ;if (!cmd) {"Failed to get a free cmd\n" );return -ENOMEM;0 , sizeof (*ci));0 , MFI_MBOX_SIZE);1 ;0 ;0 ;sizeof (struct megasas_ctrl_info));0 ] = 1 ;sizeof (struct megasas_ctrl_info));if ((instance->adapter_type != MFI_SERIES) &&else {switch (ret) {case DCMD_SUCCESS:/* Save required controller information in * CPU endianness format . /* Update the latest Ext VD info. * From Init path , store current firmware details . * From OCR path , detect any firmware properties changes . * in case of Firmware upgrade without system reboot . /*Check whether controller is iMR or MR */ 0 : 1 );0 );"controller type\t: %s(%dMB)\n" ,"iMR" : "MR" ,"Online Controller Reset(OCR)\t: %s\n" ,"Disabled" : "Enabled" );"Secure JBOD support\t: %s\n" ,"Yes" : "No" );"NVMe passthru support\t: %s\n" ,"Yes" : "No" );"FW provided TM TaskAbort/Reset timeout\t: %d secs/%d secs\n" ,"JBOD sequence map support\t: %s\n" ,"Yes" : "No" );"PCI Lane Margining support\t: %s\n" ,"Yes" : "No" );break ;case DCMD_TIMEOUT:switch (dcmd_timeout_ocr_possible(instance)) {case INITIATE_OCR:break ;case KILL_ADAPTER:break ;case IGNORE_TIMEOUT:"Ignore DCMD timeout: %s %d\n" ,break ;break ;case DCMD_FAILED:break ;if (ret != DCMD_TIMEOUT)return ret;/* * megasas_set_crash_dump_params - Sends address of crash dump DMA buffer * to firmware * * @ instance : Adapter soft state * @ crash_buf_state - tell FW to turn ON / OFF crash dump feature MR_CRASH_BUF_TURN_OFF = 0 MR_CRASH_BUF_TURN_ON = 1 * @ return 0 on success non - zero on failure . * Issues an internal command ( DCMD ) to set parameters for crash dump feature . * Driver will send address of crash dump DMA buffer and set mbox to tell FW * that driver supports crash dump feature . This DCMD will be sent only if * crash dump feature is supported by the FW . * int megasas_set_crash_dump_params(struct megasas_instance *instance,int ret = 0 ;struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;if (!cmd) {"Failed to get a free cmd\n" );return -ENOMEM;0 , MFI_MBOX_SIZE);0 ] = crash_buf_state;1 ;0 ;0 ;if ((instance->adapter_type != MFI_SERIES) &&else if (ret == DCMD_TIMEOUT) {switch (dcmd_timeout_ocr_possible(instance)) {case INITIATE_OCR:break ;case KILL_ADAPTER:break ;case IGNORE_TIMEOUT:"Ignore DCMD timeout: %s %d\n" ,break ;else return ret;/** * megasas_issue_init_mfi - Initializes the FW * @ instance : Adapter soft state * * Issues the INIT MFI cmd static int struct megasas_instance *instance)struct megasas_cmd *cmd;struct megasas_init_frame *init_frame;struct megasas_init_queue_info *initq_info;/* * Prepare a init frame . Note the init frame points to queue info * structure . Each frame has SGL allocated after first 64 bytes . For * this frame - since we don ' t need any SGL - we use SGL ' s space as * queue info structure * * We will not get a NULL command below . We just created the pool . struct megasas_init_frame *)cmd->frame;struct megasas_init_queue_info *)unsigned long )init_frame + 64 );64 ;0 , MEGAMFI_FRAME_SIZE);0 , sizeof (struct megasas_init_queue_info));1 );sizeof (struct megasas_init_queue_info));/* * disable the intr before firing the init frame to FW /* * Issue the init frame in polled mode if (megasas_issue_polled(instance, cmd)) {"Failed to init firmware\n" );goto fail_fw_init;return 0 ;return -EINVAL;static u32struct megasas_instance *instance)/* * Get various operational parameters from status register 0 x00FFFF;/* * Reduce the max supported cmds by 1 . This is to ensure that the * reply_q_sz ( 1 more than the max cmd that driver may send ) * does not exceed max cmds that the FW can support 1 ;0 xFF0000) >>0 x10;/* * For MFI skinny adapters , MEGASAS_SKINNY_INT_CMDS commands * are reserved for IOCTL + driver ' s internal DCMDs . if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||else {/* * Create a pool of commands if (megasas_alloc_cmds(instance))goto fail_alloc_cmds;/* * Allocate memory for reply queue . Length of reply queue should * be _ one_ more than the maximum commands handled by the firmware . * * Note : When FW completes commands , it places corresponding contex * values in this circular reply queue . This circular queue is a fairly * typical producer - consumer queue . FW is the producer ( of completed * commands ) and the driver is the consumer . sizeof (u32);1 );if (!instance->reply_queue) {"Out of DMA mem for reply queue\n" );goto fail_reply_queue;if (megasas_issue_init_mfi(instance))goto fail_fw_init;if (megasas_get_ctrl_info(instance)) {"(%d): Could get controller info " "Fail from %s %d\n" , instance->unique_id,goto fail_fw_init;0 ;0 x04000000);"megasas_init_mfi: fw_support_ieee=%d" ,if (instance->fw_support_ieee)1 ;return 0 ;return 1 ;static void megasas_setup_irq_poll(struct megasas_instance *instance)struct megasas_irq_context *irq_ctx;0 ? instance->msix_vectors : 1 ;/* Initialize IRQ poll */ for (i = 0 ; i < count; i++) {false ;/* * megasas_setup_irqs_ioapic - register legacy interrupts . * @ instance : Adapter soft state * * Do not enable interrupt , only setup ISRs . * * Return 0 on success . static int struct megasas_instance *instance)struct pci_dev *pdev;0 ].instance = instance;0 ].MSIxIndex = 0 ;"%s%u" ,"megasas" , instance->host->host_no);if (request_irq(pci_irq_vector(pdev, 0 ),0 ])) {"Failed to register IRQ from %s %d\n" ,return -1 ;0 ;return 0 ;/** * megasas_setup_irqs_msix - register MSI - x interrupts . * @ instance : Adapter soft state * @ is_probe : Driver probe check * * Do not enable interrupt , only setup ISRs . * * Return 0 on success . static int struct megasas_instance *instance, u8 is_probe)int i, j;struct pci_dev *pdev;/* Try MSI-x */ for (i = 0 ; i < instance->msix_vectors; i++) {"%s%u-msix%u" ,"megasas" , instance->host->host_no, i);if (request_irq(pci_irq_vector(pdev, i),0 , instance->irq_context[i].name,"Failed to register IRQ for vector %d.\n" , i);for (j = 0 ; j < i; j++) {if (j < instance->low_latency_index_start)/* Retry irq register for IO_APIC*/ 0 ;false ;if (is_probe) {return megasas_setup_irqs_ioapic(instance);else {return -1 ;return 0 ;/* * megasas_destroy_irqs - unregister interrupts . * @ instance : Adapter soft state * return : void static void struct megasas_instance *instance) {int i;int count;struct megasas_irq_context *irq_ctx;0 ? instance->msix_vectors : 1 ;if (instance->adapter_type != MFI_SERIES) {for (i = 0 ; i < count; i++) {if (instance->msix_vectors)for (i = 0 ; i < instance->msix_vectors; i++) {if (i < instance->low_latency_index_start)else 0 ),0 ]);/** * megasas_setup_jbod_map - setup jbod map for FP seq_number . * @ instance : Adapter soft state * * Return 0 on success . void struct megasas_instance *instance)int i;struct fusion_context *fusion = instance->ctrl_context;struct MR_PD_CFG_SEQ_NUM_SYNC, seq,if (reset_devices || !fusion ||"JBOD sequence map is disabled %s %d\n" ,false ;return ;if (fusion->pd_seq_sync[0 ])goto skip_alloc;for (i = 0 ; i < JBOD_MAPS_COUNT; i++) {if (!fusion->pd_seq_sync[i]) {"Failed to allocate memory from %s %d\n" ,if (i == 1 ) {0 ],0 ]);0 ] = NULL;false ;return ;if (!megasas_sync_pd_seq_num(instance, false ) &&true ))true ;else false ;static void megasas_setup_reply_map(struct megasas_instance *instance)const struct cpumask *mask;unsigned int queue, cpu, low_latency_index_start;for (queue = low_latency_index_start; queue < instance->msix_vectors; queue++) {if (!mask)goto fallback;return ;if (queue == (instance->msix_vectors - 1 ))else /** * megasas_get_device_list - Get the PD and LD device list from FW . * @ instance : Adapter soft state * @ return : Success or failure * * Issue DCMDs to Firmware to get the PD and LD list . * Based on the FW support , driver sends the HOST_DEVICE_LIST or combination * of PD_LIST / LD_LIST_QUERY DCMDs to get the device list . static int megasas_get_device_list(struct megasas_instance *instance)if (instance->enable_fw_dev_list) {if (megasas_host_device_list_query(instance, true ))return FAILED;else {if (megasas_get_pd_list(instance) < 0 ) {"failed to get PD list\n" );return FAILED;if (megasas_ld_list_query(instance,"failed to get LD list\n" );return FAILED;return SUCCESS;/** * megasas_set_high_iops_queue_affinity_and_hint - Set affinity and hint * for high IOPS queues * @ instance : Adapter soft state * return : void static inline void struct megasas_instance *instance)int i;unsigned int irq;const struct cpumask *mask;if (instance->perf_mode == MR_BALANCED_PERF_MODE) {int nid = dev_to_node(&instance->pdev->dev);if (nid == NUMA_NO_NODE)0 ;for (i = 0 ; i < instance->low_latency_index_start; i++) {static int struct megasas_instance *instance)int i, irq_flags;struct irq_affinity desc = { .pre_vectors = instance->low_latency_index_start };struct irq_affinity *descp = &desc;if (instance->smp_affinity_enable)else /* Do not allocate msix vectors for poll_queues. * msix_vectors is always within a range of FW supported reply queue . return i;/** * megasas_alloc_irq_vectors - Allocate IRQ vectors / enable MSI - x vectors * @ instance : Adapter soft state * return : void static void struct megasas_instance *instance)int i;unsigned int num_msix_req;0 ;if ((instance->adapter_type != MFI_SERIES) &&1 ;/* reserve for default and non-mananged pre-vector. */ if (instance->msix_vectors > (poll_queues + 2 ))else 0 ;0 ) +if (((instance->perf_mode == MR_BALANCED_PERF_MODE)if (instance->msix_vectors)/* Disable Balanced IOPS mode and try realloc vectors */ 1 ;0 ) +0 ;"requested/available msix %d/%d poll_queue %d\n" ,if (i > 0 )else 0 ;if (instance->smp_affinity_enable)/** * megasas_init_fw - Initializes the FW * @ instance : Adapter soft state * * This is the main function for initializing firmware static int megasas_init_fw(struct megasas_instance *instance)void *base_addr_phys;struct megasas_ctrl_info *ctrl_info = NULL;unsigned long bar_list;int i, j, loop;struct IOV_111 *iovPtr;struct fusion_context *fusion;bool intr_coalescing;unsigned int num_msix_req;/* Find first memory bar */ if (pci_request_selected_regions(instance->pdev, 1 <<instance->bar,"megasas: LSI" )) {"IO memory region busy!\n" );return -EBUSY;8192 );if (!instance->reg_set) {"Failed to map IO mem\n" );goto fail_ioremap;"BAR:0x%lx BAR's base_addr(phys):%pa mapped virt_addr:0x%p\n" ,if (instance->adapter_type != MFI_SERIES)else {switch (instance->pdev->device) {case PCI_DEVICE_ID_LSI_SAS1078R:case PCI_DEVICE_ID_LSI_SAS1078DE:break ;case PCI_DEVICE_ID_LSI_SAS1078GEN2:case PCI_DEVICE_ID_LSI_SAS0079GEN2:break ;case PCI_DEVICE_ID_LSI_SAS0073SKINNY:case PCI_DEVICE_ID_LSI_SAS0071SKINNY:break ;case PCI_DEVICE_ID_LSI_SAS1064R:case PCI_DEVICE_ID_DELL_PERC5:default :1 ;break ;if (megasas_transition_to_ready(instance, 0 )) {"Failed to transition controller to ready from %s!\n" ,if (instance->adapter_type != MFI_SERIES) {if (status_reg & MFI_RESET_ADAPTER) {if (megasas_adp_reset_wait_for_readytrue , 0 ) == FAILED)goto fail_ready_state;else {goto fail_ready_state;else {1 );0 );/*waiting for about 30 second before retry*/ 30 );if (megasas_transition_to_ready(instance, 0 ))goto fail_ready_state;"FW restarted successfully from %s!\n" ,if (megasas_set_dma_mask(instance))goto fail_ready_state;if (megasas_alloc_ctrl_mem(instance))goto fail_alloc_dma_buf;if (megasas_alloc_ctrl_dma_buffers(instance))goto fail_alloc_dma_buf;if (instance->adapter_type >= VENTURA_SERIES) {switch (instance->adapter_type) {case VENTURA_SERIES:true ;break ;case AERO_SERIES:true ;break ;default :break ;/* Check if MSI-X is supported while in ready state */ 0 x4000000) >> 0 x1a;if (msix_enable && !msix_disable) {/* Check max MSI-X vectors */ if (fusion) {if (instance->adapter_type == THUNDERBOLT_SERIES) {/* Thunderbolt Series*/ 1 ;else {1 ;/* * For Invader series , > 8 MSI - x vectors * supported by FW / HW implies combined * reply queue mode is enabled . * For Ventura series , > 16 MSI - x vectors * supported by FW / HW implies combined * reply queue mode is enabled . switch (instance->adapter_type) {case INVADER_SERIES:if (instance->msix_vectors > 8 )true ;break ;case AERO_SERIES:case VENTURA_SERIES:if (instance->msix_vectors > 16 )true ;break ;if (rdpq_enable)1 : 0 ;if (instance->adapter_type >= INVADER_SERIES &&true ;false ;/* Save 1-15 reply post index address to local memory * Index 0 is already saved from reg offset * MPI2_REPLY_POST_HOST_INDEX_OFFSET for (loop = 1 ; loop < MR_MAX_MSIX_REG_ARRAY; loop++) {0 x10));"firmware supports msix\t: (%d)" ,if (msix_vectors)else /* MFI adapters */ 1 ;/* * For Aero ( if some conditions are met ) , driver will configure a * few additional reply queues with interrupt coalescing enabled . * These queues with interrupt coalescing enabled are called * High IOPS queues and rest of reply queues ( based on number of * logical CPUs ) are termed as Low latency queues . * * Total Number of reply queues = High IOPS queues + low latency queues * * For rest of fusion adapters , 1 additional reply queue will be * reserved for management commands , rest of reply queues * ( based on number of logical CPUs ) will be used for IOs and * referenced as IO queues . * Total Number of reply queues = 1 + IO queues * * MFI adapters supports single MSI - x so single reply queue * will be used for IO and management commands . true : false ;if (intr_coalescing &&0 ) >= MR_HIGH_IOPS_QUEUE_COUNT) &&else if (instance->adapter_type == AERO_SERIES) {/* * For Aero , if PCIe link speed is < 16 GT / s , then driver should operate * in latency perf mode and enable R1 PCI bandwidth algorithm if (speed < 0 x4) {true ;/* * Performance mode settings provided through module parameter - perf_mode will * take affect only for : * 1 . Aero family of adapters . * 2 . When user sets module parameter - perf_mode in range of 0 - 2 . if ((perf_mode >= MR_BALANCED_PERF_MODE) &&/* * If intr coalescing is not supported by controller FW , then IOPS * and Balanced modes are not feasible . if (!intr_coalescing)if (instance->perf_mode == MR_BALANCED_PERF_MODE)else 1 ;0 ) +if (!instance->msix_vectors)false ;/* * MSI - X host index 0 is common for all adapter . * It is used for all MPT based Adapters . if (instance->msix_combined) {0 ] =else {0 ] =if (!instance->msix_vectors) {1 , 1 , PCI_IRQ_INTX);if (i < 0 )goto fail_init_adapter;"current msix/max num queues\t: (%d/%u)\n" ,0 ));"RDPQ mode\t: (%s)\n" , instance->is_rdpq ? "enabled" : "disabled" );unsigned long )instance);/* * Below are default value for legacy Firmware . * non - fusion based controllers /* Get operational params, sge flags, send init cmd to controller */ if (instance->instancet->init_adapter(instance))goto fail_init_adapter;if (instance->adapter_type >= VENTURA_SERIES) {if ((scratch_pad_3 & MR_NVME_PAGE_SIZE_MASK) >=1 << (scratch_pad_3 & MR_NVME_PAGE_SIZE_MASK));"NVME page size\t: (%d)\n" , instance->nvme_page_size);if (instance->msix_vectors ?1 ) :goto fail_init_adapter;if (instance->adapter_type != MFI_SERIES)"INIT adapter done\n" );if (megasas_get_device_list(instance) != SUCCESS) {"%s: megasas_get_device_list failed\n" ,goto fail_get_ld_pd_list;/* stream detection initialization */ if (instance->adapter_type >= VENTURA_SERIES) {sizeof (struct LD_STREAM_DETECT *),if (!fusion->stream_detect_by_ld) {"unable to allocate stream detection for pool of LDs\n" );goto fail_get_ld_pd_list;for (i = 0 ; i < MAX_LOGICAL_DRIVES_EXT; ++i) {sizeof (struct LD_STREAM_DETECT),if (!fusion->stream_detect_by_ld[i]) {"unable to allocate stream detect by LD\n" );for (j = 0 ; j < i; ++j)goto fail_get_ld_pd_list;/* * Compute the max allowed sectors per IO : The controller info has two * limits on max sectors . Driver should use the minimum of these two . * * 1 < < stripe_sz_ops . min = max sectors per strip * * Note that older firmwares ( < FW ver 30 ) didn ' t report information * to calculate max_sectors_1 . So the number ended up as zero always . 0 ;1 << ctrl_info->stripe_sz_ops.min) *sizeof (instance->clusterId));if (instance->UnevenSpanSupport) {struct fusion_context *fusion = instance->ctrl_context;if (MR_ValidateMapInfo(instance, instance->map_id))1 ;else 0 ;if (ctrl_info->host_interface.SRIOV) {if (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) {if (!ctrl_info->adapterOperations2.activePassive)1 ;"SR-IOV: firmware type: %s\n" ,"1.11" : "new" );if (instance->PlasmaFW111) {struct IOV_111 *)unsigned char *)ctrl_info + IOV_111_OFFSET);"SRIOV: VF requestorId %d\n" ,if (instance->crash_dump_drv_support)else {if (instance->crash_dump_buf)if (instance->snapdump_wait_time) {"Snap dump wait time\t: %d\n" ,"pci id\t\t: (0x%04x)/(0x%04x)/(0x%04x)/(0x%04x)\n" ,"unevenspan support : %s\n" ,"yes" : "no" );"firmware crash dump : %s\n" ,"yes" : "no" );"JBOD sequence map : %s\n" ,"enabled" : "disabled" );512 ;if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))/* Check for valid throttlequeuedepth module parameter */ if (throttlequeuedepth &&else if ((resetwaittime < 1 ) ||if ((scmd_timeout < 10 ) || (scmd_timeout > MEGASAS_DEFAULT_CMD_TIMEOUT))/* Launch SR-IOV heartbeat timer */ if (instance->requestorId) {if (!megasas_sriov_start_heartbeat(instance, 1 )) {else {1 ;goto fail_get_ld_pd_list;/* * Create and start watchdog thread which will monitor * controller state every 1 sec and trigger OCR when * it enters fault state if (instance->adapter_type != MFI_SERIES)if (megasas_fusion_start_watchdog(instance) != SUCCESS)goto fail_start_watchdog;return 0 ;if (instance->requestorId && !instance->skip_heartbeat_timer_del)if (instance->msix_vectors)0 ;1 <<instance->bar);"Failed from %s %d\n" ,return -EINVAL;/** * megasas_release_mfi - Reverses the FW initialization * @ instance : Adapter soft state static void megasas_release_mfi(struct megasas_instance *instance)sizeof (u32) *(instance->max_mfi_cmds + 1 );if (instance->reply_queue)1 <<instance->bar);/** * megasas_get_seq_num - Gets latest event sequence numbers * @ instance : Adapter soft state * @ eli : FW event log sequence numbers information * * FW maintains a log of all events in a non - volatile area . Upper layers would * usually find out the latest sequence number of the events , the seq number at * the boot etc . They would " read " all the events below the latest seq number * by issuing a direct fw cmd ( DCMD ) . For the future events ( beyond latest seq * number ) , they would subsribe to AEN ( asynchronous event notification ) and * wait for the events to happen . static int struct megasas_instance *instance,struct megasas_evt_log_info *eli)struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;struct megasas_evt_log_info *el_info;0 ;int ret;if (!cmd) {return -ENOMEM;sizeof (struct megasas_evt_log_info),if (!el_info) {return -ENOMEM;0 , MFI_MBOX_SIZE);0 x0;1 ;0 ;0 ;sizeof (struct megasas_evt_log_info));sizeof (struct megasas_evt_log_info));if (ret != DCMD_SUCCESS) {"Failed from %s %d\n" ,goto dcmd_failed;/* * Copy the data back into callers buffer sizeof (struct megasas_evt_log_info),return ret;/** * megasas_register_aen - Registers for asynchronous event notification * @ instance : Adapter soft state * @ seq_num : The starting sequence number * @ class_locale_word : Class of the event * * This function subscribes for AEN for events beyond the @ seq_num . It requests * to be notified if and only if the event is of type @ class_locale static int struct megasas_instance *instance, u32 seq_num,int ret_val;struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;union megasas_evt_class_locale curr_aen;union megasas_evt_class_locale prev_aen;/* * If there an AEN pending already ( aen_cmd ) , check if the * class_locale of that pending AEN is inclusive of the new * AEN request we currently have . If it is , then we don ' t have * to do anything . In other words , whichever events the current * AEN request is subscribing to , have already been subscribed * to . * * If the old_cmd is _ not_ inclusive , then we have to abort * that command , form a class_locale that is superset of both * old and current and re - issue to the FW if (instance->aen_cmd) {1 ]);if ((curr_aen.members.class < MFI_EVT_CLASS_DEBUG) ||class > MFI_EVT_CLASS_DEAD)) {"%s %d out of range class %d send by application\n" ,class );return 0 ;/* * A class whose enum value is smaller is inclusive of all * higher values . If a PROGRESS ( = - 1 ) was previously * registered , then a new registration requests for higher * classes need not be sent to FW . They are automatically * included . * * Locale numbers don ' t have such hierarchy . They are bitmap * values if ((prev_aen.members.class <= curr_aen.members.class ) &&/* * Previously issued event registration includes * current request . Nothing to do . return 0 ;else {if (prev_aen.members.class < curr_aen.members.class )class = prev_aen.members.class ;1 ;30 );if (ret_val) {"Failed to abort " "previous AEN command\n" );return ret_val;if (!cmd)return -ENOMEM;0 , sizeof (struct megasas_evt_detail));/* * Prepare DCMD for aen registration 0 , MFI_MBOX_SIZE);0 x0;1 ;0 ;0 ;sizeof (struct megasas_evt_detail));0 ] = cpu_to_le32(seq_num);1 ] = cpu_to_le32(curr_aen.word);sizeof (struct megasas_evt_detail));if (instance->aen_cmd != NULL) {return 0 ;/* * Store reference to the cmd used to register for AEN . When an * application wants us to register for AEN , we have to abort this * cmd and re - register with a new EVENT LOCALE supplied by that app /* * Issue the aen registration frame return 0 ;/* megasas_get_target_prop - Send DCMD with below details to firmware. * * This DCMD will fetch few properties of LD / system PD defined * in MR_TARGET_DEV_PROPERTIES . eg . Queue Depth , MDTS value . * * DCMD send by drivers whenever new target is added to the OS . * * dcmd . opcode - MR_DCMD_DEV_GET_TARGET_PROP * dcmd . mbox . b [ 0 ] - DCMD is to be fired for LD or system PD . * 0 = system PD , 1 = LD . * dcmd . mbox . s [ 1 ] - TargetID for LD / system PD . * dcmd . sge IN - Pointer to return MR_TARGET_DEV_PROPERTIES . * * @ instance : Adapter soft state * @ sdev : OS provided scsi device * * Returns 0 on success non - zero on failure . int struct megasas_instance *instance,struct scsi_device *sdev)int ret;struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;2 ) * MEGASAS_MAX_DEV_PER_CHANNEL) +if (!cmd) {"Failed to get cmd %s\n" , __func__);return -ENOMEM;0 , sizeof (*instance->tgt_prop));0 , MFI_MBOX_SIZE);0 ] = MEGASAS_IS_LOGICAL(sdev);1 ] = cpu_to_le16(targetId);0 xFF;1 ;0 ;0 ;sizeof (struct MR_TARGET_PROPERTIES));sizeof (struct MR_TARGET_PROPERTIES));if ((instance->adapter_type != MFI_SERIES) &&else switch (ret) {case DCMD_TIMEOUT:switch (dcmd_timeout_ocr_possible(instance)) {case INITIATE_OCR:break ;case KILL_ADAPTER:break ;case IGNORE_TIMEOUT:"Ignore DCMD timeout: %s %d\n" ,break ;break ;default :if (ret != DCMD_SUCCESS)"return from %s %d return value %d\n" ,return ret;/** * megasas_start_aen - Subscribes to AEN during driver load time * @ instance : Adapter soft state static int megasas_start_aen(struct megasas_instance *instance)struct megasas_evt_log_info eli;union megasas_evt_class_locale class_locale;/* * Get the latest sequence number from FW 0 , sizeof (eli));if (megasas_get_seq_num(instance, &eli))return -1 ;/* * Register AEN with FW for latest sequence number plus 1 0 ;class = MR_EVT_CLASS_DEBUG;return megasas_register_aen(instance,1 ,/** * megasas_io_attach - Attaches this driver to SCSI mid - layer * @ instance : Adapter soft state static int megasas_io_attach(struct megasas_instance *instance)struct Scsi_Host *host = instance->host;/* * Export parameters required by SCSI mid - layer if (instance->fw_support_ieee)/* * Check if the module parameter value for max_sectors can be used if (max_sectors && max_sectors < instance->max_sectors_per_req)else {if (max_sectors) {if (((instance->pdev->device ==else {"max_sectors should be > 0" "and <= %d (or < 1MB for GEN2 controller)\n" ,1 ;16 ;/* Use shared host tagset only for fusion adaptors * if there are managed interrupts ( smp affinity enabled case ) . * Single msix_vectors in kdump , so shared host tag is also disabled . 0 ;1 ;if ((instance->adapter_type != MFI_SERIES) &&1 ;if (instance->iopoll_q_count)3 ;else {0 ;"Max firmware commands: %d shared with default " "hw_queues = %d poll_queues %d\n" , instance->max_fw_cmds,/* * Notify the mid - layer about the new controller if (scsi_add_host(host, &instance->pdev->dev)) {"Failed to add host from %s %d\n" ,return -ENODEV;return 0 ;/** * megasas_set_dma_mask - Set DMA mask for supported controllers * * @ instance : Adapter soft state * Description : * * For Ventura , driver / FW will operate in 63 bit DMA addresses . * * For invader - * By default , driver / FW will operate in 32 bit DMA addresses * for consistent DMA mapping but if 32 bit consistent * DMA mask fails , driver will try with 63 bit consistent * mask provided FW is true 63 bit DMA capable * * For older controllers ( Thunderbolt and MFI based adapters ) - * driver / FW will operate in 32 bit consistent DMA addresses . static int struct megasas_instance *instance)struct pci_dev *pdev;63 ) : DMA_BIT_MASK(32 );if (IS_DMA64) {if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(63 )) &&32 )))goto fail_set_dma_mask;if ((*pdev->dev.dma_mask == DMA_BIT_MASK(63 )) &&32 )))) {/* * If 32 bit DMA mask fails , then try for 64 bit mask * for FW capable of handling 64 bit DMA . if (!(scratch_pad_1 & MR_CAN_HANDLE_64_BIT_DMA_OFFSET))goto fail_set_dma_mask;else if (dma_set_mask_and_coherent(&pdev->dev,63 )))goto fail_set_dma_mask;else if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32 )))goto fail_set_dma_mask;if (pdev->dev.coherent_dma_mask == DMA_BIT_MASK(32 ))false ;else true ;"%s bit DMA mask and %s bit consistent mask\n" ,63 )) ? "63" : "32" ),"63" : "32" ));return 0 ;"Failed to set DMA mask\n" );return -1 ;/* * megasas_set_adapter_type - Set adapter type . * Supported controllers can be divided in * different categories - * enum MR_ADAPTER_TYPE { * MFI_SERIES = 1 , * THUNDERBOLT_SERIES = 2 , * INVADER_SERIES = 3 , * VENTURA_SERIES = 4 , * AERO_SERIES = 5 , * } ; * @ instance : Adapter soft state * return : void static inline void megasas_set_adapter_type(struct megasas_instance *instance)if ((instance->pdev->vendor == PCI_VENDOR_ID_DELL) &&else {switch (instance->pdev->device) {case PCI_DEVICE_ID_LSI_AERO_10E1:case PCI_DEVICE_ID_LSI_AERO_10E2:case PCI_DEVICE_ID_LSI_AERO_10E5:case PCI_DEVICE_ID_LSI_AERO_10E6:break ;case PCI_DEVICE_ID_LSI_VENTURA:case PCI_DEVICE_ID_LSI_CRUSADER:case PCI_DEVICE_ID_LSI_HARPOON:case PCI_DEVICE_ID_LSI_TOMCAT:case PCI_DEVICE_ID_LSI_VENTURA_4PORT:case PCI_DEVICE_ID_LSI_CRUSADER_4PORT:break ;case PCI_DEVICE_ID_LSI_FUSION:case PCI_DEVICE_ID_LSI_PLASMA:break ;case PCI_DEVICE_ID_LSI_INVADER:case PCI_DEVICE_ID_LSI_INTRUDER:case PCI_DEVICE_ID_LSI_INTRUDER_24:case PCI_DEVICE_ID_LSI_CUTLASS_52:case PCI_DEVICE_ID_LSI_CUTLASS_53:case PCI_DEVICE_ID_LSI_FURY:break ;default : /* For all other supported controllers */ break ;static inline int megasas_alloc_mfi_ctrl_mem(struct megasas_instance *instance)sizeof (u32), &instance->producer_h, GFP_KERNEL);sizeof (u32), &instance->consumer_h, GFP_KERNEL);if (!instance->producer || !instance->consumer) {"Failed to allocate memory for producer, consumer\n" );return -1 ;0 ;0 ;return 0 ;/** * megasas_alloc_ctrl_mem - Allocate per controller memory for core data * structures which are not common across MFI * adapters and fusion adapters . * For MFI based adapters , allocate producer and * consumer buffers . For fusion adapters , allocate * memory for fusion context . * @ instance : Adapter soft state * return : 0 for SUCCESS static int megasas_alloc_ctrl_mem(struct megasas_instance *instance)sizeof (unsigned int ),if (!instance->reply_map)return -ENOMEM;switch (instance->adapter_type) {case MFI_SERIES:if (megasas_alloc_mfi_ctrl_mem(instance))return -ENOMEM;break ;case AERO_SERIES:case VENTURA_SERIES:case THUNDERBOLT_SERIES:case INVADER_SERIES:if (megasas_alloc_fusion_context(instance))return -ENOMEM;break ;return 0 ;/* * megasas_free_ctrl_mem - Free fusion context for fusion adapters and * producer , consumer buffers for MFI adapters * * @ instance - Adapter soft instance * static inline void megasas_free_ctrl_mem(struct megasas_instance *instance)if (instance->adapter_type == MFI_SERIES) {if (instance->producer)sizeof (u32),if (instance->consumer)sizeof (u32),else {/** * megasas_alloc_ctrl_dma_buffers - Allocate consistent DMA buffers during * driver load time * * @ instance : Adapter soft instance * * @ return : O for SUCCESS static inline int megasas_alloc_ctrl_dma_buffers(struct megasas_instance *instance)struct pci_dev *pdev = instance->pdev;struct fusion_context *fusion = instance->ctrl_context;sizeof (struct megasas_evt_detail),if (!instance->evt_detail) {"Failed to allocate event detail buffer\n" );return -ENOMEM;if (fusion) {sizeof (struct MPI2_IOC_INIT_REQUEST),if (!fusion->ioc_init_request) {"Failed to allocate ioc init request\n" );return -ENOMEM;sizeof (struct MR_SNAPDUMP_PROPERTIES),if (!instance->snapdump_prop)"Failed to allocate snapdump properties buffer\n" );if (!instance->host_device_list_buf) {"Failed to allocate targetid list buffer\n" );return -ENOMEM;sizeof (struct MR_PD_LIST),if (!instance->pd_list_buf) {"Failed to allocate PD list buffer\n" );return -ENOMEM;sizeof (struct megasas_ctrl_info),if (!instance->ctrl_info_buf) {"Failed to allocate controller info buffer\n" );return -ENOMEM;sizeof (struct MR_LD_LIST),if (!instance->ld_list_buf) {"Failed to allocate LD list buffer\n" );return -ENOMEM;sizeof (struct MR_LD_TARGETID_LIST),if (!instance->ld_targetid_list_buf) {"Failed to allocate LD targetid list buffer\n" );return -ENOMEM;if (!reset_devices) {sizeof (struct MR_DRV_SYSTEM_INFO),sizeof (struct MR_PD_INFO),sizeof (struct MR_TARGET_PROPERTIES),if (!instance->system_info_buf)"Failed to allocate system info buffer\n" );if (!instance->pd_info)"Failed to allocate pd_info buffer\n" );if (!instance->tgt_prop)"Failed to allocate tgt_prop buffer\n" );if (!instance->crash_dump_buf)"Failed to allocate crash dump buffer\n" );return 0 ;/* * megasas_free_ctrl_dma_buffers - Free consistent DMA buffers allocated * during driver load time * * @ instance - Adapter soft instance * static inline void megasas_free_ctrl_dma_buffers(struct megasas_instance *instance)struct pci_dev *pdev = instance->pdev;struct fusion_context *fusion = instance->ctrl_context;if (instance->evt_detail)sizeof (struct megasas_evt_detail),if (fusion && fusion->ioc_init_request)sizeof (struct MPI2_IOC_INIT_REQUEST),if (instance->pd_list_buf)sizeof (struct MR_PD_LIST),if (instance->ld_list_buf)sizeof (struct MR_LD_LIST),if (instance->ld_targetid_list_buf)sizeof (struct MR_LD_TARGETID_LIST),if (instance->ctrl_info_buf)sizeof (struct megasas_ctrl_info),if (instance->system_info_buf)sizeof (struct MR_DRV_SYSTEM_INFO),if (instance->pd_info)sizeof (struct MR_PD_INFO),if (instance->tgt_prop)sizeof (struct MR_TARGET_PROPERTIES),if (instance->crash_dump_buf)if (instance->snapdump_prop)sizeof (struct MR_SNAPDUMP_PROPERTIES),if (instance->host_device_list_buf)/* * megasas_init_ctrl_params - Initialize controller ' s instance * parameters before FW init * @ instance - Adapter soft instance * @ return - void static inline void megasas_init_ctrl_params(struct megasas_instance *instance)0 ;1 ;/* * Initialize locks and queues 0 );0 );if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||1 ;0 ;1 ;0 ;1 ;0 ;true : false ;false ;if (instance->adapter_type != MFI_SERIES)else /** * megasas_probe_one - PCI hotplug entry point * @ pdev : PCI device structure * @ id : PCI ids of supported hotplugged adapter static int megasas_probe_one(struct pci_dev *pdev,const struct pci_device_id *id)int rval, pos;struct Scsi_Host *host;struct megasas_instance *instance;0 ;switch (pdev->device) {case PCI_DEVICE_ID_LSI_AERO_10E0:case PCI_DEVICE_ID_LSI_AERO_10E3:case PCI_DEVICE_ID_LSI_AERO_10E4:case PCI_DEVICE_ID_LSI_AERO_10E7:"Adapter is in non secure mode\n" );return 1 ;case PCI_DEVICE_ID_LSI_AERO_10E1:case PCI_DEVICE_ID_LSI_AERO_10E5:"Adapter is in configurable secure mode\n" );break ;/* Reset MSI-X in the kdump kernel */ if (reset_devices) {if (pos) {if (control & PCI_MSIX_FLAGS_ENABLE) {"resetting MSI-X\n" );/* * PCI prepping : enable device set bus mastering and dma mask if (rval) {return rval;sizeof (struct megasas_instance));if (!host) {"scsi_host_alloc failed\n" );goto fail_alloc_instance;struct megasas_instance *)host->hostdata;0 , sizeof (*instance));0 );/* * Initialize PCI related and misc parameters /* * Initialize MFI Firmware if (megasas_init_fw(instance))goto fail_init_mfi;if (instance->requestorId) {if (instance->PlasmaFW111) {sizeof (struct MR_LD_VF_AFFILIATION_111),if (!instance->vf_affiliation_111)"Can't allocate " "memory for VF affiliation buffer\n" );else {1 ) *sizeof (struct MR_LD_VF_AFFILIATION),if (!instance->vf_affiliation)"Can't allocate " "memory for VF affiliation buffer\n" );/* * Store instance in PCI softstate /* * Add this controller to megasas_mgmt_info structure so that it * can be exported to management applications /* * Register with SCSI mid - layer if (megasas_io_attach(instance))goto fail_io_attach;0 ;/* * Trigger SCSI to scan our drives if (!instance->enable_fw_dev_list ||0 ))/* * Initiate AEN ( Asynchronous Event Notification ) if (megasas_start_aen(instance)) {"start aen failed\n" );goto fail_start_aen;/* Get current SR-IOV LD/VF affiliation */ if (instance->requestorId)1 );return 0 ;1 ;if (instance->requestorId && !instance->skip_heartbeat_timer_del)if (instance->adapter_type != MFI_SERIES)else if (instance->msix_vectors)0 ;if (instance->fw_crash_state != UNAVAILABLE)if (instance->adapter_type != MFI_SERIES)return -ENODEV;/** * megasas_flush_cache - Requests FW to flush all its caches * @ instance : Adapter soft state static void megasas_flush_cache(struct megasas_instance *instance)struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)return ;if (!cmd)return ;0 , MFI_MBOX_SIZE);0 x0;0 ;0 ;0 ;0 ;0 ] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;if (megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS)"return from %s %d\n" , __func__, __LINE__);return ;/** * megasas_shutdown_controller - Instructs FW to shutdown the controller * @ instance : Adapter soft state * @ opcode : Shutdown / Hibernate static void megasas_shutdown_controller(struct megasas_instance *instance,struct megasas_cmd *cmd;struct megasas_dcmd_frame *dcmd;if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)return ;if (!cmd)return ;if (instance->aen_cmd)if (instance->map_update_cmd)if (instance->jbod_seq_cmd)0 , MFI_MBOX_SIZE);0 x0;0 ;0 ;0 ;0 ;if (megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS)"return from %s %d\n" , __func__, __LINE__);return ;/** * megasas_suspend - driver suspend entry point * @ dev : Device structure static int __maybe_unusedstruct device *dev)struct megasas_instance *instance;if (!instance)return 0 ;1 ;"%s is called\n" , __func__);/* Shutdown SR-IOV heartbeat timer */ if (instance->requestorId && !instance->skip_heartbeat_timer_del)/* Stop the FW fault detection watchdog */ if (instance->adapter_type != MFI_SERIES)/* cancel the delayed work if this work still in queue */ if (instance->ev != NULL) {struct megasas_aen_event *ev = instance->ev;if (instance->msix_vectors)return 0 ;/** * megasas_resume - driver resume entry point * @ dev : Device structure static int __maybe_unusedstruct device *dev)int rval;struct Scsi_Host *host;struct megasas_instance *instance;if (!instance)return 0 ;"%s is called\n" , __func__);/* * We expect the FW state to be READY if (megasas_transition_to_ready(instance, 0 )) {"Failed to transition controller to ready from %s!\n" ,if (instance->adapter_type != MFI_SERIES) {if (!(status_reg & MFI_RESET_ADAPTER) ||true , 0 )) == FAILED))goto fail_ready_state;else {1 );0 );/* waiting for about 30 seconds before retry */ 30 );if (megasas_transition_to_ready(instance, 0 ))goto fail_ready_state;"FW restarted successfully from %s!\n" ,if (megasas_set_dma_mask(instance))goto fail_set_dma_mask;/* * Initialize MFI Firmware 0 );0 );/* Now re-enable MSI-X */ if (instance->msix_vectors)if (!instance->msix_vectors) {1 , 1 ,if (rval < 0 )goto fail_reenable_msix;if (instance->adapter_type != MFI_SERIES) {if (megasas_ioc_init_fusion(instance)) {goto fail_init_mfi;if (!megasas_get_map_info(instance))else {0 ;0 ;if (megasas_issue_init_mfi(instance))goto fail_init_mfi;if (megasas_get_ctrl_info(instance) != DCMD_SUCCESS)goto fail_init_mfi;unsigned long )instance);if (instance->msix_vectors ?0 ) :goto fail_init_mfi;if (instance->adapter_type != MFI_SERIES)/* Re-launch SR-IOV heartbeat timer */ if (instance->requestorId) {if (!megasas_sriov_start_heartbeat(instance, 0 ))else {1 ;goto fail_init_mfi;0 ;/* * Initiate AEN ( Asynchronous Event Notification ) if (megasas_start_aen(instance))"Start AEN failed\n" );/* Re-launch FW fault watchdog */ if (instance->adapter_type != MFI_SERIES)if (megasas_fusion_start_watchdog(instance) != SUCCESS)goto fail_start_watchdog;return 0 ;if (instance->requestorId && !instance->skip_heartbeat_timer_del)return -ENODEV;static inline int struct megasas_instance *instance)int wait_time = MEGASAS_RESET_WAIT_TIME * 2 ;int i;for (i = 0 ; i < wait_time; i++) {if ((adp_state == MEGASAS_HBA_OPERATIONAL) ||break ;if (!(i % MEGASAS_RESET_NOTICE_INTERVAL))"waiting for controller reset to finish\n" );1000 );if (adp_state != MEGASAS_HBA_OPERATIONAL) {"%s HBA failed to become operational, adp_state %d\n" ,return 1 ;return 0 ;/** * megasas_detach_one - PCI hot " un " plug entry point * @ pdev : PCI device structure static void megasas_detach_one(struct pci_dev *pdev)int i;struct Scsi_Host *host;struct megasas_instance *instance;struct fusion_context *fusion;if (!instance)return ;/* Shutdown SR-IOV heartbeat timer */ if (instance->requestorId && !instance->skip_heartbeat_timer_del)/* Stop the FW fault detection watchdog */ if (instance->adapter_type != MFI_SERIES)if (instance->fw_crash_state != UNAVAILABLE)1 ;if (megasas_wait_for_adapter_operational(instance))goto skip_firing_dcmds;/* cancel the delayed work if this work still in queue*/ if (instance->ev != NULL) {struct megasas_aen_event *ev = instance->ev;/* cancel all wait events */ /* * Take the instance off the instance array . Note that we will not * decrement the max_index . We let this array be sparse array for (i = 0 ; i < megasas_mgmt_info.max_index; i++) {if (megasas_mgmt_info.instance[i] == instance) {break ;if (instance->msix_vectors)if (instance->adapter_type >= VENTURA_SERIES) {for (i = 0 ; i < MAX_LOGICAL_DRIVES_EXT; ++i)if (instance->adapter_type != MFI_SERIES) {struct MR_PD_CFG_SEQ_NUM_SYNC,for (i = 0 ; i < 2 ; i++) {if (fusion->ld_map[i])if (fusion->ld_drv_map[i]) {if (is_vmalloc_addr(fusion->ld_drv_map[i]))else if (fusion->pd_seq_sync[i])else {if (instance->vf_affiliation)1 ) *sizeof (struct MR_LD_VF_AFFILIATION),if (instance->vf_affiliation_111)sizeof (struct MR_LD_VF_AFFILIATION_111),if (instance->hb_host_mem)sizeof (struct MR_CTRL_HB_HOST_MEM),/** * megasas_shutdown - Shutdown entry point * @ pdev : PCI device structure static void megasas_shutdown(struct pci_dev *pdev)struct megasas_instance *instance = pci_get_drvdata(pdev);if (!instance)return ;1 ;if (megasas_wait_for_adapter_operational(instance))goto skip_firing_dcmds;if (instance->msix_vectors)/* * megasas_mgmt_open - char node " open " entry point * @ inode : char node inode * @ filep : char node file static int megasas_mgmt_open(struct inode *inode, struct file *filep)/* * Allow only those users with admin rights if (!capable(CAP_SYS_ADMIN))return -EACCES;return 0 ;/* * megasas_mgmt_fasync - Async notifier registration from applications * @ fd : char node file descriptor number * @ filep : char node file * @ mode : notifier on / off * * This function adds the calling process to a driver global queue . When an * event occurs , SIGIO will be sent to all processes in this queue . static int megasas_mgmt_fasync(int fd, struct file *filep, int mode)int rc;if (rc >= 0 ) {/* For sanity check when we get ioctl */ return 0 ;"megasas: fasync_helper failed [%d]\n" , rc);return rc;/* * megasas_mgmt_poll - char node " poll " entry point * @ filep : char node file * @ wait : Events to poll for static __poll_t megasas_mgmt_poll(struct file *file, poll_table *wait)unsigned long flags;if (megasas_poll_wait_aen)else 0 ;0 ;return mask;/* * megasas_set_crash_dump_params_ioctl : * Send CRASH_DUMP_MODE DCMD to all controllers * @ cmd : MFI command frame static int megasas_set_crash_dump_params_ioctl(struct megasas_cmd *cmd)struct megasas_instance *local_instance;int i, error = 0 ;int crash_support;0 ];for (i = 0 ; i < megasas_mgmt_info.max_index; i++) {if (local_instance && local_instance->crash_dump_drv_support) {if ((atomic_read(&local_instance->adprecovery) =="Application firmware crash " "dump mode set success\n" );0 ;else {"Application firmware crash " "dump mode set failed\n" );1 ;return error;/** * megasas_mgmt_fw_ioctl - Issues management ioctls to FW * @ instance : Adapter soft state * @ user_ioc : User ' s ioctl packet * @ ioc : ioctl packet static int struct megasas_instance *instance,struct megasas_iocpacket __user * user_ioc,struct megasas_iocpacket *ioc)struct megasas_sge64 *kern_sge64 = NULL;struct megasas_sge32 *kern_sge32 = NULL;struct megasas_cmd *cmd;void *kbuff_arr[MAX_IOCTL_SGE];0 ;int error = 0 , i;void *sense = NULL;void *sense_ptr;0 ;int ret = DCMD_SUCCESS;0 , sizeof (kbuff_arr));if (ioc->sge_count > MAX_IOCTL_SGE) {"SGE count [%d] > max limit [%d]\n" ,return -EINVAL;if ((ioc->frame.hdr.cmd >= MFI_CMD_OP_COUNT) ||"Received invalid ioctl command 0x%x\n" ,return -ENOTSUPP;if (!cmd) {"Failed to get a cmd packet\n" );return -ENOMEM;/* * User ' s IOCTL packet has 2 frames ( maximum ) . Copy those two * frames into our cmd ' s frames . cmd - > frame ' s context will get * overwritten when we copy from user ' s frames . So set that value * alone separately 2 * MEGAMFI_FRAME_SIZE);0 ;if (instance->consistent_mask_64bit)else if (cmd->frame->hdr.cmd == MFI_CMD_DCMD)if (opcode == MR_DCMD_CTRL_SHUTDOWN) {if (megasas_get_ctrl_info(instance) != DCMD_SUCCESS) {return -1 ;if (opcode == MR_DRIVER_SET_APP_CRASHDUMP_MODE) {return error;/* * The management interface between applications and the fw uses * MFI frames . E . g , RAID configuration changes , LD property changes * etc are accomplishes through different kinds of MFI frames . The * driver needs to care only about substituting user buffers with * kernel buffers in SGLs . The location of SGL is embedded in the * struct iocpacket itself . if (instance->consistent_mask_64bit)struct megasas_sge64 *)unsigned long )cmd->frame + ioc->sgl_off);else struct megasas_sge32 *)unsigned long )cmd->frame + ioc->sgl_off);/* * For each user buffer , create a mirror buffer and copy in for (i = 0 ; i < ioc->sge_count; i++) {if (!ioc->sgl[i].iov_len)continue ;if (!kbuff_arr[i]) {"Failed to alloc " "kernel SGL buffer for IOCTL\n" );goto out;/* * We don ' t change the dma_coherent_mask , so * dma_alloc_coherent only returns 32 bit addresses if (instance->consistent_mask_64bit) {else {/* * We created a kernel buffer corresponding to the * user buffer . Now copy in from the user buffer if (copy_from_user(kbuff_arr[i], ioc->sgl[i].iov_base,goto out;if (ioc->sense_len) {/* make sure the pointer is part of the frame */ if (ioc->sense_off >sizeof (union megasas_frame) - sizeof (__le64))) {goto out;if (!sense) {goto out;/* always store 64 bits regardless of addressing */ void *)cmd->frame + ioc->sense_off;/* * Set the sync_cmd flag so that the ISR knows not to complete this * cmd to the SCSI mid - layer 1 ;0 );switch (ret) {case DCMD_INIT:case DCMD_BUSY:0 ;"return -EBUSY from %s %d cmd 0x%x opcode 0x%x cmd->cmd_status_drv 0x%x\n" ,goto out;0 ;if (instance->unload == 1 ) {"Driver unload is in progress " "don't submit data to application\n" );goto out;/* * copy out the kernel buffers to user buffers for (i = 0 ; i < ioc->sge_count; i++) {if (copy_to_user(ioc->sgl[i].iov_base, kbuff_arr[i],goto out;/* * copy out the sense if (ioc->sense_len) {void __user *uptr;/* * sense_ptr points to the location that has the user * sense buffer address void *)ioc->frame.raw + ioc->sense_off;if (in_compat_syscall())else void __user **)sense_ptr);if (copy_to_user(uptr, sense, ioc->sense_len)) {"Failed to copy out to user " "sense data\n" );goto out;/* * copy the status codes returned by the fw if (copy_to_user(&user_ioc->frame.hdr.cmd_status,sizeof (u8))) {"Error copying out cmd_status\n" );if (sense) {for (i = 0 ; i < ioc->sge_count; i++) {if (kbuff_arr[i]) {if (instance->consistent_mask_64bit)else return error;static struct megasas_iocpacket *void __user *arg)struct megasas_iocpacket *ioc;struct compat_megasas_iocpacket __user *cioc = arg;int err = -EFAULT;int i;sizeof (*ioc), GFP_KERNEL);if (!ioc)return ERR_PTR(-ENOMEM);struct megasas_iocpacket, frame) + sizeof (ioc->frame);if (copy_from_user(ioc, arg, size))goto out;for (i = 0 ; i < MAX_IOCTL_SGE; i++) {if (get_user(iov_base, &cioc->sgl[i].iov_base) ||goto out;return ioc;return ERR_PTR(err);static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)struct megasas_iocpacket __user *user_ioc =struct megasas_iocpacket __user *)arg;struct megasas_iocpacket *ioc;struct megasas_instance *instance;int error;if (in_compat_syscall())else sizeof (struct megasas_iocpacket));if (IS_ERR(ioc))return PTR_ERR(ioc);if (!instance) {goto out_kfree_ioc;/* Block ioctls in VF mode */ if (instance->requestorId && !allow_vf_ioctls) {goto out_kfree_ioc;if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {"Controller in crit error\n" );goto out_kfree_ioc;if (instance->unload == 1 ) {goto out_kfree_ioc;if (down_interruptible(&instance->ioctl_sem)) {goto out_kfree_ioc;if (megasas_wait_for_adapter_operational(instance)) {goto out_up;return error;static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)struct megasas_instance *instance;struct megasas_aen aen;int error;if (file->private_data != file) {"megasas: fasync_helper was not " "called first\n" );return -EINVAL;if (copy_from_user(&aen, (void __user *)arg, sizeof (aen)))return -EFAULT;if (!instance)return -ENODEV;if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {return -ENODEV;if (instance->unload == 1 ) {return -ENODEV;if (megasas_wait_for_adapter_operational(instance))return -ENODEV;return error;/** * megasas_mgmt_ioctl - char node ioctl entry point * @ file : char device file pointer * @ cmd : ioctl command * @ arg : ioctl command arguments address static long struct file *file, unsigned int cmd, unsigned long arg)switch (cmd) {case MEGASAS_IOC_FIRMWARE:return megasas_mgmt_ioctl_fw(file, arg);case MEGASAS_IOC_GET_AEN:return megasas_mgmt_ioctl_aen(file, arg);return -ENOTTY;#ifdef CONFIG_COMPATstatic long struct file *file, unsigned int cmd,unsigned long arg)switch (cmd) {case MEGASAS_IOC_FIRMWARE32:return megasas_mgmt_ioctl_fw(file, arg);case MEGASAS_IOC_GET_AEN:return megasas_mgmt_ioctl_aen(file, arg);return -ENOTTY;#endif /* * File operations structure for management interface static const struct file_operations megasas_mgmt_fops = {#ifdef CONFIG_COMPAT#endif static SIMPLE_DEV_PM_OPS(megasas_pm_ops, megasas_suspend, megasas_resume);/* * PCI hotplug support registration structure static struct pci_driver megasas_pci_driver = {"megaraid_sas" ,/* * Sysfs driver attributes static ssize_t version_show(struct device_driver *dd, char *buf)return snprintf(buf, strlen(MEGASAS_VERSION) + 2 , "%s\n" ,static DRIVER_ATTR_RO(version);static ssize_t release_date_show(struct device_driver *dd, char *buf)return snprintf(buf, strlen(MEGASAS_RELDATE) + 2 , "%s\n" ,static DRIVER_ATTR_RO(release_date);static ssize_t support_poll_for_event_show(struct device_driver *dd, char *buf)return sprintf(buf, "%u\n" , support_poll_for_event);static DRIVER_ATTR_RO(support_poll_for_event);static ssize_t support_device_change_show(struct device_driver *dd, char *buf)return sprintf(buf, "%u\n" , support_device_change);static DRIVER_ATTR_RO(support_device_change);static ssize_t dbg_lvl_show(struct device_driver *dd, char *buf)return sprintf(buf, "%u\n" , megasas_dbg_lvl);static ssize_t dbg_lvl_store(struct device_driver *dd, const char *buf,int retval = count;if (sscanf(buf, "%u" , &megasas_dbg_lvl) < 1 ) {"megasas: could not set dbg_lvl\n" );return retval;static DRIVER_ATTR_RW(dbg_lvl);static ssize_tstruct device_driver *dd, char *buf)return sprintf(buf, "%u\n" , support_nvme_encapsulation);static DRIVER_ATTR_RO(support_nvme_encapsulation);static ssize_tstruct device_driver *dd, char *buf)return sprintf(buf, "%u\n" , support_pci_lane_margining);static DRIVER_ATTR_RO(support_pci_lane_margining);static inline void megasas_remove_scsi_device(struct scsi_device *sdev)"SCSI device is removed\n" );/** * megasas_update_device_list - Update the PD and LD device list from FW * after an AEN event notification * @ instance : Adapter soft state * @ event_type : Indicates type of event ( PD or LD event ) * * @ return : Success or failure * * Issue DCMDs to Firmware to update the internal device list in driver . * Based on the FW support , driver sends the HOST_DEVICE_LIST or combination * of PD_LIST / LD_LIST_QUERY DCMDs to get the device list . static int megasas_update_device_list(struct megasas_instance *instance,int event_type)int dcmd_ret;if (instance->enable_fw_dev_list) {return megasas_host_device_list_query(instance, false );else {if (event_type & SCAN_PD_CHANNEL) {if (dcmd_ret != DCMD_SUCCESS)return dcmd_ret;if (event_type & SCAN_VD_CHANNEL) {if (!instance->requestorId ||0 )) {return megasas_ld_list_query(instance,return DCMD_SUCCESS;/** * megasas_add_remove_devices - Add / remove devices to SCSI mid - layer * after an AEN event notification * @ instance : Adapter soft state * @ scan_type : Indicates type of devices ( PD / LD ) to add * @ return void static void megasas_add_remove_devices(struct megasas_instance *instance,int scan_type)int i, j;0 ;0 ;0 , id = 0 ;struct Scsi_Host *host;struct scsi_device *sdev1;struct MR_HOST_DEVICE_LIST *targetid_list = NULL;struct MR_HOST_DEVICE_LIST_ENTRY *targetid_entry = NULL;if (instance->enable_fw_dev_list) {for (i = 0 ; i < targetid_list->count; i++) {if (targetid_entry->flags.u.bits.is_sys_pd) {else {0 );if (!sdev1) {0 );else {if (scan_type & SCAN_PD_CHANNEL) {for (i = 0 ; i < MEGASAS_MAX_PD_CHANNELS; i++) {for (j = 0 ; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {0 );if (instance->pd_list[pd_index].driveState ==if (!sdev1)0 );else else {if (sdev1)if (scan_type & SCAN_VD_CHANNEL) {for (i = 0 ; i < MEGASAS_MAX_LD_CHANNELS; i++) {for (j = 0 ; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {0 );if (instance->ld_ids[ld_index] != 0 xff) {if (!sdev1)0 );else else {if (sdev1)static void struct work_struct *work)struct megasas_aen_event *ev =struct megasas_aen_event, hotplug_work.work);struct megasas_instance *instance = ev->instance;union megasas_evt_class_locale class_locale;int event_type = 0 ;int error;struct scsi_device *sdev1;if (!instance) {"invalid instance!\n" );return ;/* Don't run the event workqueue thread if OCR is running */ if (instance->evt_detail) {switch (le32_to_cpu(instance->evt_detail->code)) {case MR_EVT_PD_INSERTED:case MR_EVT_PD_REMOVED:break ;case MR_EVT_LD_OFFLINE:case MR_EVT_LD_DELETED:0 );if (sdev1) {break ;case MR_EVT_LD_CREATED:break ;case MR_EVT_CFG_CLEARED:case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:case MR_EVT_FOREIGN_CFG_IMPORTED:case MR_EVT_LD_STATE_CHANGE:"scanning for scsi%d...\n" ,break ;case MR_EVT_CTRL_PROP_CHANGED:if (dcmd_ret == DCMD_SUCCESS &&"Snap dump wait time\t: %d\n" ,break ;default :0 ;break ;else {"invalid evt_detail!\n" );return ;if (event_type)if (event_type && dcmd_ret == DCMD_SUCCESS)if (dcmd_ret == DCMD_SUCCESS)1 ;else /* Register AEN with FW for latest sequence number plus 1 */ 0 ;class = MR_EVT_CLASS_DEBUG;if (instance->aen_cmd != NULL) {return ;if (error)"register aen failed error %x\n" , error);/** * megasas_init - Driver load entry point static int __init megasas_init(void )int rval;/* * Booted in kdump kernel , minimize memory footprints by * disabling few features if (reset_devices) {1 ;0 ;1 ;0 ;/* * Announce driver version and other information "megasas: %s\n" , MEGASAS_VERSION);0 ;2 ;1 ;true ;true ;0 , sizeof (megasas_mgmt_info));/* * Register character device node 0 , "megaraid_sas_ioctl" , &megasas_mgmt_fops);if (rval < 0 ) {"megasas: failed to open device node\n" );return rval;/* * Register ourselves as PCI hotplug module if (rval) {"megasas: PCI hotplug registration failed \n" );goto err_pcidrv;if ((event_log_level < MFI_EVT_CLASS_DEBUG) ||"megaraid_sas: provided event log level is out of range, setting it to default 2(CLASS_CRITICAL), permissible range is: -2 to 4\n" );if (rval)goto err_dcf_attr_ver;if (rval)goto err_dcf_rel_date;if (rval)goto err_dcf_support_poll_for_event;if (rval)goto err_dcf_dbg_lvl;if (rval)goto err_dcf_support_device_change;if (rval)goto err_dcf_support_nvme_encapsulation;if (rval)goto err_dcf_support_pci_lane_margining;return rval;"megaraid_sas_ioctl" );return rval;/** * megasas_exit - Driver unload entry point static void __exit megasas_exit(void )"megaraid_sas_ioctl" );
Messung V0.5 in Prozent C=97 H=90 G=93
¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.388Angebot
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-09-27)
¤ *Eine klare Vorstellung vom Zielzustand
2026-10-10
Neuigkeiten Aktuelles Motto des Tages letze Version des Elbe Quellennavigators
Jenseits des Üblichen ....
Besucher
Statistik #Sources=1126864 #Domains=1897691
