iio/accel/mc3230.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * mCube MC3230 3-Axis Accelerometer
0004  *
0005  * Copyright (c) 2016 Hans de Goede <hdegoede@redhat.com>
0006  *
0007  * IIO driver for mCube MC3230; 7-bit I2C address: 0x4c.
0008  */
0009
0010 #include <linux/i2c.h>
0011 #include <linux/module.h>
0012 #include <linux/iio/iio.h>
0013 #include <linux/iio/sysfs.h>
0014
0015 #define MC3230_REG_XOUT         0x00
0016 #define MC3230_REG_YOUT         0x01
0017 #define MC3230_REG_ZOUT         0x02
0018
0019 #define MC3230_REG_MODE         0x07
0020 #define MC3230_MODE_OPCON_MASK      0x03
0021 #define MC3230_MODE_OPCON_WAKE      0x01
0022 #define MC3230_MODE_OPCON_STANDBY   0x03
0023
0024 #define MC3230_REG_CHIP_ID      0x18
0025 #define MC3230_CHIP_ID          0x01
0026
0027 #define MC3230_REG_PRODUCT_CODE     0x3b
0028 #define MC3230_PRODUCT_CODE     0x19
0029
0030 /*
0031  * The accelerometer has one measurement range:
0032  *
0033  * -1.5g - +1.5g (8-bit, signed)
0034  *
0035  * scale = (1.5 + 1.5) * 9.81 / (2^8 - 1)   = 0.115411765
0036  */
0037
0038 static const int mc3230_nscale = 115411765;
0039
0040 #define MC3230_CHANNEL(reg, axis) { \
0041     .type = IIO_ACCEL,  \
0042     .address = reg, \
0043     .modified = 1,  \
0044     .channel2 = IIO_MOD_##axis, \
0045     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
0046     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
0047 }
0048
0049 static const struct iio_chan_spec mc3230_channels[] = {
0050     MC3230_CHANNEL(MC3230_REG_XOUT, X),
0051     MC3230_CHANNEL(MC3230_REG_YOUT, Y),
0052     MC3230_CHANNEL(MC3230_REG_ZOUT, Z),
0053 };
0054
0055 struct mc3230_data {
0056     struct i2c_client *client;
0057 };
0058
0059 static int mc3230_set_opcon(struct mc3230_data *data, int opcon)
0060 {
0061     int ret;
0062     struct i2c_client *client = data->client;
0063
0064     ret = i2c_smbus_read_byte_data(client, MC3230_REG_MODE);
0065     if (ret < 0) {
0066         dev_err(&client->dev, "failed to read mode reg: %d\n", ret);
0067         return ret;
0068     }
0069
0070     ret &= ~MC3230_MODE_OPCON_MASK;
0071     ret |= opcon;
0072
0073     ret = i2c_smbus_write_byte_data(client, MC3230_REG_MODE, ret);
0074     if (ret < 0) {
0075         dev_err(&client->dev, "failed to write mode reg: %d\n", ret);
0076         return ret;
0077     }
0078
0079     return 0;
0080 }
0081
0082 static int mc3230_read_raw(struct iio_dev *indio_dev,
0083                 struct iio_chan_spec const *chan,
0084                 int *val, int *val2, long mask)
0085 {
0086     struct mc3230_data *data = iio_priv(indio_dev);
0087     int ret;
0088
0089     switch (mask) {
0090     case IIO_CHAN_INFO_RAW:
0091         ret = i2c_smbus_read_byte_data(data->client, chan->address);
0092         if (ret < 0)
0093             return ret;
0094         *val = sign_extend32(ret, 7);
0095         return IIO_VAL_INT;
0096     case IIO_CHAN_INFO_SCALE:
0097         *val = 0;
0098         *val2 = mc3230_nscale;
0099         return IIO_VAL_INT_PLUS_NANO;
0100     default:
0101         return -EINVAL;
0102     }
0103 }
0104
0105 static const struct iio_info mc3230_info = {
0106     .read_raw   = mc3230_read_raw,
0107 };
0108
0109 static int mc3230_probe(struct i2c_client *client,
0110             const struct i2c_device_id *id)
0111 {
0112     int ret;
0113     struct iio_dev *indio_dev;
0114     struct mc3230_data *data;
0115
0116     /* First check chip-id and product-id */
0117     ret = i2c_smbus_read_byte_data(client, MC3230_REG_CHIP_ID);
0118     if (ret != MC3230_CHIP_ID)
0119         return (ret < 0) ? ret : -ENODEV;
0120
0121     ret = i2c_smbus_read_byte_data(client, MC3230_REG_PRODUCT_CODE);
0122     if (ret != MC3230_PRODUCT_CODE)
0123         return (ret < 0) ? ret : -ENODEV;
0124
0125     indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
0126     if (!indio_dev) {
0127         dev_err(&client->dev, "iio allocation failed!\n");
0128         return -ENOMEM;
0129     }
0130
0131     data = iio_priv(indio_dev);
0132     data->client = client;
0133     i2c_set_clientdata(client, indio_dev);
0134
0135     indio_dev->info = &mc3230_info;
0136     indio_dev->name = "mc3230";
0137     indio_dev->modes = INDIO_DIRECT_MODE;
0138     indio_dev->channels = mc3230_channels;
0139     indio_dev->num_channels = ARRAY_SIZE(mc3230_channels);
0140
0141     ret = mc3230_set_opcon(data, MC3230_MODE_OPCON_WAKE);
0142     if (ret < 0)
0143         return ret;
0144
0145     ret = iio_device_register(indio_dev);
0146     if (ret < 0) {
0147         dev_err(&client->dev, "device_register failed\n");
0148         mc3230_set_opcon(data, MC3230_MODE_OPCON_STANDBY);
0149     }
0150
0151     return ret;
0152 }
0153
0154 static int mc3230_remove(struct i2c_client *client)
0155 {
0156     struct iio_dev *indio_dev = i2c_get_clientdata(client);
0157
0158     iio_device_unregister(indio_dev);
0159
0160     mc3230_set_opcon(iio_priv(indio_dev), MC3230_MODE_OPCON_STANDBY);
0161
0162     return 0;
0163 }
0164
0165 static int mc3230_suspend(struct device *dev)
0166 {
0167     struct mc3230_data *data;
0168
0169     data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
0170
0171     return mc3230_set_opcon(data, MC3230_MODE_OPCON_STANDBY);
0172 }
0173
0174 static int mc3230_resume(struct device *dev)
0175 {
0176     struct mc3230_data *data;
0177
0178     data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
0179
0180     return mc3230_set_opcon(data, MC3230_MODE_OPCON_WAKE);
0181 }
0182
0183 static DEFINE_SIMPLE_DEV_PM_OPS(mc3230_pm_ops, mc3230_suspend, mc3230_resume);
0184
0185 static const struct i2c_device_id mc3230_i2c_id[] = {
0186     {"mc3230", 0},
0187     {}
0188 };
0189 MODULE_DEVICE_TABLE(i2c, mc3230_i2c_id);
0190
0191 static struct i2c_driver mc3230_driver = {
0192     .driver = {
0193         .name = "mc3230",
0194         .pm = pm_sleep_ptr(&mc3230_pm_ops),
0195     },
0196     .probe      = mc3230_probe,
0197     .remove     = mc3230_remove,
0198     .id_table   = mc3230_i2c_id,
0199 };
0200
0201 module_i2c_driver(mc3230_driver);
0202
0203 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
0204 MODULE_DESCRIPTION("mCube MC3230 3-Axis Accelerometer driver");
0205 MODULE_LICENSE("GPL v2");