github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-24 15:12:13 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

iio: core: Refactor iio_device_claim_direct() implementation

Browse Source 
In order to eventually unify the locking API, implement
iio_device_claim_direct() fully inline, with the use of
__iio_dev_mode_lock(), which takes care of sparse annotations.

Reviewed-by: David Lechner <dlechner@baylibre.com>
Reviewed-by: Nuno Sá <nuno.sa@analog.com>
Signed-off-by: Kurt Borja <kuurtb@gmail.com>
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
This commit is contained in:
Kurt Borja 2026-01-20 01:20:42 -05:00 committed by Jonathan Cameron
parent 88fd1f9079
commit c37ec9d507
2 changed files with 28 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
drivers/iio/industrialio-core.c
View File

@ -2201,50 +2201,6 @@ void __iio_dev_mode_unlock(struct iio_dev *indio_dev)
}
EXPORT_SYMBOL_GPL(__iio_dev_mode_unlock);
/**
* __iio_device_claim_direct - Keep device in direct mode
* @indio_dev: the iio_dev associated with the device
*
* If the device is in direct mode it is guaranteed to stay
* that way until __iio_device_release_direct() is called.
*
* Use with __iio_device_release_direct().
*
* Drivers should only call iio_device_claim_direct().
*
* Returns: true on success, false on failure.
*/
bool __iio_device_claim_direct(struct iio_dev *indio_dev)
{
struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
mutex_lock(&iio_dev_opaque->mlock);
if (iio_buffer_enabled(indio_dev)) {
mutex_unlock(&iio_dev_opaque->mlock);
return false;
}
return true;
}
EXPORT_SYMBOL_GPL(__iio_device_claim_direct);
/**
* __iio_device_release_direct - releases claim on direct mode
* @indio_dev: the iio_dev associated with the device
*
* Release the claim. Device is no longer guaranteed to stay
* in direct mode.
*
* Drivers should only call iio_device_release_direct().
*
* Use with __iio_device_claim_direct()
*/
void __iio_device_release_direct(struct iio_dev *indio_dev)
{
mutex_unlock(&to_iio_dev_opaque(indio_dev)->mlock);
}
EXPORT_SYMBOL_GPL(__iio_device_release_direct);
/**
* iio_device_claim_buffer_mode - Keep device in buffer mode
* @indio_dev: the iio_dev associated with the device

40
include/linux/iio/iio.h
View File

@ -664,31 +664,47 @@ int iio_push_event(struct iio_dev *indio_dev, u64 ev_code, s64 timestamp);
void __iio_dev_mode_lock(struct iio_dev *indio_dev) __acquires(indio_dev);
void __iio_dev_mode_unlock(struct iio_dev *indio_dev) __releases(indio_dev);
bool __iio_device_claim_direct(struct iio_dev *indio_dev);
void __iio_device_release_direct(struct iio_dev *indio_dev);
/*
* Helper functions that allow claim and release of direct mode
* in a fashion that doesn't generate many false positives from sparse.
* Note this must remain static inline in the header so that sparse
* can see the __acquire() marking. Revisit when sparse supports
* __cond_acquires()
* can see the __acquires() and __releases() annotations.
*/
/**
* iio_device_claim_direct() - Keep device in direct mode
* @indio_dev: the iio_dev associated with the device
*
* If the device is in direct mode it is guaranteed to stay
* that way until iio_device_release_direct() is called.
*
* Use with iio_device_release_direct().
*
* Returns: true on success, false on failure.
*/
static inline bool iio_device_claim_direct(struct iio_dev *indio_dev)
{
if (!__iio_device_claim_direct(indio_dev))
return false;
__iio_dev_mode_lock(indio_dev);
__acquire(iio_dev);
if (iio_buffer_enabled(indio_dev)) {
__iio_dev_mode_unlock(indio_dev);
return false;
}
return true;
}
static inline void iio_device_release_direct(struct iio_dev *indio_dev)
{
__iio_device_release_direct(indio_dev);
__release(indio_dev);
}
/**
* iio_device_release_direct() - Releases claim on direct mode
* @indio_dev: the iio_dev associated with the device
*
* Release the claim. Device is no longer guaranteed to stay
* in direct mode.
*
* Use with iio_device_claim_direct().
*/
#define iio_device_release_direct(indio_dev) __iio_dev_mode_unlock(indio_dev)
int iio_device_claim_buffer_mode(struct iio_dev *indio_dev);
void iio_device_release_buffer_mode(struct iio_dev *indio_dev);