1/*
  2 * Queue read/write lock
  3 *
  4 * This program is free software; you can redistribute it and/or modify
  5 * it under the terms of the GNU General Public License as published by
  6 * the Free Software Foundation; either version 2 of the License, or
  7 * (at your option) any later version.
  8 *
  9 * This program is distributed in the hope that it will be useful,
 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 * GNU General Public License for more details.
 13 *
 14 * (C) Copyright 2013-2014 Hewlett-Packard Development Company, L.P.
 15 *
 16 * Authors: Waiman Long <waiman.long@hp.com>
 17 */
 18#ifndef __ASM_GENERIC_QRWLOCK_H
 19#define __ASM_GENERIC_QRWLOCK_H
 20
 21#include <linux/atomic.h>
 22#include <asm/barrier.h>
 23#include <asm/processor.h>
 24
 25#include <asm-generic/qrwlock_types.h>
 26
 27/*
 28 * Writer states & reader shift and bias.
 29 *
 30 *       | +0 | +1 | +2 | +3 |
 31 *   ----+----+----+----+----+
 32 *    LE | 78 | 56 | 34 | 12 | 0x12345678
 33 *   ----+----+----+----+----+
 34 *       | wr |      rd      |
 35 *       +----+----+----+----+
 36 *
 37 *   ----+----+----+----+----+
 38 *    BE | 12 | 34 | 56 | 78 | 0x12345678
 39 *   ----+----+----+----+----+
 40 *       |      rd      | wr |
 41 *       +----+----+----+----+
 42 */
 43#define	_QW_WAITING	1		/* A writer is waiting	   */
 44#define	_QW_LOCKED	0xff		/* A writer holds the lock */
 45#define	_QW_WMASK	0xff		/* Writer mask		   */
 46#define	_QR_SHIFT	8		/* Reader count shift	   */
 47#define _QR_BIAS	(1U << _QR_SHIFT)
 48
 49/*
 50 * External function declarations
 51 */
 52extern void queued_read_lock_slowpath(struct qrwlock *lock, u32 cnts);
 53extern void queued_write_lock_slowpath(struct qrwlock *lock);
 54
 55/**
 56 * queued_read_can_lock- would read_trylock() succeed?
 57 * @lock: Pointer to queue rwlock structure
 58 */
 59static inline int queued_read_can_lock(struct qrwlock *lock)
 60{
 61	return !(atomic_read(&lock->cnts) & _QW_WMASK);
 62}
 63
 64/**
 65 * queued_write_can_lock- would write_trylock() succeed?
 66 * @lock: Pointer to queue rwlock structure
 67 */
 68static inline int queued_write_can_lock(struct qrwlock *lock)
 69{
 70	return !atomic_read(&lock->cnts);
 71}
 72
 73/**
 74 * queued_read_trylock - try to acquire read lock of a queue rwlock
 75 * @lock : Pointer to queue rwlock structure
 76 * Return: 1 if lock acquired, 0 if failed
 77 */
 78static inline int queued_read_trylock(struct qrwlock *lock)
 79{
 80	u32 cnts;
 81
 82	cnts = atomic_read(&lock->cnts);
 83	if (likely(!(cnts & _QW_WMASK))) {
 84		cnts = (u32)atomic_add_return_acquire(_QR_BIAS, &lock->cnts);
 85		if (likely(!(cnts & _QW_WMASK)))
 86			return 1;
 87		atomic_sub(_QR_BIAS, &lock->cnts);
 88	}
 89	return 0;
 90}
 91
 92/**
 93 * queued_write_trylock - try to acquire write lock of a queue rwlock
 94 * @lock : Pointer to queue rwlock structure
 95 * Return: 1 if lock acquired, 0 if failed
 96 */
 97static inline int queued_write_trylock(struct qrwlock *lock)
 98{
 99	u32 cnts;
100
101	cnts = atomic_read(&lock->cnts);
102	if (unlikely(cnts))
103		return 0;
104
105	return likely(atomic_cmpxchg_acquire(&lock->cnts,
106					     cnts, cnts | _QW_LOCKED) == cnts);
107}
108/**
109 * queued_read_lock - acquire read lock of a queue rwlock
110 * @lock: Pointer to queue rwlock structure
111 */
112static inline void queued_read_lock(struct qrwlock *lock)
113{
114	u32 cnts;
115
116	cnts = atomic_add_return_acquire(_QR_BIAS, &lock->cnts);
117	if (likely(!(cnts & _QW_WMASK)))
118		return;
119
120	/* The slowpath will decrement the reader count, if necessary. */
121	queued_read_lock_slowpath(lock, cnts);
122}
123
124/**
125 * queued_write_lock - acquire write lock of a queue rwlock
126 * @lock : Pointer to queue rwlock structure
127 */
128static inline void queued_write_lock(struct qrwlock *lock)
129{
130	/* Optimize for the unfair lock case where the fair flag is 0. */
131	if (atomic_cmpxchg_acquire(&lock->cnts, 0, _QW_LOCKED) == 0)
132		return;
133
134	queued_write_lock_slowpath(lock);
135}
136
137/**
138 * queued_read_unlock - release read lock of a queue rwlock
139 * @lock : Pointer to queue rwlock structure
140 */
141static inline void queued_read_unlock(struct qrwlock *lock)
142{
143	/*
144	 * Atomically decrement the reader count
145	 */
146	(void)atomic_sub_return_release(_QR_BIAS, &lock->cnts);
147}
148
149/**
150 * __qrwlock_write_byte - retrieve the write byte address of a queue rwlock
151 * @lock : Pointer to queue rwlock structure
152 * Return: the write byte address of a queue rwlock
153 */
154static inline u8 *__qrwlock_write_byte(struct qrwlock *lock)
155{
156	return (u8 *)lock + 3 * IS_BUILTIN(CONFIG_CPU_BIG_ENDIAN);
157}
158
159/**
160 * queued_write_unlock - release write lock of a queue rwlock
161 * @lock : Pointer to queue rwlock structure
162 */
163static inline void queued_write_unlock(struct qrwlock *lock)
164{
165	smp_store_release(__qrwlock_write_byte(lock), 0);
166}
167
168/*
169 * Remapping rwlock architecture specific functions to the corresponding
170 * queue rwlock functions.
171 */
172#define arch_read_can_lock(l)	queued_read_can_lock(l)
173#define arch_write_can_lock(l)	queued_write_can_lock(l)
174#define arch_read_lock(l)	queued_read_lock(l)
175#define arch_write_lock(l)	queued_write_lock(l)
176#define arch_read_trylock(l)	queued_read_trylock(l)
177#define arch_write_trylock(l)	queued_write_trylock(l)
178#define arch_read_unlock(l)	queued_read_unlock(l)
179#define arch_write_unlock(l)	queued_write_unlock(l)
180
181#endif /* __ASM_GENERIC_QRWLOCK_H */