drivers/iio/accel/mc3230.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * mCube MC3230 3-Axis Accelerometer
   4  *
   5  * Copyright (c) 2016 Hans de Goede <hdegoede@redhat.com>
   6  *
   7  * IIO driver for mCube MC3230; 7-bit I2C address: 0x4c.
   8  */
   9
  10 #include <linux/i2c.h>
  11 #include <linux/module.h>
  12 #include <linux/iio/iio.h>
  13 #include <linux/iio/sysfs.h>
  14
  15 #define MC3230_REG_XOUT                 0x00
  16 #define MC3230_REG_YOUT                 0x01
  17 #define MC3230_REG_ZOUT                 0x02
  18
  19 #define MC3230_REG_MODE                 0x07
  20 #define MC3230_MODE_OPCON_MASK          0x03
  21 #define MC3230_MODE_OPCON_WAKE          0x01
  22 #define MC3230_MODE_OPCON_STANDBY       0x03
  23
  24 #define MC3230_REG_CHIP_ID              0x18
  25 #define MC3230_CHIP_ID                  0x01
  26
  27 #define MC3230_REG_PRODUCT_CODE         0x3b
  28 #define MC3230_PRODUCT_CODE             0x19
  29
  30 /*
  31  * The accelerometer has one measurement range:
  32  *
  33  * -1.5g - +1.5g (8-bit, signed)
  34  *
  35  * scale = (1.5 + 1.5) * 9.81 / (2^8 - 1)       = 0.115411765
  36  */
  37
  38 static const int mc3230_nscale = 115411765;
  39
  40 #define MC3230_CHANNEL(reg, axis) {     \
  41         .type = IIO_ACCEL,      \
  42         .address = reg, \
  43         .modified = 1,  \
  44         .channel2 = IIO_MOD_##axis,     \
  45         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
  46         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
  47 }
  48
  49 static const struct iio_chan_spec mc3230_channels[] = {
  50         MC3230_CHANNEL(MC3230_REG_XOUT, X),
  51         MC3230_CHANNEL(MC3230_REG_YOUT, Y),
  52         MC3230_CHANNEL(MC3230_REG_ZOUT, Z),
  53 };
  54
  55 struct mc3230_data {
  56         struct i2c_client *client;
  57 };
  58
  59 static int mc3230_set_opcon(struct mc3230_data *data, int opcon)
  60 {
  61         int ret;
  62         struct i2c_client *client = data->client;
  63
  64         ret = i2c_smbus_read_byte_data(client, MC3230_REG_MODE);
  65         if (ret < 0) {
  66                 dev_err(&client->dev, "failed to read mode reg: %d\n", ret);
  67                 return ret;
  68         }
  69
  70         ret &= ~MC3230_MODE_OPCON_MASK;
  71         ret |= opcon;
  72
  73         ret = i2c_smbus_write_byte_data(client, MC3230_REG_MODE, ret);
  74         if (ret < 0) {
  75                 dev_err(&client->dev, "failed to write mode reg: %d\n", ret);
  76                 return ret;
  77         }
  78
  79         return 0;
  80 }
  81
  82 static int mc3230_read_raw(struct iio_dev *indio_dev,
  83                                 struct iio_chan_spec const *chan,
  84                                 int *val, int *val2, long mask)
  85 {
  86         struct mc3230_data *data = iio_priv(indio_dev);
  87         int ret;
  88
  89         switch (mask) {
  90         case IIO_CHAN_INFO_RAW:
  91                 ret = i2c_smbus_read_byte_data(data->client, chan->address);
  92                 if (ret < 0)
  93                         return ret;
  94                 *val = sign_extend32(ret, 7);
  95                 return IIO_VAL_INT;
  96         case IIO_CHAN_INFO_SCALE:
  97                 *val = 0;
  98                 *val2 = mc3230_nscale;
  99                 return IIO_VAL_INT_PLUS_NANO;
 100         default:
 101                 return -EINVAL;
 102         }
 103 }
 104
 105 static const struct iio_info mc3230_info = {
 106         .read_raw       = mc3230_read_raw,
 107 };
 108
 109 static int mc3230_probe(struct i2c_client *client)
 110 {
 111         int ret;
 112         struct iio_dev *indio_dev;
 113         struct mc3230_data *data;
 114
 115         /* First check chip-id and product-id */
 116         ret = i2c_smbus_read_byte_data(client, MC3230_REG_CHIP_ID);
 117         if (ret != MC3230_CHIP_ID)
 118                 return (ret < 0) ? ret : -ENODEV;
 119
 120         ret = i2c_smbus_read_byte_data(client, MC3230_REG_PRODUCT_CODE);
 121         if (ret != MC3230_PRODUCT_CODE)
 122                 return (ret < 0) ? ret : -ENODEV;
 123
 124         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 125         if (!indio_dev) {
 126                 dev_err(&client->dev, "iio allocation failed!\n");
 127                 return -ENOMEM;
 128         }
 129
 130         data = iio_priv(indio_dev);
 131         data->client = client;
 132         i2c_set_clientdata(client, indio_dev);
 133
 134         indio_dev->info = &mc3230_info;
 135         indio_dev->name = "mc3230";
 136         indio_dev->modes = INDIO_DIRECT_MODE;
 137         indio_dev->channels = mc3230_channels;
 138         indio_dev->num_channels = ARRAY_SIZE(mc3230_channels);
 139
 140         ret = mc3230_set_opcon(data, MC3230_MODE_OPCON_WAKE);
 141         if (ret < 0)
 142                 return ret;
 143
 144         ret = iio_device_register(indio_dev);
 145         if (ret < 0) {
 146                 dev_err(&client->dev, "device_register failed\n");
 147                 mc3230_set_opcon(data, MC3230_MODE_OPCON_STANDBY);
 148         }
 149
 150         return ret;
 151 }
 152
 153 static void mc3230_remove(struct i2c_client *client)
 154 {
 155         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 156
 157         iio_device_unregister(indio_dev);
 158
 159         mc3230_set_opcon(iio_priv(indio_dev), MC3230_MODE_OPCON_STANDBY);
 160 }
 161
 162 static int mc3230_suspend(struct device *dev)
 163 {
 164         struct mc3230_data *data;
 165
 166         data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
 167
 168         return mc3230_set_opcon(data, MC3230_MODE_OPCON_STANDBY);
 169 }
 170
 171 static int mc3230_resume(struct device *dev)
 172 {
 173         struct mc3230_data *data;
 174
 175         data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
 176
 177         return mc3230_set_opcon(data, MC3230_MODE_OPCON_WAKE);
 178 }
 179
 180 static DEFINE_SIMPLE_DEV_PM_OPS(mc3230_pm_ops, mc3230_suspend, mc3230_resume);
 181
 182 static const struct i2c_device_id mc3230_i2c_id[] = {
 183         { "mc3230" },
 184         {}
 185 };
 186 MODULE_DEVICE_TABLE(i2c, mc3230_i2c_id);
 187
 188 static struct i2c_driver mc3230_driver = {
 189         .driver = {
 190                 .name = "mc3230",
 191                 .pm = pm_sleep_ptr(&mc3230_pm_ops),
 192         },
 193         .probe          = mc3230_probe,
 194         .remove         = mc3230_remove,
 195         .id_table       = mc3230_i2c_id,
 196 };
 197
 198 module_i2c_driver(mc3230_driver);
 199
 200 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
 201 MODULE_DESCRIPTION("mCube MC3230 3-Axis Accelerometer driver");
 202 MODULE_LICENSE("GPL v2");