1#ifndef _BLACKFIN_BITOPS_H 2#define _BLACKFIN_BITOPS_H 3 4/* 5 * Copyright 1992, Linus Torvalds. 6 */ 7 8#include <linux/compiler.h> 9#include <asm/byteorder.h> /* swab32 */ 10#include <asm/system.h> /* save_flags */ 11 12#ifdef __KERNEL__ 13 14#include <asm-generic/bitops/ffs.h> 15#include <asm-generic/bitops/__ffs.h> 16#include <asm-generic/bitops/sched.h> 17#include <asm-generic/bitops/ffz.h> 18 19static __inline__ void set_bit(int nr, volatile unsigned long *addr) 20{ 21 int *a = (int *)addr; 22 int mask; 23 unsigned long flags; 24 25 a += nr >> 5; 26 mask = 1 << (nr & 0x1f); 27 local_irq_save(flags); 28 *a |= mask; 29 local_irq_restore(flags); 30} 31 32static __inline__ void __set_bit(int nr, volatile unsigned long *addr) 33{ 34 int *a = (int *)addr; 35 int mask; 36 37 a += nr >> 5; 38 mask = 1 << (nr & 0x1f); 39 *a |= mask; 40} 41 42/* 43 * clear_bit() doesn't provide any barrier for the compiler. 44 */ 45#define smp_mb__before_clear_bit() barrier() 46#define smp_mb__after_clear_bit() barrier() 47 48static __inline__ void clear_bit(int nr, volatile unsigned long *addr) 49{ 50 int *a = (int *)addr; 51 int mask; 52 unsigned long flags; 53 a += nr >> 5; 54 mask = 1 << (nr & 0x1f); 55 local_irq_save(flags); 56 *a &= ~mask; 57 local_irq_restore(flags); 58} 59 60static __inline__ void __clear_bit(int nr, volatile unsigned long *addr) 61{ 62 int *a = (int *)addr; 63 int mask; 64 65 a += nr >> 5; 66 mask = 1 << (nr & 0x1f); 67 *a &= ~mask; 68} 69 70static __inline__ void change_bit(int nr, volatile unsigned long *addr) 71{ 72 int mask, flags; 73 unsigned long *ADDR = (unsigned long *)addr; 74 75 ADDR += nr >> 5; 76 mask = 1 << (nr & 31); 77 local_irq_save(flags); 78 *ADDR ^= mask; 79 local_irq_restore(flags); 80} 81 82static __inline__ void __change_bit(int nr, volatile unsigned long *addr) 83{ 84 int mask; 85 unsigned long *ADDR = (unsigned long *)addr; 86 87 ADDR += nr >> 5; 88 mask = 1 << (nr & 31); 89 *ADDR ^= mask; 90} 91 92static __inline__ int test_and_set_bit(int nr, void *addr) 93{ 94 int mask, retval; 95 volatile unsigned int *a = (volatile unsigned int *)addr; 96 unsigned long flags; 97 98 a += nr >> 5; 99 mask = 1 << (nr & 0x1f); 100 local_irq_save(flags); 101 retval = (mask & *a) != 0; 102 *a |= mask; 103 local_irq_restore(flags); 104 105 return retval; 106} 107 108static __inline__ int __test_and_set_bit(int nr, volatile unsigned long *addr) 109{ 110 int mask, retval; 111 volatile unsigned int *a = (volatile unsigned int *)addr; 112 113 a += nr >> 5; 114 mask = 1 << (nr & 0x1f); 115 retval = (mask & *a) != 0; 116 *a |= mask; 117 return retval; 118} 119 120static __inline__ int test_and_clear_bit(int nr, volatile unsigned long *addr) 121{ 122 int mask, retval; 123 volatile unsigned int *a = (volatile unsigned int *)addr; 124 unsigned long flags; 125 126 a += nr >> 5; 127 mask = 1 << (nr & 0x1f); 128 local_irq_save(flags); 129 retval = (mask & *a) != 0; 130 *a &= ~mask; 131 local_irq_restore(flags); 132 133 return retval; 134} 135 136static __inline__ int __test_and_clear_bit(int nr, volatile unsigned long *addr) 137{ 138 int mask, retval; 139 volatile unsigned int *a = (volatile unsigned int *)addr; 140 141 a += nr >> 5; 142 mask = 1 << (nr & 0x1f); 143 retval = (mask & *a) != 0; 144 *a &= ~mask; 145 return retval; 146} 147 148static __inline__ int test_and_change_bit(int nr, volatile unsigned long *addr) 149{ 150 int mask, retval; 151 volatile unsigned int *a = (volatile unsigned int *)addr; 152 unsigned long flags; 153 154 a += nr >> 5; 155 mask = 1 << (nr & 0x1f); 156 local_irq_save(flags); 157 retval = (mask & *a) != 0; 158 *a ^= mask; 159 local_irq_restore(flags); 160 return retval; 161} 162 163static __inline__ int __test_and_change_bit(int nr, 164 volatile unsigned long *addr) 165{ 166 int mask, retval; 167 volatile unsigned int *a = (volatile unsigned int *)addr; 168 169 a += nr >> 5; 170 mask = 1 << (nr & 0x1f); 171 retval = (mask & *a) != 0; 172 *a ^= mask; 173 return retval; 174} 175 176/* 177 * This routine doesn't need to be atomic. 178 */ 179static __inline__ int __constant_test_bit(int nr, const void *addr) 180{ 181 return ((1UL << (nr & 31)) & 182 (((const volatile unsigned int *)addr)[nr >> 5])) != 0; 183} 184 185static __inline__ int __test_bit(int nr, const void *addr) 186{ 187 int *a = (int *)addr; 188 int mask; 189 190 a += nr >> 5; 191 mask = 1 << (nr & 0x1f); 192 return ((mask & *a) != 0); 193} 194 195#define test_bit(nr,addr) \ 196(__builtin_constant_p(nr) ? \ 197 __constant_test_bit((nr),(addr)) : \ 198 __test_bit((nr),(addr))) 199 200#include <asm-generic/bitops/find.h> 201#include <asm-generic/bitops/hweight.h> 202 203#include <asm-generic/bitops/ext2-atomic.h> 204#include <asm-generic/bitops/ext2-non-atomic.h> 205 206#include <asm-generic/bitops/minix.h> 207 208#endif /* __KERNEL__ */ 209 210#include <asm-generic/bitops/fls.h> 211#include <asm-generic/bitops/fls64.h> 212 213#endif /* _BLACKFIN_BITOPS_H */ 214