mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-11-11 15:37:23 +00:00
a47a12becf
As discussed on the list, move "arch/ppc" to "arch/powerpc" to better match the Linux directory structure. Please note that this patch also changes the "ppc" target in MAKEALL to "powerpc" to match this new infrastructure. But "ppc" is kept as an alias for now, to not break compatibility with scripts using this name. Signed-off-by: Stefan Roese <sr@denx.de> Acked-by: Wolfgang Denk <wd@denx.de> Acked-by: Detlev Zundel <dzu@denx.de> Acked-by: Kim Phillips <kim.phillips@freescale.com> Cc: Peter Tyser <ptyser@xes-inc.com> Cc: Anatolij Gustschin <agust@denx.de>
387 lines
8.5 KiB
C
387 lines
8.5 KiB
C
/*
|
|
* bitops.h: Bit string operations on the ppc
|
|
*/
|
|
|
|
#ifndef _PPC_BITOPS_H
|
|
#define _PPC_BITOPS_H
|
|
|
|
#include <linux/config.h>
|
|
#include <asm/byteorder.h>
|
|
|
|
extern void set_bit(int nr, volatile void *addr);
|
|
extern void clear_bit(int nr, volatile void *addr);
|
|
extern void change_bit(int nr, volatile void *addr);
|
|
extern int test_and_set_bit(int nr, volatile void *addr);
|
|
extern int test_and_clear_bit(int nr, volatile void *addr);
|
|
extern int test_and_change_bit(int nr, volatile void *addr);
|
|
|
|
/*
|
|
* Arguably these bit operations don't imply any memory barrier or
|
|
* SMP ordering, but in fact a lot of drivers expect them to imply
|
|
* both, since they do on x86 cpus.
|
|
*/
|
|
#ifdef CONFIG_SMP
|
|
#define SMP_WMB "eieio\n"
|
|
#define SMP_MB "\nsync"
|
|
#else
|
|
#define SMP_WMB
|
|
#define SMP_MB
|
|
#endif /* CONFIG_SMP */
|
|
|
|
#define __INLINE_BITOPS 1
|
|
|
|
#if __INLINE_BITOPS
|
|
/*
|
|
* These used to be if'd out here because using : "cc" as a constraint
|
|
* resulted in errors from egcs. Things may be OK with gcc-2.95.
|
|
*/
|
|
extern __inline__ void set_bit(int nr, volatile void * addr)
|
|
{
|
|
unsigned long old;
|
|
unsigned long mask = 1 << (nr & 0x1f);
|
|
unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
|
|
|
|
__asm__ __volatile__(SMP_WMB "\
|
|
1: lwarx %0,0,%3\n\
|
|
or %0,%0,%2\n\
|
|
stwcx. %0,0,%3\n\
|
|
bne 1b"
|
|
SMP_MB
|
|
: "=&r" (old), "=m" (*p)
|
|
: "r" (mask), "r" (p), "m" (*p)
|
|
: "cc" );
|
|
}
|
|
|
|
extern __inline__ void clear_bit(int nr, volatile void *addr)
|
|
{
|
|
unsigned long old;
|
|
unsigned long mask = 1 << (nr & 0x1f);
|
|
unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
|
|
|
|
__asm__ __volatile__(SMP_WMB "\
|
|
1: lwarx %0,0,%3\n\
|
|
andc %0,%0,%2\n\
|
|
stwcx. %0,0,%3\n\
|
|
bne 1b"
|
|
SMP_MB
|
|
: "=&r" (old), "=m" (*p)
|
|
: "r" (mask), "r" (p), "m" (*p)
|
|
: "cc");
|
|
}
|
|
|
|
extern __inline__ void change_bit(int nr, volatile void *addr)
|
|
{
|
|
unsigned long old;
|
|
unsigned long mask = 1 << (nr & 0x1f);
|
|
unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
|
|
|
|
__asm__ __volatile__(SMP_WMB "\
|
|
1: lwarx %0,0,%3\n\
|
|
xor %0,%0,%2\n\
|
|
stwcx. %0,0,%3\n\
|
|
bne 1b"
|
|
SMP_MB
|
|
: "=&r" (old), "=m" (*p)
|
|
: "r" (mask), "r" (p), "m" (*p)
|
|
: "cc");
|
|
}
|
|
|
|
extern __inline__ int test_and_set_bit(int nr, volatile void *addr)
|
|
{
|
|
unsigned int old, t;
|
|
unsigned int mask = 1 << (nr & 0x1f);
|
|
volatile unsigned int *p = ((volatile unsigned int *)addr) + (nr >> 5);
|
|
|
|
__asm__ __volatile__(SMP_WMB "\
|
|
1: lwarx %0,0,%4\n\
|
|
or %1,%0,%3\n\
|
|
stwcx. %1,0,%4\n\
|
|
bne 1b"
|
|
SMP_MB
|
|
: "=&r" (old), "=&r" (t), "=m" (*p)
|
|
: "r" (mask), "r" (p), "m" (*p)
|
|
: "cc");
|
|
|
|
return (old & mask) != 0;
|
|
}
|
|
|
|
extern __inline__ int test_and_clear_bit(int nr, volatile void *addr)
|
|
{
|
|
unsigned int old, t;
|
|
unsigned int mask = 1 << (nr & 0x1f);
|
|
volatile unsigned int *p = ((volatile unsigned int *)addr) + (nr >> 5);
|
|
|
|
__asm__ __volatile__(SMP_WMB "\
|
|
1: lwarx %0,0,%4\n\
|
|
andc %1,%0,%3\n\
|
|
stwcx. %1,0,%4\n\
|
|
bne 1b"
|
|
SMP_MB
|
|
: "=&r" (old), "=&r" (t), "=m" (*p)
|
|
: "r" (mask), "r" (p), "m" (*p)
|
|
: "cc");
|
|
|
|
return (old & mask) != 0;
|
|
}
|
|
|
|
extern __inline__ int test_and_change_bit(int nr, volatile void *addr)
|
|
{
|
|
unsigned int old, t;
|
|
unsigned int mask = 1 << (nr & 0x1f);
|
|
volatile unsigned int *p = ((volatile unsigned int *)addr) + (nr >> 5);
|
|
|
|
__asm__ __volatile__(SMP_WMB "\
|
|
1: lwarx %0,0,%4\n\
|
|
xor %1,%0,%3\n\
|
|
stwcx. %1,0,%4\n\
|
|
bne 1b"
|
|
SMP_MB
|
|
: "=&r" (old), "=&r" (t), "=m" (*p)
|
|
: "r" (mask), "r" (p), "m" (*p)
|
|
: "cc");
|
|
|
|
return (old & mask) != 0;
|
|
}
|
|
#endif /* __INLINE_BITOPS */
|
|
|
|
extern __inline__ int test_bit(int nr, __const__ volatile void *addr)
|
|
{
|
|
__const__ unsigned int *p = (__const__ unsigned int *) addr;
|
|
|
|
return ((p[nr >> 5] >> (nr & 0x1f)) & 1) != 0;
|
|
}
|
|
|
|
/* Return the bit position of the most significant 1 bit in a word */
|
|
/* - the result is undefined when x == 0 */
|
|
extern __inline__ int __ilog2(unsigned int x)
|
|
{
|
|
int lz;
|
|
|
|
asm ("cntlzw %0,%1" : "=r" (lz) : "r" (x));
|
|
return 31 - lz;
|
|
}
|
|
|
|
extern __inline__ int ffz(unsigned int x)
|
|
{
|
|
if ((x = ~x) == 0)
|
|
return 32;
|
|
return __ilog2(x & -x);
|
|
}
|
|
|
|
/*
|
|
* fls: find last (most-significant) bit set.
|
|
* Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32.
|
|
*
|
|
* On powerpc, __ilog2(0) returns -1, but this is not safe in general
|
|
*/
|
|
static __inline__ int fls(unsigned int x)
|
|
{
|
|
return __ilog2(x) + 1;
|
|
}
|
|
#define PLATFORM_FLS
|
|
|
|
/**
|
|
* fls64 - find last set bit in a 64-bit word
|
|
* @x: the word to search
|
|
*
|
|
* This is defined in a similar way as the libc and compiler builtin
|
|
* ffsll, but returns the position of the most significant set bit.
|
|
*
|
|
* fls64(value) returns 0 if value is 0 or the position of the last
|
|
* set bit if value is nonzero. The last (most significant) bit is
|
|
* at position 64.
|
|
*/
|
|
#if BITS_PER_LONG == 32
|
|
static inline int fls64(__u64 x)
|
|
{
|
|
__u32 h = x >> 32;
|
|
if (h)
|
|
return fls(h) + 32;
|
|
return fls(x);
|
|
}
|
|
#elif BITS_PER_LONG == 64
|
|
static inline int fls64(__u64 x)
|
|
{
|
|
if (x == 0)
|
|
return 0;
|
|
return __ilog2(x) + 1;
|
|
}
|
|
#else
|
|
#error BITS_PER_LONG not 32 or 64
|
|
#endif
|
|
|
|
static inline int __ilog2_u64(u64 n)
|
|
{
|
|
return fls64(n) - 1;
|
|
}
|
|
|
|
static inline int ffs64(u64 x)
|
|
{
|
|
return __ilog2_u64(x & -x) + 1ull;
|
|
}
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
/*
|
|
* ffs: find first bit set. This is defined the same way as
|
|
* the libc and compiler builtin ffs routines, therefore
|
|
* differs in spirit from the above ffz (man ffs).
|
|
*/
|
|
extern __inline__ int ffs(int x)
|
|
{
|
|
return __ilog2(x & -x) + 1;
|
|
}
|
|
#define PLATFORM_FFS
|
|
|
|
/*
|
|
* hweightN: returns the hamming weight (i.e. the number
|
|
* of bits set) of a N-bit word
|
|
*/
|
|
|
|
#define hweight32(x) generic_hweight32(x)
|
|
#define hweight16(x) generic_hweight16(x)
|
|
#define hweight8(x) generic_hweight8(x)
|
|
|
|
#endif /* __KERNEL__ */
|
|
|
|
/*
|
|
* This implementation of find_{first,next}_zero_bit was stolen from
|
|
* Linus' asm-alpha/bitops.h.
|
|
*/
|
|
#define find_first_zero_bit(addr, size) \
|
|
find_next_zero_bit((addr), (size), 0)
|
|
|
|
extern __inline__ unsigned long find_next_zero_bit(void * addr,
|
|
unsigned long size, unsigned long offset)
|
|
{
|
|
unsigned int * p = ((unsigned int *) addr) + (offset >> 5);
|
|
unsigned int result = offset & ~31UL;
|
|
unsigned int tmp;
|
|
|
|
if (offset >= size)
|
|
return size;
|
|
size -= result;
|
|
offset &= 31UL;
|
|
if (offset) {
|
|
tmp = *p++;
|
|
tmp |= ~0UL >> (32-offset);
|
|
if (size < 32)
|
|
goto found_first;
|
|
if (tmp != ~0U)
|
|
goto found_middle;
|
|
size -= 32;
|
|
result += 32;
|
|
}
|
|
while (size >= 32) {
|
|
if ((tmp = *p++) != ~0U)
|
|
goto found_middle;
|
|
result += 32;
|
|
size -= 32;
|
|
}
|
|
if (!size)
|
|
return result;
|
|
tmp = *p;
|
|
found_first:
|
|
tmp |= ~0UL << size;
|
|
found_middle:
|
|
return result + ffz(tmp);
|
|
}
|
|
|
|
|
|
#define _EXT2_HAVE_ASM_BITOPS_
|
|
|
|
#ifdef __KERNEL__
|
|
/*
|
|
* test_and_{set,clear}_bit guarantee atomicity without
|
|
* disabling interrupts.
|
|
*/
|
|
#define ext2_set_bit(nr, addr) test_and_set_bit((nr) ^ 0x18, addr)
|
|
#define ext2_clear_bit(nr, addr) test_and_clear_bit((nr) ^ 0x18, addr)
|
|
|
|
#else
|
|
extern __inline__ int ext2_set_bit(int nr, void * addr)
|
|
{
|
|
int mask;
|
|
unsigned char *ADDR = (unsigned char *) addr;
|
|
int oldbit;
|
|
|
|
ADDR += nr >> 3;
|
|
mask = 1 << (nr & 0x07);
|
|
oldbit = (*ADDR & mask) ? 1 : 0;
|
|
*ADDR |= mask;
|
|
return oldbit;
|
|
}
|
|
|
|
extern __inline__ int ext2_clear_bit(int nr, void * addr)
|
|
{
|
|
int mask;
|
|
unsigned char *ADDR = (unsigned char *) addr;
|
|
int oldbit;
|
|
|
|
ADDR += nr >> 3;
|
|
mask = 1 << (nr & 0x07);
|
|
oldbit = (*ADDR & mask) ? 1 : 0;
|
|
*ADDR = *ADDR & ~mask;
|
|
return oldbit;
|
|
}
|
|
#endif /* __KERNEL__ */
|
|
|
|
extern __inline__ int ext2_test_bit(int nr, __const__ void * addr)
|
|
{
|
|
__const__ unsigned char *ADDR = (__const__ unsigned char *) addr;
|
|
|
|
return (ADDR[nr >> 3] >> (nr & 7)) & 1;
|
|
}
|
|
|
|
/*
|
|
* This implementation of ext2_find_{first,next}_zero_bit was stolen from
|
|
* Linus' asm-alpha/bitops.h and modified for a big-endian machine.
|
|
*/
|
|
|
|
#define ext2_find_first_zero_bit(addr, size) \
|
|
ext2_find_next_zero_bit((addr), (size), 0)
|
|
|
|
static __inline__ unsigned long ext2_find_next_zero_bit(void *addr,
|
|
unsigned long size, unsigned long offset)
|
|
{
|
|
unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
|
|
unsigned int result = offset & ~31UL;
|
|
unsigned int tmp;
|
|
|
|
if (offset >= size)
|
|
return size;
|
|
size -= result;
|
|
offset &= 31UL;
|
|
if (offset) {
|
|
tmp = cpu_to_le32p(p++);
|
|
tmp |= ~0UL >> (32-offset);
|
|
if (size < 32)
|
|
goto found_first;
|
|
if (tmp != ~0U)
|
|
goto found_middle;
|
|
size -= 32;
|
|
result += 32;
|
|
}
|
|
while (size >= 32) {
|
|
if ((tmp = cpu_to_le32p(p++)) != ~0U)
|
|
goto found_middle;
|
|
result += 32;
|
|
size -= 32;
|
|
}
|
|
if (!size)
|
|
return result;
|
|
tmp = cpu_to_le32p(p);
|
|
found_first:
|
|
tmp |= ~0U << size;
|
|
found_middle:
|
|
return result + ffz(tmp);
|
|
}
|
|
|
|
/* Bitmap functions for the minix filesystem. */
|
|
#define minix_test_and_set_bit(nr,addr) ext2_set_bit(nr,addr)
|
|
#define minix_set_bit(nr,addr) ((void)ext2_set_bit(nr,addr))
|
|
#define minix_test_and_clear_bit(nr,addr) ext2_clear_bit(nr,addr)
|
|
#define minix_test_bit(nr,addr) ext2_test_bit(nr,addr)
|
|
#define minix_find_first_zero_bit(addr,size) ext2_find_first_zero_bit(addr,size)
|
|
|
|
#endif /* _PPC_BITOPS_H */
|