Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6 (b22793f7) · Commits · e / devices / android_kernel_teracube_2e

arch/ia64/Kconfig

+10 −2

Original line number	Original line	Diff line number	Diff line
	@@ -53,6 +53,9 @@ config MMU
	bool		bool
	default y		default y

			config ARCH_DMA_ADDR_T_64BIT
			def_bool y

	config NEED_DMA_MAP_STATE		config NEED_DMA_MAP_STATE
	def_bool y		def_bool y

	@@ -62,6 +65,9 @@ config NEED_SG_DMA_LENGTH
	config SWIOTLB		config SWIOTLB
	bool		bool

			config STACKTRACE_SUPPORT
			def_bool y

	config GENERIC_LOCKBREAK		config GENERIC_LOCKBREAK
	def_bool n		def_bool n

	@@ -683,8 +689,10 @@ source "lib/Kconfig"
	# Use the generic interrupt handling code in kernel/irq/:		# Use the generic interrupt handling code in kernel/irq/:
	#		#
	config GENERIC_HARDIRQS		config GENERIC_HARDIRQS
	bool		def_bool y
	default y
			config GENERIC_HARDIRQS_NO__DO_IRQ
			def_bool y

	config GENERIC_IRQ_PROBE		config GENERIC_IRQ_PROBE
	bool		bool

arch/ia64/include/asm/compat.h

deleted100644 → 0

+0 −208

