/*
* Copyright (C) 2012 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 <ipxe/mii.h>
#include "myson.h"
/** @file
*
* Myson Technology network card driver
*
*/
/******************************************************************************
*
* Device reset
*
******************************************************************************
*/
/**
* Reset controller chip
*
* @v myson Myson device
* @ret rc Return status code
*/
static int myson_soft_reset ( struct myson_nic *myson ) {
uint32_t bcr;
unsigned int i;
/* Initiate reset */
bcr = readl ( myson->regs + MYSON_BCR );
writel ( ( bcr | MYSON_BCR_SWR ), myson->regs + MYSON_BCR );
/* Wait for reset to complete */
for ( i = 0 ; i < MYSON_RESET_MAX_WAIT_MS ; i++ ) {
/* If reset is not complete, delay 1ms and retry */
if ( readl ( myson->regs + MYSON_BCR ) & MYSON_BCR_SWR ) {
mdelay ( 1 );
continue;
}
/* Apply a sensible default bus configuration */
bcr = readl ( myson->regs + MYSON_BCR );
bcr &= ~MYSON_BCR_PBL_MASK;
bcr |= ( MYSON_BCR_RLE | MYSON_BCR_RME | MYSON_BCR_WIE |
MYSON_BCR_PBL_DEFAULT );
writel ( bcr, myson->regs + MYSON_BCR );
DBGC ( myson, "MYSON %p using configuration %08x\n",
myson, bcr );
return 0;
}
DBGC ( myson, "MYSON %p timed out waiting for reset\n", myson );
return -ETIMEDOUT;
}
/**
* Reload configuration from EEPROM
*
* @v myson Myson device
* @ret rc Return status code
*/
static int myson_reload_config ( struct myson_nic *myson ) {
unsigned int i;
/* Initiate reload */
writel ( MYSON_ROM_AUTOLD, myson->regs + MYSON_ROM_MII );
/* Wait for reload to complete */
for ( i = 0 ; i < MYSON_AUTOLD_MAX_WAIT_MS ; i++ ) {
/* If reload is not complete, delay 1ms and retry */
if ( readl ( myson->regs + MYSON_ROM_MII ) & MYSON_ROM_AUTOLD ){
mdelay ( 1 );
continue;
}
return 0;
}
DBGC ( myson, "MYSON %p timed out waiting for configuration "
"reload\n", myson );
return -ETIMEDOUT;
}
/**
* Reset hardware
*
* @v myson Myson device
* @ret rc Return status code
*/
static int myson_reset ( struct myson_nic *myson ) {
int rc;
/* Disable all interrupts */
writel ( 0, myson->regs + MYSON_IMR );
/* Perform soft reset */
if ( ( rc = myson_soft_reset ( myson ) ) != 0 )
return rc;
/* Reload configuration from EEPROM */
if ( ( rc = myson_reload_config ( myson ) ) != 0 )
return rc;
return 0;
}
/******************************************************************************
*
* Network device interface
*
******************************************************************************
*/
/**
* Create descriptor ring
*
* @v myson Myson device
* @v ring Descriptor ring
* @ret rc Return status code
*/
static int myson_create_ring ( struct myson_nic *myson,
struct myson_ring *ring ) {
size_t len = ( ring->count * sizeof ( ring->desc[0] ) );
struct myson_descriptor *desc;
struct myson_descriptor *next;
physaddr_t address;
unsigned int i;
int rc;
/* Allocate descriptor ring */
ring->desc = malloc_dma ( len, MYSON_RING_ALIGN );
if ( ! ring->desc ) {
rc = -ENOMEM;
goto err_alloc;
}
address = virt_to_bus ( ring->desc );
/* Check address is usable by card */
if ( ! myson_address_ok ( address + len ) ) {
DBGC ( myson, "MYSON %p cannot support 64-bit ring address\n",
myson );
rc = -ENOTSUP;
goto err_64bit;
}
/* 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 ];
desc->next = cpu_to_le32 ( virt_to_bus ( next ) );
}
/* Program ring address */
writel ( address, myson->regs + ring->reg );
DBGC ( myson, "MYSON %p ring %02x is at [%08llx,%08llx)\n",
myson, ring->reg, ( ( unsigned long long ) address ),
( ( unsigned long long ) address + len ) );
return 0;
err_64bit:
free_dma ( ring->desc, len );
ring->desc = NULL;
err_alloc:
return rc;
}
/**
* Destroy descriptor ring
*
* @v myson Myson device
* @v ring Descriptor ring
*/
static void myson_destroy_ring ( struct myson_nic *myson,
struct myson_ring *ring ) {
size_t len = ( ring->count * sizeof ( ring->desc[0] ) );
/* Clear ring address */
writel ( 0, myson->regs + ring->reg );
/* Free descriptor ring */
free_dma ( ring->desc, len );
ring->desc = NULL;
ring->prod = 0;
ring->cons = 0;
}
/**
* Refill receive descriptor ring
*
* @v netdev Network device
*/
static void myson_refill_rx ( struct net_device *netdev ) {
struct myson_nic *myson = netdev->priv;
struct myson_descriptor *rx;
struct io_buffer *iobuf;
unsigned int rx_idx;
physaddr_t address;
while ( ( myson->rx.prod - myson->rx.cons ) < MYSON_NUM_RX_DESC ) {
/* Allocate I/O buffer */
iobuf = alloc_iob ( MYSON_RX_MAX_LEN );
if ( ! iobuf ) {
/* Wait for next refill */
return;
}
/* Check address is usable by card */
address = virt_to_bus ( iobuf->data );
if ( ! myson_address_ok ( address ) ) {
DBGC ( myson, "MYSON %p cannot support 64-bit RX "
"buffer address\n", myson );
netdev_rx_err ( netdev, iobuf, -ENOTSUP );
return;
}
/* Get next receive descriptor */
rx_idx = ( myson->rx.prod++ % MYSON_NUM_RX_DESC );
rx = &myson->rx.desc[rx_idx];
/* Populate receive descriptor */
rx->address = cpu_to_le32 ( address );
rx->control =
cpu_to_le32 ( MYSON_RX_CTRL_RBS ( MYSON_RX_MAX_LEN ) );
wmb();
rx->status = cpu_to_le32 ( MYSON_RX_STAT_OWN );
wmb();
/* Record I/O buffer */
assert ( myson->rx_iobuf[rx_idx] == NULL );
myson->rx_iobuf[rx_idx] = iobuf;
/* Notify card that there are descriptors available */
writel ( 0, myson->regs + MYSON_RXPDR );
DBGC2 ( myson, "MYSON %p RX %d is [%llx,%llx)\n", myson,
rx_idx, ( ( unsigned long long ) address ),
( ( unsigned long long ) address + MYSON_RX_MAX_LEN ) );
}
}
/**
* Open network device
*
* @v netdev Network device
* @ret rc Return status code
*/
static int myson_open ( struct net_device *netdev ) {
struct myson_nic *myson = netdev->priv;
union myson_physical_address mac;
int rc;
/* Set MAC address */
memset ( &mac, 0, sizeof ( mac ) );
memcpy ( mac.raw, netdev->ll_addr, ETH_ALEN );
writel ( le32_to_cpu ( mac.reg.low ), myson->regs + MYSON_PAR0 );
writel ( le32_to_cpu ( mac.reg.high ), myson->regs + MYSON_PAR4 );
/* Create transmit descriptor ring */
if ( ( rc = myson_create_ring ( myson, &myson->tx ) ) != 0 )
goto err_create_tx;
/* Create receive descriptor ring */
if ( ( rc = myson_create_ring ( myson, &myson->rx ) ) != 0 )
goto err_create_rx;
/* Configure transmitter and receiver */
writel ( ( MYSON_TCR_TE | MYSON_RCR_PROM | MYSON_RCR_AB | MYSON_RCR_AM |
MYSON_RCR_ARP | MYSON_RCR_ALP | MYSON_RCR_RE ),
myson->regs + MYSON_TCR_RCR );
/* Fill receive ring */
myson_refill_rx ( netdev );
return 0;
myson_destroy_ring ( myson, &myson->rx );
err_create_rx:
myson_destroy_ring ( myson, &myson->tx );
err_create_tx:
return rc;
}
/**
* Wait for transmit and receive to become idle
*
* @v myson Myson device
* @ret rc Return status code
*/
static int myson_wait_idle ( struct myson_nic *myson ) {
uint32_t tcr_rcr;
unsigned int i;
/* Wait for both transmit and receive to be idle */
for ( i = 0 ; i < MYSON_IDLE_MAX_WAIT_MS ; i++ ) {
/* If either process is running, delay 1ms and retry */
tcr_rcr = readl ( myson->regs + MYSON_TCR_RCR );
if ( tcr_rcr & ( MYSON_TCR_TXS | MYSON_RCR_RXS ) ) {
mdelay ( 1 );
continue;
}
return 0;
}
DBGC ( myson, "MYSON %p timed out waiting for idle state (status "
"%08x)\n", myson, tcr_rcr );
return -ETIMEDOUT;
}
/**
* Close network device
*
* @v netdev Network device
*/
static void myson_close ( struct net_device *netdev ) {
struct myson_nic *myson = netdev->priv;
unsigned int i;
/* Disable receiver and transmitter */
writel ( 0, myson->regs + MYSON_TCR_RCR );
/* Allow time for receiver and transmitter to become idle */
myson_wait_idle ( myson );
/* Destroy receive descriptor ring */
myson_destroy_ring ( myson, &myson->rx );
/* Discard any unused receive buffers */
for ( i = 0 ; i < MYSON_NUM_RX_DESC ; i++ ) {
if ( myson->rx_iobuf[i] )
free_iob ( myson->rx_iobuf[i] );
myson->rx_iobuf[i] = NULL;
}
/* Destroy transmit descriptor ring */
myson_destroy_ring ( myson, &myson->tx );
}
/**
* Transmit packet
*
* @v netdev Network device
* @v iobuf I/O buffer
* @ret rc Return status code
*/
static int myson_transmit ( struct net_device *netdev,
struct io_buffer *iobuf ) {
struct myson_nic *myson = netdev->priv;
struct myson_descriptor *tx;
unsigned int tx_idx;
physaddr_t address;
/* Check address is usable by card */
address = virt_to_bus ( iobuf->data );
if ( ! myson_address_ok ( address ) ) {
DBGC ( myson, "MYSON %p cannot support 64-bit TX buffer "
"address\n", myson );
return -ENOTSUP;
}
/* Get next transmit descriptor */
if ( ( myson->tx.prod - myson->tx.cons ) >= MYSON_NUM_TX_DESC ) {
DBGC ( myson, "MYSON %p out of transmit descriptors\n",
myson );
return -ENOBUFS;
}
tx_idx = ( myson->tx.prod++ % MYSON_NUM_TX_DESC );
tx = &myson->tx.desc[tx_idx];
/* Populate transmit descriptor */
tx->address = cpu_to_le32 ( address );
tx->control = cpu_to_le32 ( MYSON_TX_CTRL_IC | MYSON_TX_CTRL_LD |
MYSON_TX_CTRL_FD | MYSON_TX_CTRL_CRC |
MYSON_TX_CTRL_PAD | MYSON_TX_CTRL_RTLC |
MYSON_TX_CTRL_PKTS ( iob_len ( iobuf ) ) |
MYSON_TX_CTRL_TBS ( iob_len ( iobuf ) ) );
wmb();
tx->status = cpu_to_le32 ( MYSON_TX_STAT_OWN );
wmb();
/* Notify card that there are packets ready to transmit */
writel ( 0, myson->regs + MYSON_TXPDR );
DBGC2 ( myson, "MYSON %p TX %d is [%llx,%llx)\n", myson, tx_idx,
( ( unsigned long long ) address ),
( ( unsigned long long ) address + iob_len ( iobuf ) ) );
return 0;
}
/**
* Poll for completed packets
*
* @v netdev Network device
*/
static void myson_poll_tx ( struct net_device *netdev ) {
struct myson_nic *myson = netdev->priv;
struct myson_descriptor *tx;
unsigned int tx_idx;
/* Check for completed packets */
while ( myson->tx.cons != myson->tx.prod ) {
/* Get next transmit descriptor */
tx_idx = ( myson->tx.cons % MYSON_NUM_TX_DESC );
tx = &myson->tx.desc[tx_idx];
/* Stop if descriptor is still in use */
if ( tx->status & cpu_to_le32 ( MYSON_TX_STAT_OWN ) )
return;
/* Complete TX descriptor */
if ( tx->status & cpu_to_le32 ( MYSON_TX_STAT_ABORT |
MYSON_TX_STAT_CSL ) ) {
DBGC ( myson, "MYSON %p TX %d completion error "
"(%08x)\n", myson, tx_idx,
le32_to_cpu ( tx->status ) );
netdev_tx_complete_next_err ( netdev, -EIO );
} else {
DBGC2 ( myson, "MYSON %p TX %d complete\n",
myson, tx_idx );
netdev_tx_complete_next ( netdev );
}
myson->tx.cons++;
}
}
/**
* Poll for received packets
*
* @v netdev Network device
*/
static void myson_poll_rx ( struct net_device *netdev ) {
struct myson_nic *myson = netdev->priv;
struct myson_descriptor *rx;
struct io_buffer *iobuf;
unsigned int rx_idx;
size_t len;
/* Check for received packets */
while ( myson->rx.cons != myson->rx.prod ) {
/* Get next receive descriptor */
rx_idx = ( myson->rx.cons % MYSON_NUM_RX_DESC );
rx = &myson->rx.desc[rx_idx];
/* Stop if descriptor is still in use */
if ( rx->status & MYSON_RX_STAT_OWN )
return;
/* Populate I/O buffer */
iobuf = myson->rx_iobuf[rx_idx];
myson->rx_iobuf[rx_idx] = NULL;
len = MYSON_RX_STAT_FLNG ( le32_to_cpu ( rx->status ) );
iob_put ( iobuf, len - 4 /* strip CRC */ );
/* Hand off to network stack */
if ( rx->status & cpu_to_le32 ( MYSON_RX_STAT_ES ) ) {
DBGC ( myson, "MYSON %p RX %d error (length %zd, "
"status %08x)\n", myson, rx_idx, len,
le32_to_cpu ( rx->status ) );
netdev_rx_err ( netdev, iobuf, -EIO );
} else {
DBGC2 ( myson, "MYSON %p RX %d complete (length "
"%zd)\n", myson, rx_idx, len );
netdev_rx ( netdev, iobuf );
}
myson->rx.cons++;
}
}
/**
* Poll for completed and received packets
*
* @v netdev Network device
*/
static void myson_poll ( struct net_device *netdev ) {
struct myson_nic *myson = netdev->priv;
uint32_t isr;
unsigned int i;
/* Polling the ISR seems to really upset this card; it ends up
* getting no useful PCI transfers done and, for some reason,
* flooding the network with invalid packets. Work around
* this by introducing deliberate delays between ISR reads.
*/
for ( i = 0 ; i < MYSON_ISR_IODELAY_COUNT ; i++ )
iodelay();
/* Check for and acknowledge interrupts */
isr = readl ( myson->regs + MYSON_ISR );
if ( ! isr )
return;
writel ( isr, myson->regs + MYSON_ISR );
/* Poll for TX completions, if applicable */
if ( isr & MYSON_IRQ_TI )
myson_poll_tx ( netdev );
/* Poll for RX completionsm, if applicable */
if ( isr & MYSON_IRQ_RI )
myson_poll_rx ( netdev );
/* Refill RX ring */
myson_refill_rx ( netdev );
}
/**
* Enable or disable interrupts
*
* @v netdev Network device
* @v enable Interrupts should be enabled
*/
static void myson_irq ( struct net_device *netdev, int enable ) {
struct myson_nic *myson = netdev->priv;
uint32_t imr;
imr = ( enable ? ( MYSON_IRQ_TI | MYSON_IRQ_RI ) : 0 );
writel ( imr, myson->regs + MYSON_IMR );
}
/** Myson network device operations */
static struct net_device_operations myson_operations = {
.open = myson_open,
.close = myson_close,
.transmit = myson_transmit,
.poll = myson_poll,
.irq = myson_irq,
};
/******************************************************************************
*
* PCI interface
*
******************************************************************************
*/
/**
* Probe PCI device
*
* @v pci PCI device
* @ret rc Return status code
*/
static int myson_probe ( struct pci_device *pci ) {
struct net_device *netdev;
struct myson_nic *myson;
union myson_physical_address mac;
int rc;
/* Allocate and initialise net device */
netdev = alloc_etherdev ( sizeof ( *myson ) );
if ( ! netdev ) {
rc = -ENOMEM;
goto err_alloc;
}
netdev_init ( netdev, &myson_operations );
myson = netdev->priv;
pci_set_drvdata ( pci, netdev );
netdev->dev = &pci->dev;
memset ( myson, 0, sizeof ( *myson ) );
myson_init_ring ( &myson->tx, MYSON_NUM_TX_DESC, MYSON_TXLBA );
myson_init_ring ( &myson->rx, MYSON_NUM_RX_DESC, MYSON_RXLBA );
/* Fix up PCI device */
adjust_pci_device ( pci );
/* Map registers */
myson->regs = ioremap ( pci->membase, MYSON_BAR_SIZE );
if ( ! myson->regs ) {
rc = -ENODEV;
goto err_ioremap;
}
/* Reset the NIC */
if ( ( rc = myson_reset ( myson ) ) != 0 )
goto err_reset;
/* Read MAC address */
mac.reg.low = cpu_to_le32 ( readl ( myson->regs + MYSON_PAR0 ) );
mac.reg.high = cpu_to_le32 ( readl ( myson->regs + MYSON_PAR4 ) );
memcpy ( netdev->hw_addr, mac.raw, ETH_ALEN );
/* Register network device */
if ( ( rc = register_netdev ( netdev ) ) != 0 )
goto err_register_netdev;
/* Mark as link up; we don't yet handle link state */
netdev_link_up ( netdev );
return 0;
unregister_netdev ( netdev );
err_register_netdev:
myson_reset ( myson );
err_reset:
iounmap ( myson->regs );
err_ioremap:
netdev_nullify ( netdev );
netdev_put ( netdev );
err_alloc:
return rc;
}
/**
* Remove PCI device
*
* @v pci PCI device
*/
static void myson_remove ( struct pci_device *pci ) {
struct net_device *netdev = pci_get_drvdata ( pci );
struct myson_nic *myson = netdev->priv;
/* Unregister network device */
unregister_netdev ( netdev );
/* Reset card */
myson_reset ( myson );
/* Free network device */
iounmap ( myson->regs );
netdev_nullify ( netdev );
netdev_put ( netdev );
}
/** Myson PCI device IDs */
static struct pci_device_id myson_nics[] = {
PCI_ROM ( 0x1516, 0x0800, "mtd800", "MTD-8xx", 0 ),
PCI_ROM ( 0x1516, 0x0803, "mtd803", "Surecom EP-320X-S", 0 ),
PCI_ROM ( 0x1516, 0x0891, "mtd891", "MTD-8xx", 0 ),
};
/** Myson PCI driver */
struct pci_driver myson_driver __pci_driver = {
.ids = myson_nics,
.id_count = ( sizeof ( myson_nics ) / sizeof ( myson_nics[0] ) ),
.probe = myson_probe,
.remove = myson_remove,
};
