#ifndef __LINUX_SPINLOCK_TYPES_H
#define __LINUX_SPINLOCK_TYPES_H

/*
 * include/linux/spinlock_types.h - generic spinlock type definitions
 *                                  and initializers
 *
 * portions Copyright 2005, Red Hat, Inc., Ingo Molnar
 * Released under the General Public License (GPL).
 */

#if defined(CONFIG_SMP)
# include <asm/spinlock_types.h>
#else
# include <linux/spinlock_types_up.h>
#endif

#include <linux/lockdep_types.h>

typedef struct raw_spinlock {
	arch_spinlock_t raw_lock;
#ifdef CONFIG_DEBUG_SPINLOCK
	unsigned int magic, owner_cpu;
	void *owner;
#endif
#ifdef CONFIG_DEBUG_LOCK_ALLOC
	struct lockdep_map dep_map;
#endif
} raw_spinlock_t;

#define SPINLOCK_MAGIC		0xdead4ead

#define SPINLOCK_OWNER_INIT	((void *)-1L)

#ifdef CONFIG_DEBUG_LOCK_ALLOC
# define RAW_SPIN_DEP_MAP_INIT(lockname)		\
	.dep_map = {					\
		.name = #lockname,			\
		.wait_type_inner = LD_WAIT_SPIN,	\
	}
# define SPIN_DEP_MAP_INIT(lockname)			\
	.dep_map = {					\
		.name = #lockname,			\
		.wait_type_inner = LD_WAIT_CONFIG,	\
	}
# define HARD_SPIN_DEP_MAP_INIT(lockname)		\
	.dep_map = {					\
		.name = #lockname,			\
		.wait_type_inner = LD_WAIT_INV,		\
	}
#else
# define RAW_SPIN_DEP_MAP_INIT(lockname)
# define SPIN_DEP_MAP_INIT(lockname)
# define HARD_SPIN_DEP_MAP_INIT(lockname)
#endif

#ifdef CONFIG_DEBUG_SPINLOCK
# define SPIN_DEBUG_INIT(lockname)		\
	.magic = SPINLOCK_MAGIC,		\
	.owner_cpu = -1,			\
	.owner = SPINLOCK_OWNER_INIT,
#else
# define SPIN_DEBUG_INIT(lockname)
#endif

#define __RAW_SPIN_LOCK_INITIALIZER(lockname)	\
	{					\
	.raw_lock = __ARCH_SPIN_LOCK_UNLOCKED,	\
	SPIN_DEBUG_INIT(lockname)		\
	RAW_SPIN_DEP_MAP_INIT(lockname) }

#define __RAW_SPIN_LOCK_UNLOCKED(lockname)	\
	(raw_spinlock_t) __RAW_SPIN_LOCK_INITIALIZER(lockname)

#define DEFINE_RAW_SPINLOCK(x)	raw_spinlock_t x = __RAW_SPIN_LOCK_UNLOCKED(x)

typedef struct spinlock {
	union {
		struct raw_spinlock rlock;

#ifdef CONFIG_DEBUG_LOCK_ALLOC
# define LOCK_PADSIZE (offsetof(struct raw_spinlock, dep_map))
		struct {
			u8 __padding[LOCK_PADSIZE];
			struct lockdep_map dep_map;
		};
#endif
	};
} spinlock_t;

#define ___SPIN_LOCK_INITIALIZER(lockname)	\
	{					\
	.raw_lock = __ARCH_SPIN_LOCK_UNLOCKED,	\
	SPIN_DEBUG_INIT(lockname)		\
	SPIN_DEP_MAP_INIT(lockname) }

#define __SPIN_LOCK_INITIALIZER(lockname) \
	{ { .rlock = ___SPIN_LOCK_INITIALIZER(lockname) } }

#define __SPIN_LOCK_UNLOCKED(lockname) \
	(spinlock_t) __SPIN_LOCK_INITIALIZER(lockname)

#define DEFINE_SPINLOCK(x)	spinlock_t x = __SPIN_LOCK_UNLOCKED(x)

#ifdef CONFIG_IRQ_PIPELINE

void __bad_spinlock_type(void);

#define __RAWLOCK(x) ((struct raw_spinlock *)(x))

#define LOCK_ALTERNATIVES(__lock, __base_op, __raw_form, __args...)	\
	do {								\
		if (__builtin_types_compatible_p(typeof(__lock),	\
						 raw_spinlock_t *))	\
			__raw_form;					\
		else if (__builtin_types_compatible_p(typeof(__lock),	\
						 hard_spinlock_t *))	\
			hard_ ## __base_op(__RAWLOCK(__lock), ##__args); \
		else if (__builtin_types_compatible_p(typeof(__lock),	\
						 hybrid_spinlock_t *))	\
			hybrid_ ## __base_op(__RAWLOCK(__lock), ##__args); \
		else							\
			__bad_spinlock_type();				\
	} while (0)

