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}, {100000, 219}, {200000, 182}, {700000, 0} }; 326 327 /* gain mapping */ 328 static const int apds9960_pxs_gain_map[] = {1, 2, 4, 8}; 329 static const int apds9960_als_gain_map[] = {1, 4, 16, 64}; 330 331 static IIO_CONST_ATTR(proximity_scale_available, "1 2 4 8"); 332 static IIO_CONST_ATTR(intensity_scale_available, "1 4 16 64"); 333 static IIO_CONST_ATTR_INT_TIME_AVAIL("0.028 0.1 0.2 0.7"); 334 335 static struct attribute *apds9960_attributes[] = { 336 &iio_const_attr_proximity_scale_available.dev_attr.attr, 337 &iio_const_attr_intensity_scale_available.dev_attr.attr, 338 &iio_const_attr_integration_time_available.dev_attr.attr, 339 NULL, 340 }; 341 342 static struct attribute_group apds9960_attribute_group = { 343 .attrs = apds9960_attributes, 344 }; 345 346 static const struct reg_field apds9960_reg_field_int_als = 347 REG_FIELD(APDS9960_REG_ENABLE, 4, 4); 348 349 static const struct reg_field apds9960_reg_field_int_ges = 350 REG_FIELD(APDS9960_REG_GCONF_4, 1, 1); 351 352 static const struct reg_field apds9960_reg_field_int_pxs = 353 REG_FIELD(APDS9960_REG_ENABLE, 5, 5); 354 355 static const struct reg_field apds9960_reg_field_enable_als = 356 REG_FIELD(APDS9960_REG_ENABLE, 1, 1); 357 358 static const struct reg_field apds9960_reg_field_enable_ges = 359 REG_FIELD(APDS9960_REG_ENABLE, 6, 6); 360 361 static const struct reg_field apds9960_reg_field_enable_pxs = 362 REG_FIELD(APDS9960_REG_ENABLE, 2, 2); 363 364 static int apds9960_set_it_time(struct apds9960_data *data, int val2) 365 { 366 int ret = -EINVAL; 367 int idx; 368 369 for (idx = 0; idx < ARRAY_SIZE(apds9960_int_time); idx++) { 370 if (apds9960_int_time[idx][0] == val2) { 371 mutex_lock(&data->lock); 372 ret = regmap_write(data->regmap, APDS9960_REG_ATIME, 373 apds9960_int_time[idx][1]); 374 if (!ret) 375 data->als_adc_int_us = val2; 376 mutex_unlock(&data->lock); 377 break; 378 } 379 } 380 381 return ret; 382 } 383 384 static int apds9960_set_pxs_gain(struct apds9960_data *data, int val) 385 { 386 int ret = -EINVAL; 387 int idx; 388 389 for (idx = 0; idx < ARRAY_SIZE(apds9960_pxs_gain_map); idx++) { 390 if (apds9960_pxs_gain_map[idx] == val) { 391 /* pxs + gesture gains are mirrored */ 392 mutex_lock(&data->lock); 393 ret = regmap_update_bits(data->regmap, 394 APDS9960_REG_CONTROL, 395 APDS9960_REG_CONTROL_PGAIN_MASK, 396 idx << APDS9960_REG_CONTROL_PGAIN_MASK_SHIFT); 397 if (ret) { 398 mutex_unlock(&data->lock); 399 break; 400 } 401 402 ret = regmap_update_bits(data->regmap, 403 APDS9960_REG_CONFIG_2, 404 APDS9960_REG_CONFIG_2_GGAIN_MASK, 405 idx << APDS9960_REG_CONFIG_2_GGAIN_MASK_SHIFT); 406 if (!ret) 407 data->pxs_gain = idx; 408 mutex_unlock(&data->lock); 409 break; 410 } 411 } 412 413 return ret; 414 } 415 416 static int apds9960_set_als_gain(struct apds9960_data *data, int val) 417 { 418 int ret = -EINVAL; 419 int idx; 420 421 for (idx = 0; idx < ARRAY_SIZE(apds9960_als_gain_map); idx++) { 422 if (apds9960_als_gain_map[idx] == val) { 423 mutex_lock(&data->lock); 424 ret = regmap_update_bits(data->regmap, 425 APDS9960_REG_CONTROL, 426 APDS9960_REG_CONTROL_AGAIN_MASK, idx); 427 if (!ret) 428 data->als_gain = idx; 429 mutex_unlock(&data->lock); 430 break; 431 } 432 } 433 434 return ret; 435 } 436 437 #ifdef CONFIG_PM 438 static int apds9960_set_power_state(struct apds9960_data *data, bool on) 439 { 440 struct device *dev = &data->client->dev; 441 int ret = 0; 442 443 mutex_lock(&data->lock); 444 445 if (on) { 446 int suspended; 447 448 suspended = pm_runtime_suspended(dev); 449 ret = pm_runtime_get_sync(dev); 450 451 /* Allow one integration cycle before allowing a reading */ 452 if (suspended) 453 usleep_range(data->als_adc_int_us, 454 APDS9960_MAX_INT_TIME_IN_US); 455 } else { 456 ret = pm_runtime_put_autosuspend(dev); 457 } 458 459 mutex_unlock(&data->lock); 460 461 return ret; 462 } 463 #else 464 static int apds9960_set_power_state(struct apds9960_data *data, bool on) 465 { 466 return 0; 467 } 468 #endif 469 470 static int apds9960_read_raw(struct iio_dev *indio_dev, 471 struct iio_chan_spec const *chan, 472 int *val, int *val2, long mask) 473 { 474 struct apds9960_data *data = iio_priv(indio_dev); 475 __le16 buf; 476 int ret = -EINVAL; 477 478 if (data->gesture_mode_running) 479 return -EBUSY; 480 481 switch (mask) { 482 case IIO_CHAN_INFO_RAW: 483 apds9960_set_power_state(data, true); 484 switch (chan->type) { 485 case IIO_PROXIMITY: 486 ret = regmap_read(data->regmap, chan->address, val); 487 if (!ret) 488 ret = IIO_VAL_INT; 489 break; 490 case IIO_INTENSITY: 491 ret = regmap_bulk_read(data->regmap, chan->address, 492 &buf, 2); 493 if (!ret) 494 ret = IIO_VAL_INT; 495 *val = le16_to_cpu(buf); 496 break; 497 default: 498 ret = -EINVAL; 499 } 500 apds9960_set_power_state(data, false); 501 break; 502 case IIO_CHAN_INFO_INT_TIME: 503 /* RGB + ALS sensors only have integration time */ 504 mutex_lock(&data->lock); 505 switch (chan->type) { 506 case IIO_INTENSITY: 507 *val = 0; 508 *val2 = data->als_adc_int_us; 509 ret = IIO_VAL_INT_PLUS_MICRO; 510 break; 511 default: 512 ret = -EINVAL; 513 } 514 mutex_unlock(&data->lock); 515 break; 516 case IIO_CHAN_INFO_SCALE: 517 mutex_lock(&data->lock); 518 switch (chan->type) { 519 case IIO_PROXIMITY: 520 *val = apds9960_pxs_gain_map[data->pxs_gain]; 521 ret = IIO_VAL_INT; 522 break; 523 case IIO_INTENSITY: 524 *val = apds9960_als_gain_map[data->als_gain]; 525 ret = IIO_VAL_INT; 526 break; 527 default: 528 ret = -EINVAL; 529 } 530 mutex_unlock(&data->lock); 531 break; 532 } 533 534 return ret; 535 }; 536 537 static int apds9960_write_raw(struct iio_dev *indio_dev, 538 struct iio_chan_spec const *chan, 539 int val, int val2, long mask) 540 { 541 struct apds9960_data *data = iio_priv(indio_dev); 542 543 switch (mask) { 544 case IIO_CHAN_INFO_INT_TIME: 545 /* RGB + ALS sensors only have int time */ 546 switch (chan->type) { 547 case IIO_INTENSITY: 548 if (val != 0) 549 return -EINVAL; 550 return apds9960_set_it_time(data, val2); 551 default: 552 return -EINVAL; 553 } 554 case IIO_CHAN_INFO_SCALE: 555 if (val2 != 0) 556 return -EINVAL; 557 switch (chan->type) { 558 case IIO_PROXIMITY: 559 return apds9960_set_pxs_gain(data, val); 560 case IIO_INTENSITY: 561 return apds9960_set_als_gain(data, val); 562 default: 563 return -EINVAL; 564 } 565 default: 566 return -EINVAL; 567 }; 568 569 return 0; 570 } 571 572 static inline int apds9960_get_thres_reg(const struct iio_chan_spec *chan, 573 enum iio_event_direction dir, 574 u8 *reg) 575 { 576 switch (dir) { 577 case IIO_EV_DIR_RISING: 578 switch (chan->type) { 579 case IIO_PROXIMITY: 580 *reg = APDS9960_REG_PIHT; 581 break; 582 case IIO_INTENSITY: 583 *reg = APDS9960_REG_AIHTL; 584 break; 585 default: 586 return -EINVAL; 587 } 588 break; 589 case IIO_EV_DIR_FALLING: 590 switch (chan->type) { 591 case IIO_PROXIMITY: 592 *reg = APDS9960_REG_PILT; 593 break; 594 case IIO_INTENSITY: 595 *reg = APDS9960_REG_AILTL; 596 break; 597 default: 598 return -EINVAL; 599 } 600 break; 601 default: 602 return -EINVAL; 603 } 604 605 return 0; 606 } 607 608 static int apds9960_read_event(struct iio_dev *indio_dev, 609 const struct iio_chan_spec *chan, 610 enum iio_event_type type, 611 enum iio_event_direction dir, 612 enum iio_event_info info, 613 int *val, int *val2) 614 { 615 u8 reg; 616 __le16 buf; 617 int ret = 0; 618 struct apds9960_data *data = iio_priv(indio_dev); 619 620 if (info != IIO_EV_INFO_VALUE) 621 return -EINVAL; 622 623 ret = apds9960_get_thres_reg(chan, dir, ®); 624 if (ret < 0) 625 return ret; 626 627 if (chan->type == IIO_PROXIMITY) { 628 ret = regmap_read(data->regmap, reg, val); 629 if (ret < 0) 630 return ret; 631 } else if (chan->type == IIO_INTENSITY) { 632 ret = regmap_bulk_read(data->regmap, reg, &buf, 2); 633 if (ret < 0) 634 return ret; 635 *val = le16_to_cpu(buf); 636 } else 637 return -EINVAL; 638 639 *val2 = 0; 640 641 return IIO_VAL_INT; 642 } 643 644 static int apds9960_write_event(struct iio_dev *indio_dev, 645 const struct iio_chan_spec *chan, 646 enum iio_event_type type, 647 enum iio_event_direction dir, 648 enum iio_event_info info, 649 int val, int val2) 650 { 651 u8 reg; 652 __le16 buf; 653 int ret = 0; 654 struct apds9960_data *data = iio_priv(indio_dev); 655 656 if (info != IIO_EV_INFO_VALUE) 657 return -EINVAL; 658 659 ret = apds9960_get_thres_reg(chan, dir, ®); 660 if (ret < 0) 661 return ret; 662 663 if (chan->type == IIO_PROXIMITY) { 664 if (val < 0 || val > APDS9960_MAX_PXS_THRES_VAL) 665 return -EINVAL; 666 ret = regmap_write(data->regmap, reg, val); 667 if (ret < 0) 668 return ret; 669 } else if (chan->type == IIO_INTENSITY) { 670 if (val < 0 || val > APDS9960_MAX_ALS_THRES_VAL) 671 return -EINVAL; 672 buf = cpu_to_le16(val); 673 ret = regmap_bulk_write(data->regmap, reg, &buf, 2); 674 if (ret < 0) 675 return ret; 676 } else 677 return -EINVAL; 678 679 return 0; 680 } 681 682 static int apds9960_read_event_config(struct iio_dev *indio_dev, 683 const struct iio_chan_spec *chan, 684 enum iio_event_type type, 685 enum iio_event_direction dir) 686 { 687 struct apds9960_data *data = iio_priv(indio_dev); 688 689 switch (chan->type) { 690 case IIO_PROXIMITY: 691 return data->pxs_int; 692 case IIO_INTENSITY: 693 return data->als_int; 694 default: 695 return -EINVAL; 696 } 697 698 return 0; 699 } 700 701 static int apds9960_write_event_config(struct iio_dev *indio_dev, 702 const struct iio_chan_spec *chan, 703 enum iio_event_type type, 704 enum iio_event_direction dir, 705 int state) 706 { 707 struct apds9960_data *data = iio_priv(indio_dev); 708 int ret; 709 710 state = !!state; 711 712 switch (chan->type) { 713 case IIO_PROXIMITY: 714 if (data->pxs_int == state) 715 return -EINVAL; 716 717 ret = regmap_field_write(data->reg_int_pxs, state); 718 if (ret) 719 return ret; 720 data->pxs_int = state; 721 apds9960_set_power_state(data, state); 722 break; 723 case IIO_INTENSITY: 724 if (data->als_int == state) 725 return -EINVAL; 726 727 ret = regmap_field_write(data->reg_int_als, state); 728 if (ret) 729 return ret; 730 data->als_int = state; 731 apds9960_set_power_state(data, state); 732 break; 733 default: 734 return -EINVAL; 735 } 736 737 return 0; 738 } 739 740 static const struct iio_info apds9960_info = { 741 .driver_module = THIS_MODULE, 742 .attrs = &apds9960_attribute_group, 743 .read_raw = apds9960_read_raw, 744 .write_raw = apds9960_write_raw, 745 .read_event_value = apds9960_read_event, 746 .write_event_value = apds9960_write_event, 747 .read_event_config = apds9960_read_event_config, 748 .write_event_config = apds9960_write_event_config, 749 750 }; 751 752 static inline int apds9660_fifo_is_empty(struct apds9960_data *data) 753 { 754 int cnt; 755 int ret; 756 757 ret = regmap_read(data->regmap, APDS9960_REG_GFLVL, &cnt); 758 if (ret) 759 return ret; 760 761 return cnt; 762 } 763 764 static void apds9960_read_gesture_fifo(struct apds9960_data *data) 765 { 766 int ret, cnt = 0; 767 768 mutex_lock(&data->lock); 769 data->gesture_mode_running = 1; 770 771 while (cnt-- || (cnt = apds9660_fifo_is_empty(data) > 0)) { 772 ret = regmap_bulk_read(data->regmap, APDS9960_REG_GFIFO_BASE, 773 &data->buffer, 4); 774 775 if (ret) 776 goto err_read; 777 778 iio_push_to_buffers(data->indio_dev, data->buffer); 779 } 780 781 err_read: 782 data->gesture_mode_running = 0; 783 mutex_unlock(&data->lock); 784 } 785 786 static irqreturn_t apds9960_interrupt_handler(int irq, void *private) 787 { 788 struct iio_dev *indio_dev = private; 789 struct apds9960_data *data = iio_priv(indio_dev); 790 int ret, status; 791 792 ret = regmap_read(data->regmap, APDS9960_REG_STATUS, &status); 793 if (ret < 0) { 794 dev_err(&data->client->dev, "irq status reg read failed\n"); 795 return IRQ_HANDLED; 796 } 797 798 if ((status & APDS9960_REG_STATUS_ALS_INT) && data->als_int) { 799 iio_push_event(indio_dev, 800 IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 0, 801 IIO_EV_TYPE_THRESH, 802 IIO_EV_DIR_EITHER), 803 iio_get_time_ns()); 804 regmap_write(data->regmap, APDS9960_REG_CICLEAR, 1); 805 } 806 807 if ((status & APDS9960_REG_STATUS_PS_INT) && data->pxs_int) { 808 iio_push_event(indio_dev, 809 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0, 810 IIO_EV_TYPE_THRESH, 811 IIO_EV_DIR_EITHER), 812 iio_get_time_ns()); 813 regmap_write(data->regmap, APDS9960_REG_PICLEAR, 1); 814 } 815 816 if (status & APDS9960_REG_STATUS_GINT) 817 apds9960_read_gesture_fifo(data); 818 819 return IRQ_HANDLED; 820 } 821 822 static int apds9960_set_powermode(struct apds9960_data *data, bool state) 823 { 824 return regmap_update_bits(data->regmap, APDS9960_REG_ENABLE, 1, state); 825 } 826 827 static int apds9960_buffer_postenable(struct iio_dev *indio_dev) 828 { 829 struct apds9960_data *data = iio_priv(indio_dev); 830 int ret; 831 832 ret = regmap_field_write(data->reg_int_ges, 1); 833 if (ret) 834 return ret; 835 836 ret = regmap_field_write(data->reg_enable_ges, 1); 837 if (ret) 838 return ret; 839 840 pm_runtime_get_sync(&data->client->dev); 841 842 return 0; 843 } 844 845 static int apds9960_buffer_predisable(struct iio_dev *indio_dev) 846 { 847 struct apds9960_data *data = iio_priv(indio_dev); 848 int ret; 849 850 ret = regmap_field_write(data->reg_enable_ges, 0); 851 if (ret) 852 return ret; 853 854 ret = regmap_field_write(data->reg_int_ges, 0); 855 if (ret) 856 return ret; 857 858 pm_runtime_put_autosuspend(&data->client->dev); 859 860 return 0; 861 } 862 863 static const struct iio_buffer_setup_ops apds9960_buffer_setup_ops = { 864 .postenable = apds9960_buffer_postenable, 865 .predisable = apds9960_buffer_predisable, 866 }; 867 868 static int apds9960_regfield_init(struct apds9960_data *data) 869 { 870 struct device *dev = &data->client->dev; 871 struct regmap *regmap = data->regmap; 872 873 data->reg_int_als = devm_regmap_field_alloc(dev, regmap, 874 apds9960_reg_field_int_als); 875 if (IS_ERR(data->reg_int_als)) { 876 dev_err(dev, "INT ALS reg field init failed\n"); 877 return PTR_ERR(data->reg_int_als); 878 } 879 880 data->reg_int_ges = devm_regmap_field_alloc(dev, regmap, 881 apds9960_reg_field_int_ges); 882 if (IS_ERR(data->reg_int_ges)) { 883 dev_err(dev, "INT gesture reg field init failed\n"); 884 return PTR_ERR(data->reg_int_ges); 885 } 886 887 data->reg_int_pxs = devm_regmap_field_alloc(dev, regmap, 888 apds9960_reg_field_int_pxs); 889 if (IS_ERR(data->reg_int_pxs)) { 890 dev_err(dev, "INT pxs reg field init failed\n"); 891 return PTR_ERR(data->reg_int_pxs); 892 } 893 894 data->reg_enable_als = devm_regmap_field_alloc(dev, regmap, 895 apds9960_reg_field_enable_als); 896 if (IS_ERR(data->reg_enable_als)) { 897 dev_err(dev, "Enable ALS reg field init failed\n"); 898 return PTR_ERR(data->reg_enable_als); 899 } 900 901 data->reg_enable_ges = devm_regmap_field_alloc(dev, regmap, 902 apds9960_reg_field_enable_ges); 903 if (IS_ERR(data->reg_enable_ges)) { 904 dev_err(dev, "Enable gesture reg field init failed\n"); 905 return PTR_ERR(data->reg_enable_ges); 906 } 907 908 data->reg_enable_pxs = devm_regmap_field_alloc(dev, regmap, 909 apds9960_reg_field_enable_pxs); 910 if (IS_ERR(data->reg_enable_pxs)) { 911 dev_err(dev, "Enable PXS reg field init failed\n"); 912 return PTR_ERR(data->reg_enable_pxs); 913 } 914 915 return 0; 916 } 917 918 static int apds9960_chip_init(struct apds9960_data *data) 919 { 920 int ret; 921 922 /* Default IT for ALS of 28 ms */ 923 ret = apds9960_set_it_time(data, 28000); 924 if (ret) 925 return ret; 926 927 /* Ensure gesture interrupt is OFF */ 928 ret = regmap_field_write(data->reg_int_ges, 0); 929 if (ret) 930 return ret; 931 932 /* Disable gesture sensor, since polling is useless from user-space */ 933 ret = regmap_field_write(data->reg_enable_ges, 0); 934 if (ret) 935 return ret; 936 937 /* Ensure proximity interrupt is OFF */ 938 ret = regmap_field_write(data->reg_int_pxs, 0); 939 if (ret) 940 return ret; 941 942 /* Enable proximity sensor for polling */ 943 ret = regmap_field_write(data->reg_enable_pxs, 1); 944 if (ret) 945 return ret; 946 947 /* Ensure ALS interrupt is OFF */ 948 ret = regmap_field_write(data->reg_int_als, 0); 949 if (ret) 950 return ret; 951 952 /* Enable ALS sensor for polling */ 953 ret = regmap_field_write(data->reg_enable_als, 1); 954 if (ret) 955 return ret; 956 /* 957 * When enabled trigger an interrupt after 3 readings 958 * outside threshold for ALS + PXS 959 */ 960 ret = regmap_write(data->regmap, APDS9960_REG_PERS, 961 APDS9960_DEFAULT_PERS); 962 if (ret) 963 return ret; 964 965 /* 966 * Wait for 4 event outside gesture threshold to prevent interrupt 967 * flooding. 968 */ 969 ret = regmap_update_bits(data->regmap, APDS9960_REG_GCONF_1, 970 APDS9960_REG_GCONF_1_GFIFO_THRES_MASK, 971 BIT(0) << APDS9960_REG_GCONF_1_GFIFO_THRES_MASK_SHIFT); 972 if (ret) 973 return ret; 974 975 /* Default ENTER and EXIT thresholds for the GESTURE engine. */ 976 ret = regmap_write(data->regmap, APDS9960_REG_GPENTH, 977 APDS9960_DEFAULT_GPENTH); 978 if (ret) 979 return ret; 980 981 ret = regmap_write(data->regmap, APDS9960_REG_GEXTH, 982 APDS9960_DEFAULT_GEXTH); 983 if (ret) 984 return ret; 985 986 return apds9960_set_powermode(data, 1); 987 } 988 989 static int apds9960_probe(struct i2c_client *client, 990 const struct i2c_device_id *id) 991 { 992 struct apds9960_data *data; 993 struct iio_buffer *buffer; 994 struct iio_dev *indio_dev; 995 int ret; 996 997 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 998 if (!indio_dev) 999 return -ENOMEM; 1000 1001 buffer = devm_iio_kfifo_allocate(&client->dev); 1002 if (!buffer) 1003 return -ENOMEM; 1004 1005 iio_device_attach_buffer(indio_dev, buffer); 1006 1007 indio_dev->info = &apds9960_info; 1008 indio_dev->name = APDS9960_DRV_NAME; 1009 indio_dev->channels = apds9960_channels; 1010 indio_dev->num_channels = ARRAY_SIZE(apds9960_channels); 1011 indio_dev->available_scan_masks = apds9960_scan_masks; 1012 indio_dev->modes = (INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE); 1013 indio_dev->setup_ops = &apds9960_buffer_setup_ops; 1014 1015 data = iio_priv(indio_dev); 1016 i2c_set_clientdata(client, indio_dev); 1017 1018 data->regmap = devm_regmap_init_i2c(client, &apds9960_regmap_config); 1019 if (IS_ERR(data->regmap)) { 1020 dev_err(&client->dev, "regmap initialization failed.\n"); 1021 return PTR_ERR(data->regmap); 1022 } 1023 1024 data->client = client; 1025 data->indio_dev = indio_dev; 1026 mutex_init(&data->lock); 1027 1028 ret = pm_runtime_set_active(&client->dev); 1029 if (ret) 1030 goto error_power_down; 1031 1032 pm_runtime_enable(&client->dev); 1033 pm_runtime_set_autosuspend_delay(&client->dev, 5000); 1034 pm_runtime_use_autosuspend(&client->dev); 1035 1036 apds9960_set_power_state(data, true); 1037 1038 ret = apds9960_regfield_init(data); 1039 if (ret) 1040 goto error_power_down; 1041 1042 ret = apds9960_chip_init(data); 1043 if (ret) 1044 goto error_power_down; 1045 1046 if (client->irq <= 0) { 1047 dev_err(&client->dev, "no valid irq defined\n"); 1048 ret = -EINVAL; 1049 goto error_power_down; 1050 } 1051 ret = devm_request_threaded_irq(&client->dev, client->irq, 1052 NULL, apds9960_interrupt_handler, 1053 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 1054 "apds9960_event", 1055 indio_dev); 1056 if (ret) { 1057 dev_err(&client->dev, "request irq (%d) failed\n", client->irq); 1058 goto error_power_down; 1059 } 1060 1061 ret = iio_device_register(indio_dev); 1062 if (ret) 1063 goto error_power_down; 1064 1065 apds9960_set_power_state(data, false); 1066 1067 return 0; 1068 1069 error_power_down: 1070 apds9960_set_power_state(data, false); 1071 1072 return ret; 1073 } 1074 1075 static int apds9960_remove(struct i2c_client *client) 1076 { 1077 struct iio_dev *indio_dev = i2c_get_clientdata(client); 1078 struct apds9960_data *data = iio_priv(indio_dev); 1079 1080 iio_device_unregister(indio_dev); 1081 pm_runtime_disable(&client->dev); 1082 pm_runtime_set_suspended(&client->dev); 1083 apds9960_set_powermode(data, 0); 1084 1085 return 0; 1086 } 1087 1088 #ifdef CONFIG_PM 1089 static int apds9960_runtime_suspend(struct device *dev) 1090 { 1091 struct apds9960_data *data = 1092 iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 1093 1094 return apds9960_set_powermode(data, 0); 1095 } 1096 1097 static int apds9960_runtime_resume(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, 1); 1103 } 1104 #endif 1105 1106 static const struct dev_pm_ops apds9960_pm_ops = { 1107 SET_RUNTIME_PM_OPS(apds9960_runtime_suspend, 1108 apds9960_runtime_resume, NULL) 1109 }; 1110 1111 static const struct i2c_device_id apds9960_id[] = { 1112 { "apds9960", 0 }, 1113 {} 1114 }; 1115 MODULE_DEVICE_TABLE(i2c, apds9960_id); 1116 1117 static struct i2c_driver apds9960_driver = { 1118 .driver = { 1119 .name = APDS9960_DRV_NAME, 1120 .pm = &apds9960_pm_ops, 1121 }, 1122 .probe = apds9960_probe, 1123 .remove = apds9960_remove, 1124 .id_table = apds9960_id, 1125 }; 1126 module_i2c_driver(apds9960_driver); 1127 1128 MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>"); 1129 MODULE_DESCRIPTION("ADPS9960 Gesture/RGB/ALS/Proximity sensor"); 1130 MODULE_LICENSE("GPL"); 1131