cgem.c File Reference

Cadence Gigabit Ethernet MAC (GEM) network driver. More...

#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/netdevice.h>
#include <ipxe/ethernet.h>
#include <ipxe/if_ether.h>
#include <ipxe/iobuf.h>
#include <ipxe/timer.h>
#include <ipxe/devtree.h>
#include <ipxe/fdt.h>
#include "cgem.h"

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static int	cgem_reset (struct cgem_nic *cgem)
	Reset hardware. More...
static int	cgem_mii_wait (struct cgem_nic *cgem)
	Wait for MII operation to complete. More...
static int	cgem_mii_read (struct mii_interface *mdio, unsigned int phy, unsigned int reg)
	Read from MII register. More...
static int	cgem_mii_write (struct mii_interface *mdio, unsigned int phy, unsigned int reg, unsigned int data)
	Write to MII register. More...
static int	cgem_init_phy (struct cgem_nic *cgem)
	Initialise PHY. More...
static int	cgem_check_link (struct net_device *netdev)
	Check link state. More...
static void	cgem_expired (struct retry_timer *timer, int over __unused)
	Check link state periodically. More...
static int	cgem_create_ring (struct cgem_nic *cgem, struct cgem_ring *ring)
	Create descriptor ring. More...
static void	cgem_destroy_ring (struct cgem_nic *cgem, struct cgem_ring *ring)
	Destroy descriptor ring. More...
static void	cgem_refill_rx (struct cgem_nic *cgem)
	Refill receive descriptor ring. More...
static int	cgem_open (struct net_device *netdev)
	Open network device. More...
static void	cgem_close (struct net_device *netdev)
	Close network device. More...
static int	cgem_transmit (struct net_device *netdev, struct io_buffer *iobuf)
	Transmit packet. More...
static void	cgem_poll_tx (struct net_device *netdev)
	Poll for completed packets. More...
static void	cgem_poll_rx (struct net_device *netdev)
	Poll for received packets. More...
static void	cgem_poll (struct net_device *netdev)
	Poll for completed and received packets. More...
static int	cgem_probe (struct dt_device *dt, unsigned int offset)
	Probe devicetree device. More...
static void	cgem_remove (struct dt_device *dt)
	Remove devicetree device. More...

Variables
static struct mii_operations	cgem_mii_operations
	MII operations. More...
static struct net_device_operations	cgem_operations
	Cadence GEM network device operations. More...
static const char *	cgem_ids []
	Cadence GEM compatible model identifiers. More...
struct dt_driver cgem_driver	__dt_driver
	Cadence GEM devicetree driver. More...

Detailed Description

Cadence Gigabit Ethernet MAC (GEM) network driver.

Based primarily on the Zynq 7000 SoC Technical Reference Manual, available at the time of writing from:

https://docs.amd.com/r/en-US/ug585-zynq-7000-SoC-TRM

Definition in file cgem.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

cgem_reset()

static int cgem_reset ( struct cgem_nic *  cgem )

static

Reset hardware.

Parameters

cgem	Cadence GEM device

Return values

rc	Return status code

Definition at line 64 of file cgem.c.

                                                {

        /* There is no software-driven reset capability in the
         * hardware.  Instead we have to write the expected reset
         * values to the various registers.
         */

        /* Disable all interrupts */
        writel ( CGEM_IDR_ALL, ( cgem->regs + CGEM_IDR ) );

        /* Clear network control register */
        writel ( 0, ( cgem->regs + CGEM_NWCTRL ) );

        /* Clear statistics registers now that TX and RX are stopped */
        writel ( CGEM_NWCTRL_STATCLR, ( cgem->regs + CGEM_NWCTRL ) );

        /* Clear TX queue base address */
        writel ( 0, ( cgem->regs + CGEM_TXQBASE ) );

        /* Clear RX queue base address */
        writel ( 0, ( cgem->regs + CGEM_RXQBASE ) );

        /* Configure DMA */
        writel ( ( CGEM_DMACR_RXBUF ( CGEM_RX_LEN ) | CGEM_DMACR_TXSIZE_MAX |
                   CGEM_DMACR_RXSIZE_MAX | CGEM_DMACR_BLENGTH_MAX ),
                 ( cgem->regs + CGEM_DMACR ) );

        /* Enable MII interface */
        writel ( CGEM_NWCTRL_MDEN, ( cgem->regs + CGEM_NWCTRL ) );

        return 0;
}

