433 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Sensirion SPS30 particulate matter sensor serial driver4 *5 * Copyright (c) 2021 Tomasz Duszynski <tomasz.duszynski@octakon.com>6 */7#include <linux/completion.h>8#include <linux/device.h>9#include <linux/errno.h>10#include <linux/iio/iio.h>11#include <linux/minmax.h>12#include <linux/mod_devicetable.h>13#include <linux/module.h>14#include <linux/serdev.h>15#include <linux/types.h>16 17#include "sps30.h"18 19#define SPS30_SERIAL_DEV_NAME "sps30"20 21#define SPS30_SERIAL_SOF_EOF 0x7e22#define SPS30_SERIAL_TIMEOUT msecs_to_jiffies(20)23#define SPS30_SERIAL_MAX_BUF_SIZE 26324#define SPS30_SERIAL_ESCAPE_CHAR 0x7d25 26#define SPS30_SERIAL_FRAME_MIN_SIZE 727#define SPS30_SERIAL_FRAME_ADR_OFFSET 128#define SPS30_SERIAL_FRAME_CMD_OFFSET 229#define SPS30_SERIAL_FRAME_MOSI_LEN_OFFSET 330#define SPS30_SERIAL_FRAME_MISO_STATE_OFFSET 331#define SPS30_SERIAL_FRAME_MISO_LEN_OFFSET 432#define SPS30_SERIAL_FRAME_MISO_DATA_OFFSET 533 34#define SPS30_SERIAL_START_MEAS 0x0035#define SPS30_SERIAL_STOP_MEAS 0x0136#define SPS30_SERIAL_READ_MEAS 0x0337#define SPS30_SERIAL_RESET 0xd338#define SPS30_SERIAL_CLEAN_FAN 0x5639#define SPS30_SERIAL_PERIOD 0x8040#define SPS30_SERIAL_DEV_INFO 0xd041#define SPS30_SERIAL_READ_VERSION 0xd142 43struct sps30_serial_priv {44 struct completion new_frame;45 unsigned char buf[SPS30_SERIAL_MAX_BUF_SIZE];46 size_t num;47 bool escaped;48 bool done;49};50 51static int sps30_serial_xfer(struct sps30_state *state, const unsigned char *buf, size_t size)52{53 struct serdev_device *serdev = to_serdev_device(state->dev);54 struct sps30_serial_priv *priv = state->priv;55 int ret;56 57 priv->num = 0;58 priv->escaped = false;59 priv->done = false;60 61 ret = serdev_device_write(serdev, buf, size, SPS30_SERIAL_TIMEOUT);62 if (ret < 0)63 return ret;64 if (ret != size)65 return -EIO;66 67 ret = wait_for_completion_interruptible_timeout(&priv->new_frame, SPS30_SERIAL_TIMEOUT);68 if (ret < 0)69 return ret;70 if (!ret)71 return -ETIMEDOUT;72 73 return 0;74}75 76static const struct {77 u8 byte;78 u8 byte2;79} sps30_serial_bytes[] = {80 { 0x11, 0x31 },81 { 0x13, 0x33 },82 { 0x7e, 0x5e },83 { 0x7d, 0x5d },84};85 86static int sps30_serial_put_byte(u8 *buf, u8 byte)87{88 int i;89 90 for (i = 0; i < ARRAY_SIZE(sps30_serial_bytes); i++) {91 if (sps30_serial_bytes[i].byte != byte)92 continue;93 94 buf[0] = SPS30_SERIAL_ESCAPE_CHAR;95 buf[1] = sps30_serial_bytes[i].byte2;96 97 return 2;98 }99 100 buf[0] = byte;101 102 return 1;103}104 105static u8 sps30_serial_get_byte(bool escaped, u8 byte2)106{107 int i;108 109 if (!escaped)110 return byte2;111 112 for (i = 0; i < ARRAY_SIZE(sps30_serial_bytes); i++) {113 if (sps30_serial_bytes[i].byte2 != byte2)114 continue;115 116 return sps30_serial_bytes[i].byte;117 }118 119 return 0;120}121 122static unsigned char sps30_serial_calc_chksum(const unsigned char *buf, size_t num)123{124 unsigned int chksum = 0;125 size_t i;126 127 for (i = 0; i < num; i++)128 chksum += buf[i];129 130 return ~chksum;131}132 133static int sps30_serial_prep_frame(u8 *buf, u8 cmd, const u8 *arg,134 size_t arg_size)135{136 unsigned char chksum;137 int num = 0;138 size_t i;139 140 buf[num++] = SPS30_SERIAL_SOF_EOF;141 buf[num++] = 0;142 num += sps30_serial_put_byte(buf + num, cmd);143 num += sps30_serial_put_byte(buf + num, arg_size);144 145 for (i = 0; i < arg_size; i++)146 num += sps30_serial_put_byte(buf + num, arg[i]);147 148 /* SOF isn't checksummed */149 chksum = sps30_serial_calc_chksum(buf + 1, num - 1);150 num += sps30_serial_put_byte(buf + num, chksum);151 buf[num++] = SPS30_SERIAL_SOF_EOF;152 153 return num;154}155 156static bool sps30_serial_frame_valid(struct sps30_state *state, const unsigned char *buf)157{158 struct sps30_serial_priv *priv = state->priv;159 unsigned char chksum;160 161 if ((priv->num < SPS30_SERIAL_FRAME_MIN_SIZE) ||162 (priv->num != SPS30_SERIAL_FRAME_MIN_SIZE +163 priv->buf[SPS30_SERIAL_FRAME_MISO_LEN_OFFSET])) {164 dev_err(state->dev, "frame has invalid number of bytes\n");165 return false;166 }167 168 if ((priv->buf[SPS30_SERIAL_FRAME_ADR_OFFSET] != buf[SPS30_SERIAL_FRAME_ADR_OFFSET]) ||169 (priv->buf[SPS30_SERIAL_FRAME_CMD_OFFSET] != buf[SPS30_SERIAL_FRAME_CMD_OFFSET])) {170 dev_err(state->dev, "frame has wrong ADR and CMD bytes\n");171 return false;172 }173 174 if (priv->buf[SPS30_SERIAL_FRAME_MISO_STATE_OFFSET]) {175 dev_err(state->dev, "frame with non-zero state received (0x%02x)\n",176 priv->buf[SPS30_SERIAL_FRAME_MISO_STATE_OFFSET]);177 return false;178 }179 180 /* SOF, checksum and EOF are not checksummed */181 chksum = sps30_serial_calc_chksum(priv->buf + 1, priv->num - 3);182 if (priv->buf[priv->num - 2] != chksum) {183 dev_err(state->dev, "frame integrity check failed\n");184 return false;185 }186 187 return true;188}189 190static int sps30_serial_command(struct sps30_state *state, unsigned char cmd,191 const void *arg, size_t arg_size, void *rsp, size_t rsp_size)192{193 struct sps30_serial_priv *priv = state->priv;194 unsigned char buf[SPS30_SERIAL_MAX_BUF_SIZE];195 int ret, size;196 197 size = sps30_serial_prep_frame(buf, cmd, arg, arg_size);198 ret = sps30_serial_xfer(state, buf, size);199 if (ret)200 return ret;201 202 if (!sps30_serial_frame_valid(state, buf))203 return -EIO;204 205 if (rsp) {206 rsp_size = min_t(size_t, priv->buf[SPS30_SERIAL_FRAME_MISO_LEN_OFFSET], rsp_size);207 memcpy(rsp, &priv->buf[SPS30_SERIAL_FRAME_MISO_DATA_OFFSET], rsp_size);208 }209 210 return rsp_size;211}212 213static size_t sps30_serial_receive_buf(struct serdev_device *serdev,214 const u8 *buf, size_t size)215{216 struct iio_dev *indio_dev = dev_get_drvdata(&serdev->dev);217 struct sps30_serial_priv *priv;218 struct sps30_state *state;219 size_t i;220 u8 byte;221 222 if (!indio_dev)223 return 0;224 225 state = iio_priv(indio_dev);226 priv = state->priv;227 228 /* just in case device put some unexpected data on the bus */229 if (priv->done)230 return size;231 232 /* wait for the start of frame */233 if (!priv->num && size && buf[0] != SPS30_SERIAL_SOF_EOF)234 return 1;235 236 if (priv->num + size >= ARRAY_SIZE(priv->buf))237 size = ARRAY_SIZE(priv->buf) - priv->num;238 239 for (i = 0; i < size; i++) {240 byte = buf[i];241 /* remove stuffed bytes on-the-fly */242 if (byte == SPS30_SERIAL_ESCAPE_CHAR) {243 priv->escaped = true;244 continue;245 }246 247 byte = sps30_serial_get_byte(priv->escaped, byte);248 if (priv->escaped && !byte)249 dev_warn(state->dev, "unrecognized escaped char (0x%02x)\n", byte);250 251 priv->buf[priv->num++] = byte;252 253 /* EOF received */254 if (!priv->escaped && byte == SPS30_SERIAL_SOF_EOF) {255 if (priv->num < SPS30_SERIAL_FRAME_MIN_SIZE)256 continue;257 258 priv->done = true;259 complete(&priv->new_frame);260 i++;261 break;262 }263 264 priv->escaped = false;265 }266 267 return i;268}269 270static const struct serdev_device_ops sps30_serial_device_ops = {271 .receive_buf = sps30_serial_receive_buf,272 .write_wakeup = serdev_device_write_wakeup,273};274 275static int sps30_serial_start_meas(struct sps30_state *state)276{277 /* request BE IEEE754 formatted data */278 unsigned char buf[] = { 0x01, 0x03 };279 280 return sps30_serial_command(state, SPS30_SERIAL_START_MEAS, buf, sizeof(buf), NULL, 0);281}282 283static int sps30_serial_stop_meas(struct sps30_state *state)284{285 return sps30_serial_command(state, SPS30_SERIAL_STOP_MEAS, NULL, 0, NULL, 0);286}287 288static int sps30_serial_reset(struct sps30_state *state)289{290 int ret;291 292 ret = sps30_serial_command(state, SPS30_SERIAL_RESET, NULL, 0, NULL, 0);293 msleep(500);294 295 return ret;296}297 298static int sps30_serial_read_meas(struct sps30_state *state, __be32 *meas, size_t num)299{300 int ret;301 302 /* measurements are ready within a second */303 if (msleep_interruptible(1000))304 return -EINTR;305 306 ret = sps30_serial_command(state, SPS30_SERIAL_READ_MEAS, NULL, 0, meas, num * sizeof(num));307 if (ret < 0)308 return ret;309 /* if measurements aren't ready sensor returns empty frame */310 if (ret == SPS30_SERIAL_FRAME_MIN_SIZE)311 return -ETIMEDOUT;312 if (ret != num * sizeof(*meas))313 return -EIO;314 315 return 0;316}317 318static int sps30_serial_clean_fan(struct sps30_state *state)319{320 return sps30_serial_command(state, SPS30_SERIAL_CLEAN_FAN, NULL, 0, NULL, 0);321}322 323static int sps30_serial_read_cleaning_period(struct sps30_state *state, __be32 *period)324{325 unsigned char buf[] = { 0x00 };326 int ret;327 328 ret = sps30_serial_command(state, SPS30_SERIAL_PERIOD, buf, sizeof(buf),329 period, sizeof(*period));330 if (ret < 0)331 return ret;332 if (ret != sizeof(*period))333 return -EIO;334 335 return 0;336}337 338static int sps30_serial_write_cleaning_period(struct sps30_state *state, __be32 period)339{340 unsigned char buf[5] = { 0x00 };341 342 memcpy(buf + 1, &period, sizeof(period));343 344 return sps30_serial_command(state, SPS30_SERIAL_PERIOD, buf, sizeof(buf), NULL, 0);345}346 347static int sps30_serial_show_info(struct sps30_state *state)348{349 /*350 * tell device do return serial number and add extra nul byte just in case351 * serial number isn't a valid string352 */353 unsigned char buf[32 + 1] = { 0x03 };354 struct device *dev = state->dev;355 int ret;356 357 ret = sps30_serial_command(state, SPS30_SERIAL_DEV_INFO, buf, 1, buf, sizeof(buf) - 1);358 if (ret < 0)359 return ret;360 if (ret != sizeof(buf) - 1)361 return -EIO;362 363 dev_info(dev, "serial number: %s\n", buf);364 365 ret = sps30_serial_command(state, SPS30_SERIAL_READ_VERSION, NULL, 0, buf, sizeof(buf) - 1);366 if (ret < 0)367 return ret;368 if (ret < 2)369 return -EIO;370 371 dev_info(dev, "fw version: %u.%u\n", buf[0], buf[1]);372 373 return 0;374}375 376static const struct sps30_ops sps30_serial_ops = {377 .start_meas = sps30_serial_start_meas,378 .stop_meas = sps30_serial_stop_meas,379 .read_meas = sps30_serial_read_meas,380 .reset = sps30_serial_reset,381 .clean_fan = sps30_serial_clean_fan,382 .read_cleaning_period = sps30_serial_read_cleaning_period,383 .write_cleaning_period = sps30_serial_write_cleaning_period,384 .show_info = sps30_serial_show_info,385};386 387static int sps30_serial_probe(struct serdev_device *serdev)388{389 struct device *dev = &serdev->dev;390 struct sps30_serial_priv *priv;391 int ret;392 393 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);394 if (!priv)395 return -ENOMEM;396 397 init_completion(&priv->new_frame);398 serdev_device_set_client_ops(serdev, &sps30_serial_device_ops);399 400 ret = devm_serdev_device_open(dev, serdev);401 if (ret)402 return ret;403 404 serdev_device_set_baudrate(serdev, 115200);405 serdev_device_set_flow_control(serdev, false);406 407 ret = serdev_device_set_parity(serdev, SERDEV_PARITY_NONE);408 if (ret)409 return ret;410 411 return sps30_probe(dev, SPS30_SERIAL_DEV_NAME, priv, &sps30_serial_ops);412}413 414static const struct of_device_id sps30_serial_of_match[] = {415 { .compatible = "sensirion,sps30" },416 { }417};418MODULE_DEVICE_TABLE(of, sps30_serial_of_match);419 420static struct serdev_device_driver sps30_serial_driver = {421 .driver = {422 .name = KBUILD_MODNAME,423 .of_match_table = sps30_serial_of_match,424 },425 .probe = sps30_serial_probe,426};427module_serdev_device_driver(sps30_serial_driver);428 429MODULE_AUTHOR("Tomasz Duszynski <tomasz.duszynski@octakon.com>");430MODULE_DESCRIPTION("Sensirion SPS30 particulate matter sensor serial driver");431MODULE_LICENSE("GPL v2");432MODULE_IMPORT_NS(IIO_SPS30);433