PageRenderTime 85ms CodeModel.GetById 2ms app.highlight 72ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/input/misc/ct406.c

https://bitbucket.org/simonsimons34/android_kernel_motorola_electrifym
C | 1707 lines | 1383 code | 275 blank | 49 comment | 242 complexity | 8792f9b9f31b15bffb4049c02b20a41e MD5 | raw file
   1/*
   2 * Copyright (C) 2011-2012 Motorola Mobility, Inc.
   3 *
   4 * This program is free software; you can redistribute it and/or modify
   5 * it under the terms of the GNU General Public License version 2 as
   6 * published by the Free Software Foundation.
   7 *
   8 * This program is distributed in the hope that it will be useful,
   9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 * GNU General Public License for more details.
  12 *
  13 * You should have received a copy of the GNU General Public License
  14 * along with this program; if not, write to the Free Software
  15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  16 * 02111-1307, USA
  17 */
  18
  19#include <linux/ct406.h>
  20
  21#include <linux/delay.h>
  22#include <linux/earlysuspend.h>
  23#include <linux/i2c.h>
  24#include <linux/input.h>
  25#include <linux/interrupt.h>
  26#include <linux/irq.h>
  27#include <linux/miscdevice.h>
  28#include <linux/mutex.h>
  29#include <linux/platform_device.h>
  30#include <linux/regulator/consumer.h>
  31#include <linux/slab.h>
  32#include <linux/suspend.h>
  33#include <linux/types.h>
  34#include <linux/uaccess.h>
  35#include <linux/workqueue.h>
  36
  37#define CT406_I2C_RETRIES	2
  38#define CT406_I2C_RETRY_DELAY	10
  39
  40#define CT406_COMMAND_SELECT		0x80
  41#define CT406_COMMAND_AUTO_INCREMENT	0x20
  42#define CT406_COMMAND_SPECIAL_FUNCTION	0x60
  43#define CT406_COMMAND_PROX_INT_CLEAR	0x05
  44#define CT406_COMMAND_ALS_INT_CLEAR	0x06
  45
  46#define CT406_ENABLE			0x00
  47#define CT406_ENABLE_PIEN		(1<<5)
  48#define CT406_ENABLE_AIEN		(1<<4)
  49#define CT406_ENABLE_WEN		(1<<3)
  50#define CT406_ENABLE_PEN		(1<<2)
  51#define CT406_ENABLE_AEN		(1<<1)
  52#define CT406_ENABLE_PON		(1<<0)
  53
  54#define CT406_ATIME			0x01
  55#define CT406_ATIME_SATURATED		0xFF
  56#define CT406_ATIME_NOT_SATURATED	0xEE
  57
  58#define CT406_PTIME			0x02
  59
  60#define CT406_WTIME			0x03
  61#define CT406_WTIME_ALS_OFF		0xEE
  62#define CT406_WTIME_ALS_ON		0xFF
  63#define CT406_WTIME_SATURATED		0xFF
  64
  65#define CT406_AILTL			0x04
  66#define CT406_AILTH			0x05
  67#define CT406_AIHTL			0x06
  68#define CT406_AIHTH			0x07
  69#define CT406_PILTL			0x08
  70#define CT406_PILTH			0x09
  71#define CT406_PIHTL			0x0A
  72#define CT406_PIHTH			0x0B
  73
  74#define CT406_PERS			0x0C
  75#define CT406_PERS_PPERS_MASK		0xF0
  76#define CT406_PERS_APERS_MASK		0x0F
  77#define CT406_PERS_PPERS		0x10
  78#define CT406_PERS_APERS_SATURATED	0x03
  79
  80#define CT406_CONFIG			0x0D
  81#define CT406_CONFIG_AGL		(1<<2)
  82
  83#define CT406_PPCOUNT			0x0E
  84
  85#define CT406_CONTROL			0x0F
  86#define CT406_CONTROL_PDIODE_CH0	0x10
  87#define CT406_CONTROL_PDIODE_CH1	0x20
  88#define CT406_CONTROL_PGAIN_1X		0x00
  89#define CT406_CONTROL_PGAIN_2X		0x04
  90#define CT406_CONTROL_PGAIN_4X		0x08
  91#define CT406_CONTROL_PGAIN_8X		0x0C
  92#define CT406_CONTROL_AGAIN_1X		0x00
  93#define CT406_CONTROL_AGAIN_8X		0x01
  94#define CT406_CONTROL_AGAIN_16X		0x02
  95#define CT406_CONTROL_AGAIN_120X	0x03
  96
  97#define CT406_REV_ID			0x11
  98
  99#define CT406_ID			0x12
 100
 101#define CT406_STATUS			0x13
 102#define CT406_STATUS_PINT		(1<<5)
 103#define CT406_STATUS_AINT		(1<<4)
 104
 105#define CT406_C0DATA			0x14
 106#define CT406_C0DATAH			0x15
 107#define CT406_C1DATA			0x16
 108#define CT406_C1DATAH			0x17
 109#define CT406_PDATA			0x18
 110#define CT406_PDATAH			0x19
 111#define CT406_POFFSET			0x1E
 112
 113#define CT406_C0DATA_MAX		0xFFFF
 114#define CT405_PDATA_MAX			0x03FF
 115#define CT406_PDATA_MAX			0x07FF
 116
 117#define CT406_PROXIMITY_NEAR		30	/* 30 mm */
 118#define CT406_PROXIMITY_FAR		1000	/* 1 meter */
 119
 120#define CT406_ALS_LOW_TO_HIGH_THRESHOLD	200	/* 200 lux */
 121#define CT406_ALS_HIGH_TO_LOW_THRESHOLD	100	/* 100 lux */
 122
 123#define CT40X_REV_ID_CT405		0x02
 124#define CT40X_REV_ID_CT406a		0x03
 125#define CT40X_REV_ID_CT406b		0x04
 126
 127enum ct406_prox_mode {
 128	CT406_PROX_MODE_SATURATED,
 129	CT406_PROX_MODE_UNCOVERED,
 130	CT406_PROX_MODE_COVERED,
 131};
 132
 133enum ct406_als_mode {
 134	CT406_ALS_MODE_SUNLIGHT,
 135	CT406_ALS_MODE_LOW_LUX,
 136	CT406_ALS_MODE_HIGH_LUX,
 137};
 138
 139enum ct40x_hardware_type {
 140	CT405_HW_TYPE,
 141	CT406_HW_TYPE,
 142};
 143
 144struct ct406_data {
 145	struct input_dev *dev;
 146	struct i2c_client *client;
 147	struct regulator *regulator;
 148	struct work_struct work;
 149	struct workqueue_struct *workqueue;
 150	struct ct406_platform_data *pdata;
 151	struct miscdevice miscdevice;
 152	struct notifier_block pm_notifier;
 153	struct mutex mutex;
 154	/* state flags */
 155	unsigned int suspended;
 156	unsigned int regs_initialized;
 157	unsigned int oscillator_enabled;
 158	unsigned int prox_requested;
 159	unsigned int prox_enabled;
 160	enum ct406_prox_mode prox_mode;
 161	unsigned int als_requested;
 162	unsigned int als_enabled;
 163	unsigned int als_apers;
 164	unsigned int als_first_report;
 165	enum ct406_als_mode als_mode;
 166	unsigned int wait_enabled;
 167	/* numeric values */
 168	unsigned int prox_noise_floor;
 169	unsigned int prox_low_threshold;
 170	unsigned int prox_high_threshold;
 171	unsigned int als_low_threshold;
 172	u16 prox_saturation_threshold;
 173	u16 prox_covered_offset;
 174	u16 prox_uncovered_offset;
 175	u16 prox_recalibrate_offset;
 176	u8 prox_pulse_count;
 177	u8 prox_offset;
 178	u16 pdata_max;
 179	enum ct40x_hardware_type hw_type;
 180#ifdef CONFIG_HAS_EARLYSUSPEND
 181        struct early_suspend    ct406_early_suspend;
 182#endif
 183};
 184
 185static struct ct406_data *ct406_misc_data;
 186
 187static struct ct406_reg {
 188	const char *name;
 189	u8 reg;
 190} ct406_regs[] = {
 191	{ "ENABLE",	CT406_ENABLE },
 192	{ "ATIME",	CT406_ATIME },
 193	{ "PTIME",	CT406_PTIME },
 194	{ "WTIME",	CT406_WTIME },
 195	{ "AILTL",	CT406_AILTL },
 196	{ "AILTH",	CT406_AILTH },
 197	{ "AIHTL",	CT406_AIHTL },
 198	{ "AIHTH",	CT406_AIHTH },
 199	{ "PILTL",	CT406_PILTL },
 200	{ "PILTH",	CT406_PILTH },
 201	{ "PIHTL",	CT406_PIHTL },
 202	{ "PIHTH",	CT406_PIHTH },
 203	{ "PERS",	CT406_PERS },
 204	{ "CONFIG",	CT406_CONFIG },
 205	{ "PPCOUNT",	CT406_PPCOUNT },
 206	{ "CONTROL",	CT406_CONTROL },
 207	{ "ID",		CT406_ID },
 208	{ "STATUS",	CT406_STATUS },
 209	{ "C0DATA",	CT406_C0DATA },
 210	{ "C0DATAH",	CT406_C0DATAH },
 211	{ "C1DATA",	CT406_C1DATA },
 212	{ "C1DATAH",	CT406_C1DATAH },
 213	{ "PDATA",	CT406_PDATA },
 214	{ "PDATAH",	CT406_PDATAH },
 215	{ "POFFSET", 	CT406_POFFSET },
 216};
 217
 218#define CT406_DBG_INPUT			0x00000001
 219#define CT406_DBG_POWER_ON_OFF		0x00000002
 220#define CT406_DBG_ENABLE_DISABLE	0x00000004
 221#define CT406_DBG_IOCTL			0x00000008
 222#define CT406_DBG_SUSPEND_RESUME	0x00000010
 223static u32 ct406_debug = 0x00000000;
 224module_param_named(debug_mask, ct406_debug, uint, 0644);
 225
 226static int ct406_i2c_read(struct ct406_data *ct, u8 *buf, int len)
 227{
 228	int err;
 229	int tries = 0;
 230	struct i2c_msg msgs[] = {
 231		{
 232			.addr = ct->client->addr,
 233			.flags = ct->client->flags & I2C_M_TEN,
 234			.len = 1,
 235			.buf = buf,
 236		},
 237		{
 238			.addr = ct->client->addr,
 239			.flags = (ct->client->flags & I2C_M_TEN) | I2C_M_RD,
 240			.len = len,
 241			.buf = buf,
 242		},
 243	};
 244
 245	buf[0] |= CT406_COMMAND_SELECT;
 246	do {
 247		err = i2c_transfer(ct->client->adapter, msgs, 2);
 248		if (err != 2)
 249			msleep_interruptible(CT406_I2C_RETRY_DELAY);
 250	} while ((err != 2) && (++tries < CT406_I2C_RETRIES));
 251
 252	if (err != 2) {
 253		pr_err("%s: read transfer error.\n", __func__);
 254		dev_err(&ct->client->dev, "read transfer error\n");
 255		err = -EIO;
 256	} else {
 257		err = 0;
 258	}
 259
 260	return err;
 261}
 262
 263static int ct406_i2c_write(struct ct406_data *ct, u8 *buf, int len)
 264{
 265	int err;
 266	int tries = 0;
 267	struct i2c_msg msgs[] = {
 268		{
 269			.addr = ct->client->addr,
 270			.flags = ct->client->flags & I2C_M_TEN,
 271			.len = len + 1,
 272			.buf = buf,
 273		},
 274	};
 275
 276	buf[0] |= CT406_COMMAND_SELECT;
 277	do {
 278		err = i2c_transfer(ct->client->adapter, msgs, 1);
 279		if (err != 1)
 280			msleep_interruptible(CT406_I2C_RETRY_DELAY);
 281	} while ((err != 1) && (++tries < CT406_I2C_RETRIES));
 282
 283	if (err != 1) {
 284		pr_err("%s: write transfer error.\n", __func__);
 285		dev_err(&ct->client->dev, "write transfer error\n");
 286		err = -EIO;
 287	} else {
 288		err = 0;
 289	}
 290
 291	return err;
 292}
 293
 294static int ct406_write_enable(struct ct406_data *ct)
 295{
 296	int error = 0;
 297	u8 reg_data[2] = {0x00, 0x00};
 298	reg_data[0] = CT406_ENABLE;
 299	if (ct->oscillator_enabled || ct->als_enabled || ct->prox_enabled) {
 300		reg_data[1] |= CT406_ENABLE_PON;
 301		if (!ct->oscillator_enabled) {
 302			error = ct406_i2c_write(ct, reg_data, 1);
 303			if (error < 0)
 304				return error;
 305			msleep(3);
 306			ct->oscillator_enabled = 1;
 307		}
 308		if (ct->als_enabled)
 309			reg_data[1] |= CT406_ENABLE_AEN | CT406_ENABLE_AIEN;
 310		if (ct->prox_enabled)
 311			reg_data[1] |= CT406_ENABLE_PEN | CT406_ENABLE_PIEN;
 312		if (ct->wait_enabled)
 313			reg_data[1] |= CT406_ENABLE_WEN;
 314	}
 315	if (ct406_debug & CT406_DBG_ENABLE_DISABLE)
 316		pr_info("%s: writing ENABLE=0x%02x\n", __func__, reg_data[1]);
 317
 318	return ct406_i2c_write(ct, reg_data, 1);
 319}
 320
 321static int ct406_set_als_enable(struct ct406_data *ct,
 322				unsigned int enable)
 323{
 324	int error = 0;
 325	if (ct->als_enabled != enable) {
 326		ct->als_enabled = enable;
 327		if (ct->regs_initialized)
 328			error = ct406_write_enable(ct);
 329	}
 330	return error;
 331}
 332
 333static int ct406_set_prox_enable(struct ct406_data *ct,
 334				 unsigned int enable)
 335{
 336	int error = 0;
 337	if (ct->prox_enabled != enable) {
 338		ct->prox_enabled = enable;
 339		if (ct->regs_initialized)
 340			error = ct406_write_enable(ct);
 341	}
 342	return error;
 343}
 344
 345static int ct406_set_wait_enable(struct ct406_data *ct,
 346				 unsigned int enable)
 347{
 348	int error = 0;
 349	if (ct->wait_enabled != enable) {
 350		ct->wait_enabled = enable;
 351		if (ct->regs_initialized)
 352			error = ct406_write_enable(ct);
 353	}
 354	return error;
 355}
 356
 357static int ct406_clear_als_flag(struct ct406_data *ct)
 358{
 359	u8 reg_data[1] = {0};
 360	reg_data[0] = CT406_COMMAND_SPECIAL_FUNCTION
 361		| CT406_COMMAND_ALS_INT_CLEAR;
 362	return ct406_i2c_write(ct, reg_data, 0);
 363}
 364
 365static int ct406_clear_prox_flag(struct ct406_data *ct)
 366{
 367	u8 reg_data[1] = {0};
 368	reg_data[0] = CT406_COMMAND_SPECIAL_FUNCTION
 369		| CT406_COMMAND_PROX_INT_CLEAR;
 370	return ct406_i2c_write(ct, reg_data, 0);
 371}
 372
 373static int ct406_init_registers(struct ct406_data *ct)
 374{
 375	int error = 0;
 376	u8 reg_data[3] = {0};
 377
 378	/* write ALS integration time = ~49 ms */
 379	/* write prox integration time = ~3 ms */
 380	reg_data[0] = (CT406_ATIME | CT406_COMMAND_AUTO_INCREMENT);
 381	reg_data[1] = CT406_ATIME_NOT_SATURATED;
 382	if (ct->hw_type == CT405_HW_TYPE)
 383		reg_data[2] = 0xFF; /* 2.73 ms */
 384	else
 385		reg_data[2] = 0xFE; /* 5.46 ms */
 386	error = ct406_i2c_write(ct, reg_data, 2);
 387	if (error < 0)
 388		return error;
 389
 390	/* write IR LED pulse count */
 391	reg_data[0] = (CT406_PPCOUNT | CT406_COMMAND_AUTO_INCREMENT);
 392	reg_data[1] = ct->prox_pulse_count;
 393	error = ct406_i2c_write(ct, reg_data, 1);
 394	if (error < 0)
 395		return error;
 396
 397	/* write proximity diode = ch1, proximity gain = 1/2, ALS gain = 1 */
 398	reg_data[0] = (CT406_CONTROL | CT406_COMMAND_AUTO_INCREMENT);
 399	if (ct->hw_type == CT405_HW_TYPE)
 400		reg_data[1] = CT406_CONTROL_PDIODE_CH1
 401			| CT406_CONTROL_PGAIN_2X | CT406_CONTROL_AGAIN_1X;
 402	else
 403		reg_data[1] = CT406_CONTROL_PDIODE_CH1
 404			| CT406_CONTROL_PGAIN_1X | CT406_CONTROL_AGAIN_1X;
 405	error = ct406_i2c_write(ct, reg_data, 1);
 406	if (error < 0)
 407		return error;
 408
 409	/* write proximity offset */
 410	reg_data[0] = (CT406_POFFSET | CT406_COMMAND_AUTO_INCREMENT);
 411	reg_data[1] = ct->prox_offset;
 412	error = ct406_i2c_write(ct, reg_data, 1);
 413	if (error < 0)
 414		return error;
 415
 416	return 0;
 417}
 418
 419static void ct406_write_als_thresholds(struct ct406_data *ct)
 420{
 421	u8 reg_data[5] = {0};
 422	unsigned int ailt = ct->als_low_threshold;
 423	unsigned int aiht = CT406_C0DATA_MAX;
 424	int error;
 425
 426	reg_data[0] = (CT406_AILTL | CT406_COMMAND_AUTO_INCREMENT);
 427	reg_data[1] = (ailt & 0xFF);
 428	reg_data[2] = ((ailt >> 8) & 0xFF);
 429	reg_data[3] = (aiht & 0xFF);
 430	reg_data[4] = ((aiht >> 8) & 0xFF);
 431
 432	error = ct406_i2c_write(ct, reg_data, 4);
 433	if (error < 0)
 434		pr_err("%s: Error writing new ALS thresholds: %d\n",
 435			__func__, error);
 436}
 437
 438static void ct406_als_mode_sunlight(struct ct406_data *ct)
 439{
 440	int error;
 441	u8 reg_data[2] = {0};
 442
 443	/* set AGL to reduce ALS gain by 1/6 */
 444	reg_data[0] = CT406_CONFIG;
 445	reg_data[1] = CT406_CONFIG_AGL;
 446	error = ct406_i2c_write(ct, reg_data, 1);
 447	if (error < 0) {
 448		pr_err("%s: error writing CONFIG: %d\n", __func__, error);
 449		return;
 450	}
 451
 452	/* write ALS gain = 1 */
 453	reg_data[0] = CT406_CONTROL;
 454	if (ct->hw_type == CT405_HW_TYPE)
 455		reg_data[1] = CT406_CONTROL_PDIODE_CH1
 456			| CT406_CONTROL_PGAIN_2X | CT406_CONTROL_AGAIN_1X;
 457	else
 458		reg_data[1] = CT406_CONTROL_PDIODE_CH1
 459			| CT406_CONTROL_PGAIN_1X | CT406_CONTROL_AGAIN_1X;
 460	error = ct406_i2c_write(ct, reg_data, 1);
 461	if (error < 0) {
 462		pr_err("%s: error writing ALS gain: %d\n", __func__, error);
 463		return;
 464	}
 465
 466	/* write ALS integration time = ~3 ms */
 467	reg_data[0] = CT406_ATIME;
 468	reg_data[1] = CT406_ATIME_SATURATED;
 469	error = ct406_i2c_write(ct, reg_data, 1);
 470	if (error < 0) {
 471		pr_err("%s: error writing ATIME: %d\n", __func__, error);
 472		return;
 473	}
 474
 475	ct->als_mode = CT406_ALS_MODE_SUNLIGHT;
 476	ct->als_low_threshold = ct->prox_saturation_threshold;
 477	ct406_write_als_thresholds(ct);
 478}
 479
 480static void ct406_als_mode_low_lux(struct ct406_data *ct)
 481{
 482	int error;
 483	u8 reg_data[2] = {0};
 484
 485	/* clear AGL for regular ALS gain behavior */
 486	reg_data[0] = CT406_CONFIG;
 487	reg_data[1] = 0;
 488	error = ct406_i2c_write(ct, reg_data, 1);
 489	if (error < 0) {
 490		pr_err("%s: error writing CONFIG: %d\n", __func__, error);
 491		return;
 492	}
 493
 494	/* write ALS gain = 8 */
 495	reg_data[0] = CT406_CONTROL;
 496	if (ct->hw_type == CT405_HW_TYPE)
 497		reg_data[1] = CT406_CONTROL_PDIODE_CH1
 498			| CT406_CONTROL_PGAIN_2X | CT406_CONTROL_AGAIN_8X;
 499	else
 500		reg_data[1] = CT406_CONTROL_PDIODE_CH1
 501			| CT406_CONTROL_PGAIN_1X | CT406_CONTROL_AGAIN_8X;
 502	error = ct406_i2c_write(ct, reg_data, 1);
 503	if (error < 0) {
 504		pr_err("%s: error writing ALS gain: %d\n", __func__, error);
 505		return;
 506	}
 507
 508	/* write ALS integration time = ~49 ms */
 509	reg_data[0] = CT406_ATIME;
 510	reg_data[1] = CT406_ATIME_NOT_SATURATED;
 511	error = ct406_i2c_write(ct, reg_data, 1);
 512	if (error < 0) {
 513		pr_err("%s: error writing ATIME: %d\n", __func__, error);
 514		return;
 515	}
 516
 517	ct->als_mode = CT406_ALS_MODE_LOW_LUX;
 518	ct->als_low_threshold = CT406_C0DATA_MAX - 1;
 519	ct406_write_als_thresholds(ct);
 520}
 521
 522static void ct406_als_mode_high_lux(struct ct406_data *ct)
 523{
 524	int error;
 525	u8 reg_data[2] = {0};
 526
 527	/* clear AGL for regular ALS gain behavior */
 528	reg_data[0] = CT406_CONFIG;
 529	reg_data[1] = 0;
 530	error = ct406_i2c_write(ct, reg_data, 1);
 531	if (error < 0) {
 532		pr_err("%s: error writing CONFIG: %d\n", __func__, error);
 533		return;
 534	}
 535
 536	/* write ALS gain = 1 */
 537	reg_data[0] = CT406_CONTROL;
 538	if (ct->hw_type == CT405_HW_TYPE)
 539		reg_data[1] = CT406_CONTROL_PDIODE_CH1
 540			| CT406_CONTROL_PGAIN_2X | CT406_CONTROL_AGAIN_1X;
 541	else
 542		reg_data[1] = CT406_CONTROL_PDIODE_CH1
 543			| CT406_CONTROL_PGAIN_1X | CT406_CONTROL_AGAIN_1X;
 544	error = ct406_i2c_write(ct, reg_data, 1);
 545	if (error < 0) {
 546		pr_err("%s: error writing ALS gain: %d\n", __func__, error);
 547		return;
 548	}
 549
 550	/* write ALS integration time = ~49 ms */
 551	reg_data[0] = CT406_ATIME;
 552	reg_data[1] = CT406_ATIME_NOT_SATURATED;
 553	error = ct406_i2c_write(ct, reg_data, 1);
 554	if (error < 0) {
 555		pr_err("%s: error writing ATIME: %d\n", __func__, error);
 556		return;
 557	}
 558
 559	ct->als_mode = CT406_ALS_MODE_HIGH_LUX;
 560	ct->als_low_threshold = CT406_C0DATA_MAX - 1;
 561	ct406_write_als_thresholds(ct);
 562}
 563
 564static void ct406_write_prox_thresholds(struct ct406_data *ct)
 565{
 566	u8 reg_data[5] = {0};
 567	unsigned int pilt = ct->prox_low_threshold;
 568	unsigned int piht = ct->prox_high_threshold;
 569	int error;
 570
 571	reg_data[0] = (CT406_PILTL | CT406_COMMAND_AUTO_INCREMENT);
 572	reg_data[1] = (pilt & 0xFF);
 573	reg_data[2] = ((pilt >> 8) & 0xFF);
 574	reg_data[3] = (piht & 0xFF);
 575	reg_data[4] = ((piht >> 8) & 0xFF);
 576
 577	error = ct406_i2c_write(ct, reg_data, 4);
 578	if (error < 0)
 579		pr_err("%s: Error writing new prox thresholds: %d\n",
 580			__func__, error);
 581}
 582
 583static void ct406_prox_mode_saturated(struct ct406_data *ct)
 584{
 585	ct->prox_mode = CT406_PROX_MODE_SATURATED;
 586	pr_info("%s: Prox mode saturated\n", __func__);
 587}
 588
 589static void ct406_prox_mode_uncovered(struct ct406_data *ct)
 590{
 591	unsigned int noise_floor = ct->prox_noise_floor;
 592	unsigned int pilt = noise_floor - ct->prox_recalibrate_offset;
 593	unsigned int piht = noise_floor + ct->prox_covered_offset;
 594
 595	if (pilt > ct->pdata_max)
 596		pilt = 0;
 597	if (piht > ct->pdata_max)
 598		piht = ct->pdata_max;
 599
 600	ct->prox_mode = CT406_PROX_MODE_UNCOVERED;
 601	ct->prox_low_threshold = pilt;
 602	ct->prox_high_threshold = piht;
 603	ct406_write_prox_thresholds(ct);
 604	pr_info("%s: Prox mode uncovered\n", __func__);
 605}
 606
 607static void ct406_prox_mode_covered(struct ct406_data *ct)
 608{
 609	unsigned int noise_floor = ct->prox_noise_floor;
 610	unsigned int pilt = noise_floor + ct->prox_uncovered_offset;
 611	unsigned int piht = ct->pdata_max;
 612
 613	if (pilt > ct->pdata_max)
 614		pilt = ct->pdata_max;
 615
 616	ct->prox_mode = CT406_PROX_MODE_COVERED;
 617	ct->prox_low_threshold = pilt;
 618	ct->prox_high_threshold = piht;
 619	ct406_write_prox_thresholds(ct);
 620	pr_info("%s: Prox mode covered\n", __func__);
 621}
 622
 623static void ct406_device_power_off(struct ct406_data *ct)
 624{
 625	int error;
 626
 627	if (ct406_debug & CT406_DBG_POWER_ON_OFF)
 628		pr_info("%s: initialized=%d\n", __func__, ct->regs_initialized);
 629
 630	if (ct->regs_initialized) {
 631		disable_irq_nosync(ct->client->irq);
 632		ct->oscillator_enabled = 0;
 633		error = ct406_write_enable(ct);
 634		if (error) {
 635			pr_err("%s: ct406_disable failed: %d\n",
 636				__func__, error);
 637		}
 638		ct->regs_initialized = 0;
 639	}
 640
 641	if (ct->regulator) {
 642		error = regulator_disable(ct->regulator);
 643		if (error) {
 644			pr_err("%s: regulator_disable failed: %d\n",
 645				__func__, error);
 646		}
 647	}
 648
 649}
 650
 651static int ct406_device_power_on(struct ct406_data *ct)
 652{
 653	int error;
 654
 655	if (ct406_debug & CT406_DBG_POWER_ON_OFF)
 656		pr_info("%s: initialized=%d\n", __func__, ct->regs_initialized);
 657
 658	if (ct->regulator) {
 659		error = regulator_enable(ct->regulator);
 660		if (error) {
 661			pr_err("%s: regulator_enable failed: %d\n",
 662				__func__, error);
 663			return error;
 664		}
 665	}
 666	return 0;
 667}
 668
 669static int ct406_device_init(struct ct406_data *ct)
 670{
 671	int error;
 672
 673	if (!ct->regs_initialized) {
 674		error = ct406_init_registers(ct);
 675		if (error < 0) {
 676			pr_err("%s: init_registers failed: %d\n",
 677				__func__, error);
 678			if (ct->regulator)
 679				regulator_disable(ct->regulator);
 680			return error;
 681		}
 682		ct->oscillator_enabled = 0;
 683		ct->prox_enabled = 0;
 684		ct->prox_mode = CT406_PROX_MODE_SATURATED;
 685		ct->als_enabled = 0;
 686		ct->als_mode = CT406_ALS_MODE_LOW_LUX;
 687
 688		enable_irq(ct->client->irq);
 689
 690		ct->regs_initialized = 1;
 691	}
 692
 693	return 0;
 694}
 695
 696static void ct406_check_als_range(struct ct406_data *ct, unsigned int lux)
 697{
 698	if (ct->als_mode == CT406_ALS_MODE_LOW_LUX) {
 699		if (lux >= CT406_ALS_LOW_TO_HIGH_THRESHOLD)
 700			ct406_als_mode_high_lux(ct);
 701	} else if (ct->als_mode == CT406_ALS_MODE_HIGH_LUX) {
 702		if (lux < CT406_ALS_HIGH_TO_LOW_THRESHOLD)
 703			ct406_als_mode_low_lux(ct);
 704	}
 705}
 706
 707static int ct406_enable_als(struct ct406_data *ct)
 708{
 709	int error;
 710	u8 reg_data[5] = {0};
 711
 712	if (!ct->suspended && ct->als_mode != CT406_ALS_MODE_SUNLIGHT) {
 713		error = ct406_set_als_enable(ct, 0);
 714		if (error) {
 715			pr_err("%s: Unable to turn off ALS: %d\n",
 716				__func__, error);
 717			return error;
 718		}
 719
 720		ct406_als_mode_low_lux(ct);
 721
 722		/* write wait time = ALS on value */
 723		reg_data[0] = CT406_WTIME;
 724		reg_data[1] = CT406_WTIME_ALS_ON;
 725		error = ct406_i2c_write(ct, reg_data, 1);
 726		if (error < 0) {
 727			pr_err("%s: Error  %d\n", __func__, error);
 728			return error;
 729		}
 730		error = ct406_set_wait_enable(ct, 0);
 731		if (error) {
 732			pr_err("%s: Unable to set wait enable: %d\n",
 733				__func__, error);
 734			return error;
 735		}
 736
 737		/* write ALS interrupt persistence */
 738		reg_data[0] = CT406_PERS;
 739		reg_data[1] = CT406_PERS_PPERS;
 740		error = ct406_i2c_write(ct, reg_data, 1);
 741		if (error < 0) {
 742			pr_err("%s: Error  %d\n", __func__, error);
 743			return error;
 744		}
 745		ct->als_first_report = 0;
 746
 747		ct406_clear_als_flag(ct);
 748
 749		error = ct406_set_als_enable(ct, 1);
 750		if (error) {
 751			pr_err("%s: Unable to turn on ALS: %d\n",
 752				__func__, error);
 753			return error;
 754		}
 755	}
 756
 757	return 0;
 758}
 759
 760static int ct406_disable_als(struct ct406_data *ct)
 761{
 762	int error;
 763	u8 reg_data[2] = {0};
 764
 765	if (ct->als_enabled && ct->als_mode != CT406_ALS_MODE_SUNLIGHT) {
 766		ct406_set_als_enable(ct, 0);
 767
 768		/* write wait time = ALS off value */
 769		reg_data[0] = CT406_WTIME;
 770		reg_data[1] = CT406_WTIME_ALS_OFF;
 771		error = ct406_i2c_write(ct, reg_data, 1);
 772		if (error < 0) {
 773			pr_err("%s: Error  %d\n", __func__, error);
 774			return error;
 775		}
 776		error = ct406_set_wait_enable(ct, 1);
 777		if (error) {
 778			pr_err("%s: Unable to set wait enable: %d\n",
 779				__func__, error);
 780			return error;
 781		}
 782
 783		ct406_clear_als_flag(ct);
 784	}
 785
 786	return 0;
 787}
 788
 789static void ct406_measure_noise_floor(struct ct406_data *ct)
 790{
 791	int error = -EINVAL;
 792	unsigned int num_samples = ct->pdata->prox_samples_for_noise_floor;
 793	unsigned int i, sum = 0, avg = 0;
 794	unsigned int max = ct->pdata_max - 1 - ct->prox_covered_offset;
 795	u8 reg_data[2] = {0};
 796
 797	/* disable ALS temporarily */
 798	error = ct406_set_als_enable(ct, 0);
 799	if (error < 0)
 800		pr_err("%s: error disabling ALS: %d\n",
 801			__func__, error);
 802
 803	/* clear AGL for regular ALS gain behavior */
 804	reg_data[0] = CT406_CONFIG;
 805	reg_data[1] = 0;
 806	error = ct406_i2c_write(ct, reg_data, 1);
 807	if (error < 0)
 808		pr_err("%s: error writing CONFIG: %d\n",
 809			__func__, error);
 810
 811	/* write wait time = ALS off value */
 812	reg_data[0] = CT406_WTIME;
 813	reg_data[1] = CT406_WTIME_ALS_OFF;
 814	error = ct406_i2c_write(ct, reg_data, 1);
 815	if (error < 0)
 816		pr_err("%s: Error writing WTIME: %d\n",
 817				__func__, error);
 818	error = ct406_set_wait_enable(ct, 1);
 819	if (error) {
 820		pr_err("%s: Unable to set wait enable: %d\n",
 821			__func__, error);
 822	}
 823
 824	for (i = 0; i < num_samples; i++) {
 825		/* enable prox sensor and wait */
 826		error = ct406_set_prox_enable(ct, 1);
 827		if (error) {
 828			pr_err("%s: Error enabling proximity sensor: %d\n",
 829				__func__, error);
 830			break;
 831		}
 832		msleep(5);
 833
 834		reg_data[0] = (CT406_PDATA | CT406_COMMAND_AUTO_INCREMENT);
 835		error = ct406_i2c_read(ct, reg_data, 2);
 836		if (error) {
 837			pr_err("%s: Error reading prox data: %d\n",
 838				__func__, error);
 839			break;
 840		}
 841		sum += (reg_data[1] << 8) | reg_data[0];
 842
 843		/* disable prox sensor */
 844		error = ct406_set_prox_enable(ct, 0);
 845		if (error) {
 846			pr_err("%s: Error disabling proximity sensor: %d\n",
 847				__func__, error);
 848			break;
 849		}
 850	}
 851
 852	if (!error)
 853		avg = sum / num_samples;
 854
 855	if (avg < max)
 856		ct->prox_noise_floor = avg;
 857	else
 858		ct->prox_noise_floor = max;
 859
 860	if (ct406_debug & CT406_DBG_ENABLE_DISABLE)
 861		pr_info("%s: Noise floor is 0x%x\n", __func__,
 862			ct->prox_noise_floor);
 863
 864	ct406_prox_mode_uncovered(ct);
 865
 866	error = ct406_set_prox_enable(ct, 1);
 867	if (error)
 868		pr_err("%s: Error enabling proximity sensor: %d\n",
 869			__func__, error);
 870
 871	/* re-enable ALS if necessary */
 872	ct406_als_mode_low_lux(ct);
 873	if (ct->als_requested && !ct->suspended)
 874		ct406_enable_als(ct);
 875}
 876
 877static int ct406_check_saturation(struct ct406_data *ct)
 878{
 879	int error = 0;
 880	u8 reg_data[2] = {0};
 881	unsigned int c0data;
 882
 883	/* disable prox */
 884	ct406_set_prox_enable(ct, 0);
 885	ct->prox_low_threshold = 0;
 886	ct->prox_high_threshold = ct->pdata_max;
 887	ct406_write_prox_thresholds(ct);
 888
 889	ct406_als_mode_sunlight(ct);
 890	ct406_set_als_enable(ct, 1);
 891
 892	/* write ALS interrupt persistence = saturated value */
 893	reg_data[0] = CT406_PERS;
 894	reg_data[1] = CT406_PERS_PPERS | CT406_PERS_APERS_SATURATED;
 895	error = ct406_i2c_write(ct, reg_data, 1);
 896	if (error < 0)
 897		return 0;
 898
 899	/* write wait time = saturated value */
 900	reg_data[0] = CT406_WTIME;
 901	reg_data[1] = CT406_WTIME_SATURATED;
 902	error = ct406_i2c_write(ct, reg_data, 1);
 903	if (error < 0)
 904		return 0;
 905	error = ct406_set_wait_enable(ct, 1);
 906	if (error) {
 907		pr_err("%s: Unable to set wait enable: %d\n",
 908			__func__, error);
 909		return error;
 910	}
 911
 912	msleep(5);
 913
 914	/* read C0DATA */
 915	reg_data[0] = (CT406_C0DATA | CT406_COMMAND_AUTO_INCREMENT);
 916	error = ct406_i2c_read(ct, reg_data, 2);
 917	if (error < 0)
 918		return 0;
 919	c0data = (reg_data[1] << 8) | reg_data[0];
 920
 921	return (c0data > ct->als_low_threshold);
 922}
 923
 924static int ct406_enable_prox(struct ct406_data *ct)
 925{
 926	int error;
 927
 928	if (ct->suspended) {
 929		if (ct406_debug & CT406_DBG_ENABLE_DISABLE)
 930			pr_info("%s: Powering on\n", __func__);
 931		error = ct406_device_power_on(ct);
 932		if (error)
 933			return error;
 934		error = ct406_device_init(ct);
 935		if (error)
 936			return error;
 937	}
 938
 939	if (ct406_check_saturation(ct))
 940		ct406_prox_mode_saturated(ct);
 941	else
 942		ct406_measure_noise_floor(ct);
 943
 944	return 0;
 945}
 946
 947static int ct406_disable_prox(struct ct406_data *ct)
 948{
 949	if (ct->prox_enabled) {
 950		ct406_set_prox_enable(ct, 0);
 951		ct406_clear_prox_flag(ct);
 952		ct406_prox_mode_saturated(ct);
 953
 954		if (ct->als_requested) {
 955			if (ct->als_mode == CT406_ALS_MODE_SUNLIGHT) {
 956				ct406_als_mode_low_lux(ct);
 957				if (!ct->suspended)
 958					ct406_enable_als(ct);
 959			}
 960		}
 961	}
 962
 963	if (ct->suspended && ct->regs_initialized) {
 964		if (ct406_debug & CT406_DBG_ENABLE_DISABLE)
 965			pr_info("%s: Powering off\n", __func__);
 966		ct406_device_power_off(ct);
 967	}
 968
 969	return 0;
 970}
 971
 972
 973static void ct406_report_prox(struct ct406_data *ct)
 974{
 975	int error = 0;
 976	u8 reg_data[2] = {0};
 977	unsigned int pdata = 0;
 978
 979	reg_data[0] = (CT406_PDATA | CT406_COMMAND_AUTO_INCREMENT);
 980	error = ct406_i2c_read(ct, reg_data, 2);
 981	if (error < 0)
 982		return;
 983
 984	pdata = (reg_data[1] << 8) | reg_data[0];
 985	if (ct406_debug & CT406_DBG_INPUT)
 986		pr_info("%s: PDATA = %d\n", __func__, pdata);
 987
 988	switch (ct->prox_mode) {
 989	case CT406_PROX_MODE_SATURATED:
 990		pr_warn("%s: prox interrupted in saturated mode!\n", __func__);
 991		break;
 992	case CT406_PROX_MODE_UNCOVERED:
 993		if (pdata < ct->prox_low_threshold)
 994			ct406_enable_prox(ct);
 995		if (pdata > ct->prox_high_threshold) {
 996			input_event(ct->dev, EV_MSC, MSC_RAW,
 997				CT406_PROXIMITY_NEAR);
 998			input_sync(ct->dev);
 999			ct406_prox_mode_covered(ct);
1000		}
1001		break;
1002	case CT406_PROX_MODE_COVERED:
1003		if (pdata < ct->prox_low_threshold) {
1004			input_event(ct->dev, EV_MSC, MSC_RAW,
1005				CT406_PROXIMITY_FAR);
1006			input_sync(ct->dev);
1007			ct406_prox_mode_uncovered(ct);
1008		}
1009		break;
1010	default:
1011		pr_err("%s: prox mode is %d!\n", __func__, ct->prox_mode);
1012	}
1013
1014	ct406_clear_prox_flag(ct);
1015}
1016
1017static void ct406_report_als(struct ct406_data *ct)
1018{
1019	int error;
1020	u8 reg_data[4] = {0};
1021	unsigned int c0data;
1022	unsigned int c1data;
1023	unsigned int ratio;
1024	unsigned int lux = 0;
1025
1026	reg_data[0] = (CT406_C0DATA | CT406_COMMAND_AUTO_INCREMENT);
1027	error = ct406_i2c_read(ct, reg_data, 4);
1028	if (error < 0)
1029		return;
1030
1031	c0data = (reg_data[1] << 8) | reg_data[0];
1032	c1data = (reg_data[3] << 8) | reg_data[2];
1033	if (ct406_debug & CT406_DBG_INPUT)
1034		pr_info("%s: C0DATA = %d, C1DATA = %d\n",
1035			 __func__, c0data, c1data);
1036
1037	/* calculate lux using piecewise function from TAOS */
1038	if (c0data == 0)
1039		c0data = 1;
1040	ratio = ((100 * c1data) + c0data - 1) / c0data;
1041	switch (ct->als_mode) {
1042	case CT406_ALS_MODE_SUNLIGHT:
1043		if (c0data == 0x0400 || c1data == 0x0400)
1044			lux = 0xFFFF;
1045		else if (ratio <= 51)
1046			lux = (1041*c0data - 1963*c1data);
1047		else if (ratio <= 58)
1048			lux = (342*c0data - 587*c1data);
1049		else
1050			lux = 0;
1051		break;
1052	case CT406_ALS_MODE_LOW_LUX:
1053		if (c0data == 0x4800 || c1data == 0x4800)
1054			lux = CT406_ALS_LOW_TO_HIGH_THRESHOLD;
1055		else if (ratio <= 51)
1056			lux = (121*c0data - 227*c1data) / 100;
1057		else if (ratio <= 58)
1058			lux = (40*c0data - 68*c1data) / 100;
1059		else
1060			lux = 0;
1061		break;
1062	case CT406_ALS_MODE_HIGH_LUX:
1063		if (c0data == 0x4800 || c1data == 0x4800)
1064			lux = 0xFFFF;
1065		else if (ratio <= 51)
1066			lux = (964*c0data - 1818*c1data) / 100;
1067		else if (ratio <= 58)
1068			lux = (317*c0data - 544*c1data) / 100;
1069		else
1070			lux = 0;
1071		break;
1072	default:
1073		pr_err("%s: ALS mode is %d!\n", __func__, ct->als_mode);
1074	}
1075
1076	/* input.c filters consecutive LED_MISC values <=1. */
1077       lux = (lux >= 2) ? (lux * 2) : 2;
1078	
1079       if( lux > 0xFFFF )
1080           lux = 0xFFFF;
1081
1082	input_event(ct->dev, EV_LED, LED_MISC, lux);
1083	input_sync(ct->dev);
1084
1085	if (ct->als_first_report == 0) {
1086		/* write ALS interrupt persistence */
1087		reg_data[0] = CT406_PERS;
1088		reg_data[1] = CT406_PERS_PPERS | ct->als_apers;
1089		error = ct406_i2c_write(ct, reg_data, 1);
1090		if (error < 0) {
1091			pr_err("%s: Error  %d\n", __func__, error);
1092		}
1093		ct->als_first_report = 1;
1094	}
1095
1096	if (ct->als_mode != CT406_ALS_MODE_SUNLIGHT)
1097		ct406_check_als_range(ct, lux);
1098
1099	ct406_clear_als_flag(ct);
1100
1101	if (ct->als_mode == CT406_ALS_MODE_SUNLIGHT)
1102		ct406_enable_prox(ct); /* re-check saturation */
1103}
1104
1105static int ct406_misc_open(struct inode *inode, struct file *file)
1106{
1107	int err;
1108
1109	err = nonseekable_open(inode, file);
1110	if (err < 0)
1111		return err;
1112
1113	file->private_data = ct406_misc_data;
1114
1115	return 0;
1116}
1117
1118static int ct406_als_enable_param;
1119
1120static int ct406_set_als_enable_param(const char *char_value,
1121        struct kernel_param *kp)
1122{
1123        unsigned long int_value;
1124        int  ret;
1125
1126        if (!char_value)
1127                return -EINVAL;
1128
1129        if (!ct406_misc_data)
1130                return -EINVAL;
1131
1132        ret = strict_strtoul(char_value, (unsigned int)0, &int_value);
1133        if (ret)
1134                return ret;
1135
1136        *((int *)kp->arg) = int_value;
1137
1138	mutex_lock(&ct406_misc_data->mutex);
1139
1140	ct406_misc_data->als_requested = (int_value != 0);
1141	if (ct406_debug & CT406_DBG_INPUT)
1142		pr_info("%s: als enable = %d\n", __func__,
1143			ct406_misc_data->als_requested);
1144        if (ct406_misc_data->als_requested)
1145                ret = ct406_enable_als(ct406_misc_data);
1146        else
1147                ret = ct406_disable_als(ct406_misc_data);
1148
1149	mutex_unlock(&ct406_misc_data->mutex);
1150
1151        return ret;
1152}
1153
1154static int ct406_get_als_enable_param(char *buffer, struct kernel_param *kp)
1155{
1156        int num_chars;
1157
1158        if (!buffer)
1159                return -EINVAL;
1160
1161        if (!ct406_misc_data) {
1162                scnprintf(buffer, PAGE_SIZE, "0\n");
1163                return 1;
1164        }
1165
1166        num_chars = scnprintf(buffer, 2, "%d\n",
1167                ct406_misc_data->als_requested);
1168
1169        return num_chars;
1170}
1171
1172module_param_call(als_enable, ct406_set_als_enable_param, ct406_get_als_enable_param,
1173        &ct406_als_enable_param, 0644);
1174MODULE_PARM_DESC(als_enable, "Enable/disable the ALS.");
1175
1176static int ct406_prox_enable_param;
1177
1178static int ct406_set_prox_enable_param(const char *char_value,
1179        struct kernel_param *kp)
1180{
1181        unsigned long int_value;
1182        int  ret;
1183
1184        if (!char_value)
1185                return -EINVAL;
1186
1187        if (!ct406_misc_data)
1188                return -EINVAL;
1189
1190        ret = strict_strtoul(char_value, (unsigned int)0, &int_value);
1191        if (ret)
1192                return ret;
1193
1194        *((int *)kp->arg) = int_value;
1195
1196	mutex_lock(&ct406_misc_data->mutex);
1197
1198	ct406_misc_data->prox_requested = (int_value != 0);
1199	if (ct406_debug & CT406_DBG_INPUT)
1200		pr_info("%s: prox enable = %d\n", __func__,
1201			ct406_misc_data->prox_requested);
1202        if (ct406_misc_data->prox_requested)
1203                ret = ct406_enable_prox(ct406_misc_data);
1204        else
1205                ret = ct406_disable_prox(ct406_misc_data);
1206
1207	mutex_unlock(&ct406_misc_data->mutex);
1208
1209        return ret;
1210}
1211
1212static int ct406_get_prox_enable_param(char *buffer, struct kernel_param *kp)
1213{
1214        int num_chars;
1215
1216        if (!buffer)
1217                return -EINVAL;
1218
1219        if (!ct406_misc_data) {
1220                scnprintf(buffer, PAGE_SIZE, "0\n");
1221                return 1;
1222        }
1223
1224        num_chars = scnprintf(buffer, 2, "%d\n",
1225                ct406_misc_data->prox_requested);
1226
1227        return num_chars;
1228}
1229
1230module_param_call(prox_enable, ct406_set_prox_enable_param, ct406_get_prox_enable_param,
1231        &ct406_prox_enable_param, 0644);
1232MODULE_PARM_DESC(prox_enable, "Enable/disable the Prox.");
1233
1234static int ct406_als_delay_param;
1235
1236static int ct406_set_als_delay_param(const char *char_value,
1237        struct kernel_param *kp)
1238{
1239        unsigned long int_value;
1240        int  ret;
1241
1242        if (!char_value)
1243                return -EINVAL;
1244
1245        if (!ct406_misc_data)
1246                return -EINVAL;
1247
1248        ret = strict_strtoul(char_value, (unsigned int)0, &int_value);
1249        if (ret)
1250                return ret;
1251
1252        *((int *)kp->arg) = int_value;
1253
1254	mutex_lock(&ct406_misc_data->mutex);
1255
1256	ct406_als_delay_param = int_value;
1257	if (ct406_debug & CT406_DBG_INPUT)
1258		pr_info("%s: delay = %d\n", __func__, ct406_als_delay_param);
1259
1260	if (ct406_als_delay_param > 982)
1261		ct406_misc_data->als_apers = 0x07;
1262	else if (ct406_als_delay_param > 737)
1263		ct406_misc_data->als_apers = 0x06;
1264	else if (ct406_als_delay_param > 491)
1265		ct406_misc_data->als_apers = 0x05;
1266	else if (ct406_als_delay_param > 245)
1267		ct406_misc_data->als_apers = 0x04;
1268	else if (ct406_als_delay_param > 147)
1269		ct406_misc_data->als_apers = 0x03;
1270	else if (ct406_als_delay_param > 98)
1271		ct406_misc_data->als_apers = 0x02;
1272	else
1273		ct406_misc_data->als_apers = 0x01;
1274
1275	if (ct406_misc_data->als_enabled
1276		&& (ct406_misc_data->als_mode != CT406_ALS_MODE_SUNLIGHT)) {
1277		ct406_disable_als(ct406_misc_data);
1278		ct406_enable_als(ct406_misc_data);
1279	}
1280
1281	mutex_unlock(&ct406_misc_data->mutex);
1282
1283        return ret;
1284}
1285
1286static int ct406_get_als_delay_param(char *buffer, struct kernel_param *kp)
1287{
1288        int num_chars;
1289
1290        if (!buffer)
1291                return -EINVAL;
1292
1293        if (!ct406_misc_data) {
1294                scnprintf(buffer, PAGE_SIZE, "0\n");
1295                return 1;
1296        }
1297
1298        num_chars = scnprintf(buffer, 2, "%d\n", ct406_als_delay_param);
1299
1300        return num_chars;
1301}
1302
1303module_param_call(als_delay, ct406_set_als_delay_param, ct406_get_als_delay_param,
1304        &ct406_als_delay_param, 0644);
1305MODULE_PARM_DESC(als_delay, "Set ALS delay.");
1306
1307static const struct file_operations ct406_misc_fops = {
1308	.owner = THIS_MODULE,
1309	.open = ct406_misc_open,
1310};
1311
1312static ssize_t ct406_registers_show(struct device *dev,
1313				    struct device_attribute *attr,
1314				    char *buf)
1315{
1316	struct i2c_client *client = container_of(dev, struct i2c_client, dev);
1317	struct ct406_data *ct = i2c_get_clientdata(client);
1318	int error = 0;
1319	unsigned int i, n, reg_count;
1320	u8 reg_data[1] = {0};
1321
1322	reg_count = sizeof(ct406_regs) / sizeof(ct406_regs[0]);
1323	mutex_lock(&ct->mutex);
1324	for (i = 0, n = 0; i < reg_count; i++) {
1325		reg_data[0] = ct406_regs[i].reg;
1326		error = ct406_i2c_read(ct, reg_data, 1);
1327		n += scnprintf(buf + n, PAGE_SIZE - n,
1328			"%-20s = 0x%02X\n",
1329			ct406_regs[i].name,
1330			reg_data[0]);
1331	}
1332	mutex_unlock(&ct->mutex);
1333
1334	return n;
1335}
1336
1337static ssize_t ct406_registers_store(struct device *dev,
1338				     struct device_attribute *attr,
1339				     const char *buf,
1340				     size_t count)
1341{
1342	struct i2c_client *client = container_of(dev, struct i2c_client, dev);
1343	struct ct406_data *ct = i2c_get_clientdata(client);
1344	unsigned int i, reg_count;
1345	unsigned int value;
1346	u8 reg_data[2] = {0};
1347	int error;
1348	char name[30];
1349
1350	if (count >= 30) {
1351		pr_err("%s:input too long\n", __func__);
1352		return -EMSGSIZE;
1353	}
1354
1355	if (sscanf(buf, "%30s %x", name, &value) != 2) {
1356		pr_err("%s:unable to parse input\n", __func__);
1357		return -EINVAL;
1358	}
1359
1360	reg_count = sizeof(ct406_regs) / sizeof(ct406_regs[0]);
1361	for (i = 0; i < reg_count; i++) {
1362		if (!strcmp(name, ct406_regs[i].name)) {
1363			mutex_lock(&ct->mutex);
1364			error = ct406_i2c_write(ct, reg_data, 1);
1365			mutex_unlock(&ct->mutex);
1366			if (error) {
1367				pr_err("%s:Failed to write register %s\n",
1368					__func__, name);
1369				return error;
1370			}
1371			return count;
1372		}
1373	}
1374
1375	pr_err("%s:no such register %s\n", __func__, name);
1376	return -EINVAL;
1377}
1378
1379static DEVICE_ATTR(registers, 0644, ct406_registers_show,
1380		   ct406_registers_store);
1381
1382static irqreturn_t ct406_irq_handler(int irq, void *dev)
1383{
1384	struct ct406_data *ct = dev;
1385
1386	disable_irq_nosync(ct->client->irq);
1387	queue_work(ct->workqueue, &ct->work);
1388
1389	return IRQ_HANDLED;
1390}
1391
1392static void ct406_work_func_locked(struct ct406_data *ct)
1393{
1394	int error;
1395	u8 reg_data[1] = {0};
1396	reg_data[0] = CT406_STATUS;
1397	error = ct406_i2c_read(ct, reg_data, 1);
1398	if (error < 0) {
1399		pr_err("%s: Unable to read interrupt register: %d\n",
1400			__func__, error);
1401		return;
1402	}
1403
1404	if (ct->als_enabled && (reg_data[0] & CT406_STATUS_AINT))
1405		ct406_report_als(ct);
1406
1407	if (ct->prox_enabled && (reg_data[0] & CT406_STATUS_PINT))
1408		ct406_report_prox(ct);
1409}
1410
1411static void ct406_work_func(struct work_struct *work)
1412{
1413	struct ct406_data *ct =
1414		container_of(work, struct ct406_data, work);
1415
1416	mutex_lock(&ct->mutex);
1417	if (ct->regs_initialized)
1418		ct406_work_func_locked(ct);
1419	mutex_unlock(&ct->mutex);
1420
1421	enable_irq(ct->client->irq);
1422}
1423
1424#ifdef CONFIG_HAS_EARLYSUSPEND
1425static void ct406_suspend(struct early_suspend *handler)
1426{
1427	if (ct406_debug & CT406_DBG_SUSPEND_RESUME)
1428		pr_info("%s\n", __func__);
1429
1430	mutex_lock(&ct406_misc_data->mutex);
1431
1432	ct406_disable_als(ct406_misc_data);
1433
1434	if (!ct406_misc_data->prox_requested)
1435		ct406_device_power_off(ct406_misc_data);
1436
1437	ct406_misc_data->suspended = 1;
1438
1439	mutex_unlock(&ct406_misc_data->mutex);
1440}
1441
1442static void ct406_resume(struct early_suspend *handler)
1443{
1444	if (ct406_debug & CT406_DBG_SUSPEND_RESUME)
1445		pr_info("%s\n", __func__);
1446
1447	mutex_lock(&ct406_misc_data->mutex);
1448
1449	ct406_device_power_on(ct406_misc_data);
1450	ct406_device_init(ct406_misc_data);
1451
1452	ct406_misc_data->suspended = 0;
1453
1454	if (ct406_misc_data->als_requested)
1455		ct406_enable_als(ct406_misc_data);
1456
1457	mutex_unlock(&ct406_misc_data->mutex);
1458}
1459#endif /* CONFIG_HAS_EARLYSUSPEND */
1460
1461static int ct406_probe(struct i2c_client *client,
1462		       const struct i2c_device_id *id)
1463{
1464	struct ct406_platform_data *pdata = client->dev.platform_data;
1465	struct ct406_data *ct;
1466	u8 reg_data[1] = {0};
1467	int error = 0;
1468
1469	if (pdata == NULL) {
1470		pr_err("%s: platform data required\n", __func__);
1471		return -ENODEV;
1472	}
1473
1474	client->irq = pdata->irq;
1475	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1476		pr_err("%s:I2C_FUNC_I2C not supported\n", __func__);
1477		return -ENODEV;
1478	}
1479
1480	ct = kzalloc(sizeof(struct ct406_data), GFP_KERNEL);
1481	if (ct == NULL) {
1482		error = -ENOMEM;
1483		goto error_alloc_data_failed;
1484	}
1485
1486	ct->client = client;
1487	ct->pdata = pdata;
1488
1489	if (ct->pdata->regulator_name[0] != '\0') {
1490		ct->regulator = regulator_get(NULL,
1491			ct->pdata->regulator_name);
1492		if (IS_ERR(ct->regulator)) {
1493			pr_err("%s: cannot acquire regulator [%s]\n",
1494				__func__, ct->pdata->regulator_name);
1495			error = PTR_ERR(ct->regulator);
1496			goto error_regulator_get_failed;
1497		}
1498	}
1499
1500	ct->dev = input_allocate_device();
1501	if (!ct->dev) {
1502		error = -ENOMEM;
1503		pr_err("%s: input device allocate failed: %d\n", __func__,
1504			error);
1505		goto error_input_allocate_failed;
1506	}
1507
1508	ct->dev->name = "light-prox";
1509	input_set_capability(ct->dev, EV_LED, LED_MISC);
1510	input_set_capability(ct->dev, EV_MSC, MSC_RAW);
1511
1512	ct406_misc_data = ct;
1513	ct->miscdevice.minor = MISC_DYNAMIC_MINOR;
1514	ct->miscdevice.name = LD_CT406_NAME;
1515	ct->miscdevice.fops = &ct406_misc_fops;
1516	error = misc_register(&ct->miscdevice);
1517	if (error < 0) {
1518		pr_err("%s: misc_register failed\n", __func__);
1519		goto error_misc_register_failed;
1520	}
1521
1522	ct->regs_initialized = 0;
1523	ct->suspended = 0;
1524
1525	ct->oscillator_enabled = 0;
1526	ct->prox_requested = 0;
1527	ct->prox_enabled = 0;
1528	ct->prox_mode = CT406_PROX_MODE_SATURATED;
1529	ct->als_requested = 0;
1530	ct->als_enabled = 0;
1531	ct->als_apers = 0x4;
1532	ct->als_first_report = 0;
1533	ct->als_mode = CT406_ALS_MODE_LOW_LUX;
1534
1535	ct->workqueue = create_singlethread_workqueue("als_wq");
1536	if (!ct->workqueue) {
1537		pr_err("%s: Cannot create work queue\n", __func__);
1538		error = -ENOMEM;
1539		goto error_create_wq_failed;
1540	}
1541
1542	INIT_WORK(&ct->work, ct406_work_func);
1543
1544	error = request_irq(client->irq, ct406_irq_handler,
1545		IRQF_TRIGGER_LOW, LD_CT406_NAME, ct);
1546	if (error != 0) {
1547		pr_err("%s: irq request failed: %d\n", __func__, error);
1548		error = -ENODEV;
1549		goto error_req_irq_failed;
1550	}
1551	enable_irq_wake(client->irq);
1552	disable_irq(client->irq);
1553
1554	i2c_set_clientdata(client, ct);
1555
1556	mutex_init(&ct->mutex);
1557
1558	error = input_register_device(ct->dev);
1559	if (error) {
1560		pr_err("%s: input device register failed:%d\n", __func__,
1561			error);
1562		goto error_input_register_failed;
1563	}
1564
1565	error = device_create_file(&client->dev, &dev_attr_registers);
1566	if (error < 0) {
1567		pr_err("%s:File device creation failed: %d\n", __func__, error);
1568		error = -ENODEV;
1569		goto error_create_registers_file_failed;
1570	}
1571
1572	error = ct406_device_power_on(ct);
1573	if (error) {
1574		pr_err("%s:power_on failed: %d\n", __func__, error);
1575		goto error_power_on_failed;
1576	}
1577
1578	reg_data[0] = CT406_REV_ID;
1579	error = ct406_i2c_read(ct, reg_data, 1);
1580	if (error < 0) {
1581		pr_err("%s: revision read failed: %d\n", __func__, error);
1582		goto error_revision_read_failed;
1583	}
1584	if (reg_data[0] == CT40X_REV_ID_CT405) {
1585		pr_info("%s: CT405 part detected\n", __func__);
1586		ct->prox_saturation_threshold
1587			= ct->pdata->ct405_prox_saturation_threshold;
1588		ct->prox_covered_offset = ct->pdata->ct405_prox_covered_offset;
1589		ct->prox_uncovered_offset
1590			= ct->pdata->ct405_prox_uncovered_offset;
1591		ct->prox_recalibrate_offset
1592			= ct->pdata->ct405_prox_recalibrate_offset;
1593		ct->prox_pulse_count = ct->pdata->ct405_prox_pulse_count;
1594		ct->prox_offset = ct->pdata->ct405_prox_offset;
1595		ct->pdata_max = CT405_PDATA_MAX;
1596		ct->hw_type = CT405_HW_TYPE;
1597	} else {
1598		pr_info("%s: CT406 part detected\n", __func__);
1599		ct->prox_saturation_threshold
1600			= ct->pdata->ct406_prox_saturation_threshold;
1601		ct->prox_covered_offset = ct->pdata->ct406_prox_covered_offset;
1602		ct->prox_uncovered_offset
1603			= ct->pdata->ct406_prox_uncovered_offset;
1604		ct->prox_recalibrate_offset
1605			= ct->pdata->ct406_prox_recalibrate_offset;
1606		ct->prox_pulse_count = ct->pdata->ct406_prox_pulse_count;
1607		ct->prox_offset = ct->pdata->ct406_prox_offset;
1608		ct->pdata_max = CT406_PDATA_MAX;
1609		ct->hw_type = CT406_HW_TYPE;
1610	}
1611
1612	error = ct406_device_init(ct);
1613	if (error) {
1614		pr_err("%s:device init failed: %d\n", __func__, error);
1615		goto error_revision_read_failed;
1616	}
1617
1618#ifdef CONFIG_HAS_EARLYSUSPEND
1619        ct->ct406_early_suspend.suspend = ct406_suspend;
1620        ct->ct406_early_suspend.resume = ct406_resume;
1621        register_early_suspend(&ct->ct406_early_suspend);
1622#endif
1623
1624	return 0;
1625
1626error_revision_read_failed:
1627	ct406_device_power_off(ct);
1628error_power_on_failed:
1629	device_remove_file(&client->dev, &dev_attr_registers);
1630error_create_registers_file_failed:
1631	input_unregister_device(ct->dev);
1632	ct->dev = NULL;
1633error_input_register_failed:
1634	mutex_destroy(&ct->mutex);
1635	i2c_set_clientdata(client, NULL);
1636	free_irq(ct->client->irq, ct);
1637error_req_irq_failed:
1638	destroy_workqueue(ct->workqueue);
1639error_create_wq_failed:
1640	misc_deregister(&ct->miscdevice);
1641error_misc_register_failed:
1642	ct406_misc_data = NULL;
1643	input_free_device(ct->dev);
1644error_input_allocate_failed:
1645	regulator_put(ct->regulator);
1646error_regulator_get_failed:
1647	kfree(ct);
1648error_alloc_data_failed:
1649	return error;
1650}
1651
1652static int ct406_remove(struct i2c_client *client)
1653{
1654	struct ct406_data *ct = i2c_get_clientdata(client);
1655
1656	device_remove_file(&client->dev, &dev_attr_registers);
1657
1658	ct406_device_power_off(ct);
1659
1660	input_unregister_device(ct->dev);
1661
1662	mutex_destroy(&ct->mutex);
1663	i2c_set_clientdata(client, NULL);
1664	free_irq(ct->client->irq, ct);
1665
1666	destroy_workqueue(ct->workqueue);
1667
1668	misc_deregister(&ct->miscdevice);
1669
1670	regulator_put(ct->regulator);
1671
1672	kfree(ct);
1673
1674	return 0;
1675}
1676
1677static const struct i2c_device_id ct406_id[] = {
1678	{LD_CT406_NAME, 0},
1679	{}
1680};
1681
1682static struct i2c_driver ct406_i2c_driver = {
1683	.probe		= ct406_probe,
1684	.remove		= ct406_remove,
1685	.id_table	= ct406_id,
1686	.driver = {
1687		.name = LD_CT406_NAME,
1688		.owner = THIS_MODULE,
1689	},
1690};
1691
1692static int __init ct406_init(void)
1693{
1694	return i2c_add_driver(&ct406_i2c_driver);
1695}
1696
1697static void __exit ct406_exit(void)
1698{
1699	i2c_del_driver(&ct406_i2c_driver);
1700}
1701
1702module_init(ct406_init);
1703module_exit(ct406_exit);
1704
1705MODULE_DESCRIPTION("ALS and Proximity driver for CT406");
1706MODULE_AUTHOR("Motorola Mobility");
1707MODULE_LICENSE("GPL");