Original line number	Original line	Diff line number	Diff line
	#ifndef _ASM_IA64_COMPAT_H
	#define _ASM_IA64_COMPAT_H
	/*
	* Architecture specific compatibility types
	*/
	#include <linux/types.h>

	#define COMPAT_USER_HZ 100
	#define COMPAT_UTS_MACHINE "i686\0\0\0"

	typedef u32 compat_size_t;
	typedef s32 compat_ssize_t;
	typedef s32 compat_time_t;
	typedef s32 compat_clock_t;
	typedef s32 compat_key_t;
	typedef s32 compat_pid_t;
	typedef u16 __compat_uid_t;
	typedef u16 __compat_gid_t;
	typedef u32 __compat_uid32_t;
	typedef u32 __compat_gid32_t;
	typedef u16 compat_mode_t;
	typedef u32 compat_ino_t;
	typedef u16 compat_dev_t;
	typedef s32 compat_off_t;
	typedef s64 compat_loff_t;
	typedef u16 compat_nlink_t;
	typedef u16 compat_ipc_pid_t;
	typedef s32 compat_daddr_t;
	typedef u32 compat_caddr_t;
	typedef __kernel_fsid_t compat_fsid_t;
	typedef s32 compat_timer_t;

	typedef s32 compat_int_t;
	typedef s32 compat_long_t;
	typedef s64 __attribute__((aligned(4))) compat_s64;
	typedef u32 compat_uint_t;
	typedef u32 compat_ulong_t;
	typedef u64 __attribute__((aligned(4))) compat_u64;

	struct compat_timespec {
	compat_time_t tv_sec;
	s32 tv_nsec;
	};

	struct compat_timeval {
	compat_time_t tv_sec;
	s32 tv_usec;
	};

	struct compat_stat {
	compat_dev_t st_dev;
	u16 __pad1;
	compat_ino_t st_ino;
	compat_mode_t st_mode;
	compat_nlink_t st_nlink;
	__compat_uid_t st_uid;
	__compat_gid_t st_gid;
	compat_dev_t st_rdev;
	u16 __pad2;
	u32 st_size;
	u32 st_blksize;
	u32 st_blocks;
	u32 st_atime;
	u32 st_atime_nsec;
	u32 st_mtime;
	u32 st_mtime_nsec;
	u32 st_ctime;
	u32 st_ctime_nsec;
	u32 __unused4;
	u32 __unused5;
	};

	struct compat_flock {
	short l_type;
	short l_whence;
	compat_off_t l_start;
	compat_off_t l_len;
	compat_pid_t l_pid;
	};

	#define F_GETLK64 12
	#define F_SETLK64 13
	#define F_SETLKW64 14

	/*
	* IA32 uses 4 byte alignment for 64 bit quantities,
	* so we need to pack this structure.
	*/
	struct compat_flock64 {
	short l_type;
	short l_whence;
	compat_loff_t l_start;
	compat_loff_t l_len;
	compat_pid_t l_pid;
	} __attribute__((packed));

	struct compat_statfs {
	int f_type;
	int f_bsize;
	int f_blocks;
	int f_bfree;
	int f_bavail;
	int f_files;
	int f_ffree;
	compat_fsid_t f_fsid;
	int f_namelen; /* SunOS ignores this field. */
	int f_frsize;
	int f_spare[5];
	};

	#define COMPAT_RLIM_OLD_INFINITY 0x7fffffff
	#define COMPAT_RLIM_INFINITY 0xffffffff

	typedef u32 compat_old_sigset_t; /* at least 32 bits */

	#define _COMPAT_NSIG 64
	#define _COMPAT_NSIG_BPW 32

	typedef u32 compat_sigset_word;

	#define COMPAT_OFF_T_MAX 0x7fffffff
	#define COMPAT_LOFF_T_MAX 0x7fffffffffffffffL

	struct compat_ipc64_perm {
	compat_key_t key;
	__compat_uid32_t uid;
	__compat_gid32_t gid;
	__compat_uid32_t cuid;
	__compat_gid32_t cgid;
	unsigned short mode;
	unsigned short __pad1;
	unsigned short seq;
	unsigned short __pad2;
	compat_ulong_t unused1;
	compat_ulong_t unused2;
	};

	struct compat_semid64_ds {
	struct compat_ipc64_perm sem_perm;
	compat_time_t sem_otime;
	compat_ulong_t __unused1;
	compat_time_t sem_ctime;
	compat_ulong_t __unused2;
	compat_ulong_t sem_nsems;
	compat_ulong_t __unused3;
	compat_ulong_t __unused4;
	};

	struct compat_msqid64_ds {
	struct compat_ipc64_perm msg_perm;
	compat_time_t msg_stime;
	compat_ulong_t __unused1;
	compat_time_t msg_rtime;
	compat_ulong_t __unused2;
	compat_time_t msg_ctime;
	compat_ulong_t __unused3;
	compat_ulong_t msg_cbytes;
	compat_ulong_t msg_qnum;
	compat_ulong_t msg_qbytes;
	compat_pid_t msg_lspid;
	compat_pid_t msg_lrpid;
	compat_ulong_t __unused4;
	compat_ulong_t __unused5;
	};

	struct compat_shmid64_ds {
	struct compat_ipc64_perm shm_perm;
	compat_size_t shm_segsz;
	compat_time_t shm_atime;
	compat_ulong_t __unused1;
	compat_time_t shm_dtime;
	compat_ulong_t __unused2;
	compat_time_t shm_ctime;
	compat_ulong_t __unused3;
	compat_pid_t shm_cpid;
	compat_pid_t shm_lpid;
	compat_ulong_t shm_nattch;
	compat_ulong_t __unused4;
	compat_ulong_t __unused5;
	};

	/*
	* A pointer passed in from user mode. This should not be used for syscall parameters,
	* just declare them as pointers because the syscall entry code will have appropriately
	* converted them already.
	*/
	typedef u32 compat_uptr_t;

	static inline void __user *
	compat_ptr (compat_uptr_t uptr)
	{
	return (void __user *) (unsigned long) uptr;
	}

	static inline compat_uptr_t
	ptr_to_compat(void __user *uptr)
	{
	return (u32)(unsigned long)uptr;
	}

	static __inline__ void __user *
	arch_compat_alloc_user_space (long len)
	{
	struct pt_regs *regs = task_pt_regs(current);
	return (void __user *) (((regs->r12 & 0xffffffff) & -16) - len);
	}

	#endif /* _ASM_IA64_COMPAT_H */

