Commit f148f61d authored by Santiago Leon's avatar Santiago Leon Committed by David S. Miller
Browse files

ibmveth: Coding style fixes 



Fix most of the kernel coding style issues in ibmveth.

Signed-off-by: default avatarAnton Blanchard <anton@samba.org>
Signed-off-by: default avatarSantiago Leon <santil@linux.vnet.ibm.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 517e80e6

drivers/net/ibmveth.c

+172 −145
Original line number Diff line number Diff line 
/**************************************************************************/

/*                                                                        */

/* 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.   */

/*                                                                        */

/**************************************************************************/

/*

 * 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.

 */



#include <linux/module.h>

#include <linux/moduleparam.h>
@@ -75,7 +73,8 @@ static struct kobj_type ktype_veth_pool; 




static const char ibmveth_driver_name[] = "ibmveth";

static const char ibmveth_driver_string[] = "IBM i/pSeries Virtual Ethernet Driver";

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>");
@@ -108,8 +107,10 @@ struct ibmveth_stat { 
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) },

	{ "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) },
@@ -126,36 +127,39 @@ static inline u32 ibmveth_rxq_flags(struct ibmveth_adapter *adapter) 


static inline int ibmveth_rxq_toggle(struct ibmveth_adapter *adapter)

{

	return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_TOGGLE) >> IBMVETH_RXQ_TOGGLE_SHIFT;

	return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_TOGGLE) >>

			IBMVETH_RXQ_TOGGLE_SHIFT;

}



static inline int ibmveth_rxq_pending_buffer(struct ibmveth_adapter *adapter)

{

	return (ibmveth_rxq_toggle(adapter) == adapter->rx_queue.toggle);

	return ibmveth_rxq_toggle(adapter) == adapter->rx_queue.toggle;

}



static inline int ibmveth_rxq_buffer_valid(struct ibmveth_adapter *adapter)

{

	return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_VALID);

	return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_VALID;

}



static inline int ibmveth_rxq_frame_offset(struct ibmveth_adapter *adapter)

{

	return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_OFF_MASK);

	return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_OFF_MASK;

}



static inline int ibmveth_rxq_frame_length(struct ibmveth_adapter *adapter)

{

	return (adapter->rx_queue.queue_addr[adapter->rx_queue.index].length);

	return adapter->rx_queue.queue_addr[adapter->rx_queue.index].length;

}



static inline int ibmveth_rxq_csum_good(struct ibmveth_adapter *adapter)

