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

 * Copyright (C) 2004-2008 Silicon Graphics, Inc. All rights reserved.

 */

/*

 * External Cross Partition (XP) structures and defines.

 */

#ifndef _DRIVERS_MISC_SGIXP_XP_H

#define _DRIVERS_MISC_SGIXP_XP_H

#include <linux/cache.h>

#include <linux/hardirq.h>

#include <linux/mutex.h>

#include <asm/sn/types.h>

#include <asm/sn/bte.h>

#ifdef USE_DBUG_ON

#define DBUG_ON(condition)	BUG_ON(condition)

#else

#define DBUG_ON(condition)

#endif

/*

 * Define the maximum number of logically defined partitions the system

 * can support. It is constrained by the maximum number of hardware

 */

#define XP_MAX_PARTITIONS	64

/*

 * Define the number of u64s required to represent all the C-brick nasids

 * as a bitmap.  The cross-partition kernel modules deal only with

#define XP_NASID_MASK_BYTES	((XP_MAX_PHYSNODE_ID + 7) / 8)

#define XP_NASID_MASK_WORDS	((XP_MAX_PHYSNODE_ID + 63) / 64)

/*

 * Wrapper for bte_copy() that should it return a failure status will retry

 * the bte_copy() once in the hope that the failure was due to a temporary

	bte_result_t ret;

	u64 pdst = ia64_tpa(vdst);

	/*

	 * Ensure that the physically mapped memory is contiguous.

	 *

	return ret;

}

/*

 * XPC establishes channel connections between the local partition and any

 * other partition that is currently up. Over these channels, kernel-level

#error	XPC_NCHANNELS exceeds MAXIMUM allowed.

#endif

/*

 * The format of an XPC message is as follows:

 *

	u64 payload;		/* user defined portion of message */

};

#define XPC_MSG_PAYLOAD_OFFSET	(u64) (&((struct xpc_msg *)0)->payload)

#define XPC_MSG_SIZE(_payload_size) \

		L1_CACHE_ALIGN(XPC_MSG_PAYLOAD_OFFSET + (_payload_size))

/*

 * Define the return values and values passed to user's callout functions.

 * (It is important to add new value codes at the end just preceding

	xpcUnknownReason	/* 116: unknown reason -- must be last in list */

};

/*

 * Define the callout function types used by XPC to update the user on

 * connection activity and state changes (via the user function registered by

typedef void (*xpc_notify_func) (enum xpc_retval reason, partid_t partid,

				 int ch_number, void *key);

/*

 * The following is a registration entry. There is a global array of these,

 * one per channel. It is used to record the connection registration made

	u32 idle_limit;		/* limit on #of idle kthreads */

} ____cacheline_aligned;

#define XPC_CHANNEL_REGISTERED(_c)	(xpc_registrations[_c].func != NULL)

/* the following are valid xpc_allocate() flags */

#define XPC_WAIT	0	/* wait flag */

#define XPC_NOWAIT	1	/* no wait flag */

struct xpc_interface {

	void (*connect) (int);

	void (*disconnect) (int);

	enum xpc_retval (*partid_to_nasids) (partid_t, void *);

};

extern struct xpc_interface xpc_interface;

extern void xpc_set_interface(void (*)(int),

			      void (*)(int),

			      enum xpc_retval (*)(partid_t, int, u32, void **),

			      enum xpc_retval (*)(partid_t, int, void *),

		enum xpc_retval (*)(partid_t, int, void *, xpc_notify_func,

								void *),

			      enum xpc_retval (*)(partid_t, int, void *,

						  xpc_notify_func, void *),

			      void (*)(partid_t, int, void *),

			      enum xpc_retval (*)(partid_t, void *));

extern void xpc_clear_interface(void);

extern enum xpc_retval xpc_connect(int, xpc_channel_func, void *, u16,

				   u16, u32, u32);

extern void xpc_disconnect(int);

	return xpc_interface.partid_to_nasids(partid, nasids);

}

extern u64 xp_nofault_PIOR_target;

extern int xp_nofault_PIOR(void *);

extern int xp_error_PIOR(void);

#endif /* _DRIVERS_MISC_SGIXP_XP_H */

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

 */

