android/android_kernel_samsung_sm8650
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

drivers:iio:stm: extends IIO ST MEMS drivers build on k6.1

Browse Source 
Cumulative patch to allow build IIO ST MEMS drivers on k6.1

Signed-off-by: Mario Tesi <mario.tesi@st.com>
Change-Id: I1fa2524b21c800eefbfeee85d9abc26e4b2a2eef
Reviewed-on: https://gerrit.st.com/c/linuxandroidopen/stm-ldd-iio/+/295087
Tested-by: CITOOLS <MDG-smet-aci-reviews@list.st.com>
Reviewed-by: Matteo DAMENO <matteo.dameno@st.com>
This commit is contained in:
Mario Tesi 2023-03-10 16:05:48 +01:00 committed by Matteo DAMENO
parent 5b1943eda5
commit b6abc92c02
105 changed files with 864 additions and 337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
drivers/iio/stm/accel/st_acc33_buffer.c
View File

@ -270,7 +270,12 @@ int st_acc33_fifo_setup(struct st_acc33_hw *hw)
return ret;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,13,0)
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
ret = devm_iio_kfifo_buffer_setup(hw->dev, iio_dev,
&st_acc33_buffer_ops);
if (ret)
return ret;
#elif KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
ret = devm_iio_kfifo_buffer_setup(hw->dev, iio_dev,
INDIO_BUFFER_SOFTWARE,
&st_acc33_buffer_ops);

2
drivers/iio/stm/accel/st_acc33_core.c
View File

@ -15,6 +15,8 @@
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <asm/unaligned.h>
#include <linux/of_device.h>
#include <linux/property.h>
#include "st_acc33.h"

18
drivers/iio/stm/accel/st_ism303dac_accel.h
View File

@ -14,6 +14,11 @@
#include <linux/iio/iio.h>
#include <linux/iio/trigger.h>
#include <linux/platform_data/stm/ism303dac.h>
#include <linux/version.h>
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
#include <linux/iio/iio-opaque.h>
#endif /* LINUX_VERSION_CODE */
#define ISM303DAC_WHO_AM_I_ADDR 0x0f
#define ISM303DAC_WHO_AM_I_DEF 0x43
@ -279,6 +284,19 @@ static inline s64 ism303dac_get_time_ns(struct iio_dev *iio_sensors_dev)
return iio_get_time_ns(iio_sensors_dev);
}
static inline int ism303dac_iio_dev_currentmode(struct iio_dev *indio_dev)
{
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
struct iio_dev_opaque *iio_opq = to_iio_dev_opaque(indio_dev);
return iio_opq->currentmode;
#else /* LINUX_VERSION_CODE */
return indio_dev->currentmode;
#endif /* LINUX_VERSION_CODE */
}
int ism303dac_common_probe(struct ism303dac_data *cdata, int irq);
#ifdef CONFIG_PM
int ism303dac_common_suspend(struct ism303dac_data *cdata);

27
drivers/iio/stm/accel/st_ism303dac_accel_core.c
View File

