1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * RPR-0521 ROHM Ambient Light and Proximity Sensor 4 * 5 * Copyright (c) 2015, Intel Corporation. 6 * 7 * IIO driver for RPR-0521RS (7-bit I2C slave address 0x38). 8 * 9 * TODO: illuminance channel 10 */ 11 12 #include <linux/module.h> 13 #include <linux/mod_devicetable.h> 14 #include <linux/cleanup.h> 15 #include <linux/init.h> 16 #include <linux/i2c.h> 17 #include <linux/regmap.h> 18 #include <linux/delay.h> 19 20 #include <linux/iio/iio.h> 21 #include <linux/iio/buffer.h> 22 #include <linux/iio/trigger.h> 23 #include <linux/iio/trigger_consumer.h> 24 #include <linux/iio/triggered_buffer.h> 25 #include <linux/iio/sysfs.h> 26 #include <linux/pm_runtime.h> 27 28 #define RPR0521_REG_SYSTEM_CTRL 0x40 29 #define RPR0521_REG_MODE_CTRL 0x41 30 #define RPR0521_REG_ALS_CTRL 0x42 31 #define RPR0521_REG_PXS_CTRL 0x43 32 #define RPR0521_REG_PXS_DATA 0x44 /* 16-bit, little endian */ 33 #define RPR0521_REG_ALS_DATA0 0x46 /* 16-bit, little endian */ 34 #define RPR0521_REG_ALS_DATA1 0x48 /* 16-bit, little endian */ 35 #define RPR0521_REG_INTERRUPT 0x4A 36 #define RPR0521_REG_PS_OFFSET_LSB 0x53 37 #define RPR0521_REG_ID 0x92 38 39 #define RPR0521_MODE_ALS_MASK BIT(7) 40 #define RPR0521_MODE_PXS_MASK BIT(6) 41 #define RPR0521_MODE_MEAS_TIME_MASK GENMASK(3, 0) 42 #define RPR0521_ALS_DATA0_GAIN_MASK GENMASK(5, 4) 43 #define RPR0521_ALS_DATA0_GAIN_SHIFT 4 44 #define RPR0521_ALS_DATA1_GAIN_MASK GENMASK(3, 2) 45 #define RPR0521_ALS_DATA1_GAIN_SHIFT 2 46 #define RPR0521_PXS_GAIN_MASK GENMASK(5, 4) 47 #define RPR0521_PXS_GAIN_SHIFT 4 48 #define RPR0521_PXS_PERSISTENCE_MASK GENMASK(3, 0) 49 #define RPR0521_INTERRUPT_INT_TRIG_PS_MASK BIT(0) 50 #define RPR0521_INTERRUPT_INT_TRIG_ALS_MASK BIT(1) 51 #define RPR0521_INTERRUPT_INT_REASSERT_MASK BIT(3) 52 #define RPR0521_INTERRUPT_ALS_INT_STATUS_MASK BIT(6) 53 #define RPR0521_INTERRUPT_PS_INT_STATUS_MASK BIT(7) 54 55 #define RPR0521_MODE_ALS_ENABLE BIT(7) 56 #define RPR0521_MODE_ALS_DISABLE 0x00 57 #define RPR0521_MODE_PXS_ENABLE BIT(6) 58 #define RPR0521_MODE_PXS_DISABLE 0x00 59 #define RPR0521_PXS_PERSISTENCE_DRDY 0x00 60 61 #define RPR0521_INTERRUPT_INT_TRIG_PS_ENABLE BIT(0) 62 #define RPR0521_INTERRUPT_INT_TRIG_PS_DISABLE 0x00 63 #define RPR0521_INTERRUPT_INT_TRIG_ALS_ENABLE BIT(1) 64 #define RPR0521_INTERRUPT_INT_TRIG_ALS_DISABLE 0x00 65 #define RPR0521_INTERRUPT_INT_REASSERT_ENABLE BIT(3) 66 #define RPR0521_INTERRUPT_INT_REASSERT_DISABLE 0x00 67 68 #define RPR0521_MANUFACT_ID 0xE0 69 #define RPR0521_DEFAULT_MEAS_TIME 0x06 /* ALS - 100ms, PXS - 100ms */ 70 71 #define RPR0521_DRV_NAME "RPR0521" 72 #define RPR0521_IRQ_NAME "rpr0521_event" 73 #define RPR0521_REGMAP_NAME "rpr0521_regmap" 74 75 #define RPR0521_SLEEP_DELAY_MS 2000 76 77 #define RPR0521_ALS_SCALE_AVAIL "0.007812 0.015625 0.5 1" 78 #define RPR0521_PXS_SCALE_AVAIL "0.125 0.5 1" 79 80 struct rpr0521_gain { 81 int scale; 82 int uscale; 83 }; 84 85 static const struct rpr0521_gain rpr0521_als_gain[4] = { 86 {1, 0}, /* x1 */ 87 {0, 500000}, /* x2 */ 88 {0, 15625}, /* x64 */ 89 {0, 7812}, /* x128 */ 90 }; 91 92 static const struct rpr0521_gain rpr0521_pxs_gain[3] = { 93 {1, 0}, /* x1 */ 94 {0, 500000}, /* x2 */ 95 {0, 125000}, /* x4 */ 96 }; 97 98 enum rpr0521_channel { 99 RPR0521_CHAN_PXS, 100 RPR0521_CHAN_ALS_DATA0, 101 RPR0521_CHAN_ALS_DATA1, 102 }; 103 104 struct rpr0521_reg_desc { 105 u8 address; 106 u8 device_mask; 107 }; 108 109 static const struct rpr0521_reg_desc rpr0521_data_reg[] = { 110 [RPR0521_CHAN_PXS] = { 111 .address = RPR0521_REG_PXS_DATA, 112 .device_mask = RPR0521_MODE_PXS_MASK, 113 }, 114 [RPR0521_CHAN_ALS_DATA0] = { 115 .address = RPR0521_REG_ALS_DATA0, 116 .device_mask = RPR0521_MODE_ALS_MASK, 117 }, 118 [RPR0521_CHAN_ALS_DATA1] = { 119 .address = RPR0521_REG_ALS_DATA1, 120 .device_mask = RPR0521_MODE_ALS_MASK, 121 }, 122 }; 123 124 static const struct rpr0521_gain_info { 125 u8 reg; 126 u8 mask; 127 u8 shift; 128 const struct rpr0521_gain *gain; 129 int size; 130 } rpr0521_gain[] = { 131 [RPR0521_CHAN_PXS] = { 132 .reg = RPR0521_REG_PXS_CTRL, 133 .mask = RPR0521_PXS_GAIN_MASK, 134 .shift = RPR0521_PXS_GAIN_SHIFT, 135 .gain = rpr0521_pxs_gain, 136 .size = ARRAY_SIZE(rpr0521_pxs_gain), 137 }, 138 [RPR0521_CHAN_ALS_DATA0] = { 139 .reg = RPR0521_REG_ALS_CTRL, 140 .mask = RPR0521_ALS_DATA0_GAIN_MASK, 141 .shift = RPR0521_ALS_DATA0_GAIN_SHIFT, 142 .gain = rpr0521_als_gain, 143 .size = ARRAY_SIZE(rpr0521_als_gain), 144 }, 145 [RPR0521_CHAN_ALS_DATA1] = { 146 .reg = RPR0521_REG_ALS_CTRL, 147 .mask = RPR0521_ALS_DATA1_GAIN_MASK, 148 .shift = RPR0521_ALS_DATA1_GAIN_SHIFT, 149 .gain = rpr0521_als_gain, 150 .size = ARRAY_SIZE(rpr0521_als_gain), 151 }, 152 }; 153 154 struct rpr0521_samp_freq { 155 int als_hz; 156 int als_uhz; 157 int pxs_hz; 158 int pxs_uhz; 159 }; 160 161 static const struct rpr0521_samp_freq rpr0521_samp_freq_i[13] = { 162 /* {ALS, PXS}, W==currently writable option */ 163 {0, 0, 0, 0}, /* W0000, 0=standby */ 164 {0, 0, 100, 0}, /* 0001 */ 165 {0, 0, 25, 0}, /* 0010 */ 166 {0, 0, 10, 0}, /* 0011 */ 167 {0, 0, 2, 500000}, /* 0100 */ 168 {10, 0, 20, 0}, /* 0101 */ 169 {10, 0, 10, 0}, /* W0110 */ 170 {10, 0, 2, 500000}, /* 0111 */ 171 {2, 500000, 20, 0}, /* 1000, measurement 100ms, sleep 300ms */ 172 {2, 500000, 10, 0}, /* 1001, measurement 100ms, sleep 300ms */ 173 {2, 500000, 0, 0}, /* 1010, high sensitivity mode */ 174 {2, 500000, 2, 500000}, /* W1011, high sensitivity mode */ 175 {20, 0, 20, 0} /* 1100, ALS_data x 0.5, see specification P.18 */ 176 }; 177 178 struct rpr0521_data { 179 struct i2c_client *client; 180 181 /* protect device params updates (e.g state, gain) */ 182 struct mutex lock; 183 184 /* device active status */ 185 bool als_dev_en; 186 bool pxs_dev_en; 187 188 struct iio_trigger *drdy_trigger0; 189 s64 irq_timestamp; 190 191 /* optimize runtime pm ops - enable/disable device only if needed */ 192 bool als_ps_need_en; 193 bool pxs_ps_need_en; 194 bool als_need_dis; 195 bool pxs_need_dis; 196 197 struct regmap *regmap; 198 199 /* 200 * Ensure correct naturally aligned timestamp. 201 * Note that the read will put garbage data into 202 * the padding but this should not be a problem 203 */ 204 struct { 205 __le16 channels[3]; 206 u8 garbage; 207 aligned_s64 ts; 208 } scan; 209 }; 210 211 static IIO_CONST_ATTR(in_intensity_scale_available, RPR0521_ALS_SCALE_AVAIL); 212 static IIO_CONST_ATTR(in_proximity_scale_available, RPR0521_PXS_SCALE_AVAIL); 213 214 /* 215 * Start with easy freq first, whole table of freq combinations is more 216 * complicated. 217 */ 218 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("2.5 10"); 219 220 static struct attribute *rpr0521_attributes[] = { 221 &iio_const_attr_in_intensity_scale_available.dev_attr.attr, 222 &iio_const_attr_in_proximity_scale_available.dev_attr.attr, 223 &iio_const_attr_sampling_frequency_available.dev_attr.attr, 224 NULL, 225 }; 226 227 static const struct attribute_group rpr0521_attribute_group = { 228 .attrs = rpr0521_attributes, 229 }; 230 231 /* Order of the channel data in buffer */ 232 enum rpr0521_scan_index_order { 233 RPR0521_CHAN_INDEX_PXS, 234 RPR0521_CHAN_INDEX_BOTH, 235 RPR0521_CHAN_INDEX_IR, 236 }; 237 238 static const unsigned long rpr0521_available_scan_masks[] = { 239 BIT(RPR0521_CHAN_INDEX_PXS) | BIT(RPR0521_CHAN_INDEX_BOTH) | 240 BIT(RPR0521_CHAN_INDEX_IR), 241 0 242 }; 243 244 static const struct iio_chan_spec rpr0521_channels[] = { 245 { 246 .type = IIO_PROXIMITY, 247 .address = RPR0521_CHAN_PXS, 248 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 249 BIT(IIO_CHAN_INFO_OFFSET) | 250 BIT(IIO_CHAN_INFO_SCALE), 251 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), 252 .scan_index = RPR0521_CHAN_INDEX_PXS, 253 .scan_type = { 254 .sign = 'u', 255 .realbits = 16, 256 .storagebits = 16, 257 .endianness = IIO_LE, 258 }, 259 }, 260 { 261 .type = IIO_INTENSITY, 262 .modified = 1, 263 .address = RPR0521_CHAN_ALS_DATA0, 264 .channel2 = IIO_MOD_LIGHT_BOTH, 265 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 266 BIT(IIO_CHAN_INFO_SCALE), 267 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), 268 .scan_index = RPR0521_CHAN_INDEX_BOTH, 269 .scan_type = { 270 .sign = 'u', 271 .realbits = 16, 272 .storagebits = 16, 273 .endianness = IIO_LE, 274 }, 275 }, 276 { 277 .type = IIO_INTENSITY, 278 .modified = 1, 279 .address = RPR0521_CHAN_ALS_DATA1, 280 .channel2 = IIO_MOD_LIGHT_IR, 281 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 282 BIT(IIO_CHAN_INFO_SCALE), 283 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), 284 .scan_index = RPR0521_CHAN_INDEX_IR, 285 .scan_type = { 286 .sign = 'u', 287 .realbits = 16, 288 .storagebits = 16, 289 .endianness = IIO_LE, 290 }, 291 }, 292 }; 293 294 static int rpr0521_als_enable(struct rpr0521_data *data, u8 status) 295 { 296 int ret; 297 298 ret = regmap_update_bits(data->regmap, RPR0521_REG_MODE_CTRL, 299 RPR0521_MODE_ALS_MASK, 300 status); 301 if (ret < 0) 302 return ret; 303 304 if (status & RPR0521_MODE_ALS_MASK) 305 data->als_dev_en = true; 306 else 307 data->als_dev_en = false; 308 309 return 0; 310 } 311 312 static int rpr0521_pxs_enable(struct rpr0521_data *data, u8 status) 313 { 314 int ret; 315 316 ret = regmap_update_bits(data->regmap, RPR0521_REG_MODE_CTRL, 317 RPR0521_MODE_PXS_MASK, 318 status); 319 if (ret < 0) 320 return ret; 321 322 if (status & RPR0521_MODE_PXS_MASK) 323 data->pxs_dev_en = true; 324 else 325 data->pxs_dev_en = false; 326 327 return 0; 328 } 329 330 /** 331 * rpr0521_set_power_state - handles runtime PM state and sensors enabled status 332 * 333 * @data: rpr0521 device private data 334 * @on: state to be set for devices in @device_mask 335 * @device_mask: bitmask specifying for which device we need to update @on state 336 * 337 * Calls for this function must be balanced so that each ON should have matching 338 * OFF. Otherwise pm usage_count gets out of sync. 339 */ 340 static int rpr0521_set_power_state(struct rpr0521_data *data, bool on, 341 u8 device_mask) 342 { 343 #ifdef CONFIG_PM 344 int ret; 345 346 if (device_mask & RPR0521_MODE_ALS_MASK) { 347 data->als_ps_need_en = on; 348 data->als_need_dis = !on; 349 } 350 351 if (device_mask & RPR0521_MODE_PXS_MASK) { 352 data->pxs_ps_need_en = on; 353 data->pxs_need_dis = !on; 354 } 355 356 /* 357 * On: _resume() is called only when we are suspended 358 * Off: _suspend() is called after delay if _resume() is not 359 * called before that. 360 * Note: If either measurement is re-enabled before _suspend(), 361 * both stay enabled until _suspend(). 362 */ 363 if (on) { 364 ret = pm_runtime_resume_and_get(&data->client->dev); 365 } else { 366 pm_runtime_mark_last_busy(&data->client->dev); 367 ret = pm_runtime_put_autosuspend(&data->client->dev); 368 } 369 if (ret < 0) { 370 dev_err(&data->client->dev, 371 "Failed: rpr0521_set_power_state for %d, ret %d\n", 372 on, ret); 373 return ret; 374 } 375 376 if (on) { 377 /* If _resume() was not called, enable measurement now. */ 378 if (data->als_ps_need_en) { 379 ret = rpr0521_als_enable(data, RPR0521_MODE_ALS_ENABLE); 380 if (ret) 381 return ret; 382 data->als_ps_need_en = false; 383 } 384 385 if (data->pxs_ps_need_en) { 386 ret = rpr0521_pxs_enable(data, RPR0521_MODE_PXS_ENABLE); 387 if (ret) 388 return ret; 389 data->pxs_ps_need_en = false; 390 } 391 } 392 #endif 393 return 0; 394 } 395 396 /* Interrupt register tells if this sensor caused the interrupt or not. */ 397 static inline bool rpr0521_is_triggered(struct rpr0521_data *data) 398 { 399 int ret; 400 int reg; 401 402 ret = regmap_read(data->regmap, RPR0521_REG_INTERRUPT, ®); 403 if (ret < 0) 404 return false; /* Reg read failed. */ 405 if (reg & 406 (RPR0521_INTERRUPT_ALS_INT_STATUS_MASK | 407 RPR0521_INTERRUPT_PS_INT_STATUS_MASK)) 408 return true; 409 else 410 return false; /* Int not from this sensor. */ 411 } 412 413 /* IRQ to trigger handler */ 414 static irqreturn_t rpr0521_drdy_irq_handler(int irq, void *private) 415 { 416 struct iio_dev *indio_dev = private; 417 struct rpr0521_data *data = iio_priv(indio_dev); 418 419 data->irq_timestamp = iio_get_time_ns(indio_dev); 420 /* 421 * We need to wake the thread to read the interrupt reg. It 422 * is not possible to do that here because regmap_read takes a 423 * mutex. 424 */ 425 426 return IRQ_WAKE_THREAD; 427 } 428 429 static irqreturn_t rpr0521_drdy_irq_thread(int irq, void *private) 430 { 431 struct iio_dev *indio_dev = private; 432 struct rpr0521_data *data = iio_priv(indio_dev); 433 434 if (rpr0521_is_triggered(data)) { 435 iio_trigger_poll_nested(data->drdy_trigger0); 436 return IRQ_HANDLED; 437 } 438 439 return IRQ_NONE; 440 } 441 442 static irqreturn_t rpr0521_trigger_consumer_handler(int irq, void *p) 443 { 444 struct iio_poll_func *pf = p; 445 struct iio_dev *indio_dev = pf->indio_dev; 446 struct rpr0521_data *data = iio_priv(indio_dev); 447 int err; 448 449 /* Use irq timestamp when reasonable. */ 450 if (iio_trigger_using_own(indio_dev) && data->irq_timestamp) { 451 pf->timestamp = data->irq_timestamp; 452 data->irq_timestamp = 0; 453 } 454 /* Other chained trigger polls get timestamp only here. */ 455 if (!pf->timestamp) 456 pf->timestamp = iio_get_time_ns(indio_dev); 457 458 err = regmap_bulk_read(data->regmap, RPR0521_REG_PXS_DATA, 459 data->scan.channels, 460 (3 * 2) + 1); /* 3 * 16-bit + (discarded) int clear reg. */ 461 if (!err) 462 iio_push_to_buffers_with_timestamp(indio_dev, 463 &data->scan, pf->timestamp); 464 else 465 dev_err(&data->client->dev, 466 "Trigger consumer can't read from sensor.\n"); 467 pf->timestamp = 0; 468 469 iio_trigger_notify_done(indio_dev->trig); 470 471 return IRQ_HANDLED; 472 } 473 474 static int rpr0521_write_int_enable(struct rpr0521_data *data) 475 { 476 int err; 477 478 /* Interrupt after each measurement */ 479 err = regmap_update_bits(data->regmap, RPR0521_REG_PXS_CTRL, 480 RPR0521_PXS_PERSISTENCE_MASK, 481 RPR0521_PXS_PERSISTENCE_DRDY); 482 if (err) { 483 dev_err(&data->client->dev, "PS control reg write fail.\n"); 484 return -EBUSY; 485 } 486 487 /* Ignore latch and mode because of drdy */ 488 err = regmap_write(data->regmap, RPR0521_REG_INTERRUPT, 489 RPR0521_INTERRUPT_INT_REASSERT_DISABLE | 490 RPR0521_INTERRUPT_INT_TRIG_ALS_DISABLE | 491 RPR0521_INTERRUPT_INT_TRIG_PS_ENABLE 492 ); 493 if (err) { 494 dev_err(&data->client->dev, "Interrupt setup write fail.\n"); 495 return -EBUSY; 496 } 497 498 return 0; 499 } 500 501 static int rpr0521_write_int_disable(struct rpr0521_data *data) 502 { 503 /* Don't care of clearing mode, assert and latch. */ 504 return regmap_write(data->regmap, RPR0521_REG_INTERRUPT, 505 RPR0521_INTERRUPT_INT_TRIG_ALS_DISABLE | 506 RPR0521_INTERRUPT_INT_TRIG_PS_DISABLE 507 ); 508 } 509 510 /* 511 * Trigger producer enable / disable. Note that there will be trigs only when 512 * measurement data is ready to be read. 513 */ 514 static int rpr0521_pxs_drdy_set_state(struct iio_trigger *trigger, 515 bool enable_drdy) 516 { 517 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trigger); 518 struct rpr0521_data *data = iio_priv(indio_dev); 519 int err; 520 521 if (enable_drdy) 522 err = rpr0521_write_int_enable(data); 523 else 524 err = rpr0521_write_int_disable(data); 525 if (err) 526 dev_err(&data->client->dev, "rpr0521_pxs_drdy_set_state failed\n"); 527 528 return err; 529 } 530 531 static const struct iio_trigger_ops rpr0521_trigger_ops = { 532 .set_trigger_state = rpr0521_pxs_drdy_set_state, 533 }; 534 535 536 static int rpr0521_buffer_preenable(struct iio_dev *indio_dev) 537 { 538 int err; 539 struct rpr0521_data *data = iio_priv(indio_dev); 540 541 mutex_lock(&data->lock); 542 err = rpr0521_set_power_state(data, true, 543 (RPR0521_MODE_PXS_MASK | RPR0521_MODE_ALS_MASK)); 544 mutex_unlock(&data->lock); 545 if (err) 546 dev_err(&data->client->dev, "_buffer_preenable fail\n"); 547 548 return err; 549 } 550 551 static int rpr0521_buffer_postdisable(struct iio_dev *indio_dev) 552 { 553 int err; 554 struct rpr0521_data *data = iio_priv(indio_dev); 555 556 mutex_lock(&data->lock); 557 err = rpr0521_set_power_state(data, false, 558 (RPR0521_MODE_PXS_MASK | RPR0521_MODE_ALS_MASK)); 559 mutex_unlock(&data->lock); 560 if (err) 561 dev_err(&data->client->dev, "_buffer_postdisable fail\n"); 562 563 return err; 564 } 565 566 static const struct iio_buffer_setup_ops rpr0521_buffer_setup_ops = { 567 .preenable = rpr0521_buffer_preenable, 568 .postdisable = rpr0521_buffer_postdisable, 569 }; 570 571 static int rpr0521_get_gain(struct rpr0521_data *data, int chan, 572 int *val, int *val2) 573 { 574 int ret, reg, idx; 575 576 ret = regmap_read(data->regmap, rpr0521_gain[chan].reg, ®); 577 if (ret < 0) 578 return ret; 579 580 idx = (rpr0521_gain[chan].mask & reg) >> rpr0521_gain[chan].shift; 581 *val = rpr0521_gain[chan].gain[idx].scale; 582 *val2 = rpr0521_gain[chan].gain[idx].uscale; 583 584 return 0; 585 } 586 587 static int rpr0521_set_gain(struct rpr0521_data *data, int chan, 588 int val, int val2) 589 { 590 int i, idx = -EINVAL; 591 592 /* get gain index */ 593 for (i = 0; i < rpr0521_gain[chan].size; i++) 594 if (val == rpr0521_gain[chan].gain[i].scale && 595 val2 == rpr0521_gain[chan].gain[i].uscale) { 596 idx = i; 597 break; 598 } 599 600 if (idx < 0) 601 return idx; 602 603 return regmap_update_bits(data->regmap, rpr0521_gain[chan].reg, 604 rpr0521_gain[chan].mask, 605 idx << rpr0521_gain[chan].shift); 606 } 607 608 static int rpr0521_read_samp_freq(struct rpr0521_data *data, 609 enum iio_chan_type chan_type, 610 int *val, int *val2) 611 { 612 int reg, ret; 613 614 ret = regmap_read(data->regmap, RPR0521_REG_MODE_CTRL, ®); 615 if (ret < 0) 616 return ret; 617 618 reg &= RPR0521_MODE_MEAS_TIME_MASK; 619 if (reg >= ARRAY_SIZE(rpr0521_samp_freq_i)) 620 return -EINVAL; 621 622 switch (chan_type) { 623 case IIO_INTENSITY: 624 *val = rpr0521_samp_freq_i[reg].als_hz; 625 *val2 = rpr0521_samp_freq_i[reg].als_uhz; 626 return 0; 627 628 case IIO_PROXIMITY: 629 *val = rpr0521_samp_freq_i[reg].pxs_hz; 630 *val2 = rpr0521_samp_freq_i[reg].pxs_uhz; 631 return 0; 632 633 default: 634 return -EINVAL; 635 } 636 } 637 638 static int rpr0521_write_samp_freq_common(struct rpr0521_data *data, 639 enum iio_chan_type chan_type, 640 int val, int val2) 641 { 642 int i; 643 644 /* 645 * Ignore channel 646 * both pxs and als are setup only to same freq because of simplicity 647 */ 648 switch (val) { 649 case 0: 650 i = 0; 651 break; 652 653 case 2: 654 if (val2 != 500000) 655 return -EINVAL; 656 657 i = 11; 658 break; 659 660 case 10: 661 i = 6; 662 break; 663 664 default: 665 return -EINVAL; 666 } 667 668 return regmap_update_bits(data->regmap, 669 RPR0521_REG_MODE_CTRL, 670 RPR0521_MODE_MEAS_TIME_MASK, 671 i); 672 } 673 674 static int rpr0521_read_ps_offset(struct rpr0521_data *data, int *offset) 675 { 676 int ret; 677 __le16 buffer; 678 679 ret = regmap_bulk_read(data->regmap, 680 RPR0521_REG_PS_OFFSET_LSB, &buffer, sizeof(buffer)); 681 682 if (ret < 0) { 683 dev_err(&data->client->dev, "Failed to read PS OFFSET register\n"); 684 return ret; 685 } 686 *offset = le16_to_cpu(buffer); 687 688 return ret; 689 } 690 691 static int rpr0521_write_ps_offset(struct rpr0521_data *data, int offset) 692 { 693 int ret; 694 __le16 buffer; 695 696 buffer = cpu_to_le16(offset & 0x3ff); 697 ret = regmap_raw_write(data->regmap, 698 RPR0521_REG_PS_OFFSET_LSB, &buffer, sizeof(buffer)); 699 700 if (ret < 0) { 701 dev_err(&data->client->dev, "Failed to write PS OFFSET register\n"); 702 return ret; 703 } 704 705 return ret; 706 } 707 708 static int rpr0521_read_info_raw(struct rpr0521_data *data, 709 struct iio_chan_spec const *chan, 710 int *val) 711 { 712 u8 device_mask; 713 __le16 raw_data; 714 int ret; 715 716 device_mask = rpr0521_data_reg[chan->address].device_mask; 717 718 guard(mutex)(&data->lock); 719 ret = rpr0521_set_power_state(data, true, device_mask); 720 if (ret < 0) 721 return ret; 722 723 ret = regmap_bulk_read(data->regmap, 724 rpr0521_data_reg[chan->address].address, 725 &raw_data, sizeof(raw_data)); 726 if (ret < 0) { 727 rpr0521_set_power_state(data, false, device_mask); 728 return ret; 729 } 730 731 ret = rpr0521_set_power_state(data, false, device_mask); 732 if (ret < 0) 733 return ret; 734 735 *val = le16_to_cpu(raw_data); 736 737 return 0; 738 } 739 740 static int rpr0521_read_raw(struct iio_dev *indio_dev, 741 struct iio_chan_spec const *chan, int *val, 742 int *val2, long mask) 743 { 744 struct rpr0521_data *data = iio_priv(indio_dev); 745 int ret; 746 747 switch (mask) { 748 case IIO_CHAN_INFO_RAW: 749 if (chan->type != IIO_INTENSITY && chan->type != IIO_PROXIMITY) 750 return -EINVAL; 751 752 if (!iio_device_claim_direct(indio_dev)) 753 return -EBUSY; 754 755 ret = rpr0521_read_info_raw(data, chan, val); 756 iio_device_release_direct(indio_dev); 757 if (ret < 0) 758 return ret; 759 760 return IIO_VAL_INT; 761 762 case IIO_CHAN_INFO_SCALE: 763 mutex_lock(&data->lock); 764 ret = rpr0521_get_gain(data, chan->address, val, val2); 765 mutex_unlock(&data->lock); 766 if (ret < 0) 767 return ret; 768 769 return IIO_VAL_INT_PLUS_MICRO; 770 771 case IIO_CHAN_INFO_SAMP_FREQ: 772 mutex_lock(&data->lock); 773 ret = rpr0521_read_samp_freq(data, chan->type, val, val2); 774 mutex_unlock(&data->lock); 775 if (ret < 0) 776 return ret; 777 778 return IIO_VAL_INT_PLUS_MICRO; 779 780 case IIO_CHAN_INFO_OFFSET: 781 mutex_lock(&data->lock); 782 ret = rpr0521_read_ps_offset(data, val); 783 mutex_unlock(&data->lock); 784 if (ret < 0) 785 return ret; 786 787 return IIO_VAL_INT; 788 789 default: 790 return -EINVAL; 791 } 792 } 793 794 static int rpr0521_write_raw(struct iio_dev *indio_dev, 795 struct iio_chan_spec const *chan, int val, 796 int val2, long mask) 797 { 798 struct rpr0521_data *data = iio_priv(indio_dev); 799 int ret; 800 801 switch (mask) { 802 case IIO_CHAN_INFO_SCALE: 803 mutex_lock(&data->lock); 804 ret = rpr0521_set_gain(data, chan->address, val, val2); 805 mutex_unlock(&data->lock); 806 807 return ret; 808 809 case IIO_CHAN_INFO_SAMP_FREQ: 810 mutex_lock(&data->lock); 811 ret = rpr0521_write_samp_freq_common(data, chan->type, 812 val, val2); 813 mutex_unlock(&data->lock); 814 815 return ret; 816 817 case IIO_CHAN_INFO_OFFSET: 818 mutex_lock(&data->lock); 819 ret = rpr0521_write_ps_offset(data, val); 820 mutex_unlock(&data->lock); 821 822 return ret; 823 824 default: 825 return -EINVAL; 826 } 827 } 828 829 static const struct iio_info rpr0521_info = { 830 .read_raw = rpr0521_read_raw, 831 .write_raw = rpr0521_write_raw, 832 .attrs = &rpr0521_attribute_group, 833 }; 834 835 static int rpr0521_init(struct rpr0521_data *data) 836 { 837 int ret; 838 int id; 839 840 ret = regmap_read(data->regmap, RPR0521_REG_ID, &id); 841 if (ret < 0) { 842 dev_err(&data->client->dev, "Failed to read REG_ID register\n"); 843 return ret; 844 } 845 846 if (id != RPR0521_MANUFACT_ID) { 847 dev_err(&data->client->dev, "Wrong id, got %x, expected %x\n", 848 id, RPR0521_MANUFACT_ID); 849 return -ENODEV; 850 } 851 852 /* set default measurement time - 100 ms for both ALS and PS */ 853 ret = regmap_update_bits(data->regmap, RPR0521_REG_MODE_CTRL, 854 RPR0521_MODE_MEAS_TIME_MASK, 855 RPR0521_DEFAULT_MEAS_TIME); 856 if (ret) { 857 pr_err("regmap_update_bits returned %d\n", ret); 858 return ret; 859 } 860 861 #ifndef CONFIG_PM 862 ret = rpr0521_als_enable(data, RPR0521_MODE_ALS_ENABLE); 863 if (ret < 0) 864 return ret; 865 ret = rpr0521_pxs_enable(data, RPR0521_MODE_PXS_ENABLE); 866 if (ret < 0) 867 return ret; 868 #endif 869 870 data->irq_timestamp = 0; 871 872 return 0; 873 } 874 875 static int rpr0521_poweroff(struct rpr0521_data *data) 876 { 877 int ret; 878 int tmp; 879 880 ret = regmap_update_bits(data->regmap, RPR0521_REG_MODE_CTRL, 881 RPR0521_MODE_ALS_MASK | 882 RPR0521_MODE_PXS_MASK, 883 RPR0521_MODE_ALS_DISABLE | 884 RPR0521_MODE_PXS_DISABLE); 885 if (ret < 0) 886 return ret; 887 888 data->als_dev_en = false; 889 data->pxs_dev_en = false; 890 891 /* 892 * Int pin keeps state after power off. Set pin to high impedance 893 * mode to prevent power drain. 894 */ 895 ret = regmap_read(data->regmap, RPR0521_REG_INTERRUPT, &tmp); 896 if (ret) { 897 dev_err(&data->client->dev, "Failed to reset int pin.\n"); 898 return ret; 899 } 900 901 return 0; 902 } 903 904 static bool rpr0521_is_volatile_reg(struct device *dev, unsigned int reg) 905 { 906 switch (reg) { 907 case RPR0521_REG_MODE_CTRL: 908 case RPR0521_REG_ALS_CTRL: 909 case RPR0521_REG_PXS_CTRL: 910 return false; 911 default: 912 return true; 913 } 914 } 915 916 static const struct regmap_config rpr0521_regmap_config = { 917 .name = RPR0521_REGMAP_NAME, 918 919 .reg_bits = 8, 920 .val_bits = 8, 921 922 .max_register = RPR0521_REG_ID, 923 .cache_type = REGCACHE_RBTREE, 924 .volatile_reg = rpr0521_is_volatile_reg, 925 }; 926 927 static int rpr0521_probe(struct i2c_client *client) 928 { 929 struct rpr0521_data *data; 930 struct iio_dev *indio_dev; 931 struct regmap *regmap; 932 int ret; 933 934 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 935 if (!indio_dev) 936 return -ENOMEM; 937 938 regmap = devm_regmap_init_i2c(client, &rpr0521_regmap_config); 939 if (IS_ERR(regmap)) { 940 dev_err(&client->dev, "regmap_init failed!\n"); 941 return PTR_ERR(regmap); 942 } 943 944 data = iio_priv(indio_dev); 945 i2c_set_clientdata(client, indio_dev); 946 data->client = client; 947 data->regmap = regmap; 948 949 mutex_init(&data->lock); 950 951 indio_dev->info = &rpr0521_info; 952 indio_dev->name = RPR0521_DRV_NAME; 953 indio_dev->channels = rpr0521_channels; 954 indio_dev->num_channels = ARRAY_SIZE(rpr0521_channels); 955 indio_dev->modes = INDIO_DIRECT_MODE; 956 957 ret = rpr0521_init(data); 958 if (ret < 0) { 959 dev_err(&client->dev, "rpr0521 chip init failed\n"); 960 return ret; 961 } 962 963 ret = pm_runtime_set_active(&client->dev); 964 if (ret < 0) 965 goto err_poweroff; 966 967 pm_runtime_enable(&client->dev); 968 pm_runtime_set_autosuspend_delay(&client->dev, RPR0521_SLEEP_DELAY_MS); 969 pm_runtime_use_autosuspend(&client->dev); 970 971 /* 972 * If sensor write/read is needed in _probe after _use_autosuspend, 973 * sensor needs to be _resumed first using rpr0521_set_power_state(). 974 */ 975 976 /* IRQ to trigger setup */ 977 if (client->irq) { 978 /* Trigger0 producer setup */ 979 data->drdy_trigger0 = devm_iio_trigger_alloc( 980 indio_dev->dev.parent, 981 "%s-dev%d", indio_dev->name, iio_device_id(indio_dev)); 982 if (!data->drdy_trigger0) { 983 ret = -ENOMEM; 984 goto err_pm_disable; 985 } 986 data->drdy_trigger0->ops = &rpr0521_trigger_ops; 987 indio_dev->available_scan_masks = rpr0521_available_scan_masks; 988 iio_trigger_set_drvdata(data->drdy_trigger0, indio_dev); 989 990 /* Ties irq to trigger producer handler. */ 991 ret = devm_request_threaded_irq(&client->dev, client->irq, 992 rpr0521_drdy_irq_handler, rpr0521_drdy_irq_thread, 993 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 994 RPR0521_IRQ_NAME, indio_dev); 995 if (ret < 0) { 996 dev_err(&client->dev, "request irq %d for trigger0 failed\n", 997 client->irq); 998 goto err_pm_disable; 999 } 1000 1001 ret = devm_iio_trigger_register(indio_dev->dev.parent, 1002 data->drdy_trigger0); 1003 if (ret) { 1004 dev_err(&client->dev, "iio trigger register failed\n"); 1005 goto err_pm_disable; 1006 } 1007 1008 /* 1009 * Now whole pipe from physical interrupt (irq defined by 1010 * devicetree to device) to trigger0 output is set up. 1011 */ 1012 1013 /* Trigger consumer setup */ 1014 ret = devm_iio_triggered_buffer_setup(indio_dev->dev.parent, 1015 indio_dev, 1016 iio_pollfunc_store_time, 1017 rpr0521_trigger_consumer_handler, 1018 &rpr0521_buffer_setup_ops); 1019 if (ret < 0) { 1020 dev_err(&client->dev, "iio triggered buffer setup failed\n"); 1021 goto err_pm_disable; 1022 } 1023 } 1024 1025 ret = iio_device_register(indio_dev); 1026 if (ret) 1027 goto err_pm_disable; 1028 1029 return 0; 1030 1031 err_pm_disable: 1032 pm_runtime_disable(&client->dev); 1033 pm_runtime_set_suspended(&client->dev); 1034 err_poweroff: 1035 rpr0521_poweroff(data); 1036 1037 return ret; 1038 } 1039 1040 static void rpr0521_remove(struct i2c_client *client) 1041 { 1042 struct iio_dev *indio_dev = i2c_get_clientdata(client); 1043 1044 iio_device_unregister(indio_dev); 1045 1046 pm_runtime_disable(&client->dev); 1047 pm_runtime_set_suspended(&client->dev); 1048 1049 rpr0521_poweroff(iio_priv(indio_dev)); 1050 } 1051 1052 static int rpr0521_runtime_suspend(struct device *dev) 1053 { 1054 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1055 struct rpr0521_data *data = iio_priv(indio_dev); 1056 int ret; 1057 1058 mutex_lock(&data->lock); 1059 /* If measurements are enabled, enable them on resume */ 1060 if (!data->als_need_dis) 1061 data->als_ps_need_en = data->als_dev_en; 1062 if (!data->pxs_need_dis) 1063 data->pxs_ps_need_en = data->pxs_dev_en; 1064 1065 /* disable channels and sets {als,pxs}_dev_en to false */ 1066 ret = rpr0521_poweroff(data); 1067 regcache_mark_dirty(data->regmap); 1068 mutex_unlock(&data->lock); 1069 1070 return ret; 1071 } 1072 1073 static int rpr0521_runtime_resume(struct device *dev) 1074 { 1075 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1076 struct rpr0521_data *data = iio_priv(indio_dev); 1077 int ret; 1078 1079 regcache_sync(data->regmap); 1080 if (data->als_ps_need_en) { 1081 ret = rpr0521_als_enable(data, RPR0521_MODE_ALS_ENABLE); 1082 if (ret < 0) 1083 return ret; 1084 data->als_ps_need_en = false; 1085 } 1086 1087 if (data->pxs_ps_need_en) { 1088 ret = rpr0521_pxs_enable(data, RPR0521_MODE_PXS_ENABLE); 1089 if (ret < 0) 1090 return ret; 1091 data->pxs_ps_need_en = false; 1092 } 1093 msleep(100); //wait for first measurement result 1094 1095 return 0; 1096 } 1097 1098 static const struct dev_pm_ops rpr0521_pm_ops = { 1099 RUNTIME_PM_OPS(rpr0521_runtime_suspend, rpr0521_runtime_resume, NULL) 1100 }; 1101 1102 static const struct acpi_device_id rpr0521_acpi_match[] = { 1103 {"RPR0521", 0}, 1104 { } 1105 }; 1106 MODULE_DEVICE_TABLE(acpi, rpr0521_acpi_match); 1107 1108 static const struct i2c_device_id rpr0521_id[] = { 1109 { "rpr0521" }, 1110 { } 1111 }; 1112 1113 MODULE_DEVICE_TABLE(i2c, rpr0521_id); 1114 1115 static struct i2c_driver rpr0521_driver = { 1116 .driver = { 1117 .name = RPR0521_DRV_NAME, 1118 .pm = pm_ptr(&rpr0521_pm_ops), 1119 .acpi_match_table = rpr0521_acpi_match, 1120 }, 1121 .probe = rpr0521_probe, 1122 .remove = rpr0521_remove, 1123 .id_table = rpr0521_id, 1124 }; 1125 1126 module_i2c_driver(rpr0521_driver); 1127 1128 MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>"); 1129 MODULE_DESCRIPTION("RPR0521 ROHM Ambient Light and Proximity Sensor driver"); 1130 MODULE_LICENSE("GPL v2"); 1131