References CGEM_DMACR, CGEM_DMACR_BLENGTH_MAX, CGEM_DMACR_RXBUF, CGEM_DMACR_RXSIZE_MAX, CGEM_DMACR_TXSIZE_MAX, CGEM_IDR, CGEM_IDR_ALL, CGEM_NWCTRL, CGEM_NWCTRL_MDEN, CGEM_NWCTRL_STATCLR, CGEM_RX_LEN, CGEM_RXQBASE, CGEM_TXQBASE, cgem_nic::regs, and writel().

Referenced by cgem_close(), cgem_probe(), and cgem_remove().

cgem_mii_wait()

static int cgem_mii_wait ( struct cgem_nic *  cgem )

static

Wait for MII operation to complete.

Parameters

cgem	Cadence GEM device

Return values

rc	Return status code

Definition at line 110 of file cgem.c.

                                                   {
        uint32_t nwsr;
        unsigned int i;

        /* Wait for MII interface to become idle */
        for ( i = 0 ; i < CGEM_MII_MAX_WAIT_US ; i++ ) {

                /* Check if MII interface is idle */
                nwsr = readl ( cgem->regs + CGEM_NWSR );
                if ( nwsr & CGEM_NWSR_MII_IDLE )
                        return 0;

                /* Delay */
                udelay ( 1 );
        }

        DBGC ( cgem, "CGEM %s timed out waiting for MII\n", cgem->name );
        return -ETIMEDOUT;
}

References CGEM_MII_MAX_WAIT_US, CGEM_NWSR, CGEM_NWSR_MII_IDLE, DBGC, ETIMEDOUT, cgem_nic::name, readl(), cgem_nic::regs, and udelay().

Referenced by cgem_mii_read(), and cgem_mii_write().

cgem_mii_read()

static int cgem_mii_read ( struct mii_interface *  mdio, unsigned int  phy, unsigned int  reg  )

static

Read from MII register.

Parameters

mdio	MII interface
phy	PHY address
reg	Register address

Return values

data	Data read, or negative error

Definition at line 138 of file cgem.c.

                                              {
        struct cgem_nic *cgem = container_of ( mdio, struct cgem_nic, mdio );
        unsigned int data;
        int rc;

        /* Initiate read */
        writel ( ( CGEM_PHYMNTNC_CLAUSE22 | CGEM_PHYMNTNC_OP_READ |
                   CGEM_PHYMNTNC_ADDR ( phy ) | CGEM_PHYMNTNC_REG ( reg ) |
                   CGEM_PHYMNTNC_FIXED ),
                 ( cgem->regs + CGEM_PHYMNTNC ) );

        /* Wait for read to complete */
        if ( ( rc = cgem_mii_wait ( cgem ) ) != 0 )
                return rc;

        /* Read data */
        data = ( readl ( cgem->regs + CGEM_PHYMNTNC ) &
                 CGEM_PHYMNTNC_DATA_MASK );

        return data;
}

References cgem_mii_wait(), CGEM_PHYMNTNC, CGEM_PHYMNTNC_ADDR, CGEM_PHYMNTNC_CLAUSE22, CGEM_PHYMNTNC_DATA_MASK, CGEM_PHYMNTNC_FIXED, CGEM_PHYMNTNC_OP_READ, CGEM_PHYMNTNC_REG, container_of, data, cgem_nic::mdio, rc, readl(), reg, cgem_nic::regs, and writel().

cgem_mii_write()

static int cgem_mii_write ( struct mii_interface *  mdio, unsigned int  phy, unsigned int  reg, unsigned int  data  )

static

Write to MII register.

Parameters

mdio	MII interface
phy	PHY address
reg	Register address
data	Data to write

Return values

rc	Return status code

