[IA64] run rest drivers/misc/sgi-xp through scripts/Lindent

 * Copyright (c) 2004-2008 Silicon Graphics, Inc.  All Rights Reserved.

 */

/*

 * Cross Partition Communication (XPC) channel support.

 *

 *

 */

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/sched.h>

#include <asm/sn/sn_sal.h>

#include "xpc.h"

/*

 * Guarantee that the kzalloc'd memory is cacheline aligned.

 */

	return (void *)L1_CACHE_ALIGN((u64)*base);

}

/*

 * Set up the initial values for the XPartition Communication channels.

 */

	int ch_number;

	struct xpc_channel *ch;

	for (ch_number = 0; ch_number < part->nchannels; ch_number++) {

		ch = &part->channels[ch_number];

	}

}

/*

 * Setup the infrastructure necessary to support XPartition Communication

 * between the specified remote partition and the local one.

	struct timer_list *timer;

	partid_t partid = XPC_PARTID(part);

	/*

	 * Zero out MOST of the entry for this partition. Only the fields

	 * starting with `nchannels' will be zeroed. The preceding fields must

	part->nchannels = XPC_NCHANNELS;

	/* allocate all the required GET/PUT values */

	part->local_GPs = xpc_kzalloc_cacheline_aligned(XPC_GP_SIZE,

					GFP_KERNEL, &part->local_GPs_base);

							GFP_KERNEL,

							&part->local_GPs_base);

	if (part->local_GPs == NULL) {

		kfree(part->channels);

		part->channels = NULL;

	}

	part->remote_GPs = xpc_kzalloc_cacheline_aligned(XPC_GP_SIZE,

					GFP_KERNEL, &part->remote_GPs_base);

							 GFP_KERNEL,

							 &part->

							 remote_GPs_base);

	if (part->remote_GPs == NULL) {

		dev_err(xpc_chan, "can't get memory for remote get/put "

			"values\n");

		return xpcNoMemory;

	}

	/* allocate all the required open and close args */

	part->local_openclose_args = xpc_kzalloc_cacheline_aligned(

					XPC_OPENCLOSE_ARGS_SIZE, GFP_KERNEL,

	part->local_openclose_args =

	    xpc_kzalloc_cacheline_aligned(XPC_OPENCLOSE_ARGS_SIZE, GFP_KERNEL,

					  &part->local_openclose_args_base);

	if (part->local_openclose_args == NULL) {

		dev_err(xpc_chan, "can't get memory for local connect args\n");

		return xpcNoMemory;

	}

	part->remote_openclose_args = xpc_kzalloc_cacheline_aligned(

					XPC_OPENCLOSE_ARGS_SIZE, GFP_KERNEL,

	part->remote_openclose_args =

	    xpc_kzalloc_cacheline_aligned(XPC_OPENCLOSE_ARGS_SIZE, GFP_KERNEL,

					  &part->remote_openclose_args_base);

	if (part->remote_openclose_args == NULL) {

		dev_err(xpc_chan, "can't get memory for remote connect args\n");

		return xpcNoMemory;

	}

	xpc_initialize_channels(part, partid);

	atomic_set(&part->nchannels_active, 0);

	atomic_set(&part->nchannels_engaged, 0);

	/* local_IPI_amo were set to 0 by an earlier memset() */

	/* Initialize this partitions AMO_t structure */

	 */

	part->setup_state = XPC_P_SETUP;

	/*

	 * Setup the per partition specific variables required by the

	 * remote partition to establish channel connections with us.

	return xpcSuccess;

}

/*

 * Create a wrapper that hides the underlying mechanism for pulling a cacheline

 * (or multiple cachelines) from a remote partition.

{

	bte_result_t bte_ret;

	DBUG_ON((u64)src != L1_CACHE_ALIGN((u64)src));

	DBUG_ON((u64)dst != L1_CACHE_ALIGN((u64)dst));

	DBUG_ON(cnt != L1_CACHE_ALIGN(cnt));

	return xpc_map_bte_errors(bte_ret);

}

/*

 * Pull the remote per partition specific variables from the specified

 * partition.

	partid_t partid = XPC_PARTID(part);

	enum xpc_retval ret;

	/* pull the cacheline that contains the variables we're interested in */

	DBUG_ON(part->remote_vars_part_pa !=

	remote_entry_cacheline_pa = (remote_entry_pa & ~(L1_CACHE_BYTES - 1));

	pulled_entry = (struct xpc_vars_part *)((u64)pulled_entry_cacheline +

				(remote_entry_pa & (L1_CACHE_BYTES - 1)));

						(remote_entry_pa &

						 (L1_CACHE_BYTES - 1)));

	ret = xpc_pull_remote_cachelines(part, pulled_entry_cacheline,

					 (void *)remote_entry_cacheline_pa,

		return ret;

	}

	/* see if they've been set up yet */

	if (pulled_entry->magic != XPC_VP_MAGIC1 &&

	return xpcSuccess;

}

/*

 * Get the IPI flags and pull the openclose args and/or remote GPs as needed.

 */

	u64 IPI_amo;

	enum xpc_retval ret;

	/*

	 * See if there are any IPI flags to be handled.

	 */

	}

	spin_unlock_irqrestore(&part->IPI_lock, irq_flags);

	if (XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(IPI_amo)) {

		ret = xpc_pull_remote_cachelines(part,

						 part->remote_openclose_args,

					(void *) part->remote_openclose_args_pa,

						 (void *)part->

						 remote_openclose_args_pa,

						 XPC_OPENCLOSE_ARGS_SIZE);

		if (ret != xpcSuccess) {

			XPC_DEACTIVATE_PARTITION(part, ret);

	return IPI_amo;

}

/*

 * Allocate the local message queue and the notify queue.

 */

	int nentries;

	size_t nbytes;

	// >>> may want to check for ch->flags & XPC_C_DISCONNECTING between

	// >>> iterations of the for-loop, bail if set?

		nbytes = nentries * ch->msg_size;

		ch->local_msgqueue = xpc_kzalloc_cacheline_aligned(nbytes,

								   GFP_KERNEL,

						&ch->local_msgqueue_base);

								   &ch->

								   local_msgqueue_base);

		if (ch->local_msgqueue == NULL) {

			continue;

		}

	return xpcNoMemory;

}

