Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-12-27 05:11:48 +00:00
Code Issues Packages Projects Releases Wiki Activity
293f2ba897
linux/drivers/net/arm/ks8695net.c
Eric Dumazet 1ae5dc342a net: trans_start cleanups 
Now that core network takes care of trans_start updates, dont do it
in drivers themselves, if possible. Drivers can avoid one cache miss
(on dev->trans_start) in their start_xmit() handler.

Exceptions are NETIF_F_LLTX drivers

Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-05-10 05:01:31 -07:00

1752 lines
45 KiB
C
Raw Blame History

/*
* Micrel KS8695 (Centaur) Ethernet.
*
* 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.
*
* Copyright 2008 Simtec Electronics
* Daniel Silverstone <dsilvers@simtec.co.uk>
* Vincent Sanders <vince@simtec.co.uk>
*/
#include <linux/module.h>
#include <linux/ioport.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/init.h>
#include <linux/skbuff.h>
#include <linux/spinlock.h>
#include <linux/crc32.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/irq.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <asm/irq.h>
#include <mach/regs-switch.h>
#include <mach/regs-misc.h>
#include <asm/mach/irq.h>
#include <mach/regs-irq.h>
#include "ks8695net.h"
#define MODULENAME "ks8695_ether"
#define MODULEVERSION "1.02"
/*
* Transmit and device reset timeout, default 5 seconds.
*/
static int watchdog = 5000;
/* Hardware structures */
/**
* struct rx_ring_desc - Receive descriptor ring element
* @status: The status of the descriptor element (E.g. who owns it)
* @length: The number of bytes in the block pointed to by data_ptr
* @data_ptr: The physical address of the data block to receive into
* @next_desc: The physical address of the next descriptor element.
*/
struct rx_ring_desc {
__le32 status;
__le32 length;
__le32 data_ptr;
__le32 next_desc;
};
/**
* struct tx_ring_desc - Transmit descriptor ring element
* @owner: Who owns the descriptor
* @status: The number of bytes in the block pointed to by data_ptr
* @data_ptr: The physical address of the data block to receive into
* @next_desc: The physical address of the next descriptor element.
*/
struct tx_ring_desc {
__le32 owner;
__le32 status;
__le32 data_ptr;
__le32 next_desc;
};
/**
* struct ks8695_skbuff - sk_buff wrapper for rx/tx rings.
* @skb: The buffer in the ring
* @dma_ptr: The mapped DMA pointer of the buffer
* @length: The number of bytes mapped to dma_ptr
*/
struct ks8695_skbuff {
struct sk_buff *skb;
dma_addr_t dma_ptr;
u32 length;
};
/* Private device structure */
#define MAX_TX_DESC 8
#define MAX_TX_DESC_MASK 0x7
#define MAX_RX_DESC 16
#define MAX_RX_DESC_MASK 0xf
/*napi_weight have better more than rx DMA buffers*/
#define NAPI_WEIGHT 64
#define MAX_RXBUF_SIZE 0x700
#define TX_RING_DMA_SIZE (sizeof(struct tx_ring_desc) * MAX_TX_DESC)
#define RX_RING_DMA_SIZE (sizeof(struct rx_ring_desc) * MAX_RX_DESC)
#define RING_DMA_SIZE (TX_RING_DMA_SIZE + RX_RING_DMA_SIZE)
/**
* enum ks8695_dtype - Device type
* @KS8695_DTYPE_WAN: This device is a WAN interface
* @KS8695_DTYPE_LAN: This device is a LAN interface
* @KS8695_DTYPE_HPNA: This device is an HPNA interface
*/
enum ks8695_dtype {
KS8695_DTYPE_WAN,
KS8695_DTYPE_LAN,
KS8695_DTYPE_HPNA,
};
/**
* struct ks8695_priv - Private data for the KS8695 Ethernet
* @in_suspend: Flag to indicate if we're suspending/resuming
* @ndev: The net_device for this interface
* @dev: The platform device object for this interface
* @dtype: The type of this device
* @io_regs: The ioremapped registers for this interface
* @napi : Add support NAPI for Rx
* @rx_irq_name: The textual name of the RX IRQ from the platform data
* @tx_irq_name: The textual name of the TX IRQ from the platform data
* @link_irq_name: The textual name of the link IRQ from the
* platform data if available
* @rx_irq: The IRQ number for the RX IRQ
* @tx_irq: The IRQ number for the TX IRQ
* @link_irq: The IRQ number for the link IRQ if available
* @regs_req: The resource request for the registers region
* @phyiface_req: The resource request for the phy/switch region
* if available
* @phyiface_regs: The ioremapped registers for the phy/switch if available
* @ring_base: The base pointer of the dma coherent memory for the rings
* @ring_base_dma: The DMA mapped equivalent of ring_base
* @tx_ring: The pointer in ring_base of the TX ring
* @tx_ring_used: The number of slots in the TX ring which are occupied
* @tx_ring_next_slot: The next slot to fill in the TX ring
* @tx_ring_dma: The DMA mapped equivalent of tx_ring
* @tx_buffers: The sk_buff mappings for the TX ring
* @txq_lock: A lock to protect the tx_buffers tx_ring_used etc variables
* @rx_ring: The pointer in ring_base of the RX ring
* @rx_ring_dma: The DMA mapped equivalent of rx_ring
* @rx_buffers: The sk_buff mappings for the RX ring
* @next_rx_desc_read: The next RX descriptor to read from on IRQ
* @rx_lock: A lock to protect Rx irq function
* @msg_enable: The flags for which messages to emit
*/
struct ks8695_priv {
int in_suspend;
struct net_device *ndev;
struct device *dev;
enum ks8695_dtype dtype;
void __iomem *io_regs;
struct napi_struct napi;
const char *rx_irq_name, *tx_irq_name, *link_irq_name;
int rx_irq, tx_irq, link_irq;
struct resource *regs_req, *phyiface_req;
void __iomem *phyiface_regs;
void *ring_base;
dma_addr_t ring_base_dma;
struct tx_ring_desc *tx_ring;
int tx_ring_used;
int tx_ring_next_slot;
dma_addr_t tx_ring_dma;
struct ks8695_skbuff tx_buffers[MAX_TX_DESC];
spinlock_t txq_lock;
struct rx_ring_desc *rx_ring;
dma_addr_t rx_ring_dma;
struct ks8695_skbuff rx_buffers[MAX_RX_DESC];
int next_rx_desc_read;
spinlock_t rx_lock;
int msg_enable;
};
/* Register access */
/**
* ks8695_readreg - Read from a KS8695 ethernet register
* @ksp: The device to read from
* @reg: The register to read
*/
static inline u32
ks8695_readreg(struct ks8695_priv *ksp, int reg)
{
return readl(ksp->io_regs + reg);
}
/**
* ks8695_writereg - Write to a KS8695 ethernet register
* @ksp: The device to write to
* @reg: The register to write
* @value: The value to write to the register
*/
static inline void
ks8695_writereg(struct ks8695_priv *ksp, int reg, u32 value)
{
writel(value, ksp->io_regs + reg);
}
/* Utility functions */
/**
* ks8695_port_type - Retrieve port-type as user-friendly string
* @ksp: The device to return the type for
*
* Returns a string indicating which of the WAN, LAN or HPNA
* ports this device is likely to represent.
*/
static const char *
ks8695_port_type(struct ks8695_priv *ksp)
{
switch (ksp->dtype) {
case KS8695_DTYPE_LAN:
return "LAN";
case KS8695_DTYPE_WAN:
return "WAN";
case KS8695_DTYPE_HPNA:
return "HPNA";
}
return "UNKNOWN";
}
/**
* ks8695_update_mac - Update the MAC registers in the device
* @ksp: The device to update
*
* Updates the MAC registers in the KS8695 device from the address in the
* net_device structure associated with this interface.
*/
static void
ks8695_update_mac(struct ks8695_priv *ksp)
{
/* Update the HW with the MAC from the net_device */
struct net_device *ndev = ksp->ndev;
u32 machigh, maclow;
maclow = ((ndev->dev_addr[2] << 24) | (ndev->dev_addr[3] << 16) |
(ndev->dev_addr[4] << 8) | (ndev->dev_addr[5] << 0));
machigh = ((ndev->dev_addr[0] << 8) | (ndev->dev_addr[1] << 0));
ks8695_writereg(ksp, KS8695_MAL, maclow);
ks8695_writereg(ksp, KS8695_MAH, machigh);
}
/**
* ks8695_refill_rxbuffers - Re-fill the RX buffer ring
* @ksp: The device to refill
*
* Iterates the RX ring of the device looking for empty slots.
* For each empty slot, we allocate and map a new SKB and give it
* to the hardware.
* This can be called from interrupt context safely.
*/
static void
ks8695_refill_rxbuffers(struct ks8695_priv *ksp)
{
/* Run around the RX ring, filling in any missing sk_buff's */
int buff_n;
for (buff_n = 0; buff_n < MAX_RX_DESC; ++buff_n) {
if (!ksp->rx_buffers[buff_n].skb) {
struct sk_buff *skb = dev_alloc_skb(MAX_RXBUF_SIZE);
dma_addr_t mapping;
ksp->rx_buffers[buff_n].skb = skb;
if (skb == NULL) {
/* Failed to allocate one, perhaps
* we'll try again later.
*/
break;
}
mapping = dma_map_single(ksp->dev, skb->data,
MAX_RXBUF_SIZE,
DMA_FROM_DEVICE);
if (unlikely(dma_mapping_error(ksp->dev, mapping))) {
/* Failed to DMA map this SKB, try later */
dev_kfree_skb_irq(skb);
ksp->rx_buffers[buff_n].skb = NULL;
break;
}
ksp->rx_buffers[buff_n].dma_ptr = mapping;
skb->dev = ksp->ndev;
ksp->rx_buffers[buff_n].length = MAX_RXBUF_SIZE;
/* Record this into the DMA ring */
ksp->rx_ring[buff_n].data_ptr = cpu_to_le32(mapping);
ksp->rx_ring[buff_n].length =
cpu_to_le32(MAX_RXBUF_SIZE);
wmb();
/* And give ownership over to the hardware */
ksp->rx_ring[buff_n].status = cpu_to_le32(RDES_OWN);
}
}
}
/* Maximum number of multicast addresses which the KS8695 HW supports */
#define KS8695_NR_ADDRESSES 16
/**
* ks8695_init_partial_multicast - Init the mcast addr registers
* @ksp: The device to initialise
* @addr: The multicast address list to use
* @nr_addr: The number of addresses in the list
*
* This routine is a helper for ks8695_set_multicast - it writes
* the additional-address registers in the KS8695 ethernet device
* and cleans up any others left behind.
*/
static void
ks8695_init_partial_multicast(struct ks8695_priv *ksp,
struct net_device *ndev)
{
u32 low, high;
int i;
struct netdev_hw_addr *ha;
i = 0;
netdev_for_each_mc_addr(ha, ndev) {
/* Ran out of space in chip? */
BUG_ON(i == KS8695_NR_ADDRESSES);
low = (ha->addr[2] << 24) | (ha->addr[3] << 16) |
(ha->addr[4] << 8) | (ha->addr[5]);
high = (ha->addr[0] << 8) | (ha->addr[1]);
ks8695_writereg(ksp, KS8695_AAL_(i), low);
ks8695_writereg(ksp, KS8695_AAH_(i), AAH_E | high);
i++;
}
/* Clear the remaining Additional Station Addresses */
for (; i < KS8695_NR_ADDRESSES; i++) {
ks8695_writereg(ksp, KS8695_AAL_(i), 0);
ks8695_writereg(ksp, KS8695_AAH_(i), 0);
}
}
/* Interrupt handling */
/**
* ks8695_tx_irq - Transmit IRQ handler
* @irq: The IRQ which went off (ignored)
* @dev_id: The net_device for the interrupt
*
* Process the TX ring, clearing out any transmitted slots.
* Allows the net_device to pass us new packets once slots are
* freed.
*/
static irqreturn_t
ks8695_tx_irq(int irq, void *dev_id)
{
struct net_device *ndev = (struct net_device *)dev_id;
struct ks8695_priv *ksp = netdev_priv(ndev);
int buff_n;
for (buff_n = 0; buff_n < MAX_TX_DESC; ++buff_n) {
if (ksp->tx_buffers[buff_n].skb &&
!(ksp->tx_ring[buff_n].owner & cpu_to_le32(TDES_OWN))) {
rmb();
/* An SKB which is not owned by HW is present */
/* Update the stats for the net_device */
ndev->stats.tx_packets++;
ndev->stats.tx_bytes += ksp->tx_buffers[buff_n].length;
/* Free the packet from the ring */
ksp->tx_ring[buff_n].data_ptr = 0;
/* Free the sk_buff */
dma_unmap_single(ksp->dev,
ksp->tx_buffers[buff_n].dma_ptr,
ksp->tx_buffers[buff_n].length,
DMA_TO_DEVICE);
dev_kfree_skb_irq(ksp->tx_buffers[buff_n].skb);
ksp->tx_buffers[buff_n].skb = NULL;
ksp->tx_ring_used--;
}
}
netif_wake_queue(ndev);
return IRQ_HANDLED;
}
/**
* ks8695_get_rx_enable_bit - Get rx interrupt enable/status bit
* @ksp: Private data for the KS8695 Ethernet
*
* For KS8695 document:
* Interrupt Enable Register (offset 0xE204)
* Bit29 : WAN MAC Receive Interrupt Enable
* Bit16 : LAN MAC Receive Interrupt Enable
* Interrupt Status Register (Offset 0xF208)
* Bit29: WAN MAC Receive Status
* Bit16: LAN MAC Receive Status
* So, this Rx interrrupt enable/status bit number is equal
* as Rx IRQ number.
*/
static inline u32 ks8695_get_rx_enable_bit(struct ks8695_priv *ksp)
{
return ksp->rx_irq;
}
/**
* ks8695_rx_irq - Receive IRQ handler
* @irq: The IRQ which went off (ignored)
* @dev_id: The net_device for the interrupt
*
* Inform NAPI that packet reception needs to be scheduled
*/
static irqreturn_t
ks8695_rx_irq(int irq, void *dev_id)
{
struct net_device *ndev = (struct net_device *)dev_id;
struct ks8695_priv *ksp = netdev_priv(ndev);
spin_lock(&ksp->rx_lock);
if (napi_schedule_prep(&ksp->napi)) {
unsigned long status = readl(KS8695_IRQ_VA + KS8695_INTEN);
unsigned long mask_bit = 1 << ks8695_get_rx_enable_bit(ksp);
/*disable rx interrupt*/
status &= ~mask_bit;
writel(status , KS8695_IRQ_VA + KS8695_INTEN);
__napi_schedule(&ksp->napi);
}
spin_unlock(&ksp->rx_lock);
return IRQ_HANDLED;
}
/**
* ks8695_rx - Receive packets called by NAPI poll method
* @ksp: Private data for the KS8695 Ethernet
* @budget: Number of packets allowed to process
*/
static int ks8695_rx(struct ks8695_priv *ksp, int budget)
{
struct net_device *ndev = ksp->ndev;
struct sk_buff *skb;
int buff_n;
u32 flags;
int pktlen;
int received = 0;
buff_n = ksp->next_rx_desc_read;
while (received < budget
&& ksp->rx_buffers[buff_n].skb
&& (!(ksp->rx_ring[buff_n].status &
cpu_to_le32(RDES_OWN)))) {
rmb();
flags = le32_to_cpu(ksp->rx_ring[buff_n].status);
/* Found an SKB which we own, this means we
* received a packet
*/
if ((flags & (RDES_FS | RDES_LS)) !=
(RDES_FS | RDES_LS)) {
/* This packet is not the first and
* the last segment. Therefore it is
* a "spanning" packet and we can't
* handle it
*/
goto rx_failure;
}
if (flags & (RDES_ES | RDES_RE)) {
/* It's an error packet */
ndev->stats.rx_errors++;
if (flags & RDES_TL)
ndev->stats.rx_length_errors++;
if (flags & RDES_RF)
ndev->stats.rx_length_errors++;
if (flags & RDES_CE)
ndev->stats.rx_crc_errors++;
if (flags & RDES_RE)
ndev->stats.rx_missed_errors++;
goto rx_failure;
}
pktlen = flags & RDES_FLEN;
pktlen -= 4; /* Drop the CRC */
/* Retrieve the sk_buff */
skb = ksp->rx_buffers[buff_n].skb;
/* Clear it from the ring */
ksp->rx_buffers[buff_n].skb = NULL;
ksp->rx_ring[buff_n].data_ptr = 0;
/* Unmap the SKB */
dma_unmap_single(ksp->dev,
ksp->rx_buffers[buff_n].dma_ptr,
ksp->rx_buffers[buff_n].length,
DMA_FROM_DEVICE);
/* Relinquish the SKB to the network layer */
skb_put(skb, pktlen);
skb->protocol = eth_type_trans(skb, ndev);
netif_receive_skb(skb);
/* Record stats */
ndev->stats.rx_packets++;
ndev->stats.rx_bytes += pktlen;
goto rx_finished;
rx_failure:
/* This ring entry is an error, but we can
* re-use the skb
*/
/* Give the ring entry back to the hardware */
ksp->rx_ring[buff_n].status = cpu_to_le32(RDES_OWN);
rx_finished:
received++;
buff_n = (buff_n + 1) & MAX_RX_DESC_MASK;
}
/* And note which RX descriptor we last did */
ksp->next_rx_desc_read = buff_n;
/* And refill the buffers */
ks8695_refill_rxbuffers(ksp);
/* Kick the RX DMA engine, in case it became suspended */
ks8695_writereg(ksp, KS8695_DRSC, 0);
return received;
}
/**
* ks8695_poll - Receive packet by NAPI poll method
* @ksp: Private data for the KS8695 Ethernet
* @budget: The remaining number packets for network subsystem
*
* Invoked by the network core when it requests for new
* packets from the driver
*/
static int ks8695_poll(struct napi_struct *napi, int budget)
{
struct ks8695_priv *ksp = container_of(napi, struct ks8695_priv, napi);
unsigned long work_done;
unsigned long isr = readl(KS8695_IRQ_VA + KS8695_INTEN);
unsigned long mask_bit = 1 << ks8695_get_rx_enable_bit(ksp);
work_done = ks8695_rx(ksp, budget);
if (work_done < budget) {
unsigned long flags;
spin_lock_irqsave(&ksp->rx_lock, flags);
__napi_complete(napi);
/*enable rx interrupt*/
writel(isr | mask_bit, KS8695_IRQ_VA + KS8695_INTEN);
spin_unlock_irqrestore(&ksp->rx_lock, flags);
}
return work_done;
}
/**
* ks8695_link_irq - Link change IRQ handler
* @irq: The IRQ which went off (ignored)
* @dev_id: The net_device for the interrupt
*
* The WAN interface can generate an IRQ when the link changes,
* report this to the net layer and the user.
*/
static irqreturn_t
ks8695_link_irq(int irq, void *dev_id)
{
struct net_device *ndev = (struct net_device *)dev_id;
struct ks8695_priv *ksp = netdev_priv(ndev);
u32 ctrl;
ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
if (ctrl & WMC_WLS) {
netif_carrier_on(ndev);
if (netif_msg_link(ksp))
dev_info(ksp->dev,
"%s: Link is now up (10%sMbps/%s-duplex)\n",
ndev->name,
(ctrl & WMC_WSS) ? "0" : "",
(ctrl & WMC_WDS) ? "Full" : "Half");
} else {
netif_carrier_off(ndev);
if (netif_msg_link(ksp))
dev_info(ksp->dev, "%s: Link is now down.\n",
ndev->name);
}
return IRQ_HANDLED;
}
/* KS8695 Device functions */
/**
* ks8695_reset - Reset a KS8695 ethernet interface
* @ksp: The interface to reset
*
* Perform an engine reset of the interface and re-program it
* with sensible defaults.
*/
static void
ks8695_reset(struct ks8695_priv *ksp)
{
int reset_timeout = watchdog;
/* Issue the reset via the TX DMA control register */
ks8695_writereg(ksp, KS8695_DTXC, DTXC_TRST);
while (reset_timeout--) {
if (!(ks8695_readreg(ksp, KS8695_DTXC) & DTXC_TRST))
break;
msleep(1);
}
if (reset_timeout < 0) {
dev_crit(ksp->dev,
"Timeout waiting for DMA engines to reset\n");
/* And blithely carry on */
}
/* Definitely wait long enough before attempting to program
* the engines
*/
msleep(10);
/* RX: unicast and broadcast */
ks8695_writereg(ksp, KS8695_DRXC, DRXC_RU | DRXC_RB);
/* TX: pad and add CRC */
ks8695_writereg(ksp, KS8695_DTXC, DTXC_TEP | DTXC_TAC);
}
/**
* ks8695_shutdown - Shut down a KS8695 ethernet interface
* @ksp: The interface to shut down
*
* This disables packet RX/TX, cleans up IRQs, drains the rings,
* and basically places the interface into a clean shutdown
* state.
*/
static void
ks8695_shutdown(struct ks8695_priv *ksp)
{
u32 ctrl;
int buff_n;
/* Disable packet transmission */
ctrl = ks8695_readreg(ksp, KS8695_DTXC);
ks8695_writereg(ksp, KS8695_DTXC, ctrl & ~DTXC_TE);
/* Disable packet reception */
ctrl = ks8695_readreg(ksp, KS8695_DRXC);
ks8695_writereg(ksp, KS8695_DRXC, ctrl & ~DRXC_RE);
/* Release the IRQs */
free_irq(ksp->rx_irq, ksp->ndev);
free_irq(ksp->tx_irq, ksp->ndev);
if (ksp->link_irq != -1)
free_irq(ksp->link_irq, ksp->ndev);
/* Throw away any pending TX packets */
for (buff_n = 0; buff_n < MAX_TX_DESC; ++buff_n) {
if (ksp->tx_buffers[buff_n].skb) {
/* Remove this SKB from the TX ring */
ksp->tx_ring[buff_n].owner = 0;
ksp->tx_ring[buff_n].status = 0;
ksp->tx_ring[buff_n].data_ptr = 0;
/* Unmap and bin this SKB */
dma_unmap_single(ksp->dev,
ksp->tx_buffers[buff_n].dma_ptr,
ksp->tx_buffers[buff_n].length,
DMA_TO_DEVICE);
dev_kfree_skb_irq(ksp->tx_buffers[buff_n].skb);
ksp->tx_buffers[buff_n].skb = NULL;
}
}
/* Purge the RX buffers */
for (buff_n = 0; buff_n < MAX_RX_DESC; ++buff_n) {
if (ksp->rx_buffers[buff_n].skb) {
/* Remove the SKB from the RX ring */
ksp->rx_ring[buff_n].status = 0;
ksp->rx_ring[buff_n].data_ptr = 0;
/* Unmap and bin the SKB */
dma_unmap_single(ksp->dev,
ksp->rx_buffers[buff_n].dma_ptr,
ksp->rx_buffers[buff_n].length,
DMA_FROM_DEVICE);
dev_kfree_skb_irq(ksp->rx_buffers[buff_n].skb);
ksp->rx_buffers[buff_n].skb = NULL;
}
}
}
/**
* ks8695_setup_irq - IRQ setup helper function
* @irq: The IRQ number to claim
* @irq_name: The name to give the IRQ claimant
* @handler: The function to call to handle the IRQ
* @ndev: The net_device to pass in as the dev_id argument to the handler
*
* Return 0 on success.
*/
static int
ks8695_setup_irq(int irq, const char *irq_name,
irq_handler_t handler, struct net_device *ndev)
{
int ret;
ret = request_irq(irq, handler, IRQF_SHARED, irq_name, ndev);
if (ret) {
dev_err(&ndev->dev, "failure to request IRQ %d\n", irq);
return ret;
}
return 0;
}
/**
* ks8695_init_net - Initialise a KS8695 ethernet interface
* @ksp: The interface to initialise
*
* This routine fills the RX ring, initialises the DMA engines,
* allocates the IRQs and then starts the packet TX and RX
* engines.
*/
static int
ks8695_init_net(struct ks8695_priv *ksp)
{
int ret;
u32 ctrl;
ks8695_refill_rxbuffers(ksp);
/* Initialise the DMA engines */
ks8695_writereg(ksp, KS8695_RDLB, (u32) ksp->rx_ring_dma);
ks8695_writereg(ksp, KS8695_TDLB, (u32) ksp->tx_ring_dma);
/* Request the IRQs */
ret = ks8695_setup_irq(ksp->rx_irq, ksp->rx_irq_name,
ks8695_rx_irq, ksp->ndev);
if (ret)
return ret;
ret = ks8695_setup_irq(ksp->tx_irq, ksp->tx_irq_name,
ks8695_tx_irq, ksp->ndev);
if (ret)
return ret;
if (ksp->link_irq != -1) {
ret = ks8695_setup_irq(ksp->link_irq, ksp->link_irq_name,
ks8695_link_irq, ksp->ndev);
if (ret)
return ret;
}
/* Set up the ring indices */
ksp->next_rx_desc_read = 0;
ksp->tx_ring_next_slot = 0;
ksp->tx_ring_used = 0;
/* Bring up transmission */
ctrl = ks8695_readreg(ksp, KS8695_DTXC);
/* Enable packet transmission */
ks8695_writereg(ksp, KS8695_DTXC, ctrl | DTXC_TE);
/* Bring up the reception */
ctrl = ks8695_readreg(ksp, KS8695_DRXC);
/* Enable packet reception */
ks8695_writereg(ksp, KS8695_DRXC, ctrl | DRXC_RE);
/* And start the DMA engine */
ks8695_writereg(ksp, KS8695_DRSC, 0);
/* All done */
return 0;
}
/**
* ks8695_release_device - HW resource release for KS8695 e-net
* @ksp: The device to be freed
*
* This unallocates io memory regions, dma-coherent regions etc
* which were allocated in ks8695_probe.
*/
static void
ks8695_release_device(struct ks8695_priv *ksp)
{
/* Unmap the registers */
iounmap(ksp->io_regs);
if (ksp->phyiface_regs)
iounmap(ksp->phyiface_regs);
/* And release the request */
release_resource(ksp->regs_req);
kfree(ksp->regs_req);
if (ksp->phyiface_req) {
release_resource(ksp->phyiface_req);
kfree(ksp->phyiface_req);
}
/* Free the ring buffers */
dma_free_coherent(ksp->dev, RING_DMA_SIZE,
ksp->ring_base, ksp->ring_base_dma);
}
/* Ethtool support */
/**
* ks8695_get_msglevel - Get the messages enabled for emission
* @ndev: The network device to read from
*/
static u32
ks8695_get_msglevel(struct net_device *ndev)
{
struct ks8695_priv *ksp = netdev_priv(ndev);
return ksp->msg_enable;
}
/**
* ks8695_set_msglevel - Set the messages enabled for emission
* @ndev: The network device to configure
* @value: The messages to set for emission
*/
static void
ks8695_set_msglevel(struct net_device *ndev, u32 value)
{
struct ks8695_priv *ksp = netdev_priv(ndev);
ksp->msg_enable = value;
}
/**
* ks8695_get_settings - Get device-specific settings.
* @ndev: The network device to read settings from
* @cmd: The ethtool structure to read into
*/
static int
ks8695_get_settings(struct net_device *ndev, struct ethtool_cmd *cmd)
{
struct ks8695_priv *ksp = netdev_priv(ndev);
u32 ctrl;
/* All ports on the KS8695 support these... */
cmd->supported = (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
SUPPORTED_TP | SUPPORTED_MII);
cmd->transceiver = XCVR_INTERNAL;
/* Port specific extras */
switch (ksp->dtype) {
case KS8695_DTYPE_HPNA:
cmd->phy_address = 0;
/* not supported for HPNA */
cmd->autoneg = AUTONEG_DISABLE;
/* BUG: Erm, dtype hpna implies no phy regs */
/*
ctrl = readl(KS8695_MISC_VA + KS8695_HMC);
cmd->speed = (ctrl & HMC_HSS) ? SPEED_100 : SPEED_10;
cmd->duplex = (ctrl & HMC_HDS) ? DUPLEX_FULL : DUPLEX_HALF;
*/
return -EOPNOTSUPP;
case KS8695_DTYPE_WAN:
cmd->advertising = ADVERTISED_TP | ADVERTISED_MII;
cmd->port = PORT_MII;
cmd->supported |= (SUPPORTED_Autoneg | SUPPORTED_Pause);
cmd->phy_address = 0;
ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
if ((ctrl & WMC_WAND) == 0) {
/* auto-negotiation is enabled */
cmd->advertising |= ADVERTISED_Autoneg;
if (ctrl & WMC_WANA100F)
cmd->advertising |= ADVERTISED_100baseT_Full;
if (ctrl & WMC_WANA100H)
cmd->advertising |= ADVERTISED_100baseT_Half;
if (ctrl & WMC_WANA10F)
cmd->advertising |= ADVERTISED_10baseT_Full;
if (ctrl & WMC_WANA10H)
cmd->advertising |= ADVERTISED_10baseT_Half;
if (ctrl & WMC_WANAP)
cmd->advertising |= ADVERTISED_Pause;
cmd->autoneg = AUTONEG_ENABLE;
cmd->speed = (ctrl & WMC_WSS) ? SPEED_100 : SPEED_10;
cmd->duplex = (ctrl & WMC_WDS) ?
DUPLEX_FULL : DUPLEX_HALF;
} else {
/* auto-negotiation is disabled */
cmd->autoneg = AUTONEG_DISABLE;
cmd->speed = (ctrl & WMC_WANF100) ?
SPEED_100 : SPEED_10;
cmd->duplex = (ctrl & WMC_WANFF) ?
DUPLEX_FULL : DUPLEX_HALF;
}
break;
case KS8695_DTYPE_LAN:
return -EOPNOTSUPP;
}
return 0;
}
/**
* ks8695_set_settings - Set device-specific settings.
* @ndev: The network device to configure
* @cmd: The settings to configure
*/
static int
ks8695_set_settings(struct net_device *ndev, struct ethtool_cmd *cmd)
{
struct ks8695_priv *ksp = netdev_priv(ndev);
u32 ctrl;
if ((cmd->speed != SPEED_10) && (cmd->speed != SPEED_100))
return -EINVAL;
if ((cmd->duplex != DUPLEX_HALF) && (cmd->duplex != DUPLEX_FULL))
return -EINVAL;
if (cmd->port != PORT_MII)
return -EINVAL;
if (cmd->transceiver != XCVR_INTERNAL)
return -EINVAL;
if ((cmd->autoneg != AUTONEG_DISABLE) &&
(cmd->autoneg != AUTONEG_ENABLE))
return -EINVAL;
if (cmd->autoneg == AUTONEG_ENABLE) {
if ((cmd->advertising & (ADVERTISED_10baseT_Half |
ADVERTISED_10baseT_Full |
ADVERTISED_100baseT_Half |
ADVERTISED_100baseT_Full)) == 0)
return -EINVAL;
switch (ksp->dtype) {
case KS8695_DTYPE_HPNA:
/* HPNA does not support auto-negotiation. */
return -EINVAL;
case KS8695_DTYPE_WAN:
ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
ctrl &= ~(WMC_WAND | WMC_WANA100F | WMC_WANA100H |
WMC_WANA10F | WMC_WANA10H);
if (cmd->advertising & ADVERTISED_100baseT_Full)
ctrl |= WMC_WANA100F;
if (cmd->advertising & ADVERTISED_100baseT_Half)
ctrl |= WMC_WANA100H;
if (cmd->advertising & ADVERTISED_10baseT_Full)
ctrl |= WMC_WANA10F;
if (cmd->advertising & ADVERTISED_10baseT_Half)
ctrl |= WMC_WANA10H;
/* force a re-negotiation */
ctrl |= WMC_WANR;
writel(ctrl, ksp->phyiface_regs + KS8695_WMC);
break;
case KS8695_DTYPE_LAN:
return -EOPNOTSUPP;
}
} else {
switch (ksp->dtype) {
case KS8695_DTYPE_HPNA:
/* BUG: dtype_hpna implies no phy registers */
/*
ctrl = __raw_readl(KS8695_MISC_VA + KS8695_HMC);
ctrl &= ~(HMC_HSS | HMC_HDS);
if (cmd->speed == SPEED_100)
ctrl |= HMC_HSS;
if (cmd->duplex == DUPLEX_FULL)
ctrl |= HMC_HDS;
__raw_writel(ctrl, KS8695_MISC_VA + KS8695_HMC);
*/
return -EOPNOTSUPP;
case KS8695_DTYPE_WAN:
ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
/* disable auto-negotiation */
ctrl |= WMC_WAND;
ctrl &= ~(WMC_WANF100 | WMC_WANFF);
if (cmd->speed == SPEED_100)
ctrl |= WMC_WANF100;
if (cmd->duplex == DUPLEX_FULL)
ctrl |= WMC_WANFF;
writel(ctrl, ksp->phyiface_regs + KS8695_WMC);
break;
case KS8695_DTYPE_LAN:
return -EOPNOTSUPP;
}
}
return 0;
}
/**
* ks8695_nwayreset - Restart the autonegotiation on the port.
* @ndev: The network device to restart autoneotiation on
*/
static int
ks8695_nwayreset(struct net_device *ndev)
{
struct ks8695_priv *ksp = netdev_priv(ndev);
u32 ctrl;
switch (ksp->dtype) {
case KS8695_DTYPE_HPNA:
/* No phy means no autonegotiation on hpna */
return -EINVAL;
case KS8695_DTYPE_WAN:
ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
if ((ctrl & WMC_WAND) == 0)
writel(ctrl | WMC_WANR,
ksp->phyiface_regs + KS8695_WMC);
else
/* auto-negotiation not enabled */
return -EINVAL;
break;
case KS8695_DTYPE_LAN:
return -EOPNOTSUPP;
}
return 0;
}
/**
* ks8695_get_link - Retrieve link status of network interface
* @ndev: The network interface to retrive the link status of.
*/
static u32
ks8695_get_link(struct net_device *ndev)
{
struct ks8695_priv *ksp = netdev_priv(ndev);
u32 ctrl;
switch (ksp->dtype) {
case KS8695_DTYPE_HPNA:
/* HPNA always has link */
return 1;
case KS8695_DTYPE_WAN:
/* WAN we can read the PHY for */
ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
return ctrl & WMC_WLS;
case KS8695_DTYPE_LAN:
return -EOPNOTSUPP;
}
return 0;
}
/**
* ks8695_get_pause - Retrieve network pause/flow-control advertising
* @ndev: The device to retrieve settings from
* @param: The structure to fill out with the information
*/
static void
ks8695_get_pause(struct net_device *ndev, struct ethtool_pauseparam *param)
{
struct ks8695_priv *ksp = netdev_priv(ndev);
u32 ctrl;
switch (ksp->dtype) {
case KS8695_DTYPE_HPNA:
/* No phy link on hpna to configure */
return;
case KS8695_DTYPE_WAN:
ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
/* advertise Pause */
param->autoneg = (ctrl & WMC_WANAP);
/* current Rx Flow-control */
ctrl = ks8695_readreg(ksp, KS8695_DRXC);
param->rx_pause = (ctrl & DRXC_RFCE);
/* current Tx Flow-control */
ctrl = ks8695_readreg(ksp, KS8695_DTXC);
param->tx_pause = (ctrl & DTXC_TFCE);
break;
case KS8695_DTYPE_LAN:
/* The LAN's "phy" is a direct-attached switch */
return;
}
}
/**
* ks8695_set_pause - Configure pause/flow-control
* @ndev: The device to configure
* @param: The pause parameters to set
*
* TODO: Implement this
*/
static int
ks8695_set_pause(struct net_device *ndev, struct ethtool_pauseparam *param)
{
return -EOPNOTSUPP;
}
/**
* ks8695_get_drvinfo - Retrieve driver information
* @ndev: The network device to retrieve info about
* @info: The info structure to fill out.
*/
static void
ks8695_get_drvinfo(struct net_device *ndev, struct ethtool_drvinfo *info)
{
strlcpy(info->driver, MODULENAME, sizeof(info->driver));
strlcpy(info->version, MODULEVERSION, sizeof(info->version));
strlcpy(info->bus_info, dev_name(ndev->dev.parent),
sizeof(info->bus_info));
}
static const struct ethtool_ops ks8695_ethtool_ops = {
.get_msglevel = ks8695_get_msglevel,
.set_msglevel = ks8695_set_msglevel,
.get_settings = ks8695_get_settings,
.set_settings = ks8695_set_settings,
.nway_reset = ks8695_nwayreset,
.get_link = ks8695_get_link,
.get_pauseparam = ks8695_get_pause,
.set_pauseparam = ks8695_set_pause,
.get_drvinfo = ks8695_get_drvinfo,
};
/* Network device interface functions */
/**
* ks8695_set_mac - Update MAC in net dev and HW
* @ndev: The network device to update
* @addr: The new MAC address to set
*/
static int
ks8695_set_mac(struct net_device *ndev, void *addr)
{
struct ks8695_priv *ksp = netdev_priv(ndev);
struct sockaddr *address = addr;
if (!is_valid_ether_addr(address->sa_data))
return -EADDRNOTAVAIL;
memcpy(ndev->dev_addr, address->sa_data, ndev->addr_len);
ks8695_update_mac(ksp);
dev_dbg(ksp->dev, "%s: Updated MAC address to %pM\n",
ndev->name, ndev->dev_addr);
return 0;
}
/**
* ks8695_set_multicast - Set up the multicast behaviour of the interface
* @ndev: The net_device to configure
*
* This routine, called by the net layer, configures promiscuity
* and multicast reception behaviour for the interface.
*/
static void
ks8695_set_multicast(struct net_device *ndev)
{
struct ks8695_priv *ksp = netdev_priv(ndev);
u32 ctrl;
ctrl = ks8695_readreg(ksp, KS8695_DRXC);
if (ndev->flags & IFF_PROMISC) {
/* enable promiscuous mode */
ctrl |= DRXC_RA;
} else if (ndev->flags & ~IFF_PROMISC) {
/* disable promiscuous mode */
ctrl &= ~DRXC_RA;
}
if (ndev->flags & IFF_ALLMULTI) {
/* enable all multicast mode */
ctrl |= DRXC_RM;
} else if (netdev_mc_count(ndev) > KS8695_NR_ADDRESSES) {
/* more specific multicast addresses than can be
* handled in hardware
*/
ctrl |= DRXC_RM;
} else {
/* enable specific multicasts */
ctrl &= ~DRXC_RM;
ks8695_init_partial_multicast(ksp, ndev);
}
ks8695_writereg(ksp, KS8695_DRXC, ctrl);
}
/**
* ks8695_timeout - Handle a network tx/rx timeout.
* @ndev: The net_device which timed out.
*
* A network transaction timed out, reset the device.
*/
static void
ks8695_timeout(struct net_device *ndev)
{
struct ks8695_priv *ksp = netdev_priv(ndev);
netif_stop_queue(ndev);
ks8695_shutdown(ksp);
ks8695_reset(ksp);
ks8695_update_mac(ksp);
/* We ignore the return from this since it managed to init
* before it probably will be okay to init again.
*/
ks8695_init_net(ksp);
/* Reconfigure promiscuity etc */
ks8695_set_multicast(ndev);
/* And start the TX queue once more */
netif_start_queue(ndev);
}
/**
* ks8695_start_xmit - Start a packet transmission
* @skb: The packet to transmit
* @ndev: The network device to send the packet on
*
* This routine, called by the net layer, takes ownership of the
* sk_buff and adds it to the TX ring. It then kicks the TX DMA
* engine to ensure transmission begins.
*/
static int
ks8695_start_xmit(struct sk_buff *skb, struct net_device *ndev)
{
struct ks8695_priv *ksp = netdev_priv(ndev);
int buff_n;
dma_addr_t dmap;
spin_lock_irq(&ksp->txq_lock);
if (ksp->tx_ring_used == MAX_TX_DESC) {
/* Somehow we got entered when we have no room */
spin_unlock_irq(&ksp->txq_lock);
return NETDEV_TX_BUSY;
}
buff_n = ksp->tx_ring_next_slot;
BUG_ON(ksp->tx_buffers[buff_n].skb);
dmap = dma_map_single(ksp->dev, skb->data, skb->len, DMA_TO_DEVICE);
if (unlikely(dma_mapping_error(ksp->dev, dmap))) {
/* Failed to DMA map this SKB, give it back for now */
spin_unlock_irq(&ksp->txq_lock);
dev_dbg(ksp->dev, "%s: Could not map DMA memory for "\
"transmission, trying later\n", ndev->name);
return NETDEV_TX_BUSY;
}
ksp->tx_buffers[buff_n].dma_ptr = dmap;
/* Mapped okay, store the buffer pointer and length for later */
ksp->tx_buffers[buff_n].skb = skb;
ksp->tx_buffers[buff_n].length = skb->len;
/* Fill out the TX descriptor */
ksp->tx_ring[buff_n].data_ptr =
cpu_to_le32(ksp->tx_buffers[buff_n].dma_ptr);
ksp->tx_ring[buff_n].status =
cpu_to_le32(TDES_IC | TDES_FS | TDES_LS |
(skb->len & TDES_TBS));
wmb();
/* Hand it over to the hardware */
ksp->tx_ring[buff_n].owner = cpu_to_le32(TDES_OWN);
if (++ksp->tx_ring_used == MAX_TX_DESC)
netif_stop_queue(ndev);
/* Kick the TX DMA in case it decided to go IDLE */
ks8695_writereg(ksp, KS8695_DTSC, 0);
/* And update the next ring slot */
ksp->tx_ring_next_slot = (buff_n + 1) & MAX_TX_DESC_MASK;
spin_unlock_irq(&ksp->txq_lock);
return NETDEV_TX_OK;
}
/**
* ks8695_stop - Stop (shutdown) a KS8695 ethernet interface
* @ndev: The net_device to stop
*
* This disables the TX queue and cleans up a KS8695 ethernet
* device.
*/
static int
ks8695_stop(struct net_device *ndev)
{
struct ks8695_priv *ksp = netdev_priv(ndev);
netif_stop_queue(ndev);
napi_disable(&ksp->napi);
ks8695_shutdown(ksp);
return 0;
}
/**
* ks8695_open - Open (bring up) a KS8695 ethernet interface
* @ndev: The net_device to open
*
* This resets, configures the MAC, initialises the RX ring and
* DMA engines and starts the TX queue for a KS8695 ethernet
* device.
*/
static int
ks8695_open(struct net_device *ndev)
{
struct ks8695_priv *ksp = netdev_priv(ndev);
int ret;
if (!is_valid_ether_addr(ndev->dev_addr))
return -EADDRNOTAVAIL;
ks8695_reset(ksp);
ks8695_update_mac(ksp);
ret = ks8695_init_net(ksp);
if (ret) {
ks8695_shutdown(ksp);
return ret;
}
napi_enable(&ksp->napi);
netif_start_queue(ndev);
return 0;
}
/* Platform device driver */
/**
* ks8695_init_switch - Init LAN switch to known good defaults.
* @ksp: The device to initialise
*
* This initialises the LAN switch in the KS8695 to a known-good
* set of defaults.
*/
static void __devinit
ks8695_init_switch(struct ks8695_priv *ksp)
{
u32 ctrl;
/* Default value for SEC0 according to datasheet */
ctrl = 0x40819e00;
/* LED0 = Speed LED1 = Link/Activity */
ctrl &= ~(SEC0_LLED1S | SEC0_LLED0S);
ctrl |= (LLED0S_LINK | LLED1S_LINK_ACTIVITY);
/* Enable Switch */
ctrl |= SEC0_ENABLE;
writel(ctrl, ksp->phyiface_regs + KS8695_SEC0);
/* Defaults for SEC1 */
writel(0x9400100, ksp->phyiface_regs + KS8695_SEC1);
}
/**
* ks8695_init_wan_phy - Initialise the WAN PHY to sensible defaults
* @ksp: The device to initialise
*
* This initialises a KS8695's WAN phy to sensible values for
* autonegotiation etc.
*/
static void __devinit
ks8695_init_wan_phy(struct ks8695_priv *ksp)
{
u32 ctrl;
/* Support auto-negotiation */
ctrl = (WMC_WANAP | WMC_WANA100F | WMC_WANA100H |
WMC_WANA10F | WMC_WANA10H);
/* LED0 = Activity , LED1 = Link */
ctrl |= (WLED0S_ACTIVITY | WLED1S_LINK);
/* Restart Auto-negotiation */
ctrl |= WMC_WANR;
writel(ctrl, ksp->phyiface_regs + KS8695_WMC);
writel(0, ksp->phyiface_regs + KS8695_WPPM);
writel(0, ksp->phyiface_regs + KS8695_PPS);
}
static const struct net_device_ops ks8695_netdev_ops = {
.ndo_open = ks8695_open,
.ndo_stop = ks8695_stop,
.ndo_start_xmit = ks8695_start_xmit,
.ndo_tx_timeout = ks8695_timeout,
.ndo_set_mac_address = ks8695_set_mac,
.ndo_validate_addr = eth_validate_addr,
.ndo_set_multicast_list = ks8695_set_multicast,
};
/**
* ks8695_probe - Probe and initialise a KS8695 ethernet interface
* @pdev: The platform device to probe
*
* Initialise a KS8695 ethernet device from platform data.
*
* This driver requires at least one IORESOURCE_MEM for the
* registers and two IORESOURCE_IRQ for the RX and TX IRQs
* respectively. It can optionally take an additional
* IORESOURCE_MEM for the switch or phy in the case of the lan or
* wan ports, and an IORESOURCE_IRQ for the link IRQ for the wan
* port.
*/
static int __devinit
ks8695_probe(struct platform_device *pdev)
{
struct ks8695_priv *ksp;
struct net_device *ndev;
struct resource *regs_res, *phyiface_res;
struct resource *rxirq_res, *txirq_res, *linkirq_res;
int ret = 0;
int buff_n;
u32 machigh, maclow;
/* Initialise a net_device */
ndev = alloc_etherdev(sizeof(struct ks8695_priv));
if (!ndev) {
dev_err(&pdev->dev, "could not allocate device.\n");
return -ENOMEM;
}
SET_NETDEV_DEV(ndev, &pdev->dev);
dev_dbg(&pdev->dev, "ks8695_probe() called\n");
/* Configure our private structure a little */
ksp = netdev_priv(ndev);
ksp->dev = &pdev->dev;
ksp->ndev = ndev;
ksp->msg_enable = NETIF_MSG_LINK;
/* Retrieve resources */
regs_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
phyiface_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
rxirq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
txirq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
linkirq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 2);
if (!(regs_res && rxirq_res && txirq_res)) {
dev_err(ksp->dev, "insufficient resources\n");
ret = -ENOENT;
goto failure;
}
ksp->regs_req = request_mem_region(regs_res->start,
resource_size(regs_res),
pdev->name);
if (!ksp->regs_req) {
dev_err(ksp->dev, "cannot claim register space\n");
ret = -EIO;
goto failure;
}
ksp->io_regs = ioremap(regs_res->start, resource_size(regs_res));
if (!ksp->io_regs) {
dev_err(ksp->dev, "failed to ioremap registers\n");
ret = -EINVAL;
goto failure;
}
if (phyiface_res) {
ksp->phyiface_req =
request_mem_region(phyiface_res->start,
resource_size(phyiface_res),
phyiface_res->name);
if (!ksp->phyiface_req) {
dev_err(ksp->dev,
"cannot claim switch register space\n");
ret = -EIO;
goto failure;
}
ksp->phyiface_regs = ioremap(phyiface_res->start,
resource_size(phyiface_res));
if (!ksp->phyiface_regs) {
dev_err(ksp->dev,
"failed to ioremap switch registers\n");
ret = -EINVAL;
goto failure;
}
}
ksp->rx_irq = rxirq_res->start;
ksp->rx_irq_name = rxirq_res->name ? rxirq_res->name : "Ethernet RX";
ksp->tx_irq = txirq_res->start;
ksp->tx_irq_name = txirq_res->name ? txirq_res->name : "Ethernet TX";
ksp->link_irq = (linkirq_res ? linkirq_res->start : -1);
ksp->link_irq_name = (linkirq_res && linkirq_res->name) ?
linkirq_res->name : "Ethernet Link";
/* driver system setup */
ndev->netdev_ops = &ks8695_netdev_ops;
SET_ETHTOOL_OPS(ndev, &ks8695_ethtool_ops);
ndev->watchdog_timeo = msecs_to_jiffies(watchdog);
netif_napi_add(ndev, &ksp->napi, ks8695_poll, NAPI_WEIGHT);
/* Retrieve the default MAC addr from the chip. */
/* The bootloader should have left it in there for us. */
machigh = ks8695_readreg(ksp, KS8695_MAH);
maclow = ks8695_readreg(ksp, KS8695_MAL);
ndev->dev_addr[0] = (machigh >> 8) & 0xFF;
ndev->dev_addr[1] = machigh & 0xFF;
ndev->dev_addr[2] = (maclow >> 24) & 0xFF;
ndev->dev_addr[3] = (maclow >> 16) & 0xFF;
ndev->dev_addr[4] = (maclow >> 8) & 0xFF;
ndev->dev_addr[5] = maclow & 0xFF;
if (!is_valid_ether_addr(ndev->dev_addr))
dev_warn(ksp->dev, "%s: Invalid ethernet MAC address. Please "
"set using ifconfig\n", ndev->name);
/* In order to be efficient memory-wise, we allocate both
* rings in one go.
*/
ksp->ring_base = dma_alloc_coherent(&pdev->dev, RING_DMA_SIZE,
&ksp->ring_base_dma, GFP_KERNEL);
if (!ksp->ring_base) {
ret = -ENOMEM;
goto failure;
}
/* Specify the TX DMA ring buffer */
ksp->tx_ring = ksp->ring_base;
ksp->tx_ring_dma = ksp->ring_base_dma;
/* And initialise the queue's lock */
spin_lock_init(&ksp->txq_lock);
spin_lock_init(&ksp->rx_lock);
/* Specify the RX DMA ring buffer */
ksp->rx_ring = ksp->ring_base + TX_RING_DMA_SIZE;
ksp->rx_ring_dma = ksp->ring_base_dma + TX_RING_DMA_SIZE;
/* Zero the descriptor rings */
memset(ksp->tx_ring, 0, TX_RING_DMA_SIZE);
memset(ksp->rx_ring, 0, RX_RING_DMA_SIZE);
/* Build the rings */
for (buff_n = 0; buff_n < MAX_TX_DESC; ++buff_n) {
ksp->tx_ring[buff_n].next_desc =
cpu_to_le32(ksp->tx_ring_dma +
(sizeof(struct tx_ring_desc) *
((buff_n + 1) & MAX_TX_DESC_MASK)));
}
for (buff_n = 0; buff_n < MAX_RX_DESC; ++buff_n) {
ksp->rx_ring[buff_n].next_desc =
cpu_to_le32(ksp->rx_ring_dma +
(sizeof(struct rx_ring_desc) *
((buff_n + 1) & MAX_RX_DESC_MASK)));
}
/* Initialise the port (physically) */
if (ksp->phyiface_regs && ksp->link_irq == -1) {
ks8695_init_switch(ksp);
ksp->dtype = KS8695_DTYPE_LAN;
} else if (ksp->phyiface_regs && ksp->link_irq != -1) {
ks8695_init_wan_phy(ksp);
ksp->dtype = KS8695_DTYPE_WAN;
} else {
/* No initialisation since HPNA does not have a PHY */
ksp->dtype = KS8695_DTYPE_HPNA;
}
/* And bring up the net_device with the net core */
platform_set_drvdata(pdev, ndev);
ret = register_netdev(ndev);
if (ret == 0) {
dev_info(ksp->dev, "ks8695 ethernet (%s) MAC: %pM\n",
ks8695_port_type(ksp), ndev->dev_addr);
} else {
/* Report the failure to register the net_device */
dev_err(ksp->dev, "ks8695net: failed to register netdev.\n");
goto failure;
}
/* All is well */
return 0;
/* Error exit path */
failure:
ks8695_release_device(ksp);
free_netdev(ndev);
return ret;
}
/**
* ks8695_drv_suspend - Suspend a KS8695 ethernet platform device.
* @pdev: The device to suspend
* @state: The suspend state
*
* This routine detaches and shuts down a KS8695 ethernet device.
*/
static int
ks8695_drv_suspend(struct platform_device *pdev, pm_message_t state)
{
struct net_device *ndev = platform_get_drvdata(pdev);
struct ks8695_priv *ksp = netdev_priv(ndev);
ksp->in_suspend = 1;
if (netif_running(ndev)) {
netif_device_detach(ndev);
ks8695_shutdown(ksp);
}
return 0;
}
/**
* ks8695_drv_resume - Resume a KS8695 ethernet platform device.
* @pdev: The device to resume
*
* This routine re-initialises and re-attaches a KS8695 ethernet
* device.
*/
static int
ks8695_drv_resume(struct platform_device *pdev)
{
struct net_device *ndev = platform_get_drvdata(pdev);
struct ks8695_priv *ksp = netdev_priv(ndev);
if (netif_running(ndev)) {
ks8695_reset(ksp);
ks8695_init_net(ksp);
ks8695_set_multicast(ndev);
netif_device_attach(ndev);
}
ksp->in_suspend = 0;
return 0;
}
/**
* ks8695_drv_remove - Remove a KS8695 net device on driver unload.
* @pdev: The platform device to remove
*
* This unregisters and releases a KS8695 ethernet device.
*/
static int __devexit
ks8695_drv_remove(struct platform_device *pdev)
{
struct net_device *ndev = platform_get_drvdata(pdev);
struct ks8695_priv *ksp = netdev_priv(ndev);
platform_set_drvdata(pdev, NULL);
netif_napi_del(&ksp->napi);
unregister_netdev(ndev);
ks8695_release_device(ksp);
free_netdev(ndev);
dev_dbg(&pdev->dev, "released and freed device\n");
return 0;
}
static struct platform_driver ks8695_driver = {
.driver = {
.name = MODULENAME,
.owner = THIS_MODULE,
},
.probe = ks8695_probe,
.remove = __devexit_p(ks8695_drv_remove),
.suspend = ks8695_drv_suspend,
.resume = ks8695_drv_resume,
};
/* Module interface */
static int __init
ks8695_init(void)
{
printk(KERN_INFO "%s Ethernet driver, V%s\n",
MODULENAME, MODULEVERSION);
return platform_driver_register(&ks8695_driver);
}
static void __exit
ks8695_cleanup(void)
{
platform_driver_unregister(&ks8695_driver);
}
module_init(ks8695_init);
module_exit(ks8695_cleanup);
MODULE_AUTHOR("Simtec Electronics")
MODULE_DESCRIPTION("Micrel KS8695 (Centaur) Ethernet driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:" MODULENAME);
module_param(watchdog, int, 0400);
MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds");
Reference in New Issue View Git Blame Copy Permalink