rdc.c File Reference

RDC R6040 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/malloc.h>
#include <ipxe/pci.h>
#include "rdc.h"

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static int	rdc_reset (struct rdc_nic *rdc)
	Reset hardware.
static int	rdc_mii_read (struct mii_interface *mdio, unsigned int phy, unsigned int reg)
	Read from MII register.
static int	rdc_mii_write (struct mii_interface *mdio, unsigned int phy, unsigned int reg, unsigned int data)
	Write to MII register.
static int	rdc_init_phy (struct rdc_nic *rdc)
	Initialise PHY.
static int	rdc_check_link (struct net_device *netdev)
	Check link state.
static int	rdc_create_ring (struct rdc_nic *rdc, struct rdc_ring *ring)
	Create descriptor ring.
static void	rdc_destroy_ring (struct rdc_nic *rdc, struct rdc_ring *ring)
	Destroy descriptor ring.
static void	rdc_refill_rx (struct rdc_nic *rdc)
	Refill receive descriptor ring.
static int	rdc_open (struct net_device *netdev)
	Open network device.
static void	rdc_close (struct net_device *netdev)
	Close network device.
static int	rdc_transmit (struct net_device *netdev, struct io_buffer *iobuf)
	Transmit packet.
static void	rdc_poll_tx (struct net_device *netdev)
	Poll for completed packets.
static void	rdc_poll_rx (struct net_device *netdev)
	Poll for received packets.
static void	rdc_poll (struct net_device *netdev)
	Poll for completed and received packets.
static void	rdc_irq (struct net_device *netdev, int enable)
	Enable or disable interrupts.
static int	rdc_probe (struct pci_device *pci)
	Probe PCI device.
static void	rdc_remove (struct pci_device *pci)
	Remove PCI device.

Variables
static struct mii_operations	rdc_mii_operations
	RDC MII operations.
static struct net_device_operations	rdc_operations
	RDC network device operations.
static struct pci_device_id	rdc_nics []
	RDC PCI device IDs.
struct pci_driver rdc_driver	__pci_driver
	RDC PCI driver.

Detailed Description

RDC R6040 network driver.

Definition in file rdc.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

rdc_reset()

int rdc_reset ( struct rdc_nic * rdc )

static

Reset hardware.

Parameters

rdc	RDC device

Return values

rc	Return status code

Definition at line 58 of file rdc.c.

                                             {
        unsigned int i;
 
        /* Reset NIC */
        writew ( RDC_MCR1_RST, rdc->regs + RDC_MCR1 );
 
        /* Wait for reset to complete */
        for ( i = 0 ; i < RDC_RESET_MAX_WAIT_MS ; i++ ) {
 
                /* Check for reset completion */
                if ( readw ( rdc->regs + RDC_MCR1 ) & RDC_MCR1_RST ) {
                        mdelay ( 1 );
                        continue;
                }
 
                /* Reset internal state machine */
                writew ( RDC_MACSM_RST, rdc->regs + RDC_MACSM );
                writew ( 0, rdc->regs + RDC_MACSM );
                mdelay ( RDC_MACSM_RESET_DELAY_MS );
 
                return 0;
        }
 
        DBGC ( rdc, "RDC %p timed out waiting for reset\n", rdc );
        return -ETIMEDOUT;
}

References DBGC, ETIMEDOUT, mdelay(), RDC_MACSM, RDC_MACSM_RESET_DELAY_MS, RDC_MACSM_RST, RDC_MCR1, RDC_MCR1_RST, RDC_RESET_MAX_WAIT_MS, readw, rdc_nic::regs, and writew.

Referenced by rdc_probe(), and rdc_remove().

rdc_mii_read()

int rdc_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

value

Data read, or negative error

