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 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 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 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 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 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 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 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 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 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