iio/accel/stk8ba50.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Sensortek STK8BA50 3-Axis Accelerometer
0004  *
0005  * Copyright (c) 2015, Intel Corporation.
0006  *
0007  * STK8BA50 7-bit I2C address: 0x18.
0008  */
0009
0010 #include <linux/acpi.h>
0011 #include <linux/i2c.h>
0012 #include <linux/interrupt.h>
0013 #include <linux/kernel.h>
0014 #include <linux/module.h>
0015 #include <linux/iio/buffer.h>
0016 #include <linux/iio/iio.h>
0017 #include <linux/iio/sysfs.h>
0018 #include <linux/iio/trigger.h>
0019 #include <linux/iio/triggered_buffer.h>
0020 #include <linux/iio/trigger_consumer.h>
0021
0022 #define STK8BA50_REG_XOUT           0x02
0023 #define STK8BA50_REG_YOUT           0x04
0024 #define STK8BA50_REG_ZOUT           0x06
0025 #define STK8BA50_REG_RANGE          0x0F
0026 #define STK8BA50_REG_BWSEL          0x10
0027 #define STK8BA50_REG_POWMODE            0x11
0028 #define STK8BA50_REG_SWRST          0x14
0029 #define STK8BA50_REG_INTEN2         0x17
0030 #define STK8BA50_REG_INTMAP2            0x1A
0031
0032 #define STK8BA50_MODE_NORMAL            0
0033 #define STK8BA50_MODE_SUSPEND           1
0034 #define STK8BA50_MODE_POWERBIT          BIT(7)
0035 #define STK8BA50_DATA_SHIFT         6
0036 #define STK8BA50_RESET_CMD          0xB6
0037 #define STK8BA50_SR_1792HZ_IDX          7
0038 #define STK8BA50_DREADY_INT_MASK        0x10
0039 #define STK8BA50_DREADY_INT_MAP         0x81
0040 #define STK8BA50_ALL_CHANNEL_MASK       7
0041 #define STK8BA50_ALL_CHANNEL_SIZE       6
0042
0043 #define STK8BA50_DRIVER_NAME            "stk8ba50"
0044 #define STK8BA50_IRQ_NAME           "stk8ba50_event"
0045
0046 #define STK8BA50_SCALE_AVAIL            "0.0384 0.0767 0.1534 0.3069"
0047
0048 /*
0049  * The accelerometer has four measurement ranges:
0050  * +/-2g; +/-4g; +/-8g; +/-16g
0051  *
0052  * Acceleration values are 10-bit, 2's complement.
0053  * Scales are calculated as following:
0054  *
0055  * scale1 = (2 + 2) * 9.81 / (2^10 - 1)   = 0.0384
0056  * scale2 = (4 + 4) * 9.81 / (2^10 - 1)   = 0.0767
0057  * etc.
0058  *
0059  * Scales are stored in this format:
0060  * { <register value>, <scale value> }
0061  *
0062  * Locally, the range is stored as a table index.
0063  */
0064 static const struct {
0065     u8 reg_val;
0066     u32 scale_val;
0067 } stk8ba50_scale_table[] = {
0068     {3, 38400}, {5, 76700}, {8, 153400}, {12, 306900}
0069 };
0070
0071 /* Sample rates are stored as { <register value>, <Hz value> } */
0072 static const struct {
0073     u8 reg_val;
0074     u16 samp_freq;
0075 } stk8ba50_samp_freq_table[] = {
0076     {0x08, 14},  {0x09, 25},  {0x0A, 56},  {0x0B, 112},
0077     {0x0C, 224}, {0x0D, 448}, {0x0E, 896}, {0x0F, 1792}
0078 };
0079
0080 /* Used to map scan mask bits to their corresponding channel register. */
0081 static const int stk8ba50_channel_table[] = {
0082     STK8BA50_REG_XOUT,
0083     STK8BA50_REG_YOUT,
0084     STK8BA50_REG_ZOUT
0085 };
0086
0087 struct stk8ba50_data {
0088     struct i2c_client *client;
0089     struct mutex lock;
0090     int range;
0091     u8 sample_rate_idx;
0092     struct iio_trigger *dready_trig;
0093     bool dready_trigger_on;
0094     /* Ensure timestamp is naturally aligned */
0095     struct {
0096         s16 chans[3];
0097         s64 timetamp __aligned(8);
0098     } scan;
0099 };
0100
0101 #define STK8BA50_ACCEL_CHANNEL(index, reg, axis) {          \
0102     .type = IIO_ACCEL,                      \
0103     .address = reg,                         \
0104     .modified = 1,                          \
0105     .channel2 = IIO_MOD_##axis,                 \
0106     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
0107     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),       \
0108                     BIT(IIO_CHAN_INFO_SAMP_FREQ),   \
0109     .scan_index = index,                        \
0110     .scan_type = {                          \
0111         .sign = 's',                        \
0112         .realbits = 10,                     \
0113         .storagebits = 16,                  \
0114         .shift = STK8BA50_DATA_SHIFT,               \
0115         .endianness = IIO_CPU,                  \
0116     },                              \
0117 }
0118
0119 static const struct iio_chan_spec stk8ba50_channels[] = {
0120     STK8BA50_ACCEL_CHANNEL(0, STK8BA50_REG_XOUT, X),
0121     STK8BA50_ACCEL_CHANNEL(1, STK8BA50_REG_YOUT, Y),
0122     STK8BA50_ACCEL_CHANNEL(2, STK8BA50_REG_ZOUT, Z),
0123     IIO_CHAN_SOFT_TIMESTAMP(3),
0124 };
0125
0126 static IIO_CONST_ATTR(in_accel_scale_available, STK8BA50_SCALE_AVAIL);
0127
0128 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("14 25 56 112 224 448 896 1792");
0129
0130 static struct attribute *stk8ba50_attributes[] = {
0131     &iio_const_attr_in_accel_scale_available.dev_attr.attr,
0132     &iio_const_attr_sampling_frequency_available.dev_attr.attr,
0133     NULL,
0134 };
0135
0136 static const struct attribute_group stk8ba50_attribute_group = {
0137     .attrs = stk8ba50_attributes
0138 };
0139
0140 static int stk8ba50_read_accel(struct stk8ba50_data *data, u8 reg)
0141 {
0142     int ret;
0143     struct i2c_client *client = data->client;
0144
0145     ret = i2c_smbus_read_word_data(client, reg);
0146     if (ret < 0) {
0147         dev_err(&client->dev, "register read failed\n");
0148         return ret;
0149     }
0150
0151     return ret;
0152 }
0153
0154 static int stk8ba50_data_rdy_trigger_set_state(struct iio_trigger *trig,
0155                            bool state)
0156 {
0157     struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
0158     struct stk8ba50_data *data = iio_priv(indio_dev);
0159     int ret;
0160
0161     if (state)
0162         ret = i2c_smbus_write_byte_data(data->client,
0163             STK8BA50_REG_INTEN2, STK8BA50_DREADY_INT_MASK);
0164     else
0165         ret = i2c_smbus_write_byte_data(data->client,
0166             STK8BA50_REG_INTEN2, 0x00);
0167
0168     if (ret < 0)
0169         dev_err(&data->client->dev, "failed to set trigger state\n");
0170     else
0171         data->dready_trigger_on = state;
0172
0173     return ret;
0174 }
0175
0176 static const struct iio_trigger_ops stk8ba50_trigger_ops = {
0177     .set_trigger_state = stk8ba50_data_rdy_trigger_set_state,
0178 };
0179
0180 static int stk8ba50_set_power(struct stk8ba50_data *data, bool mode)
0181 {
0182     int ret;
0183     u8 masked_reg;
0184     struct i2c_client *client = data->client;
0185
0186     ret = i2c_smbus_read_byte_data(client, STK8BA50_REG_POWMODE);
0187     if (ret < 0)
0188         goto exit_err;
0189
0190     if (mode)
0191         masked_reg = ret | STK8BA50_MODE_POWERBIT;
0192     else
0193         masked_reg = ret & (~STK8BA50_MODE_POWERBIT);
0194
0195     ret = i2c_smbus_write_byte_data(client, STK8BA50_REG_POWMODE,
0196                     masked_reg);
0197     if (ret < 0)
0198         goto exit_err;
0199
0200     return ret;
0201
0202 exit_err:
0203     dev_err(&client->dev, "failed to change sensor mode\n");
0204     return ret;
0205 }
0206
0207 static int stk8ba50_read_raw(struct iio_dev *indio_dev,
0208                  struct iio_chan_spec const *chan,
0209                  int *val, int *val2, long mask)
0210 {
0211     struct stk8ba50_data *data = iio_priv(indio_dev);
0212     int ret;
0213
0214     switch (mask) {
0215     case IIO_CHAN_INFO_RAW:
0216         if (iio_buffer_enabled(indio_dev))
0217             return -EBUSY;
0218         mutex_lock(&data->lock);
0219         ret = stk8ba50_set_power(data, STK8BA50_MODE_NORMAL);
0220         if (ret < 0) {
0221             mutex_unlock(&data->lock);
0222             return -EINVAL;
0223         }
0224         ret = stk8ba50_read_accel(data, chan->address);
0225         if (ret < 0) {
0226             stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND);
0227             mutex_unlock(&data->lock);
0228             return -EINVAL;
0229         }
0230         *val = sign_extend32(ret >> chan->scan_type.shift,
0231                      chan->scan_type.realbits - 1);
0232         stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND);
0233         mutex_unlock(&data->lock);
0234         return IIO_VAL_INT;
0235     case IIO_CHAN_INFO_SCALE:
0236         *val = 0;
0237         *val2 = stk8ba50_scale_table[data->range].scale_val;
0238         return IIO_VAL_INT_PLUS_MICRO;
0239     case IIO_CHAN_INFO_SAMP_FREQ:
0240         *val = stk8ba50_samp_freq_table
0241                 [data->sample_rate_idx].samp_freq;
0242         *val2 = 0;
0243         return IIO_VAL_INT;
0244     }
0245
0246     return -EINVAL;
0247 }
0248
0249 static int stk8ba50_write_raw(struct iio_dev *indio_dev,
0250                   struct iio_chan_spec const *chan,
0251                   int val, int val2, long mask)
0252 {
0253     int ret;
0254     int i;
0255     int index = -1;
0256     struct stk8ba50_data *data = iio_priv(indio_dev);
0257
0258     switch (mask) {
0259     case IIO_CHAN_INFO_SCALE:
0260         if (val != 0)
0261             return -EINVAL;
0262
0263         for (i = 0; i < ARRAY_SIZE(stk8ba50_scale_table); i++)
0264             if (val2 == stk8ba50_scale_table[i].scale_val) {
0265                 index = i;
0266                 break;
0267             }
0268         if (index < 0)
0269             return -EINVAL;
0270
0271         ret = i2c_smbus_write_byte_data(data->client,
0272                 STK8BA50_REG_RANGE,
0273                 stk8ba50_scale_table[index].reg_val);
0274         if (ret < 0)
0275             dev_err(&data->client->dev,
0276                     "failed to set measurement range\n");
0277         else
0278             data->range = index;
0279
0280         return ret;
0281     case IIO_CHAN_INFO_SAMP_FREQ:
0282         for (i = 0; i < ARRAY_SIZE(stk8ba50_samp_freq_table); i++)
0283             if (val == stk8ba50_samp_freq_table[i].samp_freq) {
0284                 index = i;
0285                 break;
0286             }
0287         if (index < 0)
0288             return -EINVAL;
0289
0290         ret = i2c_smbus_write_byte_data(data->client,
0291                 STK8BA50_REG_BWSEL,
0292                 stk8ba50_samp_freq_table[index].reg_val);
0293         if (ret < 0)
0294             dev_err(&data->client->dev,
0295                     "failed to set sampling rate\n");
0296         else
0297             data->sample_rate_idx = index;
0298
0299         return ret;
0300     }
0301
0302     return -EINVAL;
0303 }
0304
0305 static const struct iio_info stk8ba50_info = {
0306     .read_raw       = stk8ba50_read_raw,
0307     .write_raw      = stk8ba50_write_raw,
0308     .attrs          = &stk8ba50_attribute_group,
0309 };
0310
0311 static irqreturn_t stk8ba50_trigger_handler(int irq, void *p)
0312 {
0313     struct iio_poll_func *pf = p;
0314     struct iio_dev *indio_dev = pf->indio_dev;
0315     struct stk8ba50_data *data = iio_priv(indio_dev);
0316     int bit, ret, i = 0;
0317
0318     mutex_lock(&data->lock);
0319     /*
0320      * Do a bulk read if all channels are requested,
0321      * from 0x02 (XOUT1) to 0x07 (ZOUT2)
0322      */
0323     if (*(indio_dev->active_scan_mask) == STK8BA50_ALL_CHANNEL_MASK) {
0324         ret = i2c_smbus_read_i2c_block_data(data->client,
0325                             STK8BA50_REG_XOUT,
0326                             STK8BA50_ALL_CHANNEL_SIZE,
0327                             (u8 *)data->scan.chans);
0328         if (ret < STK8BA50_ALL_CHANNEL_SIZE) {
0329             dev_err(&data->client->dev, "register read failed\n");
0330             goto err;
0331         }
0332     } else {
0333         for_each_set_bit(bit, indio_dev->active_scan_mask,
0334                  indio_dev->masklength) {
0335             ret = stk8ba50_read_accel(data,
0336                           stk8ba50_channel_table[bit]);
0337             if (ret < 0)
0338                 goto err;
0339
0340             data->scan.chans[i++] = ret;
0341         }
0342     }
0343     iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
0344                        pf->timestamp);
0345 err:
0346     mutex_unlock(&data->lock);
0347     iio_trigger_notify_done(indio_dev->trig);
0348
0349     return IRQ_HANDLED;
0350 }
0351
0352 static irqreturn_t stk8ba50_data_rdy_trig_poll(int irq, void *private)
0353 {
0354     struct iio_dev *indio_dev = private;
0355     struct stk8ba50_data *data = iio_priv(indio_dev);
0356
0357     if (data->dready_trigger_on)
0358         iio_trigger_poll(data->dready_trig);
0359
0360     return IRQ_HANDLED;
0361 }
0362
0363 static int stk8ba50_buffer_preenable(struct iio_dev *indio_dev)
0364 {
0365     struct stk8ba50_data *data = iio_priv(indio_dev);
0366
0367     return stk8ba50_set_power(data, STK8BA50_MODE_NORMAL);
0368 }
0369
0370 static int stk8ba50_buffer_postdisable(struct iio_dev *indio_dev)
0371 {
0372     struct stk8ba50_data *data = iio_priv(indio_dev);
0373
0374     return stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND);
0375 }
0376
0377 static const struct iio_buffer_setup_ops stk8ba50_buffer_setup_ops = {
0378     .preenable   = stk8ba50_buffer_preenable,
0379     .postdisable = stk8ba50_buffer_postdisable,
0380 };
0381
0382 static int stk8ba50_probe(struct i2c_client *client,
0383               const struct i2c_device_id *id)
0384 {
0385     int ret;
0386     struct iio_dev *indio_dev;
0387     struct stk8ba50_data *data;
0388
0389     indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
0390     if (!indio_dev) {
0391         dev_err(&client->dev, "iio allocation failed!\n");
0392         return -ENOMEM;
0393     }
0394
0395     data = iio_priv(indio_dev);
0396     data->client = client;
0397     i2c_set_clientdata(client, indio_dev);
0398     mutex_init(&data->lock);
0399
0400     indio_dev->info = &stk8ba50_info;
0401     indio_dev->name = STK8BA50_DRIVER_NAME;
0402     indio_dev->modes = INDIO_DIRECT_MODE;
0403     indio_dev->channels = stk8ba50_channels;
0404     indio_dev->num_channels = ARRAY_SIZE(stk8ba50_channels);
0405
0406     /* Reset all registers on startup */
0407     ret = i2c_smbus_write_byte_data(client,
0408             STK8BA50_REG_SWRST, STK8BA50_RESET_CMD);
0409     if (ret < 0) {
0410         dev_err(&client->dev, "failed to reset sensor\n");
0411         goto err_power_off;
0412     }
0413
0414     /* The default range is +/-2g */
0415     data->range = 0;
0416
0417     /* The default sampling rate is 1792 Hz (maximum) */
0418     data->sample_rate_idx = STK8BA50_SR_1792HZ_IDX;
0419
0420     /* Set up interrupts */
0421     ret = i2c_smbus_write_byte_data(client,
0422             STK8BA50_REG_INTEN2, STK8BA50_DREADY_INT_MASK);
0423     if (ret < 0) {
0424         dev_err(&client->dev, "failed to set up interrupts\n");
0425         goto err_power_off;
0426     }
0427     ret = i2c_smbus_write_byte_data(client,
0428             STK8BA50_REG_INTMAP2, STK8BA50_DREADY_INT_MAP);
0429     if (ret < 0) {
0430         dev_err(&client->dev, "failed to set up interrupts\n");
0431         goto err_power_off;
0432     }
0433
0434     if (client->irq > 0) {
0435         ret = devm_request_threaded_irq(&client->dev, client->irq,
0436                         stk8ba50_data_rdy_trig_poll,
0437                         NULL,
0438                         IRQF_TRIGGER_RISING |
0439                         IRQF_ONESHOT,
0440                         STK8BA50_IRQ_NAME,
0441                         indio_dev);
0442         if (ret < 0) {
0443             dev_err(&client->dev, "request irq %d failed\n",
0444                 client->irq);
0445             goto err_power_off;
0446         }
0447
0448         data->dready_trig = devm_iio_trigger_alloc(&client->dev,
0449                                "%s-dev%d",
0450                                indio_dev->name,
0451                                iio_device_id(indio_dev));
0452         if (!data->dready_trig) {
0453             ret = -ENOMEM;
0454             goto err_power_off;
0455         }
0456
0457         data->dready_trig->ops = &stk8ba50_trigger_ops;
0458         iio_trigger_set_drvdata(data->dready_trig, indio_dev);
0459         ret = iio_trigger_register(data->dready_trig);
0460         if (ret) {
0461             dev_err(&client->dev, "iio trigger register failed\n");
0462             goto err_power_off;
0463         }
0464     }
0465
0466     ret = iio_triggered_buffer_setup(indio_dev,
0467                      iio_pollfunc_store_time,
0468                      stk8ba50_trigger_handler,
0469                      &stk8ba50_buffer_setup_ops);
0470     if (ret < 0) {
0471         dev_err(&client->dev, "iio triggered buffer setup failed\n");
0472         goto err_trigger_unregister;
0473     }
0474
0475     ret = iio_device_register(indio_dev);
0476     if (ret < 0) {
0477         dev_err(&client->dev, "device_register failed\n");
0478         goto err_buffer_cleanup;
0479     }
0480
0481     return ret;
0482
0483 err_buffer_cleanup:
0484     iio_triggered_buffer_cleanup(indio_dev);
0485 err_trigger_unregister:
0486     if (data->dready_trig)
0487         iio_trigger_unregister(data->dready_trig);
0488 err_power_off:
0489     stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND);
0490     return ret;
0491 }
0492
0493 static int stk8ba50_remove(struct i2c_client *client)
0494 {
0495     struct iio_dev *indio_dev = i2c_get_clientdata(client);
0496     struct stk8ba50_data *data = iio_priv(indio_dev);
0497
0498     iio_device_unregister(indio_dev);
0499     iio_triggered_buffer_cleanup(indio_dev);
0500
0501     if (data->dready_trig)
0502         iio_trigger_unregister(data->dready_trig);
0503
0504     stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND);
0505
0506     return 0;
0507 }
0508
0509 static int stk8ba50_suspend(struct device *dev)
0510 {
0511     struct stk8ba50_data *data;
0512
0513     data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
0514
0515     return stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND);
0516 }
0517
0518 static int stk8ba50_resume(struct device *dev)
0519 {
0520     struct stk8ba50_data *data;
0521
0522     data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
0523
0524     return stk8ba50_set_power(data, STK8BA50_MODE_NORMAL);
0525 }
0526
0527 static DEFINE_SIMPLE_DEV_PM_OPS(stk8ba50_pm_ops, stk8ba50_suspend,
0528                 stk8ba50_resume);
0529
0530 static const struct i2c_device_id stk8ba50_i2c_id[] = {
0531     {"stk8ba50", 0},
0532     {}
0533 };
0534 MODULE_DEVICE_TABLE(i2c, stk8ba50_i2c_id);
0535
0536 static const struct acpi_device_id stk8ba50_acpi_id[] = {
0537     {"STK8BA50", 0},
0538     {}
0539 };
0540
0541 MODULE_DEVICE_TABLE(acpi, stk8ba50_acpi_id);
0542
0543 static struct i2c_driver stk8ba50_driver = {
0544     .driver = {
0545         .name = "stk8ba50",
0546         .pm = pm_sleep_ptr(&stk8ba50_pm_ops),
0547         .acpi_match_table = ACPI_PTR(stk8ba50_acpi_id),
0548     },
0549     .probe =            stk8ba50_probe,
0550     .remove =           stk8ba50_remove,
0551     .id_table =         stk8ba50_i2c_id,
0552 };
0553
0554 module_i2c_driver(stk8ba50_driver);
0555
0556 MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>");
0557 MODULE_DESCRIPTION("STK8BA50 3-Axis Accelerometer driver");
0558 MODULE_LICENSE("GPL v2");