forcedeth.c File Reference

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <assert.h>
#include <byteswap.h>
#include <errno.h>
#include <ipxe/ethernet.h>
#include <ipxe/if_ether.h>
#include <ipxe/io.h>
#include <ipxe/iobuf.h>
#include <ipxe/malloc.h>
#include <ipxe/netdevice.h>
#include <ipxe/crypto.h>
#include <ipxe/pci.h>
#include <ipxe/timer.h>
#include <mii.h>
#include "forcedeth.h"

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER)
static void	pci_push (void *ioaddr)
static int	reg_delay (struct forcedeth_private *priv, int offset, u32 mask, u32 target, int delay, int delaymax, const char *msg)
static int	mii_rw (struct forcedeth_private *priv, int addr, int miireg, int value)
static void	nv_txrx_gate (struct forcedeth_private *priv, int gate)
static void	nv_mac_reset (struct forcedeth_private *priv)
static void	nv_init_tx_ring (struct forcedeth_private *priv)
static void	nv_alloc_rx (struct forcedeth_private *priv)
	nv_alloc_rx - Allocates iobufs for every Rx descriptor that doesn't have one and isn't in use by the hardware More...
static void	nv_init_rx_ring (struct forcedeth_private *priv)
static int	nv_init_rings (struct forcedeth_private *priv)
	nv_init_rings - Allocate and intialize descriptor rings More...
static void	nv_free_rxtx_resources (struct forcedeth_private *priv)
static void	nv_txrx_reset (struct forcedeth_private *priv)
static void	nv_disable_hw_interrupts (struct forcedeth_private *priv)
static void	nv_enable_hw_interrupts (struct forcedeth_private *priv)
static void	nv_start_rx (struct forcedeth_private *priv)
static void	nv_stop_rx (struct forcedeth_private *priv)
static void	nv_start_tx (struct forcedeth_private *priv)
static void	nv_stop_tx (struct forcedeth_private *priv)
static void	nv_update_pause (struct forcedeth_private *priv, u32 pause_flags)
static int	nv_update_linkspeed (struct forcedeth_private *priv)
static int	forcedeth_open (struct net_device *netdev)
	open - Called when a network interface is made active More...
static int	forcedeth_transmit (struct net_device *netdev, struct io_buffer *iobuf)
	transmit - Transmit a packet More...
static void	nv_process_tx_packets (struct net_device *netdev)
	nv_process_tx_packets - Checks for successfully sent packets, reports them to iPXE with netdev_tx_complete() More...
static void	nv_process_rx_packets (struct net_device *netdev)
	nv_process_rx_packets - Checks for received packets, reports them to iPXE with netdev_rx() or netdev_rx_err() if there was an error receiving the packet More...
static void	forcedeth_link_status (struct net_device *netdev)
	check_link - Check for link status change More...
static void	forcedeth_poll (struct net_device *netdev)
	poll - Poll for received packets More...
static void	forcedeth_close (struct net_device *netdev)
	close - Disable network interface More...
static void	forcedeth_irq (struct net_device *netdev, int action)
	irq - enable or disable interrupts More...
static int	nv_setup_mac_addr (struct forcedeth_private *priv)
static int	nv_mgmt_acquire_sema (struct forcedeth_private *priv)
static void	nv_mgmt_release_sema (struct forcedeth_private *priv)
static int	nv_mgmt_get_version (struct forcedeth_private *priv)
static int	phy_reset (struct forcedeth_private *priv, u32 bmcr_setup)
static int	phy_init (struct forcedeth_private *priv)
static int	nv_setup_phy (struct forcedeth_private *priv)
	nv_setup_phy - Find PHY and initialize it More...
static int	forcedeth_map_regs (struct forcedeth_private *priv)
	forcedeth_map_regs - Find a suitable BAR for the NIC and map the registers in memory More...
static int	forcedeth_probe (struct pci_device *pdev)
	probe - Initial configuration of NIC More...
static void	nv_restore_phy (struct forcedeth_private *priv)
static void	forcedeth_remove (struct pci_device *pdev)
	remove - Device Removal Routine More...

Variables
static struct net_device_operations	forcedeth_operations
static struct pci_device_id	forcedeth_nics []
struct pci_driver forcedeth_driver	__pci_driver

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER

)

pci_push()

static void pci_push ( void *  ioaddr )

inlinestatic

Definition at line 62 of file forcedeth.c.

{
        /* force out pending posted writes */
        wmb();
        readl ( ioaddr );
}

References ioaddr, readl(), and wmb().

Referenced by forcedeth_open(), forcedeth_transmit(), nv_disable_hw_interrupts(), nv_mac_reset(), nv_start_rx(), nv_start_tx(), nv_txrx_reset(), nv_update_linkspeed(), and reg_delay().

reg_delay()

static int reg_delay ( struct forcedeth_private *  priv, int  offset, u32  mask, u32  target, int  delay, int  delaymax, const char *  msg  )

static

Definition at line 70 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;

        pci_push ( ioaddr );
        do {
                udelay ( delay );
                delaymax -= delay;
                if ( delaymax < 0 ) {
                        if ( msg )
                                DBG ( "%s\n", msg );
                        return 1;
                }
        } while ( ( readl ( ioaddr + offset ) & mask ) != target );

        return 0;
}

References DBG, delay, ioaddr, msg(), offset, pci_push(), priv, readl(), and udelay().

Referenced by forcedeth_open(), mii_rw(), nv_stop_rx(), and nv_stop_tx().

mii_rw()

static int mii_rw ( struct forcedeth_private *  priv, int  addr, int  miireg, int  value  )

static

Definition at line 91 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        u32 reg;
        int retval;

        writel ( NVREG_MIISTAT_MASK_RW, ioaddr + NvRegMIIStatus );

        reg = readl ( ioaddr + NvRegMIIControl );
        if ( reg & NVREG_MIICTL_INUSE ) {
                writel ( NVREG_MIICTL_INUSE, ioaddr + NvRegMIIControl );
                udelay ( NV_MIIBUSY_DELAY );
        }

        reg = ( addr << NVREG_MIICTL_ADDRSHIFT ) | miireg;
        if ( value != MII_READ ) {
                writel ( value, ioaddr + NvRegMIIData );
                reg |= NVREG_MIICTL_WRITE;
        }
        writel ( reg, ioaddr + NvRegMIIControl );

        if ( reg_delay ( priv, NvRegMIIControl, NVREG_MIICTL_INUSE, 0,
                        NV_MIIPHY_DELAY, NV_MIIPHY_DELAYMAX, NULL ) ) {
                DBG ( "mii_rw of reg %d at PHY %d timed out.\n",
                        miireg, addr );
                retval = -1;
        } else if ( value != MII_READ ) {
                /* it was a write operation - fewer failures are detectable */
                DBG ( "mii_rw wrote 0x%x to reg %d at PHY %d\n",
                        value, miireg, addr );
                retval = 0;
        } else if ( readl ( ioaddr + NvRegMIIStatus ) & NVREG_MIISTAT_ERROR ) {
                DBG ( "mii_rw of reg %d at PHY %d failed.\n",
                        miireg, addr );
                retval = -1;
        } else {
                retval = readl ( ioaddr + NvRegMIIData );
                DBG ( "mii_rw read from reg %d at PHY %d: 0x%x.\n",
                        miireg, addr, retval );
        }

        return retval;
}

References addr, DBG, ioaddr, MII_READ, NULL, NV_MIIBUSY_DELAY, NV_MIIPHY_DELAY, NV_MIIPHY_DELAYMAX, NVREG_MIICTL_ADDRSHIFT, NVREG_MIICTL_INUSE, NVREG_MIICTL_WRITE, NVREG_MIISTAT_ERROR, NVREG_MIISTAT_MASK_RW, NvRegMIIControl, NvRegMIIData, NvRegMIIStatus, priv, readl(), reg, reg_delay(), retval, udelay(), value, and writel().

Referenced by forcedeth_open(), nv_restore_phy(), nv_setup_phy(), nv_update_linkspeed(), phy_init(), and phy_reset().

nv_txrx_gate()

static void nv_txrx_gate ( struct forcedeth_private *  priv, int  gate  )

static

Definition at line 136 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        u32 powerstate;

        if ( ! priv->mac_in_use &&
             ( priv->driver_data & DEV_HAS_POWER_CNTRL ) ) {
                powerstate = readl ( ioaddr + NvRegPowerState2 );
                if ( gate )
                        powerstate |= NVREG_POWERSTATE2_GATE_CLOCKS;
                else
                        powerstate &= ~NVREG_POWERSTATE2_GATE_CLOCKS;
                writel ( powerstate, ioaddr + NvRegPowerState2 );
        }
}

References DEV_HAS_POWER_CNTRL, ioaddr, NVREG_POWERSTATE2_GATE_CLOCKS, NvRegPowerState2, priv, readl(), and writel().

Referenced by forcedeth_close(), and forcedeth_open().

nv_mac_reset()

static void nv_mac_reset ( struct forcedeth_private *  priv )

static

Definition at line 153 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        u32 temp1, temp2, temp3;

        writel ( NVREG_TXRXCTL_BIT2 | NVREG_TXRXCTL_RESET | NVREG_TXRXCTL_DESC_1,
                 ioaddr + NvRegTxRxControl );
        pci_push ( ioaddr );

        /* save registers since they will be cleared on reset */
        temp1 = readl ( ioaddr + NvRegMacAddrA );
        temp2 = readl ( ioaddr + NvRegMacAddrB );
        temp3 = readl ( ioaddr + NvRegTransmitPoll );

        writel ( NVREG_MAC_RESET_ASSERT, ioaddr + NvRegMacReset );
        pci_push ( ioaddr );
        udelay ( NV_MAC_RESET_DELAY );
        writel ( 0, ioaddr + NvRegMacReset );
        pci_push ( ioaddr );
        udelay ( NV_MAC_RESET_DELAY );

        /* restore saved registers */
        writel ( temp1, ioaddr + NvRegMacAddrA );
        writel ( temp2, ioaddr + NvRegMacAddrB );
        writel ( temp3, ioaddr + NvRegTransmitPoll );

        writel ( NVREG_TXRXCTL_BIT2 | NVREG_TXRXCTL_DESC_1,
                 ioaddr + NvRegTxRxControl );
        pci_push ( ioaddr );
}

References ioaddr, NV_MAC_RESET_DELAY, NVREG_MAC_RESET_ASSERT, NVREG_TXRXCTL_BIT2, NVREG_TXRXCTL_DESC_1, NVREG_TXRXCTL_RESET, NvRegMacAddrA, NvRegMacAddrB, NvRegMacReset, NvRegTransmitPoll, NvRegTxRxControl, pci_push(), priv, readl(), udelay(), and writel().

Referenced by forcedeth_open().

nv_init_tx_ring()

static void nv_init_tx_ring ( struct forcedeth_private *  priv )

static

Definition at line 185 of file forcedeth.c.

{
        int i;

        for ( i = 0; i < TX_RING_SIZE; i++ ) {
                priv->tx_ring[i].flaglen = 0;
                priv->tx_ring[i].buf = 0;
                priv->tx_iobuf[i] = NULL;
        }

        priv->tx_fill_ctr = 0;
        priv->tx_curr = 0;
        priv->tx_tail = 0;
}

References NULL, priv, and TX_RING_SIZE.

Referenced by nv_init_rings().

nv_alloc_rx()

static void nv_alloc_rx ( struct forcedeth_private *  priv )

static

nv_alloc_rx - Allocates iobufs for every Rx descriptor that doesn't have one and isn't in use by the hardware

Parameters

priv	Driver private structure

Definition at line 207 of file forcedeth.c.

{
        struct ring_desc *rx_curr_desc;
        int i;
        u32 status;

        DBGP ( "nv_alloc_rx\n" );

        for ( i = 0; i < RX_RING_SIZE; i++ ) {
                rx_curr_desc = priv->rx_ring + i;
                status = le32_to_cpu ( rx_curr_desc->flaglen );

                /* Don't touch the descriptors owned by the hardware */
                if ( status & NV_RX_AVAIL )
                        continue;

                /* Descriptors with iobufs still need to be processed */
                if ( priv->rx_iobuf[i] != NULL )
                        continue;

                /* If alloc_iob fails, try again later (next poll) */
                if ( ! ( priv->rx_iobuf[i] = alloc_iob ( RX_BUF_SZ ) ) ) {
                        DBG ( "Refill rx_ring failed, size %d\n", RX_BUF_SZ );
                        break;
                }

                rx_curr_desc->buf =
                        cpu_to_le32 ( virt_to_bus ( priv->rx_iobuf[i]->data ) );
                wmb();
                rx_curr_desc->flaglen =
                        cpu_to_le32 ( RX_BUF_SZ | NV_RX_AVAIL );
        }
}

