OSCL-LXR linux-6.0.1/​include/​linux/​hwspinlock.h	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 /* 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;
 
 /**
  * struct hwspinlock_pdata - platform data for hwspinlock drivers
  * @base_id: base id for this hwspinlock device
  *
  * hwspinlock devices provide system-wide hardware locks that are used
  * by remote processors that have no other way to achieve synchronization.
  *
  * To achieve that, each physical lock must have a system-wide id number
  * that is agreed upon, otherwise remote processors can't possibly assume
  * they're using the same hardware lock.
  *
  * Usually boards have a single hwspinlock device, which provides several
  * hwspinlocks, and in this case, they can be trivially numbered 0 to
  * (num-of-locks - 1).
  *
  * In case boards have several hwspinlocks devices, a different base id
  * should be used for each hwspinlock device (they can't all use 0 as
  * a starting id!).
  *
  * This platform data structure should be used to provide the base id
  * for each device (which is trivially 0 when only a single hwspinlock
  * device exists). It can be shared between different platforms, hence
  * its location.
  */
 struct hwspinlock_pdata {
     int base_id;
 };
 
 #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(void);
 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_get_id(struct hwspinlock *hwlock);
 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 devm_hwspin_lock_free(struct device *dev, struct hwspinlock *hwlock);
 struct hwspinlock *devm_hwspin_lock_request(struct device *dev);
 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(void)
 {
     return ERR_PTR(-ENODEV);
 }
 
 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 inline
 int __hwspin_lock_timeout(struct hwspinlock *hwlock, unsigned int to,
                     int mode, unsigned long *flags)
 {
     return 0;
 }
 
 static inline
 int __hwspin_trylock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
 {
     return 0;
 }
 
 static inline
 void __hwspin_unlock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
 {
 }
 
 static inline int of_hwspin_lock_get_id(struct device_node *np, int index)
 {
     return 0;
 }
 
 static inline int hwspin_lock_get_id(struct hwspinlock *hwlock)
 {
     return 0;
 }
 
 static inline
 int of_hwspin_lock_get_id_byname(struct device_node *np, const char *name)
 {
     return 0;
 }
 
 static inline
 int devm_hwspin_lock_free(struct device *dev, struct hwspinlock *hwlock)
 {
     return 0;
 }
 
 static inline struct hwspinlock *devm_hwspin_lock_request(struct device *dev)
 {
     return ERR_PTR(-ENODEV);
 }
 
 static inline
 struct 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 inline
 int 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 inline
 int 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 inline
 int 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 inline
 int 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 inline
 int 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 */

This page was automatically generated by the 2.1.0 LXR engine. The LXR team