linux/drivers/iio/light/gp2ap020a00f.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) 2013 Samsung Electronics Co., Ltd.
   3 * Author: Jacek Anaszewski <j.anaszewski@samsung.com>
   4 *
   5 * IIO features supported by the driver:
   6 *
   7 * Read-only raw channels:
   8 *   - illuminance_clear [lux]
   9 *   - illuminance_ir
  10 *   - proximity
  11 *
  12 * Triggered buffer:
  13 *   - illuminance_clear
  14 *   - illuminance_ir
  15 *   - proximity
  16 *
  17 * Events:
  18 *   - illuminance_clear (rising and falling)
  19 *   - proximity (rising and falling)
  20 *     - both falling and rising thresholds for the proximity events
  21 *       must be set to the values greater than 0.
  22 *
  23 * The driver supports triggered buffers for all the three
  24 * channels as well as high and low threshold events for the
  25 * illuminance_clear and proxmimity channels. Triggers
  26 * can be enabled simultaneously with both illuminance_clear
  27 * events. Proximity events cannot be enabled simultaneously
  28 * with any triggers or illuminance events. Enabling/disabling
  29 * one of the proximity events automatically enables/disables
  30 * the other one.
  31 *
  32 * This program is free software; you can redistribute it and/or modify
  33 * it under the terms of the GNU General Public License version 2, as
  34 * published by the Free Software Foundation.
  35 */
  36
  37#include <linux/debugfs.h>
  38#include <linux/delay.h>
  39#include <linux/i2c.h>
  40#include <linux/interrupt.h>
  41#include <linux/irq.h>
  42#include <linux/irq_work.h>
  43#include <linux/module.h>
  44#include <linux/mutex.h>
  45#include <linux/of.h>
  46#include <linux/regmap.h>
  47#include <linux/regulator/consumer.h>
  48#include <linux/slab.h>
  49#include <linux/iio/buffer.h>
  50#include <linux/iio/events.h>
  51#include <linux/iio/iio.h>
  52#include <linux/iio/sysfs.h>
  53#include <linux/iio/trigger.h>
  54#include <linux/iio/trigger_consumer.h>
  55#include <linux/iio/triggered_buffer.h>
  56
  57#define GP2A_I2C_NAME "gp2ap020a00f"
  58
  59/* Registers */
  60#define GP2AP020A00F_OP_REG     0x00 /* Basic operations */
  61#define GP2AP020A00F_ALS_REG    0x01 /* ALS related settings */
  62#define GP2AP020A00F_PS_REG     0x02 /* PS related settings */
  63#define GP2AP020A00F_LED_REG    0x03 /* LED reg */
  64#define GP2AP020A00F_TL_L_REG   0x04 /* ALS: Threshold low LSB */
  65#define GP2AP020A00F_TL_H_REG   0x05 /* ALS: Threshold low MSB */
  66#define GP2AP020A00F_TH_L_REG   0x06 /* ALS: Threshold high LSB */
  67#define GP2AP020A00F_TH_H_REG   0x07 /* ALS: Threshold high MSB */
  68#define GP2AP020A00F_PL_L_REG   0x08 /* PS: Threshold low LSB */
  69#define GP2AP020A00F_PL_H_REG   0x09 /* PS: Threshold low MSB */
  70#define GP2AP020A00F_PH_L_REG   0x0a /* PS: Threshold high LSB */
  71#define GP2AP020A00F_PH_H_REG   0x0b /* PS: Threshold high MSB */
  72#define GP2AP020A00F_D0_L_REG   0x0c /* ALS result: Clear/Illuminance LSB */
  73#define GP2AP020A00F_D0_H_REG   0x0d /* ALS result: Clear/Illuminance MSB */
  74#define GP2AP020A00F_D1_L_REG   0x0e /* ALS result: IR LSB */
  75#define GP2AP020A00F_D1_H_REG   0x0f /* ALS result: IR LSB */
  76#define GP2AP020A00F_D2_L_REG   0x10 /* PS result LSB */
  77#define GP2AP020A00F_D2_H_REG   0x11 /* PS result MSB */
  78#define GP2AP020A00F_NUM_REGS   0x12 /* Number of registers */
  79
  80/* OP_REG bits */
  81#define GP2AP020A00F_OP3_MASK           0x80 /* Software shutdown */
  82#define GP2AP020A00F_OP3_SHUTDOWN       0x00
  83#define GP2AP020A00F_OP3_OPERATION      0x80
  84#define GP2AP020A00F_OP2_MASK           0x40 /* Auto shutdown/Continuous mode */
  85#define GP2AP020A00F_OP2_AUTO_SHUTDOWN  0x00
  86#define GP2AP020A00F_OP2_CONT_OPERATION 0x40
  87#define GP2AP020A00F_OP_MASK            0x30 /* Operating mode selection  */
  88#define GP2AP020A00F_OP_ALS_AND_PS      0x00
  89#define GP2AP020A00F_OP_ALS             0x10
  90#define GP2AP020A00F_OP_PS              0x20
  91#define GP2AP020A00F_OP_DEBUG           0x30
  92#define GP2AP020A00F_PROX_MASK          0x08 /* PS: detection/non-detection */
  93#define GP2AP020A00F_PROX_NON_DETECT    0x00
  94#define GP2AP020A00F_PROX_DETECT        0x08
  95#define GP2AP020A00F_FLAG_P             0x04 /* PS: interrupt result  */
  96#define GP2AP020A00F_FLAG_A             0x02 /* ALS: interrupt result  */
  97#define GP2AP020A00F_TYPE_MASK          0x01 /* Output data type selection */
  98#define GP2AP020A00F_TYPE_MANUAL_CALC   0x00
  99#define GP2AP020A00F_TYPE_AUTO_CALC     0x01
 100
 101/* ALS_REG bits */
 102#define GP2AP020A00F_PRST_MASK          0xc0 /* Number of measurement cycles */
 103#define GP2AP020A00F_PRST_ONCE          0x00
 104#define GP2AP020A00F_PRST_4_CYCLES      0x40
 105#define GP2AP020A00F_PRST_8_CYCLES      0x80
 106#define GP2AP020A00F_PRST_16_CYCLES     0xc0
 107#define GP2AP020A00F_RES_A_MASK         0x38 /* ALS: Resolution */
 108#define GP2AP020A00F_RES_A_800ms        0x00
 109#define GP2AP020A00F_RES_A_400ms        0x08
 110#define GP2AP020A00F_RES_A_200ms        0x10
 111#define GP2AP020A00F_RES_A_100ms        0x18
 112#define GP2AP020A00F_RES_A_25ms         0x20
 113#define GP2AP020A00F_RES_A_6_25ms       0x28
 114#define GP2AP020A00F_RES_A_1_56ms       0x30
 115#define GP2AP020A00F_RES_A_0_39ms       0x38
 116#define GP2AP020A00F_RANGE_A_MASK       0x07 /* ALS: Max measurable range */
 117#define GP2AP020A00F_RANGE_A_x1         0x00
 118#define GP2AP020A00F_RANGE_A_x2         0x01
 119#define GP2AP020A00F_RANGE_A_x4         0x02
 120#define GP2AP020A00F_RANGE_A_x8         0x03
 121#define GP2AP020A00F_RANGE_A_x16        0x04
 122#define GP2AP020A00F_RANGE_A_x32        0x05
 123#define GP2AP020A00F_RANGE_A_x64        0x06
 124#define GP2AP020A00F_RANGE_A_x128       0x07
 125
 126/* PS_REG bits */
 127#define GP2AP020A00F_ALC_MASK           0x80 /* Auto light cancel */
 128#define GP2AP020A00F_ALC_ON             0x80
 129#define GP2AP020A00F_ALC_OFF            0x00
 130#define GP2AP020A00F_INTTYPE_MASK       0x40 /* Interrupt type setting */
 131#define GP2AP020A00F_INTTYPE_LEVEL      0x00
 132#define GP2AP020A00F_INTTYPE_PULSE      0x40
 133#define GP2AP020A00F_RES_P_MASK         0x38 /* PS: Resolution */
 134#define GP2AP020A00F_RES_P_800ms_x2     0x00
 135#define GP2AP020A00F_RES_P_400ms_x2     0x08
 136#define GP2AP020A00F_RES_P_200ms_x2     0x10
 137#define GP2AP020A00F_RES_P_100ms_x2     0x18
 138#define GP2AP020A00F_RES_P_25ms_x2      0x20
 139#define GP2AP020A00F_RES_P_6_25ms_x2    0x28
 140#define GP2AP020A00F_RES_P_1_56ms_x2    0x30
 141#define GP2AP020A00F_RES_P_0_39ms_x2    0x38
 142#define GP2AP020A00F_RANGE_P_MASK       0x07 /* PS: Max measurable range */
 143#define GP2AP020A00F_RANGE_P_x1         0x00
 144#define GP2AP020A00F_RANGE_P_x2         0x01
 145#define GP2AP020A00F_RANGE_P_x4         0x02
 146#define GP2AP020A00F_RANGE_P_x8         0x03
 147#define GP2AP020A00F_RANGE_P_x16        0x04
 148#define GP2AP020A00F_RANGE_P_x32        0x05
 149#define GP2AP020A00F_RANGE_P_x64        0x06
 150#define GP2AP020A00F_RANGE_P_x128       0x07
 151
 152/* LED reg bits */
 153#define GP2AP020A00F_INTVAL_MASK        0xc0 /* Intermittent operating */
 154#define GP2AP020A00F_INTVAL_0           0x00
 155#define GP2AP020A00F_INTVAL_4           0x40
 156#define GP2AP020A00F_INTVAL_8           0x80
 157#define GP2AP020A00F_INTVAL_16          0xc0
 158#define GP2AP020A00F_IS_MASK            0x30 /* ILED drive peak current */
 159#define GP2AP020A00F_IS_13_8mA          0x00
 160#define GP2AP020A00F_IS_27_5mA          0x10
 161#define GP2AP020A00F_IS_55mA            0x20
 162#define GP2AP020A00F_IS_110mA           0x30
 163#define GP2AP020A00F_PIN_MASK           0x0c /* INT terminal setting */
 164#define GP2AP020A00F_PIN_ALS_OR_PS      0x00
 165#define GP2AP020A00F_PIN_ALS            0x04
 166#define GP2AP020A00F_PIN_PS             0x08
 167#define GP2AP020A00F_PIN_PS_DETECT      0x0c
 168#define GP2AP020A00F_FREQ_MASK          0x02 /* LED modulation frequency */
 169#define GP2AP020A00F_FREQ_327_5kHz      0x00
 170#define GP2AP020A00F_FREQ_81_8kHz       0x02
 171#define GP2AP020A00F_RST                0x01 /* Software reset */
 172
 173#define GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR      0
 174#define GP2AP020A00F_SCAN_MODE_LIGHT_IR         1
 175#define GP2AP020A00F_SCAN_MODE_PROXIMITY        2
 176#define GP2AP020A00F_CHAN_TIMESTAMP             3
 177
 178#define GP2AP020A00F_DATA_READY_TIMEOUT         msecs_to_jiffies(1000)
 179#define GP2AP020A00F_DATA_REG(chan)             (GP2AP020A00F_D0_L_REG + \
 180                                                        (chan) * 2)
 181#define GP2AP020A00F_THRESH_REG(th_val_id)      (GP2AP020A00F_TL_L_REG + \
 182                                                        (th_val_id) * 2)
 183#define GP2AP020A00F_THRESH_VAL_ID(reg_addr)    ((reg_addr - 4) / 2)
 184
 185#define GP2AP020A00F_SUBTRACT_MODE      0
 186#define GP2AP020A00F_ADD_MODE           1
 187
 188#define GP2AP020A00F_MAX_CHANNELS       3
 189
 190enum gp2ap020a00f_opmode {
 191        GP2AP020A00F_OPMODE_READ_RAW_CLEAR,
 192        GP2AP020A00F_OPMODE_READ_RAW_IR,
 193        GP2AP020A00F_OPMODE_READ_RAW_PROXIMITY,
 194        GP2AP020A00F_OPMODE_ALS,
 195        GP2AP020A00F_OPMODE_PS,
 196        GP2AP020A00F_OPMODE_ALS_AND_PS,
 197        GP2AP020A00F_OPMODE_PROX_DETECT,
 198        GP2AP020A00F_OPMODE_SHUTDOWN,
 199        GP2AP020A00F_NUM_OPMODES,
 200};
 201
 202enum gp2ap020a00f_cmd {
 203        GP2AP020A00F_CMD_READ_RAW_CLEAR,
 204        GP2AP020A00F_CMD_READ_RAW_IR,
 205        GP2AP020A00F_CMD_READ_RAW_PROXIMITY,
 206        GP2AP020A00F_CMD_TRIGGER_CLEAR_EN,
 207        GP2AP020A00F_CMD_TRIGGER_CLEAR_DIS,
 208        GP2AP020A00F_CMD_TRIGGER_IR_EN,
 209        GP2AP020A00F_CMD_TRIGGER_IR_DIS,
 210        GP2AP020A00F_CMD_TRIGGER_PROX_EN,
 211        GP2AP020A00F_CMD_TRIGGER_PROX_DIS,
 212        GP2AP020A00F_CMD_ALS_HIGH_EV_EN,
 213        GP2AP020A00F_CMD_ALS_HIGH_EV_DIS,
 214        GP2AP020A00F_CMD_ALS_LOW_EV_EN,
 215        GP2AP020A00F_CMD_ALS_LOW_EV_DIS,
 216        GP2AP020A00F_CMD_PROX_HIGH_EV_EN,
 217        GP2AP020A00F_CMD_PROX_HIGH_EV_DIS,
 218        GP2AP020A00F_CMD_PROX_LOW_EV_EN,
 219        GP2AP020A00F_CMD_PROX_LOW_EV_DIS,
 220};
 221
 222enum gp2ap020a00f_flags {
 223        GP2AP020A00F_FLAG_ALS_CLEAR_TRIGGER,
 224        GP2AP020A00F_FLAG_ALS_IR_TRIGGER,
 225        GP2AP020A00F_FLAG_PROX_TRIGGER,
 226        GP2AP020A00F_FLAG_PROX_RISING_EV,
 227        GP2AP020A00F_FLAG_PROX_FALLING_EV,
 228        GP2AP020A00F_FLAG_ALS_RISING_EV,
 229        GP2AP020A00F_FLAG_ALS_FALLING_EV,
 230        GP2AP020A00F_FLAG_LUX_MODE_HI,
 231        GP2AP020A00F_FLAG_DATA_READY,
 232};
 233
 234enum gp2ap020a00f_thresh_val_id {
 235        GP2AP020A00F_THRESH_TL,
 236        GP2AP020A00F_THRESH_TH,
 237        GP2AP020A00F_THRESH_PL,
 238        GP2AP020A00F_THRESH_PH,
 239};
 240
 241struct gp2ap020a00f_data {
 242        const struct gp2ap020a00f_platform_data *pdata;
 243        struct i2c_client *client;
 244        struct mutex lock;
 245        char *buffer;
 246        struct regulator *vled_reg;
 247        unsigned long flags;
 248        enum gp2ap020a00f_opmode cur_opmode;
 249        struct iio_trigger *trig;
 250        struct regmap *regmap;
 251        unsigned int thresh_val[4];
 252        u8 debug_reg_addr;
 253        struct irq_work work;
 254        wait_queue_head_t data_ready_queue;
 255};
 256
 257static const u8 gp2ap020a00f_reg_init_tab[] = {
 258        [GP2AP020A00F_OP_REG] = GP2AP020A00F_OP3_SHUTDOWN,
 259        [GP2AP020A00F_ALS_REG] = GP2AP020A00F_RES_A_25ms |
 260                                 GP2AP020A00F_RANGE_A_x8,
 261        [GP2AP020A00F_PS_REG] = GP2AP020A00F_ALC_ON |
 262                                GP2AP020A00F_RES_P_1_56ms_x2 |
 263                                GP2AP020A00F_RANGE_P_x4,
 264        [GP2AP020A00F_LED_REG] = GP2AP020A00F_INTVAL_0 |
 265                                 GP2AP020A00F_IS_110mA |
 266                                 GP2AP020A00F_FREQ_327_5kHz,
 267        [GP2AP020A00F_TL_L_REG] = 0,
 268        [GP2AP020A00F_TL_H_REG] = 0,
 269        [GP2AP020A00F_TH_L_REG] = 0,
 270        [GP2AP020A00F_TH_H_REG] = 0,
 271        [GP2AP020A00F_PL_L_REG] = 0,
 272        [GP2AP020A00F_PL_H_REG] = 0,
 273        [GP2AP020A00F_PH_L_REG] = 0,
 274        [GP2AP020A00F_PH_H_REG] = 0,
 275};
 276
 277static bool gp2ap020a00f_is_volatile_reg(struct device *dev, unsigned int reg)
 278{
 279        switch (reg) {
 280        case GP2AP020A00F_OP_REG:
 281        case GP2AP020A00F_D0_L_REG:
 282        case GP2AP020A00F_D0_H_REG:
 283        case GP2AP020A00F_D1_L_REG:
 284        case GP2AP020A00F_D1_H_REG:
 285        case GP2AP020A00F_D2_L_REG:
 286        case GP2AP020A00F_D2_H_REG:
 287                return true;
 288        default:
 289                return false;
 290        }
 291}
 292
 293static const struct regmap_config gp2ap020a00f_regmap_config = {
 294        .reg_bits = 8,
 295        .val_bits = 8,
 296
 297        .max_register = GP2AP020A00F_D2_H_REG,
 298        .cache_type = REGCACHE_RBTREE,
 299
 300        .volatile_reg = gp2ap020a00f_is_volatile_reg,
 301};
 302
 303static const struct gp2ap020a00f_mutable_config_regs {
 304        u8 op_reg;
 305        u8 als_reg;
 306        u8 ps_reg;
 307        u8 led_reg;
 308} opmode_regs_settings[GP2AP020A00F_NUM_OPMODES] = {
 309        [GP2AP020A00F_OPMODE_READ_RAW_CLEAR] = {
 310                GP2AP020A00F_OP_ALS | GP2AP020A00F_OP2_CONT_OPERATION
 311                | GP2AP020A00F_OP3_OPERATION
 312                | GP2AP020A00F_TYPE_AUTO_CALC,
 313                GP2AP020A00F_PRST_ONCE,
 314                GP2AP020A00F_INTTYPE_LEVEL,
 315                GP2AP020A00F_PIN_ALS
 316        },
 317        [GP2AP020A00F_OPMODE_READ_RAW_IR] = {
 318                GP2AP020A00F_OP_ALS | GP2AP020A00F_OP2_CONT_OPERATION
 319                | GP2AP020A00F_OP3_OPERATION
 320                | GP2AP020A00F_TYPE_MANUAL_CALC,
 321                GP2AP020A00F_PRST_ONCE,
 322                GP2AP020A00F_INTTYPE_LEVEL,
 323                GP2AP020A00F_PIN_ALS
 324        },
 325        [GP2AP020A00F_OPMODE_READ_RAW_PROXIMITY] = {
 326                GP2AP020A00F_OP_PS | GP2AP020A00F_OP2_CONT_OPERATION
 327                | GP2AP020A00F_OP3_OPERATION
 328                | GP2AP020A00F_TYPE_MANUAL_CALC,
 329                GP2AP020A00F_PRST_ONCE,
 330                GP2AP020A00F_INTTYPE_LEVEL,
 331                GP2AP020A00F_PIN_PS
 332        },
 333        [GP2AP020A00F_OPMODE_PROX_DETECT] = {
 334                GP2AP020A00F_OP_PS | GP2AP020A00F_OP2_CONT_OPERATION
 335                | GP2AP020A00F_OP3_OPERATION
 336                | GP2AP020A00F_TYPE_MANUAL_CALC,
 337                GP2AP020A00F_PRST_4_CYCLES,
 338                GP2AP020A00F_INTTYPE_PULSE,
 339                GP2AP020A00F_PIN_PS_DETECT
 340        },
 341        [GP2AP020A00F_OPMODE_ALS] = {
 342                GP2AP020A00F_OP_ALS | GP2AP020A00F_OP2_CONT_OPERATION
 343                | GP2AP020A00F_OP3_OPERATION
 344                | GP2AP020A00F_TYPE_AUTO_CALC,
 345                GP2AP020A00F_PRST_ONCE,
 346                GP2AP020A00F_INTTYPE_LEVEL,
 347                GP2AP020A00F_PIN_ALS
 348        },
 349        [GP2AP020A00F_OPMODE_PS] = {
 350                GP2AP020A00F_OP_PS | GP2AP020A00F_OP2_CONT_OPERATION
 351                | GP2AP020A00F_OP3_OPERATION
 352                | GP2AP020A00F_TYPE_MANUAL_CALC,
 353                GP2AP020A00F_PRST_4_CYCLES,
 354                GP2AP020A00F_INTTYPE_LEVEL,
 355                GP2AP020A00F_PIN_PS
 356        },
 357        [GP2AP020A00F_OPMODE_ALS_AND_PS] = {
 358                GP2AP020A00F_OP_ALS_AND_PS
 359                | GP2AP020A00F_OP2_CONT_OPERATION
 360                | GP2AP020A00F_OP3_OPERATION
 361                | GP2AP020A00F_TYPE_AUTO_CALC,
 362                GP2AP020A00F_PRST_4_CYCLES,
 363                GP2AP020A00F_INTTYPE_LEVEL,
 364                GP2AP020A00F_PIN_ALS_OR_PS
 365        },
 366        [GP2AP020A00F_OPMODE_SHUTDOWN] = { GP2AP020A00F_OP3_SHUTDOWN, },
 367};
 368
 369static int gp2ap020a00f_set_operation_mode(struct gp2ap020a00f_data *data,
 370                                        enum gp2ap020a00f_opmode op)
 371{
 372        unsigned int op_reg_val;
 373        int err;
 374
 375        if (op != GP2AP020A00F_OPMODE_SHUTDOWN) {
 376                err = regmap_read(data->regmap, GP2AP020A00F_OP_REG,
 377                                        &op_reg_val);
 378                if (err < 0)
 379                        return err;
 380                /*
 381                 * Shutdown the device if the operation being executed entails
 382                 * mode transition.
 383                 */
 384                if ((opmode_regs_settings[op].op_reg & GP2AP020A00F_OP_MASK) !=
 385                    (op_reg_val & GP2AP020A00F_OP_MASK)) {
 386                        /* set shutdown mode */
 387                        err = regmap_update_bits(data->regmap,
 388                                GP2AP020A00F_OP_REG, GP2AP020A00F_OP3_MASK,
 389                                GP2AP020A00F_OP3_SHUTDOWN);
 390                        if (err < 0)
 391                                return err;
 392                }
 393
 394                err = regmap_update_bits(data->regmap, GP2AP020A00F_ALS_REG,
 395                        GP2AP020A00F_PRST_MASK, opmode_regs_settings[op]
 396                                                                .als_reg);
 397                if (err < 0)
 398                        return err;
 399
 400                err = regmap_update_bits(data->regmap, GP2AP020A00F_PS_REG,
 401                        GP2AP020A00F_INTTYPE_MASK, opmode_regs_settings[op]
 402                                                                .ps_reg);
 403                if (err < 0)
 404                        return err;
 405
 406                err = regmap_update_bits(data->regmap, GP2AP020A00F_LED_REG,
 407                        GP2AP020A00F_PIN_MASK, opmode_regs_settings[op]
 408                                                                .led_reg);
 409                if (err < 0)
 410                        return err;
 411        }
 412
 413        /* Set OP_REG and apply operation mode (power on / off) */
 414        err = regmap_update_bits(data->regmap,
 415                                 GP2AP020A00F_OP_REG,
 416                                 GP2AP020A00F_OP_MASK | GP2AP020A00F_OP2_MASK |
 417                                 GP2AP020A00F_OP3_MASK | GP2AP020A00F_TYPE_MASK,
 418                                 opmode_regs_settings[op].op_reg);
 419        if (err < 0)
 420                return err;
 421
 422        data->cur_opmode = op;
 423
 424        return 0;
 425}
 426
 427static bool gp2ap020a00f_als_enabled(struct gp2ap020a00f_data *data)
 428{
 429        return test_bit(GP2AP020A00F_FLAG_ALS_CLEAR_TRIGGER, &data->flags) ||
 430               test_bit(GP2AP020A00F_FLAG_ALS_IR_TRIGGER, &data->flags) ||
 431               test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &data->flags) ||
 432               test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &data->flags);
 433}
 434
 435static bool gp2ap020a00f_prox_detect_enabled(struct gp2ap020a00f_data *data)
 436{
 437        return test_bit(GP2AP020A00F_FLAG_PROX_RISING_EV, &data->flags) ||
 438               test_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV, &data->flags);
 439}
 440
 441static int gp2ap020a00f_write_event_threshold(struct gp2ap020a00f_data *data,
 442                                enum gp2ap020a00f_thresh_val_id th_val_id,
 443                                bool enable)
 444{
 445        __le16 thresh_buf = 0;
 446        unsigned int thresh_reg_val;
 447
 448        if (!enable)
 449                thresh_reg_val = 0;
 450        else if (test_bit(GP2AP020A00F_FLAG_LUX_MODE_HI, &data->flags) &&
 451                 th_val_id != GP2AP020A00F_THRESH_PL &&
 452                 th_val_id != GP2AP020A00F_THRESH_PH)
 453                /*
 454                 * For the high lux mode ALS threshold has to be scaled down
 455                 * to allow for proper comparison with the output value.
 456                 */
 457                thresh_reg_val = data->thresh_val[th_val_id] / 16;
 458        else
 459                thresh_reg_val = data->thresh_val[th_val_id] > 16000 ?
 460                                        16000 :
 461                                        data->thresh_val[th_val_id];
 462
 463        thresh_buf = cpu_to_le16(thresh_reg_val);
 464
 465        return regmap_bulk_write(data->regmap,
 466                                 GP2AP020A00F_THRESH_REG(th_val_id),
 467                                 (u8 *)&thresh_buf, 2);
 468}
 469
 470static int gp2ap020a00f_alter_opmode(struct gp2ap020a00f_data *data,
 471                        enum gp2ap020a00f_opmode diff_mode, int add_sub)
 472{
 473        enum gp2ap020a00f_opmode new_mode;
 474
 475        if (diff_mode != GP2AP020A00F_OPMODE_ALS &&
 476            diff_mode != GP2AP020A00F_OPMODE_PS)
 477                return -EINVAL;
 478
 479        if (add_sub == GP2AP020A00F_ADD_MODE) {
 480                if (data->cur_opmode == GP2AP020A00F_OPMODE_SHUTDOWN)
 481                        new_mode =  diff_mode;
 482                else
 483                        new_mode = GP2AP020A00F_OPMODE_ALS_AND_PS;
 484        } else {
 485                if (data->cur_opmode == GP2AP020A00F_OPMODE_ALS_AND_PS)
 486                        new_mode = (diff_mode == GP2AP020A00F_OPMODE_ALS) ?
 487                                        GP2AP020A00F_OPMODE_PS :
 488                                        GP2AP020A00F_OPMODE_ALS;
 489                else
 490                        new_mode = GP2AP020A00F_OPMODE_SHUTDOWN;
 491        }
 492
 493        return gp2ap020a00f_set_operation_mode(data, new_mode);
 494}
 495
 496static int gp2ap020a00f_exec_cmd(struct gp2ap020a00f_data *data,
 497                                        enum gp2ap020a00f_cmd cmd)
 498{
 499        int err = 0;
 500
 501        switch (cmd) {
 502        case GP2AP020A00F_CMD_READ_RAW_CLEAR:
 503                if (data->cur_opmode != GP2AP020A00F_OPMODE_SHUTDOWN)
 504                        return -EBUSY;
 505                err = gp2ap020a00f_set_operation_mode(data,
 506                                        GP2AP020A00F_OPMODE_READ_RAW_CLEAR);
 507                break;
 508        case GP2AP020A00F_CMD_READ_RAW_IR:
 509                if (data->cur_opmode != GP2AP020A00F_OPMODE_SHUTDOWN)
 510                        return -EBUSY;
 511                err = gp2ap020a00f_set_operation_mode(data,
 512                                        GP2AP020A00F_OPMODE_READ_RAW_IR);
 513                break;
 514        case GP2AP020A00F_CMD_READ_RAW_PROXIMITY:
 515                if (data->cur_opmode != GP2AP020A00F_OPMODE_SHUTDOWN)
 516                        return -EBUSY;
 517                err = gp2ap020a00f_set_operation_mode(data,
 518                                        GP2AP020A00F_OPMODE_READ_RAW_PROXIMITY);
 519                break;
 520        case GP2AP020A00F_CMD_TRIGGER_CLEAR_EN:
 521                if (data->cur_opmode == GP2AP020A00F_OPMODE_PROX_DETECT)
 522                        return -EBUSY;
 523                if (!gp2ap020a00f_als_enabled(data))
 524                        err = gp2ap020a00f_alter_opmode(data,
 525                                                GP2AP020A00F_OPMODE_ALS,
 526                                                GP2AP020A00F_ADD_MODE);
 527                set_bit(GP2AP020A00F_FLAG_ALS_CLEAR_TRIGGER, &data->flags);
 528                break;
 529        case GP2AP020A00F_CMD_TRIGGER_CLEAR_DIS:
 530                clear_bit(GP2AP020A00F_FLAG_ALS_CLEAR_TRIGGER, &data->flags);
 531                if (gp2ap020a00f_als_enabled(data))
 532                        break;
 533                err = gp2ap020a00f_alter_opmode(data,
 534                                                GP2AP020A00F_OPMODE_ALS,
 535                                                GP2AP020A00F_SUBTRACT_MODE);
 536                break;
 537        case GP2AP020A00F_CMD_TRIGGER_IR_EN:
 538                if (data->cur_opmode == GP2AP020A00F_OPMODE_PROX_DETECT)
 539                        return -EBUSY;
 540                if (!gp2ap020a00f_als_enabled(data))
 541                        err = gp2ap020a00f_alter_opmode(data,
 542                                                GP2AP020A00F_OPMODE_ALS,
 543                                                GP2AP020A00F_ADD_MODE);
 544                set_bit(GP2AP020A00F_FLAG_ALS_IR_TRIGGER, &data->flags);
 545                break;
 546        case GP2AP020A00F_CMD_TRIGGER_IR_DIS:
 547                clear_bit(GP2AP020A00F_FLAG_ALS_IR_TRIGGER, &data->flags);
 548                if (gp2ap020a00f_als_enabled(data))
 549                        break;
 550                err = gp2ap020a00f_alter_opmode(data,
 551                                                GP2AP020A00F_OPMODE_ALS,
 552                                                GP2AP020A00F_SUBTRACT_MODE);
 553                break;
 554        case GP2AP020A00F_CMD_TRIGGER_PROX_EN:
 555                if (data->cur_opmode == GP2AP020A00F_OPMODE_PROX_DETECT)
 556                        return -EBUSY;
 557                err = gp2ap020a00f_alter_opmode(data,
 558                                                GP2AP020A00F_OPMODE_PS,
 559                                                GP2AP020A00F_ADD_MODE);
 560                set_bit(GP2AP020A00F_FLAG_PROX_TRIGGER, &data->flags);
 561                break;
 562        case GP2AP020A00F_CMD_TRIGGER_PROX_DIS:
 563                clear_bit(GP2AP020A00F_FLAG_PROX_TRIGGER, &data->flags);
 564                err = gp2ap020a00f_alter_opmode(data,
 565                                                GP2AP020A00F_OPMODE_PS,
 566                                                GP2AP020A00F_SUBTRACT_MODE);
 567                break;
 568        case GP2AP020A00F_CMD_ALS_HIGH_EV_EN:
 569                if (test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &data->flags))
 570                        return 0;
 571                if (data->cur_opmode == GP2AP020A00F_OPMODE_PROX_DETECT)
 572                        return -EBUSY;
 573                if (!gp2ap020a00f_als_enabled(data)) {
 574                        err = gp2ap020a00f_alter_opmode(data,
 575                                                GP2AP020A00F_OPMODE_ALS,
 576                                                GP2AP020A00F_ADD_MODE);
 577                        if (err < 0)
 578                                return err;
 579                }
 580                set_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &data->flags);
 581                err =  gp2ap020a00f_write_event_threshold(data,
 582                                        GP2AP020A00F_THRESH_TH, true);
 583                break;
 584        case GP2AP020A00F_CMD_ALS_HIGH_EV_DIS:
 585                if (!test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &data->flags))
 586                        return 0;
 587                clear_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &data->flags);
 588                if (!gp2ap020a00f_als_enabled(data)) {
 589                        err = gp2ap020a00f_alter_opmode(data,
 590                                                GP2AP020A00F_OPMODE_ALS,
 591                                                GP2AP020A00F_SUBTRACT_MODE);
 592                        if (err < 0)
 593                                return err;
 594                }
 595                err =  gp2ap020a00f_write_event_threshold(data,
 596                                        GP2AP020A00F_THRESH_TH, false);
 597                break;
 598        case GP2AP020A00F_CMD_ALS_LOW_EV_EN:
 599                if (test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &data->flags))
 600                        return 0;
 601                if (data->cur_opmode == GP2AP020A00F_OPMODE_PROX_DETECT)
 602                        return -EBUSY;
 603                if (!gp2ap020a00f_als_enabled(data)) {
 604                        err = gp2ap020a00f_alter_opmode(data,
 605                                                GP2AP020A00F_OPMODE_ALS,
 606                                                GP2AP020A00F_ADD_MODE);
 607                        if (err < 0)
 608                                return err;
 609                }
 610                set_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &data->flags);
 611                err =  gp2ap020a00f_write_event_threshold(data,
 612                                        GP2AP020A00F_THRESH_TL, true);
 613                break;
 614        case GP2AP020A00F_CMD_ALS_LOW_EV_DIS:
 615                if (!test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &data->flags))
 616                        return 0;
 617                clear_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &data->flags);
 618                if (!gp2ap020a00f_als_enabled(data)) {
 619                        err = gp2ap020a00f_alter_opmode(data,
 620                                                GP2AP020A00F_OPMODE_ALS,
 621                                                GP2AP020A00F_SUBTRACT_MODE);
 622                        if (err < 0)
 623                                return err;
 624                }
 625                err =  gp2ap020a00f_write_event_threshold(data,
 626                                        GP2AP020A00F_THRESH_TL, false);
 627                break;
 628        case GP2AP020A00F_CMD_PROX_HIGH_EV_EN:
 629                if (test_bit(GP2AP020A00F_FLAG_PROX_RISING_EV, &data->flags))
 630                        return 0;
 631                if (gp2ap020a00f_als_enabled(data) ||
 632                    data->cur_opmode == GP2AP020A00F_OPMODE_PS)
 633                        return -EBUSY;
 634                if (!gp2ap020a00f_prox_detect_enabled(data)) {
 635                        err = gp2ap020a00f_set_operation_mode(data,
 636                                        GP2AP020A00F_OPMODE_PROX_DETECT);
 637                        if (err < 0)
 638                                return err;
 639                }
 640                set_bit(GP2AP020A00F_FLAG_PROX_RISING_EV, &data->flags);
 641                err =  gp2ap020a00f_write_event_threshold(data,
 642                                        GP2AP020A00F_THRESH_PH, true);
 643                break;
 644        case GP2AP020A00F_CMD_PROX_HIGH_EV_DIS:
 645                if (!test_bit(GP2AP020A00F_FLAG_PROX_RISING_EV, &data->flags))
 646                        return 0;
 647                clear_bit(GP2AP020A00F_FLAG_PROX_RISING_EV, &data->flags);
 648                err = gp2ap020a00f_set_operation_mode(data,
 649                                        GP2AP020A00F_OPMODE_SHUTDOWN);
 650                if (err < 0)
 651                        return err;
 652                err =  gp2ap020a00f_write_event_threshold(data,
 653                                        GP2AP020A00F_THRESH_PH, false);
 654                break;
 655        case GP2AP020A00F_CMD_PROX_LOW_EV_EN:
 656                if (test_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV, &data->flags))
 657                        return 0;
 658                if (gp2ap020a00f_als_enabled(data) ||
 659                    data->cur_opmode == GP2AP020A00F_OPMODE_PS)
 660                        return -EBUSY;
 661                if (!gp2ap020a00f_prox_detect_enabled(data)) {
 662                        err = gp2ap020a00f_set_operation_mode(data,
 663                                        GP2AP020A00F_OPMODE_PROX_DETECT);
 664                        if (err < 0)
 665                                return err;
 666                }
 667                set_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV, &data->flags);
 668                err =  gp2ap020a00f_write_event_threshold(data,
 669                                        GP2AP020A00F_THRESH_PL, true);
 670                break;
 671        case GP2AP020A00F_CMD_PROX_LOW_EV_DIS:
 672                if (!test_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV, &data->flags))
 673                        return 0;
 674                clear_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV, &data->flags);
 675                err = gp2ap020a00f_set_operation_mode(data,
 676                                        GP2AP020A00F_OPMODE_SHUTDOWN);
 677                if (err < 0)
 678                        return err;
 679                err =  gp2ap020a00f_write_event_threshold(data,
 680                                        GP2AP020A00F_THRESH_PL, false);
 681                break;
 682        }
 683
 684        return err;
 685}
 686
 687static int wait_conversion_complete_irq(struct gp2ap020a00f_data *data)
 688{
 689        int ret;
 690
 691        ret = wait_event_timeout(data->data_ready_queue,
 692                                 test_bit(GP2AP020A00F_FLAG_DATA_READY,
 693                                          &data->flags),
 694                                 GP2AP020A00F_DATA_READY_TIMEOUT);
 695        clear_bit(GP2AP020A00F_FLAG_DATA_READY, &data->flags);
 696
 697        return ret > 0 ? 0 : -ETIME;
 698}
 699
 700static int gp2ap020a00f_read_output(struct gp2ap020a00f_data *data,
 701                                        unsigned int output_reg, int *val)
 702{
 703        u8 reg_buf[2];
 704        int err;
 705
 706        err = wait_conversion_complete_irq(data);
 707        if (err < 0)
 708                dev_dbg(&data->client->dev, "data ready timeout\n");
 709
 710        err = regmap_bulk_read(data->regmap, output_reg, reg_buf, 2);
 711        if (err < 0)
 712                return err;
 713
 714        *val = le16_to_cpup((__le16 *)reg_buf);
 715
 716        return err;
 717}
 718
 719static bool gp2ap020a00f_adjust_lux_mode(struct gp2ap020a00f_data *data,
 720                                 int output_val)
 721{
 722        u8 new_range = 0xff;
 723        int err;
 724
 725        if (!test_bit(GP2AP020A00F_FLAG_LUX_MODE_HI, &data->flags)) {
 726                if (output_val > 16000) {
 727                        set_bit(GP2AP020A00F_FLAG_LUX_MODE_HI, &data->flags);
 728                        new_range = GP2AP020A00F_RANGE_A_x128;
 729                }
 730        } else {
 731                if (output_val < 1000) {
 732                        clear_bit(GP2AP020A00F_FLAG_LUX_MODE_HI, &data->flags);
 733                        new_range = GP2AP020A00F_RANGE_A_x8;
 734                }
 735        }
 736
 737        if (new_range != 0xff) {
 738                /* Clear als threshold registers to avoid spurious
 739                 * events caused by lux mode transition.
 740                 */
 741                err =  gp2ap020a00f_write_event_threshold(data,
 742                                        GP2AP020A00F_THRESH_TH, false);
 743                if (err < 0) {
 744                        dev_err(&data->client->dev,
 745                                "Clearing als threshold register failed.\n");
 746                        return false;
 747                }
 748
 749                err =  gp2ap020a00f_write_event_threshold(data,
 750                                        GP2AP020A00F_THRESH_TL, false);
 751                if (err < 0) {
 752                        dev_err(&data->client->dev,
 753                                "Clearing als threshold register failed.\n");
 754                        return false;
 755                }
 756
 757                /* Change lux mode */
 758                err = regmap_update_bits(data->regmap,
 759                        GP2AP020A00F_OP_REG,
 760                        GP2AP020A00F_OP3_MASK,
 761                        GP2AP020A00F_OP3_SHUTDOWN);
 762
 763                if (err < 0) {
 764                        dev_err(&data->client->dev,
 765                                "Shutting down the device failed.\n");
 766                        return false;
 767                }
 768
 769                err = regmap_update_bits(data->regmap,
 770                        GP2AP020A00F_ALS_REG,
 771                        GP2AP020A00F_RANGE_A_MASK,
 772                        new_range);
 773
 774                if (err < 0) {
 775                        dev_err(&data->client->dev,
 776                                "Adjusting device lux mode failed.\n");
 777                        return false;
 778                }
 779
 780                err = regmap_update_bits(data->regmap,
 781                        GP2AP020A00F_OP_REG,
 782                        GP2AP020A00F_OP3_MASK,
 783                        GP2AP020A00F_OP3_OPERATION);
 784
 785                if (err < 0) {
 786                        dev_err(&data->client->dev,
 787                                "Powering up the device failed.\n");
 788                        return false;
 789                }
 790
 791                /* Adjust als threshold register values to the new lux mode */
 792                if (test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &data->flags)) {
 793                        err =  gp2ap020a00f_write_event_threshold(data,
 794                                        GP2AP020A00F_THRESH_TH, true);
 795                        if (err < 0) {
 796                                dev_err(&data->client->dev,
 797                                "Adjusting als threshold value failed.\n");
 798                                return false;
 799                        }
 800                }
 801
 802                if (test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &data->flags)) {
 803                        err =  gp2ap020a00f_write_event_threshold(data,
 804                                        GP2AP020A00F_THRESH_TL, true);
 805                        if (err < 0) {
 806                                dev_err(&data->client->dev,
 807                                "Adjusting als threshold value failed.\n");
 808                                return false;
 809                        }
 810                }
 811
 812                return true;
 813        }
 814
 815        return false;
 816}
 817
 818static void gp2ap020a00f_output_to_lux(struct gp2ap020a00f_data *data,
 819                                                int *output_val)
 820{
 821        if (test_bit(GP2AP020A00F_FLAG_LUX_MODE_HI, &data->flags))
 822                *output_val *= 16;
 823}
 824
 825static void gp2ap020a00f_iio_trigger_work(struct irq_work *work)
 826{
 827        struct gp2ap020a00f_data *data =
 828                container_of(work, struct gp2ap020a00f_data, work);
 829
 830        iio_trigger_poll(data->trig);
 831}
 832
 833static irqreturn_t gp2ap020a00f_prox_sensing_handler(int irq, void *data)
 834{
 835        struct iio_dev *indio_dev = data;
 836        struct gp2ap020a00f_data *priv = iio_priv(indio_dev);
 837        unsigned int op_reg_val;
 838        int ret;
 839
 840        /* Read interrupt flags */
 841        ret = regmap_read(priv->regmap, GP2AP020A00F_OP_REG, &op_reg_val);
 842        if (ret < 0)
 843                return IRQ_HANDLED;
 844
 845        if (gp2ap020a00f_prox_detect_enabled(priv)) {
 846                if (op_reg_val & GP2AP020A00F_PROX_DETECT) {
 847                        iio_push_event(indio_dev,
 848                               IIO_UNMOD_EVENT_CODE(
 849                                    IIO_PROXIMITY,
 850                                    GP2AP020A00F_SCAN_MODE_PROXIMITY,
 851                                    IIO_EV_TYPE_ROC,
 852                                    IIO_EV_DIR_RISING),
 853                               iio_get_time_ns());
 854                } else {
 855                        iio_push_event(indio_dev,
 856                               IIO_UNMOD_EVENT_CODE(
 857                                    IIO_PROXIMITY,
 858                                    GP2AP020A00F_SCAN_MODE_PROXIMITY,
 859                                    IIO_EV_TYPE_ROC,
 860                                    IIO_EV_DIR_FALLING),
 861                               iio_get_time_ns());
 862                }
 863        }
 864
 865        return IRQ_HANDLED;
 866}
 867
 868static irqreturn_t gp2ap020a00f_thresh_event_handler(int irq, void *data)
 869{
 870        struct iio_dev *indio_dev = data;
 871        struct gp2ap020a00f_data *priv = iio_priv(indio_dev);
 872        u8 op_reg_flags, d0_reg_buf[2];
 873        unsigned int output_val, op_reg_val;
 874        int thresh_val_id, ret;
 875
 876        /* Read interrupt flags */
 877        ret = regmap_read(priv->regmap, GP2AP020A00F_OP_REG,
 878                                                        &op_reg_val);
 879        if (ret < 0)
 880                goto done;
 881
 882        op_reg_flags = op_reg_val & (GP2AP020A00F_FLAG_A | GP2AP020A00F_FLAG_P
 883                                        | GP2AP020A00F_PROX_DETECT);
 884
 885        op_reg_val &= (~GP2AP020A00F_FLAG_A & ~GP2AP020A00F_FLAG_P
 886                                        & ~GP2AP020A00F_PROX_DETECT);
 887
 888        /* Clear interrupt flags (if not in INTTYPE_PULSE mode) */
 889        if (priv->cur_opmode != GP2AP020A00F_OPMODE_PROX_DETECT) {
 890                ret = regmap_write(priv->regmap, GP2AP020A00F_OP_REG,
 891                                                                op_reg_val);
 892                if (ret < 0)
 893                        goto done;
 894        }
 895
 896        if (op_reg_flags & GP2AP020A00F_FLAG_A) {
 897                /* Check D0 register to assess if the lux mode
 898                 * transition is required.
 899                 */
 900                ret = regmap_bulk_read(priv->regmap, GP2AP020A00F_D0_L_REG,
 901                                                        d0_reg_buf, 2);
 902                if (ret < 0)
 903                        goto done;
 904
 905                output_val = le16_to_cpup((__le16 *)d0_reg_buf);
 906
 907                if (gp2ap020a00f_adjust_lux_mode(priv, output_val))
 908                        goto done;
 909
 910                gp2ap020a00f_output_to_lux(priv, &output_val);
 911
 912                /*
 913                 * We need to check output value to distinguish
 914                 * between high and low ambient light threshold event.
 915                 */
 916                if (test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &priv->flags)) {
 917                        thresh_val_id =
 918                            GP2AP020A00F_THRESH_VAL_ID(GP2AP020A00F_TH_L_REG);
 919                        if (output_val > priv->thresh_val[thresh_val_id])
 920                                iio_push_event(indio_dev,
 921                                       IIO_MOD_EVENT_CODE(
 922                                            IIO_LIGHT,
 923                                            GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR,
 924                                            IIO_MOD_LIGHT_CLEAR,
 925                                            IIO_EV_TYPE_THRESH,
 926                                            IIO_EV_DIR_RISING),
 927                                       iio_get_time_ns());
 928                }
 929
 930                if (test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &priv->flags)) {
 931                        thresh_val_id =
 932                            GP2AP020A00F_THRESH_VAL_ID(GP2AP020A00F_TL_L_REG);
 933                        if (output_val < priv->thresh_val[thresh_val_id])
 934                                iio_push_event(indio_dev,
 935                                       IIO_MOD_EVENT_CODE(
 936                                            IIO_LIGHT,
 937                                            GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR,
 938                                            IIO_MOD_LIGHT_CLEAR,
 939                                            IIO_EV_TYPE_THRESH,
 940                                            IIO_EV_DIR_FALLING),
 941                                       iio_get_time_ns());
 942                }
 943        }
 944
 945        if (priv->cur_opmode == GP2AP020A00F_OPMODE_READ_RAW_CLEAR ||
 946            priv->cur_opmode == GP2AP020A00F_OPMODE_READ_RAW_IR ||
 947            priv->cur_opmode == GP2AP020A00F_OPMODE_READ_RAW_PROXIMITY) {
 948                set_bit(GP2AP020A00F_FLAG_DATA_READY, &priv->flags);
 949                wake_up(&priv->data_ready_queue);
 950                goto done;
 951        }
 952
 953        if (test_bit(GP2AP020A00F_FLAG_ALS_CLEAR_TRIGGER, &priv->flags) ||
 954            test_bit(GP2AP020A00F_FLAG_ALS_IR_TRIGGER, &priv->flags) ||
 955            test_bit(GP2AP020A00F_FLAG_PROX_TRIGGER, &priv->flags))
 956                /* This fires off the trigger. */
 957                irq_work_queue(&priv->work);
 958
 959done:
 960        return IRQ_HANDLED;
 961}
 962
 963static irqreturn_t gp2ap020a00f_trigger_handler(int irq, void *data)
 964{
 965        struct iio_poll_func *pf = data;
 966        struct iio_dev *indio_dev = pf->indio_dev;
 967        struct gp2ap020a00f_data *priv = iio_priv(indio_dev);
 968        size_t d_size = 0;
 969        __le32 light_lux;
 970        int i, out_val, ret;
 971
 972        for_each_set_bit(i, indio_dev->active_scan_mask,
 973                indio_dev->masklength) {
 974                ret = regmap_bulk_read(priv->regmap,
 975                                GP2AP020A00F_DATA_REG(i),
 976                                &priv->buffer[d_size], 2);
 977                if (ret < 0)
 978                        goto done;
 979
 980                if (i == GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR ||
 981                    i == GP2AP020A00F_SCAN_MODE_LIGHT_IR) {
 982                        out_val = le16_to_cpup((__le16 *)&priv->buffer[d_size]);
 983                        gp2ap020a00f_output_to_lux(priv, &out_val);
 984                        light_lux = cpu_to_le32(out_val);
 985                        memcpy(&priv->buffer[d_size], (u8 *)&light_lux, 4);
 986                        d_size += 4;
 987                } else {
 988                        d_size += 2;
 989                }
 990        }
 991
 992        iio_push_to_buffers_with_timestamp(indio_dev, priv->buffer,
 993                pf->timestamp);
 994done:
 995        iio_trigger_notify_done(indio_dev->trig);
 996
 997        return IRQ_HANDLED;
 998}
 999