/*

 * Cross Partition (XP) base.

 *

 *

 */

#include <linux/kernel.h>

#include <linux/interrupt.h>

#include <linux/module.h>

#include <asm/sn/sn_sal.h>

#include "xp.h"

/*

 * Target of nofault PIO read.

 */

u64 xp_nofault_PIOR_target;

/*

 * xpc_registrations[] keeps track of xpc_connect()'s done by the kernel-level

 * users of XPC.

 */

struct xpc_registration xpc_registrations[XPC_NCHANNELS];

/*

 * Initialize the XPC interface to indicate that XPC isn't loaded.

 */

static enum xpc_retval xpc_notloaded(void) { return xpcNotLoaded; }

static enum xpc_retval

xpc_notloaded(void)

{

	return xpcNotLoaded;

}

struct xpc_interface xpc_interface = {

	(void (*)(int))xpc_notloaded,

	(enum xpc_retval(*)(partid_t, void *))xpc_notloaded

};

/*

 * XPC calls this when it (the XPC module) has been loaded.

 */

	xpc_interface.partid_to_nasids = partid_to_nasids;

}

/*

 * XPC calls this when it (the XPC module) is being unloaded.

 */

	xpc_interface.send = (enum xpc_retval(*)(partid_t, int, void *))

	    xpc_notloaded;

	xpc_interface.send_notify = (enum xpc_retval(*)(partid_t, int, void *,

				    xpc_notify_func, void *)) xpc_notloaded;

							xpc_notify_func,

							void *))xpc_notloaded;

	xpc_interface.received = (void (*)(partid_t, int, void *))

	    xpc_notloaded;

	xpc_interface.partid_to_nasids = (enum xpc_retval(*)(partid_t, void *))

	    xpc_notloaded;

}

/*

 * Register for automatic establishment of a channel connection whenever

 * a partition comes up.

{

	struct xpc_registration *registration;

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

	DBUG_ON(payload_size == 0 || nentries == 0);

	DBUG_ON(func == NULL);

	return xpcSuccess;

}

/*

 * Remove the registration for automatic connection of the specified channel

 * when a partition comes up.

{

	struct xpc_registration *registration;

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

	registration = &xpc_registrations[ch_number];

	return;

}

int __init

xp_init(void)

{

	u64 func_addr = *(u64 *)xp_nofault_PIOR;

	u64 err_func_addr = *(u64 *)xp_error_PIOR;

	if (!ia64_platform_is("sn2")) {

		return -ENODEV;

	}

	return 0;

}

module_init(xp_init);

module_init(xp_init);

void __exit

xp_exit(void)

	u64 func_addr = *(u64 *)xp_nofault_PIOR;

	u64 err_func_addr = *(u64 *)xp_error_PIOR;

	/* unregister the PIO read nofault code region */

	(void)sn_register_nofault_code(func_addr, err_func_addr,

				       err_func_addr, 1, 0);

}

module_exit(xp_exit);

module_exit(xp_exit);

MODULE_AUTHOR("Silicon Graphics, Inc.");

MODULE_DESCRIPTION("Cross Partition (XP) base");

EXPORT_SYMBOL(xpc_set_interface);

EXPORT_SYMBOL(xpc_connect);

EXPORT_SYMBOL(xpc_disconnect);

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

 */

/*

 * The xp_nofault_PIOR function takes a pointer to a remote PIO register

 * and attempts to load and consume a value from it.  This function

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

 */

/*

 * Cross Partition Communication (XPC) structures and macros.

 */

#ifndef _DRIVERS_MISC_SGIXP_XPC_H

#define _DRIVERS_MISC_SGIXP_XPC_H

#include <linux/interrupt.h>

#include <linux/sysctl.h>

#include <linux/device.h>

#include <asm/sn/shub_mmr.h>

#include "xp.h"

/*

 * XPC Version numbers consist of a major and minor number. XPC can always

 * talk to versions with same major #, and never talk to versions with a

#define XPC_VERSION_MAJOR(_v)		((_v) >> 4)

#define XPC_VERSION_MINOR(_v)		((_v) & 0xf)

/*

 * The next macros define word or bit representations for given

 * C-brick nasid in either the SAL provided bit array representing

/* define the process name of the discovery thread */

