text: /*
   * Copyright (C) 2013 Samsung Electronics Co., Ltd.
   * Author: Jacek Anaszewski <j.anaszewski@samsung.com>
   *
   * IIO features supported by the driver:
   *
   * Read-only raw channels:
   *   - illuminance_clear [lux]
   *   - illuminance_ir
   *   - proximity
   *
   * Triggered buffer:
   *   - illuminance_clear
   *   - illuminance_ir
   *   - proximity
   *
   * Events:
   *   - illuminance_clear (rising and falling)
   *   - proximity (rising and falling)
   *     - both falling and rising thresholds for the proximity events
   *       must be set to the values greater than 0.
   *
   * The driver supports triggered buffers for all the three
   * channels as well as high and low threshold events for the
   * illuminance_clear and proxmimity channels. Triggers
   * can be enabled simultaneously with both illuminance_clear
   * events. Proximity events cannot be enabled simultaneously
   * with any triggers or illuminance events. Enabling/disabling
   * one of the proximity events automatically enables/disables
   * the other one.
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License version 2, as
   * published by the Free Software Foundation.
   */
  
  #include <linux/debugfs.h>
  #include <linux/delay.h>
  #include <linux/i2c.h>
  #include <linux/interrupt.h>
  #include <linux/irq.h>
  #include <linux/irq_work.h>
  #include <linux/module.h>
  #include <linux/mutex.h>
  #include <linux/of.h>
  #include <linux/regmap.h>
  #include <linux/regulator/consumer.h>
  #include <linux/slab.h>
  #include <asm/unaligned.h>
  #include <linux/iio/buffer.h>
  #include <linux/iio/events.h>
  #include <linux/iio/iio.h>
  #include <linux/iio/sysfs.h>
  #include <linux/iio/trigger.h>
  #include <linux/iio/trigger_consumer.h>
  #include <linux/iio/triggered_buffer.h>
  
  #define GP2A_I2C_NAME "gp2ap020a00f"
  
  /* Registers */
  #define GP2AP020A00F_OP_REG	0x00 /* Basic operations */
  #define GP2AP020A00F_ALS_REG	0x01 /* ALS related settings */
  #define GP2AP020A00F_PS_REG	0x02 /* PS related settings */
  #define GP2AP020A00F_LED_REG	0x03 /* LED reg */
  #define GP2AP020A00F_TL_L_REG	0x04 /* ALS: Threshold low LSB */
  #define GP2AP020A00F_TL_H_REG	0x05 /* ALS: Threshold low MSB */
  #define GP2AP020A00F_TH_L_REG	0x06 /* ALS: Threshold high LSB */
  #define GP2AP020A00F_TH_H_REG	0x07 /* ALS: Threshold high MSB */
  #define GP2AP020A00F_PL_L_REG	0x08 /* PS: Threshold low LSB */
  #define GP2AP020A00F_PL_H_REG	0x09 /* PS: Threshold low MSB */
  #define GP2AP020A00F_PH_L_REG	0x0a /* PS: Threshold high LSB */
  #define GP2AP020A00F_PH_H_REG	0x0b /* PS: Threshold high MSB */
  #define GP2AP020A00F_D0_L_REG	0x0c /* ALS result: Clear/Illuminance LSB */
  #define GP2AP020A00F_D0_H_REG	0x0d /* ALS result: Clear/Illuminance MSB */
  #define GP2AP020A00F_D1_L_REG	0x0e /* ALS result: IR LSB */
  #define GP2AP020A00F_D1_H_REG	0x0f /* ALS result: IR LSB */
  #define GP2AP020A00F_D2_L_REG	0x10 /* PS result LSB */
  #define GP2AP020A00F_D2_H_REG	0x11 /* PS result MSB */
  #define GP2AP020A00F_NUM_REGS	0x12 /* Number of registers */
  
  /* OP_REG bits */
  #define GP2AP020A00F_OP3_MASK		0x80 /* Software shutdown */
  #define GP2AP020A00F_OP3_SHUTDOWN	0x00
  #define GP2AP020A00F_OP3_OPERATION	0x80
  #define GP2AP020A00F_OP2_MASK		0x40 /* Auto shutdown/Continuous mode */
  #define GP2AP020A00F_OP2_AUTO_SHUTDOWN	0x00
  #define GP2AP020A00F_OP2_CONT_OPERATION	0x40
  #define GP2AP020A00F_OP_MASK		0x30 /* Operating mode selection  */
  #define GP2AP020A00F_OP_ALS_AND_PS	0x00
  #define GP2AP020A00F_OP_ALS		0x10
  #define GP2AP020A00F_OP_PS		0x20
  #define GP2AP020A00F_OP_DEBUG		0x30
  #define GP2AP020A00F_PROX_MASK		0x08 /* PS: detection/non-detection */
  #define GP2AP020A00F_PROX_NON_DETECT	0x00
  #define GP2AP020A00F_PROX_DETECT	0x08
  #define GP2AP020A00F_FLAG_P		0x04 /* PS: interrupt result  */
  #define GP2AP020A00F_FLAG_A		0x02 /* ALS: interrupt result  */
  #define GP2AP020A00F_TYPE_MASK		0x01 /* Output data type selection */
  #define GP2AP020A00F_TYPE_MANUAL_CALC	0x00
  #define GP2AP020A00F_TYPE_AUTO_CALC	0x01
  
  /* ALS_REG bits */
  #define GP2AP020A00F_PRST_MASK		0xc0 /* Number of measurement cycles */
  #define GP2AP020A00F_PRST_ONCE		0x00
  #define GP2AP020A00F_PRST_4_CYCLES	0x40
  #define GP2AP020A00F_PRST_8_CYCLES	0x80
  #define GP2AP020A00F_PRST_16_CYCLES	0xc0
  #define GP2AP020A00F_RES_A_MASK		0x38 /* ALS: Resolution */
  #define GP2AP020A00F_RES_A_800ms	0x00
  #define GP2AP020A00F_RES_A_400ms	0x08
  #define GP2AP020A00F_RES_A_200ms	0x10
  #define GP2AP020A00F_RES_A_100ms	0x18
  #define GP2AP020A00F_RES_A_25ms		0x20
  #define GP2AP020A00F_RES_A_6_25ms	0x28
  #define GP2AP020A00F_RES_A_1_56ms	0x30
  #define GP2AP020A00F_RES_A_0_39ms	0x38
  #define GP2AP020A00F_RANGE_A_MASK	0x07 /* ALS: Max measurable range */
  #define GP2AP020A00F_RANGE_A_x1		0x00
  #define GP2AP020A00F_RANGE_A_x2		0x01
  #define GP2AP020A00F_RANGE_A_x4		0x02
  #define GP2AP020A00F_RANGE_A_x8		0x03
  #define GP2AP020A00F_RANGE_A_x16	0x04
  #define GP2AP020A00F_RANGE_A_x32	0x05
  #define GP2AP020A00F_RANGE_A_x64	0x06
  #define GP2AP020A00F_RANGE_A_x128	0x07
  
  /* PS_REG bits */
  #define GP2AP020A00F_ALC_MASK		0x80 /* Auto light cancel */
  #define GP2AP020A00F_ALC_ON		0x80
  #define GP2AP020A00F_ALC_OFF		0x00
  #define GP2AP020A00F_INTTYPE_MASK	0x40 /* Interrupt type setting */
  #define GP2AP020A00F_INTTYPE_LEVEL	0x00
  #define GP2AP020A00F_INTTYPE_PULSE	0x40
  #define GP2AP020A00F_RES_P_MASK		0x38 /* PS: Resolution */
  #define GP2AP020A00F_RES_P_800ms_x2	0x00
  #define GP2AP020A00F_RES_P_400ms_x2	0x08
  #define GP2AP020A00F_RES_P_200ms_x2	0x10
  #define GP2AP020A00F_RES_P_100ms_x2	0x18
  #define GP2AP020A00F_RES_P_25ms_x2	0x20
  #define GP2AP020A00F_RES_P_6_25ms_x2	0x28
  #define GP2AP020A00F_RES_P_1_56ms_x2	0x30
  #define GP2AP020A00F_RES_P_0_39ms_x2	0x38
  #define GP2AP020A00F_RANGE_P_MASK	0x07 /* PS: Max measurable range */
  #define GP2AP020A00F_RANGE_P_x1		0x00
  #define GP2AP020A00F_RANGE_P_x2		0x01
  #define GP2AP020A00F_RANGE_P_x4		0x02
  #define GP2AP020A00F_RANGE_P_x8		0x03
  #define GP2AP020A00F_RANGE_P_x16	0x04
  #define GP2AP020A00F_RANGE_P_x32	0x05
  #define GP2AP020A00F_RANGE_P_x64	0x06
  #define GP2AP020A00F_RANGE_P_x128	0x07
  
  /* LED reg bits */
  #define GP2AP020A00F_INTVAL_MASK	0xc0 /* Intermittent operating */
  #define GP2AP020A00F_INTVAL_0		0x00
  #define GP2AP020A00F_INTVAL_4		0x40
  #define GP2AP020A00F_INTVAL_8		0x80
  #define GP2AP020A00F_INTVAL_16		0xc0
  #define GP2AP020A00F_IS_MASK		0x30 /* ILED drive peak current */
  #define GP2AP020A00F_IS_13_8mA		0x00
  #define GP2AP020A00F_IS_27_5mA		0x10
  #define GP2AP020A00F_IS_55mA		0x20
  #define GP2AP020A00F_IS_110mA		0x30
  #define GP2AP020A00F_PIN_MASK		0x0c /* INT terminal setting */
  #define GP2AP020A00F_PIN_ALS_OR_PS	0x00
  #define GP2AP020A00F_PIN_ALS		0x04
  #define GP2AP020A00F_PIN_PS		0x08
  #define GP2AP020A00F_PIN_PS_DETECT	0x0c
  #define GP2AP020A00F_FREQ_MASK		0x02 /* LED modulation frequency */
  #define GP2AP020A00F_FREQ_327_5kHz	0x00
  #define GP2AP020A00F_FREQ_81_8kHz	0x02
  #define GP2AP020A00F_RST		0x01 /* Software reset */
  
  #define GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR	0
  #define GP2AP020A00F_SCAN_MODE_LIGHT_IR		1
  #define GP2AP020A00F_SCAN_MODE_PROXIMITY	2
  #define GP2AP020A00F_CHAN_TIMESTAMP		3
  
  #define GP2AP020A00F_DATA_READY_TIMEOUT		msecs_to_jiffies(1000)
  #define GP2AP020A00F_DATA_REG(chan)		(GP2AP020A00F_D0_L_REG + \
  							(chan) * 2)
  #define GP2AP020A00F_THRESH_REG(th_val_id)	(GP2AP020A00F_TL_L_REG + \
  							(th_val_id) * 2)
  #define GP2AP020A00F_THRESH_VAL_ID(reg_addr)	((reg_addr - 4) / 2)
  
  #define GP2AP020A00F_SUBTRACT_MODE	0
  #define GP2AP020A00F_ADD_MODE		1
  
  #define GP2AP020A00F_MAX_CHANNELS	3
  
  enum gp2ap020a00f_opmode {
  	GP2AP020A00F_OPMODE_READ_RAW_CLEAR,
  	GP2AP020A00F_OPMODE_READ_RAW_IR,
  	GP2AP020A00F_OPMODE_READ_RAW_PROXIMITY,
  	GP2AP020A00F_OPMODE_ALS,
  	GP2AP020A00F_OPMODE_PS,
  	GP2AP020A00F_OPMODE_ALS_AND_PS,
  	GP2AP020A00F_OPMODE_PROX_DETECT,
  	GP2AP020A00F_OPMODE_SHUTDOWN,
  	GP2AP020A00F_NUM_OPMODES,
  };
  
  enum gp2ap020a00f_cmd {
  	GP2AP020A00F_CMD_READ_RAW_CLEAR,
  	GP2AP020A00F_CMD_READ_RAW_IR,
  	GP2AP020A00F_CMD_READ_RAW_PROXIMITY,
  	GP2AP020A00F_CMD_TRIGGER_CLEAR_EN,
  	GP2AP020A00F_CMD_TRIGGER_CLEAR_DIS,
  	GP2AP020A00F_CMD_TRIGGER_IR_EN,
  	GP2AP020A00F_CMD_TRIGGER_IR_DIS,
  	GP2AP020A00F_CMD_TRIGGER_PROX_EN,
  	GP2AP020A00F_CMD_TRIGGER_PROX_DIS,
  	GP2AP020A00F_CMD_ALS_HIGH_EV_EN,
  	GP2AP020A00F_CMD_ALS_HIGH_EV_DIS,
  	GP2AP020A00F_CMD_ALS_LOW_EV_EN,
  	GP2AP020A00F_CMD_ALS_LOW_EV_DIS,
  	GP2AP020A00F_CMD_PROX_HIGH_EV_EN,
  	GP2AP020A00F_CMD_PROX_HIGH_EV_DIS,
  	GP2AP020A00F_CMD_PROX_LOW_EV_EN,
  	GP2AP020A00F_CMD_PROX_LOW_EV_DIS,
  };
  
  enum gp2ap020a00f_flags {
  	GP2AP020A00F_FLAG_ALS_CLEAR_TRIGGER,
  	GP2AP020A00F_FLAG_ALS_IR_TRIGGER,
  	GP2AP020A00F_FLAG_PROX_TRIGGER,
  	GP2AP020A00F_FLAG_PROX_RISING_EV,
  	GP2AP020A00F_FLAG_PROX_FALLING_EV,
  	GP2AP020A00F_FLAG_ALS_RISING_EV,
  	GP2AP020A00F_FLAG_ALS_FALLING_EV,
  	GP2AP020A00F_FLAG_LUX_MODE_HI,
  	GP2AP020A00F_FLAG_DATA_READY,
  };
  
  enum gp2ap020a00f_thresh_val_id {
  	GP2AP020A00F_THRESH_TL,
  	GP2AP020A00F_THRESH_TH,
  	GP2AP020A00F_THRESH_PL,
  	GP2AP020A00F_THRESH_PH,
  };
  
  struct gp2ap020a00f_data {
  	const struct gp2ap020a00f_platform_data *pdata;
  	struct i2c_client *client;
  	struct mutex lock;
  	char *buffer;
  	struct regulator *vled_reg;
  	unsigned long flags;
  	enum gp2ap020a00f_opmode cur_opmode;
  	struct iio_trigger *trig;
  	struct regmap *regmap;
  	unsigned int thresh_val[4];
  	u8 debug_reg_addr;
  	struct irq_work work;
  	wait_queue_head_t data_ready_queue;
  };
  
  static const u8 gp2ap020a00f_reg_init_tab[] = {
  	[GP2AP020A00F_OP_REG] = GP2AP020A00F_OP3_SHUTDOWN,
  	[GP2AP020A00F_ALS_REG] = GP2AP020A00F_RES_A_25ms |
  				 GP2AP020A00F_RANGE_A_x8,
  	[GP2AP020A00F_PS_REG] = GP2AP020A00F_ALC_ON |
  				GP2AP020A00F_RES_P_1_56ms_x2 |
  				GP2AP020A00F_RANGE_P_x4,
  	[GP2AP020A00F_LED_REG] = GP2AP020A00F_INTVAL_0 |
  				 GP2AP020A00F_IS_110mA |
  				 GP2AP020A00F_FREQ_327_5kHz,
  	[GP2AP020A00F_TL_L_REG] = 0,
  	[GP2AP020A00F_TL_H_REG] = 0,
  	[GP2AP020A00F_TH_L_REG] = 0,
  	[GP2AP020A00F_TH_H_REG] = 0,
  	[GP2AP020A00F_PL_L_REG] = 0,
  	[GP2AP020A00F_PL_H_REG] = 0,
  	[GP2AP020A00F_PH_L_REG] = 0,
  	[GP2AP020A00F_PH_H_REG] = 0,
  };
  
  static bool gp2ap020a00f_is_volatile_reg(struct device *dev, unsigned int reg)
  {
  	switch (reg) {
  	case GP2AP020A00F_OP_REG:
  	case GP2AP020A00F_D0_L_REG:
  	case GP2AP020A00F_D0_H_REG:
  	case GP2AP020A00F_D1_L_REG:
  	case GP2AP020A00F_D1_H_REG:
  	case GP2AP020A00F_D2_L_REG:
  	case GP2AP020A00F_D2_H_REG:
  		return true;
  	default:
  		return false;
  	}
  }
  
  static const struct regmap_config gp2ap020a00f_regmap_config = {
  	.reg_bits = 8,
  	.val_bits = 8,
  
  	.max_register = GP2AP020A00F_D2_H_REG,
  	.cache_type = REGCACHE_RBTREE,
  
  	.volatile_reg = gp2ap020a00f_is_volatile_reg,
  };
  
  static const struct gp2ap020a00f_mutable_config_regs {
  	u8 op_reg;
  	u8 als_reg;
  	u8 ps_reg;
  	u8 led_reg;
  } opmode_regs_settings[GP2AP020A00F_NUM_OPMODES] = {
  	[GP2AP020A00F_OPMODE_READ_RAW_CLEAR] = {
  		GP2AP020A00F_OP_ALS | GP2AP020A00F_OP2_CONT_OPERATION
  		| GP2AP020A00F_OP3_OPERATION
  		| GP2AP020A00F_TYPE_AUTO_CALC,
  		GP2AP020A00F_PRST_ONCE,
  		GP2AP020A00F_INTTYPE_LEVEL,
  		GP2AP020A00F_PIN_ALS
  	},
  	[GP2AP020A00F_OPMODE_READ_RAW_IR] = {
  		GP2AP020A00F_OP_ALS | GP2AP020A00F_OP2_CONT_OPERATION
  		| GP2AP020A00F_OP3_OPERATION
  		| GP2AP020A00F_TYPE_MANUAL_CALC,
  		GP2AP020A00F_PRST_ONCE,
  		GP2AP020A00F_INTTYPE_LEVEL,
  		GP2AP020A00F_PIN_ALS
  	},
  	[GP2AP020A00F_OPMODE_READ_RAW_PROXIMITY] = {
  		GP2AP020A00F_OP_PS | GP2AP020A00F_OP2_CONT_OPERATION
  		| GP2AP020A00F_OP3_OPERATION
  		| GP2AP020A00F_TYPE_MANUAL_CALC,
  		GP2AP020A00F_PRST_ONCE,
  		GP2AP020A00F_INTTYPE_LEVEL,
  		GP2AP020A00F_PIN_PS
  	},
  	[GP2AP020A00F_OPMODE_PROX_DETECT] = {
  		GP2AP020A00F_OP_PS | GP2AP020A00F_OP2_CONT_OPERATION
  		| GP2AP020A00F_OP3_OPERATION
  		| GP2AP020A00F_TYPE_MANUAL_CALC,
  		GP2AP020A00F_PRST_4_CYCLES,
  		GP2AP020A00F_INTTYPE_PULSE,
  		GP2AP020A00F_PIN_PS_DETECT
  	},
  	[GP2AP020A00F_OPMODE_ALS] = {
  		GP2AP020A00F_OP_ALS | GP2AP020A00F_OP2_CONT_OPERATION
  		| GP2AP020A00F_OP3_OPERATION
  		| GP2AP020A00F_TYPE_AUTO_CALC,
  		GP2AP020A00F_PRST_ONCE,
  		GP2AP020A00F_INTTYPE_LEVEL,
  		GP2AP020A00F_PIN_ALS
  	},
  	[GP2AP020A00F_OPMODE_PS] = {
  		GP2AP020A00F_OP_PS | GP2AP020A00F_OP2_CONT_OPERATION
  		| GP2AP020A00F_OP3_OPERATION
  		| GP2AP020A00F_TYPE_MANUAL_CALC,
  		GP2AP020A00F_PRST_4_CYCLES,
  		GP2AP020A00F_INTTYPE_LEVEL,
  		GP2AP020A00F_PIN_PS
  	},
  	[GP2AP020A00F_OPMODE_ALS_AND_PS] = {
  		GP2AP020A00F_OP_ALS_AND_PS
  		| GP2AP020A00F_OP2_CONT_OPERATION
  		| GP2AP020A00F_OP3_OPERATION
  		| GP2AP020A00F_TYPE_AUTO_CALC,
  		GP2AP020A00F_PRST_4_CYCLES,
  		GP2AP020A00F_INTTYPE_LEVEL,
  		GP2AP020A00F_PIN_ALS_OR_PS
  	},
  	[GP2AP020A00F_OPMODE_SHUTDOWN] = { GP2AP020A00F_OP3_SHUTDOWN, },
  };
  
  static int gp2ap020a00f_set_operation_mode(struct gp2ap020a00f_data *data,
  					enum gp2ap020a00f_opmode op)
  {
  	unsigned int op_reg_val;
  	int err;
  
  	if (op != GP2AP020A00F_OPMODE_SHUTDOWN) {
  		err = regmap_read(data->regmap, GP2AP020A00F_OP_REG,
  					&op_reg_val);
  		if (err < 0)
  			return err;
  		/*
  		 * Shutdown the device if the operation being executed entails
  		 * mode transition.
  		 */
  		if ((opmode_regs_settings[op].op_reg & GP2AP020A00F_OP_MASK) !=
  		    (op_reg_val & GP2AP020A00F_OP_MASK)) {
  			/* set shutdown mode */
  			err = regmap_update_bits(data->regmap,
  				GP2AP020A00F_OP_REG, GP2AP020A00F_OP3_MASK,
  				GP2AP020A00F_OP3_SHUTDOWN);
  			if (err < 0)
  				return err;
  		}
  
  		err = regmap_update_bits(data->regmap, GP2AP020A00F_ALS_REG,
  			GP2AP020A00F_PRST_MASK, opmode_regs_settings[op]
  								.als_reg);
  		if (err < 0)
  			return err;
  
  		err = regmap_update_bits(data->regmap, GP2AP020A00F_PS_REG,
  			GP2AP020A00F_INTTYPE_MASK, opmode_regs_settings[op]
  								.ps_reg);
  		if (err < 0)
  			return err;
  
  		err = regmap_update_bits(data->regmap, GP2AP020A00F_LED_REG,
  			GP2AP020A00F_PIN_MASK, opmode_regs_settings[op]
  								.led_reg);
  		if (err < 0)
  			return err;
  	}
  
  	/* Set OP_REG and apply operation mode (power on / off) */
  	err = regmap_update_bits(data->regmap,
  				 GP2AP020A00F_OP_REG,
  				 GP2AP020A00F_OP_MASK | GP2AP020A00F_OP2_MASK |
  				 GP2AP020A00F_OP3_MASK | GP2AP020A00F_TYPE_MASK,
  				 opmode_regs_settings[op].op_reg);
  	if (err < 0)
  		return err;
  
  	data->cur_opmode = op;
  
  	return 0;
  }
  
  static bool gp2ap020a00f_als_enabled(struct gp2ap020a00f_data *data)
  {
  	return test_bit(GP2AP020A00F_FLAG_ALS_CLEAR_TRIGGER, &data->flags) ||
  	       test_bit(GP2AP020A00F_FLAG_ALS_IR_TRIGGER, &data->flags) ||
  	       test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &data->flags) ||
  	       test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &data->flags);
  }
  
  static bool gp2ap020a00f_prox_detect_enabled(struct gp2ap020a00f_data *data)
  {
  	return test_bit(GP2AP020A00F_FLAG_PROX_RISING_EV, &data->flags) ||
  	       test_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV, &data->flags);
  }
  
  static int gp2ap020a00f_write_event_threshold(struct gp2ap020a00f_data *data,
  				enum gp2ap020a00f_thresh_val_id th_val_id,
  				bool enable)
  {
  	__le16 thresh_buf = 0;
  	unsigned int thresh_reg_val;
  
  	if (!enable)
  		thresh_reg_val = 0;
  	else if (test_bit(GP2AP020A00F_FLAG_LUX_MODE_HI, &data->flags) &&
  		 th_val_id != GP2AP020A00F_THRESH_PL &&
  		 th_val_id != GP2AP020A00F_THRESH_PH)
  		/*
  		 * For the high lux mode ALS threshold has to be scaled down
  		 * to allow for proper comparison with the output value.
  		 */
  		thresh_reg_val = data->thresh_val[th_val_id] / 16;
  	else
  		thresh_reg_val = data->thresh_val[th_val_id] > 16000 ?
  					16000 :
  					data->thresh_val[th_val_id];
  
  	thresh_buf = cpu_to_le16(thresh_reg_val);
  
  	return regmap_bulk_write(data->regmap,
  				 GP2AP020A00F_THRESH_REG(th_val_id),
  				 (u8 *)&thresh_buf, 2);
  }
  
  static int gp2ap020a00f_alter_opmode(struct gp2ap020a00f_data *data,
  			enum gp2ap020a00f_opmode diff_mode, int add_sub)
  {
  	enum gp2ap020a00f_opmode new_mode;
  
  	if (diff_mode != GP2AP020A00F_OPMODE_ALS &&
  	    diff_mode != GP2AP020A00F_OPMODE_PS)
  		return -EINVAL;
  
  	if (add_sub == GP2AP020A00F_ADD_MODE) {
  		if (data->cur_opmode == GP2AP020A00F_OPMODE_SHUTDOWN)
  			new_mode =  diff_mode;
  		else
  			new_mode = GP2AP020A00F_OPMODE_ALS_AND_PS;
  	} else {
  		if (data->cur_opmode == GP2AP020A00F_OPMODE_ALS_AND_PS)
  			new_mode = (diff_mode == GP2AP020A00F_OPMODE_ALS) ?
  					GP2AP020A00F_OPMODE_PS :
  					GP2AP020A00F_OPMODE_ALS;
  		else
  			new_mode = GP2AP020A00F_OPMODE_SHUTDOWN;
  	}
  
  	return gp2ap020a00f_set_operation_mode(data, new_mode);
  }
  
  static int gp2ap020a00f_exec_cmd(struct gp2ap020a00f_data *data,
  					enum gp2ap020a00f_cmd cmd)
  {
  	int err = 0;
  
  	switch (cmd) {
  	case GP2AP020A00F_CMD_READ_RAW_CLEAR:
  		if (data->cur_opmode != GP2AP020A00F_OPMODE_SHUTDOWN)
  			return -EBUSY;
  		err = gp2ap020a00f_set_operation_mode(data,
  					GP2AP020A00F_OPMODE_READ_RAW_CLEAR);
  		break;
  	case GP2AP020A00F_CMD_READ_RAW_IR:
  		if (data->cur_opmode != GP2AP020A00F_OPMODE_SHUTDOWN)
  			return -EBUSY;
  		err = gp2ap020a00f_set_operation_mode(data,
  					GP2AP020A00F_OPMODE_READ_RAW_IR);
  		break;
  	case GP2AP020A00F_CMD_READ_RAW_PROXIMITY:
  		if (data->cur_opmode != GP2AP020A00F_OPMODE_SHUTDOWN)
  			return -EBUSY;
  		err = gp2ap020a00f_set_operation_mode(data,
  					GP2AP020A00F_OPMODE_READ_RAW_PROXIMITY);
  		break;
  	case GP2AP020A00F_CMD_TRIGGER_CLEAR_EN:
  		if (data->cur_opmode == GP2AP020A00F_OPMODE_PROX_DETECT)
  			return -EBUSY;
  		if (!gp2ap020a00f_als_enabled(data))
  			err = gp2ap020a00f_alter_opmode(data,
  						GP2AP020A00F_OPMODE_ALS,
  						GP2AP020A00F_ADD_MODE);
  		set_bit(GP2AP020A00F_FLAG_ALS_CLEAR_TRIGGER, &data->flags);
  		break;
  	case GP2AP020A00F_CMD_TRIGGER_CLEAR_DIS:
  		clear_bit(GP2AP020A00F_FLAG_ALS_CLEAR_TRIGGER, &data->flags);
  		if (gp2ap020a00f_als_enabled(data))
  			break;
  		err = gp2ap020a00f_alter_opmode(data,
  						GP2AP020A00F_OPMODE_ALS,
  						GP2AP020A00F_SUBTRACT_MODE);
  		break;
  	case GP2AP020A00F_CMD_TRIGGER_IR_EN:
  		if (data->cur_opmode == GP2AP020A00F_OPMODE_PROX_DETECT)
  			return -EBUSY;
  		if (!gp2ap020a00f_als_enabled(data))
  			err = gp2ap020a00f_alter_opmode(data,
  						GP2AP020A00F_OPMODE_ALS,
  						GP2AP020A00F_ADD_MODE);
  		set_bit(GP2AP020A00F_FLAG_ALS_IR_TRIGGER, &data->flags);
  		break;
  	case GP2AP020A00F_CMD_TRIGGER_IR_DIS:
  		clear_bit(GP2AP020A00F_FLAG_ALS_IR_TRIGGER, &data->flags);
  		if (gp2ap020a00f_als_enabled(data))
  			break;
  		err = gp2ap020a00f_alter_opmode(data,
  						GP2AP020A00F_OPMODE_ALS,
  						GP2AP020A00F_SUBTRACT_MODE);
  		break;
  	case GP2AP020A00F_CMD_TRIGGER_PROX_EN:
  		if (data->cur_opmode == GP2AP020A00F_OPMODE_PROX_DETECT)
  			return -EBUSY;
  		err = gp2ap020a00f_alter_opmode(data,
  						GP2AP020A00F_OPMODE_PS,
  						GP2AP020A00F_ADD_MODE);
  		set_bit(GP2AP020A00F_FLAG_PROX_TRIGGER, &data->flags);
  		break;
  	case GP2AP020A00F_CMD_TRIGGER_PROX_DIS:
  		clear_bit(GP2AP020A00F_FLAG_PROX_TRIGGER, &data->flags);
  		err = gp2ap020a00f_alter_opmode(data,
  						GP2AP020A00F_OPMODE_PS,
  						GP2AP020A00F_SUBTRACT_MODE);
  		break;
  	case GP2AP020A00F_CMD_ALS_HIGH_EV_EN:
  		if (test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &data->flags))
  			return 0;
  		if (data->cur_opmode == GP2AP020A00F_OPMODE_PROX_DETECT)
  			return -EBUSY;
  		if (!gp2ap020a00f_als_enabled(data)) {
  			err = gp2ap020a00f_alter_opmode(data,
  						GP2AP020A00F_OPMODE_ALS,
  						GP2AP020A00F_ADD_MODE);
  			if (err < 0)
  				return err;
  		}
  		set_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &data->flags);
  		err =  gp2ap020a00f_write_event_threshold(data,
  					GP2AP020A00F_THRESH_TH, true);
  		break;
  	case GP2AP020A00F_CMD_ALS_HIGH_EV_DIS:
  		if (!test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &data->flags))
  			return 0;
  		clear_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &data->flags);
  		if (!gp2ap020a00f_als_enabled(data)) {
  			err = gp2ap020a00f_alter_opmode(data,
  						GP2AP020A00F_OPMODE_ALS,
  						GP2AP020A00F_SUBTRACT_MODE);
  			if (err < 0)
  				return err;
  		}
  		err =  gp2ap020a00f_write_event_threshold(data,
  					GP2AP020A00F_THRESH_TH, false);
  		break;
  	case GP2AP020A00F_CMD_ALS_LOW_EV_EN:
  		if (test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &data->flags))
  			return 0;
  		if (data->cur_opmode == GP2AP020A00F_OPMODE_PROX_DETECT)
  			return -EBUSY;
  		if (!gp2ap020a00f_als_enabled(data)) {
  			err = gp2ap020a00f_alter_opmode(data,
  						GP2AP020A00F_OPMODE_ALS,
  						GP2AP020A00F_ADD_MODE);
  			if (err < 0)
  				return err;
  		}
  		set_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &data->flags);
  		err =  gp2ap020a00f_write_event_threshold(data,
  					GP2AP020A00F_THRESH_TL, true);
  		break;
  	case GP2AP020A00F_CMD_ALS_LOW_EV_DIS:
  		if (!test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &data->flags))
  			return 0;
  		clear_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &data->flags);
  		if (!gp2ap020a00f_als_enabled(data)) {
  			err = gp2ap020a00f_alter_opmode(data,
  						GP2AP020A00F_OPMODE_ALS,
  						GP2AP020A00F_SUBTRACT_MODE);
  			if (err < 0)
  				return err;
  		}
  		err =  gp2ap020a00f_write_event_threshold(data,
  					GP2AP020A00F_THRESH_TL, false);
  		break;
  	case GP2AP020A00F_CMD_PROX_HIGH_EV_EN:
  		if (test_bit(GP2AP020A00F_FLAG_PROX_RISING_EV, &data->flags))
  			return 0;
  		if (gp2ap020a00f_als_enabled(data) ||
  		    data->cur_opmode == GP2AP020A00F_OPMODE_PS)
  			return -EBUSY;
  		if (!gp2ap020a00f_prox_detect_enabled(data)) {
  			err = gp2ap020a00f_set_operation_mode(data,
  					GP2AP020A00F_OPMODE_PROX_DETECT);
  			if (err < 0)
  				return err;
  		}
  		set_bit(GP2AP020A00F_FLAG_PROX_RISING_EV, &data->flags);
  		err =  gp2ap020a00f_write_event_threshold(data,
  					GP2AP020A00F_THRESH_PH, true);
  		break;
  	case GP2AP020A00F_CMD_PROX_HIGH_EV_DIS:
  		if (!test_bit(GP2AP020A00F_FLAG_PROX_RISING_EV, &data->flags))
  			return 0;
  		clear_bit(GP2AP020A00F_FLAG_PROX_RISING_EV, &data->flags);
  		err = gp2ap020a00f_set_operation_mode(data,
  					GP2AP020A00F_OPMODE_SHUTDOWN);
  		if (err < 0)
  			return err;
  		err =  gp2ap020a00f_write_event_threshold(data,
  					GP2AP020A00F_THRESH_PH, false);
  		break;
  	case GP2AP020A00F_CMD_PROX_LOW_EV_EN:
  		if (test_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV, &data->flags))
  			return 0;
  		if (gp2ap020a00f_als_enabled(data) ||
  		    data->cur_opmode == GP2AP020A00F_OPMODE_PS)
  			return -EBUSY;
  		if (!gp2ap020a00f_prox_detect_enabled(data)) {
  			err = gp2ap020a00f_set_operation_mode(data,
  					GP2AP020A00F_OPMODE_PROX_DETECT);
  			if (err < 0)
  				return err;
  		}
  		set_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV, &data->flags);
  		err =  gp2ap020a00f_write_event_threshold(data,
  					GP2AP020A00F_THRESH_PL, true);
  		break;
  	case GP2AP020A00F_CMD_PROX_LOW_EV_DIS:
  		if (!test_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV, &data->flags))
  			return 0;
  		clear_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV, &data->flags);
  		err = gp2ap020a00f_set_operation_mode(data,
  					GP2AP020A00F_OPMODE_SHUTDOWN);
  		if (err < 0)
  			return err;
  		err =  gp2ap020a00f_write_event_threshold(data,
  					GP2AP020A00F_THRESH_PL, false);
  		break;
  	}
  
  	return err;
  }
  
  static int wait_conversion_complete_irq(struct gp2ap020a00f_data *data)
  {
  	int ret;
  
  	ret = wait_event_timeout(data->data_ready_queue,
  				 test_bit(GP2AP020A00F_FLAG_DATA_READY,
  					  &data->flags),
  				 GP2AP020A00F_DATA_READY_TIMEOUT);
  	clear_bit(GP2AP020A00F_FLAG_DATA_READY, &data->flags);
  
  	return ret > 0 ? 0 : -ETIME;
  }
  
  static int gp2ap020a00f_read_output(struct gp2ap020a00f_data *data,
  					unsigned int output_reg, int *val)
  {
  	u8 reg_buf[2];
  	int err;
  
  	err = wait_conversion_complete_irq(data);
  	if (err < 0)
  		dev_dbg(&data->client->dev, "data ready timeout\n");
  
  	err = regmap_bulk_read(data->regmap, output_reg, reg_buf, 2);
  	if (err < 0)
  		return err;
  
  	*val = le16_to_cpup((__le16 *)reg_buf);
  
  	return err;
  }
  
  static bool gp2ap020a00f_adjust_lux_mode(struct gp2ap020a00f_data *data,
  				 int output_val)
  {
  	u8 new_range = 0xff;
  	int err;
  
  	if (!test_bit(GP2AP020A00F_FLAG_LUX_MODE_HI, &data->flags)) {
  		if (output_val > 16000) {
  			set_bit(GP2AP020A00F_FLAG_LUX_MODE_HI, &data->flags);
  			new_range = GP2AP020A00F_RANGE_A_x128;
  		}
  	} else {
  		if (output_val < 1000) {
  			clear_bit(GP2AP020A00F_FLAG_LUX_MODE_HI, &data->flags);
  			new_range = GP2AP020A00F_RANGE_A_x8;
  		}
  	}
  
  	if (new_range != 0xff) {
  		/* Clear als threshold registers to avoid spurious
  		 * events caused by lux mode transition.
  		 */
  		err =  gp2ap020a00f_write_event_threshold(data,
  					GP2AP020A00F_THRESH_TH, false);
  		if (err < 0) {
  			dev_err(&data->client->dev,
  				"Clearing als threshold register failed.\n");
  			return false;
  		}
  
  		err =  gp2ap020a00f_write_event_threshold(data,
  					GP2AP020A00F_THRESH_TL, false);
  		if (err < 0) {
  			dev_err(&data->client->dev,
  				"Clearing als threshold register failed.\n");
  			return false;
  		}
  
  		/* Change lux mode */
  		err = regmap_update_bits(data->regmap,
  			GP2AP020A00F_OP_REG,
  			GP2AP020A00F_OP3_MASK,
  			GP2AP020A00F_OP3_SHUTDOWN);
  
  		if (err < 0) {
  			dev_err(&data->client->dev,
  				"Shutting down the device failed.\n");
  			return false;
  		}
  
  		err = regmap_update_bits(data->regmap,
  			GP2AP020A00F_ALS_REG,
  			GP2AP020A00F_RANGE_A_MASK,
  			new_range);
  
  		if (err < 0) {
  			dev_err(&data->client->dev,
  				"Adjusting device lux mode failed.\n");
  			return false;
  		}
  
  		err = regmap_update_bits(data->regmap,
  			GP2AP020A00F_OP_REG,
  			GP2AP020A00F_OP3_MASK,
  			GP2AP020A00F_OP3_OPERATION);
  
  		if (err < 0) {
  			dev_err(&data->client->dev,
  				"Powering up the device failed.\n");
  			return false;
  		}
  
  		/* Adjust als threshold register values to the new lux mode */
  		if (test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &data->flags)) {
  			err =  gp2ap020a00f_write_event_threshold(data,
  					GP2AP020A00F_THRESH_TH, true);
  			if (err < 0) {
  				dev_err(&data->client->dev,
  				"Adjusting als threshold value failed.\n");
  				return false;
  			}
  		}
  
  		if (test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &data->flags)) {
  			err =  gp2ap020a00f_write_event_threshold(data,
  					GP2AP020A00F_THRESH_TL, true);
  			if (err < 0) {
  				dev_err(&data->client->dev,
  				"Adjusting als threshold value failed.\n");
  				return false;
  			}
  		}
  
  		return true;
  	}
  
  	return false;
  }
  
  static void gp2ap020a00f_output_to_lux(struct gp2ap020a00f_data *data,
  						int *output_val)
  {
  	if (test_bit(GP2AP020A00F_FLAG_LUX_MODE_HI, &data->flags))
  		*output_val *= 16;
  }
  
  static void gp2ap020a00f_iio_trigger_work(struct irq_work *work)
  {
  	struct gp2ap020a00f_data *data =
  		container_of(work, struct gp2ap020a00f_data, work);
  
  	iio_trigger_poll(data->trig);
  }
  
  static irqreturn_t gp2ap020a00f_prox_sensing_handler(int irq, void *data)
  {
  	struct iio_dev *indio_dev = data;
  	struct gp2ap020a00f_data *priv = iio_priv(indio_dev);
  	unsigned int op_reg_val;
  	int ret;
  
  	/* Read interrupt flags */
  	ret = regmap_read(priv->regmap, GP2AP020A00F_OP_REG, &op_reg_val);
  	if (ret < 0)
  		return IRQ_HANDLED;
  
  	if (gp2ap020a00f_prox_detect_enabled(priv)) {
  		if (op_reg_val & GP2AP020A00F_PROX_DETECT) {
  			iio_push_event(indio_dev,
  			       IIO_UNMOD_EVENT_CODE(
  				    IIO_PROXIMITY,
  				    GP2AP020A00F_SCAN_MODE_PROXIMITY,
  				    IIO_EV_TYPE_ROC,
  				    IIO_EV_DIR_RISING),
  			       iio_get_time_ns(indio_dev));
  		} else {
  			iio_push_event(indio_dev,
  			       IIO_UNMOD_EVENT_CODE(
  				    IIO_PROXIMITY,
  				    GP2AP020A00F_SCAN_MODE_PROXIMITY,
  				    IIO_EV_TYPE_ROC,
  				    IIO_EV_DIR_FALLING),
  			       iio_get_time_ns(indio_dev));
  		}
  	}
  
  	return IRQ_HANDLED;
  }
  
  static irqreturn_t gp2ap020a00f_thresh_event_handler(int irq, void *data)
  {
  	struct iio_dev *indio_dev = data;
  	struct gp2ap020a00f_data *priv = iio_priv(indio_dev);
  	u8 op_reg_flags, d0_reg_buf[2];
  	unsigned int output_val, op_reg_val;
  	int thresh_val_id, ret;
  
  	/* Read interrupt flags */
  	ret = regmap_read(priv->regmap, GP2AP020A00F_OP_REG,
  							&op_reg_val);
  	if (ret < 0)
  		goto done;
  
  	op_reg_flags = op_reg_val & (GP2AP020A00F_FLAG_A | GP2AP020A00F_FLAG_P
  					| GP2AP020A00F_PROX_DETECT);
  
  	op_reg_val &= (~GP2AP020A00F_FLAG_A & ~GP2AP020A00F_FLAG_P
  					& ~GP2AP020A00F_PROX_DETECT);
  
  	/* Clear interrupt flags (if not in INTTYPE_PULSE mode) */
  	if (priv->cur_opmode != GP2AP020A00F_OPMODE_PROX_DETECT) {
  		ret = regmap_write(priv->regmap, GP2AP020A00F_OP_REG,
  								op_reg_val);
  		if (ret < 0)
  			goto done;
  	}
  
  	if (op_reg_flags & GP2AP020A00F_FLAG_A) {
  		/* Check D0 register to assess if the lux mode
  		 * transition is required.
  		 */
  		ret = regmap_bulk_read(priv->regmap, GP2AP020A00F_D0_L_REG,
  							d0_reg_buf, 2);
  		if (ret < 0)
  			goto done;
  
  		output_val = le16_to_cpup((__le16 *)d0_reg_buf);
  
  		if (gp2ap020a00f_adjust_lux_mode(priv, output_val))
  			goto done;
  
  		gp2ap020a00f_output_to_lux(priv, &output_val);
  
  		/*
  		 * We need to check output value to distinguish
  		 * between high and low ambient light threshold event.
  		 */
  		if (test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV, &priv->flags)) {
  			thresh_val_id =
  			    GP2AP020A00F_THRESH_VAL_ID(GP2AP020A00F_TH_L_REG);
  			if (output_val > priv->thresh_val[thresh_val_id])
  				iio_push_event(indio_dev,
  				       IIO_MOD_EVENT_CODE(
  					    IIO_LIGHT,
  					    GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR,
  					    IIO_MOD_LIGHT_CLEAR,
  					    IIO_EV_TYPE_THRESH,
  					    IIO_EV_DIR_RISING),
  				       iio_get_time_ns(indio_dev));
  		}
  
  		if (test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV, &priv->flags)) {
  			thresh_val_id =
  			    GP2AP020A00F_THRESH_VAL_ID(GP2AP020A00F_TL_L_REG);
  			if (output_val < priv->thresh_val[thresh_val_id])
  				iio_push_event(indio_dev,
  				       IIO_MOD_EVENT_CODE(
  					    IIO_LIGHT,
  					    GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR,
  					    IIO_MOD_LIGHT_CLEAR,
  					    IIO_EV_TYPE_THRESH,
  					    IIO_EV_DIR_FALLING),
  				       iio_get_time_ns(indio_dev));
  		}
  	}
  
  	if (priv->cur_opmode == GP2AP020A00F_OPMODE_READ_RAW_CLEAR ||
  	    priv->cur_opmode == GP2AP020A00F_OPMODE_READ_RAW_IR ||
  	    priv->cur_opmode == GP2AP020A00F_OPMODE_READ_RAW_PROXIMITY) {
  		set_bit(GP2AP020A00F_FLAG_DATA_READY, &priv->flags);
  		wake_up(&priv->data_ready_queue);
  		goto done;
  	}
  
  	if (test_bit(GP2AP020A00F_FLAG_ALS_CLEAR_TRIGGER, &priv->flags) ||
  	    test_bit(GP2AP020A00F_FLAG_ALS_IR_TRIGGER, &priv->flags) ||
  	    test_bit(GP2AP020A00F_FLAG_PROX_TRIGGER, &priv->flags))
  		/* This fires off the trigger. */
  		irq_work_queue(&priv->work);
  
  done:
  	return IRQ_HANDLED;
  }
  
  static irqreturn_t gp2ap020a00f_trigger_handler(int irq, void *data)
  {
  	struct iio_poll_func *pf = data;
  	struct iio_dev *indio_dev = pf->indio_dev;
  	struct gp2ap020a00f_data *priv = iio_priv(indio_dev);
  	size_t d_size = 0;
  	int i, out_val, ret;
  
  	for_each_set_bit(i, indio_dev->active_scan_mask,
  		indio_dev->masklength) {
  		ret = regmap_bulk_read(priv->regmap,
  				GP2AP020A00F_DATA_REG(i),
  				&priv->buffer[d_size], 2);
  		if (ret < 0)
  			goto done;
  
  		if (i == GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR ||
  		    i == GP2AP020A00F_SCAN_MODE_LIGHT_IR) {
  			out_val = le16_to_cpup((__le16 *)&priv->buffer[d_size]);
  			gp2ap020a00f_output_to_lux(priv, &out_val);
  
  			put_unaligned_le32(out_val, &priv->buffer[d_size]);
  			d_size += 4;
  		} else {
  			d_size += 2;
  		}
  	}
  
  	iio_push_to_buffers_with_timestamp(indio_dev, priv->buffer,
  		pf->timestamp);
  done:
  	iio_trigger_notify_done(indio_dev->trig);
  
  	return IRQ_HANDLED;
  }
  
  static u8 gp2ap020a00f_get_thresh_reg(const struct iio_chan_spec *chan,
  					     enum iio_event_direction event_dir)
  {
  	switch (chan->type) {
  	case IIO_PROXIMITY:
  		if (event_dir == IIO_EV_DIR_RISING)
  			return GP2AP020A00F_PH_L_REG;
  		else
  			return GP2AP020A00F_PL_L_REG;
  	case IIO_LIGHT:
  		if (event_dir == IIO_EV_DIR_RISING)
  			return GP2AP020A00F_TH_L_REG;
  		else
  			return GP2AP020A00F_TL_L_REG;
  	default:
  		break;
  	}
  
  	return -EINVAL;
  }
  
  static int gp2ap020a00f_write_event_val(struct iio_dev *indio_dev,
  					const struct iio_chan_spec *chan,
  					enum iio_event_type type,
  					enum iio_event_direction dir,
  					enum iio_event_info info,
  					int val, int val2)
  {
  	struct gp2ap020a00f_data *data = iio_priv(indio_dev);
  	bool event_en = false;
  	u8 thresh_val_id;
  	u8 thresh_reg_l;
  	int err = 0;
  
  	mutex_lock(&data->lock);
  
  	thresh_reg_l = gp2ap020a00f_get_thresh_reg(chan, dir);
  	thresh_val_id = GP2AP020A00F_THRESH_VAL_ID(thresh_reg_l);
  
  	if (thresh_val_id > GP2AP020A00F_THRESH_PH) {
  		err = -EINVAL;
  		goto error_unlock;
  	}
  
  	switch (thresh_reg_l) {
  	case GP2AP020A00F_TH_L_REG:
  		event_en = test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV,
  							&data->flags);
  		break;
  	case GP2AP020A00F_TL_L_REG:
  		event_en = test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV,
  							&data->flags);
  		break;
  	case GP2AP020A00F_PH_L_REG:
  		if (val == 0) {
  			err = -EINVAL;
  			goto error_unlock;
  		}
  		event_en = test_bit(GP2AP020A00F_FLAG_PROX_RISING_EV,
  							&data->flags);
  		break;
  	case GP2AP020A00F_PL_L_REG:
  		if (val == 0) {
  			err = -EINVAL;
  			goto error_unlock;
  		}
  		event_en = test_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV,
  							&data->flags);
  		break;
  	}
  
  	data->thresh_val[thresh_val_id] = val;
  	err =  gp2ap020a00f_write_event_threshold(data, thresh_val_id,
  							event_en);
  error_unlock:
  	mutex_unlock(&data->lock);
  
  	return err;
  }
  
  static int gp2ap020a00f_read_event_val(struct iio_dev *indio_dev,
  				       const struct iio_chan_spec *chan,
  				       enum iio_event_type type,
  				       enum iio_event_direction dir,
  				       enum iio_event_info info,
  				       int *val, int *val2)
  {
  	struct gp2ap020a00f_data *data = iio_priv(indio_dev);
  	u8 thresh_reg_l;
  	int err = IIO_VAL_INT;
  
  	mutex_lock(&data->lock);
  
  	thresh_reg_l = gp2ap020a00f_get_thresh_reg(chan, dir);
  
  	if (thresh_reg_l > GP2AP020A00F_PH_L_REG) {
  		err = -EINVAL;
  		goto error_unlock;
  	}
  
  	*val = data->thresh_val[GP2AP020A00F_THRESH_VAL_ID(thresh_reg_l)];
  
  error_unlock:
  	mutex_unlock(&data->lock);
  
  	return err;
  }
  
  static int gp2ap020a00f_write_prox_event_config(struct iio_dev *indio_dev,
  						int state)
  {
  	struct gp2ap020a00f_data *data = iio_priv(indio_dev);
  	enum gp2ap020a00f_cmd cmd_high_ev, cmd_low_ev;
  	int err;
  
  	cmd_high_ev = state ? GP2AP020A00F_CMD_PROX_HIGH_EV_EN :
  			      GP2AP020A00F_CMD_PROX_HIGH_EV_DIS;
  	cmd_low_ev = state ? GP2AP020A00F_CMD_PROX_LOW_EV_EN :
  			     GP2AP020A00F_CMD_PROX_LOW_EV_DIS;
  
  	/*
  	 * In order to enable proximity detection feature in the device
  	 * both high and low threshold registers have to be written
  	 * with different values, greater than zero.
  	 */
  	if (state) {
  		if (data->thresh_val[GP2AP020A00F_THRESH_PL] == 0)
  			return -EINVAL;
  
  		if (data->thresh_val[GP2AP020A00F_THRESH_PH] == 0)
  			return -EINVAL;
  	}
  
  	err = gp2ap020a00f_exec_cmd(data, cmd_high_ev);
  	if (err < 0)
  		return err;
  
  	err = gp2ap020a00f_exec_cmd(data, cmd_low_ev);
  	if (err < 0)
  		return err;
  
  	free_irq(data->client->irq, indio_dev);
  
  	if (state)
  		err = request_threaded_irq(data->client->irq, NULL,
  					   &gp2ap020a00f_prox_sensing_handler,
  					   IRQF_TRIGGER_RISING |
  					   IRQF_TRIGGER_FALLING |
  					   IRQF_ONESHOT,
  					   "gp2ap020a00f_prox_sensing",
  					   indio_dev);
  	else {
  		err = request_threaded_irq(data->client->irq, NULL,
  					   &gp2ap020a00f_thresh_event_handler,
  					   IRQF_TRIGGER_FALLING |
  					   IRQF_ONESHOT,
  					   "gp2ap020a00f_thresh_event",
  					   indio_dev);
  	}
  
  	return err;
  }
  
  static int gp2ap020a00f_write_event_config(struct iio_dev *indio_dev,
  					   const struct iio_chan_spec *chan,
  					   enum iio_event_type type,
  					   enum iio_event_direction dir,
  					   int state)
  {
  	struct gp2ap020a00f_data *data = iio_priv(indio_dev);
  	enum gp2ap020a00f_cmd cmd;
  	int err;
  
  	mutex_lock(&data->lock);
  
  	switch (chan->type) {
  	case IIO_PROXIMITY:
  		err = gp2ap020a00f_write_prox_event_config(indio_dev, state);
  		break;
  	case IIO_LIGHT:
  		if (dir == IIO_EV_DIR_RISING) {
  			cmd = state ? GP2AP020A00F_CMD_ALS_HIGH_EV_EN :
  				      GP2AP020A00F_CMD_ALS_HIGH_EV_DIS;
  			err = gp2ap020a00f_exec_cmd(data, cmd);
  		} else {
  			cmd = state ? GP2AP020A00F_CMD_ALS_LOW_EV_EN :
  				      GP2AP020A00F_CMD_ALS_LOW_EV_DIS;
  			err = gp2ap020a00f_exec_cmd(data, cmd);
  		}
  		break;
  	default:
  		err = -EINVAL;
  	}
  
  	mutex_unlock(&data->lock);
  
  	return err;
  }
  
  static int gp2ap020a00f_read_event_config(struct iio_dev *indio_dev,
  					   const struct iio_chan_spec *chan,
  					   enum iio_event_type type,
  					   enum iio_event_direction dir)
  {
  	struct gp2ap020a00f_data *data = iio_priv(indio_dev);
  	int event_en = 0;
  
  	mutex_lock(&data->lock);
  
  	switch (chan->type) {
  	case IIO_PROXIMITY:
  		if (dir == IIO_EV_DIR_RISING)
  			event_en = test_bit(GP2AP020A00F_FLAG_PROX_RISING_EV,
  								&data->flags);
  		else
  			event_en = test_bit(GP2AP020A00F_FLAG_PROX_FALLING_EV,
  								&data->flags);
  		break;
  	case IIO_LIGHT:
  		if (dir == IIO_EV_DIR_RISING)
  			event_en = test_bit(GP2AP020A00F_FLAG_ALS_RISING_EV,
  								&data->flags);
  		else
  			event_en = test_bit(GP2AP020A00F_FLAG_ALS_FALLING_EV,
  								&data->flags);
  		break;
  	default:
  		event_en = -EINVAL;
  		break;
  	}
  
  	mutex_unlock(&data->lock);
  
  	return event_en;
  }
  
  static int gp2ap020a00f_read_channel(struct gp2ap020a00f_data *data,
  				struct iio_chan_spec const *chan, int *val)
  {
  	enum gp2ap020a00f_cmd cmd;
  	int err;
  
  	switch (chan->scan_index) {
  	case GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR:
  		cmd = GP2AP020A00F_CMD_READ_RAW_CLEAR;
  		break;
  	case GP2AP020A00F_SCAN_MODE_LIGHT_IR:
  		cmd = GP2AP020A00F_CMD_READ_RAW_IR;
  		break;
  	case GP2AP020A00F_SCAN_MODE_PROXIMITY:
  		cmd = GP2AP020A00F_CMD_READ_RAW_PROXIMITY;
  		break;
  	default:
  		return -EINVAL;
  	}
  
  	err = gp2ap020a00f_exec_cmd(data, cmd);
  	if (err < 0) {
  		dev_err(&data->client->dev,
  			"gp2ap020a00f_exec_cmd failed\n");
  		goto error_ret;
  	}
  
  	err = gp2ap020a00f_read_output(data, chan->address, val);
  	if (err < 0)
  		dev_err(&data->client->dev,
  			"gp2ap020a00f_read_output failed\n");
  
  	err = gp2ap020a00f_set_operation_mode(data,
  					GP2AP020A00F_OPMODE_SHUTDOWN);
  	if (err < 0)
  		dev_err(&data->client->dev,
  			"Failed to shut down the device.\n");
  
  	if (cmd == GP2AP020A00F_CMD_READ_RAW_CLEAR ||
  	    cmd == GP2AP020A00F_CMD_READ_RAW_IR)
  		gp2ap020a00f_output_to_lux(data, val);
  
  error_ret:
  	return err;
  }
  
  static int gp2ap020a00f_read_raw(struct iio_dev *indio_dev,
  			   struct iio_chan_spec const *chan,
  			   int *val, int *val2,
  			   long mask)
  {
  	struct gp2ap020a00f_data *data = iio_priv(indio_dev);
  	int err = -EINVAL;
  
  	if (mask == IIO_CHAN_INFO_RAW) {
  		err = iio_device_claim_direct_mode(indio_dev);
  		if (err)
  			return err;
  
  		err = gp2ap020a00f_read_channel(data, chan, val);
  		iio_device_release_direct_mode(indio_dev);
  	}
  	return err < 0 ? err : IIO_VAL_INT;
  }
  
  static const struct iio_event_spec gp2ap020a00f_event_spec_light[] = {
  	{
  		.type = IIO_EV_TYPE_THRESH,
  		.dir = IIO_EV_DIR_RISING,
  		.mask_separate = BIT(IIO_EV_INFO_VALUE) |
  			BIT(IIO_EV_INFO_ENABLE),
  	}, {
  		.type = IIO_EV_TYPE_THRESH,
  		.dir = IIO_EV_DIR_FALLING,
  		.mask_separate = BIT(IIO_EV_INFO_VALUE) |
  			BIT(IIO_EV_INFO_ENABLE),
  	},
  };
  
  static const struct iio_event_spec gp2ap020a00f_event_spec_prox[] = {
  	{
  		.type = IIO_EV_TYPE_ROC,
  		.dir = IIO_EV_DIR_RISING,
  		.mask_separate = BIT(IIO_EV_INFO_VALUE) |
  			BIT(IIO_EV_INFO_ENABLE),
  	}, {
  		.type = IIO_EV_TYPE_ROC,
  		.dir = IIO_EV_DIR_FALLING,
  		.mask_separate = BIT(IIO_EV_INFO_VALUE) |
  			BIT(IIO_EV_INFO_ENABLE),
  	},
  };
  
  static const struct iio_chan_spec gp2ap020a00f_channels[] = {
  	{
  		.type = IIO_LIGHT,
  		.channel2 = IIO_MOD_LIGHT_CLEAR,
  		.modified = 1,
  		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  		.scan_type = {
  			.sign = 'u',
  			.realbits = 24,
  			.shift = 0,
  			.storagebits = 32,
  			.endianness = IIO_LE,
  		},
  		.scan_index = GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR,
  		.address = GP2AP020A00F_D0_L_REG,
  		.event_spec = gp2ap020a00f_event_spec_light,
  		.num_event_specs = ARRAY_SIZE(gp2ap020a00f_event_spec_light),
  	},
  	{
  		.type = IIO_LIGHT,
  		.channel2 = IIO_MOD_LIGHT_IR,
  		.modified = 1,
  		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  		.scan_type = {
  			.sign = 'u',
  			.realbits = 24,
  			.shift = 0,
  			.storagebits = 32,
  			.endianness = IIO_LE,
  		},
  		.scan_index = GP2AP020A00F_SCAN_MODE_LIGHT_IR,
  		.address = GP2AP020A00F_D1_L_REG,
  	},
  	{
  		.type = IIO_PROXIMITY,
  		.modified = 0,
  		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  		.scan_type = {
  			.sign = 'u',
  			.realbits = 16,
  			.shift = 0,
  			.storagebits = 16,
  			.endianness = IIO_LE,
  		},
  		.scan_index = GP2AP020A00F_SCAN_MODE_PROXIMITY,
  		.address = GP2AP020A00F_D2_L_REG,
  		.event_spec = gp2ap020a00f_event_spec_prox,
  		.num_event_specs = ARRAY_SIZE(gp2ap020a00f_event_spec_prox),
  	},
  	IIO_CHAN_SOFT_TIMESTAMP(GP2AP020A00F_CHAN_TIMESTAMP),
  };
  
  static const struct iio_info gp2ap020a00f_info = {
  	.read_raw = &gp2ap020a00f_read_raw,
  	.read_event_value = &gp2ap020a00f_read_event_val,
  	.read_event_config = &gp2ap020a00f_read_event_config,
  	.write_event_value = &gp2ap020a00f_write_event_val,
  	.write_event_config = &gp2ap020a00f_write_event_config,
  };
  
  static int gp2ap020a00f_buffer_postenable(struct iio_dev *indio_dev)
  {
  	struct gp2ap020a00f_data *data = iio_priv(indio_dev);
  	int i, err = 0;
  
  	mutex_lock(&data->lock);
  
  	/*
  	 * Enable triggers according to the scan_mask. Enabling either
  	 * LIGHT_CLEAR or LIGHT_IR scan mode results in enabling ALS
  	 * module in the device, which generates samples in both D0 (clear)
  	 * and D1 (ir) registers. As the two registers are bound to the
  	 * two separate IIO channels they are treated in the driver logic
  	 * as if they were controlled independently.
  	 */
  	for_each_set_bit(i, indio_dev->active_scan_mask,
  		indio_dev->masklength) {
  		switch (i) {
  		case GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR:
  			err = gp2ap020a00f_exec_cmd(data,
  					GP2AP020A00F_CMD_TRIGGER_CLEAR_EN);
  			break;
  		case GP2AP020A00F_SCAN_MODE_LIGHT_IR:
  			err = gp2ap020a00f_exec_cmd(data,
  					GP2AP020A00F_CMD_TRIGGER_IR_EN);
  			break;
  		case GP2AP020A00F_SCAN_MODE_PROXIMITY:
  			err = gp2ap020a00f_exec_cmd(data,
  					GP2AP020A00F_CMD_TRIGGER_PROX_EN);
  			break;
  		}
  	}
  
  	if (err < 0)
  		goto error_unlock;
  
  	data->buffer = kmalloc(indio_dev->scan_bytes, GFP_KERNEL);
  	if (!data->buffer) {
  		err = -ENOMEM;
  		goto error_unlock;
  	}
  
  	err = iio_triggered_buffer_postenable(indio_dev);
  
  error_unlock:
  	mutex_unlock(&data->lock);
  
  	return err;
  }
  
  static int gp2ap020a00f_buffer_predisable(struct iio_dev *indio_dev)
  {
  	struct gp2ap020a00f_data *data = iio_priv(indio_dev);
  	int i, err;
  
  	mutex_lock(&data->lock);
  
  	err = iio_triggered_buffer_predisable(indio_dev);
  	if (err < 0)
  		goto error_unlock;
  
  	for_each_set_bit(i, indio_dev->active_scan_mask,
  		indio_dev->masklength) {
  		switch (i) {
  		case GP2AP020A00F_SCAN_MODE_LIGHT_CLEAR:
  			err = gp2ap020a00f_exec_cmd(data,
  					GP2AP020A00F_CMD_TRIGGER_CLEAR_DIS);
  			break;
  		case GP2AP020A00F_SCAN_MODE_LIGHT_IR:
  			err = gp2ap020a00f_exec_cmd(data,
  					GP2AP020A00F_CMD_TRIGGER_IR_DIS);
  			break;
  		case GP2AP020A00F_SCAN_MODE_PROXIMITY:
  			err = gp2ap020a00f_exec_cmd(data,
  					GP2AP020A00F_CMD_TRIGGER_PROX_DIS);
  			break;
  		}
  	}
  
  	if (err == 0)
  		kfree(data->buffer);
  
  error_unlock:
  	mutex_unlock(&data->lock);
  
  	return err;
  }
  
  static const struct iio_buffer_setup_ops gp2ap020a00f_buffer_setup_ops = {
  	.postenable = &gp2ap020a00f_buffer_postenable,
  	.predisable = &gp2ap020a00f_buffer_predisable,
  };
  
  static const struct iio_trigger_ops gp2ap020a00f_trigger_ops = {
  };
  
  static int gp2ap020a00f_probe(struct i2c_client *client,
  				const struct i2c_device_id *id)
  {
  	struct gp2ap020a00f_data *data;
  	struct iio_dev *indio_dev;
  	struct regmap *regmap;
  	int err;
  
  	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
  	if (!indio_dev)
  		return -ENOMEM;
  
  	data = iio_priv(indio_dev);
  
  	data->vled_reg = devm_regulator_get(&client->dev, "vled");
  	if (IS_ERR(data->vled_reg))
  		return PTR_ERR(data->vled_reg);
  
  	err = regulator_enable(data->vled_reg);
  	if (err)
  		return err;
  
  	regmap = devm_regmap_init_i2c(client, &gp2ap020a00f_regmap_config);
  	if (IS_ERR(regmap)) {
  		dev_err(&client->dev, "Regmap initialization failed.\n");
  		err = PTR_ERR(regmap);
  		goto error_regulator_disable;
  	}
  
  	/* Initialize device registers */
  	err = regmap_bulk_write(regmap, GP2AP020A00F_OP_REG,
  			gp2ap020a00f_reg_init_tab,
  			ARRAY_SIZE(gp2ap020a00f_reg_init_tab));
  
  	if (err < 0) {
  		dev_err(&client->dev, "Device initialization failed.\n");
  		goto error_regulator_disable;
  	}
  
  	i2c_set_clientdata(client, indio_dev);
  
  	data->client = client;
  	data->cur_opmode = GP2AP020A00F_OPMODE_SHUTDOWN;
  	data->regmap = regmap;
  	init_waitqueue_head(&data->data_ready_queue);
  
  	mutex_init(&data->lock);
  	indio_dev->dev.parent = &client->dev;
  	indio_dev->channels = gp2ap020a00f_channels;
  	indio_dev->num_channels = ARRAY_SIZE(gp2ap020a00f_channels);
  	indio_dev->info = &gp2ap020a00f_info;
  	indio_dev->name = id->name;
  	indio_dev->modes = INDIO_DIRECT_MODE;
  
  	/* Allocate buffer */
  	err = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
  		&gp2ap020a00f_trigger_handler, &gp2ap020a00f_buffer_setup_ops);
  	if (err < 0)
  		goto error_regulator_disable;
  
  	/* Allocate trigger */
  	data->trig = devm_iio_trigger_alloc(&client->dev, "%s-trigger",
  							indio_dev->name);
  	if (data->trig == NULL) {
  		err = -ENOMEM;
  		dev_err(&indio_dev->dev, "Failed to allocate iio trigger.\n");
  		goto error_uninit_buffer;
  	}
  
  	/* This needs to be requested here for read_raw calls to work. */
  	err = request_threaded_irq(client->irq, NULL,
  				   &gp2ap020a00f_thresh_event_handler,
  				   IRQF_TRIGGER_FALLING |
  				   IRQF_ONESHOT,
  				   "gp2ap020a00f_als_event",
  				   indio_dev);
  	if (err < 0) {
  		dev_err(&client->dev, "Irq request failed.\n");
  		goto error_uninit_buffer;
  	}
  
  	data->trig->ops = &gp2ap020a00f_trigger_ops;
  	data->trig->dev.parent = &data->client->dev;
  
  	init_irq_work(&data->work, gp2ap020a00f_iio_trigger_work);
  
  	err = iio_trigger_register(data->trig);
  	if (err < 0) {
  		dev_err(&client->dev, "Failed to register iio trigger.\n");
  		goto error_free_irq;
  	}
  
  	err = iio_device_register(indio_dev);
  	if (err < 0)
  		goto error_trigger_unregister;
  
  	return 0;
  
  error_trigger_unregister:
  	iio_trigger_unregister(data->trig);
  error_free_irq:
  	free_irq(client->irq, indio_dev);
  error_uninit_buffer:
  	iio_triggered_buffer_cleanup(indio_dev);
  error_regulator_disable:
  	regulator_disable(data->vled_reg);
  
  	return err;
  }
  
  static int gp2ap020a00f_remove(struct i2c_client *client)
  {
  	struct iio_dev *indio_dev = i2c_get_clientdata(client);
  	struct gp2ap020a00f_data *data = iio_priv(indio_dev);
  	int err;
  
  	err = gp2ap020a00f_set_operation_mode(data,
  					GP2AP020A00F_OPMODE_SHUTDOWN);
  	if (err < 0)
  		dev_err(&indio_dev->dev, "Failed to power off the device.\n");
  
  	iio_device_unregister(indio_dev);
  	iio_trigger_unregister(data->trig);
  	free_irq(client->irq, indio_dev);
  	iio_triggered_buffer_cleanup(indio_dev);
  	regulator_disable(data->vled_reg);
  
  	return 0;
  }
  
  static const struct i2c_device_id gp2ap020a00f_id[] = {
  	{ GP2A_I2C_NAME, 0 },
  	{ }
  };
  
  MODULE_DEVICE_TABLE(i2c, gp2ap020a00f_id);
  
  #ifdef CONFIG_OF
  static const struct of_device_id gp2ap020a00f_of_match[] = {
  	{ .compatible = "sharp,gp2ap020a00f" },
  	{ }
  };
  MODULE_DEVICE_TABLE(of, gp2ap020a00f_of_match);
  #endif
  
  static struct i2c_driver gp2ap020a00f_driver = {
  	.driver = {
  		.name	= GP2A_I2C_NAME,
  		.of_match_table = of_match_ptr(gp2ap020a00f_of_match),
  	},
  	.probe		= gp2ap020a00f_probe,
  	.remove		= gp2ap020a00f_remove,
  	.id_table	= gp2ap020a00f_id,
  };
  
  module_i2c_driver(gp2ap020a00f_driver);
  
  MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>");
  MODULE_DESCRIPTION("Sharp GP2AP020A00F Proximity/ALS sensor driver");
  MODULE_LICENSE("GPL v2");
  