drivers/iio/pressure/hp03.c

   1 /*
   2  * Copyright (c) 2016 Marek Vasut <marex@denx.de>
   3  *
   4  * Driver for Hope RF HP03 digital temperature and pressure sensor.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #define pr_fmt(fmt) "hp03: " fmt
  12
  13 #include <linux/module.h>
  14 #include <linux/delay.h>
  15 #include <linux/gpio/consumer.h>
  16 #include <linux/i2c.h>
  17 #include <linux/regmap.h>
  18 #include <linux/iio/iio.h>
  19 #include <linux/iio/sysfs.h>
  20
  21 /*
  22  * The HP03 sensor occupies two fixed I2C addresses:
  23  *  0x50 ... read-only EEPROM with calibration data
  24  *  0x77 ... read-write ADC for pressure and temperature
  25  */
  26 #define HP03_EEPROM_ADDR                0x50
  27 #define HP03_ADC_ADDR                   0x77
  28
  29 #define HP03_EEPROM_CX_OFFSET           0x10
  30 #define HP03_EEPROM_AB_OFFSET           0x1e
  31 #define HP03_EEPROM_CD_OFFSET           0x20
  32
  33 #define HP03_ADC_WRITE_REG              0xff
  34 #define HP03_ADC_READ_REG               0xfd
  35 #define HP03_ADC_READ_PRESSURE          0xf0    /* D1 in datasheet */
  36 #define HP03_ADC_READ_TEMP              0xe8    /* D2 in datasheet */
  37
  38 struct hp03_priv {
  39         struct i2c_client       *client;
  40         struct mutex            lock;
  41         struct gpio_desc        *xclr_gpio;
  42
  43         struct i2c_client       *eeprom_client;
  44         struct regmap           *eeprom_regmap;
  45
  46         s32                     pressure;       /* kPa */
  47         s32                     temp;           /* Deg. C */
  48 };
  49
  50 static const struct iio_chan_spec hp03_channels[] = {
  51         {
  52                 .type = IIO_PRESSURE,
  53                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  54                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
  55         },
  56         {
  57                 .type = IIO_TEMP,
  58                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  59                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
  60         },
  61 };
  62
  63 static bool hp03_is_writeable_reg(struct device *dev, unsigned int reg)
  64 {
  65         return false;
  66 }
  67
  68 static bool hp03_is_volatile_reg(struct device *dev, unsigned int reg)
  69 {
  70         return false;
  71 }
  72
  73 static const struct regmap_config hp03_regmap_config = {
  74         .reg_bits       = 8,
  75         .val_bits       = 8,
  76
  77         .max_register   = HP03_EEPROM_CD_OFFSET + 1,
  78         .cache_type     = REGCACHE_RBTREE,
  79
  80         .writeable_reg  = hp03_is_writeable_reg,
  81         .volatile_reg   = hp03_is_volatile_reg,
  82 };
  83
  84 static int hp03_get_temp_pressure(struct hp03_priv *priv, const u8 reg)
  85 {
  86         int ret;
  87
  88         ret = i2c_smbus_write_byte_data(priv->client, HP03_ADC_WRITE_REG, reg);
  89         if (ret < 0)
  90                 return ret;
  91
  92         msleep(50);     /* Wait for conversion to finish */
  93
  94         return i2c_smbus_read_word_data(priv->client, HP03_ADC_READ_REG);
  95 }
  96
  97 static int hp03_update_temp_pressure(struct hp03_priv *priv)
  98 {
  99         struct device *dev = &priv->client->dev;
 100         u8 coefs[18];
 101         u16 cx_val[7];
 102         int ab_val, d1_val, d2_val, diff_val, dut, off, sens, x;
 103         int i, ret;
 104
 105         /* Sample coefficients from EEPROM */
 106         ret = regmap_bulk_read(priv->eeprom_regmap, HP03_EEPROM_CX_OFFSET,
 107                                coefs, sizeof(coefs));
 108         if (ret < 0) {
 109                 dev_err(dev, "Failed to read EEPROM (reg=%02x)\n",
 110                         HP03_EEPROM_CX_OFFSET);
 111                 return ret;
 112         }
 113
 114         /* Sample Temperature and Pressure */
 115         gpiod_set_value_cansleep(priv->xclr_gpio, 1);
 116
 117         ret = hp03_get_temp_pressure(priv, HP03_ADC_READ_PRESSURE);
 118         if (ret < 0) {
 119                 dev_err(dev, "Failed to read pressure\n");
 120                 goto err_adc;
 121         }
 122         d1_val = ret;
 123
 124         ret = hp03_get_temp_pressure(priv, HP03_ADC_READ_TEMP);
 125         if (ret < 0) {
 126                 dev_err(dev, "Failed to read temperature\n");
 127                 goto err_adc;
 128         }
 129         d2_val = ret;
 130
 131         gpiod_set_value_cansleep(priv->xclr_gpio, 0);
 132
 133         /* The Cx coefficients and Temp/Pressure values are MSB first. */
 134         for (i = 0; i < 7; i++)
 135                 cx_val[i] = (coefs[2 * i] << 8) | (coefs[(2 * i) + 1] << 0);
 136         d1_val = ((d1_val >> 8) & 0xff) | ((d1_val & 0xff) << 8);
 137         d2_val = ((d2_val >> 8) & 0xff) | ((d2_val & 0xff) << 8);
 138
 139         /* Coefficient voodoo from the HP03 datasheet. */
 140         if (d2_val >= cx_val[4])
 141                 ab_val = coefs[14];     /* A-value */
 142         else
 143                 ab_val = coefs[15];     /* B-value */
 144
 145         diff_val = d2_val - cx_val[4];
 146         dut = (ab_val * (diff_val >> 7) * (diff_val >> 7)) >> coefs[16];
 147         dut = diff_val - dut;
 148
 149         off = (cx_val[1] + (((cx_val[3] - 1024) * dut) >> 14)) * 4;
 150         sens = cx_val[0] + ((cx_val[2] * dut) >> 10);
 151         x = ((sens * (d1_val - 7168)) >> 14) - off;
 152
 153         priv->pressure = ((x * 100) >> 5) + (cx_val[6] * 10);
 154         priv->temp = 250 + ((dut * cx_val[5]) >> 16) - (dut >> coefs[17]);
 155
 156         return 0;
 157
 158 err_adc:
 159         gpiod_set_value_cansleep(priv->xclr_gpio, 0);
 160         return ret;
 161 }
 162
 163 static int hp03_read_raw(struct iio_dev *indio_dev,
 164                          struct iio_chan_spec const *chan,
 165                          int *val, int *val2, long mask)
 166 {
 167         struct hp03_priv *priv = iio_priv(indio_dev);
 168         int ret;
 169
 170         mutex_lock(&priv->lock);
 171         ret = hp03_update_temp_pressure(priv);
 172         mutex_unlock(&priv->lock);
 173
 174         if (ret)
 175                 return ret;
 176
 177         switch (mask) {
 178         case IIO_CHAN_INFO_RAW:
 179                 switch (chan->type) {
 180                 case IIO_PRESSURE:
 181                         *val = priv->pressure;
 182                         return IIO_VAL_INT;
 183                 case IIO_TEMP:
 184                         *val = priv->temp;
 185                         return IIO_VAL_INT;
 186                 default:
 187                         return -EINVAL;
 188                 }
 189                 break;
 190         case IIO_CHAN_INFO_SCALE:
 191                 switch (chan->type) {
 192                 case IIO_PRESSURE:
 193                         *val = 0;
 194                         *val2 = 1000;
 195                         return IIO_VAL_INT_PLUS_MICRO;
 196                 case IIO_TEMP:
 197                         *val = 10;
 198                         return IIO_VAL_INT;
 199                 default:
 200                         return -EINVAL;
 201                 }
 202                 break;
 203         default:
 204                 return -EINVAL;
 205         }
 206
 207         return -EINVAL;
 208 }
 209
 210 static const struct iio_info hp03_info = {
 211         .driver_module  = THIS_MODULE,
 212         .read_raw       = &hp03_read_raw,
 213 };
 214
 215 static int hp03_probe(struct i2c_client *client,
 216                       const struct i2c_device_id *id)
 217 {
 218         struct device *dev = &client->dev;
 219         struct iio_dev *indio_dev;
 220         struct hp03_priv *priv;
 221         int ret;
 222
 223         indio_dev = devm_iio_device_alloc(dev, sizeof(*priv));
 224         if (!indio_dev)
 225                 return -ENOMEM;
 226
 227         priv = iio_priv(indio_dev);
 228         priv->client = client;
 229         mutex_init(&priv->lock);
 230
 231         indio_dev->dev.parent = dev;
 232         indio_dev->name = id->name;
 233         indio_dev->channels = hp03_channels;
 234         indio_dev->num_channels = ARRAY_SIZE(hp03_channels);
 235         indio_dev->info = &hp03_info;
 236         indio_dev->modes = INDIO_DIRECT_MODE;
 237
 238         priv->xclr_gpio = devm_gpiod_get_index(dev, "xclr", 0, GPIOD_OUT_HIGH);
 239         if (IS_ERR(priv->xclr_gpio)) {
 240                 dev_err(dev, "Failed to claim XCLR GPIO\n");
 241                 ret = PTR_ERR(priv->xclr_gpio);
 242                 return ret;
 243         }
 244
 245         /*
 246          * Allocate another device for the on-sensor EEPROM,
 247          * which has it's dedicated I2C address and contains
 248          * the calibration constants for the sensor.
 249          */
 250         priv->eeprom_client = i2c_new_dummy(client->adapter, HP03_EEPROM_ADDR);
 251         if (!priv->eeprom_client) {
 252                 dev_err(dev, "New EEPROM I2C device failed\n");
 253                 return -ENODEV;
 254         }
 255
 256         priv->eeprom_regmap = regmap_init_i2c(priv->eeprom_client,
 257                                               &hp03_regmap_config);
 258         if (IS_ERR(priv->eeprom_regmap)) {
 259                 dev_err(dev, "Failed to allocate EEPROM regmap\n");
 260                 ret = PTR_ERR(priv->eeprom_regmap);
 261                 goto err_cleanup_eeprom_client;
 262         }
 263
 264         ret = iio_device_register(indio_dev);
 265         if (ret) {
 266                 dev_err(dev, "Failed to register IIO device\n");
 267                 goto err_cleanup_eeprom_regmap;
 268         }
 269
 270         i2c_set_clientdata(client, indio_dev);
 271
 272         return 0;
 273
 274 err_cleanup_eeprom_regmap:
 275         regmap_exit(priv->eeprom_regmap);
 276
 277 err_cleanup_eeprom_client:
 278         i2c_unregister_device(priv->eeprom_client);
 279         return ret;
 280 }
 281
 282 static int hp03_remove(struct i2c_client *client)
 283 {
 284         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 285         struct hp03_priv *priv = iio_priv(indio_dev);
 286
 287         iio_device_unregister(indio_dev);
 288         regmap_exit(priv->eeprom_regmap);
 289         i2c_unregister_device(priv->eeprom_client);
 290
 291         return 0;
 292 }
 293
 294 static const struct i2c_device_id hp03_id[] = {
 295         { "hp03", 0 },
 296         { },
 297 };
 298 MODULE_DEVICE_TABLE(i2c, hp03_id);
 299
 300 static const struct of_device_id hp03_of_match[] = {
 301         { .compatible = "hoperf,hp03" },
 302         { },
 303 };
 304 MODULE_DEVICE_TABLE(of, hp03_of_match);
 305
 306 static struct i2c_driver hp03_driver = {
 307         .driver = {
 308                 .name   = "hp03",
 309                 .of_match_table = hp03_of_match,
 310         },
 311         .probe          = hp03_probe,
 312         .remove         = hp03_remove,
 313         .id_table       = hp03_id,
 314 };
 315 module_i2c_driver(hp03_driver);
 316
 317 MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
 318 MODULE_DESCRIPTION("Driver for Hope RF HP03 pressure and temperature sensor");
 319 MODULE_LICENSE("GPL v2");