drivers/iio/accel/adxl345_core.c

   1 /*
   2  * ADXL345 3-Axis Digital Accelerometer IIO core driver
   3  *
   4  * Copyright (c) 2017 Eva Rachel Retuya <eraretuya@gmail.com>
   5  *
   6  * This file is subject to the terms and conditions of version 2 of
   7  * the GNU General Public License. See the file COPYING in the main
   8  * directory of this archive for more details.
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/regmap.h>
  13
  14 #include <linux/iio/iio.h>
  15
  16 #include "adxl345.h"
  17
  18 #define ADXL345_REG_DEVID               0x00
  19 #define ADXL345_REG_POWER_CTL           0x2D
  20 #define ADXL345_REG_DATA_FORMAT         0x31
  21 #define ADXL345_REG_DATAX0              0x32
  22 #define ADXL345_REG_DATAY0              0x34
  23 #define ADXL345_REG_DATAZ0              0x36
  24 #define ADXL345_REG_DATA_AXIS(index)    \
  25         (ADXL345_REG_DATAX0 + (index) * sizeof(__le16))
  26
  27 #define ADXL345_POWER_CTL_MEASURE       BIT(3)
  28 #define ADXL345_POWER_CTL_STANDBY       0x00
  29
  30 #define ADXL345_DATA_FORMAT_FULL_RES    BIT(3) /* Up to 13-bits resolution */
  31 #define ADXL345_DATA_FORMAT_2G          0
  32 #define ADXL345_DATA_FORMAT_4G          1
  33 #define ADXL345_DATA_FORMAT_8G          2
  34 #define ADXL345_DATA_FORMAT_16G         3
  35
  36 #define ADXL345_DEVID                   0xE5
  37
  38 /*
  39  * In full-resolution mode, scale factor is maintained at ~4 mg/LSB
  40  * in all g ranges.
  41  *
  42  * At +/- 16g with 13-bit resolution, scale is computed as:
  43  * (16 + 16) * 9.81 / (2^13 - 1) = 0.0383
  44  */
  45 static const int adxl345_uscale = 38300;
  46
  47 struct adxl345_data {
  48         struct regmap *regmap;
  49         u8 data_range;
  50 };
  51
  52 #define ADXL345_CHANNEL(index, axis) {                                  \
  53         .type = IIO_ACCEL,                                              \
  54         .modified = 1,                                                  \
  55         .channel2 = IIO_MOD_##axis,                                     \
  56         .address = index,                                               \
  57         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),                   \
  58         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),           \
  59 }
  60
  61 static const struct iio_chan_spec adxl345_channels[] = {
  62         ADXL345_CHANNEL(0, X),
  63         ADXL345_CHANNEL(1, Y),
  64         ADXL345_CHANNEL(2, Z),
  65 };
  66
  67 static int adxl345_read_raw(struct iio_dev *indio_dev,
  68                             struct iio_chan_spec const *chan,
  69                             int *val, int *val2, long mask)
  70 {
  71         struct adxl345_data *data = iio_priv(indio_dev);
  72         __le16 accel;
  73         int ret;
  74
  75         switch (mask) {
  76         case IIO_CHAN_INFO_RAW:
  77                 /*
  78                  * Data is stored in adjacent registers:
  79                  * ADXL345_REG_DATA(X0/Y0/Z0) contain the least significant byte
  80                  * and ADXL345_REG_DATA(X0/Y0/Z0) + 1 the most significant byte
  81                  */
  82                 ret = regmap_bulk_read(data->regmap,
  83                                        ADXL345_REG_DATA_AXIS(chan->address),
  84                                        &accel, sizeof(accel));
  85                 if (ret < 0)
  86                         return ret;
  87
  88                 *val = sign_extend32(le16_to_cpu(accel), 12);
  89                 return IIO_VAL_INT;
  90         case IIO_CHAN_INFO_SCALE:
  91                 *val = 0;
  92                 *val2 = adxl345_uscale;
  93
  94                 return IIO_VAL_INT_PLUS_MICRO;
  95         }
  96
  97         return -EINVAL;
  98 }
  99
 100 static const struct iio_info adxl345_info = {
 101         .driver_module  = THIS_MODULE,
 102         .read_raw       = adxl345_read_raw,
 103 };
 104
 105 int adxl345_core_probe(struct device *dev, struct regmap *regmap,
 106                        const char *name)
 107 {
 108         struct adxl345_data *data;
 109         struct iio_dev *indio_dev;
 110         u32 regval;
 111         int ret;
 112
 113         ret = regmap_read(regmap, ADXL345_REG_DEVID, &regval);
 114         if (ret < 0) {
 115                 dev_err(dev, "Error reading device ID: %d\n", ret);
 116                 return ret;
 117         }
 118
 119         if (regval != ADXL345_DEVID) {
 120                 dev_err(dev, "Invalid device ID: %x, expected %x\n",
 121                         regval, ADXL345_DEVID);
 122                 return -ENODEV;
 123         }
 124
 125         indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
 126         if (!indio_dev)
 127                 return -ENOMEM;
 128
 129         data = iio_priv(indio_dev);
 130         dev_set_drvdata(dev, indio_dev);
 131         data->regmap = regmap;
 132         /* Enable full-resolution mode */
 133         data->data_range = ADXL345_DATA_FORMAT_FULL_RES;
 134
 135         ret = regmap_write(data->regmap, ADXL345_REG_DATA_FORMAT,
 136                            data->data_range);
 137         if (ret < 0) {
 138                 dev_err(dev, "Failed to set data range: %d\n", ret);
 139                 return ret;
 140         }
 141
 142         indio_dev->dev.parent = dev;
 143         indio_dev->name = name;
 144         indio_dev->info = &adxl345_info;
 145         indio_dev->modes = INDIO_DIRECT_MODE;
 146         indio_dev->channels = adxl345_channels;
 147         indio_dev->num_channels = ARRAY_SIZE(adxl345_channels);
 148
 149         /* Enable measurement mode */
 150         ret = regmap_write(data->regmap, ADXL345_REG_POWER_CTL,
 151                            ADXL345_POWER_CTL_MEASURE);
 152         if (ret < 0) {
 153                 dev_err(dev, "Failed to enable measurement mode: %d\n", ret);
 154                 return ret;
 155         }
 156
 157         ret = iio_device_register(indio_dev);
 158         if (ret < 0) {
 159                 dev_err(dev, "iio_device_register failed: %d\n", ret);
 160                 regmap_write(data->regmap, ADXL345_REG_POWER_CTL,
 161                              ADXL345_POWER_CTL_STANDBY);
 162         }
 163
 164         return ret;
 165 }
 166 EXPORT_SYMBOL_GPL(adxl345_core_probe);
 167
 168 int adxl345_core_remove(struct device *dev)
 169 {
 170         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 171         struct adxl345_data *data = iio_priv(indio_dev);
 172
 173         iio_device_unregister(indio_dev);
 174
 175         return regmap_write(data->regmap, ADXL345_REG_POWER_CTL,
 176                             ADXL345_POWER_CTL_STANDBY);
 177 }
 178 EXPORT_SYMBOL_GPL(adxl345_core_remove);
 179
 180 MODULE_AUTHOR("Eva Rachel Retuya <eraretuya@gmail.com>");
 181 MODULE_DESCRIPTION("ADXL345 3-Axis Digital Accelerometer core driver");
 182 MODULE_LICENSE("GPL v2");