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/spi/spi.h>
  13
  14 #include <linux/iio/buffer.h>
  15 #include <linux/iio/iio.h>
  16 #include <linux/iio/sysfs.h>
  17 #include <linux/iio/trigger_consumer.h>
  18 #include <linux/iio/triggered_buffer.h>
  19
  20 #define BMA220_REG_ID                           0x00
  21 #define BMA220_REG_ACCEL_X                      0x02
  22 #define BMA220_REG_ACCEL_Y                      0x03
  23 #define BMA220_REG_ACCEL_Z                      0x04
  24 #define BMA220_REG_RANGE                        0x11
  25 #define BMA220_REG_SUSPEND                      0x18
  26
  27 #define BMA220_CHIP_ID                          0xDD
  28 #define BMA220_READ_MASK                        BIT(7)
  29 #define BMA220_RANGE_MASK                       GENMASK(1, 0)
  30 #define BMA220_DATA_SHIFT                       2
  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 = BMA220_DATA_SHIFT,                             \
  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         s8 buffer[16]; /* 3x8-bit channels + 5x8 padding + 8x8 timestamp */
  67         u8 tx_buf[2] ____cacheline_aligned;
  68 };
  69
  70 static const struct iio_chan_spec bma220_channels[] = {
  71         BMA220_ACCEL_CHANNEL(0, BMA220_REG_ACCEL_X, X),
  72         BMA220_ACCEL_CHANNEL(1, BMA220_REG_ACCEL_Y, Y),
  73         BMA220_ACCEL_CHANNEL(2, BMA220_REG_ACCEL_Z, Z),
  74         IIO_CHAN_SOFT_TIMESTAMP(3),
  75 };
  76
  77 static inline int bma220_read_reg(struct spi_device *spi, u8 reg)
  78 {
  79         return spi_w8r8(spi, reg | BMA220_READ_MASK);
  80 }
  81
  82 static const unsigned long bma220_accel_scan_masks[] = {
  83         BIT(AXIS_X) | BIT(AXIS_Y) | BIT(AXIS_Z),
  84         0
  85 };
  86
  87 static irqreturn_t bma220_trigger_handler(int irq, void *p)
  88 {
  89         int ret;
  90         struct iio_poll_func *pf = p;
  91         struct iio_dev *indio_dev = pf->indio_dev;
  92         struct bma220_data *data = iio_priv(indio_dev);
  93         struct spi_device *spi = data->spi_device;
  94
  95         mutex_lock(&data->lock);
  96         data->tx_buf[0] = BMA220_REG_ACCEL_X | BMA220_READ_MASK;
  97         ret = spi_write_then_read(spi, data->tx_buf, 1, data->buffer,
  98                                   ARRAY_SIZE(bma220_channels) - 1);
  99         if (ret < 0)
 100                 goto err;
 101
 102         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
 103                                            pf->timestamp);
 104 err:
 105         mutex_unlock(&data->lock);
 106         iio_trigger_notify_done(indio_dev->trig);
 107
 108         return IRQ_HANDLED;
 109 }
 110
 111 static int bma220_read_raw(struct iio_dev *indio_dev,
 112                            struct iio_chan_spec const *chan,
 113                            int *val, int *val2, long mask)
 114 {
 115         int ret;
 116         u8 range_idx;
 117         struct bma220_data *data = iio_priv(indio_dev);
 118
 119         switch (mask) {
 120         case IIO_CHAN_INFO_RAW:
 121                 ret = bma220_read_reg(data->spi_device, chan->address);
 122                 if (ret < 0)
 123                         return -EINVAL;
 124                 *val = sign_extend32(ret >> BMA220_DATA_SHIFT, 5);
 125                 return IIO_VAL_INT;
 126         case IIO_CHAN_INFO_SCALE:
 127                 ret = bma220_read_reg(data->spi_device, BMA220_REG_RANGE);
 128                 if (ret < 0)
 129                         return ret;
 130                 range_idx = ret & BMA220_RANGE_MASK;
 131                 *val = bma220_scale_table[range_idx][0];
 132                 *val2 = bma220_scale_table[range_idx][1];
 133                 return IIO_VAL_INT_PLUS_MICRO;
 134         }
 135
 136         return -EINVAL;
 137 }
 138
 139 static int bma220_write_raw(struct iio_dev *indio_dev,
 140                             struct iio_chan_spec const *chan,
 141                             int val, int val2, long mask)
 142 {
 143         int i;
 144         int ret;
 145         int index = -1;
 146         struct bma220_data *data = iio_priv(indio_dev);
 147
 148         switch (mask) {
 149         case IIO_CHAN_INFO_SCALE:
 150                 for (i = 0; i < ARRAY_SIZE(bma220_scale_table); i++)
 151                         if (val == bma220_scale_table[i][0] &&
 152                             val2 == bma220_scale_table[i][1]) {
 153                                 index = i;
 154                                 break;
 155                         }
 156                 if (index < 0)
 157                         return -EINVAL;
 158
 159                 mutex_lock(&data->lock);
 160                 data->tx_buf[0] = BMA220_REG_RANGE;
 161                 data->tx_buf[1] = index;
 162                 ret = spi_write(data->spi_device, data->tx_buf,
 163                                 sizeof(data->tx_buf));
 164                 if (ret < 0)
 165                         dev_err(&data->spi_device->dev,
 166                                 "failed to set measurement range\n");
 167                 mutex_unlock(&data->lock);
 168
 169                 return 0;
 170         }
 171
 172         return -EINVAL;
 173 }
 174
 175 static int bma220_read_avail(struct iio_dev *indio_dev,
 176                              struct iio_chan_spec const *chan,
 177                              const int **vals, int *type, int *length,
 178                              long mask)
 179 {
 180         switch (mask) {
 181         case IIO_CHAN_INFO_SCALE:
 182                 *vals = (int *)bma220_scale_table;
 183                 *type = IIO_VAL_INT_PLUS_MICRO;
 184                 *length = ARRAY_SIZE(bma220_scale_table) * 2;
 185                 return IIO_AVAIL_LIST;
 186         default:
 187                 return -EINVAL;
 188         }
 189 }
 190
 191 static const struct iio_info bma220_info = {
 192         .read_raw               = bma220_read_raw,
 193         .write_raw              = bma220_write_raw,
 194         .read_avail             = bma220_read_avail,
 195 };
 196
 197 static int bma220_init(struct spi_device *spi)
 198 {
 199         int ret;
 200
 201         ret = bma220_read_reg(spi, BMA220_REG_ID);
 202         if (ret != BMA220_CHIP_ID)
 203                 return -ENODEV;
 204
 205         /* Make sure the chip is powered on */
 206         ret = bma220_read_reg(spi, BMA220_REG_SUSPEND);
 207         if (ret == BMA220_SUSPEND_WAKE)
 208                 ret = bma220_read_reg(spi, BMA220_REG_SUSPEND);
 209         if (ret < 0)
 210                 return ret;
 211         if (ret == BMA220_SUSPEND_WAKE)
 212                 return -EBUSY;
 213
 214         return 0;
 215 }
 216
 217 static int bma220_deinit(struct spi_device *spi)
 218 {
 219         int ret;
 220
 221         /* Make sure the chip is powered off */
 222         ret = bma220_read_reg(spi, BMA220_REG_SUSPEND);
 223         if (ret == BMA220_SUSPEND_SLEEP)
 224                 ret = bma220_read_reg(spi, BMA220_REG_SUSPEND);
 225         if (ret < 0)
 226                 return ret;
 227         if (ret == BMA220_SUSPEND_SLEEP)
 228                 return -EBUSY;
 229
 230         return 0;
 231 }
 232
 233 static int bma220_probe(struct spi_device *spi)
 234 {
 235         int ret;
 236         struct iio_dev *indio_dev;
 237         struct bma220_data *data;
 238
 239         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
 240         if (!indio_dev) {
 241                 dev_err(&spi->dev, "iio allocation failed!\n");
 242                 return -ENOMEM;
 243         }
 244
 245         data = iio_priv(indio_dev);
 246         data->spi_device = spi;
 247         spi_set_drvdata(spi, indio_dev);
 248         mutex_init(&data->lock);
 249
 250         indio_dev->info = &bma220_info;
 251         indio_dev->name = BMA220_DEVICE_NAME;
 252         indio_dev->modes = INDIO_DIRECT_MODE;
 253         indio_dev->channels = bma220_channels;
 254         indio_dev->num_channels = ARRAY_SIZE(bma220_channels);
 255         indio_dev->available_scan_masks = bma220_accel_scan_masks;
 256
 257         ret = bma220_init(data->spi_device);
 258         if (ret)
 259                 return ret;
 260
 261         ret = iio_triggered_buffer_setup(indio_dev, iio_pollfunc_store_time,
 262                                          bma220_trigger_handler, NULL);
 263         if (ret < 0) {
 264                 dev_err(&spi->dev, "iio triggered buffer setup failed\n");
 265                 goto err_suspend;
 266         }
 267
 268         ret = iio_device_register(indio_dev);
 269         if (ret < 0) {
 270                 dev_err(&spi->dev, "iio_device_register failed\n");
 271                 iio_triggered_buffer_cleanup(indio_dev);
 272                 goto err_suspend;
 273         }
 274
 275         return 0;
 276
 277 err_suspend:
 278         return bma220_deinit(spi);
 279 }
 280
 281 static int bma220_remove(struct spi_device *spi)
 282 {
 283         struct iio_dev *indio_dev = spi_get_drvdata(spi);
 284
 285         iio_device_unregister(indio_dev);
 286         iio_triggered_buffer_cleanup(indio_dev);
 287
 288         return bma220_deinit(spi);
 289 }
 290
 291 static __maybe_unused int bma220_suspend(struct device *dev)
 292 {
 293         struct bma220_data *data = iio_priv(dev_get_drvdata(dev));
 294
 295         /* The chip can be suspended/woken up by a simple register read. */
 296         return bma220_read_reg(data->spi_device, BMA220_REG_SUSPEND);
 297 }
 298
 299 static __maybe_unused int bma220_resume(struct device *dev)
 300 {
 301         struct bma220_data *data = iio_priv(dev_get_drvdata(dev));
 302
 303         return bma220_read_reg(data->spi_device, BMA220_REG_SUSPEND);
 304 }
 305 static SIMPLE_DEV_PM_OPS(bma220_pm_ops, bma220_suspend, bma220_resume);
 306
 307 static const struct spi_device_id bma220_spi_id[] = {
 308         {"bma220", 0},
 309         {}
 310 };
 311
 312 static const struct acpi_device_id bma220_acpi_id[] = {
 313         {"BMA0220", 0},
 314         {}
 315 };
 316 MODULE_DEVICE_TABLE(spi, bma220_spi_id);
 317
 318 static struct spi_driver bma220_driver = {
 319         .driver = {
 320                 .name = "bma220_spi",
 321                 .pm = &bma220_pm_ops,
 322                 .acpi_match_table = bma220_acpi_id,
 323         },
 324         .probe =            bma220_probe,
 325         .remove =           bma220_remove,
 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");