#include <mii.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <byteswap.h>
#include <ipxe/pci.h>
#include <ipxe/iobuf.h>
#include <ipxe/timer.h>
#include <ipxe/malloc.h>
#include <ipxe/if_ether.h>
#include <ipxe/ethernet.h>
#include <ipxe/netdevice.h>
#include "bnxt.h"
#include "bnxt_dbg.h"

Macros
#define	bnxt_down_chip(bp) bnxt_hwrm_run ( bring_down_chip, bp )

#define	bnxt_up_chip(bp) bnxt_hwrm_run ( bring_up_chip, bp )

#define	bnxt_down_nic(bp) bnxt_hwrm_run ( bring_down_nic, bp )

#define	bnxt_up_nic(bp) bnxt_hwrm_run ( bring_up_nic, bp )

Typedefs
typedef int(*	hwrm_func_t) (struct bnxt *bp)

Functions
	FILE_LICENCE (GPL2_ONLY)

static void	bnxt_service_cq (struct net_device *dev)

static void	bnxt_tx_complete (struct net_device *dev, u16 hw_idx)

static void	bnxt_adv_cq_index (struct bnxt *bp, u16 cnt)

static int	bnxt_rx_complete (struct net_device dev, struct rx_pkt_cmpl rx)

void	bnxt_link_evt (struct bnxt bp, struct hwrm_async_event_cmpl evt)

u8	bnxt_is_pci_vf (struct pci_device *pdev)
	Check if Virtual Function. More...

static void	bnxt_down_pci (struct bnxt *bp)

static void *	bnxt_pci_base (struct pci_device *pdev, unsigned int reg)

static int	bnxt_get_pci_info (struct bnxt *bp)

static int	bnxt_get_device_address (struct bnxt *bp)

static void	bnxt_set_link (struct bnxt *bp)

static void	thor_db (struct bnxt *bp, u32 idx, u32 xid, u32 flag)

static void	bnxt_db_nq (struct bnxt *bp)

static void	bnxt_db_cq (struct bnxt *bp)

static void	bnxt_db_rx (struct bnxt *bp, u32 idx)

static void	bnxt_db_tx (struct bnxt *bp, u32 idx)

void	bnxt_add_vlan (struct io_buffer *iob, u16 vlan)

static u16	bnxt_get_pkt_vlan (char *src)

int	bnxt_vlan_drop (struct bnxt *bp, u16 rx_vlan)

static u32	bnxt_tx_avail (struct bnxt *bp)

void	bnxt_set_txq (struct bnxt *bp, int entry, dma_addr_t mapping, int len)

int	bnxt_free_rx_iob (struct bnxt *bp)

static void	bnxt_set_rx_desc (u8 buf, struct io_buffer iob, u16 cid, u32 idx)

static int	bnxt_alloc_rx_iob (struct bnxt *bp, u16 cons_id, u16 iob_idx)

int	bnxt_post_rx_buffers (struct bnxt *bp)

u8	bnxt_rx_drop (struct bnxt bp, struct io_buffer iob, struct rx_pkt_cmpl_hi *rx_cmp_hi, u16 rx_len)

void	bnxt_rx_process (struct net_device dev, struct bnxt bp, struct rx_pkt_cmpl rx_cmp, struct rx_pkt_cmpl_hi rx_cmp_hi)

void	bnxt_mm_init (struct bnxt bp, const char func)

void	bnxt_mm_nic (struct bnxt *bp)

void	bnxt_free_mem (struct bnxt *bp)

int	bnxt_alloc_mem (struct bnxt *bp)

static void	hwrm_init (struct bnxt bp, struct input req, u16 cmd, u16 len)

static void	hwrm_write_req (struct bnxt bp, void req, u32 cnt)

static void	short_hwrm_cmd_req (struct bnxt *bp, u16 len)

static int	wait_resp (struct bnxt bp, u32 tmo, u16 len, const char func)

static int	bnxt_hwrm_ver_get (struct bnxt *bp)

static int	bnxt_hwrm_func_resource_qcaps (struct bnxt *bp)

static u32	bnxt_set_ring_info (struct bnxt *bp)

static void	bnxt_hwrm_assign_resources (struct bnxt *bp)

static int	bnxt_hwrm_func_qcaps_req (struct bnxt *bp)

static int	bnxt_hwrm_func_qcfg_req (struct bnxt *bp)

static int	bnxt_hwrm_func_reset_req (struct bnxt *bp)

static int	bnxt_hwrm_func_cfg_req (struct bnxt *bp)

static int	bnxt_hwrm_func_drv_rgtr (struct bnxt *bp)

static int	bnxt_hwrm_func_drv_unrgtr (struct bnxt *bp)

static int	bnxt_hwrm_set_async_event (struct bnxt *bp)

static int	bnxt_hwrm_cfa_l2_filter_alloc (struct bnxt *bp)

static int	bnxt_hwrm_cfa_l2_filter_free (struct bnxt *bp)

u32	set_rx_mask (u32 rx_mask)

static int	bnxt_hwrm_set_rx_mask (struct bnxt *bp, u32 rx_mask)

static int	bnxt_hwrm_port_phy_qcfg (struct bnxt *bp, u16 idx)

static int	bnxt_hwrm_nvm_get_variable_req (struct bnxt *bp, u16 data_len, u16 option_num, u16 dimensions, u16 index_0)

static int	bnxt_get_link_speed (struct bnxt *bp)

static int	bnxt_get_vlan (struct bnxt *bp)

static int	bnxt_hwrm_backing_store_qcfg (struct bnxt *bp)

static int	bnxt_hwrm_backing_store_cfg (struct bnxt *bp)

static int	bnxt_hwrm_queue_qportcfg (struct bnxt *bp)

static int	bnxt_hwrm_port_mac_cfg (struct bnxt *bp)

static int	bnxt_hwrm_port_phy_cfg (struct bnxt *bp)

static int	bnxt_query_phy_link (struct bnxt *bp)

static int	bnxt_get_phy_link (struct bnxt *bp)

static int	bnxt_hwrm_stat_ctx_alloc (struct bnxt *bp)

static int	bnxt_hwrm_stat_ctx_free (struct bnxt *bp)

static int	bnxt_hwrm_ring_free_grp (struct bnxt *bp)

static int	bnxt_hwrm_ring_alloc_grp (struct bnxt *bp)

int	bnxt_hwrm_ring_free (struct bnxt *bp, u16 ring_id, u8 ring_type)

static int	bnxt_hwrm_ring_alloc (struct bnxt *bp, u8 type)

static int	bnxt_hwrm_ring_alloc_cq (struct bnxt *bp)

static int	bnxt_hwrm_ring_alloc_tx (struct bnxt *bp)

static int	bnxt_hwrm_ring_alloc_rx (struct bnxt *bp)

static int	bnxt_hwrm_ring_free_cq (struct bnxt *bp)

static int	bnxt_hwrm_ring_free_tx (struct bnxt *bp)

static int	bnxt_hwrm_ring_free_rx (struct bnxt *bp)

static int	bnxt_hwrm_ring_alloc_nq (struct bnxt *bp)

static int	bnxt_hwrm_ring_free_nq (struct bnxt *bp)

static int	bnxt_hwrm_vnic_alloc (struct bnxt *bp)

static int	bnxt_hwrm_vnic_free (struct bnxt *bp)

static int	bnxt_hwrm_vnic_cfg (struct bnxt *bp)

static int	bnxt_set_rx_mask (struct bnxt *bp)

static int	bnxt_reset_rx_mask (struct bnxt *bp)

int	bnxt_hwrm_run (hwrm_func_t cmds[], struct bnxt *bp)

static int	bnxt_open (struct net_device *dev)

static void	bnxt_tx_adjust_pkt (struct bnxt bp, struct io_buffer iob)

static int	bnxt_tx (struct net_device dev, struct io_buffer iob)

static void	bnxt_adv_nq_index (struct bnxt *bp, u16 cnt)

static void	bnxt_service_nq (struct net_device *dev)

static void	bnxt_poll (struct net_device *dev)

static void	bnxt_close (struct net_device *dev)

static int	bnxt_init_one (struct pci_device *pci)

static void	bnxt_remove_one (struct pci_device *pci)

Variables
static struct pci_device_id	bnxt_nics []

hwrm_func_t	bring_down_chip []

hwrm_func_t	bring_down_nic []

hwrm_func_t	bring_up_chip []

hwrm_func_t	bring_up_nic []

static struct net_device_operations	bnxt_netdev_ops

struct pci_driver bnxt_pci_driver	__pci_driver

Macro Definition Documentation

◆ bnxt_down_chip

#define bnxt_down_chip ( bp ) bnxt_hwrm_run ( bring_down_chip, bp )

Definition at line 1923 of file bnxt.c.

◆ bnxt_up_chip

#define bnxt_up_chip ( bp ) bnxt_hwrm_run ( bring_up_chip, bp )

Definition at line 1924 of file bnxt.c.

◆ bnxt_down_nic

#define bnxt_down_nic ( bp ) bnxt_hwrm_run ( bring_down_nic, bp )

Definition at line 1925 of file bnxt.c.

◆ bnxt_up_nic

#define bnxt_up_nic ( bp ) bnxt_hwrm_run ( bring_up_nic, bp )

Definition at line 1926 of file bnxt.c.

Typedef Documentation

◆ hwrm_func_t

typedef int( * hwrm_func_t) (struct bnxt *bp)

Definition at line 1850 of file bnxt.c.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_ONLY )

◆ bnxt_service_cq()

static void bnxt_service_cq ( struct net_device * dev )

static

Definition at line 2010 of file bnxt.c.

 {
         struct bnxt *bp = netdev_priv ( dev );
         struct cmpl_base *cmp;
         struct tx_cmpl *tx;
         u16 old_cid = bp->cq.cons_id;
         int done = SERVICE_NEXT_CQ_BD;
         u32 cq_type;
 
         while ( done == SERVICE_NEXT_CQ_BD ) {
                 cmp = ( struct cmpl_base * )BD_NOW ( bp->cq.bd_virt,
                                                 bp->cq.cons_id,
                                                 sizeof ( struct cmpl_base ) );
 
                 if ( ( cmp->info3_v & CMPL_BASE_V ) ^ bp->cq.completion_bit )
                         break;
 
                 cq_type = cmp->type & CMPL_BASE_TYPE_MASK;
                 dump_evt ( ( u8 * )cmp, cq_type, bp->cq.cons_id, 0 );
                 dump_cq ( cmp, bp->cq.cons_id );
 
                 switch ( cq_type ) {
                 case CMPL_BASE_TYPE_TX_L2:
                         tx = ( struct tx_cmpl * )cmp;
                         bnxt_tx_complete ( dev, ( u16 )tx->opaque );
                 /* Fall through */
                 case CMPL_BASE_TYPE_STAT_EJECT:
                         bnxt_adv_cq_index ( bp, 1 );
                         break;
                 case CMPL_BASE_TYPE_RX_L2:
                         done = bnxt_rx_complete ( dev,
                                 ( struct rx_pkt_cmpl * )cmp );
                         break;
                 case CMPL_BASE_TYPE_HWRM_ASYNC_EVENT:
                         bnxt_link_evt ( bp,
                                 ( struct hwrm_async_event_cmpl * )cmp );
                         bnxt_adv_cq_index ( bp, 1 );
                         break;
                 default:
                         done = NO_MORE_CQ_BD_TO_SERVICE;
                         break;
                 }
         }
 
         if ( bp->cq.cons_id != old_cid )
                 bnxt_db_cq ( bp );
 }

References BD_NOW, bnxt_adv_cq_index(), bnxt_db_cq(), bnxt_link_evt(), bnxt_rx_complete(), bnxt_tx_complete(), bp, CMPL_BASE_TYPE_HWRM_ASYNC_EVENT, CMPL_BASE_TYPE_MASK, CMPL_BASE_TYPE_RX_L2, CMPL_BASE_TYPE_STAT_EJECT, CMPL_BASE_TYPE_TX_L2, CMPL_BASE_V, bnxt::dev, done, dump_cq, dump_evt, cmpl_base::info3_v, netdev_priv(), NO_MORE_CQ_BD_TO_SERVICE, SERVICE_NEXT_CQ_BD, tx, and cmpl_base::type.

Referenced by bnxt_poll().

◆ bnxt_tx_complete()

static void bnxt_tx_complete	(	struct net_device *	dev,
		u16	hw_idx
	)

static

Definition at line 308 of file bnxt.c.

 {
         struct bnxt *bp = netdev_priv ( dev );
         struct io_buffer *iob;
 
         iob = bp->tx.iob[hw_idx];
         dbg_tx_done ( iob->data, iob_len ( iob ), hw_idx );
         netdev_tx_complete ( dev, iob );
         bp->tx.cons_id = NEXT_IDX ( hw_idx, bp->tx.ring_cnt );
         bp->tx.cnt++;
         dump_tx_stat ( bp );
 }

References bp, io_buffer::data, dbg_tx_done, bnxt::dev, dump_tx_stat, iob_len(), netdev_priv(), netdev_tx_complete(), and NEXT_IDX.

Referenced by bnxt_service_cq().

◆ bnxt_adv_cq_index()

static void bnxt_adv_cq_index	(	struct bnxt *	bp,
		u16	cnt
	)

static

Definition at line 447 of file bnxt.c.

 {
         u16 cons_id;
 
         cons_id = bp->cq.cons_id + cnt;
         if ( cons_id >= MAX_CQ_DESC_CNT ) {
                 /* Toggle completion bit when the ring wraps. */
                 bp->cq.completion_bit ^= 1;
                 cons_id = cons_id - MAX_CQ_DESC_CNT;
         }
         bp->cq.cons_id = cons_id;
 }

References bp, and MAX_CQ_DESC_CNT.

Referenced by bnxt_rx_process(), and bnxt_service_cq().

◆ bnxt_rx_complete()

static int bnxt_rx_complete	(	struct net_device *	dev,
		struct rx_pkt_cmpl *	rx
	)

static

Definition at line 484 of file bnxt.c.

 {
         struct bnxt *bp = netdev_priv ( dev );
         struct rx_pkt_cmpl_hi *rx_cmp_hi;
         u8  cmpl_bit = bp->cq.completion_bit;
 
         if ( bp->cq.cons_id == ( bp->cq.ring_cnt - 1 ) ) {
                 rx_cmp_hi = ( struct rx_pkt_cmpl_hi * )bp->cq.bd_virt;
                 cmpl_bit ^= 0x1; /* Ring has wrapped. */
         } else
                 rx_cmp_hi = ( struct rx_pkt_cmpl_hi * ) ( rx_cmp+1 );
 
         if ( ! ( ( rx_cmp_hi->errors_v2 & RX_PKT_CMPL_V2 ) ^ cmpl_bit ) ) {
                 bnxt_rx_process ( dev, bp, rx_cmp, rx_cmp_hi );
                 return SERVICE_NEXT_CQ_BD;
         } else
                 return NO_MORE_CQ_BD_TO_SERVICE;
 }

References bnxt_rx_process(), bp, bnxt::dev, rx_pkt_cmpl_hi::errors_v2, netdev_priv(), NO_MORE_CQ_BD_TO_SERVICE, RX_PKT_CMPL_V2, and SERVICE_NEXT_CQ_BD.

Referenced by bnxt_service_cq().

◆ bnxt_link_evt()

void bnxt_link_evt	(	struct bnxt *	bp,
		struct hwrm_async_event_cmpl *	evt
	)

Definition at line 1994 of file bnxt.c.

 {
         switch ( evt->event_id ) {
         case ASYNC_EVENT_CMPL_EVENT_ID_LINK_STATUS_CHANGE:
                 if ( evt->event_data1 & 0x01 )
                         bp->link_status = STATUS_LINK_ACTIVE;
                 else
                         bp->link_status = STATUS_LINK_DOWN;
                 bnxt_set_link ( bp );
                 dbg_link_status ( bp );
                 break;
         default:
                 break;
         }
 }

References ASYNC_EVENT_CMPL_EVENT_ID_LINK_STATUS_CHANGE, bnxt_set_link(), bp, dbg_link_status, hwrm_async_event_cmpl::event_data1, hwrm_async_event_cmpl::event_id, STATUS_LINK_ACTIVE, and STATUS_LINK_DOWN.

Referenced by bnxt_service_cq(), and bnxt_service_nq().

◆ bnxt_is_pci_vf()

u8 bnxt_is_pci_vf ( struct pci_device * pdev )

Check if Virtual Function.

Definition at line 90 of file bnxt.c.

 {
         if ( FLAG_TEST ( pdev->id->driver_data, BNXT_FLAG_PCI_VF ) ) {
                 return 1;
         }
         return 0;
 }

References BNXT_FLAG_PCI_VF, pci_device_id::driver_data, FLAG_TEST, and pci_device::id.

Referenced by bnxt_get_pci_info().

◆ bnxt_down_pci()

static void bnxt_down_pci ( struct bnxt * bp )

static

