ibmveth: Add ethtool driver stats hooks
[linux-2.6.git] / drivers / net / ibmveth.c
index 52d0102..40cb00e 100644 (file)
@@ -24,7 +24,7 @@
 /* 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.   */
-/*                                                                        */ 
+/*                                                                        */
 /**************************************************************************/
 /*
   TODO:
@@ -33,7 +33,6 @@
   - possibly remove procfs support
 */
 
-#include <linux/config.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/mm.h>
 #include <linux/ethtool.h>
 #include <linux/proc_fs.h>
+#include <linux/in.h>
+#include <linux/ip.h>
+#include <net/net_namespace.h>
 #include <asm/semaphore.h>
 #include <asm/hvcall.h>
 #include <asm/atomic.h>
-#include <asm/iommu.h>
 #include <asm/vio.h>
 #include <asm/uaccess.h>
 #include <linux/seq_file.h>
@@ -61,7 +62,7 @@
 #undef DEBUG
 
 #define ibmveth_printk(fmt, args...) \
-  printk(KERN_INFO "%s: " fmt, __FILE__, ## args)
+  printk(KERN_DEBUG "%s: " fmt, __FILE__, ## args)
 
 #define ibmveth_error_printk(fmt, args...) \
   printk(KERN_ERR "(%s:%3.3d ua:%x) ERROR: " fmt, __FILE__, __LINE__ , adapter->vdev->unit_address, ## args)
 #else
 #define ibmveth_debug_printk_no_adapter(fmt, args...)
 #define ibmveth_debug_printk(fmt, args...)
-#define ibmveth_assert(expr) 
+#define ibmveth_assert(expr)
 #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);
-static int ibmveth_poll(struct net_device *dev, int *budget);
+static int ibmveth_poll(struct napi_struct *napi, int budget);
 static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *dev);
 static struct net_device_stats *ibmveth_get_stats(struct net_device *dev);
 static void ibmveth_set_multicast_list(struct net_device *dev);
@@ -94,11 +95,12 @@ 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);
-static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
-static inline void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter);
+static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance);
+static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter);
+static struct kobj_type ktype_veth_pool;
 
 #ifdef CONFIG_PROC_FS
-#define IBMVETH_PROC_DIR "net/ibmveth"
+#define IBMVETH_PROC_DIR "ibmveth"
 static struct proc_dir_entry *ibmveth_proc_dir;
 #endif
 
@@ -111,6 +113,28 @@ MODULE_DESCRIPTION("IBM i/pSeries Virtual Ethernet Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(ibmveth_driver_version);
 
+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_multidesc_send", IBMVETH_STAT_OFF(tx_multidesc_send) },
+       { "tx_linearized", IBMVETH_STAT_OFF(tx_linearized) },
+       { "tx_linearize_failed", IBMVETH_STAT_OFF(tx_linearize_failed) },
+       { "tx_map_failed", IBMVETH_STAT_OFF(tx_map_failed) },
+       { "tx_send_failed", IBMVETH_STAT_OFF(tx_send_failed) },
+};
+
 /* simple methods of getting data from the current rxq entry */
 static inline int ibmveth_rxq_pending_buffer(struct ibmveth_adapter *adapter)
 {
@@ -132,13 +156,19 @@ static inline int ibmveth_rxq_frame_length(struct ibmveth_adapter *adapter)
        return (adapter->rx_queue.queue_addr[adapter->rx_queue.index].length);
 }
 
+static inline int ibmveth_rxq_csum_good(struct ibmveth_adapter *adapter)
+{
+       return (adapter->rx_queue.queue_addr[adapter->rx_queue.index].csum_good);
+}
+
 /* setup the initial settings for a buffer pool */
-static void ibmveth_init_buffer_pool(struct ibmveth_buff_pool *pool, u32 pool_index, u32 pool_size, u32 buff_size)
+static void ibmveth_init_buffer_pool(struct ibmveth_buff_pool *pool, u32 pool_index, u32 pool_size, u32 buff_size, u32 pool_active)
 {
        pool->size = pool_size;
        pool->index = pool_index;
        pool->buff_size = buff_size;
        pool->threshold = pool_size / 2;
+       pool->active = pool_active;
 }
 
 /* allocate and setup an buffer pool - called during open */
@@ -146,13 +176,13 @@ static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool *pool)
 {
        int i;
 
-       pool->free_map = kmalloc(sizeof(u16) * pool->size, GFP_KERNEL); 
+       pool->free_map = kmalloc(sizeof(u16) * pool->size, GFP_KERNEL);
 
        if(!pool->free_map) {
                return -1;
        }
 
-       pool->dma_addr = kmalloc(sizeof(dma_addr_t) * pool->size, GFP_KERNEL); 
+       pool->dma_addr = kmalloc(sizeof(dma_addr_t) * pool->size, GFP_KERNEL);
        if(!pool->dma_addr) {
                kfree(pool->free_map);
                pool->free_map = NULL;
@@ -180,7 +210,6 @@ static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool *pool)
        atomic_set(&pool->available, 0);
        pool->producer_index = 0;
        pool->consumer_index = 0;
-       pool->active = 0;
 
        return 0;
 }
