flexboot_nodnic.h File Reference

#include "mlx_nodnic/include/mlx_nodnic_data_structures.h"
#include "nodnic_prm.h"
#include <ipxe/io.h>
#include <ipxe/infiniband.h>
#include <ipxe/netdevice.h>
#include "mlx_utils/mlx_lib/mlx_nvconfig/mlx_nvconfig.h"

Go to the source code of this file.

Data Structures
struct	flexboot_nodnic_port
	A flexboot nodnic port. More...
struct	flexboot_nodnic_queue_pair
	A flexboot nodnic queue pair. More...
struct	flexboot_nodnic_completion_queue
	A flexboot nodnic cq. More...
struct	flexboot_nodnic
	A flexboot_nodnic device. More...
struct	flexboot_nodnic_port_type
	A flexboot_nodnic port type. More...
struct	cqe_data
union	arm_cq_uar
struct	flexboot_nodnic_callbacks

Macros
#define	NODNIC_IRQ_ENABLED
#define	FLEXBOOT_NODNIC_MAX_PORTS   2
#define	FLEXBOOT_NODNIC_PORT_BASE   1
#define	FLEXBOOT_NODNIC_OPCODE_SEND   0xa
#define	FLEXBOOT_NODNIC_HCA_BAR   PCI_BASE_ADDRESS_0
#define	FLEXBOOT_NODNIC_PAGE_SHIFT   12
#define	FLEXBOOT_NODNIC_PAGE_SIZE   (1 << FLEXBOOT_NODNIC_PAGE_SHIFT)
#define	FLEXBOOT_NODNIC_PAGE_MASK   (FLEXBOOT_NODNIC_PAGE_SIZE - 1)
#define	EN_DEFAULT_ADMIN_MTU   1522

Enumerations
enum	flexboot_nodnic_protocol { FLEXBOOT_NODNIC_PROT_IB_IPV6 = 0 , FLEXBOOT_NODNIC_PROT_ETH , FLEXBOOT_NODNIC_PROT_IB_IPV4 , FLEXBOOT_NODNIC_PROT_FCOE }

Functions
	FILE_LICENCE (GPL2_OR_LATER)
int	flexboot_nodnic_probe (struct pci_device *pci, struct flexboot_nodnic_callbacks *callbacks, void *drv_priv)
void	flexboot_nodnic_remove (struct pci_device *pci)
void	flexboot_nodnic_eth_irq (struct net_device *netdev, int enable)
int	flexboot_nodnic_is_supported (struct pci_device *pci)
void	flexboot_nodnic_copy_mac (uint8_t mac_addr[], uint32_t low_byte, uint16_t high_byte)
int	init_mlx_utils (mlx_utils **utils, struct pci_device *pci)
void	free_mlx_utils (mlx_utils **utils)

Macro Definition Documentation

NODNIC_IRQ_ENABLED

#define NODNIC_IRQ_ENABLED

Definition at line 35 of file flexboot_nodnic.h.

FLEXBOOT_NODNIC_MAX_PORTS

#define FLEXBOOT_NODNIC_MAX_PORTS   2

Definition at line 37 of file flexboot_nodnic.h.

FLEXBOOT_NODNIC_PORT_BASE

#define FLEXBOOT_NODNIC_PORT_BASE   1

Definition at line 38 of file flexboot_nodnic.h.

Referenced by flexboot_nodnic_allocate_infiniband_devices().

FLEXBOOT_NODNIC_OPCODE_SEND

#define FLEXBOOT_NODNIC_OPCODE_SEND   0xa

Definition at line 40 of file flexboot_nodnic.h.

Referenced by shomron_fill_eth_send_wqe().

FLEXBOOT_NODNIC_HCA_BAR

#define FLEXBOOT_NODNIC_HCA_BAR   PCI_BASE_ADDRESS_0

Definition at line 41 of file flexboot_nodnic.h.

Referenced by flexboot_nodnic_alloc_uar().

FLEXBOOT_NODNIC_PAGE_SHIFT

#define FLEXBOOT_NODNIC_PAGE_SHIFT   12

Definition at line 42 of file flexboot_nodnic.h.

FLEXBOOT_NODNIC_PAGE_SIZE

#define FLEXBOOT_NODNIC_PAGE_SIZE   (1 << FLEXBOOT_NODNIC_PAGE_SHIFT)

Definition at line 43 of file flexboot_nodnic.h.

Referenced by flexboot_nodnic_alloc_uar().

FLEXBOOT_NODNIC_PAGE_MASK

#define FLEXBOOT_NODNIC_PAGE_MASK   (FLEXBOOT_NODNIC_PAGE_SIZE - 1)

Definition at line 44 of file flexboot_nodnic.h.

EN_DEFAULT_ADMIN_MTU

