Logo Search packages:      
Sourcecode: linux version File versions

bitops.h

#ifndef _H8300_BITOPS_H
#define _H8300_BITOPS_H

/*
 * Copyright 1992, Linus Torvalds.
 * Copyright 2002, Yoshinori Sato
 */

#include <linux/compiler.h>
#include <asm/system.h>

#ifdef __KERNEL__

#ifndef _LINUX_BITOPS_H
#error only <linux/bitops.h> can be included directly
#endif

/*
 * Function prototypes to keep gcc -Wall happy
 */

/*
 * ffz = Find First Zero in word. Undefined if no zero exists,
 * so code should check against ~0UL first..
 */
static __inline__ unsigned long ffz(unsigned long word)
{
      unsigned long result;

      result = -1;
      __asm__("1:\n\t"
            "shlr.l %2\n\t"
            "adds #1,%0\n\t"
            "bcs 1b"
            : "=r" (result)
            : "0"  (result),"r" (word));
      return result;
}

#define H8300_GEN_BITOP_CONST(OP,BIT)                     \
      case BIT:                               \
      __asm__(OP " #" #BIT ",@%0"::"r"(b_addr):"memory"); \
      break;

#define H8300_GEN_BITOP(FNAME,OP)                           \
static __inline__ void FNAME(int nr, volatile unsigned long* addr)    \
{                                                     \
      volatile unsigned char *b_addr;                             \
      b_addr = (volatile unsigned char *)addr + ((nr >> 3) ^ 3);    \
      if (__builtin_constant_p(nr)) {                             \
            switch(nr & 7) {                          \
                  H8300_GEN_BITOP_CONST(OP,0)               \
                  H8300_GEN_BITOP_CONST(OP,1)               \
                  H8300_GEN_BITOP_CONST(OP,2)               \
                  H8300_GEN_BITOP_CONST(OP,3)               \
                  H8300_GEN_BITOP_CONST(OP,4)               \
                  H8300_GEN_BITOP_CONST(OP,5)               \
                  H8300_GEN_BITOP_CONST(OP,6)               \
                  H8300_GEN_BITOP_CONST(OP,7)               \
            }                                         \
      } else {                                        \
            __asm__(OP " %w0,@%1"::"r"(nr),"r"(b_addr):"memory"); \
      }                                               \
}

/*
 * clear_bit() doesn't provide any barrier for the compiler.
 */
#define smp_mb__before_clear_bit()  barrier()
#define smp_mb__after_clear_bit()   barrier()

H8300_GEN_BITOP(set_bit   ,"bset")
H8300_GEN_BITOP(clear_bit ,"bclr")
H8300_GEN_BITOP(change_bit,"bnot")
#define __set_bit(nr,addr)    set_bit((nr),(addr))
#define __clear_bit(nr,addr)  clear_bit((nr),(addr))
#define __change_bit(nr,addr) change_bit((nr),(addr))

#undef H8300_GEN_BITOP
#undef H8300_GEN_BITOP_CONST

static __inline__ int test_bit(int nr, const unsigned long* addr)
{
      return (*((volatile unsigned char *)addr + 
               ((nr >> 3) ^ 3)) & (1UL << (nr & 7))) != 0;
}

#define __test_bit(nr, addr) test_bit(nr, addr)

#define H8300_GEN_TEST_BITOP_CONST_INT(OP,BIT)                   \
      case BIT:                                      \
      __asm__("stc ccr,%w1\n\t"                            \
            "orc #0x80,ccr\n\t"                            \
            "bld #" #BIT ",@%4\n\t"                        \
            OP " #" #BIT ",@%4\n\t"                        \
            "rotxl.l %0\n\t"                         \
            "ldc %w1,ccr"                                  \
            : "=r"(retval),"=&r"(ccrsave),"=m"(*b_addr)          \
            : "0" (retval),"r" (b_addr)                    \
            : "memory");                                         \
        break;

#define H8300_GEN_TEST_BITOP_CONST(OP,BIT)                       \
      case BIT:                                      \
      __asm__("bld #" #BIT ",@%3\n\t"                            \
            OP " #" #BIT ",@%3\n\t"                        \
            "rotxl.l %0\n\t"                         \
            : "=r"(retval),"=m"(*b_addr)                   \
            : "0" (retval),"r" (b_addr)                    \
            : "memory");                                         \
        break;

#define H8300_GEN_TEST_BITOP(FNNAME,OP)                          \
static __inline__ int FNNAME(int nr, volatile void * addr)       \
{                                                    \
      int retval = 0;                                      \
      char ccrsave;                                        \
      volatile unsigned char *b_addr;                            \
      b_addr = (volatile unsigned char *)addr + ((nr >> 3) ^ 3);   \
      if (__builtin_constant_p(nr)) {                            \
            switch(nr & 7) {                         \
                  H8300_GEN_TEST_BITOP_CONST_INT(OP,0)           \
                  H8300_GEN_TEST_BITOP_CONST_INT(OP,1)           \
                  H8300_GEN_TEST_BITOP_CONST_INT(OP,2)           \
                  H8300_GEN_TEST_BITOP_CONST_INT(OP,3)           \
                  H8300_GEN_TEST_BITOP_CONST_INT(OP,4)           \
                  H8300_GEN_TEST_BITOP_CONST_INT(OP,5)           \
                  H8300_GEN_TEST_BITOP_CONST_INT(OP,6)           \
                  H8300_GEN_TEST_BITOP_CONST_INT(OP,7)           \
            }                                        \
      } else {                                       \
            __asm__("stc ccr,%w1\n\t"                      \
                  "orc #0x80,ccr\n\t"                      \
                  "btst %w5,@%4\n\t"                       \
                  OP " %w5,@%4\n\t"                  \
                  "beq 1f\n\t"                             \
                  "inc.l #1,%0\n"                          \
                  "1:\n\t"                           \
                  "ldc %w1,ccr"                            \
                  : "=r"(retval),"=&r"(ccrsave),"=m"(*b_addr)  \
                  : "0" (retval),"r" (b_addr),"r"(nr)      \
                  : "memory");                             \
      }                                              \
      return retval;                                       \
}                                                    \
                                                     \
static __inline__ int __ ## FNNAME(int nr, volatile void * addr)     \
{                                                    \
      int retval = 0;                                      \
      volatile unsigned char *b_addr;                            \
      b_addr = (volatile unsigned char *)addr + ((nr >> 3) ^ 3);   \
      if (__builtin_constant_p(nr)) {                            \
            switch(nr & 7) {                         \
                  H8300_GEN_TEST_BITOP_CONST(OP,0)         \
                  H8300_GEN_TEST_BITOP_CONST(OP,1)         \
                  H8300_GEN_TEST_BITOP_CONST(OP,2)         \
                  H8300_GEN_TEST_BITOP_CONST(OP,3)         \
                  H8300_GEN_TEST_BITOP_CONST(OP,4)         \
                  H8300_GEN_TEST_BITOP_CONST(OP,5)         \
                  H8300_GEN_TEST_BITOP_CONST(OP,6)         \
                  H8300_GEN_TEST_BITOP_CONST(OP,7)         \
            }                                        \
      } else {                                       \
            __asm__("btst %w4,@%3\n\t"                     \
                  OP " %w4,@%3\n\t"                  \
                  "beq 1f\n\t"                             \
                  "inc.l #1,%0\n"                          \
                  "1:"                               \
                  : "=r"(retval),"=m"(*b_addr)             \
                  : "0" (retval),"r" (b_addr),"r"(nr)      \
                  : "memory");                             \
      }                                              \
      return retval;                                       \
}

H8300_GEN_TEST_BITOP(test_and_set_bit,     "bset")
H8300_GEN_TEST_BITOP(test_and_clear_bit, "bclr")
H8300_GEN_TEST_BITOP(test_and_change_bit,"bnot")
#undef H8300_GEN_TEST_BITOP_CONST
#undef H8300_GEN_TEST_BITOP_CONST_INT
#undef H8300_GEN_TEST_BITOP

#include <asm-generic/bitops/ffs.h>

static __inline__ unsigned long __ffs(unsigned long word)
{
      unsigned long result;

      result = -1;
      __asm__("1:\n\t"
            "shlr.l %2\n\t"
            "adds #1,%0\n\t"
            "bcc 1b"
            : "=r" (result)
            : "0"(result),"r"(word));
      return result;
}

#include <asm-generic/bitops/find.h>
#include <asm-generic/bitops/sched.h>
#include <asm-generic/bitops/hweight.h>
#include <asm-generic/bitops/lock.h>
#include <asm-generic/bitops/ext2-non-atomic.h>
#include <asm-generic/bitops/ext2-atomic.h>
#include <asm-generic/bitops/minix.h>

#endif /* __KERNEL__ */

#include <asm-generic/bitops/fls.h>
#include <asm-generic/bitops/fls64.h>

#endif /* _H8300_BITOPS_H */

Generated by  Doxygen 1.6.0   Back to index