Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421/* SPDX-License-Identifier: GPL-2.0 *//* * Hardware spinlock public header * * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com * * Contact: Ohad Ben-Cohen <ohad@wizery.com> */
#ifndef __LINUX_HWSPINLOCK_H#define __LINUX_HWSPINLOCK_H
#include <linux/err.h>#include <linux/sched.h>
/* hwspinlock mode argument */#define HWLOCK_IRQSTATE 0x01 /* Disable interrupts, save state */#define HWLOCK_IRQ 0x02 /* Disable interrupts, don't save state */#define HWLOCK_RAW 0x03#define HWLOCK_IN_ATOMIC 0x04 /* Called while in atomic context */
struct device;struct device_node;struct hwspinlock;struct hwspinlock_device;struct hwspinlock_ops;
#ifdef CONFIG_HWSPINLOCK
int hwspin_lock_register(struct hwspinlock_device *bank, struct device *dev, const struct hwspinlock_ops *ops, int base_id, int num_locks);int hwspin_lock_unregister(struct hwspinlock_device *bank);struct hwspinlock *hwspin_lock_request_specific(unsigned int id);int hwspin_lock_free(struct hwspinlock *hwlock);int of_hwspin_lock_get_id(struct device_node *np, int index);int __hwspin_lock_timeout(struct hwspinlock *, unsigned int, int, unsigned long *);int __hwspin_trylock(struct hwspinlock *, int, unsigned long *);void __hwspin_unlock(struct hwspinlock *, int, unsigned long *);int of_hwspin_lock_get_id_byname(struct device_node *np, const char *name);int hwspin_lock_bust(struct hwspinlock *hwlock, unsigned int id);int devm_hwspin_lock_free(struct device *dev, struct hwspinlock *hwlock);struct hwspinlock *devm_hwspin_lock_request_specific(struct device *dev, unsigned int id);int devm_hwspin_lock_unregister(struct device *dev, struct hwspinlock_device *bank);int devm_hwspin_lock_register(struct device *dev, struct hwspinlock_device *bank, const struct hwspinlock_ops *ops, int base_id, int num_locks);
#else /* !CONFIG_HWSPINLOCK */
/* * We don't want these functions to fail if CONFIG_HWSPINLOCK is not * enabled. We prefer to silently succeed in this case, and let the * code path get compiled away. This way, if CONFIG_HWSPINLOCK is not * required on a given setup, users will still work. * * The only exception is hwspin_lock_register/hwspin_lock_unregister, with which * we _do_ want users to fail (no point in registering hwspinlock instances if * the framework is not available). * * Note: ERR_PTR(-ENODEV) will still be considered a success for NULL-checking * users. Others, which care, can still check this with IS_ERR. */static inline struct hwspinlock *hwspin_lock_request_specific(unsigned int id){ return ERR_PTR(-ENODEV);}
static inline int hwspin_lock_free(struct hwspinlock *hwlock){ return 0;}
static inlineint __hwspin_lock_timeout(struct hwspinlock *hwlock, unsigned int to, int mode, unsigned long *flags){ return 0;}
static inlineint __hwspin_trylock(struct hwspinlock *hwlock, int mode, unsigned long *flags){ return 0;}
static inlinevoid __hwspin_unlock(struct hwspinlock *hwlock, int mode, unsigned long *flags){}
static inline int hwspin_lock_bust(struct hwspinlock *hwlock, unsigned int id){ return 0;}
static inline int of_hwspin_lock_get_id(struct device_node *np, int index){ return 0;}
static inlineint of_hwspin_lock_get_id_byname(struct device_node *np, const char *name){ return 0;}
static inlineint devm_hwspin_lock_free(struct device *dev, struct hwspinlock *hwlock){ return 0;}
static inlinestruct hwspinlock *devm_hwspin_lock_request_specific(struct device *dev, unsigned int id){ return ERR_PTR(-ENODEV);}
#endif /* !CONFIG_HWSPINLOCK */
/** * hwspin_trylock_irqsave() - try to lock an hwspinlock, disable interrupts * @hwlock: an hwspinlock which we want to trylock * @flags: a pointer to where the caller's interrupt state will be saved at * * This function attempts to lock the underlying hwspinlock, and will * immediately fail if the hwspinlock is already locked. * * Upon a successful return from this function, preemption and local * interrupts are disabled (previous interrupts state is saved at @flags), * so the caller must not sleep, and is advised to release the hwspinlock * as soon as possible. * * Returns 0 if we successfully locked the hwspinlock, -EBUSY if * the hwspinlock was already taken, and -EINVAL if @hwlock is invalid. */static inlineint hwspin_trylock_irqsave(struct hwspinlock *hwlock, unsigned long *flags){ return __hwspin_trylock(hwlock, HWLOCK_IRQSTATE, flags);}
/** * hwspin_trylock_irq() - try to lock an hwspinlock, disable interrupts * @hwlock: an hwspinlock which we want to trylock * * This function attempts to lock the underlying hwspinlock, and will * immediately fail if the hwspinlock is already locked. * * Upon a successful return from this function, preemption and local * interrupts are disabled, so the caller must not sleep, and is advised * to release the hwspinlock as soon as possible. * * Returns 0 if we successfully locked the hwspinlock, -EBUSY if * the hwspinlock was already taken, and -EINVAL if @hwlock is invalid. */static inline int hwspin_trylock_irq(struct hwspinlock *hwlock){ return __hwspin_trylock(hwlock, HWLOCK_IRQ, NULL);}
/** * hwspin_trylock_raw() - attempt to lock a specific hwspinlock * @hwlock: an hwspinlock which we want to trylock * * This function attempts to lock an hwspinlock, and will immediately fail * if the hwspinlock is already taken. * * Caution: User must protect the routine of getting hardware lock with mutex * or spinlock to avoid dead-lock, that will let user can do some time-consuming * or sleepable operations under the hardware lock. * * Returns 0 if we successfully locked the hwspinlock, -EBUSY if * the hwspinlock was already taken, and -EINVAL if @hwlock is invalid. */static inline int hwspin_trylock_raw(struct hwspinlock *hwlock){ return __hwspin_trylock(hwlock, HWLOCK_RAW, NULL);}
/** * hwspin_trylock_in_atomic() - attempt to lock a specific hwspinlock * @hwlock: an hwspinlock which we want to trylock * * This function attempts to lock an hwspinlock, and will immediately fail * if the hwspinlock is already taken. * * This function shall be called only from an atomic context. * * Returns 0 if we successfully locked the hwspinlock, -EBUSY if * the hwspinlock was already taken, and -EINVAL if @hwlock is invalid. */static inline int hwspin_trylock_in_atomic(struct hwspinlock *hwlock){ return __hwspin_trylock(hwlock, HWLOCK_IN_ATOMIC, NULL);}
/** * hwspin_trylock() - attempt to lock a specific hwspinlock * @hwlock: an hwspinlock which we want to trylock * * This function attempts to lock an hwspinlock, and will immediately fail * if the hwspinlock is already taken. * * Upon a successful return from this function, preemption is disabled, * so the caller must not sleep, and is advised to release the hwspinlock * as soon as possible. This is required in order to minimize remote cores * polling on the hardware interconnect. * * Returns 0 if we successfully locked the hwspinlock, -EBUSY if * the hwspinlock was already taken, and -EINVAL if @hwlock is invalid. */static inline int hwspin_trylock(struct hwspinlock *hwlock){ return __hwspin_trylock(hwlock, 0, NULL);}
/** * hwspin_lock_timeout_irqsave() - lock hwspinlock, with timeout, disable irqs * @hwlock: the hwspinlock to be locked * @to: timeout value in msecs * @flags: a pointer to where the caller's interrupt state will be saved at * * This function locks the underlying @hwlock. If the @hwlock * is already taken, the function will busy loop waiting for it to * be released, but give up when @timeout msecs have elapsed. * * Upon a successful return from this function, preemption and local interrupts * are disabled (plus previous interrupt state is saved), so the caller must * not sleep, and is advised to release the hwspinlock as soon as possible. * * Returns 0 when the @hwlock was successfully taken, and an appropriate * error code otherwise (most notably an -ETIMEDOUT if the @hwlock is still * busy after @timeout msecs). The function will never sleep. */static inline int hwspin_lock_timeout_irqsave(struct hwspinlock *hwlock, unsigned int to, unsigned long *flags){ return __hwspin_lock_timeout(hwlock, to, HWLOCK_IRQSTATE, flags);}
/** * hwspin_lock_timeout_irq() - lock hwspinlock, with timeout, disable irqs * @hwlock: the hwspinlock to be locked * @to: timeout value in msecs * * This function locks the underlying @hwlock. If the @hwlock * is already taken, the function will busy loop waiting for it to * be released, but give up when @timeout msecs have elapsed. * * Upon a successful return from this function, preemption and local interrupts * are disabled so the caller must not sleep, and is advised to release the * hwspinlock as soon as possible. * * Returns 0 when the @hwlock was successfully taken, and an appropriate * error code otherwise (most notably an -ETIMEDOUT if the @hwlock is still * busy after @timeout msecs). The function will never sleep. */static inlineint hwspin_lock_timeout_irq(struct hwspinlock *hwlock, unsigned int to){ return __hwspin_lock_timeout(hwlock, to, HWLOCK_IRQ, NULL);}
/** * hwspin_lock_timeout_raw() - lock an hwspinlock with timeout limit * @hwlock: the hwspinlock to be locked * @to: timeout value in msecs * * This function locks the underlying @hwlock. If the @hwlock * is already taken, the function will busy loop waiting for it to * be released, but give up when @timeout msecs have elapsed. * * Caution: User must protect the routine of getting hardware lock with mutex * or spinlock to avoid dead-lock, that will let user can do some time-consuming * or sleepable operations under the hardware lock. * * Returns 0 when the @hwlock was successfully taken, and an appropriate * error code otherwise (most notably an -ETIMEDOUT if the @hwlock is still * busy after @timeout msecs). The function will never sleep. */static inlineint hwspin_lock_timeout_raw(struct hwspinlock *hwlock, unsigned int to){ return __hwspin_lock_timeout(hwlock, to, HWLOCK_RAW, NULL);}
/** * hwspin_lock_timeout_in_atomic() - lock an hwspinlock with timeout limit * @hwlock: the hwspinlock to be locked * @to: timeout value in msecs * * This function locks the underlying @hwlock. If the @hwlock * is already taken, the function will busy loop waiting for it to * be released, but give up when @timeout msecs have elapsed. * * This function shall be called only from an atomic context and the timeout * value shall not exceed a few msecs. * * Returns 0 when the @hwlock was successfully taken, and an appropriate * error code otherwise (most notably an -ETIMEDOUT if the @hwlock is still * busy after @timeout msecs). The function will never sleep. */static inlineint hwspin_lock_timeout_in_atomic(struct hwspinlock *hwlock, unsigned int to){ return __hwspin_lock_timeout(hwlock, to, HWLOCK_IN_ATOMIC, NULL);}
/** * hwspin_lock_timeout() - lock an hwspinlock with timeout limit * @hwlock: the hwspinlock to be locked * @to: timeout value in msecs * * This function locks the underlying @hwlock. If the @hwlock * is already taken, the function will busy loop waiting for it to * be released, but give up when @timeout msecs have elapsed. * * Upon a successful return from this function, preemption is disabled * so the caller must not sleep, and is advised to release the hwspinlock * as soon as possible. * This is required in order to minimize remote cores polling on the * hardware interconnect. * * Returns 0 when the @hwlock was successfully taken, and an appropriate * error code otherwise (most notably an -ETIMEDOUT if the @hwlock is still * busy after @timeout msecs). The function will never sleep. */static inlineint hwspin_lock_timeout(struct hwspinlock *hwlock, unsigned int to){ return __hwspin_lock_timeout(hwlock, to, 0, NULL);}
/** * hwspin_unlock_irqrestore() - unlock hwspinlock, restore irq state * @hwlock: a previously-acquired hwspinlock which we want to unlock * @flags: previous caller's interrupt state to restore * * This function will unlock a specific hwspinlock, enable preemption and * restore the previous state of the local interrupts. It should be used * to undo, e.g., hwspin_trylock_irqsave(). * * @hwlock must be already locked before calling this function: it is a bug * to call unlock on a @hwlock that is already unlocked. */static inline void hwspin_unlock_irqrestore(struct hwspinlock *hwlock, unsigned long *flags){ __hwspin_unlock(hwlock, HWLOCK_IRQSTATE, flags);}
/** * hwspin_unlock_irq() - unlock hwspinlock, enable interrupts * @hwlock: a previously-acquired hwspinlock which we want to unlock * * This function will unlock a specific hwspinlock, enable preemption and * enable local interrupts. Should be used to undo hwspin_lock_irq(). * * @hwlock must be already locked (e.g. by hwspin_trylock_irq()) before * calling this function: it is a bug to call unlock on a @hwlock that is * already unlocked. */static inline void hwspin_unlock_irq(struct hwspinlock *hwlock){ __hwspin_unlock(hwlock, HWLOCK_IRQ, NULL);}
/** * hwspin_unlock_raw() - unlock hwspinlock * @hwlock: a previously-acquired hwspinlock which we want to unlock * * This function will unlock a specific hwspinlock. * * @hwlock must be already locked (e.g. by hwspin_trylock()) before calling * this function: it is a bug to call unlock on a @hwlock that is already * unlocked. */static inline void hwspin_unlock_raw(struct hwspinlock *hwlock){ __hwspin_unlock(hwlock, HWLOCK_RAW, NULL);}
/** * hwspin_unlock_in_atomic() - unlock hwspinlock * @hwlock: a previously-acquired hwspinlock which we want to unlock * * This function will unlock a specific hwspinlock. * * @hwlock must be already locked (e.g. by hwspin_trylock()) before calling * this function: it is a bug to call unlock on a @hwlock that is already * unlocked. */static inline void hwspin_unlock_in_atomic(struct hwspinlock *hwlock){ __hwspin_unlock(hwlock, HWLOCK_IN_ATOMIC, NULL);}
/** * hwspin_unlock() - unlock hwspinlock * @hwlock: a previously-acquired hwspinlock which we want to unlock * * This function will unlock a specific hwspinlock and enable preemption * back. * * @hwlock must be already locked (e.g. by hwspin_trylock()) before calling * this function: it is a bug to call unlock on a @hwlock that is already * unlocked. */static inline void hwspin_unlock(struct hwspinlock *hwlock){ __hwspin_unlock(hwlock, 0, NULL);}
#endif /* __LINUX_HWSPINLOCK_H */