References alloc_iob(), ring_desc::buf, cpu_to_le32, DBG, DBGP, ring_desc::flaglen, le32_to_cpu, NULL, NV_RX_AVAIL, priv, RX_BUF_SZ, RX_RING_SIZE, status, virt_to_bus(), and wmb().

Referenced by nv_init_rings(), and nv_process_rx_packets().

nv_init_rx_ring()

static void nv_init_rx_ring ( struct forcedeth_private *  priv )

static

Definition at line 242 of file forcedeth.c.

{
        int i;

        for ( i = 0; i < RX_RING_SIZE; i++ ) {
                priv->rx_ring[i].flaglen = 0;
                priv->rx_ring[i].buf = 0;
                priv->rx_iobuf[i] = NULL;
        }

        priv->rx_curr = 0;
}

References NULL, priv, and RX_RING_SIZE.

Referenced by nv_init_rings().

nv_init_rings()

static int nv_init_rings ( struct forcedeth_private *  priv )

static

nv_init_rings - Allocate and intialize descriptor rings

Parameters

priv	Driver private structure

Return values

rc	Return status code

Definition at line 263 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        int rc = -ENOMEM;

        /* Allocate ring for both TX and RX */
        priv->rx_ring =
                malloc_phys ( sizeof(struct ring_desc) * RXTX_RING_SIZE, 32 );
        if ( ! priv->rx_ring )
                goto err_malloc;
        priv->tx_ring = &priv->rx_ring[RX_RING_SIZE];

        /* Initialize rings */
        nv_init_tx_ring ( priv );
        nv_init_rx_ring ( priv );

        /* Allocate iobufs for RX */
        nv_alloc_rx ( priv );

        /* Give hw rings */
        writel ( cpu_to_le32 ( virt_to_bus ( priv->rx_ring ) ),
                 ioaddr + NvRegRxRingPhysAddr );
        writel ( cpu_to_le32 ( virt_to_bus ( priv->tx_ring ) ),
                 ioaddr + NvRegTxRingPhysAddr );

        DBG ( "RX ring at phys addr: %#08lx\n",
                virt_to_bus ( priv->rx_ring ) );
        DBG ( "TX ring at phys addr: %#08lx\n",
                virt_to_bus ( priv->tx_ring ) );

        writel ( ( ( RX_RING_SIZE - 1 ) << NVREG_RINGSZ_RXSHIFT ) +
                 ( ( TX_RING_SIZE - 1 ) << NVREG_RINGSZ_TXSHIFT ),
                 ioaddr + NvRegRingSizes );

        return 0;

err_malloc:
        DBG ( "Could not allocate descriptor rings\n");
        return rc;
}

References cpu_to_le32, DBG, ENOMEM, ioaddr, malloc_phys(), nv_alloc_rx(), nv_init_rx_ring(), nv_init_tx_ring(), NVREG_RINGSZ_RXSHIFT, NVREG_RINGSZ_TXSHIFT, NvRegRingSizes, NvRegRxRingPhysAddr, NvRegTxRingPhysAddr, priv, rc, RX_RING_SIZE, RXTX_RING_SIZE, TX_RING_SIZE, virt_to_bus(), and writel().

Referenced by forcedeth_open().

nv_free_rxtx_resources()

static void nv_free_rxtx_resources ( struct forcedeth_private *  priv )

static

Definition at line 305 of file forcedeth.c.

{
        int i;

        DBGP ( "nv_free_rxtx_resources\n" );

        free_phys ( priv->rx_ring, sizeof(struct ring_desc) * RXTX_RING_SIZE );

        for ( i = 0; i < RX_RING_SIZE; i++ ) {
                free_iob ( priv->rx_iobuf[i] );
                priv->rx_iobuf[i] = NULL;
        }
}

References DBGP, free_iob(), free_phys(), NULL, priv, RX_RING_SIZE, and RXTX_RING_SIZE.

Referenced by forcedeth_close().

nv_txrx_reset()

static void nv_txrx_reset ( struct forcedeth_private *  priv )

static

Definition at line 320 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;

        writel ( NVREG_TXRXCTL_BIT2 | NVREG_TXRXCTL_RESET | NVREG_TXRXCTL_DESC_1,
                 ioaddr + NvRegTxRxControl );
        pci_push ( ioaddr );
        udelay ( NV_TXRX_RESET_DELAY );
        writel ( NVREG_TXRXCTL_BIT2 | NVREG_TXRXCTL_DESC_1,
                 ioaddr + NvRegTxRxControl );
        pci_push ( ioaddr );
}

References ioaddr, NV_TXRX_RESET_DELAY, NVREG_TXRXCTL_BIT2, NVREG_TXRXCTL_DESC_1, NVREG_TXRXCTL_RESET, NvRegTxRxControl, pci_push(), priv, udelay(), and writel().

Referenced by forcedeth_close(), and forcedeth_open().

nv_disable_hw_interrupts()

static void nv_disable_hw_interrupts ( struct forcedeth_private *  priv )

static

Definition at line 334 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;

        writel ( 0, ioaddr + NvRegIrqMask );
        pci_push ( ioaddr );
}

References ioaddr, NvRegIrqMask, pci_push(), priv, and writel().

Referenced by forcedeth_close(), forcedeth_irq(), and forcedeth_open().

nv_enable_hw_interrupts()

static void nv_enable_hw_interrupts ( struct forcedeth_private *  priv )

static

Definition at line 343 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;

        writel ( NVREG_IRQMASK_THROUGHPUT, ioaddr + NvRegIrqMask );
}

References ioaddr, NVREG_IRQMASK_THROUGHPUT, NvRegIrqMask, priv, and writel().

Referenced by forcedeth_irq().

nv_start_rx()

static void nv_start_rx ( struct forcedeth_private *  priv )

static

Definition at line 351 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        u32 rx_ctrl = readl ( ioaddr + NvRegReceiverControl );

        DBGP ( "nv_start_rx\n" );
        /* Already running? Stop it. */
        if ( ( readl ( ioaddr + NvRegReceiverControl ) & NVREG_RCVCTL_START ) && !priv->mac_in_use ) {
                rx_ctrl &= ~NVREG_RCVCTL_START;
                writel ( rx_ctrl, ioaddr + NvRegReceiverControl );
                pci_push ( ioaddr );
        }
        writel ( priv->linkspeed, ioaddr + NvRegLinkSpeed );
        pci_push ( ioaddr );
        rx_ctrl |= NVREG_RCVCTL_START;
        if ( priv->mac_in_use )
                rx_ctrl &= ~NVREG_RCVCTL_RX_PATH_EN;
        writel ( rx_ctrl, ioaddr + NvRegReceiverControl );
        DBG ( "nv_start_rx to duplex %d, speed 0x%08x.\n",
                priv->duplex, priv->linkspeed);
        pci_push ( ioaddr );
}

References DBG, DBGP, tlan_private::duplex, ioaddr, NVREG_RCVCTL_RX_PATH_EN, NVREG_RCVCTL_START, NvRegLinkSpeed, NvRegReceiverControl, pci_push(), priv, readl(), and writel().

Referenced by forcedeth_open(), and nv_update_linkspeed().

nv_stop_rx()

static void nv_stop_rx ( struct forcedeth_private *  priv )

static

Definition at line 375 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        u32 rx_ctrl = readl ( ioaddr + NvRegReceiverControl );

        DBGP ( "nv_stop_rx\n" );
        if ( ! priv->mac_in_use )
                rx_ctrl &= ~NVREG_RCVCTL_START;
        else
                rx_ctrl |= NVREG_RCVCTL_RX_PATH_EN;
        writel ( rx_ctrl, ioaddr + NvRegReceiverControl );
        reg_delay ( priv, NvRegReceiverStatus, NVREG_RCVSTAT_BUSY, 0,
                        NV_RXSTOP_DELAY1, NV_RXSTOP_DELAY1MAX,
                        "nv_stop_rx: ReceiverStatus remained busy");

        udelay ( NV_RXSTOP_DELAY2 );
        if ( ! priv->mac_in_use )
                writel ( 0, priv + NvRegLinkSpeed );
}

References DBGP, ioaddr, NV_RXSTOP_DELAY1, NV_RXSTOP_DELAY1MAX, NV_RXSTOP_DELAY2, NVREG_RCVCTL_RX_PATH_EN, NVREG_RCVCTL_START, NVREG_RCVSTAT_BUSY, NvRegLinkSpeed, NvRegReceiverControl, NvRegReceiverStatus, priv, readl(), reg_delay(), udelay(), and writel().

Referenced by forcedeth_close(), and nv_update_linkspeed().

nv_start_tx()

static void nv_start_tx ( struct forcedeth_private *  priv )

static

Definition at line 396 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        u32 tx_ctrl = readl ( ioaddr + NvRegTransmitterControl );

        DBGP ( "nv_start_tx\n" );
        tx_ctrl |= NVREG_XMITCTL_START;
        if ( priv->mac_in_use )
                tx_ctrl &= ~NVREG_XMITCTL_TX_PATH_EN;
        writel ( tx_ctrl, ioaddr + NvRegTransmitterControl );
        pci_push ( ioaddr );
}

References DBGP, ioaddr, NVREG_XMITCTL_START, NVREG_XMITCTL_TX_PATH_EN, NvRegTransmitterControl, pci_push(), priv, readl(), and writel().

Referenced by forcedeth_open(), and nv_update_linkspeed().

nv_stop_tx()

static void nv_stop_tx ( struct forcedeth_private *  priv )

static

Definition at line 410 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        u32 tx_ctrl = readl ( ioaddr + NvRegTransmitterControl );

        DBGP ( "nv_stop_tx");

        if ( ! priv->mac_in_use )
                tx_ctrl &= ~NVREG_XMITCTL_START;
        else
                tx_ctrl |= NVREG_XMITCTL_TX_PATH_EN;
        writel ( tx_ctrl, ioaddr + NvRegTransmitterControl );
        reg_delay ( priv, NvRegTransmitterStatus, NVREG_XMITSTAT_BUSY, 0,
                        NV_TXSTOP_DELAY1, NV_TXSTOP_DELAY1MAX,
                        "nv_stop_tx: TransmitterStatus remained busy");

        udelay ( NV_TXSTOP_DELAY2 );
        if ( ! priv->mac_in_use )
                writel( readl ( ioaddr + NvRegTransmitPoll) &
                                NVREG_TRANSMITPOLL_MAC_ADDR_REV,
                        ioaddr + NvRegTransmitPoll);
}

References DBGP, ioaddr, NV_TXSTOP_DELAY1, NV_TXSTOP_DELAY1MAX, NV_TXSTOP_DELAY2, NVREG_TRANSMITPOLL_MAC_ADDR_REV, NVREG_XMITCTL_START, NVREG_XMITCTL_TX_PATH_EN, NVREG_XMITSTAT_BUSY, NvRegTransmitPoll, NvRegTransmitterControl, NvRegTransmitterStatus, priv, readl(), reg_delay(), udelay(), and writel().

Referenced by forcedeth_close(), and nv_update_linkspeed().

nv_update_pause()

static void nv_update_pause ( struct forcedeth_private *  priv, u32  pause_flags  )

static