Definition at line 100 of file rdc.c.

                                             {
        struct rdc_nic *rdc = container_of ( mdio, struct rdc_nic, mdio );
        uint16_t mmdio;
        unsigned int i;
 
        /* Initiate read */
        mmdio = ( RDC_MMDIO_MIIRD | RDC_MMDIO_PHYAD ( phy ) |
                  RDC_MMDIO_REGAD ( reg ) );
        writew ( mmdio, rdc->regs + RDC_MMDIO );
 
        /* Wait for read to complete */
        for ( i = 0 ; i < RDC_MII_MAX_WAIT_US ; i++ ) {
 
                /* Check for read completion */
                if ( readw ( rdc->regs + RDC_MMDIO ) & RDC_MMDIO_MIIRD ) {
                        udelay ( 1 );
                        continue;
                }
 
                /* Return register value */
                return ( readw ( rdc->regs + RDC_MMRD ) );
        }
 
        DBGC ( rdc, "RDC %p timed out waiting for MII read\n", rdc );
        return -ETIMEDOUT;
}

References container_of, DBGC, ETIMEDOUT, rdc_nic::mdio, RDC_MII_MAX_WAIT_US, RDC_MMDIO, RDC_MMDIO_MIIRD, RDC_MMDIO_PHYAD, RDC_MMDIO_REGAD, RDC_MMRD, readw, reg, rdc_nic::regs, udelay(), and writew.

rdc_mii_write()

int rdc_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 137 of file rdc.c.

                                                                 {
        struct rdc_nic *rdc = container_of ( mdio, struct rdc_nic, mdio );
        uint16_t mmdio;
        unsigned int i;
 
        /* Initiate write */
        mmdio = ( RDC_MMDIO_MIIWR | RDC_MMDIO_PHYAD ( phy ) |
                  RDC_MMDIO_REGAD ( reg ) );
        writew ( data, rdc->regs + RDC_MMWD );
        writew ( mmdio, rdc->regs + RDC_MMDIO );
 
        /* Wait for write to complete */
        for ( i = 0 ; i < RDC_MII_MAX_WAIT_US ; i++ ) {
 
                /* Check for write completion */
                if ( readw ( rdc->regs + RDC_MMDIO ) & RDC_MMDIO_MIIWR ) {
                        udelay ( 1 );
                        continue;
                }
 
                return 0;
        }
 
        DBGC ( rdc, "RDC %p timed out waiting for MII write\n", rdc );
        return -ETIMEDOUT;
}

References container_of, data, DBGC, ETIMEDOUT, rdc_nic::mdio, RDC_MII_MAX_WAIT_US, RDC_MMDIO, RDC_MMDIO_MIIWR, RDC_MMDIO_PHYAD, RDC_MMDIO_REGAD, RDC_MMWD, readw, reg, rdc_nic::regs, udelay(), and writew.

rdc_init_phy()

int rdc_init_phy ( struct rdc_nic * rdc )

static

Initialise PHY.

Parameters

rdc	RDC device

Return values

rc	Return status code