{

	return (ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_CSUM_GOOD);

	return ibmveth_rxq_flags(adapter) & IBMVETH_RXQ_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, u32 pool_active)

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;
@@ -171,9 +175,8 @@ static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool *pool) 


	pool->free_map = kmalloc(sizeof(u16) * pool->size, GFP_KERNEL);



	if(!pool->free_map) {

	if (!pool->free_map)

		return -1;

	}



	pool->dma_addr = kmalloc(sizeof(dma_addr_t) * pool->size, GFP_KERNEL);

	if (!pool->dma_addr) {
@@ -195,9 +198,8 @@ static int ibmveth_alloc_buffer_pool(struct ibmveth_buff_pool *pool) 


	memset(pool->dma_addr, 0, sizeof(dma_addr_t) * pool->size);



	for(i = 0; i < pool->size; ++i) {

	for (i = 0; i < pool->size; ++i)

		pool->free_map[i] = i;

	}



	atomic_set(&pool->available, 0);

	pool->producer_index = 0;
@@ -217,7 +219,8 @@ static inline void ibmveth_flush_buffer(void *addr, unsigned long length) 
/* 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)

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);
@@ -273,11 +276,12 @@ static void ibmveth_replenish_buffer_pool(struct ibmveth_adapter *adapter, struc 
						IBMVETH_BUFF_OH);

			ibmveth_flush_buffer(skb->data, len);

		}

		lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address, desc.desc);

		lpar_rc = h_add_logical_lan_buffer(adapter->vdev->unit_address,

						   desc.desc);



		if (lpar_rc != H_SUCCESS)

		if (lpar_rc != H_SUCCESS) {

			goto failure;

		else {

		} else {

			buffers_added++;

			adapter->replenish_add_buff_success++;

		}
@@ -320,11 +324,13 @@ static void ibmveth_replenish_task(struct ibmveth_adapter *adapter) 
			ibmveth_replenish_buffer_pool(adapter, pool);

	}



	adapter->rx_no_buffer = *(u64*)(((char*)adapter->buffer_list_addr) + 4096 - 8);

	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)

static void ibmveth_free_buffer_pool(struct ibmveth_adapter *adapter,

				     struct ibmveth_buff_pool *pool)

{

	int i;
@@ -357,7 +363,8 @@ static void ibmveth_free_buffer_pool(struct ibmveth_adapter *adapter, struct ibm 
}



/* remove a buffer from a pool */

static void ibmveth_remove_buffer_from_pool(struct ibmveth_adapter *adapter, u64 correlator)

static void ibmveth_remove_buffer_from_pool(struct ibmveth_adapter *adapter,

					    u64 correlator)

{

	unsigned int pool  = correlator >> 32;

	unsigned int index = correlator & 0xffffffffUL;
@@ -510,9 +517,11 @@ static int ibmveth_register_logical_lan(struct ibmveth_adapter *adapter, 
{

	int rc, try_again = 1;



	/* After a kexec the adapter will still be open, so our attempt to

	/*

	 * 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. */

	 * try again, but only once.

	 */

retry:

	rc = h_register_logical_lan(adapter->vdev->unit_address,

				    adapter->buffer_list_dma, rxq_desc.desc,
@@ -559,8 +568,10 @@ static int ibmveth_open(struct net_device *netdev) 
		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);

	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) {

		netdev_err(netdev, "unable to allocate rx queue pages\n");
@@ -596,7 +607,8 @@ static int ibmveth_open(struct net_device *netdev) 
	memcpy(&mac_address, netdev->dev_addr, netdev->addr_len);

	mac_address = mac_address >> 16;



	rxq_desc.fields.flags_len = IBMVETH_BUF_VALID | adapter->rx_queue.queue_len;

	rxq_desc.fields.flags_len = IBMVETH_BUF_VALID |

					adapter->rx_queue.queue_len;

	rxq_desc.fields.address = adapter->rx_queue.queue_dma;



	netdev_dbg(netdev, "buffer list @ 0x%p\n", adapter->buffer_list_addr);
@@ -634,7 +646,9 @@ static int ibmveth_open(struct net_device *netdev) 
	}



	netdev_dbg(netdev, "registering irq 0x%x\n", netdev->irq);

	if((rc = request_irq(netdev->irq, ibmveth_interrupt, 0, netdev->name, netdev)) != 0) {

	rc = request_irq(netdev->irq, ibmveth_interrupt, 0, netdev->name,

			 netdev);

	if (rc != 0) {

		netdev_err(netdev, "unable to request irq 0x%x, rc %d\n",

			   netdev->irq, rc);

		do {
@@ -692,15 +706,15 @@ static int ibmveth_close(struct net_device *netdev) 
		lpar_rc = h_free_logical_lan(adapter->vdev->unit_address);

	} while (H_IS_LONG_BUSY(lpar_rc) || (lpar_rc == H_BUSY));



	if(lpar_rc != H_SUCCESS)

	{

	if (lpar_rc != H_SUCCESS) {

		netdev_err(netdev, "h_free_logical_lan failed with %lx, "

			   "continuing with close\n", lpar_rc);

	}



	free_irq(netdev->irq, netdev);



	adapter->rx_no_buffer = *(u64*)(((char*)adapter->buffer_list_addr) + 4096 - 8);

	adapter->rx_no_buffer = *(u64 *)(((char *)adapter->buffer_list_addr) +

						4096 - 8);



	ibmveth_cleanup(adapter);
@@ -709,9 +723,12 @@ static int ibmveth_close(struct net_device *netdev) 
	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);

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;
@@ -723,12 +740,16 @@ static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 
	return 0;

}



static void netdev_get_drvinfo (struct net_device *dev, struct ethtool_drvinfo *info) {

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);

	strncpy(info->version, ibmveth_driver_version,

		sizeof(info->version) - 1);

}



static u32 netdev_get_link(struct net_device *dev) {

static u32 netdev_get_link(struct net_device *dev)

{

	return 1;

}
@@ -736,15 +757,16 @@ static void ibmveth_set_rx_csum_flags(struct net_device *dev, u32 data) 
{

	struct ibmveth_adapter *adapter = netdev_priv(dev);



	if (data)

	if (data) {

		adapter->rx_csum = 1;

	else {

	} 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.

		 * 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;
@@ -811,8 +833,9 @@ static int ibmveth_set_csum_offload(struct net_device *dev, u32 data, 


			ret = h_illan_attributes(adapter->vdev->unit_address,

						 set_attr, clr_attr, &ret_attr);

		} else

		} else {

			adapter->fw_ipv4_csum_support = data;

		}



		ret6 = h_illan_attributes(adapter->vdev->unit_address,

					 clr_attr6, set_attr6, &ret_attr);
@@ -866,7 +889,8 @@ static int ibmveth_set_tx_csum(struct net_device *dev, u32 data) 
		return 0;



	if (data && !adapter->rx_csum)

		rc = ibmveth_set_csum_offload(dev, data, ibmveth_set_tx_csum_flags);

		rc = ibmveth_set_csum_offload(dev, data,

					      ibmveth_set_tx_csum_flags);

	else

		ibmveth_set_tx_csum_flags(dev, data);
@@ -1091,7 +1115,8 @@ static netdev_tx_t ibmveth_start_xmit(struct sk_buff *skb, 


static int ibmveth_poll(struct napi_struct *napi, int budget)

{

	struct ibmveth_adapter *adapter = container_of(napi, struct ibmveth_adapter, napi);

	struct ibmveth_adapter *adapter =

			container_of(napi, struct ibmveth_adapter, napi);

	struct net_device *netdev = adapter->netdev;

	int frames_processed = 0;

	unsigned long lpar_rc;
@@ -1216,7 +1241,7 @@ static void ibmveth_set_multicast_list(struct net_device *netdev) 
		}

		/* add the addresses to the filter table */

		netdev_for_each_mc_addr(ha, netdev) {

			// add the multicast address to the filter table

			/* add the multicast address to the filter table */

			unsigned long mcast_addr = 0;

			memcpy(((char *)&mcast_addr)+2, ha->addr, 6);

			lpar_rc = h_multicast_ctrl(adapter->vdev->unit_address,
@@ -1351,21 +1376,20 @@ static const struct net_device_ops ibmveth_netdev_ops = { 
#endif

};



static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_id *id)

static int __devinit ibmveth_probe(struct vio_dev *dev,

				   const struct vio_device_id *id)

{

	int rc, i;

	struct net_device *netdev;

	struct ibmveth_adapter *adapter;



	unsigned char *mac_addr_p;

	unsigned int *mcastFilterSize_p;





	dev_dbg(&dev->dev, "entering ibmveth_probe for UA 0x%x\n",

		dev->unit_address);



	mac_addr_p = (unsigned char *) vio_get_attribute(dev,

						VETH_MAC_ADDR, NULL);

	mac_addr_p = (unsigned char *)vio_get_attribute(dev, VETH_MAC_ADDR,

							NULL);

	if (!mac_addr_p) {

		dev_err(&dev->dev, "Can't find VETH_MAC_ADDR attribute\n");

		return 0;
@@ -1394,14 +1418,14 @@ static int __devinit ibmveth_probe(struct vio_dev *dev, const struct vio_device_ 


	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

		2 bytes have to be ignored) while newer boxes' OF return

		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

		we'll just look for it to solve this 8 vs. 6 byte field issue */



	/*

	 * Some older boxes running PHYP non-natively have an OF that 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 local-mac-address must be a 6-byte field.

	 * 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)

		mac_addr_p += 2;
@@ -1515,8 +1539,9 @@ const char * buf, size_t count) 
				adapter->pool_config = 0;

				if ((rc = ibmveth_open(netdev)))

					return rc;

			} else

			} else {

				pool->active = 1;

			}

		} else if (!value && pool->active) {

			int mtu = netdev->mtu + IBMVETH_BUFF_OH;

			int i;
@@ -1547,9 +1572,9 @@ const char * buf, size_t count) 
			pool->active = 0;

		}

	} else if (attr == &veth_num_attr) {

		if (value <= 0 || value > IBMVETH_MAX_POOL_COUNT)

		if (value <= 0 || value > IBMVETH_MAX_POOL_COUNT) {

			return -EINVAL;

		else {

		} else {

			if (netif_running(netdev)) {

				adapter->pool_config = 1;

				ibmveth_close(netdev);
@@ -1557,13 +1582,14 @@ const char * buf, size_t count) 
				pool->size = value;

				if ((rc = ibmveth_open(netdev)))

					return rc;

			} else

			} else {

				pool->size = value;

			}

		}

	} else if (attr == &veth_size_attr) {

		if (value <= IBMVETH_BUFF_OH || value > IBMVETH_MAX_BUF_SIZE)

		if (value <= IBMVETH_BUFF_OH || value > IBMVETH_MAX_BUF_SIZE) {

			return -EINVAL;

		else {

		} else {

			if (netif_running(netdev)) {

				adapter->pool_config = 1;

				ibmveth_close(netdev);
@@ -1571,10 +1597,11 @@ const char * buf, size_t count) 
				pool->buff_size = value;

				if ((rc = ibmveth_open(netdev)))

					return rc;

			} else

			} else {

				pool->buff_size = value;

			}

		}

	}



	/* kick the interrupt handler to allocate/deallocate pools */

	ibmveth_interrupt(netdev->irq, netdev);