#define EN_DEFAULT_ADMIN_MTU   1522

Definition at line 45 of file flexboot_nodnic.h.

Referenced by flexboot_nodnic_probe().

Enumeration Type Documentation

flexboot_nodnic_protocol

enum flexboot_nodnic_protocol

Enumerator
FLEXBOOT_NODNIC_PROT_IB_IPV6
FLEXBOOT_NODNIC_PROT_ETH
FLEXBOOT_NODNIC_PROT_IB_IPV4
FLEXBOOT_NODNIC_PROT_FCOE

Definition at line 48 of file flexboot_nodnic.h.

                              {
        FLEXBOOT_NODNIC_PROT_IB_IPV6 = 0,
        FLEXBOOT_NODNIC_PROT_ETH,
        FLEXBOOT_NODNIC_PROT_IB_IPV4,
        FLEXBOOT_NODNIC_PROT_FCOE
};

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER

)

flexboot_nodnic_probe()

int flexboot_nodnic_probe	(	struct pci_device *	pci,
		struct flexboot_nodnic_callbacks *	callbacks,
		void *	drv_priv )

Definition at line 1483 of file flexboot_nodnic.c.

                                          {
        mlx_status status = MLX_SUCCESS;
        struct flexboot_nodnic *flexboot_nodnic_priv = NULL;
        nodnic_device_priv *device_priv = NULL;
        int i = 0;
 
        if ( ( pci == NULL ) || ( callbacks == NULL ) ) {
                DBGC ( flexboot_nodnic_priv, "%s: Bad Parameter\n", __FUNCTION__ );
                return -EINVAL;
        }
 
        flexboot_nodnic_priv = zalloc( sizeof ( *flexboot_nodnic_priv ) );
        if ( flexboot_nodnic_priv == NULL ) {
                DBGC ( flexboot_nodnic_priv, "%s: Failed to allocate priv data\n", __FUNCTION__ );
                status = MLX_OUT_OF_RESOURCES;
                goto device_err_alloc;
        }
 
        /* Register settings
         * Note that pci->priv will be the device private data */
        flexboot_nodnic_priv->pci = pci;
        flexboot_nodnic_priv->callbacks = callbacks;
        pci_set_drvdata ( pci, flexboot_nodnic_priv );
 
        device_priv = &flexboot_nodnic_priv->device_priv;
        /* init mlx utils */
        status = init_mlx_utils ( & device_priv->utils, pci );
        MLX_FATAL_CHECK_STATUS(status, err_utils_init,
                                "init_mlx_utils failed");
 
        /* init device */
        status = nodnic_device_init( device_priv );
        MLX_FATAL_CHECK_STATUS(status, device_init_err,
                                "nodnic_device_init failed");
 
        status = nodnic_device_get_cap( device_priv );
        MLX_FATAL_CHECK_STATUS(status, get_cap_err,
                                        "nodnic_device_get_cap failed");
 
        if ( mlx_set_admin_mtu ( device_priv->utils, 1, EN_DEFAULT_ADMIN_MTU ) ) {
                MLX_DEBUG_ERROR( device_priv->utils, "Failed to set admin mtu\n" );
        }
 
        status =  flexboot_nodnic_set_port_masking ( flexboot_nodnic_priv );
        MLX_FATAL_CHECK_STATUS(status, err_set_masking,
                                                "flexboot_nodnic_set_port_masking failed");
 
        status = flexboot_nodnic_allocate_infiniband_devices( flexboot_nodnic_priv );
        MLX_FATAL_CHECK_STATUS(status, err_alloc_ibdev,
                                        "flexboot_nodnic_allocate_infiniband_devices failed");
 
        /* port init */
        status = flexboot_nodnic_thin_init_ports( flexboot_nodnic_priv );
        MLX_FATAL_CHECK_STATUS(status, err_thin_init_ports,
                                                "flexboot_nodnic_thin_init_ports failed");
 
        if ( ( status = flexboot_nodnic_alloc_uar ( flexboot_nodnic_priv ) ) ) {
                DBGC(flexboot_nodnic_priv, "%s: flexboot_nodnic_alloc_uar failed"
                                " ( status = %d )\n",__FUNCTION__, status );
        }
 
        /* device reg */
        status = flexboot_nodnic_set_ports_type( flexboot_nodnic_priv );
        MLX_CHECK_STATUS( flexboot_nodnic_priv, status, err_set_ports_types,
                                                "flexboot_nodnic_set_ports_type failed");
 
        status = flexboot_nodnic_ports_register_dev( flexboot_nodnic_priv );
        MLX_FATAL_CHECK_STATUS(status, reg_err,
                                        "flexboot_nodnic_ports_register_dev failed");
 
        for ( i = 0; i < device_priv->device_cap.num_ports; i++ ) {
                if ( ! ( flexboot_nodnic_priv->port_mask & ( i + 1 ) ) )
                        continue;
                flexboot_nodnic_get_factory_mac ( flexboot_nodnic_priv, i );
        }
 
        /* Update ETH operations with IRQ function if supported */
        DBGC ( flexboot_nodnic_priv, "%s: %s IRQ function\n",
                        __FUNCTION__, ( callbacks->irq ? "Valid" : "No" ) );
        flexboot_nodnic_eth_operations.irq = callbacks->irq;
        return 0;
 
        flexboot_nodnic_ports_unregister_dev ( flexboot_nodnic_priv );
reg_err:
err_set_ports_types:
        flexboot_nodnic_dealloc_uar ( flexboot_nodnic_priv );
err_thin_init_ports:
err_alloc_ibdev:
err_set_masking:
get_cap_err:
        nodnic_device_teardown ( device_priv );
device_init_err:
        free_mlx_utils ( & device_priv->utils );
err_utils_init:
        free ( flexboot_nodnic_priv );
device_err_alloc:
        return status;
}

