1#ifndef _ASM_GENERIC_BITOPS_LOCK_H_
 2#define _ASM_GENERIC_BITOPS_LOCK_H_
 3
 4/**
 5 * test_and_set_bit_lock - Set a bit and return its old value, for lock
 6 * @nr: Bit to set
 7 * @addr: Address to count from
 8 *
 9 * This operation is atomic and provides acquire barrier semantics.
 
10 * It can be used to implement bit locks.
11 */
12#define test_and_set_bit_lock(nr, addr)	test_and_set_bit(nr, addr)
13
14/**
15 * clear_bit_unlock - Clear a bit in memory, for unlock
16 * @nr: the bit to set
17 * @addr: the address to start counting from
18 *
19 * This operation is atomic and provides release barrier semantics.
20 */
21#define clear_bit_unlock(nr, addr)	\
22do {					\
23	smp_mb__before_clear_bit();	\
24	clear_bit(nr, addr);		\
25} while (0)
26
27/**
28 * __clear_bit_unlock - Clear a bit in memory, for unlock
29 * @nr: the bit to set
30 * @addr: the address to start counting from
31 *
32 * This operation is like clear_bit_unlock, however it is not atomic.
33 * It does provide release barrier semantics so it can be used to unlock
34 * a bit lock, however it would only be used if no other CPU can modify
35 * any bits in the memory until the lock is released (a good example is
36 * if the bit lock itself protects access to the other bits in the word).
37 */
38#define __clear_bit_unlock(nr, addr)	\
39do {					\
40	smp_mb();			\
41	__clear_bit(nr, addr);		\
42} while (0)
43
44#endif /* _ASM_GENERIC_BITOPS_LOCK_H_ */
45

 1/* SPDX-License-Identifier: GPL-2.0 */
 2#ifndef _ASM_GENERIC_BITOPS_LOCK_H_
 3#define _ASM_GENERIC_BITOPS_LOCK_H_
 4
 5/**
 6 * test_and_set_bit_lock - Set a bit and return its old value, for lock
 7 * @nr: Bit to set
 8 * @addr: Address to count from
 9 *
10 * This operation is atomic and provides acquire barrier semantics if
11 * the returned value is 0.
12 * It can be used to implement bit locks.
13 */
14#define test_and_set_bit_lock(nr, addr)	test_and_set_bit(nr, addr)
15
16/**
17 * clear_bit_unlock - Clear a bit in memory, for unlock
18 * @nr: the bit to set
19 * @addr: the address to start counting from
20 *
21 * This operation is atomic and provides release barrier semantics.
22 */
23#define clear_bit_unlock(nr, addr)	\
24do {					\
25	smp_mb__before_atomic();	\
26	clear_bit(nr, addr);		\
27} while (0)
28
29/**
30 * __clear_bit_unlock - Clear a bit in memory, for unlock
31 * @nr: the bit to set
32 * @addr: the address to start counting from
33 *
34 * A weaker form of clear_bit_unlock() as used by __bit_lock_unlock(). If all
35 * the bits in the word are protected by this lock some archs can use weaker
36 * ops to safely unlock.
37 *
38 * See for example x86's implementation.
39 */
40#define __clear_bit_unlock(nr, addr)	\
41do {					\
42	smp_mb__before_atomic();	\
43	clear_bit(nr, addr);		\
44} while (0)
45
46#endif /* _ASM_GENERIC_BITOPS_LOCK_H_ */
47