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