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