#define XPC_DISCOVERY_THREAD_NAME	"xpc_discovery"

/*

 * the reserved page

 *

{

	int ret;

	if ((ret = stamp1->tv_sec - stamp2->tv_sec) == 0) {

		ret = stamp1->tv_nsec - stamp2->tv_nsec;

	}

	return ret;

}

/*

 * Define the structures by which XPC variables can be exported to other

 * partitions. (There are two: struct xpc_vars and struct xpc_vars_part)

#define XPC_SUPPORTS_DISENGAGE_REQUEST(_version) \

			(_version >= _XPC_VERSION(3,1))

static inline int

xpc_hb_allowed(partid_t partid, struct xpc_vars *vars)

{

		 old_mask);

}

/*

 * The AMOs page consists of a number of AMO variables which are divided into

 * four groups, The first two groups are used to identify an IRQ's sender.

#define XPC_ENGAGED_PARTITIONS_AMO (XPC_ACTIVATE_IRQ_AMOS + XP_NASID_MASK_WORDS)

#define XPC_DISENGAGE_REQUEST_AMO  (XPC_ENGAGED_PARTITIONS_AMO + 1)

/*

 * The following structure describes the per partition specific variables.

 *

#define XPC_VP_MAGIC1	0x0053524156435058L	/* 'XPCVARS\0'L (little endian) */

#define XPC_VP_MAGIC2	0x0073726176435058L	/* 'XPCvars\0'L (little endian) */

/* the reserved page sizes and offsets */

#define XPC_RP_HEADER_SIZE	L1_CACHE_ALIGN(sizeof(struct xpc_rsvd_page))

#define XPC_RP_VARS(_rp)	((struct xpc_vars *) XPC_RP_MACH_NASIDS(_rp) + xp_nasid_mask_words)

#define XPC_RP_VARS_PART(_rp)	(struct xpc_vars_part *) ((u8 *) XPC_RP_VARS(rp) + XPC_RP_VARS_SIZE)

/*

 * Functions registered by add_timer() or called by kernel_thread() only

 * allow for a single 64-bit argument. The following macros can be used to

#define XPC_UNPACK_ARG1(_args)	(((u64) _args) & 0xffffffff)

#define XPC_UNPACK_ARG2(_args)	((((u64) _args) >> 32) & 0xffffffff)

/*

 * Define a Get/Put value pair (pointers) used with a message queue.

 */

#define XPC_GP_SIZE \

		L1_CACHE_ALIGN(sizeof(struct xpc_gp) * XPC_NCHANNELS)

/*

 * Define a structure that contains arguments associated with opening and

 * closing a channel.

#define XPC_OPENCLOSE_ARGS_SIZE \

	      L1_CACHE_ALIGN(sizeof(struct xpc_openclose_args) * XPC_NCHANNELS)

/* struct xpc_msg flags */

#define	XPC_M_DONE		0x01	/* msg has been received/consumed */

#define	XPC_M_READY		0x02	/* msg is ready to be sent */

#define	XPC_M_INTERRUPT		0x04	/* send interrupt when msg consumed */

#define XPC_MSG_ADDRESS(_payload) \

		((struct xpc_msg *)((u8 *)(_payload) - XPC_MSG_PAYLOAD_OFFSET))

/*

 * Defines notify entry.

 *

#define	XPC_N_CALL		0x01	/* notify function provided by user */

/*

 * Define the structure that manages all the stuff required by a channel. In

 * particular, they are used to manage the messages sent across the channel.

} ____cacheline_aligned;

/* struct xpc_channel flags */

#define	XPC_C_WASCONNECTED	0x00000001	/* channel was connected */

				0x00020000	/* disconnecting callout completed */

#define	XPC_C_WDISCONNECT	0x00040000	/* waiting for channel disconnect */

