Loading...
1/*
2 * Hardware spinlock framework
3 *
4 * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com
5 *
6 * Contact: Ohad Ben-Cohen <ohad@wizery.com>
7 *
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.
11 *
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.
16 */
17
18#define pr_fmt(fmt) "%s: " fmt, __func__
19
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
30#include "hwspinlock_internal.h"
31
32/* radix tree tags */
33#define HWSPINLOCK_UNUSED (0) /* tags an hwspinlock as unused */
34
35/*
36 * A radix tree is used to maintain the available hwspinlock instances.
37 * The tree associates hwspinlock pointers with their integer key id,
38 * and provides easy-to-use API which makes the hwspinlock core code simple
39 * and easy to read.
40 *
41 * Radix trees are quick on lookups, and reasonably efficient in terms of
42 * storage, especially with high density usages such as this framework
43 * requires (a continuous range of integer keys, beginning with zero, is
44 * used as the ID's of the hwspinlock instances).
45 *
46 * The radix tree API supports tagging items in the tree, which this
47 * framework uses to mark unused hwspinlock instances (see the
48 * HWSPINLOCK_UNUSED tag above). As a result, the process of querying the
49 * tree, looking for an unused hwspinlock instance, is now reduced to a
50 * single radix tree API call.
51 */
52static RADIX_TREE(hwspinlock_tree, GFP_KERNEL);
53
54/*
55 * Synchronization of access to the tree is achieved using this spinlock,
56 * as the radix-tree API requires that users provide all synchronisation.
57 */
58static DEFINE_SPINLOCK(hwspinlock_tree_lock);
59
60/**
61 * __hwspin_trylock() - attempt to lock a specific hwspinlock
62 * @hwlock: an hwspinlock which we want to trylock
63 * @mode: controls whether local interrupts are disabled or not
64 * @flags: a pointer where the caller's interrupt state will be saved at (if
65 * requested)
66 *
67 * This function attempts to lock an hwspinlock, and will immediately
68 * fail if the hwspinlock is already taken.
69 *
70 * Upon a successful return from this function, preemption (and possibly
71 * interrupts) is disabled, so the caller must not sleep, and is advised to
72 * release the hwspinlock as soon as possible. This is required in order to
73 * minimize remote cores polling on the hardware interconnect.
74 *
75 * The user decides whether local interrupts are disabled or not, and if yes,
76 * whether he wants their previous state to be saved. It is up to the user
77 * to choose the appropriate @mode of operation, exactly the same way users
78 * should decide between spin_trylock, spin_trylock_irq and
79 * spin_trylock_irqsave.
80 *
81 * Returns 0 if we successfully locked the hwspinlock or -EBUSY if
82 * the hwspinlock was already taken.
83 * This function will never sleep.
84 */
85int __hwspin_trylock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
86{
87 int ret;
88
89 BUG_ON(!hwlock);
90 BUG_ON(!flags && mode == HWLOCK_IRQSTATE);
91
92 /*
93 * This spin_lock{_irq, _irqsave} serves three purposes:
94 *
95 * 1. Disable preemption, in order to minimize the period of time
96 * in which the hwspinlock is taken. This is important in order
97 * to minimize the possible polling on the hardware interconnect
98 * by a remote user of this lock.
99 * 2. Make the hwspinlock SMP-safe (so we can take it from
100 * additional contexts on the local host).
101 * 3. Ensure that in_atomic/might_sleep checks catch potential
102 * problems with hwspinlock usage (e.g. scheduler checks like
103 * 'scheduling while atomic' etc.)
104 */
105 if (mode == HWLOCK_IRQSTATE)
106 ret = spin_trylock_irqsave(&hwlock->lock, *flags);
107 else if (mode == HWLOCK_IRQ)
108 ret = spin_trylock_irq(&hwlock->lock);
109 else
110 ret = spin_trylock(&hwlock->lock);
111
112 /* is lock already taken by another context on the local cpu ? */
113 if (!ret)
114 return -EBUSY;
115
116 /* try to take the hwspinlock device */
117 ret = hwlock->ops->trylock(hwlock);
118
119 /* if hwlock is already taken, undo spin_trylock_* and exit */
120 if (!ret) {
121 if (mode == HWLOCK_IRQSTATE)
122 spin_unlock_irqrestore(&hwlock->lock, *flags);
123 else if (mode == HWLOCK_IRQ)
124 spin_unlock_irq(&hwlock->lock);
125 else
126 spin_unlock(&hwlock->lock);
127
128 return -EBUSY;
129 }
130
131 /*
132 * We can be sure the other core's memory operations
133 * are observable to us only _after_ we successfully take
134 * the hwspinlock, and we must make sure that subsequent memory
135 * operations (both reads and writes) will not be reordered before
136 * we actually took the hwspinlock.
137 *
138 * Note: the implicit memory barrier of the spinlock above is too
139 * early, so we need this additional explicit memory barrier.
140 */
141 mb();
142
143 return 0;
144}
145EXPORT_SYMBOL_GPL(__hwspin_trylock);
146
147/**
148 * __hwspin_lock_timeout() - lock an hwspinlock with timeout limit
149 * @hwlock: the hwspinlock to be locked
150 * @timeout: timeout value in msecs
151 * @mode: mode which controls whether local interrupts are disabled or not
152 * @flags: a pointer to where the caller's interrupt state will be saved at (if
153 * requested)
154 *
155 * This function locks the given @hwlock. If the @hwlock
156 * is already taken, the function will busy loop waiting for it to
157 * be released, but give up after @timeout msecs have elapsed.
158 *
159 * Upon a successful return from this function, preemption is disabled
160 * (and possibly local interrupts, too), so the caller must not sleep,
161 * and is advised to release the hwspinlock as soon as possible.
162 * This is required in order to minimize remote cores polling on the
163 * hardware interconnect.
164 *
165 * The user decides whether local interrupts are disabled or not, and if yes,
166 * whether he wants their previous state to be saved. It is up to the user
167 * to choose the appropriate @mode of operation, exactly the same way users
168 * should decide between spin_lock, spin_lock_irq and spin_lock_irqsave.
169 *
170 * Returns 0 when the @hwlock was successfully taken, and an appropriate
171 * error code otherwise (most notably -ETIMEDOUT if the @hwlock is still
172 * busy after @timeout msecs). The function will never sleep.
173 */
174int __hwspin_lock_timeout(struct hwspinlock *hwlock, unsigned int to,
175 int mode, unsigned long *flags)
176{
177 int ret;
178 unsigned long expire;
179
180 expire = msecs_to_jiffies(to) + jiffies;
181
182 for (;;) {
183 /* Try to take the hwspinlock */
184 ret = __hwspin_trylock(hwlock, mode, flags);
185 if (ret != -EBUSY)
186 break;
187
188 /*
189 * The lock is already taken, let's check if the user wants
190 * us to try again
191 */
192 if (time_is_before_eq_jiffies(expire))
193 return -ETIMEDOUT;
194
195 /*
196 * Allow platform-specific relax handlers to prevent
197 * hogging the interconnect (no sleeping, though)
198 */
199 if (hwlock->ops->relax)
200 hwlock->ops->relax(hwlock);
201 }
202
203 return ret;
204}
205EXPORT_SYMBOL_GPL(__hwspin_lock_timeout);
206
207/**
208 * __hwspin_unlock() - unlock a specific hwspinlock
209 * @hwlock: a previously-acquired hwspinlock which we want to unlock
210 * @mode: controls whether local interrupts needs to be restored or not
211 * @flags: previous caller's interrupt state to restore (if requested)
212 *
213 * This function will unlock a specific hwspinlock, enable preemption and
214 * (possibly) enable interrupts or restore their previous state.
215 * @hwlock must be already locked before calling this function: it is a bug
216 * to call unlock on a @hwlock that is already unlocked.
217 *
218 * The user decides whether local interrupts should be enabled or not, and
219 * if yes, whether he wants their previous state to be restored. It is up
220 * to the user to choose the appropriate @mode of operation, exactly the
221 * same way users decide between spin_unlock, spin_unlock_irq and
222 * spin_unlock_irqrestore.
223 *
224 * The function will never sleep.
225 */
226void __hwspin_unlock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
227{
228 BUG_ON(!hwlock);
229 BUG_ON(!flags && mode == HWLOCK_IRQSTATE);
230
231 /*
232 * We must make sure that memory operations (both reads and writes),
233 * done before unlocking the hwspinlock, will not be reordered
234 * after the lock is released.
235 *
236 * That's the purpose of this explicit memory barrier.
237 *
238 * Note: the memory barrier induced by the spin_unlock below is too
239 * late; the other core is going to access memory soon after it will
240 * take the hwspinlock, and by then we want to be sure our memory
241 * operations are already observable.
242 */
243 mb();
244
245 hwlock->ops->unlock(hwlock);
246
247 /* Undo the spin_trylock{_irq, _irqsave} called while locking */
248 if (mode == HWLOCK_IRQSTATE)
249 spin_unlock_irqrestore(&hwlock->lock, *flags);
250 else if (mode == HWLOCK_IRQ)
251 spin_unlock_irq(&hwlock->lock);
252 else
253 spin_unlock(&hwlock->lock);
254}
255EXPORT_SYMBOL_GPL(__hwspin_unlock);
256
257/**
258 * hwspin_lock_register() - register a new hw spinlock
259 * @hwlock: hwspinlock to register.
260 *
261 * This function should be called from the underlying platform-specific
262 * implementation, to register a new hwspinlock instance.
263 *
264 * Can be called from an atomic context (will not sleep) but not from
265 * within interrupt context.
266 *
267 * Returns 0 on success, or an appropriate error code on failure
268 */
269int hwspin_lock_register(struct hwspinlock *hwlock)
270{
271 struct hwspinlock *tmp;
272 int ret;
273
274 if (!hwlock || !hwlock->ops ||
275 !hwlock->ops->trylock || !hwlock->ops->unlock) {
276 pr_err("invalid parameters\n");
277 return -EINVAL;
278 }
279
280 spin_lock_init(&hwlock->lock);
281
282 spin_lock(&hwspinlock_tree_lock);
283
284 ret = radix_tree_insert(&hwspinlock_tree, hwlock->id, hwlock);
285 if (ret)
286 goto out;
287
288 /* mark this hwspinlock as available */
289 tmp = radix_tree_tag_set(&hwspinlock_tree, hwlock->id,
290 HWSPINLOCK_UNUSED);
291
292 /* self-sanity check which should never fail */
293 WARN_ON(tmp != hwlock);
294
295out:
296 spin_unlock(&hwspinlock_tree_lock);
297 return ret;
298}
299EXPORT_SYMBOL_GPL(hwspin_lock_register);
300
301/**
302 * hwspin_lock_unregister() - unregister an hw spinlock
303 * @id: index of the specific hwspinlock to unregister
304 *
305 * This function should be called from the underlying platform-specific
306 * implementation, to unregister an existing (and unused) hwspinlock.
307 *
308 * Can be called from an atomic context (will not sleep) but not from
309 * within interrupt context.
310 *
311 * Returns the address of hwspinlock @id on success, or NULL on failure
312 */
313struct hwspinlock *hwspin_lock_unregister(unsigned int id)
314{
315 struct hwspinlock *hwlock = NULL;
316 int ret;
317
318 spin_lock(&hwspinlock_tree_lock);
319
320 /* make sure the hwspinlock is not in use (tag is set) */
321 ret = radix_tree_tag_get(&hwspinlock_tree, id, HWSPINLOCK_UNUSED);
322 if (ret == 0) {
323 pr_err("hwspinlock %d still in use (or not present)\n", id);
324 goto out;
325 }
326
327 hwlock = radix_tree_delete(&hwspinlock_tree, id);
328 if (!hwlock) {
329 pr_err("failed to delete hwspinlock %d\n", id);
330 goto out;
331 }
332
333out:
334 spin_unlock(&hwspinlock_tree_lock);
335 return hwlock;
336}
337EXPORT_SYMBOL_GPL(hwspin_lock_unregister);
338
339/**
340 * __hwspin_lock_request() - tag an hwspinlock as used and power it up
341 *
342 * This is an internal function that prepares an hwspinlock instance
343 * before it is given to the user. The function assumes that
344 * hwspinlock_tree_lock is taken.
345 *
346 * Returns 0 or positive to indicate success, and a negative value to
347 * indicate an error (with the appropriate error code)
348 */
349static int __hwspin_lock_request(struct hwspinlock *hwlock)
350{
351 struct hwspinlock *tmp;
352 int ret;
353
354 /* prevent underlying implementation from being removed */
355 if (!try_module_get(hwlock->owner)) {
356 dev_err(hwlock->dev, "%s: can't get owner\n", __func__);
357 return -EINVAL;
358 }
359
360 /* notify PM core that power is now needed */
361 ret = pm_runtime_get_sync(hwlock->dev);
362 if (ret < 0) {
363 dev_err(hwlock->dev, "%s: can't power on device\n", __func__);
364 return ret;
365 }
366
367 /* mark hwspinlock as used, should not fail */
368 tmp = radix_tree_tag_clear(&hwspinlock_tree, hwlock->id,
369 HWSPINLOCK_UNUSED);
370
371 /* self-sanity check that should never fail */
372 WARN_ON(tmp != hwlock);
373
374 return ret;
375}
376
377/**
378 * hwspin_lock_get_id() - retrieve id number of a given hwspinlock
379 * @hwlock: a valid hwspinlock instance
380 *
381 * Returns the id number of a given @hwlock, or -EINVAL if @hwlock is invalid.
382 */
383int hwspin_lock_get_id(struct hwspinlock *hwlock)
384{
385 if (!hwlock) {
386 pr_err("invalid hwlock\n");
387 return -EINVAL;
388 }
389
390 return hwlock->id;
391}
392EXPORT_SYMBOL_GPL(hwspin_lock_get_id);
393
394/**
395 * hwspin_lock_request() - request an hwspinlock
396 *
397 * This function should be called by users of the hwspinlock device,
398 * in order to dynamically assign them an unused hwspinlock.
399 * Usually the user of this lock will then have to communicate the lock's id
400 * to the remote core before it can be used for synchronization (to get the
401 * id of a given hwlock, use hwspin_lock_get_id()).
402 *
403 * Can be called from an atomic context (will not sleep) but not from
404 * within interrupt context (simply because there is no use case for
405 * that yet).
406 *
407 * Returns the address of the assigned hwspinlock, or NULL on error
408 */
409struct hwspinlock *hwspin_lock_request(void)
410{
411 struct hwspinlock *hwlock;
412 int ret;
413
414 spin_lock(&hwspinlock_tree_lock);
415
416 /* look for an unused lock */
417 ret = radix_tree_gang_lookup_tag(&hwspinlock_tree, (void **)&hwlock,
418 0, 1, HWSPINLOCK_UNUSED);
419 if (ret == 0) {
420 pr_warn("a free hwspinlock is not available\n");
421 hwlock = NULL;
422 goto out;
423 }
424
425 /* sanity check that should never fail */
426 WARN_ON(ret > 1);
427
428 /* mark as used and power up */
429 ret = __hwspin_lock_request(hwlock);
430 if (ret < 0)
431 hwlock = NULL;
432
433out:
434 spin_unlock(&hwspinlock_tree_lock);
435 return hwlock;
436}
437EXPORT_SYMBOL_GPL(hwspin_lock_request);
438
439/**
440 * hwspin_lock_request_specific() - request for a specific hwspinlock
441 * @id: index of the specific hwspinlock that is requested
442 *
443 * This function should be called by users of the hwspinlock module,
444 * in order to assign them a specific hwspinlock.
445 * Usually early board code will be calling this function in order to
446 * reserve specific hwspinlock ids for predefined purposes.
447 *
448 * Can be called from an atomic context (will not sleep) but not from
449 * within interrupt context (simply because there is no use case for
450 * that yet).
451 *
452 * Returns the address of the assigned hwspinlock, or NULL on error
453 */
454struct hwspinlock *hwspin_lock_request_specific(unsigned int id)
455{
456 struct hwspinlock *hwlock;
457 int ret;
458
459 spin_lock(&hwspinlock_tree_lock);
460
461 /* make sure this hwspinlock exists */
462 hwlock = radix_tree_lookup(&hwspinlock_tree, id);
463 if (!hwlock) {
464 pr_warn("hwspinlock %u does not exist\n", id);
465 goto out;
466 }
467
468 /* sanity check (this shouldn't happen) */
469 WARN_ON(hwlock->id != id);
470
471 /* make sure this hwspinlock is unused */
472 ret = radix_tree_tag_get(&hwspinlock_tree, id, HWSPINLOCK_UNUSED);
473 if (ret == 0) {
474 pr_warn("hwspinlock %u is already in use\n", id);
475 hwlock = NULL;
476 goto out;
477 }
478
479 /* mark as used and power up */
480 ret = __hwspin_lock_request(hwlock);
481 if (ret < 0)
482 hwlock = NULL;
483
484out:
485 spin_unlock(&hwspinlock_tree_lock);
486 return hwlock;
487}
488EXPORT_SYMBOL_GPL(hwspin_lock_request_specific);
489
490/**
491 * hwspin_lock_free() - free a specific hwspinlock
492 * @hwlock: the specific hwspinlock to free
493 *
494 * This function mark @hwlock as free again.
495 * Should only be called with an @hwlock that was retrieved from
496 * an earlier call to omap_hwspin_lock_request{_specific}.
497 *
498 * Can be called from an atomic context (will not sleep) but not from
499 * within interrupt context (simply because there is no use case for
500 * that yet).
501 *
502 * Returns 0 on success, or an appropriate error code on failure
503 */
504int hwspin_lock_free(struct hwspinlock *hwlock)
505{
506 struct hwspinlock *tmp;
507 int ret;
508
509 if (!hwlock) {
510 pr_err("invalid hwlock\n");
511 return -EINVAL;
512 }
513
514 spin_lock(&hwspinlock_tree_lock);
515
516 /* make sure the hwspinlock is used */
517 ret = radix_tree_tag_get(&hwspinlock_tree, hwlock->id,
518 HWSPINLOCK_UNUSED);
519 if (ret == 1) {
520 dev_err(hwlock->dev, "%s: hwlock is already free\n", __func__);
521 dump_stack();
522 ret = -EINVAL;
523 goto out;
524 }
525
526 /* notify the underlying device that power is not needed */
527 ret = pm_runtime_put(hwlock->dev);
528 if (ret < 0)
529 goto out;
530
531 /* mark this hwspinlock as available */
532 tmp = radix_tree_tag_set(&hwspinlock_tree, hwlock->id,
533 HWSPINLOCK_UNUSED);
534
535 /* sanity check (this shouldn't happen) */
536 WARN_ON(tmp != hwlock);
537
538 module_put(hwlock->owner);
539
540out:
541 spin_unlock(&hwspinlock_tree_lock);
542 return ret;
543}
544EXPORT_SYMBOL_GPL(hwspin_lock_free);
545
546MODULE_LICENSE("GPL v2");
547MODULE_DESCRIPTION("Hardware spinlock interface");
548MODULE_AUTHOR("Ohad Ben-Cohen <ohad@wizery.com>");
1/*
2 * Hardware spinlock framework
3 *
4 * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com
5 *
6 * Contact: Ohad Ben-Cohen <ohad@wizery.com>
7 *
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.
11 *
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.
16 */
17
18#define pr_fmt(fmt) "%s: " fmt, __func__
19
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>
30
31#include "hwspinlock_internal.h"
32
33/* radix tree tags */
34#define HWSPINLOCK_UNUSED (0) /* tags an hwspinlock as unused */
35
36/*
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
40 * and easy to read.
41 *
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).
46 *
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.
52 */
53static RADIX_TREE(hwspinlock_tree, GFP_KERNEL);
54
55/*
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.
59 */
60static DEFINE_MUTEX(hwspinlock_tree_lock);
61
62
63/**
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
68 * requested)
69 *
70 * This function attempts to lock an hwspinlock, and will immediately
71 * fail if the hwspinlock is already taken.
72 *
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.
77 *
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.
83 *
84 * Returns 0 if we successfully locked the hwspinlock or -EBUSY if
85 * the hwspinlock was already taken.
86 * This function will never sleep.
87 */
88int __hwspin_trylock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
89{
90 int ret;
91
92 BUG_ON(!hwlock);
93 BUG_ON(!flags && mode == HWLOCK_IRQSTATE);
94
95 /*
96 * This spin_lock{_irq, _irqsave} serves three purposes:
97 *
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.)
107 */
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);
112 else
113 ret = spin_trylock(&hwlock->lock);
114
115 /* is lock already taken by another context on the local cpu ? */
116 if (!ret)
117 return -EBUSY;
118
119 /* try to take the hwspinlock device */
120 ret = hwlock->bank->ops->trylock(hwlock);
121
122 /* if hwlock is already taken, undo spin_trylock_* and exit */
123 if (!ret) {
124 if (mode == HWLOCK_IRQSTATE)
125 spin_unlock_irqrestore(&hwlock->lock, *flags);
126 else if (mode == HWLOCK_IRQ)
127 spin_unlock_irq(&hwlock->lock);
128 else
129 spin_unlock(&hwlock->lock);
130
131 return -EBUSY;
132 }
133
134 /*
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.
140 *
141 * Note: the implicit memory barrier of the spinlock above is too
142 * early, so we need this additional explicit memory barrier.
143 */
144 mb();
145
146 return 0;
147}
148EXPORT_SYMBOL_GPL(__hwspin_trylock);
149
150/**
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
156 * requested)
157 *
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.
161 *
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.
167 *
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.
172 *
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.
176 */
177int __hwspin_lock_timeout(struct hwspinlock *hwlock, unsigned int to,
178 int mode, unsigned long *flags)
179{
180 int ret;
181 unsigned long expire;
182
183 expire = msecs_to_jiffies(to) + jiffies;
184
185 for (;;) {
186 /* Try to take the hwspinlock */
187 ret = __hwspin_trylock(hwlock, mode, flags);
188 if (ret != -EBUSY)
189 break;
190
191 /*
192 * The lock is already taken, let's check if the user wants
193 * us to try again
194 */
195 if (time_is_before_eq_jiffies(expire))
196 return -ETIMEDOUT;
197
198 /*
199 * Allow platform-specific relax handlers to prevent
200 * hogging the interconnect (no sleeping, though)
201 */
202 if (hwlock->bank->ops->relax)
203 hwlock->bank->ops->relax(hwlock);
204 }
205
206 return ret;
207}
208EXPORT_SYMBOL_GPL(__hwspin_lock_timeout);
209
210/**
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)
215 *
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.
220 *
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.
226 *
227 * The function will never sleep.
228 */
229void __hwspin_unlock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
230{
231 BUG_ON(!hwlock);
232 BUG_ON(!flags && mode == HWLOCK_IRQSTATE);
233
234 /*
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.
238 *
239 * That's the purpose of this explicit memory barrier.
240 *
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.
245 */
246 mb();
247
248 hwlock->bank->ops->unlock(hwlock);
249
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);
255 else
256 spin_unlock(&hwlock->lock);
257}
258EXPORT_SYMBOL_GPL(__hwspin_unlock);
259
260static int hwspin_lock_register_single(struct hwspinlock *hwlock, int id)
261{
262 struct hwspinlock *tmp;
263 int ret;
264
265 mutex_lock(&hwspinlock_tree_lock);
266
267 ret = radix_tree_insert(&hwspinlock_tree, id, hwlock);
268 if (ret) {
269 if (ret == -EEXIST)
270 pr_err("hwspinlock id %d already exists!\n", id);
271 goto out;
272 }
273
274 /* mark this hwspinlock as available */
275 tmp = radix_tree_tag_set(&hwspinlock_tree, id, HWSPINLOCK_UNUSED);
276
277 /* self-sanity check which should never fail */
278 WARN_ON(tmp != hwlock);
279
280out:
281 mutex_unlock(&hwspinlock_tree_lock);
282 return 0;
283}
284
285static struct hwspinlock *hwspin_lock_unregister_single(unsigned int id)
286{
287 struct hwspinlock *hwlock = NULL;
288 int ret;
289
290 mutex_lock(&hwspinlock_tree_lock);
291
292 /* make sure the hwspinlock is not in use (tag is set) */
293 ret = radix_tree_tag_get(&hwspinlock_tree, id, HWSPINLOCK_UNUSED);
294 if (ret == 0) {
295 pr_err("hwspinlock %d still in use (or not present)\n", id);
296 goto out;
297 }
298
299 hwlock = radix_tree_delete(&hwspinlock_tree, id);
300 if (!hwlock) {
301 pr_err("failed to delete hwspinlock %d\n", id);
302 goto out;
303 }
304
305out:
306 mutex_unlock(&hwspinlock_tree_lock);
307 return hwlock;
308}
309
310/**
311 * hwspin_lock_register() - register a new hw spinlock device
312 * @bank: the hwspinlock device, which usually provides numerous hw locks
313 * @dev: the backing device
314 * @ops: hwspinlock handlers for this device
315 * @base_id: id of the first hardware spinlock in this bank
316 * @num_locks: number of hwspinlocks provided by this device
317 *
318 * This function should be called from the underlying platform-specific
319 * implementation, to register a new hwspinlock device instance.
320 *
321 * Should be called from a process context (might sleep)
322 *
323 * Returns 0 on success, or an appropriate error code on failure
324 */
325int hwspin_lock_register(struct hwspinlock_device *bank, struct device *dev,
326 const struct hwspinlock_ops *ops, int base_id, int num_locks)
327{
328 struct hwspinlock *hwlock;
329 int ret = 0, i;
330
331 if (!bank || !ops || !dev || !num_locks || !ops->trylock ||
332 !ops->unlock) {
333 pr_err("invalid parameters\n");
334 return -EINVAL;
335 }
336
337 bank->dev = dev;
338 bank->ops = ops;
339 bank->base_id = base_id;
340 bank->num_locks = num_locks;
341
342 for (i = 0; i < num_locks; i++) {
343 hwlock = &bank->lock[i];
344
345 spin_lock_init(&hwlock->lock);
346 hwlock->bank = bank;
347
348 ret = hwspin_lock_register_single(hwlock, base_id + i);
349 if (ret)
350 goto reg_failed;
351 }
352
353 return 0;
354
355reg_failed:
356 while (--i >= 0)
357 hwspin_lock_unregister_single(base_id + i);
358 return ret;
359}
360EXPORT_SYMBOL_GPL(hwspin_lock_register);
361
362/**
363 * hwspin_lock_unregister() - unregister an hw spinlock device
364 * @bank: the hwspinlock device, which usually provides numerous hw locks
365 *
366 * This function should be called from the underlying platform-specific
367 * implementation, to unregister an existing (and unused) hwspinlock.
368 *
369 * Should be called from a process context (might sleep)
370 *
371 * Returns 0 on success, or an appropriate error code on failure
372 */
373int hwspin_lock_unregister(struct hwspinlock_device *bank)
374{
375 struct hwspinlock *hwlock, *tmp;
376 int i;
377
378 for (i = 0; i < bank->num_locks; i++) {
379 hwlock = &bank->lock[i];
380
381 tmp = hwspin_lock_unregister_single(bank->base_id + i);
382 if (!tmp)
383 return -EBUSY;
384
385 /* self-sanity check that should never fail */
386 WARN_ON(tmp != hwlock);
387 }
388
389 return 0;
390}
391EXPORT_SYMBOL_GPL(hwspin_lock_unregister);
392
393/**
394 * __hwspin_lock_request() - tag an hwspinlock as used and power it up
395 *
396 * This is an internal function that prepares an hwspinlock instance
397 * before it is given to the user. The function assumes that
398 * hwspinlock_tree_lock is taken.
399 *
400 * Returns 0 or positive to indicate success, and a negative value to
401 * indicate an error (with the appropriate error code)
402 */
403static int __hwspin_lock_request(struct hwspinlock *hwlock)
404{
405 struct device *dev = hwlock->bank->dev;
406 struct hwspinlock *tmp;
407 int ret;
408
409 /* prevent underlying implementation from being removed */
410 if (!try_module_get(dev->driver->owner)) {
411 dev_err(dev, "%s: can't get owner\n", __func__);
412 return -EINVAL;
413 }
414
415 /* notify PM core that power is now needed */
416 ret = pm_runtime_get_sync(dev);
417 if (ret < 0) {
418 dev_err(dev, "%s: can't power on device\n", __func__);
419 return ret;
420 }
421
422 /* mark hwspinlock as used, should not fail */
423 tmp = radix_tree_tag_clear(&hwspinlock_tree, hwlock_to_id(hwlock),
424 HWSPINLOCK_UNUSED);
425
426 /* self-sanity check that should never fail */
427 WARN_ON(tmp != hwlock);
428
429 return ret;
430}
431
432/**
433 * hwspin_lock_get_id() - retrieve id number of a given hwspinlock
434 * @hwlock: a valid hwspinlock instance
435 *
436 * Returns the id number of a given @hwlock, or -EINVAL if @hwlock is invalid.
437 */
438int hwspin_lock_get_id(struct hwspinlock *hwlock)
439{
440 if (!hwlock) {
441 pr_err("invalid hwlock\n");
442 return -EINVAL;
443 }
444
445 return hwlock_to_id(hwlock);
446}
447EXPORT_SYMBOL_GPL(hwspin_lock_get_id);
448
449/**
450 * hwspin_lock_request() - request an hwspinlock
451 *
452 * This function should be called by users of the hwspinlock device,
453 * in order to dynamically assign them an unused hwspinlock.
454 * Usually the user of this lock will then have to communicate the lock's id
455 * to the remote core before it can be used for synchronization (to get the
456 * id of a given hwlock, use hwspin_lock_get_id()).
457 *
458 * Should be called from a process context (might sleep)
459 *
460 * Returns the address of the assigned hwspinlock, or NULL on error
461 */
462struct hwspinlock *hwspin_lock_request(void)
463{
464 struct hwspinlock *hwlock;
465 int ret;
466
467 mutex_lock(&hwspinlock_tree_lock);
468
469 /* look for an unused lock */
470 ret = radix_tree_gang_lookup_tag(&hwspinlock_tree, (void **)&hwlock,
471 0, 1, HWSPINLOCK_UNUSED);
472 if (ret == 0) {
473 pr_warn("a free hwspinlock is not available\n");
474 hwlock = NULL;
475 goto out;
476 }
477
478 /* sanity check that should never fail */
479 WARN_ON(ret > 1);
480
481 /* mark as used and power up */
482 ret = __hwspin_lock_request(hwlock);
483 if (ret < 0)
484 hwlock = NULL;
485
486out:
487 mutex_unlock(&hwspinlock_tree_lock);
488 return hwlock;
489}
490EXPORT_SYMBOL_GPL(hwspin_lock_request);
491
492/**
493 * hwspin_lock_request_specific() - request for a specific hwspinlock
494 * @id: index of the specific hwspinlock that is requested
495 *
496 * This function should be called by users of the hwspinlock module,
497 * in order to assign them a specific hwspinlock.
498 * Usually early board code will be calling this function in order to
499 * reserve specific hwspinlock ids for predefined purposes.
500 *
501 * Should be called from a process context (might sleep)
502 *
503 * Returns the address of the assigned hwspinlock, or NULL on error
504 */
505struct hwspinlock *hwspin_lock_request_specific(unsigned int id)
506{
507 struct hwspinlock *hwlock;
508 int ret;
509
510 mutex_lock(&hwspinlock_tree_lock);
511
512 /* make sure this hwspinlock exists */
513 hwlock = radix_tree_lookup(&hwspinlock_tree, id);
514 if (!hwlock) {
515 pr_warn("hwspinlock %u does not exist\n", id);
516 goto out;
517 }
518
519 /* sanity check (this shouldn't happen) */
520 WARN_ON(hwlock_to_id(hwlock) != id);
521
522 /* make sure this hwspinlock is unused */
523 ret = radix_tree_tag_get(&hwspinlock_tree, id, HWSPINLOCK_UNUSED);
524 if (ret == 0) {
525 pr_warn("hwspinlock %u is already in use\n", id);
526 hwlock = NULL;
527 goto out;
528 }
529
530 /* mark as used and power up */
531 ret = __hwspin_lock_request(hwlock);
532 if (ret < 0)
533 hwlock = NULL;
534
535out:
536 mutex_unlock(&hwspinlock_tree_lock);
537 return hwlock;
538}
539EXPORT_SYMBOL_GPL(hwspin_lock_request_specific);
540
541/**
542 * hwspin_lock_free() - free a specific hwspinlock
543 * @hwlock: the specific hwspinlock to free
544 *
545 * This function mark @hwlock as free again.
546 * Should only be called with an @hwlock that was retrieved from
547 * an earlier call to omap_hwspin_lock_request{_specific}.
548 *
549 * Should be called from a process context (might sleep)
550 *
551 * Returns 0 on success, or an appropriate error code on failure
552 */
553int hwspin_lock_free(struct hwspinlock *hwlock)
554{
555 struct device *dev = hwlock->bank->dev;
556 struct hwspinlock *tmp;
557 int ret;
558
559 if (!hwlock) {
560 pr_err("invalid hwlock\n");
561 return -EINVAL;
562 }
563
564 mutex_lock(&hwspinlock_tree_lock);
565
566 /* make sure the hwspinlock is used */
567 ret = radix_tree_tag_get(&hwspinlock_tree, hwlock_to_id(hwlock),
568 HWSPINLOCK_UNUSED);
569 if (ret == 1) {
570 dev_err(dev, "%s: hwlock is already free\n", __func__);
571 dump_stack();
572 ret = -EINVAL;
573 goto out;
574 }
575
576 /* notify the underlying device that power is not needed */
577 ret = pm_runtime_put(dev);
578 if (ret < 0)
579 goto out;
580
581 /* mark this hwspinlock as available */
582 tmp = radix_tree_tag_set(&hwspinlock_tree, hwlock_to_id(hwlock),
583 HWSPINLOCK_UNUSED);
584
585 /* sanity check (this shouldn't happen) */
586 WARN_ON(tmp != hwlock);
587
588 module_put(dev->driver->owner);
589
590out:
591 mutex_unlock(&hwspinlock_tree_lock);
592 return ret;
593}
594EXPORT_SYMBOL_GPL(hwspin_lock_free);
595
596MODULE_LICENSE("GPL v2");
597MODULE_DESCRIPTION("Hardware spinlock interface");
598MODULE_AUTHOR("Ohad Ben-Cohen <ohad@wizery.com>");