2 * Hardware spinlock framework
4 * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com
6 * Contact: Ohad Ben-Cohen <ohad@wizery.com>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 as published
10 * by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
18 #define pr_fmt(fmt) "%s: " fmt, __func__
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/spinlock.h>
23 #include <linux/types.h>
24 #include <linux/err.h>
25 #include <linux/jiffies.h>
26 #include <linux/radix-tree.h>
27 #include <linux/hwspinlock.h>
28 #include <linux/pm_runtime.h>
29 #include <linux/mutex.h>
31 #include "hwspinlock_internal.h"
34 #define HWSPINLOCK_UNUSED (0) /* tags an hwspinlock as unused */
37 * A radix tree is used to maintain the available hwspinlock instances.
38 * The tree associates hwspinlock pointers with their integer key id,
39 * and provides easy-to-use API which makes the hwspinlock core code simple
42 * Radix trees are quick on lookups, and reasonably efficient in terms of
43 * storage, especially with high density usages such as this framework
44 * requires (a continuous range of integer keys, beginning with zero, is
45 * used as the ID's of the hwspinlock instances).
47 * The radix tree API supports tagging items in the tree, which this
48 * framework uses to mark unused hwspinlock instances (see the
49 * HWSPINLOCK_UNUSED tag above). As a result, the process of querying the
50 * tree, looking for an unused hwspinlock instance, is now reduced to a
51 * single radix tree API call.
53 static RADIX_TREE(hwspinlock_tree, GFP_KERNEL);
56 * Synchronization of access to the tree is achieved using this mutex,
57 * as the radix-tree API requires that users provide all synchronisation.
58 * A mutex is needed because we're using non-atomic radix tree allocations.
60 static DEFINE_MUTEX(hwspinlock_tree_lock);
64 * __hwspin_trylock() - attempt to lock a specific hwspinlock
65 * @hwlock: an hwspinlock which we want to trylock
66 * @mode: controls whether local interrupts are disabled or not
67 * @flags: a pointer where the caller's interrupt state will be saved at (if
70 * This function attempts to lock an hwspinlock, and will immediately
71 * fail if the hwspinlock is already taken.
73 * Upon a successful return from this function, preemption (and possibly
74 * interrupts) is disabled, so the caller must not sleep, and is advised to
75 * release the hwspinlock as soon as possible. This is required in order to
76 * minimize remote cores polling on the hardware interconnect.
78 * The user decides whether local interrupts are disabled or not, and if yes,
79 * whether he wants their previous state to be saved. It is up to the user
80 * to choose the appropriate @mode of operation, exactly the same way users
81 * should decide between spin_trylock, spin_trylock_irq and
82 * spin_trylock_irqsave.
84 * Returns 0 if we successfully locked the hwspinlock or -EBUSY if
85 * the hwspinlock was already taken.
86 * This function will never sleep.
88 int __hwspin_trylock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
93 BUG_ON(!flags && mode == HWLOCK_IRQSTATE);
96 * This spin_lock{_irq, _irqsave} serves three purposes:
98 * 1. Disable preemption, in order to minimize the period of time
99 * in which the hwspinlock is taken. This is important in order
100 * to minimize the possible polling on the hardware interconnect
101 * by a remote user of this lock.
102 * 2. Make the hwspinlock SMP-safe (so we can take it from
103 * additional contexts on the local host).
104 * 3. Ensure that in_atomic/might_sleep checks catch potential
105 * problems with hwspinlock usage (e.g. scheduler checks like
106 * 'scheduling while atomic' etc.)
108 if (mode == HWLOCK_IRQSTATE)
109 ret = spin_trylock_irqsave(&hwlock->lock, *flags);
110 else if (mode == HWLOCK_IRQ)
111 ret = spin_trylock_irq(&hwlock->lock);
113 ret = spin_trylock(&hwlock->lock);
115 /* is lock already taken by another context on the local cpu ? */
119 /* try to take the hwspinlock device */
120 ret = hwlock->ops->trylock(hwlock);
122 /* if hwlock is already taken, undo spin_trylock_* and exit */
124 if (mode == HWLOCK_IRQSTATE)
125 spin_unlock_irqrestore(&hwlock->lock, *flags);
126 else if (mode == HWLOCK_IRQ)
127 spin_unlock_irq(&hwlock->lock);
129 spin_unlock(&hwlock->lock);
135 * We can be sure the other core's memory operations
136 * are observable to us only _after_ we successfully take
137 * the hwspinlock, and we must make sure that subsequent memory
138 * operations (both reads and writes) will not be reordered before
139 * we actually took the hwspinlock.
141 * Note: the implicit memory barrier of the spinlock above is too
142 * early, so we need this additional explicit memory barrier.
148 EXPORT_SYMBOL_GPL(__hwspin_trylock);
151 * __hwspin_lock_timeout() - lock an hwspinlock with timeout limit
152 * @hwlock: the hwspinlock to be locked
153 * @timeout: timeout value in msecs
154 * @mode: mode which controls whether local interrupts are disabled or not
155 * @flags: a pointer to where the caller's interrupt state will be saved at (if
158 * This function locks the given @hwlock. If the @hwlock
159 * is already taken, the function will busy loop waiting for it to
160 * be released, but give up after @timeout msecs have elapsed.
162 * Upon a successful return from this function, preemption is disabled
163 * (and possibly local interrupts, too), so the caller must not sleep,
164 * and is advised to release the hwspinlock as soon as possible.
165 * This is required in order to minimize remote cores polling on the
166 * hardware interconnect.
168 * The user decides whether local interrupts are disabled or not, and if yes,
169 * whether he wants their previous state to be saved. It is up to the user
170 * to choose the appropriate @mode of operation, exactly the same way users
171 * should decide between spin_lock, spin_lock_irq and spin_lock_irqsave.
173 * Returns 0 when the @hwlock was successfully taken, and an appropriate
174 * error code otherwise (most notably -ETIMEDOUT if the @hwlock is still
175 * busy after @timeout msecs). The function will never sleep.
177 int __hwspin_lock_timeout(struct hwspinlock *hwlock, unsigned int to,
178 int mode, unsigned long *flags)
181 unsigned long expire;
183 expire = msecs_to_jiffies(to) + jiffies;
186 /* Try to take the hwspinlock */
187 ret = __hwspin_trylock(hwlock, mode, flags);
192 * The lock is already taken, let's check if the user wants
195 if (time_is_before_eq_jiffies(expire))
199 * Allow platform-specific relax handlers to prevent
200 * hogging the interconnect (no sleeping, though)
202 if (hwlock->ops->relax)
203 hwlock->ops->relax(hwlock);
208 EXPORT_SYMBOL_GPL(__hwspin_lock_timeout);
211 * __hwspin_unlock() - unlock a specific hwspinlock
212 * @hwlock: a previously-acquired hwspinlock which we want to unlock
213 * @mode: controls whether local interrupts needs to be restored or not
214 * @flags: previous caller's interrupt state to restore (if requested)
216 * This function will unlock a specific hwspinlock, enable preemption and
217 * (possibly) enable interrupts or restore their previous state.
218 * @hwlock must be already locked before calling this function: it is a bug
219 * to call unlock on a @hwlock that is already unlocked.
221 * The user decides whether local interrupts should be enabled or not, and
222 * if yes, whether he wants their previous state to be restored. It is up
223 * to the user to choose the appropriate @mode of operation, exactly the
224 * same way users decide between spin_unlock, spin_unlock_irq and
225 * spin_unlock_irqrestore.
227 * The function will never sleep.
229 void __hwspin_unlock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
232 BUG_ON(!flags && mode == HWLOCK_IRQSTATE);
235 * We must make sure that memory operations (both reads and writes),
236 * done before unlocking the hwspinlock, will not be reordered
237 * after the lock is released.
239 * That's the purpose of this explicit memory barrier.
241 * Note: the memory barrier induced by the spin_unlock below is too
242 * late; the other core is going to access memory soon after it will
243 * take the hwspinlock, and by then we want to be sure our memory
244 * operations are already observable.
248 hwlock->ops->unlock(hwlock);
250 /* Undo the spin_trylock{_irq, _irqsave} called while locking */
251 if (mode == HWLOCK_IRQSTATE)
252 spin_unlock_irqrestore(&hwlock->lock, *flags);
253 else if (mode == HWLOCK_IRQ)
254 spin_unlock_irq(&hwlock->lock);
256 spin_unlock(&hwlock->lock);
258 EXPORT_SYMBOL_GPL(__hwspin_unlock);
261 * hwspin_lock_register() - register a new hw spinlock
262 * @hwlock: hwspinlock to register.
264 * This function should be called from the underlying platform-specific
265 * implementation, to register a new hwspinlock instance.
267 * Should be called from a process context (might sleep)
269 * Returns 0 on success, or an appropriate error code on failure
271 int hwspin_lock_register(struct hwspinlock *hwlock)
273 struct hwspinlock *tmp;
276 if (!hwlock || !hwlock->ops ||
277 !hwlock->ops->trylock || !hwlock->ops->unlock) {
278 pr_err("invalid parameters\n");
282 spin_lock_init(&hwlock->lock);
284 mutex_lock(&hwspinlock_tree_lock);
286 ret = radix_tree_insert(&hwspinlock_tree, hwlock->id, hwlock);
290 /* mark this hwspinlock as available */
291 tmp = radix_tree_tag_set(&hwspinlock_tree, hwlock->id,
294 /* self-sanity check which should never fail */
295 WARN_ON(tmp != hwlock);
298 mutex_unlock(&hwspinlock_tree_lock);
301 EXPORT_SYMBOL_GPL(hwspin_lock_register);
304 * hwspin_lock_unregister() - unregister an hw spinlock
305 * @id: index of the specific hwspinlock to unregister
307 * This function should be called from the underlying platform-specific
308 * implementation, to unregister an existing (and unused) hwspinlock.
310 * Should be called from a process context (might sleep)
312 * Returns the address of hwspinlock @id on success, or NULL on failure
314 struct hwspinlock *hwspin_lock_unregister(unsigned int id)
316 struct hwspinlock *hwlock = NULL;
319 mutex_lock(&hwspinlock_tree_lock);
321 /* make sure the hwspinlock is not in use (tag is set) */
322 ret = radix_tree_tag_get(&hwspinlock_tree, id, HWSPINLOCK_UNUSED);
324 pr_err("hwspinlock %d still in use (or not present)\n", id);
328 hwlock = radix_tree_delete(&hwspinlock_tree, id);
330 pr_err("failed to delete hwspinlock %d\n", id);
335 mutex_unlock(&hwspinlock_tree_lock);
338 EXPORT_SYMBOL_GPL(hwspin_lock_unregister);
341 * __hwspin_lock_request() - tag an hwspinlock as used and power it up
343 * This is an internal function that prepares an hwspinlock instance
344 * before it is given to the user. The function assumes that
345 * hwspinlock_tree_lock is taken.
347 * Returns 0 or positive to indicate success, and a negative value to
348 * indicate an error (with the appropriate error code)
350 static int __hwspin_lock_request(struct hwspinlock *hwlock)
352 struct hwspinlock *tmp;
355 /* prevent underlying implementation from being removed */
356 if (!try_module_get(hwlock->owner)) {
357 dev_err(hwlock->dev, "%s: can't get owner\n", __func__);
361 /* notify PM core that power is now needed */
362 ret = pm_runtime_get_sync(hwlock->dev);
364 dev_err(hwlock->dev, "%s: can't power on device\n", __func__);
368 /* mark hwspinlock as used, should not fail */
369 tmp = radix_tree_tag_clear(&hwspinlock_tree, hwlock->id,
372 /* self-sanity check that should never fail */
373 WARN_ON(tmp != hwlock);
379 * hwspin_lock_get_id() - retrieve id number of a given hwspinlock
380 * @hwlock: a valid hwspinlock instance
382 * Returns the id number of a given @hwlock, or -EINVAL if @hwlock is invalid.
384 int hwspin_lock_get_id(struct hwspinlock *hwlock)
387 pr_err("invalid hwlock\n");
393 EXPORT_SYMBOL_GPL(hwspin_lock_get_id);
396 * hwspin_lock_request() - request an hwspinlock
398 * This function should be called by users of the hwspinlock device,
399 * in order to dynamically assign them an unused hwspinlock.
400 * Usually the user of this lock will then have to communicate the lock's id
401 * to the remote core before it can be used for synchronization (to get the
402 * id of a given hwlock, use hwspin_lock_get_id()).
404 * Should be called from a process context (might sleep)
406 * Returns the address of the assigned hwspinlock, or NULL on error
408 struct hwspinlock *hwspin_lock_request(void)
410 struct hwspinlock *hwlock;
413 mutex_lock(&hwspinlock_tree_lock);
415 /* look for an unused lock */
416 ret = radix_tree_gang_lookup_tag(&hwspinlock_tree, (void **)&hwlock,
417 0, 1, HWSPINLOCK_UNUSED);
419 pr_warn("a free hwspinlock is not available\n");
424 /* sanity check that should never fail */
427 /* mark as used and power up */
428 ret = __hwspin_lock_request(hwlock);
433 mutex_unlock(&hwspinlock_tree_lock);
436 EXPORT_SYMBOL_GPL(hwspin_lock_request);
439 * hwspin_lock_request_specific() - request for a specific hwspinlock
440 * @id: index of the specific hwspinlock that is requested
442 * This function should be called by users of the hwspinlock module,
443 * in order to assign them a specific hwspinlock.
444 * Usually early board code will be calling this function in order to
445 * reserve specific hwspinlock ids for predefined purposes.
447 * Should be called from a process context (might sleep)
449 * Returns the address of the assigned hwspinlock, or NULL on error
451 struct hwspinlock *hwspin_lock_request_specific(unsigned int id)
453 struct hwspinlock *hwlock;
456 mutex_lock(&hwspinlock_tree_lock);
458 /* make sure this hwspinlock exists */
459 hwlock = radix_tree_lookup(&hwspinlock_tree, id);
461 pr_warn("hwspinlock %u does not exist\n", id);
465 /* sanity check (this shouldn't happen) */
466 WARN_ON(hwlock->id != id);
468 /* make sure this hwspinlock is unused */
469 ret = radix_tree_tag_get(&hwspinlock_tree, id, HWSPINLOCK_UNUSED);
471 pr_warn("hwspinlock %u is already in use\n", id);
476 /* mark as used and power up */
477 ret = __hwspin_lock_request(hwlock);
482 mutex_unlock(&hwspinlock_tree_lock);
485 EXPORT_SYMBOL_GPL(hwspin_lock_request_specific);
488 * hwspin_lock_free() - free a specific hwspinlock
489 * @hwlock: the specific hwspinlock to free
491 * This function mark @hwlock as free again.
492 * Should only be called with an @hwlock that was retrieved from
493 * an earlier call to omap_hwspin_lock_request{_specific}.
495 * Should be called from a process context (might sleep)
497 * Returns 0 on success, or an appropriate error code on failure
499 int hwspin_lock_free(struct hwspinlock *hwlock)
501 struct hwspinlock *tmp;
505 pr_err("invalid hwlock\n");
509 mutex_lock(&hwspinlock_tree_lock);
511 /* make sure the hwspinlock is used */
512 ret = radix_tree_tag_get(&hwspinlock_tree, hwlock->id,
515 dev_err(hwlock->dev, "%s: hwlock is already free\n", __func__);
521 /* notify the underlying device that power is not needed */
522 ret = pm_runtime_put(hwlock->dev);
526 /* mark this hwspinlock as available */
527 tmp = radix_tree_tag_set(&hwspinlock_tree, hwlock->id,
530 /* sanity check (this shouldn't happen) */
531 WARN_ON(tmp != hwlock);
533 module_put(hwlock->owner);
536 mutex_unlock(&hwspinlock_tree_lock);
539 EXPORT_SYMBOL_GPL(hwspin_lock_free);
541 MODULE_LICENSE("GPL v2");
542 MODULE_DESCRIPTION("Hardware spinlock interface");
543 MODULE_AUTHOR("Ohad Ben-Cohen <ohad@wizery.com>");