Definition at line 170 of file cgem.c.

                                                                  {
        struct cgem_nic *cgem = container_of ( mdio, struct cgem_nic, mdio );
        int rc;

        /* Initiate write */
        writel ( ( CGEM_PHYMNTNC_CLAUSE22 | CGEM_PHYMNTNC_OP_READ |
                   CGEM_PHYMNTNC_ADDR ( phy ) | CGEM_PHYMNTNC_REG ( reg ) |
                   CGEM_PHYMNTNC_FIXED | data ),
                 ( cgem->regs + CGEM_PHYMNTNC ) );

        /* Wait for write to complete */
        if ( ( rc = cgem_mii_wait ( cgem ) ) != 0 )
                return rc;

        return 0;
}

References cgem_mii_wait(), CGEM_PHYMNTNC, CGEM_PHYMNTNC_ADDR, CGEM_PHYMNTNC_CLAUSE22, CGEM_PHYMNTNC_FIXED, CGEM_PHYMNTNC_OP_READ, CGEM_PHYMNTNC_REG, container_of, data, cgem_nic::mdio, rc, reg, cgem_nic::regs, and writel().

cgem_init_phy()

static int cgem_init_phy ( struct cgem_nic *  cgem )

static

Initialise PHY.

Parameters

cgem	Cadence GEM device

Return values

rc	Return status code

Definition at line 207 of file cgem.c.

                                                   {
        int rc;

        /* Find PHY address */
        if ( ( rc = mii_find ( &cgem->mii ) ) != 0 ) {
                DBGC ( cgem, "CGEM %s could not find PHY address: %s\n",
                       cgem->name, strerror ( rc ) );
                return rc;
        }

        /* Reset PHY */
        if ( ( rc = mii_reset ( &cgem->mii ) ) != 0 ) {
                DBGC ( cgem, "CGEM %s could not reset PHY: %s\n",
                       cgem->name, strerror ( rc ) );
                return rc;
        }

        return 0;
}

References DBGC, cgem_nic::mii, mii_find(), mii_reset(), cgem_nic::name, rc, and strerror().

Referenced by cgem_probe().

cgem_check_link()

static int cgem_check_link ( struct net_device *  netdev )

static

Check link state.

Parameters

netdev

Network device

Definition at line 232 of file cgem.c.

                                                         {
        struct cgem_nic *cgem = netdev->priv;
        int rc;

        /* Check link state */
        if ( ( rc = mii_check_link ( &cgem->mii, netdev ) ) != 0 ) {
                DBGC ( cgem, "CGEM %s could not check link: %s\n",
                       cgem->name, strerror ( rc ) );
                return rc;
        }

        return 0;
}

References DBGC, cgem_nic::mii, mii_check_link(), cgem_nic::name, netdev, net_device::priv, rc, and strerror().

Referenced by cgem_expired(), cgem_open(), and cgem_probe().

cgem_expired()

static void cgem_expired ( struct retry_timer *  timer, int over  __unused  )

static

Check link state periodically.

Parameters

retry	Link state check timer
over	Failure indicator

Definition at line 252 of file cgem.c.

                                                                          {
        struct cgem_nic *cgem = container_of ( timer, struct cgem_nic, timer );
        struct net_device *netdev = cgem->netdev;

        /* Restart timer */
        start_timer_fixed ( timer, CGEM_LINK_INTERVAL );

        /* Check link state */
        cgem_check_link ( netdev );
}

References cgem_check_link(), CGEM_LINK_INTERVAL, container_of, netdev, cgem_nic::netdev, and start_timer_fixed().

Referenced by cgem_probe().

cgem_create_ring()

static int cgem_create_ring ( struct cgem_nic *  cgem, struct cgem_ring *  ring  )

static

Create descriptor ring.

Parameters

cgem	Cadence GEM device
ring	Descriptor ring

Return values

rc	Return status code

