drivers/iio/light/apds9960.c

   1 /*
   2  * apds9960.c - Support for Avago APDS9960 gesture/RGB/ALS/proximity sensor
   3  *
   4  * Copyright (C) 2015 Matt Ranostay <mranostay@gmail.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  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU General Public License for more details.
  15  *
  16  * TODO: gesture + proximity calib offsets
  17  */
  18
  19 #include <linux/module.h>
  20 #include <linux/init.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/delay.h>
  23 #include <linux/mutex.h>
  24 #include <linux/err.h>
  25 #include <linux/irq.h>
  26 #include <linux/gpio.h>
  27 #include <linux/i2c.h>
  28 #include <linux/pm_runtime.h>
  29 #include <linux/regmap.h>
  30 #include <linux/iio/iio.h>
  31 #include <linux/iio/buffer.h>
  32 #include <linux/iio/events.h>
  33 #include <linux/iio/kfifo_buf.h>
  34 #include <linux/iio/sysfs.h>
  35 #include <linux/of_gpio.h>
  36
  37 #define APDS9960_REGMAP_NAME    "apds9960_regmap"
  38 #define APDS9960_DRV_NAME       "apds9960"
  39
  40 #define APDS9960_REG_RAM_START  0x00
  41 #define APDS9960_REG_RAM_END    0x7f
  42
  43 #define APDS9960_REG_ENABLE     0x80
  44 #define APDS9960_REG_ATIME      0x81
  45 #define APDS9960_REG_WTIME      0x83
  46
  47 #define APDS9960_REG_AILTL      0x84
  48 #define APDS9960_REG_AILTH      0x85
  49 #define APDS9960_REG_AIHTL      0x86
  50 #define APDS9960_REG_AIHTH      0x87
  51
  52 #define APDS9960_REG_PILT       0x89
  53 #define APDS9960_REG_PIHT       0x8b
  54 #define APDS9960_REG_PERS       0x8c
  55
  56 #define APDS9960_REG_CONFIG_1   0x8d
  57 #define APDS9960_REG_PPULSE     0x8e
  58
  59 #define APDS9960_REG_CONTROL    0x8f
  60 #define APDS9960_REG_CONTROL_AGAIN_MASK         0x03
  61 #define APDS9960_REG_CONTROL_PGAIN_MASK         0x0c
  62 #define APDS9960_REG_CONTROL_AGAIN_MASK_SHIFT   0
  63 #define APDS9960_REG_CONTROL_PGAIN_MASK_SHIFT   2
  64
  65 #define APDS9960_REG_CONFIG_2   0x90
  66 #define APDS9960_REG_CONFIG_2_GGAIN_MASK        0x60
  67 #define APDS9960_REG_CONFIG_2_GGAIN_MASK_SHIFT  5
  68
  69 #define APDS9960_REG_ID         0x92
  70
  71 #define APDS9960_REG_STATUS     0x93
  72 #define APDS9960_REG_STATUS_PS_INT      BIT(5)
  73 #define APDS9960_REG_STATUS_ALS_INT     BIT(4)
  74 #define APDS9960_REG_STATUS_GINT        BIT(2)
  75
  76 #define APDS9960_REG_PDATA      0x9c
  77 #define APDS9960_REG_POFFSET_UR 0x9d
  78 #define APDS9960_REG_POFFSET_DL 0x9e
  79 #define APDS9960_REG_CONFIG_3   0x9f
  80
  81 #define APDS9960_REG_GPENTH     0xa0
  82 #define APDS9960_REG_GEXTH      0xa1
  83
  84 #define APDS9960_REG_GCONF_1    0xa2
  85 #define APDS9960_REG_GCONF_1_GFIFO_THRES_MASK           0xc0
  86 #define APDS9960_REG_GCONF_1_GFIFO_THRES_MASK_SHIFT     6
  87
  88 #define APDS9960_REG_GCONF_2    0xa3
  89 #define APDS9960_REG_GOFFSET_U  0xa4
  90 #define APDS9960_REG_GOFFSET_D  0xa5
  91 #define APDS9960_REG_GPULSE     0xa6
  92 #define APDS9960_REG_GOFFSET_L  0xa7
  93 #define APDS9960_REG_GOFFSET_R  0xa9
  94 #define APDS9960_REG_GCONF_3    0xaa
  95
  96 #define APDS9960_REG_GCONF_4    0xab
  97 #define APDS9960_REG_GFLVL      0xae
  98 #define APDS9960_REG_GSTATUS    0xaf
  99
 100 #define APDS9960_REG_IFORCE     0xe4
 101 #define APDS9960_REG_PICLEAR    0xe5
 102 #define APDS9960_REG_CICLEAR    0xe6
 103 #define APDS9960_REG_AICLEAR    0xe7
 104
 105 #define APDS9960_DEFAULT_PERS   0x33
 106 #define APDS9960_DEFAULT_GPENTH 0x50
 107 #define APDS9960_DEFAULT_GEXTH  0x40
 108
 109 #define APDS9960_MAX_PXS_THRES_VAL      255
 110 #define APDS9960_MAX_ALS_THRES_VAL      0xffff
 111 #define APDS9960_MAX_INT_TIME_IN_US     1000000
 112
 113 enum apds9960_als_channel_idx {
 114         IDX_ALS_CLEAR, IDX_ALS_RED, IDX_ALS_GREEN, IDX_ALS_BLUE,
 115 };
 116
 117 #define APDS9960_REG_ALS_BASE   0x94
 118 #define APDS9960_REG_ALS_CHANNEL(_colour) \
 119         (APDS9960_REG_ALS_BASE + (IDX_ALS_##_colour * 2))
 120
 121 enum apds9960_gesture_channel_idx {
 122         IDX_DIR_UP, IDX_DIR_DOWN, IDX_DIR_LEFT, IDX_DIR_RIGHT,
 123 };
 124
 125 #define APDS9960_REG_GFIFO_BASE 0xfc
 126 #define APDS9960_REG_GFIFO_DIR(_dir) \
 127         (APDS9960_REG_GFIFO_BASE + IDX_DIR_##_dir)
 128
 129 struct apds9960_data {
 130         struct i2c_client *client;
 131         struct iio_dev *indio_dev;
 132         struct mutex lock;
 133
 134         /* regmap fields */
 135         struct regmap *regmap;
 136         struct regmap_field *reg_int_als;
 137         struct regmap_field *reg_int_ges;
 138         struct regmap_field *reg_int_pxs;
 139
 140         struct regmap_field *reg_enable_als;
 141         struct regmap_field *reg_enable_ges;
 142         struct regmap_field *reg_enable_pxs;
 143
 144         /* state */
 145         int als_int;
 146         int pxs_int;
 147         int gesture_mode_running;
 148
 149         /* gain values */
 150         int als_gain;
 151         int pxs_gain;
 152
 153         /* integration time value in us */
 154         int als_adc_int_us;
 155
 156         /* gesture buffer */
 157         u8 buffer[4]; /* 4 8-bit channels */
 158 };
 159
 160 static const struct reg_default apds9960_reg_defaults[] = {
 161         /* Default ALS integration time = 2.48ms */
 162         { APDS9960_REG_ATIME, 0xff },
 163 };
 164
 165 static const struct regmap_range apds9960_volatile_ranges[] = {
 166         regmap_reg_range(APDS9960_REG_STATUS,
 167                                 APDS9960_REG_PDATA),
 168         regmap_reg_range(APDS9960_REG_GFLVL,
 169                                 APDS9960_REG_GSTATUS),
 170         regmap_reg_range(APDS9960_REG_GFIFO_DIR(UP),
 171                                 APDS9960_REG_GFIFO_DIR(RIGHT)),
 172         regmap_reg_range(APDS9960_REG_IFORCE,
 173                                 APDS9960_REG_AICLEAR),
 174 };
 175
 176 static const struct regmap_access_table apds9960_volatile_table = {
 177         .yes_ranges     = apds9960_volatile_ranges,
 178         .n_yes_ranges   = ARRAY_SIZE(apds9960_volatile_ranges),
 179 };
 180
 181 static const struct regmap_range apds9960_precious_ranges[] = {
 182         regmap_reg_range(APDS9960_REG_RAM_START, APDS9960_REG_RAM_END),
 183 };
 184
 185 static const struct regmap_access_table apds9960_precious_table = {
 186         .yes_ranges     = apds9960_precious_ranges,
 187         .n_yes_ranges   = ARRAY_SIZE(apds9960_precious_ranges),
 188 };
 189
 190 static const struct regmap_range apds9960_readable_ranges[] = {
 191         regmap_reg_range(APDS9960_REG_ENABLE,
 192                                 APDS9960_REG_GSTATUS),
 193         regmap_reg_range(APDS9960_REG_GFIFO_DIR(UP),
 194                                 APDS9960_REG_GFIFO_DIR(RIGHT)),
 195 };
 196
 197 static const struct regmap_access_table apds9960_readable_table = {
 198         .yes_ranges     = apds9960_readable_ranges,
 199         .n_yes_ranges   = ARRAY_SIZE(apds9960_readable_ranges),
 200 };
 201
 202 static const struct regmap_range apds9960_writeable_ranges[] = {
 203         regmap_reg_range(APDS9960_REG_ENABLE, APDS9960_REG_CONFIG_2),
 204         regmap_reg_range(APDS9960_REG_POFFSET_UR, APDS9960_REG_GCONF_4),
 205         regmap_reg_range(APDS9960_REG_IFORCE, APDS9960_REG_AICLEAR),
 206 };
 207
 208 static const struct regmap_access_table apds9960_writeable_table = {
 209         .yes_ranges     = apds9960_writeable_ranges,
 210         .n_yes_ranges   = ARRAY_SIZE(apds9960_writeable_ranges),
 211 };
 212
 213 static const struct regmap_config apds9960_regmap_config = {
 214         .name = APDS9960_REGMAP_NAME,
 215         .reg_bits = 8,
 216         .val_bits = 8,
 217         .use_single_rw = 1,
 218
 219         .volatile_table = &apds9960_volatile_table,
 220         .precious_table = &apds9960_precious_table,
 221         .rd_table = &apds9960_readable_table,
 222         .wr_table = &apds9960_writeable_table,
 223
 224         .reg_defaults = apds9960_reg_defaults,
 225         .num_reg_defaults = ARRAY_SIZE(apds9960_reg_defaults),
 226         .max_register = APDS9960_REG_GFIFO_DIR(RIGHT),
 227         .cache_type = REGCACHE_RBTREE,
 228 };
 229
 230 static const struct iio_event_spec apds9960_pxs_event_spec[] = {
 231         {
 232                 .type = IIO_EV_TYPE_THRESH,
 233                 .dir = IIO_EV_DIR_RISING,
 234                 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
 235                         BIT(IIO_EV_INFO_ENABLE),
 236         },
 237         {
 238                 .type = IIO_EV_TYPE_THRESH,
 239                 .dir = IIO_EV_DIR_FALLING,
 240                 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
 241                         BIT(IIO_EV_INFO_ENABLE),
 242         },
 243 };
 244
 245 static const struct iio_event_spec apds9960_als_event_spec[] = {
 246         {
 247                 .type = IIO_EV_TYPE_THRESH,
 248                 .dir = IIO_EV_DIR_RISING,
 249                 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
 250                         BIT(IIO_EV_INFO_ENABLE),
 251         },
 252         {
 253                 .type = IIO_EV_TYPE_THRESH,
 254                 .dir = IIO_EV_DIR_FALLING,
 255                 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
 256                         BIT(IIO_EV_INFO_ENABLE),
 257         },
 258 };
 259
 260 #define APDS9960_GESTURE_CHANNEL(_dir, _si) { \
 261         .type = IIO_PROXIMITY, \
 262         .channel = _si + 1, \
 263         .scan_index = _si, \
 264         .indexed = 1, \
 265         .scan_type = { \
 266                 .sign = 'u', \
 267                 .realbits = 8, \
 268                 .storagebits = 8, \
 269         }, \
 270 }
 271
 272 #define APDS9960_INTENSITY_CHANNEL(_colour) { \
 273         .type = IIO_INTENSITY, \
 274         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
 275         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
 276                         BIT(IIO_CHAN_INFO_INT_TIME), \
 277         .channel2 = IIO_MOD_LIGHT_##_colour, \
 278         .address = APDS9960_REG_ALS_CHANNEL(_colour), \
 279         .modified = 1, \
 280         .scan_index = -1, \
 281 }
 282
 283 static const unsigned long apds9960_scan_masks[] = {0xf, 0};
 284
 285 static const struct iio_chan_spec apds9960_channels[] = {
 286         {
 287                 .type = IIO_PROXIMITY,
 288                 .address = APDS9960_REG_PDATA,
 289                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 290                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
 291                 .channel = 0,
 292                 .indexed = 0,
 293                 .scan_index = -1,
 294
 295                 .event_spec = apds9960_pxs_event_spec,
 296                 .num_event_specs = ARRAY_SIZE(apds9960_pxs_event_spec),
 297         },
 298         /* Gesture Sensor */
 299         APDS9960_GESTURE_CHANNEL(UP, 0),
 300         APDS9960_GESTURE_CHANNEL(DOWN, 1),
 301         APDS9960_GESTURE_CHANNEL(LEFT, 2),
 302         APDS9960_GESTURE_CHANNEL(RIGHT, 3),
 303         /* ALS */
 304         {
 305                 .type = IIO_INTENSITY,
 306                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 307                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |
 308                         BIT(IIO_CHAN_INFO_INT_TIME),
 309                 .channel2 = IIO_MOD_LIGHT_CLEAR,
 310                 .address = APDS9960_REG_ALS_CHANNEL(CLEAR),
 311                 .modified = 1,
 312                 .scan_index = -1,
 313
 314                 .event_spec = apds9960_als_event_spec,
 315                 .num_event_specs = ARRAY_SIZE(apds9960_als_event_spec),
 316         },
 317         /* RGB Sensor */
 318         APDS9960_INTENSITY_CHANNEL(RED),
 319         APDS9960_INTENSITY_CHANNEL(GREEN),
 320         APDS9960_INTENSITY_CHANNEL(BLUE),
 321 };
 322
 323 /* integration time in us */
 324 static const int apds9960_int_time[][2] = {
 325         { 28000, 246},
 326         {100000, 219},
 327         {200000, 182},
 328         {700000,   0}
 329 };
 330
 331 /* gain mapping */
 332 static const int apds9960_pxs_gain_map[] = {1, 2, 4, 8};
 333 static const int apds9960_als_gain_map[] = {1, 4, 16, 64};
 334
 335 static IIO_CONST_ATTR(proximity_scale_available, "1 2 4 8");
 336 static IIO_CONST_ATTR(intensity_scale_available, "1 4 16 64");
 337 static IIO_CONST_ATTR_INT_TIME_AVAIL("0.028 0.1 0.2 0.7");
 338
 339 static struct attribute *apds9960_attributes[] = {
 340         &iio_const_attr_proximity_scale_available.dev_attr.attr,
 341         &iio_const_attr_intensity_scale_available.dev_attr.attr,
 342         &iio_const_attr_integration_time_available.dev_attr.attr,
 343         NULL,
 344 };
 345
 346 static const struct attribute_group apds9960_attribute_group = {
 347         .attrs = apds9960_attributes,
 348 };
 349
 350 static const struct reg_field apds9960_reg_field_int_als =
 351                                 REG_FIELD(APDS9960_REG_ENABLE, 4, 4);
 352
 353 static const struct reg_field apds9960_reg_field_int_ges =
 354                                 REG_FIELD(APDS9960_REG_GCONF_4, 1, 1);
 355
 356 static const struct reg_field apds9960_reg_field_int_pxs =
 357                                 REG_FIELD(APDS9960_REG_ENABLE, 5, 5);
 358
 359 static const struct reg_field apds9960_reg_field_enable_als =
 360                                 REG_FIELD(APDS9960_REG_ENABLE, 1, 1);
 361
 362 static const struct reg_field apds9960_reg_field_enable_ges =
 363                                 REG_FIELD(APDS9960_REG_ENABLE, 6, 6);
 364
 365 static const struct reg_field apds9960_reg_field_enable_pxs =
 366                                 REG_FIELD(APDS9960_REG_ENABLE, 2, 2);
 367
 368 static int apds9960_set_it_time(struct apds9960_data *data, int val2)
 369 {
 370         int ret = -EINVAL;
 371         int idx;
 372
 373         for (idx = 0; idx < ARRAY_SIZE(apds9960_int_time); idx++) {
 374                 if (apds9960_int_time[idx][0] == val2) {
 375                         mutex_lock(&data->lock);
 376                         ret = regmap_write(data->regmap, APDS9960_REG_ATIME,
 377                                                  apds9960_int_time[idx][1]);
 378                         if (!ret)
 379                                 data->als_adc_int_us = val2;
 380                         mutex_unlock(&data->lock);
 381                         break;
 382                 }
 383         }
 384
 385         return ret;
 386 }
 387
 388 static int apds9960_set_pxs_gain(struct apds9960_data *data, int val)
 389 {
 390         int ret = -EINVAL;
 391         int idx;
 392
 393         for (idx = 0; idx < ARRAY_SIZE(apds9960_pxs_gain_map); idx++) {
 394                 if (apds9960_pxs_gain_map[idx] == val) {
 395                         /* pxs + gesture gains are mirrored */
 396                         mutex_lock(&data->lock);
 397                         ret = regmap_update_bits(data->regmap,
 398                                 APDS9960_REG_CONTROL,
 399                                 APDS9960_REG_CONTROL_PGAIN_MASK,
 400                                 idx << APDS9960_REG_CONTROL_PGAIN_MASK_SHIFT);
 401                         if (ret) {
 402                                 mutex_unlock(&data->lock);
 403                                 break;
 404                         }
 405
 406                         ret = regmap_update_bits(data->regmap,
 407                                 APDS9960_REG_CONFIG_2,
 408                                 APDS9960_REG_CONFIG_2_GGAIN_MASK,
 409                                 idx << APDS9960_REG_CONFIG_2_GGAIN_MASK_SHIFT);
 410                         if (!ret)
 411                                 data->pxs_gain = idx;
 412                         mutex_unlock(&data->lock);
 413                         break;
 414                 }
 415         }
 416
 417         return ret;
 418 }
 419
 420 static int apds9960_set_als_gain(struct apds9960_data *data, int val)
 421 {
 422         int ret = -EINVAL;
 423         int idx;
 424
 425         for (idx = 0; idx < ARRAY_SIZE(apds9960_als_gain_map); idx++) {
 426                 if (apds9960_als_gain_map[idx] == val) {
 427                         mutex_lock(&data->lock);
 428                         ret = regmap_update_bits(data->regmap,
 429                                         APDS9960_REG_CONTROL,
 430                                         APDS9960_REG_CONTROL_AGAIN_MASK, idx);
 431                         if (!ret)
 432                                 data->als_gain = idx;
 433                         mutex_unlock(&data->lock);
 434                         break;
 435                 }
 436         }
 437
 438         return ret;
 439 }
 440
 441 #ifdef CONFIG_PM
 442 static int apds9960_set_power_state(struct apds9960_data *data, bool on)
 443 {
 444         struct device *dev = &data->client->dev;
 445         int ret = 0;
 446
 447         mutex_lock(&data->lock);
 448
 449         if (on) {
 450                 int suspended;
 451
 452                 suspended = pm_runtime_suspended(dev);
 453                 ret = pm_runtime_get_sync(dev);
 454
 455                 /* Allow one integration cycle before allowing a reading */
 456                 if (suspended)
 457                         usleep_range(data->als_adc_int_us,
 458                                      APDS9960_MAX_INT_TIME_IN_US);
 459         } else {
 460                 pm_runtime_mark_last_busy(dev);
 461                 ret = pm_runtime_put_autosuspend(dev);
 462         }
 463
 464         mutex_unlock(&data->lock);
 465
 466         return ret;
 467 }
 468 #else
 469 static int apds9960_set_power_state(struct apds9960_data *data, bool on)
 470 {
 471         return 0;
 472 }
 473 #endif
 474
 475 static int apds9960_read_raw(struct iio_dev *indio_dev,
 476                              struct iio_chan_spec const *chan,
 477                              int *val, int *val2, long mask)
 478 {
 479         struct apds9960_data *data = iio_priv(indio_dev);
 480         __le16 buf;
 481         int ret = -EINVAL;
 482
 483         if (data->gesture_mode_running)
 484                 return -EBUSY;
 485
 486         switch (mask) {
 487         case IIO_CHAN_INFO_RAW:
 488                 apds9960_set_power_state(data, true);
 489                 switch (chan->type) {
 490                 case IIO_PROXIMITY:
 491                         ret = regmap_read(data->regmap, chan->address, val);
 492                         if (!ret)
 493                                 ret = IIO_VAL_INT;
 494                         break;
 495                 case IIO_INTENSITY:
 496                         ret = regmap_bulk_read(data->regmap, chan->address,
 497                                                &buf, 2);
 498                         if (!ret) {
 499                                 ret = IIO_VAL_INT;
 500                                 *val = le16_to_cpu(buf);
 501                         }
 502                         break;
 503                 default:
 504                         ret = -EINVAL;
 505                 }
 506                 apds9960_set_power_state(data, false);
 507                 break;
 508         case IIO_CHAN_INFO_INT_TIME:
 509                 /* RGB + ALS sensors only have integration time */
 510                 mutex_lock(&data->lock);
 511                 switch (chan->type) {
 512                 case IIO_INTENSITY:
 513                         *val = 0;
 514                         *val2 = data->als_adc_int_us;
 515                         ret = IIO_VAL_INT_PLUS_MICRO;
 516                         break;
 517                 default:
 518                         ret = -EINVAL;
 519                 }
 520                 mutex_unlock(&data->lock);
 521                 break;
 522         case IIO_CHAN_INFO_SCALE:
 523                 mutex_lock(&data->lock);
 524                 switch (chan->type) {
 525                 case IIO_PROXIMITY:
 526                         *val = apds9960_pxs_gain_map[data->pxs_gain];
 527                         ret = IIO_VAL_INT;
 528                         break;
 529                 case IIO_INTENSITY:
 530                         *val = apds9960_als_gain_map[data->als_gain];
 531                         ret = IIO_VAL_INT;
 532                         break;
 533                 default:
 534                         ret = -EINVAL;
 535                 }
 536                 mutex_unlock(&data->lock);
 537                 break;
 538         }
 539
 540         return ret;
 541 };
 542
 543 static int apds9960_write_raw(struct iio_dev *indio_dev,
 544                              struct iio_chan_spec const *chan,
 545                              int val, int val2, long mask)
 546 {
 547         struct apds9960_data *data = iio_priv(indio_dev);
 548
 549         switch (mask) {
 550         case IIO_CHAN_INFO_INT_TIME:
 551                 /* RGB + ALS sensors only have int time */
 552                 switch (chan->type) {
 553                 case IIO_INTENSITY:
 554                         if (val != 0)
 555                                 return -EINVAL;
 556                         return apds9960_set_it_time(data, val2);
 557                 default:
 558                         return -EINVAL;
 559                 }
 560         case IIO_CHAN_INFO_SCALE:
 561                 if (val2 != 0)
 562                         return -EINVAL;
 563                 switch (chan->type) {
 564                 case IIO_PROXIMITY:
 565                         return apds9960_set_pxs_gain(data, val);
 566                 case IIO_INTENSITY:
 567                         return apds9960_set_als_gain(data, val);
 568                 default:
 569                         return -EINVAL;
 570                 }
 571         default:
 572                 return -EINVAL;
 573         };
 574
 575         return 0;
 576 }
 577
 578 static inline int apds9960_get_thres_reg(const struct iio_chan_spec *chan,
 579                                          enum iio_event_direction dir,
 580                                          u8 *reg)
 581 {
 582         switch (dir) {
 583         case IIO_EV_DIR_RISING:
 584                 switch (chan->type) {
 585                 case IIO_PROXIMITY:
 586                         *reg = APDS9960_REG_PIHT;
 587                         break;
 588                 case IIO_INTENSITY:
 589                         *reg = APDS9960_REG_AIHTL;
 590                         break;
 591                 default:
 592                         return -EINVAL;
 593                 }
 594                 break;
 595         case IIO_EV_DIR_FALLING:
 596                 switch (chan->type) {
 597                 case IIO_PROXIMITY:
 598                         *reg = APDS9960_REG_PILT;
 599                         break;
 600                 case IIO_INTENSITY:
 601                         *reg = APDS9960_REG_AILTL;
 602                         break;
 603                 default:
 604                         return -EINVAL;
 605                 }
 606                 break;
 607         default:
 608                 return -EINVAL;
 609         }
 610
 611         return 0;
 612 }
 613
 614 static int apds9960_read_event(struct iio_dev *indio_dev,
 615                                const struct iio_chan_spec *chan,
 616                                enum iio_event_type type,
 617                                enum iio_event_direction dir,
 618                                enum iio_event_info info,
 619                                int *val, int *val2)
 620 {
 621         u8 reg;
 622         __le16 buf;
 623         int ret = 0;
 624         struct apds9960_data *data = iio_priv(indio_dev);
 625
 626         if (info != IIO_EV_INFO_VALUE)
 627                 return -EINVAL;
 628
 629         ret = apds9960_get_thres_reg(chan, dir, &reg);
 630         if (ret < 0)
 631                 return ret;
 632
 633         if (chan->type == IIO_PROXIMITY) {
 634                 ret = regmap_read(data->regmap, reg, val);
 635                 if (ret < 0)
 636                         return ret;
 637         } else if (chan->type == IIO_INTENSITY) {
 638                 ret = regmap_bulk_read(data->regmap, reg, &buf, 2);
 639                 if (ret < 0)
 640                         return ret;
 641                 *val = le16_to_cpu(buf);
 642         } else
 643                 return -EINVAL;
 644
 645         *val2 = 0;
 646
 647         return IIO_VAL_INT;
 648 }
 649
 650 static int apds9960_write_event(struct iio_dev *indio_dev,
 651                                 const struct iio_chan_spec *chan,
 652                                 enum iio_event_type type,
 653                                 enum iio_event_direction dir,
 654                                 enum iio_event_info info,
 655                                 int val, int val2)
 656 {
 657         u8 reg;
 658         __le16 buf;
 659         int ret = 0;
 660         struct apds9960_data *data = iio_priv(indio_dev);
 661
 662         if (info != IIO_EV_INFO_VALUE)
 663                 return -EINVAL;
 664
 665         ret = apds9960_get_thres_reg(chan, dir, &reg);
 666         if (ret < 0)
 667                 return ret;
 668
 669         if (chan->type == IIO_PROXIMITY) {
 670                 if (val < 0 || val > APDS9960_MAX_PXS_THRES_VAL)
 671                         return -EINVAL;
 672                 ret = regmap_write(data->regmap, reg, val);
 673                 if (ret < 0)
 674                         return ret;
 675         } else if (chan->type == IIO_INTENSITY) {
 676                 if (val < 0 || val > APDS9960_MAX_ALS_THRES_VAL)
 677                         return -EINVAL;
 678                 buf = cpu_to_le16(val);
 679                 ret = regmap_bulk_write(data->regmap, reg, &buf, 2);
 680                 if (ret < 0)
 681                         return ret;
 682         } else
 683                 return -EINVAL;
 684
 685         return 0;
 686 }
 687
 688 static int apds9960_read_event_config(struct iio_dev *indio_dev,
 689                                       const struct iio_chan_spec *chan,
 690                                       enum iio_event_type type,
 691                                       enum iio_event_direction dir)
 692 {
 693         struct apds9960_data *data = iio_priv(indio_dev);
 694
 695         switch (chan->type) {
 696         case IIO_PROXIMITY:
 697                 return data->pxs_int;
 698         case IIO_INTENSITY:
 699                 return data->als_int;
 700         default:
 701                 return -EINVAL;
 702         }
 703
 704         return 0;
 705 }
 706
 707 static int apds9960_write_event_config(struct iio_dev *indio_dev,
 708                                        const struct iio_chan_spec *chan,
 709                                        enum iio_event_type type,
 710                                        enum iio_event_direction dir,
 711                                        int state)
 712 {
 713         struct apds9960_data *data = iio_priv(indio_dev);
 714         int ret;
 715
 716         state = !!state;
 717
 718         switch (chan->type) {
 719         case IIO_PROXIMITY:
 720                 if (data->pxs_int == state)
 721                         return -EINVAL;
 722
 723                 ret = regmap_field_write(data->reg_int_pxs, state);
 724                 if (ret)
 725                         return ret;
 726                 data->pxs_int = state;
 727                 apds9960_set_power_state(data, state);
 728                 break;
 729         case IIO_INTENSITY:
 730                 if (data->als_int == state)
 731                         return -EINVAL;
 732
 733                 ret = regmap_field_write(data->reg_int_als, state);
 734                 if (ret)
 735                         return ret;
 736                 data->als_int = state;
 737                 apds9960_set_power_state(data, state);
 738                 break;
 739         default:
 740                 return -EINVAL;
 741         }
 742
 743         return 0;
 744 }
 745
 746 static const struct iio_info apds9960_info = {
 747         .driver_module = THIS_MODULE,
 748         .attrs = &apds9960_attribute_group,
 749         .read_raw = apds9960_read_raw,
 750         .write_raw = apds9960_write_raw,
 751         .read_event_value = apds9960_read_event,
 752         .write_event_value = apds9960_write_event,
 753         .read_event_config = apds9960_read_event_config,
 754         .write_event_config = apds9960_write_event_config,
 755
 756 };
 757
 758 static inline int apds9660_fifo_is_empty(struct apds9960_data *data)
 759 {
 760         int cnt;
 761         int ret;
 762
 763         ret = regmap_read(data->regmap, APDS9960_REG_GFLVL, &cnt);
 764         if (ret)
 765                 return ret;
 766
 767         return cnt;
 768 }
 769
 770 static void apds9960_read_gesture_fifo(struct apds9960_data *data)
 771 {
 772         int ret, cnt = 0;
 773
 774         mutex_lock(&data->lock);
 775         data->gesture_mode_running = 1;
 776
 777         while (cnt || (cnt = apds9660_fifo_is_empty(data) > 0)) {
 778                 ret = regmap_bulk_read(data->regmap, APDS9960_REG_GFIFO_BASE,
 779                                       &data->buffer, 4);
 780
 781                 if (ret)
 782                         goto err_read;
 783
 784                 iio_push_to_buffers(data->indio_dev, data->buffer);
 785                 cnt--;
 786         }
 787
 788 err_read:
 789         data->gesture_mode_running = 0;
 790         mutex_unlock(&data->lock);
 791 }
 792
 793 static irqreturn_t apds9960_interrupt_handler(int irq, void *private)
 794 {
 795         struct iio_dev *indio_dev = private;
 796         struct apds9960_data *data = iio_priv(indio_dev);
 797         int ret, status;
 798
 799         ret = regmap_read(data->regmap, APDS9960_REG_STATUS, &status);
 800         if (ret < 0) {
 801                 dev_err(&data->client->dev, "irq status reg read failed\n");
 802                 return IRQ_HANDLED;
 803         }
 804
 805         if ((status & APDS9960_REG_STATUS_ALS_INT) && data->als_int) {
 806                 iio_push_event(indio_dev,
 807                                IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 0,
 808                                                     IIO_EV_TYPE_THRESH,
 809                                                     IIO_EV_DIR_EITHER),
 810                                iio_get_time_ns(indio_dev));
 811                 regmap_write(data->regmap, APDS9960_REG_CICLEAR, 1);
 812         }
 813
 814         if ((status & APDS9960_REG_STATUS_PS_INT) && data->pxs_int) {
 815                 iio_push_event(indio_dev,
 816                                IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
 817                                                     IIO_EV_TYPE_THRESH,
 818                                                     IIO_EV_DIR_EITHER),
 819                                iio_get_time_ns(indio_dev));
 820                 regmap_write(data->regmap, APDS9960_REG_PICLEAR, 1);
 821         }
 822
 823         if (status & APDS9960_REG_STATUS_GINT)
 824                 apds9960_read_gesture_fifo(data);
 825
 826         return IRQ_HANDLED;
 827 }
 828
 829 static int apds9960_set_powermode(struct apds9960_data *data, bool state)
 830 {
 831         return regmap_update_bits(data->regmap, APDS9960_REG_ENABLE, 1, state);
 832 }
 833
 834 static int apds9960_buffer_postenable(struct iio_dev *indio_dev)
 835 {
 836         struct apds9960_data *data = iio_priv(indio_dev);
 837         int ret;
 838
 839         ret = regmap_field_write(data->reg_int_ges, 1);
 840         if (ret)
 841                 return ret;
 842
 843         ret = regmap_field_write(data->reg_enable_ges, 1);
 844         if (ret)
 845                 return ret;
 846
 847         pm_runtime_get_sync(&data->client->dev);
 848
 849         return 0;
 850 }
 851
 852 static int apds9960_buffer_predisable(struct iio_dev *indio_dev)
 853 {
 854         struct apds9960_data *data = iio_priv(indio_dev);
 855         int ret;
 856
 857         ret = regmap_field_write(data->reg_enable_ges, 0);
 858         if (ret)
 859                 return ret;
 860
 861         ret = regmap_field_write(data->reg_int_ges, 0);
 862         if (ret)
 863                 return ret;
 864
 865         pm_runtime_put_autosuspend(&data->client->dev);
 866
 867         return 0;
 868 }
 869
 870 static const struct iio_buffer_setup_ops apds9960_buffer_setup_ops = {
 871         .postenable = apds9960_buffer_postenable,
 872         .predisable = apds9960_buffer_predisable,
 873 };
 874
 875 static int apds9960_regfield_init(struct apds9960_data *data)
 876 {
 877         struct device *dev = &data->client->dev;
 878         struct regmap *regmap = data->regmap;
 879
 880         data->reg_int_als = devm_regmap_field_alloc(dev, regmap,
 881                                                 apds9960_reg_field_int_als);
 882         if (IS_ERR(data->reg_int_als)) {
 883                 dev_err(dev, "INT ALS reg field init failed\n");
 884                 return PTR_ERR(data->reg_int_als);
 885         }
 886
 887         data->reg_int_ges = devm_regmap_field_alloc(dev, regmap,
 888                                                 apds9960_reg_field_int_ges);
 889         if (IS_ERR(data->reg_int_ges)) {
 890                 dev_err(dev, "INT gesture reg field init failed\n");
 891                 return PTR_ERR(data->reg_int_ges);
 892         }
 893
 894         data->reg_int_pxs = devm_regmap_field_alloc(dev, regmap,
 895                                                 apds9960_reg_field_int_pxs);
 896         if (IS_ERR(data->reg_int_pxs)) {
 897                 dev_err(dev, "INT pxs reg field init failed\n");
 898                 return PTR_ERR(data->reg_int_pxs);
 899         }
 900
 901         data->reg_enable_als = devm_regmap_field_alloc(dev, regmap,
 902                                                 apds9960_reg_field_enable_als);
 903         if (IS_ERR(data->reg_enable_als)) {
 904                 dev_err(dev, "Enable ALS reg field init failed\n");
 905                 return PTR_ERR(data->reg_enable_als);
 906         }
 907
 908         data->reg_enable_ges = devm_regmap_field_alloc(dev, regmap,
 909                                                 apds9960_reg_field_enable_ges);
 910         if (IS_ERR(data->reg_enable_ges)) {
 911                 dev_err(dev, "Enable gesture reg field init failed\n");
 912                 return PTR_ERR(data->reg_enable_ges);
 913         }
 914
 915         data->reg_enable_pxs = devm_regmap_field_alloc(dev, regmap,
 916                                                 apds9960_reg_field_enable_pxs);
 917         if (IS_ERR(data->reg_enable_pxs)) {
 918                 dev_err(dev, "Enable PXS reg field init failed\n");
 919                 return PTR_ERR(data->reg_enable_pxs);
 920         }
 921
 922         return 0;
 923 }
 924
 925 static int apds9960_chip_init(struct apds9960_data *data)
 926 {
 927         int ret;
 928
 929         /* Default IT for ALS of 28 ms */
 930         ret = apds9960_set_it_time(data, 28000);
 931         if (ret)
 932                 return ret;
 933
 934         /* Ensure gesture interrupt is OFF */
 935         ret = regmap_field_write(data->reg_int_ges, 0);
 936         if (ret)
 937                 return ret;
 938
 939         /* Disable gesture sensor, since polling is useless from user-space */
 940         ret = regmap_field_write(data->reg_enable_ges, 0);
 941         if (ret)
 942                 return ret;
 943
 944         /* Ensure proximity interrupt is OFF */
 945         ret = regmap_field_write(data->reg_int_pxs, 0);
 946         if (ret)
 947                 return ret;
 948
 949         /* Enable proximity sensor for polling */
 950         ret = regmap_field_write(data->reg_enable_pxs, 1);
 951         if (ret)
 952                 return ret;
 953
 954         /* Ensure ALS interrupt is OFF */
 955         ret = regmap_field_write(data->reg_int_als, 0);
 956         if (ret)
 957                 return ret;
 958
 959         /* Enable ALS sensor for polling */
 960         ret = regmap_field_write(data->reg_enable_als, 1);
 961         if (ret)
 962                 return ret;
 963         /*
 964          * When enabled trigger an interrupt after 3 readings
 965          * outside threshold for ALS + PXS
 966          */
 967         ret = regmap_write(data->regmap, APDS9960_REG_PERS,
 968                            APDS9960_DEFAULT_PERS);
 969         if (ret)
 970                 return ret;
 971
 972         /*
 973          * Wait for 4 event outside gesture threshold to prevent interrupt
 974          * flooding.
 975          */
 976         ret = regmap_update_bits(data->regmap, APDS9960_REG_GCONF_1,
 977                         APDS9960_REG_GCONF_1_GFIFO_THRES_MASK,
 978                         BIT(0) << APDS9960_REG_GCONF_1_GFIFO_THRES_MASK_SHIFT);
 979         if (ret)
 980                 return ret;
 981
 982         /* Default ENTER and EXIT thresholds for the GESTURE engine. */
 983         ret = regmap_write(data->regmap, APDS9960_REG_GPENTH,
 984                            APDS9960_DEFAULT_GPENTH);
 985         if (ret)
 986                 return ret;
 987
 988         ret = regmap_write(data->regmap, APDS9960_REG_GEXTH,
 989                            APDS9960_DEFAULT_GEXTH);
 990         if (ret)
 991                 return ret;
 992
 993         return apds9960_set_powermode(data, 1);
 994 }
 995
 996 static int apds9960_probe(struct i2c_client *client,
 997                           const struct i2c_device_id *id)
 998 {
 999         struct apds9960_data *data;
1000         struct iio_buffer *buffer;
1001         struct iio_dev *indio_dev;
1002         int ret;
1003
1004         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1005         if (!indio_dev)
1006                 return -ENOMEM;
1007
1008         buffer = devm_iio_kfifo_allocate(&client->dev);
1009         if (!buffer)
1010                 return -ENOMEM;
1011
1012         iio_device_attach_buffer(indio_dev, buffer);
1013
1014         indio_dev->dev.parent = &client->dev;
1015         indio_dev->info = &apds9960_info;
1016         indio_dev->name = APDS9960_DRV_NAME;
1017         indio_dev->channels = apds9960_channels;
1018         indio_dev->num_channels = ARRAY_SIZE(apds9960_channels);
1019         indio_dev->available_scan_masks = apds9960_scan_masks;
1020         indio_dev->modes = (INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE);
1021         indio_dev->setup_ops = &apds9960_buffer_setup_ops;
1022
1023         data = iio_priv(indio_dev);
1024         i2c_set_clientdata(client, indio_dev);
1025
1026         data->regmap = devm_regmap_init_i2c(client, &apds9960_regmap_config);
1027         if (IS_ERR(data->regmap)) {
1028                 dev_err(&client->dev, "regmap initialization failed.\n");
1029                 return PTR_ERR(data->regmap);
1030         }
1031
1032         data->client = client;
1033         data->indio_dev = indio_dev;
1034         mutex_init(&data->lock);
1035
1036         ret = pm_runtime_set_active(&client->dev);
1037         if (ret)
1038                 goto error_power_down;
1039
1040         pm_runtime_enable(&client->dev);
1041         pm_runtime_set_autosuspend_delay(&client->dev, 5000);
1042         pm_runtime_use_autosuspend(&client->dev);
1043
1044         apds9960_set_power_state(data, true);
1045
1046         ret = apds9960_regfield_init(data);
1047         if (ret)
1048                 goto error_power_down;
1049
1050         ret = apds9960_chip_init(data);
1051         if (ret)
1052                 goto error_power_down;
1053
1054         if (client->irq <= 0) {
1055                 dev_err(&client->dev, "no valid irq defined\n");
1056                 ret = -EINVAL;
1057                 goto error_power_down;
1058         }
1059         ret = devm_request_threaded_irq(&client->dev, client->irq,
1060                                         NULL, apds9960_interrupt_handler,
1061                                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1062                                         "apds9960_event",
1063                                         indio_dev);
1064         if (ret) {
1065                 dev_err(&client->dev, "request irq (%d) failed\n", client->irq);
1066                 goto error_power_down;
1067         }
1068
1069         ret = iio_device_register(indio_dev);
1070         if (ret)
1071                 goto error_power_down;
1072
1073         apds9960_set_power_state(data, false);
1074
1075         return 0;
1076
1077 error_power_down:
1078         apds9960_set_power_state(data, false);
1079
1080         return ret;
1081 }
1082
1083 static int apds9960_remove(struct i2c_client *client)
1084 {
1085         struct iio_dev *indio_dev = i2c_get_clientdata(client);
1086         struct apds9960_data *data = iio_priv(indio_dev);
1087
1088         iio_device_unregister(indio_dev);
1089         pm_runtime_disable(&client->dev);
1090         pm_runtime_set_suspended(&client->dev);
1091         apds9960_set_powermode(data, 0);
1092
1093         return 0;
1094 }
1095
1096 #ifdef CONFIG_PM
1097 static int apds9960_runtime_suspend(struct device *dev)
1098 {
1099         struct apds9960_data *data =
1100                         iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
1101
1102         return apds9960_set_powermode(data, 0);
1103 }
1104
1105 static int apds9960_runtime_resume(struct device *dev)
1106 {
1107         struct apds9960_data *data =
1108                         iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
1109
1110         return apds9960_set_powermode(data, 1);
1111 }
1112 #endif
1113
1114 static const struct dev_pm_ops apds9960_pm_ops = {
1115         SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
1116                                 pm_runtime_force_resume)
1117         SET_RUNTIME_PM_OPS(apds9960_runtime_suspend,
1118                            apds9960_runtime_resume, NULL)
1119 };
1120
1121 static const struct i2c_device_id apds9960_id[] = {
1122         { "apds9960", 0 },
1123         {}
1124 };
1125 MODULE_DEVICE_TABLE(i2c, apds9960_id);
1126
1127 static const struct of_device_id apds9960_of_match[] = {
1128         { .compatible = "avago,apds9960" },
1129         { }
1130 };
1131 MODULE_DEVICE_TABLE(of, apds9960_of_match);
1132
1133 static struct i2c_driver apds9960_driver = {
1134         .driver = {
1135                 .name   = APDS9960_DRV_NAME,
1136                 .of_match_table = apds9960_of_match,
1137                 .pm     = &apds9960_pm_ops,
1138         },
1139         .probe          = apds9960_probe,
1140         .remove         = apds9960_remove,
1141         .id_table       = apds9960_id,
1142 };
1143 module_i2c_driver(apds9960_driver);
1144
1145 MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
1146 MODULE_DESCRIPTION("ADPS9960 Gesture/RGB/ALS/Proximity sensor");
1147 MODULE_LICENSE("GPL");