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
39 enum {
40 PM1,
41 PM2P5,
42 PM10,
43 };
44
45 enum 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 */
59 static 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
66 struct pms7003_frame {
67 u8 data[PMS7003_MAX_DATA_LENGTH];
68 u16 expected_length;
69 u16 length;
70 };
71
72 struct 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
pms7003_do_cmd(struct pms7003_state * state,enum pms7003_cmd cmd)84 static 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
pms7003_get_pm(const u8 * data)101 static 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
pms7003_trigger_handler(int irq,void * p)107 static 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));
132 err:
133 iio_trigger_notify_done(indio_dev->trig);
134
135 return IRQ_HANDLED;
136 }
137
pms7003_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)138 static 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
169 static 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
188 static 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
pms7003_calc_checksum(struct pms7003_frame * frame)195 static 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
pms7003_frame_is_okay(struct pms7003_frame * frame)207 static 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
pms7003_receive_buf(struct serdev_device * serdev,const u8 * buf,size_t size)215 static 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
257 static const struct serdev_device_ops pms7003_serdev_ops = {
258 .receive_buf = pms7003_receive_buf,
259 .write_wakeup = serdev_device_write_wakeup,
260 };
261
pms7003_stop(void * data)262 static void pms7003_stop(void *data)
263 {
264 struct pms7003_state *state = data;
265
266 pms7003_do_cmd(state, CMD_SLEEP);
267 }
268
269 static const unsigned long pms7003_scan_masks[] = { 0x07, 0x00 };
270
pms7003_probe(struct serdev_device * serdev)271 static 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
330 static 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 };
339 MODULE_DEVICE_TABLE(of, pms7003_of_match);
340
341 static 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 };
348 module_serdev_device_driver(pms7003_driver);
349
350 MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>");
351 MODULE_DESCRIPTION("Plantower PMS7003 particulate matter sensor driver");
352 MODULE_LICENSE("GPL v2");
353