Definition at line 277 of file cgem.c.

                                                                              {
        struct cgem_descriptor *desc;
        unsigned int i;

        /* Allocate descriptor ring (on its own size) */
        ring->desc = dma_alloc ( cgem->dma, &ring->map, ring->len, ring->len );
        if ( ! ring->desc )
                return -ENOMEM;

        /* Initialise descriptor ring */
        for ( i = 0 ; i < ring->count ; i++ ) {
                desc = &ring->desc[i];
                desc->addr = cpu_to_le32 ( CGEM_RX_ADDR_OWNED );
                desc->flags = cpu_to_le32 ( CGEM_TX_FL_OWNED );
        }
        desc = &ring->desc[ ring->count - 1 ];
        desc->addr |= cpu_to_le32 ( CGEM_RX_ADDR_WRAP );
        desc->flags |= cpu_to_le32 ( CGEM_TX_FL_WRAP );

        /* Program ring address */
        writel ( dma ( &ring->map, ring->desc ),
                 ( cgem->regs + ring->qbase ) );

        DBGC ( cgem, "CGEM %s ring %02x is at [%08lx,%08lx)\n",
               cgem->name, ring->qbase, virt_to_phys ( ring->desc ),
               ( virt_to_phys ( ring->desc ) + ring->len ) );
        return 0;
}

References CGEM_RX_ADDR_OWNED, CGEM_RX_ADDR_WRAP, CGEM_TX_FL_OWNED, CGEM_TX_FL_WRAP, cgem_ring::count, cpu_to_le32, DBGC, desc, cgem_ring::desc, cgem_nic::dma, dma(), dma_alloc(), ENOMEM, cgem_ring::len, cgem_ring::map, cgem_nic::name, cgem_ring::qbase, cgem_nic::regs, and writel().

Referenced by cgem_open().

cgem_destroy_ring()

static void cgem_destroy_ring ( struct cgem_nic *  cgem, struct cgem_ring *  ring  )

static

Destroy descriptor ring.

Parameters

cgem	Cadence GEM device
ring	Descriptor ring

Definition at line 312 of file cgem.c.

                                                         {

        /* Clear ring address */
        writel ( 0, ( cgem->regs + ring->qbase ) );

        /* Free descriptor ring */
        dma_free ( &ring->map, ring->desc, ring->len );
        ring->desc = NULL;
        ring->prod = 0;
        ring->cons = 0;
}

References cgem_ring::cons, cgem_ring::desc, dma_free(), cgem_ring::len, cgem_ring::map, NULL, cgem_ring::prod, cgem_ring::qbase, cgem_nic::regs, and writel().

Referenced by cgem_close(), and cgem_open().

cgem_refill_rx()

static void cgem_refill_rx ( struct cgem_nic *  cgem )

static

Refill receive descriptor ring.

Parameters

cgem	Cadence GEM device

Definition at line 330 of file cgem.c.

                                                     {
        struct cgem_descriptor *rx;
        struct io_buffer *iobuf;
        unsigned int rx_idx;
        uint32_t addr;

        /* Refill ring */
        while ( ( cgem->rx.prod - cgem->rx.cons ) != CGEM_NUM_RX_DESC ) {

                /* Allocate I/O buffer */
                iobuf = alloc_rx_iob ( CGEM_RX_LEN, cgem->dma );
                if ( ! iobuf ) {
                        /* Wait for next refill */
                        break;
                }

                /* Get next receive descriptor */
                rx_idx = ( cgem->rx.prod++ % CGEM_NUM_RX_DESC );
                rx = &cgem->rx.desc[rx_idx];

                /* Populate receive descriptor */
                rx->flags = 0;
                addr = 0;
                if ( ( cgem->rx.prod % CGEM_NUM_RX_DESC ) == 0 )
                        addr |= CGEM_RX_ADDR_WRAP;
                rx->addr = cpu_to_le32 ( addr | iob_dma ( iobuf ) );

                /* Record I/O buffer */
                assert ( cgem->rx_iobuf[rx_idx] == NULL );
                cgem->rx_iobuf[rx_idx] = iobuf;

                DBGC2 ( cgem, "CGEM %s RX %d is [%08lx,%08lx)\n",
                        cgem->name, rx_idx, virt_to_phys ( iobuf->data ),
                        ( virt_to_phys ( iobuf->data ) + CGEM_RX_LEN ) );
        }
}

