diff options
author | Adrian Schmutzler <freifunk@adrianschmutzler.de> | 2020-10-09 21:53:35 +0200 |
---|---|---|
committer | Adrian Schmutzler <freifunk@adrianschmutzler.de> | 2020-10-30 19:29:59 +0100 |
commit | 278512665094888d3c007fdd74e090496d6c811d (patch) | |
tree | 6d4f2cdddef316e07829b89c1c1a790d0db92fc3 /target/linux/generic/backport-4.19/500-v5.1-iio-chemical-add-support-for-Sensirion-SPS30-sensor.patch | |
parent | 3824fa26d256d162fc0e02e46714eda7816cae4a (diff) | |
download | upstream-278512665094888d3c007fdd74e090496d6c811d.tar.gz upstream-278512665094888d3c007fdd74e090496d6c811d.tar.bz2 upstream-278512665094888d3c007fdd74e090496d6c811d.zip |
kernel: remove support for kernel 4.19
We use 5.4 on all targets by default, and 4.19 has never been released
in a stable version. There is no reason to keep it.
Signed-off-by: Adrian Schmutzler <freifunk@adrianschmutzler.de>
Diffstat (limited to 'target/linux/generic/backport-4.19/500-v5.1-iio-chemical-add-support-for-Sensirion-SPS30-sensor.patch')
-rw-r--r-- | target/linux/generic/backport-4.19/500-v5.1-iio-chemical-add-support-for-Sensirion-SPS30-sensor.patch | 454 |
1 files changed, 0 insertions, 454 deletions
diff --git a/target/linux/generic/backport-4.19/500-v5.1-iio-chemical-add-support-for-Sensirion-SPS30-sensor.patch b/target/linux/generic/backport-4.19/500-v5.1-iio-chemical-add-support-for-Sensirion-SPS30-sensor.patch deleted file mode 100644 index d30c7c3cc1..0000000000 --- a/target/linux/generic/backport-4.19/500-v5.1-iio-chemical-add-support-for-Sensirion-SPS30-sensor.patch +++ /dev/null @@ -1,454 +0,0 @@ -From 232e0f6ddeaee104d64675fe7d0cc142cf955f35 Mon Sep 17 00:00:00 2001 -From: Tomasz Duszynski <tduszyns@gmail.com> -Date: Fri, 14 Dec 2018 19:28:02 +0100 -Subject: [PATCH] iio: chemical: add support for Sensirion SPS30 sensor - -Add support for Sensirion SPS30 particulate matter sensor. - -Signed-off-by: Tomasz Duszynski <tduszyns@gmail.com> -Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com> ---- - drivers/iio/chemical/Kconfig | 11 + - drivers/iio/chemical/Makefile | 1 + - drivers/iio/chemical/sps30.c | 407 ++++++++++++++++++++++++++++++++++ - 3 files changed, 419 insertions(+) - create mode 100644 drivers/iio/chemical/sps30.c - ---- a/drivers/iio/chemical/Kconfig -+++ b/drivers/iio/chemical/Kconfig -@@ -61,6 +61,17 @@ config IAQCORE - iAQ-Core Continuous/Pulsed VOC (Volatile Organic Compounds) - sensors - -+config SPS30 -+ tristate "SPS30 particulate matter sensor" -+ depends on I2C -+ select CRC8 -+ help -+ Say Y here to build support for the Sensirion SPS30 particulate -+ matter sensor. -+ -+ To compile this driver as a module, choose M here: the module will -+ be called sps30. -+ - config VZ89X - tristate "SGX Sensortech MiCS VZ89X VOC sensor" - depends on I2C ---- a/drivers/iio/chemical/Makefile -+++ b/drivers/iio/chemical/Makefile -@@ -9,4 +9,5 @@ obj-$(CONFIG_BME680_I2C) += bme680_i2c.o - obj-$(CONFIG_BME680_SPI) += bme680_spi.o - obj-$(CONFIG_CCS811) += ccs811.o - obj-$(CONFIG_IAQCORE) += ams-iaq-core.o -+obj-$(CONFIG_SPS30) += sps30.o - obj-$(CONFIG_VZ89X) += vz89x.o ---- /dev/null -+++ b/drivers/iio/chemical/sps30.c -@@ -0,0 +1,407 @@ -+// SPDX-License-Identifier: GPL-2.0 -+/* -+ * Sensirion SPS30 particulate matter sensor driver -+ * -+ * Copyright (c) Tomasz Duszynski <tduszyns@gmail.com> -+ * -+ * I2C slave address: 0x69 -+ * -+ * TODO: -+ * - support for turning on fan cleaning -+ * - support for reading/setting auto cleaning interval -+ */ -+ -+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt -+ -+#include <asm/unaligned.h> -+#include <linux/crc8.h> -+#include <linux/delay.h> -+#include <linux/i2c.h> -+#include <linux/iio/buffer.h> -+#include <linux/iio/iio.h> -+#include <linux/iio/sysfs.h> -+#include <linux/iio/trigger_consumer.h> -+#include <linux/iio/triggered_buffer.h> -+#include <linux/module.h> -+ -+#define SPS30_CRC8_POLYNOMIAL 0x31 -+/* max number of bytes needed to store PM measurements or serial string */ -+#define SPS30_MAX_READ_SIZE 48 -+/* sensor measures reliably up to 3000 ug / m3 */ -+#define SPS30_MAX_PM 3000 -+ -+/* SPS30 commands */ -+#define SPS30_START_MEAS 0x0010 -+#define SPS30_STOP_MEAS 0x0104 -+#define SPS30_RESET 0xd304 -+#define SPS30_READ_DATA_READY_FLAG 0x0202 -+#define SPS30_READ_DATA 0x0300 -+#define SPS30_READ_SERIAL 0xd033 -+ -+enum { -+ PM1, -+ PM2P5, -+ PM4, -+ PM10, -+}; -+ -+struct sps30_state { -+ struct i2c_client *client; -+ /* -+ * Guards against concurrent access to sensor registers. -+ * Must be held whenever sequence of commands is to be executed. -+ */ -+ struct mutex lock; -+}; -+ -+DECLARE_CRC8_TABLE(sps30_crc8_table); -+ -+static int sps30_write_then_read(struct sps30_state *state, u8 *txbuf, -+ int txsize, u8 *rxbuf, int rxsize) -+{ -+ int ret; -+ -+ /* -+ * Sensor does not support repeated start so instead of -+ * sending two i2c messages in a row we just send one by one. -+ */ -+ ret = i2c_master_send(state->client, txbuf, txsize); -+ if (ret != txsize) -+ return ret < 0 ? ret : -EIO; -+ -+ if (!rxbuf) -+ return 0; -+ -+ ret = i2c_master_recv(state->client, rxbuf, rxsize); -+ if (ret != rxsize) -+ return ret < 0 ? ret : -EIO; -+ -+ return 0; -+} -+ -+static int sps30_do_cmd(struct sps30_state *state, u16 cmd, u8 *data, int size) -+{ -+ /* -+ * Internally sensor stores measurements in a following manner: -+ * -+ * PM1: upper two bytes, crc8, lower two bytes, crc8 -+ * PM2P5: upper two bytes, crc8, lower two bytes, crc8 -+ * PM4: upper two bytes, crc8, lower two bytes, crc8 -+ * PM10: upper two bytes, crc8, lower two bytes, crc8 -+ * -+ * What follows next are number concentration measurements and -+ * typical particle size measurement which we omit. -+ */ -+ u8 buf[SPS30_MAX_READ_SIZE] = { cmd >> 8, cmd }; -+ int i, ret = 0; -+ -+ switch (cmd) { -+ case SPS30_START_MEAS: -+ buf[2] = 0x03; -+ buf[3] = 0x00; -+ buf[4] = crc8(sps30_crc8_table, &buf[2], 2, CRC8_INIT_VALUE); -+ ret = sps30_write_then_read(state, buf, 5, NULL, 0); -+ break; -+ case SPS30_STOP_MEAS: -+ case SPS30_RESET: -+ ret = sps30_write_then_read(state, buf, 2, NULL, 0); -+ break; -+ case SPS30_READ_DATA_READY_FLAG: -+ case SPS30_READ_DATA: -+ case SPS30_READ_SERIAL: -+ /* every two data bytes are checksummed */ -+ size += size / 2; -+ ret = sps30_write_then_read(state, buf, 2, buf, size); -+ break; -+ } -+ -+ if (ret) -+ return ret; -+ -+ /* validate received data and strip off crc bytes */ -+ for (i = 0; i < size; i += 3) { -+ u8 crc = crc8(sps30_crc8_table, &buf[i], 2, CRC8_INIT_VALUE); -+ -+ if (crc != buf[i + 2]) { -+ dev_err(&state->client->dev, -+ "data integrity check failed\n"); -+ return -EIO; -+ } -+ -+ *data++ = buf[i]; -+ *data++ = buf[i + 1]; -+ } -+ -+ return 0; -+} -+ -+static s32 sps30_float_to_int_clamped(const u8 *fp) -+{ -+ int val = get_unaligned_be32(fp); -+ int mantissa = val & GENMASK(22, 0); -+ /* this is fine since passed float is always non-negative */ -+ int exp = val >> 23; -+ int fraction, shift; -+ -+ /* special case 0 */ -+ if (!exp && !mantissa) -+ return 0; -+ -+ exp -= 127; -+ if (exp < 0) { -+ /* return values ranging from 1 to 99 */ -+ return ((((1 << 23) + mantissa) * 100) >> 23) >> (-exp); -+ } -+ -+ /* return values ranging from 100 to 300000 */ -+ shift = 23 - exp; -+ val = (1 << exp) + (mantissa >> shift); -+ if (val >= SPS30_MAX_PM) -+ return SPS30_MAX_PM * 100; -+ -+ fraction = mantissa & GENMASK(shift - 1, 0); -+ -+ return val * 100 + ((fraction * 100) >> shift); -+} -+ -+static int sps30_do_meas(struct sps30_state *state, s32 *data, int size) -+{ -+ int i, ret, tries = 5; -+ u8 tmp[16]; -+ -+ while (tries--) { -+ ret = sps30_do_cmd(state, SPS30_READ_DATA_READY_FLAG, tmp, 2); -+ if (ret) -+ return -EIO; -+ -+ /* new measurements ready to be read */ -+ if (tmp[1] == 1) -+ break; -+ -+ msleep_interruptible(300); -+ } -+ -+ if (!tries) -+ return -ETIMEDOUT; -+ -+ ret = sps30_do_cmd(state, SPS30_READ_DATA, tmp, sizeof(int) * size); -+ if (ret) -+ return ret; -+ -+ for (i = 0; i < size; i++) -+ data[i] = sps30_float_to_int_clamped(&tmp[4 * i]); -+ -+ return 0; -+} -+ -+static irqreturn_t sps30_trigger_handler(int irq, void *p) -+{ -+ struct iio_poll_func *pf = p; -+ struct iio_dev *indio_dev = pf->indio_dev; -+ struct sps30_state *state = iio_priv(indio_dev); -+ int ret; -+ s32 data[4 + 2]; /* PM1, PM2P5, PM4, PM10, timestamp */ -+ -+ mutex_lock(&state->lock); -+ ret = sps30_do_meas(state, data, 4); -+ mutex_unlock(&state->lock); -+ if (ret) -+ goto err; -+ -+ iio_push_to_buffers_with_timestamp(indio_dev, data, -+ iio_get_time_ns(indio_dev)); -+err: -+ iio_trigger_notify_done(indio_dev->trig); -+ -+ return IRQ_HANDLED; -+} -+ -+static int sps30_read_raw(struct iio_dev *indio_dev, -+ struct iio_chan_spec const *chan, -+ int *val, int *val2, long mask) -+{ -+ struct sps30_state *state = iio_priv(indio_dev); -+ int data[4], ret = -EINVAL; -+ -+ switch (mask) { -+ case IIO_CHAN_INFO_PROCESSED: -+ switch (chan->type) { -+ case IIO_MASSCONCENTRATION: -+ mutex_lock(&state->lock); -+ /* read up to the number of bytes actually needed */ -+ switch (chan->channel2) { -+ case IIO_MOD_PM1: -+ ret = sps30_do_meas(state, data, 1); -+ break; -+ case IIO_MOD_PM2P5: -+ ret = sps30_do_meas(state, data, 2); -+ break; -+ case IIO_MOD_PM4: -+ ret = sps30_do_meas(state, data, 3); -+ break; -+ case IIO_MOD_PM10: -+ ret = sps30_do_meas(state, data, 4); -+ break; -+ } -+ mutex_unlock(&state->lock); -+ if (ret) -+ return ret; -+ -+ *val = data[chan->address] / 100; -+ *val2 = (data[chan->address] % 100) * 10000; -+ -+ return IIO_VAL_INT_PLUS_MICRO; -+ default: -+ return -EINVAL; -+ } -+ case IIO_CHAN_INFO_SCALE: -+ switch (chan->type) { -+ case IIO_MASSCONCENTRATION: -+ switch (chan->channel2) { -+ case IIO_MOD_PM1: -+ case IIO_MOD_PM2P5: -+ case IIO_MOD_PM4: -+ case IIO_MOD_PM10: -+ *val = 0; -+ *val2 = 10000; -+ -+ return IIO_VAL_INT_PLUS_MICRO; -+ } -+ default: -+ return -EINVAL; -+ } -+ } -+ -+ return -EINVAL; -+} -+ -+static const struct iio_info sps30_info = { -+ .read_raw = sps30_read_raw, -+}; -+ -+#define SPS30_CHAN(_index, _mod) { \ -+ .type = IIO_MASSCONCENTRATION, \ -+ .modified = 1, \ -+ .channel2 = IIO_MOD_ ## _mod, \ -+ .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \ -+ .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ -+ .address = _mod, \ -+ .scan_index = _index, \ -+ .scan_type = { \ -+ .sign = 'u', \ -+ .realbits = 19, \ -+ .storagebits = 32, \ -+ .endianness = IIO_CPU, \ -+ }, \ -+} -+ -+static const struct iio_chan_spec sps30_channels[] = { -+ SPS30_CHAN(0, PM1), -+ SPS30_CHAN(1, PM2P5), -+ SPS30_CHAN(2, PM4), -+ SPS30_CHAN(3, PM10), -+ IIO_CHAN_SOFT_TIMESTAMP(4), -+}; -+ -+static void sps30_stop_meas(void *data) -+{ -+ struct sps30_state *state = data; -+ -+ sps30_do_cmd(state, SPS30_STOP_MEAS, NULL, 0); -+} -+ -+static const unsigned long sps30_scan_masks[] = { 0x0f, 0x00 }; -+ -+static int sps30_probe(struct i2c_client *client) -+{ -+ struct iio_dev *indio_dev; -+ struct sps30_state *state; -+ u8 buf[32]; -+ int ret; -+ -+ if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) -+ return -EOPNOTSUPP; -+ -+ indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*state)); -+ if (!indio_dev) -+ return -ENOMEM; -+ -+ state = iio_priv(indio_dev); -+ i2c_set_clientdata(client, indio_dev); -+ state->client = client; -+ indio_dev->dev.parent = &client->dev; -+ indio_dev->info = &sps30_info; -+ indio_dev->name = client->name; -+ indio_dev->channels = sps30_channels; -+ indio_dev->num_channels = ARRAY_SIZE(sps30_channels); -+ indio_dev->modes = INDIO_DIRECT_MODE; -+ indio_dev->available_scan_masks = sps30_scan_masks; -+ -+ mutex_init(&state->lock); -+ crc8_populate_msb(sps30_crc8_table, SPS30_CRC8_POLYNOMIAL); -+ -+ ret = sps30_do_cmd(state, SPS30_RESET, NULL, 0); -+ if (ret) { -+ dev_err(&client->dev, "failed to reset device\n"); -+ return ret; -+ } -+ msleep(300); -+ /* -+ * Power-on-reset causes sensor to produce some glitch on i2c bus and -+ * some controllers end up in error state. Recover simply by placing -+ * some data on the bus, for example STOP_MEAS command, which -+ * is NOP in this case. -+ */ -+ sps30_do_cmd(state, SPS30_STOP_MEAS, NULL, 0); -+ -+ ret = sps30_do_cmd(state, SPS30_READ_SERIAL, buf, sizeof(buf)); -+ if (ret) { -+ dev_err(&client->dev, "failed to read serial number\n"); -+ return ret; -+ } -+ /* returned serial number is already NUL terminated */ -+ dev_info(&client->dev, "serial number: %s\n", buf); -+ -+ ret = sps30_do_cmd(state, SPS30_START_MEAS, NULL, 0); -+ if (ret) { -+ dev_err(&client->dev, "failed to start measurement\n"); -+ return ret; -+ } -+ -+ ret = devm_add_action_or_reset(&client->dev, sps30_stop_meas, state); -+ if (ret) -+ return ret; -+ -+ ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL, -+ sps30_trigger_handler, NULL); -+ if (ret) -+ return ret; -+ -+ return devm_iio_device_register(&client->dev, indio_dev); -+} -+ -+static const struct i2c_device_id sps30_id[] = { -+ { "sps30" }, -+ { } -+}; -+MODULE_DEVICE_TABLE(i2c, sps30_id); -+ -+static const struct of_device_id sps30_of_match[] = { -+ { .compatible = "sensirion,sps30" }, -+ { } -+}; -+MODULE_DEVICE_TABLE(of, sps30_of_match); -+ -+static struct i2c_driver sps30_driver = { -+ .driver = { -+ .name = "sps30", -+ .of_match_table = sps30_of_match, -+ }, -+ .id_table = sps30_id, -+ .probe_new = sps30_probe, -+}; -+module_i2c_driver(sps30_driver); -+ -+MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>"); -+MODULE_DESCRIPTION("Sensirion SPS30 particulate matter sensor driver"); -+MODULE_LICENSE("GPL v2"); |