Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/Documentation/hwspinlock.txt

  1 Hardware Spinlock Framework
  2 
  3 1. Introduction
  4 
  5 Hardware spinlock modules provide hardware assistance for synchronization
  6 and mutual exclusion between heterogeneous processors and those not operating
  7 under a single, shared operating system.
  8 
  9 For example, OMAP4 has dual Cortex-A9, dual Cortex-M3 and a C64x+ DSP,
 10 each of which is running a different Operating System (the master, A9,
 11 is usually running Linux and the slave processors, the M3 and the DSP,
 12 are running some flavor of RTOS).
 13 
 14 A generic hwspinlock framework allows platform-independent drivers to use
 15 the hwspinlock device in order to access data structures that are shared
 16 between remote processors, that otherwise have no alternative mechanism
 17 to accomplish synchronization and mutual exclusion operations.
 18 
 19 This is necessary, for example, for Inter-processor communications:
 20 on OMAP4, cpu-intensive multimedia tasks are offloaded by the host to the
 21 remote M3 and/or C64x+ slave processors (by an IPC subsystem called Syslink).
 22 
 23 To achieve fast message-based communications, a minimal kernel support
 24 is needed to deliver messages arriving from a remote processor to the
 25 appropriate user process.
 26 
 27 This communication is based on simple data structures that is shared between
 28 the remote processors, and access to it is synchronized using the hwspinlock
 29 module (remote processor directly places new messages in this shared data
 30 structure).
 31 
 32 A common hwspinlock interface makes it possible to have generic, platform-
 33 independent, drivers.
 34 
 35 2. User API
 36 
 37   struct hwspinlock *hwspin_lock_request(void);
 38    - dynamically assign an hwspinlock and return its address, or NULL
 39      in case an unused hwspinlock isn't available. Users of this
 40      API will usually want to communicate the lock's id to the remote core
 41      before it can be used to achieve synchronization.
 42      Should be called from a process context (might sleep).
 43 
 44   struct hwspinlock *hwspin_lock_request_specific(unsigned int id);
 45    - assign a specific hwspinlock id and return its address, or NULL
 46      if that hwspinlock is already in use. Usually board code will
 47      be calling this function in order to reserve specific hwspinlock
 48      ids for predefined purposes.
 49      Should be called from a process context (might sleep).
 50 
 51   int of_hwspin_lock_get_id(struct device_node *np, int index);
 52    - retrieve the global lock id for an OF phandle-based specific lock.
 53      This function provides a means for DT users of a hwspinlock module
 54      to get the global lock id of a specific hwspinlock, so that it can
 55      be requested using the normal hwspin_lock_request_specific() API.
 56      The function returns a lock id number on success, -EPROBE_DEFER if
 57      the hwspinlock device is not yet registered with the core, or other
 58      error values.
 59      Should be called from a process context (might sleep).
 60 
 61   int hwspin_lock_free(struct hwspinlock *hwlock);
 62    - free a previously-assigned hwspinlock; returns 0 on success, or an
 63      appropriate error code on failure (e.g. -EINVAL if the hwspinlock
 64      is already free).
 65      Should be called from a process context (might sleep).
 66 
 67   int hwspin_lock_timeout(struct hwspinlock *hwlock, unsigned int timeout);
 68    - lock a previously-assigned hwspinlock with a timeout limit (specified in
 69      msecs). If the hwspinlock is already taken, the function will busy loop
 70      waiting for it to be released, but give up when the timeout elapses.
 71      Upon a successful return from this function, preemption is disabled so
 72      the caller must not sleep, and is advised to release the hwspinlock as
 73      soon as possible, in order to minimize remote cores polling on the
 74      hardware interconnect.
 75      Returns 0 when successful and an appropriate error code otherwise (most
 76      notably -ETIMEDOUT if the hwspinlock is still busy after timeout msecs).
 77      The function will never sleep.
 78 
 79   int hwspin_lock_timeout_irq(struct hwspinlock *hwlock, unsigned int timeout);
 80    - lock a previously-assigned hwspinlock with a timeout limit (specified in
 81      msecs). If the hwspinlock is already taken, the function will busy loop
 82      waiting for it to be released, but give up when the timeout elapses.
 83      Upon a successful return from this function, preemption and the local
 84      interrupts are disabled, so the caller must not sleep, and is advised to
 85      release the hwspinlock as soon as possible.
 86      Returns 0 when successful and an appropriate error code otherwise (most
 87      notably -ETIMEDOUT if the hwspinlock is still busy after timeout msecs).
 88      The function will never sleep.
 89 
 90   int hwspin_lock_timeout_irqsave(struct hwspinlock *hwlock, unsigned int to,
 91                                                         unsigned long *flags);
 92    - lock a previously-assigned hwspinlock with a timeout limit (specified in
 93      msecs). If the hwspinlock is already taken, the function will busy loop
 94      waiting for it to be released, but give up when the timeout elapses.
 95      Upon a successful return from this function, preemption is disabled,
 96      local interrupts are disabled and their previous state is saved at the
 97      given flags placeholder. The caller must not sleep, and is advised to
 98      release the hwspinlock as soon as possible.
 99      Returns 0 when successful and an appropriate error code otherwise (most
100      notably -ETIMEDOUT if the hwspinlock is still busy after timeout msecs).
101      The function will never sleep.
102 
103   int hwspin_trylock(struct hwspinlock *hwlock);
104    - attempt to lock a previously-assigned hwspinlock, but immediately fail if
105      it is already taken.
106      Upon a successful return from this function, preemption is disabled so
107      caller must not sleep, and is advised to release the hwspinlock as soon as
108      possible, in order to minimize remote cores polling on the hardware
109      interconnect.
110      Returns 0 on success and an appropriate error code otherwise (most
111      notably -EBUSY if the hwspinlock was already taken).
112      The function will never sleep.
113 
114   int hwspin_trylock_irq(struct hwspinlock *hwlock);
115    - attempt to lock a previously-assigned hwspinlock, but immediately fail if
116      it is already taken.
117      Upon a successful return from this function, preemption and the local
118      interrupts are disabled so caller must not sleep, and is advised to
119      release the hwspinlock as soon as possible.
120      Returns 0 on success and an appropriate error code otherwise (most
121      notably -EBUSY if the hwspinlock was already taken).
122      The function will never sleep.
123 
124   int hwspin_trylock_irqsave(struct hwspinlock *hwlock, unsigned long *flags);
125    - attempt to lock a previously-assigned hwspinlock, but immediately fail if
126      it is already taken.
127      Upon a successful return from this function, preemption is disabled,
128      the local interrupts are disabled and their previous state is saved
129      at the given flags placeholder. The caller must not sleep, and is advised
130      to release the hwspinlock as soon as possible.
131      Returns 0 on success and an appropriate error code otherwise (most
132      notably -EBUSY if the hwspinlock was already taken).
133      The function will never sleep.
134 
135   void hwspin_unlock(struct hwspinlock *hwlock);
136    - unlock a previously-locked hwspinlock. Always succeed, and can be called
137      from any context (the function never sleeps). Note: code should _never_
138      unlock an hwspinlock which is already unlocked (there is no protection
139      against this).
140 
141   void hwspin_unlock_irq(struct hwspinlock *hwlock);
142    - unlock a previously-locked hwspinlock and enable local interrupts.
143      The caller should _never_ unlock an hwspinlock which is already unlocked.
144      Doing so is considered a bug (there is no protection against this).
145      Upon a successful return from this function, preemption and local
146      interrupts are enabled. This function will never sleep.
147 
148   void
149   hwspin_unlock_irqrestore(struct hwspinlock *hwlock, unsigned long *flags);
150    - unlock a previously-locked hwspinlock.
151      The caller should _never_ unlock an hwspinlock which is already unlocked.
152      Doing so is considered a bug (there is no protection against this).
153      Upon a successful return from this function, preemption is reenabled,
154      and the state of the local interrupts is restored to the state saved at
155      the given flags. This function will never sleep.
156 
157   int hwspin_lock_get_id(struct hwspinlock *hwlock);
158    - retrieve id number of a given hwspinlock. This is needed when an
159      hwspinlock is dynamically assigned: before it can be used to achieve
160      mutual exclusion with a remote cpu, the id number should be communicated
161      to the remote task with which we want to synchronize.
162      Returns the hwspinlock id number, or -EINVAL if hwlock is null.
163 
164 3. Typical usage
165 
166 #include <linux/hwspinlock.h>
167 #include <linux/err.h>
168 
169 int hwspinlock_example1(void)
170 {
171         struct hwspinlock *hwlock;
172         int ret;
173 
174         /* dynamically assign a hwspinlock */
175         hwlock = hwspin_lock_request();
176         if (!hwlock)
177                 ...
178 
179         id = hwspin_lock_get_id(hwlock);
180         /* probably need to communicate id to a remote processor now */
181 
182         /* take the lock, spin for 1 sec if it's already taken */
183         ret = hwspin_lock_timeout(hwlock, 1000);
184         if (ret)
185                 ...
186 
187         /*
188          * we took the lock, do our thing now, but do NOT sleep
189          */
190 
191         /* release the lock */
192         hwspin_unlock(hwlock);
193 
194         /* free the lock */
195         ret = hwspin_lock_free(hwlock);
196         if (ret)
197                 ...
198 
199         return ret;
200 }
201 
202 int hwspinlock_example2(void)
203 {
204         struct hwspinlock *hwlock;
205         int ret;
206 
207         /*
208          * assign a specific hwspinlock id - this should be called early
209          * by board init code.
210          */
211         hwlock = hwspin_lock_request_specific(PREDEFINED_LOCK_ID);
212         if (!hwlock)
213                 ...
214 
215         /* try to take it, but don't spin on it */
216         ret = hwspin_trylock(hwlock);
217         if (!ret) {
218                 pr_info("lock is already taken\n");
219                 return -EBUSY;
220         }
221 
222         /*
223          * we took the lock, do our thing now, but do NOT sleep
224          */
225 
226         /* release the lock */
227         hwspin_unlock(hwlock);
228 
229         /* free the lock */
230         ret = hwspin_lock_free(hwlock);
231         if (ret)
232                 ...
233 
234         return ret;
235 }
236 
237 
238 4. API for implementors
239 
240   int hwspin_lock_register(struct hwspinlock_device *bank, struct device *dev,
241                 const struct hwspinlock_ops *ops, int base_id, int num_locks);
242    - to be called from the underlying platform-specific implementation, in
243      order to register a new hwspinlock device (which is usually a bank of
244      numerous locks). Should be called from a process context (this function
245      might sleep).
246      Returns 0 on success, or appropriate error code on failure.
247 
248   int hwspin_lock_unregister(struct hwspinlock_device *bank);
249    - to be called from the underlying vendor-specific implementation, in order
250      to unregister an hwspinlock device (which is usually a bank of numerous
251      locks).
252      Should be called from a process context (this function might sleep).
253      Returns the address of hwspinlock on success, or NULL on error (e.g.
254      if the hwspinlock is still in use).
255 
256 5. Important structs
257 
258 struct hwspinlock_device is a device which usually contains a bank
259 of hardware locks. It is registered by the underlying hwspinlock
260 implementation using the hwspin_lock_register() API.
261 
262 /**
263  * struct hwspinlock_device - a device which usually spans numerous hwspinlocks
264  * @dev: underlying device, will be used to invoke runtime PM api
265  * @ops: platform-specific hwspinlock handlers
266  * @base_id: id index of the first lock in this device
267  * @num_locks: number of locks in this device
268  * @lock: dynamically allocated array of 'struct hwspinlock'
269  */
270 struct hwspinlock_device {
271         struct device *dev;
272         const struct hwspinlock_ops *ops;
273         int base_id;
274         int num_locks;
275         struct hwspinlock lock[0];
276 };
277 
278 struct hwspinlock_device contains an array of hwspinlock structs, each
279 of which represents a single hardware lock:
280 
281 /**
282  * struct hwspinlock - this struct represents a single hwspinlock instance
283  * @bank: the hwspinlock_device structure which owns this lock
284  * @lock: initialized and used by hwspinlock core
285  * @priv: private data, owned by the underlying platform-specific hwspinlock drv
286  */
287 struct hwspinlock {
288         struct hwspinlock_device *bank;
289         spinlock_t lock;
290         void *priv;
291 };
292 
293 When registering a bank of locks, the hwspinlock driver only needs to
294 set the priv members of the locks. The rest of the members are set and
295 initialized by the hwspinlock core itself.
296 
297 6. Implementation callbacks
298 
299 There are three possible callbacks defined in 'struct hwspinlock_ops':
300 
301 struct hwspinlock_ops {
302         int (*trylock)(struct hwspinlock *lock);
303         void (*unlock)(struct hwspinlock *lock);
304         void (*relax)(struct hwspinlock *lock);
305 };
306 
307 The first two callbacks are mandatory:
308 
309 The ->trylock() callback should make a single attempt to take the lock, and
310 return 0 on failure and 1 on success. This callback may _not_ sleep.
311 
312 The ->unlock() callback releases the lock. It always succeed, and it, too,
313 may _not_ sleep.
314 
315 The ->relax() callback is optional. It is called by hwspinlock core while
316 spinning on a lock, and can be used by the underlying implementation to force
317 a delay between two successive invocations of ->trylock(). It may _not_ sleep.

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us