References addr, alloc_rx_iob(), assert(), CGEM_NUM_RX_DESC, CGEM_RX_ADDR_WRAP, CGEM_RX_LEN, cgem_ring::cons, cpu_to_le32, io_buffer::data, DBGC2, cgem_ring::desc, cgem_nic::dma, iob_dma(), cgem_nic::name, NULL, cgem_ring::prod, cgem_nic::rx, rx, and cgem_nic::rx_iobuf.

Referenced by cgem_open(), and cgem_poll().

cgem_open()

static int cgem_open ( struct net_device *  netdev )

static

Open network device.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 373 of file cgem.c.

                                                   {
        struct cgem_nic *cgem = netdev->priv;
        union cgem_mac mac;
        int rc;

        /* Create transmit descriptor ring */
        if ( ( rc = cgem_create_ring ( cgem, &cgem->tx ) ) != 0 )
                goto err_create_tx;

        /* Create receive descriptor ring */
        if ( ( rc = cgem_create_ring ( cgem, &cgem->rx ) ) != 0 )
                goto err_create_rx;

        /* Set MAC address */
        memcpy ( mac.raw, netdev->ll_addr, ETH_ALEN );
        writel ( mac.reg.low, ( cgem->regs + CGEM_LADDRL ) );
        writel ( mac.reg.high, ( cgem->regs + CGEM_LADDRH ) );

        /* Enable transmit and receive */
        writel ( CGEM_NWCTRL_NORMAL, ( cgem->regs + CGEM_NWCTRL ) );

        /* Refill receive descriptor ring */
        cgem_refill_rx ( cgem );

        /* Update link state */
        cgem_check_link ( netdev );

        /* Start link state timer */
        start_timer_fixed ( &cgem->timer, CGEM_LINK_INTERVAL );

        return 0;

        cgem_destroy_ring ( cgem, &cgem->rx );
 err_create_rx:
        cgem_destroy_ring ( cgem, &cgem->tx );
 err_create_tx:
        return rc;
}

References cgem_check_link(), cgem_create_ring(), cgem_destroy_ring(), CGEM_LADDRH, CGEM_LADDRL, CGEM_LINK_INTERVAL, CGEM_NWCTRL, CGEM_NWCTRL_NORMAL, cgem_refill_rx(), ETH_ALEN, net_device::ll_addr, mac, memcpy(), netdev, net_device::priv, rc, cgem_nic::regs, cgem_nic::rx, start_timer_fixed(), cgem_nic::timer, cgem_nic::tx, and writel().

cgem_close()

static void cgem_close ( struct net_device *  netdev )

static

Close network device.

Parameters

netdev

Network device

Definition at line 417 of file cgem.c.

                                                     {
        struct cgem_nic *cgem = netdev->priv;
        unsigned int i;

        /* Stop link state timer */
        stop_timer ( &cgem->timer );

        /* Reset NIC */
        cgem_reset ( cgem );

        /* Discard unused receive buffers */
        for ( i = 0 ; i < CGEM_NUM_RX_DESC ; i++ ) {
                if ( cgem->rx_iobuf[i] )
                        free_rx_iob ( cgem->rx_iobuf[i] );
                cgem->rx_iobuf[i] = NULL;
        }

        /* Destroy receive descriptor ring */
        cgem_destroy_ring ( cgem, &cgem->rx );

        /* Destroy transmit descriptor ring */
        cgem_destroy_ring ( cgem, &cgem->tx );
}

References cgem_destroy_ring(), CGEM_NUM_RX_DESC, cgem_reset(), free_rx_iob(), netdev, NULL, net_device::priv, cgem_nic::rx, cgem_nic::rx_iobuf, stop_timer(), cgem_nic::timer, and cgem_nic::tx.

cgem_transmit()

static int cgem_transmit ( struct net_device *  netdev, struct io_buffer *  iobuf  )

static

Transmit packet.

Parameters

netdev	Network device
iobuf	I/O buffer

Return values

rc	Return status code