#define LOCK_ALTERNATIVES_RET(__lock, __base_op, __raw_form, __args...) \
	({								\
		long __ret = 0;						\
		if (__builtin_types_compatible_p(typeof(__lock),	\
						 raw_spinlock_t *))	\
			__ret = __raw_form;				\
		else if (__builtin_types_compatible_p(typeof(__lock),	\
						 hard_spinlock_t *))	\
			__ret = hard_ ## __base_op(__RAWLOCK(__lock), ##__args); \
		else if (__builtin_types_compatible_p(typeof(__lock),	\
						 hybrid_spinlock_t *))	\
			__ret = hybrid_ ## __base_op(__RAWLOCK(__lock), ##__args); \
		else							\
			__bad_spinlock_type();				\
		__ret;							\
	})

#define LOCKDEP_ALT_DEPMAP(__lock)					\
	({								\
		struct lockdep_map *__ret;				\
		if (__builtin_types_compatible_p(typeof(&(__lock)->dep_map), \
						 struct phony_lockdep_map *)) \
			__ret = &__RAWLOCK(__lock)->dep_map;		\
		else							\
			__ret = (struct lockdep_map *)(&(__lock)->dep_map); \
		__ret;							\
	})

#define LOCKDEP_HARD_DEBUG(__lock, __nodebug, __debug)	\
	do {						\
		if (__builtin_types_compatible_p(typeof(__lock),	\
						raw_spinlock_t *) ||	\
			irq_pipeline_debug_locking()) {			\
			__debug;			\
		} else {				\
			__nodebug;			\
		}					\
	} while (0)

#define LOCKDEP_HARD_DEBUG_RET(__lock, __nodebug, __debug)	\
	({						\
		typeof(__nodebug) __ret;		\
		if (__builtin_types_compatible_p(typeof(__lock),	\
						raw_spinlock_t *) ||	\
			irq_pipeline_debug_locking()) {			\
			__ret = (__debug);		\
		} else {				\
			__ret = (__nodebug);		\
		}					\
		__ret;					\
	})

#define __HARD_SPIN_LOCK_INITIALIZER(x)	{			\
		.rlock = {					\
			.raw_lock = __ARCH_SPIN_LOCK_UNLOCKED,	\
			SPIN_DEBUG_INIT(x)			\
			HARD_SPIN_DEP_MAP_INIT(x)		\
		}						\
	}

#define __HARD_SPIN_LOCK_UNLOCKED(x)	\
	(hard_spinlock_t) __HARD_SPIN_LOCK_INITIALIZER(x)

#define DEFINE_HARD_SPINLOCK(x)  	hard_spinlock_t x = __HARD_SPIN_LOCK_UNLOCKED(x)

#define DECLARE_HARD_SPINLOCK(x)	hard_spinlock_t x

/*
 * The presence of a phony depmap is tested by LOCKDEP_ALT_DEPMAP() to
 * locate the real depmap without enumerating every spinlock type
 * which may contain one.
 */
struct phony_lockdep_map { };

typedef struct hard_spinlock {
	/* XXX: offset_of(struct hard_spinlock, rlock) == 0 */
	struct raw_spinlock rlock;
	struct phony_lockdep_map dep_map;
} hard_spinlock_t;

#define DEFINE_MUTABLE_SPINLOCK(x)	hybrid_spinlock_t x = {	\
		.rlock = __RAW_SPIN_LOCK_UNLOCKED(x),			\
	}

#define DECLARE_MUTABLE_SPINLOCK(x)	hybrid_spinlock_t x

typedef struct hybrid_spinlock {
	/* XXX: offset_of(struct hybrid_spinlock, rlock) == 0 */
	struct raw_spinlock rlock;
	unsigned long hwflags;
	struct phony_lockdep_map dep_map;
} hybrid_spinlock_t;

#else

typedef raw_spinlock_t hard_spinlock_t;

typedef raw_spinlock_t hybrid_spinlock_t;

#define LOCK_ALTERNATIVES(__lock, __base_op, __raw_form, __args...)	\
	__raw_form

#define LOCK_ALTERNATIVES_RET(__lock, __base_op, __raw_form, __args...) \
	__raw_form

#define LOCKDEP_ALT_DEPMAP(__lock)	(&(__lock)->dep_map)

#define LOCKDEP_HARD_DEBUG(__lock, __nondebug, __debug)		do { __debug; } while (0)

#define LOCKDEP_HARD_DEBUG_RET(__lock, __nondebug, __debug)	({ __debug; })

#define DEFINE_HARD_SPINLOCK(x)		DEFINE_RAW_SPINLOCK(x)

#define DECLARE_HARD_SPINLOCK(x)	raw_spinlock_t x

#define DEFINE_MUTABLE_SPINLOCK(x)	DEFINE_RAW_SPINLOCK(x)

#define DECLARE_MUTABLE_SPINLOCK(x)	raw_spinlock_t x

#define __RAWLOCK(x) (x)

#define __HARD_SPIN_LOCK_UNLOCKED(__lock)	__RAW_SPIN_LOCK_UNLOCKED(__lock)

#define __HARD_SPIN_LOCK_INITIALIZER(__lock)	__RAW_SPIN_LOCK_UNLOCKED(__lock)

#endif	/* CONFIG_IRQ_PIPELINE */

#include <linux/rwlock_types.h>

#endif /* __LINUX_SPINLOCK_TYPES_H */