drivers/iio/accel/bma220_spi.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * BMA220 Digital triaxial acceleration sensor driver
   4  *
   5  * Copyright (c) 2016,2020 Intel Corporation.
   6  */
   7
   8 #include <linux/bits.h>
   9 #include <linux/kernel.h>
  10 #include <linux/mod_devicetable.h>
  11 #include <linux/module.h>
  12 #include <linux/types.h>
  13 #include <linux/spi/spi.h>
  14
  15 #include <linux/iio/buffer.h>
  16 #include <linux/iio/iio.h>
  17 #include <linux/iio/sysfs.h>
  18 #include <linux/iio/trigger_consumer.h>
  19 #include <linux/iio/triggered_buffer.h>
  20
  21 #define BMA220_REG_ID                           0x00
  22 #define BMA220_REG_ACCEL_X                      0x02
  23 #define BMA220_REG_ACCEL_Y                      0x03
  24 #define BMA220_REG_ACCEL_Z                      0x04
  25 #define BMA220_REG_RANGE                        0x11
  26 #define BMA220_REG_SUSPEND                      0x18
  27
  28 #define BMA220_CHIP_ID                          0xDD
  29 #define BMA220_READ_MASK                        BIT(7)
  30 #define BMA220_RANGE_MASK                       GENMASK(1, 0)
  31 #define BMA220_SUSPEND_SLEEP                    0xFF
  32 #define BMA220_SUSPEND_WAKE                     0x00
  33
  34 #define BMA220_DEVICE_NAME                      "bma220"
  35
  36 #define BMA220_ACCEL_CHANNEL(index, reg, axis) {                        \
  37         .type = IIO_ACCEL,                                              \
  38         .address = reg,                                                 \
  39         .modified = 1,                                                  \
  40         .channel2 = IIO_MOD_##axis,                                     \
  41         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),                   \
  42         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),           \
  43         .scan_index = index,                                            \
  44         .scan_type = {                                                  \
  45                 .sign = 's',                                            \
  46                 .realbits = 6,                                          \
  47                 .storagebits = 8,                                       \
  48                 .shift = 2,                                             \
  49                 .endianness = IIO_CPU,                                  \
  50         },                                                              \
  51 }
  52
  53 enum bma220_axis {
  54         AXIS_X,
  55         AXIS_Y,
  56         AXIS_Z,
  57 };
  58
  59 static const int bma220_scale_table[][2] = {
  60         {0, 623000}, {1, 248000}, {2, 491000}, {4, 983000},
  61 };
  62
  63 struct bma220_data {
  64         struct spi_device *spi_device;
  65         struct mutex lock;
  66         struct {
  67                 s8 chans[3];
  68                 /* Ensure timestamp is naturally aligned. */
  69                 s64 timestamp __aligned(8);
  70         } scan;
  71         u8 tx_buf[2] __aligned(IIO_DMA_MINALIGN);
  72 };
  73
  74 static const struct iio_chan_spec bma220_channels[] = {
  75         BMA220_ACCEL_CHANNEL(0, BMA220_REG_ACCEL_X, X),
  76         BMA220_ACCEL_CHANNEL(1, BMA220_REG_ACCEL_Y, Y),
  77         BMA220_ACCEL_CHANNEL(2, BMA220_REG_ACCEL_Z, Z),
  78         IIO_CHAN_SOFT_TIMESTAMP(3),
  79 };
  80
  81 static inline int bma220_read_reg(struct spi_device *spi, u8 reg)
  82 {
  83         return spi_w8r8(spi, reg | BMA220_READ_MASK);
  84 }
  85
  86 static const unsigned long bma220_accel_scan_masks[] = {
  87         BIT(AXIS_X) | BIT(AXIS_Y) | BIT(AXIS_Z),
  88         0
  89 };
  90
  91 static irqreturn_t bma220_trigger_handler(int irq, void *p)
  92 {
  93         int ret;
  94         struct iio_poll_func *pf = p;
  95         struct iio_dev *indio_dev = pf->indio_dev;
  96         struct bma220_data *data = iio_priv(indio_dev);
  97         struct spi_device *spi = data->spi_device;
  98
  99         mutex_lock(&data->lock);
 100         data->tx_buf[0] = BMA220_REG_ACCEL_X | BMA220_READ_MASK;
 101         ret = spi_write_then_read(spi, data->tx_buf, 1, &data->scan.chans,
 102                                   ARRAY_SIZE(bma220_channels) - 1);
 103         if (ret < 0)
 104                 goto err;
 105
 106         iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 107                                            pf->timestamp);
 108 err:
 109         mutex_unlock(&data->lock);
 110         iio_trigger_notify_done(indio_dev->trig);
 111
 112         return IRQ_HANDLED;
 113 }
 114
 115 static int bma220_read_raw(struct iio_dev *indio_dev,
 116                            struct iio_chan_spec const *chan,
 117                            int *val, int *val2, long mask)
 118 {
 119         int ret;
 120         u8 range_idx;
 121         struct bma220_data *data = iio_priv(indio_dev);
 122
 123         switch (mask) {
 124         case IIO_CHAN_INFO_RAW:
 125                 ret = bma220_read_reg(data->spi_device, chan->address);
 126                 if (ret < 0)
 127                         return -EINVAL;
 128                 *val = sign_extend32(ret >> chan->scan_type.shift,
 129                                      chan->scan_type.realbits - 1);
 130                 return IIO_VAL_INT;
 131         case IIO_CHAN_INFO_SCALE:
 132                 ret = bma220_read_reg(data->spi_device, BMA220_REG_RANGE);
 133                 if (ret < 0)
 134                         return ret;
 135                 range_idx = ret & BMA220_RANGE_MASK;
 136                 *val = bma220_scale_table[range_idx][0];
 137                 *val2 = bma220_scale_table[range_idx][1];
 138                 return IIO_VAL_INT_PLUS_MICRO;
 139         }
 140
 141         return -EINVAL;
 142 }
 143
 144 static int bma220_write_raw(struct iio_dev *indio_dev,
 145                             struct iio_chan_spec const *chan,
 146                             int val, int val2, long mask)
 147 {
 148         int i;
 149         int ret;
 150         int index = -1;
 151         struct bma220_data *data = iio_priv(indio_dev);
 152
 153         switch (mask) {
 154         case IIO_CHAN_INFO_SCALE:
 155                 for (i = 0; i < ARRAY_SIZE(bma220_scale_table); i++)
 156                         if (val == bma220_scale_table[i][0] &&
 157                             val2 == bma220_scale_table[i][1]) {
 158                                 index = i;
 159                                 break;
 160                         }
 161                 if (index < 0)
 162                         return -EINVAL;
 163
 164                 mutex_lock(&data->lock);
 165                 data->tx_buf[0] = BMA220_REG_RANGE;
 166                 data->tx_buf[1] = index;
 167                 ret = spi_write(data->spi_device, data->tx_buf,
 168                                 sizeof(data->tx_buf));
 169                 if (ret < 0)
 170                         dev_err(&data->spi_device->dev,
 171                                 "failed to set measurement range\n");
 172                 mutex_unlock(&data->lock);
 173
 174                 return 0;
 175         }
 176
 177         return -EINVAL;
 178 }
 179
 180 static int bma220_read_avail(struct iio_dev *indio_dev,
 181                              struct iio_chan_spec const *chan,
 182                              const int **vals, int *type, int *length,
 183                              long mask)
 184 {
 185         switch (mask) {
 186         case IIO_CHAN_INFO_SCALE:
 187                 *vals = (int *)bma220_scale_table;
 188                 *type = IIO_VAL_INT_PLUS_MICRO;
 189                 *length = ARRAY_SIZE(bma220_scale_table) * 2;
 190                 return IIO_AVAIL_LIST;
 191         default:
 192                 return -EINVAL;
 193         }
 194 }
 195
 196 static const struct iio_info bma220_info = {
 197         .read_raw               = bma220_read_raw,
 198         .write_raw              = bma220_write_raw,
 199         .read_avail             = bma220_read_avail,
 200 };
 201
 202 static int bma220_init(struct spi_device *spi)
 203 {
 204         int ret;
 205
 206         ret = bma220_read_reg(spi, BMA220_REG_ID);
 207         if (ret != BMA220_CHIP_ID)
 208                 return -ENODEV;
 209
 210         /* Make sure the chip is powered on */
 211         ret = bma220_read_reg(spi, BMA220_REG_SUSPEND);
 212         if (ret == BMA220_SUSPEND_WAKE)
 213                 ret = bma220_read_reg(spi, BMA220_REG_SUSPEND);
 214         if (ret < 0)
 215                 return ret;
 216         if (ret == BMA220_SUSPEND_WAKE)
 217                 return -EBUSY;
 218
 219         return 0;
 220 }
 221
 222 static int bma220_power(struct spi_device *spi, bool up)
 223 {
 224         int i, ret;
 225
 226         /**
 227          * The chip can be suspended/woken up by a simple register read.
 228          * So, we need up to 2 register reads of the suspend register
 229          * to make sure that the device is in the desired state.
 230          */
 231         for (i = 0; i < 2; i++) {
 232                 ret = bma220_read_reg(spi, BMA220_REG_SUSPEND);
 233                 if (ret < 0)
 234                         return ret;
 235
 236                 if (up && ret == BMA220_SUSPEND_SLEEP)
 237                         return 0;
 238
 239                 if (!up && ret == BMA220_SUSPEND_WAKE)
 240                         return 0;
 241         }
 242
 243         return -EBUSY;
 244 }
 245
 246 static void bma220_deinit(void *spi)
 247 {
 248         bma220_power(spi, false);
 249 }
 250
 251 static int bma220_probe(struct spi_device *spi)
 252 {
 253         int ret;
 254         struct iio_dev *indio_dev;
 255         struct bma220_data *data;
 256
 257         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
 258         if (!indio_dev) {
 259                 dev_err(&spi->dev, "iio allocation failed!\n");
 260                 return -ENOMEM;
 261         }
 262
 263         data = iio_priv(indio_dev);
 264         data->spi_device = spi;
 265         mutex_init(&data->lock);
 266
 267         indio_dev->info = &bma220_info;
 268         indio_dev->name = BMA220_DEVICE_NAME;
 269         indio_dev->modes = INDIO_DIRECT_MODE;
 270         indio_dev->channels = bma220_channels;
 271         indio_dev->num_channels = ARRAY_SIZE(bma220_channels);
 272         indio_dev->available_scan_masks = bma220_accel_scan_masks;
 273
 274         ret = bma220_init(data->spi_device);
 275         if (ret)
 276                 return ret;
 277
 278         ret = devm_add_action_or_reset(&spi->dev, bma220_deinit, spi);
 279         if (ret)
 280                 return ret;
 281
 282         ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev,
 283                                               iio_pollfunc_store_time,
 284                                               bma220_trigger_handler, NULL);
 285         if (ret < 0) {
 286                 dev_err(&spi->dev, "iio triggered buffer setup failed\n");
 287                 return ret;
 288         }
 289
 290         return devm_iio_device_register(&spi->dev, indio_dev);
 291 }
 292
 293 static int bma220_suspend(struct device *dev)
 294 {
 295         struct spi_device *spi = to_spi_device(dev);
 296
 297         return bma220_power(spi, false);
 298 }
 299
 300 static int bma220_resume(struct device *dev)
 301 {
 302         struct spi_device *spi = to_spi_device(dev);
 303
 304         return bma220_power(spi, true);
 305 }
 306 static DEFINE_SIMPLE_DEV_PM_OPS(bma220_pm_ops, bma220_suspend, bma220_resume);
 307
 308 static const struct spi_device_id bma220_spi_id[] = {
 309         {"bma220", 0},
 310         {}
 311 };
 312
 313 static const struct acpi_device_id bma220_acpi_id[] = {
 314         {"BMA0220", 0},
 315         {}
 316 };
 317 MODULE_DEVICE_TABLE(spi, bma220_spi_id);
 318
 319 static struct spi_driver bma220_driver = {
 320         .driver = {
 321                 .name = "bma220_spi",
 322                 .pm = pm_sleep_ptr(&bma220_pm_ops),
 323                 .acpi_match_table = bma220_acpi_id,
 324         },
 325         .probe =            bma220_probe,
 326         .id_table =         bma220_spi_id,
 327 };
 328 module_spi_driver(bma220_driver);
 329
 330 MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>");
 331 MODULE_DESCRIPTION("BMA220 acceleration sensor driver");
 332 MODULE_LICENSE("GPL v2");