drivers/iio/light/apds9960.c

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