/******************************************************************* * This file is part of the Emulex Linux Device Driver for * * Fibre Channel Host Bus Adapters . * * Copyright ( C ) 2017 - 2025 Broadcom . All Rights Reserved . The term * * “ Broadcom ” refers to Broadcom Inc . and / or its subsidiaries . * * Copyright ( C ) 2004 - 2016 Emulex . All rights reserved . * * EMULEX and SLI are trademarks of Emulex . * * www . broadcom . com * * Portions Copyright ( C ) 2004 - 2005 Christoph Hellwig * * * * This program is free software ; you can redistribute it and / or * * modify it under the terms of version 2 of the GNU General * * Public License as published by the Free Software Foundation . * * This program is distributed in the hope that it will be useful . * * ALL EXPRESS OR IMPLIED CONDITIONS , REPRESENTATIONS AND * * WARRANTIES , INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY , * * FITNESS FOR A PARTICULAR PURPOSE , OR NON - INFRINGEMENT , ARE * * DISCLAIMED , EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD * * TO BE LEGALLY INVALID . See the GNU General Public License for * * more details , a copy of which can be found in the file COPYING * * included with this package . * #include <linux/blkdev.h>#include <linux/pci.h>#include <linux/interrupt.h>#include <linux/delay.h>#include <linux/slab.h>#include <linux/lockdep.h>#include <scsi/scsi.h>#include <scsi/scsi_cmnd.h>#include <scsi/scsi_device.h>#include <scsi/scsi_host.h>#include <scsi/scsi_transport_fc.h>#include <scsi/fc/fc_fs.h>#include <linux/crash_dump.h>#ifdef CONFIG_X86#include <asm /set_memory.h>#endif #include "lpfc_hw4.h" #include "lpfc_hw.h" #include "lpfc_sli.h" #include "lpfc_sli4.h" #include "lpfc_nl.h" #include "lpfc_disc.h" #include "lpfc.h" #include "lpfc_scsi.h" #include "lpfc_nvme.h" #include "lpfc_crtn.h" #include "lpfc_logmsg.h" #include "lpfc_compat.h" #include "lpfc_debugfs.h" #include "lpfc_vport.h" #include "lpfc_version.h" /* There are only four IOCB completion types. */ typedef enum _lpfc_iocb_type {/* Provide function prototypes local to this module. */ static int lpfc_sli_issue_mbox_s4(struct lpfc_hba *, LPFC_MBOXQ_t *,static int lpfc_sli4_read_rev(struct lpfc_hba *, LPFC_MBOXQ_t *,static struct lpfc_iocbq *struct lpfc_hba *phba,struct lpfc_iocbq *rspiocbq);static void lpfc_sli4_send_seq_to_ulp(struct lpfc_vport *,struct hbq_dmabuf *);static void lpfc_sli4_handle_mds_loopback(struct lpfc_vport *vport,struct hbq_dmabuf *dmabuf);static bool lpfc_sli4_fp_handle_cqe(struct lpfc_hba *phba,struct lpfc_queue *cq, struct lpfc_cqe *cqe);static int lpfc_sli4_post_sgl_list(struct lpfc_hba *, struct list_head *,int );static void lpfc_sli4_hba_handle_eqe(struct lpfc_hba *phba,struct lpfc_queue *eq,struct lpfc_eqe *eqe,enum lpfc_poll_mode poll_mode);static bool lpfc_sli4_mbox_completions_pending(struct lpfc_hba *phba);static bool lpfc_sli4_process_missed_mbox_completions(struct lpfc_hba *phba);static struct lpfc_cqe *lpfc_sli4_cq_get(struct lpfc_queue *q);static void __lpfc_sli4_consume_cqe(struct lpfc_hba *phba,struct lpfc_queue *cq,struct lpfc_cqe *cqe);static uint16_t lpfc_wqe_bpl2sgl(struct lpfc_hba *phba,struct lpfc_iocbq *pwqeq,struct lpfc_sglq *sglq);union lpfc_wqe128 lpfc_iread_cmd_template;union lpfc_wqe128 lpfc_iwrite_cmd_template;union lpfc_wqe128 lpfc_icmnd_cmd_template;/* Setup WQE templates for IOs */ void lpfc_wqe_cmd_template(void )union lpfc_wqe128 *wqe;/* IREAD template */ 0 , sizeof (union lpfc_wqe128));/* Word 0, 1, 2 - BDE is variable */ /* Word 3 - cmd_buff_len, payload_offset_len is zero */ /* Word 4 - total_xfer_len is variable */ /* Word 5 - is zero */ /* Word 6 - ctxt_tag, xri_tag is variable */ /* Word 7 */ /* Word 8 - abort_tag is variable */ /* Word 9 - reqtag is variable */ /* Word 10 - dbde, wqes is variable */ 0 );0 );1 );/* Word 11 - pbde is variable */ 0 );/* Word 12 - is zero */ /* Word 13, 14, 15 - PBDE is variable */ /* IWRITE template */ 0 , sizeof (union lpfc_wqe128));/* Word 0, 1, 2 - BDE is variable */ /* Word 3 - cmd_buff_len, payload_offset_len is zero */ /* Word 4 - total_xfer_len is variable */ /* Word 5 - initial_xfer_len is variable */ /* Word 6 - ctxt_tag, xri_tag is variable */ /* Word 7 */ /* Word 8 - abort_tag is variable */ /* Word 9 - reqtag is variable */ /* Word 10 - dbde, wqes is variable */ 0 );0 );1 );/* Word 11 - pbde is variable */ 0 );/* Word 12 - is zero */ /* Word 13, 14, 15 - PBDE is variable */ /* ICMND template */ 0 , sizeof (union lpfc_wqe128));/* Word 0, 1, 2 - BDE is variable */ /* Word 3 - payload_offset_len is variable */ /* Word 4, 5 - is zero */ /* Word 6 - ctxt_tag, xri_tag is variable */ /* Word 7 */ 0 );/* Word 8 - abort_tag is variable */ /* Word 9 - reqtag is variable */ /* Word 10 - dbde, wqes is variable */ 1 );0 );1 );/* Word 11 */ 0 );/* Word 12, 13, 14, 15 - is zero */ #if defined (CONFIG_64BIT) && defined (__LITTLE_ENDIAN)/** * lpfc_sli4_pcimem_bcopy - SLI4 memory copy function * @ srcp : Source memory pointer . * @ destp : Destination memory pointer . * @ cnt : Number of words required to be copied . * Must be a multiple of sizeof ( uint64_t ) * * This function is used for copying data between driver memory * and the SLI WQ . This function also changes the endianness * of each word if native endianness is different from SLI * endianness . This function can be called with or without * lock . static void void *srcp, void *destp, uint32_t cnt)int i;for (i = 0 ; i < (int )cnt; i += sizeof (uint64_t))#else #define lpfc_sli4_pcimem_bcopy(a, b, c) lpfc_sli_pcimem_bcopy(a, b, c)#endif /** * lpfc_sli4_wq_put - Put a Work Queue Entry on an Work Queue * @ q : The Work Queue to operate on . * @ wqe : The work Queue Entry to put on the Work queue . * * This routine will copy the contents of @ wqe to the next available entry on * the @ q . This function will then ring the Work Queue Doorbell to signal the * HBA to start processing the Work Queue Entry . This function returns 0 if * successful . If no entries are available on @ q then this function will return * - ENOMEM . * The caller is expected to hold the hbalock when calling this routine . static int struct lpfc_queue *q, union lpfc_wqe128 *wqe)union lpfc_wqe *temp_wqe;struct lpfc_register doorbell;0 ;/* sanity check on queue memory */ if (unlikely(!q))return -ENOMEM;/* If the host has not yet processed the next entry then we are done */ 1 ) % q->entry_count);if (idx == q->hba_index) {return -EBUSY;/* set consumption flag every once in a while */ if (!((q->host_index + 1 ) % q->notify_interval))1 );else 0 );if (q->phba->sli3_options & LPFC_SLI4_PHWQ_ENABLED)if (q->dpp_enable && q->phba->cfg_enable_dpp) {/* write to DPP aperture taking advatage of Combined Writes */ #ifdef __raw_writeqfor (i = 0 ; i < q->entry_size; i += sizeof (uint64_t))#else for (i = 0 ; i < q->entry_size; i += sizeof (uint32_t))#endif /* ensure WQE bcopy and DPP flushed before doorbell write */ /* Update the host index before invoking device */ /* Ring Doorbell */ 0 ;if (q->db_format == LPFC_DB_LIST_FORMAT) {if (q->dpp_enable && q->phba->cfg_enable_dpp) {1 );1 );else {1 );/* Leave bits <23:16> clear for if_type 6 dpp */ if (if_type != LPFC_SLI_INTF_IF_TYPE_6)else if (q->db_format == LPFC_DB_RING_FORMAT) {1 );else {return -EINVAL;return 0 ;/** * lpfc_sli4_wq_release - Updates internal hba index for WQ * @ q : The Work Queue to operate on . * @ index : The index to advance the hba index to . * * This routine will update the HBA index of a queue to reflect consumption of * Work Queue Entries by the HBA . When the HBA indicates that it has consumed * an entry the host calls this function to update the queue ' s internal * pointers . static void struct lpfc_queue *q, uint32_t index)/* sanity check on queue memory */ if (unlikely(!q))return ;/** * lpfc_sli4_mq_put - Put a Mailbox Queue Entry on an Mailbox Queue * @ q : The Mailbox Queue to operate on . * @ mqe : The Mailbox Queue Entry to put on the Work queue . * * This routine will copy the contents of @ mqe to the next available entry on * the @ q . This function will then ring the Work Queue Doorbell to signal the * HBA to start processing the Work Queue Entry . This function returns 0 if * successful . If no entries are available on @ q then this function will return * - ENOMEM . * The caller is expected to hold the hbalock when calling this routine . static uint32_tstruct lpfc_queue *q, struct lpfc_mqe *mqe)struct lpfc_mqe *temp_mqe;struct lpfc_register doorbell;/* sanity check on queue memory */ if (unlikely(!q))return -ENOMEM;/* If the host has not yet processed the next entry then we are done */ if (((q->host_index + 1 ) % q->entry_count) == q->hba_index)return -ENOMEM;/* Save off the mailbox pointer for completion */ /* Update the host index before invoking device */ 1 ) % q->entry_count);/* Ring Doorbell */ 0 ;1 );return 0 ;/** * lpfc_sli4_mq_release - Updates internal hba index for MQ * @ q : The Mailbox Queue to operate on . * * This routine will update the HBA index of a queue to reflect consumption of * a Mailbox Queue Entry by the HBA . When the HBA indicates that it has consumed * an entry the host calls this function to update the queue ' s internal * pointers . This routine returns the number of entries that were consumed by * the HBA . static uint32_tstruct lpfc_queue *q)/* sanity check on queue memory */ if (unlikely(!q))return 0 ;/* Clear the mailbox pointer for completion */ 1 ) % q->entry_count);return 1 ;/** * lpfc_sli4_eq_get - Gets the next valid EQE from a EQ * @ q : The Event Queue to get the first valid EQE from * * This routine will get the first valid Event Queue Entry from @ q , update * the queue ' s internal hba index , and return the EQE . If no valid EQEs are in * the Queue ( no more work to do ) , or the Queue is full of EQEs that have been * processed , but not popped back to the HBA then this routine will return NULL . static struct lpfc_eqe *struct lpfc_queue *q)struct lpfc_eqe *eqe;/* sanity check on queue memory */ if (unlikely(!q))return NULL;/* If the next EQE is not valid then we are done */ if (bf_get_le32(lpfc_eqe_valid, eqe) != q->qe_valid)return NULL;/* * insert barrier for instruction interlock : data from the hardware * must have the valid bit checked before it can be copied and acted * upon . Speculative instructions were allowing a bcopy at the start * of lpfc_sli4_fp_handle_wcqe ( ) , which is called immediately * after our return , to copy data before the valid bit check above * was done . As such , some of the copied data was stale . The barrier * ensures the check is before any data is copied . return eqe;/** * lpfc_sli4_eq_clr_intr - Turn off interrupts from this EQ * @ q : The Event Queue to disable interrupts * void struct lpfc_queue *q)struct lpfc_register doorbell;0 ;1 );/** * lpfc_sli4_if6_eq_clr_intr - Turn off interrupts from this EQ * @ q : The Event Queue to disable interrupts * void struct lpfc_queue *q)struct lpfc_register doorbell;0 ;/** * lpfc_sli4_write_eq_db - write EQ DB for eqe ' s consumed or arm state * @ phba : adapter with EQ * @ q : The Event Queue that the host has completed processing for . * @ count : Number of elements that have been consumed * @ arm : Indicates whether the host wants to arms this CQ . * * This routine will notify the HBA , by ringing the doorbell , that count * number of EQEs have been processed . The @ arm parameter indicates whether * the queue should be rearmed when ringing the doorbell . void struct lpfc_hba *phba, struct lpfc_queue *q,bool arm)struct lpfc_register doorbell;/* sanity check on queue memory */ if (unlikely(!q || (count == 0 && !arm)))return ;/* ring doorbell for number popped */ 0 ;if (arm) {1 );1 );/* PCI read to flush PCI pipeline on re-arming for INTx mode */ if ((q->phba->intr_type == INTx) && (arm == LPFC_QUEUE_REARM))/** * lpfc_sli4_if6_write_eq_db - write EQ DB for eqe ' s consumed or arm state * @ phba : adapter with EQ * @ q : The Event Queue that the host has completed processing for . * @ count : Number of elements that have been consumed * @ arm : Indicates whether the host wants to arms this CQ . * * This routine will notify the HBA , by ringing the doorbell , that count * number of EQEs have been processed . The @ arm parameter indicates whether * the queue should be rearmed when ringing the doorbell . void struct lpfc_hba *phba, struct lpfc_queue *q,bool arm)struct lpfc_register doorbell;/* sanity check on queue memory */ if (unlikely(!q || (count == 0 && !arm)))return ;/* ring doorbell for number popped */ 0 ;if (arm)1 );/* PCI read to flush PCI pipeline on re-arming for INTx mode */ if ((q->phba->intr_type == INTx) && (arm == LPFC_QUEUE_REARM))static void struct lpfc_hba *phba, struct lpfc_queue *eq,struct lpfc_eqe *eqe)if (!phba->sli4_hba.pc_sli4_params.eqav)0 );1 ) % eq->entry_count);/* if the index wrapped around, toggle the valid bit */ if (phba->sli4_hba.pc_sli4_params.eqav && !eq->host_index)0 : 1 ;static void struct lpfc_hba *phba, struct lpfc_queue *eq)struct lpfc_eqe *eqe = NULL;0 , cq_count = 0 ;struct lpfc_cqe *cqe = NULL;struct lpfc_queue *cq = NULL, *childq = NULL;int cqid = 0 ;/* walk all the EQ entries and drop on the floor */ while (eqe) {/* Get the reference to the corresponding CQ */ if (childq->queue_id == cqid) {break ;/* If CQ is valid, iterate through it and drop all the CQEs */ if (cq) {while (cqe) {/* Clear and re-arm the CQ */ 0 ;/* Clear and re-arm the EQ */ static int struct lpfc_hba *phba, struct lpfc_queue *eq,enum lpfc_poll_mode poll_mode)struct lpfc_eqe *eqe;int count = 0 , consumed = 0 ;if (cmpxchg(&eq->queue_claimed, 0 , 1 ) != 0 )goto rearm_and_exit;while (eqe) {if (!(++count % eq->max_proc_limit))break ;if (!(count % eq->notify_interval)) {0 ;/* Track the max number of EQEs processed in 1 intr */ if (count > eq->EQ_max_eqe)0 );/* Always clear the EQ. */ return count;/** * lpfc_sli4_cq_get - Gets the next valid CQE from a CQ * @ q : The Completion Queue to get the first valid CQE from * * This routine will get the first valid Completion Queue Entry from @ q , update * the queue ' s internal hba index , and return the CQE . If no valid CQEs are in * the Queue ( no more work to do ) , or the Queue is full of CQEs that have been * processed , but not popped back to the HBA then this routine will return NULL . static struct lpfc_cqe *struct lpfc_queue *q)struct lpfc_cqe *cqe;/* sanity check on queue memory */ if (unlikely(!q))return NULL;/* If the next CQE is not valid then we are done */ if (bf_get_le32(lpfc_cqe_valid, cqe) != q->qe_valid)return NULL;/* * insert barrier for instruction interlock : data from the hardware * must have the valid bit checked before it can be copied and acted * upon . Given what was seen in lpfc_sli4_cq_get ( ) of speculative * instructions allowing action on content before valid bit checked , * add barrier here as well . May not be needed as " content " is a * single 32 - bit entity here ( vs multi word structure for cq ' s ) . return cqe;static void struct lpfc_hba *phba, struct lpfc_queue *cq,struct lpfc_cqe *cqe)if (!phba->sli4_hba.pc_sli4_params.cqav)0 );1 ) % cq->entry_count);/* if the index wrapped around, toggle the valid bit */ if (phba->sli4_hba.pc_sli4_params.cqav && !cq->host_index)0 : 1 ;/** * lpfc_sli4_write_cq_db - write cq DB for entries consumed or arm state . * @ phba : the adapter with the CQ * @ q : The Completion Queue that the host has completed processing for . * @ count : the number of elements that were consumed * @ arm : Indicates whether the host wants to arms this CQ . * * This routine will notify the HBA , by ringing the doorbell , that the * CQEs have been processed . The @ arm parameter specifies whether the * queue should be rearmed when ringing the doorbell . void struct lpfc_hba *phba, struct lpfc_queue *q,bool arm)struct lpfc_register doorbell;/* sanity check on queue memory */ if (unlikely(!q || (count == 0 && !arm)))return ;/* ring doorbell for number popped */ 0 ;if (arm)1 );/** * lpfc_sli4_if6_write_cq_db - write cq DB for entries consumed or arm state . * @ phba : the adapter with the CQ * @ q : The Completion Queue that the host has completed processing for . * @ count : the number of elements that were consumed * @ arm : Indicates whether the host wants to arms this CQ . * * This routine will notify the HBA , by ringing the doorbell , that the * CQEs have been processed . The @ arm parameter specifies whether the * queue should be rearmed when ringing the doorbell . void struct lpfc_hba *phba, struct lpfc_queue *q,bool arm)struct lpfc_register doorbell;/* sanity check on queue memory */ if (unlikely(!q || (count == 0 && !arm)))return ;/* ring doorbell for number popped */ 0 ;if (arm)1 );/* * lpfc_sli4_rq_put - Put a Receive Buffer Queue Entry on a Receive Queue * * This routine will copy the contents of @ wqe to the next available entry on * the @ q . This function will then ring the Receive Queue Doorbell to signal the * HBA to start processing the Receive Queue Entry . This function returns the * index that the rqe was copied to if successful . If no entries are available * on @ q then this function will return - ENOMEM . * The caller is expected to hold the hbalock when calling this routine . int struct lpfc_queue *hq, struct lpfc_queue *dq,struct lpfc_rqe *hrqe, struct lpfc_rqe *drqe)struct lpfc_rqe *temp_hrqe;struct lpfc_rqe *temp_drqe;struct lpfc_register doorbell;int hq_put_index;int dq_put_index;/* sanity check on queue memory */ if (unlikely(!hq) || unlikely(!dq))return -ENOMEM;if (hq->type != LPFC_HRQ || dq->type != LPFC_DRQ)return -EINVAL;if (hq_put_index != dq_put_index)return -EINVAL;/* If the host has not yet processed the next entry then we are done */ if (((hq_put_index + 1 ) % hq->entry_count) == hq->hba_index)return -EBUSY;/* Update the host index to point to the next slot */ 1 ) % hq->entry_count);1 ) % dq->entry_count);/* Ring The Header Receive Queue Doorbell */ if (!(hq->host_index % hq->notify_interval)) {0 ;if (hq->db_format == LPFC_DB_RING_FORMAT) {else if (hq->db_format == LPFC_DB_LIST_FORMAT) {else {return -EINVAL;return hq_put_index;/* * lpfc_sli4_rq_release - Updates internal hba index for RQ * * This routine will update the HBA index of a queue to reflect consumption of * one Receive Queue Entry by the HBA . When the HBA indicates that it has * consumed an entry the host calls this function to update the queue ' s * internal pointers . This routine returns the number of entries that were * consumed by the HBA . static uint32_tstruct lpfc_queue *hq, struct lpfc_queue *dq)/* sanity check on queue memory */ if (unlikely(!hq) || unlikely(!dq))return 0 ;if ((hq->type != LPFC_HRQ) || (dq->type != LPFC_DRQ))return 0 ;1 ) % hq->entry_count);1 ) % dq->entry_count);return 1 ;/** * lpfc_cmd_iocb - Get next command iocb entry in the ring * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * * This function returns pointer to next command iocb entry * in the command ring . The caller must hold hbalock to prevent * other threads consume the next command iocb . * SLI - 2 / SLI - 3 provide different sized iocbs . static inline IOCB_t *struct lpfc_hba *phba, struct lpfc_sli_ring *pring)return (IOCB_t *) (((char *) pring->sli.sli3.cmdringaddr) +/** * lpfc_resp_iocb - Get next response iocb entry in the ring * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * * This function returns pointer to next response iocb entry * in the response ring . The caller must hold hbalock to make sure * that no other thread consume the next response iocb . * SLI - 2 / SLI - 3 provide different sized iocbs . static inline IOCB_t *struct lpfc_hba *phba, struct lpfc_sli_ring *pring)return (IOCB_t *) (((char *) pring->sli.sli3.rspringaddr) +/** * _ _ lpfc_sli_get_iocbq - Allocates an iocb object from iocb pool * @ phba : Pointer to HBA context object . * * This function is called with hbalock held . This function * allocates a new driver iocb object from the iocb pool . If the * allocation is successful , it returns pointer to the newly * allocated iocb object else it returns NULL . struct lpfc_iocbq *struct lpfc_hba *phba)struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;struct lpfc_iocbq * iocbq = NULL;struct lpfc_iocbq, list);if (iocbq)if (phba->iocb_cnt > phba->iocb_max)return iocbq;/** * _ _ lpfc_clear_active_sglq - Remove the active sglq for this XRI . * @ phba : Pointer to HBA context object . * @ xritag : XRI value . * * This function clears the sglq pointer from the array of active * sglq ' s . The xritag that is passed in is used to index into the * array . Before the xritag can be used it needs to be adjusted * by subtracting the xribase . * * Returns sglq ponter = success , NULL = Failure . struct lpfc_sglq *struct lpfc_hba *phba, uint16_t xritag)struct lpfc_sglq *sglq;return sglq;/** * _ _ lpfc_get_active_sglq - Get the active sglq for this XRI . * @ phba : Pointer to HBA context object . * @ xritag : XRI value . * * This function returns the sglq pointer from the array of active * sglq ' s . The xritag that is passed in is used to index into the * array . Before the xritag can be used it needs to be adjusted * by subtracting the xribase . * * Returns sglq ponter = success , NULL = Failure . struct lpfc_sglq *struct lpfc_hba *phba, uint16_t xritag)struct lpfc_sglq *sglq;return sglq;/** * lpfc_clr_rrq_active - Clears RRQ active bit in xri_bitmap . * @ phba : Pointer to HBA context object . * @ xritag : xri used in this exchange . * @ rrq : The RRQ to be cleared . * void struct lpfc_hba *phba,struct lpfc_node_rrq *rrq)struct lpfc_nodelist *ndlp = NULL;/* Lookup did to verify if did is still active on this vport */ if (rrq->vport)if (!ndlp)goto out;if (test_and_clear_bit(xritag, ndlp->active_rrqs_xri_bitmap)) {0 ;0 ;0 ;/** * lpfc_handle_rrq_active - Checks if RRQ has waithed RATOV . * @ phba : Pointer to HBA context object . * * This function is called with hbalock held . This function * Checks if stop_time ( ratov from setting rrq active ) has * been reached , if it has and the send_rrq flag is set then * it will call lpfc_send_rrq . If the send_rrq flag is not set * then it will just call the routine to clear the rrq and * free the rrq resource . * The timer is set to the next rrq that is going to expire before * leaving the routine . * void struct lpfc_hba *phba)struct lpfc_node_rrq *rrq;struct lpfc_node_rrq *nextrrq;unsigned long next_time;unsigned long iflags;1 );if (time_after(jiffies, rrq->rrq_stop_time))else if (time_before(rrq->rrq_stop_time, next_time))if ((!list_empty(&phba->active_rrq_list)) &&if (!rrq->send_rrq) {/* this call will free the rrq */ else if (lpfc_send_rrq(phba, rrq)) {/* if we send the rrq then the completion handler * will clear the bit in the xribitmap . /** * lpfc_get_active_rrq - Get the active RRQ for this exchange . * @ vport : Pointer to vport context object . * @ xri : The xri used in the exchange . * @ did : The targets DID for this exchange . * * returns NULL = rrq not found in the phba - > active_rrq_list . * rrq = rrq for this xri and target . struct lpfc_node_rrq *struct lpfc_vport *vport, uint16_t xri, uint32_t did)struct lpfc_hba *phba = vport->phba;struct lpfc_node_rrq *rrq;struct lpfc_node_rrq *nextrrq;unsigned long iflags;if (phba->sli_rev != LPFC_SLI_REV4)return NULL;if (rrq->vport == vport && rrq->xritag == xri &&return rrq;return NULL;/** * lpfc_cleanup_vports_rrqs - Remove and clear the active RRQ for this vport . * @ vport : Pointer to vport context object . * @ ndlp : Pointer to the lpfc_node_list structure . * If ndlp is NULL Remove all active RRQs for this vport from the * phba - > active_rrq_list and clear the rrq . * If ndlp is not NULL then only remove rrqs for this vport & this ndlp . void struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)struct lpfc_hba *phba = vport->phba;struct lpfc_node_rrq *rrq;struct lpfc_node_rrq *nextrrq;unsigned long iflags;if (phba->sli_rev != LPFC_SLI_REV4)return ;if (!ndlp) {if (rrq->vport != vport)continue ;if (!ndlp || ndlp == lpfc_findnode_did(vport, rrq->nlp_DID))/** * lpfc_test_rrq_active - Test RRQ bit in xri_bitmap . * @ phba : Pointer to HBA context object . * @ ndlp : Targets nodelist pointer for this exchange . * @ xritag : the xri in the bitmap to test . * * This function returns : * 0 = rrq not active for this xri * 1 = rrq is valid for this xri . int struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,if (!ndlp)return 0 ;if (!ndlp->active_rrqs_xri_bitmap)return 0 ;if (test_bit(xritag, ndlp->active_rrqs_xri_bitmap))return 1 ;else return 0 ;/** * lpfc_set_rrq_active - set RRQ active bit in xri_bitmap . * @ phba : Pointer to HBA context object . * @ ndlp : nodelist pointer for this target . * @ xritag : xri used in this exchange . * @ rxid : Remote Exchange ID . * @ send_rrq : Flag used to determine if we should send rrq els cmd . * * This function takes the hbalock . * The active bit is always set in the active rrq xri_bitmap even * if there is no slot avaiable for the other rrq information . * * returns 0 rrq actived for this xri * < 0 No memory or invalid ndlp . int struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,unsigned long iflags;struct lpfc_node_rrq *rrq;int empty;if (!ndlp)return -EINVAL;if (!phba->cfg_enable_rrq)return -EINVAL;if (test_bit(FC_UNLOADING, &phba->pport->load_flag)) {goto outnl;if (ndlp->vport && test_bit(FC_UNLOADING, &ndlp->vport->load_flag))goto out;if (!ndlp->active_rrqs_xri_bitmap)goto out;if (test_and_set_bit(xritag, ndlp->active_rrqs_xri_bitmap))goto out;if (!rrq) {"3155 Unable to allocate RRQ xri:0x%x rxid:0x%x" " DID:0x%x Send:%d\n" ,return -EINVAL;if (phba->cfg_enable_rrq == 1 )else 0 ;1 );if (empty)return 0 ;"2921 Can't set rrq active xri:0x%x rxid:0x%x" " DID:0x%x Send:%d\n" ,return -EINVAL;/** * _ _ lpfc_sli_get_els_sglq - Allocates an iocb object from sgl pool * @ phba : Pointer to HBA context object . * @ piocbq : Pointer to the iocbq . * * The driver calls this function with either the nvme ls ring lock * or the fc els ring lock held depending on the iocb usage . This function * gets a new driver sglq object from the sglq list . If the list is not empty * then it is successful , it returns pointer to the newly allocated sglq * object else it returns NULL . static struct lpfc_sglq *struct lpfc_hba *phba, struct lpfc_iocbq *piocbq)struct list_head *lpfc_els_sgl_list = &phba->sli4_hba.lpfc_els_sgl_list;struct lpfc_sglq *sglq = NULL;struct lpfc_sglq *start_sglq = NULL;struct lpfc_io_buf *lpfc_cmd;struct lpfc_nodelist *ndlp;int found = 0 ;if (piocbq->cmd_flag & LPFC_IO_FCP) {else if ((cmnd == CMD_GEN_REQUEST64_CR) &&else if (piocbq->cmd_flag & LPFC_IO_LIBDFC) {if (piocbq->cmd_flag & LPFC_IO_LOOPBACK)else else {struct lpfc_sglq, list);while (!found) {if (!sglq)break ;if (ndlp && ndlp->active_rrqs_xri_bitmap &&/* This xri has an rrq outstanding for this DID. * put it back in the list and get another xri . struct lpfc_sglq, list);if (sglq == start_sglq) {break ;else continue ;1 ;return sglq;/** * _ _ lpfc_sli_get_nvmet_sglq - Allocates an iocb object from sgl pool * @ phba : Pointer to HBA context object . * @ piocbq : Pointer to the iocbq . * * This function is called with the sgl_list lock held . This function * gets a new driver sglq object from the sglq list . If the * list is not empty then it is successful , it returns pointer to the newly * allocated sglq object else it returns NULL . struct lpfc_sglq *struct lpfc_hba *phba, struct lpfc_iocbq *piocbq)struct list_head *lpfc_nvmet_sgl_list;struct lpfc_sglq *sglq = NULL;struct lpfc_sglq, list);if (!sglq)return NULL;return sglq;/** * lpfc_sli_get_iocbq - Allocates an iocb object from iocb pool * @ phba : Pointer to HBA context object . * * This function is called with no lock held . This function * allocates a new driver iocb object from the iocb pool . If the * allocation is successful , it returns pointer to the newly * allocated iocb object else it returns NULL . struct lpfc_iocbq *struct lpfc_hba *phba)struct lpfc_iocbq * iocbq = NULL;unsigned long iflags;return iocbq;/** * _ _ lpfc_sli_release_iocbq_s4 - Release iocb to the iocb pool * @ phba : Pointer to HBA context object . * @ iocbq : Pointer to driver iocb object . * * This function is called to release the driver iocb object * to the iocb pool . The iotag in the iocb object * does not change for each use of the iocb object . This function * clears all other fields of the iocb object when it is freed . * The sqlq structure that holds the xritag and phys and virtual * mappings for the scatter gather list is retrieved from the * active array of sglq . The get of the sglq pointer also clears * the entry in the array . If the status of the IO indiactes that * this IO was aborted then the sglq entry it put on the * lpfc_abts_els_sgl_list until the CQ_ABORTED_XRI is received . If the * IO has good status or fails for any other reason then the sglq * entry is added to the free list ( lpfc_els_sgl_list ) . The hbalock is * asserted held in the code path calling this routine . static void struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)struct lpfc_sglq *sglq;unsigned long iflag = 0 ;struct lpfc_sli_ring *pring;if (iocbq->sli4_xritag == NO_XRI)else if (sglq) {if (iocbq->cmd_flag & LPFC_IO_NVMET) {goto out;if ((iocbq->cmd_flag & LPFC_EXCHANGE_BUSY) &&/* Check if we can get a reference on ndlp */ if (sglq->ndlp && !lpfc_nlp_get(sglq->ndlp))else {/* Check if TXQ queue needs to be serviced */ if (pring && (!list_empty(&pring->txq)))/* * Clean all volatile data fields , preserve iotag and node struct . 0 , wqe);/** * _ _ lpfc_sli_release_iocbq_s3 - Release iocb to the iocb pool * @ phba : Pointer to HBA context object . * @ iocbq : Pointer to driver iocb object . * * This function is called to release the driver iocb object to the * iocb pool . The iotag in the iocb object does not change for each * use of the iocb object . This function clears all other fields of * the iocb object when it is freed . The hbalock is asserted held in * the code path calling this routine . static void struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)/* * Clean all volatile data fields , preserve iotag and node struct . 0 , iocb);/** * _ _ lpfc_sli_release_iocbq - Release iocb to the iocb pool * @ phba : Pointer to HBA context object . * @ iocbq : Pointer to driver iocb object . * * This function is called with hbalock held to release driver * iocb object to the iocb pool . The iotag in the iocb object * does not change for each use of the iocb object . This function * clears all other fields of the iocb object when it is freed . static void struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)/** * lpfc_sli_release_iocbq - Release iocb to the iocb pool * @ phba : Pointer to HBA context object . * @ iocbq : Pointer to driver iocb object . * * This function is called with no lock held to release the iocb to * iocb pool . void struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)unsigned long iflags;/* * Clean all volatile data fields , preserve iotag and node struct . /** * lpfc_sli_cancel_iocbs - Cancel all iocbs from a list . * @ phba : Pointer to HBA context object . * @ iocblist : List of IOCBs . * @ ulpstatus : ULP status in IOCB command field . * @ ulpWord4 : ULP word - 4 in IOCB command field . * * This function is called with a list of IOCBs to cancel . It cancels the IOCB * on the list by invoking the complete callback function associated with the * IOCB with the provided @ ulpstatus and @ ulpword4 set to the IOCB commond * fields . void struct lpfc_hba *phba, struct list_head *iocblist,struct lpfc_iocbq *piocb;while (!list_empty(iocblist)) {struct lpfc_iocbq, list);if (piocb->cmd_cmpl) {if (piocb->cmd_flag & LPFC_IO_NVME) {else {if (phba->sli_rev == LPFC_SLI_REV4) {else {4 ] = ulpWord4;else {return ;/** * lpfc_sli_iocb_cmd_type - Get the iocb type * @ iocb_cmnd : iocb command code . * * This function is called by ring event handler function to get the iocb type . * This function translates the iocb command to an iocb command type used to * decide the final disposition of each completed IOCB . * The function returns * LPFC_UNKNOWN_IOCB if it is an unsupported iocb * LPFC_SOL_IOCB if it is a solicited iocb completion * LPFC_ABORT_IOCB if it is an abort iocb * LPFC_UNSOL_IOCB if it is an unsolicited iocb * * The caller is not required to hold any lock . static lpfc_iocb_typeif (iocb_cmnd > CMD_MAX_IOCB_CMD)return 0 ;switch (iocb_cmnd) {case CMD_XMIT_SEQUENCE_CR:case CMD_XMIT_SEQUENCE_CX:case CMD_XMIT_BCAST_CN:case CMD_XMIT_BCAST_CX:case CMD_ELS_REQUEST_CR:case CMD_ELS_REQUEST_CX:case CMD_CREATE_XRI_CR:case CMD_CREATE_XRI_CX:case CMD_GET_RPI_CN:case CMD_XMIT_ELS_RSP_CX:case CMD_GET_RPI_CR:case CMD_FCP_IWRITE_CR:case CMD_FCP_IWRITE_CX:case CMD_FCP_IREAD_CR:case CMD_FCP_IREAD_CX:case CMD_FCP_ICMND_CR:case CMD_FCP_ICMND_CX:case CMD_FCP_TSEND_CX:case CMD_FCP_TRSP_CX:case CMD_FCP_TRECEIVE_CX:case CMD_FCP_AUTO_TRSP_CX:case CMD_ADAPTER_MSG:case CMD_ADAPTER_DUMP:case CMD_XMIT_SEQUENCE64_CR:case CMD_XMIT_SEQUENCE64_CX:case CMD_XMIT_BCAST64_CN:case CMD_XMIT_BCAST64_CX:case CMD_ELS_REQUEST64_CR:case CMD_ELS_REQUEST64_CX:case CMD_FCP_IWRITE64_CR:case CMD_FCP_IWRITE64_CX:case CMD_FCP_IREAD64_CR:case CMD_FCP_IREAD64_CX:case CMD_FCP_ICMND64_CR:case CMD_FCP_ICMND64_CX:case CMD_FCP_TSEND64_CX:case CMD_FCP_TRSP64_CX:case CMD_FCP_TRECEIVE64_CX:case CMD_GEN_REQUEST64_CR:case CMD_GEN_REQUEST64_CX:case CMD_XMIT_ELS_RSP64_CX:case DSSCMD_IWRITE64_CR:case DSSCMD_IWRITE64_CX:case DSSCMD_IREAD64_CR:case DSSCMD_IREAD64_CX:case CMD_SEND_FRAME:break ;case CMD_ABORT_XRI_CN:case CMD_ABORT_XRI_CX:case CMD_CLOSE_XRI_CN:case CMD_CLOSE_XRI_CX:case CMD_XRI_ABORTED_CX:case CMD_ABORT_MXRI64_CN:case CMD_XMIT_BLS_RSP64_CX:break ;case CMD_RCV_SEQUENCE_CX:case CMD_RCV_ELS_REQ_CX:case CMD_RCV_SEQUENCE64_CX:case CMD_RCV_ELS_REQ64_CX:case CMD_ASYNC_STATUS:case CMD_IOCB_RCV_SEQ64_CX:case CMD_IOCB_RCV_ELS64_CX:case CMD_IOCB_RCV_CONT64_CX:case CMD_IOCB_RET_XRI64_CX:break ;case CMD_IOCB_XMIT_MSEQ64_CR:case CMD_IOCB_XMIT_MSEQ64_CX:case CMD_IOCB_RCV_SEQ_LIST64_CX:case CMD_IOCB_RCV_ELS_LIST64_CX:case CMD_IOCB_CLOSE_EXTENDED_CN:case CMD_IOCB_ABORT_EXTENDED_CN:case CMD_IOCB_RET_HBQE64_CN:case CMD_IOCB_FCP_IBIDIR64_CR:case CMD_IOCB_FCP_IBIDIR64_CX:case CMD_IOCB_FCP_ITASKMGT64_CX:case CMD_IOCB_LOGENTRY_CN:case CMD_IOCB_LOGENTRY_ASYNC_CN:"%s - Unhandled SLI-3 Command x%x\n" ,break ;default :break ;return type;/** * lpfc_sli_ring_map - Issue config_ring mbox for all rings * @ phba : Pointer to HBA context object . * * This function is called from SLI initialization code * to configure every ring of the HBA ' s SLI interface . The * caller is not required to hold any lock . This function issues * a config_ring mailbox command for each ring . * This function returns zero if successful else returns a negative * error code . static int struct lpfc_hba *phba)struct lpfc_sli *psli = &phba->sli;int i, rc, ret = 0 ;if (!pmb)return -ENOMEM;for (i = 0 ; i < psli->num_rings; i++) {if (rc != MBX_SUCCESS) {"0446 Adapter failed to init (%d), " "mbxCmd x%x CFG_RING, mbxStatus x%x, " "ring %d\n" ,break ;return ret;/** * lpfc_sli_ringtxcmpl_put - Adds new iocb to the txcmplq * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ piocb : Pointer to the driver iocb object . * * The driver calls this function with the hbalock held for SLI3 ports or * the ring lock held for SLI4 ports . The function adds the * new iocb to txcmplq of the given ring . This function always returns * 0 . If this function is called for ELS ring , this function checks if * there is a vport associated with the ELS command . This function also * starts els_tmofunc timer if this is an ELS command . static int struct lpfc_hba *phba, struct lpfc_sli_ring *pring,struct lpfc_iocbq *piocb)0 ;if ((unlikely(pring->ringno == LPFC_ELS_RING)) &&if (!test_bit(FC_UNLOADING, &piocb->vport->load_flag))1 ));return 0 ;/** * lpfc_sli_ringtx_get - Get first element of the txq * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * * This function is called with hbalock held to get next * iocb in txq of the given ring . If there is any iocb in * the txq , the function returns first iocb in the list after * removing the iocb from the list , else it returns NULL . struct lpfc_iocbq *struct lpfc_hba *phba, struct lpfc_sli_ring *pring)struct lpfc_iocbq *cmd_iocb;struct lpfc_iocbq, list);return cmd_iocb;/** * lpfc_cmf_sync_cmpl - Process a CMF_SYNC_WQE cmpl * @ phba : Pointer to HBA context object . * @ cmdiocb : Pointer to driver command iocb object . * @ rspiocb : Pointer to driver response iocb object . * * This routine will inform the driver of any BW adjustments we need * to make . These changes will be picked up during the next CMF * timer interrupt . In addition , any BW changes will be logged * with LOG_CGN_MGMT . static void struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,struct lpfc_iocbq *rspiocb)union lpfc_wqe128 *wqe;struct lpfc_wcqe_complete *wcqe = &rspiocb->wcqe_cmpl;int asig, afpin, sigcnt, fpincnt;int wsigmax, wfpinmax, cg, tdp;char *s;/* First check for error */ if (status) {"6211 CMF_SYNC_WQE Error " "req_tag x%x status x%x hwstatus x%x " "tdatap x%x parm x%x\n" ,goto out;/* Gather congestion information on a successful cmpl */ /* See if firmware info count is valid or has changed */ if (info > LPFC_MAX_CMF_INFO || phba->cmf_info_per_interval == info)0 ;else /* Get BW requirement from firmware */ if (!bw) {"6212 CMF_SYNC_WQE x%x: NULL bw\n" ,goto out;/* Gather information needed for logging if a BW change is required */ if (phba->cmf_max_bytes_per_interval != bw ||/* Are we increasing or decreasing BW */ if (phba->cmf_max_bytes_per_interval < bw) {"Increase" ;else {"Decrease" ;/* What is the change percentage */ 200 ); /*For rounding*/ 100 + slop,100 + slop,/* Because of bytes adjustment due to shorter timer in * lpfc_cmf_timer ( ) the cmf_link_byte_count can be shorter and * may seem like BW is above 100 % . if (bwpcent > 100 )100 ;if (phba->cmf_max_bytes_per_interval < bw &&95 )"6208 Congestion bandwidth " "limits removed\n" );else if ((phba->cmf_max_bytes_per_interval > bw) &&100 ) && ((bwpcent + pcent) > 95 ))"6209 Congestion bandwidth " "limits in effect\n" );if (asig) {"6237 BW Threshold %lld%% (%lld): " "%lld%% %s: Signal Alarm: cg:%d " "Info:%u\n" ,else if (afpin) {"6238 BW Threshold %lld%% (%lld): " "%lld%% %s: FPIN Alarm: cg:%d " "Info:%u\n" ,else if (sigcnt) {"6239 BW Threshold %lld%% (%lld): " "%lld%% %s: Signal Warning: " "Cnt %d Max %d: cg:%d Info:%u\n" ,else if (fpincnt) {"6240 BW Threshold %lld%% (%lld): " "%lld%% %s: FPIN Warning: " "Cnt %d Max %d: cg:%d Info:%u\n" ,else {"6241 BW Threshold %lld%% (%lld): " "CMF %lld%% %s: cg:%d Info:%u\n" ,else if (info) {"6246 Info Threshold %u\n" , info);/* Save BW change to be picked up during next timer interrupt */ /** * lpfc_issue_cmf_sync_wqe - Issue a CMF_SYNC_WQE * @ phba : Pointer to HBA context object . * @ ms : ms to set in WQE interval , 0 means use init op * @ total : Total rcv bytes for this interval * * This routine is called every CMF timer interrupt . Its purpose is * to issue a CMF_SYNC_WQE to the firmware to inform it of any events * that may indicate we have congestion ( FPINs or Signals ) . Upon * completion , the firmware will indicate any BW restrictions the * driver may need to take . int struct lpfc_hba *phba, u32 ms, u64 total)union lpfc_wqe128 *wqe;struct lpfc_iocbq *sync_buf;unsigned long iflags;0 ;/* First address any alarm / warning activity */ 0 );0 );/* ONLY Managed mode will send the CMF_SYNC_WQE to the HBA */ if (phba->cmf_active_mode != LPFC_CFG_MANAGED ||0 ;goto out_unlock;if (!sync_buf) {"6244 No available WQEs for CMF_SYNC_WQE\n" );goto out_unlock;/* WQEs are reused. Clear stale data and set key fields to zero */ 0 , sizeof (*wqe));/* If this is the very first CMF_SYNC_WQE, issue an init operation */ if (!ms) {"6441 CMF Init %d - CMF_SYNC_WQE\n" ,1 ); /* 1=init */ goto initpath;0 ); /* 0=recalc */ /* Check for alarms / warnings */ if (atot) {if (phba->cgn_reg_signal == EDC_CG_SIG_WARN_ALARM) {/* We hit an Signal alarm condition */ 1 );else {/* We hit a FPIN alarm condition */ 1 );else if (wtot) {if (phba->cgn_reg_signal == EDC_CG_SIG_WARN_ONLY ||/* We hit an Signal warning condition */ else {/* We hit a FPIN warning condition */ 1 );1 );if (phba->cgn_fpin_frequency != LPFC_FPIN_INIT_FREQ)/* Update total read blocks during previous timer interval */ /* Setup reqtag to match the wqe completion. */ 1 );1 );0 ], sync_buf);if (ret_val) {"6214 Cannot issue CMF_SYNC_WQE: x%x\n" ,return ret_val;/** * lpfc_sli_next_iocb_slot - Get next iocb slot in the ring * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * * This function is called with hbalock held and the caller must post the * iocb without releasing the lock . If the caller releases the lock , * iocb slot returned by the function is not guaranteed to be available . * The function returns pointer to the next available iocb slot if there * is available slot in the ring , else it returns NULL . * If the get index of the ring is ahead of the put index , the function * will post an error attention event to the worker thread to take the * HBA to offline state . static IOCB_t *struct lpfc_hba *phba, struct lpfc_sli_ring *pring)struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];if ((pring->sli.sli3.next_cmdidx == pring->sli.sli3.cmdidx) &&0 ;if (unlikely(pring->sli.sli3.local_getidx ==if (unlikely(pring->sli.sli3.local_getidx >= max_cmd_idx)) {"0315 Ring %d issue: portCmdGet %d " "is bigger than cmd ring %d\n" ,/* * All error attention handlers are posted to * worker thread return NULL;if (pring->sli.sli3.local_getidx == pring->sli.sli3.next_cmdidx)return NULL;return lpfc_cmd_iocb(phba, pring);/** * lpfc_sli_next_iotag - Get an iotag for the iocb * @ phba : Pointer to HBA context object . * @ iocbq : Pointer to driver iocb object . * * This function gets an iotag for the iocb . If there is no unused iotag and * the iocbq_lookup_len < 0 xffff , this function allocates a bigger iotag_lookup * array and assigns a new iotag . * The function returns the allocated iotag if successful , else returns zero . * Zero is not a valid iotag . * The caller is not required to hold any lock . struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)struct lpfc_iocbq **new_arr;struct lpfc_iocbq **old_arr;struct lpfc_sli *psli = &phba->sli;if (++iotag < psli->iocbq_lookup_len) {return iotag;else if (psli->iocbq_lookup_len < (0 xffffsizeof (struct lpfc_iocbq *),if (new_arr) {if (new_len <= psli->iocbq_lookup_len) {/* highly unprobable case */ if (++iotag < psli->iocbq_lookup_len) {return iotag;return 0 ;if (psli->iocbq_lookup)1 ) *sizeof (struct lpfc_iocbq *)));return iotag;else "0318 Failed to allocate IOTAG.last IOTAG is %d\n" ,return 0 ;/** * lpfc_sli_submit_iocb - Submit an iocb to the firmware * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ iocb : Pointer to iocb slot in the ring . * @ nextiocb : Pointer to driver iocb object which need to be * posted to firmware . * * This function is called to post a new iocb to the firmware . This * function copies the new iocb to ring iocb slot and updates the * ring pointers . It adds the new iocb to txcmplq if there is * a completion call back for this iocb else the function will free the * iocb object . The hbalock is asserted held in the code path calling * this routine . static void struct lpfc_hba *phba, struct lpfc_sli_ring *pring,struct lpfc_iocbq *nextiocb)/* * Set up an iotag 0 ;if (pring->ringno == LPFC_ELS_RING) {"IOCB cmd ring: wd4:x%08x wd6:x%08x wd7:x%08x" ,4 ),6 ),7 ));/* * Issue iocb command to adapter /* * If there is no completion routine to call , we can release the * IOCB buffer back right now . For IOCBs , like QUE_RING_BUF , * that have no rsp ring completion , cmd_cmpl MUST be NULL . if (nextiocb->cmd_cmpl)else /* * Let the HBA know what IOCB slot will be the next one the * driver will put a command into . /** * lpfc_sli_update_full_ring - Update the chip attention register * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * * The caller is not required to hold any lock for calling this function . * This function updates the chip attention bits for the ring to inform firmware * that there are pending work to be done for this ring and requests an * interrupt when there is space available in the ring . This function is * called when the driver is unable to post more iocbs to the ring due * to unavailability of space in the ring . static void struct lpfc_hba *phba, struct lpfc_sli_ring *pring)int ringno = pring->ringno;/* * Set ring ' ringno ' to SET R0CE_REQ in Chip Att register . * The HBA will tell us when an IOCB entry is available . 4 ), phba->CAregaddr);/* flush */ /** * lpfc_sli_update_ring - Update chip attention register * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * * This function updates the chip attention register bit for the * given ring to inform HBA that there is more work to be done * in this ring . The caller is not required to hold any lock . static void struct lpfc_hba *phba, struct lpfc_sli_ring *pring)int ringno = pring->ringno;/* * Tell the HBA that there is work to do in this ring . if (!(phba->sli3_options & LPFC_SLI3_CRP_ENABLED)) {4 ), phba->CAregaddr);/* flush */ /** * lpfc_sli_resume_iocb - Process iocbs in the txq * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * * This function is called with hbalock held to post pending iocbs * in the txq to the firmware . This function is called when driver * detects space available in the ring . static void struct lpfc_hba *phba, struct lpfc_sli_ring *pring)struct lpfc_iocbq *nextiocb;/* * Check to see if : * ( a ) there is anything on the txq to send * ( b ) link is up * ( c ) link attention events can be processed ( fcp ring only ) * ( d ) IOCB processing is not blocked by the outstanding mbox command . if (lpfc_is_link_up(phba) &&while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&if (iocb)else return ;/** * lpfc_sli_next_hbq_slot - Get next hbq entry for the HBQ * @ phba : Pointer to HBA context object . * @ hbqno : HBQ number . * * This function is called with hbalock held to get the next * available slot for the given HBQ . If there is free slot * available for the HBQ it will return pointer to the next available * HBQ entry else it will return NULL . static struct lpfc_hbq_entry *struct lpfc_hba *phba, uint32_t hbqno)struct hbq_s *hbqp = &phba->hbqs[hbqno];if (hbqp->next_hbqPutIdx == hbqp->hbqPutIdx &&0 ;if (unlikely(hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)) {if (unlikely(hbqp->local_hbqGetIdx >= hbqp->entry_count)) {"1802 HBQ %d: local_hbqGetIdx " "%u is > than hbqp->entry_count %u\n" ,return NULL;if (hbqp->local_hbqGetIdx == hbqp->next_hbqPutIdx)return NULL;return (struct lpfc_hbq_entry *) phba->hbqs[hbqno].hbq_virt +/** * lpfc_sli_hbqbuf_free_all - Free all the hbq buffers * @ phba : Pointer to HBA context object . * * This function is called with no lock held to free all the * hbq buffers while uninitializing the SLI interface . It also * frees the HBQ buffers returned by the firmware but not yet * processed by the upper layers . void struct lpfc_hba *phba)struct lpfc_dmabuf *dmabuf, *next_dmabuf;struct hbq_dmabuf *hbq_buf;unsigned long flags;int i, hbq_count;/* Return all memory used by all HBQs */ for (i = 0 ; i < hbq_count; ++i) {struct hbq_dmabuf, dbuf);0 ;/* Mark the HBQs not in use */ 0 ;/** * lpfc_sli_hbq_to_firmware - Post the hbq buffer to firmware * @ phba : Pointer to HBA context object . * @ hbqno : HBQ number . * @ hbq_buf : Pointer to HBQ buffer . * * This function is called with the hbalock held to post a * hbq buffer to the firmware . If the function finds an empty * slot in the HBQ , it will post the buffer . The function will return * pointer to the hbq entry if it successfully post the buffer * else it will return NULL . static int struct lpfc_hba *phba, uint32_t hbqno,struct hbq_dmabuf *hbq_buf)return phba->lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buf);/** * lpfc_sli_hbq_to_firmware_s3 - Post the hbq buffer to SLI3 firmware * @ phba : Pointer to HBA context object . * @ hbqno : HBQ number . * @ hbq_buf : Pointer to HBQ buffer . * * This function is called with the hbalock held to post a hbq buffer to the * firmware . If the function finds an empty slot in the HBQ , it will post the * buffer and place it on the hbq_buffer_list . The function will return zero if * it successfully post the buffer else it will return an error . static int struct lpfc_hba *phba, uint32_t hbqno,struct hbq_dmabuf *hbq_buf)struct lpfc_hbq_entry *hbqe;/* Get next HBQ entry slot to use */ if (hbqe) {struct hbq_s *hbqp = &phba->hbqs[hbqno];0 ;/* Sync SLIM */ /* flush */ return 0 ;else return -ENOMEM;/** * lpfc_sli_hbq_to_firmware_s4 - Post the hbq buffer to SLI4 firmware * @ phba : Pointer to HBA context object . * @ hbqno : HBQ number . * @ hbq_buf : Pointer to HBQ buffer . * * This function is called with the hbalock held to post an RQE to the SLI4 * firmware . If able to post the RQE to the RQ it will queue the hbq entry to * the hbq_buffer_list and return zero , otherwise it will return an error . static int struct lpfc_hba *phba, uint32_t hbqno,struct hbq_dmabuf *hbq_buf)int rc;struct lpfc_rqe hrqe;struct lpfc_rqe drqe;struct lpfc_queue *hrq;struct lpfc_queue *drq;if (hbqno != LPFC_ELS_HBQ)return 1 ;if (rc < 0 )return rc;16 ));return 0 ;/* HBQ for ELS and CT traffic. */ static struct lpfc_hbq_init lpfc_els_hbq = {1 ,256 ,0 ,0 ,1 << LPFC_ELS_RING),0 ,40 ,40 ,/* Array of HBQs */ struct lpfc_hbq_init *lpfc_hbq_defs[] = {/** * lpfc_sli_hbqbuf_fill_hbqs - Post more hbq buffers to HBQ * @ phba : Pointer to HBA context object . * @ hbqno : HBQ number . * @ count : Number of HBQ buffers to be posted . * * This function is called with no lock held to post more hbq buffers to the * given HBQ . The function returns the number of HBQ buffers successfully * posted . static int struct lpfc_hba *phba, uint32_t hbqno, uint32_t count)0 ;unsigned long flags;struct hbq_dmabuf *hbq_buffer;if (!phba->hbqs[hbqno].hbq_alloc_buffer)return 0 ;if ((phba->hbqs[hbqno].buffer_count + count) >if (!count)return 0 ;/* Allocate HBQ entries */ for (i = 0 ; i < count; i++) {if (!hbq_buffer)break ;/* Check whether HBQ is still in use */ if (!phba->hbq_in_use)goto err;while (!list_empty(&hbq_buf_list)) {struct hbq_dmabuf,16 ));if (!lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer)) {else return posted;while (!list_empty(&hbq_buf_list)) {struct hbq_dmabuf,return 0 ;/** * lpfc_sli_hbqbuf_add_hbqs - Post more HBQ buffers to firmware * @ phba : Pointer to HBA context object . * @ qno : HBQ number . * * This function posts more buffers to the HBQ . This function * is called with no lock held . The function returns the number of HBQ entries * successfully allocated . int struct lpfc_hba *phba, uint32_t qno)if (phba->sli_rev == LPFC_SLI_REV4)return 0 ;else return lpfc_sli_hbqbuf_fill_hbqs(phba, qno,/** * lpfc_sli_hbqbuf_init_hbqs - Post initial buffers to the HBQ * @ phba : Pointer to HBA context object . * @ qno : HBQ queue number . * * This function is called from SLI initialization code path with * no lock held to post initial HBQ buffers to firmware . The * function returns the number of HBQ entries successfully allocated . static int struct lpfc_hba *phba, uint32_t qno)if (phba->sli_rev == LPFC_SLI_REV4)return lpfc_sli_hbqbuf_fill_hbqs(phba, qno,else return lpfc_sli_hbqbuf_fill_hbqs(phba, qno,/* * lpfc_sli_hbqbuf_get - Remove the first hbq off of an hbq list * * This function removes the first hbq buffer on an hbq list and returns a * pointer to that buffer . If it finds no buffers on the list it returns NULL . static struct hbq_dmabuf *struct list_head *rb_list)struct lpfc_dmabuf *d_buf;struct lpfc_dmabuf, list);if (!d_buf)return NULL;return container_of(d_buf, struct hbq_dmabuf, dbuf);/** * lpfc_sli_rqbuf_get - Remove the first dma buffer off of an RQ list * @ phba : Pointer to HBA context object . * @ hrq : HBQ number . * * This function removes the first RQ buffer on an RQ buffer list and returns a * pointer to that buffer . If it finds no buffers on the list it returns NULL . static struct rqb_dmabuf *struct lpfc_hba *phba, struct lpfc_queue *hrq)struct lpfc_dmabuf *h_buf;struct lpfc_rqb *rqbp;struct lpfc_dmabuf, list);if (!h_buf)return NULL;return container_of(h_buf, struct rqb_dmabuf, hbuf);/** * lpfc_sli_hbqbuf_find - Find the hbq buffer associated with a tag * @ phba : Pointer to HBA context object . * @ tag : Tag of the hbq buffer . * * This function searches for the hbq buffer associated with the given tag in * the hbq buffer list . If it finds the hbq buffer , it returns the hbq_buffer * otherwise it returns NULL . static struct hbq_dmabuf *struct lpfc_hba *phba, uint32_t tag)struct lpfc_dmabuf *d_buf;struct hbq_dmabuf *hbq_buf;16 ;if (hbqno >= LPFC_MAX_HBQS)return NULL;struct hbq_dmabuf, dbuf);if (hbq_buf->tag == tag) {return hbq_buf;"1803 Bad hbq tag. Data: x%x x%x\n" ,16 ].buffer_count);return NULL;/** * lpfc_sli_free_hbq - Give back the hbq buffer to firmware * @ phba : Pointer to HBA context object . * @ hbq_buffer : Pointer to HBQ buffer . * * This function is called with hbalock . This function gives back * the hbq buffer to firmware . If the HBQ does not have space to * post the buffer , it will free the buffer . void struct lpfc_hba *phba, struct hbq_dmabuf *hbq_buffer)if (hbq_buffer) {16 ;if (lpfc_sli_hbq_to_firmware(phba, hbqno, hbq_buffer))/** * lpfc_sli_chk_mbx_command - Check if the mailbox is a legitimate mailbox * @ mbxCommand : mailbox command code . * * This function is called by the mailbox event handler function to verify * that the completed mailbox command is a legitimate mailbox command . If the * completed mailbox is not known to the function , it will return MBX_SHUTDOWN * and the mailbox event handler will take the HBA offline . static int switch (mbxCommand) {case MBX_LOAD_SM:case MBX_READ_NV:case MBX_WRITE_NV:case MBX_WRITE_VPARMS:case MBX_RUN_BIU_DIAG:case MBX_INIT_LINK:case MBX_DOWN_LINK:case MBX_CONFIG_LINK:case MBX_CONFIG_RING:case MBX_RESET_RING:case MBX_READ_CONFIG:case MBX_READ_RCONFIG:case MBX_READ_SPARM:case MBX_READ_STATUS:case MBX_READ_RPI:case MBX_READ_XRI:case MBX_READ_REV:case MBX_READ_LNK_STAT:case MBX_REG_LOGIN:case MBX_UNREG_LOGIN:case MBX_CLEAR_LA:case MBX_DUMP_MEMORY:case MBX_DUMP_CONTEXT:case MBX_RUN_DIAGS:case MBX_RESTART:case MBX_UPDATE_CFG:case MBX_DOWN_LOAD:case MBX_DEL_LD_ENTRY:case MBX_RUN_PROGRAM:case MBX_SET_MASK:case MBX_SET_VARIABLE:case MBX_UNREG_D_ID:case MBX_KILL_BOARD:case MBX_CONFIG_FARP:case MBX_BEACON:case MBX_LOAD_AREA:case MBX_RUN_BIU_DIAG64:case MBX_CONFIG_PORT:case MBX_READ_SPARM64:case MBX_READ_RPI64:case MBX_REG_LOGIN64:case MBX_READ_TOPOLOGY:case MBX_WRITE_WWN:case MBX_SET_DEBUG:case MBX_LOAD_EXP_ROM:case MBX_ASYNCEVT_ENABLE:case MBX_REG_VPI:case MBX_UNREG_VPI:case MBX_HEARTBEAT:case MBX_PORT_CAPABILITIES:case MBX_PORT_IOV_CONTROL:case MBX_SLI4_CONFIG:case MBX_SLI4_REQ_FTRS:case MBX_REG_FCFI:case MBX_UNREG_FCFI:case MBX_REG_VFI:case MBX_UNREG_VFI:case MBX_INIT_VPI:case MBX_INIT_VFI:case MBX_RESUME_RPI:case MBX_READ_EVENT_LOG_STATUS:case MBX_READ_EVENT_LOG:case MBX_SECURITY_MGMT:case MBX_AUTH_PORT:case MBX_ACCESS_VDATA:break ;default :break ;return ret;/** * lpfc_sli_wake_mbox_wait - lpfc_sli_issue_mbox_wait mbox completion handler * @ phba : Pointer to HBA context object . * @ pmboxq : Pointer to mailbox command . * * This is completion handler function for mailbox commands issued from * lpfc_sli_issue_mbox_wait function . This function is called by the * mailbox event handler function with no lock held . This function * will wake up thread waiting on the wait queue pointed by context1 * of the mailbox . void struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)unsigned long drvr_flag;struct completion *pmbox_done;/* * If pmbox_done is empty , the driver thread gave up waiting and * continued running . if (pmbox_done)return ;/** * lpfc_sli_def_mbox_cmpl - Default mailbox completion handler * @ phba : Pointer to HBA context object . * @ pmb : Pointer to mailbox object . * * This function is the default mailbox completion handler . It * frees the memory resources associated with the completed mailbox * command . If the completed command is a REG_LOGIN mailbox command , * this function will issue a UREG_LOGIN to re - claim the RPI . void struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)struct lpfc_vport *vport = pmb->vport;struct lpfc_dmabuf *mp;struct lpfc_nodelist *ndlp;struct Scsi_Host *shost;int rc;/* * If a REG_LOGIN succeeded after node is destroyed or node * is in re - discovery driver need to cleanup the RPI . if (!test_bit(FC_UNLOADING, &phba->pport->load_flag) &&if (mp) {0 ];if (phba->sli_rev == LPFC_SLI_REV4)if (rc != MBX_NOT_FINISHED)return ;if ((pmb->u.mb.mbxCommand == MBX_REG_VPI) &&if (pmb->u.mb.mbxCommand == MBX_REG_LOGIN64) {if (pmb->u.mb.mbxCommand == MBX_UNREG_LOGIN) {/* Check to see if there are any deferred events to process */ if (ndlp) {"1438 UNREG cmpl deferred mbox x%x " "on NPort x%x Data: x%lx x%x x%px x%lx x%x\n" ,if (test_bit(NLP_UNREG_INP, &ndlp->nlp_flag) &&0 );else {/* The unreg_login mailbox is complete and had a * reference that has to be released . The PLOGI * got its own ref . /* This nlp_put pairs with lpfc_sli4_resume_rpi */ if (pmb->u.mb.mbxCommand == MBX_RESUME_RPI) {/* Check security permission status on INIT_LINK mailbox command */ if ((pmb->u.mb.mbxCommand == MBX_INIT_LINK) &&"2860 SLI authentication is required " "for INIT_LINK but has not done yet\n" );if (bf_get(lpfc_mqe_command, &pmb->u.mqe) == MBX_SLI4_CONFIG)else /** * lpfc_sli4_unreg_rpi_cmpl_clr - mailbox completion handler * @ phba : Pointer to HBA context object . * @ pmb : Pointer to mailbox object . * * This function is the unreg rpi mailbox completion handler . It * frees the memory resources associated with the completed mailbox * command . An additional reference is put on the ndlp to prevent * lpfc_nlp_release from freeing the rpi bit in the bitmask before * the unreg mailbox command completes , this routine puts the * reference back . * void struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)struct lpfc_vport *vport = pmb->vport;struct lpfc_nodelist *ndlp;bool unreg_inp;if (pmb->u.mb.mbxCommand == MBX_UNREG_LOGIN) {if (phba->sli_rev == LPFC_SLI_REV4 &&if (ndlp) {"0010 UNREG_LOGIN vpi:x%x " "rpi:%x DID:%x defer x%x flg x%lx " "x%px\n" ,/* Cleanup the nlp_flag now that the UNREG RPI * has completed . /* Check to see if there are any deferred * events to process if (unreg_inp &&"4111 UNREG cmpl deferred " "clr x%x on " "NPort x%x Data: x%x x%px\n" ,0 );/** * lpfc_sli_handle_mb_event - Handle mailbox completions from firmware * @ phba : Pointer to HBA context object . * * This function is called with no lock held . This function processes all * the completed mailbox commands and gives it to upper layers . The interrupt * service routine processes mailbox completion interrupt and adds completed * mailbox commands to the mboxq_cmpl queue and signals the worker thread . * Worker thread call lpfc_sli_handle_mb_event , which will return the * completed mailbox commands in mboxq_cmpl queue to the upper layers . This * function returns the mailbox commands to the upper layer by calling the * completion handler function of each mailbox . int struct lpfc_hba *phba)int rc;/* Get all completed mailboxe buffers into the cmplq */ /* Get a Mailbox buffer to setup mailbox commands for callback */ do {if (pmb == NULL)break ;if (pmbox->mbxCommand != MBX_HEARTBEAT) {if (pmb->vport) {"MBOX cmpl vport: cmd:x%x mb:x%x x%x" ,0 ],1 ]);else {"MBOX cmpl: cmd:x%x mb:x%x x%x" ,0 ],1 ]);/* * It is a fatal error if unknown mbox command completion . if (lpfc_sli_chk_mbx_command(pmbox->mbxCommand) ==/* Unknown mailbox command compl */ "(%d):0323 Unknown Mailbox command " "x%x (x%x/x%x) Cmpl\n" ,continue ;if (pmbox->mbxStatus) {if (pmbox->mbxStatus == MBXERR_NO_RESOURCES) {/* Mbox cmd cmpl error - RETRYing */ "(%d):0305 Mbox cmd cmpl " "error - RETRYing Data: x%x " "(x%x/x%x) x%x x%x x%x\n" ,0 ],0 ;if (rc != MBX_NOT_FINISHED)continue ;/* Mailbox cmd <cmd> Cmpl <cmpl> */ "(%d):0307 Mailbox cmd x%x (x%x/x%x) Cmpl %ps " "Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x " "x%x x%x x%x\n" ,0 ,0 ],1 ],2 ],3 ],4 ],5 ],6 ],7 ],8 ],9 ],10 ]);if (pmb->mbox_cmpl)while (1 );return 0 ;/** * lpfc_sli_get_buff - Get the buffer associated with the buffer tag * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ tag : buffer tag . * * This function is called with no lock held . When QUE_BUFTAG_BIT bit * is set in the tag the buffer is posted for a particular exchange , * the function will return the buffer without replacing the buffer . * If the buffer is for unsolicited ELS or CT traffic , this function * returns the buffer and also posts another buffer to the firmware . static struct lpfc_dmabuf *struct lpfc_hba *phba,struct lpfc_sli_ring *pring,struct hbq_dmabuf *hbq_entry;if (tag & QUE_BUFTAG_BIT)return lpfc_sli_ring_taggedbuf_get(phba, pring, tag);if (!hbq_entry)return NULL;return &hbq_entry->dbuf;/** * lpfc_nvme_unsol_ls_handler - Process an unsolicited event data buffer * containing a NVME LS request . * @ phba : pointer to lpfc hba data structure . * @ piocb : pointer to the iocbq struct representing the sequence starting * frame . * * This routine initially validates the NVME LS , validates there is a login * with the port that sent the LS , and then calls the appropriate nvme host * or target LS request handler . static void struct lpfc_hba *phba, struct lpfc_iocbq *piocb)struct lpfc_nodelist *ndlp;struct lpfc_dmabuf *d_buf;struct hbq_dmabuf *nvmebuf;struct fc_frame_header *fc_hdr;struct lpfc_async_xchg_ctx *axchg = NULL;char *failwhy = NULL;int ret = 1 ;struct hbq_dmabuf, dbuf);0 ] << 16 |1 ] << 8 |2 ]);"NVME LS RCV: xri x%x sz %d from %06x\n" ,if (test_bit(FC_UNLOADING, &phba->pport->load_flag)) {"Driver Unloading" ;else if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)) {"NVME FC4 Disabled" ;else if (!phba->nvmet_support && !phba->pport->localport) {"No Localport" ;else if (phba->nvmet_support && !phba->targetport) {"No Targetport" ;else if (unlikely(fc_hdr->fh_r_ctl != FC_RCTL_ELS4_REQ)) {"Bad NVME LS R_CTL" ;else if (unlikely((fctl & 0 x00FF0000) !="Bad NVME LS F_CTL" ;else {sizeof (*axchg), GFP_ATOMIC);if (!axchg)"No CTX memory" ;if (unlikely(failwhy)) {"6154 Drop NVME LS: SID %06X OXID x%X: %s\n" ,goto out_fail;/* validate the source of the LS is logged in */ if (!ndlp ||"6216 NVME Unsol rcv: No ndlp: " "NPort_ID x%x oxid x%x\n" ,goto out_fail;1 ;void *)nvmebuf;0 ];if (phba->nvmet_support) {if (!ret && !(ndlp->fc4_xpt_flags & NLP_XPT_HAS_HH)) {/* This reference is a single occurrence to hold the * node valid until the nvmet transport calls * host_release . if (!lpfc_nlp_get(ndlp))goto out_fail;"6206 NVMET unsol ls_req ndlp x%px " "DID x%x xflags x%x refcnt %d\n" ,else {else {/* if zero, LS was successfully handled. If non-zero, LS not handled */ if (!ret)return ;"6155 Drop NVME LS from DID %06X: SID %06X OXID x%X " "NVMe%s handler failed %d\n" ,"T" : "I" , ret);/* recycle receive buffer */ /* If start of new exchange, abort it */ if (axchg && (fctl & FC_FC_FIRST_SEQ && !(fctl & FC_FC_EX_CTX)))if (ret)/** * lpfc_complete_unsol_iocb - Complete an unsolicited sequence * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ saveq : Pointer to the iocbq struct representing the sequence starting frame . * @ fch_r_ctl : the r_ctl for the first frame of the sequence . * @ fch_type : the type for the first frame of the sequence . * * This function is called with no lock held . This function uses the r_ctl and * type of the received sequence to find the correct callback function to call * to process the sequence . static int struct lpfc_hba *phba, struct lpfc_sli_ring *pring,struct lpfc_iocbq *saveq, uint32_t fch_r_ctl,int i;switch (fch_type) {case FC_TYPE_NVME:return 1 ;default :break ;/* unSolicited Responses */ if (pring->prt[0 ].profile) {if (pring->prt[0 ].lpfc_sli_rcv_unsol_event)0 ].lpfc_sli_rcv_unsol_event) (phba, pring,return 1 ;/* We must search, based on rctl / type for (i = 0 ; i < pring->num_mask; i++) {if ((pring->prt[i].rctl == fch_r_ctl) &&if (pring->prt[i].lpfc_sli_rcv_unsol_event)return 1 ;return 0 ;static void struct lpfc_hba *phba,struct lpfc_iocbq *saveq)union lpfc_wqe128 *wqe;0 ;/* Fill wcqe with the IOCB status fields */ 4 ];/* Source ID */ /* rx-id of the response frame */ /* ox-id of the frame */ /* DID */ /* unsol data len */ for (i = 0 ; i < irsp->ulpBdeCount; i++) {struct lpfc_hbq_entry *hbqe = NULL;if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {if (i == 0 ) {struct lpfc_hbq_entry *)0 ];else if (i == 1 ) {struct lpfc_hbq_entry *)4 ];/** * lpfc_sli_process_unsol_iocb - Unsolicited iocb handler * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ saveq : Pointer to the unsolicited iocb . * * This function is called with no lock held by the ring event handler * when there is an unsolicited iocb posted to the response ring by the * firmware . This function gets the buffer associated with the iocbs * and calls the event handler for the ring . This function handles both * qring buffers and hbq buffers . * When the function returns 1 the caller can free the iocb object otherwise * upper layer functions will free the iocb objects . static int struct lpfc_hba *phba, struct lpfc_sli_ring *pring,struct lpfc_iocbq *saveq)struct lpfc_iocbq *iocbq;struct lpfc_dmabuf *dmzbuf;if (irsp->ulpCommand == CMD_ASYNC_STATUS) {if (pring->lpfc_sli_rcv_async_status)else "0316 Ring %d handler: unexpected " "ASYNC_STATUS iocb received evt_code " "0x%x\n" ,return 1 ;if ((irsp->ulpCommand == CMD_IOCB_RET_XRI64_CX) &&if (irsp->ulpBdeCount > 0 ) {3 ]);if (irsp->ulpBdeCount > 1 ) {3 ]);if (irsp->ulpBdeCount > 2 ) {7 ]);return 1 ;if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {if (irsp->ulpBdeCount != 0 ) {3 ]);if (!saveq->cmd_dmabuf)"0341 Ring %d Cannot find buffer for " "an unsolicited iocb. tag 0x%x\n" ,3 ]);if (irsp->ulpBdeCount == 2 ) {7 ]);if (!saveq->bpl_dmabuf)"0342 Ring %d Cannot find buffer for an" " unsolicited iocb. tag 0x%x\n" ,7 ]);if (irsp->ulpBdeCount != 0 ) {3 ]);if (!iocbq->cmd_dmabuf)"0343 Ring %d Cannot find " "buffer for an unsolicited iocb" ". tag 0x%x\n" , pring->ringno,3 ]);if (irsp->ulpBdeCount == 2 ) {7 ]);if (!iocbq->bpl_dmabuf)"0344 Ring %d Cannot find " "buffer for an unsolicited " "iocb. tag 0x%x\n" ,7 ]);else {0 ].addrHigh,0 ].addrLow);if (irsp->ulpBdeCount == 2 ) {1 ].addrHigh,1 ].addrLow);if (irsp->ulpBdeCount != 0 &&int found = 0 ;/* search continue save q for same XRI */ if (iocbq->iocb.unsli3.rcvsli3.ox_id ==1 ;break ;if (!found)if (saveq->iocb.ulpStatus != IOSTAT_INTERMED_RSP) {else {return 0 ;if ((irsp->ulpCommand == CMD_RCV_ELS_REQ64_CX) ||else {5 ]);/* Firmware Workaround */ if ((Rctl == 0 ) && (pring->ringno == LPFC_ELS_RING) &&if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&if (irsp->unsli3.rcvsli3.vpi == 0 xffff)else /* Prepare WQE with Unsol frame */ if (!lpfc_complete_unsol_iocb(phba, pring, saveq, Rctl, Type))"0313 Ring %d handler: unexpected Rctl x%x " "Type x%x received\n" ,return 1 ;/** * lpfc_sli_iocbq_lookup - Find command iocb for the given response iocb * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ prspiocb : Pointer to response iocb object . * * This function looks up the iocb_lookup table to get the command iocb * corresponding to the given response iocb using the iotag of the * response iocb . The driver calls this function with the hbalock held * for SLI3 ports or the ring lock held for SLI4 ports . * This function returns the command iocb object if it finds the command * iocb else returns NULL . static struct lpfc_iocbq *struct lpfc_hba *phba,struct lpfc_sli_ring *pring,struct lpfc_iocbq *prspiocb)struct lpfc_iocbq *cmd_iocb = NULL;if (phba->sli_rev == LPFC_SLI_REV4)else if (iotag != 0 && iotag <= phba->sli.last_iotag) {if (cmd_iocb->cmd_flag & LPFC_IO_ON_TXCMPLQ) {/* remove from txcmpl queue list */ return cmd_iocb;"0317 iotag x%x is out of " "range: max iotag x%x\n" ,return NULL;/** * lpfc_sli_iocbq_lookup_by_tag - Find command iocb for the iotag * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ iotag : IOCB tag . * * This function looks up the iocb_lookup table to get the command iocb * corresponding to the given iotag . The driver calls this function with * the ring lock held because this function is an SLI4 port only helper . * This function returns the command iocb object if it finds the command * iocb else returns NULL . static struct lpfc_iocbq *struct lpfc_hba *phba,struct lpfc_sli_ring *pring, uint16_t iotag)struct lpfc_iocbq *cmd_iocb = NULL;if (iotag != 0 && iotag <= phba->sli.last_iotag) {if (cmd_iocb->cmd_flag & LPFC_IO_ON_TXCMPLQ) {/* remove from txcmpl queue list */ return cmd_iocb;"0372 iotag x%x lookup error: max iotag (x%x) " "cmd_flag x%x\n" ,0 xffff);return NULL;/** * lpfc_sli_process_sol_iocb - process solicited iocb completion * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ saveq : Pointer to the response iocb to be processed . * * This function is called by the ring event handler for non - fcp * rings when there is a new response iocb in the response ring . * The caller is not required to hold any locks . This function * gets the command iocb associated with the response iocb and * calls the completion handler for the command iocb . If there * is no completion handler , the function will free the resources * associated with command iocb . If the response iocb is for * an already aborted command iocb , the status of the completion * is changed to IOSTAT_LOCAL_REJECT / IOERR_SLI_ABORTED . * This function always returns 1 . static int struct lpfc_hba *phba, struct lpfc_sli_ring *pring,struct lpfc_iocbq *saveq)struct lpfc_iocbq *cmdiocbp;unsigned long iflag;if (phba->sli_rev == LPFC_SLI_REV4)else if (phba->sli_rev == LPFC_SLI_REV4)else if (phba->sli_rev == LPFC_SLI_REV4)else if (cmdiocbp) {if (cmdiocbp->cmd_cmpl) {/* * If an ELS command failed send an event to mgmt * application . if (ulp_status &&/* * Post all ELS completions to the worker thread . * All other are passed to the completion callback . if (pring->ringno == LPFC_ELS_RING) {if ((phba->sli_rev < LPFC_SLI_REV4) &&4 ] =/* Firmware could still be in progress * of DMAing payload , so don ' t free data * buffer till after a hbeat . if (phba->sli_rev == LPFC_SLI_REV4) {if (saveq->cmd_flag &/* Set cmdiocb flag for the * exchange busy so sgl ( xri ) * will not be released until * the abort xri is received * from hba . if (cmdiocbp->cmd_flag &/* * Clear LPFC_DRIVER_ABORTED * bit in case it was driver * initiated abort . /* * For SLI4 , irspiocb contains * NO_XRI in sli_xritag , it * shall not affect releasing * sgl ( xri ) process . else else {/* * Unknown initiating command based on the response iotag . * This could be the case on the ELS ring because of * lpfc_els_abort ( ) . if (pring->ringno != LPFC_ELS_RING) {/* * Ring < ringno > handler : unexpected completion IoTag * < IoTag > "0322 Ring %d handler: " "unexpected completion IoTag x%x " "Data: x%x x%x x%x x%x\n" ,return 1 ;/** * lpfc_sli_rsp_pointers_error - Response ring pointer error handler * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * * This function is called from the iocb ring event handlers when * put pointer is ahead of the get pointer for a ring . This function signal * an error attention condition to the worker thread and the worker * thread will transition the HBA to offline state . static void struct lpfc_hba *phba, struct lpfc_sli_ring *pring)struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];/* * Ring < ringno > handler : portRspPut < portRspPut > is bigger than * rsp ring < portRspMax > "0312 Ring %d handler: portRspPut %d " "is bigger than rsp ring %d\n" ,/* * All error attention handlers are posted to * worker thread return ;/** * lpfc_poll_eratt - Error attention polling timer timeout handler * @ t : Context to fetch pointer to address of HBA context object from . * * This function is invoked by the Error Attention polling timer when the * timer times out . It will check the SLI Error Attention register for * possible attention events . If so , it will post an Error Attention event * and wake up worker thread to process it . Otherwise , it will set up the * Error Attention polling timer for the next poll . void lpfc_poll_eratt(struct timer_list *t)struct lpfc_hba *phba;0 ;if (test_bit(FC_UNLOADING, &phba->pport->load_flag))return ;if (phba->sli_rev == LPFC_SLI_REV4 &&"0663 HBA still initializing 0x%lx, restart " "timer\n" ,goto restart_timer;/* Here we will also keep track of interrupts per sec of the hba */ if (phba->sli.slistat.sli_prev_intr > sli_intr)1 ) - phba->sli.slistat.sli_prev_intr) +else /* 64-bit integer division not supported on 32-bit x86 - use do_div */ /* Check chip HA register for error event */ if (eratt) {/* Tell the worker thread there is work to do */ return ;/* Restart the timer for next eratt poll */ return ;/** * lpfc_sli_handle_fast_ring_event - Handle ring events on FCP ring * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ mask : Host attention register mask for this ring . * * This function is called from the interrupt context when there is a ring * event for the fcp ring . The caller does not hold any lock . * The function processes each response iocb in the response ring until it * finds an iocb with LE bit set and chains all the iocbs up to the iocb with * LE bit set . The function will call the completion handler of the command iocb * if the response iocb indicates a completion for a command iocb or it is * an abort completion . The function will call lpfc_sli_process_unsol_iocb * function if this is an unsolicited iocb . * This routine presumes LPFC_FCP_RING handling and doesn ' t bother * to check it explicitly . int struct lpfc_hba *phba,struct lpfc_sli_ring *pring, uint32_t mask)struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];struct lpfc_iocbq *cmdiocbq = NULL;struct lpfc_iocbq rspiocbq;int rc = 1 ;unsigned long iflag;0 ;/* * The next available response entry should never exceed the maximum * entries . If it does , treat it as an adapter hardware error . if (unlikely(portRspPut >= portRspMax)) {return 1 ;if (phba->fcp_ring_in_use) {return 1 ;else 1 ;while (pring->sli.sli3.rspidx != portRspPut) {/* * Fetch an entry off the ring and copy it into a local data * structure . The copy involves a byte - swap since the * network byte order and pci byte orders are different . if (++pring->sli.sli3.rspidx >= portRspMax)0 ;if (unlikely(irsp->ulpStatus)) {/* * If resource errors reported from HBA , reduce * queuedepths of the SCSI device . if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&4 ] & IOERR_PARAM_MASK) ==/* Rsp ring <ringno> error: IOCB */ "0336 Rsp Ring %d error: IOCB Data: " "x%x x%x x%x x%x x%x x%x x%x x%x\n" ,0 ],1 ],2 ],3 ],4 ],5 ],1 ));switch (type) {case LPFC_ABORT_IOCB:case LPFC_SOL_IOCB:/* * Idle exchange closed via ABTS from port . No iocb * resources need to be recovered . if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {"0333 IOCB cmd 0x%x" " processed. Skipping" " completion\n" ,break ;if (unlikely(!cmdiocbq))break ;if (cmdiocbq->cmd_flag & LPFC_DRIVER_ABORTED)if (cmdiocbq->cmd_cmpl) {break ;case LPFC_UNSOL_IOCB:break ;default :if (irsp->ulpCommand == CMD_ADAPTER_MSG) {char adaptermsg[LPFC_MAX_ADPTMSG];0 , LPFC_MAX_ADPTMSG);0 ], (uint8_t *) irsp,"lpfc%d: %s\n" ,else {/* Unknown IOCB command */ "0334 Unknown IOCB command " "Data: x%x, x%x x%x x%x x%x\n" ,break ;/* * The response IOCB has been processed . Update the ring * pointer in SLIM . If the port response put pointer has not * been updated , sync the pgp - > rspPutInx and fetch the new port * response put pointer . if (pring->sli.sli3.rspidx == portRspPut)if ((rsp_cmpl > 0 ) && (mask & HA_R0RE_REQ)) {4 ));if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {/* Force update of the local copy of cmdGetInx */ if ((pring->lpfc_sli_cmd_available))0 ;return rc;/** * lpfc_sli_sp_handle_rspiocb - Handle slow - path response iocb * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ rspiocbp : Pointer to driver response IOCB object . * * This function is called from the worker thread when there is a slow - path * response IOCB to process . This function chains all the response iocbs until * seeing the iocb with the LE bit set . The function will call * lpfc_sli_process_sol_iocb function if the response iocb indicates a * completion of a command iocb . The function will call the * lpfc_sli_process_unsol_iocb function if this is an unsolicited iocb . * The function frees the resources or calls the completion handler if this * iocb is an abort completion . The function returns NULL when the response * iocb has the LE bit set and all the chained iocbs are processed , otherwise * this function shall chain the iocb on to the iocb_continueq and return the * response iocb passed in . static struct lpfc_iocbq *struct lpfc_hba *phba, struct lpfc_sli_ring *pring,struct lpfc_iocbq *rspiocbp)struct lpfc_iocbq *saveq;struct lpfc_iocbq *cmdiocb;struct lpfc_iocbq *next_iocb;unsigned long iflag;int rc;/* First add the response iocb to the countinueq list */ /* * By default , the driver expects to free all resources * associated with this iocb completion . 1 ;struct lpfc_iocbq, list);0 ;/* * If resource errors reported from HBA , reduce * queuedepths of the SCSI device . if (ulp_status == IOSTAT_LOCAL_REJECT &&if (ulp_status) {/* Rsp ring <ringno> error: IOCB */ if (phba->sli_rev < LPFC_SLI_REV4) {"0328 Rsp Ring %d error: ulp_status x%x " "IOCB Data: " "x%08x x%08x x%08x x%08x " "x%08x x%08x x%08x x%08x " "x%08x x%08x x%08x x%08x " "x%08x x%08x x%08x x%08x\n" ,0 ),1 ),2 ),3 ),4 ),5 ),6 ),7 ),8 ),9 ),10 ),11 ),12 ),13 ),14 ),15 ));else {"0321 Rsp Ring %d error: " "IOCB Data: " "x%x x%x x%x x%x\n" ,/* * Fetch the iocb command type and call the correct completion * routine . Solicited and Unsolicited IOCBs on the ELS ring * get freed back to the lpfc_iocb_list by the discovery * kernel thread . switch (type) {case LPFC_SOL_IOCB:break ;case LPFC_UNSOL_IOCB:if (!rc)0 ;break ;case LPFC_ABORT_IOCB:if (ulp_command != CMD_XRI_ABORTED_CX)if (cmdiocb) {/* Call the specified completion routine */ if (cmdiocb->cmd_cmpl) {else {break ;case LPFC_UNKNOWN_IOCB:if (ulp_command == CMD_ADAPTER_MSG) {char adaptermsg[LPFC_MAX_ADPTMSG];0 , LPFC_MAX_ADPTMSG);0 ], (uint8_t *)&rspiocbp->wqe,"lpfc%d: %s\n" ,else {/* Unknown command */ "0335 Unknown IOCB " "command Data: x%x " "x%x x%x x%x\n" ,break ;if (free_saveq) {return rspiocbp;/** * lpfc_sli_handle_slow_ring_event - Wrapper func for handling slow - path iocbs * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ mask : Host attention register mask for this ring . * * This routine wraps the actual slow_ring event process routine from the * API jump table function pointer from the lpfc_hba struct . void struct lpfc_hba *phba,struct lpfc_sli_ring *pring, uint32_t mask)/** * lpfc_sli_handle_slow_ring_event_s3 - Handle SLI3 ring event for non - FCP rings * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ mask : Host attention register mask for this ring . * * This function is called from the worker thread when there is a ring event * for non - fcp rings . The caller does not hold any lock . The function will * remove each response iocb in the response ring and calls the handle * response iocb routine ( lpfc_sli_sp_handle_rspiocb ) to process it . static void struct lpfc_hba *phba,struct lpfc_sli_ring *pring, uint32_t mask)struct lpfc_pgp *pgp;struct lpfc_iocbq *rspiocbp = NULL;unsigned long iflag;/* * The next available response entry should never exceed the maximum * entries . If it does , treat it as an adapter hardware error . if (portRspPut >= portRspMax) {/* * Ring < ringno > handler : portRspPut < portRspPut > is bigger than * rsp ring < portRspMax > "0303 Ring %d handler: portRspPut %d " "is bigger than rsp ring %d\n" ,return ;while (pring->sli.sli3.rspidx != portRspPut) {/* * Build a completion list and call the appropriate handler . * The process is to get the next available response iocb , get * a free iocb from the list , copy the response data into the * free iocb , insert to the continuation list , and update the * next response index to slim . This process makes response * iocb ' s in the ring available to DMA as fast as possible but * pays a penalty for a copy operation . Since the iocb is * only 32 bytes , this penalty is considered small relative to * the PCI reads for register values and a slim write . When * the ulpLe field is set , the entire Command has been * received . if (rspiocbp == NULL) {"%s: out of buffers! Failing " "completion.\n" , __func__);break ;if (++pring->sli.sli3.rspidx >= portRspMax)0 ;if (pring->ringno == LPFC_ELS_RING) {"IOCB rsp ring: wd4:x%08x wd6:x%08x wd7:x%08x" ,4 ),6 ),7 ));/* Handle the response IOCB */ /* * If the port response put pointer has not been updated , sync * the pgp - > rspPutInx in the MAILBOX_tand fetch the new port * response put pointer . if (pring->sli.sli3.rspidx == portRspPut) {/* while (pring->sli.sli3.rspidx != portRspPut) */ if ((rspiocbp != NULL) && (mask & HA_R0RE_REQ)) {/* At least one response entry has been freed */ /* SET RxRE_RSP in Chip Att register */ 4 ));/* flush */ if ((mask & HA_R0CE_RSP) && (pring->flag & LPFC_CALL_RING_AVAILABLE)) {/* Force update of the local copy of cmdGetInx */ if ((pring->lpfc_sli_cmd_available))return ;/** * lpfc_sli_handle_slow_ring_event_s4 - Handle SLI4 slow - path els events * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ mask : Host attention register mask for this ring . * * This function is called from the worker thread when there is a pending * ELS response iocb on the driver internal slow - path response iocb worker * queue . The caller does not hold any lock . The function will remove each * response iocb from the response worker queue and calls the handle * response iocb routine ( lpfc_sli_sp_handle_rspiocb ) to process it . static void struct lpfc_hba *phba,struct lpfc_sli_ring *pring, uint32_t mask)struct lpfc_iocbq *irspiocbq;struct hbq_dmabuf *dmabuf;struct lpfc_cq_event *cq_event;unsigned long iflag;int count = 0 ;while (!list_empty(&phba->sli4_hba.sp_queue_event)) {/* Get the response iocb from the head of work queue */ struct lpfc_cq_event, list);switch (bf_get(lpfc_wcqe_c_code, &cq_event->cqe.wcqe_cmpl)) {case CQE_CODE_COMPL_WQE:struct lpfc_iocbq,/* Translate ELS WCQE to response IOCBQ */ if (irspiocbq)break ;case CQE_CODE_RECEIVE:case CQE_CODE_RECEIVE_V1:struct hbq_dmabuf,break ;default :break ;/* Limit the number of events to 64 to avoid soft lockups */ if (count == 64 )break ;/** * lpfc_sli_abort_iocb_ring - Abort all iocbs in the ring * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * * This function aborts all iocbs in the given ring and frees all the iocb * objects in txq . This function issues an abort iocb for all the iocb commands * in txcmplq . The iocbs in the txcmplq is not guaranteed to complete before * the return of this function . The caller is not required to hold any locks . void struct lpfc_hba *phba, struct lpfc_sli_ring *pring)struct lpfc_iocbq *iocb, *next_iocb;int offline;if (pring->ringno == LPFC_ELS_RING) {/* Error everything on txq and txcmplq * First do the txq . if (phba->sli_rev >= LPFC_SLI_REV4) {0 ;if (offline) {else {/* Next issue ABTS for everything on the txcmplq */ else {0 ;if (offline) {else {/* Next issue ABTS for everything on the txcmplq */ if (offline) {/* Cancel all the IOCBs from the completions list */ else {/* Make sure HBA is alive */ /* Cancel all the IOCBs from the completions list */ /** * lpfc_sli_abort_fcp_rings - Abort all iocbs in all FCP rings * @ phba : Pointer to HBA context object . * * This function aborts all iocbs in FCP rings and frees all the iocb * objects in txq . This function issues an abort iocb for all the iocb commands * in txcmplq . The iocbs in the txcmplq is not guaranteed to complete before * the return of this function . The caller is not required to hold any locks . void struct lpfc_hba *phba)struct lpfc_sli *psli = &phba->sli;struct lpfc_sli_ring *pring;/* Look on all the FCP Rings for the iotag */ if (phba->sli_rev >= LPFC_SLI_REV4) {for (i = 0 ; i < phba->cfg_hdw_queue; i++) {else {/** * lpfc_sli_flush_io_rings - flush all iocbs in the IO ring * @ phba : Pointer to HBA context object . * * This function flushes all iocbs in the IO ring and frees all the iocb * objects in txq and txcmplq . This function will not issue abort iocbs * for all the iocb commands in txcmplq , they will just be returned with * IOERR_SLI_DOWN . This function is invoked with EEH when device ' s PCI * slot has been permanently disabled . void struct lpfc_hba *phba)struct lpfc_sli *psli = &phba->sli;struct lpfc_sli_ring *pring;struct lpfc_iocbq *piocb, *next_iocb;/* Indicate the I/O queues are flushed */ /* Look on all the FCP Rings for the iotag */ if (phba->sli_rev >= LPFC_SLI_REV4) {for (i = 0 ; i < phba->cfg_hdw_queue; i++) {if (!phba->sli4_hba.hdwq ||"7777 hdwq's deleted %lx " "%lx %x %x\n" ,return ;/* Retrieve everything on txq */ /* Retrieve everything on the txcmplq */ 0 ;0 ;/* Flush the txq */ /* Flush the txcmplq */ if (unlikely(pci_channel_offline(phba->pcidev)))0 );else {/* Retrieve everything on txq */ /* Retrieve everything on the txcmplq */ 0 ;0 ;/* Flush the txq */ /* Flush the txcmpq */ /** * lpfc_sli_brdready_s3 - Check for sli3 host ready status * @ phba : Pointer to HBA context object . * @ mask : Bit mask to be checked . * * This function reads the host status register and compares * with the provided bit mask to check if HBA completed * the restart . This function will wait in a loop for the * HBA to complete restart . If the HBA does not restart within * 15 iterations , the function will reset the HBA again . The * function returns 1 when HBA fail to restart otherwise returns * zero . static int struct lpfc_hba *phba, uint32_t mask)int i = 0 ;int retval = 0 ;/* Read the HBA Host Status Register */ if (lpfc_readl(phba->HSregaddr, &status))return 1 ;/* * Check status register every 100 ms for 5 retries , then every * 500 ms for 5 , then every 2 . 5 sec for 5 , then reset board and * every 2 . 5 sec for 4 . * Break our of the loop if errors occurred during init . while (((status & mask) != mask) &&20 ) {if (i <= 5 )10 );else if (i <= 10 )500 );else 2500 );if (i == 15 ) {/* Do post */ /* Read the HBA Host Status Register */ if (lpfc_readl(phba->HSregaddr, &status)) {1 ;break ;/* Check to see if any errors occurred during init */ if ((status & HS_FFERM) || (i >= 20 )) {"2751 Adapter failed to restart, " "status reg x%x, FW Data: A8 x%x AC x%x\n" ,0 xa8),0 xac));1 ;return retval;/** * lpfc_sli_brdready_s4 - Check for sli4 host ready status * @ phba : Pointer to HBA context object . * @ mask : Bit mask to be checked . * * This function checks the host status register to check if HBA is * ready . This function will wait in a loop for the HBA to be ready * If the HBA is not ready , the function will will reset the HBA PCI * function again . The function returns 1 when HBA fail to be ready * otherwise returns zero . static int struct lpfc_hba *phba, uint32_t mask)int retval = 0 ;/* Read the HBA Host Status Register */ if (status) {/* Check to see if any errors occurred during init */ if (status) {1 ;else 0 ;return retval;/** * lpfc_sli_brdready - Wrapper func for checking the hba readyness * @ phba : Pointer to HBA context object . * @ mask : Bit mask to be checked . * * This routine wraps the actual SLI3 or SLI4 hba readyness check routine * from the API jump table function pointer from the lpfc_hba struct . int struct lpfc_hba *phba, uint32_t mask)return phba->lpfc_sli_brdready(phba, mask);#define BARRIER_TEST_PATTERN (0 xdeadbeef)/** * lpfc_reset_barrier - Make HBA ready for HBA reset * @ phba : Pointer to HBA context object . * * This function is called before resetting an HBA . This function is called * with hbalock held and requests HBA to quiesce DMAs before a reset . void lpfc_reset_barrier(struct lpfc_hba *phba)volatile struct MAILBOX_word0 mbox;int i;if (hdrtype != PCI_HEADER_TYPE_MFD ||return ;/* * Tell the other part of the chip to suspend temporarily all * its DMA activity . /* Disable the error attention */ if (lpfc_readl(phba->HCregaddr, &hc_copy))return ;/* flush */ if (lpfc_readl(phba->HAregaddr, &ha_copy))return ;if (ha_copy & HA_ERATT) {/* Clear Chip error bit */ 1 ;0 ;1 ));for (i = 0 ; i < 50 ; i++) {if (lpfc_readl((resp_buf + 1 ), &resp_data))return ;if (resp_data != ~(BARRIER_TEST_PATTERN))1 );else break ;0 ;if (lpfc_readl((resp_buf + 1 ), &resp_data))return ;if (resp_data != ~(BARRIER_TEST_PATTERN)) {if (phba->sli.sli_flag & LPFC_SLI_ACTIVE ||goto restore_hc;else goto clear_errat;0 ;for (i = 0 ; i < 500 ; i++) {if (lpfc_readl(resp_buf, &resp_data))return ;if (resp_data != mbox.word0)1 );else break ;while (++i < 500 ) {if (lpfc_readl(phba->HAregaddr, &ha_copy))return ;if (!(ha_copy & HA_ERATT))1 );else break ;if (readl(phba->HAregaddr) & HA_ERATT) {1 ;/* flush */ /** * lpfc_sli_brdkill - Issue a kill_board mailbox command * @ phba : Pointer to HBA context object . * * This function issues a kill_board mailbox command and waits for * the error attention interrupt . This function is called for stopping * the firmware processing . The caller is not required to hold any * locks . This function calls lpfc_hba_down_post function to free * any pending commands after the kill . The function will return 1 when it * fails to kill the board else will return 0 . int struct lpfc_hba *phba)struct lpfc_sli *psli;int retval;int i = 0 ;/* Kill HBA */ "0329 Kill HBA Data: x%x x%x\n" ,if (!pmb)return 1 ;/* Disable the error attention */ if (lpfc_readl(phba->HCregaddr, &status)) {return 1 ;/* flush */ if (retval != MBX_SUCCESS) {if (retval != MBX_BUSY)"2752 KILL_BOARD command failed retval %d\n" ,return 1 ;/* There is no completion for a KILL_BOARD mbox cmd. Check for an error * attention every 100 ms for 3 seconds . If we don ' t get ERATT after * 3 seconds we still set HBA_ERROR state because the status of the * board is now undefined . if (lpfc_readl(phba->HAregaddr, &ha_copy))return 1 ;while ((i++ < 30 ) && !(ha_copy & HA_ERATT)) {100 );if (lpfc_readl(phba->HAregaddr, &ha_copy))return 1 ;if (ha_copy & HA_ERATT) {1 ;return ha_copy & HA_ERATT ? 0 : 1 ;/** * lpfc_sli_brdreset - Reset a sli - 2 or sli - 3 HBA * @ phba : Pointer to HBA context object . * * This function resets the HBA by writing HC_INITFF to the control * register . After the HBA resets , this function resets all the iocb ring * indices . This function disables PCI layer parity checking during * the reset . * This function returns 0 always . * The caller is not required to hold any locks . int struct lpfc_hba *phba)struct lpfc_sli *psli;struct lpfc_sli_ring *pring;int i;/* Reset HBA */ "0325 Reset HBA Data: x%x x%x\n" ,0 ,/* perform board reset */ 0 ;0 ;if (phba->pport) {0 ;0 ;/* Turn off parity checking and serr during the physical reset */ if (pci_read_config_word(phba->pcidev, PCI_COMMAND, &cfg_value))return -EIO;/* Now toggle INITFF bit in the Host Control Register */ 1 );/* flush */ 0 , phba->HCregaddr);/* flush */ /* Restore PCI cmd register */ /* Initialize relevant SLI info */ for (i = 0 ; i < psli->num_rings; i++) {0 ;0 ;0 ;0 ;0 ;0 ;return 0 ;/** * lpfc_sli4_brdreset - Reset a sli - 4 HBA * @ phba : Pointer to HBA context object . * * This function resets a SLI4 HBA . This function disables PCI layer parity * checking during resets the device . The caller is not required to hold * any locks . * * This function returns 0 on success else returns negative error code . int struct lpfc_hba *phba)struct lpfc_sli *psli = &phba->sli;int rc = 0 ;/* Reset HBA */ "0295 Reset HBA Data: x%x x%x x%lx\n" ,/* perform board reset */ 0 ;0 ;0 ;0 ;0 ;/* Now physically reset the device */ "0389 Performing PCI function reset!\n" );/* Turn off parity checking and serr during the physical reset */ if (pci_read_config_word(phba->pcidev, PCI_COMMAND, &cfg_value)) {"3205 PCI read Config failed\n" );return -EIO;/* Perform FCoE PCI function reset before freeing queue memory */ /* Restore PCI cmd register */ return rc;/** * lpfc_sli_brdrestart_s3 - Restart a sli - 3 hba * @ phba : Pointer to HBA context object . * * This function is called in the SLI initialization code path to * restart the HBA . The caller is not required to hold any lock . * This function writes MBX_RESTART mailbox command to the SLIM and * resets the HBA . At the end of the function , it calls lpfc_hba_down_post * function to free any pending commands . The function enables * POST only during the first initialization . The function returns zero . * The function does not guarantee completion of MBX_RESTART mailbox * command before the return of this function . static int struct lpfc_hba *phba)volatile struct MAILBOX_word0 mb;struct lpfc_sli *psli;void __iomem *to_slim;/* Restart HBA */ "0337 Restart HBA Data: x%x x%x\n" ,0 ,0 ;1 ;/* flush */ /* Only skip post after fc_ffinit is completed */ if (phba->pport && phba->pport->port_state)1 ; /* This is really setting up word1 */ else 0 ; /* This is really setting up word1 */ sizeof (uint32_t);/* flush */ if (phba->pport)0 ;0 ;0 , sizeof (psli->lnk_stat_offsets));/* Give the INITFF and Post time to settle. */ 100 );return 0 ;/** * lpfc_sli_brdrestart_s4 - Restart the sli - 4 hba * @ phba : Pointer to HBA context object . * * This function is called in the SLI initialization code path to restart * a SLI4 HBA . The caller is not required to hold any lock . * At the end of the function , it calls lpfc_hba_down_post function to * free any pending commands . static int struct lpfc_hba *phba)struct lpfc_sli *psli = &phba->sli;int rc;/* Restart HBA */ "0296 Restart HBA Data: x%x x%x\n" ,if (rc) {goto hba_down_queue;0 ;0 ;/* Preserve FA-PWWN expectation */ 0 , sizeof (psli->lnk_stat_offsets));return rc;/** * lpfc_sli_brdrestart - Wrapper func for restarting hba * @ phba : Pointer to HBA context object . * * This routine wraps the actual SLI3 or SLI4 hba restart routine from the * API jump table function pointer from the lpfc_hba struct . int struct lpfc_hba *phba)return phba->lpfc_sli_brdrestart(phba);/** * lpfc_sli_chipset_init - Wait for the restart of the HBA after a restart * @ phba : Pointer to HBA context object . * * This function is called after a HBA restart to wait for successful * restart of the HBA . Successful restart of the HBA is indicated by * HS_FFRDY and HS_MBRDY bits . If the HBA fails to restart even after 15 * iteration , the function will restart the HBA again . The function returns * zero if HBA successfully restarted else returns negative error code . int struct lpfc_hba *phba)0 ;/* Read the HBA Host Status Register */ if (lpfc_readl(phba->HSregaddr, &status))return -EIO;/* Check status register to see what current state is */ 0 ;while ((status & (HS_FFRDY | HS_MBRDY)) != (HS_FFRDY | HS_MBRDY)) {/* Check every 10ms for 10 retries, then every 100ms for 90 * retries , then every 1 sec for 50 retires for a total of * ~ 60 seconds before reset the board again and check every * 1 sec for 50 retries . The up to 60 seconds before the * board ready is required by the Falcon FIPS zeroization * complete , and any reset the board in between shall cause * restart of zeroization , further delay the board ready . if (i++ >= 200 ) {/* Adapter failed to init, timeout, status reg "0436 Adapter failed to init, " "timeout, status reg x%x, " "FW Data: A8 x%x AC x%x\n" , status,0 xa8),0 xac));return -ETIMEDOUT;/* Check to see if any errors occurred during init */ if (status & HS_FFERM) {/* ERROR: During chipset initialization */ /* Adapter failed to init, chipset, status reg "0437 Adapter failed to init, " "chipset, status reg x%x, " "FW Data: A8 x%x AC x%x\n" , status,0 xa8),0 xac));return -EIO;if (i <= 10 )10 );else if (i <= 100 )100 );else 1000 );if (i == 150 ) {/* Do post */ /* Read the HBA Host Status Register */ if (lpfc_readl(phba->HSregaddr, &status))return -EIO;/* Check to see if any errors occurred during init */ if (status & HS_FFERM) {/* ERROR: During chipset initialization */ /* Adapter failed to init, chipset, status reg <status> */ "0438 Adapter failed to init, chipset, " "status reg x%x, " "FW Data: A8 x%x AC x%x\n" , status,0 xa8),0 xac));return -EIO;/* Clear all interrupt enable conditions */ 0 , phba->HCregaddr);/* flush */ /* setup host attn register */ 0 xffffffff, phba->HAregaddr);/* flush */ return 0 ;/** * lpfc_sli_hbq_count - Get the number of HBQs to be configured * * This function calculates and returns the number of HBQs required to be * configured . int void )return ARRAY_SIZE(lpfc_hbq_defs);/** * lpfc_sli_hbq_entry_count - Calculate total number of hbq entries * * This function adds the number of hbq entries in every HBQ to get * the total number of hbq entries required for the HBA and returns * the total count . static int void )int hbq_count = lpfc_sli_hbq_count();int count = 0 ;int i;for (i = 0 ; i < hbq_count; ++i)return count;/** * lpfc_sli_hbq_size - Calculate memory required for all hbq entries * * This function calculates amount of memory required for all hbq entries * to be configured and returns the total memory required . int void )return lpfc_sli_hbq_entry_count() * sizeof (struct lpfc_hbq_entry);/** * lpfc_sli_hbq_setup - configure and initialize HBQs * @ phba : Pointer to HBA context object . * * This function is called during the SLI initialization to configure * all the HBQs and post buffers to the HBQ . The caller is not * required to hold any locks . This function will return zero if successful * else it will return negative error code . static int struct lpfc_hba *phba)int hbq_count = lpfc_sli_hbq_count();/* Get a Mailbox buffer to setup mailbox * commands for HBA initialization if (!pmb)return -ENOMEM;/* Initialize the struct lpfc_sli_hbq structure for each hbq */ 1 ;0 ;for (hbqno = 0 ; hbqno < hbq_count; ++hbqno) {0 ;0 ;0 ;if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {/* Adapter failed to init, mbxCmd <cmd> CFG_RING, "1805 Adapter failed to init. " "Data: x%x x%x x%x\n" ,return -ENXIO;/* Initially populate or replenish the HBQs */ for (hbqno = 0 ; hbqno < hbq_count; ++hbqno)return 0 ;/** * lpfc_sli4_rb_setup - Initialize and post RBs to HBA * @ phba : Pointer to HBA context object . * * This function is called during the SLI initialization to configure * all the HBQs and post buffers to the HBQ . The caller is not * required to hold any locks . This function will return zero if successful * else it will return negative error code . static int struct lpfc_hba *phba)1 ;/** * Specific case when the MDS diagnostics is enabled and supported . * The receive buffer count is truncated to manage the incoming * traffic . if (phba->cfg_enable_mds_diags && phba->mds_diags_support)1 ;else 1 ;/* Initially populate or replenish the HBQs */ return 0 ;/** * lpfc_sli_config_port - Issue config port mailbox command * @ phba : Pointer to HBA context object . * @ sli_mode : sli mode - 2 / 3 * * This function is called by the sli initialization code path * to issue config_port mailbox command . This function restarts the * HBA firmware and issues a config_port mailbox command to configure * the SLI interface in the sli mode specified by sli_mode * variable . The caller is not required to hold any locks . * The function returns 0 if successful , else returns negative error * code . int struct lpfc_hba *phba, int sli_mode)0 , rc = 0 , done = 0 ;if (!pmb) {return -ENOMEM;while (resetcount < 2 && !done) {if (rc)break ;/* Call pre CONFIG_PORT mailbox command initialization. A * value of 0 means the call was successful . Any other * nonzero value is a failure , but if ERESTART is returned , * the driver may reset the HBA and try again . if (rc == -ERESTART) {continue ;else if (rc)break ;if (rc != MBX_SUCCESS) {"0442 Adapter failed to init, mbxCmd x%x " "CONFIG_PORT, mbxStatus x%x Data: x%x\n" ,0 );else {/* Allow asynchronous mailbox command to go through */ 1 ;if ((pmb->u.mb.un.varCfgPort.casabt == 1 ) &&0 ))"3110 Port did not grant ASABT\n" );if (!done) {goto do_prep_failed;if (pmb->u.mb.un.varCfgPort.sli_mode == 3 ) {if (!pmb->u.mb.un.varCfgPort.cMA) {goto do_prep_failed;if (phba->max_vpi && pmb->u.mb.un.varCfgPort.gmv) {else 0 ;if (pmb->u.mb.un.varCfgPort.gerbm)if (pmb->u.mb.un.varCfgPort.gcrp)if (phba->sli3_options & LPFC_SLI3_BG_ENABLED) {if (pmb->u.mb.un.varCfgPort.gbg == 0 ) {0 ;"0443 Adapter did not grant " "BlockGuard\n" );else {0 ;return rc;/** * lpfc_sli_hba_setup - SLI initialization function * @ phba : Pointer to HBA context object . * * This function is the main SLI initialization function . This function * is called by the HBA initialization code , HBA reset code and HBA * error attention handler code . Caller is not required to hold any * locks . This function issues config_port mailbox command to configure * the SLI , setup iocb rings and HBQ rings . In the end the function * calls the config_port_post function to issue init_link mailbox * command and to start the discovery . The function will return zero * if successful , else it will return negative error code . int struct lpfc_hba *phba)int i;int longs;/* Enable ISR already does config_port because of config_msi mbx */ if (test_bit(HBA_NEEDS_CFG_PORT, &phba->hba_flag)) {if (rc)return -EIO;0 ; /* SLI4 FC support only */ if (phba->sli_rev == 3 ) {else {0 ;"0444 Firmware in SLI %x mode. Max_vpi %d\n" ,if (rc)goto lpfc_sli_hba_setup_error;/* Initialize VPIs. */ if (phba->sli_rev == LPFC_SLI_REV3) {/* * The VPI bitmask and physical ID array are allocated * and initialized once only - at driver load . A port * reset doesn ' t need to reinitialize this memory . if ((phba->vpi_bmask == NULL) && (phba->vpi_ids == NULL)) {sizeof (unsigned long ),if (!phba->vpi_bmask) {goto lpfc_sli_hba_setup_error;1 ,sizeof (uint16_t),if (!phba->vpi_ids) {goto lpfc_sli_hba_setup_error;for (i = 0 ; i < phba->max_vpi; i++)/* Init HBQs */ if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {if (rc)goto lpfc_sli_hba_setup_error;if (rc)goto lpfc_sli_hba_setup_error;return rc;"0445 Firmware initialization failed\n" );return rc;/** * lpfc_sli4_read_fcoe_params - Read fcoe params from conf region * @ phba : Pointer to HBA context object . * * This function issue a dump mailbox command to read config region * 23 and parse the records in the region and populate driver * data structure . static int struct lpfc_hba *phba)struct lpfc_dmabuf *mp;struct lpfc_mqe *mqe;int rc;/* Program the default value of vlan_id and fc_map */ 0 ;0 ] = LPFC_FCOE_FCF_MAP0;1 ] = LPFC_FCOE_FCF_MAP1;2 ] = LPFC_FCOE_FCF_MAP2;if (!mboxq)return -ENOMEM;if (lpfc_sli4_dump_cfg_rg23(phba, mboxq)) {goto out_free_mboxq;"(%d):2571 Mailbox cmd x%x Status x%x " "Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x " "x%x x%x x%x x%x x%x x%x x%x x%x x%x " "CQ: x%x x%x x%x x%x\n" ,0 ,0 ], mqe->un.mb_words[1 ],2 ], mqe->un.mb_words[3 ],4 ], mqe->un.mb_words[5 ],6 ], mqe->un.mb_words[7 ],8 ], mqe->un.mb_words[9 ],10 ], mqe->un.mb_words[11 ],12 ], mqe->un.mb_words[13 ],14 ], mqe->un.mb_words[15 ],16 ], mqe->un.mb_words[50 ],if (rc) {goto out_free_mboxq;5 ];if (data_length > DMP_RGN23_SIZE) {goto out_free_mboxq;0 ;return rc;/** * lpfc_sli4_read_rev - Issue READ_REV and collect vpd data * @ phba : pointer to lpfc hba data structure . * @ mboxq : pointer to the LPFC_MBOXQ_t structure . * @ vpd : pointer to the memory to hold resulting port vpd data . * @ vpd_size : On input , the number of bytes allocated to @ vpd . * On output , the number of data bytes in @ vpd . * * This routine executes a READ_REV SLI4 mailbox command . In * addition , this routine gets the port vpd data . * * Return codes * 0 - successful * - ENOMEM - could not allocated memory . static int struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq,int rc = 0 ;struct lpfc_dmabuf *dmabuf;struct lpfc_mqe *mqe;sizeof (struct lpfc_dmabuf), GFP_KERNEL);if (!dmabuf)return -ENOMEM;/* * Get a DMA buffer for the vpd data resulting from the READ_REV * mailbox command . if (!dmabuf->virt) {return -ENOMEM;/* * The SLI4 implementation of READ_REV conflicts at word1 , * bits 31 : 16 and SLI4 adds vpd functionality not present * in SLI3 . This code corrects the conflicts . 0 x0000FFFF;1 );if (rc) {return -EIO;/* * The available vpd length cannot be bigger than the * DMA buffer passed to the port . Catch the less than * case and update the caller ' s size . if (mqe->un.read_rev.avail_vpd_len < *vpd_size)return 0 ;/** * lpfc_sli4_get_ctl_attr - Retrieve SLI4 device controller attributes * @ phba : pointer to lpfc hba data structure . * * This routine retrieves SLI4 device physical port name this PCI function * is attached to . * * Return codes * 0 - successful * otherwise - failed to retrieve controller attributes static int struct lpfc_hba *phba)struct lpfc_mbx_get_cntl_attributes *mbx_cntl_attr;struct lpfc_controller_attribute *cntl_attr;void *virtaddr = NULL;union lpfc_sli4_cfg_shdr *shdr;int rc;if (!mboxq)return -ENOMEM;/* Send COMMON_GET_CNTL_ATTRIBUTES mbox cmd */ sizeof (struct lpfc_mbx_get_cntl_attributes);if (alloclen < reqlen) {"3084 Allocated DMA memory size (%d) is " "less than the requested DMA memory size " "(%d)\n" , alloclen, reqlen);goto out_free_mboxq;0 ];struct lpfc_mbx_get_cntl_attributes *)virtaddr;if (shdr_status || shdr_add_status || rc) {"3085 Mailbox x%x (x%x/x%x) failed, " "rc:x%x, status:x%x, add_status:x%x\n" ,goto out_free_mboxq;sizeof (phba->BIOSVersion));sizeof (phba->BIOSVersion) - 1 ] = '\0' ;"3086 lnk_type:%d, lnk_numb:%d, bios_ver:%s, " "flash_id: x%02x, asic_rev: x%02x\n" ,if (bf_get(lpfc_mqe_command, &mboxq->u.mqe) == MBX_SLI4_CONFIG)else return rc;/** * lpfc_sli4_retrieve_pport_name - Retrieve SLI4 device physical port name * @ phba : pointer to lpfc hba data structure . * * This routine retrieves SLI4 device physical port name this PCI function * is attached to . * * Return codes * 0 - successful * otherwise - failed to retrieve physical port name static int struct lpfc_hba *phba)struct lpfc_mbx_get_port_name *get_port_name;union lpfc_sli4_cfg_shdr *shdr;char cport_name = 0 ;int rc;/* We assume nothing at this point */ if (!mboxq)return -ENOMEM;/* obtain link type and link number via READ_CONFIG */ if (phba->sli4_hba.fawwpn_flag & LPFC_FAWWPN_CONFIG)if (phba->sli4_hba.lnk_info.lnk_dv == LPFC_LNK_DAT_VAL)goto retrieve_ppname;/* obtain link type and link number via COMMON_GET_CNTL_ATTRIBUTES */ if (rc)goto out_free_mboxq;sizeof (struct lpfc_mbx_get_port_name) -sizeof (struct lpfc_sli4_cfg_mhdr),union lpfc_sli4_cfg_shdr *)&get_port_name->header.cfg_shdr;if (shdr_status || shdr_add_status || rc) {"3087 Mailbox x%x (x%x/x%x) failed: " "rc:x%x, status:x%x, add_status:x%x\n" ,goto out_free_mboxq;switch (phba->sli4_hba.lnk_info.lnk_no) {case LPFC_LINK_NUMBER_0:break ;case LPFC_LINK_NUMBER_1:break ;case LPFC_LINK_NUMBER_2:break ;case LPFC_LINK_NUMBER_3:break ;default :break ;if (phba->sli4_hba.pport_name_sta == LPFC_SLI4_PPNAME_GET) {0 ] = cport_name;1 ] = '\0' ;"3091 SLI get port name: %s\n" , phba->Port);if (bf_get(lpfc_mqe_command, &mboxq->u.mqe) == MBX_SLI4_CONFIG)else return rc;/** * lpfc_sli4_arm_cqeq_intr - Arm sli - 4 device completion and event queues * @ phba : pointer to lpfc hba data structure . * * This routine is called to explicitly arm the SLI4 device ' s completion and * event queues static void struct lpfc_hba *phba)int qidx;struct lpfc_sli4_hba *sli4_hba = &phba->sli4_hba;struct lpfc_sli4_hdw_queue *qp;struct lpfc_queue *eq;0 , LPFC_QUEUE_REARM);0 , LPFC_QUEUE_REARM);if (sli4_hba->nvmels_cq)0 ,if (sli4_hba->hdwq) {/* Loop thru all Hardware Queues */ for (qidx = 0 ; qidx < phba->cfg_hdw_queue; qidx++) {/* ARM the corresponding CQ */ 0 ,/* Loop thru all IRQ vectors */ for (qidx = 0 ; qidx < phba->cfg_irq_chann; qidx++) {/* ARM the corresponding EQ */ 0 , LPFC_QUEUE_REARM);if (phba->nvmet_support) {for (qidx = 0 ; qidx < phba->cfg_nvmet_mrq; qidx++) {0 ,/** * lpfc_sli4_get_avail_extnt_rsrc - Get available resource extent count . * @ phba : Pointer to HBA context object . * @ type : The resource extent type . * @ extnt_count : buffer to hold port available extent count . * @ extnt_size : buffer to hold element count per extent . * * This function calls the port and retrievs the number of available * extents and their size for a particular extent type . * * Returns : 0 if successful . Nonzero otherwise . int struct lpfc_hba *phba, uint16_t type,int rc = 0 ;struct lpfc_mbx_get_rsrc_extent_info *rsrc_info;0 ;0 ;if (!mbox)return -ENOMEM;/* Find out how many extents are available for this resource type */ sizeof (struct lpfc_mbx_get_rsrc_extent_info) -sizeof (struct lpfc_sli4_cfg_mhdr));/* Send an extents count of 0 - the GET doesn't use it. */ 0 , type,if (unlikely(rc)) {goto err_exit;if (!phba->sli4_hba.intr_enable)else {if (unlikely(rc)) {goto err_exit;if (bf_get(lpfc_mbox_hdr_status,"2930 Failed to get resource extents " "Status 0x%x Add'l Status 0x%x\n" ,goto err_exit;"3162 Retrieved extents type-%d from port: count:%d, " "size:%d\n" , type, *extnt_count, *extnt_size);return rc;/** * lpfc_sli4_chk_avail_extnt_rsrc - Check for available SLI4 resource extents . * @ phba : Pointer to HBA context object . * @ type : The extent type to check . * * This function reads the current available extents from the port and checks * if the extent count or extent size has changed since the last access . * Callers use this routine post port reset to understand if there is a * extent reprovisioning requirement . * * Returns : * - Error : error indicates problem . * 1 : Extent count or size has changed . * 0 : No changes . static int struct lpfc_hba *phba, uint16_t type)int rc = 0 ;struct lpfc_rsrc_blks *rsrc_entry;struct list_head *rsrc_blk_list = NULL;0 ;0 ;if (unlikely(rc))return -EIO;switch (type) {case LPFC_RSC_TYPE_FCOE_RPI:break ;case LPFC_RSC_TYPE_FCOE_VPI:break ;case LPFC_RSC_TYPE_FCOE_XRI:break ;case LPFC_RSC_TYPE_FCOE_VFI:break ;default :break ;if (rsrc_entry->rsrc_size != rsrc_ext_size)if (curr_ext_cnt != rsrc_ext_cnt || size_diff != 0 )1 ;return rc;/** * lpfc_sli4_cfg_post_extnts - * @ phba : Pointer to HBA context object . * @ extnt_cnt : number of available extents . * @ type : the extent type ( rpi , xri , vfi , vpi ) . * @ emb : buffer to hold either MBX_EMBED or MBX_NEMBED operation . * @ mbox : pointer to the caller ' s allocated mailbox structure . * * This function executes the extents allocation request . It also * takes care of the amount of memory needed to allocate or get the * allocated extents . It is the caller ' s responsibility to evaluate * the response . * * Returns : * - Error : Error value describes the condition found . * 0 : if successful static int struct lpfc_hba *phba, uint16_t extnt_cnt,bool *emb, LPFC_MBOXQ_t *mbox)int rc = 0 ;/* Calculate the total requested length of the dma memory */ sizeof (uint16_t);/* * Calculate the size of an embedded mailbox . The uint32_t * accounts for extents - specific word . sizeof (MAILBOX_t) - sizeof (struct mbox_header) -sizeof (uint32_t);/* * Presume the allocation and response will fit into an embedded * mailbox . If not true , reconfigure to a non - embedded mailbox . if (req_len > emb_len) {sizeof (uint16_t) +sizeof (union lpfc_sli4_cfg_shdr) +sizeof (uint32_t);if (alloc_len < req_len) {"2982 Allocated DMA memory size (x%x) is " "less than the requested DMA memory " "size (x%x)\n" , alloc_len, req_len);return -ENOMEM;if (unlikely(rc))return -EIO;if (!phba->sli4_hba.intr_enable)else {if (unlikely(rc))return rc;/** * lpfc_sli4_alloc_extent - Allocate an SLI4 resource extent . * @ phba : Pointer to HBA context object . * @ type : The resource extent type to allocate . * * This function allocates the number of elements for the specified * resource type . static int struct lpfc_hba *phba, uint16_t type)bool emb = false ;int i, rc;unsigned long longs;unsigned long *bmask;struct lpfc_rsrc_blks *rsrc_blks;struct lpfc_id_range *id_array = NULL;void *virtaddr = NULL;struct lpfc_mbx_nembed_rsrc_extent *n_rsrc;struct lpfc_mbx_alloc_rsrc_extents *rsrc_ext;struct list_head *ext_blk_list;if (unlikely(rc))return -EIO;if ((rsrc_cnt == 0 ) || (rsrc_size == 0 )) {"3009 No available Resource Extents " "for resource type 0x%x: Count: 0x%x, " "Size 0x%x\n" , type, rsrc_cnt,return -ENOMEM;"2903 Post resource extents type-0x%x: " "count:%d, size %d\n" , type, rsrc_cnt, rsrc_size);if (!mbox)return -ENOMEM;if (unlikely(rc)) {goto err_exit;/* * Figure out where the response is located . Then get local pointers * to the response data . The port does not guarantee to respond to * all extents counts request so update the local variable with the * allocated count from the port . if (emb == LPFC_SLI4_MBX_EMBED) {0 ];else {0 ];struct lpfc_mbx_nembed_rsrc_extent *) virtaddr;1 ) / BITS_PER_LONG;/* * Based on the resource size and count , correct the base and max * resource values . sizeof (struct lpfc_rsrc_blks);switch (type) {case LPFC_RSC_TYPE_FCOE_RPI:sizeof (unsigned long ),if (unlikely(!phba->sli4_hba.rpi_bmask)) {goto err_exit;sizeof (uint16_t),if (unlikely(!phba->sli4_hba.rpi_ids)) {goto err_exit;/* * The next_rpi was initialized with the maximum available * count but the port may allocate a smaller number . Catch * that case and update the next_rpi . /* Initialize local ptrs for common extent processing later. */ break ;case LPFC_RSC_TYPE_FCOE_VPI:sizeof (unsigned long ),if (unlikely(!phba->vpi_bmask)) {goto err_exit;sizeof (uint16_t),if (unlikely(!phba->vpi_ids)) {goto err_exit;/* Initialize local ptrs for common extent processing later. */ break ;case LPFC_RSC_TYPE_FCOE_XRI:sizeof (unsigned long ),if (unlikely(!phba->sli4_hba.xri_bmask)) {goto err_exit;0 ;sizeof (uint16_t),if (unlikely(!phba->sli4_hba.xri_ids)) {goto err_exit;/* Initialize local ptrs for common extent processing later. */ break ;case LPFC_RSC_TYPE_FCOE_VFI:sizeof (unsigned long ),if (unlikely(!phba->sli4_hba.vfi_bmask)) {goto err_exit;sizeof (uint16_t),if (unlikely(!phba->sli4_hba.vfi_ids)) {goto err_exit;/* Initialize local ptrs for common extent processing later. */ break ;default :/* Unsupported Opcode. Fail call. */ goto err_exit;/* * Complete initializing the extent configuration with the * allocated ids assigned to this function . The bitmask serves * as an index into the array and manages the available ids . The * array just stores the ids communicated to the port via the wqes . for (i = 0 , j = 0 , k = 0 ; i < rsrc_cnt; i++) {if ((i % 2 ) == 0 )else if (unlikely(!rsrc_blks)) {goto err_exit;if ((type == LPFC_RSC_TYPE_FCOE_XRI) && (j == 0 )) {while (rsrc_id < (rsrc_start + rsrc_size)) {/* Entire word processed. Get next word.*/ if ((i % 2 ) == 1 )return rc;/** * lpfc_sli4_dealloc_extent - Deallocate an SLI4 resource extent . * @ phba : Pointer to HBA context object . * @ type : the extent ' s type . * * This function deallocates all extents of a particular resource type . * SLI4 does not allow for deallocating a particular extent range . It * is the caller ' s responsibility to release all kernel memory resources . static int struct lpfc_hba *phba, uint16_t type)int rc;0 ;struct lpfc_mbx_dealloc_rsrc_extents *dealloc_rsrc;struct lpfc_rsrc_blks *rsrc_blk, *rsrc_blk_next;if (!mbox)return -ENOMEM;/* * This function sends an embedded mailbox because it only sends the * the resource type . All extents of this type are released by the * port . sizeof (struct lpfc_mbx_dealloc_rsrc_extents) -sizeof (struct lpfc_sli4_cfg_mhdr));/* Send an extents count of 0 - the dealloc doesn't use it. */ 0 , type,if (unlikely(rc)) {goto out_free_mbox;if (!phba->sli4_hba.intr_enable)else {if (unlikely(rc)) {goto out_free_mbox;if (bf_get(lpfc_mbox_hdr_status,"2919 Failed to release resource extents " "for type %d - Status 0x%x Add'l Status 0x%x. " "Resource memory not released.\n" ,goto out_free_mbox;/* Release kernel memory resources for the specific type. */ switch (type) {case LPFC_RSC_TYPE_FCOE_VPI:0 );0 ;break ;case LPFC_RSC_TYPE_FCOE_XRI:break ;case LPFC_RSC_TYPE_FCOE_VFI:0 );break ;case LPFC_RSC_TYPE_FCOE_RPI:/* RPI bitmask and physical id array are cleaned up earlier. */ break ;default :break ;0 );return rc;static void struct lpfc_hba *phba, LPFC_MBOXQ_t *mbox,0 ;sizeof (struct lpfc_mbx_set_feature) -sizeof (struct lpfc_sli4_cfg_mhdr);switch (feature) {case LPFC_SET_UE_RECOVERY:1 );8 ;break ;case LPFC_SET_MDS_DIAGS:1 );1 );8 ;break ;case LPFC_SET_CGN_SIGNAL:if (phba->cmf_active_mode == LPFC_CFG_OFF)0 ;else if (phba->cgn_reg_signal == EDC_CG_SIG_WARN_ALARM) {if (phba->cgn_reg_signal == EDC_CG_SIG_WARN_ONLY)if (phba->cmf_active_mode == LPFC_CFG_OFF ||0 ;else 12 ;break ;case LPFC_SET_DUAL_DUMP:0 );4 ;break ;case LPFC_SET_ENABLE_MI:4 ;break ;case LPFC_SET_LD_SIGNAL:16 ;break ;case LPFC_SET_ENABLE_CMF:4 ;1 );break ;return ;/** * lpfc_ras_stop_fwlog : Disable FW logging by the adapter * @ phba : Pointer to HBA context object . * * Disable FW logging into host memory on the adapter . To * be done before reading logs from the host memory . void struct lpfc_hba *phba)struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;/* Disable FW logging to host memory */ /* Wait 10ms for firmware to stop using DMA buffer */ 10 * 1000 , 20 * 1000 );/** * lpfc_sli4_ras_dma_free - Free memory allocated for FW logging . * @ phba : Pointer to HBA context object . * * This function is called to free memory allocated for RAS FW logging * support in the driver . void struct lpfc_hba *phba)struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;struct lpfc_dmabuf *dmabuf, *next;if (!list_empty(&ras_fwlog->fwlog_buff_list)) {if (ras_fwlog->lwpd.virt) {sizeof (uint32_t) * 2 ,/** * lpfc_sli4_ras_dma_alloc : Allocate memory for FW support * @ phba : Pointer to HBA context object . * @ fwlog_buff_count : Count of buffers to be created . * * This routine DMA memory for Log Write Position Data [ LPWD ] and buffer * to update FW log is posted to the adapter . * Buffer count is calculated based on module param ras_fwlog_buffsize * Size of each buffer posted to FW is 64 K . static int struct lpfc_hba *phba,struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;struct lpfc_dmabuf *dmabuf;int rc = 0 , i = 0 ;/* Initialize List */ /* Allocate memory for the LWPD */ sizeof (uint32_t) * 2 ,if (!ras_fwlog->lwpd.virt) {"6185 LWPD Memory Alloc Failed\n" );return -ENOMEM;for (i = 0 ; i < ras_fwlog->fw_buffcount; i++) {sizeof (struct lpfc_dmabuf),if (!dmabuf) {"6186 Memory Alloc failed FW logging" );goto free_mem;if (!dmabuf->virt) {"6187 DMA Alloc Failed FW logging" );goto free_mem;if (rc)return rc;/** * lpfc_sli4_ras_mbox_cmpl : Completion handler for RAS MBX command * @ phba : pointer to lpfc hba data structure . * @ pmb : pointer to the driver internal queue element for mailbox command . * * Completion handler for driver ' s RAS MBX command to the device . static void struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)union lpfc_sli4_cfg_shdr *shdr;struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;union lpfc_sli4_cfg_shdr *)if (mb->mbxStatus != MBX_SUCCESS || shdr_status) {"6188 FW LOG mailbox " "completed with status x%x add_status x%x," " mbx status x%x\n" ,false ;goto disable_ras;return ;/* Free RAS DMA memory */ /** * lpfc_sli4_ras_fwlog_init : Initialize memory and post RAS MBX command * @ phba : pointer to lpfc hba data structure . * @ fwlog_level : Logging verbosity level . * @ fwlog_enable : Enable / Disable logging . * * Initialize memory and post mailbox command to enable FW logging in host * memory . int struct lpfc_hba *phba,struct lpfc_ras_fwlog *ras_fwlog = &phba->ras_fwlog;struct lpfc_mbx_set_ras_fwlog *mbx_fwlog = NULL;struct lpfc_dmabuf *dmabuf;0 , fwlog_buffsize, fwlog_entry_count;int rc = 0 ;/* * If re - enabling FW logging support use earlier allocated * DMA buffers while posting MBX command . if (!ras_fwlog->lwpd.virt) {if (rc) {"6189 FW Log Memory Allocation Failed" );return rc;/* Setup Mailbox command */ if (!mbox) {"6190 RAS MBX Alloc Failed" );goto mem_free;sizeof (struct lpfc_mbx_set_ras_fwlog) -sizeof (struct lpfc_sli4_cfg_mhdr));struct lpfc_mbx_set_ras_fwlog *)&mbox->u.mqe.un.ras_fwlog;/* Update DMA buffer address */ 0 , LPFC_RAS_MAX_ENTRY_SIZE);/* Update LPWD address */ if (rc == MBX_NOT_FINISHED) {"6191 FW-Log Mailbox failed. " "status %d mbxStatus : x%x" , rc,goto mem_free;else 0 ;if (rc)return rc;/** * lpfc_sli4_ras_setup - Check if RAS supported on the adapter * @ phba : Pointer to HBA context object . * * Check if RAS is supported on the adapter and initialize it . void struct lpfc_hba *phba)/* Check RAS FW Log needs to be enabled or not */ if (lpfc_check_fwlog_support(phba))return ;/** * lpfc_sli4_alloc_resource_identifiers - Allocate all SLI4 resource extents . * @ phba : Pointer to HBA context object . * * This function allocates all SLI4 resource identifiers . int struct lpfc_hba *phba)int i, rc, error = 0 ;unsigned long longs;if (!phba->sli4_hba.rpi_hdrs_in_use)if (phba->sli4_hba.extents_in_use) {/* * The port supports resource extents . The XRI , VPI , VFI , RPI * resource extent count must be read and allocated before * provisioning the resource id arrays . if (bf_get(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags) ==/* * Extent - based resources are set - the driver could * be in a port reset . Figure out if any corrective * actions need to be taken . if (rc != 0 )if (rc != 0 )if (rc != 0 )if (rc != 0 )/* * It ' s possible that the number of resources * provided to this port instance changed between * resets . Detect this condition and reallocate * resources . Otherwise , there is no action . if (error) {"2931 Detected extent resource " "change. Reallocating all " "extents.\n" );else return 0 ;if (unlikely(rc))goto err_exit;if (unlikely(rc))goto err_exit;if (unlikely(rc))goto err_exit;if (unlikely(rc))goto err_exit;return rc;else {/* * The port does not support resource extents . The XRI , VPI , * VFI , RPI resource ids were determined from READ_CONFIG . * Just allocate the bitmasks and provision the resource id * arrays . If a port reset is active , the resources don ' t * need any action - just exit . if (bf_get(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags) ==/* RPIs. */ if (count <= 0 ) {"3279 Invalid provisioning of " "rpi:%d\n" , count);goto err_exit;1 ) / BITS_PER_LONG;sizeof (unsigned long ),if (unlikely(!phba->sli4_hba.rpi_bmask)) {goto err_exit;sizeof (uint16_t),if (unlikely(!phba->sli4_hba.rpi_ids)) {goto free_rpi_bmask;for (i = 0 ; i < count; i++)/* VPIs. */ if (count <= 0 ) {"3280 Invalid provisioning of " "vpi:%d\n" , count);goto free_rpi_ids;1 ) / BITS_PER_LONG;sizeof (unsigned long ),if (unlikely(!phba->vpi_bmask)) {goto free_rpi_ids;sizeof (uint16_t),if (unlikely(!phba->vpi_ids)) {goto free_vpi_bmask;for (i = 0 ; i < count; i++)/* XRIs. */ if (count <= 0 ) {"3281 Invalid provisioning of " "xri:%d\n" , count);goto free_vpi_ids;1 ) / BITS_PER_LONG;sizeof (unsigned long ),if (unlikely(!phba->sli4_hba.xri_bmask)) {goto free_vpi_ids;0 ;sizeof (uint16_t),if (unlikely(!phba->sli4_hba.xri_ids)) {goto free_xri_bmask;for (i = 0 ; i < count; i++)/* VFIs. */ if (count <= 0 ) {"3282 Invalid provisioning of " "vfi:%d\n" , count);goto free_xri_ids;1 ) / BITS_PER_LONG;sizeof (unsigned long ),if (unlikely(!phba->sli4_hba.vfi_bmask)) {goto free_xri_ids;sizeof (uint16_t),if (unlikely(!phba->sli4_hba.vfi_ids)) {goto free_vfi_bmask;for (i = 0 ; i < count; i++)/* * Mark all resources ready . An HBA reset doesn ' t need * to reset the initialization . return 0 ;return rc;/** * lpfc_sli4_dealloc_resource_identifiers - Deallocate all SLI4 resource extents . * @ phba : Pointer to HBA context object . * * This function allocates the number of elements for the specified * resource type . int struct lpfc_hba *phba)if (phba->sli4_hba.extents_in_use) {else {0 ;0 );0 );0 );return 0 ;/** * lpfc_sli4_get_allocated_extnts - Get the port ' s allocated extents . * @ phba : Pointer to HBA context object . * @ type : The resource extent type . * @ extnt_cnt : buffer to hold port extent count response * @ extnt_size : buffer to hold port extent size response . * * This function calls the port to read the host allocated extents * for a particular type . int struct lpfc_hba *phba, uint16_t type,bool emb;int rc = 0 ;0 ;struct list_head *blk_list_head;struct lpfc_rsrc_blks *rsrc_blk;void *virtaddr = NULL;struct lpfc_mbx_nembed_rsrc_extent *n_rsrc;struct lpfc_mbx_alloc_rsrc_extents *rsrc_ext;union lpfc_sli4_cfg_shdr *shdr;switch (type) {case LPFC_RSC_TYPE_FCOE_VPI:break ;case LPFC_RSC_TYPE_FCOE_XRI:break ;case LPFC_RSC_TYPE_FCOE_VFI:break ;case LPFC_RSC_TYPE_FCOE_RPI:break ;default :return -EIO;/* Count the number of extents currently allocatd for this type. */ if (curr_blks == 0 ) {/* * The GET_ALLOCATED mailbox does not return the size , * just the count . The size should be just the size * stored in the current allocated block and all sizes * for an extent type are the same so set the return * value now . /* * Calculate the size of an embedded mailbox . The uint32_t * accounts for extents - specific word . sizeof (MAILBOX_t) - sizeof (struct mbox_header) -sizeof (uint32_t);/* * Presume the allocation and response will fit into an embedded * mailbox . If not true , reconfigure to a non - embedded mailbox . if (req_len > emb_len) {sizeof (uint16_t) +sizeof (union lpfc_sli4_cfg_shdr) +sizeof (uint32_t);if (!mbox)return -ENOMEM;0 , sizeof (LPFC_MBOXQ_t));if (alloc_len < req_len) {"2983 Allocated DMA memory size (x%x) is " "less than the requested DMA memory " "size (x%x)\n" , alloc_len, req_len);goto err_exit;if (unlikely(rc)) {goto err_exit;if (!phba->sli4_hba.intr_enable)else {if (unlikely(rc)) {goto err_exit;/* * Figure out where the response is located . Then get local pointers * to the response data . The port does not guarantee to respond to * all extents counts request so update the local variable with the * allocated count from the port . if (emb == LPFC_SLI4_MBX_EMBED) {else {0 ];struct lpfc_mbx_nembed_rsrc_extent *) virtaddr;if (bf_get(lpfc_mbox_hdr_status, &shdr->response)) {"2984 Failed to read allocated resources " "for type %d - Status 0x%x Add'l Status 0x%x.\n" ,goto err_exit;return rc;/** * lpfc_sli4_repost_sgl_list - Repost the buffers sgl pages as block * @ phba : pointer to lpfc hba data structure . * @ sgl_list : linked link of sgl buffers to post * @ cnt : number of linked list buffers * * This routine walks the list of buffers that have been allocated and * repost them to the port by using SGL block post . This is needed after a * pci_function_reset / warm_start or start . It attempts to construct blocks * of buffer sgls which contains contiguous xris and uses the non - embedded * SGL block post mailbox commands to post them to the port . For single * buffer sgl with non - contiguous xri , if any , it shall use embedded SGL post * mailbox command for posting . * * Returns : 0 = success , non - zero failure . static int struct lpfc_hba *phba,struct list_head *sgl_list, int cnt)struct lpfc_sglq *sglq_entry = NULL;struct lpfc_sglq *sglq_entry_next = NULL;struct lpfc_sglq *sglq_entry_first = NULL;int status = 0 , total_cnt;int post_cnt = 0 , num_posted = 0 , block_cnt = 0 ;int last_xritag = NO_XRI;if ((last_xritag != NO_XRI) &&1 )) {/* a hole in xri block, form a sgl posting block */ 1 ;/* prepare list for next posting block */ 1 ;else {/* prepare list for next posting block */ /* enough sgls for non-embed sgl mbox command */ if (block_cnt == LPFC_NEMBED_MBOX_SGL_CNT) {0 ;/* keep track of last sgl's xritag */ /* end of repost sgl list condition for buffers */ if (num_posted == total_cnt) {if (post_cnt == 0 ) {else if (block_cnt == 1 ) {0 ,if (!status) {/* successful, put sgl to posted list */ else {/* Failure, put sgl to free list */ "3159 Failed to post " "sgl, xritag:x%x\n" ,/* continue until a nembed page worth of sgls */ if (post_cnt == 0 )continue ;/* post the buffer list sgls as a block */ if (!status) {/* success, put sgl list to posted sgl list */ else {/* Failure, put sgl list to free sgl list */ struct lpfc_sglq,"3160 Failed to post sgl-list, " "xritag:x%x-x%x\n" ,1 ));/* don't reset xirtag due to hole in xri block */ if (block_cnt == 0 )/* reset sgl post count for next round of posting */ 0 ;/* free the sgls failed to post */ /* push sgls posted to the available list */ if (!list_empty(&post_sgl_list)) {else {"3161 Failure to post sgl to port,status %x " "blkcnt %d totalcnt %d postcnt %d\n" ,return -EIO;/* return the number of XRIs actually posted */ return total_cnt;/** * lpfc_sli4_repost_io_sgl_list - Repost all the allocated nvme buffer sgls * @ phba : pointer to lpfc hba data structure . * * This routine walks the list of nvme buffers that have been allocated and * repost them to the port by using SGL block post . This is needed after a * pci_function_reset / warm_start or start . The lpfc_hba_down_post_s4 routine * is responsible for moving all nvme buffers on the lpfc_abts_nvme_sgl_list * to the lpfc_io_buf_list . If the repost fails , reject all nvme buffers . * * Returns : 0 = success , non - zero failure . static int struct lpfc_hba *phba)int num_posted, rc = 0 ;/* get all NVME buffers need to repost to a local list */ /* post the list of nvme buffer sgls to port if available */ if (!list_empty(&post_nblist)) {/* failed to post any nvme buffer, return error */ if (num_posted == 0 )return rc;static void struct lpfc_hba *phba, LPFC_MBOXQ_t *mbox)sizeof (struct lpfc_mbx_set_host_data) -sizeof (struct lpfc_sli4_cfg_mhdr);"Linux %s v" LPFC_DRIVER_VERSION,"FCoE" : "FC" );int struct lpfc_hba *phba, struct lpfc_queue *hrq,struct lpfc_queue *drq, int count, int idx)int rc, i;struct lpfc_rqe hrqe;struct lpfc_rqe drqe;struct lpfc_rqb *rqbp;unsigned long flags;struct rqb_dmabuf *rqb_buffer;for (i = 0 ; i < count; i++) {/* IF RQ is already full, don't bother */ if (rqbp->buffer_count + i >= rqbp->entry_count - 1 ) {break ;if (!rqb_buffer)break ;while (!list_empty(&rqb_buf_list)) {struct rqb_dmabuf,if (rc < 0 ) {"6421 Cannot post to HRQ %d: %x %x %x " "DRQ %x %x\n" ,else {return 1 ;static void struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)union lpfc_sli4_cfg_shdr *shdr;union lpfc_sli4_cfg_shdr *)if (shdr_status || shdr_add_status || pmb->u.mb.mbxStatus) {"4622 SET_FEATURE (x%x) mbox failed, " "status x%x add_status x%x, mbx status x%x\n" ,0 ;0 ;0 ;goto out;"4624 Success: da x%x dd x%x interval x%x\n" ,int struct lpfc_hba *phba)int rc;if (!mboxq)return -ENOMEM;if (rc == MBX_NOT_FINISHED) {return -EIO;return 0 ;static void struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)struct lpfc_vport *vport = pmb->vport;union lpfc_sli4_cfg_shdr *shdr;/* Two outcomes. (1) Set featurs was successul and EDC negotiation * is done . ( 2 ) Mailbox failed and send FPIN support only . union lpfc_sli4_cfg_shdr *)if (shdr_status || shdr_add_status || pmb->u.mb.mbxStatus) {"2516 CGN SET_FEATURE mbox failed with " "status x%x add_status x%x, mbx status x%x " "Reset Congestion to FPINs only\n" ,/* If there is a mbox error, move on to RDF */ goto out;/* Zero out Congestion Signal ACQE counter */ 0 ;"4620 SET_FEATURES Success: Freq: %ds %dms " " Reg: x%x x%x\n" , acqe, sig,/* Register for FPIN events from the fabric now that the * EDC common_set_features has completed . 0 );int struct lpfc_hba *phba)if (!mboxq)goto out_rdf;"4621 SET_FEATURES: FREQ sig x%x acqe x%x: " "Reg: x%x x%x\n" ,if (rc == MBX_NOT_FINISHED)goto out;return 0 ;/* If there is a mbox error, move on to RDF */ 0 );return -EIO;/** * lpfc_init_idle_stat_hb - Initialize idle_stat tracking * @ phba : pointer to lpfc hba data structure . * * This routine initializes the per - eq idle_stat to dynamically dictate * polling decisions . * * Return codes : * None static void lpfc_init_idle_stat_hb(struct lpfc_hba *phba)int i;struct lpfc_sli4_hdw_queue *hdwq;struct lpfc_queue *eq;struct lpfc_idle_stat *idle_stat;/* Skip if we've already handled this eq's primary CPU */ if (eq->chann != i)continue ;1 );if (phba->nvmet_support ||else if (!phba->nvmet_support && phba->intr_type == MSIX)static void lpfc_sli4_dip(struct lpfc_hba *phba)if (if_type == LPFC_SLI_INTF_IF_TYPE_2 ||struct lpfc_register reg_data;if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,return ;if (bf_get(lpfc_sliport_status_dip, ®_data))"2904 Firmware Dump Image Present" " on Adapter" );/** * lpfc_rx_monitor_create_ring - Initialize ring buffer for rx_monitor * @ rx_monitor : Pointer to lpfc_rx_info_monitor object * @ entries : Number of rx_info_entry objects to allocate in ring * * Return : * 0 - Success * ENOMEM - Failure to kmalloc int lpfc_rx_monitor_create_ring(struct lpfc_rx_info_monitor *rx_monitor,sizeof (struct rx_info_entry),if (!rx_monitor->ring)return -ENOMEM;0 ;0 ;return 0 ;/** * lpfc_rx_monitor_destroy_ring - Free ring buffer for rx_monitor * @ rx_monitor : Pointer to lpfc_rx_info_monitor object * * Called after cancellation of cmf_timer . void lpfc_rx_monitor_destroy_ring(struct lpfc_rx_info_monitor *rx_monitor)0 ;0 ;0 ;/** * lpfc_rx_monitor_record - Insert an entry into rx_monitor ' s ring * @ rx_monitor : Pointer to lpfc_rx_info_monitor object * @ entry : Pointer to rx_info_entry * * Used to insert an rx_info_entry into rx_monitor ' s ring . Note that this is a * deep copy of rx_info_entry not a shallow copy of the rx_info_entry ptr . * * This is called from lpfc_cmf_timer , which is in timer / softirq context . * * In cases of old data overflow , we do a best effort of FIFO order . void lpfc_rx_monitor_record(struct lpfc_rx_info_monitor *rx_monitor,struct rx_info_entry *entry)struct rx_info_entry *ring = rx_monitor->ring;sizeof (*entry));1 ) % ring_size;/* Best effort of FIFO saved data */ if (*tail_idx == *head_idx)1 ) % ring_size;/** * lpfc_rx_monitor_report - Read out rx_monitor ' s ring * @ phba : Pointer to lpfc_hba object * @ rx_monitor : Pointer to lpfc_rx_info_monitor object * @ buf : Pointer to char buffer that will contain rx monitor info data * @ buf_len : Length buf including null char * @ max_read_entries : Maximum number of entries to read out of ring * * Used to dump / read what ' s in rx_monitor ' s ring buffer . * * If buf is NULL | | buf_len = = 0 , then it is implied that we want to log the * information to kmsg instead of filling out buf . * * Return : * Number of entries read out of the ring struct lpfc_hba *phba,struct lpfc_rx_info_monitor *rx_monitor, char *buf,struct rx_info_entry *ring = rx_monitor->ring;struct rx_info_entry *entry;0 ;char tmp[DBG_LOG_STR_SZ] = {0 };bool log_to_kmsg = (!buf || !buf_len) ? true : false ;if (!log_to_kmsg) {/* clear the buffer to be sure */ 0 , buf_len);"\t%-16s%-16s%-16s%-16s%-8s%-8s%-8s" "%-8s%-8s%-8s%-16s\n" ,"MaxBPI" , "Tot_Data_CMF" ,"Tot_Data_Cmd" , "Tot_Data_Cmpl" ,"Lat(us)" , "Avg_IO" , "Max_IO" , "Bsy" ,"IO_cnt" , "Info" , "BWutil(ms)" );/* Needs to be _irq because record is called from timer interrupt * context while (*head_idx != *tail_idx) {/* Read out this entry's data. */ if (!log_to_kmsg) {/* If !log_to_kmsg, then store to buf. */ sizeof (tmp),"%03d:\t%-16llu%-16llu%-16llu%-16llu%-8llu" "%-8llu%-8llu%-8u%-8u%-8u%u(%u)\n" ,/* Check for buffer overflow */ if ((strlen(buf) + strlen(tmp)) >= buf_len)break ;/* Append entry's data to buffer */ else {"4410 %02u: MBPI %llu Xmit %llu " "Cmpl %llu Lat %llu ASz %llu Info %02u " "BWUtil %u Int %u slot %u\n" ,1 ) % ring_size;/* Don't feed more than max_read_entries */ if (cnt >= max_read_entries)break ;return cnt;/** * lpfc_cmf_setup - Initialize idle_stat tracking * @ phba : Pointer to HBA context object . * * This is called from HBA setup during driver load or when the HBA * comes online . this does all the initialization to support CMF and MI . static int struct lpfc_hba *phba)struct lpfc_dmabuf *mp;struct lpfc_pc_sli4_params *sli4_params;int rc, cmf, mi_ver;if (unlikely(rc))return rc;if (!mboxq)return -ENOMEM;/* Always try to enable MI feature if we can */ if (sli4_params->mi_ver) {if (rc == MBX_SUCCESS) {if (mi_ver) {"6215 MI is enabled\n" );else {"6338 MI is disabled\n" );0 ;else {/* mi_ver is already set from GET_SLI4_PARAMETERS */ "6245 Enable MI Mailbox x%x (x%x/x%x) " "failed, rc:x%x mi:x%x\n" ,else {"6217 MI is disabled\n" );/* Ensure FDMI is enabled for MI if enable_mi is set */ if (sli4_params->mi_ver)/* Always try to enable CMF feature if we can */ if (sli4_params->cmf) {if (rc == MBX_SUCCESS && cmf) {"6218 CMF is enabled: mode %d\n" ,else {"6219 Enable CMF Mailbox x%x (x%x/x%x) " "failed, rc:x%x dd:x%x\n" ,0 ;goto no_cmf;/* Allocate Congestion Information Buffer */ if (!phba->cgn_i) {sizeof (*mp), GFP_KERNEL);if (mp)sizeof (struct lpfc_cgn_info),if (!mp || !mp->virt) {"2640 Failed to alloc memory " "for Congestion Info\n" );0 ;goto no_cmf;/* initialize congestion buffer info */ /* Zero out Congestion Signal counters */ 0 );0 );if (rc < 0 ) {"6242 Error reading Cgn Params (%d)\n" ,/* Ensure CGN Mode is off */ 0 ;else if (!rc) {"6243 CGN Event empty object.\n" );/* Ensure CGN Mode is off */ 0 ;else {"6220 CMF is disabled\n" );/* Only register congestion buffer with firmware if BOTH * CMF and E2E are enabled . if (sli4_params->cmf && sli4_params->mi_ver) {if (rc) {sizeof (struct lpfc_cgn_info),/* Ensure CGN Mode is off */ 0 ;return 0 ;"6470 Setup MI version %d CMF %d mode %d\n" ,/* Initialize atomic counters */ 0 );0 );0 );0 );0 );0 );0 );/* Allocate RX Monitor Buffer */ if (!phba->rx_monitor) {sizeof (*phba->rx_monitor),if (!phba->rx_monitor) {"2644 Failed to alloc memory " "for RX Monitor Buffer\n" );return -ENOMEM;/* Instruct the rx_monitor object to instantiate its ring */ if (lpfc_rx_monitor_create_ring(phba->rx_monitor,"2645 Failed to alloc memory " "for RX Monitor's Ring\n" );return -ENOMEM;return 0 ;static int struct lpfc_hba *phba)struct timespec64 cur_time;struct tm broken;struct lpfc_mbx_set_host_date_time *tm;if (!mboxq)return -ENOMEM;sizeof (struct lpfc_mbx_set_host_data) -sizeof (struct lpfc_sli4_cfg_mhdr);sizeof (struct lpfc_mbx_set_host_date_time);0 , &broken);1 ;100 ;return rc;/** * lpfc_sli4_hba_setup - SLI4 device initialization PCI function * @ phba : Pointer to HBA context object . * * This function is the main SLI4 device initialization PCI function . This * function is called by the HBA initialization code , HBA reset code and * HBA error attention handler code . Caller is not required to hold any * locks . int struct lpfc_hba *phba)int rc, i, cnt, len, dd;struct lpfc_mqe *mqe;0 ;struct Scsi_Host *shost = lpfc_shost_from_vport(phba->pport);struct lpfc_vport *vport = phba->pport;struct lpfc_dmabuf *mp;struct lpfc_rqb *rqbp;/* Perform a PCI function reset to start from clean */ if (unlikely(rc))return -ENODEV;/* Check the HBA Host Status Register for readyness */ if (unlikely(rc))return -ENODEV;else {/* Allow a little time after setting SLI_ACTIVE for any polled * MBX commands to complete via BSG . for (i = 0 ; i < 50 && (flg & LPFC_SLI_MBOX_ACTIVE); i++) {20 );/* * Allocate a single mailbox container for initializing the * port . if (!mboxq)return -ENOMEM;/* Issue READ_REV to collect vpd and FW information. */ if (!vpd) {goto out_free_mbox;if (unlikely(rc)) {goto out_free_mbox;if (bf_get(lpfc_mbx_rd_rev_fcoe, &mqe->un.read_rev)) {0 ; /* SLI4 FC support only */ else {if (bf_get(lpfc_mbx_rd_rev_cee_ver, &mqe->un.read_rev) ==else if (phba->sli_rev != LPFC_SLI_REV4) {"0376 READ_REV Error. SLI Level %d " "FCoE enabled %d\n" ,1 : 0 );goto out_free_mbox;"6468 Set host date / time: Status x%x:\n" , rc);/* * Continue initialization with default values even if driver failed * to read FCoE param config regions , only read parameters if the * board is FCoE if (test_bit(HBA_FCOE_MODE, &phba->hba_flag) &&"2570 Failed to read FCoE parameters\n" );/* * Retrieve sli4 device physical port name , failure of doing it * is considered as non - fatal . if (!rc)"3080 Successful retrieving SLI4 device " "physical port name: %s.\n" , phba->Port);if (!rc)"8351 Successful retrieving SLI4 device " "CTL ATTR\n" );/* * Evaluate the read rev and vpd data . Populate the driver * state with the results . If this routine fails , the failure * is not fatal as the driver will use generic values . if (unlikely(!rc))"0377 Error %d parsing vpd. " "Using defaults.\n" , rc);/* Save information as VPD data */ /* * This is because first G7 ASIC doesn ' t support the standard * 0 x5a NVME cmd descriptor type / subtype if ((bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==0 ) &&1 ))0 ;16 );16 );16 );"(%d):0380 READ_REV Status x%x " "fw_rev:%s fcphHi:%x fcphLo:%x flHi:%x flLo:%x\n" ,0 ,if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==if (rc == MBX_SUCCESS) {/* Set 1Sec interval to detect UE */ 1 ;if (phba->cfg_enable_mds_diags && phba->mds_diags_support) {/* Enable MDS Diagnostics only if the SLI Port supports it */ if (rc != MBX_SUCCESS)0 ;/* * Discover the port ' s supported feature set and match it against the * hosts requests . if (unlikely(rc)) {goto out_free_mbox;/* Disable VMID if app header is not supported */ if (phba->cfg_vmid_app_header && !(bf_get(lpfc_mbx_rq_ftr_rsp_ashdr,0 );0 ;"1242 vmid feature not supported\n" );/* * The port must support FCP initiator mode as this is the * only mode running in the host . if (!(bf_get(lpfc_mbx_rq_ftr_rsp_fcpi, &mqe->un.req_ftrs))) {"0378 No support for fcpi mode.\n" );/* Performance Hints are ONLY for FCoE */ if (test_bit(HBA_FCOE_MODE, &phba->hba_flag)) {if (bf_get(lpfc_mbx_rq_ftr_rsp_perfh, &mqe->un.req_ftrs))else /* * If the port cannot support the host ' s requested features * then turn off the global config parameters to disable the * feature in the driver . This is not a fatal error . if (phba->sli3_options & LPFC_SLI3_BG_ENABLED) {if (!(bf_get(lpfc_mbx_rq_ftr_rsp_dif, &mqe->un.req_ftrs))) {0 ;if (phba->max_vpi && phba->cfg_enable_npiv &&if (ftr_rsp) {"0379 Feature Mismatch Data: x%08x %08x " "x%x x%x x%x\n" , mqe->un.req_ftrs.word2,if (!(bf_get(lpfc_mbx_rq_ftr_rsp_dif, &mqe->un.req_ftrs)))0 ;if (!(bf_get(lpfc_mbx_rq_ftr_rsp_npiv, &mqe->un.req_ftrs)))0 ;/* These SLI3 features are assumed in SLI4 */ /* Always try to enable dual dump feature if we can */ if ((rc == MBX_SUCCESS) && (dd == LPFC_ENABLE_DUAL_DUMP))"6448 Dual Dump is enabled\n" );else "6447 Dual Dump Mailbox x%x (x%x/x%x) failed, " "rc:x%x dd:x%x\n" ,/* * Allocate all resources ( xri , rpi , vpi , vfi ) now . Subsequent * calls depends on these resources to complete port setup . if (rc) {"2920 Failed to alloc Resource IDs " "rc = x%x\n" , rc);goto out_free_mbox;if (rc) {"2134 Failed to set host os driver version %x" ,/* Read the port's service parameters. */ if (rc) {goto out_free_mbox;if (rc == MBX_SUCCESS) {sizeof (struct serv_parm));0 ;/* * This memory was allocated by the lpfc_read_sparam routine but is * no longer needed . It is released and ctx_buf NULLed to prevent * unintended pointer access as the mbox is reused . if (unlikely(rc)) {"0382 READ_SPARAM command failed " "status %d, mbxStatus x%x\n" ,goto out_free_mbox;/* Update the fc_host data structures with new wwn. */ /* Create all the SLI4 queues */ if (rc) {"3089 Failed to allocate queues\n" );goto out_free_mbox;/* Set up all the queues to the device */ if (unlikely(rc)) {"0381 Error %d during queue setup.\n" , rc);goto out_destroy_queue;/* Initialize the driver internal SLI layer lists. */ /* update host els xri-sgl sizes and mappings */ if (unlikely(rc)) {"1400 Failed to update xri-sgl size and " "mapping: %d\n" , rc);goto out_destroy_queue;/* register the els sgl pool to the port */ if (unlikely(rc < 0 )) {"0582 Error %d during els sgl post " "operation\n" , rc);goto out_destroy_queue;if (phba->nvmet_support) {/* update host nvmet xri-sgl sizes and mappings */ if (unlikely(rc)) {"6308 Failed to update nvmet-sgl size " "and mapping: %d\n" , rc);goto out_destroy_queue;/* register the nvmet sgl pool to the port */ if (unlikely(rc < 0 )) {"3117 Error %d during nvmet " "sgl post\n" , rc);goto out_destroy_queue;/* We allocate an iocbq for every receive context SGL. * The additional allocation is for abort and ls handling . else {/* update host common xri-sgl sizes and mappings */ if (unlikely(rc)) {"6082 Failed to update nvme-sgl size " "and mapping: %d\n" , rc);goto out_destroy_queue;/* register the allocated common sgl pool to the port */ if (unlikely(rc)) {"6116 Error %d during nvme sgl post " "operation\n" , rc);/* Some NVME buffers were moved to abort nvme list */ /* A pci function reset will repost them */ goto out_destroy_queue;/* Each lpfc_io_buf job structure has an iocbq element. * This cnt provides for abort , els , ct and ls requests . if (!phba->sli.iocbq_lookup) {/* Initialize and populate the iocb list per host */ "2821 initialize iocb list with %d entries\n" ,if (rc) {"1413 Failed to init iocb list.\n" );goto out_destroy_queue;if (phba->nvmet_support)if (phba->nvmet_support && phba->cfg_nvmet_mrq) {/* Post initial buffers to all RQs created */ for (i = 0 ; i < phba->cfg_nvmet_mrq; i++) {0 ;/* Post the rpi header region to the device. */ if (unlikely(rc)) {"0393 Error %d during rpi post operation\n" ,goto out_free_iocblist;if (!test_bit(HBA_FCOE_MODE, &phba->hba_flag)) {if ((phba->nvmet_support == 0 ) || (phba->cfg_nvmet_mrq == 1 )) {/* * The FC Port needs to register FCFI ( index 0 ) if (rc != MBX_SUCCESS)goto out_unset_queue;0 ;else {/* We are a NVME Target mode with MRQ > 1 */ /* First register the FCFI */ 0 );if (rc != MBX_SUCCESS)goto out_unset_queue;0 ;/* Next register the MRQs */ 1 );if (rc != MBX_SUCCESS)goto out_unset_queue;0 ;/* Check if the port is configured to be disabled */ /* Don't post more new bufs if repost already recovered * the nvme sgls . if (phba->nvmet_support == 0 ) {if (phba->sli4_hba.io_xri_cnt == 0 ) {if (len == 0 ) {goto out_unset_queue;if (phba->cfg_xri_rebalancing)else {0 ;/* Allow asynchronous mailbox command to go through */ /* Post receive buffers to the device */ /* Reset HBA FCF states after HBA reset */ 0 ;0 ;/* Start the ELS watchdog timer */ 2 ));/* Start heart beat timer */ /* start eq_delay heartbeat */ if (phba->cfg_auto_imax)/* start per phba idle_stat_delay heartbeat */ /* Start error attention (ERATT) polling timer */ /* * The port is ready , set the host ' s link state to LINK_DOWN * in preparation for link interrupts . /* Check if physical ports are trunked */ if (bf_get(lpfc_conf_trunk_port0, &phba->sli4_hba))if (bf_get(lpfc_conf_trunk_port1, &phba->sli4_hba))if (bf_get(lpfc_conf_trunk_port2, &phba->sli4_hba))if (bf_get(lpfc_conf_trunk_port3, &phba->sli4_hba))/* Arm the CQs and then EQs on device */ /* Indicate device interrupt mode */ 1 ;/* Setup CMF after HBA is initialized */ if (!test_bit(HBA_FCOE_MODE, &phba->hba_flag) &&"3103 Adapter Link is disabled.\n" );if (rc != MBX_SUCCESS) {"3104 Adapter failed to issue " "DOWN_LINK mbox cmd, rc:x%x\n" , rc);goto out_io_buff_free;else if (phba->cfg_suppress_link_up == LPFC_INITIALIZE_LINK) {/* don't perform init_link on SLI4 FC port loopback test */ if (!(phba->link_flag & LS_LOOPBACK_MODE)) {if (rc)goto out_io_buff_free;/* Enable RAS FW log support */ return rc;/* Free allocated IO Buffers */ /* Unset all the queues set up in this routine when error out */ return rc;/** * lpfc_mbox_timeout - Timeout call back function for mbox timer * @ t : Context to fetch pointer to hba structure from . * * This is the callback function for mailbox timer . The mailbox * timer is armed when a new mailbox command is issued and the timer * is deleted when the mailbox complete . The function is called by * the kernel timer code when a mailbox does not complete within * expected time . This function wakes up the worker thread to * process the mailbox timeout and returns . All the processing is * done by the worker thread function lpfc_mbox_timeout_handler . void struct timer_list *t)struct lpfc_hba *phba = timer_container_of(phba, t, sli.mbox_tmo);unsigned long iflag;if (!tmo_posted)if (!tmo_posted)return ;/** * lpfc_sli4_mbox_completions_pending - check to see if any mailbox completions * are pending * @ phba : Pointer to HBA context object . * * This function checks if any mailbox completions are present on the mailbox * completion queue . static bool struct lpfc_hba *phba)struct lpfc_queue *mcq;struct lpfc_mcqe *mcqe;bool pending_completions = false ;if (unlikely(!phba) || (phba->sli_rev != LPFC_SLI_REV4))return false ;/* Check for completions on mailbox completion queue */ while (bf_get_le32(lpfc_cqe_valid,struct lpfc_cqe *)lpfc_sli4_qe(mcq, idx)) == qe_valid) {struct lpfc_mcqe *)(lpfc_sli4_qe(mcq, idx));if (bf_get_le32(lpfc_trailer_completed, mcqe) &&true ;break ;1 ) % mcq->entry_count;if (mcq->hba_index == idx)break ;/* if the index wrapped around, toggle the valid bit */ if (phba->sli4_hba.pc_sli4_params.cqav && !idx)0 : 1 ;return pending_completions;/** * lpfc_sli4_process_missed_mbox_completions - process mbox completions * that were missed . * @ phba : Pointer to HBA context object . * * For sli4 , it is possible to miss an interrupt . As such mbox completions * maybe missed causing erroneous mailbox timeouts to occur . This function * checks to see if mbox completions are on the mailbox completion queue * and will process all the completions associated with the eq for the * mailbox completion queue . static bool struct lpfc_hba *phba)struct lpfc_sli4_hba *sli4_hba = &phba->sli4_hba;struct lpfc_queue *fpeq = NULL;struct lpfc_queue *eq;bool mbox_pending;if (unlikely(!phba) || (phba->sli_rev != LPFC_SLI_REV4))return false ;/* Find the EQ associated with the mbox CQ */ if (sli4_hba->hdwq) {for (eqidx = 0 ; eqidx < phba->cfg_irq_chann; eqidx++) {if (eq && eq->queue_id == sli4_hba->mbx_cq->assoc_qid) {break ;if (!fpeq)return false ;/* Turn off interrupts from this EQ */ /* Check to see if a mbox completion is pending */ /* * If a mbox completion is pending , process all the events on EQ * associated with the mbox completion queue ( this could include * mailbox commands , async events , els commands , receive queue data * and fcp commands ) if (mbox_pending)/* process and rearm the EQ */ else /* Always clear and re-arm the EQ */ 0 , LPFC_QUEUE_REARM);return mbox_pending;/** * lpfc_mbox_timeout_handler - Worker thread function to handle mailbox timeout * @ phba : Pointer to HBA context object . * * This function is called from worker thread when a mailbox command times out . * The caller is not required to hold any locks . This function will reset the * HBA and recover all the pending commands . void struct lpfc_hba *phba)struct lpfc_sli *psli = &phba->sli;/* If the mailbox completed, process the completion */ if (!(psli->sli_flag & LPFC_SLI_ACTIVE))return ;if (pmbox != NULL)/* Check the pmbox pointer first. There is a race condition * between the mbox timeout handler getting executed in the * worklist and the mailbox actually completing . When this * race condition occurs , the mbox_active will be NULL . if (pmbox == NULL) {"0353 Active Mailbox cleared - mailbox timeout " "exiting\n" );return ;/* Mbox cmd <mbxCommand> timeout */ "0310 Mailbox command x%x timeout Data: x%x x%x x%px\n" ,/* Setting state unknown so lpfc_sli_abort_iocb_ring * would get IOCB_ERROR from lpfc_sli_issue_iocb , allowing * it to fail all outstanding SCSI IO . "0345 Resetting board due to mailbox timeout\n" );/* Reset the HBA device */ /** * lpfc_sli_issue_mbox_s3 - Issue an SLI3 mailbox command to firmware * @ phba : Pointer to HBA context object . * @ pmbox : Pointer to mailbox object . * @ flag : Flag indicating how the mailbox need to be processed . * * This function is called by discovery code and HBA management code * to submit a mailbox command to firmware with SLI - 3 interface spec . This * function gets the hbalock to protect the data structures . * The mailbox command can be submitted in polling mode , in which case * this function will wait in a polling loop for the completion of the * mailbox . * If the mailbox is submitted in no_wait mode ( not polling ) the * function will submit the command and returns immediately without waiting * for the mailbox completion . The no_wait is supported only when HBA * is in SLI2 / SLI3 mode - interrupts are enabled . * The SLI interface allows only one mailbox pending at a time . If the * mailbox is issued in polling mode and there is already a mailbox * pending , then the function will return an error . If the mailbox is issued * in NO_WAIT mode and there is a mailbox pending already , the function * will return MBX_BUSY after queuing the mailbox into mailbox queue . * The sli layer owns the mailbox object until the completion of mailbox * command if this function return MBX_BUSY or MBX_SUCCESS . For all other * return codes the caller owns the mailbox command after the return of * the function . static int struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox,struct lpfc_sli *psli = &phba->sli;int i;unsigned long timeout;unsigned long drvr_flag = 0 ;void __iomem *to_slim;int processing_queue = 0 ;if (!pmbox) {/* processing mbox queue from intr_handler */ if (unlikely(psli->sli_flag & LPFC_SLI_ASYNC_MBX_BLK)) {return MBX_SUCCESS;1 ;if (!pmbox) {return MBX_SUCCESS;if (pmbox->mbox_cmpl && pmbox->mbox_cmpl != lpfc_sli_def_mbox_cmpl &&if (!pmbox->vport) {"1806 Mbox x%x failed. No vport\n" ,goto out_not_finished;/* If the PCI channel is in offline state, do not post mbox. */ if (unlikely(pci_channel_offline(phba->pcidev))) {goto out_not_finished;/* If HBA has a deferred error attention, fail the iocb. */ if (unlikely(test_bit(DEFER_ERATT, &phba->hba_flag))) {goto out_not_finished;if (phba->link_state == LPFC_HBA_ERROR) {/* Mbox command <mbxCommand> cannot issue */ "(%d):0311 Mailbox command x%x cannot " "issue Data: x%x x%x\n" ,0 ,goto out_not_finished;if (mbx->mbxCommand != MBX_KILL_BOARD && flag & MBX_NOWAIT) {if (lpfc_readl(phba->HCregaddr, &hc_copy) ||"(%d):2528 Mailbox command x%x cannot " "issue Data: x%x x%x\n" ,0 ,goto out_not_finished;if (psli->sli_flag & LPFC_SLI_MBOX_ACTIVE) {/* Polling for a mbox command when another one is already active * is not allowed in SLI . Also , the driver must have established * SLI2 mode to queue and process multiple mbox commands . if (flag & MBX_POLL) {/* Mbox command <mbxCommand> cannot issue */ "(%d):2529 Mailbox command x%x " "cannot issue Data: x%x x%x\n" ,0 ,goto out_not_finished;if (!(psli->sli_flag & LPFC_SLI_ACTIVE)) {/* Mbox command <mbxCommand> cannot issue */ "(%d):2530 Mailbox command x%x " "cannot issue Data: x%x x%x\n" ,0 ,goto out_not_finished;/* Another mailbox command is still being processed, queue this * command to be processed later . /* Mbox cmd issue - BUSY */ "(%d):0308 Mbox cmd issue - BUSY Data: " "x%x x%x x%x x%x\n" ,0 xffffff,0 xff,if (pmbox->vport) {"MBOX Bsy vport: cmd:x%x mb:x%x x%x" ,0 ], mbx->un.varWords[1 ]);else {"MBOX Bsy: cmd:x%x mb:x%x x%x" ,0 ], mbx->un.varWords[1 ]);return MBX_BUSY;/* If we are not polling, we MUST be in SLI2 mode */ if (flag != MBX_POLL) {if (!(psli->sli_flag & LPFC_SLI_ACTIVE) &&/* Mbox command <mbxCommand> cannot issue */ "(%d):2531 Mailbox command x%x " "cannot issue Data: x%x x%x\n" ,0 ,goto out_not_finished;/* timeout active mbox command */ /* Mailbox cmd <cmd> issue */ "(%d):0309 Mailbox cmd x%x issue Data: x%x x%x " "x%x\n" ,0 ,0 xff,if (mbx->mbxCommand != MBX_HEARTBEAT) {if (pmbox->vport) {"MBOX Send vport: cmd:x%x mb:x%x x%x" ,0 ], mbx->un.varWords[1 ]);else {"MBOX Send: cmd:x%x mb:x%x x%x" ,0 ], mbx->un.varWords[1 ]);/* next set own bit for the adapter and copy over command word */ if (psli->sli_flag & LPFC_SLI_ACTIVE) {/* Populate mbox extension offset word. */ if (pmbox->in_ext_byte_len || pmbox->out_ext_byte_len) {/* Copy the mailbox extension data */ if (pmbox->in_ext_byte_len && pmbox->ext_buf) {/* Copy command data to host SLIM area */ else {/* Populate mbox extension offset word. */ if (pmbox->in_ext_byte_len || pmbox->out_ext_byte_len)/* Copy the mailbox extension data */ if (pmbox->in_ext_byte_len && pmbox->ext_buf)if (mbx->mbxCommand == MBX_CONFIG_PORT)/* copy command data into host mbox for cmpl */ /* First copy mbox command data to HBA SLIM, skip past first sizeof (uint32_t);0 ],sizeof (uint32_t));/* Next copy over first word, with mbxOwner set */ /* flush */ if (mbx->mbxCommand == MBX_CONFIG_PORT)/* switch over to host mailbox */ switch (flag) {case MBX_NOWAIT:/* Set up reference to mailbox command */ /* Interrupt board to do it */ /* flush */ /* Don't wait for it to finish, just return */ break ;case MBX_POLL:/* Set up null reference to mailbox command */ /* Interrupt board to do it */ /* flush */ if (psli->sli_flag & LPFC_SLI_ACTIVE) {/* First read mbox status word */ else {/* First read mbox status word */ if (lpfc_readl(phba->MBslimaddr, &word0)) {goto out_not_finished;/* Read the HBA Host Attention Register */ if (lpfc_readl(phba->HAregaddr, &ha_copy)) {goto out_not_finished;0 ;/* Wait for command to complete */ while (((word0 & OWN_CHIP) == OWN_CHIP) ||if (time_after(jiffies, timeout)) {goto out_not_finished;/* Check if we took a mbox interrupt while we were if (((word0 & OWN_CHIP) != OWN_CHIP)break ;if (i++ > 10 ) {1 );if (psli->sli_flag & LPFC_SLI_ACTIVE) {/* First copy command data */ if (mbx->mbxCommand == MBX_CONFIG_PORT) {/* Check real SLIM for any errors */ if (((slimword0 & OWN_CHIP) != OWN_CHIP)else {/* First copy command data */ /* Read the HBA Host Attention Register */ if (lpfc_readl(phba->HAregaddr, &ha_copy)) {goto out_not_finished;if (psli->sli_flag & LPFC_SLI_ACTIVE) {/* copy results back to user */ /* Copy the mailbox extension data */ if (pmbox->out_ext_byte_len && pmbox->ext_buf) {else {/* First copy command data */ /* Copy the mailbox extension data */ if (pmbox->out_ext_byte_len && pmbox->ext_buf) {/* flush */ return status;if (processing_queue) {return MBX_NOT_FINISHED;/** * lpfc_sli4_async_mbox_block - Block posting SLI4 asynchronous mailbox command * @ phba : Pointer to HBA context object . * * The function blocks the posting of SLI4 asynchronous mailbox commands from * the driver internal pending mailbox queue . It will then try to wait out the * possible outstanding mailbox command before return . * * Returns : * 0 - the outstanding mailbox command completed ; otherwise , the wait for * the outstanding mailbox command timed out . static int struct lpfc_hba *phba)struct lpfc_sli *psli = &phba->sli;int rc = 0 ;unsigned long timeout = 0 ;/* Mark the asynchronous mailbox command posting as blocked */ /* Determine how long we might wait for the active mailbox * command to be gracefully completed by firmware . if (phba->sli.mbox_active)/* Make sure the mailbox is really active */ if (timeout)/* Wait for the outstanding mailbox command to complete */ while (phba->sli.mbox_active) {/* Check active mailbox complete status every 2ms */ 2 );if (time_after(jiffies, timeout)) {/* Timeout, mark the outstanding cmd not complete */ /* Sanity check sli.mbox_active has not completed or * cancelled from another context during last 2 ms sleep , * so take hbalock to be sure before logging . if (phba->sli.mbox_active) {"2352 Mailbox command x%x " "(x%x/x%x) sli_flag x%x could " "not complete\n" ,else {1 ;break ;/* Can not cleanly block async mailbox command, fails it */ if (rc) {return rc;/** * lpfc_sli4_async_mbox_unblock - Block posting SLI4 async mailbox command * @ phba : Pointer to HBA context object . * * The function unblocks and resume posting of SLI4 asynchronous mailbox * commands from the driver internal pending mailbox queue . It makes sure * that there is no outstanding mailbox command before resuming posting * asynchronous mailbox commands . If , for any reason , there is outstanding * mailbox command , it will try to wait it out before resuming asynchronous * mailbox command posting . static void struct lpfc_hba *phba)struct lpfc_sli *psli = &phba->sli;if (!(psli->sli_flag & LPFC_SLI_ASYNC_MBX_BLK)) {/* Asynchronous mailbox posting is not blocked, do nothing */ return ;/* Outstanding synchronous mailbox command is guaranteed to be done, * successful or timeout , after timing - out the outstanding mailbox * command shall always be removed , so just unblock posting async * mailbox command and resume /* wake up worker thread to post asynchronous mailbox command */ /** * lpfc_sli4_wait_bmbx_ready - Wait for bootstrap mailbox register ready * @ phba : Pointer to HBA context object . * @ mboxq : Pointer to mailbox object . * * The function waits for the bootstrap mailbox register ready bit from * port for twice the regular mailbox command timeout value . * * 0 - no timeout on waiting for bootstrap mailbox register ready . * MBXERR_ERROR - wait for bootstrap mailbox register timed out or port * is in an unrecoverable state . static int struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)unsigned long timeout;struct lpfc_register bmbx_reg;struct lpfc_register portstat_reg = {-1 };/* Sanity check - there is no point to wait if the port is in an * unrecoverable state . if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) >=if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,"3858 Skipping bmbx ready because " "Port Status x%x\n" ,return MBXERR_ERROR;do {if (!db_ready)2 );if (time_after(jiffies, timeout))return MBXERR_ERROR;while (!db_ready);return 0 ;/** * lpfc_sli4_post_sync_mbox - Post an SLI4 mailbox to the bootstrap mailbox * @ phba : Pointer to HBA context object . * @ mboxq : Pointer to mailbox object . * * The function posts a mailbox to the port . The mailbox is expected * to be comletely filled in and ready for the port to operate on it . * This routine executes a synchronous completion operation on the * mailbox by polling for its completion . * * The caller must not be holding any locks when calling this routine . * * Returns : * MBX_SUCCESS - mailbox posted successfully * Any of the MBX error values . static int struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)int rc = MBX_SUCCESS;unsigned long iflag;struct lpfc_sli *psli = &phba->sli;struct lpfc_mqe *mb = &mboxq->u.mqe;struct lpfc_bmbx_create *mbox_rgn;struct dma_address *dma_address;/* * Only one mailbox can be active to the bootstrap mailbox region * at a time and there is no queueing provided . if (psli->sli_flag & LPFC_SLI_MBOX_ACTIVE) {"(%d):2532 Mailbox command x%x (x%x/x%x) " "cannot issue Data: x%x x%x\n" ,0 ,return MBXERR_ERROR;/* The server grabs the token and owns it until release */ /* wait for bootstrap mbox register for readyness */ if (rc)goto exit ;/* * Initialize the bootstrap memory region to avoid stale data areas * in the mailbox post . Then copy the caller ' s mailbox contents to * the bmbx mailbox region . 0 , sizeof (struct lpfc_bmbx_create));sizeof (struct lpfc_mqe));/* Post the high mailbox dma address to the port and wait for ready. */ /* wait for bootstrap mbox register for hi-address write done */ if (rc)goto exit ;/* Post the low mailbox dma address to the port. */ /* wait for bootstrap mbox register for low address write done */ if (rc)goto exit ;/* * Read the CQ to ensure the mailbox has completed . * If so , update the mailbox status so that the upper layers * can complete the request normally . sizeof (struct lpfc_mqe));struct lpfc_bmbx_create *) phba->sli4_hba.bmbx.avirt;sizeof (struct lpfc_mcqe));/* * When the CQE status indicates a failure and the mailbox status * indicates success then copy the CQE status into the mailbox status * ( and prefix it with x4000 ) . if (mcqe_status != MB_CQE_STATUS_SUCCESS) {if (bf_get(lpfc_mqe_status, mb) == MBX_SUCCESS)else "(%d):0356 Mailbox cmd x%x (x%x/x%x) Status x%x " "Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x x%x x%x" " x%x x%x CQ: x%x x%x x%x x%x\n" ,0 , mbx_cmnd,0 ], mb->un.mb_words[1 ],2 ], mb->un.mb_words[3 ],4 ], mb->un.mb_words[5 ],6 ], mb->un.mb_words[7 ],8 ], mb->un.mb_words[9 ],10 ], mb->un.mb_words[11 ],12 ], mboxq->mcqe.word0,exit :/* We are holding the token, no needed for lock when release */ return rc;/** * lpfc_sli_issue_mbox_s4 - Issue an SLI4 mailbox command to firmware * @ phba : Pointer to HBA context object . * @ mboxq : Pointer to mailbox object . * @ flag : Flag indicating how the mailbox need to be processed . * * This function is called by discovery code and HBA management code to submit * a mailbox command to firmware with SLI - 4 interface spec . * * Return codes the caller owns the mailbox command after the return of the * function . static int struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq,struct lpfc_sli *psli = &phba->sli;unsigned long iflags;int rc;/* dump from issue mailbox command if setup */ if (unlikely(rc)) {"(%d):2544 Mailbox command x%x (x%x/x%x) " "cannot issue Data: x%x x%x\n" ,0 ,goto out_not_finished;/* Detect polling mode and jump to a handler */ if (!phba->sli4_hba.intr_enable) {if (flag == MBX_POLL)else if (rc != MBX_SUCCESS)"(%d):2541 Mailbox command x%x " "(x%x/x%x) failure: " "mqe_sta: x%x mcqe_sta: x%x/x%x " "Data: x%x x%x\n" ,0 ,return rc;else if (flag == MBX_POLL) {"(%d):2542 Try to issue mailbox command " "x%x (x%x/x%x) synchronously ahead of async " "mailbox command queue: x%x x%x\n" ,0 ,/* Try to block the asynchronous mailbox posting */ if (!rc) {/* Successfully blocked, now issue sync mbox cmd */ if (rc != MBX_SUCCESS)"(%d):2597 Sync Mailbox command " "x%x (x%x/x%x) failure: " "mqe_sta: x%x mcqe_sta: x%x/x%x " "Data: x%x x%x\n" ,0 ,/* Unblock the async mailbox posting afterward */ return rc;/* Now, interrupt mode asynchronous mailbox command */ if (rc) {"(%d):2543 Mailbox command x%x (x%x/x%x) " "cannot issue Data: x%x x%x\n" ,0 ,goto out_not_finished;/* Put the mailbox command to the driver internal FIFO */ "(%d):0354 Mbox cmd issue - Enqueue Data: " "x%x (x%x/x%x) x%x x%x x%x x%x\n" ,0 xffffff,/* Wake up worker thread to transport mailbox command from head */ return MBX_BUSY;return MBX_NOT_FINISHED;/** * lpfc_sli4_post_async_mbox - Post an SLI4 mailbox command to device * @ phba : Pointer to HBA context object . * * This function is called by worker thread to send a mailbox command to * SLI4 HBA firmware . * int struct lpfc_hba *phba)struct lpfc_sli *psli = &phba->sli;int rc = MBX_SUCCESS;unsigned long iflags;struct lpfc_mqe *mqe;/* Check interrupt mode before post async mailbox command */ if (unlikely(!phba->sli4_hba.intr_enable))return MBX_NOT_FINISHED;/* Check for mailbox command service token */ if (unlikely(psli->sli_flag & LPFC_SLI_ASYNC_MBX_BLK)) {return MBX_NOT_FINISHED;if (psli->sli_flag & LPFC_SLI_MBOX_ACTIVE) {return MBX_NOT_FINISHED;if (unlikely(phba->sli.mbox_active)) {"0384 There is pending active mailbox cmd\n" );return MBX_NOT_FINISHED;/* Take the mailbox command service token */ /* Get the next mailbox command from head of queue */ /* If no more mailbox command waiting for post, we're done */ if (!mboxq) {return MBX_SUCCESS;/* Check device readiness for posting mailbox command */ if (unlikely(rc))/* Driver clean routine will clean up pending mailbox */ goto out_not_finished;/* Prepare the mbox command to be posted */ /* Start timer for the mbox_tmo and log some mailbox post messages */ "(%d):0355 Mailbox cmd x%x (x%x/x%x) issue Data: " "x%x x%x\n" ,0 , mbx_cmnd,if (mbx_cmnd != MBX_HEARTBEAT) {if (mboxq->vport) {"MBOX Send vport: cmd:x%x mb:x%x x%x" ,0 ],1 ]);else {"MBOX Send: cmd:x%x mb:x%x x%x" ,0 ],1 ]);/* Post the mailbox command to the port */ if (rc != MBX_SUCCESS) {"(%d):2533 Mailbox command x%x (x%x/x%x) " "cannot issue Data: x%x x%x\n" ,0 ,goto out_not_finished;return rc;if (phba->sli.mbox_active) {/* Release the token */ return MBX_NOT_FINISHED;/** * lpfc_sli_issue_mbox - Wrapper func for issuing mailbox command * @ phba : Pointer to HBA context object . * @ pmbox : Pointer to mailbox object . * @ flag : Flag indicating how the mailbox need to be processed . * * This routine wraps the actual SLI3 or SLI4 mailbox issuing routine from * the API jump table function pointer from the lpfc_hba struct . * * Return codes the caller owns the mailbox command after the return of the * function . int struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox, uint32_t flag)return phba->lpfc_sli_issue_mbox(phba, pmbox, flag);/** * lpfc_mbox_api_table_setup - Set up mbox api function jump table * @ phba : The hba struct for which this call is being executed . * @ dev_grp : The HBA PCI - Device group number . * * This routine sets up the mbox interface API function jump table in @ phba * struct . * Returns : 0 - success , - ENODEV - failure . int struct lpfc_hba *phba, uint8_t dev_grp)switch (dev_grp) {case LPFC_PCI_DEV_LP:break ;case LPFC_PCI_DEV_OC:break ;default :"1420 Invalid HBA PCI-device group: 0x%x\n" ,return -ENODEV;return 0 ;/** * _ _ lpfc_sli_ringtx_put - Add an iocb to the txq * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ piocb : Pointer to address of newly added command iocb . * * This function is called with hbalock held for SLI3 ports or * the ring lock held for SLI4 ports to add a command * iocb to the txq when SLI layer cannot submit the command iocb * to the ring . void struct lpfc_hba *phba, struct lpfc_sli_ring *pring,struct lpfc_iocbq *piocb)if (phba->sli_rev == LPFC_SLI_REV4)else /* Insert the caller's iocb in the txq tail for later processing. */ /** * lpfc_sli_next_iocb - Get the next iocb in the txq * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ piocb : Pointer to address of newly added command iocb . * * This function is called with hbalock held before a new * iocb is submitted to the firmware . This function checks * txq to flush the iocbs in txq to Firmware before * submitting new iocbs to the Firmware . * If there are iocbs in the txq which need to be submitted * to firmware , lpfc_sli_next_iocb returns the first element * of the txq after dequeuing it from txq . * If there is no iocb in the txq then the function will return * * piocb and * piocb is set to NULL . Caller needs to check * * piocb to find if there are more commands in the txq . static struct lpfc_iocbq *struct lpfc_hba *phba, struct lpfc_sli_ring *pring,struct lpfc_iocbq **piocb)struct lpfc_iocbq * nextiocb;if (!nextiocb) {return nextiocb;/** * _ _ lpfc_sli_issue_iocb_s3 - SLI3 device lockless ver of lpfc_sli_issue_iocb * @ phba : Pointer to HBA context object . * @ ring_number : SLI ring number to issue iocb on . * @ piocb : Pointer to command iocb . * @ flag : Flag indicating if this command can be put into txq . * * _ _ lpfc_sli_issue_iocb_s3 is used by other functions in the driver to issue * an iocb command to an HBA with SLI - 3 interface spec . If the PCI slot is * recovering from error state , if HBA is resetting or if LPFC_STOP_IOCB_EVENT * flag is turned on , the function returns IOCB_ERROR . When the link is down , * this function allows only iocbs for posting buffers . This function finds * next available slot in the command ring and posts the command to the * available slot and writes the port attention register to request HBA start * processing new iocb . If there is no slot available in the ring and * flag & SLI_IOCB_RET_IOCB is set , the new iocb is added to the txq , otherwise * the function returns IOCB_BUSY . * * This function is called with hbalock held . The function will return success * after it successfully submit the iocb to firmware or after adding to the * txq . static int struct lpfc_hba *phba, uint32_t ring_number,struct lpfc_iocbq *piocb, uint32_t flag)struct lpfc_iocbq *nextiocb;struct lpfc_sli_ring *pring = &phba->sli.sli3_ring[ring_number];if (piocb->cmd_cmpl && (!piocb->vport) &&"1807 IOCB x%x failed. No vport\n" ,return IOCB_ERROR;/* If the PCI channel is in offline state, do not post iocbs. */ if (unlikely(pci_channel_offline(phba->pcidev)))return IOCB_ERROR;/* If HBA has a deferred error attention, fail the iocb. */ if (unlikely(test_bit(DEFER_ERATT, &phba->hba_flag)))return IOCB_ERROR;/* * We should never get an IOCB if we are in a < LINK_DOWN state if (unlikely(phba->link_state < LPFC_LINK_DOWN))return IOCB_ERROR;/* * Check to see if we are blocking IOCB processing because of a * outstanding event . if (unlikely(pring->flag & LPFC_STOP_IOCB_EVENT))goto iocb_busy;if (unlikely(phba->link_state == LPFC_LINK_DOWN)) {/* * Only CREATE_XRI , CLOSE_XRI , and QUE_RING_BUF * can be issued if the link is not up . switch (piocb->iocb.ulpCommand) {case CMD_QUE_RING_BUF_CN:case CMD_QUE_RING_BUF64_CN:/* * For IOCBs , like QUE_RING_BUF , that have no rsp ring * completion , cmd_cmpl MUST be 0 . if (piocb->cmd_cmpl)case CMD_CREATE_XRI_CR:case CMD_CLOSE_XRI_CN:case CMD_CLOSE_XRI_CX:break ;default :goto iocb_busy;/* * For FCP commands , we must be in a state where we can process link * attention events . else if (unlikely(pring->ringno == LPFC_FCP_RING &&goto iocb_busy;while ((iocb = lpfc_sli_next_iocb_slot(phba, pring)) &&if (iocb)else if (!piocb)return IOCB_SUCCESS;goto out_busy;if (!(flag & SLI_IOCB_RET_IOCB)) {return IOCB_SUCCESS;return IOCB_BUSY;/** * _ _ lpfc_sli_issue_fcp_io_s3 - SLI3 device for sending fcp io iocb * @ phba : Pointer to HBA context object . * @ ring_number : SLI ring number to issue wqe on . * @ piocb : Pointer to command iocb . * @ flag : Flag indicating if this command can be put into txq . * * _ _ lpfc_sli_issue_fcp_io_s3 is wrapper function to invoke lockless func to * send an iocb command to an HBA with SLI - 3 interface spec . * * This function takes the hbalock before invoking the lockless version . * The function will return success after it successfully submit the wqe to * firmware or after adding to the txq . static int struct lpfc_hba *phba, uint32_t ring_number,struct lpfc_iocbq *piocb, uint32_t flag)unsigned long iflags;int rc;return rc;/** * _ _ lpfc_sli_issue_fcp_io_s4 - SLI4 device for sending fcp io wqe * @ phba : Pointer to HBA context object . * @ ring_number : SLI ring number to issue wqe on . * @ piocb : Pointer to command iocb . * @ flag : Flag indicating if this command can be put into txq . * * _ _ lpfc_sli_issue_fcp_io_s4 is used by other functions in the driver to issue * an wqe command to an HBA with SLI - 4 interface spec . * * This function is a lockless version . The function will return success * after it successfully submit the wqe to firmware or after adding to the * txq . static int struct lpfc_hba *phba, uint32_t ring_number,struct lpfc_iocbq *piocb, uint32_t flag)struct lpfc_io_buf *lpfc_cmd = piocb->io_buf;return lpfc_sli4_issue_wqe(phba, lpfc_cmd->hdwq, piocb);void struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)struct lpfc_iocbq *piocb = &lpfc_cmd->cur_iocbq;union lpfc_wqe128 *wqe = &lpfc_cmd->cur_iocbq.wqe;struct sli4_sge_le *sgl;/* 128 byte wqe support here */ struct sli4_sge_le *)lpfc_cmd->dma_sgl;if (phba->fcp_embed_io) {struct fcp_cmnd *fcp_cmnd;/* Word 0-2 - FCP_CMND */ 0 ;72 ; /* Word 18 */ 1 );0 );/* Word 18-29 FCP CMND Payload */ 18 ];else {/* Word 0-2 - Inline BDE */ /* Word 10 */ 1 );0 );/* add the VMID tags as per switch response */ if (unlikely(piocb->cmd_flag & LPFC_IO_VMID)) {if (phba->pport->vmid_flag & LPFC_VMID_TYPE_PRIO) {1 );else if (phba->cfg_vmid_app_header) {1 );1 );31 ] = piocb->vmid_tag.app_id;/** * _ _ lpfc_sli_issue_iocb_s4 - SLI4 device lockless ver of lpfc_sli_issue_iocb * @ phba : Pointer to HBA context object . * @ ring_number : SLI ring number to issue iocb on . * @ piocb : Pointer to command iocb . * @ flag : Flag indicating if this command can be put into txq . * * _ _ lpfc_sli_issue_iocb_s4 is used by other functions in the driver to issue * an iocb command to an HBA with SLI - 4 interface spec . * * This function is called with ringlock held . The function will return success * after it successfully submit the iocb to firmware or after adding to the * txq . static int struct lpfc_hba *phba, uint32_t ring_number,struct lpfc_iocbq *piocb, uint32_t flag)struct lpfc_sglq *sglq;union lpfc_wqe128 *wqe;struct lpfc_queue *wq;struct lpfc_sli_ring *pring;/* Get the WQ */ if ((piocb->cmd_flag & LPFC_IO_FCP) ||else {/* Get corresponding ring */ /* * The WQE can be either 64 or 128 bytes , if (piocb->sli4_xritag == NO_XRI) {if (ulp_command == CMD_ABORT_XRI_CX)else {if (!sglq) {if (!(flag & SLI_IOCB_RET_IOCB)) {return IOCB_SUCCESS;else {return IOCB_BUSY;else if (piocb->cmd_flag & LPFC_IO_FCP) {/* These IO's already have an XRI and a mapped sgl. */ else {/* * This is a continuation of a commandi , ( CX ) so this * sglq is on the active list if (!sglq)return IOCB_ERROR;if (sglq) {/* ABTS sent by initiator to CT exchange, the * RX_ID field will be filled with the newly * allocated responder XRI . if (ulp_command == CMD_XMIT_BLS_RSP64_CX &&if (lpfc_wqe_bpl2sgl(phba, piocb, sglq) == NO_XRI)return IOCB_ERROR;if (lpfc_sli4_wq_put(wq, wqe))return IOCB_ERROR;return 0 ;/* * lpfc_sli_issue_fcp_io - Wrapper func for issuing fcp i / o * * This routine wraps the actual fcp i / o function for issusing WQE for sli - 4 * or IOCB for sli - 3 function . * pointer from the lpfc_hba struct . * * Return codes : * IOCB_ERROR - Error * IOCB_SUCCESS - Success * IOCB_BUSY - Busy int struct lpfc_hba *phba, uint32_t ring_number,struct lpfc_iocbq *piocb, uint32_t flag)return phba->__lpfc_sli_issue_fcp_io(phba, ring_number, piocb, flag);/* * _ _ lpfc_sli_issue_iocb - Wrapper func of lockless version for issuing iocb * * This routine wraps the actual lockless version for issusing IOCB function * pointer from the lpfc_hba struct . * * Return codes : * IOCB_ERROR - Error * IOCB_SUCCESS - Success * IOCB_BUSY - Busy int struct lpfc_hba *phba, uint32_t ring_number,struct lpfc_iocbq *piocb, uint32_t flag)return phba->__lpfc_sli_issue_iocb(phba, ring_number, piocb, flag);static void struct lpfc_iocbq *cmdiocbq,struct lpfc_vport *vport,struct lpfc_dmabuf *bmp, u16 cmd_size, u32 did,struct lpfc_hba *phba = vport->phba;0 , sizeof (*cmd));if (expect_rsp) {2 * sizeof (struct ulp_bde64));/* DID */ else {sizeof (struct ulp_bde64);/* DID */ 1 ;1 ;/* If we have NPIV enabled, we want to send ELS traffic by VPI. */ if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {if (expect_rsp) {/* For ELS_REQUEST64_CR, use the VPI by default */ 0 ;/* The CT field must be 0=INVALID_RPI for the ECHO cmd */ if (elscmd == ELS_CMD_ECHO)0 ; /* context = invalid RPI */ else 1 ; /* context = VPI */ static void struct lpfc_iocbq *cmdiocbq,struct lpfc_vport *vport,struct lpfc_dmabuf *bmp, u16 cmd_size, u32 did,struct lpfc_hba *phba = vport->phba;union lpfc_wqe128 *wqe;struct ulp_bde64_le *bde;0 , sizeof (*wqe));/* Word 0 - 2 BDE */ struct ulp_bde64_le *)&wqe->generic.bde;if (expect_rsp) {/* Transfer length */ /* DID */ /* Word 11 - ELS_ID */ switch (elscmd) {case ELS_CMD_PLOGI:break ;case ELS_CMD_FLOGI:break ;case ELS_CMD_LOGO:break ;case ELS_CMD_FDISC:if (!vport->fc_myDID) {break ;default :break ;else {/* DID */ /* Transfer length */ /* If we have NPIV enabled, we want to send ELS traffic by VPI. * For SLI4 , since the driver controls VPIs we also want to include * all ELS pt2pt protocol traffic as well . if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) ||if (expect_rsp) {/* For ELS_REQUEST64_WQE, use the VPI by default */ /* The CT field must be 0=INVALID_RPI for the ECHO cmd */ if (elscmd == ELS_CMD_ECHO)0 );else 1 );void struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocbq,struct lpfc_vport *vport, struct lpfc_dmabuf *bmp,static void struct lpfc_iocbq *cmdiocbq, struct lpfc_dmabuf *bmp,0 , sizeof (*cmd));sizeof (struct ulp_bde64);1 ;1 ;static void struct lpfc_iocbq *cmdiocbq, struct lpfc_dmabuf *bmp,union lpfc_wqe128 *cmdwqe;struct ulp_bde64_le *bde, *bpl;0 , total_len = 0 , size, type, i;0 , sizeof (*cmdwqe));/* Calculate total_len and xmit_len */ struct ulp_bde64_le *)bmp->virt;for (i = 0 ; i < num_entry; i++) {for (i = 0 ; i < num_entry; i++) {if (type != ULP_BDE64_TYPE_BDE_64)break ;/* Words 0 - 2 */ struct ulp_bde64_le *)&cmdwqe->generic.bde;/* Word 3 */ /* Word 5 */ 1 );1 );/* Word 6 */ /* Word 7 */ /* Word 12 */ void struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocbq,struct lpfc_dmabuf *bmp, u16 rpi, u32 num_entry, u8 tmo)static void struct lpfc_iocbq *cmdiocbq,struct lpfc_dmabuf *bmp, u16 rpi, u16 ox_id,0 , sizeof (*icmd));sizeof (struct ulp_bde64));if (last_seq)0 ;1 ;1 ;switch (cr_cx_cmd) {case CMD_XMIT_SEQUENCE64_CR:break ;case CMD_XMIT_SEQUENCE64_CX:break ;default :break ;static void struct lpfc_iocbq *cmdiocbq,struct lpfc_dmabuf *bmp, u16 rpi, u16 ox_id,union lpfc_wqe128 *wqe;struct ulp_bde64 *bpl;0 , sizeof (*wqe));/* Words 0 - 2 */ struct ulp_bde64 *)bmp->virt;/* Word 5 */ 1 );0 );/* Word 6 */ /* Word 7 */ /* Word 9 */ if (cmdiocbq->cmd_flag & (LPFC_IO_LIBDFC | LPFC_IO_LOOPBACK)) {/* Word 10 */ if (cmdiocbq->cmd_flag & LPFC_IO_VMID) {1 );1 );31 ] = LOOPBACK_SRC_APPID;/* Word 12 */ else void struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocbq,struct lpfc_dmabuf *bmp, u16 rpi, u16 ox_id,static void struct lpfc_iocbq *cmdiocbq, u16 ulp_context,bool ia,bool wqec)0 , sizeof (*icmd));/* Word 5 */ if (ia) {/* Word 7 */ else {/* Word 3 */ /* Word 7 */ /* Word 7 */ 1 ;static void struct lpfc_iocbq *cmdiocbq, u16 ulp_context,bool ia,bool wqec)union lpfc_wqe128 *wqe;0 , sizeof (*wqe));/* Word 3 */ if (ia)1 );else 0 );/* Word 7 */ /* Word 8 */ /* Word 9 */ /* Word 10 */ 1 );/* Word 11 */ if (wqec)1 );void struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocbq,bool ia, bool wqec)/** * lpfc_sli_api_table_setup - Set up sli api function jump table * @ phba : The hba struct for which this call is being executed . * @ dev_grp : The HBA PCI - Device group number . * * This routine sets up the SLI interface API function jump table in @ phba * struct . * Returns : 0 - success , - ENODEV - failure . int struct lpfc_hba *phba, uint8_t dev_grp)switch (dev_grp) {case LPFC_PCI_DEV_LP:break ;case LPFC_PCI_DEV_OC:break ;default :"1419 Invalid HBA PCI-device group: 0x%x\n" ,return -ENODEV;return 0 ;/** * lpfc_sli4_calc_ring - Calculates which ring to use * @ phba : Pointer to HBA context object . * @ piocb : Pointer to command iocb . * * For SLI4 only , FCP IO can deferred to one fo many WQs , based on * hba_wqidx , thus we need to calculate the corresponding ring . * Since ABORTS must go on the same WQ of the command they are * aborting , we use command ' s hba_wqidx . struct lpfc_sli_ring *struct lpfc_hba *phba, struct lpfc_iocbq *piocb)struct lpfc_io_buf *lpfc_cmd;if (piocb->cmd_flag & (LPFC_IO_FCP | LPFC_USE_FCPWQIDX)) {if (unlikely(!phba->sli4_hba.hdwq))return NULL;/* * for abort iocb hba_wqidx should already * be setup based on what work queue we used . if (!(piocb->cmd_flag & LPFC_USE_FCPWQIDX)) {return phba->sli4_hba.hdwq[piocb->hba_wqidx].io_wq->pring;else {if (unlikely(!phba->sli4_hba.els_wq))return NULL;0 ;return phba->sli4_hba.els_wq->pring;inline void lpfc_sli4_poll_eq(struct lpfc_queue *eq)struct lpfc_hba *phba = eq->phba;/* * Unlocking an irq is one of the entry point to check * for re - schedule , but we are good for io submission * path as midlayer does a get_cpu to glue us in . Flush * out the invalidate queue so we can see the updated * value for flag . if (READ_ONCE(eq->mode) == LPFC_EQ_POLL)/* We will not likely get the completion for the caller * during this iteration but i guess that ' s fine . * Future io ' s coming on this eq should be able to * pick it up . As for the case of single io ' s , they * will be handled through a sched from polling timer * function which is currently triggered every 1 msec . /** * lpfc_sli_issue_iocb - Wrapper function for _ _ lpfc_sli_issue_iocb * @ phba : Pointer to HBA context object . * @ ring_number : Ring number * @ piocb : Pointer to command iocb . * @ flag : Flag indicating if this command can be put into txq . * * lpfc_sli_issue_iocb is a wrapper around _ _ lpfc_sli_issue_iocb * function . This function gets the hbalock and calls * _ _ lpfc_sli_issue_iocb function and will return the error returned * by _ _ lpfc_sli_issue_iocb function . This wrapper is used by * functions which do not hold hbalock . int struct lpfc_hba *phba, uint32_t ring_number,struct lpfc_iocbq *piocb, uint32_t flag)struct lpfc_sli_ring *pring;struct lpfc_queue *eq;unsigned long iflags;int rc;/* If the PCI channel is in offline state, do not post iocbs. */ if (unlikely(pci_channel_offline(phba->pcidev)))return IOCB_ERROR;if (phba->sli_rev == LPFC_SLI_REV4) {if (unlikely(pring == NULL))return IOCB_ERROR;else {/* For now, SLI2/3 will still use hbalock */ return rc;/** * lpfc_extra_ring_setup - Extra ring setup function * @ phba : Pointer to HBA context object . * * This function is called while driver attaches with the * HBA to setup the extra ring . The extra ring is used * only when driver needs to support target mode functionality * or IP over FC functionalities . * * This function is called with no lock held . SLI3 only . static int struct lpfc_hba *phba)struct lpfc_sli *psli;struct lpfc_sli_ring *pring;/* Adjust cmd/rsp ring iocb entries more evenly */ /* Take some away from the FCP ring */ /* and give them to the extra ring */ /* Setup default profile for this ring */ 4096 ;1 ;0 ].profile = 0 ; /* Mask 0 */ 0 ].rctl = phba->cfg_multi_ring_rctl;0 ].type = phba->cfg_multi_ring_type;0 ].lpfc_sli_rcv_unsol_event = NULL;return 0 ;static void struct lpfc_hba *phba,struct lpfc_nodelist *ndlp)unsigned long iflags;struct lpfc_work_evt *evtp = &ndlp->recovery_evt;/* Hold a node reference for outstanding queued work */ if (!lpfc_nlp_get(ndlp))return ;if (!list_empty(&evtp->evt_listp)) {return ;/* lpfc_sli_abts_err_handler - handle a failed ABTS request from an SLI3 port. * @ phba : Pointer to HBA context object . * @ iocbq : Pointer to iocb object . * * The async_event handler calls this routine when it receives * an ASYNC_STATUS_CN event from the port . The port generates * this event when an Abort Sequence request to an rport fails * twice in succession . The abort could be originated by the * driver or by the port . The ABTS could have been for an ELS * or FCP IO . The port only generates this event when an ABTS * fails to complete after one retry . static void struct lpfc_hba *phba,struct lpfc_iocbq *iocbq)struct lpfc_nodelist *ndlp = NULL;0 , vpi = 0 ;struct lpfc_vport *vport = NULL;/* The rpi in the ulpContext is vport-sensitive. */ "3092 Port generated ABTS async event " "on vpi %d rpi %d status 0x%x\n" ,if (!vport)goto err_exit;if (!ndlp)goto err_exit;if (iocbq->iocb.ulpStatus == IOSTAT_LOCAL_REJECT)return ;"3095 Event Context not found, no " "action on vpi %d rpi %d status 0x%x, reason 0x%x\n" ,/* lpfc_sli4_abts_err_handler - handle a failed ABTS request from an SLI4 port. * @ phba : pointer to HBA context object . * @ ndlp : nodelist pointer for the impacted rport . * @ axri : pointer to the wcqe containing the failed exchange . * * The driver calls this routine when it receives an ABORT_XRI_FCP CQE from the * port . The port generates this event when an abort exchange request to an * rport fails twice in succession with no reply . The abort could be originated * by the driver or by the port . The ABTS could have been for an ELS or FCP IO . void struct lpfc_hba *phba,struct lpfc_nodelist *ndlp,struct sli4_wcqe_xri_aborted *axri)0 ;if (!ndlp) {"3115 Node Context not found, driver " "ignoring abts err event\n" );return ;"3116 Port generated FCP XRI ABORT event on " "vpi %d rpi %d xri x%x status 0x%x parameter x%x\n" ,/* * Catch the ABTS protocol failure case . Older OCe FW releases returned * LOCAL_REJECT and 0 for a failed ABTS exchange and later OCe and * LPe FW releases returned LOCAL_REJECT and SEQUENCE_TIMEOUT . if ((bf_get(lpfc_wcqe_xa_status, axri) == IOSTAT_LOCAL_REJECT) &&0 )))/** * lpfc_sli_async_event_handler - ASYNC iocb handler function * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ iocbq : Pointer to iocb object . * * This function is called by the slow ring event handler * function when there is an ASYNC event iocb in the ring . * This function is called with no lock held . * Currently this function handles only temperature related * ASYNC events . The function decodes the temperature sensor * event message and posts events for the management applications . static void struct lpfc_hba * phba,struct lpfc_sli_ring * pring, struct lpfc_iocbq * iocbq)struct temp_event temp_event_data;struct Scsi_Host *shost;switch (evt_code) {case ASYNC_TEMP_WARN:case ASYNC_TEMP_SAFE:if (evt_code == ASYNC_TEMP_WARN) {"0347 Adapter is very hot, please take " "corrective action. temperature : %d Celsius\n" ,else {"0340 Adapter temperature is OK now. " "temperature : %d Celsius\n" ,/* Send temperature change event to applications */ sizeof (temp_event_data), (char *) &temp_event_data,break ;case ASYNC_STATUS_CN:break ;default :"0346 Ring %d handler: unexpected ASYNC_STATUS" " evt_code 0x%x\n" "W0 0x%08x W1 0x%08x W2 0x%08x W3 0x%08x\n" "W4 0x%08x W5 0x%08x W6 0x%08x W7 0x%08x\n" "W8 0x%08x W9 0x%08x W10 0x%08x W11 0x%08x\n" "W12 0x%08x W13 0x%08x W14 0x%08x W15 0x%08x\n" ,0 ], iocb_w[1 ], iocb_w[2 ], iocb_w[3 ],4 ], iocb_w[5 ], iocb_w[6 ], iocb_w[7 ],8 ], iocb_w[9 ], iocb_w[10 ], iocb_w[11 ],12 ], iocb_w[13 ], iocb_w[14 ], iocb_w[15 ]);break ;/** * lpfc_sli4_setup - SLI ring setup function * @ phba : Pointer to HBA context object . * * lpfc_sli_setup sets up rings of the SLI interface with * number of iocbs per ring and iotags . This function is * called while driver attach to the HBA and before the * interrupts are enabled . So there is no need for locking . * * This function always returns 0 . int struct lpfc_hba *phba)struct lpfc_sli_ring *pring;0 ].profile = 0 ; /* Mask 0 */ 0 ].rctl = FC_RCTL_ELS_REQ;0 ].type = FC_TYPE_ELS;0 ].lpfc_sli_rcv_unsol_event =1 ].profile = 0 ; /* Mask 1 */ 1 ].rctl = FC_RCTL_ELS_REP;1 ].type = FC_TYPE_ELS;1 ].lpfc_sli_rcv_unsol_event =2 ].profile = 0 ; /* Mask 2 */ /* NameServer Inquiry */ 2 ].rctl = FC_RCTL_DD_UNSOL_CTL;/* NameServer */ 2 ].type = FC_TYPE_CT;2 ].lpfc_sli_rcv_unsol_event =3 ].profile = 0 ; /* Mask 3 */ /* NameServer response */ 3 ].rctl = FC_RCTL_DD_SOL_CTL;/* NameServer */ 3 ].type = FC_TYPE_CT;3 ].lpfc_sli_rcv_unsol_event =return 0 ;/** * lpfc_sli_setup - SLI ring setup function * @ phba : Pointer to HBA context object . * * lpfc_sli_setup sets up rings of the SLI interface with * number of iocbs per ring and iotags . This function is * called while driver attach to the HBA and before the * interrupts are enabled . So there is no need for locking . * * This function always returns 0 . SLI3 only . int struct lpfc_hba *phba)int i, totiocbsize = 0 ;struct lpfc_sli *psli = &phba->sli;struct lpfc_sli_ring *pring;0 ;0 ;0 ;for (i = 0 ; i < psli->num_rings; i++) {switch (i) {case LPFC_FCP_RING: /* ring 0 - FCP */ /* numCiocb and numRiocb are used in config_port */ 3 ) ?3 ) ?0 ;2 );0 ;break ;case LPFC_EXTRA_RING: /* ring 1 - EXTRA */ /* numCiocb and numRiocb are used in config_port */ 3 ) ?3 ) ?0 ;break ;case LPFC_ELS_RING: /* ring 2 - ELS / CT */ /* numCiocb and numRiocb are used in config_port */ 3 ) ?3 ) ?0 ;0 ;4096 ;0 ].profile = 0 ; /* Mask 0 */ 0 ].rctl = FC_RCTL_ELS_REQ;0 ].type = FC_TYPE_ELS;0 ].lpfc_sli_rcv_unsol_event =1 ].profile = 0 ; /* Mask 1 */ 1 ].rctl = FC_RCTL_ELS_REP;1 ].type = FC_TYPE_ELS;1 ].lpfc_sli_rcv_unsol_event =2 ].profile = 0 ; /* Mask 2 */ /* NameServer Inquiry */ 2 ].rctl = FC_RCTL_DD_UNSOL_CTL;/* NameServer */ 2 ].type = FC_TYPE_CT;2 ].lpfc_sli_rcv_unsol_event =3 ].profile = 0 ; /* Mask 3 */ /* NameServer response */ 3 ].rctl = FC_RCTL_DD_SOL_CTL;/* NameServer */ 3 ].type = FC_TYPE_CT;3 ].lpfc_sli_rcv_unsol_event =break ;if (totiocbsize > MAX_SLIM_IOCB_SIZE) {/* Too many cmd / rsp ring entries in SLI2 SLIM */ "%d:0462 Too many cmd / rsp ring entries in " "SLI2 SLIM Data: x%x x%lx\n" ,unsigned long ) MAX_SLIM_IOCB_SIZE);if (phba->cfg_multi_ring_support == 2 )return 0 ;/** * lpfc_sli4_queue_init - Queue initialization function * @ phba : Pointer to HBA context object . * * lpfc_sli4_queue_init sets up mailbox queues and iocb queues for each * ring . This function also initializes ring indices of each ring . * This function is called during the initialization of the SLI * interface of an HBA . * This function is called with no lock held and always returns * 1 . void struct lpfc_hba *phba)struct lpfc_sli *psli;struct lpfc_sli_ring *pring;int i;/* Initialize list headers for txq and txcmplq as double linked lists */ for (i = 0 ; i < phba->cfg_hdw_queue; i++) {0 ;0 ;0 ;0 ;if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {0 ;0 ;/** * lpfc_sli_queue_init - Queue initialization function * @ phba : Pointer to HBA context object . * * lpfc_sli_queue_init sets up mailbox queues and iocb queues for each * ring . This function also initializes ring indices of each ring . * This function is called during the initialization of the SLI * interface of an HBA . * This function is called with no lock held and always returns * 1 . void struct lpfc_hba *phba)struct lpfc_sli *psli;struct lpfc_sli_ring *pring;int i;/* Initialize list headers for txq and txcmplq as double linked lists */ for (i = 0 ; i < psli->num_rings; i++) {0 ;0 ;0 ;0 ;/** * lpfc_sli_mbox_sys_flush - Flush mailbox command sub - system * @ phba : Pointer to HBA context object . * * This routine flushes the mailbox command subsystem . It will unconditionally * flush all the mailbox commands in the three possible stages in the mailbox * command sub - system : pending mailbox command queue ; the outstanding mailbox * command ; and completed mailbox command queue . It is caller ' s responsibility * to make sure that the driver is in the proper state to flush the mailbox * command sub - system . Namely , the posting of mailbox commands into the * pending mailbox command queue from the various clients must be stopped ; * either the HBA is in a state that it will never works on the outstanding * mailbox command ( such as in EEH or ERATT conditions ) or the outstanding * mailbox command has been completed . static void struct lpfc_hba *phba)struct lpfc_sli *psli = &phba->sli;unsigned long iflag;/* Disable softirqs, including timers from obtaining phba->hbalock */ /* Flush all the mailbox commands in the mbox system */ /* The pending mailbox command queue */ /* The outstanding active mailbox command */ if (psli->mbox_active) {/* The completed mailbox command queue */ /* Enable softirqs again, done with phba->hbalock */ /* Return all flushed mailbox commands with MBX_NOT_FINISHED status */ while (!list_empty(&completions)) {if (pmb->mbox_cmpl)/** * lpfc_sli_host_down - Vport cleanup function * @ vport : Pointer to virtual port object . * * lpfc_sli_host_down is called to clean up the resources * associated with a vport before destroying virtual * port data structures . * This function does following operations : * - Free discovery resources associated with this virtual * port . * - Free iocbs associated with this virtual port in * the txq . * - Send abort for all iocb commands associated with this * vport in txcmplq . * * This function is called with no lock held and always returns 1 . int struct lpfc_vport *vport)struct lpfc_hba *phba = vport->phba;struct lpfc_sli *psli = &phba->sli;struct lpfc_queue *qp = NULL;struct lpfc_sli_ring *pring;struct lpfc_iocbq *iocb, *next_iocb;int i;unsigned long flags = 0 ;/* * Error everything on the txq since these iocbs * have not been given to the FW yet . * Also issue ABTS for everything on the txcmplq if (phba->sli_rev != LPFC_SLI_REV4) {for (i = 0 ; i < psli->num_rings; i++) {/* Only slow rings */ if (pring->ringno == LPFC_ELS_RING) {/* Set the lpfc data pending flag */ if (iocb->vport != vport)continue ;if (iocb->vport != vport)continue ;else {if (!pring)continue ;if (pring == phba->sli4_hba.els_wq->pring) {/* Set the lpfc data pending flag */ if (iocb->vport != vport)continue ;if (iocb->vport != vport)continue ;/* Make sure HBA is alive */ /* Cancel all the IOCBs from the completions list */ return 1 ;/** * lpfc_sli_hba_down - Resource cleanup function for the HBA * @ phba : Pointer to HBA context object . * * This function cleans up all iocb , buffers , mailbox commands * while shutting down the HBA . This function is called with no * lock held and always returns 1 . * This function does the following to cleanup driver resources : * - Free discovery resources for each virtual port * - Cleanup any pending fabric iocbs * - Iterate through the iocb txq and free each entry * in the list . * - Free up any buffer posted to the HBA * - Free mailbox commands in the mailbox queue . int struct lpfc_hba *phba)struct lpfc_sli *psli = &phba->sli;struct lpfc_queue *qp = NULL;struct lpfc_sli_ring *pring;struct lpfc_dmabuf *buf_ptr;unsigned long flags = 0 ;int i;/* Shutdown the mailbox command sub-system */ /* Disable softirqs, including timers from obtaining phba->hbalock */ /* * Error everything on the txq since these iocbs * have not been given to the FW yet . if (phba->sli_rev != LPFC_SLI_REV4) {for (i = 0 ; i < psli->num_rings; i++) {/* Only slow rings */ if (pring->ringno == LPFC_ELS_RING) {/* Set the lpfc data pending flag */ else {if (!pring)continue ;if (pring == phba->sli4_hba.els_wq->pring) {/* Set the lpfc data pending flag */ /* Cancel all the IOCBs from the completions list */ 0 ;0 ;while (!list_empty(&completions)) {struct lpfc_dmabuf, list);/* Enable softirqs again, done with phba->hbalock */ /* Return any active mbox cmds */ return 1 ;/** * lpfc_sli_pcimem_bcopy - SLI memory copy function * @ srcp : Source memory pointer . * @ destp : Destination memory pointer . * @ cnt : Number of words required to be copied . * * This function is used for copying data between driver memory * and the SLI memory . This function also changes the endianness * of each word if native endianness is different from SLI * endianness . This function can be called with or without * lock . void void *srcp, void *destp, uint32_t cnt)int i;for (i = 0 ; i < (int )cnt; i += sizeof (uint32_t)) {/** * lpfc_sli_bemem_bcopy - SLI memory copy function * @ srcp : Source memory pointer . * @ destp : Destination memory pointer . * @ cnt : Number of words required to be copied . * * This function is used for copying data between a data structure * with big endian representation to local endianness . * This function can be called with or without lock . void void *srcp, void *destp, uint32_t cnt)int i;for (i = 0 ; i < (int )cnt; i += sizeof (uint32_t)) {/** * lpfc_sli_ringpostbuf_put - Function to add a buffer to postbufq * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ mp : Pointer to driver buffer object . * * This function is called with no lock held . * It always return zero after adding the buffer to the postbufq * buffer list . int struct lpfc_hba *phba, struct lpfc_sli_ring *pring,struct lpfc_dmabuf *mp)/* Stick struct lpfc_dmabuf at end of postbufq so driver can look it up return 0 ;/** * lpfc_sli_get_buffer_tag - allocates a tag for a CMD_QUE_XRI64_CX buffer * @ phba : Pointer to HBA context object . * * When HBQ is enabled , buffers are searched based on tags . This function * allocates a tag for buffer posted using CMD_QUE_XRI64_CX iocb . The * tag is bit wise or - ed with QUE_BUFTAG_BIT to make sure that the tag * does not conflict with tags of buffer posted for unsolicited events . * The function returns the allocated tag . The function is called with * no locks held . struct lpfc_hba *phba)/* * Always set the QUE_BUFTAG_BIT to distiguish between * a tag assigned by HBQ . return phba->buffer_tag_count;/** * lpfc_sli_ring_taggedbuf_get - find HBQ buffer associated with given tag * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ tag : Buffer tag . * * Buffers posted using CMD_QUE_XRI64_CX iocb are in pring - > postbufq * list . After HBA DMA data to these buffers , CMD_IOCB_RET_XRI64_CX * iocb is posted to the response ring with the tag of the buffer . * This function searches the pring - > postbufq list using the tag * to find buffer associated with CMD_IOCB_RET_XRI64_CX * iocb . If the buffer is found then lpfc_dmabuf object of the * buffer is returned to the caller else NULL is returned . * This function is called with no lock held . struct lpfc_dmabuf *struct lpfc_hba *phba, struct lpfc_sli_ring *pring,struct lpfc_dmabuf *mp, *next_mp;struct list_head *slp = &pring->postbufq;/* Search postbufq, from the beginning, looking for a match on tag */ if (mp->buffer_tag == tag) {return mp;"0402 Cannot find virtual addr for buffer tag on " "ring %d Data x%lx x%px x%px x%x\n" ,unsigned long ) tag,return NULL;/** * lpfc_sli_ringpostbuf_get - search buffers for unsolicited CT and ELS events * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ phys : DMA address of the buffer . * * This function searches the buffer list using the dma_address * of unsolicited event to find the driver ' s lpfc_dmabuf object * corresponding to the dma_address . The function returns the * lpfc_dmabuf object if a buffer is found else it returns NULL . * This function is called by the ct and els unsolicited event * handlers to get the buffer associated with the unsolicited * event . * * This function is called with no lock held . struct lpfc_dmabuf *struct lpfc_hba *phba, struct lpfc_sli_ring *pring,struct lpfc_dmabuf *mp, *next_mp;struct list_head *slp = &pring->postbufq;/* Search postbufq, from the beginning, looking for a match on phys */ if (mp->phys == phys) {return mp;"0410 Cannot find virtual addr for mapped buf on " "ring %d Data x%llx x%px x%px x%x\n" ,unsigned long long )phys,return NULL;/** * lpfc_sli_abort_els_cmpl - Completion handler for the els abort iocbs * @ phba : Pointer to HBA context object . * @ cmdiocb : Pointer to driver command iocb object . * @ rspiocb : Pointer to driver response iocb object . * * This function is the completion handler for the abort iocbs for * ELS commands . This function is called from the ELS ring event * handler with no lock held . This function frees memory resources * associated with the abort iocb . static void struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,struct lpfc_iocbq *rspiocb)if (ulp_status) {/* * Assume that the port already completed and returned , or * will return the iocb . Just Log the message . if (phba->sli_rev < LPFC_SLI_REV4) {if (cmnd == CMD_ABORT_XRI_CX &&goto release_iocb;"0327 Abort els iocb complete x%px with io cmd xri %x " "abort tag x%x abort status %x abort code %x\n" ,return ;/** * lpfc_ignore_els_cmpl - Completion handler for aborted ELS command * @ phba : Pointer to HBA context object . * @ cmdiocb : Pointer to driver command iocb object . * @ rspiocb : Pointer to driver response iocb object . * * The function is called from SLI ring event handler with no * lock held . This function is the completion handler for ELS commands * which are aborted . The function frees memory resources used for * the aborted ELS commands . void struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,struct lpfc_iocbq *rspiocb)struct lpfc_nodelist *ndlp = cmdiocb->ndlp;if (phba->sli_rev == LPFC_SLI_REV4) {else {/* It is possible a PLOGI_RJT for NPIV ports to get aborted. * The MBX_REG_LOGIN64 mbox command is freed back to the * mbox_mem_pool here . if (cmdiocb->context_un.mbox) {/* ELS cmd tag <ulpIoTag> completes */ "0139 Ignoring ELS cmd code x%x ref cnt x%x Data: " "x%x x%x x%x x%px\n" ,/* * Deref the ndlp after free_iocb . sli_release_iocb will access the ndlp * if exchange is busy . if (ulp_command == CMD_GEN_REQUEST64_CR)else /** * lpfc_sli_issue_abort_iotag - Abort function for a command iocb * @ phba : Pointer to HBA context object . * @ pring : Pointer to driver SLI ring object . * @ cmdiocb : Pointer to driver command iocb object . * @ cmpl : completion function . * * This function issues an abort iocb for the provided command iocb . In case * of unloading , the abort iocb will not be issued to commands on the ELS * ring . Instead , the callback function shall be changed to those commands * so that nothing happens when them finishes . This function is called with * hbalock held andno ring_lock held ( SLI4 ) . The function returns IOCB_SUCCESS * when the command iocb is an abort request . * int struct lpfc_hba *phba, struct lpfc_sli_ring *pring,struct lpfc_iocbq *cmdiocb, void *cmpl)struct lpfc_vport *vport = cmdiocb->vport;struct lpfc_iocbq *abtsiocbp;int retval = IOCB_ERROR;unsigned long iflags;struct lpfc_nodelist *ndlp = NULL;bool ia;/* * There are certain command types we don ' t want to abort . And we * don ' t want to abort commands that are already in the process of * being aborted . if (ulp_command == CMD_ABORT_XRI_WQE ||return IOCB_ABORTING;if (!pring) {if (cmdiocb->cmd_flag & LPFC_IO_FABRIC)else return retval;/* * If we ' re unloading , don ' t abort iocb on the ELS ring , but change * the callback so that nothing happens when it finishes . if (test_bit(FC_UNLOADING, &vport->load_flag) &&if (cmdiocb->cmd_flag & LPFC_IO_FABRIC)else return retval;/* issue ABTS for this IOCB based on iotag */ if (abtsiocbp == NULL)return IOCB_NORESOURCE;/* This signals the response to set the correct status * before calling the completion handler if (phba->sli_rev == LPFC_SLI_REV4) {else {if (pring->ringno == LPFC_ELS_RING) {else {/* Just close the exchange under certain conditions. */ if (test_bit(FC_UNLOADING, &vport->load_flag) ||true ;else false ;false );/* ABTS WQE must go to the same WQ as the WQE to be aborted */ if (cmdiocb->cmd_flag & LPFC_IO_FCP)if (cmdiocb->cmd_flag & LPFC_IO_FOF)if (cmpl)else if (phba->sli_rev == LPFC_SLI_REV4) {if (unlikely(pring == NULL))goto abort_iotag_exit;/* Note: both hbalock and ring_lock need to be set here */ 0 );else {0 );"0339 Abort IO XRI x%x, Original iotag x%x, " "abort tag x%x Cmdjob : x%px Abortjob : x%px " "retval x%x : IA %d cmd_cmpl %ps\n" ,if (retval) {/* * Caller to this routine should check for IOCB_ERROR * and handle it properly . This routine no longer removes * iocb off txcmplq and call compl in case of IOCB_ERROR . return retval;/** * lpfc_sli_hba_iocb_abort - Abort all iocbs to an hba . * @ phba : pointer to lpfc HBA data structure . * * This routine will abort all pending and outstanding iocbs to an HBA . void struct lpfc_hba *phba)struct lpfc_sli *psli = &phba->sli;struct lpfc_sli_ring *pring;struct lpfc_queue *qp = NULL;int i;if (phba->sli_rev != LPFC_SLI_REV4) {for (i = 0 ; i < psli->num_rings; i++) {return ;if (!pring)continue ;/** * lpfc_sli_validate_fcp_iocb_for_abort - filter iocbs appropriate for FCP aborts * @ iocbq : Pointer to iocb object . * @ vport : Pointer to driver virtual port object . * * This function acts as an iocb filter for functions which abort FCP iocbs . * * Return values * - ENODEV , if a null iocb or vport ptr is encountered * - EINVAL , if the iocb is not an FCP I / O , not on the TX cmpl queue , premarked as * driver already started the abort process , or is an abort iocb itself * 0 , passes criteria for aborting the FCP I / O iocb static int struct lpfc_iocbq *iocbq,struct lpfc_vport *vport)/* No null ptr vports */ if (!iocbq || iocbq->vport != vport)return -ENODEV;/* iocb must be for FCP IO, already exists on the TX cmpl queue, * can ' t be premarked as driver aborted , nor be an ABORT iocb itself if (!(iocbq->cmd_flag & LPFC_IO_FCP) ||return -EINVAL;return 0 ;/** * lpfc_sli_validate_fcp_iocb - validate commands associated with a SCSI target * @ iocbq : Pointer to driver iocb object . * @ vport : Pointer to driver virtual port object . * @ tgt_id : SCSI ID of the target . * @ lun_id : LUN ID of the scsi device . * @ ctx_cmd : LPFC_CTX_LUN / LPFC_CTX_TGT / LPFC_CTX_HOST * * This function acts as an iocb filter for validating a lun / SCSI target / SCSI * host . * * It will return * 0 if the filtering criteria is met for the given iocb and will return * 1 if the filtering criteria is not met . * If ctx_cmd = = LPFC_CTX_LUN , the function returns 0 only if the * given iocb is for the SCSI device specified by vport , tgt_id and * lun_id parameter . * If ctx_cmd = = LPFC_CTX_TGT , the function returns 0 only if the * given iocb is for the SCSI target specified by vport and tgt_id * parameters . * If ctx_cmd = = LPFC_CTX_HOST , the function returns 0 only if the * given iocb is for the SCSI host associated with the given vport . * This function is called with no locks held . static int struct lpfc_iocbq *iocbq, struct lpfc_vport *vport,struct lpfc_io_buf *lpfc_cmd;int rc = 1 ;struct lpfc_io_buf, cur_iocbq);if (lpfc_cmd->pCmd == NULL)return rc;switch (ctx_cmd) {case LPFC_CTX_LUN:if ((lpfc_cmd->rdata) && (lpfc_cmd->rdata->pnode) &&0 ;break ;case LPFC_CTX_TGT:if ((lpfc_cmd->rdata) && (lpfc_cmd->rdata->pnode) &&0 ;break ;case LPFC_CTX_HOST:0 ;break ;default :"%s: Unknown context cmd type, value %d\n" ,break ;return rc;/** * lpfc_sli_sum_iocb - Function to count the number of FCP iocbs pending * @ vport : Pointer to virtual port . * @ tgt_id : SCSI ID of the target . * @ lun_id : LUN ID of the scsi device . * @ ctx_cmd : LPFC_CTX_LUN / LPFC_CTX_TGT / LPFC_CTX_HOST . * * This function returns number of FCP commands pending for the vport . * When ctx_cmd = = LPFC_CTX_LUN , the function returns number of FCP * commands pending on the vport associated with SCSI device specified * by tgt_id and lun_id parameters . * When ctx_cmd = = LPFC_CTX_TGT , the function returns number of FCP * commands pending on the vport associated with SCSI target specified * by tgt_id parameter . * When ctx_cmd = = LPFC_CTX_HOST , the function returns number of FCP * commands pending on the vport . * This function returns the number of iocbs which satisfy the filter . * This function is called without any lock held . int struct lpfc_vport *vport, uint16_t tgt_id, uint64_t lun_id,struct lpfc_hba *phba = vport->phba;struct lpfc_iocbq *iocbq;int sum, i;unsigned long iflags;for (i = 1 , sum = 0 ; i <= phba->sli.last_iotag; i++) {if (!iocbq || iocbq->vport != vport)continue ;if (!(iocbq->cmd_flag & LPFC_IO_FCP) ||continue ;/* Include counting outstanding aborts */ if (ulp_command == CMD_ABORT_XRI_CN ||continue ;if (lpfc_sli_validate_fcp_iocb(iocbq, vport, tgt_id, lun_id,0 )return sum;/** * lpfc_sli_abort_fcp_cmpl - Completion handler function for aborted FCP IOCBs * @ phba : Pointer to HBA context object * @ cmdiocb : Pointer to command iocb object . * @ rspiocb : Pointer to response iocb object . * * This function is called when an aborted FCP iocb completes . This * function is called by the ring event handler with no lock held . * This function frees the iocb . void struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,struct lpfc_iocbq *rspiocb)"3096 ABORT_XRI_CX completing on rpi x%x " "original iotag x%x, abort cmd iotag x%x " "status 0x%x, reason 0x%x\n" ,return ;/** * lpfc_sli_abort_iocb - issue abort for all commands on a host / target / LUN * @ vport : Pointer to virtual port . * @ tgt_id : SCSI ID of the target . * @ lun_id : LUN ID of the scsi device . * @ abort_cmd : LPFC_CTX_LUN / LPFC_CTX_TGT / LPFC_CTX_HOST . * * This function sends an abort command for every SCSI command * associated with the given virtual port pending on the ring * filtered by lpfc_sli_validate_fcp_iocb_for_abort and then * lpfc_sli_validate_fcp_iocb function . The ordering for validation before * submitting abort iocbs must be lpfc_sli_validate_fcp_iocb_for_abort * followed by lpfc_sli_validate_fcp_iocb . * * When abort_cmd = = LPFC_CTX_LUN , the function sends abort only to the * FCP iocbs associated with lun specified by tgt_id and lun_id * parameters * When abort_cmd = = LPFC_CTX_TGT , the function sends abort only to the * FCP iocbs associated with SCSI target specified by tgt_id parameter . * When abort_cmd = = LPFC_CTX_HOST , the function sends abort to all * FCP iocbs associated with virtual port . * The pring used for SLI3 is sli3_ring [ LPFC_FCP_RING ] , for SLI4 * lpfc_sli4_calc_ring is used . * This function returns number of iocbs it failed to abort . * This function is called with no locks held . int struct lpfc_vport *vport, u16 tgt_id, u64 lun_id,struct lpfc_hba *phba = vport->phba;struct lpfc_sli_ring *pring = NULL;struct lpfc_iocbq *iocbq;int errcnt = 0 , ret_val = 0 ;unsigned long iflags;int i;/* all I/Os are in process of being flushed */ if (test_bit(HBA_IOQ_FLUSH, &phba->hba_flag))return errcnt;for (i = 1 ; i <= phba->sli.last_iotag; i++) {if (lpfc_sli_validate_fcp_iocb_for_abort(iocbq, vport))continue ;if (lpfc_sli_validate_fcp_iocb(iocbq, vport, tgt_id, lun_id,0 )continue ;if (phba->sli_rev == LPFC_SLI_REV3) {else if (phba->sli_rev == LPFC_SLI_REV4) {if (ret_val != IOCB_SUCCESS)return errcnt;/** * lpfc_sli_abort_taskmgmt - issue abort for all commands on a host / target / LUN * @ vport : Pointer to virtual port . * @ pring : Pointer to driver SLI ring object . * @ tgt_id : SCSI ID of the target . * @ lun_id : LUN ID of the scsi device . * @ cmd : LPFC_CTX_LUN / LPFC_CTX_TGT / LPFC_CTX_HOST . * * This function sends an abort command for every SCSI command * associated with the given virtual port pending on the ring * filtered by lpfc_sli_validate_fcp_iocb_for_abort and then * lpfc_sli_validate_fcp_iocb function . The ordering for validation before * submitting abort iocbs must be lpfc_sli_validate_fcp_iocb_for_abort * followed by lpfc_sli_validate_fcp_iocb . * * When taskmgmt_cmd = = LPFC_CTX_LUN , the function sends abort only to the * FCP iocbs associated with lun specified by tgt_id and lun_id * parameters * When taskmgmt_cmd = = LPFC_CTX_TGT , the function sends abort only to the * FCP iocbs associated with SCSI target specified by tgt_id parameter . * When taskmgmt_cmd = = LPFC_CTX_HOST , the function sends abort to all * FCP iocbs associated with virtual port . * This function returns number of iocbs it aborted . * This function is called with no locks held right after a taskmgmt * command is sent . int struct lpfc_vport *vport, struct lpfc_sli_ring *pring,struct lpfc_hba *phba = vport->phba;struct lpfc_io_buf *lpfc_cmd;struct lpfc_iocbq *abtsiocbq;struct lpfc_nodelist *ndlp = NULL;struct lpfc_iocbq *iocbq;int sum, i, ret_val;unsigned long iflags;struct lpfc_sli_ring *pring_s4 = NULL;bool ia;/* all I/Os are in process of being flushed */ if (test_bit(HBA_IOQ_FLUSH, &phba->hba_flag))return 0 ;0 ;for (i = 1 ; i <= phba->sli.last_iotag; i++) {if (lpfc_sli_validate_fcp_iocb_for_abort(iocbq, vport))continue ;if (lpfc_sli_validate_fcp_iocb(iocbq, vport, tgt_id, lun_id,0 )continue ;/* Guard against IO completion being called at same time */ struct lpfc_io_buf, cur_iocbq);if (!lpfc_cmd->pCmd) {continue ;if (phba->sli_rev == LPFC_SLI_REV4) {if (!pring_s4) {continue ;/* Note: both hbalock and ring_lock must be set here */ /* * If the iocbq is already being aborted , don ' t take a second * action , but do count it . if ((iocbq->cmd_flag & LPFC_DRIVER_ABORTED) ||if (phba->sli_rev == LPFC_SLI_REV4)continue ;/* issue ABTS for this IOCB based on iotag */ if (!abtsiocbq) {if (phba->sli_rev == LPFC_SLI_REV4)continue ;if (phba->sli_rev == LPFC_SLI_REV4) {else {if (pring->ringno == LPFC_ELS_RING) {else {if (lpfc_is_link_up(phba) &&false ;else true ;false );/* ABTS WQE must go to the same WQ as the WQE to be aborted */ if (iocbq->cmd_flag & LPFC_IO_FCP)if (iocbq->cmd_flag & LPFC_IO_FOF)/* Setup callback routine and issue the command. */ /* * Indicate the IO is being aborted by the driver and set * the caller ' s flag into the aborted IO . if (phba->sli_rev == LPFC_SLI_REV4) {0 );else {0 );if (ret_val == IOCB_ERROR)else return sum;/** * lpfc_sli_wake_iocb_wait - lpfc_sli_issue_iocb_wait ' s completion handler * @ phba : Pointer to HBA context object . * @ cmdiocbq : Pointer to command iocb . * @ rspiocbq : Pointer to response iocb . * * This function is the completion handler for iocbs issued using * lpfc_sli_issue_iocb_wait function . This function is called by the * ring event handler function without any lock held . This function * can be called from both worker thread context and interrupt * context . This function also can be called from other thread which * cleans up the SLI layer objects . * This function copy the contents of the response iocb to the * response iocb memory object provided by the caller of * lpfc_sli_issue_iocb_wait and then wakes up the thread which * sleeps for the iocb completion . static void struct lpfc_hba *phba,struct lpfc_iocbq *cmdiocbq,struct lpfc_iocbq *rspiocbq)unsigned long iflags;struct lpfc_io_buf *lpfc_cmd;struct lpfc_iocbq, wqe);if (cmdiocbq->cmd_flag & LPFC_IO_WAKE_TMO) {/* * A time out has occurred for the iocb . If a time out * completion handler has been supplied , call it . Otherwise , * just free the iocbq . if (cmdiocbq->cmd_cmpl)else return ;/* Copy the contents of the local rspiocb into the caller's buffer. */ if (cmdiocbq->rsp_iocb && rspiocbq)char *)cmdiocbq->rsp_iocb + offset,char *)rspiocbq + offset, sizeof (*rspiocbq) - offset);/* Set the exchange busy flag for task management commands */ if ((cmdiocbq->cmd_flag & LPFC_IO_FCP) &&struct lpfc_io_buf,if (rspiocbq && (rspiocbq->cmd_flag & LPFC_EXCHANGE_BUSY))else if (pdone_q)return ;/** * lpfc_chk_iocb_flg - Test IOCB flag with lock held . * @ phba : Pointer to HBA context object . . * @ piocbq : Pointer to command iocb . * @ flag : Flag to test . * * This routine grabs the hbalock and then test the cmd_flag to * see if the passed in flag is set . * Returns : * 1 if flag is set . * 0 if flag is not set . static int struct lpfc_hba *phba,struct lpfc_iocbq *piocbq, uint32_t flag)unsigned long iflags;int ret;return ret;/** * lpfc_sli_issue_iocb_wait - Synchronous function to issue iocb commands * @ phba : Pointer to HBA context object . . * @ ring_number : Ring number * @ piocb : Pointer to command iocb . * @ prspiocbq : Pointer to response iocb . * @ timeout : Timeout in number of seconds . * * This function issues the iocb to firmware and waits for the * iocb to complete . The cmd_cmpl field of the shall be used * to handle iocbs which time out . If the field is NULL , the * function shall free the iocbq structure . If more clean up is * needed , the caller is expected to provide a completion function * that will provide the needed clean up . If the iocb command is * not completed within timeout seconds , the function will either * free the iocbq structure ( if cmd_cmpl = = NULL ) or execute the * completion function set in the cmd_cmpl field and then return * a status of IOCB_TIMEDOUT . The caller should not free the iocb * resources if this function returns IOCB_TIMEDOUT . * The function waits for the iocb completion using an * non - interruptible wait . * This function will sleep while waiting for iocb completion . * So , this function should not be called from any context which * does not allow sleeping . Due to the same reason , this function * cannot be called with interrupt disabled . * This function assumes that the iocb completions occur while * this function sleep . So , this function cannot be called from * the thread which process iocb completion for this ring . * This function clears the cmd_flag of the iocb object before * issuing the iocb and the iocb completion handler sets this * flag and wakes this thread when the iocb completes . * The contents of the response iocb will be copied to prspiocbq * by the completion handler when the command completes . * This function returns IOCB_SUCCESS when success . * This function is called with no lock held . int struct lpfc_hba *phba,struct lpfc_iocbq *piocb,struct lpfc_iocbq *prspiocbq,long timeleft, timeout_req = 0 ;int retval = IOCB_SUCCESS;struct lpfc_iocbq *iocb;int txq_cnt = 0 ;int txcmplq_cnt = 0 ;struct lpfc_sli_ring *pring;unsigned long iflags;bool iocb_completed = true ;if (phba->sli_rev >= LPFC_SLI_REV4) {else /* * If the caller has provided a response iocbq buffer , then rsp_iocb * is NULL or its an error . if (prspiocbq) {if (piocb->rsp_iocb)return IOCB_ERROR;if (phba->cfg_poll & DISABLE_FCP_RING_INT) {if (lpfc_readl(phba->HCregaddr, &creg_val))return IOCB_ERROR;/* flush */ if (retval == IOCB_SUCCESS) {if (!(piocb->cmd_flag & LPFC_IO_WAKE)) {/* * IOCB timed out . Inform the wake iocb wait * completion function and set local status false ;if (iocb_completed) {"0331 IOCB wake signaled\n" );/* Note: we are not indicating if the IOCB has a success * status or not - that ' s for the caller to check . * IOCB_SUCCESS means just that the command was sent and * completed . Not that it completed successfully . else if (timeleft == 0 ) {"0338 IOCB wait timeout error - no " "wake response Data x%x\n" , timeout);else {"0330 IOCB wake NOT set, " "Data x%x x%lx\n" ,else if (retval == IOCB_BUSY) {if (phba->cfg_log_verbose & LOG_SLI) {"2818 Max IOCBs %d txq cnt %d txcmplq cnt %d\n" ,return retval;else {"0332 IOCB wait issue failed, Data x%x\n" ,if (phba->cfg_poll & DISABLE_FCP_RING_INT) {if (lpfc_readl(phba->HCregaddr, &creg_val))return IOCB_ERROR;/* flush */ if (prspiocbq)return retval;/** * lpfc_sli_issue_mbox_wait - Synchronous function to issue mailbox * @ phba : Pointer to HBA context object . * @ pmboxq : Pointer to driver mailbox object . * @ timeout : Timeout in number of seconds . * * This function issues the mailbox to firmware and waits for the * mailbox command to complete . If the mailbox command is not * completed within timeout seconds , it returns MBX_TIMEOUT . * The function waits for the mailbox completion using an * interruptible wait . If the thread is woken up due to a * signal , MBX_TIMEOUT error is returned to the caller . Caller * should not free the mailbox resources , if this function returns * MBX_TIMEOUT . * This function will sleep while waiting for mailbox completion . * So , this function should not be called from any context which * does not allow sleeping . Due to the same reason , this function * cannot be called with interrupt disabled . * This function assumes that the mailbox completion occurs while * this function sleep . So , this function cannot be called from * the worker thread which processes mailbox completion . * This function is called in the context of HBA management * applications . * This function returns MBX_SUCCESS when successful . * This function is called with no lock held . int struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq,struct completion mbox_done;int retval;unsigned long flag;/* setup wake call as IOCB callback */ /* setup ctx_u field to pass wait_queue pointer to wake function */ /* now issue the command */ if (retval == MBX_BUSY || retval == MBX_SUCCESS) {/* * if LPFC_MBX_WAKE flag is set the mailbox is completed * else do not free the resources . if (pmboxq->mbox_flag & LPFC_MBX_WAKE) {else {return retval;/** * lpfc_sli_mbox_sys_shutdown - shutdown mailbox command sub - system * @ phba : Pointer to HBA context . * @ mbx_action : Mailbox shutdown options . * * This function is called to shutdown the driver ' s mailbox sub - system . * It first marks the mailbox sub - system is in a block state to prevent * the asynchronous mailbox command from issued off the pending mailbox * command queue . If the mailbox command sub - system shutdown is due to * HBA error conditions such as EEH or ERATT , this routine shall invoke * the mailbox sub - system flush routine to forcefully bring down the * mailbox sub - system . Otherwise , if it is due to normal condition ( such * as with offline or HBA function reset ) , this routine will wait for the * outstanding mailbox command to complete before invoking the mailbox * sub - system flush routine to gracefully bring down mailbox sub - system . void struct lpfc_hba *phba, int mbx_action)struct lpfc_sli *psli = &phba->sli;unsigned long timeout;if (mbx_action == LPFC_MBX_NO_WAIT) {/* delay 100ms for port state */ 100 );return ;/* Disable softirqs, including timers from obtaining phba->hbalock */ if (psli->sli_flag & LPFC_SLI_ACTIVE) {/* Determine how long we might wait for the active mailbox * command to be gracefully completed by firmware . if (phba->sli.mbox_active)/* Enable softirqs again, done with phba->hbalock */ while (phba->sli.mbox_active) {/* Check active mailbox complete status every 2ms */ 2 );if (time_after(jiffies, timeout))/* Timeout, let the mailbox flush routine to * forcefully release active mailbox command break ;else {/* Enable softirqs again, done with phba->hbalock */ /** * lpfc_sli_eratt_read - read sli - 3 error attention events * @ phba : Pointer to HBA context . * * This function is called to read the SLI3 device error attention registers * for possible error attention events . The caller must hold the hostlock * with spin_lock_irq ( ) . * * This function returns 1 when there is Error Attention in the Host Attention * Register and returns 0 otherwise . static int struct lpfc_hba *phba)/* Read chip Host Attention (HA) register */ if (lpfc_readl(phba->HAregaddr, &ha_copy))goto unplug_err;if (ha_copy & HA_ERATT) {/* Read host status register to retrieve error event */ if (lpfc_sli_read_hs(phba))goto unplug_err;/* Check if there is a deferred error condition is active */ if ((HS_FFER1 & phba->work_hs) &&/* Clear all interrupt enable conditions */ 0 , phba->HCregaddr);/* Set the driver HA work bitmap */ /* Indicate polling handles this ERATT */ return 1 ;return 0 ;/* Set the driver HS work bitmap */ /* Set the driver HA work bitmap */ /* Indicate polling handles this ERATT */ return 1 ;/** * lpfc_sli4_eratt_read - read sli - 4 error attention events * @ phba : Pointer to HBA context . * * This function is called to read the SLI4 device error attention registers * for possible error attention events . The caller must hold the hostlock * with spin_lock_irq ( ) . * * This function returns 1 when there is Error Attention in the Host Attention * Register and returns 0 otherwise . static int struct lpfc_hba *phba)struct lpfc_register portstat_reg;/* * For now , use the SLI4 device internal unrecoverable error * registers for error attention . This can be changed later . switch (if_type) {case LPFC_SLI_INTF_IF_TYPE_0:if (lpfc_readl(phba->sli4_hba.u.if_type0.UERRLOregaddr,return 1 ;if ((~phba->sli4_hba.ue_mask_lo & uerr_sta_lo) ||"1423 HBA Unrecoverable error: " "uerr_lo_reg=0x%x, uerr_hi_reg=0x%x, " "ue_mask_lo_reg=0x%x, " "ue_mask_hi_reg=0x%x\n" ,0 ] = uerr_sta_lo;1 ] = uerr_sta_hi;return 1 ;break ;case LPFC_SLI_INTF_IF_TYPE_2:case LPFC_SLI_INTF_IF_TYPE_6:if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,return 1 ;if (bf_get(lpfc_sliport_status_err, &portstat_reg)) {0 ] =1 ] =if (phba->work_status[0 ] ==1 ] == SLIPORT_ERR2_REG_FW_RESTART)"2885 Port Status Event: " "port status reg 0x%x, " "port smphr reg 0x%x, " "error 1=0x%x, error 2=0x%x\n" ,0 ],1 ]);return 1 ;break ;case LPFC_SLI_INTF_IF_TYPE_1:default :"2886 HBA Error Attention on unsupported " "if type %d." , if_type);return 1 ;return 0 ;/** * lpfc_sli_check_eratt - check error attention events * @ phba : Pointer to HBA context . * * This function is called from timer soft interrupt context to check HBA ' s * error attention register bit for error attention events . * * This function returns 1 when there is Error Attention in the Host Attention * Register and returns 0 otherwise . int struct lpfc_hba *phba)/* If somebody is waiting to handle an eratt, don't process it * here . The brdkill function will do this . if (phba->link_flag & LS_IGNORE_ERATT)return 0 ;/* Check if interrupt handler handles this ERATT */ if (test_bit(HBA_ERATT_HANDLED, &phba->hba_flag))/* Interrupt handler has handled ERATT */ return 0 ;/* * If there is deferred error attention , do not check for error * attention if (unlikely(test_bit(DEFER_ERATT, &phba->hba_flag)))return 0 ;/* If PCI channel is offline, don't process it */ if (unlikely(pci_channel_offline(phba->pcidev))) {return 0 ;switch (phba->sli_rev) {case LPFC_SLI_REV2:case LPFC_SLI_REV3:/* Read chip Host Attention (HA) register */ break ;case LPFC_SLI_REV4:/* Read device Uncoverable Error (UERR) registers */ break ;default :"0299 Invalid SLI revision (%d)\n" ,0 ;break ;return ha_copy;/** * lpfc_intr_state_check - Check device state for interrupt handling * @ phba : Pointer to HBA context . * * This inline routine checks whether a device or its PCI slot is in a state * that the interrupt should be handled . * * This function returns 0 if the device or the PCI slot is in a state that * interrupt should be handled , otherwise - EIO . static inline int struct lpfc_hba *phba)/* If the pci channel is offline, ignore all the interrupts */ if (unlikely(pci_channel_offline(phba->pcidev)))return -EIO;/* Update device level interrupt statistics */ /* Ignore all interrupts during initialization. */ if (unlikely(phba->link_state < LPFC_LINK_DOWN))return -EIO;return 0 ;/** * lpfc_sli_sp_intr_handler - Slow - path interrupt handler to SLI - 3 device * @ irq : Interrupt number . * @ dev_id : The device context pointer . * * This function is directly called from the PCI layer as an interrupt * service routine when device with SLI - 3 interface spec is enabled with * MSI - X multi - message interrupt mode and there are slow - path events in * the HBA . However , when the device is enabled with either MSI or Pin - IRQ * interrupt mode , this function is called as part of the device - level * interrupt handler . When the PCI slot is in error recovery or the HBA * is undergoing initialization , the interrupt handler will not process * the interrupt . The link attention and ELS ring attention events are * handled by the worker thread . The interrupt handler signals the worker * thread and returns for these events . This function is called without * any lock held . It gets the hbalock to access and update SLI data * structures . * * This function returns IRQ_HANDLED when interrupt is handled else it * returns IRQ_NONE . int irq, void *dev_id)struct lpfc_hba *phba;unsigned long status;unsigned long iflag;struct lpfc_vport *vport;struct lpfc_nodelist *ndlp;struct lpfc_dmabuf *mp;int rc;/* * Get the driver ' s phba structure from the dev_id and * assume the HBA is not interrupting . struct lpfc_hba *)dev_id;if (unlikely(!phba))return IRQ_NONE;/* * Stuff needs to be attented to when this function is invoked as an * individual interrupt handler in MSI - X multi - message interrupt mode if (phba->intr_type == MSIX) {/* Check device state for handling interrupt */ if (lpfc_intr_state_check(phba))return IRQ_NONE;/* Need to read HA REG for slow-path events */ if (lpfc_readl(phba->HAregaddr, &ha_copy))goto unplug_error;/* If somebody is waiting to handle an eratt don't process it * here . The brdkill function will do this . if (phba->link_flag & LS_IGNORE_ERATT)/* Check the need for handling ERATT in interrupt handler */ if (ha_copy & HA_ERATT) {if (test_and_set_bit(HBA_ERATT_HANDLED,/* ERATT polling has handled ERATT */ /* * If there is deferred error attention , do not check for any * interrupt . if (unlikely(test_bit(DEFER_ERATT, &phba->hba_flag))) {return IRQ_NONE;/* Clear up only attention source related to slow-path */ if (lpfc_readl(phba->HCregaddr, &hc_copy))goto unplug_error;/* flush */ else if (work_ha_copy) {if (work_ha_copy & HA_LATT) {if (phba->sli.sli_flag & LPFC_PROCESS_LA) {/* * Turn off Link Attention interrupts * until CLEAR_LA done if (lpfc_readl(phba->HCregaddr, &control))goto unplug_error;/* flush */ else if (work_ha_copy & ~(HA_ERATT | HA_MBATT | HA_LATT)) {/* * Turn off Slow Rings interrupts , LPFC_ELS_RING is * the only slow ring . 4 *LPFC_ELS_RING)));4 *LPFC_ELS_RING);if (status & HA_RXMASK) {if (lpfc_readl(phba->HCregaddr, &control))goto unplug_error;"ISR slow ring: ctl:x%x stat:x%x isrcnt:x%x" ,if (control & (HC_R0INT_ENA << LPFC_ELS_RING)) {"ISR Disable ring:" "pwork:x%x hawork:x%x wait:x%x" ,unsigned long )/* flush */ else {"ISR slow ring: pwork:" "x%x hawork:x%x wait:x%x" ,unsigned long )if (work_ha_copy & HA_ERATT) {if (lpfc_sli_read_hs(phba))goto unplug_error;/* * Check if there is a deferred error condition * is active if ((HS_FFER1 & phba->work_hs) &&/* Clear all interrupt enable conditions */ 0 , phba->HCregaddr);if ((work_ha_copy & HA_MBATT) && (phba->sli.mbox_active)) {/* First check out the status word */ sizeof (uint32_t));if (pmbox->mbxOwner != OWN_HOST) {/* * Stray Mailbox Interrupt , mbxCommand < cmd > * mbxStatus < status > "(%d):0304 Stray Mailbox " "Interrupt mbxCommand x%x " "mbxStatus x%x\n" ,0 ),/* clear mailbox attention bit */ else {if (pmb->mbox_cmpl) {if (pmb->out_ext_byte_len &&if (pmb->mbox_flag & LPFC_MBX_IMED_UNREG) {"MBOX dflt rpi: : " "status:x%x rpi:x%x" ,0 ], 0 );if (!pmbox->mbxStatus) {/* Reg_LOGIN of dflt RPI was * successful . new lets get * rid of the RPI using the * same mbox buffer . 0 ],if (rc != MBX_BUSY)"0350 rc should have" "been MBX_BUSY\n" );if (rc != MBX_NOT_FINISHED)goto send_current_mbox;/* Do NOT queue MBX_HEARTBEAT to the worker * thread for processing . if (pmbox->mbxCommand == MBX_HEARTBEAT) {/* Process mbox now */ if (pmb->mbox_cmpl)else {/* Queue to worker thread to process */ else if ((work_ha_copy & HA_MBATT) &&/* Process next mailbox command if there is one */ do {while (rc == MBX_NOT_FINISHED);if (rc != MBX_SUCCESS)"0349 rc should be " "MBX_SUCCESS\n" );return IRQ_HANDLED;return IRQ_HANDLED;/* lpfc_sli_sp_intr_handler */ /** * lpfc_sli_fp_intr_handler - Fast - path interrupt handler to SLI - 3 device . * @ irq : Interrupt number . * @ dev_id : The device context pointer . * * This function is directly called from the PCI layer as an interrupt * service routine when device with SLI - 3 interface spec is enabled with * MSI - X multi - message interrupt mode and there is a fast - path FCP IOCB * ring event in the HBA . However , when the device is enabled with either * MSI or Pin - IRQ interrupt mode , this function is called as part of the * device - level interrupt handler . When the PCI slot is in error recovery * or the HBA is undergoing initialization , the interrupt handler will not * process the interrupt . The SCSI FCP fast - path ring event are handled in * the intrrupt context . This function is called without any lock held . * It gets the hbalock to access and update SLI data structures . * * This function returns IRQ_HANDLED when interrupt is handled else it * returns IRQ_NONE . int irq, void *dev_id)struct lpfc_hba *phba;unsigned long status;unsigned long iflag;struct lpfc_sli_ring *pring;/* Get the driver's phba structure from the dev_id and * assume the HBA is not interrupting . struct lpfc_hba *) dev_id;if (unlikely(!phba))return IRQ_NONE;/* * Stuff needs to be attented to when this function is invoked as an * individual interrupt handler in MSI - X multi - message interrupt mode if (phba->intr_type == MSIX) {/* Check device state for handling interrupt */ if (lpfc_intr_state_check(phba))return IRQ_NONE;/* Need to read HA REG for FCP ring and other ring events */ if (lpfc_readl(phba->HAregaddr, &ha_copy))return IRQ_HANDLED;/* * If there is deferred error attention , do not check for * any interrupt . if (unlikely(test_bit(DEFER_ERATT, &phba->hba_flag)))return IRQ_NONE;/* Clear up only attention source related to fast-path */ /* flush */ else /* * Process all events on FCP ring . Take the optimized path for FCP IO . 4 *LPFC_FCP_RING)));4 *LPFC_FCP_RING);if (status & HA_RXMASK)if (phba->cfg_multi_ring_support == 2 ) {/* * Process all events on extra ring . Take the optimized path * for extra ring IO . 4 *LPFC_EXTRA_RING)));4 *LPFC_EXTRA_RING);if (status & HA_RXMASK) {return IRQ_HANDLED;/* lpfc_sli_fp_intr_handler */ /** * lpfc_sli_intr_handler - Device - level interrupt handler to SLI - 3 device * @ irq : Interrupt number . * @ dev_id : The device context pointer . * * This function is the HBA device - level interrupt handler to device with * SLI - 3 interface spec , called from the PCI layer when either MSI or * Pin - IRQ interrupt mode is enabled and there is an event in the HBA which * requires driver attention . This function invokes the slow - path interrupt * attention handling function and fast - path interrupt attention handling * function in turn to process the relevant HBA attention events . This * function is called without any lock held . It gets the hbalock to access * and update SLI data structures . * * This function returns IRQ_HANDLED when interrupt is handled , else it * returns IRQ_NONE . int irq, void *dev_id)struct lpfc_hba *phba;unsigned long status1, status2;/* * Get the driver ' s phba structure from the dev_id and * assume the HBA is not interrupting . struct lpfc_hba *) dev_id;if (unlikely(!phba))return IRQ_NONE;/* Check device state for handling interrupt */ if (lpfc_intr_state_check(phba))return IRQ_NONE;if (lpfc_readl(phba->HAregaddr, &phba->ha_copy)) {return IRQ_HANDLED;if (unlikely(!phba->ha_copy)) {return IRQ_NONE;else if (phba->ha_copy & HA_ERATT) {if (test_and_set_bit(HBA_ERATT_HANDLED, &phba->hba_flag))/* ERATT polling has handled ERATT */ /* * If there is deferred error attention , do not check for any interrupt . if (unlikely(test_bit(DEFER_ERATT, &phba->hba_flag))) {return IRQ_NONE;/* Clear attention sources except link and error attentions */ if (lpfc_readl(phba->HCregaddr, &hc_copy)) {return IRQ_HANDLED;/* flush */ /* * Invokes slow - path host attention interrupt handling as appropriate . /* status of events with mailbox and link attention */ /* status of events with ELS ring */ 4 *LPFC_ELS_RING)));4 *LPFC_ELS_RING);if (status1 || (status2 & HA_RXMASK))else /* * Invoke fast - path host attention interrupt handling as appropriate . /* status of events with FCP ring */ 4 *LPFC_FCP_RING)));4 *LPFC_FCP_RING);/* status of events with extra ring */ if (phba->cfg_multi_ring_support == 2 ) {4 *LPFC_EXTRA_RING)));4 *LPFC_EXTRA_RING);else 0 ;if ((status1 & HA_RXMASK) || (status2 & HA_RXMASK))else /* Return device-level interrupt handling status */ return (sp_irq_rc == IRQ_HANDLED) ? sp_irq_rc : fp_irq_rc;/* lpfc_sli_intr_handler */ /** * lpfc_sli4_els_xri_abort_event_proc - Process els xri abort event * @ phba : pointer to lpfc hba data structure . * * This routine is invoked by the worker thread to process all the pending * SLI4 els abort xri events . void lpfc_sli4_els_xri_abort_event_proc(struct lpfc_hba *phba)struct lpfc_cq_event *cq_event;unsigned long iflags;/* First, declare the els xri abort event has been handled */ /* Now, handle all the els xri abort events */ while (!list_empty(&phba->sli4_hba.sp_els_xri_aborted_work_queue)) {/* Get the first event from the head of the event queue */ struct lpfc_cq_event, list);/* Notify aborted XRI for ELS work queue */ /* Free the event processed back to the free pool */ /** * lpfc_sli4_els_preprocess_rspiocbq - Get response iocbq from els wcqe * @ phba : Pointer to HBA context object . * @ irspiocbq : Pointer to work - queue completion queue entry . * * This routine handles an ELS work - queue completion event and construct * a pseudo response ELS IOCBQ from the SLI4 ELS WCQE for the common * discovery engine to handle . * * Return : Pointer to the receive IOCBQ , NULL otherwise . static struct lpfc_iocbq *struct lpfc_hba *phba,struct lpfc_iocbq *irspiocbq)struct lpfc_sli_ring *pring;struct lpfc_iocbq *cmdiocbq;struct lpfc_wcqe_complete *wcqe;unsigned long iflags;if (unlikely(!pring))return NULL;/* Look up the ELS command IOCB and create pseudo response IOCB */ if (unlikely(!cmdiocbq)) {"0386 ELS complete with no corresponding " "cmdiocb: 0x%x 0x%x 0x%x 0x%x\n" ,return NULL;sizeof (union lpfc_wqe128));sizeof (*wcqe));/* Put the iocb back on the txcmplq */ if (bf_get(lpfc_wcqe_c_xb, wcqe)) {return irspiocbq;inline struct lpfc_cq_event *struct lpfc_hba *phba, void *entry, int size)struct lpfc_cq_event *cq_event;/* Allocate a new internal CQ_EVENT entry */ if (!cq_event) {"0602 Failed to alloc CQ_EVENT entry\n" );return NULL;/* Move the CQE into the event */ return cq_event;/** * lpfc_sli4_sp_handle_async_event - Handle an asynchronous event * @ phba : Pointer to HBA context object . * @ mcqe : Pointer to mailbox completion queue entry . * * This routine process a mailbox completion queue entry with asynchronous * event . * * Return : true if work posted to worker thread , otherwise false . static bool struct lpfc_hba *phba, struct lpfc_mcqe *mcqe)struct lpfc_cq_event *cq_event;unsigned long iflags;"0392 Async Event: word0:x%x, word1:x%x, " "word2:x%x, word3:x%x\n" , mcqe->word0,sizeof (struct lpfc_mcqe));if (!cq_event)return false ;/* Set the async event flag */ return true ;/** * lpfc_sli4_sp_handle_mbox_event - Handle a mailbox completion event * @ phba : Pointer to HBA context object . * @ mcqe : Pointer to mailbox completion queue entry . * * This routine process a mailbox completion queue entry with mailbox * completion event . * * Return : true if work posted to worker thread , otherwise false . static bool struct lpfc_hba *phba, struct lpfc_mcqe *mcqe)struct lpfc_mqe *mqe;struct lpfc_vport *vport;struct lpfc_nodelist *ndlp;struct lpfc_dmabuf *mp;unsigned long iflags;bool workposted = false ;int rc;/* If not a mailbox complete MCQE, out by checking mailbox consume */ if (!bf_get(lpfc_trailer_completed, mcqe))goto out_no_mqe_complete;/* Get the reference to the active mbox command */ if (unlikely(!pmb)) {"1832 No pending MBOX command to handle\n" );goto out_no_mqe_complete;/* Reset heartbeat timer */ /* Move mbox data to caller's mailbox region, do endian swapping */ if (pmb->mbox_cmpl && mbox)sizeof (struct lpfc_mqe));/* * For mcqe errors , conditionally move a modified error code to * the mbox so that the error will not be missed . if (mcqe_status != MB_CQE_STATUS_SUCCESS) {if (bf_get(lpfc_mqe_status, mqe) == MBX_SUCCESS)if (pmb->mbox_flag & LPFC_MBX_IMED_UNREG) {"MBOX dflt rpi: status:x%x rpi:x%x" ,0 ], 0 );if (mcqe_status == MB_CQE_STATUS_SUCCESS) {/* Reg_LOGIN of dflt RPI was successful. Mark the * node as having an UNREG_LOGIN in progress to stop * an unsolicited PLOGI from the same NPortId from * starting another mailbox transaction . 0 ], pmb);/* No reference taken here. This is a default * RPI reg / immediate unreg cycle . The reference was * taken in the reg rpi path and is released when * this mailbox completes . if (rc != MBX_BUSY)"0385 rc should " "have been MBX_BUSY\n" );if (rc != MBX_NOT_FINISHED)goto send_current_mbox;/* Do NOT queue MBX_HEARTBEAT to the worker thread for processing. */ if (pmbox->mbxCommand == MBX_HEARTBEAT) {/* Release the mailbox command posting token */ if (bf_get(lpfc_trailer_consumed, mcqe))/* Post the next mbox command, if there is one */ /* Process cmpl now */ if (pmb->mbox_cmpl)return false ;/* There is mailbox completion work to queue to the worker thread */ true ;/* Release the mailbox command posting token */ /* Setting active mailbox pointer need to be in sync to flag clear */ if (bf_get(lpfc_trailer_consumed, mcqe))/* Wake up worker thread to post the next pending mailbox command */ return workposted;if (bf_get(lpfc_trailer_consumed, mcqe))return false ;/** * lpfc_sli4_sp_handle_mcqe - Process a mailbox completion queue entry * @ phba : Pointer to HBA context object . * @ cq : Pointer to associated CQ * @ cqe : Pointer to mailbox completion queue entry . * * This routine process a mailbox completion queue entry , it invokes the * proper mailbox complete handling or asynchronous event handling routine * according to the MCQE ' s async bit . * * Return : true if work posted to worker thread , otherwise false . static bool struct lpfc_hba *phba, struct lpfc_queue *cq,struct lpfc_cqe *cqe)struct lpfc_mcqe mcqe;bool workposted;/* Copy the mailbox MCQE and convert endian order as needed */ sizeof (struct lpfc_mcqe));/* Invoke the proper event handling routine */ if (!bf_get(lpfc_trailer_async, &mcqe))else return workposted;/** * lpfc_sli4_sp_handle_els_wcqe - Handle els work - queue completion event * @ phba : Pointer to HBA context object . * @ cq : Pointer to associated CQ * @ wcqe : Pointer to work - queue completion queue entry . * * This routine handles an ELS work - queue completion event . * * Return : true if work posted to worker thread , otherwise false . static bool struct lpfc_hba *phba, struct lpfc_queue *cq,struct lpfc_wcqe_complete *wcqe)struct lpfc_iocbq *irspiocbq;unsigned long iflags;struct lpfc_sli_ring *pring = cq->pring;int txq_cnt = 0 ;int txcmplq_cnt = 0 ;/* Check for response status */ if (unlikely(bf_get(lpfc_wcqe_c_status, wcqe))) {/* Log the error status */ "0357 ELS CQE error: status=x%x: " "CQE: %08x %08x %08x %08x\n" ,/* Get an irspiocbq for later ELS response processing use */ if (!irspiocbq) {if (!list_empty(&pring->txq))if (!list_empty(&pring->txcmplq))"0387 NO IOCBQ data: txq_cnt=%d iocb_cnt=%d " "els_txcmplq_cnt=%d\n" ,return false ;/* Save off the slow-path queue event for work thread to process */ sizeof (*wcqe));return true ;/** * lpfc_sli4_sp_handle_rel_wcqe - Handle slow - path WQ entry consumed event * @ phba : Pointer to HBA context object . * @ wcqe : Pointer to work - queue completion queue entry . * * This routine handles slow - path WQ entry consumed event by invoking the * proper WQ release routine to the slow - path WQ . static void struct lpfc_hba *phba,struct lpfc_wcqe_release *wcqe)/* sanity check on queue memory */ if (unlikely(!phba->sli4_hba.els_wq))return ;/* Check for the slow-path ELS work queue */ if (bf_get(lpfc_wcqe_r_wq_id, wcqe) == phba->sli4_hba.els_wq->queue_id)else "2579 Slow-path wqe consume event carries " "miss-matched qid: wcqe-qid=x%x, sp-qid=x%x\n" ,/** * lpfc_sli4_sp_handle_abort_xri_wcqe - Handle a xri abort event * @ phba : Pointer to HBA context object . * @ cq : Pointer to a WQ completion queue . * @ wcqe : Pointer to work - queue completion queue entry . * * This routine handles an XRI abort event . * * Return : true if work posted to worker thread , otherwise false . static bool struct lpfc_hba *phba,struct lpfc_queue *cq,struct sli4_wcqe_xri_aborted *wcqe)bool workposted = false ;struct lpfc_cq_event *cq_event;unsigned long iflags;switch (cq->subtype) {case LPFC_IO:if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {/* Notify aborted XRI for NVME work queue */ if (phba->nvmet_support)false ;break ;case LPFC_NVME_LS: /* NVME LS uses ELS resources */ case LPFC_ELS:sizeof (*wcqe));if (!cq_event) {false ;break ;/* Set the els xri abort event flag */ true ;break ;default :"0603 Invalid CQ subtype %d: " "%08x %08x %08x %08x\n" ,false ;break ;return workposted;#define FC_RCTL_MDS_DIAGS 0 xF4/** * lpfc_sli4_sp_handle_rcqe - Process a receive - queue completion queue entry * @ phba : Pointer to HBA context object . * @ rcqe : Pointer to receive - queue completion queue entry . * * This routine process a receive - queue completion queue entry . * * Return : true if work posted to worker thread , otherwise false . static bool struct lpfc_hba *phba, struct lpfc_rcqe *rcqe)bool workposted = false ;struct fc_frame_header *fc_hdr;struct lpfc_queue *hrq = phba->sli4_hba.hdr_rq;struct lpfc_queue *drq = phba->sli4_hba.dat_rq;struct lpfc_nvmet_tgtport *tgtp;struct hbq_dmabuf *dma_buf;unsigned long iflags;/* sanity check on queue memory */ if (unlikely(!hrq) || unlikely(!drq))return workposted;if (bf_get(lpfc_cqe_code, rcqe) == CQE_CODE_RECEIVE_V1)else if (rq_id != hrq->queue_id)goto out;switch (status) {case FC_STATUS_RQ_BUF_LEN_EXCEEDED:"2537 Receive Frame Truncated!!\n" );case FC_STATUS_RQ_SUCCESS:0 ].hbq_buffer_list);if (!dma_buf) {goto out;sizeof (*rcqe));struct fc_frame_header *)dma_buf->hbuf.virt;if (fc_hdr->fh_r_ctl == FC_RCTL_MDS_DIAGS ||/* Handle MDS Loopback frames */ if (!test_bit(FC_UNLOADING, &phba->pport->load_flag))else break ;/* save off the frame for the work thread to process */ /* Frame received */ true ;break ;case FC_STATUS_INSUFF_BUF_FRM_DISC:if (phba->nvmet_support) {private ;"6402 RQE Error x%x, posted %d err_cnt " "%d: %x %x %x\n" ,case FC_STATUS_INSUFF_BUF_NEED_BUF:/* Post more buffers if possible */ true ;break ;case FC_STATUS_RQ_DMA_FAILURE:"2564 RQE DMA Error x%x, x%08x x%08x x%08x " "x%08x\n" ,/* If IV set, no further recovery */ if (bf_get(lpfc_rcqe_iv, rcqe))break ;/* recycle consumed resource */ 0 ].hbq_buffer_list);if (!dma_buf) {break ;break ;default :"2565 Unexpected RQE Status x%x, w0-3 x%08x " "x%08x x%08x x%08x\n" ,break ;return workposted;/** * lpfc_sli4_sp_handle_cqe - Process a slow path completion queue entry * @ phba : Pointer to HBA context object . * @ cq : Pointer to the completion queue . * @ cqe : Pointer to a completion queue entry . * * This routine process a slow - path work - queue or receive queue completion queue * entry . * * Return : true if work posted to worker thread , otherwise false . static bool struct lpfc_hba *phba, struct lpfc_queue *cq,struct lpfc_cqe *cqe)struct lpfc_cqe cqevt;bool workposted = false ;/* Copy the work queue CQE and convert endian order if needed */ sizeof (struct lpfc_cqe));/* Check and process for different type of WCQE and dispatch */ switch (bf_get(lpfc_cqe_code, &cqevt)) {case CQE_CODE_COMPL_WQE:/* Process the WQ/RQ complete event */ struct lpfc_wcqe_complete *)&cqevt);break ;case CQE_CODE_RELEASE_WQE:/* Process the WQ release event */ struct lpfc_wcqe_release *)&cqevt);break ;case CQE_CODE_XRI_ABORTED:/* Process the WQ XRI abort event */ struct sli4_wcqe_xri_aborted *)&cqevt);break ;case CQE_CODE_RECEIVE:case CQE_CODE_RECEIVE_V1:/* Process the RQ event */ struct lpfc_rcqe *)&cqevt);break ;default :"0388 Not a valid WCQE code: x%x\n" ,break ;return workposted;/** * lpfc_sli4_sp_handle_eqe - Process a slow - path event queue entry * @ phba : Pointer to HBA context object . * @ eqe : Pointer to fast - path event queue entry . * @ speq : Pointer to slow - path event queue . * * This routine process a event queue entry from the slow - path event queue . * It will check the MajorCode and MinorCode to determine this is for a * completion event on a completion queue , if not , an error shall be logged * and just return . Otherwise , it will get to the corresponding completion * queue and process all the entries on that completion queue , rearm the * completion queue , and then return . * static void struct lpfc_hba *phba, struct lpfc_eqe *eqe,struct lpfc_queue *speq)struct lpfc_queue *cq = NULL, *childq;int ret = 0 ;/* Get the reference to the corresponding CQ */ if (childq->queue_id == cqid) {break ;if (unlikely(!cq)) {if (phba->sli.sli_flag & LPFC_SLI_ACTIVE)"0365 Slow-path CQ identifier " "(%d) does not exist\n" , cqid);return ;/* Save EQ associated with this CQ */ if (is_kdump_kernel())else if (!ret)"0390 Cannot schedule queue work " "for CQ eqcqid=%d, cqid=%d on CPU %d\n" ,/** * _ _ lpfc_sli4_process_cq - Process elements of a CQ * @ phba : Pointer to HBA context object . * @ cq : Pointer to CQ to be processed * @ handler : Routine to process each cqe * @ delay : Pointer to usdelay to set in case of rescheduling of the handler * * This routine processes completion queue entries in a CQ . While a valid * queue element is found , the handler is called . During processing checks * are made for periodic doorbell writes to let the hardware know of * element consumption . * * If the max limit on cqes to process is hit , or there are no more valid * entries , the loop stops . If we processed a sufficient number of elements , * meaning there is sufficient load , rather than rearming and generating * another interrupt , a cq rescheduling delay will be set . A delay of 0 * indicates no rescheduling . * * Returns True if work scheduled , False otherwise . static bool struct lpfc_hba *phba, struct lpfc_queue *cq,bool (*handler)(struct lpfc_hba *, struct lpfc_queue *,struct lpfc_cqe *), unsigned long *delay)struct lpfc_cqe *cqe;bool workposted = false ;int count = 0 , consumed = 0 ;bool arm = true ;/* default - no reschedule */ 0 ;if (cmpxchg(&cq->queue_claimed, 0 , 1 ) != 0 )goto rearm_and_exit;/* Process all the entries to the CQ */ 0 ;while (cqe) {if (!(++count % cq->max_proc_limit))break ;if (!(count % cq->notify_interval)) {0 ;if (count == LPFC_NVMET_CQ_NOTIFY)if (count >= phba->cfg_cq_poll_threshold) {1 ;false ;/* Track the max number of CQEs processed in 1 EQ */ if (count > cq->CQ_max_cqe)/* Catch the no cq entry condition */ if (unlikely(count == 0 ))"0369 No entry from completion queue " "qid=%d\n" , cq->queue_id);0 );return workposted;/** * _ _ lpfc_sli4_sp_process_cq - Process a slow - path event queue entry * @ cq : pointer to CQ to process * * This routine calls the cq processing routine with a handler specific * to the type of queue bound to it . * * The CQ routine returns two values : the first is the calling status , * which indicates whether work was queued to the background discovery * thread . If true , the routine should wakeup the discovery thread ; * the second is the delay parameter . If non - zero , rather than rearming * the CQ and yet another interrupt , the CQ handler should be queued so * that it is processed in a subsequent polling action . The value of * the delay indicates when to reschedule it . static void struct lpfc_queue *cq)struct lpfc_hba *phba = cq->phba;unsigned long delay;bool workposted = false ;int ret = 0 ;/* Process and rearm the CQ */ switch (cq->type) {case LPFC_MCQ:break ;case LPFC_WCQ:if (cq->subtype == LPFC_IO)else break ;default :"0370 Invalid completion queue type (%d)\n" ,return ;if (delay) {if (is_kdump_kernel())else if (!ret)"0394 Cannot schedule queue work " "for cqid=%d on CPU %d\n" ,/* wake up worker thread if there are works to be done */ if (workposted)/** * lpfc_sli4_sp_process_cq - slow - path work handler when started by * interrupt * @ work : pointer to work element * * translates from the work handler and calls the slow - path handler . static void struct work_struct *work)struct lpfc_queue *cq = container_of(work, struct lpfc_queue, spwork);/** * lpfc_sli4_dly_sp_process_cq - slow - path work handler when started by timer * @ work : pointer to work element * * translates from the work handler and calls the slow - path handler . static void struct work_struct *work)struct lpfc_queue *cq = container_of(to_delayed_work(work),struct lpfc_queue, sched_spwork);/** * lpfc_sli4_fp_handle_fcp_wcqe - Process fast - path work queue completion entry * @ phba : Pointer to HBA context object . * @ cq : Pointer to associated CQ * @ wcqe : Pointer to work - queue completion queue entry . * * This routine process a fast - path work queue completion entry from fast - path * event queue for FCP command response completion . static void struct lpfc_hba *phba, struct lpfc_queue *cq,struct lpfc_wcqe_complete *wcqe)struct lpfc_sli_ring *pring = cq->pring;struct lpfc_iocbq *cmdiocbq;unsigned long iflags;/* Check for response status */ if (unlikely(bf_get(lpfc_wcqe_c_status, wcqe))) {/* If resource errors reported from HBA, reduce queue * depth of the SCSI device . if (((bf_get(lpfc_wcqe_c_status, wcqe) ==/* Log the cmpl status */ "0373 FCP CQE cmpl: status=x%x: " "CQE: %08x %08x %08x %08x\n" ,/* Look up the FCP command IOCB and create pseudo response IOCB */ if (unlikely(!cmdiocbq)) {"0374 FCP complete with no corresponding " "cmdiocb: iotag (%d)\n" ,return ;#ifdef CONFIG_SCSI_LPFC_DEBUG_FS#endif if (bf_get(lpfc_wcqe_c_xb, wcqe)) {if (cmdiocbq->cmd_cmpl) {/* For FCP the flag is cleared in cmd_cmpl */ if (!(cmdiocbq->cmd_flag & LPFC_IO_FCP) &&/* Pass the cmd_iocb and the wcqe to the upper layer */ sizeof (struct lpfc_wcqe_complete));else {"0375 FCP cmdiocb not callback function " "iotag: (%d)\n" ,/** * lpfc_sli4_fp_handle_rel_wcqe - Handle fast - path WQ entry consumed event * @ phba : Pointer to HBA context object . * @ cq : Pointer to completion queue . * @ wcqe : Pointer to work - queue completion queue entry . * * This routine handles an fast - path WQ entry consumed event by invoking the * proper WQ release routine to the slow - path WQ . static void struct lpfc_hba *phba, struct lpfc_queue *cq,struct lpfc_wcqe_release *wcqe)struct lpfc_queue *childwq;bool wqid_matched = false ;/* Check for fast-path FCP work queue release */ if (childwq->queue_id == hba_wqid) {if (childwq->q_flag & HBA_NVMET_WQFULL)true ;break ;/* Report warning log message if no match found */ if (wqid_matched != true )"2580 Fast-path wqe consume event carries " "miss-matched qid: wcqe-qid=x%x\n" , hba_wqid);/** * lpfc_sli4_nvmet_handle_rcqe - Process a receive - queue completion queue entry * @ phba : Pointer to HBA context object . * @ cq : Pointer to completion queue . * @ rcqe : Pointer to receive - queue completion queue entry . * * This routine process a receive - queue completion queue entry . * * Return : true if work posted to worker thread , otherwise false . static bool struct lpfc_hba *phba, struct lpfc_queue *cq,struct lpfc_rcqe *rcqe)bool workposted = false ;struct lpfc_queue *hrq;struct lpfc_queue *drq;struct rqb_dmabuf *dma_buf;struct fc_frame_header *fc_hdr;struct lpfc_nvmet_tgtport *tgtp;unsigned long iflags;if ((phba->nvmet_support == 0 ) ||return workposted;0 ]->queue_id;/* sanity check on queue memory */ if (unlikely(!hrq) || unlikely(!drq))return workposted;if (bf_get(lpfc_cqe_code, rcqe) == CQE_CODE_RECEIVE_V1)else if ((phba->nvmet_support == 0 ) ||return workposted;switch (status) {case FC_STATUS_RQ_BUF_LEN_EXCEEDED:"6126 Receive Frame Truncated!!\n" );case FC_STATUS_RQ_SUCCESS:if (!dma_buf) {goto out;struct fc_frame_header *)dma_buf->hbuf.virt;/* Just some basic sanity checks on FCP Command frame */ 0 ] << 16 |1 ] << 8 |2 ]);if (((fctl &0 )) /* 0 byte swapped is still 0 */ goto drop;if (fc_hdr->fh_type == FC_TYPE_FCP) {return false ;break ;case FC_STATUS_INSUFF_BUF_FRM_DISC:if (phba->nvmet_support) {private ;"6401 RQE Error x%x, posted %d err_cnt " "%d: %x %x %x\n" ,case FC_STATUS_INSUFF_BUF_NEED_BUF:/* Post more buffers if possible */ break ;case FC_STATUS_RQ_DMA_FAILURE:"2575 RQE DMA Error x%x, x%08x x%08x x%08x " "x%08x\n" ,/* If IV set, no further recovery */ if (bf_get(lpfc_rcqe_iv, rcqe))break ;/* recycle consumed resource */ if (!dma_buf) {break ;break ;default :"2576 Unexpected RQE Status x%x, w0-3 x%08x " "x%08x x%08x x%08x\n" ,break ;return workposted;/** * lpfc_sli4_fp_handle_cqe - Process fast - path work queue completion entry * @ phba : adapter with cq * @ cq : Pointer to the completion queue . * @ cqe : Pointer to fast - path completion queue entry . * * This routine process a fast - path work queue completion entry from fast - path * event queue for FCP command response completion . * * Return : true if work posted to worker thread , otherwise false . static bool struct lpfc_hba *phba, struct lpfc_queue *cq,struct lpfc_cqe *cqe)struct lpfc_wcqe_release wcqe;bool workposted = false ;/* Copy the work queue CQE and convert endian order if needed */ sizeof (struct lpfc_cqe));/* Check and process for different type of WCQE and dispatch */ switch (bf_get(lpfc_wcqe_c_code, &wcqe)) {case CQE_CODE_COMPL_WQE:case CQE_CODE_NVME_ERSP:/* Process the WQ complete event */ if (cq->subtype == LPFC_IO || cq->subtype == LPFC_NVME_LS)struct lpfc_wcqe_complete *)&wcqe);break ;case CQE_CODE_RELEASE_WQE:/* Process the WQ release event */ struct lpfc_wcqe_release *)&wcqe);break ;case CQE_CODE_XRI_ABORTED:/* Process the WQ XRI abort event */ struct sli4_wcqe_xri_aborted *)&wcqe);break ;case CQE_CODE_RECEIVE_V1:case CQE_CODE_RECEIVE:if (cq->subtype == LPFC_NVMET) {struct lpfc_rcqe *)&wcqe);break ;default :"0144 Not a valid CQE code: x%x\n" ,break ;return workposted;/** * _ _ lpfc_sli4_hba_process_cq - Process a fast - path event queue entry * @ cq : Pointer to CQ to be processed * * This routine calls the cq processing routine with the handler for * fast path CQEs . * * The CQ routine returns two values : the first is the calling status , * which indicates whether work was queued to the background discovery * thread . If true , the routine should wakeup the discovery thread ; * the second is the delay parameter . If non - zero , rather than rearming * the CQ and yet another interrupt , the CQ handler should be queued so * that it is processed in a subsequent polling action . The value of * the delay indicates when to reschedule it . static void struct lpfc_queue *cq)struct lpfc_hba *phba = cq->phba;unsigned long delay;bool workposted = false ;int ret;/* process and rearm the CQ */ if (delay) {if (is_kdump_kernel())else if (!ret)"0367 Cannot schedule queue work " "for cqid=%d on CPU %d\n" ,/* wake up worker thread if there are works to be done */ if (workposted)/** * lpfc_sli4_hba_process_cq - fast - path work handler when started by * interrupt * @ work : pointer to work element * * translates from the work handler and calls the fast - path handler . static void struct work_struct *work)struct lpfc_queue *cq = container_of(work, struct lpfc_queue, irqwork);/** * lpfc_sli4_hba_handle_eqe - Process a fast - path event queue entry * @ phba : Pointer to HBA context object . * @ eq : Pointer to the queue structure . * @ eqe : Pointer to fast - path event queue entry . * @ poll_mode : poll_mode to execute processing the cq . * * This routine process a event queue entry from the fast - path event queue . * It will check the MajorCode and MinorCode to determine this is for a * completion event on a completion queue , if not , an error shall be logged * and just return . Otherwise , it will get to the corresponding completion * queue and process all the entries on the completion queue , rearm the * completion queue , and then return . static void struct lpfc_hba *phba, struct lpfc_queue *eq,struct lpfc_eqe *eqe, enum lpfc_poll_mode poll_mode)struct lpfc_queue *cq = NULL;int ret;if (unlikely(bf_get_le32(lpfc_eqe_major_code, eqe) != 0 )) {"0366 Not a valid completion " "event: majorcode=x%x, minorcode=x%x\n" ,return ;/* Get the reference to the corresponding CQ */ /* Use the fast lookup method first */ if (cqid <= phba->sli4_hba.cq_max) {if (cq)goto work_cq;/* Next check for NVMET completion */ if (phba->cfg_nvmet_mrq && phba->sli4_hba.nvmet_cqset) {0 ]->queue_id;if ((cqid >= id) && (cqid < (id + phba->cfg_nvmet_mrq))) {/* Process NVMET unsol rcv */ goto process_cq;if (phba->sli4_hba.nvmels_cq &&/* Process NVME unsol rcv */ /* Otherwise this is a Slow path event */ if (cq == NULL) {return ;if (unlikely(cqid != cq->queue_id)) {"0368 Miss-matched fast-path completion " "queue identifier: eqcqid=%d, fcpcqid=%d\n" ,return ;#if defined (CONFIG_SCSI_LPFC_DEBUG_FS)if (phba->ktime_on)else 0 ;#endif switch (poll_mode) {case LPFC_THREADED_IRQ:break ;case LPFC_QUEUE_WORK:default :if (is_kdump_kernel())else if (!ret)"0383 Cannot schedule queue work " "for CQ eqcqid=%d, cqid=%d on CPU %d\n" ,break ;/** * lpfc_sli4_dly_hba_process_cq - fast - path work handler when started by timer * @ work : pointer to work element * * translates from the work handler and calls the fast - path handler . static void struct work_struct *work)struct lpfc_queue *cq = container_of(to_delayed_work(work),struct lpfc_queue, sched_irqwork);/** * lpfc_sli4_hba_intr_handler - HBA interrupt handler to SLI - 4 device * @ irq : Interrupt number . * @ dev_id : The device context pointer . * * This function is directly called from the PCI layer as an interrupt * service routine when device with SLI - 4 interface spec is enabled with * MSI - X multi - message interrupt mode and there is a fast - path FCP IOCB * ring event in the HBA . However , when the device is enabled with either * MSI or Pin - IRQ interrupt mode , this function is called as part of the * device - level interrupt handler . When the PCI slot is in error recovery * or the HBA is undergoing initialization , the interrupt handler will not * process the interrupt . The SCSI FCP fast - path ring event are handled in * the intrrupt context . This function is called without any lock held . * It gets the hbalock to access and update SLI data structures . Note that , * the FCP EQ to FCP CQ are one - to - one map such that the FCP EQ index is * equal to that of FCP CQ index . * * The link attention and ELS ring attention events are handled * by the worker thread . The interrupt handler signals the worker thread * and returns for these events . This function is called without any lock * held . It gets the hbalock to access and update SLI data structures . * * This function returns IRQ_HANDLED when interrupt is handled , IRQ_WAKE_THREAD * when interrupt is scheduled to be handled from a threaded irq context , or * else returns IRQ_NONE . int irq, void *dev_id)struct lpfc_hba *phba;struct lpfc_hba_eq_hdl *hba_eq_hdl;struct lpfc_queue *fpeq;unsigned long iflag;int hba_eqidx;int ecount = 0 ;struct lpfc_eq_intr_info *eqi;/* Get the driver's phba structure from the dev_id */ struct lpfc_hba_eq_hdl *)dev_id;if (unlikely(!phba))return IRQ_NONE;if (unlikely(!phba->sli4_hba.hdwq))return IRQ_NONE;/* Get to the EQ struct associated with this vector */ if (unlikely(!fpeq))return IRQ_NONE;/* Check device state for handling interrupt */ if (unlikely(lpfc_intr_state_check(phba))) {/* Check again for link_state with lock held */ if (phba->link_state < LPFC_LINK_DOWN)/* Flush, clear interrupt, and rearm the EQ */ return IRQ_NONE;switch (fpeq->poll_mode) {case LPFC_THREADED_IRQ:/* CGN mgmt is mutually exclusive from irq processing */ if (phba->cmf_active_mode == LPFC_CFG_OFF)return IRQ_WAKE_THREAD;case LPFC_QUEUE_WORK:default :if (eqi->icnt > LPFC_EQD_ISR_TRIGGER &&/* process and rearm the EQ */ if (unlikely(ecount == 0 )) {if (phba->intr_type == MSIX)/* MSI-X treated interrupt served as no EQ share INT */ "0358 MSI-X interrupt with no EQE\n" );else /* Non MSI-X treated on interrupt as EQ share INT */ return IRQ_NONE;return IRQ_HANDLED;/* lpfc_sli4_hba_intr_handler */ /** * lpfc_sli4_intr_handler - Device - level interrupt handler for SLI - 4 device * @ irq : Interrupt number . * @ dev_id : The device context pointer . * * This function is the device - level interrupt handler to device with SLI - 4 * interface spec , called from the PCI layer when either MSI or Pin - IRQ * interrupt mode is enabled and there is an event in the HBA which requires * driver attention . This function invokes the slow - path interrupt attention * handling function and fast - path interrupt attention handling function in * turn to process the relevant HBA attention events . This function is called * without any lock held . It gets the hbalock to access and update SLI data * structures . * * This function returns IRQ_HANDLED when interrupt is handled , else it * returns IRQ_NONE . int irq, void *dev_id)struct lpfc_hba *phba;bool hba_handled = false ;int qidx;/* Get the driver's phba structure from the dev_id */ struct lpfc_hba *)dev_id;if (unlikely(!phba))return IRQ_NONE;/* * Invoke fast - path host attention interrupt handling as appropriate . for (qidx = 0 ; qidx < phba->cfg_irq_chann; qidx++) {if (hba_irq_rc == IRQ_HANDLED)true ;return (hba_handled == true ) ? IRQ_HANDLED : IRQ_NONE;/* lpfc_sli4_intr_handler */ void lpfc_sli4_poll_hbtimer(struct timer_list *t)struct lpfc_hba *phba = timer_container_of(phba, t, cpuhp_poll_timer);struct lpfc_queue *eq;if (!list_empty(&phba->poll_list))static inline void lpfc_sli4_add_to_poll_list(struct lpfc_queue *eq)struct lpfc_hba *phba = eq->phba;/* kickstart slowpath processing if needed */ if (list_empty(&phba->poll_list))static inline void lpfc_sli4_remove_from_poll_list(struct lpfc_queue *eq)struct lpfc_hba *phba = eq->phba;/* Disable slowpath processing for this eq. Kick start the eq * by RE - ARMING the eq ' s ASAP if (list_empty(&phba->poll_list))void lpfc_sli4_cleanup_poll_list(struct lpfc_hba *phba)struct lpfc_queue *eq, *next;static inline void struct lpfc_queue *eq, uint8_t mode)if (mode == eq->mode)return ;/* * currently this function is only called during a hotplug * event and the cpu on which this function is executing * is going offline . By now the hotplug has instructed * the scheduler to remove this cpu from cpu active mask . * So we don ' t need to work about being put aside by the * scheduler for a high priority process . Yes , the inte - * rrupts could come but they are known to retire ASAP . /* Disable polling in the fastpath */ /* flush out the store buffer */ /* * Add this eq to the polling list and start polling . For * a grace period both interrupt handler and poller will * try to process the eq _ but_ that ' s fine . We have a * synchronization mechanism in place ( queue_claimed ) to * deal with it . This is just a draining phase for int - * errupt handler ( not eq ' s ) as we have guranteed through * barrier that all the CPUs have seen the new CQ_POLLED * state . which will effectively disable the REARMING of * the EQ . The whole idea is eq ' s die off eventually as * we are not rearming EQ ' s anymore . void lpfc_sli4_start_polling(struct lpfc_queue *eq)void lpfc_sli4_stop_polling(struct lpfc_queue *eq)struct lpfc_hba *phba = eq->phba;/* Kick start for the pending io's in h/w. * Once we switch back to interrupt processing on a eq * the io path completion will only arm eq ' s when it * receives a completion . But since eq ' s are in disa - * rmed state it doesn ' t receive a completion . This * creates a deadlock scenaro . 0 , LPFC_QUEUE_REARM);/** * lpfc_sli4_queue_free - free a queue structure and associated memory * @ queue : The queue structure to free . * * This function frees a queue structure and the DMAable memory used for * the host resident queue . This function must be called after destroying the * queue on the HBA . void struct lpfc_queue *queue)struct lpfc_dmabuf *dmabuf;if (!queue)return ;if (!list_empty(&queue->wq_list))while (!list_empty(&queue->page_list)) {struct lpfc_dmabuf,if (queue->rqbp) {if (!list_empty(&queue->cpu_list))return ;/** * lpfc_sli4_queue_alloc - Allocate and initialize a queue structure * @ phba : The HBA that this queue is being created on . * @ page_size : The size of a queue page * @ entry_size : The size of each queue entry for this queue . * @ entry_count : The number of entries that this queue will handle . * @ cpu : The cpu that will primarily utilize this queue . * * This function allocates a queue structure and the DMAable memory used for * the host resident queue . This function must be called before creating the * queue on the HBA . struct lpfc_queue *struct lpfc_hba *phba, uint32_t page_size,int cpu)struct lpfc_queue *queue;struct lpfc_dmabuf *dmabuf;if (!phba->sli4_hba.pc_sli4_params.supported)/* If needed, Adjust page count to match the max the adapter supports */ if (pgcnt > phba->sli4_hba.pc_sli4_params.wqpcnt)sizeof (*queue) + (sizeof (void *) * pgcnt),if (!queue)return NULL;/* Set queue parameters now. If the system cannot provide memory * resources , the free routine needs to know what was allocated . void **)&queue[1 ];for (x = 0 ; x < queue->page_count; x++) {sizeof (*dmabuf), GFP_KERNEL,if (!dmabuf)goto out_fail;if (!dmabuf->virt) {goto out_fail;/* use lpfc_sli4_qe to index a paritcular entry in this page */ /* notify_interval will be set during q creation */ return queue;return NULL;/** * lpfc_dual_chute_pci_bar_map - Map pci base address register to host memory * @ phba : HBA structure that indicates port to create a queue on . * @ pci_barset : PCI BAR set flag . * * This function shall perform iomap of the specified PCI BAR address to host * memory address if not already done so and return it . The returned host * memory address can be NULL . static void __iomem *struct lpfc_hba *phba, uint16_t pci_barset)if (!phba->pcidev)return NULL;switch (pci_barset) {case WQ_PCI_BAR_0_AND_1:return phba->pci_bar0_memmap_p;case WQ_PCI_BAR_2_AND_3:return phba->pci_bar2_memmap_p;case WQ_PCI_BAR_4_AND_5:return phba->pci_bar4_memmap_p;default :break ;return NULL;/** * lpfc_modify_hba_eq_delay - Modify Delay Multiplier on EQs * @ phba : HBA structure that EQs are on . * @ startq : The starting EQ index to modify * @ numq : The number of EQs ( consecutive indexes ) to modify * @ usdelay : amount of delay * * This function revises the EQ delay on 1 or more EQs . The EQ delay * is set either by writing to a register ( if supported by the SLI Port ) * or by mailbox command . The mailbox command allows several EQs to be * updated at once . * * The @ phba struct is used to send a mailbox command to HBA . The @ startq * is used to get the starting EQ index to change . The @ numq value is * used to specify how many consecutive EQ indexes , starting at EQ index , * are to be changed . This function is asynchronous and will wait for any * mailbox commands to finish before returning . * * On success this function will return a zero . If unable to allocate * enough memory this function will return - ENOMEM . If a mailbox command * fails this function will return - ENXIO . Note : on ENXIO , some EQs may * have had their delay multipler changed . void struct lpfc_hba *phba, uint32_t startq,struct lpfc_mbx_modify_eq_delay *eq_delay;struct lpfc_queue *eq;int cnt = 0 , rc, length;int qidx;union lpfc_sli4_cfg_shdr *shdr;if (startq >= phba->cfg_irq_chann)return ;if (usdelay > 0 xFFFF) {"6429 usdelay %d too large. Scaled down to " "0xFFFF.\n" , usdelay);0 xFFFF;/* set values by EQ_DELAY register if supported */ if (phba->sli.sli_flag & LPFC_SLI_USE_EQDR) {for (qidx = startq; qidx < phba->cfg_irq_chann; qidx++) {if (!eq)continue ;if (++cnt >= numq)break ;return ;/* Otherwise, set values by mailbox cmd */ if (!mbox) {"6428 Failed allocating mailbox cmd buffer." " EQ delay was not set.\n" );return ;sizeof (struct lpfc_mbx_modify_eq_delay) -sizeof (struct lpfc_sli4_cfg_mhdr));/* Calculate delay multiper from maximum interrupt per second */ if (dmult)if (dmult > LPFC_DMULT_MAX)for (qidx = startq; qidx < phba->cfg_irq_chann; qidx++) {if (!eq)continue ;0 ;if (++cnt >= numq)break ;union lpfc_sli4_cfg_shdr *) &eq_delay->header.cfg_shdr;if (shdr_status || shdr_add_status || rc) {"2512 MODIFY_EQ_DELAY mailbox failed with " "status x%x add_status x%x, mbx status x%x\n" ,return ;/** * lpfc_eq_create - Create an Event Queue on the HBA * @ phba : HBA structure that indicates port to create a queue on . * @ eq : The queue structure to use to create the event queue . * @ imax : The maximum interrupt per second limit . * * This function creates an event queue , as detailed in @ eq , on a port , * described by @ phba by sending an EQ_CREATE mailbox command to the HBA . * * The @ phba struct is used to send mailbox command to HBA . The @ eq struct * is used to get the entry count and entry size that are necessary to * determine the number of pages to allocate and use for this queue . This * function will send the EQ_CREATE mailbox command to the HBA to setup the * event queue . This function is asynchronous and will wait for the mailbox * command to finish before continuing . * * On success this function will return a zero . If unable to allocate enough * memory this function will return - ENOMEM . If the queue create mailbox command * fails this function will return - ENXIO . int struct lpfc_hba *phba, struct lpfc_queue *eq, uint32_t imax)struct lpfc_mbx_eq_create *eq_create;int rc, length, status = 0 ;struct lpfc_dmabuf *dmabuf;union lpfc_sli4_cfg_shdr *shdr;/* sanity check on queue memory */ if (!eq)return -ENODEV;if (!phba->sli4_hba.pc_sli4_params.supported)if (!mbox)return -ENOMEM;sizeof (struct lpfc_mbx_eq_create) -sizeof (struct lpfc_sli4_cfg_mhdr));union lpfc_sli4_cfg_shdr *) &eq_create->header.cfg_shdr;1 );/* Use version 2 of CREATE_EQ if eqav is set */ if (phba->sli4_hba.pc_sli4_params.eqav) {/* don't setup delay multiplier using EQ_CREATE */ 0 ;switch (eq->entry_count) {default :"0360 Unsupported EQ count. (%d)\n" ,if (eq->entry_count < 256 ) {goto out;/* otherwise default to smallest count */ case 256 :break ;case 512 :break ;case 1024 :break ;case 2048 :break ;case 4096 :break ;0 , hw_page_size);if (shdr_status || shdr_add_status || rc) {"2500 EQ_CREATE mailbox failed with " "status x%x add_status x%x, mbx status x%x\n" ,if (eq->queue_id == 0 xFFFF)0 ;return status;/** * lpfc_sli4_hba_intr_handler_th - SLI4 HBA threaded interrupt handler * @ irq : Interrupt number . * @ dev_id : The device context pointer . * * This routine is a mirror of lpfc_sli4_hba_intr_handler , but executed within * threaded irq context . * * Returns * IRQ_HANDLED - interrupt is handled * IRQ_NONE - otherwise int irq, void *dev_id)struct lpfc_hba *phba;struct lpfc_hba_eq_hdl *hba_eq_hdl;struct lpfc_queue *fpeq;int ecount = 0 ;int hba_eqidx;struct lpfc_eq_intr_info *eqi;/* Get the driver's phba structure from the dev_id */ struct lpfc_hba_eq_hdl *)dev_id;if (unlikely(!phba))return IRQ_NONE;if (unlikely(!phba->sli4_hba.hdwq))return IRQ_NONE;/* Get to the EQ struct associated with this vector */ if (unlikely(!fpeq))return IRQ_NONE;if (eqi->icnt > LPFC_EQD_ISR_TRIGGER &&/* process and rearm the EQ */ if (unlikely(ecount == 0 )) {if (phba->intr_type == MSIX)/* MSI-X treated interrupt served as no EQ share INT */ "3358 MSI-X interrupt with no EQE\n" );else /* Non MSI-X treated on interrupt as EQ share INT */ return IRQ_NONE;return IRQ_HANDLED;/** * lpfc_cq_create - Create a Completion Queue on the HBA * @ phba : HBA structure that indicates port to create a queue on . * @ cq : The queue structure to use to create the completion queue . * @ eq : The event queue to bind this completion queue to . * @ type : Type of queue ( EQ , GCQ , MCQ , WCQ , etc ) . * @ subtype : Functional purpose of the queue ( MBOX , IO , ELS , NVMET , etc ) . * * This function creates a completion queue , as detailed in @ wq , on a port , * described by @ phba by sending a CQ_CREATE mailbox command to the HBA . * * The @ phba struct is used to send mailbox command to HBA . The @ cq struct * is used to get the entry count and entry size that are necessary to * determine the number of pages to allocate and use for this queue . The @ eq * is used to indicate which event queue to bind this completion queue to . This * function will send the CQ_CREATE mailbox command to the HBA to setup the * completion queue . This function is asynchronous and will wait for the mailbox * command to finish before continuing . * * On success this function will return a zero . If unable to allocate enough * memory this function will return - ENOMEM . If the queue create mailbox command * fails this function will return - ENXIO . int struct lpfc_hba *phba, struct lpfc_queue *cq,struct lpfc_queue *eq, uint32_t type, uint32_t subtype)struct lpfc_mbx_cq_create *cq_create;struct lpfc_dmabuf *dmabuf;int rc, length, status = 0 ;union lpfc_sli4_cfg_shdr *shdr;/* sanity check on queue memory */ if (!cq || !eq)return -ENODEV;if (!mbox)return -ENOMEM;sizeof (struct lpfc_mbx_cq_create) -sizeof (struct lpfc_sli4_cfg_mhdr));union lpfc_sli4_cfg_shdr *) &cq_create->header.cfg_shdr;1 );1 );if (phba->sli4_hba.pc_sli4_params.cqv == LPFC_Q_CREATE_VERSION_2) {else {switch (cq->entry_count) {case 2048 :case 4096 :if (phba->sli4_hba.pc_sli4_params.cqv ==break ;default :"0361 Unsupported CQ count: " "entry cnt %d sz %d pg cnt %d\n" ,if (cq->entry_count < 256 ) {goto out;/* otherwise default to smallest count */ case 256 :break ;case 512 :break ;case 1024 :break ;0 , cq->page_size);/* The IOCTL status is embedded in the mailbox subheader. */ if (shdr_status || shdr_add_status || rc) {"2501 CQ_CREATE mailbox failed with " "status x%x add_status x%x, mbx status x%x\n" ,goto out;if (cq->queue_id == 0 xFFFF) {goto out;/* link the cq onto the parent eq child list */ /* Set up completion queue's type and subtype */ 0 ;if (cq->queue_id > phba->sli4_hba.cq_max)return status;/** * lpfc_cq_create_set - Create a set of Completion Queues on the HBA for MRQ * @ phba : HBA structure that indicates port to create a queue on . * @ cqp : The queue structure array to use to create the completion queues . * @ hdwq : The hardware queue array with the EQ to bind completion queues to . * @ type : Type of queue ( EQ , GCQ , MCQ , WCQ , etc ) . * @ subtype : Functional purpose of the queue ( MBOX , IO , ELS , NVMET , etc ) . * * This function creates a set of completion queue , s to support MRQ * as detailed in @ cqp , on a port , * described by @ phba by sending a CREATE_CQ_SET mailbox command to the HBA . * * The @ phba struct is used to send mailbox command to HBA . The @ cq struct * is used to get the entry count and entry size that are necessary to * determine the number of pages to allocate and use for this queue . The @ eq * is used to indicate which event queue to bind this completion queue to . This * function will send the CREATE_CQ_SET mailbox command to the HBA to setup the * completion queue . This function is asynchronous and will wait for the mailbox * command to finish before continuing . * * On success this function will return a zero . If unable to allocate enough * memory this function will return - ENOMEM . If the queue create mailbox command * fails this function will return - ENXIO . int struct lpfc_hba *phba, struct lpfc_queue **cqp,struct lpfc_sli4_hdw_queue *hdwq, uint32_t type,struct lpfc_queue *cq;struct lpfc_queue *eq;struct lpfc_mbx_cq_create_set *cq_set;struct lpfc_dmabuf *dmabuf;int rc, length, alloclen, status = 0 ;int cnt, idx, numcq, page_idx = 0 ;union lpfc_sli4_cfg_shdr *shdr;/* sanity check on queue memory */ if (!cqp || !hdwq || !numcq)return -ENODEV;if (!mbox)return -ENOMEM;sizeof (struct lpfc_mbx_cq_create_set);0 ]->page_count) *sizeof (struct dma_address));if (alloclen < length) {"3098 Allocated DMA memory size (%d) is " "less than the requested DMA memory size " "(%d)\n" , alloclen, length);goto out;0 ];union lpfc_sli4_cfg_shdr *)&cq_set->cfg_shdr;0 );for (idx = 0 ; idx < numcq; idx++) {if (!cq || !eq) {goto out;if (!phba->sli4_hba.pc_sli4_params.supported)switch (idx) {case 0 :1 );1 );0 );switch (cq->entry_count) {case 2048 :case 4096 :if (phba->sli4_hba.pc_sli4_params.cqv ==break ;default :"3118 Bad CQ count. (%d)\n" ,if (cq->entry_count < 256 ) {goto out;/* otherwise default to smallest */ case 256 :break ;case 512 :break ;case 1024 :break ;break ;case 1 :break ;case 2 :break ;case 3 :break ;case 4 :break ;case 5 :break ;case 6 :break ;case 7 :break ;case 8 :break ;case 9 :break ;case 10 :break ;case 11 :break ;case 12 :break ;case 13 :break ;case 14 :break ;case 15 :break ;/* link the cq onto the parent eq child list */ /* Set up completion queue's type and subtype */ 0 ;0 ;0 , hw_page_size);/* The IOCTL status is embedded in the mailbox subheader. */ if (shdr_status || shdr_add_status || rc) {"3119 CQ_CREATE_SET mailbox failed with " "status x%x add_status x%x, mbx status x%x\n" ,goto out;if (rc == 0 xFFFF) {goto out;for (idx = 0 ; idx < numcq; idx++) {if (cq->queue_id > phba->sli4_hba.cq_max)return status;/** * lpfc_mq_create_fb_init - Send MCC_CREATE without async events registration * @ phba : HBA structure that indicates port to create a queue on . * @ mq : The queue structure to use to create the mailbox queue . * @ mbox : An allocated pointer to type LPFC_MBOXQ_t * @ cq : The completion queue to associate with this cq . * * This function provides failback ( fb ) functionality when the * mq_create_ext fails on older FW generations . It ' s purpose is identical * to mq_create_ext otherwise . * * This routine cannot fail as all attributes were previously accessed and * initialized in mq_create_ext . static void struct lpfc_hba *phba, struct lpfc_queue *mq,struct lpfc_queue *cq)struct lpfc_mbx_mq_create *mq_create;struct lpfc_dmabuf *dmabuf;int length;sizeof (struct lpfc_mbx_mq_create) -sizeof (struct lpfc_sli4_cfg_mhdr));1 );switch (mq->entry_count) {case 16 :break ;case 32 :break ;case 64 :break ;case 128 :break ;/** * lpfc_mq_create - Create a mailbox Queue on the HBA * @ phba : HBA structure that indicates port to create a queue on . * @ mq : The queue structure to use to create the mailbox queue . * @ cq : The completion queue to associate with this cq . * @ subtype : The queue ' s subtype . * * This function creates a mailbox queue , as detailed in @ mq , on a port , * described by @ phba by sending a MQ_CREATE mailbox command to the HBA . * * The @ phba struct is used to send mailbox command to HBA . The @ cq struct * is used to get the entry count and entry size that are necessary to * determine the number of pages to allocate and use for this queue . This * function will send the MQ_CREATE mailbox command to the HBA to setup the * mailbox queue . This function is asynchronous and will wait for the mailbox * command to finish before continuing . * * On success this function will return a zero . If unable to allocate enough * memory this function will return - ENOMEM . If the queue create mailbox command * fails this function will return - ENXIO . struct lpfc_hba *phba, struct lpfc_queue *mq,struct lpfc_queue *cq, uint32_t subtype)struct lpfc_mbx_mq_create *mq_create;struct lpfc_mbx_mq_create_ext *mq_create_ext;struct lpfc_dmabuf *dmabuf;int rc, length, status = 0 ;union lpfc_sli4_cfg_shdr *shdr;/* sanity check on queue memory */ if (!mq || !cq)return -ENODEV;if (!phba->sli4_hba.pc_sli4_params.supported)if (!mbox)return -ENOMEM;sizeof (struct lpfc_mbx_mq_create_ext) -sizeof (struct lpfc_sli4_cfg_mhdr));union lpfc_sli4_cfg_shdr *) &mq_create_ext->header.cfg_shdr;1 );1 );1 );1 );1 );1 );if (phba->sli4_hba.pc_sli4_params.mqv == LPFC_Q_CREATE_VERSION_1)else switch (mq->entry_count) {default :"0362 Unsupported MQ count. (%d)\n" ,if (mq->entry_count < 16 ) {goto out;/* otherwise default to smallest count */ case 16 :break ;case 32 :break ;case 64 :break ;case 128 :break ;0 , hw_page_size);if (rc != MBX_SUCCESS) {"2795 MQ_CREATE_EXT failed with " "status x%x. Failback to MQ_CREATE.\n" ,union lpfc_sli4_cfg_shdr *) &mq_create->header.cfg_shdr;/* The IOCTL status is embedded in the mailbox subheader. */ if (shdr_status || shdr_add_status || rc) {"2502 MQ_CREATE mailbox failed with " "status x%x add_status x%x, mbx status x%x\n" ,goto out;if (mq->queue_id == 0 xFFFF) {goto out;0 ;0 ;/* link the mq onto the parent cq child list */ return status;/** * lpfc_wq_create - Create a Work Queue on the HBA * @ phba : HBA structure that indicates port to create a queue on . * @ wq : The queue structure to use to create the work queue . * @ cq : The completion queue to bind this work queue to . * @ subtype : The subtype of the work queue indicating its functionality . * * This function creates a work queue , as detailed in @ wq , on a port , described * by @ phba by sending a WQ_CREATE mailbox command to the HBA . * * The @ phba struct is used to send mailbox command to HBA . The @ wq struct * is used to get the entry count and entry size that are necessary to * determine the number of pages to allocate and use for this queue . The @ cq * is used to indicate which completion queue to bind this work queue to . This * function will send the WQ_CREATE mailbox command to the HBA to setup the * work queue . This function is asynchronous and will wait for the mailbox * command to finish before continuing . * * On success this function will return a zero . If unable to allocate enough * memory this function will return - ENOMEM . If the queue create mailbox command * fails this function will return - ENXIO . int struct lpfc_hba *phba, struct lpfc_queue *wq,struct lpfc_queue *cq, uint32_t subtype)struct lpfc_mbx_wq_create *wq_create;struct lpfc_dmabuf *dmabuf;int rc, length, status = 0 ;union lpfc_sli4_cfg_shdr *shdr;struct dma_address *page;void __iomem *bar_memmap_p;#ifdef CONFIG_X86unsigned long pg_addr;#endif /* sanity check on queue memory */ if (!wq || !cq)return -ENODEV;if (!phba->sli4_hba.pc_sli4_params.supported)if (!mbox)return -ENOMEM;sizeof (struct lpfc_mbx_wq_create) -sizeof (struct lpfc_sli4_cfg_mhdr));union lpfc_sli4_cfg_shdr *) &wq_create->header.cfg_shdr;/* wqv is the earliest version supported, NOT the latest */ if ((phba->sli4_hba.pc_sli4_params.wqsize & LPFC_WQ_SZ128_SUPPORT) ||else switch (wq_create_version) {case LPFC_Q_CREATE_VERSION_1:switch (wq->entry_size) {default :case 64 :break ;case 128 :break ;/* Request DPP by default */ 1 );break ;default :break ;0 , hw_page_size);if (phba->sli4_hba.fw_func_mode & LPFC_DUA_MODE)1 );/* The IOCTL status is embedded in the mailbox subheader. */ if (shdr_status || shdr_add_status || rc) {"2503 WQ_CREATE mailbox failed with " "status x%x add_status x%x, mbx status x%x\n" ,goto out;if (wq_create_version == LPFC_Q_CREATE_VERSION_0)else if (wq->queue_id == 0 xFFFF) {goto out;if (wq_create_version == LPFC_Q_CREATE_VERSION_0) {if (phba->sli4_hba.fw_func_mode & LPFC_DUA_MODE) {if ((wq->db_format != LPFC_DB_LIST_FORMAT) &&"3265 WQ[%d] doorbell format " "not supported: x%x\n" ,goto out;if (!bar_memmap_p) {"3263 WQ[%d] failed to memmap " "pci barset:x%x\n" ,goto out;if ((db_offset != LPFC_ULP0_WQ_DOORBELL) &&"3252 WQ[%d] doorbell offset " "not supported: x%x\n" ,goto out;"3264 WQ[%d]: barset:x%x, offset:x%x, " "format:x%x\n" , wq->queue_id,else else {/* Check if DPP was honored by the firmware */ if (wq->dpp_enable) {if (!bar_memmap_p) {"3267 WQ[%d] failed to memmap " "pci barset:x%x\n" ,goto out;if (!bar_memmap_p) {"3268 WQ[%d] failed to memmap " "pci barset:x%x\n" ,goto out;"3271 WQ[%d]: barset:x%x, offset:x%x, " "dpp_id:x%x dpp_barset:x%x " "dpp_offset:x%x\n" ,#ifdef CONFIG_X86/* Enable combined writes for DPP aperture */ unsigned long )(wq->dpp_regaddr) & PAGE_MASK;1 );if (rc) {"3272 Cannot setup Combined " "Write on WQ[%d] - disable DPP\n" ,0 ;#else 0 ;#endif else sizeof (struct lpfc_sli_ring), GFP_KERNEL);if (wq->pring == NULL) {goto out;0 ;0 ;/* link the wq onto the parent cq child list */ return status;/** * lpfc_rq_create - Create a Receive Queue on the HBA * @ phba : HBA structure that indicates port to create a queue on . * @ hrq : The queue structure to use to create the header receive queue . * @ drq : The queue structure to use to create the data receive queue . * @ cq : The completion queue to bind this work queue to . * @ subtype : The subtype of the work queue indicating its functionality . * * This function creates a receive buffer queue pair , as detailed in @ hrq and * @ drq , on a port , described by @ phba by sending a RQ_CREATE mailbox command * to the HBA . * * The @ phba struct is used to send mailbox command to HBA . The @ drq and @ hrq * struct is used to get the entry count that is necessary to determine the * number of pages to use for this queue . The @ cq is used to indicate which * completion queue to bind received buffers that are posted to these queues to . * This function will send the RQ_CREATE mailbox command to the HBA to setup the * receive queue pair . This function is asynchronous and will wait for the * mailbox command to finish before continuing . * * On success this function will return a zero . If unable to allocate enough * memory this function will return - ENOMEM . If the queue create mailbox command * fails this function will return - ENXIO . int struct lpfc_hba *phba, struct lpfc_queue *hrq,struct lpfc_queue *drq, struct lpfc_queue *cq, uint32_t subtype)struct lpfc_mbx_rq_create *rq_create;struct lpfc_dmabuf *dmabuf;int rc, length, status = 0 ;union lpfc_sli4_cfg_shdr *shdr;void __iomem *bar_memmap_p;/* sanity check on queue memory */ if (!hrq || !drq || !cq)return -ENODEV;if (!phba->sli4_hba.pc_sli4_params.supported)if (hrq->entry_count != drq->entry_count)return -EINVAL;if (!mbox)return -ENOMEM;sizeof (struct lpfc_mbx_rq_create) -sizeof (struct lpfc_sli4_cfg_mhdr));union lpfc_sli4_cfg_shdr *) &rq_create->header.cfg_shdr;if (phba->sli4_hba.pc_sli4_params.rqv == LPFC_Q_CREATE_VERSION_1) {else {switch (hrq->entry_count) {default :"2535 Unsupported RQ count. (%d)\n" ,if (hrq->entry_count < 512 ) {goto out;/* otherwise default to smallest count */ case 512 :
Messung V0.5 in Prozent C=94 H=89 G=91
¤ Dauer der Verarbeitung: 1.738 Sekunden
(vorverarbeitet am 2026-09-27)
¤ *© Formatika GbR, Deutschland