Definition at line 435 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;

        priv->pause_flags &= ~ ( NV_PAUSEFRAME_TX_ENABLE |
                                 NV_PAUSEFRAME_RX_ENABLE );

        if ( priv->pause_flags & NV_PAUSEFRAME_RX_CAPABLE ) {
                u32 pff = readl ( ioaddr + NvRegPacketFilterFlags ) & ~NVREG_PFF_PAUSE_RX;
                if ( pause_flags & NV_PAUSEFRAME_RX_ENABLE ) {
                        writel ( pff | NVREG_PFF_PAUSE_RX, ioaddr + NvRegPacketFilterFlags );
                        priv->pause_flags |= NV_PAUSEFRAME_RX_ENABLE;
                } else {
                        writel ( pff, ioaddr + NvRegPacketFilterFlags );
                }
        }
        if ( priv->pause_flags & NV_PAUSEFRAME_TX_CAPABLE ) {
                u32 regmisc = readl ( ioaddr + NvRegMisc1 ) & ~NVREG_MISC1_PAUSE_TX;
                if ( pause_flags & NV_PAUSEFRAME_TX_ENABLE ) {
                        u32 pause_enable = NVREG_TX_PAUSEFRAME_ENABLE_V1;
                        if ( priv->driver_data & DEV_HAS_PAUSEFRAME_TX_V2 )
                                pause_enable = NVREG_TX_PAUSEFRAME_ENABLE_V2;
                        if ( priv->driver_data & DEV_HAS_PAUSEFRAME_TX_V3 ) {
                                pause_enable = NVREG_TX_PAUSEFRAME_ENABLE_V3;
                                /* limit the number of tx pause frames to a default of 8 */
                                writel ( readl ( ioaddr + NvRegTxPauseFrameLimit ) |
                                                NVREG_TX_PAUSEFRAMELIMIT_ENABLE,
                                         ioaddr + NvRegTxPauseFrameLimit );
                        }
                        writel ( pause_enable, ioaddr + NvRegTxPauseFrame );
                        writel ( regmisc | NVREG_MISC1_PAUSE_TX, ioaddr + NvRegMisc1 );
                        priv->pause_flags |= NV_PAUSEFRAME_TX_ENABLE;
                } else {
                        writel ( NVREG_TX_PAUSEFRAME_DISABLE, ioaddr + NvRegTxPauseFrame );
                        writel ( regmisc, ioaddr + NvRegMisc1 );
                }
        }
}

References DEV_HAS_PAUSEFRAME_TX_V2, DEV_HAS_PAUSEFRAME_TX_V3, ioaddr, NV_PAUSEFRAME_RX_CAPABLE, NV_PAUSEFRAME_RX_ENABLE, NV_PAUSEFRAME_TX_CAPABLE, NV_PAUSEFRAME_TX_ENABLE, NVREG_MISC1_PAUSE_TX, NVREG_PFF_PAUSE_RX, NVREG_TX_PAUSEFRAME_DISABLE, NVREG_TX_PAUSEFRAME_ENABLE_V1, NVREG_TX_PAUSEFRAME_ENABLE_V2, NVREG_TX_PAUSEFRAME_ENABLE_V3, NVREG_TX_PAUSEFRAMELIMIT_ENABLE, NvRegMisc1, NvRegPacketFilterFlags, NvRegTxPauseFrame, NvRegTxPauseFrameLimit, priv, readl(), and writel().

Referenced by nv_update_linkspeed().

nv_update_linkspeed()

static int nv_update_linkspeed ( struct forcedeth_private *  priv )

static

Definition at line 475 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        int adv = 0;
        int lpa = 0;
        int adv_lpa, adv_pause, lpa_pause;
        u32 newls = priv->linkspeed;
        int newdup = priv->duplex;
        int mii_status;
        int retval = 0;
        u32 control_1000, status_1000, phyreg, pause_flags, txreg;
        u32 txrxFlags = 0;
        u32 phy_exp;

        /* BMSR_LSTATUS is latched, read it twice:
         * we want the current value.
         */
        mii_rw ( priv, priv->phyaddr, MII_BMSR, MII_READ );
        mii_status = mii_rw ( priv, priv->phyaddr, MII_BMSR, MII_READ );

        if ( ! ( mii_status & BMSR_LSTATUS ) ) {
                DBG ( "No link detected by phy - falling back to 10HD.\n" );
                newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_10;
                newdup = 0;
                retval = 0;
                goto set_speed;
        }

        /* check auto negotiation is complete */
        if ( ! ( mii_status & BMSR_ANEGCOMPLETE ) ) {
                /* still in autonegotiation - configure nic for 10 MBit HD and wait. */
                newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_10;
                newdup = 0;
                retval = 0;
                DBG ( "autoneg not completed - falling back to 10HD.\n" );
                goto set_speed;
        }

        adv = mii_rw ( priv, priv->phyaddr, MII_ADVERTISE, MII_READ );
        lpa = mii_rw ( priv, priv->phyaddr, MII_LPA, MII_READ );
        DBG ( "nv_update_linkspeed: PHY advertises 0x%04x, lpa 0x%04x.\n", adv, lpa );

        retval = 1;
        if ( priv->gigabit == PHY_GIGABIT ) {
                control_1000 = mii_rw ( priv, priv->phyaddr, MII_CTRL1000, MII_READ);
                status_1000 = mii_rw ( priv, priv->phyaddr, MII_STAT1000, MII_READ);

                if ( ( control_1000 & ADVERTISE_1000FULL ) &&
                        ( status_1000 & LPA_1000FULL ) ) {
                        DBG ( "nv_update_linkspeed: GBit ethernet detected.\n" );
                        newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_1000;
                        newdup = 1;
                        goto set_speed;
                }
        }

        /* FIXME: handle parallel detection properly */
        adv_lpa = lpa & adv;
        if ( adv_lpa & LPA_100FULL ) {
                newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_100;
                newdup = 1;
        } else if ( adv_lpa & LPA_100HALF ) {
                newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_100;
                newdup = 0;
        } else if ( adv_lpa & LPA_10FULL ) {
                newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_10;
                newdup = 1;
        } else if ( adv_lpa & LPA_10HALF ) {
                newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_10;
                newdup = 0;
        } else {
                DBG ( "bad ability %04x - falling back to 10HD.\n", adv_lpa);
                newls = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_10;
                newdup = 0;
        }

set_speed:
        if ( priv->duplex == newdup && priv->linkspeed == newls )
                return retval;

        DBG ( "changing link setting from %d/%d to %d/%d.\n",
                priv->linkspeed, priv->duplex, newls, newdup);

        priv->duplex = newdup;
        priv->linkspeed = newls;

        /* The transmitter and receiver must be restarted for safe update */
        if ( readl ( ioaddr + NvRegTransmitterControl ) & NVREG_XMITCTL_START ) {
                txrxFlags |= NV_RESTART_TX;
                nv_stop_tx ( priv );
        }
        if ( readl ( ioaddr + NvRegReceiverControl ) & NVREG_RCVCTL_START) {
                txrxFlags |= NV_RESTART_RX;
                nv_stop_rx ( priv );
        }

        if ( priv->gigabit == PHY_GIGABIT ) {
                phyreg = readl ( ioaddr + NvRegSlotTime );
                phyreg &= ~(0x3FF00);
                if ( ( ( priv->linkspeed & 0xFFF ) == NVREG_LINKSPEED_10 ) ||
                     ( ( priv->linkspeed & 0xFFF ) == NVREG_LINKSPEED_100) )
                        phyreg |= NVREG_SLOTTIME_10_100_FULL;
                else if ( ( priv->linkspeed & 0xFFF ) == NVREG_LINKSPEED_1000 )
                        phyreg |= NVREG_SLOTTIME_1000_FULL;
                writel( phyreg, priv + NvRegSlotTime );
        }

        phyreg = readl ( ioaddr + NvRegPhyInterface );
        phyreg &= ~( PHY_HALF | PHY_100 | PHY_1000 );
        if ( priv->duplex == 0 )
                phyreg |= PHY_HALF;
        if ( ( priv->linkspeed & NVREG_LINKSPEED_MASK ) == NVREG_LINKSPEED_100 )
                phyreg |= PHY_100;
        else if ( ( priv->linkspeed & NVREG_LINKSPEED_MASK ) == NVREG_LINKSPEED_1000 )
                phyreg |= PHY_1000;
        writel ( phyreg, ioaddr + NvRegPhyInterface );

        phy_exp = mii_rw ( priv, priv->phyaddr, MII_EXPANSION, MII_READ ) & EXPANSION_NWAY; /* autoneg capable */
        if ( phyreg & PHY_RGMII ) {
                if ( ( priv->linkspeed & NVREG_LINKSPEED_MASK ) == NVREG_LINKSPEED_1000 ) {
                        txreg = NVREG_TX_DEFERRAL_RGMII_1000;
                } else {
                        if ( !phy_exp && !priv->duplex && ( priv->driver_data & DEV_HAS_COLLISION_FIX ) ) {
                                if ( ( priv->linkspeed & NVREG_LINKSPEED_MASK ) == NVREG_LINKSPEED_10 )
                                        txreg = NVREG_TX_DEFERRAL_RGMII_STRETCH_10;
                                else
                                        txreg = NVREG_TX_DEFERRAL_RGMII_STRETCH_100;
                        } else {
                                txreg = NVREG_TX_DEFERRAL_RGMII_10_100;
                        }
                }
        } else {
                if ( !phy_exp && !priv->duplex && ( priv->driver_data & DEV_HAS_COLLISION_FIX ) )
                        txreg = NVREG_TX_DEFERRAL_MII_STRETCH;
                else
                        txreg = NVREG_TX_DEFERRAL_DEFAULT;
        }
        writel ( txreg, ioaddr + NvRegTxDeferral );

        txreg = NVREG_TX_WM_DESC1_DEFAULT;
        writel ( txreg, ioaddr + NvRegTxWatermark );

        writel ( NVREG_MISC1_FORCE | ( priv->duplex ? 0 : NVREG_MISC1_HD ), ioaddr + NvRegMisc1 );
        pci_push ( ioaddr );
        writel ( priv->linkspeed, priv + NvRegLinkSpeed);
        pci_push ( ioaddr );

        pause_flags = 0;
        /* setup pause frame */
        if ( priv->duplex != 0 ) {
                if ( priv->pause_flags & NV_PAUSEFRAME_AUTONEG ) {
                        adv_pause = adv & ( ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM );
                        lpa_pause = lpa & ( LPA_PAUSE_CAP | LPA_PAUSE_ASYM );

                        switch ( adv_pause ) {
                        case ADVERTISE_PAUSE_CAP:
                                if ( lpa_pause & LPA_PAUSE_CAP ) {
                                        pause_flags |= NV_PAUSEFRAME_RX_ENABLE;
                                        if ( priv->pause_flags & NV_PAUSEFRAME_TX_REQ )
                                                pause_flags |= NV_PAUSEFRAME_TX_ENABLE;
                                }
                                break;
                        case ADVERTISE_PAUSE_ASYM:
                                if ( lpa_pause == ( LPA_PAUSE_CAP | LPA_PAUSE_ASYM ) )
                                {
                                        pause_flags |= NV_PAUSEFRAME_TX_ENABLE;
                                }
                                break;
                        case ADVERTISE_PAUSE_CAP| ADVERTISE_PAUSE_ASYM:
                                if ( lpa_pause & LPA_PAUSE_CAP )
                                {
                                        pause_flags |=  NV_PAUSEFRAME_RX_ENABLE;
                                        if ( priv->pause_flags & NV_PAUSEFRAME_TX_REQ )
                                                pause_flags |= NV_PAUSEFRAME_TX_ENABLE;
                                }
                                if ( lpa_pause == LPA_PAUSE_ASYM )
                                {
                                        pause_flags |= NV_PAUSEFRAME_RX_ENABLE;
                                }
                                break;
                        }
                } else {
                        pause_flags = priv->pause_flags;
                }
        }
        nv_update_pause ( priv, pause_flags );

        if ( txrxFlags & NV_RESTART_TX )
                nv_start_tx ( priv );
        if ( txrxFlags & NV_RESTART_RX )
                nv_start_rx ( priv );

        return retval;
}

