rdc.c

Go to the documentation of this file.

/*
 * Copyright (C) 2021 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 *
 * You can also choose to distribute this program under the terms of
 * the Unmodified Binary Distribution Licence (as given in the file
 * COPYING.UBDL), provided that you have satisfied its requirements.
 */
 
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/netdevice.h>
#include <ipxe/ethernet.h>
#include <ipxe/if_ether.h>
#include <ipxe/iobuf.h>
#include <ipxe/malloc.h>
#include <ipxe/pci.h>
#include "rdc.h"
 
/** @file
 *
 * RDC R6040 network driver
 *
 */
 
/******************************************************************************
 *
 * Device reset
 *
 ******************************************************************************
 */
 
/**
 * Reset hardware
 *
 * @v rdc               RDC device
 * @ret rc              Return status code
 */
static int rdc_reset ( struct rdc_nic *rdc ) {
        unsigned int i;
 
        /* Reset NIC */
        writew ( RDC_MCR1_RST, rdc->regs + RDC_MCR1 );
 
        /* Wait for reset to complete */
        for ( i = 0 ; i < RDC_RESET_MAX_WAIT_MS ; i++ ) {
 
                /* Check for reset completion */
                if ( readw ( rdc->regs + RDC_MCR1 ) & RDC_MCR1_RST ) {
                        mdelay ( 1 );
                        continue;
                }
 
                /* Reset internal state machine */
                writew ( RDC_MACSM_RST, rdc->regs + RDC_MACSM );
                writew ( 0, rdc->regs + RDC_MACSM );
                mdelay ( RDC_MACSM_RESET_DELAY_MS );
 
                return 0;
        }
 
        DBGC ( rdc, "RDC %p timed out waiting for reset\n", rdc );
        return -ETIMEDOUT;
}
 
/******************************************************************************
 *
 * MII interface
 *
 ******************************************************************************
 */
 
/**
 * Read from MII register
 *
 * @v mdio              MII interface
 * @v phy               PHY address
 * @v reg               Register address
 * @ret value           Data read, or negative error
 */
static int rdc_mii_read ( struct mii_interface *mdio, unsigned int phy,
                          unsigned int reg ) {
        struct rdc_nic *rdc = container_of ( mdio, struct rdc_nic, mdio );
        uint16_t mmdio;
        unsigned int i;
 
        /* Initiate read */
        mmdio = ( RDC_MMDIO_MIIRD | RDC_MMDIO_PHYAD ( phy ) |
                  RDC_MMDIO_REGAD ( reg ) );
        writew ( mmdio, rdc->regs + RDC_MMDIO );
 
        /* Wait for read to complete */
        for ( i = 0 ; i < RDC_MII_MAX_WAIT_US ; i++ ) {
 
                /* Check for read completion */
                if ( readw ( rdc->regs + RDC_MMDIO ) & RDC_MMDIO_MIIRD ) {
                        udelay ( 1 );
                        continue;
                }
 
                /* Return register value */
                return ( readw ( rdc->regs + RDC_MMRD ) );
        }
 
        DBGC ( rdc, "RDC %p timed out waiting for MII read\n", rdc );
        return -ETIMEDOUT;
}
 
/**
 * Write to MII register
 *
 * @v mdio              MII interface
 * @v phy               PHY address
 * @v reg               Register address
 * @v data              Data to write
 * @ret rc              Return status code
 */
static int rdc_mii_write ( struct mii_interface *mdio, unsigned int phy,
                           unsigned int reg, unsigned int data ) {
        struct rdc_nic *rdc = container_of ( mdio, struct rdc_nic, mdio );
        uint16_t mmdio;
        unsigned int i;
 
        /* Initiate write */
        mmdio = ( RDC_MMDIO_MIIWR | RDC_MMDIO_PHYAD ( phy ) |
                  RDC_MMDIO_REGAD ( reg ) );
        writew ( data, rdc->regs + RDC_MMWD );
        writew ( mmdio, rdc->regs + RDC_MMDIO );
 
        /* Wait for write to complete */
        for ( i = 0 ; i < RDC_MII_MAX_WAIT_US ; i++ ) {
 
                /* Check for write completion */
                if ( readw ( rdc->regs + RDC_MMDIO ) & RDC_MMDIO_MIIWR ) {
                        udelay ( 1 );
                        continue;
                }
 
                return 0;
        }
 
        DBGC ( rdc, "RDC %p timed out waiting for MII write\n", rdc );
        return -ETIMEDOUT;
}
 