Definition at line 98 of file bnxt.c.

 {
         DBGP ( "%s\n", __func__ );
         if ( bp->bar2 ) {
                 iounmap ( bp->bar2 );
                 bp->bar2 = NULL;
         }
         if ( bp->bar1 ) {
                 iounmap ( bp->bar1 );
                 bp->bar1 = NULL;
         }
         if ( bp->bar0 ) {
                 iounmap ( bp->bar0 );
                 bp->bar0 = NULL;
         }
 }

References bp, DBGP, iounmap(), and NULL.

Referenced by bnxt_close(), bnxt_init_one(), and bnxt_remove_one().

◆ bnxt_pci_base()

static void* bnxt_pci_base	(	struct pci_device *	pdev,
		unsigned int	reg
	)

static

Definition at line 115 of file bnxt.c.

 {
         unsigned long reg_base, reg_size;
 
         reg_base = pci_bar_start ( pdev, reg );
         reg_size = pci_bar_size ( pdev, reg );
         return pci_ioremap ( pdev, reg_base, reg_size );
 }

References pci_bar_size(), pci_bar_start(), pci_ioremap(), and reg.

Referenced by bnxt_close(), and bnxt_get_pci_info().

◆ bnxt_get_pci_info()

static int bnxt_get_pci_info ( struct bnxt * bp )

static

Definition at line 124 of file bnxt.c.

 {
         u16 cmd_reg = 0;
 
         DBGP ( "%s\n", __func__ );
         /* Disable Interrupt */
         pci_read_word16 ( bp->pdev, PCI_COMMAND, &bp->cmd_reg );
         cmd_reg = bp->cmd_reg | PCI_COMMAND_INTX_DISABLE;
         pci_write_word ( bp->pdev, PCI_COMMAND, cmd_reg );
         pci_read_word16 ( bp->pdev, PCI_COMMAND, &cmd_reg );
 
         /* SSVID */
         pci_read_word16 ( bp->pdev,
                         PCI_SUBSYSTEM_VENDOR_ID,
                         &bp->subsystem_vendor );
 
         /* SSDID */
         pci_read_word16 ( bp->pdev,
                         PCI_SUBSYSTEM_ID,
                         &bp->subsystem_device );
 
         /* Function Number */
         pci_read_byte ( bp->pdev,
                         PCICFG_ME_REGISTER,
                         &bp->pf_num );
 
         /* Get Bar Address */
         bp->bar0 = bnxt_pci_base ( bp->pdev, PCI_BASE_ADDRESS_0 );
         bp->bar1 = bnxt_pci_base ( bp->pdev, PCI_BASE_ADDRESS_2 );
         bp->bar2 = bnxt_pci_base ( bp->pdev, PCI_BASE_ADDRESS_4 );
 
         /* Virtual function */
         bp->vf = bnxt_is_pci_vf ( bp->pdev );
 
         dbg_pci ( bp, __func__, cmd_reg );
         return STATUS_SUCCESS;
 }

References bnxt_is_pci_vf(), bnxt_pci_base(), bp, dbg_pci, DBGP, PCI_BASE_ADDRESS_0, PCI_BASE_ADDRESS_2, PCI_BASE_ADDRESS_4, PCI_COMMAND, PCI_COMMAND_INTX_DISABLE, pci_read_byte, pci_read_word16, PCI_SUBSYSTEM_ID, PCI_SUBSYSTEM_VENDOR_ID, pci_write_word, PCICFG_ME_REGISTER, and STATUS_SUCCESS.

Referenced by bnxt_init_one().

◆ bnxt_get_device_address()

static int bnxt_get_device_address ( struct bnxt * bp )

static

Definition at line 162 of file bnxt.c.

 {
         struct net_device *dev = bp->dev;
 
         DBGP ( "%s\n", __func__ );
         memcpy ( &dev->hw_addr[0], ( char * )&bp->mac_addr[0], ETH_ALEN );
         if ( !is_valid_ether_addr ( &dev->hw_addr[0] ) ) {
                 DBGP ( "- %s (  ): Failed\n", __func__ );
                 return -EINVAL;
         }
 
         return STATUS_SUCCESS;
 }

References bp, DBGP, net_device::dev, EINVAL, ETH_ALEN, is_valid_ether_addr(), memcpy(), and STATUS_SUCCESS.

◆ bnxt_set_link()

static void bnxt_set_link ( struct bnxt * bp )

static

Definition at line 176 of file bnxt.c.

 {
         if ( bp->link_status == STATUS_LINK_ACTIVE )
                 netdev_link_up ( bp->dev );
         else
                 netdev_link_down ( bp->dev );
 }

References bp, netdev_link_down(), netdev_link_up(), and STATUS_LINK_ACTIVE.

Referenced by bnxt_get_phy_link(), and bnxt_link_evt().

◆ thor_db()

static void thor_db	(	struct bnxt *	bp,
		u32	idx,
		u32	xid,
		u32	flag
	)

static

Definition at line 184 of file bnxt.c.

 {
         void *off;
         u64  val;
 
         if ( bp->vf )
                 off = ( void * ) ( bp->bar1 + DB_OFFSET_VF );
         else
                 off = ( void * ) ( bp->bar1 + DB_OFFSET_PF );
 
         val = ( ( u64 )DBC_MSG_XID ( xid, flag ) << 32 ) |
                 ( u64 )DBC_MSG_IDX ( idx );
         write64 ( val, off );
 }

References bp, DB_OFFSET_PF, DB_OFFSET_VF, DBC_MSG_IDX, DBC_MSG_XID, flag, val, and write64.

Referenced by bnxt_db_cq(), bnxt_db_nq(), bnxt_db_rx(), and bnxt_db_tx().

◆ bnxt_db_nq()

static void bnxt_db_nq ( struct bnxt * bp )

static

Definition at line 199 of file bnxt.c.

 {
         if ( bp->thor )
                 thor_db ( bp, ( u32 )bp->nq.cons_id,
                          ( u32 )bp->nq_ring_id, DBC_DBC_TYPE_NQ_ARM );
         else
                 write32 ( CMPL_DOORBELL_KEY_CMPL, ( bp->bar1 + 0 ) );
 }

References bp, CMPL_DOORBELL_KEY_CMPL, DBC_DBC_TYPE_NQ_ARM, thor_db(), and write32.

Referenced by bnxt_service_nq().

◆ bnxt_db_cq()

static void bnxt_db_cq ( struct bnxt * bp )

static

Definition at line 208 of file bnxt.c.

 {
         if ( bp->thor )
                 thor_db ( bp, ( u32 )bp->cq.cons_id,
                          ( u32 )bp->cq_ring_id, DBC_DBC_TYPE_CQ_ARMALL );
         else
                 write32 ( CQ_DOORBELL_KEY_IDX ( bp->cq.cons_id ),
                         ( bp->bar1 + 0 ) );
 }

References bp, CQ_DOORBELL_KEY_IDX, DBC_DBC_TYPE_CQ_ARMALL, thor_db(), and write32.

Referenced by bnxt_service_cq().

◆ bnxt_db_rx()

static void bnxt_db_rx	(	struct bnxt *	bp,
		u32	idx
	)

static

Definition at line 218 of file bnxt.c.

 {
         if ( bp->thor )
                 thor_db ( bp, idx, ( u32 )bp->rx_ring_id, DBC_DBC_TYPE_SRQ );
         else
                 write32 ( RX_DOORBELL_KEY_RX | idx, ( bp->bar1 + 0 ) );
 }

References bp, DBC_DBC_TYPE_SRQ, RX_DOORBELL_KEY_RX, thor_db(), and write32.

Referenced by bnxt_post_rx_buffers().

◆ bnxt_db_tx()

static void bnxt_db_tx	(	struct bnxt *	bp,
		u32	idx
	)

static

Definition at line 226 of file bnxt.c.

 {
         if ( bp->thor )
                 thor_db ( bp, idx, ( u32 )bp->tx_ring_id, DBC_DBC_TYPE_SQ );
         else
                 write32 ( ( u32 ) ( TX_DOORBELL_KEY_TX | idx ),
                         ( bp->bar1 + 0 ) );
 }

References bp, DBC_DBC_TYPE_SQ, thor_db(), TX_DOORBELL_KEY_TX, and write32.

Referenced by bnxt_tx().

◆ bnxt_add_vlan()

void bnxt_add_vlan	(	struct io_buffer *	iob,
		u16	vlan
	)

Definition at line 235 of file bnxt.c.

 {
         char *src = ( char * )iob->data;
         u16 len = iob_len ( iob );
 
         memmove ( ( char * )&src[MAC_HDR_SIZE + VLAN_HDR_SIZE],
                          ( char * )&src[MAC_HDR_SIZE],
                          ( len - MAC_HDR_SIZE ) );
 
         * ( u16 * ) ( &src[MAC_HDR_SIZE] ) = BYTE_SWAP_S ( ETHERTYPE_VLAN );
         * ( u16 * ) ( &src[MAC_HDR_SIZE + 2] ) = BYTE_SWAP_S ( vlan );
         iob_put ( iob, VLAN_HDR_SIZE );
 }

References BYTE_SWAP_S, io_buffer::data, ETHERTYPE_VLAN, iob_len(), iob_put, len, MAC_HDR_SIZE, memmove(), src, and VLAN_HDR_SIZE.

Referenced by bnxt_rx_drop(), and bnxt_tx_adjust_pkt().

◆ bnxt_get_pkt_vlan()

static u16 bnxt_get_pkt_vlan ( char * src )

static

Definition at line 249 of file bnxt.c.

 {
         if ( * ( ( u16 * )&src[MAC_HDR_SIZE] ) == BYTE_SWAP_S ( ETHERTYPE_VLAN ) )
                 return BYTE_SWAP_S ( * ( ( u16 * )&src[MAC_HDR_SIZE + 2] ) );
         return 0;
 }

References BYTE_SWAP_S, ETHERTYPE_VLAN, MAC_HDR_SIZE, and src.

Referenced by bnxt_tx_adjust_pkt().

◆ bnxt_vlan_drop()

int bnxt_vlan_drop	(	struct bnxt *	bp,
		u16	rx_vlan
	)

Definition at line 256 of file bnxt.c.

 {
         if ( rx_vlan ) {
                 if ( bp->vlan_tx ) {
                         if ( rx_vlan == bp->vlan_tx )
                                 return 0;
                 } else {
                         if ( rx_vlan == bp->vlan_id )
                                 return 0;
                         if ( rx_vlan && !bp->vlan_id )
                                 return 0;
                 }
         } else {
                 if ( !bp->vlan_tx && !bp->vlan_id )
                         return 0;
         }
 
         return 1;
 }

References bp.

Referenced by bnxt_rx_drop().

◆ bnxt_tx_avail()

static u32 bnxt_tx_avail ( struct bnxt * bp )

inlinestatic

Definition at line 276 of file bnxt.c.

 {
         u32 avail;
         u32 use;
 
         barrier (  );
         avail = TX_AVAIL ( bp->tx.ring_cnt );
         use = TX_IN_USE ( bp->tx.prod_id, bp->tx.cons_id, bp->tx.ring_cnt );
         dbg_tx_avail ( bp, avail, use );
         return ( avail-use );
 }

References barrier, bp, dbg_tx_avail, TX_AVAIL, and TX_IN_USE.

Referenced by bnxt_tx().

◆ bnxt_set_txq()

void bnxt_set_txq	(	struct bnxt *	bp,
		int	entry,
		dma_addr_t	mapping,
		int	len
	)

Definition at line 288 of file bnxt.c.

 {
         struct tx_bd_short *prod_bd;
 
         prod_bd = ( struct tx_bd_short * )BD_NOW ( bp->tx.bd_virt,
                         entry, sizeof ( struct tx_bd_short ) );
         if ( len < 512 )
                 prod_bd->flags_type = TX_BD_SHORT_FLAGS_LHINT_LT512;
         else if ( len < 1024 )
                 prod_bd->flags_type = TX_BD_SHORT_FLAGS_LHINT_LT1K;
         else if ( len < 2048 )
                 prod_bd->flags_type = TX_BD_SHORT_FLAGS_LHINT_LT2K;
         else
                 prod_bd->flags_type = TX_BD_SHORT_FLAGS_LHINT_GTE2K;
         prod_bd->flags_type |= TX_BD_FLAGS;
         prod_bd->dma.addr = mapping;
         prod_bd->len      = len;
         prod_bd->opaque   = ( u32 )entry;
 }

References dma_addr64_t::addr, BD_NOW, bp, tx_bd_short::dma, entry, tx_bd_short::flags_type, len, tx_bd_short::len, tx_bd_short::opaque, TX_BD_FLAGS, TX_BD_SHORT_FLAGS_LHINT_GTE2K, TX_BD_SHORT_FLAGS_LHINT_LT1K, TX_BD_SHORT_FLAGS_LHINT_LT2K, TX_BD_SHORT_FLAGS_LHINT_LT512, and u32.

Referenced by bnxt_tx().

◆ bnxt_free_rx_iob()

int bnxt_free_rx_iob ( struct bnxt * bp )

Definition at line 321 of file bnxt.c.

 {
         unsigned int i;
 
         DBGP ( "%s\n", __func__ );
         if ( ! ( FLAG_TEST ( bp->flag_hwrm, VALID_RX_IOB ) ) )
                 return STATUS_SUCCESS;
 
         for ( i = 0; i < bp->rx.buf_cnt; i++ ) {
                 if ( bp->rx.iob[i] ) {
                         free_iob ( bp->rx.iob[i] );
                         bp->rx.iob[i] = NULL;
                 }
         }
         bp->rx.iob_cnt = 0;
 
         FLAG_RESET ( bp->flag_hwrm, VALID_RX_IOB );
         return STATUS_SUCCESS;
 }

References bp, DBGP, FLAG_RESET, FLAG_TEST, free_iob(), NULL, STATUS_SUCCESS, and VALID_RX_IOB.

◆ bnxt_set_rx_desc()

static void bnxt_set_rx_desc	(	u8 *	buf,
		struct io_buffer *	iob,
		u16	cid,
		u32	idx
	)

static

Definition at line 341 of file bnxt.c.

 {
         struct rx_prod_pkt_bd *desc;
         u16 off = cid * sizeof ( struct rx_prod_pkt_bd );
 
         desc = ( struct rx_prod_pkt_bd * )&buf[off];
         desc->flags_type = RX_PROD_PKT_BD_TYPE_RX_PROD_PKT;
         desc->len        = MAX_ETHERNET_PACKET_BUFFER_SIZE;
         desc->opaque     = idx;
         desc->dma.addr   = virt_to_bus ( iob->data );
 }

References dma_addr64_t::addr, io_buffer::data, rx_prod_pkt_bd::dma, rx_prod_pkt_bd::flags_type, rx_prod_pkt_bd::len, MAX_ETHERNET_PACKET_BUFFER_SIZE, rx_prod_pkt_bd::opaque, RX_PROD_PKT_BD_TYPE_RX_PROD_PKT, and virt_to_bus().

Referenced by bnxt_alloc_rx_iob().

◆ bnxt_alloc_rx_iob()

static int bnxt_alloc_rx_iob	(	struct bnxt *	bp,
		u16	cons_id,
		u16	iob_idx
	)

static

Definition at line 354 of file bnxt.c.

 {
         struct io_buffer *iob;
 
         iob = alloc_iob ( BNXT_RX_STD_DMA_SZ );
         if ( !iob ) {
                 DBGP ( "- %s (  ): alloc_iob Failed\n", __func__ );
                 return -ENOMEM;
         }
 
         dbg_alloc_rx_iob ( iob, iob_idx, cons_id );
         bnxt_set_rx_desc ( ( u8 * )bp->rx.bd_virt, iob, cons_id,
                         ( u32 ) iob_idx );
         bp->rx.iob[iob_idx] = iob;
         return 0;
 }

References alloc_iob(), BNXT_RX_STD_DMA_SZ, bnxt_set_rx_desc(), bp, dbg_alloc_rx_iob, DBGP, and ENOMEM.

Referenced by bnxt_post_rx_buffers().

◆ bnxt_post_rx_buffers()

int bnxt_post_rx_buffers ( struct bnxt * bp )

Definition at line 371 of file bnxt.c.

 {
         u16 cons_id = ( bp->rx.cons_id % bp->rx.ring_cnt );
         u16 iob_idx;
 
         while ( bp->rx.iob_cnt < bp->rx.buf_cnt ) {
                 iob_idx = ( cons_id % bp->rx.buf_cnt );
                 if ( !bp->rx.iob[iob_idx] ) {
                         if ( bnxt_alloc_rx_iob ( bp, cons_id, iob_idx ) < 0 ) {
                                 dbg_alloc_rx_iob_fail ( iob_idx, cons_id );
                                 break;
                         }
                 }
                 cons_id = NEXT_IDX ( cons_id, bp->rx.ring_cnt );
                 bp->rx.iob_cnt++;
         }
 
         if ( cons_id != bp->rx.cons_id ) {
                 dbg_rx_cid ( bp->rx.cons_id, cons_id );
                 bp->rx.cons_id = cons_id;
                 bnxt_db_rx ( bp, ( u32 )cons_id );
         }
 
         FLAG_SET ( bp->flag_hwrm, VALID_RX_IOB );
         return STATUS_SUCCESS;
 }

