Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 95694129 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'paul' (Fixups from Paul Gortmaker) 

This merges some of the fixes from Paul Gortmaker for the header file
cleanup fallout.

Some of the patches are going through arch maintainer trees, and David
Howells suggested another be done differently, but this at least fixes a
few cases.

* emailed from Paul Gortmaker <paul.gortmaker@windriver.com>:
  asm-generic: add linux/types.h to cmpxchg.h
  firewire: restore the device.h include in linux/firewire.h
  frv: fix warnings in mb93090-mb00/pci-dma.c about implicit EXPORT_SYMBOL
  parisc: fix missing cmpxchg file error from system.h split
  blackfin: fix cmpxchg build fails from system.h fallout
  avr32: fix build failures from mis-naming of atmel_nand.h
  ARM: mach-msm: fix compile fail from system.h fallout
  irq_work: fix compile failure on MIPS from system.h split
parents b1a808ff 80da6a4f

arch/arm/mach-msm/include/mach/uncompress.h

+1 −0
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ 
#ifndef __ASM_ARCH_MSM_UNCOMPRESS_H

#define __ASM_ARCH_MSM_UNCOMPRESS_H



#include <asm/barrier.h>

#include <asm/processor.h>

#include <mach/msm_iomap.h>

arch/avr32/mach-at32ap/include/mach/board.h

+1 −1
Original line number Diff line number Diff line
@@ -7,7 +7,7 @@ 
#include <linux/types.h>

#include <linux/serial.h>

#include <linux/platform_data/macb.h>

#include <linux/platform_data/atmel_nand.h>

#include <linux/platform_data/atmel.h>



#define GPIO_PIN_NONE	(-1)

arch/blackfin/include/asm/cmpxchg.h

+2 −1
Original line number Diff line number Diff line
@@ -122,7 +122,8 @@ static inline unsigned long __xchg(unsigned long x, volatile void *ptr, 
			(unsigned long)(n), sizeof(*(ptr))))

#define cmpxchg64_local(ptr, o, n) __cmpxchg64_local_generic((ptr), (o), (n))



#include <asm-generic/cmpxchg.h>

#define cmpxchg(ptr, o, n)	cmpxchg_local((ptr), (o), (n))

#define cmpxchg64(ptr, o, n)	cmpxchg64_local((ptr), (o), (n))



#endif /* !CONFIG_SMP */

arch/frv/mb93090-mb00/pci-dma.c

+1 −0
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#include <linux/dma-mapping.h>

#include <linux/list.h>

#include <linux/pci.h>

#include <linux/export.h>

#include <linux/highmem.h>

#include <linux/scatterlist.h>

#include <asm/io.h>

arch/parisc/include/asm/atomic.h

+1 −106
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 
#define _ASM_PARISC_ATOMIC_H_



#include <linux/types.h>

#include <asm/cmpxchg.h>



/*

 * Atomic operations that C can't guarantee us.  Useful for
@@ -48,112 +49,6 @@ extern arch_spinlock_t __atomic_hash[ATOMIC_HASH_SIZE] __lock_aligned; 
#  define _atomic_spin_unlock_irqrestore(l,f) do { local_irq_restore(f); } while (0)

#endif



/* This should get optimized out since it's never called.

** Or get a link error if xchg is used "wrong".

*/

extern void __xchg_called_with_bad_pointer(void);





/* __xchg32/64 defined in arch/parisc/lib/bitops.c */

extern unsigned long __xchg8(char, char *);

extern unsigned long __xchg32(int, int *);

#ifdef CONFIG_64BIT

extern unsigned long __xchg64(unsigned long, unsigned long *);

#endif



/* optimizer better get rid of switch since size is a constant */

static __inline__ unsigned long

__xchg(unsigned long x, __volatile__ void * ptr, int size)

{

	switch(size) {

#ifdef CONFIG_64BIT

	case 8: return __xchg64(x,(unsigned long *) ptr);

#endif

	case 4: return __xchg32((int) x, (int *) ptr);

	case 1: return __xchg8((char) x, (char *) ptr);

	}

	__xchg_called_with_bad_pointer();

	return x;

}





/*

** REVISIT - Abandoned use of LDCW in xchg() for now:

** o need to test sizeof(*ptr) to avoid clearing adjacent bytes

** o and while we are at it, could CONFIG_64BIT code use LDCD too?

**

**	if (__builtin_constant_p(x) && (x == NULL))

**		if (((unsigned long)p & 0xf) == 0)

**			return __ldcw(p);

*/

#define xchg(ptr,x) \

	((__typeof__(*(ptr)))__xchg((unsigned long)(x),(ptr),sizeof(*(ptr))))





#define __HAVE_ARCH_CMPXCHG	1



/* bug catcher for when unsupported size is used - won't link */

extern void __cmpxchg_called_with_bad_pointer(void);



/* __cmpxchg_u32/u64 defined in arch/parisc/lib/bitops.c */

extern unsigned long __cmpxchg_u32(volatile unsigned int *m, unsigned int old, unsigned int new_);

extern unsigned long __cmpxchg_u64(volatile unsigned long *ptr, unsigned long old, unsigned long new_);



/* don't worry...optimizer will get rid of most of this */

static __inline__ unsigned long

__cmpxchg(volatile void *ptr, unsigned long old, unsigned long new_, int size)

{

	switch(size) {

#ifdef CONFIG_64BIT

	case 8: return __cmpxchg_u64((unsigned long *)ptr, old, new_);

#endif

	case 4: return __cmpxchg_u32((unsigned int *)ptr, (unsigned int) old, (unsigned int) new_);

	}

	__cmpxchg_called_with_bad_pointer();

	return old;

}



#define cmpxchg(ptr,o,n)						 \

  ({									 \

     __typeof__(*(ptr)) _o_ = (o);					 \

     __typeof__(*(ptr)) _n_ = (n);					 \

     (__typeof__(*(ptr))) __cmpxchg((ptr), (unsigned long)_o_,		 \

				    (unsigned long)_n_, sizeof(*(ptr))); \

  })



#include <asm-generic/cmpxchg-local.h>



static inline unsigned long __cmpxchg_local(volatile void *ptr,

				      unsigned long old,

				      unsigned long new_, int size)

{

	switch (size) {

#ifdef CONFIG_64BIT

	case 8:	return __cmpxchg_u64((unsigned long *)ptr, old, new_);

#endif

	case 4:	return __cmpxchg_u32(ptr, old, new_);

	default:

		return __cmpxchg_local_generic(ptr, old, new_, size);

	}

}



/*

 * cmpxchg_local and cmpxchg64_local are atomic wrt current CPU. Always make

 * them available.

 */

#define cmpxchg_local(ptr, o, n)				  	\

	((__typeof__(*(ptr)))__cmpxchg_local((ptr), (unsigned long)(o),	\

			(unsigned long)(n), sizeof(*(ptr))))

#ifdef CONFIG_64BIT

#define cmpxchg64_local(ptr, o, n)					\

  ({									\

	BUILD_BUG_ON(sizeof(*(ptr)) != 8);				\

	cmpxchg_local((ptr), (o), (n));					\

  })

#else

#define cmpxchg64_local(ptr, o, n) __cmpxchg64_local_generic((ptr), (o), (n))

#endif



/*

 * Note that we need not lock read accesses - aligned word writes/reads

 * are atomic, so a reader never sees inconsistent values.