From 9893e9e1a0ae33a2ea2971081dbfbfd486c4214c Mon Sep 17 00:00:00 2001 From: Vasyl Vavrychuk Date: Tue, 10 May 2022 16:13:12 +0200 Subject: egvirt: linux-yocto: Adapt for kernel v5.15. * Remove changes already present in v5.15. * Refresh other patches. * Document how to recreate kernel configs for future reference. Bug-AGL: SPEC-4365 Change-Id: If8f900c9de7d8536364d71288902fd842d3ddc5f Signed-off-by: Vasyl Vavrychuk --- ...Adding-support-for-IIO-SCMI-Based-Sensors.patch | 797 --------------------- 1 file changed, 797 deletions(-) delete mode 100644 meta-egvirt/recipes-kernel/linux/linux-yocto/iio-scmi/0001-iio-scmi-Adding-support-for-IIO-SCMI-Based-Sensors.patch (limited to 'meta-egvirt/recipes-kernel/linux/linux-yocto/iio-scmi/0001-iio-scmi-Adding-support-for-IIO-SCMI-Based-Sensors.patch') diff --git a/meta-egvirt/recipes-kernel/linux/linux-yocto/iio-scmi/0001-iio-scmi-Adding-support-for-IIO-SCMI-Based-Sensors.patch b/meta-egvirt/recipes-kernel/linux/linux-yocto/iio-scmi/0001-iio-scmi-Adding-support-for-IIO-SCMI-Based-Sensors.patch deleted file mode 100644 index 15f6b6a3..00000000 --- a/meta-egvirt/recipes-kernel/linux/linux-yocto/iio-scmi/0001-iio-scmi-Adding-support-for-IIO-SCMI-Based-Sensors.patch +++ /dev/null @@ -1,797 +0,0 @@ -From df55878d8bb123266d301939a3ff90762fd466e1 Mon Sep 17 00:00:00 2001 -From: Jyoti Bhayana -Date: Fri, 12 Feb 2021 17:22:35 +0000 -Subject: [PATCH] iio/scmi: Adding support for IIO SCMI Based Sensors - -This change provides ARM SCMI Protocol based IIO device. -This driver provides support for Accelerometer and Gyroscope using -SCMI Sensor Protocol extensions added in the SCMIv3.0 ARM specification - -Signed-off-by: Jyoti Bhayana -Link: https://lore.kernel.org/r/20210212172235.507028-2-jbhayana@google.com -Signed-off-by: Jonathan Cameron -Signed-off-by: Vasyl Vavrychuk ---- - MAINTAINERS | 6 + - drivers/firmware/arm_scmi/driver.c | 2 +- - drivers/iio/common/Kconfig | 1 + - drivers/iio/common/Makefile | 1 + - drivers/iio/common/scmi_sensors/Kconfig | 18 + - drivers/iio/common/scmi_sensors/Makefile | 5 + - drivers/iio/common/scmi_sensors/scmi_iio.c | 678 +++++++++++++++++++++ - 7 files changed, 710 insertions(+), 1 deletion(-) - create mode 100644 drivers/iio/common/scmi_sensors/Kconfig - create mode 100644 drivers/iio/common/scmi_sensors/Makefile - create mode 100644 drivers/iio/common/scmi_sensors/scmi_iio.c - -diff --git a/MAINTAINERS b/MAINTAINERS -index d223a5c3f465..c3a0245a51d0 100644 ---- a/MAINTAINERS -+++ b/MAINTAINERS -@@ -8593,6 +8593,12 @@ S: Maintained - F: Documentation/devicetree/bindings/iio/multiplexer/io-channel-mux.txt - F: drivers/iio/multiplexer/iio-mux.c - -+IIO SCMI BASED DRIVER -+M: Jyoti Bhayana -+L: linux-iio@vger.kernel.org -+S: Maintained -+F: drivers/iio/common/scmi_sensors/scmi_iio.c -+ - IIO SUBSYSTEM AND DRIVERS - M: Jonathan Cameron - R: Lars-Peter Clausen -diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c -index 540a55285349..fa7279839397 100644 ---- a/drivers/firmware/arm_scmi/driver.c -+++ b/drivers/firmware/arm_scmi/driver.c -@@ -808,7 +808,7 @@ static struct scmi_prot_devnames devnames[] = { - { SCMI_PROTOCOL_SYSTEM, { "syspower" },}, - { SCMI_PROTOCOL_PERF, { "cpufreq" },}, - { SCMI_PROTOCOL_CLOCK, { "clocks" },}, -- { SCMI_PROTOCOL_SENSOR, { "hwmon" },}, -+ { SCMI_PROTOCOL_SENSOR, { "hwmon", "iiodev" },}, - { SCMI_PROTOCOL_RESET, { "reset" },}, - }; - -diff --git a/drivers/iio/common/Kconfig b/drivers/iio/common/Kconfig -index 2b9ee9161abd..0334b4954773 100644 ---- a/drivers/iio/common/Kconfig -+++ b/drivers/iio/common/Kconfig -@@ -6,5 +6,6 @@ - source "drivers/iio/common/cros_ec_sensors/Kconfig" - source "drivers/iio/common/hid-sensors/Kconfig" - source "drivers/iio/common/ms_sensors/Kconfig" -+source "drivers/iio/common/scmi_sensors/Kconfig" - source "drivers/iio/common/ssp_sensors/Kconfig" - source "drivers/iio/common/st_sensors/Kconfig" -diff --git a/drivers/iio/common/Makefile b/drivers/iio/common/Makefile -index 4bc30bb548e2..fad40e1e1718 100644 ---- a/drivers/iio/common/Makefile -+++ b/drivers/iio/common/Makefile -@@ -11,5 +11,6 @@ - obj-y += cros_ec_sensors/ - obj-y += hid-sensors/ - obj-y += ms_sensors/ -+obj-y += scmi_sensors/ - obj-y += ssp_sensors/ - obj-y += st_sensors/ -diff --git a/drivers/iio/common/scmi_sensors/Kconfig b/drivers/iio/common/scmi_sensors/Kconfig -new file mode 100644 -index 000000000000..67e084cbb1ab ---- /dev/null -+++ b/drivers/iio/common/scmi_sensors/Kconfig -@@ -0,0 +1,18 @@ -+# -+# IIO over SCMI -+# -+# When adding new entries keep the list in alphabetical order -+ -+menu "IIO SCMI Sensors" -+ -+config IIO_SCMI -+ tristate "IIO SCMI" -+ depends on ARM_SCMI_PROTOCOL -+ select IIO_BUFFER -+ select IIO_KFIFO_BUF -+ help -+ Say yes here to build support for IIO SCMI Driver. -+ This provides ARM SCMI Protocol based IIO device. -+ This driver provides support for accelerometer and gyroscope -+ sensors available on SCMI based platforms. -+endmenu -diff --git a/drivers/iio/common/scmi_sensors/Makefile b/drivers/iio/common/scmi_sensors/Makefile -new file mode 100644 -index 000000000000..f13140a2575a ---- /dev/null -+++ b/drivers/iio/common/scmi_sensors/Makefile -@@ -0,0 +1,5 @@ -+# SPDX - License - Identifier : GPL - 2.0 - only -+# -+# Makefile for the IIO over SCMI -+# -+obj-$(CONFIG_IIO_SCMI) += scmi_iio.o -diff --git a/drivers/iio/common/scmi_sensors/scmi_iio.c b/drivers/iio/common/scmi_sensors/scmi_iio.c -new file mode 100644 -index 000000000000..31977c3bc600 ---- /dev/null -+++ b/drivers/iio/common/scmi_sensors/scmi_iio.c -@@ -0,0 +1,678 @@ -+// SPDX-License-Identifier: GPL-2.0 -+ -+/* -+ * System Control and Management Interface(SCMI) based IIO sensor driver -+ * -+ * Copyright (C) 2021 Google LLC -+ */ -+ -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+ -+#define SCMI_IIO_NUM_OF_AXIS 3 -+ -+struct scmi_iio_priv { -+ struct scmi_handle *handle; -+ const struct scmi_sensor_info *sensor_info; -+ struct iio_dev *indio_dev; -+ /* adding one additional channel for timestamp */ -+ long long iio_buf[SCMI_IIO_NUM_OF_AXIS + 1]; -+ struct notifier_block sensor_update_nb; -+ u32 *freq_avail; -+}; -+ -+static int scmi_iio_sensor_update_cb(struct notifier_block *nb, -+ unsigned long event, void *data) -+{ -+ struct scmi_sensor_update_report *sensor_update = data; -+ struct iio_dev *scmi_iio_dev; -+ struct scmi_iio_priv *sensor; -+ s8 tstamp_scale; -+ u64 time, time_ns; -+ int i; -+ -+ if (sensor_update->readings_count == 0) -+ return NOTIFY_DONE; -+ -+ sensor = container_of(nb, struct scmi_iio_priv, sensor_update_nb); -+ -+ for (i = 0; i < sensor_update->readings_count; i++) -+ sensor->iio_buf[i] = sensor_update->readings[i].value; -+ -+ if (!sensor->sensor_info->timestamped) { -+ time_ns = ktime_to_ns(sensor_update->timestamp); -+ } else { -+ /* -+ * All the axes are supposed to have the same value for timestamp. -+ * We are just using the values from the Axis 0 here. -+ */ -+ time = sensor_update->readings[0].timestamp; -+ -+ /* -+ * Timestamp returned by SCMI is in seconds and is equal to -+ * time * power-of-10 multiplier(tstamp_scale) seconds. -+ * Converting the timestamp to nanoseconds below. -+ */ -+ tstamp_scale = sensor->sensor_info->tstamp_scale + -+ const_ilog2(NSEC_PER_SEC) / const_ilog2(10); -+ if (tstamp_scale < 0) -+ time_ns = -+ div64_u64(time, int_pow(10, abs(tstamp_scale))); -+ else -+ time_ns = time * int_pow(10, tstamp_scale); -+ } -+ -+ scmi_iio_dev = sensor->indio_dev; -+ iio_push_to_buffers_with_timestamp(scmi_iio_dev, sensor->iio_buf, -+ time_ns); -+ return NOTIFY_OK; -+} -+ -+static int scmi_iio_buffer_preenable(struct iio_dev *iio_dev) -+{ -+ struct scmi_iio_priv *sensor = iio_priv(iio_dev); -+ u32 sensor_id = sensor->sensor_info->id; -+ u32 sensor_config = 0; -+ int err; -+ -+ if (sensor->sensor_info->timestamped) -+ sensor_config |= FIELD_PREP(SCMI_SENS_CFG_TSTAMP_ENABLED_MASK, -+ SCMI_SENS_CFG_TSTAMP_ENABLE); -+ -+ sensor_config |= FIELD_PREP(SCMI_SENS_CFG_SENSOR_ENABLED_MASK, -+ SCMI_SENS_CFG_SENSOR_ENABLE); -+ -+ err = sensor->handle->notify_ops->register_event_notifier(sensor->handle, -+ SCMI_PROTOCOL_SENSOR, SCMI_EVENT_SENSOR_UPDATE, -+ &sensor_id, &sensor->sensor_update_nb); -+ if (err) { -+ dev_err(&iio_dev->dev, -+ "Error in registering sensor update notifier for sensor %s err %d", -+ sensor->sensor_info->name, err); -+ return err; -+ } -+ -+ err = sensor->handle->sensor_ops->config_set(sensor->handle, -+ sensor->sensor_info->id, sensor_config); -+ if (err) { -+ sensor->handle->notify_ops->unregister_event_notifier(sensor->handle, -+ SCMI_PROTOCOL_SENSOR, -+ SCMI_EVENT_SENSOR_UPDATE, &sensor_id, -+ &sensor->sensor_update_nb); -+ dev_err(&iio_dev->dev, "Error in enabling sensor %s err %d", -+ sensor->sensor_info->name, err); -+ } -+ -+ return err; -+} -+ -+static int scmi_iio_buffer_postdisable(struct iio_dev *iio_dev) -+{ -+ struct scmi_iio_priv *sensor = iio_priv(iio_dev); -+ u32 sensor_id = sensor->sensor_info->id; -+ u32 sensor_config = 0; -+ int err; -+ -+ sensor_config |= FIELD_PREP(SCMI_SENS_CFG_SENSOR_ENABLED_MASK, -+ SCMI_SENS_CFG_SENSOR_DISABLE); -+ -+ err = sensor->handle->notify_ops->unregister_event_notifier(sensor->handle, -+ SCMI_PROTOCOL_SENSOR, SCMI_EVENT_SENSOR_UPDATE, -+ &sensor_id, &sensor->sensor_update_nb); -+ if (err) { -+ dev_err(&iio_dev->dev, -+ "Error in unregistering sensor update notifier for sensor %s err %d", -+ sensor->sensor_info->name, err); -+ return err; -+ } -+ -+ err = sensor->handle->sensor_ops->config_set(sensor->handle, sensor_id, -+ sensor_config); -+ if (err) { -+ dev_err(&iio_dev->dev, -+ "Error in disabling sensor %s with err %d", -+ sensor->sensor_info->name, err); -+ } -+ -+ return err; -+} -+ -+static const struct iio_buffer_setup_ops scmi_iio_buffer_ops = { -+ .preenable = scmi_iio_buffer_preenable, -+ .postdisable = scmi_iio_buffer_postdisable, -+}; -+ -+static int scmi_iio_set_odr_val(struct iio_dev *iio_dev, int val, int val2) -+{ -+ struct scmi_iio_priv *sensor = iio_priv(iio_dev); -+ const unsigned long UHZ_PER_HZ = 1000000UL; -+ u64 sec, mult, uHz; -+ u32 sensor_config; -+ char buf[32]; -+ -+ int err = sensor->handle->sensor_ops->config_get(sensor->handle, -+ sensor->sensor_info->id, &sensor_config); -+ if (err) { -+ dev_err(&iio_dev->dev, -+ "Error in getting sensor config for sensor %s err %d", -+ sensor->sensor_info->name, err); -+ return err; -+ } -+ -+ uHz = val * UHZ_PER_HZ + val2; -+ -+ /* -+ * The seconds field in the sensor interval in SCMI is 16 bits long -+ * Therefore seconds = 1/Hz <= 0xFFFF. As floating point calculations are -+ * discouraged in the kernel driver code, to calculate the scale factor (sf) -+ * (1* 1000000 * sf)/uHz <= 0xFFFF. Therefore, sf <= (uHz * 0xFFFF)/1000000 -+ * To calculate the multiplier,we convert the sf into char string and -+ * count the number of characters -+ */ -+ mult = scnprintf(buf, sizeof(buf), "%llu", ((u64)uHz * 0xFFFF) / UHZ_PER_HZ) - 1; -+ -+ sec = div64_u64(int_pow(10, mult) * UHZ_PER_HZ, uHz); -+ if (sec == 0) { -+ dev_err(&iio_dev->dev, -+ "Trying to set invalid sensor update value for sensor %s", -+ sensor->sensor_info->name); -+ return -EINVAL; -+ } -+ -+ sensor_config &= ~SCMI_SENS_CFG_UPDATE_SECS_MASK; -+ sensor_config |= FIELD_PREP(SCMI_SENS_CFG_UPDATE_SECS_MASK, sec); -+ sensor_config &= ~SCMI_SENS_CFG_UPDATE_EXP_MASK; -+ sensor_config |= FIELD_PREP(SCMI_SENS_CFG_UPDATE_EXP_MASK, -mult); -+ -+ if (sensor->sensor_info->timestamped) { -+ sensor_config &= ~SCMI_SENS_CFG_TSTAMP_ENABLED_MASK; -+ sensor_config |= FIELD_PREP(SCMI_SENS_CFG_TSTAMP_ENABLED_MASK, -+ SCMI_SENS_CFG_TSTAMP_ENABLE); -+ } -+ -+ sensor_config &= ~SCMI_SENS_CFG_ROUND_MASK; -+ sensor_config |= -+ FIELD_PREP(SCMI_SENS_CFG_ROUND_MASK, SCMI_SENS_CFG_ROUND_AUTO); -+ -+ err = sensor->handle->sensor_ops->config_set(sensor->handle, -+ sensor->sensor_info->id, sensor_config); -+ if (err) -+ dev_err(&iio_dev->dev, -+ "Error in setting sensor update interval for sensor %s value %u err %d", -+ sensor->sensor_info->name, sensor_config, err); -+ -+ return err; -+} -+ -+static int scmi_iio_write_raw(struct iio_dev *iio_dev, -+ struct iio_chan_spec const *chan, int val, -+ int val2, long mask) -+{ -+ int err; -+ -+ switch (mask) { -+ case IIO_CHAN_INFO_SAMP_FREQ: -+ mutex_lock(&iio_dev->mlock); -+ err = scmi_iio_set_odr_val(iio_dev, val, val2); -+ mutex_unlock(&iio_dev->mlock); -+ return err; -+ default: -+ return -EINVAL; -+ } -+} -+ -+static int scmi_iio_read_avail(struct iio_dev *iio_dev, -+ struct iio_chan_spec const *chan, -+ const int **vals, int *type, int *length, -+ long mask) -+{ -+ struct scmi_iio_priv *sensor = iio_priv(iio_dev); -+ -+ switch (mask) { -+ case IIO_CHAN_INFO_SAMP_FREQ: -+ *vals = sensor->freq_avail; -+ *type = IIO_VAL_INT_PLUS_MICRO; -+ *length = sensor->sensor_info->intervals.count * 2; -+ if (sensor->sensor_info->intervals.segmented) -+ return IIO_AVAIL_RANGE; -+ else -+ return IIO_AVAIL_LIST; -+ default: -+ return -EINVAL; -+ } -+} -+ -+static void convert_ns_to_freq(u64 interval_ns, u64 *hz, u64 *uhz) -+{ -+ u64 rem; -+ -+ *hz = div64_u64_rem(NSEC_PER_SEC, interval_ns, &rem); -+ *uhz = (rem * 1000000UL) / interval_ns; -+} -+ -+static int scmi_iio_get_odr_val(struct iio_dev *iio_dev, int *val, int *val2) -+{ -+ u64 sensor_update_interval, sensor_interval_mult, hz, uhz; -+ struct scmi_iio_priv *sensor = iio_priv(iio_dev); -+ u32 sensor_config; -+ int mult; -+ -+ int err = sensor->handle->sensor_ops->config_get(sensor->handle, -+ sensor->sensor_info->id, &sensor_config); -+ if (err) { -+ dev_err(&iio_dev->dev, -+ "Error in getting sensor config for sensor %s err %d", -+ sensor->sensor_info->name, err); -+ return err; -+ } -+ -+ sensor_update_interval = -+ SCMI_SENS_CFG_GET_UPDATE_SECS(sensor_config) * NSEC_PER_SEC; -+ -+ mult = SCMI_SENS_CFG_GET_UPDATE_EXP(sensor_config); -+ if (mult < 0) { -+ sensor_interval_mult = int_pow(10, abs(mult)); -+ sensor_update_interval = -+ sensor_update_interval / sensor_interval_mult; -+ } else { -+ sensor_interval_mult = int_pow(10, mult); -+ sensor_update_interval = -+ sensor_update_interval * sensor_interval_mult; -+ } -+ -+ convert_ns_to_freq(sensor_update_interval, &hz, &uhz); -+ *val = hz; -+ *val2 = uhz; -+ return 0; -+} -+ -+static int scmi_iio_read_raw(struct iio_dev *iio_dev, -+ struct iio_chan_spec const *ch, int *val, -+ int *val2, long mask) -+{ -+ struct scmi_iio_priv *sensor = iio_priv(iio_dev); -+ s8 scale; -+ int ret; -+ -+ switch (mask) { -+ case IIO_CHAN_INFO_SCALE: -+ scale = sensor->sensor_info->axis[ch->scan_index].scale; -+ if (scale < 0) { -+ *val = 1; -+ *val2 = int_pow(10, abs(scale)); -+ return IIO_VAL_FRACTIONAL; -+ } -+ *val = int_pow(10, scale); -+ return IIO_VAL_INT; -+ case IIO_CHAN_INFO_SAMP_FREQ: -+ ret = scmi_iio_get_odr_val(iio_dev, val, val2); -+ return ret ? ret : IIO_VAL_INT_PLUS_MICRO; -+ default: -+ return -EINVAL; -+ } -+} -+ -+static const struct iio_info scmi_iio_info = { -+ .read_raw = scmi_iio_read_raw, -+ .read_avail = scmi_iio_read_avail, -+ .write_raw = scmi_iio_write_raw, -+}; -+ -+static ssize_t scmi_iio_get_raw_available(struct iio_dev *iio_dev, -+ uintptr_t private, -+ const struct iio_chan_spec *chan, -+ char *buf) -+{ -+ struct scmi_iio_priv *sensor = iio_priv(iio_dev); -+ unsigned long long resolution, rem; -+ long long min_range, max_range; -+ s8 exponent, scale; -+ int len = 0; -+ -+ /* -+ * All the axes are supposed to have the same value for range and resolution. -+ * We are just using the values from the Axis 0 here. -+ */ -+ if (sensor->sensor_info->axis[0].extended_attrs) { -+ min_range = sensor->sensor_info->axis[0].attrs.min_range; -+ max_range = sensor->sensor_info->axis[0].attrs.max_range; -+ resolution = sensor->sensor_info->axis[0].resolution; -+ exponent = sensor->sensor_info->axis[0].exponent; -+ scale = sensor->sensor_info->axis[0].scale; -+ -+ /* -+ * To provide the raw value for the resolution to the userspace, -+ * need to divide the resolution exponent by the sensor scale -+ */ -+ exponent = exponent - scale; -+ if (exponent < 0) { -+ resolution = div64_u64_rem(resolution, -+ int_pow(10, abs(exponent)), -+ &rem); -+ len = scnprintf(buf, PAGE_SIZE, -+ "[%lld %llu.%llu %lld]\n", min_range, -+ resolution, rem, max_range); -+ } else { -+ resolution = resolution * int_pow(10, exponent); -+ len = scnprintf(buf, PAGE_SIZE, "[%lld %llu %lld]\n", -+ min_range, resolution, max_range); -+ } -+ } -+ return len; -+} -+ -+static const struct iio_chan_spec_ext_info scmi_iio_ext_info[] = { -+ { -+ .name = "raw_available", -+ .read = scmi_iio_get_raw_available, -+ .shared = IIO_SHARED_BY_TYPE, -+ }, -+ {}, -+}; -+ -+static void scmi_iio_set_timestamp_channel(struct iio_chan_spec *iio_chan, -+ int scan_index) -+{ -+ iio_chan->type = IIO_TIMESTAMP; -+ iio_chan->channel = -1; -+ iio_chan->scan_index = scan_index; -+ iio_chan->scan_type.sign = 'u'; -+ iio_chan->scan_type.realbits = 64; -+ iio_chan->scan_type.storagebits = 64; -+} -+ -+static void scmi_iio_set_data_channel(struct iio_chan_spec *iio_chan, -+ enum iio_chan_type type, -+ enum iio_modifier mod, int scan_index) -+{ -+ iio_chan->type = type; -+ iio_chan->modified = 1; -+ iio_chan->channel2 = mod; -+ iio_chan->info_mask_separate = BIT(IIO_CHAN_INFO_SCALE); -+ iio_chan->info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SAMP_FREQ); -+ iio_chan->info_mask_shared_by_type_available = -+ BIT(IIO_CHAN_INFO_SAMP_FREQ); -+ iio_chan->scan_index = scan_index; -+ iio_chan->scan_type.sign = 's'; -+ iio_chan->scan_type.realbits = 64; -+ iio_chan->scan_type.storagebits = 64; -+ iio_chan->scan_type.endianness = IIO_LE; -+ iio_chan->ext_info = scmi_iio_ext_info; -+} -+ -+static int scmi_iio_get_chan_modifier(const char *name, -+ enum iio_modifier *modifier) -+{ -+ char *pch, mod; -+ -+ if (!name) -+ return -EINVAL; -+ -+ pch = strrchr(name, '_'); -+ if (!pch) -+ return -EINVAL; -+ -+ mod = *(pch + 1); -+ switch (mod) { -+ case 'X': -+ *modifier = IIO_MOD_X; -+ return 0; -+ case 'Y': -+ *modifier = IIO_MOD_Y; -+ return 0; -+ case 'Z': -+ *modifier = IIO_MOD_Z; -+ return 0; -+ default: -+ return -EINVAL; -+ } -+} -+ -+static int scmi_iio_get_chan_type(u8 scmi_type, enum iio_chan_type *iio_type) -+{ -+ switch (scmi_type) { -+ case METERS_SEC_SQUARED: -+ *iio_type = IIO_ACCEL; -+ return 0; -+ case RADIANS_SEC: -+ *iio_type = IIO_ANGL_VEL; -+ return 0; -+ default: -+ return -EINVAL; -+ } -+} -+ -+static u64 scmi_iio_convert_interval_to_ns(u32 val) -+{ -+ u64 sensor_update_interval = -+ SCMI_SENS_INTVL_GET_SECS(val) * NSEC_PER_SEC; -+ u64 sensor_interval_mult; -+ int mult; -+ -+ mult = SCMI_SENS_INTVL_GET_EXP(val); -+ if (mult < 0) { -+ sensor_interval_mult = int_pow(10, abs(mult)); -+ sensor_update_interval = -+ sensor_update_interval / sensor_interval_mult; -+ } else { -+ sensor_interval_mult = int_pow(10, mult); -+ sensor_update_interval = -+ sensor_update_interval * sensor_interval_mult; -+ } -+ return sensor_update_interval; -+} -+ -+static int scmi_iio_set_sampling_freq_avail(struct iio_dev *iio_dev) -+{ -+ u64 cur_interval_ns, low_interval_ns, high_interval_ns, step_size_ns, -+ hz, uhz; -+ unsigned int cur_interval, low_interval, high_interval, step_size; -+ struct scmi_iio_priv *sensor = iio_priv(iio_dev); -+ int i; -+ -+ sensor->freq_avail = -+ devm_kzalloc(&iio_dev->dev, -+ sizeof(*sensor->freq_avail) * -+ (sensor->sensor_info->intervals.count * 2), -+ GFP_KERNEL); -+ if (!sensor->freq_avail) -+ return -ENOMEM; -+ -+ if (sensor->sensor_info->intervals.segmented) { -+ low_interval = sensor->sensor_info->intervals -+ .desc[SCMI_SENS_INTVL_SEGMENT_LOW]; -+ low_interval_ns = scmi_iio_convert_interval_to_ns(low_interval); -+ convert_ns_to_freq(low_interval_ns, &hz, &uhz); -+ sensor->freq_avail[0] = hz; -+ sensor->freq_avail[1] = uhz; -+ -+ step_size = sensor->sensor_info->intervals -+ .desc[SCMI_SENS_INTVL_SEGMENT_STEP]; -+ step_size_ns = scmi_iio_convert_interval_to_ns(step_size); -+ convert_ns_to_freq(step_size_ns, &hz, &uhz); -+ sensor->freq_avail[2] = hz; -+ sensor->freq_avail[3] = uhz; -+ -+ high_interval = sensor->sensor_info->intervals -+ .desc[SCMI_SENS_INTVL_SEGMENT_HIGH]; -+ high_interval_ns = -+ scmi_iio_convert_interval_to_ns(high_interval); -+ convert_ns_to_freq(high_interval_ns, &hz, &uhz); -+ sensor->freq_avail[4] = hz; -+ sensor->freq_avail[5] = uhz; -+ } else { -+ for (i = 0; i < sensor->sensor_info->intervals.count; i++) { -+ cur_interval = sensor->sensor_info->intervals.desc[i]; -+ cur_interval_ns = -+ scmi_iio_convert_interval_to_ns(cur_interval); -+ convert_ns_to_freq(cur_interval_ns, &hz, &uhz); -+ sensor->freq_avail[i * 2] = hz; -+ sensor->freq_avail[i * 2 + 1] = uhz; -+ } -+ } -+ return 0; -+} -+ -+static int scmi_iio_buffers_setup(struct iio_dev *scmi_iiodev) -+{ -+ struct iio_buffer *buffer; -+ -+ buffer = devm_iio_kfifo_allocate(&scmi_iiodev->dev); -+ if (!buffer) -+ return -ENOMEM; -+ -+ iio_device_attach_buffer(scmi_iiodev, buffer); -+ scmi_iiodev->modes |= INDIO_BUFFER_SOFTWARE; -+ scmi_iiodev->setup_ops = &scmi_iio_buffer_ops; -+ return 0; -+} -+ -+static struct iio_dev *scmi_alloc_iiodev(struct device *dev, -+ struct scmi_handle *handle, -+ const struct scmi_sensor_info *sensor_info) -+{ -+ struct iio_chan_spec *iio_channels; -+ struct scmi_iio_priv *sensor; -+ enum iio_modifier modifier; -+ enum iio_chan_type type; -+ struct iio_dev *iiodev; -+ int i, ret; -+ -+ iiodev = devm_iio_device_alloc(dev, sizeof(*sensor)); -+ if (!iiodev) -+ return ERR_PTR(-ENOMEM); -+ -+ iiodev->modes = INDIO_DIRECT_MODE; -+ iiodev->dev.parent = dev; -+ sensor = iio_priv(iiodev); -+ sensor->handle = handle; -+ sensor->sensor_info = sensor_info; -+ sensor->sensor_update_nb.notifier_call = scmi_iio_sensor_update_cb; -+ sensor->indio_dev = iiodev; -+ -+ /* adding one additional channel for timestamp */ -+ iiodev->num_channels = sensor_info->num_axis + 1; -+ iiodev->name = sensor_info->name; -+ iiodev->info = &scmi_iio_info; -+ -+ iio_channels = -+ devm_kzalloc(dev, -+ sizeof(*iio_channels) * (iiodev->num_channels), -+ GFP_KERNEL); -+ if (!iio_channels) -+ return ERR_PTR(-ENOMEM); -+ -+ ret = scmi_iio_set_sampling_freq_avail(iiodev); -+ if (ret < 0) -+ return ERR_PTR(ret); -+ -+ for (i = 0; i < sensor_info->num_axis; i++) { -+ ret = scmi_iio_get_chan_type(sensor_info->axis[i].type, &type); -+ if (ret < 0) -+ return ERR_PTR(ret); -+ -+ ret = scmi_iio_get_chan_modifier(sensor_info->axis[i].name, -+ &modifier); -+ if (ret < 0) -+ return ERR_PTR(ret); -+ -+ scmi_iio_set_data_channel(&iio_channels[i], type, modifier, -+ sensor_info->axis[i].id); -+ } -+ -+ scmi_iio_set_timestamp_channel(&iio_channels[i], i); -+ iiodev->channels = iio_channels; -+ return iiodev; -+} -+ -+static int scmi_iio_dev_probe(struct scmi_device *sdev) -+{ -+ const struct scmi_sensor_info *sensor_info; -+ struct scmi_handle *handle = sdev->handle; -+ struct device *dev = &sdev->dev; -+ struct iio_dev *scmi_iio_dev; -+ u16 nr_sensors; -+ int err = -ENODEV, i; -+ -+ if (!handle || !handle->sensor_ops) { -+ dev_err(dev, "SCMI device has no sensor interface\n"); -+ return -EINVAL; -+ } -+ -+ nr_sensors = handle->sensor_ops->count_get(handle); -+ if (!nr_sensors) { -+ dev_dbg(dev, "0 sensors found via SCMI bus\n"); -+ return -ENODEV; -+ } -+ -+ for (i = 0; i < nr_sensors; i++) { -+ sensor_info = handle->sensor_ops->info_get(handle, i); -+ if (!sensor_info) { -+ dev_err(dev, "SCMI sensor %d has missing info\n", i); -+ return -EINVAL; -+ } -+ -+ /* This driver only supports 3-axis accel and gyro, skipping other sensors */ -+ if (sensor_info->num_axis != SCMI_IIO_NUM_OF_AXIS) -+ continue; -+ -+ /* This driver only supports 3-axis accel and gyro, skipping other sensors */ -+ if (sensor_info->axis[0].type != METERS_SEC_SQUARED && -+ sensor_info->axis[0].type != RADIANS_SEC) -+ continue; -+ -+ scmi_iio_dev = scmi_alloc_iiodev(dev, handle, sensor_info); -+ if (IS_ERR(scmi_iio_dev)) { -+ dev_err(dev, -+ "failed to allocate IIO device for sensor %s: %ld\n", -+ sensor_info->name, PTR_ERR(scmi_iio_dev)); -+ return PTR_ERR(scmi_iio_dev); -+ } -+ -+ err = scmi_iio_buffers_setup(scmi_iio_dev); -+ if (err < 0) { -+ dev_err(dev, -+ "IIO buffer setup error at sensor %s: %d\n", -+ sensor_info->name, err); -+ return err; -+ } -+ -+ err = devm_iio_device_register(dev, scmi_iio_dev); -+ if (err) { -+ dev_err(dev, -+ "IIO device registration failed at sensor %s: %d\n", -+ sensor_info->name, err); -+ return err; -+ } -+ } -+ return err; -+} -+ -+static const struct scmi_device_id scmi_id_table[] = { -+ { SCMI_PROTOCOL_SENSOR, "iiodev" }, -+ {}, -+}; -+ -+MODULE_DEVICE_TABLE(scmi, scmi_id_table); -+ -+static struct scmi_driver scmi_iiodev_driver = { -+ .name = "scmi-sensor-iiodev", -+ .probe = scmi_iio_dev_probe, -+ .id_table = scmi_id_table, -+}; -+ -+module_scmi_driver(scmi_iiodev_driver); -+ -+MODULE_AUTHOR("Jyoti Bhayana "); -+MODULE_DESCRIPTION("SCMI IIO Driver"); -+MODULE_LICENSE("GPL v2"); -- cgit 1.2.3-korg