pms7003.c

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