References bnxt_alloc_rx_iob(), bnxt_db_rx(), bp, dbg_alloc_rx_iob_fail, dbg_rx_cid, FLAG_SET, NEXT_IDX, STATUS_SUCCESS, and VALID_RX_IOB.

Referenced by bnxt_rx_process().

◆ bnxt_rx_drop()

u8 bnxt_rx_drop	(	struct bnxt *	bp,
		struct io_buffer *	iob,
		struct rx_pkt_cmpl_hi *	rx_cmp_hi,
		u16	rx_len
	)

Definition at line 398 of file bnxt.c.

 {
         u8  *rx_buf = ( u8 * )iob->data;
         u16 err_flags, rx_vlan;
         u8  ignore_chksum_err = 0;
         int i;
 
         err_flags = rx_cmp_hi->errors_v2 >> RX_PKT_CMPL_ERRORS_BUFFER_ERROR_SFT;
         if ( rx_cmp_hi->errors_v2 == 0x20 || rx_cmp_hi->errors_v2 == 0x21 )
                 ignore_chksum_err = 1;
 
         if ( err_flags && !ignore_chksum_err ) {
                 bp->rx.drop_err++;
                 return 1;
         }
 
         for ( i = 0; i < 6; i++ ) {
                 if ( rx_buf[6 + i] != bp->mac_addr[i] )
                         break;
         }
 
         /* Drop the loopback packets */
         if ( i == 6 ) {
                 bp->rx.drop_lb++;
                 return 2;
         }
 
         /* Get VLAN ID from RX completion ring */
         if ( rx_cmp_hi->flags2 & RX_PKT_CMPL_FLAGS2_META_FORMAT_VLAN )
                 rx_vlan = ( rx_cmp_hi->metadata &
                                 RX_PKT_CMPL_METADATA_VID_MASK );
         else
                 rx_vlan = 0;
 
         dbg_rx_vlan ( bp, rx_cmp_hi->metadata, rx_cmp_hi->flags2, rx_vlan );
         if ( bnxt_vlan_drop ( bp, rx_vlan ) ) {
                 bp->rx.drop_vlan++;
                 return 3;
         }
         iob_put ( iob, rx_len );
 
         if ( rx_vlan )
                 bnxt_add_vlan ( iob, rx_vlan );
 
         bp->rx.good++;
         return 0;
 }

References bnxt_add_vlan(), bnxt_vlan_drop(), bp, io_buffer::data, dbg_rx_vlan, rx_pkt_cmpl_hi::errors_v2, rx_pkt_cmpl_hi::flags2, if(), iob_put, rx_pkt_cmpl_hi::metadata, RX_PKT_CMPL_ERRORS_BUFFER_ERROR_SFT, RX_PKT_CMPL_FLAGS2_META_FORMAT_VLAN, and RX_PKT_CMPL_METADATA_VID_MASK.

Referenced by bnxt_rx_process().

◆ bnxt_rx_process()

void bnxt_rx_process	(	struct net_device *	dev,
		struct bnxt *	bp,
		struct rx_pkt_cmpl *	rx_cmp,
		struct rx_pkt_cmpl_hi *	rx_cmp_hi
	)

Definition at line 460 of file bnxt.c.

 {
         u32 desc_idx = rx_cmp->opaque;
         struct io_buffer *iob = bp->rx.iob[desc_idx];
         u8 drop;
 
         dump_rx_bd ( rx_cmp, rx_cmp_hi, desc_idx );
         assert ( !iob );
         drop = bnxt_rx_drop ( bp, iob, rx_cmp_hi, rx_cmp->len );
         dbg_rxp ( iob->data, rx_cmp->len, drop );
         if ( drop )
                 netdev_rx_err ( dev, iob, -EINVAL );
         else
                 netdev_rx ( dev, iob );
 
         bp->rx.cnt++;
         bp->rx.iob[desc_idx] = NULL;
         bp->rx.iob_cnt--;
         bnxt_post_rx_buffers ( bp );
         bnxt_adv_cq_index ( bp, 2 ); /* Rx completion is 2 entries. */
         dbg_rx_stat ( bp );
 }

References assert(), bnxt_adv_cq_index(), bnxt_post_rx_buffers(), bnxt_rx_drop(), bp, io_buffer::data, dbg_rx_stat, dbg_rxp, dump_rx_bd, EINVAL, rx_pkt_cmpl::len, netdev_rx(), netdev_rx_err(), NULL, and rx_pkt_cmpl::opaque.

Referenced by bnxt_rx_complete().

◆ bnxt_mm_init()

void bnxt_mm_init	(	struct bnxt *	bp,
		const char *	func
	)

Definition at line 504 of file bnxt.c.

 {
         DBGP ( "%s\n", __func__ );
         memset ( bp->hwrm_addr_req,  0, REQ_BUFFER_SIZE );
         memset ( bp->hwrm_addr_resp, 0, RESP_BUFFER_SIZE );
         memset ( bp->hwrm_addr_dma,  0, DMA_BUFFER_SIZE );
         bp->req_addr_mapping  = virt_to_bus ( bp->hwrm_addr_req );
         bp->resp_addr_mapping = virt_to_bus ( bp->hwrm_addr_resp );
         bp->dma_addr_mapping  = virt_to_bus ( bp->hwrm_addr_dma );
         bp->link_status = STATUS_LINK_DOWN;
         bp->wait_link_timeout = LINK_DEFAULT_TIMEOUT;
         bp->mtu = MAX_ETHERNET_PACKET_BUFFER_SIZE;
         bp->hwrm_max_req_len  = HWRM_MAX_REQ_LEN;
         bp->nq.ring_cnt           = MAX_NQ_DESC_CNT;
         bp->cq.ring_cnt           = MAX_CQ_DESC_CNT;
         bp->tx.ring_cnt           = MAX_TX_DESC_CNT;
         bp->rx.ring_cnt           = MAX_RX_DESC_CNT;
         bp->rx.buf_cnt            = NUM_RX_BUFFERS;
         dbg_mem ( bp, func );
 }

References bp, dbg_mem, DBGP, DMA_BUFFER_SIZE, HWRM_MAX_REQ_LEN, LINK_DEFAULT_TIMEOUT, MAX_CQ_DESC_CNT, MAX_ETHERNET_PACKET_BUFFER_SIZE, MAX_NQ_DESC_CNT, MAX_RX_DESC_CNT, MAX_TX_DESC_CNT, memset(), NUM_RX_BUFFERS, REQ_BUFFER_SIZE, RESP_BUFFER_SIZE, STATUS_LINK_DOWN, and virt_to_bus().

Referenced by bnxt_alloc_mem().

◆ bnxt_mm_nic()

void bnxt_mm_nic ( struct bnxt * bp )

Definition at line 525 of file bnxt.c.

 {
         DBGP ( "%s\n", __func__ );
         memset ( bp->cq.bd_virt, 0, CQ_RING_BUFFER_SIZE );
         memset ( bp->tx.bd_virt, 0, TX_RING_BUFFER_SIZE );
         memset ( bp->rx.bd_virt, 0, RX_RING_BUFFER_SIZE );
         memset ( bp->nq.bd_virt, 0, NQ_RING_BUFFER_SIZE );
         bp->nq.cons_id          = 0;
         bp->nq.completion_bit   = 0x1;
         bp->cq.cons_id          = 0;
         bp->cq.completion_bit   = 0x1;
         bp->tx.prod_id          = 0;
         bp->tx.cons_id          = 0;
         bp->rx.cons_id          = 0;
         bp->rx.iob_cnt          = 0;
 
         bp->link_status         = STATUS_LINK_DOWN;
         bp->wait_link_timeout   = LINK_DEFAULT_TIMEOUT;
         bp->mtu                 = MAX_ETHERNET_PACKET_BUFFER_SIZE;
         bp->hwrm_max_req_len    = HWRM_MAX_REQ_LEN;
         bp->nq.ring_cnt         = MAX_NQ_DESC_CNT;
         bp->cq.ring_cnt         = MAX_CQ_DESC_CNT;
         bp->tx.ring_cnt         = MAX_TX_DESC_CNT;
         bp->rx.ring_cnt         = MAX_RX_DESC_CNT;
         bp->rx.buf_cnt          = NUM_RX_BUFFERS;
 }

References bp, CQ_RING_BUFFER_SIZE, DBGP, HWRM_MAX_REQ_LEN, LINK_DEFAULT_TIMEOUT, MAX_CQ_DESC_CNT, MAX_ETHERNET_PACKET_BUFFER_SIZE, MAX_NQ_DESC_CNT, MAX_RX_DESC_CNT, MAX_TX_DESC_CNT, memset(), NQ_RING_BUFFER_SIZE, NUM_RX_BUFFERS, RX_RING_BUFFER_SIZE, STATUS_LINK_DOWN, and TX_RING_BUFFER_SIZE.

Referenced by bnxt_open().

◆ bnxt_free_mem()

void bnxt_free_mem ( struct bnxt * bp )

Definition at line 552 of file bnxt.c.

 {
         DBGP ( "%s\n", __func__ );
         if ( bp->nq.bd_virt ) {
                 free_phys ( bp->nq.bd_virt, NQ_RING_BUFFER_SIZE );
                 bp->nq.bd_virt = NULL;
         }
 
         if ( bp->cq.bd_virt ) {
                 free_phys ( bp->cq.bd_virt, CQ_RING_BUFFER_SIZE );
                 bp->cq.bd_virt = NULL;
         }
 
         if ( bp->rx.bd_virt ) {
                 free_phys ( bp->rx.bd_virt, RX_RING_BUFFER_SIZE );
                 bp->rx.bd_virt = NULL;
         }
 
         if ( bp->tx.bd_virt ) {
                 free_phys ( bp->tx.bd_virt, TX_RING_BUFFER_SIZE );
                 bp->tx.bd_virt = NULL;
         }
 
         if ( bp->hwrm_addr_dma ) {
                 free_phys ( bp->hwrm_addr_dma, DMA_BUFFER_SIZE );
                 bp->dma_addr_mapping = 0;
                 bp->hwrm_addr_dma = NULL;
         }
 
         if ( bp->hwrm_addr_resp ) {
                 free_phys ( bp->hwrm_addr_resp, RESP_BUFFER_SIZE );
                 bp->resp_addr_mapping = 0;
                 bp->hwrm_addr_resp = NULL;
         }
 
         if ( bp->hwrm_addr_req ) {
                 free_phys ( bp->hwrm_addr_req, REQ_BUFFER_SIZE );
                 bp->req_addr_mapping = 0;
                 bp->hwrm_addr_req = NULL;
         }
         DBGP ( "- %s (  ): - Done\n", __func__ );
 }

References bp, CQ_RING_BUFFER_SIZE, DBGP, DMA_BUFFER_SIZE, free_phys(), NQ_RING_BUFFER_SIZE, NULL, REQ_BUFFER_SIZE, RESP_BUFFER_SIZE, RX_RING_BUFFER_SIZE, and TX_RING_BUFFER_SIZE.

Referenced by bnxt_alloc_mem(), bnxt_init_one(), and bnxt_remove_one().

◆ bnxt_alloc_mem()

int bnxt_alloc_mem ( struct bnxt * bp )

Definition at line 595 of file bnxt.c.

 {
         DBGP ( "%s\n", __func__ );
         bp->hwrm_addr_req  = malloc_phys ( REQ_BUFFER_SIZE, BNXT_DMA_ALIGNMENT );
         bp->hwrm_addr_resp = malloc_phys ( RESP_BUFFER_SIZE,
                                            BNXT_DMA_ALIGNMENT );
         bp->hwrm_addr_dma  = malloc_phys ( DMA_BUFFER_SIZE, BNXT_DMA_ALIGNMENT );
         bp->tx.bd_virt = malloc_phys ( TX_RING_BUFFER_SIZE, DMA_ALIGN_4K );
         bp->rx.bd_virt = malloc_phys ( RX_RING_BUFFER_SIZE, DMA_ALIGN_4K );
         bp->cq.bd_virt = malloc_phys ( CQ_RING_BUFFER_SIZE, BNXT_DMA_ALIGNMENT );
         bp->nq.bd_virt = malloc_phys ( NQ_RING_BUFFER_SIZE, BNXT_DMA_ALIGNMENT );
         test_if ( bp->hwrm_addr_req &&
                 bp->hwrm_addr_resp &&
                 bp->hwrm_addr_dma &&
                 bp->tx.bd_virt &&
                 bp->rx.bd_virt &&
                 bp->nq.bd_virt &&
                 bp->cq.bd_virt ) {
                 bnxt_mm_init ( bp, __func__ );
                 return STATUS_SUCCESS;
         }
 
         DBGP ( "- %s (  ): Failed\n", __func__ );
         bnxt_free_mem ( bp );
         return -ENOMEM;
 }

References BNXT_DMA_ALIGNMENT, bnxt_free_mem(), bnxt_mm_init(), bp, CQ_RING_BUFFER_SIZE, DBGP, DMA_ALIGN_4K, DMA_BUFFER_SIZE, ENOMEM, malloc_phys(), NQ_RING_BUFFER_SIZE, REQ_BUFFER_SIZE, RESP_BUFFER_SIZE, RX_RING_BUFFER_SIZE, STATUS_SUCCESS, test_if, and TX_RING_BUFFER_SIZE.

Referenced by bnxt_init_one().

◆ hwrm_init()

static void hwrm_init	(	struct bnxt *	bp,
		struct input *	req,
		u16	cmd,
		u16	len
	)

static

Definition at line 622 of file bnxt.c.

 {
         memset ( req, 0, len );
         req->req_type  = cmd;
         req->cmpl_ring = ( u16 )HWRM_NA_SIGNATURE;
         req->target_id = ( u16 )HWRM_NA_SIGNATURE;
         req->resp_addr = bp->resp_addr_mapping;
         req->seq_id    = bp->seq_id++;
 }

References bp, cmd, input::cmpl_ring, HWRM_NA_SIGNATURE, len, memset(), input::req_type, input::resp_addr, input::seq_id, input::target_id, and u16.

Referenced by bnxt_hwrm_backing_store_cfg(), bnxt_hwrm_backing_store_qcfg(), bnxt_hwrm_cfa_l2_filter_alloc(), bnxt_hwrm_cfa_l2_filter_free(), bnxt_hwrm_func_cfg_req(), bnxt_hwrm_func_drv_rgtr(), bnxt_hwrm_func_drv_unrgtr(), bnxt_hwrm_func_qcaps_req(), bnxt_hwrm_func_qcfg_req(), bnxt_hwrm_func_reset_req(), bnxt_hwrm_func_resource_qcaps(), bnxt_hwrm_nvm_get_variable_req(), bnxt_hwrm_port_mac_cfg(), bnxt_hwrm_port_phy_cfg(), bnxt_hwrm_port_phy_qcfg(), bnxt_hwrm_queue_qportcfg(), bnxt_hwrm_ring_alloc(), bnxt_hwrm_ring_alloc_grp(), bnxt_hwrm_ring_free(), bnxt_hwrm_ring_free_grp(), bnxt_hwrm_set_async_event(), bnxt_hwrm_set_rx_mask(), bnxt_hwrm_stat_ctx_alloc(), bnxt_hwrm_stat_ctx_free(), bnxt_hwrm_ver_get(), bnxt_hwrm_vnic_alloc(), bnxt_hwrm_vnic_cfg(), and bnxt_hwrm_vnic_free().

◆ hwrm_write_req()

static void hwrm_write_req	(	struct bnxt *	bp,
		void *	req,
		u32	cnt
	)

static

Definition at line 632 of file bnxt.c.

 {
         u32 i = 0;
 
         for ( i = 0; i < cnt; i++ ) {
                 write32 ( ( ( u32 * )req )[i],
                          ( bp->bar0 + GRC_COM_CHAN_BASE + ( i * 4 ) ) );
         }
         write32 ( 0x1, ( bp->bar0 + GRC_COM_CHAN_BASE + GRC_COM_CHAN_TRIG ) );
 }

References bp, GRC_COM_CHAN_BASE, GRC_COM_CHAN_TRIG, and write32.

Referenced by short_hwrm_cmd_req(), and wait_resp().

◆ short_hwrm_cmd_req()

static void short_hwrm_cmd_req	(	struct bnxt *	bp,
		u16	len
	)

static

Definition at line 643 of file bnxt.c.

 {
         struct hwrm_short_input sreq;
 
         memset ( &sreq, 0, sizeof ( struct hwrm_short_input ) );
         sreq.req_type  = ( u16 ) ( ( struct input * )bp->hwrm_addr_req )->req_type;
         sreq.signature = SHORT_REQ_SIGNATURE_SHORT_CMD;
         sreq.size      = len;
         sreq.req_addr  = bp->req_addr_mapping;
         mdelay ( 100 );
         dbg_short_cmd ( ( u8 * )&sreq, __func__,
                         sizeof ( struct hwrm_short_input ) );
         hwrm_write_req ( bp, &sreq, sizeof ( struct hwrm_short_input ) / 4 );
 }