/*

 * Allocate the cached remote message queue.

 */

	int nentries;

	size_t nbytes;

	DBUG_ON(ch->remote_nentries <= 0);

	// >>> may want to check for ch->flags & XPC_C_DISCONNECTING between

		nbytes = nentries * ch->msg_size;

		ch->remote_msgqueue = xpc_kzalloc_cacheline_aligned(nbytes,

								    GFP_KERNEL,

						&ch->remote_msgqueue_base);

								    &ch->

								    remote_msgqueue_base);

		if (ch->remote_msgqueue == NULL) {

			continue;

		}

	return xpcNoMemory;

}

/*

 * Allocate message queues and other stuff associated with a channel.

 *

	unsigned long irq_flags;

	enum xpc_retval ret;

	DBUG_ON(ch->flags & XPC_C_SETUP);

	if ((ret = xpc_allocate_local_msgqueue(ch)) != xpcSuccess) {

	return xpcSuccess;

}

/*

 * Process a connect message from a remote partition.

 *

{

	enum xpc_retval ret;

	DBUG_ON(!spin_is_locked(&ch->lock));

	if (!(ch->flags & XPC_C_OPENREQUEST) ||

	spin_lock_irqsave(&ch->lock, *irq_flags);

}

/*

 * Notify those who wanted to be notified upon delivery of their message.

 */

	u8 notify_type;

	s64 get = ch->w_remote_GP.get - 1;

	while (++get < put && atomic_read(&ch->n_to_notify) > 0) {

		notify = &ch->notify_queue[get % ch->local_nentries];

		 */

		notify_type = notify->type;

		if (notify_type == 0 ||

				cmpxchg(&notify->type, notify_type, 0) !=

								notify_type) {

		    cmpxchg(&notify->type, notify_type, 0) != notify_type) {

			continue;

		}

	}

}

/*

 * Free up message queues and other stuff that were allocated for the specified

 * channel.

	}

}

/*

 * spin_lock_irqsave() is expected to be held on entry.

 */

	struct xpc_partition *part = &xpc_partitions[ch->partid];

	u32 channel_was_connected = (ch->flags & XPC_C_WASCONNECTED);

	DBUG_ON(!spin_is_locked(&ch->lock));

	if (!(ch->flags & XPC_C_DISCONNECTING)) {

	}

}

