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