drivers/iio/gyro/itg3200_core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * itg3200_core.c -- support InvenSense ITG3200
   4  *                   Digital 3-Axis Gyroscope driver
   5  *
   6  * Copyright (c) 2011 Christian Strobel <[email protected]>
   7  * Copyright (c) 2011 Manuel Stahl <[email protected]>
   8  * Copyright (c) 2012 Thorsten Nowak <[email protected]>
   9  *
  10  * TODO:
  11  * - Support digital low pass filter
  12  * - Support power management
  13  */
  14
  15 #include <linux/interrupt.h>
  16 #include <linux/irq.h>
  17 #include <linux/i2c.h>
  18 #include <linux/slab.h>
  19 #include <linux/stat.h>
  20 #include <linux/module.h>
  21 #include <linux/delay.h>
  22
  23 #include <linux/iio/iio.h>
  24 #include <linux/iio/sysfs.h>
  25 #include <linux/iio/events.h>
  26 #include <linux/iio/buffer.h>
  27
  28 #include <linux/iio/gyro/itg3200.h>
  29
  30
  31 int itg3200_write_reg_8(struct iio_dev *indio_dev,
  32                 u8 reg_address, u8 val)
  33 {
  34         struct itg3200 *st = iio_priv(indio_dev);
  35
  36         return i2c_smbus_write_byte_data(st->i2c, 0x80 | reg_address, val);
  37 }
  38
  39 int itg3200_read_reg_8(struct iio_dev *indio_dev,
  40                 u8 reg_address, u8 *val)
  41 {
  42         struct itg3200 *st = iio_priv(indio_dev);
  43         int ret;
  44
  45         ret = i2c_smbus_read_byte_data(st->i2c, reg_address);
  46         if (ret < 0)
  47                 return ret;
  48         *val = ret;
  49         return 0;
  50 }
  51
  52 static int itg3200_read_reg_s16(struct iio_dev *indio_dev, u8 lower_reg_address,
  53                 int *val)
  54 {
  55         struct itg3200 *st = iio_priv(indio_dev);
  56         struct i2c_client *client = st->i2c;
  57         int ret;
  58         s16 out;
  59
  60         struct i2c_msg msg[2] = {
  61                 {
  62                         .addr = client->addr,
  63                         .flags = client->flags,
  64                         .len = 1,
  65                         .buf = (char *)&lower_reg_address,
  66                 },
  67                 {
  68                         .addr = client->addr,
  69                         .flags = client->flags | I2C_M_RD,
  70                         .len = 2,
  71                         .buf = (char *)&out,
  72                 },
  73         };
  74
  75         lower_reg_address |= 0x80;
  76         ret = i2c_transfer(client->adapter, msg, 2);
  77         be16_to_cpus(&out);
  78         *val = out;
  79
  80         return (ret == 2) ? 0 : ret;
  81 }
  82
  83 static int itg3200_read_raw(struct iio_dev *indio_dev,
  84                 const struct iio_chan_spec *chan,
  85                 int *val, int *val2, long info)
  86 {
  87         int ret = 0;
  88         u8 reg;
  89         u8 regval;
  90
  91         switch (info) {
  92         case IIO_CHAN_INFO_RAW:
  93                 reg = (u8)chan->address;
  94                 ret = itg3200_read_reg_s16(indio_dev, reg, val);
  95                 return IIO_VAL_INT;
  96         case IIO_CHAN_INFO_SCALE:
  97                 *val = 0;
  98                 if (chan->type == IIO_TEMP)
  99                         *val2 = 1000000000/280;
 100                 else
 101                         *val2 = 1214142; /* (1 / 14,375) * (PI / 180) */
 102                 return IIO_VAL_INT_PLUS_NANO;
 103         case IIO_CHAN_INFO_OFFSET:
 104                 /* Only the temperature channel has an offset */
 105                 *val = 23000;
 106                 return IIO_VAL_INT;
 107         case IIO_CHAN_INFO_SAMP_FREQ:
 108                 ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_DLPF, &regval);
 109                 if (ret)
 110                         return ret;
 111
 112                 *val = (regval & ITG3200_DLPF_CFG_MASK) ? 1000 : 8000;
 113
 114                 ret = itg3200_read_reg_8(indio_dev,
 115                                          ITG3200_REG_SAMPLE_RATE_DIV,
 116                                          &regval);
 117                 if (ret)
 118                         return ret;
 119
 120                 *val /= regval + 1;
 121                 return IIO_VAL_INT;
 122
 123         default:
 124                 return -EINVAL;
 125         }
 126 }
 127
 128 static int itg3200_write_raw(struct iio_dev *indio_dev,
 129                              struct iio_chan_spec const *chan,
 130                              int val,
 131                              int val2,
 132                              long mask)
 133 {
 134         int ret;
 135         u8 t;
 136
 137         switch (mask) {
 138         case IIO_CHAN_INFO_SAMP_FREQ:
 139                 if (val == 0 || val2 != 0)
 140                         return -EINVAL;
 141
 142                 mutex_lock(&indio_dev->mlock);
 143
 144                 ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_DLPF, &t);
 145                 if (ret) {
 146                         mutex_unlock(&indio_dev->mlock);
 147                         return ret;
 148                 }
 149                 t = ((t & ITG3200_DLPF_CFG_MASK) ? 1000u : 8000u) / val - 1;
 150
 151                 ret = itg3200_write_reg_8(indio_dev,
 152                                           ITG3200_REG_SAMPLE_RATE_DIV,
 153                                           t);
 154
 155                 mutex_unlock(&indio_dev->mlock);
 156                 return ret;
 157
 158         default:
 159                 return -EINVAL;
 160         }
 161 }
 162
 163 /*
 164  * Reset device and internal registers to the power-up-default settings
 165  * Use the gyro clock as reference, as suggested by the datasheet
 166  */
 167 static int itg3200_reset(struct iio_dev *indio_dev)
 168 {
 169         struct itg3200 *st = iio_priv(indio_dev);
 170         int ret;
 171
 172         dev_dbg(&st->i2c->dev, "reset device");
 173
 174         ret = itg3200_write_reg_8(indio_dev,
 175                         ITG3200_REG_POWER_MANAGEMENT,
 176                         ITG3200_RESET);
 177         if (ret) {
 178                 dev_err(&st->i2c->dev, "error resetting device");
 179                 goto error_ret;
 180         }
 181
 182         /* Wait for PLL (1ms according to datasheet) */
 183         udelay(1500);
 184
 185         ret = itg3200_write_reg_8(indio_dev,
 186                         ITG3200_REG_IRQ_CONFIG,
 187                         ITG3200_IRQ_ACTIVE_HIGH |
 188                         ITG3200_IRQ_PUSH_PULL |
 189                         ITG3200_IRQ_LATCH_50US_PULSE |
 190                         ITG3200_IRQ_LATCH_CLEAR_ANY);
 191
 192         if (ret)
 193                 dev_err(&st->i2c->dev, "error init device");
 194
 195 error_ret:
 196         return ret;
 197 }
 198
 199 /* itg3200_enable_full_scale() - Disables the digital low pass filter */
 200 static int itg3200_enable_full_scale(struct iio_dev *indio_dev)
 201 {
 202         u8 val;
 203         int ret;
 204
 205         ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_DLPF, &val);
 206         if (ret)
 207                 goto err_ret;
 208
 209         val |= ITG3200_DLPF_FS_SEL_2000;
 210         return itg3200_write_reg_8(indio_dev, ITG3200_REG_DLPF, val);
 211
 212 err_ret:
 213         return ret;
 214 }
 215
 216 static int itg3200_initial_setup(struct iio_dev *indio_dev)
 217 {
 218         struct itg3200 *st = iio_priv(indio_dev);
 219         int ret;
 220         u8 val;
 221
 222         ret = itg3200_reset(indio_dev);
 223         if (ret)
 224                 goto err_ret;
 225
 226         ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_ADDRESS, &val);
 227         if (ret)
 228                 goto err_ret;
 229
 230         if (((val >> 1) & 0x3f) != 0x34) {
 231                 dev_err(&st->i2c->dev, "invalid reg value 0x%02x", val);
 232                 ret = -ENXIO;
 233                 goto err_ret;
 234         }
 235
 236         ret = itg3200_enable_full_scale(indio_dev);
 237 err_ret:
 238         return ret;
 239 }
 240
 241 static const struct iio_mount_matrix *
 242 itg3200_get_mount_matrix(const struct iio_dev *indio_dev,
 243                           const struct iio_chan_spec *chan)
 244 {
 245         struct itg3200 *data = iio_priv(indio_dev);
 246
 247         return &data->orientation;
 248 }
 249
 250 static const struct iio_chan_spec_ext_info itg3200_ext_info[] = {
 251         IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, itg3200_get_mount_matrix),
 252         { }
 253 };
 254
 255 #define ITG3200_ST                                              \
 256         { .sign = 's', .realbits = 16, .storagebits = 16, .endianness = IIO_BE }
 257
 258 #define ITG3200_GYRO_CHAN(_mod) { \
 259         .type = IIO_ANGL_VEL, \
 260         .modified = 1, \
 261         .channel2 = IIO_MOD_ ## _mod, \
 262         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
 263         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
 264         .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
 265         .address = ITG3200_REG_GYRO_ ## _mod ## OUT_H, \
 266         .scan_index = ITG3200_SCAN_GYRO_ ## _mod, \
 267         .scan_type = ITG3200_ST, \
 268         .ext_info = itg3200_ext_info, \
 269 }
 270
 271 static const struct iio_chan_spec itg3200_channels[] = {
 272         {
 273                 .type = IIO_TEMP,
 274                 .channel2 = IIO_NO_MOD,
 275                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 276                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
 277                 BIT(IIO_CHAN_INFO_SCALE),
 278                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
 279                 .address = ITG3200_REG_TEMP_OUT_H,
 280                 .scan_index = ITG3200_SCAN_TEMP,
 281                 .scan_type = ITG3200_ST,
 282         },
 283         ITG3200_GYRO_CHAN(X),
 284         ITG3200_GYRO_CHAN(Y),
 285         ITG3200_GYRO_CHAN(Z),
 286         IIO_CHAN_SOFT_TIMESTAMP(ITG3200_SCAN_ELEMENTS),
 287 };
 288
 289 static const struct iio_info itg3200_info = {
 290         .read_raw = &itg3200_read_raw,
 291         .write_raw = &itg3200_write_raw,
 292 };
 293
 294 static const unsigned long itg3200_available_scan_masks[] = { 0xffffffff, 0x0 };
 295
 296 static int itg3200_probe(struct i2c_client *client,
 297                 const struct i2c_device_id *id)
 298 {
 299         int ret;
 300         struct itg3200 *st;
 301         struct iio_dev *indio_dev;
 302
 303         dev_dbg(&client->dev, "probe I2C dev with IRQ %i", client->irq);
 304
 305         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*st));
 306         if (!indio_dev)
 307                 return -ENOMEM;
 308
 309         st = iio_priv(indio_dev);
 310
 311         ret = iio_read_mount_matrix(&client->dev, &st->orientation);
 312         if (ret)
 313                 return ret;
 314
 315         i2c_set_clientdata(client, indio_dev);
 316         st->i2c = client;
 317
 318         indio_dev->name = client->dev.driver->name;
 319         indio_dev->channels = itg3200_channels;
 320         indio_dev->num_channels = ARRAY_SIZE(itg3200_channels);
 321         indio_dev->available_scan_masks = itg3200_available_scan_masks;
 322         indio_dev->info = &itg3200_info;
 323         indio_dev->modes = INDIO_DIRECT_MODE;
 324
 325         ret = itg3200_buffer_configure(indio_dev);
 326         if (ret)
 327                 return ret;
 328
 329         if (client->irq) {
 330                 ret = itg3200_probe_trigger(indio_dev);
 331                 if (ret)
 332                         goto error_unconfigure_buffer;
 333         }
 334
 335         ret = itg3200_initial_setup(indio_dev);
 336         if (ret)
 337                 goto error_remove_trigger;
 338
 339         ret = iio_device_register(indio_dev);
 340         if (ret)
 341                 goto error_remove_trigger;
 342
 343         return 0;
 344
 345 error_remove_trigger:
 346         if (client->irq)
 347                 itg3200_remove_trigger(indio_dev);
 348 error_unconfigure_buffer:
 349         itg3200_buffer_unconfigure(indio_dev);
 350         return ret;
 351 }
 352
 353 static int itg3200_remove(struct i2c_client *client)
 354 {
 355         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 356
 357         iio_device_unregister(indio_dev);
 358
 359         if (client->irq)
 360                 itg3200_remove_trigger(indio_dev);
 361
 362         itg3200_buffer_unconfigure(indio_dev);
 363
 364         return 0;
 365 }
 366
 367 static int __maybe_unused itg3200_suspend(struct device *dev)
 368 {
 369         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 370         struct itg3200 *st = iio_priv(indio_dev);
 371
 372         dev_dbg(&st->i2c->dev, "suspend device");
 373
 374         return itg3200_write_reg_8(indio_dev, ITG3200_REG_POWER_MANAGEMENT,
 375                                    ITG3200_SLEEP);
 376 }
 377
 378 static int __maybe_unused itg3200_resume(struct device *dev)
 379 {
 380         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 381
 382         return itg3200_initial_setup(indio_dev);
 383 }
 384
 385 static SIMPLE_DEV_PM_OPS(itg3200_pm_ops, itg3200_suspend, itg3200_resume);
 386
 387 static const struct i2c_device_id itg3200_id[] = {
 388         { "itg3200", 0 },
 389         { }
 390 };
 391 MODULE_DEVICE_TABLE(i2c, itg3200_id);
 392
 393 static const struct of_device_id itg3200_of_match[] = {
 394         { .compatible = "invensense,itg3200" },
 395         { }
 396 };
 397 MODULE_DEVICE_TABLE(of, itg3200_of_match);
 398
 399 static struct i2c_driver itg3200_driver = {
 400         .driver = {
 401                 .name   = "itg3200",
 402                 .of_match_table = itg3200_of_match,
 403                 .pm     = &itg3200_pm_ops,
 404         },
 405         .id_table       = itg3200_id,
 406         .probe          = itg3200_probe,
 407         .remove         = itg3200_remove,
 408 };
 409
 410 module_i2c_driver(itg3200_driver);
 411
 412 MODULE_AUTHOR("Christian Strobel <[email protected]>");
 413 MODULE_DESCRIPTION("ITG3200 Gyroscope I2C driver");
 414 MODULE_LICENSE("GPL v2");