313162d0b8
The <linux/device.h> header includes a lot of stuff, and it in turn gets a lot of use just for the basic "struct device" which appears so often. Clean up the users as follows: 1) For those headers only needing "struct device" as a pointer in fcn args, replace the include with exactly that. 2) For headers not really using anything from device.h, simply delete the include altogether. 3) For headers relying on getting device.h implicitly before being included themselves, now explicitly include device.h 4) For files in which doing #1 or #2 uncovers an implicit dependency on some other header, fix by explicitly adding the required header(s). Any C files that were implicitly relying on device.h to be present have already been dealt with in advance. Total removals from #1 and #2: 51. Total additions coming from #3: 9. Total other implicit dependencies from #4: 7. As of 3.3-rc1, there were 110, so a net removal of 42 gives about a 38% reduction in device.h presence in include/* Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
313 lines
11 KiB
C
313 lines
11 KiB
C
/*
|
|
* Hardware spinlock public header
|
|
*
|
|
* Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com
|
|
*
|
|
* Contact: Ohad Ben-Cohen <ohad@wizery.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 as published
|
|
* by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#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 */
|
|
|
|
struct device;
|
|
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;
|
|
};
|
|
|
|
#if defined(CONFIG_HWSPINLOCK) || defined(CONFIG_HWSPINLOCK_MODULE)
|
|
|
|
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 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 *);
|
|
|
|
#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 hwspin_lock_get_id(struct hwspinlock *hwlock)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#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() - 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() - 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() - 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 */
|