References bp, dbg_short_cmd, hwrm_write_req(), len, mdelay(), memset(), hwrm_short_input::req_addr, hwrm_short_input::req_type, SHORT_REQ_SIGNATURE_SHORT_CMD, hwrm_short_input::signature, hwrm_short_input::size, and u16.

Referenced by wait_resp().

◆ wait_resp()

static int wait_resp	(	struct bnxt *	bp,
		u32	tmo,
		u16	len,
		const char *	func
	)

static

Definition at line 658 of file bnxt.c.

 {
         struct input *req = ( struct input * )bp->hwrm_addr_req;
         struct output *resp = ( struct output * )bp->hwrm_addr_resp;
         u8  *ptr = ( u8 * )resp;
         u32 idx;
         u32 wait_cnt = HWRM_CMD_DEFAULT_MULTIPLAYER ( ( u32 )tmo );
         u16 resp_len = 0;
         u16 ret = STATUS_TIMEOUT;
 
         if ( len > bp->hwrm_max_req_len )
                 short_hwrm_cmd_req ( bp, len );
         else
                 hwrm_write_req ( bp, req, ( u32 ) ( len / 4 ) );
 
         for ( idx = 0; idx < wait_cnt; idx++ ) {
                 resp_len = resp->resp_len;
                 test_if ( resp->seq_id == req->seq_id &&
                         resp->req_type == req->req_type &&
                         ptr[resp_len - 1] == 1 ) {
                         bp->last_resp_code = resp->error_code;
                         ret = resp->error_code;
                         break;
                 }
                 udelay ( HWRM_CMD_POLL_WAIT_TIME );
         }
         dbg_hw_cmd ( bp, func, len, resp_len, tmo, ret );
         return ( int )ret;
 }

References bp, dbg_hw_cmd, HWRM_CMD_DEFAULT_MULTIPLAYER, HWRM_CMD_POLL_WAIT_TIME, hwrm_write_req(), len, input::req_type, input::seq_id, short_hwrm_cmd_req(), STATUS_TIMEOUT, test_if, and udelay().

Referenced by bnxt_hwrm_backing_store_cfg(), bnxt_hwrm_backing_store_qcfg(), bnxt_hwrm_cfa_l2_filter_alloc(), bnxt_hwrm_cfa_l2_filter_free(), bnxt_hwrm_func_cfg_req(), bnxt_hwrm_func_drv_rgtr(), bnxt_hwrm_func_drv_unrgtr(), bnxt_hwrm_func_qcaps_req(), bnxt_hwrm_func_qcfg_req(), bnxt_hwrm_func_reset_req(), bnxt_hwrm_func_resource_qcaps(), bnxt_hwrm_nvm_get_variable_req(), bnxt_hwrm_port_mac_cfg(), bnxt_hwrm_port_phy_cfg(), bnxt_hwrm_port_phy_qcfg(), bnxt_hwrm_queue_qportcfg(), bnxt_hwrm_ring_alloc(), bnxt_hwrm_ring_alloc_grp(), bnxt_hwrm_ring_free(), bnxt_hwrm_ring_free_grp(), bnxt_hwrm_set_async_event(), bnxt_hwrm_set_rx_mask(), bnxt_hwrm_stat_ctx_alloc(), bnxt_hwrm_stat_ctx_free(), bnxt_hwrm_ver_get(), bnxt_hwrm_vnic_alloc(), bnxt_hwrm_vnic_cfg(), and bnxt_hwrm_vnic_free().

◆ bnxt_hwrm_ver_get()

static int bnxt_hwrm_ver_get ( struct bnxt * bp )

static

Definition at line 688 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_ver_get_input );
         struct hwrm_ver_get_input *req;
         struct hwrm_ver_get_output *resp;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_ver_get_input * )bp->hwrm_addr_req;
         resp = ( struct hwrm_ver_get_output * )bp->hwrm_addr_resp;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_VER_GET, cmd_len );
         req->hwrm_intf_maj = HWRM_VERSION_MAJOR;
         req->hwrm_intf_min = HWRM_VERSION_MINOR;
         req->hwrm_intf_upd = HWRM_VERSION_UPDATE;
         rc = wait_resp ( bp, HWRM_CMD_DEFAULT_TIMEOUT, cmd_len, __func__ );
         if ( rc )
                 return STATUS_FAILURE;
 
         bp->hwrm_spec_code =
                 resp->hwrm_intf_maj_8b << 16 |
                 resp->hwrm_intf_min_8b << 8 |
                 resp->hwrm_intf_upd_8b;
         bp->hwrm_cmd_timeout = ( u32 )resp->def_req_timeout;
         if ( !bp->hwrm_cmd_timeout )
                 bp->hwrm_cmd_timeout = ( u32 )HWRM_CMD_DEFAULT_TIMEOUT;
         if ( resp->hwrm_intf_maj_8b >= 1 )
                 bp->hwrm_max_req_len = resp->max_req_win_len;
         bp->chip_id =
                 resp->chip_rev << 24 |
                 resp->chip_metal << 16 |
                 resp->chip_bond_id << 8 |
                 resp->chip_platform_type;
         bp->chip_num = resp->chip_num;
         test_if ( ( resp->dev_caps_cfg & SHORT_CMD_SUPPORTED ) &&
                  ( resp->dev_caps_cfg & SHORT_CMD_REQUIRED ) )
                 FLAG_SET ( bp->flags, BNXT_FLAG_HWRM_SHORT_CMD_SUPP );
         bp->hwrm_max_ext_req_len = resp->max_ext_req_len;
         if ( bp->chip_num == CHIP_NUM_57500 )
                 bp->thor = 1;
         dbg_fw_ver ( resp, bp->hwrm_cmd_timeout );
         return STATUS_SUCCESS;
 }

◆ bnxt_hwrm_func_resource_qcaps()

static int bnxt_hwrm_func_resource_qcaps ( struct bnxt * bp )

static

Definition at line 731 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_func_resource_qcaps_input );
         struct hwrm_func_resource_qcaps_input *req;
         struct hwrm_func_resource_qcaps_output *resp;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_func_resource_qcaps_input * )bp->hwrm_addr_req;
         resp = ( struct hwrm_func_resource_qcaps_output * )bp->hwrm_addr_resp;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_FUNC_RESOURCE_QCAPS,
                 cmd_len );
         req->fid = ( u16 )HWRM_NA_SIGNATURE;
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc != STATUS_SUCCESS )
                 return STATUS_SUCCESS;
 
         FLAG_SET ( bp->flags, BNXT_FLAG_RESOURCE_QCAPS_SUPPORT );
 
         // VFs
         if ( !bp->vf ) {
                 bp->max_vfs = resp->max_vfs;
                 bp->vf_res_strategy = resp->vf_reservation_strategy;
         }
 
         // vNICs
         bp->min_vnics = resp->min_vnics;
         bp->max_vnics = resp->max_vnics;
 
         // MSI-X
         bp->max_msix = resp->max_msix;
 
         // Ring Groups
         bp->min_hw_ring_grps = resp->min_hw_ring_grps;
         bp->max_hw_ring_grps = resp->max_hw_ring_grps;
 
         // TX Rings
         bp->min_tx_rings = resp->min_tx_rings;
         bp->max_tx_rings = resp->max_tx_rings;
 
         // RX Rings
         bp->min_rx_rings = resp->min_rx_rings;
         bp->max_rx_rings = resp->max_rx_rings;
 
         // Completion Rings
         bp->min_cp_rings = resp->min_cmpl_rings;
         bp->max_cp_rings = resp->max_cmpl_rings;
 
         // RSS Contexts
         bp->min_rsscos_ctxs = resp->min_rsscos_ctx;
         bp->max_rsscos_ctxs = resp->max_rsscos_ctx;
 
         // L2 Contexts
         bp->min_l2_ctxs = resp->min_l2_ctxs;
         bp->max_l2_ctxs = resp->max_l2_ctxs;
 
         // Statistic Contexts
         bp->min_stat_ctxs = resp->min_stat_ctx;
         bp->max_stat_ctxs = resp->max_stat_ctx;
         dbg_func_resource_qcaps ( bp );
         return STATUS_SUCCESS;
 }

◆ bnxt_set_ring_info()

static u32 bnxt_set_ring_info ( struct bnxt * bp )

static

Definition at line 794 of file bnxt.c.

 {
         u32 enables = 0;
 
         DBGP ( "%s\n", __func__ );
         bp->num_cmpl_rings   = DEFAULT_NUMBER_OF_CMPL_RINGS;
         bp->num_tx_rings         = DEFAULT_NUMBER_OF_TX_RINGS;
         bp->num_rx_rings         = DEFAULT_NUMBER_OF_RX_RINGS;
         bp->num_hw_ring_grps = DEFAULT_NUMBER_OF_RING_GRPS;
         bp->num_stat_ctxs    = DEFAULT_NUMBER_OF_STAT_CTXS;
 
         if ( bp->min_cp_rings <= DEFAULT_NUMBER_OF_CMPL_RINGS )
                 bp->num_cmpl_rings = bp->min_cp_rings;
 
         if ( bp->min_tx_rings <= DEFAULT_NUMBER_OF_TX_RINGS )
                 bp->num_tx_rings = bp->min_tx_rings;
 
         if ( bp->min_rx_rings <= DEFAULT_NUMBER_OF_RX_RINGS )
                 bp->num_rx_rings = bp->min_rx_rings;
 
         if ( bp->min_hw_ring_grps <= DEFAULT_NUMBER_OF_RING_GRPS )
                 bp->num_hw_ring_grps = bp->min_hw_ring_grps;
 
         if ( bp->min_stat_ctxs <= DEFAULT_NUMBER_OF_STAT_CTXS )
                 bp->num_stat_ctxs = bp->min_stat_ctxs;
 
         dbg_num_rings ( bp );
         enables = ( FUNC_CFG_REQ_ENABLES_NUM_CMPL_RINGS |
                            FUNC_CFG_REQ_ENABLES_NUM_TX_RINGS |
                            FUNC_CFG_REQ_ENABLES_NUM_RX_RINGS |
                            FUNC_CFG_REQ_ENABLES_NUM_STAT_CTXS |
                            FUNC_CFG_REQ_ENABLES_NUM_HW_RING_GRPS );
         return enables;
 }

References bp, dbg_num_rings, DBGP, DEFAULT_NUMBER_OF_CMPL_RINGS, DEFAULT_NUMBER_OF_RING_GRPS, DEFAULT_NUMBER_OF_RX_RINGS, DEFAULT_NUMBER_OF_STAT_CTXS, DEFAULT_NUMBER_OF_TX_RINGS, FUNC_CFG_REQ_ENABLES_NUM_CMPL_RINGS, FUNC_CFG_REQ_ENABLES_NUM_HW_RING_GRPS, FUNC_CFG_REQ_ENABLES_NUM_RX_RINGS, FUNC_CFG_REQ_ENABLES_NUM_STAT_CTXS, and FUNC_CFG_REQ_ENABLES_NUM_TX_RINGS.

Referenced by bnxt_hwrm_assign_resources().

◆ bnxt_hwrm_assign_resources()

static void bnxt_hwrm_assign_resources ( struct bnxt * bp )

static

Definition at line 829 of file bnxt.c.

 {
         struct hwrm_func_cfg_input *req;
         u32 enables = 0;
 
         DBGP ( "%s\n", __func__ );
         if ( FLAG_TEST ( bp->flags, BNXT_FLAG_RESOURCE_QCAPS_SUPPORT ) )
                 enables = bnxt_set_ring_info ( bp );
 
         req = ( struct hwrm_func_cfg_input * )bp->hwrm_addr_req;
         req->num_cmpl_rings   = bp->num_cmpl_rings;
         req->num_tx_rings     = bp->num_tx_rings;
         req->num_rx_rings     = bp->num_rx_rings;
         req->num_stat_ctxs    = bp->num_stat_ctxs;
         req->num_hw_ring_grps = bp->num_hw_ring_grps;
         req->enables = enables;
 }

References BNXT_FLAG_RESOURCE_QCAPS_SUPPORT, bnxt_set_ring_info(), bp, DBGP, hwrm_func_cfg_input::enables, FLAG_TEST, hwrm_func_cfg_input::num_cmpl_rings, hwrm_func_cfg_input::num_hw_ring_grps, hwrm_func_cfg_input::num_rx_rings, hwrm_func_cfg_input::num_stat_ctxs, and hwrm_func_cfg_input::num_tx_rings.

Referenced by bnxt_hwrm_func_cfg_req().

◆ bnxt_hwrm_func_qcaps_req()

static int bnxt_hwrm_func_qcaps_req ( struct bnxt * bp )

static

Definition at line 847 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_func_qcaps_input );
         struct hwrm_func_qcaps_input *req;
         struct hwrm_func_qcaps_output *resp;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         if ( bp->vf )
                 return STATUS_SUCCESS;
 
         req = ( struct hwrm_func_qcaps_input * )bp->hwrm_addr_req;
         resp = ( struct hwrm_func_qcaps_output * )bp->hwrm_addr_resp;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_FUNC_QCAPS, cmd_len );
         req->fid = ( u16 )HWRM_NA_SIGNATURE;
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc ) {
                 DBGP ( "- %s (  ): Failed\n", __func__ );
                 return STATUS_FAILURE;
         }
 
         bp->fid = resp->fid;
         bp->port_idx = ( u8 )resp->port_id;
 
         /* Get MAC address for this PF */
         memcpy ( &bp->mac_addr[0], &resp->mac_address[0], ETH_ALEN );
         dbg_func_qcaps ( bp );
         return STATUS_SUCCESS;
 }

References bp, dbg_func_qcaps, DBGP, ETH_ALEN, hwrm_func_qcaps_output::fid, HWRM_FUNC_QCAPS, hwrm_init(), HWRM_NA_SIGNATURE, hwrm_func_qcaps_output::mac_address, memcpy(), hwrm_func_qcaps_output::port_id, rc, STATUS_FAILURE, STATUS_SUCCESS, u16, u8, and wait_resp().

◆ bnxt_hwrm_func_qcfg_req()

static int bnxt_hwrm_func_qcfg_req ( struct bnxt * bp )

static

Definition at line 877 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_func_qcfg_input );
         struct hwrm_func_qcfg_input *req;
         struct hwrm_func_qcfg_output *resp;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_func_qcfg_input * )bp->hwrm_addr_req;
         resp = ( struct hwrm_func_qcfg_output * )bp->hwrm_addr_resp;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_FUNC_QCFG, cmd_len );
         req->fid = ( u16 )HWRM_NA_SIGNATURE;
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc ) {
                 DBGP ( "- %s (  ): Failed\n", __func__ );
                 return STATUS_FAILURE;
         }
 
         if ( resp->flags & FUNC_QCFG_RESP_FLAGS_MULTI_HOST )
                 FLAG_SET ( bp->flags, BNXT_FLAG_MULTI_HOST );
 
         if ( resp->port_partition_type &
                 FUNC_QCFG_RESP_PORT_PARTITION_TYPE_NPAR1_0 )
                 FLAG_SET ( bp->flags, BNXT_FLAG_NPAR_MODE );
 
         bp->ordinal_value = ( u8 )resp->pci_id & 0x0F;
         bp->stat_ctx_id   = resp->stat_ctx_id;
 
         /* If VF is set to TRUE, then use some data from func_qcfg (  ). */
         if ( bp->vf ) {
                 bp->fid = resp->fid;
                 bp->port_idx = ( u8 )resp->port_id;
                 bp->vlan_id  = resp->vlan;
 
                 /* Get MAC address for this VF */
                 memcpy ( bp->mac_addr, resp->mac_address, ETH_ALEN );
         }
         dbg_func_qcfg ( bp );
         return STATUS_SUCCESS;
 }

◆ bnxt_hwrm_func_reset_req()

static int bnxt_hwrm_func_reset_req ( struct bnxt * bp )

static

Definition at line 918 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_func_reset_input );
         struct hwrm_func_reset_input *req;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_func_reset_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_FUNC_RESET, cmd_len );
         if ( !bp->vf )
                 req->func_reset_level = FUNC_RESET_REQ_FUNC_RESET_LEVEL_RESETME;
 
         return wait_resp ( bp, HWRM_CMD_WAIT ( 6 ), cmd_len, __func__ );
 }

References bp, DBGP, hwrm_func_reset_input::func_reset_level, FUNC_RESET_REQ_FUNC_RESET_LEVEL_RESETME, HWRM_CMD_WAIT, HWRM_FUNC_RESET, hwrm_init(), u16, and wait_resp().

◆ bnxt_hwrm_func_cfg_req()

static int bnxt_hwrm_func_cfg_req ( struct bnxt * bp )

static

