Add device driver for the HSC pressure sensors with SPI interface. In addition to the main measurement -pressure- these sensors also provide temperature measurement. Signed-off-by: Carlos Iglesias <carlos.iglesias@xxxxxxxxxx> --- MAINTAINERS | 6 + drivers/iio/pressure/Kconfig | 10 + drivers/iio/pressure/Makefile | 2 + drivers/iio/pressure/hsc_spi.c | 543 +++++++++++++++++++++++++++++++++ 4 files changed, 561 insertions(+) create mode 100644 drivers/iio/pressure/hsc_spi.c diff --git a/MAINTAINERS b/MAINTAINERS index 556f902b3766..a4af4cbd4b0f 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -6696,6 +6696,12 @@ W: http://artax.karlin.mff.cuni.cz/~mikulas/vyplody/hpfs/index-e.cgi S: Maintained F: fs/hpfs/ +HSC SERIES PRESSURE SENSORS +M; Carlos Iglesias <carlos.iglesias@xxxxxxxxxx> +S: Maintained +F: Documentation/devicetree/bindings/iio/pressure/hsc_spi.txt +F: drivers/iio/pressure/hsc_spi.c + HSI SUBSYSTEM M: Sebastian Reichel <sre@xxxxxxxxxx> T: git git://git.kernel.org/pub/scm/linux/kernel/git/sre/linux-hsi.git diff --git a/drivers/iio/pressure/Kconfig b/drivers/iio/pressure/Kconfig index eaa7cfcb4c2a..593663d4ffa8 100644 --- a/drivers/iio/pressure/Kconfig +++ b/drivers/iio/pressure/Kconfig @@ -227,4 +227,14 @@ config ZPA2326_SPI tristate select REGMAP_SPI +config HSC_SPI + tristate "Honeywell HSC pressure sensors (SPI)" + depends on SPI_MASTER + help + Say yes here to build support for the Honeywell HSC range of + pressure sensors (SPI interface only). + + To compile this driver as a module, choose M here: the module will + be called hsc_spi. + endmenu diff --git a/drivers/iio/pressure/Makefile b/drivers/iio/pressure/Makefile index c2058d7b2f93..b1db2116e9f6 100644 --- a/drivers/iio/pressure/Makefile +++ b/drivers/iio/pressure/Makefile @@ -31,3 +31,5 @@ obj-$(CONFIG_ZPA2326_SPI) += zpa2326_spi.o obj-$(CONFIG_IIO_ST_PRESS_I2C) += st_pressure_i2c.o obj-$(CONFIG_IIO_ST_PRESS_SPI) += st_pressure_spi.o + +obj-$(CONFIG_HSC_SPI) += hsc_spi.o diff --git a/drivers/iio/pressure/hsc_spi.c b/drivers/iio/pressure/hsc_spi.c new file mode 100644 index 000000000000..efe45a09da8f --- /dev/null +++ b/drivers/iio/pressure/hsc_spi.c @@ -0,0 +1,543 @@ +// SPDX-License-Identifier: GPL-2.0 + +/* + * hsc_spi.c - Driver for Honeywell HSC pressure sensors with + * SPI interface + * + * Copyright (c) 2018 Carlos Iglesias <carlos.iglesias@xxxxxxxxxx> + */ + +#include <linux/device.h> +#include <linux/err.h> +#include <linux/iio/iio.h> +#include <linux/io.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/of_platform.h> +#include <linux/spi/spi.h> + +#define HSC_MAX_SPI_FREQ_HZ 400000 + +#define HSC_TEMP_BITS 11 +#define HSC_PRESS_BITS 14 +#define HSC_TEMP_MASK (0x7FF) +#define HSC_TEMP_SHIFT (5) + +#define HSC_STATUS_S0 BIT(14) +#define HSC_STATUS_S1 BIT(15) +#define HSC_STATUS_MSK ((HSC_STATUS_S0) | (HSC_STATUS_S1)) +#define HSC_STATUS_CMD HSC_STATUS_S0 +#define HSC_STATUS_STALE HSC_STATUS_S1 +#define HSC_STATUS_DIAG ((HSC_STATUS_S0) | (HSC_STATUS_S1)) + +static inline int hsc_status_error(struct device dev, int val) +{ + int st_check = val & HSC_STATUS_MSK; + + if (st_check) { + switch (st_check) { + case HSC_STATUS_CMD: + dev_warn(&dev, "%s:Device in COMMAND MODE\n", + __func__); + return -EIO; + case HSC_STATUS_STALE: + dev_warn(&dev, "%s:Stale data - sampling too fast?\n", + __func__); + return -EAGAIN; + case HSC_STATUS_DIAG: + dev_warn(&dev, "%s:Calibration signature changed\n", + __func__); + return -EIO; + default: + dev_err(&dev, "%s:Invalid status code (%d)\n", + __func__, st_check); + return -EIO; + } + } + + return 0; +} + +enum hsc_variant { + /* Note: Only the absolute range sensors are supported */ + HSC001BAA, HSC001BAB, HSC001BAC, HSC001BAF, + HSC1_6BAA, HSC1_6BAB, HSC1_6BAC, HSC1_6BAF, + HSC2_5BAA, HSC2_5BAB, HSC2_5BAC, HSC2_5BAF, + HSC004BAA, HSC004BAB, HSC004BAC, HSC004BAF, + HSC006BAA, HSC006BAB, HSC006BAC, HSC006BAF, + HSC010BAA, HSC010BAB, HSC010BAC, HSC010BAF, + + HSC100KAA, HSC100KAB, HSC100KAC, HSC100KAF, + HSC160KAA, HSC160KAB, HSC160KAC, HSC160KAF, + HSC250KAA, HSC250KAB, HSC250KAC, HSC250KAF, + HSC400KAA, HSC400KAB, HSC400KAC, HSC400KAF, + HSC600KAA, HSC600KAB, HSC600KAC, HSC600KAF, + HSC001GAA, HSC001GAB, HSC001GAC, HSC001GAF, + + HSC015PAA, HSC015PAB, HSC015PAC, HSC015PAF, + HSC030PAA, HSC030PAB, HSC030PAC, HSC030PAF, + HSC060PAA, HSC060PAB, HSC060PAC, HSC060PAF, + HSC100PAA, HSC100PAB, HSC100PAC, HSC100PAF, + HSC150PAA, HSC150PAB, HSC150PAC, HSC150PAF, +}; + +enum hsc_meas_channel { + HSC_CH_PRESSURE, + HSC_CH_TEMPERATURE +}; + +struct hsc_config { + int pmin; /* Lower pressure limit */ + int pmax; /* Upper pressure limit */ + int rmin; /* Lower transfer function limit (%) */ + int rmax; /* Upper transfer function limit (%) */ + int knum; /* Pressure kPa conversion factor (numerator) */ + int kden; /* Pressure kPa conversion factor /denominator) */ +}; + +struct hsc_fract_val { + int num; /* numerator */ + int den; /* denominator */ +}; + +struct hsc_state { + struct device *dev; + struct spi_device *spi_dev; + struct spi_transfer spi_xfer; + struct spi_message spi_msg; + __be16 rx_buf[2]; + + /* Model-dependent values */ + struct hsc_fract_val scale; + struct hsc_fract_val offset; +}; + +#define HSC_CONFIG(_pmin, _pmax, _rmin, _rmax, _knum, _kden) { \ + .pmin = (_pmin), \ + .pmax = (_pmax), \ + .rmin = (_rmin), \ + .rmax = (_rmax), \ + .knum = (_knum), \ + .kden = (_kden), \ + } + +static struct hsc_config hsc_cfg[] = { + /* Absolute range, mbar */ + [HSC001BAA] = HSC_CONFIG(0, 1000, 10, 90, 1, 10), + [HSC001BAB] = HSC_CONFIG(0, 1000, 5, 95, 1, 10), + [HSC001BAC] = HSC_CONFIG(0, 1000, 5, 85, 1, 10), + [HSC001BAF] = HSC_CONFIG(0, 1000, 4, 94, 1, 10), + [HSC1_6BAA] = HSC_CONFIG(0, 1600, 10, 90, 1, 10), + [HSC1_6BAB] = HSC_CONFIG(0, 1600, 5, 95, 1, 10), + [HSC1_6BAC] = HSC_CONFIG(0, 1600, 5, 85, 1, 10), + [HSC1_6BAF] = HSC_CONFIG(0, 1600, 4, 94, 1, 10), + [HSC2_5BAA] = HSC_CONFIG(0, 2500, 10, 90, 1, 10), + [HSC2_5BAB] = HSC_CONFIG(0, 2500, 5, 95, 1, 10), + [HSC2_5BAC] = HSC_CONFIG(0, 2500, 5, 85, 1, 10), + [HSC2_5BAF] = HSC_CONFIG(0, 2500, 4, 94, 1, 10), + [HSC004BAA] = HSC_CONFIG(0, 4000, 10, 90, 1, 10), + [HSC004BAB] = HSC_CONFIG(0, 4000, 5, 95, 1, 10), + [HSC004BAC] = HSC_CONFIG(0, 4000, 5, 85, 1, 10), + [HSC004BAF] = HSC_CONFIG(0, 4000, 4, 94, 1, 10), + [HSC006BAA] = HSC_CONFIG(0, 6000, 10, 90, 1, 10), + [HSC006BAB] = HSC_CONFIG(0, 6000, 5, 95, 1, 10), + [HSC006BAC] = HSC_CONFIG(0, 6000, 5, 85, 1, 10), + [HSC006BAF] = HSC_CONFIG(0, 6000, 4, 94, 1, 10), + [HSC010BAA] = HSC_CONFIG(0, 10000, 10, 90, 1, 10), + [HSC010BAB] = HSC_CONFIG(0, 10000, 5, 95, 1, 10), + [HSC010BAC] = HSC_CONFIG(0, 10000, 5, 85, 1, 10), + [HSC010BAF] = HSC_CONFIG(0, 10000, 4, 94, 1, 10), + /* Absolute range, kPa */ + [HSC100KAA] = HSC_CONFIG(0, 100, 10, 90, 1, 1), + [HSC100KAB] = HSC_CONFIG(0, 100, 5, 95, 1, 1), + [HSC100KAC] = HSC_CONFIG(0, 100, 5, 85, 1, 1), + [HSC100KAF] = HSC_CONFIG(0, 100, 4, 94, 1, 1), + [HSC160KAA] = HSC_CONFIG(0, 160, 10, 90, 1, 1), + [HSC160KAB] = HSC_CONFIG(0, 160, 5, 95, 1, 1), + [HSC160KAC] = HSC_CONFIG(0, 160, 5, 85, 1, 1), + [HSC160KAF] = HSC_CONFIG(0, 160, 4, 94, 1, 1), + [HSC250KAA] = HSC_CONFIG(0, 250, 10, 90, 1, 1), + [HSC250KAB] = HSC_CONFIG(0, 250, 5, 95, 1, 1), + [HSC250KAC] = HSC_CONFIG(0, 250, 5, 85, 1, 1), + [HSC250KAF] = HSC_CONFIG(0, 250, 4, 94, 1, 1), + [HSC400KAA] = HSC_CONFIG(0, 400, 10, 90, 1, 1), + [HSC400KAB] = HSC_CONFIG(0, 400, 5, 95, 1, 1), + [HSC400KAC] = HSC_CONFIG(0, 400, 5, 85, 1, 1), + [HSC400KAF] = HSC_CONFIG(0, 400, 4, 94, 1, 1), + [HSC600KAA] = HSC_CONFIG(0, 600, 10, 90, 1, 1), + [HSC600KAB] = HSC_CONFIG(0, 600, 5, 95, 1, 1), + [HSC600KAC] = HSC_CONFIG(0, 600, 5, 85, 1, 1), + [HSC600KAF] = HSC_CONFIG(0, 600, 4, 94, 1, 1), + [HSC001GAA] = HSC_CONFIG(0, 1000, 10, 90, 1, 1), + [HSC001GAB] = HSC_CONFIG(0, 1000, 5, 95, 1, 1), + [HSC001GAC] = HSC_CONFIG(0, 1000, 5, 85, 1, 1), + [HSC001GAF] = HSC_CONFIG(0, 1000, 4, 94, 1, 1), + /* Absolute range, psi */ + [HSC015PAA] = HSC_CONFIG(0, 15, 10, 90, 6895, 1000), + [HSC015PAB] = HSC_CONFIG(0, 15, 5, 95, 6895, 1000), + [HSC015PAC] = HSC_CONFIG(0, 15, 5, 85, 6895, 1000), + [HSC015PAF] = HSC_CONFIG(0, 15, 4, 94, 6895, 1000), + [HSC030PAA] = HSC_CONFIG(0, 30, 10, 90, 6895, 1000), + [HSC030PAB] = HSC_CONFIG(0, 30, 5, 95, 6895, 1000), + [HSC030PAC] = HSC_CONFIG(0, 30, 5, 85, 6895, 1000), + [HSC030PAF] = HSC_CONFIG(0, 30, 4, 94, 6895, 1000), + [HSC060PAA] = HSC_CONFIG(0, 60, 10, 90, 6895, 1000), + [HSC060PAB] = HSC_CONFIG(0, 60, 5, 95, 6895, 1000), + [HSC060PAC] = HSC_CONFIG(0, 60, 5, 85, 6895, 1000), + [HSC060PAF] = HSC_CONFIG(0, 60, 4, 94, 6895, 1000), + [HSC100PAA] = HSC_CONFIG(0, 100, 10, 90, 6895, 1000), + [HSC100PAB] = HSC_CONFIG(0, 100, 5, 95, 6895, 1000), + [HSC100PAC] = HSC_CONFIG(0, 100, 5, 85, 6895, 1000), + [HSC100PAF] = HSC_CONFIG(0, 100, 4, 94, 6895, 1000), + [HSC150PAA] = HSC_CONFIG(0, 150, 10, 90, 6895, 1000), + [HSC150PAB] = HSC_CONFIG(0, 150, 5, 95, 6895, 1000), + [HSC150PAC] = HSC_CONFIG(0, 150, 5, 85, 6895, 1000), + [HSC150PAF] = HSC_CONFIG(0, 150, 4, 94, 6895, 1000), +}; + +static const struct iio_chan_spec hsc_channels[] = { + { + .type = IIO_PRESSURE, + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | + BIT(IIO_CHAN_INFO_OFFSET) | + BIT(IIO_CHAN_INFO_SCALE), + .channel = HSC_CH_PRESSURE, + .scan_type = { + .sign = 'u', + .realbits = HSC_PRESS_BITS, + .storagebits = 16, + .shift = 0, + .endianness = IIO_BE, + } + }, + { + .type = IIO_TEMP, + .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | + BIT(IIO_CHAN_INFO_OFFSET) | + BIT(IIO_CHAN_INFO_SCALE), + .channel = HSC_CH_TEMPERATURE, + .scan_type = { + .sign = 'u', + .realbits = HSC_TEMP_BITS, + .storagebits = 16, + .shift = HSC_TEMP_SHIFT, + .endianness = IIO_BE, + } + } +}; + +static int hsc_get_pressure(struct hsc_state *state) +{ + int ret = 0; + int error; + + state->spi_xfer.len = 2; + ret = spi_sync(state->spi_dev, &state->spi_msg); + if (ret) + return ret; + + ret = be16_to_cpu(state->rx_buf[0]); + + error = hsc_status_error(state->spi_dev->dev, ret); + if (error) + return error; + + return ret; +} + +static int hsc_get_temperature(struct hsc_state *state) +{ + int ret; + int error; + + state->spi_xfer.len = 4; + ret = spi_sync(state->spi_dev, &state->spi_msg); + if (ret) + return ret; + + ret = be16_to_cpu(state->rx_buf[0]); + error = hsc_status_error(state->spi_dev->dev, ret); + if (error) + return error; + + ret = be16_to_cpu(state->rx_buf[1]); + ret = (ret >> HSC_TEMP_SHIFT) & HSC_TEMP_MASK; + + return ret; +} + +static int hsc_read_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, int *val, + int *val2, long mask) +{ + struct hsc_state *state = iio_priv(indio_dev); + int ret; + + switch (mask) { + case IIO_CHAN_INFO_RAW: + switch (chan->channel) { + case HSC_CH_PRESSURE: + ret = hsc_get_pressure(state); + if (ret < 0) + break; + *val = ret; + ret = IIO_VAL_INT; + break; + case HSC_CH_TEMPERATURE: + ret = hsc_get_temperature(state); + if (ret < 0) + break; + *val = ret; + ret = IIO_VAL_INT; + break; + default: + ret = -EINVAL; + dev_err(state->dev, + "%s - IIO_CHAN_INFO_RAW-bad channel (%d)\n", + __func__, chan->channel); + break; + } + break; + case IIO_CHAN_INFO_OFFSET: + switch (chan->channel) { + case HSC_CH_PRESSURE: + *val = state->offset.num; + *val2 = state->offset.den; + ret = IIO_VAL_FRACTIONAL; + break; + case HSC_CH_TEMPERATURE: + *val = BIT(HSC_TEMP_BITS) - 1; + *val2 = -200 / 50; + ret = IIO_VAL_FRACTIONAL; + break; + default: + dev_err(state->dev, + "%s - IIO_CHAN_INFO_OFFSET-bad channel (%d)\n", + __func__, chan->channel); + ret = -EINVAL; + break; + } + break; + case IIO_CHAN_INFO_SCALE: + switch (chan->channel) { + case HSC_CH_PRESSURE: /* output unit is kPa */ + *val = state->scale.num; + *val2 = state->scale.den; + ret = IIO_VAL_FRACTIONAL; + break; + case HSC_CH_TEMPERATURE: /* output unit is milli Celsius */ + *val = 200 * 1000; + *val2 = BIT(HSC_TEMP_BITS) - 1; + ret = IIO_VAL_FRACTIONAL; + break; + default: + dev_err(state->dev, + "%s - IIO_CHAN_INFO_SCALE-bad channel (%d)\n", + __func__, chan->channel); + ret = -EINVAL; + break; + } + break; + default: + dev_err(state->dev, "%s - mask = %ld (INVALID)\n", + __func__, mask); + ret = -EINVAL; + break; + } + + return ret; +} + +static const struct iio_info hsc_info = { + .read_raw = hsc_read_raw, +}; + +static void hsc_init_device(struct iio_dev *indio_dev) +{ + struct hsc_state *state = iio_priv(indio_dev); + const struct hsc_config *cfg = of_device_get_match_data(state->dev); + + /* Pressure offset value */ + state->offset.num = BIT(HSC_PRESS_BITS) * + (cfg->pmin * cfg->rmax - cfg->pmax * cfg->rmin); + state->offset.den = 100 * (cfg->pmax - cfg->pmin); + + /* Pressure scale value */ + state->scale.num = 100 * cfg->knum * (cfg->pmax - cfg->pmin); + state->scale.den = BIT(HSC_PRESS_BITS) * + cfg->kden * (cfg->rmax - cfg->rmin); +} + +static int hsc_spi_probe(struct spi_device *spi) +{ + struct device *dev = &spi->dev; + struct hsc_state *state; + struct iio_dev *indio_dev; + int ret; + + if (spi->max_speed_hz > HSC_MAX_SPI_FREQ_HZ) { + dev_warn(dev, "SPI CLK, %d Hz exceeds %d Hz - changed to max\n", + spi->max_speed_hz, + HSC_MAX_SPI_FREQ_HZ); + spi->max_speed_hz = HSC_MAX_SPI_FREQ_HZ; + } + + spi->bits_per_word = 8; + spi->mode = SPI_MODE_0; + + ret = spi_setup(spi); + if (ret < 0) { + dev_err(dev, "%s - Error in spi_setup()\n", __func__); + return ret; + } + + indio_dev = devm_iio_device_alloc(dev, sizeof(*state)); + if (!indio_dev) { + dev_err(dev, "%s - Error allocating iio_device\n", __func__); + return -ENOMEM; + } + + state = iio_priv(indio_dev); + spi_set_drvdata(spi, state); + state->spi_dev = spi; + state->dev = dev; + + indio_dev->dev.parent = dev; + indio_dev->modes = INDIO_DIRECT_MODE; + indio_dev->info = &hsc_info; + indio_dev->channels = hsc_channels; + indio_dev->num_channels = ARRAY_SIZE(hsc_channels); + + state->spi_xfer.rx_buf = &state->rx_buf[0]; + state->spi_xfer.tx_buf = NULL; + state->spi_xfer.cs_change = 0; + spi_message_init(&state->spi_msg); + spi_message_add_tail(&state->spi_xfer, &state->spi_msg); + + hsc_init_device(indio_dev); + + ret = iio_device_register(indio_dev); + if (ret < 0) + dev_err(dev, "iio_device_register failed: %d\n", ret); + + dev_dbg(dev, "%s - scale = %d/%d, offset = %d/%d\n", __func__, + state->scale.num, state->scale.den, + state->offset.num, state->offset.den); + + return ret; +} + +static int hsc_spi_remove(struct spi_device *spi) +{ + struct device *dev = &spi->dev; + struct iio_dev *indio_dev = dev_get_drvdata(dev); + + iio_device_unregister(indio_dev); + + return 0; +} + +static const struct of_device_id hsc_of_match[] = { + { .compatible = "honeywell,hsc001baa", .data = &hsc_cfg[HSC001BAA] }, + { .compatible = "honeywell,hsc001bab", .data = &hsc_cfg[HSC001BAB] }, + { .compatible = "honeywell,hsc001bac", .data = &hsc_cfg[HSC001BAC] }, + { .compatible = "honeywell,hsc001baf", .data = &hsc_cfg[HSC001BAF] }, + + { .compatible = "honeywell,hsc1_6baa", .data = &hsc_cfg[HSC1_6BAA] }, + { .compatible = "honeywell,hsc1_6bab", .data = &hsc_cfg[HSC1_6BAB] }, + { .compatible = "honeywell,hsc1_6bac", .data = &hsc_cfg[HSC1_6BAC] }, + { .compatible = "honeywell,hsc1_6baf", .data = &hsc_cfg[HSC1_6BAF] }, + + { .compatible = "honeywell,hsc2_5baa", .data = &hsc_cfg[HSC2_5BAA] }, + { .compatible = "honeywell,hsc2_5bab", .data = &hsc_cfg[HSC2_5BAB] }, + { .compatible = "honeywell,hsc2_5bac", .data = &hsc_cfg[HSC2_5BAC] }, + { .compatible = "honeywell,hsc2_5baf", .data = &hsc_cfg[HSC2_5BAF] }, + + { .compatible = "honeywell,hsc004baa", .data = &hsc_cfg[HSC004BAA] }, + { .compatible = "honeywell,hsc004bab", .data = &hsc_cfg[HSC004BAB] }, + { .compatible = "honeywell,hsc004bac", .data = &hsc_cfg[HSC004BAC] }, + { .compatible = "honeywell,hsc004baf", .data = &hsc_cfg[HSC004BAF] }, + + { .compatible = "honeywell,hsc006baa", .data = &hsc_cfg[HSC006BAA] }, + { .compatible = "honeywell,hsc006bab", .data = &hsc_cfg[HSC006BAB] }, + { .compatible = "honeywell,hsc006bac", .data = &hsc_cfg[HSC006BAC] }, + { .compatible = "honeywell,hsc006baf", .data = &hsc_cfg[HSC006BAF] }, + + { .compatible = "honeywell,hsc010baa", .data = &hsc_cfg[HSC010BAA] }, + { .compatible = "honeywell,hsc010bab", .data = &hsc_cfg[HSC010BAB] }, + { .compatible = "honeywell,hsc010bac", .data = &hsc_cfg[HSC010BAC] }, + { .compatible = "honeywell,hsc010baf", .data = &hsc_cfg[HSC010BAF] }, + + { .compatible = "honeywell,hsc100kaa", .data = &hsc_cfg[HSC100KAA] }, + { .compatible = "honeywell,hsc100kab", .data = &hsc_cfg[HSC100KAB] }, + { .compatible = "honeywell,hsc100kac", .data = &hsc_cfg[HSC100KAC] }, + { .compatible = "honeywell,hsc100kaf", .data = &hsc_cfg[HSC100KAF] }, + + { .compatible = "honeywell,hsc160kaa", .data = &hsc_cfg[HSC160KAA] }, + { .compatible = "honeywell,hsc160kab", .data = &hsc_cfg[HSC160KAB] }, + { .compatible = "honeywell,hsc160kac", .data = &hsc_cfg[HSC160KAC] }, + { .compatible = "honeywell,hsc160kaf", .data = &hsc_cfg[HSC160KAF] }, + + { .compatible = "honeywell,hsc250kaa", .data = &hsc_cfg[HSC250KAA] }, + { .compatible = "honeywell,hsc250kab", .data = &hsc_cfg[HSC250KAB] }, + { .compatible = "honeywell,hsc250kac", .data = &hsc_cfg[HSC250KAC] }, + { .compatible = "honeywell,hsc250kaf", .data = &hsc_cfg[HSC250KAF] }, + + { .compatible = "honeywell,hsc400kaa", .data = &hsc_cfg[HSC400KAA] }, + { .compatible = "honeywell,hsc400kab", .data = &hsc_cfg[HSC400KAB] }, + { .compatible = "honeywell,hsc400kac", .data = &hsc_cfg[HSC400KAC] }, + { .compatible = "honeywell,hsc400kaf", .data = &hsc_cfg[HSC400KAF] }, + + { .compatible = "honeywell,hsc600kaa", .data = &hsc_cfg[HSC600KAA] }, + { .compatible = "honeywell,hsc600kab", .data = &hsc_cfg[HSC600KAB] }, + { .compatible = "honeywell,hsc600kac", .data = &hsc_cfg[HSC600KAC] }, + { .compatible = "honeywell,hsc600kaf", .data = &hsc_cfg[HSC600KAF] }, + + { .compatible = "honeywell,hsc001gaa", .data = &hsc_cfg[HSC001GAA] }, + { .compatible = "honeywell,hsc001gab", .data = &hsc_cfg[HSC001GAB] }, + { .compatible = "honeywell,hsc001gac", .data = &hsc_cfg[HSC001GAC] }, + { .compatible = "honeywell,hsc001gaf", .data = &hsc_cfg[HSC001GAF] }, + + { .compatible = "honeywell,hsc015paa", .data = &hsc_cfg[HSC015PAA] }, + { .compatible = "honeywell,hsc015pab", .data = &hsc_cfg[HSC015PAB] }, + { .compatible = "honeywell,hsc015pac", .data = &hsc_cfg[HSC015PAC] }, + { .compatible = "honeywell,hsc015paf", .data = &hsc_cfg[HSC015PAF] }, + + { .compatible = "honeywell,hsc030paa", .data = &hsc_cfg[HSC030PAA] }, + { .compatible = "honeywell,hsc030pab", .data = &hsc_cfg[HSC030PAB] }, + { .compatible = "honeywell,hsc030pac", .data = &hsc_cfg[HSC030PAC] }, + { .compatible = "honeywell,hsc030paf", .data = &hsc_cfg[HSC030PAF] }, + + { .compatible = "honeywell,hsc060paa", .data = &hsc_cfg[HSC060PAA] }, + { .compatible = "honeywell,hsc060pab", .data = &hsc_cfg[HSC060PAB] }, + { .compatible = "honeywell,hsc060pac", .data = &hsc_cfg[HSC060PAC] }, + { .compatible = "honeywell,hsc060paf", .data = &hsc_cfg[HSC060PAF] }, + + { .compatible = "honeywell,hsc100paa", .data = &hsc_cfg[HSC100PAA] }, + { .compatible = "honeywell,hsc100pab", .data = &hsc_cfg[HSC100PAB] }, + { .compatible = "honeywell,hsc100pac", .data = &hsc_cfg[HSC100PAC] }, + { .compatible = "honeywell,hsc100paf", .data = &hsc_cfg[HSC100PAF] }, + + { .compatible = "honeywell,hsc150paa", .data = &hsc_cfg[HSC150PAA] }, + { .compatible = "honeywell,hsc150pab", .data = &hsc_cfg[HSC150PAB] }, + { .compatible = "honeywell,hsc150pac", .data = &hsc_cfg[HSC150PAC] }, + { .compatible = "honeywell,hsc150paf", .data = &hsc_cfg[HSC150PAF] }, + + { }, +}; +MODULE_DEVICE_TABLE(of, hsc_of_match); + +static struct spi_driver hsc_spi_driver = { + .probe = hsc_spi_probe, + .remove = hsc_spi_remove, + .driver = { + .name = "hsc_spi_pressure_sensor", + .of_match_table = hsc_of_match, + }, +}; + +module_spi_driver(hsc_spi_driver); + +MODULE_AUTHOR("Carlos Iglesias <carlosiglesias@xxxxxxxxxx>"); +MODULE_DESCRIPTION("Honeywell HSC SPI pressure sensor driver"); +MODULE_LICENSE("GPL v2"); -- 2.19.1
