kernel/drivers/iio/gyro/bmg160_core.c

   1 /*
   2  * BMG160 Gyro Sensor driver
   3  * Copyright (c) 2014, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/delay.h>
  18 #include <linux/slab.h>
  19 #include <linux/acpi.h>
  20 #include <linux/gpio/consumer.h>
  21 #include <linux/pm.h>
  22 #include <linux/pm_runtime.h>
  23 #include <linux/iio/iio.h>
  24 #include <linux/iio/sysfs.h>
  25 #include <linux/iio/buffer.h>
  26 #include <linux/iio/trigger.h>
  27 #include <linux/iio/events.h>
  28 #include <linux/iio/trigger_consumer.h>
  29 #include <linux/iio/triggered_buffer.h>
  30 #include <linux/regmap.h>
  31 #include "bmg160.h"
  32
  33 #define BMG160_IRQ_NAME         "bmg160_event"
  34 #define BMG160_GPIO_NAME                "gpio_int"
  35
  36 #define BMG160_REG_CHIP_ID              0x00
  37 #define BMG160_CHIP_ID_VAL              0x0F
  38
  39 #define BMG160_REG_PMU_LPW              0x11
  40 #define BMG160_MODE_NORMAL              0x00
  41 #define BMG160_MODE_DEEP_SUSPEND        0x20
  42 #define BMG160_MODE_SUSPEND             0x80
  43
  44 #define BMG160_REG_RANGE                0x0F
  45
  46 #define BMG160_RANGE_2000DPS            0
  47 #define BMG160_RANGE_1000DPS            1
  48 #define BMG160_RANGE_500DPS             2
  49 #define BMG160_RANGE_250DPS             3
  50 #define BMG160_RANGE_125DPS             4
  51
  52 #define BMG160_REG_PMU_BW               0x10
  53 #define BMG160_NO_FILTER                0
  54 #define BMG160_DEF_BW                   100
  55
  56 #define BMG160_REG_INT_MAP_0            0x17
  57 #define BMG160_INT_MAP_0_BIT_ANY        BIT(1)
  58
  59 #define BMG160_REG_INT_MAP_1            0x18
  60 #define BMG160_INT_MAP_1_BIT_NEW_DATA   BIT(0)
  61
  62 #define BMG160_REG_INT_RST_LATCH        0x21
  63 #define BMG160_INT_MODE_LATCH_RESET     0x80
  64 #define BMG160_INT_MODE_LATCH_INT       0x0F
  65 #define BMG160_INT_MODE_NON_LATCH_INT   0x00
  66
  67 #define BMG160_REG_INT_EN_0             0x15
  68 #define BMG160_DATA_ENABLE_INT          BIT(7)
  69
  70 #define BMG160_REG_INT_EN_1             0x16
  71 #define BMG160_INT1_BIT_OD              BIT(1)
  72
  73 #define BMG160_REG_XOUT_L               0x02
  74 #define BMG160_AXIS_TO_REG(axis)        (BMG160_REG_XOUT_L + (axis * 2))
  75
  76 #define BMG160_REG_SLOPE_THRES          0x1B
  77 #define BMG160_SLOPE_THRES_MASK 0x0F
  78
  79 #define BMG160_REG_MOTION_INTR          0x1C
  80 #define BMG160_INT_MOTION_X             BIT(0)
  81 #define BMG160_INT_MOTION_Y             BIT(1)
  82 #define BMG160_INT_MOTION_Z             BIT(2)
  83 #define BMG160_ANY_DUR_MASK             0x30
  84 #define BMG160_ANY_DUR_SHIFT            4
  85
  86 #define BMG160_REG_INT_STATUS_2 0x0B
  87 #define BMG160_ANY_MOTION_MASK          0x07
  88 #define BMG160_ANY_MOTION_BIT_X         BIT(0)
  89 #define BMG160_ANY_MOTION_BIT_Y         BIT(1)
  90 #define BMG160_ANY_MOTION_BIT_Z         BIT(2)
  91
  92 #define BMG160_REG_TEMP         0x08
  93 #define BMG160_TEMP_CENTER_VAL          23
  94
  95 #define BMG160_MAX_STARTUP_TIME_MS      80
  96
  97 #define BMG160_AUTO_SUSPEND_DELAY_MS    2000
  98
  99 struct bmg160_data {
 100         struct device *dev;
 101         struct regmap *regmap;
 102         struct iio_trigger *dready_trig;
 103         struct iio_trigger *motion_trig;
 104         struct mutex mutex;
 105         s16 buffer[8];
 106         u8 bw_bits;
 107         u32 dps_range;
 108         int ev_enable_state;
 109         int slope_thres;
 110         bool dready_trigger_on;
 111         bool motion_trigger_on;
 112         int irq;
 113 };
 114
 115 enum bmg160_axis {
 116         AXIS_X,
 117         AXIS_Y,
 118         AXIS_Z,
 119 };
 120
 121 static const struct {
 122         int val;
 123         int bw_bits;
 124 } bmg160_samp_freq_table[] = { {100, 0x07},
 125                                {200, 0x06},
 126                                {400, 0x03},
 127                                {1000, 0x02},
 128                                {2000, 0x01} };
 129
 130 static const struct {
 131         int scale;
 132         int dps_range;
 133 } bmg160_scale_table[] = { { 1065, BMG160_RANGE_2000DPS},
 134                            { 532, BMG160_RANGE_1000DPS},
 135                            { 266, BMG160_RANGE_500DPS},
 136                            { 133, BMG160_RANGE_250DPS},
 137                            { 66, BMG160_RANGE_125DPS} };
 138
 139 static int bmg160_set_mode(struct bmg160_data *data, u8 mode)
 140 {
 141         int ret;
 142
 143         ret = regmap_write(data->regmap, BMG160_REG_PMU_LPW, mode);
 144         if (ret < 0) {
 145                 dev_err(data->dev, "Error writing reg_pmu_lpw\n");
 146                 return ret;
 147         }
 148
 149         return 0;
 150 }
 151
 152 static int bmg160_convert_freq_to_bit(int val)
 153 {
 154         int i;
 155
 156         for (i = 0; i < ARRAY_SIZE(bmg160_samp_freq_table); ++i) {
 157                 if (bmg160_samp_freq_table[i].val == val)
 158                         return bmg160_samp_freq_table[i].bw_bits;
 159         }
 160
 161         return -EINVAL;
 162 }
 163
 164 static int bmg160_set_bw(struct bmg160_data *data, int val)
 165 {
 166         int ret;
 167         int bw_bits;
 168
 169         bw_bits = bmg160_convert_freq_to_bit(val);
 170         if (bw_bits < 0)
 171                 return bw_bits;
 172
 173         ret = regmap_write(data->regmap, BMG160_REG_PMU_BW, bw_bits);
 174         if (ret < 0) {
 175                 dev_err(data->dev, "Error writing reg_pmu_bw\n");
 176                 return ret;
 177         }
 178
 179         data->bw_bits = bw_bits;
 180
 181         return 0;
 182 }
 183
 184 static int bmg160_chip_init(struct bmg160_data *data)
 185 {
 186         int ret;
 187         unsigned int val;
 188
 189         ret = regmap_read(data->regmap, BMG160_REG_CHIP_ID, &val);
 190         if (ret < 0) {
 191                 dev_err(data->dev, "Error reading reg_chip_id\n");
 192                 return ret;
 193         }
 194
 195         dev_dbg(data->dev, "Chip Id %x\n", val);
 196         if (val != BMG160_CHIP_ID_VAL) {
 197                 dev_err(data->dev, "invalid chip %x\n", val);
 198                 return -ENODEV;
 199         }
 200
 201         ret = bmg160_set_mode(data, BMG160_MODE_NORMAL);
 202         if (ret < 0)
 203                 return ret;
 204
 205         /* Wait upto 500 ms to be ready after changing mode */
 206         usleep_range(500, 1000);
 207
 208         /* Set Bandwidth */
 209         ret = bmg160_set_bw(data, BMG160_DEF_BW);
 210         if (ret < 0)
 211                 return ret;
 212
 213         /* Set Default Range */
 214         ret = regmap_write(data->regmap, BMG160_REG_RANGE, BMG160_RANGE_500DPS);
 215         if (ret < 0) {
 216                 dev_err(data->dev, "Error writing reg_range\n");
 217                 return ret;
 218         }
 219         data->dps_range = BMG160_RANGE_500DPS;
 220
 221         ret = regmap_read(data->regmap, BMG160_REG_SLOPE_THRES, &val);
 222         if (ret < 0) {
 223                 dev_err(data->dev, "Error reading reg_slope_thres\n");
 224                 return ret;
 225         }
 226         data->slope_thres = val;
 227
 228         /* Set default interrupt mode */
 229         ret = regmap_update_bits(data->regmap, BMG160_REG_INT_EN_1,
 230                                  BMG160_INT1_BIT_OD, 0);
 231         if (ret < 0) {
 232                 dev_err(data->dev, "Error updating bits in reg_int_en_1\n");
 233                 return ret;
 234         }
 235
 236         ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
 237                            BMG160_INT_MODE_LATCH_INT |
 238                            BMG160_INT_MODE_LATCH_RESET);
 239         if (ret < 0) {
 240                 dev_err(data->dev,
 241                         "Error writing reg_motion_intr\n");
 242                 return ret;
 243         }
 244
 245         return 0;
 246 }
 247
 248 static int bmg160_set_power_state(struct bmg160_data *data, bool on)
 249 {
 250 #ifdef CONFIG_PM
 251         int ret;
 252
 253         if (on)
 254                 ret = pm_runtime_get_sync(data->dev);
 255         else {
 256                 pm_runtime_mark_last_busy(data->dev);
 257                 ret = pm_runtime_put_autosuspend(data->dev);
 258         }
 259
 260         if (ret < 0) {
 261                 dev_err(data->dev,
 262                         "Failed: bmg160_set_power_state for %d\n", on);
 263                 if (on)
 264                         pm_runtime_put_noidle(data->dev);
 265
 266                 return ret;
 267         }
 268 #endif
 269
 270         return 0;
 271 }
 272
 273 static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
 274                                              bool status)
 275 {
 276         int ret;
 277
 278         /* Enable/Disable INT_MAP0 mapping */
 279         ret = regmap_update_bits(data->regmap, BMG160_REG_INT_MAP_0,
 280                                  BMG160_INT_MAP_0_BIT_ANY,
 281                                  (status ? BMG160_INT_MAP_0_BIT_ANY : 0));
 282         if (ret < 0) {
 283                 dev_err(data->dev, "Error updating bits reg_int_map0\n");
 284                 return ret;
 285         }
 286
 287         /* Enable/Disable slope interrupts */
 288         if (status) {
 289                 /* Update slope thres */
 290                 ret = regmap_write(data->regmap, BMG160_REG_SLOPE_THRES,
 291                                    data->slope_thres);
 292                 if (ret < 0) {
 293                         dev_err(data->dev,
 294                                 "Error writing reg_slope_thres\n");
 295                         return ret;
 296                 }
 297
 298                 ret = regmap_write(data->regmap, BMG160_REG_MOTION_INTR,
 299                                    BMG160_INT_MOTION_X | BMG160_INT_MOTION_Y |
 300                                    BMG160_INT_MOTION_Z);
 301                 if (ret < 0) {
 302                         dev_err(data->dev,
 303                                 "Error writing reg_motion_intr\n");
 304                         return ret;
 305                 }
 306
 307                 /*
 308                  * New data interrupt is always non-latched,
 309                  * which will have higher priority, so no need
 310                  * to set latched mode, we will be flooded anyway with INTR
 311                  */
 312                 if (!data->dready_trigger_on) {
 313                         ret = regmap_write(data->regmap,
 314                                            BMG160_REG_INT_RST_LATCH,
 315                                            BMG160_INT_MODE_LATCH_INT |
 316                                            BMG160_INT_MODE_LATCH_RESET);
 317                         if (ret < 0) {
 318                                 dev_err(data->dev,
 319                                         "Error writing reg_rst_latch\n");
 320                                 return ret;
 321                         }
 322                 }
 323
 324                 ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0,
 325                                    BMG160_DATA_ENABLE_INT);
 326
 327         } else {
 328                 ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0, 0);
 329         }
 330
 331         if (ret < 0) {
 332                 dev_err(data->dev, "Error writing reg_int_en0\n");
 333                 return ret;
 334         }
 335
 336         return 0;
 337 }
 338
 339 static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
 340                                            bool status)
 341 {
 342         int ret;
 343
 344         /* Enable/Disable INT_MAP1 mapping */
 345         ret = regmap_update_bits(data->regmap, BMG160_REG_INT_MAP_1,
 346                                  BMG160_INT_MAP_1_BIT_NEW_DATA,
 347                                  (status ? BMG160_INT_MAP_1_BIT_NEW_DATA : 0));
 348         if (ret < 0) {
 349                 dev_err(data->dev, "Error updating bits in reg_int_map1\n");
 350                 return ret;
 351         }
 352
 353         if (status) {
 354                 ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
 355                                    BMG160_INT_MODE_NON_LATCH_INT |
 356                                    BMG160_INT_MODE_LATCH_RESET);
 357                 if (ret < 0) {
 358                         dev_err(data->dev,
 359                                 "Error writing reg_rst_latch\n");
 360                                 return ret;
 361                 }
 362
 363                 ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0,
 364                                    BMG160_DATA_ENABLE_INT);
 365
 366         } else {
 367                 /* Restore interrupt mode */
 368                 ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
 369                                    BMG160_INT_MODE_LATCH_INT |
 370                                    BMG160_INT_MODE_LATCH_RESET);
 371                 if (ret < 0) {
 372                         dev_err(data->dev,
 373                                 "Error writing reg_rst_latch\n");
 374                                 return ret;
 375                 }
 376
 377                 ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0, 0);
 378         }
 379
 380         if (ret < 0) {
 381                 dev_err(data->dev, "Error writing reg_int_en0\n");
 382                 return ret;
 383         }
 384
 385         return 0;
 386 }
 387
 388 static int bmg160_get_bw(struct bmg160_data *data, int *val)
 389 {
 390         int i;
 391
 392         for (i = 0; i < ARRAY_SIZE(bmg160_samp_freq_table); ++i) {
 393                 if (bmg160_samp_freq_table[i].bw_bits == data->bw_bits) {
 394                         *val = bmg160_samp_freq_table[i].val;
 395                         return IIO_VAL_INT;
 396                 }
 397         }
 398
 399         return -EINVAL;
 400 }
 401
 402 static int bmg160_set_scale(struct bmg160_data *data, int val)
 403 {
 404         int ret, i;
 405
 406         for (i = 0; i < ARRAY_SIZE(bmg160_scale_table); ++i) {
 407                 if (bmg160_scale_table[i].scale == val) {
 408                         ret = regmap_write(data->regmap, BMG160_REG_RANGE,
 409                                            bmg160_scale_table[i].dps_range);
 410                         if (ret < 0) {
 411                                 dev_err(data->dev,
 412                                         "Error writing reg_range\n");
 413                                 return ret;
 414                         }
 415                         data->dps_range = bmg160_scale_table[i].dps_range;
 416                         return 0;
 417                 }
 418         }
 419
 420         return -EINVAL;
 421 }
 422
 423 static int bmg160_get_temp(struct bmg160_data *data, int *val)
 424 {
 425         int ret;
 426         unsigned int raw_val;
 427
 428         mutex_lock(&data->mutex);
 429         ret = bmg160_set_power_state(data, true);
 430         if (ret < 0) {
 431                 mutex_unlock(&data->mutex);
 432                 return ret;
 433         }
 434
 435         ret = regmap_read(data->regmap, BMG160_REG_TEMP, &raw_val);
 436         if (ret < 0) {
 437                 dev_err(data->dev, "Error reading reg_temp\n");
 438                 bmg160_set_power_state(data, false);
 439                 mutex_unlock(&data->mutex);
 440                 return ret;
 441         }
 442
 443         *val = sign_extend32(raw_val, 7);
 444         ret = bmg160_set_power_state(data, false);
 445         mutex_unlock(&data->mutex);
 446         if (ret < 0)
 447                 return ret;
 448
 449         return IIO_VAL_INT;
 450 }
 451
 452 static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
 453 {
 454         int ret;
 455         unsigned int raw_val;
 456
 457         mutex_lock(&data->mutex);
 458         ret = bmg160_set_power_state(data, true);
 459         if (ret < 0) {
 460                 mutex_unlock(&data->mutex);
 461                 return ret;
 462         }
 463
 464         ret = regmap_bulk_read(data->regmap, BMG160_AXIS_TO_REG(axis), &raw_val,
 465                                2);
 466         if (ret < 0) {
 467                 dev_err(data->dev, "Error reading axis %d\n", axis);
 468                 bmg160_set_power_state(data, false);
 469                 mutex_unlock(&data->mutex);
 470                 return ret;
 471         }
 472
 473         *val = sign_extend32(raw_val, 15);
 474         ret = bmg160_set_power_state(data, false);
 475         mutex_unlock(&data->mutex);
 476         if (ret < 0)
 477                 return ret;
 478
 479         return IIO_VAL_INT;
 480 }
 481
 482 static int bmg160_read_raw(struct iio_dev *indio_dev,
 483                            struct iio_chan_spec const *chan,
 484                            int *val, int *val2, long mask)
 485 {
 486         struct bmg160_data *data = iio_priv(indio_dev);
 487         int ret;
 488
 489         switch (mask) {
 490         case IIO_CHAN_INFO_RAW:
 491                 switch (chan->type) {
 492                 case IIO_TEMP:
 493                         return bmg160_get_temp(data, val);
 494                 case IIO_ANGL_VEL:
 495                         if (iio_buffer_enabled(indio_dev))
 496                                 return -EBUSY;
 497                         else
 498                                 return bmg160_get_axis(data, chan->scan_index,
 499                                                        val);
 500                 default:
 501                         return -EINVAL;
 502                 }
 503         case IIO_CHAN_INFO_OFFSET:
 504                 if (chan->type == IIO_TEMP) {
 505                         *val = BMG160_TEMP_CENTER_VAL;
 506                         return IIO_VAL_INT;
 507                 } else
 508                         return -EINVAL;
 509         case IIO_CHAN_INFO_SCALE:
 510                 *val = 0;
 511                 switch (chan->type) {
 512                 case IIO_TEMP:
 513                         *val2 = 500000;
 514                         return IIO_VAL_INT_PLUS_MICRO;
 515                 case IIO_ANGL_VEL:
 516                 {
 517                         int i;
 518
 519                         for (i = 0; i < ARRAY_SIZE(bmg160_scale_table); ++i) {
 520                                 if (bmg160_scale_table[i].dps_range ==
 521                                                         data->dps_range) {
 522                                         *val2 = bmg160_scale_table[i].scale;
 523                                         return IIO_VAL_INT_PLUS_MICRO;
 524                                 }
 525                         }
 526                         return -EINVAL;
 527                 }
 528                 default:
 529                         return -EINVAL;
 530                 }
 531         case IIO_CHAN_INFO_SAMP_FREQ:
 532                 *val2 = 0;
 533                 mutex_lock(&data->mutex);
 534                 ret = bmg160_get_bw(data, val);
 535                 mutex_unlock(&data->mutex);
 536                 return ret;
 537         default:
 538                 return -EINVAL;
 539         }
 540 }
 541
 542 static int bmg160_write_raw(struct iio_dev *indio_dev,
 543                             struct iio_chan_spec const *chan,
 544                             int val, int val2, long mask)
 545 {
 546         struct bmg160_data *data = iio_priv(indio_dev);
 547         int ret;
 548
 549         switch (mask) {
 550         case IIO_CHAN_INFO_SAMP_FREQ:
 551                 mutex_lock(&data->mutex);
 552                 /*
 553                  * Section 4.2 of spec
 554                  * In suspend mode, the only supported operations are reading
 555                  * registers as well as writing to the (0x14) softreset
 556                  * register. Since we will be in suspend mode by default, change
 557                  * mode to power on for other writes.
 558                  */
 559                 ret = bmg160_set_power_state(data, true);
 560                 if (ret < 0) {
 561                         mutex_unlock(&data->mutex);
 562                         return ret;
 563                 }
 564                 ret = bmg160_set_bw(data, val);
 565                 if (ret < 0) {
 566                         bmg160_set_power_state(data, false);
 567                         mutex_unlock(&data->mutex);
 568                         return ret;
 569                 }
 570                 ret = bmg160_set_power_state(data, false);
 571                 mutex_unlock(&data->mutex);
 572                 return ret;
 573         case IIO_CHAN_INFO_SCALE:
 574                 if (val)
 575                         return -EINVAL;
 576
 577                 mutex_lock(&data->mutex);
 578                 /* Refer to comments above for the suspend mode ops */
 579                 ret = bmg160_set_power_state(data, true);
 580                 if (ret < 0) {
 581                         mutex_unlock(&data->mutex);
 582                         return ret;
 583                 }
 584                 ret = bmg160_set_scale(data, val2);
 585                 if (ret < 0) {
 586                         bmg160_set_power_state(data, false);
 587                         mutex_unlock(&data->mutex);
 588                         return ret;
 589                 }
 590                 ret = bmg160_set_power_state(data, false);
 591                 mutex_unlock(&data->mutex);
 592                 return ret;
 593         default:
 594                 return -EINVAL;
 595         }
 596
 597         return -EINVAL;
 598 }
 599
 600 static int bmg160_read_event(struct iio_dev *indio_dev,
 601                              const struct iio_chan_spec *chan,
 602                              enum iio_event_type type,
 603                              enum iio_event_direction dir,
 604                              enum iio_event_info info,
 605                              int *val, int *val2)
 606 {
 607         struct bmg160_data *data = iio_priv(indio_dev);
 608
 609         *val2 = 0;
 610         switch (info) {
 611         case IIO_EV_INFO_VALUE:
 612                 *val = data->slope_thres & BMG160_SLOPE_THRES_MASK;
 613                 break;
 614         default:
 615                 return -EINVAL;
 616         }
 617
 618         return IIO_VAL_INT;
 619 }
 620
 621 static int bmg160_write_event(struct iio_dev *indio_dev,
 622                               const struct iio_chan_spec *chan,
 623                               enum iio_event_type type,
 624                               enum iio_event_direction dir,
 625                               enum iio_event_info info,
 626                               int val, int val2)
 627 {
 628         struct bmg160_data *data = iio_priv(indio_dev);
 629
 630         switch (info) {
 631         case IIO_EV_INFO_VALUE:
 632                 if (data->ev_enable_state)
 633                         return -EBUSY;
 634                 data->slope_thres &= ~BMG160_SLOPE_THRES_MASK;
 635                 data->slope_thres |= (val & BMG160_SLOPE_THRES_MASK);
 636                 break;
 637         default:
 638                 return -EINVAL;
 639         }
 640
 641         return 0;
 642 }
 643
 644 static int bmg160_read_event_config(struct iio_dev *indio_dev,
 645                                     const struct iio_chan_spec *chan,
 646                                     enum iio_event_type type,
 647                                     enum iio_event_direction dir)
 648 {
 649
 650         struct bmg160_data *data = iio_priv(indio_dev);
 651
 652         return data->ev_enable_state;
 653 }
 654
 655 static int bmg160_write_event_config(struct iio_dev *indio_dev,
 656                                      const struct iio_chan_spec *chan,
 657                                      enum iio_event_type type,
 658                                      enum iio_event_direction dir,
 659                                      int state)
 660 {
 661         struct bmg160_data *data = iio_priv(indio_dev);
 662         int ret;
 663
 664         if (state && data->ev_enable_state)
 665                 return 0;
 666
 667         mutex_lock(&data->mutex);
 668
 669         if (!state && data->motion_trigger_on) {
 670                 data->ev_enable_state = 0;
 671                 mutex_unlock(&data->mutex);
 672                 return 0;
 673         }
 674         /*
 675          * We will expect the enable and disable to do operation in
 676          * in reverse order. This will happen here anyway as our
 677          * resume operation uses sync mode runtime pm calls, the
 678          * suspend operation will be delayed by autosuspend delay
 679          * So the disable operation will still happen in reverse of
 680          * enable operation. When runtime pm is disabled the mode
 681          * is always on so sequence doesn't matter
 682          */
 683         ret = bmg160_set_power_state(data, state);
 684         if (ret < 0) {
 685                 mutex_unlock(&data->mutex);
 686                 return ret;
 687         }
 688
 689         ret =  bmg160_setup_any_motion_interrupt(data, state);
 690         if (ret < 0) {
 691                 bmg160_set_power_state(data, false);
 692                 mutex_unlock(&data->mutex);
 693                 return ret;
 694         }
 695
 696         data->ev_enable_state = state;
 697         mutex_unlock(&data->mutex);
 698
 699         return 0;
 700 }
 701
 702 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("100 200 400 1000 2000");
 703
 704 static IIO_CONST_ATTR(in_anglvel_scale_available,
 705                       "0.001065 0.000532 0.000266 0.000133 0.000066");
 706
 707 static struct attribute *bmg160_attributes[] = {
 708         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 709         &iio_const_attr_in_anglvel_scale_available.dev_attr.attr,
 710         NULL,
 711 };
 712
 713 static const struct attribute_group bmg160_attrs_group = {
 714         .attrs = bmg160_attributes,
 715 };
 716
 717 static const struct iio_event_spec bmg160_event = {
 718                 .type = IIO_EV_TYPE_ROC,
 719                 .dir = IIO_EV_DIR_EITHER,
 720                 .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) |
 721                                        BIT(IIO_EV_INFO_ENABLE)
 722 };
 723
 724 #define BMG160_CHANNEL(_axis) {                                 \
 725         .type = IIO_ANGL_VEL,                                           \
 726         .modified = 1,                                                  \
 727         .channel2 = IIO_MOD_##_axis,                                    \
 728         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),                   \
 729         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |          \
 730                                     BIT(IIO_CHAN_INFO_SAMP_FREQ),       \
 731         .scan_index = AXIS_##_axis,                                     \
 732         .scan_type = {                                                  \
 733                 .sign = 's',                                            \
 734                 .realbits = 16,                                 \
 735                 .storagebits = 16,                                      \
 736         },                                                              \
 737         .event_spec = &bmg160_event,                                    \
 738         .num_event_specs = 1                                            \
 739 }
 740
 741 static const struct iio_chan_spec bmg160_channels[] = {
 742         {
 743                 .type = IIO_TEMP,
 744                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 745                                       BIT(IIO_CHAN_INFO_SCALE) |
 746                                       BIT(IIO_CHAN_INFO_OFFSET),
 747                 .scan_index = -1,
 748         },
 749         BMG160_CHANNEL(X),
 750         BMG160_CHANNEL(Y),
 751         BMG160_CHANNEL(Z),
 752         IIO_CHAN_SOFT_TIMESTAMP(3),
 753 };
 754
 755 static const struct iio_info bmg160_info = {
 756         .attrs                  = &bmg160_attrs_group,
 757         .read_raw               = bmg160_read_raw,
 758         .write_raw              = bmg160_write_raw,
 759         .read_event_value       = bmg160_read_event,
 760         .write_event_value      = bmg160_write_event,
 761         .write_event_config     = bmg160_write_event_config,
 762         .read_event_config      = bmg160_read_event_config,
 763         .driver_module          = THIS_MODULE,
 764 };
 765
 766 static irqreturn_t bmg160_trigger_handler(int irq, void *p)
 767 {
 768         struct iio_poll_func *pf = p;
 769         struct iio_dev *indio_dev = pf->indio_dev;
 770         struct bmg160_data *data = iio_priv(indio_dev);
 771         int bit, ret, i = 0;
 772         unsigned int val;
 773
 774         mutex_lock(&data->mutex);
 775         for_each_set_bit(bit, indio_dev->active_scan_mask,
 776                          indio_dev->masklength) {
 777                 ret = regmap_bulk_read(data->regmap, BMG160_AXIS_TO_REG(bit),
 778                                        &val, 2);
 779                 if (ret < 0) {
 780                         mutex_unlock(&data->mutex);
 781                         goto err;
 782                 }
 783                 data->buffer[i++] = ret;
 784         }
 785         mutex_unlock(&data->mutex);
 786
 787         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
 788                                            pf->timestamp);
 789 err:
 790         iio_trigger_notify_done(indio_dev->trig);
 791
 792         return IRQ_HANDLED;
 793 }
 794
 795 static int bmg160_trig_try_reen(struct iio_trigger *trig)
 796 {
 797         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 798         struct bmg160_data *data = iio_priv(indio_dev);
 799         int ret;
 800
 801         /* new data interrupts don't need ack */
 802         if (data->dready_trigger_on)
 803                 return 0;
 804
 805         /* Set latched mode interrupt and clear any latched interrupt */
 806         ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
 807                            BMG160_INT_MODE_LATCH_INT |
 808                            BMG160_INT_MODE_LATCH_RESET);
 809         if (ret < 0) {
 810                 dev_err(data->dev, "Error writing reg_rst_latch\n");
 811                 return ret;
 812         }
 813
 814         return 0;
 815 }
 816
 817 static int bmg160_data_rdy_trigger_set_state(struct iio_trigger *trig,
 818                                              bool state)
 819 {
 820         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 821         struct bmg160_data *data = iio_priv(indio_dev);
 822         int ret;
 823
 824         mutex_lock(&data->mutex);
 825
 826         if (!state && data->ev_enable_state && data->motion_trigger_on) {
 827                 data->motion_trigger_on = false;
 828                 mutex_unlock(&data->mutex);
 829                 return 0;
 830         }
 831
 832         /*
 833          * Refer to comment in bmg160_write_event_config for
 834          * enable/disable operation order
 835          */
 836         ret = bmg160_set_power_state(data, state);
 837         if (ret < 0) {
 838                 mutex_unlock(&data->mutex);
 839                 return ret;
 840         }
 841         if (data->motion_trig == trig)
 842                 ret =  bmg160_setup_any_motion_interrupt(data, state);
 843         else
 844                 ret = bmg160_setup_new_data_interrupt(data, state);
 845         if (ret < 0) {
 846                 bmg160_set_power_state(data, false);
 847                 mutex_unlock(&data->mutex);
 848                 return ret;
 849         }
 850         if (data->motion_trig == trig)
 851                 data->motion_trigger_on = state;
 852         else
 853                 data->dready_trigger_on = state;
 854
 855         mutex_unlock(&data->mutex);
 856
 857         return 0;
 858 }
 859
 860 static const struct iio_trigger_ops bmg160_trigger_ops = {
 861         .set_trigger_state = bmg160_data_rdy_trigger_set_state,
 862         .try_reenable = bmg160_trig_try_reen,
 863         .owner = THIS_MODULE,
 864 };
 865
 866 static irqreturn_t bmg160_event_handler(int irq, void *private)
 867 {
 868         struct iio_dev *indio_dev = private;
 869         struct bmg160_data *data = iio_priv(indio_dev);
 870         int ret;
 871         int dir;
 872         unsigned int val;
 873
 874         ret = regmap_read(data->regmap, BMG160_REG_INT_STATUS_2, &val);
 875         if (ret < 0) {
 876                 dev_err(data->dev, "Error reading reg_int_status2\n");
 877                 goto ack_intr_status;
 878         }
 879
 880         if (val & 0x08)
 881                 dir = IIO_EV_DIR_RISING;
 882         else
 883                 dir = IIO_EV_DIR_FALLING;
 884
 885         if (val & BMG160_ANY_MOTION_BIT_X)
 886                 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
 887                                                         0,
 888                                                         IIO_MOD_X,
 889                                                         IIO_EV_TYPE_ROC,
 890                                                         dir),
 891                                                         iio_get_time_ns());
 892         if (val & BMG160_ANY_MOTION_BIT_Y)
 893                 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
 894                                                         0,
 895                                                         IIO_MOD_Y,
 896                                                         IIO_EV_TYPE_ROC,
 897                                                         dir),
 898                                                         iio_get_time_ns());
 899         if (val & BMG160_ANY_MOTION_BIT_Z)
 900                 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
 901                                                         0,
 902                                                         IIO_MOD_Z,
 903                                                         IIO_EV_TYPE_ROC,
 904                                                         dir),
 905                                                         iio_get_time_ns());
 906
 907 ack_intr_status:
 908         if (!data->dready_trigger_on) {
 909                 ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
 910                                    BMG160_INT_MODE_LATCH_INT |
 911                                    BMG160_INT_MODE_LATCH_RESET);
 912                 if (ret < 0)
 913                         dev_err(data->dev,
 914                                 "Error writing reg_rst_latch\n");
 915         }
 916
 917         return IRQ_HANDLED;
 918 }
 919
 920 static irqreturn_t bmg160_data_rdy_trig_poll(int irq, void *private)
 921 {
 922         struct iio_dev *indio_dev = private;
 923         struct bmg160_data *data = iio_priv(indio_dev);
 924
 925         if (data->dready_trigger_on)
 926                 iio_trigger_poll(data->dready_trig);
 927         else if (data->motion_trigger_on)
 928                 iio_trigger_poll(data->motion_trig);
 929
 930         if (data->ev_enable_state)
 931                 return IRQ_WAKE_THREAD;
 932         else
 933                 return IRQ_HANDLED;
 934
 935 }
 936
 937 static int bmg160_buffer_preenable(struct iio_dev *indio_dev)
 938 {
 939         struct bmg160_data *data = iio_priv(indio_dev);
 940
 941         return bmg160_set_power_state(data, true);
 942 }
 943
 944 static int bmg160_buffer_postdisable(struct iio_dev *indio_dev)
 945 {
 946         struct bmg160_data *data = iio_priv(indio_dev);
 947
 948         return bmg160_set_power_state(data, false);
 949 }
 950
 951 static const struct iio_buffer_setup_ops bmg160_buffer_setup_ops = {
 952         .preenable = bmg160_buffer_preenable,
 953         .postenable = iio_triggered_buffer_postenable,
 954         .predisable = iio_triggered_buffer_predisable,
 955         .postdisable = bmg160_buffer_postdisable,
 956 };
 957
 958 static int bmg160_gpio_probe(struct bmg160_data *data)
 959
 960 {
 961         struct device *dev;
 962         struct gpio_desc *gpio;
 963
 964         dev = data->dev;
 965
 966         /* data ready gpio interrupt pin */
 967         gpio = devm_gpiod_get_index(dev, BMG160_GPIO_NAME, 0, GPIOD_IN);
 968         if (IS_ERR(gpio)) {
 969                 dev_err(dev, "acpi gpio get index failed\n");
 970                 return PTR_ERR(gpio);
 971         }
 972
 973         data->irq = gpiod_to_irq(gpio);
 974
 975         dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio),
 976                 data->irq);
 977
 978         return 0;
 979 }
 980
 981 static const char *bmg160_match_acpi_device(struct device *dev)
 982 {
 983         const struct acpi_device_id *id;
 984
 985         id = acpi_match_device(dev->driver->acpi_match_table, dev);
 986         if (!id)
 987                 return NULL;
 988
 989         return dev_name(dev);
 990 }
 991
 992 int bmg160_core_probe(struct device *dev, struct regmap *regmap, int irq,
 993                       const char *name)
 994 {
 995         struct bmg160_data *data;
 996         struct iio_dev *indio_dev;
 997         int ret;
 998
 999         indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
1000         if (!indio_dev)
1001                 return -ENOMEM;
1002
1003         data = iio_priv(indio_dev);
1004         dev_set_drvdata(dev, indio_dev);
1005         data->dev = dev;
1006         data->irq = irq;
1007         data->regmap = regmap;
1008
1009         ret = bmg160_chip_init(data);
1010         if (ret < 0)
1011                 return ret;
1012
1013         mutex_init(&data->mutex);
1014
1015         if (ACPI_HANDLE(dev))
1016                 name = bmg160_match_acpi_device(dev);
1017
1018         indio_dev->dev.parent = dev;
1019         indio_dev->channels = bmg160_channels;
1020         indio_dev->num_channels = ARRAY_SIZE(bmg160_channels);
1021         indio_dev->name = name;
1022         indio_dev->modes = INDIO_DIRECT_MODE;
1023         indio_dev->info = &bmg160_info;
1024
1025         if (data->irq <= 0)
1026                 bmg160_gpio_probe(data);
1027
1028         if (data->irq > 0) {
1029                 ret = devm_request_threaded_irq(dev,
1030                                                 data->irq,
1031                                                 bmg160_data_rdy_trig_poll,
1032                                                 bmg160_event_handler,
1033                                                 IRQF_TRIGGER_RISING,
1034                                                 BMG160_IRQ_NAME,
1035                                                 indio_dev);
1036                 if (ret)
1037                         return ret;
1038
1039                 data->dready_trig = devm_iio_trigger_alloc(dev,
1040                                                            "%s-dev%d",
1041                                                            indio_dev->name,
1042                                                            indio_dev->id);
1043                 if (!data->dready_trig)
1044                         return -ENOMEM;
1045
1046                 data->motion_trig = devm_iio_trigger_alloc(dev,
1047                                                           "%s-any-motion-dev%d",
1048                                                           indio_dev->name,
1049                                                           indio_dev->id);
1050                 if (!data->motion_trig)
1051                         return -ENOMEM;
1052
1053                 data->dready_trig->dev.parent = dev;
1054                 data->dready_trig->ops = &bmg160_trigger_ops;
1055                 iio_trigger_set_drvdata(data->dready_trig, indio_dev);
1056                 ret = iio_trigger_register(data->dready_trig);
1057                 if (ret)
1058                         return ret;
1059
1060                 data->motion_trig->dev.parent = dev;
1061                 data->motion_trig->ops = &bmg160_trigger_ops;
1062                 iio_trigger_set_drvdata(data->motion_trig, indio_dev);
1063                 ret = iio_trigger_register(data->motion_trig);
1064                 if (ret) {
1065                         data->motion_trig = NULL;
1066                         goto err_trigger_unregister;
1067                 }
1068         }
1069
1070         ret = iio_triggered_buffer_setup(indio_dev,
1071                                          iio_pollfunc_store_time,
1072                                          bmg160_trigger_handler,
1073                                          &bmg160_buffer_setup_ops);
1074         if (ret < 0) {
1075                 dev_err(dev,
1076                         "iio triggered buffer setup failed\n");
1077                 goto err_trigger_unregister;
1078         }
1079
1080         ret = iio_device_register(indio_dev);
1081         if (ret < 0) {
1082                 dev_err(dev, "unable to register iio device\n");
1083                 goto err_buffer_cleanup;
1084         }
1085
1086         ret = pm_runtime_set_active(dev);
1087         if (ret)
1088                 goto err_iio_unregister;
1089
1090         pm_runtime_enable(dev);
1091         pm_runtime_set_autosuspend_delay(dev,
1092                                          BMG160_AUTO_SUSPEND_DELAY_MS);
1093         pm_runtime_use_autosuspend(dev);
1094
1095         return 0;
1096
1097 err_iio_unregister:
1098         iio_device_unregister(indio_dev);
1099 err_buffer_cleanup:
1100         iio_triggered_buffer_cleanup(indio_dev);
1101 err_trigger_unregister:
1102         if (data->dready_trig)
1103                 iio_trigger_unregister(data->dready_trig);
1104         if (data->motion_trig)
1105                 iio_trigger_unregister(data->motion_trig);
1106
1107         return ret;
1108 }
1109 EXPORT_SYMBOL_GPL(bmg160_core_probe);
1110
1111 void bmg160_core_remove(struct device *dev)
1112 {
1113         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1114         struct bmg160_data *data = iio_priv(indio_dev);
1115
1116         pm_runtime_disable(dev);
1117         pm_runtime_set_suspended(dev);
1118         pm_runtime_put_noidle(dev);
1119
1120         iio_device_unregister(indio_dev);
1121         iio_triggered_buffer_cleanup(indio_dev);
1122
1123         if (data->dready_trig) {
1124                 iio_trigger_unregister(data->dready_trig);
1125                 iio_trigger_unregister(data->motion_trig);
1126         }
1127
1128         mutex_lock(&data->mutex);
1129         bmg160_set_mode(data, BMG160_MODE_DEEP_SUSPEND);
1130         mutex_unlock(&data->mutex);
1131 }
1132 EXPORT_SYMBOL_GPL(bmg160_core_remove);
1133
1134 #ifdef CONFIG_PM_SLEEP
1135 static int bmg160_suspend(struct device *dev)
1136 {
1137         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1138         struct bmg160_data *data = iio_priv(indio_dev);
1139
1140         mutex_lock(&data->mutex);
1141         bmg160_set_mode(data, BMG160_MODE_SUSPEND);
1142         mutex_unlock(&data->mutex);
1143
1144         return 0;
1145 }
1146
1147 static int bmg160_resume(struct device *dev)
1148 {
1149         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1150         struct bmg160_data *data = iio_priv(indio_dev);
1151
1152         mutex_lock(&data->mutex);
1153         if (data->dready_trigger_on || data->motion_trigger_on ||
1154                                                         data->ev_enable_state)
1155                 bmg160_set_mode(data, BMG160_MODE_NORMAL);
1156         mutex_unlock(&data->mutex);
1157
1158         return 0;
1159 }
1160 #endif
1161
1162 #ifdef CONFIG_PM
1163 static int bmg160_runtime_suspend(struct device *dev)
1164 {
1165         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1166         struct bmg160_data *data = iio_priv(indio_dev);
1167         int ret;
1168
1169         ret = bmg160_set_mode(data, BMG160_MODE_SUSPEND);
1170         if (ret < 0) {
1171                 dev_err(data->dev, "set mode failed\n");
1172                 return -EAGAIN;
1173         }
1174
1175         return 0;
1176 }
1177
1178 static int bmg160_runtime_resume(struct device *dev)
1179 {
1180         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1181         struct bmg160_data *data = iio_priv(indio_dev);
1182         int ret;
1183
1184         ret = bmg160_set_mode(data, BMG160_MODE_NORMAL);
1185         if (ret < 0)
1186                 return ret;
1187
1188         msleep_interruptible(BMG160_MAX_STARTUP_TIME_MS);
1189
1190         return 0;
1191 }
1192 #endif
1193
1194 const struct dev_pm_ops bmg160_pm_ops = {
1195         SET_SYSTEM_SLEEP_PM_OPS(bmg160_suspend, bmg160_resume)
1196         SET_RUNTIME_PM_OPS(bmg160_runtime_suspend,
1197                            bmg160_runtime_resume, NULL)
1198 };
1199 EXPORT_SYMBOL_GPL(bmg160_pm_ops);
1200
1201 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
1202 MODULE_LICENSE("GPL v2");
1203 MODULE_DESCRIPTION("BMG160 Gyro driver");