@ -17,6 +17,7 @@
#include <linux/gpio.h>
#include <linux/irq.h>
#include <linux/iio/iio.h>
#include <linux/of.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/trigger.h>
#include <linux/delay.h>
@ -641,7 +642,7 @@ static ssize_t ism303dac_get_sampling_frequency(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct ism303dac_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct ism303dac_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sdata->odr);
}
@ -653,7 +654,7 @@ ssize_t ism303dac_set_sampling_frequency(struct device * dev,
int err;
u8 power_mode;
unsigned int odr, i;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism303dac_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &odr);
@ -685,7 +686,7 @@ static ssize_t ism303dac_get_sampling_frequency_avail(struct device *dev,
char *buf)
{
int i, len = 0, mode_count, mode;
struct ism303dac_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct ism303dac_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
mode = sdata->cdata->power_mode;
mode_count = (mode == ISM303DAC_LP_MODE) ?
@ -726,7 +727,7 @@ static int ism303dac_read_raw(struct iio_dev *indio_dev,
switch (mask) {
case IIO_CHAN_INFO_RAW:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (ism303dac_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -781,7 +782,7 @@ static int ism303dac_write_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_SCALE:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (ism303dac_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -807,7 +808,7 @@ static ssize_t ism303dac_sysfs_get_hwfifo_enabled(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism303dac_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n", sdata->cdata->hwfifo_enabled);
@ -819,7 +820,7 @@ ssize_t ism303dac_sysfs_set_hwfifo_enabled(struct device *dev,
{
int err = 0, enable = 0;
u8 mode = BYPASS;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism303dac_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &enable);
@ -844,7 +845,7 @@ static ssize_t ism303dac_sysfs_get_hwfifo_watermark(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism303dac_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n", sdata->cdata->hwfifo_watermark);
@ -855,7 +856,7 @@ ssize_t ism303dac_sysfs_set_hwfifo_watermark(struct device * dev,
const char *buf, size_t count)
{
int err = 0, watermark = 0;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism303dac_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &watermark);
@ -896,12 +897,12 @@ ssize_t ism303dac_sysfs_flush_fifo(struct device *dev,
{
u64 event_type;
int64_t sensor_last_timestamp;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism303dac_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (ism303dac_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
disable_irq(sdata->cdata->irq);
} else {
mutex_unlock(&indio_dev->mlock);
@ -945,7 +946,7 @@ static ssize_t ism303dac_get_selftest_status(struct device *dev,
char *buf)
{
u8 status;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism303dac_sensor_data *sdata = iio_priv(indio_dev);
status = sdata->cdata->selftest_status;
@ -957,7 +958,7 @@ static ssize_t ism303dac_set_selftest_status(struct device *dev,
const char *buf, size_t size)
{
int err, i;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism303dac_sensor_data *sdata = iio_priv(indio_dev);
for (i = 0; i < ARRAY_SIZE(ism303dac_selftest_table); i++) {

12
drivers/iio/stm/accel/st_ism303dac_accel_i2c.c
View File

@ -103,6 +103,16 @@ static int ism303dac_i2c_probe(struct i2c_client *client,
return err;
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void ism303dac_i2c_remove(struct i2c_client *client)
{
struct ism303dac_data *cdata = i2c_get_clientdata(client);
ism303dac_common_remove(cdata, client->irq);
dev_info(cdata->dev, "%s: removed\n", ISM303DAC_DEV_NAME);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int ism303dac_i2c_remove(struct i2c_client *client)
{
struct ism303dac_data *cdata = i2c_get_clientdata(client);
@ -110,8 +120,10 @@ static int ism303dac_i2c_remove(struct i2c_client *client)
ism303dac_common_remove(cdata, client->irq);
dev_info(cdata->dev, "%s: removed\n", ISM303DAC_DEV_NAME);
kfree(cdata);
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused ism303dac_suspend(struct device *dev)

11
drivers/iio/stm/accel/st_ism303dac_accel_spi.c
View File

@ -120,6 +120,16 @@ static int ism303dac_spi_probe(struct spi_device *spi)
return err;
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void ism303dac_spi_remove(struct spi_device *spi)
{
struct ism303dac_data *cdata = spi_get_drvdata(spi);
ism303dac_common_remove(cdata, spi->irq);
dev_info(cdata->dev, "%s: removed\n", ISM303DAC_DEV_NAME);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int ism303dac_spi_remove(struct spi_device *spi)
{
struct ism303dac_data *cdata = spi_get_drvdata(spi);
@ -130,6 +140,7 @@ static int ism303dac_spi_remove(struct spi_device *spi)
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused ism303dac_suspend(struct device *dev)

18
drivers/iio/stm/accel/st_lis2ds12.h
View File

@ -14,6 +14,11 @@
#include <linux/iio/iio.h>
#include <linux/iio/trigger.h>
#include <linux/platform_data/stm/lis2ds12.h>
#include <linux/version.h>
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
#include <linux/iio/iio-opaque.h>
#endif /* LINUX_VERSION_CODE */
#define LIS2DS12_WHO_AM_I_ADDR 0x0f
#define LIS2DS12_WHO_AM_I_DEF 0x43
@ -312,6 +317,19 @@ static inline s64 lis2ds12_get_time_ns(struct iio_dev *iio_dev)
return iio_get_time_ns(iio_dev);
}
static inline int lis2ds12_iio_dev_currentmode(struct iio_dev *indio_dev)
{
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
struct iio_dev_opaque *iio_opq = to_iio_dev_opaque(indio_dev);
return iio_opq->currentmode;
#else /* LINUX_VERSION_CODE */
return indio_dev->currentmode;
#endif /* LINUX_VERSION_CODE */
}
int lis2ds12_common_probe(struct lis2ds12_data *cdata, int irq);
#ifdef CONFIG_PM
int lis2ds12_common_suspend(struct lis2ds12_data *cdata);

33
drivers/iio/stm/accel/st_lis2ds12_core.c
View File

@ -22,6 +22,7 @@
#include <linux/delay.h>
#include <linux/iio/buffer.h>
#include <linux/iio/events.h>
#include <linux/of_device.h>
#include <asm/unaligned.h>
#include "st_lis2ds12.h"
@ -822,7 +823,7 @@ static ssize_t lis2ds12_get_sampling_frequency(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct lis2ds12_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lis2ds12_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sdata->odr);
}
@ -834,7 +835,7 @@ ssize_t lis2ds12_set_sampling_frequency(struct device * dev,
int err;
u8 power_mode;
unsigned int odr, i;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2ds12_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &odr);
@ -866,7 +867,7 @@ static ssize_t lis2ds12_get_sampling_frequency_avail(struct device *dev,
*attr, char *buf)
{
int i, len = 0, mode_count, mode;
struct lis2ds12_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lis2ds12_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
mode = sdata->cdata->power_mode;
mode_count = (mode == LIS2DS12_LP_MODE) ?
@ -906,7 +907,7 @@ static int lis2ds12_read_raw(struct iio_dev *indio_dev,
switch (mask) {
case IIO_CHAN_INFO_RAW:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (lis2ds12_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -960,7 +961,7 @@ static int lis2ds12_write_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_SCALE:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (lis2ds12_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -985,7 +986,7 @@ static int lis2ds12_write_raw(struct iio_dev *indio_dev,
static ssize_t lis2ds12_sysfs_get_hwfifo_enabled(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2ds12_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n", sdata->cdata->hwfifo_enabled);
@ -996,7 +997,7 @@ ssize_t lis2ds12_sysfs_set_hwfifo_enabled(struct device *dev,
{
int err = 0, enable = 0;
u8 mode = BYPASS;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2ds12_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &enable);
@ -1020,7 +1021,7 @@ ssize_t lis2ds12_sysfs_set_hwfifo_enabled(struct device *dev,
static ssize_t lis2ds12_sysfs_get_hwfifo_watermark(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2ds12_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n", sdata->cdata->hwfifo_watermark);
@ -1030,7 +1031,7 @@ ssize_t lis2ds12_sysfs_set_hwfifo_watermark(struct device * dev,
struct device_attribute * attr, const char *buf, size_t count)
{
int err = 0, watermark = 0;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2ds12_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &watermark);
@ -1068,12 +1069,12 @@ ssize_t lis2ds12_sysfs_flush_fifo(struct device *dev,
{
u64 event_type;
int64_t sensor_last_timestamp;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2ds12_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (lis2ds12_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
disable_irq(sdata->cdata->irq);
} else {
mutex_unlock(&indio_dev->mlock);
@ -1106,7 +1107,7 @@ ssize_t lis2ds12_sysfs_flush_fifo(struct device *dev,
ssize_t lis2ds12_reset_step_counter(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2ds12_sensor_data *sdata = iio_priv(indio_dev);
return lis2ds12_write_register(sdata->cdata,
@ -1121,7 +1122,7 @@ static ssize_t lis2ds12_sysfs_set_max_delivery_rate(struct device *dev,
u8 duration;
int err;
unsigned int max_delivery_rate;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2ds12_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtouint(buf, 10, &max_delivery_rate);
@ -1146,7 +1147,7 @@ static ssize_t lis2ds12_sysfs_set_max_delivery_rate(struct device *dev,
static ssize_t lis2ds12_sysfs_get_max_delivery_rate(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2ds12_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n", sdata->odr);
@ -1164,7 +1165,7 @@ static ssize_t lis2ds12_get_selftest_status(struct device *dev,
struct device_attribute *attr, char *buf)
{
u8 status;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2ds12_sensor_data *sdata = iio_priv(indio_dev);
status = sdata->cdata->selftest_status;
@ -1176,7 +1177,7 @@ static ssize_t lis2ds12_set_selftest_status(struct device *dev,
const char *buf, size_t size)
{
int err, i;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2ds12_sensor_data *sdata = iio_priv(indio_dev);
for (i = 0; i < ARRAY_SIZE(lis2ds12_selftest_table); i++) {

12
drivers/iio/stm/accel/st_lis2ds12_i2c.c
View File

@ -106,6 +106,16 @@ static int lis2ds12_i2c_probe(struct i2c_client *client,
return err;
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void lis2ds12_i2c_remove(struct i2c_client *client)
{
struct lis2ds12_data *cdata = i2c_get_clientdata(client);
lis2ds12_common_remove(cdata, client->irq);
dev_info(cdata->dev, "%s: removed\n", LIS2DS12_DEV_NAME);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int lis2ds12_i2c_remove(struct i2c_client *client)
{
struct lis2ds12_data *cdata = i2c_get_clientdata(client);
@ -113,8 +123,10 @@ static int lis2ds12_i2c_remove(struct i2c_client *client)
lis2ds12_common_remove(cdata, client->irq);
dev_info(cdata->dev, "%s: removed\n", LIS2DS12_DEV_NAME);
kfree(cdata);
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused lis2ds12_suspend(struct device *dev)

11
drivers/iio/stm/accel/st_lis2ds12_spi.c
View File

@ -120,6 +120,16 @@ static int lis2ds12_spi_probe(struct spi_device *spi)
return err;
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void lis2ds12_spi_remove(struct spi_device *spi)
{
struct lis2ds12_data *cdata = spi_get_drvdata(spi);
lis2ds12_common_remove(cdata, spi->irq);
dev_info(cdata->dev, "%s: removed\n", LIS2DS12_DEV_NAME);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int lis2ds12_spi_remove(struct spi_device *spi)
{
struct lis2ds12_data *cdata = spi_get_drvdata(spi);
@ -130,6 +140,7 @@ static int lis2ds12_spi_remove(struct spi_device *spi)
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused lis2ds12_suspend(struct device *dev)

2
drivers/iio/stm/accel/st_lis2ds12_trigger.c
View File

@ -80,7 +80,7 @@ static irqreturn_t lis2ds12_irq_handler(int irq, void *private)
{
u8 ewma_level;
struct lis2ds12_data *cdata = private;
struct iio_dev *iio_dev = dev_get_drvdata(cdata->dev);
struct iio_dev *iio_dev = dev_to_iio_dev(cdata->dev);
s64 ts;
ewma_level = (cdata->common_odr >= 100) ? 120 : 96;

19
drivers/iio/stm/accel/st_lis2duxs12_basicfunc.c
View File

@ -458,7 +458,7 @@ ssize_t st_lis2duxs12_wakeup_threshold_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[0]);
}
@ -467,7 +467,7 @@ ssize_t st_lis2duxs12_wakeup_threshold_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2duxs12_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -495,7 +495,7 @@ ssize_t st_lis2duxs12_wakeup_duration_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[1]);
}
@ -505,7 +505,7 @@ st_lis2duxs12_wakeup_duration_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2duxs12_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -533,7 +533,7 @@ ssize_t st_lis2duxs12_freefall_threshold_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[2]);
}
@ -542,7 +542,7 @@ ssize_t st_lis2duxs12_freefall_threshold_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2duxs12_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -570,7 +570,7 @@ ssize_t st_lis2duxs12_6D_threshold_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[3]);
}
@ -579,7 +579,7 @@ ssize_t st_lis2duxs12_6D_threshold_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2duxs12_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -1048,11 +1048,12 @@ int st_lis2duxs12_probe_basicfunc(struct st_lis2duxs12_hw *hw)
iio_trigger_set_drvdata(sensor->trig, iio_dev);
sensor->trig->ops = &st_lis2duxs12_trigger_ops;
sensor->trig->dev.parent = hw->dev;
iio_dev->trig = iio_trigger_get(sensor->trig);
err = devm_iio_trigger_register(hw->dev, sensor->trig);
if (err)
return err;
iio_dev->trig = iio_trigger_get(sensor->trig);
}
err = st_lis2duxs12_init_tap(hw);

15
drivers/iio/stm/accel/st_lis2duxs12_buffer.c
View File

@ -332,7 +332,7 @@ ssize_t st_lis2duxs12_get_max_watermark(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2duxs12_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%d\n", sensor->max_watermark);
@ -342,7 +342,7 @@ ssize_t st_lis2duxs12_get_watermark(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2duxs12_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%d\n", sensor->watermark);
@ -352,7 +352,7 @@ ssize_t st_lis2duxs12_set_watermark(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2duxs12_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -380,7 +380,7 @@ ssize_t st_lis2duxs12_flush_fifo(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2duxs12_sensor *sensor = iio_priv(iio_dev);
struct st_lis2duxs12_hw *hw = sensor->hw;
s64 type, event, fts, ts;
@ -721,7 +721,12 @@ int st_lis2duxs12_buffers_setup(struct st_lis2duxs12_hw *hw)
if (!hw->iio_devs[id])
continue;
#if KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[id],
&st_lis2duxs12_fifo_ops);
if (err)
return err;
#elif KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[id],
INDIO_BUFFER_SOFTWARE,
&st_lis2duxs12_fifo_ops);

20
drivers/iio/stm/accel/st_lis2duxs12_core.c
View File

@ -715,7 +715,7 @@ st_lis2duxs12_sysfs_sampling_frequency_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_lis2duxs12_sensor_id id = sensor->id;
int i, len = 0;
@ -735,7 +735,7 @@ st_lis2duxs12_sysfs_scale_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_lis2duxs12_sensor_id id = sensor->id;
int i, len = 0;
@ -768,7 +768,7 @@ ssize_t st_lis2duxs12_get_power_mode(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2duxs12_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%s\n",
@ -779,7 +779,7 @@ ssize_t st_lis2duxs12_set_power_mode(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2duxs12_sensor *sensor = iio_priv(iio_dev);
int err, i;
@ -890,7 +890,7 @@ st_lis2duxs12_sysfs_get_selftest_status(struct device *dev,
{
int8_t result;
char *message;
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_lis2duxs12_sensor_id id = sensor->id;
if (id != ST_LIS2DUXS12_ID_ACC)
@ -901,7 +901,7 @@ st_lis2duxs12_sysfs_get_selftest_status(struct device *dev,
message = "na";
else if (result < 0)
message = "fail";
else if (result > 0)
else
message = "pass";
return sprintf(buf, "%s\n", message);
@ -928,6 +928,8 @@ st_lis2duxs12_selftest_sensor(struct st_lis2duxs12_sensor *sensor,
/* wait 25 ms for stable output */
msleep(25);
odr = sensor->odr;
uodr = sensor->uodr;
if (mode == 1) {
ret = st_lis2duxs12_update_bits_locked(sensor->hw,
ST_LIS2DUXS12_CTRL3_ADDR,
@ -960,8 +962,6 @@ st_lis2duxs12_selftest_sensor(struct st_lis2duxs12_sensor *sensor,
if (ret < 0)
goto selftest_stop;
odr = sensor->odr;
uodr = sensor->uodr;
sensor->odr = 200;
sensor->uodr = 0;
@ -1030,7 +1030,7 @@ st_lis2duxs12_sysfs_start_selftest(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2duxs12_sensor *sensor = iio_priv(iio_dev);
struct st_lis2duxs12_hw *hw = sensor->hw;
int ret, mode;
@ -1080,7 +1080,7 @@ st_lis2duxs12_sysfs_reset_step_counter(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
int err;
err = st_lis2duxs12_reset_step_counter(iio_dev);

8
drivers/iio/stm/accel/st_lis2duxs12_i2c.c
View File

@ -12,6 +12,7 @@
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/version.h>
#include "st_lis2duxs12.h"
@ -38,10 +39,17 @@ static int st_lis2duxs12_i2c_probe(struct i2c_client *client,
return st_lis2duxs12_probe(&client->dev, client->irq, hw_id, regmap);
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void st_lis2duxs12_i2c_remove(struct i2c_client *client)
{
st_lis2duxs12_remove(&client->dev);
}
#else /* LINUX_VERSION_CODE */
static int st_lis2duxs12_i2c_remove(struct i2c_client *client)
{
return st_lis2duxs12_remove(&client->dev);
}
#endif /* LINUX_VERSION_CODE */
static const struct of_device_id st_lis2duxs12_i2c_of_match[] = {
{

10
drivers/iio/stm/accel/st_lis2duxs12_mlc.c
View File

@ -479,7 +479,7 @@ static ssize_t st_lis2duxs12_mlc_info(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lis2duxs12_hw *hw = sensor->hw;
return scnprintf(buf, PAGE_SIZE, "mlc %02x fsm %02x\n",
@ -499,7 +499,7 @@ static ssize_t st_lis2duxs12_mlc_flush(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lis2duxs12_hw *hw = sensor->hw;
int ret;
@ -513,7 +513,7 @@ static ssize_t st_lis2duxs12_mlc_upload(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
int err;
err = request_firmware_nowait(THIS_MODULE, true,
@ -529,7 +529,7 @@ static ssize_t st_lis2duxs12_mlc_odr(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lis2duxs12_hw *hw = sensor->hw;
return scnprintf(buf, PAGE_SIZE, "%d\n", hw->mlc_config->requested_odr);
@ -566,7 +566,7 @@ static ssize_t st_lis2duxs12_mlc_x_odr(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lis2duxs12_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return scnprintf(buf, PAGE_SIZE, "%d.%02d\n",
sensor->odr, sensor->uodr);

2
drivers/iio/stm/accel/st_lis2duxs12_qvar.c
View File

@ -42,7 +42,7 @@ st_lis2duxs12_sysfs_qvar_sampling_freq_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2duxs12_sensor *sensor = iio_priv(iio_dev);
struct st_lis2duxs12_hw *hw = sensor->hw;
int len = 0;

8
drivers/iio/stm/accel/st_lis2duxs12_spi.c
View File

@ -12,6 +12,7 @@
#include <linux/spi/spi.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/version.h>
#include "st_lis2duxs12.h"
@ -38,10 +39,17 @@ static int st_lis2duxs12_spi_probe(struct spi_device *spi)
return st_lis2duxs12_probe(&spi->dev, spi->irq, hw_id, regmap);
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void st_lis2duxs12_spi_remove(struct spi_device *spi)
{
st_lis2duxs12_remove(&spi->dev);
}
#else /* LINUX_VERSION_CODE */
static int st_lis2duxs12_spi_remove(struct spi_device *spi)
{
return st_lis2duxs12_remove(&spi->dev);
}
#endif /* LINUX_VERSION_CODE */
static const struct of_device_id st_lis2duxs12_spi_of_match[] = {
{

1
drivers/iio/stm/accel/st_lis2dw12.h
View File

@ -13,6 +13,7 @@
#include <linux/device.h>
#include <linux/iio/events.h>
#include <linux/iio/iio.h>
#include <linux/of_device.h>
#define ST_LIS2DW12_DEV_NAME "lis2dw12"
#define ST_IIS2DLPC_DEV_NAME "iis2dlpc"

11
drivers/iio/stm/accel/st_lis2dw12_buffer.c
View File

@ -88,7 +88,7 @@ ssize_t st_lis2dw12_set_hwfifo_watermark(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2dw12_sensor *sensor = iio_priv(iio_dev);
struct st_lis2dw12_hw *hw = sensor->hw;
int err, val;
@ -182,7 +182,7 @@ ssize_t st_lis2dw12_flush_fifo(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2dw12_sensor *sensor = iio_priv(iio_dev);
struct st_lis2dw12_hw *hw = sensor->hw;
s64 code;
@ -307,7 +307,12 @@ int st_lis2dw12_fifo_setup(struct st_lis2dw12_hw *hw)
return ret;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,13,0)
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
ret = devm_iio_kfifo_buffer_setup(hw->dev, iio_dev,
&st_lis2dw12_acc_buffer_setup_ops);
if (ret)
return ret;
#elif KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
ret = devm_iio_kfifo_buffer_setup(hw->dev, iio_dev,
INDIO_BUFFER_SOFTWARE,
&st_lis2dw12_acc_buffer_setup_ops);

6
drivers/iio/stm/accel/st_lis2dw12_core.c
View File

@ -691,7 +691,7 @@ static ssize_t st_lis2dw12_get_hwfifo_watermark(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2dw12_sensor *sensor = iio_priv(iio_dev);
struct st_lis2dw12_hw *hw = sensor->hw;
@ -718,7 +718,7 @@ static ssize_t st_lis2dw12_get_selftest_status(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2dw12_sensor *sensor = iio_priv(iio_dev);
struct st_lis2dw12_hw *hw = sensor->hw;
char *ret;
@ -743,7 +743,7 @@ static ssize_t st_lis2dw12_enable_selftest(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lis2dw12_sensor *sensor = iio_priv(iio_dev);
struct st_lis2dw12_hw *hw = sensor->hw;
s16 acc_st_x = 0, acc_st_y = 0, acc_st_z = 0;

18
drivers/iio/stm/accel/st_lis2hh12.h
View File

@ -13,6 +13,11 @@
#include <linux/types.h>
#include <linux/iio/iio.h>
#include <linux/iio/trigger.h>
#include <linux/version.h>
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
#include <linux/iio/iio-opaque.h>
#endif /* LINUX_VERSION_CODE */
#define LIS2HH12_WHO_AM_I_ADDR 0x0f
#define LIS2HH12_WHO_AM_I_DEF 0x41
@ -190,6 +195,19 @@ struct lis2hh12_data {
struct lis2hh12_transfer_buffer tb;
};
static inline int lis2hh12_iio_dev_currentmode(struct iio_dev *indio_dev)
{
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
struct iio_dev_opaque *iio_opq = to_iio_dev_opaque(indio_dev);
return iio_opq->currentmode;
#else /* LINUX_VERSION_CODE */
return indio_dev->currentmode;
#endif /* LINUX_VERSION_CODE */
}
int lis2hh12_common_probe(struct lis2hh12_data *cdata, int irq);
#ifdef CONFIG_PM
int lis2hh12_common_suspend(struct lis2hh12_data *cdata);

23
drivers/iio/stm/accel/st_lis2hh12_core.c
View File

@ -23,6 +23,9 @@
#include <linux/iio/buffer.h>
#include <linux/iio/events.h>
#include <asm/unaligned.h>
#include <linux/of.h>
#include <linux/property.h>
#include "st_lis2hh12.h"
#include <linux/platform_data/stm/lis2hh12.h>
@ -400,7 +403,7 @@ static ssize_t lis2hh12_sysfs_get_sampling_frequency(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct lis2hh12_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lis2hh12_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sdata->odr);
}
@ -411,7 +414,7 @@ ssize_t lis2hh12_sysfs_set_sampling_frequency(struct device * dev,
int err;
u8 mode_count;
unsigned int odr, i;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2hh12_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &odr);
@ -473,12 +476,12 @@ ssize_t lis2hh12_sysfs_flush_fifo(struct device *dev,
{
u64 event_type;
int64_t sensor_last_timestamp;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2hh12_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (lis2hh12_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
disable_irq(sdata->cdata->irq);
} else {
mutex_unlock(&indio_dev->mlock);
@ -507,7 +510,7 @@ ssize_t lis2hh12_sysfs_flush_fifo(struct device *dev,
static ssize_t lis2hh12_sysfs_get_hwfifo_enabled(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2hh12_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n", sdata->cdata->hwfifo_enabled);
@ -518,7 +521,7 @@ ssize_t lis2hh12_sysfs_set_hwfifo_enabled(struct device * dev,
{
int err = 0, enable = 0;
u8 mode = BYPASS;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2hh12_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &enable);
@ -542,7 +545,7 @@ ssize_t lis2hh12_sysfs_set_hwfifo_enabled(struct device * dev,
static ssize_t lis2hh12_sysfs_get_hwfifo_watermark(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2hh12_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n", sdata->cdata->hwfifo_watermark);
@ -552,7 +555,7 @@ ssize_t lis2hh12_sysfs_set_hwfifo_watermark(struct device * dev,
struct device_attribute * attr, const char *buf, size_t count)
{
int err = 0, watermark = 0;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lis2hh12_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &watermark);
@ -594,7 +597,7 @@ static int lis2hh12_read_raw(struct iio_dev *indio_dev,
switch (mask) {
case IIO_CHAN_INFO_RAW:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (lis2hh12_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -649,7 +652,7 @@ static int lis2hh12_write_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_SCALE:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (lis2hh12_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}

12
drivers/iio/stm/accel/st_lis2hh12_i2c.c
View File

@ -86,6 +86,16 @@ static int lis2hh12_i2c_probe(struct i2c_client *client,
return err;
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void lis2hh12_i2c_remove(struct i2c_client *client)
{
struct lis2hh12_data *cdata = i2c_get_clientdata(client);
lis2hh12_common_remove(cdata, client->irq);
dev_info(cdata->dev, "%s: removed\n", LIS2HH12_DEV_NAME);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int lis2hh12_i2c_remove(struct i2c_client *client)
{
struct lis2hh12_data *cdata = i2c_get_clientdata(client);
@ -93,8 +103,10 @@ static int lis2hh12_i2c_remove(struct i2c_client *client)
lis2hh12_common_remove(cdata, client->irq);
dev_info(cdata->dev, "%s: removed\n", LIS2HH12_DEV_NAME);
kfree(cdata);
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused lis2hh12_suspend(struct device *dev)

11
drivers/iio/stm/accel/st_lis2hh12_spi.c
View File

@ -112,6 +112,16 @@ static int lis2hh12_spi_probe(struct spi_device *spi)
return err;
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void lis2hh12_spi_remove(struct spi_device *spi)
{
struct lis2hh12_data *cdata = spi_get_drvdata(spi);
lis2hh12_common_remove(cdata, spi->irq);
dev_info(cdata->dev, "%s: removed\n", LIS2HH12_DEV_NAME);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int lis2hh12_spi_remove(struct spi_device *spi)
{
struct lis2hh12_data *cdata = spi_get_drvdata(spi);
@ -122,6 +132,7 @@ static int lis2hh12_spi_remove(struct spi_device *spi)
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused lis2hh12_suspend(struct device *dev)

13
drivers/iio/stm/accel/st_lis3dhh_buffer.c
View File

@ -101,7 +101,7 @@ ssize_t st_lis3dhh_flush_hwfifo(struct device *device,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(device);
struct iio_dev *iio_dev = dev_to_iio_dev(device);
struct st_lis3dhh_hw *hw = iio_priv(iio_dev);
s64 code;
int err;
@ -125,7 +125,7 @@ ssize_t st_lis3dhh_get_hwfifo_watermark(struct device *device,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(device);
struct iio_dev *iio_dev = dev_to_iio_dev(device);
struct st_lis3dhh_hw *hw = iio_priv(iio_dev);
return sprintf(buf, "%d\n", hw->watermark);
@ -142,7 +142,7 @@ ssize_t st_lis3dhh_set_hwfifo_watermark(struct device *device,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(device);
struct iio_dev *iio_dev = dev_to_iio_dev(device);
struct st_lis3dhh_hw *hw = iio_priv(iio_dev);
int err, val;
@ -262,7 +262,12 @@ int st_lis3dhh_fifo_setup(struct st_lis3dhh_hw *hw)
return ret;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,13,0)
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
ret = devm_iio_kfifo_buffer_setup(hw->dev, iio_dev,
&st_lis3dhh_buffer_ops);
if (ret)
return ret;
#elif KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
ret = devm_iio_kfifo_buffer_setup(hw->dev, iio_dev,
INDIO_BUFFER_SOFTWARE,
&st_lis3dhh_buffer_ops);

2
drivers/iio/stm/imu/st_asm330lhhx/st_asm330lhhx.h
View File

@ -16,6 +16,8 @@
#include <linux/delay.h>
#include <linux/workqueue.h>
#include <linux/hrtimer.h>
#include <linux/of_device.h>
#include <linux/property.h>
#include <linux/regmap.h>
#include <linux/spinlock.h>

15
drivers/iio/stm/imu/st_asm330lhhx/st_asm330lhhx_buffer.c
View File

@ -355,7 +355,7 @@ ssize_t st_asm330lhhx_get_max_watermark(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->max_watermark);
}
@ -364,7 +364,7 @@ ssize_t st_asm330lhhx_get_watermark(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->watermark);
}
@ -373,7 +373,7 @@ ssize_t st_asm330lhhx_set_watermark(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_asm330lhhx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -401,7 +401,7 @@ ssize_t st_asm330lhhx_flush_fifo(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_asm330lhhx_sensor *sensor = iio_priv(iio_dev);
struct st_asm330lhhx_hw *hw = sensor->hw;
s64 event;
@ -650,7 +650,12 @@ int st_asm330lhhx_buffers_setup(struct st_asm330lhhx_hw *hw)
if (!hw->iio_devs[i])
continue;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,13,0)
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[i],
&st_asm330lhhx_fifo_ops);
if (err)
return err;
#elif KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[i],
INDIO_BUFFER_SOFTWARE,
&st_asm330lhhx_fifo_ops);

18
drivers/iio/stm/imu/st_asm330lhhx/st_asm330lhhx_core.c
View File

@ -690,7 +690,7 @@ static ssize_t st_asm330lhhx_sysfs_get_selftest_status(struct device *dev,
{
int8_t result;
char *message = NULL;
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_asm330lhhx_sensor_id id = sensor->id;
if (id != ST_ASM330LHHX_ID_ACC &&
@ -1466,7 +1466,7 @@ st_asm330lhhx_sysfs_sampling_freq_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_asm330lhhx_sensor_id id = sensor->id;
int i, len = 0;
@ -1485,7 +1485,7 @@ static ssize_t st_asm330lhhx_sysfs_scale_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_asm330lhhx_sensor_id id = sensor->id;
int i, len = 0;
@ -1502,7 +1502,7 @@ st_asm330lhhx_sysfs_get_power_mode_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_asm330lhhx_sensor *sensor = iio_priv(iio_dev);
struct st_asm330lhhx_hw *hw = sensor->hw;
int i, len = 0;
@ -1527,7 +1527,7 @@ static ssize_t
st_asm330lhhx_get_power_mode(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_asm330lhhx_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%s\n",
@ -1539,7 +1539,7 @@ st_asm330lhhx_set_power_mode(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_asm330lhhx_sensor *sensor = iio_priv(iio_dev);
struct st_asm330lhhx_hw *hw = sensor->hw;
int err, i;
@ -1727,7 +1727,7 @@ static int st_asm330lhhx_selftest_sensor(struct st_asm330lhhx_sensor *sensor,
static ssize_t st_asm330lhhx_sysfs_start_selftest(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_asm330lhhx_sensor *sensor = iio_priv(iio_dev);
enum st_asm330lhhx_sensor_id id = sensor->id;
struct st_asm330lhhx_hw *hw = sensor->hw;
@ -1806,7 +1806,7 @@ ssize_t st_asm330lhhx_get_module_id(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_asm330lhhx_sensor *sensor = iio_priv(iio_dev);
struct st_asm330lhhx_hw *hw = sensor->hw;
@ -1844,7 +1844,7 @@ static
ssize_t __maybe_unused st_asm330lhhx_get_discharded_samples(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_asm330lhhx_sensor *sensor = iio_priv(iio_dev);
int ret;

21
drivers/iio/stm/imu/st_asm330lhhx/st_asm330lhhx_events.c
View File

@ -174,7 +174,7 @@ ssize_t st_asm330lhhx_wakeup_threshold_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[0]);
}
@ -183,7 +183,7 @@ ssize_t st_asm330lhhx_wakeup_threshold_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_asm330lhhx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -211,7 +211,7 @@ ssize_t st_asm330lhhx_wakeup_duration_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[1]);
}
@ -220,7 +220,7 @@ ssize_t st_asm330lhhx_wakeup_duration_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_asm330lhhx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -248,7 +248,7 @@ ssize_t st_asm330lhhx_freefall_threshold_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[2]);
}
@ -257,7 +257,7 @@ ssize_t st_asm330lhhx_freefall_threshold_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_asm330lhhx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -285,7 +285,7 @@ ssize_t st_asm330lhhx_6D_threshold_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[3]);
}
@ -294,7 +294,7 @@ ssize_t st_asm330lhhx_6D_threshold_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_asm330lhhx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -609,14 +609,15 @@ int st_asm330lhhx_probe_event(struct st_asm330lhhx_hw *hw)
if (!sensor->trig)
return -ENOMEM;
iio_trigger_set_drvdata(sensor->trig, iio_dev);
sensor->trig->ops = &st_asm330lhhx_trigger_ops;
sensor->trig->dev.parent = hw->dev;
iio_dev->trig = iio_trigger_get(sensor->trig);
iio_trigger_set_drvdata(sensor->trig, iio_dev);
err = devm_iio_trigger_register(hw->dev, sensor->trig);
if (err)
return err;
iio_dev->trig = iio_trigger_get(sensor->trig);
}
for (i = ST_ASM330LHHX_ID_EVENT; i < ST_ASM330LHHX_ID_MAX; i++) {

6
drivers/iio/stm/imu/st_asm330lhhx/st_asm330lhhx_mlc.c
View File

@ -607,7 +607,7 @@ static ssize_t st_asm330lhhx_mlc_info(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_asm330lhhx_hw *hw = sensor->hw;
return scnprintf(buf, PAGE_SIZE, "mlc %02x fsm %02x\n",
@ -629,7 +629,7 @@ st_asm330lhhx_mlc_upload_firmware(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
int err;
err = request_firmware_nowait(THIS_MODULE, true,
@ -645,7 +645,7 @@ static ssize_t st_asm330lhhx_mlc_flush(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_asm330lhhx_hw *hw = sensor->hw;
int ret;

4
drivers/iio/stm/imu/st_asm330lhhx/st_asm330lhhx_shub.c
View File

@ -855,7 +855,7 @@ st_asm330lhhx_sysfs_shub_sampling_freq_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_asm330lhhx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_asm330lhhx_ext_dev_info *ext_info = &sensor->ext_dev_info;
int i, len = 0;
@ -887,7 +887,7 @@ st_asm330lhhx_sysfs_shub_scale_avail(struct device *dev,
char *buf)
{
struct st_asm330lhhx_sensor *sensor =
iio_priv(dev_get_drvdata(dev));
iio_priv(dev_to_iio_dev(dev));
struct st_asm330lhhx_ext_dev_info *ext_info = &sensor->ext_dev_info;
int i, len = 0;

2
drivers/iio/stm/imu/st_imu68/st_imu68.h
View File

@ -11,6 +11,8 @@
#define ST_IMU68_H
#include <linux/device.h>
#include <linux/of_device.h>
#include <linux/version.h>
#define ST_LSM9DS1_DEV_NAME "lsm9ds1"

10
drivers/iio/stm/imu/st_imu68/st_imu68_core.c
View File

@ -277,7 +277,7 @@ st_imu68_sysfs_sampling_frequency_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_imu68_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_imu68_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_imu68_sensor_id id = sensor->id;
int i, len = 0;
@ -293,7 +293,7 @@ static ssize_t st_imu68_sysfs_scale_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_imu68_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_imu68_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_imu68_sensor_id id = sensor->id;
int i, len = 0;
@ -438,7 +438,7 @@ static ssize_t st_imu68_get_sampling_frequency(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_imu68_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_imu68_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->odr);
}
@ -447,7 +447,7 @@ static ssize_t st_imu68_set_sampling_frequency(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct st_imu68_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_imu68_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
int err, odr;
err = kstrtoint(buf, 10, &odr);
@ -463,7 +463,7 @@ ssize_t st_imu68_get_module_id(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_imu68_sensor *sensor = iio_priv(iio_dev);
struct st_imu68_hw *hw = sensor->hw;

7
drivers/iio/stm/imu/st_imu68/st_imu68_i2c.c
View File

@ -39,12 +39,19 @@ static int st_imu68_i2c_probe(struct i2c_client *client,
&st_imu68_transfer_fn);
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void st_imu68_i2c_remove(struct i2c_client *client)
{
st_imu68_remove(&client->dev);
}
#else /* LINUX_VERSION_CODE */
static int st_imu68_i2c_remove(struct i2c_client *client)
{
st_imu68_remove(&client->dev);
return 0;
}
#endif /* LINUX_VERSION_CODE */
static const struct of_device_id st_imu68_i2c_of_match[] = {
{

7
drivers/iio/stm/imu/st_imu68/st_imu68_spi.c
View File

@ -75,12 +75,19 @@ static int st_imu68_spi_probe(struct spi_device *spi)
&st_imu68_transfer_fn);
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void st_imu68_spi_remove(struct spi_device *spi)
{
st_imu68_remove(&spi->dev);
}
#else /* LINUX_VERSION_CODE */
static int st_imu68_spi_remove(struct spi_device *spi)
{
st_imu68_remove(&spi->dev);
return 0;
}
#endif /* LINUX_VERSION_CODE */
static const struct of_device_id st_imu68_spi_of_match[] = {
{

1
drivers/iio/stm/imu/st_ism330dhcx/st_ism330dhcx.h
View File

@ -12,6 +12,7 @@
#include <linux/device.h>
#include <linux/iio/iio.h>
#include <linux/of_device.h>
#include <linux/delay.h>
#define ST_ISM330DHCX_MAX_ODR 833

25
drivers/iio/stm/imu/st_ism330dhcx/st_ism330dhcx_buffer.c
View File

@ -442,7 +442,7 @@ ssize_t st_ism330dhcx_get_max_watermark(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_ism330dhcx_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%d\n", sensor->max_watermark);
@ -460,7 +460,7 @@ ssize_t st_ism330dhcx_get_watermark(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_ism330dhcx_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%d\n", sensor->watermark);
@ -479,7 +479,7 @@ ssize_t st_ism330dhcx_set_watermark(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_ism330dhcx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -518,7 +518,7 @@ ssize_t st_ism330dhcx_flush_fifo(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_ism330dhcx_sensor *sensor = iio_priv(iio_dev);
struct st_ism330dhcx_hw *hw = sensor->hw;
s64 type;
@ -978,7 +978,12 @@ int st_ism330dhcx_buffers_setup(struct st_ism330dhcx_hw *hw)
if (!hw->iio_devs[i])
continue;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,13,0)
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[i],
&st_ism330dhcx_fifo_ops);
if (err)
return err;
#elif KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[i],
INDIO_BUFFER_SOFTWARE,
&st_ism330dhcx_fifo_ops);
@ -1017,7 +1022,15 @@ int st_ism330dhcx_buffers_setup(struct st_ism330dhcx_hw *hw)
iio_trigger_set_drvdata(sensor->trig, iio_dev);
sensor->trig->ops = &st_ism330dhcx_trigger_ops;
sensor->trig->dev.parent = hw->dev;
err = devm_iio_trigger_register(hw->dev, sensor->trig);
if (err < 0) {
dev_err(hw->dev, "failed to register iio trigger.\n");
return err;
}
iio_dev->trig = iio_trigger_get(sensor->trig);
return devm_iio_trigger_register(hw->dev, sensor->trig);
return 0;
}

9
drivers/iio/stm/imu/st_ism330dhcx/st_ism330dhcx_core.c
View File

@ -852,6 +852,7 @@ static int st_ism330dhcx_write_raw(struct iio_dev *iio_dev,
break;
err = st_ism330dhcx_update_batching(iio_dev, 1);
break;
default:
break;
}
@ -951,7 +952,7 @@ st_ism330dhcx_sysfs_sampling_frequency_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_ism330dhcx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_ism330dhcx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_ism330dhcx_sensor_id id = sensor->id;
int i, len = 0;
@ -987,7 +988,7 @@ static ssize_t st_ism330dhcx_sysfs_scale_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_ism330dhcx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_ism330dhcx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_ism330dhcx_sensor_id id = sensor->id;
int i, len = 0;
@ -1013,7 +1014,7 @@ st_ism330dhcx_sysfs_reset_step_counter(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
int err;
err = st_ism330dhcx_reset_step_counter(iio_dev);
@ -1044,7 +1045,7 @@ ssize_t st_ism330dhcx_get_module_id(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_ism330dhcx_sensor *sensor = iio_priv(iio_dev);
struct st_ism330dhcx_hw *hw = sensor->hw;

4
drivers/iio/stm/imu/st_ism330dhcx/st_ism330dhcx_shub.c
View File

@ -765,7 +765,7 @@ st_ism330dhcx_sysfs_shub_sampling_freq_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_ism330dhcx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_ism330dhcx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_ism330dhcx_ext_dev_info *ext_info = &sensor->ext_dev_info;
int i, len = 0;
@ -795,7 +795,7 @@ static ssize_t st_ism330dhcx_sysfs_shub_scale_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_ism330dhcx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_ism330dhcx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_ism330dhcx_ext_dev_info *ext_info = &sensor->ext_dev_info;
int i, len = 0;

18
drivers/iio/stm/imu/st_ism330dlc/st_ism330dlc.h
View File

@ -12,6 +12,11 @@
#include <linux/types.h>
#include <linux/iio/trigger.h>
#include <linux/version.h>
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
#include <linux/iio/iio-opaque.h>
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_ST_ISM330DLC_IIO_MASTER_SUPPORT
#include <linux/i2c.h>
@ -356,4 +361,17 @@ static inline int st_ism330dlc_i2c_master_exit(struct ism330dlc_data *cdata)
}
#endif /* CONFIG_ST_ISM330DLC_IIO_MASTER_SUPPORT */
static inline int st_ism330dlc_iio_dev_currentmode(struct iio_dev *indio_dev)
{
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
struct iio_dev_opaque *iio_opq = to_iio_dev_opaque(indio_dev);
return iio_opq->currentmode;
#else /* LINUX_VERSION_CODE */
return indio_dev->currentmode;
#endif /* LINUX_VERSION_CODE */
}
#endif /* ST_ISM330DLC_H */

38
drivers/iio/stm/imu/st_ism330dlc/st_ism330dlc_core.c
View File

@ -1633,7 +1633,7 @@ static int st_ism330dlc_read_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_RAW:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_ism330dlc_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -1693,7 +1693,7 @@ static int st_ism330dlc_write_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_SCALE:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_ism330dlc_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -1774,7 +1774,7 @@ static int st_ism330dlc_set_selftest(struct ism330dlc_sensor_data *sdata, int in
static ssize_t st_ism330dlc_sysfs_get_sampling_frequency(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct ism330dlc_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct ism330dlc_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sdata->cdata->v_odr[sdata->sindex]);
}
@ -1784,7 +1784,7 @@ static ssize_t st_ism330dlc_sysfs_set_sampling_frequency(struct device *dev,
{
int err;
unsigned int odr;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &odr);
@ -1834,7 +1834,7 @@ static ssize_t st_ism330dlc_sysfs_scale_avail(struct device *dev,
struct device_attribute *attr, char *buf)
{
int i, len = 0;
struct ism330dlc_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct ism330dlc_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
for (i = 0; i < ST_ISM330DLC_FS_LIST_NUM; i++) {
len += scnprintf(buf + len, PAGE_SIZE - len, "0.%09u ",
@ -1858,7 +1858,7 @@ static ssize_t st_ism330dlc_sysfs_get_selftest_status(struct device *dev,
{
int8_t result;
char *message = NULL;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&sdata->cdata->odr_lock);
@ -1891,7 +1891,7 @@ static ssize_t st_ism330dlc_sysfs_start_selftest_status(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err, i, n;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
u8 reg_status, reg_addr, temp_reg_status, outdata[6];
int x = 0, y = 0, z = 0, x_selftest = 0, y_selftest = 0, z_selftest = 0;
@ -2069,12 +2069,12 @@ ssize_t st_ism330dlc_sysfs_flush_fifo(struct device *dev,
u64 sensor_last_timestamp, event_type = 0;
int stype = 0;
u64 timestamp_flush = 0;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_ism330dlc_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_lock(&sdata->cdata->odr_lock);
disable_irq(sdata->cdata->irq);
} else {
@ -2127,7 +2127,7 @@ ssize_t st_ism330dlc_sysfs_flush_fifo(struct device *dev,
ssize_t st_ism330dlc_sysfs_get_hwfifo_enabled(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n",
@ -2139,11 +2139,11 @@ ssize_t st_ism330dlc_sysfs_set_hwfifo_enabled(struct device *dev,
{
int err;
bool enable = false;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_ism330dlc_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
err = -EBUSY;
goto set_hwfifo_enabled_unlock_mutex;
}
@ -2174,7 +2174,7 @@ ssize_t st_ism330dlc_sysfs_set_hwfifo_enabled(struct device *dev,
ssize_t st_ism330dlc_sysfs_get_hwfifo_watermark(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n",
@ -2185,7 +2185,7 @@ ssize_t st_ism330dlc_sysfs_set_hwfifo_watermark(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err = 0, watermark = 0, old_watermark;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &watermark);
@ -2237,12 +2237,12 @@ static ssize_t st_ism330dlc_sysfs_set_injection_mode(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err, start;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_ism330dlc_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -2306,7 +2306,7 @@ static ssize_t st_ism330dlc_sysfs_set_injection_mode(struct device *dev,
static ssize_t st_ism330dlc_sysfs_get_injection_mode(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n", sdata->cdata->injection_mode);
@ -2318,7 +2318,7 @@ static ssize_t st_ism330dlc_sysfs_upload_xl_data(struct device *dev,
int err, i, n = 1;
s64 timestamp, deltatime;
u8 sample[3], current_odr;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
@ -2397,7 +2397,7 @@ ssize_t st_ism330dlc_get_module_id(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
struct ism330dlc_data *cdata = sdata->cdata;

10
drivers/iio/stm/imu/st_ism330dlc/st_ism330dlc_i2c.c
View File

@ -111,6 +111,15 @@ static int st_ism330dlc_i2c_probe(struct i2c_client *client,
return err;
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void st_ism330dlc_i2c_remove(struct i2c_client *client)
{
struct ism330dlc_data *cdata = i2c_get_clientdata(client);
st_ism330dlc_common_remove(cdata, client->irq);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int st_ism330dlc_i2c_remove(struct i2c_client *client)
{
struct ism330dlc_data *cdata = i2c_get_clientdata(client);
@ -120,6 +129,7 @@ static int st_ism330dlc_i2c_remove(struct i2c_client *client)
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused st_ism330dlc_suspend(struct device *dev)

10
drivers/iio/stm/imu/st_ism330dlc/st_ism330dlc_i2c_master.c
View File

@ -388,7 +388,7 @@ static ssize_t st_ism330dlc_i2c_master_sysfs_sampling_frequency_avail(
static ssize_t st_ism330dlc_i2c_master_sysfs_get_sampling_frequency(
struct device *dev, struct device_attribute *attr, char *buf)
{
struct ism330dlc_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct ism330dlc_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sdata->cdata->v_odr[sdata->sindex]);
}
@ -399,7 +399,7 @@ static ssize_t st_ism330dlc_i2c_master_sysfs_set_sampling_frequency(
{
int err;
unsigned int odr;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &odr);
@ -855,7 +855,7 @@ static ssize_t st_ism330dlc_i2c_master_sysfs_get_selftest_status(
{
int8_t result;
char *message = NULL;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&sdata->cdata->odr_lock);
@ -886,7 +886,7 @@ static ssize_t st_ism330dlc_i2c_master_sysfs_start_selftest(struct device *dev,
#ifdef ST_ISM330DLC_EXT0_IS_AKM
u8 temp, sh_config[3], timeout = 0;
#endif /* ST_ISM330DLC_EXT0_IS_AKM */
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct ism330dlc_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&sdata->cdata->odr_lock);
@ -1332,7 +1332,7 @@ static int st_ism330dlc_i2c_master_read_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_RAW:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_ism330dlc_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}

10
drivers/iio/stm/imu/st_ism330dlc/st_ism330dlc_spi.c
View File

@ -123,6 +123,15 @@ static int st_ism330dlc_spi_probe(struct spi_device *spi)
return err;
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void st_ism330dlc_spi_remove(struct spi_device *spi)
{
struct ism330dlc_data *cdata = spi_get_drvdata(spi);
st_ism330dlc_common_remove(cdata, spi->irq);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int st_ism330dlc_spi_remove(struct spi_device *spi)
{
struct ism330dlc_data *cdata = spi_get_drvdata(spi);
@ -132,6 +141,7 @@ static int st_ism330dlc_spi_remove(struct spi_device *spi)
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused st_ism330dlc_suspend(struct device *dev)

18
drivers/iio/stm/imu/st_lsm6ds3/st_lsm6ds3.h
View File

@ -12,6 +12,11 @@
#include <linux/types.h>
#include <linux/iio/trigger.h>
#include <linux/version.h>
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
#include <linux/iio/iio-opaque.h>
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_ST_LSM6DS3_IIO_MASTER_SUPPORT
#include <linux/i2c.h>
@ -373,4 +378,17 @@ static inline int st_lsm6ds3_i2c_master_exit(struct lsm6ds3_data *cdata)
}
#endif /* CONFIG_ST_LSM6DS3_IIO_MASTER_SUPPORT */
static inline int st_lsm6ds3_iio_dev_currentmode(struct iio_dev *indio_dev)
{
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
struct iio_dev_opaque *iio_opq = to_iio_dev_opaque(indio_dev);
return iio_opq->currentmode;
#else /* LINUX_VERSION_CODE */
return indio_dev->currentmode;
#endif /* LINUX_VERSION_CODE */
}
#endif /* ST_LSM6DS3_H */

44
drivers/iio/stm/imu/st_lsm6ds3/st_lsm6ds3_core.c
View File

@ -1755,7 +1755,7 @@ static int st_lsm6ds3_read_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_RAW:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6ds3_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -1814,7 +1814,7 @@ static int st_lsm6ds3_write_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_SCALE:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6ds3_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -1952,7 +1952,7 @@ static ssize_t st_lsm6ds3_sysfs_set_max_delivery_rate(struct device *dev,
u8 duration;
int err;
unsigned int max_delivery_rate;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtouint(buf, 10, &max_delivery_rate);
@ -1978,7 +1978,7 @@ static ssize_t st_lsm6ds3_sysfs_set_max_delivery_rate(struct device *dev,
static ssize_t st_lsm6ds3_sysfs_get_max_delivery_rate(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct lsm6ds3_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6ds3_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n",
sdata->cdata->v_odr[ST_MASK_ID_STEP_COUNTER]);
@ -1988,7 +1988,7 @@ static ssize_t st_lsm6ds3_sysfs_reset_counter(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err;
struct lsm6ds3_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6ds3_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
err = st_lsm6ds3_reset_steps(sdata->cdata);
if (err < 0)
@ -2000,7 +2000,7 @@ static ssize_t st_lsm6ds3_sysfs_reset_counter(struct device *dev,
static ssize_t st_lsm6ds3_sysfs_get_sampling_frequency(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct lsm6ds3_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6ds3_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sdata->cdata->v_odr[sdata->sindex]);
}
@ -2010,7 +2010,7 @@ static ssize_t st_lsm6ds3_sysfs_set_sampling_frequency(struct device *dev,
{
int err;
unsigned int odr;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &odr);
@ -2059,7 +2059,7 @@ static ssize_t st_lsm6ds3_sysfs_scale_avail(struct device *dev,
struct device_attribute *attr, char *buf)
{
int i, len = 0;
struct lsm6ds3_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6ds3_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
for (i = 0; i < ST_LSM6DS3_FS_LIST_NUM; i++) {
len += scnprintf(buf + len, PAGE_SIZE - len, "0.%09u ",
@ -2083,7 +2083,7 @@ static ssize_t st_lsm6ds3_sysfs_get_selftest_status(struct device *dev,
{
int8_t result;
char *message = NULL;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&sdata->cdata->odr_lock);
@ -2116,7 +2116,7 @@ static ssize_t st_lsm6ds3_sysfs_start_selftest(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err, i, n;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
u8 reg_status, reg_addr, temp_reg_status, outdata[6];
int x = 0, y = 0, z = 0, x_selftest = 0, y_selftest = 0, z_selftest = 0;
@ -2294,12 +2294,12 @@ ssize_t st_lsm6ds3_sysfs_flush_fifo(struct device *dev,
u64 sensor_last_timestamp, event_type = 0;
int stype = 0;
u64 timestamp_flush = 0;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6ds3_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_lock(&sdata->cdata->odr_lock);
disable_irq(sdata->cdata->irq);
} else {
@ -2352,7 +2352,7 @@ ssize_t st_lsm6ds3_sysfs_flush_fifo(struct device *dev,
ssize_t st_lsm6ds3_sysfs_get_hwfifo_enabled(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n",
@ -2364,7 +2364,7 @@ ssize_t st_lsm6ds3_sysfs_set_hwfifo_enabled(struct device *dev,
{
int err;
bool enable = false;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
if (sdata->cdata->spi_connection) {
@ -2374,7 +2374,7 @@ ssize_t st_lsm6ds3_sysfs_set_hwfifo_enabled(struct device *dev,
}
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6ds3_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
err = -EBUSY;
goto set_hwfifo_enabled_unlock_mutex;
}
@ -2405,7 +2405,7 @@ ssize_t st_lsm6ds3_sysfs_set_hwfifo_enabled(struct device *dev,
ssize_t st_lsm6ds3_sysfs_get_hwfifo_watermark(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n",
@ -2416,7 +2416,7 @@ ssize_t st_lsm6ds3_sysfs_set_hwfifo_watermark(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err = 0, watermark = 0, old_watermark;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &watermark);
@ -2468,12 +2468,12 @@ static ssize_t st_lsm6ds3_sysfs_set_injection_mode(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err, start;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6ds3_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -2550,7 +2550,7 @@ static ssize_t st_lsm6ds3_sysfs_set_injection_mode(struct device *dev,
static ssize_t st_lsm6ds3_sysfs_get_injection_mode(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n", sdata->cdata->injection_mode);
@ -2562,7 +2562,7 @@ static ssize_t st_lsm6ds3_sysfs_upload_xl_data(struct device *dev,
int i;
u8 sample[3];
s64 timestamp;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
@ -2658,7 +2658,7 @@ ssize_t st_lsm6ds3_get_module_id(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
struct lsm6ds3_data *cdata = sdata->cdata;

10
drivers/iio/stm/imu/st_lsm6ds3/st_lsm6ds3_i2c.c
View File

@ -106,6 +106,15 @@ static int st_lsm6ds3_i2c_probe(struct i2c_client *client,
return err;
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void st_lsm6ds3_i2c_remove(struct i2c_client *client)
{
struct lsm6ds3_data *cdata = i2c_get_clientdata(client);
st_lsm6ds3_common_remove(cdata, client->irq);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int st_lsm6ds3_i2c_remove(struct i2c_client *client)
{
struct lsm6ds3_data *cdata = i2c_get_clientdata(client);
@ -115,6 +124,7 @@ static int st_lsm6ds3_i2c_remove(struct i2c_client *client)
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused st_lsm6ds3_suspend(struct device *dev)

10
drivers/iio/stm/imu/st_lsm6ds3/st_lsm6ds3_i2c_master.c
View File

@ -388,7 +388,7 @@ static ssize_t st_lsm6ds3_i2c_master_sysfs_sampling_frequency_avail(
static ssize_t st_lsm6ds3_i2c_master_sysfs_get_sampling_frequency(
struct device *dev, struct device_attribute *attr, char *buf)
{
struct lsm6ds3_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6ds3_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sdata->cdata->v_odr[sdata->sindex]);
}
@ -399,7 +399,7 @@ static ssize_t st_lsm6ds3_i2c_master_sysfs_set_sampling_frequency(
{
int err;
unsigned int odr;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &odr);
@ -856,7 +856,7 @@ static ssize_t st_lsm6ds3_i2c_master_sysfs_get_selftest_status(
{
int8_t result;
char *message = NULL;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&sdata->cdata->odr_lock);
@ -887,7 +887,7 @@ static ssize_t st_lsm6ds3_i2c_master_sysfs_start_selftest(struct device *dev,
#ifdef ST_LSM6DS3_EXT0_IS_AKM
u8 temp, sh_config[3], timeout = 0;
#endif /* ST_LSM6DS3_EXT0_IS_AKM */
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&sdata->cdata->odr_lock);
@ -1333,7 +1333,7 @@ static int st_lsm6ds3_i2c_master_read_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_RAW:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6ds3_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}

10
drivers/iio/stm/imu/st_lsm6ds3/st_lsm6ds3_spi.c
View File

@ -124,6 +124,15 @@ static int st_lsm6ds3_spi_probe(struct spi_device *spi)
return err;
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void st_lsm6ds3_spi_remove(struct spi_device *spi)
{
struct lsm6ds3_data *cdata = spi_get_drvdata(spi);
st_lsm6ds3_common_remove(cdata, spi->irq);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int st_lsm6ds3_spi_remove(struct spi_device *spi)
{
struct lsm6ds3_data *cdata = spi_get_drvdata(spi);
@ -133,6 +142,7 @@ static int st_lsm6ds3_spi_remove(struct spi_device *spi)
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused st_lsm6ds3_suspend(struct device *dev)

18
drivers/iio/stm/imu/st_lsm6ds3h/st_lsm6ds3h.h
View File

@ -12,6 +12,11 @@
#include <linux/types.h>
#include <linux/iio/trigger.h>
#include <linux/version.h>
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
#include <linux/iio/iio-opaque.h>
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_ST_LSM6DS3H_IIO_MASTER_SUPPORT
#include <linux/i2c.h>
@ -367,4 +372,17 @@ static inline int st_lsm6ds3h_i2c_master_exit(struct lsm6ds3h_data *cdata)
}
#endif /* CONFIG_ST_LSM6DS3H_IIO_MASTER_SUPPORT */
static inline int st_lsm6ds3h_iio_dev_currentmode(struct iio_dev *indio_dev)
{
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
struct iio_dev_opaque *iio_opq = to_iio_dev_opaque(indio_dev);
return iio_opq->currentmode;
#else /* LINUX_VERSION_CODE */
return indio_dev->currentmode;
#endif /* LINUX_VERSION_CODE */
}
#endif /* ST_LSM6DS3H_H */

44
drivers/iio/stm/imu/st_lsm6ds3h/st_lsm6ds3h_core.c
View File

@ -1731,7 +1731,7 @@ static int st_lsm6ds3h_read_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_RAW:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6ds3h_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -1790,7 +1790,7 @@ static int st_lsm6ds3h_write_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_SCALE:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6ds3h_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -1928,7 +1928,7 @@ static ssize_t st_lsm6ds3h_sysfs_set_max_delivery_rate(struct device *dev,
u8 duration;
int err;
unsigned int max_delivery_rate;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtouint(buf, 10, &max_delivery_rate);
@ -1954,7 +1954,7 @@ static ssize_t st_lsm6ds3h_sysfs_set_max_delivery_rate(struct device *dev,
static ssize_t st_lsm6ds3h_sysfs_get_max_delivery_rate(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct lsm6ds3h_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6ds3h_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n",
sdata->cdata->v_odr[ST_MASK_ID_STEP_COUNTER]);
@ -1964,7 +1964,7 @@ static ssize_t st_lsm6ds3h_sysfs_reset_counter(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err;
struct lsm6ds3h_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6ds3h_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
err = st_lsm6ds3h_reset_steps(sdata->cdata);
if (err < 0)
@ -1976,7 +1976,7 @@ static ssize_t st_lsm6ds3h_sysfs_reset_counter(struct device *dev,
static ssize_t st_lsm6ds3h_sysfs_get_sampling_frequency(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct lsm6ds3h_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6ds3h_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sdata->cdata->v_odr[sdata->sindex]);
}
@ -1986,7 +1986,7 @@ static ssize_t st_lsm6ds3h_sysfs_set_sampling_frequency(struct device *dev,
{
int err;
unsigned int odr;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &odr);
@ -2035,7 +2035,7 @@ static ssize_t st_lsm6ds3h_sysfs_scale_avail(struct device *dev,
struct device_attribute *attr, char *buf)
{
int i, len = 0;
struct lsm6ds3h_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6ds3h_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
for (i = 0; i < ST_LSM6DS3H_FS_LIST_NUM; i++) {
len += scnprintf(buf + len, PAGE_SIZE - len, "0.%09u ",
@ -2059,7 +2059,7 @@ static ssize_t st_lsm6ds3h_sysfs_get_selftest_status(struct device *dev,
{
int8_t result;
char *message = NULL;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&sdata->cdata->odr_lock);
@ -2092,7 +2092,7 @@ static ssize_t st_lsm6ds3h_sysfs_start_selftest_status(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err, i, n;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
u8 reg_status, reg_addr, temp_reg_status, outdata[6];
int x = 0, y = 0, z = 0, x_selftest = 0, y_selftest = 0, z_selftest = 0;
@ -2270,12 +2270,12 @@ ssize_t st_lsm6ds3h_sysfs_flush_fifo(struct device *dev,
u64 sensor_last_timestamp, event_type = 0;
int stype = 0;
u64 timestamp_flush = 0;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6ds3h_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_lock(&sdata->cdata->odr_lock);
disable_irq(sdata->cdata->irq);
} else {
@ -2328,7 +2328,7 @@ ssize_t st_lsm6ds3h_sysfs_flush_fifo(struct device *dev,
ssize_t st_lsm6ds3h_sysfs_get_hwfifo_enabled(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n",
@ -2340,11 +2340,11 @@ ssize_t st_lsm6ds3h_sysfs_set_hwfifo_enabled(struct device *dev,
{
int err;
bool enable = false;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6ds3h_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
err = -EBUSY;
goto set_hwfifo_enabled_unlock_mutex;
}
@ -2375,7 +2375,7 @@ ssize_t st_lsm6ds3h_sysfs_set_hwfifo_enabled(struct device *dev,
ssize_t st_lsm6ds3h_sysfs_get_hwfifo_watermark(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n",
@ -2386,7 +2386,7 @@ ssize_t st_lsm6ds3h_sysfs_set_hwfifo_watermark(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err = 0, watermark = 0, old_watermark;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &watermark);
@ -2438,12 +2438,12 @@ static ssize_t st_lsm6ds3h_sysfs_set_injection_mode(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err, start;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6ds3h_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -2520,7 +2520,7 @@ static ssize_t st_lsm6ds3h_sysfs_set_injection_mode(struct device *dev,
static ssize_t st_lsm6ds3h_sysfs_get_injection_mode(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n", sdata->cdata->injection_mode);
@ -2532,7 +2532,7 @@ static ssize_t st_lsm6ds3h_sysfs_upload_xl_data(struct device *dev,
int i;
u8 sample[3];
s64 timestamp;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
@ -2628,7 +2628,7 @@ ssize_t st_lsm6ds3h_get_module_id(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
struct lsm6ds3h_data *cdata = sdata->cdata;

10
drivers/iio/stm/imu/st_lsm6ds3h/st_lsm6ds3h_i2c.c
View File

@ -105,6 +105,15 @@ static int st_lsm6ds3h_i2c_probe(struct i2c_client *client,
return err;
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void st_lsm6ds3h_i2c_remove(struct i2c_client *client)
{
struct lsm6ds3h_data *cdata = i2c_get_clientdata(client);
st_lsm6ds3h_common_remove(cdata, client->irq);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int st_lsm6ds3h_i2c_remove(struct i2c_client *client)
{
struct lsm6ds3h_data *cdata = i2c_get_clientdata(client);
@ -114,6 +123,7 @@ static int st_lsm6ds3h_i2c_remove(struct i2c_client *client)
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused st_lsm6ds3h_suspend(struct device *dev)

10
drivers/iio/stm/imu/st_lsm6ds3h/st_lsm6ds3h_i2c_master.c
View File

@ -342,7 +342,7 @@ static ssize_t st_lsm6ds3h_i2c_master_sysfs_sampling_frequency_avail(
static ssize_t st_lsm6ds3h_i2c_master_sysfs_get_sampling_frequency(
struct device *dev, struct device_attribute *attr, char *buf)
{
struct lsm6ds3h_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6ds3h_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sdata->cdata->v_odr[sdata->sindex]);
}
@ -353,7 +353,7 @@ static ssize_t st_lsm6ds3h_i2c_master_sysfs_set_sampling_frequency(
{
int err;
unsigned int odr;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &odr);
@ -782,7 +782,7 @@ static ssize_t st_lsm6ds3h_i2c_master_sysfs_get_selftest_status(
{
int8_t result;
char *message = NULL;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&sdata->cdata->odr_lock);
@ -813,7 +813,7 @@ static ssize_t st_lsm6ds3h_i2c_master_sysfs_start_selftest(struct device *dev,
#ifdef ST_LSM6DS3H_EXT0_IS_AKM
u8 temp, sh_config[3], timeout = 0;
#endif /* ST_LSM6DS3H_EXT0_IS_AKM */
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6ds3h_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&sdata->cdata->odr_lock);
@ -1259,7 +1259,7 @@ static int st_lsm6ds3h_i2c_master_read_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_RAW:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6ds3h_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}

10
drivers/iio/stm/imu/st_lsm6ds3h/st_lsm6ds3h_spi.c
View File

@ -123,6 +123,15 @@ static int st_lsm6ds3h_spi_probe(struct spi_device *spi)
return err;
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void st_lsm6ds3h_spi_remove(struct spi_device *spi)
{
struct lsm6ds3h_data *cdata = spi_get_drvdata(spi);
st_lsm6ds3h_common_remove(cdata, spi->irq);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int st_lsm6ds3h_spi_remove(struct spi_device *spi)
{
struct lsm6ds3h_data *cdata = spi_get_drvdata(spi);
@ -132,6 +141,7 @@ static int st_lsm6ds3h_spi_remove(struct spi_device *spi)
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused st_lsm6ds3h_suspend(struct device *dev)

18
drivers/iio/stm/imu/st_lsm6dsm/st_lsm6dsm.h
View File

@ -12,6 +12,11 @@
#include <linux/types.h>
#include <linux/iio/trigger.h>
#include <linux/version.h>
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
#include <linux/iio/iio-opaque.h>
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_ST_LSM6DSM_IIO_MASTER_SUPPORT
#include <linux/i2c.h>
@ -368,4 +373,17 @@ static inline int st_lsm6dsm_i2c_master_exit(struct lsm6dsm_data *cdata)
}
#endif /* CONFIG_ST_LSM6DSM_IIO_MASTER_SUPPORT */
static inline int st_lsm6dsm_iio_dev_currentmode(struct iio_dev *indio_dev)
{
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
struct iio_dev_opaque *iio_opq = to_iio_dev_opaque(indio_dev);
return iio_opq->currentmode;
#else /* LINUX_VERSION_CODE */
return indio_dev->currentmode;
#endif /* LINUX_VERSION_CODE */
}
#endif /* ST_LSM6DSM_H */

44
drivers/iio/stm/imu/st_lsm6dsm/st_lsm6dsm_core.c
View File

@ -1971,7 +1971,7 @@ static int st_lsm6dsm_read_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_RAW:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6dsm_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -2030,7 +2030,7 @@ static int st_lsm6dsm_write_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_SCALE:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6dsm_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -2192,7 +2192,7 @@ static ssize_t st_lsm6dsm_sysfs_set_max_delivery_rate(struct device *dev,
u8 duration;
int err;
unsigned int max_delivery_rate;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtouint(buf, 10, &max_delivery_rate);
@ -2218,7 +2218,7 @@ static ssize_t st_lsm6dsm_sysfs_set_max_delivery_rate(struct device *dev,
static ssize_t st_lsm6dsm_sysfs_get_max_delivery_rate(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct lsm6dsm_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6dsm_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n",
sdata->cdata->v_odr[ST_MASK_ID_STEP_COUNTER]);
@ -2228,7 +2228,7 @@ static ssize_t st_lsm6dsm_sysfs_reset_counter(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err;
struct lsm6dsm_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6dsm_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
err = st_lsm6dsm_reset_steps(sdata->cdata);
if (err < 0)
@ -2240,7 +2240,7 @@ static ssize_t st_lsm6dsm_sysfs_reset_counter(struct device *dev,
static ssize_t st_lsm6dsm_sysfs_get_sampling_frequency(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct lsm6dsm_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6dsm_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sdata->cdata->v_odr[sdata->sindex]);
}
@ -2250,7 +2250,7 @@ static ssize_t st_lsm6dsm_sysfs_set_sampling_frequency(struct device *dev,
{
int err;
unsigned int odr;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &odr);
@ -2305,7 +2305,7 @@ static ssize_t st_lsm6dsm_sysfs_scale_avail(struct device *dev,
struct device_attribute *attr, char *buf)
{
int i, len = 0;
struct lsm6dsm_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6dsm_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
for (i = 0; i < ST_LSM6DSM_FS_LIST_NUM; i++) {
len += scnprintf(buf + len, PAGE_SIZE - len, "0.%09u ",
@ -2329,7 +2329,7 @@ static ssize_t st_lsm6dsm_sysfs_get_selftest_status(struct device *dev,
{
int8_t result;
char *message = NULL;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&sdata->cdata->odr_lock);
@ -2362,7 +2362,7 @@ static ssize_t st_lsm6dsm_sysfs_start_selftest_status(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err, i, n;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
u8 reg_status, reg_addr, temp_reg_status, outdata[6];
int x = 0, y = 0, z = 0, x_selftest = 0, y_selftest = 0, z_selftest = 0;
@ -2540,12 +2540,12 @@ ssize_t st_lsm6dsm_sysfs_flush_fifo(struct device *dev,
u64 sensor_last_timestamp, event_type = 0;
int stype = 0;
u64 timestamp_flush = 0;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6dsm_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_lock(&sdata->cdata->odr_lock);
disable_irq(sdata->cdata->irq);
} else {
@ -2598,7 +2598,7 @@ ssize_t st_lsm6dsm_sysfs_flush_fifo(struct device *dev,
ssize_t st_lsm6dsm_sysfs_get_hwfifo_enabled(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n",
@ -2610,11 +2610,11 @@ ssize_t st_lsm6dsm_sysfs_set_hwfifo_enabled(struct device *dev,
{
int err;
bool enable = false;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6dsm_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
err = -EBUSY;
goto set_hwfifo_enabled_unlock_mutex;
}
@ -2645,7 +2645,7 @@ ssize_t st_lsm6dsm_sysfs_set_hwfifo_enabled(struct device *dev,
ssize_t st_lsm6dsm_sysfs_get_hwfifo_watermark(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n",
@ -2656,7 +2656,7 @@ ssize_t st_lsm6dsm_sysfs_set_hwfifo_watermark(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err = 0, watermark = 0, old_watermark;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &watermark);
@ -2708,12 +2708,12 @@ static ssize_t st_lsm6dsm_sysfs_set_injection_mode(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int err, start;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6dsm_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}
@ -2777,7 +2777,7 @@ static ssize_t st_lsm6dsm_sysfs_set_injection_mode(struct device *dev,
static ssize_t st_lsm6dsm_sysfs_get_injection_mode(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
return sprintf(buf, "%d\n", sdata->cdata->injection_mode);
@ -2789,7 +2789,7 @@ static ssize_t st_lsm6dsm_sysfs_upload_xl_data(struct device *dev,
int err, i, n = 1;
s64 timestamp, deltatime;
u8 sample[3], current_odr;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&indio_dev->mlock);
@ -2868,7 +2868,7 @@ ssize_t st_lsm6dsm_get_module_id(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
struct lsm6dsm_data *cdata = sdata->cdata;

10
drivers/iio/stm/imu/st_lsm6dsm/st_lsm6dsm_i2c.c
View File

@ -105,6 +105,15 @@ static int st_lsm6dsm_i2c_probe(struct i2c_client *client,
return err;
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void st_lsm6dsm_i2c_remove(struct i2c_client *client)
{
struct lsm6dsm_data *cdata = i2c_get_clientdata(client);
st_lsm6dsm_common_remove(cdata, client->irq);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int st_lsm6dsm_i2c_remove(struct i2c_client *client)
{
struct lsm6dsm_data *cdata = i2c_get_clientdata(client);
@ -114,6 +123,7 @@ static int st_lsm6dsm_i2c_remove(struct i2c_client *client)
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused st_lsm6dsm_suspend(struct device *dev)

10
drivers/iio/stm/imu/st_lsm6dsm/st_lsm6dsm_i2c_master.c
View File

@ -388,7 +388,7 @@ static ssize_t st_lsm6dsm_i2c_master_sysfs_sampling_frequency_avail(
static ssize_t st_lsm6dsm_i2c_master_sysfs_get_sampling_frequency(
struct device *dev, struct device_attribute *attr, char *buf)
{
struct lsm6dsm_sensor_data *sdata = iio_priv(dev_get_drvdata(dev));
struct lsm6dsm_sensor_data *sdata = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sdata->cdata->v_odr[sdata->sindex]);
}
@ -399,7 +399,7 @@ static ssize_t st_lsm6dsm_i2c_master_sysfs_set_sampling_frequency(
{
int err;
unsigned int odr;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
err = kstrtoint(buf, 10, &odr);
@ -855,7 +855,7 @@ static ssize_t st_lsm6dsm_i2c_master_sysfs_get_selftest_status(
{
int8_t result;
char *message = NULL;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&sdata->cdata->odr_lock);
@ -886,7 +886,7 @@ static ssize_t st_lsm6dsm_i2c_master_sysfs_start_selftest(struct device *dev,
#ifdef ST_LSM6DSM_EXT0_IS_AKM
u8 temp, sh_config[3], timeout = 0;
#endif /* ST_LSM6DSM_EXT0_IS_AKM */
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct lsm6dsm_sensor_data *sdata = iio_priv(indio_dev);
mutex_lock(&sdata->cdata->odr_lock);
@ -1332,7 +1332,7 @@ static int st_lsm6dsm_i2c_master_read_raw(struct iio_dev *indio_dev,
case IIO_CHAN_INFO_RAW:
mutex_lock(&indio_dev->mlock);
if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
if (st_lsm6dsm_iio_dev_currentmode(indio_dev) == INDIO_BUFFER_TRIGGERED) {
mutex_unlock(&indio_dev->mlock);
return -EBUSY;
}

10
drivers/iio/stm/imu/st_lsm6dsm/st_lsm6dsm_spi.c
View File

@ -123,6 +123,15 @@ static int st_lsm6dsm_spi_probe(struct spi_device *spi)
return err;
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void st_lsm6dsm_spi_remove(struct spi_device *spi)
{
struct lsm6dsm_data *cdata = spi_get_drvdata(spi);
st_lsm6dsm_common_remove(cdata, spi->irq);
kfree(cdata);
}
#else /* LINUX_VERSION_CODE */
static int st_lsm6dsm_spi_remove(struct spi_device *spi)
{
struct lsm6dsm_data *cdata = spi_get_drvdata(spi);
@ -132,6 +141,7 @@ static int st_lsm6dsm_spi_remove(struct spi_device *spi)
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused st_lsm6dsm_suspend(struct device *dev)

8
drivers/iio/stm/imu/st_lsm6dso16is/st_lsm6dso16is_core.c
View File

@ -533,7 +533,7 @@ st_lsm6dso16is_sysfs_sampling_frequency_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dso16is_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dso16is_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
const struct st_lsm6dso16is_odr_table_entry *odr_table;
enum st_lsm6dso16is_sensor_id id = sensor->id;
int i, len = 0;
@ -554,7 +554,7 @@ static ssize_t st_lsm6dso16is_sysfs_scale_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dso16is_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dso16is_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_lsm6dso16is_sensor_id id = sensor->id;
int i, len = 0;
@ -604,7 +604,7 @@ st_lsm6dso16is_sysfs_get_selftest_status(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dso16is_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dso16is_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_lsm6dso16is_sensor_id id = sensor->id;
char *message = NULL;
int8_t result;
@ -782,7 +782,7 @@ st_lsm6dso16is_sysfs_start_selftest(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dso16is_sensor *sensor = iio_priv(iio_dev);
enum st_lsm6dso16is_sensor_id id = sensor->id;
struct st_lsm6dso16is_hw *hw = sensor->hw;

4
drivers/iio/stm/imu/st_lsm6dso16is/st_lsm6dso16is_shub.c
View File

@ -709,7 +709,7 @@ st_lsm6dso16is_sysfs_shub_sampling_freq_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dso16is_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dso16is_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dso16is_ext_dev_info *ext_info = &sensor->ext_dev_info;
int i, len = 0;
@ -739,7 +739,7 @@ static ssize_t st_lsm6dso16is_sysfs_shub_scale_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dso16is_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dso16is_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dso16is_ext_dev_info *ext_info = &sensor->ext_dev_info;
int i, len = 0;

2
drivers/iio/stm/imu/st_lsm6dsox/st_lsm6dsox.h
View File

@ -15,9 +15,11 @@
#include <linux/device.h>
#include <linux/hrtimer.h>
#include <linux/iio/iio.h>
#include <linux/of_device.h>
#include <linux/regmap.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>
#include <linux/version.h>
#define ST_LSM6DSOX_ODR_EXPAND(odr, uodr) (((odr) * 1000000) + (uodr))

15
drivers/iio/stm/imu/st_lsm6dsox/st_lsm6dsox_buffer.c
View File

@ -345,7 +345,7 @@ static int st_lsm6dsox_read_fifo(struct st_lsm6dsox_hw *hw)
ssize_t st_lsm6dsox_get_max_watermark(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsox_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%d\n", sensor->max_watermark);
@ -354,7 +354,7 @@ ssize_t st_lsm6dsox_get_max_watermark(struct device *dev,
ssize_t st_lsm6dsox_get_watermark(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsox_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%d\n", sensor->watermark);
@ -364,7 +364,7 @@ ssize_t st_lsm6dsox_set_watermark(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsox_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -391,7 +391,7 @@ ssize_t st_lsm6dsox_flush_fifo(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsox_sensor *sensor = iio_priv(iio_dev);
struct st_lsm6dsox_hw *hw = sensor->hw;
s64 type;
@ -688,7 +688,12 @@ int st_lsm6dsox_buffers_setup(struct st_lsm6dsox_hw *hw)
if (!hw->iio_devs[i])
continue;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,13,0)
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[i],
&st_lsm6dsox_fifo_ops);
if (err)
return err;
#elif KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[i],
INDIO_BUFFER_SOFTWARE,
&st_lsm6dsox_fifo_ops);

16
drivers/iio/stm/imu/st_lsm6dsox/st_lsm6dsox_core.c
View File

@ -1028,7 +1028,7 @@ st_lsm6dsox_sysfs_sampling_frequency_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_lsm6dsox_sensor_id id = sensor->id;
int i, len = 0;
@ -1047,7 +1047,7 @@ static ssize_t st_lsm6dsox_sysfs_scale_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
const struct st_lsm6dsox_fs_table_entry *fs_table;
enum st_lsm6dsox_sensor_id id = sensor->id;
int i, len = 0;
@ -1081,7 +1081,7 @@ st_lsm6dsox_sysfs_get_power_mode_avail(struct device *dev,
ssize_t st_lsm6dsox_get_power_mode(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsox_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%s\n",
@ -1092,7 +1092,7 @@ ssize_t st_lsm6dsox_set_power_mode(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsox_sensor *sensor = iio_priv(iio_dev);
int err, i;
@ -1153,7 +1153,7 @@ static ssize_t st_lsm6dsox_sysfs_get_selftest_status(struct device *dev,
{
int8_t result;
char *message = NULL;
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_lsm6dsox_sensor_id id = sensor->id;
if (id != ST_LSM6DSOX_ID_ACC &&
@ -1486,7 +1486,7 @@ static int __maybe_unused st_lsm6dsox_restore_regs(struct st_lsm6dsox_hw *hw)
static ssize_t st_lsm6dsox_sysfs_start_selftest(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsox_sensor *sensor = iio_priv(iio_dev);
enum st_lsm6dsox_sensor_id id = sensor->id;
struct st_lsm6dsox_hw *hw = sensor->hw;
@ -1571,7 +1571,7 @@ static ssize_t st_lsm6dsox_sysfs_reset_step_counter(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
int err;
err = st_lsm6dsox_reset_step_counter(iio_dev);
@ -1583,7 +1583,7 @@ ssize_t st_lsm6dsox_get_module_id(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsox_sensor *sensor = iio_priv(iio_dev);
struct st_lsm6dsox_hw *hw = sensor->hw;

12
drivers/iio/stm/imu/st_lsm6dsox/st_lsm6dsox_i2c.c
View File

@ -37,16 +37,26 @@ static int st_lsm6dsox_i2c_probe(struct i2c_client *client,
hw_id, regmap);
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void st_lsm6dsox_i2c_remove(struct i2c_client *client)
{
struct st_lsm6dsox_hw *hw = dev_get_drvdata(&client->dev);
if (hw->settings->st_mlc_probe)
st_lsm6dsox_mlc_remove(&client->dev);
}
#else /* LINUX_VERSION_CODE */
static int st_lsm6dsox_i2c_remove(struct i2c_client *client)
{
int err = 0;
struct st_lsm6dsox_hw *hw = dev_get_drvdata(&client->dev);
int err = 0;
if (hw->settings->st_mlc_probe)
err = st_lsm6dsox_mlc_remove(&client->dev);
return err;
}
#endif /* LINUX_VERSION_CODE */
static const struct of_device_id st_lsm6dsox_i2c_of_match[] = {
{

10
drivers/iio/stm/imu/st_lsm6dsox/st_lsm6dsox_mlc.c
View File

@ -527,7 +527,7 @@ static ssize_t st_lsm6dsox_mlc_info(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsox_hw *hw = sensor->hw;
return scnprintf(buf, PAGE_SIZE, "mlc %02x fsm %02x\n",
@ -547,7 +547,7 @@ static ssize_t st_lsm6dsox_mlc_flush(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsox_hw *hw = sensor->hw;
int ret;
@ -561,7 +561,7 @@ static ssize_t st_lsm6dsox_mlc_upload_firmware(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
int err;
err = request_firmware_nowait(THIS_MODULE, true,
@ -577,7 +577,7 @@ static ssize_t st_lsm6dsox_mlc_odr(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsox_hw *hw = sensor->hw;
return scnprintf(buf, PAGE_SIZE, "%d\n", hw->mlc_config->requested_odr);
@ -617,7 +617,7 @@ static ssize_t st_lsm6dsox_mlc_x_odr(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return scnprintf(buf, PAGE_SIZE, "%d.%02d\n",
sensor->odr, sensor->uodr);

4
drivers/iio/stm/imu/st_lsm6dsox/st_lsm6dsox_shub.c
View File

@ -834,7 +834,7 @@ st_lsm6dsox_sysfs_shub_sampling_freq_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsox_ext_dev_info *ext_info = &sensor->ext_dev_info;
int i, len = 0;
@ -864,7 +864,7 @@ static ssize_t st_lsm6dsox_sysfs_shub_scale_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsox_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsox_ext_dev_info *ext_info = &sensor->ext_dev_info;
int i, len = 0;

12
drivers/iio/stm/imu/st_lsm6dsox/st_lsm6dsox_spi.c
View File

@ -36,16 +36,26 @@ static int st_lsm6dsox_spi_probe(struct spi_device *spi)
return st_lsm6dsox_probe(&spi->dev, spi->irq, hw_id, regmap);
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void st_lsm6dsox_spi_remove(struct spi_device *spi)
{
struct st_lsm6dsox_hw *hw = dev_get_drvdata(&spi->dev);
if (hw->settings->st_mlc_probe)
st_lsm6dsox_mlc_remove(&spi->dev);
}
#else /* LINUX_VERSION_CODE */
static int st_lsm6dsox_spi_remove(struct spi_device *spi)
{
int err = 0;
struct st_lsm6dsox_hw *hw = dev_get_drvdata(&spi->dev);
int err = 0;
if (hw->settings->st_mlc_probe)
err = st_lsm6dsox_mlc_remove(&spi->dev);
return err;
}
#endif /* LINUX_VERSION_CODE */
static const struct of_device_id st_lsm6dsox_spi_of_match[] = {
{

3
drivers/iio/stm/imu/st_lsm6dsrx/st_lsm6dsrx.h
View File

@ -15,9 +15,12 @@
#include <linux/device.h>
#include <linux/hrtimer.h>
#include <linux/iio/iio.h>
#include <linux/of_device.h>
#include <linux/property.h>
#include <linux/regmap.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>
#include <linux/version.h>
#define ST_LSM6DSRX_ODR_EXPAND(odr, uodr) (((odr) * 1000000) + (uodr))

15
drivers/iio/stm/imu/st_lsm6dsrx/st_lsm6dsrx_buffer.c
View File

@ -348,7 +348,7 @@ static int st_lsm6dsrx_read_fifo(struct st_lsm6dsrx_hw *hw)
ssize_t st_lsm6dsrx_get_max_watermark(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsrx_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%d\n", sensor->max_watermark);
@ -357,7 +357,7 @@ ssize_t st_lsm6dsrx_get_max_watermark(struct device *dev,
ssize_t st_lsm6dsrx_get_watermark(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsrx_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%d\n", sensor->watermark);
@ -367,7 +367,7 @@ ssize_t st_lsm6dsrx_set_watermark(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsrx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -394,7 +394,7 @@ ssize_t st_lsm6dsrx_flush_fifo(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsrx_sensor *sensor = iio_priv(iio_dev);
struct st_lsm6dsrx_hw *hw = sensor->hw;
s64 type;
@ -655,7 +655,12 @@ int st_lsm6dsrx_buffers_setup(struct st_lsm6dsrx_hw *hw)
if (!hw->iio_devs[id])
continue;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,13,0)
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[id],
&st_lsm6dsrx_fifo_ops);
if (err)
return err;
#elif KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[id],
INDIO_BUFFER_SOFTWARE,
&st_lsm6dsrx_fifo_ops);

14
drivers/iio/stm/imu/st_lsm6dsrx/st_lsm6dsrx_core.c
View File

@ -883,7 +883,7 @@ st_lsm6dsrx_sysfs_sampling_frequency_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_lsm6dsrx_sensor_id id = sensor->id;
int i, len = 0;
@ -902,7 +902,7 @@ static ssize_t st_lsm6dsrx_sysfs_scale_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_lsm6dsrx_sensor_id id = sensor->id;
int i, len = 0;
@ -934,7 +934,7 @@ st_lsm6dsrx_sysfs_get_power_mode_avail(struct device *dev,
ssize_t st_lsm6dsrx_get_power_mode(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsrx_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%s\n",
@ -945,7 +945,7 @@ ssize_t st_lsm6dsrx_set_power_mode(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsrx_sensor *sensor = iio_priv(iio_dev);
int err, i;
@ -1163,7 +1163,7 @@ static ssize_t st_lsm6dsrx_sysfs_get_selftest_status(struct device *dev,
{
int8_t result;
char *message = NULL;
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_lsm6dsrx_sensor_id id = sensor->id;
if (id != ST_LSM6DSRX_ID_ACC &&
@ -1337,7 +1337,7 @@ static int st_lsm6dsrx_selftest_sensor(struct st_lsm6dsrx_sensor *sensor,
static ssize_t st_lsm6dsrx_sysfs_start_selftest(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsrx_sensor *sensor = iio_priv(iio_dev);
enum st_lsm6dsrx_sensor_id id = sensor->id;
struct st_lsm6dsrx_hw *hw = sensor->hw;
@ -1432,7 +1432,7 @@ ssize_t st_lsm6dsrx_get_module_id(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsrx_sensor *sensor = iio_priv(iio_dev);
struct st_lsm6dsrx_hw *hw = sensor->hw;

2
drivers/iio/stm/imu/st_lsm6dsrx/st_lsm6dsrx_embfunc.c
View File

@ -260,7 +260,7 @@ st_lsm6dsrx_sysfs_reset_step_counter(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
int err;
err = iio_device_claim_direct_mode(iio_dev);

18
drivers/iio/stm/imu/st_lsm6dsrx/st_lsm6dsrx_events.c
View File

@ -448,7 +448,7 @@ st_lsm6dsrx_wakeup_threshold_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[0]);
}
@ -458,7 +458,7 @@ st_lsm6dsrx_wakeup_threshold_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsrx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -487,7 +487,7 @@ st_lsm6dsrx_wakeup_duration_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[1]);
}
@ -497,7 +497,7 @@ st_lsm6dsrx_wakeup_duration_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsrx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -526,7 +526,7 @@ st_lsm6dsrx_freefall_threshold_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[2]);
}
@ -536,7 +536,7 @@ st_lsm6dsrx_freefall_threshold_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsrx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -565,7 +565,7 @@ st_lsm6dsrx_6D_threshold_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[3]);
}
@ -575,7 +575,7 @@ st_lsm6dsrx_6D_threshold_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsrx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -1014,7 +1014,7 @@ int st_lsm6dsrx_probe_event(struct st_lsm6dsrx_hw *hw)
err = devm_iio_triggered_buffer_setup(hw->dev, iio_dev,
NULL,
pthread[i - ST_LSM6DSRX_ID_WK],
pthread[id - ST_LSM6DSRX_ID_WK],
&st_lsm6dsrx_buffer_ops);
if (err < 0)
return err;

7
drivers/iio/stm/imu/st_lsm6dsrx/st_lsm6dsrx_i2c.c
View File

@ -37,10 +37,17 @@ static int st_lsm6dsrx_i2c_probe(struct i2c_client *client,
hw_id, regmap);
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void st_lsm6dsrx_i2c_remove(struct i2c_client *client)
{
st_lsm6dsrx_mlc_remove(&client->dev);
}
#else /* LINUX_VERSION_CODE */
static int st_lsm6dsrx_i2c_remove(struct i2c_client *client)
{
return st_lsm6dsrx_mlc_remove(&client->dev);
}
#endif /* LINUX_VERSION_CODE */
static const struct of_device_id st_lsm6dsrx_i2c_of_match[] = {
{

10
drivers/iio/stm/imu/st_lsm6dsrx/st_lsm6dsrx_mlc.c
View File

@ -476,7 +476,7 @@ static ssize_t st_lsm6dsrx_mlc_info(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsrx_hw *hw = sensor->hw;
return scnprintf(buf, PAGE_SIZE, "mlc %02x fsm %02x\n",
@ -496,7 +496,7 @@ static ssize_t st_lsm6dsrx_mlc_flush(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsrx_hw *hw = sensor->hw;
int ret;
@ -510,7 +510,7 @@ static ssize_t st_lsm6dsrx_mlc_upload_firmware(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
int err;
err = request_firmware_nowait(THIS_MODULE, true,
@ -526,7 +526,7 @@ static ssize_t st_lsm6dsrx_mlc_odr(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsrx_hw *hw = sensor->hw;
return scnprintf(buf, PAGE_SIZE, "%d\n", hw->mlc_config->requested_odr);
@ -568,7 +568,7 @@ static ssize_t st_lsm6dsrx_mlc_x_odr(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return scnprintf(buf, PAGE_SIZE, "%d.%02d\n",
sensor->odr, sensor->uodr);

4
drivers/iio/stm/imu/st_lsm6dsrx/st_lsm6dsrx_shub.c
View File

@ -863,7 +863,7 @@ st_lsm6dsrx_sysfs_shub_sampling_freq_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsrx_ext_dev_info *ext_info = &sensor->ext_dev_info;
int i, len = 0;
@ -895,7 +895,7 @@ static ssize_t st_lsm6dsrx_sysfs_shub_scale_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsrx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsrx_ext_dev_info *ext_info = &sensor->ext_dev_info;
int i, len = 0;

7
drivers/iio/stm/imu/st_lsm6dsrx/st_lsm6dsrx_spi.c
View File

@ -36,10 +36,17 @@ static int st_lsm6dsrx_spi_probe(struct spi_device *spi)
return st_lsm6dsrx_probe(&spi->dev, spi->irq, hw_id, regmap);
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void st_lsm6dsrx_spi_remove(struct spi_device *spi)
{
st_lsm6dsrx_mlc_remove(&spi->dev);
}
#else /* LINUX_VERSION_CODE */
static int st_lsm6dsrx_spi_remove(struct spi_device *spi)
{
return st_lsm6dsrx_mlc_remove(&spi->dev);
}
#endif /* LINUX_VERSION_CODE */
static const struct of_device_id st_lsm6dsrx_spi_of_match[] = {
{

2
drivers/iio/stm/imu/st_lsm6dsvx/st_lsm6dsvx.h
View File

@ -15,9 +15,11 @@
#include <linux/device.h>
#include <linux/hrtimer.h>
#include <linux/iio/iio.h>
#include <linux/of_device.h>
#include <linux/regmap.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>
#include <linux/version.h>
#define ST_LSM6DSVX_ODR_LIST_SIZE 9
#define ST_LSM6DSVX_ODR_EXPAND(odr, uodr) ((odr * 1000000) + uodr)

15
drivers/iio/stm/imu/st_lsm6dsvx/st_lsm6dsvx_buffer.c
View File

@ -414,7 +414,7 @@ ssize_t st_lsm6dsvx_get_max_watermark(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsvx_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%d\n", sensor->max_watermark);
@ -424,7 +424,7 @@ ssize_t st_lsm6dsvx_get_watermark(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsvx_sensor *sensor = iio_priv(iio_dev);
return sprintf(buf, "%d\n", sensor->watermark);
@ -434,7 +434,7 @@ ssize_t st_lsm6dsvx_set_watermark(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsvx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -462,7 +462,7 @@ ssize_t st_lsm6dsvx_flush_fifo(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsvx_sensor *sensor = iio_priv(iio_dev);
struct st_lsm6dsvx_hw *hw = sensor->hw;
s64 type;
@ -758,7 +758,12 @@ int st_lsm6dsvx_buffers_setup(struct st_lsm6dsvx_hw *hw)
if (!hw->iio_devs[id])
continue;
#if KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[id],
&st_lsm6dsvx_fifo_ops);
if (err)
return err;
#elif KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[id],
INDIO_BUFFER_SOFTWARE,
&st_lsm6dsvx_fifo_ops);

20
drivers/iio/stm/imu/st_lsm6dsvx/st_lsm6dsvx_core.c
View File

@ -827,6 +827,7 @@ static int st_lsm6dsvx_write_raw(struct iio_dev *iio_dev,
break;
err = st_lsm6dsvx_update_batching(iio_dev, 1);
break;
default:
break;
}
@ -849,7 +850,7 @@ st_lsm6dsvx_sysfs_sampling_frequency_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_lsm6dsvx_sensor_id id = sensor->id;
int i, len = 0;
@ -871,7 +872,7 @@ static ssize_t
st_lsm6dsvx_sysfs_scale_avail(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_lsm6dsvx_sensor_id id = sensor->id;
int i, len = 0;
@ -979,7 +980,7 @@ static ssize_t
st_lsm6dsvx_sysfs_get_selftest_status(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
enum st_lsm6dsvx_sensor_id id = sensor->id;
int8_t result;
char *message;
@ -993,7 +994,7 @@ st_lsm6dsvx_sysfs_get_selftest_status(struct device *dev,
message = "na";
else if (result < 0)
message = "fail";
else if (result > 0)
else
message = "pass";
return sprintf(buf, "%s\n", message);
@ -1154,7 +1155,7 @@ static ssize_t st_lsm6dsvx_sysfs_start_selftest(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsvx_sensor *sensor = iio_priv(iio_dev);
enum st_lsm6dsvx_sensor_id id = sensor->id;
struct st_lsm6dsvx_hw *hw = sensor->hw;
@ -1190,12 +1191,12 @@ static ssize_t st_lsm6dsvx_sysfs_start_selftest(struct device *dev,
/* disable interrupt on FIFO watermak */
ret = st_lsm6dsvx_get_int_reg(hw, &drdy_reg, &ef_irq_reg);
if (ret < 0)
goto restore_regs;
goto out_claim;
ret = st_lsm6dsvx_write_with_mask(hw, drdy_reg,
ST_LSM6DSVX_INT_FIFO_TH_MASK, 0);
if (ret < 0)
goto restore_regs;
goto restore_irq;
gain = sensor->gain;
odr = sensor->odr;
@ -1214,10 +1215,11 @@ static ssize_t st_lsm6dsvx_sysfs_start_selftest(struct device *dev,
/* run test */
st_lsm6dsvx_selftest_sensor(sensor, test);
restore_regs:
/* restore configuration after test */
st_lsm6dsvx_set_full_scale(sensor, gain);
st_lsm6dsvx_set_odr(sensor, odr, uodr);
restore_irq:
st_lsm6dsvx_write_with_mask(hw, drdy_reg,
ST_LSM6DSVX_INT_FIFO_TH_MASK, 1);
@ -1231,7 +1233,7 @@ ssize_t st_lsm6dsvx_get_module_id(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsvx_sensor *sensor = iio_priv(iio_dev);
struct st_lsm6dsvx_hw *hw = sensor->hw;

2
drivers/iio/stm/imu/st_lsm6dsvx/st_lsm6dsvx_embfunc.c
View File

@ -260,7 +260,7 @@ st_lsm6dsvx_sysfs_reset_step_counter(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
int err;
err = iio_device_claim_direct_mode(iio_dev);

16
drivers/iio/stm/imu/st_lsm6dsvx/st_lsm6dsvx_events.c
View File

@ -435,7 +435,7 @@ st_lsm6dsvx_wakeup_threshold_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[0]);
}
@ -445,7 +445,7 @@ st_lsm6dsvx_wakeup_threshold_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsvx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -474,7 +474,7 @@ st_lsm6dsvx_wakeup_duration_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[1]);
}
@ -484,7 +484,7 @@ st_lsm6dsvx_wakeup_duration_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsvx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -513,7 +513,7 @@ st_lsm6dsvx_freefall_threshold_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[2]);
}
@ -523,7 +523,7 @@ st_lsm6dsvx_freefall_threshold_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsvx_sensor *sensor = iio_priv(iio_dev);
int err, val;
@ -552,7 +552,7 @@ st_lsm6dsvx_6D_threshold_get(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->conf[3]);
}
@ -562,7 +562,7 @@ st_lsm6dsvx_6D_threshold_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *iio_dev = dev_get_drvdata(dev);
struct iio_dev *iio_dev = dev_to_iio_dev(dev);
struct st_lsm6dsvx_sensor *sensor = iio_priv(iio_dev);
int err, val;

7
drivers/iio/stm/imu/st_lsm6dsvx/st_lsm6dsvx_i2c.c
View File

@ -37,10 +37,17 @@ static int st_lsm6dsvx_i2c_probe(struct i2c_client *client,
return st_lsm6dsvx_probe(&client->dev, client->irq, hw_id, regmap);
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void st_lsm6dsvx_i2c_remove(struct i2c_client *client)
{
st_lsm6dsvx_remove(&client->dev);
}
#else /* LINUX_VERSION_CODE */
static int st_lsm6dsvx_i2c_remove(struct i2c_client *client)
{
return st_lsm6dsvx_remove(&client->dev);
}
#endif /* LINUX_VERSION_CODE */
static const struct of_device_id st_lsm6dsvx_i2c_of_match[] = {
{

10
drivers/iio/stm/imu/st_lsm6dsvx/st_lsm6dsvx_mlc.c
View File

@ -460,7 +460,7 @@ static int st_lsm6dsvx_mlc_flush_all(struct st_lsm6dsvx_hw *hw)
static ssize_t st_lsm6dsvx_mlc_info(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsvx_hw *hw = sensor->hw;
return scnprintf(buf, PAGE_SIZE, "mlc %02x fsm %02x\n",
@ -481,7 +481,7 @@ static ssize_t st_lsm6dsvx_mlc_flush(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsvx_hw *hw = sensor->hw;
int ret;
@ -496,7 +496,7 @@ st_lsm6dsvx_mlc_upload_firmware(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
int err;
err = request_firmware_nowait(THIS_MODULE, true,
@ -512,7 +512,7 @@ static ssize_t st_lsm6dsvx_mlc_odr(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsvx_hw *hw = sensor->hw;
return scnprintf(buf, PAGE_SIZE, "%d\n",
@ -552,7 +552,7 @@ static const struct iio_info st_lsm6dsvx_mlc_event_info = {
static ssize_t st_lsm6dsvx_mlc_x_odr(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return scnprintf(buf, PAGE_SIZE, "%d.%02d\n",
sensor->odr, sensor->uodr);

16
drivers/iio/stm/imu/st_lsm6dsvx/st_lsm6dsvx_qvar.c
View File

@ -16,6 +16,7 @@
#include <linux/module.h>
#include <linux/pm.h>
#include <linux/workqueue.h>
#include <linux/version.h>
#include "st_lsm6dsvx.h"
@ -281,6 +282,20 @@ static int st_lsm6dsvx_qvar_buffer(struct st_lsm6dsvx_hw *hw)
{
struct iio_buffer *buffer;
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev,
hw->iio_devs[ST_LSM6DSVX_ID_QVAR],
&st_lsm6dsvx_qvar_ops);
if (err)
return err;
#elif KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev,
hw->iio_devs[ST_LSM6DSVX_ID_QVAR],
INDIO_BUFFER_SOFTWARE,
&st_lsm6dsvx_qvar_ops);
if (err)
return err;
#else /* LINUX_VERSION_CODE */
buffer = devm_iio_kfifo_allocate(hw->dev);
if (!buffer)
return -ENOMEM;
@ -288,6 +303,7 @@ static int st_lsm6dsvx_qvar_buffer(struct st_lsm6dsvx_hw *hw)
iio_device_attach_buffer(hw->iio_devs[ST_LSM6DSVX_ID_QVAR], buffer);
hw->iio_devs[ST_LSM6DSVX_ID_QVAR]->modes |= INDIO_BUFFER_SOFTWARE;
hw->iio_devs[ST_LSM6DSVX_ID_QVAR]->setup_ops = &st_lsm6dsvx_qvar_ops;
#endif /* LINUX_VERSION_CODE */
return st_lsm6dsvx_allocate_workqueue(hw);
}

4
drivers/iio/stm/imu/st_lsm6dsvx/st_lsm6dsvx_shub.c
View File

@ -716,7 +716,7 @@ st_lsm6dsvx_sysfs_shub_sampling_freq_avail(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsvx_ext_dev_info *ext_info = &sensor->ext_dev_info;
int i, len = 0;
@ -746,7 +746,7 @@ static ssize_t
st_lsm6dsvx_sysfs_shub_scale_avail(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lsm6dsvx_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
struct st_lsm6dsvx_ext_dev_info *ext_info = &sensor->ext_dev_info;
int i, len = 0;

7
drivers/iio/stm/imu/st_lsm6dsvx/st_lsm6dsvx_spi.c
View File

@ -36,10 +36,17 @@ static int st_lsm6dsvx_spi_probe(struct spi_device *spi)
return st_lsm6dsvx_probe(&spi->dev, spi->irq, hw_id, regmap);
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void st_lsm6dsvx_spi_remove(struct spi_device *spi)
{
st_lsm6dsvx_remove(&spi->dev);
}
#else /* LINUX_VERSION_CODE */
static int st_lsm6dsvx_spi_remove(struct spi_device *spi)
{
return st_lsm6dsvx_remove(&spi->dev);
}
#endif /* LINUX_VERSION_CODE */
static const struct of_device_id st_lsm6dsvx_spi_of_match[] = {
{

1
drivers/iio/stm/magnetometer/st_mag3d.h
View File

@ -11,6 +11,7 @@
#define __ST_MAG3D_H
#include <linux/iio/iio.h>
#include <linux/version.h>
#define LIS3MDL_DEV_NAME "lis3mdl_magn"
#define LSM9DS1_DEV_NAME "lsm9ds1_magn"

9
drivers/iio/stm/magnetometer/st_mag3d_i2c.c
View File

@ -42,6 +42,14 @@ static int st_mag3d_i2c_probe(struct i2c_client *client,
&st_mag3d_tf_i2c);
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void st_mag3d_i2c_remove(struct i2c_client *client)
{
struct iio_dev *iio_dev = i2c_get_clientdata(client);
st_mag3d_remove(iio_dev);
}
#else /* LINUX_VERSION_CODE */
static int st_mag3d_i2c_remove(struct i2c_client *client)
{
struct iio_dev *iio_dev = i2c_get_clientdata(client);
@ -50,6 +58,7 @@ static int st_mag3d_i2c_remove(struct i2c_client *client)
return 0;
}
#endif /* LINUX_VERSION_CODE */
static const struct i2c_device_id st_mag3d_ids[] = {
{ LIS3MDL_DEV_NAME },

9
drivers/iio/stm/magnetometer/st_mag3d_spi.c
View File

@ -76,6 +76,14 @@ static int st_mag3d_spi_probe(struct spi_device *spi)
&st_mag3d_tf_spi);
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void st_mag3d_spi_remove(struct spi_device *spi)
{
struct iio_dev *iio_dev = spi_get_drvdata(spi);
st_mag3d_remove(iio_dev);
}
#else /* LINUX_VERSION_CODE */
static int st_mag3d_spi_remove(struct spi_device *spi)
{
struct iio_dev *iio_dev = spi_get_drvdata(spi);
@ -84,6 +92,7 @@ static int st_mag3d_spi_remove(struct spi_device *spi)
return 0;
}
#endif /* LINUX_VERSION_CODE */
static const struct spi_device_id st_mag3d_ids[] = {
{ LIS3MDL_DEV_NAME },

1
drivers/iio/stm/magnetometer/st_mag40_core.c
View File

@ -22,6 +22,7 @@
#include <linux/delay.h>
#include <linux/iio/buffer.h>
#include <linux/iio/events.h>
#include <linux/of_device.h>
#include <asm/unaligned.h>
#include "st_mag40_core.h"

1
drivers/iio/stm/magnetometer/st_mag40_core.h
View File

@ -13,6 +13,7 @@
#include <linux/types.h>
#include <linux/iio/iio.h>
#include <linux/iio/trigger.h>
#include <linux/version.h>
#define ST_MAG40_DEV_NAME "st_mag40"
#define LIS2MDL_DEV_NAME "lis2mdl_magn"

9
drivers/iio/stm/magnetometer/st_mag40_i2c.c
View File

@ -88,6 +88,14 @@ static int st_mag40_i2c_probe(struct i2c_client *client,
return st_mag40_common_probe(iio_dev);
}
#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
static void st_mag40_i2c_remove(struct i2c_client *client)
{
struct iio_dev *iio_dev = i2c_get_clientdata(client);
st_mag40_common_remove(iio_dev);
}
#else /* LINUX_VERSION_CODE */
static int st_mag40_i2c_remove(struct i2c_client *client)
{
struct iio_dev *iio_dev = i2c_get_clientdata(client);
@ -96,6 +104,7 @@ static int st_mag40_i2c_remove(struct i2c_client *client)
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused st_mag40_i2c_suspend(struct device *dev)

9
drivers/iio/stm/magnetometer/st_mag40_spi.c
View File

@ -92,6 +92,14 @@ static int st_mag40_spi_probe(struct spi_device *spi)
return st_mag40_common_probe(iio_dev);
}
#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
static void st_mag40_spi_remove(struct spi_device *spi)
{
struct iio_dev *iio_dev = spi_get_drvdata(spi);
st_mag40_common_remove(iio_dev);
}
#else /* LINUX_VERSION_CODE */
static int st_mag40_spi_remove(struct spi_device *spi)
{
struct iio_dev *iio_dev = spi_get_drvdata(spi);
@ -100,6 +108,7 @@ static int st_mag40_spi_remove(struct spi_device *spi)
return 0;
}
#endif /* LINUX_VERSION_CODE */
#ifdef CONFIG_PM
static int __maybe_unused st_mag40_spi_suspend(struct device *dev)

1
drivers/iio/stm/pressure/st_lps22df.h
View File

@ -13,6 +13,7 @@
#include <linux/module.h>
#include <linux/types.h>
#include <linux/iio/iio.h>
#include <linux/property.h>
#include <linux/iio/trigger.h>
#define ST_LPS22DF_MAX_FIFO_LENGTH 127

12
drivers/iio/stm/pressure/st_lps22df_buffer.c
View File

@ -68,7 +68,7 @@ ssize_t st_lps22df_sysfs_set_hwfifo_watermark(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct st_lps22df_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lps22df_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
int err, watermark;
err = kstrtoint(buf, 10, &watermark);
@ -122,7 +122,7 @@ ssize_t st_lps22df_sysfs_flush_fifo(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct st_lps22df_sensor *sensor = iio_priv(indio_dev);
struct st_lps22df_hw *hw = sensor->hw;
int len, dir;
@ -286,7 +286,13 @@ int st_lps22df_allocate_buffers(struct st_lps22df_hw *hw)
if (err)
return err;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,13,0)
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev,
hw->iio_devs[ST_LPS22DF_PRESS],
&st_lps22df_buffer_ops);
if (err)
return err;
#elif KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev,
hw->iio_devs[ST_LPS22DF_PRESS],
INDIO_BUFFER_SOFTWARE,

2
drivers/iio/stm/pressure/st_lps22df_core.c
View File

@ -228,7 +228,7 @@ static ssize_t
st_lps22df_sysfs_get_hwfifo_watermark(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct st_lps22df_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lps22df_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->hw->watermark);
}

11
drivers/iio/stm/pressure/st_lps22hb_buffer.c
View File

@ -81,7 +81,7 @@ ssize_t st_lps22hb_sysfs_set_hwfifo_watermark(struct device * dev,
struct device_attribute * attr,
const char *buf, size_t count)
{
struct st_lps22hb_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lps22hb_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
int err, watermark;
err = kstrtoint(buf, 10, &watermark);
@ -139,7 +139,7 @@ ssize_t st_lps22hb_sysfs_flush_fifo(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct st_lps22hb_sensor *sensor = iio_priv(indio_dev);
struct st_lps22hb_hw *hw = sensor->hw;
u64 type, event;
@ -266,7 +266,12 @@ int st_lps22hb_allocate_buffers(struct st_lps22hb_hw *hw)
for (i = 0; i < ST_LPS22HB_SENSORS_NUMB; i++) {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,13,0)
#if KERNEL_VERSION(5, 19, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[i],
&st_lps22hb_buffer_ops);
if (err)
return err;
#elif KERNEL_VERSION(5, 13, 0) <= LINUX_VERSION_CODE
err = devm_iio_kfifo_buffer_setup(hw->dev, hw->iio_devs[i],
INDIO_BUFFER_SOFTWARE,
&st_lps22hb_buffer_ops);

2
drivers/iio/stm/pressure/st_lps22hb_core.c
View File

@ -244,7 +244,7 @@ static ssize_t
st_lps22hb_sysfs_get_hwfifo_watermark(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct st_lps22hb_sensor *sensor = iio_priv(dev_get_drvdata(dev));
struct st_lps22hb_sensor *sensor = iio_priv(dev_to_iio_dev(dev));
return sprintf(buf, "%d\n", sensor->hw->watermark);
}

Some files were not shown because too many files have changed in this diff Show More