Definition at line 448 of file cgem.c.

                                                     {
        struct cgem_nic *cgem = netdev->priv;
        struct cgem_descriptor *tx;
        unsigned int tx_idx;
        uint32_t flags;
        int rc;

        /* Get next transmit descriptor */
        if ( ( cgem->tx.prod - cgem->tx.cons ) >= CGEM_NUM_TX_DESC ) {
                DBGC ( cgem, "CGEM %s out of transmit descriptors\n",
                       cgem->name );
                return -ENOBUFS;
        }
        tx_idx = ( cgem->tx.prod % CGEM_NUM_TX_DESC );
        tx = &cgem->tx.desc[tx_idx];

        /* Pad to minimum length */
        iob_pad ( iobuf, ETH_ZLEN );

        /* Map I/O buffer */
        if ( ( rc = iob_map_tx ( iobuf, cgem->dma ) ) != 0 )
                return rc;

        /* Update producer index */
        cgem->tx.prod++;

        /* Populate transmit descriptor */
        flags = CGEM_TX_FL_LAST;
        if ( ( cgem->tx.prod % CGEM_NUM_TX_DESC ) == 0 )
                flags |= CGEM_TX_FL_WRAP;
        tx->addr = cpu_to_le32 ( iob_dma ( iobuf ) );
        wmb();
        tx->flags = cpu_to_le32 ( flags | iob_len ( iobuf ) );
        wmb();

        /* Initiate transmission */
        writel ( ( CGEM_NWCTRL_NORMAL | CGEM_NWCTRL_STARTTX ),
                 ( cgem->regs + CGEM_NWCTRL ) );

        DBGC2 ( cgem, "CGEM %s TX %d is [%08lx,%08lx)\n",
                cgem->name, tx_idx, virt_to_phys ( iobuf->data ),
                ( virt_to_phys ( iobuf->data ) + iob_len ( iobuf ) ) );
        return 0;
}

References CGEM_NUM_TX_DESC, CGEM_NWCTRL, CGEM_NWCTRL_NORMAL, CGEM_NWCTRL_STARTTX, CGEM_TX_FL_LAST, CGEM_TX_FL_WRAP, cgem_ring::cons, cpu_to_le32, io_buffer::data, DBGC, DBGC2, cgem_ring::desc, cgem_nic::dma, ENOBUFS, ETH_ZLEN, flags, iob_dma(), iob_len(), iob_map_tx(), iob_pad(), cgem_nic::name, netdev, net_device::priv, cgem_ring::prod, rc, cgem_nic::regs, cgem_nic::tx, tx, wmb(), and writel().

cgem_poll_tx()

static void cgem_poll_tx ( struct net_device *  netdev )

static

Poll for completed packets.

@V netdev Network device

Definition at line 499 of file cgem.c.

                                                       {
        struct cgem_nic *cgem = netdev->priv;
        struct cgem_descriptor *tx;
        unsigned int tx_idx;

        /* Check for completed packets */
        while ( cgem->tx.cons != cgem->tx.prod ) {

                /* Get next transmit descriptor */
                tx_idx = ( cgem->tx.cons % CGEM_NUM_TX_DESC );
                tx = &cgem->tx.desc[tx_idx];

                /* Stop if descriptor is still owned by hardware */
                if ( ! ( tx->flags & cpu_to_le32 ( CGEM_TX_FL_OWNED ) ) )
                        return;
                DBGC2 ( cgem, "CGEM %s TX %d complete\n",
                        cgem->name, tx_idx );

                /* Complete transmit descriptor */
                netdev_tx_complete_next ( netdev );
                cgem->tx.cons++;
        }
}

References CGEM_NUM_TX_DESC, CGEM_TX_FL_OWNED, cgem_ring::cons, cpu_to_le32, DBGC2, cgem_ring::desc, cgem_nic::name, netdev, netdev_tx_complete_next(), net_device::priv, cgem_ring::prod, cgem_nic::tx, and tx.

Referenced by cgem_poll().

cgem_poll_rx()

static void cgem_poll_rx ( struct net_device *  netdev )

static

Poll for received packets.

Parameters

netdev

Network device

