sgi-xp: enable XPNET to handle more than 64 partitions

 */

#include <linux/module.h>

#include <linux/types.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/ioport.h>

#include <linux/mii.h>

#include <linux/smp.h>

#include <linux/string.h>

#include <asm/sn/io.h>

#include <asm/sn/sn_sal.h>

#include <asm/atomic.h>

#include "xp.h"

 * then be released.

 */

struct xpnet_pending_msg {

	struct list_head free_list;

	struct sk_buff *skb;

	atomic_t use_count;

};

 * When we are notified of other partitions activating, we add them to

 * our bitmask of partitions to which we broadcast.

 */

static u64 xpnet_broadcast_partitions;

static unsigned long *xpnet_broadcast_partitions;

/* protect above */

static DEFINE_SPINLOCK(xpnet_broadcast_lock);

#define XPNET_DEF_MTU (0x8000UL)

/*

 * The partition id is encapsulated in the MAC address.  The following

 * define locates the octet the partid is in.

 * The partid is encapsulated in the MAC address beginning in the following

 * octet and it consists of two octets.

 */

#define XPNET_PARTID_OCTET	1

#define XPNET_LICENSE_OCTET	2

#define XPNET_PARTID_OCTET	2

/* Define the XPNET debug device structures to be used with dev_dbg() et al */

/*

 * Define the XPNET debug device structure that is to be used with dev_dbg(),

 * dev_err(), dev_warn(), and dev_info().

 */

struct device_driver xpnet_dbg_name = {

	.name = "xpnet"

};

xpnet_connection_activity(enum xp_retval reason, short partid, int channel,

			  void *data, void *key)

{

	long bp;

	DBUG_ON(partid < 0 || partid >= xp_max_npartitions);

	DBUG_ON(channel != XPC_NET_CHANNEL);

	case xpConnected:	/* connection completed to a partition */

		spin_lock_bh(&xpnet_broadcast_lock);

		xpnet_broadcast_partitions |= 1UL << (partid - 1);

		bp = xpnet_broadcast_partitions;

		__set_bit(partid, xpnet_broadcast_partitions);

		spin_unlock_bh(&xpnet_broadcast_lock);

		netif_carrier_on(xpnet_device);

		dev_dbg(xpnet, "%s connection created to partition %d; "

			"xpnet_broadcast_partitions=0x%lx\n",

			xpnet_device->name, partid, bp);

		dev_dbg(xpnet, "%s connected to partition %d\n",

			xpnet_device->name, partid);

		break;

	default:

		spin_lock_bh(&xpnet_broadcast_lock);

		xpnet_broadcast_partitions &= ~(1UL << (partid - 1));

		bp = xpnet_broadcast_partitions;

		__clear_bit(partid, xpnet_broadcast_partitions);

		spin_unlock_bh(&xpnet_broadcast_lock);

		if (bp == 0)

		if (bitmap_empty((unsigned long *)xpnet_broadcast_partitions,

				 xp_max_npartitions)) {

			netif_carrier_off(xpnet_device);

		}

		dev_dbg(xpnet, "%s disconnected from partition %d; "

			"xpnet_broadcast_partitions=0x%lx\n",

			xpnet_device->name, partid, bp);

		dev_dbg(xpnet, "%s disconnected from partition %d\n",

			xpnet_device->name, partid);

		break;

	}

}

	}

}

static void

xpnet_send(struct sk_buff *skb, struct xpnet_pending_msg *queued_msg,

	   u64 start_addr, u64 end_addr, u16 embedded_bytes, int dest_partid)

{

	u8 msg_buffer[XPNET_MSG_SIZE];

	struct xpnet_message *msg = (struct xpnet_message *)&msg_buffer;

	enum xp_retval ret;

	msg->embedded_bytes = embedded_bytes;

	if (unlikely(embedded_bytes != 0)) {

		msg->version = XPNET_VERSION_EMBED;

		dev_dbg(xpnet, "calling memcpy(0x%p, 0x%p, 0x%lx)\n",

			&msg->data, skb->data, (size_t)embedded_bytes);

		skb_copy_from_linear_data(skb, &msg->data,

					  (size_t)embedded_bytes);

	} else {

		msg->version = XPNET_VERSION;

	}

	msg->magic = XPNET_MAGIC;

	msg->size = end_addr - start_addr;

	msg->leadin_ignore = (u64)skb->data - start_addr;

	msg->tailout_ignore = end_addr - (u64)skb_tail_pointer(skb);

	msg->buf_pa = __pa(start_addr);

	dev_dbg(xpnet, "sending XPC message to %d:%d\n"

		KERN_DEBUG "msg->buf_pa=0x%lx, msg->size=%u, "

		"msg->leadin_ignore=%u, msg->tailout_ignore=%u\n",

		dest_partid, XPC_NET_CHANNEL, msg->buf_pa, msg->size,

		msg->leadin_ignore, msg->tailout_ignore);

	atomic_inc(&queued_msg->use_count);

	ret = xpc_send_notify(dest_partid, XPC_NET_CHANNEL, XPC_NOWAIT, msg,

			      XPNET_MSG_SIZE, xpnet_send_completed, queued_msg);

	if (unlikely(ret != xpSuccess))

		atomic_dec(&queued_msg->use_count);

}

