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