References __unused, flexboot_nodnic::callbacks, DBGC, _nodnic_device_priv::device_cap, flexboot_nodnic::device_priv, EINVAL, EN_DEFAULT_ADMIN_MTU, flexboot_nodnic_alloc_uar(), flexboot_nodnic_allocate_infiniband_devices(), flexboot_nodnic_dealloc_uar(), flexboot_nodnic_eth_operations, flexboot_nodnic_get_factory_mac(), flexboot_nodnic_ports_register_dev(), flexboot_nodnic_ports_unregister_dev(), flexboot_nodnic_set_port_masking(), flexboot_nodnic_set_ports_type(), flexboot_nodnic_thin_init_ports(), free, free_mlx_utils(), init_mlx_utils(), flexboot_nodnic_callbacks::irq, MLX_CHECK_STATUS, MLX_DEBUG_ERROR, MLX_FATAL_CHECK_STATUS, MLX_OUT_OF_RESOURCES, mlx_set_admin_mtu(), MLX_SUCCESS, nodnic_device_get_cap(), nodnic_device_init(), nodnic_device_teardown(), NULL, _nodnic_device_capabilites::num_ports, flexboot_nodnic::pci, pci_set_drvdata(), flexboot_nodnic::port_mask, status, _nodnic_device_priv::utils, and zalloc().

Referenced by golan_probe().

flexboot_nodnic_remove()

void flexboot_nodnic_remove

(

struct pci_device *

pci

)

Definition at line 1584 of file flexboot_nodnic.c.

{
        struct flexboot_nodnic *flexboot_nodnic_priv = pci_get_drvdata ( pci );
        nodnic_device_priv *device_priv = & ( flexboot_nodnic_priv->device_priv );
 
        flexboot_nodnic_dealloc_uar ( flexboot_nodnic_priv );
        flexboot_nodnic_ports_unregister_dev ( flexboot_nodnic_priv );
        nodnic_device_teardown( device_priv );
        free_mlx_utils ( & device_priv->utils );
        free( flexboot_nodnic_priv );
}

References flexboot_nodnic::device_priv, flexboot_nodnic_dealloc_uar(), flexboot_nodnic_ports_unregister_dev(), free, free_mlx_utils(), nodnic_device_teardown(), flexboot_nodnic::pci, pci_get_drvdata(), and _nodnic_device_priv::utils.

Referenced by golan_remove().

flexboot_nodnic_eth_irq()

void flexboot_nodnic_eth_irq	(	struct net_device *	netdev,
		int	enable )

Definition at line 1029 of file flexboot_nodnic.c.

                                                                       {
        struct flexboot_nodnic_port *port = netdev->priv;
 
        if ( enable ) {
                if ( ( port->port_priv.port_state & NODNIC_PORT_OPENED ) &&
                         ! ( port->port_priv.port_state & NODNIC_PORT_DISABLING_DMA ) ) {
                        flexboot_nodnic_arm_cq ( port );
                } else {
                        /* do nothing */
                }
        } else {
                nodnic_device_clear_int( port->port_priv.device );
        }
}

References flexboot_nodnic_arm_cq(), netdev, nodnic_device_clear_int(), NODNIC_PORT_DISABLING_DMA, NODNIC_PORT_OPENED, and port.

flexboot_nodnic_is_supported()

int flexboot_nodnic_is_supported

(

struct pci_device *

pci

)

