forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
351 lines
8.6 KiB
351 lines
8.6 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Plantower PMS7003 particulate matter sensor driver |
|
* |
|
* Copyright (c) Tomasz Duszynski <[email protected]> |
|
*/ |
|
|
|
#include <asm/unaligned.h> |
|
#include <linux/completion.h> |
|
#include <linux/device.h> |
|
#include <linux/errno.h> |
|
#include <linux/iio/buffer.h> |
|
#include <linux/iio/iio.h> |
|
#include <linux/iio/trigger_consumer.h> |
|
#include <linux/iio/triggered_buffer.h> |
|
#include <linux/jiffies.h> |
|
#include <linux/kernel.h> |
|
#include <linux/mod_devicetable.h> |
|
#include <linux/module.h> |
|
#include <linux/mutex.h> |
|
#include <linux/serdev.h> |
|
|
|
#define PMS7003_DRIVER_NAME "pms7003" |
|
|
|
#define PMS7003_MAGIC 0x424d |
|
/* last 2 data bytes hold frame checksum */ |
|
#define PMS7003_MAX_DATA_LENGTH 28 |
|
#define PMS7003_CHECKSUM_LENGTH 2 |
|
#define PMS7003_PM10_OFFSET 10 |
|
#define PMS7003_PM2P5_OFFSET 8 |
|
#define PMS7003_PM1_OFFSET 6 |
|
|
|
#define PMS7003_TIMEOUT msecs_to_jiffies(6000) |
|
#define PMS7003_CMD_LENGTH 7 |
|
#define PMS7003_PM_MAX 1000 |
|
#define PMS7003_PM_MIN 0 |
|
|
|
enum { |
|
PM1, |
|
PM2P5, |
|
PM10, |
|
}; |
|
|
|
enum pms7003_cmd { |
|
CMD_WAKEUP, |
|
CMD_ENTER_PASSIVE_MODE, |
|
CMD_READ_PASSIVE, |
|
CMD_SLEEP, |
|
}; |
|
|
|
/* |
|
* commands have following format: |
|
* |
|
* +------+------+-----+------+-----+-----------+-----------+ |
|
* | 0x42 | 0x4d | cmd | 0x00 | arg | cksum msb | cksum lsb | |
|
* +------+------+-----+------+-----+-----------+-----------+ |
|
*/ |
|
static const u8 pms7003_cmd_tbl[][PMS7003_CMD_LENGTH] = { |
|
[CMD_WAKEUP] = { 0x42, 0x4d, 0xe4, 0x00, 0x01, 0x01, 0x74 }, |
|
[CMD_ENTER_PASSIVE_MODE] = { 0x42, 0x4d, 0xe1, 0x00, 0x00, 0x01, 0x70 }, |
|
[CMD_READ_PASSIVE] = { 0x42, 0x4d, 0xe2, 0x00, 0x00, 0x01, 0x71 }, |
|
[CMD_SLEEP] = { 0x42, 0x4d, 0xe4, 0x00, 0x00, 0x01, 0x73 }, |
|
}; |
|
|
|
struct pms7003_frame { |
|
u8 data[PMS7003_MAX_DATA_LENGTH]; |
|
u16 expected_length; |
|
u16 length; |
|
}; |
|
|
|
struct pms7003_state { |
|
struct serdev_device *serdev; |
|
struct pms7003_frame frame; |
|
struct completion frame_ready; |
|
struct mutex lock; /* must be held whenever state gets touched */ |
|
/* Used to construct scan to push to the IIO buffer */ |
|
struct { |
|
u16 data[3]; /* PM1, PM2P5, PM10 */ |
|
s64 ts; |
|
} scan; |
|
}; |
|
|
|
static int pms7003_do_cmd(struct pms7003_state *state, enum pms7003_cmd cmd) |
|
{ |
|
int ret; |
|
|
|
ret = serdev_device_write(state->serdev, pms7003_cmd_tbl[cmd], |
|
PMS7003_CMD_LENGTH, PMS7003_TIMEOUT); |
|
if (ret < PMS7003_CMD_LENGTH) |
|
return ret < 0 ? ret : -EIO; |
|
|
|
ret = wait_for_completion_interruptible_timeout(&state->frame_ready, |
|
PMS7003_TIMEOUT); |
|
if (!ret) |
|
ret = -ETIMEDOUT; |
|
|
|
return ret < 0 ? ret : 0; |
|
} |
|
|
|
static u16 pms7003_get_pm(const u8 *data) |
|
{ |
|
return clamp_val(get_unaligned_be16(data), |
|
PMS7003_PM_MIN, PMS7003_PM_MAX); |
|
} |
|
|
|
static irqreturn_t pms7003_trigger_handler(int irq, void *p) |
|
{ |
|
struct iio_poll_func *pf = p; |
|
struct iio_dev *indio_dev = pf->indio_dev; |
|
struct pms7003_state *state = iio_priv(indio_dev); |
|
struct pms7003_frame *frame = &state->frame; |
|
int ret; |
|
|
|
mutex_lock(&state->lock); |
|
ret = pms7003_do_cmd(state, CMD_READ_PASSIVE); |
|
if (ret) { |
|
mutex_unlock(&state->lock); |
|
goto err; |
|
} |
|
|
|
state->scan.data[PM1] = |
|
pms7003_get_pm(frame->data + PMS7003_PM1_OFFSET); |
|
state->scan.data[PM2P5] = |
|
pms7003_get_pm(frame->data + PMS7003_PM2P5_OFFSET); |
|
state->scan.data[PM10] = |
|
pms7003_get_pm(frame->data + PMS7003_PM10_OFFSET); |
|
mutex_unlock(&state->lock); |
|
|
|
iio_push_to_buffers_with_timestamp(indio_dev, &state->scan, |
|
iio_get_time_ns(indio_dev)); |
|
err: |
|
iio_trigger_notify_done(indio_dev->trig); |
|
|
|
return IRQ_HANDLED; |
|
} |
|
|
|
static int pms7003_read_raw(struct iio_dev *indio_dev, |
|
struct iio_chan_spec const *chan, |
|
int *val, int *val2, long mask) |
|
{ |
|
struct pms7003_state *state = iio_priv(indio_dev); |
|
struct pms7003_frame *frame = &state->frame; |
|
int ret; |
|
|
|
switch (mask) { |
|
case IIO_CHAN_INFO_PROCESSED: |
|
switch (chan->type) { |
|
case IIO_MASSCONCENTRATION: |
|
mutex_lock(&state->lock); |
|
ret = pms7003_do_cmd(state, CMD_READ_PASSIVE); |
|
if (ret) { |
|
mutex_unlock(&state->lock); |
|
return ret; |
|
} |
|
|
|
*val = pms7003_get_pm(frame->data + chan->address); |
|
mutex_unlock(&state->lock); |
|
|
|
return IIO_VAL_INT; |
|
default: |
|
return -EINVAL; |
|
} |
|
} |
|
|
|
return -EINVAL; |
|
} |
|
|
|
static const struct iio_info pms7003_info = { |
|
.read_raw = pms7003_read_raw, |
|
}; |
|
|
|
#define PMS7003_CHAN(_index, _mod, _addr) { \ |
|
.type = IIO_MASSCONCENTRATION, \ |
|
.modified = 1, \ |
|
.channel2 = IIO_MOD_ ## _mod, \ |
|
.address = _addr, \ |
|
.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \ |
|
.scan_index = _index, \ |
|
.scan_type = { \ |
|
.sign = 'u', \ |
|
.realbits = 10, \ |
|
.storagebits = 16, \ |
|
.endianness = IIO_CPU, \ |
|
}, \ |
|
} |
|
|
|
static const struct iio_chan_spec pms7003_channels[] = { |
|
PMS7003_CHAN(0, PM1, PMS7003_PM1_OFFSET), |
|
PMS7003_CHAN(1, PM2P5, PMS7003_PM2P5_OFFSET), |
|
PMS7003_CHAN(2, PM10, PMS7003_PM10_OFFSET), |
|
IIO_CHAN_SOFT_TIMESTAMP(3), |
|
}; |
|
|
|
static u16 pms7003_calc_checksum(struct pms7003_frame *frame) |
|
{ |
|
u16 checksum = (PMS7003_MAGIC >> 8) + (u8)(PMS7003_MAGIC & 0xff) + |
|
(frame->length >> 8) + (u8)frame->length; |
|
int i; |
|
|
|
for (i = 0; i < frame->length - PMS7003_CHECKSUM_LENGTH; i++) |
|
checksum += frame->data[i]; |
|
|
|
return checksum; |
|
} |
|
|
|
static bool pms7003_frame_is_okay(struct pms7003_frame *frame) |
|
{ |
|
int offset = frame->length - PMS7003_CHECKSUM_LENGTH; |
|
u16 checksum = get_unaligned_be16(frame->data + offset); |
|
|
|
return checksum == pms7003_calc_checksum(frame); |
|
} |
|
|
|
static int pms7003_receive_buf(struct serdev_device *serdev, |
|
const unsigned char *buf, size_t size) |
|
{ |
|
struct iio_dev *indio_dev = serdev_device_get_drvdata(serdev); |
|
struct pms7003_state *state = iio_priv(indio_dev); |
|
struct pms7003_frame *frame = &state->frame; |
|
int num; |
|
|
|
if (!frame->expected_length) { |
|
u16 magic; |
|
|
|
/* wait for SOF and data length */ |
|
if (size < 4) |
|
return 0; |
|
|
|
magic = get_unaligned_be16(buf); |
|
if (magic != PMS7003_MAGIC) |
|
return 2; |
|
|
|
num = get_unaligned_be16(buf + 2); |
|
if (num <= PMS7003_MAX_DATA_LENGTH) { |
|
frame->expected_length = num; |
|
frame->length = 0; |
|
} |
|
|
|
return 4; |
|
} |
|
|
|
num = min(size, (size_t)(frame->expected_length - frame->length)); |
|
memcpy(frame->data + frame->length, buf, num); |
|
frame->length += num; |
|
|
|
if (frame->length == frame->expected_length) { |
|
if (pms7003_frame_is_okay(frame)) |
|
complete(&state->frame_ready); |
|
|
|
frame->expected_length = 0; |
|
} |
|
|
|
return num; |
|
} |
|
|
|
static const struct serdev_device_ops pms7003_serdev_ops = { |
|
.receive_buf = pms7003_receive_buf, |
|
.write_wakeup = serdev_device_write_wakeup, |
|
}; |
|
|
|
static void pms7003_stop(void *data) |
|
{ |
|
struct pms7003_state *state = data; |
|
|
|
pms7003_do_cmd(state, CMD_SLEEP); |
|
} |
|
|
|
static const unsigned long pms7003_scan_masks[] = { 0x07, 0x00 }; |
|
|
|
static int pms7003_probe(struct serdev_device *serdev) |
|
{ |
|
struct pms7003_state *state; |
|
struct iio_dev *indio_dev; |
|
int ret; |
|
|
|
indio_dev = devm_iio_device_alloc(&serdev->dev, sizeof(*state)); |
|
if (!indio_dev) |
|
return -ENOMEM; |
|
|
|
state = iio_priv(indio_dev); |
|
serdev_device_set_drvdata(serdev, indio_dev); |
|
state->serdev = serdev; |
|
indio_dev->info = &pms7003_info; |
|
indio_dev->name = PMS7003_DRIVER_NAME; |
|
indio_dev->channels = pms7003_channels; |
|
indio_dev->num_channels = ARRAY_SIZE(pms7003_channels); |
|
indio_dev->modes = INDIO_DIRECT_MODE; |
|
indio_dev->available_scan_masks = pms7003_scan_masks; |
|
|
|
mutex_init(&state->lock); |
|
init_completion(&state->frame_ready); |
|
|
|
serdev_device_set_client_ops(serdev, &pms7003_serdev_ops); |
|
ret = devm_serdev_device_open(&serdev->dev, serdev); |
|
if (ret) |
|
return ret; |
|
|
|
serdev_device_set_baudrate(serdev, 9600); |
|
serdev_device_set_flow_control(serdev, false); |
|
|
|
ret = serdev_device_set_parity(serdev, SERDEV_PARITY_NONE); |
|
if (ret) |
|
return ret; |
|
|
|
ret = pms7003_do_cmd(state, CMD_WAKEUP); |
|
if (ret) { |
|
dev_err(&serdev->dev, "failed to wakeup sensor\n"); |
|
return ret; |
|
} |
|
|
|
ret = pms7003_do_cmd(state, CMD_ENTER_PASSIVE_MODE); |
|
if (ret) { |
|
dev_err(&serdev->dev, "failed to enter passive mode\n"); |
|
return ret; |
|
} |
|
|
|
ret = devm_add_action_or_reset(&serdev->dev, pms7003_stop, state); |
|
if (ret) |
|
return ret; |
|
|
|
ret = devm_iio_triggered_buffer_setup(&serdev->dev, indio_dev, NULL, |
|
pms7003_trigger_handler, NULL); |
|
if (ret) |
|
return ret; |
|
|
|
return devm_iio_device_register(&serdev->dev, indio_dev); |
|
} |
|
|
|
static const struct of_device_id pms7003_of_match[] = { |
|
{ .compatible = "plantower,pms1003" }, |
|
{ .compatible = "plantower,pms3003" }, |
|
{ .compatible = "plantower,pms5003" }, |
|
{ .compatible = "plantower,pms6003" }, |
|
{ .compatible = "plantower,pms7003" }, |
|
{ .compatible = "plantower,pmsa003" }, |
|
{ } |
|
}; |
|
MODULE_DEVICE_TABLE(of, pms7003_of_match); |
|
|
|
static struct serdev_device_driver pms7003_driver = { |
|
.driver = { |
|
.name = PMS7003_DRIVER_NAME, |
|
.of_match_table = pms7003_of_match, |
|
}, |
|
.probe = pms7003_probe, |
|
}; |
|
module_serdev_device_driver(pms7003_driver); |
|
|
|
MODULE_AUTHOR("Tomasz Duszynski <[email protected]>"); |
|
MODULE_DESCRIPTION("Plantower PMS7003 particulate matter sensor driver"); |
|
MODULE_LICENSE("GPL v2");
|
|
|