1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Sensortek STK3310/STK3311 Ambient Light and Proximity Sensor 4 * 5 * Copyright (c) 2015, Intel Corporation. 6 * 7 * IIO driver for STK3310/STK3311. 7-bit I2C address: 0x48. 8 */ 9 10 #include <linux/array_size.h> 11 #include <linux/bits.h> 12 #include <linux/dev_printk.h> 13 #include <linux/err.h> 14 #include <linux/i2c.h> 15 #include <linux/interrupt.h> 16 #include <linux/mod_devicetable.h> 17 #include <linux/module.h> 18 #include <linux/mutex.h> 19 #include <linux/pm.h> 20 #include <linux/property.h> 21 #include <linux/regmap.h> 22 #include <linux/sprintf.h> 23 #include <linux/sysfs.h> 24 #include <linux/types.h> 25 26 #include <linux/iio/events.h> 27 #include <linux/iio/iio.h> 28 #include <linux/iio/sysfs.h> 29 #include <linux/iio/types.h> 30 31 #include <asm/byteorder.h> 32 33 #define STK3310_REG_STATE 0x00 34 #define STK3310_REG_PSCTRL 0x01 35 #define STK3310_REG_ALSCTRL 0x02 36 #define STK3310_REG_INT 0x04 37 #define STK3310_REG_THDH_PS 0x06 38 #define STK3310_REG_THDL_PS 0x08 39 #define STK3310_REG_FLAG 0x10 40 #define STK3310_REG_PS_DATA_MSB 0x11 41 #define STK3310_REG_PS_DATA_LSB 0x12 42 #define STK3310_REG_ALS_DATA_MSB 0x13 43 #define STK3310_REG_ALS_DATA_LSB 0x14 44 #define STK3310_REG_ID 0x3E 45 #define STK3310_MAX_REG 0x80 46 47 #define STK3310_STATE_EN_PS BIT(0) 48 #define STK3310_STATE_EN_ALS BIT(1) 49 #define STK3310_STATE_STANDBY 0x00 50 51 #define STK3013_CHIP_ID_VAL 0x31 52 #define STK3310_CHIP_ID_VAL 0x13 53 #define STK3311_CHIP_ID_VAL 0x1D 54 #define STK3311A_CHIP_ID_VAL 0x15 55 #define STK3311S34_CHIP_ID_VAL 0x1E 56 #define STK3311X_CHIP_ID_VAL 0x12 57 #define STK3335_CHIP_ID_VAL 0x51 58 #define STK3310_PSINT_EN 0x01 59 #define STK3310_PS_MAX_VAL 0xFFFF 60 61 #define STK3310_DRIVER_NAME "stk3310" 62 63 #define STK3310_SCALE_AVAILABLE "6.4 1.6 0.4 0.1" 64 65 #define STK3310_IT_AVAILABLE \ 66 "0.000185 0.000370 0.000741 0.001480 0.002960 0.005920 0.011840 " \ 67 "0.023680 0.047360 0.094720 0.189440 0.378880 0.757760 1.515520 " \ 68 "3.031040 6.062080" 69 70 #define STK3310_REGFIELD(name) \ 71 do { \ 72 data->reg_##name = \ 73 devm_regmap_field_alloc(&client->dev, regmap, \ 74 stk3310_reg_field_##name); \ 75 if (IS_ERR(data->reg_##name)) { \ 76 dev_err(&client->dev, "reg field alloc failed.\n"); \ 77 return PTR_ERR(data->reg_##name); \ 78 } \ 79 } while (0) 80 81 static const struct reg_field stk3310_reg_field_state = 82 REG_FIELD(STK3310_REG_STATE, 0, 2); 83 static const struct reg_field stk3310_reg_field_als_gain = 84 REG_FIELD(STK3310_REG_ALSCTRL, 4, 5); 85 static const struct reg_field stk3310_reg_field_ps_gain = 86 REG_FIELD(STK3310_REG_PSCTRL, 4, 5); 87 static const struct reg_field stk3310_reg_field_als_it = 88 REG_FIELD(STK3310_REG_ALSCTRL, 0, 3); 89 static const struct reg_field stk3310_reg_field_ps_it = 90 REG_FIELD(STK3310_REG_PSCTRL, 0, 3); 91 static const struct reg_field stk3310_reg_field_int_ps = 92 REG_FIELD(STK3310_REG_INT, 0, 2); 93 static const struct reg_field stk3310_reg_field_flag_psint = 94 REG_FIELD(STK3310_REG_FLAG, 4, 4); 95 static const struct reg_field stk3310_reg_field_flag_nf = 96 REG_FIELD(STK3310_REG_FLAG, 0, 0); 97 98 static const u8 stk3310_chip_ids[] = { 99 STK3013_CHIP_ID_VAL, 100 STK3310_CHIP_ID_VAL, 101 STK3311A_CHIP_ID_VAL, 102 STK3311S34_CHIP_ID_VAL, 103 STK3311X_CHIP_ID_VAL, 104 STK3311_CHIP_ID_VAL, 105 STK3335_CHIP_ID_VAL, 106 }; 107 108 /* Estimate maximum proximity values with regard to measurement scale. */ 109 static const int stk3310_ps_max[4] = { 110 STK3310_PS_MAX_VAL / 640, 111 STK3310_PS_MAX_VAL / 160, 112 STK3310_PS_MAX_VAL / 40, 113 STK3310_PS_MAX_VAL / 10 114 }; 115 116 static const int stk3310_scale_table[][2] = { 117 {6, 400000}, {1, 600000}, {0, 400000}, {0, 100000} 118 }; 119 120 /* Integration time in seconds, microseconds */ 121 static const int stk3310_it_table[][2] = { 122 {0, 185}, {0, 370}, {0, 741}, {0, 1480}, 123 {0, 2960}, {0, 5920}, {0, 11840}, {0, 23680}, 124 {0, 47360}, {0, 94720}, {0, 189440}, {0, 378880}, 125 {0, 757760}, {1, 515520}, {3, 31040}, {6, 62080}, 126 }; 127 128 struct stk3310_data { 129 struct i2c_client *client; 130 struct mutex lock; 131 u64 timestamp; 132 struct regmap *regmap; 133 struct regmap_field *reg_state; 134 struct regmap_field *reg_als_gain; 135 struct regmap_field *reg_ps_gain; 136 struct regmap_field *reg_als_it; 137 struct regmap_field *reg_ps_it; 138 struct regmap_field *reg_int_ps; 139 struct regmap_field *reg_flag_psint; 140 struct regmap_field *reg_flag_nf; 141 u32 ps_thdl; 142 u32 ps_thdh; 143 u32 ps_near_level; 144 bool als_enabled; 145 bool ps_enabled; 146 bool ps_int_enabled; 147 }; 148 149 static const struct iio_event_spec stk3310_events[] = { 150 /* Proximity event */ 151 { 152 .type = IIO_EV_TYPE_THRESH, 153 .dir = IIO_EV_DIR_RISING, 154 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 155 BIT(IIO_EV_INFO_ENABLE), 156 }, 157 /* Out-of-proximity event */ 158 { 159 .type = IIO_EV_TYPE_THRESH, 160 .dir = IIO_EV_DIR_FALLING, 161 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 162 BIT(IIO_EV_INFO_ENABLE), 163 }, 164 }; 165 166 static ssize_t stk3310_read_near_level(struct iio_dev *indio_dev, 167 uintptr_t priv, 168 const struct iio_chan_spec *chan, 169 char *buf) 170 { 171 struct stk3310_data *data = iio_priv(indio_dev); 172 173 return sprintf(buf, "%u\n", data->ps_near_level); 174 } 175 176 static const struct iio_chan_spec_ext_info stk3310_ext_info[] = { 177 { 178 .name = "nearlevel", 179 .shared = IIO_SEPARATE, 180 .read = stk3310_read_near_level, 181 }, 182 { } 183 }; 184 185 static const struct iio_chan_spec stk3310_channels[] = { 186 { 187 .type = IIO_LIGHT, 188 .info_mask_separate = 189 BIT(IIO_CHAN_INFO_RAW) | 190 BIT(IIO_CHAN_INFO_SCALE) | 191 BIT(IIO_CHAN_INFO_INT_TIME), 192 }, 193 { 194 .type = IIO_PROXIMITY, 195 .info_mask_separate = 196 BIT(IIO_CHAN_INFO_RAW) | 197 BIT(IIO_CHAN_INFO_SCALE) | 198 BIT(IIO_CHAN_INFO_INT_TIME), 199 .event_spec = stk3310_events, 200 .num_event_specs = ARRAY_SIZE(stk3310_events), 201 .ext_info = stk3310_ext_info, 202 } 203 }; 204 205 static IIO_CONST_ATTR(in_illuminance_scale_available, STK3310_SCALE_AVAILABLE); 206 207 static IIO_CONST_ATTR(in_proximity_scale_available, STK3310_SCALE_AVAILABLE); 208 209 static IIO_CONST_ATTR(in_illuminance_integration_time_available, 210 STK3310_IT_AVAILABLE); 211 212 static IIO_CONST_ATTR(in_proximity_integration_time_available, 213 STK3310_IT_AVAILABLE); 214 215 static struct attribute *stk3310_attributes[] = { 216 &iio_const_attr_in_illuminance_scale_available.dev_attr.attr, 217 &iio_const_attr_in_proximity_scale_available.dev_attr.attr, 218 &iio_const_attr_in_illuminance_integration_time_available.dev_attr.attr, 219 &iio_const_attr_in_proximity_integration_time_available.dev_attr.attr, 220 NULL, 221 }; 222 223 static const struct attribute_group stk3310_attribute_group = { 224 .attrs = stk3310_attributes 225 }; 226 227 static int stk3310_check_chip_id(const u8 chip_id) 228 { 229 for (int i = 0; i < ARRAY_SIZE(stk3310_chip_ids); i++) { 230 if (chip_id == stk3310_chip_ids[i]) 231 return 0; 232 } 233 234 return -ENODEV; 235 } 236 237 static int stk3310_get_index(const int table[][2], int table_size, 238 int val, int val2) 239 { 240 int i; 241 242 for (i = 0; i < table_size; i++) { 243 if (val == table[i][0] && val2 == table[i][1]) 244 return i; 245 } 246 247 return -EINVAL; 248 } 249 250 static int stk3310_read_event(struct iio_dev *indio_dev, 251 const struct iio_chan_spec *chan, 252 enum iio_event_type type, 253 enum iio_event_direction dir, 254 enum iio_event_info info, 255 int *val, int *val2) 256 { 257 u8 reg; 258 __be16 buf; 259 int ret; 260 struct stk3310_data *data = iio_priv(indio_dev); 261 262 if (info != IIO_EV_INFO_VALUE) 263 return -EINVAL; 264 265 /* Only proximity interrupts are implemented at the moment. */ 266 if (dir == IIO_EV_DIR_RISING) 267 reg = STK3310_REG_THDH_PS; 268 else if (dir == IIO_EV_DIR_FALLING) 269 reg = STK3310_REG_THDL_PS; 270 else 271 return -EINVAL; 272 273 mutex_lock(&data->lock); 274 ret = regmap_bulk_read(data->regmap, reg, &buf, sizeof(buf)); 275 mutex_unlock(&data->lock); 276 if (ret < 0) { 277 dev_err(&data->client->dev, "register read failed\n"); 278 return ret; 279 } 280 *val = be16_to_cpu(buf); 281 282 return IIO_VAL_INT; 283 } 284 285 static int stk3310_write_event(struct iio_dev *indio_dev, 286 const struct iio_chan_spec *chan, 287 enum iio_event_type type, 288 enum iio_event_direction dir, 289 enum iio_event_info info, 290 int val, int val2) 291 { 292 u8 reg; 293 __be16 buf; 294 int ret; 295 unsigned int index; 296 struct stk3310_data *data = iio_priv(indio_dev); 297 struct i2c_client *client = data->client; 298 299 ret = regmap_field_read(data->reg_ps_gain, &index); 300 if (ret < 0) 301 return ret; 302 303 if (val < 0 || val > stk3310_ps_max[index]) 304 return -EINVAL; 305 306 if (dir == IIO_EV_DIR_RISING) 307 reg = STK3310_REG_THDH_PS; 308 else if (dir == IIO_EV_DIR_FALLING) 309 reg = STK3310_REG_THDL_PS; 310 else 311 return -EINVAL; 312 313 buf = cpu_to_be16(val); 314 ret = regmap_bulk_write(data->regmap, reg, &buf, sizeof(buf)); 315 if (ret < 0) { 316 dev_err(&client->dev, "failed to set PS threshold!\n"); 317 return ret; 318 } 319 320 if (reg == STK3310_REG_THDH_PS) 321 data->ps_thdh = val; 322 else 323 data->ps_thdl = val; 324 325 return 0; 326 } 327 328 static int stk3310_read_event_config(struct iio_dev *indio_dev, 329 const struct iio_chan_spec *chan, 330 enum iio_event_type type, 331 enum iio_event_direction dir) 332 { 333 unsigned int event_val; 334 int ret; 335 struct stk3310_data *data = iio_priv(indio_dev); 336 337 ret = regmap_field_read(data->reg_int_ps, &event_val); 338 if (ret < 0) 339 return ret; 340 341 return event_val; 342 } 343 344 static int stk3310_write_event_config(struct iio_dev *indio_dev, 345 const struct iio_chan_spec *chan, 346 enum iio_event_type type, 347 enum iio_event_direction dir, 348 bool state) 349 { 350 int ret; 351 struct stk3310_data *data = iio_priv(indio_dev); 352 struct i2c_client *client = data->client; 353 354 /* Set INT_PS value */ 355 mutex_lock(&data->lock); 356 ret = regmap_field_write(data->reg_int_ps, state); 357 if (ret < 0) { 358 dev_err(&client->dev, "failed to set interrupt mode\n"); 359 mutex_unlock(&data->lock); 360 return ret; 361 } 362 363 data->ps_int_enabled = state; 364 365 mutex_unlock(&data->lock); 366 367 return 0; 368 } 369 370 static int stk3310_read_raw(struct iio_dev *indio_dev, 371 struct iio_chan_spec const *chan, 372 int *val, int *val2, long mask) 373 { 374 u8 reg; 375 __be16 buf; 376 int ret; 377 unsigned int index; 378 struct stk3310_data *data = iio_priv(indio_dev); 379 struct i2c_client *client = data->client; 380 381 if (chan->type != IIO_LIGHT && chan->type != IIO_PROXIMITY) 382 return -EINVAL; 383 384 switch (mask) { 385 case IIO_CHAN_INFO_RAW: 386 if (chan->type == IIO_LIGHT) 387 reg = STK3310_REG_ALS_DATA_MSB; 388 else 389 reg = STK3310_REG_PS_DATA_MSB; 390 391 mutex_lock(&data->lock); 392 ret = regmap_bulk_read(data->regmap, reg, &buf, sizeof(buf)); 393 if (ret < 0) { 394 dev_err(&client->dev, "register read failed\n"); 395 mutex_unlock(&data->lock); 396 return ret; 397 } 398 *val = be16_to_cpu(buf); 399 mutex_unlock(&data->lock); 400 return IIO_VAL_INT; 401 case IIO_CHAN_INFO_INT_TIME: 402 if (chan->type == IIO_LIGHT) 403 ret = regmap_field_read(data->reg_als_it, &index); 404 else 405 ret = regmap_field_read(data->reg_ps_it, &index); 406 if (ret < 0) 407 return ret; 408 409 *val = stk3310_it_table[index][0]; 410 *val2 = stk3310_it_table[index][1]; 411 return IIO_VAL_INT_PLUS_MICRO; 412 case IIO_CHAN_INFO_SCALE: 413 if (chan->type == IIO_LIGHT) 414 ret = regmap_field_read(data->reg_als_gain, &index); 415 else 416 ret = regmap_field_read(data->reg_ps_gain, &index); 417 if (ret < 0) 418 return ret; 419 420 *val = stk3310_scale_table[index][0]; 421 *val2 = stk3310_scale_table[index][1]; 422 return IIO_VAL_INT_PLUS_MICRO; 423 } 424 425 return -EINVAL; 426 } 427 428 static int stk3310_write_raw(struct iio_dev *indio_dev, 429 struct iio_chan_spec const *chan, 430 int val, int val2, long mask) 431 { 432 int ret; 433 int index; 434 struct stk3310_data *data = iio_priv(indio_dev); 435 436 if (chan->type != IIO_LIGHT && chan->type != IIO_PROXIMITY) 437 return -EINVAL; 438 439 switch (mask) { 440 case IIO_CHAN_INFO_INT_TIME: 441 index = stk3310_get_index(stk3310_it_table, 442 ARRAY_SIZE(stk3310_it_table), 443 val, val2); 444 if (index < 0) 445 return -EINVAL; 446 mutex_lock(&data->lock); 447 if (chan->type == IIO_LIGHT) 448 ret = regmap_field_write(data->reg_als_it, index); 449 else 450 ret = regmap_field_write(data->reg_ps_it, index); 451 if (ret < 0) 452 dev_err(&data->client->dev, 453 "sensor configuration failed\n"); 454 mutex_unlock(&data->lock); 455 return ret; 456 457 case IIO_CHAN_INFO_SCALE: 458 index = stk3310_get_index(stk3310_scale_table, 459 ARRAY_SIZE(stk3310_scale_table), 460 val, val2); 461 if (index < 0) 462 return -EINVAL; 463 mutex_lock(&data->lock); 464 if (chan->type == IIO_LIGHT) 465 ret = regmap_field_write(data->reg_als_gain, index); 466 else 467 ret = regmap_field_write(data->reg_ps_gain, index); 468 if (ret < 0) 469 dev_err(&data->client->dev, 470 "sensor configuration failed\n"); 471 mutex_unlock(&data->lock); 472 return ret; 473 } 474 475 return -EINVAL; 476 } 477 478 static const struct iio_info stk3310_info = { 479 .read_raw = stk3310_read_raw, 480 .write_raw = stk3310_write_raw, 481 .attrs = &stk3310_attribute_group, 482 .read_event_value = stk3310_read_event, 483 .write_event_value = stk3310_write_event, 484 .read_event_config = stk3310_read_event_config, 485 .write_event_config = stk3310_write_event_config, 486 }; 487 488 static int stk3310_set_state(struct stk3310_data *data, u8 state) 489 { 490 int ret; 491 struct i2c_client *client = data->client; 492 493 /* 3-bit state; 0b100 is not supported. */ 494 if (state > 7 || state == 4) 495 return -EINVAL; 496 497 mutex_lock(&data->lock); 498 ret = regmap_field_write(data->reg_state, state); 499 if (ret < 0) { 500 dev_err(&client->dev, "failed to change sensor state\n"); 501 } else if (state != STK3310_STATE_STANDBY) { 502 /* Don't reset the 'enabled' flags if we're going in standby */ 503 data->ps_enabled = !!(state & STK3310_STATE_EN_PS); 504 data->als_enabled = !!(state & STK3310_STATE_EN_ALS); 505 } 506 mutex_unlock(&data->lock); 507 508 return ret; 509 } 510 511 static int stk3310_init(struct iio_dev *indio_dev) 512 { 513 int ret; 514 int chipid; 515 u8 state; 516 struct stk3310_data *data = iio_priv(indio_dev); 517 struct i2c_client *client = data->client; 518 519 ret = regmap_read(data->regmap, STK3310_REG_ID, &chipid); 520 if (ret < 0) 521 return ret; 522 523 ret = stk3310_check_chip_id(chipid); 524 if (ret < 0) 525 dev_info(&client->dev, "new unknown chip id: 0x%x\n", chipid); 526 527 state = STK3310_STATE_EN_ALS | STK3310_STATE_EN_PS; 528 ret = stk3310_set_state(data, state); 529 if (ret < 0) { 530 dev_err(&client->dev, "failed to enable sensor"); 531 return ret; 532 } 533 534 /* Enable PS interrupts */ 535 ret = regmap_field_write(data->reg_int_ps, STK3310_PSINT_EN); 536 if (ret < 0) { 537 dev_err(&client->dev, "failed to enable interrupts!\n"); 538 return ret; 539 } 540 541 data->ps_int_enabled = true; 542 data->ps_thdh = STK3310_PS_MAX_VAL; 543 544 return 0; 545 } 546 547 static bool stk3310_is_volatile_reg(struct device *dev, unsigned int reg) 548 { 549 switch (reg) { 550 case STK3310_REG_ALS_DATA_MSB: 551 case STK3310_REG_ALS_DATA_LSB: 552 case STK3310_REG_PS_DATA_LSB: 553 case STK3310_REG_PS_DATA_MSB: 554 case STK3310_REG_FLAG: 555 return true; 556 default: 557 return false; 558 } 559 } 560 561 static const struct regmap_config stk3310_regmap_config = { 562 .name = "stk3310_regmap", 563 .reg_bits = 8, 564 .val_bits = 8, 565 .max_register = STK3310_MAX_REG, 566 .cache_type = REGCACHE_RBTREE, 567 .volatile_reg = stk3310_is_volatile_reg, 568 }; 569 570 static int stk3310_regmap_init(struct stk3310_data *data) 571 { 572 struct regmap *regmap; 573 struct i2c_client *client; 574 575 client = data->client; 576 regmap = devm_regmap_init_i2c(client, &stk3310_regmap_config); 577 if (IS_ERR(regmap)) { 578 dev_err(&client->dev, "regmap initialization failed.\n"); 579 return PTR_ERR(regmap); 580 } 581 data->regmap = regmap; 582 583 STK3310_REGFIELD(state); 584 STK3310_REGFIELD(als_gain); 585 STK3310_REGFIELD(ps_gain); 586 STK3310_REGFIELD(als_it); 587 STK3310_REGFIELD(ps_it); 588 STK3310_REGFIELD(int_ps); 589 STK3310_REGFIELD(flag_psint); 590 STK3310_REGFIELD(flag_nf); 591 592 return 0; 593 } 594 595 static irqreturn_t stk3310_irq_handler(int irq, void *private) 596 { 597 struct iio_dev *indio_dev = private; 598 struct stk3310_data *data = iio_priv(indio_dev); 599 600 data->timestamp = iio_get_time_ns(indio_dev); 601 602 return IRQ_WAKE_THREAD; 603 } 604 605 static irqreturn_t stk3310_irq_event_handler(int irq, void *private) 606 { 607 int ret; 608 unsigned int dir; 609 u64 event; 610 611 struct iio_dev *indio_dev = private; 612 struct stk3310_data *data = iio_priv(indio_dev); 613 614 /* Read FLAG_NF to figure out what threshold has been met. */ 615 mutex_lock(&data->lock); 616 ret = regmap_field_read(data->reg_flag_nf, &dir); 617 if (ret < 0) { 618 dev_err(&data->client->dev, "register read failed: %d\n", ret); 619 goto out; 620 } 621 event = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 1, 622 IIO_EV_TYPE_THRESH, 623 (dir ? IIO_EV_DIR_FALLING : 624 IIO_EV_DIR_RISING)); 625 iio_push_event(indio_dev, event, data->timestamp); 626 627 /* Reset the interrupt flag */ 628 ret = regmap_field_write(data->reg_flag_psint, 0); 629 if (ret < 0) 630 dev_err(&data->client->dev, "failed to reset interrupts\n"); 631 out: 632 mutex_unlock(&data->lock); 633 634 return IRQ_HANDLED; 635 } 636 637 static int stk3310_probe(struct i2c_client *client) 638 { 639 int ret; 640 struct iio_dev *indio_dev; 641 struct stk3310_data *data; 642 643 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 644 if (!indio_dev) 645 return -ENOMEM; 646 647 data = iio_priv(indio_dev); 648 data->client = client; 649 i2c_set_clientdata(client, indio_dev); 650 651 device_property_read_u32(&client->dev, "proximity-near-level", 652 &data->ps_near_level); 653 654 mutex_init(&data->lock); 655 656 ret = stk3310_regmap_init(data); 657 if (ret < 0) 658 return ret; 659 660 indio_dev->info = &stk3310_info; 661 indio_dev->name = STK3310_DRIVER_NAME; 662 indio_dev->modes = INDIO_DIRECT_MODE; 663 indio_dev->channels = stk3310_channels; 664 indio_dev->num_channels = ARRAY_SIZE(stk3310_channels); 665 666 ret = stk3310_init(indio_dev); 667 if (ret < 0) 668 return ret; 669 670 if (client->irq > 0) { 671 ret = devm_request_threaded_irq(&client->dev, client->irq, 672 stk3310_irq_handler, 673 stk3310_irq_event_handler, 674 IRQF_TRIGGER_FALLING | 675 IRQF_ONESHOT, 676 "stk3310_event", indio_dev); 677 if (ret < 0) { 678 dev_err(&client->dev, "request irq %d failed\n", 679 client->irq); 680 goto err_standby; 681 } 682 } 683 684 ret = iio_device_register(indio_dev); 685 if (ret < 0) { 686 dev_err(&client->dev, "device_register failed\n"); 687 goto err_standby; 688 } 689 690 return 0; 691 692 err_standby: 693 stk3310_set_state(data, STK3310_STATE_STANDBY); 694 return ret; 695 } 696 697 static void stk3310_remove(struct i2c_client *client) 698 { 699 struct iio_dev *indio_dev = i2c_get_clientdata(client); 700 701 iio_device_unregister(indio_dev); 702 stk3310_set_state(iio_priv(indio_dev), STK3310_STATE_STANDBY); 703 } 704 705 static int stk3310_suspend(struct device *dev) 706 { 707 struct stk3310_data *data; 708 int ret; 709 710 data = iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 711 712 if (data->ps_int_enabled) { 713 ret = regmap_field_write(data->reg_int_ps, 0x0); 714 if (ret < 0) { 715 dev_err(dev, "failed to disable ps int at suspend.\n"); 716 return ret; 717 } 718 } 719 720 return stk3310_set_state(data, STK3310_STATE_STANDBY); 721 } 722 723 static int stk3310_resume(struct device *dev) 724 { 725 u8 state = 0; 726 struct stk3310_data *data; 727 __be16 buf; 728 int ret; 729 730 data = iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 731 if (data->ps_enabled) 732 state |= STK3310_STATE_EN_PS; 733 if (data->als_enabled) 734 state |= STK3310_STATE_EN_ALS; 735 736 ret = stk3310_set_state(data, state); 737 if (ret < 0) 738 return ret; 739 740 if (data->ps_thdl != 0x0) { 741 buf = cpu_to_be16(data->ps_thdl); 742 ret = regmap_bulk_write(data->regmap, STK3310_REG_THDL_PS, &buf, sizeof(buf)); 743 if (ret < 0) { 744 dev_err(dev, "failed to set reg THDL_PS at resume.\n"); 745 return ret; 746 } 747 } 748 749 if (data->ps_thdh != STK3310_PS_MAX_VAL) { 750 buf = cpu_to_be16(data->ps_thdh); 751 ret = regmap_bulk_write(data->regmap, STK3310_REG_THDH_PS, &buf, sizeof(buf)); 752 if (ret < 0) { 753 dev_err(dev, "failed to set reg THDH_PS at resume.\n"); 754 return ret; 755 } 756 } 757 758 if (data->ps_int_enabled) { 759 ret = regmap_field_write(data->reg_int_ps, STK3310_PSINT_EN); 760 if (ret < 0) { 761 dev_err(dev, "failed to enable ps int at resume.\n"); 762 return ret; 763 } 764 } 765 766 return 0; 767 } 768 769 static DEFINE_SIMPLE_DEV_PM_OPS(stk3310_pm_ops, stk3310_suspend, 770 stk3310_resume); 771 772 static const struct i2c_device_id stk3310_i2c_id[] = { 773 { .name = "STK3013" }, 774 { .name = "STK3310" }, 775 { .name = "STK3311" }, 776 { .name = "STK3335" }, 777 { } 778 }; 779 MODULE_DEVICE_TABLE(i2c, stk3310_i2c_id); 780 781 static const struct acpi_device_id stk3310_acpi_id[] = { 782 {"STK3013", 0}, 783 {"STK3310", 0}, 784 {"STK3311", 0}, 785 { } 786 }; 787 788 MODULE_DEVICE_TABLE(acpi, stk3310_acpi_id); 789 790 static const struct of_device_id stk3310_of_match[] = { 791 { .compatible = "sensortek,stk3013", }, 792 { .compatible = "sensortek,stk3310", }, 793 { .compatible = "sensortek,stk3311", }, 794 { .compatible = "sensortek,stk3335", }, 795 { } 796 }; 797 MODULE_DEVICE_TABLE(of, stk3310_of_match); 798 799 static struct i2c_driver stk3310_driver = { 800 .driver = { 801 .name = "stk3310", 802 .of_match_table = stk3310_of_match, 803 .pm = pm_sleep_ptr(&stk3310_pm_ops), 804 .acpi_match_table = stk3310_acpi_id, 805 }, 806 .probe = stk3310_probe, 807 .remove = stk3310_remove, 808 .id_table = stk3310_i2c_id, 809 }; 810 811 module_i2c_driver(stk3310_driver); 812 813 MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>"); 814 MODULE_DESCRIPTION("STK3310 Ambient Light and Proximity Sensor driver"); 815 MODULE_LICENSE("GPL v2"); 816