arch/tile/include/asm/bitops_32.h

   1 /*
   2  * Copyright 2010 Tilera Corporation. All Rights Reserved.
   3  *
   4  *   This program is free software; you can redistribute it and/or
   5  *   modify it under the terms of the GNU General Public License
   6  *   as published by the Free Software Foundation, version 2.
   7  *
   8  *   This program is distributed in the hope that it will be useful, but
   9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  11  *   NON INFRINGEMENT.  See the GNU General Public License for
  12  *   more details.
  13  */
  14
  15 #ifndef _ASM_TILE_BITOPS_32_H
  16 #define _ASM_TILE_BITOPS_32_H
  17
  18 #include <linux/compiler.h>
  19 #include <asm/barrier.h>
  20
  21 /* Tile-specific routines to support <asm/bitops.h>. */
  22 unsigned long _atomic_or(volatile unsigned long *p, unsigned long mask);
  23 unsigned long _atomic_andn(volatile unsigned long *p, unsigned long mask);
  24 unsigned long _atomic_xor(volatile unsigned long *p, unsigned long mask);
  25
  26 /**
  27  * set_bit - Atomically set a bit in memory
  28  * @nr: the bit to set
  29  * @addr: the address to start counting from
  30  *
  31  * This function is atomic and may not be reordered.
  32  * See __set_bit() if you do not require the atomic guarantees.
  33  * Note that @nr may be almost arbitrarily large; this function is not
  34  * restricted to acting on a single-word quantity.
  35  */
  36 static inline void set_bit(unsigned nr, volatile unsigned long *addr)
  37 {
  38         _atomic_or(addr + BIT_WORD(nr), BIT_MASK(nr));
  39 }
  40
  41 /**
  42  * clear_bit - Clears a bit in memory
  43  * @nr: Bit to clear
  44  * @addr: Address to start counting from
  45  *
  46  * clear_bit() is atomic and may not be reordered.
  47  * See __clear_bit() if you do not require the atomic guarantees.
  48  * Note that @nr may be almost arbitrarily large; this function is not
  49  * restricted to acting on a single-word quantity.
  50  *
  51  * clear_bit() may not contain a memory barrier, so if it is used for
  52  * locking purposes, you should call smp_mb__before_atomic() and/or
  53  * smp_mb__after_atomic() to ensure changes are visible on other cpus.
  54  */
  55 static inline void clear_bit(unsigned nr, volatile unsigned long *addr)
  56 {
  57         _atomic_andn(addr + BIT_WORD(nr), BIT_MASK(nr));
  58 }
  59
  60 /**
  61  * change_bit - Toggle a bit in memory
  62  * @nr: Bit to change
  63  * @addr: Address to start counting from
  64  *
  65  * change_bit() is atomic and may not be reordered.
  66  * See __change_bit() if you do not require the atomic guarantees.
  67  * Note that @nr may be almost arbitrarily large; this function is not
  68  * restricted to acting on a single-word quantity.
  69  */
  70 static inline void change_bit(unsigned nr, volatile unsigned long *addr)
  71 {
  72         _atomic_xor(addr + BIT_WORD(nr), BIT_MASK(nr));
  73 }
  74
  75 /**
  76  * test_and_set_bit - Set a bit and return its old value
  77  * @nr: Bit to set
  78  * @addr: Address to count from
  79  *
  80  * This operation is atomic and cannot be reordered.
  81  * It also implies a memory barrier.
  82  */
  83 static inline int test_and_set_bit(unsigned nr, volatile unsigned long *addr)
  84 {
  85         unsigned long mask = BIT_MASK(nr);
  86         addr += BIT_WORD(nr);
  87         smp_mb();  /* barrier for proper semantics */
  88         return (_atomic_or(addr, mask) & mask) != 0;
  89 }
  90
  91 /**
  92  * test_and_clear_bit - Clear a bit and return its old value
  93  * @nr: Bit to clear
  94  * @addr: Address to count from
  95  *
  96  * This operation is atomic and cannot be reordered.
  97  * It also implies a memory barrier.
  98  */
  99 static inline int test_and_clear_bit(unsigned nr, volatile unsigned long *addr)
 100 {
 101         unsigned long mask = BIT_MASK(nr);
 102         addr += BIT_WORD(nr);
 103         smp_mb();  /* barrier for proper semantics */
 104         return (_atomic_andn(addr, mask) & mask) != 0;
 105 }
 106
 107 /**
 108  * test_and_change_bit - Change a bit and return its old value
 109  * @nr: Bit to change
 110  * @addr: Address to count from
 111  *
 112  * This operation is atomic and cannot be reordered.
 113  * It also implies a memory barrier.
 114  */
 115 static inline int test_and_change_bit(unsigned nr,
 116                                       volatile unsigned long *addr)
 117 {
 118         unsigned long mask = BIT_MASK(nr);
 119         addr += BIT_WORD(nr);
 120         smp_mb();  /* barrier for proper semantics */
 121         return (_atomic_xor(addr, mask) & mask) != 0;
 122 }
 123
 124 #include <asm-generic/bitops/ext2-atomic.h>
 125
 126 #endif /* _ASM_TILE_BITOPS_32_H */