/*

 * Manages channels on a partition basis. There is one of these structures

 * for each partition (a partition will never utilize the structure that

	unsigned long disengage_request_timeout;	/* timeout in jiffies */

	struct timer_list disengage_request_timer;

	/* XPC infrastructure referencing and teardown control */

	volatile u8 setup_state;	/* infrastructure setup state */

	wait_queue_head_t teardown_wq;	/* kthread waiting to teardown infra */

	atomic_t references;	/* #of references to infrastructure */

	/*

	 * NONE OF THE PRECEDING FIELDS OF THIS STRUCTURE WILL BE CLEARED WHEN

	 * XPC SETS UP THE NECESSARY INFRASTRUCTURE TO SUPPORT CROSS PARTITION

	 * 'nchannels' FIELD MUST BE THE FIRST OF THE FIELDS TO BE CLEARED.)

	 */

	u8 nchannels;		/* #of defined channels supported */

	atomic_t nchannels_active;	/* #of channels that are not DISCONNECTED */

	atomic_t nchannels_engaged;	/* #of channels engaged with remote part */

	u64 remote_GPs_pa;	/* phys address of remote partition's local */

				/* Get/Put values */

	/* fields used to pass args when opening or closing a channel */

	void *local_openclose_args_base;	/* base address of kmalloc'd space */

								/* args */

	u64 remote_openclose_args_pa;	/* phys addr of remote's args */

	/* IPI sending, receiving and handling related fields */

	int remote_IPI_nasid;	/* nasid of where to send IPIs */

	spinlock_t IPI_lock;	/* IPI handler lock */

	/* channel manager related fields */

	atomic_t channel_mgr_requests;	/* #of requests to activate chan mgr */

} ____cacheline_aligned;

/* struct xpc_partition act_state values (for XPC HB) */

#define	XPC_P_INACTIVE		0x00	/* partition is not active */

#define XPC_P_ACTIVE		0x03	/* xpc_partition_up() was called */

#define XPC_P_DEACTIVATING	0x04	/* partition deactivation initiated */

#define XPC_DEACTIVATE_PARTITION(_p, _reason) \

			xpc_deactivate_partition(__LINE__, (_p), (_reason))

/* struct xpc_partition setup_state values */

#define XPC_P_UNSET		0x00	/* infrastructure was never setup */

#define XPC_P_WTEARDOWN		0x02	/* waiting to teardown infrastructure */

#define XPC_P_TORNDOWN		0x03	/* infrastructure is torndown */

/*

 * struct xpc_partition IPI_timer #of seconds to wait before checking for

 * dropped IPIs. These occur whenever an IPI amo write doesn't complete until

 */

#define XPC_P_DROPPED_IPI_WAIT	(0.25 * HZ)

/* number of seconds to wait for other partitions to disengage */

#define XPC_DISENGAGE_REQUEST_DEFAULT_TIMELIMIT	90

/* interval in seconds to print 'waiting disengagement' messages */

#define XPC_DISENGAGE_PRINTMSG_INTERVAL		10

#define XPC_PARTID(_p)	((partid_t) ((_p) - &xpc_partitions[0]))

/* found in xp_main.c */

extern struct xpc_registration xpc_registrations[];

/* found in xpc_main.c */

extern struct device *xpc_part;

extern struct device *xpc_chan;

extern void xpc_create_kthreads(struct xpc_channel *, int, int);

extern void xpc_disconnect_wait(int);

/* found in xpc_partition.c */

extern int xpc_exiting;

extern struct xpc_vars *xpc_vars;

				     enum xpc_retval);

extern enum xpc_retval xpc_initiate_partid_to_nasids(partid_t, void *);

/* found in xpc_channel.c */

extern void xpc_initiate_connect(int);

extern void xpc_initiate_disconnect(int);

extern void xpc_partition_going_down(struct xpc_partition *, enum xpc_retval);

extern void xpc_teardown_infrastructure(struct xpc_partition *);

static inline void

xpc_wakeup_channel_mgr(struct xpc_partition *part)

{

	}

}