/*

 * Network layer has formatted a packet (skb) and is ready to place it

 * "on the wire".  Prepare and send an xpnet_message to all partitions

 * which have connected with us and are targets of this packet.

 *

 * MAC-NOTE:  For the XPNET driver, the MAC address contains the

 * destination partition_id.  If the destination partition id word

 * is 0xff, this packet is to broadcast to all partitions.

 * destination partid.  If the destination partid octets are 0xffff,

 * this packet is to be broadcast to all connected partitions.

 */

static int

xpnet_dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)

{

	struct xpnet_pending_msg *queued_msg;

	enum xp_retval ret;

	u8 msg_buffer[XPNET_MSG_SIZE];

	struct xpnet_message *msg = (struct xpnet_message *)&msg_buffer[0];

	u64 start_addr, end_addr;

	long dp;

	u8 second_mac_octet;

	short dest_partid;

	struct xpnet_dev_private *priv;

	u16 embedded_bytes;

	priv = (struct xpnet_dev_private *)dev->priv;

	struct xpnet_dev_private *priv = (struct xpnet_dev_private *)dev->priv;

	u16 embedded_bytes = 0;

	dev_dbg(xpnet, ">skb->head=0x%p skb->data=0x%p skb->tail=0x%p "

		"skb->end=0x%p skb->len=%d\n", (void *)skb->head,

		(void *)skb->data, skb_tail_pointer(skb), skb_end_pointer(skb),

		skb->len);

	if (skb->data[0] == 0x33) {

		dev_kfree_skb(skb);

		return 0;	/* nothing needed to be done */

	}

	/*

	 * The xpnet_pending_msg tracks how many outstanding

	 * xpc_send_notifies are relying on this skb.  When none

			 "packet\n", sizeof(struct xpnet_pending_msg));

		priv->stats.tx_errors++;

		return -ENOMEM;

	}

	end_addr = L1_CACHE_ALIGN((u64)skb_tail_pointer(skb));

	/* calculate how many bytes to embed in the XPC message */

	embedded_bytes = 0;

	if (unlikely(skb->len <= XPNET_MSG_DATA_MAX)) {

		/* skb->data does fit so embed */

		embedded_bytes = skb->len;

	atomic_set(&queued_msg->use_count, 1);

	queued_msg->skb = skb;

	second_mac_octet = skb->data[XPNET_PARTID_OCTET];

	if (second_mac_octet == 0xff) {

	if (skb->data[0] == 0xff) {

		/* we are being asked to broadcast to all partitions */

		dp = xpnet_broadcast_partitions;

	} else if (second_mac_octet != 0) {

		dp = xpnet_broadcast_partitions &

		    (1UL << (second_mac_octet - 1));

	} else {

		/* 0 is an invalid partid.  Ignore */

		dp = 0;

	}

	dev_dbg(xpnet, "destination Partitions mask (dp) = 0x%lx\n", dp);

	/*

	 * If we wanted to allow promiscuous mode to work like an

	 * unswitched network, this would be a good point to OR in a

	 * mask of partitions which should be receiving all packets.

	 */

	/*

	 * Main send loop.

	 */

	for (dest_partid = 0; dp && dest_partid < xp_max_npartitions;

	     dest_partid++) {

		for_each_bit(dest_partid, xpnet_broadcast_partitions,

			     xp_max_npartitions) {

		if (!(dp & (1UL << (dest_partid - 1)))) {

			/* not destined for this partition */

			continue;

			xpnet_send(skb, queued_msg, start_addr, end_addr,

				   embedded_bytes, dest_partid);

		}

		/* remove this partition from the destinations mask */

		dp &= ~(1UL << (dest_partid - 1));

		/* found a partition to send to */

		msg->embedded_bytes = embedded_bytes;

		if (unlikely(embedded_bytes != 0)) {

			msg->version = XPNET_VERSION_EMBED;

			dev_dbg(xpnet, "calling memcpy(0x%p, 0x%p, 0x%lx)\n",

				&msg->data, skb->data, (size_t)embedded_bytes);

			skb_copy_from_linear_data(skb, &msg->data,

						  (size_t)embedded_bytes);

	} else {

			msg->version = XPNET_VERSION;

		}

		msg->magic = XPNET_MAGIC;

		msg->size = end_addr - start_addr;

		msg->leadin_ignore = (u64)skb->data - start_addr;

		msg->tailout_ignore = end_addr - (u64)skb_tail_pointer(skb);

		msg->buf_pa = __pa(start_addr);

		dev_dbg(xpnet, "sending XPC message to %d:%d\n"

			KERN_DEBUG "msg->buf_pa=0x%lx, msg->size=%u, "

			"msg->leadin_ignore=%u, msg->tailout_ignore=%u\n",

			dest_partid, XPC_NET_CHANNEL, msg->buf_pa, msg->size,

			msg->leadin_ignore, msg->tailout_ignore);

		dest_partid = (short)skb->data[XPNET_PARTID_OCTET + 1];

		dest_partid |= (short)skb->data[XPNET_PARTID_OCTET + 0] << 8;

		atomic_inc(&queued_msg->use_count);

		if (dest_partid >= 0 &&

		    dest_partid < xp_max_npartitions &&

		    test_bit(dest_partid, xpnet_broadcast_partitions) != 0) {

		ret = xpc_send_notify(dest_partid, XPC_NET_CHANNEL, XPC_NOWAIT,

				      &msg, sizeof(msg) + embedded_bytes - 1,

				      xpnet_send_completed, queued_msg);

		if (unlikely(ret != xpSuccess)) {

			atomic_dec(&queued_msg->use_count);

			continue;

			xpnet_send(skb, queued_msg, start_addr, end_addr,

				   embedded_bytes, dest_partid);

		}

	}

	if (atomic_dec_return(&queued_msg->use_count) == 0) {

		dev_dbg(xpnet, "no partitions to receive packet destined for "

			"%d\n", dest_partid);

		dev_kfree_skb(skb);

		kfree(queued_msg);

	}

static int __init

xpnet_init(void)

{

	int i;

	u32 license_num;

	int result = -ENOMEM;

	int result;

	if (!ia64_platform_is("sn2"))

	if (!is_shub() && !is_uv())

		return -ENODEV;

	dev_info(xpnet, "registering network device %s\n", XPNET_DEVICE_NAME);

	xpnet_broadcast_partitions = kzalloc(BITS_TO_LONGS(xp_max_npartitions) *

					     sizeof(long), GFP_KERNEL);

	if (xpnet_broadcast_partitions == NULL)

		return -ENOMEM;

	/*

	 * use ether_setup() to init the majority of our device

	 * structure and then override the necessary pieces.

	 */

	xpnet_device = alloc_netdev(sizeof(struct xpnet_dev_private),

				    XPNET_DEVICE_NAME, ether_setup);

	if (xpnet_device == NULL)

	if (xpnet_device == NULL) {

		kfree(xpnet_broadcast_partitions);

		return -ENOMEM;

	}

	netif_carrier_off(xpnet_device);

	 * MAC addresses.  We chose the first octet of the MAC to be unlikely

	 * to collide with any vendor's officially issued MAC.

	 */

	xpnet_device->dev_addr[0] = 0xfe;

	xpnet_device->dev_addr[XPNET_PARTID_OCTET] = sn_partition_id;

	license_num = sn_partition_serial_number_val();

	for (i = 3; i >= 0; i--) {

		xpnet_device->dev_addr[XPNET_LICENSE_OCTET + i] =

		    license_num & 0xff;

		license_num = license_num >> 8;

	}

	xpnet_device->dev_addr[0] = 0x02;     /* locally administered, no OUI */

	xpnet_device->dev_addr[XPNET_PARTID_OCTET + 1] = sn_partition_id;

	xpnet_device->dev_addr[XPNET_PARTID_OCTET + 0] = (sn_partition_id >> 8);

	/*

	 * ether_setup() sets this to a multicast device.  We are

	xpnet_device->features = NETIF_F_NO_CSUM;

	result = register_netdev(xpnet_device);

	if (result != 0)

	if (result != 0) {

		free_netdev(xpnet_device);

		kfree(xpnet_broadcast_partitions);

	}

	return result;

}

		 xpnet_device[0].name);

	unregister_netdev(xpnet_device);

	free_netdev(xpnet_device);

	kfree(xpnet_broadcast_partitions);

}

module_exit(xpnet_exit);