drivers/iio/pressure/dlhl60d.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * All Sensors DLH series low voltage digital pressure sensors
   4  *
   5  * Copyright (c) 2019 AVL DiTEST GmbH
   6  *   Tomislav Denis <tomislav.denis@avl.com>
   7  *
   8  * Datasheet: https://www.allsensors.com/cad/DS-0355_Rev_B.PDF
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/delay.h>
  13 #include <linux/i2c.h>
  14 #include <linux/iio/iio.h>
  15 #include <linux/iio/buffer.h>
  16 #include <linux/iio/trigger_consumer.h>
  17 #include <linux/iio/triggered_buffer.h>
  18 #include <asm/unaligned.h>
  19
  20 /* Commands */
  21 #define DLH_START_SINGLE    0xAA
  22
  23 /* Status bits */
  24 #define DLH_STATUS_OK       0x40
  25
  26 /* DLH  data format */
  27 #define DLH_NUM_READ_BYTES  7
  28 #define DLH_NUM_DATA_BYTES  3
  29 #define DLH_NUM_PR_BITS     24
  30 #define DLH_NUM_TEMP_BITS   24
  31
  32 /* DLH  timings */
  33 #define DLH_SINGLE_DUT_MS   5
  34
  35 enum dhl_ids {
  36         dlhl60d,
  37         dlhl60g,
  38 };
  39
  40 struct dlh_info {
  41         u8 osdig;           /* digital offset factor */
  42         unsigned int fss;   /* full scale span (inch H2O) */
  43 };
  44
  45 struct dlh_state {
  46         struct i2c_client *client;
  47         struct dlh_info info;
  48         bool use_interrupt;
  49         struct completion completion;
  50         u8 rx_buf[DLH_NUM_READ_BYTES];
  51 };
  52
  53 static struct dlh_info dlh_info_tbl[] = {
  54         [dlhl60d] = {
  55                 .osdig = 2,
  56                 .fss = 120,
  57         },
  58         [dlhl60g] = {
  59                 .osdig = 10,
  60                 .fss = 60,
  61         },
  62 };
  63
  64
  65 static int dlh_cmd_start_single(struct dlh_state *st)
  66 {
  67         int ret;
  68
  69         ret = i2c_smbus_write_byte(st->client, DLH_START_SINGLE);
  70         if (ret)
  71                 dev_err(&st->client->dev,
  72                         "%s: I2C write byte failed\n", __func__);
  73
  74         return ret;
  75 }
  76
  77 static int dlh_cmd_read_data(struct dlh_state *st)
  78 {
  79         int ret;
  80
  81         ret = i2c_master_recv(st->client, st->rx_buf, DLH_NUM_READ_BYTES);
  82         if (ret < 0) {
  83                 dev_err(&st->client->dev,
  84                         "%s: I2C read block failed\n", __func__);
  85                 return ret;
  86         }
  87
  88         if (st->rx_buf[0] != DLH_STATUS_OK) {
  89                 dev_err(&st->client->dev,
  90                         "%s: invalid status 0x%02x\n", __func__, st->rx_buf[0]);
  91                 return -EBUSY;
  92         }
  93
  94         return 0;
  95 }
  96
  97 static int dlh_start_capture_and_read(struct dlh_state *st)
  98 {
  99         int ret;
 100
 101         if (st->use_interrupt)
 102                 reinit_completion(&st->completion);
 103
 104         ret = dlh_cmd_start_single(st);
 105         if (ret)
 106                 return ret;
 107
 108         if (st->use_interrupt) {
 109                 ret = wait_for_completion_timeout(&st->completion,
 110                         msecs_to_jiffies(DLH_SINGLE_DUT_MS));
 111                 if (!ret) {
 112                         dev_err(&st->client->dev,
 113                                 "%s: conversion timed out\n", __func__);
 114                         return -ETIMEDOUT;
 115                 }
 116         } else {
 117                 mdelay(DLH_SINGLE_DUT_MS);
 118         }
 119
 120         return dlh_cmd_read_data(st);
 121 }
 122
 123 static int dlh_read_direct(struct dlh_state *st,
 124         unsigned int *pressure, unsigned int *temperature)
 125 {
 126         int ret;
 127
 128         ret = dlh_start_capture_and_read(st);
 129         if (ret)
 130                 return ret;
 131
 132         *pressure = get_unaligned_be24(&st->rx_buf[1]);
 133         *temperature = get_unaligned_be24(&st->rx_buf[4]);
 134
 135         return 0;
 136 }
 137
 138 static int dlh_read_raw(struct iio_dev *indio_dev,
 139         struct iio_chan_spec const *channel, int *value,
 140         int *value2, long mask)
 141 {
 142         struct dlh_state *st = iio_priv(indio_dev);
 143         unsigned int pressure, temperature;
 144         int ret;
 145         s64 tmp;
 146         s32 rem;
 147
 148         switch (mask) {
 149         case IIO_CHAN_INFO_RAW:
 150                 ret = iio_device_claim_direct_mode(indio_dev);
 151                 if (ret)
 152                         return ret;
 153
 154                 ret = dlh_read_direct(st, &pressure, &temperature);
 155                 iio_device_release_direct_mode(indio_dev);
 156                 if (ret)
 157                         return ret;
 158
 159                 switch (channel->type) {
 160                 case IIO_PRESSURE:
 161                         *value = pressure;
 162                         return IIO_VAL_INT;
 163
 164                 case IIO_TEMP:
 165                         *value = temperature;
 166                         return IIO_VAL_INT;
 167
 168                 default:
 169                         return -EINVAL;
 170                 }
 171         case IIO_CHAN_INFO_SCALE:
 172                 switch (channel->type) {
 173                 case IIO_PRESSURE:
 174                         tmp = div_s64(125LL * st->info.fss * 24909 * 100,
 175                                 1 << DLH_NUM_PR_BITS);
 176                         tmp = div_s64_rem(tmp, 1000000000LL, &rem);
 177                         *value = tmp;
 178                         *value2 = rem;
 179                         return IIO_VAL_INT_PLUS_NANO;
 180
 181                 case IIO_TEMP:
 182                         *value = 125 * 1000;
 183                         *value2 = DLH_NUM_TEMP_BITS;
 184                         return IIO_VAL_FRACTIONAL_LOG2;
 185
 186                 default:
 187                         return -EINVAL;
 188                 }
 189         case IIO_CHAN_INFO_OFFSET:
 190                 switch (channel->type) {
 191                 case IIO_PRESSURE:
 192                         *value = -125 * st->info.fss * 24909;
 193                         *value2 = 100 * st->info.osdig * 100000;
 194                         return IIO_VAL_FRACTIONAL;
 195
 196                 case IIO_TEMP:
 197                         *value = -40 * 1000;
 198                         return IIO_VAL_INT;
 199
 200                 default:
 201                         return -EINVAL;
 202                 }
 203         }
 204
 205         return -EINVAL;
 206 }
 207
 208 static const struct iio_info dlh_info = {
 209         .read_raw = dlh_read_raw,
 210 };
 211
 212 static const struct iio_chan_spec dlh_channels[] = {
 213         {
 214                 .type = IIO_PRESSURE,
 215                 .indexed = 1,
 216                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 217                 .info_mask_shared_by_type =
 218                         BIT(IIO_CHAN_INFO_SCALE) |
 219                         BIT(IIO_CHAN_INFO_OFFSET),
 220                 .scan_index = 0,
 221                 .scan_type = {
 222                         .sign = 'u',
 223                         .realbits = DLH_NUM_PR_BITS,
 224                         .storagebits = 32,
 225                         .shift = 8,
 226                         .endianness = IIO_BE,
 227                 },
 228         }, {
 229                 .type = IIO_TEMP,
 230                 .indexed = 1,
 231                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 232                 .info_mask_shared_by_type =
 233                         BIT(IIO_CHAN_INFO_SCALE) |
 234                         BIT(IIO_CHAN_INFO_OFFSET),
 235                 .scan_index = 1,
 236                 .scan_type = {
 237                         .sign = 'u',
 238                         .realbits = DLH_NUM_TEMP_BITS,
 239                         .storagebits = 32,
 240                         .shift = 8,
 241                         .endianness = IIO_BE,
 242                 },
 243         }
 244 };
 245
 246 static irqreturn_t dlh_trigger_handler(int irq, void *private)
 247 {
 248         struct iio_poll_func *pf = private;
 249         struct iio_dev *indio_dev = pf->indio_dev;
 250         struct dlh_state *st = iio_priv(indio_dev);
 251         int ret;
 252         unsigned int chn, i = 0;
 253         __be32 tmp_buf[2];
 254
 255         ret = dlh_start_capture_and_read(st);
 256         if (ret)
 257                 goto out;
 258
 259         for_each_set_bit(chn, indio_dev->active_scan_mask,
 260                 indio_dev->masklength) {
 261                 memcpy(tmp_buf + i,
 262                         &st->rx_buf[1] + chn * DLH_NUM_DATA_BYTES,
 263                         DLH_NUM_DATA_BYTES);
 264                 i++;
 265         }
 266
 267         iio_push_to_buffers(indio_dev, tmp_buf);
 268
 269 out:
 270         iio_trigger_notify_done(indio_dev->trig);
 271
 272         return IRQ_HANDLED;
 273 }
 274
 275 static irqreturn_t dlh_interrupt(int irq, void *private)
 276 {
 277         struct iio_dev *indio_dev = private;
 278         struct dlh_state *st = iio_priv(indio_dev);
 279
 280         complete(&st->completion);
 281
 282         return IRQ_HANDLED;
 283 };
 284
 285 static int dlh_probe(struct i2c_client *client)
 286 {
 287         const struct i2c_device_id *id = i2c_client_get_device_id(client);
 288         struct dlh_state *st;
 289         struct iio_dev *indio_dev;
 290         int ret;
 291
 292         if (!i2c_check_functionality(client->adapter,
 293                 I2C_FUNC_I2C | I2C_FUNC_SMBUS_WRITE_BYTE)) {
 294                 dev_err(&client->dev,
 295                         "adapter doesn't support required i2c functionality\n");
 296                 return -EOPNOTSUPP;
 297         }
 298
 299         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*st));
 300         if (!indio_dev) {
 301                 dev_err(&client->dev, "failed to allocate iio device\n");
 302                 return -ENOMEM;
 303         }
 304
 305         i2c_set_clientdata(client, indio_dev);
 306
 307         st = iio_priv(indio_dev);
 308         st->info = dlh_info_tbl[id->driver_data];
 309         st->client = client;
 310         st->use_interrupt = false;
 311
 312         indio_dev->name = id->name;
 313         indio_dev->info = &dlh_info;
 314         indio_dev->modes = INDIO_DIRECT_MODE;
 315         indio_dev->channels =  dlh_channels;
 316         indio_dev->num_channels = ARRAY_SIZE(dlh_channels);
 317
 318         if (client->irq > 0) {
 319                 ret = devm_request_threaded_irq(&client->dev, client->irq,
 320                         dlh_interrupt, NULL,
 321                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 322                         id->name, indio_dev);
 323                 if (ret) {
 324                         dev_err(&client->dev, "failed to allocate threaded irq");
 325                         return ret;
 326                 }
 327
 328                 st->use_interrupt = true;
 329                 init_completion(&st->completion);
 330         }
 331
 332         ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev,
 333                 NULL, &dlh_trigger_handler, NULL);
 334         if (ret) {
 335                 dev_err(&client->dev, "failed to setup iio buffer\n");
 336                 return ret;
 337         }
 338
 339         ret = devm_iio_device_register(&client->dev, indio_dev);
 340         if (ret)
 341                 dev_err(&client->dev, "failed to register iio device\n");
 342
 343         return ret;
 344 }
 345
 346 static const struct of_device_id dlh_of_match[] = {
 347         { .compatible = "asc,dlhl60d" },
 348         { .compatible = "asc,dlhl60g" },
 349         {}
 350 };
 351 MODULE_DEVICE_TABLE(of, dlh_of_match);
 352
 353 static const struct i2c_device_id dlh_id[] = {
 354         { "dlhl60d",    dlhl60d },
 355         { "dlhl60g",    dlhl60g },
 356         {}
 357 };
 358 MODULE_DEVICE_TABLE(i2c, dlh_id);
 359
 360 static struct i2c_driver dlh_driver = {
 361         .driver = {
 362                 .name = "dlhl60d",
 363                 .of_match_table = dlh_of_match,
 364         },
 365         .probe = dlh_probe,
 366         .id_table = dlh_id,
 367 };
 368 module_i2c_driver(dlh_driver);
 369
 370 MODULE_AUTHOR("Tomislav Denis <tomislav.denis@avl.com>");
 371 MODULE_DESCRIPTION("Driver for All Sensors DLH series pressure sensors");
 372 MODULE_LICENSE("GPL v2");