@@ -212,9 +241,10 @@ static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, struc
                        break;
                }
 
-               free_index = pool->consumer_index++ % pool->size;
+               free_index = pool->consumer_index;
+               pool->consumer_index = (pool->consumer_index + 1) % pool->size;
                index = pool->free_map[free_index];
-       
+
                ibmveth_assert(index != IBM_VETH_INVALID_MAP);
                ibmveth_assert(pool->skbuff[index] == NULL);
 
@@ -231,14 +261,17 @@ static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, struc
                desc.desc = 0;
                desc.fields.valid = 1;
                desc.fields.length = pool->buff_size;
-               desc.fields.address = dma_addr; 
+               desc.fields.address = dma_addr;
 
                lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address, desc.desc);
-                   
+
                if(lpar_rc != H_SUCCESS) {
                        pool->free_map[free_index] = index;
                        pool->skbuff[index] = NULL;
-                       pool->consumer_index--;
+                       if (pool->consumer_index == 0)
+                               pool->consumer_index = pool->size - 1;
+                       else
+                               pool->consumer_index--;
                        dma_unmap_single(&adapter->vdev->dev,
                                        pool->dma_addr[index], pool->buff_size,
                                        DMA_FROM_DEVICE);
@@ -250,13 +283,13 @@ static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, struc
                        adapter->replenish_add_buff_success++;
                }
        }
-    
+
        mb();
        atomic_add(buffers_added, &(pool->available));
 }
 
 /* replenish routine */
-static void ibmveth_replenish_task(struct ibmveth_adapter *adapter) 
+static void ibmveth_replenish_task(struct ibmveth_adapter *adapter)
 {
        int i;
 
@@ -264,7 +297,7 @@ static void ibmveth_replenish_task(struct ibmveth_adapter *adapter)
 
        for(i = 0; i < IbmVethNumBufferPools; i++)
                if(adapter->rx_buff_pool[i].active)
-                       ibmveth_replenish_buffer_pool(adapter, 
+                       ibmveth_replenish_buffer_pool(adapter,
                                                     &adapter->rx_buff_pool[i]);
 
        adapter->rx_no_buffer = *(u64*)(((char*)adapter->buffer_list_addr) + 4096 - 8);
@@ -301,7 +334,6 @@ static void ibmveth_free_buffer_pool(struct ibmveth_adapter *adapter, struct ibm
                kfree(pool->skbuff);
                pool->skbuff = NULL;
        }
-       pool->active = 0;
 }
 
 /* remove a buffer from a pool */
@@ -326,7 +358,10 @@ static void ibmveth_remove_buffer_from_pool(struct ibmveth_adapter *adapter, u64
                         adapter->rx_buff_pool[pool].buff_size,
                         DMA_FROM_DEVICE);
 
-       free_index = adapter->rx_buff_pool[pool].producer_index++ % adapter->rx_buff_pool[pool].size;
+       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;
        adapter->rx_buff_pool[pool].free_map[free_index] = index;
 
        mb();
@@ -372,7 +407,7 @@ static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
        desc.fields.address = adapter->rx_buff_pool[pool].dma_addr[index];
 
        lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address, desc.desc);
-                   
+
        if(lpar_rc != H_SUCCESS) {
                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);
@@ -384,7 +419,7 @@ static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
        }
 }
 
-static inline void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter)
+static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter)
 {
        ibmveth_remove_buffer_from_pool(adapter, adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator);
 
@@ -407,7 +442,7 @@ static void ibmveth_cleanup(struct ibmveth_adapter *adapter)
                }
                free_page((unsigned long)adapter->buffer_list_addr);
                adapter->buffer_list_addr = NULL;
-       } 
+       }
 
        if(adapter->filter_list_addr != NULL) {
                if(!dma_mapping_error(adapter->filter_list_dma)) {
@@ -433,7 +468,34 @@ static void ibmveth_cleanup(struct ibmveth_adapter *adapter)
        }
 
        for(i = 0; i<IbmVethNumBufferPools; i++)
-               ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[i]);
+               if (adapter->rx_buff_pool[i].active)
+                       ibmveth_free_buffer_pool(adapter,
+                                                &adapter->rx_buff_pool[i]);
+}
+
+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;
 }
 
 static int ibmveth_open(struct net_device *netdev)
@@ -448,15 +510,18 @@ static int ibmveth_open(struct net_device *netdev)
 
        ibmveth_debug_printk("open starting\n");
 
+       napi_enable(&adapter->napi);
+
        for(i = 0; i<IbmVethNumBufferPools; i++)
                rxq_entries += adapter->rx_buff_pool[i].size;