/*

 * Process a change in the channel's remote connection state.

 */

	struct xpc_channel *ch = &part->channels[ch_number];

	enum xpc_retval reason;

	spin_lock_irqsave(&ch->lock, irq_flags);

      again:

	if ((ch->flags & XPC_C_DISCONNECTED) &&

					(ch->flags & XPC_C_WDISCONNECT)) {

	if ((ch->flags & XPC_C_DISCONNECTED) && (ch->flags & XPC_C_WDISCONNECT)) {

		/*

		 * Delay processing IPI flags until thread waiting disconnect

		 * has had a chance to see that the channel is disconnected.

		return;

	}

	if (IPI_flags & XPC_IPI_CLOSEREQUEST) {

		dev_dbg(xpc_chan, "XPC_IPI_CLOSEREQUEST (reason=%d) received "

		if (ch->flags & XPC_C_DISCONNECTED) {

			if (!(IPI_flags & XPC_IPI_OPENREQUEST)) {

				if ((XPC_GET_IPI_FLAGS(part->local_IPI_amo,

					 ch_number) & XPC_IPI_OPENREQUEST)) {

						       ch_number) &

				     XPC_IPI_OPENREQUEST)) {

					DBUG_ON(ch->delayed_IPI_flags != 0);

					spin_lock(&part->IPI_lock);

		xpc_process_disconnect(ch, &irq_flags);

	}

	if (IPI_flags & XPC_IPI_CLOSEREPLY) {

		dev_dbg(xpc_chan, "XPC_IPI_CLOSEREPLY received from partid=%d,"

				DBUG_ON(ch->delayed_IPI_flags != 0);

				spin_lock(&part->IPI_lock);

				XPC_SET_IPI_FLAGS(part->local_IPI_amo,

						ch_number, XPC_IPI_CLOSEREPLY);

						  ch_number,

						  XPC_IPI_CLOSEREPLY);

				spin_unlock(&part->IPI_lock);

			}

			spin_unlock_irqrestore(&ch->lock, irq_flags);

		}

	}

	if (IPI_flags & XPC_IPI_OPENREQUEST) {

		dev_dbg(xpc_chan, "XPC_IPI_OPENREQUEST (msg_size=%d, "

		ch->flags |= (XPC_C_ROPENREQUEST | XPC_C_CONNECTING);

		ch->remote_nentries = args->local_nentries;

		if (ch->flags & XPC_C_OPENREQUEST) {

			if (args->msg_size != ch->msg_size) {

				XPC_DISCONNECT_CHANNEL(ch, xpcUnequalMsgSizes,

		xpc_process_connect(ch, &irq_flags);

	}

	if (IPI_flags & XPC_IPI_OPENREPLY) {

		dev_dbg(xpc_chan, "XPC_IPI_OPENREPLY (local_msgqueue_pa=0x%lx, "

	spin_unlock_irqrestore(&ch->lock, irq_flags);

}

/*

 * Attempt to establish a channel connection to a remote partition.

 */

	unsigned long irq_flags;

	struct xpc_registration *registration = &xpc_registrations[ch->number];

	if (mutex_trylock(&registration->mutex) == 0) {

		return xpcRetry;

	}

		return ch->reason;

	}

	/* add info from the channel connect registration to the channel */

	ch->kthreads_assigned_limit = registration->assigned_limit;

	mutex_unlock(&registration->mutex);

	/* initiate the connection */

	ch->flags |= (XPC_C_OPENREQUEST | XPC_C_CONNECTING);

	return xpcSuccess;

}

/*

 * Clear some of the msg flags in the local message queue.

 */

	struct xpc_msg *msg;

	s64 get;

	get = ch->w_remote_GP.get;

	do {

		msg = (struct xpc_msg *)((u64)ch->local_msgqueue +

				(get % ch->local_nentries) * ch->msg_size);

					 (get % ch->local_nentries) *

					 ch->msg_size);

		msg->flags = 0;

	} while (++get < (volatile s64)ch->remote_GP.get);

}

/*

 * Clear some of the msg flags in the remote message queue.

 */

	struct xpc_msg *msg;

	s64 put;

	put = ch->w_remote_GP.put;

	do {

		msg = (struct xpc_msg *)((u64)ch->remote_msgqueue +

				(put % ch->remote_nentries) * ch->msg_size);

					 (put % ch->remote_nentries) *

					 ch->msg_size);

		msg->flags = 0;

	} while (++put < (volatile s64)ch->remote_GP.put);

}

static void