Definition at line 528 of file cgem.c.

                                                       {
        struct cgem_nic *cgem = netdev->priv;
        struct cgem_descriptor *rx;
        struct io_buffer *iobuf;
        unsigned int rx_idx;
        uint32_t flags;
        size_t len;

        /* Check for received packets */
        while ( cgem->rx.cons != cgem->rx.prod ) {

                /* Get next receive descriptor */
                rx_idx = ( cgem->rx.cons % CGEM_NUM_RX_DESC );
                rx = &cgem->rx.desc[rx_idx];

                /* Stop if descriptor is still in use */
                if ( ! ( rx->addr & cpu_to_le32 ( CGEM_RX_ADDR_OWNED ) ) )
                        return;

                /* Populate I/O buffer */
                iobuf = cgem->rx_iobuf[rx_idx];
                cgem->rx_iobuf[rx_idx] = NULL;
                flags = le32_to_cpu ( rx->flags );
                len = CGEM_RX_FL_LEN ( flags );
                iob_put ( iobuf, len );
                DBGC2 ( cgem, "CGEM %s RX %d complete (length %zd)\n",
                        cgem->name, rx_idx, len );

                /* Hand off to network stack */
                netdev_rx ( netdev, iobuf );
                cgem->rx.cons++;
        }
}

References CGEM_NUM_RX_DESC, CGEM_RX_ADDR_OWNED, CGEM_RX_FL_LEN, cgem_ring::cons, cpu_to_le32, DBGC2, cgem_ring::desc, flags, iob_put, le32_to_cpu, len, cgem_nic::name, netdev, netdev_rx(), NULL, net_device::priv, cgem_ring::prod, cgem_nic::rx, rx, and cgem_nic::rx_iobuf.

Referenced by cgem_poll().

cgem_poll()

static void cgem_poll ( struct net_device *  netdev )

static

Poll for completed and received packets.

Parameters

netdev

Network device

Definition at line 567 of file cgem.c.

                                                    {
        struct cgem_nic *cgem = netdev->priv;

        /* Poll for TX competions */
        cgem_poll_tx ( netdev );

        /* Poll for RX completions */
        cgem_poll_rx ( netdev );

        /* Refill RX ring */
        cgem_refill_rx ( cgem );
}

References cgem_poll_rx(), cgem_poll_tx(), cgem_refill_rx(), netdev, and net_device::priv.

cgem_probe()

static int cgem_probe ( struct dt_device *  dt, unsigned int  offset  )

static

Probe devicetree device.

Parameters

dt	Devicetree device
offset	Starting node offset

Return values

rc	Return status code

