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