xpc_process_msg_IPI(struct xpc_partition *part, int ch_number)

{

	struct xpc_channel *ch = &part->channels[ch_number];

	int nmsgs_sent;

	ch->remote_GP = part->remote_GPs[ch_number];

	/* See what, if anything, has changed for each connected channel */

	xpc_msgqueue_ref(ch);

		return;

	}

	/*

	 * First check to see if messages recently sent by us have been

	 * received by the other side. (The remote GET value will have

		}

	}

	/*

	 * Now check for newly sent messages by the other side. (The remote

	 * PUT value will have changed since we last looked at it.)

	xpc_msgqueue_deref(ch);

}

void

xpc_process_channel_activity(struct xpc_partition *part)

{

	int ch_number;

	u32 ch_flags;

	IPI_amo = xpc_get_IPI_flags(part);

	/*

	for (ch_number = 0; ch_number < part->nchannels; ch_number++) {

		ch = &part->channels[ch_number];

		/*

		 * Process any open or close related IPI flags, and then deal

		 * with connecting or disconnecting the channel as required.

			continue;

		}

		/*

		 * Process any message related IPI flags, this may involve the

		 * activation of kthreads to deliver any pending messages sent

	}

}

/*

 * XPC's heartbeat code calls this function to inform XPC that a partition is

 * going down.  XPC responds by tearing down the XPartition Communication

	int ch_number;

	struct xpc_channel *ch;

	dev_dbg(xpc_chan, "deactivating partition %d, reason=%d\n",

		XPC_PARTID(part), reason);

		return;

	}

	/* disconnect channels associated with the partition going down */

	for (ch_number = 0; ch_number < part->nchannels; ch_number++) {

	xpc_part_deref(part);

}

/*

 * Teardown the infrastructure necessary to support XPartition Communication

 * between the specified remote partition and the local one.

{

	partid_t partid = XPC_PARTID(part);

	/*

	 * We start off by making this partition inaccessible to local

	 * processes by marking it as no longer setup. Then we make it

	xpc_vars_part[partid].magic = 0;

	free_irq(SGI_XPC_NOTIFY, (void *)(u64)partid);

	/*

	 * Before proceeding with the teardown we have to wait until all

	 * existing references cease.

	 */

	wait_event(part->teardown_wq, (atomic_read(&part->references) == 0));

	/* now we can begin tearing down the infrastructure */

	part->setup_state = XPC_P_TORNDOWN;

	part->local_IPI_amo_va = NULL;

}

/*

 * Called by XP at the time of channel connection registration to cause

 * XPC to establish connections to all currently active partitions.

	struct xpc_partition *part;

	struct xpc_channel *ch;

	DBUG_ON(ch_number < 0 || ch_number >= XPC_NCHANNELS);

	for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) {

	}

}

void

xpc_connected_callout(struct xpc_channel *ch)

{

	}

}

/*

 * Called by XP at the time of channel connection unregistration to cause

 * XPC to teardown all current connections for the specified channel.

	struct xpc_partition *part;

	struct xpc_channel *ch;

	DBUG_ON(ch_number < 0 || ch_number >= XPC_NCHANNELS);

	/* initiate the channel disconnect for every active partition */

	xpc_disconnect_wait(ch_number);

}

/*

 * To disconnect a channel, and reflect it back to all who may be waiting.

 *

{

	u32 channel_was_connected = (ch->flags & XPC_C_CONNECTED);

	DBUG_ON(!spin_is_locked(&ch->lock));

	if (ch->flags & (XPC_C_DISCONNECTING | XPC_C_DISCONNECTED)) {

	spin_lock_irqsave(&ch->lock, *irq_flags);

}

void

xpc_disconnect_callout(struct xpc_channel *ch, enum xpc_retval reason)

{

	}

}

/*

 * Wait for a message entry to become available for the specified channel,

 * but don't wait any longer than 1 jiffy.

{

	enum xpc_retval ret;

	if (ch->flags & XPC_C_DISCONNECTING) {

		DBUG_ON(ch->reason == xpcInterrupted);	// >>> Is this true?

		return ch->reason;

	return ret;

}

/*

 * Allocate an entry for a message from the message queue associated with the

 * specified channel.

	enum xpc_retval ret;

	s64 put;

	/* this reference will be dropped in xpc_send_msg() */

	xpc_msgqueue_ref(ch);

		return xpcNotConnected;

	}

	/*