Definition at line 932 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_func_cfg_input );
         struct hwrm_func_cfg_input *req;
 
         DBGP ( "%s\n", __func__ );
         if ( bp->vf )
                 return STATUS_SUCCESS;
 
         req = ( struct hwrm_func_cfg_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_FUNC_CFG, cmd_len );
         req->fid = ( u16 )HWRM_NA_SIGNATURE;
         bnxt_hwrm_assign_resources ( bp );
         if ( bp->thor ) {
                 req->enables |= ( FUNC_CFG_REQ_ENABLES_NUM_MSIX |
                                   FUNC_CFG_REQ_ENABLES_NUM_VNICS |
                                   FUNC_CFG_REQ_ENABLES_EVB_MODE );
                 req->num_msix  = 1;
                 req->num_vnics = 1;
                 req->evb_mode  = FUNC_CFG_REQ_EVB_MODE_NO_EVB;
         }
         return wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
 }

References bnxt_hwrm_assign_resources(), bp, DBGP, hwrm_func_cfg_input::enables, hwrm_func_cfg_input::evb_mode, hwrm_func_cfg_input::fid, FUNC_CFG_REQ_ENABLES_EVB_MODE, FUNC_CFG_REQ_ENABLES_NUM_MSIX, FUNC_CFG_REQ_ENABLES_NUM_VNICS, FUNC_CFG_REQ_EVB_MODE_NO_EVB, HWRM_FUNC_CFG, hwrm_init(), HWRM_NA_SIGNATURE, hwrm_func_cfg_input::num_msix, hwrm_func_cfg_input::num_vnics, STATUS_SUCCESS, u16, and wait_resp().

◆ bnxt_hwrm_func_drv_rgtr()

static int bnxt_hwrm_func_drv_rgtr ( struct bnxt * bp )

static

Definition at line 956 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_func_drv_rgtr_input );
         struct hwrm_func_drv_rgtr_input *req;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_func_drv_rgtr_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_FUNC_DRV_RGTR, cmd_len );
 
         /* Register with HWRM */
         req->enables = FUNC_DRV_RGTR_REQ_ENABLES_OS_TYPE |
                         FUNC_DRV_RGTR_REQ_ENABLES_ASYNC_EVENT_FWD |
                         FUNC_DRV_RGTR_REQ_ENABLES_VER;
         req->async_event_fwd[0] |= 0x01;
         req->os_type = FUNC_DRV_RGTR_REQ_OS_TYPE_OTHER;
         req->ver_maj = IPXE_VERSION_MAJOR;
         req->ver_min = IPXE_VERSION_MINOR;
         req->ver_upd = IPXE_VERSION_UPDATE;
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc ) {
                 DBGP ( "- %s (  ): Failed\n", __func__ );
                 return STATUS_FAILURE;
         }
 
         FLAG_SET ( bp->flag_hwrm, VALID_DRIVER_REG );
         return STATUS_SUCCESS;
 }

References hwrm_func_drv_rgtr_input::async_event_fwd, bp, DBGP, hwrm_func_drv_rgtr_input::enables, FLAG_SET, FUNC_DRV_RGTR_REQ_ENABLES_ASYNC_EVENT_FWD, FUNC_DRV_RGTR_REQ_ENABLES_OS_TYPE, FUNC_DRV_RGTR_REQ_ENABLES_VER, FUNC_DRV_RGTR_REQ_OS_TYPE_OTHER, HWRM_FUNC_DRV_RGTR, hwrm_init(), IPXE_VERSION_MAJOR, IPXE_VERSION_MINOR, IPXE_VERSION_UPDATE, hwrm_func_drv_rgtr_input::os_type, rc, STATUS_FAILURE, STATUS_SUCCESS, u16, VALID_DRIVER_REG, hwrm_func_drv_rgtr_input::ver_maj, hwrm_func_drv_rgtr_input::ver_min, hwrm_func_drv_rgtr_input::ver_upd, and wait_resp().

◆ bnxt_hwrm_func_drv_unrgtr()

static int bnxt_hwrm_func_drv_unrgtr ( struct bnxt * bp )

static

Definition at line 985 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_func_drv_unrgtr_input );
         struct hwrm_func_drv_unrgtr_input *req;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         if ( ! ( FLAG_TEST ( bp->flag_hwrm, VALID_DRIVER_REG ) ) )
                 return STATUS_SUCCESS;
 
         req = ( struct hwrm_func_drv_unrgtr_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_FUNC_DRV_UNRGTR, cmd_len );
         req->flags = FUNC_DRV_UNRGTR_REQ_FLAGS_PREPARE_FOR_SHUTDOWN;
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc )
                 return STATUS_FAILURE;
 
         FLAG_RESET ( bp->flag_hwrm, VALID_DRIVER_REG );
         return STATUS_SUCCESS;
 }

References bp, DBGP, FLAG_RESET, FLAG_TEST, hwrm_func_drv_unrgtr_input::flags, FUNC_DRV_UNRGTR_REQ_FLAGS_PREPARE_FOR_SHUTDOWN, HWRM_FUNC_DRV_UNRGTR, hwrm_init(), rc, STATUS_FAILURE, STATUS_SUCCESS, u16, VALID_DRIVER_REG, and wait_resp().

◆ bnxt_hwrm_set_async_event()

static int bnxt_hwrm_set_async_event ( struct bnxt * bp )

static

Definition at line 1006 of file bnxt.c.

 {
         int rc;
         u16 idx;
 
         DBGP ( "%s\n", __func__ );
         if ( bp->thor )
                 idx = bp->nq_ring_id;
         else
                 idx = bp->cq_ring_id;
         if ( bp->vf ) {
                 u16 cmd_len = ( u16 )sizeof ( struct hwrm_func_vf_cfg_input );
                 struct hwrm_func_vf_cfg_input *req;
 
                 req = ( struct hwrm_func_vf_cfg_input * )bp->hwrm_addr_req;
                 hwrm_init ( bp, ( void * )req, ( u16 )HWRM_FUNC_VF_CFG,
                         cmd_len );
                 req->enables = VF_CFG_ENABLE_FLAGS;
                 req->async_event_cr = idx;
                 req->mtu = bp->mtu;
                 req->guest_vlan = bp->vlan_id;
                 memcpy ( ( char * )&req->dflt_mac_addr[0], bp->mac_addr,
                         ETH_ALEN );
                 rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         } else {
                 u16 cmd_len = ( u16 )sizeof ( struct hwrm_func_cfg_input );
                 struct hwrm_func_cfg_input *req;
 
                 req = ( struct hwrm_func_cfg_input * )bp->hwrm_addr_req;
                 hwrm_init ( bp, ( void * )req, ( u16 )HWRM_FUNC_CFG, cmd_len );
                 req->fid = ( u16 )HWRM_NA_SIGNATURE;
                 req->enables = FUNC_CFG_REQ_ENABLES_ASYNC_EVENT_CR;
                 req->async_event_cr = idx;
                 rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         }
         return rc;
 }

References hwrm_func_vf_cfg_input::async_event_cr, hwrm_func_cfg_input::async_event_cr, bp, DBGP, hwrm_func_vf_cfg_input::dflt_mac_addr, hwrm_func_vf_cfg_input::enables, hwrm_func_cfg_input::enables, ETH_ALEN, hwrm_func_cfg_input::fid, FUNC_CFG_REQ_ENABLES_ASYNC_EVENT_CR, hwrm_func_vf_cfg_input::guest_vlan, HWRM_FUNC_CFG, HWRM_FUNC_VF_CFG, hwrm_init(), HWRM_NA_SIGNATURE, memcpy(), hwrm_func_vf_cfg_input::mtu, rc, u16, VF_CFG_ENABLE_FLAGS, and wait_resp().

◆ bnxt_hwrm_cfa_l2_filter_alloc()

static int bnxt_hwrm_cfa_l2_filter_alloc ( struct bnxt * bp )

static

Definition at line 1044 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_cfa_l2_filter_alloc_input );
         struct hwrm_cfa_l2_filter_alloc_input *req;
         struct hwrm_cfa_l2_filter_alloc_output *resp;
         int rc;
         u32 flags = CFA_L2_FILTER_ALLOC_REQ_FLAGS_PATH_RX;
         u32 enables;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_cfa_l2_filter_alloc_input * )bp->hwrm_addr_req;
         resp = ( struct hwrm_cfa_l2_filter_alloc_output * )bp->hwrm_addr_resp;
         if ( bp->vf )
                 flags |= CFA_L2_FILTER_ALLOC_REQ_FLAGS_OUTERMOST;
         enables = CFA_L2_FILTER_ALLOC_REQ_ENABLES_DST_ID |
                 CFA_L2_FILTER_ALLOC_REQ_ENABLES_L2_ADDR |
                 CFA_L2_FILTER_ALLOC_REQ_ENABLES_L2_ADDR_MASK;
 
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_CFA_L2_FILTER_ALLOC,
                 cmd_len );
         req->flags = flags;
         req->enables = enables;
         memcpy ( ( char * )&req->l2_addr[0], ( char * )&bp->mac_addr[0],
                 ETH_ALEN );
         memset ( ( char * )&req->l2_addr_mask[0], 0xff, ETH_ALEN );
         if ( !bp->vf ) {
                 memcpy ( ( char * )&req->t_l2_addr[0], bp->mac_addr, ETH_ALEN );
                 memset ( ( char * )&req->t_l2_addr_mask[0], 0xff, ETH_ALEN );
         }
         req->src_type = CFA_L2_FILTER_ALLOC_REQ_SRC_TYPE_NPORT;
         req->src_id   = ( u32 )bp->port_idx;
         req->dst_id   = bp->vnic_id;
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc )
                 return STATUS_FAILURE;
 
         FLAG_SET ( bp->flag_hwrm, VALID_L2_FILTER );
         bp->l2_filter_id = resp->l2_filter_id;
         return STATUS_SUCCESS;
 }

References bp, CFA_L2_FILTER_ALLOC_REQ_ENABLES_DST_ID, CFA_L2_FILTER_ALLOC_REQ_ENABLES_L2_ADDR, CFA_L2_FILTER_ALLOC_REQ_ENABLES_L2_ADDR_MASK, CFA_L2_FILTER_ALLOC_REQ_FLAGS_OUTERMOST, CFA_L2_FILTER_ALLOC_REQ_FLAGS_PATH_RX, CFA_L2_FILTER_ALLOC_REQ_SRC_TYPE_NPORT, DBGP, hwrm_cfa_l2_filter_alloc_input::enables, ETH_ALEN, FLAG_SET, flags, HWRM_CFA_L2_FILTER_ALLOC, hwrm_init(), hwrm_cfa_l2_filter_alloc_output::l2_filter_id, memcpy(), memset(), rc, STATUS_FAILURE, STATUS_SUCCESS, u16, u32, VALID_L2_FILTER, and wait_resp().

◆ bnxt_hwrm_cfa_l2_filter_free()

static int bnxt_hwrm_cfa_l2_filter_free ( struct bnxt * bp )

static

Definition at line 1085 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_cfa_l2_filter_free_input );
         struct hwrm_cfa_l2_filter_free_input *req;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         if ( ! ( FLAG_TEST ( bp->flag_hwrm, VALID_L2_FILTER ) ) )
                 return STATUS_SUCCESS;
 
         req = ( struct hwrm_cfa_l2_filter_free_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_CFA_L2_FILTER_FREE,
                 cmd_len );
         req->l2_filter_id = bp->l2_filter_id;
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc ) {
                 DBGP ( "- %s (  ): Failed\n", __func__ );
                 return STATUS_FAILURE;
         }
 
         FLAG_RESET ( bp->flag_hwrm, VALID_L2_FILTER );
         return STATUS_SUCCESS;
 }

References bp, DBGP, FLAG_RESET, FLAG_TEST, HWRM_CFA_L2_FILTER_FREE, hwrm_init(), hwrm_cfa_l2_filter_free_input::l2_filter_id, rc, STATUS_FAILURE, STATUS_SUCCESS, u16, VALID_L2_FILTER, and wait_resp().

◆ set_rx_mask()

u32 set_rx_mask ( u32 rx_mask )

Definition at line 1109 of file bnxt.c.

 {
         u32 mask = 0;
 
         if ( !rx_mask )
                 return mask;
 
         mask = CFA_L2_SET_RX_MASK_REQ_MASK_BCAST;
         if ( rx_mask != RX_MASK_ACCEPT_NONE ) {
                 if ( rx_mask & RX_MASK_ACCEPT_MULTICAST )
                         mask |= CFA_L2_SET_RX_MASK_REQ_MASK_MCAST;
                 if ( rx_mask & RX_MASK_ACCEPT_ALL_MULTICAST )
                         mask |= CFA_L2_SET_RX_MASK_REQ_MASK_ALL_MCAST;
                 if ( rx_mask & RX_MASK_PROMISCUOUS_MODE )
                         mask |= CFA_L2_SET_RX_MASK_REQ_MASK_PROMISCUOUS;
         }
         return mask;
 }

References CFA_L2_SET_RX_MASK_REQ_MASK_ALL_MCAST, CFA_L2_SET_RX_MASK_REQ_MASK_BCAST, CFA_L2_SET_RX_MASK_REQ_MASK_MCAST, CFA_L2_SET_RX_MASK_REQ_MASK_PROMISCUOUS, RX_MASK_ACCEPT_ALL_MULTICAST, RX_MASK_ACCEPT_MULTICAST, RX_MASK_ACCEPT_NONE, and RX_MASK_PROMISCUOUS_MODE.

Referenced by bnxt_hwrm_set_rx_mask().

◆ bnxt_hwrm_set_rx_mask()

static int bnxt_hwrm_set_rx_mask	(	struct bnxt *	bp,
		u32	rx_mask
	)

static

Definition at line 1128 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_cfa_l2_set_rx_mask_input );
         struct hwrm_cfa_l2_set_rx_mask_input *req;
         u32 mask = set_rx_mask ( rx_mask );
 
         req = ( struct hwrm_cfa_l2_set_rx_mask_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_CFA_L2_SET_RX_MASK,
                 cmd_len );
         req->vnic_id = bp->vnic_id;
         req->mask    = mask;
 
         return wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
 }

References bp, HWRM_CFA_L2_SET_RX_MASK, hwrm_init(), hwrm_cfa_l2_set_rx_mask_input::mask, set_rx_mask(), u16, hwrm_cfa_l2_set_rx_mask_input::vnic_id, and wait_resp().

Referenced by bnxt_reset_rx_mask(), and bnxt_set_rx_mask().

◆ bnxt_hwrm_port_phy_qcfg()

static int bnxt_hwrm_port_phy_qcfg	(	struct bnxt *	bp,
		u16	idx
	)

static

Definition at line 1143 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_port_phy_qcfg_input );
         struct hwrm_port_phy_qcfg_input *req;
         struct hwrm_port_phy_qcfg_output *resp;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_port_phy_qcfg_input * )bp->hwrm_addr_req;
         resp = ( struct hwrm_port_phy_qcfg_output * )bp->hwrm_addr_resp;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_PORT_PHY_QCFG, cmd_len );
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc ) {
                 DBGP ( "- %s (  ): Failed\n", __func__ );
                 return STATUS_FAILURE;
         }
 
         if ( idx & SUPPORT_SPEEDS )
                 bp->support_speeds = resp->support_speeds;
 
         if ( idx & DETECT_MEDIA )
                 bp->media_detect = resp->module_status;
 
         if ( idx & PHY_SPEED )
                 bp->current_link_speed = resp->link_speed;
 
         if ( idx & PHY_STATUS ) {
                 if ( resp->link == PORT_PHY_QCFG_RESP_LINK_LINK )
                         bp->link_status = STATUS_LINK_ACTIVE;
                 else
                         bp->link_status = STATUS_LINK_DOWN;
         }
         return STATUS_SUCCESS;
 }

References bp, DBGP, DETECT_MEDIA, hwrm_init(), HWRM_PORT_PHY_QCFG, hwrm_port_phy_qcfg_output::link, hwrm_port_phy_qcfg_output::link_speed, hwrm_port_phy_qcfg_output::module_status, PHY_SPEED, PHY_STATUS, PORT_PHY_QCFG_RESP_LINK_LINK, rc, STATUS_FAILURE, STATUS_LINK_ACTIVE, STATUS_LINK_DOWN, STATUS_SUCCESS, SUPPORT_SPEEDS, hwrm_port_phy_qcfg_output::support_speeds, u16, and wait_resp().

Referenced by bnxt_get_phy_link(), and bnxt_query_phy_link().

◆ bnxt_hwrm_nvm_get_variable_req()

static int bnxt_hwrm_nvm_get_variable_req	(	struct bnxt *	bp,
		u16	data_len,
		u16	option_num,
		u16	dimensions,
		u16	index_0
	)

static