-    
+
        adapter->buffer_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
        adapter->filter_list_addr = (void*) get_zeroed_page(GFP_KERNEL);
+
        if(!adapter->buffer_list_addr || !adapter->filter_list_addr) {
                ibmveth_error_printk("unable to allocate filter or buffer list pages\n");
                ibmveth_cleanup(adapter);
+               napi_disable(&adapter->napi);
                return -ENOMEM;
        }
 
@@ -466,6 +531,7 @@ static int ibmveth_open(struct net_device *netdev)
        if(!adapter->rx_queue.queue_addr) {
                ibmveth_error_printk("unable to allocate rx queue pages\n");
                ibmveth_cleanup(adapter);
+               napi_disable(&adapter->napi);
                return -ENOMEM;
        }
 
@@ -482,6 +548,7 @@ static int ibmveth_open(struct net_device *netdev)
           (dma_mapping_error(adapter->rx_queue.queue_dma))) {
                ibmveth_error_printk("unable to map filter or buffer list pages\n");
                ibmveth_cleanup(adapter);
+               napi_disable(&adapter->napi);
                return -ENOMEM;
        }
 
@@ -489,9 +556,6 @@ static int ibmveth_open(struct net_device *netdev)
        adapter->rx_queue.num_slots = rxq_entries;
        adapter->rx_queue.toggle = 1;
 
-       /* call change_mtu to init the buffer pools based in initial mtu */
-       ibmveth_change_mtu(netdev, netdev->mtu);
-
        memcpy(&mac_address, netdev->dev_addr, netdev->addr_len);
        mac_address = mac_address >> 16;
 
@@ -504,12 +568,9 @@ static int ibmveth_open(struct net_device *netdev)
        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);
 
-    
-       lpar_rc = h_register_logical_lan(adapter->vdev->unit_address,
-                                        adapter->buffer_list_dma,
-                                        rxq_desc.desc,
-                                        adapter->filter_list_dma,
-                                        mac_address);
+       h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
+
+       lpar_rc = ibmveth_register_logical_lan(adapter, rxq_desc, mac_address);
 
        if(lpar_rc != H_SUCCESS) {
                ibmveth_error_printk("h_register_logical_lan failed with %ld\n", lpar_rc);
@@ -519,7 +580,20 @@ static int ibmveth_open(struct net_device *netdev)
                                     rxq_desc.desc,
                                     mac_address);
                ibmveth_cleanup(adapter);
-               return -ENONET; 
+               napi_disable(&adapter->napi);
+               return -ENONET;
+       }
+
+       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);
+                       napi_disable(&adapter->napi);
+                       return -ENOMEM ;
+               }
        }
 
        ibmveth_debug_printk("registering irq 0x%x\n", netdev->irq);
@@ -530,11 +604,12 @@ static int ibmveth_open(struct net_device *netdev)
                } while (H_IS_LONG_BUSY(rc) || (rc == H_BUSY));
 
                ibmveth_cleanup(adapter);
+               napi_disable(&adapter->napi);
                return rc;
        }
 
        ibmveth_debug_printk("initial replenish cycle\n");
-       ibmveth_interrupt(netdev->irq, netdev, NULL);
+       ibmveth_interrupt(netdev->irq, netdev);
 
        netif_start_queue(netdev);
 
@@ -547,10 +622,13 @@ static int ibmveth_close(struct net_device *netdev)
 {
        struct ibmveth_adapter *adapter = netdev->priv;
        long lpar_rc;
-    
+
        ibmveth_debug_printk("close starting\n");
 
-       netif_stop_queue(netdev);
+       napi_disable(&adapter->napi);
+
+       if (!adapter->pool_config)
+               netif_stop_queue(netdev);
 
        free_irq(netdev->irq, netdev);
 
@@ -596,12 +674,163 @@ static u32 netdev_get_link(struct net_device *dev) {
        return 1;
 }
 
-static struct ethtool_ops netdev_ethtool_ops = {
+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;
+       union ibmveth_illan_attributes set_attr, clr_attr, ret_attr;
+       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;
+       }
+
+       set_attr.desc = 0;
+       clr_attr.desc = 0;
+
+       if (data)
+               set_attr.fields.tcp_csum_offload_ipv4 = 1;
+       else
+               clr_attr.fields.tcp_csum_offload_ipv4 = 1;
+
+       ret = h_illan_attributes(adapter->vdev->unit_address, 0, 0, &ret_attr.desc);
+
+       if (ret == H_SUCCESS && !ret_attr.fields.active_trunk &&
+           !ret_attr.fields.trunk_priority &&
+           ret_attr.fields.csum_offload_padded_pkt_support) {
+               ret = h_illan_attributes(adapter->vdev->unit_address, clr_attr.desc,
+                                        set_attr.desc, &ret_attr.desc);
+
+               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,
+                                                set_attr.desc, clr_attr.desc, &ret_attr.desc);
+               } else
+                       done(dev, data);
+       } else {
+               rc1 = -EIO;
+               ibmveth_error_printk("unable to change checksum offload settings."
+                                    " %d rc=%ld ret_attr=%lx\n", data, ret, ret_attr.desc);
+       }
+
+       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;
+}
+
+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);
+}
+
+static int ibmveth_get_stats_count(struct net_device *dev)
+{
+       return ARRAY_SIZE(ibmveth_stats);
+}
+
+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);
+}
+
+static const struct ethtool_ops netdev_ethtool_ops = {
        .get_drvinfo            = netdev_get_drvinfo,
        .get_settings           = netdev_get_settings,
        .get_link               = netdev_get_link,
        .get_sg                 = ethtool_op_get_sg,
        .get_tx_csum            = ethtool_op_get_tx_csum,
+       .set_tx_csum            = ibmveth_set_tx_csum,
+       .get_rx_csum            = ibmveth_get_rx_csum,
+       .set_rx_csum            = ibmveth_set_rx_csum,
+       .get_tso                        = ethtool_op_get_tso,
+       .get_ufo                        = ethtool_op_get_ufo,
+       .get_strings            = ibmveth_get_strings,
+       .get_stats_count                = ibmveth_get_stats_count,
+       .get_ethtool_stats      = ibmveth_get_ethtool_stats,
 };
 
 static int ibmveth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
