linux/drivers/iio/chemical/pms7003.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Plantower PMS7003 particulate matter sensor driver
   4 *
   5 * Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>
   6 */
   7
   8#include <asm/unaligned.h>
   9#include <linux/completion.h>
  10#include <linux/device.h>
  11#include <linux/errno.h>
  12#include <linux/iio/buffer.h>
  13#include <linux/iio/iio.h>
  14#include <linux/iio/trigger_consumer.h>
  15#include <linux/iio/triggered_buffer.h>
  16#include <linux/jiffies.h>
  17#include <linux/kernel.h>
  18#include <linux/mod_devicetable.h>
  19#include <linux/module.h>
  20#include <linux/mutex.h>
  21#include <linux/serdev.h>
  22
  23#define PMS7003_DRIVER_NAME "pms7003"
  24
  25#define PMS7003_MAGIC 0x424d
  26/* last 2 data bytes hold frame checksum */
  27#define PMS7003_MAX_DATA_LENGTH 28
  28#define PMS7003_CHECKSUM_LENGTH 2
  29#define PMS7003_PM10_OFFSET 10
  30#define PMS7003_PM2P5_OFFSET 8
  31#define PMS7003_PM1_OFFSET 6
  32
  33#define PMS7003_TIMEOUT msecs_to_jiffies(6000)
  34#define PMS7003_CMD_LENGTH 7
  35#define PMS7003_PM_MAX 1000
  36#define PMS7003_PM_MIN 0
  37
  38enum {
  39        PM1,
  40        PM2P5,
  41        PM10,
  42};
  43
  44enum pms7003_cmd {
  45        CMD_WAKEUP,
  46        CMD_ENTER_PASSIVE_MODE,
  47        CMD_READ_PASSIVE,
  48        CMD_SLEEP,
  49};
  50
  51/*
  52 * commands have following format:
  53 *
  54 * +------+------+-----+------+-----+-----------+-----------+
  55 * | 0x42 | 0x4d | cmd | 0x00 | arg | cksum msb | cksum lsb |
  56 * +------+------+-----+------+-----+-----------+-----------+
  57 */
  58static const u8 pms7003_cmd_tbl[][PMS7003_CMD_LENGTH] = {
  59        [CMD_WAKEUP] = { 0x42, 0x4d, 0xe4, 0x00, 0x01, 0x01, 0x74 },
  60        [CMD_ENTER_PASSIVE_MODE] = { 0x42, 0x4d, 0xe1, 0x00, 0x00, 0x01, 0x70 },
  61        [CMD_READ_PASSIVE] = { 0x42, 0x4d, 0xe2, 0x00, 0x00, 0x01, 0x71 },
  62        [CMD_SLEEP] = { 0x42, 0x4d, 0xe4, 0x00, 0x00, 0x01, 0x73 },
  63};
  64
  65struct pms7003_frame {
  66        u8 data[PMS7003_MAX_DATA_LENGTH];
  67        u16 expected_length;
  68        u16 length;
  69};
  70
  71struct pms7003_state {
  72        struct serdev_device *serdev;
  73        struct pms7003_frame frame;
  74        struct completion frame_ready;
  75        struct mutex lock; /* must be held whenever state gets touched */
  76        /* Used to construct scan to push to the IIO buffer */
  77        struct {
  78                u16 data[3]; /* PM1, PM2P5, PM10 */
  79                s64 ts;
  80        } scan;
  81};
  82
  83static int pms7003_do_cmd(struct pms7003_state *state, enum pms7003_cmd cmd)
  84{
  85        int ret;
  86
  87        ret = serdev_device_write(state->serdev, pms7003_cmd_tbl[cmd],
  88                                  PMS7003_CMD_LENGTH, PMS7003_TIMEOUT);
  89        if (ret < PMS7003_CMD_LENGTH)
  90                return ret < 0 ? ret : -EIO;
  91
  92        ret = wait_for_completion_interruptible_timeout(&state->frame_ready,
  93                                                        PMS7003_TIMEOUT);
  94        if (!ret)
  95                ret = -ETIMEDOUT;
  96
  97        return ret < 0 ? ret : 0;
  98}
  99
 100static u16 pms7003_get_pm(const u8 *data)
 101{
 102        return clamp_val(get_unaligned_be16(data),
 103                         PMS7003_PM_MIN, PMS7003_PM_MAX);
 104}
 105
 106static irqreturn_t pms7003_trigger_handler(int irq, void *p)
 107{
 108        struct iio_poll_func *pf = p;
 109        struct iio_dev *indio_dev = pf->indio_dev;
 110        struct pms7003_state *state = iio_priv(indio_dev);
 111        struct pms7003_frame *frame = &state->frame;
 112        int ret;
 113
 114        mutex_lock(&state->lock);
 115        ret = pms7003_do_cmd(state, CMD_READ_PASSIVE);
 116        if (ret) {
 117                mutex_unlock(&state->lock);
 118                goto err;
 119        }
 120
 121        state->scan.data[PM1] =
 122                pms7003_get_pm(frame->data + PMS7003_PM1_OFFSET);
 123        state->scan.data[PM2P5] =
 124                pms7003_get_pm(frame->data + PMS7003_PM2P5_OFFSET);
 125        state->scan.data[PM10] =
 126                pms7003_get_pm(frame->data + PMS7003_PM10_OFFSET);
 127        mutex_unlock(&state->lock);
 128
 129        iio_push_to_buffers_with_timestamp(indio_dev, &state->scan,
 130                                           iio_get_time_ns(indio_dev));
 131err:
 132        iio_trigger_notify_done(indio_dev->trig);
 133
 134        return IRQ_HANDLED;
 135}
 136
 137static int pms7003_read_raw(struct iio_dev *indio_dev,
 138                            struct iio_chan_spec const *chan,
 139                            int *val, int *val2, long mask)
 140{
 141        struct pms7003_state *state = iio_priv(indio_dev);
 142        struct pms7003_frame *frame = &state->frame;
 143        int ret;
 144
 145        switch (mask) {
 146        case IIO_CHAN_INFO_PROCESSED:
 147                switch (chan->type) {
 148                case IIO_MASSCONCENTRATION:
 149                        mutex_lock(&state->lock);
 150                        ret = pms7003_do_cmd(state, CMD_READ_PASSIVE);
 151                        if (ret) {
 152                                mutex_unlock(&state->lock);
 153                                return ret;
 154                        }
 155
 156                        *val = pms7003_get_pm(frame->data + chan->address);
 157                        mutex_unlock(&state->lock);
 158
 159                        return IIO_VAL_INT;
 160                default:
 161                        return -EINVAL;
 162                }
 163        }
 164
 165        return -EINVAL;
 166}
 167
 168static const struct iio_info pms7003_info = {
 169        .read_raw = pms7003_read_raw,
 170};
 171
 172#define PMS7003_CHAN(_index, _mod, _addr) { \
 173        .type = IIO_MASSCONCENTRATION, \
 174        .modified = 1, \
 175        .channel2 = IIO_MOD_ ## _mod, \
 176        .address = _addr, \
 177        .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \
 178        .scan_index = _index, \
 179        .scan_type = { \
 180                .sign = 'u', \
 181                .realbits = 10, \
 182                .storagebits = 16, \
 183                .endianness = IIO_CPU, \
 184        }, \
 185}
 186
 187static const struct iio_chan_spec pms7003_channels[] = {
 188        PMS7003_CHAN(0, PM1, PMS7003_PM1_OFFSET),
 189        PMS7003_CHAN(1, PM2P5, PMS7003_PM2P5_OFFSET),
 190        PMS7003_CHAN(2, PM10, PMS7003_PM10_OFFSET),
 191        IIO_CHAN_SOFT_TIMESTAMP(3),
 192};
 193
 194static u16 pms7003_calc_checksum(struct pms7003_frame *frame)
 195{
 196        u16 checksum = (PMS7003_MAGIC >> 8) + (u8)(PMS7003_MAGIC & 0xff) +
 197                       (frame->length >> 8) + (u8)frame->length;
 198        int i;
 199
 200        for (i = 0; i < frame->length - PMS7003_CHECKSUM_LENGTH; i++)
 201                checksum += frame->data[i];
 202
 203        return checksum;
 204}
 205
 206static bool pms7003_frame_is_okay(struct pms7003_frame *frame)
 207{
 208        int offset = frame->length - PMS7003_CHECKSUM_LENGTH;
 209        u16 checksum = get_unaligned_be16(frame->data + offset);
 210
 211        return checksum == pms7003_calc_checksum(frame);
 212}
 213
 214static int pms7003_receive_buf(struct serdev_device *serdev,
 215                               const unsigned char *buf, size_t size)
 216{
 217        struct iio_dev *indio_dev = serdev_device_get_drvdata(serdev);
 218        struct pms7003_state *state = iio_priv(indio_dev);
 219        struct pms7003_frame *frame = &state->frame;
 220        int num;
 221
 222        if (!frame->expected_length) {
 223                u16 magic;
 224
 225                /* wait for SOF and data length */
 226                if (size < 4)
 227                        return 0;
 228
 229                magic = get_unaligned_be16(buf);
 230                if (magic != PMS7003_MAGIC)
 231                        return 2;
 232
 233                num = get_unaligned_be16(buf + 2);
 234                if (num <= PMS7003_MAX_DATA_LENGTH) {
 235                        frame->expected_length = num;
 236                        frame->length = 0;
 237                }
 238
 239                return 4;
 240        }
 241
 242        num = min(size, (size_t)(frame->expected_length - frame->length));
 243        memcpy(frame->data + frame->length, buf, num);
 244        frame->length += num;
 245
 246        if (frame->length == frame->expected_length) {
 247                if (pms7003_frame_is_okay(frame))
 248                        complete(&state->frame_ready);
 249
 250                frame->expected_length = 0;
 251        }
 252
 253        return num;
 254}
 255
 256static const struct serdev_device_ops pms7003_serdev_ops = {
 257        .receive_buf = pms7003_receive_buf,
 258        .write_wakeup = serdev_device_write_wakeup,
 259};
 260
 261static void pms7003_stop(void *data)
 262{
 263        struct pms7003_state *state = data;
 264
 265        pms7003_do_cmd(state, CMD_SLEEP);
 266}
 267
 268static const unsigned long pms7003_scan_masks[] = { 0x07, 0x00 };
 269
 270static int pms7003_probe(struct serdev_device *serdev)
 271{
 272        struct pms7003_state *state;
 273        struct iio_dev *indio_dev;
 274        int ret;
 275
 276        indio_dev = devm_iio_device_alloc(&serdev->dev, sizeof(*state));
 277        if (!indio_dev)
 278                return -ENOMEM;
 279
 280        state = iio_priv(indio_dev);
 281        serdev_device_set_drvdata(serdev, indio_dev);
 282        state->serdev = serdev;
 283        indio_dev->info = &pms7003_info;
 284        indio_dev->name = PMS7003_DRIVER_NAME;
 285        indio_dev->channels = pms7003_channels;
 286        indio_dev->num_channels = ARRAY_SIZE(pms7003_channels);
 287        indio_dev->modes = INDIO_DIRECT_MODE;
 288        indio_dev->available_scan_masks = pms7003_scan_masks;
 289
 290        mutex_init(&state->lock);
 291        init_completion(&state->frame_ready);
 292
 293        serdev_device_set_client_ops(serdev, &pms7003_serdev_ops);
 294        ret = devm_serdev_device_open(&serdev->dev, serdev);
 295        if (ret)
 296                return ret;
 297
 298        serdev_device_set_baudrate(serdev, 9600);
 299        serdev_device_set_flow_control(serdev, false);
 300
 301        ret = serdev_device_set_parity(serdev, SERDEV_PARITY_NONE);
 302        if (ret)
 303                return ret;
 304
 305        ret = pms7003_do_cmd(state, CMD_WAKEUP);
 306        if (ret) {
 307                dev_err(&serdev->dev, "failed to wakeup sensor\n");
 308                return ret;
 309        }
 310
 311        ret = pms7003_do_cmd(state, CMD_ENTER_PASSIVE_MODE);
 312        if (ret) {
 313                dev_err(&serdev->dev, "failed to enter passive mode\n");
 314                return ret;
 315        }
 316
 317        ret = devm_add_action_or_reset(&serdev->dev, pms7003_stop, state);
 318        if (ret)
 319                return ret;
 320
 321        ret = devm_iio_triggered_buffer_setup(&serdev->dev, indio_dev, NULL,
 322                                              pms7003_trigger_handler, NULL);
 323        if (ret)
 324                return ret;
 325
 326        return devm_iio_device_register(&serdev->dev, indio_dev);
 327}
 328
 329static const struct of_device_id pms7003_of_match[] = {
 330        { .compatible = "plantower,pms1003" },
 331        { .compatible = "plantower,pms3003" },
 332        { .compatible = "plantower,pms5003" },
 333        { .compatible = "plantower,pms6003" },
 334        { .compatible = "plantower,pms7003" },
 335        { .compatible = "plantower,pmsa003" },
 336        { }
 337};
 338MODULE_DEVICE_TABLE(of, pms7003_of_match);
 339
 340static struct serdev_device_driver pms7003_driver = {
 341        .driver = {
 342                .name = PMS7003_DRIVER_NAME,
 343                .of_match_table = pms7003_of_match,
 344        },
 345        .probe = pms7003_probe,
 346};
 347module_serdev_device_driver(pms7003_driver);
 348
 349MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>");
 350MODULE_DESCRIPTION("Plantower PMS7003 particulate matter sensor driver");
 351MODULE_LICENSE("GPL v2");
 352