arch/ia64/kernel/Makefile

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -34,6 +34,7 @@ obj-$(CONFIG_AUDIT) += audit.o
	obj-$(CONFIG_PCI_MSI) += msi_ia64.o		obj-$(CONFIG_PCI_MSI) += msi_ia64.o
	mca_recovery-y += mca_drv.o mca_drv_asm.o		mca_recovery-y += mca_drv.o mca_drv_asm.o
	obj-$(CONFIG_IA64_MC_ERR_INJECT)+= err_inject.o		obj-$(CONFIG_IA64_MC_ERR_INJECT)+= err_inject.o
			obj-$(CONFIG_STACKTRACE) += stacktrace.o

	obj-$(CONFIG_PARAVIRT) += paravirt.o paravirtentry.o \		obj-$(CONFIG_PARAVIRT) += paravirt.o paravirtentry.o \
	paravirt_patch.o		paravirt_patch.o

arch/ia64/kernel/cyclone.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -59,13 +59,13 @@ int __init init_cyclone_clock(void)
	return -ENODEV;		return -ENODEV;
	}		}
	base = readq(reg);		base = readq(reg);
			iounmap(reg);
	if(!base){		if(!base){
	printk(KERN_ERR "Summit chipset: Could not find valid CBAR"		printk(KERN_ERR "Summit chipset: Could not find valid CBAR"
	" value.\n");		" value.\n");
	use_cyclone = 0;		use_cyclone = 0;
	return -ENODEV;		return -ENODEV;
	}		}
	iounmap(reg);

	/* setup PMCC */		/* setup PMCC */
	offset = (base + CYCLONE_PMCC_OFFSET);		offset = (base + CYCLONE_PMCC_OFFSET);

arch/ia64/kernel/iosapic.c

+9 −51

