2005-04-16 16:20:36 -06:00
|
|
|
/**************************************************************************/
|
|
|
|
/* */
|
|
|
|
/* IBM eServer i/pSeries Virtual Ethernet Device Driver */
|
|
|
|
/* Copyright (C) 2003 IBM Corp. */
|
|
|
|
/* Originally written by Dave Larson (larson1@us.ibm.com) */
|
|
|
|
/* Maintained by Santiago Leon (santil@us.ibm.com) */
|
|
|
|
/* */
|
|
|
|
/* This program is free software; you can redistribute it and/or modify */
|
|
|
|
/* it under the terms of the GNU General Public License as published by */
|
|
|
|
/* the Free Software Foundation; either version 2 of the License, or */
|
|
|
|
/* (at your option) any later version. */
|
|
|
|
/* */
|
|
|
|
/* This program is distributed in the hope that it will be useful, */
|
|
|
|
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
|
|
|
|
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
|
|
|
|
/* GNU General Public License for more details. */
|
|
|
|
/* */
|
|
|
|
/* You should have received a copy of the GNU General Public License */
|
|
|
|
/* along with this program; if not, write to the Free Software */
|
|
|
|
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */
|
|
|
|
/* USA */
|
|
|
|
/* */
|
|
|
|
/* This module contains the implementation of a virtual ethernet device */
|
|
|
|
/* for use with IBM i/pSeries LPAR Linux. It utilizes the logical LAN */
|
|
|
|
/* option of the RS/6000 Platform Architechture to interface with virtual */
|
|
|
|
/* ethernet NICs that are presented to the partition by the hypervisor. */
|
2006-05-23 23:31:14 -06:00
|
|
|
/* */
|
2005-04-16 16:20:36 -06:00
|
|
|
/**************************************************************************/
|
|
|
|
/*
|
|
|
|
TODO:
|
|
|
|
- add support for sysfs
|
|
|
|
- possibly remove procfs support
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
2008-07-23 12:34:52 -06:00
|
|
|
#include <linux/moduleparam.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/ethtool.h>
|
|
|
|
#include <linux/proc_fs.h>
|
2007-09-15 14:36:07 -06:00
|
|
|
#include <linux/in.h>
|
|
|
|
#include <linux/ip.h>
|
2007-09-12 04:01:34 -06:00
|
|
|
#include <net/net_namespace.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/hvcall.h>
|
|
|
|
#include <asm/atomic.h>
|
|
|
|
#include <asm/vio.h>
|
2008-07-23 12:34:52 -06:00
|
|
|
#include <asm/iommu.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/uaccess.h>
|
2008-07-23 12:34:52 -06:00
|
|
|
#include <asm/firmware.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/seq_file.h>
|
|
|
|
|
|
|
|
#include "ibmveth.h"
|
|
|
|
|
2005-11-10 20:02:04 -07:00
|
|
|
#undef DEBUG
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define ibmveth_printk(fmt, args...) \
|
2006-04-12 14:22:29 -06:00
|
|
|
printk(KERN_DEBUG "%s: " fmt, __FILE__, ## args)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define ibmveth_error_printk(fmt, args...) \
|
|
|
|
printk(KERN_ERR "(%s:%3.3d ua:%x) ERROR: " fmt, __FILE__, __LINE__ , adapter->vdev->unit_address, ## args)
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
#define ibmveth_debug_printk_no_adapter(fmt, args...) \
|
|
|
|
printk(KERN_DEBUG "(%s:%3.3d): " fmt, __FILE__, __LINE__ , ## args)
|
|
|
|
#define ibmveth_debug_printk(fmt, args...) \
|
|
|
|
printk(KERN_DEBUG "(%s:%3.3d ua:%x): " fmt, __FILE__, __LINE__ , adapter->vdev->unit_address, ## args)
|
|
|
|
#define ibmveth_assert(expr) \
|
|
|
|
if(!(expr)) { \
|
|
|
|
printk(KERN_DEBUG "assertion failed (%s:%3.3d ua:%x): %s\n", __FILE__, __LINE__, adapter->vdev->unit_address, #expr); \
|
|
|
|
BUG(); \
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define ibmveth_debug_printk_no_adapter(fmt, args...)
|
|
|
|
#define ibmveth_debug_printk(fmt, args...)
|
2006-05-23 23:31:14 -06:00
|
|
|
#define ibmveth_assert(expr)
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
static int ibmveth_open(struct net_device *dev);
|
|
|
|
static int ibmveth_close(struct net_device *dev);
|
|
|
|
static int ibmveth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
|
[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 17:41:36 -06:00
|
|
|
static int ibmveth_poll(struct napi_struct *napi, int budget);
|
2005-04-16 16:20:36 -06:00
|
|
|
static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *dev);
|
|
|
|
static void ibmveth_set_multicast_list(struct net_device *dev);
|
|
|
|
static int ibmveth_change_mtu(struct net_device *dev, int new_mtu);
|
|
|
|
static void ibmveth_proc_register_driver(void);
|
|
|
|
static void ibmveth_proc_unregister_driver(void);
|
|
|
|
static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter);
|
|
|
|
static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter *adapter);
|
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 07:55:46 -06:00
|
|
|
static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance);
|
2007-04-16 21:12:55 -06:00
|
|
|
static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter);
|
2008-07-23 12:34:52 -06:00
|
|
|
static unsigned long ibmveth_get_desired_dma(struct vio_dev *vdev);
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
static struct kobj_type ktype_veth_pool;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-23 12:34:52 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_PROC_FS
|
2007-09-12 04:01:34 -06:00
|
|
|
#define IBMVETH_PROC_DIR "ibmveth"
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct proc_dir_entry *ibmveth_proc_dir;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static const char ibmveth_driver_name[] = "ibmveth";
|
|
|
|
static const char ibmveth_driver_string[] = "IBM i/pSeries Virtual Ethernet Driver";
|
|
|
|
#define ibmveth_driver_version "1.03"
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Santiago Leon <santil@us.ibm.com>");
|
|
|
|
MODULE_DESCRIPTION("IBM i/pSeries Virtual Ethernet Driver");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_VERSION(ibmveth_driver_version);
|
|
|
|
|
2007-08-17 08:16:43 -06:00
|
|
|
struct ibmveth_stat {
|
|
|
|
char name[ETH_GSTRING_LEN];
|
|
|
|
int offset;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define IBMVETH_STAT_OFF(stat) offsetof(struct ibmveth_adapter, stat)
|
|
|
|
#define IBMVETH_GET_STAT(a, off) *((u64 *)(((unsigned long)(a)) + off))
|
|
|
|
|
|
|
|
struct ibmveth_stat ibmveth_stats[] = {
|
|
|
|
{ "replenish_task_cycles", IBMVETH_STAT_OFF(replenish_task_cycles) },
|
|
|
|
{ "replenish_no_mem", IBMVETH_STAT_OFF(replenish_no_mem) },
|
|
|
|
{ "replenish_add_buff_failure", IBMVETH_STAT_OFF(replenish_add_buff_failure) },
|
|
|
|
{ "replenish_add_buff_success", IBMVETH_STAT_OFF(replenish_add_buff_success) },
|
|
|
|
{ "rx_invalid_buffer", IBMVETH_STAT_OFF(rx_invalid_buffer) },
|
|
|
|
{ "rx_no_buffer", IBMVETH_STAT_OFF(rx_no_buffer) },
|
|
|
|
{ "tx_map_failed", IBMVETH_STAT_OFF(tx_map_failed) },
|
|
|
|
{ "tx_send_failed", IBMVETH_STAT_OFF(tx_send_failed) },
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* simple methods of getting data from the current rxq entry */
|
2007-08-17 08:16:56 -06:00
|
|
|
static inline u32 ibmveth_rxq_flags(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
|
|
|
return adapter->rx_queue.queue_addr[adapter->rx_queue.index].flags_off;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ibmveth_rxq_toggle(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
|
|
|
return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_TOGGLE) >> IBMVETH_RXQ_TOGGLE_SHIFT;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline int ibmveth_rxq_pending_buffer(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
2007-08-17 08:16:56 -06:00
|
|
|
return (ibmveth_rxq_toggle(adapter) == adapter->rx_queue.toggle);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ibmveth_rxq_buffer_valid(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
2007-08-17 08:16:56 -06:00
|
|
|
return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_VALID);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ibmveth_rxq_frame_offset(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
2007-08-17 08:16:56 -06:00
|
|
|
return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_OFF_MASK);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ibmveth_rxq_frame_length(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
|
|
|
return (adapter->rx_queue.queue_addr[adapter->rx_queue.index].length);
|
|
|
|
}
|
|
|
|
|
2007-09-15 14:36:07 -06:00
|
|
|
static inline int ibmveth_rxq_csum_good(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
2007-08-17 08:16:56 -06:00
|
|
|
return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_CSUM_GOOD);
|
2007-09-15 14:36:07 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* setup the initial settings for a buffer pool */
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
static void ibmveth_init_buffer_pool(struct ibmveth_buff_pool *pool, u32 pool_index, u32 pool_size, u32 buff_size, u32 pool_active)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
pool->size = pool_size;
|
|
|
|
pool->index = pool_index;
|
|
|
|
pool->buff_size = buff_size;
|
|
|
|
pool->threshold = pool_size / 2;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
pool->active = pool_active;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* allocate and setup an buffer pool - called during open */
|
|
|
|
static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool *pool)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2006-05-23 23:31:14 -06:00
|
|
|
pool->free_map = kmalloc(sizeof(u16) * pool->size, GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if(!pool->free_map) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2006-05-23 23:31:14 -06:00
|
|
|
pool->dma_addr = kmalloc(sizeof(dma_addr_t) * pool->size, GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if(!pool->dma_addr) {
|
|
|
|
kfree(pool->free_map);
|
|
|
|
pool->free_map = NULL;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
pool->skbuff = kmalloc(sizeof(void*) * pool->size, GFP_KERNEL);
|
|
|
|
|
|
|
|
if(!pool->skbuff) {
|
|
|
|
kfree(pool->dma_addr);
|
|
|
|
pool->dma_addr = NULL;
|
|
|
|
|
|
|
|
kfree(pool->free_map);
|
|
|
|
pool->free_map = NULL;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(pool->skbuff, 0, sizeof(void*) * pool->size);
|
|
|
|
memset(pool->dma_addr, 0, sizeof(dma_addr_t) * pool->size);
|
|
|
|
|
|
|
|
for(i = 0; i < pool->size; ++i) {
|
|
|
|
pool->free_map[i] = i;
|
|
|
|
}
|
|
|
|
|
|
|
|
atomic_set(&pool->available, 0);
|
|
|
|
pool->producer_index = 0;
|
|
|
|
pool->consumer_index = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* replenish the buffers for a pool. note that we don't need to
|
|
|
|
* skb_reserve these since they are used for incoming...
|
|
|
|
*/
|
|
|
|
static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, struct ibmveth_buff_pool *pool)
|
|
|
|
{
|
|
|
|
u32 i;
|
|
|
|
u32 count = pool->size - atomic_read(&pool->available);
|
|
|
|
u32 buffers_added = 0;
|
2008-07-23 12:34:52 -06:00
|
|
|
struct sk_buff *skb;
|
|
|
|
unsigned int free_index, index;
|
|
|
|
u64 correlator;
|
|
|
|
unsigned long lpar_rc;
|
|
|
|
dma_addr_t dma_addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mb();
|
|
|
|
|
|
|
|
for(i = 0; i < count; ++i) {
|
|
|
|
union ibmveth_buf_desc desc;
|
|
|
|
|
|
|
|
skb = alloc_skb(pool->buff_size, GFP_ATOMIC);
|
|
|
|
|
|
|
|
if(!skb) {
|
|
|
|
ibmveth_debug_printk("replenish: unable to allocate skb\n");
|
|
|
|
adapter->replenish_no_mem++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-10-21 11:24:13 -06:00
|
|
|
free_index = pool->consumer_index;
|
|
|
|
pool->consumer_index = (pool->consumer_index + 1) % pool->size;
|
2005-04-16 16:20:36 -06:00
|
|
|
index = pool->free_map[free_index];
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ibmveth_assert(index != IBM_VETH_INVALID_MAP);
|
|
|
|
ibmveth_assert(pool->skbuff[index] == NULL);
|
|
|
|
|
|
|
|
dma_addr = dma_map_single(&adapter->vdev->dev, skb->data,
|
|
|
|
pool->buff_size, DMA_FROM_DEVICE);
|
|
|
|
|
2008-07-27 10:14:24 -06:00
|
|
|
if (dma_mapping_error(&adapter->vdev->dev, dma_addr))
|
2008-07-23 12:34:52 -06:00
|
|
|
goto failure;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
pool->free_map[free_index] = IBM_VETH_INVALID_MAP;
|
|
|
|
pool->dma_addr[index] = dma_addr;
|
|
|
|
pool->skbuff[index] = skb;
|
|
|
|
|
|
|
|
correlator = ((u64)pool->index << 32) | index;
|
|
|
|
*(u64*)skb->data = correlator;
|
|
|
|
|
2007-08-17 08:16:56 -06:00
|
|
|
desc.fields.flags_len = IBMVETH_BUF_VALID | pool->buff_size;
|
2006-05-23 23:31:14 -06:00
|
|
|
desc.fields.address = dma_addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address, desc.desc);
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2008-07-23 12:34:52 -06:00
|
|
|
if (lpar_rc != H_SUCCESS)
|
|
|
|
goto failure;
|
|
|
|
else {
|
2005-04-16 16:20:36 -06:00
|
|
|
buffers_added++;
|
|
|
|
adapter->replenish_add_buff_success++;
|
|
|
|
}
|
|
|
|
}
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2008-07-23 12:34:52 -06:00
|
|
|
mb();
|
|
|
|
atomic_add(buffers_added, &(pool->available));
|
|
|
|
return;
|
|
|
|
|
|
|
|
failure:
|
|
|
|
pool->free_map[free_index] = index;
|
|
|
|
pool->skbuff[index] = NULL;
|
|
|
|
if (pool->consumer_index == 0)
|
|
|
|
pool->consumer_index = pool->size - 1;
|
|
|
|
else
|
|
|
|
pool->consumer_index--;
|
2008-07-27 10:14:24 -06:00
|
|
|
if (!dma_mapping_error(&adapter->vdev->dev, dma_addr))
|
2008-07-23 12:34:52 -06:00
|
|
|
dma_unmap_single(&adapter->vdev->dev,
|
|
|
|
pool->dma_addr[index], pool->buff_size,
|
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
adapter->replenish_add_buff_failure++;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
mb();
|
|
|
|
atomic_add(buffers_added, &(pool->available));
|
|
|
|
}
|
|
|
|
|
2005-10-26 10:47:08 -06:00
|
|
|
/* replenish routine */
|
2006-05-23 23:31:14 -06:00
|
|
|
static void ibmveth_replenish_task(struct ibmveth_adapter *adapter)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-10-26 10:47:01 -06:00
|
|
|
int i;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
adapter->replenish_task_cycles++;
|
|
|
|
|
2008-07-23 12:34:52 -06:00
|
|
|
for (i = (IbmVethNumBufferPools - 1); i >= 0; i--)
|
2005-10-26 10:47:01 -06:00
|
|
|
if(adapter->rx_buff_pool[i].active)
|
2006-05-23 23:31:14 -06:00
|
|
|
ibmveth_replenish_buffer_pool(adapter,
|
2005-10-26 10:47:01 -06:00
|
|
|
&adapter->rx_buff_pool[i]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
adapter->rx_no_buffer = *(u64*)(((char*)adapter->buffer_list_addr) + 4096 - 8);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* empty and free ana buffer pool - also used to do cleanup in error paths */
|
|
|
|
static void ibmveth_free_buffer_pool(struct ibmveth_adapter *adapter, struct ibmveth_buff_pool *pool)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2005-10-28 14:53:13 -06:00
|
|
|
kfree(pool->free_map);
|
|
|
|
pool->free_map = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if(pool->skbuff && pool->dma_addr) {
|
|
|
|
for(i = 0; i < pool->size; ++i) {
|
|
|
|
struct sk_buff *skb = pool->skbuff[i];
|
|
|
|
if(skb) {
|
|
|
|
dma_unmap_single(&adapter->vdev->dev,
|
|
|
|
pool->dma_addr[i],
|
|
|
|
pool->buff_size,
|
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
pool->skbuff[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(pool->dma_addr) {
|
|
|
|
kfree(pool->dma_addr);
|
|
|
|
pool->dma_addr = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(pool->skbuff) {
|
|
|
|
kfree(pool->skbuff);
|
|
|
|
pool->skbuff = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remove a buffer from a pool */
|
|
|
|
static void ibmveth_remove_buffer_from_pool(struct ibmveth_adapter *adapter, u64 correlator)
|
|
|
|
{
|
|
|
|
unsigned int pool = correlator >> 32;
|
|
|
|
unsigned int index = correlator & 0xffffffffUL;
|
|
|
|
unsigned int free_index;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
ibmveth_assert(pool < IbmVethNumBufferPools);
|
|
|
|
ibmveth_assert(index < adapter->rx_buff_pool[pool].size);
|
|
|
|
|
|
|
|
skb = adapter->rx_buff_pool[pool].skbuff[index];
|
|
|
|
|
|
|
|
ibmveth_assert(skb != NULL);
|
|
|
|
|
|
|
|
adapter->rx_buff_pool[pool].skbuff[index] = NULL;
|
|
|
|
|
|
|
|
dma_unmap_single(&adapter->vdev->dev,
|
|
|
|
adapter->rx_buff_pool[pool].dma_addr[index],
|
|
|
|
adapter->rx_buff_pool[pool].buff_size,
|
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
|
2006-10-21 11:24:13 -06:00
|
|
|
free_index = adapter->rx_buff_pool[pool].producer_index;
|
|
|
|
adapter->rx_buff_pool[pool].producer_index
|
|
|
|
= (adapter->rx_buff_pool[pool].producer_index + 1)
|
|
|
|
% adapter->rx_buff_pool[pool].size;
|
2005-04-16 16:20:36 -06:00
|
|
|
adapter->rx_buff_pool[pool].free_map[free_index] = index;
|
|
|
|
|
|
|
|
mb();
|
|
|
|
|
|
|
|
atomic_dec(&(adapter->rx_buff_pool[pool].available));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get the current buffer on the rx queue */
|
|
|
|
static inline struct sk_buff *ibmveth_rxq_get_buffer(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
|
|
|
u64 correlator = adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator;
|
|
|
|
unsigned int pool = correlator >> 32;
|
|
|
|
unsigned int index = correlator & 0xffffffffUL;
|
|
|
|
|
|
|
|
ibmveth_assert(pool < IbmVethNumBufferPools);
|
|
|
|
ibmveth_assert(index < adapter->rx_buff_pool[pool].size);
|
|
|
|
|
|
|
|
return adapter->rx_buff_pool[pool].skbuff[index];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* recycle the current buffer on the rx queue */
|
|
|
|
static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
|
|
|
u32 q_index = adapter->rx_queue.index;
|
|
|
|
u64 correlator = adapter->rx_queue.queue_addr[q_index].correlator;
|
|
|
|
unsigned int pool = correlator >> 32;
|
|
|
|
unsigned int index = correlator & 0xffffffffUL;
|
|
|
|
union ibmveth_buf_desc desc;
|
|
|
|
unsigned long lpar_rc;
|
|
|
|
|
|
|
|
ibmveth_assert(pool < IbmVethNumBufferPools);
|
|
|
|
ibmveth_assert(index < adapter->rx_buff_pool[pool].size);
|
|
|
|
|
2005-10-26 10:47:01 -06:00
|
|
|
if(!adapter->rx_buff_pool[pool].active) {
|
|
|
|
ibmveth_rxq_harvest_buffer(adapter);
|
|
|
|
ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[pool]);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-08-17 08:16:56 -06:00
|
|
|
desc.fields.flags_len = IBMVETH_BUF_VALID |
|
|
|
|
adapter->rx_buff_pool[pool].buff_size;
|
2005-04-16 16:20:36 -06:00
|
|
|
desc.fields.address = adapter->rx_buff_pool[pool].dma_addr[index];
|
|
|
|
|
|
|
|
lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address, desc.desc);
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2006-03-30 05:49:40 -07:00
|
|
|
if(lpar_rc != H_SUCCESS) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ibmveth_debug_printk("h_add_logical_lan_buffer failed during recycle rc=%ld", lpar_rc);
|
|
|
|
ibmveth_remove_buffer_from_pool(adapter, adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(++adapter->rx_queue.index == adapter->rx_queue.num_slots) {
|
|
|
|
adapter->rx_queue.index = 0;
|
|
|
|
adapter->rx_queue.toggle = !adapter->rx_queue.toggle;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-04-16 21:12:55 -06:00
|
|
|
static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
ibmveth_remove_buffer_from_pool(adapter, adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator);
|
|
|
|
|
|
|
|
if(++adapter->rx_queue.index == adapter->rx_queue.num_slots) {
|
|
|
|
adapter->rx_queue.index = 0;
|
|
|
|
adapter->rx_queue.toggle = !adapter->rx_queue.toggle;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ibmveth_cleanup(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
2005-10-26 10:47:01 -06:00
|
|
|
int i;
|
2008-07-25 20:44:49 -06:00
|
|
|
struct device *dev = &adapter->vdev->dev;
|
2005-10-26 10:47:01 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if(adapter->buffer_list_addr != NULL) {
|
2008-07-25 20:44:49 -06:00
|
|
|
if (!dma_mapping_error(dev, adapter->buffer_list_dma)) {
|
|
|
|
dma_unmap_single(dev, adapter->buffer_list_dma, 4096,
|
2005-04-16 16:20:36 -06:00
|
|
|
DMA_BIDIRECTIONAL);
|
|
|
|
adapter->buffer_list_dma = DMA_ERROR_CODE;
|
|
|
|
}
|
|
|
|
free_page((unsigned long)adapter->buffer_list_addr);
|
|
|
|
adapter->buffer_list_addr = NULL;
|
2006-05-23 23:31:14 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if(adapter->filter_list_addr != NULL) {
|
2008-07-25 20:44:49 -06:00
|
|
|
if (!dma_mapping_error(dev, adapter->filter_list_dma)) {
|
|
|
|
dma_unmap_single(dev, adapter->filter_list_dma, 4096,
|
2005-04-16 16:20:36 -06:00
|
|
|
DMA_BIDIRECTIONAL);
|
|
|
|
adapter->filter_list_dma = DMA_ERROR_CODE;
|
|
|
|
}
|
|
|
|
free_page((unsigned long)adapter->filter_list_addr);
|
|
|
|
adapter->filter_list_addr = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(adapter->rx_queue.queue_addr != NULL) {
|
2008-07-25 20:44:49 -06:00
|
|
|
if (!dma_mapping_error(dev, adapter->rx_queue.queue_dma)) {
|
|
|
|
dma_unmap_single(dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
adapter->rx_queue.queue_dma,
|
|
|
|
adapter->rx_queue.queue_len,
|
|
|
|
DMA_BIDIRECTIONAL);
|
|
|
|
adapter->rx_queue.queue_dma = DMA_ERROR_CODE;
|
|
|
|
}
|
|
|
|
kfree(adapter->rx_queue.queue_addr);
|
|
|
|
adapter->rx_queue.queue_addr = NULL;
|
|
|
|
}
|
|
|
|
|
2005-10-26 10:47:01 -06:00
|
|
|
for(i = 0; i<IbmVethNumBufferPools; i++)
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
if (adapter->rx_buff_pool[i].active)
|
2006-05-23 23:31:14 -06:00
|
|
|
ibmveth_free_buffer_pool(adapter,
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
&adapter->rx_buff_pool[i]);
|
2008-07-23 12:34:52 -06:00
|
|
|
|
|
|
|
if (adapter->bounce_buffer != NULL) {
|
2008-07-27 10:14:24 -06:00
|
|
|
if (!dma_mapping_error(dev, adapter->bounce_buffer_dma)) {
|
2008-07-23 12:34:52 -06:00
|
|
|
dma_unmap_single(&adapter->vdev->dev,
|
|
|
|
adapter->bounce_buffer_dma,
|
|
|
|
adapter->netdev->mtu + IBMVETH_BUFF_OH,
|
|
|
|
DMA_BIDIRECTIONAL);
|
|
|
|
adapter->bounce_buffer_dma = DMA_ERROR_CODE;
|
|
|
|
}
|
|
|
|
kfree(adapter->bounce_buffer);
|
|
|
|
adapter->bounce_buffer = NULL;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-10-03 11:24:23 -06:00
|
|
|
static int ibmveth_register_logical_lan(struct ibmveth_adapter *adapter,
|
|
|
|
union ibmveth_buf_desc rxq_desc, u64 mac_address)
|
|
|
|
{
|
|
|
|
int rc, try_again = 1;
|
|
|
|
|
|
|
|
/* After a kexec the adapter will still be open, so our attempt to
|
|
|
|
* open it will fail. So if we get a failure we free the adapter and
|
|
|
|
* try again, but only once. */
|
|
|
|
retry:
|
|
|
|
rc = h_register_logical_lan(adapter->vdev->unit_address,
|
|
|
|
adapter->buffer_list_dma, rxq_desc.desc,
|
|
|
|
adapter->filter_list_dma, mac_address);
|
|
|
|
|
|
|
|
if (rc != H_SUCCESS && try_again) {
|
|
|
|
do {
|
|
|
|
rc = h_free_logical_lan(adapter->vdev->unit_address);
|
|
|
|
} while (H_IS_LONG_BUSY(rc) || (rc == H_BUSY));
|
|
|
|
|
|
|
|
try_again = 0;
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int ibmveth_open(struct net_device *netdev)
|
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = netdev->priv;
|
|
|
|
u64 mac_address = 0;
|
2005-10-26 10:47:01 -06:00
|
|
|
int rxq_entries = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long lpar_rc;
|
|
|
|
int rc;
|
|
|
|
union ibmveth_buf_desc rxq_desc;
|
2005-10-26 10:47:01 -06:00
|
|
|
int i;
|
2008-07-25 20:44:49 -06:00
|
|
|
struct device *dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ibmveth_debug_printk("open starting\n");
|
|
|
|
|
[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 17:41:36 -06:00
|
|
|
napi_enable(&adapter->napi);
|
|
|
|
|
2005-10-26 10:47:01 -06:00
|
|
|
for(i = 0; i<IbmVethNumBufferPools; i++)
|
|
|
|
rxq_entries += adapter->rx_buff_pool[i].size;
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
adapter->buffer_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
|
|
|
|
adapter->filter_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if(!adapter->buffer_list_addr || !adapter->filter_list_addr) {
|
|
|
|
ibmveth_error_printk("unable to allocate filter or buffer list pages\n");
|
|
|
|
ibmveth_cleanup(adapter);
|
[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 17:41:36 -06:00
|
|
|
napi_disable(&adapter->napi);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
adapter->rx_queue.queue_len = sizeof(struct ibmveth_rx_q_entry) * rxq_entries;
|
|
|
|
adapter->rx_queue.queue_addr = kmalloc(adapter->rx_queue.queue_len, GFP_KERNEL);
|
|
|
|
|
|
|
|
if(!adapter->rx_queue.queue_addr) {
|
|
|
|
ibmveth_error_printk("unable to allocate rx queue pages\n");
|
|
|
|
ibmveth_cleanup(adapter);
|
[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 17:41:36 -06:00
|
|
|
napi_disable(&adapter->napi);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2008-07-25 20:44:49 -06:00
|
|
|
dev = &adapter->vdev->dev;
|
|
|
|
|
|
|
|
adapter->buffer_list_dma = dma_map_single(dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
adapter->buffer_list_addr, 4096, DMA_BIDIRECTIONAL);
|
2008-07-25 20:44:49 -06:00
|
|
|
adapter->filter_list_dma = dma_map_single(dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
adapter->filter_list_addr, 4096, DMA_BIDIRECTIONAL);
|
2008-07-25 20:44:49 -06:00
|
|
|
adapter->rx_queue.queue_dma = dma_map_single(dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
adapter->rx_queue.queue_addr,
|
|
|
|
adapter->rx_queue.queue_len, DMA_BIDIRECTIONAL);
|
|
|
|
|
2008-07-25 20:44:49 -06:00
|
|
|
if ((dma_mapping_error(dev, adapter->buffer_list_dma)) ||
|
|
|
|
(dma_mapping_error(dev, adapter->filter_list_dma)) ||
|
|
|
|
(dma_mapping_error(dev, adapter->rx_queue.queue_dma))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ibmveth_error_printk("unable to map filter or buffer list pages\n");
|
|
|
|
ibmveth_cleanup(adapter);
|
[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 17:41:36 -06:00
|
|
|
napi_disable(&adapter->napi);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
adapter->rx_queue.index = 0;
|
|
|
|
adapter->rx_queue.num_slots = rxq_entries;
|
|
|
|
adapter->rx_queue.toggle = 1;
|
|
|
|
|
|
|
|
memcpy(&mac_address, netdev->dev_addr, netdev->addr_len);
|
|
|
|
mac_address = mac_address >> 16;
|
|
|
|
|
2007-08-17 08:16:56 -06:00
|
|
|
rxq_desc.fields.flags_len = IBMVETH_BUF_VALID | adapter->rx_queue.queue_len;
|
2005-04-16 16:20:36 -06:00
|
|
|
rxq_desc.fields.address = adapter->rx_queue.queue_dma;
|
|
|
|
|
|
|
|
ibmveth_debug_printk("buffer list @ 0x%p\n", adapter->buffer_list_addr);
|
|
|
|
ibmveth_debug_printk("filter list @ 0x%p\n", adapter->filter_list_addr);
|
|
|
|
ibmveth_debug_printk("receive q @ 0x%p\n", adapter->rx_queue.queue_addr);
|
|
|
|
|
2006-10-03 11:24:34 -06:00
|
|
|
h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
|
|
|
|
|
2006-10-03 11:24:23 -06:00
|
|
|
lpar_rc = ibmveth_register_logical_lan(adapter, rxq_desc, mac_address);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-03-30 05:49:40 -07:00
|
|
|
if(lpar_rc != H_SUCCESS) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ibmveth_error_printk("h_register_logical_lan failed with %ld\n", lpar_rc);
|
2005-10-25 00:56:43 -06:00
|
|
|
ibmveth_error_printk("buffer TCE:0x%lx filter TCE:0x%lx rxq desc:0x%lx MAC:0x%lx\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
adapter->buffer_list_dma,
|
|
|
|
adapter->filter_list_dma,
|
|
|
|
rxq_desc.desc,
|
|
|
|
mac_address);
|
|
|
|
ibmveth_cleanup(adapter);
|
[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 17:41:36 -06:00
|
|
|
napi_disable(&adapter->napi);
|
2006-05-23 23:31:14 -06:00
|
|
|
return -ENONET;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
for(i = 0; i<IbmVethNumBufferPools; i++) {
|
|
|
|
if(!adapter->rx_buff_pool[i].active)
|
|
|
|
continue;
|
|
|
|
if (ibmveth_alloc_buffer_pool(&adapter->rx_buff_pool[i])) {
|
|
|
|
ibmveth_error_printk("unable to alloc pool\n");
|
|
|
|
adapter->rx_buff_pool[i].active = 0;
|
|
|
|
ibmveth_cleanup(adapter);
|
[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 17:41:36 -06:00
|
|
|
napi_disable(&adapter->napi);
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
return -ENOMEM ;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ibmveth_debug_printk("registering irq 0x%x\n", netdev->irq);
|
|
|
|
if((rc = request_irq(netdev->irq, &ibmveth_interrupt, 0, netdev->name, netdev)) != 0) {
|
|
|
|
ibmveth_error_printk("unable to request irq 0x%x, rc %d\n", netdev->irq, rc);
|
|
|
|
do {
|
|
|
|
rc = h_free_logical_lan(adapter->vdev->unit_address);
|
2006-03-30 05:49:40 -07:00
|
|
|
} while (H_IS_LONG_BUSY(rc) || (rc == H_BUSY));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ibmveth_cleanup(adapter);
|
[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 17:41:36 -06:00
|
|
|
napi_disable(&adapter->napi);
|
2005-04-16 16:20:36 -06:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-07-23 12:34:52 -06:00
|
|
|
adapter->bounce_buffer =
|
|
|
|
kmalloc(netdev->mtu + IBMVETH_BUFF_OH, GFP_KERNEL);
|
|
|
|
if (!adapter->bounce_buffer) {
|
|
|
|
ibmveth_error_printk("unable to allocate bounce buffer\n");
|
|
|
|
ibmveth_cleanup(adapter);
|
|
|
|
napi_disable(&adapter->napi);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
adapter->bounce_buffer_dma =
|
|
|
|
dma_map_single(&adapter->vdev->dev, adapter->bounce_buffer,
|
|
|
|
netdev->mtu + IBMVETH_BUFF_OH, DMA_BIDIRECTIONAL);
|
2008-07-25 20:44:49 -06:00
|
|
|
if (dma_mapping_error(dev, adapter->bounce_buffer_dma)) {
|
2008-07-23 12:34:52 -06:00
|
|
|
ibmveth_error_printk("unable to map bounce buffer\n");
|
|
|
|
ibmveth_cleanup(adapter);
|
|
|
|
napi_disable(&adapter->napi);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2005-10-26 10:47:08 -06:00
|
|
|
ibmveth_debug_printk("initial replenish cycle\n");
|
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 07:55:46 -06:00
|
|
|
ibmveth_interrupt(netdev->irq, netdev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-10-26 10:47:08 -06:00
|
|
|
netif_start_queue(netdev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ibmveth_debug_printk("open complete\n");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ibmveth_close(struct net_device *netdev)
|
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = netdev->priv;
|
|
|
|
long lpar_rc;
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ibmveth_debug_printk("close starting\n");
|
|
|
|
|
[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 17:41:36 -06:00
|
|
|
napi_disable(&adapter->napi);
|
|
|
|
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
if (!adapter->pool_config)
|
|
|
|
netif_stop_queue(netdev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
free_irq(netdev->irq, netdev);
|
|
|
|
|
|
|
|
do {
|
|
|
|
lpar_rc = h_free_logical_lan(adapter->vdev->unit_address);
|
2006-03-30 05:49:40 -07:00
|
|
|
} while (H_IS_LONG_BUSY(lpar_rc) || (lpar_rc == H_BUSY));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-03-30 05:49:40 -07:00
|
|
|
if(lpar_rc != H_SUCCESS)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
ibmveth_error_printk("h_free_logical_lan failed with %lx, continuing with close\n",
|
|
|
|
lpar_rc);
|
|
|
|
}
|
|
|
|
|
|
|
|
adapter->rx_no_buffer = *(u64*)(((char*)adapter->buffer_list_addr) + 4096 - 8);
|
|
|
|
|
|
|
|
ibmveth_cleanup(adapter);
|
|
|
|
|
|
|
|
ibmveth_debug_printk("close complete\n");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) {
|
|
|
|
cmd->supported = (SUPPORTED_1000baseT_Full | SUPPORTED_Autoneg | SUPPORTED_FIBRE);
|
|
|
|
cmd->advertising = (ADVERTISED_1000baseT_Full | ADVERTISED_Autoneg | ADVERTISED_FIBRE);
|
|
|
|
cmd->speed = SPEED_1000;
|
|
|
|
cmd->duplex = DUPLEX_FULL;
|
|
|
|
cmd->port = PORT_FIBRE;
|
|
|
|
cmd->phy_address = 0;
|
|
|
|
cmd->transceiver = XCVR_INTERNAL;
|
|
|
|
cmd->autoneg = AUTONEG_ENABLE;
|
|
|
|
cmd->maxtxpkt = 0;
|
|
|
|
cmd->maxrxpkt = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void netdev_get_drvinfo (struct net_device *dev, struct ethtool_drvinfo *info) {
|
|
|
|
strncpy(info->driver, ibmveth_driver_name, sizeof(info->driver) - 1);
|
|
|
|
strncpy(info->version, ibmveth_driver_version, sizeof(info->version) - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 netdev_get_link(struct net_device *dev) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-08-17 08:16:31 -06:00
|
|
|
static void ibmveth_set_rx_csum_flags(struct net_device *dev, u32 data)
|
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = dev->priv;
|
|
|
|
|
|
|
|
if (data)
|
|
|
|
adapter->rx_csum = 1;
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* Since the ibmveth firmware interface does not have the concept of
|
|
|
|
* separate tx/rx checksum offload enable, if rx checksum is disabled
|
|
|
|
* we also have to disable tx checksum offload. Once we disable rx
|
|
|
|
* checksum offload, we are no longer allowed to send tx buffers that
|
|
|
|
* are not properly checksummed.
|
|
|
|
*/
|
|
|
|
adapter->rx_csum = 0;
|
|
|
|
dev->features &= ~NETIF_F_IP_CSUM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ibmveth_set_tx_csum_flags(struct net_device *dev, u32 data)
|
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = dev->priv;
|
|
|
|
|
|
|
|
if (data) {
|
|
|
|
dev->features |= NETIF_F_IP_CSUM;
|
|
|
|
adapter->rx_csum = 1;
|
|
|
|
} else
|
|
|
|
dev->features &= ~NETIF_F_IP_CSUM;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ibmveth_set_csum_offload(struct net_device *dev, u32 data,
|
|
|
|
void (*done) (struct net_device *, u32))
|
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = dev->priv;
|
2007-08-17 08:16:56 -06:00
|
|
|
u64 set_attr, clr_attr, ret_attr;
|
2007-08-17 08:16:31 -06:00
|
|
|
long ret;
|
|
|
|
int rc1 = 0, rc2 = 0;
|
|
|
|
int restart = 0;
|
|
|
|
|
|
|
|
if (netif_running(dev)) {
|
|
|
|
restart = 1;
|
|
|
|
adapter->pool_config = 1;
|
|
|
|
ibmveth_close(dev);
|
|
|
|
adapter->pool_config = 0;
|
|
|
|
}
|
|
|
|
|
2007-08-17 08:16:56 -06:00
|
|
|
set_attr = 0;
|
|
|
|
clr_attr = 0;
|
2007-08-17 08:16:31 -06:00
|
|
|
|
|
|
|
if (data)
|
2007-08-17 08:16:56 -06:00
|
|
|
set_attr = IBMVETH_ILLAN_IPV4_TCP_CSUM;
|
2007-08-17 08:16:31 -06:00
|
|
|
else
|
2007-08-17 08:16:56 -06:00
|
|
|
clr_attr = IBMVETH_ILLAN_IPV4_TCP_CSUM;
|
2007-08-17 08:16:31 -06:00
|
|
|
|
2007-08-17 08:16:56 -06:00
|
|
|
ret = h_illan_attributes(adapter->vdev->unit_address, 0, 0, &ret_attr);
|
2007-08-17 08:16:31 -06:00
|
|
|
|
2007-08-17 08:16:56 -06:00
|
|
|
if (ret == H_SUCCESS && !(ret_attr & IBMVETH_ILLAN_ACTIVE_TRUNK) &&
|
|
|
|
!(ret_attr & IBMVETH_ILLAN_TRUNK_PRI_MASK) &&
|
|
|
|
(ret_attr & IBMVETH_ILLAN_PADDED_PKT_CSUM)) {
|
|
|
|
ret = h_illan_attributes(adapter->vdev->unit_address, clr_attr,
|
|
|
|
set_attr, &ret_attr);
|
2007-08-17 08:16:31 -06:00
|
|
|
|
|
|
|
if (ret != H_SUCCESS) {
|
|
|
|
rc1 = -EIO;
|
|
|
|
ibmveth_error_printk("unable to change checksum offload settings."
|
|
|
|
" %d rc=%ld\n", data, ret);
|
|
|
|
|
|
|
|
ret = h_illan_attributes(adapter->vdev->unit_address,
|
2007-08-17 08:16:56 -06:00
|
|
|
set_attr, clr_attr, &ret_attr);
|
2007-08-17 08:16:31 -06:00
|
|
|
} else
|
|
|
|
done(dev, data);
|
|
|
|
} else {
|
|
|
|
rc1 = -EIO;
|
|
|
|
ibmveth_error_printk("unable to change checksum offload settings."
|
2007-08-17 08:16:56 -06:00
|
|
|
" %d rc=%ld ret_attr=%lx\n", data, ret, ret_attr);
|
2007-08-17 08:16:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (restart)
|
|
|
|
rc2 = ibmveth_open(dev);
|
|
|
|
|
|
|
|
return rc1 ? rc1 : rc2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ibmveth_set_rx_csum(struct net_device *dev, u32 data)
|
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = dev->priv;
|
|
|
|
|
|
|
|
if ((data && adapter->rx_csum) || (!data && !adapter->rx_csum))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return ibmveth_set_csum_offload(dev, data, ibmveth_set_rx_csum_flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ibmveth_set_tx_csum(struct net_device *dev, u32 data)
|
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = dev->priv;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
if (data && (dev->features & NETIF_F_IP_CSUM))
|
|
|
|
return 0;
|
|
|
|
if (!data && !(dev->features & NETIF_F_IP_CSUM))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (data && !adapter->rx_csum)
|
|
|
|
rc = ibmveth_set_csum_offload(dev, data, ibmveth_set_tx_csum_flags);
|
|
|
|
else
|
|
|
|
ibmveth_set_tx_csum_flags(dev, data);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 ibmveth_get_rx_csum(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = dev->priv;
|
|
|
|
return adapter->rx_csum;
|
|
|
|
}
|
|
|
|
|
2007-08-17 08:16:43 -06:00
|
|
|
static void ibmveth_get_strings(struct net_device *dev, u32 stringset, u8 *data)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (stringset != ETH_SS_STATS)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ibmveth_stats); i++, data += ETH_GSTRING_LEN)
|
|
|
|
memcpy(data, ibmveth_stats[i].name, ETH_GSTRING_LEN);
|
|
|
|
}
|
|
|
|
|
2007-10-03 19:07:32 -06:00
|
|
|
static int ibmveth_get_sset_count(struct net_device *dev, int sset)
|
2007-08-17 08:16:43 -06:00
|
|
|
{
|
2007-10-03 19:07:32 -06:00
|
|
|
switch (sset) {
|
|
|
|
case ETH_SS_STATS:
|
|
|
|
return ARRAY_SIZE(ibmveth_stats);
|
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
2007-08-17 08:16:43 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ibmveth_get_ethtool_stats(struct net_device *dev,
|
|
|
|
struct ethtool_stats *stats, u64 *data)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct ibmveth_adapter *adapter = dev->priv;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ibmveth_stats); i++)
|
|
|
|
data[i] = IBMVETH_GET_STAT(adapter, ibmveth_stats[i].offset);
|
|
|
|
}
|
|
|
|
|
2006-09-13 12:30:00 -06:00
|
|
|
static const struct ethtool_ops netdev_ethtool_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.get_drvinfo = netdev_get_drvinfo,
|
|
|
|
.get_settings = netdev_get_settings,
|
|
|
|
.get_link = netdev_get_link,
|
2007-08-17 08:16:31 -06:00
|
|
|
.set_tx_csum = ibmveth_set_tx_csum,
|
|
|
|
.get_rx_csum = ibmveth_get_rx_csum,
|
|
|
|
.set_rx_csum = ibmveth_set_rx_csum,
|
2007-08-17 08:16:43 -06:00
|
|
|
.get_strings = ibmveth_get_strings,
|
2007-10-03 19:07:32 -06:00
|
|
|
.get_sset_count = ibmveth_get_sset_count,
|
2007-08-17 08:16:43 -06:00
|
|
|
.get_ethtool_stats = ibmveth_get_ethtool_stats,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static int ibmveth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
|
|
|
|
{
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define page_offset(v) ((unsigned long)(v) & ((1 << 12) - 1))
|
|
|
|
|
|
|
|
static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
|
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = netdev->priv;
|
2007-08-17 08:16:49 -06:00
|
|
|
union ibmveth_buf_desc desc;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long lpar_rc;
|
|
|
|
unsigned long correlator;
|
2005-10-26 10:47:16 -06:00
|
|
|
unsigned long flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int retry_count;
|
2005-10-26 10:47:16 -06:00
|
|
|
unsigned int tx_dropped = 0;
|
|
|
|
unsigned int tx_bytes = 0;
|
|
|
|
unsigned int tx_packets = 0;
|
|
|
|
unsigned int tx_send_failed = 0;
|
|
|
|
unsigned int tx_map_failed = 0;
|
2008-07-23 12:34:52 -06:00
|
|
|
int used_bounce = 0;
|
|
|
|
unsigned long data_dma_addr;
|
2005-10-26 10:47:16 -06:00
|
|
|
|
2007-08-17 08:16:56 -06:00
|
|
|
desc.fields.flags_len = IBMVETH_BUF_VALID | skb->len;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-15 14:36:07 -06:00
|
|
|
if (skb->ip_summed == CHECKSUM_PARTIAL &&
|
|
|
|
ip_hdr(skb)->protocol != IPPROTO_TCP && skb_checksum_help(skb)) {
|
|
|
|
ibmveth_error_printk("tx: failed to checksum packet\n");
|
|
|
|
tx_dropped++;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (skb->ip_summed == CHECKSUM_PARTIAL) {
|
|
|
|
unsigned char *buf = skb_transport_header(skb) + skb->csum_offset;
|
|
|
|
|
2007-08-17 08:16:56 -06:00
|
|
|
desc.fields.flags_len |= (IBMVETH_BUF_NO_CSUM | IBMVETH_BUF_CSUM_GOOD);
|
2007-09-15 14:36:07 -06:00
|
|
|
|
|
|
|
/* Need to zero out the checksum */
|
|
|
|
buf[0] = 0;
|
|
|
|
buf[1] = 0;
|
|
|
|
}
|
|
|
|
|
2008-08-20 13:09:19 -06:00
|
|
|
data_dma_addr = dma_map_single(&adapter->vdev->dev, skb->data,
|
|
|
|
skb->len, DMA_TO_DEVICE);
|
2008-07-27 10:14:24 -06:00
|
|
|
if (dma_mapping_error(&adapter->vdev->dev, data_dma_addr)) {
|
2008-07-23 12:34:52 -06:00
|
|
|
if (!firmware_has_feature(FW_FEATURE_CMO))
|
|
|
|
ibmveth_error_printk("tx: unable to map xmit buffer\n");
|
|
|
|
skb_copy_from_linear_data(skb, adapter->bounce_buffer,
|
|
|
|
skb->len);
|
|
|
|
desc.fields.address = adapter->bounce_buffer_dma;
|
2005-10-26 10:47:16 -06:00
|
|
|
tx_map_failed++;
|
2008-07-23 12:34:52 -06:00
|
|
|
used_bounce = 1;
|
2008-08-20 13:09:19 -06:00
|
|
|
wmb();
|
2008-07-23 12:34:52 -06:00
|
|
|
} else
|
|
|
|
desc.fields.address = data_dma_addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* send the frame. Arbitrarily set retrycount to 1024 */
|
|
|
|
correlator = 0;
|
|
|
|
retry_count = 1024;
|
|
|
|
do {
|
|
|
|
lpar_rc = h_send_logical_lan(adapter->vdev->unit_address,
|
2007-08-17 08:16:49 -06:00
|
|
|
desc.desc, 0, 0, 0, 0, 0,
|
|
|
|
correlator, &correlator);
|
2006-03-30 05:49:40 -07:00
|
|
|
} while ((lpar_rc == H_BUSY) && (retry_count--));
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2006-03-30 05:49:40 -07:00
|
|
|
if(lpar_rc != H_SUCCESS && lpar_rc != H_DROPPED) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ibmveth_error_printk("tx: h_send_logical_lan failed with rc=%ld\n", lpar_rc);
|
2007-08-17 08:16:49 -06:00
|
|
|
ibmveth_error_printk("tx: valid=%d, len=%d, address=0x%08x\n",
|
2007-08-17 08:16:56 -06:00
|
|
|
(desc.fields.flags_len & IBMVETH_BUF_VALID) ? 1 : 0,
|
|
|
|
skb->len, desc.fields.address);
|
2005-10-26 10:47:16 -06:00
|
|
|
tx_send_failed++;
|
|
|
|
tx_dropped++;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2005-10-26 10:47:16 -06:00
|
|
|
tx_packets++;
|
|
|
|
tx_bytes += skb->len;
|
2005-10-26 10:46:53 -06:00
|
|
|
netdev->trans_start = jiffies;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-07-23 12:34:52 -06:00
|
|
|
if (!used_bounce)
|
|
|
|
dma_unmap_single(&adapter->vdev->dev, data_dma_addr,
|
|
|
|
skb->len, DMA_TO_DEVICE);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-10-26 10:47:16 -06:00
|
|
|
out: spin_lock_irqsave(&adapter->stats_lock, flags);
|
2007-10-03 18:41:50 -06:00
|
|
|
netdev->stats.tx_dropped += tx_dropped;
|
|
|
|
netdev->stats.tx_bytes += tx_bytes;
|
|
|
|
netdev->stats.tx_packets += tx_packets;
|
2005-10-26 10:47:16 -06:00
|
|
|
adapter->tx_send_failed += tx_send_failed;
|
|
|
|
adapter->tx_map_failed += tx_map_failed;
|
|
|
|
spin_unlock_irqrestore(&adapter->stats_lock, flags);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
dev_kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
[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 17:41:36 -06:00
|
|
|
static int ibmveth_poll(struct napi_struct *napi, int budget)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
[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 17:41:36 -06:00
|
|
|
struct ibmveth_adapter *adapter = container_of(napi, struct ibmveth_adapter, napi);
|
|
|
|
struct net_device *netdev = adapter->netdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
int frames_processed = 0;
|
|
|
|
unsigned long lpar_rc;
|
|
|
|
|
|
|
|
restart_poll:
|
|
|
|
do {
|
[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 17:41:36 -06:00
|
|
|
struct sk_buff *skb;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[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 17:41:36 -06:00
|
|
|
if (!ibmveth_rxq_pending_buffer(adapter))
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[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 17:41:36 -06:00
|
|
|
rmb();
|
|
|
|
if (!ibmveth_rxq_buffer_valid(adapter)) {
|
|
|
|
wmb(); /* suggested by larson1 */
|
|
|
|
adapter->rx_invalid_buffer++;
|
|
|
|
ibmveth_debug_printk("recycling invalid buffer\n");
|
|
|
|
ibmveth_rxq_recycle_buffer(adapter);
|
|
|
|
} else {
|
|
|
|
int length = ibmveth_rxq_frame_length(adapter);
|
|
|
|
int offset = ibmveth_rxq_frame_offset(adapter);
|
2007-09-15 14:36:07 -06:00
|
|
|
int csum_good = ibmveth_rxq_csum_good(adapter);
|
|
|
|
|
[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 17:41:36 -06:00
|
|
|
skb = ibmveth_rxq_get_buffer(adapter);
|
2007-09-15 14:36:07 -06:00
|
|
|
if (csum_good)
|
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[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 17:41:36 -06:00
|
|
|
ibmveth_rxq_harvest_buffer(adapter);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[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 17:41:36 -06:00
|
|
|
skb_reserve(skb, offset);
|
|
|
|
skb_put(skb, length);
|
|
|
|
skb->protocol = eth_type_trans(skb, netdev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[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 17:41:36 -06:00
|
|
|
netif_receive_skb(skb); /* send it up */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-03 18:41:50 -06:00
|
|
|
netdev->stats.rx_packets++;
|
|
|
|
netdev->stats.rx_bytes += length;
|
[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 17:41:36 -06:00
|
|
|
frames_processed++;
|
|
|
|
netdev->last_rx = jiffies;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
[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 17:41:36 -06:00
|
|
|
} while (frames_processed < budget);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-10-26 10:47:08 -06:00
|
|
|
ibmveth_replenish_task(adapter);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[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 17:41:36 -06:00
|
|
|
if (frames_processed < budget) {
|
|
|
|
/* We think we are done - reenable interrupts,
|
|
|
|
* then check once more to make sure we are done.
|
|
|
|
*/
|
|
|
|
lpar_rc = h_vio_signal(adapter->vdev->unit_address,
|
|
|
|
VIO_IRQ_ENABLE);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[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 17:41:36 -06:00
|
|
|
ibmveth_assert(lpar_rc == H_SUCCESS);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[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 17:41:36 -06:00
|
|
|
netif_rx_complete(netdev, napi);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[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 17:41:36 -06:00
|
|
|
if (ibmveth_rxq_pending_buffer(adapter) &&
|
|
|
|
netif_rx_reschedule(netdev, napi)) {
|
|
|
|
lpar_rc = h_vio_signal(adapter->vdev->unit_address,
|
|
|
|
VIO_IRQ_DISABLE);
|
|
|
|
goto restart_poll;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
[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 17:41:36 -06:00
|
|
|
return frames_processed;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
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 07:55:46 -06:00
|
|
|
static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance)
|
2006-05-23 23:31:14 -06:00
|
|
|
{
|
2005-04-16 16:20:36 -06:00
|
|
|
struct net_device *netdev = dev_instance;
|
|
|
|
struct ibmveth_adapter *adapter = netdev->priv;
|
|
|
|
unsigned long lpar_rc;
|
|
|
|
|
[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 17:41:36 -06:00
|
|
|
if (netif_rx_schedule_prep(netdev, &adapter->napi)) {
|
|
|
|
lpar_rc = h_vio_signal(adapter->vdev->unit_address,
|
|
|
|
VIO_IRQ_DISABLE);
|
2006-03-30 05:49:40 -07:00
|
|
|
ibmveth_assert(lpar_rc == H_SUCCESS);
|
[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 17:41:36 -06:00
|
|
|
__netif_rx_schedule(netdev, &adapter->napi);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ibmveth_set_multicast_list(struct net_device *netdev)
|
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = netdev->priv;
|
|
|
|
unsigned long lpar_rc;
|
|
|
|
|
|
|
|
if((netdev->flags & IFF_PROMISC) || (netdev->mc_count > adapter->mcastFilterSize)) {
|
|
|
|
lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
|
|
|
|
IbmVethMcastEnableRecv |
|
|
|
|
IbmVethMcastDisableFiltering,
|
|
|
|
0);
|
2006-03-30 05:49:40 -07:00
|
|
|
if(lpar_rc != H_SUCCESS) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ibmveth_error_printk("h_multicast_ctrl rc=%ld when entering promisc mode\n", lpar_rc);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct dev_mc_list *mclist = netdev->mc_list;
|
|
|
|
int i;
|
|
|
|
/* clear the filter table & disable filtering */
|
|
|
|
lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
|
|
|
|
IbmVethMcastEnableRecv |
|
|
|
|
IbmVethMcastDisableFiltering |
|
|
|
|
IbmVethMcastClearFilterTable,
|
|
|
|
0);
|
2006-03-30 05:49:40 -07:00
|
|
|
if(lpar_rc != H_SUCCESS) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ibmveth_error_printk("h_multicast_ctrl rc=%ld when attempting to clear filter table\n", lpar_rc);
|
|
|
|
}
|
|
|
|
/* add the addresses to the filter table */
|
|
|
|
for(i = 0; i < netdev->mc_count; ++i, mclist = mclist->next) {
|
|
|
|
// add the multicast address to the filter table
|
|
|
|
unsigned long mcast_addr = 0;
|
|
|
|
memcpy(((char *)&mcast_addr)+2, mclist->dmi_addr, 6);
|
|
|
|
lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
|
|
|
|
IbmVethMcastAddFilter,
|
|
|
|
mcast_addr);
|
2006-03-30 05:49:40 -07:00
|
|
|
if(lpar_rc != H_SUCCESS) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ibmveth_error_printk("h_multicast_ctrl rc=%ld when adding an entry to the filter table\n", lpar_rc);
|
|
|
|
}
|
|
|
|
}
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* re-enable filtering */
|
|
|
|
lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
|
|
|
|
IbmVethMcastEnableFiltering,
|
|
|
|
0);
|
2006-03-30 05:49:40 -07:00
|
|
|
if(lpar_rc != H_SUCCESS) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ibmveth_error_printk("h_multicast_ctrl rc=%ld when enabling filtering\n", lpar_rc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ibmveth_change_mtu(struct net_device *dev, int new_mtu)
|
|
|
|
{
|
2005-10-26 10:47:01 -06:00
|
|
|
struct ibmveth_adapter *adapter = dev->priv;
|
2008-07-23 12:34:52 -06:00
|
|
|
struct vio_dev *viodev = adapter->vdev;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
int new_mtu_oh = new_mtu + IBMVETH_BUFF_OH;
|
2008-07-23 12:34:52 -06:00
|
|
|
int i;
|
2005-10-26 10:47:01 -06:00
|
|
|
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
if (new_mtu < IBMVETH_MAX_MTU)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
2005-10-26 10:47:01 -06:00
|
|
|
|
2007-06-08 13:05:17 -06:00
|
|
|
for (i = 0; i < IbmVethNumBufferPools; i++)
|
|
|
|
if (new_mtu_oh < adapter->rx_buff_pool[i].buff_size)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (i == IbmVethNumBufferPools)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-07-23 12:34:23 -06:00
|
|
|
/* Deactivate all the buffer pools so that the next loop can activate
|
|
|
|
only the buffer pools necessary to hold the new MTU */
|
|
|
|
for (i = 0; i < IbmVethNumBufferPools; i++)
|
|
|
|
if (adapter->rx_buff_pool[i].active) {
|
|
|
|
ibmveth_free_buffer_pool(adapter,
|
|
|
|
&adapter->rx_buff_pool[i]);
|
|
|
|
adapter->rx_buff_pool[i].active = 0;
|
|
|
|
}
|
|
|
|
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
/* Look for an active buffer pool that can hold the new MTU */
|
2005-10-26 10:47:01 -06:00
|
|
|
for(i = 0; i<IbmVethNumBufferPools; i++) {
|
2008-07-23 12:34:23 -06:00
|
|
|
adapter->rx_buff_pool[i].active = 1;
|
2007-06-08 13:05:17 -06:00
|
|
|
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
if (new_mtu_oh < adapter->rx_buff_pool[i].buff_size) {
|
2008-07-23 12:34:23 -06:00
|
|
|
if (netif_running(adapter->netdev)) {
|
2007-06-08 13:05:17 -06:00
|
|
|
adapter->pool_config = 1;
|
|
|
|
ibmveth_close(adapter->netdev);
|
|
|
|
adapter->pool_config = 0;
|
|
|
|
dev->mtu = new_mtu;
|
2008-07-23 12:34:52 -06:00
|
|
|
vio_cmo_set_dev_desired(viodev,
|
|
|
|
ibmveth_get_desired_dma
|
|
|
|
(viodev));
|
|
|
|
return ibmveth_open(adapter->netdev);
|
|
|
|
}
|
|
|
|
dev->mtu = new_mtu;
|
|
|
|
vio_cmo_set_dev_desired(viodev,
|
|
|
|
ibmveth_get_desired_dma
|
|
|
|
(viodev));
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
return 0;
|
2005-10-26 10:47:01 -06:00
|
|
|
}
|
|
|
|
}
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-10-03 11:24:28 -06:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
static void ibmveth_poll_controller(struct net_device *dev)
|
|
|
|
{
|
|
|
|
ibmveth_replenish_task(dev->priv);
|
2006-10-10 15:33:30 -06:00
|
|
|
ibmveth_interrupt(dev->irq, dev);
|
2006-10-03 11:24:28 -06:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-07-23 12:34:52 -06:00
|
|
|
/**
|
|
|
|
* ibmveth_get_desired_dma - Calculate IO memory desired by the driver
|
|
|
|
*
|
|
|
|
* @vdev: struct vio_dev for the device whose desired IO mem is to be returned
|
|
|
|
*
|
|
|
|
* Return value:
|
|
|
|
* Number of bytes of IO data the driver will need to perform well.
|
|
|
|
*/
|
|
|
|
static unsigned long ibmveth_get_desired_dma(struct vio_dev *vdev)
|
|
|
|
{
|
|
|
|
struct net_device *netdev = dev_get_drvdata(&vdev->dev);
|
|
|
|
struct ibmveth_adapter *adapter;
|
|
|
|
unsigned long ret;
|
|
|
|
int i;
|
|
|
|
int rxqentries = 1;
|
|
|
|
|
|
|
|
/* netdev inits at probe time along with the structures we need below*/
|
|
|
|
if (netdev == NULL)
|
|
|
|
return IOMMU_PAGE_ALIGN(IBMVETH_IO_ENTITLEMENT_DEFAULT);
|
|
|
|
|
|
|
|
adapter = netdev_priv(netdev);
|
|
|
|
|
|
|
|
ret = IBMVETH_BUFF_LIST_SIZE + IBMVETH_FILT_LIST_SIZE;
|
|
|
|
ret += IOMMU_PAGE_ALIGN(netdev->mtu);
|
|
|
|
|
|
|
|
for (i = 0; i < IbmVethNumBufferPools; i++) {
|
|
|
|
/* add the size of the active receive buffers */
|
|
|
|
if (adapter->rx_buff_pool[i].active)
|
|
|
|
ret +=
|
|
|
|
adapter->rx_buff_pool[i].size *
|
|
|
|
IOMMU_PAGE_ALIGN(adapter->rx_buff_pool[i].
|
|
|
|
buff_size);
|
|
|
|
rxqentries += adapter->rx_buff_pool[i].size;
|
|
|
|
}
|
|
|
|
/* add the size of the receive queue entries */
|
|
|
|
ret += IOMMU_PAGE_ALIGN(rxqentries * sizeof(struct ibmveth_rx_q_entry));
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_id *id)
|
|
|
|
{
|
2005-10-26 10:47:01 -06:00
|
|
|
int rc, i;
|
2007-09-15 14:36:07 -06:00
|
|
|
long ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct net_device *netdev;
|
2007-08-06 15:44:03 -06:00
|
|
|
struct ibmveth_adapter *adapter;
|
2007-08-17 08:16:56 -06:00
|
|
|
u64 set_attr, ret_attr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
unsigned char *mac_addr_p;
|
|
|
|
unsigned int *mcastFilterSize_p;
|
|
|
|
|
|
|
|
|
2006-05-23 23:31:14 -06:00
|
|
|
ibmveth_debug_printk_no_adapter("entering ibmveth_probe for UA 0x%x\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
dev->unit_address);
|
|
|
|
|
2007-04-16 21:12:55 -06:00
|
|
|
mac_addr_p = (unsigned char *) vio_get_attribute(dev,
|
|
|
|
VETH_MAC_ADDR, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if(!mac_addr_p) {
|
|
|
|
printk(KERN_ERR "(%s:%3.3d) ERROR: Can't find VETH_MAC_ADDR "
|
|
|
|
"attribute\n", __FILE__, __LINE__);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2007-04-16 21:12:55 -06:00
|
|
|
mcastFilterSize_p = (unsigned int *) vio_get_attribute(dev,
|
|
|
|
VETH_MCAST_FILTER_SIZE, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if(!mcastFilterSize_p) {
|
|
|
|
printk(KERN_ERR "(%s:%3.3d) ERROR: Can't find "
|
|
|
|
"VETH_MCAST_FILTER_SIZE attribute\n",
|
|
|
|
__FILE__, __LINE__);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
netdev = alloc_etherdev(sizeof(struct ibmveth_adapter));
|
|
|
|
|
|
|
|
if(!netdev)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
adapter = netdev->priv;
|
|
|
|
dev->dev.driver_data = netdev;
|
|
|
|
|
|
|
|
adapter->vdev = dev;
|
|
|
|
adapter->netdev = netdev;
|
|
|
|
adapter->mcastFilterSize= *mcastFilterSize_p;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
adapter->pool_config = 0;
|
2006-05-23 23:31:14 -06:00
|
|
|
|
[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 17:41:36 -06:00
|
|
|
netif_napi_add(netdev, &adapter->napi, ibmveth_poll, 16);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Some older boxes running PHYP non-natively have an OF that
|
2006-05-23 23:31:14 -06:00
|
|
|
returns a 8-byte local-mac-address field (and the first
|
2005-04-16 16:20:36 -06:00
|
|
|
2 bytes have to be ignored) while newer boxes' OF return
|
2006-05-23 23:31:14 -06:00
|
|
|
a 6-byte field. Note that IEEE 1275 specifies that
|
2005-04-16 16:20:36 -06:00
|
|
|
local-mac-address must be a 6-byte field.
|
2006-05-23 23:31:14 -06:00
|
|
|
The RPA doc specifies that the first byte must be 10b, so
|
2005-04-16 16:20:36 -06:00
|
|
|
we'll just look for it to solve this 8 vs. 6 byte field issue */
|
|
|
|
|
|
|
|
if ((*mac_addr_p & 0x3) != 0x02)
|
|
|
|
mac_addr_p += 2;
|
|
|
|
|
|
|
|
adapter->mac_addr = 0;
|
|
|
|
memcpy(&adapter->mac_addr, mac_addr_p, 6);
|
|
|
|
|
|
|
|
netdev->irq = dev->irq;
|
|
|
|
netdev->open = ibmveth_open;
|
|
|
|
netdev->stop = ibmveth_close;
|
|
|
|
netdev->hard_start_xmit = ibmveth_start_xmit;
|
|
|
|
netdev->set_multicast_list = ibmveth_set_multicast_list;
|
|
|
|
netdev->do_ioctl = ibmveth_ioctl;
|
|
|
|
netdev->ethtool_ops = &netdev_ethtool_ops;
|
|
|
|
netdev->change_mtu = ibmveth_change_mtu;
|
|
|
|
SET_NETDEV_DEV(netdev, &dev->dev);
|
2006-10-03 11:24:28 -06:00
|
|
|
#ifdef CONFIG_NET_POLL_CONTROLLER
|
|
|
|
netdev->poll_controller = ibmveth_poll_controller;
|
|
|
|
#endif
|
2006-05-23 23:31:14 -06:00
|
|
|
netdev->features |= NETIF_F_LLTX;
|
2005-10-26 10:47:16 -06:00
|
|
|
spin_lock_init(&adapter->stats_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
memcpy(&netdev->dev_addr, &adapter->mac_addr, netdev->addr_len);
|
|
|
|
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
for(i = 0; i<IbmVethNumBufferPools; i++) {
|
|
|
|
struct kobject *kobj = &adapter->rx_buff_pool[i].kobj;
|
2007-12-17 12:54:39 -07:00
|
|
|
int error;
|
|
|
|
|
2006-05-23 23:31:14 -06:00
|
|
|
ibmveth_init_buffer_pool(&adapter->rx_buff_pool[i], i,
|
|
|
|
pool_count[i], pool_size[i],
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
pool_active[i]);
|
2007-12-17 12:54:39 -07:00
|
|
|
error = kobject_init_and_add(kobj, &ktype_veth_pool,
|
|
|
|
&dev->dev.kobj, "pool%d", i);
|
|
|
|
if (!error)
|
|
|
|
kobject_uevent(kobj, KOBJ_ADD);
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ibmveth_debug_printk("adapter @ 0x%p\n", adapter);
|
|
|
|
|
|
|
|
adapter->buffer_list_dma = DMA_ERROR_CODE;
|
|
|
|
adapter->filter_list_dma = DMA_ERROR_CODE;
|
|
|
|
adapter->rx_queue.queue_dma = DMA_ERROR_CODE;
|
|
|
|
|
|
|
|
ibmveth_debug_printk("registering netdev...\n");
|
|
|
|
|
2007-08-17 08:16:56 -06:00
|
|
|
ret = h_illan_attributes(dev->unit_address, 0, 0, &ret_attr);
|
2007-09-15 14:36:07 -06:00
|
|
|
|
2007-08-17 08:16:56 -06:00
|
|
|
if (ret == H_SUCCESS && !(ret_attr & IBMVETH_ILLAN_ACTIVE_TRUNK) &&
|
|
|
|
!(ret_attr & IBMVETH_ILLAN_TRUNK_PRI_MASK) &&
|
|
|
|
(ret_attr & IBMVETH_ILLAN_PADDED_PKT_CSUM)) {
|
|
|
|
set_attr = IBMVETH_ILLAN_IPV4_TCP_CSUM;
|
2007-09-15 14:36:07 -06:00
|
|
|
|
2007-08-17 08:16:56 -06:00
|
|
|
ret = h_illan_attributes(dev->unit_address, 0, set_attr, &ret_attr);
|
2007-09-15 14:36:07 -06:00
|
|
|
|
2007-08-17 08:16:31 -06:00
|
|
|
if (ret == H_SUCCESS) {
|
|
|
|
adapter->rx_csum = 1;
|
2007-09-15 14:36:07 -06:00
|
|
|
netdev->features |= NETIF_F_IP_CSUM;
|
2007-08-17 08:16:31 -06:00
|
|
|
} else
|
2007-08-17 08:16:56 -06:00
|
|
|
ret = h_illan_attributes(dev->unit_address, set_attr, 0, &ret_attr);
|
2007-09-15 14:36:07 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = register_netdev(netdev);
|
|
|
|
|
|
|
|
if(rc) {
|
|
|
|
ibmveth_debug_printk("failed to register netdev rc=%d\n", rc);
|
|
|
|
free_netdev(netdev);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
ibmveth_debug_printk("registered\n");
|
|
|
|
|
|
|
|
ibmveth_proc_register_adapter(adapter);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __devexit ibmveth_remove(struct vio_dev *dev)
|
|
|
|
{
|
|
|
|
struct net_device *netdev = dev->dev.driver_data;
|
|
|
|
struct ibmveth_adapter *adapter = netdev->priv;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i = 0; i<IbmVethNumBufferPools; i++)
|
2007-12-20 09:13:05 -07:00
|
|
|
kobject_put(&adapter->rx_buff_pool[i].kobj);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
unregister_netdev(netdev);
|
|
|
|
|
|
|
|
ibmveth_proc_unregister_adapter(adapter);
|
|
|
|
|
|
|
|
free_netdev(netdev);
|
2008-07-23 12:34:52 -06:00
|
|
|
dev_set_drvdata(&dev->dev, NULL);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
static void ibmveth_proc_register_driver(void)
|
|
|
|
{
|
2007-09-12 04:01:34 -06:00
|
|
|
ibmveth_proc_dir = proc_mkdir(IBMVETH_PROC_DIR, init_net.proc_net);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ibmveth_proc_dir) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ibmveth_proc_unregister_driver(void)
|
|
|
|
{
|
2007-09-12 04:01:34 -06:00
|
|
|
remove_proc_entry(IBMVETH_PROC_DIR, init_net.proc_net);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-02-18 03:55:10 -07:00
|
|
|
static int ibmveth_show(struct seq_file *seq, void *v)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ibmveth_adapter *adapter = seq->private;
|
|
|
|
char *current_mac = ((char*) &adapter->netdev->dev_addr);
|
|
|
|
char *firmware_mac = ((char*) &adapter->mac_addr) ;
|
|
|
|
|
|
|
|
seq_printf(seq, "%s %s\n\n", ibmveth_driver_string, ibmveth_driver_version);
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "Unit Address: 0x%x\n", adapter->vdev->unit_address);
|
2008-10-27 16:59:26 -06:00
|
|
|
seq_printf(seq, "Current MAC: %pM\n", current_mac);
|
|
|
|
seq_printf(seq, "Firmware MAC: %pM\n", firmware_mac);
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "\nAdapter Statistics:\n");
|
2007-08-17 08:16:49 -06:00
|
|
|
seq_printf(seq, " TX: vio_map_single failres: %ld\n", adapter->tx_map_failed);
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, " send failures: %ld\n", adapter->tx_send_failed);
|
|
|
|
seq_printf(seq, " RX: replenish task cycles: %ld\n", adapter->replenish_task_cycles);
|
|
|
|
seq_printf(seq, " alloc_skb_failures: %ld\n", adapter->replenish_no_mem);
|
|
|
|
seq_printf(seq, " add buffer failures: %ld\n", adapter->replenish_add_buff_failure);
|
|
|
|
seq_printf(seq, " invalid buffers: %ld\n", adapter->rx_invalid_buffer);
|
|
|
|
seq_printf(seq, " no buffers: %ld\n", adapter->rx_no_buffer);
|
2006-05-23 23:31:14 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ibmveth_proc_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2008-02-18 03:55:10 -07:00
|
|
|
return single_open(file, ibmveth_show, PDE(inode)->data);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-12 01:55:34 -07:00
|
|
|
static const struct file_operations ibmveth_proc_fops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = ibmveth_proc_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2008-02-18 03:55:10 -07:00
|
|
|
.release = single_release,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
|
|
|
struct proc_dir_entry *entry;
|
|
|
|
if (ibmveth_proc_dir) {
|
2006-10-03 11:24:39 -06:00
|
|
|
char u_addr[10];
|
|
|
|
sprintf(u_addr, "%x", adapter->vdev->unit_address);
|
2008-04-29 02:02:29 -06:00
|
|
|
entry = proc_create_data(u_addr, S_IFREG, ibmveth_proc_dir,
|
|
|
|
&ibmveth_proc_fops, adapter);
|
|
|
|
if (!entry)
|
2005-04-16 16:20:36 -06:00
|
|
|
ibmveth_error_printk("Cannot create adapter proc entry");
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter *adapter)
|
|
|
|
{
|
|
|
|
if (ibmveth_proc_dir) {
|
2006-10-03 11:24:39 -06:00
|
|
|
char u_addr[10];
|
|
|
|
sprintf(u_addr, "%x", adapter->vdev->unit_address);
|
|
|
|
remove_proc_entry(u_addr, ibmveth_proc_dir);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* CONFIG_PROC_FS */
|
2006-05-23 23:31:14 -06:00
|
|
|
static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2006-05-23 23:31:14 -06:00
|
|
|
static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter *adapter)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
}
|
|
|
|
static void ibmveth_proc_register_driver(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ibmveth_proc_unregister_driver(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_PROC_FS */
|
|
|
|
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
static struct attribute veth_active_attr;
|
|
|
|
static struct attribute veth_num_attr;
|
|
|
|
static struct attribute veth_size_attr;
|
|
|
|
|
|
|
|
static ssize_t veth_pool_show(struct kobject * kobj,
|
|
|
|
struct attribute * attr, char * buf)
|
|
|
|
{
|
2006-05-23 23:31:14 -06:00
|
|
|
struct ibmveth_buff_pool *pool = container_of(kobj,
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
struct ibmveth_buff_pool,
|
|
|
|
kobj);
|
|
|
|
|
|
|
|
if (attr == &veth_active_attr)
|
|
|
|
return sprintf(buf, "%d\n", pool->active);
|
|
|
|
else if (attr == &veth_num_attr)
|
|
|
|
return sprintf(buf, "%d\n", pool->size);
|
|
|
|
else if (attr == &veth_size_attr)
|
|
|
|
return sprintf(buf, "%d\n", pool->buff_size);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t veth_pool_store(struct kobject * kobj, struct attribute * attr,
|
|
|
|
const char * buf, size_t count)
|
|
|
|
{
|
2006-05-23 23:31:14 -06:00
|
|
|
struct ibmveth_buff_pool *pool = container_of(kobj,
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
struct ibmveth_buff_pool,
|
|
|
|
kobj);
|
2006-05-23 23:31:14 -06:00
|
|
|
struct net_device *netdev =
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
container_of(kobj->parent, struct device, kobj)->driver_data;
|
|
|
|
struct ibmveth_adapter *adapter = netdev->priv;
|
|
|
|
long value = simple_strtol(buf, NULL, 10);
|
|
|
|
long rc;
|
|
|
|
|
|
|
|
if (attr == &veth_active_attr) {
|
|
|
|
if (value && !pool->active) {
|
2007-06-08 13:05:16 -06:00
|
|
|
if (netif_running(netdev)) {
|
|
|
|
if(ibmveth_alloc_buffer_pool(pool)) {
|
|
|
|
ibmveth_error_printk("unable to alloc pool\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
pool->active = 1;
|
|
|
|
adapter->pool_config = 1;
|
|
|
|
ibmveth_close(netdev);
|
|
|
|
adapter->pool_config = 0;
|
|
|
|
if ((rc = ibmveth_open(netdev)))
|
|
|
|
return rc;
|
|
|
|
} else
|
|
|
|
pool->active = 1;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
} else if (!value && pool->active) {
|
|
|
|
int mtu = netdev->mtu + IBMVETH_BUFF_OH;
|
|
|
|
int i;
|
|
|
|
/* Make sure there is a buffer pool with buffers that
|
|
|
|
can hold a packet of the size of the MTU */
|
2007-08-02 21:55:19 -06:00
|
|
|
for (i = 0; i < IbmVethNumBufferPools; i++) {
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
if (pool == &adapter->rx_buff_pool[i])
|
|
|
|
continue;
|
|
|
|
if (!adapter->rx_buff_pool[i].active)
|
|
|
|
continue;
|
2007-08-02 21:55:19 -06:00
|
|
|
if (mtu <= adapter->rx_buff_pool[i].buff_size)
|
|
|
|
break;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
}
|
2007-08-02 21:55:19 -06:00
|
|
|
|
|
|
|
if (i == IbmVethNumBufferPools) {
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
ibmveth_error_printk("no active pool >= MTU\n");
|
|
|
|
return -EPERM;
|
|
|
|
}
|
2007-08-02 21:55:19 -06:00
|
|
|
|
|
|
|
if (netif_running(netdev)) {
|
|
|
|
adapter->pool_config = 1;
|
|
|
|
ibmveth_close(netdev);
|
2008-07-23 12:34:23 -06:00
|
|
|
pool->active = 0;
|
2007-08-02 21:55:19 -06:00
|
|
|
adapter->pool_config = 0;
|
|
|
|
if ((rc = ibmveth_open(netdev)))
|
|
|
|
return rc;
|
|
|
|
}
|
2008-07-23 12:34:23 -06:00
|
|
|
pool->active = 0;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
}
|
|
|
|
} else if (attr == &veth_num_attr) {
|
|
|
|
if (value <= 0 || value > IBMVETH_MAX_POOL_COUNT)
|
|
|
|
return -EINVAL;
|
|
|
|
else {
|
2007-06-08 13:05:16 -06:00
|
|
|
if (netif_running(netdev)) {
|
|
|
|
adapter->pool_config = 1;
|
|
|
|
ibmveth_close(netdev);
|
|
|
|
adapter->pool_config = 0;
|
|
|
|
pool->size = value;
|
|
|
|
if ((rc = ibmveth_open(netdev)))
|
|
|
|
return rc;
|
|
|
|
} else
|
|
|
|
pool->size = value;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
}
|
|
|
|
} else if (attr == &veth_size_attr) {
|
|
|
|
if (value <= IBMVETH_BUFF_OH || value > IBMVETH_MAX_BUF_SIZE)
|
|
|
|
return -EINVAL;
|
|
|
|
else {
|
2007-06-08 13:05:16 -06:00
|
|
|
if (netif_running(netdev)) {
|
|
|
|
adapter->pool_config = 1;
|
|
|
|
ibmveth_close(netdev);
|
|
|
|
adapter->pool_config = 0;
|
|
|
|
pool->buff_size = value;
|
|
|
|
if ((rc = ibmveth_open(netdev)))
|
|
|
|
return rc;
|
|
|
|
} else
|
|
|
|
pool->buff_size = value;
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* kick the interrupt handler to allocate/deallocate pools */
|
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 07:55:46 -06:00
|
|
|
ibmveth_interrupt(netdev->irq, netdev);
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#define ATTR(_name, _mode) \
|
|
|
|
struct attribute veth_##_name##_attr = { \
|
2007-06-13 12:45:17 -06:00
|
|
|
.name = __stringify(_name), .mode = _mode, \
|
[PATCH] ibmveth change buffer pools dynamically
This patch provides a sysfs interface to change some properties of the
ibmveth buffer pools (size of the buffers, number of buffers per pool,
and whether a pool is active). Ethernet drivers use ethtool to provide
this type of functionality. However, the buffers in the ibmveth driver
can have an arbitrary size (not only regular, mini, and jumbo which are
the only sizes that ethtool can change), and also ibmveth can have an
arbitrary number of buffer pools
Under heavy load we have seen dropped packets which obviously kills TCP
performance. We have created several fixes that mitigate this issue,
but we definitely need a way of changing the number of buffers for an
adapter dynamically. Also, changing the size of the buffers allows
users to change the MTU to something big (bigger than a jumbo frame)
greatly improving performance on partition to partition transfers.
The patch creates directories pool1...pool4 in the device directory in
sysfs, each with files: num, size, and active (which default to the
values in the mainline version).
Comments and suggestions are welcome...
--
Santiago A. Leon
Power Linux Development
IBM Linux Technology Center
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-04-25 10:19:59 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static ATTR(active, 0644);
|
|
|
|
static ATTR(num, 0644);
|
|
|
|
static ATTR(size, 0644);
|
|
|
|
|
|
|
|
static struct attribute * veth_pool_attrs[] = {
|
|
|
|
&veth_active_attr,
|
|
|
|
&veth_num_attr,
|
|
|
|
&veth_size_attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct sysfs_ops veth_pool_ops = {
|
|
|
|
.show = veth_pool_show,
|
|
|
|
.store = veth_pool_store,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct kobj_type ktype_veth_pool = {
|
|
|
|
.release = NULL,
|
|
|
|
.sysfs_ops = &veth_pool_ops,
|
|
|
|
.default_attrs = veth_pool_attrs,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct vio_device_id ibmveth_device_table[] __devinitdata= {
|
|
|
|
{ "network", "IBM,l-lan"},
|
2005-08-17 00:42:59 -06:00
|
|
|
{ "", "" }
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(vio, ibmveth_device_table);
|
|
|
|
|
|
|
|
static struct vio_driver ibmveth_driver = {
|
2005-10-23 22:53:21 -06:00
|
|
|
.id_table = ibmveth_device_table,
|
|
|
|
.probe = ibmveth_probe,
|
|
|
|
.remove = ibmveth_remove,
|
2008-07-23 12:34:52 -06:00
|
|
|
.get_desired_dma = ibmveth_get_desired_dma,
|
2005-10-23 22:53:21 -06:00
|
|
|
.driver = {
|
|
|
|
.name = ibmveth_driver_name,
|
2005-10-23 23:12:22 -06:00
|
|
|
.owner = THIS_MODULE,
|
2005-10-23 22:53:21 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __init ibmveth_module_init(void)
|
|
|
|
{
|
|
|
|
ibmveth_printk("%s: %s %s\n", ibmveth_driver_name, ibmveth_driver_string, ibmveth_driver_version);
|
|
|
|
|
|
|
|
ibmveth_proc_register_driver();
|
|
|
|
|
|
|
|
return vio_register_driver(&ibmveth_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit ibmveth_module_exit(void)
|
|
|
|
{
|
|
|
|
vio_unregister_driver(&ibmveth_driver);
|
|
|
|
ibmveth_proc_unregister_driver();
|
2006-05-23 23:31:14 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
module_init(ibmveth_module_init);
|
|
|
|
module_exit(ibmveth_module_exit);
|