@@ -646,6 +875,24 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                                        desc[0].fields.length, DMA_TO_DEVICE);
        desc[0].fields.valid   = 1;
 
+       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;
+
+               desc[0].fields.no_csum = 1;
+               desc[0].fields.csum_good = 1;
+
+               /* Need to zero out the checksum */
+               buf[0] = 0;
+               buf[1] = 0;
+       }
+
        if(dma_mapping_error(desc[0].fields.address)) {
                ibmveth_error_printk("tx: unable to map initial fragment\n");
                tx_map_failed++;
@@ -664,6 +911,10 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                                frag->size, DMA_TO_DEVICE);
                desc[curfrag+1].fields.length = frag->size;
                desc[curfrag+1].fields.valid  = 1;
+               if (skb->ip_summed == CHECKSUM_PARTIAL) {
+                       desc[curfrag+1].fields.no_csum = 1;
+                       desc[curfrag+1].fields.csum_good = 1;
+               }
 
                if(dma_mapping_error(desc[curfrag+1].fields.address)) {
                        ibmveth_error_printk("tx: unable to map fragment %d\n", curfrag);
@@ -692,9 +943,10 @@ static int ibmveth_start_xmit(struct sk_buff *skb, struct net_device *netdev)
                                             desc[3].desc,
                                             desc[4].desc,
                                             desc[5].desc,
-                                            correlator);
+                                            correlator,
+                                            &correlator);
        } while ((lpar_rc == H_BUSY) && (retry_count--));
-    
+
        if(lpar_rc != H_SUCCESS && lpar_rc != H_DROPPED) {
                int i;
                ibmveth_error_printk("tx: h_send_logical_lan failed with rc=%ld\n", lpar_rc);
@@ -728,93 +980,85 @@ out:      spin_lock_irqsave(&adapter->stats_lock, flags);
        return 0;
 }
 
-static int ibmveth_poll(struct net_device *netdev, int *budget)
+static int ibmveth_poll(struct napi_struct *napi, int budget)
 {
-       struct ibmveth_adapter *adapter = netdev->priv;
-       int max_frames_to_process = netdev->quota;
+       struct ibmveth_adapter *adapter = container_of(napi, struct ibmveth_adapter, napi);
+       struct net_device *netdev = adapter->netdev;
        int frames_processed = 0;
-       int more_work = 1;
        unsigned long lpar_rc;
 
  restart_poll:
        do {
-               struct net_device *netdev = adapter->netdev;
+               struct sk_buff *skb;
 
-               if(ibmveth_rxq_pending_buffer(adapter)) {
-                       struct sk_buff *skb;
+               if (!ibmveth_rxq_pending_buffer(adapter))
+                       break;
 
-                       rmb();
+               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);
+                       int csum_good = ibmveth_rxq_csum_good(adapter);
 
-                       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);
-                               skb = ibmveth_rxq_get_buffer(adapter);
+                       skb = ibmveth_rxq_get_buffer(adapter);
+                       if (csum_good)
+                               skb->ip_summed = CHECKSUM_UNNECESSARY;
 
-                               ibmveth_rxq_harvest_buffer(adapter);
+                       ibmveth_rxq_harvest_buffer(adapter);
 
-                               skb_reserve(skb, offset);
-                               skb_put(skb, length);
-                               skb->dev = netdev;
-                               skb->protocol = eth_type_trans(skb, netdev);
+                       skb_reserve(skb, offset);
+                       skb_put(skb, length);
+                       skb->protocol = eth_type_trans(skb, netdev);
 
-                               netif_receive_skb(skb); /* send it up */
+                       netif_receive_skb(skb); /* send it up */
 
-                               adapter->stats.rx_packets++;
-                               adapter->stats.rx_bytes += length;
-                               frames_processed++;
-                               netdev->last_rx = jiffies;
-                       }
-               } else {
-                       more_work = 0;
+                       adapter->stats.rx_packets++;
+                       adapter->stats.rx_bytes += length;
+                       frames_processed++;
+                       netdev->last_rx = jiffies;
                }