Definition at line 1306 of file flexboot_nodnic.c.

                                                            {
        mlx_utils utils;
        mlx_pci_gw_buffer buffer;
        mlx_status status;
        int is_supported = 0;
 
        DBG ( "%s: start\n", __FUNCTION__ );
 
        memset ( &utils, 0, sizeof ( utils ) );
 
        status = mlx_utils_init ( &utils, pci );
        MLX_CHECK_STATUS ( pci, status, utils_init_err, "mlx_utils_init failed" );
 
        status = mlx_pci_gw_init ( &utils );
        MLX_CHECK_STATUS ( pci, status, pci_gw_init_err, "mlx_pci_gw_init failed" );
 
        status = mlx_pci_gw_read ( &utils, PCI_GW_SPACE_NODNIC,
                        NODNIC_NIC_INTERFACE_SUPPORTED_OFFSET, &buffer );
 
        if ( status == MLX_SUCCESS ) {
                buffer >>= NODNIC_NIC_INTERFACE_SUPPORTED_BIT;
                is_supported = ( buffer & 0x1 );
        }
 
        mlx_pci_gw_teardown( &utils );
 
pci_gw_init_err:
        mlx_utils_teardown(&utils);
utils_init_err:
        DBG ( "%s: NODNIC is %s supported (status = %d)\n",
                        __FUNCTION__, ( is_supported ? "": "not" ), status );
        return is_supported;
}

References buffer, DBG, memset(), MLX_CHECK_STATUS, mlx_pci_gw_init(), mlx_pci_gw_read(), mlx_pci_gw_teardown(), MLX_SUCCESS, mlx_utils_init(), mlx_utils_teardown(), NODNIC_NIC_INTERFACE_SUPPORTED_BIT, NODNIC_NIC_INTERFACE_SUPPORTED_OFFSET, PCI_GW_SPACE_NODNIC, and status.

Referenced by shomron_nodnic_is_supported().

flexboot_nodnic_copy_mac()

void flexboot_nodnic_copy_mac	(	uint8_t	mac_addr[],
		uint32_t	low_byte,
		uint16_t	high_byte )

Definition at line 1341 of file flexboot_nodnic.c.

                                     {
        union mac_addr {
                struct {
                        uint32_t low_byte;
                        uint16_t high_byte;
                };
                uint8_t mac_addr[ETH_ALEN];
        } mac_addr_aux;
 
        mac_addr_aux.high_byte = high_byte;
        mac_addr_aux.low_byte = low_byte;
 
        mac_addr[0] = mac_addr_aux.mac_addr[5];
        mac_addr[1] = mac_addr_aux.mac_addr[4];
        mac_addr[2] = mac_addr_aux.mac_addr[3];
        mac_addr[3] = mac_addr_aux.mac_addr[2];
        mac_addr[4] = mac_addr_aux.mac_addr[1];
        mac_addr[5] = mac_addr_aux.mac_addr[0];
}

References ETH_ALEN.

init_mlx_utils()

int init_mlx_utils	(	mlx_utils **	utils,
		struct pci_device *	pci )

Definition at line 1404 of file flexboot_nodnic.c.

                                                                 {
        int rc = 0;
 
        *utils = ( mlx_utils * ) zalloc ( sizeof ( mlx_utils ) );
        if ( *utils == NULL ) {
                DBGC ( utils, "%s: Failed to allocate utils\n", __FUNCTION__ );
                rc = -1;
                goto err_utils_alloc;
        }
        if ( mlx_utils_init ( *utils, pci ) ) {
                DBGC ( utils, "%s: mlx_utils_init failed\n", __FUNCTION__ );
                rc = -1;
                goto err_utils_init;
        }
        if ( mlx_pci_gw_init ( *utils ) ){
                DBGC ( utils, "%s: mlx_pci_gw_init failed\n", __FUNCTION__ );
                rc = -1;
                goto err_cmd_init;
        }
 
        return 0;
 
        mlx_pci_gw_teardown ( *utils );
err_cmd_init:
        mlx_utils_teardown ( *utils );
err_utils_init:
        free ( *utils );
err_utils_alloc:
        *utils = NULL;
 
        return rc;
}

References DBGC, free, mlx_pci_gw_init(), mlx_pci_gw_teardown(), mlx_utils_init(), mlx_utils_teardown(), NULL, rc, and zalloc().

Referenced by flexboot_nodnic_probe(), golan_probe_normal(), and golan_set_link_speed().

free_mlx_utils()

void free_mlx_utils

(

mlx_utils **

utils

)

Definition at line 1437 of file flexboot_nodnic.c.

                                          {
 
        mlx_pci_gw_teardown ( *utils );
        mlx_utils_teardown ( *utils );
        free ( *utils );
        *utils = NULL;
}

References free, mlx_pci_gw_teardown(), mlx_utils_teardown(), and NULL.

Referenced by flexboot_nodnic_probe(), flexboot_nodnic_remove(), golan_probe_normal(), golan_remove_normal(), and golan_set_link_speed().