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