1000static u8 gp2ap020a00f_get_thresh_reg(const struct iio_chan_spec *chan,
1001                                             enum iio_event_direction event_dir)
1002{
1003        switch (chan->type) {
1004        case IIO_PROXIMITY:
1005                if (event_dir == IIO_EV_DIR_RISING)
1006                        return GP2AP020A00F_PH_L_REG;
1007                else
1008                        return GP2AP020A00F_PL_L_REG;
1009        case IIO_LIGHT:
1010                if (event_dir == IIO_EV_DIR_RISING)
1011                        return GP2AP020A00F_TH_L_REG;
1012                else
1013                        return GP2AP020A00F_TL_L_REG;
1014        default:
1015                break;
1016        }
1017
1018        return -EINVAL;
1019}
1020
1021static int gp2ap020a00f_write_event_val(struct iio_dev *indio_dev,
1022                                        const struct iio_chan_spec *chan,
1023                                        enum iio_event_type type,
1024                                        enum iio_event_direction dir,
1025                                        enum iio_event_info info,
1026                                        int val, int val2)
1027{
1028        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
1029        bool event_en = false;
1030        u8 thresh_val_id;
1031        u8 thresh_reg_l;
1032        int err = 0;
1033
1034        mutex_lock(&data->lock);
1035
1036        thresh_reg_l = gp2ap020a00f_get_thresh_reg(chan, dir);
1037        thresh_val_id = GP2AP020A00F_THRESH_VAL_ID(thresh_reg_l);
1038
1039        if (thresh_val_id > GP2AP020A00F_THRESH_PH) {
1040                err = -EINVAL;
1041                goto error_unlock;
1042        }
1043
1044        switch (thresh_reg_l) {
1045        case GP2AP020A00F_TH_L_REG:
1046                event_en = test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV,
1047                                                        &data->flags);
1048                break;
1049        case GP2AP020A00F_TL_L_REG:
1050                event_en = test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV,
1051                                                        &data->flags);
1052                break;
1053        case GP2AP020A00F_PH_L_REG:
1054                if (val == 0) {
1055                        err = -EINVAL;
1056                        goto error_unlock;
1057                }
1058                event_en = test_bit(GP2AP020A00F_FLAG_PROX_RISING_EV,
1059                                                        &data->flags);
1060                break;
1061        case GP2AP020A00F_PL_L_REG:
1062                if (val == 0) {
1063                        err = -EINVAL;
1064                        goto error_unlock;
1065                }
1066                event_en = test_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV,
1067                                                        &data->flags);
1068                break;
1069        }
1070
1071        data->thresh_val[thresh_val_id] = val;
1072        err =  gp2ap020a00f_write_event_threshold(data, thresh_val_id,
1073                                                        event_en);
1074error_unlock:
1075        mutex_unlock(&data->lock);
1076
1077        return err;
1078}
1079
1080static int gp2ap020a00f_read_event_val(struct iio_dev *indio_dev,
1081                                       const struct iio_chan_spec *chan,
1082                                       enum iio_event_type type,
1083                                       enum iio_event_direction dir,
1084                                       enum iio_event_info info,
1085                                       int *val, int *val2)
1086{
1087        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
1088        u8 thresh_reg_l;
1089        int err = IIO_VAL_INT;
1090
1091        mutex_lock(&data->lock);
1092
1093        thresh_reg_l = gp2ap020a00f_get_thresh_reg(chan, dir);
1094
1095        if (thresh_reg_l > GP2AP020A00F_PH_L_REG) {
1096                err = -EINVAL;
1097                goto error_unlock;
1098        }
1099
1100        *val = data->thresh_val[GP2AP020A00F_THRESH_VAL_ID(thresh_reg_l)];
1101
1102error_unlock:
1103        mutex_unlock(&data->lock);
1104
1105        return err;
1106}
1107
1108static int gp2ap020a00f_write_prox_event_config(struct iio_dev *indio_dev,
1109                                                int state)
1110{
1111        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
1112        enum gp2ap020a00f_cmd cmd_high_ev, cmd_low_ev;
1113        int err;
1114
1115        cmd_high_ev = state ? GP2AP020A00F_CMD_PROX_HIGH_EV_EN :
1116                              GP2AP020A00F_CMD_PROX_HIGH_EV_DIS;
1117        cmd_low_ev = state ? GP2AP020A00F_CMD_PROX_LOW_EV_EN :
1118                             GP2AP020A00F_CMD_PROX_LOW_EV_DIS;
1119
1120        /*
1121         * In order to enable proximity detection feature in the device
1122         * both high and low threshold registers have to be written
1123         * with different values, greater than zero.
1124         */
1125        if (state) {
1126                if (data->thresh_val[GP2AP020A00F_THRESH_PL] == 0)
1127                        return -EINVAL;
1128
1129                if (data->thresh_val[GP2AP020A00F_THRESH_PH] == 0)
1130                        return -EINVAL;
1131        }
1132
1133        err = gp2ap020a00f_exec_cmd(data, cmd_high_ev);
1134        if (err < 0)
1135                return err;
1136
1137        err = gp2ap020a00f_exec_cmd(data, cmd_low_ev);
1138        if (err < 0)
1139                return err;
1140
1141        free_irq(data->client->irq, indio_dev);
1142
1143        if (state)
1144                err = request_threaded_irq(data->client->irq, NULL,
1145                                           &gp2ap020a00f_prox_sensing_handler,
1146                                           IRQF_TRIGGER_RISING |
1147                                           IRQF_TRIGGER_FALLING |
1148                                           IRQF_ONESHOT,
1149                                           "gp2ap020a00f_prox_sensing",
1150                                           indio_dev);
1151        else {
1152                err = request_threaded_irq(data->client->irq, NULL,
1153                                           &gp2ap020a00f_thresh_event_handler,
1154                                           IRQF_TRIGGER_FALLING |
1155                                           IRQF_ONESHOT,
1156                                           "gp2ap020a00f_thresh_event",
1157                                           indio_dev);
1158        }
1159
1160        return err;
1161}
1162
1163static int gp2ap020a00f_write_event_config(struct iio_dev *indio_dev,
1164                                           const struct iio_chan_spec *chan,
1165                                           enum iio_event_type type,
1166                                           enum iio_event_direction dir,
1167                                           int state)
1168{
1169        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
1170        enum gp2ap020a00f_cmd cmd;
1171        int err;
1172
1173        mutex_lock(&data->lock);
1174
1175        switch (chan->type) {
1176        case IIO_PROXIMITY:
1177                err = gp2ap020a00f_write_prox_event_config(indio_dev, state);
1178                break;
1179        case IIO_LIGHT:
1180                if (dir == IIO_EV_DIR_RISING) {
1181                        cmd = state ? GP2AP020A00F_CMD_ALS_HIGH_EV_EN :
1182                                      GP2AP020A00F_CMD_ALS_HIGH_EV_DIS;
1183                        err = gp2ap020a00f_exec_cmd(data, cmd);
1184                } else {
1185                        cmd = state ? GP2AP020A00F_CMD_ALS_LOW_EV_EN :
1186                                      GP2AP020A00F_CMD_ALS_LOW_EV_DIS;
1187                        err = gp2ap020a00f_exec_cmd(data, cmd);
1188                }
1189                break;
1190        default:
1191                err = -EINVAL;
1192        }
1193
1194        mutex_unlock(&data->lock);
1195
1196        return err;
1197}
1198
1199static int gp2ap020a00f_read_event_config(struct iio_dev *indio_dev,
1200                                           const struct iio_chan_spec *chan,
1201                                           enum iio_event_type type,
1202                                           enum iio_event_direction dir)
1203{
1204        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
1205        int event_en = 0;
1206
1207        mutex_lock(&data->lock);
1208
1209        switch (chan->type) {
1210        case IIO_PROXIMITY:
1211                if (dir == IIO_EV_DIR_RISING)
1212                        event_en = test_bit(GP2AP020A00F_FLAG_PROX_RISING_EV,
1213                                                                &data->flags);
1214                else
1215                        event_en = test_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV,
1216                                                                &data->flags);
1217                break;
1218        case IIO_LIGHT:
1219                if (dir == IIO_EV_DIR_RISING)
1220                        event_en = test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV,
1221                                                                &data->flags);
1222                else
1223                        event_en = test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV,
1224                                                                &data->flags);
1225                break;
1226        default:
1227                event_en = -EINVAL;
1228                break;
1229        }
1230
1231        mutex_unlock(&data->lock);
1232
1233        return event_en;
1234}
1235
1236static int gp2ap020a00f_read_channel(struct gp2ap020a00f_data *data,
1237                                struct iio_chan_spec const *chan, int *val)
1238{
1239        enum gp2ap020a00f_cmd cmd;
1240        int err;
1241
1242        switch (chan->scan_index) {
1243        case GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR:
1244                cmd = GP2AP020A00F_CMD_READ_RAW_CLEAR;
1245                break;
1246        case GP2AP020A00F_SCAN_MODE_LIGHT_IR:
1247                cmd = GP2AP020A00F_CMD_READ_RAW_IR;
1248                break;
1249        case GP2AP020A00F_SCAN_MODE_PROXIMITY:
1250                cmd = GP2AP020A00F_CMD_READ_RAW_PROXIMITY;
1251                break;
1252        default:
1253                return -EINVAL;
1254        }
1255
1256        err = gp2ap020a00f_exec_cmd(data, cmd);
1257        if (err < 0) {
1258                dev_err(&data->client->dev,
1259                        "gp2ap020a00f_exec_cmd failed\n");
1260                goto error_ret;
1261        }
1262
1263        err = gp2ap020a00f_read_output(data, chan->address, val);
1264        if (err < 0)
1265                dev_err(&data->client->dev,
1266                        "gp2ap020a00f_read_output failed\n");
1267
1268        err = gp2ap020a00f_set_operation_mode(data,
1269                                        GP2AP020A00F_OPMODE_SHUTDOWN);
1270        if (err < 0)
1271                dev_err(&data->client->dev,
1272                        "Failed to shut down the device.\n");
1273
1274        if (cmd == GP2AP020A00F_CMD_READ_RAW_CLEAR ||
1275            cmd == GP2AP020A00F_CMD_READ_RAW_IR)
1276                gp2ap020a00f_output_to_lux(data, val);
1277
1278error_ret:
1279        return err;
1280}
1281
1282static int gp2ap020a00f_read_raw(struct iio_dev *indio_dev,
1283                           struct iio_chan_spec const *chan,
1284                           int *val, int *val2,
1285                           long mask)
1286{
1287        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
1288        int err = -EINVAL;
1289
1290        mutex_lock(&data->lock);
1291
1292        switch (mask) {
1293        case IIO_CHAN_INFO_RAW:
1294                if (iio_buffer_enabled(indio_dev)) {
1295                        err = -EBUSY;
1296                        goto error_unlock;
1297                }
1298
1299                err = gp2ap020a00f_read_channel(data, chan, val);
1300                break;
1301        }
1302
1303error_unlock:
1304        mutex_unlock(&data->lock);
1305
1306        return err < 0 ? err : IIO_VAL_INT;
1307}
1308
1309static const struct iio_event_spec gp2ap020a00f_event_spec_light[] = {
1310        {
1311                .type = IIO_EV_TYPE_THRESH,
1312                .dir = IIO_EV_DIR_RISING,
1313                .mask_separate = BIT(IIO_EV_INFO_VALUE) |
1314                        BIT(IIO_EV_INFO_ENABLE),
1315        }, {
1316                .type = IIO_EV_TYPE_THRESH,
1317                .dir = IIO_EV_DIR_FALLING,
1318                .mask_separate = BIT(IIO_EV_INFO_VALUE) |
1319                        BIT(IIO_EV_INFO_ENABLE),
1320        },
1321};
1322
1323static const struct iio_event_spec gp2ap020a00f_event_spec_prox[] = {
1324        {
1325                .type = IIO_EV_TYPE_ROC,
1326                .dir = IIO_EV_DIR_RISING,
1327                .mask_separate = BIT(IIO_EV_INFO_VALUE) |
1328                        BIT(IIO_EV_INFO_ENABLE),
1329        }, {
1330                .type = IIO_EV_TYPE_ROC,
1331                .dir = IIO_EV_DIR_FALLING,
1332                .mask_separate = BIT(IIO_EV_INFO_VALUE) |
1333                        BIT(IIO_EV_INFO_ENABLE),
1334        },
1335};
1336
1337static const struct iio_chan_spec gp2ap020a00f_channels[] = {
1338        {
1339                .type = IIO_LIGHT,
1340                .channel2 = IIO_MOD_LIGHT_CLEAR,
1341                .modified = 1,
1342                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1343                .scan_type = {
1344                        .sign = 'u',
1345                        .realbits = 24,
1346                        .shift = 0,
1347                        .storagebits = 32,
1348                        .endianness = IIO_LE,
1349                },
1350                .scan_index = GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR,
1351                .address = GP2AP020A00F_D0_L_REG,
1352                .event_spec = gp2ap020a00f_event_spec_light,
1353                .num_event_specs = ARRAY_SIZE(gp2ap020a00f_event_spec_light),
1354        },
1355        {
1356                .type = IIO_LIGHT,
1357                .channel2 = IIO_MOD_LIGHT_IR,
1358                .modified = 1,
1359                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1360                .scan_type = {
1361                        .sign = 'u',
1362                        .realbits = 24,
1363                        .shift = 0,
1364                        .storagebits = 32,
1365                        .endianness = IIO_LE,
1366                },
1367                .scan_index = GP2AP020A00F_SCAN_MODE_LIGHT_IR,
1368                .address = GP2AP020A00F_D1_L_REG,
1369        },
1370        {
1371                .type = IIO_PROXIMITY,
1372                .modified = 0,
1373                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1374                .scan_type = {
1375                        .sign = 'u',
1376                        .realbits = 16,
1377                        .shift = 0,
1378                        .storagebits = 16,
1379                        .endianness = IIO_LE,
1380                },
1381                .scan_index = GP2AP020A00F_SCAN_MODE_PROXIMITY,
1382                .address = GP2AP020A00F_D2_L_REG,
1383                .event_spec = gp2ap020a00f_event_spec_prox,
1384                .num_event_specs = ARRAY_SIZE(gp2ap020a00f_event_spec_prox),
1385        },
1386        IIO_CHAN_SOFT_TIMESTAMP(GP2AP020A00F_CHAN_TIMESTAMP),
1387};
1388
1389static const struct iio_info gp2ap020a00f_info = {
1390        .read_raw = &gp2ap020a00f_read_raw,
1391        .read_event_value = &gp2ap020a00f_read_event_val,
1392        .read_event_config = &gp2ap020a00f_read_event_config,
1393        .write_event_value = &gp2ap020a00f_write_event_val,
1394        .write_event_config = &gp2ap020a00f_write_event_config,
1395        .driver_module = THIS_MODULE,
1396};
1397
1398static int gp2ap020a00f_buffer_postenable(struct iio_dev *indio_dev)
1399{
1400        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
1401        int i, err = 0;
1402
1403        mutex_lock(&data->lock);
1404
1405        /*
1406         * Enable triggers according to the scan_mask. Enabling either
1407         * LIGHT_CLEAR or LIGHT_IR scan mode results in enabling ALS
1408         * module in the device, which generates samples in both D0 (clear)
1409         * and D1 (ir) registers. As the two registers are bound to the
1410         * two separate IIO channels they are treated in the driver logic
1411         * as if they were controlled independently.
1412         */
1413        for_each_set_bit(i, indio_dev->active_scan_mask,
1414                indio_dev->masklength) {
1415                switch (i) {
1416                case GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR:
1417                        err = gp2ap020a00f_exec_cmd(data,
1418                                        GP2AP020A00F_CMD_TRIGGER_CLEAR_EN);
1419                        break;
1420                case GP2AP020A00F_SCAN_MODE_LIGHT_IR:
1421                        err = gp2ap020a00f_exec_cmd(data,
1422                                        GP2AP020A00F_CMD_TRIGGER_IR_EN);
1423                        break;
1424                case GP2AP020A00F_SCAN_MODE_PROXIMITY:
1425                        err = gp2ap020a00f_exec_cmd(data,
1426                                        GP2AP020A00F_CMD_TRIGGER_PROX_EN);
1427                        break;
1428                }
1429        }
1430
1431        if (err < 0)
1432                goto error_unlock;
1433
1434        data->buffer = kmalloc(indio_dev->scan_bytes, GFP_KERNEL);
1435        if (!data->buffer) {
1436                err = -ENOMEM;
1437                goto error_unlock;
1438        }
1439
1440        err = iio_triggered_buffer_postenable(indio_dev);
1441
1442error_unlock:
1443        mutex_unlock(&data->lock);
1444
1445        return err;
1446}
1447
1448static int gp2ap020a00f_buffer_predisable(struct iio_dev *indio_dev)
1449{
1450        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
1451        int i, err;
1452
1453        mutex_lock(&data->lock);
1454
1455        err = iio_triggered_buffer_predisable(indio_dev);
1456        if (err < 0)
1457                goto error_unlock;
1458
1459        for_each_set_bit(i, indio_dev->active_scan_mask,
1460                indio_dev->masklength) {
1461                switch (i) {
1462                case GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR:
1463                        err = gp2ap020a00f_exec_cmd(data,
1464                                        GP2AP020A00F_CMD_TRIGGER_CLEAR_DIS);
1465                        break;
1466                case GP2AP020A00F_SCAN_MODE_LIGHT_IR:
1467                        err = gp2ap020a00f_exec_cmd(data,
1468                                        GP2AP020A00F_CMD_TRIGGER_IR_DIS);
1469                        break;
1470                case GP2AP020A00F_SCAN_MODE_PROXIMITY:
1471                        err = gp2ap020a00f_exec_cmd(data,
1472                                        GP2AP020A00F_CMD_TRIGGER_PROX_DIS);
1473                        break;
1474                }
1475        }
1476
1477        if (err == 0)
1478                kfree(data->buffer);
1479
1480error_unlock:
1481        mutex_unlock(&data->lock);
1482
1483        return err;
1484}
1485
1486static const struct iio_buffer_setup_ops gp2ap020a00f_buffer_setup_ops = {
1487        .postenable = &gp2ap020a00f_buffer_postenable,
1488        .predisable = &gp2ap020a00f_buffer_predisable,
1489};
1490
1491static const struct iio_trigger_ops gp2ap020a00f_trigger_ops = {
1492        .owner = THIS_MODULE,
1493};
1494
1495static int gp2ap020a00f_probe(struct i2c_client *client,
1496                                const struct i2c_device_id *id)
1497{
1498        struct gp2ap020a00f_data *data;
1499        struct iio_dev *indio_dev;
1500        struct regmap *regmap;
1501        int err;
1502
1503        indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1504        if (!indio_dev)
1505                return -ENOMEM;
1506
1507        data = iio_priv(indio_dev);
1508
1509        data->vled_reg = devm_regulator_get(&client->dev, "vled");
1510        if (IS_ERR(data->vled_reg))
1511                return PTR_ERR(data->vled_reg);
1512
1513        err = regulator_enable(data->vled_reg);
1514        if (err)
1515                return err;
1516
1517        regmap = devm_regmap_init_i2c(client, &gp2ap020a00f_regmap_config);
1518        if (IS_ERR(regmap)) {
1519                dev_err(&client->dev, "Regmap initialization failed.\n");
1520                err = PTR_ERR(regmap);
1521                goto error_regulator_disable;
1522        }
1523
1524        /* Initialize device registers */
1525        err = regmap_bulk_write(regmap, GP2AP020A00F_OP_REG,
1526                        gp2ap020a00f_reg_init_tab,
1527                        ARRAY_SIZE(gp2ap020a00f_reg_init_tab));
1528
1529        if (err < 0) {
1530                dev_err(&client->dev, "Device initialization failed.\n");
1531                goto error_regulator_disable;
1532        }
1533
1534        i2c_set_clientdata(client, indio_dev);
1535
1536        data->client = client;
1537        data->cur_opmode = GP2AP020A00F_OPMODE_SHUTDOWN;
1538        data->regmap = regmap;
1539        init_waitqueue_head(&data->data_ready_queue);
1540
1541        mutex_init(&data->lock);
1542        indio_dev->dev.parent = &client->dev;
1543        indio_dev->channels = gp2ap020a00f_channels;
1544        indio_dev->num_channels = ARRAY_SIZE(gp2ap020a00f_channels);
1545        indio_dev->info = &gp2ap020a00f_info;
1546        indio_dev->name = id->name;
1547        indio_dev->modes = INDIO_DIRECT_MODE;
1548
1549        /* Allocate buffer */
1550        err = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
1551                &gp2ap020a00f_trigger_handler, &gp2ap020a00f_buffer_setup_ops);
1552        if (err < 0)
1553                goto error_regulator_disable;
1554
1555        /* Allocate trigger */
1556        data->trig = devm_iio_trigger_alloc(&client->dev, "%s-trigger",
1557                                                        indio_dev->name);
1558        if (data->trig == NULL) {
1559                err = -ENOMEM;
1560                dev_err(&indio_dev->dev, "Failed to allocate iio trigger.\n");
1561                goto error_uninit_buffer;
1562        }
1563
1564        /* This needs to be requested here for read_raw calls to work. */
1565        err = request_threaded_irq(client->irq, NULL,
1566                                   &gp2ap020a00f_thresh_event_handler,
1567                                   IRQF_TRIGGER_FALLING |
1568                                   IRQF_ONESHOT,
1569                                   "gp2ap020a00f_als_event",
1570                                   indio_dev);
1571        if (err < 0) {
1572                dev_err(&client->dev, "Irq request failed.\n");
1573                goto error_uninit_buffer;
1574        }
1575
1576        data->trig->ops = &gp2ap020a00f_trigger_ops;
1577        data->trig->dev.parent = &data->client->dev;
1578
1579        init_irq_work(&data->work, gp2ap020a00f_iio_trigger_work);
1580
1581        err = iio_trigger_register(data->trig);
1582        if (err < 0) {
1583                dev_err(&client->dev, "Failed to register iio trigger.\n");
1584                goto error_free_irq;
1585        }
1586
1587        err = iio_device_register(indio_dev);
1588        if (err < 0)
1589                goto error_trigger_unregister;
1590
1591        return 0;
1592
1593error_trigger_unregister:
1594        iio_trigger_unregister(data->trig);
1595error_free_irq:
1596        free_irq(client->irq, indio_dev);
1597error_uninit_buffer:
1598        iio_triggered_buffer_cleanup(indio_dev);
1599error_regulator_disable:
1600        regulator_disable(data->vled_reg);
1601
1602        return err;
1603}
1604
1605static int gp2ap020a00f_remove(struct i2c_client *client)
1606{
1607        struct iio_dev *indio_dev = i2c_get_clientdata(client);
1608        struct gp2ap020a00f_data *data = iio_priv(indio_dev);
1609        int err;
1610
1611        err = gp2ap020a00f_set_operation_mode(data,
1612                                        GP2AP020A00F_OPMODE_SHUTDOWN);
1613        if (err < 0)
1614                dev_err(&indio_dev->dev, "Failed to power off the device.\n");
1615
1616        iio_device_unregister(indio_dev);
1617        iio_trigger_unregister(data->trig);
1618        free_irq(client->irq, indio_dev);
1619        iio_triggered_buffer_cleanup(indio_dev);
1620        regulator_disable(data->vled_reg);
1621
1622        return 0;
1623}
1624
1625static const struct i2c_device_id gp2ap020a00f_id[] = {
1626        { GP2A_I2C_NAME, 0 },
1627        { }
1628};
1629
1630MODULE_DEVICE_TABLE(i2c, gp2ap020a00f_id);
1631
1632#ifdef CONFIG_OF
1633static const struct of_device_id gp2ap020a00f_of_match[] = {
1634        { .compatible = "sharp,gp2ap020a00f" },
1635        { }
1636};
1637#endif
1638
1639static struct i2c_driver gp2ap020a00f_driver = {
1640        .driver = {
1641                .name   = GP2A_I2C_NAME,
1642                .of_match_table = of_match_ptr(gp2ap020a00f_of_match),
1643                .owner  = THIS_MODULE,
1644        },
1645        .probe          = gp2ap020a00f_probe,
1646        .remove         = gp2ap020a00f_remove,
1647        .id_table       = gp2ap020a00f_id,
1648};
1649
1650module_i2c_driver(gp2ap020a00f_driver);
1651
1652MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>");
1653MODULE_DESCRIPTION("Sharp GP2AP020A00F Proximity/ALS sensor driver");
1654MODULE_LICENSE("GPL v2");
1655
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.