Definition at line 1178 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_nvm_get_variable_input );
         struct hwrm_nvm_get_variable_input *req;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_nvm_get_variable_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_NVM_GET_VARIABLE, cmd_len );
         req->dest_data_addr = bp->dma_addr_mapping;
         req->data_len           = data_len;
         req->option_num         = option_num;
         req->dimensions         = dimensions;
         req->index_0            = index_0;
         return wait_resp ( bp,
                 HWRM_CMD_FLASH_MULTIPLAYER ( bp->hwrm_cmd_timeout ),
                 cmd_len, __func__ );
 }

References bp, hwrm_nvm_get_variable_input::data_len, DBGP, hwrm_nvm_get_variable_input::dest_data_addr, hwrm_nvm_get_variable_input::dimensions, HWRM_CMD_FLASH_MULTIPLAYER, hwrm_init(), HWRM_NVM_GET_VARIABLE, hwrm_nvm_get_variable_input::index_0, hwrm_nvm_get_variable_input::option_num, u16, and wait_resp().

Referenced by bnxt_get_link_speed(), and bnxt_get_vlan().

◆ bnxt_get_link_speed()

static int bnxt_get_link_speed ( struct bnxt * bp )

static

Definition at line 1197 of file bnxt.c.

 {
         u32 *ptr32 = ( u32 * )bp->hwrm_addr_dma;
 
         DBGP ( "%s\n", __func__ );
         test_if ( bnxt_hwrm_nvm_get_variable_req ( bp, 4,
                 ( u16 )LINK_SPEED_DRV_NUM,
                 1, ( u16 )bp->port_idx ) != STATUS_SUCCESS )
                 return STATUS_FAILURE;
         bp->link_set = SET_LINK ( *ptr32, SPEED_DRV_MASK, SPEED_DRV_SHIFT );
         test_if ( bnxt_hwrm_nvm_get_variable_req ( bp, 4,
                 ( u16 )LINK_SPEED_FW_NUM,
                 1, ( u16 )bp->port_idx ) != STATUS_SUCCESS )
                 return STATUS_FAILURE;
         bp->link_set |= SET_LINK ( *ptr32, SPEED_FW_MASK, SPEED_FW_SHIFT );
         test_if ( bnxt_hwrm_nvm_get_variable_req ( bp, 4,
                  ( u16 )D3_LINK_SPEED_FW_NUM, 1,
                  ( u16 )bp->port_idx ) != STATUS_SUCCESS )
                 return STATUS_FAILURE;
         bp->link_set |= SET_LINK ( *ptr32, D3_SPEED_FW_MASK,
                         D3_SPEED_FW_SHIFT );
         test_if ( bnxt_hwrm_nvm_get_variable_req ( bp, 1,
                  ( u16 )PORT_CFG_LINK_SETTINGS_MEDIA_AUTO_DETECT_NUM,
                 1, ( u16 )bp->port_idx ) != STATUS_SUCCESS )
                 return STATUS_FAILURE;
         bp->link_set |= SET_LINK ( *ptr32,
                 MEDIA_AUTO_DETECT_MASK, MEDIA_AUTO_DETECT_SHIFT );
 
         switch ( bp->link_set & LINK_SPEED_DRV_MASK ) {
         case LINK_SPEED_DRV_1G:
                 bp->medium = SET_MEDIUM_SPEED ( bp, MEDIUM_SPEED_1000MBPS );
                 break;
         case LINK_SPEED_DRV_2_5G:
                 bp->medium = SET_MEDIUM_SPEED ( bp, MEDIUM_SPEED_2500MBPS );
                 break;
         case LINK_SPEED_DRV_10G:
                 bp->medium = SET_MEDIUM_SPEED ( bp, MEDIUM_SPEED_10GBPS );
                 break;
         case LINK_SPEED_DRV_25G:
                 bp->medium = SET_MEDIUM_SPEED ( bp, MEDIUM_SPEED_25GBPS );
                 break;
         case LINK_SPEED_DRV_40G:
                 bp->medium = SET_MEDIUM_SPEED ( bp, MEDIUM_SPEED_40GBPS );
                 break;
         case LINK_SPEED_DRV_50G:
                 bp->medium = SET_MEDIUM_SPEED ( bp, MEDIUM_SPEED_50GBPS );
                 break;
         case LINK_SPEED_DRV_100G:
                 bp->medium = SET_MEDIUM_SPEED ( bp, MEDIUM_SPEED_100GBPS );
                 break;
         case LINK_SPEED_DRV_200G:
                 bp->medium = SET_MEDIUM_SPEED ( bp, MEDIUM_SPEED_200GBPS );
                 break;
         case LINK_SPEED_DRV_AUTONEG:
                 bp->medium = SET_MEDIUM_SPEED ( bp, MEDIUM_SPEED_AUTONEG );
                 break;
         default:
                 bp->medium = SET_MEDIUM_DUPLEX ( bp, MEDIUM_FULL_DUPLEX );
                 break;
         }
         prn_set_speed ( bp->link_set );
         return STATUS_SUCCESS;
 }

References bnxt_hwrm_nvm_get_variable_req(), bp, D3_LINK_SPEED_FW_NUM, D3_SPEED_FW_MASK, D3_SPEED_FW_SHIFT, DBGP, LINK_SPEED_DRV_100G, LINK_SPEED_DRV_10G, LINK_SPEED_DRV_1G, LINK_SPEED_DRV_200G, LINK_SPEED_DRV_25G, LINK_SPEED_DRV_2_5G, LINK_SPEED_DRV_40G, LINK_SPEED_DRV_50G, LINK_SPEED_DRV_AUTONEG, LINK_SPEED_DRV_MASK, LINK_SPEED_DRV_NUM, LINK_SPEED_FW_NUM, MEDIA_AUTO_DETECT_MASK, MEDIA_AUTO_DETECT_SHIFT, MEDIUM_FULL_DUPLEX, MEDIUM_SPEED_1000MBPS, MEDIUM_SPEED_100GBPS, MEDIUM_SPEED_10GBPS, MEDIUM_SPEED_200GBPS, MEDIUM_SPEED_2500MBPS, MEDIUM_SPEED_25GBPS, MEDIUM_SPEED_40GBPS, MEDIUM_SPEED_50GBPS, MEDIUM_SPEED_AUTONEG, PORT_CFG_LINK_SETTINGS_MEDIA_AUTO_DETECT_NUM, prn_set_speed, SET_LINK, SET_MEDIUM_DUPLEX, SET_MEDIUM_SPEED, SPEED_DRV_MASK, SPEED_DRV_SHIFT, SPEED_FW_MASK, SPEED_FW_SHIFT, STATUS_FAILURE, STATUS_SUCCESS, and test_if.

Referenced by bnxt_query_phy_link().

◆ bnxt_get_vlan()

static int bnxt_get_vlan ( struct bnxt * bp )

static

Definition at line 1261 of file bnxt.c.

 {
         u32 *ptr32 = ( u32 * )bp->hwrm_addr_dma;
 
         /* If VF is set to TRUE, Do not issue this command */
         if ( bp->vf )
                 return STATUS_SUCCESS;
 
         test_if ( bnxt_hwrm_nvm_get_variable_req ( bp, 1,
                  ( u16 )FUNC_CFG_PRE_BOOT_MBA_VLAN_NUM, 1,
                  ( u16 )bp->ordinal_value ) != STATUS_SUCCESS )
                 return STATUS_FAILURE;
 
         bp->mba_cfg2 = SET_MBA ( *ptr32, VLAN_MASK, VLAN_SHIFT );
         test_if ( bnxt_hwrm_nvm_get_variable_req ( bp, 16,
                  ( u16 )FUNC_CFG_PRE_BOOT_MBA_VLAN_VALUE_NUM, 1,
                  ( u16 )bp->ordinal_value ) != STATUS_SUCCESS )
                 return STATUS_FAILURE;
 
         bp->mba_cfg2 |= SET_MBA ( *ptr32, VLAN_VALUE_MASK, VLAN_VALUE_SHIFT );
         if ( bp->mba_cfg2 & FUNC_CFG_PRE_BOOT_MBA_VLAN_ENABLED )
                 bp->vlan_id = bp->mba_cfg2 & VLAN_VALUE_MASK;
         else
                 bp->vlan_id = 0;
 
         if ( bp->mba_cfg2 & FUNC_CFG_PRE_BOOT_MBA_VLAN_ENABLED )
                 DBGP ( "VLAN MBA Enabled ( %d )\n",
                         ( bp->mba_cfg2 & VLAN_VALUE_MASK ) );
 
         return STATUS_SUCCESS;
 }

References bnxt_hwrm_nvm_get_variable_req(), bp, DBGP, FUNC_CFG_PRE_BOOT_MBA_VLAN_ENABLED, FUNC_CFG_PRE_BOOT_MBA_VLAN_NUM, FUNC_CFG_PRE_BOOT_MBA_VLAN_VALUE_NUM, if(), SET_MBA, STATUS_FAILURE, STATUS_SUCCESS, test_if, VLAN_MASK, VLAN_SHIFT, VLAN_VALUE_MASK, and VLAN_VALUE_SHIFT.

◆ bnxt_hwrm_backing_store_qcfg()

static int bnxt_hwrm_backing_store_qcfg ( struct bnxt * bp )

static

Definition at line 1293 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_func_backing_store_qcfg_input );
         struct hwrm_func_backing_store_qcfg_input *req;
 
         DBGP ( "%s\n", __func__ );
         if ( !bp->thor )
                 return STATUS_SUCCESS;
 
         req = ( struct hwrm_func_backing_store_qcfg_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_FUNC_BACKING_STORE_QCFG,
                 cmd_len );
         return wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
 }

References bp, DBGP, HWRM_FUNC_BACKING_STORE_QCFG, hwrm_init(), STATUS_SUCCESS, u16, and wait_resp().

◆ bnxt_hwrm_backing_store_cfg()

static int bnxt_hwrm_backing_store_cfg ( struct bnxt * bp )

static

Definition at line 1308 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_func_backing_store_cfg_input );
         struct hwrm_func_backing_store_cfg_input *req;
 
         DBGP ( "%s\n", __func__ );
         if ( !bp->thor )
                 return STATUS_SUCCESS;
 
         req = ( struct hwrm_func_backing_store_cfg_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_FUNC_BACKING_STORE_CFG,
                 cmd_len );
         req->flags   = FUNC_BACKING_STORE_CFG_REQ_FLAGS_PREBOOT_MODE;
         req->enables = 0;
         return wait_resp ( bp, HWRM_CMD_WAIT ( 6 ), cmd_len, __func__ );
 }

References bp, DBGP, hwrm_func_backing_store_cfg_input::enables, hwrm_func_backing_store_cfg_input::flags, FUNC_BACKING_STORE_CFG_REQ_FLAGS_PREBOOT_MODE, HWRM_CMD_WAIT, HWRM_FUNC_BACKING_STORE_CFG, hwrm_init(), STATUS_SUCCESS, u16, and wait_resp().

◆ bnxt_hwrm_queue_qportcfg()

static int bnxt_hwrm_queue_qportcfg ( struct bnxt * bp )

static

Definition at line 1325 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_queue_qportcfg_input );
         struct hwrm_queue_qportcfg_input *req;
         struct hwrm_queue_qportcfg_output *resp;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         if ( !bp->thor )
                 return STATUS_SUCCESS;
 
         req = ( struct hwrm_queue_qportcfg_input * )bp->hwrm_addr_req;
         resp = ( struct hwrm_queue_qportcfg_output * )bp->hwrm_addr_resp;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_QUEUE_QPORTCFG, cmd_len );
         req->flags   = 0;
         req->port_id = 0;
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc ) {
                 DBGP ( "- %s (  ): Failed\n", __func__ );
                 return STATUS_FAILURE;
         }
 
         bp->queue_id = resp->queue_id0;
         return STATUS_SUCCESS;
 }

References bp, DBGP, hwrm_init(), HWRM_QUEUE_QPORTCFG, hwrm_queue_qportcfg_output::queue_id0, rc, STATUS_FAILURE, STATUS_SUCCESS, u16, and wait_resp().

◆ bnxt_hwrm_port_mac_cfg()

static int bnxt_hwrm_port_mac_cfg ( struct bnxt * bp )

static

Definition at line 1351 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_port_mac_cfg_input );
         struct hwrm_port_mac_cfg_input *req;
 
         DBGP ( "%s\n", __func__ );
         if ( bp->vf )
                 return STATUS_SUCCESS;
 
         req = ( struct hwrm_port_mac_cfg_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_PORT_MAC_CFG, cmd_len );
         req->lpbk = PORT_MAC_CFG_REQ_LPBK_NONE;
         return wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
 }

References bp, DBGP, hwrm_init(), HWRM_PORT_MAC_CFG, hwrm_port_mac_cfg_input::lpbk, PORT_MAC_CFG_REQ_LPBK_NONE, STATUS_SUCCESS, u16, and wait_resp().

◆ bnxt_hwrm_port_phy_cfg()

static int bnxt_hwrm_port_phy_cfg ( struct bnxt * bp )

static

Definition at line 1366 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_port_phy_cfg_input );
         struct hwrm_port_phy_cfg_input *req;
         u32 flags;
         u32 enables = 0;
         u16 force_link_speed = 0;
         u16 auto_link_speed_mask = 0;
         u8  auto_mode = 0;
         u8  auto_pause = 0;
         u8  auto_duplex = 0;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_port_phy_cfg_input * )bp->hwrm_addr_req;
         flags = PORT_PHY_CFG_REQ_FLAGS_FORCE |
                 PORT_PHY_CFG_REQ_FLAGS_RESET_PHY;
 
         switch ( GET_MEDIUM_SPEED ( bp->medium ) ) {
         case MEDIUM_SPEED_1000MBPS:
                 force_link_speed = PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_1GB;
                 break;
         case MEDIUM_SPEED_10GBPS:
                 force_link_speed = PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_10GB;
                 break;
         case MEDIUM_SPEED_25GBPS:
                 force_link_speed = PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_25GB;
                 break;
         case MEDIUM_SPEED_40GBPS:
                 force_link_speed = PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_40GB;
                 break;
         case MEDIUM_SPEED_50GBPS:
                 force_link_speed = PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_50GB;
                 break;
         case MEDIUM_SPEED_100GBPS:
                 force_link_speed = PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_100GB;
                 break;
         case MEDIUM_SPEED_200GBPS:
                 force_link_speed = PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_200GB;
                 break;
         default:
                 auto_mode = PORT_PHY_CFG_REQ_AUTO_MODE_SPEED_MASK;
                 flags &= ~PORT_PHY_CFG_REQ_FLAGS_FORCE;
                 enables |= PORT_PHY_CFG_REQ_ENABLES_AUTO_MODE |
                         PORT_PHY_CFG_REQ_ENABLES_AUTO_LINK_SPEED_MASK |
                         PORT_PHY_CFG_REQ_ENABLES_AUTO_DUPLEX |
                         PORT_PHY_CFG_REQ_ENABLES_AUTO_PAUSE;
                 auto_pause = PORT_PHY_CFG_REQ_AUTO_PAUSE_TX |
                                 PORT_PHY_CFG_REQ_AUTO_PAUSE_RX;
                 auto_duplex = PORT_PHY_CFG_REQ_AUTO_DUPLEX_BOTH;
                 auto_link_speed_mask = bp->support_speeds;
                 break;
         }
 
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_PORT_PHY_CFG, cmd_len );
         req->flags = flags;
         req->enables = enables;
         req->port_id = bp->port_idx;
         req->force_link_speed = force_link_speed;
         req->auto_mode = auto_mode;
         req->auto_duplex = auto_duplex;
         req->auto_pause = auto_pause;
         req->auto_link_speed_mask = auto_link_speed_mask;
 
         return wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
 }

References hwrm_port_phy_cfg_input::auto_duplex, hwrm_port_phy_cfg_input::auto_link_speed_mask, hwrm_port_phy_cfg_input::auto_mode, hwrm_port_phy_cfg_input::auto_pause, bp, DBGP, hwrm_port_phy_cfg_input::enables, flags, hwrm_port_phy_cfg_input::force_link_speed, GET_MEDIUM_SPEED, hwrm_init(), HWRM_PORT_PHY_CFG, MEDIUM_SPEED_1000MBPS, MEDIUM_SPEED_100GBPS, MEDIUM_SPEED_10GBPS, MEDIUM_SPEED_200GBPS, MEDIUM_SPEED_25GBPS, MEDIUM_SPEED_40GBPS, MEDIUM_SPEED_50GBPS, PORT_PHY_CFG_REQ_AUTO_DUPLEX_BOTH, PORT_PHY_CFG_REQ_AUTO_MODE_SPEED_MASK, PORT_PHY_CFG_REQ_AUTO_PAUSE_RX, PORT_PHY_CFG_REQ_AUTO_PAUSE_TX, PORT_PHY_CFG_REQ_ENABLES_AUTO_DUPLEX, PORT_PHY_CFG_REQ_ENABLES_AUTO_LINK_SPEED_MASK, PORT_PHY_CFG_REQ_ENABLES_AUTO_MODE, PORT_PHY_CFG_REQ_ENABLES_AUTO_PAUSE, PORT_PHY_CFG_REQ_FLAGS_FORCE, PORT_PHY_CFG_REQ_FLAGS_RESET_PHY, PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_100GB, PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_10GB, PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_1GB, PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_200GB, PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_25GB, PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_40GB, PORT_PHY_CFG_REQ_FORCE_LINK_SPEED_50GB, switch(), u16, and wait_resp().