-       } while(more_work && (frames_processed < max_frames_to_process));
+       } while (frames_processed < budget);
 
        ibmveth_replenish_task(adapter);
 
-       if(more_work) {
-               /* more work to do - return that we are not done yet */
-               netdev->quota -= frames_processed;
-               *budget -= frames_processed;
-               return 1; 
-       }
-
-       /* 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);
+       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);
 
-       ibmveth_assert(lpar_rc == H_SUCCESS);
+               ibmveth_assert(lpar_rc == H_SUCCESS);
 
-       netif_rx_complete(netdev);
+               netif_rx_complete(netdev, napi);
 
-       if(ibmveth_rxq_pending_buffer(adapter) && netif_rx_reschedule(netdev, frames_processed))
-       {
-               lpar_rc = h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
-               ibmveth_assert(lpar_rc == H_SUCCESS);
-               more_work = 1;
-               goto restart_poll;
+               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;
+               }
        }
 
-       netdev->quota -= frames_processed;
-       *budget -= frames_processed;
-
-       /* we really are done */
-       return 0;
+       return frames_processed;
 }
 
-static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
-{   
+static irqreturn_t ibmveth_interrupt(int irq, void *dev_instance)
+{
        struct net_device *netdev = dev_instance;
        struct ibmveth_adapter *adapter = netdev->priv;
        unsigned long lpar_rc;
 
-       if(netif_rx_schedule_prep(netdev)) {
-               lpar_rc = h_vio_signal(adapter->vdev->unit_address, VIO_IRQ_DISABLE);
+       if (netif_rx_schedule_prep(netdev, &adapter->napi)) {
+               lpar_rc = h_vio_signal(adapter->vdev->unit_address,
+                                      VIO_IRQ_DISABLE);
                ibmveth_assert(lpar_rc == H_SUCCESS);
-               __netif_rx_schedule(netdev);
+               __netif_rx_schedule(netdev, &adapter->napi);
        }
        return IRQ_HANDLED;
 }
@@ -862,7 +1106,7 @@ static void ibmveth_set_multicast_list(struct net_device *netdev)
                                ibmveth_error_printk("h_multicast_ctrl rc=%ld when adding an entry to the filter table\n", lpar_rc);
                        }
                }
-       
+
                /* re-enable filtering */
                lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
                                           IbmVethMcastEnableFiltering,
