2012-06-05 03:42:12 +00:00
|
|
|
/* drivers/net/ethernet/freescale/gianfar.c
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Gianfar Ethernet Driver
|
2005-11-11 18:38:59 +00:00
|
|
|
* This driver is designed for the non-CPM ethernet controllers
|
|
|
|
* on the 85xx and 83xx family of integrated processors
|
2005-04-16 22:20:36 +00:00
|
|
|
* Based on 8260_io/fcc_enet.c
|
|
|
|
*
|
|
|
|
* Author: Andy Fleming
|
2005-11-14 00:06:30 +00:00
|
|
|
* Maintainer: Kumar Gala
|
2009-11-02 07:03:00 +00:00
|
|
|
* Modifier: Sandeep Gopalpet <sandeep.kumar@freescale.com>
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2011-06-07 21:46:51 +00:00
|
|
|
* Copyright 2002-2009, 2011 Freescale Semiconductor, Inc.
|
2009-11-02 07:03:00 +00:00
|
|
|
* Copyright 2007 MontaVista Software, Inc.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* Gianfar: AKA Lambda Draconis, "Dragon"
|
|
|
|
* RA 11 31 24.2
|
|
|
|
* Dec +69 19 52
|
|
|
|
* V 3.84
|
|
|
|
* B-V +1.62
|
|
|
|
*
|
|
|
|
* Theory of operation
|
2005-06-20 15:54:21 +00:00
|
|
|
*
|
2008-12-16 23:29:15 +00:00
|
|
|
* The driver is initialized through of_device. Configuration information
|
|
|
|
* is therefore conveyed through an OF-style device tree.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* The Gianfar Ethernet Controller uses a ring of buffer
|
|
|
|
* descriptors. The beginning is indicated by a register
|
2005-06-20 15:54:21 +00:00
|
|
|
* pointing to the physical address of the start of the ring.
|
|
|
|
* The end is determined by a "wrap" bit being set in the
|
2005-04-16 22:20:36 +00:00
|
|
|
* last descriptor of the ring.
|
|
|
|
*
|
|
|
|
* When a packet is received, the RXF bit in the
|
2005-06-20 15:54:21 +00:00
|
|
|
* IEVENT register is set, triggering an interrupt when the
|
2005-04-16 22:20:36 +00:00
|
|
|
* corresponding bit in the IMASK register is also set (if
|
|
|
|
* interrupt coalescing is active, then the interrupt may not
|
|
|
|
* happen immediately, but will wait until either a set number
|
2005-09-24 02:54:21 +00:00
|
|
|
* of frames or amount of time have passed). In NAPI, the
|
2005-04-16 22:20:36 +00:00
|
|
|
* interrupt handler will signal there is work to be done, and
|
2008-07-10 22:33:52 +00:00
|
|
|
* exit. This method will start at the last known empty
|
2005-06-20 15:54:21 +00:00
|
|
|
* descriptor, and process every subsequent descriptor until there
|
2005-04-16 22:20:36 +00:00
|
|
|
* are none left with data (NAPI will stop after a set number of
|
|
|
|
* packets to give time to other tasks, but will eventually
|
|
|
|
* process all the packets). The data arrives inside a
|
|
|
|
* pre-allocated skb, and so after the skb is passed up to the
|
|
|
|
* stack, a new skb must be allocated, and the address field in
|
|
|
|
* the buffer descriptor must be updated to indicate this new
|
|
|
|
* skb.
|
|
|
|
*
|
|
|
|
* When the kernel requests that a packet be transmitted, the
|
|
|
|
* driver starts where it left off last time, and points the
|
|
|
|
* descriptor at the buffer which was passed in. The driver
|
|
|
|
* then informs the DMA engine that there are packets ready to
|
|
|
|
* be transmitted. Once the controller is finished transmitting
|
|
|
|
* the packet, an interrupt may be triggered (under the same
|
|
|
|
* conditions as for reception, but depending on the TXF bit).
|
|
|
|
* The driver then cleans up the buffer.
|
|
|
|
*/
|
|
|
|
|
2011-06-14 08:57:47 +00:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#define DEBUG
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/errno.h>
|
2005-09-24 02:54:21 +00:00
|
|
|
#include <linux/unistd.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/skbuff.h>
|
2005-06-20 15:54:21 +00:00
|
|
|
#include <linux/if_vlan.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/mm.h>
|
2009-04-25 12:53:12 +00:00
|
|
|
#include <linux/of_mdio.h>
|
2008-12-16 23:29:15 +00:00
|
|
|
#include <linux/of_platform.h>
|
2005-06-20 15:54:21 +00:00
|
|
|
#include <linux/ip.h>
|
|
|
|
#include <linux/tcp.h>
|
|
|
|
#include <linux/udp.h>
|
2006-01-11 19:26:25 +00:00
|
|
|
#include <linux/in.h>
|
2010-04-08 23:10:03 +00:00
|
|
|
#include <linux/net_tstamp.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <asm/io.h>
|
2010-06-30 06:39:12 +00:00
|
|
|
#include <asm/reg.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/crc32.h>
|
2005-09-24 02:54:21 +00:00
|
|
|
#include <linux/mii.h>
|
|
|
|
#include <linux/phy.h>
|
2008-12-16 23:29:15 +00:00
|
|
|
#include <linux/phy_fixed.h>
|
|
|
|
#include <linux/of.h>
|
2010-10-26 22:07:13 +00:00
|
|
|
#include <linux/of_net.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include "gianfar.h"
|
|
|
|
|
|
|
|
#define TX_TIMEOUT (1*HZ)
|
|
|
|
|
2005-11-11 18:38:59 +00:00
|
|
|
const char gfar_driver_version[] = "1.3";
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static int gfar_enet_open(struct net_device *dev);
|
|
|
|
static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev);
|
2008-08-19 19:12:45 +00:00
|
|
|
static void gfar_reset_task(struct work_struct *work);
|
2005-04-16 22:20:36 +00:00
|
|
|
static void gfar_timeout(struct net_device *dev);
|
|
|
|
static int gfar_close(struct net_device *dev);
|
2008-04-22 22:18:29 +00:00
|
|
|
struct sk_buff *gfar_new_skb(struct net_device *dev);
|
2009-11-02 07:03:00 +00:00
|
|
|
static void gfar_new_rxbdp(struct gfar_priv_rx_q *rx_queue, struct rxbd8 *bdp,
|
2012-06-05 03:42:13 +00:00
|
|
|
struct sk_buff *skb);
|
2005-04-16 22:20:36 +00:00
|
|
|
static int gfar_set_mac_address(struct net_device *dev);
|
|
|
|
static int gfar_change_mtu(struct net_device *dev, int new_mtu);
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static irqreturn_t gfar_error(int irq, void *dev_id);
|
|
|
|
static irqreturn_t gfar_transmit(int irq, void *dev_id);
|
|
|
|
static irqreturn_t gfar_interrupt(int irq, void *dev_id);
|
2005-04-16 22:20:36 +00:00
|
|
|
static void adjust_link(struct net_device *dev);
|
|
|
|
static void init_registers(struct net_device *dev);
|
|
|
|
static int init_phy(struct net_device *dev);
|
2011-02-23 04:05:51 +00:00
|
|
|
static int gfar_probe(struct platform_device *ofdev);
|
2010-08-06 15:25:50 +00:00
|
|
|
static int gfar_remove(struct platform_device *ofdev);
|
2005-09-24 02:54:21 +00:00
|
|
|
static void free_skb_resources(struct gfar_private *priv);
|
2005-04-16 22:20:36 +00:00
|
|
|
static void gfar_set_multi(struct net_device *dev);
|
|
|
|
static void gfar_set_hash_for_addr(struct net_device *dev, u8 *addr);
|
2007-05-11 23:25:11 +00:00
|
|
|
static void gfar_configure_serdes(struct net_device *dev);
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
static int gfar_poll(struct napi_struct *napi, int budget);
|
2006-11-07 10:27:02 +00:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
static void gfar_netpoll(struct net_device *dev);
|
|
|
|
#endif
|
2009-11-02 07:03:00 +00:00
|
|
|
int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit);
|
|
|
|
static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue);
|
2008-12-16 23:31:15 +00:00
|
|
|
static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
|
2012-04-19 22:54:35 +00:00
|
|
|
int amount_pull, struct napi_struct *napi);
|
2005-11-11 18:38:59 +00:00
|
|
|
void gfar_halt(struct net_device *dev);
|
2008-07-11 23:04:45 +00:00
|
|
|
static void gfar_halt_nodisable(struct net_device *dev);
|
2005-11-11 18:38:59 +00:00
|
|
|
void gfar_start(struct net_device *dev);
|
|
|
|
static void gfar_clear_exact_match(struct net_device *dev);
|
2010-12-21 10:16:08 +00:00
|
|
|
static void gfar_set_mac_for_addr(struct net_device *dev, int num,
|
|
|
|
const u8 *addr);
|
2009-03-10 12:58:28 +00:00
|
|
|
static int gfar_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
MODULE_AUTHOR("Freescale Semiconductor, Inc");
|
|
|
|
MODULE_DESCRIPTION("Gianfar Ethernet Driver");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
static void gfar_init_rxbdp(struct gfar_priv_rx_q *rx_queue, struct rxbd8 *bdp,
|
2009-10-12 06:00:37 +00:00
|
|
|
dma_addr_t buf)
|
|
|
|
{
|
|
|
|
u32 lstatus;
|
|
|
|
|
|
|
|
bdp->bufPtr = buf;
|
|
|
|
|
|
|
|
lstatus = BD_LFLAG(RXBD_EMPTY | RXBD_INTERRUPT);
|
2009-11-02 07:03:00 +00:00
|
|
|
if (bdp == rx_queue->rx_bd_base + rx_queue->rx_ring_size - 1)
|
2009-10-12 06:00:37 +00:00
|
|
|
lstatus |= BD_LFLAG(RXBD_WRAP);
|
|
|
|
|
|
|
|
eieio();
|
|
|
|
|
|
|
|
bdp->lstatus = lstatus;
|
|
|
|
}
|
|
|
|
|
2009-10-12 06:00:39 +00:00
|
|
|
static int gfar_init_bds(struct net_device *ndev)
|
2009-10-12 06:00:34 +00:00
|
|
|
{
|
2009-10-12 06:00:39 +00:00
|
|
|
struct gfar_private *priv = netdev_priv(ndev);
|
2009-11-02 07:03:00 +00:00
|
|
|
struct gfar_priv_tx_q *tx_queue = NULL;
|
|
|
|
struct gfar_priv_rx_q *rx_queue = NULL;
|
2009-10-12 06:00:34 +00:00
|
|
|
struct txbd8 *txbdp;
|
|
|
|
struct rxbd8 *rxbdp;
|
2009-11-02 07:03:15 +00:00
|
|
|
int i, j;
|
2009-11-02 07:03:00 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
for (i = 0; i < priv->num_tx_queues; i++) {
|
|
|
|
tx_queue = priv->tx_queue[i];
|
|
|
|
/* Initialize some variables in our dev structure */
|
|
|
|
tx_queue->num_txbdfree = tx_queue->tx_ring_size;
|
|
|
|
tx_queue->dirty_tx = tx_queue->tx_bd_base;
|
|
|
|
tx_queue->cur_tx = tx_queue->tx_bd_base;
|
|
|
|
tx_queue->skb_curtx = 0;
|
|
|
|
tx_queue->skb_dirtytx = 0;
|
|
|
|
|
|
|
|
/* Initialize Transmit Descriptor Ring */
|
|
|
|
txbdp = tx_queue->tx_bd_base;
|
|
|
|
for (j = 0; j < tx_queue->tx_ring_size; j++) {
|
|
|
|
txbdp->lstatus = 0;
|
|
|
|
txbdp->bufPtr = 0;
|
|
|
|
txbdp++;
|
|
|
|
}
|
2009-10-12 06:00:39 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
/* Set the last descriptor in the ring to indicate wrap */
|
|
|
|
txbdp--;
|
|
|
|
txbdp->status |= TXBD_WRAP;
|
2009-10-12 06:00:39 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
for (i = 0; i < priv->num_rx_queues; i++) {
|
|
|
|
rx_queue = priv->rx_queue[i];
|
|
|
|
rx_queue->cur_rx = rx_queue->rx_bd_base;
|
|
|
|
rx_queue->skb_currx = 0;
|
|
|
|
rxbdp = rx_queue->rx_bd_base;
|
2009-10-12 06:00:39 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
for (j = 0; j < rx_queue->rx_ring_size; j++) {
|
|
|
|
struct sk_buff *skb = rx_queue->rx_skbuff[j];
|
2009-10-12 06:00:39 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
if (skb) {
|
|
|
|
gfar_init_rxbdp(rx_queue, rxbdp,
|
|
|
|
rxbdp->bufPtr);
|
|
|
|
} else {
|
|
|
|
skb = gfar_new_skb(ndev);
|
|
|
|
if (!skb) {
|
2011-06-14 08:57:47 +00:00
|
|
|
netdev_err(ndev, "Can't allocate RX buffers\n");
|
2012-11-08 22:11:41 +00:00
|
|
|
return -ENOMEM;
|
2009-11-02 07:03:15 +00:00
|
|
|
}
|
|
|
|
rx_queue->rx_skbuff[j] = skb;
|
|
|
|
|
|
|
|
gfar_new_rxbdp(rx_queue, rxbdp, skb);
|
2009-10-12 06:00:39 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
rxbdp++;
|
2009-10-12 06:00:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gfar_alloc_skb_resources(struct net_device *ndev)
|
|
|
|
{
|
2009-10-12 06:00:34 +00:00
|
|
|
void *vaddr;
|
2009-11-02 07:03:15 +00:00
|
|
|
dma_addr_t addr;
|
|
|
|
int i, j, k;
|
2009-10-12 06:00:34 +00:00
|
|
|
struct gfar_private *priv = netdev_priv(ndev);
|
|
|
|
struct device *dev = &priv->ofdev->dev;
|
2009-11-02 07:03:00 +00:00
|
|
|
struct gfar_priv_tx_q *tx_queue = NULL;
|
|
|
|
struct gfar_priv_rx_q *rx_queue = NULL;
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
priv->total_tx_ring_size = 0;
|
|
|
|
for (i = 0; i < priv->num_tx_queues; i++)
|
|
|
|
priv->total_tx_ring_size += priv->tx_queue[i]->tx_ring_size;
|
|
|
|
|
|
|
|
priv->total_rx_ring_size = 0;
|
|
|
|
for (i = 0; i < priv->num_rx_queues; i++)
|
|
|
|
priv->total_rx_ring_size += priv->rx_queue[i]->rx_ring_size;
|
2009-10-12 06:00:34 +00:00
|
|
|
|
|
|
|
/* Allocate memory for the buffer descriptors */
|
2009-10-12 06:00:39 +00:00
|
|
|
vaddr = dma_alloc_coherent(dev,
|
2009-11-02 07:03:15 +00:00
|
|
|
sizeof(struct txbd8) * priv->total_tx_ring_size +
|
|
|
|
sizeof(struct rxbd8) * priv->total_rx_ring_size,
|
|
|
|
&addr, GFP_KERNEL);
|
2009-10-12 06:00:34 +00:00
|
|
|
if (!vaddr) {
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_err(priv, ifup, ndev,
|
|
|
|
"Could not allocate buffer descriptors!\n");
|
2009-10-12 06:00:34 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
for (i = 0; i < priv->num_tx_queues; i++) {
|
|
|
|
tx_queue = priv->tx_queue[i];
|
2011-06-16 19:08:06 +00:00
|
|
|
tx_queue->tx_bd_base = vaddr;
|
2009-11-02 07:03:15 +00:00
|
|
|
tx_queue->tx_bd_dma_base = addr;
|
|
|
|
tx_queue->dev = ndev;
|
|
|
|
/* enet DMA only understands physical addresses */
|
2012-06-05 03:42:13 +00:00
|
|
|
addr += sizeof(struct txbd8) * tx_queue->tx_ring_size;
|
|
|
|
vaddr += sizeof(struct txbd8) * tx_queue->tx_ring_size;
|
2009-11-02 07:03:15 +00:00
|
|
|
}
|
2009-10-12 06:00:34 +00:00
|
|
|
|
|
|
|
/* Start the rx descriptor ring where the tx ring leaves off */
|
2009-11-02 07:03:15 +00:00
|
|
|
for (i = 0; i < priv->num_rx_queues; i++) {
|
|
|
|
rx_queue = priv->rx_queue[i];
|
2011-06-16 19:08:06 +00:00
|
|
|
rx_queue->rx_bd_base = vaddr;
|
2009-11-02 07:03:15 +00:00
|
|
|
rx_queue->rx_bd_dma_base = addr;
|
|
|
|
rx_queue->dev = ndev;
|
2012-06-05 03:42:13 +00:00
|
|
|
addr += sizeof(struct rxbd8) * rx_queue->rx_ring_size;
|
|
|
|
vaddr += sizeof(struct rxbd8) * rx_queue->rx_ring_size;
|
2009-11-02 07:03:15 +00:00
|
|
|
}
|
2009-10-12 06:00:34 +00:00
|
|
|
|
|
|
|
/* Setup the skbuff rings */
|
2009-11-02 07:03:15 +00:00
|
|
|
for (i = 0; i < priv->num_tx_queues; i++) {
|
|
|
|
tx_queue = priv->tx_queue[i];
|
|
|
|
tx_queue->tx_skbuff = kmalloc(sizeof(*tx_queue->tx_skbuff) *
|
2012-06-05 03:42:13 +00:00
|
|
|
tx_queue->tx_ring_size,
|
|
|
|
GFP_KERNEL);
|
2009-11-02 07:03:15 +00:00
|
|
|
if (!tx_queue->tx_skbuff) {
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_err(priv, ifup, ndev,
|
|
|
|
"Could not allocate tx_skbuff\n");
|
2009-11-02 07:03:15 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2009-10-12 06:00:34 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
for (k = 0; k < tx_queue->tx_ring_size; k++)
|
|
|
|
tx_queue->tx_skbuff[k] = NULL;
|
|
|
|
}
|
2009-10-12 06:00:34 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
for (i = 0; i < priv->num_rx_queues; i++) {
|
|
|
|
rx_queue = priv->rx_queue[i];
|
|
|
|
rx_queue->rx_skbuff = kmalloc(sizeof(*rx_queue->rx_skbuff) *
|
2012-06-05 03:42:13 +00:00
|
|
|
rx_queue->rx_ring_size,
|
|
|
|
GFP_KERNEL);
|
2009-10-12 06:00:34 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
if (!rx_queue->rx_skbuff) {
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_err(priv, ifup, ndev,
|
|
|
|
"Could not allocate rx_skbuff\n");
|
2009-11-02 07:03:15 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (j = 0; j < rx_queue->rx_ring_size; j++)
|
|
|
|
rx_queue->rx_skbuff[j] = NULL;
|
|
|
|
}
|
2009-10-12 06:00:34 +00:00
|
|
|
|
2009-10-12 06:00:39 +00:00
|
|
|
if (gfar_init_bds(ndev))
|
|
|
|
goto cleanup;
|
2009-10-12 06:00:34 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
free_skb_resources(priv);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
static void gfar_init_tx_rx_base(struct gfar_private *priv)
|
|
|
|
{
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = priv->gfargrp[0].regs;
|
2009-11-04 12:53:00 +00:00
|
|
|
u32 __iomem *baddr;
|
2009-11-02 07:03:15 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
baddr = ®s->tbase0;
|
2012-06-05 03:42:13 +00:00
|
|
|
for (i = 0; i < priv->num_tx_queues; i++) {
|
2009-11-02 07:03:15 +00:00
|
|
|
gfar_write(baddr, priv->tx_queue[i]->tx_bd_dma_base);
|
2012-06-05 03:42:13 +00:00
|
|
|
baddr += 2;
|
2009-11-02 07:03:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
baddr = ®s->rbase0;
|
2012-06-05 03:42:13 +00:00
|
|
|
for (i = 0; i < priv->num_rx_queues; i++) {
|
2009-11-02 07:03:15 +00:00
|
|
|
gfar_write(baddr, priv->rx_queue[i]->rx_bd_dma_base);
|
2012-06-05 03:42:13 +00:00
|
|
|
baddr += 2;
|
2009-11-02 07:03:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-12 06:00:34 +00:00
|
|
|
static void gfar_init_mac(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(ndev);
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = priv->gfargrp[0].regs;
|
2009-10-12 06:00:34 +00:00
|
|
|
u32 rctrl = 0;
|
|
|
|
u32 tctrl = 0;
|
|
|
|
u32 attrs = 0;
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
/* write the tx/rx base registers */
|
|
|
|
gfar_init_tx_rx_base(priv);
|
2009-10-12 06:00:36 +00:00
|
|
|
|
2009-10-12 06:00:34 +00:00
|
|
|
/* Configure the coalescing support */
|
2009-11-02 07:03:34 +00:00
|
|
|
gfar_configure_coalescing(priv, 0xFF, 0xFF);
|
2009-11-02 07:03:15 +00:00
|
|
|
|
2009-12-16 01:14:58 +00:00
|
|
|
if (priv->rx_filer_enable) {
|
2009-11-02 07:03:15 +00:00
|
|
|
rctrl |= RCTRL_FILREN;
|
2009-12-16 01:14:58 +00:00
|
|
|
/* Program the RIR0 reg with the required distribution */
|
|
|
|
gfar_write(®s->rir0, DEFAULT_RIR0);
|
|
|
|
}
|
2009-10-12 06:00:34 +00:00
|
|
|
|
2011-04-15 04:50:50 +00:00
|
|
|
if (ndev->features & NETIF_F_RXCSUM)
|
2009-10-12 06:00:34 +00:00
|
|
|
rctrl |= RCTRL_CHECKSUMMING;
|
|
|
|
|
|
|
|
if (priv->extended_hash) {
|
|
|
|
rctrl |= RCTRL_EXTHASH;
|
|
|
|
|
|
|
|
gfar_clear_exact_match(ndev);
|
|
|
|
rctrl |= RCTRL_EMEN;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->padding) {
|
|
|
|
rctrl &= ~RCTRL_PAL_MASK;
|
|
|
|
rctrl |= RCTRL_PADDING(priv->padding);
|
|
|
|
}
|
|
|
|
|
2010-04-08 23:10:03 +00:00
|
|
|
/* Insert receive time stamps into padding alignment bytes */
|
|
|
|
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER) {
|
|
|
|
rctrl &= ~RCTRL_PAL_MASK;
|
2010-06-11 01:49:05 +00:00
|
|
|
rctrl |= RCTRL_PADDING(8);
|
2010-04-08 23:10:03 +00:00
|
|
|
priv->padding = 8;
|
|
|
|
}
|
|
|
|
|
2010-06-11 01:49:05 +00:00
|
|
|
/* Enable HW time stamping if requested from user space */
|
|
|
|
if (priv->hwts_rx_en)
|
|
|
|
rctrl |= RCTRL_PRSDEP_INIT | RCTRL_TS_ENABLE;
|
|
|
|
|
2011-07-20 04:54:19 +00:00
|
|
|
if (ndev->features & NETIF_F_HW_VLAN_RX)
|
2011-07-26 00:03:13 +00:00
|
|
|
rctrl |= RCTRL_VLEX | RCTRL_PRSDEP_INIT;
|
2009-10-12 06:00:34 +00:00
|
|
|
|
|
|
|
/* Init rctrl based on our settings */
|
|
|
|
gfar_write(®s->rctrl, rctrl);
|
|
|
|
|
|
|
|
if (ndev->features & NETIF_F_IP_CSUM)
|
|
|
|
tctrl |= TCTRL_INIT_CSUM;
|
|
|
|
|
2012-09-23 22:39:08 +00:00
|
|
|
if (priv->prio_sched_en)
|
|
|
|
tctrl |= TCTRL_TXSCHED_PRIO;
|
|
|
|
else {
|
|
|
|
tctrl |= TCTRL_TXSCHED_WRRS;
|
|
|
|
gfar_write(®s->tr03wt, DEFAULT_WRRS_WEIGHT);
|
|
|
|
gfar_write(®s->tr47wt, DEFAULT_WRRS_WEIGHT);
|
|
|
|
}
|
2009-11-02 07:03:15 +00:00
|
|
|
|
2009-10-12 06:00:34 +00:00
|
|
|
gfar_write(®s->tctrl, tctrl);
|
|
|
|
|
|
|
|
/* Set the extraction length and index */
|
|
|
|
attrs = ATTRELI_EL(priv->rx_stash_size) |
|
|
|
|
ATTRELI_EI(priv->rx_stash_index);
|
|
|
|
|
|
|
|
gfar_write(®s->attreli, attrs);
|
|
|
|
|
|
|
|
/* Start with defaults, and add stashing or locking
|
2012-06-05 03:42:12 +00:00
|
|
|
* depending on the approprate variables
|
|
|
|
*/
|
2009-10-12 06:00:34 +00:00
|
|
|
attrs = ATTR_INIT_SETTINGS;
|
|
|
|
|
|
|
|
if (priv->bd_stash_en)
|
|
|
|
attrs |= ATTR_BDSTASH;
|
|
|
|
|
|
|
|
if (priv->rx_stash_size != 0)
|
|
|
|
attrs |= ATTR_BUFSTASH;
|
|
|
|
|
|
|
|
gfar_write(®s->attr, attrs);
|
|
|
|
|
|
|
|
gfar_write(®s->fifo_tx_thr, priv->fifo_threshold);
|
|
|
|
gfar_write(®s->fifo_tx_starve, priv->fifo_starve);
|
|
|
|
gfar_write(®s->fifo_tx_starve_shutoff, priv->fifo_starve_off);
|
|
|
|
}
|
|
|
|
|
2009-12-16 01:15:07 +00:00
|
|
|
static struct net_device_stats *gfar_get_stats(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
|
|
|
unsigned long rx_packets = 0, rx_bytes = 0, rx_dropped = 0;
|
|
|
|
unsigned long tx_packets = 0, tx_bytes = 0;
|
2012-06-05 03:42:14 +00:00
|
|
|
int i;
|
2009-12-16 01:15:07 +00:00
|
|
|
|
|
|
|
for (i = 0; i < priv->num_rx_queues; i++) {
|
|
|
|
rx_packets += priv->rx_queue[i]->stats.rx_packets;
|
2012-06-05 03:42:13 +00:00
|
|
|
rx_bytes += priv->rx_queue[i]->stats.rx_bytes;
|
2009-12-16 01:15:07 +00:00
|
|
|
rx_dropped += priv->rx_queue[i]->stats.rx_dropped;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->stats.rx_packets = rx_packets;
|
2012-06-05 03:42:13 +00:00
|
|
|
dev->stats.rx_bytes = rx_bytes;
|
2009-12-16 01:15:07 +00:00
|
|
|
dev->stats.rx_dropped = rx_dropped;
|
|
|
|
|
|
|
|
for (i = 0; i < priv->num_tx_queues; i++) {
|
2011-01-12 12:13:14 +00:00
|
|
|
tx_bytes += priv->tx_queue[i]->stats.tx_bytes;
|
|
|
|
tx_packets += priv->tx_queue[i]->stats.tx_packets;
|
2009-12-16 01:15:07 +00:00
|
|
|
}
|
|
|
|
|
2012-06-05 03:42:13 +00:00
|
|
|
dev->stats.tx_bytes = tx_bytes;
|
2009-12-16 01:15:07 +00:00
|
|
|
dev->stats.tx_packets = tx_packets;
|
|
|
|
|
|
|
|
return &dev->stats;
|
|
|
|
}
|
|
|
|
|
2009-03-10 12:58:28 +00:00
|
|
|
static const struct net_device_ops gfar_netdev_ops = {
|
|
|
|
.ndo_open = gfar_enet_open,
|
|
|
|
.ndo_start_xmit = gfar_start_xmit,
|
|
|
|
.ndo_stop = gfar_close,
|
|
|
|
.ndo_change_mtu = gfar_change_mtu,
|
2011-04-15 04:50:50 +00:00
|
|
|
.ndo_set_features = gfar_set_features,
|
2011-08-16 06:29:01 +00:00
|
|
|
.ndo_set_rx_mode = gfar_set_multi,
|
2009-03-10 12:58:28 +00:00
|
|
|
.ndo_tx_timeout = gfar_timeout,
|
|
|
|
.ndo_do_ioctl = gfar_ioctl,
|
2009-12-16 01:15:07 +00:00
|
|
|
.ndo_get_stats = gfar_get_stats,
|
2009-07-09 17:54:35 +00:00
|
|
|
.ndo_set_mac_address = eth_mac_addr,
|
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
2009-03-10 12:58:28 +00:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
.ndo_poll_controller = gfar_netpoll,
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
void lock_rx_qs(struct gfar_private *priv)
|
|
|
|
{
|
2012-06-05 03:42:14 +00:00
|
|
|
int i;
|
2009-11-02 07:03:15 +00:00
|
|
|
|
|
|
|
for (i = 0; i < priv->num_rx_queues; i++)
|
|
|
|
spin_lock(&priv->rx_queue[i]->rxlock);
|
|
|
|
}
|
|
|
|
|
|
|
|
void lock_tx_qs(struct gfar_private *priv)
|
|
|
|
{
|
2012-06-05 03:42:14 +00:00
|
|
|
int i;
|
2009-11-02 07:03:15 +00:00
|
|
|
|
|
|
|
for (i = 0; i < priv->num_tx_queues; i++)
|
|
|
|
spin_lock(&priv->tx_queue[i]->txlock);
|
|
|
|
}
|
|
|
|
|
|
|
|
void unlock_rx_qs(struct gfar_private *priv)
|
|
|
|
{
|
2012-06-05 03:42:14 +00:00
|
|
|
int i;
|
2009-11-02 07:03:15 +00:00
|
|
|
|
|
|
|
for (i = 0; i < priv->num_rx_queues; i++)
|
|
|
|
spin_unlock(&priv->rx_queue[i]->rxlock);
|
|
|
|
}
|
|
|
|
|
|
|
|
void unlock_tx_qs(struct gfar_private *priv)
|
|
|
|
{
|
2012-06-05 03:42:14 +00:00
|
|
|
int i;
|
2009-11-02 07:03:15 +00:00
|
|
|
|
|
|
|
for (i = 0; i < priv->num_tx_queues; i++)
|
|
|
|
spin_unlock(&priv->tx_queue[i]->txlock);
|
|
|
|
}
|
|
|
|
|
2011-07-20 04:54:19 +00:00
|
|
|
static bool gfar_is_vlan_on(struct gfar_private *priv)
|
|
|
|
{
|
|
|
|
return (priv->ndev->features & NETIF_F_HW_VLAN_RX) ||
|
|
|
|
(priv->ndev->features & NETIF_F_HW_VLAN_TX);
|
|
|
|
}
|
|
|
|
|
2005-11-11 18:38:59 +00:00
|
|
|
/* Returns 1 if incoming frames use an FCB */
|
|
|
|
static inline int gfar_uses_fcb(struct gfar_private *priv)
|
2005-06-20 15:54:21 +00:00
|
|
|
{
|
2011-07-20 04:54:19 +00:00
|
|
|
return gfar_is_vlan_on(priv) ||
|
2012-06-05 03:42:13 +00:00
|
|
|
(priv->ndev->features & NETIF_F_RXCSUM) ||
|
|
|
|
(priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER);
|
2005-06-20 15:54:21 +00:00
|
|
|
}
|
2005-09-24 02:54:21 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
static void free_tx_pointers(struct gfar_private *priv)
|
|
|
|
{
|
2012-06-05 03:42:14 +00:00
|
|
|
int i;
|
2009-11-02 07:03:15 +00:00
|
|
|
|
|
|
|
for (i = 0; i < priv->num_tx_queues; i++)
|
|
|
|
kfree(priv->tx_queue[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_rx_pointers(struct gfar_private *priv)
|
|
|
|
{
|
2012-06-05 03:42:14 +00:00
|
|
|
int i;
|
2009-11-02 07:03:15 +00:00
|
|
|
|
|
|
|
for (i = 0; i < priv->num_rx_queues; i++)
|
|
|
|
kfree(priv->rx_queue[i]);
|
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
static void unmap_group_regs(struct gfar_private *priv)
|
|
|
|
{
|
2012-06-05 03:42:14 +00:00
|
|
|
int i;
|
2009-11-02 07:03:34 +00:00
|
|
|
|
|
|
|
for (i = 0; i < MAXGROUPS; i++)
|
|
|
|
if (priv->gfargrp[i].regs)
|
|
|
|
iounmap(priv->gfargrp[i].regs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void disable_napi(struct gfar_private *priv)
|
|
|
|
{
|
2012-06-05 03:42:14 +00:00
|
|
|
int i;
|
2009-11-02 07:03:34 +00:00
|
|
|
|
|
|
|
for (i = 0; i < priv->num_grps; i++)
|
|
|
|
napi_disable(&priv->gfargrp[i].napi);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void enable_napi(struct gfar_private *priv)
|
|
|
|
{
|
2012-06-05 03:42:14 +00:00
|
|
|
int i;
|
2009-11-02 07:03:34 +00:00
|
|
|
|
|
|
|
for (i = 0; i < priv->num_grps; i++)
|
|
|
|
napi_enable(&priv->gfargrp[i].napi);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gfar_parse_group(struct device_node *np,
|
2012-06-05 03:42:13 +00:00
|
|
|
struct gfar_private *priv, const char *model)
|
2009-11-02 07:03:34 +00:00
|
|
|
{
|
|
|
|
u32 *queue_mask;
|
|
|
|
|
2010-04-23 07:12:44 +00:00
|
|
|
priv->gfargrp[priv->num_grps].regs = of_iomap(np, 0);
|
2009-11-02 07:03:34 +00:00
|
|
|
if (!priv->gfargrp[priv->num_grps].regs)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
priv->gfargrp[priv->num_grps].interruptTransmit =
|
|
|
|
irq_of_parse_and_map(np, 0);
|
|
|
|
|
|
|
|
/* If we aren't the FEC we have multiple interrupts */
|
|
|
|
if (model && strcasecmp(model, "FEC")) {
|
|
|
|
priv->gfargrp[priv->num_grps].interruptReceive =
|
|
|
|
irq_of_parse_and_map(np, 1);
|
|
|
|
priv->gfargrp[priv->num_grps].interruptError =
|
|
|
|
irq_of_parse_and_map(np,2);
|
2010-11-15 10:59:42 +00:00
|
|
|
if (priv->gfargrp[priv->num_grps].interruptTransmit == NO_IRQ ||
|
|
|
|
priv->gfargrp[priv->num_grps].interruptReceive == NO_IRQ ||
|
|
|
|
priv->gfargrp[priv->num_grps].interruptError == NO_IRQ)
|
2009-11-02 07:03:34 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
priv->gfargrp[priv->num_grps].grp_id = priv->num_grps;
|
|
|
|
priv->gfargrp[priv->num_grps].priv = priv;
|
|
|
|
spin_lock_init(&priv->gfargrp[priv->num_grps].grplock);
|
2012-06-05 03:42:13 +00:00
|
|
|
if (priv->mode == MQ_MG_MODE) {
|
|
|
|
queue_mask = (u32 *)of_get_property(np, "fsl,rx-bit-map", NULL);
|
|
|
|
priv->gfargrp[priv->num_grps].rx_bit_map = queue_mask ?
|
|
|
|
*queue_mask : (DEFAULT_MAPPING >> priv->num_grps);
|
|
|
|
queue_mask = (u32 *)of_get_property(np, "fsl,tx-bit-map", NULL);
|
|
|
|
priv->gfargrp[priv->num_grps].tx_bit_map = queue_mask ?
|
|
|
|
*queue_mask : (DEFAULT_MAPPING >> priv->num_grps);
|
2009-11-02 07:03:34 +00:00
|
|
|
} else {
|
|
|
|
priv->gfargrp[priv->num_grps].rx_bit_map = 0xFF;
|
|
|
|
priv->gfargrp[priv->num_grps].tx_bit_map = 0xFF;
|
|
|
|
}
|
|
|
|
priv->num_grps++;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-08-06 15:25:50 +00:00
|
|
|
static int gfar_of_init(struct platform_device *ofdev, struct net_device **pdev)
|
2008-12-16 23:29:15 +00:00
|
|
|
{
|
|
|
|
const char *model;
|
|
|
|
const char *ctype;
|
|
|
|
const void *mac_addr;
|
2009-11-02 07:03:15 +00:00
|
|
|
int err = 0, i;
|
|
|
|
struct net_device *dev = NULL;
|
|
|
|
struct gfar_private *priv = NULL;
|
2010-04-13 23:12:29 +00:00
|
|
|
struct device_node *np = ofdev->dev.of_node;
|
2009-11-02 07:03:34 +00:00
|
|
|
struct device_node *child = NULL;
|
2009-02-05 00:43:44 +00:00
|
|
|
const u32 *stash;
|
|
|
|
const u32 *stash_len;
|
|
|
|
const u32 *stash_idx;
|
2009-11-02 07:03:15 +00:00
|
|
|
unsigned int num_tx_qs, num_rx_qs;
|
|
|
|
u32 *tx_queues, *rx_queues;
|
2008-12-16 23:29:15 +00:00
|
|
|
|
|
|
|
if (!np || !of_device_is_available(np))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
/* parse the num of tx and rx queues */
|
|
|
|
tx_queues = (u32 *)of_get_property(np, "fsl,num_tx_queues", NULL);
|
|
|
|
num_tx_qs = tx_queues ? *tx_queues : 1;
|
|
|
|
|
|
|
|
if (num_tx_qs > MAX_TX_QS) {
|
2011-06-14 08:57:47 +00:00
|
|
|
pr_err("num_tx_qs(=%d) greater than MAX_TX_QS(=%d)\n",
|
|
|
|
num_tx_qs, MAX_TX_QS);
|
|
|
|
pr_err("Cannot do alloc_etherdev, aborting\n");
|
2009-11-02 07:03:15 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
rx_queues = (u32 *)of_get_property(np, "fsl,num_rx_queues", NULL);
|
|
|
|
num_rx_qs = rx_queues ? *rx_queues : 1;
|
|
|
|
|
|
|
|
if (num_rx_qs > MAX_RX_QS) {
|
2011-06-14 08:57:47 +00:00
|
|
|
pr_err("num_rx_qs(=%d) greater than MAX_RX_QS(=%d)\n",
|
|
|
|
num_rx_qs, MAX_RX_QS);
|
|
|
|
pr_err("Cannot do alloc_etherdev, aborting\n");
|
2009-11-02 07:03:15 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
*pdev = alloc_etherdev_mq(sizeof(*priv), num_tx_qs);
|
|
|
|
dev = *pdev;
|
|
|
|
if (NULL == dev)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
priv = netdev_priv(dev);
|
2010-04-13 23:12:29 +00:00
|
|
|
priv->node = ofdev->dev.of_node;
|
2009-11-02 07:03:15 +00:00
|
|
|
priv->ndev = dev;
|
|
|
|
|
|
|
|
priv->num_tx_queues = num_tx_qs;
|
2010-09-27 08:27:37 +00:00
|
|
|
netif_set_real_num_rx_queues(dev, num_rx_qs);
|
2009-11-02 07:03:15 +00:00
|
|
|
priv->num_rx_queues = num_rx_qs;
|
2009-11-02 07:03:34 +00:00
|
|
|
priv->num_grps = 0x0;
|
2008-12-16 23:29:15 +00:00
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* Init Rx queue filer rule set linked list */
|
2011-06-20 20:57:59 +00:00
|
|
|
INIT_LIST_HEAD(&priv->rx_list.list);
|
|
|
|
priv->rx_list.count = 0;
|
|
|
|
mutex_init(&priv->rx_queue_access);
|
|
|
|
|
2008-12-16 23:29:15 +00:00
|
|
|
model = of_get_property(np, "model", NULL);
|
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
for (i = 0; i < MAXGROUPS; i++)
|
|
|
|
priv->gfargrp[i].regs = NULL;
|
2008-12-16 23:29:15 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
/* Parse and initialize group specific information */
|
|
|
|
if (of_device_is_compatible(np, "fsl,etsec2")) {
|
|
|
|
priv->mode = MQ_MG_MODE;
|
|
|
|
for_each_child_of_node(np, child) {
|
|
|
|
err = gfar_parse_group(child, priv, model);
|
|
|
|
if (err)
|
|
|
|
goto err_grp_init;
|
2008-12-16 23:29:15 +00:00
|
|
|
}
|
2009-11-02 07:03:34 +00:00
|
|
|
} else {
|
|
|
|
priv->mode = SQ_SG_MODE;
|
|
|
|
err = gfar_parse_group(np, priv, model);
|
2012-06-05 03:42:13 +00:00
|
|
|
if (err)
|
2009-11-02 07:03:34 +00:00
|
|
|
goto err_grp_init;
|
2008-12-16 23:29:15 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
for (i = 0; i < priv->num_tx_queues; i++)
|
|
|
|
priv->tx_queue[i] = NULL;
|
|
|
|
for (i = 0; i < priv->num_rx_queues; i++)
|
|
|
|
priv->rx_queue[i] = NULL;
|
|
|
|
|
|
|
|
for (i = 0; i < priv->num_tx_queues; i++) {
|
2010-05-31 17:23:12 +00:00
|
|
|
priv->tx_queue[i] = kzalloc(sizeof(struct gfar_priv_tx_q),
|
|
|
|
GFP_KERNEL);
|
2009-11-02 07:03:15 +00:00
|
|
|
if (!priv->tx_queue[i]) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto tx_alloc_failed;
|
|
|
|
}
|
|
|
|
priv->tx_queue[i]->tx_skbuff = NULL;
|
|
|
|
priv->tx_queue[i]->qindex = i;
|
|
|
|
priv->tx_queue[i]->dev = dev;
|
|
|
|
spin_lock_init(&(priv->tx_queue[i]->txlock));
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < priv->num_rx_queues; i++) {
|
2010-05-31 17:23:12 +00:00
|
|
|
priv->rx_queue[i] = kzalloc(sizeof(struct gfar_priv_rx_q),
|
|
|
|
GFP_KERNEL);
|
2009-11-02 07:03:15 +00:00
|
|
|
if (!priv->rx_queue[i]) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto rx_alloc_failed;
|
|
|
|
}
|
|
|
|
priv->rx_queue[i]->rx_skbuff = NULL;
|
|
|
|
priv->rx_queue[i]->qindex = i;
|
|
|
|
priv->rx_queue[i]->dev = dev;
|
|
|
|
spin_lock_init(&(priv->rx_queue[i]->rxlock));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-02-05 00:43:44 +00:00
|
|
|
stash = of_get_property(np, "bd-stash", NULL);
|
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
if (stash) {
|
2009-02-05 00:43:44 +00:00
|
|
|
priv->device_flags |= FSL_GIANFAR_DEV_HAS_BD_STASHING;
|
|
|
|
priv->bd_stash_en = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
stash_len = of_get_property(np, "rx-stash-len", NULL);
|
|
|
|
|
|
|
|
if (stash_len)
|
|
|
|
priv->rx_stash_size = *stash_len;
|
|
|
|
|
|
|
|
stash_idx = of_get_property(np, "rx-stash-idx", NULL);
|
|
|
|
|
|
|
|
if (stash_idx)
|
|
|
|
priv->rx_stash_index = *stash_idx;
|
|
|
|
|
|
|
|
if (stash_len || stash_idx)
|
|
|
|
priv->device_flags |= FSL_GIANFAR_DEV_HAS_BUF_STASHING;
|
|
|
|
|
2008-12-16 23:29:15 +00:00
|
|
|
mac_addr = of_get_mac_address(np);
|
2012-06-05 03:42:13 +00:00
|
|
|
|
2008-12-16 23:29:15 +00:00
|
|
|
if (mac_addr)
|
2011-11-16 09:38:02 +00:00
|
|
|
memcpy(dev->dev_addr, mac_addr, ETH_ALEN);
|
2008-12-16 23:29:15 +00:00
|
|
|
|
|
|
|
if (model && !strcasecmp(model, "TSEC"))
|
2012-06-05 03:42:13 +00:00
|
|
|
priv->device_flags = FSL_GIANFAR_DEV_HAS_GIGABIT |
|
|
|
|
FSL_GIANFAR_DEV_HAS_COALESCE |
|
|
|
|
FSL_GIANFAR_DEV_HAS_RMON |
|
|
|
|
FSL_GIANFAR_DEV_HAS_MULTI_INTR;
|
|
|
|
|
2008-12-16 23:29:15 +00:00
|
|
|
if (model && !strcasecmp(model, "eTSEC"))
|
2012-06-05 03:42:13 +00:00
|
|
|
priv->device_flags = FSL_GIANFAR_DEV_HAS_GIGABIT |
|
|
|
|
FSL_GIANFAR_DEV_HAS_COALESCE |
|
|
|
|
FSL_GIANFAR_DEV_HAS_RMON |
|
|
|
|
FSL_GIANFAR_DEV_HAS_MULTI_INTR |
|
|
|
|
FSL_GIANFAR_DEV_HAS_PADDING |
|
|
|
|
FSL_GIANFAR_DEV_HAS_CSUM |
|
|
|
|
FSL_GIANFAR_DEV_HAS_VLAN |
|
|
|
|
FSL_GIANFAR_DEV_HAS_MAGIC_PACKET |
|
|
|
|
FSL_GIANFAR_DEV_HAS_EXTENDED_HASH |
|
|
|
|
FSL_GIANFAR_DEV_HAS_TIMER;
|
2008-12-16 23:29:15 +00:00
|
|
|
|
|
|
|
ctype = of_get_property(np, "phy-connection-type", NULL);
|
|
|
|
|
|
|
|
/* We only care about rgmii-id. The rest are autodetected */
|
|
|
|
if (ctype && !strcmp(ctype, "rgmii-id"))
|
|
|
|
priv->interface = PHY_INTERFACE_MODE_RGMII_ID;
|
|
|
|
else
|
|
|
|
priv->interface = PHY_INTERFACE_MODE_MII;
|
|
|
|
|
|
|
|
if (of_get_property(np, "fsl,magic-packet", NULL))
|
|
|
|
priv->device_flags |= FSL_GIANFAR_DEV_HAS_MAGIC_PACKET;
|
|
|
|
|
2009-04-25 12:53:12 +00:00
|
|
|
priv->phy_node = of_parse_phandle(np, "phy-handle", 0);
|
2008-12-16 23:29:15 +00:00
|
|
|
|
|
|
|
/* Find the TBI PHY. If it's not there, we don't support SGMII */
|
2009-04-25 12:53:12 +00:00
|
|
|
priv->tbi_node = of_parse_phandle(np, "tbi-handle", 0);
|
2008-12-16 23:29:15 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
rx_alloc_failed:
|
|
|
|
free_rx_pointers(priv);
|
|
|
|
tx_alloc_failed:
|
|
|
|
free_tx_pointers(priv);
|
2009-11-02 07:03:34 +00:00
|
|
|
err_grp_init:
|
|
|
|
unmap_group_regs(priv);
|
2009-11-02 07:03:15 +00:00
|
|
|
free_netdev(dev);
|
2008-12-16 23:29:15 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-04-08 23:10:03 +00:00
|
|
|
static int gfar_hwtstamp_ioctl(struct net_device *netdev,
|
2012-06-05 03:42:13 +00:00
|
|
|
struct ifreq *ifr, int cmd)
|
2010-04-08 23:10:03 +00:00
|
|
|
{
|
|
|
|
struct hwtstamp_config config;
|
|
|
|
struct gfar_private *priv = netdev_priv(netdev);
|
|
|
|
|
|
|
|
if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
/* reserved for future extensions */
|
|
|
|
if (config.flags)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-04-08 23:10:35 +00:00
|
|
|
switch (config.tx_type) {
|
|
|
|
case HWTSTAMP_TX_OFF:
|
|
|
|
priv->hwts_tx_en = 0;
|
|
|
|
break;
|
|
|
|
case HWTSTAMP_TX_ON:
|
|
|
|
if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER))
|
|
|
|
return -ERANGE;
|
|
|
|
priv->hwts_tx_en = 1;
|
|
|
|
break;
|
|
|
|
default:
|
2010-04-08 23:10:03 +00:00
|
|
|
return -ERANGE;
|
2010-04-08 23:10:35 +00:00
|
|
|
}
|
2010-04-08 23:10:03 +00:00
|
|
|
|
|
|
|
switch (config.rx_filter) {
|
|
|
|
case HWTSTAMP_FILTER_NONE:
|
2010-06-11 01:49:05 +00:00
|
|
|
if (priv->hwts_rx_en) {
|
|
|
|
stop_gfar(netdev);
|
|
|
|
priv->hwts_rx_en = 0;
|
|
|
|
startup_gfar(netdev);
|
|
|
|
}
|
2010-04-08 23:10:03 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER))
|
|
|
|
return -ERANGE;
|
2010-06-11 01:49:05 +00:00
|
|
|
if (!priv->hwts_rx_en) {
|
|
|
|
stop_gfar(netdev);
|
|
|
|
priv->hwts_rx_en = 1;
|
|
|
|
startup_gfar(netdev);
|
|
|
|
}
|
2010-04-08 23:10:03 +00:00
|
|
|
config.rx_filter = HWTSTAMP_FILTER_ALL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return copy_to_user(ifr->ifr_data, &config, sizeof(config)) ?
|
|
|
|
-EFAULT : 0;
|
|
|
|
}
|
|
|
|
|
2009-01-09 10:23:11 +00:00
|
|
|
/* Ioctl MII Interface */
|
|
|
|
static int gfar_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
|
|
|
|
|
|
|
if (!netif_running(dev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-04-08 23:10:03 +00:00
|
|
|
if (cmd == SIOCSHWTSTAMP)
|
|
|
|
return gfar_hwtstamp_ioctl(dev, rq, cmd);
|
|
|
|
|
2009-01-09 10:23:11 +00:00
|
|
|
if (!priv->phydev)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2010-07-17 08:48:55 +00:00
|
|
|
return phy_mii_ioctl(priv->phydev, rq, cmd);
|
2009-01-09 10:23:11 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
static unsigned int reverse_bitmap(unsigned int bit_map, unsigned int max_qs)
|
|
|
|
{
|
|
|
|
unsigned int new_bit_map = 0x0;
|
|
|
|
int mask = 0x1 << (max_qs - 1), i;
|
2012-06-05 03:42:13 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
for (i = 0; i < max_qs; i++) {
|
|
|
|
if (bit_map & mask)
|
|
|
|
new_bit_map = new_bit_map + (1 << i);
|
|
|
|
mask = mask >> 0x1;
|
|
|
|
}
|
|
|
|
return new_bit_map;
|
|
|
|
}
|
2009-11-02 07:03:40 +00:00
|
|
|
|
2009-11-04 12:53:00 +00:00
|
|
|
static u32 cluster_entry_per_class(struct gfar_private *priv, u32 rqfar,
|
|
|
|
u32 class)
|
2009-11-02 07:03:40 +00:00
|
|
|
{
|
|
|
|
u32 rqfpr = FPR_FILER_MASK;
|
|
|
|
u32 rqfcr = 0x0;
|
|
|
|
|
|
|
|
rqfar--;
|
|
|
|
rqfcr = RQFCR_CLE | RQFCR_PID_MASK | RQFCR_CMP_EXACT;
|
2011-06-07 21:46:51 +00:00
|
|
|
priv->ftp_rqfpr[rqfar] = rqfpr;
|
|
|
|
priv->ftp_rqfcr[rqfar] = rqfcr;
|
2009-11-02 07:03:40 +00:00
|
|
|
gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
|
|
|
|
|
|
|
|
rqfar--;
|
|
|
|
rqfcr = RQFCR_CMP_NOMATCH;
|
2011-06-07 21:46:51 +00:00
|
|
|
priv->ftp_rqfpr[rqfar] = rqfpr;
|
|
|
|
priv->ftp_rqfcr[rqfar] = rqfcr;
|
2009-11-02 07:03:40 +00:00
|
|
|
gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
|
|
|
|
|
|
|
|
rqfar--;
|
|
|
|
rqfcr = RQFCR_CMP_EXACT | RQFCR_PID_PARSE | RQFCR_CLE | RQFCR_AND;
|
|
|
|
rqfpr = class;
|
2011-06-07 21:46:51 +00:00
|
|
|
priv->ftp_rqfcr[rqfar] = rqfcr;
|
|
|
|
priv->ftp_rqfpr[rqfar] = rqfpr;
|
2009-11-02 07:03:40 +00:00
|
|
|
gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
|
|
|
|
|
|
|
|
rqfar--;
|
|
|
|
rqfcr = RQFCR_CMP_EXACT | RQFCR_PID_MASK | RQFCR_AND;
|
|
|
|
rqfpr = class;
|
2011-06-07 21:46:51 +00:00
|
|
|
priv->ftp_rqfcr[rqfar] = rqfcr;
|
|
|
|
priv->ftp_rqfpr[rqfar] = rqfpr;
|
2009-11-02 07:03:40 +00:00
|
|
|
gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
|
|
|
|
|
|
|
|
return rqfar;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gfar_init_filer_table(struct gfar_private *priv)
|
|
|
|
{
|
|
|
|
int i = 0x0;
|
|
|
|
u32 rqfar = MAX_FILER_IDX;
|
|
|
|
u32 rqfcr = 0x0;
|
|
|
|
u32 rqfpr = FPR_FILER_MASK;
|
|
|
|
|
|
|
|
/* Default rule */
|
|
|
|
rqfcr = RQFCR_CMP_MATCH;
|
2011-06-07 21:46:51 +00:00
|
|
|
priv->ftp_rqfcr[rqfar] = rqfcr;
|
|
|
|
priv->ftp_rqfpr[rqfar] = rqfpr;
|
2009-11-02 07:03:40 +00:00
|
|
|
gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
|
|
|
|
|
|
|
|
rqfar = cluster_entry_per_class(priv, rqfar, RQFPR_IPV6);
|
|
|
|
rqfar = cluster_entry_per_class(priv, rqfar, RQFPR_IPV6 | RQFPR_UDP);
|
|
|
|
rqfar = cluster_entry_per_class(priv, rqfar, RQFPR_IPV6 | RQFPR_TCP);
|
|
|
|
rqfar = cluster_entry_per_class(priv, rqfar, RQFPR_IPV4);
|
|
|
|
rqfar = cluster_entry_per_class(priv, rqfar, RQFPR_IPV4 | RQFPR_UDP);
|
|
|
|
rqfar = cluster_entry_per_class(priv, rqfar, RQFPR_IPV4 | RQFPR_TCP);
|
|
|
|
|
2010-06-11 10:16:55 +00:00
|
|
|
/* cur_filer_idx indicated the first non-masked rule */
|
2009-11-02 07:03:40 +00:00
|
|
|
priv->cur_filer_idx = rqfar;
|
|
|
|
|
|
|
|
/* Rest are masked rules */
|
|
|
|
rqfcr = RQFCR_CMP_NOMATCH;
|
|
|
|
for (i = 0; i < rqfar; i++) {
|
2011-06-07 21:46:51 +00:00
|
|
|
priv->ftp_rqfcr[i] = rqfcr;
|
|
|
|
priv->ftp_rqfpr[i] = rqfpr;
|
2009-11-02 07:03:40 +00:00
|
|
|
gfar_write_filer(priv, i, rqfcr, rqfpr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-30 06:39:12 +00:00
|
|
|
static void gfar_detect_errata(struct gfar_private *priv)
|
|
|
|
{
|
|
|
|
struct device *dev = &priv->ofdev->dev;
|
|
|
|
unsigned int pvr = mfspr(SPRN_PVR);
|
|
|
|
unsigned int svr = mfspr(SPRN_SVR);
|
|
|
|
unsigned int mod = (svr >> 16) & 0xfff6; /* w/o E suffix */
|
|
|
|
unsigned int rev = svr & 0xffff;
|
|
|
|
|
|
|
|
/* MPC8313 Rev 2.0 and higher; All MPC837x */
|
|
|
|
if ((pvr == 0x80850010 && mod == 0x80b0 && rev >= 0x0020) ||
|
2012-06-05 03:42:13 +00:00
|
|
|
(pvr == 0x80861010 && (mod & 0xfff9) == 0x80c0))
|
2010-06-30 06:39:12 +00:00
|
|
|
priv->errata |= GFAR_ERRATA_74;
|
|
|
|
|
2010-06-30 06:39:13 +00:00
|
|
|
/* MPC8313 and MPC837x all rev */
|
|
|
|
if ((pvr == 0x80850010 && mod == 0x80b0) ||
|
2012-06-05 03:42:13 +00:00
|
|
|
(pvr == 0x80861010 && (mod & 0xfff9) == 0x80c0))
|
2010-06-30 06:39:13 +00:00
|
|
|
priv->errata |= GFAR_ERRATA_76;
|
|
|
|
|
2010-06-30 06:39:15 +00:00
|
|
|
/* MPC8313 and MPC837x all rev */
|
|
|
|
if ((pvr == 0x80850010 && mod == 0x80b0) ||
|
2012-06-05 03:42:13 +00:00
|
|
|
(pvr == 0x80861010 && (mod & 0xfff9) == 0x80c0))
|
2010-06-30 06:39:15 +00:00
|
|
|
priv->errata |= GFAR_ERRATA_A002;
|
|
|
|
|
2011-03-16 17:57:13 +00:00
|
|
|
/* MPC8313 Rev < 2.0, MPC8548 rev 2.0 */
|
|
|
|
if ((pvr == 0x80850010 && mod == 0x80b0 && rev < 0x0020) ||
|
2012-06-05 03:42:13 +00:00
|
|
|
(pvr == 0x80210020 && mod == 0x8030 && rev == 0x0020))
|
2011-03-16 17:57:13 +00:00
|
|
|
priv->errata |= GFAR_ERRATA_12;
|
|
|
|
|
2010-06-30 06:39:12 +00:00
|
|
|
if (priv->errata)
|
|
|
|
dev_info(dev, "enabled errata workarounds, flags: 0x%x\n",
|
|
|
|
priv->errata);
|
|
|
|
}
|
|
|
|
|
2005-09-24 02:54:21 +00:00
|
|
|
/* Set up the ethernet device structure, private data,
|
2012-06-05 03:42:12 +00:00
|
|
|
* and anything else we need before we start
|
|
|
|
*/
|
2011-02-23 04:05:51 +00:00
|
|
|
static int gfar_probe(struct platform_device *ofdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
u32 tempval;
|
|
|
|
struct net_device *dev = NULL;
|
|
|
|
struct gfar_private *priv = NULL;
|
2009-11-02 07:03:09 +00:00
|
|
|
struct gfar __iomem *regs = NULL;
|
2009-11-02 07:03:34 +00:00
|
|
|
int err = 0, i, grp_idx = 0;
|
2009-11-02 07:03:15 +00:00
|
|
|
u32 rstat = 0, tstat = 0, rqueue = 0, tqueue = 0;
|
2009-11-02 07:03:34 +00:00
|
|
|
u32 isrg = 0;
|
2009-11-04 12:53:00 +00:00
|
|
|
u32 __iomem *baddr;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
err = gfar_of_init(ofdev, &dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
priv = netdev_priv(dev);
|
2009-03-19 06:28:22 +00:00
|
|
|
priv->ndev = dev;
|
|
|
|
priv->ofdev = ofdev;
|
2010-04-13 23:12:29 +00:00
|
|
|
priv->node = ofdev->dev.of_node;
|
2009-03-19 06:28:22 +00:00
|
|
|
SET_NETDEV_DEV(dev, &ofdev->dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-11 23:04:45 +00:00
|
|
|
spin_lock_init(&priv->bflock);
|
2008-08-19 19:12:45 +00:00
|
|
|
INIT_WORK(&priv->reset_task, gfar_reset_task);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-16 23:29:15 +00:00
|
|
|
dev_set_drvdata(&ofdev->dev, priv);
|
2009-11-02 07:03:34 +00:00
|
|
|
regs = priv->gfargrp[0].regs;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-06-30 06:39:12 +00:00
|
|
|
gfar_detect_errata(priv);
|
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* Stop the DMA engine now, in case it was running before
|
|
|
|
* (The firmware could have used it, and left it running).
|
|
|
|
*/
|
2008-12-16 23:25:45 +00:00
|
|
|
gfar_halt(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Reset MAC layer */
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->maccfg1, MACCFG1_SOFT_RESET);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-02-05 00:38:05 +00:00
|
|
|
/* We need to delay at least 3 TX clocks */
|
|
|
|
udelay(2);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
tempval = (MACCFG1_TX_FLOW | MACCFG1_RX_FLOW);
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->maccfg1, tempval);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Initialize MACCFG2. */
|
2010-06-30 06:39:12 +00:00
|
|
|
tempval = MACCFG2_INIT_SETTINGS;
|
|
|
|
if (gfar_has_errata(priv, GFAR_ERRATA_74))
|
|
|
|
tempval |= MACCFG2_HUGEFRAME | MACCFG2_LENGTHCHECK;
|
|
|
|
gfar_write(®s->maccfg2, tempval);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Initialize ECNTRL */
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->ecntrl, ECNTRL_INIT_SETTINGS);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Set the dev->base_addr to the gfar reg region */
|
2009-11-02 07:03:09 +00:00
|
|
|
dev->base_addr = (unsigned long) regs;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-16 23:29:15 +00:00
|
|
|
SET_NETDEV_DEV(dev, &ofdev->dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Fill in the dev structure */
|
|
|
|
dev->watchdog_timeo = TX_TIMEOUT;
|
|
|
|
dev->mtu = 1500;
|
2009-03-10 12:58:28 +00:00
|
|
|
dev->netdev_ops = &gfar_netdev_ops;
|
2005-06-20 15:54:21 +00:00
|
|
|
dev->ethtool_ops = &gfar_ethtool_ops;
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
/* Register for napi ...We are registering NAPI for each grp */
|
2009-11-02 07:03:34 +00:00
|
|
|
for (i = 0; i < priv->num_grps; i++)
|
2012-06-05 03:42:13 +00:00
|
|
|
netif_napi_add(dev, &priv->gfargrp[i].napi, gfar_poll,
|
|
|
|
GFAR_DEV_WEIGHT);
|
2009-11-02 07:03:00 +00:00
|
|
|
|
2008-12-16 23:29:15 +00:00
|
|
|
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM) {
|
2011-04-15 04:50:50 +00:00
|
|
|
dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG |
|
2012-06-05 03:42:13 +00:00
|
|
|
NETIF_F_RXCSUM;
|
2011-04-15 04:50:50 +00:00
|
|
|
dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG |
|
2012-06-05 03:42:13 +00:00
|
|
|
NETIF_F_RXCSUM | NETIF_F_HIGHDMA;
|
2011-04-15 04:50:50 +00:00
|
|
|
}
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2011-07-20 04:54:19 +00:00
|
|
|
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_VLAN) {
|
|
|
|
dev->hw_features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
|
2012-08-23 21:46:25 +00:00
|
|
|
dev->features |= NETIF_F_HW_VLAN_RX;
|
2011-07-20 04:54:19 +00:00
|
|
|
}
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2008-12-16 23:29:15 +00:00
|
|
|
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_EXTENDED_HASH) {
|
2005-06-20 15:54:21 +00:00
|
|
|
priv->extended_hash = 1;
|
|
|
|
priv->hash_width = 9;
|
|
|
|
|
2009-11-02 07:03:09 +00:00
|
|
|
priv->hash_regs[0] = ®s->igaddr0;
|
|
|
|
priv->hash_regs[1] = ®s->igaddr1;
|
|
|
|
priv->hash_regs[2] = ®s->igaddr2;
|
|
|
|
priv->hash_regs[3] = ®s->igaddr3;
|
|
|
|
priv->hash_regs[4] = ®s->igaddr4;
|
|
|
|
priv->hash_regs[5] = ®s->igaddr5;
|
|
|
|
priv->hash_regs[6] = ®s->igaddr6;
|
|
|
|
priv->hash_regs[7] = ®s->igaddr7;
|
|
|
|
priv->hash_regs[8] = ®s->gaddr0;
|
|
|
|
priv->hash_regs[9] = ®s->gaddr1;
|
|
|
|
priv->hash_regs[10] = ®s->gaddr2;
|
|
|
|
priv->hash_regs[11] = ®s->gaddr3;
|
|
|
|
priv->hash_regs[12] = ®s->gaddr4;
|
|
|
|
priv->hash_regs[13] = ®s->gaddr5;
|
|
|
|
priv->hash_regs[14] = ®s->gaddr6;
|
|
|
|
priv->hash_regs[15] = ®s->gaddr7;
|
2005-06-20 15:54:21 +00:00
|
|
|
|
|
|
|
} else {
|
|
|
|
priv->extended_hash = 0;
|
|
|
|
priv->hash_width = 8;
|
|
|
|
|
2009-11-02 07:03:09 +00:00
|
|
|
priv->hash_regs[0] = ®s->gaddr0;
|
|
|
|
priv->hash_regs[1] = ®s->gaddr1;
|
|
|
|
priv->hash_regs[2] = ®s->gaddr2;
|
|
|
|
priv->hash_regs[3] = ®s->gaddr3;
|
|
|
|
priv->hash_regs[4] = ®s->gaddr4;
|
|
|
|
priv->hash_regs[5] = ®s->gaddr5;
|
|
|
|
priv->hash_regs[6] = ®s->gaddr6;
|
|
|
|
priv->hash_regs[7] = ®s->gaddr7;
|
2005-06-20 15:54:21 +00:00
|
|
|
}
|
|
|
|
|
2008-12-16 23:29:15 +00:00
|
|
|
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_PADDING)
|
2005-06-20 15:54:21 +00:00
|
|
|
priv->padding = DEFAULT_PADDING;
|
|
|
|
else
|
|
|
|
priv->padding = 0;
|
|
|
|
|
2010-04-08 23:10:03 +00:00
|
|
|
if (dev->features & NETIF_F_IP_CSUM ||
|
2012-06-05 03:42:13 +00:00
|
|
|
priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER)
|
2012-05-21 23:00:48 +00:00
|
|
|
dev->needed_headroom = GMAC_FCB_LEN;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
/* Program the isrg regs only if number of grps > 1 */
|
|
|
|
if (priv->num_grps > 1) {
|
|
|
|
baddr = ®s->isrg0;
|
|
|
|
for (i = 0; i < priv->num_grps; i++) {
|
|
|
|
isrg |= (priv->gfargrp[i].rx_bit_map << ISRG_SHIFT_RX);
|
|
|
|
isrg |= (priv->gfargrp[i].tx_bit_map << ISRG_SHIFT_TX);
|
|
|
|
gfar_write(baddr, isrg);
|
|
|
|
baddr++;
|
|
|
|
isrg = 0x0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
/* Need to reverse the bit maps as bit_map's MSB is q0
|
2010-03-05 21:41:37 +00:00
|
|
|
* but, for_each_set_bit parses from right to left, which
|
2012-06-05 03:42:12 +00:00
|
|
|
* basically reverses the queue numbers
|
|
|
|
*/
|
2009-11-02 07:03:34 +00:00
|
|
|
for (i = 0; i< priv->num_grps; i++) {
|
2012-06-05 03:42:13 +00:00
|
|
|
priv->gfargrp[i].tx_bit_map =
|
|
|
|
reverse_bitmap(priv->gfargrp[i].tx_bit_map, MAX_TX_QS);
|
|
|
|
priv->gfargrp[i].rx_bit_map =
|
|
|
|
reverse_bitmap(priv->gfargrp[i].rx_bit_map, MAX_RX_QS);
|
2009-11-02 07:03:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Calculate RSTAT, TSTAT, RQUEUE and TQUEUE values,
|
2012-06-05 03:42:12 +00:00
|
|
|
* also assign queues to groups
|
|
|
|
*/
|
2009-11-02 07:03:34 +00:00
|
|
|
for (grp_idx = 0; grp_idx < priv->num_grps; grp_idx++) {
|
|
|
|
priv->gfargrp[grp_idx].num_rx_queues = 0x0;
|
2012-06-05 03:42:13 +00:00
|
|
|
|
2010-03-05 21:41:37 +00:00
|
|
|
for_each_set_bit(i, &priv->gfargrp[grp_idx].rx_bit_map,
|
2012-06-05 03:42:13 +00:00
|
|
|
priv->num_rx_queues) {
|
2009-11-02 07:03:34 +00:00
|
|
|
priv->gfargrp[grp_idx].num_rx_queues++;
|
|
|
|
priv->rx_queue[i]->grp = &priv->gfargrp[grp_idx];
|
|
|
|
rstat = rstat | (RSTAT_CLEAR_RHALT >> i);
|
|
|
|
rqueue = rqueue | ((RQUEUE_EN0 | RQUEUE_EX0) >> i);
|
|
|
|
}
|
|
|
|
priv->gfargrp[grp_idx].num_tx_queues = 0x0;
|
2012-06-05 03:42:13 +00:00
|
|
|
|
2010-03-05 21:41:37 +00:00
|
|
|
for_each_set_bit(i, &priv->gfargrp[grp_idx].tx_bit_map,
|
2012-06-05 03:42:13 +00:00
|
|
|
priv->num_tx_queues) {
|
2009-11-02 07:03:34 +00:00
|
|
|
priv->gfargrp[grp_idx].num_tx_queues++;
|
|
|
|
priv->tx_queue[i]->grp = &priv->gfargrp[grp_idx];
|
|
|
|
tstat = tstat | (TSTAT_CLEAR_THALT >> i);
|
|
|
|
tqueue = tqueue | (TQUEUE_EN0 >> i);
|
|
|
|
}
|
|
|
|
priv->gfargrp[grp_idx].rstat = rstat;
|
|
|
|
priv->gfargrp[grp_idx].tstat = tstat;
|
|
|
|
rstat = tstat =0;
|
2009-11-02 07:03:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
gfar_write(®s->rqueue, rqueue);
|
|
|
|
gfar_write(®s->tqueue, tqueue);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
priv->rx_buffer_size = DEFAULT_RX_BUFFER_SIZE;
|
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
/* Initializing some of the rx/tx queue level parameters */
|
2009-11-02 07:03:15 +00:00
|
|
|
for (i = 0; i < priv->num_tx_queues; i++) {
|
|
|
|
priv->tx_queue[i]->tx_ring_size = DEFAULT_TX_RING_SIZE;
|
|
|
|
priv->tx_queue[i]->num_txbdfree = DEFAULT_TX_RING_SIZE;
|
|
|
|
priv->tx_queue[i]->txcoalescing = DEFAULT_TX_COALESCE;
|
|
|
|
priv->tx_queue[i]->txic = DEFAULT_TXIC;
|
|
|
|
}
|
2009-11-02 07:03:00 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
for (i = 0; i < priv->num_rx_queues; i++) {
|
|
|
|
priv->rx_queue[i]->rx_ring_size = DEFAULT_RX_RING_SIZE;
|
|
|
|
priv->rx_queue[i]->rxcoalescing = DEFAULT_RX_COALESCE;
|
|
|
|
priv->rx_queue[i]->rxic = DEFAULT_RXIC;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* always enable rx filer */
|
2011-06-20 20:57:59 +00:00
|
|
|
priv->rx_filer_enable = 1;
|
2005-06-20 15:54:21 +00:00
|
|
|
/* Enable most messages by default */
|
|
|
|
priv->msg_enable = (NETIF_MSG_IFUP << 1 ) - 1;
|
2012-09-23 22:39:08 +00:00
|
|
|
/* use pritority h/w tx queue scheduling for single queue devices */
|
|
|
|
if (priv->num_tx_queues == 1)
|
|
|
|
priv->prio_sched_en = 1;
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2008-10-02 11:12:24 +00:00
|
|
|
/* Carrier starts down, phylib will bring it up */
|
|
|
|
netif_carrier_off(dev);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
err = register_netdev(dev);
|
|
|
|
|
|
|
|
if (err) {
|
2011-06-14 08:57:47 +00:00
|
|
|
pr_err("%s: Cannot register net device, aborting\n", dev->name);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto register_fail;
|
|
|
|
}
|
|
|
|
|
2009-02-01 08:52:34 +00:00
|
|
|
device_init_wakeup(&dev->dev,
|
2012-06-05 03:42:13 +00:00
|
|
|
priv->device_flags &
|
|
|
|
FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
|
2009-02-01 08:52:34 +00:00
|
|
|
|
2008-12-18 00:51:32 +00:00
|
|
|
/* fill out IRQ number and name fields */
|
2009-11-02 07:03:34 +00:00
|
|
|
for (i = 0; i < priv->num_grps; i++) {
|
|
|
|
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
|
2012-03-25 07:10:07 +00:00
|
|
|
sprintf(priv->gfargrp[i].int_name_tx, "%s%s%c%s",
|
|
|
|
dev->name, "_g", '0' + i, "_tx");
|
|
|
|
sprintf(priv->gfargrp[i].int_name_rx, "%s%s%c%s",
|
|
|
|
dev->name, "_g", '0' + i, "_rx");
|
|
|
|
sprintf(priv->gfargrp[i].int_name_er, "%s%s%c%s",
|
|
|
|
dev->name, "_g", '0' + i, "_er");
|
2009-11-02 07:03:34 +00:00
|
|
|
} else
|
2012-03-25 07:10:07 +00:00
|
|
|
strcpy(priv->gfargrp[i].int_name_tx, dev->name);
|
2009-11-02 07:03:34 +00:00
|
|
|
}
|
2008-12-18 00:51:32 +00:00
|
|
|
|
2009-11-02 07:03:40 +00:00
|
|
|
/* Initialize the filer table */
|
|
|
|
gfar_init_filer_table(priv);
|
|
|
|
|
2005-11-11 18:38:59 +00:00
|
|
|
/* Create all the sysfs files */
|
|
|
|
gfar_init_sysfs(dev);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Print out the device info */
|
2011-06-14 08:57:47 +00:00
|
|
|
netdev_info(dev, "mac: %pM\n", dev->dev_addr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* Even more device info helps when determining which kernel
|
|
|
|
* provided which set of benchmarks.
|
|
|
|
*/
|
2011-06-14 08:57:47 +00:00
|
|
|
netdev_info(dev, "Running with NAPI enabled\n");
|
2009-11-02 07:03:15 +00:00
|
|
|
for (i = 0; i < priv->num_rx_queues; i++)
|
2011-06-14 08:57:47 +00:00
|
|
|
netdev_info(dev, "RX BD ring size for Q[%d]: %d\n",
|
|
|
|
i, priv->rx_queue[i]->rx_ring_size);
|
2012-06-05 03:42:13 +00:00
|
|
|
for (i = 0; i < priv->num_tx_queues; i++)
|
2011-06-14 08:57:47 +00:00
|
|
|
netdev_info(dev, "TX BD ring size for Q[%d]: %d\n",
|
|
|
|
i, priv->tx_queue[i]->tx_ring_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
register_fail:
|
2009-11-02 07:03:34 +00:00
|
|
|
unmap_group_regs(priv);
|
2009-11-02 07:03:15 +00:00
|
|
|
free_tx_pointers(priv);
|
|
|
|
free_rx_pointers(priv);
|
2009-04-25 12:53:12 +00:00
|
|
|
if (priv->phy_node)
|
|
|
|
of_node_put(priv->phy_node);
|
|
|
|
if (priv->tbi_node)
|
|
|
|
of_node_put(priv->tbi_node);
|
2005-04-16 22:20:36 +00:00
|
|
|
free_netdev(dev);
|
2005-09-24 02:54:21 +00:00
|
|
|
return err;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-08-06 15:25:50 +00:00
|
|
|
static int gfar_remove(struct platform_device *ofdev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-12-16 23:29:15 +00:00
|
|
|
struct gfar_private *priv = dev_get_drvdata(&ofdev->dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-25 12:53:12 +00:00
|
|
|
if (priv->phy_node)
|
|
|
|
of_node_put(priv->phy_node);
|
|
|
|
if (priv->tbi_node)
|
|
|
|
of_node_put(priv->tbi_node);
|
|
|
|
|
2008-12-16 23:29:15 +00:00
|
|
|
dev_set_drvdata(&ofdev->dev, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-09-06 08:41:02 +00:00
|
|
|
unregister_netdev(priv->ndev);
|
2009-11-02 07:03:34 +00:00
|
|
|
unmap_group_regs(priv);
|
2009-03-19 06:28:22 +00:00
|
|
|
free_netdev(priv->ndev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-11 23:04:45 +00:00
|
|
|
#ifdef CONFIG_PM
|
2009-10-12 06:00:42 +00:00
|
|
|
|
|
|
|
static int gfar_suspend(struct device *dev)
|
2008-07-11 23:04:45 +00:00
|
|
|
{
|
2009-10-12 06:00:42 +00:00
|
|
|
struct gfar_private *priv = dev_get_drvdata(dev);
|
|
|
|
struct net_device *ndev = priv->ndev;
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = priv->gfargrp[0].regs;
|
2008-07-11 23:04:45 +00:00
|
|
|
unsigned long flags;
|
|
|
|
u32 tempval;
|
|
|
|
|
|
|
|
int magic_packet = priv->wol_en &&
|
2012-06-05 03:42:13 +00:00
|
|
|
(priv->device_flags &
|
|
|
|
FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
2009-10-12 06:00:42 +00:00
|
|
|
netif_device_detach(ndev);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
2009-10-12 06:00:42 +00:00
|
|
|
if (netif_running(ndev)) {
|
2009-11-02 07:03:15 +00:00
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
lock_tx_qs(priv);
|
|
|
|
lock_rx_qs(priv);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
2009-10-12 06:00:42 +00:00
|
|
|
gfar_halt_nodisable(ndev);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
|
|
|
/* Disable Tx, and Rx if wake-on-LAN is disabled. */
|
2009-11-02 07:03:09 +00:00
|
|
|
tempval = gfar_read(®s->maccfg1);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
|
|
|
tempval &= ~MACCFG1_TX_EN;
|
|
|
|
|
|
|
|
if (!magic_packet)
|
|
|
|
tempval &= ~MACCFG1_RX_EN;
|
|
|
|
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->maccfg1, tempval);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
unlock_rx_qs(priv);
|
|
|
|
unlock_tx_qs(priv);
|
|
|
|
local_irq_restore(flags);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
disable_napi(priv);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
|
|
|
if (magic_packet) {
|
|
|
|
/* Enable interrupt on Magic Packet */
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->imask, IMASK_MAG);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
|
|
|
/* Enable Magic Packet mode */
|
2009-11-02 07:03:09 +00:00
|
|
|
tempval = gfar_read(®s->maccfg2);
|
2008-07-11 23:04:45 +00:00
|
|
|
tempval |= MACCFG2_MPEN;
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->maccfg2, tempval);
|
2008-07-11 23:04:45 +00:00
|
|
|
} else {
|
|
|
|
phy_stop(priv->phydev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-12 06:00:42 +00:00
|
|
|
static int gfar_resume(struct device *dev)
|
2008-07-11 23:04:45 +00:00
|
|
|
{
|
2009-10-12 06:00:42 +00:00
|
|
|
struct gfar_private *priv = dev_get_drvdata(dev);
|
|
|
|
struct net_device *ndev = priv->ndev;
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = priv->gfargrp[0].regs;
|
2008-07-11 23:04:45 +00:00
|
|
|
unsigned long flags;
|
|
|
|
u32 tempval;
|
|
|
|
int magic_packet = priv->wol_en &&
|
2012-06-05 03:42:13 +00:00
|
|
|
(priv->device_flags &
|
|
|
|
FSL_GIANFAR_DEV_HAS_MAGIC_PACKET);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
2009-10-12 06:00:42 +00:00
|
|
|
if (!netif_running(ndev)) {
|
|
|
|
netif_device_attach(ndev);
|
2008-07-11 23:04:45 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!magic_packet && priv->phydev)
|
|
|
|
phy_start(priv->phydev);
|
|
|
|
|
|
|
|
/* Disable Magic Packet mode, in case something
|
|
|
|
* else woke us up.
|
|
|
|
*/
|
2009-11-02 07:03:15 +00:00
|
|
|
local_irq_save(flags);
|
|
|
|
lock_tx_qs(priv);
|
|
|
|
lock_rx_qs(priv);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
2009-11-02 07:03:09 +00:00
|
|
|
tempval = gfar_read(®s->maccfg2);
|
2008-07-11 23:04:45 +00:00
|
|
|
tempval &= ~MACCFG2_MPEN;
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->maccfg2, tempval);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
2009-10-12 06:00:42 +00:00
|
|
|
gfar_start(ndev);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
unlock_rx_qs(priv);
|
|
|
|
unlock_tx_qs(priv);
|
|
|
|
local_irq_restore(flags);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
2009-10-12 06:00:42 +00:00
|
|
|
netif_device_attach(ndev);
|
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
enable_napi(priv);
|
2009-10-12 06:00:42 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gfar_restore(struct device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = dev_get_drvdata(dev);
|
|
|
|
struct net_device *ndev = priv->ndev;
|
|
|
|
|
2012-11-09 04:43:51 +00:00
|
|
|
if (!netif_running(ndev)) {
|
|
|
|
netif_device_attach(ndev);
|
|
|
|
|
2009-10-12 06:00:42 +00:00
|
|
|
return 0;
|
2012-11-09 04:43:51 +00:00
|
|
|
}
|
2009-10-12 06:00:42 +00:00
|
|
|
|
2012-11-08 22:11:41 +00:00
|
|
|
if (gfar_init_bds(ndev)) {
|
|
|
|
free_skb_resources(priv);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2009-10-12 06:00:42 +00:00
|
|
|
init_registers(ndev);
|
|
|
|
gfar_set_mac_address(ndev);
|
|
|
|
gfar_init_mac(ndev);
|
|
|
|
gfar_start(ndev);
|
|
|
|
|
|
|
|
priv->oldlink = 0;
|
|
|
|
priv->oldspeed = 0;
|
|
|
|
priv->oldduplex = -1;
|
|
|
|
|
|
|
|
if (priv->phydev)
|
|
|
|
phy_start(priv->phydev);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
2009-10-12 06:00:42 +00:00
|
|
|
netif_device_attach(ndev);
|
2009-11-10 14:11:05 +00:00
|
|
|
enable_napi(priv);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2009-10-12 06:00:42 +00:00
|
|
|
|
|
|
|
static struct dev_pm_ops gfar_pm_ops = {
|
|
|
|
.suspend = gfar_suspend,
|
|
|
|
.resume = gfar_resume,
|
|
|
|
.freeze = gfar_suspend,
|
|
|
|
.thaw = gfar_resume,
|
|
|
|
.restore = gfar_restore,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define GFAR_PM_OPS (&gfar_pm_ops)
|
|
|
|
|
2008-07-11 23:04:45 +00:00
|
|
|
#else
|
2009-10-12 06:00:42 +00:00
|
|
|
|
|
|
|
#define GFAR_PM_OPS NULL
|
|
|
|
|
2008-07-11 23:04:45 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-01 18:01:06 +00:00
|
|
|
/* Reads the controller's registers to determine what interface
|
|
|
|
* connects it to the PHY.
|
|
|
|
*/
|
|
|
|
static phy_interface_t gfar_get_interface(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = priv->gfargrp[0].regs;
|
2009-11-02 07:03:09 +00:00
|
|
|
u32 ecntrl;
|
|
|
|
|
|
|
|
ecntrl = gfar_read(®s->ecntrl);
|
2006-12-01 18:01:06 +00:00
|
|
|
|
|
|
|
if (ecntrl & ECNTRL_SGMII_MODE)
|
|
|
|
return PHY_INTERFACE_MODE_SGMII;
|
|
|
|
|
|
|
|
if (ecntrl & ECNTRL_TBI_MODE) {
|
|
|
|
if (ecntrl & ECNTRL_REDUCED_MODE)
|
|
|
|
return PHY_INTERFACE_MODE_RTBI;
|
|
|
|
else
|
|
|
|
return PHY_INTERFACE_MODE_TBI;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ecntrl & ECNTRL_REDUCED_MODE) {
|
2012-06-05 03:42:13 +00:00
|
|
|
if (ecntrl & ECNTRL_REDUCED_MII_MODE) {
|
2006-12-01 18:01:06 +00:00
|
|
|
return PHY_INTERFACE_MODE_RMII;
|
2012-06-05 03:42:13 +00:00
|
|
|
}
|
2007-07-11 16:43:07 +00:00
|
|
|
else {
|
2008-12-16 23:29:15 +00:00
|
|
|
phy_interface_t interface = priv->interface;
|
2007-07-11 16:43:07 +00:00
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* This isn't autodetected right now, so it must
|
2007-07-11 16:43:07 +00:00
|
|
|
* be set by the device tree or platform code.
|
|
|
|
*/
|
|
|
|
if (interface == PHY_INTERFACE_MODE_RGMII_ID)
|
|
|
|
return PHY_INTERFACE_MODE_RGMII_ID;
|
|
|
|
|
2006-12-01 18:01:06 +00:00
|
|
|
return PHY_INTERFACE_MODE_RGMII;
|
2007-07-11 16:43:07 +00:00
|
|
|
}
|
2006-12-01 18:01:06 +00:00
|
|
|
}
|
|
|
|
|
2008-12-16 23:29:15 +00:00
|
|
|
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_GIGABIT)
|
2006-12-01 18:01:06 +00:00
|
|
|
return PHY_INTERFACE_MODE_GMII;
|
|
|
|
|
|
|
|
return PHY_INTERFACE_MODE_MII;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-09-24 02:54:21 +00:00
|
|
|
/* Initializes driver's PHY state, and attaches to the PHY.
|
|
|
|
* Returns 0 on success.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
static int init_phy(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2005-09-24 02:54:21 +00:00
|
|
|
uint gigabit_support =
|
2008-12-16 23:29:15 +00:00
|
|
|
priv->device_flags & FSL_GIANFAR_DEV_HAS_GIGABIT ?
|
2005-09-24 02:54:21 +00:00
|
|
|
SUPPORTED_1000baseT_Full : 0;
|
2006-12-01 18:01:06 +00:00
|
|
|
phy_interface_t interface;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
priv->oldlink = 0;
|
|
|
|
priv->oldspeed = 0;
|
|
|
|
priv->oldduplex = -1;
|
|
|
|
|
2006-12-01 18:01:06 +00:00
|
|
|
interface = gfar_get_interface(dev);
|
|
|
|
|
2009-07-16 21:31:42 +00:00
|
|
|
priv->phydev = of_phy_connect(dev, priv->phy_node, &adjust_link, 0,
|
|
|
|
interface);
|
|
|
|
if (!priv->phydev)
|
|
|
|
priv->phydev = of_phy_connect_fixed_link(dev, &adjust_link,
|
|
|
|
interface);
|
|
|
|
if (!priv->phydev) {
|
|
|
|
dev_err(&dev->dev, "could not attach to PHY\n");
|
|
|
|
return -ENODEV;
|
2009-04-25 12:53:12 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-11 23:25:11 +00:00
|
|
|
if (interface == PHY_INTERFACE_MODE_SGMII)
|
|
|
|
gfar_configure_serdes(dev);
|
|
|
|
|
2005-09-24 02:54:21 +00:00
|
|
|
/* Remove any features not supported by the controller */
|
2009-04-25 12:53:12 +00:00
|
|
|
priv->phydev->supported &= (GFAR_SUPPORTED | gigabit_support);
|
|
|
|
priv->phydev->advertising = priv->phydev->supported;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* Initialize TBI PHY interface for communicating with the
|
2008-04-17 04:08:10 +00:00
|
|
|
* SERDES lynx PHY on the chip. We communicate with this PHY
|
|
|
|
* through the MDIO bus on each controller, treating it as a
|
|
|
|
* "normal" PHY at the address found in the TBIPA register. We assume
|
|
|
|
* that the TBIPA register is valid. Either the MDIO bus code will set
|
|
|
|
* it to a value that doesn't conflict with other PHYs on the bus, or the
|
|
|
|
* value doesn't matter, as there are no other PHYs on the bus.
|
|
|
|
*/
|
2007-05-11 23:25:11 +00:00
|
|
|
static void gfar_configure_serdes(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-04-25 12:53:12 +00:00
|
|
|
struct phy_device *tbiphy;
|
|
|
|
|
|
|
|
if (!priv->tbi_node) {
|
|
|
|
dev_warn(&dev->dev, "error: SGMII mode requires that the "
|
|
|
|
"device tree specify a tbi-handle\n");
|
|
|
|
return;
|
|
|
|
}
|
gianfar: Fix race in TBI/SerDes configuration
The init_phy() function attaches to the PHY, then configures the
SerDes<->TBI link (in SGMII mode). The TBI is on the MDIO bus with the PHY
(sort of) and is accessed via the gianfar's MDIO registers, using the
functions gfar_local_mdio_read/write(), which don't do any locking.
The previously attached PHY will start a work-queue on a timer, and
probably an irq handler as well, which will talk to the PHY and thus use
the MDIO bus. This uses phy_read/write(), which have locking, but not
against the gfar_local_mdio versions.
The result is that PHY code will try to use the MDIO bus at the same time
as the SerDes setup code, corrupting the transfers.
Setting up the SerDes before attaching to the PHY will insure that there is
no race between the SerDes code and *our* PHY, but doesn't fix everything.
Typically the PHYs for all gianfar devices are on the same MDIO bus, which
is associated with the first gianfar device. This means that the first
gianfar's SerDes code could corrupt the MDIO transfers for a different
gianfar's PHY.
The lock used by phy_read/write() is contained in the mii_bus structure,
which is pointed to by the PHY. This is difficult to access from the
gianfar drivers, as there is no link between a gianfar device and the
mii_bus which shares the same MDIO registers. As far as the device layer
and drivers are concerned they are two unrelated devices (which happen to
share registers).
Generally all gianfar devices' PHYs will be on the bus associated with the
first gianfar. But this might not be the case, so simply locking the
gianfar's PHY's mii bus might not lock the mii bus that the SerDes setup
code is going to use.
We solve this by having the code that creates the gianfar platform device
look in the device tree for an mdio device that shares the gianfar's
registers. If one is found the ID of its platform device is saved in the
gianfar's platform data.
A new function in the gianfar mii code, gfar_get_miibus(), can use the bus
ID to search through the platform devices for a gianfar_mdio device with
the right ID. The platform device's driver data is the mii_bus structure,
which the SerDes setup code can use to lock the current bus.
Signed-off-by: Trent Piepho <tpiepho@freescale.com>
CC: Andy Fleming <afleming@freescale.com>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2008-10-31 01:17:06 +00:00
|
|
|
|
2009-04-25 12:53:12 +00:00
|
|
|
tbiphy = of_phy_find_device(priv->tbi_node);
|
|
|
|
if (!tbiphy) {
|
|
|
|
dev_err(&dev->dev, "error: Could not get TBI device\n");
|
2008-12-16 23:29:15 +00:00
|
|
|
return;
|
|
|
|
}
|
2007-05-11 23:25:11 +00:00
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* If the link is already up, we must already be ok, and don't need to
|
2008-10-31 01:17:07 +00:00
|
|
|
* configure and reset the TBI<->SerDes link. Maybe U-Boot configured
|
|
|
|
* everything for us? Resetting it takes the link down and requires
|
|
|
|
* several seconds for it to come back.
|
|
|
|
*/
|
2009-04-25 12:53:12 +00:00
|
|
|
if (phy_read(tbiphy, MII_BMSR) & BMSR_LSTATUS)
|
2008-12-16 23:29:15 +00:00
|
|
|
return;
|
2007-05-11 23:25:11 +00:00
|
|
|
|
2008-04-17 04:08:10 +00:00
|
|
|
/* Single clk mode, mii mode off(for serdes communication) */
|
2009-04-25 12:53:12 +00:00
|
|
|
phy_write(tbiphy, MII_TBICON, TBICON_CLK_SELECT);
|
2007-05-11 23:25:11 +00:00
|
|
|
|
2009-04-25 12:53:12 +00:00
|
|
|
phy_write(tbiphy, MII_ADVERTISE,
|
2012-06-05 03:42:13 +00:00
|
|
|
ADVERTISE_1000XFULL | ADVERTISE_1000XPAUSE |
|
|
|
|
ADVERTISE_1000XPSE_ASYM);
|
2007-05-11 23:25:11 +00:00
|
|
|
|
2012-06-05 03:42:13 +00:00
|
|
|
phy_write(tbiphy, MII_BMCR,
|
|
|
|
BMCR_ANENABLE | BMCR_ANRESTART | BMCR_FULLDPLX |
|
|
|
|
BMCR_SPEED1000);
|
2007-05-11 23:25:11 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static void init_registers(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-11-02 07:03:09 +00:00
|
|
|
struct gfar __iomem *regs = NULL;
|
2012-06-05 03:42:14 +00:00
|
|
|
int i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
for (i = 0; i < priv->num_grps; i++) {
|
|
|
|
regs = priv->gfargrp[i].regs;
|
|
|
|
/* Clear IEVENT */
|
|
|
|
gfar_write(®s->ievent, IEVENT_INIT_CLEAR);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
/* Initialize IMASK */
|
|
|
|
gfar_write(®s->imask, IMASK_INIT_CLEAR);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
regs = priv->gfargrp[0].regs;
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Init hash registers to zero */
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->igaddr0, 0);
|
|
|
|
gfar_write(®s->igaddr1, 0);
|
|
|
|
gfar_write(®s->igaddr2, 0);
|
|
|
|
gfar_write(®s->igaddr3, 0);
|
|
|
|
gfar_write(®s->igaddr4, 0);
|
|
|
|
gfar_write(®s->igaddr5, 0);
|
|
|
|
gfar_write(®s->igaddr6, 0);
|
|
|
|
gfar_write(®s->igaddr7, 0);
|
|
|
|
|
|
|
|
gfar_write(®s->gaddr0, 0);
|
|
|
|
gfar_write(®s->gaddr1, 0);
|
|
|
|
gfar_write(®s->gaddr2, 0);
|
|
|
|
gfar_write(®s->gaddr3, 0);
|
|
|
|
gfar_write(®s->gaddr4, 0);
|
|
|
|
gfar_write(®s->gaddr5, 0);
|
|
|
|
gfar_write(®s->gaddr6, 0);
|
|
|
|
gfar_write(®s->gaddr7, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Zero out the rmon mib registers if it has them */
|
2008-12-16 23:29:15 +00:00
|
|
|
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
|
2009-11-02 07:03:09 +00:00
|
|
|
memset_io(&(regs->rmon), 0, sizeof (struct rmon_mib));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Mask off the CAM interrupts */
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->rmon.cam1, 0xffffffff);
|
|
|
|
gfar_write(®s->rmon.cam2, 0xffffffff);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize the max receive buffer length */
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->mrblr, priv->rx_buffer_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Initialize the Minimum Frame Length Register */
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->minflr, MINFLR_INIT_SETTINGS);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-06-30 06:39:15 +00:00
|
|
|
static int __gfar_is_rx_idle(struct gfar_private *priv)
|
|
|
|
{
|
|
|
|
u32 res;
|
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* Normaly TSEC should not hang on GRS commands, so we should
|
2010-06-30 06:39:15 +00:00
|
|
|
* actually wait for IEVENT_GRSC flag.
|
|
|
|
*/
|
|
|
|
if (likely(!gfar_has_errata(priv, GFAR_ERRATA_A002)))
|
|
|
|
return 0;
|
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* Read the eTSEC register at offset 0xD1C. If bits 7-14 are
|
2010-06-30 06:39:15 +00:00
|
|
|
* the same as bits 23-30, the eTSEC Rx is assumed to be idle
|
|
|
|
* and the Rx can be safely reset.
|
|
|
|
*/
|
|
|
|
res = gfar_read((void __iomem *)priv->gfargrp[0].regs + 0xd1c);
|
|
|
|
res &= 0x7f807f80;
|
|
|
|
if ((res & 0xffff) == (res >> 16))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2005-06-20 15:54:21 +00:00
|
|
|
|
|
|
|
/* Halt the receive and transmit queues */
|
2008-07-11 23:04:45 +00:00
|
|
|
static void gfar_halt_nodisable(struct net_device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
u32 tempval;
|
2012-06-05 03:42:14 +00:00
|
|
|
int i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
for (i = 0; i < priv->num_grps; i++) {
|
|
|
|
regs = priv->gfargrp[i].regs;
|
|
|
|
/* Mask all interrupts */
|
|
|
|
gfar_write(®s->imask, IMASK_INIT_CLEAR);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
/* Clear all interrupts */
|
|
|
|
gfar_write(®s->ievent, IEVENT_INIT_CLEAR);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
regs = priv->gfargrp[0].regs;
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Stop the DMA, and wait for it to stop */
|
2009-11-02 07:03:09 +00:00
|
|
|
tempval = gfar_read(®s->dmactrl);
|
2012-06-05 03:42:13 +00:00
|
|
|
if ((tempval & (DMACTRL_GRS | DMACTRL_GTS)) !=
|
|
|
|
(DMACTRL_GRS | DMACTRL_GTS)) {
|
2010-06-30 06:39:15 +00:00
|
|
|
int ret;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
tempval |= (DMACTRL_GRS | DMACTRL_GTS);
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->dmactrl, tempval);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-06-30 06:39:15 +00:00
|
|
|
do {
|
|
|
|
ret = spin_event_timeout(((gfar_read(®s->ievent) &
|
|
|
|
(IEVENT_GRSC | IEVENT_GTSC)) ==
|
|
|
|
(IEVENT_GRSC | IEVENT_GTSC)), 1000000, 0);
|
|
|
|
if (!ret && !(gfar_read(®s->ievent) & IEVENT_GRSC))
|
|
|
|
ret = __gfar_is_rx_idle(priv);
|
|
|
|
} while (!ret);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-07-11 23:04:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Halt the receive and transmit queues */
|
|
|
|
void gfar_halt(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = priv->gfargrp[0].regs;
|
2008-07-11 23:04:45 +00:00
|
|
|
u32 tempval;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-12 20:10:46 +00:00
|
|
|
gfar_halt_nodisable(dev);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Disable Rx and Tx */
|
|
|
|
tempval = gfar_read(®s->maccfg1);
|
|
|
|
tempval &= ~(MACCFG1_RX_EN | MACCFG1_TX_EN);
|
|
|
|
gfar_write(®s->maccfg1, tempval);
|
2005-06-20 15:54:21 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
static void free_grp_irqs(struct gfar_priv_grp *grp)
|
|
|
|
{
|
|
|
|
free_irq(grp->interruptError, grp);
|
|
|
|
free_irq(grp->interruptTransmit, grp);
|
|
|
|
free_irq(grp->interruptReceive, grp);
|
|
|
|
}
|
|
|
|
|
2005-06-20 15:54:21 +00:00
|
|
|
void stop_gfar(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
|
|
|
unsigned long flags;
|
2009-11-02 07:03:34 +00:00
|
|
|
int i;
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2005-09-24 02:54:21 +00:00
|
|
|
phy_stop(priv->phydev);
|
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
|
2005-06-20 15:54:21 +00:00
|
|
|
/* Lock it down */
|
2009-11-02 07:03:15 +00:00
|
|
|
local_irq_save(flags);
|
|
|
|
lock_tx_qs(priv);
|
|
|
|
lock_rx_qs(priv);
|
2005-06-20 15:54:21 +00:00
|
|
|
|
|
|
|
gfar_halt(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
unlock_rx_qs(priv);
|
|
|
|
unlock_tx_qs(priv);
|
|
|
|
local_irq_restore(flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Free the IRQs */
|
2008-12-16 23:29:15 +00:00
|
|
|
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
|
2009-11-02 07:03:34 +00:00
|
|
|
for (i = 0; i < priv->num_grps; i++)
|
|
|
|
free_grp_irqs(&priv->gfargrp[i]);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
2009-11-02 07:03:34 +00:00
|
|
|
for (i = 0; i < priv->num_grps; i++)
|
|
|
|
free_irq(priv->gfargrp[i].interruptTransmit,
|
2012-06-05 03:42:13 +00:00
|
|
|
&priv->gfargrp[i]);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
free_skb_resources(priv);
|
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
static void free_skb_tx_queue(struct gfar_priv_tx_q *tx_queue)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct txbd8 *txbdp;
|
2009-11-02 07:03:15 +00:00
|
|
|
struct gfar_private *priv = netdev_priv(tx_queue->dev);
|
2008-12-18 00:51:04 +00:00
|
|
|
int i, j;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
txbdp = tx_queue->tx_bd_base;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
for (i = 0; i < tx_queue->tx_ring_size; i++) {
|
|
|
|
if (!tx_queue->tx_skbuff[i])
|
2008-12-18 00:51:04 +00:00
|
|
|
continue;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-19 06:28:22 +00:00
|
|
|
dma_unmap_single(&priv->ofdev->dev, txbdp->bufPtr,
|
2012-06-05 03:42:13 +00:00
|
|
|
txbdp->length, DMA_TO_DEVICE);
|
2008-12-18 00:51:04 +00:00
|
|
|
txbdp->lstatus = 0;
|
2009-11-02 07:03:15 +00:00
|
|
|
for (j = 0; j < skb_shinfo(tx_queue->tx_skbuff[i])->nr_frags;
|
2012-06-05 03:42:13 +00:00
|
|
|
j++) {
|
2008-12-18 00:51:04 +00:00
|
|
|
txbdp++;
|
2009-03-19 06:28:22 +00:00
|
|
|
dma_unmap_page(&priv->ofdev->dev, txbdp->bufPtr,
|
2012-06-05 03:42:13 +00:00
|
|
|
txbdp->length, DMA_TO_DEVICE);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-05-07 18:20:55 +00:00
|
|
|
txbdp++;
|
2009-11-02 07:03:00 +00:00
|
|
|
dev_kfree_skb_any(tx_queue->tx_skbuff[i]);
|
|
|
|
tx_queue->tx_skbuff[i] = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-11-02 07:03:00 +00:00
|
|
|
kfree(tx_queue->tx_skbuff);
|
2012-11-08 22:11:41 +00:00
|
|
|
tx_queue->tx_skbuff = NULL;
|
2009-11-02 07:03:15 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
static void free_skb_rx_queue(struct gfar_priv_rx_q *rx_queue)
|
|
|
|
{
|
|
|
|
struct rxbd8 *rxbdp;
|
|
|
|
struct gfar_private *priv = netdev_priv(rx_queue->dev);
|
|
|
|
int i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
rxbdp = rx_queue->rx_bd_base;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
for (i = 0; i < rx_queue->rx_ring_size; i++) {
|
|
|
|
if (rx_queue->rx_skbuff[i]) {
|
2009-11-02 07:03:15 +00:00
|
|
|
dma_unmap_single(&priv->ofdev->dev,
|
2012-06-05 03:42:13 +00:00
|
|
|
rxbdp->bufPtr, priv->rx_buffer_size,
|
|
|
|
DMA_FROM_DEVICE);
|
2009-11-02 07:03:00 +00:00
|
|
|
dev_kfree_skb_any(rx_queue->rx_skbuff[i]);
|
|
|
|
rx_queue->rx_skbuff[i] = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-10-12 06:00:30 +00:00
|
|
|
rxbdp->lstatus = 0;
|
|
|
|
rxbdp->bufPtr = 0;
|
|
|
|
rxbdp++;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-11-02 07:03:00 +00:00
|
|
|
kfree(rx_queue->rx_skbuff);
|
2012-11-08 22:11:41 +00:00
|
|
|
rx_queue->rx_skbuff = NULL;
|
2009-11-02 07:03:15 +00:00
|
|
|
}
|
2009-10-12 06:00:30 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
/* If there are any tx skbs or rx skbs still around, free them.
|
2012-06-05 03:42:12 +00:00
|
|
|
* Then free tx_skbuff and rx_skbuff
|
|
|
|
*/
|
2009-11-02 07:03:15 +00:00
|
|
|
static void free_skb_resources(struct gfar_private *priv)
|
|
|
|
{
|
|
|
|
struct gfar_priv_tx_q *tx_queue = NULL;
|
|
|
|
struct gfar_priv_rx_q *rx_queue = NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Go through all the buffer descriptors and free their data buffers */
|
|
|
|
for (i = 0; i < priv->num_tx_queues; i++) {
|
2012-01-06 18:51:03 +00:00
|
|
|
struct netdev_queue *txq;
|
2012-06-05 03:42:13 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
tx_queue = priv->tx_queue[i];
|
2012-01-06 18:51:03 +00:00
|
|
|
txq = netdev_get_tx_queue(tx_queue->dev, tx_queue->qindex);
|
2012-06-05 03:42:13 +00:00
|
|
|
if (tx_queue->tx_skbuff)
|
2009-11-02 07:03:15 +00:00
|
|
|
free_skb_tx_queue(tx_queue);
|
2012-01-06 18:51:03 +00:00
|
|
|
netdev_tx_reset_queue(txq);
|
2009-11-02 07:03:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < priv->num_rx_queues; i++) {
|
|
|
|
rx_queue = priv->rx_queue[i];
|
2012-06-05 03:42:13 +00:00
|
|
|
if (rx_queue->rx_skbuff)
|
2009-11-02 07:03:15 +00:00
|
|
|
free_skb_rx_queue(rx_queue);
|
|
|
|
}
|
|
|
|
|
|
|
|
dma_free_coherent(&priv->ofdev->dev,
|
2012-06-05 03:42:13 +00:00
|
|
|
sizeof(struct txbd8) * priv->total_tx_ring_size +
|
|
|
|
sizeof(struct rxbd8) * priv->total_rx_ring_size,
|
|
|
|
priv->tx_queue[0]->tx_bd_base,
|
|
|
|
priv->tx_queue[0]->tx_bd_dma_base);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-06-20 15:54:21 +00:00
|
|
|
void gfar_start(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = priv->gfargrp[0].regs;
|
2005-06-20 15:54:21 +00:00
|
|
|
u32 tempval;
|
2009-11-02 07:03:34 +00:00
|
|
|
int i = 0;
|
2005-06-20 15:54:21 +00:00
|
|
|
|
|
|
|
/* Enable Rx and Tx in MACCFG1 */
|
|
|
|
tempval = gfar_read(®s->maccfg1);
|
|
|
|
tempval |= (MACCFG1_RX_EN | MACCFG1_TX_EN);
|
|
|
|
gfar_write(®s->maccfg1, tempval);
|
|
|
|
|
|
|
|
/* Initialize DMACTRL to have WWR and WOP */
|
2009-11-02 07:03:09 +00:00
|
|
|
tempval = gfar_read(®s->dmactrl);
|
2005-06-20 15:54:21 +00:00
|
|
|
tempval |= DMACTRL_INIT_SETTINGS;
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->dmactrl, tempval);
|
2005-06-20 15:54:21 +00:00
|
|
|
|
|
|
|
/* Make sure we aren't stopped */
|
2009-11-02 07:03:09 +00:00
|
|
|
tempval = gfar_read(®s->dmactrl);
|
2005-06-20 15:54:21 +00:00
|
|
|
tempval &= ~(DMACTRL_GRS | DMACTRL_GTS);
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->dmactrl, tempval);
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
for (i = 0; i < priv->num_grps; i++) {
|
|
|
|
regs = priv->gfargrp[i].regs;
|
|
|
|
/* Clear THLT/RHLT, so that the DMA starts polling now */
|
|
|
|
gfar_write(®s->tstat, priv->gfargrp[i].tstat);
|
|
|
|
gfar_write(®s->rstat, priv->gfargrp[i].rstat);
|
|
|
|
/* Unmask the interrupts we look for */
|
|
|
|
gfar_write(®s->imask, IMASK_DEFAULT);
|
|
|
|
}
|
2008-12-16 23:30:20 +00:00
|
|
|
|
2010-05-10 12:01:31 +00:00
|
|
|
dev->trans_start = jiffies; /* prevent tx timeout */
|
2005-06-20 15:54:21 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
void gfar_configure_coalescing(struct gfar_private *priv,
|
2012-06-05 03:42:13 +00:00
|
|
|
unsigned long tx_mask, unsigned long rx_mask)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = priv->gfargrp[0].regs;
|
2009-11-04 12:53:00 +00:00
|
|
|
u32 __iomem *baddr;
|
2009-11-02 07:03:34 +00:00
|
|
|
int i = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
/* Backward compatible case ---- even if we enable
|
|
|
|
* multiple queues, there's only single reg to program
|
|
|
|
*/
|
|
|
|
gfar_write(®s->txic, 0);
|
2012-06-05 03:42:13 +00:00
|
|
|
if (likely(priv->tx_queue[0]->txcoalescing))
|
2009-11-02 07:03:34 +00:00
|
|
|
gfar_write(®s->txic, priv->tx_queue[0]->txic);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
gfar_write(®s->rxic, 0);
|
2012-06-05 03:42:13 +00:00
|
|
|
if (unlikely(priv->rx_queue[0]->rxcoalescing))
|
2009-11-02 07:03:34 +00:00
|
|
|
gfar_write(®s->rxic, priv->rx_queue[0]->rxic);
|
2008-04-22 22:18:29 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
if (priv->mode == MQ_MG_MODE) {
|
|
|
|
baddr = ®s->txic0;
|
2010-03-05 21:41:37 +00:00
|
|
|
for_each_set_bit(i, &tx_mask, priv->num_tx_queues) {
|
2012-06-28 04:40:53 +00:00
|
|
|
gfar_write(baddr + i, 0);
|
|
|
|
if (likely(priv->tx_queue[i]->txcoalescing))
|
2009-11-02 07:03:34 +00:00
|
|
|
gfar_write(baddr + i, priv->tx_queue[i]->txic);
|
|
|
|
}
|
|
|
|
|
|
|
|
baddr = ®s->rxic0;
|
2010-03-05 21:41:37 +00:00
|
|
|
for_each_set_bit(i, &rx_mask, priv->num_rx_queues) {
|
2012-06-28 04:40:53 +00:00
|
|
|
gfar_write(baddr + i, 0);
|
|
|
|
if (likely(priv->rx_queue[i]->rxcoalescing))
|
2009-11-02 07:03:34 +00:00
|
|
|
gfar_write(baddr + i, priv->rx_queue[i]->rxic);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int register_grp_irqs(struct gfar_priv_grp *grp)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = grp->priv;
|
|
|
|
struct net_device *dev = priv->ndev;
|
|
|
|
int err;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* If the device has multiple interrupts, register for
|
2012-06-05 03:42:12 +00:00
|
|
|
* them. Otherwise, only register for the one
|
|
|
|
*/
|
2008-12-16 23:29:15 +00:00
|
|
|
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
|
2005-06-20 15:54:21 +00:00
|
|
|
/* Install our interrupt handlers for Error,
|
2012-06-05 03:42:12 +00:00
|
|
|
* Transmit, and Receive
|
|
|
|
*/
|
2012-06-05 03:42:13 +00:00
|
|
|
if ((err = request_irq(grp->interruptError, gfar_error,
|
|
|
|
0, grp->int_name_er, grp)) < 0) {
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_err(priv, intr, dev, "Can't get IRQ %d\n",
|
|
|
|
grp->interruptError);
|
2009-11-02 07:03:34 +00:00
|
|
|
|
2010-08-05 10:26:20 +00:00
|
|
|
goto err_irq_fail;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
if ((err = request_irq(grp->interruptTransmit, gfar_transmit,
|
2012-06-05 03:42:13 +00:00
|
|
|
0, grp->int_name_tx, grp)) < 0) {
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_err(priv, intr, dev, "Can't get IRQ %d\n",
|
|
|
|
grp->interruptTransmit);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto tx_irq_fail;
|
|
|
|
}
|
|
|
|
|
2012-06-05 03:42:13 +00:00
|
|
|
if ((err = request_irq(grp->interruptReceive, gfar_receive,
|
|
|
|
0, grp->int_name_rx, grp)) < 0) {
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_err(priv, intr, dev, "Can't get IRQ %d\n",
|
|
|
|
grp->interruptReceive);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto rx_irq_fail;
|
|
|
|
}
|
|
|
|
} else {
|
2012-06-05 03:42:13 +00:00
|
|
|
if ((err = request_irq(grp->interruptTransmit, gfar_interrupt,
|
|
|
|
0, grp->int_name_tx, grp)) < 0) {
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_err(priv, intr, dev, "Can't get IRQ %d\n",
|
|
|
|
grp->interruptTransmit);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto err_irq_fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
rx_irq_fail:
|
|
|
|
free_irq(grp->interruptTransmit, grp);
|
|
|
|
tx_irq_fail:
|
|
|
|
free_irq(grp->interruptError, grp);
|
|
|
|
err_irq_fail:
|
|
|
|
return err;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Bring the controller up and running */
|
|
|
|
int startup_gfar(struct net_device *ndev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(ndev);
|
|
|
|
struct gfar __iomem *regs = NULL;
|
|
|
|
int err, i, j;
|
|
|
|
|
|
|
|
for (i = 0; i < priv->num_grps; i++) {
|
|
|
|
regs= priv->gfargrp[i].regs;
|
|
|
|
gfar_write(®s->imask, IMASK_INIT_CLEAR);
|
|
|
|
}
|
|
|
|
|
|
|
|
regs= priv->gfargrp[0].regs;
|
|
|
|
err = gfar_alloc_skb_resources(ndev);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
gfar_init_mac(ndev);
|
|
|
|
|
|
|
|
for (i = 0; i < priv->num_grps; i++) {
|
|
|
|
err = register_grp_irqs(&priv->gfargrp[i]);
|
|
|
|
if (err) {
|
|
|
|
for (j = 0; j < i; j++)
|
|
|
|
free_grp_irqs(&priv->gfargrp[j]);
|
2011-01-18 02:36:02 +00:00
|
|
|
goto irq_fail;
|
2009-11-02 07:03:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-11 18:38:59 +00:00
|
|
|
/* Start the controller */
|
2009-10-12 06:00:26 +00:00
|
|
|
gfar_start(ndev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-10-12 06:00:34 +00:00
|
|
|
phy_start(priv->phydev);
|
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
gfar_configure_coalescing(priv, 0xFF, 0xFF);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
irq_fail:
|
2009-10-12 06:00:30 +00:00
|
|
|
free_skb_resources(priv);
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* Called when something needs to use the ethernet device
|
|
|
|
* Returns 0 for success.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
static int gfar_enet_open(struct net_device *dev)
|
|
|
|
{
|
2007-10-12 13:53:51 +00:00
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
int err;
|
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
enable_napi(priv);
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Initialize a bunch of registers */
|
|
|
|
init_registers(dev);
|
|
|
|
|
|
|
|
gfar_set_mac_address(dev);
|
|
|
|
|
|
|
|
err = init_phy(dev);
|
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
if (err) {
|
2009-11-02 07:03:34 +00:00
|
|
|
disable_napi(priv);
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
err = startup_gfar(dev);
|
2007-10-17 19:57:46 +00:00
|
|
|
if (err) {
|
2009-11-02 07:03:34 +00:00
|
|
|
disable_napi(priv);
|
2007-10-17 19:57:46 +00:00
|
|
|
return err;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
netif_tx_start_all_queues(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-02-01 08:52:34 +00:00
|
|
|
device_set_wakeup_enable(&dev->dev, priv->wol_en);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-03-27 07:38:45 +00:00
|
|
|
static inline struct txfcb *gfar_add_fcb(struct sk_buff *skb)
|
2005-06-20 15:54:21 +00:00
|
|
|
{
|
2009-03-27 07:38:45 +00:00
|
|
|
struct txfcb *fcb = (struct txfcb *)skb_push(skb, GMAC_FCB_LEN);
|
2009-04-28 15:04:10 +00:00
|
|
|
|
|
|
|
memset(fcb, 0, GMAC_FCB_LEN);
|
2005-06-20 15:54:21 +00:00
|
|
|
|
|
|
|
return fcb;
|
|
|
|
}
|
|
|
|
|
2012-01-09 23:26:51 +00:00
|
|
|
static inline void gfar_tx_checksum(struct sk_buff *skb, struct txfcb *fcb,
|
2012-06-05 03:42:13 +00:00
|
|
|
int fcb_length)
|
2005-06-20 15:54:21 +00:00
|
|
|
{
|
|
|
|
/* If we're here, it's a IP packet with a TCP or UDP
|
|
|
|
* payload. We set it to checksum, using a pseudo-header
|
|
|
|
* we provide
|
|
|
|
*/
|
2012-06-05 03:42:14 +00:00
|
|
|
u8 flags = TXFCB_DEFAULT;
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* Tell the controller what the protocol is
|
|
|
|
* And provide the already calculated phcs
|
|
|
|
*/
|
2007-04-21 05:47:35 +00:00
|
|
|
if (ip_hdr(skb)->protocol == IPPROTO_UDP) {
|
2005-11-11 18:38:59 +00:00
|
|
|
flags |= TXFCB_UDP;
|
2007-03-13 17:28:48 +00:00
|
|
|
fcb->phcs = udp_hdr(skb)->check;
|
2005-11-11 18:38:59 +00:00
|
|
|
} else
|
2007-06-29 05:12:04 +00:00
|
|
|
fcb->phcs = tcp_hdr(skb)->check;
|
2005-06-20 15:54:21 +00:00
|
|
|
|
|
|
|
/* l3os is the distance between the start of the
|
|
|
|
* frame (skb->data) and the start of the IP hdr.
|
|
|
|
* l4os is the distance between the start of the
|
2012-06-05 03:42:12 +00:00
|
|
|
* l3 hdr and the l4 hdr
|
|
|
|
*/
|
2012-01-09 23:26:51 +00:00
|
|
|
fcb->l3os = (u16)(skb_network_offset(skb) - fcb_length);
|
2007-03-16 20:26:39 +00:00
|
|
|
fcb->l4os = skb_network_header_len(skb);
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2005-11-11 18:38:59 +00:00
|
|
|
fcb->flags = flags;
|
2005-06-20 15:54:21 +00:00
|
|
|
}
|
|
|
|
|
2005-11-11 18:38:59 +00:00
|
|
|
void inline gfar_tx_vlan(struct sk_buff *skb, struct txfcb *fcb)
|
2005-06-20 15:54:21 +00:00
|
|
|
{
|
2005-11-11 18:38:59 +00:00
|
|
|
fcb->flags |= TXFCB_VLN;
|
2005-06-20 15:54:21 +00:00
|
|
|
fcb->vlctl = vlan_tx_tag_get(skb);
|
|
|
|
}
|
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
static inline struct txbd8 *skip_txbd(struct txbd8 *bdp, int stride,
|
2012-06-05 03:42:13 +00:00
|
|
|
struct txbd8 *base, int ring_size)
|
2008-12-18 00:51:04 +00:00
|
|
|
{
|
|
|
|
struct txbd8 *new_bd = bdp + stride;
|
|
|
|
|
|
|
|
return (new_bd >= (base + ring_size)) ? (new_bd - ring_size) : new_bd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct txbd8 *next_txbd(struct txbd8 *bdp, struct txbd8 *base,
|
2012-06-05 03:42:13 +00:00
|
|
|
int ring_size)
|
2008-12-18 00:51:04 +00:00
|
|
|
{
|
|
|
|
return skip_txbd(bdp, 1, base, ring_size);
|
|
|
|
}
|
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* This is called by the kernel when a frame is ready for transmission.
|
|
|
|
* It is pointed to by the dev->hard_start_xmit function pointer
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-11-02 07:03:00 +00:00
|
|
|
struct gfar_priv_tx_q *tx_queue = NULL;
|
2009-11-02 07:03:15 +00:00
|
|
|
struct netdev_queue *txq;
|
2009-11-02 07:03:09 +00:00
|
|
|
struct gfar __iomem *regs = NULL;
|
2005-06-20 15:54:21 +00:00
|
|
|
struct txfcb *fcb = NULL;
|
2010-04-08 23:10:35 +00:00
|
|
|
struct txbd8 *txbdp, *txbdp_start, *base, *txbdp_tstamp = NULL;
|
2008-12-16 23:34:50 +00:00
|
|
|
u32 lstatus;
|
2010-04-08 23:10:35 +00:00
|
|
|
int i, rq = 0, do_tstamp = 0;
|
2008-12-18 00:51:04 +00:00
|
|
|
u32 bufaddr;
|
2006-04-20 21:44:29 +00:00
|
|
|
unsigned long flags;
|
2012-01-09 23:26:51 +00:00
|
|
|
unsigned int nr_frags, nr_txbds, length, fcb_length = GMAC_FCB_LEN;
|
2009-11-02 07:03:15 +00:00
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* TOE=1 frames larger than 2500 bytes may see excess delays
|
2010-06-30 06:39:13 +00:00
|
|
|
* before start of transmission.
|
|
|
|
*/
|
|
|
|
if (unlikely(gfar_has_errata(priv, GFAR_ERRATA_76) &&
|
2012-06-05 03:42:13 +00:00
|
|
|
skb->ip_summed == CHECKSUM_PARTIAL &&
|
|
|
|
skb->len > 2500)) {
|
2010-06-30 06:39:13 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = skb_checksum_help(skb);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
rq = skb->queue_mapping;
|
|
|
|
tx_queue = priv->tx_queue[rq];
|
|
|
|
txq = netdev_get_tx_queue(dev, rq);
|
2009-11-02 07:03:00 +00:00
|
|
|
base = tx_queue->tx_bd_base;
|
2009-11-02 07:03:34 +00:00
|
|
|
regs = tx_queue->grp->regs;
|
2010-04-08 23:10:35 +00:00
|
|
|
|
|
|
|
/* check if time stamp should be generated */
|
2010-08-17 08:59:14 +00:00
|
|
|
if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP &&
|
2012-06-05 03:42:13 +00:00
|
|
|
priv->hwts_tx_en)) {
|
2010-04-08 23:10:35 +00:00
|
|
|
do_tstamp = 1;
|
2012-01-09 23:26:51 +00:00
|
|
|
fcb_length = GMAC_FCB_LEN + GMAC_TXPAL_LEN;
|
|
|
|
}
|
2008-12-18 00:51:04 +00:00
|
|
|
|
2009-03-27 22:54:30 +00:00
|
|
|
/* make space for additional header when fcb is needed */
|
|
|
|
if (((skb->ip_summed == CHECKSUM_PARTIAL) ||
|
2012-06-05 03:42:13 +00:00
|
|
|
vlan_tx_tag_present(skb) ||
|
|
|
|
unlikely(do_tstamp)) &&
|
|
|
|
(skb_headroom(skb) < fcb_length)) {
|
2009-03-27 07:38:45 +00:00
|
|
|
struct sk_buff *skb_new;
|
|
|
|
|
2012-01-09 23:26:51 +00:00
|
|
|
skb_new = skb_realloc_headroom(skb, fcb_length);
|
2009-03-27 07:38:45 +00:00
|
|
|
if (!skb_new) {
|
|
|
|
dev->stats.tx_errors++;
|
2009-03-27 08:10:58 +00:00
|
|
|
kfree_skb(skb);
|
2009-03-27 07:38:45 +00:00
|
|
|
return NETDEV_TX_OK;
|
|
|
|
}
|
2012-01-09 23:26:50 +00:00
|
|
|
|
2012-07-05 11:45:13 +00:00
|
|
|
if (skb->sk)
|
|
|
|
skb_set_owner_w(skb_new, skb->sk);
|
|
|
|
consume_skb(skb);
|
2009-03-27 07:38:45 +00:00
|
|
|
skb = skb_new;
|
|
|
|
}
|
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
/* total number of fragments in the SKB */
|
|
|
|
nr_frags = skb_shinfo(skb)->nr_frags;
|
|
|
|
|
2010-04-08 23:10:35 +00:00
|
|
|
/* calculate the required number of TxBDs for this skb */
|
|
|
|
if (unlikely(do_tstamp))
|
|
|
|
nr_txbds = nr_frags + 2;
|
|
|
|
else
|
|
|
|
nr_txbds = nr_frags + 1;
|
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
/* check if there is space to queue this packet */
|
2010-04-08 23:10:35 +00:00
|
|
|
if (nr_txbds > tx_queue->num_txbdfree) {
|
2008-12-18 00:51:04 +00:00
|
|
|
/* no space, stop the queue */
|
2009-11-02 07:03:15 +00:00
|
|
|
netif_tx_stop_queue(txq);
|
2008-12-18 00:51:04 +00:00
|
|
|
dev->stats.tx_fifo_errors++;
|
|
|
|
return NETDEV_TX_BUSY;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Update transmit stats */
|
2011-01-12 12:13:14 +00:00
|
|
|
tx_queue->stats.tx_bytes += skb->len;
|
|
|
|
tx_queue->stats.tx_packets++;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
txbdp = txbdp_start = tx_queue->cur_tx;
|
2010-04-08 23:10:35 +00:00
|
|
|
lstatus = txbdp->lstatus;
|
|
|
|
|
|
|
|
/* Time stamp insertion requires one additional TxBD */
|
|
|
|
if (unlikely(do_tstamp))
|
|
|
|
txbdp_tstamp = txbdp = next_txbd(txbdp, base,
|
2012-06-05 03:42:13 +00:00
|
|
|
tx_queue->tx_ring_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
if (nr_frags == 0) {
|
2010-04-08 23:10:35 +00:00
|
|
|
if (unlikely(do_tstamp))
|
|
|
|
txbdp_tstamp->lstatus |= BD_LFLAG(TXBD_LAST |
|
2012-06-05 03:42:13 +00:00
|
|
|
TXBD_INTERRUPT);
|
2010-04-08 23:10:35 +00:00
|
|
|
else
|
|
|
|
lstatus |= BD_LFLAG(TXBD_LAST | TXBD_INTERRUPT);
|
2008-12-18 00:51:04 +00:00
|
|
|
} else {
|
|
|
|
/* Place the fragment addresses and lengths into the TxBDs */
|
|
|
|
for (i = 0; i < nr_frags; i++) {
|
|
|
|
/* Point at the next BD, wrapping as needed */
|
2009-11-02 07:03:00 +00:00
|
|
|
txbdp = next_txbd(txbdp, base, tx_queue->tx_ring_size);
|
2008-12-18 00:51:04 +00:00
|
|
|
|
|
|
|
length = skb_shinfo(skb)->frags[i].size;
|
|
|
|
|
|
|
|
lstatus = txbdp->lstatus | length |
|
2012-06-05 03:42:13 +00:00
|
|
|
BD_LFLAG(TXBD_READY);
|
2008-12-18 00:51:04 +00:00
|
|
|
|
|
|
|
/* Handle the last BD specially */
|
|
|
|
if (i == nr_frags - 1)
|
|
|
|
lstatus |= BD_LFLAG(TXBD_LAST | TXBD_INTERRUPT);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-08-29 23:18:29 +00:00
|
|
|
bufaddr = skb_frag_dma_map(&priv->ofdev->dev,
|
|
|
|
&skb_shinfo(skb)->frags[i],
|
|
|
|
0,
|
|
|
|
length,
|
|
|
|
DMA_TO_DEVICE);
|
2008-12-18 00:51:04 +00:00
|
|
|
|
|
|
|
/* set the TxBD length and buffer pointer */
|
|
|
|
txbdp->bufPtr = bufaddr;
|
|
|
|
txbdp->lstatus = lstatus;
|
|
|
|
}
|
|
|
|
|
|
|
|
lstatus = txbdp_start->lstatus;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-01-09 23:26:51 +00:00
|
|
|
/* Add TxPAL between FCB and frame if required */
|
|
|
|
if (unlikely(do_tstamp)) {
|
|
|
|
skb_push(skb, GMAC_TXPAL_LEN);
|
|
|
|
memset(skb->data, 0, GMAC_TXPAL_LEN);
|
|
|
|
}
|
|
|
|
|
2005-06-20 15:54:21 +00:00
|
|
|
/* Set up checksumming */
|
2008-12-16 23:30:20 +00:00
|
|
|
if (CHECKSUM_PARTIAL == skb->ip_summed) {
|
2009-03-27 07:38:45 +00:00
|
|
|
fcb = gfar_add_fcb(skb);
|
2011-03-16 17:57:13 +00:00
|
|
|
/* as specified by errata */
|
2012-06-05 03:42:13 +00:00
|
|
|
if (unlikely(gfar_has_errata(priv, GFAR_ERRATA_12) &&
|
|
|
|
((unsigned long)fcb % 0x20) > 0x18)) {
|
2011-03-16 17:57:13 +00:00
|
|
|
__skb_pull(skb, GMAC_FCB_LEN);
|
|
|
|
skb_checksum_help(skb);
|
|
|
|
} else {
|
|
|
|
lstatus |= BD_LFLAG(TXBD_TOE);
|
2012-01-09 23:26:51 +00:00
|
|
|
gfar_tx_checksum(skb, fcb, fcb_length);
|
2011-03-16 17:57:13 +00:00
|
|
|
}
|
2005-06-20 15:54:21 +00:00
|
|
|
}
|
|
|
|
|
2010-10-20 13:56:03 +00:00
|
|
|
if (vlan_tx_tag_present(skb)) {
|
2009-03-27 07:38:45 +00:00
|
|
|
if (unlikely(NULL == fcb)) {
|
|
|
|
fcb = gfar_add_fcb(skb);
|
2008-12-16 23:34:50 +00:00
|
|
|
lstatus |= BD_LFLAG(TXBD_TOE);
|
2005-11-11 18:38:59 +00:00
|
|
|
}
|
2009-03-27 07:38:45 +00:00
|
|
|
|
|
|
|
gfar_tx_vlan(skb, fcb);
|
2005-06-20 15:54:21 +00:00
|
|
|
}
|
|
|
|
|
2010-04-08 23:10:35 +00:00
|
|
|
/* Setup tx hardware time stamping if requested */
|
|
|
|
if (unlikely(do_tstamp)) {
|
2010-08-17 08:59:14 +00:00
|
|
|
skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
|
2010-04-08 23:10:35 +00:00
|
|
|
if (fcb == NULL)
|
|
|
|
fcb = gfar_add_fcb(skb);
|
|
|
|
fcb->ptp = 1;
|
|
|
|
lstatus |= BD_LFLAG(TXBD_TOE);
|
|
|
|
}
|
|
|
|
|
2009-03-19 06:28:22 +00:00
|
|
|
txbdp_start->bufPtr = dma_map_single(&priv->ofdev->dev, skb->data,
|
2012-06-05 03:42:13 +00:00
|
|
|
skb_headlen(skb), DMA_TO_DEVICE);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* If time stamping is requested one additional TxBD must be set up. The
|
2010-04-08 23:10:35 +00:00
|
|
|
* first TxBD points to the FCB and must have a data length of
|
|
|
|
* GMAC_FCB_LEN. The second TxBD points to the actual frame data with
|
|
|
|
* the full frame length.
|
|
|
|
*/
|
|
|
|
if (unlikely(do_tstamp)) {
|
2012-01-09 23:26:51 +00:00
|
|
|
txbdp_tstamp->bufPtr = txbdp_start->bufPtr + fcb_length;
|
2010-04-08 23:10:35 +00:00
|
|
|
txbdp_tstamp->lstatus |= BD_LFLAG(TXBD_READY) |
|
2012-06-05 03:42:13 +00:00
|
|
|
(skb_headlen(skb) - fcb_length);
|
2010-04-08 23:10:35 +00:00
|
|
|
lstatus |= BD_LFLAG(TXBD_CRC | TXBD_READY) | GMAC_FCB_LEN;
|
|
|
|
} else {
|
|
|
|
lstatus |= BD_LFLAG(TXBD_CRC | TXBD_READY) | skb_headlen(skb);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-01-06 18:51:03 +00:00
|
|
|
netdev_tx_sent_queue(txq, skb->len);
|
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* We can work in parallel with gfar_clean_tx_ring(), except
|
2009-11-10 14:11:10 +00:00
|
|
|
* when modifying num_txbdfree. Note that we didn't grab the lock
|
|
|
|
* when we were reading the num_txbdfree and checking for available
|
|
|
|
* space, that's because outside of this function it can only grow,
|
|
|
|
* and once we've got needed space, it cannot suddenly disappear.
|
|
|
|
*
|
|
|
|
* The lock also protects us from gfar_error(), which can modify
|
|
|
|
* regs->tstat and thus retrigger the transfers, which is why we
|
|
|
|
* also must grab the lock before setting ready bit for the first
|
|
|
|
* to be transmitted BD.
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&tx_queue->txlock, flags);
|
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* The powerpc-specific eieio() is used, as wmb() has too strong
|
2007-05-16 20:06:59 +00:00
|
|
|
* semantics (it requires synchronization between cacheable and
|
|
|
|
* uncacheable mappings, which eieio doesn't provide and which we
|
|
|
|
* don't need), thus requiring a more expensive sync instruction. At
|
|
|
|
* some point, the set of architecture-independent barrier functions
|
|
|
|
* should be expanded to include weaker barriers.
|
|
|
|
*/
|
|
|
|
eieio();
|
2005-11-11 18:38:59 +00:00
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
txbdp_start->lstatus = lstatus;
|
|
|
|
|
gianfar: Fix TX ring processing on SMP machines
Starting with commit a3bc1f11e9b867a4f49505 ("gianfar: Revive SKB
recycling") gianfar driver sooner or later stops transmitting any
packets on SMP machines.
start_xmit() prepares new skb for transmitting, generally it does
three things:
1. sets up all BDs (marks them ready to send), except the first one.
2. stores skb into tx_queue->tx_skbuff so that clean_tx_ring()
would cleanup it later.
3. sets up the first BD, i.e. marks it ready.
Here is what clean_tx_ring() does:
1. reads skbs from tx_queue->tx_skbuff
2. checks if the *last* BD is ready. If it's still ready [to send]
then it it isn't transmitted, so clean_tx_ring() returns.
Otherwise it actually cleanups BDs. All is OK.
Now, if there is just one BD, code flow:
- start_xmit(): stores skb into tx_skbuff. Note that the first BD
(which is also the last one) isn't marked as ready, yet.
- clean_tx_ring(): sees that skb is not null, *and* its lstatus
says that it is NOT ready (like if BD was sent), so it cleans
it up (bad!)
- start_xmit(): marks BD as ready [to send], but it's too late.
We can fix this simply by reordering lstatus/tx_skbuff writes.
Reported-by: Martyn Welch <martyn.welch@ge.com>
Bisected-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: Anton Vorontsov <avorontsov@ru.mvista.com>
Tested-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Tested-by: Martyn Welch <martyn.welch@ge.com>
Cc: Sandeep Gopalpet <Sandeep.Kumar@freescale.com>
Cc: Stable <stable@vger.kernel.org> [2.6.33]
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-03-03 08:18:58 +00:00
|
|
|
eieio(); /* force lstatus write before tx_skbuff */
|
|
|
|
|
|
|
|
tx_queue->tx_skbuff[tx_queue->skb_curtx] = skb;
|
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
/* Update the current skb pointer to the next entry we will use
|
2012-06-05 03:42:12 +00:00
|
|
|
* (wrapping if necessary)
|
|
|
|
*/
|
2009-11-02 07:03:00 +00:00
|
|
|
tx_queue->skb_curtx = (tx_queue->skb_curtx + 1) &
|
2012-06-05 03:42:13 +00:00
|
|
|
TX_RING_MOD_MASK(tx_queue->tx_ring_size);
|
2008-12-18 00:51:04 +00:00
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
tx_queue->cur_tx = next_txbd(txbdp, base, tx_queue->tx_ring_size);
|
2008-12-18 00:51:04 +00:00
|
|
|
|
|
|
|
/* reduce TxBD free count */
|
2010-04-08 23:10:35 +00:00
|
|
|
tx_queue->num_txbdfree -= (nr_txbds);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* If the next BD still needs to be cleaned up, then the bds
|
2012-06-05 03:42:12 +00:00
|
|
|
* are full. We need to tell the kernel to stop sending us stuff.
|
|
|
|
*/
|
2009-11-02 07:03:00 +00:00
|
|
|
if (!tx_queue->num_txbdfree) {
|
2009-11-02 07:03:15 +00:00
|
|
|
netif_tx_stop_queue(txq);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-10-04 00:41:50 +00:00
|
|
|
dev->stats.tx_fifo_errors++;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Tell the DMA to go go go */
|
2009-11-02 07:03:15 +00:00
|
|
|
gfar_write(®s->tstat, TSTAT_CLEAR_THALT >> tx_queue->qindex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Unlock priv */
|
2009-11-02 07:03:00 +00:00
|
|
|
spin_unlock_irqrestore(&tx_queue->txlock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-27 07:38:45 +00:00
|
|
|
return NETDEV_TX_OK;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Stops the kernel queue, and halts the controller */
|
|
|
|
static int gfar_close(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
disable_napi(priv);
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
|
2008-08-19 19:12:45 +00:00
|
|
|
cancel_work_sync(&priv->reset_task);
|
2005-04-16 22:20:36 +00:00
|
|
|
stop_gfar(dev);
|
|
|
|
|
2005-09-24 02:54:21 +00:00
|
|
|
/* Disconnect from the PHY */
|
|
|
|
phy_disconnect(priv->phydev);
|
|
|
|
priv->phydev = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
netif_tx_stop_all_queues(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Changes the mac address if the controller is not running. */
|
2008-05-02 18:00:30 +00:00
|
|
|
static int gfar_set_mac_address(struct net_device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-11-11 18:38:59 +00:00
|
|
|
gfar_set_mac_for_addr(dev, 0, dev->dev_addr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-15 23:00:20 +00:00
|
|
|
/* Check if rx parser should be activated */
|
|
|
|
void gfar_check_rx_parser_mode(struct gfar_private *priv)
|
|
|
|
{
|
|
|
|
struct gfar __iomem *regs;
|
|
|
|
u32 tempval;
|
|
|
|
|
|
|
|
regs = priv->gfargrp[0].regs;
|
|
|
|
|
|
|
|
tempval = gfar_read(®s->rctrl);
|
|
|
|
/* If parse is no longer required, then disable parser */
|
|
|
|
if (tempval & RCTRL_REQ_PARSER)
|
|
|
|
tempval |= RCTRL_PRSDEP_INIT;
|
|
|
|
else
|
|
|
|
tempval &= ~RCTRL_PRSDEP_INIT;
|
|
|
|
gfar_write(®s->rctrl, tempval);
|
|
|
|
}
|
|
|
|
|
2005-06-20 15:54:21 +00:00
|
|
|
/* Enables and disables VLAN insertion/extraction */
|
2011-11-15 15:29:55 +00:00
|
|
|
void gfar_vlan_mode(struct net_device *dev, netdev_features_t features)
|
2005-06-20 15:54:21 +00:00
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-11-02 07:03:09 +00:00
|
|
|
struct gfar __iomem *regs = NULL;
|
2005-06-20 15:54:21 +00:00
|
|
|
unsigned long flags;
|
|
|
|
u32 tempval;
|
|
|
|
|
2009-11-02 07:03:34 +00:00
|
|
|
regs = priv->gfargrp[0].regs;
|
2009-11-02 07:03:15 +00:00
|
|
|
local_irq_save(flags);
|
|
|
|
lock_rx_qs(priv);
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2011-07-20 04:54:19 +00:00
|
|
|
if (features & NETIF_F_HW_VLAN_TX) {
|
2005-06-20 15:54:21 +00:00
|
|
|
/* Enable VLAN tag insertion */
|
2009-11-02 07:03:09 +00:00
|
|
|
tempval = gfar_read(®s->tctrl);
|
2005-06-20 15:54:21 +00:00
|
|
|
tempval |= TCTRL_VLINS;
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->tctrl, tempval);
|
2005-06-20 15:54:21 +00:00
|
|
|
} else {
|
|
|
|
/* Disable VLAN tag insertion */
|
2009-11-02 07:03:09 +00:00
|
|
|
tempval = gfar_read(®s->tctrl);
|
2005-06-20 15:54:21 +00:00
|
|
|
tempval &= ~TCTRL_VLINS;
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->tctrl, tempval);
|
2011-07-20 04:54:19 +00:00
|
|
|
}
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2011-07-20 04:54:19 +00:00
|
|
|
if (features & NETIF_F_HW_VLAN_RX) {
|
|
|
|
/* Enable VLAN tag extraction */
|
|
|
|
tempval = gfar_read(®s->rctrl);
|
|
|
|
tempval |= (RCTRL_VLEX | RCTRL_PRSDEP_INIT);
|
|
|
|
gfar_write(®s->rctrl, tempval);
|
|
|
|
} else {
|
2005-06-20 15:54:21 +00:00
|
|
|
/* Disable VLAN tag extraction */
|
2009-11-02 07:03:09 +00:00
|
|
|
tempval = gfar_read(®s->rctrl);
|
2005-06-20 15:54:21 +00:00
|
|
|
tempval &= ~RCTRL_VLEX;
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->rctrl, tempval);
|
2011-07-15 23:00:20 +00:00
|
|
|
|
|
|
|
gfar_check_rx_parser_mode(priv);
|
2005-06-20 15:54:21 +00:00
|
|
|
}
|
|
|
|
|
2008-12-16 23:30:48 +00:00
|
|
|
gfar_change_mtu(dev, dev->mtu);
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
unlock_rx_qs(priv);
|
|
|
|
local_irq_restore(flags);
|
2005-06-20 15:54:21 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int gfar_change_mtu(struct net_device *dev, int new_mtu)
|
|
|
|
{
|
|
|
|
int tempsize, tempval;
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = priv->gfargrp[0].regs;
|
2005-04-16 22:20:36 +00:00
|
|
|
int oldsize = priv->rx_buffer_size;
|
2005-06-20 15:54:21 +00:00
|
|
|
int frame_size = new_mtu + ETH_HLEN;
|
|
|
|
|
2011-07-20 04:54:19 +00:00
|
|
|
if (gfar_is_vlan_on(priv))
|
2008-03-24 15:53:26 +00:00
|
|
|
frame_size += VLAN_HLEN;
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if ((frame_size < 64) || (frame_size > JUMBO_FRAME_SIZE)) {
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_err(priv, drv, dev, "Invalid MTU setting\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-12-16 23:30:48 +00:00
|
|
|
if (gfar_uses_fcb(priv))
|
|
|
|
frame_size += GMAC_FCB_LEN;
|
|
|
|
|
|
|
|
frame_size += priv->padding;
|
|
|
|
|
2012-06-05 03:42:13 +00:00
|
|
|
tempsize = (frame_size & ~(INCREMENTAL_BUFFER_SIZE - 1)) +
|
|
|
|
INCREMENTAL_BUFFER_SIZE;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Only stop and start the controller if it isn't already
|
2012-06-05 03:42:12 +00:00
|
|
|
* stopped, and we changed something
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
if ((oldsize != tempsize) && (dev->flags & IFF_UP))
|
|
|
|
stop_gfar(dev);
|
|
|
|
|
|
|
|
priv->rx_buffer_size = tempsize;
|
|
|
|
|
|
|
|
dev->mtu = new_mtu;
|
|
|
|
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->mrblr, priv->rx_buffer_size);
|
|
|
|
gfar_write(®s->maxfrm, priv->rx_buffer_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* If the mtu is larger than the max size for standard
|
|
|
|
* ethernet frames (ie, a jumbo frame), then set maccfg2
|
2012-06-05 03:42:12 +00:00
|
|
|
* to allow huge frames, and to check the length
|
|
|
|
*/
|
2009-11-02 07:03:09 +00:00
|
|
|
tempval = gfar_read(®s->maccfg2);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-06-30 06:39:12 +00:00
|
|
|
if (priv->rx_buffer_size > DEFAULT_RX_BUFFER_SIZE ||
|
2012-06-05 03:42:13 +00:00
|
|
|
gfar_has_errata(priv, GFAR_ERRATA_74))
|
2005-04-16 22:20:36 +00:00
|
|
|
tempval |= (MACCFG2_HUGEFRAME | MACCFG2_LENGTHCHECK);
|
|
|
|
else
|
|
|
|
tempval &= ~(MACCFG2_HUGEFRAME | MACCFG2_LENGTHCHECK);
|
|
|
|
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->maccfg2, tempval);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if ((oldsize != tempsize) && (dev->flags & IFF_UP))
|
|
|
|
startup_gfar(dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-19 19:12:45 +00:00
|
|
|
/* gfar_reset_task gets scheduled when a packet has not been
|
2005-04-16 22:20:36 +00:00
|
|
|
* transmitted after a set amount of time.
|
|
|
|
* For now, assume that clearing out all the structures, and
|
2008-08-19 19:12:45 +00:00
|
|
|
* starting over will fix the problem.
|
|
|
|
*/
|
|
|
|
static void gfar_reset_task(struct work_struct *work)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-08-19 19:12:45 +00:00
|
|
|
struct gfar_private *priv = container_of(work, struct gfar_private,
|
2012-06-05 03:42:13 +00:00
|
|
|
reset_task);
|
2009-03-19 06:28:22 +00:00
|
|
|
struct net_device *dev = priv->ndev;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (dev->flags & IFF_UP) {
|
2009-11-02 07:03:15 +00:00
|
|
|
netif_tx_stop_all_queues(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
stop_gfar(dev);
|
|
|
|
startup_gfar(dev);
|
2009-11-02 07:03:15 +00:00
|
|
|
netif_tx_start_all_queues(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-15 10:47:41 +00:00
|
|
|
netif_tx_schedule_all(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-08-19 19:12:45 +00:00
|
|
|
static void gfar_timeout(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
|
|
|
|
|
|
|
dev->stats.tx_errors++;
|
|
|
|
schedule_work(&priv->reset_task);
|
|
|
|
}
|
|
|
|
|
2010-07-07 22:54:54 +00:00
|
|
|
static void gfar_align_skb(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
/* We need the data buffer to be aligned properly. We will reserve
|
|
|
|
* as many bytes as needed to align the data properly
|
|
|
|
*/
|
|
|
|
skb_reserve(skb, RXBUF_ALIGNMENT -
|
2012-06-05 03:42:13 +00:00
|
|
|
(((unsigned long) skb->data) & (RXBUF_ALIGNMENT - 1)));
|
2010-07-07 22:54:54 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Interrupt Handler for Transmit complete */
|
2009-11-02 07:03:00 +00:00
|
|
|
static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-11-02 07:03:00 +00:00
|
|
|
struct net_device *dev = tx_queue->dev;
|
2012-01-06 18:51:03 +00:00
|
|
|
struct netdev_queue *txq;
|
2008-04-10 00:37:51 +00:00
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-11-02 07:03:00 +00:00
|
|
|
struct gfar_priv_rx_q *rx_queue = NULL;
|
2010-04-08 23:10:35 +00:00
|
|
|
struct txbd8 *bdp, *next = NULL;
|
2008-12-18 00:51:04 +00:00
|
|
|
struct txbd8 *lbdp = NULL;
|
2009-11-02 07:03:00 +00:00
|
|
|
struct txbd8 *base = tx_queue->tx_bd_base;
|
2008-12-18 00:51:04 +00:00
|
|
|
struct sk_buff *skb;
|
|
|
|
int skb_dirtytx;
|
2009-11-02 07:03:00 +00:00
|
|
|
int tx_ring_size = tx_queue->tx_ring_size;
|
2010-04-08 23:10:35 +00:00
|
|
|
int frags = 0, nr_txbds = 0;
|
2008-12-18 00:51:04 +00:00
|
|
|
int i;
|
2008-04-10 00:37:51 +00:00
|
|
|
int howmany = 0;
|
2012-01-06 18:51:03 +00:00
|
|
|
int tqi = tx_queue->qindex;
|
|
|
|
unsigned int bytes_sent = 0;
|
2008-12-18 00:51:04 +00:00
|
|
|
u32 lstatus;
|
2010-04-08 23:10:35 +00:00
|
|
|
size_t buflen;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-01-06 18:51:03 +00:00
|
|
|
rx_queue = priv->rx_queue[tqi];
|
|
|
|
txq = netdev_get_tx_queue(dev, tqi);
|
2009-11-02 07:03:00 +00:00
|
|
|
bdp = tx_queue->dirty_tx;
|
|
|
|
skb_dirtytx = tx_queue->skb_dirtytx;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
while ((skb = tx_queue->tx_skbuff[skb_dirtytx])) {
|
2009-11-10 14:11:10 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
frags = skb_shinfo(skb)->nr_frags;
|
2010-04-08 23:10:35 +00:00
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* When time stamping, one additional TxBD must be freed.
|
2010-04-08 23:10:35 +00:00
|
|
|
* Also, we need to dma_unmap_single() the TxPAL.
|
|
|
|
*/
|
2010-08-17 08:59:14 +00:00
|
|
|
if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS))
|
2010-04-08 23:10:35 +00:00
|
|
|
nr_txbds = frags + 2;
|
|
|
|
else
|
|
|
|
nr_txbds = frags + 1;
|
|
|
|
|
|
|
|
lbdp = skip_txbd(bdp, nr_txbds - 1, base, tx_ring_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
lstatus = lbdp->lstatus;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
/* Only clean completed frames */
|
|
|
|
if ((lstatus & BD_LFLAG(TXBD_READY)) &&
|
2012-06-05 03:42:13 +00:00
|
|
|
(lstatus & BD_LENGTH_MASK))
|
2008-12-18 00:51:04 +00:00
|
|
|
break;
|
|
|
|
|
2010-08-17 08:59:14 +00:00
|
|
|
if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS)) {
|
2010-04-08 23:10:35 +00:00
|
|
|
next = next_txbd(bdp, base, tx_ring_size);
|
2012-01-09 23:26:51 +00:00
|
|
|
buflen = next->length + GMAC_FCB_LEN + GMAC_TXPAL_LEN;
|
2010-04-08 23:10:35 +00:00
|
|
|
} else
|
|
|
|
buflen = bdp->length;
|
|
|
|
|
|
|
|
dma_unmap_single(&priv->ofdev->dev, bdp->bufPtr,
|
2012-06-05 03:42:13 +00:00
|
|
|
buflen, DMA_TO_DEVICE);
|
2010-04-08 23:10:35 +00:00
|
|
|
|
2010-08-17 08:59:14 +00:00
|
|
|
if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS)) {
|
2010-04-08 23:10:35 +00:00
|
|
|
struct skb_shared_hwtstamps shhwtstamps;
|
|
|
|
u64 *ns = (u64*) (((u32)skb->data + 0x10) & ~0x7);
|
2012-06-05 03:42:13 +00:00
|
|
|
|
2010-04-08 23:10:35 +00:00
|
|
|
memset(&shhwtstamps, 0, sizeof(shhwtstamps));
|
|
|
|
shhwtstamps.hwtstamp = ns_to_ktime(*ns);
|
2012-01-09 23:26:51 +00:00
|
|
|
skb_pull(skb, GMAC_FCB_LEN + GMAC_TXPAL_LEN);
|
2010-04-08 23:10:35 +00:00
|
|
|
skb_tstamp_tx(skb, &shhwtstamps);
|
|
|
|
bdp->lstatus &= BD_LFLAG(TXBD_WRAP);
|
|
|
|
bdp = next;
|
|
|
|
}
|
2008-11-12 16:07:11 +00:00
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
bdp->lstatus &= BD_LFLAG(TXBD_WRAP);
|
|
|
|
bdp = next_txbd(bdp, base, tx_ring_size);
|
2008-04-10 00:37:51 +00:00
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
for (i = 0; i < frags; i++) {
|
2012-06-05 03:42:13 +00:00
|
|
|
dma_unmap_page(&priv->ofdev->dev, bdp->bufPtr,
|
|
|
|
bdp->length, DMA_TO_DEVICE);
|
2008-12-18 00:51:04 +00:00
|
|
|
bdp->lstatus &= BD_LFLAG(TXBD_WRAP);
|
|
|
|
bdp = next_txbd(bdp, base, tx_ring_size);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-01-06 18:51:03 +00:00
|
|
|
bytes_sent += skb->len;
|
|
|
|
|
2012-10-05 06:23:55 +00:00
|
|
|
dev_kfree_skb_any(skb);
|
2009-02-05 00:43:16 +00:00
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
tx_queue->tx_skbuff[skb_dirtytx] = NULL;
|
2008-04-10 00:37:51 +00:00
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
skb_dirtytx = (skb_dirtytx + 1) &
|
2012-06-05 03:42:13 +00:00
|
|
|
TX_RING_MOD_MASK(tx_ring_size);
|
2008-12-18 00:51:04 +00:00
|
|
|
|
|
|
|
howmany++;
|
2009-11-10 14:11:10 +00:00
|
|
|
spin_lock_irqsave(&tx_queue->txlock, flags);
|
2010-04-08 23:10:35 +00:00
|
|
|
tx_queue->num_txbdfree += nr_txbds;
|
2009-11-10 14:11:10 +00:00
|
|
|
spin_unlock_irqrestore(&tx_queue->txlock, flags);
|
2008-12-18 00:51:04 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
/* If we freed a buffer, we can restart transmission, if necessary */
|
2012-03-18 21:11:22 +00:00
|
|
|
if (netif_tx_queue_stopped(txq) && tx_queue->num_txbdfree)
|
2012-01-06 18:51:03 +00:00
|
|
|
netif_wake_subqueue(dev, tqi);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-18 00:51:04 +00:00
|
|
|
/* Update dirty indicators */
|
2009-11-02 07:03:00 +00:00
|
|
|
tx_queue->skb_dirtytx = skb_dirtytx;
|
|
|
|
tx_queue->dirty_tx = bdp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-01-06 18:51:03 +00:00
|
|
|
netdev_tx_completed_queue(txq, howmany, bytes_sent);
|
|
|
|
|
2008-04-10 00:37:51 +00:00
|
|
|
return howmany;
|
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:09 +00:00
|
|
|
static void gfar_schedule_cleanup(struct gfar_priv_grp *gfargrp)
|
2008-04-10 00:37:51 +00:00
|
|
|
{
|
2009-01-13 05:57:34 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
spin_lock_irqsave(&gfargrp->grplock, flags);
|
|
|
|
if (napi_schedule_prep(&gfargrp->napi)) {
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(&gfargrp->regs->imask, IMASK_RTX_DISABLED);
|
2009-11-02 07:03:15 +00:00
|
|
|
__napi_schedule(&gfargrp->napi);
|
2009-02-09 22:59:30 +00:00
|
|
|
} else {
|
2012-06-05 03:42:12 +00:00
|
|
|
/* Clear IEVENT, so interrupts aren't called again
|
2009-02-09 22:59:30 +00:00
|
|
|
* because of the packets that have already arrived.
|
|
|
|
*/
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(&gfargrp->regs->ievent, IEVENT_RTX_MASK);
|
2008-03-24 15:53:28 +00:00
|
|
|
}
|
2009-11-02 07:03:15 +00:00
|
|
|
spin_unlock_irqrestore(&gfargrp->grplock, flags);
|
2009-01-13 05:57:34 +00:00
|
|
|
|
2008-12-18 00:52:00 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-18 00:52:00 +00:00
|
|
|
/* Interrupt Handler for Transmit complete */
|
2009-11-02 07:03:09 +00:00
|
|
|
static irqreturn_t gfar_transmit(int irq, void *grp_id)
|
2008-12-18 00:52:00 +00:00
|
|
|
{
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_schedule_cleanup((struct gfar_priv_grp *)grp_id);
|
2005-04-16 22:20:36 +00:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
static void gfar_new_rxbdp(struct gfar_priv_rx_q *rx_queue, struct rxbd8 *bdp,
|
2012-06-05 03:42:13 +00:00
|
|
|
struct sk_buff *skb)
|
2008-04-22 22:18:29 +00:00
|
|
|
{
|
2009-11-02 07:03:00 +00:00
|
|
|
struct net_device *dev = rx_queue->dev;
|
2008-04-22 22:18:29 +00:00
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-10-12 06:00:37 +00:00
|
|
|
dma_addr_t buf;
|
2008-04-22 22:18:29 +00:00
|
|
|
|
2009-10-12 06:00:37 +00:00
|
|
|
buf = dma_map_single(&priv->ofdev->dev, skb->data,
|
|
|
|
priv->rx_buffer_size, DMA_FROM_DEVICE);
|
2009-11-02 07:03:00 +00:00
|
|
|
gfar_init_rxbdp(rx_queue, bdp, buf);
|
2008-04-22 22:18:29 +00:00
|
|
|
}
|
|
|
|
|
2012-06-05 03:42:11 +00:00
|
|
|
static struct sk_buff *gfar_alloc_skb(struct net_device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2012-10-05 06:23:55 +00:00
|
|
|
struct sk_buff *skb;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-07-07 22:54:54 +00:00
|
|
|
skb = netdev_alloc_skb(dev, priv->rx_buffer_size + RXBUF_ALIGNMENT);
|
2008-04-22 22:18:29 +00:00
|
|
|
if (!skb)
|
2005-04-16 22:20:36 +00:00
|
|
|
return NULL;
|
|
|
|
|
2010-07-07 22:54:54 +00:00
|
|
|
gfar_align_skb(skb);
|
2005-11-11 18:38:59 +00:00
|
|
|
|
2010-07-07 22:54:54 +00:00
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
2012-06-05 03:42:11 +00:00
|
|
|
struct sk_buff *gfar_new_skb(struct net_device *dev)
|
2010-07-07 22:54:54 +00:00
|
|
|
{
|
2012-10-05 06:23:55 +00:00
|
|
|
return gfar_alloc_skb(dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-10-16 06:18:13 +00:00
|
|
|
static inline void count_errors(unsigned short status, struct net_device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-10-16 06:18:13 +00:00
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2007-10-04 00:41:50 +00:00
|
|
|
struct net_device_stats *stats = &dev->stats;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct gfar_extra_stats *estats = &priv->extra_stats;
|
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* If the packet was truncated, none of the other errors matter */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (status & RXBD_TRUNCATED) {
|
|
|
|
stats->rx_length_errors++;
|
|
|
|
|
|
|
|
estats->rx_trunc++;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Count the errors, if there were any */
|
|
|
|
if (status & (RXBD_LARGE | RXBD_SHORT)) {
|
|
|
|
stats->rx_length_errors++;
|
|
|
|
|
|
|
|
if (status & RXBD_LARGE)
|
|
|
|
estats->rx_large++;
|
|
|
|
else
|
|
|
|
estats->rx_short++;
|
|
|
|
}
|
|
|
|
if (status & RXBD_NONOCTET) {
|
|
|
|
stats->rx_frame_errors++;
|
|
|
|
estats->rx_nonoctet++;
|
|
|
|
}
|
|
|
|
if (status & RXBD_CRCERR) {
|
|
|
|
estats->rx_crcerr++;
|
|
|
|
stats->rx_crc_errors++;
|
|
|
|
}
|
|
|
|
if (status & RXBD_OVERRUN) {
|
|
|
|
estats->rx_overrun++;
|
|
|
|
stats->rx_crc_errors++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:09 +00:00
|
|
|
irqreturn_t gfar_receive(int irq, void *grp_id)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_schedule_cleanup((struct gfar_priv_grp *)grp_id);
|
2005-04-16 22:20:36 +00:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2005-06-20 15:54:21 +00:00
|
|
|
static inline void gfar_rx_checksum(struct sk_buff *skb, struct rxfcb *fcb)
|
|
|
|
{
|
|
|
|
/* If valid headers were found, and valid sums
|
|
|
|
* were verified, then we tell the kernel that no
|
2012-06-05 03:42:12 +00:00
|
|
|
* checksumming is necessary. Otherwise, it is [FIXME]
|
|
|
|
*/
|
2005-11-11 18:38:59 +00:00
|
|
|
if ((fcb->flags & RXFCB_CSUM_MASK) == (RXFCB_CIP | RXFCB_CTU))
|
2005-06-20 15:54:21 +00:00
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
|
|
|
else
|
2010-09-02 20:07:41 +00:00
|
|
|
skb_checksum_none_assert(skb);
|
2005-06-20 15:54:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* gfar_process_frame() -- handle one incoming packet if skb isn't NULL. */
|
2005-04-16 22:20:36 +00:00
|
|
|
static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
|
2012-04-19 22:54:35 +00:00
|
|
|
int amount_pull, struct napi_struct *napi)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2005-06-20 15:54:21 +00:00
|
|
|
struct rxfcb *fcb = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-04-19 22:54:35 +00:00
|
|
|
gro_result_t ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-16 23:31:15 +00:00
|
|
|
/* fcb is at the beginning if exists */
|
|
|
|
fcb = (struct rxfcb *)skb->data;
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* Remove the FCB from the skb
|
|
|
|
* Remove the padded bytes, if there are any
|
|
|
|
*/
|
2009-12-24 03:13:06 +00:00
|
|
|
if (amount_pull) {
|
|
|
|
skb_record_rx_queue(skb, fcb->rq);
|
2008-12-16 23:31:15 +00:00
|
|
|
skb_pull(skb, amount_pull);
|
2009-12-24 03:13:06 +00:00
|
|
|
}
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2010-04-08 23:10:03 +00:00
|
|
|
/* Get receive timestamp from the skb */
|
|
|
|
if (priv->hwts_rx_en) {
|
|
|
|
struct skb_shared_hwtstamps *shhwtstamps = skb_hwtstamps(skb);
|
|
|
|
u64 *ns = (u64 *) skb->data;
|
2012-06-05 03:42:13 +00:00
|
|
|
|
2010-04-08 23:10:03 +00:00
|
|
|
memset(shhwtstamps, 0, sizeof(*shhwtstamps));
|
|
|
|
shhwtstamps->hwtstamp = ns_to_ktime(*ns);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->padding)
|
|
|
|
skb_pull(skb, priv->padding);
|
|
|
|
|
2011-04-15 04:50:50 +00:00
|
|
|
if (dev->features & NETIF_F_RXCSUM)
|
2008-12-16 23:31:15 +00:00
|
|
|
gfar_rx_checksum(skb, fcb);
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2008-12-16 23:31:15 +00:00
|
|
|
/* Tell the skb what kind of packet this is */
|
|
|
|
skb->protocol = eth_type_trans(skb, dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* There's need to check for NETIF_F_HW_VLAN_RX here.
|
2011-08-10 01:19:48 +00:00
|
|
|
* Even if vlan rx accel is disabled, on some chips
|
|
|
|
* RXFCB_VLN is pseudo randomly set.
|
|
|
|
*/
|
|
|
|
if (dev->features & NETIF_F_HW_VLAN_RX &&
|
|
|
|
fcb->flags & RXFCB_VLN)
|
2011-07-20 04:54:19 +00:00
|
|
|
__vlan_hwaccel_put_tag(skb, fcb->vlctl);
|
|
|
|
|
2008-12-16 23:31:15 +00:00
|
|
|
/* Send the packet up the stack */
|
2012-04-19 22:54:35 +00:00
|
|
|
ret = napi_gro_receive(napi, skb);
|
2005-06-20 15:54:21 +00:00
|
|
|
|
2012-04-19 22:54:35 +00:00
|
|
|
if (GRO_DROP == ret)
|
2008-12-16 23:31:15 +00:00
|
|
|
priv->extra_stats.kernel_dropped++;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* gfar_clean_rx_ring() -- Processes each frame in the rx ring
|
2012-06-05 03:42:11 +00:00
|
|
|
* until the budget/quota has been reached. Returns the number
|
|
|
|
* of frames handled
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2009-11-02 07:03:00 +00:00
|
|
|
int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-11-02 07:03:00 +00:00
|
|
|
struct net_device *dev = rx_queue->dev;
|
2008-12-16 23:33:40 +00:00
|
|
|
struct rxbd8 *bdp, *base;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct sk_buff *skb;
|
2008-12-16 23:31:15 +00:00
|
|
|
int pkt_len;
|
|
|
|
int amount_pull;
|
2005-04-16 22:20:36 +00:00
|
|
|
int howmany = 0;
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
|
|
|
|
|
|
|
/* Get the first full descriptor */
|
2009-11-02 07:03:00 +00:00
|
|
|
bdp = rx_queue->cur_rx;
|
|
|
|
base = rx_queue->rx_bd_base;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-04-08 23:10:03 +00:00
|
|
|
amount_pull = (gfar_uses_fcb(priv) ? GMAC_FCB_LEN : 0);
|
2008-12-16 23:31:15 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
while (!((bdp->status & RXBD_EMPTY) || (--rx_work_limit < 0))) {
|
2008-04-22 22:18:29 +00:00
|
|
|
struct sk_buff *newskb;
|
2012-06-05 03:42:13 +00:00
|
|
|
|
2007-05-16 20:06:59 +00:00
|
|
|
rmb();
|
2008-04-22 22:18:29 +00:00
|
|
|
|
|
|
|
/* Add another skb for the future */
|
|
|
|
newskb = gfar_new_skb(dev);
|
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
skb = rx_queue->rx_skbuff[rx_queue->skb_currx];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-19 06:28:22 +00:00
|
|
|
dma_unmap_single(&priv->ofdev->dev, bdp->bufPtr,
|
2012-06-05 03:42:13 +00:00
|
|
|
priv->rx_buffer_size, DMA_FROM_DEVICE);
|
2008-11-12 16:07:11 +00:00
|
|
|
|
2010-06-11 10:51:03 +00:00
|
|
|
if (unlikely(!(bdp->status & RXBD_ERR) &&
|
2012-06-05 03:42:13 +00:00
|
|
|
bdp->length > priv->rx_buffer_size))
|
2010-06-11 10:51:03 +00:00
|
|
|
bdp->status = RXBD_LARGE;
|
|
|
|
|
2008-04-22 22:18:29 +00:00
|
|
|
/* We drop the frame if we failed to allocate a new buffer */
|
|
|
|
if (unlikely(!newskb || !(bdp->status & RXBD_LAST) ||
|
2012-06-05 03:42:13 +00:00
|
|
|
bdp->status & RXBD_ERR)) {
|
2008-04-22 22:18:29 +00:00
|
|
|
count_errors(bdp->status, dev);
|
|
|
|
|
|
|
|
if (unlikely(!newskb))
|
|
|
|
newskb = skb;
|
2010-07-07 22:54:54 +00:00
|
|
|
else if (skb)
|
2012-10-05 06:23:55 +00:00
|
|
|
dev_kfree_skb(skb);
|
2008-04-22 22:18:29 +00:00
|
|
|
} else {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Increment the number of packets */
|
2009-12-16 01:15:07 +00:00
|
|
|
rx_queue->stats.rx_packets++;
|
2005-04-16 22:20:36 +00:00
|
|
|
howmany++;
|
|
|
|
|
2008-12-16 23:31:15 +00:00
|
|
|
if (likely(skb)) {
|
|
|
|
pkt_len = bdp->length - ETH_FCS_LEN;
|
|
|
|
/* Remove the FCS from the packet length */
|
|
|
|
skb_put(skb, pkt_len);
|
2009-12-16 01:15:07 +00:00
|
|
|
rx_queue->stats.rx_bytes += pkt_len;
|
2009-12-24 03:13:06 +00:00
|
|
|
skb_record_rx_queue(skb, rx_queue->qindex);
|
2012-04-19 22:54:35 +00:00
|
|
|
gfar_process_frame(dev, skb, amount_pull,
|
2012-06-05 03:42:13 +00:00
|
|
|
&rx_queue->grp->napi);
|
2008-12-16 23:31:15 +00:00
|
|
|
|
|
|
|
} else {
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_warn(priv, rx_err, dev, "Missing skb!\n");
|
2009-12-16 01:15:07 +00:00
|
|
|
rx_queue->stats.rx_dropped++;
|
2008-12-16 23:31:15 +00:00
|
|
|
priv->extra_stats.rx_skbmissing++;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
rx_queue->rx_skbuff[rx_queue->skb_currx] = newskb;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-22 22:18:29 +00:00
|
|
|
/* Setup the new bdp */
|
2009-11-02 07:03:00 +00:00
|
|
|
gfar_new_rxbdp(rx_queue, bdp, newskb);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Update to the next pointer */
|
2009-11-02 07:03:00 +00:00
|
|
|
bdp = next_bd(bdp, base, rx_queue->rx_ring_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* update to point at the next skb */
|
2012-06-05 03:42:13 +00:00
|
|
|
rx_queue->skb_currx = (rx_queue->skb_currx + 1) &
|
|
|
|
RX_RING_MOD_MASK(rx_queue->rx_ring_size);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Update the current rxbd pointer to be the next one */
|
2009-11-02 07:03:00 +00:00
|
|
|
rx_queue->cur_rx = bdp;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return howmany;
|
|
|
|
}
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-03 23:41:36 +00:00
|
|
|
static int gfar_poll(struct napi_struct *napi, int budget)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2012-06-05 03:42:13 +00:00
|
|
|
struct gfar_priv_grp *gfargrp =
|
|
|
|
container_of(napi, struct gfar_priv_grp, napi);
|
2009-11-02 07:03:15 +00:00
|
|
|
struct gfar_private *priv = gfargrp->priv;
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = gfargrp->regs;
|
2009-11-02 07:03:00 +00:00
|
|
|
struct gfar_priv_tx_q *tx_queue = NULL;
|
2009-11-02 07:03:15 +00:00
|
|
|
struct gfar_priv_rx_q *rx_queue = NULL;
|
|
|
|
int rx_cleaned = 0, budget_per_queue = 0, rx_cleaned_per_queue = 0;
|
2009-11-04 12:53:00 +00:00
|
|
|
int tx_cleaned = 0, i, left_over_budget = budget;
|
|
|
|
unsigned long serviced_queues = 0;
|
2009-11-02 07:03:15 +00:00
|
|
|
int num_queues = 0;
|
2008-04-10 00:37:51 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
num_queues = gfargrp->num_rx_queues;
|
|
|
|
budget_per_queue = budget/num_queues;
|
|
|
|
|
2008-12-18 00:52:00 +00:00
|
|
|
/* Clear IEVENT, so interrupts aren't called again
|
2012-06-05 03:42:12 +00:00
|
|
|
* because of the packets that have already arrived
|
|
|
|
*/
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->ievent, IEVENT_RTX_MASK);
|
2008-12-18 00:52:00 +00:00
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
while (num_queues && left_over_budget) {
|
|
|
|
budget_per_queue = left_over_budget/num_queues;
|
|
|
|
left_over_budget = 0;
|
|
|
|
|
2010-03-05 21:41:37 +00:00
|
|
|
for_each_set_bit(i, &gfargrp->rx_bit_map, priv->num_rx_queues) {
|
2009-11-02 07:03:15 +00:00
|
|
|
if (test_bit(i, &serviced_queues))
|
|
|
|
continue;
|
|
|
|
rx_queue = priv->rx_queue[i];
|
|
|
|
tx_queue = priv->tx_queue[rx_queue->qindex];
|
|
|
|
|
2009-11-10 14:11:10 +00:00
|
|
|
tx_cleaned += gfar_clean_tx_ring(tx_queue);
|
2012-06-05 03:42:13 +00:00
|
|
|
rx_cleaned_per_queue =
|
|
|
|
gfar_clean_rx_ring(rx_queue, budget_per_queue);
|
2009-11-02 07:03:15 +00:00
|
|
|
rx_cleaned += rx_cleaned_per_queue;
|
2012-06-05 03:42:13 +00:00
|
|
|
if (rx_cleaned_per_queue < budget_per_queue) {
|
2009-11-02 07:03:15 +00:00
|
|
|
left_over_budget = left_over_budget +
|
2012-06-05 03:42:13 +00:00
|
|
|
(budget_per_queue -
|
|
|
|
rx_cleaned_per_queue);
|
2009-11-02 07:03:15 +00:00
|
|
|
set_bit(i, &serviced_queues);
|
|
|
|
num_queues--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-18 00:52:30 +00:00
|
|
|
if (tx_cleaned)
|
|
|
|
return budget;
|
|
|
|
|
|
|
|
if (rx_cleaned < budget) {
|
2009-01-20 00:43:59 +00:00
|
|
|
napi_complete(napi);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Clear the halt bit in RSTAT */
|
2009-11-02 07:03:15 +00:00
|
|
|
gfar_write(®s->rstat, gfargrp->rstat);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->imask, IMASK_DEFAULT);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* If we are coalescing interrupts, update the timer
|
|
|
|
* Otherwise, clear it
|
|
|
|
*/
|
2012-06-05 03:42:13 +00:00
|
|
|
gfar_configure_coalescing(priv, gfargrp->rx_bit_map,
|
|
|
|
gfargrp->tx_bit_map);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-12-18 00:52:30 +00:00
|
|
|
return rx_cleaned;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-11-07 10:27:02 +00:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
2012-06-05 03:42:12 +00:00
|
|
|
/* Polling 'interrupt' - used by things like netconsole to send skbs
|
2006-11-07 10:27:02 +00:00
|
|
|
* without having to re-enable interrupts. It's not called while
|
|
|
|
* the interrupt routine is executing.
|
|
|
|
*/
|
|
|
|
static void gfar_netpoll(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2012-06-05 03:42:14 +00:00
|
|
|
int i;
|
2006-11-07 10:27:02 +00:00
|
|
|
|
|
|
|
/* If the device has multiple interrupts, run tx/rx */
|
2008-12-16 23:29:15 +00:00
|
|
|
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
|
2009-11-02 07:03:34 +00:00
|
|
|
for (i = 0; i < priv->num_grps; i++) {
|
|
|
|
disable_irq(priv->gfargrp[i].interruptTransmit);
|
|
|
|
disable_irq(priv->gfargrp[i].interruptReceive);
|
|
|
|
disable_irq(priv->gfargrp[i].interruptError);
|
|
|
|
gfar_interrupt(priv->gfargrp[i].interruptTransmit,
|
2012-06-05 03:42:13 +00:00
|
|
|
&priv->gfargrp[i]);
|
2009-11-02 07:03:34 +00:00
|
|
|
enable_irq(priv->gfargrp[i].interruptError);
|
|
|
|
enable_irq(priv->gfargrp[i].interruptReceive);
|
|
|
|
enable_irq(priv->gfargrp[i].interruptTransmit);
|
|
|
|
}
|
2006-11-07 10:27:02 +00:00
|
|
|
} else {
|
2009-11-02 07:03:34 +00:00
|
|
|
for (i = 0; i < priv->num_grps; i++) {
|
|
|
|
disable_irq(priv->gfargrp[i].interruptTransmit);
|
|
|
|
gfar_interrupt(priv->gfargrp[i].interruptTransmit,
|
2012-06-05 03:42:13 +00:00
|
|
|
&priv->gfargrp[i]);
|
2009-11-02 07:03:34 +00:00
|
|
|
enable_irq(priv->gfargrp[i].interruptTransmit);
|
2009-12-09 10:52:19 +00:00
|
|
|
}
|
2006-11-07 10:27:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* The interrupt handler for devices with one interrupt */
|
2009-11-02 07:03:09 +00:00
|
|
|
static irqreturn_t gfar_interrupt(int irq, void *grp_id)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-11-02 07:03:09 +00:00
|
|
|
struct gfar_priv_grp *gfargrp = grp_id;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Save ievent for future reference */
|
2009-11-02 07:03:09 +00:00
|
|
|
u32 events = gfar_read(&gfargrp->regs->ievent);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Check for reception */
|
2007-02-15 13:56:01 +00:00
|
|
|
if (events & IEVENT_RX_MASK)
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_receive(irq, grp_id);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Check for transmit completion */
|
2007-02-15 13:56:01 +00:00
|
|
|
if (events & IEVENT_TX_MASK)
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_transmit(irq, grp_id);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-15 13:56:01 +00:00
|
|
|
/* Check for errors */
|
|
|
|
if (events & IEVENT_ERR_MASK)
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_error(irq, grp_id);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Called every time the controller might need to be made
|
|
|
|
* aware of new link state. The PHY code conveys this
|
2005-09-24 02:54:21 +00:00
|
|
|
* information through variables in the phydev structure, and this
|
2005-04-16 22:20:36 +00:00
|
|
|
* function converts those variables into the appropriate
|
|
|
|
* register values, and can bring down the device if needed.
|
|
|
|
*/
|
|
|
|
static void adjust_link(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = priv->gfargrp[0].regs;
|
2005-09-24 02:54:21 +00:00
|
|
|
unsigned long flags;
|
|
|
|
struct phy_device *phydev = priv->phydev;
|
|
|
|
int new_state = 0;
|
|
|
|
|
2009-11-02 07:03:15 +00:00
|
|
|
local_irq_save(flags);
|
|
|
|
lock_tx_qs(priv);
|
|
|
|
|
2005-09-24 02:54:21 +00:00
|
|
|
if (phydev->link) {
|
|
|
|
u32 tempval = gfar_read(®s->maccfg2);
|
2005-11-11 18:38:59 +00:00
|
|
|
u32 ecntrl = gfar_read(®s->ecntrl);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Now we make sure that we can be in full duplex mode.
|
2012-06-05 03:42:12 +00:00
|
|
|
* If not, we operate in half-duplex mode.
|
|
|
|
*/
|
2005-09-24 02:54:21 +00:00
|
|
|
if (phydev->duplex != priv->oldduplex) {
|
|
|
|
new_state = 1;
|
|
|
|
if (!(phydev->duplex))
|
2005-04-16 22:20:36 +00:00
|
|
|
tempval &= ~(MACCFG2_FULL_DUPLEX);
|
2005-09-24 02:54:21 +00:00
|
|
|
else
|
2005-04-16 22:20:36 +00:00
|
|
|
tempval |= MACCFG2_FULL_DUPLEX;
|
|
|
|
|
2005-09-24 02:54:21 +00:00
|
|
|
priv->oldduplex = phydev->duplex;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-09-24 02:54:21 +00:00
|
|
|
if (phydev->speed != priv->oldspeed) {
|
|
|
|
new_state = 1;
|
|
|
|
switch (phydev->speed) {
|
2005-04-16 22:20:36 +00:00
|
|
|
case 1000:
|
|
|
|
tempval =
|
|
|
|
((tempval & ~(MACCFG2_IF)) | MACCFG2_GMII);
|
2009-01-06 22:08:10 +00:00
|
|
|
|
|
|
|
ecntrl &= ~(ECNTRL_R100);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case 100:
|
|
|
|
case 10:
|
|
|
|
tempval =
|
|
|
|
((tempval & ~(MACCFG2_IF)) | MACCFG2_MII);
|
2005-11-11 18:38:59 +00:00
|
|
|
|
|
|
|
/* Reduced mode distinguishes
|
2012-06-05 03:42:12 +00:00
|
|
|
* between 10 and 100
|
|
|
|
*/
|
2005-11-11 18:38:59 +00:00
|
|
|
if (phydev->speed == SPEED_100)
|
|
|
|
ecntrl |= ECNTRL_R100;
|
|
|
|
else
|
|
|
|
ecntrl &= ~(ECNTRL_R100);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_warn(priv, link, dev,
|
|
|
|
"Ack! Speed (%d) is not 10/100/1000!\n",
|
|
|
|
phydev->speed);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-09-24 02:54:21 +00:00
|
|
|
priv->oldspeed = phydev->speed;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-09-24 02:54:21 +00:00
|
|
|
gfar_write(®s->maccfg2, tempval);
|
2005-11-11 18:38:59 +00:00
|
|
|
gfar_write(®s->ecntrl, ecntrl);
|
2005-09-24 02:54:21 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!priv->oldlink) {
|
2005-09-24 02:54:21 +00:00
|
|
|
new_state = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
priv->oldlink = 1;
|
|
|
|
}
|
2005-09-24 02:54:21 +00:00
|
|
|
} else if (priv->oldlink) {
|
|
|
|
new_state = 1;
|
|
|
|
priv->oldlink = 0;
|
|
|
|
priv->oldspeed = 0;
|
|
|
|
priv->oldduplex = -1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-09-24 02:54:21 +00:00
|
|
|
if (new_state && netif_msg_link(priv))
|
|
|
|
phy_print_status(phydev);
|
2009-11-02 07:03:15 +00:00
|
|
|
unlock_tx_qs(priv);
|
|
|
|
local_irq_restore(flags);
|
2005-09-24 02:54:21 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Update the hash table based on the current list of multicast
|
|
|
|
* addresses we subscribe to. Also, change the promiscuity of
|
|
|
|
* the device based on the flags (this function is called
|
2012-06-05 03:42:12 +00:00
|
|
|
* whenever dev->flags is changed
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
static void gfar_set_multi(struct net_device *dev)
|
|
|
|
{
|
2010-04-01 21:22:57 +00:00
|
|
|
struct netdev_hw_addr *ha;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = priv->gfargrp[0].regs;
|
2005-04-16 22:20:36 +00:00
|
|
|
u32 tempval;
|
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
if (dev->flags & IFF_PROMISC) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Set RCTRL to PROM */
|
|
|
|
tempval = gfar_read(®s->rctrl);
|
|
|
|
tempval |= RCTRL_PROM;
|
|
|
|
gfar_write(®s->rctrl, tempval);
|
|
|
|
} else {
|
|
|
|
/* Set RCTRL to not PROM */
|
|
|
|
tempval = gfar_read(®s->rctrl);
|
|
|
|
tempval &= ~(RCTRL_PROM);
|
|
|
|
gfar_write(®s->rctrl, tempval);
|
|
|
|
}
|
2006-09-13 17:24:59 +00:00
|
|
|
|
2009-11-02 07:03:00 +00:00
|
|
|
if (dev->flags & IFF_ALLMULTI) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Set the hash to rx all multicast frames */
|
2005-06-20 15:54:21 +00:00
|
|
|
gfar_write(®s->igaddr0, 0xffffffff);
|
|
|
|
gfar_write(®s->igaddr1, 0xffffffff);
|
|
|
|
gfar_write(®s->igaddr2, 0xffffffff);
|
|
|
|
gfar_write(®s->igaddr3, 0xffffffff);
|
|
|
|
gfar_write(®s->igaddr4, 0xffffffff);
|
|
|
|
gfar_write(®s->igaddr5, 0xffffffff);
|
|
|
|
gfar_write(®s->igaddr6, 0xffffffff);
|
|
|
|
gfar_write(®s->igaddr7, 0xffffffff);
|
2005-04-16 22:20:36 +00:00
|
|
|
gfar_write(®s->gaddr0, 0xffffffff);
|
|
|
|
gfar_write(®s->gaddr1, 0xffffffff);
|
|
|
|
gfar_write(®s->gaddr2, 0xffffffff);
|
|
|
|
gfar_write(®s->gaddr3, 0xffffffff);
|
|
|
|
gfar_write(®s->gaddr4, 0xffffffff);
|
|
|
|
gfar_write(®s->gaddr5, 0xffffffff);
|
|
|
|
gfar_write(®s->gaddr6, 0xffffffff);
|
|
|
|
gfar_write(®s->gaddr7, 0xffffffff);
|
|
|
|
} else {
|
2005-11-11 18:38:59 +00:00
|
|
|
int em_num;
|
|
|
|
int idx;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* zero out the hash */
|
2005-06-20 15:54:21 +00:00
|
|
|
gfar_write(®s->igaddr0, 0x0);
|
|
|
|
gfar_write(®s->igaddr1, 0x0);
|
|
|
|
gfar_write(®s->igaddr2, 0x0);
|
|
|
|
gfar_write(®s->igaddr3, 0x0);
|
|
|
|
gfar_write(®s->igaddr4, 0x0);
|
|
|
|
gfar_write(®s->igaddr5, 0x0);
|
|
|
|
gfar_write(®s->igaddr6, 0x0);
|
|
|
|
gfar_write(®s->igaddr7, 0x0);
|
2005-04-16 22:20:36 +00:00
|
|
|
gfar_write(®s->gaddr0, 0x0);
|
|
|
|
gfar_write(®s->gaddr1, 0x0);
|
|
|
|
gfar_write(®s->gaddr2, 0x0);
|
|
|
|
gfar_write(®s->gaddr3, 0x0);
|
|
|
|
gfar_write(®s->gaddr4, 0x0);
|
|
|
|
gfar_write(®s->gaddr5, 0x0);
|
|
|
|
gfar_write(®s->gaddr6, 0x0);
|
|
|
|
gfar_write(®s->gaddr7, 0x0);
|
|
|
|
|
2005-11-11 18:38:59 +00:00
|
|
|
/* If we have extended hash tables, we need to
|
|
|
|
* clear the exact match registers to prepare for
|
2012-06-05 03:42:12 +00:00
|
|
|
* setting them
|
|
|
|
*/
|
2005-11-11 18:38:59 +00:00
|
|
|
if (priv->extended_hash) {
|
|
|
|
em_num = GFAR_EM_NUM + 1;
|
|
|
|
gfar_clear_exact_match(dev);
|
|
|
|
idx = 1;
|
|
|
|
} else {
|
|
|
|
idx = 0;
|
|
|
|
em_num = 0;
|
|
|
|
}
|
|
|
|
|
2010-02-08 04:30:35 +00:00
|
|
|
if (netdev_mc_empty(dev))
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* Parse the list, and set the appropriate bits */
|
2010-04-01 21:22:57 +00:00
|
|
|
netdev_for_each_mc_addr(ha, dev) {
|
2005-11-11 18:38:59 +00:00
|
|
|
if (idx < em_num) {
|
2010-04-01 21:22:57 +00:00
|
|
|
gfar_set_mac_for_addr(dev, idx, ha->addr);
|
2005-11-11 18:38:59 +00:00
|
|
|
idx++;
|
|
|
|
} else
|
2010-04-01 21:22:57 +00:00
|
|
|
gfar_set_hash_for_addr(dev, ha->addr);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-11 18:38:59 +00:00
|
|
|
|
|
|
|
/* Clears each of the exact match registers to zero, so they
|
2012-06-05 03:42:12 +00:00
|
|
|
* don't interfere with normal reception
|
|
|
|
*/
|
2005-11-11 18:38:59 +00:00
|
|
|
static void gfar_clear_exact_match(struct net_device *dev)
|
|
|
|
{
|
|
|
|
int idx;
|
2011-11-16 09:38:02 +00:00
|
|
|
static const u8 zero_arr[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
|
2005-11-11 18:38:59 +00:00
|
|
|
|
2012-06-05 03:42:13 +00:00
|
|
|
for (idx = 1; idx < GFAR_EM_NUM + 1; idx++)
|
2010-12-21 10:16:08 +00:00
|
|
|
gfar_set_mac_for_addr(dev, idx, zero_arr);
|
2005-11-11 18:38:59 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Set the appropriate hash bit for the given addr */
|
|
|
|
/* The algorithm works like so:
|
|
|
|
* 1) Take the Destination Address (ie the multicast address), and
|
|
|
|
* do a CRC on it (little endian), and reverse the bits of the
|
|
|
|
* result.
|
|
|
|
* 2) Use the 8 most significant bits as a hash into a 256-entry
|
|
|
|
* table. The table is controlled through 8 32-bit registers:
|
|
|
|
* gaddr0-7. gaddr0's MSB is entry 0, and gaddr7's LSB is
|
|
|
|
* gaddr7. This means that the 3 most significant bits in the
|
|
|
|
* hash index which gaddr register to use, and the 5 other bits
|
|
|
|
* indicate which bit (assuming an IBM numbering scheme, which
|
|
|
|
* for PowerPC (tm) is usually the case) in the register holds
|
2012-06-05 03:42:12 +00:00
|
|
|
* the entry.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
static void gfar_set_hash_for_addr(struct net_device *dev, u8 *addr)
|
|
|
|
{
|
|
|
|
u32 tempval;
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2011-11-16 09:38:02 +00:00
|
|
|
u32 result = ether_crc(ETH_ALEN, addr);
|
2005-06-20 15:54:21 +00:00
|
|
|
int width = priv->hash_width;
|
|
|
|
u8 whichbit = (result >> (32 - width)) & 0x1f;
|
|
|
|
u8 whichreg = result >> (32 - width + 5);
|
2005-04-16 22:20:36 +00:00
|
|
|
u32 value = (1 << (31-whichbit));
|
|
|
|
|
2005-06-20 15:54:21 +00:00
|
|
|
tempval = gfar_read(priv->hash_regs[whichreg]);
|
2005-04-16 22:20:36 +00:00
|
|
|
tempval |= value;
|
2005-06-20 15:54:21 +00:00
|
|
|
gfar_write(priv->hash_regs[whichreg], tempval);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-11-11 18:38:59 +00:00
|
|
|
|
|
|
|
/* There are multiple MAC Address register pairs on some controllers
|
|
|
|
* This function sets the numth pair to a given address
|
|
|
|
*/
|
2010-12-21 10:16:08 +00:00
|
|
|
static void gfar_set_mac_for_addr(struct net_device *dev, int num,
|
|
|
|
const u8 *addr)
|
2005-11-11 18:38:59 +00:00
|
|
|
{
|
|
|
|
struct gfar_private *priv = netdev_priv(dev);
|
2009-11-02 07:03:34 +00:00
|
|
|
struct gfar __iomem *regs = priv->gfargrp[0].regs;
|
2005-11-11 18:38:59 +00:00
|
|
|
int idx;
|
2011-11-16 09:38:02 +00:00
|
|
|
char tmpbuf[ETH_ALEN];
|
2005-11-11 18:38:59 +00:00
|
|
|
u32 tempval;
|
2009-11-02 07:03:09 +00:00
|
|
|
u32 __iomem *macptr = ®s->macstnaddr1;
|
2005-11-11 18:38:59 +00:00
|
|
|
|
|
|
|
macptr += num*2;
|
|
|
|
|
2012-06-05 03:42:12 +00:00
|
|
|
/* Now copy it into the mac registers backwards, cuz
|
|
|
|
* little endian is silly
|
|
|
|
*/
|
2011-11-16 09:38:02 +00:00
|
|
|
for (idx = 0; idx < ETH_ALEN; idx++)
|
|
|
|
tmpbuf[ETH_ALEN - 1 - idx] = addr[idx];
|
2005-11-11 18:38:59 +00:00
|
|
|
|
|
|
|
gfar_write(macptr, *((u32 *) (tmpbuf)));
|
|
|
|
|
|
|
|
tempval = *((u32 *) (tmpbuf + 4));
|
|
|
|
|
|
|
|
gfar_write(macptr+1, tempval);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* GFAR error interrupt handler */
|
2009-11-02 07:03:09 +00:00
|
|
|
static irqreturn_t gfar_error(int irq, void *grp_id)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-11-02 07:03:09 +00:00
|
|
|
struct gfar_priv_grp *gfargrp = grp_id;
|
|
|
|
struct gfar __iomem *regs = gfargrp->regs;
|
|
|
|
struct gfar_private *priv= gfargrp->priv;
|
|
|
|
struct net_device *dev = priv->ndev;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Save ievent for future reference */
|
2009-11-02 07:03:09 +00:00
|
|
|
u32 events = gfar_read(®s->ievent);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Clear IEVENT */
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_write(®s->ievent, events & IEVENT_ERR_MASK);
|
2008-07-11 23:04:45 +00:00
|
|
|
|
|
|
|
/* Magic Packet is not an error. */
|
2008-12-16 23:29:15 +00:00
|
|
|
if ((priv->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET) &&
|
2008-07-11 23:04:45 +00:00
|
|
|
(events & IEVENT_MAG))
|
|
|
|
events &= ~IEVENT_MAG;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Hmm... */
|
2005-06-20 15:54:21 +00:00
|
|
|
if (netif_msg_rx_err(priv) || netif_msg_tx_err(priv))
|
2012-06-05 03:42:13 +00:00
|
|
|
netdev_dbg(dev,
|
|
|
|
"error interrupt (ievent=0x%08x imask=0x%08x)\n",
|
2011-06-14 08:57:47 +00:00
|
|
|
events, gfar_read(®s->imask));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Update the error counters */
|
|
|
|
if (events & IEVENT_TXE) {
|
2007-10-04 00:41:50 +00:00
|
|
|
dev->stats.tx_errors++;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (events & IEVENT_LC)
|
2007-10-04 00:41:50 +00:00
|
|
|
dev->stats.tx_window_errors++;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (events & IEVENT_CRL)
|
2007-10-04 00:41:50 +00:00
|
|
|
dev->stats.tx_aborted_errors++;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (events & IEVENT_XFUN) {
|
2009-11-10 14:11:08 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_dbg(priv, tx_err, dev,
|
|
|
|
"TX FIFO underrun, packet dropped\n");
|
2007-10-04 00:41:50 +00:00
|
|
|
dev->stats.tx_dropped++;
|
2005-04-16 22:20:36 +00:00
|
|
|
priv->extra_stats.tx_underrun++;
|
|
|
|
|
2009-11-10 14:11:08 +00:00
|
|
|
local_irq_save(flags);
|
|
|
|
lock_tx_qs(priv);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Reactivate the Tx Queues */
|
2009-11-02 07:03:15 +00:00
|
|
|
gfar_write(®s->tstat, gfargrp->tstat);
|
2009-11-10 14:11:08 +00:00
|
|
|
|
|
|
|
unlock_tx_qs(priv);
|
|
|
|
local_irq_restore(flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_dbg(priv, tx_err, dev, "Transmit Error\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (events & IEVENT_BSY) {
|
2007-10-04 00:41:50 +00:00
|
|
|
dev->stats.rx_errors++;
|
2005-04-16 22:20:36 +00:00
|
|
|
priv->extra_stats.rx_bsy++;
|
|
|
|
|
2009-11-02 07:03:09 +00:00
|
|
|
gfar_receive(irq, grp_id);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_dbg(priv, rx_err, dev, "busy error (rstat: %x)\n",
|
|
|
|
gfar_read(®s->rstat));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (events & IEVENT_BABR) {
|
2007-10-04 00:41:50 +00:00
|
|
|
dev->stats.rx_errors++;
|
2005-04-16 22:20:36 +00:00
|
|
|
priv->extra_stats.rx_babr++;
|
|
|
|
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_dbg(priv, rx_err, dev, "babbling RX error\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (events & IEVENT_EBERR) {
|
|
|
|
priv->extra_stats.eberr++;
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_dbg(priv, rx_err, dev, "bus error\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2011-06-14 08:57:47 +00:00
|
|
|
if (events & IEVENT_RXC)
|
|
|
|
netif_dbg(priv, rx_status, dev, "control frame\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (events & IEVENT_BABT) {
|
|
|
|
priv->extra_stats.tx_babt++;
|
2011-06-14 08:57:47 +00:00
|
|
|
netif_dbg(priv, tx_err, dev, "babbling TX error\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2008-12-16 23:29:15 +00:00
|
|
|
static struct of_device_id gfar_match[] =
|
|
|
|
{
|
|
|
|
{
|
|
|
|
.type = "network",
|
|
|
|
.compatible = "gianfar",
|
|
|
|
},
|
2009-11-02 07:03:34 +00:00
|
|
|
{
|
|
|
|
.compatible = "fsl,etsec2",
|
|
|
|
},
|
2008-12-16 23:29:15 +00:00
|
|
|
{},
|
|
|
|
};
|
2009-10-14 21:54:52 +00:00
|
|
|
MODULE_DEVICE_TABLE(of, gfar_match);
|
2008-12-16 23:29:15 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Structure for a device driver */
|
2011-02-23 04:05:51 +00:00
|
|
|
static struct platform_driver gfar_driver = {
|
2010-04-13 23:13:02 +00:00
|
|
|
.driver = {
|
|
|
|
.name = "fsl-gianfar",
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.pm = GFAR_PM_OPS,
|
|
|
|
.of_match_table = gfar_match,
|
|
|
|
},
|
2005-04-16 22:20:36 +00:00
|
|
|
.probe = gfar_probe,
|
|
|
|
.remove = gfar_remove,
|
|
|
|
};
|
|
|
|
|
2011-11-27 16:44:17 +00:00
|
|
|
module_platform_driver(gfar_driver);
|