References ADVERTISE_1000FULL, ADVERTISE_PAUSE_ASYM, ADVERTISE_PAUSE_CAP, BMSR_ANEGCOMPLETE, BMSR_LSTATUS, DBG, DEV_HAS_COLLISION_FIX, tlan_private::duplex, EXPANSION_NWAY, ioaddr, LPA_1000FULL, LPA_100FULL, LPA_100HALF, LPA_10FULL, LPA_10HALF, LPA_PAUSE_ASYM, LPA_PAUSE_CAP, MII_ADVERTISE, MII_BMSR, MII_CTRL1000, MII_EXPANSION, MII_LPA, MII_READ, mii_rw(), MII_STAT1000, NV_PAUSEFRAME_AUTONEG, NV_PAUSEFRAME_RX_ENABLE, NV_PAUSEFRAME_TX_ENABLE, NV_PAUSEFRAME_TX_REQ, NV_RESTART_RX, NV_RESTART_TX, nv_start_rx(), nv_start_tx(), nv_stop_rx(), nv_stop_tx(), nv_update_pause(), NVREG_LINKSPEED_10, NVREG_LINKSPEED_100, NVREG_LINKSPEED_1000, NVREG_LINKSPEED_FORCE, NVREG_LINKSPEED_MASK, NVREG_MISC1_FORCE, NVREG_MISC1_HD, NVREG_RCVCTL_START, NVREG_SLOTTIME_1000_FULL, NVREG_SLOTTIME_10_100_FULL, NVREG_TX_DEFERRAL_DEFAULT, NVREG_TX_DEFERRAL_MII_STRETCH, NVREG_TX_DEFERRAL_RGMII_1000, NVREG_TX_DEFERRAL_RGMII_10_100, NVREG_TX_DEFERRAL_RGMII_STRETCH_10, NVREG_TX_DEFERRAL_RGMII_STRETCH_100, NVREG_TX_WM_DESC1_DEFAULT, NVREG_XMITCTL_START, NvRegLinkSpeed, NvRegMisc1, NvRegPhyInterface, NvRegReceiverControl, NvRegSlotTime, NvRegTransmitterControl, NvRegTxDeferral, NvRegTxWatermark, pci_push(), PHY_100, PHY_1000, PHY_GIGABIT, PHY_HALF, PHY_RGMII, priv, readl(), retval, and writel().

Referenced by forcedeth_link_status(), and forcedeth_open().

forcedeth_open()

static int forcedeth_open ( struct net_device *  netdev )

static

open - Called when a network interface is made active

Parameters

netdev

Network device

Return values

rc	Return status code, 0 on success, negative value on failure

Definition at line 678 of file forcedeth.c.

{
        struct forcedeth_private *priv = netdev->priv;
        void *ioaddr = priv->mmio_addr;
        int i;
        int rc;
        u32 low;

        DBGP ( "forcedeth_open\n" );

        /* Power up phy */
        mii_rw ( priv, priv->phyaddr, MII_BMCR,
                 mii_rw ( priv, priv->phyaddr, MII_BMCR, MII_READ ) & ~BMCR_PDOWN );

        nv_txrx_gate ( priv, 0 );

        /* Erase previous misconfiguration */
        if ( priv->driver_data & DEV_HAS_POWER_CNTRL )
                nv_mac_reset ( priv );

        /* Clear multicast masks and addresses, enter promiscuous mode */
        writel ( 0, ioaddr + NvRegMulticastAddrA );
        writel ( 0, ioaddr + NvRegMulticastAddrB );
        writel ( NVREG_MCASTMASKA_NONE, ioaddr + NvRegMulticastMaskA );
        writel ( NVREG_MCASTMASKB_NONE, ioaddr + NvRegMulticastMaskB );
        writel ( NVREG_PFF_PROMISC, ioaddr + NvRegPacketFilterFlags );

        writel ( 0, ioaddr + NvRegTransmitterControl );
        writel ( 0, ioaddr + NvRegReceiverControl );

        writel ( 0, ioaddr + NvRegAdapterControl );

        writel ( 0, ioaddr + NvRegLinkSpeed );
        writel ( readl ( ioaddr + NvRegTransmitPoll ) & NVREG_TRANSMITPOLL_MAC_ADDR_REV,
                 ioaddr + NvRegTransmitPoll );
        nv_txrx_reset ( priv );
        writel ( 0, ioaddr + NvRegUnknownSetupReg6 );

        /* Initialize descriptor rings */
        if ( ( rc = nv_init_rings ( priv ) ) != 0 )
                goto err_init_rings;

        writel ( priv->linkspeed, ioaddr + NvRegLinkSpeed );
        writel ( NVREG_TX_WM_DESC1_DEFAULT, ioaddr + NvRegTxWatermark );
        writel ( NVREG_TXRXCTL_DESC_1, ioaddr + NvRegTxRxControl );
        writel ( 0 , ioaddr + NvRegVlanControl );
        pci_push ( ioaddr );
        writel ( NVREG_TXRXCTL_BIT1 | NVREG_TXRXCTL_DESC_1,
                 ioaddr + NvRegTxRxControl );
        reg_delay ( priv, NvRegUnknownSetupReg5, NVREG_UNKSETUP5_BIT31,
                    NVREG_UNKSETUP5_BIT31, NV_SETUP5_DELAY, NV_SETUP5_DELAYMAX,
                    "open: SetupReg5, Bit 31 remained off\n" );

        writel ( 0, ioaddr + NvRegMIIMask );
        writel ( NVREG_IRQSTAT_MASK, ioaddr + NvRegIrqStatus );
        writel ( NVREG_MIISTAT_MASK_ALL, ioaddr + NvRegMIIStatus );

        writel ( NVREG_MISC1_FORCE | NVREG_MISC1_HD, ioaddr + NvRegMisc1 );
        writel ( readl ( ioaddr + NvRegTransmitterStatus ),
                 ioaddr + NvRegTransmitterStatus );
        writel ( RX_BUF_SZ, ioaddr + NvRegOffloadConfig );

        writel ( readl ( ioaddr + NvRegReceiverStatus),
                 ioaddr + NvRegReceiverStatus );

        /* Set up slot time */
        low = ( random() & NVREG_SLOTTIME_MASK );
        writel ( low | NVREG_SLOTTIME_DEFAULT, ioaddr + NvRegSlotTime );

        writel ( NVREG_TX_DEFERRAL_DEFAULT , ioaddr + NvRegTxDeferral );
        writel ( NVREG_RX_DEFERRAL_DEFAULT , ioaddr + NvRegRxDeferral );

        writel ( NVREG_POLL_DEFAULT_THROUGHPUT, ioaddr + NvRegPollingInterval );

        writel ( NVREG_UNKSETUP6_VAL, ioaddr + NvRegUnknownSetupReg6 );
        writel ( ( priv->phyaddr << NVREG_ADAPTCTL_PHYSHIFT ) |
                 NVREG_ADAPTCTL_PHYVALID | NVREG_ADAPTCTL_RUNNING,
                 ioaddr + NvRegAdapterControl );
        writel ( NVREG_MIISPEED_BIT8 | NVREG_MIIDELAY, ioaddr + NvRegMIISpeed );
        writel ( NVREG_MII_LINKCHANGE, ioaddr + NvRegMIIMask );

        i = readl ( ioaddr + NvRegPowerState );
        if ( ( i & NVREG_POWERSTATE_POWEREDUP ) == 0 )
                writel ( NVREG_POWERSTATE_POWEREDUP | i, ioaddr + NvRegPowerState );

        pci_push ( ioaddr );
        udelay ( 10 );
        writel ( readl ( ioaddr + NvRegPowerState ) | NVREG_POWERSTATE_VALID,
                 ioaddr + NvRegPowerState );

        nv_disable_hw_interrupts ( priv );
        writel ( NVREG_MIISTAT_MASK_ALL, ioaddr + NvRegMIIStatus );
        writel ( NVREG_IRQSTAT_MASK, ioaddr + NvRegIrqStatus );
        pci_push ( ioaddr );

        readl ( ioaddr + NvRegMIIStatus );
        writel ( NVREG_MIISTAT_MASK_ALL, ioaddr + NvRegMIIStatus );
        priv->linkspeed = 0;
        nv_update_linkspeed ( priv );
        nv_start_rx ( priv );
        nv_start_tx ( priv );

        return 0;

err_init_rings:
        return rc;
}

References BMCR_PDOWN, DBGP, DEV_HAS_POWER_CNTRL, ioaddr, low, MII_BMCR, MII_READ, mii_rw(), netdev, nv_disable_hw_interrupts(), nv_init_rings(), nv_mac_reset(), NV_SETUP5_DELAY, NV_SETUP5_DELAYMAX, nv_start_rx(), nv_start_tx(), nv_txrx_gate(), nv_txrx_reset(), nv_update_linkspeed(), NVREG_ADAPTCTL_PHYSHIFT, NVREG_ADAPTCTL_PHYVALID, NVREG_ADAPTCTL_RUNNING, NVREG_IRQSTAT_MASK, NVREG_MCASTMASKA_NONE, NVREG_MCASTMASKB_NONE, NVREG_MII_LINKCHANGE, NVREG_MIIDELAY, NVREG_MIISPEED_BIT8, NVREG_MIISTAT_MASK_ALL, NVREG_MISC1_FORCE, NVREG_MISC1_HD, NVREG_PFF_PROMISC, NVREG_POLL_DEFAULT_THROUGHPUT, NVREG_POWERSTATE_POWEREDUP, NVREG_POWERSTATE_VALID, NVREG_RX_DEFERRAL_DEFAULT, NVREG_SLOTTIME_DEFAULT, NVREG_SLOTTIME_MASK, NVREG_TRANSMITPOLL_MAC_ADDR_REV, NVREG_TX_DEFERRAL_DEFAULT, NVREG_TX_WM_DESC1_DEFAULT, NVREG_TXRXCTL_BIT1, NVREG_TXRXCTL_DESC_1, NVREG_UNKSETUP5_BIT31, NVREG_UNKSETUP6_VAL, NvRegAdapterControl, NvRegIrqStatus, NvRegLinkSpeed, NvRegMIIMask, NvRegMIISpeed, NvRegMIIStatus, NvRegMisc1, NvRegMulticastAddrA, NvRegMulticastAddrB, NvRegMulticastMaskA, NvRegMulticastMaskB, NvRegOffloadConfig, NvRegPacketFilterFlags, NvRegPollingInterval, NvRegPowerState, NvRegReceiverControl, NvRegReceiverStatus, NvRegRxDeferral, NvRegSlotTime, NvRegTransmitPoll, NvRegTransmitterControl, NvRegTransmitterStatus, NvRegTxDeferral, NvRegTxRxControl, NvRegTxWatermark, NvRegUnknownSetupReg5, NvRegUnknownSetupReg6, NvRegVlanControl, pci_push(), priv, net_device::priv, random(), rc, readl(), reg_delay(), RX_BUF_SZ, udelay(), and writel().

forcedeth_transmit()

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

static

transmit - Transmit a packet

Parameters

netdev	Network device
iobuf	I/O buffer

Return values

rc	Returns 0 on success, negative on failure

Definition at line 795 of file forcedeth.c.

{
        struct forcedeth_private *priv = netdev->priv;
        void *ioaddr = priv->mmio_addr;
        struct ring_desc *tx_curr_desc;
        u32 size = iob_len ( iobuf );

        DBGP ( "forcedeth_transmit\n" );

        /* NOTE: Some NICs have a hw bug that causes them to malfunction
         * when there are more than 16 outstanding TXs. Increasing the TX
         * ring size might trigger this bug */
        if ( priv->tx_fill_ctr == TX_RING_SIZE ) {
                DBG ( "Tx overflow\n" );
                return -ENOBUFS;
        }

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

        priv->tx_iobuf[priv->tx_curr] = iobuf;

        tx_curr_desc = priv->tx_ring + priv->tx_curr;

        /* Configure current descriptor to transmit packet
         * ( NV_TX_VALID sets the ownership bit ) */
        tx_curr_desc->buf =
                cpu_to_le32 ( virt_to_bus ( iobuf->data ) );
        wmb();
        /* Since we don't do fragmentation offloading, we always have
         * the last packet bit set */
        tx_curr_desc->flaglen =
                cpu_to_le32 ( ( size - 1 ) | NV_TX_VALID | NV_TX_LASTPACKET );

        DBG ( "forcedeth_transmit: flaglen = %#04x\n",
                ( size - 1 ) | NV_TX_VALID | NV_TX_LASTPACKET );
        DBG ( "forcedeth_transmit: tx_fill_ctr = %d\n",
                priv->tx_fill_ctr );

        writel ( NVREG_TXRXCTL_KICK | NVREG_TXRXCTL_DESC_1,
                 ioaddr + NvRegTxRxControl );
        pci_push ( ioaddr );

        /* Point to the next free descriptor */
        priv->tx_curr = ( priv->tx_curr + 1 ) % TX_RING_SIZE;

        /* Increment number of descriptors in use */
        priv->tx_fill_ctr++;

        return 0;
}

References ring_desc::buf, cpu_to_le32, io_buffer::data, DBG, DBGP, ENOBUFS, ETH_ZLEN, ring_desc::flaglen, ioaddr, iob_len(), iob_pad(), netdev, NV_TX_LASTPACKET, NV_TX_VALID, NVREG_TXRXCTL_DESC_1, NVREG_TXRXCTL_KICK, NvRegTxRxControl, pci_push(), priv, net_device::priv, size, TX_RING_SIZE, virt_to_bus(), wmb(), and writel().

