1 /* 2 * This file is part of the ROHM BH1770GLC / OSRAM SFH7770 sensor driver. 3 * Chip is combined proximity and ambient light sensor. 4 * 5 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). 6 * 7 * Contact: Samu Onkalo <samu.p.onkalo@nokia.com> 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License 11 * version 2 as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 21 * 02110-1301 USA 22 * 23 */ 24 25 #include <linux/kernel.h> 26 #include <linux/module.h> 27 #include <linux/i2c.h> 28 #include <linux/interrupt.h> 29 #include <linux/mutex.h> 30 #include <linux/i2c/bh1770glc.h> 31 #include <linux/regulator/consumer.h> 32 #include <linux/pm_runtime.h> 33 #include <linux/workqueue.h> 34 #include <linux/delay.h> 35 #include <linux/wait.h> 36 #include <linux/slab.h> 37 38 #define BH1770_ALS_CONTROL 0x80 /* ALS operation mode control */ 39 #define BH1770_PS_CONTROL 0x81 /* PS operation mode control */ 40 #define BH1770_I_LED 0x82 /* active LED and LED1, LED2 current */ 41 #define BH1770_I_LED3 0x83 /* LED3 current setting */ 42 #define BH1770_ALS_PS_MEAS 0x84 /* Forced mode trigger */ 43 #define BH1770_PS_MEAS_RATE 0x85 /* PS meas. rate at stand alone mode */ 44 #define BH1770_ALS_MEAS_RATE 0x86 /* ALS meas. rate at stand alone mode */ 45 #define BH1770_PART_ID 0x8a /* Part number and revision ID */ 46 #define BH1770_MANUFACT_ID 0x8b /* Manufacturerer ID */ 47 #define BH1770_ALS_DATA_0 0x8c /* ALS DATA low byte */ 48 #define BH1770_ALS_DATA_1 0x8d /* ALS DATA high byte */ 49 #define BH1770_ALS_PS_STATUS 0x8e /* Measurement data and int status */ 50 #define BH1770_PS_DATA_LED1 0x8f /* PS data from LED1 */ 51 #define BH1770_PS_DATA_LED2 0x90 /* PS data from LED2 */ 52 #define BH1770_PS_DATA_LED3 0x91 /* PS data from LED3 */ 53 #define BH1770_INTERRUPT 0x92 /* Interrupt setting */ 54 #define BH1770_PS_TH_LED1 0x93 /* PS interrupt threshold for LED1 */ 55 #define BH1770_PS_TH_LED2 0x94 /* PS interrupt threshold for LED2 */ 56 #define BH1770_PS_TH_LED3 0x95 /* PS interrupt threshold for LED3 */ 57 #define BH1770_ALS_TH_UP_0 0x96 /* ALS upper threshold low byte */ 58 #define BH1770_ALS_TH_UP_1 0x97 /* ALS upper threshold high byte */ 59 #define BH1770_ALS_TH_LOW_0 0x98 /* ALS lower threshold low byte */ 60 #define BH1770_ALS_TH_LOW_1 0x99 /* ALS lower threshold high byte */ 61 62 /* MANUFACT_ID */ 63 #define BH1770_MANUFACT_ROHM 0x01 64 #define BH1770_MANUFACT_OSRAM 0x03 65 66 /* PART_ID */ 67 #define BH1770_PART 0x90 68 #define BH1770_PART_MASK 0xf0 69 #define BH1770_REV_MASK 0x0f 70 #define BH1770_REV_SHIFT 0 71 #define BH1770_REV_0 0x00 72 #define BH1770_REV_1 0x01 73 74 /* Operating modes for both */ 75 #define BH1770_STANDBY 0x00 76 #define BH1770_FORCED 0x02 77 #define BH1770_STANDALONE 0x03 78 #define BH1770_SWRESET (0x01 << 2) 79 80 #define BH1770_PS_TRIG_MEAS (1 << 0) 81 #define BH1770_ALS_TRIG_MEAS (1 << 1) 82 83 /* Interrupt control */ 84 #define BH1770_INT_OUTPUT_MODE (1 << 3) /* 0 = latched */ 85 #define BH1770_INT_POLARITY (1 << 2) /* 1 = active high */ 86 #define BH1770_INT_ALS_ENA (1 << 1) 87 #define BH1770_INT_PS_ENA (1 << 0) 88 89 /* Interrupt status */ 90 #define BH1770_INT_LED1_DATA (1 << 0) 91 #define BH1770_INT_LED1_INT (1 << 1) 92 #define BH1770_INT_LED2_DATA (1 << 2) 93 #define BH1770_INT_LED2_INT (1 << 3) 94 #define BH1770_INT_LED3_DATA (1 << 4) 95 #define BH1770_INT_LED3_INT (1 << 5) 96 #define BH1770_INT_LEDS_INT ((1 << 1) | (1 << 3) | (1 << 5)) 97 #define BH1770_INT_ALS_DATA (1 << 6) 98 #define BH1770_INT_ALS_INT (1 << 7) 99 100 /* Led channels */ 101 #define BH1770_LED1 0x00 102 103 #define BH1770_DISABLE 0 104 #define BH1770_ENABLE 1 105 #define BH1770_PROX_CHANNELS 1 106 107 #define BH1770_LUX_DEFAULT_RATE 1 /* Index to lux rate table */ 108 #define BH1770_PROX_DEFAULT_RATE 1 /* Direct HW value =~ 50Hz */ 109 #define BH1770_PROX_DEF_RATE_THRESH 6 /* Direct HW value =~ 5 Hz */ 110 #define BH1770_STARTUP_DELAY 50 111 #define BH1770_RESET_TIME 10 112 #define BH1770_TIMEOUT 2100 /* Timeout in 2.1 seconds */ 113 114 #define BH1770_LUX_RANGE 65535 115 #define BH1770_PROX_RANGE 255 116 #define BH1770_COEF_SCALER 1024 117 #define BH1770_CALIB_SCALER 8192 118 #define BH1770_LUX_NEUTRAL_CALIB_VALUE (1 * BH1770_CALIB_SCALER) 119 #define BH1770_LUX_DEF_THRES 1000 120 #define BH1770_PROX_DEF_THRES 70 121 #define BH1770_PROX_DEF_ABS_THRES 100 122 #define BH1770_DEFAULT_PERSISTENCE 10 123 #define BH1770_PROX_MAX_PERSISTENCE 50 124 #define BH1770_LUX_GA_SCALE 16384 125 #define BH1770_LUX_CF_SCALE 2048 /* CF ChipFactor */ 126 #define BH1770_NEUTRAL_CF BH1770_LUX_CF_SCALE 127 #define BH1770_LUX_CORR_SCALE 4096 128 129 #define PROX_ABOVE_THRESHOLD 1 130 #define PROX_BELOW_THRESHOLD 0 131 132 #define PROX_IGNORE_LUX_LIMIT 500 133 134 struct bh1770_chip { 135 struct bh1770_platform_data *pdata; 136 char chipname[10]; 137 u8 revision; 138 struct i2c_client *client; 139 struct regulator_bulk_data regs[2]; 140 struct mutex mutex; /* avoid parallel access */ 141 wait_queue_head_t wait; 142 143 bool int_mode_prox; 144 bool int_mode_lux; 145 struct delayed_work prox_work; 146 u32 lux_cf; /* Chip specific factor */ 147 u32 lux_ga; 148 u32 lux_calib; 149 int lux_rate_index; 150 u32 lux_corr; 151 u16 lux_data_raw; 152 u16 lux_threshold_hi; 153 u16 lux_threshold_lo; 154 u16 lux_thres_hi_onchip; 155 u16 lux_thres_lo_onchip; 156 bool lux_wait_result; 157 158 int prox_enable_count; 159 u16 prox_coef; 160 u16 prox_const; 161 int prox_rate; 162 int prox_rate_threshold; 163 u8 prox_persistence; 164 u8 prox_persistence_counter; 165 u8 prox_data; 166 u8 prox_threshold; 167 u8 prox_threshold_hw; 168 bool prox_force_update; 169 u8 prox_abs_thres; 170 u8 prox_led; 171 }; 172 173 static const char reg_vcc[] = "Vcc"; 174 static const char reg_vleds[] = "Vleds"; 175 176 /* 177 * Supported stand alone rates in ms from chip data sheet 178 * {10, 20, 30, 40, 70, 100, 200, 500, 1000, 2000}; 179 */ 180 static const s16 prox_rates_hz[] = {100, 50, 33, 25, 14, 10, 5, 2}; 181 static const s16 prox_rates_ms[] = {10, 20, 30, 40, 70, 100, 200, 500}; 182 183 /* Supported IR-led currents in mA */ 184 static const u8 prox_curr_ma[] = {5, 10, 20, 50, 100, 150, 200}; 185 186 /* 187 * Supported stand alone rates in ms from chip data sheet 188 * {100, 200, 500, 1000, 2000}; 189 */ 190 static const s16 lux_rates_hz[] = {10, 5, 2, 1, 0}; 191 192 /* 193 * interrupt control functions are called while keeping chip->mutex 194 * excluding module probe / remove 195 */ 196 static inline int bh1770_lux_interrupt_control(struct bh1770_chip *chip, 197 int lux) 198 { 199 chip->int_mode_lux = lux; 200 /* Set interrupt modes, interrupt active low, latched */ 201 return i2c_smbus_write_byte_data(chip->client, 202 BH1770_INTERRUPT, 203 (lux << 1) | chip->int_mode_prox); 204 } 205 206 static inline int bh1770_prox_interrupt_control(struct bh1770_chip *chip, 207 int ps) 208 { 209 chip->int_mode_prox = ps; 210 return i2c_smbus_write_byte_data(chip->client, 211 BH1770_INTERRUPT, 212 (chip->int_mode_lux << 1) | (ps << 0)); 213 } 214 215 /* chip->mutex is always kept here */ 216 static int bh1770_lux_rate(struct bh1770_chip *chip, int rate_index) 217 { 218 /* sysfs may call this when the chip is powered off */ 219 if (pm_runtime_suspended(&chip->client->dev)) 220 return 0; 221 222 /* Proper proximity response needs fastest lux rate (100ms) */ 223 if (chip->prox_enable_count) 224 rate_index = 0; 225 226 return i2c_smbus_write_byte_data(chip->client, 227 BH1770_ALS_MEAS_RATE, 228 rate_index); 229 } 230 231 static int bh1770_prox_rate(struct bh1770_chip *chip, int mode) 232 { 233 int rate; 234 235 rate = (mode == PROX_ABOVE_THRESHOLD) ? 236 chip->prox_rate_threshold : chip->prox_rate; 237 238 return i2c_smbus_write_byte_data(chip->client, 239 BH1770_PS_MEAS_RATE, 240 rate); 241 } 242 243 /* InfraredLED is controlled by the chip during proximity scanning */ 244 static inline int bh1770_led_cfg(struct bh1770_chip *chip) 245 { 246 /* LED cfg, current for leds 1 and 2 */ 247 return i2c_smbus_write_byte_data(chip->client, 248 BH1770_I_LED, 249 (BH1770_LED1 << 6) | 250 (BH1770_LED_5mA << 3) | 251 chip->prox_led); 252 } 253 254 /* 255 * Following two functions converts raw ps values from HW to normalized 256 * values. Purpose is to compensate differences between different sensor 257 * versions and variants so that result means about the same between 258 * versions. 259 */ 260 static inline u8 bh1770_psraw_to_adjusted(struct bh1770_chip *chip, u8 psraw) 261 { 262 u16 adjusted; 263 adjusted = (u16)(((u32)(psraw + chip->prox_const) * chip->prox_coef) / 264 BH1770_COEF_SCALER); 265 if (adjusted > BH1770_PROX_RANGE) 266 adjusted = BH1770_PROX_RANGE; 267 return adjusted; 268 } 269 270 static inline u8 bh1770_psadjusted_to_raw(struct bh1770_chip *chip, u8 ps) 271 { 272 u16 raw; 273 274 raw = (((u32)ps * BH1770_COEF_SCALER) / chip->prox_coef); 275 if (raw > chip->prox_const) 276 raw = raw - chip->prox_const; 277 else 278 raw = 0; 279 return raw; 280 } 281 282 /* 283 * Following two functions converts raw lux values from HW to normalized 284 * values. Purpose is to compensate differences between different sensor 285 * versions and variants so that result means about the same between 286 * versions. Chip->mutex is kept when this is called. 287 */ 288 static int bh1770_prox_set_threshold(struct bh1770_chip *chip) 289 { 290 u8 tmp = 0; 291 292 /* sysfs may call this when the chip is powered off */ 293 if (pm_runtime_suspended(&chip->client->dev)) 294 return 0; 295 296 tmp = bh1770_psadjusted_to_raw(chip, chip->prox_threshold); 297 chip->prox_threshold_hw = tmp; 298 299 return i2c_smbus_write_byte_data(chip->client, BH1770_PS_TH_LED1, 300 tmp); 301 } 302 303 static inline u16 bh1770_lux_raw_to_adjusted(struct bh1770_chip *chip, u16 raw) 304 { 305 u32 lux; 306 lux = ((u32)raw * chip->lux_corr) / BH1770_LUX_CORR_SCALE; 307 return min(lux, (u32)BH1770_LUX_RANGE); 308 } 309 310 static inline u16 bh1770_lux_adjusted_to_raw(struct bh1770_chip *chip, 311 u16 adjusted) 312 { 313 return (u32)adjusted * BH1770_LUX_CORR_SCALE / chip->lux_corr; 314 } 315 316 /* chip->mutex is kept when this is called */ 317 static int bh1770_lux_update_thresholds(struct bh1770_chip *chip, 318 u16 threshold_hi, u16 threshold_lo) 319 { 320 u8 data[4]; 321 int ret; 322 323 /* sysfs may call this when the chip is powered off */ 324 if (pm_runtime_suspended(&chip->client->dev)) 325 return 0; 326 327 /* 328 * Compensate threshold values with the correction factors if not 329 * set to minimum or maximum. 330 * Min & max values disables interrupts. 331 */ 332 if (threshold_hi != BH1770_LUX_RANGE && threshold_hi != 0) 333 threshold_hi = bh1770_lux_adjusted_to_raw(chip, threshold_hi); 334 335 if (threshold_lo != BH1770_LUX_RANGE && threshold_lo != 0) 336 threshold_lo = bh1770_lux_adjusted_to_raw(chip, threshold_lo); 337 338 if (chip->lux_thres_hi_onchip == threshold_hi && 339 chip->lux_thres_lo_onchip == threshold_lo) 340 return 0; 341 342 chip->lux_thres_hi_onchip = threshold_hi; 343 chip->lux_thres_lo_onchip = threshold_lo; 344 345 data[0] = threshold_hi; 346 data[1] = threshold_hi >> 8; 347 data[2] = threshold_lo; 348 data[3] = threshold_lo >> 8; 349 350 ret = i2c_smbus_write_i2c_block_data(chip->client, 351 BH1770_ALS_TH_UP_0, 352 ARRAY_SIZE(data), 353 data); 354 return ret; 355 } 356 357 static int bh1770_lux_get_result(struct bh1770_chip *chip) 358 { 359 u16 data; 360 int ret; 361 362 ret = i2c_smbus_read_byte_data(chip->client, BH1770_ALS_DATA_0); 363 if (ret < 0) 364 return ret; 365 366 data = ret & 0xff; 367 ret = i2c_smbus_read_byte_data(chip->client, BH1770_ALS_DATA_1); 368 if (ret < 0) 369 return ret; 370 371 chip->lux_data_raw = data | ((ret & 0xff) << 8); 372 373 return 0; 374 } 375 376 /* Calculate correction value which contains chip and device specific parts */ 377 static u32 bh1770_get_corr_value(struct bh1770_chip *chip) 378 { 379 u32 tmp; 380 /* Impact of glass attenuation correction */ 381 tmp = (BH1770_LUX_CORR_SCALE * chip->lux_ga) / BH1770_LUX_GA_SCALE; 382 /* Impact of chip factor correction */ 383 tmp = (tmp * chip->lux_cf) / BH1770_LUX_CF_SCALE; 384 /* Impact of Device specific calibration correction */ 385 tmp = (tmp * chip->lux_calib) / BH1770_CALIB_SCALER; 386 return tmp; 387 } 388 389 static int bh1770_lux_read_result(struct bh1770_chip *chip) 390 { 391 bh1770_lux_get_result(chip); 392 return bh1770_lux_raw_to_adjusted(chip, chip->lux_data_raw); 393 } 394 395 /* 396 * Chip on / off functions are called while keeping mutex except probe 397 * or remove phase 398 */ 399 static int bh1770_chip_on(struct bh1770_chip *chip) 400 { 401 int ret = regulator_bulk_enable(ARRAY_SIZE(chip->regs), 402 chip->regs); 403 if (ret < 0) 404 return ret; 405 406 usleep_range(BH1770_STARTUP_DELAY, BH1770_STARTUP_DELAY * 2); 407 408 /* Reset the chip */ 409 i2c_smbus_write_byte_data(chip->client, BH1770_ALS_CONTROL, 410 BH1770_SWRESET); 411 usleep_range(BH1770_RESET_TIME, BH1770_RESET_TIME * 2); 412 413 /* 414 * ALS is started always since proximity needs als results 415 * for realibility estimation. 416 * Let's assume dark until the first ALS measurement is ready. 417 */ 418 chip->lux_data_raw = 0; 419 chip->prox_data = 0; 420 ret = i2c_smbus_write_byte_data(chip->client, 421 BH1770_ALS_CONTROL, BH1770_STANDALONE); 422 423 /* Assume reset defaults */ 424 chip->lux_thres_hi_onchip = BH1770_LUX_RANGE; 425 chip->lux_thres_lo_onchip = 0; 426 427 return ret; 428 } 429 430 static void bh1770_chip_off(struct bh1770_chip *chip) 431 { 432 i2c_smbus_write_byte_data(chip->client, 433 BH1770_INTERRUPT, BH1770_DISABLE); 434 i2c_smbus_write_byte_data(chip->client, 435 BH1770_ALS_CONTROL, BH1770_STANDBY); 436 i2c_smbus_write_byte_data(chip->client, 437 BH1770_PS_CONTROL, BH1770_STANDBY); 438 regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs); 439 } 440 441 /* chip->mutex is kept when this is called */ 442 static int bh1770_prox_mode_control(struct bh1770_chip *chip) 443 { 444 if (chip->prox_enable_count) { 445 chip->prox_force_update = true; /* Force immediate update */ 446 447 bh1770_lux_rate(chip, chip->lux_rate_index); 448 bh1770_prox_set_threshold(chip); 449 bh1770_led_cfg(chip); 450 bh1770_prox_rate(chip, PROX_BELOW_THRESHOLD); 451 bh1770_prox_interrupt_control(chip, BH1770_ENABLE); 452 i2c_smbus_write_byte_data(chip->client, 453 BH1770_PS_CONTROL, BH1770_STANDALONE); 454 } else { 455 chip->prox_data = 0; 456 bh1770_lux_rate(chip, chip->lux_rate_index); 457 bh1770_prox_interrupt_control(chip, BH1770_DISABLE); 458 i2c_smbus_write_byte_data(chip->client, 459 BH1770_PS_CONTROL, BH1770_STANDBY); 460 } 461 return 0; 462 } 463 464 /* chip->mutex is kept when this is called */ 465 static int bh1770_prox_read_result(struct bh1770_chip *chip) 466 { 467 int ret; 468 bool above; 469 u8 mode; 470 471 ret = i2c_smbus_read_byte_data(chip->client, BH1770_PS_DATA_LED1); 472 if (ret < 0) 473 goto out; 474 475 if (ret > chip->prox_threshold_hw) 476 above = true; 477 else 478 above = false; 479 480 /* 481 * when ALS levels goes above limit, proximity result may be 482 * false proximity. Thus ignore the result. With real proximity 483 * there is a shadow causing low als levels. 484 */ 485 if (chip->lux_data_raw > PROX_IGNORE_LUX_LIMIT) 486 ret = 0; 487 488 chip->prox_data = bh1770_psraw_to_adjusted(chip, ret); 489 490 /* Strong proximity level or force mode requires immediate response */ 491 if (chip->prox_data >= chip->prox_abs_thres || 492 chip->prox_force_update) 493 chip->prox_persistence_counter = chip->prox_persistence; 494 495 chip->prox_force_update = false; 496 497 /* Persistence filttering to reduce false proximity events */ 498 if (likely(above)) { 499 if (chip->prox_persistence_counter < chip->prox_persistence) { 500 chip->prox_persistence_counter++; 501 ret = -ENODATA; 502 } else { 503 mode = PROX_ABOVE_THRESHOLD; 504 ret = 0; 505 } 506 } else { 507 chip->prox_persistence_counter = 0; 508 mode = PROX_BELOW_THRESHOLD; 509 chip->prox_data = 0; 510 ret = 0; 511 } 512 513 /* Set proximity detection rate based on above or below value */ 514 if (ret == 0) { 515 bh1770_prox_rate(chip, mode); 516 sysfs_notify(&chip->client->dev.kobj, NULL, "prox0_raw"); 517 } 518 out: 519 return ret; 520 } 521 522 static int bh1770_detect(struct bh1770_chip *chip) 523 { 524 struct i2c_client *client = chip->client; 525 s32 ret; 526 u8 manu, part; 527 528 ret = i2c_smbus_read_byte_data(client, BH1770_MANUFACT_ID); 529 if (ret < 0) 530 goto error; 531 manu = (u8)ret; 532 533 ret = i2c_smbus_read_byte_data(client, BH1770_PART_ID); 534 if (ret < 0) 535 goto error; 536 part = (u8)ret; 537 538 chip->revision = (part & BH1770_REV_MASK) >> BH1770_REV_SHIFT; 539 chip->prox_coef = BH1770_COEF_SCALER; 540 chip->prox_const = 0; 541 chip->lux_cf = BH1770_NEUTRAL_CF; 542 543 if ((manu == BH1770_MANUFACT_ROHM) && 544 ((part & BH1770_PART_MASK) == BH1770_PART)) { 545 snprintf(chip->chipname, sizeof(chip->chipname), "BH1770GLC"); 546 return 0; 547 } 548 549 if ((manu == BH1770_MANUFACT_OSRAM) && 550 ((part & BH1770_PART_MASK) == BH1770_PART)) { 551 snprintf(chip->chipname, sizeof(chip->chipname), "SFH7770"); 552 /* Values selected by comparing different versions */ 553 chip->prox_coef = 819; /* 0.8 * BH1770_COEF_SCALER */ 554 chip->prox_const = 40; 555 return 0; 556 } 557 558 ret = -ENODEV; 559 error: 560 dev_dbg(&client->dev, "BH1770 or SFH7770 not found\n"); 561 562 return ret; 563 } 564 565 /* 566 * This work is re-scheduled at every proximity interrupt. 567 * If this work is running, it means that there hasn't been any 568 * proximity interrupt in time. Situation is handled as no-proximity. 569 * It would be nice to have low-threshold interrupt or interrupt 570 * when measurement and hi-threshold are both 0. But neither of those exists. 571 * This is a workaroud for missing HW feature. 572 */ 573 574 static void bh1770_prox_work(struct work_struct *work) 575 { 576 struct bh1770_chip *chip = 577 container_of(work, struct bh1770_chip, prox_work.work); 578 579 mutex_lock(&chip->mutex); 580 bh1770_prox_read_result(chip); 581 mutex_unlock(&chip->mutex); 582 } 583 584 /* This is threaded irq handler */ 585 static irqreturn_t bh1770_irq(int irq, void *data) 586 { 587 struct bh1770_chip *chip = data; 588 int status; 589 int rate = 0; 590 591 mutex_lock(&chip->mutex); 592 status = i2c_smbus_read_byte_data(chip->client, BH1770_ALS_PS_STATUS); 593 594 /* Acknowledge interrupt by reading this register */ 595 i2c_smbus_read_byte_data(chip->client, BH1770_INTERRUPT); 596 597 /* 598 * Check if there is fresh data available for als. 599 * If this is the very first data, update thresholds after that. 600 */ 601 if (status & BH1770_INT_ALS_DATA) { 602 bh1770_lux_get_result(chip); 603 if (unlikely(chip->lux_wait_result)) { 604 chip->lux_wait_result = false; 605 wake_up(&chip->wait); 606 bh1770_lux_update_thresholds(chip, 607 chip->lux_threshold_hi, 608 chip->lux_threshold_lo); 609 } 610 } 611 612 /* Disable interrupt logic to guarantee acknowledgement */ 613 i2c_smbus_write_byte_data(chip->client, BH1770_INTERRUPT, 614 (0 << 1) | (0 << 0)); 615 616 if ((status & BH1770_INT_ALS_INT)) 617 sysfs_notify(&chip->client->dev.kobj, NULL, "lux0_input"); 618 619 if (chip->int_mode_prox && (status & BH1770_INT_LEDS_INT)) { 620 rate = prox_rates_ms[chip->prox_rate_threshold]; 621 bh1770_prox_read_result(chip); 622 } 623 624 /* Re-enable interrupt logic */ 625 i2c_smbus_write_byte_data(chip->client, BH1770_INTERRUPT, 626 (chip->int_mode_lux << 1) | 627 (chip->int_mode_prox << 0)); 628 mutex_unlock(&chip->mutex); 629 630 /* 631 * Can't cancel work while keeping mutex since the work uses the 632 * same mutex. 633 */ 634 if (rate) { 635 /* 636 * Simulate missing no-proximity interrupt 50ms after the 637 * next expected interrupt time. 638 */ 639 cancel_delayed_work_sync(&chip->prox_work); 640 schedule_delayed_work(&chip->prox_work, 641 msecs_to_jiffies(rate + 50)); 642 } 643 return IRQ_HANDLED; 644 } 645 646 static ssize_t bh1770_power_state_store(struct device *dev, 647 struct device_attribute *attr, 648 const char *buf, size_t count) 649 { 650 struct bh1770_chip *chip = dev_get_drvdata(dev); 651 unsigned long value; 652 ssize_t ret; 653 654 if (strict_strtoul(buf, 0, &value)) 655 return -EINVAL; 656 657 mutex_lock(&chip->mutex); 658 if (value) { 659 pm_runtime_get_sync(dev); 660 661 ret = bh1770_lux_rate(chip, chip->lux_rate_index); 662 if (ret < 0) { 663 pm_runtime_put(dev); 664 goto leave; 665 } 666 667 ret = bh1770_lux_interrupt_control(chip, BH1770_ENABLE); 668 if (ret < 0) { 669 pm_runtime_put(dev); 670 goto leave; 671 } 672 673 /* This causes interrupt after the next measurement cycle */ 674 bh1770_lux_update_thresholds(chip, BH1770_LUX_DEF_THRES, 675 BH1770_LUX_DEF_THRES); 676 /* Inform that we are waiting for a result from ALS */ 677 chip->lux_wait_result = true; 678 bh1770_prox_mode_control(chip); 679 } else if (!pm_runtime_suspended(dev)) { 680 pm_runtime_put(dev); 681 } 682 ret = count; 683 leave: 684 mutex_unlock(&chip->mutex); 685 return ret; 686 } 687 688 static ssize_t bh1770_power_state_show(struct device *dev, 689 struct device_attribute *attr, char *buf) 690 { 691 return sprintf(buf, "%d\n", !pm_runtime_suspended(dev)); 692 } 693 694 static ssize_t bh1770_lux_result_show(struct device *dev, 695 struct device_attribute *attr, char *buf) 696 { 697 struct bh1770_chip *chip = dev_get_drvdata(dev); 698 ssize_t ret; 699 long timeout; 700 701 if (pm_runtime_suspended(dev)) 702 return -EIO; /* Chip is not enabled at all */ 703 704 timeout = wait_event_interruptible_timeout(chip->wait, 705 !chip->lux_wait_result, 706 msecs_to_jiffies(BH1770_TIMEOUT)); 707 if (!timeout) 708 return -EIO; 709 710 mutex_lock(&chip->mutex); 711 ret = sprintf(buf, "%d\n", bh1770_lux_read_result(chip)); 712 mutex_unlock(&chip->mutex); 713 714 return ret; 715 } 716 717 static ssize_t bh1770_lux_range_show(struct device *dev, 718 struct device_attribute *attr, char *buf) 719 { 720 return sprintf(buf, "%d\n", BH1770_LUX_RANGE); 721 } 722 723 static ssize_t bh1770_prox_enable_store(struct device *dev, 724 struct device_attribute *attr, 725 const char *buf, size_t count) 726 { 727 struct bh1770_chip *chip = dev_get_drvdata(dev); 728 unsigned long value; 729 730 if (strict_strtoul(buf, 0, &value)) 731 return -EINVAL; 732 733 mutex_lock(&chip->mutex); 734 /* Assume no proximity. Sensor will tell real state soon */ 735 if (!chip->prox_enable_count) 736 chip->prox_data = 0; 737 738 if (value) 739 chip->prox_enable_count++; 740 else if (chip->prox_enable_count > 0) 741 chip->prox_enable_count--; 742 else 743 goto leave; 744 745 /* Run control only when chip is powered on */ 746 if (!pm_runtime_suspended(dev)) 747 bh1770_prox_mode_control(chip); 748 leave: 749 mutex_unlock(&chip->mutex); 750 return count; 751 } 752 753 static ssize_t bh1770_prox_enable_show(struct device *dev, 754 struct device_attribute *attr, char *buf) 755 { 756 struct bh1770_chip *chip = dev_get_drvdata(dev); 757 ssize_t len; 758 759 mutex_lock(&chip->mutex); 760 len = sprintf(buf, "%d\n", chip->prox_enable_count); 761 mutex_unlock(&chip->mutex); 762 return len; 763 } 764 765 static ssize_t bh1770_prox_result_show(struct device *dev, 766 struct device_attribute *attr, char *buf) 767 { 768 struct bh1770_chip *chip = dev_get_drvdata(dev); 769 ssize_t ret; 770 771 mutex_lock(&chip->mutex); 772 if (chip->prox_enable_count && !pm_runtime_suspended(dev)) 773 ret = sprintf(buf, "%d\n", chip->prox_data); 774 else 775 ret = -EIO; 776 mutex_unlock(&chip->mutex); 777 return ret; 778 } 779 780 static ssize_t bh1770_prox_range_show(struct device *dev, 781 struct device_attribute *attr, char *buf) 782 { 783 return sprintf(buf, "%d\n", BH1770_PROX_RANGE); 784 } 785 786 static ssize_t bh1770_get_prox_rate_avail(struct device *dev, 787 struct device_attribute *attr, char *buf) 788 { 789 int i; 790 int pos = 0; 791 for (i = 0; i < ARRAY_SIZE(prox_rates_hz); i++) 792 pos += sprintf(buf + pos, "%d ", prox_rates_hz[i]); 793 sprintf(buf + pos - 1, "\n"); 794 return pos; 795 } 796 797 static ssize_t bh1770_get_prox_rate_above(struct device *dev, 798 struct device_attribute *attr, char *buf) 799 { 800 struct bh1770_chip *chip = dev_get_drvdata(dev); 801 return sprintf(buf, "%d\n", prox_rates_hz[chip->prox_rate_threshold]); 802 } 803 804 static ssize_t bh1770_get_prox_rate_below(struct device *dev, 805 struct device_attribute *attr, char *buf) 806 { 807 struct bh1770_chip *chip = dev_get_drvdata(dev); 808 return sprintf(buf, "%d\n", prox_rates_hz[chip->prox_rate]); 809 } 810 811 static int bh1770_prox_rate_validate(int rate) 812 { 813 int i; 814 815 for (i = 0; i < ARRAY_SIZE(prox_rates_hz) - 1; i++) 816 if (rate >= prox_rates_hz[i]) 817 break; 818 return i; 819 } 820 821 static ssize_t bh1770_set_prox_rate_above(struct device *dev, 822 struct device_attribute *attr, 823 const char *buf, size_t count) 824 { 825 struct bh1770_chip *chip = dev_get_drvdata(dev); 826 unsigned long value; 827 828 if (strict_strtoul(buf, 0, &value)) 829 return -EINVAL; 830 831 mutex_lock(&chip->mutex); 832 chip->prox_rate_threshold = bh1770_prox_rate_validate(value); 833 mutex_unlock(&chip->mutex); 834 return count; 835 } 836 837 static ssize_t bh1770_set_prox_rate_below(struct device *dev, 838 struct device_attribute *attr, 839 const char *buf, size_t count) 840 { 841 struct bh1770_chip *chip = dev_get_drvdata(dev); 842 unsigned long value; 843 844 if (strict_strtoul(buf, 0, &value)) 845 return -EINVAL; 846 847 mutex_lock(&chip->mutex); 848 chip->prox_rate = bh1770_prox_rate_validate(value); 849 mutex_unlock(&chip->mutex); 850 return count; 851 } 852 853 static ssize_t bh1770_get_prox_thres(struct device *dev, 854 struct device_attribute *attr, char *buf) 855 { 856 struct bh1770_chip *chip = dev_get_drvdata(dev); 857 return sprintf(buf, "%d\n", chip->prox_threshold); 858 } 859 860 static ssize_t bh1770_set_prox_thres(struct device *dev, 861 struct device_attribute *attr, 862 const char *buf, size_t count) 863 { 864 struct bh1770_chip *chip = dev_get_drvdata(dev); 865 unsigned long value; 866 int ret; 867 868 if (strict_strtoul(buf, 0, &value)) 869 return -EINVAL; 870 if (value > BH1770_PROX_RANGE) 871 return -EINVAL; 872 873 mutex_lock(&chip->mutex); 874 chip->prox_threshold = value; 875 ret = bh1770_prox_set_threshold(chip); 876 mutex_unlock(&chip->mutex); 877 if (ret < 0) 878 return ret; 879 return count; 880 } 881 882 static ssize_t bh1770_prox_persistence_show(struct device *dev, 883 struct device_attribute *attr, char *buf) 884 { 885 struct bh1770_chip *chip = dev_get_drvdata(dev); 886 887 return sprintf(buf, "%u\n", chip->prox_persistence); 888 } 889 890 static ssize_t bh1770_prox_persistence_store(struct device *dev, 891 struct device_attribute *attr, 892 const char *buf, size_t len) 893 { 894 struct bh1770_chip *chip = dev_get_drvdata(dev); 895 unsigned long value; 896 897 if (strict_strtoul(buf, 0, &value)) 898 return -EINVAL; 899 900 if (value > BH1770_PROX_MAX_PERSISTENCE) 901 return -EINVAL; 902 903 chip->prox_persistence = value; 904 905 return len; 906 } 907 908 static ssize_t bh1770_prox_abs_thres_show(struct device *dev, 909 struct device_attribute *attr, char *buf) 910 { 911 struct bh1770_chip *chip = dev_get_drvdata(dev); 912 return sprintf(buf, "%u\n", chip->prox_abs_thres); 913 } 914 915 static ssize_t bh1770_prox_abs_thres_store(struct device *dev, 916 struct device_attribute *attr, 917 const char *buf, size_t len) 918 { 919 struct bh1770_chip *chip = dev_get_drvdata(dev); 920 unsigned long value; 921 922 if (strict_strtoul(buf, 0, &value)) 923 return -EINVAL; 924 925 if (value > BH1770_PROX_RANGE) 926 return -EINVAL; 927 928 chip->prox_abs_thres = value; 929 930 return len; 931 } 932 933 static ssize_t bh1770_chip_id_show(struct device *dev, 934 struct device_attribute *attr, char *buf) 935 { 936 struct bh1770_chip *chip = dev_get_drvdata(dev); 937 return sprintf(buf, "%s rev %d\n", chip->chipname, chip->revision); 938 } 939 940 static ssize_t bh1770_lux_calib_default_show(struct device *dev, 941 struct device_attribute *attr, char *buf) 942 { 943 return sprintf(buf, "%u\n", BH1770_CALIB_SCALER); 944 } 945 946 static ssize_t bh1770_lux_calib_show(struct device *dev, 947 struct device_attribute *attr, char *buf) 948 { 949 struct bh1770_chip *chip = dev_get_drvdata(dev); 950 ssize_t len; 951 952 mutex_lock(&chip->mutex); 953 len = sprintf(buf, "%u\n", chip->lux_calib); 954 mutex_unlock(&chip->mutex); 955 return len; 956 } 957 958 static ssize_t bh1770_lux_calib_store(struct device *dev, 959 struct device_attribute *attr, 960 const char *buf, size_t len) 961 { 962 struct bh1770_chip *chip = dev_get_drvdata(dev); 963 unsigned long value; 964 u32 old_calib; 965 u32 new_corr; 966 967 if (strict_strtoul(buf, 0, &value)) 968 return -EINVAL; 969 970 mutex_lock(&chip->mutex); 971 old_calib = chip->lux_calib; 972 chip->lux_calib = value; 973 new_corr = bh1770_get_corr_value(chip); 974 if (new_corr == 0) { 975 chip->lux_calib = old_calib; 976 mutex_unlock(&chip->mutex); 977 return -EINVAL; 978 } 979 chip->lux_corr = new_corr; 980 /* Refresh thresholds on HW after changing correction value */ 981 bh1770_lux_update_thresholds(chip, chip->lux_threshold_hi, 982 chip->lux_threshold_lo); 983 984 mutex_unlock(&chip->mutex); 985 986 return len; 987 } 988 989 static ssize_t bh1770_get_lux_rate_avail(struct device *dev, 990 struct device_attribute *attr, char *buf) 991 { 992 int i; 993 int pos = 0; 994 for (i = 0; i < ARRAY_SIZE(lux_rates_hz); i++) 995 pos += sprintf(buf + pos, "%d ", lux_rates_hz[i]); 996 sprintf(buf + pos - 1, "\n"); 997 return pos; 998 } 999 1000 static ssize_t bh1770_get_lux_rate(struct device *dev, 1001 struct device_attribute *attr, char *buf) 1002 { 1003 struct bh1770_chip *chip = dev_get_drvdata(dev); 1004 return sprintf(buf, "%d\n", lux_rates_hz[chip->lux_rate_index]); 1005 } 1006 1007 static ssize_t bh1770_set_lux_rate(struct device *dev, 1008 struct device_attribute *attr, 1009 const char *buf, size_t count) 1010 { 1011 struct bh1770_chip *chip = dev_get_drvdata(dev); 1012 unsigned long rate_hz; 1013 int ret, i; 1014 1015 if (strict_strtoul(buf, 0, &rate_hz)) 1016 return -EINVAL; 1017 1018 for (i = 0; i < ARRAY_SIZE(lux_rates_hz) - 1; i++) 1019 if (rate_hz >= lux_rates_hz[i]) 1020 break; 1021 1022 mutex_lock(&chip->mutex); 1023 chip->lux_rate_index = i; 1024 ret = bh1770_lux_rate(chip, i); 1025 mutex_unlock(&chip->mutex); 1026 1027 if (ret < 0) 1028 return ret; 1029 1030 return count; 1031 } 1032 1033 static ssize_t bh1770_get_lux_thresh_above(struct device *dev, 1034 struct device_attribute *attr, char *buf) 1035 { 1036 struct bh1770_chip *chip = dev_get_drvdata(dev); 1037 return sprintf(buf, "%d\n", chip->lux_threshold_hi); 1038 } 1039 1040 static ssize_t bh1770_get_lux_thresh_below(struct device *dev, 1041 struct device_attribute *attr, char *buf) 1042 { 1043 struct bh1770_chip *chip = dev_get_drvdata(dev); 1044 return sprintf(buf, "%d\n", chip->lux_threshold_lo); 1045 } 1046 1047 static ssize_t bh1770_set_lux_thresh(struct bh1770_chip *chip, u16 *target, 1048 const char *buf) 1049 { 1050 int ret = 0; 1051 unsigned long thresh; 1052 1053 if (strict_strtoul(buf, 0, &thresh)) 1054 return -EINVAL; 1055 1056 if (thresh > BH1770_LUX_RANGE) 1057 return -EINVAL; 1058 1059 mutex_lock(&chip->mutex); 1060 *target = thresh; 1061 /* 1062 * Don't update values in HW if we are still waiting for 1063 * first interrupt to come after device handle open call. 1064 */ 1065 if (!chip->lux_wait_result) 1066 ret = bh1770_lux_update_thresholds(chip, 1067 chip->lux_threshold_hi, 1068 chip->lux_threshold_lo); 1069 mutex_unlock(&chip->mutex); 1070 return ret; 1071 1072 } 1073 1074 static ssize_t bh1770_set_lux_thresh_above(struct device *dev, 1075 struct device_attribute *attr, 1076 const char *buf, size_t len) 1077 { 1078 struct bh1770_chip *chip = dev_get_drvdata(dev); 1079 int ret = bh1770_set_lux_thresh(chip, &chip->lux_threshold_hi, buf); 1080 if (ret < 0) 1081 return ret; 1082 return len; 1083 } 1084 1085 static ssize_t bh1770_set_lux_thresh_below(struct device *dev, 1086 struct device_attribute *attr, 1087 const char *buf, size_t len) 1088 { 1089 struct bh1770_chip *chip = dev_get_drvdata(dev); 1090 int ret = bh1770_set_lux_thresh(chip, &chip->lux_threshold_lo, buf); 1091 if (ret < 0) 1092 return ret; 1093 return len; 1094 } 1095 1096 static DEVICE_ATTR(prox0_raw_en, S_IRUGO | S_IWUSR, bh1770_prox_enable_show, 1097 bh1770_prox_enable_store); 1098 static DEVICE_ATTR(prox0_thresh_above1_value, S_IRUGO | S_IWUSR, 1099 bh1770_prox_abs_thres_show, 1100 bh1770_prox_abs_thres_store); 1101 static DEVICE_ATTR(prox0_thresh_above0_value, S_IRUGO | S_IWUSR, 1102 bh1770_get_prox_thres, 1103 bh1770_set_prox_thres); 1104 static DEVICE_ATTR(prox0_raw, S_IRUGO, bh1770_prox_result_show, NULL); 1105 static DEVICE_ATTR(prox0_sensor_range, S_IRUGO, bh1770_prox_range_show, NULL); 1106 static DEVICE_ATTR(prox0_thresh_above_count, S_IRUGO | S_IWUSR, 1107 bh1770_prox_persistence_show, 1108 bh1770_prox_persistence_store); 1109 static DEVICE_ATTR(prox0_rate_above, S_IRUGO | S_IWUSR, 1110 bh1770_get_prox_rate_above, 1111 bh1770_set_prox_rate_above); 1112 static DEVICE_ATTR(prox0_rate_below, S_IRUGO | S_IWUSR, 1113 bh1770_get_prox_rate_below, 1114 bh1770_set_prox_rate_below); 1115 static DEVICE_ATTR(prox0_rate_avail, S_IRUGO, bh1770_get_prox_rate_avail, NULL); 1116 1117 static DEVICE_ATTR(lux0_calibscale, S_IRUGO | S_IWUSR, bh1770_lux_calib_show, 1118 bh1770_lux_calib_store); 1119 static DEVICE_ATTR(lux0_calibscale_default, S_IRUGO, 1120 bh1770_lux_calib_default_show, 1121 NULL); 1122 static DEVICE_ATTR(lux0_input, S_IRUGO, bh1770_lux_result_show, NULL); 1123 static DEVICE_ATTR(lux0_sensor_range, S_IRUGO, bh1770_lux_range_show, NULL); 1124 static DEVICE_ATTR(lux0_rate, S_IRUGO | S_IWUSR, bh1770_get_lux_rate, 1125 bh1770_set_lux_rate); 1126 static DEVICE_ATTR(lux0_rate_avail, S_IRUGO, bh1770_get_lux_rate_avail, NULL); 1127 static DEVICE_ATTR(lux0_thresh_above_value, S_IRUGO | S_IWUSR, 1128 bh1770_get_lux_thresh_above, 1129 bh1770_set_lux_thresh_above); 1130 static DEVICE_ATTR(lux0_thresh_below_value, S_IRUGO | S_IWUSR, 1131 bh1770_get_lux_thresh_below, 1132 bh1770_set_lux_thresh_below); 1133 static DEVICE_ATTR(chip_id, S_IRUGO, bh1770_chip_id_show, NULL); 1134 static DEVICE_ATTR(power_state, S_IRUGO | S_IWUSR, bh1770_power_state_show, 1135 bh1770_power_state_store); 1136 1137 1138 static struct attribute *sysfs_attrs[] = { 1139 &dev_attr_lux0_calibscale.attr, 1140 &dev_attr_lux0_calibscale_default.attr, 1141 &dev_attr_lux0_input.attr, 1142 &dev_attr_lux0_sensor_range.attr, 1143 &dev_attr_lux0_rate.attr, 1144 &dev_attr_lux0_rate_avail.attr, 1145 &dev_attr_lux0_thresh_above_value.attr, 1146 &dev_attr_lux0_thresh_below_value.attr, 1147 &dev_attr_prox0_raw.attr, 1148 &dev_attr_prox0_sensor_range.attr, 1149 &dev_attr_prox0_raw_en.attr, 1150 &dev_attr_prox0_thresh_above_count.attr, 1151 &dev_attr_prox0_rate_above.attr, 1152 &dev_attr_prox0_rate_below.attr, 1153 &dev_attr_prox0_rate_avail.attr, 1154 &dev_attr_prox0_thresh_above0_value.attr, 1155 &dev_attr_prox0_thresh_above1_value.attr, 1156 &dev_attr_chip_id.attr, 1157 &dev_attr_power_state.attr, 1158 NULL 1159 }; 1160 1161 static struct attribute_group bh1770_attribute_group = { 1162 .attrs = sysfs_attrs 1163 }; 1164 1165 static int __devinit bh1770_probe(struct i2c_client *client, 1166 const struct i2c_device_id *id) 1167 { 1168 struct bh1770_chip *chip; 1169 int err; 1170 1171 chip = kzalloc(sizeof *chip, GFP_KERNEL); 1172 if (!chip) 1173 return -ENOMEM; 1174 1175 i2c_set_clientdata(client, chip); 1176 chip->client = client; 1177 1178 mutex_init(&chip->mutex); 1179 init_waitqueue_head(&chip->wait); 1180 INIT_DELAYED_WORK(&chip->prox_work, bh1770_prox_work); 1181 1182 if (client->dev.platform_data == NULL) { 1183 dev_err(&client->dev, "platform data is mandatory\n"); 1184 err = -EINVAL; 1185 goto fail1; 1186 } 1187 1188 chip->pdata = client->dev.platform_data; 1189 chip->lux_calib = BH1770_LUX_NEUTRAL_CALIB_VALUE; 1190 chip->lux_rate_index = BH1770_LUX_DEFAULT_RATE; 1191 chip->lux_threshold_lo = BH1770_LUX_DEF_THRES; 1192 chip->lux_threshold_hi = BH1770_LUX_DEF_THRES; 1193 1194 if (chip->pdata->glass_attenuation == 0) 1195 chip->lux_ga = BH1770_NEUTRAL_GA; 1196 else 1197 chip->lux_ga = chip->pdata->glass_attenuation; 1198 1199 chip->prox_threshold = BH1770_PROX_DEF_THRES; 1200 chip->prox_led = chip->pdata->led_def_curr; 1201 chip->prox_abs_thres = BH1770_PROX_DEF_ABS_THRES; 1202 chip->prox_persistence = BH1770_DEFAULT_PERSISTENCE; 1203 chip->prox_rate_threshold = BH1770_PROX_DEF_RATE_THRESH; 1204 chip->prox_rate = BH1770_PROX_DEFAULT_RATE; 1205 chip->prox_data = 0; 1206 1207 chip->regs[0].supply = reg_vcc; 1208 chip->regs[1].supply = reg_vleds; 1209 1210 err = regulator_bulk_get(&client->dev, 1211 ARRAY_SIZE(chip->regs), chip->regs); 1212 if (err < 0) { 1213 dev_err(&client->dev, "Cannot get regulators\n"); 1214 goto fail1; 1215 } 1216 1217 err = regulator_bulk_enable(ARRAY_SIZE(chip->regs), 1218 chip->regs); 1219 if (err < 0) { 1220 dev_err(&client->dev, "Cannot enable regulators\n"); 1221 goto fail2; 1222 } 1223 1224 usleep_range(BH1770_STARTUP_DELAY, BH1770_STARTUP_DELAY * 2); 1225 err = bh1770_detect(chip); 1226 if (err < 0) 1227 goto fail3; 1228 1229 /* Start chip */ 1230 bh1770_chip_on(chip); 1231 pm_runtime_set_active(&client->dev); 1232 pm_runtime_enable(&client->dev); 1233 1234 chip->lux_corr = bh1770_get_corr_value(chip); 1235 if (chip->lux_corr == 0) { 1236 dev_err(&client->dev, "Improper correction values\n"); 1237 err = -EINVAL; 1238 goto fail3; 1239 } 1240 1241 if (chip->pdata->setup_resources) { 1242 err = chip->pdata->setup_resources(); 1243 if (err) { 1244 err = -EINVAL; 1245 goto fail3; 1246 } 1247 } 1248 1249 err = sysfs_create_group(&chip->client->dev.kobj, 1250 &bh1770_attribute_group); 1251 if (err < 0) { 1252 dev_err(&chip->client->dev, "Sysfs registration failed\n"); 1253 goto fail4; 1254 } 1255 1256 /* 1257 * Chip needs level triggered interrupt to work. However, 1258 * level triggering doesn't work always correctly with power 1259 * management. Select both 1260 */ 1261 err = request_threaded_irq(client->irq, NULL, 1262 bh1770_irq, 1263 IRQF_TRIGGER_FALLING | IRQF_ONESHOT | 1264 IRQF_TRIGGER_LOW, 1265 "bh1770", chip); 1266 if (err) { 1267 dev_err(&client->dev, "could not get IRQ %d\n", 1268 client->irq); 1269 goto fail5; 1270 } 1271 regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs); 1272 return err; 1273 fail5: 1274 sysfs_remove_group(&chip->client->dev.kobj, 1275 &bh1770_attribute_group); 1276 fail4: 1277 if (chip->pdata->release_resources) 1278 chip->pdata->release_resources(); 1279 fail3: 1280 regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs); 1281 fail2: 1282 regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs); 1283 fail1: 1284 kfree(chip); 1285 return err; 1286 } 1287 1288 static int __devexit bh1770_remove(struct i2c_client *client) 1289 { 1290 struct bh1770_chip *chip = i2c_get_clientdata(client); 1291 1292 free_irq(client->irq, chip); 1293 1294 sysfs_remove_group(&chip->client->dev.kobj, 1295 &bh1770_attribute_group); 1296 1297 if (chip->pdata->release_resources) 1298 chip->pdata->release_resources(); 1299 1300 cancel_delayed_work_sync(&chip->prox_work); 1301 1302 if (!pm_runtime_suspended(&client->dev)) 1303 bh1770_chip_off(chip); 1304 1305 pm_runtime_disable(&client->dev); 1306 pm_runtime_set_suspended(&client->dev); 1307 1308 regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs); 1309 kfree(chip); 1310 return 0; 1311 } 1312 1313 #ifdef CONFIG_PM 1314 static int bh1770_suspend(struct device *dev) 1315 { 1316 struct i2c_client *client = container_of(dev, struct i2c_client, dev); 1317 struct bh1770_chip *chip = i2c_get_clientdata(client); 1318 1319 bh1770_chip_off(chip); 1320 1321 return 0; 1322 } 1323 1324 static int bh1770_resume(struct device *dev) 1325 { 1326 struct i2c_client *client = container_of(dev, struct i2c_client, dev); 1327 struct bh1770_chip *chip = i2c_get_clientdata(client); 1328 int ret = 0; 1329 1330 bh1770_chip_on(chip); 1331 1332 if (!pm_runtime_suspended(dev)) { 1333 /* 1334 * If we were enabled at suspend time, it is expected 1335 * everything works nice and smoothly 1336 */ 1337 ret = bh1770_lux_rate(chip, chip->lux_rate_index); 1338 ret |= bh1770_lux_interrupt_control(chip, BH1770_ENABLE); 1339 1340 /* This causes interrupt after the next measurement cycle */ 1341 bh1770_lux_update_thresholds(chip, BH1770_LUX_DEF_THRES, 1342 BH1770_LUX_DEF_THRES); 1343 /* Inform that we are waiting for a result from ALS */ 1344 chip->lux_wait_result = true; 1345 bh1770_prox_mode_control(chip); 1346 } 1347 return ret; 1348 } 1349 1350 #else 1351 #define bh1770_suspend NULL 1352 #define bh1770_shutdown NULL 1353 #define bh1770_resume NULL 1354 #endif 1355 1356 #ifdef CONFIG_PM_RUNTIME 1357 static int bh1770_runtime_suspend(struct device *dev) 1358 { 1359 struct i2c_client *client = container_of(dev, struct i2c_client, dev); 1360 struct bh1770_chip *chip = i2c_get_clientdata(client); 1361 1362 bh1770_chip_off(chip); 1363 1364 return 0; 1365 } 1366 1367 static int bh1770_runtime_resume(struct device *dev) 1368 { 1369 struct i2c_client *client = container_of(dev, struct i2c_client, dev); 1370 struct bh1770_chip *chip = i2c_get_clientdata(client); 1371 1372 bh1770_chip_on(chip); 1373 1374 return 0; 1375 } 1376 #endif 1377 1378 static const struct i2c_device_id bh1770_id[] = { 1379 {"bh1770glc", 0 }, 1380 {"sfh7770", 0 }, 1381 {} 1382 }; 1383 1384 MODULE_DEVICE_TABLE(i2c, bh1770_id); 1385 1386 static const struct dev_pm_ops bh1770_pm_ops = { 1387 SET_SYSTEM_SLEEP_PM_OPS(bh1770_suspend, bh1770_resume) 1388 SET_RUNTIME_PM_OPS(bh1770_runtime_suspend, bh1770_runtime_resume, NULL) 1389 }; 1390 1391 static struct i2c_driver bh1770_driver = { 1392 .driver = { 1393 .name = "bh1770glc", 1394 .owner = THIS_MODULE, 1395 .pm = &bh1770_pm_ops, 1396 }, 1397 .probe = bh1770_probe, 1398 .remove = __devexit_p(bh1770_remove), 1399 .id_table = bh1770_id, 1400 }; 1401 1402 static int __init bh1770_init(void) 1403 { 1404 return i2c_add_driver(&bh1770_driver); 1405 } 1406 1407 static void __exit bh1770_exit(void) 1408 { 1409 i2c_del_driver(&bh1770_driver); 1410 } 1411 1412 MODULE_DESCRIPTION("BH1770GLC / SFH7770 combined ALS and proximity sensor"); 1413 MODULE_AUTHOR("Samu Onkalo, Nokia Corporation"); 1414 MODULE_LICENSE("GPL v2"); 1415 1416 module_init(bh1770_init); 1417 module_exit(bh1770_exit); 1418