/*

 * These next two inlines are used to keep us from tearing down a channel's

 * msg queues while a thread may be referencing them.

	}

}

#define XPC_DISCONNECT_CHANNEL(_ch, _reason, _irqflgs) \

		xpc_disconnect_channel(__LINE__, _ch, _reason, _irqflgs)

/*

 * These two inlines are used to keep us from tearing down a partition's

 * setup infrastructure while a thread may be referencing it.

{

	s32 refs = atomic_dec_return(&part->references);

	DBUG_ON(refs < 0);

	if (refs == 0 && part->setup_state == XPC_P_WTEARDOWN) {

		wake_up(&part->teardown_wq);

{

	int setup;

	atomic_inc(&part->references);

	setup = (part->setup_state == XPC_P_SETUP);

	if (!setup) {

	return setup;

}

/*

 * The following macro is to be used for the setting of the reason and

 * reason_line fields in both the struct xpc_channel and struct xpc_partition

		(_p)->reason_line = _line; \

	}

/*

 * This next set of inlines are used to keep track of when a partition is

 * potentially engaged in accessing memory belonging to another partition.

{

	unsigned long irq_flags;

	AMO_t *amo = (AMO_t *)__va(part->remote_amos_page_pa +

				(XPC_ENGAGED_PARTITIONS_AMO * sizeof(AMO_t)));

				   (XPC_ENGAGED_PARTITIONS_AMO *

				    sizeof(AMO_t)));

	local_irq_save(irq_flags);

	 * keep sending IPIs and AMOs to it until the heartbeat times out.

	 */

	(void)xp_nofault_PIOR((u64 *)GLOBAL_MMR_ADDR(NASID_GET(&amo->

				variable), xp_nofault_PIOR_target));

							       variable),

						     xp_nofault_PIOR_target));

	local_irq_restore(irq_flags);

}

{

	unsigned long irq_flags;

	AMO_t *amo = (AMO_t *)__va(part->remote_amos_page_pa +

				(XPC_ENGAGED_PARTITIONS_AMO * sizeof(AMO_t)));

				   (XPC_ENGAGED_PARTITIONS_AMO *

				    sizeof(AMO_t)));

	local_irq_save(irq_flags);

	 * keep sending IPIs and AMOs to it until the heartbeat times out.

	 */

	(void)xp_nofault_PIOR((u64 *)GLOBAL_MMR_ADDR(NASID_GET(&amo->

				variable), xp_nofault_PIOR_target));

							       variable),

						     xp_nofault_PIOR_target));

	local_irq_restore(irq_flags);

}

	AMO_t *amo = (AMO_t *)__va(part->remote_amos_page_pa +

				   (XPC_DISENGAGE_REQUEST_AMO * sizeof(AMO_t)));

	local_irq_save(irq_flags);

	/* set bit corresponding to our partid in remote partition's AMO */

	 * keep sending IPIs and AMOs to it until the heartbeat times out.

	 */

	(void)xp_nofault_PIOR((u64 *)GLOBAL_MMR_ADDR(NASID_GET(&amo->

				variable), xp_nofault_PIOR_target));

							       variable),

						     xp_nofault_PIOR_target));

	local_irq_restore(irq_flags);

}

	AMO_t *amo = (AMO_t *)__va(part->remote_amos_page_pa +

				   (XPC_DISENGAGE_REQUEST_AMO * sizeof(AMO_t)));

	local_irq_save(irq_flags);

	/* clear bit corresponding to our partid in remote partition's AMO */

	 * keep sending IPIs and AMOs to it until the heartbeat times out.

	 */

	(void)xp_nofault_PIOR((u64 *)GLOBAL_MMR_ADDR(NASID_GET(&amo->

				variable), xp_nofault_PIOR_target));

							       variable),

						     xp_nofault_PIOR_target));

	local_irq_restore(irq_flags);

}

{

	AMO_t *amo = xpc_vars->amos_page + XPC_ENGAGED_PARTITIONS_AMO;

	/* return our partition's AMO variable ANDed with partid_mask */

	return (FETCHOP_LOAD_OP(TO_AMO((u64)&amo->variable), FETCHOP_LOAD) &

		partid_mask);

{

	AMO_t *amo = xpc_vars->amos_page + XPC_DISENGAGE_REQUEST_AMO;

	/* return our partition's AMO variable ANDed with partid_mask */

	return (FETCHOP_LOAD_OP(TO_AMO((u64)&amo->variable), FETCHOP_LOAD) &

		partid_mask);

{

	AMO_t *amo = xpc_vars->amos_page + XPC_ENGAGED_PARTITIONS_AMO;

	/* clear bit(s) based on partid_mask in our partition's AMO */

	FETCHOP_STORE_OP(TO_AMO((u64)&amo->variable), FETCHOP_AND,

			 ~partid_mask);