nv_process_tx_packets()

static void nv_process_tx_packets ( struct net_device *  netdev )

static

nv_process_tx_packets - Checks for successfully sent packets, reports them to iPXE with netdev_tx_complete()

Parameters

netdev

Network device

Definition at line 854 of file forcedeth.c.

{
        struct forcedeth_private *priv = netdev->priv;
        struct ring_desc *tx_curr_desc;
        u32 flaglen;

        DBGP ( "nv_process_tx_packets\n" );

        while ( priv->tx_tail != priv->tx_curr ) {

                tx_curr_desc = priv->tx_ring + priv->tx_tail;
                flaglen = le32_to_cpu ( tx_curr_desc->flaglen );
                rmb();

                /* Skip this descriptor if hardware still owns it */
                if ( flaglen & NV_TX_VALID )
                        break;

                DBG ( "Transmitted packet.\n" );
                DBG ( "priv->tx_fill_ctr= %d\n", priv->tx_fill_ctr );
                DBG ( "priv->tx_tail    = %d\n", priv->tx_tail );
                DBG ( "priv->tx_curr    = %d\n", priv->tx_curr );
                DBG ( "flaglen          = %#04x\n", flaglen );

                /* This packet is ready for completion */
                netdev_tx_complete ( netdev, priv->tx_iobuf[priv->tx_tail] );

                /* Clear the descriptor */
                memset ( tx_curr_desc, 0, sizeof(*tx_curr_desc) );

                /* Reduce the number of tx descriptors in use */
                priv->tx_fill_ctr--;

                /* Go to next available descriptor */
                priv->tx_tail = ( priv->tx_tail + 1 ) % TX_RING_SIZE;
        }
}

References DBG, DBGP, ring_desc::flaglen, le32_to_cpu, memset(), netdev, netdev_tx_complete(), NV_TX_VALID, priv, net_device::priv, rmb, and TX_RING_SIZE.

Referenced by forcedeth_poll().

nv_process_rx_packets()

static void nv_process_rx_packets ( struct net_device *  netdev )

static

nv_process_rx_packets - Checks for received packets, reports them to iPXE with netdev_rx() or netdev_rx_err() if there was an error receiving the packet

Parameters

netdev

Network device

Definition at line 900 of file forcedeth.c.

{
        struct forcedeth_private *priv = netdev->priv;
        struct io_buffer *curr_iob;
        struct ring_desc *rx_curr_desc;
        u32 flags, len;
        int i;

        DBGP ( "nv_process_rx_packets\n" );

        for ( i = 0; i < RX_RING_SIZE; i++ ) {

                rx_curr_desc = priv->rx_ring + priv->rx_curr;
                flags = le32_to_cpu ( rx_curr_desc->flaglen );
                rmb();

                /* Skip this descriptor if hardware still owns it */
                if ( flags & NV_RX_AVAIL )
                        break;

                /* We own the descriptor, but it has not been refilled yet */
                curr_iob = priv->rx_iobuf[priv->rx_curr];
                DBG ( "%p %p\n", curr_iob, priv->rx_iobuf[priv->rx_curr] );
                if ( curr_iob == NULL )
                        break;

                DBG ( "Received packet.\n" );
                DBG ( "priv->rx_curr    = %d\n", priv->rx_curr );
                DBG ( "flags            = %#04x\n", flags );

                /* Check for errors */
                if ( ( flags & NV_RX_DESCRIPTORVALID ) &&
                     ( flags & NV_RX_ERROR ) ) {
                                netdev_rx_err ( netdev, curr_iob, -EINVAL );
                                DBG ( " Corrupted packet received!\n" );
                } else {
                        len = flags & LEN_MASK_V1;

                        iob_put ( curr_iob, len );
                        netdev_rx ( netdev, curr_iob );
                }

                /* Invalidate iobuf */
                priv->rx_iobuf[priv->rx_curr] = NULL;

                /* Invalidate descriptor */
                memset ( rx_curr_desc, 0, sizeof(*rx_curr_desc) );

                /* Point to the next free descriptor */
                priv->rx_curr = ( priv->rx_curr + 1 ) % RX_RING_SIZE;
        }

        nv_alloc_rx ( priv );
}

References DBG, DBGP, EINVAL, ring_desc::flaglen, flags, iob_put, le32_to_cpu, len, LEN_MASK_V1, memset(), netdev, netdev_rx(), netdev_rx_err(), NULL, nv_alloc_rx(), NV_RX_AVAIL, NV_RX_DESCRIPTORVALID, NV_RX_ERROR, priv, net_device::priv, rmb, and RX_RING_SIZE.

Referenced by forcedeth_poll().

forcedeth_link_status()

static void forcedeth_link_status ( struct net_device *  netdev )

static

check_link - Check for link status change

Parameters

netdev

Network device

Definition at line 961 of file forcedeth.c.

{
        struct forcedeth_private *priv = netdev->priv;
        void *ioaddr = priv->mmio_addr;

        /* Clear the MII link change status by reading the MIIStatus register */
        readl ( ioaddr + NvRegMIIStatus );
        writel ( NVREG_MIISTAT_LINKCHANGE, ioaddr + NvRegMIIStatus );

        if ( nv_update_linkspeed ( priv ) == 1 )
                netdev_link_up ( netdev );
        else
                netdev_link_down ( netdev );
}

References ioaddr, netdev, netdev_link_down(), netdev_link_up(), nv_update_linkspeed(), NVREG_MIISTAT_LINKCHANGE, NvRegMIIStatus, priv, net_device::priv, readl(), and writel().

Referenced by forcedeth_poll(), and forcedeth_probe().

forcedeth_poll()

static void forcedeth_poll ( struct net_device *  netdev )

static

poll - Poll for received packets

Parameters

netdev

Network device

Definition at line 982 of file forcedeth.c.

{
        struct forcedeth_private *priv = netdev->priv;
        void *ioaddr = priv->mmio_addr;
        u32 status;

        DBGP ( "forcedeth_poll\n" );

        status = readl ( ioaddr + NvRegIrqStatus ) & NVREG_IRQSTAT_MASK;

        /* Return when no interrupts have been triggered */
        if ( ! status )
                return;

        /* Clear interrupts */
        writel ( NVREG_IRQSTAT_MASK, ioaddr + NvRegIrqStatus );

        DBG ( "forcedeth_poll: status = %#04x\n", status );

        /* Link change interrupt occurred. Call always if link is down,
         * to give auto-neg a chance to finish */
        if ( ( status & NVREG_IRQ_LINK ) || ! ( netdev_link_ok ( netdev ) ) )
                forcedeth_link_status ( netdev );

        /* Process transmitted packets */
        nv_process_tx_packets ( netdev );

        /* Process received packets */
        nv_process_rx_packets ( netdev );
}

References DBG, DBGP, forcedeth_link_status(), ioaddr, netdev, netdev_link_ok(), nv_process_rx_packets(), nv_process_tx_packets(), NVREG_IRQ_LINK, NVREG_IRQSTAT_MASK, NvRegIrqStatus, priv, net_device::priv, readl(), status, and writel().

forcedeth_close()

static void forcedeth_close ( struct net_device *  netdev )

static

close - Disable network interface

Parameters

netdev

network interface device structure

Definition at line 1019 of file forcedeth.c.

{
        struct forcedeth_private *priv = netdev->priv;

        DBGP ( "forcedeth_close\n" );

        nv_stop_rx ( priv );
        nv_stop_tx ( priv );
        nv_txrx_reset ( priv );

        /* Disable interrupts on the nic or we will lock up */
        nv_disable_hw_interrupts ( priv );

        nv_free_rxtx_resources ( priv );

        nv_txrx_gate ( priv, 0 );

        /* FIXME: power down nic */
}

References DBGP, netdev, nv_disable_hw_interrupts(), nv_free_rxtx_resources(), nv_stop_rx(), nv_stop_tx(), nv_txrx_gate(), nv_txrx_reset(), priv, and net_device::priv.

forcedeth_irq()

static void forcedeth_irq ( struct net_device *  netdev, int  action  )

static

irq - enable or disable interrupts

Parameters

netdev	network adapter
action	requested interrupt action

Definition at line 1046 of file forcedeth.c.

{
        struct forcedeth_private *priv = netdev->priv;

        DBGP ( "forcedeth_irq\n" );

        switch ( action ) {
        case 0:
                nv_disable_hw_interrupts ( priv );
                break;
        default:
                nv_enable_hw_interrupts ( priv );
                break;
        }
}

References DBGP, netdev, nv_disable_hw_interrupts(), nv_enable_hw_interrupts(), priv, and net_device::priv.

nv_setup_mac_addr()

static int nv_setup_mac_addr ( struct forcedeth_private *  priv )

static

Definition at line 1071 of file forcedeth.c.

{
        struct net_device *dev = priv->netdev;
        void *ioaddr = priv->mmio_addr;
        u32 orig_mac[2];
        u32 txreg;

        orig_mac[0] = readl ( ioaddr + NvRegMacAddrA );
        orig_mac[1] = readl ( ioaddr + NvRegMacAddrB );

        txreg = readl ( ioaddr + NvRegTransmitPoll );

        if ( ( priv->driver_data & DEV_HAS_CORRECT_MACADDR ) ||
             ( txreg & NVREG_TRANSMITPOLL_MAC_ADDR_REV ) ) {
                /* mac address is already in correct order */
                dev->hw_addr[0] = ( orig_mac[0] >> 0 ) & 0xff;
                dev->hw_addr[1] = ( orig_mac[0] >> 8 ) & 0xff;
                dev->hw_addr[2] = ( orig_mac[0] >> 16 ) & 0xff;
                dev->hw_addr[3] = ( orig_mac[0] >> 24 ) & 0xff;
                dev->hw_addr[4] = ( orig_mac[1] >> 0 ) & 0xff;
                dev->hw_addr[5] = ( orig_mac[1] >> 8 ) & 0xff;
        } else {
                /* need to reverse mac address to correct order */
                dev->hw_addr[0] = ( orig_mac[1] >> 8 ) & 0xff;
                dev->hw_addr[1] = ( orig_mac[1] >> 0 ) & 0xff;
                dev->hw_addr[2] = ( orig_mac[0] >> 24 ) & 0xff;
                dev->hw_addr[3] = ( orig_mac[0] >> 16 ) & 0xff;
                dev->hw_addr[4] = ( orig_mac[0] >> 8 ) & 0xff;
                dev->hw_addr[5] = ( orig_mac[0] >> 0 ) & 0xff;
        }

        if ( ! is_valid_ether_addr ( dev->hw_addr ) )
                return -EADDRNOTAVAIL;

        DBG ( "MAC address is: %s\n", eth_ntoa ( dev->hw_addr ) );

        return 0;
}

References DBG, net_device::dev, DEV_HAS_CORRECT_MACADDR, EADDRNOTAVAIL, eth_ntoa(), ioaddr, is_valid_ether_addr(), NVREG_TRANSMITPOLL_MAC_ADDR_REV, NvRegMacAddrA, NvRegMacAddrB, NvRegTransmitPoll, priv, and readl().

Referenced by forcedeth_probe().

nv_mgmt_acquire_sema()

static int nv_mgmt_acquire_sema ( struct forcedeth_private *  priv )

static

Definition at line 1111 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        int i;
        u32 tx_ctrl, mgmt_sema;

        for ( i = 0; i < 10; i++ ) {
                mgmt_sema = readl ( ioaddr + NvRegTransmitterControl ) &
                        NVREG_XMITCTL_MGMT_SEMA_MASK;
                if ( mgmt_sema == NVREG_XMITCTL_MGMT_SEMA_FREE )
                        break;
                mdelay ( 500 );
        }

        if ( mgmt_sema != NVREG_XMITCTL_MGMT_SEMA_FREE )
                return 0;

        for ( i = 0; i < 2; i++ ) {
                tx_ctrl = readl ( ioaddr + NvRegTransmitterControl );
                tx_ctrl |= NVREG_XMITCTL_HOST_SEMA_ACQ;
                writel ( tx_ctrl, ioaddr + NvRegTransmitterControl );

                /* verify that the semaphore was acquired */
                tx_ctrl = readl ( ioaddr + NvRegTransmitterControl );
                if ( ( ( tx_ctrl & NVREG_XMITCTL_HOST_SEMA_MASK ) ==
                       NVREG_XMITCTL_HOST_SEMA_ACQ ) &&
                     ( ( tx_ctrl & NVREG_XMITCTL_MGMT_SEMA_MASK ) ==
                       NVREG_XMITCTL_MGMT_SEMA_FREE ) ) {
                        priv->mgmt_sema = 1;
                        return 1;
                } else {
                        udelay ( 50 );
                }
        }

        return 0;
}

