drivers/iio/accel/mc3230.c

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