Original line number	Original line	Diff line number	Diff line
	@@ -108,10 +108,6 @@
	#define DBG(fmt...)		#define DBG(fmt...)
	#endif		#endif

	#define NR_PREALLOCATE_RTE_ENTRIES \
	(PAGE_SIZE / sizeof(struct iosapic_rte_info))
	#define RTE_PREALLOCATED (1)

	static DEFINE_SPINLOCK(iosapic_lock);		static DEFINE_SPINLOCK(iosapic_lock);

	/*		/*
	@@ -136,7 +132,6 @@ struct iosapic_rte_info {
	struct list_head rte_list; /* RTEs sharing the same vector */		struct list_head rte_list; /* RTEs sharing the same vector */
	char rte_index; /* IOSAPIC RTE index */		char rte_index; /* IOSAPIC RTE index */
	int refcnt; /* reference counter */		int refcnt; /* reference counter */
	unsigned int flags; /* flags */
	struct iosapic *iosapic;		struct iosapic *iosapic;
	} ____cacheline_aligned;		} ____cacheline_aligned;

	@@ -155,9 +150,6 @@ static struct iosapic_intr_info {

	static unsigned char pcat_compat __devinitdata; /* 8259 compatibility flag */		static unsigned char pcat_compat __devinitdata; /* 8259 compatibility flag */

	static int iosapic_kmalloc_ok;
	static LIST_HEAD(free_rte_list);

	static inline void		static inline void
	iosapic_write(struct iosapic *iosapic, unsigned int reg, u32 val)		iosapic_write(struct iosapic *iosapic, unsigned int reg, u32 val)
	{		{
	@@ -394,7 +386,7 @@ iosapic_startup_level_irq (unsigned int irq)
	}		}

	static void		static void
	iosapic_end_level_irq (unsigned int irq)		iosapic_unmask_level_irq (unsigned int irq)
	{		{
	ia64_vector vec = irq_to_vector(irq);		ia64_vector vec = irq_to_vector(irq);
	struct iosapic_rte_info *rte;		struct iosapic_rte_info *rte;
	@@ -404,7 +396,8 @@ iosapic_end_level_irq (unsigned int irq)
	if (unlikely(irq_desc[irq].status & IRQ_MOVE_PENDING)) {		if (unlikely(irq_desc[irq].status & IRQ_MOVE_PENDING)) {
	do_unmask_irq = 1;		do_unmask_irq = 1;
	mask_irq(irq);		mask_irq(irq);
	}		} else
			unmask_irq(irq);

	list_for_each_entry(rte, &iosapic_intr_info[irq].rtes, rte_list)		list_for_each_entry(rte, &iosapic_intr_info[irq].rtes, rte_list)
	iosapic_eoi(rte->iosapic->addr, vec);		iosapic_eoi(rte->iosapic->addr, vec);
	@@ -427,9 +420,8 @@ static struct irq_chip irq_type_iosapic_level = {
	.enable = iosapic_enable_level_irq,		.enable = iosapic_enable_level_irq,
	.disable = iosapic_disable_level_irq,		.disable = iosapic_disable_level_irq,
	.ack = iosapic_ack_level_irq,		.ack = iosapic_ack_level_irq,
	.end = iosapic_end_level_irq,
	.mask = mask_irq,		.mask = mask_irq,
	.unmask = unmask_irq,		.unmask = iosapic_unmask_level_irq,
	.set_affinity = iosapic_set_affinity		.set_affinity = iosapic_set_affinity
	};		};

	@@ -552,37 +544,6 @@ iosapic_reassign_vector (int irq)
	}		}
	}		}

	static struct iosapic_rte_info * __init_refok iosapic_alloc_rte (void)
	{
	int i;
	struct iosapic_rte_info *rte;
	int preallocated = 0;

	if (!iosapic_kmalloc_ok && list_empty(&free_rte_list)) {
	rte = alloc_bootmem(sizeof(struct iosapic_rte_info) *
	NR_PREALLOCATE_RTE_ENTRIES);
	for (i = 0; i < NR_PREALLOCATE_RTE_ENTRIES; i++, rte++)
	list_add(&rte->rte_list, &free_rte_list);
	}

	if (!list_empty(&free_rte_list)) {
	rte = list_entry(free_rte_list.next, struct iosapic_rte_info,
	rte_list);
	list_del(&rte->rte_list);
	preallocated++;
	} else {
	rte = kmalloc(sizeof(struct iosapic_rte_info), GFP_ATOMIC);
	if (!rte)
	return NULL;
	}

	memset(rte, 0, sizeof(struct iosapic_rte_info));
	if (preallocated)
	rte->flags \|= RTE_PREALLOCATED;

	return rte;
	}

	static inline int irq_is_shared (int irq)		static inline int irq_is_shared (int irq)
	{		{
	return (iosapic_intr_info[irq].count > 1);		return (iosapic_intr_info[irq].count > 1);
	@@ -615,7 +576,7 @@ register_intr (unsigned int gsi, int irq, unsigned char delivery,

	rte = find_rte(irq, gsi);		rte = find_rte(irq, gsi);
	if (!rte) {		if (!rte) {
	rte = iosapic_alloc_rte();		rte = kzalloc(sizeof (*rte), GFP_ATOMIC);
	if (!rte) {		if (!rte) {
	printk(KERN_WARNING "%s: cannot allocate memory\n",		printk(KERN_WARNING "%s: cannot allocate memory\n",
	__func__);		__func__);
	@@ -658,6 +619,10 @@ register_intr (unsigned int gsi, int irq, unsigned char delivery,
	idesc->chip->name, irq_type->name);		idesc->chip->name, irq_type->name);
	idesc->chip = irq_type;		idesc->chip = irq_type;
	}		}
			if (trigger == IOSAPIC_EDGE)
			__set_irq_handler_unlocked(irq, handle_edge_irq);
			else
			__set_irq_handler_unlocked(irq, handle_level_irq);
	return 0;		return 0;
	}		}

	@@ -1161,10 +1126,3 @@ map_iosapic_to_node(unsigned int gsi_base, int node)
	return;		return;
	}		}
	#endif		#endif

	static int __init iosapic_enable_kmalloc (void)
	{
	iosapic_kmalloc_ok = 1;
	return 0;
	}
	core_initcall (iosapic_enable_kmalloc);