References ioaddr, mdelay(), NVREG_XMITCTL_HOST_SEMA_ACQ, NVREG_XMITCTL_HOST_SEMA_MASK, NVREG_XMITCTL_MGMT_SEMA_FREE, NVREG_XMITCTL_MGMT_SEMA_MASK, NvRegTransmitterControl, priv, readl(), udelay(), and writel().

Referenced by nv_setup_phy().

nv_mgmt_release_sema()

static void nv_mgmt_release_sema ( struct forcedeth_private *  priv )

static

Definition at line 1150 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        u32 tx_ctrl;

        if ( priv->driver_data & DEV_HAS_MGMT_UNIT ) {
                if ( priv->mgmt_sema ) {
                        tx_ctrl = readl (ioaddr + NvRegTransmitterControl );
                        tx_ctrl &= ~NVREG_XMITCTL_HOST_SEMA_ACQ;
                        writel ( tx_ctrl, ioaddr + NvRegTransmitterControl );
                }
        }
}

References DEV_HAS_MGMT_UNIT, ioaddr, NVREG_XMITCTL_HOST_SEMA_ACQ, NvRegTransmitterControl, priv, readl(), and writel().

Referenced by forcedeth_remove().

nv_mgmt_get_version()

static int nv_mgmt_get_version ( struct forcedeth_private *  priv )

static

Definition at line 1165 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        u32 data_ready = readl ( ioaddr + NvRegTransmitterControl );
        u32 data_ready2 = 0;
        unsigned long start;
        int ready = 0;

        writel ( NVREG_MGMTUNITGETVERSION,
                ioaddr + NvRegMgmtUnitGetVersion );
        writel ( data_ready ^ NVREG_XMITCTL_DATA_START,
                ioaddr + NvRegTransmitterControl );
        start = currticks();

        while ( currticks() > start + 5 * TICKS_PER_SEC ) {
                data_ready2 = readl ( ioaddr + NvRegTransmitterControl );
                if ( ( data_ready & NVREG_XMITCTL_DATA_READY ) !=
                     ( data_ready2 & NVREG_XMITCTL_DATA_READY ) ) {
                        ready = 1;
                        break;
                }
                mdelay ( 1000 );
        }

        if ( ! ready || ( data_ready2 & NVREG_XMITCTL_DATA_ERROR ) )
                return 0;

        priv->mgmt_version =
                readl ( ioaddr + NvRegMgmtUnitVersion ) & NVREG_MGMTUNITVERSION;

        return 1;
}

References currticks(), ioaddr, mdelay(), NVREG_MGMTUNITGETVERSION, NVREG_MGMTUNITVERSION, NVREG_XMITCTL_DATA_ERROR, NVREG_XMITCTL_DATA_READY, NVREG_XMITCTL_DATA_START, NvRegMgmtUnitGetVersion, NvRegMgmtUnitVersion, NvRegTransmitterControl, priv, readl(), start, TICKS_PER_SEC, and writel().

Referenced by nv_setup_phy().

phy_reset()

static int phy_reset ( struct forcedeth_private *  priv, u32  bmcr_setup  )

static

Definition at line 1201 of file forcedeth.c.

{
        u32 miicontrol;
        unsigned int tries = 0;

        miicontrol = BMCR_RESET | bmcr_setup;
        if ( mii_rw ( priv, priv->phyaddr, MII_BMCR, miicontrol ) ) {
                return -1;
        }

        mdelay ( 500 );

        /* must wait till reset is deasserted */
        while ( miicontrol & BMCR_RESET ) {
                mdelay ( 10 );
                miicontrol = mii_rw ( priv, priv->phyaddr, MII_BMCR, MII_READ );
                if ( tries++ > 100 )
                        return -1;
        }
        return 0;
}

References BMCR_RESET, mdelay(), MII_BMCR, MII_READ, mii_rw(), and priv.

Referenced by phy_init().

phy_init()

static int phy_init ( struct forcedeth_private *  priv )

static