/** RDC MII operations */
static struct mii_operations rdc_mii_operations = {
        .read = rdc_mii_read,
        .write = rdc_mii_write,
};
 
/******************************************************************************
 *
 * Link state
 *
 ******************************************************************************
 */
 
/**
 * Initialise PHY
 *
 * @v rdc               RDC device
 * @ret rc              Return status code
 */
static int rdc_init_phy ( struct rdc_nic *rdc ) {
        int rc;
 
        /* Find PHY address */
        if ( ( rc = mii_find ( &rdc->mii ) ) != 0 ) {
                DBGC ( rdc, "RDC %p could not find PHY address: %s\n",
                       rdc, strerror ( rc ) );
                return rc;
        }
 
        /* Reset PHY */
        if ( ( rc = mii_reset ( &rdc->mii ) ) != 0 ) {
                DBGC ( rdc, "RDC %p could not reset PHY: %s\n",
                       rdc, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}
 
/**
 * Check link state
 *
 * @v netdev            Network device
 * @ret rc              Return status code
 */
static int rdc_check_link ( struct net_device *netdev ) {
        struct rdc_nic *rdc = netdev->priv;
        int rc;
 
        /* Check link state */
        if ( ( rc = mii_check_link ( &rdc->mii, netdev ) ) != 0 ) {
                DBGC ( rdc, "RDC %p could not check link: %s\n",
                       rdc, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}
 
/******************************************************************************
 *
 * Network device interface
 *
 ******************************************************************************
 */
 
/**
 * Create descriptor ring
 *
 * @v rdc               RDC device
 * @v ring              Descriptor ring
 * @ret rc              Return status code
 */
static int rdc_create_ring ( struct rdc_nic *rdc, struct rdc_ring *ring ) {
        size_t len = ( ring->count * sizeof ( ring->desc[0] ) );
        struct rdc_descriptor *desc;
        struct rdc_descriptor *next;
        physaddr_t start;
        unsigned int i;
 
        /* Allocate descriptor ring */
        ring->desc = dma_alloc ( rdc->dma, &ring->map, len, len );
        if ( ! ring->desc )
                return -ENOMEM;
 
        /* Initialise descriptor ring */
        memset ( ring->desc, 0, len );
        for ( i = 0 ; i < ring->count ; i++ ) {
                desc = &ring->desc[i];
                next = &ring->desc[ ( i + 1 ) & ( ring->count - 1 ) ];
                desc->next = cpu_to_le32 ( dma ( &ring->map, next ) );
        }
 
        /* Program ring address */
        start = dma ( &ring->map, ring->desc );
        writew ( ( start >> 0 ), ( rdc->regs + ring->reg + RDC_MxDSA_LO ) );
        writew ( ( start >> 16 ), ( rdc->regs + ring->reg + RDC_MxDSA_HI ) );
 
        DBGC ( rdc, "RDC %p ring %#02x is at [%08lx,%08lx)\n",
               rdc, ring->reg, virt_to_phys ( ring->desc ),
               ( virt_to_phys ( ring->desc ) + len ) );
        return 0;
}
 
/**
 * Destroy descriptor ring
 *
 * @v rdc               RDC device
 * @v ring              Descriptor ring
 */
static void rdc_destroy_ring ( struct rdc_nic *rdc, struct rdc_ring *ring ) {
        size_t len = ( ring->count * sizeof ( ring->desc[0] ) );
 
        /* Clear ring address */
        writew ( 0, ( rdc->regs + ring->reg + RDC_MxDSA_LO ) );
        writew ( 0, ( rdc->regs + ring->reg + RDC_MxDSA_HI ) );
 
        /* Free descriptors */
        dma_free ( &ring->map, ring->desc, len );
        ring->desc = NULL;
 
        /* Reset ring */
        ring->prod = 0;
        ring->cons = 0;
}
 
/**
 * Refill receive descriptor ring
 *
 * @v rdc               RDC device
 */
static void rdc_refill_rx ( struct rdc_nic *rdc ) {
        struct rdc_descriptor *rx;
        struct io_buffer *iobuf;
        unsigned int rx_idx;
 
        /* Refill ring */
        while ( ( rdc->rx.prod - rdc->rx.cons ) < RDC_NUM_RX_DESC ) {
 
                /* Allocate I/O buffer */
                iobuf = alloc_rx_iob ( RDC_RX_MAX_LEN, rdc->dma );
                if ( ! iobuf ) {
                        /* Wait for next refill */
                        break;
                }
 
                /* Get next receive descriptor */
                rx_idx = ( rdc->rx.prod++ % RDC_NUM_RX_DESC );
                rx = &rdc->rx.desc[rx_idx];
 
                /* Populate receive descriptor */
                rx->len = cpu_to_le16 ( RDC_RX_MAX_LEN );
                rx->addr = cpu_to_le32 ( iob_dma ( iobuf ) );
                wmb();
                rx->flags = cpu_to_le16 ( RDC_FL_OWNED );
 
                /* Record I/O buffer */
                assert ( rdc->rx_iobuf[rx_idx] == NULL );
                rdc->rx_iobuf[rx_idx] = iobuf;
 
                DBGC2 ( rdc, "RDC %p RX %d is [%lx,%lx)\n",
                        rdc, rx_idx, virt_to_phys ( iobuf->data ),
                        ( virt_to_phys ( iobuf->data ) + RDC_RX_MAX_LEN ) );
        }
}
 
/**
 * Open network device
 *
 * @v netdev            Network device
 * @ret rc              Return status code
 */
static int rdc_open ( struct net_device *netdev ) {
        struct rdc_nic *rdc = netdev->priv;
        int rc;
 
        /* Create transmit descriptor ring */
        if ( ( rc = rdc_create_ring ( rdc, &rdc->tx ) ) != 0 )
                goto err_create_tx;
 
        /* Create receive descriptor ring */
        if ( ( rc = rdc_create_ring ( rdc, &rdc->rx ) ) != 0 )
                goto err_create_rx;
 
        /* Program receive buffer length */
        writew ( RDC_RX_MAX_LEN, rdc->regs + RDC_MRBSR );
 
        /* Enable transmit and receive */
        writew ( ( RDC_MCR0_FD | RDC_MCR0_TXEN | RDC_MCR0_PROMISC |
                   RDC_MCR0_RXEN ),
                 rdc->regs + RDC_MCR0 );
 
        /* Enable PHY status polling */
        writew ( ( RDC_MPSCCR_EN | RDC_MPSCCR_PHYAD ( rdc->mii.address ) |
                   RDC_MPSCCR_SLOW ),
                 rdc->regs + RDC_MPSCCR );
 
        /* Fill receive ring */
        rdc_refill_rx ( rdc );
 
        /* Update link state */
        rdc_check_link ( netdev );
 
        return 0;
 
        rdc_destroy_ring ( rdc, &rdc->rx );
 err_create_rx:
        rdc_destroy_ring ( rdc, &rdc->tx );
 err_create_tx:
        return rc;
}
 
/**
 * Close network device
 *
 * @v netdev            Network device
 */
static void rdc_close ( struct net_device *netdev ) {
        struct rdc_nic *rdc = netdev->priv;
        unsigned int i;
 
        /* Disable NIC */
        writew ( 0, rdc->regs + RDC_MCR0 );
 
        /* Destroy receive descriptor ring */
        rdc_destroy_ring ( rdc, &rdc->rx );
 
        /* Discard any unused receive buffers */
        for ( i = 0 ; i < RDC_NUM_RX_DESC ; i++ ) {
                if ( rdc->rx_iobuf[i] )
                        free_rx_iob ( rdc->rx_iobuf[i] );
                rdc->rx_iobuf[i] = NULL;
        }
 
        /* Destroy transmit descriptor ring */
        rdc_destroy_ring ( rdc, &rdc->tx );
}
 
/**
 * Transmit packet
 *
 * @v netdev            Network device
 * @v iobuf             I/O buffer
 * @ret rc              Return status code
 */
static int rdc_transmit ( struct net_device *netdev, struct io_buffer *iobuf ) {
        struct rdc_nic *rdc = netdev->priv;
        struct rdc_descriptor *tx;
        unsigned int tx_idx;
        int rc;
 
        /* Get next transmit descriptor */
        if ( ( rdc->tx.prod - rdc->tx.cons ) >= RDC_NUM_TX_DESC ) {
                DBGC ( rdc, "RDC %p out of transmit descriptors\n", rdc );
                return -ENOBUFS;
        }
        tx_idx = ( rdc->tx.prod % RDC_NUM_TX_DESC );
        tx = &rdc->tx.desc[tx_idx];
 
        /* Pad to minimum length */
        iob_pad ( iobuf, ETH_ZLEN );
 
        /* Map I/O buffer */
        if ( ( rc = iob_map_tx ( iobuf, rdc->dma ) ) != 0 )
                return rc;
 
        /* Update producer index */
        rdc->tx.prod++;
 
        /* Populate transmit descriptor */
        tx->len = cpu_to_le16 ( iob_len ( iobuf ) );
        tx->addr = cpu_to_le32 ( iob_dma ( iobuf ) );
        wmb();
        tx->flags = cpu_to_le16 ( RDC_FL_OWNED );
        wmb();
 
        /* Notify card that there are packets ready to transmit */
        writew ( RDC_MTPR_TM2TX, rdc->regs + RDC_MTPR );
 
        return 0;
}
 
/**
 * Poll for completed packets
 *
 * @v netdev            Network device
 */
static void rdc_poll_tx ( struct net_device *netdev ) {
        struct rdc_nic *rdc = netdev->priv;
        struct rdc_descriptor *tx;
        unsigned int tx_idx;
 
        /* Check for completed packets */
        while ( rdc->tx.cons != rdc->tx.prod ) {
 
                /* Get next transmit descriptor */
                tx_idx = ( rdc->tx.cons % RDC_NUM_TX_DESC );
                tx = &rdc->tx.desc[tx_idx];
 
                /* Stop if descriptor is still in use */
                if ( tx->flags & cpu_to_le16 ( RDC_FL_OWNED ) )
                        return;
                DBGC2 ( rdc, "RDC %p TX %d complete\n", rdc, tx_idx );
 
                /* Complete transmit descriptor */
                rdc->tx.cons++;
                netdev_tx_complete_next ( netdev );
        }
}
 
/**
 * Poll for received packets
 *
 * @v netdev            Network device
 */
static void rdc_poll_rx ( struct net_device *netdev ) {
        struct rdc_nic *rdc = netdev->priv;
        struct rdc_descriptor *rx;
        struct io_buffer *iobuf;
        unsigned int rx_idx;
        size_t len;
 
        /* Check for received packets */
        while ( rdc->rx.cons != rdc->rx.prod ) {
 
                /* Get next receive descriptor */
                rx_idx = ( rdc->rx.cons % RDC_NUM_RX_DESC );
                rx = &rdc->rx.desc[rx_idx];
 
                /* Stop if descriptor is still in use */
                if ( rx->flags & cpu_to_le16 ( RDC_FL_OWNED ) )
                        return;
 
                /* Populate I/O buffer */
                iobuf = rdc->rx_iobuf[rx_idx];
                rdc->rx_iobuf[rx_idx] = NULL;
                len = le16_to_cpu ( rx->len );
                iob_put ( iobuf, len );
                iob_unput ( iobuf, 4 /* strip CRC */ );
 
                /* Hand off to network stack */
                if ( rx->flags & cpu_to_le16 ( RDC_FL_OK ) ) {
                        DBGC2 ( rdc, "RDC %p RX %d complete (length %zd)\n",
                                rdc, rx_idx, len );
                        netdev_rx ( netdev, iobuf );
                } else {
                        DBGC2 ( rdc, "RDC %p RX %d error (length %zd, "
                                "flags %#04x)\n", rdc, rx_idx, len,
                                le16_to_cpu ( rx->flags ) );
                        netdev_rx_err ( netdev, iobuf, -EIO );
                }
                rdc->rx.cons++;
        }
}
 
/**
 * Poll for completed and received packets
 *
 * @v netdev            Network device
 */
static void rdc_poll ( struct net_device *netdev ) {
        struct rdc_nic *rdc = netdev->priv;
        uint16_t misr;
 
        /* Check for (and acknowledge) interrupts */
        misr = readw ( rdc->regs + RDC_MISR );
 
        /* Poll for TX completions, if applicable */
        if ( misr & RDC_MIRQ_TX )
                rdc_poll_tx ( netdev );
 
        /* Poll for RX completions, if applicable */
        if ( misr & RDC_MIRQ_RX )
                rdc_poll_rx ( netdev );
 
        /* Check link state, if applicable */
        if ( misr & RDC_MIRQ_LINK )
                rdc_check_link ( netdev );
 
        /* Check for unexpected interrupts */
        if ( misr & ~( RDC_MIRQ_LINK | RDC_MIRQ_TX | RDC_MIRQ_RX_EARLY |
                       RDC_MIRQ_RX_EMPTY | RDC_MIRQ_RX ) ) {
                DBGC ( rdc, "RDC %p unexpected MISR %#04x\n", rdc, misr );
                /* Report as a TX error */
                netdev_tx_err ( netdev, NULL, -ENOTSUP );
        }
 
        /* Refill receive ring */
        rdc_refill_rx ( rdc );
}
 
/**
 * Enable or disable interrupts
 *
 * @v netdev            Network device
 * @v enable            Interrupts should be enabled
 */
static void rdc_irq ( struct net_device *netdev, int enable ) {
        struct rdc_nic *rdc = netdev->priv;
        uint16_t mier;
 
        /* Enable/disable interrupts */
        mier = ( enable ? ( RDC_MIRQ_LINK | RDC_MIRQ_TX | RDC_MIRQ_RX ) : 0 );
        writew ( mier, rdc->regs + RDC_MIER );
}
 
/** RDC network device operations */
static struct net_device_operations rdc_operations = {
        .open           = rdc_open,
        .close          = rdc_close,
        .transmit       = rdc_transmit,
        .poll           = rdc_poll,
        .irq            = rdc_irq,
};
 
/******************************************************************************
 *
 * PCI interface
 *
 ******************************************************************************
 */
 
/**
 * Probe PCI device
 *
 * @v pci               PCI device
 * @ret rc              Return status code
 */
static int rdc_probe ( struct pci_device *pci ) {
        struct net_device *netdev;
        struct rdc_nic *rdc;
        union rdc_mac mac;
        int rc;
 
        /* Allocate and initialise net device */
        netdev = alloc_etherdev ( sizeof ( *rdc ) );
        if ( ! netdev ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        netdev_init ( netdev, &rdc_operations );
        rdc = netdev->priv;
        pci_set_drvdata ( pci, netdev );
        netdev->dev = &pci->dev;
        memset ( rdc, 0, sizeof ( *rdc ) );
        rdc->dma = &pci->dma;
        mdio_init ( &rdc->mdio, &rdc_mii_operations );
        mii_init ( &rdc->mii, &rdc->mdio, 0 );
        rdc_init_ring ( &rdc->tx, RDC_NUM_TX_DESC, RDC_MTDSA );
        rdc_init_ring ( &rdc->rx, RDC_NUM_RX_DESC, RDC_MRDSA );
 
        /* Fix up PCI device */
        adjust_pci_device ( pci );
 
        /* Map registers */
        rdc->regs = pci_ioremap ( pci, pci->membase, RDC_BAR_SIZE );
        if ( ! rdc->regs ) {
                rc = -ENODEV;
                goto err_ioremap;
        }
 
        /* Fetch MAC address */
        mac.mid[0] = cpu_to_le16 ( readw ( rdc->regs + RDC_MID0 ) );
        mac.mid[1] = cpu_to_le16 ( readw ( rdc->regs + RDC_MID1 ) );
        mac.mid[2] = cpu_to_le16 ( readw ( rdc->regs + RDC_MID2 ) );
        memcpy ( netdev->hw_addr, mac.raw, ETH_ALEN );
 
        /* Reset the NIC */
        if ( ( rc = rdc_reset ( rdc ) ) != 0 )
                goto err_reset;
 
        /* Initialise PHY */
        if ( ( rc = rdc_init_phy ( rdc ) ) != 0 )
                goto err_init_phy;
 
        /* Register network device */
        if ( ( rc = register_netdev ( netdev ) ) != 0 )
                goto err_register_netdev;
 
        /* Set initial link state */
        rdc_check_link ( netdev );
 
        return 0;
 
        unregister_netdev ( netdev );
 err_register_netdev:
 err_init_phy:
        rdc_reset ( rdc );
 err_reset:
        iounmap ( rdc->regs );
 err_ioremap:
        netdev_nullify ( netdev );
        netdev_put ( netdev );
 err_alloc:
        return rc;
}
 
/**
 * Remove PCI device
 *
 * @v pci               PCI device
 */
static void rdc_remove ( struct pci_device *pci ) {
        struct net_device *netdev = pci_get_drvdata ( pci );
        struct rdc_nic *rdc = netdev->priv;
 
        /* Unregister network device */
        unregister_netdev ( netdev );
 
        /* Reset card */
        rdc_reset ( rdc );
 
        /* Free network device */
        iounmap ( rdc->regs );
        netdev_nullify ( netdev );
        netdev_put ( netdev );
}
 
/** RDC PCI device IDs */
static struct pci_device_id rdc_nics[] = {
        PCI_ROM ( 0x17f3, 0x6040, "r6040", "RDC R6040", 0 ),
};
 
/** RDC PCI driver */
struct pci_driver rdc_driver __pci_driver = {
        .ids = rdc_nics,
        .id_count = ( sizeof ( rdc_nics ) / sizeof ( rdc_nics[0] ) ),
        .probe = rdc_probe,
        .remove = rdc_remove,
};