Definition at line 602 of file cgem.c.

                                                                    {
        struct net_device *netdev;
        struct cgem_nic *cgem;
        union cgem_mac mac;
        int rc;

        /* Allocate and initialise net device */
        netdev = alloc_etherdev ( sizeof ( *cgem ) );
        if ( ! netdev ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        netdev_init ( netdev, &cgem_operations );
        cgem = netdev->priv;
        dt_set_drvdata ( dt, netdev );
        netdev->dev = &dt->dev;
        memset ( cgem, 0, sizeof ( *cgem ) );
        cgem->dma = &dt->dma;
        cgem->netdev = netdev;
        cgem->name = netdev->dev->name;
        mdio_init ( &cgem->mdio, &cgem_mii_operations );
        mii_init ( &cgem->mii, &cgem->mdio, 0 );
        timer_init ( &cgem->timer, cgem_expired, &netdev->refcnt );
        cgem_init_ring ( &cgem->tx, CGEM_NUM_TX_DESC, CGEM_TXQBASE );
        cgem_init_ring ( &cgem->rx, CGEM_NUM_RX_DESC, CGEM_RXQBASE );

        /* Map registers */
        cgem->regs = dt_ioremap ( dt, offset, CGEM_REG_IDX, CGEM_REG_LEN );
        if ( ! cgem->regs ) {
                rc = -ENODEV;
                goto err_ioremap;
        }

        /* Reset the NIC */
        if ( ( rc = cgem_reset ( cgem ) ) != 0 )
                goto err_reset;

        /* Initialise the PHY */
        if ( ( rc = cgem_init_phy ( cgem ) ) != 0 )
                goto err_init_phy;

        /* Fetch devicetree MAC address */
        if ( ( rc = fdt_mac ( &sysfdt, offset, netdev ) ) != 0 ) {
                DBGC ( cgem, "CGEM %s could not fetch MAC: %s\n",
                       cgem->name, strerror ( rc ) );
                goto err_mac;
        }

        /* Fetch current MAC address, if set */
        mac.reg.low = readl ( cgem->regs + CGEM_LADDRL );
        mac.reg.high = readl ( cgem->regs + CGEM_LADDRH );
        memcpy ( netdev->ll_addr, mac.raw, ETH_ALEN );

        /* Register network device */
        if ( ( rc = register_netdev ( netdev ) ) != 0 )
                goto err_register_netdev;

        /* Set initial link state */
        cgem_check_link ( netdev );

        return 0;

        unregister_netdev ( netdev );
 err_register_netdev:
 err_mac:
 err_init_phy:
        cgem_reset ( cgem );
 err_reset:
        iounmap ( cgem->regs );
 err_ioremap:
        netdev_nullify ( netdev );
        netdev_put ( netdev );
 err_alloc:
        return rc;
}

References alloc_etherdev(), cgem_check_link(), cgem_expired(), cgem_init_phy(), cgem_init_ring(), CGEM_LADDRH, CGEM_LADDRL, cgem_mii_operations, CGEM_NUM_RX_DESC, CGEM_NUM_TX_DESC, cgem_operations, CGEM_REG_IDX, CGEM_REG_LEN, cgem_reset(), CGEM_RXQBASE, CGEM_TXQBASE, DBGC, dt_device::dev, net_device::dev, dt_device::dma, cgem_nic::dma, dt_ioremap(), dt_set_drvdata(), ENODEV, ENOMEM, ETH_ALEN, fdt_mac(), iounmap(), net_device::ll_addr, mac, cgem_nic::mdio, mdio_init(), memcpy(), memset(), cgem_nic::mii, mii_init(), device::name, cgem_nic::name, netdev, cgem_nic::netdev, netdev_init(), netdev_nullify(), netdev_put(), offset, net_device::priv, rc, readl(), net_device::refcnt, register_netdev(), cgem_nic::regs, cgem_nic::rx, strerror(), sysfdt, cgem_nic::timer, cgem_nic::tx, and unregister_netdev().

cgem_remove()

static void cgem_remove ( struct dt_device *  dt )

static

Remove devicetree device.

Parameters

dt	Devicetree device

Definition at line 683 of file cgem.c.

                                                 {
        struct net_device *netdev = dt_get_drvdata ( dt );
        struct cgem_nic *cgem = netdev->priv;

        /* Unregister network device */
        unregister_netdev ( netdev );

        /* Reset card */
        cgem_reset ( cgem );

        /* Free network device */
        iounmap ( cgem->regs );
        netdev_nullify ( netdev );
        netdev_put ( netdev );
}

References cgem_reset(), dt_get_drvdata(), iounmap(), netdev, netdev_nullify(), netdev_put(), net_device::priv, cgem_nic::regs, and unregister_netdev().

Variable Documentation

cgem_mii_operations

struct mii_operations cgem_mii_operations

static

Initial value:

= {
        .read = cgem_mii_read,
        .write = cgem_mii_write,
}

MII operations.

Definition at line 189 of file cgem.c.

Referenced by cgem_probe().

cgem_operations

struct net_device_operations cgem_operations

static

Initial value:

= {
        .open           = cgem_open,
        .close          = cgem_close,
        .transmit       = cgem_transmit,
        .poll           = cgem_poll,
}

Cadence GEM network device operations.

Definition at line 581 of file cgem.c.

Referenced by cgem_probe().

cgem_ids

const char* cgem_ids[]

static

Initial value:

= {
        "sifive,fu540-c000-gem",
}

Cadence GEM compatible model identifiers.

Definition at line 700 of file cgem.c.

__dt_driver

struct dt_driver cgem_driver __dt_driver

Initial value:

= {
        .name = "cgem",
        .ids = cgem_ids,
        .id_count = ( sizeof ( cgem_ids ) / sizeof ( cgem_ids[0] ) ),
        .probe = cgem_probe,
        .remove = cgem_remove,
}

Cadence GEM devicetree driver.

Definition at line 705 of file cgem.c.