Referenced by bnxt_query_phy_link().

◆ bnxt_query_phy_link()

static int bnxt_query_phy_link ( struct bnxt * bp )

static

Definition at line 1432 of file bnxt.c.

 {
         u16 flag = PHY_STATUS | PHY_SPEED | DETECT_MEDIA;
 
         DBGP ( "%s\n", __func__ );
         /* Query Link Status */
         if ( bnxt_hwrm_port_phy_qcfg ( bp, QCFG_PHY_ALL ) != STATUS_SUCCESS ) {
                         return STATUS_FAILURE;
         }
 
         if ( bp->link_status == STATUS_LINK_ACTIVE )
                 return STATUS_SUCCESS;
 
         /* If VF is set to TRUE, Do not issue the following commands */
         if ( bp->vf )
                 return STATUS_SUCCESS;
 
         /* If multi_host or NPAR, Do not issue bnxt_get_link_speed */
         if ( FLAG_TEST ( bp->flags, PORT_PHY_FLAGS ) ) {
                 dbg_flags ( __func__, bp->flags );
                 return STATUS_SUCCESS;
         }
 
         /* HWRM_NVM_GET_VARIABLE - speed */
         if ( bnxt_get_link_speed ( bp ) != STATUS_SUCCESS ) {
                         return STATUS_FAILURE;
         }
 
         /* Configure link if it is not up */
         bnxt_hwrm_port_phy_cfg ( bp );
 
         /* refresh link speed values after bringing link up */
         return bnxt_hwrm_port_phy_qcfg ( bp, flag );
 }

References bnxt_get_link_speed(), bnxt_hwrm_port_phy_cfg(), bnxt_hwrm_port_phy_qcfg(), bp, dbg_flags, DBGP, DETECT_MEDIA, flag, FLAG_TEST, PHY_SPEED, PHY_STATUS, PORT_PHY_FLAGS, QCFG_PHY_ALL, STATUS_FAILURE, STATUS_LINK_ACTIVE, and STATUS_SUCCESS.

◆ bnxt_get_phy_link()

static int bnxt_get_phy_link ( struct bnxt * bp )

static

Definition at line 1467 of file bnxt.c.

 {
         u16 i;
         u16 flag = PHY_STATUS | PHY_SPEED | DETECT_MEDIA;
 
         DBGP ( "%s\n", __func__ );
         dbg_chip_info ( bp );
         for ( i = 0; i < ( bp->wait_link_timeout / 100 ); i++ ) {
                 if ( bnxt_hwrm_port_phy_qcfg ( bp, flag ) != STATUS_SUCCESS )
                         break;
 
                 if ( bp->link_status == STATUS_LINK_ACTIVE )
                         break;
 
 //              if ( bp->media_detect )
 //                      break;
                 mdelay ( LINK_POLL_WAIT_TIME );
         }
         dbg_link_state ( bp, ( u32 ) ( ( i + 1 ) * 100 ) );
         bnxt_set_link ( bp );
         return STATUS_SUCCESS;
 }

References bnxt_hwrm_port_phy_qcfg(), bnxt_set_link(), bp, dbg_chip_info, dbg_link_state, DBGP, DETECT_MEDIA, flag, LINK_POLL_WAIT_TIME, mdelay(), PHY_SPEED, PHY_STATUS, STATUS_LINK_ACTIVE, and STATUS_SUCCESS.

◆ bnxt_hwrm_stat_ctx_alloc()

static int bnxt_hwrm_stat_ctx_alloc ( struct bnxt * bp )

static

Definition at line 1490 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_stat_ctx_alloc_input );
         struct hwrm_stat_ctx_alloc_input *req;
         struct hwrm_stat_ctx_alloc_output *resp;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_stat_ctx_alloc_input * )bp->hwrm_addr_req;
         resp = ( struct hwrm_stat_ctx_alloc_output * )bp->hwrm_addr_resp;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_STAT_CTX_ALLOC, cmd_len );
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc ) {
                 DBGP ( "- %s (  ): Failed\n", __func__ );
                 return STATUS_FAILURE;
         }
 
         FLAG_SET ( bp->flag_hwrm, VALID_STAT_CTX );
         bp->stat_ctx_id = ( u16 )resp->stat_ctx_id;
         return STATUS_SUCCESS;
 }

References bp, DBGP, FLAG_SET, hwrm_init(), HWRM_STAT_CTX_ALLOC, rc, hwrm_stat_ctx_alloc_output::stat_ctx_id, STATUS_FAILURE, STATUS_SUCCESS, u16, VALID_STAT_CTX, and wait_resp().

◆ bnxt_hwrm_stat_ctx_free()

static int bnxt_hwrm_stat_ctx_free ( struct bnxt * bp )

static

Definition at line 1512 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_stat_ctx_free_input );
         struct hwrm_stat_ctx_free_input *req;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         if ( ! ( FLAG_TEST ( bp->flag_hwrm, VALID_STAT_CTX ) ) )
                 return STATUS_SUCCESS;
 
         req = ( struct hwrm_stat_ctx_free_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_STAT_CTX_FREE, cmd_len );
         req->stat_ctx_id = ( u32 )bp->stat_ctx_id;
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc ) {
                 DBGP ( "- %s (  ): Failed\n", __func__ );
                 return STATUS_FAILURE;
         }
 
         FLAG_RESET ( bp->flag_hwrm, VALID_STAT_CTX );
         return STATUS_SUCCESS;
 }

References bp, DBGP, FLAG_RESET, FLAG_TEST, hwrm_init(), HWRM_STAT_CTX_FREE, rc, hwrm_stat_ctx_free_input::stat_ctx_id, STATUS_FAILURE, STATUS_SUCCESS, u16, u32, VALID_STAT_CTX, and wait_resp().

◆ bnxt_hwrm_ring_free_grp()

static int bnxt_hwrm_ring_free_grp ( struct bnxt * bp )

static

Definition at line 1535 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_ring_grp_free_input );
         struct hwrm_ring_grp_free_input *req;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         if ( ! ( FLAG_TEST ( bp->flag_hwrm, VALID_RING_GRP ) ) )
                 return STATUS_SUCCESS;
 
         req = ( struct hwrm_ring_grp_free_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_RING_GRP_FREE, cmd_len );
         req->ring_group_id = ( u32 )bp->ring_grp_id;
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc ) {
                 DBGP ( "- %s (  ): Failed\n", __func__ );
                 return STATUS_FAILURE;
         }
 
         FLAG_RESET ( bp->flag_hwrm, VALID_RING_GRP );
         return STATUS_SUCCESS;
 }

References bp, DBGP, FLAG_RESET, FLAG_TEST, hwrm_init(), HWRM_RING_GRP_FREE, rc, hwrm_ring_grp_free_input::ring_group_id, STATUS_FAILURE, STATUS_SUCCESS, u16, u32, VALID_RING_GRP, and wait_resp().

◆ bnxt_hwrm_ring_alloc_grp()

static int bnxt_hwrm_ring_alloc_grp ( struct bnxt * bp )

static

Definition at line 1558 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_ring_grp_alloc_input );
         struct hwrm_ring_grp_alloc_input *req;
         struct hwrm_ring_grp_alloc_output *resp;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         if ( bp->thor )
                 return STATUS_SUCCESS;
 
         req = ( struct hwrm_ring_grp_alloc_input * )bp->hwrm_addr_req;
         resp = ( struct hwrm_ring_grp_alloc_output * )bp->hwrm_addr_resp;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_RING_GRP_ALLOC, cmd_len );
         req->cr = bp->cq_ring_id;
         req->rr = bp->rx_ring_id;
         req->ar = ( u16 )HWRM_NA_SIGNATURE;
         if ( bp->vf )
                 req->sc = bp->stat_ctx_id;
 
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc ) {
                 DBGP ( "- %s (  ): Failed\n", __func__ );
                 return STATUS_FAILURE;
         }
 
         FLAG_SET ( bp->flag_hwrm, VALID_RING_GRP );
         bp->ring_grp_id = ( u16 )resp->ring_group_id;
         return STATUS_SUCCESS;
 }

References bp, DBGP, FLAG_SET, hwrm_init(), HWRM_NA_SIGNATURE, HWRM_RING_GRP_ALLOC, rc, hwrm_ring_grp_alloc_output::ring_group_id, STATUS_FAILURE, STATUS_SUCCESS, u16, VALID_RING_GRP, and wait_resp().

◆ bnxt_hwrm_ring_free()

int bnxt_hwrm_ring_free	(	struct bnxt *	bp,
		u16	ring_id,
		u8	ring_type
	)

Definition at line 1589 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_ring_free_input );
         struct hwrm_ring_free_input *req;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_ring_free_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_RING_FREE, cmd_len );
         req->ring_type = ring_type;
         req->ring_id   = ring_id;
         return wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
 }

References bp, DBGP, hwrm_init(), HWRM_RING_FREE, hwrm_ring_free_input::ring_id, hwrm_ring_free_input::ring_type, u16, and wait_resp().

◆ bnxt_hwrm_ring_alloc()

static int bnxt_hwrm_ring_alloc	(	struct bnxt *	bp,
		u8	type
	)

static

Definition at line 1602 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_ring_alloc_input );
         struct hwrm_ring_alloc_input *req;
         struct hwrm_ring_alloc_output *resp;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_ring_alloc_input * )bp->hwrm_addr_req;
         resp = ( struct hwrm_ring_alloc_output * )bp->hwrm_addr_resp;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_RING_ALLOC, cmd_len );
         req->ring_type = type;
         switch ( type ) {
         case RING_ALLOC_REQ_RING_TYPE_NQ:
                 req->page_size  = LM_PAGE_BITS ( 12 );
                 req->int_mode   = BNXT_CQ_INTR_MODE ( bp->vf );
                 req->length     = ( u32 )bp->nq.ring_cnt;
                 req->logical_id = 0xFFFF; // Required value for Thor FW?
                 req->page_tbl_addr = virt_to_bus ( bp->nq.bd_virt );
                 break;
         case RING_ALLOC_REQ_RING_TYPE_L2_CMPL:
                 req->page_size = LM_PAGE_BITS ( 8 );
                 req->int_mode  = BNXT_CQ_INTR_MODE ( bp->vf );
                 req->length    = ( u32 )bp->cq.ring_cnt;
                 req->page_tbl_addr = virt_to_bus ( bp->cq.bd_virt );
                 if ( !bp->thor )
                         break;
                 req->enables = RING_ALLOC_REQ_ENABLES_NQ_RING_ID_VALID;
                 req->nq_ring_id = bp->nq_ring_id;
                 req->cq_handle = ( u64 )bp->nq_ring_id;
                 break;
         case RING_ALLOC_REQ_RING_TYPE_TX:
                 req->page_size   = LM_PAGE_BITS ( 8 );
                 req->int_mode    = RING_ALLOC_REQ_INT_MODE_POLL;
                 req->length      = ( u32 )bp->tx.ring_cnt;
                 req->queue_id    = TX_RING_QID;
                 req->stat_ctx_id = ( u32 )bp->stat_ctx_id;
                 req->cmpl_ring_id  = bp->cq_ring_id;
                 req->page_tbl_addr = virt_to_bus ( bp->tx.bd_virt );
                 break;
         case RING_ALLOC_REQ_RING_TYPE_RX:
                 req->page_size   = LM_PAGE_BITS ( 8 );
                 req->int_mode    = RING_ALLOC_REQ_INT_MODE_POLL;
                 req->length      = ( u32 )bp->rx.ring_cnt;
                 req->stat_ctx_id = ( u32 )STAT_CTX_ID;
                 req->cmpl_ring_id  = bp->cq_ring_id;
                 req->page_tbl_addr = virt_to_bus ( bp->rx.bd_virt );
                 if ( !bp->thor )
                         break;
                 req->queue_id    = ( u16 )RX_RING_QID;
                 req->rx_buf_size = MAX_ETHERNET_PACKET_BUFFER_SIZE;
                 req->enables     = RING_ALLOC_REQ_ENABLES_RX_BUF_SIZE_VALID;
                 break;
         default:
                 return STATUS_SUCCESS;
         }
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc ) {
                 DBGP ( "- %s (  ): Failed, type = %x\n", __func__, type );
                 return STATUS_FAILURE;
         }
 
         if ( type == RING_ALLOC_REQ_RING_TYPE_L2_CMPL ) {
                 FLAG_SET ( bp->flag_hwrm, VALID_RING_CQ );
                 bp->cq_ring_id = resp->ring_id;
         } else if ( type == RING_ALLOC_REQ_RING_TYPE_TX ) {
                 FLAG_SET ( bp->flag_hwrm, VALID_RING_TX );
                 bp->tx_ring_id = resp->ring_id;
         } else if ( type == RING_ALLOC_REQ_RING_TYPE_RX ) {
                 FLAG_SET ( bp->flag_hwrm, VALID_RING_RX );
                 bp->rx_ring_id = resp->ring_id;
         } else if ( type == RING_ALLOC_REQ_RING_TYPE_NQ ) {
                 FLAG_SET ( bp->flag_hwrm, VALID_RING_NQ );
                 bp->nq_ring_id = resp->ring_id;
         }
         return STATUS_SUCCESS;
 }

References BNXT_CQ_INTR_MODE, bp, DBGP, FLAG_SET, hwrm_init(), HWRM_RING_ALLOC, LM_PAGE_BITS, MAX_ETHERNET_PACKET_BUFFER_SIZE, rc, RING_ALLOC_REQ_ENABLES_NQ_RING_ID_VALID, RING_ALLOC_REQ_ENABLES_RX_BUF_SIZE_VALID, RING_ALLOC_REQ_INT_MODE_POLL, RING_ALLOC_REQ_RING_TYPE_L2_CMPL, RING_ALLOC_REQ_RING_TYPE_NQ, RING_ALLOC_REQ_RING_TYPE_RX, RING_ALLOC_REQ_RING_TYPE_TX, hwrm_ring_alloc_output::ring_id, RX_RING_QID, STAT_CTX_ID, STATUS_FAILURE, STATUS_SUCCESS, TX_RING_QID, type, u16, u32, VALID_RING_CQ, VALID_RING_NQ, VALID_RING_RX, VALID_RING_TX, virt_to_bus(), and wait_resp().

Referenced by bnxt_hwrm_ring_alloc_cq(), bnxt_hwrm_ring_alloc_nq(), bnxt_hwrm_ring_alloc_rx(), and bnxt_hwrm_ring_alloc_tx().

◆ bnxt_hwrm_ring_alloc_cq()

static int bnxt_hwrm_ring_alloc_cq ( struct bnxt * bp )

static

Definition at line 1680 of file bnxt.c.

 {
         DBGP ( "%s\n", __func__ );
         return bnxt_hwrm_ring_alloc ( bp, RING_ALLOC_REQ_RING_TYPE_L2_CMPL );
 }

References bnxt_hwrm_ring_alloc(), bp, DBGP, and RING_ALLOC_REQ_RING_TYPE_L2_CMPL.

◆ bnxt_hwrm_ring_alloc_tx()

static int bnxt_hwrm_ring_alloc_tx ( struct bnxt * bp )

static

Definition at line 1686 of file bnxt.c.

 {
         DBGP ( "%s\n", __func__ );
         return bnxt_hwrm_ring_alloc ( bp, RING_ALLOC_REQ_RING_TYPE_TX );
 }

References bnxt_hwrm_ring_alloc(), bp, DBGP, and RING_ALLOC_REQ_RING_TYPE_TX.

◆ bnxt_hwrm_ring_alloc_rx()

static int bnxt_hwrm_ring_alloc_rx ( struct bnxt * bp )

static

Definition at line 1692 of file bnxt.c.

 {
         DBGP ( "%s\n", __func__ );
         return bnxt_hwrm_ring_alloc ( bp, RING_ALLOC_REQ_RING_TYPE_RX );
 }

References bnxt_hwrm_ring_alloc(), bp, DBGP, and RING_ALLOC_REQ_RING_TYPE_RX.

◆ bnxt_hwrm_ring_free_cq()

static int bnxt_hwrm_ring_free_cq ( struct bnxt * bp )

static

Definition at line 1698 of file bnxt.c.

 {
         int ret = STATUS_SUCCESS;
 
         DBGP ( "%s\n", __func__ );
         if ( ! ( FLAG_TEST ( bp->flag_hwrm, VALID_RING_CQ ) ) )
                 return ret;
 
         ret = RING_FREE ( bp, bp->cq_ring_id, RING_FREE_REQ_RING_TYPE_L2_CMPL );
         if ( ret == STATUS_SUCCESS )
                 FLAG_RESET ( bp->flag_hwrm, VALID_RING_CQ );
 
         return ret;
 }

