iio/chemical/pms7003.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Plantower PMS7003 particulate matter sensor driver
0004  *
0005  * Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>
0006  */
0007
0008 #include <asm/unaligned.h>
0009 #include <linux/completion.h>
0010 #include <linux/device.h>
0011 #include <linux/errno.h>
0012 #include <linux/iio/buffer.h>
0013 #include <linux/iio/iio.h>
0014 #include <linux/iio/trigger_consumer.h>
0015 #include <linux/iio/triggered_buffer.h>
0016 #include <linux/jiffies.h>
0017 #include <linux/kernel.h>
0018 #include <linux/mod_devicetable.h>
0019 #include <linux/module.h>
0020 #include <linux/mutex.h>
0021 #include <linux/serdev.h>
0022
0023 #define PMS7003_DRIVER_NAME "pms7003"
0024
0025 #define PMS7003_MAGIC 0x424d
0026 /* last 2 data bytes hold frame checksum */
0027 #define PMS7003_MAX_DATA_LENGTH 28
0028 #define PMS7003_CHECKSUM_LENGTH 2
0029 #define PMS7003_PM10_OFFSET 10
0030 #define PMS7003_PM2P5_OFFSET 8
0031 #define PMS7003_PM1_OFFSET 6
0032
0033 #define PMS7003_TIMEOUT msecs_to_jiffies(6000)
0034 #define PMS7003_CMD_LENGTH 7
0035 #define PMS7003_PM_MAX 1000
0036 #define PMS7003_PM_MIN 0
0037
0038 enum {
0039     PM1,
0040     PM2P5,
0041     PM10,
0042 };
0043
0044 enum pms7003_cmd {
0045     CMD_WAKEUP,
0046     CMD_ENTER_PASSIVE_MODE,
0047     CMD_READ_PASSIVE,
0048     CMD_SLEEP,
0049 };
0050
0051 /*
0052  * commands have following format:
0053  *
0054  * +------+------+-----+------+-----+-----------+-----------+
0055  * | 0x42 | 0x4d | cmd | 0x00 | arg | cksum msb | cksum lsb |
0056  * +------+------+-----+------+-----+-----------+-----------+
0057  */
0058 static const u8 pms7003_cmd_tbl[][PMS7003_CMD_LENGTH] = {
0059     [CMD_WAKEUP] = { 0x42, 0x4d, 0xe4, 0x00, 0x01, 0x01, 0x74 },
0060     [CMD_ENTER_PASSIVE_MODE] = { 0x42, 0x4d, 0xe1, 0x00, 0x00, 0x01, 0x70 },
0061     [CMD_READ_PASSIVE] = { 0x42, 0x4d, 0xe2, 0x00, 0x00, 0x01, 0x71 },
0062     [CMD_SLEEP] = { 0x42, 0x4d, 0xe4, 0x00, 0x00, 0x01, 0x73 },
0063 };
0064
0065 struct pms7003_frame {
0066     u8 data[PMS7003_MAX_DATA_LENGTH];
0067     u16 expected_length;
0068     u16 length;
0069 };
0070
0071 struct pms7003_state {
0072     struct serdev_device *serdev;
0073     struct pms7003_frame frame;
0074     struct completion frame_ready;
0075     struct mutex lock; /* must be held whenever state gets touched */
0076     /* Used to construct scan to push to the IIO buffer */
0077     struct {
0078         u16 data[3]; /* PM1, PM2P5, PM10 */
0079         s64 ts;
0080     } scan;
0081 };
0082
0083 static int pms7003_do_cmd(struct pms7003_state *state, enum pms7003_cmd cmd)
0084 {
0085     int ret;
0086
0087     ret = serdev_device_write(state->serdev, pms7003_cmd_tbl[cmd],
0088                   PMS7003_CMD_LENGTH, PMS7003_TIMEOUT);
0089     if (ret < PMS7003_CMD_LENGTH)
0090         return ret < 0 ? ret : -EIO;
0091
0092     ret = wait_for_completion_interruptible_timeout(&state->frame_ready,
0093                             PMS7003_TIMEOUT);
0094     if (!ret)
0095         ret = -ETIMEDOUT;
0096
0097     return ret < 0 ? ret : 0;
0098 }
0099
0100 static u16 pms7003_get_pm(const u8 *data)
0101 {
0102     return clamp_val(get_unaligned_be16(data),
0103              PMS7003_PM_MIN, PMS7003_PM_MAX);
0104 }
0105
0106 static irqreturn_t pms7003_trigger_handler(int irq, void *p)
0107 {
0108     struct iio_poll_func *pf = p;
0109     struct iio_dev *indio_dev = pf->indio_dev;
0110     struct pms7003_state *state = iio_priv(indio_dev);
0111     struct pms7003_frame *frame = &state->frame;
0112     int ret;
0113
0114     mutex_lock(&state->lock);
0115     ret = pms7003_do_cmd(state, CMD_READ_PASSIVE);
0116     if (ret) {
0117         mutex_unlock(&state->lock);
0118         goto err;
0119     }
0120
0121     state->scan.data[PM1] =
0122         pms7003_get_pm(frame->data + PMS7003_PM1_OFFSET);
0123     state->scan.data[PM2P5] =
0124         pms7003_get_pm(frame->data + PMS7003_PM2P5_OFFSET);
0125     state->scan.data[PM10] =
0126         pms7003_get_pm(frame->data + PMS7003_PM10_OFFSET);
0127     mutex_unlock(&state->lock);
0128
0129     iio_push_to_buffers_with_timestamp(indio_dev, &state->scan,
0130                        iio_get_time_ns(indio_dev));
0131 err:
0132     iio_trigger_notify_done(indio_dev->trig);
0133
0134     return IRQ_HANDLED;
0135 }
0136
0137 static int pms7003_read_raw(struct iio_dev *indio_dev,
0138                 struct iio_chan_spec const *chan,
0139                 int *val, int *val2, long mask)
0140 {
0141     struct pms7003_state *state = iio_priv(indio_dev);
0142     struct pms7003_frame *frame = &state->frame;
0143     int ret;
0144
0145     switch (mask) {
0146     case IIO_CHAN_INFO_PROCESSED:
0147         switch (chan->type) {
0148         case IIO_MASSCONCENTRATION:
0149             mutex_lock(&state->lock);
0150             ret = pms7003_do_cmd(state, CMD_READ_PASSIVE);
0151             if (ret) {
0152                 mutex_unlock(&state->lock);
0153                 return ret;
0154             }
0155
0156             *val = pms7003_get_pm(frame->data + chan->address);
0157             mutex_unlock(&state->lock);
0158
0159             return IIO_VAL_INT;
0160         default:
0161             return -EINVAL;
0162         }
0163     }
0164
0165     return -EINVAL;
0166 }
0167
0168 static const struct iio_info pms7003_info = {
0169     .read_raw = pms7003_read_raw,
0170 };
0171
0172 #define PMS7003_CHAN(_index, _mod, _addr) { \
0173     .type = IIO_MASSCONCENTRATION, \
0174     .modified = 1, \
0175     .channel2 = IIO_MOD_ ## _mod, \
0176     .address = _addr, \
0177     .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \
0178     .scan_index = _index, \
0179     .scan_type = { \
0180         .sign = 'u', \
0181         .realbits = 10, \
0182         .storagebits = 16, \
0183         .endianness = IIO_CPU, \
0184     }, \
0185 }
0186
0187 static const struct iio_chan_spec pms7003_channels[] = {
0188     PMS7003_CHAN(0, PM1, PMS7003_PM1_OFFSET),
0189     PMS7003_CHAN(1, PM2P5, PMS7003_PM2P5_OFFSET),
0190     PMS7003_CHAN(2, PM10, PMS7003_PM10_OFFSET),
0191     IIO_CHAN_SOFT_TIMESTAMP(3),
0192 };
0193
0194 static u16 pms7003_calc_checksum(struct pms7003_frame *frame)
0195 {
0196     u16 checksum = (PMS7003_MAGIC >> 8) + (u8)(PMS7003_MAGIC & 0xff) +
0197                (frame->length >> 8) + (u8)frame->length;
0198     int i;
0199
0200     for (i = 0; i < frame->length - PMS7003_CHECKSUM_LENGTH; i++)
0201         checksum += frame->data[i];
0202
0203     return checksum;
0204 }
0205
0206 static bool pms7003_frame_is_okay(struct pms7003_frame *frame)
0207 {
0208     int offset = frame->length - PMS7003_CHECKSUM_LENGTH;
0209     u16 checksum = get_unaligned_be16(frame->data + offset);
0210
0211     return checksum == pms7003_calc_checksum(frame);
0212 }
0213
0214 static int pms7003_receive_buf(struct serdev_device *serdev,
0215                    const unsigned char *buf, size_t size)
0216 {
0217     struct iio_dev *indio_dev = serdev_device_get_drvdata(serdev);
0218     struct pms7003_state *state = iio_priv(indio_dev);
0219     struct pms7003_frame *frame = &state->frame;
0220     int num;
0221
0222     if (!frame->expected_length) {
0223         u16 magic;
0224
0225         /* wait for SOF and data length */
0226         if (size < 4)
0227             return 0;
0228
0229         magic = get_unaligned_be16(buf);
0230         if (magic != PMS7003_MAGIC)
0231             return 2;
0232
0233         num = get_unaligned_be16(buf + 2);
0234         if (num <= PMS7003_MAX_DATA_LENGTH) {
0235             frame->expected_length = num;
0236             frame->length = 0;
0237         }
0238
0239         return 4;
0240     }
0241
0242     num = min(size, (size_t)(frame->expected_length - frame->length));
0243     memcpy(frame->data + frame->length, buf, num);
0244     frame->length += num;
0245
0246     if (frame->length == frame->expected_length) {
0247         if (pms7003_frame_is_okay(frame))
0248             complete(&state->frame_ready);
0249
0250         frame->expected_length = 0;
0251     }
0252
0253     return num;
0254 }
0255
0256 static const struct serdev_device_ops pms7003_serdev_ops = {
0257     .receive_buf = pms7003_receive_buf,
0258     .write_wakeup = serdev_device_write_wakeup,
0259 };
0260
0261 static void pms7003_stop(void *data)
0262 {
0263     struct pms7003_state *state = data;
0264
0265     pms7003_do_cmd(state, CMD_SLEEP);
0266 }
0267
0268 static const unsigned long pms7003_scan_masks[] = { 0x07, 0x00 };
0269
0270 static int pms7003_probe(struct serdev_device *serdev)
0271 {
0272     struct pms7003_state *state;
0273     struct iio_dev *indio_dev;
0274     int ret;
0275
0276     indio_dev = devm_iio_device_alloc(&serdev->dev, sizeof(*state));
0277     if (!indio_dev)
0278         return -ENOMEM;
0279
0280     state = iio_priv(indio_dev);
0281     serdev_device_set_drvdata(serdev, indio_dev);
0282     state->serdev = serdev;
0283     indio_dev->info = &pms7003_info;
0284     indio_dev->name = PMS7003_DRIVER_NAME;
0285     indio_dev->channels = pms7003_channels;
0286     indio_dev->num_channels = ARRAY_SIZE(pms7003_channels);
0287     indio_dev->modes = INDIO_DIRECT_MODE;
0288     indio_dev->available_scan_masks = pms7003_scan_masks;
0289
0290     mutex_init(&state->lock);
0291     init_completion(&state->frame_ready);
0292
0293     serdev_device_set_client_ops(serdev, &pms7003_serdev_ops);
0294     ret = devm_serdev_device_open(&serdev->dev, serdev);
0295     if (ret)
0296         return ret;
0297
0298     serdev_device_set_baudrate(serdev, 9600);
0299     serdev_device_set_flow_control(serdev, false);
0300
0301     ret = serdev_device_set_parity(serdev, SERDEV_PARITY_NONE);
0302     if (ret)
0303         return ret;
0304
0305     ret = pms7003_do_cmd(state, CMD_WAKEUP);
0306     if (ret) {
0307         dev_err(&serdev->dev, "failed to wakeup sensor\n");
0308         return ret;
0309     }
0310
0311     ret = pms7003_do_cmd(state, CMD_ENTER_PASSIVE_MODE);
0312     if (ret) {
0313         dev_err(&serdev->dev, "failed to enter passive mode\n");
0314         return ret;
0315     }
0316
0317     ret = devm_add_action_or_reset(&serdev->dev, pms7003_stop, state);
0318     if (ret)
0319         return ret;
0320
0321     ret = devm_iio_triggered_buffer_setup(&serdev->dev, indio_dev, NULL,
0322                           pms7003_trigger_handler, NULL);
0323     if (ret)
0324         return ret;
0325
0326     return devm_iio_device_register(&serdev->dev, indio_dev);
0327 }
0328
0329 static const struct of_device_id pms7003_of_match[] = {
0330     { .compatible = "plantower,pms1003" },
0331     { .compatible = "plantower,pms3003" },
0332     { .compatible = "plantower,pms5003" },
0333     { .compatible = "plantower,pms6003" },
0334     { .compatible = "plantower,pms7003" },
0335     { .compatible = "plantower,pmsa003" },
0336     { }
0337 };
0338 MODULE_DEVICE_TABLE(of, pms7003_of_match);
0339
0340 static struct serdev_device_driver pms7003_driver = {
0341     .driver = {
0342         .name = PMS7003_DRIVER_NAME,
0343         .of_match_table = pms7003_of_match,
0344     },
0345     .probe = pms7003_probe,
0346 };
0347 module_serdev_device_driver(pms7003_driver);
0348
0349 MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>");
0350 MODULE_DESCRIPTION("Plantower PMS7003 particulate matter sensor driver");
0351 MODULE_LICENSE("GPL v2");