Definition at line 184 of file rdc.c.

                                                {
        int rc;
 
        /* Find PHY address */
        if ( ( rc = mii_find ( &rdc->mii ) ) != 0 ) {
                DBGC ( rdc, "RDC %p could not find PHY address: %s\n",
                       rdc, strerror ( rc ) );
                return rc;
        }
 
        /* Reset PHY */
        if ( ( rc = mii_reset ( &rdc->mii ) ) != 0 ) {
                DBGC ( rdc, "RDC %p could not reset PHY: %s\n",
                       rdc, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

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

Referenced by rdc_probe().

rdc_check_link()

int rdc_check_link ( struct net_device * netdev )

static

Check link state.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 210 of file rdc.c.

                                                        {
        struct rdc_nic *rdc = netdev->priv;
        int rc;
 
        /* Check link state */
        if ( ( rc = mii_check_link ( &rdc->mii, netdev ) ) != 0 ) {
                DBGC ( rdc, "RDC %p could not check link: %s\n",
                       rdc, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References DBGC, rdc_nic::mii, mii_check_link(), netdev, rc, and strerror().

Referenced by rdc_open(), rdc_poll(), and rdc_probe().

rdc_create_ring()

int rdc_create_ring ( struct rdc_nic * rdc, struct rdc_ring * ring )

static

Create descriptor ring.

Parameters

rdc	RDC device
ring	Descriptor ring

Return values

rc	Return status code

Definition at line 238 of file rdc.c.

                                                                          {
        size_t len = ( ring->count * sizeof ( ring->desc[0] ) );
        struct rdc_descriptor *desc;
        struct rdc_descriptor *next;
        physaddr_t start;
        unsigned int i;
 
        /* Allocate descriptor ring */
        ring->desc = dma_alloc ( rdc->dma, &ring->map, len, len );
        if ( ! ring->desc )
                return -ENOMEM;
 
        /* Initialise descriptor ring */
        memset ( ring->desc, 0, len );
        for ( i = 0 ; i < ring->count ; i++ ) {
                desc = &ring->desc[i];
                next = &ring->desc[ ( i + 1 ) & ( ring->count - 1 ) ];
                desc->next = cpu_to_le32 ( dma ( &ring->map, next ) );
        }
 
        /* Program ring address */
        start = dma ( &ring->map, ring->desc );
        writew ( ( start >> 0 ), ( rdc->regs + ring->reg + RDC_MxDSA_LO ) );
        writew ( ( start >> 16 ), ( rdc->regs + ring->reg + RDC_MxDSA_HI ) );
 
        DBGC ( rdc, "RDC %p ring %#02x is at [%08lx,%08lx)\n",
               rdc, ring->reg, virt_to_phys ( ring->desc ),
               ( virt_to_phys ( ring->desc ) + len ) );
        return 0;
}

References rdc_ring::count, cpu_to_le32, DBGC, desc, rdc_ring::desc, dma(), rdc_nic::dma, dma_alloc(), ENOMEM, len, rdc_ring::map, memset(), next, RDC_MxDSA_HI, RDC_MxDSA_LO, rdc_ring::reg, rdc_nic::regs, start, and writew.

Referenced by rdc_open().

rdc_destroy_ring()

void rdc_destroy_ring ( struct rdc_nic * rdc, struct rdc_ring * ring )

static

Destroy descriptor ring.

Parameters

rdc	RDC device
ring	Descriptor ring

Definition at line 275 of file rdc.c.

                                                                            {
        size_t len = ( ring->count * sizeof ( ring->desc[0] ) );
 
        /* Clear ring address */
        writew ( 0, ( rdc->regs + ring->reg + RDC_MxDSA_LO ) );
        writew ( 0, ( rdc->regs + ring->reg + RDC_MxDSA_HI ) );
 
        /* Free descriptors */
        dma_free ( &ring->map, ring->desc, len );
        ring->desc = NULL;
 
        /* Reset ring */
        ring->prod = 0;
        ring->cons = 0;
}

References rdc_ring::cons, rdc_ring::count, rdc_ring::desc, dma_free(), len, rdc_ring::map, NULL, rdc_ring::prod, RDC_MxDSA_HI, RDC_MxDSA_LO, rdc_ring::reg, rdc_nic::regs, and writew.

Referenced by rdc_close(), and rdc_open().

rdc_refill_rx()

void rdc_refill_rx ( struct rdc_nic * rdc )

static

Refill receive descriptor ring.

Parameters

rdc	RDC device

Definition at line 296 of file rdc.c.

                                                  {
        struct rdc_descriptor *rx;
        struct io_buffer *iobuf;
        unsigned int rx_idx;
 
        /* Refill ring */
        while ( ( rdc->rx.prod - rdc->rx.cons ) < RDC_NUM_RX_DESC ) {
 
                /* Allocate I/O buffer */
                iobuf = alloc_rx_iob ( RDC_RX_MAX_LEN, rdc->dma );
                if ( ! iobuf ) {
                        /* Wait for next refill */
                        break;
                }
 
                /* Get next receive descriptor */
                rx_idx = ( rdc->rx.prod++ % RDC_NUM_RX_DESC );
                rx = &rdc->rx.desc[rx_idx];
 
                /* Populate receive descriptor */
                rx->len = cpu_to_le16 ( RDC_RX_MAX_LEN );
                rx->addr = cpu_to_le32 ( iob_dma ( iobuf ) );
                wmb();
                rx->flags = cpu_to_le16 ( RDC_FL_OWNED );
 
                /* Record I/O buffer */
                assert ( rdc->rx_iobuf[rx_idx] == NULL );
                rdc->rx_iobuf[rx_idx] = iobuf;
 
                DBGC2 ( rdc, "RDC %p RX %d is [%lx,%lx)\n",
                        rdc, rx_idx, virt_to_phys ( iobuf->data ),
                        ( virt_to_phys ( iobuf->data ) + RDC_RX_MAX_LEN ) );
        }
}

References alloc_rx_iob(), assert, rdc_ring::cons, cpu_to_le16, cpu_to_le32, io_buffer::data, DBGC2, rdc_ring::desc, rdc_nic::dma, iob_dma(), NULL, rdc_ring::prod, RDC_FL_OWNED, RDC_NUM_RX_DESC, RDC_RX_MAX_LEN, rdc_nic::rx, rx, rdc_nic::rx_iobuf, and wmb.

Referenced by rdc_open(), and rdc_poll().

rdc_open()

int rdc_open ( struct net_device * netdev )

static

Open network device.

Parameters

netdev

Network device

Return values

rc	Return status code

Definition at line 337 of file rdc.c.

                                                  {
        struct rdc_nic *rdc = netdev->priv;
        int rc;
 
        /* Create transmit descriptor ring */
        if ( ( rc = rdc_create_ring ( rdc, &rdc->tx ) ) != 0 )
                goto err_create_tx;
 
        /* Create receive descriptor ring */
        if ( ( rc = rdc_create_ring ( rdc, &rdc->rx ) ) != 0 )
                goto err_create_rx;
 
        /* Program receive buffer length */
        writew ( RDC_RX_MAX_LEN, rdc->regs + RDC_MRBSR );
 
        /* Enable transmit and receive */
        writew ( ( RDC_MCR0_FD | RDC_MCR0_TXEN | RDC_MCR0_PROMISC |
                   RDC_MCR0_RXEN ),
                 rdc->regs + RDC_MCR0 );
 
        /* Enable PHY status polling */
        writew ( ( RDC_MPSCCR_EN | RDC_MPSCCR_PHYAD ( rdc->mii.address ) |
                   RDC_MPSCCR_SLOW ),
                 rdc->regs + RDC_MPSCCR );
 
        /* Fill receive ring */
        rdc_refill_rx ( rdc );
 
        /* Update link state */
        rdc_check_link ( netdev );
 
        return 0;
 
        rdc_destroy_ring ( rdc, &rdc->rx );
 err_create_rx:
        rdc_destroy_ring ( rdc, &rdc->tx );
 err_create_tx:
        return rc;
}

References mii_device::address, rdc_nic::mii, netdev, rc, rdc_check_link(), rdc_create_ring(), rdc_destroy_ring(), RDC_MCR0, RDC_MCR0_FD, RDC_MCR0_PROMISC, RDC_MCR0_RXEN, RDC_MCR0_TXEN, RDC_MPSCCR, RDC_MPSCCR_EN, RDC_MPSCCR_PHYAD, RDC_MPSCCR_SLOW, RDC_MRBSR, rdc_refill_rx(), RDC_RX_MAX_LEN, rdc_nic::regs, rdc_nic::rx, rdc_nic::tx, and writew.

rdc_close()

void rdc_close ( struct net_device * netdev )

static

Close network device.

Parameters

netdev

Network device

Definition at line 382 of file rdc.c.

                                                    {
        struct rdc_nic *rdc = netdev->priv;
        unsigned int i;
 
        /* Disable NIC */
        writew ( 0, rdc->regs + RDC_MCR0 );
 
        /* Destroy receive descriptor ring */
        rdc_destroy_ring ( rdc, &rdc->rx );
 
        /* Discard any unused receive buffers */
        for ( i = 0 ; i < RDC_NUM_RX_DESC ; i++ ) {
                if ( rdc->rx_iobuf[i] )
                        free_rx_iob ( rdc->rx_iobuf[i] );
                rdc->rx_iobuf[i] = NULL;
        }
 
        /* Destroy transmit descriptor ring */
        rdc_destroy_ring ( rdc, &rdc->tx );
}

References free_rx_iob(), netdev, NULL, rdc_destroy_ring(), RDC_MCR0, RDC_NUM_RX_DESC, rdc_nic::regs, rdc_nic::rx, rdc_nic::rx_iobuf, rdc_nic::tx, and writew.

rdc_transmit()

int rdc_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 410 of file rdc.c.

                                                                               {
        struct rdc_nic *rdc = netdev->priv;
        struct rdc_descriptor *tx;
        unsigned int tx_idx;
        int rc;
 
        /* Get next transmit descriptor */
        if ( ( rdc->tx.prod - rdc->tx.cons ) >= RDC_NUM_TX_DESC ) {
                DBGC ( rdc, "RDC %p out of transmit descriptors\n", rdc );
                return -ENOBUFS;
        }
        tx_idx = ( rdc->tx.prod % RDC_NUM_TX_DESC );
        tx = &rdc->tx.desc[tx_idx];
 
        /* Pad to minimum length */
        iob_pad ( iobuf, ETH_ZLEN );
 
        /* Map I/O buffer */
        if ( ( rc = iob_map_tx ( iobuf, rdc->dma ) ) != 0 )
                return rc;
 
        /* Update producer index */
        rdc->tx.prod++;
 
        /* Populate transmit descriptor */
        tx->len = cpu_to_le16 ( iob_len ( iobuf ) );
        tx->addr = cpu_to_le32 ( iob_dma ( iobuf ) );
        wmb();
        tx->flags = cpu_to_le16 ( RDC_FL_OWNED );
        wmb();
 
        /* Notify card that there are packets ready to transmit */
        writew ( RDC_MTPR_TM2TX, rdc->regs + RDC_MTPR );
 
        return 0;
}

References rdc_ring::cons, cpu_to_le16, cpu_to_le32, DBGC, rdc_ring::desc, rdc_nic::dma, ENOBUFS, ETH_ZLEN, iob_dma(), iob_len(), iob_map_tx(), iob_pad(), netdev, rdc_ring::prod, rc, RDC_FL_OWNED, RDC_MTPR, RDC_MTPR_TM2TX, RDC_NUM_TX_DESC, rdc_nic::regs, rdc_nic::tx, tx, wmb, and writew.

rdc_poll_tx()

void rdc_poll_tx ( struct net_device * netdev )

static

Poll for completed packets.

Parameters

netdev

Network device

Definition at line 452 of file rdc.c.

                                                      {
        struct rdc_nic *rdc = netdev->priv;
        struct rdc_descriptor *tx;
        unsigned int tx_idx;
 
        /* Check for completed packets */
        while ( rdc->tx.cons != rdc->tx.prod ) {
 
                /* Get next transmit descriptor */
                tx_idx = ( rdc->tx.cons % RDC_NUM_TX_DESC );
                tx = &rdc->tx.desc[tx_idx];
 
                /* Stop if descriptor is still in use */
                if ( tx->flags & cpu_to_le16 ( RDC_FL_OWNED ) )
                        return;
                DBGC2 ( rdc, "RDC %p TX %d complete\n", rdc, tx_idx );
 
                /* Complete transmit descriptor */
                rdc->tx.cons++;
                netdev_tx_complete_next ( netdev );
        }
}

References rdc_ring::cons, cpu_to_le16, DBGC2, rdc_ring::desc, netdev, netdev_tx_complete_next(), rdc_ring::prod, RDC_FL_OWNED, RDC_NUM_TX_DESC, rdc_nic::tx, and tx.

Referenced by rdc_poll().

rdc_poll_rx()

void rdc_poll_rx ( struct net_device * netdev )

static

Poll for received packets.

Parameters

netdev

Network device

Definition at line 480 of file rdc.c.

                                                      {
        struct rdc_nic *rdc = netdev->priv;
        struct rdc_descriptor *rx;
        struct io_buffer *iobuf;
        unsigned int rx_idx;
        size_t len;
 
        /* Check for received packets */
        while ( rdc->rx.cons != rdc->rx.prod ) {
 
                /* Get next receive descriptor */
                rx_idx = ( rdc->rx.cons % RDC_NUM_RX_DESC );
                rx = &rdc->rx.desc[rx_idx];
 
                /* Stop if descriptor is still in use */
                if ( rx->flags & cpu_to_le16 ( RDC_FL_OWNED ) )
                        return;
 
                /* Populate I/O buffer */
                iobuf = rdc->rx_iobuf[rx_idx];
                rdc->rx_iobuf[rx_idx] = NULL;
                len = le16_to_cpu ( rx->len );
                iob_put ( iobuf, len );
                iob_unput ( iobuf, 4 /* strip CRC */ );
 
                /* Hand off to network stack */
                if ( rx->flags & cpu_to_le16 ( RDC_FL_OK ) ) {
                        DBGC2 ( rdc, "RDC %p RX %d complete (length %zd)\n",
                                rdc, rx_idx, len );
                        netdev_rx ( netdev, iobuf );
                } else {
                        DBGC2 ( rdc, "RDC %p RX %d error (length %zd, "
                                "flags %#04x)\n", rdc, rx_idx, len,
                                le16_to_cpu ( rx->flags ) );
                        netdev_rx_err ( netdev, iobuf, -EIO );
                }
                rdc->rx.cons++;
        }
}

References rdc_ring::cons, cpu_to_le16, DBGC2, rdc_ring::desc, EIO, iob_put, iob_unput, le16_to_cpu, len, netdev, netdev_rx(), netdev_rx_err(), NULL, rdc_ring::prod, RDC_FL_OK, RDC_FL_OWNED, RDC_NUM_RX_DESC, rdc_nic::rx, rx, and rdc_nic::rx_iobuf.

Referenced by rdc_poll().

rdc_poll()

void rdc_poll ( struct net_device * netdev )

static

Poll for completed and received packets.

Parameters

netdev

Network device

Definition at line 525 of file rdc.c.

                                                   {
        struct rdc_nic *rdc = netdev->priv;
        uint16_t misr;
 
        /* Check for (and acknowledge) interrupts */
        misr = readw ( rdc->regs + RDC_MISR );
 
        /* Poll for TX completions, if applicable */
        if ( misr & RDC_MIRQ_TX )
                rdc_poll_tx ( netdev );
 
        /* Poll for RX completions, if applicable */
        if ( misr & RDC_MIRQ_RX )
                rdc_poll_rx ( netdev );
 
        /* Check link state, if applicable */
        if ( misr & RDC_MIRQ_LINK )
                rdc_check_link ( netdev );
 
        /* Check for unexpected interrupts */
        if ( misr & ~( RDC_MIRQ_LINK | RDC_MIRQ_TX | RDC_MIRQ_RX_EARLY |
                       RDC_MIRQ_RX_EMPTY | RDC_MIRQ_RX ) ) {
                DBGC ( rdc, "RDC %p unexpected MISR %#04x\n", rdc, misr );
                /* Report as a TX error */
                netdev_tx_err ( netdev, NULL, -ENOTSUP );
        }
 
        /* Refill receive ring */
        rdc_refill_rx ( rdc );
}

References DBGC, ENOTSUP, netdev, netdev_tx_err(), NULL, rdc_check_link(), RDC_MIRQ_LINK, RDC_MIRQ_RX, RDC_MIRQ_RX_EARLY, RDC_MIRQ_RX_EMPTY, RDC_MIRQ_TX, RDC_MISR, rdc_poll_rx(), rdc_poll_tx(), rdc_refill_rx(), readw, and rdc_nic::regs.

rdc_irq()

void rdc_irq ( struct net_device * netdev, int enable )

static

Enable or disable interrupts.

Parameters

netdev	Network device
enable	Interrupts should be enabled

Definition at line 562 of file rdc.c.

                                                              {
        struct rdc_nic *rdc = netdev->priv;
        uint16_t mier;
 
        /* Enable/disable interrupts */
        mier = ( enable ? ( RDC_MIRQ_LINK | RDC_MIRQ_TX | RDC_MIRQ_RX ) : 0 );
        writew ( mier, rdc->regs + RDC_MIER );
}

References netdev, RDC_MIER, RDC_MIRQ_LINK, RDC_MIRQ_RX, RDC_MIRQ_TX, rdc_nic::regs, and writew.

rdc_probe()

int rdc_probe ( struct pci_device * pci )

static

Probe PCI device.

Parameters

pci	PCI device

Return values

rc	Return status code

Definition at line 593 of file rdc.c.

                                                {
        struct net_device *netdev;
        struct rdc_nic *rdc;
        union rdc_mac mac;
        int rc;
 
        /* Allocate and initialise net device */
        netdev = alloc_etherdev ( sizeof ( *rdc ) );
        if ( ! netdev ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        netdev_init ( netdev, &rdc_operations );
        rdc = netdev->priv;
        pci_set_drvdata ( pci, netdev );
        netdev->dev = &pci->dev;
        memset ( rdc, 0, sizeof ( *rdc ) );
        rdc->dma = &pci->dma;
        mdio_init ( &rdc->mdio, &rdc_mii_operations );
        mii_init ( &rdc->mii, &rdc->mdio, 0 );
        rdc_init_ring ( &rdc->tx, RDC_NUM_TX_DESC, RDC_MTDSA );
        rdc_init_ring ( &rdc->rx, RDC_NUM_RX_DESC, RDC_MRDSA );
 
        /* Fix up PCI device */
        adjust_pci_device ( pci );
 
        /* Map registers */
        rdc->regs = pci_ioremap ( pci, pci->membase, RDC_BAR_SIZE );
        if ( ! rdc->regs ) {
                rc = -ENODEV;
                goto err_ioremap;
        }
 
        /* Fetch MAC address */
        mac.mid[0] = cpu_to_le16 ( readw ( rdc->regs + RDC_MID0 ) );
        mac.mid[1] = cpu_to_le16 ( readw ( rdc->regs + RDC_MID1 ) );
        mac.mid[2] = cpu_to_le16 ( readw ( rdc->regs + RDC_MID2 ) );
        memcpy ( netdev->hw_addr, mac.raw, ETH_ALEN );
 
        /* Reset the NIC */
        if ( ( rc = rdc_reset ( rdc ) ) != 0 )
                goto err_reset;
 
        /* Initialise PHY */
        if ( ( rc = rdc_init_phy ( rdc ) ) != 0 )
                goto err_init_phy;
 
        /* Register network device */
        if ( ( rc = register_netdev ( netdev ) ) != 0 )
                goto err_register_netdev;
 
        /* Set initial link state */
        rdc_check_link ( netdev );
 
        return 0;
 
        unregister_netdev ( netdev );
 err_register_netdev:
 err_init_phy:
        rdc_reset ( rdc );
 err_reset:
        iounmap ( rdc->regs );
 err_ioremap:
        netdev_nullify ( netdev );
        netdev_put ( netdev );
 err_alloc:
        return rc;
}

References adjust_pci_device(), alloc_etherdev(), cpu_to_le16, pci_device::dev, pci_device::dma, rdc_nic::dma, ENODEV, ENOMEM, ETH_ALEN, iounmap(), mac, rdc_nic::mdio, mdio_init(), pci_device::membase, memcpy(), memset(), rdc_nic::mii, mii_init(), netdev, netdev_init(), netdev_nullify(), netdev_put(), pci_ioremap(), pci_set_drvdata(), rc, RDC_BAR_SIZE, rdc_check_link(), rdc_init_phy(), rdc_init_ring(), RDC_MID0, RDC_MID1, RDC_MID2, rdc_mii_operations, RDC_MRDSA, RDC_MTDSA, RDC_NUM_RX_DESC, RDC_NUM_TX_DESC, rdc_operations, rdc_reset(), readw, register_netdev(), rdc_nic::regs, rdc_nic::rx, rdc_nic::tx, and unregister_netdev().

rdc_remove()

void rdc_remove ( struct pci_device * pci )

static

Remove PCI device.

Parameters

pci	PCI device

Definition at line 667 of file rdc.c.

                                                  {
        struct net_device *netdev = pci_get_drvdata ( pci );
        struct rdc_nic *rdc = netdev->priv;
 
        /* Unregister network device */
        unregister_netdev ( netdev );
 
        /* Reset card */
        rdc_reset ( rdc );
 
        /* Free network device */
        iounmap ( rdc->regs );
        netdev_nullify ( netdev );
        netdev_put ( netdev );
}

References iounmap(), netdev, netdev_nullify(), netdev_put(), pci_get_drvdata(), rdc_reset(), rdc_nic::regs, and unregister_netdev().

Variable Documentation

rdc_mii_operations

struct mii_operations rdc_mii_operations

static

Initial value:

= {
        .read = rdc_mii_read,
        .write = rdc_mii_write,
}

RDC MII operations.

Definition at line 166 of file rdc.c.

                                                  {
        .read = rdc_mii_read,
        .write = rdc_mii_write,
};

Referenced by rdc_probe().

rdc_operations

struct net_device_operations rdc_operations

static

Initial value:

= {
        .open           = rdc_open,
        .close          = rdc_close,
        .transmit       = rdc_transmit,
        .poll           = rdc_poll,
        .irq            = rdc_irq,
}

RDC network device operations.

Definition at line 572 of file rdc.c.

                                                     {
        .open           = rdc_open,
        .close          = rdc_close,
        .transmit       = rdc_transmit,
        .poll           = rdc_poll,
        .irq            = rdc_irq,
};

Referenced by rdc_probe().

rdc_nics

struct pci_device_id rdc_nics[]

static

Initial value:

= {
        PCI_ROM ( 0x17f3, 0x6040, "r6040", "RDC R6040", 0 ),
}

RDC PCI device IDs.

Definition at line 684 of file rdc.c.

                                         {
        PCI_ROM ( 0x17f3, 0x6040, "r6040", "RDC R6040", 0 ),
};

__pci_driver

struct pci_driver rdc_driver __pci_driver

Initial value:

= {
        .ids = rdc_nics,
        .id_count = ( sizeof ( rdc_nics ) / sizeof ( rdc_nics[0] ) ),
        .probe = rdc_probe,
        .remove = rdc_remove,
}

RDC PCI driver.

Definition at line 689 of file rdc.c.

                                            {
        .ids = rdc_nics,
        .id_count = ( sizeof ( rdc_nics ) / sizeof ( rdc_nics[0] ) ),
        .probe = rdc_probe,
        .remove = rdc_remove,
};