Definition at line 1224 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        u32 phyinterface, phy_reserved, mii_status;
        u32 mii_control, mii_control_1000, reg;

        /* phy errata for E3016 phy */
        if ( priv->phy_model == PHY_MODEL_MARVELL_E3016 ) {
                reg = mii_rw ( priv, priv->phyaddr, MII_NCONFIG, MII_READ );
                reg &= ~PHY_MARVELL_E3016_INITMASK;
                if ( mii_rw ( priv, priv->phyaddr, MII_NCONFIG, reg ) ) {
                        DBG ( "PHY write to errata reg failed.\n" );
                        return PHY_ERROR;
                }
        }

        if ( priv->phy_oui == PHY_OUI_REALTEK ) {
                if ( priv->phy_model == PHY_MODEL_REALTEK_8211 &&
                     priv->phy_rev == PHY_REV_REALTEK_8211B ) {
                        if ( mii_rw ( priv, priv->phyaddr,
                                PHY_REALTEK_INIT_REG1, PHY_REALTEK_INIT1 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                PHY_REALTEK_INIT_REG2, PHY_REALTEK_INIT2 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                PHY_REALTEK_INIT_REG1, PHY_REALTEK_INIT3 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                PHY_REALTEK_INIT_REG3, PHY_REALTEK_INIT4 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                PHY_REALTEK_INIT_REG4, PHY_REALTEK_INIT5 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                PHY_REALTEK_INIT_REG5, PHY_REALTEK_INIT6 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                PHY_REALTEK_INIT_REG1, PHY_REALTEK_INIT1 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                }

                if ( priv->phy_model == PHY_MODEL_REALTEK_8211 &&
                     priv->phy_rev == PHY_REV_REALTEK_8211C ) {
                        u32 powerstate = readl ( ioaddr + NvRegPowerState2 );

                        /* need to perform hw phy reset */
                        powerstate |= NVREG_POWERSTATE2_PHY_RESET;
                        writel ( powerstate , ioaddr + NvRegPowerState2 );
                        mdelay ( 25 );

                        powerstate &= ~NVREG_POWERSTATE2_PHY_RESET;
                        writel ( powerstate , ioaddr + NvRegPowerState2 );
                        mdelay ( 25 );

                        reg = mii_rw ( priv, priv->phyaddr,
                                PHY_REALTEK_INIT_REG6, MII_READ );
                        reg |= PHY_REALTEK_INIT9;
                        if ( mii_rw ( priv, priv->phyaddr,
                                PHY_REALTEK_INIT_REG6, reg ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                PHY_REALTEK_INIT_REG1, PHY_REALTEK_INIT10 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }

                        reg = mii_rw ( priv, priv->phyaddr,
                                PHY_REALTEK_INIT_REG7, MII_READ );
                        if ( ! ( reg & PHY_REALTEK_INIT11 ) ) {
                                reg |= PHY_REALTEK_INIT11;
                                if ( mii_rw ( priv, priv->phyaddr,
                                        PHY_REALTEK_INIT_REG7, reg ) ) {
                                        DBG ( "PHY init failed.\n" );
                                        return PHY_ERROR;
                                }
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                PHY_REALTEK_INIT_REG1, PHY_REALTEK_INIT1 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                }
                if ( priv->phy_model == PHY_MODEL_REALTEK_8201 ) {
                        if ( priv->driver_data & DEV_NEED_PHY_INIT_FIX ) {
                                phy_reserved = mii_rw ( priv, priv->phyaddr,
                                                        PHY_REALTEK_INIT_REG6,
                                                        MII_READ );
                                phy_reserved |= PHY_REALTEK_INIT7;
                                if ( mii_rw ( priv, priv->phyaddr,
                                              PHY_REALTEK_INIT_REG6,
                                              phy_reserved ) ) {
                                        DBG ( "PHY init failed.\n" );
                                        return PHY_ERROR;
                                }
                        }
                }
        }

        /* set advertise register */
        reg = mii_rw ( priv, priv->phyaddr, MII_ADVERTISE, MII_READ );
        reg |= ( ADVERTISE_10HALF | ADVERTISE_10FULL | ADVERTISE_100HALF |
                 ADVERTISE_100FULL | ADVERTISE_PAUSE_ASYM | ADVERTISE_PAUSE_CAP );
        if ( mii_rw ( priv, priv->phyaddr, MII_ADVERTISE, reg ) ) {
                DBG ( "PHY init failed.\n" );
                return PHY_ERROR;
        }

        /* get phy interface type */
        phyinterface = readl ( ioaddr + NvRegPhyInterface );

        /* see if gigabit phy */
        mii_status = mii_rw ( priv, priv->phyaddr, MII_BMSR, MII_READ );
        if ( mii_status & PHY_GIGABIT ) {
                priv->gigabit = PHY_GIGABIT;
                mii_control_1000 =
                        mii_rw ( priv, priv->phyaddr, MII_CTRL1000, MII_READ );
                mii_control_1000 &= ~ADVERTISE_1000HALF;
                if ( phyinterface & PHY_RGMII )
                        mii_control_1000 |= ADVERTISE_1000FULL;
                else
                        mii_control_1000 &= ~ADVERTISE_1000FULL;

                if ( mii_rw ( priv, priv->phyaddr, MII_CTRL1000, mii_control_1000)) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
        } else {
                priv->gigabit = 0;
        }

        mii_control = mii_rw ( priv, priv->phyaddr, MII_BMCR, MII_READ );
        mii_control |= BMCR_ANENABLE;

        if ( priv->phy_oui == PHY_OUI_REALTEK &&
             priv->phy_model == PHY_MODEL_REALTEK_8211 &&
             priv->phy_rev == PHY_REV_REALTEK_8211C ) {
                /* start autoneg since we already performed hw reset above */
                mii_control |= BMCR_ANRESTART;
                if ( mii_rw ( priv, priv->phyaddr, MII_BMCR, mii_control ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
        } else {
                /* reset the phy
                 * (certain phys need bmcr to be setup with reset )
                 */
                if ( phy_reset ( priv, mii_control ) ) {
                        DBG ( "PHY reset failed\n" );
                        return PHY_ERROR;
                }
        }

        /* phy vendor specific configuration */
        if ( ( priv->phy_oui == PHY_OUI_CICADA ) && ( phyinterface & PHY_RGMII ) ) {
                phy_reserved = mii_rw ( priv, priv->phyaddr, MII_RESV1, MII_READ );
                phy_reserved &= ~( PHY_CICADA_INIT1 | PHY_CICADA_INIT2 );
                phy_reserved |= ( PHY_CICADA_INIT3 | PHY_CICADA_INIT4 );
                if ( mii_rw ( priv, priv->phyaddr, MII_RESV1, phy_reserved ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                phy_reserved = mii_rw ( priv, priv->phyaddr, MII_NCONFIG, MII_READ );
                phy_reserved |= PHY_CICADA_INIT5;
                if ( mii_rw ( priv, priv->phyaddr, MII_NCONFIG, phy_reserved ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
        }
        if ( priv->phy_oui == PHY_OUI_CICADA ) {
                phy_reserved = mii_rw ( priv, priv->phyaddr, MII_SREVISION, MII_READ );
                phy_reserved |= PHY_CICADA_INIT6;
                if ( mii_rw ( priv, priv->phyaddr, MII_SREVISION, phy_reserved ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
        }
        if ( priv->phy_oui == PHY_OUI_VITESSE ) {
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG1,
                                                   PHY_VITESSE_INIT1)) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG2,
                                                   PHY_VITESSE_INIT2)) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                phy_reserved = mii_rw ( priv, priv->phyaddr,
                                        PHY_VITESSE_INIT_REG4, MII_READ);
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG4,
                                                   phy_reserved ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                phy_reserved = mii_rw ( priv, priv->phyaddr,
                                        PHY_VITESSE_INIT_REG3, MII_READ);
                phy_reserved &= ~PHY_VITESSE_INIT_MSK1;
                phy_reserved |= PHY_VITESSE_INIT3;
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG3,
                                                   phy_reserved ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG2,
                                                   PHY_VITESSE_INIT4 ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG2,
                                                   PHY_VITESSE_INIT5 ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                phy_reserved = mii_rw ( priv, priv->phyaddr,
                                        PHY_VITESSE_INIT_REG4, MII_READ);
                phy_reserved &= ~PHY_VITESSE_INIT_MSK1;
                phy_reserved |= PHY_VITESSE_INIT3;
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG4,
                                                   phy_reserved ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                phy_reserved = mii_rw ( priv, priv->phyaddr,
                                        PHY_VITESSE_INIT_REG3, MII_READ);
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG3,
                                                   phy_reserved ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG2,
                                                   PHY_VITESSE_INIT6 ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG2,
                                                   PHY_VITESSE_INIT7 ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                phy_reserved = mii_rw ( priv, priv->phyaddr,
                                        PHY_VITESSE_INIT_REG4, MII_READ);
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG4,
                                                   phy_reserved ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                phy_reserved = mii_rw ( priv, priv->phyaddr,
                                        PHY_VITESSE_INIT_REG3, MII_READ);
                phy_reserved &= ~PHY_VITESSE_INIT_MSK2;
                phy_reserved |= PHY_VITESSE_INIT8;
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG3,
                                                   phy_reserved ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG2,
                                                   PHY_VITESSE_INIT9 ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
                if ( mii_rw ( priv, priv->phyaddr, PHY_VITESSE_INIT_REG1,
                                                   PHY_VITESSE_INIT10 ) ) {
                        DBG ( "PHY init failed.\n" );
                        return PHY_ERROR;
                }
        }

        if ( priv->phy_oui == PHY_OUI_REALTEK ) {
                if ( priv->phy_model == PHY_MODEL_REALTEK_8211 &&
                     priv->phy_rev == PHY_REV_REALTEK_8211B ) {
                        /* reset could have cleared these out, set them back */
                        if ( mii_rw ( priv, priv->phyaddr,
                                      PHY_REALTEK_INIT_REG1, PHY_REALTEK_INIT1 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                      PHY_REALTEK_INIT_REG2, PHY_REALTEK_INIT2 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                      PHY_REALTEK_INIT_REG1, PHY_REALTEK_INIT3 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                      PHY_REALTEK_INIT_REG3, PHY_REALTEK_INIT4 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                      PHY_REALTEK_INIT_REG4, PHY_REALTEK_INIT5 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                      PHY_REALTEK_INIT_REG5, PHY_REALTEK_INIT6 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                      PHY_REALTEK_INIT_REG1, PHY_REALTEK_INIT1 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                }
                if ( priv->phy_model == PHY_MODEL_REALTEK_8201 ) {
                        if ( priv->driver_data & DEV_NEED_PHY_INIT_FIX ) {
                                phy_reserved = mii_rw ( priv, priv->phyaddr,
                                                        PHY_REALTEK_INIT_REG6,
                                                        MII_READ );
                                phy_reserved |= PHY_REALTEK_INIT7;
                                if ( mii_rw ( priv, priv->phyaddr,
                                              PHY_REALTEK_INIT_REG6,
                                              phy_reserved ) ) {
                                        DBG ( "PHY init failed.\n" );
                                        return PHY_ERROR;
                                }
                        }

                        if ( mii_rw ( priv, priv->phyaddr,
                                      PHY_REALTEK_INIT_REG1,
                                      PHY_REALTEK_INIT3 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        phy_reserved = mii_rw ( priv, priv->phyaddr,
                                                PHY_REALTEK_INIT_REG2,
                                                MII_READ );
                        phy_reserved &= ~PHY_REALTEK_INIT_MSK1;
                        phy_reserved |= PHY_REALTEK_INIT3;
                        if ( mii_rw ( priv, priv->phyaddr,
                                      PHY_REALTEK_INIT_REG2,
                                      phy_reserved ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                        if ( mii_rw ( priv, priv->phyaddr,
                                      PHY_REALTEK_INIT_REG1,
                                      PHY_REALTEK_INIT1 ) ) {
                                DBG ( "PHY init failed.\n" );
                                return PHY_ERROR;
                        }
                }
        }

        /* some phys clear out pause advertisement on reset, set it back */
        mii_rw ( priv, priv->phyaddr, MII_ADVERTISE, reg );

        /* restart auto negotiation, power down phy */
        mii_control = mii_rw ( priv, priv->phyaddr, MII_BMCR, MII_READ );
        mii_control |= ( BMCR_ANRESTART | BMCR_ANENABLE );
        if ( mii_rw ( priv, priv->phyaddr, MII_BMCR, mii_control ) ) {
                return PHY_ERROR;
        }

        return 0;
}

References ADVERTISE_1000FULL, ADVERTISE_1000HALF, ADVERTISE_100FULL, ADVERTISE_100HALF, ADVERTISE_10FULL, ADVERTISE_10HALF, ADVERTISE_PAUSE_ASYM, ADVERTISE_PAUSE_CAP, BMCR_ANENABLE, BMCR_ANRESTART, DBG, DEV_NEED_PHY_INIT_FIX, ioaddr, mdelay(), MII_ADVERTISE, MII_BMCR, MII_BMSR, MII_CTRL1000, MII_NCONFIG, MII_READ, MII_RESV1, mii_rw(), MII_SREVISION, NVREG_POWERSTATE2_PHY_RESET, NvRegPhyInterface, NvRegPowerState2, PHY_CICADA_INIT1, PHY_CICADA_INIT2, PHY_CICADA_INIT3, PHY_CICADA_INIT4, PHY_CICADA_INIT5, PHY_CICADA_INIT6, PHY_ERROR, PHY_GIGABIT, PHY_MARVELL_E3016_INITMASK, PHY_MODEL_MARVELL_E3016, PHY_MODEL_REALTEK_8201, PHY_MODEL_REALTEK_8211, PHY_OUI_CICADA, PHY_OUI_REALTEK, PHY_OUI_VITESSE, PHY_REALTEK_INIT1, PHY_REALTEK_INIT10, PHY_REALTEK_INIT11, PHY_REALTEK_INIT2, PHY_REALTEK_INIT3, PHY_REALTEK_INIT4, PHY_REALTEK_INIT5, PHY_REALTEK_INIT6, PHY_REALTEK_INIT7, PHY_REALTEK_INIT9, PHY_REALTEK_INIT_MSK1, PHY_REALTEK_INIT_REG1, PHY_REALTEK_INIT_REG2, PHY_REALTEK_INIT_REG3, PHY_REALTEK_INIT_REG4, PHY_REALTEK_INIT_REG5, PHY_REALTEK_INIT_REG6, PHY_REALTEK_INIT_REG7, phy_reset(), PHY_REV_REALTEK_8211B, PHY_REV_REALTEK_8211C, PHY_RGMII, PHY_VITESSE_INIT1, PHY_VITESSE_INIT10, PHY_VITESSE_INIT2, PHY_VITESSE_INIT3, PHY_VITESSE_INIT4, PHY_VITESSE_INIT5, PHY_VITESSE_INIT6, PHY_VITESSE_INIT7, PHY_VITESSE_INIT8, PHY_VITESSE_INIT9, PHY_VITESSE_INIT_MSK1, PHY_VITESSE_INIT_MSK2, PHY_VITESSE_INIT_REG1, PHY_VITESSE_INIT_REG2, PHY_VITESSE_INIT_REG3, PHY_VITESSE_INIT_REG4, priv, readl(), reg, and writel().

Referenced by nv_setup_phy().

nv_setup_phy()

static int nv_setup_phy ( struct forcedeth_private *  priv )

static

nv_setup_phy - Find PHY and initialize it

Parameters

priv	Driver private structure

Return values

rc	Return status code

Definition at line 1609 of file forcedeth.c.

{
        void *ioaddr = priv->mmio_addr;
        u32 phystate_orig = 0, phystate;
        int phyinitialised = 0;
        u32 powerstate;
        int rc = 0;
        int i;

        if ( priv->driver_data & DEV_HAS_POWER_CNTRL ) {
                /* take phy and nic out of low power mode */
                powerstate = readl ( ioaddr + NvRegPowerState2 );
                powerstate &= ~NVREG_POWERSTATE2_POWERUP_MASK;
                if ( ( priv->driver_data & DEV_NEED_LOW_POWER_FIX ) &&
                     ( ( priv->pci_dev->class & 0xff ) >= 0xA3 ) )
                        powerstate |= NVREG_POWERSTATE2_POWERUP_REV_A3;
                writel ( powerstate, ioaddr + NvRegPowerState2 );
        }


        /* clear phy state and temporarily halt phy interrupts */
        writel ( 0, ioaddr + NvRegMIIMask );
        phystate = readl ( ioaddr + NvRegAdapterControl );
        if ( phystate & NVREG_ADAPTCTL_RUNNING ) {
                phystate_orig = 1;
                phystate &= ~NVREG_ADAPTCTL_RUNNING;
                writel ( phystate, ioaddr + NvRegAdapterControl );
        }
        writel ( NVREG_MIISTAT_MASK_ALL, ioaddr + NvRegMIIStatus );

        if ( priv->driver_data & DEV_HAS_MGMT_UNIT ) {
                /* management unit running on the mac? */
                if ( ( readl ( ioaddr + NvRegTransmitterControl ) & NVREG_XMITCTL_MGMT_ST ) &&
                     ( readl ( ioaddr + NvRegTransmitterControl ) & NVREG_XMITCTL_SYNC_PHY_INIT ) &&
                     nv_mgmt_acquire_sema ( priv ) &&
                     nv_mgmt_get_version ( priv ) ) {
                        priv->mac_in_use = 1;
                        if ( priv->mgmt_version > 0 ) {
                                priv->mac_in_use = readl ( ioaddr + NvRegMgmtUnitControl ) & NVREG_MGMTUNITCONTROL_INUSE;
                        }

                        DBG ( "mgmt unit is running. mac in use\n" );

                        /* management unit setup the phy already? */
                        if ( priv->mac_in_use &&
                           ( ( readl ( ioaddr + NvRegTransmitterControl ) & NVREG_XMITCTL_SYNC_MASK ) ==
                             NVREG_XMITCTL_SYNC_PHY_INIT ) ) {
                                /* phy is inited by mgmt unit */
                                phyinitialised = 1;
                                DBG ( "Phy already initialized by mgmt unit" );
                        }
                }
        }

        /* find a suitable phy */
        for ( i = 1; i <= 32; i++ ) {
                int id1, id2;
                int phyaddr = i & 0x1f;

                id1 = mii_rw ( priv, phyaddr, MII_PHYSID1, MII_READ );
                if ( id1 < 0 || id1 == 0xffff )
                        continue;
                id2 = mii_rw ( priv, phyaddr, MII_PHYSID2, MII_READ );
                if ( id2 < 0 || id2 == 0xffff )
                        continue;

                priv->phy_model = id2 & PHYID2_MODEL_MASK;
                id1 = ( id1 & PHYID1_OUI_MASK ) << PHYID1_OUI_SHFT;
                id2 = ( id2 & PHYID2_OUI_MASK ) >> PHYID2_OUI_SHFT;
                DBG ( "Found PHY: %04x:%04x at address %d\n", id1, id2, phyaddr );
                priv->phyaddr = phyaddr;
                priv->phy_oui = id1 | id2;

                /* Realtek hardcoded phy id1 to all zeros on certain phys */
                if ( priv->phy_oui == PHY_OUI_REALTEK2 )
                        priv->phy_oui = PHY_OUI_REALTEK;
                /* Setup phy revision for Realtek */
                if ( priv->phy_oui == PHY_OUI_REALTEK &&
                     priv->phy_model == PHY_MODEL_REALTEK_8211 )
                        priv->phy_rev = mii_rw ( priv, phyaddr, MII_RESV1,
                                                 MII_READ ) & PHY_REV_MASK;
                break;
        }
        if ( i == 33 ) {
                DBG ( "Could not find a valid PHY.\n" );
                rc = -ENODEV;
                goto err_phy;
        }

        if ( ! phyinitialised ) {
                /* reset it */
                phy_init ( priv );
        } else {
                u32 mii_status = mii_rw ( priv, priv->phyaddr, MII_BMSR, MII_READ );
                if ( mii_status & PHY_GIGABIT ) {
                        priv->gigabit = PHY_GIGABIT;
                }
        }

        return 0;

err_phy:
        if ( phystate_orig )
                writel ( phystate | NVREG_ADAPTCTL_RUNNING,
                         ioaddr + NvRegAdapterControl );
        return rc;
}

References DBG, DEV_HAS_MGMT_UNIT, DEV_HAS_POWER_CNTRL, DEV_NEED_LOW_POWER_FIX, ENODEV, ioaddr, MII_BMSR, MII_PHYSID1, MII_PHYSID2, MII_READ, MII_RESV1, mii_rw(), nv_mgmt_acquire_sema(), nv_mgmt_get_version(), NVREG_ADAPTCTL_RUNNING, NVREG_MGMTUNITCONTROL_INUSE, NVREG_MIISTAT_MASK_ALL, NVREG_POWERSTATE2_POWERUP_MASK, NVREG_POWERSTATE2_POWERUP_REV_A3, NVREG_XMITCTL_MGMT_ST, NVREG_XMITCTL_SYNC_MASK, NVREG_XMITCTL_SYNC_PHY_INIT, NvRegAdapterControl, NvRegMgmtUnitControl, NvRegMIIMask, NvRegMIIStatus, NvRegPowerState2, NvRegTransmitterControl, PHY_GIGABIT, phy_init(), PHY_MODEL_REALTEK_8211, PHY_OUI_REALTEK, PHY_OUI_REALTEK2, PHY_REV_MASK, PHYID1_OUI_MASK, PHYID1_OUI_SHFT, PHYID2_MODEL_MASK, PHYID2_OUI_MASK, PHYID2_OUI_SHFT, priv, rc, readl(), and writel().

Referenced by forcedeth_probe().

forcedeth_map_regs()

static int forcedeth_map_regs ( struct forcedeth_private *  priv )

static

forcedeth_map_regs - Find a suitable BAR for the NIC and map the registers in memory

Parameters

priv	Driver private structure

Return values

rc	Return status code

Definition at line 1726 of file forcedeth.c.

{
        void *ioaddr;
        uint32_t bar;
        unsigned long addr;
        u32 register_size;
        int reg;
        int rc;

        /* Set register size based on NIC */
        if ( priv->driver_data & ( DEV_HAS_VLAN | DEV_HAS_MSI_X |
                DEV_HAS_POWER_CNTRL | DEV_HAS_STATISTICS_V2 |
                DEV_HAS_STATISTICS_V3 ) ) {
                register_size = NV_PCI_REGSZ_VER3;
        } else if ( priv->driver_data & DEV_HAS_STATISTICS_V1 ) {
                register_size = NV_PCI_REGSZ_VER2;
        } else {
                register_size = NV_PCI_REGSZ_VER1;
        }

        /* Find an appropriate region for all the registers */
        rc = -EINVAL;
        addr = 0;
        for ( reg = PCI_BASE_ADDRESS_0; reg <= PCI_BASE_ADDRESS_5; reg += 4 ) {
                pci_read_config_dword ( priv->pci_dev, reg, &bar );

                if ( ( ! ( bar & PCI_BASE_ADDRESS_SPACE_IO ) ) &&
                     ( pci_bar_size ( priv->pci_dev, reg ) >= register_size ) ){
                        addr = pci_bar_start ( priv->pci_dev, reg );
                        break;
                }
        }

        if ( reg > PCI_BASE_ADDRESS_5 ) {
                DBG ( "Couldn't find register window\n" );
                goto err_bar_sz;
        }

        rc = -ENOMEM;
        ioaddr = pci_ioremap ( priv->pci_dev, addr, register_size );
        if ( ! ioaddr ) {
                DBG ( "Cannot remap MMIO\n" );
                goto err_ioremap;
        }

        priv->mmio_addr = ioaddr;

        return 0;

err_bar_sz:
err_ioremap:
        return rc;
}

References addr, DBG, DEV_HAS_MSI_X, DEV_HAS_POWER_CNTRL, DEV_HAS_STATISTICS_V1, DEV_HAS_STATISTICS_V2, DEV_HAS_STATISTICS_V3, DEV_HAS_VLAN, EINVAL, ENOMEM, ioaddr, NV_PCI_REGSZ_VER1, NV_PCI_REGSZ_VER2, NV_PCI_REGSZ_VER3, pci_bar_size(), pci_bar_start(), PCI_BASE_ADDRESS_0, PCI_BASE_ADDRESS_5, PCI_BASE_ADDRESS_SPACE_IO, pci_ioremap(), pci_read_config_dword(), priv, rc, and reg.

Referenced by forcedeth_probe().

forcedeth_probe()

static int forcedeth_probe ( struct pci_device *  pdev )

static

probe - Initial configuration of NIC

Parameters

pdev	PCI device
ent	PCI IDs

Return values

rc	Return status code

Definition at line 1789 of file forcedeth.c.

{
        struct net_device *netdev;
        struct forcedeth_private *priv;
        void *ioaddr;
        int rc;

        DBGP ( "forcedeth_probe\n" );

        DBG ( "Found %s, vendor = %#04x, device = %#04x\n",
              pdev->id->name, pdev->id->vendor, pdev->id->device );

        /* Allocate our private data */
        netdev = alloc_etherdev ( sizeof ( *priv ) );
        if ( ! netdev ) {
                rc = -ENOMEM;
                DBG ( "Failed to allocate net device\n" );
                goto err_alloc_etherdev;
        }

        /* Link our operations to the netdev struct */
        netdev_init ( netdev, &forcedeth_operations );

        /* Link the PCI device to the netdev struct */
        pci_set_drvdata ( pdev, netdev );
        netdev->dev = &pdev->dev;

        /* Get a reference to our private data */
        priv = netdev->priv;

        /* We'll need these set up for the rest of the routines */
        priv->pci_dev = pdev;
        priv->netdev = netdev;
        priv->driver_data = pdev->id->driver_data;

        adjust_pci_device ( pdev );

        /* Use memory mapped I/O */
        if ( ( rc = forcedeth_map_regs ( priv ) ) != 0 )
                goto err_map_regs;
        ioaddr = priv->mmio_addr;

        /* Verify and get MAC address */
        if ( ( rc = nv_setup_mac_addr ( priv ) ) != 0 ) {
                DBG ( "Invalid MAC address detected\n" );
                goto err_mac_addr;
        }

        /* Disable WOL */
        writel ( 0, ioaddr + NvRegWakeUpFlags );

        if ( ( rc = nv_setup_phy ( priv ) ) != 0 )
                goto err_setup_phy;

        /* Set Pause Frame parameters */
        priv->pause_flags = NV_PAUSEFRAME_RX_CAPABLE |
                            NV_PAUSEFRAME_RX_REQ |
                            NV_PAUSEFRAME_AUTONEG;
        if ( ( priv->driver_data & DEV_HAS_PAUSEFRAME_TX_V1 ) ||
             ( priv->driver_data & DEV_HAS_PAUSEFRAME_TX_V2 ) ||
             ( priv->driver_data & DEV_HAS_PAUSEFRAME_TX_V3 ) ) {
                priv->pause_flags |= NV_PAUSEFRAME_TX_CAPABLE | NV_PAUSEFRAME_TX_REQ;
        }

        if ( priv->pause_flags & NV_PAUSEFRAME_TX_CAPABLE )
                writel ( NVREG_TX_PAUSEFRAME_DISABLE, ioaddr + NvRegTxPauseFrame );

        /* Set default link speed settings */
        priv->linkspeed = NVREG_LINKSPEED_FORCE | NVREG_LINKSPEED_10;
        priv->duplex = 0;

        if ( ( rc = register_netdev ( netdev ) ) != 0 ) {
                DBG ( "Error registering netdev\n" );
                goto err_register_netdev;
        }

        forcedeth_link_status ( netdev );

        return 0;

err_register_netdev:
err_setup_phy:
err_mac_addr:
        iounmap ( priv->mmio_addr );
err_map_regs:
        netdev_nullify ( netdev );
        netdev_put ( netdev );
err_alloc_etherdev:
        return rc;
}

References adjust_pci_device(), alloc_etherdev(), DBG, DBGP, pci_device::dev, net_device::dev, DEV_HAS_PAUSEFRAME_TX_V1, DEV_HAS_PAUSEFRAME_TX_V2, DEV_HAS_PAUSEFRAME_TX_V3, pci_device_id::device, pci_device_id::driver_data, tlan_private::duplex, ENOMEM, forcedeth_link_status(), forcedeth_map_regs(), forcedeth_operations, pci_device::id, ioaddr, iounmap(), pci_device_id::name, netdev, netdev_init(), netdev_nullify(), netdev_put(), NV_PAUSEFRAME_AUTONEG, NV_PAUSEFRAME_RX_CAPABLE, NV_PAUSEFRAME_RX_REQ, NV_PAUSEFRAME_TX_CAPABLE, NV_PAUSEFRAME_TX_REQ, nv_setup_mac_addr(), nv_setup_phy(), NVREG_LINKSPEED_10, NVREG_LINKSPEED_FORCE, NVREG_TX_PAUSEFRAME_DISABLE, NvRegTxPauseFrame, NvRegWakeUpFlags, pci_set_drvdata(), priv, net_device::priv, rc, register_netdev(), pci_device_id::vendor, and writel().

nv_restore_phy()

static void nv_restore_phy ( struct forcedeth_private *  priv )

static

Definition at line 1881 of file forcedeth.c.

{
        u16 phy_reserved, mii_control;

        if ( priv->phy_oui == PHY_OUI_REALTEK &&
             priv->phy_model == PHY_MODEL_REALTEK_8201 ) {
                mii_rw ( priv, priv->phyaddr, PHY_REALTEK_INIT_REG1,
                                              PHY_REALTEK_INIT3 );
                phy_reserved = mii_rw ( priv, priv->phyaddr,
                                        PHY_REALTEK_INIT_REG2, MII_READ );
                phy_reserved &= ~PHY_REALTEK_INIT_MSK1;
                phy_reserved |= PHY_REALTEK_INIT8;
                mii_rw ( priv, priv->phyaddr, PHY_REALTEK_INIT_REG2,
                                              phy_reserved );
                mii_rw ( priv, priv->phyaddr, PHY_REALTEK_INIT_REG1,
                                              PHY_REALTEK_INIT1 );

                /* restart auto negotiation */
                mii_control = mii_rw ( priv, priv->phyaddr, MII_BMCR, MII_READ );
                mii_control |= ( BMCR_ANRESTART | BMCR_ANENABLE );
                mii_rw ( priv, priv->phyaddr, MII_BMCR, mii_control );
        }
}

References BMCR_ANENABLE, BMCR_ANRESTART, MII_BMCR, MII_READ, mii_rw(), PHY_MODEL_REALTEK_8201, PHY_OUI_REALTEK, PHY_REALTEK_INIT1, PHY_REALTEK_INIT3, PHY_REALTEK_INIT8, PHY_REALTEK_INIT_MSK1, PHY_REALTEK_INIT_REG1, PHY_REALTEK_INIT_REG2, and priv.

Referenced by forcedeth_remove().

forcedeth_remove()

static void forcedeth_remove ( struct pci_device *  pdev )

static

remove - Device Removal Routine

Parameters

pdev	PCI device information struct

Definition at line 1911 of file forcedeth.c.

{
        struct net_device *netdev = pci_get_drvdata ( pdev );
        struct forcedeth_private *priv = netdev->priv;

        DBGP ( "forcedeth_remove\n" );

        unregister_netdev ( netdev );

        nv_restore_phy ( priv );

        nv_mgmt_release_sema ( priv );

        iounmap ( priv->mmio_addr );

        netdev_nullify ( netdev );
        netdev_put ( netdev );
}

References DBGP, iounmap(), netdev, netdev_nullify(), netdev_put(), nv_mgmt_release_sema(), nv_restore_phy(), pci_get_drvdata(), priv, net_device::priv, and unregister_netdev().

Variable Documentation

forcedeth_operations

struct net_device_operations forcedeth_operations

static

Initial value:

= {
        .open           = forcedeth_open,
        .transmit       = forcedeth_transmit,
        .poll           = forcedeth_poll,
        .close          = forcedeth_close,
        .irq            = forcedeth_irq,
}

Definition at line 1062 of file forcedeth.c.

Referenced by forcedeth_probe().

forcedeth_nics

struct pci_device_id forcedeth_nics[]

static

Definition at line 1930 of file forcedeth.c.

__pci_driver

struct pci_driver forcedeth_driver __pci_driver

Initial value:

= {
        .ids            = forcedeth_nics,
        .id_count       = ARRAY_SIZE(forcedeth_nics),
        .probe          = forcedeth_probe,
        .remove         = forcedeth_remove,
}

Definition at line 1973 of file forcedeth.c.