@@ -876,76 +1120,83 @@ static void ibmveth_set_multicast_list(struct net_device *netdev)
 static int ibmveth_change_mtu(struct net_device *dev, int new_mtu)
 {
        struct ibmveth_adapter *adapter = dev->priv;
-       int i;
-       int prev_smaller = 1;
+       int new_mtu_oh = new_mtu + IBMVETH_BUFF_OH;
+       int reinit = 0;
+       int i, rc;
 
-       if ((new_mtu < 68) || 
-           (new_mtu > (pool_size[IbmVethNumBufferPools-1]) - IBMVETH_BUFF_OH))
+       if (new_mtu < IBMVETH_MAX_MTU)
                return -EINVAL;
 
-       for(i = 0; i<IbmVethNumBufferPools; i++) {
-               int activate = 0;
-               if (new_mtu > (pool_size[i]  - IBMVETH_BUFF_OH)) { 
-                       activate = 1;
-                       prev_smaller= 1;
-               } else {
-                       if (prev_smaller)
-                               activate = 1;
-                       prev_smaller= 0;
-               }
+       for (i = 0; i < IbmVethNumBufferPools; i++)
+               if (new_mtu_oh < adapter->rx_buff_pool[i].buff_size)
+                       break;
 
-               if (activate && !adapter->rx_buff_pool[i].active) {
-                       struct ibmveth_buff_pool *pool = 
-                                               &adapter->rx_buff_pool[i];
-                       if(ibmveth_alloc_buffer_pool(pool)) {
-                               ibmveth_error_printk("unable to alloc pool\n");
-                               return -ENOMEM;
-                       }
+       if (i == IbmVethNumBufferPools)
+               return -EINVAL;
+
+       /* Look for an active buffer pool that can hold the new MTU */
+       for(i = 0; i<IbmVethNumBufferPools; i++) {
+               if (!adapter->rx_buff_pool[i].active) {
                        adapter->rx_buff_pool[i].active = 1;
-               } else if (!activate && adapter->rx_buff_pool[i].active) {
-                       adapter->rx_buff_pool[i].active = 0;
-                       h_free_logical_lan_buffer(adapter->vdev->unit_address,
-                                         (u64)pool_size[i]);
+                       reinit = 1;
                }
 
+               if (new_mtu_oh < adapter->rx_buff_pool[i].buff_size) {
+                       if (reinit && netif_running(adapter->netdev)) {
+                               adapter->pool_config = 1;
+                               ibmveth_close(adapter->netdev);
+                               adapter->pool_config = 0;
+                               dev->mtu = new_mtu;
+                               if ((rc = ibmveth_open(adapter->netdev)))
+                                       return rc;
+                       } else
+                               dev->mtu = new_mtu;
+                       return 0;
+               }
        }
+       return -EINVAL;
+}
 
-       /* kick the interrupt handler so that the new buffer pools get
-          replenished or deallocated */
-       ibmveth_interrupt(dev->irq, dev, NULL);
-
-       dev->mtu = new_mtu;
-       return 0;       
+#ifdef CONFIG_NET_POLL_CONTROLLER
+static void ibmveth_poll_controller(struct net_device *dev)
+{
+       ibmveth_replenish_task(dev->priv);
+       ibmveth_interrupt(dev->irq, dev);
 }
+#endif
 
 static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_id *id)
 {
        int rc, i;
+       long ret;
        struct net_device *netdev;
-       struct ibmveth_adapter *adapter = NULL;
+       struct ibmveth_adapter *adapter;
+       union ibmveth_illan_attributes set_attr, ret_attr;
 
        unsigned char *mac_addr_p;
        unsigned int *mcastFilterSize_p;
 
 
-       ibmveth_debug_printk_no_adapter("entering ibmveth_probe for UA 0x%x\n", 
+       ibmveth_debug_printk_no_adapter("entering ibmveth_probe for UA 0x%x\n",
                                        dev->unit_address);
 
-       mac_addr_p = (unsigned char *) vio_get_attribute(dev, VETH_MAC_ADDR, 0);
+       mac_addr_p = (unsigned char *) vio_get_attribute(dev,
+                                               VETH_MAC_ADDR, NULL);
        if(!mac_addr_p) {
                printk(KERN_ERR "(%s:%3.3d) ERROR: Can't find VETH_MAC_ADDR "
                                "attribute\n", __FILE__, __LINE__);
                return 0;
        }
-       
-       mcastFilterSize_p= (unsigned int *) vio_get_attribute(dev, VETH_MCAST_FILTER_SIZE, 0);
+
+       mcastFilterSize_p = (unsigned int *) vio_get_attribute(dev,
+                                               VETH_MCAST_FILTER_SIZE, NULL);
        if(!mcastFilterSize_p) {
                printk(KERN_ERR "(%s:%3.3d) ERROR: Can't find "
                                "VETH_MCAST_FILTER_SIZE attribute\n",
                                __FILE__, __LINE__);
                return 0;
        }
-       
+
        netdev = alloc_etherdev(sizeof(struct ibmveth_adapter));
 
        if(!netdev)
@@ -954,19 +1205,21 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_
        SET_MODULE_OWNER(netdev);
 
        adapter = netdev->priv;
-       memset(adapter, 0, sizeof(adapter));
        dev->dev.driver_data = netdev;
 
        adapter->vdev = dev;
        adapter->netdev = netdev;
        adapter->mcastFilterSize= *mcastFilterSize_p;
-       
+       adapter->pool_config = 0;
+
+       netif_napi_add(netdev, &adapter->napi, ibmveth_poll, 16);
+
        /*      Some older boxes running PHYP non-natively have an OF that
-               returns a 8-byte local-mac-address field (and the first 
+               returns a 8-byte local-mac-address field (and the first
                2 bytes have to be ignored) while newer boxes' OF return
-               a 6-byte field. Note that IEEE 1275 specifies that 
+               a 6-byte field. Note that IEEE 1275 specifies that
                local-mac-address must be a 6-byte field.
-               The RPA doc specifies that the first byte must be 10b, so 
+               The RPA doc specifies that the first byte must be 10b, so
                we'll just look for it to solve this 8 vs. 6 byte field issue */
 
        if ((*mac_addr_p & 0x3) != 0x02)
@@ -975,12 +1228,8 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_
        adapter->mac_addr = 0;
        memcpy(&adapter->mac_addr, mac_addr_p, 6);
 
-       adapter->liobn = dev->iommu_table->it_index;
-       
        netdev->irq = dev->irq;
        netdev->open               = ibmveth_open;
-       netdev->poll               = ibmveth_poll;
-       netdev->weight             = 16;
        netdev->stop               = ibmveth_close;
        netdev->hard_start_xmit    = ibmveth_start_xmit;
        netdev->get_stats          = ibmveth_get_stats;
@@ -989,14 +1238,24 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_
        netdev->ethtool_ops           = &netdev_ethtool_ops;
        netdev->change_mtu         = ibmveth_change_mtu;
        SET_NETDEV_DEV(netdev, &dev->dev);
-       netdev->features |= NETIF_F_LLTX; 
+#ifdef CONFIG_NET_POLL_CONTROLLER
+       netdev->poll_controller = ibmveth_poll_controller;
+#endif
+       netdev->features |= NETIF_F_LLTX;
        spin_lock_init(&adapter->stats_lock);
 
        memcpy(&netdev->dev_addr, &adapter->mac_addr, netdev->addr_len);
 
-       for(i = 0; i<IbmVethNumBufferPools; i++)
-               ibmveth_init_buffer_pool(&adapter->rx_buff_pool[i], i, 
-                                        pool_count[i], pool_size[i]);
+       for(i = 0; i<IbmVethNumBufferPools; i++) {
+               struct kobject *kobj = &adapter->rx_buff_pool[i].kobj;
+               ibmveth_init_buffer_pool(&adapter->rx_buff_pool[i], i,
+                                        pool_count[i], pool_size[i],
+                                        pool_active[i]);
+               kobj->parent = &dev->dev.kobj;
+               sprintf(kobj->name, "pool%d", i);
+               kobj->ktype = &ktype_veth_pool;
+               kobject_register(kobj);
+       }
 
        ibmveth_debug_printk("adapter @ 0x%p\n", adapter);
 
@@ -1006,6 +1265,25 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_
 
        ibmveth_debug_printk("registering netdev...\n");
 
+       ret = h_illan_attributes(dev->unit_address, 0, 0, &ret_attr.desc);
+
+       if (ret == H_SUCCESS && !ret_attr.fields.active_trunk &&
+           !ret_attr.fields.trunk_priority &&
+           ret_attr.fields.csum_offload_padded_pkt_support) {
+               set_attr.desc = 0;
+               set_attr.fields.tcp_csum_offload_ipv4 = 1;
+
+               ret = h_illan_attributes(dev->unit_address, 0, set_attr.desc,
+                                        &ret_attr.desc);
+
+               if (ret == H_SUCCESS) {
+                       adapter->rx_csum = 1;
+                       netdev->features |= NETIF_F_IP_CSUM;
+               } else
+                       ret = h_illan_attributes(dev->unit_address, set_attr.desc,
+                                                0, &ret_attr.desc);
+       }
+
        rc = register_netdev(netdev);
 
        if(rc) {
@@ -1025,6 +1303,10 @@ static int __devexit ibmveth_remove(struct vio_dev *dev)
 {
        struct net_device *netdev = dev->dev.driver_data;
        struct ibmveth_adapter *adapter = netdev->priv;
+       int i;
+
+       for(i = 0; i<IbmVethNumBufferPools; i++)
+               kobject_unregister(&adapter->rx_buff_pool[i].kobj);
 
        unregister_netdev(netdev);
 
@@ -1037,7 +1319,7 @@ static int __devexit ibmveth_remove(struct vio_dev *dev)
 #ifdef CONFIG_PROC_FS
 static void ibmveth_proc_register_driver(void)
 {
-       ibmveth_proc_dir = proc_mkdir(IBMVETH_PROC_DIR, NULL);
+       ibmveth_proc_dir = proc_mkdir(IBMVETH_PROC_DIR, init_net.proc_net);
        if (ibmveth_proc_dir) {
                SET_MODULE_OWNER(ibmveth_proc_dir);
        }
@@ -1045,10 +1327,10 @@ static void ibmveth_proc_register_driver(void)
 
 static void ibmveth_proc_unregister_driver(void)
 {
-       remove_proc_entry(IBMVETH_PROC_DIR, NULL);
+       remove_proc_entry(IBMVETH_PROC_DIR, init_net.proc_net);
 }
 
-static void *ibmveth_seq_start(struct seq_file *seq, loff_t *pos) 
+static void *ibmveth_seq_start(struct seq_file *seq, loff_t *pos)
 {
        if (*pos == 0) {
                return (void *)1;
@@ -1063,27 +1345,26 @@ static void *ibmveth_seq_next(struct seq_file *seq, void *v, loff_t *pos)
        return NULL;
 }
 
-static void ibmveth_seq_stop(struct seq_file *seq, void *v) 
+static void ibmveth_seq_stop(struct seq_file *seq, void *v)
 {
 }
 
-static int ibmveth_seq_show(struct seq_file *seq, void *v) 
+static int ibmveth_seq_show(struct seq_file *seq, void *v)
 {
        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);
-       
+
        seq_printf(seq, "Unit Address:    0x%x\n", adapter->vdev->unit_address);
-       seq_printf(seq, "LIOBN:           0x%lx\n", adapter->liobn);
        seq_printf(seq, "Current MAC:     %02X:%02X:%02X:%02X:%02X:%02X\n",
                   current_mac[0], current_mac[1], current_mac[2],
                   current_mac[3], current_mac[4], current_mac[5]);
        seq_printf(seq, "Firmware MAC:    %02X:%02X:%02X:%02X:%02X:%02X\n",
                   firmware_mac[0], firmware_mac[1], firmware_mac[2],
                   firmware_mac[3], firmware_mac[4], firmware_mac[5]);
-       
+
        seq_printf(seq, "\nAdapter Statistics:\n");
        seq_printf(seq, "  TX:  skbuffs linearized:          %ld\n", adapter->tx_linearized);
        seq_printf(seq, "       multi-descriptor sends:      %ld\n", adapter->tx_multidesc_send);
@@ -1095,7 +1376,7 @@ static int ibmveth_seq_show(struct seq_file *seq, void *v)
        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);
-       
+
        return 0;
 }
 static struct seq_operations ibmveth_seq_ops = {
@@ -1121,7 +1402,7 @@ static int ibmveth_proc_open(struct inode *inode, struct file *file)
        return rc;
 }
 
-static struct file_operations ibmveth_proc_fops = {
+static const struct file_operations ibmveth_proc_fops = {
        .owner   = THIS_MODULE,
        .open    = ibmveth_proc_open,
        .read    = seq_read,
@@ -1133,7 +1414,9 @@ static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter)
 {
        struct proc_dir_entry *entry;
        if (ibmveth_proc_dir) {
-               entry = create_proc_entry(adapter->netdev->name, S_IFREG, ibmveth_proc_dir);
+               char u_addr[10];
+               sprintf(u_addr, "%x", adapter->vdev->unit_address);
+               entry = create_proc_entry(u_addr, S_IFREG, ibmveth_proc_dir);
                if (!entry) {
                        ibmveth_error_printk("Cannot create adapter proc entry");
                } else {
@@ -1148,16 +1431,18 @@ static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter)
 static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter *adapter)
 {
        if (ibmveth_proc_dir) {
-               remove_proc_entry(adapter->netdev->name, ibmveth_proc_dir);
+               char u_addr[10];
+               sprintf(u_addr, "%x", adapter->vdev->unit_address);
+               remove_proc_entry(u_addr, ibmveth_proc_dir);
        }
 }
 
 #else /* CONFIG_PROC_FS */
-static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter) 
+static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter)
 {
 }
 
-static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter *adapter) 
+static void ibmveth_proc_unregister_adapter(struct ibmveth_adapter *adapter)
 {
 }
 static void ibmveth_proc_register_driver(void)
@@ -1169,6 +1454,145 @@ static void ibmveth_proc_unregister_driver(void)
 }
 #endif /* CONFIG_PROC_FS */
 
+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)
+{
+       struct ibmveth_buff_pool *pool = container_of(kobj,
+                                                     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)
+{
+       struct ibmveth_buff_pool *pool = container_of(kobj,
+                                                     struct ibmveth_buff_pool,
+                                                     kobj);
+       struct net_device *netdev =
+           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) {
+                       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;
+               } 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 */
+                       for (i = 0; i < IbmVethNumBufferPools; i++) {
+                               if (pool == &adapter->rx_buff_pool[i])
+                                       continue;
+                               if (!adapter->rx_buff_pool[i].active)
+                                       continue;
+                               if (mtu <= adapter->rx_buff_pool[i].buff_size)
+                                       break;
+                       }
+
+                       if (i == IbmVethNumBufferPools) {
+                               ibmveth_error_printk("no active pool >= MTU\n");
+                               return -EPERM;
+                       }
+
+                       pool->active = 0;
+                       if (netif_running(netdev)) {
+                               adapter->pool_config = 1;
+                               ibmveth_close(netdev);
+                               adapter->pool_config = 0;
+                               if ((rc = ibmveth_open(netdev)))
+                                       return rc;
+                       }
+               }
+       } else if (attr == &veth_num_attr) {
+               if (value <= 0 || value > IBMVETH_MAX_POOL_COUNT)
+                       return -EINVAL;
+               else {
+                       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;
+               }
+       } else if (attr == &veth_size_attr) {
+               if (value <= IBMVETH_BUFF_OH || value > IBMVETH_MAX_BUF_SIZE)
+                       return -EINVAL;
+               else {
+                       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;
+               }
+       }
+
+       /* kick the interrupt handler to allocate/deallocate pools */
+       ibmveth_interrupt(netdev->irq, netdev);
+       return count;
+}
+
+
+#define ATTR(_name, _mode)      \
+        struct attribute veth_##_name##_attr = {               \
+        .name = __stringify(_name), .mode = _mode, \
+        };
+
+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,
+};
+
+
 static struct vio_device_id ibmveth_device_table[] __devinitdata= {
        { "network", "IBM,l-lan"},
        { "", "" }
@@ -1198,7 +1622,7 @@ static void __exit ibmveth_module_exit(void)
 {
        vio_unregister_driver(&ibmveth_driver);
        ibmveth_proc_unregister_driver();
-}      
+}
 
 module_init(ibmveth_module_init);
 module_exit(ibmveth_module_exit);