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