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 38 enum { 39 PM1, 40 PM2P5, 41 PM10, 42 }; 43 44 enum 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 */ 58 static 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 65 struct pms7003_frame { 66 u8 data[PMS7003_MAX_DATA_LENGTH]; 67 u16 expected_length; 68 u16 length; 69 }; 70 71 struct 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 }; 77 78 static int pms7003_do_cmd(struct pms7003_state *state, enum pms7003_cmd cmd) 79 { 80 int ret; 81 82 ret = serdev_device_write(state->serdev, pms7003_cmd_tbl[cmd], 83 PMS7003_CMD_LENGTH, PMS7003_TIMEOUT); 84 if (ret < PMS7003_CMD_LENGTH) 85 return ret < 0 ? ret : -EIO; 86 87 ret = wait_for_completion_interruptible_timeout(&state->frame_ready, 88 PMS7003_TIMEOUT); 89 if (!ret) 90 ret = -ETIMEDOUT; 91 92 return ret < 0 ? ret : 0; 93 } 94 95 static u16 pms7003_get_pm(const u8 *data) 96 { 97 return clamp_val(get_unaligned_be16(data), 98 PMS7003_PM_MIN, PMS7003_PM_MAX); 99 } 100 101 static irqreturn_t pms7003_trigger_handler(int irq, void *p) 102 { 103 struct iio_poll_func *pf = p; 104 struct iio_dev *indio_dev = pf->indio_dev; 105 struct pms7003_state *state = iio_priv(indio_dev); 106 struct pms7003_frame *frame = &state->frame; 107 u16 data[3 + 1 + 4]; /* PM1, PM2P5, PM10, padding, timestamp */ 108 int ret; 109 110 mutex_lock(&state->lock); 111 ret = pms7003_do_cmd(state, CMD_READ_PASSIVE); 112 if (ret) { 113 mutex_unlock(&state->lock); 114 goto err; 115 } 116 117 data[PM1] = pms7003_get_pm(frame->data + PMS7003_PM1_OFFSET); 118 data[PM2P5] = pms7003_get_pm(frame->data + PMS7003_PM2P5_OFFSET); 119 data[PM10] = pms7003_get_pm(frame->data + PMS7003_PM10_OFFSET); 120 mutex_unlock(&state->lock); 121 122 iio_push_to_buffers_with_timestamp(indio_dev, data, 123 iio_get_time_ns(indio_dev)); 124 err: 125 iio_trigger_notify_done(indio_dev->trig); 126 127 return IRQ_HANDLED; 128 } 129 130 static int pms7003_read_raw(struct iio_dev *indio_dev, 131 struct iio_chan_spec const *chan, 132 int *val, int *val2, long mask) 133 { 134 struct pms7003_state *state = iio_priv(indio_dev); 135 struct pms7003_frame *frame = &state->frame; 136 int ret; 137 138 switch (mask) { 139 case IIO_CHAN_INFO_PROCESSED: 140 switch (chan->type) { 141 case IIO_MASSCONCENTRATION: 142 mutex_lock(&state->lock); 143 ret = pms7003_do_cmd(state, CMD_READ_PASSIVE); 144 if (ret) { 145 mutex_unlock(&state->lock); 146 return ret; 147 } 148 149 *val = pms7003_get_pm(frame->data + chan->address); 150 mutex_unlock(&state->lock); 151 152 return IIO_VAL_INT; 153 default: 154 return -EINVAL; 155 } 156 } 157 158 return -EINVAL; 159 } 160 161 static const struct iio_info pms7003_info = { 162 .read_raw = pms7003_read_raw, 163 }; 164 165 #define PMS7003_CHAN(_index, _mod, _addr) { \ 166 .type = IIO_MASSCONCENTRATION, \ 167 .modified = 1, \ 168 .channel2 = IIO_MOD_ ## _mod, \ 169 .address = _addr, \ 170 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \ 171 .scan_index = _index, \ 172 .scan_type = { \ 173 .sign = 'u', \ 174 .realbits = 10, \ 175 .storagebits = 16, \ 176 .endianness = IIO_CPU, \ 177 }, \ 178 } 179 180 static const struct iio_chan_spec pms7003_channels[] = { 181 PMS7003_CHAN(0, PM1, PMS7003_PM1_OFFSET), 182 PMS7003_CHAN(1, PM2P5, PMS7003_PM2P5_OFFSET), 183 PMS7003_CHAN(2, PM10, PMS7003_PM10_OFFSET), 184 IIO_CHAN_SOFT_TIMESTAMP(3), 185 }; 186 187 static u16 pms7003_calc_checksum(struct pms7003_frame *frame) 188 { 189 u16 checksum = (PMS7003_MAGIC >> 8) + (u8)(PMS7003_MAGIC & 0xff) + 190 (frame->length >> 8) + (u8)frame->length; 191 int i; 192 193 for (i = 0; i < frame->length - PMS7003_CHECKSUM_LENGTH; i++) 194 checksum += frame->data[i]; 195 196 return checksum; 197 } 198 199 static bool pms7003_frame_is_okay(struct pms7003_frame *frame) 200 { 201 int offset = frame->length - PMS7003_CHECKSUM_LENGTH; 202 u16 checksum = get_unaligned_be16(frame->data + offset); 203 204 return checksum == pms7003_calc_checksum(frame); 205 } 206 207 static int pms7003_receive_buf(struct serdev_device *serdev, 208 const unsigned char *buf, size_t size) 209 { 210 struct iio_dev *indio_dev = serdev_device_get_drvdata(serdev); 211 struct pms7003_state *state = iio_priv(indio_dev); 212 struct pms7003_frame *frame = &state->frame; 213 int num; 214 215 if (!frame->expected_length) { 216 u16 magic; 217 218 /* wait for SOF and data length */ 219 if (size < 4) 220 return 0; 221 222 magic = get_unaligned_be16(buf); 223 if (magic != PMS7003_MAGIC) 224 return 2; 225 226 num = get_unaligned_be16(buf + 2); 227 if (num <= PMS7003_MAX_DATA_LENGTH) { 228 frame->expected_length = num; 229 frame->length = 0; 230 } 231 232 return 4; 233 } 234 235 num = min(size, (size_t)(frame->expected_length - frame->length)); 236 memcpy(frame->data + frame->length, buf, num); 237 frame->length += num; 238 239 if (frame->length == frame->expected_length) { 240 if (pms7003_frame_is_okay(frame)) 241 complete(&state->frame_ready); 242 243 frame->expected_length = 0; 244 } 245 246 return num; 247 } 248 249 static const struct serdev_device_ops pms7003_serdev_ops = { 250 .receive_buf = pms7003_receive_buf, 251 .write_wakeup = serdev_device_write_wakeup, 252 }; 253 254 static void pms7003_stop(void *data) 255 { 256 struct pms7003_state *state = data; 257 258 pms7003_do_cmd(state, CMD_SLEEP); 259 } 260 261 static const unsigned long pms7003_scan_masks[] = { 0x07, 0x00 }; 262 263 static int pms7003_probe(struct serdev_device *serdev) 264 { 265 struct pms7003_state *state; 266 struct iio_dev *indio_dev; 267 int ret; 268 269 indio_dev = devm_iio_device_alloc(&serdev->dev, sizeof(*state)); 270 if (!indio_dev) 271 return -ENOMEM; 272 273 state = iio_priv(indio_dev); 274 serdev_device_set_drvdata(serdev, indio_dev); 275 state->serdev = serdev; 276 indio_dev->dev.parent = &serdev->dev; 277 indio_dev->info = &pms7003_info; 278 indio_dev->name = PMS7003_DRIVER_NAME; 279 indio_dev->channels = pms7003_channels, 280 indio_dev->num_channels = ARRAY_SIZE(pms7003_channels); 281 indio_dev->modes = INDIO_DIRECT_MODE; 282 indio_dev->available_scan_masks = pms7003_scan_masks; 283 284 mutex_init(&state->lock); 285 init_completion(&state->frame_ready); 286 287 serdev_device_set_client_ops(serdev, &pms7003_serdev_ops); 288 ret = devm_serdev_device_open(&serdev->dev, serdev); 289 if (ret) 290 return ret; 291 292 serdev_device_set_baudrate(serdev, 9600); 293 serdev_device_set_flow_control(serdev, false); 294 295 ret = serdev_device_set_parity(serdev, SERDEV_PARITY_NONE); 296 if (ret) 297 return ret; 298 299 ret = pms7003_do_cmd(state, CMD_WAKEUP); 300 if (ret) { 301 dev_err(&serdev->dev, "failed to wakeup sensor\n"); 302 return ret; 303 } 304 305 ret = pms7003_do_cmd(state, CMD_ENTER_PASSIVE_MODE); 306 if (ret) { 307 dev_err(&serdev->dev, "failed to enter passive mode\n"); 308 return ret; 309 } 310 311 ret = devm_add_action_or_reset(&serdev->dev, pms7003_stop, state); 312 if (ret) 313 return ret; 314 315 ret = devm_iio_triggered_buffer_setup(&serdev->dev, indio_dev, NULL, 316 pms7003_trigger_handler, NULL); 317 if (ret) 318 return ret; 319 320 return devm_iio_device_register(&serdev->dev, indio_dev); 321 } 322 323 static const struct of_device_id pms7003_of_match[] = { 324 { .compatible = "plantower,pms7003" }, 325 { } 326 }; 327 MODULE_DEVICE_TABLE(of, pms7003_of_match); 328 329 static struct serdev_device_driver pms7003_driver = { 330 .driver = { 331 .name = PMS7003_DRIVER_NAME, 332 .of_match_table = pms7003_of_match, 333 }, 334 .probe = pms7003_probe, 335 }; 336 module_serdev_device_driver(pms7003_driver); 337 338 MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>"); 339 MODULE_DESCRIPTION("Plantower PMS7003 particulate matter sensor driver"); 340 MODULE_LICENSE("GPL v2"); 341