References bp, DBGP, FLAG_RESET, FLAG_TEST, RING_FREE, RING_FREE_REQ_RING_TYPE_L2_CMPL, STATUS_SUCCESS, and VALID_RING_CQ.

◆ bnxt_hwrm_ring_free_tx()

static int bnxt_hwrm_ring_free_tx ( struct bnxt * bp )

static

Definition at line 1713 of file bnxt.c.

 {
         int ret = STATUS_SUCCESS;
 
         DBGP ( "%s\n", __func__ );
         if ( ! ( FLAG_TEST ( bp->flag_hwrm, VALID_RING_TX ) ) )
                 return ret;
 
         ret = RING_FREE ( bp, bp->tx_ring_id, RING_FREE_REQ_RING_TYPE_TX );
         if ( ret == STATUS_SUCCESS )
                 FLAG_RESET ( bp->flag_hwrm, VALID_RING_TX );
 
         return ret;
 }

References bp, DBGP, FLAG_RESET, FLAG_TEST, RING_FREE, RING_FREE_REQ_RING_TYPE_TX, STATUS_SUCCESS, and VALID_RING_TX.

◆ bnxt_hwrm_ring_free_rx()

static int bnxt_hwrm_ring_free_rx ( struct bnxt * bp )

static

Definition at line 1728 of file bnxt.c.

 {
         int ret = STATUS_SUCCESS;
 
         DBGP ( "%s\n", __func__ );
         if ( ! ( FLAG_TEST ( bp->flag_hwrm, VALID_RING_RX ) ) )
                 return ret;
 
         ret = RING_FREE ( bp, bp->rx_ring_id, RING_FREE_REQ_RING_TYPE_RX );
         if ( ret == STATUS_SUCCESS )
                 FLAG_RESET ( bp->flag_hwrm, VALID_RING_RX );
 
         return ret;
 }

References bp, DBGP, FLAG_RESET, FLAG_TEST, RING_FREE, RING_FREE_REQ_RING_TYPE_RX, STATUS_SUCCESS, and VALID_RING_RX.

◆ bnxt_hwrm_ring_alloc_nq()

static int bnxt_hwrm_ring_alloc_nq ( struct bnxt * bp )

static

Definition at line 1743 of file bnxt.c.

 {
         if ( !bp->thor )
                 return STATUS_SUCCESS;
         return bnxt_hwrm_ring_alloc ( bp, RING_ALLOC_REQ_RING_TYPE_NQ );
 }

References bnxt_hwrm_ring_alloc(), bp, RING_ALLOC_REQ_RING_TYPE_NQ, and STATUS_SUCCESS.

◆ bnxt_hwrm_ring_free_nq()

static int bnxt_hwrm_ring_free_nq ( struct bnxt * bp )

static

Definition at line 1750 of file bnxt.c.

 {
         int ret = STATUS_SUCCESS;
 
         if ( !bp->thor )
                 return STATUS_SUCCESS;
 
         DBGP ( "%s\n", __func__ );
         if ( ! ( FLAG_TEST ( bp->flag_hwrm, VALID_RING_NQ ) ) )
                 return ret;
 
         ret = RING_FREE ( bp, bp->nq_ring_id, RING_FREE_REQ_RING_TYPE_NQ );
         if ( ret == STATUS_SUCCESS )
                 FLAG_RESET ( bp->flag_hwrm, VALID_RING_NQ );
 
         return ret;
 }

References bp, DBGP, FLAG_RESET, FLAG_TEST, RING_FREE, RING_FREE_REQ_RING_TYPE_NQ, STATUS_SUCCESS, and VALID_RING_NQ.

◆ bnxt_hwrm_vnic_alloc()

static int bnxt_hwrm_vnic_alloc ( struct bnxt * bp )

static

Definition at line 1768 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_vnic_alloc_input );
         struct hwrm_vnic_alloc_input *req;
         struct hwrm_vnic_alloc_output *resp;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_vnic_alloc_input * )bp->hwrm_addr_req;
         resp = ( struct hwrm_vnic_alloc_output * )bp->hwrm_addr_resp;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_VNIC_ALLOC, cmd_len );
         req->flags = VNIC_ALLOC_REQ_FLAGS_DEFAULT;
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc ) {
                 DBGP ( "- %s (  ): Failed\n", __func__ );
                 return STATUS_FAILURE;
         }
 
         FLAG_SET ( bp->flag_hwrm, VALID_VNIC_ID );
         bp->vnic_id = resp->vnic_id;
         return STATUS_SUCCESS;
 }

References bp, DBGP, FLAG_SET, hwrm_init(), HWRM_VNIC_ALLOC, rc, STATUS_FAILURE, STATUS_SUCCESS, u16, VALID_VNIC_ID, VNIC_ALLOC_REQ_FLAGS_DEFAULT, hwrm_vnic_alloc_output::vnic_id, and wait_resp().

◆ bnxt_hwrm_vnic_free()

static int bnxt_hwrm_vnic_free ( struct bnxt * bp )

static

Definition at line 1791 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_vnic_free_input );
         struct hwrm_vnic_free_input *req;
         int rc;
 
         DBGP ( "%s\n", __func__ );
         if ( ! ( FLAG_TEST ( bp->flag_hwrm, VALID_VNIC_ID ) ) )
                 return STATUS_SUCCESS;
 
         req = ( struct hwrm_vnic_free_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_VNIC_FREE, cmd_len );
         req->vnic_id = bp->vnic_id;
         rc = wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
         if ( rc ) {
                 DBGP ( "- %s (  ): Failed\n", __func__ );
                 return STATUS_FAILURE;
         }
 
         FLAG_RESET ( bp->flag_hwrm, VALID_VNIC_ID );
         return STATUS_SUCCESS;
 }

References bp, DBGP, FLAG_RESET, FLAG_TEST, hwrm_init(), HWRM_VNIC_FREE, rc, STATUS_FAILURE, STATUS_SUCCESS, u16, VALID_VNIC_ID, hwrm_vnic_free_input::vnic_id, and wait_resp().

◆ bnxt_hwrm_vnic_cfg()

static int bnxt_hwrm_vnic_cfg ( struct bnxt * bp )

static

Definition at line 1814 of file bnxt.c.

 {
         u16 cmd_len = ( u16 )sizeof ( struct hwrm_vnic_cfg_input );
         struct hwrm_vnic_cfg_input *req;
 
         DBGP ( "%s\n", __func__ );
         req = ( struct hwrm_vnic_cfg_input * )bp->hwrm_addr_req;
         hwrm_init ( bp, ( void * )req, ( u16 )HWRM_VNIC_CFG, cmd_len );
         req->enables = VNIC_CFG_REQ_ENABLES_MRU;
         req->mru         = bp->mtu;
 
         if ( bp->thor ) {
                 req->enables |= ( VNIC_CFG_REQ_ENABLES_DEFAULT_RX_RING_ID |
                                 VNIC_CFG_REQ_ENABLES_DEFAULT_CMPL_RING_ID );
                 req->default_rx_ring_id   = bp->rx_ring_id;
                 req->default_cmpl_ring_id = bp->cq_ring_id;
         } else {
                 req->enables |= VNIC_CFG_REQ_ENABLES_DFLT_RING_GRP;
                 req->dflt_ring_grp = bp->ring_grp_id;
         }
 
         req->flags   = VNIC_CFG_REQ_FLAGS_VLAN_STRIP_MODE;
         req->vnic_id = bp->vnic_id;
         return wait_resp ( bp, bp->hwrm_cmd_timeout, cmd_len, __func__ );
 }

References bp, DBGP, hwrm_vnic_cfg_input::default_cmpl_ring_id, hwrm_vnic_cfg_input::default_rx_ring_id, hwrm_vnic_cfg_input::dflt_ring_grp, hwrm_vnic_cfg_input::enables, hwrm_vnic_cfg_input::flags, hwrm_init(), HWRM_VNIC_CFG, hwrm_vnic_cfg_input::mru, u16, VNIC_CFG_REQ_ENABLES_DEFAULT_CMPL_RING_ID, VNIC_CFG_REQ_ENABLES_DEFAULT_RX_RING_ID, VNIC_CFG_REQ_ENABLES_DFLT_RING_GRP, VNIC_CFG_REQ_ENABLES_MRU, VNIC_CFG_REQ_FLAGS_VLAN_STRIP_MODE, hwrm_vnic_cfg_input::vnic_id, and wait_resp().

◆ bnxt_set_rx_mask()

static int bnxt_set_rx_mask ( struct bnxt * bp )

static

Definition at line 1840 of file bnxt.c.

 {
         return bnxt_hwrm_set_rx_mask ( bp, RX_MASK );
 }

References bnxt_hwrm_set_rx_mask(), bp, and RX_MASK.

◆ bnxt_reset_rx_mask()

static int bnxt_reset_rx_mask ( struct bnxt * bp )

static

Definition at line 1845 of file bnxt.c.

 {
         return bnxt_hwrm_set_rx_mask ( bp, 0 );
 }

References bnxt_hwrm_set_rx_mask(), and bp.

◆ bnxt_hwrm_run()

int bnxt_hwrm_run	(	hwrm_func_t	cmds[],
		struct bnxt *	bp
	)

Definition at line 1906 of file bnxt.c.

 {
         hwrm_func_t *ptr;
         int ret;
 
         for ( ptr = cmds; *ptr; ++ptr ) {
                 memset ( bp->hwrm_addr_req,  0, REQ_BUFFER_SIZE );
                 memset ( bp->hwrm_addr_resp, 0, RESP_BUFFER_SIZE );
                 ret = ( *ptr ) ( bp );
                 if ( ret ) {
                         DBGP ( "- %s (  ): Failed\n", __func__ );
                         return STATUS_FAILURE;
                 }
         }
         return STATUS_SUCCESS;
 }

References bp, DBGP, memset(), REQ_BUFFER_SIZE, RESP_BUFFER_SIZE, STATUS_FAILURE, and STATUS_SUCCESS.

◆ bnxt_open()

static int bnxt_open ( struct net_device * dev )

static

Definition at line 1928 of file bnxt.c.

 {
         struct bnxt *bp = netdev_priv ( dev );
 
         DBGP ( "%s\n", __func__ );
         bnxt_mm_nic ( bp );
         return (bnxt_up_nic ( bp ));
 }

References bnxt_mm_nic(), bnxt_up_nic, bp, DBGP, bnxt::dev, and netdev_priv().

◆ bnxt_tx_adjust_pkt()

static void bnxt_tx_adjust_pkt	(	struct bnxt *	bp,
		struct io_buffer *	iob
	)

static

Definition at line 1937 of file bnxt.c.

 {
         u16 prev_len = iob_len ( iob );
 
         bp->vlan_tx = bnxt_get_pkt_vlan ( ( char * )iob->data );
         if ( !bp->vlan_tx && bp->vlan_id )
                 bnxt_add_vlan ( iob, bp->vlan_id );
 
         dbg_tx_vlan ( bp, ( char * )iob->data, prev_len, iob_len ( iob ) );
         if ( iob_len ( iob ) != prev_len )
                 prev_len = iob_len ( iob );
 
         iob_pad ( iob, ETH_ZLEN );
         dbg_tx_pad ( prev_len, iob_len ( iob ) );
 }

References bnxt_add_vlan(), bnxt_get_pkt_vlan(), bp, io_buffer::data, dbg_tx_pad, dbg_tx_vlan, ETH_ZLEN, iob_len(), and iob_pad().

Referenced by bnxt_tx().

◆ bnxt_tx()

static int bnxt_tx	(	struct net_device *	dev,
		struct io_buffer *	iob
	)

static

Definition at line 1953 of file bnxt.c.

 {
         struct bnxt *bp = netdev_priv ( dev );
         u16 len, entry;
         dma_addr_t mapping;
 
         if ( bnxt_tx_avail ( bp ) < 1 ) {
                 DBGP ( "- %s (  ): Failed no bd's available\n", __func__ );
                 return -ENOBUFS;
         }
 
         bnxt_tx_adjust_pkt ( bp, iob );
         entry = bp->tx.prod_id;
         mapping = virt_to_bus ( iob->data );
         len = iob_len ( iob );
         bp->tx.iob[entry] = iob;
         bnxt_set_txq ( bp, entry, mapping, len );
         entry = NEXT_IDX ( entry, bp->tx.ring_cnt );
         dump_tx_pkt ( ( u8 * )iob->data, len, bp->tx.prod_id );
         /* Packets are ready, update Tx producer idx local and on card. */
         bnxt_db_tx ( bp, ( u32 )entry );
         bp->tx.prod_id = entry;
         bp->tx.cnt_req++;
         /* memory barrier */
         mb (  );
         return 0;
 }

References bnxt_db_tx(), bnxt_set_txq(), bnxt_tx_adjust_pkt(), bnxt_tx_avail(), bp, io_buffer::data, DBGP, bnxt::dev, dump_tx_pkt, ENOBUFS, entry, iob_len(), len, mb(), netdev_priv(), NEXT_IDX, and virt_to_bus().

◆ bnxt_adv_nq_index()

static void bnxt_adv_nq_index	(	struct bnxt *	bp,
		u16	cnt
	)

static

Definition at line 1981 of file bnxt.c.

 {
         u16 cons_id;
 
         cons_id = bp->nq.cons_id + cnt;
         if ( cons_id >= bp->nq.ring_cnt ) {
                 /* Toggle completion bit when the ring wraps. */
                 bp->nq.completion_bit ^= 1;
                 cons_id = cons_id - bp->nq.ring_cnt;
         }
         bp->nq.cons_id = cons_id;
 }

References bp.

Referenced by bnxt_service_nq().

◆ bnxt_service_nq()

static void bnxt_service_nq ( struct net_device * dev )

static

Definition at line 2058 of file bnxt.c.

2059 {

2060 struct bnxt *bp = netdev_priv (

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ bnxt_down_chip

◆ bnxt_up_chip

◆ bnxt_down_nic

◆ bnxt_up_nic

Typedef Documentation

◆ hwrm_func_t

Function Documentation

◆ FILE_LICENCE()

◆ bnxt_service_cq()

◆ bnxt_tx_complete()

◆ bnxt_adv_cq_index()

◆ bnxt_rx_complete()

◆ bnxt_link_evt()

◆ bnxt_is_pci_vf()

◆ bnxt_down_pci()

◆ bnxt_pci_base()

◆ bnxt_get_pci_info()

◆ bnxt_get_device_address()

◆ bnxt_set_link()

◆ thor_db()

◆ bnxt_db_nq()

◆ bnxt_db_cq()

◆ bnxt_db_rx()

◆ bnxt_db_tx()

◆ bnxt_add_vlan()

◆ bnxt_get_pkt_vlan()

◆ bnxt_vlan_drop()

◆ bnxt_tx_avail()

◆ bnxt_set_txq()

◆ bnxt_free_rx_iob()

◆ bnxt_set_rx_desc()

◆ bnxt_alloc_rx_iob()

◆ bnxt_post_rx_buffers()

◆ bnxt_rx_drop()

◆ bnxt_rx_process()

◆ bnxt_mm_init()

◆ bnxt_mm_nic()

◆ bnxt_free_mem()

◆ bnxt_alloc_mem()

◆ hwrm_init()

◆ hwrm_write_req()

◆ short_hwrm_cmd_req()

◆ wait_resp()

◆ bnxt_hwrm_ver_get()

◆ bnxt_hwrm_func_resource_qcaps()

◆ bnxt_set_ring_info()

◆ bnxt_hwrm_assign_resources()

◆ bnxt_hwrm_func_qcaps_req()

◆ bnxt_hwrm_func_qcfg_req()

◆ bnxt_hwrm_func_reset_req()

◆ bnxt_hwrm_func_cfg_req()

◆ bnxt_hwrm_func_drv_rgtr()

◆ bnxt_hwrm_func_drv_unrgtr()

◆ bnxt_hwrm_set_async_event()

◆ bnxt_hwrm_cfa_l2_filter_alloc()

◆ bnxt_hwrm_cfa_l2_filter_free()

◆ set_rx_mask()

◆ bnxt_hwrm_set_rx_mask()

◆ bnxt_hwrm_port_phy_qcfg()

◆ bnxt_hwrm_nvm_get_variable_req()

◆ bnxt_get_link_speed()

◆ bnxt_get_vlan()

◆ bnxt_hwrm_backing_store_qcfg()

◆ bnxt_hwrm_backing_store_cfg()

◆ bnxt_hwrm_queue_qportcfg()

◆ bnxt_hwrm_port_mac_cfg()

◆ bnxt_hwrm_port_phy_cfg()

◆ bnxt_query_phy_link()

◆ bnxt_get_phy_link()

◆ bnxt_hwrm_stat_ctx_alloc()

◆ bnxt_hwrm_stat_ctx_free()

◆ bnxt_hwrm_ring_free_grp()

◆ bnxt_hwrm_ring_alloc_grp()

◆ bnxt_hwrm_ring_free()

◆ bnxt_hwrm_ring_alloc()