Initial file dump from open source releaseHEADmaster

86 files changed, 60295 insertions, 0 deletions

diff --git a/drivers/input/misc/88pm80x_onkey.c b/drivers/input/misc/88pm80x_onkey.c
new file mode 100644
index 00000000..ee43e5b7
--- /dev/null
+++ b/drivers/input/misc/88pm80x_onkey.c
@@ -0,0 +1,168 @@
+/*
+ * Marvell 88PM80x ONKEY driver
+ *
+ * Copyright (C) 2012 Marvell International Ltd.
+ * Haojian Zhuang <haojian.zhuang@marvell.com>
+ * Qiao Zhou <zhouqiao@marvell.com>
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License. See the file "COPYING" in the main directory of this
+ * archive for more details.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/input.h>
+#include <linux/mfd/88pm80x.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+
+#define PM800_LONG_ONKEY_EN		(1 << 0)
+#define PM800_LONG_KEY_DELAY		(8)	/* 1 .. 16 seconds */
+#define PM800_LONKEY_PRESS_TIME		((PM800_LONG_KEY_DELAY-1) << 4)
+#define PM800_LONKEY_PRESS_TIME_MASK	(0xF0)
+#define PM800_SW_PDOWN			(1 << 5)
+
+struct pm80x_onkey_info {
+	struct input_dev *idev;
+	struct pm80x_chip *pm80x;
+	struct regmap *map;
+	int irq;
+};
+
+/* 88PM80x gives us an interrupt when ONKEY is held */
+static irqreturn_t pm80x_onkey_handler(int irq, void *data)
+{
+	struct pm80x_onkey_info *info = data;
+	int ret = 0;
+	unsigned int val;
+
+	ret = regmap_read(info->map, PM800_STATUS_1, &val);
+	if (ret < 0) {
+		dev_err(info->idev->dev.parent, "failed to read status: %d\n", ret);
+		return IRQ_NONE;
+	}
+	val &= PM800_ONKEY_STS1;
+
+	input_report_key(info->idev, KEY_POWER, val);
+	input_sync(info->idev);
+
+	return IRQ_HANDLED;
+}
+
+static SIMPLE_DEV_PM_OPS(pm80x_onkey_pm_ops, pm80x_dev_suspend,
+			 pm80x_dev_resume);
+
+static int pm80x_onkey_probe(struct platform_device *pdev)
+{
+
+	struct pm80x_chip *chip = dev_get_drvdata(pdev->dev.parent);
+	struct pm80x_onkey_info *info;
+	int err;
+
+	info = kzalloc(sizeof(struct pm80x_onkey_info), GFP_KERNEL);
+	if (!info)
+		return -ENOMEM;
+
+	info->pm80x = chip;
+
+	info->irq = platform_get_irq(pdev, 0);
+	if (info->irq < 0) {
+		dev_err(&pdev->dev, "No IRQ resource!\n");
+		err = -EINVAL;
+		goto out;
+	}
+
+	info->map = info->pm80x->regmap;
+	if (!info->map) {
+		dev_err(&pdev->dev, "no regmap!\n");
+		err = -EINVAL;
+		goto out;
+	}
+
+	info->idev = input_allocate_device();
+	if (!info->idev) {
+		dev_err(&pdev->dev, "Failed to allocate input dev\n");
+		err = -ENOMEM;
+		goto out;
+	}
+
+	info->idev->name = "88pm80x_on";
+	info->idev->phys = "88pm80x_on/input0";
+	info->idev->id.bustype = BUS_I2C;
+	info->idev->dev.parent = &pdev->dev;
+	info->idev->evbit[0] = BIT_MASK(EV_KEY);
+	__set_bit(KEY_POWER, info->idev->keybit);
+
+	err = pm80x_request_irq(info->pm80x, info->irq, pm80x_onkey_handler,
+					    IRQF_ONESHOT, "onkey", info);
+	if (err < 0) {
+		dev_err(&pdev->dev, "Failed to request IRQ: #%d: %d\n",
+			info->irq, err);
+		goto out_reg;
+	}
+
+	err = input_register_device(info->idev);
+	if (err) {
+		dev_err(&pdev->dev, "Can't register input device: %d\n", err);
+		goto out_irq;
+	}
+
+	platform_set_drvdata(pdev, info);
+
+	/* Enable long onkey detection */
+	regmap_update_bits(info->map, PM800_RTC_MISC4, PM800_LONG_ONKEY_EN,
+			   PM800_LONG_ONKEY_EN);
+	/* Set 8-second interval */
+	regmap_update_bits(info->map, PM800_RTC_MISC3,
+			   PM800_LONKEY_PRESS_TIME_MASK,
+			   PM800_LONKEY_PRESS_TIME);
+
+	device_init_wakeup(&pdev->dev, 1);
+	return 0;
+
+out_irq:
+	pm80x_free_irq(info->pm80x, info->irq, info);
+out_reg:
+	input_free_device(info->idev);
+out:
+	kfree(info);
+	return err;
+}
+
+static int pm80x_onkey_remove(struct platform_device *pdev)
+{
+	struct pm80x_onkey_info *info = platform_get_drvdata(pdev);
+
+	device_init_wakeup(&pdev->dev, 0);
+	pm80x_free_irq(info->pm80x, info->irq, info);
+	input_unregister_device(info->idev);
+	kfree(info);
+	return 0;
+}
+
+static struct platform_driver pm80x_onkey_driver = {
+	.driver = {
+		   .name = "88pm80x-onkey",
+		   .owner = THIS_MODULE,
+		   .pm = &pm80x_onkey_pm_ops,
+		   },
+	.probe = pm80x_onkey_probe,
+	.remove = pm80x_onkey_remove,
+};
+
+module_platform_driver(pm80x_onkey_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Marvell 88PM80x ONKEY driver");
+MODULE_AUTHOR("Qiao Zhou <zhouqiao@marvell.com>");
+MODULE_ALIAS("platform:88pm80x-onkey");
diff --git a/drivers/input/misc/88pm860x_onkey.c b/drivers/input/misc/88pm860x_onkey.c
new file mode 100644
index 00000000..abd8453e
--- /dev/null
+++ b/drivers/input/misc/88pm860x_onkey.c
@@ -0,0 +1,170 @@
+/*
+ * 88pm860x_onkey.c - Marvell 88PM860x ONKEY driver
+ *
+ * Copyright (C) 2009-2010 Marvell International Ltd.
+ *      Haojian Zhuang <haojian.zhuang@marvell.com>
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License. See the file "COPYING" in the main directory of this
+ * archive for more details.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/88pm860x.h>
+#include <linux/slab.h>
+
+#define PM8607_WAKEUP		0x0b
+
+#define LONG_ONKEY_EN		(1 << 1)
+#define ONKEY_STATUS		(1 << 0)
+
+struct pm860x_onkey_info {
+	struct input_dev	*idev;
+	struct pm860x_chip	*chip;
+	struct i2c_client	*i2c;
+	struct device		*dev;
+	int			irq;
+};
+
+/* 88PM860x gives us an interrupt when ONKEY is held */
+static irqreturn_t pm860x_onkey_handler(int irq, void *data)
+{
+	struct pm860x_onkey_info *info = data;
+	int ret;
+
+	ret = pm860x_reg_read(info->i2c, PM8607_STATUS_2);
+	ret &= ONKEY_STATUS;
+	input_report_key(info->idev, KEY_POWER, ret);
+	input_sync(info->idev);
+
+	/* Enable 8-second long onkey detection */
+	pm860x_set_bits(info->i2c, PM8607_WAKEUP, 3, LONG_ONKEY_EN);
+	return IRQ_HANDLED;
+}
+
+static int pm860x_onkey_probe(struct platform_device *pdev)
+{
+	struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
+	struct pm860x_onkey_info *info;
+	int irq, ret;
+
+	irq = platform_get_irq(pdev, 0);
+	if (irq < 0) {
+		dev_err(&pdev->dev, "No IRQ resource!\n");
+		return -EINVAL;
+	}
+
+	info = kzalloc(sizeof(struct pm860x_onkey_info), GFP_KERNEL);
+	if (!info)
+		return -ENOMEM;
+	info->chip = chip;
+	info->i2c = (chip->id == CHIP_PM8607) ? chip->client : chip->companion;
+	info->dev = &pdev->dev;
+	info->irq = irq;
+
+	info->idev = input_allocate_device();
+	if (!info->idev) {
+		dev_err(chip->dev, "Failed to allocate input dev\n");
+		ret = -ENOMEM;
+		goto out;
+	}
+
+	info->idev->name = "88pm860x_on";
+	info->idev->phys = "88pm860x_on/input0";
+	info->idev->id.bustype = BUS_I2C;
+	info->idev->dev.parent = &pdev->dev;
+	info->idev->evbit[0] = BIT_MASK(EV_KEY);
+	info->idev->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
+
+	ret = input_register_device(info->idev);
+	if (ret) {
+		dev_err(chip->dev, "Can't register input device: %d\n", ret);
+		goto out_reg;
+	}
+
+	ret = request_threaded_irq(info->irq, NULL, pm860x_onkey_handler,
+				   IRQF_ONESHOT, "onkey", info);
+	if (ret < 0) {
+		dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
+			info->irq, ret);
+		goto out_irq;
+	}
+
+	platform_set_drvdata(pdev, info);
+	device_init_wakeup(&pdev->dev, 1);
+
+	return 0;
+
+out_irq:
+	input_unregister_device(info->idev);
+	kfree(info);
+	return ret;
+
+out_reg:
+	input_free_device(info->idev);
+out:
+	kfree(info);
+	return ret;
+}
+
+static int pm860x_onkey_remove(struct platform_device *pdev)
+{
+	struct pm860x_onkey_info *info = platform_get_drvdata(pdev);
+
+	free_irq(info->irq, info);
+	input_unregister_device(info->idev);
+	kfree(info);
+	return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int pm860x_onkey_suspend(struct device *dev)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
+
+	if (device_may_wakeup(dev))
+		chip->wakeup_flag |= 1 << PM8607_IRQ_ONKEY;
+	return 0;
+}
+static int pm860x_onkey_resume(struct device *dev)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
+
+	if (device_may_wakeup(dev))
+		chip->wakeup_flag &= ~(1 << PM8607_IRQ_ONKEY);
+	return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(pm860x_onkey_pm_ops, pm860x_onkey_suspend, pm860x_onkey_resume);
+
+static struct platform_driver pm860x_onkey_driver = {
+	.driver		= {
+		.name	= "88pm860x-onkey",
+		.owner	= THIS_MODULE,
+		.pm	= &pm860x_onkey_pm_ops,
+	},
+	.probe		= pm860x_onkey_probe,
+	.remove		= pm860x_onkey_remove,
+};
+module_platform_driver(pm860x_onkey_driver);
+
+MODULE_DESCRIPTION("Marvell 88PM860x ONKEY driver");
+MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
new file mode 100644
index 00000000..08e1faf2
--- /dev/null
+++ b/drivers/input/misc/Kconfig
@@ -0,0 +1,776 @@
+#
+# Input misc drivers configuration
+#
+menuconfig INPUT_MISC
+	bool "Miscellaneous devices"
+	help
+	  Say Y here, and a list of miscellaneous input drivers will be displayed.
+	  Everything that didn't fit into the other categories is here. This option
+	  doesn't affect the kernel.
+
+	  If unsure, say Y.
+
+if INPUT_MISC
+
+config INPUT_88PM860X_ONKEY
+	tristate "88PM860x ONKEY support"
+	depends on MFD_88PM860X
+	help
+	  Support the ONKEY of Marvell 88PM860x PMICs as an input device
+	  reporting power button status.
+
+	  To compile this driver as a module, choose M here: the module
+	  will be called 88pm860x_onkey.
+
+config INPUT_88PM80X_ONKEY
+	tristate "88PM80x ONKEY support"
+	depends on MFD_88PM800
+	help
+	  Support the ONKEY of Marvell 88PM80x PMICs as an input device
+	  reporting power button status.
+
+	  To compile this driver as a module, choose M here: the module
+	  will be called 88pm80x_onkey.
+
+config INPUT_AB8500_PONKEY
+	tristate "AB8500 Pon (PowerOn) Key"
+	depends on AB8500_CORE
+	help
+	  Say Y here to use the PowerOn Key for ST-Ericsson's AB8500
+	  Mix-Sig PMIC.
+
+	  To compile this driver as a module, choose M here: the module
+	  will be called ab8500-ponkey.
+
+config INPUT_AD714X
+	tristate "Analog Devices AD714x Capacitance Touch Sensor"
+	help
+	  Say Y here if you want to support an AD7142/3/7/8/7A touch sensor.
+
+	  You should select a bus connection too.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called ad714x.
+
+config INPUT_AD714X_I2C
+	tristate "support I2C bus connection"
+	depends on INPUT_AD714X && I2C
+	default y
+	help
+	  Say Y here if you have AD7142/AD7147 hooked to an I2C bus.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called ad714x-i2c.
+
+config INPUT_AD714X_SPI
+	tristate "support SPI bus connection"
+	depends on INPUT_AD714X && SPI
+	default y
+	help
+	  Say Y here if you have AD7142/AD7147 hooked to a SPI bus.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called ad714x-spi.
+
+config INPUT_ARIZONA_HAPTICS
+	tristate "Arizona haptics support"
+	depends on MFD_ARIZONA && SND_SOC
+	select INPUT_FF_MEMLESS
+	help
+	  Say Y to enable support for the haptics module in Arizona CODECs.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called arizona-haptics.
+
+config INPUT_BMA150
+	tristate "BMA150/SMB380 acceleration sensor support"
+	depends on I2C
+	select INPUT_POLLDEV
+	help
+	  Say Y here if you have Bosch Sensortec's BMA150 or SMB380
+	  acceleration sensor hooked to an I2C bus.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called bma150.
+
+config INPUT_PCSPKR
+	tristate "PC Speaker support"
+	depends on PCSPKR_PLATFORM
+	help
+	  Say Y here if you want the standard PC Speaker to be used for
+	  bells and whistles.
+
+	  If unsure, say Y.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called pcspkr.
+
+config INPUT_PM8XXX_VIBRATOR
+	tristate "Qualcomm PM8XXX vibrator support"
+	depends on MFD_PM8XXX
+	select INPUT_FF_MEMLESS
+	help
+	  This option enables device driver support for the vibrator
+	  on Qualcomm PM8xxx chip. This driver supports ff-memless interface
+	  from input framework.
+
+	  To compile this driver as module, choose M here: the
+	  module will be called pm8xxx-vibrator.
+
+config INPUT_PMIC8XXX_PWRKEY
+	tristate "PMIC8XXX power key support"
+	depends on MFD_PM8XXX
+	help
+	  Say Y here if you want support for the PMIC8XXX power key.
+
+	  If unsure, say N.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called pmic8xxx-pwrkey.
+
+config INPUT_SPARCSPKR
+	tristate "SPARC Speaker support"
+	depends on PCI && SPARC64
+	help
+	  Say Y here if you want the standard Speaker on Sparc PCI systems
+	  to be used for bells and whistles.
+
+	  If unsure, say Y.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called sparcspkr.
+
+config INPUT_M68K_BEEP
+	tristate "M68k Beeper support"
+	depends on M68K
+
+config INPUT_MAX8925_ONKEY
+	tristate "MAX8925 ONKEY support"
+	depends on MFD_MAX8925
+	help
+	  Support the ONKEY of MAX8925 PMICs as an input device
+	  reporting power button status.
+
+	  To compile this driver as a module, choose M here: the module
+	  will be called max8925_onkey.
+
+config INPUT_MAX8997_HAPTIC
+	tristate "MAXIM MAX8997 haptic controller support"
+	depends on HAVE_PWM && MFD_MAX8997
+	select INPUT_FF_MEMLESS
+	help
+	  This option enables device driver support for the haptic controller
+	  on MAXIM MAX8997 chip. This driver supports ff-memless interface
+	  from input framework.
+
+	  To compile this driver as module, choose M here: the
+	  module will be called max8997-haptic.
+
+config INPUT_MC13783_PWRBUTTON
+	tristate "MC13783 ON buttons"
+	depends on MFD_MC13783
+	help
+	  Support the ON buttons of MC13783 PMIC as an input device
+	  reporting power button status.
+
+	  To compile this driver as a module, choose M here: the module
+	  will be called mc13783-pwrbutton.
+
+config INPUT_MMA8450
+	tristate "MMA8450 - Freescale's 3-Axis, 8/12-bit Digital Accelerometer"
+	depends on I2C
+	select INPUT_POLLDEV
+	help
+	  Say Y here if you want to support Freescale's MMA8450 Accelerometer
+	  through I2C interface.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called mma8450.
+
+config INPUT_MPU3050
+	tristate "MPU3050 Triaxial gyroscope sensor"
+	depends on I2C
+	help
+	  Say Y here if you want to support InvenSense MPU3050
+	  connected via an I2C bus.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called mpu3050.
+
+config INPUT_APANEL
+	tristate "Fujitsu Lifebook Application Panel buttons"
+	depends on X86 && I2C && LEDS_CLASS
+	select INPUT_POLLDEV
+	select CHECK_SIGNATURE
+	help
+	 Say Y here for support of the Application Panel buttons, used on
+	 Fujitsu Lifebook. These are attached to the mainboard through
+	 an SMBus interface managed by the I2C Intel ICH (i801) driver,
+	 which you should also build for this kernel.
+
+	 To compile this driver as a module, choose M here: the module will
+	 be called apanel.
+
+config INPUT_GP2A
+	tristate "Sharp GP2AP002A00F I2C Proximity/Opto sensor driver"
+	depends on I2C
+	depends on GPIOLIB
+	help
+	  Say Y here if you have a Sharp GP2AP002A00F proximity/als combo-chip
+	  hooked to an I2C bus.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called gp2ap002a00f.
+
+config INPUT_GPIO_TILT_POLLED
+	tristate "Polled GPIO tilt switch"
+	depends on GPIOLIB
+	select INPUT_POLLDEV
+	help
+	  This driver implements support for tilt switches connected
+	  to GPIO pins that are not capable of generating interrupts.
+
+	  The list of gpios to use and the mapping of their states
+	  to specific angles is done via platform data.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called gpio_tilt_polled.
+
+config INPUT_IXP4XX_BEEPER
+	tristate "IXP4XX Beeper support"
+	depends on ARCH_IXP4XX
+	help
+	  If you say yes here, you can connect a beeper to the
+	  ixp4xx gpio pins. This is used by the LinkSys NSLU2.
+
+	  If unsure, say Y.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called ixp4xx-beeper.
+
+config INPUT_COBALT_BTNS
+	tristate "Cobalt button interface"
+	depends on MIPS_COBALT
+	select INPUT_POLLDEV
+	help
+	  Say Y here if you want to support MIPS Cobalt button interface.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called cobalt_btns.
+
+config INPUT_WISTRON_BTNS
+	tristate "x86 Wistron laptop button interface"
+	depends on X86 && !X86_64
+	select INPUT_POLLDEV
+	select INPUT_SPARSEKMAP
+	select NEW_LEDS
+	select LEDS_CLASS
+	select CHECK_SIGNATURE
+	help
+	  Say Y here for support of Wistron laptop button interfaces, used on
+	  laptops of various brands, including Acer and Fujitsu-Siemens. If
+	  available, mail and wifi LEDs will be controllable via /sys/class/leds.
+
+	  To compile this driver as a module, choose M here: the module will
+	  be called wistron_btns.
+
+config INPUT_ATLAS_BTNS
+	tristate "x86 Atlas button interface"
+	depends on X86 && ACPI
+	help
+	  Say Y here for support of Atlas wallmount touchscreen buttons.
+	  The events will show up as scancodes F1 through F9 via evdev.
+
+	  To compile this driver as a module, choose M here: the module will
+	  be called atlas_btns.
+
+config INPUT_ATI_REMOTE2
+	tristate "ATI / Philips USB RF remote control"
+	depends on USB_ARCH_HAS_HCD
+	select USB
+	help
+	  Say Y here if you want to use an ATI or Philips USB RF remote control.
+	  These are RF remotes with USB receivers.
+	  ATI Remote Wonder II comes with some ATI's All-In-Wonder video cards
+	  and is also available as a separate product.
+	  This driver provides mouse pointer, left and right mouse buttons,
+	  and maps all the other remote buttons to keypress events.
+
+	  To compile this driver as a module, choose M here: the module will be
+	  called ati_remote2.
+
+config INPUT_KEYCHORD
+	tristate "Key chord input driver support"
+	help
+	  Say Y here if you want to enable the key chord driver
+	  accessible at /dev/keychord.  This driver can be used
+	  for receiving notifications when client specified key
+	  combinations are pressed.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called keychord.
+
+config INPUT_KEYSPAN_REMOTE
+	tristate "Keyspan DMR USB remote control"
+	depends on USB_ARCH_HAS_HCD
+	select USB
+	help
+	  Say Y here if you want to use a Keyspan DMR USB remote control.
+	  Currently only the UIA-11 type of receiver has been tested.  The tag
+	  on the receiver that connects to the USB port should have a P/N that
+	  will tell you what type of DMR you have.  The UIA-10 type is not
+	  supported at this time.  This driver maps all buttons to keypress
+	  events.
+
+	  To compile this driver as a module, choose M here: the module will
+	  be called keyspan_remote.
+
+config INPUT_KXTJ9
+	tristate "Kionix KXTJ9 tri-axis digital accelerometer"
+	depends on I2C
+	help
+	  Say Y here to enable support for the Kionix KXTJ9 digital tri-axis
+	  accelerometer.
+
+	  To compile this driver as a module, choose M here: the module will
+	  be called kxtj9.
+
+config INPUT_KXTJ9_POLLED_MODE
+	bool "Enable polling mode support"
+	depends on INPUT_KXTJ9
+	select INPUT_POLLDEV
+	help
+	  Say Y here if you need accelerometer to work in polling mode.
+
+config INPUT_POWERMATE
+	tristate "Griffin PowerMate and Contour Jog support"
+	depends on USB_ARCH_HAS_HCD
+	select USB
+	help
+	  Say Y here if you want to use Griffin PowerMate or Contour Jog devices.
+	  These are aluminum dials which can measure clockwise and anticlockwise
+	  rotation.  The dial also acts as a pushbutton.  The base contains an LED
+	  which can be instructed to pulse or to switch to a particular intensity.
+
+	  You can download userspace tools from
+	  <http://sowerbutts.com/powermate/>.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called powermate.
+
+config INPUT_YEALINK
+	tristate "Yealink usb-p1k voip phone"
+	depends on USB_ARCH_HAS_HCD
+	select USB
+	help
+	  Say Y here if you want to enable keyboard and LCD functions of the
+	  Yealink usb-p1k usb phones. The audio part is enabled by the generic
+	  usb sound driver, so you might want to enable that as well.
+
+	  For information about how to use these additional functions, see
+	  <file:Documentation/input/yealink.txt>.
+
+	  To compile this driver as a module, choose M here: the module will be
+	  called yealink.
+
+config INPUT_CM109
+	tristate "C-Media CM109 USB I/O Controller"
+	depends on USB_ARCH_HAS_HCD
+	select USB
+	help
+	  Say Y here if you want to enable keyboard and buzzer functions of the
+	  C-Media CM109 usb phones. The audio part is enabled by the generic
+	  usb sound driver, so you might want to enable that as well.
+
+	  To compile this driver as a module, choose M here: the module will be
+	  called cm109.
+
+config INPUT_RETU_PWRBUTTON
+	tristate "Retu Power button Driver"
+	depends on MFD_RETU
+	help
+	  Say Y here if you want to enable power key reporting via the
+	  Retu chips found in Nokia Internet Tablets (770, N800, N810).
+
+	  To compile this driver as a module, choose M here. The module will
+	  be called retu-pwrbutton.
+
+config INPUT_TWL4030_PWRBUTTON
+	tristate "TWL4030 Power button Driver"
+	depends on TWL4030_CORE
+	help
+	  Say Y here if you want to enable power key reporting via the
+	  TWL4030 family of chips.
+
+	  To compile this driver as a module, choose M here. The module will
+	  be called twl4030_pwrbutton.
+
+config INPUT_TWL4030_VIBRA
+	tristate "Support for TWL4030 Vibrator"
+	depends on TWL4030_CORE
+	select MFD_TWL4030_AUDIO
+	select INPUT_FF_MEMLESS
+	help
+	  This option enables support for TWL4030 Vibrator Driver.
+
+	  To compile this driver as a module, choose M here. The module will
+	  be called twl4030_vibra.
+
+config INPUT_TWL6040_VIBRA
+	tristate "Support for TWL6040 Vibrator"
+	depends on TWL6040_CORE
+	select INPUT_FF_MEMLESS
+	help
+	  This option enables support for TWL6040 Vibrator Driver.
+
+	  To compile this driver as a module, choose M here. The module will
+	  be called twl6040_vibra.
+
+config INPUT_UINPUT
+	tristate "User level driver support"
+	help
+	  Say Y here if you want to support user level drivers for input
+	  subsystem accessible under char device 10:223 - /dev/input/uinput.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called uinput.
+
+config INPUT_SGI_BTNS
+	tristate "SGI Indy/O2 volume button interface"
+	depends on SGI_IP22 || SGI_IP32
+	select INPUT_POLLDEV
+	help
+	  Say Y here if you want to support SGI Indy/O2 volume button interface.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called sgi_btns.
+
+config INPUT_GPIO
+	tristate "GPIO driver support"
+	help
+	  Say Y here if you want to support gpio based keys, wheels etc...
+
+config HP_SDC_RTC
+	tristate "HP SDC Real Time Clock"
+	depends on (GSC || HP300) && SERIO
+	select HP_SDC
+	help
+	  Say Y here if you want to support the built-in real time clock
+	  of the HP SDC controller.
+
+config INPUT_PCF50633_PMU
+	tristate "PCF50633 PMU events"
+	depends on MFD_PCF50633
+	help
+	 Say Y to include support for delivering  PMU events via  input
+	 layer on NXP PCF50633.
+
+config INPUT_PCF8574
+	tristate "PCF8574 Keypad input device"
+	depends on I2C
+	help
+	  Say Y here if you want to support a keypad connected via I2C
+	  with a PCF8574.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called pcf8574_keypad.
+
+config INPUT_PWM_BEEPER
+	tristate "PWM beeper support"
+	depends on HAVE_PWM || PWM
+	help
+	  Say Y here to get support for PWM based beeper devices.
+
+	  If unsure, say N.
+
+	  To compile this driver as a module, choose M here: the module will be
+	  called pwm-beeper.
+
+config INPUT_GPIO_ROTARY_ENCODER
+	tristate "Rotary encoders connected to GPIO pins"
+	depends on GPIOLIB
+	help
+	  Say Y here to add support for rotary encoders connected to GPIO lines.
+	  Check file:Documentation/input/rotary-encoder.txt for more
+	  information.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called rotary_encoder.
+
+config INPUT_RB532_BUTTON
+	tristate "Mikrotik Routerboard 532 button interface"
+	depends on MIKROTIK_RB532
+	depends on GPIOLIB
+	select INPUT_POLLDEV
+	help
+	  Say Y here if you want support for the S1 button built into
+	  Mikrotik's Routerboard 532.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called rb532_button.
+
+config INPUT_DA9052_ONKEY
+	tristate "Dialog DA9052/DA9053 Onkey"
+	depends on PMIC_DA9052
+	help
+	  Support the ONKEY of Dialog DA9052 PMICs as an input device
+	  reporting power button status.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called da9052_onkey.
+
+config INPUT_DA9055_ONKEY
+	tristate "Dialog Semiconductor DA9055 ONKEY"
+	depends on MFD_DA9055
+	help
+	  Support the ONKEY of DA9055 PMICs as an input device
+	  reporting power button status.
+
+	  To compile this driver as a module, choose M here: the module
+	  will be called da9055_onkey.
+
+config INPUT_DM355EVM
+	tristate "TI DaVinci DM355 EVM Keypad and IR Remote"
+	depends on MFD_DM355EVM_MSP
+	select INPUT_SPARSEKMAP
+	help
+	  Supports the pushbuttons and IR remote used with
+	  the DM355 EVM board.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called dm355evm_keys.
+
+config INPUT_BFIN_ROTARY
+	tristate "Blackfin Rotary support"
+	depends on BF54x || BF52x
+	help
+	  Say Y here if you want to use the Blackfin Rotary.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called bfin-rotary.
+
+config INPUT_WM831X_ON
+	tristate "WM831X ON pin"
+	depends on MFD_WM831X
+	help
+	  Support the ON pin of WM831X PMICs as an input device
+	  reporting power button status.
+
+	  To compile this driver as a module, choose M here: the module
+	  will be called wm831x_on.
+
+config INPUT_PCAP
+	tristate "Motorola EZX PCAP misc input events"
+	depends on EZX_PCAP
+	help
+	  Say Y here if you want to use Power key and Headphone button
+	  on Motorola EZX phones.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called pcap_keys.
+
+config INPUT_ADXL34X
+	tristate "Analog Devices ADXL34x Three-Axis Digital Accelerometer"
+	default n
+	help
+	  Say Y here if you have a Accelerometer interface using the
+	  ADXL345/6 controller, and your board-specific initialization
+	  code includes that in its table of devices.
+
+	  This driver can use either I2C or SPI communication to the
+	  ADXL345/6 controller.  Select the appropriate method for
+	  your system.
+
+	  If unsure, say N (but it's safe to say "Y").
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called adxl34x.
+
+config INPUT_ADXL34X_I2C
+	tristate "support I2C bus connection"
+	depends on INPUT_ADXL34X && I2C
+	default y
+	help
+	  Say Y here if you have ADXL345/6 hooked to an I2C bus.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called adxl34x-i2c.
+
+config INPUT_ADXL34X_SPI
+	tristate "support SPI bus connection"
+	depends on INPUT_ADXL34X && SPI
+	default y
+	help
+	  Say Y here if you have ADXL345/6 hooked to a SPI bus.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called adxl34x-spi.
+
+config INPUT_IMS_PCU
+	tristate "IMS Passenger Control Unit driver"
+	depends on USB
+	depends on LEDS_CLASS
+	help
+	  Say Y here if you have system with IMS Rave Passenger Control Unit.
+
+	  To compile this driver as a module, choose M here: the module will be
+	  called ims_pcu.
+
+config INPUT_CMA3000
+	tristate "VTI CMA3000 Tri-axis accelerometer"
+	help
+	  Say Y here if you want to use VTI CMA3000_D0x Accelerometer
+	  driver
+
+	  This driver currently only supports I2C interface to the
+	  controller. Also select the I2C method.
+
+	  If unsure, say N
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called cma3000_d0x.
+
+config INPUT_CMA3000_I2C
+	tristate "Support I2C bus connection"
+	depends on INPUT_CMA3000 && I2C
+	help
+	  Say Y here if you want to use VTI CMA3000_D0x Accelerometer
+	  through I2C interface.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called cma3000_d0x_i2c.
+
+config INPUT_XEN_KBDDEV_FRONTEND
+	tristate "Xen virtual keyboard and mouse support"
+	depends on XEN
+	default y
+	select XEN_XENBUS_FRONTEND
+	help
+	  This driver implements the front-end of the Xen virtual
+	  keyboard and mouse device driver.  It communicates with a back-end
+	  in another domain.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called xen-kbdfront.
+
+config INPUT_HEADSET_SPRD_SC2723
+     tristate "SPRD SC2723 builtin headset & button detect driver"
+     default n
+     help
+       Say Y here if you are using SPRD platform.
+
+       To compile this driver as a module, choose M here: the
+       module will be called headset.
+
+config INPUT_SPRD_HEADSET_SHARK
+     tristate "SPRD platform builtin headset & button detect driver"
+     help
+       Say Y here if you are using SPRD platform.
+
+       To compile this driver as a module, choose M here: the
+       module will be called headset.
+
+config  HEADSET_KEY_VOLUME_SUPPORTED
+	bool "HEADSET_KEY_VOLUME_SUPPORTED"
+	depends on INPUT_SPRD_HEADSET_SHARK
+	help
+	  Say Y to enable HEADSET_KEY_VOLUME_SUPPORT.
+
+config  HEADSET_EXTERNAL_HEADMICBIAS_POWER_SUPPORTED
+	bool "HEADSET_EXTERNAL_HEADMICBIAS_POWER_SUPPORTED"
+	depends on INPUT_SPRD_HEADSET_SHARK
+	help
+	  Say Y to enable HEADSET_EXTERNAL_HEADMICBIAS_POWER_SUPPORT.
+
+config  HEADSET_STS_POLLING_DISABLED
+	bool "HEADSET_STS_POLLING_DISABLED"
+	depends on INPUT_SPRD_HEADSET_SHARK
+	help
+	  Say Y to disable HEADSET_STS_POLLING.
+
+config  HEADSET_AUXADC_CAL_SUPPORTED
+	bool "HEADSET_AUXADC_CAL_SUPPORTED"
+	depends on INPUT_SPRD_HEADSET_SHARK
+	help
+	  Say Y to enable HEADSET_AUXADC_CAL_SUPPORTED.
+	  
+#add by lgd
+config  CAMERA_POLE_SUPPORT
+	bool "CAMERA_POLE_SUPPORT"
+	depends on INPUT_SPRD_HEADSET_SHARK
+	help
+	  Say Y to enable camera pole support.
+
+config INPUT_LIS3DH_I2C
+	tristate "ST lid3dh 3-Axid accelerometer device with I2C bus"
+	depends on I2C
+	default n
+	help
+	  Say Y here if you have a lis3dh device on the board and use I2C
+	  communication, else say N.
+
+	  To compile this driver as a module, choose M here.
+
+config INPUT_LIS3DH_I2C_INTERRUPT
+	tristate "ST lid3dh 3-Axid accelerometer device with I2C bus  for interrupt mode"
+	depends on I2C
+	default n
+	help
+	  Say Y here if you have a lis3dh device on the board and use I2C
+	  communication, else say N.
+
+	  To compile this driver as a module, choose M here.
+
+config INPUT_LIS3DH_ZT_I2C
+	tristate "ST lid3dh_zt 3-Axid accelerometer device with I2C bus"
+	depends on I2C
+	default n
+	help
+	  Say Y here if you have a lis3dh_zt device on the board and use I2C
+	  communication, else say N.
+
+	  To compile this driver as a module, choose M here.
+
+config INPUT_LTR558_I2C
+	tristate "LTR558 proximity and light sensor device with I2C bus"
+	depends on I2C
+	default n
+	help
+	  Say Y here if you have a LTR558 device on the board and use I2C
+	  communication, else say N.
+
+config INPUT_STK3X1X_I2C
+	tristate "STK3X1X proximity and light sensor device with I2C bus"
+	depends on I2C
+	default n
+	help
+	  Say Y here if you have a LTR558 device on the board and use I2C
+	  communication, else say N.
+	  
+	  To compile this driver as a module, choose M here.
+config INPUT_SENSORS_BMA2X2
+	tristate "BMA2x2 acceleration sensor support"
+	depends on I2C
+	help
+	To compile this driver as a module, choose M here.
+	
+config INPUT_EPL2182_I2C
+	tristate "epl2182 proximity and light sensor device with I2C bus"
+	depends on I2C
+	default n
+	help
+	  Say Y here if you have a epl2182 device on the board and use I2C
+	  communication, else say N.
+
+	  To compile this driver as a module, choose M here.
+
+config INPUT_EPL259X_I2C
+	tristate "epl259x proximity and light sensor device with I2C bus"
+	depends on I2C
+	default n
+	help
+	  Say Y here if you have a epl259x device on the board and use I2C
+	  communication, else say N.
+
+	  To compile this driver as a module, choose M here.
+endif
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
new file mode 100644
index 00000000..201efeac
--- /dev/null
+++ b/drivers/input/misc/Makefile
@@ -0,0 +1,81 @@
+#
+# Makefile for the input misc drivers.
+#
+
+# Each configuration option enables a list of files.
+
+obj-$(CONFIG_INPUT_88PM860X_ONKEY)	+= 88pm860x_onkey.o
+obj-$(CONFIG_INPUT_88PM80X_ONKEY)	+= 88pm80x_onkey.o
+obj-$(CONFIG_INPUT_AB8500_PONKEY)	+= ab8500-ponkey.o
+obj-$(CONFIG_INPUT_AD714X)		+= ad714x.o
+obj-$(CONFIG_INPUT_AD714X_I2C)		+= ad714x-i2c.o
+obj-$(CONFIG_INPUT_AD714X_SPI)		+= ad714x-spi.o
+obj-$(CONFIG_INPUT_ADXL34X)		+= adxl34x.o
+obj-$(CONFIG_INPUT_ADXL34X_I2C)		+= adxl34x-i2c.o
+obj-$(CONFIG_INPUT_ADXL34X_SPI)		+= adxl34x-spi.o
+obj-$(CONFIG_INPUT_APANEL)		+= apanel.o
+obj-$(CONFIG_INPUT_ARIZONA_HAPTICS)	+= arizona-haptics.o
+obj-$(CONFIG_INPUT_ATI_REMOTE2)		+= ati_remote2.o
+obj-$(CONFIG_INPUT_ATLAS_BTNS)		+= atlas_btns.o
+obj-$(CONFIG_INPUT_BFIN_ROTARY)		+= bfin_rotary.o
+obj-$(CONFIG_INPUT_BMA150)		+= bma150.o
+obj-$(CONFIG_INPUT_CM109)		+= cm109.o
+obj-$(CONFIG_INPUT_CMA3000)		+= cma3000_d0x.o
+obj-$(CONFIG_INPUT_CMA3000_I2C)		+= cma3000_d0x_i2c.o
+obj-$(CONFIG_INPUT_COBALT_BTNS)		+= cobalt_btns.o
+obj-$(CONFIG_INPUT_DA9052_ONKEY)	+= da9052_onkey.o
+obj-$(CONFIG_INPUT_DA9055_ONKEY)	+= da9055_onkey.o
+obj-$(CONFIG_INPUT_DM355EVM)		+= dm355evm_keys.o
+obj-$(CONFIG_INPUT_GP2A)		+= gp2ap002a00f.o
+obj-$(CONFIG_INPUT_GPIO_TILT_POLLED)	+= gpio_tilt_polled.o
+obj-$(CONFIG_INPUT_GPIO)		+= gpio_event.o gpio_matrix.o gpio_input.o gpio_output.o gpio_axis.o
+obj-$(CONFIG_HP_SDC_RTC)		+= hp_sdc_rtc.o
+obj-$(CONFIG_INPUT_IMS_PCU)		+= ims-pcu.o
+obj-$(CONFIG_INPUT_IXP4XX_BEEPER)	+= ixp4xx-beeper.o
+obj-$(CONFIG_INPUT_KEYCHORD)		+= keychord.o
+obj-$(CONFIG_INPUT_KEYSPAN_REMOTE)	+= keyspan_remote.o
+obj-$(CONFIG_INPUT_KXTJ9)		+= kxtj9.o
+obj-$(CONFIG_INPUT_M68K_BEEP)		+= m68kspkr.o
+obj-$(CONFIG_INPUT_MAX8925_ONKEY)	+= max8925_onkey.o
+obj-$(CONFIG_INPUT_MAX8997_HAPTIC)	+= max8997_haptic.o
+obj-$(CONFIG_INPUT_MC13783_PWRBUTTON)	+= mc13783-pwrbutton.o
+obj-$(CONFIG_INPUT_MMA8450)		+= mma8450.o
+obj-$(CONFIG_INPUT_MPU3050)		+= mpu3050.o
+obj-$(CONFIG_INPUT_PCAP)		+= pcap_keys.o
+obj-$(CONFIG_INPUT_PCF50633_PMU)	+= pcf50633-input.o
+obj-$(CONFIG_INPUT_PCF8574)		+= pcf8574_keypad.o
+obj-$(CONFIG_INPUT_PCSPKR)		+= pcspkr.o
+obj-$(CONFIG_INPUT_PM8XXX_VIBRATOR)	+= pm8xxx-vibrator.o
+obj-$(CONFIG_INPUT_PMIC8XXX_PWRKEY)	+= pmic8xxx-pwrkey.o
+obj-$(CONFIG_INPUT_POWERMATE)		+= powermate.o
+obj-$(CONFIG_INPUT_PWM_BEEPER)		+= pwm-beeper.o
+obj-$(CONFIG_INPUT_RB532_BUTTON)	+= rb532_button.o
+obj-$(CONFIG_INPUT_RETU_PWRBUTTON)	+= retu-pwrbutton.o
+obj-$(CONFIG_INPUT_GPIO_ROTARY_ENCODER)	+= rotary_encoder.o
+obj-$(CONFIG_INPUT_SGI_BTNS)		+= sgi_btns.o
+obj-$(CONFIG_INPUT_SPARCSPKR)		+= sparcspkr.o
+obj-$(CONFIG_INPUT_TWL4030_PWRBUTTON)	+= twl4030-pwrbutton.o
+obj-$(CONFIG_INPUT_TWL4030_VIBRA)	+= twl4030-vibra.o
+obj-$(CONFIG_INPUT_TWL6040_VIBRA)	+= twl6040-vibra.o
+obj-$(CONFIG_INPUT_UINPUT)		+= uinput.o
+obj-$(CONFIG_INPUT_WISTRON_BTNS)	+= wistron_btns.o
+obj-$(CONFIG_INPUT_WM831X_ON)		+= wm831x-on.o
+obj-$(CONFIG_INPUT_XEN_KBDDEV_FRONTEND)	+= xen-kbdfront.o
+obj-$(CONFIG_INPUT_YEALINK)		+= yealink.o
+obj-$(CONFIG_INPUT_LTR558_I2C)		+= ltr_558als.o
+obj-$(CONFIG_INPUT_EPL2182_I2C)         += epl2182_pls_v2.o
+obj-$(CONFIG_INPUT_EPL259X_I2C)         += epl259x.o
+obj-$(CONFIG_INPUT_LIS3DH_I2C)          += lis3dh.o
+obj-$(CONFIG_INPUT_LIS3DH_I2C_INTERRUPT)+= lis3dh_interrupt.o
+obj-$(CONFIG_INPUT_LIS3DH_ZT_I2C)          += lis3dh_zt.o
+obj-$(CONFIG_INPUT_SPRD_HEADSET_SHARK)  += headset_sprd.o
+obj-$(CONFIG_INPUT_HEADSET_SPRD_SC2723)  += headset_sprd_sc2723.o
+obj-$(CONFIG_INPUT_STK3X1X_I2C)  += stk3x1x.o
+obj-$(CONFIG_INPUT_SENSORS_BMA2X2)	+= bstclass.o bma2x2.o 
+ifeq ($(CONFIG_SENSORS_BMA2X2_ENABLE_INT1),y)
+	EXTRA_CFLAGS += -DBMA2X2_ENABLE_INT1
+endif
+
+ifeq ($(CONFIG_BOSCH_BMA2X2_ENABLE_INT2),y)
+	EXTRA_CFLAGS += -DBMA2X2_ENABLE_INT2
+endif
diff --git a/drivers/input/misc/ab8500-ponkey.c b/drivers/input/misc/ab8500-ponkey.c
new file mode 100644
index 00000000..2f090b46
--- /dev/null
+++ b/drivers/input/misc/ab8500-ponkey.c
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License Terms: GNU General Public License v2
+ * Author: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
+ *
+ * AB8500 Power-On Key handler
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/abx500/ab8500.h>
+#include <linux/of.h>
+#include <linux/slab.h>
+
+/**
+ * struct ab8500_ponkey - ab8500 ponkey information
+ * @input_dev: pointer to input device
+ * @ab8500: ab8500 parent
+ * @irq_dbf: irq number for falling transition
+ * @irq_dbr: irq number for rising transition
+ */
+struct ab8500_ponkey {
+	struct input_dev	*idev;
+	struct ab8500		*ab8500;
+	int			irq_dbf;
+	int			irq_dbr;
+};
+
+/* AB8500 gives us an interrupt when ONKEY is held */
+static irqreturn_t ab8500_ponkey_handler(int irq, void *data)
+{
+	struct ab8500_ponkey *ponkey = data;
+
+	if (irq == ponkey->irq_dbf)
+		input_report_key(ponkey->idev, KEY_POWER, true);
+	else if (irq == ponkey->irq_dbr)
+		input_report_key(ponkey->idev, KEY_POWER, false);
+
+	input_sync(ponkey->idev);
+
+	return IRQ_HANDLED;
+}
+
+static int ab8500_ponkey_probe(struct platform_device *pdev)
+{
+	struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
+	struct ab8500_ponkey *ponkey;
+	struct input_dev *input;
+	int irq_dbf, irq_dbr;
+	int error;
+
+	irq_dbf = platform_get_irq_byname(pdev, "ONKEY_DBF");
+	if (irq_dbf < 0) {
+		dev_err(&pdev->dev, "No IRQ for ONKEY_DBF, error=%d\n", irq_dbf);
+		return irq_dbf;
+	}
+
+	irq_dbr = platform_get_irq_byname(pdev, "ONKEY_DBR");
+	if (irq_dbr < 0) {
+		dev_err(&pdev->dev, "No IRQ for ONKEY_DBR, error=%d\n", irq_dbr);
+		return irq_dbr;
+	}
+
+	ponkey = kzalloc(sizeof(struct ab8500_ponkey), GFP_KERNEL);
+	input = input_allocate_device();
+	if (!ponkey || !input) {
+		error = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	ponkey->idev = input;
+	ponkey->ab8500 = ab8500;
+	ponkey->irq_dbf = irq_dbf;
+	ponkey->irq_dbr = irq_dbr;
+
+	input->name = "AB8500 POn(PowerOn) Key";
+	input->dev.parent = &pdev->dev;
+
+	input_set_capability(input, EV_KEY, KEY_POWER);
+
+	error = request_any_context_irq(ponkey->irq_dbf, ab8500_ponkey_handler,
+					0, "ab8500-ponkey-dbf", ponkey);
+	if (error < 0) {
+		dev_err(ab8500->dev, "Failed to request dbf IRQ#%d: %d\n",
+			ponkey->irq_dbf, error);
+		goto err_free_mem;
+	}
+
+	error = request_any_context_irq(ponkey->irq_dbr, ab8500_ponkey_handler,
+					0, "ab8500-ponkey-dbr", ponkey);
+	if (error < 0) {
+		dev_err(ab8500->dev, "Failed to request dbr IRQ#%d: %d\n",
+			ponkey->irq_dbr, error);
+		goto err_free_dbf_irq;
+	}
+
+	error = input_register_device(ponkey->idev);
+	if (error) {
+		dev_err(ab8500->dev, "Can't register input device: %d\n", error);
+		goto err_free_dbr_irq;
+	}
+
+	platform_set_drvdata(pdev, ponkey);
+	return 0;
+
+err_free_dbr_irq:
+	free_irq(ponkey->irq_dbr, ponkey);
+err_free_dbf_irq:
+	free_irq(ponkey->irq_dbf, ponkey);
+err_free_mem:
+	input_free_device(input);
+	kfree(ponkey);
+
+	return error;
+}
+
+static int ab8500_ponkey_remove(struct platform_device *pdev)
+{
+	struct ab8500_ponkey *ponkey = platform_get_drvdata(pdev);
+
+	free_irq(ponkey->irq_dbf, ponkey);
+	free_irq(ponkey->irq_dbr, ponkey);
+	input_unregister_device(ponkey->idev);
+	kfree(ponkey);
+
+	platform_set_drvdata(pdev, NULL);
+
+	return 0;
+}
+
+#ifdef CONFIG_OF
+static const struct of_device_id ab8500_ponkey_match[] = {
+	{ .compatible = "stericsson,ab8500-ponkey", },
+	{}
+};
+#endif
+
+static struct platform_driver ab8500_ponkey_driver = {
+	.driver		= {
+		.name	= "ab8500-poweron-key",
+		.owner	= THIS_MODULE,
+		.of_match_table = of_match_ptr(ab8500_ponkey_match),
+	},
+	.probe		= ab8500_ponkey_probe,
+	.remove		= ab8500_ponkey_remove,
+};
+module_platform_driver(ab8500_ponkey_driver);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Sundar Iyer <sundar.iyer@stericsson.com>");
+MODULE_DESCRIPTION("ST-Ericsson AB8500 Power-ON(Pon) Key driver");
diff --git a/drivers/input/misc/ad714x-i2c.c b/drivers/input/misc/ad714x-i2c.c
new file mode 100644
index 00000000..e0f52251
--- /dev/null
+++ b/drivers/input/misc/ad714x-i2c.c
@@ -0,0 +1,123 @@
+/*
+ * AD714X CapTouch Programmable Controller driver (I2C bus)
+ *
+ * Copyright 2009-2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/input.h>	/* BUS_I2C */
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/pm.h>
+#include "ad714x.h"
+
+#ifdef CONFIG_PM_SLEEP
+static int ad714x_i2c_suspend(struct device *dev)
+{
+	return ad714x_disable(i2c_get_clientdata(to_i2c_client(dev)));
+}
+
+static int ad714x_i2c_resume(struct device *dev)
+{
+	return ad714x_enable(i2c_get_clientdata(to_i2c_client(dev)));
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(ad714x_i2c_pm, ad714x_i2c_suspend, ad714x_i2c_resume);
+
+static int ad714x_i2c_write(struct ad714x_chip *chip,
+			    unsigned short reg, unsigned short data)
+{
+	struct i2c_client *client = to_i2c_client(chip->dev);
+	int error;
+
+	chip->xfer_buf[0] = cpu_to_be16(reg);
+	chip->xfer_buf[1] = cpu_to_be16(data);
+
+	error = i2c_master_send(client, (u8 *)chip->xfer_buf,
+				2 * sizeof(*chip->xfer_buf));
+	if (unlikely(error < 0)) {
+		dev_err(&client->dev, "I2C write error: %d\n", error);
+		return error;
+	}
+
+	return 0;
+}
+
+static int ad714x_i2c_read(struct ad714x_chip *chip,
+			   unsigned short reg, unsigned short *data, size_t len)
+{
+	struct i2c_client *client = to_i2c_client(chip->dev);
+	int i;
+	int error;
+
+	chip->xfer_buf[0] = cpu_to_be16(reg);
+
+	error = i2c_master_send(client, (u8 *)chip->xfer_buf,
+				sizeof(*chip->xfer_buf));
+	if (error >= 0)
+		error = i2c_master_recv(client, (u8 *)chip->xfer_buf,
+					len * sizeof(*chip->xfer_buf));
+
+	if (unlikely(error < 0)) {
+		dev_err(&client->dev, "I2C read error: %d\n", error);
+		return error;
+	}
+
+	for (i = 0; i < len; i++)
+		data[i] = be16_to_cpu(chip->xfer_buf[i]);
+
+	return 0;
+}
+
+static int ad714x_i2c_probe(struct i2c_client *client,
+					const struct i2c_device_id *id)
+{
+	struct ad714x_chip *chip;
+
+	chip = ad714x_probe(&client->dev, BUS_I2C, client->irq,
+			    ad714x_i2c_read, ad714x_i2c_write);
+	if (IS_ERR(chip))
+		return PTR_ERR(chip);
+
+	i2c_set_clientdata(client, chip);
+
+	return 0;
+}
+
+static int ad714x_i2c_remove(struct i2c_client *client)
+{
+	struct ad714x_chip *chip = i2c_get_clientdata(client);
+
+	ad714x_remove(chip);
+
+	return 0;
+}
+
+static const struct i2c_device_id ad714x_id[] = {
+	{ "ad7142_captouch", 0 },
+	{ "ad7143_captouch", 0 },
+	{ "ad7147_captouch", 0 },
+	{ "ad7147a_captouch", 0 },
+	{ "ad7148_captouch", 0 },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, ad714x_id);
+
+static struct i2c_driver ad714x_i2c_driver = {
+	.driver = {
+		.name = "ad714x_captouch",
+		.pm   = &ad714x_i2c_pm,
+	},
+	.probe    = ad714x_i2c_probe,
+	.remove   = ad714x_i2c_remove,
+	.id_table = ad714x_id,
+};
+
+module_i2c_driver(ad714x_i2c_driver);
+
+MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor I2C Bus Driver");
+MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/ad714x-spi.c b/drivers/input/misc/ad714x-spi.c
new file mode 100644
index 00000000..61891486
--- /dev/null
+++ b/drivers/input/misc/ad714x-spi.c
@@ -0,0 +1,130 @@
+/*
+ * AD714X CapTouch Programmable Controller driver (SPI bus)
+ *
+ * Copyright 2009-2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/input.h>	/* BUS_SPI */
+#include <linux/module.h>
+#include <linux/spi/spi.h>
+#include <linux/pm.h>
+#include <linux/types.h>
+#include "ad714x.h"
+
+#define AD714x_SPI_CMD_PREFIX      0xE000   /* bits 15:11 */
+#define AD714x_SPI_READ            BIT(10)
+
+#ifdef CONFIG_PM_SLEEP
+static int ad714x_spi_suspend(struct device *dev)
+{
+	return ad714x_disable(spi_get_drvdata(to_spi_device(dev)));
+}
+
+static int ad714x_spi_resume(struct device *dev)
+{
+	return ad714x_enable(spi_get_drvdata(to_spi_device(dev)));
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(ad714x_spi_pm, ad714x_spi_suspend, ad714x_spi_resume);
+
+static int ad714x_spi_read(struct ad714x_chip *chip,
+			   unsigned short reg, unsigned short *data, size_t len)
+{
+	struct spi_device *spi = to_spi_device(chip->dev);
+	struct spi_message message;
+	struct spi_transfer xfer[2];
+	int i;
+	int error;
+
+	spi_message_init(&message);
+	memset(xfer, 0, sizeof(xfer));
+
+	chip->xfer_buf[0] = cpu_to_be16(AD714x_SPI_CMD_PREFIX |
+					AD714x_SPI_READ | reg);
+	xfer[0].tx_buf = &chip->xfer_buf[0];
+	xfer[0].len = sizeof(chip->xfer_buf[0]);
+	spi_message_add_tail(&xfer[0], &message);
+
+	xfer[1].rx_buf = &chip->xfer_buf[1];
+	xfer[1].len = sizeof(chip->xfer_buf[1]) * len;
+	spi_message_add_tail(&xfer[1], &message);
+
+	error = spi_sync(spi, &message);
+	if (unlikely(error)) {
+		dev_err(chip->dev, "SPI read error: %d\n", error);
+		return error;
+	}
+
+	for (i = 0; i < len; i++)
+		data[i] = be16_to_cpu(chip->xfer_buf[i + 1]);
+
+	return 0;
+}
+
+static int ad714x_spi_write(struct ad714x_chip *chip,
+			    unsigned short reg, unsigned short data)
+{
+	struct spi_device *spi = to_spi_device(chip->dev);
+	int error;
+
+	chip->xfer_buf[0] = cpu_to_be16(AD714x_SPI_CMD_PREFIX | reg);
+	chip->xfer_buf[1] = cpu_to_be16(data);
+
+	error = spi_write(spi, (u8 *)chip->xfer_buf,
+			  2 * sizeof(*chip->xfer_buf));
+	if (unlikely(error)) {
+		dev_err(chip->dev, "SPI write error: %d\n", error);
+		return error;
+	}
+
+	return 0;
+}
+
+static int ad714x_spi_probe(struct spi_device *spi)
+{
+	struct ad714x_chip *chip;
+	int err;
+
+	spi->bits_per_word = 8;
+	err = spi_setup(spi);
+	if (err < 0)
+		return err;
+
+	chip = ad714x_probe(&spi->dev, BUS_SPI, spi->irq,
+			    ad714x_spi_read, ad714x_spi_write);
+	if (IS_ERR(chip))
+		return PTR_ERR(chip);
+
+	spi_set_drvdata(spi, chip);
+
+	return 0;
+}
+
+static int ad714x_spi_remove(struct spi_device *spi)
+{
+	struct ad714x_chip *chip = spi_get_drvdata(spi);
+
+	ad714x_remove(chip);
+	spi_set_drvdata(spi, NULL);
+
+	return 0;
+}
+
+static struct spi_driver ad714x_spi_driver = {
+	.driver = {
+		.name	= "ad714x_captouch",
+		.owner	= THIS_MODULE,
+		.pm	= &ad714x_spi_pm,
+	},
+	.probe		= ad714x_spi_probe,
+	.remove		= ad714x_spi_remove,
+};
+
+module_spi_driver(ad714x_spi_driver);
+
+MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor SPI Bus Driver");
+MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/ad714x.c b/drivers/input/misc/ad714x.c
new file mode 100644
index 00000000..2e5d5e1d
--- /dev/null
+++ b/drivers/input/misc/ad714x.c
@@ -0,0 +1,1261 @@
+/*
+ * AD714X CapTouch Programmable Controller driver supporting AD7142/3/7/8/7A
+ *
+ * Copyright 2009-2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/input/ad714x.h>
+#include <linux/module.h>
+#include "ad714x.h"
+
+#define AD714X_PWR_CTRL           0x0
+#define AD714X_STG_CAL_EN_REG     0x1
+#define AD714X_AMB_COMP_CTRL0_REG 0x2
+#define AD714X_PARTID_REG         0x17
+#define AD7142_PARTID             0xE620
+#define AD7143_PARTID             0xE630
+#define AD7147_PARTID             0x1470
+#define AD7148_PARTID             0x1480
+#define AD714X_STAGECFG_REG       0x80
+#define AD714X_SYSCFG_REG         0x0
+
+#define STG_LOW_INT_EN_REG     0x5
+#define STG_HIGH_INT_EN_REG    0x6
+#define STG_COM_INT_EN_REG     0x7
+#define STG_LOW_INT_STA_REG    0x8
+#define STG_HIGH_INT_STA_REG   0x9
+#define STG_COM_INT_STA_REG    0xA
+
+#define CDC_RESULT_S0          0xB
+#define CDC_RESULT_S1          0xC
+#define CDC_RESULT_S2          0xD
+#define CDC_RESULT_S3          0xE
+#define CDC_RESULT_S4          0xF
+#define CDC_RESULT_S5          0x10
+#define CDC_RESULT_S6          0x11
+#define CDC_RESULT_S7          0x12
+#define CDC_RESULT_S8          0x13
+#define CDC_RESULT_S9          0x14
+#define CDC_RESULT_S10         0x15
+#define CDC_RESULT_S11         0x16
+
+#define STAGE0_AMBIENT		0xF1
+#define STAGE1_AMBIENT		0x115
+#define STAGE2_AMBIENT		0x139
+#define STAGE3_AMBIENT		0x15D
+#define STAGE4_AMBIENT		0x181
+#define STAGE5_AMBIENT		0x1A5
+#define STAGE6_AMBIENT		0x1C9
+#define STAGE7_AMBIENT		0x1ED
+#define STAGE8_AMBIENT		0x211
+#define STAGE9_AMBIENT		0x234
+#define STAGE10_AMBIENT		0x259
+#define STAGE11_AMBIENT		0x27D
+
+#define PER_STAGE_REG_NUM      36
+#define STAGE_CFGREG_NUM       8
+#define SYS_CFGREG_NUM         8
+
+/*
+ * driver information which will be used to maintain the software flow
+ */
+enum ad714x_device_state { IDLE, JITTER, ACTIVE, SPACE };
+
+struct ad714x_slider_drv {
+	int highest_stage;
+	int abs_pos;
+	int flt_pos;
+	enum ad714x_device_state state;
+	struct input_dev *input;
+};
+
+struct ad714x_wheel_drv {
+	int abs_pos;
+	int flt_pos;
+	int pre_highest_stage;
+	int highest_stage;
+	enum ad714x_device_state state;
+	struct input_dev *input;
+};
+
+struct ad714x_touchpad_drv {
+	int x_highest_stage;
+	int x_flt_pos;
+	int x_abs_pos;
+	int y_highest_stage;
+	int y_flt_pos;
+	int y_abs_pos;
+	int left_ep;
+	int left_ep_val;
+	int right_ep;
+	int right_ep_val;
+	int top_ep;
+	int top_ep_val;
+	int bottom_ep;
+	int bottom_ep_val;
+	enum ad714x_device_state state;
+	struct input_dev *input;
+};
+
+struct ad714x_button_drv {
+	enum ad714x_device_state state;
+	/*
+	 * Unlike slider/wheel/touchpad, all buttons point to
+	 * same input_dev instance
+	 */
+	struct input_dev *input;
+};
+
+struct ad714x_driver_data {
+	struct ad714x_slider_drv *slider;
+	struct ad714x_wheel_drv *wheel;
+	struct ad714x_touchpad_drv *touchpad;
+	struct ad714x_button_drv *button;
+};
+
+/*
+ * information to integrate all things which will be private data
+ * of spi/i2c device
+ */
+
+static void ad714x_use_com_int(struct ad714x_chip *ad714x,
+				int start_stage, int end_stage)
+{
+	unsigned short data;
+	unsigned short mask;
+
+	mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
+
+	ad714x->read(ad714x, STG_COM_INT_EN_REG, &data, 1);
+	data |= 1 << end_stage;
+	ad714x->write(ad714x, STG_COM_INT_EN_REG, data);
+
+	ad714x->read(ad714x, STG_HIGH_INT_EN_REG, &data, 1);
+	data &= ~mask;
+	ad714x->write(ad714x, STG_HIGH_INT_EN_REG, data);
+}
+
+static void ad714x_use_thr_int(struct ad714x_chip *ad714x,
+				int start_stage, int end_stage)
+{
+	unsigned short data;
+	unsigned short mask;
+
+	mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
+
+	ad714x->read(ad714x, STG_COM_INT_EN_REG, &data, 1);
+	data &= ~(1 << end_stage);
+	ad714x->write(ad714x, STG_COM_INT_EN_REG, data);
+
+	ad714x->read(ad714x, STG_HIGH_INT_EN_REG, &data, 1);
+	data |= mask;
+	ad714x->write(ad714x, STG_HIGH_INT_EN_REG, data);
+}
+
+static int ad714x_cal_highest_stage(struct ad714x_chip *ad714x,
+					int start_stage, int end_stage)
+{
+	int max_res = 0;
+	int max_idx = 0;
+	int i;
+
+	for (i = start_stage; i <= end_stage; i++) {
+		if (ad714x->sensor_val[i] > max_res) {
+			max_res = ad714x->sensor_val[i];
+			max_idx = i;
+		}
+	}
+
+	return max_idx;
+}
+
+static int ad714x_cal_abs_pos(struct ad714x_chip *ad714x,
+				int start_stage, int end_stage,
+				int highest_stage, int max_coord)
+{
+	int a_param, b_param;
+
+	if (highest_stage == start_stage) {
+		a_param = ad714x->sensor_val[start_stage + 1];
+		b_param = ad714x->sensor_val[start_stage] +
+			ad714x->sensor_val[start_stage + 1];
+	} else if (highest_stage == end_stage) {
+		a_param = ad714x->sensor_val[end_stage] *
+			(end_stage - start_stage) +
+			ad714x->sensor_val[end_stage - 1] *
+			(end_stage - start_stage - 1);
+		b_param = ad714x->sensor_val[end_stage] +
+			ad714x->sensor_val[end_stage - 1];
+	} else {
+		a_param = ad714x->sensor_val[highest_stage] *
+			(highest_stage - start_stage) +
+			ad714x->sensor_val[highest_stage - 1] *
+			(highest_stage - start_stage - 1) +
+			ad714x->sensor_val[highest_stage + 1] *
+			(highest_stage - start_stage + 1);
+		b_param = ad714x->sensor_val[highest_stage] +
+			ad714x->sensor_val[highest_stage - 1] +
+			ad714x->sensor_val[highest_stage + 1];
+	}
+
+	return (max_coord / (end_stage - start_stage)) * a_param / b_param;
+}
+
+/*
+ * One button can connect to multi positive and negative of CDCs
+ * Multi-buttons can connect to same positive/negative of one CDC
+ */
+static void ad714x_button_state_machine(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_button_plat *hw = &ad714x->hw->button[idx];
+	struct ad714x_button_drv *sw = &ad714x->sw->button[idx];
+
+	switch (sw->state) {
+	case IDLE:
+		if (((ad714x->h_state & hw->h_mask) == hw->h_mask) &&
+		    ((ad714x->l_state & hw->l_mask) == hw->l_mask)) {
+			dev_dbg(ad714x->dev, "button %d touched\n", idx);
+			input_report_key(sw->input, hw->keycode, 1);
+			input_sync(sw->input);
+			sw->state = ACTIVE;
+		}
+		break;
+
+	case ACTIVE:
+		if (((ad714x->h_state & hw->h_mask) != hw->h_mask) ||
+		    ((ad714x->l_state & hw->l_mask) != hw->l_mask)) {
+			dev_dbg(ad714x->dev, "button %d released\n", idx);
+			input_report_key(sw->input, hw->keycode, 0);
+			input_sync(sw->input);
+			sw->state = IDLE;
+		}
+		break;
+
+	default:
+		break;
+	}
+}
+
+/*
+ * The response of a sensor is defined by the absolute number of codes
+ * between the current CDC value and the ambient value.
+ */
+static void ad714x_slider_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
+	int i;
+
+	ad714x->read(ad714x, CDC_RESULT_S0 + hw->start_stage,
+			&ad714x->adc_reg[hw->start_stage],
+			hw->end_stage - hw->start_stage + 1);
+
+	for (i = hw->start_stage; i <= hw->end_stage; i++) {
+		ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
+				&ad714x->amb_reg[i], 1);
+
+		ad714x->sensor_val[i] =
+			abs(ad714x->adc_reg[i] - ad714x->amb_reg[i]);
+	}
+}
+
+static void ad714x_slider_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
+	struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
+
+	sw->highest_stage = ad714x_cal_highest_stage(ad714x, hw->start_stage,
+			hw->end_stage);
+
+	dev_dbg(ad714x->dev, "slider %d highest_stage:%d\n", idx,
+		sw->highest_stage);
+}
+
+/*
+ * The formulae are very straight forward. It uses the sensor with the
+ * highest response and the 2 adjacent ones.
+ * When Sensor 0 has the highest response, only sensor 0 and sensor 1
+ * are used in the calculations. Similarly when the last sensor has the
+ * highest response, only the last sensor and the second last sensors
+ * are used in the calculations.
+ *
+ * For i= idx_of_peak_Sensor-1 to i= idx_of_peak_Sensor+1
+ *         v += Sensor response(i)*i
+ *         w += Sensor response(i)
+ * POS=(Number_of_Positions_Wanted/(Number_of_Sensors_Used-1)) *(v/w)
+ */
+static void ad714x_slider_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
+	struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
+
+	sw->abs_pos = ad714x_cal_abs_pos(ad714x, hw->start_stage, hw->end_stage,
+		sw->highest_stage, hw->max_coord);
+
+	dev_dbg(ad714x->dev, "slider %d absolute position:%d\n", idx,
+		sw->abs_pos);
+}
+
+/*
+ * To minimise the Impact of the noise on the algorithm, ADI developed a
+ * routine that filters the CDC results after they have been read by the
+ * host processor.
+ * The filter used is an Infinite Input Response(IIR) filter implemented
+ * in firmware and attenuates the noise on the CDC results after they've
+ * been read by the host processor.
+ * Filtered_CDC_result = (Filtered_CDC_result * (10 - Coefficient) +
+ *				Latest_CDC_result * Coefficient)/10
+ */
+static void ad714x_slider_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
+
+	sw->flt_pos = (sw->flt_pos * (10 - 4) +
+			sw->abs_pos * 4)/10;
+
+	dev_dbg(ad714x->dev, "slider %d filter position:%d\n", idx,
+		sw->flt_pos);
+}
+
+static void ad714x_slider_use_com_int(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
+
+	ad714x_use_com_int(ad714x, hw->start_stage, hw->end_stage);
+}
+
+static void ad714x_slider_use_thr_int(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
+
+	ad714x_use_thr_int(ad714x, hw->start_stage, hw->end_stage);
+}
+
+static void ad714x_slider_state_machine(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
+	struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
+	unsigned short h_state, c_state;
+	unsigned short mask;
+
+	mask = ((1 << (hw->end_stage + 1)) - 1) - ((1 << hw->start_stage) - 1);
+
+	h_state = ad714x->h_state & mask;
+	c_state = ad714x->c_state & mask;
+
+	switch (sw->state) {
+	case IDLE:
+		if (h_state) {
+			sw->state = JITTER;
+			/* In End of Conversion interrupt mode, the AD714X
+			 * continuously generates hardware interrupts.
+			 */
+			ad714x_slider_use_com_int(ad714x, idx);
+			dev_dbg(ad714x->dev, "slider %d touched\n", idx);
+		}
+		break;
+
+	case JITTER:
+		if (c_state == mask) {
+			ad714x_slider_cal_sensor_val(ad714x, idx);
+			ad714x_slider_cal_highest_stage(ad714x, idx);
+			ad714x_slider_cal_abs_pos(ad714x, idx);
+			sw->flt_pos = sw->abs_pos;
+			sw->state = ACTIVE;
+		}
+		break;
+
+	case ACTIVE:
+		if (c_state == mask) {
+			if (h_state) {
+				ad714x_slider_cal_sensor_val(ad714x, idx);
+				ad714x_slider_cal_highest_stage(ad714x, idx);
+				ad714x_slider_cal_abs_pos(ad714x, idx);
+				ad714x_slider_cal_flt_pos(ad714x, idx);
+				input_report_abs(sw->input, ABS_X, sw->flt_pos);
+				input_report_key(sw->input, BTN_TOUCH, 1);
+			} else {
+				/* When the user lifts off the sensor, configure
+				 * the AD714X back to threshold interrupt mode.
+				 */
+				ad714x_slider_use_thr_int(ad714x, idx);
+				sw->state = IDLE;
+				input_report_key(sw->input, BTN_TOUCH, 0);
+				dev_dbg(ad714x->dev, "slider %d released\n",
+					idx);
+			}
+			input_sync(sw->input);
+		}
+		break;
+
+	default:
+		break;
+	}
+}
+
+/*
+ * When the scroll wheel is activated, we compute the absolute position based
+ * on the sensor values. To calculate the position, we first determine the
+ * sensor that has the greatest response among the 8 sensors that constitutes
+ * the scrollwheel. Then we determined the 2 sensors on either sides of the
+ * sensor with the highest response and we apply weights to these sensors.
+ */
+static void ad714x_wheel_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
+	struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
+
+	sw->pre_highest_stage = sw->highest_stage;
+	sw->highest_stage = ad714x_cal_highest_stage(ad714x, hw->start_stage,
+			hw->end_stage);
+
+	dev_dbg(ad714x->dev, "wheel %d highest_stage:%d\n", idx,
+		sw->highest_stage);
+}
+
+static void ad714x_wheel_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
+	int i;
+
+	ad714x->read(ad714x, CDC_RESULT_S0 + hw->start_stage,
+			&ad714x->adc_reg[hw->start_stage],
+			hw->end_stage - hw->start_stage + 1);
+
+	for (i = hw->start_stage; i <= hw->end_stage; i++) {
+		ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
+				&ad714x->amb_reg[i], 1);
+		if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
+			ad714x->sensor_val[i] =
+				ad714x->adc_reg[i] - ad714x->amb_reg[i];
+		else
+			ad714x->sensor_val[i] = 0;
+	}
+}
+
+/*
+ * When the scroll wheel is activated, we compute the absolute position based
+ * on the sensor values. To calculate the position, we first determine the
+ * sensor that has the greatest response among the sensors that constitutes
+ * the scrollwheel. Then we determined the sensors on either sides of the
+ * sensor with the highest response and we apply weights to these sensors. The
+ * result of this computation gives us the mean value.
+ */
+
+static void ad714x_wheel_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
+	struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
+	int stage_num = hw->end_stage - hw->start_stage + 1;
+	int first_before, highest, first_after;
+	int a_param, b_param;
+
+	first_before = (sw->highest_stage + stage_num - 1) % stage_num;
+	highest = sw->highest_stage;
+	first_after = (sw->highest_stage + stage_num + 1) % stage_num;
+
+	a_param = ad714x->sensor_val[highest] *
+		(highest - hw->start_stage) +
+		ad714x->sensor_val[first_before] *
+		(highest - hw->start_stage - 1) +
+		ad714x->sensor_val[first_after] *
+		(highest - hw->start_stage + 1);
+	b_param = ad714x->sensor_val[highest] +
+		ad714x->sensor_val[first_before] +
+		ad714x->sensor_val[first_after];
+
+	sw->abs_pos = ((hw->max_coord / (hw->end_stage - hw->start_stage)) *
+			a_param) / b_param;
+
+	if (sw->abs_pos > hw->max_coord)
+		sw->abs_pos = hw->max_coord;
+	else if (sw->abs_pos < 0)
+		sw->abs_pos = 0;
+}
+
+static void ad714x_wheel_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
+	struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
+	if (((sw->pre_highest_stage == hw->end_stage) &&
+			(sw->highest_stage == hw->start_stage)) ||
+	    ((sw->pre_highest_stage == hw->start_stage) &&
+			(sw->highest_stage == hw->end_stage)))
+		sw->flt_pos = sw->abs_pos;
+	else
+		sw->flt_pos = ((sw->flt_pos * 30) + (sw->abs_pos * 71)) / 100;
+
+	if (sw->flt_pos > hw->max_coord)
+		sw->flt_pos = hw->max_coord;
+}
+
+static void ad714x_wheel_use_com_int(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
+
+	ad714x_use_com_int(ad714x, hw->start_stage, hw->end_stage);
+}
+
+static void ad714x_wheel_use_thr_int(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
+
+	ad714x_use_thr_int(ad714x, hw->start_stage, hw->end_stage);
+}
+
+static void ad714x_wheel_state_machine(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
+	struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
+	unsigned short h_state, c_state;
+	unsigned short mask;
+
+	mask = ((1 << (hw->end_stage + 1)) - 1) - ((1 << hw->start_stage) - 1);
+
+	h_state = ad714x->h_state & mask;
+	c_state = ad714x->c_state & mask;
+
+	switch (sw->state) {
+	case IDLE:
+		if (h_state) {
+			sw->state = JITTER;
+			/* In End of Conversion interrupt mode, the AD714X
+			 * continuously generates hardware interrupts.
+			 */
+			ad714x_wheel_use_com_int(ad714x, idx);
+			dev_dbg(ad714x->dev, "wheel %d touched\n", idx);
+		}
+		break;
+
+	case JITTER:
+		if (c_state == mask)	{
+			ad714x_wheel_cal_sensor_val(ad714x, idx);
+			ad714x_wheel_cal_highest_stage(ad714x, idx);
+			ad714x_wheel_cal_abs_pos(ad714x, idx);
+			sw->flt_pos = sw->abs_pos;
+			sw->state = ACTIVE;
+		}
+		break;
+
+	case ACTIVE:
+		if (c_state == mask) {
+			if (h_state) {
+				ad714x_wheel_cal_sensor_val(ad714x, idx);
+				ad714x_wheel_cal_highest_stage(ad714x, idx);
+				ad714x_wheel_cal_abs_pos(ad714x, idx);
+				ad714x_wheel_cal_flt_pos(ad714x, idx);
+				input_report_abs(sw->input, ABS_WHEEL,
+					sw->flt_pos);
+				input_report_key(sw->input, BTN_TOUCH, 1);
+			} else {
+				/* When the user lifts off the sensor, configure
+				 * the AD714X back to threshold interrupt mode.
+				 */
+				ad714x_wheel_use_thr_int(ad714x, idx);
+				sw->state = IDLE;
+				input_report_key(sw->input, BTN_TOUCH, 0);
+
+				dev_dbg(ad714x->dev, "wheel %d released\n",
+					idx);
+			}
+			input_sync(sw->input);
+		}
+		break;
+
+	default:
+		break;
+	}
+}
+
+static void touchpad_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+	int i;
+
+	ad714x->read(ad714x, CDC_RESULT_S0 + hw->x_start_stage,
+			&ad714x->adc_reg[hw->x_start_stage],
+			hw->x_end_stage - hw->x_start_stage + 1);
+
+	for (i = hw->x_start_stage; i <= hw->x_end_stage; i++) {
+		ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
+				&ad714x->amb_reg[i], 1);
+		if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
+			ad714x->sensor_val[i] =
+				ad714x->adc_reg[i] - ad714x->amb_reg[i];
+		else
+			ad714x->sensor_val[i] = 0;
+	}
+}
+
+static void touchpad_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+	struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
+
+	sw->x_highest_stage = ad714x_cal_highest_stage(ad714x,
+		hw->x_start_stage, hw->x_end_stage);
+	sw->y_highest_stage = ad714x_cal_highest_stage(ad714x,
+		hw->y_start_stage, hw->y_end_stage);
+
+	dev_dbg(ad714x->dev,
+		"touchpad %d x_highest_stage:%d, y_highest_stage:%d\n",
+		idx, sw->x_highest_stage, sw->y_highest_stage);
+}
+
+/*
+ * If 2 fingers are touching the sensor then 2 peaks can be observed in the
+ * distribution.
+ * The arithmetic doesn't support to get absolute coordinates for multi-touch
+ * yet.
+ */
+static int touchpad_check_second_peak(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+	struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
+	int i;
+
+	for (i = hw->x_start_stage; i < sw->x_highest_stage; i++) {
+		if ((ad714x->sensor_val[i] - ad714x->sensor_val[i + 1])
+			> (ad714x->sensor_val[i + 1] / 10))
+			return 1;
+	}
+
+	for (i = sw->x_highest_stage; i < hw->x_end_stage; i++) {
+		if ((ad714x->sensor_val[i + 1] - ad714x->sensor_val[i])
+			> (ad714x->sensor_val[i] / 10))
+			return 1;
+	}
+
+	for (i = hw->y_start_stage; i < sw->y_highest_stage; i++) {
+		if ((ad714x->sensor_val[i] - ad714x->sensor_val[i + 1])
+			> (ad714x->sensor_val[i + 1] / 10))
+			return 1;
+	}
+
+	for (i = sw->y_highest_stage; i < hw->y_end_stage; i++) {
+		if ((ad714x->sensor_val[i + 1] - ad714x->sensor_val[i])
+			> (ad714x->sensor_val[i] / 10))
+			return 1;
+	}
+
+	return 0;
+}
+
+/*
+ * If only one finger is used to activate the touch pad then only 1 peak will be
+ * registered in the distribution. This peak and the 2 adjacent sensors will be
+ * used in the calculation of the absolute position. This will prevent hand
+ * shadows to affect the absolute position calculation.
+ */
+static void touchpad_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+	struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
+
+	sw->x_abs_pos = ad714x_cal_abs_pos(ad714x, hw->x_start_stage,
+			hw->x_end_stage, sw->x_highest_stage, hw->x_max_coord);
+	sw->y_abs_pos = ad714x_cal_abs_pos(ad714x, hw->y_start_stage,
+			hw->y_end_stage, sw->y_highest_stage, hw->y_max_coord);
+
+	dev_dbg(ad714x->dev, "touchpad %d absolute position:(%d, %d)\n", idx,
+			sw->x_abs_pos, sw->y_abs_pos);
+}
+
+static void touchpad_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
+
+	sw->x_flt_pos = (sw->x_flt_pos * (10 - 4) +
+			sw->x_abs_pos * 4)/10;
+	sw->y_flt_pos = (sw->y_flt_pos * (10 - 4) +
+			sw->y_abs_pos * 4)/10;
+
+	dev_dbg(ad714x->dev, "touchpad %d filter position:(%d, %d)\n",
+			idx, sw->x_flt_pos, sw->y_flt_pos);
+}
+
+/*
+ * To prevent distortion from showing in the absolute position, it is
+ * necessary to detect the end points. When endpoints are detected, the
+ * driver stops updating the status variables with absolute positions.
+ * End points are detected on the 4 edges of the touchpad sensor. The
+ * method to detect them is the same for all 4.
+ * To detect the end points, the firmware computes the difference in
+ * percent between the sensor on the edge and the adjacent one. The
+ * difference is calculated in percent in order to make the end point
+ * detection independent of the pressure.
+ */
+
+#define LEFT_END_POINT_DETECTION_LEVEL                  550
+#define RIGHT_END_POINT_DETECTION_LEVEL                 750
+#define LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL         850
+#define TOP_END_POINT_DETECTION_LEVEL                   550
+#define BOTTOM_END_POINT_DETECTION_LEVEL                950
+#define TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL         700
+static int touchpad_check_endpoint(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+	struct ad714x_touchpad_drv *sw  = &ad714x->sw->touchpad[idx];
+	int percent_sensor_diff;
+
+	/* left endpoint detect */
+	percent_sensor_diff = (ad714x->sensor_val[hw->x_start_stage] -
+			ad714x->sensor_val[hw->x_start_stage + 1]) * 100 /
+			ad714x->sensor_val[hw->x_start_stage + 1];
+	if (!sw->left_ep) {
+		if (percent_sensor_diff >= LEFT_END_POINT_DETECTION_LEVEL)  {
+			sw->left_ep = 1;
+			sw->left_ep_val =
+				ad714x->sensor_val[hw->x_start_stage + 1];
+		}
+	} else {
+		if ((percent_sensor_diff < LEFT_END_POINT_DETECTION_LEVEL) &&
+		    (ad714x->sensor_val[hw->x_start_stage + 1] >
+		     LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL + sw->left_ep_val))
+			sw->left_ep = 0;
+	}
+
+	/* right endpoint detect */
+	percent_sensor_diff = (ad714x->sensor_val[hw->x_end_stage] -
+			ad714x->sensor_val[hw->x_end_stage - 1]) * 100 /
+			ad714x->sensor_val[hw->x_end_stage - 1];
+	if (!sw->right_ep) {
+		if (percent_sensor_diff >= RIGHT_END_POINT_DETECTION_LEVEL)  {
+			sw->right_ep = 1;
+			sw->right_ep_val =
+				ad714x->sensor_val[hw->x_end_stage - 1];
+		}
+	} else {
+		if ((percent_sensor_diff < RIGHT_END_POINT_DETECTION_LEVEL) &&
+		(ad714x->sensor_val[hw->x_end_stage - 1] >
+		LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL + sw->right_ep_val))
+			sw->right_ep = 0;
+	}
+
+	/* top endpoint detect */
+	percent_sensor_diff = (ad714x->sensor_val[hw->y_start_stage] -
+			ad714x->sensor_val[hw->y_start_stage + 1]) * 100 /
+			ad714x->sensor_val[hw->y_start_stage + 1];
+	if (!sw->top_ep) {
+		if (percent_sensor_diff >= TOP_END_POINT_DETECTION_LEVEL)  {
+			sw->top_ep = 1;
+			sw->top_ep_val =
+				ad714x->sensor_val[hw->y_start_stage + 1];
+		}
+	} else {
+		if ((percent_sensor_diff < TOP_END_POINT_DETECTION_LEVEL) &&
+		(ad714x->sensor_val[hw->y_start_stage + 1] >
+		TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL + sw->top_ep_val))
+			sw->top_ep = 0;
+	}
+
+	/* bottom endpoint detect */
+	percent_sensor_diff = (ad714x->sensor_val[hw->y_end_stage] -
+		ad714x->sensor_val[hw->y_end_stage - 1]) * 100 /
+		ad714x->sensor_val[hw->y_end_stage - 1];
+	if (!sw->bottom_ep) {
+		if (percent_sensor_diff >= BOTTOM_END_POINT_DETECTION_LEVEL)  {
+			sw->bottom_ep = 1;
+			sw->bottom_ep_val =
+				ad714x->sensor_val[hw->y_end_stage - 1];
+		}
+	} else {
+		if ((percent_sensor_diff < BOTTOM_END_POINT_DETECTION_LEVEL) &&
+		(ad714x->sensor_val[hw->y_end_stage - 1] >
+		 TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL + sw->bottom_ep_val))
+			sw->bottom_ep = 0;
+	}
+
+	return sw->left_ep || sw->right_ep || sw->top_ep || sw->bottom_ep;
+}
+
+static void touchpad_use_com_int(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+
+	ad714x_use_com_int(ad714x, hw->x_start_stage, hw->x_end_stage);
+}
+
+static void touchpad_use_thr_int(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+
+	ad714x_use_thr_int(ad714x, hw->x_start_stage, hw->x_end_stage);
+	ad714x_use_thr_int(ad714x, hw->y_start_stage, hw->y_end_stage);
+}
+
+static void ad714x_touchpad_state_machine(struct ad714x_chip *ad714x, int idx)
+{
+	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+	struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
+	unsigned short h_state, c_state;
+	unsigned short mask;
+
+	mask = (((1 << (hw->x_end_stage + 1)) - 1) -
+		((1 << hw->x_start_stage) - 1)) +
+		(((1 << (hw->y_end_stage + 1)) - 1) -
+		((1 << hw->y_start_stage) - 1));
+
+	h_state = ad714x->h_state & mask;
+	c_state = ad714x->c_state & mask;
+
+	switch (sw->state) {
+	case IDLE:
+		if (h_state) {
+			sw->state = JITTER;
+			/* In End of Conversion interrupt mode, the AD714X
+			 * continuously generates hardware interrupts.
+			 */
+			touchpad_use_com_int(ad714x, idx);
+			dev_dbg(ad714x->dev, "touchpad %d touched\n", idx);
+		}
+		break;
+
+	case JITTER:
+		if (c_state == mask) {
+			touchpad_cal_sensor_val(ad714x, idx);
+			touchpad_cal_highest_stage(ad714x, idx);
+			if ((!touchpad_check_second_peak(ad714x, idx)) &&
+				(!touchpad_check_endpoint(ad714x, idx))) {
+				dev_dbg(ad714x->dev,
+					"touchpad%d, 2 fingers or endpoint\n",
+					idx);
+				touchpad_cal_abs_pos(ad714x, idx);
+				sw->x_flt_pos = sw->x_abs_pos;
+				sw->y_flt_pos = sw->y_abs_pos;
+				sw->state = ACTIVE;
+			}
+		}
+		break;
+
+	case ACTIVE:
+		if (c_state == mask) {
+			if (h_state) {
+				touchpad_cal_sensor_val(ad714x, idx);
+				touchpad_cal_highest_stage(ad714x, idx);
+				if ((!touchpad_check_second_peak(ad714x, idx))
+				  && (!touchpad_check_endpoint(ad714x, idx))) {
+					touchpad_cal_abs_pos(ad714x, idx);
+					touchpad_cal_flt_pos(ad714x, idx);
+					input_report_abs(sw->input, ABS_X,
+						sw->x_flt_pos);
+					input_report_abs(sw->input, ABS_Y,
+						sw->y_flt_pos);
+					input_report_key(sw->input, BTN_TOUCH,
+						1);
+				}
+			} else {
+				/* When the user lifts off the sensor, configure
+				 * the AD714X back to threshold interrupt mode.
+				 */
+				touchpad_use_thr_int(ad714x, idx);
+				sw->state = IDLE;
+				input_report_key(sw->input, BTN_TOUCH, 0);
+				dev_dbg(ad714x->dev, "touchpad %d released\n",
+					idx);
+			}
+			input_sync(sw->input);
+		}
+		break;
+
+	default:
+		break;
+	}
+}
+
+static int ad714x_hw_detect(struct ad714x_chip *ad714x)
+{
+	unsigned short data;
+
+	ad714x->read(ad714x, AD714X_PARTID_REG, &data, 1);
+	switch (data & 0xFFF0) {
+	case AD7142_PARTID:
+		ad714x->product = 0x7142;
+		ad714x->version = data & 0xF;
+		dev_info(ad714x->dev, "found AD7142 captouch, rev:%d\n",
+				ad714x->version);
+		return 0;
+
+	case AD7143_PARTID:
+		ad714x->product = 0x7143;
+		ad714x->version = data & 0xF;
+		dev_info(ad714x->dev, "found AD7143 captouch, rev:%d\n",
+				ad714x->version);
+		return 0;
+
+	case AD7147_PARTID:
+		ad714x->product = 0x7147;
+		ad714x->version = data & 0xF;
+		dev_info(ad714x->dev, "found AD7147(A) captouch, rev:%d\n",
+				ad714x->version);
+		return 0;
+
+	case AD7148_PARTID:
+		ad714x->product = 0x7148;
+		ad714x->version = data & 0xF;
+		dev_info(ad714x->dev, "found AD7148 captouch, rev:%d\n",
+				ad714x->version);
+		return 0;
+
+	default:
+		dev_err(ad714x->dev,
+			"fail to detect AD714X captouch, read ID is %04x\n",
+			data);
+		return -ENODEV;
+	}
+}
+
+static void ad714x_hw_init(struct ad714x_chip *ad714x)
+{
+	int i, j;
+	unsigned short reg_base;
+	unsigned short data;
+
+	/* configuration CDC and interrupts */
+
+	for (i = 0; i < STAGE_NUM; i++) {
+		reg_base = AD714X_STAGECFG_REG + i * STAGE_CFGREG_NUM;
+		for (j = 0; j < STAGE_CFGREG_NUM; j++)
+			ad714x->write(ad714x, reg_base + j,
+					ad714x->hw->stage_cfg_reg[i][j]);
+	}
+
+	for (i = 0; i < SYS_CFGREG_NUM; i++)
+		ad714x->write(ad714x, AD714X_SYSCFG_REG + i,
+			ad714x->hw->sys_cfg_reg[i]);
+	for (i = 0; i < SYS_CFGREG_NUM; i++)
+		ad714x->read(ad714x, AD714X_SYSCFG_REG + i, &data, 1);
+
+	ad714x->write(ad714x, AD714X_STG_CAL_EN_REG, 0xFFF);
+
+	/* clear all interrupts */
+	ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
+}
+
+static irqreturn_t ad714x_interrupt_thread(int irq, void *data)
+{
+	struct ad714x_chip *ad714x = data;
+	int i;
+
+	mutex_lock(&ad714x->mutex);
+
+	ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
+
+	for (i = 0; i < ad714x->hw->button_num; i++)
+		ad714x_button_state_machine(ad714x, i);
+	for (i = 0; i < ad714x->hw->slider_num; i++)
+		ad714x_slider_state_machine(ad714x, i);
+	for (i = 0; i < ad714x->hw->wheel_num; i++)
+		ad714x_wheel_state_machine(ad714x, i);
+	for (i = 0; i < ad714x->hw->touchpad_num; i++)
+		ad714x_touchpad_state_machine(ad714x, i);
+
+	mutex_unlock(&ad714x->mutex);
+
+	return IRQ_HANDLED;
+}
+
+#define MAX_DEVICE_NUM 8
+struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
+				 ad714x_read_t read, ad714x_write_t write)
+{
+	int i, alloc_idx;
+	int error;
+	struct input_dev *input[MAX_DEVICE_NUM];
+
+	struct ad714x_platform_data *plat_data = dev->platform_data;
+	struct ad714x_chip *ad714x;
+	void *drv_mem;
+	unsigned long irqflags;
+
+	struct ad714x_button_drv *bt_drv;
+	struct ad714x_slider_drv *sd_drv;
+	struct ad714x_wheel_drv *wl_drv;
+	struct ad714x_touchpad_drv *tp_drv;
+
+
+	if (irq <= 0) {
+		dev_err(dev, "IRQ not configured!\n");
+		error = -EINVAL;
+		goto err_out;
+	}
+
+	if (dev->platform_data == NULL) {
+		dev_err(dev, "platform data for ad714x doesn't exist\n");
+		error = -EINVAL;
+		goto err_out;
+	}
+
+	ad714x = kzalloc(sizeof(*ad714x) + sizeof(*ad714x->sw) +
+			 sizeof(*sd_drv) * plat_data->slider_num +
+			 sizeof(*wl_drv) * plat_data->wheel_num +
+			 sizeof(*tp_drv) * plat_data->touchpad_num +
+			 sizeof(*bt_drv) * plat_data->button_num, GFP_KERNEL);
+	if (!ad714x) {
+		error = -ENOMEM;
+		goto err_out;
+	}
+
+	ad714x->hw = plat_data;
+
+	drv_mem = ad714x + 1;
+	ad714x->sw = drv_mem;
+	drv_mem += sizeof(*ad714x->sw);
+	ad714x->sw->slider = sd_drv = drv_mem;
+	drv_mem += sizeof(*sd_drv) * ad714x->hw->slider_num;
+	ad714x->sw->wheel = wl_drv = drv_mem;
+	drv_mem += sizeof(*wl_drv) * ad714x->hw->wheel_num;
+	ad714x->sw->touchpad = tp_drv = drv_mem;
+	drv_mem += sizeof(*tp_drv) * ad714x->hw->touchpad_num;
+	ad714x->sw->button = bt_drv = drv_mem;
+	drv_mem += sizeof(*bt_drv) * ad714x->hw->button_num;
+
+	ad714x->read = read;
+	ad714x->write = write;
+	ad714x->irq = irq;
+	ad714x->dev = dev;
+
+	error = ad714x_hw_detect(ad714x);
+	if (error)
+		goto err_free_mem;
+
+	/* initialize and request sw/hw resources */
+
+	ad714x_hw_init(ad714x);
+	mutex_init(&ad714x->mutex);
+
+	/*
+	 * Allocate and register AD714X input device
+	 */
+	alloc_idx = 0;
+
+	/* a slider uses one input_dev instance */
+	if (ad714x->hw->slider_num > 0) {
+		struct ad714x_slider_plat *sd_plat = ad714x->hw->slider;
+
+		for (i = 0; i < ad714x->hw->slider_num; i++) {
+			sd_drv[i].input = input[alloc_idx] = input_allocate_device();
+			if (!input[alloc_idx]) {
+				error = -ENOMEM;
+				goto err_free_dev;
+			}
+
+			__set_bit(EV_ABS, input[alloc_idx]->evbit);
+			__set_bit(EV_KEY, input[alloc_idx]->evbit);
+			__set_bit(ABS_X, input[alloc_idx]->absbit);
+			__set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
+			input_set_abs_params(input[alloc_idx],
+				ABS_X, 0, sd_plat->max_coord, 0, 0);
+
+			input[alloc_idx]->id.bustype = bus_type;
+			input[alloc_idx]->id.product = ad714x->product;
+			input[alloc_idx]->id.version = ad714x->version;
+			input[alloc_idx]->name = "ad714x_captouch_slider";
+			input[alloc_idx]->dev.parent = dev;
+
+			error = input_register_device(input[alloc_idx]);
+			if (error)
+				goto err_free_dev;
+
+			alloc_idx++;
+		}
+	}
+
+	/* a wheel uses one input_dev instance */
+	if (ad714x->hw->wheel_num > 0) {
+		struct ad714x_wheel_plat *wl_plat = ad714x->hw->wheel;
+
+		for (i = 0; i < ad714x->hw->wheel_num; i++) {
+			wl_drv[i].input = input[alloc_idx] = input_allocate_device();
+			if (!input[alloc_idx]) {
+				error = -ENOMEM;
+				goto err_free_dev;
+			}
+
+			__set_bit(EV_KEY, input[alloc_idx]->evbit);
+			__set_bit(EV_ABS, input[alloc_idx]->evbit);
+			__set_bit(ABS_WHEEL, input[alloc_idx]->absbit);
+			__set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
+			input_set_abs_params(input[alloc_idx],
+				ABS_WHEEL, 0, wl_plat->max_coord, 0, 0);
+
+			input[alloc_idx]->id.bustype = bus_type;
+			input[alloc_idx]->id.product = ad714x->product;
+			input[alloc_idx]->id.version = ad714x->version;
+			input[alloc_idx]->name = "ad714x_captouch_wheel";
+			input[alloc_idx]->dev.parent = dev;
+
+			error = input_register_device(input[alloc_idx]);
+			if (error)
+				goto err_free_dev;
+
+			alloc_idx++;
+		}
+	}
+
+	/* a touchpad uses one input_dev instance */
+	if (ad714x->hw->touchpad_num > 0) {
+		struct ad714x_touchpad_plat *tp_plat = ad714x->hw->touchpad;
+
+		for (i = 0; i < ad714x->hw->touchpad_num; i++) {
+			tp_drv[i].input = input[alloc_idx] = input_allocate_device();
+			if (!input[alloc_idx]) {
+				error = -ENOMEM;
+				goto err_free_dev;
+			}
+
+			__set_bit(EV_ABS, input[alloc_idx]->evbit);
+			__set_bit(EV_KEY, input[alloc_idx]->evbit);
+			__set_bit(ABS_X, input[alloc_idx]->absbit);
+			__set_bit(ABS_Y, input[alloc_idx]->absbit);
+			__set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
+			input_set_abs_params(input[alloc_idx],
+				ABS_X, 0, tp_plat->x_max_coord, 0, 0);
+			input_set_abs_params(input[alloc_idx],
+				ABS_Y, 0, tp_plat->y_max_coord, 0, 0);
+
+			input[alloc_idx]->id.bustype = bus_type;
+			input[alloc_idx]->id.product = ad714x->product;
+			input[alloc_idx]->id.version = ad714x->version;
+			input[alloc_idx]->name = "ad714x_captouch_pad";
+			input[alloc_idx]->dev.parent = dev;
+
+			error = input_register_device(input[alloc_idx]);
+			if (error)
+				goto err_free_dev;
+
+			alloc_idx++;
+		}
+	}
+
+	/* all buttons use one input node */
+	if (ad714x->hw->button_num > 0) {
+		struct ad714x_button_plat *bt_plat = ad714x->hw->button;
+
+		input[alloc_idx] = input_allocate_device();
+		if (!input[alloc_idx]) {
+			error = -ENOMEM;
+			goto err_free_dev;
+		}
+
+		__set_bit(EV_KEY, input[alloc_idx]->evbit);
+		for (i = 0; i < ad714x->hw->button_num; i++) {
+			bt_drv[i].input = input[alloc_idx];
+			__set_bit(bt_plat[i].keycode, input[alloc_idx]->keybit);
+		}
+
+		input[alloc_idx]->id.bustype = bus_type;
+		input[alloc_idx]->id.product = ad714x->product;
+		input[alloc_idx]->id.version = ad714x->version;
+		input[alloc_idx]->name = "ad714x_captouch_button";
+		input[alloc_idx]->dev.parent = dev;
+
+		error = input_register_device(input[alloc_idx]);
+		if (error)
+			goto err_free_dev;
+
+		alloc_idx++;
+	}
+
+	irqflags = plat_data->irqflags ?: IRQF_TRIGGER_FALLING;
+	irqflags |= IRQF_ONESHOT;
+
+	error = request_threaded_irq(ad714x->irq, NULL, ad714x_interrupt_thread,
+				     irqflags, "ad714x_captouch", ad714x);
+	if (error) {
+		dev_err(dev, "can't allocate irq %d\n", ad714x->irq);
+		goto err_unreg_dev;
+	}
+
+	return ad714x;
+
+ err_free_dev:
+	dev_err(dev, "failed to setup AD714x input device %i\n", alloc_idx);
+	input_free_device(input[alloc_idx]);
+ err_unreg_dev:
+	while (--alloc_idx >= 0)
+		input_unregister_device(input[alloc_idx]);
+ err_free_mem:
+	kfree(ad714x);
+ err_out:
+	return ERR_PTR(error);
+}
+EXPORT_SYMBOL(ad714x_probe);
+
+void ad714x_remove(struct ad714x_chip *ad714x)
+{
+	struct ad714x_platform_data *hw = ad714x->hw;
+	struct ad714x_driver_data *sw = ad714x->sw;
+	int i;
+
+	free_irq(ad714x->irq, ad714x);
+
+	/* unregister and free all input devices */
+
+	for (i = 0; i < hw->slider_num; i++)
+		input_unregister_device(sw->slider[i].input);
+
+	for (i = 0; i < hw->wheel_num; i++)
+		input_unregister_device(sw->wheel[i].input);
+
+	for (i = 0; i < hw->touchpad_num; i++)
+		input_unregister_device(sw->touchpad[i].input);
+
+	if (hw->button_num)
+		input_unregister_device(sw->button[0].input);
+
+	kfree(ad714x);
+}
+EXPORT_SYMBOL(ad714x_remove);
+
+#ifdef CONFIG_PM
+int ad714x_disable(struct ad714x_chip *ad714x)
+{
+	unsigned short data;
+
+	dev_dbg(ad714x->dev, "%s enter\n", __func__);
+
+	mutex_lock(&ad714x->mutex);
+
+	data = ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL] | 0x3;
+	ad714x->write(ad714x, AD714X_PWR_CTRL, data);
+
+	mutex_unlock(&ad714x->mutex);
+
+	return 0;
+}
+EXPORT_SYMBOL(ad714x_disable);
+
+int ad714x_enable(struct ad714x_chip *ad714x)
+{
+	dev_dbg(ad714x->dev, "%s enter\n", __func__);
+
+	mutex_lock(&ad714x->mutex);
+
+	/* resume to non-shutdown mode */
+
+	ad714x->write(ad714x, AD714X_PWR_CTRL,
+			ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL]);
+
+	/* make sure the interrupt output line is not low level after resume,
+	 * otherwise we will get no chance to enter falling-edge irq again
+	 */
+
+	ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
+
+	mutex_unlock(&ad714x->mutex);
+
+	return 0;
+}
+EXPORT_SYMBOL(ad714x_enable);
+#endif
+
+MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor Driver");
+MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/ad714x.h b/drivers/input/misc/ad714x.h
new file mode 100644
index 00000000..3c85455a
--- /dev/null
+++ b/drivers/input/misc/ad714x.h
@@ -0,0 +1,55 @@
+/*
+ * AD714X CapTouch Programmable Controller driver (bus interfaces)
+ *
+ * Copyright 2009-2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#ifndef _AD714X_H_
+#define _AD714X_H_
+
+#include <linux/types.h>
+
+#define STAGE_NUM              12
+
+struct device;
+struct ad714x_platform_data;
+struct ad714x_driver_data;
+struct ad714x_chip;
+
+typedef int (*ad714x_read_t)(struct ad714x_chip *, unsigned short, unsigned short *, size_t);
+typedef int (*ad714x_write_t)(struct ad714x_chip *, unsigned short, unsigned short);
+
+struct ad714x_chip {
+	unsigned short l_state;
+	unsigned short h_state;
+	unsigned short c_state;
+	unsigned short adc_reg[STAGE_NUM];
+	unsigned short amb_reg[STAGE_NUM];
+	unsigned short sensor_val[STAGE_NUM];
+
+	struct ad714x_platform_data *hw;
+	struct ad714x_driver_data *sw;
+
+	int irq;
+	struct device *dev;
+	ad714x_read_t read;
+	ad714x_write_t write;
+
+	struct mutex mutex;
+
+	unsigned product;
+	unsigned version;
+
+	__be16 xfer_buf[16] ____cacheline_aligned;
+
+};
+
+int ad714x_disable(struct ad714x_chip *ad714x);
+int ad714x_enable(struct ad714x_chip *ad714x);
+struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
+				 ad714x_read_t read, ad714x_write_t write);
+void ad714x_remove(struct ad714x_chip *ad714x);
+
+#endif
diff --git a/drivers/input/misc/adxl34x-i2c.c b/drivers/input/misc/adxl34x-i2c.c
new file mode 100644
index 00000000..416f47dd
--- /dev/null
+++ b/drivers/input/misc/adxl34x-i2c.c
@@ -0,0 +1,155 @@
+/*
+ * ADLX345/346 Three-Axis Digital Accelerometers (I2C Interface)
+ *
+ * Enter bugs at http://blackfin.uclinux.org/
+ *
+ * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/input.h>	/* BUS_I2C */
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/pm.h>
+#include "adxl34x.h"
+
+static int adxl34x_smbus_read(struct device *dev, unsigned char reg)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+
+	return i2c_smbus_read_byte_data(client, reg);
+}
+
+static int adxl34x_smbus_write(struct device *dev,
+			       unsigned char reg, unsigned char val)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+
+	return i2c_smbus_write_byte_data(client, reg, val);
+}
+
+static int adxl34x_smbus_read_block(struct device *dev,
+				    unsigned char reg, int count,
+				    void *buf)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+
+	return i2c_smbus_read_i2c_block_data(client, reg, count, buf);
+}
+
+static int adxl34x_i2c_read_block(struct device *dev,
+				  unsigned char reg, int count,
+				  void *buf)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	int ret;
+
+	ret = i2c_master_send(client, &reg, 1);
+	if (ret < 0)
+		return ret;
+
+	ret = i2c_master_recv(client, buf, count);
+	if (ret < 0)
+		return ret;
+
+	if (ret != count)
+		return -EIO;
+
+	return 0;
+}
+
+static const struct adxl34x_bus_ops adxl34x_smbus_bops = {
+	.bustype	= BUS_I2C,
+	.write		= adxl34x_smbus_write,
+	.read		= adxl34x_smbus_read,
+	.read_block	= adxl34x_smbus_read_block,
+};
+
+static const struct adxl34x_bus_ops adxl34x_i2c_bops = {
+	.bustype	= BUS_I2C,
+	.write		= adxl34x_smbus_write,
+	.read		= adxl34x_smbus_read,
+	.read_block	= adxl34x_i2c_read_block,
+};
+
+static int adxl34x_i2c_probe(struct i2c_client *client,
+				       const struct i2c_device_id *id)
+{
+	struct adxl34x *ac;
+	int error;
+
+	error = i2c_check_functionality(client->adapter,
+			I2C_FUNC_SMBUS_BYTE_DATA);
+	if (!error) {
+		dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
+		return -EIO;
+	}
+
+	ac = adxl34x_probe(&client->dev, client->irq, false,
+			   i2c_check_functionality(client->adapter,
+						   I2C_FUNC_SMBUS_READ_I2C_BLOCK) ?
+				&adxl34x_smbus_bops : &adxl34x_i2c_bops);
+	if (IS_ERR(ac))
+		return PTR_ERR(ac);
+
+	i2c_set_clientdata(client, ac);
+
+	return 0;
+}
+
+static int adxl34x_i2c_remove(struct i2c_client *client)
+{
+	struct adxl34x *ac = i2c_get_clientdata(client);
+
+	return adxl34x_remove(ac);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int adxl34x_i2c_suspend(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct adxl34x *ac = i2c_get_clientdata(client);
+
+	adxl34x_suspend(ac);
+
+	return 0;
+}
+
+static int adxl34x_i2c_resume(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct adxl34x *ac = i2c_get_clientdata(client);
+
+	adxl34x_resume(ac);
+
+	return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(adxl34x_i2c_pm, adxl34x_i2c_suspend,
+			 adxl34x_i2c_resume);
+
+static const struct i2c_device_id adxl34x_id[] = {
+	{ "adxl34x", 0 },
+	{ }
+};
+
+MODULE_DEVICE_TABLE(i2c, adxl34x_id);
+
+static struct i2c_driver adxl34x_driver = {
+	.driver = {
+		.name = "adxl34x",
+		.owner = THIS_MODULE,
+		.pm = &adxl34x_i2c_pm,
+	},
+	.probe    = adxl34x_i2c_probe,
+	.remove   = adxl34x_i2c_remove,
+	.id_table = adxl34x_id,
+};
+
+module_i2c_driver(adxl34x_driver);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer I2C Bus Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/adxl34x-spi.c b/drivers/input/misc/adxl34x-spi.c
new file mode 100644
index 00000000..76dc0679
--- /dev/null
+++ b/drivers/input/misc/adxl34x-spi.c
@@ -0,0 +1,136 @@
+/*
+ * ADLX345/346 Three-Axis Digital Accelerometers (SPI Interface)
+ *
+ * Enter bugs at http://blackfin.uclinux.org/
+ *
+ * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/input.h>	/* BUS_SPI */
+#include <linux/module.h>
+#include <linux/spi/spi.h>
+#include <linux/pm.h>
+#include <linux/types.h>
+#include "adxl34x.h"
+
+#define MAX_SPI_FREQ_HZ		5000000
+#define MAX_FREQ_NO_FIFODELAY	1500000
+#define ADXL34X_CMD_MULTB	(1 << 6)
+#define ADXL34X_CMD_READ	(1 << 7)
+#define ADXL34X_WRITECMD(reg)	(reg & 0x3F)
+#define ADXL34X_READCMD(reg)	(ADXL34X_CMD_READ | (reg & 0x3F))
+#define ADXL34X_READMB_CMD(reg) (ADXL34X_CMD_READ | ADXL34X_CMD_MULTB \
+					| (reg & 0x3F))
+
+static int adxl34x_spi_read(struct device *dev, unsigned char reg)
+{
+	struct spi_device *spi = to_spi_device(dev);
+	unsigned char cmd;
+
+	cmd = ADXL34X_READCMD(reg);
+
+	return spi_w8r8(spi, cmd);
+}
+
+static int adxl34x_spi_write(struct device *dev,
+			     unsigned char reg, unsigned char val)
+{
+	struct spi_device *spi = to_spi_device(dev);
+	unsigned char buf[2];
+
+	buf[0] = ADXL34X_WRITECMD(reg);
+	buf[1] = val;
+
+	return spi_write(spi, buf, sizeof(buf));
+}
+
+static int adxl34x_spi_read_block(struct device *dev,
+				  unsigned char reg, int count,
+				  void *buf)
+{
+	struct spi_device *spi = to_spi_device(dev);
+	ssize_t status;
+
+	reg = ADXL34X_READMB_CMD(reg);
+	status = spi_write_then_read(spi, &reg, 1, buf, count);
+
+	return (status < 0) ? status : 0;
+}
+
+static const struct adxl34x_bus_ops adxl34x_spi_bops = {
+	.bustype	= BUS_SPI,
+	.write		= adxl34x_spi_write,
+	.read		= adxl34x_spi_read,
+	.read_block	= adxl34x_spi_read_block,
+};
+
+static int adxl34x_spi_probe(struct spi_device *spi)
+{
+	struct adxl34x *ac;
+
+	/* don't exceed max specified SPI CLK frequency */
+	if (spi->max_speed_hz > MAX_SPI_FREQ_HZ) {
+		dev_err(&spi->dev, "SPI CLK %d Hz too fast\n", spi->max_speed_hz);
+		return -EINVAL;
+	}
+
+	ac = adxl34x_probe(&spi->dev, spi->irq,
+			   spi->max_speed_hz > MAX_FREQ_NO_FIFODELAY,
+			   &adxl34x_spi_bops);
+
+	if (IS_ERR(ac))
+		return PTR_ERR(ac);
+
+	spi_set_drvdata(spi, ac);
+
+	return 0;
+}
+
+static int adxl34x_spi_remove(struct spi_device *spi)
+{
+	struct adxl34x *ac = spi_get_drvdata(spi);
+
+	return adxl34x_remove(ac);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int adxl34x_spi_suspend(struct device *dev)
+{
+	struct spi_device *spi = to_spi_device(dev);
+	struct adxl34x *ac = spi_get_drvdata(spi);
+
+	adxl34x_suspend(ac);
+
+	return 0;
+}
+
+static int adxl34x_spi_resume(struct device *dev)
+{
+	struct spi_device *spi = to_spi_device(dev);
+	struct adxl34x *ac = spi_get_drvdata(spi);
+
+	adxl34x_resume(ac);
+
+	return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(adxl34x_spi_pm, adxl34x_spi_suspend,
+			 adxl34x_spi_resume);
+
+static struct spi_driver adxl34x_driver = {
+	.driver = {
+		.name = "adxl34x",
+		.owner = THIS_MODULE,
+		.pm = &adxl34x_spi_pm,
+	},
+	.probe   = adxl34x_spi_probe,
+	.remove  = adxl34x_spi_remove,
+};
+
+module_spi_driver(adxl34x_driver);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer SPI Bus Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/adxl34x.c b/drivers/input/misc/adxl34x.c
new file mode 100644
index 00000000..0735de3a
--- /dev/null
+++ b/drivers/input/misc/adxl34x.c
@@ -0,0 +1,914 @@
+/*
+ * ADXL345/346 Three-Axis Digital Accelerometers
+ *
+ * Enter bugs at http://blackfin.uclinux.org/
+ *
+ * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+#include <linux/input/adxl34x.h>
+#include <linux/module.h>
+
+#include "adxl34x.h"
+
+/* ADXL345/6 Register Map */
+#define DEVID		0x00	/* R   Device ID */
+#define THRESH_TAP	0x1D	/* R/W Tap threshold */
+#define OFSX		0x1E	/* R/W X-axis offset */
+#define OFSY		0x1F	/* R/W Y-axis offset */
+#define OFSZ		0x20	/* R/W Z-axis offset */
+#define DUR		0x21	/* R/W Tap duration */
+#define LATENT		0x22	/* R/W Tap latency */
+#define WINDOW		0x23	/* R/W Tap window */
+#define THRESH_ACT	0x24	/* R/W Activity threshold */
+#define THRESH_INACT	0x25	/* R/W Inactivity threshold */
+#define TIME_INACT	0x26	/* R/W Inactivity time */
+#define ACT_INACT_CTL	0x27	/* R/W Axis enable control for activity and */
+				/* inactivity detection */
+#define THRESH_FF	0x28	/* R/W Free-fall threshold */
+#define TIME_FF		0x29	/* R/W Free-fall time */
+#define TAP_AXES	0x2A	/* R/W Axis control for tap/double tap */
+#define ACT_TAP_STATUS	0x2B	/* R   Source of tap/double tap */
+#define BW_RATE		0x2C	/* R/W Data rate and power mode control */
+#define POWER_CTL	0x2D	/* R/W Power saving features control */
+#define INT_ENABLE	0x2E	/* R/W Interrupt enable control */
+#define INT_MAP		0x2F	/* R/W Interrupt mapping control */
+#define INT_SOURCE	0x30	/* R   Source of interrupts */
+#define DATA_FORMAT	0x31	/* R/W Data format control */
+#define DATAX0		0x32	/* R   X-Axis Data 0 */
+#define DATAX1		0x33	/* R   X-Axis Data 1 */
+#define DATAY0		0x34	/* R   Y-Axis Data 0 */
+#define DATAY1		0x35	/* R   Y-Axis Data 1 */
+#define DATAZ0		0x36	/* R   Z-Axis Data 0 */
+#define DATAZ1		0x37	/* R   Z-Axis Data 1 */
+#define FIFO_CTL	0x38	/* R/W FIFO control */
+#define FIFO_STATUS	0x39	/* R   FIFO status */
+#define TAP_SIGN	0x3A	/* R   Sign and source for tap/double tap */
+/* Orientation ADXL346 only */
+#define ORIENT_CONF	0x3B	/* R/W Orientation configuration */
+#define ORIENT		0x3C	/* R   Orientation status */
+
+/* DEVIDs */
+#define ID_ADXL345	0xE5
+#define ID_ADXL346	0xE6
+
+/* INT_ENABLE/INT_MAP/INT_SOURCE Bits */
+#define DATA_READY	(1 << 7)
+#define SINGLE_TAP	(1 << 6)
+#define DOUBLE_TAP	(1 << 5)
+#define ACTIVITY	(1 << 4)
+#define INACTIVITY	(1 << 3)
+#define FREE_FALL	(1 << 2)
+#define WATERMARK	(1 << 1)
+#define OVERRUN		(1 << 0)
+
+/* ACT_INACT_CONTROL Bits */
+#define ACT_ACDC	(1 << 7)
+#define ACT_X_EN	(1 << 6)
+#define ACT_Y_EN	(1 << 5)
+#define ACT_Z_EN	(1 << 4)
+#define INACT_ACDC	(1 << 3)
+#define INACT_X_EN	(1 << 2)
+#define INACT_Y_EN	(1 << 1)
+#define INACT_Z_EN	(1 << 0)
+
+/* TAP_AXES Bits */
+#define SUPPRESS	(1 << 3)
+#define TAP_X_EN	(1 << 2)
+#define TAP_Y_EN	(1 << 1)
+#define TAP_Z_EN	(1 << 0)
+
+/* ACT_TAP_STATUS Bits */
+#define ACT_X_SRC	(1 << 6)
+#define ACT_Y_SRC	(1 << 5)
+#define ACT_Z_SRC	(1 << 4)
+#define ASLEEP		(1 << 3)
+#define TAP_X_SRC	(1 << 2)
+#define TAP_Y_SRC	(1 << 1)
+#define TAP_Z_SRC	(1 << 0)
+
+/* BW_RATE Bits */
+#define LOW_POWER	(1 << 4)
+#define RATE(x)		((x) & 0xF)
+
+/* POWER_CTL Bits */
+#define PCTL_LINK	(1 << 5)
+#define PCTL_AUTO_SLEEP (1 << 4)
+#define PCTL_MEASURE	(1 << 3)
+#define PCTL_SLEEP	(1 << 2)
+#define PCTL_WAKEUP(x)	((x) & 0x3)
+
+/* DATA_FORMAT Bits */
+#define SELF_TEST	(1 << 7)
+#define SPI		(1 << 6)
+#define INT_INVERT	(1 << 5)
+#define FULL_RES	(1 << 3)
+#define JUSTIFY		(1 << 2)
+#define RANGE(x)	((x) & 0x3)
+#define RANGE_PM_2g	0
+#define RANGE_PM_4g	1
+#define RANGE_PM_8g	2
+#define RANGE_PM_16g	3
+
+/*
+ * Maximum value our axis may get in full res mode for the input device
+ * (signed 13 bits)
+ */
+#define ADXL_FULLRES_MAX_VAL 4096
+
+/*
+ * Maximum value our axis may get in fixed res mode for the input device
+ * (signed 10 bits)
+ */
+#define ADXL_FIXEDRES_MAX_VAL 512
+
+/* FIFO_CTL Bits */
+#define FIFO_MODE(x)	(((x) & 0x3) << 6)
+#define FIFO_BYPASS	0
+#define FIFO_FIFO	1
+#define FIFO_STREAM	2
+#define FIFO_TRIGGER	3
+#define TRIGGER		(1 << 5)
+#define SAMPLES(x)	((x) & 0x1F)
+
+/* FIFO_STATUS Bits */
+#define FIFO_TRIG	(1 << 7)
+#define ENTRIES(x)	((x) & 0x3F)
+
+/* TAP_SIGN Bits ADXL346 only */
+#define XSIGN		(1 << 6)
+#define YSIGN		(1 << 5)
+#define ZSIGN		(1 << 4)
+#define XTAP		(1 << 3)
+#define YTAP		(1 << 2)
+#define ZTAP		(1 << 1)
+
+/* ORIENT_CONF ADXL346 only */
+#define ORIENT_DEADZONE(x)	(((x) & 0x7) << 4)
+#define ORIENT_DIVISOR(x)	((x) & 0x7)
+
+/* ORIENT ADXL346 only */
+#define ADXL346_2D_VALID		(1 << 6)
+#define ADXL346_2D_ORIENT(x)		(((x) & 0x3) >> 4)
+#define ADXL346_3D_VALID		(1 << 3)
+#define ADXL346_3D_ORIENT(x)		((x) & 0x7)
+#define ADXL346_2D_PORTRAIT_POS		0	/* +X */
+#define ADXL346_2D_PORTRAIT_NEG		1	/* -X */
+#define ADXL346_2D_LANDSCAPE_POS	2	/* +Y */
+#define ADXL346_2D_LANDSCAPE_NEG	3	/* -Y */
+
+#define ADXL346_3D_FRONT		3	/* +X */
+#define ADXL346_3D_BACK			4	/* -X */
+#define ADXL346_3D_RIGHT		2	/* +Y */
+#define ADXL346_3D_LEFT			5	/* -Y */
+#define ADXL346_3D_TOP			1	/* +Z */
+#define ADXL346_3D_BOTTOM		6	/* -Z */
+
+#undef ADXL_DEBUG
+
+#define ADXL_X_AXIS			0
+#define ADXL_Y_AXIS			1
+#define ADXL_Z_AXIS			2
+
+#define AC_READ(ac, reg)	((ac)->bops->read((ac)->dev, reg))
+#define AC_WRITE(ac, reg, val)	((ac)->bops->write((ac)->dev, reg, val))
+
+struct axis_triple {
+	int x;
+	int y;
+	int z;
+};
+
+struct adxl34x {
+	struct device *dev;
+	struct input_dev *input;
+	struct mutex mutex;	/* reentrant protection for struct */
+	struct adxl34x_platform_data pdata;
+	struct axis_triple swcal;
+	struct axis_triple hwcal;
+	struct axis_triple saved;
+	char phys[32];
+	unsigned orient2d_saved;
+	unsigned orient3d_saved;
+	bool disabled;	/* P: mutex */
+	bool opened;	/* P: mutex */
+	bool suspended;	/* P: mutex */
+	bool fifo_delay;
+	int irq;
+	unsigned model;
+	unsigned int_mask;
+
+	const struct adxl34x_bus_ops *bops;
+};
+
+static const struct adxl34x_platform_data adxl34x_default_init = {
+	.tap_threshold = 35,
+	.tap_duration = 3,
+	.tap_latency = 20,
+	.tap_window = 20,
+	.tap_axis_control = ADXL_TAP_X_EN | ADXL_TAP_Y_EN | ADXL_TAP_Z_EN,
+	.act_axis_control = 0xFF,
+	.activity_threshold = 6,
+	.inactivity_threshold = 4,
+	.inactivity_time = 3,
+	.free_fall_threshold = 8,
+	.free_fall_time = 0x20,
+	.data_rate = 8,
+	.data_range = ADXL_FULL_RES,
+
+	.ev_type = EV_ABS,
+	.ev_code_x = ABS_X,	/* EV_REL */
+	.ev_code_y = ABS_Y,	/* EV_REL */
+	.ev_code_z = ABS_Z,	/* EV_REL */
+
+	.ev_code_tap = {BTN_TOUCH, BTN_TOUCH, BTN_TOUCH}, /* EV_KEY {x,y,z} */
+	.power_mode = ADXL_AUTO_SLEEP | ADXL_LINK,
+	.fifo_mode = ADXL_FIFO_STREAM,
+	.watermark = 0,
+};
+
+static void adxl34x_get_triple(struct adxl34x *ac, struct axis_triple *axis)
+{
+	short buf[3];
+
+	ac->bops->read_block(ac->dev, DATAX0, DATAZ1 - DATAX0 + 1, buf);
+
+	mutex_lock(&ac->mutex);
+	ac->saved.x = (s16) le16_to_cpu(buf[0]);
+	axis->x = ac->saved.x;
+
+	ac->saved.y = (s16) le16_to_cpu(buf[1]);
+	axis->y = ac->saved.y;
+
+	ac->saved.z = (s16) le16_to_cpu(buf[2]);
+	axis->z = ac->saved.z;
+	mutex_unlock(&ac->mutex);
+}
+
+static void adxl34x_service_ev_fifo(struct adxl34x *ac)
+{
+	struct adxl34x_platform_data *pdata = &ac->pdata;
+	struct axis_triple axis;
+
+	adxl34x_get_triple(ac, &axis);
+
+	input_event(ac->input, pdata->ev_type, pdata->ev_code_x,
+		    axis.x - ac->swcal.x);
+	input_event(ac->input, pdata->ev_type, pdata->ev_code_y,
+		    axis.y - ac->swcal.y);
+	input_event(ac->input, pdata->ev_type, pdata->ev_code_z,
+		    axis.z - ac->swcal.z);
+}
+
+static void adxl34x_report_key_single(struct input_dev *input, int key)
+{
+	input_report_key(input, key, true);
+	input_sync(input);
+	input_report_key(input, key, false);
+}
+
+static void adxl34x_send_key_events(struct adxl34x *ac,
+		struct adxl34x_platform_data *pdata, int status, int press)
+{
+	int i;
+
+	for (i = ADXL_X_AXIS; i <= ADXL_Z_AXIS; i++) {
+		if (status & (1 << (ADXL_Z_AXIS - i)))
+			input_report_key(ac->input,
+					 pdata->ev_code_tap[i], press);
+	}
+}
+
+static void adxl34x_do_tap(struct adxl34x *ac,
+		struct adxl34x_platform_data *pdata, int status)
+{
+	adxl34x_send_key_events(ac, pdata, status, true);
+	input_sync(ac->input);
+	adxl34x_send_key_events(ac, pdata, status, false);
+}
+
+static irqreturn_t adxl34x_irq(int irq, void *handle)
+{
+	struct adxl34x *ac = handle;
+	struct adxl34x_platform_data *pdata = &ac->pdata;
+	int int_stat, tap_stat, samples, orient, orient_code;
+
+	/*
+	 * ACT_TAP_STATUS should be read before clearing the interrupt
+	 * Avoid reading ACT_TAP_STATUS in case TAP detection is disabled
+	 */
+
+	if (pdata->tap_axis_control & (TAP_X_EN | TAP_Y_EN | TAP_Z_EN))
+		tap_stat = AC_READ(ac, ACT_TAP_STATUS);
+	else
+		tap_stat = 0;
+
+	int_stat = AC_READ(ac, INT_SOURCE);
+
+	if (int_stat & FREE_FALL)
+		adxl34x_report_key_single(ac->input, pdata->ev_code_ff);
+
+	if (int_stat & OVERRUN)
+		dev_dbg(ac->dev, "OVERRUN\n");
+
+	if (int_stat & (SINGLE_TAP | DOUBLE_TAP)) {
+		adxl34x_do_tap(ac, pdata, tap_stat);
+
+		if (int_stat & DOUBLE_TAP)
+			adxl34x_do_tap(ac, pdata, tap_stat);
+	}
+
+	if (pdata->ev_code_act_inactivity) {
+		if (int_stat & ACTIVITY)
+			input_report_key(ac->input,
+					 pdata->ev_code_act_inactivity, 1);
+		if (int_stat & INACTIVITY)
+			input_report_key(ac->input,
+					 pdata->ev_code_act_inactivity, 0);
+	}
+
+	/*
+	 * ORIENTATION SENSING ADXL346 only
+	 */
+	if (pdata->orientation_enable) {
+		orient = AC_READ(ac, ORIENT);
+		if ((pdata->orientation_enable & ADXL_EN_ORIENTATION_2D) &&
+		    (orient & ADXL346_2D_VALID)) {
+
+			orient_code = ADXL346_2D_ORIENT(orient);
+			/* Report orientation only when it changes */
+			if (ac->orient2d_saved != orient_code) {
+				ac->orient2d_saved = orient_code;
+				adxl34x_report_key_single(ac->input,
+					pdata->ev_codes_orient_2d[orient_code]);
+			}
+		}
+
+		if ((pdata->orientation_enable & ADXL_EN_ORIENTATION_3D) &&
+		    (orient & ADXL346_3D_VALID)) {
+
+			orient_code = ADXL346_3D_ORIENT(orient) - 1;
+			/* Report orientation only when it changes */
+			if (ac->orient3d_saved != orient_code) {
+				ac->orient3d_saved = orient_code;
+				adxl34x_report_key_single(ac->input,
+					pdata->ev_codes_orient_3d[orient_code]);
+			}
+		}
+	}
+
+	if (int_stat & (DATA_READY | WATERMARK)) {
+
+		if (pdata->fifo_mode)
+			samples = ENTRIES(AC_READ(ac, FIFO_STATUS)) + 1;
+		else
+			samples = 1;
+
+		for (; samples > 0; samples--) {
+			adxl34x_service_ev_fifo(ac);
+			/*
+			 * To ensure that the FIFO has
+			 * completely popped, there must be at least 5 us between
+			 * the end of reading the data registers, signified by the
+			 * transition to register 0x38 from 0x37 or the CS pin
+			 * going high, and the start of new reads of the FIFO or
+			 * reading the FIFO_STATUS register. For SPI operation at
+			 * 1.5 MHz or lower, the register addressing portion of the
+			 * transmission is sufficient delay to ensure the FIFO has
+			 * completely popped. It is necessary for SPI operation
+			 * greater than 1.5 MHz to de-assert the CS pin to ensure a
+			 * total of 5 us, which is at most 3.4 us at 5 MHz
+			 * operation.
+			 */
+			if (ac->fifo_delay && (samples > 1))
+				udelay(3);
+		}
+	}
+
+	input_sync(ac->input);
+
+	return IRQ_HANDLED;
+}
+
+static void __adxl34x_disable(struct adxl34x *ac)
+{
+	/*
+	 * A '0' places the ADXL34x into standby mode
+	 * with minimum power consumption.
+	 */
+	AC_WRITE(ac, POWER_CTL, 0);
+}
+
+static void __adxl34x_enable(struct adxl34x *ac)
+{
+	AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE);
+}
+
+void adxl34x_suspend(struct adxl34x *ac)
+{
+	mutex_lock(&ac->mutex);
+
+	if (!ac->suspended && !ac->disabled && ac->opened)
+		__adxl34x_disable(ac);
+
+	ac->suspended = true;
+
+	mutex_unlock(&ac->mutex);
+}
+EXPORT_SYMBOL_GPL(adxl34x_suspend);
+
+void adxl34x_resume(struct adxl34x *ac)
+{
+	mutex_lock(&ac->mutex);
+
+	if (ac->suspended && !ac->disabled && ac->opened)
+		__adxl34x_enable(ac);
+
+	ac->suspended = false;
+
+	mutex_unlock(&ac->mutex);
+}
+EXPORT_SYMBOL_GPL(adxl34x_resume);
+
+static ssize_t adxl34x_disable_show(struct device *dev,
+				    struct device_attribute *attr, char *buf)
+{
+	struct adxl34x *ac = dev_get_drvdata(dev);
+
+	return sprintf(buf, "%u\n", ac->disabled);
+}
+
+static ssize_t adxl34x_disable_store(struct device *dev,
+				     struct device_attribute *attr,
+				     const char *buf, size_t count)
+{
+	struct adxl34x *ac = dev_get_drvdata(dev);
+	unsigned int val;
+	int error;
+
+	error = kstrtouint(buf, 10, &val);
+	if (error)
+		return error;
+
+	mutex_lock(&ac->mutex);
+
+	if (!ac->suspended && ac->opened) {
+		if (val) {
+			if (!ac->disabled)
+				__adxl34x_disable(ac);
+		} else {
+			if (ac->disabled)
+				__adxl34x_enable(ac);
+		}
+	}
+
+	ac->disabled = !!val;
+
+	mutex_unlock(&ac->mutex);
+
+	return count;
+}
+
+static DEVICE_ATTR(disable, 0664, adxl34x_disable_show, adxl34x_disable_store);
+
+static ssize_t adxl34x_calibrate_show(struct device *dev,
+				      struct device_attribute *attr, char *buf)
+{
+	struct adxl34x *ac = dev_get_drvdata(dev);
+	ssize_t count;
+
+	mutex_lock(&ac->mutex);
+	count = sprintf(buf, "%d,%d,%d\n",
+			ac->hwcal.x * 4 + ac->swcal.x,
+			ac->hwcal.y * 4 + ac->swcal.y,
+			ac->hwcal.z * 4 + ac->swcal.z);
+	mutex_unlock(&ac->mutex);
+
+	return count;
+}
+
+static ssize_t adxl34x_calibrate_store(struct device *dev,
+				       struct device_attribute *attr,
+				       const char *buf, size_t count)
+{
+	struct adxl34x *ac = dev_get_drvdata(dev);
+
+	/*
+	 * Hardware offset calibration has a resolution of 15.6 mg/LSB.
+	 * We use HW calibration and handle the remaining bits in SW. (4mg/LSB)
+	 */
+
+	mutex_lock(&ac->mutex);
+	ac->hwcal.x -= (ac->saved.x / 4);
+	ac->swcal.x = ac->saved.x % 4;
+
+	ac->hwcal.y -= (ac->saved.y / 4);
+	ac->swcal.y = ac->saved.y % 4;
+
+	ac->hwcal.z -= (ac->saved.z / 4);
+	ac->swcal.z = ac->saved.z % 4;
+
+	AC_WRITE(ac, OFSX, (s8) ac->hwcal.x);
+	AC_WRITE(ac, OFSY, (s8) ac->hwcal.y);
+	AC_WRITE(ac, OFSZ, (s8) ac->hwcal.z);
+	mutex_unlock(&ac->mutex);
+
+	return count;
+}
+
+static DEVICE_ATTR(calibrate, 0664,
+		   adxl34x_calibrate_show, adxl34x_calibrate_store);
+
+static ssize_t adxl34x_rate_show(struct device *dev,
+				 struct device_attribute *attr, char *buf)
+{
+	struct adxl34x *ac = dev_get_drvdata(dev);
+
+	return sprintf(buf, "%u\n", RATE(ac->pdata.data_rate));
+}
+
+static ssize_t adxl34x_rate_store(struct device *dev,
+				  struct device_attribute *attr,
+				  const char *buf, size_t count)
+{
+	struct adxl34x *ac = dev_get_drvdata(dev);
+	unsigned char val;
+	int error;
+
+	error = kstrtou8(buf, 10, &val);
+	if (error)
+		return error;
+
+	mutex_lock(&ac->mutex);
+
+	ac->pdata.data_rate = RATE(val);
+	AC_WRITE(ac, BW_RATE,
+		 ac->pdata.data_rate |
+			(ac->pdata.low_power_mode ? LOW_POWER : 0));
+
+	mutex_unlock(&ac->mutex);
+
+	return count;
+}
+
+static DEVICE_ATTR(rate, 0664, adxl34x_rate_show, adxl34x_rate_store);
+
+static ssize_t adxl34x_autosleep_show(struct device *dev,
+				 struct device_attribute *attr, char *buf)
+{
+	struct adxl34x *ac = dev_get_drvdata(dev);
+
+	return sprintf(buf, "%u\n",
+		ac->pdata.power_mode & (PCTL_AUTO_SLEEP | PCTL_LINK) ? 1 : 0);
+}
+
+static ssize_t adxl34x_autosleep_store(struct device *dev,
+				  struct device_attribute *attr,
+				  const char *buf, size_t count)
+{
+	struct adxl34x *ac = dev_get_drvdata(dev);
+	unsigned int val;
+	int error;
+
+	error = kstrtouint(buf, 10, &val);
+	if (error)
+		return error;
+
+	mutex_lock(&ac->mutex);
+
+	if (val)
+		ac->pdata.power_mode |= (PCTL_AUTO_SLEEP | PCTL_LINK);
+	else
+		ac->pdata.power_mode &= ~(PCTL_AUTO_SLEEP | PCTL_LINK);
+
+	if (!ac->disabled && !ac->suspended && ac->opened)
+		AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE);
+
+	mutex_unlock(&ac->mutex);
+
+	return count;
+}
+
+static DEVICE_ATTR(autosleep, 0664,
+		   adxl34x_autosleep_show, adxl34x_autosleep_store);
+
+static ssize_t adxl34x_position_show(struct device *dev,
+				 struct device_attribute *attr, char *buf)
+{
+	struct adxl34x *ac = dev_get_drvdata(dev);
+	ssize_t count;
+
+	mutex_lock(&ac->mutex);
+	count = sprintf(buf, "(%d, %d, %d)\n",
+			ac->saved.x, ac->saved.y, ac->saved.z);
+	mutex_unlock(&ac->mutex);
+
+	return count;
+}
+
+static DEVICE_ATTR(position, S_IRUGO, adxl34x_position_show, NULL);
+
+#ifdef ADXL_DEBUG
+static ssize_t adxl34x_write_store(struct device *dev,
+				   struct device_attribute *attr,
+				   const char *buf, size_t count)
+{
+	struct adxl34x *ac = dev_get_drvdata(dev);
+	unsigned int val;
+	int error;
+
+	/*
+	 * This allows basic ADXL register write access for debug purposes.
+	 */
+	error = kstrtouint(buf, 16, &val);
+	if (error)
+		return error;
+
+	mutex_lock(&ac->mutex);
+	AC_WRITE(ac, val >> 8, val & 0xFF);
+	mutex_unlock(&ac->mutex);
+
+	return count;
+}
+
+static DEVICE_ATTR(write, 0664, NULL, adxl34x_write_store);
+#endif
+
+static struct attribute *adxl34x_attributes[] = {
+	&dev_attr_disable.attr,
+	&dev_attr_calibrate.attr,
+	&dev_attr_rate.attr,
+	&dev_attr_autosleep.attr,
+	&dev_attr_position.attr,
+#ifdef ADXL_DEBUG
+	&dev_attr_write.attr,
+#endif
+	NULL
+};
+
+static const struct attribute_group adxl34x_attr_group = {
+	.attrs = adxl34x_attributes,
+};
+
+static int adxl34x_input_open(struct input_dev *input)
+{
+	struct adxl34x *ac = input_get_drvdata(input);
+
+	mutex_lock(&ac->mutex);
+
+	if (!ac->suspended && !ac->disabled)
+		__adxl34x_enable(ac);
+
+	ac->opened = true;
+
+	mutex_unlock(&ac->mutex);
+
+	return 0;
+}
+
+static void adxl34x_input_close(struct input_dev *input)
+{
+	struct adxl34x *ac = input_get_drvdata(input);
+
+	mutex_lock(&ac->mutex);
+
+	if (!ac->suspended && !ac->disabled)
+		__adxl34x_disable(ac);
+
+	ac->opened = false;
+
+	mutex_unlock(&ac->mutex);
+}
+
+struct adxl34x *adxl34x_probe(struct device *dev, int irq,
+			      bool fifo_delay_default,
+			      const struct adxl34x_bus_ops *bops)
+{
+	struct adxl34x *ac;
+	struct input_dev *input_dev;
+	const struct adxl34x_platform_data *pdata;
+	int err, range, i;
+	unsigned char revid;
+
+	if (!irq) {
+		dev_err(dev, "no IRQ?\n");
+		err = -ENODEV;
+		goto err_out;
+	}
+
+	ac = kzalloc(sizeof(*ac), GFP_KERNEL);
+	input_dev = input_allocate_device();
+	if (!ac || !input_dev) {
+		err = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	ac->fifo_delay = fifo_delay_default;
+
+	pdata = dev->platform_data;
+	if (!pdata) {
+		dev_dbg(dev,
+			"No platform data: Using default initialization\n");
+		pdata = &adxl34x_default_init;
+	}
+
+	ac->pdata = *pdata;
+	pdata = &ac->pdata;
+
+	ac->input = input_dev;
+	ac->dev = dev;
+	ac->irq = irq;
+	ac->bops = bops;
+
+	mutex_init(&ac->mutex);
+
+	input_dev->name = "ADXL34x accelerometer";
+	revid = AC_READ(ac, DEVID);
+
+	switch (revid) {
+	case ID_ADXL345:
+		ac->model = 345;
+		break;
+	case ID_ADXL346:
+		ac->model = 346;
+		break;
+	default:
+		dev_err(dev, "Failed to probe %s\n", input_dev->name);
+		err = -ENODEV;
+		goto err_free_mem;
+	}
+
+	snprintf(ac->phys, sizeof(ac->phys), "%s/input0", dev_name(dev));
+
+	input_dev->phys = ac->phys;
+	input_dev->dev.parent = dev;
+	input_dev->id.product = ac->model;
+	input_dev->id.bustype = bops->bustype;
+	input_dev->open = adxl34x_input_open;
+	input_dev->close = adxl34x_input_close;
+
+	input_set_drvdata(input_dev, ac);
+
+	__set_bit(ac->pdata.ev_type, input_dev->evbit);
+
+	if (ac->pdata.ev_type == EV_REL) {
+		__set_bit(REL_X, input_dev->relbit);
+		__set_bit(REL_Y, input_dev->relbit);
+		__set_bit(REL_Z, input_dev->relbit);
+	} else {
+		/* EV_ABS */
+		__set_bit(ABS_X, input_dev->absbit);
+		__set_bit(ABS_Y, input_dev->absbit);
+		__set_bit(ABS_Z, input_dev->absbit);
+
+		if (pdata->data_range & FULL_RES)
+			range = ADXL_FULLRES_MAX_VAL;	/* Signed 13-bit */
+		else
+			range = ADXL_FIXEDRES_MAX_VAL;	/* Signed 10-bit */
+
+		input_set_abs_params(input_dev, ABS_X, -range, range, 3, 3);
+		input_set_abs_params(input_dev, ABS_Y, -range, range, 3, 3);
+		input_set_abs_params(input_dev, ABS_Z, -range, range, 3, 3);
+	}
+
+	__set_bit(EV_KEY, input_dev->evbit);
+	__set_bit(pdata->ev_code_tap[ADXL_X_AXIS], input_dev->keybit);
+	__set_bit(pdata->ev_code_tap[ADXL_Y_AXIS], input_dev->keybit);
+	__set_bit(pdata->ev_code_tap[ADXL_Z_AXIS], input_dev->keybit);
+
+	if (pdata->ev_code_ff) {
+		ac->int_mask = FREE_FALL;
+		__set_bit(pdata->ev_code_ff, input_dev->keybit);
+	}
+
+	if (pdata->ev_code_act_inactivity)
+		__set_bit(pdata->ev_code_act_inactivity, input_dev->keybit);
+
+	ac->int_mask |= ACTIVITY | INACTIVITY;
+
+	if (pdata->watermark) {
+		ac->int_mask |= WATERMARK;
+		if (!FIFO_MODE(pdata->fifo_mode))
+			ac->pdata.fifo_mode |= FIFO_STREAM;
+	} else {
+		ac->int_mask |= DATA_READY;
+	}
+
+	if (pdata->tap_axis_control & (TAP_X_EN | TAP_Y_EN | TAP_Z_EN))
+		ac->int_mask |= SINGLE_TAP | DOUBLE_TAP;
+
+	if (FIFO_MODE(pdata->fifo_mode) == FIFO_BYPASS)
+		ac->fifo_delay = false;
+
+	AC_WRITE(ac, POWER_CTL, 0);
+
+	err = request_threaded_irq(ac->irq, NULL, adxl34x_irq,
+				   IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
+				   dev_name(dev), ac);
+	if (err) {
+		dev_err(dev, "irq %d busy?\n", ac->irq);
+		goto err_free_mem;
+	}
+
+	err = sysfs_create_group(&dev->kobj, &adxl34x_attr_group);
+	if (err)
+		goto err_free_irq;
+
+	err = input_register_device(input_dev);
+	if (err)
+		goto err_remove_attr;
+
+	AC_WRITE(ac, OFSX, pdata->x_axis_offset);
+	ac->hwcal.x = pdata->x_axis_offset;
+	AC_WRITE(ac, OFSY, pdata->y_axis_offset);
+	ac->hwcal.y = pdata->y_axis_offset;
+	AC_WRITE(ac, OFSZ, pdata->z_axis_offset);
+	ac->hwcal.z = pdata->z_axis_offset;
+	AC_WRITE(ac, THRESH_TAP, pdata->tap_threshold);
+	AC_WRITE(ac, DUR, pdata->tap_duration);
+	AC_WRITE(ac, LATENT, pdata->tap_latency);
+	AC_WRITE(ac, WINDOW, pdata->tap_window);
+	AC_WRITE(ac, THRESH_ACT, pdata->activity_threshold);
+	AC_WRITE(ac, THRESH_INACT, pdata->inactivity_threshold);
+	AC_WRITE(ac, TIME_INACT, pdata->inactivity_time);
+	AC_WRITE(ac, THRESH_FF, pdata->free_fall_threshold);
+	AC_WRITE(ac, TIME_FF, pdata->free_fall_time);
+	AC_WRITE(ac, TAP_AXES, pdata->tap_axis_control);
+	AC_WRITE(ac, ACT_INACT_CTL, pdata->act_axis_control);
+	AC_WRITE(ac, BW_RATE, RATE(ac->pdata.data_rate) |
+		 (pdata->low_power_mode ? LOW_POWER : 0));
+	AC_WRITE(ac, DATA_FORMAT, pdata->data_range);
+	AC_WRITE(ac, FIFO_CTL, FIFO_MODE(pdata->fifo_mode) |
+			SAMPLES(pdata->watermark));
+
+	if (pdata->use_int2) {
+		/* Map all INTs to INT2 */
+		AC_WRITE(ac, INT_MAP, ac->int_mask | OVERRUN);
+	} else {
+		/* Map all INTs to INT1 */
+		AC_WRITE(ac, INT_MAP, 0);
+	}
+
+	if (ac->model == 346 && ac->pdata.orientation_enable) {
+		AC_WRITE(ac, ORIENT_CONF,
+			ORIENT_DEADZONE(ac->pdata.deadzone_angle) |
+			ORIENT_DIVISOR(ac->pdata.divisor_length));
+
+		ac->orient2d_saved = 1234;
+		ac->orient3d_saved = 1234;
+
+		if (pdata->orientation_enable & ADXL_EN_ORIENTATION_3D)
+			for (i = 0; i < ARRAY_SIZE(pdata->ev_codes_orient_3d); i++)
+				__set_bit(pdata->ev_codes_orient_3d[i],
+					  input_dev->keybit);
+
+		if (pdata->orientation_enable & ADXL_EN_ORIENTATION_2D)
+			for (i = 0; i < ARRAY_SIZE(pdata->ev_codes_orient_2d); i++)
+				__set_bit(pdata->ev_codes_orient_2d[i],
+					  input_dev->keybit);
+	} else {
+		ac->pdata.orientation_enable = 0;
+	}
+
+	AC_WRITE(ac, INT_ENABLE, ac->int_mask | OVERRUN);
+
+	ac->pdata.power_mode &= (PCTL_AUTO_SLEEP | PCTL_LINK);
+
+	return ac;
+
+ err_remove_attr:
+	sysfs_remove_group(&dev->kobj, &adxl34x_attr_group);
+ err_free_irq:
+	free_irq(ac->irq, ac);
+ err_free_mem:
+	input_free_device(input_dev);
+	kfree(ac);
+ err_out:
+	return ERR_PTR(err);
+}
+EXPORT_SYMBOL_GPL(adxl34x_probe);
+
+int adxl34x_remove(struct adxl34x *ac)
+{
+	sysfs_remove_group(&ac->dev->kobj, &adxl34x_attr_group);
+	free_irq(ac->irq, ac);
+	input_unregister_device(ac->input);
+	dev_dbg(ac->dev, "unregistered accelerometer\n");
+	kfree(ac);
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(adxl34x_remove);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/adxl34x.h b/drivers/input/misc/adxl34x.h
new file mode 100644
index 00000000..bbbc80fd
--- /dev/null
+++ b/drivers/input/misc/adxl34x.h
@@ -0,0 +1,30 @@
+/*
+ * ADXL345/346 Three-Axis Digital Accelerometers (I2C/SPI Interface)
+ *
+ * Enter bugs at http://blackfin.uclinux.org/
+ *
+ * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
+ * Licensed under the GPL-2 or later.
+ */
+
+#ifndef _ADXL34X_H_
+#define _ADXL34X_H_
+
+struct device;
+struct adxl34x;
+
+struct adxl34x_bus_ops {
+	u16 bustype;
+	int (*read)(struct device *, unsigned char);
+	int (*read_block)(struct device *, unsigned char, int, void *);
+	int (*write)(struct device *, unsigned char, unsigned char);
+};
+
+void adxl34x_suspend(struct adxl34x *ac);
+void adxl34x_resume(struct adxl34x *ac);
+struct adxl34x *adxl34x_probe(struct device *dev, int irq,
+			      bool fifo_delay_default,
+			      const struct adxl34x_bus_ops *bops);
+int adxl34x_remove(struct adxl34x *ac);
+
+#endif
diff --git a/drivers/input/misc/al3006_pls.c b/drivers/input/misc/al3006_pls.c
new file mode 100644
index 00000000..8d72a055
--- /dev/null
+++ b/drivers/input/misc/al3006_pls.c
@@ -0,0 +1,838 @@
+/*
+ * File:         al3006_pls.c
+ * Based on:
+ * Author:       Yunlong Wang <Yunlong.Wang @spreadtrum.com>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+    *
+ */
+
+
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/irq.h>
+#include <linux/input.h>
+#include <linux/gpio.h>
+#ifdef CONFIG_HAS_EARLYSUSPEND
+#include <linux/earlysuspend.h>
+#endif
+#include <linux/fs.h>
+#include <asm/uaccess.h>
+#include <linux/i2c/al3006_pls.h>
+#include <linux/miscdevice.h>
+
+static struct i2c_client *this_client;
+static atomic_t p_flag;
+static atomic_t l_flag;
+static int al3006_pls_opened=0;
+
+/*0: sleep out; 1: sleep in*/
+static unsigned char suspend_flag=0;
+
+
+static ssize_t al3006_pls_show_suspend(struct device* cd,struct device_attribute *attr, char* buf);
+static ssize_t al3006_pls_store_suspend(struct device* cd, struct device_attribute *attr,const char* buf, size_t len);
+static ssize_t al3006_pls_show_version(struct device* cd,struct device_attribute *attr, char* buf);
+#ifdef CONFIG_HAS_EARLYSUSPEND
+static void al3006_pls_early_suspend(struct early_suspend *handler);
+static void al3006_pls_early_resume(struct early_suspend *handler);
+#endif
+static int al3006_pls_write_data(unsigned char addr, unsigned char data);
+static int al3006_pls_read_data(unsigned char addr, unsigned char *data);
+static int al3006_pls_enable(SENSOR_TYPE type);
+static int al3006_pls_disable(SENSOR_TYPE type);
+static void al3006_pls_report_init(void);
+
+static int al3006_pls_adc2lux[64]={
+	1, 1, 1, 2, 2, 2, 3, 4,
+	4, 5, 6, 7, 9, 11, 13, 16,
+	19, 22, 27, 32, 39, 46, 56, 67,
+	80, 96, 116, 139, 167, 200, 240, 289,
+	346, 416, 499, 599, 720, 864, 1037, 1245,
+	1495, 1795, 2154, 2586, 3105, 3728, 4475, 5372,
+	6449, 7743, 9295, 11159, 13396, 16082, 19307, 23178,
+	27862, 33405, 40103, 48144, 57797, 69386, 83298, 100000
+};
+
+
+static DEVICE_ATTR(suspend, S_IRUGO | S_IWUSR, al3006_pls_show_suspend, al3006_pls_store_suspend);
+static DEVICE_ATTR(version, S_IRUGO | S_IWUSR, al3006_pls_show_version, NULL);
+
+static ssize_t al3006_pls_show_suspend(struct device* cd,
+				     struct device_attribute *attr, char* buf)
+{
+	ssize_t ret = 0;
+
+	if(suspend_flag==1)
+		sprintf(buf, "AL3006 Resume\n");
+	else
+		sprintf(buf, "AL3006 Suspend\n");
+
+	ret = strlen(buf) + 1;
+
+	return ret;
+}
+
+static ssize_t al3006_pls_store_suspend(struct device* cd, struct device_attribute *attr,
+		       const char* buf, size_t len)
+{
+	unsigned long on_off = simple_strtoul(buf, NULL, 10);
+	suspend_flag = on_off;
+
+	if(on_off==1)
+	{
+		printk(KERN_INFO "AL3006 Entry Resume\n");
+		al3006_pls_enable(AL3006_PLS_BOTH);
+	}
+	else
+	{
+		printk(KERN_INFO "AL3006 Entry Suspend\n");
+		al3006_pls_disable(AL3006_PLS_BOTH);
+	}
+
+	return len;
+}
+
+static ssize_t al3006_pls_show_version(struct device* cd,
+				     struct device_attribute *attr, char* buf)
+{
+	ssize_t ret = 0;
+
+	sprintf(buf, "AL3006");
+	ret = strlen(buf) + 1;
+
+	return ret;
+}
+
+static int al3006_pls_create_sysfs(struct i2c_client *client)
+{
+	int err;
+	struct device *dev = &(client->dev);
+
+	PLS_DBG("%s", __func__);
+
+	err = device_create_file(dev, &dev_attr_suspend);
+	err = device_create_file(dev, &dev_attr_version);
+
+	return err;
+}
+
+/*******************************************************************************
+* Function    :  al3006_pls_enable
+* Description :  type: proximity / light
+*******************************************************************************/
+static int al3006_pls_enable(SENSOR_TYPE type)
+{
+	unsigned char config;
+
+	al3006_pls_read_data(AL3006_PLS_REG_CONFIG, &config);
+
+	PLS_DBG("%s: type=%d; config=0x%x", __func__, type, config);
+
+	switch(type) {
+		case AL3006_PLS_ALPS:
+			if(config == AL3006_PLS_PXY_ACTIVE)
+				type = AL3006_PLS_BOTH;
+			break;
+		case AL3006_PLS_PXY:
+			if(config == AL3006_PLS_ALPS_ACTIVE)
+				type = AL3006_PLS_BOTH;
+			break;
+		case AL3006_PLS_BOTH:
+			break;
+	}
+
+	PLS_DBG("%s: after type=%d\n",__func__, type);
+
+	switch(type) {
+		case AL3006_PLS_ALPS:
+			al3006_pls_write_data(AL3006_PLS_REG_CONFIG, AL3006_PLS_ALPS_ACTIVE);
+			break;
+		case AL3006_PLS_PXY:
+			al3006_pls_write_data(AL3006_PLS_REG_CONFIG, AL3006_PLS_PXY_ACTIVE);
+			al3006_pls_report_init();
+			break;
+		case AL3006_PLS_BOTH:
+			al3006_pls_write_data(AL3006_PLS_REG_CONFIG, AL3006_PLS_BOTH_ACTIVE);
+			al3006_pls_report_init();
+			break;
+		default:
+			break;
+	}
+
+	return 0;
+}
+
+/*******************************************************************************
+* Function    :  al3006_pls_disable
+* Description :  type: proximity / light
+*******************************************************************************/
+static int al3006_pls_disable(SENSOR_TYPE type)
+{
+	int pxy_flag, apls_flag;
+
+	PLS_DBG("%s: type=%d", __func__, type);
+
+	switch(type) {
+		case AL3006_PLS_ALPS:
+			pxy_flag = atomic_read(&p_flag);
+			/*check proximiy sensor status*/
+			if(pxy_flag == 0) {
+				PLS_DBG("%s: Disable both sensor for pxy_flag=%d", __func__, pxy_flag);
+				al3006_pls_write_data(AL3006_PLS_REG_CONFIG, AL3006_PLS_BOTH_DEACTIVE);
+			} else {
+				PLS_DBG("%s: Only Proximity Sensor alive", __func__);
+				al3006_pls_write_data(AL3006_PLS_REG_CONFIG, AL3006_PLS_PXY_ACTIVE);
+			}
+
+			break;
+		case AL3006_PLS_PXY:
+			apls_flag = atomic_read(&l_flag);
+			/*check light sensor status*/
+			if(apls_flag == 0) {
+				PLS_DBG("%s: Disable both sensor for apls_flag=%d", __func__, apls_flag);
+				al3006_pls_write_data(AL3006_PLS_REG_CONFIG, AL3006_PLS_BOTH_DEACTIVE);
+			} else {
+				PLS_DBG("%s: Only Light Sensor alive", __func__);
+				al3006_pls_write_data(AL3006_PLS_REG_CONFIG, AL3006_PLS_ALPS_ACTIVE);
+			}
+			break;
+		case AL3006_PLS_BOTH:
+			PLS_DBG("%s: Disable both sensors", __func__);
+			al3006_pls_write_data(AL3006_PLS_REG_CONFIG, AL3006_PLS_BOTH_DEACTIVE);
+			break;
+		default:
+			break;
+	}
+
+	return 0;
+}
+
+static int al3006_pls_open(struct inode *inode, struct file *file)
+{
+	PLS_DBG("%s\n", __func__);
+	if (al3006_pls_opened)
+		return -EBUSY;
+	al3006_pls_opened = 1;
+	return 0;
+}
+
+static int al3006_pls_release(struct inode *inode, struct file *file)
+{
+	PLS_DBG("%s", __func__);
+	al3006_pls_opened = 0;
+	return al3006_pls_disable(AL3006_PLS_BOTH);
+}
+
+
+/*******************************************************************************
+* Function    :  al3006_pls_ioctl
+* Description :  ioctl interface to control the sensor
+*******************************************************************************/
+static long al3006_pls_ioctl(struct file *file, unsigned int cmd,unsigned long arg)
+{
+	void __user *argp = (void __user *)arg;
+	int flag;
+	unsigned char data;
+
+	PLS_DBG("%s: cmd %d", __func__, _IOC_NR(cmd));
+
+	/*get ioctl parameter*/
+	switch (cmd) {
+	case LTR_IOCTL_SET_PFLAG:
+	case LTR_IOCTL_SET_LFLAG:
+		if (copy_from_user(&flag, argp, sizeof(flag))) {
+			return -EFAULT;
+		}
+		if (flag < 0 || flag > 1) {
+			return -EINVAL;
+		}
+		PLS_DBG("%s: set flag=%d", __func__, flag);
+		break;
+	default:
+		break;
+	}
+
+	/*handle ioctl*/
+	switch (cmd) {
+	case LTR_IOCTL_GET_PFLAG:
+		flag = atomic_read(&p_flag);
+		break;
+
+	case LTR_IOCTL_GET_LFLAG:
+		flag = atomic_read(&l_flag);
+		break;
+
+	case LTR_IOCTL_GET_DATA:
+		break;
+
+	case LTR_IOCTL_SET_PFLAG:
+		atomic_set(&p_flag, flag);
+		if(flag==1){
+			al3006_pls_enable(AL3006_PLS_PXY);
+		}
+		else if(flag==0) {
+			al3006_pls_disable(AL3006_PLS_PXY);
+		}
+		break;
+
+	case LTR_IOCTL_SET_LFLAG:
+		atomic_set(&l_flag, flag);
+		if(flag==1){
+			al3006_pls_enable(AL3006_PLS_ALPS);
+		}
+		else if(flag==0) {
+			al3006_pls_disable(AL3006_PLS_ALPS);
+		}
+		break;
+
+	default:
+		pr_err("%s: invalid cmd %d\n", __func__, _IOC_NR(cmd));
+		return -EINVAL;
+	}
+
+	/*report ioctl*/
+	switch (cmd) {
+	case LTR_IOCTL_GET_PFLAG:
+	case LTR_IOCTL_GET_LFLAG:
+		if (copy_to_user(argp, &flag, sizeof(flag))) {
+			return -EFAULT;
+		}
+		PLS_DBG("%s: get flag=%d", __func__, flag);
+		break;
+
+	case LTR_IOCTL_GET_DATA:
+		al3006_pls_read_data(AL3006_PLS_REG_DATA,&data);
+		if (copy_to_user(argp, &data, sizeof(data))) {
+			return -EFAULT;
+		}
+		PLS_DBG("%s: get data=%d", __func__, flag);
+		break;
+
+	default:
+		break;
+	}
+
+	return 0;
+
+}
+
+
+static struct file_operations al3006_pls_fops = {
+	.owner				= THIS_MODULE,
+	.open				= al3006_pls_open,
+	.release			= al3006_pls_release,
+	.unlocked_ioctl		= al3006_pls_ioctl,
+};
+
+static struct miscdevice al3006_pls_device = {
+	.minor = MISC_DYNAMIC_MINOR,
+	.name = AL3006_PLS_DEVICE,
+	.fops = &al3006_pls_fops,
+};
+
+/*******************************************************************************
+* Function    :  al3006_pls_rx_data
+* Description :  read data from i2c
+* Parameters  :  buf: content, len: length
+*******************************************************************************/
+static int al3006_pls_rx_data(char *buf, int len)
+{
+	int ret;
+
+	struct i2c_msg msgs[] = {
+		{
+			.addr	= this_client->addr,
+			.flags	= 0,
+			.len	= 1,
+			.buf	= buf,
+		},
+		{
+			.addr	= this_client->addr,
+			.flags	= I2C_M_RD,
+			.len	= len,
+			.buf	= buf,
+		}
+	};
+
+	ret = i2c_transfer(this_client->adapter, msgs, 2);
+    if (ret < 0)
+            printk(KERN_ERR "%s i2c read error: %d\n", __func__, ret);
+
+
+	return ret;
+}
+
+/*******************************************************************************
+* Function    :  al3006_pls_tx_data
+* Description :  send data to i2c
+* Parameters  :  buf: content, len: length
+*******************************************************************************/
+static int al3006_pls_tx_data(char *buf, int len)
+{
+	int ret;
+
+	struct i2c_msg msg[] = {
+		{
+			.addr	= this_client->addr,
+			.flags	= 0,
+			.len	= len,
+			.buf	= buf,
+		}
+	};
+
+	ret = i2c_transfer(this_client->adapter, msg, 1);
+	if (ret < 0)
+		printk(KERN_ERR "%s i2c write error: %d\n", __func__, ret);
+
+	return ret;
+}
+
+/*******************************************************************************
+* Function    :  al3006_pls_write_data
+* Description :  write data to IC
+* Parameters  :  addr: register address, data: register data
+*******************************************************************************/
+static int al3006_pls_write_data(unsigned char addr, unsigned char data)
+{
+	unsigned char buf[2];
+	buf[0]=addr;
+	buf[1]=data;
+	return al3006_pls_tx_data(buf, 2);
+}
+
+/*******************************************************************************
+* Function    :  al3006_pls_read_data
+* Description :  read data from IC
+* Parameters  :  addr: register address, data: read data
+*******************************************************************************/
+static int al3006_pls_read_data(unsigned char addr, unsigned char *data)
+{
+	int ret;
+	unsigned char buf;
+
+	buf=addr;
+	ret = al3006_pls_rx_data(&buf, 1);
+	*data = buf;
+
+	return ret;;
+}
+
+#if PLS_DEBUG
+static void al3006_pls_reg_dump(void)
+{
+	unsigned char config,time_ctrl,dls_ctrl,int_status,dps_ctrl,data,dls_win;
+	al3006_pls_read_data(AL3006_PLS_REG_CONFIG,&config);
+	al3006_pls_read_data(AL3006_PLS_REG_TIME_CTRL,&time_ctrl);
+	al3006_pls_read_data(AL3006_PLS_REG_DLS_CTRL,&dls_ctrl);
+	al3006_pls_read_data(AL3006_PLS_REG_INT_STATUS,&int_status);
+	al3006_pls_read_data(AL3006_PLS_REG_DPS_CTRL,&dps_ctrl);
+	al3006_pls_read_data(AL3006_PLS_REG_DATA,&data);
+	al3006_pls_read_data(AL3006_PLS_REG_DLS_WIN,&dls_win);
+
+	PLS_DBG("%s: config=0x%x,time_ctrl=0x%x,dls_ctrl=0x%x,int_status=0x%x,dps_ctrl=0x%x,data=0x%x,dls_win=0x%x", \
+		__func__, config,time_ctrl,dls_ctrl,int_status,dps_ctrl,data,dls_win);
+}
+#endif
+
+/*******************************************************************************
+* Function    :  al3006_pls_reg_init
+* Description :  set al3006 registers
+* Parameters  :  none
+* Return      :  void
+*******************************************************************************/
+static int al3006_pls_reg_init(void)
+{
+	int ret=0;
+
+	/*set window loss*/
+	if(al3006_pls_write_data(AL3006_PLS_REG_DLS_WIN,0x0D)<0) {
+		printk(KERN_ERR "%s: I2C Write Reg %x Failed\n", __func__, AL3006_PLS_REG_DLS_WIN);
+		ret = -1;
+	}
+
+	/*set time control*/
+	if(al3006_pls_write_data(AL3006_PLS_REG_TIME_CTRL,0x1)<0) {
+		printk(KERN_ERR "%s: I2C Write Reg %x Failed\n", __func__, AL3006_PLS_REG_TIME_CTRL);
+		ret = -1;
+	}
+
+	/*set alps level*/
+#if defined(AL3006_PLS_ADC_LEVEL64)
+	al3006_pls_write_data(AL3006_PLS_REG_DLS_CTRL,0xA0);
+#elif defined(AL3006_PLS_ADC_LEVEL9)
+	al3006_pls_write_data(AL3006_PLS_REG_DLS_CTRL,0x40);
+#elif defined(AL3006_PLS_ADC_LEVEL5)
+	al3006_pls_write_data(AL3006_PLS_REG_DLS_CTRL,0x20);
+#endif
+
+	/*set dps distance*/
+	if(al3006_pls_write_data(AL3006_PLS_REG_DPS_CTRL,0x10)<0) {
+		printk(KERN_ERR "%s: I2C Write Reg %x Failed\n", __func__, AL3006_PLS_REG_DPS_CTRL);
+		ret = -1;
+	}
+
+	/*enter power down mode*/
+	if(al3006_pls_write_data(AL3006_PLS_REG_CONFIG,AL3006_PLS_BOTH_DEACTIVE)<0) {
+		printk(KERN_ERR "%s: I2C Write Reg %x Failed\n", __func__, AL3006_PLS_BOTH_DEACTIVE);
+		ret = -1;
+	}
+
+#if PLS_DEBUG
+	al3006_pls_reg_dump();
+#endif
+
+	return ret;
+}
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+/*******************************************************************************
+* Function    :  al3006_pls_early_suspend
+* Description :  cancel the delayed work and put ts to shutdown mode
+* Parameters  :  handler
+* Return      :    none
+*******************************************************************************/
+static void al3006_pls_early_suspend(struct early_suspend *handler)
+{
+	PLS_DBG("%s\n", __func__);
+#if 0
+	al3006_pls_disable(AL3006_PLS_BOTH);
+#endif
+}
+
+/*******************************************************************************
+* Function    :  al3006_pls_early_resume
+* Description :  ts re-entry the normal mode and schedule the work, there need to be  a litte time
+                      for ts ready
+* Parameters  :  handler
+* Return      :    none
+*******************************************************************************/
+static void al3006_pls_early_resume(struct early_suspend *handler)
+{
+	PLS_DBG("%s\n", __func__);
+#if 0
+	al3006_pls_enable(AL3006_PLS_BOTH);
+#endif
+}
+#endif
+
+static void al3006_pls_report_init(void)
+{
+	al3006_pls_struct *al3006_pls = (al3006_pls_struct *)i2c_get_clientdata(this_client);
+	PLS_DBG("%s\n",__func__);
+	/*report far*/
+	input_report_abs(al3006_pls->input, ABS_DISTANCE, 1);
+	input_sync(al3006_pls->input);
+}
+
+/*******************************************************************************
+* Function    :  al3006_pls_report_dps
+* Description :  reg data,input dev
+* Parameters  :  report proximity sensor data to input system
+* Return      :  none
+*******************************************************************************/
+static void al3006_pls_report_dps(unsigned char data, struct input_dev *input)
+{
+	unsigned char dps_data = (data&0x80)>>7;
+
+	dps_data = (dps_data==1) ? 0: 1;
+	PLS_DBG("%s: proximity=%d", __func__, dps_data);
+
+	input_report_abs(input, ABS_DISTANCE, dps_data);
+	input_sync(input);
+}
+
+/*******************************************************************************
+* Function    :  al3006_pls_report_dls
+* Description :  reg data,input dev
+* Parameters  :  report light sensor data to input system
+* Return      :  none
+*******************************************************************************/
+static void al3006_pls_report_dls(unsigned char data, struct input_dev *input)
+{
+	int lux;
+	unsigned char adc = data&0x3f;
+
+#if defined(AL3006_PLS_ADC_LEVEL9)
+	adc = adc<<3;
+#elif defined(AL3006_PLS_ADC_LEVEL5)
+	adc = adc<<4;
+#endif
+
+	lux = al3006_pls_adc2lux[adc];
+	PLS_DBG("%s: adc=%d, lux=%d", __func__, adc, lux);
+	input_report_abs(input, ABS_MISC, lux);
+	input_sync(input);
+}
+
+/*******************************************************************************
+* Function    :  al3006_pls_work
+* Description :  handler current data and report coordinate
+* Parameters  :  work
+* Return      :    none
+*******************************************************************************/
+
+static void al3006_pls_work(struct work_struct *work)
+{
+	unsigned char int_status, data, enable;
+	al3006_pls_struct *pls = container_of(work, al3006_pls_struct, work);
+
+	al3006_pls_read_data(AL3006_PLS_REG_CONFIG,&enable);
+	al3006_pls_read_data(AL3006_PLS_REG_INT_STATUS,&int_status);
+	al3006_pls_read_data(AL3006_PLS_REG_DATA,&data);
+
+	PLS_DBG("\033[33;1m %s: enable=0x%x; int_status=0x%x; data=0x%x \033[m",\
+		__func__, enable, int_status, data);
+
+	switch(int_status & AL3006_PLS_INT_MASK) {
+		case AL3006_PLS_DPS_INT:
+			al3006_pls_report_dps(data, pls->input);
+			break;
+
+		case AL3006_PLS_DLS_INT:
+			al3006_pls_report_dls(data, pls->input);
+			break;
+
+		case AL3006_PLS_INT_MASK:
+			al3006_pls_report_dps(data, pls->input);
+			al3006_pls_report_dls(data, pls->input);
+			break;
+
+		default:
+			break;
+	}
+
+	enable_irq(pls->client->irq);
+
+}
+
+
+/*******************************************************************************
+* Function    :  al3006_pls_irq_handler
+* Description :  handle ts irq
+* Parameters  :  handler
+* Return      :    none
+*******************************************************************************/
+static irqreturn_t al3006_pls_irq_handler(int irq, void *dev_id)
+{
+	al3006_pls_struct *pls = (al3006_pls_struct *)dev_id;
+
+	disable_irq_nosync(pls->client->irq);
+	queue_work(pls->ltr_work_queue,&pls->work);
+	return IRQ_HANDLED;
+}
+
+static void al3006_pls_pininit(int irq_pin)
+{
+	printk(KERN_INFO "%s [irq=%d]\n",__func__,irq_pin);
+	gpio_request(irq_pin, AL3006_PLS_IRQ_PIN);
+}
+
+
+static int al3006_pls_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+
+	int err = 0;
+	struct al3006_pls_platform_data *pdata = client->dev.platform_data;
+	struct input_dev  *input_dev;
+	al3006_pls_struct *al3006_pls;
+
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+		printk("%s: functionality check failed\n", __func__);
+		err = -ENODEV;
+		goto exit_check_functionality_failed;
+	}
+
+	al3006_pls = kzalloc(sizeof(al3006_pls_struct), GFP_KERNEL);
+	if (!al3006_pls)
+	{
+		printk("%s: request memory failed\n", __func__);
+		err= -ENOMEM;
+		goto exit_request_memory_failed;
+	}
+
+	this_client = client;
+	al3006_pls->client = client;
+	i2c_set_clientdata(client, al3006_pls);
+
+	/*pin init*/
+	al3006_pls_pininit(pdata->irq_gpio_number);
+
+	/*get irq*/
+	client->irq = gpio_to_irq(pdata->irq_gpio_number);
+	al3006_pls->irq = client->irq;
+
+	PLS_DBG("I2C name=%s, addr=0x%x, gpio=%d, irq=%d",client->name,client->addr, \
+		pdata->irq_gpio_number, client->irq);
+
+	/*init AL3006_PLS*/
+	if(al3006_pls_reg_init()<0)
+	{
+		printk(KERN_ERR "%s: device init failed\n", __func__);
+		err=-1;
+		goto exit_device_init_failed;
+	}
+
+	/*register device*/
+	err = misc_register(&al3006_pls_device);
+	if (err) {
+		printk(KERN_ERR "%s: al3006_pls_device register failed\n", __func__);
+		goto exit_device_register_failed;
+	}
+
+
+	/* register input device*/
+	input_dev = input_allocate_device();
+	if (!input_dev)
+	{
+		printk(KERN_ERR "%s: input allocate device failed\n", __func__);
+		err = -ENOMEM;
+		goto exit_input_dev_allocate_failed;
+	}
+
+	al3006_pls->input = input_dev;
+
+	input_dev->name  = AL3006_PLS_INPUT_DEV;
+	input_dev->phys  = AL3006_PLS_INPUT_DEV;
+	input_dev->id.bustype = BUS_I2C;
+	input_dev->dev.parent = &client->dev;
+	input_dev->id.vendor = 0x0001;
+	input_dev->id.product = 0x0001;
+	input_dev->id.version = 0x0010;
+
+	__set_bit(EV_ABS, input_dev->evbit);
+	/*for proximity*/
+	input_set_abs_params(input_dev, ABS_DISTANCE, 0, 1, 0, 0);
+	/*for lightsensor*/
+	input_set_abs_params(input_dev, ABS_MISC, 0, 100001, 0, 0);
+
+	err = input_register_device(input_dev);
+	if (err < 0)
+	{
+	    printk(KERN_ERR "%s: input device regist failed\n", __func__);
+	    goto exit_input_register_failed;
+	}
+
+	/*create work queue*/
+	INIT_WORK(&al3006_pls->work, al3006_pls_work);
+	al3006_pls->ltr_work_queue= create_singlethread_workqueue(AL3006_PLS_DEVICE);
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	/*register early suspend*/
+	al3006_pls->ltr_early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
+	al3006_pls->ltr_early_suspend.suspend = al3006_pls_early_suspend;
+	al3006_pls->ltr_early_suspend.resume = al3006_pls_early_resume;
+	register_early_suspend(&al3006_pls->ltr_early_suspend);
+#endif
+
+	if(client->irq > 0)
+	{
+		err =  request_irq(client->irq, al3006_pls_irq_handler, IRQ_TYPE_LEVEL_LOW, client->name,al3006_pls);
+		if (err <0)
+		{
+			printk(KERN_ERR "%s: IRQ setup failed %d\n", __func__, err);
+			goto irq_request_err;
+		}
+	}
+
+	/*create attribute files*/
+	al3006_pls_create_sysfs(client);
+
+
+	printk(KERN_INFO "%s: Probe Success!\n",__func__);
+
+	return 0;
+
+irq_request_err:
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	unregister_early_suspend(&al3006_pls->ltr_early_suspend);
+#endif
+	destroy_workqueue(al3006_pls->ltr_work_queue);
+exit_input_register_failed:
+	input_free_device(input_dev);
+	misc_deregister(&al3006_pls_device);
+exit_device_register_failed:
+exit_input_dev_allocate_failed:
+exit_device_init_failed:
+	kfree(al3006_pls);
+exit_request_memory_failed:
+exit_check_functionality_failed:
+	printk(KERN_ERR "%s: Probe Fail!\n",__func__);
+	return err;
+
+}
+
+static int al3006_pls_remove(struct i2c_client *client)
+{
+	al3006_pls_struct *al3006_pls = i2c_get_clientdata(client);
+
+	PLS_DBG("%s", __func__);
+
+	/*remove queue*/
+	flush_workqueue(al3006_pls->ltr_work_queue);
+	destroy_workqueue(al3006_pls->ltr_work_queue);
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	/*free suspend*/
+	unregister_early_suspend(&al3006_pls->ltr_early_suspend);
+#endif
+	misc_deregister(&al3006_pls_device);
+	/*free input*/
+	input_unregister_device(al3006_pls->input);
+	input_free_device(al3006_pls->input);
+	/*free irq*/
+	free_irq(al3006_pls->client->irq, al3006_pls);
+	/*free malloc*/
+	kfree(al3006_pls);
+
+	return 0;
+}
+
+static const struct i2c_device_id al3006_pls_id[] = {
+	{ AL3006_PLS_DEVICE, 0 },
+	{ }
+};
+/*----------------------------------------------------------------------------*/
+static struct i2c_driver al3006_pls_driver = {
+    .driver = {
+        .owner = THIS_MODULE,
+        .name  = AL3006_PLS_DEVICE,
+    },
+	.probe      = al3006_pls_probe,
+	.remove     = al3006_pls_remove,
+	.id_table = al3006_pls_id,
+};
+/*----------------------------------------------------------------------------*/
+
+static int __init al3006_pls_init(void)
+{
+	PLS_DBG("%s", __func__);
+	return i2c_add_driver(&al3006_pls_driver);
+}
+
+static void __exit al3006_pls_exit(void)
+{
+	PLS_DBG("%s", __func__);
+	i2c_del_driver(&al3006_pls_driver);
+}
+
+module_init(al3006_pls_init);
+module_exit(al3006_pls_exit);
+
+
+MODULE_AUTHOR("Yunlong Wang <Yunlong.Wang@spreadtrum.com>");
+MODULE_DESCRIPTION("Proximity&Light Sensor AL3006 DRIVER");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/input/misc/apanel.c b/drivers/input/misc/apanel.c
new file mode 100644
index 00000000..a8d2b8db
--- /dev/null
+++ b/drivers/input/misc/apanel.c
@@ -0,0 +1,350 @@
+/*
+ *  Fujitsu Lifebook Application Panel button drive
+ *
+ *  Copyright (C) 2007 Stephen Hemminger <shemminger@linux-foundation.org>
+ *  Copyright (C) 2001-2003 Jochen Eisinger <jochen@penguin-breeder.org>
+ *
+ * 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.
+ *
+ * Many Fujitsu Lifebook laptops have a small panel of buttons that are
+ * accessible via the i2c/smbus interface. This driver polls those
+ * buttons and generates input events.
+ *
+ * For more details see:
+ *	http://apanel.sourceforge.net/tech.php
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <linux/input-polldev.h>
+#include <linux/i2c.h>
+#include <linux/workqueue.h>
+#include <linux/leds.h>
+
+#define APANEL_NAME	"Fujitsu Application Panel"
+#define APANEL_VERSION	"1.3.1"
+#define APANEL		"apanel"
+
+/* How often we poll keys - msecs */
+#define POLL_INTERVAL_DEFAULT	1000
+
+/* Magic constants in BIOS that tell about buttons */
+enum apanel_devid {
+	APANEL_DEV_NONE	  = 0,
+	APANEL_DEV_APPBTN = 1,
+	APANEL_DEV_CDBTN  = 2,
+	APANEL_DEV_LCD	  = 3,
+	APANEL_DEV_LED	  = 4,
+
+	APANEL_DEV_MAX,
+};
+
+enum apanel_chip {
+	CHIP_NONE    = 0,
+	CHIP_OZ992C  = 1,
+	CHIP_OZ163T  = 2,
+	CHIP_OZ711M3 = 4,
+};
+
+/* Result of BIOS snooping/probing -- what features are supported */
+static enum apanel_chip device_chip[APANEL_DEV_MAX];
+
+#define MAX_PANEL_KEYS	12
+
+struct apanel {
+	struct input_polled_dev *ipdev;
+	struct i2c_client *client;
+	unsigned short keymap[MAX_PANEL_KEYS];
+	u16    nkeys;
+	u16    led_bits;
+	struct work_struct led_work;
+	struct led_classdev mail_led;
+};
+
+
+static int apanel_probe(struct i2c_client *, const struct i2c_device_id *);
+
+static void report_key(struct input_dev *input, unsigned keycode)
+{
+	pr_debug(APANEL ": report key %#x\n", keycode);
+	input_report_key(input, keycode, 1);
+	input_sync(input);
+
+	input_report_key(input, keycode, 0);
+	input_sync(input);
+}
+
+/* Poll for key changes
+ *
+ * Read Application keys via SMI
+ *  A (0x4), B (0x8), Internet (0x2), Email (0x1).
+ *
+ * CD keys:
+ * Forward (0x100), Rewind (0x200), Stop (0x400), Pause (0x800)
+ */
+static void apanel_poll(struct input_polled_dev *ipdev)
+{
+	struct apanel *ap = ipdev->private;
+	struct input_dev *idev = ipdev->input;
+	u8 cmd = device_chip[APANEL_DEV_APPBTN] == CHIP_OZ992C ? 0 : 8;
+	s32 data;
+	int i;
+
+	data = i2c_smbus_read_word_data(ap->client, cmd);
+	if (data < 0)
+		return;	/* ignore errors (due to ACPI??) */
+
+	/* write back to clear latch */
+	i2c_smbus_write_word_data(ap->client, cmd, 0);
+
+	if (!data)
+		return;
+
+	dev_dbg(&idev->dev, APANEL ": data %#x\n", data);
+	for (i = 0; i < idev->keycodemax; i++)
+		if ((1u << i) & data)
+			report_key(idev, ap->keymap[i]);
+}
+
+/* Track state changes of LED */
+static void led_update(struct work_struct *work)
+{
+	struct apanel *ap = container_of(work, struct apanel, led_work);
+
+	i2c_smbus_write_word_data(ap->client, 0x10, ap->led_bits);
+}
+
+static void mail_led_set(struct led_classdev *led,
+			 enum led_brightness value)
+{
+	struct apanel *ap = container_of(led, struct apanel, mail_led);
+
+	if (value != LED_OFF)
+		ap->led_bits |= 0x8000;
+	else
+		ap->led_bits &= ~0x8000;
+
+	schedule_work(&ap->led_work);
+}
+
+static int apanel_remove(struct i2c_client *client)
+{
+	struct apanel *ap = i2c_get_clientdata(client);
+
+	if (device_chip[APANEL_DEV_LED] != CHIP_NONE)
+		led_classdev_unregister(&ap->mail_led);
+
+	input_unregister_polled_device(ap->ipdev);
+	input_free_polled_device(ap->ipdev);
+
+	return 0;
+}
+
+static void apanel_shutdown(struct i2c_client *client)
+{
+	apanel_remove(client);
+}
+
+static const struct i2c_device_id apanel_id[] = {
+	{ "fujitsu_apanel", 0 },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, apanel_id);
+
+static struct i2c_driver apanel_driver = {
+	.driver = {
+		.name = APANEL,
+	},
+	.probe		= &apanel_probe,
+	.remove		= &apanel_remove,
+	.shutdown	= &apanel_shutdown,
+	.id_table	= apanel_id,
+};
+
+static struct apanel apanel = {
+	.keymap = {
+		[0] = KEY_MAIL,
+		[1] = KEY_WWW,
+		[2] = KEY_PROG2,
+		[3] = KEY_PROG1,
+
+		[8] = KEY_FORWARD,
+		[9] = KEY_REWIND,
+		[10] = KEY_STOPCD,
+		[11] = KEY_PLAYPAUSE,
+
+	},
+	.mail_led = {
+		.name = "mail:blue",
+		.brightness_set = mail_led_set,
+	},
+};
+
+/* NB: Only one panel on the i2c. */
+static int apanel_probe(struct i2c_client *client,
+			const struct i2c_device_id *id)
+{
+	struct apanel *ap;
+	struct input_polled_dev *ipdev;
+	struct input_dev *idev;
+	u8 cmd = device_chip[APANEL_DEV_APPBTN] == CHIP_OZ992C ? 0 : 8;
+	int i, err = -ENOMEM;
+
+	ap = &apanel;
+
+	ipdev = input_allocate_polled_device();
+	if (!ipdev)
+		goto out1;
+
+	ap->ipdev = ipdev;
+	ap->client = client;
+
+	i2c_set_clientdata(client, ap);
+
+	err = i2c_smbus_write_word_data(client, cmd, 0);
+	if (err) {
+		dev_warn(&client->dev, APANEL ": smbus write error %d\n",
+			 err);
+		goto out3;
+	}
+
+	ipdev->poll = apanel_poll;
+	ipdev->poll_interval = POLL_INTERVAL_DEFAULT;
+	ipdev->private = ap;
+
+	idev = ipdev->input;
+	idev->name = APANEL_NAME " buttons";
+	idev->phys = "apanel/input0";
+	idev->id.bustype = BUS_HOST;
+	idev->dev.parent = &client->dev;
+
+	set_bit(EV_KEY, idev->evbit);
+
+	idev->keycode = ap->keymap;
+	idev->keycodesize = sizeof(ap->keymap[0]);
+	idev->keycodemax = (device_chip[APANEL_DEV_CDBTN] != CHIP_NONE) ? 12 : 4;
+
+	for (i = 0; i < idev->keycodemax; i++)
+		if (ap->keymap[i])
+			set_bit(ap->keymap[i], idev->keybit);
+
+	err = input_register_polled_device(ipdev);
+	if (err)
+		goto out3;
+
+	INIT_WORK(&ap->led_work, led_update);
+	if (device_chip[APANEL_DEV_LED] != CHIP_NONE) {
+		err = led_classdev_register(&client->dev, &ap->mail_led);
+		if (err)
+			goto out4;
+	}
+
+	return 0;
+out4:
+	input_unregister_polled_device(ipdev);
+out3:
+	input_free_polled_device(ipdev);
+out1:
+	return err;
+}
+
+/* Scan the system ROM for the signature "FJKEYINF" */
+static __init const void __iomem *bios_signature(const void __iomem *bios)
+{
+	ssize_t offset;
+	const unsigned char signature[] = "FJKEYINF";
+
+	for (offset = 0; offset < 0x10000; offset += 0x10) {
+		if (check_signature(bios + offset, signature,
+				    sizeof(signature)-1))
+			return bios + offset;
+	}
+	pr_notice(APANEL ": Fujitsu BIOS signature '%s' not found...\n",
+		  signature);
+	return NULL;
+}
+
+static int __init apanel_init(void)
+{
+	void __iomem *bios;
+	const void __iomem *p;
+	u8 devno;
+	unsigned char i2c_addr;
+	int found = 0;
+
+	bios = ioremap(0xF0000, 0x10000); /* Can't fail */
+
+	p = bios_signature(bios);
+	if (!p) {
+		iounmap(bios);
+		return -ENODEV;
+	}
+
+	/* just use the first address */
+	p += 8;
+	i2c_addr = readb(p + 3) >> 1;
+
+	for ( ; (devno = readb(p)) & 0x7f; p += 4) {
+		unsigned char method, slave, chip;
+
+		method = readb(p + 1);
+		chip = readb(p + 2);
+		slave = readb(p + 3) >> 1;
+
+		if (slave != i2c_addr) {
+			pr_notice(APANEL ": only one SMBus slave "
+				  "address supported, skiping device...\n");
+			continue;
+		}
+
+		/* translate alternative device numbers */
+		switch (devno) {
+		case 6:
+			devno = APANEL_DEV_APPBTN;
+			break;
+		case 7:
+			devno = APANEL_DEV_LED;
+			break;
+		}
+
+		if (devno >= APANEL_DEV_MAX)
+			pr_notice(APANEL ": unknown device %u found\n", devno);
+		else if (device_chip[devno] != CHIP_NONE)
+			pr_warning(APANEL ": duplicate entry for devno %u\n", devno);
+
+		else if (method != 1 && method != 2 && method != 4) {
+			pr_notice(APANEL ": unknown method %u for devno %u\n",
+				  method, devno);
+		} else {
+			device_chip[devno] = (enum apanel_chip) chip;
+			++found;
+		}
+	}
+	iounmap(bios);
+
+	if (found == 0) {
+		pr_info(APANEL ": no input devices reported by BIOS\n");
+		return -EIO;
+	}
+
+	return i2c_add_driver(&apanel_driver);
+}
+module_init(apanel_init);
+
+static void __exit apanel_cleanup(void)
+{
+	i2c_del_driver(&apanel_driver);
+}
+module_exit(apanel_cleanup);
+
+MODULE_AUTHOR("Stephen Hemminger <shemminger@linux-foundation.org>");
+MODULE_DESCRIPTION(APANEL_NAME " driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(APANEL_VERSION);
+
+MODULE_ALIAS("dmi:*:svnFUJITSU:pnLifeBook*:pvr*:rvnFUJITSU:*");
+MODULE_ALIAS("dmi:*:svnFUJITSU:pnLifebook*:pvr*:rvnFUJITSU:*");
diff --git a/drivers/input/misc/arizona-haptics.c b/drivers/input/misc/arizona-haptics.c
new file mode 100644
index 00000000..e7e12a5f
--- /dev/null
+++ b/drivers/input/misc/arizona-haptics.c
@@ -0,0 +1,252 @@
+/*
+ * Arizona haptics driver
+ *
+ * Copyright 2012 Wolfson Microelectronics plc
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ * 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/module.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+
+#include <linux/mfd/arizona/core.h>
+#include <linux/mfd/arizona/pdata.h>
+#include <linux/mfd/arizona/registers.h>
+
+struct arizona_haptics {
+	struct arizona *arizona;
+	struct input_dev *input_dev;
+	struct work_struct work;
+
+	struct mutex mutex;
+	u8 intensity;
+};
+
+static void arizona_haptics_work(struct work_struct *work)
+{
+	struct arizona_haptics *haptics = container_of(work,
+						       struct arizona_haptics,
+						       work);
+	struct arizona *arizona = haptics->arizona;
+	struct mutex *dapm_mutex = &arizona->dapm->card->dapm_mutex;
+	int ret;
+
+	if (!haptics->arizona->dapm) {
+		dev_err(arizona->dev, "No DAPM context\n");
+		return;
+	}
+
+	if (haptics->intensity) {
+		ret = regmap_update_bits(arizona->regmap,
+					 ARIZONA_HAPTICS_PHASE_2_INTENSITY,
+					 ARIZONA_PHASE2_INTENSITY_MASK,
+					 haptics->intensity);
+		if (ret != 0) {
+			dev_err(arizona->dev, "Failed to set intensity: %d\n",
+				ret);
+			return;
+		}
+
+		/* This enable sequence will be a noop if already enabled */
+		ret = regmap_update_bits(arizona->regmap,
+					 ARIZONA_HAPTICS_CONTROL_1,
+					 ARIZONA_HAP_CTRL_MASK,
+					 1 << ARIZONA_HAP_CTRL_SHIFT);
+		if (ret != 0) {
+			dev_err(arizona->dev, "Failed to start haptics: %d\n",
+				ret);
+			return;
+		}
+
+		mutex_lock_nested(dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
+
+		ret = snd_soc_dapm_enable_pin(arizona->dapm, "HAPTICS");
+		if (ret != 0) {
+			dev_err(arizona->dev, "Failed to start HAPTICS: %d\n",
+				ret);
+			mutex_unlock(dapm_mutex);
+			return;
+		}
+
+		mutex_unlock(dapm_mutex);
+
+		ret = snd_soc_dapm_sync(arizona->dapm);
+		if (ret != 0) {
+			dev_err(arizona->dev, "Failed to sync DAPM: %d\n",
+				ret);
+			return;
+		}
+	} else {
+		/* This disable sequence will be a noop if already enabled */
+		mutex_lock_nested(dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
+
+		ret = snd_soc_dapm_disable_pin(arizona->dapm, "HAPTICS");
+		if (ret != 0) {
+			dev_err(arizona->dev, "Failed to disable HAPTICS: %d\n",
+				ret);
+			mutex_unlock(dapm_mutex);
+			return;
+		}
+
+		mutex_unlock(dapm_mutex);
+
+		ret = snd_soc_dapm_sync(arizona->dapm);
+		if (ret != 0) {
+			dev_err(arizona->dev, "Failed to sync DAPM: %d\n",
+				ret);
+			return;
+		}
+
+		ret = regmap_update_bits(arizona->regmap,
+					 ARIZONA_HAPTICS_CONTROL_1,
+					 ARIZONA_HAP_CTRL_MASK,
+					 1 << ARIZONA_HAP_CTRL_SHIFT);
+		if (ret != 0) {
+			dev_err(arizona->dev, "Failed to stop haptics: %d\n",
+				ret);
+			return;
+		}
+	}
+}
+
+static int arizona_haptics_play(struct input_dev *input, void *data,
+				struct ff_effect *effect)
+{
+	struct arizona_haptics *haptics = input_get_drvdata(input);
+	struct arizona *arizona = haptics->arizona;
+
+	if (!arizona->dapm) {
+		dev_err(arizona->dev, "No DAPM context\n");
+		return -EBUSY;
+	}
+
+	if (effect->u.rumble.strong_magnitude) {
+		/* Scale the magnitude into the range the device supports */
+		if (arizona->pdata.hap_act) {
+			haptics->intensity =
+				effect->u.rumble.strong_magnitude >> 9;
+			if (effect->direction < 0x8000)
+				haptics->intensity += 0x7f;
+		} else {
+			haptics->intensity =
+				effect->u.rumble.strong_magnitude >> 8;
+		}
+	} else {
+		haptics->intensity = 0;
+	}
+
+	schedule_work(&haptics->work);
+
+	return 0;
+}
+
+static void arizona_haptics_close(struct input_dev *input)
+{
+	struct arizona_haptics *haptics = input_get_drvdata(input);
+	struct mutex *dapm_mutex = &haptics->arizona->dapm->card->dapm_mutex;
+
+	cancel_work_sync(&haptics->work);
+
+	mutex_lock_nested(dapm_mutex, SND_SOC_DAPM_CLASS_RUNTIME);
+
+	if (haptics->arizona->dapm)
+		snd_soc_dapm_disable_pin(haptics->arizona->dapm, "HAPTICS");
+
+	mutex_unlock(dapm_mutex);
+}
+
+static int arizona_haptics_probe(struct platform_device *pdev)
+{
+	struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
+	struct arizona_haptics *haptics;
+	int ret;
+
+	haptics = devm_kzalloc(&pdev->dev, sizeof(*haptics), GFP_KERNEL);
+	if (!haptics)
+		return -ENOMEM;
+
+	haptics->arizona = arizona;
+
+	ret = regmap_update_bits(arizona->regmap, ARIZONA_HAPTICS_CONTROL_1,
+				 ARIZONA_HAP_ACT, arizona->pdata.hap_act);
+	if (ret != 0) {
+		dev_err(arizona->dev, "Failed to set haptics actuator: %d\n",
+			ret);
+		return ret;
+	}
+
+	INIT_WORK(&haptics->work, arizona_haptics_work);
+
+	haptics->input_dev = input_allocate_device();
+	if (haptics->input_dev == NULL) {
+		dev_err(arizona->dev, "Failed to allocate input device\n");
+		return -ENOMEM;
+	}
+
+	input_set_drvdata(haptics->input_dev, haptics);
+
+	haptics->input_dev->name = "arizona:haptics";
+	haptics->input_dev->dev.parent = pdev->dev.parent;
+	haptics->input_dev->close = arizona_haptics_close;
+	__set_bit(FF_RUMBLE, haptics->input_dev->ffbit);
+
+	ret = input_ff_create_memless(haptics->input_dev, NULL,
+				      arizona_haptics_play);
+	if (ret < 0) {
+		dev_err(arizona->dev, "input_ff_create_memless() failed: %d\n",
+			ret);
+		goto err_ialloc;
+	}
+
+	ret = input_register_device(haptics->input_dev);
+	if (ret < 0) {
+		dev_err(arizona->dev, "couldn't register input device: %d\n",
+			ret);
+		goto err_iff;
+	}
+
+	platform_set_drvdata(pdev, haptics);
+
+	return 0;
+
+err_iff:
+	if (haptics->input_dev)
+		input_ff_destroy(haptics->input_dev);
+err_ialloc:
+	input_free_device(haptics->input_dev);
+
+	return ret;
+}
+
+static int arizona_haptics_remove(struct platform_device *pdev)
+{
+	struct arizona_haptics *haptics = platform_get_drvdata(pdev);
+
+	input_unregister_device(haptics->input_dev);
+
+	return 0;
+}
+
+static struct platform_driver arizona_haptics_driver = {
+	.probe		= arizona_haptics_probe,
+	.remove		= arizona_haptics_remove,
+	.driver		= {
+		.name	= "arizona-haptics",
+		.owner	= THIS_MODULE,
+	},
+};
+module_platform_driver(arizona_haptics_driver);
+
+MODULE_ALIAS("platform:arizona-haptics");
+MODULE_DESCRIPTION("Arizona haptics driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
diff --git a/drivers/input/misc/ati_remote2.c b/drivers/input/misc/ati_remote2.c
new file mode 100644
index 00000000..f63341f2
--- /dev/null
+++ b/drivers/input/misc/ati_remote2.c
@@ -0,0 +1,1016 @@
+/*
+ * ati_remote2 - ATI/Philips USB RF remote driver
+ *
+ * Copyright (C) 2005-2008 Ville Syrjala <syrjala@sci.fi>
+ * Copyright (C) 2007-2008 Peter Stokes <linux@dadeos.co.uk>
+ *
+ * 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/usb/input.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+
+#define DRIVER_DESC    "ATI/Philips USB RF remote driver"
+#define DRIVER_VERSION "0.3"
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_AUTHOR("Ville Syrjala <syrjala@sci.fi>");
+MODULE_LICENSE("GPL");
+
+/*
+ * ATI Remote Wonder II Channel Configuration
+ *
+ * The remote control can by assigned one of sixteen "channels" in order to facilitate
+ * the use of multiple remote controls within range of each other.
+ * A remote's "channel" may be altered by pressing and holding the "PC" button for
+ * approximately 3 seconds, after which the button will slowly flash the count of the
+ * currently configured "channel", using the numeric keypad enter a number between 1 and
+ * 16 and then press the "PC" button again, the button will slowly flash the count of the
+ * newly configured "channel".
+ */
+
+enum {
+	ATI_REMOTE2_MAX_CHANNEL_MASK = 0xFFFF,
+	ATI_REMOTE2_MAX_MODE_MASK = 0x1F,
+};
+
+static int ati_remote2_set_mask(const char *val,
+				const struct kernel_param *kp,
+				unsigned int max)
+{
+	unsigned int mask;
+	int ret;
+
+	if (!val)
+		return -EINVAL;
+
+	ret = kstrtouint(val, 0, &mask);
+	if (ret)
+		return ret;
+
+	if (mask & ~max)
+		return -EINVAL;
+
+	*(unsigned int *)kp->arg = mask;
+
+	return 0;
+}
+
+static int ati_remote2_set_channel_mask(const char *val,
+					const struct kernel_param *kp)
+{
+	pr_debug("%s()\n", __func__);
+
+	return ati_remote2_set_mask(val, kp, ATI_REMOTE2_MAX_CHANNEL_MASK);
+}
+
+static int ati_remote2_get_channel_mask(char *buffer,
+					const struct kernel_param *kp)
+{
+	pr_debug("%s()\n", __func__);
+
+	return sprintf(buffer, "0x%04x", *(unsigned int *)kp->arg);
+}
+
+static int ati_remote2_set_mode_mask(const char *val,
+				     const struct kernel_param *kp)
+{
+	pr_debug("%s()\n", __func__);
+
+	return ati_remote2_set_mask(val, kp, ATI_REMOTE2_MAX_MODE_MASK);
+}
+
+static int ati_remote2_get_mode_mask(char *buffer,
+				     const struct kernel_param *kp)
+{
+	pr_debug("%s()\n", __func__);
+
+	return sprintf(buffer, "0x%02x", *(unsigned int *)kp->arg);
+}
+
+static unsigned int channel_mask = ATI_REMOTE2_MAX_CHANNEL_MASK;
+#define param_check_channel_mask(name, p) __param_check(name, p, unsigned int)
+static struct kernel_param_ops param_ops_channel_mask = {
+	.set = ati_remote2_set_channel_mask,
+	.get = ati_remote2_get_channel_mask,
+};
+module_param(channel_mask, channel_mask, 0644);
+MODULE_PARM_DESC(channel_mask, "Bitmask of channels to accept <15:Channel16>...<1:Channel2><0:Channel1>");
+
+static unsigned int mode_mask = ATI_REMOTE2_MAX_MODE_MASK;
+#define param_check_mode_mask(name, p) __param_check(name, p, unsigned int)
+static struct kernel_param_ops param_ops_mode_mask = {
+	.set = ati_remote2_set_mode_mask,
+	.get = ati_remote2_get_mode_mask,
+};
+module_param(mode_mask, mode_mask, 0644);
+MODULE_PARM_DESC(mode_mask, "Bitmask of modes to accept <4:PC><3:AUX4><2:AUX3><1:AUX2><0:AUX1>");
+
+static struct usb_device_id ati_remote2_id_table[] = {
+	{ USB_DEVICE(0x0471, 0x0602) },	/* ATI Remote Wonder II */
+	{ }
+};
+MODULE_DEVICE_TABLE(usb, ati_remote2_id_table);
+
+static DEFINE_MUTEX(ati_remote2_mutex);
+
+enum {
+	ATI_REMOTE2_OPENED = 0x1,
+	ATI_REMOTE2_SUSPENDED = 0x2,
+};
+
+enum {
+	ATI_REMOTE2_AUX1,
+	ATI_REMOTE2_AUX2,
+	ATI_REMOTE2_AUX3,
+	ATI_REMOTE2_AUX4,
+	ATI_REMOTE2_PC,
+	ATI_REMOTE2_MODES,
+};
+
+static const struct {
+	u8  hw_code;
+	u16 keycode;
+} ati_remote2_key_table[] = {
+	{ 0x00, KEY_0 },
+	{ 0x01, KEY_1 },
+	{ 0x02, KEY_2 },
+	{ 0x03, KEY_3 },
+	{ 0x04, KEY_4 },
+	{ 0x05, KEY_5 },
+	{ 0x06, KEY_6 },
+	{ 0x07, KEY_7 },
+	{ 0x08, KEY_8 },
+	{ 0x09, KEY_9 },
+	{ 0x0c, KEY_POWER },
+	{ 0x0d, KEY_MUTE },
+	{ 0x10, KEY_VOLUMEUP },
+	{ 0x11, KEY_VOLUMEDOWN },
+	{ 0x20, KEY_CHANNELUP },
+	{ 0x21, KEY_CHANNELDOWN },
+	{ 0x28, KEY_FORWARD },
+	{ 0x29, KEY_REWIND },
+	{ 0x2c, KEY_PLAY },
+	{ 0x30, KEY_PAUSE },
+	{ 0x31, KEY_STOP },
+	{ 0x37, KEY_RECORD },
+	{ 0x38, KEY_DVD },
+	{ 0x39, KEY_TV },
+	{ 0x3f, KEY_PROG1 }, /* AUX1-AUX4 and PC */
+	{ 0x54, KEY_MENU },
+	{ 0x58, KEY_UP },
+	{ 0x59, KEY_DOWN },
+	{ 0x5a, KEY_LEFT },
+	{ 0x5b, KEY_RIGHT },
+	{ 0x5c, KEY_OK },
+	{ 0x78, KEY_A },
+	{ 0x79, KEY_B },
+	{ 0x7a, KEY_C },
+	{ 0x7b, KEY_D },
+	{ 0x7c, KEY_E },
+	{ 0x7d, KEY_F },
+	{ 0x82, KEY_ENTER },
+	{ 0x8e, KEY_VENDOR },
+	{ 0x96, KEY_COFFEE },
+	{ 0xa9, BTN_LEFT },
+	{ 0xaa, BTN_RIGHT },
+	{ 0xbe, KEY_QUESTION },
+	{ 0xd0, KEY_EDIT },
+	{ 0xd5, KEY_FRONT },
+	{ 0xf9, KEY_INFO },
+};
+
+struct ati_remote2 {
+	struct input_dev *idev;
+	struct usb_device *udev;
+
+	struct usb_interface *intf[2];
+	struct usb_endpoint_descriptor *ep[2];
+	struct urb *urb[2];
+	void *buf[2];
+	dma_addr_t buf_dma[2];
+
+	unsigned long jiffies;
+	int mode;
+
+	char name[64];
+	char phys[64];
+
+	/* Each mode (AUX1-AUX4 and PC) can have an independent keymap. */
+	u16 keycode[ATI_REMOTE2_MODES][ARRAY_SIZE(ati_remote2_key_table)];
+
+	unsigned int flags;
+
+	unsigned int channel_mask;
+	unsigned int mode_mask;
+};
+
+static int ati_remote2_probe(struct usb_interface *interface, const struct usb_device_id *id);
+static void ati_remote2_disconnect(struct usb_interface *interface);
+static int ati_remote2_suspend(struct usb_interface *interface, pm_message_t message);
+static int ati_remote2_resume(struct usb_interface *interface);
+static int ati_remote2_reset_resume(struct usb_interface *interface);
+static int ati_remote2_pre_reset(struct usb_interface *interface);
+static int ati_remote2_post_reset(struct usb_interface *interface);
+
+static struct usb_driver ati_remote2_driver = {
+	.name       = "ati_remote2",
+	.probe      = ati_remote2_probe,
+	.disconnect = ati_remote2_disconnect,
+	.id_table   = ati_remote2_id_table,
+	.suspend    = ati_remote2_suspend,
+	.resume     = ati_remote2_resume,
+	.reset_resume = ati_remote2_reset_resume,
+	.pre_reset  = ati_remote2_pre_reset,
+	.post_reset = ati_remote2_post_reset,
+	.supports_autosuspend = 1,
+};
+
+static int ati_remote2_submit_urbs(struct ati_remote2 *ar2)
+{
+	int r;
+
+	r = usb_submit_urb(ar2->urb[0], GFP_KERNEL);
+	if (r) {
+		dev_err(&ar2->intf[0]->dev,
+			"%s(): usb_submit_urb() = %d\n", __func__, r);
+		return r;
+	}
+	r = usb_submit_urb(ar2->urb[1], GFP_KERNEL);
+	if (r) {
+		usb_kill_urb(ar2->urb[0]);
+		dev_err(&ar2->intf[1]->dev,
+			"%s(): usb_submit_urb() = %d\n", __func__, r);
+		return r;
+	}
+
+	return 0;
+}
+
+static void ati_remote2_kill_urbs(struct ati_remote2 *ar2)
+{
+	usb_kill_urb(ar2->urb[1]);
+	usb_kill_urb(ar2->urb[0]);
+}
+
+static int ati_remote2_open(struct input_dev *idev)
+{
+	struct ati_remote2 *ar2 = input_get_drvdata(idev);
+	int r;
+
+	dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
+
+	r = usb_autopm_get_interface(ar2->intf[0]);
+	if (r) {
+		dev_err(&ar2->intf[0]->dev,
+			"%s(): usb_autopm_get_interface() = %d\n", __func__, r);
+		goto fail1;
+	}
+
+	mutex_lock(&ati_remote2_mutex);
+
+	if (!(ar2->flags & ATI_REMOTE2_SUSPENDED)) {
+		r = ati_remote2_submit_urbs(ar2);
+		if (r)
+			goto fail2;
+	}
+
+	ar2->flags |= ATI_REMOTE2_OPENED;
+
+	mutex_unlock(&ati_remote2_mutex);
+
+	usb_autopm_put_interface(ar2->intf[0]);
+
+	return 0;
+
+ fail2:
+	mutex_unlock(&ati_remote2_mutex);
+	usb_autopm_put_interface(ar2->intf[0]);
+ fail1:
+	return r;
+}
+
+static void ati_remote2_close(struct input_dev *idev)
+{
+	struct ati_remote2 *ar2 = input_get_drvdata(idev);
+
+	dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
+
+	mutex_lock(&ati_remote2_mutex);
+
+	if (!(ar2->flags & ATI_REMOTE2_SUSPENDED))
+		ati_remote2_kill_urbs(ar2);
+
+	ar2->flags &= ~ATI_REMOTE2_OPENED;
+
+	mutex_unlock(&ati_remote2_mutex);
+}
+
+static void ati_remote2_input_mouse(struct ati_remote2 *ar2)
+{
+	struct input_dev *idev = ar2->idev;
+	u8 *data = ar2->buf[0];
+	int channel, mode;
+
+	channel = data[0] >> 4;
+
+	if (!((1 << channel) & ar2->channel_mask))
+		return;
+
+	mode = data[0] & 0x0F;
+
+	if (mode > ATI_REMOTE2_PC) {
+		dev_err(&ar2->intf[0]->dev,
+			"Unknown mode byte (%02x %02x %02x %02x)\n",
+			data[3], data[2], data[1], data[0]);
+		return;
+	}
+
+	if (!((1 << mode) & ar2->mode_mask))
+		return;
+
+	input_event(idev, EV_REL, REL_X, (s8) data[1]);
+	input_event(idev, EV_REL, REL_Y, (s8) data[2]);
+	input_sync(idev);
+}
+
+static int ati_remote2_lookup(unsigned int hw_code)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(ati_remote2_key_table); i++)
+		if (ati_remote2_key_table[i].hw_code == hw_code)
+			return i;
+
+	return -1;
+}
+
+static void ati_remote2_input_key(struct ati_remote2 *ar2)
+{
+	struct input_dev *idev = ar2->idev;
+	u8 *data = ar2->buf[1];
+	int channel, mode, hw_code, index;
+
+	channel = data[0] >> 4;
+
+	if (!((1 << channel) & ar2->channel_mask))
+		return;
+
+	mode = data[0] & 0x0F;
+
+	if (mode > ATI_REMOTE2_PC) {
+		dev_err(&ar2->intf[1]->dev,
+			"Unknown mode byte (%02x %02x %02x %02x)\n",
+			data[3], data[2], data[1], data[0]);
+		return;
+	}
+
+	hw_code = data[2];
+	if (hw_code == 0x3f) {
+		/*
+		 * For some incomprehensible reason the mouse pad generates
+		 * events which look identical to the events from the last
+		 * pressed mode key. Naturally we don't want to generate key
+		 * events for the mouse pad so we filter out any subsequent
+		 * events from the same mode key.
+		 */
+		if (ar2->mode == mode)
+			return;
+
+		if (data[1] == 0)
+			ar2->mode = mode;
+	}
+
+	if (!((1 << mode) & ar2->mode_mask))
+		return;
+
+	index = ati_remote2_lookup(hw_code);
+	if (index < 0) {
+		dev_err(&ar2->intf[1]->dev,
+			"Unknown code byte (%02x %02x %02x %02x)\n",
+			data[3], data[2], data[1], data[0]);
+		return;
+	}
+
+	switch (data[1]) {
+	case 0:	/* release */
+		break;
+	case 1:	/* press */
+		ar2->jiffies = jiffies + msecs_to_jiffies(idev->rep[REP_DELAY]);
+		break;
+	case 2:	/* repeat */
+
+		/* No repeat for mouse buttons. */
+		if (ar2->keycode[mode][index] == BTN_LEFT ||
+		    ar2->keycode[mode][index] == BTN_RIGHT)
+			return;
+
+		if (!time_after_eq(jiffies, ar2->jiffies))
+			return;
+
+		ar2->jiffies = jiffies + msecs_to_jiffies(idev->rep[REP_PERIOD]);
+		break;
+	default:
+		dev_err(&ar2->intf[1]->dev,
+			"Unknown state byte (%02x %02x %02x %02x)\n",
+			data[3], data[2], data[1], data[0]);
+		return;
+	}
+
+	input_event(idev, EV_KEY, ar2->keycode[mode][index], data[1]);
+	input_sync(idev);
+}
+
+static void ati_remote2_complete_mouse(struct urb *urb)
+{
+	struct ati_remote2 *ar2 = urb->context;
+	int r;
+
+	switch (urb->status) {
+	case 0:
+		usb_mark_last_busy(ar2->udev);
+		ati_remote2_input_mouse(ar2);
+		break;
+	case -ENOENT:
+	case -EILSEQ:
+	case -ECONNRESET:
+	case -ESHUTDOWN:
+		dev_dbg(&ar2->intf[0]->dev,
+			"%s(): urb status = %d\n", __func__, urb->status);
+		return;
+	default:
+		usb_mark_last_busy(ar2->udev);
+		dev_err(&ar2->intf[0]->dev,
+			"%s(): urb status = %d\n", __func__, urb->status);
+	}
+
+	r = usb_submit_urb(urb, GFP_ATOMIC);
+	if (r)
+		dev_err(&ar2->intf[0]->dev,
+			"%s(): usb_submit_urb() = %d\n", __func__, r);
+}
+
+static void ati_remote2_complete_key(struct urb *urb)
+{
+	struct ati_remote2 *ar2 = urb->context;
+	int r;
+
+	switch (urb->status) {
+	case 0:
+		usb_mark_last_busy(ar2->udev);
+		ati_remote2_input_key(ar2);
+		break;
+	case -ENOENT:
+	case -EILSEQ:
+	case -ECONNRESET:
+	case -ESHUTDOWN:
+		dev_dbg(&ar2->intf[1]->dev,
+			"%s(): urb status = %d\n", __func__, urb->status);
+		return;
+	default:
+		usb_mark_last_busy(ar2->udev);
+		dev_err(&ar2->intf[1]->dev,
+			"%s(): urb status = %d\n", __func__, urb->status);
+	}
+
+	r = usb_submit_urb(urb, GFP_ATOMIC);
+	if (r)
+		dev_err(&ar2->intf[1]->dev,
+			"%s(): usb_submit_urb() = %d\n", __func__, r);
+}
+
+static int ati_remote2_getkeycode(struct input_dev *idev,
+				  struct input_keymap_entry *ke)
+{
+	struct ati_remote2 *ar2 = input_get_drvdata(idev);
+	unsigned int mode;
+	int offset;
+	unsigned int index;
+	unsigned int scancode;
+
+	if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
+		index = ke->index;
+		if (index >= ATI_REMOTE2_MODES *
+				ARRAY_SIZE(ati_remote2_key_table))
+			return -EINVAL;
+
+		mode = ke->index / ARRAY_SIZE(ati_remote2_key_table);
+		offset = ke->index % ARRAY_SIZE(ati_remote2_key_table);
+		scancode = (mode << 8) + ati_remote2_key_table[offset].hw_code;
+	} else {
+		if (input_scancode_to_scalar(ke, &scancode))
+			return -EINVAL;
+
+		mode = scancode >> 8;
+		if (mode > ATI_REMOTE2_PC)
+			return -EINVAL;
+
+		offset = ati_remote2_lookup(scancode & 0xff);
+		if (offset < 0)
+			return -EINVAL;
+
+		index = mode * ARRAY_SIZE(ati_remote2_key_table) + offset;
+	}
+
+	ke->keycode = ar2->keycode[mode][offset];
+	ke->len = sizeof(scancode);
+	memcpy(&ke->scancode, &scancode, sizeof(scancode));
+	ke->index = index;
+
+	return 0;
+}
+
+static int ati_remote2_setkeycode(struct input_dev *idev,
+				  const struct input_keymap_entry *ke,
+				  unsigned int *old_keycode)
+{
+	struct ati_remote2 *ar2 = input_get_drvdata(idev);
+	unsigned int mode;
+	int offset;
+	unsigned int index;
+	unsigned int scancode;
+
+	if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
+		if (ke->index >= ATI_REMOTE2_MODES *
+				ARRAY_SIZE(ati_remote2_key_table))
+			return -EINVAL;
+
+		mode = ke->index / ARRAY_SIZE(ati_remote2_key_table);
+		offset = ke->index % ARRAY_SIZE(ati_remote2_key_table);
+	} else {
+		if (input_scancode_to_scalar(ke, &scancode))
+			return -EINVAL;
+
+		mode = scancode >> 8;
+		if (mode > ATI_REMOTE2_PC)
+			return -EINVAL;
+
+		offset = ati_remote2_lookup(scancode & 0xff);
+		if (offset < 0)
+			return -EINVAL;
+	}
+
+	*old_keycode = ar2->keycode[mode][offset];
+	ar2->keycode[mode][offset] = ke->keycode;
+	__set_bit(ke->keycode, idev->keybit);
+
+	for (mode = 0; mode < ATI_REMOTE2_MODES; mode++) {
+		for (index = 0; index < ARRAY_SIZE(ati_remote2_key_table); index++) {
+			if (ar2->keycode[mode][index] == *old_keycode)
+				return 0;
+		}
+	}
+
+	__clear_bit(*old_keycode, idev->keybit);
+
+	return 0;
+}
+
+static int ati_remote2_input_init(struct ati_remote2 *ar2)
+{
+	struct input_dev *idev;
+	int index, mode, retval;
+
+	idev = input_allocate_device();
+	if (!idev)
+		return -ENOMEM;
+
+	ar2->idev = idev;
+	input_set_drvdata(idev, ar2);
+
+	idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) | BIT_MASK(EV_REL);
+	idev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
+		BIT_MASK(BTN_RIGHT);
+	idev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
+
+	for (mode = 0; mode < ATI_REMOTE2_MODES; mode++) {
+		for (index = 0; index < ARRAY_SIZE(ati_remote2_key_table); index++) {
+			ar2->keycode[mode][index] = ati_remote2_key_table[index].keycode;
+			__set_bit(ar2->keycode[mode][index], idev->keybit);
+		}
+	}
+
+	/* AUX1-AUX4 and PC generate the same scancode. */
+	index = ati_remote2_lookup(0x3f);
+	ar2->keycode[ATI_REMOTE2_AUX1][index] = KEY_PROG1;
+	ar2->keycode[ATI_REMOTE2_AUX2][index] = KEY_PROG2;
+	ar2->keycode[ATI_REMOTE2_AUX3][index] = KEY_PROG3;
+	ar2->keycode[ATI_REMOTE2_AUX4][index] = KEY_PROG4;
+	ar2->keycode[ATI_REMOTE2_PC][index] = KEY_PC;
+	__set_bit(KEY_PROG1, idev->keybit);
+	__set_bit(KEY_PROG2, idev->keybit);
+	__set_bit(KEY_PROG3, idev->keybit);
+	__set_bit(KEY_PROG4, idev->keybit);
+	__set_bit(KEY_PC, idev->keybit);
+
+	idev->rep[REP_DELAY]  = 250;
+	idev->rep[REP_PERIOD] = 33;
+
+	idev->open = ati_remote2_open;
+	idev->close = ati_remote2_close;
+
+	idev->getkeycode = ati_remote2_getkeycode;
+	idev->setkeycode = ati_remote2_setkeycode;
+
+	idev->name = ar2->name;
+	idev->phys = ar2->phys;
+
+	usb_to_input_id(ar2->udev, &idev->id);
+	idev->dev.parent = &ar2->udev->dev;
+
+	retval = input_register_device(idev);
+	if (retval)
+		input_free_device(idev);
+
+	return retval;
+}
+
+static int ati_remote2_urb_init(struct ati_remote2 *ar2)
+{
+	struct usb_device *udev = ar2->udev;
+	int i, pipe, maxp;
+
+	for (i = 0; i < 2; i++) {
+		ar2->buf[i] = usb_alloc_coherent(udev, 4, GFP_KERNEL, &ar2->buf_dma[i]);
+		if (!ar2->buf[i])
+			return -ENOMEM;
+
+		ar2->urb[i] = usb_alloc_urb(0, GFP_KERNEL);
+		if (!ar2->urb[i])
+			return -ENOMEM;
+
+		pipe = usb_rcvintpipe(udev, ar2->ep[i]->bEndpointAddress);
+		maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
+		maxp = maxp > 4 ? 4 : maxp;
+
+		usb_fill_int_urb(ar2->urb[i], udev, pipe, ar2->buf[i], maxp,
+				 i ? ati_remote2_complete_key : ati_remote2_complete_mouse,
+				 ar2, ar2->ep[i]->bInterval);
+		ar2->urb[i]->transfer_dma = ar2->buf_dma[i];
+		ar2->urb[i]->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+	}
+
+	return 0;
+}
+
+static void ati_remote2_urb_cleanup(struct ati_remote2 *ar2)
+{
+	int i;
+
+	for (i = 0; i < 2; i++) {
+		usb_free_urb(ar2->urb[i]);
+		usb_free_coherent(ar2->udev, 4, ar2->buf[i], ar2->buf_dma[i]);
+	}
+}
+
+static int ati_remote2_setup(struct ati_remote2 *ar2, unsigned int ch_mask)
+{
+	int r, i, channel;
+
+	/*
+	 * Configure receiver to only accept input from remote "channel"
+	 *  channel == 0  -> Accept input from any remote channel
+	 *  channel == 1  -> Only accept input from remote channel 1
+	 *  channel == 2  -> Only accept input from remote channel 2
+	 *  ...
+	 *  channel == 16 -> Only accept input from remote channel 16
+	 */
+
+	channel = 0;
+	for (i = 0; i < 16; i++) {
+		if ((1 << i) & ch_mask) {
+			if (!(~(1 << i) & ch_mask))
+				channel = i + 1;
+			break;
+		}
+	}
+
+	r = usb_control_msg(ar2->udev, usb_sndctrlpipe(ar2->udev, 0),
+			    0x20,
+			    USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
+			    channel, 0x0, NULL, 0, USB_CTRL_SET_TIMEOUT);
+	if (r) {
+		dev_err(&ar2->udev->dev, "%s - failed to set channel due to error: %d\n",
+			__func__, r);
+		return r;
+	}
+
+	return 0;
+}
+
+static ssize_t ati_remote2_show_channel_mask(struct device *dev,
+					     struct device_attribute *attr,
+					     char *buf)
+{
+	struct usb_device *udev = to_usb_device(dev);
+	struct usb_interface *intf = usb_ifnum_to_if(udev, 0);
+	struct ati_remote2 *ar2 = usb_get_intfdata(intf);
+
+	return sprintf(buf, "0x%04x\n", ar2->channel_mask);
+}
+
+static ssize_t ati_remote2_store_channel_mask(struct device *dev,
+					      struct device_attribute *attr,
+					      const char *buf, size_t count)
+{
+	struct usb_device *udev = to_usb_device(dev);
+	struct usb_interface *intf = usb_ifnum_to_if(udev, 0);
+	struct ati_remote2 *ar2 = usb_get_intfdata(intf);
+	unsigned int mask;
+	int r;
+
+	r = kstrtouint(buf, 0, &mask);
+	if (r)
+		return r;
+
+	if (mask & ~ATI_REMOTE2_MAX_CHANNEL_MASK)
+		return -EINVAL;
+
+	r = usb_autopm_get_interface(ar2->intf[0]);
+	if (r) {
+		dev_err(&ar2->intf[0]->dev,
+			"%s(): usb_autopm_get_interface() = %d\n", __func__, r);
+		return r;
+	}
+
+	mutex_lock(&ati_remote2_mutex);
+
+	if (mask != ar2->channel_mask) {
+		r = ati_remote2_setup(ar2, mask);
+		if (!r)
+			ar2->channel_mask = mask;
+	}
+
+	mutex_unlock(&ati_remote2_mutex);
+
+	usb_autopm_put_interface(ar2->intf[0]);
+
+	return r ? r : count;
+}
+
+static ssize_t ati_remote2_show_mode_mask(struct device *dev,
+					  struct device_attribute *attr,
+					  char *buf)
+{
+	struct usb_device *udev = to_usb_device(dev);
+	struct usb_interface *intf = usb_ifnum_to_if(udev, 0);
+	struct ati_remote2 *ar2 = usb_get_intfdata(intf);
+
+	return sprintf(buf, "0x%02x\n", ar2->mode_mask);
+}
+
+static ssize_t ati_remote2_store_mode_mask(struct device *dev,
+					   struct device_attribute *attr,
+					   const char *buf, size_t count)
+{
+	struct usb_device *udev = to_usb_device(dev);
+	struct usb_interface *intf = usb_ifnum_to_if(udev, 0);
+	struct ati_remote2 *ar2 = usb_get_intfdata(intf);
+	unsigned int mask;
+	int err;
+
+	err = kstrtouint(buf, 0, &mask);
+	if (err)
+		return err;
+
+	if (mask & ~ATI_REMOTE2_MAX_MODE_MASK)
+		return -EINVAL;
+
+	ar2->mode_mask = mask;
+
+	return count;
+}
+
+static DEVICE_ATTR(channel_mask, 0644, ati_remote2_show_channel_mask,
+		   ati_remote2_store_channel_mask);
+
+static DEVICE_ATTR(mode_mask, 0644, ati_remote2_show_mode_mask,
+		   ati_remote2_store_mode_mask);
+
+static struct attribute *ati_remote2_attrs[] = {
+	&dev_attr_channel_mask.attr,
+	&dev_attr_mode_mask.attr,
+	NULL,
+};
+
+static struct attribute_group ati_remote2_attr_group = {
+	.attrs = ati_remote2_attrs,
+};
+
+static int ati_remote2_probe(struct usb_interface *interface, const struct usb_device_id *id)
+{
+	struct usb_device *udev = interface_to_usbdev(interface);
+	struct usb_host_interface *alt = interface->cur_altsetting;
+	struct ati_remote2 *ar2;
+	int r;
+
+	if (alt->desc.bInterfaceNumber)
+		return -ENODEV;
+
+	ar2 = kzalloc(sizeof (struct ati_remote2), GFP_KERNEL);
+	if (!ar2)
+		return -ENOMEM;
+
+	ar2->udev = udev;
+
+	ar2->intf[0] = interface;
+	ar2->ep[0] = &alt->endpoint[0].desc;
+
+	ar2->intf[1] = usb_ifnum_to_if(udev, 1);
+	r = usb_driver_claim_interface(&ati_remote2_driver, ar2->intf[1], ar2);
+	if (r)
+		goto fail1;
+	alt = ar2->intf[1]->cur_altsetting;
+	ar2->ep[1] = &alt->endpoint[0].desc;
+
+	r = ati_remote2_urb_init(ar2);
+	if (r)
+		goto fail2;
+
+	ar2->channel_mask = channel_mask;
+	ar2->mode_mask = mode_mask;
+
+	r = ati_remote2_setup(ar2, ar2->channel_mask);
+	if (r)
+		goto fail2;
+
+	usb_make_path(udev, ar2->phys, sizeof(ar2->phys));
+	strlcat(ar2->phys, "/input0", sizeof(ar2->phys));
+
+	strlcat(ar2->name, "ATI Remote Wonder II", sizeof(ar2->name));
+
+	r = sysfs_create_group(&udev->dev.kobj, &ati_remote2_attr_group);
+	if (r)
+		goto fail2;
+
+	r = ati_remote2_input_init(ar2);
+	if (r)
+		goto fail3;
+
+	usb_set_intfdata(interface, ar2);
+
+	interface->needs_remote_wakeup = 1;
+
+	return 0;
+
+ fail3:
+	sysfs_remove_group(&udev->dev.kobj, &ati_remote2_attr_group);
+ fail2:
+	ati_remote2_urb_cleanup(ar2);
+	usb_driver_release_interface(&ati_remote2_driver, ar2->intf[1]);
+ fail1:
+	kfree(ar2);
+
+	return r;
+}
+
+static void ati_remote2_disconnect(struct usb_interface *interface)
+{
+	struct ati_remote2 *ar2;
+	struct usb_host_interface *alt = interface->cur_altsetting;
+
+	if (alt->desc.bInterfaceNumber)
+		return;
+
+	ar2 = usb_get_intfdata(interface);
+	usb_set_intfdata(interface, NULL);
+
+	input_unregister_device(ar2->idev);
+
+	sysfs_remove_group(&ar2->udev->dev.kobj, &ati_remote2_attr_group);
+
+	ati_remote2_urb_cleanup(ar2);
+
+	usb_driver_release_interface(&ati_remote2_driver, ar2->intf[1]);
+
+	kfree(ar2);
+}
+
+static int ati_remote2_suspend(struct usb_interface *interface,
+			       pm_message_t message)
+{
+	struct ati_remote2 *ar2;
+	struct usb_host_interface *alt = interface->cur_altsetting;
+
+	if (alt->desc.bInterfaceNumber)
+		return 0;
+
+	ar2 = usb_get_intfdata(interface);
+
+	dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
+
+	mutex_lock(&ati_remote2_mutex);
+
+	if (ar2->flags & ATI_REMOTE2_OPENED)
+		ati_remote2_kill_urbs(ar2);
+
+	ar2->flags |= ATI_REMOTE2_SUSPENDED;
+
+	mutex_unlock(&ati_remote2_mutex);
+
+	return 0;
+}
+
+static int ati_remote2_resume(struct usb_interface *interface)
+{
+	struct ati_remote2 *ar2;
+	struct usb_host_interface *alt = interface->cur_altsetting;
+	int r = 0;
+
+	if (alt->desc.bInterfaceNumber)
+		return 0;
+
+	ar2 = usb_get_intfdata(interface);
+
+	dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
+
+	mutex_lock(&ati_remote2_mutex);
+
+	if (ar2->flags & ATI_REMOTE2_OPENED)
+		r = ati_remote2_submit_urbs(ar2);
+
+	if (!r)
+		ar2->flags &= ~ATI_REMOTE2_SUSPENDED;
+
+	mutex_unlock(&ati_remote2_mutex);
+
+	return r;
+}
+
+static int ati_remote2_reset_resume(struct usb_interface *interface)
+{
+	struct ati_remote2 *ar2;
+	struct usb_host_interface *alt = interface->cur_altsetting;
+	int r = 0;
+
+	if (alt->desc.bInterfaceNumber)
+		return 0;
+
+	ar2 = usb_get_intfdata(interface);
+
+	dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
+
+	mutex_lock(&ati_remote2_mutex);
+
+	r = ati_remote2_setup(ar2, ar2->channel_mask);
+	if (r)
+		goto out;
+
+	if (ar2->flags & ATI_REMOTE2_OPENED)
+		r = ati_remote2_submit_urbs(ar2);
+
+	if (!r)
+		ar2->flags &= ~ATI_REMOTE2_SUSPENDED;
+
+ out:
+	mutex_unlock(&ati_remote2_mutex);
+
+	return r;
+}
+
+static int ati_remote2_pre_reset(struct usb_interface *interface)
+{
+	struct ati_remote2 *ar2;
+	struct usb_host_interface *alt = interface->cur_altsetting;
+
+	if (alt->desc.bInterfaceNumber)
+		return 0;
+
+	ar2 = usb_get_intfdata(interface);
+
+	dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
+
+	mutex_lock(&ati_remote2_mutex);
+
+	if (ar2->flags == ATI_REMOTE2_OPENED)
+		ati_remote2_kill_urbs(ar2);
+
+	return 0;
+}
+
+static int ati_remote2_post_reset(struct usb_interface *interface)
+{
+	struct ati_remote2 *ar2;
+	struct usb_host_interface *alt = interface->cur_altsetting;
+	int r = 0;
+
+	if (alt->desc.bInterfaceNumber)
+		return 0;
+
+	ar2 = usb_get_intfdata(interface);
+
+	dev_dbg(&ar2->intf[0]->dev, "%s()\n", __func__);
+
+	if (ar2->flags == ATI_REMOTE2_OPENED)
+		r = ati_remote2_submit_urbs(ar2);
+
+	mutex_unlock(&ati_remote2_mutex);
+
+	return r;
+}
+
+module_usb_driver(ati_remote2_driver);
diff --git a/drivers/input/misc/atlas_btns.c b/drivers/input/misc/atlas_btns.c
new file mode 100644
index 00000000..5d440236
--- /dev/null
+++ b/drivers/input/misc/atlas_btns.c
@@ -0,0 +1,159 @@
+/*
+ *  atlas_btns.c - Atlas Wallmount Touchscreen ACPI Extras
+ *
+ *  Copyright (C) 2006 Jaya Kumar
+ *  Based on Toshiba ACPI by John Belmonte and ASUS ACPI
+ *  This work was sponsored by CIS(M) Sdn Bhd.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/types.h>
+#include <asm/uaccess.h>
+#include <acpi/acpi_drivers.h>
+
+#define ACPI_ATLAS_NAME		"Atlas ACPI"
+#define ACPI_ATLAS_CLASS	"Atlas"
+
+static unsigned short atlas_keymap[16];
+static struct input_dev *input_dev;
+
+/* button handling code */
+static acpi_status acpi_atlas_button_setup(acpi_handle region_handle,
+		    u32 function, void *handler_context, void **return_context)
+{
+	*return_context =
+		(function != ACPI_REGION_DEACTIVATE) ? handler_context : NULL;
+
+	return AE_OK;
+}
+
+static acpi_status acpi_atlas_button_handler(u32 function,
+		      acpi_physical_address address,
+		      u32 bit_width, u64 *value,
+		      void *handler_context, void *region_context)
+{
+	acpi_status status;
+
+	if (function == ACPI_WRITE) {
+		int code = address & 0x0f;
+		int key_down = !(address & 0x10);
+
+		input_event(input_dev, EV_MSC, MSC_SCAN, code);
+		input_report_key(input_dev, atlas_keymap[code], key_down);
+		input_sync(input_dev);
+
+		status = AE_OK;
+	} else {
+		pr_warn("shrugged on unexpected function: function=%x,address=%lx,value=%x\n",
+			function, (unsigned long)address, (u32)*value);
+		status = AE_BAD_PARAMETER;
+	}
+
+	return status;
+}
+
+static int atlas_acpi_button_add(struct acpi_device *device)
+{
+	acpi_status status;
+	int i;
+	int err;
+
+	input_dev = input_allocate_device();
+	if (!input_dev) {
+		pr_err("unable to allocate input device\n");
+		return -ENOMEM;
+	}
+
+	input_dev->name = "Atlas ACPI button driver";
+	input_dev->phys = "ASIM0000/atlas/input0";
+	input_dev->id.bustype = BUS_HOST;
+	input_dev->keycode = atlas_keymap;
+	input_dev->keycodesize = sizeof(unsigned short);
+	input_dev->keycodemax = ARRAY_SIZE(atlas_keymap);
+
+	input_set_capability(input_dev, EV_MSC, MSC_SCAN);
+	__set_bit(EV_KEY, input_dev->evbit);
+	for (i = 0; i < ARRAY_SIZE(atlas_keymap); i++) {
+		if (i < 9) {
+			atlas_keymap[i] = KEY_F1 + i;
+			__set_bit(KEY_F1 + i, input_dev->keybit);
+		} else
+			atlas_keymap[i] = KEY_RESERVED;
+	}
+
+	err = input_register_device(input_dev);
+	if (err) {
+		pr_err("couldn't register input device\n");
+		input_free_device(input_dev);
+		return err;
+	}
+
+	/* hookup button handler */
+	status = acpi_install_address_space_handler(device->handle,
+				0x81, &acpi_atlas_button_handler,
+				&acpi_atlas_button_setup, device);
+	if (ACPI_FAILURE(status)) {
+		pr_err("error installing addr spc handler\n");
+		input_unregister_device(input_dev);
+		err = -EINVAL;
+	}
+
+	return err;
+}
+
+static int atlas_acpi_button_remove(struct acpi_device *device)
+{
+	acpi_status status;
+
+	status = acpi_remove_address_space_handler(device->handle,
+				0x81, &acpi_atlas_button_handler);
+	if (ACPI_FAILURE(status))
+		pr_err("error removing addr spc handler\n");
+
+	input_unregister_device(input_dev);
+
+	return 0;
+}
+
+static const struct acpi_device_id atlas_device_ids[] = {
+	{"ASIM0000", 0},
+	{"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, atlas_device_ids);
+
+static struct acpi_driver atlas_acpi_driver = {
+	.name	= ACPI_ATLAS_NAME,
+	.class	= ACPI_ATLAS_CLASS,
+	.owner	= THIS_MODULE,
+	.ids	= atlas_device_ids,
+	.ops	= {
+		.add	= atlas_acpi_button_add,
+		.remove	= atlas_acpi_button_remove,
+	},
+};
+module_acpi_driver(atlas_acpi_driver);
+
+MODULE_AUTHOR("Jaya Kumar");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Atlas button driver");
+
diff --git a/drivers/input/misc/bfin_rotary.c b/drivers/input/misc/bfin_rotary.c
new file mode 100644
index 00000000..a6666e14
--- /dev/null
+++ b/drivers/input/misc/bfin_rotary.c
@@ -0,0 +1,272 @@
+/*
+ * Rotary counter driver for Analog Devices Blackfin Processors
+ *
+ * Copyright 2008-2009 Analog Devices Inc.
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/pm.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+
+#include <asm/portmux.h>
+#include <asm/bfin_rotary.h>
+
+static const u16 per_cnt[] = {
+	P_CNT_CUD,
+	P_CNT_CDG,
+	P_CNT_CZM,
+	0
+};
+
+struct bfin_rot {
+	struct input_dev *input;
+	int irq;
+	unsigned int up_key;
+	unsigned int down_key;
+	unsigned int button_key;
+	unsigned int rel_code;
+	unsigned short cnt_config;
+	unsigned short cnt_imask;
+	unsigned short cnt_debounce;
+};
+
+static void report_key_event(struct input_dev *input, int keycode)
+{
+	/* simulate a press-n-release */
+	input_report_key(input, keycode, 1);
+	input_sync(input);
+	input_report_key(input, keycode, 0);
+	input_sync(input);
+}
+
+static void report_rotary_event(struct bfin_rot *rotary, int delta)
+{
+	struct input_dev *input = rotary->input;
+
+	if (rotary->up_key) {
+		report_key_event(input,
+				 delta > 0 ? rotary->up_key : rotary->down_key);
+	} else {
+		input_report_rel(input, rotary->rel_code, delta);
+		input_sync(input);
+	}
+}
+
+static irqreturn_t bfin_rotary_isr(int irq, void *dev_id)
+{
+	struct platform_device *pdev = dev_id;
+	struct bfin_rot *rotary = platform_get_drvdata(pdev);
+	int delta;
+
+	switch (bfin_read_CNT_STATUS()) {
+
+	case ICII:
+		break;
+
+	case UCII:
+	case DCII:
+		delta = bfin_read_CNT_COUNTER();
+		if (delta)
+			report_rotary_event(rotary, delta);
+		break;
+
+	case CZMII:
+		report_key_event(rotary->input, rotary->button_key);
+		break;
+
+	default:
+		break;
+	}
+
+	bfin_write_CNT_COMMAND(W1LCNT_ZERO);	/* Clear COUNTER */
+	bfin_write_CNT_STATUS(-1);	/* Clear STATUS */
+
+	return IRQ_HANDLED;
+}
+
+static int bfin_rotary_probe(struct platform_device *pdev)
+{
+	struct bfin_rotary_platform_data *pdata = pdev->dev.platform_data;
+	struct bfin_rot *rotary;
+	struct input_dev *input;
+	int error;
+
+	/* Basic validation */
+	if ((pdata->rotary_up_key && !pdata->rotary_down_key) ||
+	    (!pdata->rotary_up_key && pdata->rotary_down_key)) {
+		return -EINVAL;
+	}
+
+	error = peripheral_request_list(per_cnt, dev_name(&pdev->dev));
+	if (error) {
+		dev_err(&pdev->dev, "requesting peripherals failed\n");
+		return error;
+	}
+
+	rotary = kzalloc(sizeof(struct bfin_rot), GFP_KERNEL);
+	input = input_allocate_device();
+	if (!rotary || !input) {
+		error = -ENOMEM;
+		goto out1;
+	}
+
+	rotary->input = input;
+
+	rotary->up_key = pdata->rotary_up_key;
+	rotary->down_key = pdata->rotary_down_key;
+	rotary->button_key = pdata->rotary_button_key;
+	rotary->rel_code = pdata->rotary_rel_code;
+
+	error = rotary->irq = platform_get_irq(pdev, 0);
+	if (error < 0)
+		goto out1;
+
+	input->name = pdev->name;
+	input->phys = "bfin-rotary/input0";
+	input->dev.parent = &pdev->dev;
+
+	input_set_drvdata(input, rotary);
+
+	input->id.bustype = BUS_HOST;
+	input->id.vendor = 0x0001;
+	input->id.product = 0x0001;
+	input->id.version = 0x0100;
+
+	if (rotary->up_key) {
+		__set_bit(EV_KEY, input->evbit);
+		__set_bit(rotary->up_key, input->keybit);
+		__set_bit(rotary->down_key, input->keybit);
+	} else {
+		__set_bit(EV_REL, input->evbit);
+		__set_bit(rotary->rel_code, input->relbit);
+	}
+
+	if (rotary->button_key) {
+		__set_bit(EV_KEY, input->evbit);
+		__set_bit(rotary->button_key, input->keybit);
+	}
+
+	error = request_irq(rotary->irq, bfin_rotary_isr,
+			    0, dev_name(&pdev->dev), pdev);
+	if (error) {
+		dev_err(&pdev->dev,
+			"unable to claim irq %d; error %d\n",
+			rotary->irq, error);
+		goto out1;
+	}
+
+	error = input_register_device(input);
+	if (error) {
+		dev_err(&pdev->dev,
+			"unable to register input device (%d)\n", error);
+		goto out2;
+	}
+
+	if (pdata->rotary_button_key)
+		bfin_write_CNT_IMASK(CZMIE);
+
+	if (pdata->mode & ROT_DEBE)
+		bfin_write_CNT_DEBOUNCE(pdata->debounce & DPRESCALE);
+
+	if (pdata->mode)
+		bfin_write_CNT_CONFIG(bfin_read_CNT_CONFIG() |
+					(pdata->mode & ~CNTE));
+
+	bfin_write_CNT_IMASK(bfin_read_CNT_IMASK() | UCIE | DCIE);
+	bfin_write_CNT_CONFIG(bfin_read_CNT_CONFIG() | CNTE);
+
+	platform_set_drvdata(pdev, rotary);
+	device_init_wakeup(&pdev->dev, 1);
+
+	return 0;
+
+out2:
+	free_irq(rotary->irq, pdev);
+out1:
+	input_free_device(input);
+	kfree(rotary);
+	peripheral_free_list(per_cnt);
+
+	return error;
+}
+
+static int bfin_rotary_remove(struct platform_device *pdev)
+{
+	struct bfin_rot *rotary = platform_get_drvdata(pdev);
+
+	bfin_write_CNT_CONFIG(0);
+	bfin_write_CNT_IMASK(0);
+
+	free_irq(rotary->irq, pdev);
+	input_unregister_device(rotary->input);
+	peripheral_free_list(per_cnt);
+
+	kfree(rotary);
+	platform_set_drvdata(pdev, NULL);
+
+	return 0;
+}
+
+#ifdef CONFIG_PM
+static int bfin_rotary_suspend(struct device *dev)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct bfin_rot *rotary = platform_get_drvdata(pdev);
+
+	rotary->cnt_config = bfin_read_CNT_CONFIG();
+	rotary->cnt_imask = bfin_read_CNT_IMASK();
+	rotary->cnt_debounce = bfin_read_CNT_DEBOUNCE();
+
+	if (device_may_wakeup(&pdev->dev))
+		enable_irq_wake(rotary->irq);
+
+	return 0;
+}
+
+static int bfin_rotary_resume(struct device *dev)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct bfin_rot *rotary = platform_get_drvdata(pdev);
+
+	bfin_write_CNT_DEBOUNCE(rotary->cnt_debounce);
+	bfin_write_CNT_IMASK(rotary->cnt_imask);
+	bfin_write_CNT_CONFIG(rotary->cnt_config & ~CNTE);
+
+	if (device_may_wakeup(&pdev->dev))
+		disable_irq_wake(rotary->irq);
+
+	if (rotary->cnt_config & CNTE)
+		bfin_write_CNT_CONFIG(rotary->cnt_config);
+
+	return 0;
+}
+
+static const struct dev_pm_ops bfin_rotary_pm_ops = {
+	.suspend	= bfin_rotary_suspend,
+	.resume		= bfin_rotary_resume,
+};
+#endif
+
+static struct platform_driver bfin_rotary_device_driver = {
+	.probe		= bfin_rotary_probe,
+	.remove		= bfin_rotary_remove,
+	.driver		= {
+		.name	= "bfin-rotary",
+		.owner	= THIS_MODULE,
+#ifdef CONFIG_PM
+		.pm	= &bfin_rotary_pm_ops,
+#endif
+	},
+};
+module_platform_driver(bfin_rotary_device_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("Rotary Counter driver for Blackfin Processors");
+MODULE_ALIAS("platform:bfin-rotary");
diff --git a/drivers/input/misc/bma150.c b/drivers/input/misc/bma150.c
new file mode 100644
index 00000000..865c2f9d
--- /dev/null
+++ b/drivers/input/misc/bma150.c
@@ -0,0 +1,668 @@
+/*
+ * Copyright (c) 2011 Bosch Sensortec GmbH
+ * Copyright (c) 2011 Unixphere
+ *
+ * This driver adds support for Bosch Sensortec's digital acceleration
+ * sensors BMA150 and SMB380.
+ * The SMB380 is fully compatible with BMA150 and only differs in packaging.
+ *
+ * The datasheet for the BMA150 chip can be found here:
+ * http://www.bosch-sensortec.com/content/language1/downloads/BST-BMA150-DS000-07.pdf
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/input-polldev.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
+#include <linux/bma150.h>
+
+#define ABSMAX_ACC_VAL		0x01FF
+#define ABSMIN_ACC_VAL		-(ABSMAX_ACC_VAL)
+
+/* Each axis is represented by a 2-byte data word */
+#define BMA150_XYZ_DATA_SIZE	6
+
+/* Input poll interval in milliseconds */
+#define BMA150_POLL_INTERVAL	10
+#define BMA150_POLL_MAX		200
+#define BMA150_POLL_MIN		0
+
+#define BMA150_MODE_NORMAL	0
+#define BMA150_MODE_SLEEP	2
+#define BMA150_MODE_WAKE_UP	3
+
+/* Data register addresses */
+#define BMA150_DATA_0_REG	0x00
+#define BMA150_DATA_1_REG	0x01
+#define BMA150_DATA_2_REG	0x02
+
+/* Control register addresses */
+#define BMA150_CTRL_0_REG	0x0A
+#define BMA150_CTRL_1_REG	0x0B
+#define BMA150_CTRL_2_REG	0x14
+#define BMA150_CTRL_3_REG	0x15
+
+/* Configuration/Setting register addresses */
+#define BMA150_CFG_0_REG	0x0C
+#define BMA150_CFG_1_REG	0x0D
+#define BMA150_CFG_2_REG	0x0E
+#define BMA150_CFG_3_REG	0x0F
+#define BMA150_CFG_4_REG	0x10
+#define BMA150_CFG_5_REG	0x11
+
+#define BMA150_CHIP_ID		2
+#define BMA150_CHIP_ID_REG	BMA150_DATA_0_REG
+
+#define BMA150_ACC_X_LSB_REG	BMA150_DATA_2_REG
+
+#define BMA150_SLEEP_POS	0
+#define BMA150_SLEEP_MSK	0x01
+#define BMA150_SLEEP_REG	BMA150_CTRL_0_REG
+
+#define BMA150_BANDWIDTH_POS	0
+#define BMA150_BANDWIDTH_MSK	0x07
+#define BMA150_BANDWIDTH_REG	BMA150_CTRL_2_REG
+
+#define BMA150_RANGE_POS	3
+#define BMA150_RANGE_MSK	0x18
+#define BMA150_RANGE_REG	BMA150_CTRL_2_REG
+
+#define BMA150_WAKE_UP_POS	0
+#define BMA150_WAKE_UP_MSK	0x01
+#define BMA150_WAKE_UP_REG	BMA150_CTRL_3_REG
+
+#define BMA150_SW_RES_POS	1
+#define BMA150_SW_RES_MSK	0x02
+#define BMA150_SW_RES_REG	BMA150_CTRL_0_REG
+
+/* Any-motion interrupt register fields */
+#define BMA150_ANY_MOTION_EN_POS	6
+#define BMA150_ANY_MOTION_EN_MSK	0x40
+#define BMA150_ANY_MOTION_EN_REG	BMA150_CTRL_1_REG
+
+#define BMA150_ANY_MOTION_DUR_POS	6
+#define BMA150_ANY_MOTION_DUR_MSK	0xC0
+#define BMA150_ANY_MOTION_DUR_REG	BMA150_CFG_5_REG
+
+#define BMA150_ANY_MOTION_THRES_REG	BMA150_CFG_4_REG
+
+/* Advanced interrupt register fields */
+#define BMA150_ADV_INT_EN_POS		6
+#define BMA150_ADV_INT_EN_MSK		0x40
+#define BMA150_ADV_INT_EN_REG		BMA150_CTRL_3_REG
+
+/* High-G interrupt register fields */
+#define BMA150_HIGH_G_EN_POS		1
+#define BMA150_HIGH_G_EN_MSK		0x02
+#define BMA150_HIGH_G_EN_REG		BMA150_CTRL_1_REG
+
+#define BMA150_HIGH_G_HYST_POS		3
+#define BMA150_HIGH_G_HYST_MSK		0x38
+#define BMA150_HIGH_G_HYST_REG		BMA150_CFG_5_REG
+
+#define BMA150_HIGH_G_DUR_REG		BMA150_CFG_3_REG
+#define BMA150_HIGH_G_THRES_REG		BMA150_CFG_2_REG
+
+/* Low-G interrupt register fields */
+#define BMA150_LOW_G_EN_POS		0
+#define BMA150_LOW_G_EN_MSK		0x01
+#define BMA150_LOW_G_EN_REG		BMA150_CTRL_1_REG
+
+#define BMA150_LOW_G_HYST_POS		0
+#define BMA150_LOW_G_HYST_MSK		0x07
+#define BMA150_LOW_G_HYST_REG		BMA150_CFG_5_REG
+
+#define BMA150_LOW_G_DUR_REG		BMA150_CFG_1_REG
+#define BMA150_LOW_G_THRES_REG		BMA150_CFG_0_REG
+
+struct bma150_data {
+	struct i2c_client *client;
+	struct input_polled_dev *input_polled;
+	struct input_dev *input;
+	u8 mode;
+};
+
+/*
+ * The settings for the given range, bandwidth and interrupt features
+ * are stated and verified by Bosch Sensortec where they are configured
+ * to provide a generic sensitivity performance.
+ */
+static struct bma150_cfg default_cfg = {
+	.any_motion_int = 1,
+	.hg_int = 1,
+	.lg_int = 1,
+	.any_motion_dur = 0,
+	.any_motion_thres = 0,
+	.hg_hyst = 0,
+	.hg_dur = 150,
+	.hg_thres = 160,
+	.lg_hyst = 0,
+	.lg_dur = 150,
+	.lg_thres = 20,
+	.range = BMA150_RANGE_2G,
+	.bandwidth = BMA150_BW_50HZ
+};
+
+static int bma150_write_byte(struct i2c_client *client, u8 reg, u8 val)
+{
+	s32 ret;
+
+	/* As per specification, disable irq in between register writes */
+	if (client->irq)
+		disable_irq_nosync(client->irq);
+
+	ret = i2c_smbus_write_byte_data(client, reg, val);
+
+	if (client->irq)
+		enable_irq(client->irq);
+
+	return ret;
+}
+
+static int bma150_set_reg_bits(struct i2c_client *client,
+					int val, int shift, u8 mask, u8 reg)
+{
+	int data;
+
+	data = i2c_smbus_read_byte_data(client, reg);
+	if (data < 0)
+		return data;
+
+	data = (data & ~mask) | ((val << shift) & mask);
+	return bma150_write_byte(client, reg, data);
+}
+
+static int bma150_set_mode(struct bma150_data *bma150, u8 mode)
+{
+	int error;
+
+	error = bma150_set_reg_bits(bma150->client, mode, BMA150_WAKE_UP_POS,
+				BMA150_WAKE_UP_MSK, BMA150_WAKE_UP_REG);
+	if (error)
+		return error;
+
+	error = bma150_set_reg_bits(bma150->client, mode, BMA150_SLEEP_POS,
+				BMA150_SLEEP_MSK, BMA150_SLEEP_REG);
+	if (error)
+		return error;
+
+	if (mode == BMA150_MODE_NORMAL)
+		msleep(2);
+
+	bma150->mode = mode;
+	return 0;
+}
+
+static int bma150_soft_reset(struct bma150_data *bma150)
+{
+	int error;
+
+	error = bma150_set_reg_bits(bma150->client, 1, BMA150_SW_RES_POS,
+				BMA150_SW_RES_MSK, BMA150_SW_RES_REG);
+	if (error)
+		return error;
+
+	msleep(2);
+	return 0;
+}
+
+static int bma150_set_range(struct bma150_data *bma150, u8 range)
+{
+	return bma150_set_reg_bits(bma150->client, range, BMA150_RANGE_POS,
+				BMA150_RANGE_MSK, BMA150_RANGE_REG);
+}
+
+static int bma150_set_bandwidth(struct bma150_data *bma150, u8 bw)
+{
+	return bma150_set_reg_bits(bma150->client, bw, BMA150_BANDWIDTH_POS,
+				BMA150_BANDWIDTH_MSK, BMA150_BANDWIDTH_REG);
+}
+
+static int bma150_set_low_g_interrupt(struct bma150_data *bma150,
+					u8 enable, u8 hyst, u8 dur, u8 thres)
+{
+	int error;
+
+	error = bma150_set_reg_bits(bma150->client, hyst,
+				BMA150_LOW_G_HYST_POS, BMA150_LOW_G_HYST_MSK,
+				BMA150_LOW_G_HYST_REG);
+	if (error)
+		return error;
+
+	error = bma150_write_byte(bma150->client, BMA150_LOW_G_DUR_REG, dur);
+	if (error)
+		return error;
+
+	error = bma150_write_byte(bma150->client, BMA150_LOW_G_THRES_REG, thres);
+	if (error)
+		return error;
+
+	return bma150_set_reg_bits(bma150->client, !!enable,
+				BMA150_LOW_G_EN_POS, BMA150_LOW_G_EN_MSK,
+				BMA150_LOW_G_EN_REG);
+}
+
+static int bma150_set_high_g_interrupt(struct bma150_data *bma150,
+					u8 enable, u8 hyst, u8 dur, u8 thres)
+{
+	int error;
+
+	error = bma150_set_reg_bits(bma150->client, hyst,
+				BMA150_HIGH_G_HYST_POS, BMA150_HIGH_G_HYST_MSK,
+				BMA150_HIGH_G_HYST_REG);
+	if (error)
+		return error;
+
+	error = bma150_write_byte(bma150->client,
+				BMA150_HIGH_G_DUR_REG, dur);
+	if (error)
+		return error;
+
+	error = bma150_write_byte(bma150->client,
+				BMA150_HIGH_G_THRES_REG, thres);
+	if (error)
+		return error;
+
+	return bma150_set_reg_bits(bma150->client, !!enable,
+				BMA150_HIGH_G_EN_POS, BMA150_HIGH_G_EN_MSK,
+				BMA150_HIGH_G_EN_REG);
+}
+
+
+static int bma150_set_any_motion_interrupt(struct bma150_data *bma150,
+						u8 enable, u8 dur, u8 thres)
+{
+	int error;
+
+	error = bma150_set_reg_bits(bma150->client, dur,
+				BMA150_ANY_MOTION_DUR_POS,
+				BMA150_ANY_MOTION_DUR_MSK,
+				BMA150_ANY_MOTION_DUR_REG);
+	if (error)
+		return error;
+
+	error = bma150_write_byte(bma150->client,
+				BMA150_ANY_MOTION_THRES_REG, thres);
+	if (error)
+		return error;
+
+	error = bma150_set_reg_bits(bma150->client, !!enable,
+				BMA150_ADV_INT_EN_POS, BMA150_ADV_INT_EN_MSK,
+				BMA150_ADV_INT_EN_REG);
+	if (error)
+		return error;
+
+	return bma150_set_reg_bits(bma150->client, !!enable,
+				BMA150_ANY_MOTION_EN_POS,
+				BMA150_ANY_MOTION_EN_MSK,
+				BMA150_ANY_MOTION_EN_REG);
+}
+
+static void bma150_report_xyz(struct bma150_data *bma150)
+{
+	u8 data[BMA150_XYZ_DATA_SIZE];
+	s16 x, y, z;
+	s32 ret;
+
+	ret = i2c_smbus_read_i2c_block_data(bma150->client,
+			BMA150_ACC_X_LSB_REG, BMA150_XYZ_DATA_SIZE, data);
+	if (ret != BMA150_XYZ_DATA_SIZE)
+		return;
+
+	x = ((0xc0 & data[0]) >> 6) | (data[1] << 2);
+	y = ((0xc0 & data[2]) >> 6) | (data[3] << 2);
+	z = ((0xc0 & data[4]) >> 6) | (data[5] << 2);
+
+	/* sign extension */
+	x = (s16) (x << 6) >> 6;
+	y = (s16) (y << 6) >> 6;
+	z = (s16) (z << 6) >> 6;
+
+	input_report_abs(bma150->input, ABS_X, x);
+	input_report_abs(bma150->input, ABS_Y, y);
+	input_report_abs(bma150->input, ABS_Z, z);
+	input_sync(bma150->input);
+}
+
+static irqreturn_t bma150_irq_thread(int irq, void *dev)
+{
+	bma150_report_xyz(dev);
+
+	return IRQ_HANDLED;
+}
+
+static void bma150_poll(struct input_polled_dev *dev)
+{
+	bma150_report_xyz(dev->private);
+}
+
+static int bma150_open(struct bma150_data *bma150)
+{
+	int error;
+
+	error = pm_runtime_get_sync(&bma150->client->dev);
+	if (error < 0 && error != -ENOSYS)
+		return error;
+
+	/*
+	 * See if runtime PM woke up the device. If runtime PM
+	 * is disabled we need to do it ourselves.
+	 */
+	if (bma150->mode != BMA150_MODE_NORMAL) {
+		error = bma150_set_mode(bma150, BMA150_MODE_NORMAL);
+		if (error)
+			return error;
+	}
+
+	return 0;
+}
+
+static void bma150_close(struct bma150_data *bma150)
+{
+	pm_runtime_put_sync(&bma150->client->dev);
+
+	if (bma150->mode != BMA150_MODE_SLEEP)
+		bma150_set_mode(bma150, BMA150_MODE_SLEEP);
+}
+
+static int bma150_irq_open(struct input_dev *input)
+{
+	struct bma150_data *bma150 = input_get_drvdata(input);
+
+	return bma150_open(bma150);
+}
+
+static void bma150_irq_close(struct input_dev *input)
+{
+	struct bma150_data *bma150 = input_get_drvdata(input);
+
+	bma150_close(bma150);
+}
+
+static void bma150_poll_open(struct input_polled_dev *ipoll_dev)
+{
+	struct bma150_data *bma150 = ipoll_dev->private;
+
+	bma150_open(bma150);
+}
+
+static void bma150_poll_close(struct input_polled_dev *ipoll_dev)
+{
+	struct bma150_data *bma150 = ipoll_dev->private;
+
+	bma150_close(bma150);
+}
+
+static int bma150_initialize(struct bma150_data *bma150,
+				       const struct bma150_cfg *cfg)
+{
+	int error;
+
+	error = bma150_soft_reset(bma150);
+	if (error)
+		return error;
+
+	error = bma150_set_bandwidth(bma150, cfg->bandwidth);
+	if (error)
+		return error;
+
+	error = bma150_set_range(bma150, cfg->range);
+	if (error)
+		return error;
+
+	if (bma150->client->irq) {
+		error = bma150_set_any_motion_interrupt(bma150,
+					cfg->any_motion_int,
+					cfg->any_motion_dur,
+					cfg->any_motion_thres);
+		if (error)
+			return error;
+
+		error = bma150_set_high_g_interrupt(bma150,
+					cfg->hg_int, cfg->hg_hyst,
+					cfg->hg_dur, cfg->hg_thres);
+		if (error)
+			return error;
+
+		error = bma150_set_low_g_interrupt(bma150,
+					cfg->lg_int, cfg->lg_hyst,
+					cfg->lg_dur, cfg->lg_thres);
+		if (error)
+			return error;
+	}
+
+	return bma150_set_mode(bma150, BMA150_MODE_SLEEP);
+}
+
+static void bma150_init_input_device(struct bma150_data *bma150,
+						struct input_dev *idev)
+{
+	idev->name = BMA150_DRIVER;
+	idev->phys = BMA150_DRIVER "/input0";
+	idev->id.bustype = BUS_I2C;
+	idev->dev.parent = &bma150->client->dev;
+
+	idev->evbit[0] = BIT_MASK(EV_ABS);
+	input_set_abs_params(idev, ABS_X, ABSMIN_ACC_VAL, ABSMAX_ACC_VAL, 0, 0);
+	input_set_abs_params(idev, ABS_Y, ABSMIN_ACC_VAL, ABSMAX_ACC_VAL, 0, 0);
+	input_set_abs_params(idev, ABS_Z, ABSMIN_ACC_VAL, ABSMAX_ACC_VAL, 0, 0);
+}
+
+static int bma150_register_input_device(struct bma150_data *bma150)
+{
+	struct input_dev *idev;
+	int error;
+
+	idev = input_allocate_device();
+	if (!idev)
+		return -ENOMEM;
+
+	bma150_init_input_device(bma150, idev);
+
+	idev->open = bma150_irq_open;
+	idev->close = bma150_irq_close;
+	input_set_drvdata(idev, bma150);
+
+	error = input_register_device(idev);
+	if (error) {
+		input_free_device(idev);
+		return error;
+	}
+
+	bma150->input = idev;
+	return 0;
+}
+
+static int bma150_register_polled_device(struct bma150_data *bma150)
+{
+	struct input_polled_dev *ipoll_dev;
+	int error;
+
+	ipoll_dev = input_allocate_polled_device();
+	if (!ipoll_dev)
+		return -ENOMEM;
+
+	ipoll_dev->private = bma150;
+	ipoll_dev->open = bma150_poll_open;
+	ipoll_dev->close = bma150_poll_close;
+	ipoll_dev->poll = bma150_poll;
+	ipoll_dev->poll_interval = BMA150_POLL_INTERVAL;
+	ipoll_dev->poll_interval_min = BMA150_POLL_MIN;
+	ipoll_dev->poll_interval_max = BMA150_POLL_MAX;
+
+	bma150_init_input_device(bma150, ipoll_dev->input);
+
+	error = input_register_polled_device(ipoll_dev);
+	if (error) {
+		input_free_polled_device(ipoll_dev);
+		return error;
+	}
+
+	bma150->input_polled = ipoll_dev;
+	bma150->input = ipoll_dev->input;
+
+	return 0;
+}
+
+static int bma150_probe(struct i2c_client *client,
+				  const struct i2c_device_id *id)
+{
+	const struct bma150_platform_data *pdata = client->dev.platform_data;
+	const struct bma150_cfg *cfg;
+	struct bma150_data *bma150;
+	int chip_id;
+	int error;
+
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+		dev_err(&client->dev, "i2c_check_functionality error\n");
+		return -EIO;
+	}
+
+	chip_id = i2c_smbus_read_byte_data(client, BMA150_CHIP_ID_REG);
+	if (chip_id != BMA150_CHIP_ID) {
+		dev_err(&client->dev, "BMA150 chip id error: %d\n", chip_id);
+		return -EINVAL;
+	}
+
+	bma150 = kzalloc(sizeof(struct bma150_data), GFP_KERNEL);
+	if (!bma150)
+		return -ENOMEM;
+
+	bma150->client = client;
+
+	if (pdata) {
+		if (pdata->irq_gpio_cfg) {
+			error = pdata->irq_gpio_cfg();
+			if (error) {
+				dev_err(&client->dev,
+					"IRQ GPIO conf. error %d, error %d\n",
+					client->irq, error);
+				goto err_free_mem;
+			}
+		}
+		cfg = &pdata->cfg;
+	} else {
+		cfg = &default_cfg;
+	}
+
+	error = bma150_initialize(bma150, cfg);
+	if (error)
+		goto err_free_mem;
+
+	if (client->irq > 0) {
+		error = bma150_register_input_device(bma150);
+		if (error)
+			goto err_free_mem;
+
+		error = request_threaded_irq(client->irq,
+					NULL, bma150_irq_thread,
+					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+					BMA150_DRIVER, bma150);
+		if (error) {
+			dev_err(&client->dev,
+				"irq request failed %d, error %d\n",
+				client->irq, error);
+			input_unregister_device(bma150->input);
+			goto err_free_mem;
+		}
+	} else {
+		error = bma150_register_polled_device(bma150);
+		if (error)
+			goto err_free_mem;
+	}
+
+	i2c_set_clientdata(client, bma150);
+
+	pm_runtime_enable(&client->dev);
+
+	return 0;
+
+err_free_mem:
+	kfree(bma150);
+	return error;
+}
+
+static int bma150_remove(struct i2c_client *client)
+{
+	struct bma150_data *bma150 = i2c_get_clientdata(client);
+
+	pm_runtime_disable(&client->dev);
+
+	if (client->irq > 0) {
+		free_irq(client->irq, bma150);
+		input_unregister_device(bma150->input);
+	} else {
+		input_unregister_polled_device(bma150->input_polled);
+		input_free_polled_device(bma150->input_polled);
+	}
+
+	kfree(bma150);
+
+	return 0;
+}
+
+#ifdef CONFIG_PM
+static int bma150_suspend(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma150_data *bma150 = i2c_get_clientdata(client);
+
+	return bma150_set_mode(bma150, BMA150_MODE_SLEEP);
+}
+
+static int bma150_resume(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma150_data *bma150 = i2c_get_clientdata(client);
+
+	return bma150_set_mode(bma150, BMA150_MODE_NORMAL);
+}
+#endif
+
+static UNIVERSAL_DEV_PM_OPS(bma150_pm, bma150_suspend, bma150_resume, NULL);
+
+static const struct i2c_device_id bma150_id[] = {
+	{ "bma150", 0 },
+	{ "smb380", 0 },
+	{ "bma023", 0 },
+	{ }
+};
+
+MODULE_DEVICE_TABLE(i2c, bma150_id);
+
+static struct i2c_driver bma150_driver = {
+	.driver = {
+		.owner	= THIS_MODULE,
+		.name	= BMA150_DRIVER,
+		.pm	= &bma150_pm,
+	},
+	.class		= I2C_CLASS_HWMON,
+	.id_table	= bma150_id,
+	.probe		= bma150_probe,
+	.remove		= bma150_remove,
+};
+
+module_i2c_driver(bma150_driver);
+
+MODULE_AUTHOR("Albert Zhang <xu.zhang@bosch-sensortec.com>");
+MODULE_DESCRIPTION("BMA150 driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/bma2x2.c b/drivers/input/misc/bma2x2.c
new file mode 100644
index 00000000..28ead0b5
--- /dev/null
+++ b/drivers/input/misc/bma2x2.c
@@ -0,0 +1,7564 @@
+/*!
+ * @section LICENSE
+ * $license$
+ *
+ * @filename $filename$
+ * @date    2015/07/13 15:32
+ * @id       $id$
+ * @version  2.1.3
+ *
+ * @brief
+ * This file contains all function implementations for the BMA2X2 in linux
+*/
+
+#ifdef CONFIG_SIG_MOTION
+#undef CONFIG_HAS_EARLYSUSPEND
+#endif
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/workqueue.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
+#include <linux/mutex.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <asm/irq.h>
+#include <asm/mach/irq.h>
+#include <linux/hrtimer.h>
+#include <linux/timer.h>
+
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+#include <linux/earlysuspend.h>
+#endif
+
+#ifdef __KERNEL__
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/unistd.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#else
+#include <unistd.h>
+#include <sys/types.h>
+#include <string.h>
+#endif
+
+
+#include <linux/init.h>
+#include <linux/syscalls.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/fcntl.h>
+#include <asm/uaccess.h>
+
+
+#include "bstclass.h"
+#include "bs_log.h"
+
+#define ACC_NAME  "ACC"
+/*#define CONFIG_BMA_ENABLE_NEWDATA_INT 1*/
+
+#define SENSOR_NAME                 "bma2x2"
+#define ABSMIN                      -512
+#define ABSMAX                      512
+#define SLOPE_THRESHOLD_VALUE       32
+#define SLOPE_DURATION_VALUE        1
+#define INTERRUPT_LATCH_MODE        13
+#define INTERRUPT_ENABLE            1
+#define INTERRUPT_DISABLE           0
+#define MAP_SLOPE_INTERRUPT         2
+#define SLOPE_X_INDEX               5
+#define SLOPE_Y_INDEX               6
+#define SLOPE_Z_INDEX               7
+#define BMA2X2_MAX_DELAY            200
+#define BMA2X2_RANGE_SET            3  /* +/- 2G */
+#define BMA2X2_BW_SET               12 /* 125HZ  */
+
+#define LOW_G_INTERRUPT             REL_Z
+#define HIGH_G_INTERRUPT            REL_HWHEEL
+#define SLOP_INTERRUPT              REL_DIAL
+#define DOUBLE_TAP_INTERRUPT        REL_WHEEL
+#define SINGLE_TAP_INTERRUPT        REL_MISC
+#define ORIENT_INTERRUPT            ABS_PRESSURE
+#define FLAT_INTERRUPT              ABS_DISTANCE
+#define SLOW_NO_MOTION_INTERRUPT    REL_Y
+
+#define HIGH_G_INTERRUPT_X_HAPPENED                 1
+#define HIGH_G_INTERRUPT_Y_HAPPENED                 2
+#define HIGH_G_INTERRUPT_Z_HAPPENED                 3
+#define HIGH_G_INTERRUPT_X_NEGATIVE_HAPPENED        4
+#define HIGH_G_INTERRUPT_Y_NEGATIVE_HAPPENED        5
+#define HIGH_G_INTERRUPT_Z_NEGATIVE_HAPPENED        6
+#define SLOPE_INTERRUPT_X_HAPPENED                  7
+#define SLOPE_INTERRUPT_Y_HAPPENED                  8
+#define SLOPE_INTERRUPT_Z_HAPPENED                  9
+#define SLOPE_INTERRUPT_X_NEGATIVE_HAPPENED         10
+#define SLOPE_INTERRUPT_Y_NEGATIVE_HAPPENED         11
+#define SLOPE_INTERRUPT_Z_NEGATIVE_HAPPENED         12
+#define DOUBLE_TAP_INTERRUPT_HAPPENED               13
+#define SINGLE_TAP_INTERRUPT_HAPPENED               14
+#define UPWARD_PORTRAIT_UP_INTERRUPT_HAPPENED       15
+#define UPWARD_PORTRAIT_DOWN_INTERRUPT_HAPPENED     16
+#define UPWARD_LANDSCAPE_LEFT_INTERRUPT_HAPPENED    17
+#define UPWARD_LANDSCAPE_RIGHT_INTERRUPT_HAPPENED   18
+#define DOWNWARD_PORTRAIT_UP_INTERRUPT_HAPPENED     19
+#define DOWNWARD_PORTRAIT_DOWN_INTERRUPT_HAPPENED   20
+#define DOWNWARD_LANDSCAPE_LEFT_INTERRUPT_HAPPENED  21
+#define DOWNWARD_LANDSCAPE_RIGHT_INTERRUPT_HAPPENED 22
+#define FLAT_INTERRUPT_TURE_HAPPENED                23
+#define FLAT_INTERRUPT_FALSE_HAPPENED               24
+#define LOW_G_INTERRUPT_HAPPENED                    25
+#define SLOW_NO_MOTION_INTERRUPT_HAPPENED           26
+
+#define PAD_LOWG                    0
+#define PAD_HIGHG                   1
+#define PAD_SLOP                    2
+#define PAD_DOUBLE_TAP              3
+#define PAD_SINGLE_TAP              4
+#define PAD_ORIENT                  5
+#define PAD_FLAT                    6
+#define PAD_SLOW_NO_MOTION          7
+
+#define BMA2X2_EEP_OFFSET                       0x16
+#define BMA2X2_IMAGE_BASE                       0x38
+#define BMA2X2_IMAGE_LEN                        22
+
+#define BMA2X2_CHIP_ID_REG                      0x00
+#define BMA2X2_VERSION_REG                      0x01
+#define BMA2X2_X_AXIS_LSB_REG                   0x02
+#define BMA2X2_X_AXIS_MSB_REG                   0x03
+#define BMA2X2_Y_AXIS_LSB_REG                   0x04
+#define BMA2X2_Y_AXIS_MSB_REG                   0x05
+#define BMA2X2_Z_AXIS_LSB_REG                   0x06
+#define BMA2X2_Z_AXIS_MSB_REG                   0x07
+#define BMA2X2_TEMPERATURE_REG                  0x08
+#define BMA2X2_STATUS1_REG                      0x09
+#define BMA2X2_STATUS2_REG                      0x0A
+#define BMA2X2_STATUS_TAP_SLOPE_REG             0x0B
+#define BMA2X2_STATUS_ORIENT_HIGH_REG           0x0C
+#define BMA2X2_STATUS_FIFO_REG                  0x0E
+#define BMA2X2_RANGE_SEL_REG                    0x0F
+#define BMA2X2_BW_SEL_REG                       0x10
+#define BMA2X2_MODE_CTRL_REG                    0x11
+#define BMA2X2_LOW_NOISE_CTRL_REG               0x12
+#define BMA2X2_DATA_CTRL_REG                    0x13
+#define BMA2X2_RESET_REG                        0x14
+#define BMA2X2_INT_ENABLE1_REG                  0x16
+#define BMA2X2_INT_ENABLE2_REG                  0x17
+#define BMA2X2_INT_SLO_NO_MOT_REG               0x18
+#define BMA2X2_INT1_PAD_SEL_REG                 0x19
+#define BMA2X2_INT_DATA_SEL_REG                 0x1A
+#define BMA2X2_INT2_PAD_SEL_REG                 0x1B
+#define BMA2X2_INT_SRC_REG                      0x1E
+#define BMA2X2_INT_SET_REG                      0x20
+#define BMA2X2_INT_CTRL_REG                     0x21
+#define BMA2X2_LOW_DURN_REG                     0x22
+#define BMA2X2_LOW_THRES_REG                    0x23
+#define BMA2X2_LOW_HIGH_HYST_REG                0x24
+#define BMA2X2_HIGH_DURN_REG                    0x25
+#define BMA2X2_HIGH_THRES_REG                   0x26
+#define BMA2X2_SLOPE_DURN_REG                   0x27
+#define BMA2X2_SLOPE_THRES_REG                  0x28
+#define BMA2X2_SLO_NO_MOT_THRES_REG             0x29
+#define BMA2X2_TAP_PARAM_REG                    0x2A
+#define BMA2X2_TAP_THRES_REG                    0x2B
+#define BMA2X2_ORIENT_PARAM_REG                 0x2C
+#define BMA2X2_THETA_BLOCK_REG                  0x2D
+#define BMA2X2_THETA_FLAT_REG                   0x2E
+#define BMA2X2_FLAT_HOLD_TIME_REG               0x2F
+#define BMA2X2_FIFO_WML_TRIG                    0x30
+#define BMA2X2_SELF_TEST_REG                    0x32
+#define BMA2X2_EEPROM_CTRL_REG                  0x33
+#define BMA2X2_SERIAL_CTRL_REG                  0x34
+#define BMA2X2_EXTMODE_CTRL_REG                 0x35
+#define BMA2X2_OFFSET_CTRL_REG                  0x36
+#define BMA2X2_OFFSET_PARAMS_REG                0x37
+#define BMA2X2_OFFSET_X_AXIS_REG                0x38
+#define BMA2X2_OFFSET_Y_AXIS_REG                0x39
+#define BMA2X2_OFFSET_Z_AXIS_REG                0x3A
+#define BMA2X2_GP0_REG                          0x3B
+#define BMA2X2_GP1_REG                          0x3C
+#define BMA2X2_FIFO_MODE_REG                    0x3E
+#define BMA2X2_FIFO_DATA_OUTPUT_REG             0x3F
+
+#define BMA2X2_CHIP_ID__POS             0
+#define BMA2X2_CHIP_ID__MSK             0xFF
+#define BMA2X2_CHIP_ID__LEN             8
+#define BMA2X2_CHIP_ID__REG             BMA2X2_CHIP_ID_REG
+
+#define BMA2X2_VERSION__POS          0
+#define BMA2X2_VERSION__LEN          8
+#define BMA2X2_VERSION__MSK          0xFF
+#define BMA2X2_VERSION__REG          BMA2X2_VERSION_REG
+
+#define BMA2x2_SLO_NO_MOT_DUR__POS   2
+#define BMA2x2_SLO_NO_MOT_DUR__LEN   6
+#define BMA2x2_SLO_NO_MOT_DUR__MSK   0xFC
+#define BMA2x2_SLO_NO_MOT_DUR__REG   BMA2X2_SLOPE_DURN_REG
+
+#define BMA2X2_NEW_DATA_X__POS          0
+#define BMA2X2_NEW_DATA_X__LEN          1
+#define BMA2X2_NEW_DATA_X__MSK          0x01
+#define BMA2X2_NEW_DATA_X__REG          BMA2X2_X_AXIS_LSB_REG
+
+#define BMA2X2_ACC_X14_LSB__POS           2
+#define BMA2X2_ACC_X14_LSB__LEN           6
+#define BMA2X2_ACC_X14_LSB__MSK           0xFC
+#define BMA2X2_ACC_X14_LSB__REG           BMA2X2_X_AXIS_LSB_REG
+
+#define BMA2X2_ACC_X12_LSB__POS           4
+#define BMA2X2_ACC_X12_LSB__LEN           4
+#define BMA2X2_ACC_X12_LSB__MSK           0xF0
+#define BMA2X2_ACC_X12_LSB__REG           BMA2X2_X_AXIS_LSB_REG
+
+#define BMA2X2_ACC_X10_LSB__POS           6
+#define BMA2X2_ACC_X10_LSB__LEN           2
+#define BMA2X2_ACC_X10_LSB__MSK           0xC0
+#define BMA2X2_ACC_X10_LSB__REG           BMA2X2_X_AXIS_LSB_REG
+
+#define BMA2X2_ACC_X8_LSB__POS           0
+#define BMA2X2_ACC_X8_LSB__LEN           0
+#define BMA2X2_ACC_X8_LSB__MSK           0x00
+#define BMA2X2_ACC_X8_LSB__REG           BMA2X2_X_AXIS_LSB_REG
+
+#define BMA2X2_ACC_X_MSB__POS           0
+#define BMA2X2_ACC_X_MSB__LEN           8
+#define BMA2X2_ACC_X_MSB__MSK           0xFF
+#define BMA2X2_ACC_X_MSB__REG           BMA2X2_X_AXIS_MSB_REG
+
+#define BMA2X2_NEW_DATA_Y__POS          0
+#define BMA2X2_NEW_DATA_Y__LEN          1
+#define BMA2X2_NEW_DATA_Y__MSK          0x01
+#define BMA2X2_NEW_DATA_Y__REG          BMA2X2_Y_AXIS_LSB_REG
+
+#define BMA2X2_ACC_Y14_LSB__POS           2
+#define BMA2X2_ACC_Y14_LSB__LEN           6
+#define BMA2X2_ACC_Y14_LSB__MSK           0xFC
+#define BMA2X2_ACC_Y14_LSB__REG           BMA2X2_Y_AXIS_LSB_REG
+
+#define BMA2X2_ACC_Y12_LSB__POS           4
+#define BMA2X2_ACC_Y12_LSB__LEN           4
+#define BMA2X2_ACC_Y12_LSB__MSK           0xF0
+#define BMA2X2_ACC_Y12_LSB__REG           BMA2X2_Y_AXIS_LSB_REG
+
+#define BMA2X2_ACC_Y10_LSB__POS           6
+#define BMA2X2_ACC_Y10_LSB__LEN           2
+#define BMA2X2_ACC_Y10_LSB__MSK           0xC0
+#define BMA2X2_ACC_Y10_LSB__REG           BMA2X2_Y_AXIS_LSB_REG
+
+#define BMA2X2_ACC_Y8_LSB__POS           0
+#define BMA2X2_ACC_Y8_LSB__LEN           0
+#define BMA2X2_ACC_Y8_LSB__MSK           0x00
+#define BMA2X2_ACC_Y8_LSB__REG           BMA2X2_Y_AXIS_LSB_REG
+
+#define BMA2X2_ACC_Y_MSB__POS           0
+#define BMA2X2_ACC_Y_MSB__LEN           8
+#define BMA2X2_ACC_Y_MSB__MSK           0xFF
+#define BMA2X2_ACC_Y_MSB__REG           BMA2X2_Y_AXIS_MSB_REG
+
+#define BMA2X2_NEW_DATA_Z__POS          0
+#define BMA2X2_NEW_DATA_Z__LEN          1
+#define BMA2X2_NEW_DATA_Z__MSK          0x01
+#define BMA2X2_NEW_DATA_Z__REG          BMA2X2_Z_AXIS_LSB_REG
+
+#define BMA2X2_ACC_Z14_LSB__POS           2
+#define BMA2X2_ACC_Z14_LSB__LEN           6
+#define BMA2X2_ACC_Z14_LSB__MSK           0xFC
+#define BMA2X2_ACC_Z14_LSB__REG           BMA2X2_Z_AXIS_LSB_REG
+
+#define BMA2X2_ACC_Z12_LSB__POS           4
+#define BMA2X2_ACC_Z12_LSB__LEN           4
+#define BMA2X2_ACC_Z12_LSB__MSK           0xF0
+#define BMA2X2_ACC_Z12_LSB__REG           BMA2X2_Z_AXIS_LSB_REG
+
+#define BMA2X2_ACC_Z10_LSB__POS           6
+#define BMA2X2_ACC_Z10_LSB__LEN           2
+#define BMA2X2_ACC_Z10_LSB__MSK           0xC0
+#define BMA2X2_ACC_Z10_LSB__REG           BMA2X2_Z_AXIS_LSB_REG
+
+#define BMA2X2_ACC_Z8_LSB__POS           0
+#define BMA2X2_ACC_Z8_LSB__LEN           0
+#define BMA2X2_ACC_Z8_LSB__MSK           0x00
+#define BMA2X2_ACC_Z8_LSB__REG           BMA2X2_Z_AXIS_LSB_REG
+
+#define BMA2X2_ACC_Z_MSB__POS           0
+#define BMA2X2_ACC_Z_MSB__LEN           8
+#define BMA2X2_ACC_Z_MSB__MSK           0xFF
+#define BMA2X2_ACC_Z_MSB__REG           BMA2X2_Z_AXIS_MSB_REG
+
+#define BMA2X2_TEMPERATURE__POS         0
+#define BMA2X2_TEMPERATURE__LEN         8
+#define BMA2X2_TEMPERATURE__MSK         0xFF
+#define BMA2X2_TEMPERATURE__REG         BMA2X2_TEMP_RD_REG
+
+#define BMA2X2_LOWG_INT_S__POS          0
+#define BMA2X2_LOWG_INT_S__LEN          1
+#define BMA2X2_LOWG_INT_S__MSK          0x01
+#define BMA2X2_LOWG_INT_S__REG          BMA2X2_STATUS1_REG
+
+#define BMA2X2_HIGHG_INT_S__POS          1
+#define BMA2X2_HIGHG_INT_S__LEN          1
+#define BMA2X2_HIGHG_INT_S__MSK          0x02
+#define BMA2X2_HIGHG_INT_S__REG          BMA2X2_STATUS1_REG
+
+#define BMA2X2_SLOPE_INT_S__POS          2
+#define BMA2X2_SLOPE_INT_S__LEN          1
+#define BMA2X2_SLOPE_INT_S__MSK          0x04
+#define BMA2X2_SLOPE_INT_S__REG          BMA2X2_STATUS1_REG
+
+
+#define BMA2X2_SLO_NO_MOT_INT_S__POS          3
+#define BMA2X2_SLO_NO_MOT_INT_S__LEN          1
+#define BMA2X2_SLO_NO_MOT_INT_S__MSK          0x08
+#define BMA2X2_SLO_NO_MOT_INT_S__REG          BMA2X2_STATUS1_REG
+
+#define BMA2X2_DOUBLE_TAP_INT_S__POS     4
+#define BMA2X2_DOUBLE_TAP_INT_S__LEN     1
+#define BMA2X2_DOUBLE_TAP_INT_S__MSK     0x10
+#define BMA2X2_DOUBLE_TAP_INT_S__REG     BMA2X2_STATUS1_REG
+
+#define BMA2X2_SINGLE_TAP_INT_S__POS     5
+#define BMA2X2_SINGLE_TAP_INT_S__LEN     1
+#define BMA2X2_SINGLE_TAP_INT_S__MSK     0x20
+#define BMA2X2_SINGLE_TAP_INT_S__REG     BMA2X2_STATUS1_REG
+
+#define BMA2X2_ORIENT_INT_S__POS         6
+#define BMA2X2_ORIENT_INT_S__LEN         1
+#define BMA2X2_ORIENT_INT_S__MSK         0x40
+#define BMA2X2_ORIENT_INT_S__REG         BMA2X2_STATUS1_REG
+
+#define BMA2X2_FLAT_INT_S__POS           7
+#define BMA2X2_FLAT_INT_S__LEN           1
+#define BMA2X2_FLAT_INT_S__MSK           0x80
+#define BMA2X2_FLAT_INT_S__REG           BMA2X2_STATUS1_REG
+
+#define BMA2X2_FIFO_FULL_INT_S__POS           5
+#define BMA2X2_FIFO_FULL_INT_S__LEN           1
+#define BMA2X2_FIFO_FULL_INT_S__MSK           0x20
+#define BMA2X2_FIFO_FULL_INT_S__REG           BMA2X2_STATUS2_REG
+
+#define BMA2X2_FIFO_WM_INT_S__POS           6
+#define BMA2X2_FIFO_WM_INT_S__LEN           1
+#define BMA2X2_FIFO_WM_INT_S__MSK           0x40
+#define BMA2X2_FIFO_WM_INT_S__REG           BMA2X2_STATUS2_REG
+
+#define BMA2X2_DATA_INT_S__POS           7
+#define BMA2X2_DATA_INT_S__LEN           1
+#define BMA2X2_DATA_INT_S__MSK           0x80
+#define BMA2X2_DATA_INT_S__REG           BMA2X2_STATUS2_REG
+
+#define BMA2X2_SLOPE_FIRST_X__POS        0
+#define BMA2X2_SLOPE_FIRST_X__LEN        1
+#define BMA2X2_SLOPE_FIRST_X__MSK        0x01
+#define BMA2X2_SLOPE_FIRST_X__REG        BMA2X2_STATUS_TAP_SLOPE_REG
+
+#define BMA2X2_SLOPE_FIRST_Y__POS        1
+#define BMA2X2_SLOPE_FIRST_Y__LEN        1
+#define BMA2X2_SLOPE_FIRST_Y__MSK        0x02
+#define BMA2X2_SLOPE_FIRST_Y__REG        BMA2X2_STATUS_TAP_SLOPE_REG
+
+#define BMA2X2_SLOPE_FIRST_Z__POS        2
+#define BMA2X2_SLOPE_FIRST_Z__LEN        1
+#define BMA2X2_SLOPE_FIRST_Z__MSK        0x04
+#define BMA2X2_SLOPE_FIRST_Z__REG        BMA2X2_STATUS_TAP_SLOPE_REG
+
+#define BMA2X2_SLOPE_SIGN_S__POS         3
+#define BMA2X2_SLOPE_SIGN_S__LEN         1
+#define BMA2X2_SLOPE_SIGN_S__MSK         0x08
+#define BMA2X2_SLOPE_SIGN_S__REG         BMA2X2_STATUS_TAP_SLOPE_REG
+
+#define BMA2X2_TAP_FIRST_X__POS        4
+#define BMA2X2_TAP_FIRST_X__LEN        1
+#define BMA2X2_TAP_FIRST_X__MSK        0x10
+#define BMA2X2_TAP_FIRST_X__REG        BMA2X2_STATUS_TAP_SLOPE_REG
+
+#define BMA2X2_TAP_FIRST_Y__POS        5
+#define BMA2X2_TAP_FIRST_Y__LEN        1
+#define BMA2X2_TAP_FIRST_Y__MSK        0x20
+#define BMA2X2_TAP_FIRST_Y__REG        BMA2X2_STATUS_TAP_SLOPE_REG
+
+#define BMA2X2_TAP_FIRST_Z__POS        6
+#define BMA2X2_TAP_FIRST_Z__LEN        1
+#define BMA2X2_TAP_FIRST_Z__MSK        0x40
+#define BMA2X2_TAP_FIRST_Z__REG        BMA2X2_STATUS_TAP_SLOPE_REG
+
+#define BMA2X2_TAP_SIGN_S__POS         7
+#define BMA2X2_TAP_SIGN_S__LEN         1
+#define BMA2X2_TAP_SIGN_S__MSK         0x80
+#define BMA2X2_TAP_SIGN_S__REG         BMA2X2_STATUS_TAP_SLOPE_REG
+
+#define BMA2X2_HIGHG_FIRST_X__POS        0
+#define BMA2X2_HIGHG_FIRST_X__LEN        1
+#define BMA2X2_HIGHG_FIRST_X__MSK        0x01
+#define BMA2X2_HIGHG_FIRST_X__REG        BMA2X2_STATUS_ORIENT_HIGH_REG
+
+#define BMA2X2_HIGHG_FIRST_Y__POS        1
+#define BMA2X2_HIGHG_FIRST_Y__LEN        1
+#define BMA2X2_HIGHG_FIRST_Y__MSK        0x02
+#define BMA2X2_HIGHG_FIRST_Y__REG        BMA2X2_STATUS_ORIENT_HIGH_REG
+
+#define BMA2X2_HIGHG_FIRST_Z__POS        2
+#define BMA2X2_HIGHG_FIRST_Z__LEN        1
+#define BMA2X2_HIGHG_FIRST_Z__MSK        0x04
+#define BMA2X2_HIGHG_FIRST_Z__REG        BMA2X2_STATUS_ORIENT_HIGH_REG
+
+#define BMA2X2_HIGHG_SIGN_S__POS         3
+#define BMA2X2_HIGHG_SIGN_S__LEN         1
+#define BMA2X2_HIGHG_SIGN_S__MSK         0x08
+#define BMA2X2_HIGHG_SIGN_S__REG         BMA2X2_STATUS_ORIENT_HIGH_REG
+
+#define BMA2X2_ORIENT_S__POS             4
+#define BMA2X2_ORIENT_S__LEN             3
+#define BMA2X2_ORIENT_S__MSK             0x70
+#define BMA2X2_ORIENT_S__REG             BMA2X2_STATUS_ORIENT_HIGH_REG
+
+#define BMA2X2_FLAT_S__POS               7
+#define BMA2X2_FLAT_S__LEN               1
+#define BMA2X2_FLAT_S__MSK               0x80
+#define BMA2X2_FLAT_S__REG               BMA2X2_STATUS_ORIENT_HIGH_REG
+
+#define BMA2X2_FIFO_FRAME_COUNTER_S__POS             0
+#define BMA2X2_FIFO_FRAME_COUNTER_S__LEN             7
+#define BMA2X2_FIFO_FRAME_COUNTER_S__MSK             0x7F
+#define BMA2X2_FIFO_FRAME_COUNTER_S__REG             BMA2X2_STATUS_FIFO_REG
+#define BMA2X2_FIFO_OVERRUN_S__POS             7
+#define BMA2X2_FIFO_OVERRUN_S__LEN             1
+#define BMA2X2_FIFO_OVERRUN_S__MSK             0x80
+#define BMA2X2_FIFO_OVERRUN_S__REG             BMA2X2_STATUS_FIFO_REG
+
+#define BMA2X2_RANGE_SEL__POS             0
+#define BMA2X2_RANGE_SEL__LEN             4
+#define BMA2X2_RANGE_SEL__MSK             0x0F
+#define BMA2X2_RANGE_SEL__REG             BMA2X2_RANGE_SEL_REG
+
+#define BMA2X2_BANDWIDTH__POS             0
+#define BMA2X2_BANDWIDTH__LEN             5
+#define BMA2X2_BANDWIDTH__MSK             0x1F
+#define BMA2X2_BANDWIDTH__REG             BMA2X2_BW_SEL_REG
+
+#define BMA2X2_SLEEP_DUR__POS             1
+#define BMA2X2_SLEEP_DUR__LEN             4
+#define BMA2X2_SLEEP_DUR__MSK             0x1E
+#define BMA2X2_SLEEP_DUR__REG             BMA2X2_MODE_CTRL_REG
+
+#define BMA2X2_MODE_CTRL__POS             5
+#define BMA2X2_MODE_CTRL__LEN             3
+#define BMA2X2_MODE_CTRL__MSK             0xE0
+#define BMA2X2_MODE_CTRL__REG             BMA2X2_MODE_CTRL_REG
+
+#define BMA2X2_DEEP_SUSPEND__POS          5
+#define BMA2X2_DEEP_SUSPEND__LEN          1
+#define BMA2X2_DEEP_SUSPEND__MSK          0x20
+#define BMA2X2_DEEP_SUSPEND__REG          BMA2X2_MODE_CTRL_REG
+
+#define BMA2X2_EN_LOW_POWER__POS          6
+#define BMA2X2_EN_LOW_POWER__LEN          1
+#define BMA2X2_EN_LOW_POWER__MSK          0x40
+#define BMA2X2_EN_LOW_POWER__REG          BMA2X2_MODE_CTRL_REG
+
+#define BMA2X2_EN_SUSPEND__POS            7
+#define BMA2X2_EN_SUSPEND__LEN            1
+#define BMA2X2_EN_SUSPEND__MSK            0x80
+#define BMA2X2_EN_SUSPEND__REG            BMA2X2_MODE_CTRL_REG
+
+#define BMA2X2_SLEEP_TIMER__POS          5
+#define BMA2X2_SLEEP_TIMER__LEN          1
+#define BMA2X2_SLEEP_TIMER__MSK          0x20
+#define BMA2X2_SLEEP_TIMER__REG          BMA2X2_LOW_NOISE_CTRL_REG
+
+#define BMA2X2_LOW_POWER_MODE__POS          6
+#define BMA2X2_LOW_POWER_MODE__LEN          1
+#define BMA2X2_LOW_POWER_MODE__MSK          0x40
+#define BMA2X2_LOW_POWER_MODE__REG          BMA2X2_LOW_NOISE_CTRL_REG
+
+#define BMA2X2_EN_LOW_NOISE__POS          7
+#define BMA2X2_EN_LOW_NOISE__LEN          1
+#define BMA2X2_EN_LOW_NOISE__MSK          0x80
+#define BMA2X2_EN_LOW_NOISE__REG          BMA2X2_LOW_NOISE_CTRL_REG
+
+#define BMA2X2_DIS_SHADOW_PROC__POS       6
+#define BMA2X2_DIS_SHADOW_PROC__LEN       1
+#define BMA2X2_DIS_SHADOW_PROC__MSK       0x40
+#define BMA2X2_DIS_SHADOW_PROC__REG       BMA2X2_DATA_CTRL_REG
+
+#define BMA2X2_EN_DATA_HIGH_BW__POS         7
+#define BMA2X2_EN_DATA_HIGH_BW__LEN         1
+#define BMA2X2_EN_DATA_HIGH_BW__MSK         0x80
+#define BMA2X2_EN_DATA_HIGH_BW__REG         BMA2X2_DATA_CTRL_REG
+
+#define BMA2X2_EN_SOFT_RESET__POS         0
+#define BMA2X2_EN_SOFT_RESET__LEN         8
+#define BMA2X2_EN_SOFT_RESET__MSK         0xFF
+#define BMA2X2_EN_SOFT_RESET__REG         BMA2X2_RESET_REG
+
+#define BMA2X2_EN_SOFT_RESET_VALUE        0xB6
+
+#define BMA2X2_EN_SLOPE_X_INT__POS         0
+#define BMA2X2_EN_SLOPE_X_INT__LEN         1
+#define BMA2X2_EN_SLOPE_X_INT__MSK         0x01
+#define BMA2X2_EN_SLOPE_X_INT__REG         BMA2X2_INT_ENABLE1_REG
+
+#define BMA2X2_EN_SLOPE_Y_INT__POS         1
+#define BMA2X2_EN_SLOPE_Y_INT__LEN         1
+#define BMA2X2_EN_SLOPE_Y_INT__MSK         0x02
+#define BMA2X2_EN_SLOPE_Y_INT__REG         BMA2X2_INT_ENABLE1_REG
+
+#define BMA2X2_EN_SLOPE_Z_INT__POS         2
+#define BMA2X2_EN_SLOPE_Z_INT__LEN         1
+#define BMA2X2_EN_SLOPE_Z_INT__MSK         0x04
+#define BMA2X2_EN_SLOPE_Z_INT__REG         BMA2X2_INT_ENABLE1_REG
+
+#define BMA2X2_EN_DOUBLE_TAP_INT__POS      4
+#define BMA2X2_EN_DOUBLE_TAP_INT__LEN      1
+#define BMA2X2_EN_DOUBLE_TAP_INT__MSK      0x10
+#define BMA2X2_EN_DOUBLE_TAP_INT__REG      BMA2X2_INT_ENABLE1_REG
+
+#define BMA2X2_EN_SINGLE_TAP_INT__POS      5
+#define BMA2X2_EN_SINGLE_TAP_INT__LEN      1
+#define BMA2X2_EN_SINGLE_TAP_INT__MSK      0x20
+#define BMA2X2_EN_SINGLE_TAP_INT__REG      BMA2X2_INT_ENABLE1_REG
+
+#define BMA2X2_EN_ORIENT_INT__POS          6
+#define BMA2X2_EN_ORIENT_INT__LEN          1
+#define BMA2X2_EN_ORIENT_INT__MSK          0x40
+#define BMA2X2_EN_ORIENT_INT__REG          BMA2X2_INT_ENABLE1_REG
+
+#define BMA2X2_EN_FLAT_INT__POS            7
+#define BMA2X2_EN_FLAT_INT__LEN            1
+#define BMA2X2_EN_FLAT_INT__MSK            0x80
+#define BMA2X2_EN_FLAT_INT__REG            BMA2X2_INT_ENABLE1_REG
+
+#define BMA2X2_EN_HIGHG_X_INT__POS         0
+#define BMA2X2_EN_HIGHG_X_INT__LEN         1
+#define BMA2X2_EN_HIGHG_X_INT__MSK         0x01
+#define BMA2X2_EN_HIGHG_X_INT__REG         BMA2X2_INT_ENABLE2_REG
+
+#define BMA2X2_EN_HIGHG_Y_INT__POS         1
+#define BMA2X2_EN_HIGHG_Y_INT__LEN         1
+#define BMA2X2_EN_HIGHG_Y_INT__MSK         0x02
+#define BMA2X2_EN_HIGHG_Y_INT__REG         BMA2X2_INT_ENABLE2_REG
+
+#define BMA2X2_EN_HIGHG_Z_INT__POS         2
+#define BMA2X2_EN_HIGHG_Z_INT__LEN         1
+#define BMA2X2_EN_HIGHG_Z_INT__MSK         0x04
+#define BMA2X2_EN_HIGHG_Z_INT__REG         BMA2X2_INT_ENABLE2_REG
+
+#define BMA2X2_EN_LOWG_INT__POS            3
+#define BMA2X2_EN_LOWG_INT__LEN            1
+#define BMA2X2_EN_LOWG_INT__MSK            0x08
+#define BMA2X2_EN_LOWG_INT__REG            BMA2X2_INT_ENABLE2_REG
+
+#define BMA2X2_EN_NEW_DATA_INT__POS        4
+#define BMA2X2_EN_NEW_DATA_INT__LEN        1
+#define BMA2X2_EN_NEW_DATA_INT__MSK        0x10
+#define BMA2X2_EN_NEW_DATA_INT__REG        BMA2X2_INT_ENABLE2_REG
+
+#define BMA2X2_INT_FFULL_EN_INT__POS        5
+#define BMA2X2_INT_FFULL_EN_INT__LEN        1
+#define BMA2X2_INT_FFULL_EN_INT__MSK        0x20
+#define BMA2X2_INT_FFULL_EN_INT__REG        BMA2X2_INT_ENABLE2_REG
+
+#define BMA2X2_INT_FWM_EN_INT__POS        6
+#define BMA2X2_INT_FWM_EN_INT__LEN        1
+#define BMA2X2_INT_FWM_EN_INT__MSK        0x40
+#define BMA2X2_INT_FWM_EN_INT__REG        BMA2X2_INT_ENABLE2_REG
+
+#define BMA2X2_INT_SLO_NO_MOT_EN_X_INT__POS        0
+#define BMA2X2_INT_SLO_NO_MOT_EN_X_INT__LEN        1
+#define BMA2X2_INT_SLO_NO_MOT_EN_X_INT__MSK        0x01
+#define BMA2X2_INT_SLO_NO_MOT_EN_X_INT__REG        BMA2X2_INT_SLO_NO_MOT_REG
+
+#define BMA2X2_INT_SLO_NO_MOT_EN_Y_INT__POS        1
+#define BMA2X2_INT_SLO_NO_MOT_EN_Y_INT__LEN        1
+#define BMA2X2_INT_SLO_NO_MOT_EN_Y_INT__MSK        0x02
+#define BMA2X2_INT_SLO_NO_MOT_EN_Y_INT__REG        BMA2X2_INT_SLO_NO_MOT_REG
+
+#define BMA2X2_INT_SLO_NO_MOT_EN_Z_INT__POS        2
+#define BMA2X2_INT_SLO_NO_MOT_EN_Z_INT__LEN        1
+#define BMA2X2_INT_SLO_NO_MOT_EN_Z_INT__MSK        0x04
+#define BMA2X2_INT_SLO_NO_MOT_EN_Z_INT__REG        BMA2X2_INT_SLO_NO_MOT_REG
+
+#define BMA2X2_INT_SLO_NO_MOT_EN_SEL_INT__POS        3
+#define BMA2X2_INT_SLO_NO_MOT_EN_SEL_INT__LEN        1
+#define BMA2X2_INT_SLO_NO_MOT_EN_SEL_INT__MSK        0x08
+#define BMA2X2_INT_SLO_NO_MOT_EN_SEL_INT__REG        BMA2X2_INT_SLO_NO_MOT_REG
+
+#define BMA2X2_EN_INT1_PAD_LOWG__POS        0
+#define BMA2X2_EN_INT1_PAD_LOWG__LEN        1
+#define BMA2X2_EN_INT1_PAD_LOWG__MSK        0x01
+#define BMA2X2_EN_INT1_PAD_LOWG__REG        BMA2X2_INT1_PAD_SEL_REG
+
+#define BMA2X2_EN_INT1_PAD_HIGHG__POS       1
+#define BMA2X2_EN_INT1_PAD_HIGHG__LEN       1
+#define BMA2X2_EN_INT1_PAD_HIGHG__MSK       0x02
+#define BMA2X2_EN_INT1_PAD_HIGHG__REG       BMA2X2_INT1_PAD_SEL_REG
+
+#define BMA2X2_EN_INT1_PAD_SLOPE__POS       2
+#define BMA2X2_EN_INT1_PAD_SLOPE__LEN       1
+#define BMA2X2_EN_INT1_PAD_SLOPE__MSK       0x04
+#define BMA2X2_EN_INT1_PAD_SLOPE__REG       BMA2X2_INT1_PAD_SEL_REG
+
+#define BMA2X2_EN_INT1_PAD_SLO_NO_MOT__POS        3
+#define BMA2X2_EN_INT1_PAD_SLO_NO_MOT__LEN        1
+#define BMA2X2_EN_INT1_PAD_SLO_NO_MOT__MSK        0x08
+#define BMA2X2_EN_INT1_PAD_SLO_NO_MOT__REG        BMA2X2_INT1_PAD_SEL_REG
+
+#define BMA2X2_EN_INT1_PAD_DB_TAP__POS      4
+#define BMA2X2_EN_INT1_PAD_DB_TAP__LEN      1
+#define BMA2X2_EN_INT1_PAD_DB_TAP__MSK      0x10
+#define BMA2X2_EN_INT1_PAD_DB_TAP__REG      BMA2X2_INT1_PAD_SEL_REG
+
+#define BMA2X2_EN_INT1_PAD_SNG_TAP__POS     5
+#define BMA2X2_EN_INT1_PAD_SNG_TAP__LEN     1
+#define BMA2X2_EN_INT1_PAD_SNG_TAP__MSK     0x20
+#define BMA2X2_EN_INT1_PAD_SNG_TAP__REG     BMA2X2_INT1_PAD_SEL_REG
+
+#define BMA2X2_EN_INT1_PAD_ORIENT__POS      6
+#define BMA2X2_EN_INT1_PAD_ORIENT__LEN      1
+#define BMA2X2_EN_INT1_PAD_ORIENT__MSK      0x40
+#define BMA2X2_EN_INT1_PAD_ORIENT__REG      BMA2X2_INT1_PAD_SEL_REG
+
+#define BMA2X2_EN_INT1_PAD_FLAT__POS        7
+#define BMA2X2_EN_INT1_PAD_FLAT__LEN        1
+#define BMA2X2_EN_INT1_PAD_FLAT__MSK        0x80
+#define BMA2X2_EN_INT1_PAD_FLAT__REG        BMA2X2_INT1_PAD_SEL_REG
+
+#define BMA2X2_EN_INT2_PAD_LOWG__POS        0
+#define BMA2X2_EN_INT2_PAD_LOWG__LEN        1
+#define BMA2X2_EN_INT2_PAD_LOWG__MSK        0x01
+#define BMA2X2_EN_INT2_PAD_LOWG__REG        BMA2X2_INT2_PAD_SEL_REG
+
+#define BMA2X2_EN_INT2_PAD_HIGHG__POS       1
+#define BMA2X2_EN_INT2_PAD_HIGHG__LEN       1
+#define BMA2X2_EN_INT2_PAD_HIGHG__MSK       0x02
+#define BMA2X2_EN_INT2_PAD_HIGHG__REG       BMA2X2_INT2_PAD_SEL_REG
+
+#define BMA2X2_EN_INT2_PAD_SLOPE__POS       2
+#define BMA2X2_EN_INT2_PAD_SLOPE__LEN       1
+#define BMA2X2_EN_INT2_PAD_SLOPE__MSK       0x04
+#define BMA2X2_EN_INT2_PAD_SLOPE__REG       BMA2X2_INT2_PAD_SEL_REG
+
+#define BMA2X2_EN_INT2_PAD_SLO_NO_MOT__POS        3
+#define BMA2X2_EN_INT2_PAD_SLO_NO_MOT__LEN        1
+#define BMA2X2_EN_INT2_PAD_SLO_NO_MOT__MSK        0x08
+#define BMA2X2_EN_INT2_PAD_SLO_NO_MOT__REG        BMA2X2_INT2_PAD_SEL_REG
+
+#define BMA2X2_EN_INT2_PAD_DB_TAP__POS      4
+#define BMA2X2_EN_INT2_PAD_DB_TAP__LEN      1
+#define BMA2X2_EN_INT2_PAD_DB_TAP__MSK      0x10
+#define BMA2X2_EN_INT2_PAD_DB_TAP__REG      BMA2X2_INT2_PAD_SEL_REG
+
+#define BMA2X2_EN_INT2_PAD_SNG_TAP__POS     5
+#define BMA2X2_EN_INT2_PAD_SNG_TAP__LEN     1
+#define BMA2X2_EN_INT2_PAD_SNG_TAP__MSK     0x20
+#define BMA2X2_EN_INT2_PAD_SNG_TAP__REG     BMA2X2_INT2_PAD_SEL_REG
+
+#define BMA2X2_EN_INT2_PAD_ORIENT__POS      6
+#define BMA2X2_EN_INT2_PAD_ORIENT__LEN      1
+#define BMA2X2_EN_INT2_PAD_ORIENT__MSK      0x40
+#define BMA2X2_EN_INT2_PAD_ORIENT__REG      BMA2X2_INT2_PAD_SEL_REG
+
+#define BMA2X2_EN_INT2_PAD_FLAT__POS        7
+#define BMA2X2_EN_INT2_PAD_FLAT__LEN        1
+#define BMA2X2_EN_INT2_PAD_FLAT__MSK        0x80
+#define BMA2X2_EN_INT2_PAD_FLAT__REG        BMA2X2_INT2_PAD_SEL_REG
+
+#define BMA2X2_EN_INT1_PAD_NEWDATA__POS     0
+#define BMA2X2_EN_INT1_PAD_NEWDATA__LEN     1
+#define BMA2X2_EN_INT1_PAD_NEWDATA__MSK     0x01
+#define BMA2X2_EN_INT1_PAD_NEWDATA__REG     BMA2X2_INT_DATA_SEL_REG
+
+#define BMA2X2_EN_INT1_PAD_FWM__POS     1
+#define BMA2X2_EN_INT1_PAD_FWM__LEN     1
+#define BMA2X2_EN_INT1_PAD_FWM__MSK     0x02
+#define BMA2X2_EN_INT1_PAD_FWM__REG     BMA2X2_INT_DATA_SEL_REG
+
+#define BMA2X2_EN_INT1_PAD_FFULL__POS     2
+#define BMA2X2_EN_INT1_PAD_FFULL__LEN     1
+#define BMA2X2_EN_INT1_PAD_FFULL__MSK     0x04
+#define BMA2X2_EN_INT1_PAD_FFULL__REG     BMA2X2_INT_DATA_SEL_REG
+
+#define BMA2X2_EN_INT2_PAD_FFULL__POS     5
+#define BMA2X2_EN_INT2_PAD_FFULL__LEN     1
+#define BMA2X2_EN_INT2_PAD_FFULL__MSK     0x20
+#define BMA2X2_EN_INT2_PAD_FFULL__REG     BMA2X2_INT_DATA_SEL_REG
+
+#define BMA2X2_EN_INT2_PAD_FWM__POS     6
+#define BMA2X2_EN_INT2_PAD_FWM__LEN     1
+#define BMA2X2_EN_INT2_PAD_FWM__MSK     0x40
+#define BMA2X2_EN_INT2_PAD_FWM__REG     BMA2X2_INT_DATA_SEL_REG
+
+#define BMA2X2_EN_INT2_PAD_NEWDATA__POS     7
+#define BMA2X2_EN_INT2_PAD_NEWDATA__LEN     1
+#define BMA2X2_EN_INT2_PAD_NEWDATA__MSK     0x80
+#define BMA2X2_EN_INT2_PAD_NEWDATA__REG     BMA2X2_INT_DATA_SEL_REG
+
+#define BMA2X2_UNFILT_INT_SRC_LOWG__POS        0
+#define BMA2X2_UNFILT_INT_SRC_LOWG__LEN        1
+#define BMA2X2_UNFILT_INT_SRC_LOWG__MSK        0x01
+#define BMA2X2_UNFILT_INT_SRC_LOWG__REG        BMA2X2_INT_SRC_REG
+
+#define BMA2X2_UNFILT_INT_SRC_HIGHG__POS       1
+#define BMA2X2_UNFILT_INT_SRC_HIGHG__LEN       1
+#define BMA2X2_UNFILT_INT_SRC_HIGHG__MSK       0x02
+#define BMA2X2_UNFILT_INT_SRC_HIGHG__REG       BMA2X2_INT_SRC_REG
+
+#define BMA2X2_UNFILT_INT_SRC_SLOPE__POS       2
+#define BMA2X2_UNFILT_INT_SRC_SLOPE__LEN       1
+#define BMA2X2_UNFILT_INT_SRC_SLOPE__MSK       0x04
+#define BMA2X2_UNFILT_INT_SRC_SLOPE__REG       BMA2X2_INT_SRC_REG
+
+#define BMA2X2_UNFILT_INT_SRC_SLO_NO_MOT__POS        3
+#define BMA2X2_UNFILT_INT_SRC_SLO_NO_MOT__LEN        1
+#define BMA2X2_UNFILT_INT_SRC_SLO_NO_MOT__MSK        0x08
+#define BMA2X2_UNFILT_INT_SRC_SLO_NO_MOT__REG        BMA2X2_INT_SRC_REG
+
+#define BMA2X2_UNFILT_INT_SRC_TAP__POS         4
+#define BMA2X2_UNFILT_INT_SRC_TAP__LEN         1
+#define BMA2X2_UNFILT_INT_SRC_TAP__MSK         0x10
+#define BMA2X2_UNFILT_INT_SRC_TAP__REG         BMA2X2_INT_SRC_REG
+
+#define BMA2X2_UNFILT_INT_SRC_DATA__POS        5
+#define BMA2X2_UNFILT_INT_SRC_DATA__LEN        1
+#define BMA2X2_UNFILT_INT_SRC_DATA__MSK        0x20
+#define BMA2X2_UNFILT_INT_SRC_DATA__REG        BMA2X2_INT_SRC_REG
+
+#define BMA2X2_INT1_PAD_ACTIVE_LEVEL__POS       0
+#define BMA2X2_INT1_PAD_ACTIVE_LEVEL__LEN       1
+#define BMA2X2_INT1_PAD_ACTIVE_LEVEL__MSK       0x01
+#define BMA2X2_INT1_PAD_ACTIVE_LEVEL__REG       BMA2X2_INT_SET_REG
+
+#define BMA2X2_INT2_PAD_ACTIVE_LEVEL__POS       2
+#define BMA2X2_INT2_PAD_ACTIVE_LEVEL__LEN       1
+#define BMA2X2_INT2_PAD_ACTIVE_LEVEL__MSK       0x04
+#define BMA2X2_INT2_PAD_ACTIVE_LEVEL__REG       BMA2X2_INT_SET_REG
+
+#define BMA2X2_INT1_PAD_OUTPUT_TYPE__POS        1
+#define BMA2X2_INT1_PAD_OUTPUT_TYPE__LEN        1
+#define BMA2X2_INT1_PAD_OUTPUT_TYPE__MSK        0x02
+#define BMA2X2_INT1_PAD_OUTPUT_TYPE__REG        BMA2X2_INT_SET_REG
+
+#define BMA2X2_INT2_PAD_OUTPUT_TYPE__POS        3
+#define BMA2X2_INT2_PAD_OUTPUT_TYPE__LEN        1
+#define BMA2X2_INT2_PAD_OUTPUT_TYPE__MSK        0x08
+#define BMA2X2_INT2_PAD_OUTPUT_TYPE__REG        BMA2X2_INT_SET_REG
+
+#define BMA2X2_INT_MODE_SEL__POS                0
+#define BMA2X2_INT_MODE_SEL__LEN                4
+#define BMA2X2_INT_MODE_SEL__MSK                0x0F
+#define BMA2X2_INT_MODE_SEL__REG                BMA2X2_INT_CTRL_REG
+
+#define BMA2X2_RESET_INT__POS           7
+#define BMA2X2_RESET_INT__LEN           1
+#define BMA2X2_RESET_INT__MSK           0x80
+#define BMA2X2_RESET_INT__REG           BMA2X2_INT_CTRL_REG
+
+#define BMA2X2_LOWG_DUR__POS                    0
+#define BMA2X2_LOWG_DUR__LEN                    8
+#define BMA2X2_LOWG_DUR__MSK                    0xFF
+#define BMA2X2_LOWG_DUR__REG                    BMA2X2_LOW_DURN_REG
+
+#define BMA2X2_LOWG_THRES__POS                  0
+#define BMA2X2_LOWG_THRES__LEN                  8
+#define BMA2X2_LOWG_THRES__MSK                  0xFF
+#define BMA2X2_LOWG_THRES__REG                  BMA2X2_LOW_THRES_REG
+
+#define BMA2X2_LOWG_HYST__POS                   0
+#define BMA2X2_LOWG_HYST__LEN                   2
+#define BMA2X2_LOWG_HYST__MSK                   0x03
+#define BMA2X2_LOWG_HYST__REG                   BMA2X2_LOW_HIGH_HYST_REG
+
+#define BMA2X2_LOWG_INT_MODE__POS               2
+#define BMA2X2_LOWG_INT_MODE__LEN               1
+#define BMA2X2_LOWG_INT_MODE__MSK               0x04
+#define BMA2X2_LOWG_INT_MODE__REG               BMA2X2_LOW_HIGH_HYST_REG
+
+#define BMA2X2_HIGHG_DUR__POS                    0
+#define BMA2X2_HIGHG_DUR__LEN                    8
+#define BMA2X2_HIGHG_DUR__MSK                    0xFF
+#define BMA2X2_HIGHG_DUR__REG                    BMA2X2_HIGH_DURN_REG
+
+#define BMA2X2_HIGHG_THRES__POS                  0
+#define BMA2X2_HIGHG_THRES__LEN                  8
+#define BMA2X2_HIGHG_THRES__MSK                  0xFF
+#define BMA2X2_HIGHG_THRES__REG                  BMA2X2_HIGH_THRES_REG
+
+#define BMA2X2_HIGHG_HYST__POS                  6
+#define BMA2X2_HIGHG_HYST__LEN                  2
+#define BMA2X2_HIGHG_HYST__MSK                  0xC0
+#define BMA2X2_HIGHG_HYST__REG                  BMA2X2_LOW_HIGH_HYST_REG
+
+#define BMA2X2_SLOPE_DUR__POS                    0
+#define BMA2X2_SLOPE_DUR__LEN                    2
+#define BMA2X2_SLOPE_DUR__MSK                    0x03
+#define BMA2X2_SLOPE_DUR__REG                    BMA2X2_SLOPE_DURN_REG
+
+#define BMA2X2_SLO_NO_MOT_DUR__POS                    2
+#define BMA2X2_SLO_NO_MOT_DUR__LEN                    6
+#define BMA2X2_SLO_NO_MOT_DUR__MSK                    0xFC
+#define BMA2X2_SLO_NO_MOT_DUR__REG                    BMA2X2_SLOPE_DURN_REG
+
+#define BMA2X2_SLOPE_THRES__POS                  0
+#define BMA2X2_SLOPE_THRES__LEN                  8
+#define BMA2X2_SLOPE_THRES__MSK                  0xFF
+#define BMA2X2_SLOPE_THRES__REG                  BMA2X2_SLOPE_THRES_REG
+
+#define BMA2X2_SLO_NO_MOT_THRES__POS                  0
+#define BMA2X2_SLO_NO_MOT_THRES__LEN                  8
+#define BMA2X2_SLO_NO_MOT_THRES__MSK                  0xFF
+#define BMA2X2_SLO_NO_MOT_THRES__REG           BMA2X2_SLO_NO_MOT_THRES_REG
+
+#define BMA2X2_TAP_DUR__POS                    0
+#define BMA2X2_TAP_DUR__LEN                    3
+#define BMA2X2_TAP_DUR__MSK                    0x07
+#define BMA2X2_TAP_DUR__REG                    BMA2X2_TAP_PARAM_REG
+
+#define BMA2X2_TAP_SHOCK_DURN__POS             6
+#define BMA2X2_TAP_SHOCK_DURN__LEN             1
+#define BMA2X2_TAP_SHOCK_DURN__MSK             0x40
+#define BMA2X2_TAP_SHOCK_DURN__REG             BMA2X2_TAP_PARAM_REG
+
+#define BMA2X2_ADV_TAP_INT__POS                5
+#define BMA2X2_ADV_TAP_INT__LEN                1
+#define BMA2X2_ADV_TAP_INT__MSK                0x20
+#define BMA2X2_ADV_TAP_INT__REG                BMA2X2_TAP_PARAM_REG
+
+#define BMA2X2_TAP_QUIET_DURN__POS             7
+#define BMA2X2_TAP_QUIET_DURN__LEN             1
+#define BMA2X2_TAP_QUIET_DURN__MSK             0x80
+#define BMA2X2_TAP_QUIET_DURN__REG             BMA2X2_TAP_PARAM_REG
+
+#define BMA2X2_TAP_THRES__POS                  0
+#define BMA2X2_TAP_THRES__LEN                  5
+#define BMA2X2_TAP_THRES__MSK                  0x1F
+#define BMA2X2_TAP_THRES__REG                  BMA2X2_TAP_THRES_REG
+
+#define BMA2X2_TAP_SAMPLES__POS                6
+#define BMA2X2_TAP_SAMPLES__LEN                2
+#define BMA2X2_TAP_SAMPLES__MSK                0xC0
+#define BMA2X2_TAP_SAMPLES__REG                BMA2X2_TAP_THRES_REG
+
+#define BMA2X2_ORIENT_MODE__POS                  0
+#define BMA2X2_ORIENT_MODE__LEN                  2
+#define BMA2X2_ORIENT_MODE__MSK                  0x03
+#define BMA2X2_ORIENT_MODE__REG                  BMA2X2_ORIENT_PARAM_REG
+
+#define BMA2X2_ORIENT_BLOCK__POS                 2
+#define BMA2X2_ORIENT_BLOCK__LEN                 2
+#define BMA2X2_ORIENT_BLOCK__MSK                 0x0C
+#define BMA2X2_ORIENT_BLOCK__REG                 BMA2X2_ORIENT_PARAM_REG
+
+#define BMA2X2_ORIENT_HYST__POS                  4
+#define BMA2X2_ORIENT_HYST__LEN                  3
+#define BMA2X2_ORIENT_HYST__MSK                  0x70
+#define BMA2X2_ORIENT_HYST__REG                  BMA2X2_ORIENT_PARAM_REG
+
+#define BMA2X2_ORIENT_AXIS__POS                  7
+#define BMA2X2_ORIENT_AXIS__LEN                  1
+#define BMA2X2_ORIENT_AXIS__MSK                  0x80
+#define BMA2X2_ORIENT_AXIS__REG                  BMA2X2_THETA_BLOCK_REG
+
+#define BMA2X2_ORIENT_UD_EN__POS                  6
+#define BMA2X2_ORIENT_UD_EN__LEN                  1
+#define BMA2X2_ORIENT_UD_EN__MSK                  0x40
+#define BMA2X2_ORIENT_UD_EN__REG                  BMA2X2_THETA_BLOCK_REG
+
+#define BMA2X2_THETA_BLOCK__POS                  0
+#define BMA2X2_THETA_BLOCK__LEN                  6
+#define BMA2X2_THETA_BLOCK__MSK                  0x3F
+#define BMA2X2_THETA_BLOCK__REG                  BMA2X2_THETA_BLOCK_REG
+
+#define BMA2X2_THETA_FLAT__POS                  0
+#define BMA2X2_THETA_FLAT__LEN                  6
+#define BMA2X2_THETA_FLAT__MSK                  0x3F
+#define BMA2X2_THETA_FLAT__REG                  BMA2X2_THETA_FLAT_REG
+
+#define BMA2X2_FLAT_HOLD_TIME__POS              4
+#define BMA2X2_FLAT_HOLD_TIME__LEN              2
+#define BMA2X2_FLAT_HOLD_TIME__MSK              0x30
+#define BMA2X2_FLAT_HOLD_TIME__REG              BMA2X2_FLAT_HOLD_TIME_REG
+
+#define BMA2X2_FLAT_HYS__POS                   0
+#define BMA2X2_FLAT_HYS__LEN                   3
+#define BMA2X2_FLAT_HYS__MSK                   0x07
+#define BMA2X2_FLAT_HYS__REG                   BMA2X2_FLAT_HOLD_TIME_REG
+
+#define BMA2X2_FIFO_WML_TRIG_RETAIN__POS                   0
+#define BMA2X2_FIFO_WML_TRIG_RETAIN__LEN                   6
+#define BMA2X2_FIFO_WML_TRIG_RETAIN__MSK                   0x3F
+#define BMA2X2_FIFO_WML_TRIG_RETAIN__REG                   BMA2X2_FIFO_WML_TRIG
+
+#define BMA2X2_EN_SELF_TEST__POS                0
+#define BMA2X2_EN_SELF_TEST__LEN                2
+#define BMA2X2_EN_SELF_TEST__MSK                0x03
+#define BMA2X2_EN_SELF_TEST__REG                BMA2X2_SELF_TEST_REG
+
+#define BMA2X2_NEG_SELF_TEST__POS               2
+#define BMA2X2_NEG_SELF_TEST__LEN               1
+#define BMA2X2_NEG_SELF_TEST__MSK               0x04
+#define BMA2X2_NEG_SELF_TEST__REG               BMA2X2_SELF_TEST_REG
+
+#define BMA2X2_SELF_TEST_AMP__POS               4
+#define BMA2X2_SELF_TEST_AMP__LEN               1
+#define BMA2X2_SELF_TEST_AMP__MSK               0x10
+#define BMA2X2_SELF_TEST_AMP__REG               BMA2X2_SELF_TEST_REG
+
+
+#define BMA2X2_UNLOCK_EE_PROG_MODE__POS     0
+#define BMA2X2_UNLOCK_EE_PROG_MODE__LEN     1
+#define BMA2X2_UNLOCK_EE_PROG_MODE__MSK     0x01
+#define BMA2X2_UNLOCK_EE_PROG_MODE__REG     BMA2X2_EEPROM_CTRL_REG
+
+#define BMA2X2_START_EE_PROG_TRIG__POS      1
+#define BMA2X2_START_EE_PROG_TRIG__LEN      1
+#define BMA2X2_START_EE_PROG_TRIG__MSK      0x02
+#define BMA2X2_START_EE_PROG_TRIG__REG      BMA2X2_EEPROM_CTRL_REG
+
+#define BMA2X2_EE_PROG_READY__POS          2
+#define BMA2X2_EE_PROG_READY__LEN          1
+#define BMA2X2_EE_PROG_READY__MSK          0x04
+#define BMA2X2_EE_PROG_READY__REG          BMA2X2_EEPROM_CTRL_REG
+
+#define BMA2X2_UPDATE_IMAGE__POS                3
+#define BMA2X2_UPDATE_IMAGE__LEN                1
+#define BMA2X2_UPDATE_IMAGE__MSK                0x08
+#define BMA2X2_UPDATE_IMAGE__REG                BMA2X2_EEPROM_CTRL_REG
+
+#define BMA2X2_EE_REMAIN__POS                4
+#define BMA2X2_EE_REMAIN__LEN                4
+#define BMA2X2_EE_REMAIN__MSK                0xF0
+#define BMA2X2_EE_REMAIN__REG                BMA2X2_EEPROM_CTRL_REG
+
+#define BMA2X2_EN_SPI_MODE_3__POS              0
+#define BMA2X2_EN_SPI_MODE_3__LEN              1
+#define BMA2X2_EN_SPI_MODE_3__MSK              0x01
+#define BMA2X2_EN_SPI_MODE_3__REG              BMA2X2_SERIAL_CTRL_REG
+
+#define BMA2X2_I2C_WATCHDOG_PERIOD__POS        1
+#define BMA2X2_I2C_WATCHDOG_PERIOD__LEN        1
+#define BMA2X2_I2C_WATCHDOG_PERIOD__MSK        0x02
+#define BMA2X2_I2C_WATCHDOG_PERIOD__REG        BMA2X2_SERIAL_CTRL_REG
+
+#define BMA2X2_EN_I2C_WATCHDOG__POS            2
+#define BMA2X2_EN_I2C_WATCHDOG__LEN            1
+#define BMA2X2_EN_I2C_WATCHDOG__MSK            0x04
+#define BMA2X2_EN_I2C_WATCHDOG__REG            BMA2X2_SERIAL_CTRL_REG
+
+#define BMA2X2_EXT_MODE__POS              7
+#define BMA2X2_EXT_MODE__LEN              1
+#define BMA2X2_EXT_MODE__MSK              0x80
+#define BMA2X2_EXT_MODE__REG              BMA2X2_EXTMODE_CTRL_REG
+
+#define BMA2X2_ALLOW_UPPER__POS        6
+#define BMA2X2_ALLOW_UPPER__LEN        1
+#define BMA2X2_ALLOW_UPPER__MSK        0x40
+#define BMA2X2_ALLOW_UPPER__REG        BMA2X2_EXTMODE_CTRL_REG
+
+#define BMA2X2_MAP_2_LOWER__POS            5
+#define BMA2X2_MAP_2_LOWER__LEN            1
+#define BMA2X2_MAP_2_LOWER__MSK            0x20
+#define BMA2X2_MAP_2_LOWER__REG            BMA2X2_EXTMODE_CTRL_REG
+
+#define BMA2X2_MAGIC_NUMBER__POS            0
+#define BMA2X2_MAGIC_NUMBER__LEN            5
+#define BMA2X2_MAGIC_NUMBER__MSK            0x1F
+#define BMA2X2_MAGIC_NUMBER__REG            BMA2X2_EXTMODE_CTRL_REG
+
+#define BMA2X2_UNLOCK_EE_WRITE_TRIM__POS        4
+#define BMA2X2_UNLOCK_EE_WRITE_TRIM__LEN        4
+#define BMA2X2_UNLOCK_EE_WRITE_TRIM__MSK        0xF0
+#define BMA2X2_UNLOCK_EE_WRITE_TRIM__REG        BMA2X2_CTRL_UNLOCK_REG
+
+#define BMA2X2_EN_SLOW_COMP_X__POS              0
+#define BMA2X2_EN_SLOW_COMP_X__LEN              1
+#define BMA2X2_EN_SLOW_COMP_X__MSK              0x01
+#define BMA2X2_EN_SLOW_COMP_X__REG              BMA2X2_OFFSET_CTRL_REG
+
+#define BMA2X2_EN_SLOW_COMP_Y__POS              1
+#define BMA2X2_EN_SLOW_COMP_Y__LEN              1
+#define BMA2X2_EN_SLOW_COMP_Y__MSK              0x02
+#define BMA2X2_EN_SLOW_COMP_Y__REG              BMA2X2_OFFSET_CTRL_REG
+
+#define BMA2X2_EN_SLOW_COMP_Z__POS              2
+#define BMA2X2_EN_SLOW_COMP_Z__LEN              1
+#define BMA2X2_EN_SLOW_COMP_Z__MSK              0x04
+#define BMA2X2_EN_SLOW_COMP_Z__REG              BMA2X2_OFFSET_CTRL_REG
+
+#define BMA2X2_FAST_CAL_RDY_S__POS             4
+#define BMA2X2_FAST_CAL_RDY_S__LEN             1
+#define BMA2X2_FAST_CAL_RDY_S__MSK             0x10
+#define BMA2X2_FAST_CAL_RDY_S__REG             BMA2X2_OFFSET_CTRL_REG
+
+#define BMA2X2_CAL_TRIGGER__POS                5
+#define BMA2X2_CAL_TRIGGER__LEN                2
+#define BMA2X2_CAL_TRIGGER__MSK                0x60
+#define BMA2X2_CAL_TRIGGER__REG                BMA2X2_OFFSET_CTRL_REG
+
+#define BMA2X2_RESET_OFFSET_REGS__POS           7
+#define BMA2X2_RESET_OFFSET_REGS__LEN           1
+#define BMA2X2_RESET_OFFSET_REGS__MSK           0x80
+#define BMA2X2_RESET_OFFSET_REGS__REG           BMA2X2_OFFSET_CTRL_REG
+
+#define BMA2X2_COMP_CUTOFF__POS                 0
+#define BMA2X2_COMP_CUTOFF__LEN                 1
+#define BMA2X2_COMP_CUTOFF__MSK                 0x01
+#define BMA2X2_COMP_CUTOFF__REG                 BMA2X2_OFFSET_PARAMS_REG
+
+#define BMA2X2_COMP_TARGET_OFFSET_X__POS        1
+#define BMA2X2_COMP_TARGET_OFFSET_X__LEN        2
+#define BMA2X2_COMP_TARGET_OFFSET_X__MSK        0x06
+#define BMA2X2_COMP_TARGET_OFFSET_X__REG        BMA2X2_OFFSET_PARAMS_REG
+
+#define BMA2X2_COMP_TARGET_OFFSET_Y__POS        3
+#define BMA2X2_COMP_TARGET_OFFSET_Y__LEN        2
+#define BMA2X2_COMP_TARGET_OFFSET_Y__MSK        0x18
+#define BMA2X2_COMP_TARGET_OFFSET_Y__REG        BMA2X2_OFFSET_PARAMS_REG
+
+#define BMA2X2_COMP_TARGET_OFFSET_Z__POS        5
+#define BMA2X2_COMP_TARGET_OFFSET_Z__LEN        2
+#define BMA2X2_COMP_TARGET_OFFSET_Z__MSK        0x60
+#define BMA2X2_COMP_TARGET_OFFSET_Z__REG        BMA2X2_OFFSET_PARAMS_REG
+
+#define BMA2X2_FIFO_DATA_SELECT__POS                 0
+#define BMA2X2_FIFO_DATA_SELECT__LEN                 2
+#define BMA2X2_FIFO_DATA_SELECT__MSK                 0x03
+#define BMA2X2_FIFO_DATA_SELECT__REG                 BMA2X2_FIFO_MODE_REG
+
+#define BMA2X2_FIFO_TRIGGER_SOURCE__POS                 2
+#define BMA2X2_FIFO_TRIGGER_SOURCE__LEN                 2
+#define BMA2X2_FIFO_TRIGGER_SOURCE__MSK                 0x0C
+#define BMA2X2_FIFO_TRIGGER_SOURCE__REG                 BMA2X2_FIFO_MODE_REG
+
+#define BMA2X2_FIFO_TRIGGER_ACTION__POS                 4
+#define BMA2X2_FIFO_TRIGGER_ACTION__LEN                 2
+#define BMA2X2_FIFO_TRIGGER_ACTION__MSK                 0x30
+#define BMA2X2_FIFO_TRIGGER_ACTION__REG                 BMA2X2_FIFO_MODE_REG
+
+#define BMA2X2_FIFO_MODE__POS                 6
+#define BMA2X2_FIFO_MODE__LEN                 2
+#define BMA2X2_FIFO_MODE__MSK                 0xC0
+#define BMA2X2_FIFO_MODE__REG                 BMA2X2_FIFO_MODE_REG
+
+
+#define BMA2X2_STATUS1                             0
+#define BMA2X2_STATUS2                             1
+#define BMA2X2_STATUS3                             2
+#define BMA2X2_STATUS4                             3
+#define BMA2X2_STATUS5                             4
+
+
+#define BMA2X2_RANGE_2G                 3
+#define BMA2X2_RANGE_4G                 5
+#define BMA2X2_RANGE_8G                 8
+#define BMA2X2_RANGE_16G                12
+
+
+#define BMA2X2_BW_7_81HZ        0x08
+#define BMA2X2_BW_15_63HZ       0x09
+#define BMA2X2_BW_31_25HZ       0x0A
+#define BMA2X2_BW_62_50HZ       0x0B
+#define BMA2X2_BW_125HZ         0x0C
+#define BMA2X2_BW_250HZ         0x0D
+#define BMA2X2_BW_500HZ         0x0E
+#define BMA2X2_BW_1000HZ        0x0F
+
+#define BMA2X2_SLEEP_DUR_0_5MS        0x05
+#define BMA2X2_SLEEP_DUR_1MS          0x06
+#define BMA2X2_SLEEP_DUR_2MS          0x07
+#define BMA2X2_SLEEP_DUR_4MS          0x08
+#define BMA2X2_SLEEP_DUR_6MS          0x09
+#define BMA2X2_SLEEP_DUR_10MS         0x0A
+#define BMA2X2_SLEEP_DUR_25MS         0x0B
+#define BMA2X2_SLEEP_DUR_50MS         0x0C
+#define BMA2X2_SLEEP_DUR_100MS        0x0D
+#define BMA2X2_SLEEP_DUR_500MS        0x0E
+#define BMA2X2_SLEEP_DUR_1S           0x0F
+
+#define BMA2X2_LATCH_DUR_NON_LATCH    0x00
+#define BMA2X2_LATCH_DUR_250MS        0x01
+#define BMA2X2_LATCH_DUR_500MS        0x02
+#define BMA2X2_LATCH_DUR_1S           0x03
+#define BMA2X2_LATCH_DUR_2S           0x04
+#define BMA2X2_LATCH_DUR_4S           0x05
+#define BMA2X2_LATCH_DUR_8S           0x06
+#define BMA2X2_LATCH_DUR_LATCH        0x07
+#define BMA2X2_LATCH_DUR_NON_LATCH1   0x08
+#define BMA2X2_LATCH_DUR_250US        0x09
+#define BMA2X2_LATCH_DUR_500US        0x0A
+#define BMA2X2_LATCH_DUR_1MS          0x0B
+#define BMA2X2_LATCH_DUR_12_5MS       0x0C
+#define BMA2X2_LATCH_DUR_25MS         0x0D
+#define BMA2X2_LATCH_DUR_50MS         0x0E
+#define BMA2X2_LATCH_DUR_LATCH1       0x0F
+
+#define BMA2X2_MODE_NORMAL             0
+#define BMA2X2_MODE_LOWPOWER1          1
+#define BMA2X2_MODE_SUSPEND            2
+#define BMA2X2_MODE_DEEP_SUSPEND       3
+#define BMA2X2_MODE_LOWPOWER2          4
+#define BMA2X2_MODE_STANDBY            5
+
+#define BMA2X2_X_AXIS           0
+#define BMA2X2_Y_AXIS           1
+#define BMA2X2_Z_AXIS           2
+
+#define BMA2X2_Low_G_Interrupt       0
+#define BMA2X2_High_G_X_Interrupt    1
+#define BMA2X2_High_G_Y_Interrupt    2
+#define BMA2X2_High_G_Z_Interrupt    3
+#define BMA2X2_DATA_EN               4
+#define BMA2X2_Slope_X_Interrupt     5
+#define BMA2X2_Slope_Y_Interrupt     6
+#define BMA2X2_Slope_Z_Interrupt     7
+#define BMA2X2_Single_Tap_Interrupt  8
+#define BMA2X2_Double_Tap_Interrupt  9
+#define BMA2X2_Orient_Interrupt      10
+#define BMA2X2_Flat_Interrupt        11
+#define BMA2X2_FFULL_INTERRUPT       12
+#define BMA2X2_FWM_INTERRUPT         13
+
+#define BMA2X2_INT1_LOWG         0
+#define BMA2X2_INT2_LOWG         1
+#define BMA2X2_INT1_HIGHG        0
+#define BMA2X2_INT2_HIGHG        1
+#define BMA2X2_INT1_SLOPE        0
+#define BMA2X2_INT2_SLOPE        1
+#define BMA2X2_INT1_SLO_NO_MOT   0
+#define BMA2X2_INT2_SLO_NO_MOT   1
+#define BMA2X2_INT1_DTAP         0
+#define BMA2X2_INT2_DTAP         1
+#define BMA2X2_INT1_STAP         0
+#define BMA2X2_INT2_STAP         1
+#define BMA2X2_INT1_ORIENT       0
+#define BMA2X2_INT2_ORIENT       1
+#define BMA2X2_INT1_FLAT         0
+#define BMA2X2_INT2_FLAT         1
+#define BMA2X2_INT1_NDATA        0
+#define BMA2X2_INT2_NDATA        1
+#define BMA2X2_INT1_FWM          0
+#define BMA2X2_INT2_FWM          1
+#define BMA2X2_INT1_FFULL        0
+#define BMA2X2_INT2_FFULL        1
+
+#define BMA2X2_SRC_LOWG         0
+#define BMA2X2_SRC_HIGHG        1
+#define BMA2X2_SRC_SLOPE        2
+#define BMA2X2_SRC_SLO_NO_MOT   3
+#define BMA2X2_SRC_TAP          4
+#define BMA2X2_SRC_DATA         5
+
+#define BMA2X2_INT1_OUTPUT      0
+#define BMA2X2_INT2_OUTPUT      1
+#define BMA2X2_INT1_LEVEL       0
+#define BMA2X2_INT2_LEVEL       1
+
+#define BMA2X2_LOW_DURATION            0
+#define BMA2X2_HIGH_DURATION           1
+#define BMA2X2_SLOPE_DURATION          2
+#define BMA2X2_SLO_NO_MOT_DURATION     3
+
+#define BMA2X2_LOW_THRESHOLD            0
+#define BMA2X2_HIGH_THRESHOLD           1
+#define BMA2X2_SLOPE_THRESHOLD          2
+#define BMA2X2_SLO_NO_MOT_THRESHOLD     3
+
+
+#define BMA2X2_LOWG_HYST                0
+#define BMA2X2_HIGHG_HYST               1
+
+#define BMA2X2_ORIENT_THETA             0
+#define BMA2X2_FLAT_THETA               1
+
+#define BMA2X2_I2C_SELECT               0
+#define BMA2X2_I2C_EN                   1
+
+#define BMA2X2_SLOW_COMP_X              0
+#define BMA2X2_SLOW_COMP_Y              1
+#define BMA2X2_SLOW_COMP_Z              2
+
+#define BMA2X2_CUT_OFF                  0
+#define BMA2X2_OFFSET_TRIGGER_X         1
+#define BMA2X2_OFFSET_TRIGGER_Y         2
+#define BMA2X2_OFFSET_TRIGGER_Z         3
+
+#define BMA2X2_GP0                      0
+#define BMA2X2_GP1                      1
+
+#define BMA2X2_SLO_NO_MOT_EN_X          0
+#define BMA2X2_SLO_NO_MOT_EN_Y          1
+#define BMA2X2_SLO_NO_MOT_EN_Z          2
+#define BMA2X2_SLO_NO_MOT_EN_SEL        3
+
+#define BMA2X2_WAKE_UP_DUR_20MS         0
+#define BMA2X2_WAKE_UP_DUR_80MS         1
+#define BMA2X2_WAKE_UP_DUR_320MS                2
+#define BMA2X2_WAKE_UP_DUR_2560MS               3
+
+#define BMA2X2_SELF_TEST0_ON            1
+#define BMA2X2_SELF_TEST1_ON            2
+
+#define BMA2X2_EE_W_OFF                 0
+#define BMA2X2_EE_W_ON                  1
+
+#define BMA2X2_LOW_TH_IN_G(gthres, range)           ((256 * gthres) / range)
+
+
+#define BMA2X2_HIGH_TH_IN_G(gthres, range)          ((256 * gthres) / range)
+
+
+#define BMA2X2_LOW_HY_IN_G(ghyst, range)            ((32 * ghyst) / range)
+
+
+#define BMA2X2_HIGH_HY_IN_G(ghyst, range)           ((32 * ghyst) / range)
+
+
+#define BMA2X2_SLOPE_TH_IN_G(gthres, range)    ((128 * gthres) / range)
+
+
+#define BMA2X2_GET_BITSLICE(regvar, bitname)\
+	((regvar & bitname##__MSK) >> bitname##__POS)
+
+
+#define BMA2X2_SET_BITSLICE(regvar, bitname, val)\
+	((regvar & ~bitname##__MSK) | ((val<<bitname##__POS)&bitname##__MSK))
+
+#define CHECK_CHIP_ID_TIME_MAX 5
+#define BMA255_CHIP_ID 0XFA
+#define BMA250E_CHIP_ID 0XF9
+#define BMA222E_CHIP_ID 0XF8
+#define BMA280_CHIP_ID 0XFB
+#define BMA355_CHIP_ID 0XEA
+
+#define BMA255_TYPE 0
+#define BMA250E_TYPE 1
+#define BMA222E_TYPE 2
+#define BMA280_TYPE 3
+
+#define MAX_FIFO_F_LEVEL 32
+#define MAX_FIFO_F_BYTES 6
+#define BMA_MAX_RETRY_I2C_XFER (100)
+
+#ifdef CONFIG_DOUBLE_TAP
+#define DEFAULT_TAP_JUDGE_PERIOD 1000    /* default judge in 1 second */
+#endif
+
+/*! Bosch sensor unknown place*/
+#define BOSCH_SENSOR_PLACE_UNKNOWN (-1)
+
+#define BOSCH_SENSOR_PLACE         (4)
+
+/*! Bosch sensor remapping table size P0~P7*/
+#define MAX_AXIS_REMAP_TAB_SZ 8
+
+/* How was BMA enabled(set to operation mode) */
+#define BMA_ENABLED_ALL 0
+#define BMA_ENABLED_SGM 1
+#define BMA_ENABLED_DTAP 2
+#define BMA_ENABLED_INPUT 3
+#define BMA_ENABLED_BSX 4
+
+#define BOSCH_SENSOR_BAD_ADDR        -1
+
+
+/*!
+ * @brief:BMI058 feature
+ *  macro definition
+*/
+
+#define BMA2X2_FIFO_DAT_SEL_X                     1
+#define BMA2X2_FIFO_DAT_SEL_Y                     2
+#define BMA2X2_FIFO_DAT_SEL_Z                     3
+
+#ifdef CONFIG_SENSORS_BMI058
+#define C_BMI058_One_U8X                                 1
+#define C_BMI058_Two_U8X                                 2
+#define BMI058_OFFSET_TRIGGER_X                BMA2X2_OFFSET_TRIGGER_Y
+#define BMI058_OFFSET_TRIGGER_Y                BMA2X2_OFFSET_TRIGGER_X
+
+/*! BMI058 X AXIS OFFSET REG definition*/
+#define BMI058_OFFSET_X_AXIS_REG              BMA2X2_OFFSET_Y_AXIS_REG
+/*! BMI058 Y AXIS OFFSET REG definition*/
+#define BMI058_OFFSET_Y_AXIS_REG              BMA2X2_OFFSET_X_AXIS_REG
+
+#define BMI058_FIFO_DAT_SEL_X                       BMA2X2_FIFO_DAT_SEL_Y
+#define BMI058_FIFO_DAT_SEL_Y                       BMA2X2_FIFO_DAT_SEL_X
+
+/*! BMA2x2 common slow no motion X interrupt type definition*/
+#define BMA2X2_SLOW_NO_MOT_X_INT          12
+/*! BMA2x2 common slow no motion Y interrupt type definition*/
+#define BMA2X2_SLOW_NO_MOT_Y_INT          13
+/*! BMA2x2 common High G X interrupt type definition*/
+#define BMA2X2_HIGHG_X_INT          1
+/*! BMA2x2 common High G Y interrupt type definition*/
+#define BMA2X2_HIGHG_Y_INT          2
+/*! BMA2x2 common slope X interrupt type definition*/
+#define BMA2X2_SLOPE_X_INT          5
+/*! BMA2x2 common slope Y interrupt type definition*/
+#define BMA2X2_SLOPE_Y_INT          6
+
+/*! this structure holds some interrupt types difference
+**between BMA2x2 and BMI058.
+*/
+struct interrupt_map_t {
+	int x;
+	int y;
+};
+/*!*Need to use BMA2x2 Common interrupt type definition to
+* instead of Some of BMI058 reversed Interrupt type
+* because of HW Register.
+* The reversed Interrupt types contain:
+* slow_no_mot_x_int && slow_not_mot_y_int
+* highg_x_int && highg_y_int
+* slope_x_int && slope_y_int
+**/
+static const struct interrupt_map_t int_map[] = {
+	{BMA2X2_SLOW_NO_MOT_X_INT, BMA2X2_SLOW_NO_MOT_Y_INT},
+	{BMA2X2_HIGHG_X_INT, BMA2X2_HIGHG_Y_INT},
+	{BMA2X2_SLOPE_X_INT, BMA2X2_SLOPE_Y_INT}
+};
+
+/*! high g or slope interrupt type definition for BMI058*/
+/*! High G interrupt of x, y, z axis happened */
+#define HIGH_G_INTERRUPT_X            HIGH_G_INTERRUPT_Y_HAPPENED
+#define HIGH_G_INTERRUPT_Y            HIGH_G_INTERRUPT_X_HAPPENED
+#define HIGH_G_INTERRUPT_Z            HIGH_G_INTERRUPT_Z_HAPPENED
+/*! High G interrupt of x, y, z negative axis happened */
+#define HIGH_G_INTERRUPT_X_N          HIGH_G_INTERRUPT_Y_NEGATIVE_HAPPENED
+#define HIGH_G_INTERRUPT_Y_N          HIGH_G_INTERRUPT_X_NEGATIVE_HAPPENED
+#define HIGH_G_INTERRUPT_Z_N          HIGH_G_INTERRUPT_Z_NEGATIVE_HAPPENED
+/*! Slope interrupt of x, y, z axis happened */
+#define SLOPE_INTERRUPT_X             SLOPE_INTERRUPT_Y_HAPPENED
+#define SLOPE_INTERRUPT_Y             SLOPE_INTERRUPT_X_HAPPENED
+#define SLOPE_INTERRUPT_Z             SLOPE_INTERRUPT_Z_HAPPENED
+/*! Slope interrupt of x, y, z negative axis happened */
+#define SLOPE_INTERRUPT_X_N           SLOPE_INTERRUPT_Y_NEGATIVE_HAPPENED
+#define SLOPE_INTERRUPT_Y_N           SLOPE_INTERRUPT_X_NEGATIVE_HAPPENED
+#define SLOPE_INTERRUPT_Z_N           SLOPE_INTERRUPT_Z_NEGATIVE_HAPPENED
+
+
+#else
+
+/*! high g or slope interrupt type definition*/
+/*! High G interrupt of x, y, z axis happened */
+#define HIGH_G_INTERRUPT_X            HIGH_G_INTERRUPT_X_HAPPENED
+#define HIGH_G_INTERRUPT_Y            HIGH_G_INTERRUPT_Y_HAPPENED
+#define HIGH_G_INTERRUPT_Z            HIGH_G_INTERRUPT_Z_HAPPENED
+/*! High G interrupt of x, y, z negative axis happened */
+#define HIGH_G_INTERRUPT_X_N          HIGH_G_INTERRUPT_X_NEGATIVE_HAPPENED
+#define HIGH_G_INTERRUPT_Y_N          HIGH_G_INTERRUPT_Y_NEGATIVE_HAPPENED
+#define HIGH_G_INTERRUPT_Z_N          HIGH_G_INTERRUPT_Z_NEGATIVE_HAPPENED
+/*! Slope interrupt of x, y, z axis happened */
+#define SLOPE_INTERRUPT_X             SLOPE_INTERRUPT_X_HAPPENED
+#define SLOPE_INTERRUPT_Y             SLOPE_INTERRUPT_Y_HAPPENED
+#define SLOPE_INTERRUPT_Z             SLOPE_INTERRUPT_Z_HAPPENED
+/*! Slope interrupt of x, y, z negative axis happened */
+#define SLOPE_INTERRUPT_X_N           SLOPE_INTERRUPT_X_NEGATIVE_HAPPENED
+#define SLOPE_INTERRUPT_Y_N           SLOPE_INTERRUPT_Y_NEGATIVE_HAPPENED
+#define SLOPE_INTERRUPT_Z_N           SLOPE_INTERRUPT_Z_NEGATIVE_HAPPENED
+
+
+#endif/*End of CONFIG_SENSORS_BMI058*/
+
+
+struct bma2x2_type_map_t {
+
+	/*! bma2x2 sensor chip id */
+	uint16_t chip_id;
+
+	/*! bma2x2 sensor type */
+	uint16_t sensor_type;
+
+	/*! bma2x2 sensor name */
+	const char *sensor_name;
+};
+
+static const struct bma2x2_type_map_t sensor_type_map[] = {
+
+	{BMA255_CHIP_ID, BMA255_TYPE, "BMA255/254"},
+	{BMA355_CHIP_ID, BMA255_TYPE, "BMA355"},
+	{BMA250E_CHIP_ID, BMA250E_TYPE, "BMA250E"},
+	{BMA222E_CHIP_ID, BMA222E_TYPE, "BMA222E"},
+	{BMA280_CHIP_ID, BMA280_TYPE, "BMA280"},
+
+};
+
+/*!
+* Bst sensor common definition,
+* please give parameters in BSP file.
+*/
+struct bosch_sensor_specific {
+	char *name;
+	/* 0 to 7 */
+	int place;
+	int irq;
+	int (*irq_gpio_cfg)(void);
+};
+
+
+/*!
+ * we use a typedef to hide the detail,
+ * because this type might be changed
+ */
+struct bosch_sensor_axis_remap {
+	/* src means which source will be mapped to target x, y, z axis */
+	/* if an target OS axis is remapped from (-)x,
+	 * src is 0, sign_* is (-)1 */
+	/* if an target OS axis is remapped from (-)y,
+	 * src is 1, sign_* is (-)1 */
+	/* if an target OS axis is remapped from (-)z,
+	 * src is 2, sign_* is (-)1 */
+	int src_x:3;
+	int src_y:3;
+	int src_z:3;
+
+	int sign_x:2;
+	int sign_y:2;
+	int sign_z:2;
+};
+
+struct bosch_sensor_data {
+	union {
+		int16_t v[3];
+		struct {
+			int16_t x;
+			int16_t y;
+			int16_t z;
+		};
+	};
+};
+
+struct bma2x2acc {
+	s16 x;
+	s16 y;
+	s16 z;
+};
+
+struct bma2x2_data {
+	struct i2c_client *bma2x2_client;
+	atomic_t delay;
+	atomic_t enable;
+	atomic_t selftest_result;
+	unsigned int chip_id;
+	unsigned int fifo_count;
+	unsigned char fifo_datasel;
+	unsigned char mode;
+	signed char sensor_type;
+	struct input_dev *input;
+
+	struct bst_dev *bst_acc;
+
+	struct bma2x2acc value;
+	struct mutex value_mutex;
+	struct mutex enable_mutex;
+	struct mutex mode_mutex;
+//	struct delayed_work work;
+	struct work_struct work;
+	struct hrtimer timer;
+	struct workqueue_struct *wq;
+	struct work_struct irq_work;
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	struct early_suspend early_suspend;
+#endif
+	int IRQ;
+	struct bosch_sensor_specific *bst_pd;
+
+	int bma_mode_enabled;
+	struct input_dev *dev_interrupt;
+
+#ifdef CONFIG_SIG_MOTION
+	struct class *g_sensor_class;
+	struct device *g_sensor_dev;
+
+	/*struct bma250_platform_data *pdata;*/
+	atomic_t en_sig_motion;
+#endif
+
+#ifdef CONFIG_DOUBLE_TAP
+	struct class *g_sensor_class_doubletap;
+	struct device *g_sensor_dev_doubletap;
+	atomic_t en_double_tap;
+	unsigned char tap_times;
+	struct mutex		tap_mutex;
+	struct timer_list	tap_timer;
+	int tap_time_period;
+#endif
+};
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+static void bma2x2_early_suspend(struct early_suspend *h);
+static void bma2x2_late_resume(struct early_suspend *h);
+#endif
+
+static int bma2x2_set_mode(struct i2c_client *client,
+			u8 mode, u8 enabled_mode);
+static int bma2x2_get_mode(struct i2c_client *client, u8 *mode);
+static int bma2x2_get_fifo_mode(struct i2c_client *client, u8 *fifo_mode);
+static int bma2x2_set_fifo_mode(struct i2c_client *client, u8 fifo_mode);
+static int bma2x2_normal_to_suspend(struct bma2x2_data *bma2x2,
+				unsigned char data1, unsigned char data2);
+
+
+/*Remapping for BMA2X2*/
+
+static const struct bosch_sensor_axis_remap
+bst_axis_remap_tab_dft[MAX_AXIS_REMAP_TAB_SZ] = {
+	/* src_x src_y src_z  sign_x  sign_y  sign_z */
+	{  0,    1,    2,     1,      1,      1 }, /* P0 */
+	{  1,    0,    2,     1,     -1,      1 }, /* P1 */
+	{  0,    1,    2,    -1,     -1,      1 }, /* P2 */
+	{  1,    0,    2,    -1,      1,      1 }, /* P3 */
+
+	{  0,    1,    2,    -1,      1,     -1 }, /* P4 */
+	{  1,    0,    2,    -1,     -1,     -1 }, /* P5 */
+	{  0,    1,    2,     1,     -1,     -1 }, /* P6 */
+	{  1,    0,    2,     1,      1,     -1 }, /* P7 */
+};
+
+static unsigned int read_file(char *filename)
+{
+    struct file *filp;
+    char bufs[100];
+    int ret;
+	unsigned int data_val=0;
+ 
+   // strcpy(bufs, "hello my world");
+ 
+    /* kernel memory access setting */
+    mm_segment_t old_fs = get_fs();
+    set_fs(KERNEL_DS);
+ 
+    /* open a file */
+    filp = filp_open(filename, O_RDWR, 0664);
+    if (IS_ERR(filp)) {
+        printk(KERN_ERR"open error\n");
+        return -1;
+    }
+    else {
+        printk(KERN_ERR"open success\n");
+    }
+ 
+    /* write example */
+  ///  printk("filp->f_pos = %d\n", (int)filp->f_pos);
+  //  vfs_write(filp, bufs, strlen(bufs), &filp->f_pos);
+  //  printk("filp->f_pos = %d\n", (int)filp->f_pos);
+ 
+    /* read example */
+    printk(KERN_DEBUG);
+
+     //   int pos = (int)filp->f_pos;
+        printk(KERN_ERR"filp->f_pos=%d \n: ", (int)filp->f_pos);
+        memset(bufs,'\n',60);
+        ret = vfs_read(filp, bufs, 60, &filp->f_pos);
+        printk(KERN_ERR"char_cnt =%d \n: ", ret);
+		
+        if (ret != 0) {
+            printk(KERN_ERR"filp->f_pos=%d\n", (int)filp->f_pos);
+        }
+        printk("\n");
+
+ 	ret= sscanf(bufs,"%10d\n",&data_val);
+	printk(KERN_ERR"data_val=%d\n", data_val);
+    filp_close(filp, NULL);  /* filp_close(filp, current->files) ?  */
+    /* restore kernel memory setting */
+
+    set_fs(old_fs);
+	return data_val;
+}
+
+static void bst_remap_sensor_data(struct bosch_sensor_data *data,
+		const struct bosch_sensor_axis_remap *remap)
+{
+	struct bosch_sensor_data tmp;
+
+	tmp.x = data->v[remap->src_x] * remap->sign_x;
+	tmp.y = data->v[remap->src_y] * remap->sign_y;
+	tmp.z = data->v[remap->src_z] * remap->sign_z;
+
+	memcpy(data, &tmp, sizeof(*data));
+}
+
+static void bst_remap_sensor_data_dft_tab(struct bosch_sensor_data *data,
+		int place)
+{
+	/* sensor with place 0 needs not to be remapped */
+	if ((place <= 0) || (place >= MAX_AXIS_REMAP_TAB_SZ))
+		return;
+
+	bst_remap_sensor_data(data, &bst_axis_remap_tab_dft[place]);
+}
+
+static void bma2x2_remap_sensor_data(struct bma2x2acc *val,
+		struct bma2x2_data *client_data)
+{
+	struct bosch_sensor_data bsd;
+	int place;
+
+	if ((NULL == client_data->bst_pd) || (BOSCH_SENSOR_PLACE_UNKNOWN
+			 == client_data->bst_pd->place))
+		place = BOSCH_SENSOR_PLACE_UNKNOWN;
+	else
+		place = client_data->bst_pd->place;
+
+#ifdef CONFIG_SENSORS_BMI058
+/*x,y need to be invesed becase of HW Register for BMI058*/
+	bsd.y = val->x;
+	bsd.x = val->y;
+	bsd.z = val->z;
+#else
+	bsd.x = val->x;
+	bsd.y = val->y;
+	bsd.z = val->z;
+#endif
+
+	bst_remap_sensor_data_dft_tab(&bsd, place);
+
+	val->x = bsd.x;
+	val->y = bsd.y;
+	val->z = bsd.z;
+
+}
+
+
+static int bma2x2_smbus_read_byte(struct i2c_client *client,
+		unsigned char reg_addr, unsigned char *data)
+{
+	s32 dummy;
+	dummy = i2c_smbus_read_byte_data(client, reg_addr);
+	if (dummy < 0)
+		return -1;
+	*data = dummy & 0x000000ff;
+
+	return 0;
+}
+
+static int bma2x2_smbus_write_byte(struct i2c_client *client,
+		unsigned char reg_addr, unsigned char *data)
+{
+	s32 dummy;
+
+	dummy = i2c_smbus_write_byte_data(client, reg_addr, *data);
+	if (dummy < 0)
+		return -1;
+	udelay(2);
+	return 0;
+}
+
+static int bma2x2_smbus_read_byte_block(struct i2c_client *client,
+		unsigned char reg_addr, unsigned char *data, unsigned char len)
+{
+	s32 dummy;
+	dummy = i2c_smbus_read_i2c_block_data(client, reg_addr, len, data);
+	if (dummy < 0)
+		return -1;
+	return 0;
+}
+
+static int bma_i2c_burst_read(struct i2c_client *client, u8 reg_addr,
+		u8 *data, u16 len)
+{
+	int retry;
+
+	struct i2c_msg msg[] = {
+		{
+		 .addr = client->addr,
+		 .flags = 0,
+		 .len = 1,
+		 .buf = &reg_addr,
+		},
+
+		{
+		 .addr = client->addr,
+		 .flags = I2C_M_RD,
+		 .len = len,
+		 .buf = data,
+		 },
+	};
+
+	for (retry = 0; retry < BMA_MAX_RETRY_I2C_XFER; retry++) {
+		if (i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg)) > 0)
+			break;
+		else
+			mdelay(1);
+	}
+
+	if (BMA_MAX_RETRY_I2C_XFER <= retry) {
+		PINFO("I2C xfer error");
+		return -EIO;
+	}
+
+	return 0;
+}
+
+static int bma2x2_check_chip_id(struct i2c_client *client,
+					struct bma2x2_data *data)
+{
+	int i = 0;
+	int err = 0;
+	unsigned char chip_id = 0;
+	unsigned char read_count = 0;
+	unsigned char bma2x2_sensor_type_count = 0;
+
+	bma2x2_sensor_type_count =
+		sizeof(sensor_type_map) / sizeof(struct bma2x2_type_map_t);
+
+	while (read_count++ < CHECK_CHIP_ID_TIME_MAX) {
+		if (bma2x2_smbus_read_byte(client, BMA2X2_CHIP_ID_REG,
+							&chip_id) < 0) {
+			PERR("Bosch Sensortec Device not found"
+			"i2c bus read error, read chip_id:%d\n", chip_id);
+			continue;
+		} else {
+		for (i = 0; i < bma2x2_sensor_type_count; i++) {
+			if (sensor_type_map[i].chip_id == chip_id) {
+				data->sensor_type =
+					sensor_type_map[i].sensor_type;
+				data->chip_id = chip_id;
+				PINFO("Bosch Sensortec Device detected,"
+					" HW IC name: %s\n",
+						sensor_type_map[i].sensor_name);
+					return err;
+			}
+		}
+		if (i < bma2x2_sensor_type_count)
+			return err;
+		else {
+			if (read_count == CHECK_CHIP_ID_TIME_MAX) {
+				PERR("Failed! Bosch Sensortec Device"
+					" not found, mismatch chip_id:%d\n",
+								chip_id);
+					err = -ENODEV;
+					return err;
+			}
+		}
+		mdelay(1);
+		}
+	}
+	return err;
+}
+
+#ifdef CONFIG_BMA_ENABLE_NEWDATA_INT
+static int bma2x2_set_newdata(struct i2c_client *client,
+			unsigned char channel, unsigned char int_newdata)
+{
+
+	unsigned char data = 0;
+	int comres = 0;
+
+	switch (channel) {
+	case BMA2X2_INT1_NDATA:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT1_PAD_NEWDATA__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data,
+				BMA2X2_EN_INT1_PAD_NEWDATA, int_newdata);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT1_PAD_NEWDATA__REG, &data);
+		break;
+	case BMA2X2_INT2_NDATA:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT2_PAD_NEWDATA__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data,
+				BMA2X2_EN_INT2_PAD_NEWDATA, int_newdata);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT2_PAD_NEWDATA__REG, &data);
+		break;
+	default:
+		comres = -1;
+		break;
+	}
+
+	return comres;
+
+}
+#endif /* CONFIG_BMA_ENABLE_NEWDATA_INT */
+
+#ifdef BMA2X2_ENABLE_INT1
+static int bma2x2_set_int1_pad_sel(struct i2c_client *client, unsigned char
+		int1sel)
+{
+	int comres = 0;
+	unsigned char data = 0;
+	unsigned char state;
+	state = 0x01;
+
+	switch (int1sel) {
+	case 0:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT1_PAD_LOWG__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT1_PAD_LOWG,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT1_PAD_LOWG__REG, &data);
+		break;
+	case 1:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT1_PAD_HIGHG__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT1_PAD_HIGHG,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT1_PAD_HIGHG__REG, &data);
+		break;
+	case 2:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT1_PAD_SLOPE__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT1_PAD_SLOPE,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT1_PAD_SLOPE__REG, &data);
+		break;
+	case 3:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT1_PAD_DB_TAP__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT1_PAD_DB_TAP,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT1_PAD_DB_TAP__REG, &data);
+		break;
+	case 4:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT1_PAD_SNG_TAP__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT1_PAD_SNG_TAP,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT1_PAD_SNG_TAP__REG, &data);
+		break;
+	case 5:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT1_PAD_ORIENT__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT1_PAD_ORIENT,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT1_PAD_ORIENT__REG, &data);
+		break;
+	case 6:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT1_PAD_FLAT__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT1_PAD_FLAT,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT1_PAD_FLAT__REG, &data);
+		break;
+	case 7:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT1_PAD_SLO_NO_MOT__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT1_PAD_SLO_NO_MOT,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT1_PAD_SLO_NO_MOT__REG, &data);
+		break;
+
+	default:
+		break;
+	}
+
+	return comres;
+}
+#endif /* BMA2X2_ENABLE_INT1 */
+
+#ifdef BMA2X2_ENABLE_INT2
+static int bma2x2_set_int2_pad_sel(struct i2c_client *client, unsigned char
+		int2sel)
+{
+	int comres = 0;
+	unsigned char data = 0;
+	unsigned char state;
+	state = 0x01;
+
+
+	switch (int2sel) {
+	case 0:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT2_PAD_LOWG__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT2_PAD_LOWG,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT2_PAD_LOWG__REG, &data);
+		break;
+	case 1:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT2_PAD_HIGHG__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT2_PAD_HIGHG,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT2_PAD_HIGHG__REG, &data);
+		break;
+	case 2:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT2_PAD_SLOPE__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT2_PAD_SLOPE,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT2_PAD_SLOPE__REG, &data);
+		break;
+	case 3:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT2_PAD_DB_TAP__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT2_PAD_DB_TAP,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT2_PAD_DB_TAP__REG, &data);
+		break;
+	case 4:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT2_PAD_SNG_TAP__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT2_PAD_SNG_TAP,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT2_PAD_SNG_TAP__REG, &data);
+		break;
+	case 5:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT2_PAD_ORIENT__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT2_PAD_ORIENT,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT2_PAD_ORIENT__REG, &data);
+		break;
+	case 6:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT2_PAD_FLAT__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT2_PAD_FLAT,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT2_PAD_FLAT__REG, &data);
+		break;
+	case 7:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_EN_INT2_PAD_SLO_NO_MOT__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_INT2_PAD_SLO_NO_MOT,
+				state);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_EN_INT2_PAD_SLO_NO_MOT__REG, &data);
+		break;
+	default:
+		break;
+	}
+
+	return comres;
+}
+#endif /* BMA2X2_ENABLE_INT2 */
+
+static int bma2x2_set_Int_Enable(struct i2c_client *client, unsigned char
+		InterruptType , unsigned char value)
+{
+	int comres = 0;
+	unsigned char data1 = 0;
+	unsigned char data2 = 0;
+
+	if ((11 < InterruptType) && (InterruptType < 16)) {
+		switch (InterruptType) {
+		case 12:
+			/* slow/no motion X Interrupt  */
+			comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_INT_SLO_NO_MOT_EN_X_INT__REG, &data1);
+			data1 = BMA2X2_SET_BITSLICE(data1,
+				BMA2X2_INT_SLO_NO_MOT_EN_X_INT, value);
+			comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_INT_SLO_NO_MOT_EN_X_INT__REG, &data1);
+			break;
+		case 13:
+			/* slow/no motion Y Interrupt  */
+			comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_INT_SLO_NO_MOT_EN_Y_INT__REG, &data1);
+			data1 = BMA2X2_SET_BITSLICE(data1,
+				BMA2X2_INT_SLO_NO_MOT_EN_Y_INT, value);
+			comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_INT_SLO_NO_MOT_EN_Y_INT__REG, &data1);
+			break;
+		case 14:
+			/* slow/no motion Z Interrupt  */
+			comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_INT_SLO_NO_MOT_EN_Z_INT__REG, &data1);
+			data1 = BMA2X2_SET_BITSLICE(data1,
+				BMA2X2_INT_SLO_NO_MOT_EN_Z_INT, value);
+			comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_INT_SLO_NO_MOT_EN_Z_INT__REG, &data1);
+			break;
+		case 15:
+			/* slow / no motion Interrupt select */
+			comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_INT_SLO_NO_MOT_EN_SEL_INT__REG, &data1);
+			data1 = BMA2X2_SET_BITSLICE(data1,
+				BMA2X2_INT_SLO_NO_MOT_EN_SEL_INT, value);
+			comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_INT_SLO_NO_MOT_EN_SEL_INT__REG, &data1);
+		}
+
+	return comres;
+	}
+
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_INT_ENABLE1_REG, &data1);
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_INT_ENABLE2_REG, &data2);
+
+	value = value & 1;
+	switch (InterruptType) {
+	case 0:
+		/* Low G Interrupt  */
+		data2 = BMA2X2_SET_BITSLICE(data2, BMA2X2_EN_LOWG_INT, value);
+		break;
+
+	case 1:
+		/* High G X Interrupt */
+		data2 = BMA2X2_SET_BITSLICE(data2, BMA2X2_EN_HIGHG_X_INT,
+				value);
+		break;
+
+	case 2:
+		/* High G Y Interrupt */
+		data2 = BMA2X2_SET_BITSLICE(data2, BMA2X2_EN_HIGHG_Y_INT,
+				value);
+		break;
+
+	case 3:
+		/* High G Z Interrupt */
+		data2 = BMA2X2_SET_BITSLICE(data2, BMA2X2_EN_HIGHG_Z_INT,
+				value);
+		break;
+
+	case 4:
+		/* New Data Interrupt  */
+		data2 = BMA2X2_SET_BITSLICE(data2, BMA2X2_EN_NEW_DATA_INT,
+				value);
+		break;
+
+	case 5:
+		/* Slope X Interrupt */
+		data1 = BMA2X2_SET_BITSLICE(data1, BMA2X2_EN_SLOPE_X_INT,
+				value);
+		break;
+
+	case 6:
+		/* Slope Y Interrupt */
+		data1 = BMA2X2_SET_BITSLICE(data1, BMA2X2_EN_SLOPE_Y_INT,
+				value);
+		break;
+
+	case 7:
+		/* Slope Z Interrupt */
+		data1 = BMA2X2_SET_BITSLICE(data1, BMA2X2_EN_SLOPE_Z_INT,
+				value);
+		break;
+
+	case 8:
+		/* Single Tap Interrupt */
+		data1 = BMA2X2_SET_BITSLICE(data1, BMA2X2_EN_SINGLE_TAP_INT,
+				value);
+		break;
+
+	case 9:
+		/* Double Tap Interrupt */
+		data1 = BMA2X2_SET_BITSLICE(data1, BMA2X2_EN_DOUBLE_TAP_INT,
+				value);
+		break;
+
+	case 10:
+		/* Orient Interrupt  */
+		data1 = BMA2X2_SET_BITSLICE(data1, BMA2X2_EN_ORIENT_INT, value);
+		break;
+
+	case 11:
+		/* Flat Interrupt */
+		data1 = BMA2X2_SET_BITSLICE(data1, BMA2X2_EN_FLAT_INT, value);
+		break;
+
+	default:
+		break;
+	}
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_INT_ENABLE1_REG,
+			&data1);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_INT_ENABLE2_REG,
+			&data2);
+
+	return comres;
+}
+
+
+#if defined(BMA2X2_ENABLE_INT1) || defined(BMA2X2_ENABLE_INT2)
+static int bma2x2_get_interruptstatus1(struct i2c_client *client, unsigned char
+		*intstatus)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_STATUS1_REG, &data);
+	*intstatus = data;
+
+	return comres;
+}
+
+#ifdef CONFIG_BMA_ENABLE_NEWDATA_INT
+static int bma2x2_get_interruptstatus2(struct i2c_client *client, unsigned char
+		*intstatus)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_STATUS2_REG, &data);
+	*intstatus = data;
+
+	return comres;
+}
+#endif
+
+static int bma2x2_get_HIGH_first(struct i2c_client *client, unsigned char
+						param, unsigned char *intstatus)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	switch (param) {
+	case 0:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_STATUS_ORIENT_HIGH_REG, &data);
+		data = BMA2X2_GET_BITSLICE(data, BMA2X2_HIGHG_FIRST_X);
+		*intstatus = data;
+		break;
+	case 1:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_STATUS_ORIENT_HIGH_REG, &data);
+		data = BMA2X2_GET_BITSLICE(data, BMA2X2_HIGHG_FIRST_Y);
+		*intstatus = data;
+		break;
+	case 2:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_STATUS_ORIENT_HIGH_REG, &data);
+		data = BMA2X2_GET_BITSLICE(data, BMA2X2_HIGHG_FIRST_Z);
+		*intstatus = data;
+		break;
+	default:
+		break;
+	}
+
+	return comres;
+}
+
+static int bma2x2_get_HIGH_sign(struct i2c_client *client, unsigned char
+		*intstatus)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_STATUS_ORIENT_HIGH_REG,
+			&data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_HIGHG_SIGN_S);
+	*intstatus = data;
+
+	return comres;
+}
+
+#ifndef CONFIG_SIG_MOTION
+static int bma2x2_get_slope_first(struct i2c_client *client, unsigned char
+	param, unsigned char *intstatus)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	switch (param) {
+	case 0:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_STATUS_TAP_SLOPE_REG, &data);
+		data = BMA2X2_GET_BITSLICE(data, BMA2X2_SLOPE_FIRST_X);
+		*intstatus = data;
+		break;
+	case 1:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_STATUS_TAP_SLOPE_REG, &data);
+		data = BMA2X2_GET_BITSLICE(data, BMA2X2_SLOPE_FIRST_Y);
+		*intstatus = data;
+		break;
+	case 2:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_STATUS_TAP_SLOPE_REG, &data);
+		data = BMA2X2_GET_BITSLICE(data, BMA2X2_SLOPE_FIRST_Z);
+		*intstatus = data;
+		break;
+	default:
+		break;
+	}
+
+	return comres;
+}
+
+static int bma2x2_get_slope_sign(struct i2c_client *client, unsigned char
+		*intstatus)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_STATUS_TAP_SLOPE_REG,
+			&data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_SLOPE_SIGN_S);
+	*intstatus = data;
+
+	return comres;
+}
+#endif
+
+static int bma2x2_get_orient_status(struct i2c_client *client, unsigned char
+		*intstatus)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_STATUS_ORIENT_HIGH_REG,
+			&data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_ORIENT_S);
+	*intstatus = data;
+
+	return comres;
+}
+
+static int bma2x2_get_orient_flat_status(struct i2c_client *client, unsigned
+		char *intstatus)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_STATUS_ORIENT_HIGH_REG,
+			&data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_FLAT_S);
+	*intstatus = data;
+
+	return comres;
+}
+#endif /* defined(BMA2X2_ENABLE_INT1)||defined(BMA2X2_ENABLE_INT2) */
+
+static int bma2x2_set_Int_Mode(struct i2c_client *client, unsigned char Mode)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+
+	comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_INT_MODE_SEL__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_INT_MODE_SEL, Mode);
+	comres = bma2x2_smbus_write_byte(client,
+			BMA2X2_INT_MODE_SEL__REG, &data);
+
+
+	return comres;
+}
+
+static int bma2x2_get_Int_Mode(struct i2c_client *client, unsigned char *Mode)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+
+	comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_INT_MODE_SEL__REG, &data);
+	data  = BMA2X2_GET_BITSLICE(data, BMA2X2_INT_MODE_SEL);
+	*Mode = data;
+
+
+	return comres;
+}
+static int bma2x2_set_slope_duration(struct i2c_client *client, unsigned char
+		duration)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+
+	comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_SLOPE_DUR__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_SLOPE_DUR, duration);
+	comres = bma2x2_smbus_write_byte(client,
+			BMA2X2_SLOPE_DUR__REG, &data);
+
+	return comres;
+}
+
+static int bma2x2_get_slope_duration(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+
+	comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_SLOPE_DURN_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_SLOPE_DUR);
+	*status = data;
+
+
+	return comres;
+}
+
+static int bma2x2_set_slope_no_mot_duration(struct i2c_client *client,
+			unsigned char duration)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+
+	comres = bma2x2_smbus_read_byte(client,
+			BMA2x2_SLO_NO_MOT_DUR__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2x2_SLO_NO_MOT_DUR, duration);
+	comres = bma2x2_smbus_write_byte(client,
+			BMA2x2_SLO_NO_MOT_DUR__REG, &data);
+
+
+	return comres;
+}
+
+static int bma2x2_get_slope_no_mot_duration(struct i2c_client *client,
+			unsigned char *status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+
+	comres = bma2x2_smbus_read_byte(client,
+			BMA2x2_SLO_NO_MOT_DUR__REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2x2_SLO_NO_MOT_DUR);
+	*status = data;
+
+
+	return comres;
+}
+
+static int bma2x2_set_slope_threshold(struct i2c_client *client,
+		unsigned char threshold)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	data = threshold;
+	comres = bma2x2_smbus_write_byte(client,
+			BMA2X2_SLOPE_THRES__REG, &data);
+
+	return comres;
+}
+
+static int bma2x2_get_slope_threshold(struct i2c_client *client,
+		unsigned char *status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+
+	comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_SLOPE_THRES_REG, &data);
+	*status = data;
+
+	return comres;
+}
+
+static int bma2x2_set_slope_no_mot_threshold(struct i2c_client *client,
+		unsigned char threshold)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	data = threshold;
+	comres = bma2x2_smbus_write_byte(client,
+			BMA2X2_SLO_NO_MOT_THRES_REG, &data);
+
+	return comres;
+}
+
+static int bma2x2_get_slope_no_mot_threshold(struct i2c_client *client,
+		unsigned char *status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+
+	comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_SLO_NO_MOT_THRES_REG, &data);
+	*status = data;
+
+	return comres;
+}
+
+
+static int bma2x2_set_low_g_duration(struct i2c_client *client, unsigned char
+		duration)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_LOWG_DUR__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_LOWG_DUR, duration);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_LOWG_DUR__REG, &data);
+
+	return comres;
+}
+
+static int bma2x2_get_low_g_duration(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_LOW_DURN_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_LOWG_DUR);
+	*status = data;
+
+	return comres;
+}
+
+static int bma2x2_set_low_g_threshold(struct i2c_client *client, unsigned char
+		threshold)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_LOWG_THRES__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_LOWG_THRES, threshold);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_LOWG_THRES__REG, &data);
+
+	return comres;
+}
+
+static int bma2x2_get_low_g_threshold(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_LOW_THRES_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_LOWG_THRES);
+	*status = data;
+
+	return comres;
+}
+
+static int bma2x2_set_high_g_duration(struct i2c_client *client, unsigned char
+		duration)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_HIGHG_DUR__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_HIGHG_DUR, duration);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_HIGHG_DUR__REG, &data);
+
+	return comres;
+}
+
+static int bma2x2_get_high_g_duration(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_HIGH_DURN_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_HIGHG_DUR);
+	*status = data;
+
+	return comres;
+}
+
+static int bma2x2_set_high_g_threshold(struct i2c_client *client, unsigned char
+		threshold)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_HIGHG_THRES__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_HIGHG_THRES, threshold);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_HIGHG_THRES__REG,
+			&data);
+
+	return comres;
+}
+
+static int bma2x2_get_high_g_threshold(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_HIGH_THRES_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_HIGHG_THRES);
+	*status = data;
+
+	return comres;
+}
+
+
+static int bma2x2_set_tap_duration(struct i2c_client *client, unsigned char
+		duration)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_TAP_DUR__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_TAP_DUR, duration);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_TAP_DUR__REG, &data);
+
+	return comres;
+}
+
+static int bma2x2_get_tap_duration(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_TAP_PARAM_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_TAP_DUR);
+	*status = data;
+
+	return comres;
+}
+
+static int bma2x2_set_tap_shock(struct i2c_client *client, unsigned char setval)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_TAP_SHOCK_DURN__REG,
+			&data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_TAP_SHOCK_DURN, setval);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_TAP_SHOCK_DURN__REG,
+			&data);
+
+	return comres;
+}
+
+static int bma2x2_get_tap_shock(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_TAP_PARAM_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_TAP_SHOCK_DURN);
+	*status = data;
+
+	return comres;
+}
+
+static int bma2x2_set_tap_quiet(struct i2c_client *client, unsigned char
+		duration)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_TAP_QUIET_DURN__REG,
+			&data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_TAP_QUIET_DURN, duration);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_TAP_QUIET_DURN__REG,
+			&data);
+
+	return comres;
+}
+
+static int bma2x2_get_tap_quiet(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_TAP_PARAM_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_TAP_QUIET_DURN);
+	*status = data;
+
+	return comres;
+}
+
+static int bma2x2_set_tap_threshold(struct i2c_client *client, unsigned char
+		threshold)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_TAP_THRES__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_TAP_THRES, threshold);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_TAP_THRES__REG, &data);
+
+	return comres;
+}
+
+static int bma2x2_get_tap_threshold(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_TAP_THRES_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_TAP_THRES);
+	*status = data;
+
+	return comres;
+}
+
+static int bma2x2_set_tap_samp(struct i2c_client *client, unsigned char samp)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_TAP_SAMPLES__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_TAP_SAMPLES, samp);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_TAP_SAMPLES__REG,
+			&data);
+
+	return comres;
+}
+
+static int bma2x2_get_tap_samp(struct i2c_client *client, unsigned char *status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_TAP_THRES_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_TAP_SAMPLES);
+	*status = data;
+
+	return comres;
+}
+
+static int bma2x2_set_orient_mode(struct i2c_client *client, unsigned char mode)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_ORIENT_MODE__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_ORIENT_MODE, mode);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_ORIENT_MODE__REG,
+			&data);
+
+	return comres;
+}
+
+static int bma2x2_get_orient_mode(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_ORIENT_PARAM_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_ORIENT_MODE);
+	*status = data;
+
+	return comres;
+}
+
+static int bma2x2_set_orient_blocking(struct i2c_client *client, unsigned char
+		samp)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_ORIENT_BLOCK__REG,
+			&data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_ORIENT_BLOCK, samp);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_ORIENT_BLOCK__REG,
+			&data);
+
+	return comres;
+}
+
+static int bma2x2_get_orient_blocking(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_ORIENT_PARAM_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_ORIENT_BLOCK);
+	*status = data;
+
+	return comres;
+}
+
+static int bma2x2_set_orient_hyst(struct i2c_client *client, unsigned char
+		orienthyst)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_ORIENT_HYST__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_ORIENT_HYST, orienthyst);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_ORIENT_HYST__REG,
+			&data);
+
+	return comres;
+}
+
+static int bma2x2_get_orient_hyst(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_ORIENT_PARAM_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_ORIENT_HYST);
+	*status = data;
+
+	return comres;
+}
+static int bma2x2_set_theta_blocking(struct i2c_client *client, unsigned char
+		thetablk)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_THETA_BLOCK__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_THETA_BLOCK, thetablk);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_THETA_BLOCK__REG,
+			&data);
+
+	return comres;
+}
+
+static int bma2x2_get_theta_blocking(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_THETA_BLOCK_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_THETA_BLOCK);
+	*status = data;
+
+	return comres;
+}
+
+static int bma2x2_set_theta_flat(struct i2c_client *client, unsigned char
+		thetaflat)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_THETA_FLAT__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_THETA_FLAT, thetaflat);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_THETA_FLAT__REG, &data);
+
+	return comres;
+}
+
+static int bma2x2_get_theta_flat(struct i2c_client *client, unsigned char
+		*status)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_THETA_FLAT_REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_THETA_FLAT);
+	*status = data;
+
+	return comres;
+}
+
+static int bma2x2_set_flat_hold_time(struct i2c_client *client, unsigned char
+		holdtime)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_FLAT_HOLD_TIME__REG,
+			&data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_FLAT_HOLD_TIME, holdtime);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_FLAT_HOLD_TIME__REG,
+			&data);
+
+	return comres;
+}
+
+static int bma2x2_get_flat_hold_time(struct i2c_client *client, unsigned char
+		*holdtime)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_FLAT_HOLD_TIME_REG,
+			&data);
+	data  = BMA2X2_GET_BITSLICE(data, BMA2X2_FLAT_HOLD_TIME);
+	*holdtime = data;
+
+	return comres;
+}
+
+/*!
+ * brief: bma2x2 switch from normal to suspend mode
+ * @param[i] bma2x2
+ * @param[i] data1, write to PMU_LPW
+ * @param[i] data2, write to PMU_LOW_NOSIE
+ *
+ * @return zero success, none-zero failed
+ */
+static int bma2x2_normal_to_suspend(struct bma2x2_data *bma2x2,
+				unsigned char data1, unsigned char data2)
+{
+	unsigned char current_fifo_mode;
+	unsigned char current_op_mode;
+	if (bma2x2 == NULL)
+		return -1;
+	/* get current op mode from mode register */
+	if (bma2x2_get_mode(bma2x2->bma2x2_client, &current_op_mode) < 0)
+		return -1;
+	/* only aimed at operatiom mode chang from normal/lpw1 mode
+	 * to suspend state.
+	*/
+	if (current_op_mode == BMA2X2_MODE_NORMAL ||
+			current_op_mode == BMA2X2_MODE_LOWPOWER1) {
+		/* get current fifo mode from fifo config register */
+		if (bma2x2_get_fifo_mode(bma2x2->bma2x2_client,
+							&current_fifo_mode) < 0)
+			return -1;
+		else {
+			bma2x2_smbus_write_byte(bma2x2->bma2x2_client,
+					BMA2X2_LOW_NOISE_CTRL_REG, &data2);
+			bma2x2_smbus_write_byte(bma2x2->bma2x2_client,
+					BMA2X2_MODE_CTRL_REG, &data1);
+			bma2x2_smbus_write_byte(bma2x2->bma2x2_client,
+				BMA2X2_FIFO_MODE__REG, &current_fifo_mode);
+			mdelay(3);
+			return 0;
+		}
+	} else {
+		bma2x2_smbus_write_byte(bma2x2->bma2x2_client,
+					BMA2X2_LOW_NOISE_CTRL_REG, &data2);
+		bma2x2_smbus_write_byte(bma2x2->bma2x2_client,
+					BMA2X2_MODE_CTRL_REG, &data1);
+		mdelay(3);
+		return 0;
+	}
+
+}
+
+static int bma2x2_set_mode(struct i2c_client *client, unsigned char mode,
+						unsigned char enabled_mode)
+{
+	int comres = 0;
+	unsigned char data1 = 0;
+	unsigned char data2 = 0;
+	int ret = 0;
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	mutex_lock(&bma2x2->mode_mutex);
+	if (BMA2X2_MODE_SUSPEND == mode) {
+		if (enabled_mode != BMA_ENABLED_ALL) {
+			if ((bma2x2->bma_mode_enabled &
+						(1<<enabled_mode)) == 0) {
+				/* sensor is already closed in this mode */
+				mutex_unlock(&bma2x2->mode_mutex);
+				return 0;
+			} else {
+				bma2x2->bma_mode_enabled &= ~(1<<enabled_mode);
+			}
+		} else {
+			/* shut down, close all and force do it*/
+			bma2x2->bma_mode_enabled = 0;
+		}
+	} else if (BMA2X2_MODE_NORMAL == mode) {
+		if ((bma2x2->bma_mode_enabled & (1<<enabled_mode)) != 0) {
+			/* sensor is already enabled in this mode */
+			mutex_unlock(&bma2x2->mode_mutex);
+			return 0;
+		} else {
+			bma2x2->bma_mode_enabled |= (1<<enabled_mode);
+		}
+	} else {
+		/* other mode, close all and force do it*/
+		bma2x2->bma_mode_enabled = 0;
+	}
+	mutex_unlock(&bma2x2->mode_mutex);
+
+	if (mode < 6) {
+		comres = bma2x2_smbus_read_byte(client, BMA2X2_MODE_CTRL_REG,
+				&data1);
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_LOW_NOISE_CTRL_REG,
+				&data2);
+		switch (mode) {
+		case BMA2X2_MODE_NORMAL:
+				data1  = BMA2X2_SET_BITSLICE(data1,
+						BMA2X2_MODE_CTRL, 0);
+				data2  = BMA2X2_SET_BITSLICE(data2,
+						BMA2X2_LOW_POWER_MODE, 0);
+				bma2x2_smbus_write_byte(client,
+						BMA2X2_MODE_CTRL_REG, &data1);
+				mdelay(3);
+				bma2x2_smbus_write_byte(client,
+					BMA2X2_LOW_NOISE_CTRL_REG, &data2);
+				break;
+		case BMA2X2_MODE_LOWPOWER1:
+				data1  = BMA2X2_SET_BITSLICE(data1,
+						BMA2X2_MODE_CTRL, 2);
+				data2  = BMA2X2_SET_BITSLICE(data2,
+						BMA2X2_LOW_POWER_MODE, 0);
+				bma2x2_smbus_write_byte(client,
+						BMA2X2_MODE_CTRL_REG, &data1);
+				mdelay(3);
+				bma2x2_smbus_write_byte(client,
+					BMA2X2_LOW_NOISE_CTRL_REG, &data2);
+				break;
+		case BMA2X2_MODE_SUSPEND:
+			if (bma2x2->bma_mode_enabled != 0) {
+				PERR("bma still working");
+				return 0;
+			}
+			data1  = BMA2X2_SET_BITSLICE(data1,
+					BMA2X2_MODE_CTRL, 4);
+			data2  = BMA2X2_SET_BITSLICE(data2,
+					BMA2X2_LOW_POWER_MODE, 0);
+			/*aimed at anomaly resolution when switch to suspend*/
+			ret = bma2x2_normal_to_suspend(bma2x2, data1, data2);
+			if (ret < 0)
+				PERR("Error switching to suspend");
+			break;
+		case BMA2X2_MODE_DEEP_SUSPEND:
+			if (bma2x2->bma_mode_enabled != 0) {
+				PERR("bma still working");
+				return 0;
+			}
+			data1  = BMA2X2_SET_BITSLICE(data1,
+				BMA2X2_MODE_CTRL, 1);
+			data2  = BMA2X2_SET_BITSLICE(data2,
+				BMA2X2_LOW_POWER_MODE, 1);
+			bma2x2_smbus_write_byte(client,
+				BMA2X2_MODE_CTRL_REG, &data1);
+			mdelay(3);
+			bma2x2_smbus_write_byte(client,
+				BMA2X2_LOW_NOISE_CTRL_REG, &data2);
+			break;
+		case BMA2X2_MODE_LOWPOWER2:
+				data1  = BMA2X2_SET_BITSLICE(data1,
+						BMA2X2_MODE_CTRL, 2);
+				data2  = BMA2X2_SET_BITSLICE(data2,
+						BMA2X2_LOW_POWER_MODE, 1);
+				bma2x2_smbus_write_byte(client,
+						BMA2X2_MODE_CTRL_REG, &data1);
+				mdelay(3);
+				bma2x2_smbus_write_byte(client,
+					BMA2X2_LOW_NOISE_CTRL_REG, &data2);
+				break;
+		case BMA2X2_MODE_STANDBY:
+				data1  = BMA2X2_SET_BITSLICE(data1,
+						BMA2X2_MODE_CTRL, 4);
+				data2  = BMA2X2_SET_BITSLICE(data2,
+						BMA2X2_LOW_POWER_MODE, 1);
+				bma2x2_smbus_write_byte(client,
+					BMA2X2_LOW_NOISE_CTRL_REG, &data2);
+				mdelay(3);
+				bma2x2_smbus_write_byte(client,
+						BMA2X2_MODE_CTRL_REG, &data1);
+				break;
+		}
+	} else {
+		comres = -1;
+	}
+
+	return comres;
+}
+
+
+static int bma2x2_get_mode(struct i2c_client *client, unsigned char *mode)
+{
+	int comres = 0;
+	unsigned char data1 = 0;
+	unsigned char data2 = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_MODE_CTRL_REG, &data1);
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_LOW_NOISE_CTRL_REG,
+			&data2);
+
+	data1  = (data1 & 0xE0) >> 5;
+	data2  = (data2 & 0x40) >> 6;
+
+
+	if ((data1 == 0x00) && (data2 == 0x00)) {
+		*mode  = BMA2X2_MODE_NORMAL;
+	} else {
+		if ((data1 == 0x02) && (data2 == 0x00)) {
+			*mode  = BMA2X2_MODE_LOWPOWER1;
+		} else {
+			if ((data1 == 0x04 || data1 == 0x06) &&
+						(data2 == 0x00)) {
+				*mode  = BMA2X2_MODE_SUSPEND;
+			} else {
+				if (((data1 & 0x01) == 0x01)) {
+					*mode  = BMA2X2_MODE_DEEP_SUSPEND;
+				} else {
+					if ((data1 == 0x02) &&
+							(data2 == 0x01)) {
+						*mode  = BMA2X2_MODE_LOWPOWER2;
+					} else {
+						if ((data1 == 0x04) && (data2 ==
+									0x01)) {
+							*mode  =
+							BMA2X2_MODE_STANDBY;
+						} else {
+							*mode =
+						BMA2X2_MODE_DEEP_SUSPEND;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return comres;
+}
+
+static int bma2x2_set_range(struct i2c_client *client, unsigned char Range)
+{
+	int comres = 0;
+	unsigned char data1 = 0;
+
+	if ((Range == 3) || (Range == 5) || (Range == 8) || (Range == 12)) {
+		comres = bma2x2_smbus_read_byte(client, BMA2X2_RANGE_SEL_REG,
+				&data1);
+		switch (Range) {
+		case BMA2X2_RANGE_2G:
+			data1  = BMA2X2_SET_BITSLICE(data1,
+					BMA2X2_RANGE_SEL, 3);
+			break;
+		case BMA2X2_RANGE_4G:
+			data1  = BMA2X2_SET_BITSLICE(data1,
+					BMA2X2_RANGE_SEL, 5);
+			break;
+		case BMA2X2_RANGE_8G:
+			data1  = BMA2X2_SET_BITSLICE(data1,
+					BMA2X2_RANGE_SEL, 8);
+			break;
+		case BMA2X2_RANGE_16G:
+			data1  = BMA2X2_SET_BITSLICE(data1,
+					BMA2X2_RANGE_SEL, 12);
+			break;
+		default:
+			break;
+		}
+		comres += bma2x2_smbus_write_byte(client, BMA2X2_RANGE_SEL_REG,
+				&data1);
+	} else {
+		comres = -1;
+	}
+
+	return comres;
+}
+
+static int bma2x2_get_range(struct i2c_client *client, unsigned char *Range)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_RANGE_SEL__REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_RANGE_SEL);
+	*Range = data;
+
+	return comres;
+}
+
+
+static int bma2x2_set_bandwidth(struct i2c_client *client, unsigned char BW)
+{
+	int comres = 0;
+	unsigned char data = 0;
+	int Bandwidth = 0;
+
+	if (BW > 7 && BW < 16) {
+		switch (BW) {
+		case BMA2X2_BW_7_81HZ:
+			Bandwidth = BMA2X2_BW_7_81HZ;
+
+			/*  7.81 Hz      64000 uS   */
+			break;
+		case BMA2X2_BW_15_63HZ:
+			Bandwidth = BMA2X2_BW_15_63HZ;
+
+			/*  15.63 Hz     32000 uS   */
+			break;
+		case BMA2X2_BW_31_25HZ:
+			Bandwidth = BMA2X2_BW_31_25HZ;
+
+			/*  31.25 Hz     16000 uS   */
+			break;
+		case BMA2X2_BW_62_50HZ:
+			Bandwidth = BMA2X2_BW_62_50HZ;
+
+			/*  62.50 Hz     8000 uS   */
+			break;
+		case BMA2X2_BW_125HZ:
+			Bandwidth = BMA2X2_BW_125HZ;
+
+			/*  125 Hz       4000 uS   */
+			break;
+		case BMA2X2_BW_250HZ:
+			Bandwidth = BMA2X2_BW_250HZ;
+
+			/*  250 Hz       2000 uS   */
+			break;
+		case BMA2X2_BW_500HZ:
+			Bandwidth = BMA2X2_BW_500HZ;
+
+			/*  500 Hz       1000 uS   */
+			break;
+		case BMA2X2_BW_1000HZ:
+			Bandwidth = BMA2X2_BW_1000HZ;
+
+			/*  1000 Hz      500 uS   */
+			break;
+		default:
+			break;
+		}
+		comres = bma2x2_smbus_read_byte(client, BMA2X2_BANDWIDTH__REG,
+				&data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_BANDWIDTH, Bandwidth);
+		comres += bma2x2_smbus_write_byte(client, BMA2X2_BANDWIDTH__REG,
+				&data);
+	} else {
+		comres = -1;
+	}
+
+	return comres;
+}
+
+static int bma2x2_get_bandwidth(struct i2c_client *client, unsigned char *BW)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_BANDWIDTH__REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_BANDWIDTH);
+	*BW = data;
+
+	return comres;
+}
+
+int bma2x2_get_sleep_duration(struct i2c_client *client, unsigned char
+		*sleep_dur)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_SLEEP_DUR__REG, &data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_SLEEP_DUR);
+	*sleep_dur = data;
+
+	return comres;
+}
+
+int bma2x2_set_sleep_duration(struct i2c_client *client, unsigned char
+		sleep_dur)
+{
+	int comres = 0;
+	unsigned char data = 0;
+	int sleep_duration = 0;
+
+	if (sleep_dur > 4 && sleep_dur < 16) {
+		switch (sleep_dur) {
+		case BMA2X2_SLEEP_DUR_0_5MS:
+			sleep_duration = BMA2X2_SLEEP_DUR_0_5MS;
+
+			/*  0.5 MS   */
+			break;
+		case BMA2X2_SLEEP_DUR_1MS:
+			sleep_duration = BMA2X2_SLEEP_DUR_1MS;
+
+			/*  1 MS  */
+			break;
+		case BMA2X2_SLEEP_DUR_2MS:
+			sleep_duration = BMA2X2_SLEEP_DUR_2MS;
+
+			/*  2 MS  */
+			break;
+		case BMA2X2_SLEEP_DUR_4MS:
+			sleep_duration = BMA2X2_SLEEP_DUR_4MS;
+
+			/*  4 MS   */
+			break;
+		case BMA2X2_SLEEP_DUR_6MS:
+			sleep_duration = BMA2X2_SLEEP_DUR_6MS;
+
+			/*  6 MS  */
+			break;
+		case BMA2X2_SLEEP_DUR_10MS:
+			sleep_duration = BMA2X2_SLEEP_DUR_10MS;
+
+			/*  10 MS  */
+			break;
+		case BMA2X2_SLEEP_DUR_25MS:
+			sleep_duration = BMA2X2_SLEEP_DUR_25MS;
+
+			/*  25 MS  */
+			break;
+		case BMA2X2_SLEEP_DUR_50MS:
+			sleep_duration = BMA2X2_SLEEP_DUR_50MS;
+
+			/*  50 MS   */
+			break;
+		case BMA2X2_SLEEP_DUR_100MS:
+			sleep_duration = BMA2X2_SLEEP_DUR_100MS;
+
+			/*  100 MS  */
+			break;
+		case BMA2X2_SLEEP_DUR_500MS:
+			sleep_duration = BMA2X2_SLEEP_DUR_500MS;
+
+			/*  500 MS   */
+			break;
+		case BMA2X2_SLEEP_DUR_1S:
+			sleep_duration = BMA2X2_SLEEP_DUR_1S;
+
+			/*  1 SECS   */
+			break;
+		default:
+			break;
+		}
+		comres = bma2x2_smbus_read_byte(client, BMA2X2_SLEEP_DUR__REG,
+				&data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_SLEEP_DUR,
+				sleep_duration);
+		comres = bma2x2_smbus_write_byte(client, BMA2X2_SLEEP_DUR__REG,
+				&data);
+	} else {
+		comres = -1;
+	}
+
+
+	return comres;
+}
+
+static int bma2x2_get_fifo_mode(struct i2c_client *client, unsigned char
+		*fifo_mode)
+{
+	int comres;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_FIFO_MODE__REG, &data);
+	*fifo_mode = BMA2X2_GET_BITSLICE(data, BMA2X2_FIFO_MODE);
+
+	return comres;
+}
+
+static int bma2x2_set_fifo_mode(struct i2c_client *client, unsigned char
+		fifo_mode)
+{
+	unsigned char data = 0;
+	int comres = 0;
+
+	if (fifo_mode < 4) {
+		comres = bma2x2_smbus_read_byte(client, BMA2X2_FIFO_MODE__REG,
+				&data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_FIFO_MODE, fifo_mode);
+		comres = bma2x2_smbus_write_byte(client, BMA2X2_FIFO_MODE__REG,
+				&data);
+	} else {
+		comres = -1;
+	}
+
+	return comres;
+}
+
+static int bma2x2_get_fifo_trig(struct i2c_client *client, unsigned char
+		*fifo_trig)
+{
+	int comres;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_FIFO_TRIGGER_ACTION__REG, &data);
+	*fifo_trig = BMA2X2_GET_BITSLICE(data, BMA2X2_FIFO_TRIGGER_ACTION);
+
+	return comres;
+}
+
+static int bma2x2_set_fifo_trig(struct i2c_client *client, unsigned char
+		fifo_trig)
+{
+	unsigned char data = 0;
+	int comres = 0;
+
+	if (fifo_trig < 4) {
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_FIFO_TRIGGER_ACTION__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_FIFO_TRIGGER_ACTION,
+				fifo_trig);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_FIFO_TRIGGER_ACTION__REG, &data);
+	} else {
+		comres = -1;
+	}
+
+	return comres;
+}
+
+static int bma2x2_get_fifo_trig_src(struct i2c_client *client, unsigned char
+		*trig_src)
+{
+	int comres;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_FIFO_TRIGGER_SOURCE__REG, &data);
+	*trig_src = BMA2X2_GET_BITSLICE(data, BMA2X2_FIFO_TRIGGER_SOURCE);
+
+	return comres;
+}
+
+static int bma2x2_set_fifo_trig_src(struct i2c_client *client, unsigned char
+		trig_src)
+{
+	unsigned char data = 0;
+	int comres = 0;
+
+	if (trig_src < 4) {
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_FIFO_TRIGGER_SOURCE__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_FIFO_TRIGGER_SOURCE,
+				trig_src);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_FIFO_TRIGGER_SOURCE__REG, &data);
+	} else {
+		comres = -1;
+	}
+
+	return comres;
+}
+
+static int bma2x2_get_fifo_framecount(struct i2c_client *client, unsigned char
+			 *framecount)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_FIFO_FRAME_COUNTER_S__REG, &data);
+	*framecount = BMA2X2_GET_BITSLICE(data, BMA2X2_FIFO_FRAME_COUNTER_S);
+
+	return comres;
+}
+
+static int bma2x2_get_fifo_data_sel(struct i2c_client *client, unsigned char
+		*data_sel)
+{
+	int comres;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_FIFO_DATA_SELECT__REG, &data);
+	*data_sel = BMA2X2_GET_BITSLICE(data, BMA2X2_FIFO_DATA_SELECT);
+
+	return comres;
+}
+
+static int bma2x2_set_fifo_data_sel(struct i2c_client *client, unsigned char
+		data_sel)
+{
+	unsigned char data = 0;
+	int comres = 0;
+
+	if (data_sel < 4) {
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_FIFO_DATA_SELECT__REG,
+				&data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_FIFO_DATA_SELECT,
+				data_sel);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_FIFO_DATA_SELECT__REG,
+				&data);
+	} else {
+		comres = -1;
+	}
+
+	return comres;
+}
+
+
+static int bma2x2_get_offset_target(struct i2c_client *client, unsigned char
+		channel, unsigned char *offset)
+{
+	unsigned char data = 0;
+	int comres = 0;
+
+	switch (channel) {
+	case BMA2X2_CUT_OFF:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_COMP_CUTOFF__REG, &data);
+		*offset = BMA2X2_GET_BITSLICE(data, BMA2X2_COMP_CUTOFF);
+		break;
+	case BMA2X2_OFFSET_TRIGGER_X:
+		comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_COMP_TARGET_OFFSET_X__REG, &data);
+		*offset = BMA2X2_GET_BITSLICE(data,
+				BMA2X2_COMP_TARGET_OFFSET_X);
+		break;
+	case BMA2X2_OFFSET_TRIGGER_Y:
+		comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_COMP_TARGET_OFFSET_Y__REG, &data);
+		*offset = BMA2X2_GET_BITSLICE(data,
+				BMA2X2_COMP_TARGET_OFFSET_Y);
+		break;
+	case BMA2X2_OFFSET_TRIGGER_Z:
+		comres = bma2x2_smbus_read_byte(client,
+			BMA2X2_COMP_TARGET_OFFSET_Z__REG, &data);
+		*offset = BMA2X2_GET_BITSLICE(data,
+				BMA2X2_COMP_TARGET_OFFSET_Z);
+		break;
+	default:
+		comres = -1;
+		break;
+	}
+
+	return comres;
+}
+
+static int bma2x2_set_offset_target(struct i2c_client *client, unsigned char
+		channel, unsigned char offset)
+{
+	unsigned char data = 0;
+	int comres = 0;
+
+	switch (channel) {
+	case BMA2X2_CUT_OFF:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_COMP_CUTOFF__REG, &data);
+		data = BMA2X2_SET_BITSLICE(data, BMA2X2_COMP_CUTOFF,
+				offset);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_COMP_CUTOFF__REG, &data);
+		break;
+	case BMA2X2_OFFSET_TRIGGER_X:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_COMP_TARGET_OFFSET_X__REG,
+				&data);
+		data = BMA2X2_SET_BITSLICE(data,
+				BMA2X2_COMP_TARGET_OFFSET_X,
+				offset);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_COMP_TARGET_OFFSET_X__REG,
+				&data);
+		break;
+	case BMA2X2_OFFSET_TRIGGER_Y:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_COMP_TARGET_OFFSET_Y__REG,
+				&data);
+		data = BMA2X2_SET_BITSLICE(data,
+				BMA2X2_COMP_TARGET_OFFSET_Y,
+				offset);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_COMP_TARGET_OFFSET_Y__REG,
+				&data);
+		break;
+	case BMA2X2_OFFSET_TRIGGER_Z:
+		comres = bma2x2_smbus_read_byte(client,
+				BMA2X2_COMP_TARGET_OFFSET_Z__REG,
+				&data);
+		data = BMA2X2_SET_BITSLICE(data,
+				BMA2X2_COMP_TARGET_OFFSET_Z,
+				offset);
+		comres = bma2x2_smbus_write_byte(client,
+				BMA2X2_COMP_TARGET_OFFSET_Z__REG,
+				&data);
+		break;
+	default:
+		comres = -1;
+		break;
+	}
+
+	return comres;
+}
+
+static int bma2x2_get_cal_ready(struct i2c_client *client,
+					unsigned char *calrdy)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_FAST_CAL_RDY_S__REG,
+			&data);
+	data = BMA2X2_GET_BITSLICE(data, BMA2X2_FAST_CAL_RDY_S);
+	*calrdy = data;
+
+	return comres;
+}
+
+static int bma2x2_set_cal_trigger(struct i2c_client *client, unsigned char
+		caltrigger)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_CAL_TRIGGER__REG, &data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_CAL_TRIGGER, caltrigger);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_CAL_TRIGGER__REG,
+			&data);
+
+	return comres;
+}
+
+static int bma2x2_write_reg(struct i2c_client *client, unsigned char addr,
+		unsigned char *data)
+{
+	int comres = 0;
+	comres = bma2x2_smbus_write_byte(client, addr, data);
+
+	return comres;
+}
+
+
+static int bma2x2_set_offset_x(struct i2c_client *client, unsigned char
+		offsetfilt)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	data =  offsetfilt;
+
+#ifdef CONFIG_SENSORS_BMI058
+	comres = bma2x2_smbus_write_byte(client, BMI058_OFFSET_X_AXIS_REG,
+							&data);
+#else
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_OFFSET_X_AXIS_REG,
+						&data);
+#endif
+
+	return comres;
+}
+
+
+static int bma2x2_get_offset_x(struct i2c_client *client, unsigned char
+						*offsetfilt)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+#ifdef CONFIG_SENSORS_BMI058
+	comres = bma2x2_smbus_read_byte(client, BMI058_OFFSET_X_AXIS_REG,
+							&data);
+#else
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_OFFSET_X_AXIS_REG,
+							&data);
+#endif
+	*offsetfilt = data;
+
+	return comres;
+}
+
+static int bma2x2_set_offset_y(struct i2c_client *client, unsigned char
+						offsetfilt)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	data =  offsetfilt;
+
+#ifdef CONFIG_SENSORS_BMI058
+	comres = bma2x2_smbus_write_byte(client, BMI058_OFFSET_Y_AXIS_REG,
+							&data);
+#else
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_OFFSET_Y_AXIS_REG,
+							&data);
+#endif
+	return comres;
+}
+
+static int bma2x2_get_offset_y(struct i2c_client *client, unsigned char
+						*offsetfilt)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+#ifdef CONFIG_SENSORS_BMI058
+	comres = bma2x2_smbus_read_byte(client, BMI058_OFFSET_Y_AXIS_REG,
+							&data);
+#else
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_OFFSET_Y_AXIS_REG,
+							&data);
+#endif
+	*offsetfilt = data;
+
+	return comres;
+}
+
+static int bma2x2_set_offset_z(struct i2c_client *client, unsigned char
+						offsetfilt)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	data =  offsetfilt;
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_OFFSET_Z_AXIS_REG,
+						&data);
+
+	return comres;
+}
+
+static int bma2x2_get_offset_z(struct i2c_client *client, unsigned char
+						*offsetfilt)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_OFFSET_Z_AXIS_REG,
+						&data);
+	*offsetfilt = data;
+
+	return comres;
+}
+
+
+static int bma2x2_set_selftest_st(struct i2c_client *client, unsigned char
+		selftest)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_EN_SELF_TEST__REG,
+			&data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_EN_SELF_TEST, selftest);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_EN_SELF_TEST__REG,
+			&data);
+
+	return comres;
+}
+
+static int bma2x2_set_selftest_stn(struct i2c_client *client, unsigned char stn)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_NEG_SELF_TEST__REG,
+			&data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_NEG_SELF_TEST, stn);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_NEG_SELF_TEST__REG,
+			&data);
+
+	return comres;
+}
+
+static int bma2x2_set_selftest_amp(struct i2c_client *client, unsigned char amp)
+{
+	int comres = 0;
+	unsigned char data = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_SELF_TEST_AMP__REG,
+			&data);
+	data = BMA2X2_SET_BITSLICE(data, BMA2X2_SELF_TEST_AMP, amp);
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_SELF_TEST_AMP__REG,
+			&data);
+
+	return comres;
+}
+
+static int bma2x2_read_accel_x(struct i2c_client *client,
+				signed char sensor_type, short *a_x)
+{
+	int comres = 0;
+	unsigned char data[2];
+
+	switch (sensor_type) {
+	case 0:
+		comres = bma2x2_smbus_read_byte_block(client,
+					BMA2X2_ACC_X12_LSB__REG, data, 2);
+		*a_x = BMA2X2_GET_BITSLICE(data[0], BMA2X2_ACC_X12_LSB)|
+			(BMA2X2_GET_BITSLICE(data[1],
+				BMA2X2_ACC_X_MSB)<<(BMA2X2_ACC_X12_LSB__LEN));
+		*a_x = *a_x << (sizeof(short)*8-(BMA2X2_ACC_X12_LSB__LEN
+					+ BMA2X2_ACC_X_MSB__LEN));
+		*a_x = *a_x >> (sizeof(short)*8-(BMA2X2_ACC_X12_LSB__LEN
+					+ BMA2X2_ACC_X_MSB__LEN));
+		break;
+	case 1:
+		comres = bma2x2_smbus_read_byte_block(client,
+					BMA2X2_ACC_X10_LSB__REG, data, 2);
+		*a_x = BMA2X2_GET_BITSLICE(data[0], BMA2X2_ACC_X10_LSB)|
+			(BMA2X2_GET_BITSLICE(data[1],
+				BMA2X2_ACC_X_MSB)<<(BMA2X2_ACC_X10_LSB__LEN));
+		*a_x = *a_x << (sizeof(short)*8-(BMA2X2_ACC_X10_LSB__LEN
+					+ BMA2X2_ACC_X_MSB__LEN));
+		*a_x = *a_x >> (sizeof(short)*8-(BMA2X2_ACC_X10_LSB__LEN
+					+ BMA2X2_ACC_X_MSB__LEN));
+		break;
+	case 2:
+		comres = bma2x2_smbus_read_byte_block(client,
+					BMA2X2_ACC_X8_LSB__REG, data, 2);
+		*a_x = BMA2X2_GET_BITSLICE(data[0], BMA2X2_ACC_X8_LSB)|
+			(BMA2X2_GET_BITSLICE(data[1],
+				BMA2X2_ACC_X_MSB)<<(BMA2X2_ACC_X8_LSB__LEN));
+		*a_x = *a_x << (sizeof(short)*8-(BMA2X2_ACC_X8_LSB__LEN
+					+ BMA2X2_ACC_X_MSB__LEN));
+		*a_x = *a_x >> (sizeof(short)*8-(BMA2X2_ACC_X8_LSB__LEN
+					+ BMA2X2_ACC_X_MSB__LEN));
+		break;
+	case 3:
+		comres = bma2x2_smbus_read_byte_block(client,
+					BMA2X2_ACC_X14_LSB__REG, data, 2);
+		*a_x = BMA2X2_GET_BITSLICE(data[0], BMA2X2_ACC_X14_LSB)|
+			(BMA2X2_GET_BITSLICE(data[1],
+				BMA2X2_ACC_X_MSB)<<(BMA2X2_ACC_X14_LSB__LEN));
+		*a_x = *a_x << (sizeof(short)*8-(BMA2X2_ACC_X14_LSB__LEN
+					+ BMA2X2_ACC_X_MSB__LEN));
+		*a_x = *a_x >> (sizeof(short)*8-(BMA2X2_ACC_X14_LSB__LEN
+					+ BMA2X2_ACC_X_MSB__LEN));
+		break;
+	default:
+		break;
+	}
+
+	return comres;
+}
+
+static int bma2x2_soft_reset(struct i2c_client *client)
+{
+	int comres = 0;
+	unsigned char data = BMA2X2_EN_SOFT_RESET_VALUE;
+
+	comres = bma2x2_smbus_write_byte(client, BMA2X2_EN_SOFT_RESET__REG,
+					&data);
+
+	return comres;
+}
+
+static int bma2x2_read_accel_y(struct i2c_client *client,
+				signed char sensor_type, short *a_y)
+{
+	int comres = 0;
+	unsigned char data[2];
+
+	switch (sensor_type) {
+	case 0:
+		comres = bma2x2_smbus_read_byte_block(client,
+				BMA2X2_ACC_Y12_LSB__REG, data, 2);
+		*a_y = BMA2X2_GET_BITSLICE(data[0], BMA2X2_ACC_Y12_LSB)|
+			(BMA2X2_GET_BITSLICE(data[1],
+				BMA2X2_ACC_Y_MSB)<<(BMA2X2_ACC_Y12_LSB__LEN));
+		*a_y = *a_y << (sizeof(short)*8-(BMA2X2_ACC_Y12_LSB__LEN
+						+ BMA2X2_ACC_Y_MSB__LEN));
+		*a_y = *a_y >> (sizeof(short)*8-(BMA2X2_ACC_Y12_LSB__LEN
+						+ BMA2X2_ACC_Y_MSB__LEN));
+		break;
+	case 1:
+		comres = bma2x2_smbus_read_byte_block(client,
+				BMA2X2_ACC_Y10_LSB__REG, data, 2);
+		*a_y = BMA2X2_GET_BITSLICE(data[0], BMA2X2_ACC_Y10_LSB)|
+			(BMA2X2_GET_BITSLICE(data[1],
+				BMA2X2_ACC_Y_MSB)<<(BMA2X2_ACC_Y10_LSB__LEN));
+		*a_y = *a_y << (sizeof(short)*8-(BMA2X2_ACC_Y10_LSB__LEN
+						+ BMA2X2_ACC_Y_MSB__LEN));
+		*a_y = *a_y >> (sizeof(short)*8-(BMA2X2_ACC_Y10_LSB__LEN
+						+ BMA2X2_ACC_Y_MSB__LEN));
+		break;
+	case 2:
+		comres = bma2x2_smbus_read_byte_block(client,
+				BMA2X2_ACC_Y8_LSB__REG, data, 2);
+		*a_y = BMA2X2_GET_BITSLICE(data[0], BMA2X2_ACC_Y8_LSB)|
+				(BMA2X2_GET_BITSLICE(data[1],
+				BMA2X2_ACC_Y_MSB)<<(BMA2X2_ACC_Y8_LSB__LEN));
+		*a_y = *a_y << (sizeof(short)*8-(BMA2X2_ACC_Y8_LSB__LEN
+						+ BMA2X2_ACC_Y_MSB__LEN));
+		*a_y = *a_y >> (sizeof(short)*8-(BMA2X2_ACC_Y8_LSB__LEN
+						+ BMA2X2_ACC_Y_MSB__LEN));
+		break;
+	case 3:
+		comres = bma2x2_smbus_read_byte_block(client,
+				BMA2X2_ACC_Y14_LSB__REG, data, 2);
+		*a_y = BMA2X2_GET_BITSLICE(data[0], BMA2X2_ACC_Y14_LSB)|
+			(BMA2X2_GET_BITSLICE(data[1],
+				BMA2X2_ACC_Y_MSB)<<(BMA2X2_ACC_Y14_LSB__LEN));
+		*a_y = *a_y << (sizeof(short)*8-(BMA2X2_ACC_Y14_LSB__LEN
+						+ BMA2X2_ACC_Y_MSB__LEN));
+		*a_y = *a_y >> (sizeof(short)*8-(BMA2X2_ACC_Y14_LSB__LEN
+						+ BMA2X2_ACC_Y_MSB__LEN));
+		break;
+	default:
+		break;
+	}
+
+	return comres;
+}
+
+static int bma2x2_read_accel_z(struct i2c_client *client,
+				signed char sensor_type, short *a_z)
+{
+	int comres = 0;
+	unsigned char data[2];
+
+	switch (sensor_type) {
+	case 0:
+		comres = bma2x2_smbus_read_byte_block(client,
+				BMA2X2_ACC_Z12_LSB__REG, data, 2);
+		*a_z = BMA2X2_GET_BITSLICE(data[0], BMA2X2_ACC_Z12_LSB)|
+			(BMA2X2_GET_BITSLICE(data[1],
+				BMA2X2_ACC_Z_MSB)<<(BMA2X2_ACC_Z12_LSB__LEN));
+		*a_z = *a_z << (sizeof(short)*8-(BMA2X2_ACC_Z12_LSB__LEN
+						+ BMA2X2_ACC_Z_MSB__LEN));
+		*a_z = *a_z >> (sizeof(short)*8-(BMA2X2_ACC_Z12_LSB__LEN
+						+ BMA2X2_ACC_Z_MSB__LEN));
+		break;
+	case 1:
+		comres = bma2x2_smbus_read_byte_block(client,
+				BMA2X2_ACC_Z10_LSB__REG, data, 2);
+		*a_z = BMA2X2_GET_BITSLICE(data[0], BMA2X2_ACC_Z10_LSB)|
+			(BMA2X2_GET_BITSLICE(data[1],
+				BMA2X2_ACC_Z_MSB)<<(BMA2X2_ACC_Z10_LSB__LEN));
+		*a_z = *a_z << (sizeof(short)*8-(BMA2X2_ACC_Z10_LSB__LEN
+						+ BMA2X2_ACC_Z_MSB__LEN));
+		*a_z = *a_z >> (sizeof(short)*8-(BMA2X2_ACC_Z10_LSB__LEN
+						+ BMA2X2_ACC_Z_MSB__LEN));
+		break;
+	case 2:
+		comres = bma2x2_smbus_read_byte_block(client,
+				BMA2X2_ACC_Z8_LSB__REG, data, 2);
+		*a_z = BMA2X2_GET_BITSLICE(data[0], BMA2X2_ACC_Z8_LSB)|
+			(BMA2X2_GET_BITSLICE(data[1],
+				BMA2X2_ACC_Z_MSB)<<(BMA2X2_ACC_Z8_LSB__LEN));
+		*a_z = *a_z << (sizeof(short)*8-(BMA2X2_ACC_Z8_LSB__LEN
+						+ BMA2X2_ACC_Z_MSB__LEN));
+		*a_z = *a_z >> (sizeof(short)*8-(BMA2X2_ACC_Z8_LSB__LEN
+						+ BMA2X2_ACC_Z_MSB__LEN));
+		break;
+	case 3:
+		comres = bma2x2_smbus_read_byte_block(client,
+				BMA2X2_ACC_Z14_LSB__REG, data, 2);
+		*a_z = BMA2X2_GET_BITSLICE(data[0], BMA2X2_ACC_Z14_LSB)|
+				(BMA2X2_GET_BITSLICE(data[1],
+				BMA2X2_ACC_Z_MSB)<<(BMA2X2_ACC_Z14_LSB__LEN));
+		*a_z = *a_z << (sizeof(short)*8-(BMA2X2_ACC_Z14_LSB__LEN
+						+ BMA2X2_ACC_Z_MSB__LEN));
+		*a_z = *a_z >> (sizeof(short)*8-(BMA2X2_ACC_Z14_LSB__LEN
+						+ BMA2X2_ACC_Z_MSB__LEN));
+		break;
+	default:
+		break;
+	}
+
+	return comres;
+}
+
+
+static int bma2x2_read_temperature(struct i2c_client *client,
+					signed char *temperature)
+{
+	unsigned char data = 0;
+	int comres = 0;
+
+	comres = bma2x2_smbus_read_byte(client, BMA2X2_TEMPERATURE_REG, &data);
+	*temperature = (signed char)data;
+
+	return comres;
+}
+
+static ssize_t bma2x2_enable_int_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	int type, value;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+#ifdef CONFIG_SENSORS_BMI058
+	int i;
+#endif
+
+	sscanf(buf, "%3d %3d", &type, &value);
+
+#ifdef CONFIG_SENSORS_BMI058
+	for (i = 0; i < sizeof(int_map) / sizeof(struct interrupt_map_t); i++) {
+		if (int_map[i].x == type) {
+			type = int_map[i].y;
+			break;
+		}
+		if (int_map[i].y == type) {
+			type = int_map[i].x;
+			break;
+		}
+	}
+#endif
+
+	if (bma2x2_set_Int_Enable(bma2x2->bma2x2_client, type, value) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+
+static ssize_t bma2x2_int_mode_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_Int_Mode(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+}
+
+static ssize_t bma2x2_int_mode_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_Int_Mode(bma2x2->bma2x2_client, (unsigned char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+static ssize_t bma2x2_slope_duration_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_slope_duration(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_slope_duration_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_slope_duration(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_slope_no_mot_duration_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_slope_no_mot_duration(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_slope_no_mot_duration_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_slope_no_mot_duration(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+
+static ssize_t bma2x2_slope_threshold_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_slope_threshold(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_slope_threshold_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if (bma2x2_set_slope_threshold(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_slope_no_mot_threshold_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_slope_no_mot_threshold(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_slope_no_mot_threshold_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if (bma2x2_set_slope_no_mot_threshold(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_high_g_duration_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_high_g_duration(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_high_g_duration_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_high_g_duration(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_high_g_threshold_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_high_g_threshold(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_high_g_threshold_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if (bma2x2_set_high_g_threshold(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_low_g_duration_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_low_g_duration(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_low_g_duration_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_low_g_duration(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_low_g_threshold_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_low_g_threshold(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_low_g_threshold_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if (bma2x2_set_low_g_threshold(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+static ssize_t bma2x2_tap_threshold_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_tap_threshold(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_tap_threshold_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if (bma2x2_set_tap_threshold(bma2x2->bma2x2_client, (unsigned char)data)
+			< 0)
+		return -EINVAL;
+
+	return count;
+}
+static ssize_t bma2x2_tap_duration_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_tap_duration(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_tap_duration_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_tap_duration(bma2x2->bma2x2_client, (unsigned char)data)
+			< 0)
+		return -EINVAL;
+
+	return count;
+}
+static ssize_t bma2x2_tap_quiet_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_tap_quiet(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_tap_quiet_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_tap_quiet(bma2x2->bma2x2_client, (unsigned char)data) <
+			0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_tap_shock_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_tap_shock(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_tap_shock_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_tap_shock(bma2x2->bma2x2_client, (unsigned char)data) <
+			0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_tap_samp_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_tap_samp(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_tap_samp_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_tap_samp(bma2x2->bma2x2_client, (unsigned char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_orient_mode_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_orient_mode(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_orient_mode_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_orient_mode(bma2x2->bma2x2_client, (unsigned char)data) <
+			0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_orient_blocking_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_orient_blocking(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_orient_blocking_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_orient_blocking(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+static ssize_t bma2x2_orient_hyst_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_orient_hyst(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_orient_hyst_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_orient_hyst(bma2x2->bma2x2_client, (unsigned char)data) <
+			0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_orient_theta_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_theta_blocking(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_orient_theta_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_theta_blocking(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_flat_theta_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_theta_flat(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_flat_theta_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_theta_flat(bma2x2->bma2x2_client, (unsigned char)data) <
+			0)
+		return -EINVAL;
+
+	return count;
+}
+static ssize_t bma2x2_flat_hold_time_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_get_flat_hold_time(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+static ssize_t bma2x2_selftest_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+
+
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	return sprintf(buf, "%d\n", atomic_read(&bma2x2->selftest_result));
+
+}
+
+static ssize_t bma2x2_softreset_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if (bma2x2_soft_reset(bma2x2->bma2x2_client) < 0)
+		return -EINVAL;
+
+	return count;
+}
+static ssize_t bma2x2_selftest_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+
+	unsigned long data;
+	unsigned char clear_value = 0;
+	int error;
+	short value1 = 0;
+	short value2 = 0;
+	short diff = 0;
+	unsigned long result = 0;
+	unsigned char test_result_branch = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	bma2x2_soft_reset(bma2x2->bma2x2_client);
+	mdelay(5);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (data != 1)
+		return -EINVAL;
+
+	bma2x2_write_reg(bma2x2->bma2x2_client, 0x32, &clear_value);
+
+	if ((bma2x2->sensor_type == BMA280_TYPE) ||
+		(bma2x2->sensor_type == BMA255_TYPE)) {
+#ifdef CONFIG_SENSORS_BMI058
+		/*set self test amp */
+		if (bma2x2_set_selftest_amp(bma2x2->bma2x2_client, 1) < 0)
+			return -EINVAL;
+		/* set to 8 G range */
+		if (bma2x2_set_range(bma2x2->bma2x2_client,
+							BMA2X2_RANGE_8G) < 0)
+			return -EINVAL;
+#else
+		/* set to 4 G range */
+		if (bma2x2_set_range(bma2x2->bma2x2_client,
+							BMA2X2_RANGE_4G) < 0)
+			return -EINVAL;
+#endif
+	}
+
+	if ((bma2x2->sensor_type == BMA250E_TYPE) ||
+			(bma2x2->sensor_type == BMA222E_TYPE)) {
+		/* set to 8 G range */
+		if (bma2x2_set_range(bma2x2->bma2x2_client, 8) < 0)
+			return -EINVAL;
+		if (bma2x2_set_selftest_amp(bma2x2->bma2x2_client, 1) < 0)
+			return -EINVAL;
+	}
+
+	/* 1 for x-axis(but BMI058 is 1 for y-axis )*/
+	bma2x2_set_selftest_st(bma2x2->bma2x2_client, 1);
+	bma2x2_set_selftest_stn(bma2x2->bma2x2_client, 0);
+	mdelay(10);
+	bma2x2_read_accel_x(bma2x2->bma2x2_client,
+					bma2x2->sensor_type, &value1);
+	bma2x2_set_selftest_stn(bma2x2->bma2x2_client, 1);
+	mdelay(10);
+	bma2x2_read_accel_x(bma2x2->bma2x2_client,
+					bma2x2->sensor_type, &value2);
+	diff = value1-value2;
+
+#ifdef CONFIG_SENSORS_BMI058
+	PINFO("diff y is %d,value1 is %d, value2 is %d\n", diff,
+				value1, value2);
+	test_result_branch = 2;
+#else
+	PINFO("diff x is %d,value1 is %d, value2 is %d\n", diff,
+				value1, value2);
+	test_result_branch = 1;
+#endif
+
+	if (bma2x2->sensor_type == BMA280_TYPE) {
+#ifdef CONFIG_SENSORS_BMI058
+		if (abs(diff) < 819)
+			result |= test_result_branch;
+#else
+		if (abs(diff) < 1638)
+			result |= test_result_branch;
+#endif
+	}
+	if (bma2x2->sensor_type == BMA255_TYPE) {
+		if (abs(diff) < 409)
+			result |= 1;
+	}
+	if (bma2x2->sensor_type == BMA250E_TYPE) {
+		if (abs(diff) < 51)
+			result |= 1;
+	}
+	if (bma2x2->sensor_type == BMA222E_TYPE) {
+		if (abs(diff) < 12)
+			result |= 1;
+	}
+
+	/* 2 for y-axis but BMI058 is 1*/
+	bma2x2_set_selftest_st(bma2x2->bma2x2_client, 2);
+	bma2x2_set_selftest_stn(bma2x2->bma2x2_client, 0);
+	mdelay(10);
+	bma2x2_read_accel_y(bma2x2->bma2x2_client,
+					bma2x2->sensor_type, &value1);
+	bma2x2_set_selftest_stn(bma2x2->bma2x2_client, 1);
+	mdelay(10);
+	bma2x2_read_accel_y(bma2x2->bma2x2_client,
+					bma2x2->sensor_type, &value2);
+	diff = value1-value2;
+
+#ifdef CONFIG_SENSORS_BMI058
+	PINFO("diff x is %d,value1 is %d, value2 is %d\n", diff,
+				value1, value2);
+	test_result_branch = 1;
+#else
+	PINFO("diff y is %d,value1 is %d, value2 is %d\n", diff,
+				value1, value2);
+	test_result_branch = 2;
+#endif
+
+	if (bma2x2->sensor_type == BMA280_TYPE) {
+#ifdef CONFIG_SENSORS_BMI058
+		if (abs(diff) < 819)
+			result |= test_result_branch;
+#else
+		if (abs(diff) < 1638)
+			result |= test_result_branch;
+#endif
+	}
+	if (bma2x2->sensor_type == BMA255_TYPE) {
+		if (abs(diff) < 409)
+			result |= test_result_branch;
+	}
+	if (bma2x2->sensor_type == BMA250E_TYPE) {
+		if (abs(diff) < 51)
+			result |= test_result_branch;
+	}
+	if (bma2x2->sensor_type == BMA222E_TYPE) {
+		if (abs(diff) < 12)
+			result |= test_result_branch;
+	}
+
+
+	bma2x2_set_selftest_st(bma2x2->bma2x2_client, 3); /* 3 for z-axis*/
+	bma2x2_set_selftest_stn(bma2x2->bma2x2_client, 0);
+	mdelay(10);
+	bma2x2_read_accel_z(bma2x2->bma2x2_client,
+					bma2x2->sensor_type, &value1);
+	bma2x2_set_selftest_stn(bma2x2->bma2x2_client, 1);
+	mdelay(10);
+	bma2x2_read_accel_z(bma2x2->bma2x2_client,
+					bma2x2->sensor_type, &value2);
+	diff = value1-value2;
+
+	PINFO("diff z is %d,value1 is %d, value2 is %d\n", diff,
+			value1, value2);
+
+	if (bma2x2->sensor_type == BMA280_TYPE) {
+#ifdef CONFIG_SENSORS_BMI058
+			if (abs(diff) < 409)
+				result |= 4;
+#else
+			if (abs(diff) < 819)
+				result |= 4;
+#endif
+	}
+	if (bma2x2->sensor_type == BMA255_TYPE) {
+		if (abs(diff) < 204)
+			result |= 4;
+	}
+	if (bma2x2->sensor_type == BMA250E_TYPE) {
+		if (abs(diff) < 25)
+			result |= 4;
+	}
+	if (bma2x2->sensor_type == BMA222E_TYPE) {
+		if (abs(diff) < 6)
+			result |= 4;
+	}
+
+	/* self test for bma254 */
+	if ((bma2x2->sensor_type == BMA255_TYPE) && (result > 0)) {
+		result = 0;
+		bma2x2_soft_reset(bma2x2->bma2x2_client);
+		mdelay(5);
+		bma2x2_write_reg(bma2x2->bma2x2_client, 0x32, &clear_value);
+		/* set to 8 G range */
+		if (bma2x2_set_range(bma2x2->bma2x2_client, 8) < 0)
+			return -EINVAL;
+		if (bma2x2_set_selftest_amp(bma2x2->bma2x2_client, 1) < 0)
+			return -EINVAL;
+
+		bma2x2_set_selftest_st(bma2x2->bma2x2_client, 1); /* 1
+								for x-axis*/
+		bma2x2_set_selftest_stn(bma2x2->bma2x2_client, 0); /*
+							positive direction*/
+		mdelay(10);
+		bma2x2_read_accel_x(bma2x2->bma2x2_client,
+						bma2x2->sensor_type, &value1);
+		bma2x2_set_selftest_stn(bma2x2->bma2x2_client, 1); /*
+							negative direction*/
+		mdelay(10);
+		bma2x2_read_accel_x(bma2x2->bma2x2_client,
+						bma2x2->sensor_type, &value2);
+		diff = value1-value2;
+
+		PINFO("diff x is %d,value1 is %d, value2 is %d\n",
+						diff, value1, value2);
+		if (abs(diff) < 204)
+			result |= 1;
+
+		bma2x2_set_selftest_st(bma2x2->bma2x2_client, 2); /* 2
+								for y-axis*/
+		bma2x2_set_selftest_stn(bma2x2->bma2x2_client, 0); /*
+							positive direction*/
+		mdelay(10);
+		bma2x2_read_accel_y(bma2x2->bma2x2_client,
+						bma2x2->sensor_type, &value1);
+		bma2x2_set_selftest_stn(bma2x2->bma2x2_client, 1); /*
+							negative direction*/
+		mdelay(10);
+		bma2x2_read_accel_y(bma2x2->bma2x2_client,
+						bma2x2->sensor_type, &value2);
+		diff = value1-value2;
+		PINFO("diff y is %d,value1 is %d, value2 is %d\n",
+						diff, value1, value2);
+
+		if (abs(diff) < 204)
+			result |= 2;
+
+		bma2x2_set_selftest_st(bma2x2->bma2x2_client, 3); /* 3
+								for z-axis*/
+		bma2x2_set_selftest_stn(bma2x2->bma2x2_client, 0); /*
+							positive direction*/
+		mdelay(10);
+		bma2x2_read_accel_z(bma2x2->bma2x2_client,
+						bma2x2->sensor_type, &value1);
+		bma2x2_set_selftest_stn(bma2x2->bma2x2_client, 1); /*
+							negative direction*/
+		mdelay(10);
+		bma2x2_read_accel_z(bma2x2->bma2x2_client,
+						bma2x2->sensor_type, &value2);
+		diff = value1-value2;
+
+		PINFO("diff z is %d,value1 is %d, value2 is %d\n",
+						diff, value1, value2);
+		if (abs(diff) < 102)
+			result |= 4;
+	}
+
+	atomic_set(&bma2x2->selftest_result, (unsigned int)result);
+
+	bma2x2_soft_reset(bma2x2->bma2x2_client);
+	mdelay(5);
+	PINFO("self test finished\n");
+
+	return count;
+}
+
+
+
+static ssize_t bma2x2_flat_hold_time_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_flat_hold_time(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+const int bma2x2_sensor_bitwidth[] = {
+	12,  10,  8, 14
+};
+
+static int bma2x2_read_accel_xyz(struct i2c_client *client,
+		signed char sensor_type, struct bma2x2acc *acc)
+{
+	int comres = 0;
+	unsigned char data[6];
+	struct bma2x2_data *client_data = i2c_get_clientdata(client);
+#ifndef BMA2X2_SENSOR_IDENTIFICATION_ENABLE
+	int bitwidth;
+#endif
+
+    if(!client_data){
+        return BOSCH_SENSOR_BAD_ADDR;
+    }
+		
+	comres = bma2x2_smbus_read_byte_block(client,
+				BMA2X2_ACC_X12_LSB__REG, data, 6);
+	if (sensor_type >= 4)
+		return -EINVAL;
+
+	acc->x = (data[1]<<8)|data[0];
+	acc->y = (data[3]<<8)|data[2];
+	acc->z = (data[5]<<8)|data[4];
+
+#ifndef BMA2X2_SENSOR_IDENTIFICATION_ENABLE
+	bitwidth = bma2x2_sensor_bitwidth[sensor_type];
+
+	acc->x = (acc->x >> (16 - bitwidth));
+	acc->y = (acc->y >> (16 - bitwidth));
+	acc->z = (acc->z >> (16 - bitwidth));
+#endif
+
+	bma2x2_remap_sensor_data(acc, client_data);
+	return comres;
+}
+
+
+static int bma_cali_flag=0;
+
+int  bma2x2_real_cali(struct bma2x2_data *bma2x2);
+
+
+#ifndef CONFIG_BMA_ENABLE_NEWDATA_INT
+
+static void bma2x2_work_func(struct work_struct *work)
+{
+//	struct bma2x2_data *bma2x2 = container_of((struct delayed_work *)work,
+	struct bma2x2_data *bma2x2 = container_of((struct work_struct *)work,
+			struct bma2x2_data, work);
+	static struct bma2x2acc acc;
+	int ret=0;
+//	unsigned long delay = msecs_to_jiffies(atomic_read(&bma2x2->delay));
+
+	if(bma_cali_flag==0)
+	{
+		ret = bma2x2_real_cali(bma2x2);
+		if(ret >= 0)
+		{
+		   bma_cali_flag = 1;
+		}
+	}
+	bma2x2_read_accel_xyz(bma2x2->bma2x2_client, bma2x2->sensor_type, &acc);
+#if 0
+	input_report_abs(bma2x2->input, ABS_X, acc.x);
+	input_report_abs(bma2x2->input, ABS_Y, acc.y);
+	input_report_abs(bma2x2->input, ABS_Z, acc.z);
+#else
+	input_event(bma2x2->input, EV_MSC, MSC_RAW, acc.x);
+        input_event(bma2x2->input, EV_MSC, MSC_SCAN, acc.y);
+        input_event(bma2x2->input, EV_MSC, MSC_GESTURE, acc.z);
+#endif
+	input_sync(bma2x2->input);
+	mutex_lock(&bma2x2->value_mutex);
+	bma2x2->value = acc;
+	mutex_unlock(&bma2x2->value_mutex);
+//	schedule_delayed_work(&bma2x2->work, delay);
+}
+#endif
+
+static ssize_t bma2x2_register_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	int address, value;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	sscanf(buf, "%3d %3d", &address, &value);
+	if (bma2x2_write_reg(bma2x2->bma2x2_client, (unsigned char)address,
+				(unsigned char *)&value) < 0)
+		return -EINVAL;
+	return count;
+}
+static ssize_t bma2x2_register_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	size_t count = 0;
+	u8 reg[0x40];
+	int i;
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	for (i = 0; i < 0x40; i++) {
+		bma2x2_smbus_read_byte(bma2x2->bma2x2_client, i, reg+i);
+
+		count += sprintf(&buf[count], "0x%x: %d\n", i, reg[i]);
+	}
+	return count;
+
+
+}
+
+static ssize_t bma2x2_range_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (bma2x2_get_range(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+}
+
+static ssize_t bma2x2_range_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+	
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if (bma2x2_set_range(bma2x2->bma2x2_client, (unsigned char) data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_bandwidth_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+	if (bma2x2_get_bandwidth(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_bandwidth_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2->sensor_type == BMA280_TYPE)
+		if ((unsigned char) data > 14)
+			return -EINVAL;
+
+	if (bma2x2_set_bandwidth(bma2x2->bma2x2_client,
+				(unsigned char) data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_mode_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (bma2x2_get_mode(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d %d\n", data, bma2x2->bma_mode_enabled);
+}
+
+static ssize_t bma2x2_mode_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if (bma2x2_set_mode(bma2x2->bma2x2_client,
+		(unsigned char) data, BMA_ENABLED_BSX) < 0)
+			return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_value_cache_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct input_dev *input = to_input_dev(dev);
+	struct bma2x2_data *bma2x2 = input_get_drvdata(input);
+	struct bma2x2acc acc_value;
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	mutex_lock(&bma2x2->value_mutex);
+	acc_value = bma2x2->value;
+	mutex_unlock(&bma2x2->value_mutex);
+
+	return sprintf(buf, "%d %d %d\n", acc_value.x, acc_value.y,
+			acc_value.z);
+}
+
+static ssize_t bma2x2_value_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct input_dev *input = to_input_dev(dev);
+	struct bma2x2_data *bma2x2 = input_get_drvdata(input);
+	struct bma2x2acc acc_value;
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	bma2x2_read_accel_xyz(bma2x2->bma2x2_client, bma2x2->sensor_type,
+								&acc_value);
+
+	return sprintf(buf, "%d %d %d\n", acc_value.x, acc_value.y,
+			acc_value.z);
+}
+
+static ssize_t bma2x2_delay_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	return sprintf(buf, "%d\n", atomic_read(&bma2x2->delay));
+
+}
+
+static ssize_t bma2x2_chip_id_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	return sprintf(buf, "%u\n", bma2x2->chip_id);
+
+}
+
+
+static ssize_t bma2x2_place_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+	int place = BOSCH_SENSOR_PLACE_UNKNOWN;
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (NULL != bma2x2->bst_pd)
+		place = bma2x2->bst_pd->place;
+
+	return sprintf(buf, "%d\n", place);
+}
+
+
+static ssize_t bma2x2_delay_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if (data > BMA2X2_MAX_DELAY)
+		data = BMA2X2_MAX_DELAY;
+	atomic_set(&bma2x2->delay, (unsigned int) data);
+
+	return count;
+}
+
+int  bma2x2_real_cali(struct bma2x2_data *bma2x2)
+{
+    int cali_xyz=0;
+	unsigned int flag=0;
+	unsigned char bst_offset_x=0;
+    unsigned char bst_offset_y=0;
+    unsigned char bst_offset_z=0;
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	cali_xyz = read_file("/productinfo/gsensor_calibration.ini");
+
+    if(cali_xyz<0){
+		return -EINVAL;
+    }
+	
+    flag=(cali_xyz>>24)&0xff;
+
+	if(flag==0x2)
+	{
+      	bst_offset_x =  cali_xyz & 0xff;
+	    bst_offset_y =  (cali_xyz>>8)&0xff;
+	    bst_offset_z =	(cali_xyz>>16)&0xff;
+	}
+	else
+	{
+		bst_offset_x =  0;
+	    bst_offset_y =  0;
+	    bst_offset_z =	0;
+	}
+
+	if (bma2x2_set_offset_x(bma2x2->bma2x2_client, bst_offset_x) < 0)
+		return -EINVAL;
+	
+	if (bma2x2_set_offset_y(bma2x2->bma2x2_client, bst_offset_y) < 0)
+		return -EINVAL;
+	
+	if (bma2x2_set_offset_z(bma2x2->bma2x2_client, bst_offset_z) < 0)
+		return -EINVAL;
+	
+	return 0;
+}
+
+static ssize_t bma2x2_enable_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	return sprintf(buf, "%d\n", atomic_read(&bma2x2->enable));
+
+}
+
+static void bma2x2_set_enable(struct device *dev, int enable)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+	int pre_enable;
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	pre_enable = atomic_read(&bma2x2->enable);
+
+	mutex_lock(&bma2x2->enable_mutex);
+	
+	if (enable) {
+
+		if (pre_enable == 0) {
+			bma2x2_set_mode(bma2x2->bma2x2_client,
+					BMA2X2_MODE_NORMAL, BMA_ENABLED_INPUT);
+				
+#if 0
+#ifndef CONFIG_BMA_ENABLE_NEWDATA_INT
+			schedule_delayed_work(&bma2x2->work,
+				msecs_to_jiffies(atomic_read(&bma2x2->delay)));
+#endif
+#endif
+			hrtimer_start(&bma2x2->timer, ktime_set(0,
+				atomic_read(&bma2x2->delay) * 1000000), HRTIMER_MODE_REL);
+			atomic_set(&bma2x2->enable, 1);
+		}
+
+	} else {
+		if (pre_enable == 1) {
+			bma2x2_set_mode(bma2x2->bma2x2_client,
+					BMA2X2_MODE_SUSPEND, BMA_ENABLED_INPUT);
+#if 0
+#ifndef CONFIG_BMA_ENABLE_NEWDATA_INT
+			cancel_delayed_work_sync(&bma2x2->work);
+#endif
+#endif
+			hrtimer_cancel(&bma2x2->timer);
+			atomic_set(&bma2x2->enable, 0);
+		}
+	}
+	mutex_unlock(&bma2x2->enable_mutex);
+
+}
+
+static ssize_t bma2x2_enable_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if ((data == 0) || (data == 1))
+		bma2x2_set_enable(dev, data);
+
+	return count;
+}
+static ssize_t bma2x2_fast_calibration_x_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+	}
+
+#ifdef CONFIG_SENSORS_BMI058
+	if (bma2x2_get_offset_target(bma2x2->bma2x2_client,
+				BMI058_OFFSET_TRIGGER_X, &data) < 0)
+		return -EINVAL;
+#else
+	if (bma2x2_get_offset_target(bma2x2->bma2x2_client,
+				BMA2X2_OFFSET_TRIGGER_X, &data) < 0)
+		return -EINVAL;
+#endif
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_fast_calibration_x_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	signed char tmp;
+	unsigned char timeout = 0;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+#ifdef CONFIG_SENSORS_BMI058
+	if (bma2x2_set_offset_target(bma2x2->bma2x2_client,
+			BMI058_OFFSET_TRIGGER_X, (unsigned char)data) < 0)
+		return -EINVAL;
+#else
+	if (bma2x2_set_offset_target(bma2x2->bma2x2_client,
+			BMA2X2_OFFSET_TRIGGER_X, (unsigned char)data) < 0)
+		return -EINVAL;
+#endif
+
+	if (bma2x2_set_cal_trigger(bma2x2->bma2x2_client, 1) < 0)
+		return -EINVAL;
+
+	do {
+		mdelay(2);
+		bma2x2_get_cal_ready(bma2x2->bma2x2_client, &tmp);
+
+		/*PINFO("wait 2ms cal ready flag is %d\n", tmp); */
+		timeout++;
+		if (timeout == 50) {
+			PINFO("get fast calibration ready error\n");
+			return -EINVAL;
+		};
+
+	} while (tmp == 0);
+
+	PINFO("x axis fast calibration finished\n");
+	return count;
+}
+
+
+static int bma2x2_fast_calibration_x(struct device *dev, unsigned char data)
+{
+	signed char tmp;
+	unsigned char timeout = 0;
+
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+#ifdef CONFIG_SENSORS_BMI058
+	if (bma2x2_set_offset_target(bma2x2->bma2x2_client,
+			BMI058_OFFSET_TRIGGER_X, (unsigned char)data) < 0)
+		return -EINVAL;
+#else
+	if (bma2x2_set_offset_target(bma2x2->bma2x2_client,
+			BMA2X2_OFFSET_TRIGGER_X, (unsigned char)data) < 0)
+		return -EINVAL;
+#endif
+
+	if (bma2x2_set_cal_trigger(bma2x2->bma2x2_client, 1) < 0)
+		return -EINVAL;
+
+	do {
+		mdelay(2);
+		bma2x2_get_cal_ready(bma2x2->bma2x2_client, &tmp);
+
+		/*PINFO("wait 2ms cal ready flag is %d\n", tmp); */
+		timeout++;
+		if (timeout == 50) {
+			PINFO("get fast calibration ready error\n");
+			return -EINVAL;
+		};
+
+	} while (tmp == 0);
+
+	PINFO("x axis fast calibration finished\n");
+	return 0;
+}
+
+
+static ssize_t bma2x2_fast_calibration_y_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+
+
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+	}
+
+#ifdef CONFIG_SENSORS_BMI058
+	if (bma2x2_get_offset_target(bma2x2->bma2x2_client,
+					BMI058_OFFSET_TRIGGER_Y, &data) < 0)
+		return -EINVAL;
+#else
+	if (bma2x2_get_offset_target(bma2x2->bma2x2_client,
+					BMA2X2_OFFSET_TRIGGER_Y, &data) < 0)
+		return -EINVAL;
+#endif
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_fast_calibration_y_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	signed char tmp;
+	unsigned char timeout = 0;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+#ifdef CONFIG_SENSORS_BMI058
+	if (bma2x2_set_offset_target(bma2x2->bma2x2_client,
+			BMI058_OFFSET_TRIGGER_Y, (unsigned char)data) < 0)
+		return -EINVAL;
+#else
+	if (bma2x2_set_offset_target(bma2x2->bma2x2_client,
+			BMA2X2_OFFSET_TRIGGER_Y, (unsigned char)data) < 0)
+		return -EINVAL;
+#endif
+
+	if (bma2x2_set_cal_trigger(bma2x2->bma2x2_client, 2) < 0)
+		return -EINVAL;
+
+	do {
+		mdelay(2);
+		bma2x2_get_cal_ready(bma2x2->bma2x2_client, &tmp);
+
+		/*PINFO("wait 2ms cal ready flag is %d\n", tmp);*/
+		timeout++;
+		if (timeout == 50) {
+			PINFO("get fast calibration ready error\n");
+			return -EINVAL;
+		};
+
+	} while (tmp == 0);
+
+	PINFO("y axis fast calibration finished\n");
+	return count;
+}
+
+
+static int bma2x2_fast_calibration_y(struct device *dev, unsigned char data)
+{
+	signed char tmp;
+	unsigned char timeout = 0;
+
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+#ifdef CONFIG_SENSORS_BMI058
+	if (bma2x2_set_offset_target(bma2x2->bma2x2_client,
+			BMI058_OFFSET_TRIGGER_Y, (unsigned char)data) < 0)
+		return -EINVAL;
+#else
+	if (bma2x2_set_offset_target(bma2x2->bma2x2_client,
+			BMA2X2_OFFSET_TRIGGER_Y, (unsigned char)data) < 0)
+		return -EINVAL;
+#endif
+
+	if (bma2x2_set_cal_trigger(bma2x2->bma2x2_client, 2) < 0)
+		return -EINVAL;
+
+	do {
+		mdelay(2);
+		bma2x2_get_cal_ready(bma2x2->bma2x2_client, &tmp);
+
+		/*PINFO("wait 2ms cal ready flag is %d\n", tmp);*/
+		timeout++;
+		if (timeout == 50) {
+			PINFO("get fast calibration ready error\n");
+			return -EINVAL;
+		};
+
+	} while (tmp == 0);
+
+	PINFO("y axis fast calibration finished\n");
+	return 0;
+}
+
+
+static ssize_t bma2x2_fast_calibration_z_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (bma2x2_get_offset_target(bma2x2->bma2x2_client, 3, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_fast_calibration_z_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	signed char tmp;
+	unsigned char timeout = 0;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_offset_target(bma2x2->bma2x2_client, 3, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	if (bma2x2_set_cal_trigger(bma2x2->bma2x2_client, 3) < 0)
+		return -EINVAL;
+
+	do {
+		mdelay(2);
+		bma2x2_get_cal_ready(bma2x2->bma2x2_client, &tmp);
+
+		/*PINFO("wait 2ms cal ready flag is %d\n", tmp);*/
+		timeout++;
+		if (timeout == 50) {
+			PINFO("get fast calibration ready error\n");
+			return -EINVAL;
+		};
+
+	} while (tmp == 0);
+
+	PINFO("z axis fast calibration finished\n");
+	return count;
+}
+
+
+static ssize_t bma2x2_fast_calibration_z(struct device *dev,unsigned char data)
+{
+	signed char tmp;
+	unsigned char timeout = 0;
+
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (bma2x2_set_offset_target(bma2x2->bma2x2_client, 3, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	if (bma2x2_set_cal_trigger(bma2x2->bma2x2_client, 3) < 0)
+		return -EINVAL;
+
+	do {
+		mdelay(2);
+		bma2x2_get_cal_ready(bma2x2->bma2x2_client, &tmp);
+
+		/*PINFO("wait 2ms cal ready flag is %d\n", tmp);*/
+		timeout++;
+		if (timeout == 50) {
+			PINFO("get fast calibration ready error\n");
+			return -EINVAL;
+		};
+
+	} while (tmp == 0);
+
+	PINFO("z axis fast calibration finished\n");
+	return 0;
+}
+
+
+static ssize_t bma2x2_enable_cali_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char datax = 0;
+	unsigned char datay = 0;
+	unsigned char dataz = 0;
+	unsigned int data=0;
+	
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	bma2x2_fast_calibration_x(dev,3);
+	bma2x2_fast_calibration_y(dev,3);
+	bma2x2_fast_calibration_z(dev,2);
+
+	if (bma2x2_get_offset_x(bma2x2->bma2x2_client, &datax) < 0)
+		return -1;
+	if (bma2x2_get_offset_y(bma2x2->bma2x2_client, &datay) < 0)
+		return -1;
+	if (bma2x2_get_offset_z(bma2x2->bma2x2_client, &dataz) < 0)
+		return -1;
+
+	data = dataz;
+	data = (data<<8)|datay;
+	data = (data<<8)|datax;
+
+	return sprintf(buf, "%d\n", data);
+}
+
+static ssize_t bma2x2_SleepDur_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (bma2x2_get_sleep_duration(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+}
+
+static ssize_t bma2x2_SleepDur_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if (bma2x2_set_sleep_duration(bma2x2->bma2x2_client,
+				(unsigned char) data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_fifo_mode_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (bma2x2_get_fifo_mode(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_fifo_mode_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if (bma2x2_set_fifo_mode(bma2x2->bma2x2_client,
+				(unsigned char) data) < 0)
+		return -EINVAL;
+	return count;
+}
+
+static ssize_t bma2x2_fifo_trig_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (bma2x2_get_fifo_trig(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_fifo_trig_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if (bma2x2_set_fifo_trig(bma2x2->bma2x2_client,
+				(unsigned char) data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_fifo_trig_src_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (bma2x2_get_fifo_trig_src(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_fifo_trig_src_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if (bma2x2_set_fifo_trig_src(bma2x2->bma2x2_client,
+				(unsigned char) data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+
+/*!
+ * @brief show fifo_data_sel axis definition(Android definition, not sensor HW reg).
+ * 0--> x, y, z axis fifo data for every frame
+ * 1--> only x axis fifo data for every frame
+ * 2--> only y axis fifo data for every frame
+ * 3--> only z axis fifo data for every frame
+ */
+static ssize_t bma2x2_fifo_data_sel_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+	signed char place = BOSCH_SENSOR_PLACE_UNKNOWN;
+
+	if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+		
+	if (bma2x2_get_fifo_data_sel(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+#ifdef CONFIG_SENSORS_BMI058
+/*Update BMI058 fifo_data_sel to the BMA2x2 common definition*/
+	if (BMI058_FIFO_DAT_SEL_X == data)
+		data = BMA2X2_FIFO_DAT_SEL_X;
+	else if (BMI058_FIFO_DAT_SEL_Y == data)
+		data = BMA2X2_FIFO_DAT_SEL_Y;
+#endif
+
+	/*remaping fifo_dat_sel if define virtual place in BSP files*/
+	if ((NULL != bma2x2->bst_pd) &&
+		(BOSCH_SENSOR_PLACE_UNKNOWN != bma2x2->bst_pd->place)) {
+		place = bma2x2->bst_pd->place;
+		/* sensor with place 0 needs not to be remapped */
+		if ((place > 0) && (place < MAX_AXIS_REMAP_TAB_SZ)) {
+			/* BMA2X2_FIFO_DAT_SEL_X: 1, Y:2, Z:3;
+			* but bst_axis_remap_tab_dft[i].src_x:0, y:1, z:2
+			* so we need to +1*/
+			if (BMA2X2_FIFO_DAT_SEL_X == data)
+				data = bst_axis_remap_tab_dft[place].src_x + 1;
+			else if (BMA2X2_FIFO_DAT_SEL_Y == data)
+				data = bst_axis_remap_tab_dft[place].src_y + 1;
+		}
+	}
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_fifo_framecount_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	unsigned char mode;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (bma2x2_get_fifo_framecount(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	if (data > MAX_FIFO_F_LEVEL) {
+
+		if (bma2x2_get_mode(bma2x2->bma2x2_client, &mode) < 0)
+			return -EINVAL;
+
+		if (BMA2X2_MODE_NORMAL == mode) {
+			PERR("bma2x2 fifo_count: %d abnormal, op_mode: %d",
+					data, mode);
+			data = MAX_FIFO_F_LEVEL;
+		} else {
+			/*chip already suspend or shutdown*/
+			data = 0;
+		}
+	}
+
+	return sprintf(buf, "%d\n", data);
+}
+
+static ssize_t bma2x2_fifo_framecount_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	bma2x2->fifo_count = (unsigned int) data;
+
+	return count;
+}
+
+static ssize_t bma2x2_temperature_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (bma2x2_read_temperature(bma2x2->bma2x2_client, &data) < 0)
+		return -EINVAL;
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+/*!
+ * @brief store fifo_data_sel axis definition(Android definition, not sensor HW reg).
+ * 0--> x, y, z axis fifo data for every frame
+ * 1--> only x axis fifo data for every frame
+ * 2--> only y axis fifo data for every frame
+ * 3--> only z axis fifo data for every frame
+ */
+static ssize_t bma2x2_fifo_data_sel_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+	signed char place;
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	/*save fifo_data_sel(android definition)*/
+	bma2x2->fifo_datasel = (unsigned char) data;
+
+	/*remaping fifo_dat_sel if define virtual place*/
+	if ((NULL != bma2x2->bst_pd) &&
+		(BOSCH_SENSOR_PLACE_UNKNOWN != bma2x2->bst_pd->place)) {
+		place = bma2x2->bst_pd->place;
+		/* sensor with place 0 needs not to be remapped */
+		if ((place > 0) && (place < MAX_AXIS_REMAP_TAB_SZ)) {
+			/*Need X Y axis revesal sensor place: P1, P3, P5, P7 */
+			/* BMA2X2_FIFO_DAT_SEL_X: 1, Y:2, Z:3;
+			  * but bst_axis_remap_tab_dft[i].src_x:0, y:1, z:2
+			  * so we need to +1*/
+			if (BMA2X2_FIFO_DAT_SEL_X == data)
+				data =  bst_axis_remap_tab_dft[place].src_x + 1;
+			else if (BMA2X2_FIFO_DAT_SEL_Y == data)
+				data =  bst_axis_remap_tab_dft[place].src_y + 1;
+		}
+	}
+#ifdef CONFIG_SENSORS_BMI058
+	/*Update BMI058 fifo_data_sel to the BMA2x2 common definition*/
+		if (BMA2X2_FIFO_DAT_SEL_X == data)
+			data = BMI058_FIFO_DAT_SEL_X;
+		else if (BMA2X2_FIFO_DAT_SEL_Y == data)
+			data = BMI058_FIFO_DAT_SEL_Y;
+
+#endif
+	if (bma2x2_set_fifo_data_sel(bma2x2->bma2x2_client,
+				(unsigned char) data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+
+/*!
+ * brief: bma2x2 single axis data remaping
+ * @param[i] fifo_datasel   fifo axis data select setting
+ * @param[i/o] remap_dir   remapping direction
+ * @param[i] client_data   to transfer sensor place
+ *
+ * @return none
+ */
+static void bma2x2_single_axis_remaping(unsigned char fifo_datasel,
+		unsigned char *remap_dir, struct bma2x2_data *client_data)
+{
+	if ((NULL == client_data->bst_pd) ||
+			(BOSCH_SENSOR_PLACE_UNKNOWN
+			 == client_data->bst_pd->place))
+		return;
+	else {
+		signed char place = client_data->bst_pd->place;
+		/* sensor with place 0 needs not to be remapped */
+		if ((place <= 0)  || (place >= MAX_AXIS_REMAP_TAB_SZ))
+			return;
+
+		if (fifo_datasel < 1 || fifo_datasel > 3)
+			return;
+		else {
+			switch (fifo_datasel) {
+			/*P2, P3, P4, P5 X axis(andorid) need to reverse*/
+			case BMA2X2_FIFO_DAT_SEL_X:
+				if (-1 == bst_axis_remap_tab_dft[place].sign_x)
+					*remap_dir = 1;
+				else
+					*remap_dir = 0;
+				break;
+			/*P1, P2, P5, P6 Y axis(andorid) need to reverse*/
+			case BMA2X2_FIFO_DAT_SEL_Y:
+				if (-1 == bst_axis_remap_tab_dft[place].sign_y)
+					*remap_dir = 1;
+				else
+					*remap_dir = 0;
+				break;
+			case BMA2X2_FIFO_DAT_SEL_Z:
+			/*P4, P5, P6, P7 Z axis(andorid) need to reverse*/
+				if (-1 == bst_axis_remap_tab_dft[place].sign_z)
+					*remap_dir = 1;
+				else
+					*remap_dir = 0;
+				break;
+			default:
+				break;
+			}
+		}
+	}
+
+	return;
+}
+
+static ssize_t bma2x2_fifo_data_out_frame_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	int err, i, len;
+	signed char fifo_data_out[MAX_FIFO_F_LEVEL * MAX_FIFO_F_BYTES] = {0};
+	unsigned char f_len = 0;
+	s16 value;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+	struct bma2x2acc acc_lsb;
+	unsigned char axis_dir_remap = 0;
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+		
+	if (bma2x2->fifo_datasel) {
+		/*Select one axis data output for every fifo frame*/
+		f_len = 2;
+	} else	{
+		/*Select X Y Z axis data output for every fifo frame*/
+		f_len = 6;
+	}
+
+	if (bma2x2->fifo_count == 0)
+		return -EINVAL;
+
+	if (bma2x2->bma_mode_enabled == 0) {
+		PERR("bma2x2_fifo_data, bma_mode_enabled 0");
+		/*return -EINVAL;*/
+	}
+
+	if (bma_i2c_burst_read(bma2x2->bma2x2_client,
+			BMA2X2_FIFO_DATA_OUTPUT_REG, fifo_data_out,
+						bma2x2->fifo_count * f_len) < 0)
+		return -EINVAL;
+
+	err = 0;
+
+/* please give attation for the fifo output data format*/
+	if (f_len == 6) {
+		/* Select X Y Z axis data output for every frame */
+		for (i = 0; i < bma2x2->fifo_count; i++) {
+			acc_lsb.x =
+			((unsigned char)fifo_data_out[i * f_len + 1] << 8 |
+				(unsigned char)fifo_data_out[i * f_len + 0]);
+			acc_lsb.y =
+			((unsigned char)fifo_data_out[i * f_len + 3] << 8 |
+				(unsigned char)fifo_data_out[i * f_len + 2]);
+			acc_lsb.z =
+			((unsigned char)fifo_data_out[i * f_len + 5] << 8 |
+				(unsigned char)fifo_data_out[i * f_len + 4]);
+#ifndef BMA2X2_SENSOR_IDENTIFICATION_ENABLE
+			acc_lsb.x >>=
+			(16 - bma2x2_sensor_bitwidth[bma2x2->sensor_type]);
+			acc_lsb.y >>=
+			(16 - bma2x2_sensor_bitwidth[bma2x2->sensor_type]);
+			acc_lsb.z >>=
+			(16 - bma2x2_sensor_bitwidth[bma2x2->sensor_type]);
+#endif
+			bma2x2_remap_sensor_data(&acc_lsb, bma2x2);
+			len = sprintf(buf, "%d %d %d ",
+				acc_lsb.x, acc_lsb.y, acc_lsb.z);
+			buf += len;
+			err += len;
+		}
+	} else {
+		/* single axis data output for every frame */
+		bma2x2_single_axis_remaping(bma2x2->fifo_datasel,
+					&axis_dir_remap, bma2x2);
+		for (i = 0; i < bma2x2->fifo_count * f_len / 2; i++)	{
+			value = ((unsigned char)fifo_data_out[2 * i + 1] << 8 |
+					(unsigned char)fifo_data_out[2 * i]);
+#ifndef BMA2X2_SENSOR_IDENTIFICATION_ENABLE
+			value >>=
+			(16 - bma2x2_sensor_bitwidth[bma2x2->sensor_type]);
+#endif
+			if (axis_dir_remap)
+				value = 0 - value;
+			len = sprintf(buf, "%d ", value);
+			buf += len;
+			err += len;
+		}
+	}
+
+	return err;
+}
+
+static ssize_t bma2x2_offset_x_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (bma2x2_get_offset_x(bma2x2->bma2x2_client, &data) < 0)
+		return sprintf(buf, "Read error\n");
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_offset_x_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_offset_x(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_offset_y_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (bma2x2_get_offset_y(bma2x2->bma2x2_client, &data) < 0)
+		return sprintf(buf, "Read error\n");
+
+	return sprintf(buf, "%d\n", data);
+}
+
+static ssize_t bma2x2_offset_y_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_offset_y(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+static ssize_t bma2x2_offset_z_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	unsigned char data = 0;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (bma2x2_get_offset_z(bma2x2->bma2x2_client, &data) < 0)
+		return sprintf(buf, "Read error\n");
+
+	return sprintf(buf, "%d\n", data);
+
+}
+
+static ssize_t bma2x2_offset_z_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if (bma2x2_set_offset_z(bma2x2->bma2x2_client, (unsigned
+					char)data) < 0)
+		return -EINVAL;
+
+	return count;
+}
+
+#ifdef CONFIG_SIG_MOTION
+static int bma2x2_set_en_slope_int(struct bma2x2_data *bma2x2,
+		int en)
+{
+	int err;
+	struct i2c_client *client = bma2x2->bma2x2_client;
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (en) {
+		/* Set the related parameters which needs to be fine tuned by
+		* interfaces: slope_threshold and slope_duration
+		*/
+		/*dur: 192 samples ~= 3s*/
+		err = bma2x2_set_slope_duration(client, 0x0);
+		err += bma2x2_set_slope_threshold(client, 0x16);
+
+		/*Enable the interrupts*/
+		err += bma2x2_set_Int_Enable(client, 5, 1);/*Slope X*/
+		err += bma2x2_set_Int_Enable(client, 6, 1);/*Slope Y*/
+		err += bma2x2_set_Int_Enable(client, 7, 1);/*Slope Z*/
+	#ifdef BMA2X2_ENABLE_INT1
+		/* TODO: SLOPE can now only be routed to INT1 pin*/
+		err += bma2x2_set_int1_pad_sel(client, PAD_SLOP);
+	#else
+		/* err += bma2x2_set_int2_pad_sel(client, PAD_SLOP); */
+	#endif
+	} else {
+		err = bma2x2_set_Int_Enable(client, 5, 0);/*Slope X*/
+		err += bma2x2_set_Int_Enable(client, 6, 0);/*Slope Y*/
+		err += bma2x2_set_Int_Enable(client, 7, 0);/*Slope Z*/
+	}
+	return err;
+}
+
+static ssize_t bma2x2_en_sig_motion_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	return sprintf(buf, "%d\n", atomic_read(&bma2x2->en_sig_motion));
+}
+
+static int bma2x2_set_en_sig_motion(struct bma2x2_data *bma2x2,
+		int en)
+{
+	int err = 0;
+
+	en = (en >= 1) ? 1 : 0;  /* set sig motion sensor status */
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	if (atomic_read(&bma2x2->en_sig_motion) != en) {
+		if (en) {
+			err = bma2x2_set_mode(bma2x2->bma2x2_client,
+					BMA2X2_MODE_NORMAL, BMA_ENABLED_SGM);
+			err = bma2x2_set_en_slope_int(bma2x2, en);
+			enable_irq_wake(bma2x2->IRQ);
+		} else {
+			disable_irq_wake(bma2x2->IRQ);
+			err = bma2x2_set_en_slope_int(bma2x2, en);
+			err = bma2x2_set_mode(bma2x2->bma2x2_client,
+					BMA2X2_MODE_SUSPEND, BMA_ENABLED_SGM);
+		}
+		atomic_set(&bma2x2->en_sig_motion, en);
+	}
+	return err;
+}
+
+static ssize_t bma2x2_en_sig_motion_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+    if(!bma2x2){
+		return BOSCH_SENSOR_BAD_ADDR;
+    }
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if ((data == 0) || (data == 1))
+		bma2x2_set_en_sig_motion(bma2x2, data);
+
+	return count;
+}
+#endif
+
+#ifdef CONFIG_DOUBLE_TAP
+static int bma2x2_set_en_single_tap_int(struct bma2x2_data *bma2x2, int en)
+{
+	int err;
+	struct i2c_client *client = bma2x2->bma2x2_client;
+
+	if (en) {
+		/* set tap interruption parameter here if needed.
+		bma2x2_set_tap_duration(client, 0xc0);
+		bma2x2_set_tap_threshold(client, 0x16);
+		*/
+
+		/*Enable the single tap interrupts*/
+		err = bma2x2_set_Int_Enable(client, 8, 1);
+	#ifdef BMA2X2_ENABLE_INT1
+		err += bma2x2_set_int1_pad_sel(client, PAD_SINGLE_TAP);
+	#else
+		err += bma2x2_set_int2_pad_sel(client, PAD_SINGLE_TAP);
+	#endif
+	} else {
+		err = bma2x2_set_Int_Enable(client, 8, 0);
+	}
+	return err;
+}
+
+static ssize_t bma2x2_tap_time_period_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	return sprintf(buf, "%d\n", bma2x2->tap_time_period);
+}
+
+static ssize_t bma2x2_tap_time_period_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	bma2x2->tap_time_period = data;
+
+	return count;
+}
+
+static ssize_t bma2x2_en_double_tap_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	return sprintf(buf, "%d\n", atomic_read(&bma2x2->en_double_tap));
+}
+
+static int bma2x2_set_en_double_tap(struct bma2x2_data *bma2x2,
+		int en)
+{
+	int err = 0;
+
+	en = (en >= 1) ? 1 : 0;
+
+	if (atomic_read(&bma2x2->en_double_tap) != en) {
+		if (en) {
+			err = bma2x2_set_mode(bma2x2->bma2x2_client,
+					BMA2X2_MODE_NORMAL, BMA_ENABLED_DTAP);
+			err = bma2x2_set_en_single_tap_int(bma2x2, en);
+		} else {
+			err = bma2x2_set_en_single_tap_int(bma2x2, en);
+			err = bma2x2_set_mode(bma2x2->bma2x2_client,
+					BMA2X2_MODE_SUSPEND, BMA_ENABLED_DTAP);
+		}
+		atomic_set(&bma2x2->en_double_tap, en);
+	}
+	return err;
+}
+
+static ssize_t bma2x2_en_double_tap_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct i2c_client *client = to_i2c_client(dev);
+	struct bma2x2_data *bma2x2 = i2c_get_clientdata(client);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+
+	if ((data == 0) || (data == 1))
+		bma2x2_set_en_double_tap(bma2x2, data);
+
+	return count;
+}
+
+static void bma2x2_tap_timeout_handle(unsigned long data)
+{
+	struct bma2x2_data *bma2x2 = (struct bma2x2_data *)data;
+
+	PINFO("tap interrupt handle, timeout\n");
+	mutex_lock(&bma2x2->tap_mutex);
+	bma2x2->tap_times = 0;
+	mutex_unlock(&bma2x2->tap_mutex);
+
+	/* if a single tap need to report, open the define */
+#ifdef REPORT_SINGLE_TAP_WHEN_DOUBLE_TAP_SENSOR_ENABLED
+	input_report_rel(bma2x2->dev_interrupt,
+		SINGLE_TAP_INTERRUPT,
+		SINGLE_TAP_INTERRUPT_HAPPENED);
+	input_sync(bma2x2->dev_interrupt);
+#endif
+
+}
+#endif
+
+static DEVICE_ATTR(range, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_range_show, bma2x2_range_store);
+static DEVICE_ATTR(bandwidth, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_bandwidth_show, bma2x2_bandwidth_store);
+static DEVICE_ATTR(op_mode, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_mode_show, bma2x2_mode_store);
+static DEVICE_ATTR(value, S_IRUGO,
+		bma2x2_value_show, NULL);
+static DEVICE_ATTR(value_cache, S_IRUGO,
+		bma2x2_value_cache_show, NULL);
+static DEVICE_ATTR(delay, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_delay_show, bma2x2_delay_store);
+static DEVICE_ATTR(enable, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_enable_show, bma2x2_enable_store);
+static DEVICE_ATTR(SleepDur, S_IRUGO|S_IWUSR|S_IWGRP,
+		bma2x2_SleepDur_show, bma2x2_SleepDur_store);
+static DEVICE_ATTR(fast_calibration_x, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_fast_calibration_x_show,
+		bma2x2_fast_calibration_x_store);
+static DEVICE_ATTR(fast_calibration_y, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_fast_calibration_y_show,
+		bma2x2_fast_calibration_y_store);
+static DEVICE_ATTR(fast_calibration_z, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_fast_calibration_z_show,
+		bma2x2_fast_calibration_z_store);
+static DEVICE_ATTR(enable_cali, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_enable_cali_show,
+		NULL);
+static DEVICE_ATTR(fifo_mode, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_fifo_mode_show, bma2x2_fifo_mode_store);
+static DEVICE_ATTR(fifo_framecount, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_fifo_framecount_show, bma2x2_fifo_framecount_store);
+static DEVICE_ATTR(fifo_trig, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_fifo_trig_show, bma2x2_fifo_trig_store);
+static DEVICE_ATTR(fifo_trig_src, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_fifo_trig_src_show, bma2x2_fifo_trig_src_store);
+static DEVICE_ATTR(fifo_data_sel, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_fifo_data_sel_show, bma2x2_fifo_data_sel_store);
+static DEVICE_ATTR(fifo_data_frame, S_IRUGO,
+		bma2x2_fifo_data_out_frame_show, NULL);
+static DEVICE_ATTR(reg, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_register_show, bma2x2_register_store);
+static DEVICE_ATTR(chip_id, S_IRUGO,
+		bma2x2_chip_id_show, NULL);
+static DEVICE_ATTR(offset_x, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_offset_x_show,
+		bma2x2_offset_x_store);
+static DEVICE_ATTR(offset_y, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_offset_y_show,
+		bma2x2_offset_y_store);
+static DEVICE_ATTR(offset_z, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_offset_z_show,
+		bma2x2_offset_z_store);
+static DEVICE_ATTR(enable_int, S_IWUSR|S_IWGRP|S_IWOTH,
+		NULL, bma2x2_enable_int_store);
+static DEVICE_ATTR(int_mode, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_int_mode_show, bma2x2_int_mode_store);
+static DEVICE_ATTR(slope_duration, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_slope_duration_show, bma2x2_slope_duration_store);
+static DEVICE_ATTR(slope_threshold, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_slope_threshold_show, bma2x2_slope_threshold_store);
+static DEVICE_ATTR(slope_no_mot_duration, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_slope_no_mot_duration_show,
+			bma2x2_slope_no_mot_duration_store);
+static DEVICE_ATTR(slope_no_mot_threshold, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_slope_no_mot_threshold_show,
+			bma2x2_slope_no_mot_threshold_store);
+static DEVICE_ATTR(high_g_duration, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_high_g_duration_show, bma2x2_high_g_duration_store);
+static DEVICE_ATTR(high_g_threshold, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_high_g_threshold_show, bma2x2_high_g_threshold_store);
+static DEVICE_ATTR(low_g_duration, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_low_g_duration_show, bma2x2_low_g_duration_store);
+static DEVICE_ATTR(low_g_threshold, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_low_g_threshold_show, bma2x2_low_g_threshold_store);
+static DEVICE_ATTR(tap_duration, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_tap_duration_show, bma2x2_tap_duration_store);
+static DEVICE_ATTR(tap_threshold, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_tap_threshold_show, bma2x2_tap_threshold_store);
+static DEVICE_ATTR(tap_quiet, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_tap_quiet_show, bma2x2_tap_quiet_store);
+static DEVICE_ATTR(tap_shock, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_tap_shock_show, bma2x2_tap_shock_store);
+static DEVICE_ATTR(tap_samp, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_tap_samp_show, bma2x2_tap_samp_store);
+static DEVICE_ATTR(orient_mode, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_orient_mode_show, bma2x2_orient_mode_store);
+static DEVICE_ATTR(orient_blocking, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_orient_blocking_show, bma2x2_orient_blocking_store);
+static DEVICE_ATTR(orient_hyst, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_orient_hyst_show, bma2x2_orient_hyst_store);
+static DEVICE_ATTR(orient_theta, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_orient_theta_show, bma2x2_orient_theta_store);
+static DEVICE_ATTR(flat_theta, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_flat_theta_show, bma2x2_flat_theta_store);
+static DEVICE_ATTR(flat_hold_time, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_flat_hold_time_show, bma2x2_flat_hold_time_store);
+static DEVICE_ATTR(selftest, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_selftest_show, bma2x2_selftest_store);
+static DEVICE_ATTR(softreset, S_IWUSR|S_IWGRP|S_IWOTH,
+		NULL, bma2x2_softreset_store);
+static DEVICE_ATTR(temperature, S_IRUGO,
+		bma2x2_temperature_show, NULL);
+static DEVICE_ATTR(place, S_IRUGO,
+		bma2x2_place_show, NULL);
+#ifdef CONFIG_SIG_MOTION
+static DEVICE_ATTR(en_sig_motion, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_en_sig_motion_show, bma2x2_en_sig_motion_store);
+#endif
+#ifdef CONFIG_DOUBLE_TAP
+static DEVICE_ATTR(tap_time_period, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_tap_time_period_show, bma2x2_tap_time_period_store);
+static DEVICE_ATTR(en_double_tap, S_IRUGO|S_IWUSR|S_IWGRP|S_IWOTH,
+		bma2x2_en_double_tap_show, bma2x2_en_double_tap_store);
+#endif
+
+static struct attribute *bma2x2_attributes[] = {
+	&dev_attr_range.attr,
+	&dev_attr_bandwidth.attr,
+	&dev_attr_op_mode.attr,
+	&dev_attr_value.attr,
+	&dev_attr_value_cache.attr,
+	&dev_attr_delay.attr,
+	&dev_attr_enable.attr,
+	&dev_attr_SleepDur.attr,
+	&dev_attr_reg.attr,
+	&dev_attr_fast_calibration_x.attr,
+	&dev_attr_fast_calibration_y.attr,
+	&dev_attr_fast_calibration_z.attr,
+	&dev_attr_enable_cali.attr,
+	&dev_attr_fifo_mode.attr,
+	&dev_attr_fifo_framecount.attr,
+	&dev_attr_fifo_trig.attr,
+	&dev_attr_fifo_trig_src.attr,
+	&dev_attr_fifo_data_sel.attr,
+	&dev_attr_fifo_data_frame.attr,
+	&dev_attr_chip_id.attr,
+	&dev_attr_offset_x.attr,
+	&dev_attr_offset_y.attr,
+	&dev_attr_offset_z.attr,
+	&dev_attr_enable_int.attr,
+	&dev_attr_int_mode.attr,
+	&dev_attr_slope_duration.attr,
+	&dev_attr_slope_threshold.attr,
+	&dev_attr_slope_no_mot_duration.attr,
+	&dev_attr_slope_no_mot_threshold.attr,
+	&dev_attr_high_g_duration.attr,
+	&dev_attr_high_g_threshold.attr,
+	&dev_attr_low_g_duration.attr,
+	&dev_attr_low_g_threshold.attr,
+	&dev_attr_tap_threshold.attr,
+	&dev_attr_tap_duration.attr,
+	&dev_attr_tap_quiet.attr,
+	&dev_attr_tap_shock.attr,
+	&dev_attr_tap_samp.attr,
+	&dev_attr_orient_mode.attr,
+	&dev_attr_orient_blocking.attr,
+	&dev_attr_orient_hyst.attr,
+	&dev_attr_orient_theta.attr,
+	&dev_attr_flat_theta.attr,
+	&dev_attr_flat_hold_time.attr,
+	&dev_attr_selftest.attr,
+	&dev_attr_softreset.attr,
+	&dev_attr_temperature.attr,
+	&dev_attr_place.attr,
+#ifdef CONFIG_SIG_MOTION
+	&dev_attr_en_sig_motion.attr,
+#endif
+#ifdef CONFIG_DOUBLE_TAP
+	&dev_attr_en_double_tap.attr,
+#endif
+
+	NULL
+};
+
+static struct attribute_group bma2x2_attribute_group = {
+	.attrs = bma2x2_attributes
+};
+
+#ifdef CONFIG_SIG_MOTION
+static struct attribute *bma2x2_sig_motion_attributes[] = {
+	&dev_attr_slope_duration.attr,
+	&dev_attr_slope_threshold.attr,
+	&dev_attr_en_sig_motion.attr,
+	NULL
+};
+static struct attribute_group bma2x2_sig_motion_attribute_group = {
+	.attrs = bma2x2_sig_motion_attributes
+};
+#endif
+
+#ifdef CONFIG_DOUBLE_TAP
+static struct attribute *bma2x2_double_tap_attributes[] = {
+	&dev_attr_tap_threshold.attr,
+	&dev_attr_tap_duration.attr,
+	&dev_attr_tap_quiet.attr,
+	&dev_attr_tap_shock.attr,
+	&dev_attr_tap_samp.attr,
+	&dev_attr_tap_time_period.attr,
+	&dev_attr_en_double_tap.attr,
+	NULL
+};
+static struct attribute_group bma2x2_double_tap_attribute_group = {
+	.attrs = bma2x2_double_tap_attributes
+};
+#endif
+
+
+#if defined(BMA2X2_ENABLE_INT1) || defined(BMA2X2_ENABLE_INT2)
+unsigned char *orient[] = {"upward looking portrait upright",
+	"upward looking portrait upside-down",
+		"upward looking landscape left",
+		"upward looking landscape right",
+		"downward looking portrait upright",
+		"downward looking portrait upside-down",
+		"downward looking landscape left",
+		"downward looking landscape right"};
+
+
+static void bma2x2_high_g_interrupt_handle(struct bma2x2_data *bma2x2)
+{
+	unsigned char first_value = 0;
+	unsigned char sign_value = 0;
+	int i;
+
+	for (i = 0; i < 3; i++) {
+		bma2x2_get_HIGH_first(bma2x2->bma2x2_client, i, &first_value);
+		if (first_value == 1) {
+			bma2x2_get_HIGH_sign(bma2x2->bma2x2_client,
+								&sign_value);
+			if (sign_value == 1) {
+				if (i == 0)
+					input_report_rel(bma2x2->dev_interrupt,
+							HIGH_G_INTERRUPT,
+							HIGH_G_INTERRUPT_X_N);
+				if (i == 1)
+					input_report_rel(bma2x2->dev_interrupt,
+							HIGH_G_INTERRUPT,
+							HIGH_G_INTERRUPT_Y_N);
+				if (i == 2)
+					input_report_rel(bma2x2->dev_interrupt,
+							HIGH_G_INTERRUPT,
+							HIGH_G_INTERRUPT_Z_N);
+			} else {
+				if (i == 0)
+					input_report_rel(bma2x2->dev_interrupt,
+							HIGH_G_INTERRUPT,
+							HIGH_G_INTERRUPT_X);
+				if (i == 1)
+					input_report_rel(bma2x2->dev_interrupt,
+							HIGH_G_INTERRUPT,
+							HIGH_G_INTERRUPT_Y);
+				if (i == 2)
+					input_report_rel(bma2x2->dev_interrupt,
+							HIGH_G_INTERRUPT,
+							HIGH_G_INTERRUPT_Z);
+			}
+		}
+
+		PINFO("High G interrupt happened,exis is %d,"
+					"first is %d,sign is %d\n", i,
+						first_value, sign_value);
+	}
+
+
+}
+
+#ifndef CONFIG_SIG_MOTION
+static void bma2x2_slope_interrupt_handle(struct bma2x2_data *bma2x2)
+{
+	unsigned char first_value = 0;
+	unsigned char sign_value = 0;
+	int i;
+	for (i = 0; i < 3; i++) {
+		bma2x2_get_slope_first(bma2x2->bma2x2_client, i, &first_value);
+		if (first_value == 1) {
+			bma2x2_get_slope_sign(bma2x2->bma2x2_client,
+								&sign_value);
+			if (sign_value == 1) {
+				if (i == 0)
+					input_report_rel(bma2x2->dev_interrupt,
+							SLOP_INTERRUPT,
+							SLOPE_INTERRUPT_X_N);
+				if (i == 1)
+					input_report_rel(bma2x2->dev_interrupt,
+							SLOP_INTERRUPT,
+							SLOPE_INTERRUPT_Y_N);
+				if (i == 2)
+					input_report_rel(bma2x2->dev_interrupt,
+							SLOP_INTERRUPT,
+							SLOPE_INTERRUPT_Z_N);
+			} else {
+				if (i == 0)
+					input_report_rel(bma2x2->dev_interrupt,
+							SLOP_INTERRUPT,
+							SLOPE_INTERRUPT_X);
+				if (i == 1)
+					input_report_rel(bma2x2->dev_interrupt,
+							SLOP_INTERRUPT,
+							SLOPE_INTERRUPT_Y);
+				if (i == 2)
+					input_report_rel(bma2x2->dev_interrupt,
+							SLOP_INTERRUPT,
+							SLOPE_INTERRUPT_Z);
+
+			}
+		}
+
+		PINFO("Slop interrupt happened,exis is %d,"
+					"first is %d,sign is %d\n", i,
+						first_value, sign_value);
+	}
+}
+#endif
+
+static void bma2x2_irq_work_func(struct work_struct *work)
+{
+	struct bma2x2_data *bma2x2 = container_of((struct work_struct *)work,
+			struct bma2x2_data, irq_work);
+#ifdef CONFIG_DOUBLE_TAP
+	struct i2c_client *client = bma2x2->bma2x2_client;
+#endif
+
+	unsigned char status = 0;
+	unsigned char first_value = 0;
+	unsigned char sign_value = 0;
+
+#ifdef CONFIG_BMA_ENABLE_NEWDATA_INT
+	static struct bma2x2acc acc;
+
+	bma2x2_get_interruptstatus2(bma2x2->bma2x2_client, &status);
+
+	if ((status&0x80) == 0x80) {
+		/* PINFO("New data interrupt happened\n");*/
+		bma2x2_read_accel_xyz(bma2x2->bma2x2_client,
+					bma2x2->sensor_type, &acc);
+		input_report_abs(bma2x2->input, ABS_X, acc.x);
+		input_report_abs(bma2x2->input, ABS_Y, acc.y);
+		input_report_abs(bma2x2->input, ABS_Z, acc.z);
+		input_sync(bma2x2->input);
+		mutex_lock(&bma2x2->value_mutex);
+		bma2x2->value = acc;
+		mutex_unlock(&bma2x2->value_mutex);
+		return;
+	}
+#endif
+
+	bma2x2_get_interruptstatus1(bma2x2->bma2x2_client, &status);
+	PINFO("bma2x2_irq_work_func, status = 0x%x\n", status);
+
+#ifdef CONFIG_SIG_MOTION
+	if (status & 0x04)	{
+		if (atomic_read(&bma2x2->en_sig_motion) == 1) {
+			PINFO("Significant motion interrupt happened\n");
+			/* close sig sensor,
+			it will be open again if APP wants */
+			bma2x2_set_en_sig_motion(bma2x2, 0);
+
+			input_report_rel(bma2x2->dev_interrupt,
+				SLOP_INTERRUPT, 1);
+			input_sync(bma2x2->dev_interrupt);
+		}
+	}
+#endif
+
+#ifdef CONFIG_DOUBLE_TAP
+	if (status & 0x20) {
+		if (atomic_read(&bma2x2->en_double_tap) == 1) {
+			PINFO("single tap interrupt happened\n");
+			bma2x2_set_Int_Enable(client, 8, 0);
+			if (bma2x2->tap_times == 0)	{
+				mod_timer(&bma2x2->tap_timer, jiffies +
+				msecs_to_jiffies(bma2x2->tap_time_period));
+				bma2x2->tap_times = 1;
+			} else {
+				/* only double tap is judged */
+				PINFO("double tap\n");
+				mutex_lock(&bma2x2->tap_mutex);
+				bma2x2->tap_times = 0;
+				del_timer(&bma2x2->tap_timer);
+				mutex_unlock(&bma2x2->tap_mutex);
+				input_report_rel(bma2x2->dev_interrupt,
+					DOUBLE_TAP_INTERRUPT,
+					DOUBLE_TAP_INTERRUPT_HAPPENED);
+				input_sync(bma2x2->dev_interrupt);
+			}
+			bma2x2_set_Int_Enable(client, 8, 1);
+		}
+	}
+#endif
+
+	switch (status) {
+
+	case 0x01:
+		PINFO("Low G interrupt happened\n");
+		input_report_rel(bma2x2->dev_interrupt, LOW_G_INTERRUPT,
+				LOW_G_INTERRUPT_HAPPENED);
+		break;
+
+	case 0x02:
+		bma2x2_high_g_interrupt_handle(bma2x2);
+		break;
+
+#ifndef CONFIG_SIG_MOTION
+	case 0x04:
+		bma2x2_slope_interrupt_handle(bma2x2);
+		break;
+#endif
+
+	case 0x08:
+		PINFO("slow/ no motion interrupt happened\n");
+		input_report_rel(bma2x2->dev_interrupt,
+			SLOW_NO_MOTION_INTERRUPT,
+			SLOW_NO_MOTION_INTERRUPT_HAPPENED);
+		break;
+
+#ifndef CONFIG_DOUBLE_TAP
+	case 0x10:
+		PINFO("double tap interrupt happened\n");
+		input_report_rel(bma2x2->dev_interrupt,
+			DOUBLE_TAP_INTERRUPT,
+			DOUBLE_TAP_INTERRUPT_HAPPENED);
+		break;
+	case 0x20:
+		PINFO("single tap interrupt happened\n");
+		input_report_rel(bma2x2->dev_interrupt,
+			SINGLE_TAP_INTERRUPT,
+			SINGLE_TAP_INTERRUPT_HAPPENED);
+		break;
+#endif
+
+	case 0x40:
+		bma2x2_get_orient_status(bma2x2->bma2x2_client,
+				    &first_value);
+		PINFO("orient interrupt happened,%s\n",
+				orient[first_value]);
+		if (first_value == 0)
+			input_report_abs(bma2x2->dev_interrupt,
+			ORIENT_INTERRUPT,
+			UPWARD_PORTRAIT_UP_INTERRUPT_HAPPENED);
+		else if (first_value == 1)
+			input_report_abs(bma2x2->dev_interrupt,
+				ORIENT_INTERRUPT,
+				UPWARD_PORTRAIT_DOWN_INTERRUPT_HAPPENED);
+		else if (first_value == 2)
+			input_report_abs(bma2x2->dev_interrupt,
+				ORIENT_INTERRUPT,
+				UPWARD_LANDSCAPE_LEFT_INTERRUPT_HAPPENED);
+		else if (first_value == 3)
+			input_report_abs(bma2x2->dev_interrupt,
+				ORIENT_INTERRUPT,
+				UPWARD_LANDSCAPE_RIGHT_INTERRUPT_HAPPENED);
+		else if (first_value == 4)
+			input_report_abs(bma2x2->dev_interrupt,
+				ORIENT_INTERRUPT,
+				DOWNWARD_PORTRAIT_UP_INTERRUPT_HAPPENED);
+		else if (first_value == 5)
+			input_report_abs(bma2x2->dev_interrupt,
+				ORIENT_INTERRUPT,
+				DOWNWARD_PORTRAIT_DOWN_INTERRUPT_HAPPENED);
+		else if (first_value == 6)
+			input_report_abs(bma2x2->dev_interrupt,
+				ORIENT_INTERRUPT,
+				DOWNWARD_LANDSCAPE_LEFT_INTERRUPT_HAPPENED);
+		else if (first_value == 7)
+			input_report_abs(bma2x2->dev_interrupt,
+				ORIENT_INTERRUPT,
+				DOWNWARD_LANDSCAPE_RIGHT_INTERRUPT_HAPPENED);
+		break;
+	case 0x80:
+		bma2x2_get_orient_flat_status(bma2x2->bma2x2_client,
+				    &sign_value);
+		PINFO("flat interrupt happened,flat status is %d\n",
+				    sign_value);
+		if (sign_value == 1) {
+			input_report_abs(bma2x2->dev_interrupt,
+				FLAT_INTERRUPT,
+				FLAT_INTERRUPT_TURE_HAPPENED);
+		} else {
+			input_report_abs(bma2x2->dev_interrupt,
+				FLAT_INTERRUPT,
+				FLAT_INTERRUPT_FALSE_HAPPENED);
+		}
+		break;
+
+	default:
+		break;
+	}
+}
+
+static irqreturn_t bma2x2_irq_handler(int irq, void *handle)
+{
+	struct bma2x2_data *data = handle;
+
+	if (data == NULL)
+		return IRQ_HANDLED;
+	if (data->bma2x2_client == NULL)
+		return IRQ_HANDLED;
+
+	schedule_work(&data->irq_work);
+
+	return IRQ_HANDLED;
+}
+#endif /* defined(BMA2X2_ENABLE_INT1)||defined(BMA2X2_ENABLE_INT2) */
+
+static enum hrtimer_restart timer_handler(struct hrtimer *handle)
+{
+	struct bma2x2_data *client_data;
+
+	client_data = container_of(handle, struct bma2x2_data, timer);
+	queue_work(client_data->wq, &client_data->work);
+
+	hrtimer_forward_now(&client_data->timer, ktime_set(0, atomic_read(&client_data->delay) * 1000000));
+
+	return HRTIMER_RESTART;
+}
+
+static int bma2x2_probe(struct i2c_client *client,
+		const struct i2c_device_id *id)
+{
+	int err = 0;
+	struct bma2x2_data *data;
+	struct input_dev *dev;
+	struct bst_dev  *dev_acc;
+#if defined(BMA2X2_ENABLE_INT1) || defined(BMA2X2_ENABLE_INT2)
+	struct bosch_sensor_specific *pdata;
+#endif
+	struct input_dev *dev_interrupt;
+
+	PINFO("bma2x2_probe start\n");
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+		PERR("i2c_check_functionality error\n");
+		err = -EIO;
+		goto exit;
+	}
+	data = kzalloc(sizeof(struct bma2x2_data), GFP_KERNEL);
+	if (!data) {
+		err = -ENOMEM;
+		goto exit;
+	}
+
+	/* do soft reset */
+	mdelay(5);
+	if (bma2x2_soft_reset(client) < 0) {
+		PERR("i2c bus write error, pls check HW connection\n");
+		err = -EINVAL;
+		goto kfree_exit;
+	}
+	mdelay(5);
+	/* read and check chip id */
+	if (bma2x2_check_chip_id(client, data) < 0) {
+		err = -EINVAL;
+		goto kfree_exit;
+	}
+
+	i2c_set_clientdata(client, data);
+	data->bma2x2_client = client;
+	mutex_init(&data->value_mutex);
+	mutex_init(&data->mode_mutex);
+	mutex_init(&data->enable_mutex);
+	bma2x2_set_bandwidth(client, BMA2X2_BW_SET);
+	bma2x2_set_range(client, BMA2X2_RANGE_SET);
+
+
+#if defined(BMA2X2_ENABLE_INT1) || defined(BMA2X2_ENABLE_INT2)
+
+	pdata = client->dev.platform_data;
+	if (pdata) {
+		if (pdata->irq_gpio_cfg && (pdata->irq_gpio_cfg() < 0)) {
+			PERR("IRQ GPIO conf. error %d\n",
+				client->irq);
+		}
+	}
+
+#ifdef BMA2X2_ENABLE_INT1
+	/* maps interrupt to INT1 pin */
+	bma2x2_set_int1_pad_sel(client, PAD_LOWG);
+	bma2x2_set_int1_pad_sel(client, PAD_HIGHG);
+	bma2x2_set_int1_pad_sel(client, PAD_SLOP);
+	bma2x2_set_int1_pad_sel(client, PAD_DOUBLE_TAP);
+	bma2x2_set_int1_pad_sel(client, PAD_SINGLE_TAP);
+	bma2x2_set_int1_pad_sel(client, PAD_ORIENT);
+	bma2x2_set_int1_pad_sel(client, PAD_FLAT);
+	bma2x2_set_int1_pad_sel(client, PAD_SLOW_NO_MOTION);
+#ifdef CONFIG_BMA_ENABLE_NEWDATA_INT
+	bma2x2_set_newdata(client, BMA2X2_INT1_NDATA, 1);
+	bma2x2_set_newdata(client, BMA2X2_INT2_NDATA, 0);
+#endif
+#endif
+
+#ifdef BMA2X2_ENABLE_INT2
+	/* maps interrupt to INT2 pin */
+	bma2x2_set_int2_pad_sel(client, PAD_LOWG);
+	bma2x2_set_int2_pad_sel(client, PAD_HIGHG);
+	bma2x2_set_int2_pad_sel(client, PAD_SLOP);
+	bma2x2_set_int2_pad_sel(client, PAD_DOUBLE_TAP);
+	bma2x2_set_int2_pad_sel(client, PAD_SINGLE_TAP);
+	bma2x2_set_int2_pad_sel(client, PAD_ORIENT);
+	bma2x2_set_int2_pad_sel(client, PAD_FLAT);
+	bma2x2_set_int2_pad_sel(client, PAD_SLOW_NO_MOTION);
+#ifdef CONFIG_BMA_ENABLE_NEWDATA_INT
+	bma2x2_set_newdata(client, BMA2X2_INT1_NDATA, 0);
+	bma2x2_set_newdata(client, BMA2X2_INT2_NDATA, 1);
+#endif
+#endif
+
+	bma2x2_set_Int_Mode(client, 1);/*latch interrupt 250ms*/
+
+	/* do not open any interrupt here  */
+	/*10,orient
+	11,flat*/
+	/* bma2x2_set_Int_Enable(client, 10, 1);	*/
+	/* bma2x2_set_Int_Enable(client, 11, 1); */
+
+#ifdef CONFIG_BMA_ENABLE_NEWDATA_INT
+	/* enable new data interrupt */
+	bma2x2_set_Int_Enable(client, 4, 1);
+#endif
+
+
+	data->IRQ = client->irq;
+	err = request_irq(data->IRQ, bma2x2_irq_handler, IRQF_TRIGGER_RISING,
+			"bma2x2", data);
+#ifdef CONFIG_SIG_MOTION
+	enable_irq_wake(data->IRQ);
+#endif
+	if (err)
+		PERR("could not request irq\n");
+
+	INIT_WORK(&data->irq_work, bma2x2_irq_work_func);
+#endif
+
+#ifndef CONFIG_BMA_ENABLE_NEWDATA_INT
+	//INIT_DELAYED_WORK(&data->work, bma2x2_work_func);
+	INIT_WORK(&data->work, bma2x2_work_func);
+	data->wq = create_workqueue("bma_wq");
+	hrtimer_init(&data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+	data->timer.function = timer_handler;
+#endif
+	atomic_set(&data->delay, BMA2X2_MAX_DELAY);
+	atomic_set(&data->enable, 0);
+
+	dev = input_allocate_device();
+	if (!dev)
+		return -ENOMEM;
+
+	dev_interrupt = input_allocate_device();
+	if (!dev_interrupt) {
+		kfree(data);
+		input_free_device(dev); /*free the successful dev and return*/
+		return -ENOMEM;
+	}
+
+	/* only value events reported */
+	dev->name = SENSOR_NAME;
+	dev->id.bustype = BUS_I2C;
+#if 0
+	input_set_capability(dev, EV_ABS, ABS_MISC);
+	input_set_abs_params(dev, ABS_X, ABSMIN, ABSMAX, 0, 0);
+	input_set_abs_params(dev, ABS_Y, ABSMIN, ABSMAX, 0, 0);
+	input_set_abs_params(dev, ABS_Z, ABSMIN, ABSMAX, 0, 0);
+#else
+	input_set_capability(dev, EV_MSC, MSC_RAW);
+	input_set_capability(dev, EV_MSC, MSC_SCAN);
+	input_set_capability(dev, EV_MSC, MSC_GESTURE);
+#endif
+
+	input_set_drvdata(dev, data);
+	err = input_register_device(dev);
+	if (err < 0)
+		goto err_register_input_device;
+
+	/* all interrupt generated events are moved to interrupt input devices*/
+	dev_interrupt->name = "bma_interrupt";
+	dev_interrupt->id.bustype = BUS_I2C;
+	input_set_capability(dev_interrupt, EV_REL,
+		SLOW_NO_MOTION_INTERRUPT);
+	input_set_capability(dev_interrupt, EV_REL,
+		LOW_G_INTERRUPT);
+	input_set_capability(dev_interrupt, EV_REL,
+		HIGH_G_INTERRUPT);
+	input_set_capability(dev_interrupt, EV_REL,
+		SLOP_INTERRUPT);
+	input_set_capability(dev_interrupt, EV_REL,
+		DOUBLE_TAP_INTERRUPT);
+	input_set_capability(dev_interrupt, EV_REL,
+		SINGLE_TAP_INTERRUPT);
+	input_set_capability(dev_interrupt, EV_ABS,
+		ORIENT_INTERRUPT);
+	input_set_capability(dev_interrupt, EV_ABS,
+		FLAT_INTERRUPT);
+	input_set_drvdata(dev_interrupt, data);
+
+	err = input_register_device(dev_interrupt);
+	if (err < 0)
+		goto err_register_input_device_interrupt;
+
+	data->dev_interrupt = dev_interrupt;
+	data->input = dev;
+
+#ifdef CONFIG_SIG_MOTION
+	data->g_sensor_class = class_create(THIS_MODULE, "sig_sensor");
+	if (IS_ERR(data->g_sensor_class)) {
+		err = PTR_ERR(data->g_sensor_class);
+		data->g_sensor_class = NULL;
+		PERR("could not allocate g_sensor_class\n");
+		goto err_create_class;
+	}
+
+	data->g_sensor_dev = device_create(data->g_sensor_class,
+				NULL, 0, "%s", "g_sensor");
+	if (unlikely(IS_ERR(data->g_sensor_dev))) {
+		err = PTR_ERR(data->g_sensor_dev);
+		data->g_sensor_dev = NULL;
+
+		PERR("could not allocate g_sensor_dev\n");
+		goto err_create_g_sensor_device;
+	}
+
+	dev_set_drvdata(data->g_sensor_dev, data);
+
+	err = sysfs_create_group(&data->g_sensor_dev->kobj,
+			&bma2x2_sig_motion_attribute_group);
+	if (err < 0)
+		goto error_sysfs;
+#endif
+
+
+#ifdef CONFIG_DOUBLE_TAP
+	data->g_sensor_class_doubletap =
+		class_create(THIS_MODULE, "dtap_sensor");
+	if (IS_ERR(data->g_sensor_class_doubletap)) {
+		err = PTR_ERR(data->g_sensor_class_doubletap);
+		data->g_sensor_class_doubletap = NULL;
+		PERR("could not allocate g_sensor_class_doubletap\n");
+		goto err_create_class;
+	}
+
+
+	data->g_sensor_dev_doubletap = device_create(
+				data->g_sensor_class_doubletap,
+				NULL, 0, "%s", "g_sensor");
+	if (unlikely(IS_ERR(data->g_sensor_dev_doubletap))) {
+		err = PTR_ERR(data->g_sensor_dev_doubletap);
+		data->g_sensor_dev_doubletap = NULL;
+
+		PERR("could not allocate g_sensor_dev_doubletap\n");
+		goto err_create_g_sensor_device_double_tap;
+	}
+
+
+	dev_set_drvdata(data->g_sensor_dev_doubletap, data);
+
+	err = sysfs_create_group(&data->g_sensor_dev_doubletap->kobj,
+			&bma2x2_double_tap_attribute_group);
+	if (err < 0)
+		goto error_sysfs;
+#endif
+
+
+	err = sysfs_create_group(&data->input->dev.kobj,
+			&bma2x2_attribute_group);
+	if (err < 0)
+		goto error_sysfs;
+
+	dev_acc = bst_allocate_device();
+	if (!dev_acc) {
+		err = -ENOMEM;
+		goto error_sysfs;
+	}
+	dev_acc->name = ACC_NAME;
+
+	bst_set_drvdata(dev_acc, data);
+
+	err = bst_register_device(dev_acc);
+	if (err < 0)
+		goto bst_free_acc_exit;
+
+	data->bst_acc = dev_acc;
+	err = sysfs_create_group(&data->bst_acc->dev.kobj,
+			&bma2x2_attribute_group);
+
+	if (err < 0)
+		goto bst_free_exit;
+
+#if 0
+	if (NULL != client->dev.platform_data) {
+		data->bst_pd = kzalloc(sizeof(*data->bst_pd),
+				GFP_KERNEL);
+
+		if (NULL != data->bst_pd) {
+			memcpy(data->bst_pd, client->dev.platform_data,
+					sizeof(*data->bst_pd));
+			PINFO("%s sensor driver set place: p%d",
+				data->bst_pd->name, data->bst_pd->place);
+		}
+	}
+#endif
+
+    data->bst_pd = kzalloc(sizeof(*data->bst_pd),
+			GFP_KERNEL);
+
+	if (NULL != data->bst_pd) {
+		data->bst_pd->place=BOSCH_SENSOR_PLACE;
+	}
+
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
+	data->early_suspend.suspend = bma2x2_early_suspend;
+	data->early_suspend.resume = bma2x2_late_resume;
+	register_early_suspend(&data->early_suspend);
+#endif
+
+	data->bma_mode_enabled = 0;
+	data->fifo_datasel = 0;
+	data->fifo_count = 0;
+
+	
+#ifdef CONFIG_SIG_MOTION
+	atomic_set(&data->en_sig_motion, 0);
+#endif
+#ifdef CONFIG_DOUBLE_TAP
+	atomic_set(&data->en_double_tap, 0);
+	data->tap_times = 0;
+	data->tap_time_period = DEFAULT_TAP_JUDGE_PERIOD;
+	mutex_init(&data->tap_mutex);
+	setup_timer(&data->tap_timer, bma2x2_tap_timeout_handle,
+			(unsigned long)data);
+#endif
+
+	if (bma2x2_set_mode(client, BMA2X2_MODE_SUSPEND, BMA_ENABLED_ALL) < 0)
+		return -EINVAL;
+	PINFO("BMA2x2 driver probe successfully");
+
+	return 0;
+
+bst_free_exit:
+	bst_unregister_device(dev_acc);
+
+bst_free_acc_exit:
+	bst_free_device(dev_acc);
+
+error_sysfs:
+	input_unregister_device(data->input);
+
+#ifdef CONFIG_DOUBLE_TAP
+err_create_g_sensor_device_double_tap:
+	class_destroy(data->g_sensor_class_doubletap);
+#endif
+
+#ifdef CONFIG_SIG_MOTION
+err_create_g_sensor_device:
+	class_destroy(data->g_sensor_class);
+#endif
+
+#if defined(CONFIG_SIG_MOTION) || defined(CONFIG_DOUBLE_TAP)
+err_create_class:
+	input_unregister_device(data->dev_interrupt);
+#endif
+
+err_register_input_device_interrupt:
+	input_free_device(dev_interrupt);
+	input_unregister_device(data->input);
+
+err_register_input_device:
+	input_free_device(dev);
+
+kfree_exit:
+	if ((NULL != data) && (NULL != data->bst_pd)) {
+		kfree(data->bst_pd);
+		data->bst_pd = NULL;
+	}
+	kfree(data);
+exit:
+	return err;
+}
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+static void bma2x2_early_suspend(struct early_suspend *h)
+{
+	struct bma2x2_data *data =
+		container_of(h, struct bma2x2_data, early_suspend);
+
+	mutex_lock(&data->enable_mutex);
+	if (atomic_read(&data->enable) == 1) {
+		bma2x2_set_mode(data->bma2x2_client,
+			BMA2X2_MODE_SUSPEND, BMA_ENABLED_INPUT);
+#ifndef CONFIG_BMA_ENABLE_NEWDATA_INT
+//		cancel_delayed_work_sync(&data->work);
+		cancel_work_sync(&data->work);
+#endif
+	}
+	mutex_unlock(&data->enable_mutex);
+}
+
+static void bma2x2_late_resume(struct early_suspend *h)
+{
+	struct bma2x2_data *data =
+		container_of(h, struct bma2x2_data, early_suspend);
+	if (NULL == data)
+		return;
+
+	mutex_lock(&data->enable_mutex);
+	if (atomic_read(&data->enable) == 1) {
+		bma2x2_set_mode(data->bma2x2_client,
+			BMA2X2_MODE_NORMAL, BMA_ENABLED_INPUT);
+#ifndef CONFIG_BMA_ENABLE_NEWDATA_INT
+//		schedule_delayed_work(&data->work,
+//				msecs_to_jiffies(atomic_read(&data->delay)));
+		schedule_work(&data->work);
+#endif
+	}
+	mutex_unlock(&data->enable_mutex);
+}
+#endif
+
+static int bma2x2_remove(struct i2c_client *client)
+{
+	struct bma2x2_data *data = i2c_get_clientdata(client);
+
+	if (NULL == data)
+		return 0;
+
+	bma2x2_set_enable(&client->dev, 0);
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	unregister_early_suspend(&data->early_suspend);
+#endif
+	sysfs_remove_group(&data->input->dev.kobj, &bma2x2_attribute_group);
+	input_unregister_device(data->input);
+
+	if (NULL != data->bst_pd) {
+		kfree(data->bst_pd);
+		data->bst_pd = NULL;
+	}
+
+	kfree(data);
+	return 0;
+}
+
+void bma2x2_shutdown(struct i2c_client *client)
+{
+	struct bma2x2_data *data = i2c_get_clientdata(client);
+
+	mutex_lock(&data->enable_mutex);
+	bma2x2_set_mode(data->bma2x2_client,
+		BMA2X2_MODE_DEEP_SUSPEND, BMA_ENABLED_ALL);
+	mutex_unlock(&data->enable_mutex);
+}
+
+#ifdef CONFIG_PM
+static int bma2x2_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+	struct bma2x2_data *data = i2c_get_clientdata(client);
+
+	mutex_lock(&data->enable_mutex);
+	if (atomic_read(&data->enable) == 1) {
+		bma2x2_set_mode(data->bma2x2_client,
+			BMA2X2_MODE_SUSPEND, BMA_ENABLED_INPUT);
+#ifndef CONFIG_BMA_ENABLE_NEWDATA_INT
+//		cancel_delayed_work_sync(&data->work);
+		cancel_work_sync(&data->work);
+
+#endif
+	}
+	mutex_unlock(&data->enable_mutex);
+
+	return 0;
+}
+
+static int bma2x2_resume(struct i2c_client *client)
+{
+	struct bma2x2_data *data = i2c_get_clientdata(client);
+
+	mutex_lock(&data->enable_mutex);
+	if (atomic_read(&data->enable) == 1) {
+		bma2x2_set_mode(data->bma2x2_client,
+			BMA2X2_MODE_NORMAL, BMA_ENABLED_INPUT);
+#ifndef CONFIG_BMA_ENABLE_NEWDATA_INT
+//		schedule_delayed_work(&data->work,
+//				msecs_to_jiffies(atomic_read(&data->delay)));
+		schedule_work(&data->work);
+#endif
+	}
+	mutex_unlock(&data->enable_mutex);
+
+	return 0;
+}
+
+#else
+
+#define bma2x2_suspend      NULL
+#define bma2x2_resume       NULL
+
+#endif /* CONFIG_PM */
+
+static const struct i2c_device_id bma2x2_id[] = {
+	{ SENSOR_NAME, 0 },
+	{ }
+};
+
+MODULE_DEVICE_TABLE(i2c, bma2x2_id);
+
+
+static struct of_device_id bst_match_table[] = {
+        { .compatible = "bst,bma2x2", },
+        { },
+};
+
+static struct i2c_driver bma2x2_driver = {
+	.driver = {
+		.owner  = THIS_MODULE,
+		.name   = SENSOR_NAME,
+#ifdef CONFIG_OF
+                .of_match_table = bst_match_table,
+#endif
+	},
+	.suspend    = bma2x2_suspend,
+	.resume     = bma2x2_resume,
+	.id_table   = bma2x2_id,
+	.probe      = bma2x2_probe,
+	.remove     = bma2x2_remove,
+	.shutdown   = bma2x2_shutdown,
+};
+
+static struct bosch_sensor_specific __initdata bma2x2_pdata = {
+	.name   = "bma2x2",
+	.place  = 0,
+};
+
+static struct i2c_board_info __initdata sprd_i2c_bst = {
+   	   I2C_BOARD_INFO("bma2x2", 0x18),
+       .platform_data	= &bma2x2_pdata,
+};
+
+static int __init BMA2X2_init(void)
+{
+	return i2c_add_driver(&bma2x2_driver);
+}
+
+static void __exit BMA2X2_exit(void)
+{
+	i2c_del_driver(&bma2x2_driver);
+}
+
+MODULE_AUTHOR("contact@bosch-sensortec.com");
+MODULE_DESCRIPTION("BMA2X2 ACCELEROMETER SENSOR DRIVER");
+MODULE_LICENSE("GPL v2");
+
+//module_init(BMA2X2_init);
+late_initcall(BMA2X2_init);
+module_exit(BMA2X2_exit);
+
diff --git a/drivers/input/misc/bs_log.h b/drivers/input/misc/bs_log.h
new file mode 100644
index 00000000..0d3af001
--- /dev/null
+++ b/drivers/input/misc/bs_log.h
@@ -0,0 +1,167 @@
+/*!
+ * @section LICENSE
+ * $license$
+ *
+ * @filename $filename$
+ * @date     $date$
+ * @id       $id$
+ *
+ * @brief
+ * The head file of BOSCH SENSOR LOG
+*/
+
+#ifndef __BS_LOG_H
+#define __BS_LOG_H
+
+#include <linux/kernel.h>
+
+/*! @ trace functions
+ @{*/
+/*! ERROR LOG LEVEL */
+#define LOG_LEVEL_E 3
+/*! NOTICE LOG LEVEL */
+#define LOG_LEVEL_N 5
+/*! INFORMATION LOG LEVEL */
+#define LOG_LEVEL_I 6
+/*! DEBUG LOG LEVEL */
+#define LOG_LEVEL_D 7
+/*! DEBUG_FWDL LOG LEVEL */
+#define LOG_LEVEL_DF 10
+/*! DEBUG_DATA LOG LEVEL */
+#define LOG_LEVEL_DA 15
+/*! ALL LOG LEVEL */
+#define LOG_LEVEL_A 20
+
+#ifndef MODULE_TAG
+/*! MODULE TAG DEFINATION */
+#define MODULE_TAG "<BS_LOG>"
+#endif
+
+#ifndef LOG_LEVEL
+/*! LOG LEVEL DEFINATION */
+#define LOG_LEVEL LOG_LEVEL_I
+#endif
+
+#ifdef BOSCH_DRIVER_LOG_FUNC
+	#ifdef BSLOG_VAR_DEF
+		uint8_t debug_log_level = LOG_LEVEL;
+	#else
+		extern uint8_t debug_log_level;
+	#endif
+
+	/*! print error message */
+	#define PERR(fmt, args...) do\
+	{\
+		if (debug_log_level >= LOG_LEVEL_E)\
+			printk(KERN_INFO "\n" "[E]" KERN_ERR MODULE_TAG \
+				"<%s><%d>" fmt "\n", __func__, __LINE__, ##args);\
+	} while (0)
+
+	/*! print notice message */
+	#define PNOTICE(fmt, args...) do\
+	{\
+		if (debug_log_level >= LOG_LEVEL_N)\
+			printk(KERN_INFO "\n" "[N]" KERN_NOTICE MODULE_TAG \
+				"<%s><%d>" fmt "\n", __func__, __LINE__, ##args);\
+	} while (0)
+
+	/*! print information message */
+	#define PINFO(fmt, args...) do\
+	{\
+		if (debug_log_level >= LOG_LEVEL_I)\
+			printk(KERN_INFO "\n" "[I]" KERN_INFO MODULE_TAG \
+				"<%s><%d>" fmt "\n", __func__, __LINE__, ##args);\
+	} while (0)
+
+	/*! print debug message */
+	#define PDEBUG(fmt, args...) do\
+	{\
+		if (debug_log_level >= LOG_LEVEL_D)\
+			printk(KERN_INFO "\n" "[D]" KERN_DEBUG MODULE_TAG \
+				"<%s><%d>" fmt "\n", __func__, __LINE__, ##args);\
+	} while (0)
+
+	/*! print debug fw download message */
+	#define PDEBUG_FWDL(fmt, args...) do\
+	{\
+		if (debug_log_level >= LOG_LEVEL_DF)\
+			printk(KERN_INFO "\n" "[DF]" KERN_DEBUG MODULE_TAG \
+				"<%s><%d>" fmt "\n", __func__, __LINE__, ##args);\
+	} while (0)
+
+	/*! print debug data log message */
+	#define PDEBUG_DLOG(fmt, args...) do\
+	{\
+		if (debug_log_level >= LOG_LEVEL_DA)\
+			printk(KERN_INFO "\n" "[DA]" KERN_DEBUG MODULE_TAG \
+				"<%s><%d>" fmt "\n", __func__, __LINE__, ##args);\
+	} while (0)
+
+	void set_debug_log_level(uint8_t level);
+	uint8_t get_debug_log_level(void);
+
+#else
+
+	#if (LOG_LEVEL >= LOG_LEVEL_E)
+	/*! print error message */
+	#define PERR(fmt, args...) \
+		printk(KERN_INFO "\n" "[E]" KERN_ERR MODULE_TAG \
+		"<%s><%d>" fmt "\n", __func__, __LINE__, ##args)
+	#else
+	/*! invalid message */
+	#define PERR(fmt, args...)
+	#endif
+
+	#if (LOG_LEVEL >= LOG_LEVEL_N)
+	/*! print notice message */
+	#define PNOTICE(fmt, args...) \
+		printk(KERN_INFO "\n" "[N]" KERN_NOTICE MODULE_TAG \
+		"<%s><%d>" fmt "\n", __func__, __LINE__, ##args)
+	#else
+	/*! invalid message */
+	#define PNOTICE(fmt, args...)
+	#endif
+
+	#if (LOG_LEVEL >= LOG_LEVEL_I)
+	/*! print information message */
+	#define PINFO(fmt, args...) printk(KERN_INFO "\n" "[I]" KERN_INFO MODULE_TAG \
+		"<%s><%d>" fmt "\n", __func__, __LINE__, ##args)
+	#else
+	/*! invalid message */
+	#define PINFO(fmt, args...)
+	#endif
+
+	#if (LOG_LEVEL >= LOG_LEVEL_D)
+	/*! print debug message */
+	#define PDEBUG(fmt, args...) printk(KERN_INFO "\n" "[D]" KERN_DEBUG MODULE_TAG \
+		"<%s><%d>" fmt "\n", __func__, __LINE__, ##args)
+	#else
+	/*! invalid message */
+	#define PDEBUG(fmt, args...)
+	#endif
+
+	#if (LOG_LEVEL >= LOG_LEVEL_DF)
+	/*! print debug fw download message */
+	#define PDEBUG_FWDL(fmt, args...) printk(KERN_INFO "\n" "[DF]" KERN_DEBUG MODULE_TAG \
+		"<%s><%d>" fmt "\n", __func__, __LINE__, ##args)
+	#else
+	/*! invalid message */
+	#define PDEBUG_FWDL(fmt, args...)
+	#endif
+
+	#if (LOG_LEVEL >= LOG_LEVEL_DA)
+	/*! print debug data log message */
+	#define PDEBUG_DLOG(fmt, args...) printk(KERN_INFO "\n" "[DA]" KERN_DEBUG MODULE_TAG \
+		"<%s><%d>" fmt "\n", __func__, __LINE__, ##args)
+	#else
+	/*! invalid message */
+	#define PDEBUG_DLOG(fmt, args...)
+	#endif
+
+	#define set_debug_log_level(level) {}
+	#define get_debug_log_level() (LOG_LEVEL)
+
+#endif
+
+#endif/*__BS_LOG_H*/
+/*@}*/
diff --git a/drivers/input/misc/bstclass.c b/drivers/input/misc/bstclass.c
new file mode 100644
index 00000000..11c3c39d
--- /dev/null
+++ b/drivers/input/misc/bstclass.c
@@ -0,0 +1,234 @@
+/*!
+ * @section LICENSE
+ * $license$
+ *
+ * @filename $filename$
+ * @date     $date$
+ * @id       $id$
+ *
+ * @brief
+ * The core code of bst device driver
+*/
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/random.h>
+#include <linux/sched.h>
+#include <linux/seq_file.h>
+#include <linux/poll.h>
+#include <linux/mutex.h>
+#include <linux/rcupdate.h>
+#include <linux/compiler.h>
+#include <linux/compat.h>
+#include "bstclass.h"
+#include "bs_log.h"
+
+static LIST_HEAD(bst_dev_list);
+
+/*
+ * bst_mutex protects access to both bst_dev_list and input_handler_list.
+ * This also causes bst_[un]register_device and bst_[un]register_handler
+ * be mutually exclusive which simplifies locking in drivers implementing
+ * input handlers.
+ */
+static DEFINE_MUTEX(bst_mutex);
+
+
+static void bst_dev_release(struct device *device)
+{
+	struct bst_dev *dev = to_bst_dev(device);
+	if (NULL != dev)
+		kfree(dev);
+	module_put(THIS_MODULE);
+}
+
+
+#ifdef CONFIG_PM
+static int bst_dev_suspend(struct device *dev)
+{
+	return 0;
+}
+
+static int bst_dev_resume(struct device *dev)
+{
+	return 0;
+}
+
+static const struct dev_pm_ops bst_dev_pm_ops = {
+	.suspend    = bst_dev_suspend,
+	.resume     = bst_dev_resume,
+	.poweroff   = bst_dev_suspend,
+	.restore    = bst_dev_resume,
+};
+#endif /* CONFIG_PM */
+
+static const struct attribute_group *bst_dev_attr_groups[] = {
+	NULL
+};
+
+static struct device_type bst_dev_type = {
+	.groups      = bst_dev_attr_groups,
+	.release = bst_dev_release,
+#ifdef CONFIG_PM
+	.pm      = &bst_dev_pm_ops,
+#endif
+};
+
+
+
+static char *bst_devnode(struct device *dev, mode_t *mode)
+{
+	return kasprintf(GFP_KERNEL, "%s", dev_name(dev));
+}
+
+struct class bst_class = {
+	.name        = "bst",
+	.owner       = THIS_MODULE,
+	.devnode     = bst_devnode,
+	.dev_release = bst_dev_release,
+};
+EXPORT_SYMBOL_GPL(bst_class);
+
+/**
+ * bst_allocate_device - allocate memory for new input device
+ *
+ * Returns prepared struct bst_dev or NULL.
+ *
+ * NOTE: Use bst_free_device() to free devices that have not been
+ * registered; bst_unregister_device() should be used for already
+ * registered devices.
+ */
+struct bst_dev *bst_allocate_device(void)
+{
+	struct bst_dev *dev;
+
+	dev = kzalloc(sizeof(struct bst_dev), GFP_KERNEL);
+	if (dev) {
+		dev->dev.type = &bst_dev_type;
+		dev->dev.class = &bst_class;
+		device_initialize(&dev->dev);
+		mutex_init(&dev->mutex);
+		INIT_LIST_HEAD(&dev->node);
+		__module_get(THIS_MODULE);
+	}
+	return dev;
+}
+EXPORT_SYMBOL(bst_allocate_device);
+
+
+
+/**
+ * bst_free_device - free memory occupied by bst_dev structure
+ * @dev: input device to free
+ *
+ * This function should only be used if bst_register_device()
+ * was not called yet or if it failed. Once device was registered
+ * use bst_unregister_device() and memory will be freed once last
+ * reference to the device is dropped.
+ *
+ * Device should be allocated by bst_allocate_device().
+ *
+ * NOTE: If there are references to the input device then memory
+ * will not be freed until last reference is dropped.
+ */
+void bst_free_device(struct bst_dev *dev)
+{
+	if (dev)
+		bst_put_device(dev);
+}
+EXPORT_SYMBOL(bst_free_device);
+
+/**
+ * bst_register_device - register device with input core
+ * @dev: device to be registered
+ *
+ * This function registers device with input core. The device must be
+ * allocated with bst_allocate_device() and all it's capabilities
+ * set up before registering.
+ * If function fails the device must be freed with bst_free_device().
+ * Once device has been successfully registered it can be unregistered
+ * with bst_unregister_device(); bst_free_device() should not be
+ * called in this case.
+ */
+int bst_register_device(struct bst_dev *dev)
+{
+	const char *path;
+	int error;
+
+
+	/*
+	 * If delay and period are pre-set by the driver, then autorepeating
+	 * is handled by the driver itself and we don't do it in input.c.
+	 */
+	dev_set_name(&dev->dev, dev->name);
+
+	error = device_add(&dev->dev);
+	if (error)
+		return error;
+
+	path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
+	PINFO("%s as %s\n",
+			dev->name ? dev->name : "Unspecified device",
+			path ? path : "N/A");
+	kfree(path);
+	error = mutex_lock_interruptible(&bst_mutex);
+	if (error) {
+		device_del(&dev->dev);
+		return error;
+	}
+
+	list_add_tail(&dev->node, &bst_dev_list);
+
+	mutex_unlock(&bst_mutex);
+	return 0;
+}
+EXPORT_SYMBOL(bst_register_device);
+
+/**
+ * bst_unregister_device - unregister previously registered device
+ * @dev: device to be unregistered
+ *
+ * This function unregisters an input device. Once device is unregistered
+ * the caller should not try to access it as it may get freed at any moment.
+ */
+void bst_unregister_device(struct bst_dev *dev)
+{
+	int ret = 0;
+	ret = mutex_lock_interruptible(&bst_mutex);
+	if(ret){
+		return;
+	}
+
+	list_del_init(&dev->node);
+	mutex_unlock(&bst_mutex);
+	device_unregister(&dev->dev);
+}
+EXPORT_SYMBOL(bst_unregister_device);
+
+static int __init bst_init(void)
+{
+	int err;
+	/*bst class register*/
+	err = class_register(&bst_class);
+	if (err) {
+		pr_err("unable to register bst_dev class\n");
+		return err;
+	}
+	return err;
+}
+
+static void __exit bst_exit(void)
+{
+	/*bst class*/
+	class_unregister(&bst_class);
+}
+
+/*subsys_initcall(bst_init);*/
+
+MODULE_AUTHOR("contact@bosch-sensortec.com");
+MODULE_DESCRIPTION("BST CLASS CORE");
+MODULE_LICENSE("GPL V2");
+
+module_init(bst_init);
+module_exit(bst_exit);
diff --git a/drivers/input/misc/bstclass.h b/drivers/input/misc/bstclass.h
new file mode 100644
index 00000000..2291cca0
--- /dev/null
+++ b/drivers/input/misc/bstclass.h
@@ -0,0 +1,74 @@
+/*!
+ * @section LICENSE
+ * $license$
+ *
+ * @filename $filename$
+ * @date     $date$
+ * @id       $id$
+ *
+ * @brief
+ * The core code of bst device driver
+*/
+
+#ifndef _BSTCLASS_H
+#define _BSTCLASS_H
+
+#ifdef __KERNEL__
+#include <linux/time.h>
+#include <linux/list.h>
+#else
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <linux/types.h>
+#endif
+
+#include <linux/device.h>
+#include <linux/fs.h>
+#include <linux/mod_devicetable.h>
+
+struct bst_dev {
+	const char *name;
+
+	int (*open)(struct bst_dev *dev);
+	void (*close)(struct bst_dev *dev);
+	struct mutex mutex;
+	struct device dev;
+	struct list_head node;
+};
+
+#define to_bst_dev(d) container_of(d, struct bst_dev, dev)
+
+struct bst_dev *bst_allocate_device(void);
+void bst_free_device(struct bst_dev *dev);
+
+static inline struct bst_dev *bst_get_device(struct bst_dev *dev)
+{
+	return dev ? to_bst_dev(get_device(&dev->dev)) : NULL;
+}
+
+static inline void bst_put_device(struct bst_dev *dev)
+{
+	if (dev)
+		put_device(&dev->dev);
+}
+
+static inline void *bst_get_drvdata(struct bst_dev *dev)
+{
+	return dev_get_drvdata(&dev->dev);
+}
+
+static inline void bst_set_drvdata(struct bst_dev *dev, void *data)
+{
+	dev_set_drvdata(&dev->dev, data);
+}
+
+int __must_check bst_register_device(struct bst_dev *);
+void bst_unregister_device(struct bst_dev *);
+
+void bst_reset_device(struct bst_dev *);
+
+
+extern struct class bst_class;
+
+#endif
diff --git a/drivers/input/misc/cm109.c b/drivers/input/misc/cm109.c
new file mode 100644
index 00000000..082684e7
--- /dev/null
+++ b/drivers/input/misc/cm109.c
@@ -0,0 +1,918 @@
+/*
+ * Driver for the VoIP USB phones with CM109 chipsets.
+ *
+ * Copyright (C) 2007 - 2008 Alfred E. Heggestad <aeh@db.org>
+ *
+ *	This program is free software; you can redistribute it and/or
+ *	modify it under the terms of the GNU General Public License as
+ *	published by the Free Software Foundation, version 2.
+ */
+
+/*
+ *   Tested devices:
+ *	- Komunikate KIP1000
+ *	- Genius G-talk
+ *	- Allied-Telesis Corega USBPH01
+ *	- ...
+ *
+ * This driver is based on the yealink.c driver
+ *
+ * Thanks to:
+ *   - Authors of yealink.c
+ *   - Thomas Reitmayr
+ *   - Oliver Neukum for good review comments and code
+ *   - Shaun Jackman <sjackman@gmail.com> for Genius G-talk keymap
+ *   - Dmitry Torokhov for valuable input and review
+ *
+ * Todo:
+ *   - Read/write EEPROM
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/rwsem.h>
+#include <linux/usb/input.h>
+
+#define DRIVER_VERSION "20080805"
+#define DRIVER_AUTHOR  "Alfred E. Heggestad"
+#define DRIVER_DESC    "CM109 phone driver"
+
+static char *phone = "kip1000";
+module_param(phone, charp, S_IRUSR);
+MODULE_PARM_DESC(phone, "Phone name {kip1000, gtalk, usbph01, atcom}");
+
+enum {
+	/* HID Registers */
+	HID_IR0 = 0x00, /* Record/Playback-mute button, Volume up/down  */
+	HID_IR1 = 0x01, /* GPI, generic registers or EEPROM_DATA0       */
+	HID_IR2 = 0x02, /* Generic registers or EEPROM_DATA1            */
+	HID_IR3 = 0x03, /* Generic registers or EEPROM_CTRL             */
+	HID_OR0 = 0x00, /* Mapping control, buzzer, SPDIF (offset 0x04) */
+	HID_OR1 = 0x01, /* GPO - General Purpose Output                 */
+	HID_OR2 = 0x02, /* Set GPIO to input/output mode                */
+	HID_OR3 = 0x03, /* SPDIF status channel or EEPROM_CTRL          */
+
+	/* HID_IR0 */
+	RECORD_MUTE   = 1 << 3,
+	PLAYBACK_MUTE = 1 << 2,
+	VOLUME_DOWN   = 1 << 1,
+	VOLUME_UP     = 1 << 0,
+
+	/* HID_OR0 */
+	/* bits 7-6
+	   0: HID_OR1-2 are used for GPO; HID_OR0, 3 are used for buzzer
+	      and SPDIF
+	   1: HID_OR0-3 are used as generic HID registers
+	   2: Values written to HID_OR0-3 are also mapped to MCU_CTRL,
+	      EEPROM_DATA0-1, EEPROM_CTRL (see Note)
+	   3: Reserved
+	 */
+	HID_OR_GPO_BUZ_SPDIF   = 0 << 6,
+	HID_OR_GENERIC_HID_REG = 1 << 6,
+	HID_OR_MAP_MCU_EEPROM  = 2 << 6,
+
+	BUZZER_ON = 1 << 5,
+
+	/* up to 256 normal keys, up to 16 special keys */
+	KEYMAP_SIZE = 256 + 16,
+};
+
+/* CM109 protocol packet */
+struct cm109_ctl_packet {
+	u8 byte[4];
+} __attribute__ ((packed));
+
+enum { USB_PKT_LEN = sizeof(struct cm109_ctl_packet) };
+
+/* CM109 device structure */
+struct cm109_dev {
+	struct input_dev *idev;	 /* input device */
+	struct usb_device *udev; /* usb device */
+	struct usb_interface *intf;
+
+	/* irq input channel */
+	struct cm109_ctl_packet *irq_data;
+	dma_addr_t irq_dma;
+	struct urb *urb_irq;
+
+	/* control output channel */
+	struct cm109_ctl_packet *ctl_data;
+	dma_addr_t ctl_dma;
+	struct usb_ctrlrequest *ctl_req;
+	struct urb *urb_ctl;
+	/*
+	 * The 3 bitfields below are protected by ctl_submit_lock.
+	 * They have to be separate since they are accessed from IRQ
+	 * context.
+	 */
+	unsigned irq_urb_pending:1;	/* irq_urb is in flight */
+	unsigned ctl_urb_pending:1;	/* ctl_urb is in flight */
+	unsigned buzzer_pending:1;	/* need to issue buzz command */
+	spinlock_t ctl_submit_lock;
+
+	unsigned char buzzer_state;	/* on/off */
+
+	/* flags */
+	unsigned open:1;
+	unsigned resetting:1;
+	unsigned shutdown:1;
+
+	/* This mutex protects writes to the above flags */
+	struct mutex pm_mutex;
+
+	unsigned short keymap[KEYMAP_SIZE];
+
+	char phys[64];		/* physical device path */
+	int key_code;		/* last reported key */
+	int keybit;		/* 0=new scan  1,2,4,8=scan columns  */
+	u8 gpi;			/* Cached value of GPI (high nibble) */
+};
+
+/******************************************************************************
+ * CM109 key interface
+ *****************************************************************************/
+
+static unsigned short special_keymap(int code)
+{
+	if (code > 0xff) {
+		switch (code - 0xff) {
+		case RECORD_MUTE:	return KEY_MUTE;
+		case PLAYBACK_MUTE:	return KEY_MUTE;
+		case VOLUME_DOWN:	return KEY_VOLUMEDOWN;
+		case VOLUME_UP:		return KEY_VOLUMEUP;
+		}
+	}
+	return KEY_RESERVED;
+}
+
+/* Map device buttons to internal key events.
+ *
+ * The "up" and "down" keys, are symbolised by arrows on the button.
+ * The "pickup" and "hangup" keys are symbolised by a green and red phone
+ * on the button.
+
+ Komunikate KIP1000 Keyboard Matrix
+
+     -> -- 1 -- 2 -- 3  --> GPI pin 4 (0x10)
+      |    |    |    |
+     <- -- 4 -- 5 -- 6  --> GPI pin 5 (0x20)
+      |    |    |    |
+     END - 7 -- 8 -- 9  --> GPI pin 6 (0x40)
+      |    |    |    |
+     OK -- * -- 0 -- #  --> GPI pin 7 (0x80)
+      |    |    |    |
+
+     /|\  /|\  /|\  /|\
+      |    |    |    |
+GPO
+pin:  3    2    1    0
+     0x8  0x4  0x2  0x1
+
+ */
+static unsigned short keymap_kip1000(int scancode)
+{
+	switch (scancode) {				/* phone key:   */
+	case 0x82: return KEY_NUMERIC_0;		/*   0          */
+	case 0x14: return KEY_NUMERIC_1;		/*   1          */
+	case 0x12: return KEY_NUMERIC_2;		/*   2          */
+	case 0x11: return KEY_NUMERIC_3;		/*   3          */
+	case 0x24: return KEY_NUMERIC_4;		/*   4          */
+	case 0x22: return KEY_NUMERIC_5;		/*   5          */
+	case 0x21: return KEY_NUMERIC_6;		/*   6          */
+	case 0x44: return KEY_NUMERIC_7;		/*   7          */
+	case 0x42: return KEY_NUMERIC_8;		/*   8          */
+	case 0x41: return KEY_NUMERIC_9;		/*   9          */
+	case 0x81: return KEY_NUMERIC_POUND;		/*   #          */
+	case 0x84: return KEY_NUMERIC_STAR;		/*   *          */
+	case 0x88: return KEY_ENTER;			/*   pickup     */
+	case 0x48: return KEY_ESC;			/*   hangup     */
+	case 0x28: return KEY_LEFT;			/*   IN         */
+	case 0x18: return KEY_RIGHT;			/*   OUT        */
+	default:   return special_keymap(scancode);
+	}
+}
+
+/*
+  Contributed by Shaun Jackman <sjackman@gmail.com>
+
+  Genius G-Talk keyboard matrix
+     0 1 2 3
+  4: 0 4 8 Talk
+  5: 1 5 9 End
+  6: 2 6 # Up
+  7: 3 7 * Down
+*/
+static unsigned short keymap_gtalk(int scancode)
+{
+	switch (scancode) {
+	case 0x11: return KEY_NUMERIC_0;
+	case 0x21: return KEY_NUMERIC_1;
+	case 0x41: return KEY_NUMERIC_2;
+	case 0x81: return KEY_NUMERIC_3;
+	case 0x12: return KEY_NUMERIC_4;
+	case 0x22: return KEY_NUMERIC_5;
+	case 0x42: return KEY_NUMERIC_6;
+	case 0x82: return KEY_NUMERIC_7;
+	case 0x14: return KEY_NUMERIC_8;
+	case 0x24: return KEY_NUMERIC_9;
+	case 0x44: return KEY_NUMERIC_POUND;	/* # */
+	case 0x84: return KEY_NUMERIC_STAR;	/* * */
+	case 0x18: return KEY_ENTER;		/* Talk (green handset) */
+	case 0x28: return KEY_ESC;		/* End (red handset) */
+	case 0x48: return KEY_UP;		/* Menu up (rocker switch) */
+	case 0x88: return KEY_DOWN;		/* Menu down (rocker switch) */
+	default:   return special_keymap(scancode);
+	}
+}
+
+/*
+ * Keymap for Allied-Telesis Corega USBPH01
+ * http://www.alliedtelesis-corega.com/2/1344/1437/1360/chprd.html
+ *
+ * Contributed by july@nat.bg
+ */
+static unsigned short keymap_usbph01(int scancode)
+{
+	switch (scancode) {
+	case 0x11: return KEY_NUMERIC_0;		/*   0          */
+	case 0x21: return KEY_NUMERIC_1;		/*   1          */
+	case 0x41: return KEY_NUMERIC_2;		/*   2          */
+	case 0x81: return KEY_NUMERIC_3;		/*   3          */
+	case 0x12: return KEY_NUMERIC_4;		/*   4          */
+	case 0x22: return KEY_NUMERIC_5;		/*   5          */
+	case 0x42: return KEY_NUMERIC_6;		/*   6          */
+	case 0x82: return KEY_NUMERIC_7;		/*   7          */
+	case 0x14: return KEY_NUMERIC_8;		/*   8          */
+	case 0x24: return KEY_NUMERIC_9;		/*   9          */
+	case 0x44: return KEY_NUMERIC_POUND;		/*   #          */
+	case 0x84: return KEY_NUMERIC_STAR;		/*   *          */
+	case 0x18: return KEY_ENTER;			/*   pickup     */
+	case 0x28: return KEY_ESC;			/*   hangup     */
+	case 0x48: return KEY_LEFT;			/*   IN         */
+	case 0x88: return KEY_RIGHT;			/*   OUT        */
+	default:   return special_keymap(scancode);
+	}
+}
+
+/*
+ * Keymap for ATCom AU-100
+ * http://www.atcom.cn/products.html 
+ * http://www.packetizer.com/products/au100/
+ * http://www.voip-info.org/wiki/view/AU-100
+ *
+ * Contributed by daniel@gimpelevich.san-francisco.ca.us
+ */
+static unsigned short keymap_atcom(int scancode)
+{
+	switch (scancode) {				/* phone key:   */
+	case 0x82: return KEY_NUMERIC_0;		/*   0          */
+	case 0x11: return KEY_NUMERIC_1;		/*   1          */
+	case 0x12: return KEY_NUMERIC_2;		/*   2          */
+	case 0x14: return KEY_NUMERIC_3;		/*   3          */
+	case 0x21: return KEY_NUMERIC_4;		/*   4          */
+	case 0x22: return KEY_NUMERIC_5;		/*   5          */
+	case 0x24: return KEY_NUMERIC_6;		/*   6          */
+	case 0x41: return KEY_NUMERIC_7;		/*   7          */
+	case 0x42: return KEY_NUMERIC_8;		/*   8          */
+	case 0x44: return KEY_NUMERIC_9;		/*   9          */
+	case 0x84: return KEY_NUMERIC_POUND;		/*   #          */
+	case 0x81: return KEY_NUMERIC_STAR;		/*   *          */
+	case 0x18: return KEY_ENTER;			/*   pickup     */
+	case 0x28: return KEY_ESC;			/*   hangup     */
+	case 0x48: return KEY_LEFT;			/* left arrow   */
+	case 0x88: return KEY_RIGHT;			/* right arrow  */
+	default:   return special_keymap(scancode);
+	}
+}
+
+static unsigned short (*keymap)(int) = keymap_kip1000;
+
+/*
+ * Completes a request by converting the data into events for the
+ * input subsystem.
+ */
+static void report_key(struct cm109_dev *dev, int key)
+{
+	struct input_dev *idev = dev->idev;
+
+	if (dev->key_code >= 0) {
+		/* old key up */
+		input_report_key(idev, dev->key_code, 0);
+	}
+
+	dev->key_code = key;
+	if (key >= 0) {
+		/* new valid key */
+		input_report_key(idev, key, 1);
+	}
+
+	input_sync(idev);
+}
+
+/******************************************************************************
+ * CM109 usb communication interface
+ *****************************************************************************/
+
+static void cm109_submit_buzz_toggle(struct cm109_dev *dev)
+{
+	int error;
+
+	if (dev->buzzer_state)
+		dev->ctl_data->byte[HID_OR0] |= BUZZER_ON;
+	else
+		dev->ctl_data->byte[HID_OR0] &= ~BUZZER_ON;
+
+	error = usb_submit_urb(dev->urb_ctl, GFP_ATOMIC);
+	if (error)
+		dev_err(&dev->intf->dev,
+			"%s: usb_submit_urb (urb_ctl) failed %d\n",
+			__func__, error);
+}
+
+/*
+ * IRQ handler
+ */
+static void cm109_urb_irq_callback(struct urb *urb)
+{
+	struct cm109_dev *dev = urb->context;
+	const int status = urb->status;
+	int error;
+
+	dev_dbg(&dev->intf->dev, "### URB IRQ: [0x%02x 0x%02x 0x%02x 0x%02x] keybit=0x%02x\n",
+	     dev->irq_data->byte[0],
+	     dev->irq_data->byte[1],
+	     dev->irq_data->byte[2],
+	     dev->irq_data->byte[3],
+	     dev->keybit);
+
+	if (status) {
+		if (status == -ESHUTDOWN)
+			return;
+		dev_err(&dev->intf->dev, "%s: urb status %d\n", __func__, status);
+	}
+
+	/* Special keys */
+	if (dev->irq_data->byte[HID_IR0] & 0x0f) {
+		const int code = (dev->irq_data->byte[HID_IR0] & 0x0f);
+		report_key(dev, dev->keymap[0xff + code]);
+	}
+
+	/* Scan key column */
+	if (dev->keybit == 0xf) {
+
+		/* Any changes ? */
+		if ((dev->gpi & 0xf0) == (dev->irq_data->byte[HID_IR1] & 0xf0))
+			goto out;
+
+		dev->gpi = dev->irq_data->byte[HID_IR1] & 0xf0;
+		dev->keybit = 0x1;
+	} else {
+		report_key(dev, dev->keymap[dev->irq_data->byte[HID_IR1]]);
+
+		dev->keybit <<= 1;
+		if (dev->keybit > 0x8)
+			dev->keybit = 0xf;
+	}
+
+ out:
+
+	spin_lock(&dev->ctl_submit_lock);
+
+	dev->irq_urb_pending = 0;
+
+	if (likely(!dev->shutdown)) {
+
+		if (dev->buzzer_state)
+			dev->ctl_data->byte[HID_OR0] |= BUZZER_ON;
+		else
+			dev->ctl_data->byte[HID_OR0] &= ~BUZZER_ON;
+
+		dev->ctl_data->byte[HID_OR1] = dev->keybit;
+		dev->ctl_data->byte[HID_OR2] = dev->keybit;
+
+		dev->buzzer_pending = 0;
+		dev->ctl_urb_pending = 1;
+
+		error = usb_submit_urb(dev->urb_ctl, GFP_ATOMIC);
+		if (error)
+			dev_err(&dev->intf->dev,
+				"%s: usb_submit_urb (urb_ctl) failed %d\n",
+				__func__, error);
+	}
+
+	spin_unlock(&dev->ctl_submit_lock);
+}
+
+static void cm109_urb_ctl_callback(struct urb *urb)
+{
+	struct cm109_dev *dev = urb->context;
+	const int status = urb->status;
+	int error;
+
+	dev_dbg(&dev->intf->dev, "### URB CTL: [0x%02x 0x%02x 0x%02x 0x%02x]\n",
+	     dev->ctl_data->byte[0],
+	     dev->ctl_data->byte[1],
+	     dev->ctl_data->byte[2],
+	     dev->ctl_data->byte[3]);
+
+	if (status)
+		dev_err(&dev->intf->dev, "%s: urb status %d\n", __func__, status);
+
+	spin_lock(&dev->ctl_submit_lock);
+
+	dev->ctl_urb_pending = 0;
+
+	if (likely(!dev->shutdown)) {
+
+		if (dev->buzzer_pending) {
+			dev->buzzer_pending = 0;
+			dev->ctl_urb_pending = 1;
+			cm109_submit_buzz_toggle(dev);
+		} else if (likely(!dev->irq_urb_pending)) {
+			/* ask for key data */
+			dev->irq_urb_pending = 1;
+			error = usb_submit_urb(dev->urb_irq, GFP_ATOMIC);
+			if (error)
+				dev_err(&dev->intf->dev,
+					"%s: usb_submit_urb (urb_irq) failed %d\n",
+					__func__, error);
+		}
+	}
+
+	spin_unlock(&dev->ctl_submit_lock);
+}
+
+static void cm109_toggle_buzzer_async(struct cm109_dev *dev)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&dev->ctl_submit_lock, flags);
+
+	if (dev->ctl_urb_pending) {
+		/* URB completion will resubmit */
+		dev->buzzer_pending = 1;
+	} else {
+		dev->ctl_urb_pending = 1;
+		cm109_submit_buzz_toggle(dev);
+	}
+
+	spin_unlock_irqrestore(&dev->ctl_submit_lock, flags);
+}
+
+static void cm109_toggle_buzzer_sync(struct cm109_dev *dev, int on)
+{
+	int error;
+
+	if (on)
+		dev->ctl_data->byte[HID_OR0] |= BUZZER_ON;
+	else
+		dev->ctl_data->byte[HID_OR0] &= ~BUZZER_ON;
+
+	error = usb_control_msg(dev->udev,
+				usb_sndctrlpipe(dev->udev, 0),
+				dev->ctl_req->bRequest,
+				dev->ctl_req->bRequestType,
+				le16_to_cpu(dev->ctl_req->wValue),
+				le16_to_cpu(dev->ctl_req->wIndex),
+				dev->ctl_data,
+				USB_PKT_LEN, USB_CTRL_SET_TIMEOUT);
+	if (error < 0 && error != -EINTR)
+		dev_err(&dev->intf->dev, "%s: usb_control_msg() failed %d\n",
+			__func__, error);
+}
+
+static void cm109_stop_traffic(struct cm109_dev *dev)
+{
+	dev->shutdown = 1;
+	/*
+	 * Make sure other CPUs see this
+	 */
+	smp_wmb();
+
+	usb_kill_urb(dev->urb_ctl);
+	usb_kill_urb(dev->urb_irq);
+
+	cm109_toggle_buzzer_sync(dev, 0);
+
+	dev->shutdown = 0;
+	smp_wmb();
+}
+
+static void cm109_restore_state(struct cm109_dev *dev)
+{
+	if (dev->open) {
+		/*
+		 * Restore buzzer state.
+		 * This will also kick regular URB submission
+		 */
+		cm109_toggle_buzzer_async(dev);
+	}
+}
+
+/******************************************************************************
+ * input event interface
+ *****************************************************************************/
+
+static int cm109_input_open(struct input_dev *idev)
+{
+	struct cm109_dev *dev = input_get_drvdata(idev);
+	int error;
+
+	error = usb_autopm_get_interface(dev->intf);
+	if (error < 0) {
+		dev_err(&idev->dev, "%s - cannot autoresume, result %d\n",
+			__func__, error);
+		return error;
+	}
+
+	mutex_lock(&dev->pm_mutex);
+
+	dev->buzzer_state = 0;
+	dev->key_code = -1;	/* no keys pressed */
+	dev->keybit = 0xf;
+
+	/* issue INIT */
+	dev->ctl_data->byte[HID_OR0] = HID_OR_GPO_BUZ_SPDIF;
+	dev->ctl_data->byte[HID_OR1] = dev->keybit;
+	dev->ctl_data->byte[HID_OR2] = dev->keybit;
+	dev->ctl_data->byte[HID_OR3] = 0x00;
+
+	error = usb_submit_urb(dev->urb_ctl, GFP_KERNEL);
+	if (error)
+		dev_err(&dev->intf->dev, "%s: usb_submit_urb (urb_ctl) failed %d\n",
+			__func__, error);
+	else
+		dev->open = 1;
+
+	mutex_unlock(&dev->pm_mutex);
+
+	if (error)
+		usb_autopm_put_interface(dev->intf);
+
+	return error;
+}
+
+static void cm109_input_close(struct input_dev *idev)
+{
+	struct cm109_dev *dev = input_get_drvdata(idev);
+
+	mutex_lock(&dev->pm_mutex);
+
+	/*
+	 * Once we are here event delivery is stopped so we
+	 * don't need to worry about someone starting buzzer
+	 * again
+	 */
+	cm109_stop_traffic(dev);
+	dev->open = 0;
+
+	mutex_unlock(&dev->pm_mutex);
+
+	usb_autopm_put_interface(dev->intf);
+}
+
+static int cm109_input_ev(struct input_dev *idev, unsigned int type,
+			  unsigned int code, int value)
+{
+	struct cm109_dev *dev = input_get_drvdata(idev);
+
+	dev_dbg(&dev->intf->dev,
+		"input_ev: type=%u code=%u value=%d\n", type, code, value);
+
+	if (type != EV_SND)
+		return -EINVAL;
+
+	switch (code) {
+	case SND_TONE:
+	case SND_BELL:
+		dev->buzzer_state = !!value;
+		if (!dev->resetting)
+			cm109_toggle_buzzer_async(dev);
+		return 0;
+
+	default:
+		return -EINVAL;
+	}
+}
+
+
+/******************************************************************************
+ * Linux interface and usb initialisation
+ *****************************************************************************/
+
+struct driver_info {
+	char *name;
+};
+
+static const struct driver_info info_cm109 = {
+	.name = "CM109 USB driver",
+};
+
+enum {
+	VENDOR_ID        = 0x0d8c, /* C-Media Electronics */
+	PRODUCT_ID_CM109 = 0x000e, /* CM109 defines range 0x0008 - 0x000f */
+};
+
+/* table of devices that work with this driver */
+static const struct usb_device_id cm109_usb_table[] = {
+	{
+		.match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+				USB_DEVICE_ID_MATCH_INT_INFO,
+		.idVendor = VENDOR_ID,
+		.idProduct = PRODUCT_ID_CM109,
+		.bInterfaceClass = USB_CLASS_HID,
+		.bInterfaceSubClass = 0,
+		.bInterfaceProtocol = 0,
+		.driver_info = (kernel_ulong_t) &info_cm109
+	},
+	/* you can add more devices here with product ID 0x0008 - 0x000f */
+	{ }
+};
+
+static void cm109_usb_cleanup(struct cm109_dev *dev)
+{
+	kfree(dev->ctl_req);
+	if (dev->ctl_data)
+		usb_free_coherent(dev->udev, USB_PKT_LEN,
+				  dev->ctl_data, dev->ctl_dma);
+	if (dev->irq_data)
+		usb_free_coherent(dev->udev, USB_PKT_LEN,
+				  dev->irq_data, dev->irq_dma);
+
+	usb_free_urb(dev->urb_irq);	/* parameter validation in core/urb */
+	usb_free_urb(dev->urb_ctl);	/* parameter validation in core/urb */
+	kfree(dev);
+}
+
+static void cm109_usb_disconnect(struct usb_interface *interface)
+{
+	struct cm109_dev *dev = usb_get_intfdata(interface);
+
+	usb_set_intfdata(interface, NULL);
+	input_unregister_device(dev->idev);
+	cm109_usb_cleanup(dev);
+}
+
+static int cm109_usb_probe(struct usb_interface *intf,
+			   const struct usb_device_id *id)
+{
+	struct usb_device *udev = interface_to_usbdev(intf);
+	struct driver_info *nfo = (struct driver_info *)id->driver_info;
+	struct usb_host_interface *interface;
+	struct usb_endpoint_descriptor *endpoint;
+	struct cm109_dev *dev;
+	struct input_dev *input_dev = NULL;
+	int ret, pipe, i;
+	int error = -ENOMEM;
+
+	interface = intf->cur_altsetting;
+	endpoint = &interface->endpoint[0].desc;
+
+	if (!usb_endpoint_is_int_in(endpoint))
+		return -ENODEV;
+
+	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+	if (!dev)
+		return -ENOMEM;
+
+	spin_lock_init(&dev->ctl_submit_lock);
+	mutex_init(&dev->pm_mutex);
+
+	dev->udev = udev;
+	dev->intf = intf;
+
+	dev->idev = input_dev = input_allocate_device();
+	if (!input_dev)
+		goto err_out;
+
+	/* allocate usb buffers */
+	dev->irq_data = usb_alloc_coherent(udev, USB_PKT_LEN,
+					   GFP_KERNEL, &dev->irq_dma);
+	if (!dev->irq_data)
+		goto err_out;
+
+	dev->ctl_data = usb_alloc_coherent(udev, USB_PKT_LEN,
+					   GFP_KERNEL, &dev->ctl_dma);
+	if (!dev->ctl_data)
+		goto err_out;
+
+	dev->ctl_req = kmalloc(sizeof(*(dev->ctl_req)), GFP_KERNEL);
+	if (!dev->ctl_req)
+		goto err_out;
+
+	/* allocate urb structures */
+	dev->urb_irq = usb_alloc_urb(0, GFP_KERNEL);
+	if (!dev->urb_irq)
+		goto err_out;
+
+	dev->urb_ctl = usb_alloc_urb(0, GFP_KERNEL);
+	if (!dev->urb_ctl)
+		goto err_out;
+
+	/* get a handle to the interrupt data pipe */
+	pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);
+	ret = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
+	if (ret != USB_PKT_LEN)
+		dev_err(&intf->dev, "invalid payload size %d, expected %d\n",
+			ret, USB_PKT_LEN);
+
+	/* initialise irq urb */
+	usb_fill_int_urb(dev->urb_irq, udev, pipe, dev->irq_data,
+			 USB_PKT_LEN,
+			 cm109_urb_irq_callback, dev, endpoint->bInterval);
+	dev->urb_irq->transfer_dma = dev->irq_dma;
+	dev->urb_irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+	dev->urb_irq->dev = udev;
+
+	/* initialise ctl urb */
+	dev->ctl_req->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE |
+					USB_DIR_OUT;
+	dev->ctl_req->bRequest = USB_REQ_SET_CONFIGURATION;
+	dev->ctl_req->wValue = cpu_to_le16(0x200);
+	dev->ctl_req->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber);
+	dev->ctl_req->wLength = cpu_to_le16(USB_PKT_LEN);
+
+	usb_fill_control_urb(dev->urb_ctl, udev, usb_sndctrlpipe(udev, 0),
+			     (void *)dev->ctl_req, dev->ctl_data, USB_PKT_LEN,
+			     cm109_urb_ctl_callback, dev);
+	dev->urb_ctl->transfer_dma = dev->ctl_dma;
+	dev->urb_ctl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+	dev->urb_ctl->dev = udev;
+
+	/* find out the physical bus location */
+	usb_make_path(udev, dev->phys, sizeof(dev->phys));
+	strlcat(dev->phys, "/input0", sizeof(dev->phys));
+
+	/* register settings for the input device */
+	input_dev->name = nfo->name;
+	input_dev->phys = dev->phys;
+	usb_to_input_id(udev, &input_dev->id);
+	input_dev->dev.parent = &intf->dev;
+
+	input_set_drvdata(input_dev, dev);
+	input_dev->open = cm109_input_open;
+	input_dev->close = cm109_input_close;
+	input_dev->event = cm109_input_ev;
+
+	input_dev->keycode = dev->keymap;
+	input_dev->keycodesize = sizeof(unsigned char);
+	input_dev->keycodemax = ARRAY_SIZE(dev->keymap);
+
+	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_SND);
+	input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
+
+	/* register available key events */
+	for (i = 0; i < KEYMAP_SIZE; i++) {
+		unsigned short k = keymap(i);
+		dev->keymap[i] = k;
+		__set_bit(k, input_dev->keybit);
+	}
+	__clear_bit(KEY_RESERVED, input_dev->keybit);
+
+	error = input_register_device(dev->idev);
+	if (error)
+		goto err_out;
+
+	usb_set_intfdata(intf, dev);
+
+	return 0;
+
+ err_out:
+	input_free_device(input_dev);
+	cm109_usb_cleanup(dev);
+	return error;
+}
+
+static int cm109_usb_suspend(struct usb_interface *intf, pm_message_t message)
+{
+	struct cm109_dev *dev = usb_get_intfdata(intf);
+
+	dev_info(&intf->dev, "cm109: usb_suspend (event=%d)\n", message.event);
+
+	mutex_lock(&dev->pm_mutex);
+	cm109_stop_traffic(dev);
+	mutex_unlock(&dev->pm_mutex);
+
+	return 0;
+}
+
+static int cm109_usb_resume(struct usb_interface *intf)
+{
+	struct cm109_dev *dev = usb_get_intfdata(intf);
+
+	dev_info(&intf->dev, "cm109: usb_resume\n");
+
+	mutex_lock(&dev->pm_mutex);
+	cm109_restore_state(dev);
+	mutex_unlock(&dev->pm_mutex);
+
+	return 0;
+}
+
+static int cm109_usb_pre_reset(struct usb_interface *intf)
+{
+	struct cm109_dev *dev = usb_get_intfdata(intf);
+
+	mutex_lock(&dev->pm_mutex);
+
+	/*
+	 * Make sure input events don't try to toggle buzzer
+	 * while we are resetting
+	 */
+	dev->resetting = 1;
+	smp_wmb();
+
+	cm109_stop_traffic(dev);
+
+	return 0;
+}
+
+static int cm109_usb_post_reset(struct usb_interface *intf)
+{
+	struct cm109_dev *dev = usb_get_intfdata(intf);
+
+	dev->resetting = 0;
+	smp_wmb();
+
+	cm109_restore_state(dev);
+
+	mutex_unlock(&dev->pm_mutex);
+
+	return 0;
+}
+
+static struct usb_driver cm109_driver = {
+	.name		= "cm109",
+	.probe		= cm109_usb_probe,
+	.disconnect	= cm109_usb_disconnect,
+	.suspend	= cm109_usb_suspend,
+	.resume		= cm109_usb_resume,
+	.reset_resume	= cm109_usb_resume,
+	.pre_reset	= cm109_usb_pre_reset,
+	.post_reset	= cm109_usb_post_reset,
+	.id_table	= cm109_usb_table,
+	.supports_autosuspend = 1,
+};
+
+static int __init cm109_select_keymap(void)
+{
+	/* Load the phone keymap */
+	if (!strcasecmp(phone, "kip1000")) {
+		keymap = keymap_kip1000;
+		printk(KERN_INFO KBUILD_MODNAME ": "
+			"Keymap for Komunikate KIP1000 phone loaded\n");
+	} else if (!strcasecmp(phone, "gtalk")) {
+		keymap = keymap_gtalk;
+		printk(KERN_INFO KBUILD_MODNAME ": "
+			"Keymap for Genius G-talk phone loaded\n");
+	} else if (!strcasecmp(phone, "usbph01")) {
+		keymap = keymap_usbph01;
+		printk(KERN_INFO KBUILD_MODNAME ": "
+			"Keymap for Allied-Telesis Corega USBPH01 phone loaded\n");
+	} else if (!strcasecmp(phone, "atcom")) {
+		keymap = keymap_atcom;
+		printk(KERN_INFO KBUILD_MODNAME ": "
+			"Keymap for ATCom AU-100 phone loaded\n");
+	} else {
+		printk(KERN_ERR KBUILD_MODNAME ": "
+			"Unsupported phone: %s\n", phone);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int __init cm109_init(void)
+{
+	int err;
+
+	err = cm109_select_keymap();
+	if (err)
+		return err;
+
+	err = usb_register(&cm109_driver);
+	if (err)
+		return err;
+
+	printk(KERN_INFO KBUILD_MODNAME ": "
+		DRIVER_DESC ": " DRIVER_VERSION " (C) " DRIVER_AUTHOR "\n");
+
+	return 0;
+}
+
+static void __exit cm109_exit(void)
+{
+	usb_deregister(&cm109_driver);
+}
+
+module_init(cm109_init);
+module_exit(cm109_exit);
+
+MODULE_DEVICE_TABLE(usb, cm109_usb_table);
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/cma3000_d0x.c b/drivers/input/misc/cma3000_d0x.c
new file mode 100644
index 00000000..df9b7565
--- /dev/null
+++ b/drivers/input/misc/cma3000_d0x.c
@@ -0,0 +1,399 @@
+/*
+ * VTI CMA3000_D0x Accelerometer driver
+ *
+ * Copyright (C) 2010 Texas Instruments
+ * Author: Hemanth V <hemanthv@ti.com>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/types.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/input/cma3000.h>
+#include <linux/module.h>
+
+#include "cma3000_d0x.h"
+
+#define CMA3000_WHOAMI      0x00
+#define CMA3000_REVID       0x01
+#define CMA3000_CTRL        0x02
+#define CMA3000_STATUS      0x03
+#define CMA3000_RSTR        0x04
+#define CMA3000_INTSTATUS   0x05
+#define CMA3000_DOUTX       0x06
+#define CMA3000_DOUTY       0x07
+#define CMA3000_DOUTZ       0x08
+#define CMA3000_MDTHR       0x09
+#define CMA3000_MDFFTMR     0x0A
+#define CMA3000_FFTHR       0x0B
+
+#define CMA3000_RANGE2G    (1 << 7)
+#define CMA3000_RANGE8G    (0 << 7)
+#define CMA3000_BUSI2C     (0 << 4)
+#define CMA3000_MODEMASK   (7 << 1)
+#define CMA3000_GRANGEMASK (1 << 7)
+
+#define CMA3000_STATUS_PERR    1
+#define CMA3000_INTSTATUS_FFDET (1 << 2)
+
+/* Settling time delay in ms */
+#define CMA3000_SETDELAY    30
+
+/* Delay for clearing interrupt in us */
+#define CMA3000_INTDELAY    44
+
+
+/*
+ * Bit weights in mg for bit 0, other bits need
+ * multiply factor 2^n. Eight bit is the sign bit.
+ */
+#define BIT_TO_2G  18
+#define BIT_TO_8G  71
+
+struct cma3000_accl_data {
+	const struct cma3000_bus_ops *bus_ops;
+	const struct cma3000_platform_data *pdata;
+
+	struct device *dev;
+	struct input_dev *input_dev;
+
+	int bit_to_mg;
+	int irq;
+
+	int g_range;
+	u8 mode;
+
+	struct mutex mutex;
+	bool opened;
+	bool suspended;
+};
+
+#define CMA3000_READ(data, reg, msg) \
+	(data->bus_ops->read(data->dev, reg, msg))
+#define CMA3000_SET(data, reg, val, msg) \
+	((data)->bus_ops->write(data->dev, reg, val, msg))
+
+/*
+ * Conversion for each of the eight modes to g, depending
+ * on G range i.e 2G or 8G. Some modes always operate in
+ * 8G.
+ */
+
+static int mode_to_mg[8][2] = {
+	{ 0, 0 },
+	{ BIT_TO_8G, BIT_TO_2G },
+	{ BIT_TO_8G, BIT_TO_2G },
+	{ BIT_TO_8G, BIT_TO_8G },
+	{ BIT_TO_8G, BIT_TO_8G },
+	{ BIT_TO_8G, BIT_TO_2G },
+	{ BIT_TO_8G, BIT_TO_2G },
+	{ 0, 0},
+};
+
+static void decode_mg(struct cma3000_accl_data *data, int *datax,
+				int *datay, int *dataz)
+{
+	/* Data in 2's complement, convert to mg */
+	*datax = ((s8)*datax) * data->bit_to_mg;
+	*datay = ((s8)*datay) * data->bit_to_mg;
+	*dataz = ((s8)*dataz) * data->bit_to_mg;
+}
+
+static irqreturn_t cma3000_thread_irq(int irq, void *dev_id)
+{
+	struct cma3000_accl_data *data = dev_id;
+	int datax, datay, dataz, intr_status;
+	u8 ctrl, mode, range;
+
+	intr_status = CMA3000_READ(data, CMA3000_INTSTATUS, "interrupt status");
+	if (intr_status < 0)
+		return IRQ_NONE;
+
+	/* Check if free fall is detected, report immediately */
+	if (intr_status & CMA3000_INTSTATUS_FFDET) {
+		input_report_abs(data->input_dev, ABS_MISC, 1);
+		input_sync(data->input_dev);
+	} else {
+		input_report_abs(data->input_dev, ABS_MISC, 0);
+	}
+
+	datax = CMA3000_READ(data, CMA3000_DOUTX, "X");
+	datay = CMA3000_READ(data, CMA3000_DOUTY, "Y");
+	dataz = CMA3000_READ(data, CMA3000_DOUTZ, "Z");
+
+	ctrl = CMA3000_READ(data, CMA3000_CTRL, "ctrl");
+	mode = (ctrl & CMA3000_MODEMASK) >> 1;
+	range = (ctrl & CMA3000_GRANGEMASK) >> 7;
+
+	data->bit_to_mg = mode_to_mg[mode][range];
+
+	/* Interrupt not for this device */
+	if (data->bit_to_mg == 0)
+		return IRQ_NONE;
+
+	/* Decode register values to milli g */
+	decode_mg(data, &datax, &datay, &dataz);
+
+	input_report_abs(data->input_dev, ABS_X, datax);
+	input_report_abs(data->input_dev, ABS_Y, datay);
+	input_report_abs(data->input_dev, ABS_Z, dataz);
+	input_sync(data->input_dev);
+
+	return IRQ_HANDLED;
+}
+
+static int cma3000_reset(struct cma3000_accl_data *data)
+{
+	int val;
+
+	/* Reset sequence */
+	CMA3000_SET(data, CMA3000_RSTR, 0x02, "Reset");
+	CMA3000_SET(data, CMA3000_RSTR, 0x0A, "Reset");
+	CMA3000_SET(data, CMA3000_RSTR, 0x04, "Reset");
+
+	/* Settling time delay */
+	mdelay(10);
+
+	val = CMA3000_READ(data, CMA3000_STATUS, "Status");
+	if (val < 0) {
+		dev_err(data->dev, "Reset failed\n");
+		return val;
+	}
+
+	if (val & CMA3000_STATUS_PERR) {
+		dev_err(data->dev, "Parity Error\n");
+		return -EIO;
+	}
+
+	return 0;
+}
+
+static int cma3000_poweron(struct cma3000_accl_data *data)
+{
+	const struct cma3000_platform_data *pdata = data->pdata;
+	u8 ctrl = 0;
+	int ret;
+
+	if (data->g_range == CMARANGE_2G) {
+		ctrl = (data->mode << 1) | CMA3000_RANGE2G;
+	} else if (data->g_range == CMARANGE_8G) {
+		ctrl = (data->mode << 1) | CMA3000_RANGE8G;
+	} else {
+		dev_info(data->dev,
+			 "Invalid G range specified, assuming 8G\n");
+		ctrl = (data->mode << 1) | CMA3000_RANGE8G;
+	}
+
+	ctrl |= data->bus_ops->ctrl_mod;
+
+	CMA3000_SET(data, CMA3000_MDTHR, pdata->mdthr,
+		    "Motion Detect Threshold");
+	CMA3000_SET(data, CMA3000_MDFFTMR, pdata->mdfftmr,
+		    "Time register");
+	CMA3000_SET(data, CMA3000_FFTHR, pdata->ffthr,
+		    "Free fall threshold");
+	ret = CMA3000_SET(data, CMA3000_CTRL, ctrl, "Mode setting");
+	if (ret < 0)
+		return -EIO;
+
+	msleep(CMA3000_SETDELAY);
+
+	return 0;
+}
+
+static int cma3000_poweroff(struct cma3000_accl_data *data)
+{
+	int ret;
+
+	ret = CMA3000_SET(data, CMA3000_CTRL, CMAMODE_POFF, "Mode setting");
+	msleep(CMA3000_SETDELAY);
+
+	return ret;
+}
+
+static int cma3000_open(struct input_dev *input_dev)
+{
+	struct cma3000_accl_data *data = input_get_drvdata(input_dev);
+
+	mutex_lock(&data->mutex);
+
+	if (!data->suspended)
+		cma3000_poweron(data);
+
+	data->opened = true;
+
+	mutex_unlock(&data->mutex);
+
+	return 0;
+}
+
+static void cma3000_close(struct input_dev *input_dev)
+{
+	struct cma3000_accl_data *data = input_get_drvdata(input_dev);
+
+	mutex_lock(&data->mutex);
+
+	if (!data->suspended)
+		cma3000_poweroff(data);
+
+	data->opened = false;
+
+	mutex_unlock(&data->mutex);
+}
+
+void cma3000_suspend(struct cma3000_accl_data *data)
+{
+	mutex_lock(&data->mutex);
+
+	if (!data->suspended && data->opened)
+		cma3000_poweroff(data);
+
+	data->suspended = true;
+
+	mutex_unlock(&data->mutex);
+}
+EXPORT_SYMBOL(cma3000_suspend);
+
+
+void cma3000_resume(struct cma3000_accl_data *data)
+{
+	mutex_lock(&data->mutex);
+
+	if (data->suspended && data->opened)
+		cma3000_poweron(data);
+
+	data->suspended = false;
+
+	mutex_unlock(&data->mutex);
+}
+EXPORT_SYMBOL(cma3000_resume);
+
+struct cma3000_accl_data *cma3000_init(struct device *dev, int irq,
+				       const struct cma3000_bus_ops *bops)
+{
+	const struct cma3000_platform_data *pdata = dev->platform_data;
+	struct cma3000_accl_data *data;
+	struct input_dev *input_dev;
+	int rev;
+	int error;
+
+	if (!pdata) {
+		dev_err(dev, "platform data not found\n");
+		error = -EINVAL;
+		goto err_out;
+	}
+
+
+	/* if no IRQ return error */
+	if (irq == 0) {
+		error = -EINVAL;
+		goto err_out;
+	}
+
+	data = kzalloc(sizeof(struct cma3000_accl_data), GFP_KERNEL);
+	input_dev = input_allocate_device();
+	if (!data || !input_dev) {
+		error = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	data->dev = dev;
+	data->input_dev = input_dev;
+	data->bus_ops = bops;
+	data->pdata = pdata;
+	data->irq = irq;
+	mutex_init(&data->mutex);
+
+	data->mode = pdata->mode;
+	if (data->mode > CMAMODE_POFF) {
+		data->mode = CMAMODE_MOTDET;
+		dev_warn(dev,
+			 "Invalid mode specified, assuming Motion Detect\n");
+	}
+
+	data->g_range = pdata->g_range;
+	if (data->g_range != CMARANGE_2G && data->g_range != CMARANGE_8G) {
+		dev_info(dev,
+			 "Invalid G range specified, assuming 8G\n");
+		data->g_range = CMARANGE_8G;
+	}
+
+	input_dev->name = "cma3000-accelerometer";
+	input_dev->id.bustype = bops->bustype;
+	input_dev->open = cma3000_open;
+	input_dev->close = cma3000_close;
+
+	 __set_bit(EV_ABS, input_dev->evbit);
+
+	input_set_abs_params(input_dev, ABS_X,
+			-data->g_range, data->g_range, pdata->fuzz_x, 0);
+	input_set_abs_params(input_dev, ABS_Y,
+			-data->g_range, data->g_range, pdata->fuzz_y, 0);
+	input_set_abs_params(input_dev, ABS_Z,
+			-data->g_range, data->g_range, pdata->fuzz_z, 0);
+	input_set_abs_params(input_dev, ABS_MISC, 0, 1, 0, 0);
+
+	input_set_drvdata(input_dev, data);
+
+	error = cma3000_reset(data);
+	if (error)
+		goto err_free_mem;
+
+	rev = CMA3000_READ(data, CMA3000_REVID, "Revid");
+	if (rev < 0) {
+		error = rev;
+		goto err_free_mem;
+	}
+
+	pr_info("CMA3000 Accelerometer: Revision %x\n", rev);
+
+	error = request_threaded_irq(irq, NULL, cma3000_thread_irq,
+				     pdata->irqflags | IRQF_ONESHOT,
+				     "cma3000_d0x", data);
+	if (error) {
+		dev_err(dev, "request_threaded_irq failed\n");
+		goto err_free_mem;
+	}
+
+	error = input_register_device(data->input_dev);
+	if (error) {
+		dev_err(dev, "Unable to register input device\n");
+		goto err_free_irq;
+	}
+
+	return data;
+
+err_free_irq:
+	free_irq(irq, data);
+err_free_mem:
+	input_free_device(input_dev);
+	kfree(data);
+err_out:
+	return ERR_PTR(error);
+}
+EXPORT_SYMBOL(cma3000_init);
+
+void cma3000_exit(struct cma3000_accl_data *data)
+{
+	free_irq(data->irq, data);
+	input_unregister_device(data->input_dev);
+	kfree(data);
+}
+EXPORT_SYMBOL(cma3000_exit);
+
+MODULE_DESCRIPTION("CMA3000-D0x Accelerometer Driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Hemanth V <hemanthv@ti.com>");
diff --git a/drivers/input/misc/cma3000_d0x.h b/drivers/input/misc/cma3000_d0x.h
new file mode 100644
index 00000000..2304ce30
--- /dev/null
+++ b/drivers/input/misc/cma3000_d0x.h
@@ -0,0 +1,42 @@
+/*
+ * VTI CMA3000_D0x Accelerometer driver
+ *
+ * Copyright (C) 2010 Texas Instruments
+ * Author: Hemanth V <hemanthv@ti.com>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _INPUT_CMA3000_H
+#define _INPUT_CMA3000_H
+
+#include <linux/types.h>
+#include <linux/input.h>
+
+struct device;
+struct cma3000_accl_data;
+
+struct cma3000_bus_ops {
+	u16 bustype;
+	u8 ctrl_mod;
+	int (*read)(struct device *, u8, char *);
+	int (*write)(struct device *, u8, u8, char *);
+};
+
+struct cma3000_accl_data *cma3000_init(struct device *dev, int irq,
+					const struct cma3000_bus_ops *bops);
+void cma3000_exit(struct cma3000_accl_data *);
+void cma3000_suspend(struct cma3000_accl_data *);
+void cma3000_resume(struct cma3000_accl_data *);
+
+#endif
diff --git a/drivers/input/misc/cma3000_d0x_i2c.c b/drivers/input/misc/cma3000_d0x_i2c.c
new file mode 100644
index 00000000..4fdef98c
--- /dev/null
+++ b/drivers/input/misc/cma3000_d0x_i2c.c
@@ -0,0 +1,132 @@
+/*
+ * Implements I2C interface for VTI CMA300_D0x Accelerometer driver
+ *
+ * Copyright (C) 2010 Texas Instruments
+ * Author: Hemanth V <hemanthv@ti.com>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/input/cma3000.h>
+#include "cma3000_d0x.h"
+
+static int cma3000_i2c_set(struct device *dev,
+			   u8 reg, u8 val, char *msg)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	int ret;
+
+	ret = i2c_smbus_write_byte_data(client, reg, val);
+	if (ret < 0)
+		dev_err(&client->dev,
+			"%s failed (%s, %d)\n", __func__, msg, ret);
+	return ret;
+}
+
+static int cma3000_i2c_read(struct device *dev, u8 reg, char *msg)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	int ret;
+
+	ret = i2c_smbus_read_byte_data(client, reg);
+	if (ret < 0)
+		dev_err(&client->dev,
+			"%s failed (%s, %d)\n", __func__, msg, ret);
+	return ret;
+}
+
+static const struct cma3000_bus_ops cma3000_i2c_bops = {
+	.bustype	= BUS_I2C,
+#define CMA3000_BUSI2C     (0 << 4)
+	.ctrl_mod	= CMA3000_BUSI2C,
+	.read		= cma3000_i2c_read,
+	.write		= cma3000_i2c_set,
+};
+
+static int cma3000_i2c_probe(struct i2c_client *client,
+					const struct i2c_device_id *id)
+{
+	struct cma3000_accl_data *data;
+
+	data = cma3000_init(&client->dev, client->irq, &cma3000_i2c_bops);
+	if (IS_ERR(data))
+		return PTR_ERR(data);
+
+	i2c_set_clientdata(client, data);
+
+	return 0;
+}
+
+static int cma3000_i2c_remove(struct i2c_client *client)
+{
+	struct cma3000_accl_data *data = i2c_get_clientdata(client);
+
+	cma3000_exit(data);
+
+	return 0;
+}
+
+#ifdef CONFIG_PM
+static int cma3000_i2c_suspend(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct cma3000_accl_data *data = i2c_get_clientdata(client);
+
+	cma3000_suspend(data);
+
+	return 0;
+}
+
+static int cma3000_i2c_resume(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct cma3000_accl_data *data = i2c_get_clientdata(client);
+
+	cma3000_resume(data);
+
+	return 0;
+}
+
+static const struct dev_pm_ops cma3000_i2c_pm_ops = {
+	.suspend	= cma3000_i2c_suspend,
+	.resume		= cma3000_i2c_resume,
+};
+#endif
+
+static const struct i2c_device_id cma3000_i2c_id[] = {
+	{ "cma3000_d01", 0 },
+	{ },
+};
+
+MODULE_DEVICE_TABLE(i2c, cma3000_i2c_id);
+
+static struct i2c_driver cma3000_i2c_driver = {
+	.probe		= cma3000_i2c_probe,
+	.remove		= cma3000_i2c_remove,
+	.id_table	= cma3000_i2c_id,
+	.driver = {
+		.name	= "cma3000_i2c_accl",
+		.owner	= THIS_MODULE,
+#ifdef CONFIG_PM
+		.pm	= &cma3000_i2c_pm_ops,
+#endif
+	},
+};
+
+module_i2c_driver(cma3000_i2c_driver);
+
+MODULE_DESCRIPTION("CMA3000-D0x Accelerometer I2C Driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Hemanth V <hemanthv@ti.com>");
diff --git a/drivers/input/misc/cobalt_btns.c b/drivers/input/misc/cobalt_btns.c
new file mode 100644
index 00000000..4f77f878
--- /dev/null
+++ b/drivers/input/misc/cobalt_btns.c
@@ -0,0 +1,166 @@
+/*
+ *  Cobalt button interface driver.
+ *
+ *  Copyright (C) 2007-2008  Yoichi Yuasa <yuasa@linux-mips.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#include <linux/init.h>
+#include <linux/input-polldev.h>
+#include <linux/ioport.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#define BUTTONS_POLL_INTERVAL	30	/* msec */
+#define BUTTONS_COUNT_THRESHOLD	3
+#define BUTTONS_STATUS_MASK	0xfe000000
+
+static const unsigned short cobalt_map[] = {
+	KEY_RESERVED,
+	KEY_RESTART,
+	KEY_LEFT,
+	KEY_UP,
+	KEY_DOWN,
+	KEY_RIGHT,
+	KEY_ENTER,
+	KEY_SELECT
+};
+
+struct buttons_dev {
+	struct input_polled_dev *poll_dev;
+	unsigned short keymap[ARRAY_SIZE(cobalt_map)];
+	int count[ARRAY_SIZE(cobalt_map)];
+	void __iomem *reg;
+};
+
+static void handle_buttons(struct input_polled_dev *dev)
+{
+	struct buttons_dev *bdev = dev->private;
+	struct input_dev *input = dev->input;
+	uint32_t status;
+	int i;
+
+	status = ~readl(bdev->reg) >> 24;
+
+	for (i = 0; i < ARRAY_SIZE(bdev->keymap); i++) {
+		if (status & (1U << i)) {
+			if (++bdev->count[i] == BUTTONS_COUNT_THRESHOLD) {
+				input_event(input, EV_MSC, MSC_SCAN, i);
+				input_report_key(input, bdev->keymap[i], 1);
+				input_sync(input);
+			}
+		} else {
+			if (bdev->count[i] >= BUTTONS_COUNT_THRESHOLD) {
+				input_event(input, EV_MSC, MSC_SCAN, i);
+				input_report_key(input, bdev->keymap[i], 0);
+				input_sync(input);
+			}
+			bdev->count[i] = 0;
+		}
+	}
+}
+
+static int cobalt_buttons_probe(struct platform_device *pdev)
+{
+	struct buttons_dev *bdev;
+	struct input_polled_dev *poll_dev;
+	struct input_dev *input;
+	struct resource *res;
+	int error, i;
+
+	bdev = kzalloc(sizeof(struct buttons_dev), GFP_KERNEL);
+	poll_dev = input_allocate_polled_device();
+	if (!bdev || !poll_dev) {
+		error = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	memcpy(bdev->keymap, cobalt_map, sizeof(bdev->keymap));
+
+	poll_dev->private = bdev;
+	poll_dev->poll = handle_buttons;
+	poll_dev->poll_interval = BUTTONS_POLL_INTERVAL;
+
+	input = poll_dev->input;
+	input->name = "Cobalt buttons";
+	input->phys = "cobalt/input0";
+	input->id.bustype = BUS_HOST;
+	input->dev.parent = &pdev->dev;
+
+	input->keycode = bdev->keymap;
+	input->keycodemax = ARRAY_SIZE(bdev->keymap);
+	input->keycodesize = sizeof(unsigned short);
+
+	input_set_capability(input, EV_MSC, MSC_SCAN);
+	__set_bit(EV_KEY, input->evbit);
+	for (i = 0; i < ARRAY_SIZE(cobalt_map); i++)
+		__set_bit(bdev->keymap[i], input->keybit);
+	__clear_bit(KEY_RESERVED, input->keybit);
+
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	if (!res) {
+		error = -EBUSY;
+		goto err_free_mem;
+	}
+
+	bdev->poll_dev = poll_dev;
+	bdev->reg = ioremap(res->start, resource_size(res));
+	dev_set_drvdata(&pdev->dev, bdev);
+
+	error = input_register_polled_device(poll_dev);
+	if (error)
+		goto err_iounmap;
+
+	return 0;
+
+ err_iounmap:
+	iounmap(bdev->reg);
+ err_free_mem:
+	input_free_polled_device(poll_dev);
+	kfree(bdev);
+	dev_set_drvdata(&pdev->dev, NULL);
+	return error;
+}
+
+static int cobalt_buttons_remove(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct buttons_dev *bdev = dev_get_drvdata(dev);
+
+	input_unregister_polled_device(bdev->poll_dev);
+	input_free_polled_device(bdev->poll_dev);
+	iounmap(bdev->reg);
+	kfree(bdev);
+	dev_set_drvdata(dev, NULL);
+
+	return 0;
+}
+
+MODULE_AUTHOR("Yoichi Yuasa <yuasa@linux-mips.org>");
+MODULE_DESCRIPTION("Cobalt button interface driver");
+MODULE_LICENSE("GPL");
+/* work with hotplug and coldplug */
+MODULE_ALIAS("platform:Cobalt buttons");
+
+static struct platform_driver cobalt_buttons_driver = {
+	.probe	= cobalt_buttons_probe,
+	.remove	= cobalt_buttons_remove,
+	.driver	= {
+		.name	= "Cobalt buttons",
+		.owner	= THIS_MODULE,
+	},
+};
+module_platform_driver(cobalt_buttons_driver);
diff --git a/drivers/input/misc/da9052_onkey.c b/drivers/input/misc/da9052_onkey.c
new file mode 100644
index 00000000..020569a4
--- /dev/null
+++ b/drivers/input/misc/da9052_onkey.c
@@ -0,0 +1,158 @@
+/*
+ * ON pin driver for Dialog DA9052 PMICs
+ *
+ * Copyright(c) 2012 Dialog Semiconductor Ltd.
+ *
+ * Author: David Dajun Chen <dchen@diasemi.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+
+#include <linux/mfd/da9052/da9052.h>
+#include <linux/mfd/da9052/reg.h>
+
+struct da9052_onkey {
+	struct da9052 *da9052;
+	struct input_dev *input;
+	struct delayed_work work;
+};
+
+static void da9052_onkey_query(struct da9052_onkey *onkey)
+{
+	int key_stat;
+
+	key_stat = da9052_reg_read(onkey->da9052, DA9052_EVENT_B_REG);
+	if (key_stat < 0) {
+		dev_err(onkey->da9052->dev,
+			"Failed to read onkey event %d\n", key_stat);
+	} else {
+		/*
+		 * Since interrupt for deassertion of ONKEY pin is not
+		 * generated, onkey event state determines the onkey
+		 * button state.
+		 */
+		key_stat &= DA9052_EVENTB_ENONKEY;
+		input_report_key(onkey->input, KEY_POWER, key_stat);
+		input_sync(onkey->input);
+	}
+
+	/*
+	 * Interrupt is generated only when the ONKEY pin is asserted.
+	 * Hence the deassertion of the pin is simulated through work queue.
+	 */
+	if (key_stat)
+		schedule_delayed_work(&onkey->work, msecs_to_jiffies(50));
+}
+
+static void da9052_onkey_work(struct work_struct *work)
+{
+	struct da9052_onkey *onkey = container_of(work, struct da9052_onkey,
+						  work.work);
+
+	da9052_onkey_query(onkey);
+}
+
+static irqreturn_t da9052_onkey_irq(int irq, void *data)
+{
+	struct da9052_onkey *onkey = data;
+
+	da9052_onkey_query(onkey);
+
+	return IRQ_HANDLED;
+}
+
+static int da9052_onkey_probe(struct platform_device *pdev)
+{
+	struct da9052 *da9052 = dev_get_drvdata(pdev->dev.parent);
+	struct da9052_onkey *onkey;
+	struct input_dev *input_dev;
+	int error;
+
+	if (!da9052) {
+		dev_err(&pdev->dev, "Failed to get the driver's data\n");
+		return -EINVAL;
+	}
+
+	onkey = kzalloc(sizeof(*onkey), GFP_KERNEL);
+	input_dev = input_allocate_device();
+	if (!onkey || !input_dev) {
+		dev_err(&pdev->dev, "Failed to allocate memory\n");
+		error = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	onkey->input = input_dev;
+	onkey->da9052 = da9052;
+	INIT_DELAYED_WORK(&onkey->work, da9052_onkey_work);
+
+	input_dev->name = "da9052-onkey";
+	input_dev->phys = "da9052-onkey/input0";
+	input_dev->dev.parent = &pdev->dev;
+
+	input_dev->evbit[0] = BIT_MASK(EV_KEY);
+	__set_bit(KEY_POWER, input_dev->keybit);
+
+	error = da9052_request_irq(onkey->da9052, DA9052_IRQ_NONKEY, "ONKEY",
+			    da9052_onkey_irq, onkey);
+	if (error < 0) {
+		dev_err(onkey->da9052->dev,
+			"Failed to register ONKEY IRQ: %d\n", error);
+		goto err_free_mem;
+	}
+
+	error = input_register_device(onkey->input);
+	if (error) {
+		dev_err(&pdev->dev, "Unable to register input device, %d\n",
+			error);
+		goto err_free_irq;
+	}
+
+	platform_set_drvdata(pdev, onkey);
+	return 0;
+
+err_free_irq:
+	da9052_free_irq(onkey->da9052, DA9052_IRQ_NONKEY, onkey);
+	cancel_delayed_work_sync(&onkey->work);
+err_free_mem:
+	input_free_device(input_dev);
+	kfree(onkey);
+
+	return error;
+}
+
+static int da9052_onkey_remove(struct platform_device *pdev)
+{
+	struct da9052_onkey *onkey = platform_get_drvdata(pdev);
+
+	da9052_free_irq(onkey->da9052, DA9052_IRQ_NONKEY, onkey);
+	cancel_delayed_work_sync(&onkey->work);
+
+	input_unregister_device(onkey->input);
+	kfree(onkey);
+
+	return 0;
+}
+
+static struct platform_driver da9052_onkey_driver = {
+	.probe	= da9052_onkey_probe,
+	.remove	= da9052_onkey_remove,
+	.driver = {
+		.name	= "da9052-onkey",
+		.owner	= THIS_MODULE,
+	},
+};
+module_platform_driver(da9052_onkey_driver);
+
+MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");
+MODULE_DESCRIPTION("Onkey driver for DA9052");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:da9052-onkey");
diff --git a/drivers/input/misc/da9055_onkey.c b/drivers/input/misc/da9055_onkey.c
new file mode 100644
index 00000000..ee6ae3a0
--- /dev/null
+++ b/drivers/input/misc/da9055_onkey.c
@@ -0,0 +1,171 @@
+/*
+ * ON pin driver for Dialog DA9055 PMICs
+ *
+ * Copyright(c) 2012 Dialog Semiconductor Ltd.
+ *
+ * Author: David Dajun Chen <dchen@diasemi.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+
+#include <linux/mfd/da9055/core.h>
+#include <linux/mfd/da9055/reg.h>
+
+struct da9055_onkey {
+	struct da9055 *da9055;
+	struct input_dev *input;
+	struct delayed_work work;
+};
+
+static void da9055_onkey_query(struct da9055_onkey *onkey)
+{
+	int key_stat;
+
+	key_stat = da9055_reg_read(onkey->da9055, DA9055_REG_STATUS_A);
+	if (key_stat < 0) {
+		dev_err(onkey->da9055->dev,
+			"Failed to read onkey event %d\n", key_stat);
+	} else {
+		key_stat &= DA9055_NOKEY_STS;
+		/*
+		 * Onkey status bit is cleared when onkey button is relased.
+		 */
+		if (!key_stat) {
+			input_report_key(onkey->input, KEY_POWER, 0);
+			input_sync(onkey->input);
+		}
+	}
+
+	/*
+	 * Interrupt is generated only when the ONKEY pin is asserted.
+	 * Hence the deassertion of the pin is simulated through work queue.
+	 */
+	if (key_stat)
+		schedule_delayed_work(&onkey->work, msecs_to_jiffies(10));
+
+}
+
+static void da9055_onkey_work(struct work_struct *work)
+{
+	struct da9055_onkey *onkey = container_of(work, struct da9055_onkey,
+						  work.work);
+
+	da9055_onkey_query(onkey);
+}
+
+static irqreturn_t da9055_onkey_irq(int irq, void *data)
+{
+	struct da9055_onkey *onkey = data;
+
+	input_report_key(onkey->input, KEY_POWER, 1);
+	input_sync(onkey->input);
+
+	da9055_onkey_query(onkey);
+
+	return IRQ_HANDLED;
+}
+
+static int da9055_onkey_probe(struct platform_device *pdev)
+{
+	struct da9055 *da9055 = dev_get_drvdata(pdev->dev.parent);
+	struct da9055_onkey *onkey;
+	struct input_dev *input_dev;
+	int irq, err;
+
+	irq = platform_get_irq_byname(pdev, "ONKEY");
+	if (irq < 0) {
+		dev_err(&pdev->dev,
+			"Failed to get an IRQ for input device, %d\n", irq);
+		return -EINVAL;
+	}
+
+	onkey = devm_kzalloc(&pdev->dev, sizeof(*onkey), GFP_KERNEL);
+	if (!onkey) {
+		dev_err(&pdev->dev, "Failed to allocate memory\n");
+		return -ENOMEM;
+	}
+
+	input_dev = input_allocate_device();
+	if (!input_dev) {
+		dev_err(&pdev->dev, "Failed to allocate memory\n");
+		return -ENOMEM;
+	}
+
+	onkey->input = input_dev;
+	onkey->da9055 = da9055;
+	input_dev->name = "da9055-onkey";
+	input_dev->phys = "da9055-onkey/input0";
+	input_dev->dev.parent = &pdev->dev;
+
+	input_dev->evbit[0] = BIT_MASK(EV_KEY);
+	__set_bit(KEY_POWER, input_dev->keybit);
+
+	INIT_DELAYED_WORK(&onkey->work, da9055_onkey_work);
+
+	irq = regmap_irq_get_virq(da9055->irq_data, irq);
+	err = request_threaded_irq(irq, NULL, da9055_onkey_irq,
+				   IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
+				   "ONKEY", onkey);
+	if (err < 0) {
+		dev_err(&pdev->dev,
+			"Failed to register ONKEY IRQ %d, error = %d\n",
+			irq, err);
+		goto err_free_input;
+	}
+
+	err = input_register_device(input_dev);
+	if (err) {
+		dev_err(&pdev->dev, "Unable to register input device, %d\n",
+			err);
+		goto err_free_irq;
+	}
+
+	platform_set_drvdata(pdev, onkey);
+
+	return 0;
+
+err_free_irq:
+	free_irq(irq, onkey);
+	cancel_delayed_work_sync(&onkey->work);
+err_free_input:
+	input_free_device(input_dev);
+
+	return err;
+}
+
+static int da9055_onkey_remove(struct platform_device *pdev)
+{
+	struct da9055_onkey *onkey = platform_get_drvdata(pdev);
+	int irq = platform_get_irq_byname(pdev, "ONKEY");
+
+	irq = regmap_irq_get_virq(onkey->da9055->irq_data, irq);
+	free_irq(irq, onkey);
+	cancel_delayed_work_sync(&onkey->work);
+	input_unregister_device(onkey->input);
+
+	return 0;
+}
+
+static struct platform_driver da9055_onkey_driver = {
+	.probe	= da9055_onkey_probe,
+	.remove	= da9055_onkey_remove,
+	.driver = {
+		.name	= "da9055-onkey",
+		.owner	= THIS_MODULE,
+	},
+};
+
+module_platform_driver(da9055_onkey_driver);
+
+MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");
+MODULE_DESCRIPTION("Onkey driver for DA9055");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:da9055-onkey");
diff --git a/drivers/input/misc/dm355evm_keys.c b/drivers/input/misc/dm355evm_keys.c
new file mode 100644
index 00000000..a309a5c0
--- /dev/null
+++ b/drivers/input/misc/dm355evm_keys.c
@@ -0,0 +1,273 @@
+/*
+ * dm355evm_keys.c - support buttons and IR remote on DM355 EVM board
+ *
+ * Copyright (c) 2008 by David Brownell
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+
+#include <linux/i2c/dm355evm_msp.h>
+#include <linux/module.h>
+
+
+/*
+ * The MSP430 firmware on the DM355 EVM monitors on-board pushbuttons
+ * and an IR receptor used for the remote control.  When any key is
+ * pressed, or its autorepeat kicks in, an event is sent.  This driver
+ * read those events from the small (32 event) queue and reports them.
+ *
+ * Note that physically there can only be one of these devices.
+ *
+ * This driver was tested with firmware revision A4.
+ */
+struct dm355evm_keys {
+	struct input_dev	*input;
+	struct device		*dev;
+	int			irq;
+};
+
+/* These initial keycodes can be remapped */
+static const struct key_entry dm355evm_keys[] = {
+	/*
+	 * Pushbuttons on the EVM board ... note that the labels for these
+	 * are SW10/SW11/etc on the PC board.  The left/right orientation
+	 * comes only from the firmware's documentation, and presumes the
+	 * power connector is immediately in front of you and the IR sensor
+	 * is to the right.  (That is, rotate the board counter-clockwise
+	 * by 90 degrees from the SW10/etc and "DM355 EVM" labels.)
+	 */
+	{ KE_KEY, 0x00d8, { KEY_OK } },		/* SW12 */
+	{ KE_KEY, 0x00b8, { KEY_UP } },		/* SW13 */
+	{ KE_KEY, 0x00e8, { KEY_DOWN } },	/* SW11 */
+	{ KE_KEY, 0x0078, { KEY_LEFT } },	/* SW14 */
+	{ KE_KEY, 0x00f0, { KEY_RIGHT } },	/* SW10 */
+
+	/*
+	 * IR buttons ... codes assigned to match the universal remote
+	 * provided with the EVM (Philips PM4S) using DVD code 0020.
+	 *
+	 * These event codes match firmware documentation, but other
+	 * remote controls could easily send more RC5-encoded events.
+	 * The PM4S manual was used in several cases to help select
+	 * a keycode reflecting the intended usage.
+	 *
+	 * RC5 codes are 14 bits, with two start bits (0x3 prefix)
+	 * and a toggle bit (masked out below).
+	 */
+	{ KE_KEY, 0x300c, { KEY_POWER } },	/* NOTE: docs omit this */
+	{ KE_KEY, 0x3000, { KEY_NUMERIC_0 } },
+	{ KE_KEY, 0x3001, { KEY_NUMERIC_1 } },
+	{ KE_KEY, 0x3002, { KEY_NUMERIC_2 } },
+	{ KE_KEY, 0x3003, { KEY_NUMERIC_3 } },
+	{ KE_KEY, 0x3004, { KEY_NUMERIC_4 } },
+	{ KE_KEY, 0x3005, { KEY_NUMERIC_5 } },
+	{ KE_KEY, 0x3006, { KEY_NUMERIC_6 } },
+	{ KE_KEY, 0x3007, { KEY_NUMERIC_7 } },
+	{ KE_KEY, 0x3008, { KEY_NUMERIC_8 } },
+	{ KE_KEY, 0x3009, { KEY_NUMERIC_9 } },
+	{ KE_KEY, 0x3022, { KEY_ENTER } },
+	{ KE_KEY, 0x30ec, { KEY_MODE } },	/* "tv/vcr/..." */
+	{ KE_KEY, 0x300f, { KEY_SELECT } },	/* "info" */
+	{ KE_KEY, 0x3020, { KEY_CHANNELUP } },	/* "up" */
+	{ KE_KEY, 0x302e, { KEY_MENU } },	/* "in/out" */
+	{ KE_KEY, 0x3011, { KEY_VOLUMEDOWN } },	/* "left" */
+	{ KE_KEY, 0x300d, { KEY_MUTE } },	/* "ok" */
+	{ KE_KEY, 0x3010, { KEY_VOLUMEUP } },	/* "right" */
+	{ KE_KEY, 0x301e, { KEY_SUBTITLE } },	/* "cc" */
+	{ KE_KEY, 0x3021, { KEY_CHANNELDOWN } },/* "down" */
+	{ KE_KEY, 0x3022, { KEY_PREVIOUS } },
+	{ KE_KEY, 0x3026, { KEY_SLEEP } },
+	{ KE_KEY, 0x3172, { KEY_REWIND } },	/* NOTE: docs wrongly say 0x30ca */
+	{ KE_KEY, 0x3175, { KEY_PLAY } },
+	{ KE_KEY, 0x3174, { KEY_FASTFORWARD } },
+	{ KE_KEY, 0x3177, { KEY_RECORD } },
+	{ KE_KEY, 0x3176, { KEY_STOP } },
+	{ KE_KEY, 0x3169, { KEY_PAUSE } },
+};
+
+/*
+ * Because we communicate with the MSP430 using I2C, and all I2C calls
+ * in Linux sleep, we use a threaded IRQ handler.  The IRQ itself is
+ * active low, but we go through the GPIO controller so we can trigger
+ * on falling edges and not worry about enabling/disabling the IRQ in
+ * the keypress handling path.
+ */
+static irqreturn_t dm355evm_keys_irq(int irq, void *_keys)
+{
+	static u16 last_event;
+	struct dm355evm_keys *keys = _keys;
+	const struct key_entry *ke;
+	unsigned int keycode;
+	int status;
+	u16 event;
+
+	/* For simplicity we ignore INPUT_COUNT and just read
+	 * events until we get the "queue empty" indicator.
+	 * Reading INPUT_LOW decrements the count.
+	 */
+	for (;;) {
+		status = dm355evm_msp_read(DM355EVM_MSP_INPUT_HIGH);
+		if (status < 0) {
+			dev_dbg(keys->dev, "input high err %d\n",
+					status);
+			break;
+		}
+		event = status << 8;
+
+		status = dm355evm_msp_read(DM355EVM_MSP_INPUT_LOW);
+		if (status < 0) {
+			dev_dbg(keys->dev, "input low err %d\n",
+					status);
+			break;
+		}
+		event |= status;
+		if (event == 0xdead)
+			break;
+
+		/* Press and release a button:  two events, same code.
+		 * Press and hold (autorepeat), then release: N events
+		 * (N > 2), same code.  For RC5 buttons the toggle bits
+		 * distinguish (for example) "1-autorepeat" from "1 1";
+		 * but PCB buttons don't support that bit.
+		 *
+		 * So we must synthesize release events.  We do that by
+		 * mapping events to a press/release event pair; then
+		 * to avoid adding extra events, skip the second event
+		 * of each pair.
+		 */
+		if (event == last_event) {
+			last_event = 0;
+			continue;
+		}
+		last_event = event;
+
+		/* ignore the RC5 toggle bit */
+		event &= ~0x0800;
+
+		/* find the key, or report it as unknown */
+		ke = sparse_keymap_entry_from_scancode(keys->input, event);
+		keycode = ke ? ke->keycode : KEY_UNKNOWN;
+		dev_dbg(keys->dev,
+			"input event 0x%04x--> keycode %d\n",
+			event, keycode);
+
+		/* report press + release */
+		input_report_key(keys->input, keycode, 1);
+		input_sync(keys->input);
+		input_report_key(keys->input, keycode, 0);
+		input_sync(keys->input);
+	}
+
+	return IRQ_HANDLED;
+}
+
+/*----------------------------------------------------------------------*/
+
+static int dm355evm_keys_probe(struct platform_device *pdev)
+{
+	struct dm355evm_keys	*keys;
+	struct input_dev	*input;
+	int			status;
+
+	/* allocate instance struct and input dev */
+	keys = kzalloc(sizeof *keys, GFP_KERNEL);
+	input = input_allocate_device();
+	if (!keys || !input) {
+		status = -ENOMEM;
+		goto fail1;
+	}
+
+	keys->dev = &pdev->dev;
+	keys->input = input;
+
+	/* set up "threaded IRQ handler" */
+	status = platform_get_irq(pdev, 0);
+	if (status < 0)
+		goto fail1;
+	keys->irq = status;
+
+	input_set_drvdata(input, keys);
+
+	input->name = "DM355 EVM Controls";
+	input->phys = "dm355evm/input0";
+	input->dev.parent = &pdev->dev;
+
+	input->id.bustype = BUS_I2C;
+	input->id.product = 0x0355;
+	input->id.version = dm355evm_msp_read(DM355EVM_MSP_FIRMREV);
+
+	status = sparse_keymap_setup(input, dm355evm_keys, NULL);
+	if (status)
+		goto fail1;
+
+	/* REVISIT:  flush the event queue? */
+
+	status = request_threaded_irq(keys->irq, NULL, dm355evm_keys_irq,
+				      IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+				      dev_name(&pdev->dev), keys);
+	if (status < 0)
+		goto fail2;
+
+	/* register */
+	status = input_register_device(input);
+	if (status < 0)
+		goto fail3;
+
+	platform_set_drvdata(pdev, keys);
+
+	return 0;
+
+fail3:
+	free_irq(keys->irq, keys);
+fail2:
+	sparse_keymap_free(input);
+fail1:
+	input_free_device(input);
+	kfree(keys);
+	dev_err(&pdev->dev, "can't register, err %d\n", status);
+
+	return status;
+}
+
+static int dm355evm_keys_remove(struct platform_device *pdev)
+{
+	struct dm355evm_keys	*keys = platform_get_drvdata(pdev);
+
+	free_irq(keys->irq, keys);
+	sparse_keymap_free(keys->input);
+	input_unregister_device(keys->input);
+	kfree(keys);
+
+	return 0;
+}
+
+/* REVISIT:  add suspend/resume when DaVinci supports it.  The IRQ should
+ * be able to wake up the system.  When device_may_wakeup(&pdev->dev), call
+ * enable_irq_wake() on suspend, and disable_irq_wake() on resume.
+ */
+
+/*
+ * I2C is used to talk to the MSP430, but this platform device is
+ * exposed by an MFD driver that manages I2C communications.
+ */
+static struct platform_driver dm355evm_keys_driver = {
+	.probe		= dm355evm_keys_probe,
+	.remove		= dm355evm_keys_remove,
+	.driver		= {
+		.owner	= THIS_MODULE,
+		.name	= "dm355evm_keys",
+	},
+};
+module_platform_driver(dm355evm_keys_driver);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/epl2182_pls_v2.c b/drivers/input/misc/epl2182_pls_v2.c
new file mode 100644
index 00000000..6d14770c
--- /dev/null
+++ b/drivers/input/misc/epl2182_pls_v2.c
@@ -0,0 +1,1496 @@
+/* drivers/i2c/chips/epl2182.c - light and proxmity sensors driver
+ * Copyright (C) 2011 ELAN Corporation.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/hrtimer.h>
+#include <linux/timer.h>
+#include <linux/delay.h>
+#include <linux/earlysuspend.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+#include <linux/irq.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/miscdevice.h>
+#include <linux/slab.h>
+#include <asm/uaccess.h>
+//#include <asm/mach-types.h>
+#include <asm/setup.h>
+#include <linux/wakelock.h>
+#include <linux/jiffies.h>
+#include <linux/regulator/consumer.h>
+#include <linux/platform_device.h>
+#include <linux/poll.h>
+#include <linux/i2c/epl2182_pls_v2.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+
+/******************************************************************************
+ * configuration
+*******************************************************************************/
+#define PS_INTERRUPT_MODE		1		// 0 is polling mode, 1 is interrupt mode
+#define PLSENSOR_ADAPTIVE
+#ifdef PLSENSOR_ADAPTIVE
+/*ensure the initial value can enable Psensor interrupt,the ps_state of the initial value will be 0*/
+static u16 P_SENSOR_LTHD = 0x7fff;   //init
+static u16 P_SENSOR_HTHD = 0x0;       //init
+#else
+#define P_SENSOR_LTHD                  1900//120         //100
+#define P_SENSOR_HTHD                  2000//170         //500
+#endif
+
+#define PS_POLLING_RATE			100
+#define ALS_POLLING_RATE		1000
+
+#define LUX_PER_COUNT			440		// 660 = 1.1*0.6*1000
+#ifdef PLSENSOR_ADAPTIVE
+#define DEBOUNCE 30
+#define MIN_SPACING 250
+#define DIVEDE 4
+static bool first_do_irq = true;
+static u16 ps_min = 0;
+static u16 ps_max = 0;
+static u16 ps_threshold = 0;
+#endif
+/******************************************************************************
+ * configuration
+*******************************************************************************/
+
+typedef enum
+{
+    CMC_MODE_ALS    = 0x00,
+    CMC_MODE_PS     = 0x10,
+} CMC_MODE;
+
+#define TXBYTES				2
+#define RXBYTES				2
+
+#define PS_DELAY			50
+#define ALS_DELAY			55
+
+#define PACKAGE_SIZE		2
+#define I2C_RETRY_COUNT		10
+#define P_INTT				1
+
+#define PS_INTT				4
+#define ALS_INTT			6	//5-8
+
+static int set_psensor_intr_threshold(uint16_t low_thd, uint16_t high_thd);
+
+#if PS_INTERRUPT_MODE
+static void epl_sensor_irq_do_work(struct work_struct *work);
+static DECLARE_WORK(epl_sensor_irq_work, epl_sensor_irq_do_work);
+#endif
+
+static void report_polling_do_work(struct work_struct *work);
+static DECLARE_DELAYED_WORK(report_polling_work, report_polling_do_work);
+static void polling_do_work(struct work_struct *work);
+static DECLARE_DELAYED_WORK(polling_work, polling_do_work);
+
+/* primitive raw data from I2C */
+typedef struct _epl_raw_data
+{
+    u8 raw_bytes[PACKAGE_SIZE];
+    u16 ps_state;
+    u16 ps_int_state;
+    u16 ps_ch1_raw;
+    u16 als_ch1_raw;
+} epl_raw_data;
+
+struct elan_epl_data
+{
+    struct i2c_client *client;
+    //struct input_dev *als_input_dev;
+    struct input_dev *ps_input_dev;
+    struct workqueue_struct *epl_wq;
+    struct early_suspend early_suspend;
+
+    int intr_pin;
+    //int (*power)(int on);
+
+    int ps_opened;
+    int als_opened;
+
+    int enable_pflag;
+    int enable_lflag;
+    int read_flag;
+    int irq;
+} ;
+
+static DECLARE_WAIT_QUEUE_HEAD(ps_waitqueue);
+static DECLARE_WAIT_QUEUE_HEAD(ls_waitqueue);
+
+
+static int ps_data_changed;
+static int ls_data_changed;
+static struct i2c_client *this_client = NULL;
+
+//static struct wake_lock g_ps_wlock;
+struct elan_epl_data *epl_data;
+static epl_raw_data	gRawData;
+static int dual_count;
+
+static const char ElanPsensorName[] = "proximity";
+static const char ElanALsensorName[] = "lightsensor-level";
+
+static int psensor_mode_suspend = 0;
+
+#define LOG_TAG				        "[EPL2182] "
+#define LOG_FUN(f)			        printk(KERN_INFO LOG_TAG"%s\n", __FUNCTION__)
+#define LOG_INFO(fmt, args...)		printk(KERN_INFO LOG_TAG fmt, ##args)
+#define LOG_ERR(fmt, args...)		printk(KERN_ERR  LOG_TAG"%s %d : "fmt, __FUNCTION__, __LINE__, ##args)
+
+/*
+//====================I2C write operation===============//
+//regaddr: ELAN Register Address.
+//bytecount: How many bytes to be written to register via i2c bus.
+//txbyte: I2C bus transmit byte(s). Single byte(0X01) transmit only slave address.
+//data: setting value.
+//
+// Example: If you want to write single byte to 0x1D register address, show below
+//	      elan_sensor_I2C_Write(client,0x1D,0x01,0X02,0xff);
+//
+*/
+static int elan_sensor_I2C_Write(struct i2c_client *client, uint8_t regaddr, uint8_t bytecount, uint8_t txbyte, uint8_t data)
+{
+    uint8_t buffer[2];
+    int ret = 0;
+    int retry,val;
+    struct elan_epl_data *epld = epl_data;
+
+    buffer[0] = (regaddr<<3) | bytecount ;
+    buffer[1] = data;
+
+    for(retry = 0; retry < I2C_RETRY_COUNT; retry++)
+    {
+        ret = i2c_master_send(client, buffer, txbyte);
+
+        if (ret == txbyte)
+        {
+            break;
+        }
+
+        val = gpio_get_value(epld->intr_pin);
+
+        LOG_INFO("INTERRUPT GPIO val = %d\n",  val);
+
+        msleep(10);
+    }
+
+    if(retry>=I2C_RETRY_COUNT)
+    {
+        LOG_ERR(KERN_ERR "i2c write retry over %d\n", I2C_RETRY_COUNT);
+        return -EINVAL;
+    }
+
+    return ret;
+}
+
+static int elan_sensor_I2C_Read(struct i2c_client *client)
+{
+    uint8_t buffer[RXBYTES];
+    int ret = 0, i =0;
+    int retry,val;
+    struct elan_epl_data *epld = epl_data;
+
+    for(retry = 0; retry < I2C_RETRY_COUNT; retry++)
+    {
+        ret = i2c_master_recv(client, buffer, RXBYTES);
+
+        if (ret == RXBYTES)
+            break;
+
+        val = gpio_get_value(epld->intr_pin);
+
+        LOG_INFO("INTERRUPT GPIO val = %d\n", val);
+
+        msleep(10);
+    }
+
+    if(retry>=I2C_RETRY_COUNT)
+    {
+        LOG_ERR("i2c read retry over %d\n", I2C_RETRY_COUNT);
+        return -EINVAL;
+    }
+
+    for(i=0; i<PACKAGE_SIZE; i++)
+    {
+        gRawData.raw_bytes[i] = buffer[i];
+    }
+
+    return ret;
+}
+
+static void elan_sensor_restart_work(void)
+{
+    struct elan_epl_data *epld = epl_data;
+    cancel_delayed_work(&polling_work);
+    cancel_delayed_work(&report_polling_work);
+    queue_delayed_work(epld->epl_wq, &polling_work,msecs_to_jiffies(10));
+}
+
+static int elan_sensor_psensor_enable(struct elan_epl_data *epld)
+{
+    int ret;
+    uint8_t regdata = 0;
+    struct i2c_client *client = epld->client;
+
+    LOG_INFO("--- Proximity sensor Enable --- \n");
+
+    //disable_irq(epld->irq);
+    ret = elan_sensor_I2C_Write(client,REG_9,W_SINGLE_BYTE,0x02,EPL_INT_DISABLE);
+
+    regdata = EPL_SENSING_8_TIME | EPL_PS_MODE | EPL_L_GAIN ;
+    regdata = regdata | (PS_INTERRUPT_MODE ? EPL_C_SENSING_MODE : EPL_S_SENSING_MODE);
+    ret = elan_sensor_I2C_Write(client,REG_0,W_SINGLE_BYTE,0X02,regdata);
+
+    regdata = PS_INTT<<4 | EPL_PST_1_TIME | EPL_10BIT_ADC;
+    ret = elan_sensor_I2C_Write(client,REG_1,W_SINGLE_BYTE,0X02,regdata);
+
+    set_psensor_intr_threshold(P_SENSOR_LTHD ,P_SENSOR_HTHD);
+#ifdef PLSENSOR_ADAPTIVE
+    if (true == first_do_irq) {
+            msleep(PS_DELAY);
+            elan_sensor_I2C_Write(client,REG_13,R_SINGLE_BYTE,0x01,0);
+            elan_sensor_I2C_Read(client);
+            gRawData.ps_state= !((gRawData.raw_bytes[0]&0x04)>>2);
+            elan_sensor_I2C_Write(client,REG_16,R_TWO_BYTE,0x01,0x00);
+            elan_sensor_I2C_Read(client);
+            gRawData.ps_ch1_raw = (gRawData.raw_bytes[1]<<8) | gRawData.raw_bytes[0];
+            P_SENSOR_LTHD = gRawData.ps_ch1_raw + MIN_SPACING - DEBOUNCE;
+            P_SENSOR_HTHD = gRawData.ps_ch1_raw + MIN_SPACING - DEBOUNCE;
+            set_psensor_intr_threshold(P_SENSOR_LTHD ,P_SENSOR_HTHD);
+    }
+#endif
+
+    ret = elan_sensor_I2C_Write(client,REG_7,W_SINGLE_BYTE,0X02,EPL_C_RESET);
+    ret = elan_sensor_I2C_Write(client,REG_7,W_SINGLE_BYTE,0x02,EPL_C_START_RUN);
+
+#if PS_INTERRUPT_MODE
+    if(epld->enable_lflag)
+    {
+        msleep(PS_DELAY);
+        elan_sensor_I2C_Write(client,REG_13,R_SINGLE_BYTE,0x01,0);
+        elan_sensor_I2C_Read(client);
+        gRawData.ps_state= !((gRawData.raw_bytes[0]&0x04)>>2);
+
+        if(gRawData.ps_state!= gRawData.ps_int_state)
+        {
+            elan_sensor_I2C_Write(client,REG_9,W_SINGLE_BYTE,0x02,EPL_INT_FRAME_ENABLE);
+        }
+        else
+        {
+            elan_sensor_I2C_Write(client,REG_9,W_SINGLE_BYTE,0x02,EPL_INT_ACTIVE_LOW);
+        }
+
+    }
+    else
+    {
+        elan_sensor_I2C_Write(client,REG_9,W_SINGLE_BYTE,0x02,EPL_INT_ACTIVE_LOW);
+    }
+    //enable_irq(epld->irq);
+#endif
+
+    if (ret != 0x02)
+    {
+        LOG_INFO("P-sensor i2c err\n");
+    }
+
+    return ret;
+}
+
+static int elan_sensor_lsensor_enable(struct elan_epl_data *epld)
+{
+    int ret;
+    uint8_t regdata = 0;
+    struct i2c_client *client = epld->client;
+
+    LOG_INFO("--- ALS sensor Enable --- \n");
+
+    //disable_irq(epld->irq);
+    regdata = EPL_INT_DISABLE;
+    ret = elan_sensor_I2C_Write(client,REG_9,W_SINGLE_BYTE,0x02, regdata);
+
+    regdata = EPL_S_SENSING_MODE | EPL_SENSING_8_TIME | EPL_ALS_MODE | EPL_AUTO_GAIN;
+    ret = elan_sensor_I2C_Write(client,REG_0,W_SINGLE_BYTE,0X02,regdata);
+
+    regdata = ALS_INTT<<4 | EPL_PST_1_TIME | EPL_10BIT_ADC;
+    ret = elan_sensor_I2C_Write(client,REG_1,W_SINGLE_BYTE,0X02,regdata);
+
+    ret = elan_sensor_I2C_Write(client,REG_10,W_SINGLE_BYTE,0x02, EPL_GO_MID);
+    ret = elan_sensor_I2C_Write(client,REG_11,W_SINGLE_BYTE,0x02, EPL_GO_LOW);
+
+    ret = elan_sensor_I2C_Write(client,REG_7,W_SINGLE_BYTE,0X02,EPL_C_RESET);
+    ret = elan_sensor_I2C_Write(client,REG_7,W_SINGLE_BYTE,0x02,EPL_C_START_RUN);
+
+    if(ret != 0x02)
+    {
+        LOG_INFO(" ALS-sensor i2c err\n");
+    }
+
+    return ret;
+
+}
+
+/*
+//====================elan_epl_ps_poll_rawdata===============//
+//polling method for proximity sensor detect. Report proximity sensor raw data.
+//Report "ABS_DISTANCE" event to HAL layer.
+//Variable "value" 0 and 1 to represent which distance from psensor to target(human's face..etc).
+//value: 0 represent near.
+//value: 1 represent far.
+*/
+static int elan_epl_ps_poll_rawdata(void)
+{
+    struct elan_epl_data *epld = epl_data;
+    struct i2c_client *client = epld->client;
+    u16 value = 0;
+
+    elan_sensor_I2C_Write(epld->client,REG_7,W_SINGLE_BYTE,0x02,EPL_DATA_LOCK);
+
+    elan_sensor_I2C_Write(client,REG_13,R_SINGLE_BYTE,0x01,0);
+    elan_sensor_I2C_Read(client);
+    gRawData.ps_state= !((gRawData.raw_bytes[0]&0x04)>>2);
+
+    elan_sensor_I2C_Write(client,REG_16,R_TWO_BYTE,0x01,0x00);
+    elan_sensor_I2C_Read(client);
+    gRawData.ps_ch1_raw = (gRawData.raw_bytes[1]<<8) | gRawData.raw_bytes[0];
+
+#ifdef PLSENSOR_ADAPTIVE
+    value = gRawData.ps_ch1_raw;
+    /*threshold detect process*/
+    if(0 == ps_max || 0 == ps_min) {
+        ps_min = value;
+        ps_max = value;
+        ps_threshold = ps_min + MIN_SPACING;
+    }
+    if(value > ps_max) {
+        ps_max = value;
+        ps_threshold = ((ps_max - ps_min)  / DIVEDE) + ps_min;
+        if(ps_threshold - ps_min < MIN_SPACING)
+              ps_threshold = ps_min + MIN_SPACING;
+    } else if(value < ps_min) {
+        ps_min = value;
+        ps_threshold = ((ps_max - ps_min)  / DIVEDE) + ps_min;
+        if(ps_threshold - ps_min < MIN_SPACING)
+              ps_threshold = ps_min + MIN_SPACING;
+    }
+    P_SENSOR_LTHD = ps_threshold - DEBOUNCE;
+    P_SENSOR_HTHD = ps_threshold + DEBOUNCE;
+    set_psensor_intr_threshold(P_SENSOR_LTHD ,P_SENSOR_HTHD);
+    /*threshold detect process end*/
+    LOG_INFO("ps_min (%4d), ps_max (%4d), ps_threshold (%4d)\n", ps_min, ps_max, ps_threshold);
+    if (true == first_do_irq)
+            first_do_irq = false;
+#endif
+    elan_sensor_I2C_Write(epld->client,REG_7,W_SINGLE_BYTE,0x02,EPL_DATA_UNLOCK);
+    LOG_INFO("### ps_ch1_raw_data  (%d), value(%d) ###\n", gRawData.ps_ch1_raw, gRawData.ps_state);
+    ps_data_changed = 1;
+
+    input_report_abs(epld->ps_input_dev, ABS_DISTANCE, gRawData.ps_state);
+    input_sync(epld->ps_input_dev);
+    return 0;
+}
+
+static void elan_epl_als_rawdata(void)
+{
+    struct elan_epl_data *epld = epl_data;
+    struct i2c_client *client = epld->client;
+    uint32_t lux;
+
+    elan_sensor_I2C_Write(client,REG_16,R_TWO_BYTE,0x01,0x00);
+    elan_sensor_I2C_Read(client);
+    gRawData.als_ch1_raw = (gRawData.raw_bytes[1]<<8) | gRawData.raw_bytes[0];
+
+    lux =  (gRawData.als_ch1_raw* LUX_PER_COUNT) / 1000 * 15 / 100;
+    if(lux>20000)
+        lux=20000;
+
+    LOG_INFO("-------------------  ALS raw = %d, lux = %d\n\n",  gRawData.als_ch1_raw,  lux);
+	ls_data_changed = 1;
+#if 1
+    input_report_abs(epld->ps_input_dev, ABS_MISC, lux);
+    input_sync(epld->ps_input_dev);
+#else
+    input_report_abs(epld->als_input_dev, ABS_MISC, lux);
+    input_sync(epld->als_input_dev);
+#endif
+}
+
+/*
+//====================set_psensor_intr_threshold===============//
+//low_thd: The value is psensor interrupt low threshold.
+//high_thd:	The value is psensor interrupt hihg threshold.
+//When psensor rawdata > hihg_threshold, interrupt pin will be pulled low.
+//After interrupt occur, psensor rawdata < low_threshold, interrupt pin will be pulled high.
+*/
+static int set_psensor_intr_threshold(uint16_t low_thd, uint16_t high_thd)
+{
+    int ret = 0;
+    struct elan_epl_data *epld = epl_data;
+    struct i2c_client *client = epld->client;
+
+    uint8_t high_msb ,high_lsb, low_msb, low_lsb;
+
+    high_msb = (uint8_t) (high_thd >> 8);
+    high_lsb = (uint8_t) (high_thd & 0x00ff);
+    low_msb  = (uint8_t) (low_thd >> 8);
+    low_lsb  = (uint8_t) (low_thd & 0x00ff);
+
+    elan_sensor_I2C_Write(client,REG_2,W_SINGLE_BYTE,0x02,high_lsb);
+    elan_sensor_I2C_Write(client,REG_3,W_SINGLE_BYTE,0x02,high_msb);
+    elan_sensor_I2C_Write(client,REG_4,W_SINGLE_BYTE,0x02,low_lsb);
+    elan_sensor_I2C_Write(client,REG_5,W_SINGLE_BYTE,0x02,low_msb);
+
+    return ret;
+}
+
+#if PS_INTERRUPT_MODE
+static void epl_sensor_irq_do_work(struct work_struct *work)
+{
+    struct elan_epl_data *epld = epl_data;
+    struct i2c_client *client = epld->client;
+    int mode = 0;
+    LOG_FUN();
+
+    elan_sensor_I2C_Write(epld->client,REG_7,W_SINGLE_BYTE,0x02,EPL_DATA_LOCK);
+
+    elan_sensor_I2C_Write(client,REG_13,R_SINGLE_BYTE,0x01,0);
+    elan_sensor_I2C_Read(client);
+    mode = gRawData.raw_bytes[0]&(3<<4);
+
+    // 0x10 is ps mode
+    if(mode==CMC_MODE_PS && epld->enable_pflag)
+    {
+        gRawData.ps_int_state= !((gRawData.raw_bytes[0]&0x04)>>2);
+        elan_epl_ps_poll_rawdata();
+    }
+    else
+    {
+        LOG_INFO("interrupt in als\n");
+    }
+    elan_sensor_I2C_Write(client,REG_9,W_SINGLE_BYTE,0x02,EPL_INT_ACTIVE_LOW);
+    elan_sensor_I2C_Write(client,REG_7,W_SINGLE_BYTE,0x02,EPL_DATA_UNLOCK);
+    enable_irq(epld->irq);
+}
+
+static irqreturn_t elan_sensor_irq_handler(int irqNo, void *handle)
+{
+    struct elan_epl_data *epld = (struct elan_epl_data*)handle;
+
+    disable_irq_nosync(epld->irq);
+    queue_work(epld->epl_wq, &epl_sensor_irq_work);
+
+    return IRQ_HANDLED;
+}
+#endif
+
+static void report_polling_do_work(struct work_struct *work)
+{
+    struct elan_epl_data *epld = epl_data;
+
+    if(dual_count==CMC_MODE_PS)
+    {
+        elan_epl_ps_poll_rawdata();
+    }
+    else if(dual_count==CMC_MODE_ALS)
+    {
+        elan_epl_als_rawdata();
+    }
+
+    if(epld->enable_pflag)
+    {
+        elan_sensor_psensor_enable(epld);
+
+        if(PS_INTERRUPT_MODE==0)
+        {
+            dual_count=CMC_MODE_PS; // ps mode
+            queue_delayed_work(epld->epl_wq, &report_polling_work,msecs_to_jiffies(PS_POLLING_RATE));
+        }
+    }
+}
+
+static void polling_do_work(struct work_struct *work)
+{
+    struct elan_epl_data *epld = epl_data;
+    struct i2c_client *client = epld->client;
+
+    bool isInterleaving = epld->enable_pflag==1 && epld->enable_lflag==1;
+    bool isAlsOnly = epld->enable_pflag==0 && epld->enable_lflag==1;
+    bool isPsOnly = epld->enable_pflag==1 && epld->enable_lflag==0;
+
+    cancel_delayed_work(&polling_work);
+    cancel_delayed_work(&report_polling_work);
+
+    LOG_INFO("enable_pflag = %d, enable_lflag = %d\n", epld->enable_pflag, epld->enable_lflag);
+
+    if(isAlsOnly || isInterleaving)
+    {
+        elan_sensor_lsensor_enable(epld);
+        dual_count = CMC_MODE_ALS;
+
+        queue_delayed_work(epld->epl_wq, &report_polling_work,msecs_to_jiffies(ALS_DELAY));
+        queue_delayed_work(epld->epl_wq, &polling_work,msecs_to_jiffies(ALS_POLLING_RATE));
+    }
+    else if(isPsOnly)
+    {
+        elan_sensor_psensor_enable(epld);
+        dual_count = CMC_MODE_PS;
+
+        if(PS_INTERRUPT_MODE)
+        {
+            // do nothing
+        }
+        else
+        {
+            queue_delayed_work(epld->epl_wq, &report_polling_work,msecs_to_jiffies(PS_DELAY));
+            queue_delayed_work(epld->epl_wq, &polling_work,msecs_to_jiffies(PS_POLLING_RATE));
+        }
+    }
+    else
+    {
+        elan_sensor_I2C_Write(client,REG_9,W_SINGLE_BYTE,0x02,EPL_INT_DISABLE);
+        elan_sensor_I2C_Write(client,REG_0,W_SINGLE_BYTE,0X02,EPL_S_SENSING_MODE);
+    }
+}
+
+#if 0
+static ssize_t elan_ls_operationmode_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    uint16_t mode=0;
+    struct elan_epl_data *epld = epl_data;
+    LOG_FUN();
+
+    sscanf(buf, "%hu",&mode);
+    LOG_INFO("==>[operation mode]=%d\n", mode);
+
+    if(mode == 0)
+    {
+        epld->enable_lflag = 0;
+        epld->enable_pflag = 0;
+    }
+    else if(mode == 1)
+    {
+        epld->enable_lflag = 1;
+        epld->enable_pflag = 0;
+    }
+    else if(mode == 2)
+    {
+        epld->enable_lflag = 0;
+        epld->enable_pflag = 1;
+    }
+    else if(mode == 3)
+    {
+        epld->enable_lflag = 1;
+        epld->enable_pflag = 1;
+    }
+    else
+    {
+        LOG_INFO("0: none\n1: als only\n2: ps only\n3: interleaving");
+    }
+
+    elan_sensor_restart_work();
+    return count;
+}
+
+static ssize_t elan_ls_operationmode_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    struct elan_epl_data *epld = epl_data;
+    long *tmp = (long*)buf;
+    uint16_t mode =0;
+    LOG_FUN();
+
+    if(  epld->enable_pflag==0 &&  epld->enable_lflag==0)
+    {
+        mode = 0;
+    }
+    else if(  epld->enable_pflag==0 &&  epld->enable_lflag==1)
+    {
+        mode = 1;
+    }
+    else if(  epld->enable_pflag==1 && epld->enable_lflag==0)
+    {
+        mode = 2;
+    }
+    else if(  epld->enable_pflag==1 && epld->enable_lflag==1)
+    {
+        mode = 3;
+    }
+    tmp[0] = mode;
+    return sprintf(buf, "%d \n", mode);
+}
+
+static ssize_t elan_ls_status_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    struct elan_epl_data *epld = epl_data;
+    u16 ch1;
+
+    if(!epl_data)
+    {
+        LOG_INFO("epl_data is null!!\n");
+        return 0;
+    }
+    elan_sensor_I2C_Write(epld->client,REG_7,W_SINGLE_BYTE,0x02,EPL_DATA_LOCK);
+
+    elan_sensor_I2C_Write(epld->client,REG_16,R_TWO_BYTE,0x01,0x00);
+    elan_sensor_I2C_Read(epld->client);
+    ch1 = (gRawData.raw_bytes[1]<<8) | gRawData.raw_bytes[0];
+    LOG_INFO("ch1 raw_data = %d\n", ch1);
+
+    elan_sensor_I2C_Write(epld->client,REG_7,W_SINGLE_BYTE,0x02,EPL_DATA_UNLOCK);
+
+    return sprintf(buf, "%d\n", ch1);
+}
+
+static DEVICE_ATTR(elan_ls_operationmode, S_IROTH|S_IWOTH, elan_ls_operationmode_show,elan_ls_operationmode_store);
+static DEVICE_ATTR(elan_ls_status, S_IROTH|S_IWOTH, elan_ls_status_show,NULL);
+
+static struct attribute *ets_attributes[] =
+{
+    &dev_attr_elan_ls_operationmode.attr,
+    &dev_attr_elan_ls_status.attr,
+    NULL,
+};
+
+static struct attribute_group ets_attr_group =
+{
+    .attrs = ets_attributes,
+};
+#endif
+
+#if 0   //ices add
+static int elan_als_open(struct inode *inode, struct file *file)
+{
+    struct elan_epl_data *epld = epl_data;
+
+    LOG_FUN();
+
+    if (epld->als_opened)
+    {
+        return -EBUSY;
+    }
+    epld->als_opened = 1;
+
+    return 0;
+}
+
+static int elan_als_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
+{
+    struct elan_epl_data *epld = epl_data;
+    int buf[1];
+    if(epld->read_flag ==1)
+    {
+        buf[0] = gRawData.als_ch1_raw;
+        if(copy_to_user(buffer, &buf , sizeof(buf)))
+            return 0;
+        epld->read_flag = 0;
+        return 12;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+static int elan_als_release(struct inode *inode, struct file *file)
+{
+    struct elan_epl_data *epld = epl_data;
+
+    LOG_FUN();
+
+    epld->als_opened = 0;
+
+    return 0;
+}
+#if 1
+static long elan_als_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+    int flag;
+    unsigned long buf[1];
+    struct elan_epl_data *epld = epl_data;
+
+    void __user *argp = (void __user *)arg;
+
+    LOG_INFO("als io ctrl cmd %d\n", _IOC_NR(cmd));
+
+    switch(cmd)
+    {
+        case ELAN_EPL6800_IOCTL_GET_LFLAG:
+
+            LOG_INFO("elan ambient-light IOCTL Sensor get lflag \n");
+            flag = epld->enable_lflag;
+            if (copy_to_user(argp, &flag, sizeof(flag)))
+                return -EFAULT;
+
+            LOG_INFO("elan ambient-light Sensor get lflag %d\n",flag);
+            break;
+
+        case ELAN_EPL6800_IOCTL_ENABLE_LFLAG:
+
+            LOG_INFO("elan ambient-light IOCTL Sensor set lflag \n");
+            if (copy_from_user(&flag, argp, 1))
+                return -EFAULT;
+			LOG_INFO("elan ambient-light Sensor set lflag %d\n",flag);
+			if(flag) {
+				flag = 1;
+			}else {
+				flag = 0;
+			}
+            //if (flag < 0 || flag > 1)
+            //    return -EINVAL;
+
+            epld->enable_lflag = flag;
+            elan_sensor_restart_work();
+
+            //LOG_INFO("elan ambient-light Sensor set lflag %d\n",flag);
+            break;
+
+        case ELAN_EPL6800_IOCTL_GETDATA:
+            buf[0] = (unsigned long)gRawData.als_ch1_raw;
+            if(copy_to_user(argp, &buf , 2))
+                return -EFAULT;
+
+            break;
+
+        default:
+            LOG_ERR("invalid cmd %d\n", _IOC_NR(cmd));
+            return -EINVAL;
+    }
+
+    return 0;
+
+}
+#endif
+static unsigned int elan_als_poll(struct file *fp, poll_table * wait)
+{
+	if(ls_data_changed){
+		//pr_info("%s, ls_data_changed 1st, ls_data = 0x%x\n", __func__, ls_data);
+		ls_data_changed = 0;
+		//mutex_unlock(&stk3x1x_mutex);
+		return POLLIN | POLLRDNORM;
+	}
+	poll_wait(fp, &ls_waitqueue, wait);
+	//mutex_unlock(&stk3x1x_mutex);
+	return 0;
+}
+
+static struct file_operations elan_als_fops =
+{
+    .owner = THIS_MODULE,
+    .open = elan_als_open,
+    .read = elan_als_read,
+    .release = elan_als_release,
+    .unlocked_ioctl = elan_als_ioctl,
+    .poll = elan_als_poll,
+};
+
+static struct miscdevice elan_als_device =
+{
+    .minor = MISC_DYNAMIC_MINOR,
+    .name = "elan_als",
+    .fops = &elan_als_fops
+};
+#endif  //ices end
+
+static int elan_ps_open(struct inode *inode, struct file *file)
+{
+    struct elan_epl_data *epld = epl_data;
+
+    LOG_FUN();
+
+    if (epld->ps_opened)
+        return -EBUSY;
+
+    epld->ps_opened = 1;
+
+    return 0;
+}
+
+static int elan_ps_release(struct inode *inode, struct file *file)
+{
+    struct elan_epl_data *epld = epl_data;
+
+    LOG_FUN();
+
+    epld->ps_opened = 0;
+
+    psensor_mode_suspend = 0;
+
+    return 0;
+}
+
+static int epl2182_read_chip_info(struct i2c_client *client, char *buf)
+{
+        if(NULL == buf) {
+                return -1;
+        }
+        if(NULL == client) {
+                *buf = 0;
+                return -2;
+        }
+
+        sprintf(buf, "EPL2182");
+        printk("[EPL2182] epl2182_read_chip_info %s\n",buf);
+        return 0;
+}
+
+static long elan_ps_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+    int flag, err;
+    unsigned long buf;
+    char strbuf[256];
+    struct elan_epl_data *epld = epl_data;
+    void __user *argp = (void __user *)arg;
+
+    LOG_INFO("ps io ctrl cmd %d\n", _IOC_NR(cmd));
+    //ioctl message handle must define by android sensor library (case by case)
+    switch(cmd)
+    {
+        case ELAN_EPL6800_IOCTL_GET_PFLAG:
+            flag = epld->enable_pflag;
+            if (copy_to_user(argp, &flag, sizeof(flag)))
+                return -EFAULT;
+            LOG_INFO("elan Proximity Sensor get pflag %d\n",flag);
+            break;
+
+        case ELAN_EPL6800_IOCTL_ENABLE_PFLAG:
+            if (copy_from_user(&flag, argp, sizeof(flag)))
+                return -EFAULT;
+            LOG_INFO("elan Proximity Sensor set pflag %d\n",flag);
+            if(flag) {
+		    flag = 1;
+            }else {
+		    flag = 0;
+            }
+            epld->enable_pflag = flag;
+            elan_sensor_restart_work();
+            break;
+
+        case ELAN_EPL6800_IOCTL_GET_CHIPINFO:
+                err = epl2182_read_chip_info(this_client, strbuf);
+                if(err < 0)
+                        return -EFAULT;
+                if(copy_to_user(argp, strbuf, strlen(strbuf)+1))
+                        return -EFAULT;
+            break;
+
+        case ELAN_EPL6800_IOCTL_GET_LFLAG:
+            flag = epld->enable_lflag;
+            if (copy_to_user(argp, &flag, sizeof(flag)))
+                return -EFAULT;
+            LOG_INFO("elan ambient-light Sensor get lflag %d\n",flag);
+            break;
+
+        case ELAN_EPL6800_IOCTL_ENABLE_LFLAG:
+            if (copy_from_user(&flag, argp, sizeof(flag)))
+                return -EFAULT;
+            LOG_INFO("elan ambient-light Sensor set lflag %d\n",flag);
+            if(flag) {
+		    flag = 1;
+            }else {
+		    flag = 0;
+            }
+            epld->enable_lflag = flag;
+            elan_sensor_restart_work();
+            break;
+
+        case ELAN_EPL6800_IOCTL_GETDATA:
+            buf = (unsigned long)gRawData.als_ch1_raw;
+            if(copy_to_user(argp, &buf , sizeof(buf)))
+                return -EFAULT;
+            LOG_INFO("elan als Sensor get data (%lu)\n",buf);
+            break;
+
+        default:
+            LOG_ERR("invalid cmd %d\n", _IOC_NR(cmd));
+            return -EINVAL;
+    }
+
+    return 0;
+}
+
+static unsigned int elan_ps_poll(struct file *fp, poll_table * wait)
+{
+	if(ps_data_changed) {
+		ps_data_changed = 0;
+		return POLLIN | POLLRDNORM;
+	}
+	poll_wait(fp, &ps_waitqueue, wait);
+	return 0;
+}
+
+
+static struct file_operations elan_ps_fops =
+{
+    .owner = THIS_MODULE,
+    .open = elan_ps_open,
+    .release = elan_ps_release,
+    .unlocked_ioctl = elan_ps_ioctl,
+    .poll		= elan_ps_poll,
+};
+
+static struct miscdevice elan_ps_device =
+{
+    .minor = MISC_DYNAMIC_MINOR,
+    .name = EPL2182_PLS_DEVICE,
+    .fops = &elan_ps_fops
+};
+
+static int initial_sensor(struct elan_epl_data *epld)
+{
+    struct i2c_client *client = epld->client;
+
+    int ret = 0;
+
+    LOG_INFO("initial_sensor enter!\n");
+
+    ret = elan_sensor_I2C_Read(client);
+
+    if(ret < 0)
+        return -EINVAL;
+
+    elan_sensor_I2C_Write(client,REG_0,W_SINGLE_BYTE,0x02, EPL_S_SENSING_MODE);
+    elan_sensor_I2C_Write(client,REG_9,W_SINGLE_BYTE,0x02,EPL_INT_DISABLE);
+    set_psensor_intr_threshold(P_SENSOR_LTHD , P_SENSOR_HTHD);
+
+    msleep(2);
+
+    epld->enable_lflag = 0;
+    epld->enable_pflag = 0;
+
+    return ret;
+}
+#if 0   //ices add
+/*----------------------------------------------------------------------------*/
+static ssize_t light_enable_show(struct device *dev,
+					 struct device_attribute *attr, char *buf)
+{
+	struct elan_epl_data *epld  = epl_data;
+	printk("%s: ALS_status=%d\n", __func__, epld->enable_lflag);
+	return sprintf(buf, "%d\n", epld->enable_lflag);
+}
+
+static ssize_t light_enable_store(struct device *dev,
+					  struct device_attribute *attr,
+					  const char *buf, size_t size)
+{
+	struct elan_epl_data *epld = epl_data;
+
+    LOG_INFO("light_enable_store: enable=%s \n", buf);
+
+	if (sysfs_streq(buf, "1"))
+		epld->enable_lflag= 1;
+	else if (sysfs_streq(buf, "0"))
+		epld->enable_lflag= 0;
+	else {
+		pr_err("%s: invalid value %d\n", __func__, *buf);
+		return 0;
+	}
+
+	elan_sensor_restart_work();
+	return size;
+}
+
+/*----------------------------------------------------------------------------*/
+static struct device_attribute dev_attr_light_enable =
+__ATTR(enable, S_IRWXUGO,
+	   light_enable_show, light_enable_store);
+
+static struct attribute *light_sysfs_attrs[] = {
+	&dev_attr_light_enable.attr,
+	NULL
+};
+
+static struct attribute_group light_attribute_group = {
+	.attrs = light_sysfs_attrs,
+};
+/*----------------------------------------------------------------------------*/
+
+static int lightsensor_setup(struct elan_epl_data *epld)
+{
+    int err = 0;
+    LOG_INFO("lightsensor_setup enter.\n");
+
+    epld->als_input_dev = input_allocate_device();
+    if (!epld->als_input_dev)
+    {
+        LOG_ERR( "could not allocate ls input device\n");
+        return -ENOMEM;
+    }
+    epld->als_input_dev->name = ElanALsensorName;
+    set_bit(EV_ABS, epld->als_input_dev->evbit);
+    input_set_abs_params(epld->als_input_dev, ABS_MISC, 0, 9, 0, 0);
+
+    err = input_register_device(epld->als_input_dev);
+    if (err < 0)
+    {
+        LOG_ERR("can not register ls input device\n");
+        goto err_free_ls_input_device;
+    }
+#if 0   //ices add
+    err = misc_register(&elan_als_device);
+    if (err < 0)
+    {
+        LOG_ERR("can not register ls misc device\n");
+        goto err_unregister_ls_input_device;
+    }
+#endif  //ices end
+    err = sysfs_create_group(&epld->als_input_dev->dev.kobj, &light_attribute_group);
+
+	if (err) {
+		pr_err("%s: could not create sysfs group\n", __func__);
+		goto err_free_ls_input_device;
+	}
+
+    return err;
+
+err_unregister_ls_input_device:
+    input_unregister_device(epld->als_input_dev);
+err_free_ls_input_device:
+    input_free_device(epld->als_input_dev);
+    return err;
+}
+#endif
+/*----------------------------------------------------------------------------*/
+static ssize_t proximity_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+	struct elan_epl_data *epld = epl_data;
+	printk("%s: PS status=%d\n", __func__, epld->enable_pflag);
+	LOG_INFO("epl2182_setup_psensor enter.\n");
+	return sprintf(buf, "%d\n", epld->enable_pflag);
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static ssize_t proximity_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
+{
+    struct elan_epl_data *epld = epl_data;
+
+    LOG_INFO("proximity_enable_store: enable=%s \n", buf);
+	if (sysfs_streq(buf, "1"))
+		epld->enable_pflag =1;
+	else if (sysfs_streq(buf, "0"))
+	    epld->enable_pflag =0;
+	else {
+		pr_err("%s: invalid value %d\n", __func__, *buf);
+		return 0;
+	}
+
+	elan_sensor_restart_work();
+	return size;
+}
+/*----------------------------------------------------------------------------*/
+static struct device_attribute dev_attr_ps_enable =
+__ATTR(enable, S_IRWXUGO,
+	   proximity_enable_show, proximity_enable_store);
+
+static struct attribute *proximity_sysfs_attrs[] = {
+	&dev_attr_ps_enable.attr,
+	NULL
+};
+
+static struct attribute_group proximity_attribute_group = {
+	.attrs = proximity_sysfs_attrs,
+};
+/*----------------------------------------------------------------------------*/
+
+static int psensor_setup(struct elan_epl_data *epld)
+{
+    int err = 0;
+    LOG_INFO("psensor_setup enter.\n");
+
+    epld->ps_input_dev = input_allocate_device();
+    if (!epld->ps_input_dev)
+    {
+        LOG_ERR("could not allocate ps input device\n");
+        return -ENOMEM;
+    }
+    epld->ps_input_dev->name = ElanPsensorName;
+
+    set_bit(EV_ABS, epld->ps_input_dev->evbit);
+    input_set_abs_params(epld->ps_input_dev, ABS_DISTANCE, 0, 1, 0, 0);
+#if 1
+    set_bit(EV_ABS, epld->ps_input_dev->evbit);
+    input_set_abs_params(epld->ps_input_dev, ABS_MISC, 0, 9, 0, 0);
+#endif
+
+    err = input_register_device(epld->ps_input_dev);
+    if (err < 0)
+    {
+        LOG_ERR("could not register ps input device\n");
+        goto err_free_ps_input_device;
+    }
+
+    err = misc_register(&elan_ps_device);
+    if (err < 0)
+    {
+        LOG_ERR("could not register ps misc device\n");
+        goto err_unregister_ps_input_device;
+    }
+
+    err = sysfs_create_group(&epld->ps_input_dev->dev.kobj, &proximity_attribute_group);
+	if (err) {
+		pr_err("%s: PS could not create sysfs group\n", __func__);
+		goto err_free_ps_input_device;
+	}
+
+    return err;
+
+err_unregister_ps_input_device:
+    input_unregister_device(epld->ps_input_dev);
+err_free_ps_input_device:
+    input_free_device(epld->ps_input_dev);
+    return err;
+}
+
+#if PS_INTERRUPT_MODE
+static int setup_interrupt(struct elan_epl_data *epld)
+{
+    struct i2c_client *client = epld->client;
+	struct elan_epl_platform_data *pdata = client->dev.platform_data;
+
+    int err = 0;
+    msleep(5);
+#if 1
+    err = gpio_request(pdata->irq_gpio_number, "Elan EPL IRQ");
+    if (err)
+    {
+        LOG_ERR("gpio pin request fail (%d)\n", err);
+        goto initial_fail;
+    }
+    else
+    {
+
+		gpio_direction_input(pdata->irq_gpio_number);
+
+		/*get irq*/
+		client->irq = gpio_to_irq(pdata->irq_gpio_number);
+		epld->irq = client->irq;
+
+		printk("IRQ number is %d\n", client->irq);
+
+    }
+#endif
+    err = request_irq(epld->irq,elan_sensor_irq_handler, IRQF_TRIGGER_FALLING | IRQF_NO_SUSPEND ,
+                      client->dev.driver->name, epld);
+    if(err <0)
+    {
+        LOG_ERR("request irq pin %d fail for gpio\n",err);
+        goto fail_free_intr_pin;
+    }
+
+    return err;
+
+initial_fail:
+fail_free_intr_pin:
+    gpio_free(epld->intr_pin);
+    return err;
+}
+#endif
+
+#ifdef CONFIG_SUSPEND
+static int elan_sensor_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+    LOG_FUN();
+
+    if(epl_data->enable_pflag==0 )
+    {
+        elan_sensor_I2C_Write(client,REG_7, W_SINGLE_BYTE, 0x02, EPL_C_P_DOWN);
+        cancel_delayed_work(&polling_work);
+    }
+    return 0;
+}
+
+static int elan_sensor_resume(struct i2c_client *client)
+{
+    struct elan_epl_data *epld = epl_data;
+    LOG_FUN();
+
+    if(epld->enable_pflag | epld->enable_lflag)
+    {
+        elan_sensor_I2C_Write(client,REG_7, W_SINGLE_BYTE, 0x02, EPL_C_P_UP);
+    }
+
+    if(epld->enable_pflag)
+    {
+        elan_sensor_restart_work();
+    }
+    return 0;
+}
+#endif
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+static void elan_sensor_early_suspend(struct early_suspend *h)
+{
+    struct elan_epl_data *epld = epl_data;
+    struct i2c_client *client = epld->client;
+    LOG_FUN();
+
+    if( epld->enable_pflag==0)
+    {
+        elan_sensor_I2C_Write(client,REG_7, W_SINGLE_BYTE, 0x02, EPL_C_P_DOWN);
+        cancel_delayed_work(&polling_work);
+    }
+
+    psensor_mode_suspend = 1;
+}
+
+static void elan_sensor_late_resume(struct early_suspend *h)
+{
+    struct elan_epl_data *epld = epl_data;
+    struct i2c_client *client = epld->client;
+
+    LOG_FUN();
+
+    if(epld->enable_pflag | epld->enable_lflag)
+    {
+        elan_sensor_I2C_Write(client,REG_7, W_SINGLE_BYTE, 0x02, EPL_C_P_UP);
+    }
+
+    if(epld->enable_pflag || epld->enable_lflag)
+    {
+        elan_sensor_restart_work();
+    }
+    psensor_mode_suspend = 0;
+}
+#endif
+
+static int elan_sensor_probe(struct i2c_client *client,const struct i2c_device_id *id)
+{
+    int err = 0;
+    int chip_id = 0;
+    struct elan_epl_data *epld ;
+    struct elan_epl_platform_data *pdata = client->dev.platform_data;
+    //static struct platform_device *sensor_dev;
+    struct device_node *np = client->dev.of_node;
+    LOG_INFO("elan sensor probe enter.\n");
+#ifdef CONFIG_OF
+        if (np && !pdata){
+		pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+		if (!pdata) {
+			dev_err(&client->dev, "Could not allocate struct elan_epl_platform_data");
+			goto exit_allocate_pdata_failed;
+		}
+		pdata->irq_gpio_number = of_get_gpio(np, 0);
+		if(pdata->irq_gpio_number < 0){
+			dev_err(&client->dev, "fail to get irq_gpio_number\n");
+			kfree(pdata);
+			goto exit_irq_gpio_read_fail;
+		}
+		client->dev.platform_data = pdata;
+	}
+#endif
+
+    epld = kzalloc(sizeof(struct elan_epl_data), GFP_KERNEL);
+    if (!epld) {
+        err = -ENOMEM;
+        LOG_ERR("kzalloc elan_epl_data failed!\n");
+        goto exit_kzalloc_epld_failed;
+    }
+
+    if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
+    {
+        dev_err(&client->dev,"No supported i2c func what we need?!!\n");
+        err = -ENOTSUPP;
+        goto i2c_fail;
+    }
+    chip_id = i2c_smbus_read_byte_data(client, 0x00);
+    if (chip_id < 0)
+    {
+        dev_err(&client->dev,"read chip id REG 0x00 failed\n");
+        err = -ENODEV;
+        goto exit_read_chipid_failed;
+    }
+    LOG_INFO("chip id REG 0x00 value = %8x\n", i2c_smbus_read_byte_data(client, 0x00));
+    LOG_INFO("chip id REG 0x01 value = %8x\n", i2c_smbus_read_byte_data(client, 0x08));
+    LOG_INFO("chip id REG 0x02 value = %8x\n", i2c_smbus_read_byte_data(client, 0x10));
+    LOG_INFO("chip id REG 0x03 value = %8x\n", i2c_smbus_read_byte_data(client, 0x18));
+    LOG_INFO("chip id REG 0x04 value = %8x\n", i2c_smbus_read_byte_data(client, 0x20));
+    LOG_INFO("chip id REG 0x05 value = %8x\n", i2c_smbus_read_byte_data(client, 0x28));
+    LOG_INFO("chip id REG 0x06 value = %8x\n", i2c_smbus_read_byte_data(client, 0x30));
+    LOG_INFO("chip id REG 0x07 value = %8x\n", i2c_smbus_read_byte_data(client, 0x38));
+    LOG_INFO("chip id REG 0x09 value = %8x\n", i2c_smbus_read_byte_data(client, 0x48));
+    LOG_INFO("chip id REG 0x0D value = %8x\n", i2c_smbus_read_byte_data(client, 0x68));
+    LOG_INFO("chip id REG 0x0E value = %8x\n", i2c_smbus_read_byte_data(client, 0x70));
+    LOG_INFO("chip id REG 0x0F value = %8x\n", i2c_smbus_read_byte_data(client, 0x71));
+    LOG_INFO("chip id REG 0x10 value = %8x\n", i2c_smbus_read_byte_data(client, 0x80));
+    LOG_INFO("chip id REG 0x11 value = %8x\n", i2c_smbus_read_byte_data(client, 0x88));
+    LOG_INFO("chip id REG 0x13 value = %8x\n", i2c_smbus_read_byte_data(client, 0x98));
+
+    epld->client = client;
+    this_client = client;
+    epld->irq = client->irq;
+    i2c_set_clientdata(client, epld);
+
+    epl_data = epld;
+
+    epld->epl_wq = create_singlethread_workqueue(EPL2182_PLS_DEVICE);
+    if (!epld->epl_wq)
+    {
+        LOG_ERR("can't create workqueue\n");
+        err = -ENOMEM;
+        goto err_create_singlethread_workqueue;
+    }
+#if 0   //ices add
+    err = lightsensor_setup(epld);
+    if (err < 0)
+    {
+        LOG_ERR("lightsensor_setup error!!\n");
+        goto err_lightsensor_setup;
+    }
+#endif
+    err = psensor_setup(epld);
+    if (err < 0)
+    {
+        LOG_ERR("psensor_setup error!!\n");
+        goto err_psensor_setup;
+    }
+
+    err = initial_sensor(epld);
+    if (err < 0)
+    {
+        LOG_ERR("fail to initial sensor (%d)\n", err);
+        goto err_sensor_setup;
+    }
+
+#if PS_INTERRUPT_MODE
+    err = setup_interrupt(epld);
+    if (err < 0)
+    {
+        LOG_ERR("setup error!\n");
+        goto err_sensor_setup;
+    }
+#endif
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+    epld->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
+    epld->early_suspend.suspend = elan_sensor_early_suspend;
+    epld->early_suspend.resume = elan_sensor_late_resume;
+    register_early_suspend(&epld->early_suspend);
+#endif
+
+#if 0
+    wake_lock_init(&g_ps_wlock, WAKE_LOCK_SUSPEND, "ps_wakelock");
+
+    sensor_dev = platform_device_register_simple("elan_alsps", -1, NULL, 0);
+    if (IS_ERR(sensor_dev))
+    {
+        printk ("sensor_dev_init: error\n");
+        goto err_fail;
+    }
+
+    err = sysfs_create_group(&sensor_dev->dev.kobj, &ets_attr_group);
+    if (err !=0)
+    {
+        dev_err(&client->dev,"%s:create sysfs group error", __func__);
+        goto err_fail;
+    }
+#endif
+
+    LOG_INFO("sensor probe success.\n");
+
+    return err;
+
+err_fail:
+    //input_unregister_device(epld->als_input_dev);
+    input_unregister_device(epld->ps_input_dev);
+    //input_free_device(epld->als_input_dev);
+    input_free_device(epld->ps_input_dev);
+//err_lightsensor_setup:
+err_psensor_setup:
+err_sensor_setup:
+    destroy_workqueue(epld->epl_wq);
+    misc_deregister(&elan_ps_device);
+//    misc_deregister(&elan_als_device);    //ices add
+err_create_singlethread_workqueue:
+exit_read_chipid_failed:
+i2c_fail:
+//err_platform_data_null:
+    kfree(epld);
+exit_kzalloc_epld_failed:
+#ifdef CONFIG_OF
+exit_irq_gpio_read_fail:
+exit_allocate_pdata_failed:
+#endif
+    return err;
+}
+
+static int elan_sensor_remove(struct i2c_client *client)
+{
+    struct elan_epl_data *epld = i2c_get_clientdata(client);
+
+    dev_dbg(&client->dev, "%s: enter.\n", __func__);
+
+    unregister_early_suspend(&epld->early_suspend);
+    //input_unregister_device(epld->als_input_dev);
+    input_unregister_device(epld->ps_input_dev);
+    //input_free_device(epld->als_input_dev);
+    input_free_device(epld->ps_input_dev);
+    misc_deregister(&elan_ps_device);
+//    misc_deregister(&elan_als_device);    //ices add
+    free_irq(epld->irq,epld);
+    destroy_workqueue(epld->epl_wq);
+    kfree(epld);
+    return 0;
+}
+
+static const struct i2c_device_id elan_sensor_id[] =
+{
+    { EPL2182_PLS_DEVICE, 0 },
+    { }
+};
+
+static const struct of_device_id epl2182_of_match[] = {
+       { .compatible = "ELAN,epl2182_pls", },
+        {}
+};
+MODULE_DEVICE_TABLE(of, epl2182_of_match);
+
+static struct i2c_driver elan_sensor_driver =
+{
+    .probe	= elan_sensor_probe,
+    .remove	= elan_sensor_remove,
+    .id_table	= elan_sensor_id,
+    .driver	= {
+        .name = EPL2182_PLS_DEVICE,
+        .owner = THIS_MODULE,
+        .of_match_table = epl2182_of_match,
+    },
+#ifdef CONFIG_SUSPEND
+    .suspend = elan_sensor_suspend,
+    .resume = elan_sensor_resume,
+#endif
+};
+
+static int __init elan_sensor_init(void)
+{
+    return i2c_add_driver(&elan_sensor_driver);
+}
+
+static void __exit  elan_sensor_exit(void)
+{
+    i2c_del_driver(&elan_sensor_driver);
+}
+
+module_init(elan_sensor_init);
+module_exit(elan_sensor_exit);
+
+MODULE_AUTHOR("Renato Pan <renato.pan@eminent-tek.com>");
+MODULE_DESCRIPTION("ELAN epl2182 driver");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/input/misc/epl259x.c b/drivers/input/misc/epl259x.c
new file mode 100644
index 00000000..81bcd79a
--- /dev/null
+++ b/drivers/input/misc/epl259x.c
@@ -0,0 +1,4645 @@
+/* drivers/i2c/chips/epl259x.c - light and proxmity sensors driver
+ * Copyright (C) 2014 ELAN Corporation.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+
+#include <linux/hrtimer.h>
+#include <linux/timer.h>
+#include <linux/delay.h>
+#if defined(CONFIG_HAS_EARLYSUSPEND)
+#include <linux/earlysuspend.h>
+#endif
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+#include <linux/irq.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/miscdevice.h>
+#include <linux/slab.h>
+#include <asm/uaccess.h>
+//#include <asm/mach-types.h>
+#include <asm/setup.h>
+#include <linux/wakelock.h>
+#include <linux/jiffies.h>
+#include <linux/i2c/epl259x.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+#include <linux/regulator/consumer.h>
+#include <linux/platform_device.h>
+
+/******************************************************************************
+* configuration
+*******************************************************************************/
+#define ALS_POLLING_MODE         	1					// 1 is polling mode, 0 is interrupt mode
+#define PS_POLLING_MODE         	0					// 1 is polling mode, 0 is interrupt mode
+
+#define ALS_LOW_THRESHOLD		1000
+#define ALS_HIGH_THRESHOLD		3000
+
+#define PS_LOW_THRESHOLD		3000
+#define PS_HIGH_THRESHOLD		4000
+
+#define LUX_PER_COUNT			700
+
+//platform select
+#define S5PV210     0
+#define SPREAD      1
+#define QCOM        0
+#define LEADCORE    0
+#define MARVELL     0
+
+//#define ELAN_INT_PIN 140    /*Interrupt pin setting*/
+
+//debug message
+#define COMMON_DEBUG 0
+#define ALS_DEBUG   0
+#define PS_DEBUG    1
+#define SHOW_DBG    0
+
+#define ALS_DYN_INTT    0
+#define PS_DYN_K        0
+#define PS_DYN_K_STR   0
+#define HS_ENABLE       0
+#define PS_GES          0
+
+#define ALS_LEVEL    16
+static int polling_time = 200;
+static struct i2c_client *this_client = NULL;
+static int als_level[] = {20, 45, 70, 90, 150, 300, 500, 700, 1150, 2250, 4500, 8000, 15000, 30000, 50000};
+static int als_value[] = {10, 30, 60, 80, 100, 200, 400, 600, 800, 1500, 3000, 6000, 10000, 20000, 40000, 60000};
+
+#if ALS_DYN_INTT
+//Dynamic INTT
+int dynamic_intt_idx;
+int dynamic_intt_init_idx = 1;	//initial dynamic_intt_idx
+int c_gain;
+int dynamic_intt_lux = 0;
+
+uint16_t dynamic_intt_high_thr;
+uint16_t dynamic_intt_low_thr;
+uint32_t dynamic_intt_max_lux = 12000;
+uint32_t dynamic_intt_min_lux = 0;
+uint32_t dynamic_intt_min_unit = 1000;
+
+static int als_dynamic_intt_intt[] = {EPL_ALS_INTT_8192, EPL_ALS_INTT_64};
+static int als_dynamic_intt_value[] = {8192, 64};
+static int als_dynamic_intt_gain[] = {EPL_GAIN_MID, EPL_GAIN_MID};
+static int als_dynamic_intt_high_thr[] = {60000, 53000};
+static int als_dynamic_intt_low_thr[] = {200, 300};
+static int als_dynamic_intt_intt_num =  sizeof(als_dynamic_intt_value)/sizeof(int);
+#endif
+
+#if ALS_DYN_INTT
+typedef enum
+{
+    CMC_BIT_LSRC_NON		= 0x0,
+    CMC_BIT_LSRC_SCALE     	= 0x1,
+    CMC_BIT_LSRC_SLOPE		= 0x2,
+    CMC_BIT_LSRC_BOTH		= 0x3,
+} CMC_LSRC_REPORT_TYPE;
+#endif
+
+#if PS_DYN_K
+static int dynk_polling_delay = 200;
+int dynk_min_ps_raw_data;
+int dynk_max_ir_data;
+
+u32 dynk_thd_low = 0;
+u32 dynk_thd_high = 0;
+
+int dynk_low_offset;
+int dynk_high_offset;
+
+bool dynk_change_flag = false;
+u16 dynk_change_thd_max;
+u16 dynk_thd_offset;
+
+u8 dynk_last_status = 0;
+
+#if PS_DYN_K_STR
+bool dynk_enhance_flag = true;
+u8 dynk_enhance_integration_time;
+u8 dynk_enhance_gain;
+u8 dynk_enhance_adc;
+u16 dynk_enhance_ch0;
+u16 dynk_enhance_ch1;
+u16 dynk_enhance_max_ch0;
+#endif
+
+#endif
+
+#if HS_ENABLE
+static struct mutex hs_sensor_mutex;
+static bool hs_enable_flag = false;
+#endif
+
+#if PS_GES
+static bool ps_ges_enable_flag = false;
+u16 ges_threshold_low = 1000;
+u16 ges_threshold_high = 1500;
+#define KEYCODE_LEFT			KEY_LEFTALT
+bool ps_ges_suspend_flag = false;
+#endif
+
+bool polling_flag = true;
+bool eint_flag = true;
+
+//ps calibration file location
+static const char ps_cal_file[]="/data/data/com.eminent.ps.calibration/ps.dat";
+
+//als calibration file location
+static const char als_cal_file[]="/data/data/com.eminent.ps.calibration/als.dat";
+
+static int PS_h_offset = 2000;
+static int PS_l_offset = 1000;
+static int PS_MAX_XTALK = 30000;
+
+int als_frame_time = 0;
+int ps_frame_time = 0;
+/******************************************************************************
+*******************************************************************************/
+
+#define TXBYTES                             2
+#define RXBYTES                             2
+
+#define PACKAGE_SIZE 			8
+#define I2C_RETRY_COUNT 		10
+#define EPL_DEV_NAME   		    "epl2182_pls"
+#define DRIVER_VERSION          "1.0.3"
+//struct timeval  ges_enable_time;
+
+//int ges_frame_count;
+
+typedef enum
+{
+    CMC_BIT_RAW   			= 0x0,
+    CMC_BIT_PRE_COUNT     	= 0x1,
+    CMC_BIT_DYN_INT			= 0x2,
+    CMC_BIT_DEF_LIGHT		= 0x4,
+    CMC_BIT_TABLE			= 0x8,
+} CMC_ALS_REPORT_TYPE;
+
+typedef struct _epl_raw_data
+{
+    u8 raw_bytes[PACKAGE_SIZE];
+    u16 renvo;
+} epl_raw_data;
+
+struct epl_sensor_priv
+{
+    struct i2c_client *client;
+    struct input_dev *als_input_dev;
+    struct input_dev *ps_input_dev;
+    struct workqueue_struct *epl_wq;
+    struct delayed_work  eint_work;
+#if defined(CONFIG_HAS_EARLYSUSPEND)
+    struct early_suspend early_suspend;
+#endif
+    int intr_pin;
+    int (*power)(int on);
+
+    int ps_opened;
+    int als_opened;
+
+    int als_suspend;
+    int ps_suspend;
+
+    int lux_per_count;
+
+    int enable_pflag;
+    int enable_lflag;
+#if HS_ENABLE
+    int enable_hflag;
+	int hs_suspend;
+#endif
+#if PS_GES
+    struct input_dev *gs_input_dev;
+    int enable_gflag;
+	int ges_suspend;
+#endif
+    int read_flag;
+    int irq;
+    spinlock_t lock;
+
+#if ALS_DYN_INTT
+    uint32_t ratio;
+    uint32_t last_ratio;
+    int c_gain_h; // fluorescent (C1)
+    int c_gain_l; // incandescent (C2)
+    uint32_t lsource_thd_high; //different light source boundary (N) fluorescent (C1)
+    uint32_t lsource_thd_low; //different light source boundary (N) incandescent (C2)
+#endif
+
+    /*data*/
+    u16         	als_level_num;
+    u16         	als_value_num;
+    u32         	als_level[ALS_LEVEL-1];
+    u32         	als_value[ALS_LEVEL];
+} ;
+
+static struct platform_device *sensor_dev;
+struct epl_sensor_priv *epl_sensor_obj;
+static epl_optical_sensor epl_sensor;
+int i2c_max_count=8;
+
+static epl_raw_data	gRawData;
+
+static struct wake_lock ps_lock;
+static struct mutex sensor_mutex;
+
+#if S5PV210
+static const char ElanPsensorName[]="proximity";
+static const char ElanALsensorName[]="lightsensor-level";
+#elif SPREAD
+static const char ElanPsensorName[] = "proximity";
+#elif QCOM || LEADCORE
+static const char ElanPsensorName[] = "proximity";
+static const char ElanALsensorName[] = "light";
+#elif MARVELL
+static const char ElanPsensorName[] = "alps_pxy";
+#endif
+
+#define LOG_TAG                      "[EPL259x] "
+#define LOG_FUN(f)               	 printk(KERN_INFO LOG_TAG"%s\n", __FUNCTION__)
+#define LOG_INFO(fmt, args...)    	 printk(KERN_INFO LOG_TAG fmt, ##args)
+#define LOG_ERR(fmt, args...)   	 printk(KERN_ERR  LOG_TAG"%s %d : "fmt, __FUNCTION__, __LINE__, ##args)
+
+
+void epl_sensor_update_mode(struct i2c_client *client);
+int epl_sensor_read_als_status(struct i2c_client *client);
+static int epl_sensor_setup_interrupt(struct epl_sensor_priv *epld);
+static int ps_sensing_time(int intt, int adc, int cycle);
+static int als_sensing_time(int intt, int adc, int cycle);
+
+static void epl_sensor_eint_work(struct work_struct *work);
+//static DECLARE_WORK(epl_sensor_irq_work, epl_sensor_eint_work);
+
+static void epl_sensor_polling_work(struct work_struct *work);
+static DECLARE_DELAYED_WORK(polling_work, epl_sensor_polling_work);
+
+#if PS_DYN_K
+void epl_sensor_dynk_thd_polling_work(struct work_struct *work);
+void epl_sensor_restart_dynk_polling(void);
+static DECLARE_DELAYED_WORK(dynk_thd_polling_work, epl_sensor_dynk_thd_polling_work);
+#endif
+
+
+
+
+/*
+//====================I2C write operation===============//
+*/
+static int epl_sensor_I2C_Write_Cmd(struct i2c_client *client, uint8_t regaddr, uint8_t data, uint8_t txbyte)
+{
+    uint8_t buffer[2];
+    int ret = 0;
+    int retry;
+
+    buffer[0] = regaddr ;
+    buffer[1] = data;
+
+    for(retry = 0; retry < I2C_RETRY_COUNT; retry++)
+    {
+        ret = i2c_master_send(client, buffer, txbyte);
+
+        if (ret == txbyte)
+        {
+            break;
+        }
+
+        LOG_ERR("i2c write error,TXBYTES %d\n",ret);
+        mdelay(10);
+    }
+
+
+    if(retry>=I2C_RETRY_COUNT)
+    {
+        LOG_ERR("i2c write retry over %d\n", I2C_RETRY_COUNT);
+        return -EINVAL;
+    }
+
+    return ret;
+}
+
+static int epl_sensor_I2C_Write(struct i2c_client *client, uint8_t regaddr, uint8_t data)
+{
+    int ret = 0;
+    ret = epl_sensor_I2C_Write_Cmd(client, regaddr, data, 0x02);
+    return ret;
+    return 0;
+}
+/*----------------------------------------------------------------------------*/
+static int epl_sensor_I2C_Read(struct i2c_client *client, uint8_t regaddr, uint8_t bytecount)
+{
+
+    int ret = 0;
+
+
+    int retry;
+    int read_count=0, rx_count=0;
+
+    while(bytecount>0)
+    {
+        epl_sensor_I2C_Write_Cmd(client, regaddr+read_count, 0x00, 0x01);
+
+        for(retry = 0; retry < I2C_RETRY_COUNT; retry++)
+        {
+            rx_count = bytecount>i2c_max_count?i2c_max_count:bytecount;
+            ret = i2c_master_recv(client, &gRawData.raw_bytes[read_count], rx_count);
+
+            if (ret == rx_count)
+                break;
+
+            LOG_ERR("i2c read error,RXBYTES %d\r\n",ret);
+            mdelay(10);
+        }
+
+        if(retry>=I2C_RETRY_COUNT)
+        {
+            LOG_ERR("i2c read retry over %d\n", I2C_RETRY_COUNT);
+            return -EINVAL;
+        }
+        bytecount-=rx_count;
+        read_count+=rx_count;
+    }
+
+    return ret;
+}
+
+/*----------------------------------------------------------------------------*/
+static void epl_sensor_restart_polling(void)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+
+    cancel_delayed_work(&polling_work);
+    queue_delayed_work(epld->epl_wq, &polling_work,msecs_to_jiffies(polling_time));
+
+}
+/*----------------------------------------------------------------------------*/
+
+#if PS_GES
+static void epl_sensor_notify_event(void)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    struct input_dev *idev = epld->gs_input_dev;
+
+    LOG_INFO("  --> LEFT\n\n");
+    input_report_key(idev, KEYCODE_LEFT, 1);
+    input_report_key(idev,  KEYCODE_LEFT, 0);
+    input_sync(idev);
+}
+#endif
+
+/*----------------------------------------------------------------------------*/
+static void epl_sensor_report_lux(int repott_lux)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+
+    LOG_INFO("-------------------  ALS raw = %d, lux = %d\n\n",epl_sensor.als.data.channels[1],  repott_lux);
+#if SPREAD || MARVELL
+    input_report_abs(epld->ps_input_dev, ABS_MISC, repott_lux);
+    input_sync(epld->ps_input_dev);
+#else
+    input_report_abs(epld->als_input_dev, ABS_MISC, repott_lux);
+    input_sync(epld->als_input_dev);
+#endif
+}
+/*----------------------------------------------------------------------------*/
+#if ALS_DYN_INTT
+long raw_convert_to_lux(u16 raw_data)
+{
+    long lux = 0;
+
+    lux = raw_data * (c_gain / als_dynamic_intt_value[dynamic_intt_idx]);
+#if ALS_DEBUG
+    LOG_INFO("[%s]:raw_data=%d, lux=%ld\r\n", __func__, raw_data, lux);
+#endif
+
+    if(lux >= (dynamic_intt_max_lux * dynamic_intt_min_unit)){
+#if ALS_DEBUG
+        LOG_INFO("[%s]:raw_convert_to_lux: change max lux\r\n", __func__);
+#endif
+        lux = dynamic_intt_max_lux * dynamic_intt_min_unit;
+    }
+    else if(lux <= (dynamic_intt_min_lux*dynamic_intt_min_unit)){
+#if ALS_DEBUG
+        LOG_INFO("[%s]:raw_convert_to_lux: change min lux\r\n", __func__);
+#endif
+        lux = dynamic_intt_min_lux * dynamic_intt_min_unit;
+    }
+
+    return lux;
+}
+#endif
+/*----------------------------------------------------------------------------*/
+static int epl_sensor_get_als_value(struct epl_sensor_priv *obj, u16 als)
+{
+	int idx;
+	int invalid = 0;
+#if ALS_DYN_INTT
+	long now_lux=0, lux_tmp=0;
+    bool change_flag = false;
+#endif
+	switch(epl_sensor.als.report_type)
+	{
+		case CMC_BIT_RAW:
+			return als;
+		break;
+
+		case CMC_BIT_PRE_COUNT:
+			return (als * epl_sensor.als.factory.lux_per_count)/1000;
+		break;
+
+		case CMC_BIT_TABLE:
+			for(idx = 0; idx < obj->als_level_num; idx++)
+			{
+			    if(als < als_level[idx])
+			    {
+			        break;
+			    }
+			}
+
+			if(idx >= obj->als_value_num)
+			{
+			    LOG_ERR("exceed range\n");
+			    idx = obj->als_value_num - 1;
+			}
+
+			if(!invalid)
+			{
+			    LOG_INFO("ALS: %05d => %05d\n", als, als_value[idx]);
+			    return als_value[idx];
+			}
+			else
+			{
+			    LOG_ERR("ALS: %05d => %05d (-1)\n", als, als_value[idx]);
+			    return als;
+			}
+		break;
+#if ALS_DYN_INTT
+		case CMC_BIT_DYN_INT:
+
+            if(epl_sensor.als.lsrc_type != CMC_BIT_LSRC_NON)
+            {
+                long luxratio = 0;
+                epl_sensor_read_als_status(obj->client);
+
+                if (epl_sensor.als.data.channels[0] == 0)
+                {
+                   epl_sensor.als.data.channels[0] = 1;
+                   LOG_ERR("[%s]:read ch0 data is 0 \r\n", __func__);
+                }
+
+                luxratio = (long)((als*dynamic_intt_min_unit) / epl_sensor.als.data.channels[0]); //lux ratio (A=CH1/CH0)
+
+                obj->ratio = luxratio;
+                if((epl_sensor.als.saturation >> 5) == 0)
+                {
+                    if(epl_sensor.als.lsrc_type == CMC_BIT_LSRC_SCALE || epl_sensor.als.lsrc_type == CMC_BIT_LSRC_BOTH)
+                    {
+                        if(obj->ratio == 0){
+                            obj->last_ratio = luxratio;
+                        }
+                        else{
+                            obj->last_ratio = (luxratio + obj->last_ratio*9)  / 10;
+                        }
+
+                        if (obj->last_ratio >= obj->lsource_thd_high)  //fluorescent (C1)
+                        {
+                            c_gain = obj->c_gain_h;
+                        }
+                        else if (obj->last_ratio <= obj->lsource_thd_low)   //incandescent (C2)
+                        {
+                            c_gain = obj->c_gain_l;
+                        }
+                        else if(epl_sensor.als.lsrc_type == CMC_BIT_LSRC_BOTH)
+                        {
+                            int a = 0, b = 0, c = 0;
+                            a = (obj->c_gain_h - obj->c_gain_l) * dynamic_intt_min_unit / (obj->lsource_thd_high - obj->lsource_thd_low);
+                            b = (obj->c_gain_h) - ((a * obj->lsource_thd_high)/dynamic_intt_min_unit );
+                            c  = ((a * obj->last_ratio)/dynamic_intt_min_unit) + b;
+                            if(c > obj->c_gain_h)
+                                c_gain = obj->c_gain_h;
+                            else if (c < obj->c_gain_l)
+                                c_gain = obj->c_gain_l;
+                            else
+                                c_gain = c;
+                        }
+                    }
+                    else if(epl_sensor.als.lsrc_type == CMC_BIT_LSRC_SLOPE)
+                    {
+                        if (luxratio >= obj->lsource_thd_high)  //fluorescent (C1)
+                        {
+                            c_gain = obj->c_gain_h;
+                        }
+                        else if (luxratio <= obj->lsource_thd_low)   //incandescent (C2)
+                        {
+                            c_gain = obj->c_gain_l;
+                        }
+                        else{ /*mix*/
+                            int a = 0, b = 0, c = 0;
+                            a = (obj->c_gain_h - obj->c_gain_l) * dynamic_intt_min_unit / (obj->lsource_thd_high - obj->lsource_thd_low);
+                            b = (obj->c_gain_h) - ((a * obj->lsource_thd_high)/dynamic_intt_min_unit );
+                            c = ((a * luxratio)/dynamic_intt_min_unit) + b;
+                            if(c > obj->c_gain_h)
+                                c_gain = obj->c_gain_h;
+                            else if (c < obj->c_gain_l)
+                                c_gain = obj->c_gain_l;
+                            else
+                                c_gain = c;
+                        }
+                    }
+                    LOG_INFO("[%s]:ch0=%d, ch1=%d, c_gain=%d, obj->ratio=%d, obj->last_ratio=%d \r\n\n",
+                                      __func__,epl_sensor.als.data.channels[0], als, c_gain, obj->ratio, obj->last_ratio);
+                }
+                else
+                {
+                    LOG_INFO("[%s]: ALS saturation(%d) \r\n", __func__, (epl_sensor.als.saturation >> 5));
+                }
+            }
+
+#if ALS_DEBUG
+            LOG_INFO("[%s]: dynamic_intt_idx=%d, als_dynamic_intt_value=%d, dynamic_intt_gain=%d, als=%d \r\n",
+                                    __func__, dynamic_intt_idx, als_dynamic_intt_value[dynamic_intt_idx], als_dynamic_intt_gain[dynamic_intt_idx], als);
+#endif
+
+            if(als > dynamic_intt_high_thr)
+        	{
+          		if(dynamic_intt_idx == (als_dynamic_intt_intt_num - 1)){
+                    als = dynamic_intt_high_thr;
+          		    lux_tmp = raw_convert_to_lux(als);
+#if ALS_DEBUG
+        	      	LOG_INFO(">>>>>>>>>>>>>>>>>>>>>>>> INTT_MAX_LUX\r\n");
+#endif
+          		}
+                else{
+                    change_flag = true;
+        			als  = dynamic_intt_high_thr;
+              		lux_tmp = raw_convert_to_lux(als);
+                    dynamic_intt_idx++;
+#if ALS_DEBUG
+                    LOG_INFO(">>>>>>>>>>>>>>>>>>>>>>>>change INTT high: %d, raw: %d \r\n", dynamic_intt_idx, als);
+#endif
+                }
+            }
+            else if(als < dynamic_intt_low_thr)
+            {
+                if(dynamic_intt_idx == 0){
+                    //als = dynamic_intt_low_thr;
+                    lux_tmp = raw_convert_to_lux(als);
+#if ALS_DEBUG
+                    LOG_INFO(">>>>>>>>>>>>>>>>>>>>>>>> INTT_MIN_LUX\r\n");
+#endif
+                }
+                else{
+                    change_flag = true;
+        			als  = dynamic_intt_low_thr;
+                	lux_tmp = raw_convert_to_lux(als);
+                    dynamic_intt_idx--;
+#if ALS_DEBUG
+                    LOG_INFO(">>>>>>>>>>>>>>>>>>>>>>>>change INTT low: %d, raw: %d \r\n", dynamic_intt_idx, als);
+#endif
+                }
+            }
+            else
+            {
+            	lux_tmp = raw_convert_to_lux(als);
+            }
+
+            now_lux = lux_tmp;
+            dynamic_intt_lux = now_lux/dynamic_intt_min_unit;
+
+            epl_sensor_report_lux(dynamic_intt_lux);
+
+            if(change_flag == true)
+            {
+                epl_sensor.als.integration_time = als_dynamic_intt_intt[dynamic_intt_idx];
+                epl_sensor.als.gain = als_dynamic_intt_gain[dynamic_intt_idx];
+                dynamic_intt_high_thr = als_dynamic_intt_high_thr[dynamic_intt_idx];
+                dynamic_intt_low_thr = als_dynamic_intt_low_thr[dynamic_intt_idx];
+                epl_sensor_update_mode(obj->client);
+                change_flag = false;
+            }
+            return dynamic_intt_lux;
+
+		break;
+#endif
+
+    }
+	return 0;
+}
+/*----------------------------------------------------------------------------*/
+
+int epl_sensor_read_als(struct i2c_client *client)
+{
+	struct epl_sensor_priv *epld = i2c_get_clientdata(client);
+
+	if(client == NULL)
+	{
+		LOG_ERR("CLIENT CANN'T EQUL NULL\n");
+		return -1;
+	}
+
+	epl_sensor_I2C_Read(epld->client, 0x13, 4);
+#if PS_DYN_K && PS_DYN_K_STR
+    if(dynk_enhance_flag == false)
+    {
+        dynk_enhance_ch0 = (gRawData.raw_bytes[1]<<8) | gRawData.raw_bytes[0];
+        dynk_enhance_ch1 = (gRawData.raw_bytes[3]<<8) | gRawData.raw_bytes[2];
+
+        LOG_INFO("read dynk_enhance_ch0 = %d\n", dynk_enhance_ch0);
+        LOG_INFO("read dynk_enhance_ch1 = %d\n", dynk_enhance_ch1);
+    }
+    else
+#endif
+    {
+    	epl_sensor.als.data.channels[0] = (gRawData.raw_bytes[1]<<8) | gRawData.raw_bytes[0];
+    	epl_sensor.als.data.channels[1] = (gRawData.raw_bytes[3]<<8) | gRawData.raw_bytes[2];
+
+#if ALS_DEBUG
+    	LOG_INFO("read als channel 0 = %d\n", epl_sensor.als.data.channels[0]);
+    	LOG_INFO("read als channel 1 = %d\n", epl_sensor.als.data.channels[1]);
+#endif
+    }
+
+
+    if(epl_sensor.wait == EPL_WAIT_SINGLE)
+	    epl_sensor_I2C_Write(epld->client,0x11,  epl_sensor.power | epl_sensor.reset);
+	return 0;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static void epl_sensor_report_ps_status(void)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+
+
+    LOG_INFO("------------------- epl_sensor.ps.data.data=%d, value=%d \n\n", epl_sensor.ps.data.data, epl_sensor.ps.compare_low >> 3);
+
+    input_report_abs(epld->ps_input_dev, ABS_DISTANCE, epl_sensor.ps.compare_low >> 3);
+    input_sync(epld->ps_input_dev);
+}
+
+int epl_sensor_read_ps(struct i2c_client *client)
+{
+    struct epl_sensor_priv *epld = i2c_get_clientdata(client);
+	if(client == NULL)
+	{
+		LOG_ERR("CLIENT CANN'T EQUL NULL\n");
+		return -1;
+	}
+
+	epl_sensor_I2C_Read(epld->client,0x1c, 4);
+
+	epl_sensor.ps.data.ir_data = (gRawData.raw_bytes[1]<<8) | gRawData.raw_bytes[0];
+	epl_sensor.ps.data.data = (gRawData.raw_bytes[3]<<8) | gRawData.raw_bytes[2];
+
+	LOG_INFO("[%s] data = %d\n", __FUNCTION__, epl_sensor.ps.data.data);
+	LOG_INFO("[%s] ir data = %d\n", __FUNCTION__, epl_sensor.ps.data.ir_data);
+
+    if(epl_sensor.wait == EPL_WAIT_SINGLE)
+	    epl_sensor_I2C_Write(epld->client, 0x11, epl_sensor.power | epl_sensor.reset);
+
+	return 0;
+}
+
+int epl_sensor_read_ps_status(struct i2c_client *client)
+{
+	u8 buf;
+#if PS_GES
+    struct epl_sensor_priv *obj = epl_sensor_obj;
+    u8 new_ps_state;
+    u8 ges_saturation;
+    bool enable_ges = obj->enable_gflag==1 && obj->ges_suspend==0;
+#endif
+	if(client == NULL)
+	{
+		LOG_ERR("CLIENT CANN'T EQUL NULL\n");
+		return -1;
+	}
+
+	epl_sensor_I2C_Read(client, 0x1b, 1);
+
+	buf = gRawData.raw_bytes[0];
+
+#if PS_GES
+    ges_saturation = (buf & 0x20);
+    new_ps_state = (buf & 0x08) >> 3;
+    LOG_INFO("[%s]:new_ps_state=%d, ps_ges_suspend_flag=%d \r\n", __func__, new_ps_state, ps_ges_suspend_flag);
+    if(enable_ges == 1 && epl_sensor.ges.polling_mode == 1)
+    {
+        if( new_ps_state == 0 && (epl_sensor.ps.compare_low>>3 == 1) && ps_ges_suspend_flag == false && ges_saturation == 0)
+            epl_sensor_notify_event();
+    }
+    else if(enable_ges == 1 && epl_sensor.ges.polling_mode == 0 && ps_ges_suspend_flag == false && ges_saturation == 0)
+    {
+        if(new_ps_state == 0)
+           epl_sensor_notify_event();
+    }
+#endif
+
+	epl_sensor.ps.saturation = (buf & 0x20);
+	epl_sensor.ps.compare_high = (buf & 0x10);
+	epl_sensor.ps.compare_low = (buf & 0x08);
+	epl_sensor.ps.interrupt_flag = (buf & 0x04);
+	epl_sensor.ps.compare_reset = (buf & 0x02);
+	epl_sensor.ps.lock= (buf & 0x01);
+#if PS_DEBUG
+	LOG_INFO("ps: ~~~~ PS ~~~~~ \n");
+	LOG_INFO("ps: buf = 0x%x\n", buf);
+	LOG_INFO("ps: sat = 0x%x\n", epl_sensor.ps.saturation);
+	LOG_INFO("ps: cmp h = 0x%x, l = 0x%x\n", epl_sensor.ps.compare_high, epl_sensor.ps.compare_low);
+	LOG_INFO("ps: int_flag = 0x%x\n",epl_sensor.ps.interrupt_flag);
+	LOG_INFO("ps: cmp_rstn = 0x%x, lock = %x\n", epl_sensor.ps.compare_reset, epl_sensor.ps.lock);
+#endif
+	return 0;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int set_psensor_intr_threshold(uint16_t low_thd, uint16_t high_thd)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    struct i2c_client *client = epld->client;
+    uint8_t high_msb ,high_lsb, low_msb, low_lsb;
+
+
+    high_msb = (uint8_t) (high_thd >> 8);
+    high_lsb   = (uint8_t) (high_thd & 0x00ff);
+    low_msb  = (uint8_t) (low_thd >> 8);
+    low_lsb    = (uint8_t) (low_thd & 0x00ff);
+
+    LOG_INFO("%s: low_thd = %d, high_thd = %d \n",__FUNCTION__, low_thd, high_thd);
+
+    epl_sensor_I2C_Write(client,0x0c,low_lsb);
+    epl_sensor_I2C_Write(client,0x0d,low_msb);
+    epl_sensor_I2C_Write(client,0x0e,high_lsb);
+    epl_sensor_I2C_Write(client,0x0f,high_msb);
+
+    return 0;
+}
+
+static int set_lsensor_intr_threshold(uint16_t low_thd, uint16_t high_thd)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    struct i2c_client *client = epld->client;
+    uint8_t high_msb ,high_lsb, low_msb, low_lsb;
+
+    high_msb = (uint8_t) (high_thd >> 8);
+    high_lsb   = (uint8_t) (high_thd & 0x00ff);
+    low_msb  = (uint8_t) (low_thd >> 8);
+    low_lsb    = (uint8_t) (low_thd & 0x00ff);
+
+    epl_sensor_I2C_Write(client,0x08,low_lsb);
+    epl_sensor_I2C_Write(client,0x09,low_msb);
+    epl_sensor_I2C_Write(client,0x0a,high_lsb);
+    epl_sensor_I2C_Write(client,0x0b,high_msb);
+
+    LOG_INFO("%s: low_thd = %d, high_thd = %d \n",__FUNCTION__, low_thd, high_thd);
+
+    return 0;
+}
+
+int epl_sensor_read_als_status(struct i2c_client *client)
+{
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+	u8 buf;
+
+	if(client == NULL)
+	{
+		LOG_ERR("CLIENT CANN'T EQUL NULL\n");
+		return -1;
+	}
+
+	epl_sensor_I2C_Read(epld->client, 0x12, 1);
+
+	buf = gRawData.raw_bytes[0];
+
+	epl_sensor.als.saturation = (buf & 0x20);
+	epl_sensor.als.compare_high = (buf & 0x10);
+	epl_sensor.als.compare_low = (buf & 0x08);
+	epl_sensor.als.interrupt_flag = (buf & 0x04);
+	epl_sensor.als.compare_reset = (buf & 0x02);
+	epl_sensor.als.lock= (buf & 0x01);
+#if ALS_DEBUG
+	LOG_INFO("als: ~~~~ ALS ~~~~~ \n");
+	LOG_INFO("als: buf = 0x%x\n", buf);
+	LOG_INFO("als: sat = 0x%x\n", epl_sensor.als.saturation);
+	LOG_INFO("als: cmp h = 0x%x, l = 0x%x\n", epl_sensor.als.compare_high, epl_sensor.als.compare_low);
+	LOG_INFO("als: int_flag = 0x%x\n",epl_sensor.als.interrupt_flag);
+	LOG_INFO("als: cmp_rstn = 0x%x, lock = 0x%x\n", epl_sensor.als.compare_reset, epl_sensor.als.lock);
+#endif
+	return 0;
+}
+
+static int write_factory_calibration(struct epl_sensor_priv *epl_data, char* ps_data, int ps_cal_len)
+{
+    struct file *fp_cal;
+
+	mm_segment_t fs;
+	loff_t pos;
+
+	LOG_FUN();
+    pos = 0;
+
+	fp_cal = filp_open(ps_cal_file, O_CREAT|O_RDWR|O_TRUNC, 0755/*S_IRWXU*/);
+	if (IS_ERR(fp_cal))
+	{
+		LOG_ERR("[ELAN]create file_h error\n");
+		return -1;
+	}
+
+    fs = get_fs();
+	set_fs(KERNEL_DS);
+
+	vfs_write(fp_cal, ps_data, ps_cal_len, &pos);
+
+    filp_close(fp_cal, NULL);
+
+	set_fs(fs);
+
+	return 0;
+}
+
+static bool read_factory_calibration(void)
+{
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+	struct file *fp;
+	mm_segment_t fs;
+	loff_t pos;
+	char buffer[100]= {0};
+	if(epl_sensor.ps.factory.calibration_enable && !epl_sensor.ps.factory.calibrated)
+	{
+		fp = filp_open(ps_cal_file, O_RDWR, S_IRUSR);
+
+		if (IS_ERR(fp))
+		{
+			LOG_ERR("NO PS calibration file(%d)\n", (int)IS_ERR(fp));
+			epl_sensor.ps.factory.calibration_enable =  false;
+		}
+		else
+		{
+		    int ps_cancelation = 0, ps_hthr = 0, ps_lthr = 0;
+			pos = 0;
+			fs = get_fs();
+			set_fs(KERNEL_DS);
+			vfs_read(fp, buffer, sizeof(buffer), &pos);
+			filp_close(fp, NULL);
+
+			sscanf(buffer, "%d,%d,%d", &ps_cancelation, &ps_hthr, &ps_lthr);
+			epl_sensor.ps.factory.cancelation = ps_cancelation;
+			epl_sensor.ps.factory.high_threshold = ps_hthr;
+			epl_sensor.ps.factory.low_threshold = ps_lthr;
+			set_fs(fs);
+
+			epl_sensor.ps.high_threshold = epl_sensor.ps.factory.high_threshold;
+			epl_sensor.ps.low_threshold = epl_sensor.ps.factory.low_threshold;
+			epl_sensor.ps.cancelation = epl_sensor.ps.factory.cancelation;
+		}
+
+		epl_sensor_I2C_Write(epld->client,0x22, (u8)(epl_sensor.ps.cancelation& 0xff));
+		epl_sensor_I2C_Write(epld->client,0x23, (u8)((epl_sensor.ps.cancelation & 0xff00) >> 8));
+		set_psensor_intr_threshold(epl_sensor.ps.low_threshold, epl_sensor.ps.high_threshold);
+
+		epl_sensor.ps.factory.calibrated = true;
+	}
+
+	if(epl_sensor.als.factory.calibration_enable && !epl_sensor.als.factory.calibrated)
+	{
+		fp = filp_open(als_cal_file, O_RDONLY, S_IRUSR);
+		if (IS_ERR(fp))
+		{
+			LOG_ERR("NO ALS calibration file(%d)\n", (int)IS_ERR(fp));
+			epl_sensor.als.factory.calibration_enable =  false;
+		}
+		else
+		{
+		    int als_lux_per_count = 0;
+			pos = 0;
+			fs = get_fs();
+			set_fs(KERNEL_DS);
+			vfs_read(fp, buffer, sizeof(buffer), &pos);
+			filp_close(fp, NULL);
+
+			sscanf(buffer, "%d", &als_lux_per_count);
+			epl_sensor.als.factory.lux_per_count = als_lux_per_count;
+			set_fs(fs);
+		}
+		epl_sensor.als.factory.calibrated = true;
+	}
+	return true;
+}
+
+static int epl_run_ps_calibration(struct epl_sensor_priv *epl_data)
+{
+    struct epl_sensor_priv *epld = epl_data;
+    bool enable_ps = epld->enable_pflag==1 && epld->ps_suspend==0;
+    u16 ch1=0;
+    u32 ch1_all=0;
+    int count =5, i;
+    int ps_hthr=0, ps_lthr=0, ps_cancelation=0, ps_cal_len = 0;
+    char ps_calibration[20];
+
+
+    if(PS_MAX_XTALK < 0)
+    {
+        LOG_ERR("[%s]:Failed: PS_MAX_XTALK < 0 \r\n", __func__);
+        return -EINVAL;
+    }
+
+    if(enable_ps == 0)
+    {
+        epld->enable_pflag = 1;
+        epl_sensor_update_mode(epld->client);
+    }
+
+    polling_flag = false;
+
+    for(i=0; i<count; i++)
+    {
+        msleep(50);
+    	switch(epl_sensor.mode)
+    	{
+    		case EPL_MODE_PS:
+    		case EPL_MODE_ALS_PS:
+                if(enable_ps == true && polling_flag == true && eint_flag == true && epl_sensor.ps.polling_mode == 0)
+    		 	    epl_sensor_read_ps(epld->client);
+    			ch1 = epl_sensor.ps.data.data;
+		    break;
+    	}
+
+    	ch1_all = ch1_all + ch1;
+    	if(epl_sensor.wait == EPL_WAIT_SINGLE)
+    		epl_sensor_I2C_Write(epld->client,0x11, epl_sensor.power | epl_sensor.reset);
+    }
+
+
+    ch1 = (u16)(ch1_all/count);
+
+    if(ch1 > PS_MAX_XTALK)
+    {
+        LOG_ERR("[%s]:Failed: ch1 > max_xtalk(%d) \r\n", __func__, ch1);
+        return -EINVAL;
+    }
+    else if(ch1 <= 0)
+    {
+        LOG_ERR("[%s]:Failed: ch1 = 0\r\n", __func__);
+        return -EINVAL;
+    }
+
+    ps_hthr = ch1 + PS_h_offset;
+    ps_lthr = ch1 + PS_l_offset;
+
+    ps_cal_len = sprintf(ps_calibration, "%d,%d,%d", ps_cancelation, ps_hthr, ps_lthr);
+
+    if(write_factory_calibration(epld, ps_calibration, ps_cal_len) < 0)
+    {
+        LOG_ERR("[%s] create file error \n", __func__);
+        return -EINVAL;
+    }
+
+    epl_sensor.ps.low_threshold = ps_lthr;
+	epl_sensor.ps.high_threshold = ps_hthr;
+	set_psensor_intr_threshold(epl_sensor.ps.low_threshold, epl_sensor.ps.high_threshold);
+
+	LOG_INFO("[%s]: ch1 = %d\n", __func__, ch1);
+
+    polling_flag = true;
+    epl_sensor_restart_polling();
+	return ch1;
+}
+
+/*
+//====================write global variable===============//
+*/
+static void write_global_variable(struct i2c_client *client)
+{
+	u8 buf;
+#if HS_ENABLE
+    struct epl_sensor_priv *obj = epl_sensor_obj;
+    bool enable_hs = obj->enable_hflag==1 && obj->hs_suspend==0;
+#endif
+#if PS_GES
+    bool enable_ges = obj->enable_gflag==1 && obj->ges_suspend==0;
+#endif
+	//wake up chip
+	buf = epl_sensor.reset | epl_sensor.power;
+	epl_sensor_I2C_Write(client,0x11, buf);
+
+       /* read revno*/
+	epl_sensor_I2C_Read(client, 0x20, 2);
+	epl_sensor.revno = gRawData.raw_bytes[0] | gRawData.raw_bytes[1] << 8;
+
+    /*chip refrash*/
+    epl_sensor_I2C_Write(client, 0xfd, 0x8e);
+    epl_sensor_I2C_Write(client, 0xfe, 0x22);
+    epl_sensor_I2C_Write(client, 0xfe, 0x02);
+    epl_sensor_I2C_Write(client, 0xfd, 0x00);
+
+    epl_sensor_I2C_Write(client, 0xfc, EPL_A_D | EPL_NORMAL| EPL_GFIN_ENABLE | EPL_VOS_ENABLE | EPL_DOC_ON);
+
+#if HS_ENABLE
+	if(enable_hs)
+	{
+	    epl_sensor.mode = EPL_MODE_PS;
+	    epl_sensor_I2C_Write(obj->client, 0x00, epl_sensor.wait | EPL_MODE_IDLE);
+
+		/*hs setting*/
+		buf = epl_sensor.hs.integration_time | epl_sensor.hs.gain;
+		epl_sensor_I2C_Write(client, 0x03, buf);
+
+		buf = epl_sensor.hs.adc | epl_sensor.hs.cycle;
+		epl_sensor_I2C_Write(client, 0x04, buf);
+
+		buf = epl_sensor.hs.ir_on_control | epl_sensor.hs.ir_mode | epl_sensor.hs.ir_driver;
+		epl_sensor_I2C_Write(client, 0x05, buf);
+
+		buf = epl_sensor.hs.compare_reset | epl_sensor.hs.lock;
+
+		epl_sensor_I2C_Write(client, 0x1b, buf);
+	}
+#if !PS_GES	/*PS_GES*/
+	else
+#elif PS_GES
+    else if(enable_ges)
+#endif  /*PS_GES*/
+#endif
+
+#if PS_GES
+
+#if !HS_ENABLE /*HS_ENABLE*/
+    if(enable_ges)
+#endif  /*HS_ENABLE*/
+    {
+        /*ges setting*/
+        buf = epl_sensor.ges.integration_time | epl_sensor.ges.gain;
+        epl_sensor_I2C_Write(client, 0x03, buf);
+
+        buf = epl_sensor.ges.adc | epl_sensor.ges.cycle;
+        epl_sensor_I2C_Write(client, 0x04, buf);
+
+        buf = epl_sensor.ges.ir_on_control | epl_sensor.ges.ir_mode | epl_sensor.ges.ir_drive;
+        epl_sensor_I2C_Write(client, 0x05, buf);
+
+        buf = epl_sensor.interrupt_control | epl_sensor.ges.persist |epl_sensor.ges.interrupt_type;
+        epl_sensor_I2C_Write(client, 0x06, buf);
+
+        buf = epl_sensor.ges.compare_reset | epl_sensor.ges.lock;
+        epl_sensor_I2C_Write(client, 0x1b, buf);
+
+        epl_sensor_I2C_Write(client, 0x22, (u8)(epl_sensor.ges.cancelation& 0xff));
+        epl_sensor_I2C_Write(client, 0x23, (u8)((epl_sensor.ges.cancelation & 0xff00) >> 8));
+        set_psensor_intr_threshold(epl_sensor.ges.low_threshold, epl_sensor.ges.high_threshold);
+    }
+    else
+#endif
+    {
+    	/*ps setting*/
+    	buf = epl_sensor.ps.integration_time | epl_sensor.ps.gain;
+    	epl_sensor_I2C_Write(client,0x03, buf);
+
+    	buf = epl_sensor.ps.adc | epl_sensor.ps.cycle;
+    	epl_sensor_I2C_Write(client,0x04, buf);
+
+    	buf = epl_sensor.ps.ir_on_control | epl_sensor.ps.ir_mode | epl_sensor.ps.ir_drive;
+    	epl_sensor_I2C_Write(client,0x05, buf);
+
+    	buf = epl_sensor.interrupt_control | epl_sensor.ps.persist |epl_sensor.ps.interrupt_type;
+    	epl_sensor_I2C_Write(client,0x06, buf);
+
+    	buf = epl_sensor.ps.compare_reset | epl_sensor.ps.lock;
+    	epl_sensor_I2C_Write(client,0x1b, buf);
+
+    	epl_sensor_I2C_Write(client,0x22, (u8)(epl_sensor.ps.cancelation& 0xff));
+    	epl_sensor_I2C_Write(client,0x23, (u8)((epl_sensor.ps.cancelation & 0xff0) >> 8));
+    	set_psensor_intr_threshold(epl_sensor.ps.low_threshold, epl_sensor.ps.high_threshold);
+
+    	/*als setting*/
+    	buf = epl_sensor.als.integration_time | epl_sensor.als.gain;
+    	epl_sensor_I2C_Write(client,0x01, buf);
+
+    	buf = epl_sensor.als.adc | epl_sensor.als.cycle;
+    	epl_sensor_I2C_Write(client,0x02, buf);
+
+    	buf = epl_sensor.als.interrupt_channel_select | epl_sensor.als.persist | epl_sensor.als.interrupt_type;
+    	epl_sensor_I2C_Write(client,0x07, buf);
+
+    	buf = epl_sensor.als.compare_reset | epl_sensor.als.lock;
+    	epl_sensor_I2C_Write(client,0x12, buf);
+
+    	set_lsensor_intr_threshold(epl_sensor.als.low_threshold, epl_sensor.als.high_threshold);
+    }
+	//set mode and wait
+	buf = epl_sensor.wait | epl_sensor.mode;
+	epl_sensor_I2C_Write(client,0x00, buf);
+}
+
+static void set_als_ps_intr_type(struct i2c_client *client, bool ps_polling, bool als_polling)
+{
+
+    //set als / ps interrupt control mode and trigger type
+	switch((ps_polling << 1) | als_polling)
+	{
+		case 0: // ps and als interrupt
+			epl_sensor.interrupt_control = 	EPL_INT_CTRL_ALS_OR_PS;
+			epl_sensor.als.interrupt_type = EPL_INTTY_ACTIVE;
+			epl_sensor.ps.interrupt_type = EPL_INTTY_ACTIVE;
+		break;
+
+		case 1: //ps interrupt and als polling
+			epl_sensor.interrupt_control = 	EPL_INT_CTRL_PS;
+			epl_sensor.als.interrupt_type = EPL_INTTY_DISABLE;
+			epl_sensor.ps.interrupt_type = EPL_INTTY_ACTIVE;
+		break;
+
+		case 2: // ps polling and als interrupt
+			epl_sensor.interrupt_control = 	EPL_INT_CTRL_ALS;
+			epl_sensor.als.interrupt_type = EPL_INTTY_ACTIVE;
+			epl_sensor.ps.interrupt_type = EPL_INTTY_DISABLE;
+		break;
+
+		case 3: //ps and als polling
+			epl_sensor.interrupt_control = 	EPL_INT_CTRL_ALS_OR_PS;
+			epl_sensor.als.interrupt_type = EPL_INTTY_DISABLE;
+			epl_sensor.ps.interrupt_type = EPL_INTTY_DISABLE;
+		break;
+	}
+}
+
+//====================initial global variable===============//
+static void initial_global_variable(struct i2c_client *client, struct epl_sensor_priv *obj)
+{
+
+	//general setting
+	epl_sensor.power = EPL_POWER_ON;
+	epl_sensor.reset = EPL_RESETN_RUN;
+	epl_sensor.mode = EPL_MODE_IDLE;
+	epl_sensor.wait = EPL_WAIT_20_MS;
+	epl_sensor.osc_sel = EPL_OSC_SEL_1MHZ;
+
+	//als setting
+	epl_sensor.als.polling_mode = ALS_POLLING_MODE;
+	epl_sensor.als.integration_time = EPL_ALS_INTT_64;
+	epl_sensor.als.gain = EPL_GAIN_MID;
+	epl_sensor.als.adc = EPL_PSALS_ADC_13;
+	epl_sensor.als.cycle = EPL_CYCLE_16;
+	epl_sensor.als.interrupt_channel_select = EPL_ALS_INT_CHSEL_1;
+	epl_sensor.als.persist = EPL_PERIST_1;
+	epl_sensor.als.compare_reset = EPL_CMP_RESET;
+	epl_sensor.als.lock = EPL_UN_LOCK;
+	epl_sensor.als.report_type = CMC_BIT_RAW; //CMC_BIT_DYN_INT
+	epl_sensor.als.high_threshold = ALS_HIGH_THRESHOLD;
+	epl_sensor.als.low_threshold = ALS_LOW_THRESHOLD;
+	//als factory
+	epl_sensor.als.factory.calibration_enable =  false;
+	epl_sensor.als.factory.calibrated = false;
+	epl_sensor.als.factory.lux_per_count = LUX_PER_COUNT;
+
+#if ALS_DYN_INTT
+
+    epl_sensor.als.lsrc_type = CMC_BIT_LSRC_NON;
+
+    if(epl_sensor.als.report_type == CMC_BIT_DYN_INT)
+    {
+        dynamic_intt_idx = dynamic_intt_init_idx;
+        epl_sensor.als.integration_time = als_dynamic_intt_intt[dynamic_intt_idx];
+        epl_sensor.als.gain = als_dynamic_intt_gain[dynamic_intt_idx];
+        dynamic_intt_high_thr = als_dynamic_intt_high_thr[dynamic_intt_idx];
+        dynamic_intt_low_thr = als_dynamic_intt_low_thr[dynamic_intt_idx];
+    }
+
+    c_gain = 21000; // 21000/1000=21
+
+    obj->lsource_thd_high = 1900; //different light source boundary (N) (1.9)
+    obj->lsource_thd_low = 1500;   //1.5
+    obj->c_gain_h = 21000; //fluorescent (C1) (21)
+    obj->c_gain_l = 15000;  //incandescent (C2)   (15)
+
+#endif
+	//ps setting
+	epl_sensor.ps.polling_mode = PS_POLLING_MODE;
+	epl_sensor.ps.integration_time = EPL_PS_INTT_80;
+	epl_sensor.ps.gain = EPL_GAIN_MID;
+#if PS_DYN_K
+    dynk_min_ps_raw_data = 0xffff; //min raw data
+    dynk_max_ir_data = 50000;      //max ch0
+    dynk_low_offset = 500;         //low thd offset
+    dynk_high_offset = 800;        //high thd offset
+    dynk_change_thd_max = 30000;   //change thd condition
+    dynk_thd_offset = 500;         //change thd offset
+#if PS_DYN_K_STR
+    dynk_enhance_max_ch0 = 50000; //enhance max ch0
+    dynk_enhance_integration_time = EPL_ALS_INTT_64;
+    dynk_enhance_gain = EPL_GAIN_LOW;
+    dynk_enhance_adc = EPL_PSALS_ADC_12;
+#endif
+#endif
+	epl_sensor.ps.adc = EPL_PSALS_ADC_12;
+	epl_sensor.ps.cycle = EPL_CYCLE_32;
+	epl_sensor.ps.persist = EPL_PERIST_1;
+	epl_sensor.ps.ir_on_control = EPL_IR_ON_CTRL_ON;
+	epl_sensor.ps.ir_mode = EPL_IR_MODE_CURRENT;
+	epl_sensor.ps.ir_drive = EPL_IR_DRIVE_100;
+	epl_sensor.ps.compare_reset = EPL_CMP_RESET;
+	epl_sensor.ps.lock = EPL_UN_LOCK;
+	epl_sensor.ps.high_threshold = PS_HIGH_THRESHOLD;
+	epl_sensor.ps.low_threshold = PS_LOW_THRESHOLD;
+	//ps factory
+	epl_sensor.ps.factory.calibration_enable = false;
+	epl_sensor.ps.factory.calibrated = false;
+	epl_sensor.ps.factory.cancelation= 0;
+
+#if HS_ENABLE
+	//hs setting
+    epl_sensor.hs.integration_time = EPL_PS_INTT_80;
+	epl_sensor.hs.integration_time_max = EPL_PS_INTT_272;
+	epl_sensor.hs.integration_time_min = EPL_PS_INTT_32;
+    epl_sensor.hs.gain = EPL_GAIN_LOW;
+    epl_sensor.hs.adc = EPL_PSALS_ADC_11;
+    epl_sensor.hs.cycle = EPL_CYCLE_4;
+    epl_sensor.hs.ir_on_control = EPL_IR_ON_CTRL_ON;
+    epl_sensor.hs.ir_mode = EPL_IR_MODE_CURRENT;
+    epl_sensor.hs.ir_driver = EPL_IR_DRIVE_200;
+    epl_sensor.hs.compare_reset = EPL_CMP_RESET;
+    epl_sensor.hs.lock = EPL_UN_LOCK;
+	epl_sensor.hs.low_threshold = 6400;
+	epl_sensor.hs.mid_threshold = 25600;
+	epl_sensor.hs.high_threshold = 60800;
+#endif
+
+#if PS_GES
+    //ps setting
+    epl_sensor.ges.polling_mode = PS_POLLING_MODE;
+    epl_sensor.ges.integration_time = EPL_PS_INTT_80;
+    epl_sensor.ges.gain = EPL_GAIN_LOW;
+    epl_sensor.ges.adc = EPL_PSALS_ADC_12;
+    epl_sensor.ges.cycle = EPL_CYCLE_2;
+    epl_sensor.ges.persist = EPL_PERIST_1;
+    epl_sensor.ges.ir_on_control = EPL_IR_ON_CTRL_ON;
+    epl_sensor.ges.ir_mode = EPL_IR_MODE_CURRENT;
+    epl_sensor.ges.ir_drive = EPL_IR_DRIVE_200;
+    epl_sensor.ges.compare_reset = EPL_CMP_RESET;
+    epl_sensor.ges.lock = EPL_UN_LOCK;
+    epl_sensor.ges.high_threshold = ges_threshold_high;
+    epl_sensor.ges.low_threshold = ges_threshold_low;
+#endif
+
+    set_als_ps_intr_type(client, epl_sensor.ps.polling_mode, epl_sensor.als.polling_mode);
+	//write setting to sensor
+	write_global_variable(client);
+}
+
+#if HS_ENABLE
+int epl_sensor_read_hs(struct i2c_client *client)
+{
+    u8 buf;
+
+    if(client == NULL)
+    {
+        LOG_ERR("CLIENT CANN'T EQUL NULL\n");
+        return -1;
+    }
+
+    mutex_lock(&hs_sensor_mutex);
+    epl_sensor_I2C_Read(client,0x1e, 2);
+    epl_sensor.hs.raw = (gRawData.raw_bytes[1]<<8) | gRawData.raw_bytes[0];
+    LOG_INFO("epl_sensor.hs.raw=%d \r\n", epl_sensor.hs.raw);
+    if(epl_sensor.hs.dynamic_intt == true && epl_sensor.hs.raw>epl_sensor.hs.high_threshold && epl_sensor.hs.integration_time > epl_sensor.hs.integration_time_min)
+    {
+		epl_sensor.hs.integration_time -= 4;
+		buf = epl_sensor.hs.integration_time | epl_sensor.hs.gain;
+		epl_sensor_I2C_Write(client, 0x03, buf);
+    }
+    else if(epl_sensor.hs.dynamic_intt == true && epl_sensor.hs.raw>epl_sensor.hs.low_threshold && epl_sensor.hs.raw <epl_sensor.hs.mid_threshold && epl_sensor.hs.integration_time <  epl_sensor.hs.integration_time_max)
+	{
+		epl_sensor.hs.integration_time += 4;
+		buf = epl_sensor.hs.integration_time | epl_sensor.hs.gain;
+		epl_sensor_I2C_Write(client, 0x03, buf);
+	}
+
+	mutex_unlock(&hs_sensor_mutex);
+
+    if(epl_sensor.hs.raws_count<200)
+    {
+		epl_sensor.hs.raws[epl_sensor.hs.raws_count] = epl_sensor.hs.raw;
+        epl_sensor.hs.raws_count++;
+    }
+
+    return 0;
+}
+#endif
+
+#if PS_DYN_K
+void epl_sensor_reset_dynk_thd(u8 last_status, u8 now_status)
+{
+    if(last_status==0 && now_status==1)
+    {
+#if PS_DYN_K_STR
+        if( (epl_sensor.ps.saturation == 0) && (epl_sensor.ps.data.ir_data < dynk_max_ir_data) && (dynk_enhance_ch0 < dynk_enhance_max_ch0) )
+#else
+        if( (epl_sensor.ps.saturation == 0)&&(epl_sensor.ps.data.ir_data < dynk_max_ir_data) )
+#endif
+        {
+            dynk_min_ps_raw_data = epl_sensor.ps.data.data;
+        }
+
+        dynk_thd_low = dynk_min_ps_raw_data + dynk_low_offset;
+	    dynk_thd_high = dynk_min_ps_raw_data + dynk_high_offset;
+
+        if(dynk_thd_low>65534)
+            dynk_thd_low = 65534;
+        if(dynk_thd_high>65535)
+            dynk_thd_high = 65535;
+#if PS_DEBUG
+	    LOG_INFO("[%s]:restart dynk ps raw = %d, min = %d, ir_data = %d\n", __func__, epl_sensor.ps.data.data, dynk_min_ps_raw_data, epl_sensor.ps.data.ir_data);
+	    LOG_INFO("[%s]:restart dynk thre_l = %ld, thre_h = %ld\n", __func__, (long)dynk_thd_low, (long)dynk_thd_high);
+#endif
+        eint_flag = false;
+	    set_psensor_intr_threshold((u16)dynk_thd_low, (u16)dynk_thd_high);
+        eint_flag = true;
+    }
+    else if(last_status==1 && now_status==0)
+    {
+        dynk_change_flag = true;
+    }
+}
+#if PS_DYN_K_STR
+void epl_sensor_enhance_enable(struct i2c_client *client, bool enable)
+{
+    bool cmp_flag = false;
+    u8 buf, now_cmp_l;
+    int enh_time=0, ps_time=0, total_time=0;
+    ps_time = ps_sensing_time(epl_sensor.ps.integration_time, epl_sensor.ps.adc, epl_sensor.ps.cycle);
+
+
+    //mutex_lock(&sensor_mutex);
+    polling_flag = false;
+
+
+    epl_sensor_I2C_Read(client, 0x1b, 1);
+    buf = gRawData.raw_bytes[0];
+    epl_sensor.ps.compare_high = (buf & 0x10);
+	now_cmp_l = (buf & 0x08);
+
+	if(now_cmp_l != epl_sensor.ps.compare_low)
+	{
+	    LOG_INFO("[%s]: buf=0x%x, now_cmp_l=0x%x, epl_sensor.ps.compare_low=0x%x \r\n", __func__, buf, now_cmp_l, epl_sensor.ps.compare_low);
+        //PS unlock and reset
+        epl_sensor.ps.compare_reset = EPL_CMP_RESET;
+        epl_sensor.ps.lock = EPL_UN_LOCK;
+        epl_sensor_I2C_Write(client, 0x1b, epl_sensor.ps.compare_reset |epl_sensor.ps.lock);
+
+        cmp_flag = true;
+	}
+
+    epl_sensor.ps.interrupt_flag = EPL_INT_CLEAR;
+    epl_sensor.als.interrupt_flag = EPL_INT_CLEAR;
+
+    epl_sensor_I2C_Write(client, 0x00, epl_sensor.wait | EPL_MODE_IDLE);
+
+    if(enable == true){
+        enh_time = als_sensing_time(dynk_enhance_integration_time, dynk_enhance_adc, epl_sensor.als.cycle) / 2;
+        epl_sensor_I2C_Write(client, 0x01, dynk_enhance_integration_time | dynk_enhance_gain);
+        epl_sensor_I2C_Write(client, 0x02, dynk_enhance_adc | epl_sensor.als.cycle);
+        epl_sensor_I2C_Write(client, 0xfc, EPL_A_D | EPL_NORMAL| EPL_GFIN_ENABLE | EPL_VOS_ENABLE | EPL_DOC_OFF);
+    }
+    else
+    {
+        enh_time = als_sensing_time(epl_sensor.als.integration_time, epl_sensor.als.adc, epl_sensor.als.cycle);
+        epl_sensor_I2C_Write(client, 0x01, epl_sensor.als.integration_time | epl_sensor.als.gain);
+        epl_sensor_I2C_Write(client, 0x02, epl_sensor.als.adc | epl_sensor.als.cycle);
+        epl_sensor_I2C_Write(client, 0xfc, EPL_A_D | EPL_NORMAL| EPL_GFIN_ENABLE | EPL_VOS_ENABLE | EPL_DOC_ON);
+    }
+
+    als_frame_time = enh_time;
+    ps_frame_time = ps_time;
+
+    epl_sensor_I2C_Write(client, 0x00, epl_sensor.wait | epl_sensor.mode);
+    if(cmp_flag == true)
+    {
+        //PS unlock and run
+        epl_sensor.ps.compare_reset = EPL_CMP_RUN;
+        epl_sensor.ps.lock = EPL_UN_LOCK;
+        epl_sensor_I2C_Write(client, 0x1b, epl_sensor.ps.compare_reset |epl_sensor.ps.lock);
+
+        cmp_flag = false;
+    }
+    //mutex_unlock(&sensor_mutex);
+
+    total_time = ps_time+enh_time+wait_value[epl_sensor.wait>>4];
+    if((2*total_time) >= dynk_polling_delay)
+    {
+        dynk_polling_delay = 2*total_time+50;
+        LOG_INFO("[%s]: dynk_polling_delay=%d \r\n", __func__, dynk_polling_delay);
+    }
+
+    msleep(total_time);
+    LOG_INFO("[%s] PS+ALS(%dms)\r\n", __func__, total_time);
+
+    //mutex_lock(&sensor_mutex);
+    if(enable == true)
+    {
+        epl_sensor_read_als(client);
+    }
+
+    if(epl_sensor.ps.interrupt_flag == EPL_INT_TRIGGER)
+    {
+        //PS unlock and run
+        epl_sensor.ps.compare_reset = EPL_CMP_RUN;
+        epl_sensor.ps.lock = EPL_UN_LOCK;
+        epl_sensor_I2C_Write(client, 0x1b, epl_sensor.ps.compare_reset |epl_sensor.ps.lock);
+    }
+    polling_flag = true;
+    //mutex_unlock(&sensor_mutex);
+
+}
+#endif
+
+void epl_sensor_restart_dynk_polling(void)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    cancel_delayed_work(&dynk_thd_polling_work);
+    queue_delayed_work(epld->epl_wq, &dynk_thd_polling_work,msecs_to_jiffies(dynk_polling_delay));
+}
+
+void epl_sensor_dynk_thd_polling_work(struct work_struct *work)
+{
+    struct epl_sensor_priv *obj = epl_sensor_obj;
+
+    bool enable_ps = obj->enable_pflag==1 && obj->ps_suspend==0;
+#if PS_DEBUG
+    bool enable_als = obj->enable_lflag==1 && obj->als_suspend==0;
+    LOG_INFO("[%s]:als / ps enable: %d / %d\n", __func__,enable_als, enable_ps);
+#endif
+
+    if(enable_ps == true)
+    {
+#if PS_DYN_K_STR
+        dynk_enhance_flag = false;
+        if(polling_flag == true && eint_flag == true)
+        {
+             epl_sensor_enhance_enable(obj->client, true);
+        }
+#endif
+        if(polling_flag == true && eint_flag == true && epl_sensor.ps.polling_mode == 0)
+        {
+            mutex_lock(&sensor_mutex);
+            epl_sensor_read_ps_status(obj->client);
+            epl_sensor_read_ps(obj->client);
+            mutex_unlock(&sensor_mutex);
+        }
+#if PS_DYN_K_STR
+        if( (dynk_min_ps_raw_data > epl_sensor.ps.data.data)
+            && (epl_sensor.ps.saturation == 0)
+            && (epl_sensor.ps.data.ir_data < dynk_max_ir_data)
+            && (dynk_enhance_ch0 < dynk_enhance_max_ch0) )
+#else
+        if( (dynk_min_ps_raw_data > epl_sensor.ps.data.data)
+            && (epl_sensor.ps.saturation == 0)
+            && (epl_sensor.ps.data.ir_data < dynk_max_ir_data) )
+#endif
+        {
+            dynk_min_ps_raw_data = epl_sensor.ps.data.data;
+            dynk_thd_low = dynk_min_ps_raw_data + dynk_low_offset;
+		    dynk_thd_high = dynk_min_ps_raw_data + dynk_high_offset;
+
+            if(dynk_thd_low>65534)
+                dynk_thd_low = 65534;
+            if(dynk_thd_high>65535)
+                dynk_thd_high = 65535;
+#if PS_DEBUG
+		    LOG_INFO("[%s]:dyn ps raw = %d, min = %d, ir_data = %d\n", __func__, epl_sensor.ps.data.data, dynk_min_ps_raw_data, epl_sensor.ps.data.ir_data);
+#endif
+            eint_flag = false;
+            mutex_lock(&sensor_mutex);
+		    set_psensor_intr_threshold((u16)dynk_thd_low, (u16)dynk_thd_high);
+            mutex_unlock(&sensor_mutex);
+            eint_flag = true;
+#if PS_DEBUG
+		    LOG_INFO("[%s]:dyn k thre_l = %ld, thre_h = %ld\n", __func__, (long)dynk_thd_low, (long)dynk_thd_high);
+#endif
+        }
+        else if(dynk_change_flag==true && (epl_sensor.ps.data.data>dynk_change_thd_max) && ( (epl_sensor.ps.compare_low >> 3)==0 ))
+        {
+            dynk_change_flag = false;
+            dynk_thd_low += dynk_thd_offset;
+	        dynk_thd_high += dynk_thd_offset;
+
+	        if(dynk_thd_low>65534)
+                dynk_thd_low = 65534;
+            if(dynk_thd_high>65535)
+                dynk_thd_high = 65535;
+
+            eint_flag = false;
+            mutex_lock(&sensor_mutex);
+            set_psensor_intr_threshold((u16)dynk_thd_low, (u16)dynk_thd_high);
+            mutex_unlock(&sensor_mutex);
+            eint_flag = true;
+#if PS_DEBUG
+            LOG_INFO("[%s]: epl_sensor.ps.data.data=%d, L/H=%ld/%ld \r\n", __func__, epl_sensor.ps.data.data, (long)dynk_thd_low, (long)dynk_thd_high);
+#endif
+        }
+#if PS_DYN_K_STR
+        if(polling_flag == true && eint_flag == true)
+        {
+            epl_sensor_enhance_enable(obj->client, false);
+        }
+        dynk_enhance_flag = true;
+#endif
+        queue_delayed_work(obj->epl_wq, &dynk_thd_polling_work,msecs_to_jiffies(dynk_polling_delay));
+    }
+}
+#endif
+
+/************************************************************************/
+//for 3637
+static int als_sensing_time(int intt, int adc, int cycle)
+{
+    long sensing_us_time;
+    int sensing_ms_time;
+    int als_intt, als_adc, als_cycle;
+
+    als_intt = als_intt_value[intt>>2];
+    als_adc = adc_value[adc>>3];
+    als_cycle = cycle_value[cycle];
+#if COMMON_DEBUG
+    LOG_INFO("ALS: INTT=%d, ADC=%d, Cycle=%d \r\n", als_intt, als_adc, als_cycle);
+#endif
+
+    sensing_us_time = (als_intt + als_adc*2*2) * 2 * als_cycle;
+    sensing_ms_time = sensing_us_time / 1000;
+
+#if COMMON_DEBUG
+    LOG_INFO("[%s]: sensing=%d ms \r\n", __func__, sensing_ms_time);
+#endif
+    return (sensing_ms_time + 5);
+}
+
+static int ps_sensing_time(int intt, int adc, int cycle)
+{
+    long sensing_us_time;
+    int sensing_ms_time;
+    int ps_intt, ps_adc, ps_cycle;
+
+    ps_intt = ps_intt_value[intt>>2];
+    ps_adc = adc_value[adc>>3];
+    ps_cycle = cycle_value[cycle];
+#if COMMON_DEBUG
+    LOG_INFO("PS: INTT=%d, ADC=%d, Cycle=%d \r\n", ps_intt, ps_adc, ps_cycle);
+#endif
+
+    sensing_us_time = (ps_intt*3 + ps_adc*2*3) * ps_cycle;
+    sensing_ms_time = sensing_us_time / 1000;
+#if COMMON_DEBUG
+    LOG_INFO("[%s]: sensing=%d ms\r\n", __func__, sensing_ms_time);
+#endif
+
+
+    return (sensing_ms_time + 5);
+}
+
+static int epl_sensor_get_wait_time(int ps_time, int als_time)
+{
+    int wait_idx = 0;
+    int wait_time = 0;
+
+    wait_time = als_time - ps_time;
+    if(wait_time < 0){
+        wait_time = 0;
+    }
+#if COMMON_DEBUG
+    LOG_INFO("[%s]: wait_len = %d \r\n", __func__, wait_len);
+#endif
+    for(wait_idx = 0; wait_idx < wait_len; wait_idx++)
+	{
+	    if(wait_time < wait_value[wait_idx])
+	    {
+	        break;
+	    }
+	}
+	if(wait_idx >= wait_len){
+        wait_idx = wait_len - 1;
+	}
+
+#if COMMON_DEBUG
+	LOG_INFO("[%s]: wait_idx = %d, wait = %dms \r\n", __func__, wait_idx, wait_value[wait_idx]);
+#endif
+	return (wait_idx << 4);
+}
+/************************************************************************/
+
+void epl_sensor_update_mode(struct i2c_client *client)
+{
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+    int als_time = 0, ps_time = 0;
+
+	bool enable_ps = epld->enable_pflag==1 && epld->ps_suspend==0;
+    bool enable_als = epld->enable_lflag==1 && epld->als_suspend==0;
+#if HS_ENABLE
+	bool enable_hs = epld->enable_hflag==1 && epld->hs_suspend==0;
+#endif
+#if PS_GES
+    bool enable_ges = epld->enable_gflag==1 && epld->ges_suspend==0;
+#endif
+    polling_flag = false;
+    als_time = als_sensing_time(epl_sensor.als.integration_time, epl_sensor.als.adc, epl_sensor.als.cycle);
+    ps_time = ps_sensing_time(epl_sensor.ps.integration_time, epl_sensor.ps.adc, epl_sensor.ps.cycle);
+
+    als_frame_time = als_time;
+    ps_frame_time = ps_time;
+
+#if HS_ENABLE
+    if(enable_hs)
+    {
+        LOG_INFO("[%s]: HS mode \r\n", __func__);
+        epl_sensor_restart_polling();
+    }
+	else
+#endif
+    {
+        //PS unlock and reset
+        epl_sensor.ps.compare_reset = EPL_CMP_RESET;
+        epl_sensor.ps.lock = EPL_UN_LOCK;
+        epl_sensor_I2C_Write(epld->client, 0x1b, epl_sensor.ps.compare_reset |epl_sensor.ps.lock);
+
+        //ALS unlock and reset
+        epl_sensor.als.compare_reset = EPL_CMP_RESET;
+    	epl_sensor.als.lock = EPL_UN_LOCK;
+    	epl_sensor_I2C_Write(epld->client, 0x12, epl_sensor.als.compare_reset | epl_sensor.als.lock);
+
+
+        //epl_sensor_I2C_Write(epld->client, 0x11, EPL_RESETN_RESET | EPL_POWER_OFF);
+        epl_sensor.ps.interrupt_flag = EPL_INT_CLEAR;
+        epl_sensor.als.interrupt_flag = EPL_INT_CLEAR;
+
+#if PS_GES
+        LOG_INFO("mode selection =0x%x\n", (enable_ps|enable_ges) | (enable_als << 1));
+#else
+    	LOG_INFO("mode selection =0x%x\n", enable_ps | (enable_als << 1));
+#endif
+
+#if PS_GES
+        //**** mode selection ****
+        switch((enable_als << 1) | (enable_ps|enable_ges))
+#else
+        //**** mode selection ****
+        switch((enable_als << 1) | enable_ps)
+#endif
+        {
+            case 0: //disable all
+                epl_sensor.mode = EPL_MODE_IDLE;
+                break;
+
+            case 1: //als = 0, ps = 1
+#if PS_DYN_K && PS_DYN_K_STR
+                epl_sensor.mode = EPL_MODE_ALS_PS;
+#else
+                epl_sensor.mode = EPL_MODE_PS;
+#endif
+                break;
+
+            case 2: //als = 1, ps = 0
+                epl_sensor.mode = EPL_MODE_ALS;
+                break;
+
+            case 3: //als = 1, ps = 1
+                epl_sensor.mode = EPL_MODE_ALS_PS;
+                break;
+        }
+
+        //**** write setting ****
+        // step 1. set sensor at idle mode
+        // step 2. set sensor at operation mode
+        // step 3. delay sensing time
+        // step 4. unlock and run als / ps status
+        epl_sensor_I2C_Write(epld->client, 0x00, epl_sensor.wait | EPL_MODE_IDLE);
+        // initial factory calibration variable
+        read_factory_calibration();
+
+        epl_sensor_I2C_Write(epld->client, 0x02, epl_sensor.als.adc | epl_sensor.als.cycle);
+        set_als_ps_intr_type(epld->client, epl_sensor.ps.polling_mode, epl_sensor.als.polling_mode);
+
+        epl_sensor_I2C_Write(epld->client, 0x06, epl_sensor.interrupt_control | epl_sensor.ps.persist |epl_sensor.ps.interrupt_type);
+
+        epl_sensor_I2C_Write(epld->client, 0x07, epl_sensor.als.interrupt_channel_select | epl_sensor.als.persist | epl_sensor.als.interrupt_type);
+
+#if ALS_DYN_INTT
+        if(epl_sensor.als.report_type == CMC_BIT_DYN_INT){
+    	    epl_sensor_I2C_Write(client, 0x01, epl_sensor.als.integration_time | epl_sensor.als.gain);
+        }
+#endif
+
+        if(epl_sensor.mode == EPL_MODE_ALS_PS && epl_sensor.als.polling_mode == 0 && epl_sensor.ps.polling_mode == 0){
+            int wait = 0;
+            wait = epl_sensor_get_wait_time(ps_time, als_time);
+            epl_sensor_I2C_Write(epld->client, 0x00, wait | epl_sensor.mode);
+        }
+        else{
+#if PS_GES
+            if(enable_ges == 1 && enable_ps == 0)
+            {
+                set_psensor_intr_threshold(epl_sensor.ges.low_threshold, epl_sensor.ges.high_threshold);
+                epl_sensor_I2C_Write(client, 0x00, EPL_WAIT_2_MS | epl_sensor.mode);
+            }
+            else
+#endif
+                epl_sensor_I2C_Write(epld->client, 0x00, epl_sensor.wait | epl_sensor.mode);
+        }
+
+        //ALS unlock and run
+       	epl_sensor.als.compare_reset = EPL_CMP_RUN;
+    	epl_sensor.als.lock = EPL_UN_LOCK;
+    	epl_sensor_I2C_Write(epld->client, 0x12, epl_sensor.als.compare_reset | epl_sensor.als.lock);
+
+        //PS unlock and run
+        epl_sensor.ps.compare_reset = EPL_CMP_RUN;
+        epl_sensor.ps.lock = EPL_UN_LOCK;
+        epl_sensor_I2C_Write(epld->client, 0x1b, epl_sensor.ps.compare_reset |epl_sensor.ps.lock);
+
+        //epl_sensor_I2C_Write(epld->client, 0x11, epl_sensor.reset | epl_sensor.power);
+
+#if COMMON_DEBUG
+        //**** check setting ****
+        if(enable_ps == 1)
+        {
+            LOG_INFO("[%s] PS:low_thd = %d, high_thd = %d \n",__func__, epl_sensor.ps.low_threshold, epl_sensor.ps.high_threshold);
+        }
+
+        if(enable_als == 1 && epl_sensor.als.polling_mode == 0)
+        {
+            LOG_INFO("[%s] ALS:low_thd = %d, high_thd = %d \n",__func__, epl_sensor.als.low_threshold, epl_sensor.als.high_threshold);
+        }
+#if PS_GES
+        if(enable_ges)
+        {
+            LOG_INFO("[%s] GES:low_thd = %d, high_thd = %d \n",__func__, epl_sensor.ges.low_threshold, epl_sensor.ges.high_threshold);
+
+        }
+#endif
+
+    	LOG_INFO("[%s] reg0x00= 0x%x \n", __func__, epl_sensor.wait | epl_sensor.mode);
+    	LOG_INFO("[%s] reg0x07= 0x%x \n", __func__, epl_sensor.als.interrupt_channel_select | epl_sensor.als.persist | epl_sensor.als.interrupt_type);
+    	LOG_INFO("[%s] reg0x06= 0x%x \n", __func__, epl_sensor.interrupt_control | epl_sensor.ps.persist |epl_sensor.ps.interrupt_type);
+    	LOG_INFO("[%s] reg0x11= 0x%x \n", __func__, epl_sensor.power | epl_sensor.reset);
+    	LOG_INFO("[%s] reg0x12= 0x%x \n", __func__, epl_sensor.als.compare_reset | epl_sensor.als.lock);
+    	LOG_INFO("[%s] reg0x1b= 0x%x \n", __func__, epl_sensor.ps.compare_reset | epl_sensor.ps.lock);
+#endif
+
+        if(epl_sensor.mode == EPL_MODE_PS)
+        {
+            msleep(ps_time);
+            LOG_INFO("[%s] PS only(%dms)\r\n", __func__, ps_time);
+        }
+        else if (epl_sensor.mode == EPL_MODE_ALS)
+        {
+            msleep(als_time);
+            LOG_INFO("[%s] ALS only(%dms)\r\n", __func__, als_time);
+        }
+        else if (epl_sensor.mode == EPL_MODE_ALS_PS)
+        {
+            msleep(ps_time+als_time+wait_value[epl_sensor.wait>>4]);
+            LOG_INFO("[%s] PS+ALS(%dms)\r\n", __func__, ps_time+als_time+wait_value[epl_sensor.wait>>4]);
+        }
+
+        if(epl_sensor.ps.interrupt_flag == EPL_INT_TRIGGER)
+        {
+           //PS unlock and run
+            epl_sensor.ps.compare_reset = EPL_CMP_RUN;
+            epl_sensor.ps.lock = EPL_UN_LOCK;
+            epl_sensor_I2C_Write(epld->client, 0x1b, epl_sensor.ps.compare_reset |epl_sensor.ps.lock);
+        }
+
+        if(epl_sensor.als.interrupt_flag == EPL_INT_TRIGGER)
+        {
+            //ALS unlock and run
+           	epl_sensor.als.compare_reset = EPL_CMP_RUN;
+        	epl_sensor.als.lock = EPL_UN_LOCK;
+        	epl_sensor_I2C_Write(epld->client, 0x12, epl_sensor.als.compare_reset | epl_sensor.als.lock);
+        }
+
+#if PS_GES
+        if((enable_als==1 && epl_sensor.als.polling_mode==1) || (enable_ps==1 && epl_sensor.ps.polling_mode==1) || (enable_ges == 1 && epl_sensor.ges.polling_mode==1))
+#else
+        if((enable_als==1 && epl_sensor.als.polling_mode==1) || (enable_ps==1 && epl_sensor.ps.polling_mode==1))
+#endif
+        {
+            epl_sensor_restart_polling();
+        }
+
+#if PS_DYN_K
+        if(enable_ps == 1)
+        {
+            epl_sensor_restart_dynk_polling();
+        }
+#endif
+    }
+    polling_flag = true;
+
+}
+
+/*----------------------------------------------------------------------------*/
+static void epl_sensor_polling_work(struct work_struct *work)
+{
+
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    struct i2c_client *client = epld->client;
+
+    bool enable_ps = epld->enable_pflag==1 && epld->ps_suspend==0;
+    bool enable_als = epld->enable_lflag==1 && epld->als_suspend==0;
+#if HS_ENABLE
+    bool enable_hs = epld->enable_hflag==1 && epld->hs_suspend==0;
+
+#endif
+#if PS_GES
+     bool enable_ges = epld->enable_gflag==1 && epld->ges_suspend==0;
+#endif
+
+#if COMMON_DEBUG
+#if HS_ENABLE && PS_GES
+    LOG_INFO("enable_pflag=%d, enable_lflag=%d, enable_hs=%d, enable_ges=%d \n", enable_ps, enable_als, enable_hs, enable_ges);
+#elif HS_ENABLE
+    LOG_INFO("enable_pflag=%d, enable_lflag=%d, enable_hs=%d\n", enable_ps, enable_als, enable_hs);
+#elif PS_GES
+    LOG_INFO("enable_pflag=%d, enable_lflag=%d, enable_ges=%d\n", enable_ps, enable_als, enable_ges);
+#else
+    LOG_INFO("enable_pflag = %d, enable_lflag = %d \n", enable_ps, enable_als);
+#endif
+#endif
+
+#if PS_DYN_K && PS_DYN_K_STR
+    if(polling_flag == false && eint_flag == false && dynk_enhance_flag == false)
+#else
+    if(polling_flag == false && eint_flag == false)
+#endif
+    {
+#if PS_DYN_K && PS_DYN_K_STR
+        LOG_INFO("[%s]: epl_sensor_update_mode(%d) or eint_work(%d) is running, dynk_enhance_flag=%d !\r\n", __func__, polling_flag, eint_flag, dynk_enhance_flag);
+#else
+        LOG_INFO("[%s]: epl_sensor_update_mode(%d) or eint_work(%d) is running !\r\n", __func__, polling_flag, eint_flag);
+#endif
+        return;
+    }
+
+    cancel_delayed_work(&polling_work);
+
+    if( (enable_als &&  epl_sensor.als.polling_mode == 1) || (enable_ps &&  epl_sensor.ps.polling_mode == 1) )
+    {
+        queue_delayed_work(epld->epl_wq, &polling_work,msecs_to_jiffies(polling_time));
+    }
+
+#if HS_ENABLE
+    if (enable_hs)
+    {
+        queue_delayed_work(epld->epl_wq, &polling_work,msecs_to_jiffies(20));
+        epl_sensor_read_hs(client);
+    }
+#if PS_GES  /*PS_GES*/
+    else if (enable_ges && epl_sensor.ges.polling_mode==1)
+#endif /*PS_GES*/
+#endif
+
+#if PS_GES
+#if !HS_ENABLE /*HS_ENABLE*/
+    if (enable_ges && epl_sensor.ges.polling_mode==1)
+#endif  /*HS_ENABLE*/
+    {
+        queue_delayed_work(epld->epl_wq, &polling_work, msecs_to_jiffies(polling_time));
+        epl_sensor_read_ps(epld->client);
+        epl_sensor_read_ps_status(epld->client);
+    }
+#endif
+
+    if(enable_als &&  epl_sensor.als.polling_mode == 1)
+    {
+	    int report_lux = 0;
+#if PS_DYN_K && PS_DYN_K_STR
+        if(polling_flag == true && eint_flag == true && dynk_enhance_flag == true)
+#else
+	    if(polling_flag == true && eint_flag == true)
+#endif
+        {
+            mutex_lock(&sensor_mutex);
+            //epl_sensor_read_als_status(client);   // for test
+    	    epl_sensor_read_als(client);
+    	    mutex_unlock(&sensor_mutex);
+    	    report_lux = epl_sensor_get_als_value(epld, epl_sensor.als.data.channels[1]);
+    	    if(epl_sensor.als.report_type != CMC_BIT_DYN_INT){
+                epl_sensor_report_lux(report_lux);
+            }
+        }
+    }
+
+    if(enable_ps && epl_sensor.ps.polling_mode == 1)
+    {
+#if PS_DYN_K && PS_DYN_K_STR
+        if(polling_flag == true && eint_flag == true && dynk_enhance_flag == true)
+#else
+        if(polling_flag == true && eint_flag == true)
+#endif
+        {
+            mutex_lock(&sensor_mutex);
+            epl_sensor_read_ps_status(client);
+            epl_sensor_read_ps(client);
+            mutex_unlock(&sensor_mutex);
+#if PS_DYN_K
+            epl_sensor_reset_dynk_thd(dynk_last_status, (epl_sensor.ps.compare_low >> 3));
+            dynk_last_status = (epl_sensor.ps.compare_low >> 3);
+#endif
+            epl_sensor_report_ps_status();
+        }
+    }
+#if HS_ENABLE && PS_GES
+    if(enable_als==false && enable_ps==false && enable_hs==false && enable_ges==false)
+#elif HS_ENABLE
+    if(enable_als==false && enable_ps==false && enable_hs==false)
+#elif PS_GES
+    if(enable_als==false && enable_ps==false && enable_ges==false)
+#else
+    if(enable_als==false && enable_ps==false)
+#endif
+    {
+        cancel_delayed_work(&polling_work);
+        LOG_INFO("disable sensor\n");
+    }
+
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static irqreturn_t epl_sensor_eint_func(int irqNo, void *handle)
+{
+    struct epl_sensor_priv *epld = (struct epl_sensor_priv*)handle;
+    disable_irq_nosync(epld->irq);
+    //queue_work(epld->epl_wq, &epl_sensor_irq_work);
+    schedule_delayed_work(&epld->eint_work, 0);
+
+    return IRQ_HANDLED;
+}
+/*----------------------------------------------------------------------------*/
+static void epl_sensor_intr_als_report_lux(void)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+
+
+    int report_lux = 0;
+	epl_sensor_read_als(epld->client);
+
+	report_lux = epl_sensor_get_als_value(epld, epl_sensor.als.data.channels[1]);
+    epl_sensor_report_lux(report_lux);
+
+    epl_sensor.als.compare_reset = EPL_CMP_RESET;
+	epl_sensor.als.lock = EPL_UN_LOCK;
+	epl_sensor_I2C_Write(epld->client,0x12, epl_sensor.als.compare_reset | epl_sensor.als.lock);
+
+	//set dynamic threshold
+	if(epl_sensor.als.compare_high >> 4)
+	{
+		epl_sensor.als.high_threshold = epl_sensor.als.high_threshold + 250;
+		epl_sensor.als.low_threshold = epl_sensor.als.low_threshold + 250;
+
+		if (epl_sensor.als.high_threshold > 60000)
+		{
+			epl_sensor.als.high_threshold = epl_sensor.als.high_threshold -250;
+			epl_sensor.als.low_threshold = epl_sensor.als.low_threshold - 250;
+		}
+	}
+	if(epl_sensor.als.compare_low>> 3)
+	{
+		epl_sensor.als.high_threshold = epl_sensor.als.high_threshold -250;
+		epl_sensor.als.low_threshold = epl_sensor.als.low_threshold - 250;
+
+		if (epl_sensor.als.high_threshold < 250)
+		{
+			epl_sensor.als.high_threshold = epl_sensor.als.high_threshold + 250;
+			epl_sensor.als.low_threshold = epl_sensor.als.low_threshold + 250;
+		}
+	}
+
+	if(epl_sensor.als.high_threshold < epl_sensor.als.low_threshold)
+	{
+	    LOG_INFO("[%s]:recover default setting \r\n", __FUNCTION__);
+	    epl_sensor.als.high_threshold = ALS_HIGH_THRESHOLD;
+	    epl_sensor.als.low_threshold = ALS_LOW_THRESHOLD;
+	}
+
+	//write new threshold
+	set_lsensor_intr_threshold(epl_sensor.als.low_threshold, epl_sensor.als.high_threshold);
+}
+/*----------------------------------------------------------------------------*/
+static void epl_sensor_eint_work(struct work_struct *work)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    LOG_FUN();
+
+    bool enable_ps = epld->enable_pflag==1 && epld->ps_suspend==0;
+    bool enable_als = epld->enable_lflag==1 && epld->als_suspend==0;
+#if PS_GES
+    bool enable_ges = epld->enable_gflag==1 && epld->ges_suspend==0;
+#endif
+    eint_flag = false;
+    mutex_lock(&sensor_mutex);
+
+#if PS_GES
+    if(enable_ges && epl_sensor.ges.polling_mode == 0)
+    {
+        epl_sensor_read_ps_status(epld->client);
+        if(polling_flag == true)
+        {
+		//GES unlock and run
+    		epl_sensor.ges.compare_reset = EPL_CMP_RUN;
+    		epl_sensor.ges.lock = EPL_UN_LOCK;
+    		epl_sensor_I2C_Write(epld->client,0x1b, epl_sensor.ges.compare_reset | epl_sensor.ges.lock);
+	}
+    }
+#endif
+    if(enable_ps && epl_sensor.ps.polling_mode == 0)
+    {
+	epl_sensor_read_ps_status(epld->client);
+	if(epl_sensor.ps.interrupt_flag == EPL_INT_TRIGGER)
+	{
+#if PS_DEBUG || PS_DYN_K
+		epl_sensor_read_ps(epld->client);
+#endif
+
+#if PS_DYN_K
+		epl_sensor_reset_dynk_thd(dynk_last_status, (epl_sensor.ps.compare_low >> 3));
+		dynk_last_status = (epl_sensor.ps.compare_low >> 3);
+#endif
+		epl_sensor_report_ps_status();
+
+		if(polling_flag == true)
+		{
+			 //PS unlock and run
+			epl_sensor.ps.compare_reset = EPL_CMP_RUN;
+			epl_sensor.ps.lock = EPL_UN_LOCK;
+			epl_sensor_I2C_Write(epld->client,0x1b, epl_sensor.ps.compare_reset |epl_sensor.ps.lock);
+		}
+
+	}
+    }
+    if(enable_als && epl_sensor.als.polling_mode == 0)
+    {
+	epl_sensor_read_als_status(epld->client);
+	if(epl_sensor.als.interrupt_flag == EPL_INT_TRIGGER)
+	{
+		epl_sensor_intr_als_report_lux();
+		if(polling_flag == true)
+		{
+			//ALS unlock and run
+			epl_sensor.als.compare_reset = EPL_CMP_RUN;
+        		epl_sensor.als.lock = EPL_UN_LOCK;
+        		epl_sensor_I2C_Write(epld->client,0x12, epl_sensor.als.compare_reset | epl_sensor.als.lock);
+		}
+	}
+    }
+
+    //enable_irq(epld->irq);
+    mutex_unlock(&sensor_mutex);
+    eint_flag = true;
+    enable_irq(epld->irq);
+}
+/*----------------------------------------------------------------------------*/
+static int epl_sensor_setup_interrupt(struct epl_sensor_priv *epld)
+{
+    struct i2c_client *client = epld->client;
+    int err = 0;
+#if QCOM
+    unsigned int irq_gpio;
+    unsigned int irq_gpio_flags;
+    struct device_node *np = client->dev.of_node;
+#endif
+    msleep(5);
+#if S5PV210
+    err = gpio_request(S5PV210_GPH0(1), "Elan EPL IRQ");
+    if (err)
+    {
+        LOG_ERR("gpio pin request fail (%d)\n", err);
+        goto initial_fail;
+    }
+    else
+    {
+        LOG_INFO("----- Samsung gpio config success -----\n");
+        s3c_gpio_cfgpin(S5PV210_GPH0(1),S3C_GPIO_SFN(0x0F)/*(S5PV210_GPH0_1_EXT_INT30_1) */);
+        s3c_gpio_setpull(S5PV210_GPH0(1),S3C_GPIO_PULL_UP);
+
+    }
+#elif SPREAD
+    //epld->intr_pin = ELAN_INT_PIN; /*need setting*/
+    err = gpio_request(epld->intr_pin, "Elan EPL IRQ");
+    if (err)
+    {
+	LOG_ERR("gpio pin request fail (%d)\n", err);
+	goto initial_fail;
+    }else{
+	gpio_direction_input(epld->intr_pin);
+	/*get irq*/
+	client->irq = gpio_to_irq(epld->intr_pin);
+	epld->irq = client->irq;
+	LOG_INFO("IRQ number is %d\n", client->irq);
+    }
+#elif QCOM
+    irq_gpio = of_get_named_gpio_flags(np, "epl,irq-gpio", 0, &irq_gpio_flags);
+    //irq_gpio = ELAN_INT_PIN;
+    epld->intr_pin = irq_gpio;
+    if (epld->intr_pin < 0) {
+        goto initial_fail;
+    }
+
+    if (gpio_is_valid(epld->intr_pin)) {
+		err = gpio_request(epld->intr_pin, "epl_irq_gpio");
+		if (err) {
+			LOG_ERR( "irq gpio request failed");
+			goto initial_fail;
+		}
+
+		err = gpio_direction_input(epld->intr_pin);
+		if (err) {
+			LOG_ERR("set_direction for irq gpio failed\n");
+			goto initial_fail;
+		}
+    }
+#elif LEADCORE
+    //epld->intr_pin = ELAN_INT_PIN; /*need setting*/
+    epld->intr_pin = irq_to_gpio(client->irq); /*need confirm*/
+
+    err = gpio_request(epld->intr_pin, "epl irq"); /*ep12182 irq*/
+    //err = gpio_request(epld->intr_pin, "ep12182 irq");
+    if (err < 0){
+	LOG_ERR("%s:Gpio request failed! \r\n", __func__);
+	goto initial_fail;
+    }
+    gpio_direction_input(epld->intr_pin);
+    client->irq = gpio_to_irq(epld->intr_pin);
+#elif MARVELL
+
+   epld->intr_pin = ELAN_INT_PIN; /*need setting*/
+   if(client->irq <= 0)
+   {
+        LOG_ERR("client->irq(%d) Failed \r\n", client->irq);
+        goto initial_fail;
+   }
+#endif
+    err = request_irq(epld->irq,epl_sensor_eint_func, IRQF_TRIGGER_FALLING,
+                      "epl2182_pls", epld);
+    if(err <0)
+    {
+        LOG_ERR("request irq pin %d fail for gpio\n",err);
+        goto fail_free_intr_pin;
+    }
+
+    return err;
+
+initial_fail:
+fail_free_intr_pin:
+    gpio_free(epld->intr_pin);
+    //free_irq(epld->irq, epld);
+    return err;
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+
+static ssize_t epl_sensor_show_reg(struct device *dev, struct device_attribute *attr, char *buf)
+{
+
+    ssize_t len = 0;
+    struct i2c_client *client = epl_sensor_obj->client;
+
+    if(!epl_sensor_obj)
+    {
+        LOG_ERR("epl_obj is null!!\n");
+        return 0;
+    }
+
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x00 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x00));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x01 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x01));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x02 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x02));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x03 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x03));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x04 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x04));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x05 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x05));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x06 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x06));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x07 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x07));
+    if(epl_sensor.als.polling_mode == 0)
+    {
+        len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x08 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x08));
+        len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x09 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x09));
+        len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x0A value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x0A));
+        len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x0B value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x0B));
+    }
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x0C value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x0C));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x0D value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x0D));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x0E value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x0E));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x0F value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x0F));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x11 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x11));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x12 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x12));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x1B value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x1B));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x22 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x22));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x23 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x23));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x24 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x24));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0x25 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x25));
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip id REG 0xFC value = 0x%x\n", i2c_smbus_read_byte_data(client, 0xFC));
+
+    return len;
+
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_show_status(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    ssize_t len = 0;
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    bool enable_ps = epld->enable_pflag==1 && epld->ps_suspend==0;
+    bool enable_als = epld->enable_lflag==1 && epld->als_suspend==0;
+#if HS_ENABLE
+	bool enable_hs = epld->enable_hflag==1 && epld->hs_suspend==0;
+#endif
+
+    if(!epl_sensor_obj)
+    {
+        LOG_ERR("epl_sensor_obj is null!!\n");
+        return 0;
+    }
+
+    len += snprintf(buf+len, PAGE_SIZE-len, "chip is %s, ver is %s \n", EPL_DEV_NAME, DRIVER_VERSION);
+    len += snprintf(buf+len, PAGE_SIZE-len, "als/ps polling is %d-%d\n", epl_sensor.als.polling_mode, epl_sensor.ps.polling_mode);
+    len += snprintf(buf+len, PAGE_SIZE-len, "wait = %d, mode = %d\n",epl_sensor.wait >> 4, epl_sensor.mode);
+    len += snprintf(buf+len, PAGE_SIZE-len, "interrupt control = %d\n", epl_sensor.interrupt_control >> 4);
+    len += snprintf(buf+len, PAGE_SIZE-len, "frame time ps=%dms, als=%dms\n", ps_frame_time, als_frame_time);
+#if HS_ENABLE
+    if(enable_hs)
+    {
+        len += snprintf(buf+len, PAGE_SIZE-len, "hs adc= %d\n", epl_sensor.hs.adc>>3);
+        len += snprintf(buf+len, PAGE_SIZE-len, "hs int_time= %d\n", epl_sensor.hs.integration_time>>2);
+        len += snprintf(buf+len, PAGE_SIZE-len, "hs cycle= %d\n", epl_sensor.hs.cycle);
+        len += snprintf(buf+len, PAGE_SIZE-len, "hs gain= %d\n", epl_sensor.hs.gain);
+        len += snprintf(buf+len, PAGE_SIZE-len, "hs ch1 raw= %d\n", epl_sensor.hs.raw);
+    }
+#endif
+    if(enable_ps)
+    {
+        len += snprintf(buf+len, PAGE_SIZE-len, "PS: \n");
+        len += snprintf(buf+len, PAGE_SIZE-len, "INTEG = %d, gain = %d\n", epl_sensor.ps.integration_time >> 2, epl_sensor.ps.gain);
+        len += snprintf(buf+len, PAGE_SIZE-len, "ADC = %d, cycle = %d, ir drive = %d\n", epl_sensor.ps.adc >> 3, epl_sensor.ps.cycle, epl_sensor.ps.ir_drive);
+        len += snprintf(buf+len, PAGE_SIZE-len, "saturation = %d, int flag = %d\n", epl_sensor.ps.saturation >> 5, epl_sensor.ps.interrupt_flag >> 2);
+        len += snprintf(buf+len, PAGE_SIZE-len, "Thr(L/H) = (%d/%d)\n", epl_sensor.ps.low_threshold, epl_sensor.ps.high_threshold);
+#if PS_DYN_K
+#if PS_DYN_K_STR
+        len += snprintf(buf+len, PAGE_SIZE-len, "Dyn enhance ch0 = %d \n", dynk_enhance_ch0);
+#endif
+        len += snprintf(buf+len, PAGE_SIZE-len, "Dyn thr(L/H) = (%ld/%ld)\n", (long)dynk_thd_low, (long)dynk_thd_high);
+#endif
+        len += snprintf(buf+len, PAGE_SIZE-len, "pals data = %d, data = %d\n", epl_sensor.ps.data.ir_data, epl_sensor.ps.data.data);
+    }
+    if(enable_als)
+    {
+        len += snprintf(buf+len, PAGE_SIZE-len, "ALS: \n");
+        len += snprintf(buf+len, PAGE_SIZE-len, "INTEG = %d, gain = %d\n", epl_sensor.als.integration_time >> 2, epl_sensor.als.gain);
+        len += snprintf(buf+len, PAGE_SIZE-len, "ADC = %d, cycle = %d\n", epl_sensor.als.adc >> 3, epl_sensor.als.cycle);
+#if ALS_DYN_INTT
+        if(epl_sensor.als.lsrc_type != CMC_BIT_LSRC_NON)
+        {
+            len += snprintf(buf+len, PAGE_SIZE-len, "lsource_thd_low=%d, lsource_thd_high=%d \n", epld->lsource_thd_low, epld->lsource_thd_high);
+            len += snprintf(buf+len, PAGE_SIZE-len, "saturation = %d\n", epl_sensor.als.saturation >> 5);
+
+            if(epl_sensor.als.lsrc_type == CMC_BIT_LSRC_SCALE || epl_sensor.als.lsrc_type == CMC_BIT_LSRC_BOTH)
+            {
+                len += snprintf(buf+len, PAGE_SIZE-len, "real_ratio = %d\n", epld->ratio);
+                len += snprintf(buf+len, PAGE_SIZE-len, "use_ratio = %d\n", epld->last_ratio);
+            }
+            else if(epl_sensor.als.lsrc_type == CMC_BIT_LSRC_SLOPE)
+            {
+                len += snprintf(buf+len, PAGE_SIZE-len, "ratio = %d\n", epld->ratio);
+            }
+        }
+
+        len += snprintf(buf+len, PAGE_SIZE-len, "c_gain = %d\n", c_gain);
+        len += snprintf(buf+len, PAGE_SIZE-len, "dynamic_intt_lux = %d\n", dynamic_intt_lux);
+#endif
+        if(epl_sensor.als.polling_mode == 0)
+            len += snprintf(buf+len, PAGE_SIZE-len, "Thr(L/H) = (%d/%d)\n", epl_sensor.als.low_threshold, epl_sensor.als.high_threshold);
+        len += snprintf(buf+len, PAGE_SIZE-len, "ch0 = %d, ch1 = %d\n", epl_sensor.als.data.channels[0], epl_sensor.als.data.channels[1]);
+    }
+
+    return len;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_als_enable(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    uint16_t mode=0;
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    LOG_FUN();
+
+
+    sscanf(buf, "%hu",&mode);
+    if(epld->enable_lflag != mode)
+    {
+#if ALS_DYN_INTT
+        if(epl_sensor.als.report_type == CMC_BIT_DYN_INT)
+        {
+            dynamic_intt_idx = dynamic_intt_init_idx;
+            epl_sensor.als.integration_time = als_dynamic_intt_intt[dynamic_intt_idx];
+            epl_sensor.als.gain = als_dynamic_intt_gain[dynamic_intt_idx];
+            dynamic_intt_high_thr = als_dynamic_intt_high_thr[dynamic_intt_idx];
+            dynamic_intt_low_thr = als_dynamic_intt_low_thr[dynamic_intt_idx];
+        }
+#endif
+        epld->enable_lflag = mode;
+
+        epl_sensor_update_mode(epld->client);
+    }
+
+    return count;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_ps_enable(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    uint16_t mode=0;
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+#if HS_ENABLE
+    bool enable_hs = epld->enable_hflag==1 && epld->hs_suspend==0;
+#endif
+#if PS_GES
+    bool enable_ges = epld->enable_gflag==1 && epld->ges_suspend==0;
+#endif
+    LOG_FUN();
+
+    sscanf(buf, "%hu",&mode);
+#if HS_ENABLE
+    if(enable_hs == 1 && mode == 1)
+    {
+        epld->enable_hflag = 0;
+        if(hs_enable_flag == true)
+        {
+            epld->enable_lflag = 1;
+            hs_enable_flag = false;
+        }
+        write_global_variable(epld->client);
+        LOG_INFO("[%s] Disable HS and recover ps setting \r\n", __func__);
+    }
+#endif
+#if PS_GES
+    if(enable_ges == 1 && mode == 1)
+    {
+        epld->enable_gflag = 0;
+        write_global_variable(epld->client);
+        ps_ges_enable_flag = true;
+        LOG_INFO("[%s] Disable GES and recover ps setting \r\n", __func__);
+    }
+    else if (ps_ges_enable_flag == true && mode == 0)
+    {
+        epld->enable_gflag = 1;
+        write_global_variable(epld->client);
+        ps_ges_enable_flag = false;
+        LOG_INFO("[%s] enable GES and recover ges setting \r\n", __func__);
+    }
+#endif
+    if(epld->enable_pflag != mode)
+    {
+        epld->enable_pflag = mode;
+        if(mode)
+        {
+            wake_lock(&ps_lock);
+#if PS_DYN_K
+            dynk_min_ps_raw_data = 0xffff;
+            dynk_change_flag = false;
+#if PS_DYN_K_STR
+            dynk_enhance_flag = false;
+#endif
+#endif
+        }
+        else
+        {
+#if PS_DYN_K
+            cancel_delayed_work(&dynk_thd_polling_work);
+#endif
+            wake_unlock(&ps_lock);
+        }
+
+        epl_sensor_update_mode(epld->client);
+    }
+
+    return count;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_show_cal_raw(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    u16 ch1 = 0;
+    u32 ch1_all=0;
+    int count =5;
+    int i;
+    ssize_t len = 0;
+#if !PS_DYN_K
+    bool enable_ps = epld->enable_pflag==1 && epld->ps_suspend==0;
+#endif
+
+    if(!epl_sensor_obj)
+    {
+        LOG_ERR("epl_sensor_obj is null!!\n");
+        return 0;
+    }
+
+
+
+    for(i=0; i<count; i++)
+    {
+    	switch(epl_sensor.mode)
+    	{
+    	    msleep(50);
+#if PS_DYN_K_STR
+            case EPL_MODE_ALS_PS:
+#else
+    		case EPL_MODE_PS:
+#endif
+#if !PS_DYN_K
+                if(enable_ps == true && polling_flag == true && eint_flag == true && epl_sensor.ps.polling_mode == 0)
+                    epl_sensor_read_ps(epld->client);
+#endif
+    			ch1 = epl_sensor.ps.data.data;
+		    break;
+
+    		case EPL_MODE_ALS:
+    		    if(epl_sensor.als.polling_mode == 0)
+    		 	    epl_sensor_read_als(epld->client);
+    			ch1 = epl_sensor.als.data.channels[1];
+		    break;
+    	}
+
+    	ch1_all = ch1_all + ch1;
+    	if(epl_sensor.wait == EPL_WAIT_SINGLE)
+    		epl_sensor_I2C_Write(epld->client,0x11,  epl_sensor.power | epl_sensor.reset);
+    }
+
+    ch1 = (u16)(ch1_all/count);
+
+    LOG_INFO("cal_raw = %d \r\n" , ch1);
+
+    len += snprintf(buf + len, PAGE_SIZE - len, "%d \r\n", ch1);
+
+    return  len;
+}
+
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_threshold(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+    int hthr = 0, lthr = 0;
+	if(!epld)
+	{
+	    LOG_ERR("epl_sensor_obj is null!!\n");
+	    return 0;
+	}
+
+	switch(epl_sensor.mode)
+	{
+#if PS_DYN_K_STR
+            case EPL_MODE_ALS_PS:
+#else
+		case EPL_MODE_PS:
+#endif
+			sscanf(buf, "%d,%d", &lthr, &hthr);
+			epl_sensor.ps.low_threshold = lthr;
+			epl_sensor.ps.high_threshold = hthr;
+			set_psensor_intr_threshold(epl_sensor.ps.low_threshold, epl_sensor.ps.high_threshold);
+		break;
+
+		case EPL_MODE_ALS:
+			sscanf(buf, "%d,%d", &lthr, &hthr);
+			epl_sensor.als.low_threshold = lthr;
+			epl_sensor.als.high_threshold = hthr;
+			set_lsensor_intr_threshold(epl_sensor.als.low_threshold, epl_sensor.als.high_threshold);
+		break;
+
+	}
+	return count;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_wait_time(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    int val;
+    sscanf(buf, "%d",&val);
+
+    epl_sensor.wait = (val & 0xf) << 4;
+
+    return count;
+}
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_gain(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+	int value = 0;
+    LOG_FUN();
+
+    sscanf(buf, "%d", &value);
+
+    value = value & 0x03;
+
+	switch (epl_sensor.mode)
+	{
+#if PS_DYN_K_STR
+       case EPL_MODE_ALS_PS:
+#else
+		case EPL_MODE_PS: //ps
+#endif
+            epl_sensor.ps.gain = value;
+	        epl_sensor_I2C_Write(epld->client, 0x03, epl_sensor.ps.integration_time | epl_sensor.ps.gain);
+		break;
+
+        case EPL_MODE_ALS: //als
+            epl_sensor.als.gain = value;
+	        epl_sensor_I2C_Write(epld->client, 0x01, epl_sensor.als.integration_time | epl_sensor.als.gain);
+		break;
+    }
+
+	epl_sensor_update_mode(epld->client);
+
+	return count;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+	int value=0;
+
+	LOG_FUN();
+
+    epld->enable_pflag = 0;
+    epld->enable_lflag = 0;
+
+	sscanf(buf, "%d",&value);
+
+	switch (value)
+	{
+		case 0:
+			epl_sensor.mode = EPL_MODE_IDLE;
+		break;
+
+		case 1:
+            epld->enable_lflag = 1;
+			epl_sensor.mode = EPL_MODE_ALS;
+		break;
+
+		case 2:
+            epld->enable_pflag = 1;
+			epl_sensor.mode = EPL_MODE_PS;
+		break;
+
+		case 3:
+		    epld->enable_lflag = 1;
+            epld->enable_pflag = 1;
+			epl_sensor.mode = EPL_MODE_ALS_PS;
+		break;
+	}
+
+       epl_sensor_update_mode(epld->client);
+
+	return count;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_ir_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	int value=0;
+
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+
+	LOG_FUN();
+
+	sscanf(buf, "%d", &value);
+
+	switch (epl_sensor.mode)
+	{
+#if PS_DYN_K_STR
+        case EPL_MODE_ALS_PS:
+#else
+		case EPL_MODE_PS: //ps
+#endif
+		switch(value)
+			{
+				case 0:
+			    		epl_sensor.ps.ir_mode = EPL_IR_MODE_CURRENT;
+				break;
+
+				case 1:
+			    		epl_sensor.ps.ir_mode = EPL_IR_MODE_VOLTAGE;
+				break;
+			}
+
+			epl_sensor_I2C_Write(epld->client,0x05, epl_sensor.ps.ir_on_control | epl_sensor.ps.ir_mode | epl_sensor.ps.ir_drive);
+		break;
+	}
+
+	epl_sensor_I2C_Write(epld->client,0x00,epl_sensor.wait | epl_sensor.mode);
+
+	return count;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_ir_contrl(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	int value=0;
+	uint8_t  data;
+
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+
+	LOG_FUN();
+
+	sscanf(buf, "%d",&value);
+
+	switch (epl_sensor.mode)
+	{
+#if PS_DYN_K_STR
+       case EPL_MODE_ALS_PS:
+#else
+		case EPL_MODE_PS: //ps
+#endif
+			switch(value)
+			{
+				case 0:
+			    		epl_sensor.ps.ir_on_control = EPL_IR_ON_CTRL_OFF;
+				break;
+
+				case 1:
+			    		epl_sensor.ps.ir_on_control = EPL_IR_ON_CTRL_ON;
+				break;
+			}
+
+			data = epl_sensor.ps.ir_on_control | epl_sensor.ps.ir_mode | epl_sensor.ps.ir_drive;
+			LOG_INFO("[%s]: 0x05 = 0x%x\n", __FUNCTION__, data);
+
+			epl_sensor_I2C_Write(epld->client,0x05, epl_sensor.ps.ir_on_control | epl_sensor.ps.ir_mode | epl_sensor.ps.ir_drive);
+		break;
+	}
+
+	epl_sensor_I2C_Write(epld->client,0x00,epl_sensor.wait | epl_sensor.mode);
+
+	return count;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_ir_drive(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	int value=0;
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+
+	LOG_FUN();
+
+	sscanf(buf, "%d", &value);
+
+	switch(epl_sensor.mode)
+	{
+#if PS_DYN_K_STR
+        case EPL_MODE_ALS_PS:
+#else
+		case EPL_MODE_PS:
+#endif
+			epl_sensor.ps.ir_drive = (value & 0x03);
+			epl_sensor_I2C_Write(epld->client,0x05, epl_sensor.ps.ir_on_control | epl_sensor.ps.ir_mode | epl_sensor.ps.ir_drive);
+		break;
+	}
+
+	epl_sensor_I2C_Write(epld->client,0x00,epl_sensor.wait | epl_sensor.mode);
+
+	return count;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_interrupt_type(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	int value=0;
+
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+
+	LOG_FUN();
+
+	sscanf(buf, "%d",&value);
+
+	switch (epl_sensor.mode)
+	{
+#if PS_DYN_K_STR
+        case EPL_MODE_ALS_PS:
+#else
+		case EPL_MODE_PS: //ps
+#endif
+			if(!epl_sensor.ps.polling_mode)
+			{
+		    	epl_sensor.ps.interrupt_type = value & 0x03;
+				epl_sensor_I2C_Write(epld->client,0x06, epl_sensor.interrupt_control | epl_sensor.ps.persist |epl_sensor.ps.interrupt_type);
+				LOG_INFO("[%s]: 0x06 = 0x%x\n", __FUNCTION__, epl_sensor.interrupt_control | epl_sensor.ps.persist |epl_sensor.ps.interrupt_type);
+			}
+		break;
+
+		case EPL_MODE_ALS: //als
+			if(!epl_sensor.als.polling_mode)
+			{
+		    	epl_sensor.als.interrupt_type = value & 0x03;
+				epl_sensor_I2C_Write(epld->client,0x07, epl_sensor.als.interrupt_channel_select | epl_sensor.als.persist | epl_sensor.als.interrupt_type);
+				LOG_INFO("[%s]: 0x07 = 0x%x\n", __FUNCTION__, epl_sensor.als.interrupt_channel_select | epl_sensor.als.persist | epl_sensor.als.interrupt_type);
+			}
+		break;
+	}
+
+	return count;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static ssize_t epl_sensor_store_ps_polling_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    int polling_mode = 0;
+
+
+    sscanf(buf, "%d",&polling_mode);
+    epl_sensor.ps.polling_mode = polling_mode;
+#if PS_GES
+    epl_sensor.ges.polling_mode = polling_mode;
+#endif
+
+    epl_sensor_update_mode(epld->client);
+
+    return count;
+}
+
+static ssize_t epl_sensor_store_als_polling_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    int polling_mode = 0;
+
+    sscanf(buf, "%d",&polling_mode);
+    epl_sensor.als.polling_mode = polling_mode;
+
+    epl_sensor_update_mode(epld->client);
+
+    return count;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_integration(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	int value=0;
+
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+
+	LOG_FUN();
+
+	sscanf(buf, "%d",&value);
+
+	switch (epl_sensor.mode)
+	{
+#if PS_DYN_K_STR
+        case EPL_MODE_ALS_PS:
+#else
+		case EPL_MODE_PS: //ps
+#endif
+			epl_sensor.ps.integration_time = (value & 0xf) << 2;
+			epl_sensor_I2C_Write(epld->client,0x03, epl_sensor.ps.integration_time | epl_sensor.ps.gain);
+			epl_sensor_I2C_Read(epld->client, 0x03, 1);
+			LOG_INFO("[%s]: 0x03 = 0x%x (0x%x)\n", __FUNCTION__, epl_sensor.ps.integration_time | epl_sensor.ps.gain, gRawData.raw_bytes[0]);
+		break;
+
+		case EPL_MODE_ALS: //als
+			epl_sensor.als.integration_time = (value & 0xf) << 2;
+			epl_sensor_I2C_Write(epld->client,0x01, epl_sensor.als.integration_time | epl_sensor.als.gain);
+			epl_sensor_I2C_Read(epld->client, 0x01, 1);
+			LOG_INFO("[%s]: 0x01 = 0x%x (0x%x)\n", __FUNCTION__, epl_sensor.als.integration_time | epl_sensor.als.gain, gRawData.raw_bytes[0]);
+		break;
+	}
+
+	epl_sensor_update_mode(epld->client);
+	return count;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_adc(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	int value=0;
+
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+
+	LOG_FUN();
+
+	sscanf(buf, "%d",&value);
+
+	switch (epl_sensor.mode)
+	{
+#if PS_DYN_K_STR
+        case EPL_MODE_ALS_PS:
+#else
+		case EPL_MODE_PS: //ps
+#endif
+			epl_sensor.ps.adc = (value & 0x3) << 3;
+			epl_sensor_I2C_Write(epld->client,0x04, epl_sensor.ps.adc | epl_sensor.ps.cycle);
+			epl_sensor_I2C_Read(epld->client, 0x04, 1);
+			LOG_INFO("[%s]:0x04 = 0x%x (0x%x)\n", __FUNCTION__, epl_sensor.ps.adc | epl_sensor.ps.cycle, gRawData.raw_bytes[0]);
+		break;
+
+		case EPL_MODE_ALS: //als
+			epl_sensor.als.adc = (value & 0x3) << 3;
+			epl_sensor_I2C_Write(epld->client,0x02, epl_sensor.als.adc | epl_sensor.als.cycle);
+			epl_sensor_I2C_Read(epld->client, 0x02, 1);
+			LOG_INFO("[%s]:0x02 = 0x%x (0x%x)\n", __FUNCTION__, epl_sensor.als.adc | epl_sensor.als.cycle, gRawData.raw_bytes[0]);
+		break;
+	}
+
+	epl_sensor_update_mode(epld->client);
+	return count;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_cycle(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	int value=0;
+
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+
+	LOG_FUN();
+
+	sscanf(buf, "%d",&value);
+
+	switch (epl_sensor.mode)
+	{
+#if PS_DYN_K_STR
+        case EPL_MODE_ALS_PS:
+#else
+		case EPL_MODE_PS: //ps
+#endif
+			epl_sensor.ps.cycle = (value & 0x7);
+			epl_sensor_I2C_Write(epld->client,0x04, epl_sensor.ps.adc | epl_sensor.ps.cycle);
+			LOG_INFO("[%s]:0x04 = 0x%x (0x%x)\n", __FUNCTION__, epl_sensor.ps.adc | epl_sensor.ps.cycle, gRawData.raw_bytes[0]);
+		break;
+
+		case EPL_MODE_ALS: //als
+			epl_sensor.als.cycle = (value & 0x7);
+			epl_sensor_I2C_Write(epld->client,0x02, epl_sensor.als.adc | epl_sensor.als.cycle);
+			LOG_INFO("[%s]:0x02 = 0x%x (0x%x)\n", __FUNCTION__, epl_sensor.als.adc | epl_sensor.als.cycle, gRawData.raw_bytes[0]);
+		break;
+	}
+
+	epl_sensor_update_mode(epld->client);
+	return count;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_als_report_type(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	int value=0;
+
+	LOG_FUN();
+
+	sscanf(buf, "%d", &value);
+	epl_sensor.als.report_type = value & 0xf;
+
+	return count;
+}
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_store_ps_w_calfile(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+    int ps_hthr=0, ps_lthr=0, ps_cancelation=0;
+    int ps_cal_len = 0;
+    char ps_calibration[20];
+	LOG_FUN();
+
+	if(!epl_sensor_obj)
+    {
+        LOG_ERR("epl_obj is null!!\n");
+        return 0;
+    }
+    sscanf(buf, "%d,%d,%d",&ps_cancelation, &ps_hthr, &ps_lthr);
+
+    ps_cal_len = sprintf(ps_calibration, "%d,%d,%d",  ps_cancelation, ps_hthr, ps_lthr);
+
+    write_factory_calibration(epld, ps_calibration, ps_cal_len);
+	return count;
+}
+/*----------------------------------------------------------------------------*/
+
+static ssize_t epl_sensor_store_reg_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    int reg;
+    int data;
+    LOG_FUN();
+
+    sscanf(buf, "%x,%x",&reg, &data);
+
+    LOG_INFO("[%s]: reg=0x%x, data=0x%x", __func__, reg, data);
+    epl_sensor_I2C_Write(epld->client, reg, data);
+
+    return count;
+}
+
+static ssize_t epl_sensor_store_unlock(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+    int mode;
+    LOG_FUN();
+
+    sscanf(buf, "%d",&mode);
+
+    LOG_INFO("mode = %d \r\n", mode);
+	switch (mode)
+	{
+		case 0: //ps
+			//PS unlock and run
+        	epl_sensor.ps.compare_reset = EPL_CMP_RUN;
+        	epl_sensor.ps.lock = EPL_UN_LOCK;
+        	epl_sensor_I2C_Write(epld->client,0x1b, epl_sensor.ps.compare_reset |epl_sensor.ps.lock);
+		break;
+
+		case 1: //als
+			//ALS unlock and run
+        	epl_sensor.als.compare_reset = EPL_CMP_RUN;
+        	epl_sensor.als.lock = EPL_UN_LOCK;
+        	epl_sensor_I2C_Write(epld->client,0x12, epl_sensor.als.compare_reset | epl_sensor.als.lock);
+		break;
+
+        case 2: //als unlock and reset
+    		epl_sensor.als.compare_reset = EPL_CMP_RESET;
+        	epl_sensor.als.lock = EPL_UN_LOCK;
+        	epl_sensor_I2C_Write(epld->client,0x12, epl_sensor.als.compare_reset | epl_sensor.als.lock);
+        break;
+
+		case 3: //ps+als
+		    //PS unlock and run
+        	epl_sensor.ps.compare_reset = EPL_CMP_RUN;
+        	epl_sensor.ps.lock = EPL_UN_LOCK;
+        	epl_sensor_I2C_Write(epld->client,0x1b, epl_sensor.ps.compare_reset |epl_sensor.ps.lock);
+
+			//ALS unlock and run
+        	epl_sensor.als.compare_reset = EPL_CMP_RUN;
+        	epl_sensor.als.lock = EPL_UN_LOCK;
+        	epl_sensor_I2C_Write(epld->client,0x12, epl_sensor.als.compare_reset | epl_sensor.als.lock);
+		break;
+	}
+    /*double check PS or ALS lock*/
+
+
+	return count;
+}
+
+static ssize_t epl_sensor_store_als_ch_sel(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+    int ch_sel;
+    LOG_FUN();
+
+    sscanf(buf, "%d",&ch_sel);
+
+    LOG_INFO("channel selection = %d \r\n", ch_sel);
+	switch (ch_sel)
+	{
+		case 0: //ch0
+		    epl_sensor.als.interrupt_channel_select = EPL_ALS_INT_CHSEL_0;
+		break;
+
+		case 1: //ch1
+        	epl_sensor.als.interrupt_channel_select = EPL_ALS_INT_CHSEL_1;
+		break;
+	}
+    epl_sensor_I2C_Write(epld->client,0x07, epl_sensor.als.interrupt_channel_select | epl_sensor.als.persist | epl_sensor.als.interrupt_type);
+
+    epl_sensor_update_mode(epld->client);
+
+	return count;
+}
+
+static ssize_t epl_sensor_store_ps_cancelation(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+    int cancelation;
+    LOG_FUN();
+
+    sscanf(buf, "%d",&cancelation);
+
+    epl_sensor.ps.cancelation = cancelation;
+
+    LOG_INFO("epl_sensor.ps.cancelation = %d \r\n", epl_sensor.ps.cancelation);
+
+    epl_sensor_I2C_Write(epld->client,0x22, (u8)(epl_sensor.ps.cancelation& 0xff));
+    epl_sensor_I2C_Write(epld->client,0x23, (u8)((epl_sensor.ps.cancelation & 0xff00) >> 8));
+
+	return count;
+}
+
+static ssize_t epl_sensor_show_ps_polling(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    u16 *tmp = (u16*)buf;
+    tmp[0]= epl_sensor.ps.polling_mode;
+    return 2;
+}
+
+static ssize_t epl_sensor_show_als_polling(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    u16 *tmp = (u16*)buf;
+    tmp[0]= epl_sensor.als.polling_mode;
+    return 2;
+}
+
+static ssize_t epl_sensor_show_ps_run_cali(struct device *dev, struct device_attribute *attr, char *buf)
+{
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+	ssize_t len = 0;
+    int ret;
+
+    LOG_FUN();
+
+    ret = epl_run_ps_calibration(epld);
+
+    len += snprintf(buf+len, PAGE_SIZE-len, "ret = %d\r\n", ret);
+
+	return len;
+}
+
+static ssize_t epl_sensor_show_pdata(struct device *dev, struct device_attribute *attr, char *buf)
+{
+      struct epl_sensor_priv *epld = epl_sensor_obj;
+      ssize_t len = 0;
+      bool enable_ps = epld->enable_pflag==1 && epld->ps_suspend==0;
+      LOG_FUN();
+
+      if(enable_ps == true && polling_flag == true && eint_flag == true && epl_sensor.ps.polling_mode == 0)
+      {
+        mutex_lock(&sensor_mutex);
+        epl_sensor_read_ps(epld->client);
+        mutex_unlock(&sensor_mutex);
+      }
+      LOG_INFO("[%s]: epl_sensor.ps.data.data = %d \r\n", __func__, epl_sensor.ps.data.data);
+      len += snprintf(buf + len, PAGE_SIZE - len, "%d", epl_sensor.ps.data.data);
+      return len;
+
+}
+
+static ssize_t epl_sensor_show_als_data(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    ssize_t len = 0;
+    bool enable_als = epld->enable_lflag==1 && epld->als_suspend==0;
+    LOG_FUN();
+
+#if ALS_DYN_INTT
+    if(epl_sensor.als.report_type == CMC_BIT_DYN_INT)
+    {
+        LOG_INFO("[%s]: dynamic_intt_lux = %d \r\n", __func__, dynamic_intt_lux);
+        len += snprintf(buf + len, PAGE_SIZE - len, "%d", dynamic_intt_lux);
+    }
+    else
+#endif
+    {
+        if(enable_als == true && polling_flag == true && eint_flag == true && epl_sensor.als.polling_mode == 0)
+        {
+            mutex_lock(&sensor_mutex);
+    	    epl_sensor_read_als(epld->client);
+    	    mutex_unlock(&sensor_mutex);
+    	}
+    	len += snprintf(buf + len, PAGE_SIZE - len, "%d", epl_sensor.als.data.channels[1]);
+    }
+
+    return len;
+}
+
+#if ALS_DYN_INTT
+static ssize_t epl_sensor_store_c_gain(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    int c_h,c_l;
+    LOG_FUN();
+
+    if(epl_sensor.als.lsrc_type == CMC_BIT_LSRC_NON)
+    {
+        sscanf(buf, "%d",&c_h);
+        c_gain = c_h;
+        LOG_INFO("c_gain = %d \r\n", c_gain);
+    }
+    else
+    {
+        sscanf(buf, "%d,%d",&c_l, &c_h);
+        epld->c_gain_h = c_h;
+        epld->c_gain_l = c_l;
+    }
+
+	return count;
+}
+
+static ssize_t epl_sensor_store_lsrc_type(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    int type;
+    LOG_FUN();
+
+    sscanf(buf, "%d",&type);
+
+    epl_sensor.als.lsrc_type = type;
+
+    LOG_INFO("epl_sensor.als.lsrc_type = %d \r\n", epl_sensor.als.lsrc_type);
+
+	return count;
+}
+
+static ssize_t epl_sensor_store_lsrc_thd(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    int lsrc_thrl, lsrc_thrh;
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    LOG_FUN();
+
+    sscanf(buf, "%d,%d",&lsrc_thrl, &lsrc_thrh);
+
+    epld->lsource_thd_low = lsrc_thrl;
+    epld->lsource_thd_high = lsrc_thrh;
+
+    LOG_INFO("lsource_thd=(%d,%d) \r\n", epld->lsource_thd_low, epld->lsource_thd_high);
+
+	return count;
+}
+
+#endif
+
+#if PS_DYN_K
+static ssize_t epl_sensor_store_dyn_offset(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    int dyn_h,dyn_l;
+    LOG_FUN();
+
+    sscanf(buf, "%d,%d",&dyn_l, &dyn_h);
+
+    dynk_low_offset = dyn_l;
+    dynk_high_offset = dyn_h;
+
+    return count;
+}
+
+static ssize_t epl_sensor_store_dyn_thd_offset(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    int thd_offset;
+    LOG_FUN();
+
+    sscanf(buf, "%d",&thd_offset);
+    dynk_thd_offset = thd_offset;
+
+    return count;
+}
+
+static ssize_t epl_sensor_store_dyn_change_thd_max(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    int thd_max;
+    LOG_FUN();
+
+    sscanf(buf, "%d",&thd_max);
+    dynk_change_thd_max = thd_max;
+
+    return count;
+}
+
+static ssize_t epl_sensor_store_dyn_max_ir_data(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    int max_ir_data;
+    LOG_FUN();
+
+    sscanf(buf, "%d",&max_ir_data);
+    dynk_max_ir_data = max_ir_data;
+
+    return count;
+}
+
+#if PS_DYN_K_STR
+static ssize_t epl_sensor_store_dyn_enhance_max_ch0(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    //struct epl_sensor_priv *epld = epl_sensor_obj;
+    int max_ch0;
+    LOG_FUN();
+
+    sscanf(buf, "%d",&max_ch0);
+    dynk_enhance_max_ch0 = max_ch0;
+
+    return count;
+}
+
+static ssize_t epl_sensor_store_dyn_enhance_gain_intt(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    //struct epl_sensor_priv *epld = epl_sensor_obj;
+    int gain, intt;
+    LOG_FUN();
+
+    sscanf(buf, "%d,%d",&gain, &intt);
+
+    dynk_enhance_integration_time = intt;
+    dynk_enhance_gain = gain;
+
+    return count;
+}
+#endif
+
+#endif
+
+#if HS_ENABLE
+static ssize_t epl_sensor_show_renvo(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    ssize_t len = 0;
+
+    LOG_FUN();
+    LOG_INFO("gRawData.renvo=0x%x \r\n", epl_sensor.revno);
+
+    len += snprintf(buf+len, PAGE_SIZE-len, "%x", epl_sensor.revno);
+
+    return len;
+}
+
+static ssize_t epl_sensor_store_hs_enable(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    uint16_t mode=0;
+    struct epl_sensor_priv *obj = epl_sensor_obj;
+    bool enable_ps = obj->enable_pflag==1 && obj->ps_suspend==0;
+	bool enable_als = obj->enable_lflag==1 && obj->als_suspend==0;
+    LOG_FUN();
+
+    sscanf(buf, "%hu",&mode);
+
+    if(enable_ps == 0)
+    {
+        if(mode > 0)
+    	{
+    	    if(enable_als == 1)
+    	    {
+                obj->enable_lflag = 0;
+                hs_enable_flag = true;
+    	    }
+    		epl_sensor.hs.integration_time = epl_sensor.hs.integration_time_max;
+    		epl_sensor.hs.raws_count=0;
+            obj->enable_hflag = 1;
+
+            if(mode == 2)
+            {
+                epl_sensor.hs.dynamic_intt = false;
+            }
+            else
+            {
+                epl_sensor.hs.dynamic_intt = true;
+            }
+    	}
+        else
+    	{
+            obj->enable_hflag = 0;
+            if(hs_enable_flag == true)
+            {
+                obj->enable_lflag = 1;
+                hs_enable_flag = false;
+            }
+
+    	}
+        write_global_variable(obj->client);
+        epl_sensor_update_mode(obj->client);
+    }
+
+    return count;
+}
+
+static ssize_t epl_sensor_store_hs_int_time(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    struct epl_sensor_priv *obj = epl_sensor_obj;
+	int value;
+	u8 intt_buf;
+
+    sscanf(buf, "%d",&value);
+
+	mutex_lock(&hs_sensor_mutex);
+	epl_sensor.hs.integration_time = value<<2;
+	intt_buf = epl_sensor.hs.integration_time | epl_sensor.hs.gain;
+	epl_sensor_I2C_Write(obj->client, 0x03, intt_buf);
+	mutex_unlock(&hs_sensor_mutex);
+
+    return count;
+}
+
+/*----------------------------------------------------------------------------*/
+static ssize_t epl_sensor_show_hs_raws(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    u16 *tmp = (u16*)buf;
+    int byte_count=2+epl_sensor.hs.raws_count*2;
+    int i=0;
+    LOG_FUN();
+    mutex_lock(&hs_sensor_mutex);
+    tmp[0]= epl_sensor.hs.raws_count;
+
+    for(i=0; i<epl_sensor.hs.raws_count; i++){
+        tmp[i+1] = epl_sensor.hs.raws[i];
+    }
+
+    epl_sensor.hs.raws_count=0;
+    mutex_unlock(&hs_sensor_mutex);
+
+    return byte_count;
+}
+#endif
+
+#if PS_GES
+static ssize_t epl_sensor_store_ges_enable(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    int ges_enable=0;
+    struct epl_sensor_priv *obj = epl_sensor_obj;
+    struct i2c_client *client = obj->client;
+    bool enable_ps = obj->enable_pflag==1 && obj->ps_suspend==0;
+    LOG_FUN();
+
+    sscanf(buf, "%d",&ges_enable);
+    LOG_INFO("[%s]: enable_ps=%d, ges_enable=%d \r\n", __func__, enable_ps, ges_enable);
+
+    if(enable_ps == 0)
+    {
+        if(ges_enable == 1)
+        {
+            obj->enable_gflag = 1;
+        }
+        else
+        {
+            obj->enable_gflag = 0;
+        }
+    }
+
+    write_global_variable(obj->client);
+    epl_sensor_update_mode(client);
+    return count;
+}
+
+static ssize_t epl_sensor_store_ges_polling_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    int ges_mode=0;
+    struct epl_sensor_priv *obj = epl_sensor_obj;
+    struct i2c_client *client = obj->client;
+
+    LOG_FUN();
+    sscanf(buf, "%d",&ges_mode);
+    LOG_INFO("[%s]: ges_mode=%d \r\n", __func__, ges_mode);
+
+    epl_sensor.ges.polling_mode = ges_mode;
+    epl_sensor.ps.polling_mode = ges_mode;
+
+    epl_sensor_update_mode(client);
+    return count;
+}
+
+static ssize_t epl_sensor_store_ges_thd(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    int ges_l=0, ges_h=0;
+    struct epl_sensor_priv *obj = epl_sensor_obj;
+    struct i2c_client *client = obj->client;
+
+    LOG_FUN();
+    sscanf(buf, "%d,%d",&ges_l, &ges_h);
+    epl_sensor.ges.low_threshold = ges_l;
+    epl_sensor.ges.high_threshold = ges_h;
+    LOG_INFO("[%s]: ges_thd=%d,%d \r\n", __func__, epl_sensor.ges.low_threshold, epl_sensor.ges.high_threshold);
+
+    write_global_variable(obj->client);
+    epl_sensor_update_mode(client);
+    return count;
+}
+
+#endif
+/*----------------------------------------------------------------------------*/
+
+static DEVICE_ATTR(elan_status,					S_IROTH  | S_IWOTH, epl_sensor_show_status,  	  		NULL										);
+static DEVICE_ATTR(elan_reg,    				S_IROTH  | S_IWOTH, epl_sensor_show_reg,   				NULL										);
+static DEVICE_ATTR(mode,						S_IROTH  | S_IWOTH, NULL,   							epl_sensor_store_mode						);
+static DEVICE_ATTR(wait_time,					S_IROTH  | S_IWOTH, NULL,   					 		epl_sensor_store_wait_time					);
+static DEVICE_ATTR(set_threshold,     			S_IROTH  | S_IWOTH, NULL,   					 		epl_sensor_store_threshold					);
+static DEVICE_ATTR(cal_raw, 					S_IROTH  | S_IWOTH, epl_sensor_show_cal_raw, 	  		NULL										);
+static DEVICE_ATTR(als_enable,					S_IROTH  | S_IWOTH, NULL,   							epl_sensor_store_als_enable					);
+static DEVICE_ATTR(als_report_type,				S_IROTH  | S_IWOTH, NULL,								epl_sensor_store_als_report_type			);
+static DEVICE_ATTR(ps_enable,				    S_IROTH  | S_IWOTH, NULL,   							epl_sensor_store_ps_enable					);
+static DEVICE_ATTR(ps_polling_mode,				S_IROTH  | S_IWOTH, epl_sensor_show_ps_polling,   		epl_sensor_store_ps_polling_mode			);
+static DEVICE_ATTR(als_polling_mode,			S_IROTH  | S_IWOTH, epl_sensor_show_als_polling,   		epl_sensor_store_als_polling_mode			);
+static DEVICE_ATTR(gain,						S_IROTH  | S_IWOTH, NULL,   							epl_sensor_store_gain						);
+static DEVICE_ATTR(ir_mode,						S_IROTH  | S_IWOTH, NULL,   							epl_sensor_store_ir_mode					);
+static DEVICE_ATTR(ir_drive,					S_IROTH  | S_IWOTH, NULL,   							epl_sensor_store_ir_drive					);
+static DEVICE_ATTR(ir_on,						S_IROTH  | S_IWOTH, NULL,								epl_sensor_store_ir_contrl					);
+static DEVICE_ATTR(interrupt_type,				S_IROTH  | S_IWOTH, NULL,								epl_sensor_store_interrupt_type				);
+static DEVICE_ATTR(integration,					S_IROTH  | S_IWOTH, NULL,								epl_sensor_store_integration				);
+static DEVICE_ATTR(adc,							S_IROTH  | S_IWOTH, NULL,								epl_sensor_store_adc						);
+static DEVICE_ATTR(cycle,						S_IROTH  | S_IWOTH, NULL,								epl_sensor_store_cycle						);
+static DEVICE_ATTR(ps_w_calfile,				S_IROTH  | S_IWOTH, NULL,			                    epl_sensor_store_ps_w_calfile				);
+static DEVICE_ATTR(i2c_w,                       S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_reg_write                  );
+static DEVICE_ATTR(unlock,				        S_IROTH  | S_IWOTH, NULL,			                    epl_sensor_store_unlock						);
+static DEVICE_ATTR(als_ch,				        S_IROTH  | S_IWOTH, NULL,			                    epl_sensor_store_als_ch_sel					);
+static DEVICE_ATTR(ps_cancel,				    S_IROTH  | S_IWOTH, NULL,			                    epl_sensor_store_ps_cancelation				);
+static DEVICE_ATTR(run_ps_cali, 				S_IROTH  | S_IWOTH, epl_sensor_show_ps_run_cali, 	  	NULL										);
+static DEVICE_ATTR(pdata,                       S_IROTH  | S_IWOTH, epl_sensor_show_pdata,              NULL                                        );
+static DEVICE_ATTR(als_data,                    S_IROTH  | S_IWOTH, epl_sensor_show_als_data,           NULL                                        );
+#if ALS_DYN_INTT
+static DEVICE_ATTR(als_dyn_c_gain,              S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_c_gain);
+static DEVICE_ATTR(als_dyn_lsrc_type,           S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_lsrc_type);
+static DEVICE_ATTR(als_dyn_lsrc_thd,            S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_lsrc_thd);
+#endif
+#if PS_DYN_K
+static DEVICE_ATTR(dyn_offset,                  S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_dyn_offset);
+static DEVICE_ATTR(dyn_thd_offset,              S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_dyn_thd_offset);
+static DEVICE_ATTR(dyn_change_max,              S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_dyn_change_thd_max);
+static DEVICE_ATTR(dyn_max_ir_data,             S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_dyn_max_ir_data            );
+#if PS_DYN_K_STR
+static DEVICE_ATTR(dyn_enh_max_ch0,              S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_dyn_enhance_max_ch0       );
+static DEVICE_ATTR(dyn_enh_gain_intt,              S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_dyn_enhance_gain_intt       );
+#endif
+#endif
+#if HS_ENABLE
+static DEVICE_ATTR(elan_renvo,                  S_IROTH  | S_IWOTH, epl_sensor_show_renvo,              NULL                                        );
+static DEVICE_ATTR(hs_enable,					S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_hs_enable                  );
+static DEVICE_ATTR(hs_int_time,					S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_hs_int_time                );
+static DEVICE_ATTR(hs_raws,					    S_IROTH  | S_IWOTH, epl_sensor_show_hs_raws,            NULL                                        );
+#endif
+#if PS_GES
+static DEVICE_ATTR(ges_enable,					S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_ges_enable                 );
+static DEVICE_ATTR(ges_polling_mode,			S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_ges_polling_mode           );
+static DEVICE_ATTR(ges_thd,			            S_IROTH  | S_IWOTH, NULL,                               epl_sensor_store_ges_thd                    );
+#endif
+/*----------------------------------------------------------------------------*/
+static struct attribute *epl_sensor_attr_list[] =
+{
+    &dev_attr_elan_status.attr,
+    &dev_attr_elan_reg.attr,
+    &dev_attr_als_enable.attr,
+    &dev_attr_ps_enable.attr,
+    &dev_attr_cal_raw.attr,
+    &dev_attr_set_threshold.attr,
+    &dev_attr_wait_time.attr,
+    &dev_attr_gain.attr,
+    &dev_attr_mode.attr,
+    &dev_attr_ir_mode.attr,
+    &dev_attr_ir_drive.attr,
+    &dev_attr_ir_on.attr,
+    &dev_attr_interrupt_type.attr,
+    &dev_attr_integration.attr,
+    &dev_attr_adc.attr,
+    &dev_attr_cycle.attr,
+    &dev_attr_als_report_type.attr,
+    &dev_attr_ps_polling_mode.attr,
+    &dev_attr_als_polling_mode.attr,
+    &dev_attr_ps_w_calfile.attr,
+    &dev_attr_i2c_w.attr,
+    &dev_attr_unlock.attr,
+    &dev_attr_als_ch.attr,
+    &dev_attr_ps_cancel.attr,
+    &dev_attr_run_ps_cali.attr,
+    &dev_attr_pdata.attr,
+    &dev_attr_als_data.attr,
+#if ALS_DYN_INTT
+    &dev_attr_als_dyn_c_gain.attr,
+    &dev_attr_als_dyn_lsrc_type.attr,
+    &dev_attr_als_dyn_lsrc_thd.attr,
+#endif
+#if PS_DYN_K
+    &dev_attr_dyn_offset.attr,
+    &dev_attr_dyn_thd_offset.attr,
+    &dev_attr_dyn_change_max.attr,
+    &dev_attr_dyn_max_ir_data.attr,
+#if PS_DYN_K_STR
+    &dev_attr_dyn_enh_max_ch0.attr,
+    &dev_attr_dyn_enh_gain_intt.attr,
+#endif
+#endif
+#if HS_ENABLE
+    &dev_attr_elan_renvo.attr,
+    &dev_attr_hs_enable.attr,
+    &dev_attr_hs_int_time.attr,
+    &dev_attr_hs_raws.attr,
+#endif
+#if PS_GES
+    &dev_attr_ges_enable.attr,
+    &dev_attr_ges_polling_mode.attr,
+    &dev_attr_ges_thd.attr,
+#endif
+};
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static struct attribute_group epl_sensor_attr_group =
+{
+    .attrs = epl_sensor_attr_list,
+};
+/*----------------------------------------------------------------------------*/
+#if !(SPREAD || MARVELL)/*SPREAD MARVELL start.....*/
+/*----------------------------------------------------------------------------*/
+static int epl_sensor_als_open(struct inode *inode, struct file *file)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+
+    LOG_FUN();
+
+    if (epld->als_opened)
+    {
+        return -EBUSY;
+    }
+    epld->als_opened = 1;
+
+    return 0;
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static int epl_sensor_als_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    int buf[1];
+    if(epld->read_flag ==1)
+    {
+        buf[0] = epl_sensor.als.data.channels[1];
+        if(copy_to_user(buffer, &buf , sizeof(buf)))
+            return 0;
+        epld->read_flag = 0;
+        return 12;
+    }
+    else
+    {
+        return 0;
+    }
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static int epl_sensor_als_release(struct inode *inode, struct file *file)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+
+    LOG_FUN();
+
+    epld->als_opened = 0;
+
+    return 0;
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static long epl_sensor_als_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+    int flag;
+    unsigned long buf[1];
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    bool enable_als = epld->enable_lflag==1 && epld->als_suspend==0;
+    void __user *argp = (void __user *)arg;
+
+    LOG_INFO("als io ctrl cmd %d\n", _IOC_NR(cmd));
+
+    switch(cmd)
+    {
+        case ELAN_EPL8800_IOCTL_GET_LFLAG:
+
+            LOG_INFO("elan ambient-light IOCTL Sensor get lflag \n");
+            flag = epld->enable_lflag;
+            if (copy_to_user(argp, &flag, sizeof(flag)))
+                return -EFAULT;
+
+            LOG_INFO("elan ambient-light Sensor get lflag %d\n",flag);
+            break;
+
+        case ELAN_EPL8800_IOCTL_ENABLE_LFLAG:
+#if LEADCORE
+        case LIGHT_SET_ENALBE:
+#endif
+            LOG_INFO("elan ambient-light IOCTL Sensor set lflag \n");
+            if (copy_from_user(&flag, argp, sizeof(flag)))
+                return -EFAULT;
+            if (flag < 0 || flag > 1)
+                return -EINVAL;
+
+            if(epld->enable_lflag != flag)
+            {
+#if ALS_DYN_INTT
+                if(epl_sensor.als.report_type == CMC_BIT_DYN_INT)
+                {
+                    dynamic_intt_idx = dynamic_intt_init_idx;
+                    epl_sensor.als.integration_time = als_dynamic_intt_intt[dynamic_intt_idx];
+                    epl_sensor.als.gain = als_dynamic_intt_gain[dynamic_intt_idx];
+                    dynamic_intt_high_thr = als_dynamic_intt_high_thr[dynamic_intt_idx];
+                    dynamic_intt_low_thr = als_dynamic_intt_low_thr[dynamic_intt_idx];
+                }
+#endif
+                epld->enable_lflag = flag;
+
+                epl_sensor_update_mode(epld->client);
+            }
+
+            LOG_INFO("elan ambient-light Sensor set lflag %d\n",flag);
+            break;
+
+        case ELAN_EPL8800_IOCTL_GETDATA:
+            if(enable_als == 0)
+            {
+                epld->enable_lflag = 1;
+                epl_sensor_update_mode(epld->client);
+                msleep(30);
+            }
+
+            if(enable_als == true && polling_flag == true && eint_flag == true && epl_sensor.als.polling_mode == 0)
+            {
+                mutex_lock(&sensor_mutex);
+                epl_sensor_read_als(epld->client);
+                mutex_unlock(&sensor_mutex);
+            }
+#if ALS_DYN_INTT
+            if(epl_sensor.als.report_type == CMC_BIT_DYN_INT)
+            {
+                buf[0] = dynamic_intt_lux;
+                LOG_INFO("[%s]: als dynamic_intt_lux = %d \r\n", __func__, dynamic_intt_lux);
+            }
+            else
+#else
+            {
+                buf[0] = epl_sensor.als.data.channels[1];
+                LOG_INFO("[%s]: epl_sensor.als.data.channels[1] = %d \r\n", __func__, epl_sensor.als.data.channels[1]);
+            }
+#endif
+
+            if(copy_to_user(argp, &buf , sizeof(buf)))
+                return -EFAULT;
+
+            break;
+#if LEADCORE
+        case LIGHT_SET_DELAY:
+
+			if (arg > LIGHT_MAX_DELAY)
+				arg = LIGHT_MAX_DELAY;
+			else if (arg < LIGHT_MIN_DELAY)
+				arg = LIGHT_MIN_DELAY;
+			LOG_INFO("LIGHT_SET_DELAY--%d\r\n",(int)arg);
+			polling_time = arg;
+			break;
+#endif
+        default:
+            LOG_ERR("invalid cmd %d\n", _IOC_NR(cmd));
+            return -EINVAL;
+    }
+
+    return 0;
+
+
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static struct file_operations epl_sensor_als_fops =
+{
+    .owner = THIS_MODULE,
+    .open = epl_sensor_als_open,
+    .read = epl_sensor_als_read,
+    .release = epl_sensor_als_release,
+    .unlocked_ioctl = epl_sensor_als_ioctl
+};
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static struct miscdevice epl_sensor_als_device =
+{
+    .minor = MISC_DYNAMIC_MINOR,
+#if LEADCORE
+    .name = "light",
+#else
+    .name = "elan_als",
+#endif
+    .fops = &epl_sensor_als_fops
+};
+/*----------------------------------------------------------------------------*/
+#endif /*SPREAD MARVELL end.........*/
+
+/*----------------------------------------------------------------------------*/
+static int epl_sensor_ps_open(struct inode *inode, struct file *file)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+
+    LOG_FUN();
+
+    if (epld->ps_opened)
+        return -EBUSY;
+
+    epld->ps_opened = 1;
+
+    return 0;
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static int epl_sensor_ps_release(struct inode *inode, struct file *file)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+
+    LOG_FUN();
+
+    epld->ps_opened = 0;
+
+    return 0;
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+
+static int epl259x_read_chip_info(struct i2c_client *client, char *buf)
+{
+        if(NULL == buf) {
+                return -1;
+        }
+        if(NULL == client) {
+                *buf = 0;
+                return -2;
+        }
+
+        sprintf(buf, "EPL2182");
+        printk("[EPL259x] epl259x_read_chip_info %s\n",buf);
+        return 0;
+}
+
+static long epl_sensor_ps_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+    int value;
+    int flag,err =0;
+    char strbuf[100];
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    bool enable_ps = epld->enable_pflag==1 && epld->ps_suspend==0;
+#if HS_ENABLE
+    bool enable_hs = epld->enable_hflag==1 && epld->hs_suspend==0;
+#endif
+#if PS_GES
+    bool enable_ges = epld->enable_gflag==1 && epld->ges_suspend==0;
+#endif
+    void __user *argp = (void __user *)arg;
+
+    LOG_INFO("ps io ctrl cmd %d\n", _IOC_NR(cmd));
+
+    //ioctl message handle must define by android sensor library (case by case)
+    switch(cmd)
+    {
+        case ELAN_EPL8800_IOCTL_GET_PFLAG:
+#if MARVELL
+        case LTR_IOCTL_GET_PFLAG:
+#endif
+            LOG_INFO("elan Proximity Sensor IOCTL get pflag \n");
+            flag = epld->enable_pflag;
+            if (copy_to_user(argp, &flag, sizeof(flag)))
+                return -EFAULT;
+
+            LOG_INFO("elan Proximity Sensor get pflag %d\n",flag);
+            break;
+
+        case ELAN_EPL8800_IOCTL_ENABLE_PFLAG:
+#if LEADCORE
+        case PROXIMITY_SET_ENALBE:
+#elif MARVELL
+        case LTR_IOCTL_SET_PFLAG:
+#endif
+            LOG_INFO("elan Proximity IOCTL Sensor set pflag \n");
+            if (copy_from_user(&flag, argp, sizeof(flag)))
+                return -EFAULT;
+            if (flag < 0 || flag > 1)
+                return -EINVAL;
+#if HS_ENABLE
+            if(enable_hs == 1 && flag == 1)
+            {
+                epld->enable_hflag = 0;
+                if(hs_enable_flag == true)
+                {
+                    epld->enable_lflag = 1;
+                    hs_enable_flag = false;
+                }
+                write_global_variable(epld->client);
+                LOG_INFO("[%s] Disable HS and recover ps setting \r\n", __func__);
+            }
+#endif
+#if PS_GES
+            if(enable_ges == 1 && flag == 1)
+            {
+                epld->enable_gflag = 0;
+                write_global_variable(epld->client);
+                ps_ges_enable_flag = true;
+                LOG_INFO("[%s] Disable GES and recover ps setting \r\n", __func__);
+            }
+            else if (ps_ges_enable_flag == true && flag == 0)
+            {
+                epld->enable_gflag = 1;
+                write_global_variable(epld->client);
+                ps_ges_enable_flag = false;
+                LOG_INFO("[%s] enable GES and recover ges setting \r\n", __func__);
+            }
+#endif
+            if(epld->enable_pflag != flag)
+            {
+                epld->enable_pflag = flag;
+                if(flag)
+                {
+                    wake_lock(&ps_lock);
+#if PS_DYN_K
+                    dynk_min_ps_raw_data = 0xffff;
+                    dynk_change_flag = false;
+#if PS_DYN_K_STR
+                    dynk_enhance_flag = false;
+#endif
+#endif
+                }else{
+#if PS_DYN_K
+                    cancel_delayed_work(&dynk_thd_polling_work);
+#endif
+                    wake_unlock(&ps_lock);
+                }
+                epl_sensor_update_mode(epld->client);
+            }
+
+            LOG_INFO("elan Proximity Sensor set pflag %d\n",flag);
+            break;
+
+        case ELAN_EPL8800_IOCTL_GETDATA:
+            if(enable_ps == 0)
+            {
+                epld->enable_pflag = 1;
+                epl_sensor_update_mode(epld->client);
+                msleep(30);
+            }
+
+            if(enable_ps == true && polling_flag == true && eint_flag == true && epl_sensor.ps.polling_mode == 0)
+            {
+                mutex_lock(&sensor_mutex);
+                epl_sensor_read_ps(epld->client);
+                mutex_unlock(&sensor_mutex);
+            }
+
+            LOG_INFO("[%s]: epl_sensor.ps.data.data = %d \r\n", __func__, epl_sensor.ps.data.data);
+
+            value = epl_sensor.ps.data.data;
+            if(copy_to_user(argp, &value , sizeof(value)))
+                return -EFAULT;
+
+            LOG_INFO("elan proximity Sensor get data (%d) \n",value);
+            break;
+#if LEADCORE
+		case PROXIMITY_SET_DELAY:
+			if (arg > PROXIMITY_MAX_DELAY)
+				arg = PROXIMITY_MAX_DELAY;
+			else if (arg < PROXIMITY_MIN_DELAY)
+				arg = PROXIMITY_MIN_DELAY;
+			LOG_INFO("PROXIMITY_SET_DELAY--%d\r\n",(int)arg);
+			polling_time = arg;
+			break;
+#endif
+
+#if SPREAD || MARVELL  /*SPREAD MARVELL start.....*/
+        case ELAN_EPL8800_IOCTL_GET_LFLAG:
+#if MARVELL
+        case LTR_IOCTL_GET_LFLAG:
+#endif
+            LOG_INFO("elan ambient-light IOCTL Sensor get lflag \n");
+            flag = epld->enable_lflag;
+            if (copy_to_user(argp, &flag, sizeof(flag)))
+                return -EFAULT;
+
+            LOG_INFO("elan ambient-light Sensor get lflag %d\n",flag);
+            break;
+
+        case ELAN_EPL8800_IOCTL_GET_CHIPINFO:
+                err = epl259x_read_chip_info(this_client, strbuf);
+                if(err < 0)
+                        return -EFAULT;
+                if(copy_to_user(argp, strbuf, strlen(strbuf)+1))
+                        return -EFAULT;
+            break;
+
+        case ELAN_EPL8800_IOCTL_ENABLE_LFLAG:
+#if MARVELL
+        case LTR_IOCTL_SET_LFLAG:
+#endif
+            LOG_INFO("elan ambient-light IOCTL Sensor set lflag \n");
+            if (copy_from_user(&flag, argp, sizeof(flag)))
+                return -EFAULT;
+            if (flag < 0 || flag > 1)
+                return -EINVAL;
+
+            if(epld->enable_lflag != flag)
+            {
+#if ALS_DYN_INTT
+                if(epl_sensor.als.report_type == CMC_BIT_DYN_INT)
+                {
+                    dynamic_intt_idx = dynamic_intt_init_idx;
+                    epl_sensor.als.integration_time = als_dynamic_intt_intt[dynamic_intt_idx];
+                    epl_sensor.als.gain = als_dynamic_intt_gain[dynamic_intt_idx];
+                    dynamic_intt_high_thr = als_dynamic_intt_high_thr[dynamic_intt_idx];
+                    dynamic_intt_low_thr = als_dynamic_intt_low_thr[dynamic_intt_idx];
+                }
+#endif
+                epld->enable_lflag = flag;
+
+                epl_sensor_update_mode(epld->client);
+            }
+
+            LOG_INFO("elan ambient-light Sensor set lflag %d\n",flag);
+            break;
+#if 0
+        case ELAN_EPL8800_IOCTL_GETDATA:
+            if(enable_als == 0)
+            {
+                epld->enable_lflag = 1;
+                epl_sensor_update_mode(epld->client);
+                msleep(30);
+            }
+
+            if(enable_als == true && polling_flag == true && eint_flag == true && epl_sensor.als.polling_mode == 0)
+            {
+                mutex_lock(&sensor_mutex);
+                epl_sensor_read_als(epld->client);
+                mutex_unlock(&sensor_mutex);
+            }
+#if ALS_DYN_INTT
+            if(epl_sensor.als.report_type == CMC_BIT_DYN_INT)
+            {
+                buf[0] = dynamic_intt_lux;
+                LOG_INFO("[%s]: als dynamic_intt_lux = %d \r\n", __func__, dynamic_intt_lux);
+            }
+            else
+#else
+            {
+                buf[0] = epl_sensor.als.data.channels[1];
+                LOG_INFO("[%s]: epl_sensor.als.data.channels[1] = %d \r\n", __func__, epl_sensor.als.data.channels[1]);
+            }
+#endif
+
+            if(copy_to_user(argp, &buf , sizeof(buf)))
+                return -EFAULT;
+
+            break;
+#endif
+#endif  /*SPREAD MARVELL end......*/
+        default:
+            LOG_ERR("invalid cmd %d\n", _IOC_NR(cmd));
+            return -EINVAL;
+    }
+
+    return 0;
+
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static struct file_operations epl_sensor_ps_fops =
+{
+    .owner = THIS_MODULE,
+    .open = epl_sensor_ps_open,
+    .release = epl_sensor_ps_release,
+    .unlocked_ioctl = epl_sensor_ps_ioctl
+};
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static struct miscdevice epl_sensor_ps_device =
+{
+    .minor = MISC_DYNAMIC_MINOR,
+#if LEADCORE
+    .name = "proximity",
+#elif MARVELL
+    .name = "alps_pxy",
+#elif SPREAD
+    .name = "epl2182_pls",
+#endif
+    .fops = &epl_sensor_ps_fops
+};
+
+#if !(SPREAD || MARVELL) /*SPREAD MARVELL start.....*/
+/*----------------------------------------------------------------------------*/
+static ssize_t light_enable_show(struct device *dev,
+					 struct device_attribute *attr, char *buf)
+{
+	struct epl_sensor_priv *epld  = epl_sensor_obj;
+	LOG_INFO("%s: ALS_status=%d\n", __func__, epld->enable_lflag);
+	return sprintf(buf, "%d\n", epld->enable_lflag);
+}
+
+static ssize_t light_enable_store(struct device *dev,
+					  struct device_attribute *attr,
+					  const char *buf, size_t size)
+{
+	struct epl_sensor_priv *epld = epl_sensor_obj;
+    uint16_t als_enable = 0;
+    LOG_INFO("light_enable_store: enable=%s \n", buf);
+
+    sscanf(buf, "%hu",&als_enable);
+
+    if(epld->enable_lflag != als_enable)
+    {
+        epld->enable_lflag = als_enable;
+
+        epl_sensor_update_mode(epld->client);
+    }
+
+	return size;
+}
+/*----------------------------------------------------------------------------*/
+static struct device_attribute dev_attr_light_enable =
+__ATTR(enable, S_IRWXUGO,
+	   light_enable_show, light_enable_store);
+
+static struct attribute *light_sysfs_attrs[] = {
+	&dev_attr_light_enable.attr,
+	NULL
+};
+
+static struct attribute_group light_attribute_group = {
+	.attrs = light_sysfs_attrs,
+};
+/*----------------------------------------------------------------------------*/
+static int epl_sensor_setup_lsensor(struct epl_sensor_priv *epld)
+{
+    int err = 0;
+    LOG_INFO("epl_sensor_setup_lsensor enter.\n");
+
+    epld->als_input_dev = input_allocate_device();
+    if (!epld->als_input_dev)
+    {
+        LOG_ERR( "could not allocate ls input device\n");
+        return -ENOMEM;
+    }
+    epld->als_input_dev->name = ElanALsensorName;
+    set_bit(EV_ABS, epld->als_input_dev->evbit);
+    input_set_abs_params(epld->als_input_dev, ABS_MISC, 0, 9, 0, 0);
+
+    err = input_register_device(epld->als_input_dev);
+    if (err < 0)
+    {
+        LOG_ERR("can not register ls input device\n");
+        goto err_free_ls_input_device;
+    }
+
+    err = misc_register(&epl_sensor_als_device);
+    if (err < 0)
+    {
+        LOG_ERR("can not register ls misc device\n");
+        goto err_unregister_ls_input_device;
+    }
+
+    err = sysfs_create_group(&epld->als_input_dev->dev.kobj, &light_attribute_group);
+
+	if (err) {
+		pr_err("%s: could not create sysfs group\n", __func__);
+		goto err_free_ls_input_device;
+	}
+    return err;
+
+
+err_unregister_ls_input_device:
+    input_unregister_device(epld->als_input_dev);
+err_free_ls_input_device:
+    input_free_device(epld->als_input_dev);
+    return err;
+}
+#endif /*SPREAD MARVELL end.....*/
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static ssize_t proximity_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+	struct epl_sensor_priv *epld  = epl_sensor_obj;
+	LOG_INFO("%s: PS status=%d\n", __func__, epld->enable_pflag);
+	return sprintf(buf, "%d\n", epld->enable_pflag);
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static ssize_t proximity_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    uint16_t ps_enable = 0;
+#if HS_ENABLE
+    bool enable_hs = epld->enable_hflag==1 && epld->hs_suspend==0;
+#endif
+#if PS_GES
+    bool enable_ges = epld->enable_gflag==1 && epld->ges_suspend==0;
+#endif
+    LOG_INFO("proximity_enable_store: enable=%s \n", buf);
+
+    sscanf(buf, "%hu",&ps_enable);
+
+#if HS_ENABLE
+    if(enable_hs == 1 && ps_enable == 1)
+    {
+        epld->enable_hflag = 0;
+        if(hs_enable_flag == true)
+        {
+            epld->enable_lflag = 1;
+            hs_enable_flag = false;
+        }
+        write_global_variable(epld->client);
+        LOG_INFO("[%s] Disable HS and recover ps setting \r\n", __func__);
+    }
+#endif
+#if PS_GES
+    if(enable_ges == 1 && ps_enable == 1)
+    {
+        epld->enable_gflag = 0;
+        write_global_variable(epld->client);
+        ps_ges_enable_flag = true;
+        LOG_INFO("[%s] Disable GES and recover ps setting \r\n", __func__);
+    }
+    else if (ps_ges_enable_flag == true && ps_enable == 0)
+    {
+        epld->enable_gflag = 1;
+        write_global_variable(epld->client);
+        ps_ges_enable_flag = false;
+        LOG_INFO("[%s] enable GES and recover ges setting \r\n", __func__);
+    }
+#endif
+    if(epld->enable_pflag != ps_enable)
+    {
+        epld->enable_pflag = ps_enable;
+        if(ps_enable)
+        {
+            wake_lock(&ps_lock);
+#if PS_DYN_K
+            dynk_min_ps_raw_data = 0xffff;
+            dynk_change_flag = false;
+#if PS_DYN_K_STR
+            dynk_enhance_flag = false;
+#endif
+#endif
+        }
+        else
+        {
+#if PS_DYN_K
+            cancel_delayed_work(&dynk_thd_polling_work);
+#endif
+            wake_unlock(&ps_lock);
+        }
+
+        epl_sensor_update_mode(epld->client);
+    }
+
+	return size;
+}
+/*----------------------------------------------------------------------------*/
+static struct device_attribute dev_attr_psensor_enable =
+__ATTR(enable, S_IRWXUGO,
+	   proximity_enable_show, proximity_enable_store);
+
+static struct attribute *proximity_sysfs_attrs[] = {
+	&dev_attr_psensor_enable.attr,
+	NULL
+};
+
+static struct attribute_group proximity_attribute_group = {
+	.attrs = proximity_sysfs_attrs,
+};
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static int epl_sensor_setup_psensor(struct epl_sensor_priv *epld)
+{
+    int err = 0;
+    LOG_INFO("epl_sensor_setup_psensor enter.\n");
+
+
+    epld->ps_input_dev = input_allocate_device();
+    if (!epld->ps_input_dev)
+    {
+        LOG_ERR("could not allocate ps input device\n");
+        return -ENOMEM;
+    }
+    epld->ps_input_dev->name = ElanPsensorName;
+
+    set_bit(EV_ABS, epld->ps_input_dev->evbit);
+    input_set_abs_params(epld->ps_input_dev, ABS_DISTANCE, 0, 1, 0, 0);
+#if 1
+    set_bit(EV_ABS, epld->ps_input_dev->evbit);
+    input_set_abs_params(epld->ps_input_dev, ABS_MISC, 0, 9, 0, 0);
+#endif
+
+    err = input_register_device(epld->ps_input_dev);
+    if (err < 0)
+    {
+        LOG_ERR("could not register ps input device\n");
+        goto err_free_ps_input_device;
+    }
+
+    err = misc_register(&epl_sensor_ps_device);
+    if (err < 0)
+    {
+        LOG_ERR("could not register ps misc device\n");
+        goto err_unregister_ps_input_device;
+    }
+
+    err = sysfs_create_group(&epld->ps_input_dev->dev.kobj, &proximity_attribute_group);
+
+	if (err) {
+		pr_err("%s: PS could not create sysfs group\n", __func__);
+		goto err_free_ps_input_device;
+	}
+
+    return err;
+
+err_unregister_ps_input_device:
+    input_unregister_device(epld->ps_input_dev);
+err_free_ps_input_device:
+    input_free_device(epld->ps_input_dev);
+    return err;
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+#ifdef CONFIG_SUSPEND
+static int epl_sensor_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    LOG_FUN();
+
+    epld->als_suspend=1;
+#if HS_ENABLE
+    epld->hs_suspend=1;
+#endif
+#if PS_GES
+    epld->ges_suspend = 1;
+    ps_ges_suspend_flag = true;
+#endif
+    if(epld->enable_pflag == 1){
+        //epld->ps_suspend=0;
+        LOG_INFO("[%s]: ps enable \r\n", __func__);
+    }
+    else{
+        //epld->ps_suspend=1;
+        LOG_INFO("[%s]: ps disable \r\n", __func__);
+        epl_sensor_update_mode(epld->client);
+    }
+
+    return 0;
+}
+
+static int epl_sensor_resume(struct i2c_client *client)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    LOG_FUN();
+
+    epld->als_suspend=0;
+    epld->ps_suspend=0;
+#if HS_ENABLE
+    epld->hs_suspend=0;
+#endif
+#if PS_GES
+    epld->ges_suspend = 0;
+#endif
+    if(epld->enable_pflag == 1){
+        //epld->ps_suspend=0;
+        LOG_INFO("[%s]: ps enable \r\n", __func__);
+        epl_sensor_restart_polling();
+    }
+    else{
+        //epld->ps_suspend=1;
+        LOG_INFO("[%s]: ps disable \r\n", __func__);
+        epl_sensor_update_mode(epld->client);
+    }
+
+#if !defined(CONFIG_HAS_EARLYSUSPEND) && PS_GES
+    ps_ges_suspend_flag = false;
+#endif
+    return 0;
+}
+#endif
+
+/*----------------------------------------------------------------------------*/
+#if defined(CONFIG_HAS_EARLYSUSPEND)
+static void epl_sensor_early_suspend(struct early_suspend *h)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    LOG_FUN();
+
+    epld->als_suspend=1;
+#if HS_ENABLE
+    epld->hs_suspend=1;
+#endif
+#if PS_GES
+    epld->ges_suspend = 1;
+    ps_ges_suspend_flag = true;
+#endif
+    if(epld->enable_pflag == 1)
+    {
+        //epld->ps_suspend=0;
+        LOG_INFO("[%s]: ps enable \r\n", __func__);
+    }
+    else
+    {
+        //epld->ps_suspend=1;
+        LOG_INFO("[%s]: ps disable \r\n", __func__);
+        epl_sensor_update_mode(epld->client);
+    }
+
+}
+
+static void epl_sensor_late_resume(struct early_suspend *h)
+{
+    struct epl_sensor_priv *epld = epl_sensor_obj;
+    LOG_FUN();
+
+    epld->als_suspend=0;
+    epld->ps_suspend=0;
+#if HS_ENABLE
+    epld->hs_suspend=0;
+#endif
+#if PS_GES
+    epld->ges_suspend = 0;
+#endif
+    if(epld->enable_pflag == 1){
+        //epld->ps_suspend=0;
+        LOG_INFO("[%s]: ps enable \r\n", __func__);
+        epl_sensor_restart_polling();
+    }
+    else{
+        //epld->ps_suspend=1;
+        LOG_INFO("[%s]: ps disable \r\n", __func__);
+        epl_sensor_update_mode(epld->client);
+    }
+#if PS_GES
+    ps_ges_suspend_flag = false;
+#endif
+}
+#endif
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static int epl_sensor_probe(struct i2c_client *client,const struct i2c_device_id *id)
+{
+    int err = 0;
+    struct epl_sensor_priv *epld ;
+    struct elan_epl_platform_data *pdata = client->dev.platform_data;
+    struct device_node *np = client->dev.of_node;
+    LOG_INFO("elan sensor probe enter.\n");
+
+#ifdef CONFIG_OF
+        if (np && !pdata){
+		pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+		if (!pdata) {
+			dev_err(&client->dev, "Could not allocate struct elan_epl_platform_data");
+			goto exit_allocate_pdata_failed;
+		}
+		pdata->irq_gpio_number = of_get_gpio(np, 0);
+		if(pdata->irq_gpio_number < 0){
+			dev_err(&client->dev, "fail to get irq_gpio_number\n");
+			kfree(pdata);
+			goto exit_irq_gpio_read_fail;
+		}
+		client->dev.platform_data = pdata;
+	}
+#endif
+
+    epld = kzalloc(sizeof(struct epl_sensor_priv), GFP_KERNEL);
+    if (!epld)
+        return -ENOMEM;
+
+    if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
+    {
+        dev_err(&client->dev,"No supported i2c func what we need?!!\n");
+        err = -ENOTSUPP;
+        goto i2c_fail;
+    }
+    LOG_INFO("chip id REG 0x00 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x00));
+    LOG_INFO("chip id REG 0x01 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x01));
+    LOG_INFO("chip id REG 0x02 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x02));
+    LOG_INFO("chip id REG 0x03 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x03));
+    LOG_INFO("chip id REG 0x04 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x04));
+    LOG_INFO("chip id REG 0x05 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x05));
+    LOG_INFO("chip id REG 0x06 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x06));
+    LOG_INFO("chip id REG 0x07 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x07));
+    LOG_INFO("chip id REG 0x11 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x11));
+    LOG_INFO("chip id REG 0x12 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x12));
+    LOG_INFO("chip id REG 0x1B value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x1B));
+    LOG_INFO("chip id REG 0x20 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x20));
+    LOG_INFO("chip id REG 0x21 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x21));
+    LOG_INFO("chip id REG 0x24 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x24));
+    LOG_INFO("chip id REG 0x25 value = 0x%x\n", i2c_smbus_read_byte_data(client, 0x25));
+
+    if((i2c_smbus_read_byte_data(client, 0x21)) != 0x81){
+        LOG_INFO("elan ALS/PS sensor is failed. \n");
+        goto i2c_fail;
+     }
+
+    epld->als_level_num = sizeof(epld->als_level)/sizeof(epld->als_level[0]);
+    epld->als_value_num = sizeof(epld->als_value)/sizeof(epld->als_value[0]);
+    BUG_ON(sizeof(epld->als_level) != sizeof(als_level));
+    memcpy(epld->als_level, als_level, sizeof(epld->als_level));
+    BUG_ON(sizeof(epld->als_value) != sizeof(als_value));
+    memcpy(epld->als_value, als_value, sizeof(epld->als_value));
+
+    epld->client = client;
+    this_client = client;
+    epld->intr_pin= pdata->irq_gpio_number;
+
+#if HS_ENABLE
+    epld->hs_suspend = 0;
+	mutex_init(&hs_sensor_mutex);
+#endif
+#if PS_GES
+    epld->ges_suspend = 0;
+    epld->gs_input_dev = input_allocate_device();
+    set_bit(EV_KEY, epld->gs_input_dev->evbit);
+    set_bit(EV_REL, epld->gs_input_dev->evbit);
+    set_bit(EV_ABS, epld->gs_input_dev->evbit);
+    epld->gs_input_dev->evbit[0] |= BIT_MASK(EV_REP);
+    epld->gs_input_dev->keycodemax = 500;
+    epld->gs_input_dev->name ="elan_gesture";
+    epld->gs_input_dev->keybit[BIT_WORD(KEYCODE_LEFT)] |= BIT_MASK(KEYCODE_LEFT);
+    if (input_register_device(epld->gs_input_dev))
+        LOG_ERR("register input error\n");
+#endif
+    i2c_set_clientdata(client, epld);
+
+    epl_sensor_obj = epld;
+
+    INIT_DELAYED_WORK(&epld->eint_work, epl_sensor_eint_work);
+
+    epld->epl_wq = create_workqueue("epl2182_pls"); //create_singlethread_workqueue
+    if (!epld->epl_wq)
+    {
+        LOG_ERR("can't create workqueue\n");
+        err = -ENOMEM;
+        goto err_create_singlethread_workqueue;
+    }
+
+    mutex_init(&sensor_mutex);
+
+    //initial global variable and write to senosr
+    initial_global_variable(client, epld);
+#if !(SPREAD || MARVELL)
+    err = epl_sensor_setup_lsensor(epld);
+    if (err < 0)
+    {
+        LOG_ERR("epl_sensor_setup_lsensor error!!\n");
+        goto err_lightsensor_setup;
+    }
+#endif
+
+    err = epl_sensor_setup_psensor(epld);
+    if (err < 0)
+    {
+        LOG_ERR("epl_sensor_setup_psensor error!!\n");
+        goto err_psensor_setup;
+    }
+
+
+    if (epl_sensor.als.polling_mode==0 || epl_sensor.ps.polling_mode==0)
+    {
+        err = epl_sensor_setup_interrupt(epld);
+        if (err < 0)
+        {
+            LOG_ERR("setup error!\n");
+            goto err_sensor_setup;
+        }
+    }
+    //disable_irq(epld->irq); //ices add
+
+#ifdef CONFIG_SUSPEND
+
+#if defined(CONFIG_HAS_EARLYSUSPEND)
+    epld->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
+    epld->early_suspend.suspend = epl_sensor_early_suspend;
+    epld->early_suspend.resume = epl_sensor_late_resume;
+    register_early_suspend(&epld->early_suspend);
+#endif
+
+#endif
+
+    wake_lock_init(&ps_lock, WAKE_LOCK_SUSPEND, "ps wakelock");
+#if 0
+    sensor_dev = platform_device_register_simple("elan_alsps", -1, NULL, 0);
+    if (IS_ERR(sensor_dev))
+    {
+        printk ("sensor_dev_init: error\n");
+        goto err_fail;
+    }
+
+
+    err = sysfs_create_group(&sensor_dev->dev.kobj, &epl_sensor_attr_group);
+    if (err !=0)
+    {
+        dev_err(&client->dev,"%s:create sysfs group error", __func__);
+        goto err_fail;
+    }
+#endif
+    LOG_INFO("sensor probe success.\n");
+    return err;
+
+err_fail:
+    input_unregister_device(epld->als_input_dev);
+    input_unregister_device(epld->ps_input_dev);
+    input_free_device(epld->als_input_dev);
+    input_free_device(epld->ps_input_dev);
+#if !(SPREAD || MARVELL)
+err_lightsensor_setup:
+#endif
+err_psensor_setup:
+err_sensor_setup:
+    destroy_workqueue(epld->epl_wq);
+    misc_deregister(&epl_sensor_ps_device);
+#if !(SPREAD || MARVELL)
+    misc_deregister(&epl_sensor_als_device);
+#endif
+err_create_singlethread_workqueue:
+i2c_fail:
+    kfree(epld);
+#ifdef CONFIG_OF
+exit_irq_gpio_read_fail:
+exit_allocate_pdata_failed:
+#endif
+
+    return err;
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static int epl_sensor_remove(struct i2c_client *client)
+{
+    struct epl_sensor_priv *epld = i2c_get_clientdata(client);
+
+    dev_dbg(&client->dev, "%s: enter.\n", __func__);
+#if defined(CONFIG_HAS_EARLYSUSPEND)
+    unregister_early_suspend(&epld->early_suspend);
+#endif
+    sysfs_remove_group(&sensor_dev->dev.kobj, &epl_sensor_attr_group);
+    platform_device_unregister(sensor_dev);
+    input_unregister_device(epld->als_input_dev);
+    input_unregister_device(epld->ps_input_dev);
+#if !(SPREAD || MARVELL)
+    input_free_device(epld->als_input_dev);
+#endif
+    input_free_device(epld->ps_input_dev);
+    misc_deregister(&epl_sensor_ps_device);
+#if !(SPREAD || MARVELL)
+    misc_deregister(&epl_sensor_als_device);
+#endif
+    free_irq(epld->irq,epld);
+    destroy_workqueue(epld->epl_wq);
+    kfree(epld);
+    return 0;
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static const struct i2c_device_id epl_sensor_id[] =
+{
+       { EPL_DEV_NAME, 0 },
+       {}
+};
+
+#if SPREAD
+static struct of_device_id epl_match_table[] = {
+       { .compatible = "ELAN,epl259x_pls", },
+       {}
+};
+#endif
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+static struct i2c_driver epl_sensor_driver =
+{
+    .probe	        = epl_sensor_probe,
+    .remove	= epl_sensor_remove,
+    .id_table	= epl_sensor_id,
+    .driver	= {
+        .name = EPL_DEV_NAME,
+        .owner = THIS_MODULE,
+#if SPREAD
+        .of_match_table =epl_match_table,
+#endif
+    },
+#ifdef CONFIG_SUSPEND
+    //.suspend = epl_sensor_suspend,
+    //.resume = epl_sensor_resume,
+#endif
+};
+
+static int __init epl_sensor_init(void)
+{
+    return i2c_add_driver(&epl_sensor_driver);
+}
+
+static void __exit  epl_sensor_exit(void)
+{
+    i2c_del_driver(&epl_sensor_driver);
+}
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+module_init(epl_sensor_init);
+module_exit(epl_sensor_exit);
+/*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*/
+MODULE_AUTHOR("Renato Pan <renato.pan@eminent-tek.com>");
+MODULE_DESCRIPTION("ELAN epl259x driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/ewtsa.c b/drivers/input/misc/ewtsa.c
new file mode 100644
index 00000000..bdb0b973
--- /dev/null
+++ b/drivers/input/misc/ewtsa.c
@@ -0,0 +1,2763 @@
+/*
+ * linux/drivers/input/misc/ewtsa.c
+ *
+ * Copyright 2010-2011 Panasonic Electronic Devices. All Rights Reserved.
+ */
+
+/*
+ * The code contained herein is licensed under the GNU General Public
+ * License. You may obtain a copy of the GNU General Public License
+ * Version 2 or later at the following locations:
+ *
+ * http://www.opensource.org/licenses/gpl-license.html
+ * http://www.gnu.org/copyleft/gpl.html
+ */
+
+/*include files*/
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/err.h>
+#include <linux/input.h>
+#include <linux/input-polldev.h>
+#include <linux/regulator/consumer.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <mach/hardware.h>
+#include <linux/gpio.h>
+#include <linux/delay.h>
+#include <linux/timer.h>
+#include <linux/jiffies.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+
+/* configurable */
+#define GYRO_MOUNT_SWAP_XY      0   /* swap X, Y */
+#define GYRO_MOUNT_REVERSE_X    0   /* reverse X */
+#define GYRO_MOUNT_REVERSE_Y    0   /* reverse Y */
+#define GYRO_MOUNT_REVERSE_Z    0   /* reverse Z */
+#define GYRO_VER3_ES1           0
+#define GYRO_VER3_ES3           0
+#define GYRO_VER3_ES4           1
+#define GYRO_REGISTER_MAP2      0
+#define GYRO_SPI_INTERFACE      0
+
+#define USE_GPIO_DRDY_PIN       0
+#define USE_GPIO_DIAG_PIN       0
+#define USE_GPIO_WINDOW_PIN     0
+
+/* macro defines */
+#define CHIP_ID                 0x68
+#define DEVICE_NAME             "ewtsa"
+#define EWTSA_ON                1
+#define EWTSA_OFF               0
+#define WINDOW_PIN              14
+#define DRDY_PIN                12
+#define DIAG_PIN                11
+#define DIAG_ENABLE             0
+#define DIAG_DISABLE            1
+#define MAX_VALUE               32768
+
+/* ewtsa_delay parameter */
+#define DELAY_THRES_MIN         1
+#define DELAY_THRES_1           4
+#define DELAY_THRES_2           9   /* msec x 90% */
+#define DELAY_THRES_3           18
+#define DELAY_THRES_4           45
+#define DELAY_THRES_5           90
+#define DELAY_THRES_6           128
+#define DELAY_THRES_MAX         255
+#define DELAY_DLPF_0            0
+#define DELAY_DLPF_1            1
+#define DELAY_DLPF_2            2
+#define DELAY_DLPF_3            3
+#define DELAY_DLPF_4            4
+#define DELAY_DLPF_5            5
+#define DELAY_DLPF_6            6
+#define DELAY_INTMIN_THRES      9
+#define DELAY_INT8K_THRES       79
+#define DELAY_THRES_FIFO        150
+
+/* ewtsa_range parameter */
+#define DYNRANGE_250            0x00
+#define DYNRANGE_500            0x01
+#define DYNRANGE_1000           0x02
+#define DYNRANGE_2000           0x03
+
+#define DATA_RATE_1             0x01
+#define DATA_RATE_5             0x05
+#define DATA_RATE_8             0x08
+#define DATA_RATE_10            0x0A
+
+/* ewtsa_sleep parameter */
+#define SLEEP_OFF               0
+#define SLEEP_ON                1
+#define SLEEP_ALLRESET          2
+
+/* ewtsa_calib parameter */
+#define BOOST_TIME_500MS        0
+#define BOOST_TIME_300MS        1
+#define BOOST_TIME_200MS        2
+#define BOOST_TIME_100MS        3
+#define BOOST_FS_48KHZ          0
+#define BOOST_FS_16KHZ          1
+#define HPF_001HZ              0
+#define HPF_002HZ              1
+#define MASK_CLIP               0
+#define MASK_NON_CLIP           1
+#define THRESHOLD_ON            0
+#define THRESHOLD_OFF           1
+#define LAG_NON                 0
+#define LAG_5SMP                1
+#define LAG_10SMP               2
+#define LAG_20SMP               3
+#define W1_THRES_LEVEL_2DPS     0
+#define W1_THRES_LEVEL_5DPS     1
+#define W1_THRES_LEVEL_10DPS    2
+#define W1_THRES_LEVEL_15DPS    3
+#define REFERENCE_WAIT          16
+#define W1_THRES_CENTER_COEF    25000
+#define CALIB_FS_62_5HZ         0
+#define CALIB_FS_31_25HZ        1
+
+/* ewtsa_configuration parameter */
+#define BYPASS_MODE           0
+#define FIFO_MODE             1
+#define FIFO_MAX              32
+#define FIFO_MIN_DELAY        5
+#define MAP_NAME_SIZE         4
+#define INTERFACE_NAME_SIZE   3
+#define CMD_SIZE_3            3
+#define CMD_SIZE_4            4
+#define THRES_CENTER_MIN      0
+#define THRES_CENTER_MAX      359
+#define THRES_CENTER_INIT_X   160
+#define THRES_CENTER_INIT_Y   160
+#define THRES_CENTER_INIT_Z   160
+
+/* EWTSA_system_restart parameter */
+#define RST_REG_INIT_OFF      0x00
+#define RST_REG_INIT_RANGE    0x01
+#define RST_REG_INIT_DELAY    0x02
+#define RST_REG_INIT_ALL      0xFF
+
+/* event mode */
+#define EWTSA_POLLING_MODE    0
+#define EWTSA_INTERUPT_MODE   1
+
+/* ewtsa register address */
+#define REG_SLAD                0x00
+#define REG_FIFO_DRDY           0x10
+#define REG_FIFO_CTRL1          0x13
+#define REG_FIFO_CTRL2          0x14
+#define REG_DATA_RATE           0x15
+#define REG_FS_DLPF_CTRL        0x16
+#define REG_INT_CTRL            0x17
+#define REG_CTRL_REG2           0x18
+#define REG_CTRL_REG3           0x19
+#define REG_INT_STAT            0x1A
+#define REG_TEMP_H              0x1B
+#define REG_TEMP_L              0x1C
+#define REG_OUTX_H              0x1D
+#define REG_OUTX_L              0x1E
+#define REG_OUTY_H              0x1F
+#define REG_OUTY_L              0x20
+#define REG_OUTZ_H              0x21
+#define REG_OUTZ_L              0x22
+#define REG_CTRL_REG5           0x24
+#define REG_REFERENCE           0x25
+#define REG_STATUS_REG          0x27
+#define REG_DIGITAL_CAL         0x29
+#define REG_DIAG_CTRL           0x2B
+#define REG_FIFO_DM             0x2F
+#define REG_DIAG_MONI           0x39
+#define REG_SLEEP_CTRL          0x3E
+#define REG_W1THX_H             0x46
+#define REG_W1THX_L             0x47
+#define REG_W1THY_H             0x48
+#define REG_W1THY_L             0x49
+#define REG_W1THZ_H             0x4A
+#define REG_W1THZ_L             0x4B
+#define REG_SOC_CNT1            0x4C
+#define REG_SOC_CNT2            0x4D
+#define REG_SLFSLP_CNT          0x4F
+#define REG_SPITYPE             0x60
+#define REG_MBURST_ALL          0xFF
+
+/* ewtsa register map2 address */
+#define REG2_CTRL_REG1          0x20
+
+/* ewtsa register param */
+#define INT_CTRL_WTMON_ENABLE   0x0D
+#define INT_CTRL_WTMON_DISABLE  0x00
+#define DIGITAL_CAL_ENABLE      0x00
+#define DIGITAL_CAL_DISABLE     0x01
+#define SLEEP_CTRL_ACTIVATE     0x44
+#define SLEEP_CTRL_SLEEP        0x04
+#define SLEEP_CTRL_ALLRSTSLEEP  0x00
+#define SLEEP_CTRL_LOGIC_RST    0x80
+#define SOC_CNT1_BOOST_ON       0x01
+#define SOC_CNT1_WIN_DIS        0x70
+#define SOC_CNT2_SOCCLK_ON      0x40
+#define SOC_CNT2_SOCCLK_OFF     0x00
+#define INT_CTRL_INT_ENABLE     0x01
+#define INT_CTRL_INT_DISABLE    0x00
+#define INT_CTRL_INT_WTMON_EN   0x08
+#define CTRL_REG2_REF_MODE      0x10
+#define CTRL_REG2_NOR_MODE      0x60
+#define CTRL_REG2_HPCF          0x09
+#define CTRL_REG5_FIFO_EN       0x53
+#define CTRL_REG5_INIT          0x13
+#define FIFO_DRDY_DITH_EN       0x02
+#define FIFO_DRDY_INIT          0x17
+#define CTRL_REG3_WTM_DIS       0x00
+#define CTRL_REG3_WTM_EN        0x04
+#define STATUS_REG_OVERRUN      0xF0
+#define FIFO_CTRL1_CLEAR        0x02
+
+/* ewtsa register map2 param */
+#define CTRL_REG1_SLEEP         0x07
+#define CTRL_REG1_ACTIVATE      0x0F
+
+/* ewtsa interrupt control */
+#define EWSTA_INT_CLEAR         0x00
+#define EWSTA_INT_SKIP          0x01
+
+/* EWTSA_set_calibration param */
+#define EWTSA_RANGE_0           250
+#define EWTSA_RANGE_1           500
+#define EWTSA_RANGE_2           1000
+#define EWTSA_RANGE_3           2000
+#define EWTSA_BOOST_TIME_0      500
+#define EWTSA_BOOST_TIME_1      300
+#define EWTSA_BOOST_TIME_2      200
+#define EWTSA_BOOST_TIME_3      100
+#define EWTSA_W1_THRES_LV_0     2
+#define EWTSA_W1_THRES_LV_1     5
+#define EWTSA_W1_THRES_LV_2     10
+#define EWTSA_W1_THRES_LV_3     15
+
+/* init param */
+#define SLEEP_INIT_VAL       SLEEP_ALLRESET
+#define FIFO_TYPE_INIT_VAL   BYPASS_MODE
+#define DELAY_INIT_VAL       DELAY_THRES_1
+#define RANGE_INIT_VAL       DYNRANGE_1000
+#define DLPF_INIT_VAL        DELAY_DLPF_2
+#define CALIB_FUNC_INIT_VAL  EWTSA_ON
+#if GYRO_VER3_ES4
+#define CALIB_BTIM_INIT_VAL  BOOST_TIME_100MS
+#else
+#define CALIB_BTIM_INIT_VAL  BOOST_TIME_500MS
+#endif
+#define CALIB_FS_INIT_VAL    CALIB_FS_62_5HZ
+#define CALIB_RST_INIT_VAL   EWTSA_ON
+#define CALIB_BFS_INIT_VAL   BOOST_FS_48KHZ
+#define CALIB_CLK_INIT_VAL   EWTSA_ON
+#define CALIB_HPF_INIT_VAL   HPF_002HZ
+#if GYRO_VER3_ES4
+#define CALIB_LAG_INIT_VAL   LAG_5SMP
+#else
+#define CALIB_LAG_INIT_VAL   LAG_10SMP
+#endif
+#define W1_FUNC_INIT_VAL     THRESHOLD_ON
+#define W2_FUNC_INIT_VAL     THRESHOLD_OFF
+#if GYRO_VER3_ES4
+#define W1_LV_INIT_VAL       W1_THRES_LEVEL_5DPS
+#define W1_MASK_INIT_VAL     MASK_CLIP
+#else
+#define W1_LV_INIT_VAL       W1_THRES_LEVEL_15DPS
+#define W1_MASK_INIT_VAL     MASK_NON_CLIP
+#endif
+
+/* declarations */
+struct ewtsa_t {
+    struct i2c_client *client;
+    struct input_dev *input_dev;
+    struct workqueue_struct *workqueue;
+    struct delayed_work input_work;
+    struct mutex mlock;
+    spinlock_t slock;
+    unsigned long delay;
+    signed short  fifo_lastdata[4];
+    unsigned short w1_thres_x;
+    unsigned short w1_thres_y;
+    unsigned short w1_thres_z;
+    unsigned char event;
+    unsigned char range;
+    unsigned char sleep;
+    unsigned char dlpf;
+    unsigned char calib;
+    unsigned char calib_fs;
+    unsigned char calib_rst;
+    unsigned char calib_boost_tm;
+    unsigned char calib_boost_fs;
+    unsigned char fifo_mode;
+    unsigned char fifo_num;
+    unsigned char fifo_data_flag;
+    unsigned char reset_param;
+    unsigned char int_skip;
+    unsigned char calib_alway;
+    unsigned char hpf;
+    unsigned char w1_datamask;
+    unsigned char w1_thres_en;
+    unsigned char w2_thres_en;
+    unsigned char offset_lag;
+    unsigned char w1_thres_level;
+    unsigned char reserved;
+};
+
+static int __init init_ewtsa(void);
+static void __exit exit_ewtsa(void);
+static ssize_t ewtsa_sleep_show(struct device *dev, struct device_attribute *attr, char *buf);
+static ssize_t ewtsa_sleep_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t ewtsa_delay_show(struct device *dev, struct device_attribute *attr, char *buf);
+static ssize_t ewtsa_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t ewtsa_range_show(struct device *dev, struct device_attribute *attr, char *buf);
+static ssize_t ewtsa_range_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t ewtsa_calib_show(struct device *dev, struct device_attribute *attr, char *buf);
+static ssize_t ewtsa_calib_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t ewtsa_config_show(struct device *dev, struct device_attribute *attr, char *buf);
+static ssize_t ewtsa_config_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
+static int EWTSA_probe(struct i2c_client *client, const struct i2c_device_id *id);
+static int EWTSA_remove(struct i2c_client *client);
+static int EWTSA_suspend(struct i2c_client *client, pm_message_t mesg);
+static int EWTSA_resume(struct i2c_client *client);
+static void EWTSA_report_abs(struct ewtsa_t *ewt);
+static void EWTSA_dev_poll(struct work_struct *work);
+static void EWTSA_input_work_func(struct work_struct *work);
+#if USE_GPIO_DRDY_PIN
+static irqreturn_t EWTSA_interrupt(int irq, void *dev_id);
+#endif
+static void EWTSA_system_restart(struct ewtsa_t *ewtsa);
+static void EWTSA_set_calibration(struct ewtsa_t *ewtsa);
+
+static struct device_attribute ewtsa_sleep_attr = {
+    .attr = {
+         .name = "ewtsa_sleep",
+         .mode = S_IRUGO | S_IWUSR,
+        },
+    .show = ewtsa_sleep_show,
+    .store = ewtsa_sleep_store,
+};
+
+static struct device_attribute ewtsa_delay_attr = {
+    .attr = {
+        .name = "ewtsa_delay",
+        .mode = S_IRUGO | S_IWUSR,
+    },
+    .show = ewtsa_delay_show,
+    .store = ewtsa_delay_store,
+};
+
+static struct device_attribute ewtsa_range_attr = {
+    .attr = {
+        .name = "ewtsa_range",
+        .mode = S_IRUGO | S_IWUSR,
+    },
+    .show = ewtsa_range_show,
+    .store = ewtsa_range_store,
+};
+
+static struct device_attribute ewtsa_calib_attr = {
+    .attr = {
+        .name = "ewtsa_calib",
+        .mode = S_IRUGO | S_IWUSR,
+    },
+    .show = ewtsa_calib_show,
+    .store = ewtsa_calib_store,
+};
+
+static struct device_attribute ewtsa_config_attr = {
+    .attr = {
+        .name = "ewtsa_configuration",
+        .mode = S_IRUGO | S_IWUSR,
+    },
+    .show = ewtsa_config_show,
+    .store = ewtsa_config_store,
+};
+
+static const struct i2c_device_id ewtsa_id[] = {
+    {"ewtsa", 0},
+    {{0}, 0}
+};
+
+MODULE_DEVICE_TABLE(i2c, ewtsa_id);
+
+static struct i2c_driver i2c_ewtsa_driver = {
+    .driver = {
+           .name = "ewtsa",
+           },
+    .probe = EWTSA_probe,
+    .remove = EWTSA_remove,
+    .suspend = EWTSA_suspend,
+    .resume  = EWTSA_resume,
+    .id_table = ewtsa_id,
+};
+
+/* show the sleep mode */
+static ssize_t ewtsa_sleep_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    struct i2c_client *client;
+    struct ewtsa_t *ewtsa;
+#if !GYRO_VER3_ES1
+    int ret;
+    unsigned char val;
+#endif /* GYRO_VER3_ES1 */
+
+    if (dev == NULL) {
+        printk(KERN_INFO "struct device null pointer\n");
+        return -EIO;
+    }
+    client = to_i2c_client(dev);
+
+    if (client == NULL) {
+        printk(KERN_INFO "struct i2c_client null pointer\n");
+        return -EIO;
+    }
+    ewtsa = i2c_get_clientdata(client);
+
+    /* output buffer check */
+    if (buf == NULL) {
+        dev_err(&client->dev, "buf pointer null!\n");
+        return -EIO;
+    }
+
+#if GYRO_VER3_ES1
+    return sprintf(buf, "%d\n", ewtsa->sleep);
+#else /* GYRO_VER3_ES1 */
+    ret = i2c_smbus_read_byte_data(ewtsa->client, REG_SLEEP_CTRL);
+    if (ret < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SLEEP_CTRL read err(ret = %d)\n", ret);
+        return ret;
+    }
+    val = (unsigned char)ret;
+
+    /* REG_SLEEP_CTRL register value check */
+    if ((val & SLEEP_CTRL_ACTIVATE) == SLEEP_CTRL_ACTIVATE) {
+        val = SLEEP_OFF;
+    }
+    else if ((val & SLEEP_CTRL_SLEEP) == SLEEP_CTRL_SLEEP) {
+        val = SLEEP_ON;
+    }
+    else {
+        val = SLEEP_ALLRESET;
+    }
+
+    return sprintf(buf, "%d\n", val);
+#endif /* GYRO_VER3_ES1 */
+}
+
+/* Set the sleep mode */
+static ssize_t ewtsa_sleep_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    u8 reg;
+    struct i2c_client *client;
+    struct ewtsa_t *ewtsa;
+    unsigned char val;
+    unsigned char before_sleep;
+    s32 ret;
+#if GYRO_VER3_ES1 || USE_GPIO_DRDY_PIN
+    int err;
+#endif /* GYRO_VER3_ES1 */
+    long           chk_param;
+    unsigned long  l_flags = 0;
+#if GYRO_VER3_ES1
+    unsigned char map2_flag = EWTSA_OFF;
+#endif /* GYRO_VER3_ES1 */
+
+    if (dev == NULL) {
+        printk(KERN_INFO "struct device null pointer\n");
+        return -EIO;
+    }
+    client = to_i2c_client(dev);
+
+    if (client == NULL) {
+        printk(KERN_INFO "struct i2c_client null pointer\n");
+        return -EIO;
+    }
+    ewtsa = i2c_get_clientdata(client);
+
+    /* input buffer check */
+    if (buf == NULL) {
+        dev_err(&client->dev, "buf pointer null!\n");
+        return -EIO;
+    }
+
+    chk_param = simple_strtol(buf, NULL, 10);
+    if ((chk_param < SLEEP_OFF) || (chk_param >SLEEP_ALLRESET)) {
+        dev_err(&ewtsa->client->dev, "invalid value = %ld\n", chk_param);
+        return -EINVAL;
+    }
+    val = (unsigned char)chk_param;
+
+    dev_info(&ewtsa->client->dev, "set SLEEP = %d\n", val);
+
+#if GYRO_VER3_ES1
+    /* if current status is same */
+    if (ewtsa->sleep == val) {
+        return count;
+    }
+#else /* GYRO_VER3_ES1 */
+    ret = i2c_smbus_read_byte_data(ewtsa->client, REG_SLEEP_CTRL);
+    if (ret < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SLEEP_CTRL read err(ret = %d)\n", ret);
+        return ret;
+    }
+    reg = (u8)ret;
+
+    /* REG_SLEEP_CTRL register value check */
+    if ((reg & SLEEP_CTRL_ACTIVATE) == SLEEP_CTRL_ACTIVATE) {
+        reg = SLEEP_OFF;
+    }
+    else if ((reg & SLEEP_CTRL_SLEEP) == SLEEP_CTRL_SLEEP) {
+        reg = SLEEP_ON;
+    }
+    else {
+        reg = SLEEP_ALLRESET;
+    }
+
+    /* if current status is same */
+    if (reg == val) {
+        return count;
+    }
+#endif /* GYRO_VER3_ES1 */
+
+    before_sleep = ewtsa->sleep;
+    switch(val)
+    {
+        case SLEEP_OFF:
+#if GYRO_VER3_ES1
+            if (ewtsa->sleep == SLEEP_ON) {
+                reg = CTRL_REG1_ACTIVATE;
+                map2_flag = EWTSA_ON;
+            }
+            else {
+                reg = SLEEP_CTRL_ACTIVATE;
+            }
+#else /* GYRO_VER3_ES1 */
+            reg = SLEEP_CTRL_ACTIVATE;
+#endif /* GYRO_VER3_ES1 */
+            break;
+        case SLEEP_ON:
+            if (ewtsa->sleep == SLEEP_ALLRESET) {
+                return count;
+            }
+            reg = SLEEP_CTRL_SLEEP;
+            ewtsa->calib_rst = EWTSA_ON; 
+            break;
+        default:                                 /* SLEEP_ALLRESET */
+            reg = SLEEP_CTRL_ALLRSTSLEEP;
+            ewtsa->calib_rst = EWTSA_ON;
+            ewtsa->reset_param = RST_REG_INIT_ALL;
+            break;
+    }
+
+    if (ewtsa->event != EWTSA_POLLING_MODE) {
+        /* disable interrupt */
+        ret = i2c_smbus_write_byte_data(ewtsa->client, REG_INT_CTRL, INT_CTRL_INT_DISABLE);
+        if (ret < 0) 
+        {
+            dev_err(&ewtsa->client->dev, "REG_INT_CTRL write err(data = 0x%02x, ret = %d)\n", INT_CTRL_INT_DISABLE, ret);
+            return ret;
+        }
+    }
+
+    dev_info(&ewtsa->client->dev, "set reg = 0x%02x\n", reg);
+#if GYRO_VER3_ES1
+    if (map2_flag == EWTSA_ON) {
+        ret = i2c_smbus_write_byte_data(ewtsa->client, REG2_CTRL_REG1, reg);
+    }
+    else {
+        ret = i2c_smbus_write_byte_data(ewtsa->client, REG_SLEEP_CTRL, reg);
+    }
+#else /* GYRO_VER3_ES1 */
+    ret = i2c_smbus_write_byte_data(ewtsa->client, REG_SLEEP_CTRL, reg);
+#endif /* GYRO_VER3_ES1 */
+    if (ret < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SLEEP_CTRL write err(data = 0x%02x, ret = %d)\n", reg, ret);
+        return ret;
+    }
+    ewtsa->sleep = val;
+
+    if (val != SLEEP_OFF) {
+        if (ewtsa->event == EWTSA_POLLING_MODE) {
+            cancel_delayed_work(&ewtsa->input_work);
+        }
+    }
+    else {
+        ret = i2c_smbus_write_byte_data(ewtsa->client, REG_DIAG_CTRL, DIAG_ENABLE);
+        if (ret < 0) {
+            dev_err(&ewtsa->client->dev, "REG_DIAG_CTRL write err(data = 0x%02x, ret = %d)\n", DIAG_ENABLE, ret);
+            return ret;
+        }
+        if (ewtsa->event == EWTSA_POLLING_MODE) {
+            ret = i2c_smbus_write_byte_data(ewtsa->client, REG_INT_CTRL, INT_CTRL_WTMON_DISABLE); /* No INT */
+            if (ret < 0) {
+                dev_err(&ewtsa->client->dev, "REG_INT_CTRL write err(data = 0x%02x, ret = %d)\n", INT_CTRL_WTMON_DISABLE, ret);
+                return ret;
+            }
+        }
+
+        if (ewtsa->calib_rst == EWTSA_ON) {
+            EWTSA_system_restart(ewtsa);
+        }
+        if (ewtsa->event == EWTSA_POLLING_MODE) {
+            /* polling timer start */
+            queue_delayed_work(ewtsa->workqueue,
+                &ewtsa->input_work,
+                msecs_to_jiffies(ewtsa->delay));
+        }
+    }
+
+    if (ewtsa->event == EWTSA_POLLING_MODE) {
+        mutex_lock(&ewtsa->mlock);
+        input_report_abs(ewtsa->input_dev, ABS_RY, -1);
+        input_sync(ewtsa->input_dev);
+        mutex_unlock(&ewtsa->mlock);
+    }
+    else {
+        spin_lock_irqsave(&ewtsa->slock, l_flags);
+        input_report_abs(ewtsa->input_dev, ABS_RY, -1);
+        input_sync(ewtsa->input_dev);
+        spin_unlock_irqrestore(&ewtsa->slock, l_flags);
+
+        if (val == SLEEP_OFF) {
+            /* enable interrupt */
+#if USE_GPIO_DRDY_PIN
+            err = gpio_request(DRDY_PIN, "DRDY");
+            err += gpio_direction_input(DRDY_PIN);
+            err += request_threaded_irq(gpio_to_irq(DRDY_PIN), NULL, EWTSA_interrupt, IRQF_TRIGGER_RISING, DEVICE_NAME, ewtsa);
+            if (err != 0) {
+                dev_err(&ewtsa->client->dev, "request_irq err(%d)\n", err);
+                return err;
+            }
+#endif
+
+            ewtsa->fifo_data_flag = EWTSA_OFF;
+            memset(ewtsa->fifo_lastdata, 0x00, sizeof(ewtsa->fifo_lastdata));
+            ewtsa->int_skip = EWSTA_INT_SKIP;
+            if (ewtsa->fifo_mode == BYPASS_MODE) {
+                reg = (u8)INT_CTRL_INT_ENABLE;
+            }
+            else {
+                reg = (u8)(INT_CTRL_INT_ENABLE | INT_CTRL_INT_WTMON_EN);
+            }
+            ret = i2c_smbus_write_byte_data(ewtsa->client, REG_INT_CTRL, reg);
+            if (ret < 0) {
+                dev_err(&ewtsa->client->dev, "REG_INT_CTRL write err(data = 0x%02x, ret = %d)\n", reg, ret);
+                return ret;
+            }
+        }
+        else
+        {
+            if (before_sleep == SLEEP_OFF) {
+#if USE_GPIO_DRDY_PIN
+                free_irq(gpio_to_irq(DRDY_PIN), ewtsa);
+                gpio_free(DRDY_PIN);
+#endif
+            }
+        }
+    }
+
+    return count;
+}
+
+/* Show the LPF settings */
+static ssize_t ewtsa_delay_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    struct i2c_client *client;
+    struct ewtsa_t *ewtsa;
+
+    if (dev == NULL) {
+        printk(KERN_INFO "struct device null pointer\n");
+        return -EIO;
+    }
+    client = to_i2c_client(dev);
+
+    if (client == NULL) {
+        printk(KERN_INFO "struct i2c_client null pointer\n");
+        return -EIO;
+    }
+    ewtsa = i2c_get_clientdata(client);
+
+    /* output buffer check */
+    if (buf == NULL) {
+        dev_err(&client->dev, "buf pointer null!\n");
+        return -EIO;
+    }
+
+    return sprintf(buf, "%ld\n", ewtsa->delay);
+}
+
+/* Set the LPF settings*/
+static ssize_t ewtsa_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    struct i2c_client *client;
+    struct ewtsa_t *ewtsa;
+    unsigned long delay;
+    unsigned char val;
+    unsigned char number;
+    u8            smpl;
+    int           err;
+    unsigned char reg;
+    unsigned char fifo_type;
+
+    if (dev == NULL) {
+        printk(KERN_INFO "struct device null pointer\n");
+        return -EIO;
+    }
+    client = to_i2c_client(dev);
+
+    if (client == NULL) {
+        printk(KERN_INFO "struct i2c_client null pointer\n");
+        return -EIO;
+    }
+    ewtsa = i2c_get_clientdata(client);
+
+    /* input buffer check */
+    if (buf == NULL) {
+        dev_err(&client->dev, "buf pointer null!\n");
+        return -EIO;
+    }
+    err = strict_strtoul(buf, 0, &delay);
+    if (err != 0) {
+        dev_err(&ewtsa->client->dev, "strict_strtoul err(ret = %d)\n", err);
+        return err;
+    }
+
+    if (delay == ewtsa->delay) {
+        return count;
+    }
+
+    if ((delay < DELAY_THRES_MIN) || (delay > DELAY_THRES_MAX)) {
+        dev_err(&ewtsa->client->dev, "param err(ret = %ld)\n", delay);
+        return -EINVAL;
+    }
+
+    dev_info(&ewtsa->client->dev, "Delay = %ld\n", delay);
+
+    if (ewtsa->sleep == SLEEP_OFF) {
+        if (ewtsa->event == EWTSA_POLLING_MODE) {
+            cancel_delayed_work(&ewtsa->input_work);
+        }
+        else {
+            /* disable interrupt */
+            err = i2c_smbus_write_byte_data(ewtsa->client, REG_INT_CTRL, INT_CTRL_INT_DISABLE);
+            if (err < 0) {
+                dev_err(&ewtsa->client->dev, "REG_INT_CTRL write err(data = 0x%02x, ret = %d)\n", INT_CTRL_INT_DISABLE, err);
+                return err;
+            }
+        }
+
+        if (ewtsa->event == EWTSA_POLLING_MODE) {
+            fifo_type = BYPASS_MODE;
+        }
+        else {
+            fifo_type = ewtsa->fifo_mode;
+        }
+
+        if (fifo_type == BYPASS_MODE) {
+            if (delay < DELAY_THRES_4) {
+                if (delay >= DELAY_THRES_3) {
+                    val = DELAY_DLPF_3;
+                } else {
+                    val = DELAY_DLPF_2;
+                }
+            } else {
+                if (delay >= DELAY_THRES_6) {
+                    val = DELAY_DLPF_6;
+                } else if (delay >= DELAY_THRES_5) {
+                    val = DELAY_DLPF_5;
+                } else {
+                    val = DELAY_DLPF_4;
+                }
+            }
+        }
+        else {
+            if (delay <= DELAY_THRES_FIFO) {
+                val = DELAY_DLPF_1;
+            }
+            else {
+                val = DELAY_DLPF_2;
+            }
+        }
+
+        reg = (unsigned char)((unsigned char)(ewtsa->range << 3) | val );
+        dev_info(&ewtsa->client->dev, "FS_DLPF = %2X\n", (unsigned int)reg);
+        err = i2c_smbus_write_byte_data(ewtsa->client, REG_FS_DLPF_CTRL, reg);
+        if (err < 0) {
+            dev_err(&ewtsa->client->dev, "REG_FS_DLPF_CTRL write err(data = 0x%02x, ret = %d)\n", reg, err);
+            return err;
+        }
+        ewtsa->dlpf = val;
+
+        err = i2c_smbus_write_byte_data(ewtsa->client, REG_CTRL_REG5, CTRL_REG5_INIT);
+        if (err < 0) {
+            dev_err(&ewtsa->client->dev, "REG_CTRL_REG5 write err(data = 0x%02x, ret = %d)\n", CTRL_REG5_INIT, err);
+            return err;
+        }
+
+        if (fifo_type != BYPASS_MODE) {
+            reg = FIFO_DRDY_DITH_EN;
+        }
+        else {
+            dev_info(&ewtsa->client->dev, "FIFO_CTR = %2X\n", fifo_type);
+            reg = (unsigned char)(fifo_type << 5);
+            err = i2c_smbus_write_byte_data(ewtsa->client, REG_FIFO_CTRL2, reg);
+            if (err < 0) {
+                dev_err(&ewtsa->client->dev, "REG_FIFO_CTRL2 write err(data = 0x%02x, ret = %d)\n", reg, err);
+                return err;
+            }
+            reg = FIFO_DRDY_INIT;
+        }
+
+        err = i2c_smbus_write_byte_data(ewtsa->client, REG_FIFO_DRDY, reg);
+        if (err < 0) {
+            dev_err(&ewtsa->client->dev, "REG_FIFO_DRDY write err(data = 0x%02x, ret = %d)\n", reg, err);
+            return err;
+        }
+
+        if (ewtsa->event == EWTSA_POLLING_MODE) {
+            smpl = DATA_RATE_1 - 1; /* SMPL = 0 */
+            dev_info(&ewtsa->client->dev, "SMPL+1 = %2X\n", smpl);
+            err = i2c_smbus_write_byte_data(ewtsa->client, REG_DATA_RATE, smpl);
+            if (err < 0) {
+                dev_err(&ewtsa->client->dev, "REG_DATA_RATE write err(data = 0x%02x, ret = %d)\n", smpl, err);
+                return err;
+            }
+            ewtsa->delay = delay;
+            ewtsa->reset_param &= (unsigned char)~RST_REG_INIT_DELAY;
+            EWTSA_system_restart(ewtsa);
+
+            queue_delayed_work(ewtsa->workqueue,
+                &ewtsa->input_work,
+                msecs_to_jiffies(ewtsa->delay));
+        }
+        else {
+            if (fifo_type == BYPASS_MODE) {
+                if (delay <= DELAY_THRES_2) {
+                    smpl = DELAY_INTMIN_THRES;
+                }
+                else {
+                    smpl = (unsigned char)(delay - 1);
+                }
+                ewtsa->fifo_num = 1;
+            }
+            else {
+                if (delay <= DELAY_THRES_FIFO) {
+                    if (delay > FIFO_MIN_DELAY) {
+                        number = (unsigned char)(delay / DATA_RATE_5);
+                        if ((delay % DATA_RATE_5) != 0) {
+                            number++;
+                        }
+                    }
+                    else {
+                        number = 2;
+                    }
+                    smpl = DATA_RATE_5 - 1; /* SMPL = 4 */
+                }
+                else {
+                    number = (unsigned char)(delay / DATA_RATE_10);
+                    if ((delay % DATA_RATE_10) != 0) {
+                        number++;
+                    }
+                    smpl = DATA_RATE_10 - 1; /* SMPL = 9 */
+                }
+
+                reg = (unsigned char)(fifo_type << 5);
+                reg |= number;
+                err = i2c_smbus_write_byte_data(ewtsa->client, REG_FIFO_CTRL2, reg);
+                if (err < 0) {
+                    dev_err(&ewtsa->client->dev, "REG_FIFO_CTRL2 write err(data = 0x%02x, ret = %d)\n", reg, err);
+                    return err;
+                }
+                ewtsa->fifo_num = number;
+
+                err = i2c_smbus_write_byte_data(ewtsa->client, REG_CTRL_REG3, CTRL_REG3_WTM_EN);
+                if (err < 0) {
+                    dev_err(&ewtsa->client->dev, "REG_CTRL_REG3 write err(data = 0x%02x, ret = %d)\n", CTRL_REG3_WTM_EN, err);
+                    return err;
+                }
+
+                err = i2c_smbus_write_byte_data(ewtsa->client, REG_CTRL_REG5, CTRL_REG5_FIFO_EN);
+                if (err < 0) {
+                    dev_err(&ewtsa->client->dev, "REG_CTRL_REG5 write err(data = 0x%02x, ret = %d)\n", CTRL_REG5_FIFO_EN, err);
+                    return err;
+                }
+            }
+            dev_info(&ewtsa->client->dev, "SMPL+1 = %2X\n", smpl);
+            err = i2c_smbus_write_byte_data(ewtsa->client, REG_DATA_RATE, smpl);
+            if (err < 0) {
+                dev_err(&ewtsa->client->dev, "REG_DATA_RATE write err(data = 0x%02x, ret = %d)\n", smpl, err);
+                return err;
+            }
+            ewtsa->delay = delay;
+            ewtsa->reset_param &= (unsigned char)~RST_REG_INIT_DELAY;
+            EWTSA_system_restart(ewtsa);
+
+            /* enable interrupt */
+            ewtsa->fifo_data_flag = EWTSA_OFF;
+            memset(ewtsa->fifo_lastdata, 0x00, sizeof(ewtsa->fifo_lastdata));
+            ewtsa->int_skip = EWSTA_INT_SKIP;
+            if (fifo_type == BYPASS_MODE) {
+                reg = (u8)INT_CTRL_INT_ENABLE;
+            }
+            else {
+                reg = (u8)(INT_CTRL_INT_ENABLE | INT_CTRL_INT_WTMON_EN);
+            }
+            err = i2c_smbus_write_byte_data(ewtsa->client, REG_INT_CTRL, reg);
+            if (err < 0) {
+                dev_err(&ewtsa->client->dev, "REG_INT_CTRL write err(data = 0x%02x, ret = %d)\n", reg, err);
+                return err;
+            }
+        }
+    }
+    else {
+        ewtsa->delay = delay;
+        ewtsa->calib_rst = EWTSA_ON;
+        ewtsa->reset_param |= RST_REG_INIT_DELAY;
+    }
+
+    return count;
+}
+
+/* Show the FS settings */
+static ssize_t ewtsa_range_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    struct i2c_client *client;
+    struct ewtsa_t *ewtsa ;
+
+    if (dev == NULL) {
+        printk(KERN_INFO "struct device null pointer\n");
+        return -EIO;
+    }
+    client = to_i2c_client(dev);
+
+    if (client == NULL) {
+        printk(KERN_INFO "struct i2c_client null pointer\n");
+        return -EIO;
+    }
+    ewtsa = i2c_get_clientdata(client);
+
+    /* output buffer check */
+    if (buf == NULL) {
+        dev_err(&client->dev, "buf pointer null!\n");
+        return -EIO;
+    }
+
+    return sprintf(buf, "%d\n", ewtsa->range);
+}
+
+/* Set the FS settings*/
+static ssize_t ewtsa_range_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    struct i2c_client *client;
+    struct ewtsa_t *ewtsa;
+    unsigned char val;
+    s32           err;
+    unsigned char rng;
+    u8            reg;
+    long          chk_param;
+
+    if (dev == NULL) {
+        printk(KERN_INFO "struct device null pointer\n");
+        return -EIO;
+    }
+    client = to_i2c_client(dev);
+
+    if (client == NULL) {
+        printk(KERN_INFO "struct i2c_client null pointer\n");
+        return -EIO;
+    }
+    ewtsa = i2c_get_clientdata(client);
+
+    /* input buffer check */
+    if (buf == NULL) {
+        dev_err(&client->dev, "buf pointer null!\n");
+        return -EIO;
+    }
+    chk_param = simple_strtol(buf, NULL, 10);
+    if ((chk_param < DYNRANGE_250) || (chk_param > DYNRANGE_2000)) {
+        dev_info(&ewtsa->client->dev, "invalid value = %ld\n", chk_param);
+        return -EINVAL;
+    }
+    val = (unsigned char)chk_param;
+
+    if (val == ewtsa->range) {
+        return count;
+    }
+
+    dev_info(&ewtsa->client->dev, "FS = %d\n", (int)val);
+    if (ewtsa->sleep == SLEEP_OFF) {
+        if (ewtsa->event != EWTSA_POLLING_MODE) {
+            /* disable interrupt */
+            err = i2c_smbus_write_byte_data(ewtsa->client, REG_INT_CTRL, INT_CTRL_INT_DISABLE);
+            if (err < 0) {
+                dev_err(&ewtsa->client->dev, "REG_INT_CTRL write err(data = 0x%02x, ret = %d)\n", INT_CTRL_INT_DISABLE, err);
+                return err;
+            }
+        }
+        rng = (unsigned char)((unsigned char)(val << 3) | ewtsa->dlpf);
+        err = i2c_smbus_write_byte_data(ewtsa->client, REG_FS_DLPF_CTRL, rng);
+        if (err < 0) {
+            dev_err(&ewtsa->client->dev, "REG_FS_DLPF_CTRL write err(data = 0x%02x, ret = %d)\n", rng, err);
+            return err;
+        }
+        ewtsa->range = val;
+        ewtsa->reset_param &= (unsigned char)~RST_REG_INIT_RANGE;
+        if (ewtsa->event == EWTSA_POLLING_MODE) {
+            cancel_delayed_work(&ewtsa->input_work);
+            EWTSA_system_restart(ewtsa);
+            queue_delayed_work(ewtsa->workqueue,
+                &ewtsa->input_work,
+                msecs_to_jiffies(ewtsa->delay));
+        }
+        else {
+            EWTSA_system_restart(ewtsa);
+
+            /* enable interrupt */
+            ewtsa->fifo_data_flag = EWTSA_OFF;
+            memset(ewtsa->fifo_lastdata, 0x00, sizeof(ewtsa->fifo_lastdata));
+            ewtsa->int_skip = EWSTA_INT_SKIP;
+            if (ewtsa->fifo_mode == BYPASS_MODE) {
+                reg = (u8)INT_CTRL_INT_ENABLE;
+            }
+            else {
+                reg = (u8)(INT_CTRL_INT_ENABLE | INT_CTRL_INT_WTMON_EN);
+            }
+            err = i2c_smbus_write_byte_data(ewtsa->client, REG_INT_CTRL, reg);
+            if (err < 0) {
+                dev_err(&ewtsa->client->dev, "REG_INT_CTRL write err(data = 0x%02x, ret = %d)\n", reg, err);
+                return err;
+            }
+        }
+    }
+    else {
+        ewtsa->range = val;
+        ewtsa->calib_rst = EWTSA_ON;
+        ewtsa->reset_param |= RST_REG_INIT_RANGE;
+    }
+
+    return count;
+}
+
+/* Show the SELF O C settings */
+static ssize_t ewtsa_calib_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    struct i2c_client *client;
+    struct ewtsa_t *ewtsa;
+
+    if (dev == NULL) {
+        printk(KERN_INFO "struct device null pointer\n");
+        return -EIO;
+    }
+    client = to_i2c_client(dev);
+
+    if (client == NULL) {
+        printk(KERN_INFO "struct i2c_client null pointer\n");
+        return -EIO;
+    }
+    ewtsa = i2c_get_clientdata(client);
+
+    /* output buffer check */
+    if (buf == NULL) {
+        dev_err(&client->dev, "buf pointer null!\n");
+        return -EIO;
+    }
+
+    return sprintf(buf, "%d\n", ewtsa->calib);
+}
+
+/* Set the SELF O C settings*/
+static ssize_t ewtsa_calib_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    struct i2c_client *client;
+    struct ewtsa_t *ewtsa;
+    unsigned char val;
+    s32           err;
+    u8            reg;
+    long          chk_param;
+
+    if (dev == NULL) {
+        printk(KERN_INFO "struct device null pointer\n");
+        return -EIO;
+    }
+    client = to_i2c_client(dev);
+
+    if (client == NULL) {
+        printk(KERN_INFO "struct i2c_client null pointer\n");
+        return -EIO;
+    }
+    ewtsa = i2c_get_clientdata(client);
+
+    /* input buffer check */
+    if (buf == NULL) {
+        dev_err(&client->dev, "buf pointer null!\n");
+        return -EIO;
+    }
+    chk_param = simple_strtol(buf, NULL, 10);
+    if ((chk_param != EWTSA_ON) && (chk_param != EWTSA_OFF)) {
+        dev_info(&ewtsa->client->dev, "invalid value = %ld\n", chk_param);
+        return -EINVAL;
+    }
+    val = (unsigned char)chk_param;
+
+    dev_info(&ewtsa->client->dev, "SELF_O_C = %d(now = %d)\n", (int)val, ewtsa->calib);
+
+    if (ewtsa->calib == val) {
+        return count;
+    }
+
+    ewtsa->calib = val;
+    if (ewtsa->sleep == SLEEP_OFF) {
+        if (ewtsa->event == EWTSA_POLLING_MODE) {
+            cancel_delayed_work(&ewtsa->input_work);
+            EWTSA_system_restart(ewtsa);
+            queue_delayed_work(ewtsa->workqueue,
+                &ewtsa->input_work,
+                msecs_to_jiffies(ewtsa->delay));
+        }
+        else {
+            /* disable interrupt */
+            err = i2c_smbus_write_byte_data(ewtsa->client, REG_INT_CTRL, INT_CTRL_INT_DISABLE);
+            if (err < 0) {
+                dev_err(&ewtsa->client->dev, "REG_INT_CTRL write err(data = 0x%02x, ret = %d)\n", INT_CTRL_INT_DISABLE, err);
+                return err;
+            }
+
+            EWTSA_system_restart(ewtsa);
+
+            /* enable interrupt */
+            ewtsa->fifo_data_flag = EWTSA_OFF;
+            memset(ewtsa->fifo_lastdata, 0x00, sizeof(ewtsa->fifo_lastdata));
+            ewtsa->int_skip = EWSTA_INT_SKIP;
+            if (ewtsa->fifo_mode == BYPASS_MODE) {
+                reg = (u8)INT_CTRL_INT_ENABLE;
+            }
+            else {
+                reg = (u8)(INT_CTRL_INT_ENABLE | INT_CTRL_INT_WTMON_EN);
+            }
+            err = i2c_smbus_write_byte_data(ewtsa->client, REG_INT_CTRL, reg);
+            if (err < 0) {
+                dev_err(&ewtsa->client->dev, "REG_INT_CTRL write err(data = 0x%02x, ret = %d)\n", reg, err);
+                return err;
+            }
+        }
+    }
+    else {
+        ewtsa->calib_rst = EWTSA_ON;
+    }
+
+    return count;
+}
+
+/* Show the gyro configurations */
+static ssize_t ewtsa_config_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+    struct i2c_client *l_client;
+    struct ewtsa_t *ewtsa;
+    int            ret;
+    ssize_t        ret_len = 0;
+
+    if (dev == NULL) {
+        printk(KERN_INFO "struct device null pointer\n");
+        return -EIO;
+    }
+    l_client = to_i2c_client(dev);
+
+    if (l_client == NULL) {
+        printk(KERN_INFO "struct i2c_client null pointer\n");
+        return -EIO;
+    }
+    ewtsa = i2c_get_clientdata(l_client);
+
+    /* output buffer check */
+    if (buf == NULL) {
+        dev_err(&ewtsa->client->dev, "buf pointer null!\n");
+        return -EIO;
+    }
+
+#if GYRO_REGISTER_MAP2
+    ret = sprintf(buf+ret_len, "MAP2;");
+#else /* GYRO_REGISTER_MAP2 */
+    ret = sprintf(buf+ret_len, "MAP1;");
+#endif /* GYRO_REGISTER_MAP2 */
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+#if GYRO_SPI_INTERFACE
+    ret = sprintf(buf+ret_len, "SPI;");
+#else /* GYRO_SPI_INTERFACE */
+    ret = sprintf(buf+ret_len, "I2C;");
+#endif /* GYRO_SPI_INTERFACE */
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "SLP=%d;", ewtsa->sleep);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "DLY=%ld;", ewtsa->delay);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "RNG=%d;", ewtsa->range);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "SOC=%d;", ewtsa->calib);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "SBT=%d;", ewtsa->calib_boost_tm);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "HPF=%d;", ewtsa->hpf);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "SFR=%d;", ewtsa->calib_fs);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "EVE=%d;", ewtsa->event);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "FIFO=%d;", ewtsa->fifo_mode);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "SAA=%d;", ewtsa->calib_alway);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "W1CX=%d;", ewtsa->w1_thres_x);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "W1CY=%d;", ewtsa->w1_thres_y);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "W1CZ=%d;", ewtsa->w1_thres_z);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "BFR=%d;", ewtsa->calib_boost_fs);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "OTL=%d;", ewtsa->offset_lag);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "W1L=%d;", ewtsa->w1_thres_level);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    ret = sprintf(buf+ret_len, "W1DM=%d;", ewtsa->w1_datamask);
+    if (ret >= 0) {
+        ret_len += ret;
+    }
+
+    return ret_len;
+}
+
+/* Set the gyro configurations */
+static ssize_t ewtsa_config_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+    struct i2c_client *l_client;
+    struct ewtsa_t *ewtsa;
+    char val_char[4] = {0};
+    char sleep_val[4] = {0};
+    unsigned char cmd[5] = {0};
+    unsigned char cmd_size = 0;
+    unsigned char val_size = 0;
+    unsigned char sleep_flag = EWTSA_OFF;
+    unsigned char sleep_mode = SLEEP_ALLRESET;
+    unsigned char fifo_tmp;
+    unsigned char event_tmp;
+    int           loop;
+    int           size_err;
+    unsigned long val = 0;
+    size_t        chk_cnt = 0;
+    ssize_t       sleep_ret;
+
+    if (dev == NULL) {
+        printk(KERN_INFO "struct device null pointer\n");
+        return -EIO;
+    }
+    l_client = to_i2c_client(dev);
+
+    if (l_client == NULL) {
+        printk(KERN_INFO "struct i2c_client null pointer\n");
+        return -EIO;
+    }
+    ewtsa = i2c_get_clientdata(l_client);
+
+    /* input buffer check */
+    if (buf == NULL) {
+        dev_err(&ewtsa->client->dev, "buf pointer null!\n");
+        return -EIO;
+    }
+
+    fifo_tmp = ewtsa->fifo_mode;
+    event_tmp = ewtsa->event;
+
+    if (strncmp(buf, "MAP", 3) == 0) {
+        /* get register map information */
+#if GYRO_REGISTER_MAP2
+        if (strncmp(buf, "MAP2", MAP_NAME_SIZE) != 0) {
+            dev_err(&ewtsa->client->dev, "register map unmatch!\n");
+            return -EINVAL;
+        }
+#else /* GYRO_REGISTER_MAP2 */
+        if (strncmp(buf, "MAP1", MAP_NAME_SIZE) != 0) {
+            dev_err(&ewtsa->client->dev, "register map unmatch!\n");
+            return -EINVAL;
+        }
+#endif /* GYRO_REGISTER_MAP2 */
+        buf += MAP_NAME_SIZE + 1;
+        chk_cnt += MAP_NAME_SIZE + 1;
+
+        /* get communication interface */
+#if GYRO_SPI_INTERFACE
+        if (strncmp(buf, "SPI", INTERFACE_NAME_SIZE) != 0) {
+            dev_err(&ewtsa->client->dev, "communication interface unmatch!\n");
+            return -EINVAL;
+        }
+#else /* GYRO_SPI_INTERFACE */
+        if (strncmp(buf, "I2C", INTERFACE_NAME_SIZE) != 0) {
+            dev_err(&ewtsa->client->dev, "communication interface unmatch!\n");
+            return -EINVAL;
+        }
+#endif /* GYRO_SPI_INTERFACE */
+        buf += INTERFACE_NAME_SIZE + 1;
+        chk_cnt += INTERFACE_NAME_SIZE + 1;
+    }
+
+    while (chk_cnt < count) {
+        memset(cmd, 0x00, sizeof(cmd));
+        memset(val_char, 0x00, sizeof(val_char));
+        size_err = 0;
+
+        for (loop = 0; (chk_cnt + loop) < count; loop++) {
+            if (*(buf + loop) == '=') {
+                break;
+            }
+
+            if (*(buf + loop) == ';') {
+                dev_err(&ewtsa->client->dev, "command format err\n");
+                return -EINVAL;
+            }
+        }
+
+        if ((chk_cnt + loop) >= count) {
+            break;
+        }
+
+        cmd_size = (unsigned char)loop;
+        if (cmd_size == 0) {
+            dev_err(&ewtsa->client->dev, "command nothing\n");
+            return -EINVAL;
+        }
+
+        /* command size over? */
+        if (loop > (sizeof(cmd) - 1)) {
+            size_err = EWTSA_ON;
+        }
+        else {
+            memcpy(cmd, buf, cmd_size);
+        }
+        buf += cmd_size + 1;
+        chk_cnt += cmd_size + 1;
+
+        for (loop = 0; (chk_cnt + loop) < count; loop++) {
+            if (*(buf + loop) == ';') {
+                break;
+            }
+        }
+
+        if ((chk_cnt + loop) >= count) {
+            break;
+        }
+
+        val_size = (unsigned char)loop;
+        if (val_size == 0) {
+            dev_err(&ewtsa->client->dev, "value nothing(cmd = %s)\n", cmd);
+            return -EINVAL;
+        }
+
+        if (size_err != 0) {
+            /* if command size is over, value ignore and next command check. */
+            buf += val_size + 1;
+            chk_cnt += val_size + 1;
+            continue;
+        }
+        else if (loop > (sizeof(val_char) - 1)) {
+            /* if value size is over, return format err. */
+            size_err = EWTSA_ON;
+        }
+        else {
+            memcpy(val_char, buf, val_size);
+            size_err = strict_strtoul(val_char, 10, &val);
+        }
+
+        if (size_err != 0) {
+            dev_err(&ewtsa->client->dev, "value format err(cmd = %s)\n", cmd);
+            return -EINVAL;
+        }
+        buf += val_size + 1;
+        chk_cnt += val_size + 1;
+
+        if (cmd_size == CMD_SIZE_3) {
+            if (strncmp((char*)cmd, "SLP", CMD_SIZE_3) == 0) {
+                sleep_flag = EWTSA_ON;
+                memcpy(sleep_val, val_char, sizeof(sleep_val));
+                if (val == 0) {
+                    sleep_mode = SLEEP_OFF;
+                }
+            }
+            else if (strncmp((char*)cmd, "DLY", CMD_SIZE_3) == 0) {
+                if ((val < DELAY_THRES_MIN) || (val > DELAY_THRES_MAX)) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+
+                ewtsa->delay = val;
+                ewtsa->calib_rst = EWTSA_ON;
+                ewtsa->reset_param |= RST_REG_INIT_DELAY;
+            }
+            else if (strncmp((char*)cmd, "RNG", CMD_SIZE_3) == 0) {
+                if (val > DYNRANGE_2000) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                ewtsa->range = (unsigned char)val;
+                ewtsa->calib_rst = EWTSA_ON;
+                ewtsa->reset_param |= RST_REG_INIT_RANGE;
+            }
+            else if (strncmp((char*)cmd, "SOC", CMD_SIZE_3) == 0) {
+                if ((val != EWTSA_ON) && (val != EWTSA_OFF)) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                ewtsa->calib = (unsigned char)val;
+                ewtsa->calib_rst = EWTSA_ON;
+            }
+            else if (strncmp((char*)cmd, "SBT", CMD_SIZE_3) == 0) {
+                if (val > BOOST_TIME_100MS) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                ewtsa->calib_boost_tm = (unsigned char)val;
+            }
+            else if (strncmp((char*)cmd, "HPF", CMD_SIZE_3) == 0) {
+                if ((val != HPF_001HZ) && (val != HPF_002HZ)) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                ewtsa->hpf = (unsigned char)val;
+                ewtsa->calib_rst = EWTSA_ON;
+            }
+            else if (strncmp((char*)cmd, "SFR", CMD_SIZE_3) == 0) {
+                if ((val != CALIB_FS_62_5HZ) && (val != CALIB_FS_31_25HZ)) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                ewtsa->calib_fs = (unsigned char)val;
+                ewtsa->calib_rst = EWTSA_ON;
+            }
+            else if (strncmp((char*)cmd, "EVE", CMD_SIZE_3) == 0) {
+                if ((val != EWTSA_POLLING_MODE) && (val != EWTSA_INTERUPT_MODE)) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+#if USE_GPIO_DRDY_PIN
+                event_tmp = (unsigned char)val;
+#else
+                event_tmp = (unsigned char)EWTSA_POLLING_MODE;
+#endif
+                ewtsa->calib_rst = EWTSA_ON;
+                ewtsa->reset_param = RST_REG_INIT_ALL;
+            }
+            else if (strncmp((char*)cmd, "SAA", CMD_SIZE_3) == 0) {
+                if ((val != EWTSA_ON) && (val != EWTSA_OFF)) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                ewtsa->calib_alway = (unsigned char)val;
+                ewtsa->calib_rst = EWTSA_ON;
+            }
+            else if (strncmp((char*)cmd, "BFR", CMD_SIZE_3) == 0) {
+                if ((val != BOOST_FS_48KHZ) && (val != BOOST_FS_16KHZ)) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                ewtsa->calib_boost_fs = (unsigned char)val;
+            }
+            else if (strncmp((char*)cmd, "OTL", CMD_SIZE_3) == 0) {
+                if (val > LAG_20SMP) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                ewtsa->offset_lag = (unsigned char)val;
+                ewtsa->calib_rst = EWTSA_ON;
+            }
+            else if (strncmp((char*)cmd, "W1L", CMD_SIZE_3) == 0) {
+                if (val > W1_THRES_LEVEL_15DPS) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                ewtsa->w1_thres_level = (unsigned char)val;
+                ewtsa->calib_rst = EWTSA_ON;
+            }
+            else {
+                dev_info(&ewtsa->client->dev, "unknown command(%s)\n", cmd);
+            }
+        }
+        else if (cmd_size == CMD_SIZE_4) {
+            if (strncmp((char*)cmd, "FIFO", CMD_SIZE_4) == 0) {
+                if ((val != BYPASS_MODE) && (val != FIFO_MODE)) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                fifo_tmp = (unsigned char)val;
+                ewtsa->calib_rst = EWTSA_ON;
+                ewtsa->reset_param = RST_REG_INIT_ALL;
+            }
+            else if (strncmp((char*)cmd, "W1CX", CMD_SIZE_4) == 0) {
+                if (val > THRES_CENTER_MAX) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                ewtsa->w1_thres_x = (unsigned short)val;
+                ewtsa->calib_rst = EWTSA_ON;
+            }
+            else if (strncmp((char*)cmd, "W1CY", CMD_SIZE_4) == 0) {
+                if (val > THRES_CENTER_MAX) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                ewtsa->w1_thres_y = (unsigned short)val;
+                ewtsa->calib_rst = EWTSA_ON;
+            }
+            else if (strncmp((char*)cmd, "W1CZ", CMD_SIZE_4) == 0) {
+                if (val > THRES_CENTER_MAX) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                ewtsa->w1_thres_z = (unsigned short)val;
+                ewtsa->calib_rst = EWTSA_ON;
+            }
+            else if (strncmp((char*)cmd, "W1DM", CMD_SIZE_4) == 0) {
+                if ((val != MASK_CLIP) && (val != MASK_NON_CLIP)) {
+                    dev_err(&ewtsa->client->dev, "invalid value = %ld\n", val);
+                    return -EINVAL;
+                }
+                ewtsa->w1_datamask = (unsigned char)val;
+                ewtsa->calib_rst = EWTSA_ON;
+            }
+            else {
+                dev_info(&ewtsa->client->dev, "unknown command(%s)\n", cmd);
+            }
+        }
+        else {
+            dev_info(&ewtsa->client->dev, "unknown command(%s)\n", cmd);
+        }
+    }
+
+    if (sleep_flag == EWTSA_ON) {
+        if (sleep_mode == SLEEP_OFF) {
+            /* all reset sleep mode */
+            val_char[0] = '2';
+            val_char[1] = '\0';
+            sleep_ret = ewtsa_sleep_store(dev, attr, val_char, 1);
+            if (sleep_ret != 1) {
+                dev_err(&ewtsa->client->dev, "ewtsa_sleep_store err(%d)\n", sleep_ret);
+                return sleep_ret;
+            }
+            ewtsa->event = event_tmp;
+            ewtsa->fifo_mode = fifo_tmp;
+        }
+        sleep_ret = ewtsa_sleep_store(dev, attr, sleep_val, sizeof(sleep_val));
+        if (sleep_ret != sizeof(sleep_val)) {
+            dev_err(&ewtsa->client->dev, "ewtsa_sleep_store err(%d)\n", sleep_ret);
+            return sleep_ret;
+        }
+        ewtsa->event = event_tmp;
+        ewtsa->fifo_mode = fifo_tmp;
+    }
+    else {
+        if (ewtsa->calib_rst == EWTSA_ON) {
+            sleep_mode = ewtsa->sleep;
+
+            /* all reset sleep mode */
+            val_char[0] = '2';
+            val_char[1] = '\0';
+            sleep_ret = ewtsa_sleep_store(dev, attr, val_char, 1);
+            if (sleep_ret != 1) {
+                dev_err(&ewtsa->client->dev, "ewtsa_sleep_store err(%d)\n", sleep_ret);
+                return sleep_ret;
+            }
+
+            ewtsa->event = event_tmp;
+            ewtsa->fifo_mode = fifo_tmp;
+
+            if (sleep_mode == SLEEP_OFF) {
+                /* sleep off mode */
+                val_char[0] = '0';
+                val_char[1] = '\0';
+                sleep_ret = ewtsa_sleep_store(dev, attr, val_char, 1);
+                if (sleep_ret != 1) {
+                    dev_err(&ewtsa->client->dev, "ewtsa_sleep_store err(%d)\n", sleep_ret);
+                    return sleep_ret;
+                }
+            }
+        }
+    }
+
+    return count;
+}
+
+/* calibration & register settings */
+static void EWTSA_system_restart(struct ewtsa_t *ewtsa)
+{
+    unsigned char  val;
+    unsigned char  smpl;
+    unsigned char  number;
+    unsigned char  fifo_type;
+    s32            err;
+#if GYRO_VER3_ES1
+    signed long    ret;
+    signed long    timeout;
+#endif
+
+    if (ewtsa == NULL) {
+         printk(KERN_INFO "EWTSA_system_restart:ewtsa null pointer\n");
+        return;
+    }
+
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_DIGITAL_CAL, DIGITAL_CAL_DISABLE);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_DIGITAL_CAL write err(data = 0x%02x, ret = %d)\n", DIGITAL_CAL_DISABLE, err);
+        return;
+    }
+
+#if GYRO_VER3_ES1
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_REFERENCE, 0x00);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_REFERENCE write err(data = 0x00, ret = %d)\n", err);
+        return;
+    }
+
+    val = (unsigned char)(CTRL_REG2_REF_MODE | CTRL_REG2_HPCF);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_CTRL_REG2, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_CTRL_REG2 write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    err = i2c_smbus_read_byte_data(ewtsa->client, REG_REFERENCE);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_REFERENCE read err(ret = %d)\n", err);
+        return;
+    }
+
+    val = SOC_CNT2_SOCCLK_ON;
+    val |= (unsigned char)(CALIB_FS_62_5HZ << 7);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_SOC_CNT2, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SOC_CNT2 write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    /* Wait reference mode setting */
+    ret = (signed long)((REFERENCE_WAIT * HZ)/1000);
+    ret += (signed long)(1000 / HZ);
+    while (ret > 0) {
+        timeout = ret;
+        set_current_state(TASK_UNINTERRUPTIBLE);
+        ret = schedule_timeout(timeout);
+    }
+
+    val = SOC_CNT2_SOCCLK_OFF;
+    val |= (unsigned char)(CALIB_FS_62_5HZ << 7);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_SOC_CNT2, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SOC_CNT2 write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    val = (unsigned char)(CTRL_REG2_NOR_MODE | CTRL_REG2_HPCF);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_CTRL_REG2, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_CTRL_REG2 write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+#endif /* GYRO_VER3_ES1 */
+
+    if (ewtsa->event == EWTSA_POLLING_MODE) {
+        fifo_type = BYPASS_MODE;
+    }
+    else {
+        fifo_type = ewtsa->fifo_mode;
+    }
+
+    if ((ewtsa->reset_param & RST_REG_INIT_ALL) != RST_REG_INIT_OFF) {
+        if (fifo_type == BYPASS_MODE) {
+            if (ewtsa->delay < DELAY_THRES_4) {
+                if (ewtsa->delay >= DELAY_THRES_3) {
+                    ewtsa->dlpf = DELAY_DLPF_3;
+                } else {
+                    ewtsa->dlpf = DELAY_DLPF_2;
+                }
+            } else {
+                if (ewtsa->delay >= DELAY_THRES_6) {
+                    ewtsa->dlpf = DELAY_DLPF_6;
+                } else if (ewtsa->delay >= DELAY_THRES_5) {
+                    ewtsa->dlpf = DELAY_DLPF_5;
+                } else {
+                    ewtsa->dlpf = DELAY_DLPF_4;
+                }
+            }
+        }
+        else {
+            if (ewtsa->delay <= DELAY_THRES_FIFO) {
+                ewtsa->dlpf = DELAY_DLPF_1;
+            }
+            else {
+                ewtsa->dlpf = DELAY_DLPF_2;
+            }
+        }
+        val = (unsigned char)((unsigned char)(ewtsa->range << 3) | ewtsa->dlpf);
+
+        err = i2c_smbus_write_byte_data(ewtsa->client, REG_FS_DLPF_CTRL, val);
+        if (err < 0) {
+            dev_err(&ewtsa->client->dev, "REG_FS_DLPF_CTRL write err(data = 0x%02x, ret = %d)\n", val, err);
+            return;
+        }
+    }
+
+    if ((ewtsa->reset_param & RST_REG_INIT_DELAY) != RST_REG_INIT_OFF) {
+        err = i2c_smbus_write_byte_data(ewtsa->client, REG_CTRL_REG5, CTRL_REG5_INIT);
+        if (err < 0) {
+            dev_err(&ewtsa->client->dev, "REG_CTRL_REG5 write err(data = 0x%02x, ret = %d)\n", CTRL_REG5_INIT, err);
+            return;
+        }
+
+        if (fifo_type != BYPASS_MODE) {
+            val = FIFO_DRDY_DITH_EN;
+        }
+        else {
+            val = (unsigned char)(fifo_type << 5);
+            err = i2c_smbus_write_byte_data(ewtsa->client, REG_FIFO_CTRL2, val);
+            if (err < 0) {
+                dev_err(&ewtsa->client->dev, "REG_FIFO_CTRL2 write err(data = 0x%02x, ret = %d)\n", val, err);
+                return;
+            }
+            val = FIFO_DRDY_INIT;
+        }
+
+        err = i2c_smbus_write_byte_data(ewtsa->client, REG_FIFO_DRDY, val);
+        if (err < 0) {
+            dev_err(&ewtsa->client->dev, "REG_FIFO_DRDY write err(data = 0x%02x, ret = %d)\n", val, err);
+            return;
+        }
+
+        if (fifo_type == BYPASS_MODE) {
+            if (ewtsa->event == EWTSA_POLLING_MODE) {
+                smpl = DATA_RATE_1 - 1; /* SMPL = 0 */
+            }
+            else {
+                if (ewtsa->delay <= DELAY_THRES_2) {
+                    smpl =  DELAY_INTMIN_THRES;
+                }
+                else {
+                    smpl = (unsigned char)(ewtsa->delay - 1);
+                }
+            }
+            ewtsa->fifo_num = 1;
+        }
+        else {
+            if (ewtsa->delay <= DELAY_THRES_FIFO) {
+                if (ewtsa->delay > FIFO_MIN_DELAY) {
+                    number = (unsigned char)(ewtsa->delay / DATA_RATE_5);
+                    if ((ewtsa->delay % DATA_RATE_5) != 0) {
+                        number++;
+                    }
+                }
+                else {
+                    number = 2;
+                }
+                smpl = DATA_RATE_5 - 1; /* SMPL = 4 */
+            }
+            else {
+                number = (unsigned char)(ewtsa->delay / DATA_RATE_10);
+                if ((ewtsa->delay % DATA_RATE_10) != 0) {
+                    number++;
+                }
+                smpl = DATA_RATE_10 - 1; /* SMPL = 9 */
+            }
+
+            val = (unsigned char)(fifo_type << 5);
+            val |= number;
+            err = i2c_smbus_write_byte_data(ewtsa->client, REG_FIFO_CTRL2, val);
+            if (err < 0) {
+                dev_err(&ewtsa->client->dev, "REG_FIFO_CTRL2 write err(data = 0x%02x, ret = %d)\n", val, err);
+                return;
+            }
+            ewtsa->fifo_num = number;
+
+            val = CTRL_REG3_WTM_EN;
+            err = i2c_smbus_write_byte_data(ewtsa->client, REG_CTRL_REG3, val);
+            if (err < 0) {
+                dev_err(&ewtsa->client->dev, "REG_CTRL_REG3 write err(data = 0x%02x, ret = %d)\n", val, err);
+                return;
+            }
+
+            err = i2c_smbus_write_byte_data(ewtsa->client, REG_CTRL_REG5, CTRL_REG5_FIFO_EN);
+            if (err < 0) {
+                dev_err(&ewtsa->client->dev, "REG_CTRL_REG5 write err(data = 0x%02x, ret = %d)\n", CTRL_REG5_FIFO_EN, err);
+                return;
+            }
+        }
+        err = i2c_smbus_write_byte_data(ewtsa->client, REG_DATA_RATE, smpl);
+        if (err < 0) {
+            dev_err(&ewtsa->client->dev, "REG_DATA_RATE write err(data = 0x%02x, ret = %d)\n", smpl, err);
+            return;
+        }
+    }
+    ewtsa->reset_param = RST_REG_INIT_OFF;
+
+    if (ewtsa->calib == EWTSA_ON) {
+        EWTSA_set_calibration(ewtsa);
+    }
+    else {
+        err = i2c_smbus_write_byte_data(ewtsa->client, REG_SLEEP_CTRL, SLEEP_CTRL_SLEEP);
+        if (err < 0) {
+            dev_err(&ewtsa->client->dev, "REG_SLEEP_CTRL write err(data = 0x%02x, ret = %d)\n", SLEEP_CTRL_SLEEP, err);
+            return;
+        }
+
+#if GYRO_VER3_ES1
+        err = i2c_smbus_write_byte_data(ewtsa->client, REG2_CTRL_REG1, CTRL_REG1_ACTIVATE);
+        if (err < 0) {
+            dev_err(&ewtsa->client->dev, "REG2_CTRL_REG1 write err(data = 0x%02x, ret = %d)\n", CTRL_REG1_ACTIVATE, err);
+            return;
+        }
+#else /* GYRO_VER3_ES1 */
+        err = i2c_smbus_write_byte_data(ewtsa->client, REG_SLEEP_CTRL, SLEEP_CTRL_ACTIVATE);
+        if (err < 0) {
+            dev_err(&ewtsa->client->dev, "REG_SLEEP_CTRL write err(data = 0x%02x, ret = %d)\n", SLEEP_CTRL_ACTIVATE, err);
+            return;
+        }
+#endif /* GYRO_VER3_ES1 */
+
+        /* FIFO clear */
+        err = i2c_smbus_write_byte_data(ewtsa->client, REG_FIFO_CTRL1, FIFO_CTRL1_CLEAR);
+        if (err < 0) {
+            dev_err(&ewtsa->client->dev, "REG_FIFO_CTRL1 write err(data = 0x02, ret = %d)\n", err);
+            return;
+        }
+    }
+
+    ewtsa->calib_rst = EWTSA_OFF;
+}
+
+static void EWTSA_set_calibration(struct ewtsa_t *ewtsa)
+{
+    unsigned char  val;
+    s32            err;
+    signed long    ret;
+    signed long    l_timeout;
+    unsigned long  center;
+    static const unsigned short ewtsa_boost_time[4] = {
+        EWTSA_BOOST_TIME_0, EWTSA_BOOST_TIME_1, EWTSA_BOOST_TIME_2, EWTSA_BOOST_TIME_3
+    };
+    static const unsigned char ewtsa_w1_threshold_level[4] = {
+        EWTSA_W1_THRES_LV_0, EWTSA_W1_THRES_LV_1, EWTSA_W1_THRES_LV_2, EWTSA_W1_THRES_LV_3
+    };
+    static const unsigned short ewtsa_dynamic_range[4] = {
+        EWTSA_RANGE_0, EWTSA_RANGE_1, EWTSA_RANGE_2, EWTSA_RANGE_3
+    };
+
+    if (ewtsa == NULL) {
+         printk(KERN_INFO "EWTSA_system_restart:ewtsa null pointer\n");
+        return;
+    }
+
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_SOC_CNT1, SOC_CNT1_WIN_DIS | SOC_CNT1_BOOST_ON);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SOC_CNT1 write err(data = 0x%02x, ret = %d)\n", SOC_CNT1_WIN_DIS | SOC_CNT1_BOOST_ON, err);
+        return;
+    }
+
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_SLEEP_CTRL, SLEEP_CTRL_SLEEP);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SLEEP_CTRL write err(data = 0x%02x, ret = %d)\n", SLEEP_CTRL_SLEEP, err);
+        return;
+    }
+
+#if GYRO_VER3_ES1
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG2_CTRL_REG1, CTRL_REG1_ACTIVATE);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG2_CTRL_REG1 write err(data = 0x%02x, ret = %d)\n", CTRL_REG1_ACTIVATE, err);
+        return;
+    }
+#else /* GYRO_VER3_ES1 */
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_SLEEP_CTRL, SLEEP_CTRL_ACTIVATE);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SLEEP_CTRL write err(data = 0x%02x, ret = %d)\n", SLEEP_CTRL_ACTIVATE, err);
+        return;
+    }
+#endif /* GYRO_VER3_ES1 */
+
+    if (ewtsa_w1_threshold_level[ewtsa->w1_thres_level] > ewtsa->w1_thres_x) {
+        center = ewtsa_w1_threshold_level[ewtsa->w1_thres_level] + 1;
+    }
+    else {
+        center = ewtsa->w1_thres_x;
+    }
+    center *= W1_THRES_CENTER_COEF;
+    center /= ewtsa_dynamic_range[ewtsa->range];
+    val = (unsigned char)((0xFF00 & center) >> 8);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_REFERENCE, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_REFERENCE write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    val = (unsigned char)(CTRL_REG2_REF_MODE | CTRL_REG2_HPCF);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_CTRL_REG2, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_CTRL_REG2 write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    val = SOC_CNT2_SOCCLK_ON;
+    val |= (unsigned char)(CALIB_FS_62_5HZ << 7);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_SOC_CNT2, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SOC_CNT2 write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    /* Wait reference mode setting */
+    ret = (signed long)((REFERENCE_WAIT * HZ)/1000);
+    ret += (signed long)(1000 / HZ);
+    while (ret > 0) {
+        l_timeout = ret;
+        set_current_state(TASK_UNINTERRUPTIBLE);
+        ret = schedule_timeout(l_timeout);
+    }
+
+    val = SOC_CNT2_SOCCLK_OFF;
+    val |= (unsigned char)(CALIB_FS_62_5HZ << 7);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_SOC_CNT2, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SOC_CNT2 write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    val = (unsigned char)(CTRL_REG2_NOR_MODE | CTRL_REG2_HPCF);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_CTRL_REG2, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_CTRL_REG2 write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+#if GYRO_VER3_ES3 || GYRO_VER3_ES4 //2012.01.25 for ES3 & ES4
+    val = (unsigned char)(0x40 | SOC_CNT1_BOOST_ON);
+#else
+    val = (unsigned char)((unsigned char)(ewtsa->w1_datamask << 6) | SOC_CNT1_BOOST_ON);
+#endif
+    val |= (unsigned char)(ewtsa->w2_thres_en << 5);
+    val |= (unsigned char)(ewtsa->w1_thres_en << 4);
+    val |= (unsigned char)(ewtsa->calib_boost_tm << 2);
+    val |= (unsigned char)(ewtsa->calib_boost_fs << 1);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_SOC_CNT1, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SOC_CNT1 write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    val = (unsigned char)(SOC_CNT2_SOCCLK_ON | ewtsa->w1_thres_level);
+    val |= (unsigned char)(ewtsa->calib_fs << 7);
+    val |= (unsigned char)(ewtsa->offset_lag << 4);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_SOC_CNT2, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SOC_CNT2 write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    val = (unsigned char)(ewtsa->hpf << 7);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_SLFSLP_CNT, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SLFSLP_CNT write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    if (ewtsa_w1_threshold_level[ewtsa->w1_thres_level] > ewtsa->w1_thres_x) {
+        center = ewtsa_w1_threshold_level[ewtsa->w1_thres_level] + 1;
+    }
+    else {
+        center = ewtsa->w1_thres_x;
+    }
+    center *= W1_THRES_CENTER_COEF;
+    center /= ewtsa_dynamic_range[ewtsa->range];
+    val = (unsigned char)((0xFF00 & center) >> 8);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_W1THX_H, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_W1THX_H write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    val = (unsigned char)(0xFF & center);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_W1THX_L, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_W1THX_L write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    if (ewtsa_w1_threshold_level[ewtsa->w1_thres_level] > ewtsa->w1_thres_y) {
+        center = ewtsa_w1_threshold_level[ewtsa->w1_thres_level] + 1;
+    }
+    else {
+        center = ewtsa->w1_thres_y;
+    }
+    center *= W1_THRES_CENTER_COEF;
+    center /= ewtsa_dynamic_range[ewtsa->range];
+    val = (unsigned char)((0xFF00 & center) >> 8);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_W1THY_H, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_W1THY_H write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    val = (unsigned char)(0xFF & center);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_W1THY_L, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_W1THY_L write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    if (ewtsa_w1_threshold_level[ewtsa->w1_thres_level] > ewtsa->w1_thres_z) {
+        center = ewtsa_w1_threshold_level[ewtsa->w1_thres_level] + 1;
+    }
+    else {
+        center = ewtsa->w1_thres_z;
+    }
+    center *= W1_THRES_CENTER_COEF;
+    center /= ewtsa_dynamic_range[ewtsa->range];
+    val = (unsigned char)((0xFF00 & center) >> 8);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_W1THZ_H, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_W1THZ_H write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    val = (unsigned char)(0xFF & center);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_W1THZ_L, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_W1THZ_L write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_DIGITAL_CAL, DIGITAL_CAL_ENABLE);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_DIGITAL_CAL write err(data = 0x%02x, ret = %d)\n", DIGITAL_CAL_ENABLE, err);
+        return;
+    }
+
+    /* Wait calibration boost */
+    ret = (signed long)((ewtsa_boost_time[ewtsa->calib_boost_tm] * HZ)/1000);
+    ret += (signed long)(1000 / HZ);
+    while (ret > 0) {
+        l_timeout = ret;
+        set_current_state(TASK_UNINTERRUPTIBLE);
+        ret = schedule_timeout(l_timeout);
+    }
+
+    /* boost stop */
+    val = (unsigned char)(ewtsa->w1_datamask << 6);
+    val |= (unsigned char)(ewtsa->w2_thres_en << 5);
+    val |= (unsigned char)(ewtsa->w1_thres_en << 4);
+    val |= (unsigned char)(ewtsa->calib_boost_tm << 2);
+    val |= (unsigned char)(ewtsa->calib_boost_fs << 1);
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_SOC_CNT1, val);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SOC_CNT1 write err(data = 0x%02x, ret = %d)\n", val, err);
+        return;
+    }
+
+    if ((ewtsa->calib_alway != EWTSA_ON) ||
+        ((ewtsa->w1_thres_en == THRESHOLD_OFF) && (ewtsa->w2_thres_en == THRESHOLD_OFF))) {
+        val = (unsigned char)(SOC_CNT2_SOCCLK_OFF | ewtsa->w1_thres_level);
+        err = i2c_smbus_write_byte_data(ewtsa->client, REG_SOC_CNT2, val);
+        if (err < 0) {
+            dev_err(&ewtsa->client->dev, "REG_SOC_CNT2 write err(data = 0x%02x, ret = %d)\n", val, err);
+            return;
+        }
+    }
+
+    /* FIFO clear */
+    err = i2c_smbus_write_byte_data(ewtsa->client, REG_FIFO_CTRL1, FIFO_CTRL1_CLEAR);
+    if (err < 0) {
+        dev_err(&ewtsa->client->dev, "REG_FIFO_CTRL1 write err(data = 0x02, ret = %d)\n", err);
+        return;
+    }
+    return;
+}
+
+/* Read the angular data from the registers */
+static void EWTSA_report_abs(struct ewtsa_t *ewt)
+{
+    unsigned short x = 0, y = 0, z = 0, temp = 0;
+    s16 send_x, send_y, send_z, send_temp;
+    unsigned char reg = REG_MBURST_ALL;
+    unsigned char reg2[32][8];
+    int err;
+    struct i2c_msg msg[2];
+#if GYRO_MOUNT_SWAP_XY
+    s16 tmp;
+#endif /* GYRO_MOUNT_SWAP_XY */
+    unsigned char diag_stat = 0;
+    unsigned char loop;
+    unsigned long l_flags = 0;
+    signed long cal_tmp[4] = {0};
+    unsigned char get_num = 0;
+    unsigned char read_num = 0;
+
+    if (ewt == NULL) {
+        printk(KERN_INFO "struct ewtsa_t null pointer\n");
+        return;
+    }
+
+    if (ewt->event == EWTSA_POLLING_MODE) {
+        mutex_lock(&ewt->mlock);
+    }
+    else {
+        if (ewt->fifo_mode == FIFO_MODE) {
+            err = i2c_smbus_read_byte_data(ewt->client, REG_FIFO_DM);
+            if (err < 0) {
+                dev_err(&ewt->client->dev, "REG_FIFO_DM read err(%d)\n", err);
+                err = 0;
+            }
+            read_num = (unsigned char)err;
+            if (((unsigned char)(read_num & 0x20) >> 5) == 1) {
+                /* data nothing */
+                err = i2c_smbus_read_byte_data(ewt->client, REG_INT_STAT);
+                if (err < 0) {
+                    dev_err(&ewt->client->dev, "REG_INT_STAT read err(%d)\n", err);
+                }
+                return;
+            }
+            read_num &= 0x1F;
+
+            if (ewt->fifo_num > read_num) {
+                err = i2c_smbus_read_byte_data(ewt->client, REG_INT_STAT);
+                if (err < 0) {
+                    dev_err(&ewt->client->dev, "REG_INT_STAT read err(%d)\n", err);
+                }
+                return;
+            }
+        }
+    }
+
+    msg[0].addr = ewt->client->addr;
+    msg[0].flags = 0;
+    msg[0].len = 1;
+    msg[0].buf = &reg;
+
+    msg[1].addr = ewt->client->addr;
+    msg[1].flags = I2C_M_RD;
+    msg[1].len = (unsigned short)(8 * ewt->fifo_num);
+    msg[1].buf = &reg2[0][0];
+
+    err = i2c_transfer(ewt->client->adapter, msg, 2);
+    if (err < 0) {
+        dev_err(&ewt->client->dev, "REG_MBURST_ALL read err(%d)\n", err);
+        memset(reg2, 0x00, sizeof(reg2));
+    }
+
+    for (loop = 0; loop < ewt->fifo_num; loop++) {
+        x = (unsigned short)(0xFF & reg2[loop][3]);
+        x |= (unsigned short)(0xFF00 & (unsigned short)(reg2[loop][2] << 8));
+        y = (unsigned short)(0xFF & reg2[loop][5]);
+        y |= (unsigned short)(0xFF00 & (unsigned short)(reg2[loop][4] << 8));
+        z = (unsigned short)(0xFF & reg2[loop][7]);
+        z |= (unsigned short)(0xFF00 & (unsigned short)(reg2[loop][6] << 8));
+        temp = (unsigned short)(0xFF & reg2[loop][1]);
+        temp |= (unsigned short)(0xFF00 & (unsigned short)(reg2[loop][0] << 8));
+
+        cal_tmp[0] += (signed short)x;
+        cal_tmp[1] += (signed short)y;
+        cal_tmp[2] += (signed short)z;
+        cal_tmp[3] += (signed short)temp;
+        get_num++;
+    }
+
+    err = i2c_smbus_read_byte_data(ewt->client, REG_STATUS_REG);
+    if (err < 0) {
+        dev_err(&ewt->client->dev, "REG_STATUS_REG read err(%d)\n", err);
+        err = 0;
+    }
+    reg = (unsigned char)err;
+    if ((reg & STATUS_REG_OVERRUN) != 0) {
+        err = i2c_smbus_write_byte_data(ewt->client, REG_FIFO_CTRL1, FIFO_CTRL1_CLEAR);
+        if (err < 0) {
+            dev_err(&ewt->client->dev, "REG_FIFO_CTRL1 read err(%d)\n", err);
+        }
+    }
+
+    if (ewt->int_skip == EWSTA_INT_SKIP) {
+        ewt->int_skip = EWSTA_INT_CLEAR;
+        err = i2c_smbus_read_byte_data(ewt->client, REG_INT_STAT);
+        if (err < 0) {
+            dev_err(&ewt->client->dev, "REG_INT_STAT read err(%d)\n", err);
+        }
+        return;
+    }
+
+    if (get_num != 0) {
+        if (ewt->fifo_data_flag == EWTSA_ON) {
+            cal_tmp[0] += ewt->fifo_lastdata[0];
+            cal_tmp[1] += ewt->fifo_lastdata[1];
+            cal_tmp[2] += ewt->fifo_lastdata[2];
+            cal_tmp[3] += ewt->fifo_lastdata[3];
+            get_num++;
+        }
+
+        /* fifo mode only */
+        if (get_num > 1) {
+            ewt->fifo_lastdata[0] = (signed short)x;
+            ewt->fifo_lastdata[1] = (signed short)y;
+            ewt->fifo_lastdata[2] = (signed short)z;
+            ewt->fifo_lastdata[3] = (signed short)temp;
+            ewt->fifo_data_flag = EWTSA_ON;
+        }
+
+        send_x = (signed short)(cal_tmp[0] / get_num);
+        send_y = (signed short)(cal_tmp[1] / get_num);
+        send_z = (signed short)(cal_tmp[2] / get_num);
+        send_temp = (signed short)(cal_tmp[3] / get_num);
+    }
+    else {
+        ewt->fifo_lastdata[0] = 0;
+        ewt->fifo_lastdata[1] = 0;
+        ewt->fifo_lastdata[2] = 0;
+        ewt->fifo_lastdata[3] = 0;
+        ewt->fifo_data_flag = EWTSA_OFF;
+
+        send_x = 0;
+        send_y = 0;
+        send_z = 0;
+        send_temp = 0;
+        err = i2c_smbus_write_byte_data(ewt->client, REG_FIFO_CTRL1, FIFO_CTRL1_CLEAR);
+        if (err < 0) {
+            dev_err(&ewt->client->dev, "REG_FIFO_CTRL1 read err(%d)\n", err);
+        }
+    }
+
+#if GYRO_MOUNT_SWAP_XY
+    tmp = send_x;
+    send_x = send_y;
+    send_y = tmp;
+#endif /* GYRO_MOUNT_SWAP_XY */
+#if GYRO_MOUNT_REVERSE_X
+    send_x *= -1;
+#endif /* GYRO_MOUNT_REVERSE_X */
+#if GYRO_MOUNT_REVERSE_Y
+    send_y *= -1;
+#endif /* GYRO_MOUNT_REVERSE_Y */
+#if GYRO_MOUNT_REVERSE_Z
+    send_z *= -1;
+#endif /* GYRO_MOUNT_REVERSE_Z */
+
+    if (ewt->event != EWTSA_POLLING_MODE) {
+        err = i2c_smbus_read_byte_data(ewt->client, REG_INT_STAT);
+        if (err < 0) {
+            dev_err(&ewt->client->dev, "REG_INT_STAT read err(%d)\n", err);
+            err = 0;
+        }
+        diag_stat = (unsigned char)err;
+        spin_lock_irqsave(&ewt->slock, l_flags);
+    }
+
+    input_report_abs(ewt->input_dev, ABS_X, send_x); 
+    input_report_abs(ewt->input_dev, ABS_Y, send_y);
+    input_report_abs(ewt->input_dev, ABS_Z, send_z);
+    input_report_abs(ewt->input_dev, ABS_RX, send_temp);
+
+#if USE_GPIO_DIAG_PIN
+    if (ewt->event == EWTSA_POLLING_MODE) {
+        input_report_abs(ewt->input_dev, ABS_RY, gpio_get_value(DIAG_PIN));
+    }
+    else {
+        diag_stat = (unsigned char)((unsigned char)(diag_stat & 0x04) >> 2);
+        input_report_abs(ewt->input_dev, ABS_RY, diag_stat);
+    }
+#else
+    diag_stat = (unsigned char)((unsigned char)(diag_stat & 0x04) >> 2);
+    input_report_abs(ewt->input_dev, ABS_RY, diag_stat);
+#endif
+    input_sync(ewt->input_dev);
+
+    if (ewt->event == EWTSA_POLLING_MODE) {
+        mutex_unlock(&ewt->mlock);
+    }
+    else {
+        spin_unlock_irqrestore(&ewt->slock, l_flags);
+    }
+}
+
+static void EWTSA_dev_poll(struct work_struct *work)
+{
+    struct ewtsa_t *ewt;
+
+    if (work == NULL) {
+        printk(KERN_INFO "struct work_struct null pointer\n");
+        return;
+    }
+    ewt = container_of(work, struct ewtsa_t, input_work.work);
+
+    if (ewt->sleep == SLEEP_OFF) {
+      EWTSA_report_abs(ewt);
+    }
+}
+
+/* Interrupt handler */
+#if USE_GPIO_DRDY_PIN
+static irqreturn_t EWTSA_interrupt(int irq, void *dev_id)
+{
+    struct ewtsa_t *ewtsa = dev_id;
+
+    if (ewtsa == NULL) {
+        printk(KERN_INFO "struct ewtsa_t null pointer\n");
+        return IRQ_RETVAL(1);
+    }
+
+    if (irq == gpio_to_irq(DRDY_PIN)) {
+        if (ewtsa->sleep != SLEEP_OFF) {
+            return IRQ_RETVAL(1);
+        }
+        EWTSA_report_abs(ewtsa);
+    }
+    return IRQ_RETVAL(1);
+}
+#endif
+
+static void EWTSA_input_work_func(struct work_struct *work)
+{
+    struct ewtsa_t *ewt;
+    volatile unsigned long start_jiff = jiffies, delay_jiff, next_jiff;
+
+    if (work == NULL) {
+        printk(KERN_INFO "struct work_struct null pointer\n");
+        return;
+    }
+    ewt = container_of(work, struct ewtsa_t, input_work.work);
+
+    if (ewt->sleep == SLEEP_OFF) {
+        EWTSA_dev_poll(work);
+
+        /* adjust polling interval */
+        delay_jiff = jiffies;
+        if (start_jiff > delay_jiff) {               /* jiffies overflow */
+            delay_jiff += 0xFFFFFFFFUL - start_jiff;
+        }
+        else {
+            delay_jiff -= start_jiff;
+        }
+        next_jiff = msecs_to_jiffies(ewt->delay);
+        /* for delay_jiff > next_jiff */
+        delay_jiff %= next_jiff;
+        next_jiff -= delay_jiff;
+
+        queue_delayed_work(ewt->workqueue,
+            &ewt->input_work,
+            next_jiff);
+    }
+}
+
+/* Suspend function to register device */
+static int EWTSA_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+    struct ewtsa_t *ewt;
+    s32             ret;
+
+    if (client == NULL) {
+        printk(KERN_INFO "struct i2c_client null pointer\n");
+        return -EIO;
+    }
+    ewt = i2c_get_clientdata(client);
+
+    if (ewt->event == EWTSA_POLLING_MODE) {
+        cancel_delayed_work(&ewt->input_work);
+    }
+    else {
+        /* disable interrupt */
+        ret = i2c_smbus_write_byte_data(ewt->client, REG_INT_CTRL, INT_CTRL_INT_DISABLE);
+        if (ret < 0) {
+            dev_err(&ewt->client->dev, "REG_INT_CTRL write err(ret = %d)\n", ret);
+        }
+
+        if (ewt->sleep == SLEEP_OFF) {
+#if USE_GPIO_DRDY_PIN
+            free_irq(gpio_to_irq(DRDY_PIN), ewt);
+            /* keep sleep status for resume  */
+#endif
+        }
+        else {
+            ewt->sleep = SLEEP_ALLRESET;
+        }
+    }
+#if USE_GPIO_WINDOW_PIN
+    gpio_free(WINDOW_PIN);
+#endif
+#if USE_GPIO_DRDY_PIN
+    gpio_free(DRDY_PIN);
+#endif
+#if USE_GPIO_DIAG_PIN
+    gpio_free(DIAG_PIN);
+#endif
+    ewt->calib_rst = EWTSA_ON;
+    ewt->reset_param = RST_REG_INIT_ALL;
+    ret = i2c_smbus_write_byte_data(ewt->client, REG_SLEEP_CTRL, SLEEP_CTRL_ALLRSTSLEEP);
+    if (ret < 0) {
+        dev_err(&ewt->client->dev, "REG_SLEEP_CTRL write err(ret = %d)\n", ret);
+    }
+    return 0;
+}
+
+/* Resume function to register device */
+static int EWTSA_resume(struct i2c_client *client)
+{
+    struct ewtsa_t *ewt;
+    int             ret;
+
+    if (client == NULL) {
+        printk(KERN_INFO "struct i2c_client null pointer\n");
+        return -EIO;
+    }
+    ewt = i2c_get_clientdata(client);
+
+#if USE_GPIO_WINDOW_PIN
+    ret = gpio_request(WINDOW_PIN, "WINDOW");
+    ret += gpio_direction_input(WINDOW_PIN);
+#else
+    ret = 0;
+#endif
+#if USE_GPIO_DIAG_PIN
+    ret += gpio_request(DIAG_PIN, "DIAG");
+    ret += gpio_direction_input(DIAG_PIN);
+#endif
+    if ((ewt->sleep != SLEEP_OFF) || (ret != 0)) {
+        return 0;
+    }
+
+#if GYRO_VER3_ES1
+    ret = i2c_smbus_write_byte_data(ewt->client, REG2_CTRL_REG1, CTRL_REG1_ACTIVATE);
+#else /* GYRO_VER3_ES1 */
+    ret = i2c_smbus_write_byte_data(ewt->client, REG_SLEEP_CTRL, SLEEP_CTRL_ACTIVATE);
+#endif /* GYRO_VER3_ES1 */
+
+    if (ret >= 0) {
+        EWTSA_system_restart(ewt);
+
+        if (ewt->event == EWTSA_POLLING_MODE) {
+            queue_delayed_work(ewt->workqueue,
+                &ewt->input_work,
+                msecs_to_jiffies(ewt->delay));
+        }
+        else {
+            /* enable interrupt */
+#if USE_GPIO_DRDY_PIN
+            ret = gpio_request(DRDY_PIN, "DRDY");
+            ret += gpio_direction_input(DRDY_PIN);
+            ret += request_threaded_irq(gpio_to_irq(DRDY_PIN), NULL, EWTSA_interrupt, IRQF_TRIGGER_RISING, DEVICE_NAME, ewt);
+
+            if (ret == 0) {
+                ewt->int_skip = EWSTA_INT_SKIP;
+                if (ewt->fifo_mode == BYPASS_MODE) {
+                    ret = i2c_smbus_write_byte_data(ewt->client, REG_INT_CTRL, INT_CTRL_INT_ENABLE);
+                }
+                else {
+                    ret = i2c_smbus_write_byte_data(ewt->client, REG_INT_CTRL, INT_CTRL_INT_ENABLE | INT_CTRL_INT_WTMON_EN);
+                }
+                if (ret < 0) {
+                    dev_err(&ewt->client->dev, "REG_INT_CTRL write err(ret = %d)\n", ret);
+                }
+            }
+#endif
+        }
+    }
+    else {
+        dev_err(&ewt->client->dev, "REG_SLEEP_CTRL write err(ret = %d)\n", ret);
+    }
+
+    return 0;
+}
+
+/* Probe function to register device */
+static int EWTSA_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+    int ret;
+    struct ewtsa_t *ewtsa;
+
+    if (client == NULL) {
+        printk(KERN_INFO "EWTSA_probe:client null pointer\n");
+        return -EIO;
+    }
+
+    ewtsa = kzalloc(sizeof(*ewtsa), GFP_KERNEL);
+    if (ewtsa == NULL) {
+        dev_err(&client->dev, "unable to allocate memory!\n");
+        return -ENOMEM;
+    }
+
+    ewtsa->workqueue = create_workqueue("ewtsa_workqueue");
+    if (ewtsa->workqueue == NULL) {
+        dev_err(&client->dev, "Unable to create workqueue!\n");
+        kfree(ewtsa);
+        return -ENOMEM;
+    }
+
+    ewtsa->client = client;
+    i2c_set_clientdata(client, ewtsa);
+
+    ewtsa->sleep          = SLEEP_INIT_VAL;      /* sleep mode            */
+    ewtsa->delay          = DELAY_INIT_VAL;      /* information interval  */
+    ewtsa->range          = RANGE_INIT_VAL;      /* dynamic range         */
+    ewtsa->dlpf           = DLPF_INIT_VAL;       /* dlpf                  */
+    ewtsa->calib          = CALIB_FUNC_INIT_VAL; /* calibration function  */
+    ewtsa->calib_boost_tm = CALIB_BTIM_INIT_VAL; /* boost time[ms]        */
+    ewtsa->calib_fs       = CALIB_FS_INIT_VAL;   /* offset renewal rate   */
+    ewtsa->calib_rst      = CALIB_RST_INIT_VAL;  /* calib restart flag    */
+    ewtsa->fifo_mode      = FIFO_TYPE_INIT_VAL;  /* fifo type             */
+    ewtsa->reset_param    = RST_REG_INIT_ALL;    /* register setting flag */
+#if USE_GPIO_DRDY_PIN
+    ewtsa->event          = EWTSA_INTERUPT_MODE; /* data detect method    */
+#else
+    ewtsa->event          = EWTSA_POLLING_MODE; /* data detect method    */
+#endif
+    ewtsa->calib_boost_fs = CALIB_BFS_INIT_VAL;  /* calibration boost fs  */
+    ewtsa->int_skip       = EWSTA_INT_CLEAR;     /* first data flag       */
+    ewtsa->calib_alway    = CALIB_CLK_INIT_VAL;  /* socclk flag           */
+    ewtsa->hpf            = CALIB_HPF_INIT_VAL;  /* hpf                   */
+    ewtsa->w1_thres_x     = THRES_CENTER_INIT_X; /* threshold center val  */
+    ewtsa->w1_thres_y     = THRES_CENTER_INIT_Y; /* threshold center val  */
+    ewtsa->w1_thres_z     = THRES_CENTER_INIT_Z; /* threshold center val  */
+    ewtsa->w1_datamask    = W1_MASK_INIT_VAL;    /* window1 datamask set  */
+    ewtsa->w1_thres_en    = W1_FUNC_INIT_VAL;    /* window1 function flag */
+    ewtsa->w2_thres_en    = W2_FUNC_INIT_VAL;    /* window2 function flag */
+    ewtsa->offset_lag     = CALIB_LAG_INIT_VAL;  /* offset renewal lag    */
+    ewtsa->w1_thres_level = W1_LV_INIT_VAL;      /* window1 threshold lv  */
+    ewtsa->fifo_data_flag = EWTSA_OFF;           /* last data flag        */
+    ewtsa->fifo_num       = 0;                   /* fifo number           */
+    memset(ewtsa->fifo_lastdata, 0x00, sizeof(ewtsa->fifo_lastdata));
+
+    /*create device file in sysfs as user interface */
+    ret = device_create_file(&client->dev, &ewtsa_sleep_attr);
+    if (ret != 0) {
+        dev_err(&client->dev, "create device(sleep_attr) file failed!\n");
+        destroy_workqueue(ewtsa->workqueue);
+        kfree(ewtsa);
+        return ret;
+    }
+    ret = device_create_file(&client->dev, &ewtsa_delay_attr);
+    if (ret != 0) {
+        dev_err(&client->dev, "create device(delay_attr) file failed!\n");
+        device_remove_file(&client->dev, &ewtsa_sleep_attr);
+        destroy_workqueue(ewtsa->workqueue);
+        kfree(ewtsa);
+        return ret;
+    }
+    ret = device_create_file(&client->dev, &ewtsa_range_attr);
+    if (ret != 0) {
+        dev_err(&client->dev, "create device(range_attr) file failed!\n");
+        device_remove_file(&client->dev, &ewtsa_delay_attr);
+        device_remove_file(&client->dev, &ewtsa_sleep_attr);
+        destroy_workqueue(ewtsa->workqueue);
+        kfree(ewtsa);
+        return ret;
+    }
+    ret = device_create_file(&client->dev, &ewtsa_calib_attr);
+    if (ret != 0) {
+        dev_err(&client->dev, "create device(calib_attr) file failed!\n");
+        device_remove_file(&client->dev, &ewtsa_range_attr);
+        device_remove_file(&client->dev, &ewtsa_delay_attr);
+        device_remove_file(&client->dev, &ewtsa_sleep_attr);
+        destroy_workqueue(ewtsa->workqueue);
+        kfree(ewtsa);
+        return ret;
+    }
+    ret = device_create_file(&client->dev, &ewtsa_config_attr);
+    if (ret != 0) {
+        dev_err(&client->dev, "create device(calib_attr) file failed!\n");
+        device_remove_file(&client->dev, &ewtsa_calib_attr);
+        device_remove_file(&client->dev, &ewtsa_range_attr);
+        device_remove_file(&client->dev, &ewtsa_delay_attr);
+        device_remove_file(&client->dev, &ewtsa_sleep_attr);
+        destroy_workqueue(ewtsa->workqueue);
+        kfree(ewtsa);
+        return ret;
+    }
+
+    /*input poll device register */
+    ewtsa->input_dev = input_allocate_device();
+    if (ewtsa->input_dev == NULL) {
+        dev_err(&client->dev, "alloc input device failed!\n");
+        device_remove_file(&client->dev, &ewtsa_config_attr);
+        device_remove_file(&client->dev, &ewtsa_calib_attr);
+        device_remove_file(&client->dev, &ewtsa_range_attr);
+        device_remove_file(&client->dev, &ewtsa_delay_attr);
+        device_remove_file(&client->dev, &ewtsa_sleep_attr);
+        destroy_workqueue(ewtsa->workqueue);
+        kfree(ewtsa);
+        return -ENOMEM;
+    }
+    ewtsa->input_dev->name = DEVICE_NAME;
+    ewtsa->input_dev->id.bustype = BUS_I2C;
+    ewtsa->input_dev->evbit[0] = BIT_MASK(EV_ABS);
+
+    mutex_init(&ewtsa->mlock);
+    spin_lock_init(&ewtsa->slock);
+
+    input_set_abs_params(ewtsa->input_dev, ABS_X, -MAX_VALUE, MAX_VALUE, 0, 0);
+    input_set_abs_params(ewtsa->input_dev, ABS_Y, -MAX_VALUE, MAX_VALUE, 0, 0);
+    input_set_abs_params(ewtsa->input_dev, ABS_Z, -MAX_VALUE, MAX_VALUE, 0, 0);
+    input_set_abs_params(ewtsa->input_dev, ABS_RX, -200, 200, 0, 0);
+    input_set_abs_params(ewtsa->input_dev, ABS_RY, -200, 200, 0, 0);
+
+    ret = input_register_device(ewtsa->input_dev);
+    if (ret != 0) {
+        dev_err(&client->dev, "register poll device failed!\n");
+        input_free_device(ewtsa->input_dev);
+        device_remove_file(&client->dev, &ewtsa_config_attr);
+        device_remove_file(&client->dev, &ewtsa_calib_attr);
+        device_remove_file(&client->dev, &ewtsa_range_attr);
+        device_remove_file(&client->dev, &ewtsa_delay_attr);
+        device_remove_file(&client->dev, &ewtsa_sleep_attr);
+        destroy_workqueue(ewtsa->workqueue);
+        kfree(ewtsa);
+        return ret;
+    }
+
+    /* GPIO configuration */
+    ret = i2c_smbus_write_byte_data(ewtsa->client, REG_SLEEP_CTRL, SLEEP_CTRL_ALLRSTSLEEP);
+    if (ret < 0) {
+        dev_err(&ewtsa->client->dev, "REG_SLEEP_CTRL write err(data = 0x00, ret = %d)\n", ret);
+    }
+#if USE_GPIO_WINDOW_PIN
+    ret = gpio_request(WINDOW_PIN, "WINDOW");
+    ret += gpio_direction_input(WINDOW_PIN);
+#else
+    ret = 0;
+#endif
+#if USE_GPIO_DIAG_PIN
+    ret += gpio_request(DIAG_PIN, "DIAG");
+    ret += gpio_direction_input(DIAG_PIN);
+#endif
+    if (ret != 0) {
+        dev_err(&client->dev, "gpio_request failed!\n");
+#if USE_GPIO_WINDOW_PIN
+        gpio_free(WINDOW_PIN);
+#endif
+#if USE_GPIO_DIAG_PIN
+        gpio_free(DIAG_PIN);
+#endif
+        input_unregister_device(ewtsa->input_dev);
+        input_free_device(ewtsa->input_dev);
+        device_remove_file(&client->dev, &ewtsa_config_attr);
+        device_remove_file(&client->dev, &ewtsa_calib_attr);
+        device_remove_file(&client->dev, &ewtsa_range_attr);
+        device_remove_file(&client->dev, &ewtsa_delay_attr);
+        device_remove_file(&client->dev, &ewtsa_sleep_attr);
+        destroy_workqueue(ewtsa->workqueue);
+        kfree(ewtsa);
+        return ret;
+    }
+
+    INIT_DELAYED_WORK(&ewtsa->input_work, EWTSA_input_work_func);
+
+    dev_info(&client->dev, "ewtsa device is probed successfully.\n");
+    return 0;
+}
+
+/* Remove function to unregister the device */
+static int EWTSA_remove(struct i2c_client *client)
+{
+    struct ewtsa_t *ewtsa;
+
+    if (client == NULL) {
+        printk(KERN_INFO "client pointer null!\n");
+        return -EIO;
+    }
+    ewtsa = i2c_get_clientdata(client);
+
+    i2c_smbus_write_byte_data(ewtsa->client, REG_SLEEP_CTRL, SLEEP_CTRL_ALLRSTSLEEP);
+#if USE_GPIO_DRDY_PIN
+    if (ewtsa->sleep == SLEEP_OFF) {
+        free_irq(gpio_to_irq(DRDY_PIN), ewtsa);
+        gpio_free(DRDY_PIN);
+    }
+#endif
+#if USE_GPIO_WINDOW_PIN
+    gpio_free(WINDOW_PIN);
+#endif
+#if USE_GPIO_DIAG_PIN
+    gpio_free(DIAG_PIN);
+#endif
+
+    input_unregister_device(ewtsa->input_dev);
+    input_free_device(ewtsa->input_dev);
+    destroy_workqueue(ewtsa->workqueue);
+    device_remove_file(&client->dev, &ewtsa_sleep_attr);
+    device_remove_file(&client->dev, &ewtsa_delay_attr);
+    device_remove_file(&client->dev, &ewtsa_range_attr);
+    device_remove_file(&client->dev, &ewtsa_calib_attr);
+    device_remove_file(&client->dev, &ewtsa_config_attr);
+    kfree(ewtsa);
+    dev_info(&client->dev, "ewtsa device is removed successfully.\n");
+    return 0;
+}
+
+
+static int __init init_ewtsa(void)
+{
+     return i2c_add_driver(&i2c_ewtsa_driver);
+}
+
+static void __exit exit_ewtsa(void)
+{
+    i2c_del_driver(&i2c_ewtsa_driver);
+}
+
+module_init(init_ewtsa);
+module_exit(exit_ewtsa);
+
+MODULE_AUTHOR("Panasonic Electronic Devices");
+MODULE_DESCRIPTION("Gyro sensor driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/gp2ap002a00f.c b/drivers/input/misc/gp2ap002a00f.c
new file mode 100644
index 00000000..fe30bd0f
--- /dev/null
+++ b/drivers/input/misc/gp2ap002a00f.c
@@ -0,0 +1,288 @@
+/*
+ * Copyright (C) 2011 Sony Ericsson Mobile Communications Inc.
+ *
+ * Author: Courtney Cavin <courtney.cavin@sonyericsson.com>
+ * Prepared for up-stream by: Oskar Andero <oskar.andero@sonyericsson.com>
+ *
+ * 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/i2c.h>
+#include <linux/irq.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/gpio.h>
+#include <linux/delay.h>
+#include <linux/input/gp2ap002a00f.h>
+
+struct gp2a_data {
+	struct input_dev *input;
+	const struct gp2a_platform_data *pdata;
+	struct i2c_client *i2c_client;
+};
+
+enum gp2a_addr {
+	GP2A_ADDR_PROX	= 0x0,
+	GP2A_ADDR_GAIN	= 0x1,
+	GP2A_ADDR_HYS	= 0x2,
+	GP2A_ADDR_CYCLE	= 0x3,
+	GP2A_ADDR_OPMOD	= 0x4,
+	GP2A_ADDR_CON	= 0x6
+};
+
+enum gp2a_controls {
+	/* Software Shutdown control: 0 = shutdown, 1 = normal operation */
+	GP2A_CTRL_SSD	= 0x01
+};
+
+static int gp2a_report(struct gp2a_data *dt)
+{
+	int vo = gpio_get_value(dt->pdata->vout_gpio);
+
+	input_report_switch(dt->input, SW_FRONT_PROXIMITY, !vo);
+	input_sync(dt->input);
+
+	return 0;
+}
+
+static irqreturn_t gp2a_irq(int irq, void *handle)
+{
+	struct gp2a_data *dt = handle;
+
+	gp2a_report(dt);
+
+	return IRQ_HANDLED;
+}
+
+static int gp2a_enable(struct gp2a_data *dt)
+{
+	return i2c_smbus_write_byte_data(dt->i2c_client, GP2A_ADDR_OPMOD,
+					 GP2A_CTRL_SSD);
+}
+
+static int gp2a_disable(struct gp2a_data *dt)
+{
+	return i2c_smbus_write_byte_data(dt->i2c_client, GP2A_ADDR_OPMOD,
+					 0x00);
+}
+
+static int gp2a_device_open(struct input_dev *dev)
+{
+	struct gp2a_data *dt = input_get_drvdata(dev);
+	int error;
+
+	error = gp2a_enable(dt);
+	if (error < 0) {
+		dev_err(&dt->i2c_client->dev,
+			"unable to activate, err %d\n", error);
+		return error;
+	}
+
+	gp2a_report(dt);
+
+	return 0;
+}
+
+static void gp2a_device_close(struct input_dev *dev)
+{
+	struct gp2a_data *dt = input_get_drvdata(dev);
+	int error;
+
+	error = gp2a_disable(dt);
+	if (error < 0)
+		dev_err(&dt->i2c_client->dev,
+			"unable to deactivate, err %d\n", error);
+}
+
+static int gp2a_initialize(struct gp2a_data *dt)
+{
+	int error;
+
+	error = i2c_smbus_write_byte_data(dt->i2c_client, GP2A_ADDR_GAIN,
+					  0x08);
+	if (error < 0)
+		return error;
+
+	error = i2c_smbus_write_byte_data(dt->i2c_client, GP2A_ADDR_HYS,
+					  0xc2);
+	if (error < 0)
+		return error;
+
+	error = i2c_smbus_write_byte_data(dt->i2c_client, GP2A_ADDR_CYCLE,
+					  0x04);
+	if (error < 0)
+		return error;
+
+	error = gp2a_disable(dt);
+
+	return error;
+}
+
+static int gp2a_probe(struct i2c_client *client,
+				const struct i2c_device_id *id)
+{
+	const struct gp2a_platform_data *pdata = client->dev.platform_data;
+	struct gp2a_data *dt;
+	int error;
+
+	if (!pdata)
+		return -EINVAL;
+
+	if (pdata->hw_setup) {
+		error = pdata->hw_setup(client);
+		if (error < 0)
+			return error;
+	}
+
+	error = gpio_request_one(pdata->vout_gpio, GPIOF_IN, GP2A_I2C_NAME);
+	if (error)
+		goto err_hw_shutdown;
+
+	dt = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL);
+	if (!dt) {
+		error = -ENOMEM;
+		goto err_free_gpio;
+	}
+
+	dt->pdata = pdata;
+	dt->i2c_client = client;
+
+	error = gp2a_initialize(dt);
+	if (error < 0)
+		goto err_free_mem;
+
+	dt->input = input_allocate_device();
+	if (!dt->input) {
+		error = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	input_set_drvdata(dt->input, dt);
+
+	dt->input->open = gp2a_device_open;
+	dt->input->close = gp2a_device_close;
+	dt->input->name = GP2A_I2C_NAME;
+	dt->input->id.bustype = BUS_I2C;
+	dt->input->dev.parent = &client->dev;
+
+	input_set_capability(dt->input, EV_SW, SW_FRONT_PROXIMITY);
+
+	error = request_threaded_irq(client->irq, NULL, gp2a_irq,
+			IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
+				IRQF_ONESHOT,
+			GP2A_I2C_NAME, dt);
+	if (error) {
+		dev_err(&client->dev, "irq request failed\n");
+		goto err_free_input_dev;
+	}
+
+	error = input_register_device(dt->input);
+	if (error) {
+		dev_err(&client->dev, "device registration failed\n");
+		goto err_free_irq;
+	}
+
+	device_init_wakeup(&client->dev, pdata->wakeup);
+	i2c_set_clientdata(client, dt);
+
+	return 0;
+
+err_free_irq:
+	free_irq(client->irq, dt);
+err_free_input_dev:
+	input_free_device(dt->input);
+err_free_mem:
+	kfree(dt);
+err_free_gpio:
+	gpio_free(pdata->vout_gpio);
+err_hw_shutdown:
+	if (pdata->hw_shutdown)
+		pdata->hw_shutdown(client);
+	return error;
+}
+
+static int gp2a_remove(struct i2c_client *client)
+{
+	struct gp2a_data *dt = i2c_get_clientdata(client);
+	const struct gp2a_platform_data *pdata = dt->pdata;
+
+	device_init_wakeup(&client->dev, false);
+
+	free_irq(client->irq, dt);
+
+	input_unregister_device(dt->input);
+	kfree(dt);
+
+	gpio_free(pdata->vout_gpio);
+
+	if (pdata->hw_shutdown)
+		pdata->hw_shutdown(client);
+
+	return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int gp2a_suspend(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct gp2a_data *dt = i2c_get_clientdata(client);
+	int retval = 0;
+
+	if (device_may_wakeup(&client->dev)) {
+		enable_irq_wake(client->irq);
+	} else {
+		mutex_lock(&dt->input->mutex);
+		if (dt->input->users)
+			retval = gp2a_disable(dt);
+		mutex_unlock(&dt->input->mutex);
+	}
+
+	return retval;
+}
+
+static int gp2a_resume(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct gp2a_data *dt = i2c_get_clientdata(client);
+	int retval = 0;
+
+	if (device_may_wakeup(&client->dev)) {
+		disable_irq_wake(client->irq);
+	} else {
+		mutex_lock(&dt->input->mutex);
+		if (dt->input->users)
+			retval = gp2a_enable(dt);
+		mutex_unlock(&dt->input->mutex);
+	}
+
+	return retval;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(gp2a_pm, gp2a_suspend, gp2a_resume);
+
+static const struct i2c_device_id gp2a_i2c_id[] = {
+	{ GP2A_I2C_NAME, 0 },
+	{ }
+};
+
+static struct i2c_driver gp2a_i2c_driver = {
+	.driver = {
+		.name	= GP2A_I2C_NAME,
+		.owner	= THIS_MODULE,
+		.pm	= &gp2a_pm,
+	},
+	.probe		= gp2a_probe,
+	.remove		= gp2a_remove,
+	.id_table	= gp2a_i2c_id,
+};
+
+module_i2c_driver(gp2a_i2c_driver);
+
+MODULE_AUTHOR("Courtney Cavin <courtney.cavin@sonyericsson.com>");
+MODULE_DESCRIPTION("Sharp GP2AP002A00F I2C Proximity/Opto sensor driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/misc/gpio_axis.c b/drivers/input/misc/gpio_axis.c
new file mode 100644
index 00000000..0acf4a57
--- /dev/null
+++ b/drivers/input/misc/gpio_axis.c
@@ -0,0 +1,192 @@
+/* drivers/input/misc/gpio_axis.c
+ *
+ * Copyright (C) 2007 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/gpio.h>
+#include <linux/gpio_event.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+
+struct gpio_axis_state {
+	struct gpio_event_input_devs *input_devs;
+	struct gpio_event_axis_info *info;
+	uint32_t pos;
+};
+
+uint16_t gpio_axis_4bit_gray_map_table[] = {
+	[0x0] = 0x0, [0x1] = 0x1, /* 0000 0001 */
+	[0x3] = 0x2, [0x2] = 0x3, /* 0011 0010 */
+	[0x6] = 0x4, [0x7] = 0x5, /* 0110 0111 */
+	[0x5] = 0x6, [0x4] = 0x7, /* 0101 0100 */
+	[0xc] = 0x8, [0xd] = 0x9, /* 1100 1101 */
+	[0xf] = 0xa, [0xe] = 0xb, /* 1111 1110 */
+	[0xa] = 0xc, [0xb] = 0xd, /* 1010 1011 */
+	[0x9] = 0xe, [0x8] = 0xf, /* 1001 1000 */
+};
+uint16_t gpio_axis_4bit_gray_map(struct gpio_event_axis_info *info, uint16_t in)
+{
+	return gpio_axis_4bit_gray_map_table[in];
+}
+
+uint16_t gpio_axis_5bit_singletrack_map_table[] = {
+	[0x10] = 0x00, [0x14] = 0x01, [0x1c] = 0x02, /*     10000 10100 11100 */
+	[0x1e] = 0x03, [0x1a] = 0x04, [0x18] = 0x05, /*     11110 11010 11000 */
+	[0x08] = 0x06, [0x0a] = 0x07, [0x0e] = 0x08, /*    01000 01010 01110  */
+	[0x0f] = 0x09, [0x0d] = 0x0a, [0x0c] = 0x0b, /*    01111 01101 01100  */
+	[0x04] = 0x0c, [0x05] = 0x0d, [0x07] = 0x0e, /*   00100 00101 00111   */
+	[0x17] = 0x0f, [0x16] = 0x10, [0x06] = 0x11, /*   10111 10110 00110   */
+	[0x02] = 0x12, [0x12] = 0x13, [0x13] = 0x14, /*  00010 10010 10011    */
+	[0x1b] = 0x15, [0x0b] = 0x16, [0x03] = 0x17, /*  11011 01011 00011    */
+	[0x01] = 0x18, [0x09] = 0x19, [0x19] = 0x1a, /* 00001 01001 11001     */
+	[0x1d] = 0x1b, [0x15] = 0x1c, [0x11] = 0x1d, /* 11101 10101 10001     */
+};
+uint16_t gpio_axis_5bit_singletrack_map(
+	struct gpio_event_axis_info *info, uint16_t in)
+{
+	return gpio_axis_5bit_singletrack_map_table[in];
+}
+
+static void gpio_event_update_axis(struct gpio_axis_state *as, int report)
+{
+	struct gpio_event_axis_info *ai = as->info;
+	int i;
+	int change;
+	uint16_t state = 0;
+	uint16_t pos;
+	uint16_t old_pos = as->pos;
+	for (i = ai->count - 1; i >= 0; i--)
+		state = (state << 1) | gpio_get_value(ai->gpio[i]);
+	pos = ai->map(ai, state);
+	if (ai->flags & GPIOEAF_PRINT_RAW)
+		pr_info("axis %d-%d raw %x, pos %d -> %d\n",
+			ai->type, ai->code, state, old_pos, pos);
+	if (report && pos != old_pos) {
+		if (ai->type == EV_REL) {
+			change = (ai->decoded_size + pos - old_pos) %
+				  ai->decoded_size;
+			if (change > ai->decoded_size / 2)
+				change -= ai->decoded_size;
+			if (change == ai->decoded_size / 2) {
+				if (ai->flags & GPIOEAF_PRINT_EVENT)
+					pr_info("axis %d-%d unknown direction, "
+						"pos %d -> %d\n", ai->type,
+						ai->code, old_pos, pos);
+				change = 0; /* no closest direction */
+			}
+			if (ai->flags & GPIOEAF_PRINT_EVENT)
+				pr_info("axis %d-%d change %d\n",
+					ai->type, ai->code, change);
+			input_report_rel(as->input_devs->dev[ai->dev],
+						ai->code, change);
+		} else {
+			if (ai->flags & GPIOEAF_PRINT_EVENT)
+				pr_info("axis %d-%d now %d\n",
+					ai->type, ai->code, pos);
+			input_event(as->input_devs->dev[ai->dev],
+					ai->type, ai->code, pos);
+		}
+		input_sync(as->input_devs->dev[ai->dev]);
+	}
+	as->pos = pos;
+}
+
+static irqreturn_t gpio_axis_irq_handler(int irq, void *dev_id)
+{
+	struct gpio_axis_state *as = dev_id;
+	gpio_event_update_axis(as, 1);
+	return IRQ_HANDLED;
+}
+
+int gpio_event_axis_func(struct gpio_event_input_devs *input_devs,
+			 struct gpio_event_info *info, void **data, int func)
+{
+	int ret;
+	int i;
+	int irq;
+	struct gpio_event_axis_info *ai;
+	struct gpio_axis_state *as;
+
+	ai = container_of(info, struct gpio_event_axis_info, info);
+	if (func == GPIO_EVENT_FUNC_SUSPEND) {
+		for (i = 0; i < ai->count; i++)
+			disable_irq(gpio_to_irq(ai->gpio[i]));
+		return 0;
+	}
+	if (func == GPIO_EVENT_FUNC_RESUME) {
+		for (i = 0; i < ai->count; i++)
+			enable_irq(gpio_to_irq(ai->gpio[i]));
+		return 0;
+	}
+
+	if (func == GPIO_EVENT_FUNC_INIT) {
+		*data = as = kmalloc(sizeof(*as), GFP_KERNEL);
+		if (as == NULL) {
+			ret = -ENOMEM;
+			goto err_alloc_axis_state_failed;
+		}
+		as->input_devs = input_devs;
+		as->info = ai;
+		if (ai->dev >= input_devs->count) {
+			pr_err("gpio_event_axis: bad device index %d >= %d "
+				"for %d:%d\n", ai->dev, input_devs->count,
+				ai->type, ai->code);
+			ret = -EINVAL;
+			goto err_bad_device_index;
+		}
+
+		input_set_capability(input_devs->dev[ai->dev],
+				     ai->type, ai->code);
+		if (ai->type == EV_ABS) {
+			input_set_abs_params(input_devs->dev[ai->dev], ai->code,
+					     0, ai->decoded_size - 1, 0, 0);
+		}
+		for (i = 0; i < ai->count; i++) {
+			ret = gpio_request(ai->gpio[i], "gpio_event_axis");
+			if (ret < 0)
+				goto err_request_gpio_failed;
+			ret = gpio_direction_input(ai->gpio[i]);
+			if (ret < 0)
+				goto err_gpio_direction_input_failed;
+			ret = irq = gpio_to_irq(ai->gpio[i]);
+			if (ret < 0)
+				goto err_get_irq_num_failed;
+			ret = request_irq(irq, gpio_axis_irq_handler,
+					  IRQF_TRIGGER_RISING |
+					  IRQF_TRIGGER_FALLING,
+					  "gpio_event_axis", as);
+			if (ret < 0)
+				goto err_request_irq_failed;
+		}
+		gpio_event_update_axis(as, 0);
+		return 0;
+	}
+
+	ret = 0;
+	as = *data;
+	for (i = ai->count - 1; i >= 0; i--) {
+		free_irq(gpio_to_irq(ai->gpio[i]), as);
+err_request_irq_failed:
+err_get_irq_num_failed:
+err_gpio_direction_input_failed:
+		gpio_free(ai->gpio[i]);
+err_request_gpio_failed:
+		;
+	}
+err_bad_device_index:
+	kfree(as);
+	*data = NULL;
+err_alloc_axis_state_failed:
+	return ret;
+}
diff --git a/drivers/input/misc/gpio_event.c b/drivers/input/misc/gpio_event.c
new file mode 100644
index 00000000..90f07eba
--- /dev/null
+++ b/drivers/input/misc/gpio_event.c
@@ -0,0 +1,228 @@
+/* drivers/input/misc/gpio_event.c
+ *
+ * Copyright (C) 2007 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/input.h>
+#include <linux/gpio_event.h>
+#include <linux/hrtimer.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+struct gpio_event {
+	struct gpio_event_input_devs *input_devs;
+	const struct gpio_event_platform_data *info;
+	void *state[0];
+};
+
+static int gpio_input_event(
+	struct input_dev *dev, unsigned int type, unsigned int code, int value)
+{
+	int i;
+	int devnr;
+	int ret = 0;
+	int tmp_ret;
+	struct gpio_event_info **ii;
+	struct gpio_event *ip = input_get_drvdata(dev);
+
+	for (devnr = 0; devnr < ip->input_devs->count; devnr++)
+		if (ip->input_devs->dev[devnr] == dev)
+			break;
+	if (devnr == ip->input_devs->count) {
+		pr_err("gpio_input_event: unknown device %p\n", dev);
+		return -EIO;
+	}
+
+	for (i = 0, ii = ip->info->info; i < ip->info->info_count; i++, ii++) {
+		if ((*ii)->event) {
+			tmp_ret = (*ii)->event(ip->input_devs, *ii,
+						&ip->state[i],
+						devnr, type, code, value);
+			if (tmp_ret)
+				ret = tmp_ret;
+		}
+	}
+	return ret;
+}
+
+static int gpio_event_call_all_func(struct gpio_event *ip, int func)
+{
+	int i;
+	int ret;
+	struct gpio_event_info **ii;
+
+	if (func == GPIO_EVENT_FUNC_INIT || func == GPIO_EVENT_FUNC_RESUME) {
+		ii = ip->info->info;
+		for (i = 0; i < ip->info->info_count; i++, ii++) {
+			if ((*ii)->func == NULL) {
+				ret = -ENODEV;
+				pr_err("gpio_event_probe: Incomplete pdata, "
+					"no function\n");
+				goto err_no_func;
+			}
+			if (func == GPIO_EVENT_FUNC_RESUME && (*ii)->no_suspend)
+				continue;
+			ret = (*ii)->func(ip->input_devs, *ii, &ip->state[i],
+					  func);
+			if (ret) {
+				pr_err("gpio_event_probe: function failed\n");
+				goto err_func_failed;
+			}
+		}
+		return 0;
+	}
+
+	ret = 0;
+	i = ip->info->info_count;
+	ii = ip->info->info + i;
+	while (i > 0) {
+		i--;
+		ii--;
+		if ((func & ~1) == GPIO_EVENT_FUNC_SUSPEND && (*ii)->no_suspend)
+			continue;
+		(*ii)->func(ip->input_devs, *ii, &ip->state[i], func & ~1);
+err_func_failed:
+err_no_func:
+		;
+	}
+	return ret;
+}
+
+static void __maybe_unused gpio_event_suspend(struct gpio_event *ip)
+{
+	gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_SUSPEND);
+	if (ip->info->power)
+		ip->info->power(ip->info, 0);
+}
+
+static void __maybe_unused gpio_event_resume(struct gpio_event *ip)
+{
+	if (ip->info->power)
+		ip->info->power(ip->info, 1);
+	gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_RESUME);
+}
+
+static int gpio_event_probe(struct platform_device *pdev)
+{
+	int err;
+	struct gpio_event *ip;
+	struct gpio_event_platform_data *event_info;
+	int dev_count = 1;
+	int i;
+	int registered = 0;
+
+	event_info = pdev->dev.platform_data;
+	if (event_info == NULL) {
+		pr_err("gpio_event_probe: No pdata\n");
+		return -ENODEV;
+	}
+	if ((!event_info->name && !event_info->names[0]) ||
+	    !event_info->info || !event_info->info_count) {
+		pr_err("gpio_event_probe: Incomplete pdata\n");
+		return -ENODEV;
+	}
+	if (!event_info->name)
+		while (event_info->names[dev_count])
+			dev_count++;
+	ip = kzalloc(sizeof(*ip) +
+		     sizeof(ip->state[0]) * event_info->info_count +
+		     sizeof(*ip->input_devs) +
+		     sizeof(ip->input_devs->dev[0]) * dev_count, GFP_KERNEL);
+	if (ip == NULL) {
+		err = -ENOMEM;
+		pr_err("gpio_event_probe: Failed to allocate private data\n");
+		goto err_kp_alloc_failed;
+	}
+	ip->input_devs = (void*)&ip->state[event_info->info_count];
+	platform_set_drvdata(pdev, ip);
+
+	for (i = 0; i < dev_count; i++) {
+		struct input_dev *input_dev = input_allocate_device();
+		if (input_dev == NULL) {
+			err = -ENOMEM;
+			pr_err("gpio_event_probe: "
+				"Failed to allocate input device\n");
+			goto err_input_dev_alloc_failed;
+		}
+		input_set_drvdata(input_dev, ip);
+		input_dev->name = event_info->name ?
+					event_info->name : event_info->names[i];
+		input_dev->event = gpio_input_event;
+		ip->input_devs->dev[i] = input_dev;
+	}
+	ip->input_devs->count = dev_count;
+	ip->info = event_info;
+	if (event_info->power)
+		ip->info->power(ip->info, 1);
+
+	err = gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_INIT);
+	if (err)
+		goto err_call_all_func_failed;
+
+	for (i = 0; i < dev_count; i++) {
+		err = input_register_device(ip->input_devs->dev[i]);
+		if (err) {
+			pr_err("gpio_event_probe: Unable to register %s "
+				"input device\n", ip->input_devs->dev[i]->name);
+			goto err_input_register_device_failed;
+		}
+		registered++;
+	}
+
+	return 0;
+
+err_input_register_device_failed:
+	gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_UNINIT);
+err_call_all_func_failed:
+	if (event_info->power)
+		ip->info->power(ip->info, 0);
+	for (i = 0; i < registered; i++)
+		input_unregister_device(ip->input_devs->dev[i]);
+	for (i = dev_count - 1; i >= registered; i--) {
+		input_free_device(ip->input_devs->dev[i]);
+err_input_dev_alloc_failed:
+		;
+	}
+	kfree(ip);
+err_kp_alloc_failed:
+	return err;
+}
+
+static int gpio_event_remove(struct platform_device *pdev)
+{
+	struct gpio_event *ip = platform_get_drvdata(pdev);
+	int i;
+
+	gpio_event_call_all_func(ip, GPIO_EVENT_FUNC_UNINIT);
+	if (ip->info->power)
+		ip->info->power(ip->info, 0);
+	for (i = 0; i < ip->input_devs->count; i++)
+		input_unregister_device(ip->input_devs->dev[i]);
+	kfree(ip);
+	return 0;
+}
+
+static struct platform_driver gpio_event_driver = {
+	.probe		= gpio_event_probe,
+	.remove		= gpio_event_remove,
+	.driver		= {
+		.name	= GPIO_EVENT_DEV_NAME,
+	},
+};
+
+module_platform_driver(gpio_event_driver);
+
+MODULE_DESCRIPTION("GPIO Event Driver");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/input/misc/gpio_input.c b/drivers/input/misc/gpio_input.c
new file mode 100644
index 00000000..eefd0272
--- /dev/null
+++ b/drivers/input/misc/gpio_input.c
@@ -0,0 +1,390 @@
+/* drivers/input/misc/gpio_input.c
+ *
+ * Copyright (C) 2007 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/gpio.h>
+#include <linux/gpio_event.h>
+#include <linux/hrtimer.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/pm_wakeup.h>
+
+enum {
+	DEBOUNCE_UNSTABLE     = BIT(0),	/* Got irq, while debouncing */
+	DEBOUNCE_PRESSED      = BIT(1),
+	DEBOUNCE_NOTPRESSED   = BIT(2),
+	DEBOUNCE_WAIT_IRQ     = BIT(3),	/* Stable irq state */
+	DEBOUNCE_POLL         = BIT(4),	/* Stable polling state */
+
+	DEBOUNCE_UNKNOWN =
+		DEBOUNCE_PRESSED | DEBOUNCE_NOTPRESSED,
+};
+
+struct gpio_key_state {
+	struct gpio_input_state *ds;
+	uint8_t debounce;
+};
+
+struct gpio_input_state {
+	struct gpio_event_input_devs *input_devs;
+	const struct gpio_event_input_info *info;
+	struct hrtimer timer;
+	int use_irq;
+	int debounce_count;
+	spinlock_t irq_lock;
+	struct wakeup_source *ws;
+	struct gpio_key_state key_state[0];
+};
+
+static enum hrtimer_restart gpio_event_input_timer_func(struct hrtimer *timer)
+{
+	int i;
+	int pressed;
+	struct gpio_input_state *ds =
+		container_of(timer, struct gpio_input_state, timer);
+	unsigned gpio_flags = ds->info->flags;
+	unsigned npolarity;
+	int nkeys = ds->info->keymap_size;
+	const struct gpio_event_direct_entry *key_entry;
+	struct gpio_key_state *key_state;
+	unsigned long irqflags;
+	uint8_t debounce;
+	bool sync_needed;
+
+#if 0
+	key_entry = kp->keys_info->keymap;
+	key_state = kp->key_state;
+	for (i = 0; i < nkeys; i++, key_entry++, key_state++)
+		pr_info("gpio_read_detect_status %d %d\n", key_entry->gpio,
+			gpio_read_detect_status(key_entry->gpio));
+#endif
+	key_entry = ds->info->keymap;
+	key_state = ds->key_state;
+	sync_needed = false;
+	spin_lock_irqsave(&ds->irq_lock, irqflags);
+	for (i = 0; i < nkeys; i++, key_entry++, key_state++) {
+		debounce = key_state->debounce;
+		if (debounce & DEBOUNCE_WAIT_IRQ)
+			continue;
+		if (key_state->debounce & DEBOUNCE_UNSTABLE) {
+			debounce = key_state->debounce = DEBOUNCE_UNKNOWN;
+			enable_irq(gpio_to_irq(key_entry->gpio));
+			if (gpio_flags & GPIOEDF_PRINT_KEY_UNSTABLE)
+				pr_info("gpio_keys_scan_keys: key %x-%x, %d "
+					"(%d) continue debounce\n",
+					ds->info->type, key_entry->code,
+					i, key_entry->gpio);
+		}
+		npolarity = !(gpio_flags & GPIOEDF_ACTIVE_HIGH);
+		pressed = gpio_get_value(key_entry->gpio) ^ npolarity;
+		if (debounce & DEBOUNCE_POLL) {
+			if (pressed == !(debounce & DEBOUNCE_PRESSED)) {
+				ds->debounce_count++;
+				key_state->debounce = DEBOUNCE_UNKNOWN;
+				if (gpio_flags & GPIOEDF_PRINT_KEY_DEBOUNCE)
+					pr_info("gpio_keys_scan_keys: key %x-"
+						"%x, %d (%d) start debounce\n",
+						ds->info->type, key_entry->code,
+						i, key_entry->gpio);
+			}
+			continue;
+		}
+		if (pressed && (debounce & DEBOUNCE_NOTPRESSED)) {
+			if (gpio_flags & GPIOEDF_PRINT_KEY_DEBOUNCE)
+				pr_info("gpio_keys_scan_keys: key %x-%x, %d "
+					"(%d) debounce pressed 1\n",
+					ds->info->type, key_entry->code,
+					i, key_entry->gpio);
+			key_state->debounce = DEBOUNCE_PRESSED;
+			continue;
+		}
+		if (!pressed && (debounce & DEBOUNCE_PRESSED)) {
+			if (gpio_flags & GPIOEDF_PRINT_KEY_DEBOUNCE)
+				pr_info("gpio_keys_scan_keys: key %x-%x, %d "
+					"(%d) debounce pressed 0\n",
+					ds->info->type, key_entry->code,
+					i, key_entry->gpio);
+			key_state->debounce = DEBOUNCE_NOTPRESSED;
+			continue;
+		}
+		/* key is stable */
+		ds->debounce_count--;
+		if (ds->use_irq)
+			key_state->debounce |= DEBOUNCE_WAIT_IRQ;
+		else
+			key_state->debounce |= DEBOUNCE_POLL;
+		if (gpio_flags & GPIOEDF_PRINT_KEYS)
+			pr_info("gpio_keys_scan_keys: key %x-%x, %d (%d) "
+				"changed to %d\n", ds->info->type,
+				key_entry->code, i, key_entry->gpio, pressed);
+		input_event(ds->input_devs->dev[key_entry->dev], ds->info->type,
+			    key_entry->code, pressed);
+		sync_needed = true;
+	}
+	if (sync_needed) {
+		for (i = 0; i < ds->input_devs->count; i++)
+			input_sync(ds->input_devs->dev[i]);
+	}
+
+#if 0
+	key_entry = kp->keys_info->keymap;
+	key_state = kp->key_state;
+	for (i = 0; i < nkeys; i++, key_entry++, key_state++) {
+		pr_info("gpio_read_detect_status %d %d\n", key_entry->gpio,
+			gpio_read_detect_status(key_entry->gpio));
+	}
+#endif
+
+	if (ds->debounce_count)
+		hrtimer_start(timer, ds->info->debounce_time, HRTIMER_MODE_REL);
+	else if (!ds->use_irq)
+		hrtimer_start(timer, ds->info->poll_time, HRTIMER_MODE_REL);
+	else
+		__pm_relax(ds->ws);
+
+	spin_unlock_irqrestore(&ds->irq_lock, irqflags);
+
+	return HRTIMER_NORESTART;
+}
+
+static irqreturn_t gpio_event_input_irq_handler(int irq, void *dev_id)
+{
+	struct gpio_key_state *ks = dev_id;
+	struct gpio_input_state *ds = ks->ds;
+	int keymap_index = ks - ds->key_state;
+	const struct gpio_event_direct_entry *key_entry;
+	unsigned long irqflags;
+	int pressed;
+
+	if (!ds->use_irq)
+		return IRQ_HANDLED;
+
+	key_entry = &ds->info->keymap[keymap_index];
+
+	if (ds->info->debounce_time.tv64) {
+		spin_lock_irqsave(&ds->irq_lock, irqflags);
+		if (ks->debounce & DEBOUNCE_WAIT_IRQ) {
+			ks->debounce = DEBOUNCE_UNKNOWN;
+			if (ds->debounce_count++ == 0) {
+				__pm_stay_awake(ds->ws);
+				hrtimer_start(
+					&ds->timer, ds->info->debounce_time,
+					HRTIMER_MODE_REL);
+			}
+			if (ds->info->flags & GPIOEDF_PRINT_KEY_DEBOUNCE)
+				pr_info("gpio_event_input_irq_handler: "
+					"key %x-%x, %d (%d) start debounce\n",
+					ds->info->type, key_entry->code,
+					keymap_index, key_entry->gpio);
+		} else {
+			disable_irq_nosync(irq);
+			ks->debounce = DEBOUNCE_UNSTABLE;
+		}
+		spin_unlock_irqrestore(&ds->irq_lock, irqflags);
+	} else {
+		pressed = gpio_get_value(key_entry->gpio) ^
+			!(ds->info->flags & GPIOEDF_ACTIVE_HIGH);
+		if (ds->info->flags & GPIOEDF_PRINT_KEYS)
+			pr_info("gpio_event_input_irq_handler: key %x-%x, %d "
+				"(%d) changed to %d\n",
+				ds->info->type, key_entry->code, keymap_index,
+				key_entry->gpio, pressed);
+		input_event(ds->input_devs->dev[key_entry->dev], ds->info->type,
+			    key_entry->code, pressed);
+		input_sync(ds->input_devs->dev[key_entry->dev]);
+	}
+	return IRQ_HANDLED;
+}
+
+static int gpio_event_input_request_irqs(struct gpio_input_state *ds)
+{
+	int i;
+	int err;
+	unsigned int irq;
+	unsigned long req_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
+
+	for (i = 0; i < ds->info->keymap_size; i++) {
+		err = irq = gpio_to_irq(ds->info->keymap[i].gpio);
+		if (err < 0)
+			goto err_gpio_get_irq_num_failed;
+		err = request_irq(irq, gpio_event_input_irq_handler,
+				  req_flags, "gpio_keys", &ds->key_state[i]);
+		if (err) {
+			pr_err("gpio_event_input_request_irqs: request_irq "
+				"failed for input %d, irq %d\n",
+				ds->info->keymap[i].gpio, irq);
+			goto err_request_irq_failed;
+		}
+		if (ds->info->info.no_suspend) {
+			err = enable_irq_wake(irq);
+			if (err) {
+				pr_err("gpio_event_input_request_irqs: "
+					"enable_irq_wake failed for input %d, "
+					"irq %d\n",
+					ds->info->keymap[i].gpio, irq);
+				goto err_enable_irq_wake_failed;
+			}
+		}
+	}
+	return 0;
+
+	for (i = ds->info->keymap_size - 1; i >= 0; i--) {
+		irq = gpio_to_irq(ds->info->keymap[i].gpio);
+		if (ds->info->info.no_suspend)
+			disable_irq_wake(irq);
+err_enable_irq_wake_failed:
+		free_irq(irq, &ds->key_state[i]);
+err_request_irq_failed:
+err_gpio_get_irq_num_failed:
+		;
+	}
+	return err;
+}
+
+int gpio_event_input_func(struct gpio_event_input_devs *input_devs,
+			struct gpio_event_info *info, void **data, int func)
+{
+	int ret;
+	int i;
+	unsigned long irqflags;
+	struct gpio_event_input_info *di;
+	struct gpio_input_state *ds = *data;
+	char *wlname;
+
+	di = container_of(info, struct gpio_event_input_info, info);
+
+	if (func == GPIO_EVENT_FUNC_SUSPEND) {
+		if (ds->use_irq)
+			for (i = 0; i < di->keymap_size; i++)
+				disable_irq(gpio_to_irq(di->keymap[i].gpio));
+		hrtimer_cancel(&ds->timer);
+		return 0;
+	}
+	if (func == GPIO_EVENT_FUNC_RESUME) {
+		spin_lock_irqsave(&ds->irq_lock, irqflags);
+		if (ds->use_irq)
+			for (i = 0; i < di->keymap_size; i++)
+				enable_irq(gpio_to_irq(di->keymap[i].gpio));
+		hrtimer_start(&ds->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
+		spin_unlock_irqrestore(&ds->irq_lock, irqflags);
+		return 0;
+	}
+
+	if (func == GPIO_EVENT_FUNC_INIT) {
+		if (ktime_to_ns(di->poll_time) <= 0)
+			di->poll_time = ktime_set(0, 20 * NSEC_PER_MSEC);
+
+		*data = ds = kzalloc(sizeof(*ds) + sizeof(ds->key_state[0]) *
+					di->keymap_size, GFP_KERNEL);
+		if (ds == NULL) {
+			ret = -ENOMEM;
+			pr_err("gpio_event_input_func: "
+				"Failed to allocate private data\n");
+			goto err_ds_alloc_failed;
+		}
+		ds->debounce_count = di->keymap_size;
+		ds->input_devs = input_devs;
+		ds->info = di;
+		wlname = kasprintf(GFP_KERNEL, "gpio_input:%s%s",
+				   input_devs->dev[0]->name,
+				   (input_devs->count > 1) ? "..." : "");
+
+		ds->ws = wakeup_source_register(wlname);
+		kfree(wlname);
+		if (!ds->ws) {
+			ret = -ENOMEM;
+			pr_err("gpio_event_input_func: "
+				"Failed to allocate wakeup source\n");
+			goto err_ws_failed;
+		}
+
+		spin_lock_init(&ds->irq_lock);
+
+		for (i = 0; i < di->keymap_size; i++) {
+			int dev = di->keymap[i].dev;
+			if (dev >= input_devs->count) {
+				pr_err("gpio_event_input_func: bad device "
+					"index %d >= %d for key code %d\n",
+					dev, input_devs->count,
+					di->keymap[i].code);
+				ret = -EINVAL;
+				goto err_bad_keymap;
+			}
+			input_set_capability(input_devs->dev[dev], di->type,
+					     di->keymap[i].code);
+			ds->key_state[i].ds = ds;
+			ds->key_state[i].debounce = DEBOUNCE_UNKNOWN;
+		}
+
+		for (i = 0; i < di->keymap_size; i++) {
+			ret = gpio_request(di->keymap[i].gpio, "gpio_kp_in");
+			if (ret) {
+				pr_err("gpio_event_input_func: gpio_request "
+					"failed for %d\n", di->keymap[i].gpio);
+				goto err_gpio_request_failed;
+			}
+			ret = gpio_direction_input(di->keymap[i].gpio);
+			if (ret) {
+				pr_err("gpio_event_input_func: "
+					"gpio_direction_input failed for %d\n",
+					di->keymap[i].gpio);
+				goto err_gpio_configure_failed;
+			}
+		}
+
+		ret = gpio_event_input_request_irqs(ds);
+
+		spin_lock_irqsave(&ds->irq_lock, irqflags);
+		ds->use_irq = ret == 0;
+
+		pr_info("GPIO Input Driver: Start gpio inputs for %s%s in %s "
+			"mode\n", input_devs->dev[0]->name,
+			(input_devs->count > 1) ? "..." : "",
+			ret == 0 ? "interrupt" : "polling");
+
+		hrtimer_init(&ds->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+		ds->timer.function = gpio_event_input_timer_func;
+		hrtimer_start(&ds->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
+		spin_unlock_irqrestore(&ds->irq_lock, irqflags);
+		return 0;
+	}
+
+	ret = 0;
+	spin_lock_irqsave(&ds->irq_lock, irqflags);
+	hrtimer_cancel(&ds->timer);
+	if (ds->use_irq) {
+		for (i = di->keymap_size - 1; i >= 0; i--) {
+			int irq = gpio_to_irq(di->keymap[i].gpio);
+			if (ds->info->info.no_suspend)
+				disable_irq_wake(irq);
+			free_irq(irq, &ds->key_state[i]);
+		}
+	}
+	spin_unlock_irqrestore(&ds->irq_lock, irqflags);
+
+	for (i = di->keymap_size - 1; i >= 0; i--) {
+err_gpio_configure_failed:
+		gpio_free(di->keymap[i].gpio);
+err_gpio_request_failed:
+		;
+	}
+err_bad_keymap:
+	wakeup_source_unregister(ds->ws);
+err_ws_failed:
+	kfree(ds);
+err_ds_alloc_failed:
+	return ret;
+}
diff --git a/drivers/input/misc/gpio_matrix.c b/drivers/input/misc/gpio_matrix.c
new file mode 100644
index 00000000..eaa9e89d
--- /dev/null
+++ b/drivers/input/misc/gpio_matrix.c
@@ -0,0 +1,441 @@
+/* drivers/input/misc/gpio_matrix.c
+ *
+ * Copyright (C) 2007 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/gpio.h>
+#include <linux/gpio_event.h>
+#include <linux/hrtimer.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/wakelock.h>
+
+struct gpio_kp {
+	struct gpio_event_input_devs *input_devs;
+	struct gpio_event_matrix_info *keypad_info;
+	struct hrtimer timer;
+	struct wake_lock wake_lock;
+	int current_output;
+	unsigned int use_irq:1;
+	unsigned int key_state_changed:1;
+	unsigned int last_key_state_changed:1;
+	unsigned int some_keys_pressed:2;
+	unsigned int disabled_irq:1;
+	unsigned long keys_pressed[0];
+};
+
+static void clear_phantom_key(struct gpio_kp *kp, int out, int in)
+{
+	struct gpio_event_matrix_info *mi = kp->keypad_info;
+	int key_index = out * mi->ninputs + in;
+	unsigned short keyentry = mi->keymap[key_index];
+	unsigned short keycode = keyentry & MATRIX_KEY_MASK;
+	unsigned short dev = keyentry >> MATRIX_CODE_BITS;
+
+	if (!test_bit(keycode, kp->input_devs->dev[dev]->key)) {
+		if (mi->flags & GPIOKPF_PRINT_PHANTOM_KEYS)
+			pr_info("gpiomatrix: phantom key %x, %d-%d (%d-%d) "
+				"cleared\n", keycode, out, in,
+				mi->output_gpios[out], mi->input_gpios[in]);
+		__clear_bit(key_index, kp->keys_pressed);
+	} else {
+		if (mi->flags & GPIOKPF_PRINT_PHANTOM_KEYS)
+			pr_info("gpiomatrix: phantom key %x, %d-%d (%d-%d) "
+				"not cleared\n", keycode, out, in,
+				mi->output_gpios[out], mi->input_gpios[in]);
+	}
+}
+
+static int restore_keys_for_input(struct gpio_kp *kp, int out, int in)
+{
+	int rv = 0;
+	int key_index;
+
+	key_index = out * kp->keypad_info->ninputs + in;
+	while (out < kp->keypad_info->noutputs) {
+		if (test_bit(key_index, kp->keys_pressed)) {
+			rv = 1;
+			clear_phantom_key(kp, out, in);
+		}
+		key_index += kp->keypad_info->ninputs;
+		out++;
+	}
+	return rv;
+}
+
+static void remove_phantom_keys(struct gpio_kp *kp)
+{
+	int out, in, inp;
+	int key_index;
+
+	if (kp->some_keys_pressed < 3)
+		return;
+
+	for (out = 0; out < kp->keypad_info->noutputs; out++) {
+		inp = -1;
+		key_index = out * kp->keypad_info->ninputs;
+		for (in = 0; in < kp->keypad_info->ninputs; in++, key_index++) {
+			if (test_bit(key_index, kp->keys_pressed)) {
+				if (inp == -1) {
+					inp = in;
+					continue;
+				}
+				if (inp >= 0) {
+					if (!restore_keys_for_input(kp, out + 1,
+									inp))
+						break;
+					clear_phantom_key(kp, out, inp);
+					inp = -2;
+				}
+				restore_keys_for_input(kp, out, in);
+			}
+		}
+	}
+}
+
+static void report_key(struct gpio_kp *kp, int key_index, int out, int in)
+{
+	struct gpio_event_matrix_info *mi = kp->keypad_info;
+	int pressed = test_bit(key_index, kp->keys_pressed);
+	unsigned short keyentry = mi->keymap[key_index];
+	unsigned short keycode = keyentry & MATRIX_KEY_MASK;
+	unsigned short dev = keyentry >> MATRIX_CODE_BITS;
+
+	if (pressed != test_bit(keycode, kp->input_devs->dev[dev]->key)) {
+		if (keycode == KEY_RESERVED) {
+			if (mi->flags & GPIOKPF_PRINT_UNMAPPED_KEYS)
+				pr_info("gpiomatrix: unmapped key, %d-%d "
+					"(%d-%d) changed to %d\n",
+					out, in, mi->output_gpios[out],
+					mi->input_gpios[in], pressed);
+		} else {
+			if (mi->flags & GPIOKPF_PRINT_MAPPED_KEYS)
+				pr_info("gpiomatrix: key %x, %d-%d (%d-%d) "
+					"changed to %d\n", keycode,
+					out, in, mi->output_gpios[out],
+					mi->input_gpios[in], pressed);
+			input_report_key(kp->input_devs->dev[dev], keycode, pressed);
+		}
+	}
+}
+
+static void report_sync(struct gpio_kp *kp)
+{
+	int i;
+
+	for (i = 0; i < kp->input_devs->count; i++)
+		input_sync(kp->input_devs->dev[i]);
+}
+
+static enum hrtimer_restart gpio_keypad_timer_func(struct hrtimer *timer)
+{
+	int out, in;
+	int key_index;
+	int gpio;
+	struct gpio_kp *kp = container_of(timer, struct gpio_kp, timer);
+	struct gpio_event_matrix_info *mi = kp->keypad_info;
+	unsigned gpio_keypad_flags = mi->flags;
+	unsigned polarity = !!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH);
+
+	out = kp->current_output;
+	if (out == mi->noutputs) {
+		out = 0;
+		kp->last_key_state_changed = kp->key_state_changed;
+		kp->key_state_changed = 0;
+		kp->some_keys_pressed = 0;
+	} else {
+		key_index = out * mi->ninputs;
+		for (in = 0; in < mi->ninputs; in++, key_index++) {
+			gpio = mi->input_gpios[in];
+			if (gpio_get_value(gpio) ^ !polarity) {
+				if (kp->some_keys_pressed < 3)
+					kp->some_keys_pressed++;
+				kp->key_state_changed |= !__test_and_set_bit(
+						key_index, kp->keys_pressed);
+			} else
+				kp->key_state_changed |= __test_and_clear_bit(
+						key_index, kp->keys_pressed);
+		}
+		gpio = mi->output_gpios[out];
+		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
+			gpio_set_value(gpio, !polarity);
+		else
+			gpio_direction_input(gpio);
+		out++;
+	}
+	kp->current_output = out;
+	if (out < mi->noutputs) {
+		gpio = mi->output_gpios[out];
+		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
+			gpio_set_value(gpio, polarity);
+		else
+			gpio_direction_output(gpio, polarity);
+		hrtimer_start(timer, mi->settle_time, HRTIMER_MODE_REL);
+		return HRTIMER_NORESTART;
+	}
+	if (gpio_keypad_flags & GPIOKPF_DEBOUNCE) {
+		if (kp->key_state_changed) {
+			hrtimer_start(&kp->timer, mi->debounce_delay,
+				      HRTIMER_MODE_REL);
+			return HRTIMER_NORESTART;
+		}
+		kp->key_state_changed = kp->last_key_state_changed;
+	}
+	if (kp->key_state_changed) {
+		if (gpio_keypad_flags & GPIOKPF_REMOVE_SOME_PHANTOM_KEYS)
+			remove_phantom_keys(kp);
+		key_index = 0;
+		for (out = 0; out < mi->noutputs; out++)
+			for (in = 0; in < mi->ninputs; in++, key_index++)
+				report_key(kp, key_index, out, in);
+		report_sync(kp);
+	}
+	if (!kp->use_irq || kp->some_keys_pressed) {
+		hrtimer_start(timer, mi->poll_time, HRTIMER_MODE_REL);
+		return HRTIMER_NORESTART;
+	}
+
+	/* No keys are pressed, reenable interrupt */
+	for (out = 0; out < mi->noutputs; out++) {
+		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
+			gpio_set_value(mi->output_gpios[out], polarity);
+		else
+			gpio_direction_output(mi->output_gpios[out], polarity);
+	}
+	for (in = 0; in < mi->ninputs; in++)
+		enable_irq(gpio_to_irq(mi->input_gpios[in]));
+	wake_unlock(&kp->wake_lock);
+	return HRTIMER_NORESTART;
+}
+
+static irqreturn_t gpio_keypad_irq_handler(int irq_in, void *dev_id)
+{
+	int i;
+	struct gpio_kp *kp = dev_id;
+	struct gpio_event_matrix_info *mi = kp->keypad_info;
+	unsigned gpio_keypad_flags = mi->flags;
+
+	if (!kp->use_irq) {
+		/* ignore interrupt while registering the handler */
+		kp->disabled_irq = 1;
+		disable_irq_nosync(irq_in);
+		return IRQ_HANDLED;
+	}
+
+	for (i = 0; i < mi->ninputs; i++)
+		disable_irq_nosync(gpio_to_irq(mi->input_gpios[i]));
+	for (i = 0; i < mi->noutputs; i++) {
+		if (gpio_keypad_flags & GPIOKPF_DRIVE_INACTIVE)
+			gpio_set_value(mi->output_gpios[i],
+				!(gpio_keypad_flags & GPIOKPF_ACTIVE_HIGH));
+		else
+			gpio_direction_input(mi->output_gpios[i]);
+	}
+	wake_lock(&kp->wake_lock);
+	hrtimer_start(&kp->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
+	return IRQ_HANDLED;
+}
+
+static int gpio_keypad_request_irqs(struct gpio_kp *kp)
+{
+	int i;
+	int err;
+	unsigned int irq;
+	unsigned long request_flags;
+	struct gpio_event_matrix_info *mi = kp->keypad_info;
+
+	switch (mi->flags & (GPIOKPF_ACTIVE_HIGH|GPIOKPF_LEVEL_TRIGGERED_IRQ)) {
+	default:
+		request_flags = IRQF_TRIGGER_FALLING;
+		break;
+	case GPIOKPF_ACTIVE_HIGH:
+		request_flags = IRQF_TRIGGER_RISING;
+		break;
+	case GPIOKPF_LEVEL_TRIGGERED_IRQ:
+		request_flags = IRQF_TRIGGER_LOW;
+		break;
+	case GPIOKPF_LEVEL_TRIGGERED_IRQ | GPIOKPF_ACTIVE_HIGH:
+		request_flags = IRQF_TRIGGER_HIGH;
+		break;
+	}
+
+	for (i = 0; i < mi->ninputs; i++) {
+		err = irq = gpio_to_irq(mi->input_gpios[i]);
+		if (err < 0)
+			goto err_gpio_get_irq_num_failed;
+		err = request_irq(irq, gpio_keypad_irq_handler, request_flags,
+				  "gpio_kp", kp);
+		if (err) {
+			pr_err("gpiomatrix: request_irq failed for input %d, "
+				"irq %d\n", mi->input_gpios[i], irq);
+			goto err_request_irq_failed;
+		}
+		err = enable_irq_wake(irq);
+		if (err) {
+			pr_err("gpiomatrix: set_irq_wake failed for input %d, "
+				"irq %d\n", mi->input_gpios[i], irq);
+		}
+		disable_irq(irq);
+		if (kp->disabled_irq) {
+			kp->disabled_irq = 0;
+			enable_irq(irq);
+		}
+	}
+	return 0;
+
+	for (i = mi->noutputs - 1; i >= 0; i--) {
+		free_irq(gpio_to_irq(mi->input_gpios[i]), kp);
+err_request_irq_failed:
+err_gpio_get_irq_num_failed:
+		;
+	}
+	return err;
+}
+
+int gpio_event_matrix_func(struct gpio_event_input_devs *input_devs,
+	struct gpio_event_info *info, void **data, int func)
+{
+	int i;
+	int err;
+	int key_count;
+	struct gpio_kp *kp;
+	struct gpio_event_matrix_info *mi;
+
+	mi = container_of(info, struct gpio_event_matrix_info, info);
+	if (func == GPIO_EVENT_FUNC_SUSPEND || func == GPIO_EVENT_FUNC_RESUME) {
+		/* TODO: disable scanning */
+		return 0;
+	}
+
+	if (func == GPIO_EVENT_FUNC_INIT) {
+		if (mi->keymap == NULL ||
+		   mi->input_gpios == NULL ||
+		   mi->output_gpios == NULL) {
+			err = -ENODEV;
+			pr_err("gpiomatrix: Incomplete pdata\n");
+			goto err_invalid_platform_data;
+		}
+		key_count = mi->ninputs * mi->noutputs;
+
+		*data = kp = kzalloc(sizeof(*kp) + sizeof(kp->keys_pressed[0]) *
+				     BITS_TO_LONGS(key_count), GFP_KERNEL);
+		if (kp == NULL) {
+			err = -ENOMEM;
+			pr_err("gpiomatrix: Failed to allocate private data\n");
+			goto err_kp_alloc_failed;
+		}
+		kp->input_devs = input_devs;
+		kp->keypad_info = mi;
+		for (i = 0; i < key_count; i++) {
+			unsigned short keyentry = mi->keymap[i];
+			unsigned short keycode = keyentry & MATRIX_KEY_MASK;
+			unsigned short dev = keyentry >> MATRIX_CODE_BITS;
+			if (dev >= input_devs->count) {
+				pr_err("gpiomatrix: bad device index %d >= "
+					"%d for key code %d\n",
+					dev, input_devs->count, keycode);
+				err = -EINVAL;
+				goto err_bad_keymap;
+			}
+			if (keycode && keycode <= KEY_MAX)
+				input_set_capability(input_devs->dev[dev],
+							EV_KEY, keycode);
+		}
+
+		for (i = 0; i < mi->noutputs; i++) {
+			err = gpio_request(mi->output_gpios[i], "gpio_kp_out");
+			if (err) {
+				pr_err("gpiomatrix: gpio_request failed for "
+					"output %d\n", mi->output_gpios[i]);
+				goto err_request_output_gpio_failed;
+			}
+			if (gpio_cansleep(mi->output_gpios[i])) {
+				pr_err("gpiomatrix: unsupported output gpio %d,"
+					" can sleep\n", mi->output_gpios[i]);
+				err = -EINVAL;
+				goto err_output_gpio_configure_failed;
+			}
+			if (mi->flags & GPIOKPF_DRIVE_INACTIVE)
+				err = gpio_direction_output(mi->output_gpios[i],
+					!(mi->flags & GPIOKPF_ACTIVE_HIGH));
+			else
+				err = gpio_direction_input(mi->output_gpios[i]);
+			if (err) {
+				pr_err("gpiomatrix: gpio_configure failed for "
+					"output %d\n", mi->output_gpios[i]);
+				goto err_output_gpio_configure_failed;
+			}
+		}
+		for (i = 0; i < mi->ninputs; i++) {
+			err = gpio_request(mi->input_gpios[i], "gpio_kp_in");
+			if (err) {
+				pr_err("gpiomatrix: gpio_request failed for "
+					"input %d\n", mi->input_gpios[i]);
+				goto err_request_input_gpio_failed;
+			}
+			err = gpio_direction_input(mi->input_gpios[i]);
+			if (err) {
+				pr_err("gpiomatrix: gpio_direction_input failed"
+					" for input %d\n", mi->input_gpios[i]);
+				goto err_gpio_direction_input_failed;
+			}
+		}
+		kp->current_output = mi->noutputs;
+		kp->key_state_changed = 1;
+
+		hrtimer_init(&kp->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+		kp->timer.function = gpio_keypad_timer_func;
+		wake_lock_init(&kp->wake_lock, WAKE_LOCK_SUSPEND, "gpio_kp");
+		err = gpio_keypad_request_irqs(kp);
+		kp->use_irq = err == 0;
+
+		pr_info("GPIO Matrix Keypad Driver: Start keypad matrix for "
+			"%s%s in %s mode\n", input_devs->dev[0]->name,
+			(input_devs->count > 1) ? "..." : "",
+			kp->use_irq ? "interrupt" : "polling");
+
+		if (kp->use_irq)
+			wake_lock(&kp->wake_lock);
+		hrtimer_start(&kp->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
+
+		return 0;
+	}
+
+	err = 0;
+	kp = *data;
+
+	if (kp->use_irq)
+		for (i = mi->noutputs - 1; i >= 0; i--)
+			free_irq(gpio_to_irq(mi->input_gpios[i]), kp);
+
+	hrtimer_cancel(&kp->timer);
+	wake_lock_destroy(&kp->wake_lock);
+	for (i = mi->noutputs - 1; i >= 0; i--) {
+err_gpio_direction_input_failed:
+		gpio_free(mi->input_gpios[i]);
+err_request_input_gpio_failed:
+		;
+	}
+	for (i = mi->noutputs - 1; i >= 0; i--) {
+err_output_gpio_configure_failed:
+		gpio_free(mi->output_gpios[i]);
+err_request_output_gpio_failed:
+		;
+	}
+err_bad_keymap:
+	kfree(kp);
+err_kp_alloc_failed:
+err_invalid_platform_data:
+	return err;
+}
diff --git a/drivers/input/misc/gpio_output.c b/drivers/input/misc/gpio_output.c
new file mode 100644
index 00000000..2aac2fad
--- /dev/null
+++ b/drivers/input/misc/gpio_output.c
@@ -0,0 +1,97 @@
+/* drivers/input/misc/gpio_output.c
+ *
+ * Copyright (C) 2007 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/gpio.h>
+#include <linux/gpio_event.h>
+
+int gpio_event_output_event(
+	struct gpio_event_input_devs *input_devs, struct gpio_event_info *info,
+	void **data, unsigned int dev, unsigned int type,
+	unsigned int code, int value)
+{
+	int i;
+	struct gpio_event_output_info *oi;
+	oi = container_of(info, struct gpio_event_output_info, info);
+	if (type != oi->type)
+		return 0;
+	if (!(oi->flags & GPIOEDF_ACTIVE_HIGH))
+		value = !value;
+	for (i = 0; i < oi->keymap_size; i++)
+		if (dev == oi->keymap[i].dev && code == oi->keymap[i].code)
+			gpio_set_value(oi->keymap[i].gpio, value);
+	return 0;
+}
+
+int gpio_event_output_func(
+	struct gpio_event_input_devs *input_devs, struct gpio_event_info *info,
+	void **data, int func)
+{
+	int ret;
+	int i;
+	struct gpio_event_output_info *oi;
+	oi = container_of(info, struct gpio_event_output_info, info);
+
+	if (func == GPIO_EVENT_FUNC_SUSPEND || func == GPIO_EVENT_FUNC_RESUME)
+		return 0;
+
+	if (func == GPIO_EVENT_FUNC_INIT) {
+		int output_level = !(oi->flags & GPIOEDF_ACTIVE_HIGH);
+
+		for (i = 0; i < oi->keymap_size; i++) {
+			int dev = oi->keymap[i].dev;
+			if (dev >= input_devs->count) {
+				pr_err("gpio_event_output_func: bad device "
+					"index %d >= %d for key code %d\n",
+					dev, input_devs->count,
+					oi->keymap[i].code);
+				ret = -EINVAL;
+				goto err_bad_keymap;
+			}
+			input_set_capability(input_devs->dev[dev], oi->type,
+					     oi->keymap[i].code);
+		}
+
+		for (i = 0; i < oi->keymap_size; i++) {
+			ret = gpio_request(oi->keymap[i].gpio,
+					   "gpio_event_output");
+			if (ret) {
+				pr_err("gpio_event_output_func: gpio_request "
+					"failed for %d\n", oi->keymap[i].gpio);
+				goto err_gpio_request_failed;
+			}
+			ret = gpio_direction_output(oi->keymap[i].gpio,
+						    output_level);
+			if (ret) {
+				pr_err("gpio_event_output_func: "
+					"gpio_direction_output failed for %d\n",
+					oi->keymap[i].gpio);
+				goto err_gpio_direction_output_failed;
+			}
+		}
+		return 0;
+	}
+
+	ret = 0;
+	for (i = oi->keymap_size - 1; i >= 0; i--) {
+err_gpio_direction_output_failed:
+		gpio_free(oi->keymap[i].gpio);
+err_gpio_request_failed:
+		;
+	}
+err_bad_keymap:
+	return ret;
+}
+
diff --git a/drivers/input/misc/gpio_tilt_polled.c b/drivers/input/misc/gpio_tilt_polled.c
new file mode 100644
index 00000000..da05cca8
--- /dev/null
+++ b/drivers/input/misc/gpio_tilt_polled.c
@@ -0,0 +1,213 @@
+/*
+ *  Driver for tilt switches connected via GPIO lines
+ *  not capable of generating interrupts
+ *
+ *  Copyright (C) 2011 Heiko Stuebner <heiko@sntech.de>
+ *
+ *  based on: drivers/input/keyboard/gpio_keys_polled.c
+ *
+ *  Copyright (C) 2007-2010 Gabor Juhos <juhosg@openwrt.org>
+ *  Copyright (C) 2010 Nuno Goncalves <nunojpg@gmail.com>
+ *
+ *  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/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/input-polldev.h>
+#include <linux/ioport.h>
+#include <linux/platform_device.h>
+#include <linux/gpio.h>
+#include <linux/input/gpio_tilt.h>
+
+#define DRV_NAME	"gpio-tilt-polled"
+
+struct gpio_tilt_polled_dev {
+	struct input_polled_dev *poll_dev;
+	struct device *dev;
+	const struct gpio_tilt_platform_data *pdata;
+
+	int last_state;
+
+	int threshold;
+	int count;
+};
+
+static void gpio_tilt_polled_poll(struct input_polled_dev *dev)
+{
+	struct gpio_tilt_polled_dev *tdev = dev->private;
+	const struct gpio_tilt_platform_data *pdata = tdev->pdata;
+	struct input_dev *input = dev->input;
+	struct gpio_tilt_state *tilt_state = NULL;
+	int state, i;
+
+	if (tdev->count < tdev->threshold) {
+		tdev->count++;
+	} else {
+		state = 0;
+		for (i = 0; i < pdata->nr_gpios; i++)
+			state |= (!!gpio_get_value(pdata->gpios[i].gpio) << i);
+
+		if (state != tdev->last_state) {
+			for (i = 0; i < pdata->nr_states; i++)
+				if (pdata->states[i].gpios == state)
+					tilt_state = &pdata->states[i];
+
+			if (tilt_state) {
+				for (i = 0; i < pdata->nr_axes; i++)
+					input_report_abs(input,
+							 pdata->axes[i].axis,
+							 tilt_state->axes[i]);
+
+				input_sync(input);
+			}
+
+			tdev->count = 0;
+			tdev->last_state = state;
+		}
+	}
+}
+
+static void gpio_tilt_polled_open(struct input_polled_dev *dev)
+{
+	struct gpio_tilt_polled_dev *tdev = dev->private;
+	const struct gpio_tilt_platform_data *pdata = tdev->pdata;
+
+	if (pdata->enable)
+		pdata->enable(tdev->dev);
+
+	/* report initial state of the axes */
+	tdev->last_state = -1;
+	tdev->count = tdev->threshold;
+	gpio_tilt_polled_poll(tdev->poll_dev);
+}
+
+static void gpio_tilt_polled_close(struct input_polled_dev *dev)
+{
+	struct gpio_tilt_polled_dev *tdev = dev->private;
+	const struct gpio_tilt_platform_data *pdata = tdev->pdata;
+
+	if (pdata->disable)
+		pdata->disable(tdev->dev);
+}
+
+static int gpio_tilt_polled_probe(struct platform_device *pdev)
+{
+	const struct gpio_tilt_platform_data *pdata = pdev->dev.platform_data;
+	struct device *dev = &pdev->dev;
+	struct gpio_tilt_polled_dev *tdev;
+	struct input_polled_dev *poll_dev;
+	struct input_dev *input;
+	int error, i;
+
+	if (!pdata || !pdata->poll_interval)
+		return -EINVAL;
+
+	tdev = kzalloc(sizeof(struct gpio_tilt_polled_dev), GFP_KERNEL);
+	if (!tdev) {
+		dev_err(dev, "no memory for private data\n");
+		return -ENOMEM;
+	}
+
+	error = gpio_request_array(pdata->gpios, pdata->nr_gpios);
+	if (error) {
+		dev_err(dev,
+			"Could not request tilt GPIOs: %d\n", error);
+		goto err_free_tdev;
+	}
+
+	poll_dev = input_allocate_polled_device();
+	if (!poll_dev) {
+		dev_err(dev, "no memory for polled device\n");
+		error = -ENOMEM;
+		goto err_free_gpios;
+	}
+
+	poll_dev->private = tdev;
+	poll_dev->poll = gpio_tilt_polled_poll;
+	poll_dev->poll_interval = pdata->poll_interval;
+	poll_dev->open = gpio_tilt_polled_open;
+	poll_dev->close = gpio_tilt_polled_close;
+
+	input = poll_dev->input;
+
+	input->name = pdev->name;
+	input->phys = DRV_NAME"/input0";
+	input->dev.parent = &pdev->dev;
+
+	input->id.bustype = BUS_HOST;
+	input->id.vendor = 0x0001;
+	input->id.product = 0x0001;
+	input->id.version = 0x0100;
+
+	__set_bit(EV_ABS, input->evbit);
+	for (i = 0; i < pdata->nr_axes; i++)
+		input_set_abs_params(input, pdata->axes[i].axis,
+				     pdata->axes[i].min, pdata->axes[i].max,
+				     pdata->axes[i].fuzz, pdata->axes[i].flat);
+
+	tdev->threshold = DIV_ROUND_UP(pdata->debounce_interval,
+				       pdata->poll_interval);
+
+	tdev->poll_dev = poll_dev;
+	tdev->dev = dev;
+	tdev->pdata = pdata;
+
+	error = input_register_polled_device(poll_dev);
+	if (error) {
+		dev_err(dev, "unable to register polled device, err=%d\n",
+			error);
+		goto err_free_polldev;
+	}
+
+	platform_set_drvdata(pdev, tdev);
+
+	return 0;
+
+err_free_polldev:
+	input_free_polled_device(poll_dev);
+err_free_gpios:
+	gpio_free_array(pdata->gpios, pdata->nr_gpios);
+err_free_tdev:
+	kfree(tdev);
+
+	return error;
+}
+
+static int gpio_tilt_polled_remove(struct platform_device *pdev)
+{
+	struct gpio_tilt_polled_dev *tdev = platform_get_drvdata(pdev);
+	const struct gpio_tilt_platform_data *pdata = tdev->pdata;
+
+	platform_set_drvdata(pdev, NULL);
+
+	input_unregister_polled_device(tdev->poll_dev);
+	input_free_polled_device(tdev->poll_dev);
+
+	gpio_free_array(pdata->gpios, pdata->nr_gpios);
+
+	kfree(tdev);
+
+	return 0;
+}
+
+static struct platform_driver gpio_tilt_polled_driver = {
+	.probe	= gpio_tilt_polled_probe,
+	.remove	= gpio_tilt_polled_remove,
+	.driver	= {
+		.name	= DRV_NAME,
+		.owner	= THIS_MODULE,
+	},
+};
+
+module_platform_driver(gpio_tilt_polled_driver);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");
+MODULE_DESCRIPTION("Polled GPIO tilt driver");
+MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/input/misc/headset.c b/drivers/input/misc/headset.c
new file mode 100644
index 00000000..9a46670e
--- /dev/null
+++ b/drivers/input/misc/headset.c
@@ -0,0 +1,462 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/delay.h>
+#include <mach/gpio.h>
+#include <linux/headset.h>
+#include <mach/board.h>
+
+#ifndef HEADSET_DETECT_GPIO
+#define HEADSET_DETECT_GPIO 165
+#endif
+#ifndef HEADSET_BUTTON_GPIO
+#define HEADSET_BUTTON_GPIO 164
+#endif
+
+#ifndef HEADSET_DETECT_GPIO_ACTIVE_LOW
+#define HEADSET_DETECT_GPIO_ACTIVE_LOW 1
+#endif
+#ifndef HEADSET_BUTTON_GPIO_ACTIVE_LOW
+#define HEADSET_BUTTON_GPIO_ACTIVE_LOW 0
+#endif
+
+#ifndef HEADSET_DETECT_GPIO_DEBOUNCE_SW
+#define HEADSET_DETECT_GPIO_DEBOUNCE_SW 1000
+#endif
+#ifndef HEADSET_BUTTON_GPIO_DEBOUNCE_SW
+#define HEADSET_BUTTON_GPIO_DEBOUNCE_SW 100
+#endif
+
+static enum hrtimer_restart report_headset_button_status(int active, struct _headset_gpio *hgp);
+static enum hrtimer_restart report_headset_detect_status(int active, struct _headset_gpio *hgp);
+static struct _headset headset = {
+	.sdev = {
+		.name = "h2w",
+	},
+	.detect = {
+		.desc = "headset detect",
+		.active_low = HEADSET_DETECT_GPIO_ACTIVE_LOW,
+		.gpio = HEADSET_DETECT_GPIO,
+		.debounce = 0,
+		.debounce_sw = HEADSET_DETECT_GPIO_DEBOUNCE_SW,
+		.irq_enabled = 1,
+		.callback = report_headset_detect_status,
+	},
+	.button = {
+		.desc = "headset button",
+		.active_low = HEADSET_BUTTON_GPIO_ACTIVE_LOW,
+		.gpio = HEADSET_BUTTON_GPIO,
+		.debounce = 0,
+		.debounce_sw = HEADSET_BUTTON_GPIO_DEBOUNCE_SW,
+		.irq_enabled = 1,
+		.callback = report_headset_button_status,
+		.timeout_ms = 800, /* 800ms for long button down */
+	},
+};
+
+
+#ifndef headset_gpio_init
+#define headset_gpio_init(gpio, desc) \
+	do { \
+		gpio_request(gpio, desc); \
+		gpio_direction_input(gpio); \
+	} while (0)
+#endif
+
+#ifndef headset_gpio_free
+#define headset_gpio_free(gpio) \
+	gpio_free(gpio)
+#endif
+
+#ifndef headset_gpio2irq_free
+#define headset_gpio2irq_free(irq, args) { }
+#endif
+
+#ifndef headset_gpio2irq
+#define headset_gpio2irq(gpio) \
+	gpio_to_irq(gpio)
+#endif
+
+#ifndef headset_gpio_set_irq_type
+#define headset_gpio_set_irq_type(irq, type) \
+	irq_set_irq_type(irq, type)
+#endif
+
+#ifndef headset_gpio_get_value
+#define headset_gpio_get_value(gpio) \
+	gpio_get_value(gpio)
+#endif
+
+#ifndef headset_gpio_debounce
+#define headset_gpio_debounce(gpio, ms) \
+	gpio_set_debounce(gpio, ms)
+#endif
+
+#ifndef headset_hook_detect
+#define headset_hook_detect(status) { }
+#endif
+
+#define HEADSET_DEBOUNCE_ROUND_UP(dw) \
+	dw = (((dw ? dw : 1) + HEADSET_GPIO_DEBOUNCE_SW_SAMPLE_PERIOD - 1) / \
+		HEADSET_GPIO_DEBOUNCE_SW_SAMPLE_PERIOD) * HEADSET_GPIO_DEBOUNCE_SW_SAMPLE_PERIOD;
+
+static struct _headset_keycap headset_key_capability[20] = {
+	{ EV_KEY, KEY_MEDIA },
+	{ EV_KEY, KEY_END },
+	{ EV_KEY, KEY_RESERVED },
+};
+
+static unsigned int (*headset_get_button_code_board_method)(int v);
+static unsigned int (*headset_map_code2push_code_board_method)(unsigned int code, int push_type);
+static __devinit int headset_button_probe(struct platform_device *pdev)
+{
+	struct _headset_button *headset_button = platform_get_drvdata(pdev);
+	headset_get_button_code_board_method = headset_button->headset_get_button_code_board_method;
+	headset_map_code2push_code_board_method = headset_button->headset_map_code2push_code_board_method;
+	memcpy(headset_key_capability, headset_button->cap, sizeof headset_button->cap);
+	return 0;
+}
+
+static struct platform_driver headset_button_driver = {
+	.driver = {
+		.name = "headset-button",
+		.owner = THIS_MODULE,
+	},
+	.probe = headset_button_probe,
+};
+
+static unsigned int headset_get_button_code(int v)
+{
+	unsigned int code;
+	if (headset_get_button_code_board_method)
+		code = headset_get_button_code_board_method(v);
+	else
+		code = KEY_MEDIA;
+	return code;
+}
+
+static unsigned int headset_map_code2key_type(unsigned int code)
+{
+	unsigned int key_type = EV_KEY;
+	int i;
+	for(i = 0; headset_key_capability[i].key != KEY_RESERVED &&
+		headset_key_capability[i].key != code && i < ARRY_SIZE(headset_key_capability); i++);
+	if (i < ARRY_SIZE(headset_key_capability) &&
+		headset_key_capability[i].key == code)
+		key_type = headset_key_capability[i].type;
+	else
+		pr_err("headset not find code [0x%x]'s maping type\n", code);
+	return key_type;
+}
+
+static unsigned int headset_map_code2push_code(unsigned int code, int push_type)
+{
+	if (headset_map_code2push_code_board_method)
+		return headset_map_code2push_code_board_method(code, push_type);
+
+	switch (push_type) {
+	case HEADSET_BUTTON_DOWN_SHORT:
+		code = KEY_MEDIA;
+		break;
+	case HEADSET_BUTTON_DOWN_LONG:
+		code = KEY_END;
+		break;
+	}
+
+	return code;
+}
+
+static void headset_gpio_irq_enable(int enable, struct _headset_gpio *hgp);
+#define HEADSET_GPIO_DEBOUNCE_SW_SAMPLE_PERIOD	50 /* 10 */
+static enum hrtimer_restart report_headset_button_status(int active, struct _headset_gpio *hgp)
+{
+	enum hrtimer_restart restart;
+	int button_push_type = HEADSET_BUTTON_DOWN_INVALID;
+	unsigned int key_type;
+	static int pre_code = KEY_RESERVED;
+	static int step = 0;
+
+	if (active < 0) {
+		step = 0;
+		pre_code = KEY_RESERVED;
+		return HRTIMER_NORESTART;
+	}
+	if (active) {
+		restart = HRTIMER_RESTART;
+		if (++step > 3)
+			step = 0;
+		switch (step) {
+		case 1:
+			pre_code = headset_get_button_code(0);
+			break;
+		case 2:
+			button_push_type = HEADSET_BUTTON_DOWN_LONG;
+			break;
+		}
+	} else {
+		restart = HRTIMER_NORESTART;
+		if (step == 1)
+			button_push_type = HEADSET_BUTTON_DOWN_SHORT;
+		step = 0;
+	}
+
+	if (button_push_type != HEADSET_BUTTON_DOWN_INVALID) {
+		unsigned int code = headset_map_code2push_code(pre_code, button_push_type);
+		key_type = headset_map_code2key_type(code);
+		switch (key_type) {
+		case EV_KEY:
+			input_event(hgp->parent->input, key_type, code, 1);
+			input_sync(hgp->parent->input);
+			input_event(hgp->parent->input, key_type, code, 0);
+			input_sync(hgp->parent->input);
+			pr_info("headset button-%d[%dms]\n", code, hgp->holded);
+			break;
+		default:
+			pr_err("headset not support key type [%d]\n", key_type);
+		}
+	}
+	return restart;
+}
+
+static enum hrtimer_restart report_headset_detect_status(int active, struct _headset_gpio *hgp)
+{
+	struct _headset * ht = hgp->parent;
+
+	if (active) {
+		headset_hook_detect(1);
+		ht->headphone = 0;
+		/* ht->headphone = ht->button.active_low ^ headset_gpio_get_value(ht->button.gpio); */
+		if (ht->headphone) {
+			ht->type = BIT_HEADSET_NO_MIC;
+			queue_work(ht->switch_workqueue, &ht->switch_work);
+			pr_info("headphone plug in\n");
+		} else {
+			ht->type = BIT_HEADSET_MIC;
+			queue_work(ht->switch_workqueue, &ht->switch_work);
+			pr_info("headset plug in\n");
+			headset_gpio_set_irq_type(ht->button.irq, ht->button.irq_type_active);
+			headset_gpio_irq_enable(1, &ht->button);
+		}
+	} else {
+		headset_gpio_irq_enable(0, &ht->button);
+		ht->button.callback(-1, &ht->button);
+		headset_hook_detect(0);
+		if (ht->headphone)
+			pr_info("headphone plug out\n");
+		else {
+			pr_info("headset plug out\n");
+		}
+		ht->type = BIT_HEADSET_OUT;
+		queue_work(ht->switch_workqueue, &ht->switch_work);
+	}
+	/* use below code only when gpio irq misses state, because of the dithering */
+	headset_gpio_set_irq_type(hgp->irq, active ? hgp->irq_type_inactive : hgp->irq_type_active);
+	return HRTIMER_NORESTART;
+}
+
+static enum hrtimer_restart headset_gpio_timer_func(struct hrtimer *timer)
+{
+	enum hrtimer_restart restart = HRTIMER_RESTART;
+	struct _headset_gpio *hgp =
+		container_of(timer, struct _headset_gpio, timer);
+	int active = hgp->active_low ^ headset_gpio_get_value(hgp->gpio); /* hgp->active */
+	int green_ch = (!active && &hgp->parent->detect == hgp);
+	if (active != hgp->active) {
+		pr_info("The value %s mismatch [%d:%d] at %dms!\n",
+				hgp->desc, active, hgp->active, hgp->holded);
+		hgp->holded = 0;
+	}
+	pr_debug("%s : %s %s green_ch[%d], holed=%d, debounce_sw=%d\n", __func__,
+			hgp->desc, active ? "active" : "inactive", green_ch, hgp->holded, hgp->debounce_sw);
+	hgp->holded += HEADSET_GPIO_DEBOUNCE_SW_SAMPLE_PERIOD;
+	if (hgp->holded >= hgp->debounce_sw || green_ch) {
+		if (hgp->holded == hgp->debounce_sw || \
+			hgp->holded == hgp->timeout_ms || \
+			green_ch) {
+			pr_debug("call headset gpio handler\n");
+			restart = hgp->callback(active, hgp);
+		} else
+			pr_debug("gpio <%d> has kept active for %d ms\n", hgp->gpio, hgp->holded);
+	}
+	if (restart == HRTIMER_RESTART)
+		hrtimer_forward_now(timer,
+			ktime_set(HEADSET_GPIO_DEBOUNCE_SW_SAMPLE_PERIOD / 1000,
+					(HEADSET_GPIO_DEBOUNCE_SW_SAMPLE_PERIOD % 1000) * 1000000)); /* repeat timer */
+	return restart;
+}
+
+static irqreturn_t headset_gpio_irq_handler(int irq, void *dev)
+{
+	struct _headset_gpio *hgp = dev;
+	hrtimer_cancel(&hgp->timer);
+	hgp->active = hgp->active_low ^ headset_gpio_get_value(hgp->gpio);
+	headset_gpio_set_irq_type(hgp->irq, hgp->active ? hgp->irq_type_inactive : hgp->irq_type_active);
+	pr_debug("%s : %s %s\n", __func__, hgp->desc, hgp->active ? "active" : "inactive");
+	hgp->holded = 0;
+	hrtimer_start(&hgp->timer,
+			ktime_set(HEADSET_GPIO_DEBOUNCE_SW_SAMPLE_PERIOD / 1000,
+				(HEADSET_GPIO_DEBOUNCE_SW_SAMPLE_PERIOD % 1000) * 1000000),
+			HRTIMER_MODE_REL);
+	return IRQ_HANDLED;
+}
+
+static void headset_gpio_irq_enable(int enable, struct _headset_gpio *hgp)
+{
+	int action = 0;
+	if (enable) {
+		if (!hgp->irq_enabled) {
+			hrtimer_cancel(&hgp->timer);
+			hgp->irq_enabled = 1;
+			action = 1;
+			hgp->holded = 0;
+			enable_irq(hgp->irq);
+		}
+	} else {
+		if (hgp->irq_enabled) {
+			disable_irq(hgp->irq);
+			hrtimer_cancel(&hgp->timer);
+			hgp->irq_enabled = 0;
+			action = 1;
+			hgp->holded = 0;
+		}
+	}
+	pr_info("%s [ irq=%d ] --- %saction %s\n", __func__, hgp->irq_enabled, action ? "do " : "no ", hgp->desc);
+}
+
+static void headset_switch_state(struct work_struct *work)
+{
+	struct _headset *ht;
+	int type;
+
+	ht = container_of(work, struct _headset, switch_work);
+	type = ht->type;
+	switch_set_state(&headset.sdev, type);
+	pr_info("set headset state to %d\n", type);
+}
+
+static int __init headset_init(void)
+{
+	int ret, i;
+	struct _headset *ht = &headset;
+
+	ret = switch_dev_register(&ht->sdev);
+	if (ret < 0) {
+		pr_err("switch_dev_register failed!\n");
+		return ret;
+	}
+	platform_driver_register(&headset_button_driver);
+	ht->input = input_allocate_device();
+	if (ht->input == NULL) {
+		pr_err("switch_dev_register failed!\n");
+		goto _switch_dev_register;
+	}
+	ht->input->name = "headset-keyboard";
+	ht->input->id.bustype = BUS_HOST;
+	ht->input->id.vendor = 0x0001;
+	ht->input->id.product = 0x0001;
+	ht->input->id.version = 0x0100;
+
+	for(i = 0; headset_key_capability[i].key != KEY_RESERVED; i++) {
+		__set_bit(headset_key_capability[i].type, ht->input->evbit);
+		input_set_capability(ht->input, headset_key_capability[i].type, headset_key_capability[i].key);
+	}
+
+	if (input_register_device(ht->input))
+		goto _switch_dev_register;
+
+	headset_gpio_init(ht->detect.gpio, ht->detect.desc);
+	headset_gpio_init(ht->button.gpio, ht->button.desc);
+
+	headset_gpio_debounce(ht->detect.gpio, ht->detect.debounce * 1000);
+	headset_gpio_debounce(ht->button.gpio, ht->button.debounce * 1000);
+
+	hrtimer_init(&ht->button.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+	ht->button.timer.function = headset_gpio_timer_func;
+	HEADSET_DEBOUNCE_ROUND_UP(ht->button.debounce_sw);
+	HEADSET_DEBOUNCE_ROUND_UP(ht->button.timeout_ms);
+	ht->button.parent = ht;
+	ht->button.irq = headset_gpio2irq(ht->button.gpio);
+	ht->button.irq_type_active = ht->button.active_low ? IRQF_TRIGGER_LOW : IRQF_TRIGGER_HIGH;
+	ht->button.irq_type_inactive = ht->button.active_low ? IRQF_TRIGGER_HIGH : IRQF_TRIGGER_LOW;
+	ret = request_irq(ht->button.irq, headset_gpio_irq_handler,
+					ht->button.irq_type_active, ht->button.desc, &ht->button);
+	if (ret) {
+		pr_err("request_irq gpio %d's irq failed!\n", ht->button.gpio);
+		goto _gpio_request;
+	}
+	headset_gpio_irq_enable(0, &ht->button);
+
+	hrtimer_init(&ht->detect.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+	ht->detect.timer.function = headset_gpio_timer_func;
+	HEADSET_DEBOUNCE_ROUND_UP(ht->detect.debounce_sw);
+	ht->detect.parent = ht;
+	ht->detect.irq = headset_gpio2irq(ht->detect.gpio);
+	ht->detect.irq_type_active = ht->detect.active_low ? IRQF_TRIGGER_LOW : IRQF_TRIGGER_HIGH;
+	ht->detect.irq_type_inactive = ht->detect.active_low ? IRQF_TRIGGER_HIGH : IRQF_TRIGGER_LOW;
+	ret = request_irq(ht->detect.irq, headset_gpio_irq_handler,
+					ht->detect.irq_type_active, ht->detect.desc, &ht->detect);
+	if (ret) {
+		pr_err("request_irq gpio %d's irq failed!\n", ht->detect.gpio);
+		goto _headset_button_gpio_irq_handler;
+	}
+
+	INIT_WORK(&ht->switch_work, headset_switch_state);
+	ht->switch_workqueue = create_singlethread_workqueue("headset_switch");
+
+	if (ht->switch_workqueue == NULL) {
+		pr_err("can't create headset switch workqueue\n");
+		ret = -ENOMEM;
+		goto _headset_button_gpio_irq_handler;
+	}
+
+	return 0;
+
+	destroy_workqueue(ht->switch_workqueue);
+_headset_button_gpio_irq_handler:
+	free_irq(ht->button.irq, &ht->button);
+	headset_gpio2irq_free(ht->button.irq, &ht->button);
+_gpio_request:
+	headset_gpio_free(ht->detect.gpio);
+	headset_gpio_free(ht->button.gpio);
+	input_free_device(ht->input);
+_switch_dev_register:
+	platform_driver_unregister(&headset_button_driver);
+	switch_dev_unregister(&ht->sdev);
+	return ret;
+}
+module_init(headset_init);
+
+static void __exit headset_exit(void)
+{
+	struct _headset *ht = &headset;
+	destroy_workqueue(ht->switch_workqueue);
+	headset_gpio_irq_enable(0, &ht->button);
+	headset_gpio_irq_enable(0, &ht->detect);
+	free_irq(ht->detect.irq, &ht->detect);
+	headset_gpio2irq_free(ht->detect.irq, &ht->detect);
+	free_irq(ht->button.irq, &ht->button);
+	headset_gpio2irq_free(ht->button.irq, &ht->button);
+	headset_gpio_free(ht->detect.gpio);
+	headset_gpio_free(ht->button.gpio);
+	input_free_device(ht->input);
+	platform_driver_unregister(&headset_button_driver);
+	switch_dev_unregister(&ht->sdev);
+}
+module_exit(headset_exit);
+
+MODULE_DESCRIPTION("headset & button detect driver");
+MODULE_AUTHOR("Luther Ge <luther.ge@spreadtrum.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/headset_sprd.c b/drivers/input/misc/headset_sprd.c
new file mode 100644
index 00000000..db6d1f7d
--- /dev/null
+++ b/drivers/input/misc/headset_sprd.c
@@ -0,0 +1,2377 @@
+/*
+ * Copyright (C) 2013 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/delay.h>
+#include <mach/gpio.h>
+#include <linux/headset_sprd.h>
+#include <soc/sprd/board.h>
+#include <linux/input.h>
+
+#include <soc/sprd/adc.h>
+#include <asm/io.h>
+#include <soc/sprd/hardware.h>
+#include <soc/sprd/adi.h>
+#include <linux/module.h>
+#include <linux/wakelock.h>
+
+#include <linux/regulator/consumer.h>
+#include <soc/sprd/regulator.h>
+#include <soc/sprd/sci_glb_regs.h>
+#include <soc/sprd/arch_misc.h>
+#include <linux/notifier.h>
+#ifdef CONFIG_OF
+#include <linux/slab.h>
+#include <linux/of_device.h>
+#endif
+
+//====================  debug  ====================
+#define ENTER \
+do{ if(debug_level >= 1) printk(KERN_INFO "[SPRD_HEADSET_DBG][%d] func: %s  line: %04d\n", adie_type, __func__, __LINE__); }while(0)
+
+#define PRINT_DBG(format,x...)  \
+do{ if(debug_level >= 1) printk(KERN_INFO "[SPRD_HEADSET_DBG][%d] " format, adie_type, ## x); }while(0)
+
+#define PRINT_INFO(format,x...)  \
+do{ printk(KERN_INFO "[SPRD_HEADSET_INFO][%d] " format, adie_type, ## x); }while(0)
+
+#define PRINT_WARN(format,x...)  \
+do{ printk(KERN_INFO "[SPRD_HEADSET_WARN][%d] " format, adie_type, ## x); }while(0)
+
+#define PRINT_ERR(format,x...)  \
+do{ printk(KERN_ERR "[SPRD_HEADSET_ERR][%d] func: %s  line: %04d  info: " format, adie_type, __func__, __LINE__, ## x); }while(0)
+//====================  debug  ====================
+
+/**********************************************
+ * The micro ADPGAR_BYP_SELECT is used for avoiding the Bug#298417,
+ * please refer to Bug#298417 to confirm your configuration.
+ **********************************************/
+#define ADPGAR_BYP_SELECT
+
+#ifdef CONFIG_HEADSET_STS_POLLING_DISABLED
+#undef SPRD_STS_POLLING_EN
+#else
+#define SPRD_STS_POLLING_EN
+#endif
+
+#define PLUG_CONFIRM_COUNT (2)
+#define NO_MIC_RETRY_COUNT (0)
+#define ADC_READ_COUNT (5)
+#define ADC_READ_LOOP (2)
+#define ADC_GND (100)
+#define SCI_ADC_GET_VALUE_COUNT (50)
+
+#define ARM_MF_REG (0x0110)
+#define HEAD_INSERT2_EIC_EN (BIT(15))
+#define HEAD_INSERT_EIC_EN (BIT(14))
+
+#define EIC3_DBNC_CTRL (0x4C)
+#define DBNC_CNT3_VALUE (30)
+#define DBNC_CNT3_SHIFT (0)
+#define DBNC_CNT3_MASK (0xFFF << DBNC_CNT3_SHIFT)
+
+#define EIC5_DBNC_CTRL (0x54)
+#define DBNC_CNT5_VALUE (100)
+#define DBNC_CNT5_SHIFT (0)
+#define DBNC_CNT5_MASK (0xFFF << DBNC_CNT5_SHIFT)
+
+#if (defined(CONFIG_ARCH_SCX15))
+        #define ADIE_CHID_LOW 0x0134
+        #define ADIE_CHID_HIGH 0x0138
+#else
+        #if (defined(CONFIG_ARCH_SCX35))
+                #define ADIE_CHID_LOW 0x0108
+                #define ADIE_CHID_HIGH 0x010C
+        #endif
+#endif
+
+#if (defined(CONFIG_ARCH_SCX15))
+        #define CLK_AUD_HID_EN (BIT(4))
+        #define CLK_AUD_HBD_EN (BIT(3))
+#else
+        #if (defined(CONFIG_ARCH_SCX35))
+                #define CLK_AUD_HID_EN (BIT(5))
+                #define CLK_AUD_HBD_EN (BIT(4))
+        #endif
+#endif
+
+#define HEADMIC_DETECT_BASE (ANA_AUDCFGA_INT_BASE)
+#define HEADMIC_DETECT_REG(X) (HEADMIC_DETECT_BASE + (X))
+
+#define HDT_EN (BIT(5))
+#define AUD_EN (BIT(4))
+
+#define HEADMIC_BUTTON_BASE (ANA_HDT_INT_BASE)
+#define HEADMIC_BUTTON_REG(X) (HEADMIC_BUTTON_BASE + (X))
+#define HID_CFG0 (0x0080)
+#define HID_CFG2 (0x0088)
+#define HID_CFG3 (0x008C)
+#define HID_CFG4 (0x0090)
+
+#define ANA_CFG0 (0x0040)
+#define ANA_CFG1 (0x0044)
+#define ANA_CFG2 (0x0048)
+#define ANA_CFG5 (0x0064)
+#define ANA_CFG20 (0x00A0)
+#define ANA_STS0 (0x00C0)
+
+#define HEADMIC_DETECT_GLB_REG(X) (ANA_REGS_GLB_BASE + (X))
+
+#define HID_TMR_T1T2_STEP_SHIFT (5)
+#define HID_TMR_T0_SHIFT (0)
+#define HID_TMR_T1_SHIFT (0)
+#define HID_TMR_T2_SHIFT (0)
+
+#define HID_TMR_T1T2_STEP_MASK (0x1F << HID_TMR_T1T2_STEP_SHIFT)
+#define HID_TMR_T0_MASK (0x1F << HID_TMR_T0_SHIFT)
+#define HID_TMR_T1_MASK (0xFFFF << HID_TMR_T1_SHIFT)
+#define HID_TMR_T2_MASK (0xFFFF << HID_TMR_T2_SHIFT)
+
+#define HID_TMR_T1T2_STEP_VAL (0x1)
+#define HID_TMR_T0_VAL (0xF)
+#define HID_TMR_T1_VAL (0xF)
+#define HID_TMR_T2_VAL (0xF)
+
+#define AUDIO_ICM_PLUS_EN (BIT(2))
+
+#define AUDIO_HEADMIC_SLEEP_EN (BIT(1))
+#define AUDIO_MICBIAS_HV_EN (BIT(2))
+#define AUDIO_MICBIAS_V_SHIFT (3)
+#define AUDIO_MICBIAS_V_MASK (0x3 << AUDIO_MICBIAS_V_SHIFT)
+#define AUDIO_MICBIAS_V_1P7_OR_2P2 (0)
+#define AUDIO_MICBIAS_V_1P9_OR_2P4 (1)
+#define AUDIO_MICBIAS_V_2P1_OR_2P7 (2)
+#define AUDIO_MICBIAS_V_2P3_OR_3P0 (3)
+
+#define AUDIO_ADPGAR_BYP_SHIFT (10)
+#define AUDIO_ADPGAR_BYP_MASK (0x3 << AUDIO_ADPGAR_BYP_SHIFT)
+#define AUDIO_ADPGAR_BYP_NORMAL (0)
+#define AUDIO_ADPGAR_BYP_ADC_PGAR1_2_ADCR (1)
+#define AUDIO_ADPGAR_BYP_HEADMIC_2_ADCR (2)
+#define AUDIO_ADPGAR_BYP_ALL_DISCONNECTED (3)
+
+#if (defined(CONFIG_ARCH_SCX15))
+        #define AUDIO_HEAD_SDET_SHIFT (4)
+#else
+        #if (defined(CONFIG_ARCH_SCX35))
+                #define AUDIO_HEAD_SDET_SHIFT (5)
+        #endif
+#endif
+#define AUDIO_HEAD_SDET_MASK (0x3 << AUDIO_HEAD_SDET_SHIFT)
+#define AUDIO_HEAD_SDET_2P1_OR_1P4 (3)
+#define AUDIO_HEAD_SDET_2P3_OR_1P5 (2)
+#define AUDIO_HEAD_SDET_2P5_OR_1P6 (1)
+#define AUDIO_HEAD_SDET_2P7_OR_1P7 (0)
+
+#if (defined(CONFIG_ARCH_SCX15))
+        #define AUDIO_HEAD_INS_VREF_SHIFT (7)
+#else
+        #if (defined(CONFIG_ARCH_SCX35))
+                #define AUDIO_HEAD_INS_VREF_SHIFT (8)
+        #endif
+#endif
+#define AUDIO_HEAD_INS_VREF_MASK (0x3 << AUDIO_HEAD_INS_VREF_SHIFT)
+#define AUDIO_HEAD_INS_VREF_2P1_OR_1P4 (3)
+#define AUDIO_HEAD_INS_VREF_2P3_OR_1P5 (2)
+#define AUDIO_HEAD_INS_VREF_2P5_OR_1P6 (1)
+#define AUDIO_HEAD_INS_VREF_2P7_OR_1P7 (0)
+
+#if (defined(CONFIG_ARCH_SCX15))
+        #define AUDIO_HEAD_SBUT_SHIFT (0)
+#else
+        #if (defined(CONFIG_ARCH_SCX35))
+                #define AUDIO_HEAD_SBUT_SHIFT (1)
+        #endif
+#endif
+#define AUDIO_HEAD_SBUT_MASK (0xF << AUDIO_HEAD_SBUT_SHIFT)
+
+#define AUDIO_HEADMIC_ADC_SEL (BIT(13))
+#define AUDIO_HEAD_INS_HMBIAS_EN (BIT(11))
+
+#if (defined(CONFIG_ARCH_SCX15))
+        #define AUDIO_V2ADC_EN (BIT(15))
+        #define AUDIO_HEAD_BUF_EN (BIT(14))
+        #define AUDIO_HEAD2ADC_SEL_SHIFT (12)
+        #define AUDIO_HEAD2ADC_SEL_MASK (0x3 << AUDIO_HEAD2ADC_SEL_SHIFT)
+        #define AUDIO_HEAD2ADC_SEL_DISABLE (0)
+        #define AUDIO_HEAD2ADC_SEL_MIC_IN (1)
+        #define AUDIO_HEAD2ADC_SEL_L_INT (2)
+        #define AUDIO_HEAD2ADC_SEL_DRO_L (3)
+#else
+        #if (defined(CONFIG_ARCH_SCX35))
+                #define AUDIO_V2ADC_EN (BIT(14))
+                #define AUDIO_HEAD_BUF_EN (BIT(15))
+                #define AUDIO_HEAD2ADC_SEL_SHIFT (13)
+                #define AUDIO_HEAD2ADC_SEL_MASK (0x1 << AUDIO_HEAD2ADC_SEL_SHIFT)
+                #define AUDIO_HEAD2ADC_SEL_DISABLE (0)
+                #define AUDIO_HEAD2ADC_SEL_MIC_IN (1)
+                #define AUDIO_HEAD2ADC_SEL_L_INT (0)
+                #define AUDIO_HEAD2ADC_SEL_DRO_L (0)
+        #endif
+#endif
+
+#define AUDIO_HEAD_BUTTON (BIT(7))
+#define AUDIO_HEAD_INSERT (BIT(6))
+#define AUDIO_HEAD_INSERT_2 (BIT(5))
+
+#define ABS(x) (((x) < (0)) ? (-(x)) : (x))
+#define MAX(x,y) (((x) > (y)) ? (x) : (y))
+
+#define headset_reg_read(addr)	\
+    do {	\
+	sci_adi_read(addr);	\
+} while(0)
+
+#define headset_reg_set_val(addr, val, mask, shift)  \
+    do {    \
+        uint32_t temp;    \
+        temp = sci_adi_read(addr);  \
+        temp = (temp & (~mask)) | ((val) << (shift));   \
+        sci_adi_raw_write(addr, temp);    \
+    } while(0)
+
+#define headset_reg_clr_bit(addr, bit)   \
+    do {    \
+        uint32_t temp;    \
+        temp = sci_adi_read(addr);  \
+        temp = temp & (~bit);   \
+        sci_adi_raw_write(addr, temp);  \
+    } while(0)
+
+#define headset_reg_set_bit(addr, bit)   \
+    do {    \
+        uint32_t temp;    \
+        temp = sci_adi_read(addr);  \
+        temp = temp | bit;  \
+        sci_adi_raw_write(addr, temp);  \
+    } while(0)
+
+static inline uint32_t headset_reg_get_bit(uint32_t addr, uint32_t bit)
+{
+        uint32_t temp;
+        temp = sci_adi_read(addr);
+        temp = temp & bit;
+        return temp;
+}
+
+typedef enum sprd_headset_type {
+        HEADSET_NORMAL,
+        HEADSET_NO_MIC,
+        HEADSET_NORTH_AMERICA,
+        HEADSET_APPLE,
+        HEADSET_CAMERA_POLE,			//add by lgd
+        HEADSET_TYPE_ERR = -1,
+} SPRD_HEADSET_TYPE;
+
+static struct delayed_work reg_dump_work;
+static struct workqueue_struct *reg_dump_work_queue;
+
+/* < add by lgd */
+#ifdef CONFIG_CAMERA_POLE_SUPPORT
+static struct delayed_work camera_pole_work;
+static struct workqueue_struct *camera_pole_work_queue;
+static int headset_ctl = 0;
+#define CAMERA_POLE_CODE KEY_CAMERA
+#endif
+/* add by lgd > */
+
+/***polling ana_sts0 to avoid the hardware defect***/
+#ifdef SPRD_STS_POLLING_EN
+static struct delayed_work sts_check_work;
+static struct workqueue_struct *sts_check_work_queue;
+static int plug_state_class_g_on = 0;
+static int sts_check_work_need_to_cancel = 1;
+#endif
+/***polling ana_sts0 to avoid the hardware defect***/
+
+#ifdef ADPGAR_BYP_SELECT
+static struct delayed_work adpgar_byp_select_work;
+static struct workqueue_struct *adpgar_byp_select_work_queue;
+#endif
+
+static DEFINE_SPINLOCK(irq_button_lock);
+static DEFINE_SPINLOCK(irq_detect_lock);
+static int detect_err_count = 0;
+static int debug_level = 0;
+static int adie_type = 100;
+static int gpio_detect_value_last = 0;
+static int gpio_button_value_last = 0;
+static volatile int button_state_last = 0; //0==released, 1==pressed
+static int current_key_code = KEY_RESERVED;
+static int plug_state_last = 0; //if the hardware detected the headset is plug in, set plug_state_last = 1
+static struct wake_lock headset_detect_wakelock;
+static struct wake_lock headset_button_wakelock;
+static struct semaphore headset_sem;
+
+
+static struct sprd_headset headset = {
+        .sdev = {
+                .name = "h2w",
+        },
+};
+
+#ifdef CONFIG_HEADSET_AUXADC_CAL_SUPPORTED
+static int adc_get_ideal(int adc_mic);
+#endif
+//========================  audio codec  ========================
+static struct sprd_headset_power {
+	struct regulator *head_mic;
+	struct regulator *vcom_buf;
+	struct regulator *vbo;
+} sprd_hts_power;
+
+static int sprd_headset_power_get(struct device *dev,
+				  struct regulator **regu, const char *id)
+{
+	if (!*regu) {
+		*regu = regulator_get(dev, id);
+		if (IS_ERR(*regu)) {
+			pr_err("ERR:Failed to request %ld: %s\n",
+			       PTR_ERR(*regu), id);
+			*regu = 0;
+			return PTR_ERR(*regu);
+		}
+	}
+	return 0;
+}
+
+static int sprd_headset_power_init(struct device *dev)
+{
+	int ret = 0;
+	ret =
+	    sprd_headset_power_get(dev, &sprd_hts_power.head_mic,
+				   "HEADMICBIAS");
+	if (ret || (sprd_hts_power.head_mic == NULL)) {
+		sprd_hts_power.head_mic = 0;
+		return ret;
+	}
+    regulator_set_voltage(sprd_hts_power.head_mic, 950000, 950000);
+
+	ret = sprd_headset_power_get(dev, &sprd_hts_power.vcom_buf, "VCOM_BUF");
+	if (ret) {
+		sprd_hts_power.vcom_buf = 0;
+		goto __err1;
+	}
+
+	ret = sprd_headset_power_get(dev, &sprd_hts_power.vbo, "VBO");
+	if (ret) {
+		sprd_hts_power.vbo = 0;
+		goto __err2;
+	}
+	if (sprd_hts_power.vbo != NULL)
+		regulator_enable(sprd_hts_power.vbo);
+	goto __ok;
+__err2:
+	regulator_put(sprd_hts_power.vcom_buf);
+__err1:
+	regulator_put(sprd_hts_power.head_mic);
+__ok:
+	return ret;
+}
+
+static void sprd_headset_power_deinit(void)
+{
+	regulator_put(sprd_hts_power.head_mic);
+	regulator_put(sprd_hts_power.vcom_buf);
+	regulator_put(sprd_hts_power.vbo);
+}
+
+static int sprd_headset_audio_block_is_running(struct device *dev)
+{
+	return regulator_is_enabled(sprd_hts_power.vcom_buf)
+	    || regulator_is_enabled(sprd_hts_power.vbo);
+}
+
+static int sprd_headset_audio_headmic_sleep_disable(struct device *dev, int on)
+{
+	int ret = 0;
+	if (!sprd_hts_power.head_mic) {
+		return -1;
+	}
+
+	if (on) {
+			ret = regulator_enable(sprd_hts_power.vbo);
+			ret =
+			    regulator_set_mode(sprd_hts_power.head_mic,
+					       REGULATOR_MODE_NORMAL);
+	} else {
+		ret = regulator_disable(sprd_hts_power.vbo);
+		if (sprd_headset_audio_block_is_running(dev)) {
+			ret =
+			    regulator_set_mode(sprd_hts_power.head_mic,
+					       REGULATOR_MODE_NORMAL);
+		} else {
+			ret =
+			    regulator_set_mode(sprd_hts_power.head_mic,
+					       REGULATOR_MODE_STANDBY);
+		}
+	}
+	return ret;
+}
+
+static int sprd_headset_headmic_bias_control(struct device *dev, int on)
+{
+	int ret = 0;
+	if (!sprd_hts_power.head_mic) {
+		return -1;
+	}
+	if (on) {
+		ret = regulator_enable(sprd_hts_power.head_mic);
+	} else {
+		ret = regulator_disable(sprd_hts_power.head_mic);
+	}
+	if (!ret) {
+		/* Set HEADMIC_SLEEP when audio block closed */
+		if (sprd_headset_audio_block_is_running(dev)) {
+			ret =
+			    regulator_set_mode(sprd_hts_power.head_mic,
+					       REGULATOR_MODE_NORMAL);
+		} else {
+			ret =
+			    regulator_set_mode(sprd_hts_power.head_mic,
+					       REGULATOR_MODE_STANDBY);
+		}
+	}
+	return ret;
+}
+
+static BLOCKING_NOTIFIER_HEAD(hp_chain_list);
+int hp_register_notifier(struct notifier_block *nb)
+{
+	return blocking_notifier_chain_register(&hp_chain_list, nb);
+}
+EXPORT_SYMBOL(hp_register_notifier);
+
+int hp_unregister_notifier(struct notifier_block *nb)
+{
+	return blocking_notifier_chain_unregister(&hp_chain_list, nb);
+}
+EXPORT_SYMBOL(hp_unregister_notifier);
+
+static int hp_notifier_call_chain(unsigned long val)
+{
+    return (blocking_notifier_call_chain(&hp_chain_list, val, NULL)
+            == NOTIFY_BAD) ? -EINVAL : 0;
+}
+
+int get_hp_plug_state(void)
+{
+	return !!plug_state_last;
+}
+EXPORT_SYMBOL(get_hp_plug_state);
+//========================  audio codec  ========================
+
+static int wrap_sci_adc_get_value(unsigned int channel, int scale)
+{
+	int count = 0;
+	int average = 0;
+
+	while(count < SCI_ADC_GET_VALUE_COUNT) {
+		average += sci_adc_get_value(channel, scale);
+		count++;
+	}
+	average /= SCI_ADC_GET_VALUE_COUNT;
+
+	return average;
+}
+
+/*  on = 0: open headmic detect circuit */
+static void headset_detect_circuit(unsigned on)
+{
+        if (on) {
+                headset_reg_clr_bit(HEADMIC_DETECT_REG(ANA_CFG20), AUDIO_HEAD_INS_HMBIAS_EN);
+        } else {
+                headset_reg_set_bit(HEADMIC_DETECT_REG(ANA_CFG20), AUDIO_HEAD_INS_HMBIAS_EN);
+        }
+}
+
+static void headset_detect_clk_en(void)
+{
+        //address:0x4003_8800+0x00
+        headset_reg_set_bit(HEADMIC_DETECT_GLB_REG(0x00), (HDT_EN | AUD_EN));
+        //address:0x4003_8800+0x04
+        headset_reg_set_bit(HEADMIC_DETECT_GLB_REG(0x04), (CLK_AUD_HID_EN | CLK_AUD_HBD_EN));
+}
+
+static void headset_detect_init(void)
+{
+        headset_detect_clk_en();
+        /* set headset detect voltage */
+        headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG20), AUDIO_HEAD_SDET_2P5_OR_1P6, AUDIO_HEAD_SDET_MASK, AUDIO_HEAD_SDET_SHIFT);
+        headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG20), AUDIO_HEAD_INS_VREF_2P1_OR_1P4, AUDIO_HEAD_INS_VREF_MASK, AUDIO_HEAD_INS_VREF_SHIFT);
+        /*set headmicbias voltage*/
+        headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG0), AUDIO_MICBIAS_V_2P3_OR_3P0, AUDIO_MICBIAS_V_MASK, AUDIO_MICBIAS_V_SHIFT);
+        headset_reg_set_bit(HEADMIC_DETECT_REG(ANA_CFG0), AUDIO_MICBIAS_HV_EN);
+}
+
+static void headmic_sleep_disable(struct device *dev, int on);
+
+static void headset_adc_en(int en)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+
+        if (en) {
+                headset_reg_set_bit(HEADMIC_DETECT_REG(ANA_CFG20), AUDIO_HEAD_BUF_EN);
+                headset_reg_set_bit(HEADMIC_DETECT_REG(ANA_CFG20), AUDIO_V2ADC_EN);
+                headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG20), AUDIO_HEAD2ADC_SEL_MIC_IN, AUDIO_HEAD2ADC_SEL_MASK, AUDIO_HEAD2ADC_SEL_SHIFT);
+                headset_reg_set_bit(HEADMIC_DETECT_REG(ANA_CFG1), AUDIO_ICM_PLUS_EN);
+                headmic_sleep_disable(&ht->this_pdev, 1);
+        } else {
+                if(debug_level <= 2) {
+                        headset_reg_clr_bit(HEADMIC_DETECT_REG(ANA_CFG20), AUDIO_HEAD_BUF_EN);
+                        headset_reg_clr_bit(HEADMIC_DETECT_REG(ANA_CFG20), AUDIO_V2ADC_EN);
+                        headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG20), AUDIO_HEAD2ADC_SEL_DISABLE, AUDIO_HEAD2ADC_SEL_MASK, AUDIO_HEAD2ADC_SEL_SHIFT);
+                }
+                headmic_sleep_disable(&ht->this_pdev, 0);
+        }
+}
+
+/* is_set = 1, headset_mic to AUXADC */
+static void set_adc_to_headmic(unsigned is_set)
+{
+        headset_adc_en(1);
+
+        if (is_set) {
+                headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG20), AUDIO_HEAD2ADC_SEL_MIC_IN, AUDIO_HEAD2ADC_SEL_MASK, AUDIO_HEAD2ADC_SEL_SHIFT);
+        } else {
+                headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG20), AUDIO_HEAD2ADC_SEL_L_INT, AUDIO_HEAD2ADC_SEL_MASK, AUDIO_HEAD2ADC_SEL_SHIFT);
+        }
+}
+
+static void headset_button_irq_threshold(int enable)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+        int audio_head_sbut = 0;
+
+        audio_head_sbut = pdata->irq_threshold_buttont;
+		/* < add by lgd */
+        #ifdef CONFIG_CAMERA_POLE_SUPPORT
+        if(enable) {
+                if(HEADSET_CAMERA_POLE == ht->raw_type)
+                        headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG20), 11, AUDIO_HEAD_SBUT_MASK, AUDIO_HEAD_SBUT_SHIFT);
+                else
+                        headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG20), audio_head_sbut, AUDIO_HEAD_SBUT_MASK, AUDIO_HEAD_SBUT_SHIFT);
+        }
+        else
+                headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG20), 0xF, AUDIO_HEAD_SBUT_MASK, AUDIO_HEAD_SBUT_SHIFT);
+        #else
+		
+        if (enable)
+                headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG20), audio_head_sbut, AUDIO_HEAD_SBUT_MASK, AUDIO_HEAD_SBUT_SHIFT);
+        else
+                headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG20), 0xF, AUDIO_HEAD_SBUT_MASK, AUDIO_HEAD_SBUT_SHIFT);
+		#endif
+		/* add by lgd > */
+}
+
+static void headset_micbias_polling_en(int en)
+{
+        if(en) {
+                //step 1: enable clk for register accessable
+                headset_detect_clk_en();
+                //step 2: start polling & set timer
+                headset_reg_set_val(HEADMIC_BUTTON_REG(HID_CFG2), HID_TMR_T1T2_STEP_VAL, HID_TMR_T1T2_STEP_MASK, HID_TMR_T1T2_STEP_SHIFT);//step for T1 & T2 [9:5]
+                headset_reg_set_val(HEADMIC_BUTTON_REG(HID_CFG2), HID_TMR_T0_VAL, HID_TMR_T0_MASK, HID_TMR_T0_SHIFT);//T0 timer count [4:0]
+                headset_reg_set_val(HEADMIC_BUTTON_REG(HID_CFG3), HID_TMR_T1_VAL, HID_TMR_T1_MASK, HID_TMR_T1_SHIFT);//T1 timer count [15:0]
+                headset_reg_set_val(HEADMIC_BUTTON_REG(HID_CFG4), HID_TMR_T2_VAL, HID_TMR_T2_MASK, HID_TMR_T2_SHIFT);//T2 timer count [15:0]
+                //step 3: disable headmicbias
+                headset_reg_clr_bit(HEADMIC_DETECT_REG(ANA_CFG0), BIT(5));
+                //headset_reg_set_bit(HEADMIC_DETECT_REG(ANA_CFG0), BIT(1));
+                PRINT_INFO("headmicbias polling enable\n");
+                PRINT_DBG("ANA_CFG0(0x%08X)  HID_CFG0(0x%08X)  HID_CFG2(0x%08X)  HID_CFG3(0x%08X)  HID_CFG4(0x%08X)\n",
+                          sci_adi_read(HEADMIC_DETECT_REG(ANA_CFG0)),
+                          sci_adi_read(HEADMIC_BUTTON_REG(HID_CFG0)),
+                          sci_adi_read(HEADMIC_BUTTON_REG(HID_CFG2)),
+                          sci_adi_read(HEADMIC_BUTTON_REG(HID_CFG3)),
+                          sci_adi_read(HEADMIC_BUTTON_REG(HID_CFG4)));
+        } else {
+                //step 1: enable headmicbias
+                //headset_reg_clr_bit(HEADMIC_DETECT_REG(ANA_CFG0), BIT(1));
+                headset_reg_set_bit(HEADMIC_DETECT_REG(ANA_CFG0), BIT(5));
+                //step 2: stop polling
+                PRINT_INFO("headmicbias polling disable\n");
+                PRINT_DBG("ANA_CFG0(0x%08X)  HID_CFG0(0x%08X)  HID_CFG2(0x%08X)  HID_CFG3(0x%08X)  HID_CFG4(0x%08X)\n",
+                          sci_adi_read(HEADMIC_DETECT_REG(ANA_CFG0)),
+                          sci_adi_read(HEADMIC_BUTTON_REG(HID_CFG0)),
+                          sci_adi_read(HEADMIC_BUTTON_REG(HID_CFG2)),
+                          sci_adi_read(HEADMIC_BUTTON_REG(HID_CFG3)),
+                          sci_adi_read(HEADMIC_BUTTON_REG(HID_CFG4)));
+        }
+}
+
+static void headset_irq_button_enable(int enable, unsigned int irq)
+{
+	PRINT_INFO("headset_irq_button_enable irq = %d\n",irq);
+        unsigned long spin_lock_flags;
+        static int current_irq_state = 1;//irq is enabled after request_irq()
+        spin_lock_irqsave(&irq_button_lock, spin_lock_flags);
+        if (1 == enable) {
+                if (0 == current_irq_state) {
+                        enable_irq(irq);
+                        current_irq_state = 1;
+                }
+        } else {
+                if (1 == current_irq_state) {
+                        disable_irq_nosync(irq);
+                        current_irq_state = 0;
+                }
+        }
+        spin_unlock_irqrestore(&irq_button_lock, spin_lock_flags);
+        return;
+}
+
+static void headset_irq_detect_enable(int enable, unsigned int irq)
+{
+	PRINT_INFO("headset_irq_detect_enable irq = %d\n",irq);
+        unsigned long spin_lock_flags;
+        static int current_irq_state = 1;//irq is enabled after request_irq()
+        spin_lock_irqsave(&irq_detect_lock, spin_lock_flags);
+        if (1 == enable) {
+                if (0 == current_irq_state) {
+                        enable_irq(irq);
+                        current_irq_state = 1;
+                }
+        } else {
+                if (1 == current_irq_state) {
+                        disable_irq_nosync(irq);
+                        current_irq_state = 0;
+                }
+        }
+        spin_unlock_irqrestore(&irq_detect_lock, spin_lock_flags);
+        return;
+}
+
+static void headmic_sleep_disable(struct device *dev, int on)
+{
+	static int current_power_state = 0;
+
+	if (1 == on) {
+		if (0 == current_power_state) {
+			sprd_headset_audio_headmic_sleep_disable(dev, 1);
+			current_power_state = 1;
+		}
+	} else {
+		if (1 == current_power_state) {
+			sprd_headset_audio_headmic_sleep_disable(dev, 0);
+			current_power_state = 0;
+		}
+	}
+
+	return;
+}
+
+static void headmicbias_power_on(struct device *dev, int on)
+{
+	static int current_power_state = 0;
+	struct sprd_headset *ht = &headset;
+
+	if (1 == on) {
+		if (0 == current_power_state) {
+			if(NULL != ht->platform_data->external_headmicbias_power_on)
+				ht->platform_data->external_headmicbias_power_on(1);
+			sprd_headset_headmic_bias_control(dev, 1);
+			current_power_state = 1;
+		}
+	} else {
+		if (1 == current_power_state) {
+			if(NULL != ht->platform_data->external_headmicbias_power_on)
+				ht->platform_data->external_headmicbias_power_on(0);
+			sprd_headset_headmic_bias_control(dev, 0);
+			current_power_state = 0;
+		}
+	}
+
+	return;
+}
+
+static int ana_sts0_confirm(void)
+{
+        if(0 == headset_reg_get_bit(HEADMIC_DETECT_REG(ANA_STS0), AUDIO_HEAD_INSERT))
+                return 0;
+        else
+                return 1;
+}
+
+static int adc_compare(int x1, int x2)
+{
+        int delta = 0;
+        int max = 0;
+
+        if((x1<100) && (x2<100))
+                return 1;
+
+        x1 = ((0==x1) ? 1 : (x1*100));
+        x2 = ((0==x2) ? 1 : (x2*100));
+
+        delta = ABS(x1-x2);
+        max = MAX(x1, x2);
+
+        if(delta < ((max*10)/100))
+                return 1;
+        else
+                return 0;
+}
+
+static int adc_get_average(int gpio_num, int gpio_value)
+{
+	int i = 0;
+	int j = 0;
+	int k = 0;
+	int adc_average = 0;
+	int success = 1;
+	int adc[ADC_READ_COUNT] = {0};
+	struct sprd_headset *ht = &headset;
+	struct sprd_headset_platform_data *pdata = ht->platform_data;
+
+	//================= debug =====================
+	if(debug_level >= 3) {
+		int count = 0;
+		int adc_val = 0;
+		int gpio_button = 0;
+		int ana_cfg0 = 0;
+		int ana_cfg1 = 0;
+		int ana_cfg20 = 0;
+		int ana_sts0 = 0;
+
+		while(count < 20)
+		{
+			count++;
+			adc_val = wrap_sci_adc_get_value(ADC_CHANNEL_HEADMIC, 0);
+			gpio_button = gpio_get_value(pdata->gpio_button);
+			ana_cfg0 = sci_adi_read(HEADMIC_DETECT_REG(ANA_CFG0));
+			ana_cfg1 = sci_adi_read(HEADMIC_DETECT_REG(ANA_CFG1));
+			ana_cfg20 = sci_adi_read(HEADMIC_DETECT_REG(ANA_CFG20));
+			ana_sts0 = sci_adi_read(HEADMIC_DETECT_REG(ANA_STS0));
+
+			PRINT_INFO("%2d:  gpio_button=%d  adc=%4d  ana_cfg0=0x%08X  ana_cfg1=0x%08X  ana_cfg20=0x%08X  ana_sts0=0x%08X\n",
+				count, gpio_button, adc_val, ana_cfg0, ana_cfg1, ana_cfg20, ana_sts0);
+			msleep(1);
+		}
+	}
+	//================= debug =====================
+
+	msleep(1);
+	if(0 == headset_reg_get_bit(HEADMIC_DETECT_REG(ANA_CFG0), AUDIO_HEADMIC_SLEEP_EN))
+		PRINT_INFO("AUDIO_HEADMIC_SLEEP_EN is disabled\n");
+
+	for(i=0; i< ADC_READ_LOOP; i++) {
+		if(gpio_get_value(gpio_num) != gpio_value) {
+			PRINT_INFO("gpio value changed!!! the adc read operation aborted (step1)\n");
+			return -1;
+		}
+		if(0 == ana_sts0_confirm()) {
+			PRINT_INFO("ana_sts0_confirm failed!!! the adc read operation aborted (step2)\n");
+			return -1;
+		}
+		adc[0] = wrap_sci_adc_get_value(ADC_CHANNEL_HEADMIC, 0);
+		for(j=0; j<ADC_READ_COUNT-1; j++) {
+			udelay(100);
+			if(gpio_get_value(gpio_num) != gpio_value) {
+				PRINT_INFO("gpio value changed!!! the adc read operation aborted (step3)\n");
+				return -1;
+			}
+			if(0 == ana_sts0_confirm()) {
+				PRINT_INFO("ana_sts0_confirm failed!!! the adc read operation aborted (step4)\n");
+				return -1;
+			}
+			adc[j+1] = wrap_sci_adc_get_value(ADC_CHANNEL_HEADMIC, 0);
+			if(0 == adc_compare(adc[j], adc[j+1])) {
+				success = 0;
+				for(k=0; k<=j+1; k++) {
+					PRINT_DBG("adc[%d] = %d\n", k, adc[k]);
+				}
+				break;
+			}
+		}
+		if(1 == success) {
+			msleep(DBNC_CNT3_VALUE);
+			if(gpio_get_value(gpio_num) != gpio_value) {
+				PRINT_INFO("gpio value changed!!! the adc read operation aborted (step5)\n");
+				return -1;
+			}
+			if(0 == ana_sts0_confirm()) {
+				PRINT_INFO("ana_sts0_confirm failed!!! the adc read operation aborted (step6)\n");
+				return -1;
+			}
+			for(i=0; i<ADC_READ_COUNT; i++) {
+				adc_average += adc[i];
+				PRINT_DBG("adc[%d] = %d\n", i, adc[i]);
+			}
+			adc_average = adc_average / ADC_READ_COUNT;
+			PRINT_DBG("adc_get_average success, adc_average = %d\n", adc_average);
+			return adc_average;
+		}
+		else if(i+1< ADC_READ_LOOP) {
+			PRINT_INFO("adc_get_average failed, retrying count = %d\n", i+1);
+			msleep(1);
+		}
+	}
+
+	return -1;
+}
+
+static int headset_irq_set_irq_type(unsigned int irq, unsigned int type)
+{
+        struct sprd_headset *ht = &headset;
+        struct irq_desc *irq_desc = NULL;
+        unsigned int irq_flags = 0;
+        int ret = -1;
+
+        ret = irq_set_irq_type(irq, type);
+        irq_desc = irq_to_desc(irq);
+        irq_flags = irq_desc->action->flags;
+
+        if(irq == ht->irq_button) {
+                if(IRQF_TRIGGER_HIGH == type) {
+                        PRINT_DBG("IRQF_TRIGGER_HIGH is set for irq_button(%d). irq_flags = 0x%08X, ret = %d\n",
+							ht->irq_button, irq_flags, ret);
+                }
+                else if(IRQF_TRIGGER_LOW == type) {
+                        PRINT_DBG("IRQF_TRIGGER_LOW is set for irq_button(%d). irq_flags = 0x%08X, ret = %d\n",
+							ht->irq_button, irq_flags, ret);
+                }
+        }
+        else if(irq == ht->irq_detect) {
+                if(IRQF_TRIGGER_HIGH == type) {
+                        PRINT_DBG("IRQF_TRIGGER_HIGH is set for irq_detect(%d). irq_flags = 0x%08X, ret = %d\n",
+							ht->irq_detect, irq_flags, ret);
+                }
+                else if(IRQF_TRIGGER_LOW == type) {
+                        PRINT_DBG("IRQF_TRIGGER_LOW is set for irq_detect(%d). irq_flags = 0x%08X, ret = %d\n",
+							ht->irq_detect, irq_flags, ret);
+                }
+        }
+        return 0;
+}
+
+static int headset_button_valid(int gpio_detect_value_current)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+        int button_is_valid = 0;
+
+        if(1 == pdata->irq_trigger_level_detect) {
+                if(1 == gpio_detect_value_current)
+                        button_is_valid = 1;
+                else
+                        button_is_valid = 0;
+        } else {
+                if(0 == gpio_detect_value_current)
+                        button_is_valid = 1;
+                else
+                        button_is_valid = 0;
+        }
+
+        return button_is_valid;
+}
+
+static int headset_gpio_2_button_state(int gpio_button_value_current)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+        int button_state_current = 0;
+
+        if(1 == pdata->irq_trigger_level_button) {
+                if(1 == gpio_button_value_current)
+                        button_state_current = 1;
+                else
+                        button_state_current = 0;
+        } else {
+                if(0 == gpio_button_value_current)
+                        button_state_current = 1;
+                else
+                        button_state_current = 0;
+        }
+
+        return button_state_current; //0==released, 1==pressed
+}
+
+static int headset_plug_confirm_by_adc(int last_gpio_detect_value)
+{
+	struct sprd_headset *ht = &headset;
+	struct sprd_headset_platform_data *pdata = ht->platform_data;
+	int adc_last = 0;
+	int adc_current = 0;
+	int count = 0;
+	int adc_read_interval = 10;
+
+	msleep(adc_read_interval);
+	adc_last = adc_get_average(pdata->gpio_detect, last_gpio_detect_value);
+	if(-1 == adc_last) {
+		PRINT_INFO("headset_plug_confirm_by_adc failed!!!\n");
+		return -1;
+	}
+
+	while(count < PLUG_CONFIRM_COUNT) {
+		adc_current = adc_get_average(pdata->gpio_detect, last_gpio_detect_value);
+		if(-1 == adc_current) {
+			PRINT_INFO("headset_plug_confirm_by_adc failed!!!\n");
+			return -1;
+		}
+		if(0 == adc_compare(adc_last, adc_current)) {
+			PRINT_INFO("headset_plug_confirm_by_adc failed!!!\n");
+			return -1;
+		}
+		adc_last = adc_current;
+		count++;
+		msleep(adc_read_interval);
+	}
+	PRINT_INFO("headset_plug_confirm_by_adc success!!!\n");
+	return adc_current;
+}
+
+static SPRD_HEADSET_TYPE headset_type_detect(int last_gpio_detect_value)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+        int adc_mic_average = 0;
+        int adc_left_average = 0;
+#ifdef CONFIG_HEADSET_AUXADC_CAL_SUPPORTED
+        int adc_mic_ideal = 0;
+        int adc_left_ideal = 0;
+#endif
+        int no_mic_retry_count = NO_MIC_RETRY_COUNT;
+        unsigned int head_insert_2;
+
+        ENTER;
+
+        if(0 != pdata->gpio_switch)
+                gpio_direction_output(pdata->gpio_switch, 0);
+        else
+                PRINT_INFO("automatic type switch is unsupported\n");
+
+        headset_button_irq_threshold(1);
+        headset_detect_init();
+        headset_detect_circuit(1);
+
+no_mic_retry:
+
+        //get adc value of left
+        if(EIC_AUD_HEAD_INST2 == pdata->gpio_detect) {
+                PRINT_INFO("HEADSET_DETECT_GPIO=%d, matched the reference phone, now getting adc value of left\n", pdata->gpio_detect);
+                set_adc_to_headmic(0);
+                msleep(50);
+                adc_left_average = headset_plug_confirm_by_adc(last_gpio_detect_value);
+                if(-1 == adc_left_average)
+                        return HEADSET_TYPE_ERR;
+        } else {
+                PRINT_INFO("HEADSET_DETECT_GPIO=%d, NOT matched the reference phone(GPIO_%d), set adc_left_average to 0\n",
+					pdata->gpio_detect, EIC_AUD_HEAD_INST2);
+                adc_left_average = 0;
+        }
+
+        //get adc value of mic
+        set_adc_to_headmic(1);
+        msleep(50);
+        adc_mic_average = headset_plug_confirm_by_adc(last_gpio_detect_value);
+        if(-1 == adc_mic_average)
+                return HEADSET_TYPE_ERR;
+#ifdef CONFIG_HEADSET_AUXADC_CAL_SUPPORTED
+        adc_mic_ideal = adc_get_ideal(adc_mic_average);
+        adc_left_ideal = adc_get_ideal(adc_left_average);
+
+        PRINT_INFO("adc_mic_average=%d, adc_mic_ideal=%d\n", adc_mic_average, adc_mic_ideal);
+        PRINT_INFO("adc_left_average=%d, adc_left_ideal=%d\n", adc_left_average, adc_left_ideal);
+
+        if(adc_mic_ideal >= 0 && adc_left_ideal >= 0) {
+                adc_mic_average = adc_mic_ideal;
+                adc_left_average = adc_left_ideal;
+        }
+#else
+        PRINT_INFO("adc_mic_average = %d\n", adc_mic_average);
+        PRINT_INFO("adc_left_average = %d\n", adc_left_average);
+#endif
+        if((gpio_get_value(pdata->gpio_detect)) != last_gpio_detect_value) {
+                PRINT_INFO("software debance (gpio check)!!!(headset_type_detect)\n");
+                return HEADSET_TYPE_ERR;
+        }
+
+        if(0 == ana_sts0_confirm()) {
+                PRINT_INFO("software debance (ana_sts0_confirm)!!!(headset_type_detect)\n");
+                return HEADSET_TYPE_ERR;
+        }
+
+        head_insert_2 = headset_reg_get_bit(HEADMIC_DETECT_REG(ANA_STS0), AUDIO_HEAD_INSERT_2);
+        if((adc_mic_average < pdata->adc_threshold_3pole_detect)) {
+                if(0 != no_mic_retry_count) {
+                        PRINT_INFO("no_mic_retry\n");
+                        no_mic_retry_count--;
+                        goto no_mic_retry;
+                }
+                return HEADSET_NO_MIC;
+        }
+        else if((adc_left_average < ADC_GND) && (adc_mic_average > ADC_GND))
+                return HEADSET_NORMAL;
+/* < add by lgd */
+#ifdef CONFIG_CAMERA_POLE_SUPPORT
+        else if((adc_left_average > ADC_GND) && (adc_mic_average > ADC_GND)) {
+                if (ABS(adc_mic_average - adc_left_average) < ADC_GND  && adc_left_average < 2300)
+                        return HEADSET_NORTH_AMERICA;
+                else
+                        return HEADSET_CAMERA_POLE;
+        }
+#else
+        else if((adc_left_average > ADC_GND) && (adc_mic_average > ADC_GND)
+                && (ABS(adc_mic_average - adc_left_average) < ADC_GND))
+                return HEADSET_NORTH_AMERICA;
+#endif
+/* add by lgd > */
+        else {
+                PRINT_INFO("head_insert_2 = %d\n", head_insert_2);
+                return HEADSET_TYPE_ERR;
+        }
+
+}
+
+static void button_release_verify(void)
+{
+        struct sprd_headset *ht = &headset;
+
+        if(1 == button_state_last) {
+                input_event(ht->input_dev, EV_KEY, current_key_code, 0);
+                input_sync(ht->input_dev);
+                button_state_last = 0;
+                PRINT_INFO("headset button released by force!!! current_key_code = %d(0x%04X)\n", current_key_code, current_key_code);
+
+                if (1 == ht->platform_data->irq_trigger_level_button)
+                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_HIGH);
+                else
+                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_LOW);
+        }
+}
+
+static void headset_button_work_func(struct work_struct *work)
+{
+	PRINT_INFO("headset_button_work_func enter into\n");
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+        int gpio_button_value_current = 0;
+        int button_state_current = 0;
+        int adc_mic_average = 0;
+#ifdef CONFIG_HEADSET_AUXADC_CAL_SUPPORTED
+        int adc_ideal = 0;
+#endif
+        int i = 0;
+
+        down(&headset_sem);
+        set_adc_to_headmic(1);
+
+        ENTER;
+
+        gpio_button_value_current = gpio_get_value(pdata->gpio_button);
+        if(gpio_button_value_current != gpio_button_value_last) {
+                PRINT_INFO("software debance (step 1: gpio check)!!!(headset_button_work_func)\n");
+                #ifdef ADPGAR_BYP_SELECT
+                queue_delayed_work(adpgar_byp_select_work_queue, &adpgar_byp_select_work, msecs_to_jiffies(0));
+                #endif
+                goto out;
+        }
+
+        button_state_current = headset_gpio_2_button_state(gpio_button_value_current);
+
+        if(1 == button_state_current) {//pressed!
+                if(ht->platform_data->nbuttons > 0) {
+                        adc_mic_average = adc_get_average(pdata->gpio_button, gpio_button_value_last);
+                        if(-1 == adc_mic_average) {
+                                PRINT_INFO("software debance (step 3: adc check)!!!(headset_button_work_func)(pressed)\n");
+                                #ifdef ADPGAR_BYP_SELECT
+                                queue_delayed_work(adpgar_byp_select_work_queue, &adpgar_byp_select_work, msecs_to_jiffies(0));
+                                #endif
+                                goto out;
+                        }
+#ifdef CONFIG_HEADSET_AUXADC_CAL_SUPPORTED
+                        adc_ideal = adc_get_ideal(adc_mic_average);
+                        PRINT_INFO("adc_mic_average=%d, adc_ideal=%d\n", adc_mic_average, adc_ideal);
+
+                        if (adc_ideal >= 0)
+                                adc_mic_average = adc_ideal;
+#else
+                        PRINT_INFO("adc_mic_average = %d\n", adc_mic_average);
+#endif
+                        for (i = 0; i < ht->platform_data->nbuttons; i++) {
+                                PRINT_DBG("adc_min=%d, adc_max=%d, code = %d\n",
+                                        ht->platform_data->headset_buttons[i].adc_min,
+                                        ht->platform_data->headset_buttons[i].adc_max,
+                                        ht->platform_data->headset_buttons[i].code);
+                                if (adc_mic_average >= ht->platform_data->headset_buttons[i].adc_min &&
+                                    adc_mic_average < ht->platform_data->headset_buttons[i].adc_max) {
+                                        current_key_code = ht->platform_data->headset_buttons[i].code;
+                                        break;
+                                }
+                                current_key_code = KEY_RESERVED;
+                        }
+                }
+				/* < add by lgd */
+				#ifdef CONFIG_CAMERA_POLE_SUPPORT
+                if(HEADSET_CAMERA_POLE == ht->raw_type) {
+                        current_key_code = CAMERA_POLE_CODE;
+                }
+                #endif
+				/* add by lgd > */
+                if(0 == button_state_last) {
+                        input_event(ht->input_dev, EV_KEY, current_key_code, 1);
+                        input_sync(ht->input_dev);
+                        button_state_last = 1;
+                        PRINT_INFO("headset button pressed! current_key_code = %d(0x%04X)\n", current_key_code, current_key_code);
+                } else {
+                        PRINT_ERR("headset button pressed already! current_key_code = %d(0x%04X)\n", current_key_code, current_key_code);
+                        #ifdef ADPGAR_BYP_SELECT
+                        queue_delayed_work(adpgar_byp_select_work_queue, &adpgar_byp_select_work, msecs_to_jiffies(0));
+                        #endif
+                }
+
+                if (1 == ht->platform_data->irq_trigger_level_button)
+                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_LOW);
+                else
+                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_HIGH);
+
+                headset_irq_button_enable(1, ht->irq_button);
+        } else { //released!
+                if(1 == button_state_last) {
+                        input_event(ht->input_dev, EV_KEY, current_key_code, 0);
+                        input_sync(ht->input_dev);
+                        button_state_last = 0;
+                        PRINT_INFO("headset button released! current_key_code = %d(0x%04X)\n", current_key_code, current_key_code);
+                } else
+                        PRINT_ERR("headset button released already! current_key_code = %d(0x%04X)\n", current_key_code, current_key_code);
+
+                if (1 == ht->platform_data->irq_trigger_level_button)
+                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_HIGH);
+                else
+                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_LOW);
+
+                headset_irq_button_enable(1, ht->irq_button);
+        }
+out:
+        headset_adc_en(0);
+        headset_irq_button_enable(1, ht->irq_button);
+        //wake_unlock(&headset_button_wakelock);
+        up(&headset_sem);
+	PRINT_INFO("headset_button_work_func go out\n");
+        return;
+}
+static void headset_detect_work_func(struct work_struct *work)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+        SPRD_HEADSET_TYPE headset_type;
+        int plug_state_current = 0;
+        int gpio_detect_value_current = 0;
+
+        down(&headset_sem);
+        ENTER;
+        if (sprd_hts_power.head_mic == NULL) {
+            sprd_headset_power_init(&ht->this_pdev);
+        }
+        if (sprd_hts_power.head_mic == NULL ) {
+            PRINT_INFO("sprd_headset_power_init fail \n");
+            goto out;
+        }
+
+        if(0 == plug_state_last) {
+            if(adie_type >= 3) {
+			    headmicbias_power_on(&ht->this_pdev, 1);
+            }
+        }
+        if(0 == plug_state_last) {
+                gpio_detect_value_current = gpio_get_value(pdata->gpio_detect);
+                PRINT_INFO("gpio_detect_value_current = %d, gpio_detect_value_last = %d, plug_state_last = %d\n",
+                           gpio_detect_value_current, gpio_detect_value_last, plug_state_last);
+
+                if(gpio_detect_value_current != gpio_detect_value_last) {
+                        PRINT_INFO("software debance (step 1)!!!(headset_detect_work_func)\n");
+                        goto out;
+                }
+
+                if(1 == pdata->irq_trigger_level_detect) {
+                        if(1 == gpio_detect_value_current)
+                                plug_state_current = 1;
+                        else
+                                plug_state_current = 0;
+                } else {
+                        if(0 == gpio_detect_value_current)
+                                plug_state_current = 1;
+                        else
+                                plug_state_current = 0;
+                }
+        }
+        else
+                plug_state_current = 0;//no debounce for plug out!!!
+
+        if(1 == plug_state_current && 0 == plug_state_last) {
+                headset_type = headset_type_detect(gpio_detect_value_last);
+				/* < add by lgd */
+				#ifdef CONFIG_CAMERA_POLE_SUPPORT
+                ht->raw_type = headset_type;
+                #endif
+				/* add by lgd > */
+                headset_adc_en(0);
+                switch (headset_type) {
+                case HEADSET_TYPE_ERR:
+                        detect_err_count ++;
+			PRINT_INFO("headset_type = %d detect_err_count = %d(HEADSET_TYPE_ERR)\n", headset_type,detect_err_count);
+                        goto out;
+                case HEADSET_NORTH_AMERICA:
+                        PRINT_INFO("headset_type = %d (HEADSET_NORTH_AMERICA)\n", headset_type);
+                        if(0 != pdata->gpio_switch)
+                                gpio_direction_output(pdata->gpio_switch, 1);
+                        break;
+                case HEADSET_NORMAL:
+                        PRINT_INFO("headset_type = %d (HEADSET_NORMAL)\n", headset_type);
+                        if(0 != pdata->gpio_switch)
+                                gpio_direction_output(pdata->gpio_switch, 0);
+                        break;
+                case HEADSET_NO_MIC:
+                        PRINT_INFO("headset_type = %d (HEADSET_NO_MIC)\n", headset_type);
+                        if(0 != pdata->gpio_switch)
+                                gpio_direction_output(pdata->gpio_switch, 0);
+                        break;
+                case HEADSET_APPLE:
+                        PRINT_INFO("headset_type = %d (HEADSET_APPLE)\n", headset_type);
+                        PRINT_INFO("we have not yet implemented this in the code\n");
+                        break;
+				/* < add by lgd */
+				#ifdef CONFIG_CAMERA_POLE_SUPPORT
+                case HEADSET_CAMERA_POLE:
+                        PRINT_INFO("headset_type = %d (HEADSET_CAMERA_POLE)\n", headset_type);
+                        break;
+				#endif				
+				/* add by lgd > */
+                default:
+                        PRINT_INFO("headset_type = %d (HEADSET_UNKNOWN)\n", headset_type);
+                        break;
+                }
+		detect_err_count = 0;
+                if(headset_type == HEADSET_NO_MIC)
+                        ht->headphone = 1;
+                else
+                        ht->headphone = 0;
+
+                if (ht->headphone) {
+                        headset_button_irq_threshold(0);
+                        headset_irq_button_enable(0, ht->irq_button);
+
+                        ht->type = BIT_HEADSET_NO_MIC;
+			hp_notifier_call_chain(ht->type);
+                        switch_set_state(&ht->sdev, ht->type);
+                        PRINT_INFO("headphone plug in (headset_detect_work_func)\n");
+                } else {
+                        headset_button_irq_threshold(1);
+
+                        if((HEADSET_NORTH_AMERICA == headset_type) && (0 == pdata->gpio_switch)) {
+                                headset_irq_button_enable(0, ht->irq_button);
+                                PRINT_INFO("HEADSET_NORTH_AMERICA is not supported by your hardware! so disable the button irq!\n");
+                        } else {
+                                if (1 == ht->platform_data->irq_trigger_level_button)
+                                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_HIGH);
+                                else
+                                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_LOW);
+
+                                headset_irq_button_enable(1, ht->irq_button);
+                        }
+						/* < add by lgd */
+                        #ifdef CONFIG_CAMERA_POLE_SUPPORT
+                        if(HEADSET_CAMERA_POLE != ht->raw_type) {
+                        #endif
+						/* add by lgd > */
+                        ht->type = BIT_HEADSET_MIC;
+						hp_notifier_call_chain(ht->type);
+                        switch_set_state(&ht->sdev, ht->type);
+						/* < add by lgd */
+                        #ifdef CONFIG_CAMERA_POLE_SUPPORT
+                        }
+                        #endif						
+						/* add by lgd > */
+                        PRINT_INFO("headset plug in (headset_detect_work_func)\n");
+                        #ifdef ADPGAR_BYP_SELECT
+                        queue_delayed_work(adpgar_byp_select_work_queue, &adpgar_byp_select_work, msecs_to_jiffies(500));
+                        #endif
+                }
+
+                /***polling ana_sts0 to avoid the hardware defect***/
+#ifdef SPRD_STS_POLLING_EN
+                if ((1 != adie_type) && (adie_type < 5)) {
+                        plug_state_class_g_on = 1;
+                        sts_check_work_need_to_cancel = 0;
+                        queue_delayed_work(sts_check_work_queue, &sts_check_work, msecs_to_jiffies(1000));
+                        PRINT_INFO("start sts_check_work_queue\n");
+                }
+                else
+                        PRINT_INFO("sts_check_work_queue is no need to start\n");
+#else
+                PRINT_INFO("sts_check_work_queue is not used\n");
+#endif
+                /***polling ana_sts0 to avoid the hardware defect***/
+
+                plug_state_last = 1;
+
+                if(1 == pdata->irq_trigger_level_detect)
+                        headset_irq_set_irq_type(ht->irq_detect, IRQF_TRIGGER_LOW);
+                else
+                        headset_irq_set_irq_type(ht->irq_detect, IRQF_TRIGGER_HIGH);
+				/* < add by lgd */	
+				#ifdef CONFIG_CAMERA_POLE_SUPPORT
+                if(HEADSET_CAMERA_POLE != ht->raw_type)
+                #endif
+				/* add by lgd > */
+                if (adie_type >= 5) {
+                        headset_reg_set_bit(ANA_CTL_GLB_BASE + ARM_MF_REG, HEAD_INSERT_EIC_EN);
+                        headset_reg_clr_bit(ANA_CTL_GLB_BASE + ARM_MF_REG, HEAD_INSERT2_EIC_EN);
+                        PRINT_INFO("disable HEAD_INSERT2_EIC_EN, enable HEAD_INSERT_EIC_EN\n");
+                }
+
+                headset_irq_detect_enable(1, ht->irq_detect);
+        } else if(0 == plug_state_current && 1 == plug_state_last) {
+
+                headset_irq_button_enable(0, ht->irq_button);
+                button_release_verify();
+
+                /***polling ana_sts0 to avoid the hardware defect***/
+#ifdef SPRD_STS_POLLING_EN
+                if ((1 != adie_type) && (adie_type < 5)) {
+                        sts_check_work_need_to_cancel = 1;
+                        if(0 == plug_state_class_g_on) {
+                                PRINT_INFO("plug out already!!!\n");
+                                goto plug_out_already;
+                        }
+                        plug_state_class_g_on = 0;
+                }
+#endif
+                /***polling ana_sts0 to avoid the hardware defect***/
+
+                if (ht->headphone) {
+                        PRINT_INFO("headphone plug out (headset_detect_work_func)\n");
+                } else {
+                        PRINT_INFO("headset plug out (headset_detect_work_func)\n");
+                }
+				/* < add by lgd */
+                #ifdef CONFIG_CAMERA_POLE_SUPPORT
+                if(HEADSET_CAMERA_POLE != ht->raw_type) {
+                #endif				
+				/* add by lgd > */
+                ht->type = BIT_HEADSET_OUT;
+		hp_notifier_call_chain(ht->type);
+                switch_set_state(&ht->sdev, ht->type);
+				/* < add by lgd */
+                #ifdef CONFIG_CAMERA_POLE_SUPPORT
+                }
+                #endif
+				/* add by lgd > */
+plug_out_already:
+                plug_state_last = 0;
+
+                if(1 == pdata->irq_trigger_level_detect)
+                        headset_irq_set_irq_type(ht->irq_detect, IRQF_TRIGGER_HIGH);
+                else
+                        headset_irq_set_irq_type(ht->irq_detect, IRQF_TRIGGER_LOW);
+
+                if (adie_type >= 5) {
+                        headset_reg_set_bit(ANA_CTL_GLB_BASE + ARM_MF_REG, HEAD_INSERT2_EIC_EN);
+						/* < add by lgd */
+                        #ifdef CONFIG_CAMERA_POLE_SUPPORT
+                        if(0 == headset_ctl) {
+                        #endif
+						/* add by lgd > */
+                        headset_reg_clr_bit(ANA_CTL_GLB_BASE + ARM_MF_REG, HEAD_INSERT_EIC_EN);
+                        PRINT_INFO("disable HEAD_INSERT_EIC_EN, enable HEAD_INSERT2_EIC_EN\n");
+						/* < add by lgd */
+                        #ifdef CONFIG_CAMERA_POLE_SUPPORT
+                        }
+                        #endif
+						/* add by lgd > */
+                }
+
+                headset_irq_detect_enable(1, ht->irq_detect);
+        } else {
+                PRINT_INFO("irq_detect must be enabled anyway!!!\n");
+                goto out;
+        }
+out:
+
+        if(0 == plug_state_last) {
+                if(adie_type >= 3) {
+					/* < add by lgd */
+					    #ifdef CONFIG_CAMERA_POLE_SUPPORT
+                        if(0 == headset_ctl)
+                        #endif
+					/* add by lgd > */
+			headmicbias_power_on(&ht->this_pdev, 0);
+                }
+        }
+	if(detect_err_count < 500) {
+        	headset_irq_detect_enable(1, ht->irq_detect);
+	}
+        //wake_unlock(&headset_detect_wakelock);
+        up(&headset_sem);
+        return;
+}
+
+/***polling ana_sts0 to avoid the hardware defect***/
+#ifdef SPRD_STS_POLLING_EN
+static void headset_sts_check_func(struct work_struct *work)
+{
+        int ana_sts0 = 0;
+        int ana_sts0_debance = 0;
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+		SPRD_HEADSET_TYPE headset_type;
+		/* < add by lgd */
+        #ifdef CONFIG_CAMERA_POLE_SUPPORT
+        if(HEADSET_CAMERA_POLE == ht->raw_type) {
+                PRINT_INFO("headset_sts_check_func is not implemented for camera pole\n");
+                return;
+        }
+        #endif		
+		/* add by lgd > */
+        down(&headset_sem);
+
+        ENTER;
+
+        if(1 == sts_check_work_need_to_cancel)
+                goto out;
+
+        ana_sts0_debance = sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_STS0);//arm base address:0x40038600
+        msleep(100);
+        ana_sts0 = sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_STS0);//arm base address:0x40038600
+        if((0x00000060 & ana_sts0) != (0x00000060 & ana_sts0_debance)) {
+                PRINT_INFO("software debance!!!(headset_sts_check_func)\n");
+                goto out;
+        }
+
+        if(((0x00000060 & ana_sts0) != 0x00000060) && (1 == plug_state_class_g_on)) {
+
+                headset_irq_button_enable(0, ht->irq_button);
+                button_release_verify();
+
+                if (ht->headphone) {
+                        PRINT_INFO("headphone plug out (headset_sts_check_func)\n");
+                } else {
+                        PRINT_INFO("headset plug out (headset_sts_check_func)\n");
+                }
+                ht->type = BIT_HEADSET_OUT;
+		hp_notifier_call_chain(ht->type);
+                switch_set_state(&ht->sdev, ht->type);
+                plug_state_class_g_on = 0;
+        }
+        if(((0x00000060 & ana_sts0) == 0x00000060) && (0 == plug_state_class_g_on)) {
+                headset_type = headset_type_detect(gpio_get_value(pdata->gpio_detect));
+                headset_adc_en(0);
+                switch (headset_type) {
+                case HEADSET_TYPE_ERR:
+                        PRINT_INFO("headset_type = %d (HEADSET_TYPE_ERR)\n", headset_type);
+                        goto out;
+                case HEADSET_NORTH_AMERICA:
+                        PRINT_INFO("headset_type = %d (HEADSET_NORTH_AMERICA)\n", headset_type);
+                        if(0 != pdata->gpio_switch)
+                                gpio_direction_output(pdata->gpio_switch, 1);
+                        break;
+                case HEADSET_NORMAL:
+                        PRINT_INFO("headset_type = %d (HEADSET_NORMAL)\n", headset_type);
+                        if(0 != pdata->gpio_switch)
+                                gpio_direction_output(pdata->gpio_switch, 0);
+                        break;
+                case HEADSET_NO_MIC:
+                        PRINT_INFO("headset_type = %d (HEADSET_NO_MIC)\n", headset_type);
+                        if(0 != pdata->gpio_switch)
+                                gpio_direction_output(pdata->gpio_switch, 0);
+                        break;
+                case HEADSET_APPLE:
+                        PRINT_INFO("headset_type = %d (HEADSET_APPLE)\n", headset_type);
+                        PRINT_INFO("we have not yet implemented this in the code\n");
+                        break;
+                default:
+                        PRINT_INFO("headset_type = %d (HEADSET_UNKNOWN)\n", headset_type);
+                        break;
+                }
+
+                if(headset_type == HEADSET_NO_MIC)
+                        ht->headphone = 1;
+                else
+                        ht->headphone = 0;
+
+                if (ht->headphone) {
+                        headset_button_irq_threshold(0);
+                        headset_irq_button_enable(0, ht->irq_button);
+
+                        ht->type = BIT_HEADSET_NO_MIC;
+			hp_notifier_call_chain(ht->type);
+                        switch_set_state(&ht->sdev, ht->type);
+                        PRINT_INFO("headphone plug in (headset_sts_check_func)\n");
+                } else {
+                        headset_button_irq_threshold(1);
+
+                        if((HEADSET_NORTH_AMERICA == headset_type) && (0 == pdata->gpio_switch)) {
+                                headset_irq_button_enable(0, ht->irq_button);
+                                PRINT_INFO("HEADSET_NORTH_AMERICA is not supported by your hardware! so disable the button irq!\n");
+                        } else {
+                                if (1 == ht->platform_data->irq_trigger_level_button)
+                                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_HIGH);
+                                else
+                                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_LOW);
+
+                                headset_irq_button_enable(1, ht->irq_button);
+                        }
+
+                        ht->type = BIT_HEADSET_MIC;
+			hp_notifier_call_chain(ht->type);
+                        switch_set_state(&ht->sdev, ht->type);
+                        PRINT_INFO("headset plug in (headset_sts_check_func)\n");
+                }
+                plug_state_class_g_on = 1;
+        }
+out:
+        if(0 == sts_check_work_need_to_cancel)
+                queue_delayed_work(sts_check_work_queue, &sts_check_work, msecs_to_jiffies(1000));
+        else
+                PRINT_INFO("sts_check_work cancelled\n");
+
+        up(&headset_sem);
+        return;
+}
+#endif
+/***polling ana_sts0 to avoid the hardware defect***/
+
+#ifdef ADPGAR_BYP_SELECT
+static void adpgar_byp_select_func(struct work_struct *work)
+{
+        headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG5), AUDIO_ADPGAR_BYP_HEADMIC_2_ADCR, AUDIO_ADPGAR_BYP_MASK, AUDIO_ADPGAR_BYP_SHIFT);
+        PRINT_INFO("ANA_CFG5 = 0x%08X\n", sci_adi_read(HEADMIC_DETECT_REG(ANA_CFG5)));
+        msleep(100);
+        headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CFG5), AUDIO_ADPGAR_BYP_NORMAL, AUDIO_ADPGAR_BYP_MASK, AUDIO_ADPGAR_BYP_SHIFT);
+        PRINT_INFO("ANA_CFG5 = 0x%08X\n", sci_adi_read(HEADMIC_DETECT_REG(ANA_CFG5)));
+        PRINT_INFO("adpgar_byp_select_func\n");
+}
+#endif
+
+static void reg_dump_func(struct work_struct *work)
+{
+        int adc_mic = 0;
+
+        int gpio_detect = 0;
+        int gpio_button = 0;
+
+        int ana_sts0 = 0;
+        int ana_cfg0 = 0;
+        int ana_cfg1 = 0;
+        int ana_cfg20 = 0;
+
+        int hid_cfg0 = 0;
+        int hid_cfg2 = 0;
+        int hid_cfg3 = 0;
+        int hid_cfg4 = 0;
+
+        int arm_module_en = 0;
+        int arm_clk_en = 0;
+
+        adc_mic = wrap_sci_adc_get_value(ADC_CHANNEL_HEADMIC, 0);
+
+        gpio_detect = gpio_get_value(headset.platform_data->gpio_detect);
+        gpio_button = gpio_get_value(headset.platform_data->gpio_button);
+
+        sci_adi_write(ANA_REG_GLB_ARM_MODULE_EN, BIT_ANA_AUD_EN, BIT_ANA_AUD_EN);//arm base address:0x40038800 for register accessable
+        ana_cfg0 = sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_CFG0);//arm base address:0x40038600
+        ana_cfg1 = sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_CFG1);//arm base address:0x40038600
+        ana_cfg20 = sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_CFG20);//arm base address:0x40038600
+        ana_sts0 = sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_STS0);//arm base address:0x40038600
+
+        sci_adi_write(ANA_REG_GLB_ARM_MODULE_EN, BIT_ANA_HDT_EN, BIT_ANA_HDT_EN);//arm base address:0x40038800 for register accessable
+        sci_adi_write(ANA_REG_GLB_ARM_CLK_EN, BIT_CLK_AUD_HID_EN, BIT_CLK_AUD_HID_EN);//arm base address:0x40038800 for register accessable
+
+        hid_cfg2 = sci_adi_read(ANA_HDT_INT_BASE+HID_CFG2);//arm base address:0x40038700
+        hid_cfg3 = sci_adi_read(ANA_HDT_INT_BASE+HID_CFG3);//arm base address:0x40038700
+        hid_cfg4 = sci_adi_read(ANA_HDT_INT_BASE+HID_CFG4);//arm base address:0x40038700
+        hid_cfg0 = sci_adi_read(ANA_HDT_INT_BASE+HID_CFG0);//arm base address:0x40038700
+
+        arm_module_en = sci_adi_read(ANA_REG_GLB_ARM_MODULE_EN);
+        arm_clk_en = sci_adi_read(ANA_REG_GLB_ARM_CLK_EN);
+
+        PRINT_INFO("GPIO_%03d(det)=%d    GPIO_%03d(but)=%d    adc_mic=%d\n",
+                   headset.platform_data->gpio_detect, gpio_detect,
+                   headset.platform_data->gpio_button, gpio_button,
+                   adc_mic);
+        PRINT_INFO("arm_module_en|arm_clk_en|ana_cfg0  |ana_cfg1  |ana_cfg20 |ana_sts0  |hid_cfg2  |hid_cfg3  |hid_cfg4  |hid_cfg0\n");
+        PRINT_INFO("0x%08X   |0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X\n",
+                   arm_module_en, arm_clk_en, ana_cfg0, ana_cfg1, ana_cfg20, ana_sts0, hid_cfg2, hid_cfg3, hid_cfg4, hid_cfg0);
+#if 0
+        int i = 0;
+        int hbd[20] = {0};
+
+        for(i=0; i<20; i++)
+                hbd[i] = sci_adi_read(ANA_HDT_INT_BASE + (i*4));
+
+        PRINT_INFO(" hbd_cfg0 | hbd_cfg1 | hbd_cfg2 | hbd_cfg3 | hbd_cfg4 | hbd_cfg5 | hbd_cfg6 | hbd_cfg7 | hbd_cfg8 | hbd_cfg9\n");
+        PRINT_INFO("0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X\n",
+                   hbd[0], hbd[1], hbd[2], hbd[3], hbd[4], hbd[5], hbd[6], hbd[7], hbd[8], hbd[9]);
+
+        PRINT_INFO("hbd_cfg10 |hbd_cfg11 |hbd_cfg12 |hbd_cfg13 |hbd_cfg14 |hbd_cfg15 |hbd_cfg16 | hbd_sts0 | hbd_sts1 | hbd_sts2\n");
+        PRINT_INFO("0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X\n",
+                   hbd[10], hbd[11], hbd[12], hbd[13], hbd[14], hbd[15], hbd[16], hbd[17], hbd[18], hbd[19]);
+#endif
+
+        if (debug_level >= 2)
+                queue_delayed_work(reg_dump_work_queue, &reg_dump_work, msecs_to_jiffies(500));
+        return;
+}
+
+/* < add by lgd */
+#ifdef CONFIG_CAMERA_POLE_SUPPORT
+static void camera_pole_func(struct work_struct *work)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+
+        down(&headset_sem);
+        
+        if(1 == headset_ctl) {
+				headmicbias_power_on(&ht->this_pdev, 1);
+                msleep(5);
+                headset_detect_circuit(1);
+                msleep(5);
+                headset_reg_set_bit(ANA_CTL_GLB_BASE + ARM_MF_REG, HEAD_INSERT_EIC_EN);
+                PRINT_INFO("enable headmic_in insert detect\n");
+        } else {
+                if((HEADSET_CAMERA_POLE == ht->raw_type) || (0 == plug_state_last)) {
+                        headset_reg_clr_bit(ANA_CTL_GLB_BASE + ARM_MF_REG, HEAD_INSERT_EIC_EN);
+						headmicbias_power_on(&ht->this_pdev, 0);
+                        msleep(5);
+                        headset_detect_circuit(0);
+                        msleep(5);
+                        PRINT_INFO("disable headmic_in insert detect\n");
+                }
+        }
+
+        up(&headset_sem);
+}
+#endif
+/* add by lgd > */
+
+/**
+ * some phone boards, when no headset plugin, the button headset_button_valid()
+ * will always return 0, so we need to disable headset_button irq in here
+ * otherwise button irq will always happen.
+ */
+volatile int headset_button_hardware_bug_fix_stage = 1;
+static void headset_button_hardware_bug_fix(struct sprd_headset *ht)
+{
+	if (headset_button_hardware_bug_fix_stage) {
+		headset_irq_button_enable(0, ht->irq_button); // disable button irq before headset detected
+		pr_err("This phone board headset button circuit has bug, please fix the hardware\n");
+	}
+}
+
+static irqreturn_t headset_button_irq_handler(int irq, void *dev)
+{
+	PRINT_INFO("headset_button_irq_handler enter into\n");
+        struct sprd_headset *ht = dev;
+        int button_state_current = 0;
+        int gpio_button_value_current = 0;
+
+		/* < add by lgd */
+        #ifdef CONFIG_CAMERA_POLE_SUPPORT
+        if(HEADSET_CAMERA_POLE != ht->raw_type)
+        #endif
+		/* add by lgd > */
+		
+        if(0 == headset_button_valid(gpio_get_value(ht->platform_data->gpio_detect))) {
+                PRINT_INFO("headset_button_irq_handler: button is invalid!!! IRQ_%d(GPIO_%d) = %d, ANA_STS0 = 0x%08X\n",
+                        ht->irq_button, ht->platform_data->gpio_button, gpio_button_value_last,
+                        sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_STS0));
+				headset_button_hardware_bug_fix(ht);
+
+                if(0 == plug_state_last)
+                        headset_irq_button_enable(0, ht->irq_button);
+
+                return IRQ_HANDLED;
+        }
+
+        gpio_button_value_current = gpio_get_value(ht->platform_data->gpio_button);
+        button_state_current = headset_gpio_2_button_state(gpio_button_value_current);
+        #ifdef ADPGAR_BYP_SELECT
+        if(0 == button_state_current) {
+                queue_delayed_work(adpgar_byp_select_work_queue, &adpgar_byp_select_work, msecs_to_jiffies(0));
+        }
+        #endif
+        if(button_state_current == button_state_last) {
+                PRINT_INFO("button state check failed!!! maybe the release is too quick. button_state_current=%d, button_state_last=%d\n",
+					button_state_current, button_state_last);
+                return IRQ_HANDLED;
+        }
+
+        headset_irq_button_enable(0, ht->irq_button);
+        wake_lock_timeout(&headset_button_wakelock, msecs_to_jiffies(2000));
+        gpio_button_value_last = gpio_button_value_current;
+        PRINT_DBG("headset_button_irq_handler: IRQ_%d(GPIO_%d) = %d, ANA_STS0 = 0x%08X\n",
+                  ht->irq_button, ht->platform_data->gpio_button, gpio_button_value_last,
+                  sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_STS0));
+        queue_work(ht->button_work_queue, &ht->work_button);
+	PRINT_INFO("headset_button_irq_handler go out\n");
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t headset_detect_irq_handler(int irq, void *dev)
+{
+        struct sprd_headset *ht = dev;
+        headset_irq_button_enable(0, ht->irq_button);
+        headset_irq_detect_enable(0, ht->irq_detect);
+        wake_lock_timeout(&headset_detect_wakelock, msecs_to_jiffies(2000));
+        gpio_detect_value_last = gpio_get_value(ht->platform_data->gpio_detect);
+        PRINT_DBG("headset_detect_irq_handler: IRQ_%d(GPIO_%d) = %d, ANA_STS0 = 0x%08X\n",
+                  ht->irq_detect, ht->platform_data->gpio_detect, gpio_detect_value_last,
+                  sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_STS0));
+        queue_delayed_work(ht->detect_work_queue, &ht->work_detect, msecs_to_jiffies(0));
+        return IRQ_HANDLED;
+}
+
+//================= create sys fs for debug ===================
+//============= /sys/kernel/headset/debug_level ===============
+
+static ssize_t headset_debug_level_show(struct kobject *kobj, struct kobj_attribute *attr, char *buff)
+{
+        PRINT_INFO("debug_level = %d\n", debug_level);
+        return sprintf(buff, "%d\n", debug_level);
+}
+
+static ssize_t headset_debug_level_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buff, size_t len)
+{
+        unsigned long level = simple_strtoul(buff, NULL, 10);
+        debug_level = level;
+        PRINT_INFO("debug_level = %d\n", debug_level);
+        if(debug_level >= 2)
+                queue_delayed_work(reg_dump_work_queue, &reg_dump_work, msecs_to_jiffies(500));
+        return len;
+}
+
+static struct kobject *headset_debug_kobj = NULL;
+static struct kobj_attribute headset_debug_attr =
+        __ATTR(debug_level, 0644, headset_debug_level_show, headset_debug_level_store);
+
+
+/* < add by lgd */
+#ifdef CONFIG_CAMERA_POLE_SUPPORT 
+static ssize_t headset_ctl_show(struct kobject *kobj, struct kobj_attribute *attr, char *buff)
+{
+        PRINT_INFO("headset_ctl = %d\n", headset_ctl);
+        return sprintf(buff, "%d\n", headset_ctl);
+}
+
+static ssize_t headset_ctl_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buff, size_t len)
+{
+        unsigned long ctl = simple_strtoul(buff, NULL, 10);
+		if (headset_ctl == ctl)
+				return len;
+        headset_ctl = ctl;
+        PRINT_INFO("headset_ctl = %d\n", headset_ctl);
+        queue_delayed_work(camera_pole_work_queue, &camera_pole_work, msecs_to_jiffies(100));
+        return len;
+}
+
+static struct kobj_attribute headset_ctl_attr =
+        __ATTR(headset_ctl, 0666, headset_ctl_show, headset_ctl_store);
+#endif
+/* add by lgd > */
+		
+static int headset_debug_sysfs_init(void)
+{
+        int ret = -1;
+
+        headset_debug_kobj = kobject_create_and_add("headset", kernel_kobj);
+        if (headset_debug_kobj == NULL) {
+                ret = -ENOMEM;
+                PRINT_ERR("register sysfs failed. ret = %d\n", ret);
+                return ret;
+        }
+
+        ret = sysfs_create_file(headset_debug_kobj, &headset_debug_attr.attr);
+        if (ret) {
+                PRINT_ERR("create sysfs failed. ret = %d\n", ret);
+                return ret;
+        }
+		/* < add by lgd */
+#ifdef CONFIG_CAMERA_POLE_SUPPORT
+        ret = sysfs_create_file(headset_debug_kobj, &headset_ctl_attr.attr);
+        if (ret) {
+                PRINT_ERR("create sysfs failed 2. ret = %d\n", ret);
+                return ret;
+        }
+#endif		
+		/* add by lgd > */
+
+        PRINT_INFO("headset_debug_sysfs_init success\n");
+        return ret;
+}
+//================= create sys fs for debug ===================
+
+#ifdef CONFIG_OF
+static struct sprd_headset_platform_data *headset_detect_parse_dt(
+                         struct device *dev)
+{
+	struct sprd_headset_platform_data *pdata;
+	struct device_node *np = dev->of_node,*buttons_np = NULL;
+	int ret;
+	struct headset_buttons *buttons_data;
+
+	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+	if (!pdata) {
+		dev_err(dev, "could not allocate memory for platform data\n");
+		return NULL;
+	}
+	ret = of_property_read_u32(np, "gpio_switch", &pdata->gpio_switch);
+	if(ret){
+		dev_err(dev, "fail to get gpio_switch\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "gpio_detect", &pdata->gpio_detect);
+	if(ret){
+		dev_err(dev, "fail to get gpio_detect\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "gpio_button", &pdata->gpio_button);
+	if(ret){
+		dev_err(dev, "fail to get gpio_button\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "irq_trigger_level_detect", &pdata->irq_trigger_level_detect);
+	if(ret){
+		dev_err(dev, "fail to get irq_trigger_level_detect\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "irq_trigger_level_button", &pdata->irq_trigger_level_button);
+	if(ret){
+		dev_err(dev, "fail to get irq_trigger_level_button\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "adc_threshold_3pole_detect", &pdata->adc_threshold_3pole_detect);
+	if(ret){
+		dev_err(dev, "fail to get adc_threshold_3pole_detect\n");
+		goto fail;
+	}
+
+	ret = of_property_read_u32(np, "adc_threshold_4pole_detect", &pdata->adc_threshold_4pole_detect);
+	if(ret){
+		dev_err(dev, "fail to get adc_threshold_4pole_detect\n");
+		goto fail;
+	}
+
+	ret = of_property_read_u32(np, "irq_threshold_buttont", &pdata->irq_threshold_buttont);
+	if(ret){
+		dev_err(dev, "fail to get irq_threshold_buttont\n");
+		goto fail;
+	}
+
+	ret = of_property_read_u32(np, "voltage_headmicbias", &pdata->voltage_headmicbias);
+	if(ret){
+		dev_err(dev, "fail to get voltage_headmicbias\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "nbuttons", &pdata->nbuttons);
+	if(ret){
+		dev_err(dev, "fail to get nbuttons\n");
+		goto fail;
+	}
+
+	buttons_data = kzalloc(pdata->nbuttons*sizeof(*buttons_data),GFP_KERNEL);
+	if (!buttons_data) {
+		dev_err(dev, "could not allocate memory for headset_buttons\n");
+		goto fail;
+	}
+        pdata->headset_buttons = buttons_data;
+
+	for_each_child_of_node(np,buttons_np){
+
+		ret = of_property_read_u32(buttons_np, "adc_min", &buttons_data->adc_min);
+		if (ret) {
+			dev_err(dev, "fail to get adc_min\n");
+			goto fail_buttons_data;
+		}
+		ret = of_property_read_u32(buttons_np, "adc_max", &buttons_data->adc_max);
+		if (ret) {
+			dev_err(dev, "fail to get adc_max\n");
+			goto fail_buttons_data;
+		}
+		ret = of_property_read_u32(buttons_np, "code", &buttons_data->code);
+		if (ret) {
+			dev_err(dev, "fail to get code\n");
+			goto fail_buttons_data;
+		}
+		ret = of_property_read_u32(buttons_np, "type", &buttons_data->type);
+		if (ret) {
+			dev_err(dev, "fail to get type\n");
+			goto fail_buttons_data;
+		}
+		printk("device tree data: adc_min = %d adc_max = %d code = %d type = %d \n", buttons_data->adc_min,
+			buttons_data->adc_max, buttons_data->code, buttons_data->type);
+		buttons_data++;
+	};
+
+	return pdata;
+
+fail_buttons_data:
+	kfree(buttons_data);
+	pdata->headset_buttons = NULL;
+fail:
+	kfree(pdata);
+	return NULL;
+}
+#endif
+
+static int headset_detect_probe(struct platform_device *pdev)
+{
+        struct sprd_headset_platform_data *pdata = pdev->dev.platform_data;
+        struct sprd_headset *ht = &headset;
+        unsigned long irqflags = 0;
+        struct input_dev *input_dev = NULL;
+        int i = 0;
+        int ret = -1;
+        int ana_sts0 = 0;
+        int adie_chip_id_low = 0;
+        int adie_chip_id_high = 0;
+
+#ifdef CONFIG_OF
+        struct device_node *np = pdev->dev.of_node;
+        if (pdev->dev.of_node && !pdata){
+                pdata = headset_detect_parse_dt(&pdev->dev);
+                if(pdata)
+                        pdev->dev.platform_data = pdata;
+        }
+        if (!pdata) {
+                printk(KERN_WARNING "headset_detect_probe get platform_data NULL\n");
+                ret = -EINVAL;
+                goto fail_to_get_platform_data;
+        }
+#endif
+
+        adie_chip_id_low = sci_adi_read(ANA_CTL_GLB_BASE+ADIE_CHID_LOW);//A-die chip id LOW
+        adie_chip_id_high = sci_adi_read(ANA_CTL_GLB_BASE+ADIE_CHID_HIGH);//A-die chip id HIGH
+
+        sci_adi_write(ANA_REG_GLB_ARM_MODULE_EN, BIT_ANA_AUD_EN, BIT_ANA_AUD_EN);//arm base address:0x40038800 for register accessable
+        ana_sts0 = sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_STS0);//arm base address:0x40038600
+
+	switch (adie_chip_id_high) {
+		case 0x2713: {//chip is 2713
+			switch (adie_chip_id_low) {
+				case 0xA000: {
+					adie_type = 1; //AC
+					break;
+				}
+				case 0xA001: {
+					if ((0x00000040 & ana_sts0) == 0x00000040) {
+						adie_type = 2; //BA
+						break;
+					} else {
+						adie_type = 3; //BB
+						break;
+					}
+					break;
+				}
+				case 0xCA00: {
+					adie_type = 5; //CA
+					break;
+				}
+				default: {
+					adie_type = 100; //unknow
+					PRINT_ERR("unknow 2713 chip ID!!!\n");
+					break;
+				}
+			}
+			PRINT_INFO("adie chip is 2713, type = %d\n", adie_type);
+			break;//break from 2713
+		}
+
+		case 0x2711: {//chip is 2711
+			adie_type = 4; //Dolphin
+			PRINT_INFO("adie chip is 2711, type = %d\n", adie_type);
+			break; //break from 2711
+		}
+
+		default: {
+			adie_type = 100; //unknow
+			PRINT_ERR("unknow adie chip !!!\n");
+			break;
+		}
+	}
+
+        ht->platform_data = pdata;
+        ht->this_pdev = pdev;
+        headset_detect_init();
+
+        ret = sprd_headset_power_init(&pdev->dev);
+        if (ret)
+                goto fail_to_sprd_headset_power_init;
+
+        if(adie_type < 3) {
+                headmicbias_power_on(&pdev->dev, 1);
+                msleep(5);//this time delay is necessary here
+        }
+
+        PRINT_INFO("====================================================================\n");
+        PRINT_INFO(" write 0~3 to \"/sys/kernel/headset/debug_level\" for headset debug\n");
+        PRINT_INFO("====================================================================\n");
+        PRINT_INFO("D-die chip id = 0x%08X\n", __raw_readl(REG_AON_APB_CHIP_ID));
+        PRINT_INFO("A-die chip id HIGH = 0x%08X\n", adie_chip_id_high);
+        PRINT_INFO("A-die chip id LOW = 0x%08X\n", adie_chip_id_low);
+
+        if (1 == adie_type) {
+                pdata->gpio_detect -= 1;
+                PRINT_WARN("use EIC_AUD_HEAD_INST (EIC4, GPIO_%d) for insert detecting\n", pdata->gpio_detect);
+        } else {
+                PRINT_INFO("use GPIO_%d for insert detecting\n", pdata->gpio_detect);
+        }
+
+        if(0 != pdata->gpio_switch) {
+                ret = gpio_request(pdata->gpio_switch, "headset_switch");
+                if (ret < 0) {
+                        PRINT_ERR("failed to request GPIO_%d(headset_switch)\n", pdata->gpio_switch);
+                        goto failed_to_request_gpio_switch;
+                }
+        }
+        else
+                PRINT_INFO("automatic type switch is unsupported\n");
+
+        ret = gpio_request(pdata->gpio_detect, "headset_detect");
+        if (ret < 0) {
+                PRINT_ERR("failed to request GPIO_%d(headset_detect)\n", pdata->gpio_detect);
+                goto failed_to_request_gpio_detect;
+        }
+
+        ret = gpio_request(pdata->gpio_button, "headset_button");
+        if (ret < 0) {
+                PRINT_ERR("failed to request GPIO_%d(headset_button)\n", pdata->gpio_button);
+                goto failed_to_request_gpio_button;
+        }
+
+        if(0 != pdata->gpio_switch)
+                gpio_direction_output(pdata->gpio_switch, 0);
+        gpio_direction_input(pdata->gpio_detect);
+        gpio_direction_input(pdata->gpio_button);
+        ht->irq_detect = gpio_to_irq(pdata->gpio_detect);
+        ht->irq_button = gpio_to_irq(pdata->gpio_button);
+
+        ret = switch_dev_register(&ht->sdev);
+        if (ret < 0) {
+                PRINT_ERR("switch_dev_register failed!\n");
+                goto failed_to_register_switch_dev;
+        }
+
+        input_dev = input_allocate_device();
+        if ( !input_dev) {
+                PRINT_ERR("input_allocate_device for headset_button failed!\n");
+                ret = -ENOMEM;
+                goto failed_to_allocate_input_device;
+        }
+
+        input_dev->name = "headset-keyboard";
+        input_dev->id.bustype = BUS_HOST;
+        ht->input_dev = input_dev;
+
+        for (i = 0; i < pdata->nbuttons; i++) {
+                struct headset_buttons *buttons = &pdata->headset_buttons[i];
+                unsigned int type = buttons->type ?: EV_KEY;
+                input_set_capability(input_dev, type, buttons->code);
+        }
+		/* < add by lgd */
+        #ifdef CONFIG_CAMERA_POLE_SUPPORT
+        input_set_capability(input_dev, EV_KEY, CAMERA_POLE_CODE);
+        #endif
+		/* add by lgd > */
+        ret = input_register_device(input_dev);
+        if (ret) {
+                PRINT_ERR("input_register_device for headset_button failed!\n");
+                goto failed_to_register_input_device;
+        }
+
+        sema_init(&headset_sem, 1);
+
+        INIT_WORK(&ht->work_button, headset_button_work_func);
+        ht->button_work_queue = create_singlethread_workqueue("headset_button");
+        if(ht->button_work_queue == NULL) {
+                PRINT_ERR("create_singlethread_workqueue for headset_button failed!\n");
+                goto failed_to_create_singlethread_workqueue_for_headset_button;
+        }
+
+        INIT_DELAYED_WORK(&ht->work_detect, headset_detect_work_func);
+        ht->detect_work_queue = create_singlethread_workqueue("headset_detect");
+        if(ht->detect_work_queue == NULL) {
+                PRINT_ERR("create_singlethread_workqueue for headset_detect failed!\n");
+                goto failed_to_create_singlethread_workqueue_for_headset_detect;
+        }
+
+        /***polling ana_sts0 to avoid the hardware defect***/
+#ifdef SPRD_STS_POLLING_EN
+        INIT_DELAYED_WORK(&sts_check_work, headset_sts_check_func);
+        sts_check_work_queue = create_singlethread_workqueue("headset_sts_check");
+        if(sts_check_work_queue == NULL) {
+                PRINT_ERR("create_singlethread_workqueue for headset_sts_check failed!\n");
+                goto failed_to_create_singlethread_workqueue_for_headset_sts_check;
+        }
+#endif
+        /***polling ana_sts0 to avoid the hardware defect***/
+
+        INIT_DELAYED_WORK(&reg_dump_work, reg_dump_func);
+        reg_dump_work_queue = create_singlethread_workqueue("headset_reg_dump");
+        if(reg_dump_work_queue == NULL) {
+                PRINT_ERR("create_singlethread_workqueue for headset_reg_dump failed!\n");
+                goto failed_to_create_singlethread_workqueue_for_headset_reg_dump;
+        }
+        if (debug_level >= 2)
+                queue_delayed_work(reg_dump_work_queue, &reg_dump_work, msecs_to_jiffies(500));
+		/* < add by lgd */
+#ifdef CONFIG_CAMERA_POLE_SUPPORT
+        INIT_DELAYED_WORK(&camera_pole_work, camera_pole_func);
+        camera_pole_work_queue = create_singlethread_workqueue("camera_pole");
+        if(NULL == camera_pole_work_queue) {
+                PRINT_ERR("create_singlethread_workqueue for camera_pole failed!\n");
+                goto failed_to_create_singlethread_workqueue_for_camera_pole;
+        }
+#endif		
+		/* add by lgd > */
+#ifdef ADPGAR_BYP_SELECT
+        //work queue for Bug#298417
+        INIT_DELAYED_WORK(&adpgar_byp_select_work, adpgar_byp_select_func);
+        adpgar_byp_select_work_queue = create_singlethread_workqueue("adpgar_byp_select");
+        if(adpgar_byp_select_work_queue == NULL) {
+                PRINT_ERR("create_singlethread_workqueue for adpgar_byp_select failed!\n");
+                goto failed_to_create_singlethread_workqueue_for_adpgar_byp_select;
+        }
+        PRINT_INFO("ADPGAR_BYP_SELECT is enabled!\n");
+#endif
+
+        wake_lock_init(&headset_detect_wakelock, WAKE_LOCK_SUSPEND, "headset_detect_wakelock");
+        wake_lock_init(&headset_button_wakelock, WAKE_LOCK_SUSPEND, "headset_button_wakelock");
+
+        //set EIC3 de-bounce time for button irq
+        headset_reg_set_val((ANA_EIC_BASE+EIC3_DBNC_CTRL), DBNC_CNT3_VALUE, DBNC_CNT3_MASK, DBNC_CNT3_SHIFT);
+        //set EIC5 de-bounce time for inser irq
+        headset_reg_set_val((ANA_EIC_BASE+EIC5_DBNC_CTRL), DBNC_CNT5_VALUE, DBNC_CNT5_MASK, DBNC_CNT5_SHIFT);
+
+        irqflags = pdata->irq_trigger_level_button ? IRQF_TRIGGER_HIGH : IRQF_TRIGGER_LOW;
+        ret = request_irq(ht->irq_button, headset_button_irq_handler, irqflags | IRQF_NO_SUSPEND, "headset_button", ht);
+        if (ret) {
+                PRINT_ERR("failed to request IRQ_%d(GPIO_%d)\n", ht->irq_button, pdata->gpio_button);
+                goto failed_to_request_irq_headset_button;
+        }
+        headset_irq_button_enable(0, ht->irq_button);//disable button irq before headset detected
+		headset_button_hardware_bug_fix_stage = 0;
+
+        irqflags = pdata->irq_trigger_level_detect ? IRQF_TRIGGER_HIGH : IRQF_TRIGGER_LOW;
+        ret = request_irq(ht->irq_detect, headset_detect_irq_handler, irqflags | IRQF_NO_SUSPEND, "headset_detect", ht);
+        if (ret < 0) {
+                PRINT_ERR("failed to request IRQ_%d(GPIO_%d)\n", ht->irq_detect, pdata->gpio_detect);
+                goto failed_to_request_irq_headset_detect;
+        }
+
+        ret = headset_debug_sysfs_init();
+
+        PRINT_INFO("headset_detect_probe success\n");
+        return ret;
+
+failed_to_request_irq_headset_detect:
+        free_irq(ht->irq_button, ht);
+failed_to_request_irq_headset_button:
+
+#ifdef ADPGAR_BYP_SELECT
+        cancel_delayed_work_sync(&adpgar_byp_select_work);
+        destroy_workqueue(adpgar_byp_select_work_queue);
+failed_to_create_singlethread_workqueue_for_adpgar_byp_select:
+#endif
+
+/* < add by lgd */
+#ifdef CONFIG_CAMERA_POLE_SUPPORT
+        cancel_delayed_work_sync(&camera_pole_work);
+        destroy_workqueue(camera_pole_work_queue);
+failed_to_create_singlethread_workqueue_for_camera_pole:
+#endif
+/* add by lgd > */
+
+        cancel_delayed_work_sync(&reg_dump_work);
+        destroy_workqueue(reg_dump_work_queue);
+failed_to_create_singlethread_workqueue_for_headset_reg_dump:
+
+#ifdef SPRD_STS_POLLING_EN
+        destroy_workqueue(sts_check_work_queue);
+failed_to_create_singlethread_workqueue_for_headset_sts_check:
+#endif
+
+        destroy_workqueue(ht->detect_work_queue);
+failed_to_create_singlethread_workqueue_for_headset_detect:
+        destroy_workqueue(ht->button_work_queue);
+failed_to_create_singlethread_workqueue_for_headset_button:
+        input_unregister_device(input_dev);
+failed_to_register_input_device:
+        input_free_device(input_dev);
+failed_to_allocate_input_device:
+        switch_dev_unregister(&ht->sdev);
+failed_to_register_switch_dev:
+        gpio_free(pdata->gpio_button);
+failed_to_request_gpio_button:
+        gpio_free(pdata->gpio_detect);
+failed_to_request_gpio_detect:
+        if(0 != pdata->gpio_switch)
+                gpio_free(pdata->gpio_switch);
+failed_to_request_gpio_switch:
+        headmicbias_power_on(&pdev->dev, 0);
+fail_to_sprd_headset_power_init:
+fail_to_get_platform_data:
+        PRINT_ERR("headset_detect_probe failed\n");
+        return ret;
+}
+
+#ifdef CONFIG_PM
+static int headset_suspend(struct platform_device *dev, pm_message_t state)
+{
+        PRINT_INFO("suspend (det_irq = %d, but_irq = %d, plug_state_last = %d)\n",
+			headset.irq_detect, headset.irq_button, plug_state_last);
+        return 0;
+}
+
+static int headset_resume(struct platform_device *dev)
+{
+        PRINT_INFO("resume (det_irq = %d, but_irq = %d, plug_state_last = %d)\n",
+			headset.irq_detect, headset.irq_button, plug_state_last);
+        return 0;
+}
+#else
+#define headset_suspend NULL
+#define headset_resume NULL
+#endif
+
+#ifdef CONFIG_HEADSET_AUXADC_CAL_SUPPORTED
+#define SPRD_HEADSET_AUXADC_CAL_NO         0
+#define SPRD_HEADSET_AUXADC_CAL_NV         1
+#define SPRD_HEADSET_AUXADC_CAL_CHIP       2
+
+struct sprd_headset_auxadc_cal {
+	uint16_t p0_vol;	//900mV
+	uint16_t p0_adc;
+	uint16_t p1_vol;	//300mV
+	uint16_t p1_adc;
+	uint16_t cal_type;
+};
+
+static struct sprd_headset_auxadc_cal adc_cal = {
+        0, 0,
+        0, 0,
+        SPRD_HEADSET_AUXADC_CAL_NO,
+};
+
+static void adc_cal_from_efuse(void);
+extern int sci_efuse_get_cal_v3(unsigned int * pdata, int num);
+
+static int adc_get_ideal(int adc_mic)
+{
+	int32_t A = 0;
+	int32_t B = 0;
+	int32_t temp1 = 0;
+	int32_t temp2 = 0;
+	int32_t temp3 = 0;
+	int32_t adc_ideal = -1;
+	PRINT_INFO("adc_get_ideal headset enter into \n");
+	if (SPRD_HEADSET_AUXADC_CAL_CHIP == adc_cal.cal_type) {
+		A = adc_cal.p1_adc;
+		B = adc_cal.p0_adc;
+
+		temp1 = 18 * adc_mic - 27 * A + 9 * B;
+		temp2 = B - A;
+		temp3 = 109 * temp1;
+		adc_ideal = temp3 / temp2;
+
+		adc_ideal = (adc_ideal <= 0) ? 0 : adc_ideal;
+
+		PRINT_INFO("Calibration data from efuse, adc_mic=%d, adc_ideal=%d\n", adc_mic, adc_ideal);
+	} else {
+		PRINT_ERR("The chip and NV do not calibrate ADC!\n");
+	}
+
+	return adc_ideal;
+}
+
+static void adc_cal_from_efuse(void)
+{
+	int ret;
+	unsigned int efuse_cal_data[2] = {0};
+
+	PRINT_INFO("getting calibration data from efuse ...\n");
+
+	if (adc_cal.cal_type != SPRD_HEADSET_AUXADC_CAL_CHIP) {
+		if (!(sci_efuse_get_cal_v3(efuse_cal_data,2))) {
+			if(((efuse_cal_data[0] >> 16) & 0xffff - (efuse_cal_data[1] >> 16) & 0xffff == 0)) {
+				PRINT_ERR("ADC is equal to two points, So calibrate from efuse error!\n");
+				return;
+			}
+
+			adc_cal.p0_vol = efuse_cal_data[0] & 0xffff;
+			adc_cal.p0_adc = (efuse_cal_data[0] >> 16) & 0xffff;
+			adc_cal.p1_vol = efuse_cal_data[1] & 0xffff;
+			adc_cal.p1_adc = (efuse_cal_data[1] >> 16) & 0xffff;
+
+			adc_cal.cal_type = SPRD_HEADSET_AUXADC_CAL_CHIP;
+
+			PRINT_INFO("efuse_cal_data[0]=0x%08x\n", efuse_cal_data[0]);
+			PRINT_INFO("efuse_cal_data[1]=0x%08x\n", efuse_cal_data[1]);
+
+			PRINT_INFO("========auxadc cal from efuse=========\n");
+			PRINT_INFO("    ADC     VOL\n");
+			PRINT_INFO("p0: %4d    %4d\n", adc_cal.p0_adc, adc_cal.p0_vol);
+			PRINT_INFO("p1: %4d    %4d\n", adc_cal.p1_adc, adc_cal.p1_vol);
+			PRINT_INFO("========auxadc cal from efuse=========\n");
+
+			PRINT_INFO("calibrate from efuse success!\n");
+		} else {
+			PRINT_ERR("calibrate from efuse failed!\n");
+		}
+	} else {
+		PRINT_INFO("no need to calibrate from efuse!\n");
+	}
+}
+
+#endif
+
+static const struct of_device_id headset_detect_of_match[] = {
+	{.compatible = "sprd,headset-detect",},
+	{ }
+};
+static struct platform_driver headset_detect_driver = {
+        .driver = {
+                .name = "headset-detect",
+                .owner = THIS_MODULE,
+                .of_match_table = headset_detect_of_match,
+        },
+        .probe = headset_detect_probe,
+        .suspend = headset_suspend,
+        .resume = headset_resume,
+};
+
+static int __init headset_init(void)
+{
+        int ret;
+#ifdef CONFIG_HEADSET_AUXADC_CAL_SUPPORTED
+        adc_cal_from_efuse();
+#endif
+        ret = platform_driver_register(&headset_detect_driver);
+        return ret;
+}
+
+static void __exit headset_exit(void)
+{
+	sprd_headset_power_deinit();
+        platform_driver_unregister(&headset_detect_driver);
+}
+
+late_initcall(headset_init);
+module_exit(headset_exit);
+
+MODULE_DESCRIPTION("headset & button detect driver");
+MODULE_AUTHOR("Yaochuan Li <yaochuan.li@spreadtrum.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/headset_sprd_sc2723.c b/drivers/input/misc/headset_sprd_sc2723.c
new file mode 100644
index 00000000..3c210d31
--- /dev/null
+++ b/drivers/input/misc/headset_sprd_sc2723.c
@@ -0,0 +1,1920 @@
+/*
+ * Copyright (C) 2013 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/delay.h>
+#include <soc/sprd/gpio.h>
+#include <linux/headset_sprd_sc2723.h>
+#include <soc/sprd/board.h>
+#include <linux/input.h>
+
+#include <soc/sprd/adc.h>
+#include <asm/io.h>
+#include <soc/sprd/hardware.h>
+#include <soc/sprd/adi.h>
+#include <linux/module.h>
+#include <linux/wakelock.h>
+
+#include <linux/regulator/consumer.h>
+#include <soc/sprd/regulator.h>
+#include <soc/sprd/sci_glb_regs.h>
+#include <soc/sprd/arch_misc.h>
+#include <linux/notifier.h>
+#ifdef CONFIG_OF
+#include <linux/slab.h>
+#include <linux/of_device.h>
+#endif
+#include <asm/div64.h>
+#include <linux/sched.h>
+#include <linux/timer.h>
+
+//====================  debug  ====================
+#define ENTER \
+do{ if(debug_level >= 1) printk(KERN_INFO "[SPRD_HEADSET_DBG][%d] func: %s  line: %04d\n", adie_type, __func__, __LINE__); }while(0)
+
+#define PRINT_DBG(format,x...)  \
+do{ if(debug_level >= 1) printk(KERN_INFO "[SPRD_HEADSET_DBG][%d] " format, adie_type, ## x); }while(0)
+
+#define PRINT_INFO(format,x...)  \
+do{ printk(KERN_INFO "[SPRD_HEADSET_INFO][%d] " format, adie_type, ## x); }while(0)
+
+#define PRINT_WARN(format,x...)  \
+do{ printk(KERN_INFO "[SPRD_HEADSET_WARN][%d] " format, adie_type, ## x); }while(0)
+
+#define PRINT_ERR(format,x...)  \
+do{ printk(KERN_ERR "[SPRD_HEADSET_ERR][%d] func: %s  line: %04d  info: " format, adie_type, __func__, __LINE__, ## x); }while(0)
+//====================  debug  ====================
+
+/**********************************************
+ * The micro ADPGAR_BYP_SELECT is used for avoiding the Bug#298417,
+ * please refer to Bug#298417 to confirm your configuration.
+ **********************************************/
+#define ADPGAR_BYP_SELECT
+
+#define PLUG_CONFIRM_COUNT (1)
+#define NO_MIC_RETRY_COUNT (0)
+#define ADC_READ_COUNT (5)
+#define ADC_READ_LOOP (2)
+#define ADC_GND (300)
+#define SCI_ADC_GET_VALUE_COUNT (50)
+
+#define EIC3_DBNC_CTRL (0x4C)
+#define SW_DBNC_VALUE (10)
+#define DBNC_CNT3_VALUE (30)
+#define DBNC_CNT3_SHIFT (0)
+#define DBNC_CNT3_MASK (0xFFF << DBNC_CNT3_SHIFT)
+
+#define EIC5_DBNC_CTRL (0x54)
+#define DBNC_CNT5_VALUE (25)
+#define DBNC_CNT5_SHIFT (0)
+#define DBNC_CNT5_MASK (0xFFF << DBNC_CNT5_SHIFT)
+
+
+#define EIC8_DBNC_CTRL (0x60)
+#define DBNC_CNT8_VALUE (25)
+#define DBNC_CNT8_SHIFT (0)
+#define DBNC_CNT8_MASK (0xFFF << DBNC_CNT8_SHIFT)
+
+#define CLK_AUD_HID_EN (BIT(4))
+#define CLK_AUD_HBD_EN (BIT(3))
+
+#define HEADMIC_DETECT_BASE (ANA_AUDCFGA_INT_BASE)
+#define HEADMIC_DETECT_REG(X) (HEADMIC_DETECT_BASE + (X))
+
+#define HEADMIC_DETECT_GLB_REG(X) (ANA_REGS_GLB_BASE + (X))
+#define HDT_EN (BIT(5))
+#define AUD_EN (BIT(4))
+
+//no use
+#define HEADMIC_BUTTON_BASE (ANA_HDT_INT_BASE)
+#define HEADMIC_BUTTON_REG(X) (HEADMIC_BUTTON_BASE + (X))
+#define HID_CFG0 (0x0080)
+#define HID_CFG2 (0x0088)
+#define HID_CFG3 (0x008C)
+#define HID_CFG4 (0x0090)
+//no use
+
+#define ANA_PMU0 (0x0000)
+#define ANA_CDC1 (0x0020)
+#define ANA_HDT0 (0x0068)
+#define ANA_STS0 (0x0074)
+
+#define AUDIO_HEADMIC_SLEEP_EN (BIT(6))
+
+#define AUDIO_ADPGAR_BYP_SHIFT (10)
+#define AUDIO_ADPGAR_BYP_MASK (0x3 << AUDIO_ADPGAR_BYP_SHIFT)
+#define AUDIO_ADPGAR_BYP_NORMAL (0)
+#define AUDIO_ADPGAR_BYP_ADC_PGAR1_2_ADCR (1)
+#define AUDIO_ADPGAR_BYP_HEADMIC_2_ADCR (2)
+#define AUDIO_ADPGAR_BYP_ALL_DISCONNECTED (3)
+
+#define AUDIO_HEAD_SDET_SHIFT (5)
+#define AUDIO_HEAD_SDET_MASK (0x3 << AUDIO_HEAD_SDET_SHIFT)
+#define AUDIO_HEAD_SDET_2P1 (3)
+#define AUDIO_HEAD_SDET_2P3 (2)
+#define AUDIO_HEAD_SDET_2P5 (1)
+#define AUDIO_HEAD_SDET_2P7 (0)
+
+#define AUDIO_HEAD_INS_VREF_SHIFT (8)
+#define AUDIO_HEAD_INS_VREF_MASK (0x3 << AUDIO_HEAD_INS_VREF_SHIFT)
+#define AUDIO_HEAD_INS_VREF_2P1 (3)
+#define AUDIO_HEAD_INS_VREF_2P3 (2)
+#define AUDIO_HEAD_INS_VREF_2P5 (1)
+#define AUDIO_HEAD_INS_VREF_2P7 (0)
+
+#define AUDIO_HEAD_SBUT_SHIFT (1)
+#define AUDIO_HEAD_SBUT_MASK (0xF << AUDIO_HEAD_SBUT_SHIFT)
+
+#define AUDIO_HEAD_INS_PD (BIT(10))
+#define AUDIO_HEADDETECT_PD (BIT(7))
+
+#define AUDIO_V2ADC_EN (BIT(15))
+#define AUDIO_HEAD2ADC_SEL_SHIFT (11)
+#define AUDIO_HEAD2ADC_SEL_MASK (0xF << AUDIO_HEAD2ADC_SEL_SHIFT)
+#define AUDIO_HEAD2ADC_SEL_DISABLE (0)
+#define AUDIO_HEAD2ADC_SEL_HEADMIC_IN (1)
+#define AUDIO_HEAD2ADC_SEL_HEADSET_L_INT (3)
+#define AUDIO_HEAD2ADC_SEL_HEAD_DRO_L (4)
+
+#define AUDIO_HEAD_BUTTON (BIT(11))
+#define AUDIO_HEAD_INSERT (BIT(10))
+#define AUDIO_HEAD_INSERT_2 (BIT(9))
+
+#define AUDIO_PMUR1 (BIT(0))
+#define ANA_PMU1 (0x0004)
+
+#define ABS(x) (((x) < (0)) ? (-(x)) : (x))
+#define MAX(x,y) (((x) > (y)) ? (x) : (y))
+
+#define headset_reg_read(addr)	\
+    do {	\
+	sci_adi_read(addr);	\
+} while(0)
+
+#define headset_reg_set_val(addr, val, mask, shift)  \
+    do {    \
+        uint32_t temp;    \
+        temp = sci_adi_read(addr);  \
+        temp = (temp & (~mask)) | ((val) << (shift));   \
+        sci_adi_raw_write(addr, temp);    \
+    } while(0)
+
+#define headset_reg_clr_bit(addr, bit)   \
+    do {    \
+        uint32_t temp;    \
+        temp = sci_adi_read(addr);  \
+        temp = temp & (~bit);   \
+        sci_adi_raw_write(addr, temp);  \
+    } while(0)
+
+#define headset_reg_set_bit(addr, bit)   \
+    do {    \
+        uint32_t temp;    \
+        temp = sci_adi_read(addr);  \
+        temp = temp | bit;  \
+        sci_adi_raw_write(addr, temp);  \
+    } while(0)
+
+static inline uint32_t headset_reg_get_bit(uint32_t addr, uint32_t bit)
+{
+        uint32_t temp;
+        temp = sci_adi_read(addr);
+        temp = temp & bit;
+        return temp;
+}
+
+typedef enum sprd_headset_type {
+        HEADSET_4POLE_NORMAL,
+        HEADSET_NO_MIC,
+        HEADSET_4POLE_NOT_NORMAL,
+        HEADSET_APPLE,
+        HEADSET_TYPE_ERR = -1,
+} SPRD_HEADSET_TYPE;
+
+static struct delayed_work reg_dump_work;
+static struct workqueue_struct *reg_dump_work_queue;
+
+#ifdef ADPGAR_BYP_SELECT
+static struct delayed_work adpgar_byp_select_work;
+static struct workqueue_struct *adpgar_byp_select_work_queue;
+#endif
+
+struct sprd_headset_auxadc_cal_l {
+	u32 A;
+	u32 B;
+	u32 E;
+	u32 cal_type;
+};
+
+#define SPRD_HEADSET_AUXADC_CAL_NO 0
+#define SPRD_HEADSET_AUXADC_CAL_DO 1
+
+static struct sprd_headset_auxadc_cal_l adc_cal_headset = {
+        0, 0,0,SPRD_HEADSET_AUXADC_CAL_NO,
+};
+
+
+
+static DEFINE_SPINLOCK(irq_button_lock);
+static DEFINE_SPINLOCK(irq_detect_lock);
+static DEFINE_SPINLOCK(irq_detect_mic_lock);
+
+static int detect_err_count = 0;
+static int debug_level = 0;
+static int adie_type = -1;
+static int gpio_detect_value_last = 0;
+static int gpio_button_value_last = 0;
+static volatile int button_state_last = 0; //0==released, 1==pressed
+static int current_key_code = KEY_RESERVED;
+static int plug_state_last = 0; //if the hardware detected the headset is plug in, set plug_state_last = 1
+static struct wake_lock headset_detect_wakelock;
+static struct wake_lock headset_button_wakelock;
+static struct semaphore headset_sem;
+static struct platform_device *this_pdev = NULL;
+static struct sprd_headset headset = {
+        .sdev = {
+                .name = "h2w",
+        },
+};
+
+//========================  audio codec  ========================
+static struct sprd_headset_power {
+        struct regulator *head_mic;
+        struct regulator *vcom_buf;
+        struct regulator *vbo;
+} sprd_hts_power;
+
+static int sprd_headset_power_get(struct device *dev,
+                                  struct regulator **regu, const char *id)
+{
+        if (!*regu) {
+                *regu = regulator_get(dev, id);
+                if (IS_ERR(*regu)) {
+                        pr_err("ERR:Failed to request %ld: %s\n", PTR_ERR(*regu), id);
+                        *regu = 0;
+                        return PTR_ERR(*regu);
+                }
+        }
+        return 0;
+}
+
+static int sprd_headset_power_init(struct device *dev)
+{
+        int ret = 0;
+        ret = sprd_headset_power_get(dev, &sprd_hts_power.head_mic, "HEADMICBIAS");
+        if (ret || (sprd_hts_power.head_mic == NULL)) {
+                sprd_hts_power.head_mic = 0;
+                return ret;
+        }
+        regulator_set_voltage(sprd_hts_power.head_mic, 950000, 950000);
+
+        ret = sprd_headset_power_get(dev, &sprd_hts_power.vcom_buf, "VCOM_BUF");
+        if (ret) {
+                sprd_hts_power.vcom_buf = 0;
+                goto __err1;
+        }
+
+        ret = sprd_headset_power_get(dev, &sprd_hts_power.vbo, "VBO");
+        if (ret) {
+                sprd_hts_power.vbo = 0;
+                goto __err2;
+        }
+
+        goto __ok;
+__err2:
+        regulator_put(sprd_hts_power.vcom_buf);
+__err1:
+        regulator_put(sprd_hts_power.head_mic);
+__ok:
+        return ret;
+}
+
+static void sprd_headset_power_deinit(void)
+{
+        regulator_put(sprd_hts_power.head_mic);
+        regulator_put(sprd_hts_power.vcom_buf);
+        regulator_put(sprd_hts_power.vbo);
+}
+
+static int sprd_headset_audio_block_is_running(struct device *dev)
+{
+        return regulator_is_enabled(sprd_hts_power.vcom_buf)
+               || regulator_is_enabled(sprd_hts_power.vbo);
+}
+
+static int sprd_headset_audio_headmic_sleep_disable(struct device *dev, int on)
+{
+        int ret = 0;
+        if (!sprd_hts_power.head_mic) {
+                return -1;
+        }
+
+        if (on) {
+                ret = regulator_enable(sprd_hts_power.vbo);
+                ret = regulator_set_mode(sprd_hts_power.head_mic, REGULATOR_MODE_NORMAL);
+        } else {
+                ret = regulator_disable(sprd_hts_power.vbo);
+                if (sprd_headset_audio_block_is_running(dev)) {
+                        ret = regulator_set_mode(sprd_hts_power.head_mic, REGULATOR_MODE_NORMAL);
+                } else {
+                        ret = regulator_set_mode(sprd_hts_power.head_mic, REGULATOR_MODE_STANDBY);
+                }
+        }
+        return ret;
+}
+
+static int sprd_headset_headmic_bias_control(struct device *dev, int on)
+{
+        int ret = 0;
+        if (!sprd_hts_power.head_mic) {
+                return -1;
+        }
+        if (on) {
+                ret = regulator_enable(sprd_hts_power.head_mic);
+        } else {
+                ret = regulator_disable(sprd_hts_power.head_mic);
+        }
+        if (!ret) {
+                /* Set HEADMIC_SLEEP when audio block closed */
+                if (sprd_headset_audio_block_is_running(dev)) {
+                        ret = regulator_set_mode(sprd_hts_power.head_mic, REGULATOR_MODE_NORMAL);
+                } else {
+                        ret = regulator_set_mode(sprd_hts_power.head_mic, REGULATOR_MODE_STANDBY);
+                }
+        }
+        return ret;
+}
+
+static BLOCKING_NOTIFIER_HEAD(hp_chain_list);
+int hp_register_notifier(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_register(&hp_chain_list, nb);
+}
+EXPORT_SYMBOL(hp_register_notifier);
+
+int hp_unregister_notifier(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_unregister(&hp_chain_list, nb);
+}
+EXPORT_SYMBOL(hp_unregister_notifier);
+
+#if 0
+static int hp_notifier_call_chain(unsigned long val)
+{
+        return (blocking_notifier_call_chain(&hp_chain_list, val, NULL)
+                == NOTIFY_BAD) ? -EINVAL : 0;
+}
+#endif
+
+int get_hp_plug_state(void)
+{
+        return !!plug_state_last;
+}
+EXPORT_SYMBOL(get_hp_plug_state);
+//========================  audio codec  ========================
+
+static int wrap_sci_adc_get_value(unsigned int channel, int scale)
+{
+        int count = 0;
+        int average = 0;
+
+        while(count < SCI_ADC_GET_VALUE_COUNT) {
+                average += sci_adc_get_value(channel, scale);
+                count++;
+        }
+        average /= SCI_ADC_GET_VALUE_COUNT;
+
+        return average;
+}
+
+/*  on = 0: open headmic detect circuit */
+static void headset_detect_circuit(unsigned on)
+{
+        if (on) {
+                headset_reg_clr_bit(HEADMIC_DETECT_REG(ANA_HDT0), AUDIO_HEAD_INS_PD);
+                headset_reg_clr_bit(HEADMIC_DETECT_REG(ANA_HDT0), AUDIO_HEADDETECT_PD);
+        } else {
+                headset_reg_set_bit(HEADMIC_DETECT_REG(ANA_HDT0), AUDIO_HEAD_INS_PD);
+                headset_reg_set_bit(HEADMIC_DETECT_REG(ANA_HDT0), AUDIO_HEADDETECT_PD);
+        }
+}
+
+static void headset_detect_clk_en(void)
+{
+        //address:0x4003_8800+0x00
+        headset_reg_set_bit(HEADMIC_DETECT_GLB_REG(0x00), (HDT_EN | AUD_EN));
+        //address:0x4003_8800+0x04
+        headset_reg_set_bit(HEADMIC_DETECT_GLB_REG(0x04), (CLK_AUD_HID_EN | CLK_AUD_HBD_EN));
+}
+
+static void headset_detect_init(void)
+{
+        headset_detect_clk_en();
+        /* set headset detect voltage */
+        headset_reg_set_bit(HEADMIC_DETECT_REG(ANA_PMU1), AUDIO_PMUR1);
+        headset_reg_set_val(HEADMIC_DETECT_REG(ANA_HDT0), AUDIO_HEAD_SDET_2P5, AUDIO_HEAD_SDET_MASK, AUDIO_HEAD_SDET_SHIFT);
+        headset_reg_set_val(HEADMIC_DETECT_REG(ANA_HDT0), AUDIO_HEAD_INS_VREF_2P1, AUDIO_HEAD_INS_VREF_MASK, AUDIO_HEAD_INS_VREF_SHIFT);
+}
+
+static void headmic_sleep_disable(struct device *dev, int on);
+
+static void headset_adc_en(int en)
+{
+        if (en) {
+                headset_reg_set_bit(HEADMIC_DETECT_REG(ANA_HDT0), AUDIO_V2ADC_EN);
+                headset_reg_set_val(HEADMIC_DETECT_REG(ANA_HDT0), AUDIO_HEAD2ADC_SEL_HEADMIC_IN, AUDIO_HEAD2ADC_SEL_MASK, AUDIO_HEAD2ADC_SEL_SHIFT);
+                headmic_sleep_disable(&this_pdev->dev, 1);
+        } else {
+                if(debug_level <= 2) {
+                        headset_reg_clr_bit(HEADMIC_DETECT_REG(ANA_HDT0), AUDIO_V2ADC_EN);
+                        headset_reg_set_val(HEADMIC_DETECT_REG(ANA_HDT0), AUDIO_HEAD2ADC_SEL_DISABLE, AUDIO_HEAD2ADC_SEL_MASK, AUDIO_HEAD2ADC_SEL_SHIFT);
+                }
+                headmic_sleep_disable(&this_pdev->dev, 0);
+        }
+}
+
+/* is_set = 1, headset_mic to AUXADC */
+static void set_adc_to_headmic(unsigned is_set)
+{
+        headset_adc_en(1);
+
+        if (is_set) {
+                headset_reg_set_val(HEADMIC_DETECT_REG(ANA_HDT0), AUDIO_HEAD2ADC_SEL_HEADMIC_IN, AUDIO_HEAD2ADC_SEL_MASK, AUDIO_HEAD2ADC_SEL_SHIFT);
+        } else {
+                headset_reg_set_val(HEADMIC_DETECT_REG(ANA_HDT0), AUDIO_HEAD2ADC_SEL_HEADSET_L_INT, AUDIO_HEAD2ADC_SEL_MASK, AUDIO_HEAD2ADC_SEL_SHIFT);
+        }
+}
+
+static void headset_button_irq_threshold(int enable)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+        int audio_head_sbut = 0;
+
+        audio_head_sbut = pdata->irq_threshold_buttont;
+
+        if (enable)
+                headset_reg_set_val(HEADMIC_DETECT_REG(ANA_HDT0), audio_head_sbut, AUDIO_HEAD_SBUT_MASK, AUDIO_HEAD_SBUT_SHIFT);
+        else
+                headset_reg_set_val(HEADMIC_DETECT_REG(ANA_HDT0), 0xF, AUDIO_HEAD_SBUT_MASK, AUDIO_HEAD_SBUT_SHIFT);
+}
+
+static void headset_irq_button_enable(int enable, unsigned int irq)
+{
+        unsigned long spin_lock_flags;
+        static int current_irq_state = 1;//irq is enabled after request_irq()
+        spin_lock_irqsave(&irq_button_lock, spin_lock_flags);
+        if (1 == enable) {
+                if (0 == current_irq_state) {
+                        enable_irq(irq);
+                        current_irq_state = 1;
+                }
+        } else {
+                if (1 == current_irq_state) {
+                        disable_irq_nosync(irq);
+                        current_irq_state = 0;
+                }
+        }
+        spin_unlock_irqrestore(&irq_button_lock, spin_lock_flags);
+        return;
+}
+
+static void headset_irq_detect_enable(int enable, unsigned int irq)
+{
+        unsigned long spin_lock_flags;
+        static int current_irq_state = 1;//irq is enabled after request_irq()
+        spin_lock_irqsave(&irq_detect_lock, spin_lock_flags);
+        if (1 == enable) {
+                if (0 == current_irq_state) {
+                        enable_irq(irq);
+                        current_irq_state = 1;
+                }
+        } else {
+                if (1 == current_irq_state) {
+                        disable_irq_nosync(irq);
+                        current_irq_state = 0;
+                }
+        }
+        spin_unlock_irqrestore(&irq_detect_lock, spin_lock_flags);
+        return;
+}
+
+static void headset_irq_detect_mic_enable(int enable, unsigned int irq)
+{
+	unsigned long spin_lock_flags;
+	static int current_irq_state = 1;
+	spin_lock_irqsave(&irq_detect_mic_lock, spin_lock_flags);
+	if (1 == enable) {
+		if (0 == current_irq_state) {
+			enable_irq(irq);
+			current_irq_state = 1;
+		}
+	} else {
+		if (1 == current_irq_state) {
+			disable_irq_nosync(irq);
+			current_irq_state = 0;
+		}
+	}
+	spin_unlock_irqrestore(&irq_detect_mic_lock, spin_lock_flags);
+	return;
+}
+
+static void headmic_sleep_disable(struct device *dev, int on)
+{
+        static int current_power_state = 0;
+
+        if (1 == on) {
+                if (0 == current_power_state) {
+                        sprd_headset_audio_headmic_sleep_disable(dev, 1);
+                        current_power_state = 1;
+                }
+        } else {
+                if (1 == current_power_state) {
+                        sprd_headset_audio_headmic_sleep_disable(dev, 0);
+                        current_power_state = 0;
+                }
+        }
+
+        return;
+}
+
+static void headmicbias_power_on(struct device *dev, int on)
+{
+        static int current_power_state = 0;
+        struct sprd_headset *ht = &headset;
+
+        if (1 == on) {
+                if (0 == current_power_state) {
+                        if(NULL != ht->platform_data->external_headmicbias_power_on)
+                                ht->platform_data->external_headmicbias_power_on(1);
+                        sprd_headset_headmic_bias_control(dev, 1);
+                        current_power_state = 1;
+                }
+        } else {
+                if (1 == current_power_state) {
+                        if(NULL != ht->platform_data->external_headmicbias_power_on)
+                                ht->platform_data->external_headmicbias_power_on(0);
+                        sprd_headset_headmic_bias_control(dev, 0);
+                        current_power_state = 0;
+                }
+        }
+
+        return;
+}
+
+static int ana_sts0_confirm(void)
+{
+	if (0 == headset_reg_get_bit(HEADMIC_DETECT_REG(ANA_STS0), AUDIO_HEAD_INSERT))
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+		return 0;
+#else
+		return 1;
+#endif
+	else
+		return 1;
+}
+
+static int adc_compare(int x1, int x2)
+{
+        int delta = 0;
+        int max = 0;
+
+        if((x1<300) && (x2<300))
+                return 1;
+
+        x1 = ((0==x1) ? 1 : (x1*100));
+        x2 = ((0==x2) ? 1 : (x2*100));
+
+        delta = ABS(x1-x2);
+        max = MAX(x1, x2);
+
+        if(delta < ((max*10)/100))
+                return 1;
+        else
+                return 0;
+}
+
+static int adc_get_average(int gpio_num, int gpio_value)
+{
+        int i = 0;
+        int j = 0;
+        int k = 0;
+        int adc_average = 0;
+        int success = 1;
+        int adc[ADC_READ_COUNT] = {0};
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+
+        //================= debug =====================
+        if(debug_level >= 3) {
+                int count = 0;
+                int adc_val = 0;
+                int gpio_button = 0;
+                int ana_pmu0 = 0;
+                int ana_cfg1 = 0;
+                int ana_hdt0 = 0;
+                int ana_sts0 = 0;
+
+                while(count < 20) {
+                        count++;
+                        adc_val = wrap_sci_adc_get_value(ADC_CHANNEL_HEADMIC, 0);
+                        gpio_button = gpio_get_value(pdata->gpio_button);
+                        ana_pmu0 = sci_adi_read(HEADMIC_DETECT_REG(ANA_PMU0));
+                        ana_hdt0 = sci_adi_read(HEADMIC_DETECT_REG(ANA_HDT0));
+                        ana_sts0 = sci_adi_read(HEADMIC_DETECT_REG(ANA_STS0));
+
+                        PRINT_INFO("%2d:  gpio_button=%d  adc=%4d  ana_pmu0=0x%08X  ana_cfg1=0x%08X  ana_hdt0=0x%08X  ana_sts0=0x%08X\n",
+                                   count, gpio_button, adc_val, ana_pmu0, ana_cfg1, ana_hdt0, ana_sts0);
+                        msleep(1);
+                }
+        }
+        //================= debug =====================
+
+        msleep(1);
+        if(0 == headset_reg_get_bit(HEADMIC_DETECT_REG(ANA_PMU0), AUDIO_HEADMIC_SLEEP_EN))
+                PRINT_INFO("AUDIO_HEADMIC_SLEEP_EN is disabled\n");
+
+        for(i=0; i< ADC_READ_LOOP; i++) {
+                if(gpio_get_value(gpio_num) != gpio_value) {
+                        PRINT_INFO("gpio value changed!!! the adc read operation aborted (step1)\n");
+                        return -1;
+                }
+                if(0 == ana_sts0_confirm()) {
+                        PRINT_INFO("ana_sts0_confirm failed!!! the adc read operation aborted (step2)\n");
+                        return -1;
+                }
+                adc[0] = wrap_sci_adc_get_value(ADC_CHANNEL_HEADMIC, 0);
+
+                for(j=0; j<ADC_READ_COUNT-1; j++) {
+                        udelay(100);
+                        if(gpio_get_value(gpio_num) != gpio_value) {
+                                PRINT_INFO("gpio value changed!!! the adc read operation aborted (step3)\n");
+                                return -1;
+                        }
+                        if(0 == ana_sts0_confirm()) {
+                                PRINT_INFO("ana_sts0_confirm failed!!! the adc read operation aborted (step4)\n");
+                                return -1;
+                        }
+                        adc[j+1] = wrap_sci_adc_get_value(ADC_CHANNEL_HEADMIC, 0);
+
+                        if(0 == adc_compare(adc[j], adc[j+1])) {
+                                success = 0;
+                                for(k=0; k<=j+1; k++) {
+                                        PRINT_DBG("adc[%d] = %d\n", k, adc[k]);
+                                }
+                                break;
+                        }
+                }
+                if(1 == success) {
+                        msleep(3);
+                        if(gpio_get_value(gpio_num) != gpio_value) {
+                                PRINT_INFO("gpio value changed!!! the adc read operation aborted (step5)\n");
+                                return -1;
+                        }
+                        if(0 == ana_sts0_confirm()) {
+                                PRINT_INFO("ana_sts0_confirm failed!!! the adc read operation aborted (step6)\n");
+                                return -1;
+                        }
+                        for(i=0; i<ADC_READ_COUNT; i++) {
+                                adc_average += adc[i];
+                                PRINT_DBG("adc[%d] = %d\n", i, adc[i]);
+                        }
+                        adc_average = adc_average / ADC_READ_COUNT;
+                        PRINT_DBG("adc_get_average success, adc_average = %d\n", adc_average);
+                        return adc_average;
+                } else if(i+1< ADC_READ_LOOP) {
+                        PRINT_INFO("adc_get_average failed, retrying count = %d\n", i+1);
+                        msleep(1);
+                }
+        }
+        PRINT_INFO("adc_get_average out \n");
+        return -1;
+}
+
+static int headset_irq_set_irq_type(unsigned int irq, unsigned int type)
+{
+        struct sprd_headset *ht = &headset;
+        struct irq_desc *irq_desc = NULL;
+        unsigned int irq_flags = 0;
+        int ret = -1;
+
+        ret = irq_set_irq_type(irq, type);
+        irq_desc = irq_to_desc(irq);
+        irq_flags = irq_desc->action->flags;
+
+        if(irq == ht->irq_button) {
+                if(IRQF_TRIGGER_HIGH == type) {
+                        PRINT_DBG("IRQF_TRIGGER_HIGH is set for irq_button(%d). irq_flags = 0x%08X, ret = %d\n",
+                                  ht->irq_button, irq_flags, ret);
+                } else if(IRQF_TRIGGER_LOW == type) {
+                        PRINT_DBG("IRQF_TRIGGER_LOW is set for irq_button(%d). irq_flags = 0x%08X, ret = %d\n",
+                                  ht->irq_button, irq_flags, ret);
+                }
+        } else if(irq == ht->irq_detect) {
+                if(IRQF_TRIGGER_HIGH == type) {
+                        PRINT_DBG("IRQF_TRIGGER_HIGH is set for irq_detect(%d). irq_flags = 0x%08X, ret = %d\n",
+                                  ht->irq_detect, irq_flags, ret);
+                } else if(IRQF_TRIGGER_LOW == type) {
+                        PRINT_DBG("IRQF_TRIGGER_LOW is set for irq_detect(%d). irq_flags = 0x%08X, ret = %d\n",
+                                  ht->irq_detect, irq_flags, ret);
+                }
+        }
+        return 0;
+}
+
+static int headset_button_valid(int gpio_detect_value_current)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+        int button_is_valid = 0;
+
+        if(1 == pdata->irq_trigger_level_detect) {
+                if(1 == gpio_detect_value_current)
+                        button_is_valid = 1;
+                else
+                        button_is_valid = 0;
+        } else {
+                if(0 == gpio_detect_value_current)
+                        button_is_valid = 1;
+                else
+                        button_is_valid = 0;
+        }
+
+        return button_is_valid;
+}
+
+static int headset_gpio_2_button_state(int gpio_button_value_current)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+        int button_state_current = 0;
+
+        if(1 == pdata->irq_trigger_level_button) {
+                if(1 == gpio_button_value_current)
+                        button_state_current = 1;
+                else
+                        button_state_current = 0;
+        } else {
+                if(0 == gpio_button_value_current)
+                        button_state_current = 1;
+                else
+                        button_state_current = 0;
+        }
+
+        return button_state_current; //0==released, 1==pressed
+}
+
+static int headset_plug_confirm_by_adc(int last_gpio_detect_value)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+        int adc_last = 0;
+        int adc_current = 0;
+        int count = 0;
+        int adc_read_interval = 10;
+
+        adc_last = adc_get_average(pdata->gpio_detect, last_gpio_detect_value);
+        if(-1 == adc_last) {
+                PRINT_INFO("headset_plug_confirm_by_adc failed!!!\n");
+                return -1;
+        }
+
+        while(count < PLUG_CONFIRM_COUNT) {
+                msleep(adc_read_interval);
+                adc_current = adc_get_average(pdata->gpio_detect, last_gpio_detect_value);
+                if(-1 == adc_current) {
+                        PRINT_INFO("headset_plug_confirm_by_adc failed!!!\n");
+                        return -1;
+                }
+                if(0 == adc_compare(adc_last, adc_current)) {
+                        PRINT_INFO("headset_plug_confirm_by_adc failed!!!\n");
+                        return -1;
+                }
+                adc_last = adc_current;
+                count++;
+        }
+        PRINT_INFO("headset_plug_confirm_by_adc success!!!\n");
+        return adc_current;
+}
+static int adc_get_ideal(u32 adc_mic);
+
+static SPRD_HEADSET_TYPE headset_type_detect(int last_gpio_detect_value)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+        int adc_mic_average = 0;
+        int adc_left_average = 0;
+        int adc_mic_ideal = 0;
+        int no_mic_retry_count = NO_MIC_RETRY_COUNT;
+
+        ENTER;
+
+        if(0 != pdata->gpio_switch)
+                gpio_direction_output(pdata->gpio_switch, 0);
+        else
+                PRINT_INFO("automatic type switch is unsupported\n");
+
+        headset_button_irq_threshold(1);
+        headset_detect_init();
+        headset_detect_circuit(1);
+
+no_mic_retry:
+
+        //get adc value of left
+        if(EIC_AUD_HEAD_INST2 == pdata->gpio_detect) {
+                PRINT_INFO("HEADSET_DETECT_GPIO=%d, matched the reference phone, now getting adc value of left\n", pdata->gpio_detect);
+                set_adc_to_headmic(0);
+                msleep(100);
+                adc_left_average = headset_plug_confirm_by_adc(last_gpio_detect_value);
+                if(-1 == adc_left_average)
+                        return HEADSET_TYPE_ERR;
+        } else {
+                PRINT_INFO("HEADSET_DETECT_GPIO=%d, NOT matched the reference phone(GPIO_%d), set adc_left_average to 0\n",
+                           pdata->gpio_detect, EIC_AUD_HEAD_INST2);
+                adc_left_average = 0;
+        }
+
+        //get adc value of mic
+        set_adc_to_headmic(1);
+        msleep(50);
+        adc_mic_average = headset_plug_confirm_by_adc(last_gpio_detect_value);
+        if(-1 == adc_mic_average)
+                return HEADSET_TYPE_ERR;
+        adc_mic_ideal = adc_get_ideal(adc_mic_average);
+        PRINT_INFO("adc_mic_average=%d, adc_mic_ideal=%d\n", adc_mic_average, adc_mic_ideal);
+        if(adc_mic_ideal >= 0) {
+            adc_mic_average = adc_mic_ideal;
+        }
+        PRINT_INFO("adc_mic_average = %d\n", adc_mic_average);
+        PRINT_INFO("adc_left_average = %d\n", adc_left_average);
+
+        if((gpio_get_value(pdata->gpio_detect)) != last_gpio_detect_value) {
+                PRINT_INFO("software debance (gpio check)!!!(headset_type_detect)\n");
+                return HEADSET_TYPE_ERR;
+        }
+
+        if(0 == ana_sts0_confirm()) {
+                PRINT_INFO("software debance (ana_sts0_confirm)!!!(headset_type_detect)\n");
+                return HEADSET_TYPE_ERR;
+        }
+
+        if((adc_mic_average < pdata->adc_threshold_3pole_detect)) {
+                if(0 != no_mic_retry_count) {
+                        PRINT_INFO("no_mic_retry\n");
+                        no_mic_retry_count--;
+                        goto no_mic_retry;
+                }
+                return HEADSET_NO_MIC;
+        } else if((adc_left_average < ADC_GND) && (adc_mic_average > ADC_GND))
+                return HEADSET_4POLE_NORMAL;
+        else if((adc_left_average > ADC_GND) && (adc_mic_average > ADC_GND)
+                && (ABS(adc_mic_average - adc_left_average) < ADC_GND))
+                return HEADSET_4POLE_NOT_NORMAL;
+        else
+                return HEADSET_TYPE_ERR;
+
+        return HEADSET_TYPE_ERR;
+}
+
+static void button_release_verify(void)
+{
+        struct sprd_headset *ht = &headset;
+
+        if(1 == button_state_last) {
+                input_event(ht->input_dev, EV_KEY, current_key_code, 0);
+                input_sync(ht->input_dev);
+                button_state_last = 0;
+                PRINT_INFO("headset button released by force!!! current_key_code = %d(0x%04X)\n", current_key_code, current_key_code);
+
+                if (1 == ht->platform_data->irq_trigger_level_button)
+                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_HIGH);
+                else
+                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_LOW);
+        }
+}
+
+static void headset_button_work_func(struct work_struct *work)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+        int gpio_button_value_current = 0;
+        int button_state_current = 0;
+        int adc_mic_average = 0;
+        int i = 0;
+        int adc_ideal = 0;
+
+        down(&headset_sem);
+        set_adc_to_headmic(1);
+
+        ENTER;
+
+        gpio_button_value_current = gpio_get_value(pdata->gpio_button);
+        if(gpio_button_value_current != gpio_button_value_last) {
+                PRINT_INFO("software debance (step 1: gpio check)!!!(headset_button_work_func)\n");
+#ifdef ADPGAR_BYP_SELECT
+                queue_delayed_work(adpgar_byp_select_work_queue, &adpgar_byp_select_work, msecs_to_jiffies(0));
+#endif
+                goto out;
+        }
+
+        button_state_current = headset_gpio_2_button_state(gpio_button_value_current);
+
+        if(1 == button_state_current) {//pressed!
+                if(ht->platform_data->nbuttons > 0) {
+                        adc_mic_average = adc_get_average(pdata->gpio_button, gpio_button_value_last);
+                        if(-1 == adc_mic_average) {
+                                PRINT_INFO("software debance (step 3: adc check)!!!(headset_button_work_func)(pressed)\n");
+#ifdef ADPGAR_BYP_SELECT
+                                queue_delayed_work(adpgar_byp_select_work_queue, &adpgar_byp_select_work, msecs_to_jiffies(0));
+#endif
+                                goto out;
+                        }
+                        adc_ideal = adc_get_ideal(adc_mic_average);
+                        PRINT_INFO("adc_mic_average=%d, adc_ideal=%d\n", adc_mic_average, adc_ideal);
+                        if (adc_ideal >= 0)
+                            adc_mic_average = adc_ideal;
+                        PRINT_INFO("adc_mic_average = %d\n", adc_mic_average);
+                        for (i = 0; i < ht->platform_data->nbuttons; i++) {
+                                if (adc_mic_average >= ht->platform_data->headset_buttons[i].adc_min &&
+                                    adc_mic_average < ht->platform_data->headset_buttons[i].adc_max) {
+                                        current_key_code = ht->platform_data->headset_buttons[i].code;
+                                        break;
+                                }
+                                current_key_code = KEY_RESERVED;
+                        }
+                }
+
+                if(0 == button_state_last) {
+                        input_event(ht->input_dev, EV_KEY, current_key_code, 1);
+                        input_sync(ht->input_dev);
+                        button_state_last = 1;
+                        PRINT_INFO("headset button pressed! current_key_code = %d(0x%04X)\n", current_key_code, current_key_code);
+                } else {
+                        PRINT_ERR("headset button pressed already! current_key_code = %d(0x%04X)\n", current_key_code, current_key_code);
+#ifdef ADPGAR_BYP_SELECT
+                        queue_delayed_work(adpgar_byp_select_work_queue, &adpgar_byp_select_work, msecs_to_jiffies(0));
+#endif
+                }
+
+                if (1 == ht->platform_data->irq_trigger_level_button)
+                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_LOW);
+                else
+                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_HIGH);
+
+                headset_irq_button_enable(1, ht->irq_button);
+        } else { //released!
+                if(1 == button_state_last) {
+                        input_event(ht->input_dev, EV_KEY, current_key_code, 0);
+                        input_sync(ht->input_dev);
+                        button_state_last = 0;
+                        PRINT_INFO("headset button released! current_key_code = %d(0x%04X)\n", current_key_code, current_key_code);
+                } else
+                        PRINT_ERR("headset button released already! current_key_code = %d(0x%04X)\n", current_key_code, current_key_code);
+
+                if (1 == ht->platform_data->irq_trigger_level_button)
+                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_HIGH);
+                else
+                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_LOW);
+
+                headset_irq_button_enable(1, ht->irq_button);
+        }
+out:
+        headset_adc_en(0);
+        headset_irq_button_enable(1, ht->irq_button);
+        //wake_unlock(&headset_button_wakelock);
+        up(&headset_sem);
+        return;
+}
+
+static void headset_detect_work_func(struct work_struct *work)
+{
+        struct sprd_headset *ht = &headset;
+        struct sprd_headset_platform_data *pdata = ht->platform_data;
+        SPRD_HEADSET_TYPE headset_type;
+        int plug_state_current = 0;
+        int gpio_detect_value_current = 0;
+        down(&headset_sem);
+
+        ENTER;
+        if (sprd_hts_power.head_mic == NULL) {
+            sprd_headset_power_init(&this_pdev->dev);
+        }
+        if (sprd_hts_power.head_mic == NULL ) {
+            PRINT_INFO("sprd_headset_power_init fail 0 \n");
+            goto out;
+        }
+
+        if(0 == plug_state_last) {
+            //schedule_timeout_uninterruptible(msecs_to_jiffies(10));
+            headmicbias_power_on(&this_pdev->dev, 1);
+        }
+
+        if(0 == plug_state_last) {
+                gpio_detect_value_current = gpio_get_value(pdata->gpio_detect);
+                PRINT_INFO("gpio_detect_value_current = %d, gpio_detect_value_last = %d, plug_state_last = %d\n",
+                           gpio_detect_value_current, gpio_detect_value_last, plug_state_last);
+
+                if(gpio_detect_value_current != gpio_detect_value_last) {
+                        PRINT_INFO("software debance (step 1)!!!(headset_detect_work_func)\n");
+                        goto out;
+                }
+
+                if(1 == pdata->irq_trigger_level_detect) {
+                        if(1 == gpio_detect_value_current)
+                                plug_state_current = 1;
+                        else
+                                plug_state_current = 0;
+                } else {
+                        if(0 == gpio_detect_value_current)
+                                plug_state_current = 1;
+                        else
+                                plug_state_current = 0;
+                }
+        } else
+                plug_state_current = 0;//no debounce for plug out!!!
+
+        if(1 == plug_state_current && 0 == plug_state_last) {
+                headset_type = headset_type_detect(gpio_detect_value_last);
+                headset_adc_en(0);
+                switch (headset_type) {
+                case HEADSET_TYPE_ERR:
+                        detect_err_count ++;
+                        PRINT_INFO("headset_type = %d detect_err_count = %d(HEADSET_TYPE_ERR)\n", headset_type,detect_err_count);
+                        goto out;
+                case HEADSET_4POLE_NOT_NORMAL:
+                        PRINT_INFO("headset_type = %d (HEADSET_4POLE_NOT_NORMAL)\n", headset_type);
+                        if(0 != pdata->gpio_switch)
+                                gpio_direction_output(pdata->gpio_switch, 1);
+                        break;
+                case HEADSET_4POLE_NORMAL:
+                        PRINT_INFO("headset_type = %d (HEADSET_4POLE_NORMAL)\n", headset_type);
+                        if(0 != pdata->gpio_switch)
+                                gpio_direction_output(pdata->gpio_switch, 0);
+                        break;
+                case HEADSET_NO_MIC:
+                        PRINT_INFO("headset_type = %d (HEADSET_NO_MIC)\n", headset_type);
+                        if(0 != pdata->gpio_switch)
+                                gpio_direction_output(pdata->gpio_switch, 0);
+                        break;
+                case HEADSET_APPLE:
+                        PRINT_INFO("headset_type = %d (HEADSET_APPLE)\n", headset_type);
+                        PRINT_INFO("we have not yet implemented this in the code\n");
+                        break;
+                default:
+                        PRINT_INFO("headset_type = %d (HEADSET_UNKNOWN)\n", headset_type);
+                        break;
+                }
+
+                detect_err_count = 0;
+                if(headset_type == HEADSET_NO_MIC)
+                        ht->headphone = 1;
+                else
+                        ht->headphone = 0;
+
+                if (ht->headphone) {
+                        headset_button_irq_threshold(0);
+                        headset_irq_button_enable(0, ht->irq_button);
+
+                        ht->type = BIT_HEADSET_NO_MIC;
+                        //hp_notifier_call_chain(ht->type);
+                        switch_set_state(&ht->sdev, ht->type);
+                        PRINT_INFO("headphone plug in (headset_detect_work_func)\n");
+                } else {
+                        headset_button_irq_threshold(1);
+
+                        if((HEADSET_4POLE_NOT_NORMAL == headset_type) && (0 == pdata->gpio_switch)) {
+                                headset_irq_button_enable(0, ht->irq_button);
+                                PRINT_INFO("HEADSET_4POLE_NOT_NORMAL is not supported by your hardware! so disable the button irq!\n");
+                        } else {
+                                if (1 == ht->platform_data->irq_trigger_level_button)
+                                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_HIGH);
+                                else
+                                        headset_irq_set_irq_type(ht->irq_button, IRQF_TRIGGER_LOW);
+
+                                headset_irq_button_enable(1, ht->irq_button);
+                        }
+
+                        ht->type = BIT_HEADSET_MIC;
+                        //hp_notifier_call_chain(ht->type);
+                        switch_set_state(&ht->sdev, ht->type);
+                        PRINT_INFO("headset plug in (headset_detect_work_func)\n");
+#ifdef ADPGAR_BYP_SELECT
+                        queue_delayed_work(adpgar_byp_select_work_queue, &adpgar_byp_select_work, msecs_to_jiffies(500));
+#endif
+                }
+
+                plug_state_last = 1;
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+				headset_irq_detect_enable(0, ht->irq_detect);
+				headset_irq_detect_mic_enable(1, ht->irq_detect_mic);
+#else
+                if(1 == pdata->irq_trigger_level_detect)
+                        headset_irq_set_irq_type(ht->irq_detect, IRQF_TRIGGER_LOW);
+                else
+                        headset_irq_set_irq_type(ht->irq_detect, IRQF_TRIGGER_HIGH);
+
+                headset_irq_detect_enable(1, ht->irq_detect);
+#endif
+        } else if(0 == plug_state_current && 1 == plug_state_last) {
+
+                headset_irq_button_enable(0, ht->irq_button);
+                button_release_verify();
+
+                if (ht->headphone) {
+                        PRINT_INFO("headphone plug out (headset_detect_work_func)\n");
+                } else {
+                        PRINT_INFO("headset plug out (headset_detect_work_func)\n");
+                }
+                ht->type = BIT_HEADSET_OUT;
+                //hp_notifier_call_chain(ht->type);
+                switch_set_state(&ht->sdev, ht->type);
+                plug_state_last = 0;
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+				headset_irq_detect_mic_enable(0, ht->irq_detect_mic);
+#else
+                if(1 == pdata->irq_trigger_level_detect)
+                        headset_irq_set_irq_type(ht->irq_detect, IRQF_TRIGGER_HIGH);
+                else
+                        headset_irq_set_irq_type(ht->irq_detect, IRQF_TRIGGER_LOW);
+#endif
+                headset_irq_detect_enable(1, ht->irq_detect);
+        } else {
+                PRINT_INFO("irq_detect must be enabled anyway!!!\n");
+                goto out;
+        }
+out:
+
+        if(0 == plug_state_last) {
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+			headset_irq_detect_mic_enable(0, ht->irq_detect_mic);
+			if (detect_err_count < 500) {
+				headset_irq_detect_enable(1, ht->irq_detect);
+			}
+#endif
+			headmicbias_power_on(&this_pdev->dev, 0);
+			//headset_detect_clk_en();
+			//if (sprd_hts_power.head_mic) {
+				//regulator_set_mode(sprd_hts_power.head_mic, REGULATOR_MODE_NORMAL);
+			//}
+		}
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+		if (1 == plug_state_last) {
+			headset_irq_detect_mic_enable(1, ht->irq_detect_mic);
+			headset_irq_detect_enable(0, ht->irq_detect);
+		}
+#else
+        headset_irq_detect_enable(1, ht->irq_detect);
+#endif
+        //wake_unlock(&headset_detect_wakelock);
+        up(&headset_sem);
+        return;
+}
+
+#ifdef ADPGAR_BYP_SELECT
+static void adpgar_byp_select_func(struct work_struct *work)
+{
+	if ((0x2723 == (sci_get_ana_chip_id() >> 16))
+			&& (SC2723ES == sci_get_ana_chip_ver()
+				|| SC2723TS == sci_get_ana_chip_ver())) {
+		return;
+	}
+
+        headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CDC1), AUDIO_ADPGAR_BYP_HEADMIC_2_ADCR, AUDIO_ADPGAR_BYP_MASK, AUDIO_ADPGAR_BYP_SHIFT);
+        PRINT_INFO("ANA_CDC1 = 0x%08X\n", sci_adi_read(HEADMIC_DETECT_REG(ANA_CDC1)));
+        msleep(100);
+        headset_reg_set_val(HEADMIC_DETECT_REG(ANA_CDC1), AUDIO_ADPGAR_BYP_NORMAL, AUDIO_ADPGAR_BYP_MASK, AUDIO_ADPGAR_BYP_SHIFT);
+        PRINT_INFO("ANA_CDC1 = 0x%08X\n", sci_adi_read(HEADMIC_DETECT_REG(ANA_CDC1)));
+        PRINT_INFO("adpgar_byp_select_func\n");
+}
+#endif
+
+static void reg_dump_func(struct work_struct *work)
+{
+        int adc_mic = 0;
+
+        int gpio_detect = 0;
+        int gpio_button = 0;
+	int gpio_detect_mic = 0;
+
+        int ana_sts0 = 0;
+        int ana_pmu0 = 0;
+        int ana_cfg1 = 0;
+        int ana_hdt0 = 0;
+
+        int hid_cfg0 = 0;
+        int hid_cfg2 = 0;
+        int hid_cfg3 = 0;
+        int hid_cfg4 = 0;
+
+        int arm_module_en = 0;
+        int arm_clk_en = 0;
+
+        adc_mic = wrap_sci_adc_get_value(ADC_CHANNEL_HEADMIC, 1);
+
+        gpio_detect = gpio_get_value(headset.platform_data->gpio_detect);
+        gpio_button = gpio_get_value(headset.platform_data->gpio_button);
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+		gpio_detect_mic = gpio_get_value(headset.platform_data->gpio_detect_mic);
+#endif
+
+        sci_adi_write(ANA_REG_GLB_ARM_MODULE_EN, BIT_ANA_AUD_EN, BIT_ANA_AUD_EN);//arm base address:0x40038800 for register accessable
+        ana_pmu0 = sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_PMU0);//arm base address:0x40038600
+        ana_hdt0 = sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_HDT0);//arm base address:0x40038600
+        ana_sts0 = sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_STS0);//arm base address:0x40038600
+
+        sci_adi_write(ANA_REG_GLB_ARM_MODULE_EN, BIT_ANA_HDT_EN, BIT_ANA_HDT_EN);//arm base address:0x40038800 for register accessable
+        sci_adi_write(ANA_REG_GLB_ARM_CLK_EN, BIT_CLK_AUD_HID_EN, BIT_CLK_AUD_HID_EN);//arm base address:0x40038800 for register accessable
+
+        hid_cfg2 = sci_adi_read(ANA_HDT_INT_BASE+HID_CFG2);//arm base address:0x40038700
+        hid_cfg3 = sci_adi_read(ANA_HDT_INT_BASE+HID_CFG3);//arm base address:0x40038700
+        hid_cfg4 = sci_adi_read(ANA_HDT_INT_BASE+HID_CFG4);//arm base address:0x40038700
+        hid_cfg0 = sci_adi_read(ANA_HDT_INT_BASE+HID_CFG0);//arm base address:0x40038700
+
+        arm_module_en = sci_adi_read(ANA_REG_GLB_ARM_MODULE_EN);
+        arm_clk_en = sci_adi_read(ANA_REG_GLB_ARM_CLK_EN);
+
+		PRINT_INFO("GPIO_%03d(det)=%d    GPIO_%03d(but)=%d    GPIO_%03d(det_mic)=%d    adc_mic=%d\n",
+			headset.platform_data->gpio_detect, gpio_detect,
+			headset.platform_data->gpio_button, gpio_button,
+			headset.platform_data->gpio_detect_mic, gpio_detect_mic,
+			adc_mic);
+        PRINT_INFO("arm_module_en|arm_clk_en|ana_pmu0  |ana_cfg1  |ana_hdt0 |ana_sts0  |hid_cfg2  |hid_cfg3  |hid_cfg4  |hid_cfg0\n");
+        PRINT_INFO("0x%08X   |0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X\n",
+                   arm_module_en, arm_clk_en, ana_pmu0, ana_cfg1, ana_hdt0, ana_sts0, hid_cfg2, hid_cfg3, hid_cfg4, hid_cfg0);
+#if 0
+        int i = 0;
+        int hbd[20] = {0};
+
+        for(i=0; i<20; i++)
+                hbd[i] = sci_adi_read(ANA_HDT_INT_BASE + (i*4));
+
+        PRINT_INFO(" hbd_cfg0 | hbd_cfg1 | hbd_cfg2 | hbd_cfg3 | hbd_cfg4 | hbd_cfg5 | hbd_cfg6 | hbd_cfg7 | hbd_cfg8 | hbd_cfg9\n");
+        PRINT_INFO("0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X\n",
+                   hbd[0], hbd[1], hbd[2], hbd[3], hbd[4], hbd[5], hbd[6], hbd[7], hbd[8], hbd[9]);
+
+        PRINT_INFO("hbd_cfg10 |hbd_cfg11 |hbd_cfg12 |hbd_cfg13 |hbd_cfg14 |hbd_cfg15 |hbd_cfg16 | hbd_sts0 | hbd_sts1 | hbd_sts2\n");
+        PRINT_INFO("0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X|0x%08X\n",
+                   hbd[10], hbd[11], hbd[12], hbd[13], hbd[14], hbd[15], hbd[16], hbd[17], hbd[18], hbd[19]);
+#endif
+
+        if (debug_level >= 2)
+                queue_delayed_work(reg_dump_work_queue, &reg_dump_work, msecs_to_jiffies(500));
+        return;
+}
+
+/**
+ * some phone boards, when no headset plugin, the button headset_button_valid()
+ * will always return 0, so we need to disable headset_button irq in here
+ * otherwise button irq will always happen.
+ */
+volatile int headset_button_hardware_bug_fix_stage = 1;
+static void headset_button_hardware_bug_fix(struct sprd_headset *ht)
+{
+        if (headset_button_hardware_bug_fix_stage) {
+                headset_irq_button_enable(0, ht->irq_button); // disable button irq before headset detected
+                pr_err("This phone board headset button circuit has bug, please fix the hardware\n");
+        }
+}
+
+static irqreturn_t headset_button_irq_handler(int irq, void *dev)
+{
+        struct sprd_headset *ht = dev;
+        int button_state_current = 0;
+        int gpio_button_value_current = 0;
+
+        if(0 == headset_button_valid(gpio_get_value(ht->platform_data->gpio_detect))) {
+                PRINT_INFO("headset_button_irq_handler: button is invalid!!! IRQ_%d(GPIO_%d) = %d, ANA_STS0 = 0x%08X\n",
+                           ht->irq_button, ht->platform_data->gpio_button, gpio_button_value_last,
+                           sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_STS0));
+                headset_button_hardware_bug_fix(ht);
+
+                if(0 == plug_state_last)
+                        headset_irq_button_enable(0, ht->irq_button);
+
+                return IRQ_HANDLED;
+        }
+
+        gpio_button_value_current = gpio_get_value(ht->platform_data->gpio_button);
+        button_state_current = headset_gpio_2_button_state(gpio_button_value_current);
+#ifdef ADPGAR_BYP_SELECT
+        if(0 == button_state_current) {
+                queue_delayed_work(adpgar_byp_select_work_queue, &adpgar_byp_select_work, msecs_to_jiffies(0));
+        }
+#endif
+        if(button_state_current == button_state_last) {
+                PRINT_INFO("button state check failed!!! maybe the release is too quick. button_state_current=%d, button_state_last=%d\n",
+                           button_state_current, button_state_last);
+                return IRQ_HANDLED;
+        }
+
+        headset_irq_button_enable(0, ht->irq_button);
+        wake_lock_timeout(&headset_button_wakelock, msecs_to_jiffies(2000));
+        gpio_button_value_last = gpio_button_value_current;
+        PRINT_DBG("headset_button_irq_handler: IRQ_%d(GPIO_%d) = %d, ANA_STS0 = 0x%08X\n",
+                  ht->irq_button, ht->platform_data->gpio_button, gpio_button_value_last,
+                  sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_STS0));
+        queue_work(ht->button_work_queue, &ht->work_button);
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t headset_detect_irq_handler(int irq, void *dev)
+{
+	struct sprd_headset *ht = dev;
+	PRINT_INFO("headset_detect_irq_handler in \n");
+	headset_irq_button_enable(0, ht->irq_button);
+	headset_irq_detect_enable(0, ht->irq_detect);
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+	headset_irq_detect_mic_enable(0, ht->irq_detect_mic);
+#endif
+	wake_lock_timeout(&headset_detect_wakelock, msecs_to_jiffies(2000));
+	gpio_detect_value_last = gpio_get_value(ht->platform_data->gpio_detect);
+	PRINT_DBG("headset_detect_irq_handler: IRQ_%d(GPIO_%d) = %d, ANA_STS0 = 0x%08X\n",
+		ht->irq_detect, ht->platform_data->gpio_detect, gpio_detect_value_last,
+		sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_STS0));
+	queue_delayed_work(ht->detect_work_queue, &ht->work_detect, msecs_to_jiffies(0));
+	PRINT_INFO("headset_detect_irq_handler out \n");
+	return IRQ_HANDLED;
+}
+
+static irqreturn_t headset_detect_mic_irq_handler(int irq, void *dev)
+{
+	struct sprd_headset *ht = dev;
+	PRINT_INFO("headset_detect_mic_irq_handler in \n");
+	if (plug_state_last != 1) {
+		headset_irq_detect_mic_enable(0, ht->irq_detect_mic);
+		PRINT_INFO("headset_detect_mic_irq_handler out0 \n");
+		return IRQ_HANDLED;
+	}
+	headset_irq_detect_mic_enable(0, ht->irq_detect_mic);
+	headset_irq_detect_enable(0, ht->irq_detect);
+	wake_lock_timeout(&headset_detect_wakelock, msecs_to_jiffies(2000));
+	queue_delayed_work(ht->detect_work_queue, &ht->work_detect, msecs_to_jiffies(0));
+	PRINT_INFO("headset_detect_mic_irq_handler out1 \n");
+	return IRQ_HANDLED;
+}
+
+//================= create sys fs for debug ===================
+//============= /sys/kernel/headset/debug_level ===============
+
+static ssize_t headset_debug_level_show(struct kobject *kobj, struct kobj_attribute *attr, char *buff)
+{
+        PRINT_INFO("debug_level = %d\n", debug_level);
+        return sprintf(buff, "%d\n", debug_level);
+}
+
+static ssize_t headset_debug_level_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buff, size_t len)
+{
+        unsigned long level = simple_strtoul(buff, NULL, 10);
+        debug_level = level;
+        PRINT_INFO("debug_level = %d\n", debug_level);
+        if(debug_level >= 2)
+                queue_delayed_work(reg_dump_work_queue, &reg_dump_work, msecs_to_jiffies(500));
+        return len;
+}
+
+static struct kobject *headset_debug_kobj = NULL;
+static struct kobj_attribute headset_debug_attr =
+        __ATTR(debug_level, 0644, headset_debug_level_show, headset_debug_level_store);
+
+static int headset_debug_sysfs_init(void)
+{
+        int ret = -1;
+
+        headset_debug_kobj = kobject_create_and_add("headset", kernel_kobj);
+        if (headset_debug_kobj == NULL) {
+                ret = -ENOMEM;
+                PRINT_ERR("register sysfs failed. ret = %d\n", ret);
+                return ret;
+        }
+
+        ret = sysfs_create_file(headset_debug_kobj, &headset_debug_attr.attr);
+        if (ret) {
+                PRINT_ERR("create sysfs failed. ret = %d\n", ret);
+                return ret;
+        }
+
+        PRINT_INFO("headset_debug_sysfs_init success\n");
+        return ret;
+}
+//================= create sys fs for debug ===================
+
+#ifdef CONFIG_OF
+static struct sprd_headset_platform_data *headset_detect_parse_dt(struct device *dev)
+{
+        struct sprd_headset_platform_data *pdata;
+        struct device_node *np = dev->of_node,*buttons_np = NULL;
+        int ret;
+        struct headset_buttons *buttons_data;
+
+        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+        if (!pdata) {
+                dev_err(dev, "could not allocate memory for platform data\n");
+                return NULL;
+        }
+        ret = of_property_read_u32(np, "gpio_switch", &pdata->gpio_switch);
+        if(ret) {
+                dev_err(dev, "fail to get gpio_switch\n");
+                goto fail;
+        }
+        ret = of_property_read_u32(np, "gpio_detect", &pdata->gpio_detect);
+        if(ret) {
+                dev_err(dev, "fail to get gpio_detect\n");
+                goto fail;
+        }
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+		ret = of_property_read_u32(np, "gpio_detect_mic", &pdata->gpio_detect_mic);
+		if (ret) {
+			dev_err(dev, "fail to get gpio_detect_mic\n");
+			goto fail;
+		}
+#endif
+        ret = of_property_read_u32(np, "gpio_button", &pdata->gpio_button);
+        if(ret) {
+                dev_err(dev, "fail to get gpio_button\n");
+                goto fail;
+        }
+        ret = of_property_read_u32(np, "irq_trigger_level_detect", &pdata->irq_trigger_level_detect);
+        if(ret) {
+                dev_err(dev, "fail to get irq_trigger_level_detect\n");
+                goto fail;
+        }
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+		ret = of_property_read_u32(np, "irq_trigger_level_detect_mic", &pdata->irq_trigger_level_detect_mic);
+		if (ret) {
+			dev_err(dev, "fail to get irq_trigger_level_detect_mic\n");
+			goto fail;
+		}
+#endif
+        ret = of_property_read_u32(np, "irq_trigger_level_button", &pdata->irq_trigger_level_button);
+        if(ret) {
+                dev_err(dev, "fail to get irq_trigger_level_button\n");
+                goto fail;
+        }
+        ret = of_property_read_u32(np, "adc_threshold_3pole_detect", &pdata->adc_threshold_3pole_detect);
+        if(ret) {
+                dev_err(dev, "fail to get adc_threshold_3pole_detect\n");
+                goto fail;
+        }
+
+        ret = of_property_read_u32(np, "adc_threshold_4pole_detect", &pdata->adc_threshold_4pole_detect);
+        if(ret) {
+                dev_err(dev, "fail to get adc_threshold_4pole_detect\n");
+                goto fail;
+        }
+
+        ret = of_property_read_u32(np, "irq_threshold_buttont", &pdata->irq_threshold_buttont);
+        if(ret) {
+                dev_err(dev, "fail to get irq_threshold_buttont\n");
+                goto fail;
+        }
+
+        ret = of_property_read_u32(np, "voltage_headmicbias", &pdata->voltage_headmicbias);
+        if(ret) {
+                dev_err(dev, "fail to get voltage_headmicbias\n");
+                goto fail;
+        }
+        ret = of_property_read_u32(np, "nbuttons", &pdata->nbuttons);
+        if(ret) {
+                dev_err(dev, "fail to get nbuttons\n");
+                goto fail;
+        }
+
+        buttons_data = kzalloc(pdata->nbuttons*sizeof(*buttons_data),GFP_KERNEL);
+        if (!buttons_data) {
+                dev_err(dev, "could not allocate memory for headset_buttons\n");
+                goto fail;
+        }
+        pdata->headset_buttons = buttons_data;
+
+        for_each_child_of_node(np,buttons_np) {
+
+                ret = of_property_read_u32(buttons_np, "adc_min", &buttons_data->adc_min);
+                if (ret) {
+                        dev_err(dev, "fail to get adc_min\n");
+                        goto fail_buttons_data;
+                }
+                ret = of_property_read_u32(buttons_np, "adc_max", &buttons_data->adc_max);
+                if (ret) {
+                        dev_err(dev, "fail to get adc_max\n");
+                        goto fail_buttons_data;
+                }
+                ret = of_property_read_u32(buttons_np, "code", &buttons_data->code);
+                if (ret) {
+                        dev_err(dev, "fail to get code\n");
+                        goto fail_buttons_data;
+                }
+                ret = of_property_read_u32(buttons_np, "type", &buttons_data->type);
+                if (ret) {
+                        dev_err(dev, "fail to get type\n");
+                        goto fail_buttons_data;
+                }
+                PRINT_INFO("device tree data: adc_min = %d adc_max = %d code = %d type = %d \n", buttons_data->adc_min,
+                       buttons_data->adc_max, buttons_data->code, buttons_data->type);
+                buttons_data++;
+        };
+
+        return pdata;
+
+fail_buttons_data:
+        kfree(buttons_data);
+        pdata->headset_buttons = NULL;
+fail:
+        kfree(pdata);
+        return NULL;
+}
+#endif
+static void adc_cal_from_efuse(void);
+
+static int headset_detect_probe(struct platform_device *pdev)
+{
+        struct sprd_headset_platform_data *pdata = pdev->dev.platform_data;
+        struct sprd_headset *ht = &headset;
+        unsigned long irqflags = 0;
+        struct input_dev *input_dev = NULL;
+        int i = 0;
+        int ret = -1;
+        int ana_sts0 = 0;
+        int adie_chip_id_low = 0;
+        int adie_chip_id_high = 0;
+        unsigned int adie_chip_id = 0;
+        unsigned int ddie_chip_id = 0;
+
+#ifdef CONFIG_OF
+        struct device_node *np = NULL;
+        np = pdev->dev.of_node;
+
+        if (pdev->dev.of_node && !pdata) {
+                pdata = headset_detect_parse_dt(&pdev->dev);
+                if(pdata)
+                        pdev->dev.platform_data = pdata;
+        }
+        if (!pdata) {
+                PRINT_ERR("headset_detect_probe get platform_data NULL\n");
+                ret = -EINVAL;
+                goto fail_to_get_platform_data;
+        }
+#endif
+
+        this_pdev = pdev;
+
+        sci_adi_write(ANA_REG_GLB_ARM_MODULE_EN, BIT_ANA_AUD_EN, BIT_ANA_AUD_EN);//arm base address:0x40038800 for register accessable
+        ana_sts0 = sci_adi_read(ANA_AUDCFGA_INT_BASE+ANA_STS0);//arm base address:0x40038600
+
+        ddie_chip_id = sci_get_chip_id();
+        PRINT_INFO("ddie_chip_id=0x%08X\n", ddie_chip_id);
+        adie_chip_id = sci_get_ana_chip_id();
+        PRINT_INFO("adie_chip_id=0x%08X\n", adie_chip_id);
+
+        adie_chip_id_high = (adie_chip_id >> 16) & 0xFFFF;
+        adie_chip_id_low = adie_chip_id & 0xFFFF;
+
+        switch (adie_chip_id_high) {
+        case 0x2723: {//chip is 2723
+                adie_type = 2723;
+                PRINT_INFO("adie chip is 2723, type = %d\n", adie_type);
+                break; //break from 2723
+        }
+
+        default: {
+                adie_type = -1; //unknow
+                PRINT_ERR("unknow adie chip !!!\n");
+                break;
+        }
+        }
+
+        ht->platform_data = pdata;
+        headset_detect_init();
+
+        ret = sprd_headset_power_init(&pdev->dev);
+        if (ret)
+                goto fail_to_sprd_headset_power_init;
+
+        PRINT_INFO("====================== SPRD HEADSET DETECT v2 ======================\n");
+        PRINT_INFO(" write 0~3 to \"/sys/kernel/headset/debug_level\" for headset debug\n");
+        PRINT_INFO("====================================================================\n");
+        PRINT_INFO("use GPIO_%d for insert detecting\n", pdata->gpio_detect);
+
+        if(0 != pdata->gpio_switch) {
+                ret = gpio_request(pdata->gpio_switch, "headset_switch");
+                if (ret < 0) {
+                        PRINT_ERR("failed to request GPIO_%d(headset_switch)\n", pdata->gpio_switch);
+                        goto failed_to_request_gpio_switch;
+                }
+        } else
+                PRINT_INFO("automatic type switch is unsupported\n");
+
+        ret = gpio_request(pdata->gpio_detect, "headset_detect");
+        if (ret < 0) {
+                PRINT_ERR("failed to request GPIO_%d(headset_detect)\n", pdata->gpio_detect);
+                goto failed_to_request_gpio_detect;
+        }
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+		ret = gpio_request(pdata->gpio_detect_mic, "headset_detect_mic");
+		if (ret < 0) {
+			PRINT_ERR("failed to request GPIO_%d(headset_detect_mic)\n", pdata->gpio_detect_mic);
+			goto failed_to_request_gpio_detect_mic;
+		}
+#endif
+        ret = gpio_request(pdata->gpio_button, "headset_button");
+        if (ret < 0) {
+                PRINT_ERR("failed to request GPIO_%d(headset_button)\n", pdata->gpio_button);
+                goto failed_to_request_gpio_button;
+        }
+
+        if(0 != pdata->gpio_switch)
+                gpio_direction_output(pdata->gpio_switch, 0);
+        gpio_direction_input(pdata->gpio_detect);
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+		gpio_direction_input(pdata->gpio_detect_mic);
+#endif
+        gpio_direction_input(pdata->gpio_button);
+        ht->irq_detect = gpio_to_irq(pdata->gpio_detect);
+        ht->irq_button = gpio_to_irq(pdata->gpio_button);
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+		ht->irq_detect_mic = gpio_to_irq(pdata->gpio_detect_mic);
+#endif
+        ret = switch_dev_register(&ht->sdev);
+        if (ret < 0) {
+                PRINT_ERR("switch_dev_register failed!\n");
+                goto failed_to_register_switch_dev;
+        }
+
+        input_dev = input_allocate_device();
+        if ( !input_dev) {
+                PRINT_ERR("input_allocate_device for headset_button failed!\n");
+                ret = -ENOMEM;
+                goto failed_to_allocate_input_device;
+        }
+
+        input_dev->name = "headset-keyboard";
+        input_dev->id.bustype = BUS_HOST;
+        ht->input_dev = input_dev;
+
+        for (i = 0; i < pdata->nbuttons; i++) {
+                struct headset_buttons *buttons = &pdata->headset_buttons[i];
+                unsigned int type = buttons->type ?: EV_KEY;
+                input_set_capability(input_dev, type, buttons->code);
+        }
+
+        ret = input_register_device(input_dev);
+        if (ret) {
+                PRINT_ERR("input_register_device for headset_button failed!\n");
+                goto failed_to_register_input_device;
+        }
+
+        sema_init(&headset_sem, 1);
+
+        INIT_WORK(&ht->work_button, headset_button_work_func);
+        ht->button_work_queue = create_singlethread_workqueue("headset_button");
+        if(ht->button_work_queue == NULL) {
+                PRINT_ERR("create_singlethread_workqueue for headset_button failed!\n");
+                goto failed_to_create_singlethread_workqueue_for_headset_button;
+        }
+
+        INIT_DELAYED_WORK(&ht->work_detect, headset_detect_work_func);
+        ht->detect_work_queue = create_singlethread_workqueue("headset_detect");
+        if(ht->detect_work_queue == NULL) {
+                PRINT_ERR("create_singlethread_workqueue for headset_detect failed!\n");
+                goto failed_to_create_singlethread_workqueue_for_headset_detect;
+        }
+
+        INIT_DELAYED_WORK(&reg_dump_work, reg_dump_func);
+        reg_dump_work_queue = create_singlethread_workqueue("headset_reg_dump");
+        if(reg_dump_work_queue == NULL) {
+                PRINT_ERR("create_singlethread_workqueue for headset_reg_dump failed!\n");
+                goto failed_to_create_singlethread_workqueue_for_headset_reg_dump;
+        }
+        if (debug_level >= 2)
+                queue_delayed_work(reg_dump_work_queue, &reg_dump_work, msecs_to_jiffies(500));
+
+#ifdef ADPGAR_BYP_SELECT
+        //work queue for Bug#298417
+        INIT_DELAYED_WORK(&adpgar_byp_select_work, adpgar_byp_select_func);
+        adpgar_byp_select_work_queue = create_singlethread_workqueue("adpgar_byp_select");
+        if(adpgar_byp_select_work_queue == NULL) {
+                PRINT_ERR("create_singlethread_workqueue for adpgar_byp_select failed!\n");
+                goto failed_to_create_singlethread_workqueue_for_adpgar_byp_select;
+        }
+        PRINT_INFO("ADPGAR_BYP_SELECT is enabled!\n");
+#endif
+
+        wake_lock_init(&headset_detect_wakelock, WAKE_LOCK_SUSPEND, "headset_detect_wakelock");
+        wake_lock_init(&headset_button_wakelock, WAKE_LOCK_SUSPEND, "headset_button_wakelock");
+
+        //set EIC3 de-bounce time for button irq
+        headset_reg_set_val((ANA_EIC_BASE+EIC3_DBNC_CTRL), DBNC_CNT3_VALUE, DBNC_CNT3_MASK, DBNC_CNT3_SHIFT);
+        //set EIC5 de-bounce time for inser irq
+        headset_reg_set_val((ANA_EIC_BASE+EIC8_DBNC_CTRL), DBNC_CNT8_VALUE, DBNC_CNT8_MASK, DBNC_CNT8_SHIFT);
+
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+		/* set EIC5 de-bounce time for ins_mic irq */
+		headset_reg_set_val((ANA_EIC_BASE+EIC5_DBNC_CTRL), DBNC_CNT5_VALUE, DBNC_CNT5_MASK, DBNC_CNT5_SHIFT);
+#endif
+        irqflags = pdata->irq_trigger_level_button ? IRQF_TRIGGER_HIGH : IRQF_TRIGGER_LOW;
+        ret = request_irq(ht->irq_button, headset_button_irq_handler, irqflags | IRQF_NO_SUSPEND, "headset_button", ht);
+        if (ret) {
+                PRINT_ERR("failed to request IRQ_%d(GPIO_%d)\n", ht->irq_button, pdata->gpio_button);
+                goto failed_to_request_irq_headset_button;
+        }
+        headset_irq_button_enable(0, ht->irq_button);//disable button irq before headset detected
+        headset_button_hardware_bug_fix_stage = 0;
+
+        irqflags = pdata->irq_trigger_level_detect ? IRQF_TRIGGER_HIGH : IRQF_TRIGGER_LOW;
+        ret = request_irq(ht->irq_detect, headset_detect_irq_handler, irqflags | IRQF_NO_SUSPEND, "headset_detect", ht);
+        if (ret < 0) {
+                PRINT_ERR("failed to request IRQ_%d(GPIO_%d)\n", ht->irq_detect, pdata->gpio_detect);
+                goto failed_to_request_irq_headset_detect;
+        }
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+		irqflags = pdata->irq_trigger_level_detect_mic ? IRQF_TRIGGER_HIGH : IRQF_TRIGGER_LOW;
+		ret = request_irq(ht->irq_detect_mic, headset_detect_mic_irq_handler, irqflags | IRQF_NO_SUSPEND, "headset_detect_mic", ht);
+		if (ret < 0) {
+			PRINT_ERR("failed to request IRQ_%d(GPIO_%d)\n", ht->irq_detect_mic, pdata->gpio_detect_mic);
+			goto failed_to_request_irq_mic_headset_detect;
+		}
+#endif
+        ret = headset_debug_sysfs_init();
+        adc_cal_from_efuse();
+        PRINT_INFO("headset_detect_probe success\n");
+        return ret;
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+failed_to_request_irq_mic_headset_detect:
+		free_irq(ht->irq_detect_mic, ht);
+#endif
+failed_to_request_irq_headset_detect:
+        free_irq(ht->irq_button, ht);
+failed_to_request_irq_headset_button:
+
+#ifdef ADPGAR_BYP_SELECT
+        cancel_delayed_work_sync(&adpgar_byp_select_work);
+        destroy_workqueue(adpgar_byp_select_work_queue);
+failed_to_create_singlethread_workqueue_for_adpgar_byp_select:
+#endif
+
+        cancel_delayed_work_sync(&reg_dump_work);
+        destroy_workqueue(reg_dump_work_queue);
+failed_to_create_singlethread_workqueue_for_headset_reg_dump:
+        destroy_workqueue(ht->detect_work_queue);
+failed_to_create_singlethread_workqueue_for_headset_detect:
+        destroy_workqueue(ht->button_work_queue);
+failed_to_create_singlethread_workqueue_for_headset_button:
+        input_unregister_device(input_dev);
+failed_to_register_input_device:
+        input_free_device(input_dev);
+failed_to_allocate_input_device:
+        switch_dev_unregister(&ht->sdev);
+failed_to_register_switch_dev:
+        gpio_free(pdata->gpio_button);
+failed_to_request_gpio_button:
+        gpio_free(pdata->gpio_detect);
+#ifdef CONFIG_SND_SOC_SPRD_USE_EAR_JACK_TYPE13
+failed_to_request_gpio_detect_mic:
+		gpio_free(pdata->gpio_detect_mic);
+#endif
+failed_to_request_gpio_detect:
+        if(0 != pdata->gpio_switch)
+                gpio_free(pdata->gpio_switch);
+failed_to_request_gpio_switch:
+        headmicbias_power_on(&pdev->dev, 0);
+fail_to_sprd_headset_power_init:
+fail_to_get_platform_data:
+        PRINT_ERR("headset_detect_probe failed\n");
+        return ret;
+}
+
+#ifdef CONFIG_PM
+static int headset_suspend(struct platform_device *dev, pm_message_t state)
+{
+        PRINT_INFO("suspend (det_irq = %d, but_irq = %d, plug_state_last = %d)\n",
+                   headset.irq_detect, headset.irq_button, plug_state_last);
+        return 0;
+}
+
+static int headset_resume(struct platform_device *dev)
+{
+        PRINT_INFO("resume (det_irq = %d, but_irq = %d, plug_state_last = %d)\n",
+                   headset.irq_detect, headset.irq_button, plug_state_last);
+        return 0;
+}
+#else
+#define headset_suspend NULL
+#define headset_resume NULL
+#endif
+
+static int adc_get_ideal(u32 adc_mic)
+{
+    u64 numerator = 0;
+    u32 denominator = 0;
+    u32 adc_ideal = 0;
+    if (adc_cal_headset.cal_type == SPRD_HEADSET_AUXADC_CAL_DO){
+        PRINT_INFO("wangzuo adc_get_ideal in\n");
+        u32 a = adc_cal_headset.A;
+        u32 b = adc_cal_headset.B;
+        u32 e = adc_cal_headset.E;
+
+        if (9*adc_mic + b < 10*a){
+            return adc_mic;
+        }
+        denominator = e*(b-a);
+        numerator = 917280*(9*(u64)adc_mic+(u64)b-10*(u64)a);
+        PRINT_INFO("denominator=%u, numerator=%llu\n", denominator, numerator);
+        do_div(numerator,denominator);
+        adc_ideal = (u32)numerator;
+        PRINT_INFO("adc_mic=%d, adc_ideal=%d\n", adc_mic, adc_ideal);
+        return adc_ideal;
+    } else {
+        return adc_mic;
+    }
+}
+extern u32 __adie_efuse_read_bits(int bit_index, int length);
+
+#define DELTA1_BLOCK9 9
+#define DELTA2_BLOCK10 10
+#define DELTA3_BLOCK11 11
+#define BITCOUNT 8
+#define BLK_WIDTH 8
+static void adc_cal_from_efuse(void)
+{
+    u32 delta[3] = {0};
+    u32 block0_bit7 = 128;
+    u8 test[3] = {0};
+    PRINT_INFO("to get calibration data from efuse ...\n");
+
+    if (adc_cal_headset.cal_type == SPRD_HEADSET_AUXADC_CAL_NO) {
+
+        delta[0] = __adie_efuse_read_bits(DELTA1_BLOCK9*BLK_WIDTH,BITCOUNT);
+        delta[1] = __adie_efuse_read_bits(DELTA2_BLOCK10*BLK_WIDTH,BITCOUNT);
+        delta[2] = __adie_efuse_read_bits(DELTA3_BLOCK11*BLK_WIDTH,BITCOUNT);
+
+        test[0] = delta[0]&0xff;
+        test[1] = delta[1]&0xff;
+        test[2] = delta[2]&0xff;
+        PRINT_INFO("test[0] 0x%x %d, test[1] 0x%x %d, test[2] 0x%x %d \n",test[0],test[0],test[1],test[1],test[2],test[2]);
+
+        block0_bit7 = __adie_efuse_read_bits(0,BITCOUNT);
+        PRINT_INFO("block_7 0x%08x \n",block0_bit7);
+        if(block0_bit7&(1<<7)){
+            PRINT_INFO("block 0 bit 7 set 1 no efuse data\n");
+            return;
+        } else {
+            adc_cal_headset.cal_type = SPRD_HEADSET_AUXADC_CAL_DO;
+            PRINT_INFO("block 0 bit 7 set 0 have efuse data\n");
+        }
+
+        PRINT_INFO("test[0] %d, test[1] %d, test[2] %d \n",test[0],test[1],test[2]);
+
+        adc_cal_headset.A = (test[0]*4)-184;
+        adc_cal_headset.B = (test[1]*4)+2764;
+        adc_cal_headset.E = (test[2]*2)+2500;
+        PRINT_INFO("adc_cal_headset.A %d, adc_cal_headset.B %d, adc_cal_headset.E %d \n",adc_cal_headset.A,adc_cal_headset.B,adc_cal_headset.E);
+    } else {
+        PRINT_INFO("efuse A,B,E has been calculated! \n");
+    }
+
+}
+
+static const struct of_device_id headset_detect_of_match[] = {
+        {.compatible = "sprd,headset_sprd_sc2723",},
+        { }
+};
+static struct platform_driver headset_detect_driver = {
+        .driver = {
+                .name = "headset_sprd_sc2723",
+                .owner = THIS_MODULE,
+                .of_match_table = headset_detect_of_match,
+        },
+        .probe = headset_detect_probe,
+        //.suspend = headset_suspend,
+        //.resume = headset_resume,
+};
+
+static int __init headset_init(void)
+{
+        int ret;
+        ret = platform_driver_register(&headset_detect_driver);
+        return ret;
+}
+
+static void __exit headset_exit(void)
+{
+        sprd_headset_power_deinit();
+        platform_driver_unregister(&headset_detect_driver);
+}
+
+late_initcall(headset_init);
+module_exit(headset_exit);
+
+MODULE_DESCRIPTION("headset & button detect driver v2");
+MODULE_AUTHOR("Yaochuan Li <yaochuan.li@spreadtrum.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/hp_sdc_rtc.c b/drivers/input/misc/hp_sdc_rtc.c
new file mode 100644
index 00000000..86b82280
--- /dev/null
+++ b/drivers/input/misc/hp_sdc_rtc.c
@@ -0,0 +1,730 @@
+/*
+ * HP i8042 SDC + MSM-58321 BBRTC driver.
+ *
+ * Copyright (c) 2001 Brian S. Julin
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL").
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ *
+ * References:
+ * System Device Controller Microprocessor Firmware Theory of Operation
+ *      for Part Number 1820-4784 Revision B.  Dwg No. A-1820-4784-2
+ * efirtc.c by Stephane Eranian/Hewlett Packard
+ *
+ */
+
+#include <linux/hp_sdc.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/time.h>
+#include <linux/miscdevice.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <linux/poll.h>
+#include <linux/rtc.h>
+#include <linux/mutex.h>
+#include <linux/semaphore.h>
+
+MODULE_AUTHOR("Brian S. Julin <bri@calyx.com>");
+MODULE_DESCRIPTION("HP i8042 SDC + MSM-58321 RTC Driver");
+MODULE_LICENSE("Dual BSD/GPL");
+
+#define RTC_VERSION "1.10d"
+
+static DEFINE_MUTEX(hp_sdc_rtc_mutex);
+static unsigned long epoch = 2000;
+
+static struct semaphore i8042tregs;
+
+static hp_sdc_irqhook hp_sdc_rtc_isr;
+
+static struct fasync_struct *hp_sdc_rtc_async_queue;
+
+static DECLARE_WAIT_QUEUE_HEAD(hp_sdc_rtc_wait);
+
+static ssize_t hp_sdc_rtc_read(struct file *file, char __user *buf,
+			       size_t count, loff_t *ppos);
+
+static long hp_sdc_rtc_unlocked_ioctl(struct file *file,
+				      unsigned int cmd, unsigned long arg);
+
+static unsigned int hp_sdc_rtc_poll(struct file *file, poll_table *wait);
+
+static int hp_sdc_rtc_open(struct inode *inode, struct file *file);
+static int hp_sdc_rtc_fasync (int fd, struct file *filp, int on);
+
+static void hp_sdc_rtc_isr (int irq, void *dev_id, 
+			    uint8_t status, uint8_t data) 
+{
+	return;
+}
+
+static int hp_sdc_rtc_do_read_bbrtc (struct rtc_time *rtctm)
+{
+	struct semaphore tsem;
+	hp_sdc_transaction t;
+	uint8_t tseq[91];
+	int i;
+	
+	i = 0;
+	while (i < 91) {
+		tseq[i++] = HP_SDC_ACT_DATAREG |
+			HP_SDC_ACT_POSTCMD | HP_SDC_ACT_DATAIN;
+		tseq[i++] = 0x01;			/* write i8042[0x70] */
+	  	tseq[i]   = i / 7;			/* BBRTC reg address */
+		i++;
+		tseq[i++] = HP_SDC_CMD_DO_RTCR;		/* Trigger command   */
+		tseq[i++] = 2;		/* expect 1 stat/dat pair back.   */
+		i++; i++;               /* buffer for stat/dat pair       */
+	}
+	tseq[84] |= HP_SDC_ACT_SEMAPHORE;
+	t.endidx =		91;
+	t.seq =			tseq;
+	t.act.semaphore =	&tsem;
+	sema_init(&tsem, 0);
+	
+	if (hp_sdc_enqueue_transaction(&t)) return -1;
+	
+	/* Put ourselves to sleep for results. */
+	if (WARN_ON(down_interruptible(&tsem)))
+		return -1;
+	
+	/* Check for nonpresence of BBRTC */
+	if (!((tseq[83] | tseq[90] | tseq[69] | tseq[76] |
+	       tseq[55] | tseq[62] | tseq[34] | tseq[41] |
+	       tseq[20] | tseq[27] | tseq[6]  | tseq[13]) & 0x0f))
+		return -1;
+
+	memset(rtctm, 0, sizeof(struct rtc_time));
+	rtctm->tm_year = (tseq[83] & 0x0f) + (tseq[90] & 0x0f) * 10;
+	rtctm->tm_mon  = (tseq[69] & 0x0f) + (tseq[76] & 0x0f) * 10;
+	rtctm->tm_mday = (tseq[55] & 0x0f) + (tseq[62] & 0x0f) * 10;
+	rtctm->tm_wday = (tseq[48] & 0x0f);
+	rtctm->tm_hour = (tseq[34] & 0x0f) + (tseq[41] & 0x0f) * 10;
+	rtctm->tm_min  = (tseq[20] & 0x0f) + (tseq[27] & 0x0f) * 10;
+	rtctm->tm_sec  = (tseq[6]  & 0x0f) + (tseq[13] & 0x0f) * 10;
+	
+	return 0;
+}
+
+static int hp_sdc_rtc_read_bbrtc (struct rtc_time *rtctm)
+{
+	struct rtc_time tm, tm_last;
+	int i = 0;
+
+	/* MSM-58321 has no read latch, so must read twice and compare. */
+
+	if (hp_sdc_rtc_do_read_bbrtc(&tm_last)) return -1;
+	if (hp_sdc_rtc_do_read_bbrtc(&tm)) return -1;
+
+	while (memcmp(&tm, &tm_last, sizeof(struct rtc_time))) {
+		if (i++ > 4) return -1;
+		memcpy(&tm_last, &tm, sizeof(struct rtc_time));
+		if (hp_sdc_rtc_do_read_bbrtc(&tm)) return -1;
+	}
+
+	memcpy(rtctm, &tm, sizeof(struct rtc_time));
+
+	return 0;
+}
+
+
+static int64_t hp_sdc_rtc_read_i8042timer (uint8_t loadcmd, int numreg)
+{
+	hp_sdc_transaction t;
+	uint8_t tseq[26] = {
+		HP_SDC_ACT_PRECMD | HP_SDC_ACT_POSTCMD | HP_SDC_ACT_DATAIN,
+		0,
+		HP_SDC_CMD_READ_T1, 2, 0, 0,
+		HP_SDC_ACT_POSTCMD | HP_SDC_ACT_DATAIN, 
+		HP_SDC_CMD_READ_T2, 2, 0, 0,
+		HP_SDC_ACT_POSTCMD | HP_SDC_ACT_DATAIN, 
+		HP_SDC_CMD_READ_T3, 2, 0, 0,
+		HP_SDC_ACT_POSTCMD | HP_SDC_ACT_DATAIN, 
+		HP_SDC_CMD_READ_T4, 2, 0, 0,
+		HP_SDC_ACT_POSTCMD | HP_SDC_ACT_DATAIN, 
+		HP_SDC_CMD_READ_T5, 2, 0, 0
+	};
+
+	t.endidx = numreg * 5;
+
+	tseq[1] = loadcmd;
+	tseq[t.endidx - 4] |= HP_SDC_ACT_SEMAPHORE; /* numreg assumed > 1 */
+
+	t.seq =			tseq;
+	t.act.semaphore =	&i8042tregs;
+
+	/* Sleep if output regs in use. */
+	if (WARN_ON(down_interruptible(&i8042tregs)))
+		return -1;
+
+	if (hp_sdc_enqueue_transaction(&t)) return -1;
+	
+	/* Sleep until results come back. */
+	if (WARN_ON(down_interruptible(&i8042tregs)))
+		return -1;
+
+	up(&i8042tregs);
+
+	return (tseq[5] | 
+		((uint64_t)(tseq[10]) << 8)  | ((uint64_t)(tseq[15]) << 16) |
+		((uint64_t)(tseq[20]) << 24) | ((uint64_t)(tseq[25]) << 32));
+}
+
+
+/* Read the i8042 real-time clock */
+static inline int hp_sdc_rtc_read_rt(struct timeval *res) {
+	int64_t raw;
+	uint32_t tenms; 
+	unsigned int days;
+
+	raw = hp_sdc_rtc_read_i8042timer(HP_SDC_CMD_LOAD_RT, 5);
+	if (raw < 0) return -1;
+
+	tenms = (uint32_t)raw & 0xffffff;
+	days  = (unsigned int)(raw >> 24) & 0xffff;
+
+	res->tv_usec = (suseconds_t)(tenms % 100) * 10000;
+	res->tv_sec =  (time_t)(tenms / 100) + days * 86400;
+
+	return 0;
+}
+
+
+/* Read the i8042 fast handshake timer */
+static inline int hp_sdc_rtc_read_fhs(struct timeval *res) {
+	int64_t raw;
+	unsigned int tenms;
+
+	raw = hp_sdc_rtc_read_i8042timer(HP_SDC_CMD_LOAD_FHS, 2);
+	if (raw < 0) return -1;
+
+	tenms = (unsigned int)raw & 0xffff;
+
+	res->tv_usec = (suseconds_t)(tenms % 100) * 10000;
+	res->tv_sec  = (time_t)(tenms / 100);
+
+	return 0;
+}
+
+
+/* Read the i8042 match timer (a.k.a. alarm) */
+static inline int hp_sdc_rtc_read_mt(struct timeval *res) {
+	int64_t raw;	
+	uint32_t tenms; 
+
+	raw = hp_sdc_rtc_read_i8042timer(HP_SDC_CMD_LOAD_MT, 3);
+	if (raw < 0) return -1;
+
+	tenms = (uint32_t)raw & 0xffffff;
+
+	res->tv_usec = (suseconds_t)(tenms % 100) * 10000;
+	res->tv_sec  = (time_t)(tenms / 100);
+
+	return 0;
+}
+
+
+/* Read the i8042 delay timer */
+static inline int hp_sdc_rtc_read_dt(struct timeval *res) {
+	int64_t raw;
+	uint32_t tenms;
+
+	raw = hp_sdc_rtc_read_i8042timer(HP_SDC_CMD_LOAD_DT, 3);
+	if (raw < 0) return -1;
+
+	tenms = (uint32_t)raw & 0xffffff;
+
+	res->tv_usec = (suseconds_t)(tenms % 100) * 10000;
+	res->tv_sec  = (time_t)(tenms / 100);
+
+	return 0;
+}
+
+
+/* Read the i8042 cycle timer (a.k.a. periodic) */
+static inline int hp_sdc_rtc_read_ct(struct timeval *res) {
+	int64_t raw;
+	uint32_t tenms;
+
+	raw = hp_sdc_rtc_read_i8042timer(HP_SDC_CMD_LOAD_CT, 3);
+	if (raw < 0) return -1;
+
+	tenms = (uint32_t)raw & 0xffffff;
+
+	res->tv_usec = (suseconds_t)(tenms % 100) * 10000;
+	res->tv_sec  = (time_t)(tenms / 100);
+
+	return 0;
+}
+
+
+#if 0 /* not used yet */
+/* Set the i8042 real-time clock */
+static int hp_sdc_rtc_set_rt (struct timeval *setto)
+{
+	uint32_t tenms;
+	unsigned int days;
+	hp_sdc_transaction t;
+	uint8_t tseq[11] = {
+		HP_SDC_ACT_PRECMD | HP_SDC_ACT_DATAOUT,
+		HP_SDC_CMD_SET_RTMS, 3, 0, 0, 0,
+		HP_SDC_ACT_PRECMD | HP_SDC_ACT_DATAOUT,
+		HP_SDC_CMD_SET_RTD, 2, 0, 0 
+	};
+
+	t.endidx = 10;
+
+	if (0xffff < setto->tv_sec / 86400) return -1;
+	days = setto->tv_sec / 86400;
+	if (0xffff < setto->tv_usec / 1000000 / 86400) return -1;
+	days += ((setto->tv_sec % 86400) + setto->tv_usec / 1000000) / 86400;
+	if (days > 0xffff) return -1;
+
+	if (0xffffff < setto->tv_sec) return -1;
+	tenms  = setto->tv_sec * 100;
+	if (0xffffff < setto->tv_usec / 10000) return -1;
+	tenms += setto->tv_usec / 10000;
+	if (tenms > 0xffffff) return -1;
+
+	tseq[3] = (uint8_t)(tenms & 0xff);
+	tseq[4] = (uint8_t)((tenms >> 8)  & 0xff);
+	tseq[5] = (uint8_t)((tenms >> 16) & 0xff);
+
+	tseq[9] = (uint8_t)(days & 0xff);
+	tseq[10] = (uint8_t)((days >> 8) & 0xff);
+
+	t.seq =	tseq;
+
+	if (hp_sdc_enqueue_transaction(&t)) return -1;
+	return 0;
+}
+
+/* Set the i8042 fast handshake timer */
+static int hp_sdc_rtc_set_fhs (struct timeval *setto)
+{
+	uint32_t tenms;
+	hp_sdc_transaction t;
+	uint8_t tseq[5] = {
+		HP_SDC_ACT_PRECMD | HP_SDC_ACT_DATAOUT,
+		HP_SDC_CMD_SET_FHS, 2, 0, 0
+	};
+
+	t.endidx = 4;
+
+	if (0xffff < setto->tv_sec) return -1;
+	tenms  = setto->tv_sec * 100;
+	if (0xffff < setto->tv_usec / 10000) return -1;
+	tenms += setto->tv_usec / 10000;
+	if (tenms > 0xffff) return -1;
+
+	tseq[3] = (uint8_t)(tenms & 0xff);
+	tseq[4] = (uint8_t)((tenms >> 8)  & 0xff);
+
+	t.seq =	tseq;
+
+	if (hp_sdc_enqueue_transaction(&t)) return -1;
+	return 0;
+}
+
+
+/* Set the i8042 match timer (a.k.a. alarm) */
+#define hp_sdc_rtc_set_mt (setto) \
+	hp_sdc_rtc_set_i8042timer(setto, HP_SDC_CMD_SET_MT)
+
+/* Set the i8042 delay timer */
+#define hp_sdc_rtc_set_dt (setto) \
+	hp_sdc_rtc_set_i8042timer(setto, HP_SDC_CMD_SET_DT)
+
+/* Set the i8042 cycle timer (a.k.a. periodic) */
+#define hp_sdc_rtc_set_ct (setto) \
+	hp_sdc_rtc_set_i8042timer(setto, HP_SDC_CMD_SET_CT)
+
+/* Set one of the i8042 3-byte wide timers */
+static int hp_sdc_rtc_set_i8042timer (struct timeval *setto, uint8_t setcmd)
+{
+	uint32_t tenms;
+	hp_sdc_transaction t;
+	uint8_t tseq[6] = {
+		HP_SDC_ACT_PRECMD | HP_SDC_ACT_DATAOUT,
+		0, 3, 0, 0, 0
+	};
+
+	t.endidx = 6;
+
+	if (0xffffff < setto->tv_sec) return -1;
+	tenms  = setto->tv_sec * 100;
+	if (0xffffff < setto->tv_usec / 10000) return -1;
+	tenms += setto->tv_usec / 10000;
+	if (tenms > 0xffffff) return -1;
+
+	tseq[1] = setcmd;
+	tseq[3] = (uint8_t)(tenms & 0xff);
+	tseq[4] = (uint8_t)((tenms >> 8)  & 0xff);
+	tseq[5] = (uint8_t)((tenms >> 16)  & 0xff);
+
+	t.seq =			tseq;
+
+	if (hp_sdc_enqueue_transaction(&t)) { 
+		return -1;
+	}
+	return 0;
+}
+#endif
+
+static ssize_t hp_sdc_rtc_read(struct file *file, char __user *buf,
+			       size_t count, loff_t *ppos) {
+	ssize_t retval;
+
+        if (count < sizeof(unsigned long))
+                return -EINVAL;
+
+	retval = put_user(68, (unsigned long __user *)buf);
+	return retval;
+}
+
+static unsigned int hp_sdc_rtc_poll(struct file *file, poll_table *wait)
+{
+        unsigned long l;
+
+	l = 0;
+        if (l != 0)
+                return POLLIN | POLLRDNORM;
+        return 0;
+}
+
+static int hp_sdc_rtc_open(struct inode *inode, struct file *file)
+{
+        return 0;
+}
+
+static int hp_sdc_rtc_fasync (int fd, struct file *filp, int on)
+{
+        return fasync_helper (fd, filp, on, &hp_sdc_rtc_async_queue);
+}
+
+static int hp_sdc_rtc_proc_show(struct seq_file *m, void *v)
+{
+#define YN(bit) ("no")
+#define NY(bit) ("yes")
+        struct rtc_time tm;
+	struct timeval tv;
+
+	memset(&tm, 0, sizeof(struct rtc_time));
+
+	if (hp_sdc_rtc_read_bbrtc(&tm)) {
+		seq_puts(m, "BBRTC\t\t: READ FAILED!\n");
+	} else {
+		seq_printf(m,
+			     "rtc_time\t: %02d:%02d:%02d\n"
+			     "rtc_date\t: %04d-%02d-%02d\n"
+			     "rtc_epoch\t: %04lu\n",
+			     tm.tm_hour, tm.tm_min, tm.tm_sec,
+			     tm.tm_year + 1900, tm.tm_mon + 1, 
+			     tm.tm_mday, epoch);
+	}
+
+	if (hp_sdc_rtc_read_rt(&tv)) {
+		seq_puts(m, "i8042 rtc\t: READ FAILED!\n");
+	} else {
+		seq_printf(m, "i8042 rtc\t: %ld.%02d seconds\n", 
+			     tv.tv_sec, (int)tv.tv_usec/1000);
+	}
+
+	if (hp_sdc_rtc_read_fhs(&tv)) {
+		seq_puts(m, "handshake\t: READ FAILED!\n");
+	} else {
+        	seq_printf(m, "handshake\t: %ld.%02d seconds\n", 
+			     tv.tv_sec, (int)tv.tv_usec/1000);
+	}
+
+	if (hp_sdc_rtc_read_mt(&tv)) {
+		seq_puts(m, "alarm\t\t: READ FAILED!\n");
+	} else {
+		seq_printf(m, "alarm\t\t: %ld.%02d seconds\n", 
+			     tv.tv_sec, (int)tv.tv_usec/1000);
+	}
+
+	if (hp_sdc_rtc_read_dt(&tv)) {
+		seq_puts(m, "delay\t\t: READ FAILED!\n");
+	} else {
+		seq_printf(m, "delay\t\t: %ld.%02d seconds\n", 
+			     tv.tv_sec, (int)tv.tv_usec/1000);
+	}
+
+	if (hp_sdc_rtc_read_ct(&tv)) {
+		seq_puts(m, "periodic\t: READ FAILED!\n");
+	} else {
+		seq_printf(m, "periodic\t: %ld.%02d seconds\n", 
+			     tv.tv_sec, (int)tv.tv_usec/1000);
+	}
+
+        seq_printf(m,
+                     "DST_enable\t: %s\n"
+                     "BCD\t\t: %s\n"
+                     "24hr\t\t: %s\n"
+                     "square_wave\t: %s\n"
+                     "alarm_IRQ\t: %s\n"
+                     "update_IRQ\t: %s\n"
+                     "periodic_IRQ\t: %s\n"
+		     "periodic_freq\t: %ld\n"
+                     "batt_status\t: %s\n",
+                     YN(RTC_DST_EN),
+                     NY(RTC_DM_BINARY),
+                     YN(RTC_24H),
+                     YN(RTC_SQWE),
+                     YN(RTC_AIE),
+                     YN(RTC_UIE),
+                     YN(RTC_PIE),
+                     1UL,
+                     1 ? "okay" : "dead");
+
+        return 0;
+#undef YN
+#undef NY
+}
+
+static int hp_sdc_rtc_proc_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, hp_sdc_rtc_proc_show, NULL);
+}
+
+static const struct file_operations hp_sdc_rtc_proc_fops = {
+	.open		= hp_sdc_rtc_proc_open,
+	.read		= seq_read,
+	.llseek		= seq_lseek,
+	.release	= single_release,
+};
+
+static int hp_sdc_rtc_ioctl(struct file *file, 
+			    unsigned int cmd, unsigned long arg)
+{
+#if 1
+	return -EINVAL;
+#else
+	
+        struct rtc_time wtime; 
+	struct timeval ttime;
+	int use_wtime = 0;
+
+	/* This needs major work. */
+
+        switch (cmd) {
+
+        case RTC_AIE_OFF:       /* Mask alarm int. enab. bit    */
+        case RTC_AIE_ON:        /* Allow alarm interrupts.      */
+	case RTC_PIE_OFF:       /* Mask periodic int. enab. bit */
+        case RTC_PIE_ON:        /* Allow periodic ints          */
+        case RTC_UIE_ON:        /* Allow ints for RTC updates.  */
+        case RTC_UIE_OFF:       /* Allow ints for RTC updates.  */
+        {
+		/* We cannot mask individual user timers and we
+		   cannot tell them apart when they occur, so it 
+		   would be disingenuous to succeed these IOCTLs */
+		return -EINVAL;
+        }
+        case RTC_ALM_READ:      /* Read the present alarm time */
+        {
+		if (hp_sdc_rtc_read_mt(&ttime)) return -EFAULT;
+		if (hp_sdc_rtc_read_bbrtc(&wtime)) return -EFAULT;
+
+		wtime.tm_hour = ttime.tv_sec / 3600;  ttime.tv_sec %= 3600;
+		wtime.tm_min  = ttime.tv_sec / 60;    ttime.tv_sec %= 60;
+		wtime.tm_sec  = ttime.tv_sec;
+                
+		break;
+        }
+        case RTC_IRQP_READ:     /* Read the periodic IRQ rate.  */
+        {
+                return put_user(hp_sdc_rtc_freq, (unsigned long *)arg);
+        }
+        case RTC_IRQP_SET:      /* Set periodic IRQ rate.       */
+        {
+                /* 
+                 * The max we can do is 100Hz.
+		 */
+
+                if ((arg < 1) || (arg > 100)) return -EINVAL;
+		ttime.tv_sec = 0;
+		ttime.tv_usec = 1000000 / arg;
+		if (hp_sdc_rtc_set_ct(&ttime)) return -EFAULT;
+		hp_sdc_rtc_freq = arg;
+                return 0;
+        }
+        case RTC_ALM_SET:       /* Store a time into the alarm */
+        {
+                /*
+                 * This expects a struct hp_sdc_rtc_time. Writing 0xff means
+                 * "don't care" or "match all" for PC timers.  The HP SDC
+		 * does not support that perk, but it could be emulated fairly
+		 * easily.  Only the tm_hour, tm_min and tm_sec are used.
+		 * We could do it with 10ms accuracy with the HP SDC, if the 
+		 * rtc interface left us a way to do that.
+                 */
+                struct hp_sdc_rtc_time alm_tm;
+
+                if (copy_from_user(&alm_tm, (struct hp_sdc_rtc_time*)arg,
+                                   sizeof(struct hp_sdc_rtc_time)))
+                       return -EFAULT;
+
+                if (alm_tm.tm_hour > 23) return -EINVAL;
+		if (alm_tm.tm_min  > 59) return -EINVAL;
+		if (alm_tm.tm_sec  > 59) return -EINVAL;  
+
+		ttime.sec = alm_tm.tm_hour * 3600 + 
+		  alm_tm.tm_min * 60 + alm_tm.tm_sec;
+		ttime.usec = 0;
+		if (hp_sdc_rtc_set_mt(&ttime)) return -EFAULT;
+                return 0;
+        }
+        case RTC_RD_TIME:       /* Read the time/date from RTC  */
+        {
+		if (hp_sdc_rtc_read_bbrtc(&wtime)) return -EFAULT;
+                break;
+        }
+        case RTC_SET_TIME:      /* Set the RTC */
+        {
+                struct rtc_time hp_sdc_rtc_tm;
+                unsigned char mon, day, hrs, min, sec, leap_yr;
+                unsigned int yrs;
+
+                if (!capable(CAP_SYS_TIME))
+                        return -EACCES;
+		if (copy_from_user(&hp_sdc_rtc_tm, (struct rtc_time *)arg,
+                                   sizeof(struct rtc_time)))
+                        return -EFAULT;
+
+                yrs = hp_sdc_rtc_tm.tm_year + 1900;
+                mon = hp_sdc_rtc_tm.tm_mon + 1;   /* tm_mon starts at zero */
+                day = hp_sdc_rtc_tm.tm_mday;
+                hrs = hp_sdc_rtc_tm.tm_hour;
+                min = hp_sdc_rtc_tm.tm_min;
+                sec = hp_sdc_rtc_tm.tm_sec;
+
+                if (yrs < 1970)
+                        return -EINVAL;
+
+                leap_yr = ((!(yrs % 4) && (yrs % 100)) || !(yrs % 400));
+
+                if ((mon > 12) || (day == 0))
+                        return -EINVAL;
+                if (day > (days_in_mo[mon] + ((mon == 2) && leap_yr)))
+                        return -EINVAL;
+		if ((hrs >= 24) || (min >= 60) || (sec >= 60))
+                        return -EINVAL;
+
+                if ((yrs -= eH) > 255)    /* They are unsigned */
+                        return -EINVAL;
+
+
+                return 0;
+        }
+        case RTC_EPOCH_READ:    /* Read the epoch.      */
+        {
+                return put_user (epoch, (unsigned long *)arg);
+        }
+        case RTC_EPOCH_SET:     /* Set the epoch.       */
+        {
+                /* 
+                 * There were no RTC clocks before 1900.
+                 */
+                if (arg < 1900)
+		  return -EINVAL;
+		if (!capable(CAP_SYS_TIME))
+		  return -EACCES;
+		
+                epoch = arg;
+                return 0;
+        }
+        default:
+                return -EINVAL;
+        }
+        return copy_to_user((void *)arg, &wtime, sizeof wtime) ? -EFAULT : 0;
+#endif
+}
+
+static long hp_sdc_rtc_unlocked_ioctl(struct file *file,
+				      unsigned int cmd, unsigned long arg)
+{
+	int ret;
+
+	mutex_lock(&hp_sdc_rtc_mutex);
+	ret = hp_sdc_rtc_ioctl(file, cmd, arg);
+	mutex_unlock(&hp_sdc_rtc_mutex);
+
+	return ret;
+}
+
+
+static const struct file_operations hp_sdc_rtc_fops = {
+        .owner =		THIS_MODULE,
+        .llseek =		no_llseek,
+        .read =			hp_sdc_rtc_read,
+        .poll =			hp_sdc_rtc_poll,
+        .unlocked_ioctl =	hp_sdc_rtc_unlocked_ioctl,
+        .open =			hp_sdc_rtc_open,
+        .fasync =		hp_sdc_rtc_fasync,
+};
+
+static struct miscdevice hp_sdc_rtc_dev = {
+        .minor =	RTC_MINOR,
+        .name =		"rtc_HIL",
+        .fops =		&hp_sdc_rtc_fops
+};
+
+static int __init hp_sdc_rtc_init(void)
+{
+	int ret;
+
+#ifdef __mc68000__
+	if (!MACH_IS_HP300)
+		return -ENODEV;
+#endif
+
+	sema_init(&i8042tregs, 1);
+
+	if ((ret = hp_sdc_request_timer_irq(&hp_sdc_rtc_isr)))
+		return ret;
+	if (misc_register(&hp_sdc_rtc_dev) != 0)
+		printk(KERN_INFO "Could not register misc. dev for i8042 rtc\n");
+
+        proc_create("driver/rtc", 0, NULL, &hp_sdc_rtc_proc_fops);
+
+	printk(KERN_INFO "HP i8042 SDC + MSM-58321 RTC support loaded "
+			 "(RTC v " RTC_VERSION ")\n");
+
+	return 0;
+}
+
+static void __exit hp_sdc_rtc_exit(void)
+{
+	remove_proc_entry ("driver/rtc", NULL);
+        misc_deregister(&hp_sdc_rtc_dev);
+	hp_sdc_release_timer_irq(hp_sdc_rtc_isr);
+        printk(KERN_INFO "HP i8042 SDC + MSM-58321 RTC support unloaded\n");
+}
+
+module_init(hp_sdc_rtc_init);
+module_exit(hp_sdc_rtc_exit);
diff --git a/drivers/input/misc/ims-pcu.c b/drivers/input/misc/ims-pcu.c
new file mode 100644
index 00000000..e204f26b
--- /dev/null
+++ b/drivers/input/misc/ims-pcu.c
@@ -0,0 +1,1901 @@
+/*
+ * Driver for IMS Passenger Control Unit Devices
+ *
+ * Copyright (C) 2013 The IMS Company
+ *
+ * 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/completion.h>
+#include <linux/device.h>
+#include <linux/firmware.h>
+#include <linux/ihex.h>
+#include <linux/input.h>
+#include <linux/kernel.h>
+#include <linux/leds.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+#include <linux/usb/input.h>
+#include <linux/usb/cdc.h>
+#include <asm/unaligned.h>
+
+#define IMS_PCU_KEYMAP_LEN		32
+
+struct ims_pcu_buttons {
+	struct input_dev *input;
+	char name[32];
+	char phys[32];
+	unsigned short keymap[IMS_PCU_KEYMAP_LEN];
+};
+
+struct ims_pcu_gamepad {
+	struct input_dev *input;
+	char name[32];
+	char phys[32];
+};
+
+struct ims_pcu_backlight {
+	struct led_classdev cdev;
+	struct work_struct work;
+	enum led_brightness desired_brightness;
+	char name[32];
+};
+
+#define IMS_PCU_PART_NUMBER_LEN		15
+#define IMS_PCU_SERIAL_NUMBER_LEN	8
+#define IMS_PCU_DOM_LEN			8
+#define IMS_PCU_FW_VERSION_LEN		(9 + 1)
+#define IMS_PCU_BL_VERSION_LEN		(9 + 1)
+#define IMS_PCU_BL_RESET_REASON_LEN	(2 + 1)
+
+#define IMS_PCU_BUF_SIZE		128
+
+struct ims_pcu {
+	struct usb_device *udev;
+	struct device *dev; /* control interface's device, used for logging */
+
+	unsigned int device_no;
+
+	bool bootloader_mode;
+
+	char part_number[IMS_PCU_PART_NUMBER_LEN];
+	char serial_number[IMS_PCU_SERIAL_NUMBER_LEN];
+	char date_of_manufacturing[IMS_PCU_DOM_LEN];
+	char fw_version[IMS_PCU_FW_VERSION_LEN];
+	char bl_version[IMS_PCU_BL_VERSION_LEN];
+	char reset_reason[IMS_PCU_BL_RESET_REASON_LEN];
+	int update_firmware_status;
+
+	struct usb_interface *ctrl_intf;
+
+	struct usb_endpoint_descriptor *ep_ctrl;
+	struct urb *urb_ctrl;
+	u8 *urb_ctrl_buf;
+	dma_addr_t ctrl_dma;
+	size_t max_ctrl_size;
+
+	struct usb_interface *data_intf;
+
+	struct usb_endpoint_descriptor *ep_in;
+	struct urb *urb_in;
+	u8 *urb_in_buf;
+	dma_addr_t read_dma;
+	size_t max_in_size;
+
+	struct usb_endpoint_descriptor *ep_out;
+	u8 *urb_out_buf;
+	size_t max_out_size;
+
+	u8 read_buf[IMS_PCU_BUF_SIZE];
+	u8 read_pos;
+	u8 check_sum;
+	bool have_stx;
+	bool have_dle;
+
+	u8 cmd_buf[IMS_PCU_BUF_SIZE];
+	u8 ack_id;
+	u8 expected_response;
+	u8 cmd_buf_len;
+	struct completion cmd_done;
+	struct mutex cmd_mutex;
+
+	u32 fw_start_addr;
+	u32 fw_end_addr;
+	struct completion async_firmware_done;
+
+	struct ims_pcu_buttons buttons;
+	struct ims_pcu_gamepad *gamepad;
+	struct ims_pcu_backlight backlight;
+
+	bool setup_complete; /* Input and LED devices have been created */
+};
+
+
+/*********************************************************************
+ *             Buttons Input device support                          *
+ *********************************************************************/
+
+static const unsigned short ims_pcu_keymap_1[] = {
+	[1] = KEY_ATTENDANT_OFF,
+	[2] = KEY_ATTENDANT_ON,
+	[3] = KEY_LIGHTS_TOGGLE,
+	[4] = KEY_VOLUMEUP,
+	[5] = KEY_VOLUMEDOWN,
+	[6] = KEY_INFO,
+};
+
+static const unsigned short ims_pcu_keymap_2[] = {
+	[4] = KEY_VOLUMEUP,
+	[5] = KEY_VOLUMEDOWN,
+	[6] = KEY_INFO,
+};
+
+static const unsigned short ims_pcu_keymap_3[] = {
+	[1] = KEY_HOMEPAGE,
+	[2] = KEY_ATTENDANT_TOGGLE,
+	[3] = KEY_LIGHTS_TOGGLE,
+	[4] = KEY_VOLUMEUP,
+	[5] = KEY_VOLUMEDOWN,
+	[6] = KEY_DISPLAYTOGGLE,
+	[18] = KEY_PLAYPAUSE,
+};
+
+static const unsigned short ims_pcu_keymap_4[] = {
+	[1] = KEY_ATTENDANT_OFF,
+	[2] = KEY_ATTENDANT_ON,
+	[3] = KEY_LIGHTS_TOGGLE,
+	[4] = KEY_VOLUMEUP,
+	[5] = KEY_VOLUMEDOWN,
+	[6] = KEY_INFO,
+	[18] = KEY_PLAYPAUSE,
+};
+
+static const unsigned short ims_pcu_keymap_5[] = {
+	[1] = KEY_ATTENDANT_OFF,
+	[2] = KEY_ATTENDANT_ON,
+	[3] = KEY_LIGHTS_TOGGLE,
+};
+
+struct ims_pcu_device_info {
+	const unsigned short *keymap;
+	size_t keymap_len;
+	bool has_gamepad;
+};
+
+#define IMS_PCU_DEVINFO(_n, _gamepad)				\
+	[_n] = {						\
+		.keymap = ims_pcu_keymap_##_n,			\
+		.keymap_len = ARRAY_SIZE(ims_pcu_keymap_##_n),	\
+		.has_gamepad = _gamepad,			\
+	}
+
+static const struct ims_pcu_device_info ims_pcu_device_info[] = {
+	IMS_PCU_DEVINFO(1, true),
+	IMS_PCU_DEVINFO(2, true),
+	IMS_PCU_DEVINFO(3, true),
+	IMS_PCU_DEVINFO(4, true),
+	IMS_PCU_DEVINFO(5, false),
+};
+
+static void ims_pcu_buttons_report(struct ims_pcu *pcu, u32 data)
+{
+	struct ims_pcu_buttons *buttons = &pcu->buttons;
+	struct input_dev *input = buttons->input;
+	int i;
+
+	for (i = 0; i < 32; i++) {
+		unsigned short keycode = buttons->keymap[i];
+
+		if (keycode != KEY_RESERVED)
+			input_report_key(input, keycode, data & (1UL << i));
+	}
+
+	input_sync(input);
+}
+
+static int ims_pcu_setup_buttons(struct ims_pcu *pcu,
+				 const unsigned short *keymap,
+				 size_t keymap_len)
+{
+	struct ims_pcu_buttons *buttons = &pcu->buttons;
+	struct input_dev *input;
+	int i;
+	int error;
+
+	input = input_allocate_device();
+	if (!input) {
+		dev_err(pcu->dev,
+			"Not enough memory for input input device\n");
+		return -ENOMEM;
+	}
+
+	snprintf(buttons->name, sizeof(buttons->name),
+		 "IMS PCU#%d Button Interface", pcu->device_no);
+
+	usb_make_path(pcu->udev, buttons->phys, sizeof(buttons->phys));
+	strlcat(buttons->phys, "/input0", sizeof(buttons->phys));
+
+	memcpy(buttons->keymap, keymap, sizeof(*keymap) * keymap_len);
+
+	input->name = buttons->name;
+	input->phys = buttons->phys;
+	usb_to_input_id(pcu->udev, &input->id);
+	input->dev.parent = &pcu->ctrl_intf->dev;
+
+	input->keycode = buttons->keymap;
+	input->keycodemax = ARRAY_SIZE(buttons->keymap);
+	input->keycodesize = sizeof(buttons->keymap[0]);
+
+	__set_bit(EV_KEY, input->evbit);
+	for (i = 0; i < IMS_PCU_KEYMAP_LEN; i++)
+		__set_bit(buttons->keymap[i], input->keybit);
+	__clear_bit(KEY_RESERVED, input->keybit);
+
+	error = input_register_device(input);
+	if (error) {
+		dev_err(pcu->dev,
+			"Failed to register buttons input device: %d\n",
+			error);
+		input_free_device(input);
+		return error;
+	}
+
+	buttons->input = input;
+	return 0;
+}
+
+static void ims_pcu_destroy_buttons(struct ims_pcu *pcu)
+{
+	struct ims_pcu_buttons *buttons = &pcu->buttons;
+
+	input_unregister_device(buttons->input);
+}
+
+
+/*********************************************************************
+ *             Gamepad Input device support                          *
+ *********************************************************************/
+
+static void ims_pcu_gamepad_report(struct ims_pcu *pcu, u32 data)
+{
+	struct ims_pcu_gamepad *gamepad = pcu->gamepad;
+	struct input_dev *input = gamepad->input;
+	int x, y;
+
+	x = !!(data & (1 << 14)) - !!(data & (1 << 13));
+	y = !!(data & (1 << 12)) - !!(data & (1 << 11));
+
+	input_report_abs(input, ABS_X, x);
+	input_report_abs(input, ABS_Y, y);
+
+	input_report_key(input, BTN_A, data & (1 << 7));
+	input_report_key(input, BTN_B, data & (1 << 8));
+	input_report_key(input, BTN_X, data & (1 << 9));
+	input_report_key(input, BTN_Y, data & (1 << 10));
+	input_report_key(input, BTN_START, data & (1 << 15));
+	input_report_key(input, BTN_SELECT, data & (1 << 16));
+
+	input_sync(input);
+}
+
+static int ims_pcu_setup_gamepad(struct ims_pcu *pcu)
+{
+	struct ims_pcu_gamepad *gamepad;
+	struct input_dev *input;
+	int error;
+
+	gamepad = kzalloc(sizeof(struct ims_pcu_gamepad), GFP_KERNEL);
+	input = input_allocate_device();
+	if (!gamepad || !input) {
+		dev_err(pcu->dev,
+			"Not enough memory for gamepad device\n");
+		error = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	gamepad->input = input;
+
+	snprintf(gamepad->name, sizeof(gamepad->name),
+		 "IMS PCU#%d Gamepad Interface", pcu->device_no);
+
+	usb_make_path(pcu->udev, gamepad->phys, sizeof(gamepad->phys));
+	strlcat(gamepad->phys, "/input1", sizeof(gamepad->phys));
+
+	input->name = gamepad->name;
+	input->phys = gamepad->phys;
+	usb_to_input_id(pcu->udev, &input->id);
+	input->dev.parent = &pcu->ctrl_intf->dev;
+
+	__set_bit(EV_KEY, input->evbit);
+	__set_bit(BTN_A, input->keybit);
+	__set_bit(BTN_B, input->keybit);
+	__set_bit(BTN_X, input->keybit);
+	__set_bit(BTN_Y, input->keybit);
+	__set_bit(BTN_START, input->keybit);
+	__set_bit(BTN_SELECT, input->keybit);
+
+	__set_bit(EV_ABS, input->evbit);
+	input_set_abs_params(input, ABS_X, -1, 1, 0, 0);
+	input_set_abs_params(input, ABS_Y, -1, 1, 0, 0);
+
+	error = input_register_device(input);
+	if (error) {
+		dev_err(pcu->dev,
+			"Failed to register gamepad input device: %d\n",
+			error);
+		goto err_free_mem;
+	}
+
+	pcu->gamepad = gamepad;
+	return 0;
+
+err_free_mem:
+	input_free_device(input);
+	kfree(gamepad);
+	return -ENOMEM;
+}
+
+static void ims_pcu_destroy_gamepad(struct ims_pcu *pcu)
+{
+	struct ims_pcu_gamepad *gamepad = pcu->gamepad;
+
+	input_unregister_device(gamepad->input);
+	kfree(gamepad);
+}
+
+
+/*********************************************************************
+ *             PCU Communication protocol handling                   *
+ *********************************************************************/
+
+#define IMS_PCU_PROTOCOL_STX		0x02
+#define IMS_PCU_PROTOCOL_ETX		0x03
+#define IMS_PCU_PROTOCOL_DLE		0x10
+
+/* PCU commands */
+#define IMS_PCU_CMD_STATUS		0xa0
+#define IMS_PCU_CMD_PCU_RESET		0xa1
+#define IMS_PCU_CMD_RESET_REASON	0xa2
+#define IMS_PCU_CMD_SEND_BUTTONS	0xa3
+#define IMS_PCU_CMD_JUMP_TO_BTLDR	0xa4
+#define IMS_PCU_CMD_GET_INFO		0xa5
+#define IMS_PCU_CMD_SET_BRIGHTNESS	0xa6
+#define IMS_PCU_CMD_EEPROM		0xa7
+#define IMS_PCU_CMD_GET_FW_VERSION	0xa8
+#define IMS_PCU_CMD_GET_BL_VERSION	0xa9
+#define IMS_PCU_CMD_SET_INFO		0xab
+#define IMS_PCU_CMD_GET_BRIGHTNESS	0xac
+#define IMS_PCU_CMD_GET_DEVICE_ID	0xae
+#define IMS_PCU_CMD_SPECIAL_INFO	0xb0
+#define IMS_PCU_CMD_BOOTLOADER		0xb1	/* Pass data to bootloader */
+
+/* PCU responses */
+#define IMS_PCU_RSP_STATUS		0xc0
+#define IMS_PCU_RSP_PCU_RESET		0	/* Originally 0xc1 */
+#define IMS_PCU_RSP_RESET_REASON	0xc2
+#define IMS_PCU_RSP_SEND_BUTTONS	0xc3
+#define IMS_PCU_RSP_JUMP_TO_BTLDR	0	/* Originally 0xc4 */
+#define IMS_PCU_RSP_GET_INFO		0xc5
+#define IMS_PCU_RSP_SET_BRIGHTNESS	0xc6
+#define IMS_PCU_RSP_EEPROM		0xc7
+#define IMS_PCU_RSP_GET_FW_VERSION	0xc8
+#define IMS_PCU_RSP_GET_BL_VERSION	0xc9
+#define IMS_PCU_RSP_SET_INFO		0xcb
+#define IMS_PCU_RSP_GET_BRIGHTNESS	0xcc
+#define IMS_PCU_RSP_CMD_INVALID		0xcd
+#define IMS_PCU_RSP_GET_DEVICE_ID	0xce
+#define IMS_PCU_RSP_SPECIAL_INFO	0xd0
+#define IMS_PCU_RSP_BOOTLOADER		0xd1	/* Bootloader response */
+
+#define IMS_PCU_RSP_EVNT_BUTTONS	0xe0	/* Unsolicited, button state */
+#define IMS_PCU_GAMEPAD_MASK		0x0001ff80UL	/* Bits 7 through 16 */
+
+
+#define IMS_PCU_MIN_PACKET_LEN		3
+#define IMS_PCU_DATA_OFFSET		2
+
+#define IMS_PCU_CMD_WRITE_TIMEOUT	100 /* msec */
+#define IMS_PCU_CMD_RESPONSE_TIMEOUT	500 /* msec */
+
+static void ims_pcu_report_events(struct ims_pcu *pcu)
+{
+	u32 data = get_unaligned_be32(&pcu->read_buf[3]);
+
+	ims_pcu_buttons_report(pcu, data & ~IMS_PCU_GAMEPAD_MASK);
+	if (pcu->gamepad)
+		ims_pcu_gamepad_report(pcu, data);
+}
+
+static void ims_pcu_handle_response(struct ims_pcu *pcu)
+{
+	switch (pcu->read_buf[0]) {
+	case IMS_PCU_RSP_EVNT_BUTTONS:
+		if (likely(pcu->setup_complete))
+			ims_pcu_report_events(pcu);
+		break;
+
+	default:
+		/*
+		 * See if we got command completion.
+		 * If both the sequence and response code match save
+		 * the data and signal completion.
+		 */
+		if (pcu->read_buf[0] == pcu->expected_response &&
+		    pcu->read_buf[1] == pcu->ack_id - 1) {
+
+			memcpy(pcu->cmd_buf, pcu->read_buf, pcu->read_pos);
+			pcu->cmd_buf_len = pcu->read_pos;
+			complete(&pcu->cmd_done);
+		}
+		break;
+	}
+}
+
+static void ims_pcu_process_data(struct ims_pcu *pcu, struct urb *urb)
+{
+	int i;
+
+	for (i = 0; i < urb->actual_length; i++) {
+		u8 data = pcu->urb_in_buf[i];
+
+		/* Skip everything until we get Start Xmit */
+		if (!pcu->have_stx && data != IMS_PCU_PROTOCOL_STX)
+			continue;
+
+		if (pcu->have_dle) {
+			pcu->have_dle = false;
+			pcu->read_buf[pcu->read_pos++] = data;
+			pcu->check_sum += data;
+			continue;
+		}
+
+		switch (data) {
+		case IMS_PCU_PROTOCOL_STX:
+			if (pcu->have_stx)
+				dev_warn(pcu->dev,
+					 "Unexpected STX at byte %d, discarding old data\n",
+					 pcu->read_pos);
+			pcu->have_stx = true;
+			pcu->have_dle = false;
+			pcu->read_pos = 0;
+			pcu->check_sum = 0;
+			break;
+
+		case IMS_PCU_PROTOCOL_DLE:
+			pcu->have_dle = true;
+			break;
+
+		case IMS_PCU_PROTOCOL_ETX:
+			if (pcu->read_pos < IMS_PCU_MIN_PACKET_LEN) {
+				dev_warn(pcu->dev,
+					 "Short packet received (%d bytes), ignoring\n",
+					 pcu->read_pos);
+			} else if (pcu->check_sum != 0) {
+				dev_warn(pcu->dev,
+					 "Invalid checksum in packet (%d bytes), ignoring\n",
+					 pcu->read_pos);
+			} else {
+				ims_pcu_handle_response(pcu);
+			}
+
+			pcu->have_stx = false;
+			pcu->have_dle = false;
+			pcu->read_pos = 0;
+			break;
+
+		default:
+			pcu->read_buf[pcu->read_pos++] = data;
+			pcu->check_sum += data;
+			break;
+		}
+	}
+}
+
+static bool ims_pcu_byte_needs_escape(u8 byte)
+{
+	return byte == IMS_PCU_PROTOCOL_STX ||
+	       byte == IMS_PCU_PROTOCOL_ETX ||
+	       byte == IMS_PCU_PROTOCOL_DLE;
+}
+
+static int ims_pcu_send_cmd_chunk(struct ims_pcu *pcu,
+				  u8 command, int chunk, int len)
+{
+	int error;
+
+	error = usb_bulk_msg(pcu->udev,
+			     usb_sndbulkpipe(pcu->udev,
+					     pcu->ep_out->bEndpointAddress),
+			     pcu->urb_out_buf, len,
+			     NULL, IMS_PCU_CMD_WRITE_TIMEOUT);
+	if (error < 0) {
+		dev_dbg(pcu->dev,
+			"Sending 0x%02x command failed at chunk %d: %d\n",
+			command, chunk, error);
+		return error;
+	}
+
+	return 0;
+}
+
+static int ims_pcu_send_command(struct ims_pcu *pcu,
+				u8 command, const u8 *data, int len)
+{
+	int count = 0;
+	int chunk = 0;
+	int delta;
+	int i;
+	int error;
+	u8 csum = 0;
+	u8 ack_id;
+
+	pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_STX;
+
+	/* We know the command need not be escaped */
+	pcu->urb_out_buf[count++] = command;
+	csum += command;
+
+	ack_id = pcu->ack_id++;
+	if (ack_id == 0xff)
+		ack_id = pcu->ack_id++;
+
+	if (ims_pcu_byte_needs_escape(ack_id))
+		pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE;
+
+	pcu->urb_out_buf[count++] = ack_id;
+	csum += ack_id;
+
+	for (i = 0; i < len; i++) {
+
+		delta = ims_pcu_byte_needs_escape(data[i]) ? 2 : 1;
+		if (count + delta >= pcu->max_out_size) {
+			error = ims_pcu_send_cmd_chunk(pcu, command,
+						       ++chunk, count);
+			if (error)
+				return error;
+
+			count = 0;
+		}
+
+		if (delta == 2)
+			pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE;
+
+		pcu->urb_out_buf[count++] = data[i];
+		csum += data[i];
+	}
+
+	csum = 1 + ~csum;
+
+	delta = ims_pcu_byte_needs_escape(csum) ? 3 : 2;
+	if (count + delta >= pcu->max_out_size) {
+		error = ims_pcu_send_cmd_chunk(pcu, command, ++chunk, count);
+		if (error)
+			return error;
+
+		count = 0;
+	}
+
+	if (delta == 3)
+		pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_DLE;
+
+	pcu->urb_out_buf[count++] = csum;
+	pcu->urb_out_buf[count++] = IMS_PCU_PROTOCOL_ETX;
+
+	return ims_pcu_send_cmd_chunk(pcu, command, ++chunk, count);
+}
+
+static int __ims_pcu_execute_command(struct ims_pcu *pcu,
+				     u8 command, const void *data, size_t len,
+				     u8 expected_response, int response_time)
+{
+	int error;
+
+	pcu->expected_response = expected_response;
+	init_completion(&pcu->cmd_done);
+
+	error = ims_pcu_send_command(pcu, command, data, len);
+	if (error)
+		return error;
+
+	if (expected_response &&
+	    !wait_for_completion_timeout(&pcu->cmd_done,
+					 msecs_to_jiffies(response_time))) {
+		dev_dbg(pcu->dev, "Command 0x%02x timed out\n", command);
+		return -ETIMEDOUT;
+	}
+
+	return 0;
+}
+
+#define ims_pcu_execute_command(pcu, code, data, len)			\
+	__ims_pcu_execute_command(pcu,					\
+				  IMS_PCU_CMD_##code, data, len,	\
+				  IMS_PCU_RSP_##code,			\
+				  IMS_PCU_CMD_RESPONSE_TIMEOUT)
+
+#define ims_pcu_execute_query(pcu, code)				\
+	ims_pcu_execute_command(pcu, code, NULL, 0)
+
+/* Bootloader commands */
+#define IMS_PCU_BL_CMD_QUERY_DEVICE	0xa1
+#define IMS_PCU_BL_CMD_UNLOCK_CONFIG	0xa2
+#define IMS_PCU_BL_CMD_ERASE_APP	0xa3
+#define IMS_PCU_BL_CMD_PROGRAM_DEVICE	0xa4
+#define IMS_PCU_BL_CMD_PROGRAM_COMPLETE	0xa5
+#define IMS_PCU_BL_CMD_READ_APP		0xa6
+#define IMS_PCU_BL_CMD_RESET_DEVICE	0xa7
+#define IMS_PCU_BL_CMD_LAUNCH_APP	0xa8
+
+/* Bootloader commands */
+#define IMS_PCU_BL_RSP_QUERY_DEVICE	0xc1
+#define IMS_PCU_BL_RSP_UNLOCK_CONFIG	0xc2
+#define IMS_PCU_BL_RSP_ERASE_APP	0xc3
+#define IMS_PCU_BL_RSP_PROGRAM_DEVICE	0xc4
+#define IMS_PCU_BL_RSP_PROGRAM_COMPLETE	0xc5
+#define IMS_PCU_BL_RSP_READ_APP		0xc6
+#define IMS_PCU_BL_RSP_RESET_DEVICE	0	/* originally 0xa7 */
+#define IMS_PCU_BL_RSP_LAUNCH_APP	0	/* originally 0xa8 */
+
+#define IMS_PCU_BL_DATA_OFFSET		3
+
+static int __ims_pcu_execute_bl_command(struct ims_pcu *pcu,
+				        u8 command, const void *data, size_t len,
+				        u8 expected_response, int response_time)
+{
+	int error;
+
+	pcu->cmd_buf[0] = command;
+	if (data)
+		memcpy(&pcu->cmd_buf[1], data, len);
+
+	error = __ims_pcu_execute_command(pcu,
+				IMS_PCU_CMD_BOOTLOADER, pcu->cmd_buf, len + 1,
+				expected_response ? IMS_PCU_RSP_BOOTLOADER : 0,
+				response_time);
+	if (error) {
+		dev_err(pcu->dev,
+			"Failure when sending 0x%02x command to bootloader, error: %d\n",
+			pcu->cmd_buf[0], error);
+		return error;
+	}
+
+	if (expected_response && pcu->cmd_buf[2] != expected_response) {
+		dev_err(pcu->dev,
+			"Unexpected response from bootloader: 0x%02x, wanted 0x%02x\n",
+			pcu->cmd_buf[2], expected_response);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+#define ims_pcu_execute_bl_command(pcu, code, data, len, timeout)	\
+	__ims_pcu_execute_bl_command(pcu,				\
+				     IMS_PCU_BL_CMD_##code, data, len,	\
+				     IMS_PCU_BL_RSP_##code, timeout)	\
+
+#define IMS_PCU_INFO_PART_OFFSET	2
+#define IMS_PCU_INFO_DOM_OFFSET		17
+#define IMS_PCU_INFO_SERIAL_OFFSET	25
+
+#define IMS_PCU_SET_INFO_SIZE		31
+
+static int ims_pcu_get_info(struct ims_pcu *pcu)
+{
+	int error;
+
+	error = ims_pcu_execute_query(pcu, GET_INFO);
+	if (error) {
+		dev_err(pcu->dev,
+			"GET_INFO command failed, error: %d\n", error);
+		return error;
+	}
+
+	memcpy(pcu->part_number,
+	       &pcu->cmd_buf[IMS_PCU_INFO_PART_OFFSET],
+	       sizeof(pcu->part_number));
+	memcpy(pcu->date_of_manufacturing,
+	       &pcu->cmd_buf[IMS_PCU_INFO_DOM_OFFSET],
+	       sizeof(pcu->date_of_manufacturing));
+	memcpy(pcu->serial_number,
+	       &pcu->cmd_buf[IMS_PCU_INFO_SERIAL_OFFSET],
+	       sizeof(pcu->serial_number));
+
+	return 0;
+}
+
+static int ims_pcu_set_info(struct ims_pcu *pcu)
+{
+	int error;
+
+	memcpy(&pcu->cmd_buf[IMS_PCU_INFO_PART_OFFSET],
+	       pcu->part_number, sizeof(pcu->part_number));
+	memcpy(&pcu->cmd_buf[IMS_PCU_INFO_DOM_OFFSET],
+	       pcu->date_of_manufacturing, sizeof(pcu->date_of_manufacturing));
+	memcpy(&pcu->cmd_buf[IMS_PCU_INFO_SERIAL_OFFSET],
+	       pcu->serial_number, sizeof(pcu->serial_number));
+
+	error = ims_pcu_execute_command(pcu, SET_INFO,
+					&pcu->cmd_buf[IMS_PCU_DATA_OFFSET],
+					IMS_PCU_SET_INFO_SIZE);
+	if (error) {
+		dev_err(pcu->dev,
+			"Failed to update device information, error: %d\n",
+			error);
+		return error;
+	}
+
+	return 0;
+}
+
+static int ims_pcu_switch_to_bootloader(struct ims_pcu *pcu)
+{
+	int error;
+
+	/* Execute jump to the bootoloader */
+	error = ims_pcu_execute_command(pcu, JUMP_TO_BTLDR, NULL, 0);
+	if (error) {
+		dev_err(pcu->dev,
+			"Failure when sending JUMP TO BOOLTLOADER command, error: %d\n",
+			error);
+		return error;
+	}
+
+	return 0;
+}
+
+/*********************************************************************
+ *             Firmware Update handling                              *
+ *********************************************************************/
+
+#define IMS_PCU_FIRMWARE_NAME	"imspcu.fw"
+
+struct ims_pcu_flash_fmt {
+	__le32 addr;
+	u8 len;
+	u8 data[];
+};
+
+static unsigned int ims_pcu_count_fw_records(const struct firmware *fw)
+{
+	const struct ihex_binrec *rec = (const struct ihex_binrec *)fw->data;
+	unsigned int count = 0;
+
+	while (rec) {
+		count++;
+		rec = ihex_next_binrec(rec);
+	}
+
+	return count;
+}
+
+static int ims_pcu_verify_block(struct ims_pcu *pcu,
+				u32 addr, u8 len, const u8 *data)
+{
+	struct ims_pcu_flash_fmt *fragment;
+	int error;
+
+	fragment = (void *)&pcu->cmd_buf[1];
+	put_unaligned_le32(addr, &fragment->addr);
+	fragment->len = len;
+
+	error = ims_pcu_execute_bl_command(pcu, READ_APP, NULL, 5,
+					IMS_PCU_CMD_RESPONSE_TIMEOUT);
+	if (error) {
+		dev_err(pcu->dev,
+			"Failed to retrieve block at 0x%08x, len %d, error: %d\n",
+			addr, len, error);
+		return error;
+	}
+
+	fragment = (void *)&pcu->cmd_buf[IMS_PCU_BL_DATA_OFFSET];
+	if (get_unaligned_le32(&fragment->addr) != addr ||
+	    fragment->len != len) {
+		dev_err(pcu->dev,
+			"Wrong block when retrieving 0x%08x (0x%08x), len %d (%d)\n",
+			addr, get_unaligned_le32(&fragment->addr),
+			len, fragment->len);
+		return -EINVAL;
+	}
+
+	if (memcmp(fragment->data, data, len)) {
+		dev_err(pcu->dev,
+			"Mismatch in block at 0x%08x, len %d\n",
+			addr, len);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int ims_pcu_flash_firmware(struct ims_pcu *pcu,
+				  const struct firmware *fw,
+				  unsigned int n_fw_records)
+{
+	const struct ihex_binrec *rec = (const struct ihex_binrec *)fw->data;
+	struct ims_pcu_flash_fmt *fragment;
+	unsigned int count = 0;
+	u32 addr;
+	u8 len;
+	int error;
+
+	error = ims_pcu_execute_bl_command(pcu, ERASE_APP, NULL, 0, 2000);
+	if (error) {
+		dev_err(pcu->dev,
+			"Failed to erase application image, error: %d\n",
+			error);
+		return error;
+	}
+
+	while (rec) {
+		/*
+		 * The firmware format is messed up for some reason.
+		 * The address twice that of what is needed for some
+		 * reason and we end up overwriting half of the data
+		 * with the next record.
+		 */
+		addr = be32_to_cpu(rec->addr) / 2;
+		len = be16_to_cpu(rec->len);
+
+		fragment = (void *)&pcu->cmd_buf[1];
+		put_unaligned_le32(addr, &fragment->addr);
+		fragment->len = len;
+		memcpy(fragment->data, rec->data, len);
+
+		error = ims_pcu_execute_bl_command(pcu, PROGRAM_DEVICE,
+						NULL, len + 5,
+						IMS_PCU_CMD_RESPONSE_TIMEOUT);
+		if (error) {
+			dev_err(pcu->dev,
+				"Failed to write block at 0x%08x, len %d, error: %d\n",
+				addr, len, error);
+			return error;
+		}
+
+		if (addr >= pcu->fw_start_addr && addr < pcu->fw_end_addr) {
+			error = ims_pcu_verify_block(pcu, addr, len, rec->data);
+			if (error)
+				return error;
+		}
+
+		count++;
+		pcu->update_firmware_status = (count * 100) / n_fw_records;
+
+		rec = ihex_next_binrec(rec);
+	}
+
+	error = ims_pcu_execute_bl_command(pcu, PROGRAM_COMPLETE,
+					    NULL, 0, 2000);
+	if (error)
+		dev_err(pcu->dev,
+			"Failed to send PROGRAM_COMPLETE, error: %d\n",
+			error);
+
+	return 0;
+}
+
+static int ims_pcu_handle_firmware_update(struct ims_pcu *pcu,
+					  const struct firmware *fw)
+{
+	unsigned int n_fw_records;
+	int retval;
+
+	dev_info(pcu->dev, "Updating firmware %s, size: %zu\n",
+		 IMS_PCU_FIRMWARE_NAME, fw->size);
+
+	n_fw_records = ims_pcu_count_fw_records(fw);
+
+	retval = ims_pcu_flash_firmware(pcu, fw, n_fw_records);
+	if (retval)
+		goto out;
+
+	retval = ims_pcu_execute_bl_command(pcu, LAUNCH_APP, NULL, 0, 0);
+	if (retval)
+		dev_err(pcu->dev,
+			"Failed to start application image, error: %d\n",
+			retval);
+
+out:
+	pcu->update_firmware_status = retval;
+	sysfs_notify(&pcu->dev->kobj, NULL, "update_firmware_status");
+	return retval;
+}
+
+static void ims_pcu_process_async_firmware(const struct firmware *fw,
+					   void *context)
+{
+	struct ims_pcu *pcu = context;
+	int error;
+
+	if (!fw) {
+		dev_err(pcu->dev, "Failed to get firmware %s\n",
+			IMS_PCU_FIRMWARE_NAME);
+		goto out;
+	}
+
+	error = ihex_validate_fw(fw);
+	if (error) {
+		dev_err(pcu->dev, "Firmware %s is invalid\n",
+			IMS_PCU_FIRMWARE_NAME);
+		goto out;
+	}
+
+	mutex_lock(&pcu->cmd_mutex);
+	ims_pcu_handle_firmware_update(pcu, fw);
+	mutex_unlock(&pcu->cmd_mutex);
+
+	release_firmware(fw);
+
+out:
+	complete(&pcu->async_firmware_done);
+}
+
+/*********************************************************************
+ *             Backlight LED device support                          *
+ *********************************************************************/
+
+#define IMS_PCU_MAX_BRIGHTNESS		31998
+
+static void ims_pcu_backlight_work(struct work_struct *work)
+{
+	struct ims_pcu_backlight *backlight =
+			container_of(work, struct ims_pcu_backlight, work);
+	struct ims_pcu *pcu =
+			container_of(backlight, struct ims_pcu, backlight);
+	int desired_brightness = backlight->desired_brightness;
+	__le16 br_val = cpu_to_le16(desired_brightness);
+	int error;
+
+	mutex_lock(&pcu->cmd_mutex);
+
+	error = ims_pcu_execute_command(pcu, SET_BRIGHTNESS,
+					&br_val, sizeof(br_val));
+	if (error && error != -ENODEV)
+		dev_warn(pcu->dev,
+			 "Failed to set desired brightness %u, error: %d\n",
+			 desired_brightness, error);
+
+	mutex_unlock(&pcu->cmd_mutex);
+}
+
+static void ims_pcu_backlight_set_brightness(struct led_classdev *cdev,
+					     enum led_brightness value)
+{
+	struct ims_pcu_backlight *backlight =
+			container_of(cdev, struct ims_pcu_backlight, cdev);
+
+	backlight->desired_brightness = value;
+	schedule_work(&backlight->work);
+}
+
+static enum led_brightness
+ims_pcu_backlight_get_brightness(struct led_classdev *cdev)
+{
+	struct ims_pcu_backlight *backlight =
+			container_of(cdev, struct ims_pcu_backlight, cdev);
+	struct ims_pcu *pcu =
+			container_of(backlight, struct ims_pcu, backlight);
+	int brightness;
+	int error;
+
+	mutex_lock(&pcu->cmd_mutex);
+
+	error = ims_pcu_execute_query(pcu, GET_BRIGHTNESS);
+	if (error) {
+		dev_warn(pcu->dev,
+			 "Failed to get current brightness, error: %d\n",
+			 error);
+		/* Assume the LED is OFF */
+		brightness = LED_OFF;
+	} else {
+		brightness =
+			get_unaligned_le16(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET]);
+	}
+
+	mutex_unlock(&pcu->cmd_mutex);
+
+	return brightness;
+}
+
+static int ims_pcu_setup_backlight(struct ims_pcu *pcu)
+{
+	struct ims_pcu_backlight *backlight = &pcu->backlight;
+	int error;
+
+	INIT_WORK(&backlight->work, ims_pcu_backlight_work);
+	snprintf(backlight->name, sizeof(backlight->name),
+		 "pcu%d::kbd_backlight", pcu->device_no);
+
+	backlight->cdev.name = backlight->name;
+	backlight->cdev.max_brightness = IMS_PCU_MAX_BRIGHTNESS;
+	backlight->cdev.brightness_get = ims_pcu_backlight_get_brightness;
+	backlight->cdev.brightness_set = ims_pcu_backlight_set_brightness;
+
+	error = led_classdev_register(pcu->dev, &backlight->cdev);
+	if (error) {
+		dev_err(pcu->dev,
+			"Failed to register backlight LED device, error: %d\n",
+			error);
+		return error;
+	}
+
+	return 0;
+}
+
+static void ims_pcu_destroy_backlight(struct ims_pcu *pcu)
+{
+	struct ims_pcu_backlight *backlight = &pcu->backlight;
+
+	led_classdev_unregister(&backlight->cdev);
+	cancel_work_sync(&backlight->work);
+}
+
+
+/*********************************************************************
+ *             Sysfs attributes handling                             *
+ *********************************************************************/
+
+struct ims_pcu_attribute {
+	struct device_attribute dattr;
+	size_t field_offset;
+	int field_length;
+};
+
+static ssize_t ims_pcu_attribute_show(struct device *dev,
+				      struct device_attribute *dattr,
+				      char *buf)
+{
+	struct usb_interface *intf = to_usb_interface(dev);
+	struct ims_pcu *pcu = usb_get_intfdata(intf);
+	struct ims_pcu_attribute *attr =
+			container_of(dattr, struct ims_pcu_attribute, dattr);
+	char *field = (char *)pcu + attr->field_offset;
+
+	return scnprintf(buf, PAGE_SIZE, "%.*s\n", attr->field_length, field);
+}
+
+static ssize_t ims_pcu_attribute_store(struct device *dev,
+				       struct device_attribute *dattr,
+				       const char *buf, size_t count)
+{
+
+	struct usb_interface *intf = to_usb_interface(dev);
+	struct ims_pcu *pcu = usb_get_intfdata(intf);
+	struct ims_pcu_attribute *attr =
+			container_of(dattr, struct ims_pcu_attribute, dattr);
+	char *field = (char *)pcu + attr->field_offset;
+	size_t data_len;
+	int error;
+
+	if (count > attr->field_length)
+		return -EINVAL;
+
+	data_len = strnlen(buf, attr->field_length);
+	if (data_len > attr->field_length)
+		return -EINVAL;
+
+	error = mutex_lock_interruptible(&pcu->cmd_mutex);
+	if (error)
+		return error;
+
+	memset(field, 0, attr->field_length);
+	memcpy(field, buf, data_len);
+
+	error = ims_pcu_set_info(pcu);
+
+	/*
+	 * Even if update failed, let's fetch the info again as we just
+	 * clobbered one of the fields.
+	 */
+	ims_pcu_get_info(pcu);
+
+	mutex_unlock(&pcu->cmd_mutex);
+
+	return error < 0 ? error : count;
+}
+
+#define IMS_PCU_ATTR(_field, _mode)					\
+struct ims_pcu_attribute ims_pcu_attr_##_field = {			\
+	.dattr = __ATTR(_field, _mode,					\
+			ims_pcu_attribute_show,				\
+			ims_pcu_attribute_store),			\
+	.field_offset = offsetof(struct ims_pcu, _field),		\
+	.field_length = sizeof(((struct ims_pcu *)NULL)->_field),	\
+}
+
+#define IMS_PCU_RO_ATTR(_field)						\
+		IMS_PCU_ATTR(_field, S_IRUGO)
+#define IMS_PCU_RW_ATTR(_field)						\
+		IMS_PCU_ATTR(_field, S_IRUGO | S_IWUSR)
+
+static IMS_PCU_RW_ATTR(part_number);
+static IMS_PCU_RW_ATTR(serial_number);
+static IMS_PCU_RW_ATTR(date_of_manufacturing);
+
+static IMS_PCU_RO_ATTR(fw_version);
+static IMS_PCU_RO_ATTR(bl_version);
+static IMS_PCU_RO_ATTR(reset_reason);
+
+static ssize_t ims_pcu_reset_device(struct device *dev,
+				    struct device_attribute *dattr,
+				    const char *buf, size_t count)
+{
+	static const u8 reset_byte = 1;
+	struct usb_interface *intf = to_usb_interface(dev);
+	struct ims_pcu *pcu = usb_get_intfdata(intf);
+	int value;
+	int error;
+
+	error = kstrtoint(buf, 0, &value);
+	if (error)
+		return error;
+
+	if (value != 1)
+		return -EINVAL;
+
+	dev_info(pcu->dev, "Attempting to reset device\n");
+
+	error = ims_pcu_execute_command(pcu, PCU_RESET, &reset_byte, 1);
+	if (error) {
+		dev_info(pcu->dev,
+			 "Failed to reset device, error: %d\n",
+			 error);
+		return error;
+	}
+
+	return count;
+}
+
+static DEVICE_ATTR(reset_device, S_IWUSR, NULL, ims_pcu_reset_device);
+
+static ssize_t ims_pcu_update_firmware_store(struct device *dev,
+					     struct device_attribute *dattr,
+					     const char *buf, size_t count)
+{
+	struct usb_interface *intf = to_usb_interface(dev);
+	struct ims_pcu *pcu = usb_get_intfdata(intf);
+	const struct firmware *fw = NULL;
+	int value;
+	int error;
+
+	error = kstrtoint(buf, 0, &value);
+	if (error)
+		return error;
+
+	if (value != 1)
+		return -EINVAL;
+
+	error = mutex_lock_interruptible(&pcu->cmd_mutex);
+	if (error)
+		return error;
+
+	error = request_ihex_firmware(&fw, IMS_PCU_FIRMWARE_NAME, pcu->dev);
+	if (error) {
+		dev_err(pcu->dev, "Failed to request firmware %s, error: %d\n",
+			IMS_PCU_FIRMWARE_NAME, error);
+		goto out;
+	}
+
+	/*
+	 * If we are already in bootloader mode we can proceed with
+	 * flashing the firmware.
+	 *
+	 * If we are in application mode, then we need to switch into
+	 * bootloader mode, which will cause the device to disconnect
+	 * and reconnect as different device.
+	 */
+	if (pcu->bootloader_mode)
+		error = ims_pcu_handle_firmware_update(pcu, fw);
+	else
+		error = ims_pcu_switch_to_bootloader(pcu);
+
+	release_firmware(fw);
+
+out:
+	mutex_unlock(&pcu->cmd_mutex);
+	return error ?: count;
+}
+
+static DEVICE_ATTR(update_firmware, S_IWUSR,
+		   NULL, ims_pcu_update_firmware_store);
+
+static ssize_t
+ims_pcu_update_firmware_status_show(struct device *dev,
+				    struct device_attribute *dattr,
+				    char *buf)
+{
+	struct usb_interface *intf = to_usb_interface(dev);
+	struct ims_pcu *pcu = usb_get_intfdata(intf);
+
+	return scnprintf(buf, PAGE_SIZE, "%d\n", pcu->update_firmware_status);
+}
+
+static DEVICE_ATTR(update_firmware_status, S_IRUGO,
+		   ims_pcu_update_firmware_status_show, NULL);
+
+static struct attribute *ims_pcu_attrs[] = {
+	&ims_pcu_attr_part_number.dattr.attr,
+	&ims_pcu_attr_serial_number.dattr.attr,
+	&ims_pcu_attr_date_of_manufacturing.dattr.attr,
+	&ims_pcu_attr_fw_version.dattr.attr,
+	&ims_pcu_attr_bl_version.dattr.attr,
+	&ims_pcu_attr_reset_reason.dattr.attr,
+	&dev_attr_reset_device.attr,
+	&dev_attr_update_firmware.attr,
+	&dev_attr_update_firmware_status.attr,
+	NULL
+};
+
+static umode_t ims_pcu_is_attr_visible(struct kobject *kobj,
+				       struct attribute *attr, int n)
+{
+	struct device *dev = container_of(kobj, struct device, kobj);
+	struct usb_interface *intf = to_usb_interface(dev);
+	struct ims_pcu *pcu = usb_get_intfdata(intf);
+	umode_t mode = attr->mode;
+
+	if (pcu->bootloader_mode) {
+		if (attr != &dev_attr_update_firmware_status.attr &&
+		    attr != &dev_attr_update_firmware.attr &&
+		    attr != &dev_attr_reset_device.attr) {
+			mode = 0;
+		}
+	} else {
+		if (attr == &dev_attr_update_firmware_status.attr)
+			mode = 0;
+	}
+
+	return mode;
+}
+
+static struct attribute_group ims_pcu_attr_group = {
+	.is_visible	= ims_pcu_is_attr_visible,
+	.attrs		= ims_pcu_attrs,
+};
+
+static void ims_pcu_irq(struct urb *urb)
+{
+	struct ims_pcu *pcu = urb->context;
+	int retval, status;
+
+	status = urb->status;
+
+	switch (status) {
+	case 0:
+		/* success */
+		break;
+	case -ECONNRESET:
+	case -ENOENT:
+	case -ESHUTDOWN:
+		/* this urb is terminated, clean up */
+		dev_dbg(pcu->dev, "%s - urb shutting down with status: %d\n",
+			__func__, status);
+		return;
+	default:
+		dev_dbg(pcu->dev, "%s - nonzero urb status received: %d\n",
+			__func__, status);
+		goto exit;
+	}
+
+	dev_dbg(pcu->dev, "%s: received %d: %*ph\n", __func__,
+		urb->actual_length, urb->actual_length, pcu->urb_in_buf);
+
+	if (urb == pcu->urb_in)
+		ims_pcu_process_data(pcu, urb);
+
+exit:
+	retval = usb_submit_urb(urb, GFP_ATOMIC);
+	if (retval && retval != -ENODEV)
+		dev_err(pcu->dev, "%s - usb_submit_urb failed with result %d\n",
+			__func__, retval);
+}
+
+static int ims_pcu_buffers_alloc(struct ims_pcu *pcu)
+{
+	int error;
+
+	pcu->urb_in_buf = usb_alloc_coherent(pcu->udev, pcu->max_in_size,
+					     GFP_KERNEL, &pcu->read_dma);
+	if (!pcu->urb_in_buf) {
+		dev_err(pcu->dev,
+			"Failed to allocate memory for read buffer\n");
+		return -ENOMEM;
+	}
+
+	pcu->urb_in = usb_alloc_urb(0, GFP_KERNEL);
+	if (!pcu->urb_in) {
+		dev_err(pcu->dev, "Failed to allocate input URB\n");
+		error = -ENOMEM;
+		goto err_free_urb_in_buf;
+	}
+
+	pcu->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+	pcu->urb_in->transfer_dma = pcu->read_dma;
+
+	usb_fill_bulk_urb(pcu->urb_in, pcu->udev,
+			  usb_rcvbulkpipe(pcu->udev,
+					  pcu->ep_in->bEndpointAddress),
+			  pcu->urb_in_buf, pcu->max_in_size,
+			  ims_pcu_irq, pcu);
+
+	/*
+	 * We are using usb_bulk_msg() for sending so there is no point
+	 * in allocating memory with usb_alloc_coherent().
+	 */
+	pcu->urb_out_buf = kmalloc(pcu->max_out_size, GFP_KERNEL);
+	if (!pcu->urb_out_buf) {
+		dev_err(pcu->dev, "Failed to allocate memory for write buffer\n");
+		error = -ENOMEM;
+		goto err_free_in_urb;
+	}
+
+	pcu->urb_ctrl_buf = usb_alloc_coherent(pcu->udev, pcu->max_ctrl_size,
+					       GFP_KERNEL, &pcu->ctrl_dma);
+	if (!pcu->urb_ctrl_buf) {
+		dev_err(pcu->dev,
+			"Failed to allocate memory for read buffer\n");
+		goto err_free_urb_out_buf;
+	}
+
+	pcu->urb_ctrl = usb_alloc_urb(0, GFP_KERNEL);
+	if (!pcu->urb_ctrl) {
+		dev_err(pcu->dev, "Failed to allocate input URB\n");
+		error = -ENOMEM;
+		goto err_free_urb_ctrl_buf;
+	}
+
+	pcu->urb_ctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+	pcu->urb_ctrl->transfer_dma = pcu->ctrl_dma;
+
+	usb_fill_int_urb(pcu->urb_ctrl, pcu->udev,
+			  usb_rcvintpipe(pcu->udev,
+					 pcu->ep_ctrl->bEndpointAddress),
+			  pcu->urb_ctrl_buf, pcu->max_ctrl_size,
+			  ims_pcu_irq, pcu, pcu->ep_ctrl->bInterval);
+
+	return 0;
+
+err_free_urb_ctrl_buf:
+	usb_free_coherent(pcu->udev, pcu->max_ctrl_size,
+			  pcu->urb_ctrl_buf, pcu->ctrl_dma);
+err_free_urb_out_buf:
+	kfree(pcu->urb_out_buf);
+err_free_in_urb:
+	usb_free_urb(pcu->urb_in);
+err_free_urb_in_buf:
+	usb_free_coherent(pcu->udev, pcu->max_in_size,
+			  pcu->urb_in_buf, pcu->read_dma);
+	return error;
+}
+
+static void ims_pcu_buffers_free(struct ims_pcu *pcu)
+{
+	usb_kill_urb(pcu->urb_in);
+	usb_free_urb(pcu->urb_in);
+
+	usb_free_coherent(pcu->udev, pcu->max_out_size,
+			  pcu->urb_in_buf, pcu->read_dma);
+
+	kfree(pcu->urb_out_buf);
+
+	usb_kill_urb(pcu->urb_ctrl);
+	usb_free_urb(pcu->urb_ctrl);
+
+	usb_free_coherent(pcu->udev, pcu->max_ctrl_size,
+			  pcu->urb_ctrl_buf, pcu->ctrl_dma);
+}
+
+static const struct usb_cdc_union_desc *
+ims_pcu_get_cdc_union_desc(struct usb_interface *intf)
+{
+	const void *buf = intf->altsetting->extra;
+	size_t buflen = intf->altsetting->extralen;
+	struct usb_cdc_union_desc *union_desc;
+
+	if (!buf) {
+		dev_err(&intf->dev, "Missing descriptor data\n");
+		return NULL;
+	}
+
+	if (!buflen) {
+		dev_err(&intf->dev, "Zero length descriptor\n");
+		return NULL;
+	}
+
+	while (buflen > 0) {
+		union_desc = (struct usb_cdc_union_desc *)buf;
+
+		if (union_desc->bDescriptorType == USB_DT_CS_INTERFACE &&
+		    union_desc->bDescriptorSubType == USB_CDC_UNION_TYPE) {
+			dev_dbg(&intf->dev, "Found union header\n");
+			return union_desc;
+		}
+
+		buflen -= union_desc->bLength;
+		buf += union_desc->bLength;
+	}
+
+	dev_err(&intf->dev, "Missing CDC union descriptor\n");
+	return NULL;
+}
+
+static int ims_pcu_parse_cdc_data(struct usb_interface *intf, struct ims_pcu *pcu)
+{
+	const struct usb_cdc_union_desc *union_desc;
+	struct usb_host_interface *alt;
+
+	union_desc = ims_pcu_get_cdc_union_desc(intf);
+	if (!union_desc)
+		return -EINVAL;
+
+	pcu->ctrl_intf = usb_ifnum_to_if(pcu->udev,
+					 union_desc->bMasterInterface0);
+
+	alt = pcu->ctrl_intf->cur_altsetting;
+	pcu->ep_ctrl = &alt->endpoint[0].desc;
+	pcu->max_ctrl_size = usb_endpoint_maxp(pcu->ep_ctrl);
+
+	pcu->data_intf = usb_ifnum_to_if(pcu->udev,
+					 union_desc->bSlaveInterface0);
+
+	alt = pcu->data_intf->cur_altsetting;
+	if (alt->desc.bNumEndpoints != 2) {
+		dev_err(pcu->dev,
+			"Incorrect number of endpoints on data interface (%d)\n",
+			alt->desc.bNumEndpoints);
+		return -EINVAL;
+	}
+
+	pcu->ep_out = &alt->endpoint[0].desc;
+	if (!usb_endpoint_is_bulk_out(pcu->ep_out)) {
+		dev_err(pcu->dev,
+			"First endpoint on data interface is not BULK OUT\n");
+		return -EINVAL;
+	}
+
+	pcu->max_out_size = usb_endpoint_maxp(pcu->ep_out);
+	if (pcu->max_out_size < 8) {
+		dev_err(pcu->dev,
+			"Max OUT packet size is too small (%zd)\n",
+			pcu->max_out_size);
+		return -EINVAL;
+	}
+
+	pcu->ep_in = &alt->endpoint[1].desc;
+	if (!usb_endpoint_is_bulk_in(pcu->ep_in)) {
+		dev_err(pcu->dev,
+			"Second endpoint on data interface is not BULK IN\n");
+		return -EINVAL;
+	}
+
+	pcu->max_in_size = usb_endpoint_maxp(pcu->ep_in);
+	if (pcu->max_in_size < 8) {
+		dev_err(pcu->dev,
+			"Max IN packet size is too small (%zd)\n",
+			pcu->max_in_size);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int ims_pcu_start_io(struct ims_pcu *pcu)
+{
+	int error;
+
+	error = usb_submit_urb(pcu->urb_ctrl, GFP_KERNEL);
+	if (error) {
+		dev_err(pcu->dev,
+			"Failed to start control IO - usb_submit_urb failed with result: %d\n",
+			error);
+		return -EIO;
+	}
+
+	error = usb_submit_urb(pcu->urb_in, GFP_KERNEL);
+	if (error) {
+		dev_err(pcu->dev,
+			"Failed to start IO - usb_submit_urb failed with result: %d\n",
+			error);
+		usb_kill_urb(pcu->urb_ctrl);
+		return -EIO;
+	}
+
+	return 0;
+}
+
+static void ims_pcu_stop_io(struct ims_pcu *pcu)
+{
+	usb_kill_urb(pcu->urb_in);
+	usb_kill_urb(pcu->urb_ctrl);
+}
+
+static int ims_pcu_line_setup(struct ims_pcu *pcu)
+{
+	struct usb_host_interface *interface = pcu->ctrl_intf->cur_altsetting;
+	struct usb_cdc_line_coding *line = (void *)pcu->cmd_buf;
+	int error;
+
+	memset(line, 0, sizeof(*line));
+	line->dwDTERate = cpu_to_le32(57600);
+	line->bDataBits = 8;
+
+	error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
+				USB_CDC_REQ_SET_LINE_CODING,
+				USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+				0, interface->desc.bInterfaceNumber,
+				line, sizeof(struct usb_cdc_line_coding),
+				5000);
+	if (error < 0) {
+		dev_err(pcu->dev, "Failed to set line coding, error: %d\n",
+			error);
+		return error;
+	}
+
+	error = usb_control_msg(pcu->udev, usb_sndctrlpipe(pcu->udev, 0),
+				USB_CDC_REQ_SET_CONTROL_LINE_STATE,
+				USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+				0x03, interface->desc.bInterfaceNumber,
+				NULL, 0, 5000);
+	if (error < 0) {
+		dev_err(pcu->dev, "Failed to set line state, error: %d\n",
+			error);
+		return error;
+	}
+
+	return 0;
+}
+
+static int ims_pcu_get_device_info(struct ims_pcu *pcu)
+{
+	int error;
+
+	error = ims_pcu_get_info(pcu);
+	if (error)
+		return error;
+
+	error = ims_pcu_execute_query(pcu, GET_FW_VERSION);
+	if (error) {
+		dev_err(pcu->dev,
+			"GET_FW_VERSION command failed, error: %d\n", error);
+		return error;
+	}
+
+	snprintf(pcu->fw_version, sizeof(pcu->fw_version),
+		 "%02d%02d%02d%02d.%c%c",
+		 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
+		 pcu->cmd_buf[6], pcu->cmd_buf[7]);
+
+	error = ims_pcu_execute_query(pcu, GET_BL_VERSION);
+	if (error) {
+		dev_err(pcu->dev,
+			"GET_BL_VERSION command failed, error: %d\n", error);
+		return error;
+	}
+
+	snprintf(pcu->bl_version, sizeof(pcu->bl_version),
+		 "%02d%02d%02d%02d.%c%c",
+		 pcu->cmd_buf[2], pcu->cmd_buf[3], pcu->cmd_buf[4], pcu->cmd_buf[5],
+		 pcu->cmd_buf[6], pcu->cmd_buf[7]);
+
+	error = ims_pcu_execute_query(pcu, RESET_REASON);
+	if (error) {
+		dev_err(pcu->dev,
+			"RESET_REASON command failed, error: %d\n", error);
+		return error;
+	}
+
+	snprintf(pcu->reset_reason, sizeof(pcu->reset_reason),
+		 "%02x", pcu->cmd_buf[IMS_PCU_DATA_OFFSET]);
+
+	dev_dbg(pcu->dev,
+		"P/N: %s, MD: %s, S/N: %s, FW: %s, BL: %s, RR: %s\n",
+		pcu->part_number,
+		pcu->date_of_manufacturing,
+		pcu->serial_number,
+		pcu->fw_version,
+		pcu->bl_version,
+		pcu->reset_reason);
+
+	return 0;
+}
+
+static int ims_pcu_identify_type(struct ims_pcu *pcu, u8 *device_id)
+{
+	int error;
+
+	error = ims_pcu_execute_query(pcu, GET_DEVICE_ID);
+	if (error) {
+		dev_err(pcu->dev,
+			"GET_DEVICE_ID command failed, error: %d\n", error);
+		return error;
+	}
+
+	*device_id = pcu->cmd_buf[IMS_PCU_DATA_OFFSET];
+	dev_dbg(pcu->dev, "Detected device ID: %d\n", *device_id);
+
+	return 0;
+}
+
+static int ims_pcu_init_application_mode(struct ims_pcu *pcu)
+{
+	static atomic_t device_no = ATOMIC_INIT(0);
+
+	const struct ims_pcu_device_info *info;
+	u8 device_id;
+	int error;
+
+	error = ims_pcu_get_device_info(pcu);
+	if (error) {
+		/* Device does not respond to basic queries, hopeless */
+		return error;
+	}
+
+	error = ims_pcu_identify_type(pcu, &device_id);
+	if (error) {
+		dev_err(pcu->dev,
+			"Failed to identify device, error: %d\n", error);
+		/*
+		 * Do not signal error, but do not create input nor
+		 * backlight devices either, let userspace figure this
+		 * out (flash a new firmware?).
+		 */
+		return 0;
+	}
+
+	if (device_id >= ARRAY_SIZE(ims_pcu_device_info) ||
+	    !ims_pcu_device_info[device_id].keymap) {
+		dev_err(pcu->dev, "Device ID %d is not valid\n", device_id);
+		/* Same as above, punt to userspace */
+		return 0;
+	}
+
+	/* Device appears to be operable, complete initialization */
+	pcu->device_no = atomic_inc_return(&device_no) - 1;
+
+	error = ims_pcu_setup_backlight(pcu);
+	if (error)
+		return error;
+
+	info = &ims_pcu_device_info[device_id];
+	error = ims_pcu_setup_buttons(pcu, info->keymap, info->keymap_len);
+	if (error)
+		goto err_destroy_backlight;
+
+	if (info->has_gamepad) {
+		error = ims_pcu_setup_gamepad(pcu);
+		if (error)
+			goto err_destroy_buttons;
+	}
+
+	pcu->setup_complete = true;
+
+	return 0;
+
+err_destroy_backlight:
+	ims_pcu_destroy_backlight(pcu);
+err_destroy_buttons:
+	ims_pcu_destroy_buttons(pcu);
+	return error;
+}
+
+static void ims_pcu_destroy_application_mode(struct ims_pcu *pcu)
+{
+	if (pcu->setup_complete) {
+		pcu->setup_complete = false;
+		mb(); /* make sure flag setting is not reordered */
+
+		if (pcu->gamepad)
+			ims_pcu_destroy_gamepad(pcu);
+		ims_pcu_destroy_buttons(pcu);
+		ims_pcu_destroy_backlight(pcu);
+	}
+}
+
+static int ims_pcu_init_bootloader_mode(struct ims_pcu *pcu)
+{
+	int error;
+
+	error = ims_pcu_execute_bl_command(pcu, QUERY_DEVICE, NULL, 0,
+					   IMS_PCU_CMD_RESPONSE_TIMEOUT);
+	if (error) {
+		dev_err(pcu->dev, "Bootloader does not respond, aborting\n");
+		return error;
+	}
+
+	pcu->fw_start_addr =
+		get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 11]);
+	pcu->fw_end_addr =
+		get_unaligned_le32(&pcu->cmd_buf[IMS_PCU_DATA_OFFSET + 15]);
+
+	dev_info(pcu->dev,
+		 "Device is in bootloader mode (addr 0x%08x-0x%08x), requesting firmware\n",
+		 pcu->fw_start_addr, pcu->fw_end_addr);
+
+	error = request_firmware_nowait(THIS_MODULE, true,
+					IMS_PCU_FIRMWARE_NAME,
+					pcu->dev, GFP_KERNEL, pcu,
+					ims_pcu_process_async_firmware);
+	if (error) {
+		/* This error is not fatal, let userspace have another chance */
+		complete(&pcu->async_firmware_done);
+	}
+
+	return 0;
+}
+
+static void ims_pcu_destroy_bootloader_mode(struct ims_pcu *pcu)
+{
+	/* Make sure our initial firmware request has completed */
+	wait_for_completion(&pcu->async_firmware_done);
+}
+
+#define IMS_PCU_APPLICATION_MODE	0
+#define IMS_PCU_BOOTLOADER_MODE		1
+
+static struct usb_driver ims_pcu_driver;
+
+static int ims_pcu_probe(struct usb_interface *intf,
+			 const struct usb_device_id *id)
+{
+	struct usb_device *udev = interface_to_usbdev(intf);
+	struct ims_pcu *pcu;
+	int error;
+
+	pcu = kzalloc(sizeof(struct ims_pcu), GFP_KERNEL);
+	if (!pcu)
+		return -ENOMEM;
+
+	pcu->dev = &intf->dev;
+	pcu->udev = udev;
+	pcu->bootloader_mode = id->driver_info == IMS_PCU_BOOTLOADER_MODE;
+	mutex_init(&pcu->cmd_mutex);
+	init_completion(&pcu->cmd_done);
+	init_completion(&pcu->async_firmware_done);
+
+	error = ims_pcu_parse_cdc_data(intf, pcu);
+	if (error)
+		goto err_free_mem;
+
+	error = usb_driver_claim_interface(&ims_pcu_driver,
+					   pcu->data_intf, pcu);
+	if (error) {
+		dev_err(&intf->dev,
+			"Unable to claim corresponding data interface: %d\n",
+			error);
+		goto err_free_mem;
+	}
+
+	usb_set_intfdata(pcu->ctrl_intf, pcu);
+	usb_set_intfdata(pcu->data_intf, pcu);
+
+	error = ims_pcu_buffers_alloc(pcu);
+	if (error)
+		goto err_unclaim_intf;
+
+	error = ims_pcu_start_io(pcu);
+	if (error)
+		goto err_free_buffers;
+
+	error = ims_pcu_line_setup(pcu);
+	if (error)
+		goto err_stop_io;
+
+	error = sysfs_create_group(&intf->dev.kobj, &ims_pcu_attr_group);
+	if (error)
+		goto err_stop_io;
+
+	error = pcu->bootloader_mode ?
+			ims_pcu_init_bootloader_mode(pcu) :
+			ims_pcu_init_application_mode(pcu);
+	if (error)
+		goto err_remove_sysfs;
+
+	return 0;
+
+err_remove_sysfs:
+	sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);
+err_stop_io:
+	ims_pcu_stop_io(pcu);
+err_free_buffers:
+	ims_pcu_buffers_free(pcu);
+err_unclaim_intf:
+	usb_driver_release_interface(&ims_pcu_driver, pcu->data_intf);
+err_free_mem:
+	kfree(pcu);
+	return error;
+}
+
+static void ims_pcu_disconnect(struct usb_interface *intf)
+{
+	struct ims_pcu *pcu = usb_get_intfdata(intf);
+	struct usb_host_interface *alt = intf->cur_altsetting;
+
+	usb_set_intfdata(intf, NULL);
+
+	/*
+	 * See if we are dealing with control or data interface. The cleanup
+	 * happens when we unbind primary (control) interface.
+	 */
+	if (alt->desc.bInterfaceClass != USB_CLASS_COMM)
+		return;
+
+	sysfs_remove_group(&intf->dev.kobj, &ims_pcu_attr_group);
+
+	ims_pcu_stop_io(pcu);
+
+	if (pcu->bootloader_mode)
+		ims_pcu_destroy_bootloader_mode(pcu);
+	else
+		ims_pcu_destroy_application_mode(pcu);
+
+	ims_pcu_buffers_free(pcu);
+	kfree(pcu);
+}
+
+#ifdef CONFIG_PM
+static int ims_pcu_suspend(struct usb_interface *intf,
+			   pm_message_t message)
+{
+	struct ims_pcu *pcu = usb_get_intfdata(intf);
+	struct usb_host_interface *alt = intf->cur_altsetting;
+
+	if (alt->desc.bInterfaceClass == USB_CLASS_COMM)
+		ims_pcu_stop_io(pcu);
+
+	return 0;
+}
+
+static int ims_pcu_resume(struct usb_interface *intf)
+{
+	struct ims_pcu *pcu = usb_get_intfdata(intf);
+	struct usb_host_interface *alt = intf->cur_altsetting;
+	int retval = 0;
+
+	if (alt->desc.bInterfaceClass == USB_CLASS_COMM) {
+		retval = ims_pcu_start_io(pcu);
+		if (retval == 0)
+			retval = ims_pcu_line_setup(pcu);
+	}
+
+	return retval;
+}
+#endif
+
+static const struct usb_device_id ims_pcu_id_table[] = {
+	{
+		USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0082,
+					USB_CLASS_COMM,
+					USB_CDC_SUBCLASS_ACM,
+					USB_CDC_ACM_PROTO_AT_V25TER),
+		.driver_info = IMS_PCU_APPLICATION_MODE,
+	},
+	{
+		USB_DEVICE_AND_INTERFACE_INFO(0x04d8, 0x0083,
+					USB_CLASS_COMM,
+					USB_CDC_SUBCLASS_ACM,
+					USB_CDC_ACM_PROTO_AT_V25TER),
+		.driver_info = IMS_PCU_BOOTLOADER_MODE,
+	},
+	{ }
+};
+
+static struct usb_driver ims_pcu_driver = {
+	.name			= "ims_pcu",
+	.id_table		= ims_pcu_id_table,
+	.probe			= ims_pcu_probe,
+	.disconnect		= ims_pcu_disconnect,
+#ifdef CONFIG_PM
+	.suspend		= ims_pcu_suspend,
+	.resume			= ims_pcu_resume,
+	.reset_resume		= ims_pcu_resume,
+#endif
+};
+
+module_usb_driver(ims_pcu_driver);
+
+MODULE_DESCRIPTION("IMS Passenger Control Unit driver");
+MODULE_AUTHOR("Dmitry Torokhov <dmitry.torokhov@gmail.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/ixp4xx-beeper.c b/drivers/input/misc/ixp4xx-beeper.c
new file mode 100644
index 00000000..6ab3decc
--- /dev/null
+++ b/drivers/input/misc/ixp4xx-beeper.c
@@ -0,0 +1,172 @@
+/*
+ * Generic IXP4xx beeper driver
+ *
+ * Copyright (C) 2005 Tower Technologies
+ *
+ * based on nslu2-io.c
+ *  Copyright (C) 2004 Karen Spearel
+ *
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ * Maintainers: http://www.nslu2-linux.org/
+ *
+ * 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/module.h>
+#include <linux/input.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <mach/hardware.h>
+
+MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
+MODULE_DESCRIPTION("ixp4xx beeper driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:ixp4xx-beeper");
+
+static DEFINE_SPINLOCK(beep_lock);
+
+static void ixp4xx_spkr_control(unsigned int pin, unsigned int count)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&beep_lock, flags);
+
+	 if (count) {
+		gpio_line_config(pin, IXP4XX_GPIO_OUT);
+		gpio_line_set(pin, IXP4XX_GPIO_LOW);
+
+		*IXP4XX_OSRT2 = (count & ~IXP4XX_OST_RELOAD_MASK) | IXP4XX_OST_ENABLE;
+	} else {
+		gpio_line_config(pin, IXP4XX_GPIO_IN);
+		gpio_line_set(pin, IXP4XX_GPIO_HIGH);
+
+		*IXP4XX_OSRT2 = 0;
+	}
+
+	spin_unlock_irqrestore(&beep_lock, flags);
+}
+
+static int ixp4xx_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
+{
+	unsigned int pin = (unsigned int) input_get_drvdata(dev);
+	unsigned int count = 0;
+
+	if (type != EV_SND)
+		return -1;
+
+	switch (code) {
+		case SND_BELL:
+			if (value)
+				value = 1000;
+		case SND_TONE:
+			break;
+		default:
+			return -1;
+	}
+
+	if (value > 20 && value < 32767)
+		count = (IXP4XX_TIMER_FREQ / (value * 4)) - 1;
+
+	ixp4xx_spkr_control(pin, count);
+
+	return 0;
+}
+
+static irqreturn_t ixp4xx_spkr_interrupt(int irq, void *dev_id)
+{
+	/* clear interrupt */
+	*IXP4XX_OSST = IXP4XX_OSST_TIMER_2_PEND;
+
+	/* flip the beeper output */
+	*IXP4XX_GPIO_GPOUTR ^= (1 << (unsigned int) dev_id);
+
+	return IRQ_HANDLED;
+}
+
+static int ixp4xx_spkr_probe(struct platform_device *dev)
+{
+	struct input_dev *input_dev;
+	int err;
+
+	input_dev = input_allocate_device();
+	if (!input_dev)
+		return -ENOMEM;
+
+	input_set_drvdata(input_dev, (void *) dev->id);
+
+	input_dev->name = "ixp4xx beeper",
+	input_dev->phys = "ixp4xx/gpio";
+	input_dev->id.bustype = BUS_HOST;
+	input_dev->id.vendor  = 0x001f;
+	input_dev->id.product = 0x0001;
+	input_dev->id.version = 0x0100;
+	input_dev->dev.parent = &dev->dev;
+
+	input_dev->evbit[0] = BIT_MASK(EV_SND);
+	input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
+	input_dev->event = ixp4xx_spkr_event;
+
+	err = request_irq(IRQ_IXP4XX_TIMER2, &ixp4xx_spkr_interrupt,
+			  IRQF_NO_SUSPEND, "ixp4xx-beeper",
+			  (void *) dev->id);
+	if (err)
+		goto err_free_device;
+
+	err = input_register_device(input_dev);
+	if (err)
+		goto err_free_irq;
+
+	platform_set_drvdata(dev, input_dev);
+
+	return 0;
+
+ err_free_irq:
+	free_irq(IRQ_IXP4XX_TIMER2, dev);
+ err_free_device:
+	input_free_device(input_dev);
+
+	return err;
+}
+
+static int ixp4xx_spkr_remove(struct platform_device *dev)
+{
+	struct input_dev *input_dev = platform_get_drvdata(dev);
+	unsigned int pin = (unsigned int) input_get_drvdata(input_dev);
+
+	input_unregister_device(input_dev);
+	platform_set_drvdata(dev, NULL);
+
+	/* turn the speaker off */
+	disable_irq(IRQ_IXP4XX_TIMER2);
+	ixp4xx_spkr_control(pin, 0);
+
+	free_irq(IRQ_IXP4XX_TIMER2, dev);
+
+	return 0;
+}
+
+static void ixp4xx_spkr_shutdown(struct platform_device *dev)
+{
+	struct input_dev *input_dev = platform_get_drvdata(dev);
+	unsigned int pin = (unsigned int) input_get_drvdata(input_dev);
+
+	/* turn off the speaker */
+	disable_irq(IRQ_IXP4XX_TIMER2);
+	ixp4xx_spkr_control(pin, 0);
+}
+
+static struct platform_driver ixp4xx_spkr_platform_driver = {
+	.driver		= {
+		.name	= "ixp4xx-beeper",
+		.owner	= THIS_MODULE,
+	},
+	.probe		= ixp4xx_spkr_probe,
+	.remove		= ixp4xx_spkr_remove,
+	.shutdown	= ixp4xx_spkr_shutdown,
+};
+module_platform_driver(ixp4xx_spkr_platform_driver);
+
diff --git a/drivers/input/misc/keychord.c b/drivers/input/misc/keychord.c
new file mode 100644
index 00000000..a5ea27ad
--- /dev/null
+++ b/drivers/input/misc/keychord.c
@@ -0,0 +1,391 @@
+/*
+ *  drivers/input/misc/keychord.c
+ *
+ * Copyright (C) 2008 Google, Inc.
+ * Author: Mike Lockwood <lockwood@android.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+*/
+
+#include <linux/poll.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/keychord.h>
+#include <linux/sched.h>
+
+#define KEYCHORD_NAME		"keychord"
+#define BUFFER_SIZE			16
+
+MODULE_AUTHOR("Mike Lockwood <lockwood@android.com>");
+MODULE_DESCRIPTION("Key chord input driver");
+MODULE_SUPPORTED_DEVICE("keychord");
+MODULE_LICENSE("GPL");
+
+#define NEXT_KEYCHORD(kc) ((struct input_keychord *) \
+		((char *)kc + sizeof(struct input_keychord) + \
+		kc->count * sizeof(kc->keycodes[0])))
+
+struct keychord_device {
+	struct input_handler	input_handler;
+	int			registered;
+
+	/* list of keychords to monitor */
+	struct input_keychord	*keychords;
+	int			keychord_count;
+
+	/* bitmask of keys contained in our keychords */
+	unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];
+	/* current state of the keys */
+	unsigned long keystate[BITS_TO_LONGS(KEY_CNT)];
+	/* number of keys that are currently pressed */
+	int key_down;
+
+	/* second input_device_id is needed for null termination */
+	struct input_device_id  device_ids[2];
+
+	spinlock_t		lock;
+	wait_queue_head_t	waitq;
+	unsigned char		head;
+	unsigned char		tail;
+	__u16			buff[BUFFER_SIZE];
+};
+
+static int check_keychord(struct keychord_device *kdev,
+		struct input_keychord *keychord)
+{
+	int i;
+
+	if (keychord->count != kdev->key_down)
+		return 0;
+
+	for (i = 0; i < keychord->count; i++) {
+		if (!test_bit(keychord->keycodes[i], kdev->keystate))
+			return 0;
+	}
+
+	/* we have a match */
+	return 1;
+}
+
+static void keychord_event(struct input_handle *handle, unsigned int type,
+			   unsigned int code, int value)
+{
+	struct keychord_device *kdev = handle->private;
+	struct input_keychord *keychord;
+	unsigned long flags;
+	int i, got_chord = 0;
+
+	if (type != EV_KEY || code >= KEY_MAX)
+		return;
+
+	spin_lock_irqsave(&kdev->lock, flags);
+	/* do nothing if key state did not change */
+	if (!test_bit(code, kdev->keystate) == !value)
+		goto done;
+	__change_bit(code, kdev->keystate);
+	if (value)
+		kdev->key_down++;
+	else
+		kdev->key_down--;
+
+	/* don't notify on key up */
+	if (!value)
+		goto done;
+	/* ignore this event if it is not one of the keys we are monitoring */
+	if (!test_bit(code, kdev->keybit))
+		goto done;
+
+	keychord = kdev->keychords;
+	if (!keychord)
+		goto done;
+
+	/* check to see if the keyboard state matches any keychords */
+	for (i = 0; i < kdev->keychord_count; i++) {
+		if (check_keychord(kdev, keychord)) {
+			kdev->buff[kdev->head] = keychord->id;
+			kdev->head = (kdev->head + 1) % BUFFER_SIZE;
+			got_chord = 1;
+			break;
+		}
+		/* skip to next keychord */
+		keychord = NEXT_KEYCHORD(keychord);
+	}
+
+done:
+	spin_unlock_irqrestore(&kdev->lock, flags);
+
+	if (got_chord) {
+		pr_info("keychord: got keychord id %d. Any tasks: %d\n",
+			keychord->id,
+			!list_empty_careful(&kdev->waitq.task_list));
+		wake_up_interruptible(&kdev->waitq);
+	}
+}
+
+static int keychord_connect(struct input_handler *handler,
+					  struct input_dev *dev,
+					  const struct input_device_id *id)
+{
+	int i, ret;
+	struct input_handle *handle;
+	struct keychord_device *kdev =
+		container_of(handler, struct keychord_device, input_handler);
+
+	/*
+	 * ignore this input device if it does not contain any keycodes
+	 * that we are monitoring
+	 */
+	for (i = 0; i < KEY_MAX; i++) {
+		if (test_bit(i, kdev->keybit) && test_bit(i, dev->keybit))
+			break;
+	}
+	if (i == KEY_MAX)
+		return -ENODEV;
+
+	handle = kzalloc(sizeof(*handle), GFP_KERNEL);
+	if (!handle)
+		return -ENOMEM;
+
+	handle->dev = dev;
+	handle->handler = handler;
+	handle->name = KEYCHORD_NAME;
+	handle->private = kdev;
+
+	ret = input_register_handle(handle);
+	if (ret)
+		goto err_input_register_handle;
+
+	ret = input_open_device(handle);
+	if (ret)
+		goto err_input_open_device;
+
+	pr_info("keychord: using input dev %s for fevent\n", dev->name);
+
+	return 0;
+
+err_input_open_device:
+	input_unregister_handle(handle);
+err_input_register_handle:
+	kfree(handle);
+	return ret;
+}
+
+static void keychord_disconnect(struct input_handle *handle)
+{
+	input_close_device(handle);
+	input_unregister_handle(handle);
+	kfree(handle);
+}
+
+/*
+ * keychord_read is used to read keychord events from the driver
+ */
+static ssize_t keychord_read(struct file *file, char __user *buffer,
+		size_t count, loff_t *ppos)
+{
+	struct keychord_device *kdev = file->private_data;
+	__u16   id;
+	int retval;
+	unsigned long flags;
+
+	if (count < sizeof(id))
+		return -EINVAL;
+	count = sizeof(id);
+
+	if (kdev->head == kdev->tail && (file->f_flags & O_NONBLOCK))
+		return -EAGAIN;
+
+	retval = wait_event_interruptible(kdev->waitq,
+			kdev->head != kdev->tail);
+	if (retval)
+		return retval;
+
+	spin_lock_irqsave(&kdev->lock, flags);
+	/* pop a keychord ID off the queue */
+	id = kdev->buff[kdev->tail];
+	kdev->tail = (kdev->tail + 1) % BUFFER_SIZE;
+	spin_unlock_irqrestore(&kdev->lock, flags);
+
+	if (copy_to_user(buffer, &id, count))
+		return -EFAULT;
+
+	return count;
+}
+
+/*
+ * keychord_write is used to configure the driver
+ */
+static ssize_t keychord_write(struct file *file, const char __user *buffer,
+		size_t count, loff_t *ppos)
+{
+	struct keychord_device *kdev = file->private_data;
+	struct input_keychord *keychords = 0;
+	struct input_keychord *keychord, *next, *end;
+	int ret, i, key;
+	unsigned long flags;
+
+	if (count < sizeof(struct input_keychord))
+		return -EINVAL;
+	keychords = kzalloc(count, GFP_KERNEL);
+	if (!keychords)
+		return -ENOMEM;
+
+	/* read list of keychords from userspace */
+	if (copy_from_user(keychords, buffer, count)) {
+		kfree(keychords);
+		return -EFAULT;
+	}
+
+	/* unregister handler before changing configuration */
+	if (kdev->registered) {
+		input_unregister_handler(&kdev->input_handler);
+		kdev->registered = 0;
+	}
+
+	spin_lock_irqsave(&kdev->lock, flags);
+	/* clear any existing configuration */
+	kfree(kdev->keychords);
+	kdev->keychords = 0;
+	kdev->keychord_count = 0;
+	kdev->key_down = 0;
+	memset(kdev->keybit, 0, sizeof(kdev->keybit));
+	memset(kdev->keystate, 0, sizeof(kdev->keystate));
+	kdev->head = kdev->tail = 0;
+
+	keychord = keychords;
+	end = (struct input_keychord *)((char *)keychord + count);
+
+	while (keychord < end) {
+		next = NEXT_KEYCHORD(keychord);
+		if (keychord->count <= 0 || next > end) {
+			pr_err("keychord: invalid keycode count %d\n",
+				keychord->count);
+			goto err_unlock_return;
+		}
+		if (keychord->version != KEYCHORD_VERSION) {
+			pr_err("keychord: unsupported version %d\n",
+				keychord->version);
+			goto err_unlock_return;
+		}
+
+		/* keep track of the keys we are monitoring in keybit */
+		for (i = 0; i < keychord->count; i++) {
+			key = keychord->keycodes[i];
+			if (key < 0 || key >= KEY_CNT) {
+				pr_err("keychord: keycode %d out of range\n",
+					key);
+				goto err_unlock_return;
+			}
+			__set_bit(key, kdev->keybit);
+		}
+
+		kdev->keychord_count++;
+		keychord = next;
+	}
+
+	kdev->keychords = keychords;
+	spin_unlock_irqrestore(&kdev->lock, flags);
+
+	ret = input_register_handler(&kdev->input_handler);
+	if (ret) {
+		kfree(keychords);
+		kdev->keychords = 0;
+		return ret;
+	}
+	kdev->registered = 1;
+
+	return count;
+
+err_unlock_return:
+	spin_unlock_irqrestore(&kdev->lock, flags);
+	kfree(keychords);
+	return -EINVAL;
+}
+
+static unsigned int keychord_poll(struct file *file, poll_table *wait)
+{
+	struct keychord_device *kdev = file->private_data;
+
+	poll_wait(file, &kdev->waitq, wait);
+
+	if (kdev->head != kdev->tail)
+		return POLLIN | POLLRDNORM;
+
+	return 0;
+}
+
+static int keychord_open(struct inode *inode, struct file *file)
+{
+	struct keychord_device *kdev;
+
+	kdev = kzalloc(sizeof(struct keychord_device), GFP_KERNEL);
+	if (!kdev)
+		return -ENOMEM;
+
+	spin_lock_init(&kdev->lock);
+	init_waitqueue_head(&kdev->waitq);
+
+	kdev->input_handler.event = keychord_event;
+	kdev->input_handler.connect = keychord_connect;
+	kdev->input_handler.disconnect = keychord_disconnect;
+	kdev->input_handler.name = KEYCHORD_NAME;
+	kdev->input_handler.id_table = kdev->device_ids;
+
+	kdev->device_ids[0].flags = INPUT_DEVICE_ID_MATCH_EVBIT;
+	__set_bit(EV_KEY, kdev->device_ids[0].evbit);
+
+	file->private_data = kdev;
+
+	return 0;
+}
+
+static int keychord_release(struct inode *inode, struct file *file)
+{
+	struct keychord_device *kdev = file->private_data;
+
+	if (kdev->registered)
+		input_unregister_handler(&kdev->input_handler);
+	kfree(kdev);
+
+	return 0;
+}
+
+static const struct file_operations keychord_fops = {
+	.owner		= THIS_MODULE,
+	.open		= keychord_open,
+	.release	= keychord_release,
+	.read		= keychord_read,
+	.write		= keychord_write,
+	.poll		= keychord_poll,
+};
+
+static struct miscdevice keychord_misc = {
+	.fops		= &keychord_fops,
+	.name		= KEYCHORD_NAME,
+	.minor		= MISC_DYNAMIC_MINOR,
+};
+
+static int __init keychord_init(void)
+{
+	return misc_register(&keychord_misc);
+}
+
+static void __exit keychord_exit(void)
+{
+	misc_deregister(&keychord_misc);
+}
+
+module_init(keychord_init);
+module_exit(keychord_exit);
diff --git a/drivers/input/misc/keyspan_remote.c b/drivers/input/misc/keyspan_remote.c
new file mode 100644
index 00000000..290fa5f9
--- /dev/null
+++ b/drivers/input/misc/keyspan_remote.c
@@ -0,0 +1,597 @@
+/*
+ * keyspan_remote: USB driver for the Keyspan DMR
+ *
+ * Copyright (C) 2005 Zymeta Corporation - Michael Downey (downey@zymeta.com)
+ *
+ *	This program is free software; you can redistribute it and/or
+ *	modify it under the terms of the GNU General Public License as
+ *	published by the Free Software Foundation, version 2.
+ *
+ * This driver has been put together with the support of Innosys, Inc.
+ * and Keyspan, Inc the manufacturers of the Keyspan USB DMR product.
+ */
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/usb/input.h>
+
+#define DRIVER_VERSION	"v0.1"
+#define DRIVER_AUTHOR	"Michael Downey <downey@zymeta.com>"
+#define DRIVER_DESC	"Driver for the USB Keyspan remote control."
+#define DRIVER_LICENSE	"GPL"
+
+/* Parameters that can be passed to the driver. */
+static int debug;
+module_param(debug, int, 0444);
+MODULE_PARM_DESC(debug, "Enable extra debug messages and information");
+
+/* Vendor and product ids */
+#define USB_KEYSPAN_VENDOR_ID		0x06CD
+#define USB_KEYSPAN_PRODUCT_UIA11	0x0202
+
+/* Defines for converting the data from the remote. */
+#define ZERO		0x18
+#define ZERO_MASK	0x1F	/* 5 bits for a 0 */
+#define ONE		0x3C
+#define ONE_MASK	0x3F	/* 6 bits for a 1 */
+#define SYNC		0x3F80
+#define SYNC_MASK	0x3FFF	/* 14 bits for a SYNC sequence */
+#define STOP		0x00
+#define STOP_MASK	0x1F	/* 5 bits for the STOP sequence */
+#define GAP		0xFF
+
+#define RECV_SIZE	8	/* The UIA-11 type have a 8 byte limit. */
+
+/*
+ * Table that maps the 31 possible keycodes to input keys.
+ * Currently there are 15 and 17 button models so RESERVED codes
+ * are blank areas in the mapping.
+ */
+static const unsigned short keyspan_key_table[] = {
+	KEY_RESERVED,		/* 0 is just a place holder. */
+	KEY_RESERVED,
+	KEY_STOP,
+	KEY_PLAYCD,
+	KEY_RESERVED,
+	KEY_PREVIOUSSONG,
+	KEY_REWIND,
+	KEY_FORWARD,
+	KEY_NEXTSONG,
+	KEY_RESERVED,
+	KEY_RESERVED,
+	KEY_RESERVED,
+	KEY_PAUSE,
+	KEY_VOLUMEUP,
+	KEY_RESERVED,
+	KEY_RESERVED,
+	KEY_RESERVED,
+	KEY_VOLUMEDOWN,
+	KEY_RESERVED,
+	KEY_UP,
+	KEY_RESERVED,
+	KEY_MUTE,
+	KEY_LEFT,
+	KEY_ENTER,
+	KEY_RIGHT,
+	KEY_RESERVED,
+	KEY_RESERVED,
+	KEY_DOWN,
+	KEY_RESERVED,
+	KEY_KPASTERISK,
+	KEY_RESERVED,
+	KEY_MENU
+};
+
+/* table of devices that work with this driver */
+static struct usb_device_id keyspan_table[] = {
+	{ USB_DEVICE(USB_KEYSPAN_VENDOR_ID, USB_KEYSPAN_PRODUCT_UIA11) },
+	{ }					/* Terminating entry */
+};
+
+/* Structure to store all the real stuff that a remote sends to us. */
+struct keyspan_message {
+	u16	system;
+	u8	button;
+	u8	toggle;
+};
+
+/* Structure used for all the bit testing magic needed to be done. */
+struct bit_tester {
+	u32	tester;
+	int	len;
+	int	pos;
+	int	bits_left;
+	u8	buffer[32];
+};
+
+/* Structure to hold all of our driver specific stuff */
+struct usb_keyspan {
+	char				name[128];
+	char				phys[64];
+	unsigned short			keymap[ARRAY_SIZE(keyspan_key_table)];
+	struct usb_device		*udev;
+	struct input_dev		*input;
+	struct usb_interface		*interface;
+	struct usb_endpoint_descriptor	*in_endpoint;
+	struct urb*			irq_urb;
+	int				open;
+	dma_addr_t			in_dma;
+	unsigned char			*in_buffer;
+
+	/* variables used to parse messages from remote. */
+	struct bit_tester		data;
+	int				stage;
+	int				toggle;
+};
+
+static struct usb_driver keyspan_driver;
+
+/*
+ * Debug routine that prints out what we've received from the remote.
+ */
+static void keyspan_print(struct usb_keyspan* dev) /*unsigned char* data)*/
+{
+	char codes[4 * RECV_SIZE];
+	int i;
+
+	for (i = 0; i < RECV_SIZE; i++)
+		snprintf(codes + i * 3, 4, "%02x ", dev->in_buffer[i]);
+
+	dev_info(&dev->udev->dev, "%s\n", codes);
+}
+
+/*
+ * Routine that manages the bit_tester structure.  It makes sure that there are
+ * at least bits_needed bits loaded into the tester.
+ */
+static int keyspan_load_tester(struct usb_keyspan* dev, int bits_needed)
+{
+	if (dev->data.bits_left >= bits_needed)
+		return 0;
+
+	/*
+	 * Somehow we've missed the last message. The message will be repeated
+	 * though so it's not too big a deal
+	 */
+	if (dev->data.pos >= dev->data.len) {
+		dev_dbg(&dev->interface->dev,
+			"%s - Error ran out of data. pos: %d, len: %d\n",
+			__func__, dev->data.pos, dev->data.len);
+		return -1;
+	}
+
+	/* Load as much as we can into the tester. */
+	while ((dev->data.bits_left + 7 < (sizeof(dev->data.tester) * 8)) &&
+	       (dev->data.pos < dev->data.len)) {
+		dev->data.tester += (dev->data.buffer[dev->data.pos++] << dev->data.bits_left);
+		dev->data.bits_left += 8;
+	}
+
+	return 0;
+}
+
+static void keyspan_report_button(struct usb_keyspan *remote, int button, int press)
+{
+	struct input_dev *input = remote->input;
+
+	input_event(input, EV_MSC, MSC_SCAN, button);
+	input_report_key(input, remote->keymap[button], press);
+	input_sync(input);
+}
+
+/*
+ * Routine that handles all the logic needed to parse out the message from the remote.
+ */
+static void keyspan_check_data(struct usb_keyspan *remote)
+{
+	int i;
+	int found = 0;
+	struct keyspan_message message;
+
+	switch(remote->stage) {
+	case 0:
+		/*
+		 * In stage 0 we want to find the start of a message.  The remote sends a 0xFF as filler.
+		 * So the first byte that isn't a FF should be the start of a new message.
+		 */
+		for (i = 0; i < RECV_SIZE && remote->in_buffer[i] == GAP; ++i);
+
+		if (i < RECV_SIZE) {
+			memcpy(remote->data.buffer, remote->in_buffer, RECV_SIZE);
+			remote->data.len = RECV_SIZE;
+			remote->data.pos = 0;
+			remote->data.tester = 0;
+			remote->data.bits_left = 0;
+			remote->stage = 1;
+		}
+		break;
+
+	case 1:
+		/*
+		 * Stage 1 we should have 16 bytes and should be able to detect a
+		 * SYNC.  The SYNC is 14 bits, 7 0's and then 7 1's.
+		 */
+		memcpy(remote->data.buffer + remote->data.len, remote->in_buffer, RECV_SIZE);
+		remote->data.len += RECV_SIZE;
+
+		found = 0;
+		while ((remote->data.bits_left >= 14 || remote->data.pos < remote->data.len) && !found) {
+			for (i = 0; i < 8; ++i) {
+				if (keyspan_load_tester(remote, 14) != 0) {
+					remote->stage = 0;
+					return;
+				}
+
+				if ((remote->data.tester & SYNC_MASK) == SYNC) {
+					remote->data.tester = remote->data.tester >> 14;
+					remote->data.bits_left -= 14;
+					found = 1;
+					break;
+				} else {
+					remote->data.tester = remote->data.tester >> 1;
+					--remote->data.bits_left;
+				}
+			}
+		}
+
+		if (!found) {
+			remote->stage = 0;
+			remote->data.len = 0;
+		} else {
+			remote->stage = 2;
+		}
+		break;
+
+	case 2:
+		/*
+		 * Stage 2 we should have 24 bytes which will be enough for a full
+		 * message.  We need to parse out the system code, button code,
+		 * toggle code, and stop.
+		 */
+		memcpy(remote->data.buffer + remote->data.len, remote->in_buffer, RECV_SIZE);
+		remote->data.len += RECV_SIZE;
+
+		message.system = 0;
+		for (i = 0; i < 9; i++) {
+			keyspan_load_tester(remote, 6);
+
+			if ((remote->data.tester & ZERO_MASK) == ZERO) {
+				message.system = message.system << 1;
+				remote->data.tester = remote->data.tester >> 5;
+				remote->data.bits_left -= 5;
+			} else if ((remote->data.tester & ONE_MASK) == ONE) {
+				message.system = (message.system << 1) + 1;
+				remote->data.tester = remote->data.tester >> 6;
+				remote->data.bits_left -= 6;
+			} else {
+				dev_err(&remote->interface->dev,
+					"%s - Unknown sequence found in system data.\n",
+					__func__);
+				remote->stage = 0;
+				return;
+			}
+		}
+
+		message.button = 0;
+		for (i = 0; i < 5; i++) {
+			keyspan_load_tester(remote, 6);
+
+			if ((remote->data.tester & ZERO_MASK) == ZERO) {
+				message.button = message.button << 1;
+				remote->data.tester = remote->data.tester >> 5;
+				remote->data.bits_left -= 5;
+			} else if ((remote->data.tester & ONE_MASK) == ONE) {
+				message.button = (message.button << 1) + 1;
+				remote->data.tester = remote->data.tester >> 6;
+				remote->data.bits_left -= 6;
+			} else {
+				dev_err(&remote->interface->dev,
+					"%s - Unknown sequence found in button data.\n",
+					__func__);
+				remote->stage = 0;
+				return;
+			}
+		}
+
+		keyspan_load_tester(remote, 6);
+		if ((remote->data.tester & ZERO_MASK) == ZERO) {
+			message.toggle = 0;
+			remote->data.tester = remote->data.tester >> 5;
+			remote->data.bits_left -= 5;
+		} else if ((remote->data.tester & ONE_MASK) == ONE) {
+			message.toggle = 1;
+			remote->data.tester = remote->data.tester >> 6;
+			remote->data.bits_left -= 6;
+		} else {
+			dev_err(&remote->interface->dev,
+				"%s - Error in message, invalid toggle.\n",
+				__func__);
+			remote->stage = 0;
+			return;
+		}
+
+		keyspan_load_tester(remote, 5);
+		if ((remote->data.tester & STOP_MASK) == STOP) {
+			remote->data.tester = remote->data.tester >> 5;
+			remote->data.bits_left -= 5;
+		} else {
+			dev_err(&remote->interface->dev,
+				"Bad message received, no stop bit found.\n");
+		}
+
+		dev_dbg(&remote->interface->dev,
+			"%s found valid message: system: %d, button: %d, toggle: %d\n",
+			__func__, message.system, message.button, message.toggle);
+
+		if (message.toggle != remote->toggle) {
+			keyspan_report_button(remote, message.button, 1);
+			keyspan_report_button(remote, message.button, 0);
+			remote->toggle = message.toggle;
+		}
+
+		remote->stage = 0;
+		break;
+	}
+}
+
+/*
+ * Routine for sending all the initialization messages to the remote.
+ */
+static int keyspan_setup(struct usb_device* dev)
+{
+	int retval = 0;
+
+	retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+				 0x11, 0x40, 0x5601, 0x0, NULL, 0, 0);
+	if (retval) {
+		dev_dbg(&dev->dev, "%s - failed to set bit rate due to error: %d\n",
+			__func__, retval);
+		return(retval);
+	}
+
+	retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+				 0x44, 0x40, 0x0, 0x0, NULL, 0, 0);
+	if (retval) {
+		dev_dbg(&dev->dev, "%s - failed to set resume sensitivity due to error: %d\n",
+			__func__, retval);
+		return(retval);
+	}
+
+	retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+				 0x22, 0x40, 0x0, 0x0, NULL, 0, 0);
+	if (retval) {
+		dev_dbg(&dev->dev, "%s - failed to turn receive on due to error: %d\n",
+			__func__, retval);
+		return(retval);
+	}
+
+	dev_dbg(&dev->dev, "%s - Setup complete.\n", __func__);
+	return(retval);
+}
+
+/*
+ * Routine used to handle a new message that has come in.
+ */
+static void keyspan_irq_recv(struct urb *urb)
+{
+	struct usb_keyspan *dev = urb->context;
+	int retval;
+
+	/* Check our status in case we need to bail out early. */
+	switch (urb->status) {
+	case 0:
+		break;
+
+	/* Device went away so don't keep trying to read from it. */
+	case -ECONNRESET:
+	case -ENOENT:
+	case -ESHUTDOWN:
+		return;
+
+	default:
+		goto resubmit;
+		break;
+	}
+
+	if (debug)
+		keyspan_print(dev);
+
+	keyspan_check_data(dev);
+
+resubmit:
+	retval = usb_submit_urb(urb, GFP_ATOMIC);
+	if (retval)
+		dev_err(&dev->interface->dev,
+			"%s - usb_submit_urb failed with result: %d\n",
+			__func__, retval);
+}
+
+static int keyspan_open(struct input_dev *dev)
+{
+	struct usb_keyspan *remote = input_get_drvdata(dev);
+
+	remote->irq_urb->dev = remote->udev;
+	if (usb_submit_urb(remote->irq_urb, GFP_KERNEL))
+		return -EIO;
+
+	return 0;
+}
+
+static void keyspan_close(struct input_dev *dev)
+{
+	struct usb_keyspan *remote = input_get_drvdata(dev);
+
+	usb_kill_urb(remote->irq_urb);
+}
+
+static struct usb_endpoint_descriptor *keyspan_get_in_endpoint(struct usb_host_interface *iface)
+{
+
+	struct usb_endpoint_descriptor *endpoint;
+	int i;
+
+	for (i = 0; i < iface->desc.bNumEndpoints; ++i) {
+		endpoint = &iface->endpoint[i].desc;
+
+		if (usb_endpoint_is_int_in(endpoint)) {
+			/* we found our interrupt in endpoint */
+			return endpoint;
+		}
+	}
+
+	return NULL;
+}
+
+/*
+ * Routine that sets up the driver to handle a specific USB device detected on the bus.
+ */
+static int keyspan_probe(struct usb_interface *interface, const struct usb_device_id *id)
+{
+	struct usb_device *udev = interface_to_usbdev(interface);
+	struct usb_endpoint_descriptor *endpoint;
+	struct usb_keyspan *remote;
+	struct input_dev *input_dev;
+	int i, error;
+
+	endpoint = keyspan_get_in_endpoint(interface->cur_altsetting);
+	if (!endpoint)
+		return -ENODEV;
+
+	remote = kzalloc(sizeof(*remote), GFP_KERNEL);
+	input_dev = input_allocate_device();
+	if (!remote || !input_dev) {
+		error = -ENOMEM;
+		goto fail1;
+	}
+
+	remote->udev = udev;
+	remote->input = input_dev;
+	remote->interface = interface;
+	remote->in_endpoint = endpoint;
+	remote->toggle = -1;	/* Set to -1 so we will always not match the toggle from the first remote message. */
+
+	remote->in_buffer = usb_alloc_coherent(udev, RECV_SIZE, GFP_ATOMIC, &remote->in_dma);
+	if (!remote->in_buffer) {
+		error = -ENOMEM;
+		goto fail1;
+	}
+
+	remote->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
+	if (!remote->irq_urb) {
+		error = -ENOMEM;
+		goto fail2;
+	}
+
+	error = keyspan_setup(udev);
+	if (error) {
+		error = -ENODEV;
+		goto fail3;
+	}
+
+	if (udev->manufacturer)
+		strlcpy(remote->name, udev->manufacturer, sizeof(remote->name));
+
+	if (udev->product) {
+		if (udev->manufacturer)
+			strlcat(remote->name, " ", sizeof(remote->name));
+		strlcat(remote->name, udev->product, sizeof(remote->name));
+	}
+
+	if (!strlen(remote->name))
+		snprintf(remote->name, sizeof(remote->name),
+			 "USB Keyspan Remote %04x:%04x",
+			 le16_to_cpu(udev->descriptor.idVendor),
+			 le16_to_cpu(udev->descriptor.idProduct));
+
+	usb_make_path(udev, remote->phys, sizeof(remote->phys));
+	strlcat(remote->phys, "/input0", sizeof(remote->phys));
+	memcpy(remote->keymap, keyspan_key_table, sizeof(remote->keymap));
+
+	input_dev->name = remote->name;
+	input_dev->phys = remote->phys;
+	usb_to_input_id(udev, &input_dev->id);
+	input_dev->dev.parent = &interface->dev;
+	input_dev->keycode = remote->keymap;
+	input_dev->keycodesize = sizeof(unsigned short);
+	input_dev->keycodemax = ARRAY_SIZE(remote->keymap);
+
+	input_set_capability(input_dev, EV_MSC, MSC_SCAN);
+	__set_bit(EV_KEY, input_dev->evbit);
+	for (i = 0; i < ARRAY_SIZE(keyspan_key_table); i++)
+		__set_bit(keyspan_key_table[i], input_dev->keybit);
+	__clear_bit(KEY_RESERVED, input_dev->keybit);
+
+	input_set_drvdata(input_dev, remote);
+
+	input_dev->open = keyspan_open;
+	input_dev->close = keyspan_close;
+
+	/*
+	 * Initialize the URB to access the device.
+	 * The urb gets sent to the device in keyspan_open()
+	 */
+	usb_fill_int_urb(remote->irq_urb,
+			 remote->udev,
+			 usb_rcvintpipe(remote->udev, endpoint->bEndpointAddress),
+			 remote->in_buffer, RECV_SIZE, keyspan_irq_recv, remote,
+			 endpoint->bInterval);
+	remote->irq_urb->transfer_dma = remote->in_dma;
+	remote->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+	/* we can register the device now, as it is ready */
+	error = input_register_device(remote->input);
+	if (error)
+		goto fail3;
+
+	/* save our data pointer in this interface device */
+	usb_set_intfdata(interface, remote);
+
+	return 0;
+
+ fail3:	usb_free_urb(remote->irq_urb);
+ fail2:	usb_free_coherent(udev, RECV_SIZE, remote->in_buffer, remote->in_dma);
+ fail1:	kfree(remote);
+	input_free_device(input_dev);
+
+	return error;
+}
+
+/*
+ * Routine called when a device is disconnected from the USB.
+ */
+static void keyspan_disconnect(struct usb_interface *interface)
+{
+	struct usb_keyspan *remote;
+
+	remote = usb_get_intfdata(interface);
+	usb_set_intfdata(interface, NULL);
+
+	if (remote) {	/* We have a valid driver structure so clean up everything we allocated. */
+		input_unregister_device(remote->input);
+		usb_kill_urb(remote->irq_urb);
+		usb_free_urb(remote->irq_urb);
+		usb_free_coherent(remote->udev, RECV_SIZE, remote->in_buffer, remote->in_dma);
+		kfree(remote);
+	}
+}
+
+/*
+ * Standard driver set up sections
+ */
+static struct usb_driver keyspan_driver =
+{
+	.name =		"keyspan_remote",
+	.probe =	keyspan_probe,
+	.disconnect =	keyspan_disconnect,
+	.id_table =	keyspan_table
+};
+
+module_usb_driver(keyspan_driver);
+
+MODULE_DEVICE_TABLE(usb, keyspan_table);
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE(DRIVER_LICENSE);
diff --git a/drivers/input/misc/kxtj9.c b/drivers/input/misc/kxtj9.c
new file mode 100644
index 00000000..a993b67a
--- /dev/null
+++ b/drivers/input/misc/kxtj9.c
@@ -0,0 +1,674 @@
+/*
+ * Copyright (C) 2011 Kionix, Inc.
+ * Written by Chris Hudson <chudson@kionix.com>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ * 02111-1307, USA
+ */
+
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/input/kxtj9.h>
+#include <linux/input-polldev.h>
+
+#define NAME			"kxtj9"
+#define G_MAX			8000
+/* OUTPUT REGISTERS */
+#define XOUT_L			0x06
+#define WHO_AM_I		0x0F
+/* CONTROL REGISTERS */
+#define INT_REL			0x1A
+#define CTRL_REG1		0x1B
+#define INT_CTRL1		0x1E
+#define DATA_CTRL		0x21
+/* CONTROL REGISTER 1 BITS */
+#define PC1_OFF			0x7F
+#define PC1_ON			(1 << 7)
+/* Data ready funtion enable bit: set during probe if using irq mode */
+#define DRDYE			(1 << 5)
+/* DATA CONTROL REGISTER BITS */
+#define ODR12_5F		0
+#define ODR25F			1
+#define ODR50F			2
+#define ODR100F		3
+#define ODR200F		4
+#define ODR400F		5
+#define ODR800F		6
+/* INTERRUPT CONTROL REGISTER 1 BITS */
+/* Set these during probe if using irq mode */
+#define KXTJ9_IEL		(1 << 3)
+#define KXTJ9_IEA		(1 << 4)
+#define KXTJ9_IEN		(1 << 5)
+/* INPUT_ABS CONSTANTS */
+#define FUZZ			3
+#define FLAT			3
+/* RESUME STATE INDICES */
+#define RES_DATA_CTRL		0
+#define RES_CTRL_REG1		1
+#define RES_INT_CTRL1		2
+#define RESUME_ENTRIES		3
+
+/*
+ * The following table lists the maximum appropriate poll interval for each
+ * available output data rate.
+ */
+static const struct {
+	unsigned int cutoff;
+	u8 mask;
+} kxtj9_odr_table[] = {
+	{ 3,	ODR800F },
+	{ 5,	ODR400F },
+	{ 10,	ODR200F },
+	{ 20,	ODR100F },
+	{ 40,	ODR50F  },
+	{ 80,	ODR25F  },
+	{ 0,	ODR12_5F},
+};
+
+struct kxtj9_data {
+	struct i2c_client *client;
+	struct kxtj9_platform_data pdata;
+	struct input_dev *input_dev;
+#ifdef CONFIG_INPUT_KXTJ9_POLLED_MODE
+	struct input_polled_dev *poll_dev;
+#endif
+	unsigned int last_poll_interval;
+	u8 shift;
+	u8 ctrl_reg1;
+	u8 data_ctrl;
+	u8 int_ctrl;
+};
+
+static int kxtj9_i2c_read(struct kxtj9_data *tj9, u8 addr, u8 *data, int len)
+{
+	struct i2c_msg msgs[] = {
+		{
+			.addr = tj9->client->addr,
+			.flags = tj9->client->flags,
+			.len = 1,
+			.buf = &addr,
+		},
+		{
+			.addr = tj9->client->addr,
+			.flags = tj9->client->flags | I2C_M_RD,
+			.len = len,
+			.buf = data,
+		},
+	};
+
+	return i2c_transfer(tj9->client->adapter, msgs, 2);
+}
+
+static void kxtj9_report_acceleration_data(struct kxtj9_data *tj9)
+{
+	s16 acc_data[3]; /* Data bytes from hardware xL, xH, yL, yH, zL, zH */
+	s16 x, y, z;
+	int err;
+
+	err = kxtj9_i2c_read(tj9, XOUT_L, (u8 *)acc_data, 6);
+	if (err < 0)
+		dev_err(&tj9->client->dev, "accelerometer data read failed\n");
+
+	x = le16_to_cpu(acc_data[tj9->pdata.axis_map_x]);
+	y = le16_to_cpu(acc_data[tj9->pdata.axis_map_y]);
+	z = le16_to_cpu(acc_data[tj9->pdata.axis_map_z]);
+
+	x >>= tj9->shift;
+	y >>= tj9->shift;
+	z >>= tj9->shift;
+
+	input_report_abs(tj9->input_dev, ABS_X, tj9->pdata.negate_x ? -x : x);
+	input_report_abs(tj9->input_dev, ABS_Y, tj9->pdata.negate_y ? -y : y);
+	input_report_abs(tj9->input_dev, ABS_Z, tj9->pdata.negate_z ? -z : z);
+	input_sync(tj9->input_dev);
+}
+
+static irqreturn_t kxtj9_isr(int irq, void *dev)
+{
+	struct kxtj9_data *tj9 = dev;
+	int err;
+
+	/* data ready is the only possible interrupt type */
+	kxtj9_report_acceleration_data(tj9);
+
+	err = i2c_smbus_read_byte_data(tj9->client, INT_REL);
+	if (err < 0)
+		dev_err(&tj9->client->dev,
+			"error clearing interrupt status: %d\n", err);
+
+	return IRQ_HANDLED;
+}
+
+static int kxtj9_update_g_range(struct kxtj9_data *tj9, u8 new_g_range)
+{
+	switch (new_g_range) {
+	case KXTJ9_G_2G:
+		tj9->shift = 4;
+		break;
+	case KXTJ9_G_4G:
+		tj9->shift = 3;
+		break;
+	case KXTJ9_G_8G:
+		tj9->shift = 2;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	tj9->ctrl_reg1 &= 0xe7;
+	tj9->ctrl_reg1 |= new_g_range;
+
+	return 0;
+}
+
+static int kxtj9_update_odr(struct kxtj9_data *tj9, unsigned int poll_interval)
+{
+	int err;
+	int i;
+
+	/* Use the lowest ODR that can support the requested poll interval */
+	for (i = 0; i < ARRAY_SIZE(kxtj9_odr_table); i++) {
+		tj9->data_ctrl = kxtj9_odr_table[i].mask;
+		if (poll_interval < kxtj9_odr_table[i].cutoff)
+			break;
+	}
+
+	err = i2c_smbus_write_byte_data(tj9->client, CTRL_REG1, 0);
+	if (err < 0)
+		return err;
+
+	err = i2c_smbus_write_byte_data(tj9->client, DATA_CTRL, tj9->data_ctrl);
+	if (err < 0)
+		return err;
+
+	err = i2c_smbus_write_byte_data(tj9->client, CTRL_REG1, tj9->ctrl_reg1);
+	if (err < 0)
+		return err;
+
+	return 0;
+}
+
+static int kxtj9_device_power_on(struct kxtj9_data *tj9)
+{
+	if (tj9->pdata.power_on)
+		return tj9->pdata.power_on();
+
+	return 0;
+}
+
+static void kxtj9_device_power_off(struct kxtj9_data *tj9)
+{
+	int err;
+
+	tj9->ctrl_reg1 &= PC1_OFF;
+	err = i2c_smbus_write_byte_data(tj9->client, CTRL_REG1, tj9->ctrl_reg1);
+	if (err < 0)
+		dev_err(&tj9->client->dev, "soft power off failed\n");
+
+	if (tj9->pdata.power_off)
+		tj9->pdata.power_off();
+}
+
+static int kxtj9_enable(struct kxtj9_data *tj9)
+{
+	int err;
+
+	err = kxtj9_device_power_on(tj9);
+	if (err < 0)
+		return err;
+
+	/* ensure that PC1 is cleared before updating control registers */
+	err = i2c_smbus_write_byte_data(tj9->client, CTRL_REG1, 0);
+	if (err < 0)
+		return err;
+
+	/* only write INT_CTRL_REG1 if in irq mode */
+	if (tj9->client->irq) {
+		err = i2c_smbus_write_byte_data(tj9->client,
+						INT_CTRL1, tj9->int_ctrl);
+		if (err < 0)
+			return err;
+	}
+
+	err = kxtj9_update_g_range(tj9, tj9->pdata.g_range);
+	if (err < 0)
+		return err;
+
+	/* turn on outputs */
+	tj9->ctrl_reg1 |= PC1_ON;
+	err = i2c_smbus_write_byte_data(tj9->client, CTRL_REG1, tj9->ctrl_reg1);
+	if (err < 0)
+		return err;
+
+	err = kxtj9_update_odr(tj9, tj9->last_poll_interval);
+	if (err < 0)
+		return err;
+
+	/* clear initial interrupt if in irq mode */
+	if (tj9->client->irq) {
+		err = i2c_smbus_read_byte_data(tj9->client, INT_REL);
+		if (err < 0) {
+			dev_err(&tj9->client->dev,
+				"error clearing interrupt: %d\n", err);
+			goto fail;
+		}
+	}
+
+	return 0;
+
+fail:
+	kxtj9_device_power_off(tj9);
+	return err;
+}
+
+static void kxtj9_disable(struct kxtj9_data *tj9)
+{
+	kxtj9_device_power_off(tj9);
+}
+
+static int kxtj9_input_open(struct input_dev *input)
+{
+	struct kxtj9_data *tj9 = input_get_drvdata(input);
+
+	return kxtj9_enable(tj9);
+}
+
+static void kxtj9_input_close(struct input_dev *dev)
+{
+	struct kxtj9_data *tj9 = input_get_drvdata(dev);
+
+	kxtj9_disable(tj9);
+}
+
+static void kxtj9_init_input_device(struct kxtj9_data *tj9,
+					      struct input_dev *input_dev)
+{
+	__set_bit(EV_ABS, input_dev->evbit);
+	input_set_abs_params(input_dev, ABS_X, -G_MAX, G_MAX, FUZZ, FLAT);
+	input_set_abs_params(input_dev, ABS_Y, -G_MAX, G_MAX, FUZZ, FLAT);
+	input_set_abs_params(input_dev, ABS_Z, -G_MAX, G_MAX, FUZZ, FLAT);
+
+	input_dev->name = "kxtj9_accel";
+	input_dev->id.bustype = BUS_I2C;
+	input_dev->dev.parent = &tj9->client->dev;
+}
+
+static int kxtj9_setup_input_device(struct kxtj9_data *tj9)
+{
+	struct input_dev *input_dev;
+	int err;
+
+	input_dev = input_allocate_device();
+	if (!input_dev) {
+		dev_err(&tj9->client->dev, "input device allocate failed\n");
+		return -ENOMEM;
+	}
+
+	tj9->input_dev = input_dev;
+
+	input_dev->open = kxtj9_input_open;
+	input_dev->close = kxtj9_input_close;
+	input_set_drvdata(input_dev, tj9);
+
+	kxtj9_init_input_device(tj9, input_dev);
+
+	err = input_register_device(tj9->input_dev);
+	if (err) {
+		dev_err(&tj9->client->dev,
+			"unable to register input polled device %s: %d\n",
+			tj9->input_dev->name, err);
+		input_free_device(tj9->input_dev);
+		return err;
+	}
+
+	return 0;
+}
+
+/*
+ * When IRQ mode is selected, we need to provide an interface to allow the user
+ * to change the output data rate of the part.  For consistency, we are using
+ * the set_poll method, which accepts a poll interval in milliseconds, and then
+ * calls update_odr() while passing this value as an argument.  In IRQ mode, the
+ * data outputs will not be read AT the requested poll interval, rather, the
+ * lowest ODR that can support the requested interval.  The client application
+ * will be responsible for retrieving data from the input node at the desired
+ * interval.
+ */
+
+/* Returns currently selected poll interval (in ms) */
+static ssize_t kxtj9_get_poll(struct device *dev,
+				struct device_attribute *attr, char *buf)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct kxtj9_data *tj9 = i2c_get_clientdata(client);
+
+	return sprintf(buf, "%d\n", tj9->last_poll_interval);
+}
+
+/* Allow users to select a new poll interval (in ms) */
+static ssize_t kxtj9_set_poll(struct device *dev, struct device_attribute *attr,
+						const char *buf, size_t count)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct kxtj9_data *tj9 = i2c_get_clientdata(client);
+	struct input_dev *input_dev = tj9->input_dev;
+	unsigned int interval;
+	int error;
+
+	error = kstrtouint(buf, 10, &interval);
+	if (error < 0)
+		return error;
+
+	/* Lock the device to prevent races with open/close (and itself) */
+	mutex_lock(&input_dev->mutex);
+
+	disable_irq(client->irq);
+
+	/*
+	 * Set current interval to the greater of the minimum interval or
+	 * the requested interval
+	 */
+	tj9->last_poll_interval = max(interval, tj9->pdata.min_interval);
+
+	kxtj9_update_odr(tj9, tj9->last_poll_interval);
+
+	enable_irq(client->irq);
+	mutex_unlock(&input_dev->mutex);
+
+	return count;
+}
+
+static DEVICE_ATTR(poll, S_IRUGO|S_IWUSR, kxtj9_get_poll, kxtj9_set_poll);
+
+static struct attribute *kxtj9_attributes[] = {
+	&dev_attr_poll.attr,
+	NULL
+};
+
+static struct attribute_group kxtj9_attribute_group = {
+	.attrs = kxtj9_attributes
+};
+
+
+#ifdef CONFIG_INPUT_KXTJ9_POLLED_MODE
+static void kxtj9_poll(struct input_polled_dev *dev)
+{
+	struct kxtj9_data *tj9 = dev->private;
+	unsigned int poll_interval = dev->poll_interval;
+
+	kxtj9_report_acceleration_data(tj9);
+
+	if (poll_interval != tj9->last_poll_interval) {
+		kxtj9_update_odr(tj9, poll_interval);
+		tj9->last_poll_interval = poll_interval;
+	}
+}
+
+static void kxtj9_polled_input_open(struct input_polled_dev *dev)
+{
+	struct kxtj9_data *tj9 = dev->private;
+
+	kxtj9_enable(tj9);
+}
+
+static void kxtj9_polled_input_close(struct input_polled_dev *dev)
+{
+	struct kxtj9_data *tj9 = dev->private;
+
+	kxtj9_disable(tj9);
+}
+
+static int kxtj9_setup_polled_device(struct kxtj9_data *tj9)
+{
+	int err;
+	struct input_polled_dev *poll_dev;
+	poll_dev = input_allocate_polled_device();
+
+	if (!poll_dev) {
+		dev_err(&tj9->client->dev,
+			"Failed to allocate polled device\n");
+		return -ENOMEM;
+	}
+
+	tj9->poll_dev = poll_dev;
+	tj9->input_dev = poll_dev->input;
+
+	poll_dev->private = tj9;
+	poll_dev->poll = kxtj9_poll;
+	poll_dev->open = kxtj9_polled_input_open;
+	poll_dev->close = kxtj9_polled_input_close;
+
+	kxtj9_init_input_device(tj9, poll_dev->input);
+
+	err = input_register_polled_device(poll_dev);
+	if (err) {
+		dev_err(&tj9->client->dev,
+			"Unable to register polled device, err=%d\n", err);
+		input_free_polled_device(poll_dev);
+		return err;
+	}
+
+	return 0;
+}
+
+static void kxtj9_teardown_polled_device(struct kxtj9_data *tj9)
+{
+	input_unregister_polled_device(tj9->poll_dev);
+	input_free_polled_device(tj9->poll_dev);
+}
+
+#else
+
+static inline int kxtj9_setup_polled_device(struct kxtj9_data *tj9)
+{
+	return -ENOSYS;
+}
+
+static inline void kxtj9_teardown_polled_device(struct kxtj9_data *tj9)
+{
+}
+
+#endif
+
+static int kxtj9_verify(struct kxtj9_data *tj9)
+{
+	int retval;
+
+	retval = kxtj9_device_power_on(tj9);
+	if (retval < 0)
+		return retval;
+
+	retval = i2c_smbus_read_byte_data(tj9->client, WHO_AM_I);
+	if (retval < 0) {
+		dev_err(&tj9->client->dev, "read err int source\n");
+		goto out;
+	}
+
+	retval = (retval != 0x07 && retval != 0x08) ? -EIO : 0;
+
+out:
+	kxtj9_device_power_off(tj9);
+	return retval;
+}
+
+static int kxtj9_probe(struct i2c_client *client,
+				 const struct i2c_device_id *id)
+{
+	const struct kxtj9_platform_data *pdata = client->dev.platform_data;
+	struct kxtj9_data *tj9;
+	int err;
+
+	if (!i2c_check_functionality(client->adapter,
+				I2C_FUNC_I2C | I2C_FUNC_SMBUS_BYTE_DATA)) {
+		dev_err(&client->dev, "client is not i2c capable\n");
+		return -ENXIO;
+	}
+
+	if (!pdata) {
+		dev_err(&client->dev, "platform data is NULL; exiting\n");
+		return -EINVAL;
+	}
+
+	tj9 = kzalloc(sizeof(*tj9), GFP_KERNEL);
+	if (!tj9) {
+		dev_err(&client->dev,
+			"failed to allocate memory for module data\n");
+		return -ENOMEM;
+	}
+
+	tj9->client = client;
+	tj9->pdata = *pdata;
+
+	if (pdata->init) {
+		err = pdata->init();
+		if (err < 0)
+			goto err_free_mem;
+	}
+
+	err = kxtj9_verify(tj9);
+	if (err < 0) {
+		dev_err(&client->dev, "device not recognized\n");
+		goto err_pdata_exit;
+	}
+
+	i2c_set_clientdata(client, tj9);
+
+	tj9->ctrl_reg1 = tj9->pdata.res_12bit | tj9->pdata.g_range;
+	tj9->last_poll_interval = tj9->pdata.init_interval;
+
+	if (client->irq) {
+		/* If in irq mode, populate INT_CTRL_REG1 and enable DRDY. */
+		tj9->int_ctrl |= KXTJ9_IEN | KXTJ9_IEA | KXTJ9_IEL;
+		tj9->ctrl_reg1 |= DRDYE;
+
+		err = kxtj9_setup_input_device(tj9);
+		if (err)
+			goto err_pdata_exit;
+
+		err = request_threaded_irq(client->irq, NULL, kxtj9_isr,
+					   IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+					   "kxtj9-irq", tj9);
+		if (err) {
+			dev_err(&client->dev, "request irq failed: %d\n", err);
+			goto err_destroy_input;
+		}
+
+		err = sysfs_create_group(&client->dev.kobj, &kxtj9_attribute_group);
+		if (err) {
+			dev_err(&client->dev, "sysfs create failed: %d\n", err);
+			goto err_free_irq;
+		}
+
+	} else {
+		err = kxtj9_setup_polled_device(tj9);
+		if (err)
+			goto err_pdata_exit;
+	}
+
+	return 0;
+
+err_free_irq:
+	free_irq(client->irq, tj9);
+err_destroy_input:
+	input_unregister_device(tj9->input_dev);
+err_pdata_exit:
+	if (tj9->pdata.exit)
+		tj9->pdata.exit();
+err_free_mem:
+	kfree(tj9);
+	return err;
+}
+
+static int kxtj9_remove(struct i2c_client *client)
+{
+	struct kxtj9_data *tj9 = i2c_get_clientdata(client);
+
+	if (client->irq) {
+		sysfs_remove_group(&client->dev.kobj, &kxtj9_attribute_group);
+		free_irq(client->irq, tj9);
+		input_unregister_device(tj9->input_dev);
+	} else {
+		kxtj9_teardown_polled_device(tj9);
+	}
+
+	if (tj9->pdata.exit)
+		tj9->pdata.exit();
+
+	kfree(tj9);
+
+	return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int kxtj9_suspend(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct kxtj9_data *tj9 = i2c_get_clientdata(client);
+	struct input_dev *input_dev = tj9->input_dev;
+
+	mutex_lock(&input_dev->mutex);
+
+	if (input_dev->users)
+		kxtj9_disable(tj9);
+
+	mutex_unlock(&input_dev->mutex);
+	return 0;
+}
+
+static int kxtj9_resume(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct kxtj9_data *tj9 = i2c_get_clientdata(client);
+	struct input_dev *input_dev = tj9->input_dev;
+	int retval = 0;
+
+	mutex_lock(&input_dev->mutex);
+
+	if (input_dev->users)
+		kxtj9_enable(tj9);
+
+	mutex_unlock(&input_dev->mutex);
+	return retval;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(kxtj9_pm_ops, kxtj9_suspend, kxtj9_resume);
+
+static const struct i2c_device_id kxtj9_id[] = {
+	{ NAME, 0 },
+	{ },
+};
+
+MODULE_DEVICE_TABLE(i2c, kxtj9_id);
+
+static struct i2c_driver kxtj9_driver = {
+	.driver = {
+		.name	= NAME,
+		.owner	= THIS_MODULE,
+		.pm	= &kxtj9_pm_ops,
+	},
+	.probe		= kxtj9_probe,
+	.remove		= kxtj9_remove,
+	.id_table	= kxtj9_id,
+};
+
+module_i2c_driver(kxtj9_driver);
+
+MODULE_DESCRIPTION("KXTJ9 accelerometer driver");
+MODULE_AUTHOR("Chris Hudson <chudson@kionix.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/lis3dh.c b/drivers/input/misc/lis3dh.c
new file mode 100644
index 00000000..947c3bbb
--- /dev/null
+++ b/drivers/input/misc/lis3dh.c
@@ -0,0 +1,1707 @@
+/******************** (C) COPYRIGHT 2010 STMicroelectronics ********************
+ *
+ * File Name          : lis3dh_acc.c
+ * Authors            : MSH - Motion Mems BU - Application Team
+ *		      : Carmine Iascone (carmine.iascone@st.com)
+ *		      : Matteo Dameno (matteo.dameno@st.com)
+ * Version            : V.1.0.5
+ * Date               : 16/08/2010
+ * Description        : LIS3DH accelerometer sensor API
+ *
+ *******************************************************************************
+ *
+ * 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.
+ *
+ * THE PRESENT SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES
+ * OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, FOR THE SOLE
+ * PURPOSE TO SUPPORT YOUR APPLICATION DEVELOPMENT.
+ * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+ * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+ * CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+ * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ *
+ * THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS.
+ *
+ ******************************************************************************
+ Revision 1.0.0 05/11/09
+ First Release
+ Revision 1.0.3 22/01/2010
+  Linux K&R Compliant Release;
+ Revision 1.0.5 16/08/2010
+ modified _get_acceleration_data function
+ modified _update_odr function
+ manages 2 interrupts
+
+ ******************************************************************************/
+
+#include	<linux/module.h>
+#include	<linux/err.h>
+#include	<linux/errno.h>
+#include	<linux/delay.h>
+#include	<linux/fs.h>
+#include	<linux/i2c.h>
+
+#include	<linux/input.h>
+#include	<linux/input-polldev.h>
+#include	<linux/miscdevice.h>
+#include	<linux/uaccess.h>
+#include        <linux/slab.h>
+
+#include	<linux/workqueue.h>
+#include	<linux/irq.h>
+#include	<linux/gpio.h>
+#include	<linux/interrupt.h>
+#ifdef CONFIG_HAS_EARLYSUSPEND
+#include        <linux/earlysuspend.h>
+#endif
+
+#include        <linux/i2c/lis3dh.h>
+#include <linux/of_device.h>
+#include <linux/of_address.h>
+#include <linux/of_gpio.h>
+
+#define	INTERRUPT_MANAGEMENT 1
+
+#define	G_MAX		16000	/** Maximum polled-device-reported g value */
+
+/*
+#define	SHIFT_ADJ_2G		4
+#define	SHIFT_ADJ_4G		3
+#define	SHIFT_ADJ_8G		2
+#define	SHIFT_ADJ_16G		1
+*/
+
+#define SENSITIVITY_2G		1	/**	mg/LSB	*/
+#define SENSITIVITY_4G		2	/**	mg/LSB	*/
+#define SENSITIVITY_8G		4	/**	mg/LSB	*/
+#define SENSITIVITY_16G		12	/**	mg/LSB	*/
+
+#define	HIGH_RESOLUTION		0x08
+
+#define	AXISDATA_REG		0x28
+#define WHOAMI_LIS3DH_ACC	0x33	/*      Expctd content for WAI  */
+
+/*	CONTROL REGISTERS	*/
+#define WHO_AM_I		0x0F	/*      WhoAmI register         */
+#define	TEMP_CFG_REG		0x1F	/*      temper sens control reg */
+/* ctrl 1: ODR3 ODR2 ODR ODR0 LPen Zenable Yenable Zenable */
+#define	CTRL_REG1		0x20	/*      control reg 1           */
+#define	CTRL_REG2		0x21	/*      control reg 2           */
+#define	CTRL_REG3		0x22	/*      control reg 3           */
+#define	CTRL_REG4		0x23	/*      control reg 4           */
+#define	CTRL_REG5		0x24	/*      control reg 5           */
+#define	CTRL_REG6		0x25	/*      control reg 6           */
+
+#define	FIFO_CTRL_REG		0x2E	/*      FiFo control reg        */
+
+#define	INT_CFG1		0x30	/*      interrupt 1 config      */
+#define	INT_SRC1		0x31	/*      interrupt 1 source      */
+#define	INT_THS1		0x32	/*      interrupt 1 threshold   */
+#define	INT_DUR1		0x33	/*      interrupt 1 duration    */
+
+#define	INT_CFG2		0x34	/*      interrupt 2 config      */
+#define	INT_SRC2		0x35	/*      interrupt 2 source      */
+#define	INT_THS2		0x36	/*      interrupt 2 threshold   */
+#define	INT_DUR2		0x37	/*      interrupt 2 duration    */
+
+#define	TT_CFG			0x38	/*      tap config              */
+#define	TT_SRC			0x39	/*      tap source              */
+#define	TT_THS			0x3A	/*      tap threshold           */
+#define	TT_LIM			0x3B	/*      tap time limit          */
+#define	TT_TLAT			0x3C	/*      tap time latency        */
+#define	TT_TW			0x3D	/*      tap time window         */
+/*	end CONTROL REGISTRES	*/
+
+#define ENABLE_HIGH_RESOLUTION	1
+
+#define LIS3DH_ACC_PM_OFF		0x00
+#define LIS3DH_ACC_ENABLE_ALL_AXES	0x07
+
+#define PMODE_MASK			0x08
+#define ODR_MASK			0XF0
+
+#define ODR1		0x10	/* 1Hz output data rate */
+#define ODR10		0x20	/* 10Hz output data rate */
+#define ODR25		0x30	/* 25Hz output data rate */
+#define ODR50		0x40	/* 50Hz output data rate */
+#define ODR100		0x50	/* 100Hz output data rate */
+#define ODR200		0x60	/* 200Hz output data rate */
+#define ODR400		0x70	/* 400Hz output data rate */
+#define ODR1250		0x90	/* 1250Hz output data rate */
+
+#define	IA			0x40
+#define	ZH			0x20
+#define	ZL			0x10
+#define	YH			0x08
+#define	YL			0x04
+#define	XH			0x02
+#define	XL			0x01
+/* */
+/* CTRL REG BITS*/
+#define	CTRL_REG3_I1_AOI1	0x40
+#define	CTRL_REG6_I2_TAPEN	0x80
+#define	CTRL_REG6_HLACTIVE	0x02
+/* */
+
+/* TAP_SOURCE_REG BIT */
+#define	DTAP			0x20
+#define	STAP			0x10
+#define	SIGNTAP			0x08
+#define	ZTAP			0x04
+#define	YTAP			0x02
+#define	XTAZ			0x01
+
+#define	FUZZ			32
+#define	FLAT			32
+#define	I2C_RETRY_DELAY		5
+#define	I2C_RETRIES		5
+#define	I2C_AUTO_INCREMENT	0x80
+
+/* RESUME STATE INDICES */
+#define	RES_CTRL_REG1		0
+#define	RES_CTRL_REG2		1
+#define	RES_CTRL_REG3		2
+#define	RES_CTRL_REG4		3
+#define	RES_CTRL_REG5		4
+#define	RES_CTRL_REG6		5
+
+#define	RES_INT_CFG1		6
+#define	RES_INT_THS1		7
+#define	RES_INT_DUR1		8
+#define	RES_INT_CFG2		9
+#define	RES_INT_THS2		10
+#define	RES_INT_DUR2		11
+
+#define	RES_TT_CFG		12
+#define	RES_TT_THS		13
+#define	RES_TT_LIM		14
+#define	RES_TT_TLAT		15
+#define	RES_TT_TW		16
+
+#define	RES_TEMP_CFG_REG	17
+#define	RES_REFERENCE_REG	18
+#define	RES_FIFO_CTRL_REG	19
+
+#define	RESUME_ENTRIES		20
+#define DEVICE_INFO             "ST, LIS3DH"
+#define DEVICE_INFO_LEN         32
+/* end RESUME STATE INDICES */
+
+#define GSENSOR_GINT1_GPI 0
+#define GSENSOR_GINT2_GPI 1
+
+struct {
+	unsigned int cutoff_ms;
+	unsigned int mask;
+} lis3dh_acc_odr_table[] = {
+	{
+	1, ODR1250}, {
+	3, ODR400}, {
+	5, ODR200}, {
+	10, ODR100}, {
+	20, ODR50}, {
+	40, ODR25}, {
+	100, ODR10}, {
+1000, ODR1},};
+
+struct lis3dh_acc_data {
+	struct i2c_client *client;
+	struct lis3dh_acc_platform_data *pdata;
+
+	struct mutex lock;
+	struct delayed_work input_work;
+
+	struct input_dev *input_dev;
+
+	int hw_initialized;
+	/* hw_working=-1 means not tested yet */
+	int hw_working;
+	atomic_t enabled;
+	int on_before_suspend;
+
+	u8 sensitivity;
+
+	u8 resume_state[RESUME_ENTRIES];
+
+	int irq1;
+	struct work_struct irq1_work;
+	struct workqueue_struct *irq1_work_queue;
+	int irq2;
+	struct work_struct irq2_work;
+	struct workqueue_struct *irq2_work_queue;
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	struct early_suspend early_suspend;
+#endif
+};
+
+/*
+ * Because misc devices can not carry a pointer from driver register to
+ * open, we keep this global.  This limits the driver to a single instance.
+ */
+struct lis3dh_acc_data *lis3dh_acc_misc_data;
+struct i2c_client *lis3dh_i2c_client;
+
+static int lis3dh_acc_i2c_read(struct lis3dh_acc_data *acc, u8 * buf, int len)
+{
+	int err;
+	int tries = 0;
+
+	struct i2c_msg msgs[] = {
+		{
+		 .addr = acc->client->addr,
+		 .flags = acc->client->flags & I2C_M_TEN,
+		 .len = 1,
+		 .buf = buf,},
+		{
+		 .addr = acc->client->addr,
+		 .flags = (acc->client->flags & I2C_M_TEN) | I2C_M_RD,
+		 .len = len,
+		 .buf = buf,},
+	};
+
+	do {
+		err = i2c_transfer(acc->client->adapter, msgs, 2);
+		if (err != 2)
+			msleep_interruptible(I2C_RETRY_DELAY);
+	} while ((err != 2) && (++tries < I2C_RETRIES));
+
+	if (err != 2) {
+		dev_err(&acc->client->dev, "read transfer error\n");
+		err = -EIO;
+	} else {
+		err = 0;
+	}
+
+	return err;
+}
+
+static int lis3dh_acc_i2c_write(struct lis3dh_acc_data *acc, u8 * buf, int len)
+{
+	int err;
+	int tries = 0;
+
+	struct i2c_msg msgs[] = { {.addr = acc->client->addr,
+				   .flags = acc->client->flags & I2C_M_TEN,
+				   .len = len + 1,.buf = buf,},
+	};
+	do {
+		err = i2c_transfer(acc->client->adapter, msgs, 1);
+		if (err != 1)
+			msleep_interruptible(I2C_RETRY_DELAY);
+	} while ((err != 1) && (++tries < I2C_RETRIES));
+
+	if (err != 1) {
+		dev_err(&acc->client->dev, "write transfer error\n");
+		err = -EIO;
+	} else {
+		err = 0;
+	}
+
+	return err;
+}
+
+static int lis3dh_acc_hw_init(struct lis3dh_acc_data *acc)
+{
+	int err = -1;
+	u8 buf[7];
+
+	pr_debug("%s: hw init start\n", LIS3DH_ACC_DEV_NAME);
+
+	buf[0] = WHO_AM_I;
+	err = lis3dh_acc_i2c_read(acc, buf, 1);
+	if (err < 0)
+		goto error_firstread;
+	else
+		acc->hw_working = 1;
+	if (buf[0] != WHOAMI_LIS3DH_ACC) {
+		err = -1;	/* choose the right coded error */
+		goto error_unknown_device;
+	}
+
+	buf[0] = CTRL_REG1;
+	buf[1] = acc->resume_state[RES_CTRL_REG1];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = TEMP_CFG_REG;
+	buf[1] = acc->resume_state[RES_TEMP_CFG_REG];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = FIFO_CTRL_REG;
+	buf[1] = acc->resume_state[RES_FIFO_CTRL_REG];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = (I2C_AUTO_INCREMENT | TT_THS);
+	buf[1] = acc->resume_state[RES_TT_THS];
+	buf[2] = acc->resume_state[RES_TT_LIM];
+	buf[3] = acc->resume_state[RES_TT_TLAT];
+	buf[4] = acc->resume_state[RES_TT_TW];
+	err = lis3dh_acc_i2c_write(acc, buf, 4);
+	if (err < 0)
+		goto error1;
+	buf[0] = TT_CFG;
+	buf[1] = acc->resume_state[RES_TT_CFG];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = (I2C_AUTO_INCREMENT | INT_THS1);
+	buf[1] = acc->resume_state[RES_INT_THS1];
+	buf[2] = acc->resume_state[RES_INT_DUR1];
+	err = lis3dh_acc_i2c_write(acc, buf, 2);
+	if (err < 0)
+		goto error1;
+	buf[0] = INT_CFG1;
+	buf[1] = acc->resume_state[RES_INT_CFG1];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = (I2C_AUTO_INCREMENT | INT_THS2);
+	buf[1] = acc->resume_state[RES_INT_THS2];
+	buf[2] = acc->resume_state[RES_INT_DUR2];
+	err = lis3dh_acc_i2c_write(acc, buf, 2);
+	if (err < 0)
+		goto error1;
+	buf[0] = INT_CFG2;
+	buf[1] = acc->resume_state[RES_INT_CFG2];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = (I2C_AUTO_INCREMENT | CTRL_REG2);
+	buf[1] = acc->resume_state[RES_CTRL_REG2];
+	buf[2] = acc->resume_state[RES_CTRL_REG3];
+	buf[3] = acc->resume_state[RES_CTRL_REG4];
+	buf[4] = acc->resume_state[RES_CTRL_REG5];
+	buf[5] = acc->resume_state[RES_CTRL_REG6];
+	err = lis3dh_acc_i2c_write(acc, buf, 5);
+	if (err < 0)
+		goto error1;
+
+	acc->hw_initialized = 1;
+	pr_debug("%s: hw init done\n", LIS3DH_ACC_DEV_NAME);
+	return 0;
+
+error_firstread:
+	acc->hw_working = 0;
+	dev_warn(&acc->client->dev, "Error reading WHO_AM_I: is device "
+		 "available/working?\n");
+	goto error1;
+error_unknown_device:
+	dev_err(&acc->client->dev,
+		"device unknown. Expected: 0x%x,"
+		" Replies: 0x%x\n", WHOAMI_LIS3DH_ACC, buf[0]);
+error1:
+	acc->hw_initialized = 0;
+	dev_err(&acc->client->dev, "hw init error 0x%x,0x%x: %d\n", buf[0],
+		buf[1], err);
+	return err;
+}
+
+static void lis3dh_acc_device_power_off(struct lis3dh_acc_data *acc)
+{
+	int err;
+	u8 buf[2] = { CTRL_REG1, LIS3DH_ACC_PM_OFF };
+
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		dev_err(&acc->client->dev, "soft power off failed: %d\n", err);
+
+	if (acc->pdata->power_off) {
+		if (acc->irq1 != 0)
+			disable_irq_nosync(acc->irq1);
+		if (acc->irq2 != 0)
+			disable_irq_nosync(acc->irq2);
+		acc->pdata->power_off();
+		acc->hw_initialized = 0;
+	}
+	if (acc->hw_initialized) {
+		if (acc->irq1 != 0)
+			disable_irq_nosync(acc->irq1);
+		if (acc->irq2 != 0)
+			disable_irq_nosync(acc->irq2);
+		acc->hw_initialized = 0;
+	}
+}
+
+static int lis3dh_acc_device_power_on(struct lis3dh_acc_data *acc)
+{
+	int err = -1;
+
+	if (acc->pdata->power_on) {
+		err = acc->pdata->power_on();
+		if (err < 0) {
+			dev_err(&acc->client->dev,
+				"power_on failed: %d\n", err);
+			return err;
+		}
+	}
+
+	if (!acc->hw_initialized) {
+		err = lis3dh_acc_hw_init(acc);
+		if (acc->hw_working == 1 && err < 0) {
+			lis3dh_acc_device_power_off(acc);
+			return err;
+		}
+	}
+	return 0;
+}
+
+static irqreturn_t lis3dh_acc_isr1(int irq, void *dev)
+{
+	struct lis3dh_acc_data *acc = dev;
+
+	disable_irq_nosync(irq);
+	queue_work(acc->irq1_work_queue, &acc->irq1_work);
+
+	pr_debug("%s: isr1 queued\n", LIS3DH_ACC_DEV_NAME);
+
+	return IRQ_HANDLED;
+}
+
+static irqreturn_t lis3dh_acc_isr2(int irq, void *dev)
+{
+	struct lis3dh_acc_data *acc = dev;
+
+	disable_irq_nosync(irq);
+	queue_work(acc->irq2_work_queue, &acc->irq2_work);
+
+	pr_debug("%s: isr2 queued\n", LIS3DH_ACC_DEV_NAME);
+
+	return IRQ_HANDLED;
+}
+
+static void lis3dh_acc_irq1_work_func(struct work_struct *work)
+{
+
+	/*struct lis3dh_acc_data *acc =
+	    container_of(work, struct lis3dh_acc_data, irq1_work);
+	*/
+	/* TODO  add interrupt service procedure.
+	   ie:lis3dh_acc_get_int1_source(acc); */
+	;
+	/*  */
+	pr_debug("%s: IRQ1 triggered\n", LIS3DH_ACC_DEV_NAME);
+}
+
+static void lis3dh_acc_irq2_work_func(struct work_struct *work)
+{
+
+	/*struct lis3dh_acc_data *acc =
+	    container_of(work, struct lis3dh_acc_data, irq2_work);
+	*/
+	/* TODO  add interrupt service procedure.
+	   ie:lis3dh_acc_get_tap_source(acc); */
+	;
+	/*  */
+
+	pr_debug("%s: IRQ2 triggered\n", LIS3DH_ACC_DEV_NAME);
+}
+
+int lis3dh_acc_update_g_range(struct lis3dh_acc_data *acc, u8 new_g_range)
+{
+	int err;
+
+	u8 sensitivity;
+	u8 buf[2];
+	u8 updated_val;
+	u8 init_val;
+	u8 new_val;
+	u8 mask = LIS3DH_ACC_FS_MASK | HIGH_RESOLUTION;
+
+	pr_debug("%s\n", __func__);
+
+	switch (new_g_range) {
+	case LIS3DH_ACC_G_2G:
+
+		sensitivity = SENSITIVITY_2G;
+		break;
+	case LIS3DH_ACC_G_4G:
+
+		sensitivity = SENSITIVITY_4G;
+		break;
+	case LIS3DH_ACC_G_8G:
+
+		sensitivity = SENSITIVITY_8G;
+		break;
+	case LIS3DH_ACC_G_16G:
+
+		sensitivity = SENSITIVITY_16G;
+		break;
+	default:
+		dev_err(&acc->client->dev, "invalid g range requested: %u\n",
+			new_g_range);
+		return -EINVAL;
+	}
+
+	if (atomic_read(&acc->enabled)) {
+		/* Set configuration register 4, which contains g range setting
+		 *  NOTE: this is a straight overwrite because this driver does
+		 *  not use any of the other configuration bits in this
+		 *  register.  Should this become untrue, we will have to read
+		 *  out the value and only change the relevant bits --XX----
+		 *  (marked by X) */
+		buf[0] = CTRL_REG4;
+		err = lis3dh_acc_i2c_read(acc, buf, 1);
+		if (err < 0)
+			goto error;
+		init_val = buf[0];
+		acc->resume_state[RES_CTRL_REG4] = init_val;
+		new_val = new_g_range | HIGH_RESOLUTION;
+		updated_val = ((mask & new_val) | ((~mask) & init_val));
+		buf[1] = updated_val;
+		buf[0] = CTRL_REG4;
+		err = lis3dh_acc_i2c_write(acc, buf, 1);
+		if (err < 0)
+			goto error;
+		acc->resume_state[RES_CTRL_REG4] = updated_val;
+		acc->sensitivity = sensitivity;
+
+		pr_debug("%s sensitivity %d g-range %d\n", __func__, sensitivity,new_g_range);
+	}
+
+	return 0;
+error:
+	dev_err(&acc->client->dev, "update g range failed 0x%x,0x%x: %d\n",
+		buf[0], buf[1], err);
+
+	return err;
+}
+
+int lis3dh_acc_update_odr(struct lis3dh_acc_data *acc, int poll_interval_ms)
+{
+	int err = -1;
+	int i;
+	u8 config[2];
+
+	/* Convert the poll interval into an output data rate configuration
+	 *  that is as low as possible.  The ordering of these checks must be
+	 *  maintained due to the cascading cut off values - poll intervals are
+	 *  checked from shortest to longest.  At each check, if the next lower
+	 *  ODR cannot support the current poll interval, we stop searching */
+	for (i = ARRAY_SIZE(lis3dh_acc_odr_table) - 1; i >= 0; i--) {
+		if (lis3dh_acc_odr_table[i].cutoff_ms <= poll_interval_ms)
+			break;
+	}
+	config[1] = lis3dh_acc_odr_table[i].mask;
+
+	config[1] |= LIS3DH_ACC_ENABLE_ALL_AXES;
+
+	/* If device is currently enabled, we need to write new
+	 *  configuration out to it */
+	if (atomic_read(&acc->enabled)) {
+		config[0] = CTRL_REG1;
+		err = lis3dh_acc_i2c_write(acc, config, 1);
+		if (err < 0)
+			goto error;
+		acc->resume_state[RES_CTRL_REG1] = config[1];
+	}
+
+	return 0;
+
+error:
+	dev_err(&acc->client->dev, "update odr failed 0x%x,0x%x: %d\n",
+		config[0], config[1], err);
+
+	return err;
+}
+
+/* */
+
+static int lis3dh_acc_register_write(struct lis3dh_acc_data *acc, u8 * buf,
+				     u8 reg_address, u8 new_value)
+{
+	int err = -1;
+
+	if (atomic_read(&acc->enabled)) {
+		/* Sets configuration register at reg_address
+		 *  NOTE: this is a straight overwrite  */
+		buf[0] = reg_address;
+		buf[1] = new_value;
+		err = lis3dh_acc_i2c_write(acc, buf, 1);
+		if (err < 0)
+			return err;
+	}
+	return err;
+}
+
+static int lis3dh_acc_register_read(struct lis3dh_acc_data *acc, u8 * buf,
+				    u8 reg_address)
+{
+
+	int err = -1;
+	buf[0] = (reg_address);
+	err = lis3dh_acc_i2c_read(acc, buf, 1);
+	return err;
+}
+
+static int lis3dh_acc_register_update(struct lis3dh_acc_data *acc, u8 * buf,
+				      u8 reg_address, u8 mask,
+				      u8 new_bit_values)
+{
+	int err = -1;
+	u8 init_val;
+	u8 updated_val;
+	err = lis3dh_acc_register_read(acc, buf, reg_address);
+	if (!(err < 0)) {
+		init_val = buf[1];
+		updated_val = ((mask & new_bit_values) | ((~mask) & init_val));
+		err = lis3dh_acc_register_write(acc, buf, reg_address,
+						updated_val);
+	}
+	return err;
+}
+
+/* */
+
+static int lis3dh_acc_get_acceleration_data(struct lis3dh_acc_data *acc,
+					    int *xyz)
+{
+	int err = -1;
+	/* Data bytes from hardware xL, xH, yL, yH, zL, zH */
+	u8 acc_data[6];
+	/* x,y,z hardware data */
+	s16 hw_d[3] = { 0 };
+
+	acc_data[0] = (I2C_AUTO_INCREMENT | AXISDATA_REG);
+	err = lis3dh_acc_i2c_read(acc, acc_data, 6);
+
+	if (err < 0) {
+		pr_debug("%s I2C read error %d\n", LIS3DH_ACC_I2C_NAME,
+		       err);
+		return err;
+	}
+
+	hw_d[0] = (((s16) ((acc_data[1] << 8) | acc_data[0])) >> 4);
+	hw_d[1] = (((s16) ((acc_data[3] << 8) | acc_data[2])) >> 4);
+	hw_d[2] = (((s16) ((acc_data[5] << 8) | acc_data[4])) >> 4);
+
+	hw_d[0] = hw_d[0] * acc->sensitivity;
+	hw_d[1] = hw_d[1] * acc->sensitivity;
+	hw_d[2] = hw_d[2] * acc->sensitivity;
+
+	xyz[0] = ((acc->pdata->negate_x) ? (-hw_d[acc->pdata->axis_map_x])
+		  : (hw_d[acc->pdata->axis_map_x]));
+	xyz[1] = ((acc->pdata->negate_y) ? (-hw_d[acc->pdata->axis_map_y])
+		  : (hw_d[acc->pdata->axis_map_y]));
+	xyz[2] = ((acc->pdata->negate_z) ? (-hw_d[acc->pdata->axis_map_z])
+		  : (hw_d[acc->pdata->axis_map_z]));
+
+	pr_debug("%s read x=%d, y=%d, z=%d\n",
+	       LIS3DH_ACC_DEV_NAME, xyz[0], xyz[1], xyz[2]);
+
+	return err;
+}
+
+static void lis3dh_acc_report_values(struct lis3dh_acc_data *acc, int *xyz)
+{
+	input_report_abs(acc->input_dev, ABS_X, xyz[0]);
+	input_report_abs(acc->input_dev, ABS_Y, xyz[1]);
+	input_report_abs(acc->input_dev, ABS_Z, xyz[2]);
+	input_sync(acc->input_dev);
+}
+
+static int lis3dh_acc_enable(struct lis3dh_acc_data *acc)
+{
+	int err;
+	printk("sprd-gsensor: -- %s -- !\n",__func__);
+	if (!atomic_cmpxchg(&acc->enabled, 0, 1)) {
+		err = lis3dh_acc_device_power_on(acc);
+		if (err < 0) {
+			atomic_set(&acc->enabled, 0);
+			return err;
+		}
+
+		if (acc->hw_initialized) {
+			if (acc->irq1 != 0)
+				enable_irq(acc->irq1);
+			if (acc->irq2 != 0)
+				enable_irq(acc->irq2);
+			pr_debug("%s: power on: irq enabled\n",
+			       LIS3DH_ACC_DEV_NAME);
+		}
+
+		schedule_delayed_work(&acc->input_work,
+				      msecs_to_jiffies(acc->pdata->
+						       poll_interval));
+	}
+	printk("sprd-gsensor: -- %s -- success!\n",__func__);
+	return 0;
+}
+
+static int lis3dh_acc_disable(struct lis3dh_acc_data *acc)
+{
+	printk("sprd-gsensor: -- %s -- \n",__func__);
+	if (atomic_cmpxchg(&acc->enabled, 1, 0)) {
+		cancel_delayed_work_sync(&acc->input_work);
+		lis3dh_acc_device_power_off(acc);
+	}
+
+	return 0;
+}
+
+static int lis3dh_acc_misc_open(struct inode *inode, struct file *file)
+{
+	int err;
+	err = nonseekable_open(inode, file);
+	if (err < 0)
+		return err;
+
+	file->private_data = lis3dh_acc_misc_data;
+
+	return 0;
+}
+
+static long lis3dh_acc_misc_ioctl(struct file *file, unsigned int cmd,
+				unsigned long arg)
+{
+	void __user *argp = (void __user *)arg;
+	u8 buf[4];
+	u8 mask;
+	u8 reg_address;
+	u8 bit_values;
+	int err;
+	int interval;
+	int xyz[3] = { 0 };
+	struct lis3dh_acc_data *acc = file->private_data;
+
+	switch (cmd) {
+	case LIS3DH_ACC_IOCTL_GET_DELAY:
+		interval = acc->pdata->poll_interval;
+		if (copy_to_user(argp, &interval, sizeof(interval)))
+			return -EFAULT;
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_DELAY:
+		if (copy_from_user(&interval, argp, sizeof(interval)))
+			return -EFAULT;
+		if (interval < 0 || interval > 1000)
+			return -EINVAL;
+
+		acc->pdata->poll_interval = max(interval,
+			acc->pdata->min_interval);
+err = lis3dh_acc_update_odr(acc, 2);
+		/* TODO: if update fails poll is still set */
+		if (err < 0)
+			return err;
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_ENABLE:
+		if (copy_from_user(&interval, argp, sizeof(interval)))
+			return -EFAULT;
+		if (interval > 1)
+			return -EINVAL;
+		if (interval)
+			err = lis3dh_acc_enable(acc);
+		else
+			err = lis3dh_acc_disable(acc);
+		return err;
+		break;
+
+	case LIS3DH_ACC_IOCTL_GET_ENABLE:
+		interval = atomic_read(&acc->enabled);
+		if (copy_to_user(argp, &interval, sizeof(interval)))
+			return -EINVAL;
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_G_RANGE:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		bit_values = buf[0];
+		err = lis3dh_acc_update_g_range(acc, bit_values);
+		if (err < 0)
+			return err;
+		break;
+
+#ifdef INTERRUPT_MANAGEMENT
+	case LIS3DH_ACC_IOCTL_SET_CTRL_REG3:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = CTRL_REG3;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_CTRL_REG3] = ((mask & bit_values) |
+						    (~mask & acc->
+						     resume_state
+						     [RES_CTRL_REG3]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_CTRL_REG6:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = CTRL_REG6;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_CTRL_REG6] = ((mask & bit_values) |
+						    (~mask & acc->
+						     resume_state
+						     [RES_CTRL_REG6]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_DURATION1:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		reg_address = INT_DUR1;
+		mask = 0x7F;
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_DUR1] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_DUR1]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_THRESHOLD1:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		reg_address = INT_THS1;
+		mask = 0x7F;
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_THS1] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_THS1]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_CONFIG1:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = INT_CFG1;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_CFG1] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_CFG1]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_GET_SOURCE1:
+		err = lis3dh_acc_register_read(acc, buf, INT_SRC1);
+		if (err < 0)
+			return err;
+
+		pr_debug("INT1_SRC content: %d , 0x%x\n", buf[0], buf[0]);
+
+		if (copy_to_user(argp, buf, 1))
+			return -EINVAL;
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_DURATION2:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		reg_address = INT_DUR2;
+		mask = 0x7F;
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_DUR2] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_DUR2]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_THRESHOLD2:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		reg_address = INT_THS2;
+		mask = 0x7F;
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_THS2] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_THS2]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_CONFIG2:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = INT_CFG2;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_CFG2] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_CFG2]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_GET_SOURCE2:
+		err = lis3dh_acc_register_read(acc, buf, INT_SRC2);
+		if (err < 0)
+			return err;
+
+		pr_debug("INT2_SRC content: %d , 0x%x\n", buf[0], buf[0]);
+
+		if (copy_to_user(argp, buf, 1))
+			return -EINVAL;
+		break;
+
+	case LIS3DH_ACC_IOCTL_GET_TAP_SOURCE:
+		err = lis3dh_acc_register_read(acc, buf, TT_SRC);
+		if (err < 0)
+			return err;
+		pr_debug("TT_SRC content: %d , 0x%x\n", buf[0], buf[0]);
+
+		if (copy_to_user(argp, buf, 1)) {
+			pr_err("%s: %s error in copy_to_user \n",
+			       LIS3DH_ACC_DEV_NAME, __func__);
+			return -EINVAL;
+		}
+		break;
+	case LIS3DH_ACC_IOCTL_GET_COOR_XYZ:
+		err = lis3dh_acc_get_acceleration_data(acc, xyz);
+		if (err < 0)
+			return err;
+
+		if (copy_to_user(argp, xyz, sizeof(xyz))) {
+			pr_err(" %s %d error in copy_to_user \n",
+			       __func__, __LINE__);
+			return -EINVAL;
+		}
+		break;
+	case LIS3DH_ACC_IOCTL_SET_TAP_CFG:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_CFG;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_CFG] = ((mask & bit_values) |
+						 (~mask & acc->
+						  resume_state[RES_TT_CFG]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_TAP_TLIM:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_LIM;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_LIM] = ((mask & bit_values) |
+						 (~mask & acc->
+						  resume_state[RES_TT_LIM]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_TAP_THS:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_THS;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_THS] = ((mask & bit_values) |
+						 (~mask & acc->
+						  resume_state[RES_TT_THS]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_TAP_TLAT:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_TLAT;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_TLAT] = ((mask & bit_values) |
+						  (~mask & acc->
+						   resume_state[RES_TT_TLAT]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_TAP_TW:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_TW;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_TW] = ((mask & bit_values) |
+						(~mask & acc->
+						 resume_state[RES_TT_TW]));
+		break;
+
+#endif /* INTERRUPT_MANAGEMENT */
+	case LIS3DH_ACC_IOCTL_GET_CHIP_ID:
+	    {
+	        u8 devid = 0;
+	        u8 devinfo[DEVICE_INFO_LEN] = {0};
+	        err = lis3dh_acc_register_read(acc, &devid, WHO_AM_I);
+	        if (err < 0) {
+	            printk("__func__, error read register WHO_AM_I\n", __func__);
+	            return -EAGAIN;
+	        }
+	        sprintf(devinfo, "%s, %#x", DEVICE_INFO, devid);
+
+	        if (copy_to_user(argp, devinfo, sizeof(devinfo))) {
+	            printk("%s error in copy_to_user(IOCTL_GET_CHIP_ID)\n", __func__);
+	            return -EINVAL;
+	        }
+	    }
+	   break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static const struct file_operations lis3dh_acc_misc_fops = {
+	.owner = THIS_MODULE,
+	.open = lis3dh_acc_misc_open,
+	.unlocked_ioctl = lis3dh_acc_misc_ioctl,
+};
+
+static struct miscdevice lis3dh_acc_misc_device = {
+	.minor = MISC_DYNAMIC_MINOR,
+	.name = LIS3DH_ACC_DEV_NAME,
+	.fops = &lis3dh_acc_misc_fops,
+};
+
+static void lis3dh_acc_input_work_func(struct work_struct *work)
+{
+	struct lis3dh_acc_data *acc;
+
+	int xyz[3] = { 0 };
+	int err;
+
+	acc = container_of((struct delayed_work *)work,
+			   struct lis3dh_acc_data, input_work);
+
+	mutex_lock(&acc->lock);
+	err = lis3dh_acc_get_acceleration_data(acc, xyz);
+	if (err < 0)
+		dev_err(&acc->client->dev, "get_acceleration_data failed\n");
+	else
+		lis3dh_acc_report_values(acc, xyz);
+
+	schedule_delayed_work(&acc->input_work,
+			      msecs_to_jiffies(acc->pdata->poll_interval));
+	mutex_unlock(&acc->lock);
+}
+
+#ifdef LIS3DH_OPEN_ENABLE
+int lis3dh_acc_input_open(struct input_dev *input)
+{
+	struct lis3dh_acc_data *acc = input_get_drvdata(input);
+
+	return lis3dh_acc_enable(acc);
+}
+
+void lis3dh_acc_input_close(struct input_dev *dev)
+{
+	struct lis3dh_acc_data *acc = input_get_drvdata(dev);
+
+	lis3dh_acc_disable(acc);
+}
+#endif
+
+static int lis3dh_acc_validate_pdata(struct lis3dh_acc_data *acc)
+{
+	acc->pdata->poll_interval = max(acc->pdata->poll_interval,
+					acc->pdata->min_interval);
+
+	if (acc->pdata->axis_map_x > 2 || acc->pdata->axis_map_y > 2
+	    || acc->pdata->axis_map_z > 2) {
+		dev_err(&acc->client->dev, "invalid axis_map value "
+			"x:%u y:%u z%u\n", acc->pdata->axis_map_x,
+			acc->pdata->axis_map_y, acc->pdata->axis_map_z);
+		return -EINVAL;
+	}
+
+	/* Only allow 0 and 1 for negation boolean flag */
+	if (acc->pdata->negate_x > 1 || acc->pdata->negate_y > 1
+	    || acc->pdata->negate_z > 1) {
+		dev_err(&acc->client->dev, "invalid negate value "
+			"x:%u y:%u z:%u\n", acc->pdata->negate_x,
+			acc->pdata->negate_y, acc->pdata->negate_z);
+		return -EINVAL;
+	}
+
+	/* Enforce minimum polling interval */
+	if (acc->pdata->poll_interval < acc->pdata->min_interval) {
+		dev_err(&acc->client->dev, "minimum poll interval violated\n");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int lis3dh_acc_input_init(struct lis3dh_acc_data *acc)
+{
+	int err;
+	/* Polling rx data when the interrupt is not used.*/
+	if (1 /*acc->irq1 == 0 && acc->irq1 == 0 */ ) {
+		INIT_DELAYED_WORK(&acc->input_work, lis3dh_acc_input_work_func);
+	}
+
+	acc->input_dev = input_allocate_device();
+	if (!acc->input_dev) {
+		err = -ENOMEM;
+		dev_err(&acc->client->dev, "input device allocate failed\n");
+		goto err0;
+	}
+#ifdef LIS3DH_ACC_OPEN_ENABLE
+	acc->input_dev->open = lis3dh_acc_input_open;
+	acc->input_dev->close = lis3dh_acc_input_close;
+#endif
+
+	input_set_drvdata(acc->input_dev, acc);
+
+	set_bit(EV_ABS, acc->input_dev->evbit);
+	/*      next is used for interruptA sources data if the case */
+	set_bit(ABS_MISC, acc->input_dev->absbit);
+	/*      next is used for interruptB sources data if the case */
+	set_bit(ABS_WHEEL, acc->input_dev->absbit);
+
+	input_set_abs_params(acc->input_dev, ABS_X, -G_MAX, G_MAX, 0, 0);
+	input_set_abs_params(acc->input_dev, ABS_Y, -G_MAX, G_MAX, 0, 0);
+	input_set_abs_params(acc->input_dev, ABS_Z, -G_MAX, G_MAX, 0, 0);
+	/*      next is used for interruptA sources data if the case */
+	input_set_abs_params(acc->input_dev, ABS_MISC, INT_MIN, INT_MAX, 0, 0);
+	/*      next is used for interruptB sources data if the case */
+	input_set_abs_params(acc->input_dev, ABS_WHEEL, INT_MIN, INT_MAX, 0, 0);
+
+	acc->input_dev->name = "accelerometer";
+
+	err = input_register_device(acc->input_dev);
+	if (err) {
+		dev_err(&acc->client->dev,
+			"unable to register input polled device %s\n",
+			acc->input_dev->name);
+		goto err1;
+	}
+
+	return 0;
+
+err1:
+	input_free_device(acc->input_dev);
+err0:
+	return err;
+}
+
+static void lis3dh_acc_input_cleanup(struct lis3dh_acc_data *acc)
+{
+	input_unregister_device(acc->input_dev);
+	input_free_device(acc->input_dev);
+}
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+static void lis3dh_early_suspend(struct early_suspend *es);
+static void lis3dh_early_resume(struct early_suspend *es);
+#endif
+
+#ifdef CONFIG_OF
+static struct lis3dh_acc_platform_data *lis3dh_acc_parse_dt(struct device *dev)
+{
+	struct lis3dh_acc_platform_data *pdata;
+	struct device_node *np = dev->of_node;
+	int ret;
+	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+	if (!pdata) {
+		dev_err(dev, "Could not allocate struct lis3dh_acc_platform_data");
+		return NULL;
+	}
+	ret = of_property_read_u32(np, "poll_interval", &pdata->poll_interval);
+	if(ret){
+		dev_err(dev, "fail to get poll_interval\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "min_interval", &pdata->min_interval);
+	if(ret){
+		dev_err(dev, "fail to get min_interval\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "g_range", &pdata->g_range);
+	if(ret){
+		dev_err(dev, "fail to get g_range\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "axis_map_x", &pdata->axis_map_x);
+	if(ret){
+		dev_err(dev, "fail to get axis_map_x\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "axis_map_y", &pdata->axis_map_y);
+	if(ret){
+		dev_err(dev, "fail to get axis_map_y\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "axis_map_z", &pdata->axis_map_z);
+	if(ret){
+		dev_err(dev, "fail to get axis_map_z\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "negate_x", &pdata->negate_x);
+	if(ret){
+		dev_err(dev, "fail to get negate_x\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "negate_y", &pdata->negate_y);
+	if(ret){
+		dev_err(dev, "fail to get negate_y\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "negate_z", &pdata->negate_z);
+	if(ret){
+		dev_err(dev, "fail to get negate_z\n");
+		goto fail;
+	}
+	return pdata;
+fail:
+	kfree(pdata);
+	return NULL;
+}
+#endif
+static int lis3dh_acc_probe(struct i2c_client *client,
+			    const struct i2c_device_id *id)
+{
+
+	struct lis3dh_acc_data *acc;
+	struct lis3dh_acc_platform_data *pdata = client->dev.platform_data;
+
+	int err = -1;
+	int tempvalue;
+	printk("sprd-gsensor: -- %s -- start !\n",__func__);
+	pr_debug("%s: probe start.\n", LIS3DH_ACC_DEV_NAME);
+
+#ifdef CONFIG_OF
+	struct device_node *np = client->dev.of_node;
+	if (np && !pdata){
+		pdata = lis3dh_acc_parse_dt(&client->dev);
+		if(pdata){
+			client->dev.platform_data = pdata;
+		}
+		if(!pdata){
+			err = -ENOMEM;
+			goto exit_alloc_platform_data_failed;
+		}
+	}
+#endif
+	/*
+	if (client->dev.platform_data == NULL) {
+		dev_err(&client->dev, "platform data is NULL. exiting.\n");
+		err = -ENODEV;
+		goto exit_check_functionality_failed;
+	}
+	*/
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+		dev_err(&client->dev, "client not i2c capable\n");
+		err = -ENODEV;
+		goto exit_check_functionality_failed;
+	}
+
+	if (!i2c_check_functionality(client->adapter,
+				     I2C_FUNC_SMBUS_BYTE |
+				     I2C_FUNC_SMBUS_BYTE_DATA |
+				     I2C_FUNC_SMBUS_WORD_DATA)) {
+		dev_err(&client->dev, "client not smb-i2c capable:2\n");
+		err = -EIO;
+		goto exit_check_functionality_failed;
+	}
+
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
+		dev_err(&client->dev, "client not smb-i2c capable:3\n");
+		err = -EIO;
+		goto exit_check_functionality_failed;
+	}
+	/*
+	 * OK. From now, we presume we have a valid client. We now create the
+	 * client structure, even though we cannot fill it completely yet.
+	 */
+
+	acc = kzalloc(sizeof(struct lis3dh_acc_data), GFP_KERNEL);
+	if (acc == NULL) {
+		err = -ENOMEM;
+		dev_err(&client->dev,
+			"failed to allocate memory for module data: "
+			"%d\n", err);
+		goto exit_alloc_data_failed;
+	}
+
+	mutex_init(&acc->lock);
+	mutex_lock(&acc->lock);
+
+	acc->client = client;
+	lis3dh_i2c_client = client;
+	i2c_set_clientdata(client, acc);
+
+	pr_debug("%s: %s has set irq1 to irq: %d\n",
+	       LIS3DH_ACC_DEV_NAME, __func__, acc->irq1);
+	pr_debug("%s: %s has set irq2 to irq: %d\n",
+	       LIS3DH_ACC_DEV_NAME, __func__, acc->irq2);
+
+	gpio_request(GSENSOR_GINT1_GPI, "GSENSOR_INT1");
+	gpio_request(GSENSOR_GINT2_GPI, "GSENSOR_INT2");
+	acc->irq1 = 0; /* gpio_to_irq(GSENSOR_GINT1_GPI); */
+	acc->irq2 = 0; /* gpio_to_irq(GSENSOR_GINT2_GPI); */
+
+	if (acc->irq1 != 0) {
+		pr_debug("%s request irq1\n", __func__);
+		err =
+		    request_irq(acc->irq1, lis3dh_acc_isr1, IRQF_TRIGGER_RISING,
+				"lis3dh_acc_irq1", acc);
+		if (err < 0) {
+			dev_err(&client->dev, "request irq1 failed: %d\n", err);
+			goto err_mutexunlockfreedata;
+		}
+		disable_irq_nosync(acc->irq1);
+
+		INIT_WORK(&acc->irq1_work, lis3dh_acc_irq1_work_func);
+		acc->irq1_work_queue =
+		    create_singlethread_workqueue("lis3dh_acc_wq1");
+		if (!acc->irq1_work_queue) {
+			err = -ENOMEM;
+			dev_err(&client->dev, "cannot create work queue1: %d\n",
+				err);
+			goto err_free_irq1;
+		}
+	}
+
+	if (acc->irq2 != 0) {
+		err =
+		    request_irq(acc->irq2, lis3dh_acc_isr2, IRQF_TRIGGER_RISING,
+				"lis3dh_acc_irq2", acc);
+		if (err < 0) {
+			dev_err(&client->dev, "request irq2 failed: %d\n", err);
+			goto err_destoyworkqueue1;
+		}
+		disable_irq_nosync(acc->irq2);
+
+/*		 Create workqueue for IRQ.*/
+
+		INIT_WORK(&acc->irq2_work, lis3dh_acc_irq2_work_func);
+		acc->irq2_work_queue =
+		    create_singlethread_workqueue("lis3dh_acc_wq2");
+		if (!acc->irq2_work_queue) {
+			err = -ENOMEM;
+			dev_err(&client->dev, "cannot create work queue2: %d\n",
+				err);
+			goto err_free_irq2;
+		}
+	}
+
+	acc->pdata = kmalloc(sizeof(*acc->pdata), GFP_KERNEL);
+	if (acc->pdata == NULL) {
+		err = -ENOMEM;
+		dev_err(&client->dev,
+			"failed to allocate memory for pdata: %d\n", err);
+		goto err_destoyworkqueue2;
+	}
+
+	memcpy(acc->pdata, client->dev.platform_data, sizeof(*acc->pdata));
+
+	err = lis3dh_acc_validate_pdata(acc);
+	if (err < 0) {
+		dev_err(&client->dev, "failed to validate platform data\n");
+		goto exit_kfree_pdata;
+	}
+
+	err = lis3dh_acc_device_power_on(acc);
+	if (err < 0) {
+		dev_err(&client->dev, "power on failed: %d\n", err);
+		goto err2;
+	}
+
+#if 1
+	if (i2c_smbus_read_byte(client) < 0) {
+		pr_err("i2c_smbus_read_byte error!!\n");
+		goto err_destoyworkqueue2;
+	} else {
+		pr_debug("%s Device detected!\n", LIS3DH_ACC_DEV_NAME);
+	}
+#endif
+	/* read chip id */
+
+	tempvalue = i2c_smbus_read_word_data(client, WHO_AM_I);
+
+	if ((tempvalue & 0x00FF) == WHOAMI_LIS3DH_ACC) {
+		pr_debug("%s I2C driver registered!\n",
+		       LIS3DH_ACC_DEV_NAME);
+	} else {
+		acc->client = NULL;
+		pr_debug("I2C driver not registered!"
+		       " Device unknown 0x%x\n", tempvalue);
+		goto err_destoyworkqueue2;
+	}
+	
+	i2c_set_clientdata(client, acc);
+
+	if (acc->pdata->init) {
+		err = acc->pdata->init();
+		if (err < 0) {
+			dev_err(&client->dev, "init failed: %d\n", err);
+			goto err2;
+		}
+	}
+
+	memset(acc->resume_state, 0, ARRAY_SIZE(acc->resume_state));
+
+	acc->resume_state[RES_CTRL_REG1] = LIS3DH_ACC_ENABLE_ALL_AXES;
+	acc->resume_state[RES_CTRL_REG2] = 0x00;
+	acc->resume_state[RES_CTRL_REG3] = 0x00;
+	acc->resume_state[RES_CTRL_REG4] = 0x00;
+	acc->resume_state[RES_CTRL_REG5] = 0x00;
+	acc->resume_state[RES_CTRL_REG6] = 0x00;
+
+	acc->resume_state[RES_TEMP_CFG_REG] = 0x00;
+	acc->resume_state[RES_FIFO_CTRL_REG] = 0x00;
+	acc->resume_state[RES_INT_CFG1] = 0x00;
+	acc->resume_state[RES_INT_THS1] = 0x00;
+	acc->resume_state[RES_INT_DUR1] = 0x00;
+	acc->resume_state[RES_INT_CFG2] = 0x00;
+	acc->resume_state[RES_INT_THS2] = 0x00;
+	acc->resume_state[RES_INT_DUR2] = 0x00;
+
+	acc->resume_state[RES_TT_CFG] = 0x00;
+	acc->resume_state[RES_TT_THS] = 0x00;
+	acc->resume_state[RES_TT_LIM] = 0x00;
+	acc->resume_state[RES_TT_TLAT] = 0x00;
+	acc->resume_state[RES_TT_TW] = 0x00;
+
+
+	atomic_set(&acc->enabled, 1);
+
+	err = lis3dh_acc_update_g_range(acc, acc->pdata->g_range);
+	if (err < 0) {
+		dev_err(&client->dev, "update_g_range failed\n");
+		goto err_power_off;
+	}
+
+	err = lis3dh_acc_update_odr(acc, acc->pdata->poll_interval);
+	if (err < 0) {
+		dev_err(&client->dev, "update_odr failed\n");
+		goto err_power_off;
+	}
+
+	err = lis3dh_acc_input_init(acc);
+	if (err < 0) {
+		dev_err(&client->dev, "input init failed\n");
+		goto err_power_off;
+	}
+	lis3dh_acc_misc_data = acc;
+
+	err = misc_register(&lis3dh_acc_misc_device);
+	if (err < 0) {
+		dev_err(&client->dev,
+			"misc LIS3DH_ACC_DEV_NAME register failed\n");
+		goto err_input_cleanup;
+	}
+
+	lis3dh_acc_device_power_off(acc);
+
+	/* As default, do not report information */
+	atomic_set(&acc->enabled, 0);
+/*
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	acc->early_suspend.suspend = lis3dh_early_suspend;
+	acc->early_suspend.resume = lis3dh_early_resume;
+	acc->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
+	register_early_suspend(&acc->early_suspend);
+#endif
+*/
+	mutex_unlock(&acc->lock);
+	dev_info(&client->dev, "###%s###\n", __func__);
+	printk("sprd-gsensor: -- %s -- success !\n",__func__);
+	return 0;
+
+err_input_cleanup:
+	lis3dh_acc_input_cleanup(acc);
+err_power_off:
+	lis3dh_acc_device_power_off(acc);
+err2:
+	if (acc->pdata->exit)
+		acc->pdata->exit();
+exit_kfree_pdata:
+	kfree(acc->pdata);
+err_destoyworkqueue2:
+	if (acc->irq2_work_queue)
+		destroy_workqueue(acc->irq2_work_queue);
+err_free_irq2:
+	if (acc->irq2) {
+		free_irq(acc->irq2, acc);
+		gpio_free(GSENSOR_GINT2_GPI);
+	}
+err_destoyworkqueue1:
+	if (acc->irq1_work_queue)
+		destroy_workqueue(acc->irq1_work_queue);
+err_free_irq1:
+	if (acc->irq1) {
+		free_irq(acc->irq1, acc);
+		gpio_free(GSENSOR_GINT1_GPI);
+	}
+err_mutexunlockfreedata:
+	i2c_set_clientdata(client, NULL);
+	mutex_unlock(&acc->lock);
+	kfree(acc);
+	lis3dh_acc_misc_data = NULL;
+exit_alloc_data_failed:
+exit_check_functionality_failed:
+	pr_err("%s: Driver Init failed\n", LIS3DH_ACC_DEV_NAME);
+exit_alloc_platform_data_failed:
+	return err;
+}
+
+static int  lis3dh_acc_remove(struct i2c_client *client)
+{
+	/* TODO: revisit ordering here once _probe order is finalized */
+	struct lis3dh_acc_data *acc = i2c_get_clientdata(client);
+	if (acc != NULL) {
+		if (acc->irq1) {
+			free_irq(acc->irq1, acc);
+			gpio_free(GSENSOR_GINT1_GPI);
+		}
+		if (acc->irq2) {
+			free_irq(acc->irq2, acc);
+			gpio_free(GSENSOR_GINT2_GPI);
+		}
+
+		if (acc->irq1_work_queue)
+			destroy_workqueue(acc->irq1_work_queue);
+		if (acc->irq2_work_queue)
+			destroy_workqueue(acc->irq2_work_queue);
+		misc_deregister(&lis3dh_acc_misc_device);
+		lis3dh_acc_input_cleanup(acc);
+		lis3dh_acc_device_power_off(acc);
+		if (acc->pdata->exit)
+			acc->pdata->exit();
+		kfree(acc->pdata);
+		kfree(acc);
+	}
+
+	return 0;
+}
+
+static int lis3dh_acc_resume(struct i2c_client *client)
+{
+	struct lis3dh_acc_data *acc = i2c_get_clientdata(client);
+	printk("sprd-gsensor: -- %s -- !\n",__func__);
+	dev_dbg(&client->dev, "###%s###\n", __func__);
+
+	if (acc != NULL && acc->on_before_suspend)
+		return lis3dh_acc_enable(acc);
+
+	return 0;
+}
+
+static int lis3dh_acc_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+	struct lis3dh_acc_data *acc = i2c_get_clientdata(client);
+	printk("sprd-gsensor: -- %s -- !\n",__func__);
+	dev_dbg(&client->dev, "###%s###\n", __func__);
+
+	if (acc != NULL) {
+		acc->on_before_suspend = atomic_read(&acc->enabled);
+		return lis3dh_acc_disable(acc);
+	}
+	return 0;
+}
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+
+static void lis3dh_early_suspend(struct early_suspend *es)
+{
+	lis3dh_acc_suspend(lis3dh_i2c_client, (pm_message_t) {
+			   .event = 0});
+}
+
+static void lis3dh_early_resume(struct early_suspend *es)
+{
+	lis3dh_acc_resume(lis3dh_i2c_client);
+}
+
+#endif /* CONFIG_HAS_EARLYSUSPEND */
+
+static const struct i2c_device_id lis3dh_acc_id[]
+= { {LIS3DH_ACC_DEV_NAME, 0}, {}, };
+
+MODULE_DEVICE_TABLE(i2c, lis3dh_acc_id);
+
+static const struct of_device_id lis3dh_acc_of_match[] = {
+       { .compatible = "ST,lis3dh_acc", },
+       { }
+};
+MODULE_DEVICE_TABLE(of, lis3dh_acc_of_match);
+static struct i2c_driver lis3dh_acc_driver = {
+	.driver = {
+		   .name = LIS3DH_ACC_I2C_NAME,
+		   .of_match_table = lis3dh_acc_of_match,
+		   },
+	.probe = lis3dh_acc_probe,
+	.remove = lis3dh_acc_remove,
+	.resume = lis3dh_acc_resume,
+	.suspend = lis3dh_acc_suspend,
+	.id_table = lis3dh_acc_id,
+};
+
+
+static int __init lis3dh_acc_init(void)
+{
+	pr_debug("%s accelerometer driver: init\n", LIS3DH_ACC_I2C_NAME);
+
+	return i2c_add_driver(&lis3dh_acc_driver);
+}
+
+static void __exit lis3dh_acc_exit(void)
+{
+	pr_debug("%s accelerometer driver exit\n", LIS3DH_ACC_DEV_NAME);
+
+	i2c_del_driver(&lis3dh_acc_driver);
+	return;
+}
+
+module_init(lis3dh_acc_init);
+module_exit(lis3dh_acc_exit);
+
+MODULE_DESCRIPTION("lis3dh accelerometer misc driver");
+MODULE_AUTHOR("STMicroelectronics");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/lis3dh_interrupt.c b/drivers/input/misc/lis3dh_interrupt.c
new file mode 100644
index 00000000..ba801834
--- /dev/null
+++ b/drivers/input/misc/lis3dh_interrupt.c
@@ -0,0 +1,2261 @@
+/******************** (C) COPYRIGHT 2010 STMicroelectronics ********************
+ *
+ * File Name          : lis3dh_acc.c
+ * Authors            : MSH - Motion Mems BU - Application Team
+ *		      : Carmine Iascone (carmine.iascone@st.com)
+ *		      : Matteo Dameno (matteo.dameno@st.com)
+ * Version            : V.1.0.5
+ * Date               : 16/08/2010
+ * Description        : LIS3DH accelerometer sensor API
+ *
+ *******************************************************************************
+ *
+ * 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.
+ *
+ * THE PRESENT SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES
+ * OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, FOR THE SOLE
+ * PURPOSE TO SUPPORT YOUR APPLICATION DEVELOPMENT.
+ * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+ * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+ * CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+ * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ *
+ * THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS.
+ *
+ ******************************************************************************
+ Revision 1.0.0 05/11/09
+ First Release
+ Revision 1.0.3 22/01/2010
+  Linux K&R Compliant Release;
+ Revision 1.0.5 16/08/2010
+ modified _get_acceleration_data function
+ modified _update_odr function
+ manages 2 interrupts
+
+ ******************************************************************************/
+
+#include	<linux/module.h>
+#include	<linux/err.h>
+#include	<linux/errno.h>
+#include	<linux/delay.h>
+#include	<linux/fs.h>
+#include	<linux/i2c.h>
+
+#include	<linux/input.h>
+#include	<linux/input-polldev.h>
+#include	<linux/miscdevice.h>
+#include	<linux/uaccess.h>
+#include        <linux/slab.h>
+
+#include	<linux/workqueue.h>
+#include	<linux/irq.h>
+#include	<linux/gpio.h>
+#include	<linux/interrupt.h>
+#ifdef CONFIG_HAS_EARLYSUSPEND
+#include  <linux/earlysuspend.h>
+#endif
+
+#include <linux/i2c/lis3dh.h>
+#include <linux/of_device.h>
+#include <linux/of_address.h>
+#include <linux/of_gpio.h>
+
+#include <linux/sched.h>
+#include <linux/kthread.h>
+#include <linux/completion.h>
+#include <linux/err.h>
+
+#include <soc/sprd/i2c-sprd.h>
+
+#define	INTERRUPT_MANAGEMENT 1
+
+#define	G_MAX		16000	/** Maximum polled-device-reported g value */
+
+/*
+#define	SHIFT_ADJ_2G		4
+#define	SHIFT_ADJ_4G		3
+#define	SHIFT_ADJ_8G		2
+#define	SHIFT_ADJ_16G		1
+*/
+#define GSENSOR_INTERRUPT_MODE
+
+#define SENSITIVITY_2G		1	/**	mg/LSB	*/
+#define SENSITIVITY_4G		2	/**	mg/LSB	*/
+#define SENSITIVITY_8G		4	/**	mg/LSB	*/
+#define SENSITIVITY_16G		12	/**	mg/LSB	*/
+
+#define	HIGH_RESOLUTION		0x08
+
+#define	AXISDATA_REG		0x28
+#define WHOAMI_LIS3DH_ACC	0x33	/*      Expctd content for WAI  */
+
+/*	CONTROL REGISTERS	*/
+#define WHO_AM_I		0x0F	/*      WhoAmI register         */
+#define	TEMP_CFG_REG		0x1F	/*      temper sens control reg */
+/* ctrl 1: ODR3 ODR2 ODR ODR0 LPen Zenable Yenable Zenable */
+#define	CTRL_REG1		0x20	/*      control reg 1           */
+#define	CTRL_REG2		0x21	/*      control reg 2           */
+#define	CTRL_REG3		0x22	/*      control reg 3           */
+#define	CTRL_REG4		0x23	/*      control reg 4           */
+#define	CTRL_REG5		0x24	/*      control reg 5           */
+#define	CTRL_REG6		0x25	/*      control reg 6           */
+
+#define	FIFO_CTRL_REG		0x2E	/*      FiFo control reg        */
+
+#define	INT_CFG1		0x30	/*      interrupt 1 config      */
+#define	INT_SRC1		0x31	/*      interrupt 1 source      */
+#define	INT_THS1		0x32	/*      interrupt 1 threshold   */
+#define	INT_DUR1		0x33	/*      interrupt 1 duration    */
+
+#define	INT_CFG2		0x34	/*      interrupt 2 config      */
+#define	INT_SRC2		0x35	/*      interrupt 2 source      */
+#define	INT_THS2		0x36	/*      interrupt 2 threshold   */
+#define	INT_DUR2		0x37	/*      interrupt 2 duration    */
+
+#define	TT_CFG			0x38	/*      tap config              */
+#define	TT_SRC			0x39	/*      tap source              */
+#define	TT_THS			0x3A	/*      tap threshold           */
+#define	TT_LIM			0x3B	/*      tap time limit          */
+#define	TT_TLAT			0x3C	/*      tap time latency        */
+#define	TT_TW			0x3D	/*      tap time window         */
+/*	end CONTROL REGISTRES	*/
+
+#define ENABLE_HIGH_RESOLUTION	1
+
+#define LIS3DH_ACC_PM_OFF		0x00
+#define LIS3DH_ACC_ENABLE_ALL_AXES	0x07
+
+#define PMODE_MASK			0x08
+#define ODR_MASK			0XF0
+
+#define ODR1		0x10	/* 1Hz output data rate */
+#define ODR10		0x20	/* 10Hz output data rate */
+#define ODR25		0x30	/* 25Hz output data rate */
+#define ODR50		0x40	/* 50Hz output data rate */
+#define ODR100		0x50	/* 100Hz output data rate */
+#define ODR200		0x60	/* 200Hz output data rate */
+#define ODR400		0x70	/* 400Hz output data rate */
+#define ODR1250		0x90	/* 1250Hz output data rate  : test actually 650hz*/ 
+
+#define	IA			0x40
+#define	ZH			0x20
+#define	ZL			0x10
+#define	YH			0x08
+#define	YL			0x04
+#define	XH			0x02
+#define	XL			0x01
+/* */
+/* CTRL REG BITS*/
+#define	CTRL_REG3_I1_AOI1	0x40
+#define	CTRL_REG6_I2_TAPEN	0x80
+/*
+CTRL_REG3 (22h)  µÄI1_DRDY1 λ  enable
+CTRL_REG5 (24h)   LIR_INT1   1 Ϊ ´¥·¢ÖÐ¶Ï ºó Öжϱ£³Ö£¬0  Ϊ Âö³å 
+CTRL_REG6 (25h)    0  ΪÖÐ¶Ï ¸ßÓÐЧ£¬ 1  ΪÖжϵÍÓÐЧ
+********must read data then will interrupter,******
+*/
+#define	CTRL_REG3_I1_DRDY1	0x10  //DRDY1 interrupt on INT1
+#define	CTRL_REG5_LIR_INT1        0x08  //latch interrupt
+//#define	CTRL_REG6_HLACTIVE	0x02  //low
+#define	CTRL_REG6_HLACTIVE	0x00  //high
+
+
+/* */
+
+/* TAP_SOURCE_REG BIT */
+#define	DTAP			0x20
+#define	STAP			0x10
+#define	SIGNTAP			0x08
+#define	ZTAP			0x04
+#define	YTAP			0x02
+#define	XTAZ			0x01
+
+#define	FUZZ			32
+#define	FLAT			32
+#define	I2C_RETRY_DELAY		5
+#define	I2C_RETRIES		5
+#define	I2C_AUTO_INCREMENT	0x80
+
+/* RESUME STATE INDICES */
+#define	RES_CTRL_REG1		0
+#define	RES_CTRL_REG2		1
+#define	RES_CTRL_REG3		2
+#define	RES_CTRL_REG4		3
+#define	RES_CTRL_REG5		4
+#define	RES_CTRL_REG6		5
+
+#define	RES_INT_CFG1		6
+#define	RES_INT_THS1		7
+#define	RES_INT_DUR1		8
+#define	RES_INT_CFG2		9
+#define	RES_INT_THS2		10
+#define	RES_INT_DUR2		11
+
+#define	RES_TT_CFG		12
+#define	RES_TT_THS		13
+#define	RES_TT_LIM		14
+#define	RES_TT_TLAT		15
+#define	RES_TT_TW		16
+
+#define	RES_TEMP_CFG_REG	17
+#define	RES_REFERENCE_REG	18
+#define	RES_FIFO_CTRL_REG	19
+
+#define	RESUME_ENTRIES		20
+#define DEVICE_INFO             "ST, LIS3DH"
+#define DEVICE_INFO_LEN         32
+/* end RESUME STATE INDICES */
+
+//#define GSENSOR_GINT1_GPI 238
+#define GSENSOR_GINT2_GPI 1
+
+#define LOG_TAG				        "[LIS3DH] "
+#define LOG_FUN( )			        printk(KERN_INFO LOG_TAG"%s\n", __FUNCTION__)
+#define LOG_INFO(fmt, args...)		printk(KERN_INFO LOG_TAG fmt, ##args)
+#define LOG_ERR(fmt, args...)		printk(KERN_ERR  LOG_TAG"%s %d : "fmt, __FUNCTION__, __LINE__, ##args)
+
+//#define LIS3DH_DBG
+#define GSENSOR_INTERRUPT_MODE
+#define USE_WAIT_QUEUE 1
+#if USE_WAIT_QUEUE
+static struct task_struct *thread = NULL;
+static DECLARE_WAIT_QUEUE_HEAD(waiter);
+static int gsensor_flag = 0;
+#endif
+
+struct {
+	unsigned int cutoff_ms;
+	unsigned int mask;
+} lis3dh_acc_odr_table[] = {
+	{
+	1, ODR1250}, {
+	2, ODR400}, {
+	5, ODR200}, {
+	10, ODR100}, {
+	20, ODR50}, {
+	40, ODR25}, {
+	100, ODR10}, {
+	1000, ODR1},};
+
+struct lis3dh_acc_data {
+	struct i2c_client *client;
+	struct lis3dh_acc_platform_data *pdata;
+
+	struct mutex lock;
+	struct delayed_work input_work;
+
+	struct input_dev *input_dev;
+
+	int hw_initialized;
+	/* hw_working=-1 means not tested yet */
+	int hw_working;
+	atomic_t enabled;
+	int on_before_suspend;
+
+	u8 sensitivity;
+
+	u8 resume_state[RESUME_ENTRIES];
+
+//	int irq1_gpio_number;
+	int irq1;
+	struct work_struct irq1_work;
+	struct workqueue_struct *irq1_work_queue;
+	int irq2;
+	struct work_struct irq2_work;
+	struct workqueue_struct *irq2_work_queue;
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	struct early_suspend early_suspend;
+#endif
+#ifdef LIS3DH_DBG
+struct {
+		u8 diag_reg_addr_wr;
+		u8 diag_reg_val_wr;
+	} debug;
+	u64 data_num;
+#endif
+};
+
+/*
+ * Because misc devices can not carry a pointer from driver register to
+ * open, we keep this global.  This limits the driver to a single instance.
+ */
+struct lis3dh_acc_data *lis3dh_acc_misc_data;
+struct i2c_client *lis3dh_i2c_client;
+
+#ifndef GSENSOR_INTERRUPT_MODE 
+static struct workqueue_struct *_gSensorWork_workqueue = NULL;
+#endif
+
+static int lis3dh_acc_get_acceleration_data(struct lis3dh_acc_data *acc,int *xyz);
+static void lis3dh_acc_report_values(struct lis3dh_acc_data *acc, int *xyz);
+
+static int lis3dh_acc_i2c_read(struct lis3dh_acc_data *acc, u8 * buf, int len)
+{
+	int err;
+	int tries = 0;
+
+	struct i2c_msg msgs[] = {
+		{
+		 .addr = acc->client->addr,
+		 .flags = acc->client->flags & I2C_M_TEN,
+		 .len = 1,
+		 .buf = buf,},
+		{
+		 .addr = acc->client->addr,
+		 .flags = (acc->client->flags & I2C_M_TEN) | I2C_M_RD,
+		 .len = len,
+		 .buf = buf,},
+	};
+
+	do {
+		err = i2c_transfer(acc->client->adapter, msgs, 2);
+		if (err != 2){
+			LOG_ERR("************* exception read transfer error,tries=%d********\n",tries);
+			msleep_interruptible(I2C_RETRY_DELAY);
+		}
+	} while ((err != 2) && (++tries < I2C_RETRIES));
+
+	if (err != 2) {
+		LOG_ERR(" exception read transfer error\n");
+		err = -EIO;
+	} else {
+		err = 0;
+	}
+
+	return err;
+}
+
+static int lis3dh_acc_i2c_write(struct lis3dh_acc_data *acc, u8 * buf, int len)
+{
+	int err;
+	int tries = 0;
+
+	struct i2c_msg msgs[] = { {.addr = acc->client->addr,
+				   .flags = acc->client->flags & I2C_M_TEN,
+				   .len = len + 1,.buf = buf,},
+	};
+	do {
+		err = i2c_transfer(acc->client->adapter, msgs, 1);
+		if (err != 1)
+			msleep_interruptible(I2C_RETRY_DELAY);
+	} while ((err != 1) && (++tries < I2C_RETRIES));
+
+	if (err != 1) {
+		dev_err(&acc->client->dev, "write transfer error\n");
+		err = -EIO;
+	} else {
+		err = 0;
+	}
+
+	return err;
+}
+
+
+static int lis3dh_acc_register_read(struct lis3dh_acc_data *acc, u8 * buf,
+				    u8 reg_address)
+{
+	int err = -1;
+	buf[0] = (reg_address);
+	err = lis3dh_acc_i2c_read(acc, buf, 1);
+	return err;
+}
+
+static void lis3dh_read_interrupt_reg(struct lis3dh_acc_data *acc)
+{      
+	  u8 value = 0;
+	   int err;
+
+	err = lis3dh_acc_register_read(acc, &value, CTRL_REG3);
+	LOG_INFO("REG content: =======================>\n");
+	if (err >= 0)
+		LOG_INFO("REG content: [CTRL_REG3:0x%x]= 0x%02x\n", CTRL_REG3, value);
+
+	err = lis3dh_acc_register_read(acc, &value, CTRL_REG5);
+	if (err >= 0)
+		LOG_INFO("REG content: [CTRL_REG5:0x%x]= 0x%02x\n", CTRL_REG5, value);
+	err = lis3dh_acc_register_read(acc, &value, CTRL_REG6);
+	if (err >= 0)
+		LOG_INFO("REG content: [CTRL_REG6:0x%x]= 0x%02x\n", CTRL_REG6, value);
+
+	LOG_INFO("REG content:< =======================\n");
+
+}
+
+
+
+/*  if  CTM want to turn off vdd & vddio , we recommend to call this function to retrive register setting   */
+
+static int lis3dh_acc_hw_init(struct lis3dh_acc_data *acc)
+{
+	int err = -1;
+	u8 buf[7];
+
+	pr_debug("%s: hw init start\n", LIS3DH_ACC_DEV_NAME);
+	LOG_INFO("sprd-gsensor: -- %s entry  :acc-> pdata ->gpio_int1=%d-- !\n",__func__,gpio_get_value(acc-> pdata ->gpio_int1));
+
+	buf[0] = WHO_AM_I;
+	err = lis3dh_acc_i2c_read(acc, buf, 1);
+	if (err < 0)
+		goto error_firstread;
+	else
+		acc->hw_working = 1;
+	if (buf[0] != WHOAMI_LIS3DH_ACC) {
+		err = -1;	/* choose the right coded error */
+		goto error_unknown_device;
+	}
+
+	buf[0] = CTRL_REG1;
+	buf[1] = acc->resume_state[RES_CTRL_REG1];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = TEMP_CFG_REG;
+	buf[1] = acc->resume_state[RES_TEMP_CFG_REG];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = FIFO_CTRL_REG;
+	buf[1] = acc->resume_state[RES_FIFO_CTRL_REG];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = (I2C_AUTO_INCREMENT | TT_THS);
+	buf[1] = acc->resume_state[RES_TT_THS];
+	buf[2] = acc->resume_state[RES_TT_LIM];
+	buf[3] = acc->resume_state[RES_TT_TLAT];
+	buf[4] = acc->resume_state[RES_TT_TW];
+	err = lis3dh_acc_i2c_write(acc, buf, 4);
+	if (err < 0)
+		goto error1;
+	buf[0] = TT_CFG;
+	buf[1] = acc->resume_state[RES_TT_CFG];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = (I2C_AUTO_INCREMENT | INT_THS1);
+	buf[1] = acc->resume_state[RES_INT_THS1];
+	buf[2] = acc->resume_state[RES_INT_DUR1];
+	err = lis3dh_acc_i2c_write(acc, buf, 2);
+	if (err < 0)
+		goto error1;
+	buf[0] = INT_CFG1;
+	buf[1] = acc->resume_state[RES_INT_CFG1];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = (I2C_AUTO_INCREMENT | INT_THS2);
+	buf[1] = acc->resume_state[RES_INT_THS2];
+	buf[2] = acc->resume_state[RES_INT_DUR2];
+	err = lis3dh_acc_i2c_write(acc, buf, 2);
+	if (err < 0)
+		goto error1;
+	buf[0] = INT_CFG2;
+	buf[1] = acc->resume_state[RES_INT_CFG2];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = (I2C_AUTO_INCREMENT | CTRL_REG2);
+	buf[1] = acc->resume_state[RES_CTRL_REG2];
+	buf[2] = acc->resume_state[RES_CTRL_REG3];
+	buf[3] = acc->resume_state[RES_CTRL_REG4];
+	buf[4] = acc->resume_state[RES_CTRL_REG5];
+	buf[5] = acc->resume_state[RES_CTRL_REG6];
+	err = lis3dh_acc_i2c_write(acc, buf, 5);
+	if (err < 0)
+		goto error1;
+
+	acc->hw_initialized = 1;
+
+	LOG_INFO("sprd-gsensor: -- %s exit :acc-> pdata ->gpio_int1=%d-- !\n",__func__,gpio_get_value(acc-> pdata ->gpio_int1));
+
+	pr_debug("%s: hw init done\n", LIS3DH_ACC_DEV_NAME);
+	return 0;
+
+error_firstread:
+	acc->hw_working = 0;
+	dev_warn(&acc->client->dev, "Error reading WHO_AM_I: is device "
+		 "available/working?\n");
+	goto error1;
+error_unknown_device:
+	dev_err(&acc->client->dev,
+		"device unknown. Expected: 0x%x,"
+		" Replies: 0x%x\n", WHOAMI_LIS3DH_ACC, buf[0]);
+error1:
+	acc->hw_initialized = 0;
+	dev_err(&acc->client->dev, "hw init error 0x%x,0x%x: %d\n", buf[0],
+		buf[1], err);
+	return err;
+}
+
+static void lis3dh_acc_device_power_off(struct lis3dh_acc_data *acc)
+{
+	int err;
+	u8 buf[2] = { CTRL_REG1, LIS3DH_ACC_PM_OFF };
+	int xyz[3] = { 0 };
+
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		dev_err(&acc->client->dev, "soft power off failed: %d\n", err);
+#ifdef GSENSOR_INTERRUPT_MODE
+/*
+read data:clear interrupter
+*/
+	err = lis3dh_acc_get_acceleration_data(acc, xyz);
+#endif
+	LOG_INFO("sprd-gsensor: -- %s  acc-> pdata ->gpio_int1=%d  acc->hw_initialized=%d-- !\n",__func__,gpio_get_value(acc-> pdata ->gpio_int1),acc->hw_initialized);	
+
+}
+
+static int lis3dh_acc_device_power_on(struct lis3dh_acc_data *acc)
+{
+	int err = -1;
+	u8 buf[2];
+
+
+	if (acc->pdata->power_on) {
+		err = acc->pdata->power_on();
+		if (err < 0) {
+			dev_err(&acc->client->dev,
+				"power_on failed: %d\n", err);
+			return err;
+		}
+	}
+
+	LOG_INFO("sprd-gsensor: -- %s  acc->irq1_gpio_number=%d acc->hw_initialized=%d-- !\n",__func__,gpio_get_value(acc-> pdata ->gpio_int1),acc->hw_initialized);	
+	buf[0] = CTRL_REG1;
+	buf[1] = acc->resume_state[RES_CTRL_REG1];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		return err;
+	LOG_INFO("sprd-gsensor: -- %s  acc->resume_state[RES_CTRL_REG1]=0x%02x-- !\n",__func__, acc->resume_state[RES_CTRL_REG1]);
+
+
+	if (!acc->hw_initialized) {
+		err = lis3dh_acc_hw_init(acc);
+		lis3dh_read_interrupt_reg(acc);
+		if (acc->hw_working == 1 && err < 0) {
+			lis3dh_acc_device_power_off(acc);
+			return err;
+		}
+	}
+	return 0;
+}
+
+static irqreturn_t lis3dh_acc_isr1(int irq, void *dev)
+{
+#ifndef USE_WAIT_QUEUE
+	struct lis3dh_acc_data *acc = dev;
+#endif
+
+#ifdef LIS3DH_DBG
+	static int count_intr = 0;
+	static s64 interrupt_last = 0;
+	static s64 interrupt_cur = 0;
+	static int poll_interval=0;
+	ktime_t time_mono;
+
+	time_mono = ktime_get();
+	if (poll_interval !=lis3dh_acc_misc_data->pdata->poll_interval) {
+		count_intr=1;
+		poll_interval = lis3dh_acc_misc_data->pdata->poll_interval;
+	      interrupt_last = ktime_to_ns(time_mono);
+	}
+	interrupt_cur = ktime_to_ns(time_mono);
+	int interrupt_interval = interrupt_cur - interrupt_last;
+	interrupt_last = interrupt_cur;
+
+	if(interrupt_interval > (lis3dh_acc_misc_data->pdata->poll_interval*1000000) +(lis3dh_acc_misc_data->pdata->poll_interval*1000000) /4)
+		LOG_INFO("***sprd-gsensor ISR  exception:count_intr=%d,interrupt_interval=%d,poll_interva=%d********\n",count_intr++,interrupt_interval,lis3dh_acc_misc_data->pdata->poll_interval);
+       LOG_INFO("sprd-gsensor: -- %s entry : interrupt_interval=%d,poll_interval=%d,acc->irq1_gpio_number=%d-- >>>>>>>>>>>>>>>>>!\n",__func__,interrupt_interval,poll_interval,gpio_get_value(lis3dh_acc_misc_data->pdata->gpio_int1));	
+#endif
+
+	disable_irq_nosync(irq);
+#if USE_WAIT_QUEUE
+	gsensor_flag = 1;
+	wake_up_interruptible(&waiter);
+#else
+	queue_work(acc->irq1_work_queue, &acc->irq1_work);
+#endif
+	pr_debug("%s: isr1 queued\n", LIS3DH_ACC_DEV_NAME);
+	return IRQ_HANDLED;
+}
+
+static irqreturn_t lis3dh_acc_isr2(int irq, void *dev)
+{
+	struct lis3dh_acc_data *acc = dev;
+
+//	disable_irq_nosync(irq);
+	queue_work(acc->irq2_work_queue, &acc->irq2_work);
+
+	pr_debug("%s: isr2 queued\n", LIS3DH_ACC_DEV_NAME);
+
+	return IRQ_HANDLED;
+}
+//static int lis3dh_acc_get_acceleration_data(struct lis3dh_acc_data *acc,int *xyz);
+static void lis3dh_acc_irq1_work_func(struct work_struct *work)
+{
+	int xyz[3] = { 0 };
+	int err;
+	u8 value;
+	struct lis3dh_acc_data *acc =
+	    container_of(work, struct lis3dh_acc_data, irq1_work);
+
+	/* TODO  add interrupt service procedure.
+	   ie:lis3dh_acc_get_int1_source(acc); */
+	;
+	/*  */
+	LOG_INFO("%s: isr1 queued=========>>>>>>>>>>>>>>>>>\n", __func__);
+       LOG_INFO("sprd-gsensor: -- %s entry :acc->irq1_gpio_number=%d-- !\n",__func__,gpio_get_value(acc->pdata->gpio_int1));
+	   
+	err = lis3dh_acc_register_read(acc, &value, INT_SRC1);
+
+        if (err < 0) {
+	        LOG_INFO("%s, error read register INT_SRC1\n", __func__);
+        }
+	LOG_INFO("%s: IRQ1 triggered  INT_SRC1=0x%02x\n",__func__,value);
+
+	err = lis3dh_acc_get_acceleration_data(acc, xyz);
+	if (err < 0)
+		dev_err(&acc->client->dev, "get_acceleration_data failed\n");
+	else
+		lis3dh_acc_report_values(acc, xyz);
+
+
+       LOG_INFO("sprd-gsensor: -- %s exit :acc->irq1_gpio_number=%d-- !\n",__func__,gpio_get_value(acc->pdata->gpio_int1));
+	enable_irq(acc->irq1);
+}
+
+
+#if USE_WAIT_QUEUE
+
+static void lis3dh_acc_update_data_func(void)
+{
+	int xyz[3] = { 0 };
+	int err;
+	struct lis3dh_acc_data *acc =lis3dh_acc_misc_data;
+
+//       LOG_INFO("sprd-gsensor: -- %s entry :acc->irq1_gpio_number=%d-- !\n",__func__,gpio_get_value(acc->pdata->gpio_int1));
+	err = lis3dh_acc_get_acceleration_data(acc, xyz);
+ 	if (err < 0)
+		LOG_ERR("get_acceleration_data failed*******************************\n");
+	else
+		lis3dh_acc_report_values(acc, xyz);
+#ifdef LIS3DH_DBG
+       LOG_INFO("sprd-gsensor: -- %s exit :acc->irq1_gpio_number=%d-->>>>>>>>>>>>>>>>> !\n\n",__func__,gpio_get_value(acc->pdata->gpio_int1));
+       LOG_INFO("\n");
+   #endif
+	enable_irq(acc->irq1);
+}
+
+static int gsensor_event_handler(void *unused)
+{
+#ifdef LIS3DH_DBG
+	static int count_intr = 0;
+	static s64 interrupt_last = 0;
+	static s64 interrupt_read = 0;
+	static s64 interrupt_cur = 0;
+	static int poll_interval=0;
+	ktime_t time_mono;
+#endif
+	struct sched_param param = { .sched_priority = 5};
+
+	sched_setscheduler(current, SCHED_RR, &param);
+        LOG_INFO("sprd-gsensor: -- %s entry :acc->irq1_gpio_number=%d-- !\n",__func__,gpio_get_value(lis3dh_acc_misc_data->pdata->gpio_int1));	
+
+	do {
+#ifdef LIS3DH_DBG
+	       LOG_INFO("sprd-gsensor: -- %s 1 : gsensor_flag=%d,acc->irq1_gpio_number=%d-- !\n",__func__,gsensor_flag,gpio_get_value(lis3dh_acc_misc_data->pdata->gpio_int1));	
+#endif
+
+		set_current_state(TASK_INTERRUPTIBLE);
+		wait_event_interruptible(waiter, (0 != gsensor_flag));
+//
+#ifdef LIS3DH_DBG
+		time_mono = ktime_get();
+		if (poll_interval !=lis3dh_acc_misc_data->pdata->poll_interval) {
+			count_intr=1;
+			poll_interval = lis3dh_acc_misc_data->pdata->poll_interval;
+		      interrupt_last = ktime_to_ns(time_mono);
+		}
+		interrupt_cur = ktime_to_ns(time_mono);
+		int interrupt_interval = interrupt_cur - interrupt_last;
+		interrupt_last = interrupt_cur;
+
+		if(interrupt_interval > (lis3dh_acc_misc_data->pdata->poll_interval*1000000) +(lis3dh_acc_misc_data->pdata->poll_interval*1000000) /4)
+			LOG_INFO("***sprd-gsensor SHED  exception:count_intr=%d,interrupt_interval=%d,poll_interva=%d********\n",count_intr++,interrupt_interval,lis3dh_acc_misc_data->pdata->poll_interval);
+
+	       LOG_INFO("sprd-gsensor: -- %s 2: interrupt_interval=%d,poll_interval=%d,gsensor_flag=%d,acc->irq1_gpio_number=%d-- !\n",__func__,interrupt_interval,poll_interval,gsensor_flag,gpio_get_value(lis3dh_acc_misc_data->pdata->gpio_int1));	
+#endif
+		gsensor_flag = 0;
+		set_current_state(TASK_RUNNING);
+		lis3dh_acc_update_data_func();
+#ifdef LIS3DH_DBG
+             time_mono = ktime_get();
+             interrupt_read=ktime_to_ns(time_mono)-interrupt_cur;
+		if(interrupt_interval > (lis3dh_acc_misc_data->pdata->poll_interval*1000000) +(lis3dh_acc_misc_data->pdata->poll_interval*1000000) /4)
+			LOG_INFO("***sprd-gsensor SHED  exception:count_intr=%d,interrupt_interval=%d,poll_interva=%d, interrupt_read=%lld********\n",count_intr++,interrupt_interval,lis3dh_acc_misc_data->pdata->poll_interval,interrupt_read);
+
+             LOG_INFO("sprd-gsensor: -- %s 3: interrupt_read=%lld,poll_interval=%d,gsensor_flag=%d,acc->irq1_gpio_number=%d-- !\n",__func__,interrupt_read,poll_interval,gsensor_flag,gpio_get_value(lis3dh_acc_misc_data->pdata->gpio_int1));		    
+#endif
+	} while (!kthread_should_stop());
+
+	return 0;
+}
+#endif
+
+
+static void lis3dh_acc_irq2_work_func(struct work_struct *work)
+{
+
+	/*struct lis3dh_acc_data *acc =
+	    container_of(work, struct lis3dh_acc_data, irq2_work);
+	*/
+	/* TODO  add interrupt service procedure.
+	   ie:lis3dh_acc_get_tap_source(acc); */
+	;
+	/*  */
+
+	LOG_INFO("%s: IRQ2 triggered\n", LIS3DH_ACC_DEV_NAME);
+}
+
+int lis3dh_acc_update_g_range(struct lis3dh_acc_data *acc, u8 new_g_range)
+{
+	int err;
+
+	u8 sensitivity;
+	u8 buf[2];
+	u8 updated_val;
+	u8 init_val;
+	u8 new_val;
+	u8 mask = LIS3DH_ACC_FS_MASK | HIGH_RESOLUTION;
+
+	pr_debug("%s\n", __func__);
+
+	switch (new_g_range) {
+	case LIS3DH_ACC_G_2G:
+
+		sensitivity = SENSITIVITY_2G;
+		break;
+	case LIS3DH_ACC_G_4G:
+
+		sensitivity = SENSITIVITY_4G;
+		break;
+	case LIS3DH_ACC_G_8G:
+
+		sensitivity = SENSITIVITY_8G;
+		break;
+	case LIS3DH_ACC_G_16G:
+
+		sensitivity = SENSITIVITY_16G;
+		break;
+	default:
+		dev_err(&acc->client->dev, "invalid g range requested: %u\n",
+			new_g_range);
+		return -EINVAL;
+	}
+
+	if (atomic_read(&acc->enabled)) {
+		/* Set configuration register 4, which contains g range setting
+		 *  NOTE: this is a straight overwrite because this driver does
+		 *  not use any of the other configuration bits in this
+		 *  register.  Should this become untrue, we will have to read
+		 *  out the value and only change the relevant bits --XX----
+		 *  (marked by X) */
+		buf[0] = CTRL_REG4;
+		err = lis3dh_acc_i2c_read(acc, buf, 1);
+		if (err < 0)
+			goto error;
+		init_val = buf[0];
+		acc->resume_state[RES_CTRL_REG4] = init_val;
+		new_val = new_g_range | HIGH_RESOLUTION;
+		updated_val = ((mask & new_val) | ((~mask) & init_val));
+		buf[1] = updated_val;
+		buf[0] = CTRL_REG4;
+		err = lis3dh_acc_i2c_write(acc, buf, 1);
+		if (err < 0)
+			goto error;
+		acc->resume_state[RES_CTRL_REG4] = updated_val;
+		acc->sensitivity = sensitivity;
+
+		pr_debug("%s sensitivity %d g-range %d\n", __func__, sensitivity,new_g_range);
+	}
+
+	return 0;
+error:
+	dev_err(&acc->client->dev, "update g range failed 0x%x,0x%x: %d\n",
+		buf[0], buf[1], err);
+
+	return err;
+}
+
+int lis3dh_acc_update_odr(struct lis3dh_acc_data *acc, int poll_interval_ms)
+{
+	int err = -1;
+	int i;
+	u8 config[2];
+
+	/* Convert the poll interval into an output data rate configuration
+	 *  that is as low as possible.  The ordering of these checks must be
+	 *  maintained due to the cascading cut off values - poll intervals are
+	 *  checked from shortest to longest.  At each check, if the next lower
+	 *  ODR cannot support the current poll interval, we stop searching */
+	for (i = ARRAY_SIZE(lis3dh_acc_odr_table) - 1; i >= 0; i--) {
+		if (lis3dh_acc_odr_table[i].cutoff_ms <= poll_interval_ms)
+			break;
+	}
+	config[1] = lis3dh_acc_odr_table[i].mask;
+
+	LOG_INFO("%s :ODR  poll_interval_ms=%d, config[1]=0x%02x,cutoff_ms %d",__func__,poll_interval_ms,config[1],lis3dh_acc_odr_table[i].cutoff_ms );
+
+	config[1] |= LIS3DH_ACC_ENABLE_ALL_AXES;
+
+	/* If device is currently enabled, we need to write new
+	 *  configuration out to it */
+	if (atomic_read(&acc->enabled)) {
+		config[0] = CTRL_REG1;
+		err = lis3dh_acc_i2c_write(acc, config, 1);
+		if (err < 0)
+			goto error;
+		acc->resume_state[RES_CTRL_REG1] = config[1];
+	}
+
+	return 0;
+
+error:
+	dev_err(&acc->client->dev, "update odr failed 0x%x,0x%x: %d\n",
+		config[0], config[1], err);
+
+	return err;
+}
+
+/* */
+
+static int lis3dh_acc_register_write(struct lis3dh_acc_data *acc, u8 * buf,
+				     u8 reg_address, u8 new_value)
+{
+	int err = -1;
+
+	if (atomic_read(&acc->enabled)) {
+		/* Sets configuration register at reg_address
+		 *  NOTE: this is a straight overwrite  */
+		buf[0] = reg_address;
+		buf[1] = new_value;
+		err = lis3dh_acc_i2c_write(acc, buf, 1);
+		if (err < 0)
+			return err;
+	}
+	return err;
+}
+
+static int lis3dh_acc_register_update(struct lis3dh_acc_data *acc, u8 * buf,
+				      u8 reg_address, u8 mask,
+				      u8 new_bit_values)
+{
+	int err = -1;
+	u8 init_val;
+	u8 updated_val;
+	err = lis3dh_acc_register_read(acc, buf, reg_address);
+	if (!(err < 0)) {
+		init_val = buf[1];
+		updated_val = ((mask & new_bit_values) | ((~mask) & init_val));
+		err = lis3dh_acc_register_write(acc, buf, reg_address,
+						updated_val);
+	}
+	return err;
+}
+
+/* */
+
+static int lis3dh_acc_get_acceleration_data(struct lis3dh_acc_data *acc,
+					    int *xyz)
+{
+	int err = -1;
+	/* Data bytes from hardware xL, xH, yL, yH, zL, zH */
+	u8 acc_data[6];
+	/* x,y,z hardware data */
+	s16 hw_d[3] = { 0 };
+
+	acc_data[0] = (I2C_AUTO_INCREMENT | AXISDATA_REG);
+	err = lis3dh_acc_i2c_read(acc, acc_data, 6);
+
+	if (err < 0) {
+		LOG_ERR("%s  exception ssssI2C read error %d\n", LIS3DH_ACC_I2C_NAME,
+		       err);
+		return err;
+	}
+
+	hw_d[0] = (((s16) ((acc_data[1] << 8) | acc_data[0])) >> 4);
+	hw_d[1] = (((s16) ((acc_data[3] << 8) | acc_data[2])) >> 4);
+	hw_d[2] = (((s16) ((acc_data[5] << 8) | acc_data[4])) >> 4);
+
+	hw_d[0] = hw_d[0] * acc->sensitivity;
+	hw_d[1] = hw_d[1] * acc->sensitivity;
+	hw_d[2] = hw_d[2] * acc->sensitivity;
+
+	xyz[0] = ((acc->pdata->negate_x) ? (-hw_d[acc->pdata->axis_map_x])
+		  : (hw_d[acc->pdata->axis_map_x]));
+	xyz[1] = ((acc->pdata->negate_y) ? (-hw_d[acc->pdata->axis_map_y])
+		  : (hw_d[acc->pdata->axis_map_y]));
+	xyz[2] = ((acc->pdata->negate_z) ? (-hw_d[acc->pdata->axis_map_z])
+		  : (hw_d[acc->pdata->axis_map_z]));
+#ifdef LIS3DH_DBG
+	LOG_INFO("%s read x=%d, y=%d, z=%d\n",
+	       LIS3DH_ACC_DEV_NAME, xyz[0], xyz[1], xyz[2]);
+#endif
+
+	return err;
+}
+
+static void lis3dh_acc_report_values(struct lis3dh_acc_data *acc, int *xyz)
+{
+	input_report_abs(acc->input_dev, ABS_X, xyz[0]);
+	input_report_abs(acc->input_dev, ABS_Y, xyz[1]);
+	input_report_abs(acc->input_dev, ABS_Z, xyz[2]);
+	input_sync(acc->input_dev);
+	#ifdef LIS3DH_DBG
+		acc->data_num++;
+	#endif
+}
+
+static int lis3dh_acc_enable(struct lis3dh_acc_data *acc)
+{
+	int err;
+
+	pr_debug("%s: pr_debug PRINT  \n", __func__);
+
+	LOG_INFO("sprd-gsensor: -- %s entry :acc->irq1_gpio_number=%d-- !\n",__func__,gpio_get_value(acc->pdata->gpio_int1));	
+
+	if (!atomic_cmpxchg(&acc->enabled, 0, 1)) {
+		err = lis3dh_acc_device_power_on(acc);
+		LOG_INFO("sprd-gsensor: -- %s err=%d-- !\n",__func__,err);
+		if (err < 0) {
+			atomic_set(&acc->enabled, 0);
+			return err;
+		}
+
+		LOG_INFO("sprd-gsensor: -- %s  acc->hw_initialized=%d  acc->irq1=%d-- !\n",__func__,acc->hw_initialized,acc->irq1);
+		if (acc->hw_initialized) {
+			if (acc->irq1 != 0){
+				LOG_INFO("sprd-gsensor: -- %s  after init : acc->irq1_gpio_number=%d-- !\n",__func__,gpio_get_value(acc->pdata->gpio_int1));	
+				enable_irq(acc->irq1);
+			}
+			if (acc->irq2 != 0)
+				enable_irq(acc->irq2);
+			LOG_INFO("%s: power on: irq enabled\n",
+			       LIS3DH_ACC_DEV_NAME);
+		}
+
+		#ifdef LIS3DH_DBG
+			acc->data_num = 0;
+		#endif
+
+       /* 
+		schedule_delayed_work(&acc->input_work,
+				      msecs_to_jiffies(acc->pdata->
+						       poll_interval));
+	*/
+#ifndef GSENSOR_INTERRUPT_MODE
+        queue_delayed_work(_gSensorWork_workqueue, &acc->input_work, msecs_to_jiffies(acc->pdata->poll_interval));
+#endif
+        }
+	 LOG_INFO("sprd-gsensor: -- %s exit :acc->irq1_gpio_number=%d-- !\n",__func__,gpio_get_value(acc->pdata->gpio_int1));
+        LOG_INFO("sprd-gsensor: -- %s -- success!\n",__func__);
+	return 0;
+}
+
+static int lis3dh_acc_disable(struct lis3dh_acc_data *acc)
+{
+	LOG_INFO("sprd-gsensor: -- %s --acc->hw_initialized=%d\n",__func__,acc->hw_initialized);
+	if (atomic_cmpxchg(&acc->enabled, 1, 0)) {
+		cancel_delayed_work_sync(&acc->input_work);
+
+		if (acc->pdata->power_off) {
+			if (acc->irq1 != 0)
+				disable_irq_nosync(acc->irq1);
+			if (acc->irq2 != 0)
+				disable_irq_nosync(acc->irq2);
+			acc->pdata->power_off();
+			acc->hw_initialized = 0;
+		}
+		if (acc->hw_initialized) {
+			if (acc->irq1 != 0)
+				disable_irq_nosync(acc->irq1);
+			if (acc->irq2 != 0)
+				disable_irq_nosync(acc->irq2);
+	//only init once during probe, the sensor is ALWAYS power supply
+	//		acc->hw_initialized = 0;
+		}
+		lis3dh_acc_device_power_off(acc);
+	}
+#ifdef LIS3DH_DBG
+	LOG_INFO("******sprd-gsensor: -- %s --acc->data_num =%lld ,acc->pdata->poll_interval =%d****\n",__func__,acc->data_num,acc->pdata->poll_interval);
+	acc->data_num = 0;
+#endif
+	return 0;
+}
+
+static int lis3dh_acc_misc_open(struct inode *inode, struct file *file)
+{
+	int err;
+	err = nonseekable_open(inode, file);
+	if (err < 0)
+		return err;
+
+	file->private_data = lis3dh_acc_misc_data;
+
+	return 0;
+}
+
+static long lis3dh_acc_misc_ioctl(struct file *file, unsigned int cmd,
+				unsigned long arg)
+{
+	void __user *argp = (void __user *)arg;
+	u8 buf[4];
+	u8 mask;
+	u8 reg_address;
+	u8 bit_values;
+	int err;
+	int interval;
+	int xyz[3] = { 0 };
+	struct lis3dh_acc_data *acc = file->private_data;
+
+
+       LOG_INFO("%s :ioctl cmd %d\n",__func__, _IOC_NR(cmd));
+	switch (cmd) {
+	case LIS3DH_ACC_IOCTL_GET_DELAY:
+		interval = acc->pdata->poll_interval;
+		if (copy_to_user(argp, &interval, sizeof(interval)))
+			return -EFAULT;
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_DELAY:
+		if (copy_from_user(&interval, argp, sizeof(interval)))
+			return -EFAULT;
+		if (interval < 0 || interval > 1000)
+			return -EINVAL;
+		interval = interval/2;
+		acc->pdata->poll_interval = max(interval,acc->pdata->min_interval); // max the frequecy of g sensor
+             LOG_INFO(" %s,acc->pdata->poll_interval =%d,interval=%d,acc->pdata->min_interval=%d\n", __func__,acc->pdata->poll_interval,interval,acc->pdata->min_interval );
+		err = lis3dh_acc_update_odr(acc, acc->pdata->poll_interval);
+		/* TODO: if update fails poll is still set */
+		if (err < 0)
+			return err;
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_ENABLE:
+		if (copy_from_user(&interval, argp, sizeof(interval)))
+			return -EFAULT;
+		if (interval > 1)
+			return -EINVAL;
+		if (interval)
+			err = lis3dh_acc_enable(acc);
+		else
+			err = lis3dh_acc_disable(acc);
+		return err;
+		break;
+
+	case LIS3DH_ACC_IOCTL_GET_ENABLE:
+		interval = atomic_read(&acc->enabled);
+		if (copy_to_user(argp, &interval, sizeof(interval)))
+			return -EINVAL;
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_G_RANGE:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		bit_values = buf[0];
+		err = lis3dh_acc_update_g_range(acc, bit_values);
+		if (err < 0)
+			return err;
+		break;
+
+#ifdef INTERRUPT_MANAGEMENT
+	case LIS3DH_ACC_IOCTL_SET_CTRL_REG3:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = CTRL_REG3;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_CTRL_REG3] = ((mask & bit_values) |
+						    (~mask & acc->
+						     resume_state
+						     [RES_CTRL_REG3]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_CTRL_REG6:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = CTRL_REG6;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_CTRL_REG6] = ((mask & bit_values) |
+						    (~mask & acc->
+						     resume_state
+						     [RES_CTRL_REG6]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_DURATION1:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		reg_address = INT_DUR1;
+		mask = 0x7F;
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_DUR1] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_DUR1]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_THRESHOLD1:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		reg_address = INT_THS1;
+		mask = 0x7F;
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_THS1] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_THS1]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_CONFIG1:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = INT_CFG1;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_CFG1] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_CFG1]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_GET_SOURCE1:
+		err = lis3dh_acc_register_read(acc, buf, INT_SRC1);
+		if (err < 0)
+			return err;
+
+		pr_debug("INT1_SRC content: %d , 0x%x\n", buf[0], buf[0]);
+
+		if (copy_to_user(argp, buf, 1))
+			return -EINVAL;
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_DURATION2:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		reg_address = INT_DUR2;
+		mask = 0x7F;
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_DUR2] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_DUR2]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_THRESHOLD2:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		reg_address = INT_THS2;
+		mask = 0x7F;
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_THS2] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_THS2]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_CONFIG2:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = INT_CFG2;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_CFG2] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_CFG2]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_GET_SOURCE2:
+		err = lis3dh_acc_register_read(acc, buf, INT_SRC2);
+		if (err < 0)
+			return err;
+
+		pr_debug("INT2_SRC content: %d , 0x%x\n", buf[0], buf[0]);
+
+		if (copy_to_user(argp, buf, 1))
+			return -EINVAL;
+		break;
+
+	case LIS3DH_ACC_IOCTL_GET_TAP_SOURCE:
+		err = lis3dh_acc_register_read(acc, buf, TT_SRC);
+		if (err < 0)
+			return err;
+		pr_debug("TT_SRC content: %d , 0x%x\n", buf[0], buf[0]);
+
+		if (copy_to_user(argp, buf, 1)) {
+			pr_err("%s: %s error in copy_to_user \n",
+			       LIS3DH_ACC_DEV_NAME, __func__);
+			return -EINVAL;
+		}
+		break;
+	case LIS3DH_ACC_IOCTL_GET_COOR_XYZ:
+		err = lis3dh_acc_get_acceleration_data(acc, xyz);
+		if (err < 0)
+			return err;
+
+		if (copy_to_user(argp, xyz, sizeof(xyz))) {
+			pr_err(" %s %d error in copy_to_user \n",
+			       __func__, __LINE__);
+			return -EINVAL;
+		}
+		break;
+	case LIS3DH_ACC_IOCTL_SET_TAP_CFG:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_CFG;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_CFG] = ((mask & bit_values) |
+						 (~mask & acc->
+						  resume_state[RES_TT_CFG]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_TAP_TLIM:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_LIM;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_LIM] = ((mask & bit_values) |
+						 (~mask & acc->
+						  resume_state[RES_TT_LIM]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_TAP_THS:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_THS;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_THS] = ((mask & bit_values) |
+						 (~mask & acc->
+						  resume_state[RES_TT_THS]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_TAP_TLAT:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_TLAT;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_TLAT] = ((mask & bit_values) |
+						  (~mask & acc->
+						   resume_state[RES_TT_TLAT]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_TAP_TW:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_TW;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_TW] = ((mask & bit_values) |
+						(~mask & acc->
+						 resume_state[RES_TT_TW]));
+		break;
+
+#endif /* INTERRUPT_MANAGEMENT */
+	case LIS3DH_ACC_IOCTL_GET_CHIP_ID:
+	    {
+	        u8 devid = 0;
+	        u8 devinfo[DEVICE_INFO_LEN] = {0};
+	        err = lis3dh_acc_register_read(acc, &devid, WHO_AM_I);
+	        if (err < 0) {
+	            LOG_INFO("%s, error read register WHO_AM_I\n", __func__);
+	            return -EAGAIN;
+	        }
+	        sprintf(devinfo, "%s, %#x", DEVICE_INFO, devid);
+
+	        if (copy_to_user(argp, devinfo, sizeof(devinfo))) {
+	            printk("%s error in copy_to_user(IOCTL_GET_CHIP_ID)\n", __func__);
+	            return -EINVAL;
+	        }
+	    }
+	   break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static const struct file_operations lis3dh_acc_misc_fops = {
+	.owner = THIS_MODULE,
+	.open = lis3dh_acc_misc_open,
+	.unlocked_ioctl = lis3dh_acc_misc_ioctl,
+};
+
+static struct miscdevice lis3dh_acc_misc_device = {
+	.minor = MISC_DYNAMIC_MINOR,
+	.name = LIS3DH_ACC_DEV_NAME,
+	.fops = &lis3dh_acc_misc_fops,
+};
+
+
+#ifndef GSENSOR_INTERRUPT_MODE 
+
+static void lis3dh_acc_input_work_func(struct work_struct *work)
+{
+	struct lis3dh_acc_data *acc;
+
+	int xyz[3] = { 0 };
+	int err;
+	static int count_intr = 0;
+	static s64 interrupt_last = 0;
+	static s64 interrupt_cur = 0;
+	ktime_t time_mono;
+	time_mono = ktime_get();
+	interrupt_cur = ktime_to_ns(time_mono);
+	int interrupt_interval = interrupt_cur - interrupt_last;
+	interrupt_last = interrupt_cur;
+
+//	LOG_INFO("ENTRY----->%s\n",__func__);
+	acc = container_of((struct delayed_work *)work,
+			   struct lis3dh_acc_data, input_work);
+
+	mutex_lock(&acc->lock);
+	err = lis3dh_acc_get_acceleration_data(acc, xyz);
+	if (err < 0)
+		dev_err(&acc->client->dev, "get_acceleration_data failed\n");
+	else
+		lis3dh_acc_report_values(acc, xyz);
+//	LOG_INFO(KERN_ERR "lihai: sprd-gsensor count_intr=%8d  interrupt_interval=%8d,  poll_interval=%d, err=%d \n", count_intr++, interrupt_interval, acc->pdata->poll_interval, err);
+#if 0
+        schedule_delayed_work(&acc->input_work,
+			      msecs_to_jiffies(acc->pdata->poll_interval));
+#else
+        queue_delayed_work(_gSensorWork_workqueue, &acc->input_work, msecs_to_jiffies(acc->pdata->poll_interval));
+#endif        
+        mutex_unlock(&acc->lock);
+
+//	LOG_INFO("EXIT----->%s\n\n",__func__);
+}
+#endif
+	
+#ifdef LIS3DH_OPEN_ENABLE
+int lis3dh_acc_input_open(struct input_dev *input)
+{
+	struct lis3dh_acc_data *acc = input_get_drvdata(input);
+
+	return lis3dh_acc_enable(acc);
+}
+
+void lis3dh_acc_input_close(struct input_dev *dev)
+{
+	struct lis3dh_acc_data *acc = input_get_drvdata(dev);
+
+	lis3dh_acc_disable(acc);
+}
+#endif
+
+static int lis3dh_acc_validate_pdata(struct lis3dh_acc_data *acc)
+{
+	acc->pdata->poll_interval = max(acc->pdata->poll_interval,
+					acc->pdata->min_interval);
+
+	if (acc->pdata->axis_map_x > 2 || acc->pdata->axis_map_y > 2
+	    || acc->pdata->axis_map_z > 2) {
+		dev_err(&acc->client->dev, "invalid axis_map value "
+			"x:%u y:%u z%u\n", acc->pdata->axis_map_x,
+			acc->pdata->axis_map_y, acc->pdata->axis_map_z);
+		return -EINVAL;
+	}
+
+	/* Only allow 0 and 1 for negation boolean flag */
+	if (acc->pdata->negate_x > 1 || acc->pdata->negate_y > 1
+	    || acc->pdata->negate_z > 1) {
+		dev_err(&acc->client->dev, "invalid negate value "
+			"x:%u y:%u z:%u\n", acc->pdata->negate_x,
+			acc->pdata->negate_y, acc->pdata->negate_z);
+		return -EINVAL;
+	}
+
+	/* Enforce minimum polling interval */
+	if (acc->pdata->poll_interval < acc->pdata->min_interval) {
+		dev_err(&acc->client->dev, "minimum poll interval violated\n");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int lis3dh_acc_input_init(struct lis3dh_acc_data *acc)
+{
+	int err;
+
+#ifndef GSENSOR_INTERRUPT_MODE 
+	/* Polling rx data when the interrupt is not used.*/
+	if (1 /*acc->irq1 == 0 && acc->irq1 == 0 */ ) {
+		INIT_DELAYED_WORK(&acc->input_work, lis3dh_acc_input_work_func);
+	    _gSensorWork_workqueue = create_singlethread_workqueue("acc_singlethread");
+            if (!_gSensorWork_workqueue) {
+                    err = -ESRCH;
+                    printk(KERN_ERR "acc: create_singlethread_workqueue\n");
+                   return err;
+            }
+        }
+#endif
+
+	acc->input_dev = input_allocate_device();
+	if (!acc->input_dev) {
+		err = -ENOMEM;
+		dev_err(&acc->client->dev, "input device allocate failed\n");
+		goto err0;
+	}
+#ifdef LIS3DH_ACC_OPEN_ENABLE
+	acc->input_dev->open = lis3dh_acc_input_open;
+	acc->input_dev->close = lis3dh_acc_input_close;
+#endif
+
+	input_set_drvdata(acc->input_dev, acc);
+
+	set_bit(EV_ABS, acc->input_dev->evbit);
+	/*      next is used for interruptA sources data if the case */
+	set_bit(ABS_MISC, acc->input_dev->absbit);
+	/*      next is used for interruptB sources data if the case */
+	set_bit(ABS_WHEEL, acc->input_dev->absbit);
+
+	input_set_abs_params(acc->input_dev, ABS_X, -G_MAX, G_MAX, 0, 0);
+	input_set_abs_params(acc->input_dev, ABS_Y, -G_MAX, G_MAX, 0, 0);
+	input_set_abs_params(acc->input_dev, ABS_Z, -G_MAX, G_MAX, 0, 0);
+	/*      next is used for interruptA sources data if the case */
+	input_set_abs_params(acc->input_dev, ABS_MISC, INT_MIN, INT_MAX, 0, 0);
+	/*      next is used for interruptB sources data if the case */
+	input_set_abs_params(acc->input_dev, ABS_WHEEL, INT_MIN, INT_MAX, 0, 0);
+
+	acc->input_dev->name = "accelerometer";
+
+	err = input_register_device(acc->input_dev);
+	if (err) {
+		dev_err(&acc->client->dev,
+			"unable to register input polled device %s\n",
+			acc->input_dev->name);
+		goto err1;
+	}
+
+	return 0;
+
+err1:
+	input_free_device(acc->input_dev);
+err0:
+	return err;
+}
+
+static void lis3dh_acc_input_cleanup(struct lis3dh_acc_data *acc)
+{
+	input_unregister_device(acc->input_dev);
+	input_free_device(acc->input_dev);
+}
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+static void lis3dh_early_suspend(struct early_suspend *es);
+static void lis3dh_early_resume(struct early_suspend *es);
+#endif
+
+#ifdef CONFIG_OF
+static struct lis3dh_acc_platform_data *lis3dh_acc_parse_dt(struct device *dev)
+{
+	struct lis3dh_acc_platform_data *pdata;
+	struct device_node *np = dev->of_node;
+	int ret;
+	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+	if (!pdata) {
+		dev_err(dev, "Could not allocate struct lis3dh_acc_platform_data");
+		return NULL;
+	}
+
+	pdata->gpio_int1 = of_get_gpio(np, 0);
+	LOG_INFO(" %s:get gpio_int1  %d\n",__func__,pdata->gpio_int1);
+	if(pdata->gpio_int1 < 0){
+		dev_err(dev, "fail to get irq_gpio_number\n");
+		LOG_INFO(" get irq1_gpio_number fail\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "poll_interval", &pdata->poll_interval);
+	LOG_INFO("%s: get pdata->poll_interval %d\n",__func__,pdata->poll_interval);	
+	if(ret){
+		dev_err(dev, "fail to get poll_interval\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "min_interval", &pdata->min_interval);
+	if(ret){
+		dev_err(dev, "fail to get min_interval\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "g_range", &pdata->g_range);
+	if(ret){
+		dev_err(dev, "fail to get g_range\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "axis_map_x", &pdata->axis_map_x);
+	if(ret){
+		dev_err(dev, "fail to get axis_map_x\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "axis_map_y", &pdata->axis_map_y);
+	if(ret){
+		dev_err(dev, "fail to get axis_map_y\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "axis_map_z", &pdata->axis_map_z);
+	if(ret){
+		dev_err(dev, "fail to get axis_map_z\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "negate_x", &pdata->negate_x);
+	if(ret){
+		dev_err(dev, "fail to get negate_x\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "negate_y", &pdata->negate_y);
+	if(ret){
+		dev_err(dev, "fail to get negate_y\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "negate_z", &pdata->negate_z);
+	if(ret){
+		dev_err(dev, "fail to get negate_z\n");
+		goto fail;
+	}
+	return pdata;
+fail:
+	kfree(pdata);
+	return NULL;
+}
+#endif
+
+
+
+
+#ifdef LIS3DH_DBG
+static int str2int(char *p, char *end)
+{
+        int result = 0;
+        int len = end - p + 1;
+        int c;
+
+        for(; len > 0; len--, p++) {
+                if(p > end)
+                        return -1;
+                c = *p - '0';
+                if((unsigned int)c >= 10)
+                        return -1;
+                result = result * 10 + c;
+        }
+        return result;
+}
+
+/*parse a int from the string*/
+static int get_int(char *p, u8 max_len)
+{
+        char *start = p;
+        char *end =NULL;
+
+        if(max_len > 60) {
+                LOG_ERR("CMD ERROR!the max length of the cmd should less than 60\n");
+                return -1;
+        }
+        for(; max_len > 0; max_len--, p++) {
+                if(*p >= '0' && *p <= '9') {
+                        start = p;
+                        break;
+                }
+        }
+        if(0 == max_len)
+                return -1;
+
+        end = start;
+
+        for(; max_len > 0; max_len--, p++) {
+                if(*p >= '0' && *p <= '9') {
+                        end = p;
+                        continue;
+                }
+                break;
+        }
+
+        return str2int(start, end);
+}
+
+static ssize_t lis3dh_val_show(struct kobject *kobj, struct kobj_attribute *attr, char *buff)
+{
+	 LOG_FUN( );
+	
+        return sprintf(buff, "acc->pdata->poll_interva=%d\n",lis3dh_acc_misc_data->pdata->poll_interval);
+}
+// adjust poll interval dynamiclly,eg echo 5>val_show ,means poll interval is 5ms
+static ssize_t lis3dh_val_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buff, size_t n)
+{
+	LOG_FUN( );
+	char *buff_temp = NULL;
+	int interval;
+       int err;
+	   
+	buff_temp = kmalloc(n, GFP_KERNEL);
+	if(NULL == buff_temp){
+	    LOG_ERR("kmalloc err\n");
+	    return n;
+	}
+
+	memcpy(buff_temp, buff, n);
+	interval = get_int(buff_temp, n);
+
+	if (interval < 0 || interval > 1000)
+	return -EINVAL;
+
+	lis3dh_acc_misc_data->pdata->poll_interval = max(interval,lis3dh_acc_misc_data->pdata->min_interval); // max the frequecy of g sensor
+       LOG_INFO("yuebao %s,acc->pdata->poll_interval =%d,interval=%d,acc->pdata->min_interval=%d\n", __func__,lis3dh_acc_misc_data->pdata->poll_interval,interval,lis3dh_acc_misc_data->pdata->min_interval );
+	err = lis3dh_acc_update_odr(lis3dh_acc_misc_data, lis3dh_acc_misc_data->pdata->poll_interval );
+	/* TODO: if update fails poll is still set */
+	//		if (err < 0)
+	//			return err;
+	if(buff_temp != NULL)
+	    kfree(buff_temp);
+
+	return 0;
+}
+
+/*
+1  should first write ,eg echo 0x20=0x97>reg
+2  then read ,eg cat reg:Addr: 0x20 Val: 0x97
+*/
+static ssize_t sensor_reg_show(struct kobject *kobj, struct kobj_attribute *attr, char *buff)
+{
+        int err;
+	  u8 value = 0;
+	
+	 LOG_FUN( );
+
+	err = lis3dh_acc_register_read(lis3dh_acc_misc_data, &value, lis3dh_acc_misc_data->debug.diag_reg_addr_wr);
+	return sprintf(buff, "Addr: 0x%x Val: 0x%x\n",
+			lis3dh_acc_misc_data->debug.diag_reg_addr_wr, value);	
+}
+
+static ssize_t sensor_reg_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buff, size_t n)
+{
+	char buf[32];
+	char *sptr, *token;
+	unsigned int len = 0;
+	u8 reg_addr, reg_val;
+	 int err = -1;
+
+	LOG_INFO("%s, user echo is:%s\n",__func__,buff);
+	len = min(n, sizeof(buf) - 1);
+	if (!memcpy(buf, buff, len)){
+		LOG_INFO("%s, %s\n",__func__,buf);
+		return -EFAULT;
+	}
+
+	buf[len] = '\0';
+	sptr = buf;
+
+	token = strsep(&sptr, "=");
+	LOG_INFO("%s, token=%s\n",__func__,token);
+
+	if (!token)
+		return -EINVAL;
+
+	 LOG_INFO("%s,now  token=%s,sptr=%s\n",__func__,token,sptr);
+
+	if (kstrtou8(token, 0, &reg_addr)){
+		 LOG_INFO("%s,now  reg_addr=0x%x\n",__func__,reg_addr);
+		return -EINVAL;
+	}
+//	if (!ath6kl_dbg_is_diag_reg_valid(reg_addr))
+//		return -EINVAL;
+
+	if (kstrtou8(sptr, 0, &reg_val)){
+		 LOG_INFO("%s,now reg_val=0x%x\n",__func__,reg_val);
+		return -EINVAL;
+	}
+	 LOG_INFO("%s,now  reg_addr=0x%x,reg_val=0x%x\n",__func__,reg_addr,reg_val);
+
+	lis3dh_acc_misc_data->debug.diag_reg_addr_wr = reg_addr;
+	lis3dh_acc_misc_data->debug.diag_reg_val_wr = reg_val;
+
+	buf[0] = reg_addr;
+	buf[1] = reg_val;
+		
+	err = lis3dh_acc_i2c_write(lis3dh_acc_misc_data, buf, 1);
+	if (err < 0){
+		LOG_ERR("%s: %d\n",__func__,err);
+		return -EIO;
+	}
+	//resume_state[index]   index  is not   reg addr,  so ONLY CAN config CTRL_REG1~CTRL_REG6 
+	lis3dh_acc_misc_data->resume_state[reg_addr-0x20] = reg_val;
+	 LOG_INFO("%s,now n=%d\n",__func__,n);
+	return n;
+}
+static struct kobject *lis3dh_kobj;
+static struct kobj_attribute lis3dh_val_attr =
+        __ATTR(show_val, 0644, lis3dh_val_show, lis3dh_val_store);
+static struct kobj_attribute sensor_reg_attr =
+        __ATTR(reg, 0644, sensor_reg_show, sensor_reg_store);
+
+
+static struct attribute *sensor_sysfs_attrs[] = {
+	&lis3dh_val_attr.attr,
+	&sensor_reg_attr.attr,
+		
+	NULL
+};
+
+static struct attribute_group sensor_attribute_group = {
+	.attrs = sensor_sysfs_attrs,
+};
+
+
+static int lis3dh_sysfs_init(struct lis3dh_acc_data *acc)
+{
+        int ret = -1;
+
+        lis3dh_kobj = kobject_create_and_add("lis3dh", &(acc->input_dev->dev.kobj));
+        if (lis3dh_kobj == NULL) {
+                ret = -ENOMEM;
+                LOG_ERR("register sysfs failed. ret = %d\n", ret);
+                return ret;
+        }
+	 ret = sysfs_create_group(lis3dh_kobj, &sensor_attribute_group);
+        if (ret) {
+                LOG_ERR("create sysfs failed. ret = %d\n", ret);
+                return ret;
+        }
+        return ret;
+}
+
+#endif
+
+static int lis3dh_acc_probe(struct i2c_client *client,
+			    const struct i2c_device_id *id)
+{
+
+	struct lis3dh_acc_data *acc;
+	struct lis3dh_acc_platform_data *pdata = client->dev.platform_data;
+
+	int err = -1;
+	int tempvalue;
+	LOG_INFO("sprd-gsensor: -- %s -- start !\n",__func__);
+	pr_debug("%s: probe start.\n", LIS3DH_ACC_DEV_NAME);
+
+
+#ifdef CONFIG_OF
+	struct device_node *np = client->dev.of_node;
+	if (np && !pdata){
+		pdata = lis3dh_acc_parse_dt(&client->dev);
+		if(pdata){
+			client->dev.platform_data = pdata;
+		}
+		if(!pdata){
+			err = -ENOMEM;
+			goto exit_alloc_platform_data_failed;
+		}
+	}
+#endif
+	/*
+	if (client->dev.platform_data == NULL) {
+		dev_err(&client->dev, "platform data is NULL. exiting.\n");
+		err = -ENODEV;
+		goto exit_check_functionality_failed;
+	}
+	*/
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+		dev_err(&client->dev, "client not i2c capable\n");
+		err = -ENODEV;
+		goto exit_check_functionality_failed;
+	}
+
+	if (!i2c_check_functionality(client->adapter,
+				     I2C_FUNC_SMBUS_BYTE |
+				     I2C_FUNC_SMBUS_BYTE_DATA |
+				     I2C_FUNC_SMBUS_WORD_DATA)) {
+		dev_err(&client->dev, "client not smb-i2c capable:2\n");
+		err = -EIO;
+		goto exit_check_functionality_failed;
+	}
+
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
+		dev_err(&client->dev, "client not smb-i2c capable:3\n");
+		err = -EIO;
+		goto exit_check_functionality_failed;
+	}
+	/*
+	 * OK. From now, we presume we have a valid client. We now create the
+	 * client structure, even though we cannot fill it completely yet.
+	 */
+
+	acc = kzalloc(sizeof(struct lis3dh_acc_data), GFP_KERNEL);
+	if (acc == NULL) {
+		err = -ENOMEM;
+		dev_err(&client->dev,
+			"failed to allocate memory for module data: "
+			"%d\n", err);
+		goto exit_alloc_data_failed;
+	}
+
+	mutex_init(&acc->lock);
+	mutex_lock(&acc->lock);
+
+	acc->client = client;
+	lis3dh_i2c_client = client;
+	i2c_set_clientdata(client, acc);
+
+	LOG_INFO("gpio pin request  (%d)\n", pdata->gpio_int1);
+       err=gpio_request(pdata->gpio_int1, "GSENSOR_INT1");
+    
+	if (err) {
+	        LOG_ERR("gpio pin request fail (%d)\n", err);
+	        goto err_free_irq1;
+	}  else  {
+			gpio_direction_input(pdata->gpio_int1);
+			LOG_INFO("sprd-gsensor: -- %s  acc->irq1_gpio_number  status is [%d]-- !\n",__func__,gpio_get_value(pdata->gpio_int1));
+			/*get irq*/
+			acc->irq1  = gpio_to_irq(pdata->gpio_int1);
+			LOG_INFO("IRQ1 number is %d\n", acc->irq1 );
+	}
+	if (acc->irq1 != 0) {
+		pr_debug("%s request irq1\n", __func__);
+		err =
+		    request_irq(acc->irq1, lis3dh_acc_isr1, IRQF_TRIGGER_HIGH| IRQF_NO_SUSPEND ,
+				"lis3dh_acc_irq1", acc);
+		if (err < 0) {
+			dev_err(&client->dev, "request irq1 failed: %d\n", err);
+			goto err_mutexunlockfreedata;
+		}
+		disable_irq_nosync(acc->irq1);
+
+		INIT_WORK(&acc->irq1_work, lis3dh_acc_irq1_work_func);
+		acc->irq1_work_queue =
+		    create_singlethread_workqueue("lis3dh_acc_wq1");
+		if (!acc->irq1_work_queue) {
+			err = -ENOMEM;
+			dev_err(&client->dev, "cannot create work queue1: %d\n",
+				err);
+			goto err_free_irq1;
+		}
+	}
+
+
+//	gpio_request(GSENSOR_GINT2_GPI, "GSENSOR_INT2");
+	acc->irq2 = 0; /* gpio_to_irq(GSENSOR_GINT2_GPI); */
+	if (acc->irq2 != 0) {
+		err =
+		    request_irq(acc->irq2, lis3dh_acc_isr2, IRQF_TRIGGER_RISING,
+				"lis3dh_acc_irq2", acc);
+		if (err < 0) {
+			dev_err(&client->dev, "request irq2 failed: %d\n", err);
+			goto err_destoyworkqueue1;
+		}
+		disable_irq_nosync(acc->irq2);
+
+/*		 Create workqueue for IRQ.*/
+
+		INIT_WORK(&acc->irq2_work, lis3dh_acc_irq2_work_func);
+		acc->irq2_work_queue =
+		    create_singlethread_workqueue("lis3dh_acc_wq2");
+		if (!acc->irq2_work_queue) {
+			err = -ENOMEM;
+			dev_err(&client->dev, "cannot create work queue2: %d\n",
+				err);
+			goto err_free_irq2;
+		}
+	}
+
+	acc->pdata = kmalloc(sizeof(*acc->pdata), GFP_KERNEL);
+	if (acc->pdata == NULL) {
+		err = -ENOMEM;
+		dev_err(&client->dev,
+			"failed to allocate memory for pdata: %d\n", err);
+		goto err_destoyworkqueue2;
+	}
+
+	memcpy(acc->pdata, client->dev.platform_data, sizeof(*acc->pdata));
+
+	err = lis3dh_acc_validate_pdata(acc);
+	if (err < 0) {
+		dev_err(&client->dev, "failed to validate platform data\n");
+		goto exit_kfree_pdata;
+	}
+
+#ifdef GSENSOR_INTERRUPT_MODE
+memset(acc->resume_state, 0, ARRAY_SIZE(acc->resume_state));
+
+	acc->resume_state[RES_CTRL_REG1] = LIS3DH_ACC_ENABLE_ALL_AXES;
+	acc->resume_state[RES_CTRL_REG2] = 0x00;
+	acc->resume_state[RES_CTRL_REG3] = CTRL_REG3_I1_DRDY1;//0x00;
+	acc->resume_state[RES_CTRL_REG4] = 0x00;
+	acc->resume_state[RES_CTRL_REG5] = CTRL_REG5_LIR_INT1;//0x00;
+	acc->resume_state[RES_CTRL_REG6] = CTRL_REG6_HLACTIVE;//0x00;
+
+	acc->resume_state[RES_TEMP_CFG_REG] = 0x00;
+	acc->resume_state[RES_FIFO_CTRL_REG] = 0x00;
+	acc->resume_state[RES_INT_CFG1] = 0x00;
+	acc->resume_state[RES_INT_THS1] = 0x00;
+	acc->resume_state[RES_INT_DUR1] = 0x00;
+	acc->resume_state[RES_INT_CFG2] = 0x00;
+	acc->resume_state[RES_INT_THS2] = 0x00;
+	acc->resume_state[RES_INT_DUR2] = 0x00;
+
+	acc->resume_state[RES_TT_CFG] = 0x00;
+	acc->resume_state[RES_TT_THS] = 0x00;
+	acc->resume_state[RES_TT_LIM] = 0x00;
+	acc->resume_state[RES_TT_TLAT] = 0x00;
+	acc->resume_state[RES_TT_TW] = 0x00;
+
+#endif
+	sprd_i2c_ctl_chg_clk(client->adapter->nr, 400000);
+
+
+
+
+	err = lis3dh_acc_device_power_on(acc);
+	if (err < 0) {
+		dev_err(&client->dev, "power on failed: %d\n", err);
+		goto err2;
+	}
+
+#if 1
+	if (i2c_smbus_read_byte(client) < 0) {
+		pr_err("i2c_smbus_read_byte error!!\n");
+		goto err_destoyworkqueue2;
+	} else {
+		pr_debug("%s Device detected!\n", LIS3DH_ACC_DEV_NAME);
+	}
+#endif
+	/* read chip id */
+
+	tempvalue = i2c_smbus_read_word_data(client, WHO_AM_I);
+
+	if ((tempvalue & 0x00FF) == WHOAMI_LIS3DH_ACC) {
+		pr_debug("%s I2C driver registered!\n",
+		       LIS3DH_ACC_DEV_NAME);
+	} else {
+		acc->client = NULL;
+		pr_debug("I2C driver not registered!"
+		       " Device unknown 0x%x\n", tempvalue);
+		goto err_destoyworkqueue2;
+	}
+	
+	i2c_set_clientdata(client, acc);
+
+	if (acc->pdata->init) {
+		err = acc->pdata->init();
+		if (err < 0) {
+			dev_err(&client->dev, "init failed: %d\n", err);
+			goto err2;
+		}
+	}
+#ifndef GSENSOR_INTERRUPT_MODE
+	memset(acc->resume_state, 0, ARRAY_SIZE(acc->resume_state));
+
+	acc->resume_state[RES_CTRL_REG1] = LIS3DH_ACC_ENABLE_ALL_AXES;
+	acc->resume_state[RES_CTRL_REG2] = 0x00;
+	acc->resume_state[RES_CTRL_REG3] = CTRL_REG3_I1_DRDY1;//0x00;
+	acc->resume_state[RES_CTRL_REG4] = 0x00;
+	acc->resume_state[RES_CTRL_REG5] = 0x00;//CTRL_REG5_LIR_INT1;//0x04;
+	acc->resume_state[RES_CTRL_REG6] = CTRL_REG6_HLACTIVE;//0x00;
+
+	acc->resume_state[RES_TEMP_CFG_REG] = 0x00;
+	acc->resume_state[RES_FIFO_CTRL_REG] = 0x00;
+	acc->resume_state[RES_INT_CFG1] = 0x00;
+	acc->resume_state[RES_INT_THS1] = 0x00;
+	acc->resume_state[RES_INT_DUR1] = 0x00;
+	acc->resume_state[RES_INT_CFG2] = 0x00;
+	acc->resume_state[RES_INT_THS2] = 0x00;
+	acc->resume_state[RES_INT_DUR2] = 0x00;
+
+	acc->resume_state[RES_TT_CFG] = 0x00;
+	acc->resume_state[RES_TT_THS] = 0x00;
+	acc->resume_state[RES_TT_LIM] = 0x00;
+	acc->resume_state[RES_TT_TLAT] = 0x00;
+	acc->resume_state[RES_TT_TW] = 0x00;
+
+#endif
+	atomic_set(&acc->enabled, 1);
+
+	err = lis3dh_acc_update_g_range(acc, acc->pdata->g_range);
+	if (err < 0) {
+		dev_err(&client->dev, "update_g_range failed\n");
+		goto err_power_off;
+	}
+
+	err = lis3dh_acc_update_odr(acc, acc->pdata->poll_interval);
+	if (err < 0) {
+		dev_err(&client->dev, "update_odr failed\n");
+		goto err_power_off;
+	}
+
+	err = lis3dh_acc_input_init(acc);
+	if (err < 0) {
+		dev_err(&client->dev, "input init failed\n");
+		goto err_power_off;
+	}
+	lis3dh_acc_misc_data = acc;
+
+	err = misc_register(&lis3dh_acc_misc_device);
+	if (err < 0) {
+		dev_err(&client->dev,
+			"misc LIS3DH_ACC_DEV_NAME register failed\n");
+		goto err_input_cleanup;
+	}
+
+	lis3dh_acc_device_power_off(acc);
+
+	/* As default, do not report information */
+	atomic_set(&acc->enabled, 0);
+/*
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	acc->early_suspend.suspend = lis3dh_early_suspend;
+	acc->early_suspend.resume = lis3dh_early_resume;
+	acc->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
+	register_early_suspend(&acc->early_suspend);
+#endif
+*/
+#ifdef LIS3DH_DBG
+        err = lis3dh_sysfs_init(acc);
+        if(err) {
+                LOG_ERR("lis3dh_sysfs_init failed!\n");
+                goto exit_lis3dh_sysfs_init_failed;
+        }
+#endif
+#if USE_WAIT_QUEUE
+	thread = kthread_run(gsensor_event_handler, 0, "gsensor-wait");
+	if (IS_ERR(thread))
+	{
+		err = PTR_ERR(thread);
+		LOG_ERR("failed to create kernel thread: %d\n", err);
+	}
+#endif
+	mutex_unlock(&acc->lock);
+	dev_info(&client->dev, "###%s###\n", __func__);
+       LOG_INFO("sprd-gsensor: -- %s exit :acc->irq1_gpio_number status is [%d]-- !\n",__func__,gpio_get_value(acc->pdata->gpio_int1));
+	LOG_INFO("sprd-gsensor: -- %s -- success !\n",__func__);
+	return 0;
+
+#ifdef LIS3DH_DBG
+exit_lis3dh_sysfs_init_failed:
+#endif
+	
+err_input_cleanup:
+	lis3dh_acc_input_cleanup(acc);
+err_power_off:
+	lis3dh_acc_device_power_off(acc);
+err2:
+	if (acc->pdata->exit)
+		acc->pdata->exit();
+exit_kfree_pdata:
+	kfree(acc->pdata);
+err_destoyworkqueue2:
+	if (acc->irq2_work_queue)
+		destroy_workqueue(acc->irq2_work_queue);
+err_free_irq2:
+	if (acc->irq2) {
+		free_irq(acc->irq2, acc);
+		gpio_free(GSENSOR_GINT2_GPI);
+	}
+err_destoyworkqueue1:
+	if (acc->irq1_work_queue)
+		destroy_workqueue(acc->irq1_work_queue);
+err_free_irq1:
+	if (acc->irq1) {
+		free_irq(acc->irq1, acc);
+		gpio_free(acc->pdata->gpio_int1);
+	}
+err_mutexunlockfreedata:
+	i2c_set_clientdata(client, NULL);
+	mutex_unlock(&acc->lock);
+	kfree(acc);
+	lis3dh_acc_misc_data = NULL;
+exit_alloc_data_failed:
+exit_check_functionality_failed:
+	pr_err("%s: Driver Init failed\n", LIS3DH_ACC_DEV_NAME);
+exit_alloc_platform_data_failed:
+	return err;
+}
+
+static int  lis3dh_acc_remove(struct i2c_client *client)
+{
+
+	/* TODO: revisit ordering here once _probe order is finalized */
+	struct lis3dh_acc_data *acc = i2c_get_clientdata(client);
+	if (acc != NULL) {
+		if (acc->irq1) {
+			free_irq(acc->irq1, acc);
+			gpio_free(acc->pdata->gpio_int1);
+		}
+		if (acc->irq2) {
+			free_irq(acc->irq2, acc);
+			gpio_free(GSENSOR_GINT2_GPI);
+		}
+
+		if (acc->irq1_work_queue)
+			destroy_workqueue(acc->irq1_work_queue);
+		if (acc->irq2_work_queue)
+			destroy_workqueue(acc->irq2_work_queue);
+		misc_deregister(&lis3dh_acc_misc_device);
+		lis3dh_acc_input_cleanup(acc);
+		lis3dh_acc_device_power_off(acc);
+		if (acc->pdata->exit)
+			acc->pdata->exit();
+		kfree(acc->pdata);
+		kfree(acc);
+	}
+
+	return 0;
+}
+
+static int lis3dh_acc_resume(struct i2c_client *client)
+{
+	struct lis3dh_acc_data *acc = i2c_get_clientdata(client);
+
+	LOG_INFO("sprd-gsensor: -- %s -- !\n",__func__);
+	dev_dbg(&client->dev, "###%s###\n", __func__);
+	if (acc != NULL && acc->on_before_suspend)
+		return lis3dh_acc_enable(acc);
+
+	return 0;
+}
+
+static int lis3dh_acc_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+	struct lis3dh_acc_data *acc = i2c_get_clientdata(client);
+
+	LOG_INFO("sprd-gsensor: -- %s -- !\n",__func__);
+	dev_dbg(&client->dev, "###%s###\n", __func__);
+	if (acc != NULL) {
+		acc->on_before_suspend = atomic_read(&acc->enabled);
+		return lis3dh_acc_disable(acc);
+	}
+	return 0;
+}
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+
+static void lis3dh_early_suspend(struct early_suspend *es)
+{
+	lis3dh_acc_suspend(lis3dh_i2c_client, (pm_message_t) {
+			   .event = 0});
+}
+
+static void lis3dh_early_resume(struct early_suspend *es)
+{
+	lis3dh_acc_resume(lis3dh_i2c_client);
+}
+
+#endif /* CONFIG_HAS_EARLYSUSPEND */
+
+static const struct i2c_device_id lis3dh_acc_id[]
+= { {LIS3DH_ACC_DEV_NAME, 0}, {}, };
+
+MODULE_DEVICE_TABLE(i2c, lis3dh_acc_id);
+
+static const struct of_device_id lis3dh_acc_of_match[] = {
+       { .compatible = "ST,lis3dh_acc", },
+       { }
+};
+MODULE_DEVICE_TABLE(of, lis3dh_acc_of_match);
+static struct i2c_driver lis3dh_acc_driver = {
+	.driver = {
+		   .name = LIS3DH_ACC_I2C_NAME,
+		   .of_match_table = lis3dh_acc_of_match,
+		   },
+	.probe = lis3dh_acc_probe,
+	.remove = lis3dh_acc_remove,
+	.resume = lis3dh_acc_resume,
+	.suspend = lis3dh_acc_suspend,
+	.id_table = lis3dh_acc_id,
+};
+
+
+static int __init lis3dh_acc_init(void)
+{
+	pr_debug("%s accelerometer driver: init\n", LIS3DH_ACC_I2C_NAME);
+
+	return i2c_add_driver(&lis3dh_acc_driver);
+}
+
+static void __exit lis3dh_acc_exit(void)
+{
+	pr_debug("%s accelerometer driver exit\n", LIS3DH_ACC_DEV_NAME);
+
+	i2c_del_driver(&lis3dh_acc_driver);
+	return;
+}
+
+module_init(lis3dh_acc_init);
+module_exit(lis3dh_acc_exit);
+
+MODULE_DESCRIPTION("lis3dh accelerometer misc driver");
+MODULE_AUTHOR("STMicroelectronics");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/lis3dh_zt.c b/drivers/input/misc/lis3dh_zt.c
new file mode 100644
index 00000000..c0494cb3
--- /dev/null
+++ b/drivers/input/misc/lis3dh_zt.c
@@ -0,0 +1,1729 @@
+/******************** (C) COPYRIGHT 2010 STMicroelectronics ********************
+ *
+ * File Name          : lis3dh_acc.c
+ * Authors            : MSH - Motion Mems BU - Application Team
+ *		      : Carmine Iascone (carmine.iascone@st.com)
+ *		      : Matteo Dameno (matteo.dameno@st.com)
+ * Version            : V.1.0.5
+ * Date               : 16/08/2010
+ * Description        : LIS3DH accelerometer sensor API
+ *
+ *******************************************************************************
+ *
+ * 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.
+ *
+ * THE PRESENT SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES
+ * OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, FOR THE SOLE
+ * PURPOSE TO SUPPORT YOUR APPLICATION DEVELOPMENT.
+ * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+ * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+ * CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+ * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+ *
+ * THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS.
+ *
+ ******************************************************************************
+ Revision 1.0.0 05/11/09
+ First Release
+ Revision 1.0.3 22/01/2010
+  Linux K&R Compliant Release;
+ Revision 1.0.5 16/08/2010
+ modified _get_acceleration_data function
+ modified _update_odr function
+ manages 2 interrupts
+
+ ******************************************************************************/
+
+#include	<linux/module.h>
+#include	<linux/err.h>
+#include	<linux/errno.h>
+#include	<linux/delay.h>
+#include	<linux/fs.h>
+#include	<linux/i2c.h>
+
+#include	<linux/input.h>
+#include	<linux/input-polldev.h>
+#include	<linux/miscdevice.h>
+#include	<linux/uaccess.h>
+#include        <linux/slab.h>
+
+#include	<linux/workqueue.h>
+#include	<linux/irq.h>
+#include	<linux/gpio.h>
+#include	<linux/interrupt.h>
+#ifdef CONFIG_HAS_EARLYSUSPEND
+#include        <linux/earlysuspend.h>
+#endif
+
+#include        <linux/i2c/lis3dh_zt.h>
+#include <linux/of_device.h>
+#include <linux/of_address.h>
+#include <linux/of_gpio.h>
+
+#define	INTERRUPT_MANAGEMENT 1
+
+#define	G_MAX		16000	/** Maximum polled-device-reported g value */
+
+/*
+#define	SHIFT_ADJ_2G		4
+#define	SHIFT_ADJ_4G		3
+#define	SHIFT_ADJ_8G		2
+#define	SHIFT_ADJ_16G		1
+*/
+
+//#define SENSITIVITY_2G		1	/**	mg/LSB	*/
+#define SENSITIVITY_2G	  15.6		/**	mg/LSB	*/
+//#define SENSITIVITY_4G		2	/**	mg/LSB	*/
+#define SENSITIVITY_4G	  31.2	/**	mg/LSB	*/
+//#define SENSITIVITY_8G		4	/**	mg/LSB	*/
+#define SENSITIVITY_8G	  62.5	/**	mg/LSB	*/
+//#define SENSITIVITY_16G		12	/**	mg/LSB	*/
+#define SENSITIVITY_16G	  187.5	/**	mg/LSB	*/
+
+#define	HIGH_RESOLUTION		0x08
+
+#define	AXISDATA_REG		0x28
+#define WHOAMI_LIS3DH_ACC	0x33	/*      Expctd content for WAI  */
+
+/*	CONTROL REGISTERS	*/
+#define WHO_AM_I		0x0F	/*      WhoAmI register         */
+#define	TEMP_CFG_REG		0x1F	/*      temper sens control reg */
+/* ctrl 1: ODR3 ODR2 ODR ODR0 LPen Zenable Yenable Zenable */
+#define	CTRL_REG1		0x20	/*      control reg 1           */
+#define	CTRL_REG2		0x21	/*      control reg 2           */
+#define	CTRL_REG3		0x22	/*      control reg 3           */
+#define	CTRL_REG4		0x23	/*      control reg 4           */
+#define	CTRL_REG5		0x24	/*      control reg 5           */
+#define	CTRL_REG6		0x25	/*      control reg 6           */
+
+#define	FIFO_CTRL_REG		0x2E	/*      FiFo control reg        */
+
+#define	INT_CFG1		0x30	/*      interrupt 1 config      */
+#define	INT_SRC1		0x31	/*      interrupt 1 source      */
+#define	INT_THS1		0x32	/*      interrupt 1 threshold   */
+#define	INT_DUR1		0x33	/*      interrupt 1 duration    */
+
+#define	INT_CFG2		0x34	/*      interrupt 2 config      */
+#define	INT_SRC2		0x35	/*      interrupt 2 source      */
+#define	INT_THS2		0x36	/*      interrupt 2 threshold   */
+#define	INT_DUR2		0x37	/*      interrupt 2 duration    */
+
+#define	TT_CFG			0x38	/*      tap config              */
+#define	TT_SRC			0x39	/*      tap source              */
+#define	TT_THS			0x3A	/*      tap threshold           */
+#define	TT_LIM			0x3B	/*      tap time limit          */
+#define	TT_TLAT			0x3C	/*      tap time latency        */
+#define	TT_TW			0x3D	/*      tap time window         */
+/*	end CONTROL REGISTRES	*/
+
+#define ENABLE_HIGH_RESOLUTION	1
+
+#define LIS3DH_ACC_PM_OFF		0x00
+#define LIS3DH_ACC_ENABLE_ALL_AXES	0x07
+
+#define PMODE_MASK			0x08
+#define ODR_MASK			0XF0
+
+#define ODR1		0x10	/* 1Hz output data rate */
+#define ODR10		0x20	/* 10Hz output data rate */
+#define ODR25		0x30	/* 25Hz output data rate */
+#define ODR50		0x40	/* 50Hz output data rate */
+#define ODR100		0x50	/* 100Hz output data rate */
+#define ODR200		0x60	/* 200Hz output data rate */
+#define ODR400		0x70	/* 400Hz output data rate */
+#define ODR1250		0x90	/* 1250Hz output data rate */
+
+#define	IA			0x40
+#define	ZH			0x20
+#define	ZL			0x10
+#define	YH			0x08
+#define	YL			0x04
+#define	XH			0x02
+#define	XL			0x01
+/* */
+/* CTRL REG BITS*/
+#define	CTRL_REG3_I1_AOI1	0x40
+#define	CTRL_REG6_I2_TAPEN	0x80
+#define	CTRL_REG6_HLACTIVE	0x02
+/* */
+
+/* TAP_SOURCE_REG BIT */
+#define	DTAP			0x20
+#define	STAP			0x10
+#define	SIGNTAP			0x08
+#define	ZTAP			0x04
+#define	YTAP			0x02
+#define	XTAZ			0x01
+
+#define	FUZZ			32
+#define	FLAT			32
+#define	I2C_RETRY_DELAY		5
+#define	I2C_RETRIES		5
+#define	I2C_AUTO_INCREMENT	0x80
+
+/* RESUME STATE INDICES */
+#define	RES_CTRL_REG1		0
+#define	RES_CTRL_REG2		1
+#define	RES_CTRL_REG3		2
+#define	RES_CTRL_REG4		3
+#define	RES_CTRL_REG5		4
+#define	RES_CTRL_REG6		5
+
+#define	RES_INT_CFG1		6
+#define	RES_INT_THS1		7
+#define	RES_INT_DUR1		8
+#define	RES_INT_CFG2		9
+#define	RES_INT_THS2		10
+#define	RES_INT_DUR2		11
+
+#define	RES_TT_CFG		12
+#define	RES_TT_THS		13
+#define	RES_TT_LIM		14
+#define	RES_TT_TLAT		15
+#define	RES_TT_TW		16
+
+#define	RES_TEMP_CFG_REG	17
+#define	RES_REFERENCE_REG	18
+#define	RES_FIFO_CTRL_REG	19
+
+#define	RESUME_ENTRIES		20
+#define DEVICE_INFO             "ST, LIS3DH"
+#define DEVICE_INFO_LEN         32
+/* end RESUME STATE INDICES */
+
+#define GSENSOR_GINT1_GPI 0
+#define GSENSOR_GINT2_GPI 1
+
+struct {
+	unsigned int cutoff_ms;
+	unsigned int mask;
+} lis3dh_acc_odr_table[] = {
+	{
+	1, ODR1250}, {
+	3, ODR400}, {
+	5, ODR200}, {
+	10, ODR100}, {
+	20, ODR50}, {
+	40, ODR25}, {
+	100, ODR10}, {
+1000, ODR1},};
+
+struct lis3dh_acc_data {
+	struct i2c_client *client;
+	struct lis3dh_acc_platform_data *pdata;
+
+	struct mutex lock;
+	struct delayed_work input_work;
+
+	struct input_dev *input_dev;
+
+	int hw_initialized;
+	/* hw_working=-1 means not tested yet */
+	int hw_working;
+	atomic_t enabled;
+	int on_before_suspend;
+
+	u8 sensitivity;
+
+	u8 resume_state[RESUME_ENTRIES];
+
+	int irq1;
+	struct work_struct irq1_work;
+	struct workqueue_struct *irq1_work_queue;
+	int irq2;
+	struct work_struct irq2_work;
+	struct workqueue_struct *irq2_work_queue;
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	struct early_suspend early_suspend;
+#endif
+};
+
+/*
+ * Because misc devices can not carry a pointer from driver register to
+ * open, we keep this global.  This limits the driver to a single instance.
+ */
+struct lis3dh_acc_data *lis3dh_acc_misc_data;
+struct i2c_client *lis3dh_i2c_client;
+
+static int lis3dh_acc_i2c_read(struct lis3dh_acc_data *acc, u8 * buf, int len)
+{
+	int err;
+	int tries = 0;
+
+	struct i2c_msg msgs[] = {
+		{
+		 .addr = acc->client->addr,
+		 .flags = acc->client->flags & I2C_M_TEN,
+		 .len = 1,
+		 .buf = buf,},
+		{
+		 .addr = acc->client->addr,
+		 .flags = (acc->client->flags & I2C_M_TEN) | I2C_M_RD,
+		 .len = len,
+		 .buf = buf,},
+	};
+
+	do {
+		err = i2c_transfer(acc->client->adapter, msgs, 2);
+		if (err != 2)
+			msleep_interruptible(I2C_RETRY_DELAY);
+	} while ((err != 2) && (++tries < I2C_RETRIES));
+
+	if (err != 2) {
+		dev_err(&acc->client->dev, "read transfer error\n");
+		err = -EIO;
+	} else {
+		err = 0;
+	}
+
+	return err;
+}
+
+static int lis3dh_acc_i2c_write(struct lis3dh_acc_data *acc, u8 * buf, int len)
+{
+	int err;
+	int tries = 0;
+
+	struct i2c_msg msgs[] = { {.addr = acc->client->addr,
+				   .flags = acc->client->flags & I2C_M_TEN,
+				   .len = len + 1,.buf = buf,},
+	};
+	do {
+		err = i2c_transfer(acc->client->adapter, msgs, 1);
+		if (err != 1)
+			msleep_interruptible(I2C_RETRY_DELAY);
+	} while ((err != 1) && (++tries < I2C_RETRIES));
+
+	if (err != 1) {
+		dev_err(&acc->client->dev, "write transfer error\n");
+		err = -EIO;
+	} else {
+		err = 0;
+	}
+
+	return err;
+}
+
+static int lis3dh_acc_hw_init(struct lis3dh_acc_data *acc)
+{
+	int err = -1;
+	u8 buf[7];
+
+	pr_debug("%s: hw init start\n", LIS3DH_ACC_DEV_NAME);
+
+	buf[0] = WHO_AM_I;
+	err = lis3dh_acc_i2c_read(acc, buf, 1);
+	if (err < 0)
+		goto error_firstread;
+	else
+		acc->hw_working = 1;
+	if (buf[0] != WHOAMI_LIS3DH_ACC) {
+		err = -1;	/* choose the right coded error */
+		goto error_unknown_device;
+	}
+
+	buf[0] = CTRL_REG1;
+	buf[1] = acc->resume_state[RES_CTRL_REG1];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = TEMP_CFG_REG;
+	buf[1] = acc->resume_state[RES_TEMP_CFG_REG];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = FIFO_CTRL_REG;
+	buf[1] = acc->resume_state[RES_FIFO_CTRL_REG];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = (I2C_AUTO_INCREMENT | TT_THS);
+	buf[1] = acc->resume_state[RES_TT_THS];
+	buf[2] = acc->resume_state[RES_TT_LIM];
+	buf[3] = acc->resume_state[RES_TT_TLAT];
+	buf[4] = acc->resume_state[RES_TT_TW];
+	err = lis3dh_acc_i2c_write(acc, buf, 4);
+	if (err < 0)
+		goto error1;
+	buf[0] = TT_CFG;
+	buf[1] = acc->resume_state[RES_TT_CFG];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = (I2C_AUTO_INCREMENT | INT_THS1);
+	buf[1] = acc->resume_state[RES_INT_THS1];
+	buf[2] = acc->resume_state[RES_INT_DUR1];
+	err = lis3dh_acc_i2c_write(acc, buf, 2);
+	if (err < 0)
+		goto error1;
+	buf[0] = INT_CFG1;
+	buf[1] = acc->resume_state[RES_INT_CFG1];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = (I2C_AUTO_INCREMENT | INT_THS2);
+	buf[1] = acc->resume_state[RES_INT_THS2];
+	buf[2] = acc->resume_state[RES_INT_DUR2];
+	err = lis3dh_acc_i2c_write(acc, buf, 2);
+	if (err < 0)
+		goto error1;
+	buf[0] = INT_CFG2;
+	buf[1] = acc->resume_state[RES_INT_CFG2];
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		goto error1;
+
+	buf[0] = (I2C_AUTO_INCREMENT | CTRL_REG2);
+	buf[1] = acc->resume_state[RES_CTRL_REG2];
+	buf[2] = acc->resume_state[RES_CTRL_REG3];
+	buf[3] = acc->resume_state[RES_CTRL_REG4];
+	buf[4] = acc->resume_state[RES_CTRL_REG5];
+	buf[5] = acc->resume_state[RES_CTRL_REG6];
+	err = lis3dh_acc_i2c_write(acc, buf, 5);
+	if (err < 0)
+		goto error1;
+
+	acc->hw_initialized = 1;
+	pr_debug("%s: hw init done\n", LIS3DH_ACC_DEV_NAME);
+	return 0;
+
+error_firstread:
+	acc->hw_working = 0;
+	dev_warn(&acc->client->dev, "Error reading WHO_AM_I: is device "
+		 "available/working?\n");
+	goto error1;
+error_unknown_device:
+	dev_err(&acc->client->dev,
+		"device unknown. Expected: 0x%x,"
+		" Replies: 0x%x\n", WHOAMI_LIS3DH_ACC, buf[0]);
+error1:
+	acc->hw_initialized = 0;
+	dev_err(&acc->client->dev, "hw init error 0x%x,0x%x: %d\n", buf[0],
+		buf[1], err);
+	return err;
+}
+
+static void lis3dh_acc_device_power_off(struct lis3dh_acc_data *acc)
+{
+	int err;
+	u8 buf[2] = { CTRL_REG1, LIS3DH_ACC_PM_OFF };
+
+	err = lis3dh_acc_i2c_write(acc, buf, 1);
+	if (err < 0)
+		dev_err(&acc->client->dev, "soft power off failed: %d\n", err);
+
+	if (acc->pdata->power_off) {
+		if (acc->irq1 != 0)
+			disable_irq_nosync(acc->irq1);
+		if (acc->irq2 != 0)
+			disable_irq_nosync(acc->irq2);
+		acc->pdata->power_off();
+		acc->hw_initialized = 0;
+	}
+	if (acc->hw_initialized) {
+		if (acc->irq1 != 0)
+			disable_irq_nosync(acc->irq1);
+		if (acc->irq2 != 0)
+			disable_irq_nosync(acc->irq2);
+		acc->hw_initialized = 0;
+	}
+}
+
+static int lis3dh_acc_device_power_on(struct lis3dh_acc_data *acc)
+{
+	int err = -1;
+
+	if (acc->pdata->power_on) {
+		err = acc->pdata->power_on();
+		if (err < 0) {
+			dev_err(&acc->client->dev,
+				"power_on failed: %d\n", err);
+			return err;
+		}
+	}
+
+	if (!acc->hw_initialized) {
+		err = lis3dh_acc_hw_init(acc);
+		if (acc->hw_working == 1 && err < 0) {
+			lis3dh_acc_device_power_off(acc);
+			return err;
+		}
+	}
+	return 0;
+}
+
+static irqreturn_t lis3dh_acc_isr1(int irq, void *dev)
+{
+	struct lis3dh_acc_data *acc = dev;
+
+	disable_irq_nosync(irq);
+	queue_work(acc->irq1_work_queue, &acc->irq1_work);
+
+	pr_debug("%s: isr1 queued\n", LIS3DH_ACC_DEV_NAME);
+
+	return IRQ_HANDLED;
+}
+
+static irqreturn_t lis3dh_acc_isr2(int irq, void *dev)
+{
+	struct lis3dh_acc_data *acc = dev;
+
+	disable_irq_nosync(irq);
+	queue_work(acc->irq2_work_queue, &acc->irq2_work);
+
+	pr_debug("%s: isr2 queued\n", LIS3DH_ACC_DEV_NAME);
+
+	return IRQ_HANDLED;
+}
+
+static void lis3dh_acc_irq1_work_func(struct work_struct *work)
+{
+
+	struct lis3dh_acc_data *acc =
+	    container_of(work, struct lis3dh_acc_data, irq1_work);
+	
+	/* TODO  add interrupt service procedure.
+	   ie:lis3dh_acc_get_int1_source(acc); */
+	;
+	/*  */
+	pr_debug("%s: IRQ1 triggered\n", LIS3DH_ACC_DEV_NAME);
+}
+
+static void lis3dh_acc_irq2_work_func(struct work_struct *work)
+{
+
+	/*struct lis3dh_acc_data *acc =
+	    container_of(work, struct lis3dh_acc_data, irq2_work);
+	*/
+	/* TODO  add interrupt service procedure.
+	   ie:lis3dh_acc_get_tap_source(acc); */
+	;
+	/*  */
+
+	pr_debug("%s: IRQ2 triggered\n", LIS3DH_ACC_DEV_NAME);
+}
+
+int lis3dh_acc_update_g_range(struct lis3dh_acc_data *acc, u8 new_g_range)
+{
+	int err;
+
+	u8 sensitivity;
+	u8 buf[2];
+	u8 updated_val;
+	u8 init_val;
+	u8 new_val;
+	u8 mask = LIS3DH_ACC_FS_MASK | HIGH_RESOLUTION;
+
+	pr_debug("%s\n", __func__);
+
+	switch (new_g_range) {
+	case LIS3DH_ACC_G_2G:
+
+		sensitivity = SENSITIVITY_2G;
+		break;
+	case LIS3DH_ACC_G_4G:
+
+		sensitivity = SENSITIVITY_4G;
+		break;
+	case LIS3DH_ACC_G_8G:
+
+		sensitivity = SENSITIVITY_8G;
+		break;
+	case LIS3DH_ACC_G_16G:
+
+		sensitivity = SENSITIVITY_16G;
+		break;
+	default:
+		dev_err(&acc->client->dev, "invalid g range requested: %u\n",
+			new_g_range);
+		return -EINVAL;
+	}
+
+	if (atomic_read(&acc->enabled)) {
+		/* Set configuration register 4, which contains g range setting
+		 *  NOTE: this is a straight overwrite because this driver does
+		 *  not use any of the other configuration bits in this
+		 *  register.  Should this become untrue, we will have to read
+		 *  out the value and only change the relevant bits --XX----
+		 *  (marked by X) */
+		buf[0] = CTRL_REG4;
+		err = lis3dh_acc_i2c_read(acc, buf, 1);
+		if (err < 0)
+			goto error;
+		init_val = buf[0];
+		acc->resume_state[RES_CTRL_REG4] = init_val;
+		new_val = new_g_range | HIGH_RESOLUTION;
+		updated_val = ((mask & new_val) | ((~mask) & init_val));
+		buf[1] = updated_val;
+		buf[0] = CTRL_REG4;
+		err = lis3dh_acc_i2c_write(acc, buf, 1);
+		if (err < 0)
+			goto error;
+		acc->resume_state[RES_CTRL_REG4] = updated_val;
+		acc->sensitivity = sensitivity;
+
+		pr_debug("%s sensitivity %d g-range %d\n", __func__, sensitivity,new_g_range);
+	}
+
+	return 0;
+error:
+	dev_err(&acc->client->dev, "update g range failed 0x%x,0x%x: %d\n",
+		buf[0], buf[1], err);
+
+	return err;
+}
+
+int lis3dh_acc_update_odr(struct lis3dh_acc_data *acc, int poll_interval_ms)
+{
+	int err = -1;
+	int i;
+	u8 config[2];
+
+	/* Convert the poll interval into an output data rate configuration
+	 *  that is as low as possible.  The ordering of these checks must be
+	 *  maintained due to the cascading cut off values - poll intervals are
+	 *  checked from shortest to longest.  At each check, if the next lower
+	 *  ODR cannot support the current poll interval, we stop searching */
+	for (i = ARRAY_SIZE(lis3dh_acc_odr_table) - 1; i >= 0; i--) {
+		if (lis3dh_acc_odr_table[i].cutoff_ms <= poll_interval_ms)
+			break;
+	}
+	config[1] = lis3dh_acc_odr_table[i].mask;
+
+	config[1] |= LIS3DH_ACC_ENABLE_ALL_AXES;
+
+	/* If device is currently enabled, we need to write new
+	 *  configuration out to it */
+	if (atomic_read(&acc->enabled)) {
+		config[0] = CTRL_REG1;
+		err = lis3dh_acc_i2c_write(acc, config, 1);
+		if (err < 0)
+			goto error;
+		acc->resume_state[RES_CTRL_REG1] = config[1];
+	}
+
+	return 0;
+
+error:
+	dev_err(&acc->client->dev, "update odr failed 0x%x,0x%x: %d\n",
+		config[0], config[1], err);
+
+	return err;
+}
+
+/* */
+
+static int lis3dh_acc_register_write(struct lis3dh_acc_data *acc, u8 * buf,
+				     u8 reg_address, u8 new_value)
+{
+	int err = -1;
+
+	if (atomic_read(&acc->enabled)) {
+		/* Sets configuration register at reg_address
+		 *  NOTE: this is a straight overwrite  */
+		buf[0] = reg_address;
+		buf[1] = new_value;
+		err = lis3dh_acc_i2c_write(acc, buf, 1);
+		if (err < 0)
+			return err;
+	}
+	return err;
+}
+
+static int lis3dh_acc_register_read(struct lis3dh_acc_data *acc, u8 * buf,
+				    u8 reg_address)
+{
+
+	int err = -1;
+	buf[0] = (reg_address);
+	err = lis3dh_acc_i2c_read(acc, buf, 1);
+	return err;
+}
+
+static int lis3dh_acc_register_update(struct lis3dh_acc_data *acc, u8 * buf,
+				      u8 reg_address, u8 mask,
+				      u8 new_bit_values)
+{
+	int err = -1;
+	u8 init_val;
+	u8 updated_val;
+	err = lis3dh_acc_register_read(acc, buf, reg_address);
+	if (!(err < 0)) {
+		init_val = buf[1];
+		updated_val = ((mask & new_bit_values) | ((~mask) & init_val));
+		err = lis3dh_acc_register_write(acc, buf, reg_address,
+						updated_val);
+	}
+	return err;
+}
+
+/* */
+
+static int lis3dh_acc_get_acceleration_data(struct lis3dh_acc_data *acc,
+					    int *xyz)
+{
+	int err = -1;
+	/* Data bytes from hardware xL, xH, yL, yH, zL, zH */
+	u8 acc_data[6];
+	/* x,y,z hardware data */
+	s16 hw_d[3] = { 0 };
+	s8  acc_data_term[3]={0};
+
+	acc_data[0] = (I2C_AUTO_INCREMENT | AXISDATA_REG);
+	err = lis3dh_acc_i2c_read(acc, acc_data, 6);
+
+	if (err < 0) {
+		pr_debug("%s I2C read error %d\n", LIS3DH_ACC_I2C_NAME,
+		       err);
+		return err;
+	}
+
+	//hw_d[0] = (((s16) ((acc_data[1] << 8) | acc_data[0])) >> 4);
+	//hw_d[1] = (((s16) ((acc_data[3] << 8) | acc_data[2])) >> 4);
+	//hw_d[2] = (((s16) ((acc_data[5] << 8) | acc_data[4])) >> 4);
+	acc_data_term[0]=acc_data[1];
+	acc_data_term[1]=acc_data[3];
+	acc_data_term[2]=acc_data[5];
+
+	//printk("%s read 000 x=%d, y=%d, z=%d\n",
+	//       LIS3DH_ACC_DEV_NAME, acc_data_term[0], acc_data_term[1], acc_data_term[2]);
+	//hw_d[0] = hw_d[0] * acc->sensitivity;
+	hw_d[0] = acc_data_term[0] * acc->sensitivity;
+	//hw_d[1] = hw_d[1] * acc->sensitivity;
+	hw_d[1] = acc_data_term[1] * acc->sensitivity;
+	//hw_d[2] = hw_d[2] * acc->sensitivity;
+	hw_d[2] = acc_data_term[2] * acc->sensitivity;
+
+	acc->pdata->negate_x = -acc->pdata->negate_x;
+	acc->pdata->negate_y = -acc->pdata->negate_y;
+
+	xyz[0] = ((acc->pdata->negate_x) ? (-hw_d[acc->pdata->axis_map_x])
+		  : (hw_d[acc->pdata->axis_map_x]));
+	xyz[1] = ((acc->pdata->negate_y) ? (-hw_d[acc->pdata->axis_map_y])
+		  : (hw_d[acc->pdata->axis_map_y]));
+	xyz[2] = ((acc->pdata->negate_z) ? (-hw_d[acc->pdata->axis_map_z])
+		  : (hw_d[acc->pdata->axis_map_z]));
+
+	pr_debug("%s read x=%d, y=%d, z=%d\n",
+	       LIS3DH_ACC_DEV_NAME, xyz[0], xyz[1], xyz[2]);
+
+	return err;
+}
+
+static void lis3dh_acc_report_values(struct lis3dh_acc_data *acc, int *xyz)
+{
+	input_report_abs(acc->input_dev, ABS_X, xyz[0]);
+	input_report_abs(acc->input_dev, ABS_Y, xyz[1]);
+	input_report_abs(acc->input_dev, ABS_Z, xyz[2]);
+	input_sync(acc->input_dev);
+}
+
+static int lis3dh_acc_enable(struct lis3dh_acc_data *acc)
+{
+	int err;
+	printk("sprd-gsensor: -- %s -- !\n",__func__);
+	if (!atomic_cmpxchg(&acc->enabled, 0, 1)) {
+		err = lis3dh_acc_device_power_on(acc);
+		if (err < 0) {
+			atomic_set(&acc->enabled, 0);
+			return err;
+		}
+
+		if (acc->hw_initialized) {
+			if (acc->irq1 != 0)
+				enable_irq(acc->irq1);
+			if (acc->irq2 != 0)
+				enable_irq(acc->irq2);
+			pr_debug("%s: power on: irq enabled\n",
+			       LIS3DH_ACC_DEV_NAME);
+		}
+
+		schedule_delayed_work(&acc->input_work,
+				      msecs_to_jiffies(acc->pdata->
+						       poll_interval));
+	}
+	printk("sprd-gsensor: -- %s -- success!\n",__func__);
+	return 0;
+}
+
+static int lis3dh_acc_disable(struct lis3dh_acc_data *acc)
+{
+	printk("sprd-gsensor: -- %s -- \n",__func__);
+	if (atomic_cmpxchg(&acc->enabled, 1, 0)) {
+		cancel_delayed_work_sync(&acc->input_work);
+		lis3dh_acc_device_power_off(acc);
+	}
+
+	return 0;
+}
+
+static int lis3dh_acc_misc_open(struct inode *inode, struct file *file)
+{
+	int err;
+	err = nonseekable_open(inode, file);
+	if (err < 0)
+		return err;
+
+	file->private_data = lis3dh_acc_misc_data;
+
+	return 0;
+}
+
+static long lis3dh_acc_misc_ioctl(struct file *file, unsigned int cmd,
+				unsigned long arg)
+{
+	void __user *argp = (void __user *)arg;
+	u8 buf[4];
+	u8 mask;
+	u8 reg_address;
+	u8 bit_values;
+	int err;
+	int interval;
+	int xyz[3] = { 0 };
+	struct lis3dh_acc_data *acc = file->private_data;
+
+	switch (cmd) {
+	case LIS3DH_ACC_IOCTL_GET_DELAY:
+		interval = acc->pdata->poll_interval;
+		if (copy_to_user(argp, &interval, sizeof(interval)))
+			return -EFAULT;
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_DELAY:
+		if (copy_from_user(&interval, argp, sizeof(interval)))
+			return -EFAULT;
+		if (interval < 0 || interval > 1000)
+			return -EINVAL;
+
+		acc->pdata->poll_interval = max(interval,
+						acc->pdata->min_interval);
+		err = lis3dh_acc_update_odr(acc, acc->pdata->poll_interval);
+		/* TODO: if update fails poll is still set */
+		if (err < 0)
+			return err;
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_ENABLE:
+		if (copy_from_user(&interval, argp, sizeof(interval)))
+			return -EFAULT;
+		if (interval > 1)
+			return -EINVAL;
+		if (interval)
+			err = lis3dh_acc_enable(acc);
+		else
+			err = lis3dh_acc_disable(acc);
+		return err;
+		break;
+
+	case LIS3DH_ACC_IOCTL_GET_ENABLE:
+		interval = atomic_read(&acc->enabled);
+		if (copy_to_user(argp, &interval, sizeof(interval)))
+			return -EINVAL;
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_G_RANGE:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		bit_values = buf[0];
+		err = lis3dh_acc_update_g_range(acc, bit_values);
+		if (err < 0)
+			return err;
+		break;
+
+#ifdef INTERRUPT_MANAGEMENT
+	case LIS3DH_ACC_IOCTL_SET_CTRL_REG3:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = CTRL_REG3;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_CTRL_REG3] = ((mask & bit_values) |
+						    (~mask & acc->
+						     resume_state
+						     [RES_CTRL_REG3]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_CTRL_REG6:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = CTRL_REG6;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_CTRL_REG6] = ((mask & bit_values) |
+						    (~mask & acc->
+						     resume_state
+						     [RES_CTRL_REG6]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_DURATION1:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		reg_address = INT_DUR1;
+		mask = 0x7F;
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_DUR1] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_DUR1]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_THRESHOLD1:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		reg_address = INT_THS1;
+		mask = 0x7F;
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_THS1] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_THS1]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_CONFIG1:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = INT_CFG1;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_CFG1] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_CFG1]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_GET_SOURCE1:
+		err = lis3dh_acc_register_read(acc, buf, INT_SRC1);
+		if (err < 0)
+			return err;
+
+		pr_debug("INT1_SRC content: %d , 0x%x\n", buf[0], buf[0]);
+
+		if (copy_to_user(argp, buf, 1))
+			return -EINVAL;
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_DURATION2:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		reg_address = INT_DUR2;
+		mask = 0x7F;
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_DUR2] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_DUR2]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_THRESHOLD2:
+		if (copy_from_user(buf, argp, 1))
+			return -EFAULT;
+		reg_address = INT_THS2;
+		mask = 0x7F;
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_THS2] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_THS2]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_CONFIG2:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = INT_CFG2;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_INT_CFG2] = ((mask & bit_values) |
+						   (~mask & acc->
+						    resume_state
+						    [RES_INT_CFG2]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_GET_SOURCE2:
+		err = lis3dh_acc_register_read(acc, buf, INT_SRC2);
+		if (err < 0)
+			return err;
+
+		pr_debug("INT2_SRC content: %d , 0x%x\n", buf[0], buf[0]);
+
+		if (copy_to_user(argp, buf, 1))
+			return -EINVAL;
+		break;
+
+	case LIS3DH_ACC_IOCTL_GET_TAP_SOURCE:
+		err = lis3dh_acc_register_read(acc, buf, TT_SRC);
+		if (err < 0)
+			return err;
+		pr_debug("TT_SRC content: %d , 0x%x\n", buf[0], buf[0]);
+
+		if (copy_to_user(argp, buf, 1)) {
+			pr_err("%s: %s error in copy_to_user \n",
+			       LIS3DH_ACC_DEV_NAME, __func__);
+			return -EINVAL;
+		}
+		break;
+	case LIS3DH_ACC_IOCTL_GET_COOR_XYZ:
+		err = lis3dh_acc_get_acceleration_data(acc, xyz);
+		if (err < 0)
+			return err;
+
+		if (copy_to_user(argp, xyz, sizeof(xyz))) {
+			pr_err(" %s %d error in copy_to_user \n",
+			       __func__, __LINE__);
+			return -EINVAL;
+		}
+		break;
+	case LIS3DH_ACC_IOCTL_SET_TAP_CFG:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_CFG;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_CFG] = ((mask & bit_values) |
+						 (~mask & acc->
+						  resume_state[RES_TT_CFG]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_TAP_TLIM:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_LIM;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_LIM] = ((mask & bit_values) |
+						 (~mask & acc->
+						  resume_state[RES_TT_LIM]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_TAP_THS:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_THS;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_THS] = ((mask & bit_values) |
+						 (~mask & acc->
+						  resume_state[RES_TT_THS]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_TAP_TLAT:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_TLAT;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_TLAT] = ((mask & bit_values) |
+						  (~mask & acc->
+						   resume_state[RES_TT_TLAT]));
+		break;
+
+	case LIS3DH_ACC_IOCTL_SET_TAP_TW:
+		if (copy_from_user(buf, argp, 2))
+			return -EFAULT;
+		reg_address = TT_TW;
+		mask = buf[1];
+		bit_values = buf[0];
+		err = lis3dh_acc_register_update(acc, (u8 *) arg, reg_address,
+						 mask, bit_values);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_TT_TW] = ((mask & bit_values) |
+						(~mask & acc->
+						 resume_state[RES_TT_TW]));
+		break;
+
+#endif /* INTERRUPT_MANAGEMENT */
+	case LIS3DH_ACC_IOCTL_GET_CHIP_ID:
+	    {
+	        u8 devid = 0;
+	        u8 devinfo[DEVICE_INFO_LEN] = {0};
+	        err = lis3dh_acc_register_read(acc, &devid, WHO_AM_I);
+	        if (err < 0) {
+	            printk("__func__, error read register WHO_AM_I\n", __func__);
+	            return -EAGAIN;
+	        }
+	        sprintf(devinfo, "%s, %#x", DEVICE_INFO, devid);
+
+	        if (copy_to_user(argp, devinfo, sizeof(devinfo))) {
+	            printk("%s error in copy_to_user(IOCTL_GET_CHIP_ID)\n", __func__);
+	            return -EINVAL;
+	        }
+	    }
+	   break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static const struct file_operations lis3dh_acc_misc_fops = {
+	.owner = THIS_MODULE,
+	.open = lis3dh_acc_misc_open,
+	.unlocked_ioctl = lis3dh_acc_misc_ioctl,
+};
+
+static struct miscdevice lis3dh_acc_misc_device = {
+	.minor = MISC_DYNAMIC_MINOR,
+	.name = LIS3DH_ACC_DEV_NAME,
+	.fops = &lis3dh_acc_misc_fops,
+};
+
+static void lis3dh_acc_input_work_func(struct work_struct *work)
+{
+	struct lis3dh_acc_data *acc;
+
+	int xyz[3] = { 0 };
+	int err;
+
+	acc = container_of((struct delayed_work *)work,
+			   struct lis3dh_acc_data, input_work);
+
+	mutex_lock(&acc->lock);
+	err = lis3dh_acc_get_acceleration_data(acc, xyz);
+	if (err < 0)
+		dev_err(&acc->client->dev, "get_acceleration_data failed\n");
+	else
+		lis3dh_acc_report_values(acc, xyz);
+
+	schedule_delayed_work(&acc->input_work,
+			      msecs_to_jiffies(acc->pdata->poll_interval));
+	mutex_unlock(&acc->lock);
+}
+
+#ifdef LIS3DH_OPEN_ENABLE
+int lis3dh_acc_input_open(struct input_dev *input)
+{
+	struct lis3dh_acc_data *acc = input_get_drvdata(input);
+
+	return lis3dh_acc_enable(acc);
+}
+
+void lis3dh_acc_input_close(struct input_dev *dev)
+{
+	struct lis3dh_acc_data *acc = input_get_drvdata(dev);
+
+	lis3dh_acc_disable(acc);
+}
+#endif
+
+static int lis3dh_acc_validate_pdata(struct lis3dh_acc_data *acc)
+{
+	acc->pdata->poll_interval = max(acc->pdata->poll_interval,
+					acc->pdata->min_interval);
+
+	if (acc->pdata->axis_map_x > 2 || acc->pdata->axis_map_y > 2
+	    || acc->pdata->axis_map_z > 2) {
+		dev_err(&acc->client->dev, "invalid axis_map value "
+			"x:%u y:%u z%u\n", acc->pdata->axis_map_x,
+			acc->pdata->axis_map_y, acc->pdata->axis_map_z);
+		return -EINVAL;
+	}
+
+	/* Only allow 0 and 1 for negation boolean flag */
+	if (acc->pdata->negate_x > 1 || acc->pdata->negate_y > 1
+	    || acc->pdata->negate_z > 1) {
+		dev_err(&acc->client->dev, "invalid negate value "
+			"x:%u y:%u z:%u\n", acc->pdata->negate_x,
+			acc->pdata->negate_y, acc->pdata->negate_z);
+		return -EINVAL;
+	}
+
+	/* Enforce minimum polling interval */
+	if (acc->pdata->poll_interval < acc->pdata->min_interval) {
+		dev_err(&acc->client->dev, "minimum poll interval violated\n");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int lis3dh_acc_input_init(struct lis3dh_acc_data *acc)
+{
+	int err;
+	/* Polling rx data when the interrupt is not used.*/
+	if (1 /*acc->irq1 == 0 && acc->irq1 == 0 */ ) {
+		INIT_DELAYED_WORK(&acc->input_work, lis3dh_acc_input_work_func);
+	}
+
+	acc->input_dev = input_allocate_device();
+	if (!acc->input_dev) {
+		err = -ENOMEM;
+		dev_err(&acc->client->dev, "input device allocate failed\n");
+		goto err0;
+	}
+#ifdef LIS3DH_ACC_OPEN_ENABLE
+	acc->input_dev->open = lis3dh_acc_input_open;
+	acc->input_dev->close = lis3dh_acc_input_close;
+#endif
+
+	input_set_drvdata(acc->input_dev, acc);
+
+	set_bit(EV_ABS, acc->input_dev->evbit);
+	/*      next is used for interruptA sources data if the case */
+	set_bit(ABS_MISC, acc->input_dev->absbit);
+	/*      next is used for interruptB sources data if the case */
+	set_bit(ABS_WHEEL, acc->input_dev->absbit);
+
+	input_set_abs_params(acc->input_dev, ABS_X, -G_MAX, G_MAX, 0, 0);
+	input_set_abs_params(acc->input_dev, ABS_Y, -G_MAX, G_MAX, 0, 0);
+	input_set_abs_params(acc->input_dev, ABS_Z, -G_MAX, G_MAX, 0, 0);
+	/*      next is used for interruptA sources data if the case */
+	input_set_abs_params(acc->input_dev, ABS_MISC, INT_MIN, INT_MAX, 0, 0);
+	/*      next is used for interruptB sources data if the case */
+	input_set_abs_params(acc->input_dev, ABS_WHEEL, INT_MIN, INT_MAX, 0, 0);
+
+	acc->input_dev->name = "accelerometer";
+
+	err = input_register_device(acc->input_dev);
+	if (err) {
+		dev_err(&acc->client->dev,
+			"unable to register input polled device %s\n",
+			acc->input_dev->name);
+		goto err1;
+	}
+
+	return 0;
+
+err1:
+	input_free_device(acc->input_dev);
+err0:
+	return err;
+}
+
+static void lis3dh_acc_input_cleanup(struct lis3dh_acc_data *acc)
+{
+	input_unregister_device(acc->input_dev);
+	input_free_device(acc->input_dev);
+}
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+static void lis3dh_early_suspend(struct early_suspend *es);
+static void lis3dh_early_resume(struct early_suspend *es);
+#endif
+
+#ifdef CONFIG_OF
+static struct lis3dh_acc_platform_data *lis3dh_acc_parse_dt(struct device *dev)
+{
+	struct lis3dh_acc_platform_data *pdata;
+	struct device_node *np = dev->of_node;
+	int ret;
+	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+	if (!pdata) {
+		dev_err(dev, "Could not allocate struct lis3dh_acc_platform_data");
+		return NULL;
+	}
+	ret = of_property_read_u32(np, "poll_interval", &pdata->poll_interval);
+	if(ret){
+		dev_err(dev, "fail to get poll_interval\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "min_interval", &pdata->min_interval);
+	if(ret){
+		dev_err(dev, "fail to get min_interval\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "g_range", &pdata->g_range);
+	if(ret){
+		dev_err(dev, "fail to get g_range\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "axis_map_x", &pdata->axis_map_x);
+	if(ret){
+		dev_err(dev, "fail to get axis_map_x\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "axis_map_y", &pdata->axis_map_y);
+	if(ret){
+		dev_err(dev, "fail to get axis_map_y\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "axis_map_z", &pdata->axis_map_z);
+	if(ret){
+		dev_err(dev, "fail to get axis_map_z\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "negate_x", &pdata->negate_x);
+	if(ret){
+		dev_err(dev, "fail to get negate_x\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "negate_y", &pdata->negate_y);
+	if(ret){
+		dev_err(dev, "fail to get negate_y\n");
+		goto fail;
+	}
+	ret = of_property_read_u32(np, "negate_z", &pdata->negate_z);
+	if(ret){
+		dev_err(dev, "fail to get negate_z\n");
+		goto fail;
+	}
+	return pdata;
+fail:
+	kfree(pdata);
+	return NULL;
+}
+#endif
+static int lis3dh_acc_probe(struct i2c_client *client,
+			    const struct i2c_device_id *id)
+{
+
+	struct lis3dh_acc_data *acc;
+	struct lis3dh_acc_platform_data *pdata = client->dev.platform_data;
+	int xyz[3] = { 0 };
+
+	int err = -1;
+	int tempvalue;
+	printk("sprd-gsensor: -- %s -- start !\n",__func__);
+	pr_debug("%s: probe start.\n", LIS3DH_ACC_DEV_NAME);
+
+#ifdef CONFIG_OF
+	struct device_node *np = client->dev.of_node;
+	if (np && !pdata){
+		pdata = lis3dh_acc_parse_dt(&client->dev);
+		if(pdata){
+			client->dev.platform_data = pdata;
+		}
+		if(!pdata){
+			err = -ENOMEM;
+			goto exit_alloc_platform_data_failed;
+		}
+	}
+#endif
+	/*
+	if (client->dev.platform_data == NULL) {
+		dev_err(&client->dev, "platform data is NULL. exiting.\n");
+		err = -ENODEV;
+		goto exit_check_functionality_failed;
+	}
+	*/
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+		dev_err(&client->dev, "client not i2c capable\n");
+		err = -ENODEV;
+		goto exit_check_functionality_failed;
+	}
+
+	if (!i2c_check_functionality(client->adapter,
+				     I2C_FUNC_SMBUS_BYTE |
+				     I2C_FUNC_SMBUS_BYTE_DATA |
+				     I2C_FUNC_SMBUS_WORD_DATA)) {
+		dev_err(&client->dev, "client not smb-i2c capable:2\n");
+		err = -EIO;
+		goto exit_check_functionality_failed;
+	}
+
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
+		dev_err(&client->dev, "client not smb-i2c capable:3\n");
+		err = -EIO;
+		goto exit_check_functionality_failed;
+	}
+	/*
+	 * OK. From now, we presume we have a valid client. We now create the
+	 * client structure, even though we cannot fill it completely yet.
+	 */
+
+	acc = kzalloc(sizeof(struct lis3dh_acc_data), GFP_KERNEL);
+	if (acc == NULL) {
+		err = -ENOMEM;
+		dev_err(&client->dev,
+			"failed to allocate memory for module data: "
+			"%d\n", err);
+		goto exit_alloc_data_failed;
+	}
+
+	mutex_init(&acc->lock);
+	mutex_lock(&acc->lock);
+
+	acc->client = client;
+	lis3dh_i2c_client = client;
+	i2c_set_clientdata(client, acc);
+
+	pr_debug("%s: %s has set irq1 to irq: %d\n",
+	       LIS3DH_ACC_DEV_NAME, __func__, acc->irq1);
+	pr_debug("%s: %s has set irq2 to irq: %d\n",
+	       LIS3DH_ACC_DEV_NAME, __func__, acc->irq2);
+
+	gpio_request(GSENSOR_GINT1_GPI, "GSENSOR_INT1");
+	gpio_request(GSENSOR_GINT2_GPI, "GSENSOR_INT2");
+	acc->irq1 = 0; /* gpio_to_irq(GSENSOR_GINT1_GPI); */
+	acc->irq2 = 0; /* gpio_to_irq(GSENSOR_GINT2_GPI); */
+
+	if (acc->irq1 != 0) {
+		pr_debug("%s request irq1\n", __func__);
+		err =
+		    request_irq(acc->irq1, lis3dh_acc_isr1, IRQF_TRIGGER_RISING,
+				"lis3dh_acc_irq1", acc);
+		if (err < 0) {
+			dev_err(&client->dev, "request irq1 failed: %d\n", err);
+			goto err_mutexunlockfreedata;
+		}
+		disable_irq_nosync(acc->irq1);
+
+		INIT_WORK(&acc->irq1_work, lis3dh_acc_irq1_work_func);
+		acc->irq1_work_queue =
+		    create_singlethread_workqueue("lis3dh_acc_wq1");
+		if (!acc->irq1_work_queue) {
+			err = -ENOMEM;
+			dev_err(&client->dev, "cannot create work queue1: %d\n",
+				err);
+			goto err_free_irq1;
+		}
+	}
+
+	if (acc->irq2 != 0) {
+		err =
+		    request_irq(acc->irq2, lis3dh_acc_isr2, IRQF_TRIGGER_RISING,
+				"lis3dh_acc_irq2", acc);
+		if (err < 0) {
+			dev_err(&client->dev, "request irq2 failed: %d\n", err);
+			goto err_destoyworkqueue1;
+		}
+		disable_irq_nosync(acc->irq2);
+
+/*		 Create workqueue for IRQ.*/
+
+		INIT_WORK(&acc->irq2_work, lis3dh_acc_irq2_work_func);
+		acc->irq2_work_queue =
+		    create_singlethread_workqueue("lis3dh_acc_wq2");
+		if (!acc->irq2_work_queue) {
+			err = -ENOMEM;
+			dev_err(&client->dev, "cannot create work queue2: %d\n",
+				err);
+			goto err_free_irq2;
+		}
+	}
+
+	acc->pdata = kmalloc(sizeof(*acc->pdata), GFP_KERNEL);
+	if (acc->pdata == NULL) {
+		err = -ENOMEM;
+		dev_err(&client->dev,
+			"failed to allocate memory for pdata: %d\n", err);
+		goto err_destoyworkqueue2;
+	}
+
+	memcpy(acc->pdata, client->dev.platform_data, sizeof(*acc->pdata));
+
+	err = lis3dh_acc_validate_pdata(acc);
+	if (err < 0) {
+		dev_err(&client->dev, "failed to validate platform data\n");
+		goto exit_kfree_pdata;
+	}
+
+	err = lis3dh_acc_device_power_on(acc);
+	if (err < 0) {
+		dev_err(&client->dev, "power on failed: %d\n", err);
+		goto err2;
+	}
+
+#if 1
+	if (i2c_smbus_read_byte(client) < 0) {
+		pr_err("i2c_smbus_read_byte error!!\n");
+		goto err_destoyworkqueue2;
+	} else {
+		pr_debug("%s Device detected!\n", LIS3DH_ACC_DEV_NAME);
+	}
+#endif
+	/* read chip id */
+
+	tempvalue = i2c_smbus_read_word_data(client, WHO_AM_I);
+
+	if ((tempvalue & 0x00FF) == WHOAMI_LIS3DH_ACC) {
+		pr_debug("%s I2C driver registered!\n",
+		       LIS3DH_ACC_DEV_NAME);
+	} else {
+		acc->client = NULL;
+		pr_debug("I2C driver not registered!"
+		       " Device unknown 0x%x\n", tempvalue);
+		goto err_destoyworkqueue2;
+	}
+	
+	i2c_set_clientdata(client, acc);
+
+	if (acc->pdata->init) {
+		err = acc->pdata->init();
+		if (err < 0) {
+			dev_err(&client->dev, "init failed: %d\n", err);
+			goto err2;
+		}
+	}
+
+	memset(acc->resume_state, 0, ARRAY_SIZE(acc->resume_state));
+
+	acc->resume_state[RES_CTRL_REG1] = LIS3DH_ACC_ENABLE_ALL_AXES;
+	acc->resume_state[RES_CTRL_REG2] = 0x00;
+	acc->resume_state[RES_CTRL_REG3] = 0x00;
+	acc->resume_state[RES_CTRL_REG4] = 0x00;
+	acc->resume_state[RES_CTRL_REG5] = 0x00;
+	acc->resume_state[RES_CTRL_REG6] = 0x00;
+
+	acc->resume_state[RES_TEMP_CFG_REG] = 0x00;
+	acc->resume_state[RES_FIFO_CTRL_REG] = 0x00;
+	acc->resume_state[RES_INT_CFG1] = 0x00;
+	acc->resume_state[RES_INT_THS1] = 0x00;
+	acc->resume_state[RES_INT_DUR1] = 0x00;
+	acc->resume_state[RES_INT_CFG2] = 0x00;
+	acc->resume_state[RES_INT_THS2] = 0x00;
+	acc->resume_state[RES_INT_DUR2] = 0x00;
+
+	acc->resume_state[RES_TT_CFG] = 0x00;
+	acc->resume_state[RES_TT_THS] = 0x00;
+	acc->resume_state[RES_TT_LIM] = 0x00;
+	acc->resume_state[RES_TT_TLAT] = 0x00;
+	acc->resume_state[RES_TT_TW] = 0x00;
+
+
+	atomic_set(&acc->enabled, 1);
+
+	err = lis3dh_acc_update_g_range(acc, acc->pdata->g_range);
+	if (err < 0) {
+		dev_err(&client->dev, "update_g_range failed\n");
+		goto err_power_off;
+	}
+
+	err = lis3dh_acc_update_odr(acc, acc->pdata->poll_interval);
+	if (err < 0) {
+		dev_err(&client->dev, "update_odr failed\n");
+		goto err_power_off;
+	}
+
+	err = lis3dh_acc_input_init(acc);
+	if (err < 0) {
+		dev_err(&client->dev, "input init failed\n");
+		goto err_power_off;
+	}
+	lis3dh_acc_misc_data = acc;
+
+	err = misc_register(&lis3dh_acc_misc_device);
+	if (err < 0) {
+		dev_err(&client->dev,
+			"misc LIS3DH_ACC_DEV_NAME register failed\n");
+		goto err_input_cleanup;
+	}
+
+	lis3dh_acc_device_power_off(acc);
+
+	/* As default, do not report information */
+	atomic_set(&acc->enabled, 0);
+/*
+#ifdef CONFIG_HAS_EARLYSUSPEND
+	acc->early_suspend.suspend = lis3dh_early_suspend;
+	acc->early_suspend.resume = lis3dh_early_resume;
+	acc->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
+	register_early_suspend(&acc->early_suspend);
+#endif
+*/
+	mutex_unlock(&acc->lock);
+	dev_info(&client->dev, "###%s###\n", __func__);
+	printk("sprd-gsensor: -- %s -- success !\n",__func__);
+
+	
+	err = lis3dh_acc_get_acceleration_data(acc, xyz);
+
+	
+	return 0;
+
+err_input_cleanup:
+	lis3dh_acc_input_cleanup(acc);
+err_power_off:
+	lis3dh_acc_device_power_off(acc);
+err2:
+	if (acc->pdata->exit)
+		acc->pdata->exit();
+exit_kfree_pdata:
+	kfree(acc->pdata);
+err_destoyworkqueue2:
+	if (acc->irq2_work_queue)
+		destroy_workqueue(acc->irq2_work_queue);
+err_free_irq2:
+	if (acc->irq2) {
+		free_irq(acc->irq2, acc);
+		gpio_free(GSENSOR_GINT2_GPI);
+	}
+err_destoyworkqueue1:
+	if (acc->irq1_work_queue)
+		destroy_workqueue(acc->irq1_work_queue);
+err_free_irq1:
+	if (acc->irq1) {
+		free_irq(acc->irq1, acc);
+		gpio_free(GSENSOR_GINT1_GPI);
+	}
+err_mutexunlockfreedata:
+	i2c_set_clientdata(client, NULL);
+	mutex_unlock(&acc->lock);
+	kfree(acc);
+	lis3dh_acc_misc_data = NULL;
+exit_alloc_data_failed:
+exit_check_functionality_failed:
+	pr_err("%s: Driver Init failed\n", LIS3DH_ACC_DEV_NAME);
+exit_alloc_platform_data_failed:
+	return err;
+}
+
+static int  lis3dh_acc_remove(struct i2c_client *client)
+{
+	/* TODO: revisit ordering here once _probe order is finalized */
+	struct lis3dh_acc_data *acc = i2c_get_clientdata(client);
+	if (acc != NULL) {
+		if (acc->irq1) {
+			free_irq(acc->irq1, acc);
+			gpio_free(GSENSOR_GINT1_GPI);
+		}
+		if (acc->irq2) {
+			free_irq(acc->irq2, acc);
+			gpio_free(GSENSOR_GINT2_GPI);
+		}
+
+		if (acc->irq1_work_queue)
+			destroy_workqueue(acc->irq1_work_queue);
+		if (acc->irq2_work_queue)
+			destroy_workqueue(acc->irq2_work_queue);
+		misc_deregister(&lis3dh_acc_misc_device);
+		lis3dh_acc_input_cleanup(acc);
+		lis3dh_acc_device_power_off(acc);
+		if (acc->pdata->exit)
+			acc->pdata->exit();
+		kfree(acc->pdata);
+		kfree(acc);
+	}
+
+	return 0;
+}
+
+static int lis3dh_acc_resume(struct i2c_client *client)
+{
+	struct lis3dh_acc_data *acc = i2c_get_clientdata(client);
+	printk("sprd-gsensor: -- %s -- !\n",__func__);
+	dev_dbg(&client->dev, "###%s###\n", __func__);
+
+	if (acc != NULL && acc->on_before_suspend)
+		return lis3dh_acc_enable(acc);
+
+	return 0;
+}
+
+static int lis3dh_acc_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+	struct lis3dh_acc_data *acc = i2c_get_clientdata(client);
+	printk("sprd-gsensor: -- %s -- !\n",__func__);
+	dev_dbg(&client->dev, "###%s###\n", __func__);
+
+	if (acc != NULL) {
+		acc->on_before_suspend = atomic_read(&acc->enabled);
+		return lis3dh_acc_disable(acc);
+	}
+	return 0;
+}
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+
+static void lis3dh_early_suspend(struct early_suspend *es)
+{
+	lis3dh_acc_suspend(lis3dh_i2c_client, (pm_message_t) {
+			   .event = 0});
+}
+
+static void lis3dh_early_resume(struct early_suspend *es)
+{
+	lis3dh_acc_resume(lis3dh_i2c_client);
+}
+
+#endif /* CONFIG_HAS_EARLYSUSPEND */
+
+static const struct i2c_device_id lis3dh_acc_id[]
+= { {LIS3DH_ACC_DEV_NAME, 0}, {}, };
+
+MODULE_DEVICE_TABLE(i2c, lis3dh_acc_id);
+
+static const struct of_device_id lis3dh_acc_of_match[] = {
+       { .compatible = "ST,lis3dh_acc", },
+       { }
+};
+MODULE_DEVICE_TABLE(of, lis3dh_acc_of_match);
+static struct i2c_driver lis3dh_acc_driver = {
+	.driver = {
+		   .name = LIS3DH_ACC_I2C_NAME,
+		   .of_match_table = lis3dh_acc_of_match,
+		   },
+	.probe = lis3dh_acc_probe,
+	.remove = lis3dh_acc_remove,
+	.resume = lis3dh_acc_resume,
+	.suspend = lis3dh_acc_suspend,
+	.id_table = lis3dh_acc_id,
+};
+
+
+static int __init lis3dh_acc_init(void)
+{
+	pr_debug("%s accelerometer driver: init\n", LIS3DH_ACC_I2C_NAME);
+
+	return i2c_add_driver(&lis3dh_acc_driver);
+}
+
+static void __exit lis3dh_acc_exit(void)
+{
+	pr_debug("%s accelerometer driver exit\n", LIS3DH_ACC_DEV_NAME);
+
+	i2c_del_driver(&lis3dh_acc_driver);
+	return;
+}
+
+module_init(lis3dh_acc_init);
+module_exit(lis3dh_acc_exit);
+
+MODULE_DESCRIPTION("lis3dh accelerometer misc driver");
+MODULE_AUTHOR("STMicroelectronics");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/ltr_558als.c b/drivers/input/misc/ltr_558als.c
new file mode 100644
index 00000000..0251cdb9
--- /dev/null
+++ b/drivers/input/misc/ltr_558als.c
@@ -0,0 +1,1236 @@
+/*
+ * File:ltr_558als.c
+ * Author:Yaochuan Li <yaochuan.li@spreadtrum.com>
+ * Created:2013-03-18
+ * Description:LTR-558ALS Driver
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/jiffies.h>
+#include <linux/i2c.h>
+#include <linux/i2c-dev.h>
+#include <linux/miscdevice.h>
+#include <linux/mutex.h>
+#include <linux/mm.h>
+#include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/sysctl.h>
+#include <linux/input.h>
+#include <linux/gpio.h>
+#include <linux/irq.h>
+#include <linux/earlysuspend.h>
+#include <linux/platform_device.h>
+#include <asm/uaccess.h>
+#include <linux/wakelock.h>
+#include <linux/i2c/ltr_558als.h>
+#include <linux/slab.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+
+#define LTR588_DBG
+#define LTR558_ADAPTIVE
+#ifdef LTR588_DBG
+#define ENTER printk(KERN_INFO "[LTR588_DBG] func: %s  line: %04d  ", __func__, __LINE__)
+#define PRINT_DBG(x...)  printk(KERN_INFO "[LTR588_DBG] " x)
+#define PRINT_INFO(x...)  printk(KERN_INFO "[LTR588_INFO] " x)
+#define PRINT_WARN(x...)  printk(KERN_INFO "[LTR588_WARN] " x)
+#define PRINT_ERR(format,x...)  printk(KERN_ERR "[LTR588_ERR] func: %s  line: %04d  info: " format, __func__, __LINE__, ## x)
+#else
+#define ENTER
+#define PRINT_DBG(x...)
+#define PRINT_INFO(x...)  printk(KERN_INFO "[LTR588_INFO] " x)
+#define PRINT_WARN(x...)  printk(KERN_INFO "[LTR588_WARN] " x)
+#define PRINT_ERR(format,x...)  printk(KERN_ERR "[LTR588_ERR] func: %s  line: %04d  info: " format, __func__, __LINE__, ## x)
+#endif
+
+typedef struct tag_ltr558 {
+        struct input_dev *input;
+        struct i2c_client *client;
+        struct work_struct work;
+        struct workqueue_struct *ltr_work_queue;
+#ifdef CONFIG_HAS_EARLYSUSPEND
+        struct early_suspend ltr_early_suspend;
+#endif
+} ltr558_t, *ltr558_p;
+
+static int ps_threshold = 0;
+static int ps_threshold_high = 600;
+static int ps_threshold_low = 500;
+static int dyna_cali = 2047;
+
+static int p_flag = 0;
+static int l_flag = 0;
+static u8 p_gainrange = PS_RANGE4;
+static u8 l_gainrange = ALS_RANGE1_320;
+//static int ps_threshold = 0;
+static struct i2c_client *this_client = NULL;
+static int LTR_PLS_MODE = 0;
+
+#ifdef LTR558_ADAPTIVE
+#define DEBOUNCE 10
+#define MIN_SPACING 120
+#define DIVEDE 10
+static int ps_max_filter[5] = {0};
+static int ps_min_filter[5] = {0};
+static int max_index = 0;
+static int min_index = 0;
+static int ps_min = 0;
+static int ps_max = 0;
+#endif
+
+static int ltr558_reg_init(void);
+
+static int ltr558_i2c_read_bytes(u8 index, u8 *rx_buff, u8 length)
+{
+        int ret = -1;
+        struct i2c_msg msgs[] = {
+                {
+                        .addr = this_client->addr,//chip address, 7bit
+                        .flags = 0,//write
+                        .len = 1,
+                        .buf = &index,
+                },
+                {
+                        .addr = this_client->addr,
+                        .flags = I2C_M_RD,//read
+                        .len = length,
+                        .buf = rx_buff,
+                },
+        };
+
+        ret = i2c_transfer(this_client->adapter, msgs, 2);
+        if(ret != 2) {
+                PRINT_ERR("READ ERROR!ret=%d\n", ret);
+        }
+        return ret;
+}
+
+static int ltr558_i2c_write_bytes(u8 *tx_buff, u8 length)
+{
+        int ret = -1;
+        struct i2c_msg msgs[1];
+
+        msgs[0].addr = this_client->addr;
+        msgs[0].flags = 0;
+        msgs[0].len = length;
+        msgs[0].buf = tx_buff;
+
+        ret = i2c_transfer(this_client->adapter, msgs, 1);
+        if(ret != 1) {
+                PRINT_ERR("WRITE ERROR!ret=%d\n", ret);
+        }
+        return ret;
+}
+
+static int ltr558_i2c_read_2_bytes(u8 reg)
+{
+        int ret = 0;
+        u8 data[2] = {0};
+
+        ret = ltr558_i2c_read_bytes(reg, data, 2);
+        if(ret != 2) {
+                PRINT_ERR("READ ERROR!ret=%d\n", ret);
+                return -1;
+        }
+
+        ret = data[1];
+        ret = ( ret<<8) |data[0];
+
+        return ret;
+}
+
+static int ltr558_i2c_read_1_byte(u8 reg)
+{
+        int ret = 0;
+        u8 data[1] = {0};
+
+        ret = ltr558_i2c_read_bytes(reg, data, 1);
+        if(ret != 2) {
+                PRINT_ERR("READ ERROR!ret=%d\n", ret);
+                return -1;
+        }
+
+        ret = data[0];
+        return ret;
+}
+
+static int ltr558_i2c_write_2_bytes(u8 reg, u16 value)
+{
+        int ret = 0;
+        u8 data[3] = {0};
+
+        data[0] = reg;
+        data[1] = value & 0x00FF;
+        data[2] = value >> 8;
+
+        ret = ltr558_i2c_write_bytes(data, 3);
+        if(ret != 1) {
+                PRINT_ERR("WRITE ERROR!ret=%d\n", ret);
+                return -1;
+        }
+        return 1;
+}
+
+static int ltr558_i2c_write_1_byte(u8 reg, u8 value)
+{
+        int ret = 0;
+        u8 data[2] = {0};
+
+        data[0] = reg;
+        data[1] = value;
+
+        ret = ltr558_i2c_write_bytes(data, 2);
+        if(ret != 1) {
+                PRINT_ERR("WRITE ERROR!ret=%d\n", ret);
+                return -1;
+        }
+        return 1;
+}
+
+static int ltr_read_chip_info(struct i2c_client *client, char *buf)
+{
+        if(NULL == buf) {
+                return -1;
+        }
+        if(NULL == client) {
+                *buf = 0;
+                return -2;
+        }
+
+        if( LTR_PLS_553 == LTR_PLS_MODE)
+        {
+                sprintf(buf, "LTR558ALS");
+                printk("[LTR553] ltr_read_chip_info LTR553ALS\n");
+        }
+        if(LTR_PLS_558 == LTR_PLS_MODE)
+        {
+                sprintf(buf, "LTR558ALS");
+                printk("[LTR558] ltr_read_chip_info LTR558ALS\n");
+        }
+        return 0;
+}
+
+static int dynamic_cali(void)
+{
+	int i=0;
+	int j=0;
+	int val=0;
+	int data_total=0;
+	int noise=0;
+
+	for (i = 0; i < 3; i++)
+		{
+			msleep(10);
+			val = ltr558_i2c_read_2_bytes(LTR558_PS_DATA_0);
+			data_total += val;
+		}
+	noise = data_total/3;
+
+	if(noise < (dyna_cali + 500))
+		{
+			if(noise < 1500)
+				{
+				ps_threshold_high = noise + 250;
+				ps_threshold_low = noise + 220;
+				}else{
+				ps_threshold_high = 1800;
+				ps_threshold_low = 1600;
+				}
+		}
+        PRINT_INFO("ltr558_ps_enable, ps_threshold_high=%d, ps_threshold_low=%d\n", ps_threshold_high, ps_threshold_low);
+}
+
+static int ltr558_ps_enable(u8 gainrange)
+{
+        int ret = -1;
+        u8 setgain;
+        ltr558_t *ltr_558als = (ltr558_t *)i2c_get_clientdata(this_client);
+
+        if(LTR_PLS_553 == LTR_PLS_MODE)
+        {
+            switch (gainrange)
+            {
+                case PS_553_RANGE16:
+                    setgain = MODE_PS_553_ON_Gain16;
+                    break;
+                case PS_553_RANGE32:
+                    setgain = MODE_PS_553_ON_Gain32;
+                    break;
+                case PS_553_RANGE64:
+                    setgain = MODE_PS_553_ON_Gain64;
+                    break;
+                default:
+                    setgain = MODE_PS_553_ON_Gain16;
+                    break;
+            }
+        }
+        else
+        {
+            switch (gainrange) {
+                case PS_558_RANGE1:
+                    setgain = MODE_PS_558_ON_Gain1;
+                    break;
+                case PS_558_RANGE2:
+                    setgain = MODE_PS_558_ON_Gain4;
+                    break;
+                case PS_558_RANGE4:
+                    setgain = MODE_PS_558_ON_Gain8;
+                    break;
+                case PS_558_RANGE8:
+                    setgain = MODE_PS_558_ON_Gain16;
+                    break;
+                default:
+                    setgain = MODE_PS_558_ON_Gain8;
+                    break;
+              }
+        }
+
+        ret = ltr558_i2c_write_1_byte(LTR558_PS_CONTR, setgain);
+        mdelay(WAKEUP_DELAY);
+
+        if(setgain != ltr558_i2c_read_1_byte(LTR558_PS_CONTR))
+        {
+            ret = ltr558_i2c_write_1_byte(LTR558_PS_CONTR, setgain);
+            mdelay(WAKEUP_DELAY);
+        }
+
+        /*input report init*/
+        input_report_abs(ltr_558als->input, ABS_DISTANCE, 1);
+        input_sync(ltr_558als->input);
+
+        dynamic_cali();
+
+        PRINT_INFO("ltr558_ps_enable, gainrange=%d, ret=%d\n", gainrange, ret);
+        if(ret >= 0)
+                return 0;
+        else
+                return ret;
+}
+
+static int ltr558_ps_disable(void)
+{
+        int ret = -1;
+        ltr558_t *ltr_558als = (ltr558_t *)i2c_get_clientdata(this_client);
+        ret = ltr558_i2c_write_1_byte(LTR558_PS_CONTR, MODE_PS_STANDBY);
+
+        /*input report init*/
+        input_report_abs(ltr_558als->input, ABS_DISTANCE, 1);
+        input_sync(ltr_558als->input);
+
+        PRINT_INFO("ltr558_ps_disable, ret=%d\n", ret);
+        if(ret >= 0)
+                return 0;
+        else
+                return ret;
+}
+
+static int ltr558_als_enable(u8 gainrange)
+{
+        int ret = -1;
+        u8 setgain;
+
+        if(LTR_PLS_553 == LTR_PLS_MODE)
+        {
+            switch (gainrange)
+            {
+                case ALS_553_RANGE1_64K:
+                    setgain = MODE_ALS_553_ON_Range1;
+                    break;
+
+                case ALS_553_RANGE2_32K:
+                    setgain = MODE_ALS_553_ON_Range2;
+                    break;
+
+                case ALS_553_RANGE4_16K:
+                    setgain = MODE_ALS_553_ON_Range4;
+                    break;
+
+                case ALS_553_RANGE8_8K:
+                    setgain = MODE_ALS_553_ON_Range8;
+                    break;
+
+                case ALS_553_RANGE48_1K3:
+                    setgain = MODE_ALS_553_ON_Range48;
+                    break;
+
+                case ALS_553_RANGE96_600:
+                    setgain = MODE_ALS_553_ON_Range96;
+                    break;
+
+                default:
+                    setgain = MODE_ALS_553_ON_Range1;
+                    break;
+            }
+        }
+        else
+        {
+            switch (gainrange)
+            {
+                case  ALS_558_RANGE1_320:
+                    setgain = MODE_ALS_558_ON_Range1;
+                    break;
+
+                case ALS_558_RANGE2_64K:
+                    setgain = MODE_ALS_558_ON_Range2;
+                    break;
+
+                default:
+                    setgain = MODE_ALS_558_ON_Range1;
+                    break;
+            }
+        }
+
+        ret = ltr558_i2c_write_1_byte(LTR558_ALS_CONTR, setgain);
+        mdelay(WAKEUP_DELAY);
+
+        if(setgain != ltr558_i2c_read_1_byte(LTR558_ALS_CONTR))
+        {
+            ret = ltr558_i2c_write_1_byte(LTR558_ALS_CONTR, setgain);
+            mdelay(WAKEUP_DELAY);
+        }
+
+        ltr558_i2c_read_1_byte(LTR558_ALS_PS_STATUS);
+        ltr558_i2c_read_2_bytes(LTR558_PS_DATA_0);
+        ltr558_i2c_read_2_bytes(LTR558_ALS_DATA_CH1);
+        ltr558_i2c_read_2_bytes(LTR558_ALS_DATA_CH0);
+
+        PRINT_INFO("ltr558_als_enable, gainrange=%d, ret = %d\n", gainrange, ret);
+        if(ret >= 0)
+                return 0;
+        else
+                return ret;
+}
+
+// Put ALS into Standby mode
+static int ltr558_als_disable(void)
+{
+        int ret = -1;
+        ret = ltr558_i2c_write_1_byte(LTR558_ALS_CONTR, MODE_ALS_STANDBY);
+        PRINT_INFO("ltr558_als_disable, ret = %d \n", ret);
+        if(ret >= 0)
+                return 0;
+        else
+                return ret;
+}
+
+static int ltr558_als_read(int gainrange)
+{
+        int luxdata_int;
+        int luxdata_flt, ratio;
+        int ch0, ch1;
+
+        /*IMPORTANT!CH1 MUST BE READ FIRST!*/
+        ch1 = ltr558_i2c_read_2_bytes(LTR558_ALS_DATA_CH1);
+        ch0 = ltr558_i2c_read_2_bytes(LTR558_ALS_DATA_CH0);
+
+        PRINT_DBG("ch0=%d,  ch1=%d\n", ch0, ch1);
+        if (0 == ch0)
+                ratio = 100;
+        else
+                ratio = (ch1 * 100) / ch0;
+
+        // Compute Lux data from ALS data (ch0 and ch1)
+        // For Ratio < 0.69:
+        // 1.3618*CH0 – 1.5*CH1
+        // For 0.69 <= Ratio < 1:
+        // 0.57*CH0 – 0.345*CH1
+        // For high gain, divide the calculated lux by 150.
+        if (ratio < 69) {
+                luxdata_flt = (13618 * ch0) - (15000 * ch1);
+                luxdata_flt = luxdata_flt / 10000;
+        } else if ((ratio >= 69) && (ratio < 100)) {
+                luxdata_flt = (5700 * ch0) - (3450 * ch1);
+                luxdata_flt = luxdata_flt / 10000;
+        } else {
+                luxdata_flt = 0;
+        }
+
+        // For Range1
+        //if (gainrange == ALS_RANGE1_320)
+        //      luxdata_flt = luxdata_flt / 150;
+
+        luxdata_int = luxdata_flt / 80;
+        return luxdata_int;
+}
+
+static int ltr558_open(struct inode *inode, struct file *file)
+{
+        PRINT_INFO("ltr558_open\n");
+        return 0;
+}
+
+static int ltr558_release(struct inode *inode, struct file *file)
+{
+        PRINT_INFO("ltr558_release\n");
+        return 0;
+}
+
+static long ltr558_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        void __user *argp = (void __user *)arg;
+        int flag, err;
+        char strbuf[256];
+        PRINT_INFO("cmd = %d, %d\n", _IOC_NR(cmd), cmd);
+        switch (cmd) {
+        case LTR_IOCTL_SET_PFLAG: {
+                if (copy_from_user(&flag, argp, sizeof(flag)))
+                        return -EFAULT;
+                PRINT_INFO("LTR_IOCTL_SET_PFLAG = %d\n", flag);
+                if (1 == flag) {
+			ltr558_reg_init();
+			msleep(20);
+                        if (ltr558_ps_enable(p_gainrange))
+                                return -EIO;
+                } else if (0 == flag) {
+                        if (ltr558_ps_disable())
+                                return -EIO;
+                } else {
+                        return -EINVAL;
+                }
+                p_flag = flag;
+        }
+        break;
+        case LTR_IOCTL_SET_LFLAG: {
+                if (copy_from_user(&flag, argp, sizeof(flag)))
+                        return -EFAULT;
+                PRINT_INFO("LTR_IOCTL_SET_LFLAG = %d\n", flag);
+                if (1 == flag) {
+                        ltr558_reg_init();
+                        msleep(20);
+                        if (ltr558_als_enable(l_gainrange))
+                                return -EIO;
+                } else if (0 == flag) {
+                        if (ltr558_als_disable())
+                                return -EIO;
+                } else {
+                        return -EINVAL;
+                }
+                l_flag = flag;
+        }
+        break;
+        case LTR_IOCTL_GET_CHIPINFO: {
+                err = ltr_read_chip_info(this_client, strbuf);
+                if(err < 0)
+                        return -EFAULT;
+                if(copy_to_user(argp, strbuf, strlen(strbuf)+1))
+                        return -EFAULT;
+        }
+        break;
+        case LTR_IOCTL_GET_PFLAG: {
+                flag = p_flag;
+                PRINT_INFO("LTR_IOCTL_GET_PFLAG = %d\n", flag);
+                if (copy_to_user(argp, &flag, sizeof(flag)))
+                        return -EFAULT;
+        }
+        break;
+        case LTR_IOCTL_GET_LFLAG: {
+                flag = l_flag;
+                PRINT_INFO("LTR_IOCTL_GET_LFLAG = %d\n", flag);
+                if (copy_to_user(argp, &flag, sizeof(flag)))
+                        return -EFAULT;
+        }
+        break;
+        default:
+                PRINT_ERR("unknown command: 0x%08X  (%d)\n", cmd, cmd);
+                break;
+        }
+        return 0;
+}
+
+static struct file_operations ltr558_fops = {
+        .owner = THIS_MODULE,
+        .open = ltr558_open,
+        .release = ltr558_release,
+        .unlocked_ioctl = ltr558_ioctl,
+};
+
+static struct miscdevice ltr558_device = {
+        .minor = MISC_DYNAMIC_MINOR,
+        .name = LTR558_I2C_NAME,
+        .fops = &ltr558_fops,
+};
+
+static int get_min_value(int* array, int size)
+{
+        int ret = 0;
+        int i = 0;
+        ret =  array[0];
+        for(i=1; i<size; i++) {
+                if(ret > array[i])
+                        ret = array[i];
+        }
+        return ret;
+}
+
+static int get_max_value(int* array, int size)
+{
+        int ret = 0;
+        int i = 0;
+        ret =  array[0];
+        for(i=1; i<size; i++) {
+                if(ret < array[i])
+                        ret = array[i];
+        }
+        return ret;
+}
+
+static void ltr558_work(struct work_struct *work)
+{
+        int status = 0;
+        int value = 0;
+        ltr558_t *pls = container_of(work, ltr558_t, work);
+
+        status = ltr558_i2c_read_1_byte(LTR558_ALS_PS_STATUS);
+        PRINT_DBG("LTR558_ALS_PS_STATUS = 0x%02X\n", status);
+
+        if ((0x03 == (status & 0x03)) && (LTR_PLS_MODE == LTR_PLS_558)) {/*is 558 PS*/
+                value = ltr558_i2c_read_2_bytes(LTR558_PS_DATA_0);
+                PRINT_DBG("LTR_PLS_MODE is pls 558, LTR558_PS_DATA_0 = %d\n", value);
+                if (value >= ps_threshold_high) {     // 3cm //high
+                        /*ltr558_i2c_write_1_byte(LTR558_PS_THRES_UP_0, 0xff);
+                        ltr558_i2c_write_1_byte(LTR558_PS_THRES_UP_1, 0x07);
+                        ltr558_i2c_write_1_byte(LTR558_PS_THRES_LOW_0, 0xDC);
+                        ltr558_i2c_write_1_byte(LTR558_PS_THRES_LOW_1, 0x05);
+                        */
+
+			ltr558_i2c_write_2_bytes(LTR558_PS_THRES_UP, 0x07FF);
+                        ltr558_i2c_write_2_bytes(LTR558_PS_THRES_LOW, ps_threshold_low);
+
+                        input_report_abs(pls->input, ABS_DISTANCE, 0);
+                        input_sync(pls->input);
+                } else if (value <= ps_threshold_low) {      // 5cm //low
+                        /*ltr558_i2c_write_1_byte(LTR558_PS_THRES_UP_0, 0x0E);
+                        ltr558_i2c_write_1_byte(LTR558_PS_THRES_UP_1, 0x06);
+                        ltr558_i2c_write_1_byte(LTR558_PS_THRES_LOW_0, 0x00);
+                        ltr558_i2c_write_1_byte(LTR558_PS_THRES_LOW_1, 0x00);
+                        */
+
+                        if(dyna_cali > 20 && value <(dyna_cali - 100))
+                        {
+                                if(value < 1500)
+                                {
+                                    ps_threshold_high = value + 250;
+                                    ps_threshold_low = value + 220;
+                                }else{
+                                    ps_threshold_high = 1800;
+                                    ps_threshold_low = 1600;
+                                }
+                        }
+
+                        ltr558_i2c_write_2_bytes(LTR558_PS_THRES_UP, ps_threshold_high);
+                        ltr558_i2c_write_2_bytes(LTR558_PS_THRES_LOW, 0x0000);
+
+                        input_report_abs(pls->input, ABS_DISTANCE, 1);
+                        input_sync(pls->input);
+                }
+        }
+
+       if ((0x03 == (status & 0x03)) && (LTR_PLS_MODE == LTR_PLS_553)) {/*is 553 PS*/
+                value = ltr558_i2c_read_2_bytes(LTR558_PS_DATA_0);
+                PRINT_DBG("LTR_PLS_MODE is pls 553 \n");
+#ifdef LTR558_ADAPTIVE
+                /*threshold detect process*/
+                if(0 == ps_max || 0 == ps_min) {
+                        ps_min = value;
+                        ps_max = value;
+                        ps_threshold = ps_min + MIN_SPACING;
+                }
+                if(value > ps_max) {
+                        ps_max_filter[max_index++] = value;
+                        if(ARRAY_SIZE(ps_max_filter) == max_index) {
+                                ps_max = get_min_value(ps_max_filter, ARRAY_SIZE(ps_max_filter));
+                                ps_threshold = ((ps_max - ps_min)  / DIVEDE) + ps_min;
+                                if(ps_threshold - ps_min < MIN_SPACING)
+                                        ps_threshold = ps_min + MIN_SPACING;
+                                max_index = 0;
+                        }
+                        min_index = 0;
+                } else if(value < ps_min) {
+                        ps_min_filter[min_index++] = value;
+                        if(ARRAY_SIZE(ps_min_filter) == min_index) {
+                                ps_min = get_max_value(ps_min_filter, ARRAY_SIZE(ps_min_filter));
+                                ps_threshold = ((ps_max - ps_min)  / DIVEDE) + ps_min;
+                                if(ps_threshold - ps_min < MIN_SPACING)
+                                        ps_threshold = ps_min + MIN_SPACING;
+                                min_index = 0;
+                        }
+                        max_index = 0;
+                } else {
+                        max_index = 0;
+                        min_index = 0;
+                }
+                /*threshold detect process end*/
+
+                if (value > (ps_threshold + DEBOUNCE)) {
+                        input_report_abs(pls->input, ABS_DISTANCE, 0);
+                        input_sync(pls->input);
+                } else if (value < (ps_threshold - DEBOUNCE)) {
+                        input_report_abs(pls->input, ABS_DISTANCE, 1);
+                        input_sync(pls->input);
+                }
+                PRINT_DBG("PS INT: PS_DATA_VAL = 0x%04X(%4d)  ps_min=%4d ps_max=%4d ps_threshold=%4d\n", \
+                          value, value, ps_min, ps_max, ps_threshold);
+#else
+                if (value >= ps_threshold) {
+                        ltr558_i2c_write_2_bytes(LTR558_PS_THRES_UP, 0x07FF);
+                        ltr558_i2c_write_2_bytes(LTR558_PS_THRES_LOW, ps_threshold);
+                        input_report_abs(pls->input, ABS_DISTANCE, 0);
+                        input_sync(pls->input);
+                } else if (value <= ps_threshold) {
+                        ltr558_i2c_write_2_bytes(LTR558_PS_THRES_UP, ps_threshold);
+                        ltr558_i2c_write_2_bytes(LTR558_PS_THRES_LOW, 0x0000);
+                        input_report_abs(pls->input, ABS_DISTANCE, 1);
+                        input_sync(pls->input);
+                }
+                PRINT_DBG("PS INT: PS_DATA_VAL = 0x%04X ( %d )\n", value, value);
+#endif
+        }
+        if (0x0c == (status & 0x0c)) {/*is ALS*/
+                value = ltr558_als_read(l_gainrange);
+                PRINT_DBG("ALS INT: ALS_DATA_VAL = 0x%04X(%4d)\n", value, value);
+                input_report_abs(pls->input, ABS_MISC, value);
+                input_sync(pls->input);
+        }
+
+        enable_irq(pls->client->irq);
+}
+
+static irqreturn_t ltr558_irq_handler(int irq, void *dev_id)
+{
+        ltr558_t *pls = (ltr558_t *) dev_id;
+
+        disable_irq_nosync(pls->client->irq);
+        queue_work(pls->ltr_work_queue, &pls->work);
+        return IRQ_HANDLED;
+}
+
+static int ltr558_sw_reset(void)
+{
+        int ret = 0;
+        ret = ltr558_i2c_write_1_byte(LTR558_ALS_CONTR, 0x04);
+        if(1 == ret)
+                PRINT_INFO("ltr558_sw_reset success\n");
+        else
+                PRINT_ERR("ltr558_sw_reset failed! ret = %d\n", ret);
+        return ret;
+}
+
+static int ltr558_reg_init(void)
+{
+        int ret = 0;
+//        ret = ltr558_sw_reset();
+//        if(1 != ret)  {
+//                PRINT_ERR("ltr558_reg_init failed! ret = %d\n", ret);
+//                return ret;
+//        }
+//        mdelay(PON_DELAY);
+
+        if(LTR_PLS_558 == LTR_PLS_MODE){
+                //set: LED Pulse Frequency=60KHz,LED Duty Cycle=100%,LED Peak Current=50mA
+                ltr558_i2c_write_1_byte(LTR558_PS_LED, 0x7B);
+                //set: LED Pulse Count=15
+                ltr558_i2c_write_1_byte(LTR558_PS_N_PULSES , 0x1f);
+                //set: PS Measurement Repeat Rate: 0x00=50ms 0x02=100ms
+                ltr558_i2c_write_1_byte(LTR558_PS_MEAS_RATE, 0x00);
+                //set: ALS Integration Time=100ms, ALS Measurement Repeat Rate=100ms
+                ltr558_i2c_write_1_byte(LTR558_ALS_MEAS_RATE, 0x13);
+                ltr558_i2c_write_1_byte(LTR558_INTERRUPT_PERSIST,0x02);
+                //set: INT MODE=updated after every measurement,
+                //=active low level,
+                //=both PS & ALS measurement can trigger interrupt
+                ltr558_i2c_write_1_byte(LTR558_INTERRUPT, 0x0B);
+        }else{
+                //set: LED Pulse Frequency=60KHz,LED Duty Cycle=100%,LED Peak Current=50mA
+                ltr558_i2c_write_1_byte(LTR558_PS_LED, 0x7B);
+                //set: LED Pulse Count=15
+                ltr558_i2c_write_1_byte(LTR558_PS_N_PULSES , 0x08);
+                //set: PS Measurement Repeat Rate: 0x00=50ms 0x02=100ms
+                ltr558_i2c_write_1_byte(LTR558_PS_MEAS_RATE, 0x00);
+                //set: ALS Integration Time=100ms, ALS Measurement Repeat Rate=100ms
+                ltr558_i2c_write_1_byte(LTR558_ALS_MEAS_RATE, 0x03);
+                ltr558_i2c_write_1_byte(LTR558_INTERRUPT_PERSIST,0x12);
+                //set: INT MODE=updated after every measurement,
+                //=active low level,
+                //=both PS & ALS measurement can trigger interrupt
+                ltr558_i2c_write_1_byte(LTR558_INTERRUPT, 0x03);
+        }
+        //set: PS Persist=2, ALS Persist=2
+        //ltr558_i2c_write_1_byte(LTR558_INTERRUPT_PERSIST, 0x22);
+        //set: PS Threshold
+        //ltr558_i2c_write_2_bytes(LTR558_PS_THRES_UP, 0x0000);
+        //ltr558_i2c_write_2_bytes(LTR558_PS_THRES_LOW, 0x0000);
+        //set: ALS Threshold
+        //ltr558_i2c_write_2_bytes(LTR558_ALS_THRES_UP, 0x0000);
+        //ltr558_i2c_write_2_bytes(LTR558_ALS_THRES_LOW, 0x0001);/*DO NOT set:0x0000*/
+
+        // ps
+        ltr558_i2c_write_1_byte(LTR558_PS_THRES_UP_0, 0x00);
+        ltr558_i2c_write_1_byte(LTR558_PS_THRES_UP_1, 0x03);
+        ltr558_i2c_write_1_byte(LTR558_PS_THRES_LOW_0, 0xf0);
+        ltr558_i2c_write_1_byte(LTR558_PS_THRES_LOW_1, 0x02);
+
+        // als
+        ltr558_i2c_write_1_byte(LTR558_ALS_THRES_UP_0, 0x00);
+        ltr558_i2c_write_1_byte(LTR558_ALS_THRES_UP_1, 0x00);
+        ltr558_i2c_write_1_byte(LTR558_ALS_THRES_LOW_0, 0x01);
+        ltr558_i2c_write_1_byte(LTR558_ALS_THRES_LOW_1, 0x00);
+
+        msleep(WAKEUP_DELAY);
+
+        PRINT_INFO("ltr558_reg_init success!\n");
+        return ret;
+}
+
+static int ltr558_version_check(void)
+{
+        int part_id = -1;
+        int manufacturer_id = -1;
+        part_id = ltr558_i2c_read_1_byte(LTR558_PART_NUMBER_ID);
+        manufacturer_id = ltr558_i2c_read_1_byte(LTR558_MANUFACTURER_ID);
+        PRINT_INFO("PART_ID: 0x%02X   MANUFACTURER_ID: 0x%02X\n", part_id, manufacturer_id);
+
+        if(part_id == 0x80 && manufacturer_id == 0x05) {
+                PRINT_INFO("I'm LTR558, and I'm working now\n");
+                return 0;
+        }else if(part_id == 0x92 && manufacturer_id == 0x05)
+        {
+                PRINT_INFO("I'm LTR553, and I'm working now\n");
+                return 0;
+        }
+        else if(part_id < 0 || manufacturer_id < 0) {
+                PRINT_ERR("can't read who am I\n");
+                return -1;
+        } else {
+                PRINT_ERR("I'm working, but I'm NOT LTR558\n");
+                return -1;
+        }
+}
+
+static ssize_t ltr_558als_show(struct kobject *kobj, struct kobj_attribute *attr, char *buff)
+{
+        return sprintf(buff, "ps_min=%4d  ps_max=%4d  ps_threshold=%4d\n", ps_min, ps_max, ps_threshold);
+}
+
+#ifdef LTR588_DBG
+static int str2int(char *p, char *end)
+{
+        int result = 0;
+        int len = end - p + 1;
+        int c;
+
+        for(; len > 0; len--, p++) {
+                if(p > end)
+                        return -1;
+                c = *p - '0';
+                if((unsigned int)c >= 10)
+                        return -1;
+                result = result * 10 + c;
+        }
+        return result;
+}
+
+/*parse a int from the string*/
+static int get_int(char *p, u8 max_len)
+{
+        char *start = p;
+        char *end =NULL;
+
+        if(max_len > 60) {
+                PRINT_ERR("CMD ERROR!the max length of the cmd should less than 60\n");
+                return -1;
+        }
+        for(; max_len > 0; max_len--, p++) {
+                if(*p >= '0' && *p <= '9') {
+                        start = p;
+                        break;
+                }
+        }
+        if(0 == max_len)
+                return -1;
+
+        end = start;
+
+        for(; max_len > 0; max_len--, p++) {
+                if(*p >= '0' && *p <= '9') {
+                        end = p;
+                        continue;
+                }
+                break;
+        }
+
+        return str2int(start, end);
+}
+
+static ssize_t ltr_558als_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buff, size_t n)
+{
+        char *buff_temp = NULL;
+
+        buff_temp = kmalloc(n, GFP_KERNEL);
+        if(NULL == buff_temp){
+                PRINT_ERR("kmalloc err\n");
+                return n;
+		}
+
+        memcpy(buff_temp, buff, n);
+
+        ps_threshold = get_int(buff_temp, n);
+        if(0x07FF < ps_threshold) {
+                ps_threshold = LTR558_PS_THRESHOLD;
+                PRINT_WARN("ps_threshold value over range, replace with the default value\n");
+        }
+        PRINT_INFO("set ps_threshold = 0x%04X ( %d )\n", ps_threshold, ps_threshold);
+
+        ltr558_i2c_write_2_bytes(LTR558_PS_THRES_UP, 0x0000);
+        ltr558_i2c_write_2_bytes(LTR558_PS_THRES_LOW, 0x0000);
+
+        if(buff_temp != NULL)
+                kfree(buff_temp);
+
+        return n;
+}
+
+static int break_loop = 0;
+static ssize_t ltr_558als_val_show(struct kobject *kobj, struct kobj_attribute *attr, char *buff)
+{
+        int measured_val = 0;
+        ltr558_t *pls = (ltr558_t *)i2c_get_clientdata(this_client);
+
+        disable_irq_nosync(pls->client->irq);
+        ltr558_als_enable(l_gainrange);
+        ltr558_ps_enable(p_gainrange);
+
+        break_loop = 0;
+        while(1) {
+                measured_val = ltr558_i2c_read_2_bytes(LTR558_PS_DATA_0);
+                PRINT_DBG("PS_DATA_VAL = 0x%04X ( %d )\n", measured_val, measured_val);
+                input_report_abs(pls->input, ABS_DISTANCE, measured_val);
+                input_sync(pls->input);
+
+                measured_val = ltr558_als_read(l_gainrange);
+                PRINT_DBG("ALS_DATA_VAL = 0x%04X ( %d )\n", measured_val, measured_val);
+                input_report_abs(pls->input, ABS_MISC, measured_val);
+                input_sync(pls->input);
+
+                if(1 == break_loop)
+                        break;
+                msleep(200);
+        }
+        ltr558_ps_disable();
+        ltr558_als_disable();
+        enable_irq(pls->client->irq);
+
+        return 0;
+}
+
+static ssize_t ltr_558als_val_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buff, size_t n)
+{
+        break_loop = 1;
+        PRINT_INFO("stop show value\n");
+        ltr558_i2c_write_2_bytes(LTR558_PS_THRES_UP, 0x0000);
+        ltr558_i2c_write_2_bytes(LTR558_PS_THRES_LOW, 0x0000);
+        return n;
+}
+#endif
+
+static struct kobject *ltr_558als_kobj;
+static struct kobj_attribute ltr_558als_attr =
+        __ATTR(ps_threshold, 0644, ltr_558als_show, NULL);
+#ifdef LTR588_DBG
+static struct kobj_attribute ltr_558als_val_attr =
+        __ATTR(show_val, 0644, ltr_558als_val_show, ltr_558als_val_store);
+#endif
+
+static int ltr_558als_sysfs_init(struct input_dev *input_dev)
+{
+        int ret = -1;
+
+        ltr_558als_kobj = kobject_create_and_add("ltr_558als", &(input_dev->dev.kobj));
+        if (ltr_558als_kobj == NULL) {
+                ret = -ENOMEM;
+                PRINT_ERR("register sysfs failed. ret = %d\n", ret);
+                return ret;
+        }
+
+        ret = sysfs_create_file(ltr_558als_kobj, &ltr_558als_attr.attr);
+        if (ret) {
+                PRINT_ERR("create sysfs failed. ret = %d\n", ret);
+                return ret;
+        }
+#ifdef LTR588_DBG
+        ret = sysfs_create_file(ltr_558als_kobj, &ltr_558als_val_attr.attr);
+        if (ret) {
+                PRINT_ERR("create sysfs failed. ret = %d\n", ret);
+                return ret;
+        }
+#endif
+        return ret;
+}
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+static void ltr558_early_suspend(struct early_suspend *handler)
+{
+        PRINT_INFO("ltr558_early_suspend\n");
+}
+
+static void ltr558_late_resume(struct early_suspend *handler)
+{
+        PRINT_INFO("ltr558_late_resume\n");
+}
+#endif
+
+static int ltr558_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+        int ret = 0;
+        ltr558_t *ltr_558als = NULL;
+        struct input_dev *input_dev = NULL;
+        struct ltr558_pls_platform_data *pdata = client->dev.platform_data;
+        int chip_id = 0;
+#ifdef CONFIG_OF
+        struct device_node *np = client->dev.of_node;
+        if (np && !pdata){
+		pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+		if (!pdata) {
+			dev_err(&client->dev, "Could not allocate struct ltr558_pls_platform_data");
+			goto exit_allocate_pdata_failed;
+		}
+		pdata->irq_gpio_number = of_get_gpio(np, 0);
+		if(pdata->irq_gpio_number < 0){
+			dev_err(&client->dev, "fail to get irq_gpio_number\n");
+			kfree(pdata);
+			goto exit_irq_gpio_read_fail;
+		}
+		client->dev.platform_data = pdata;
+	}
+#endif
+        ret = gpio_request(pdata->irq_gpio_number, LTR558_PLS_IRQ_PIN);
+        if(ret) {
+                PRINT_ERR("gpio_request failed!\n");
+                goto exit_gpio_request_failed;
+        }
+        gpio_direction_input(pdata->irq_gpio_number);
+        client->irq = gpio_to_irq(pdata->irq_gpio_number);
+        PRINT_INFO("client->irq = %d\n", client->irq);
+
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+                PRINT_ERR("i2c_check_functionality failed!\n");
+                ret = -ENODEV;
+                goto exit_i2c_check_functionality_failed;
+        }
+
+        ltr_558als = kzalloc(sizeof(ltr558_t), GFP_KERNEL);
+        if (!ltr_558als) {
+                PRINT_ERR("kzalloc failed!\n");
+                ret = -ENOMEM;
+                goto exit_kzalloc_failed;
+        }
+
+        i2c_set_clientdata(client, ltr_558als);
+        ltr_558als->client = client;
+        this_client = client;
+
+        chip_id = ltr558_i2c_read_1_byte(LTR558_PART_ID);
+        if(chip_id < 0)
+        {
+            PRINT_ERR("ltr558 or ltr553 read chip_id failed!\n");
+            ret = -ENOMEM;
+            goto exit_read_chip_id_failed;
+        }
+        if(LTR_553_PART_ID == chip_id)
+        {
+            LTR_PLS_MODE = LTR_PLS_553;
+            p_gainrange = PS_553_RANGE16;
+            l_gainrange = ALS_553_RANGE1_64K;
+        }
+        else
+        {
+            LTR_PLS_MODE = LTR_PLS_558;
+            p_gainrange = PS_558_RANGE4;
+            l_gainrange = ALS_558_RANGE1_320;
+        }
+
+        input_dev = input_allocate_device();
+        if (!input_dev) {
+                PRINT_ERR("input_allocate_device failed!\n");
+                ret = -ENOMEM;
+                goto exit_input_allocate_device_failed;
+        }
+
+        input_dev->name = LTR558_INPUT_DEV;
+        input_dev->phys = LTR558_INPUT_DEV;
+        input_dev->id.bustype = BUS_I2C;
+        input_dev->dev.parent = &client->dev;
+        input_dev->id.vendor = 0x0001;
+        input_dev->id.product = 0x0001;
+        input_dev->id.version = 0x0010;
+        ltr_558als->input = input_dev;
+
+        __set_bit(EV_ABS, input_dev->evbit);
+        input_set_abs_params(input_dev, ABS_DISTANCE, 0, 1, 0, 0);
+        input_set_abs_params(input_dev, ABS_MISC, 0, 100001, 0, 0);
+
+        ret = input_register_device(input_dev);
+        if (ret < 0) {
+                PRINT_ERR("input_register_device failed!\n");
+                input_free_device(input_dev);
+                input_dev = NULL;
+                goto exit_input_register_device_failed;
+        }
+
+        ret = misc_register(&ltr558_device);
+        if (ret) {
+                PRINT_ERR("misc_register failed!\n");
+                goto exit_misc_register_failed;
+        }
+
+        if (ltr558_reg_init() < 0) {
+                PRINT_ERR("ltr558_reg_init failed!\n");
+                ret = -1;
+                goto exit_ltr558_reg_init_failed;
+        }
+
+        ret = ltr558_version_check();
+        if(ret) {
+               PRINT_ERR("ltr558_version_check failed!\n");
+                goto exit_ltr558_version_check_failed;
+        }
+
+        INIT_WORK(&ltr_558als->work, ltr558_work);
+        ltr_558als->ltr_work_queue = create_singlethread_workqueue(LTR558_I2C_NAME);
+        if (!ltr_558als->ltr_work_queue) {
+                PRINT_ERR("create_singlethread_workqueue failed!\n");
+                goto exit_create_singlethread_workqueue_failed;
+        }
+
+        if (client->irq > 0) {
+                ret = request_irq(client->irq, ltr558_irq_handler, IRQ_TYPE_LEVEL_LOW | IRQF_NO_SUSPEND, client->name, ltr_558als);
+                if (ret < 0) {
+                        PRINT_ERR("request_irq failed!\n");
+                        goto exit_request_irq_failed;
+                }
+        }
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+        ltr_558als->ltr_early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 25;
+        ltr_558als->ltr_early_suspend.suspend = ltr558_early_suspend;
+        ltr_558als->ltr_early_suspend.resume = ltr558_late_resume;
+        register_early_suspend(&ltr_558als->ltr_early_suspend);
+#endif
+
+        ret = ltr_558als_sysfs_init(input_dev);
+        if(ret) {
+                PRINT_ERR("ltr_558als_sysfs_init failed!\n");
+                goto exit_ltr_558als_sysfs_init_failed;
+        }
+
+        PRINT_INFO("probe success!\n");
+        return 0;
+
+exit_ltr_558als_sysfs_init_failed:
+        free_irq(ltr_558als->client->irq, ltr_558als);
+exit_request_irq_failed:
+        destroy_workqueue(ltr_558als->ltr_work_queue);
+        ltr_558als->ltr_work_queue = NULL;
+exit_create_singlethread_workqueue_failed:
+exit_ltr558_version_check_failed:
+exit_ltr558_reg_init_failed:
+        misc_deregister(&ltr558_device);
+exit_misc_register_failed:
+        input_unregister_device(input_dev);
+exit_input_register_device_failed:
+exit_input_allocate_device_failed:
+exit_read_chip_id_failed:
+        kfree(ltr_558als);
+        ltr_558als = NULL;
+exit_kzalloc_failed:
+exit_i2c_check_functionality_failed:
+        gpio_free(pdata->irq_gpio_number);
+exit_gpio_request_failed:
+exit_irq_gpio_read_fail:
+exit_allocate_pdata_failed:
+        PRINT_ERR("probe failed!\n");
+        return ret;
+}
+
+static int ltr558_remove(struct i2c_client *client)
+{
+        ltr558_t *ltr_558als = i2c_get_clientdata(client);
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+        unregister_early_suspend(&ltr_558als->ltr_early_suspend);
+#endif
+
+        flush_workqueue(ltr_558als->ltr_work_queue);
+        destroy_workqueue(ltr_558als->ltr_work_queue);
+        ltr_558als->ltr_work_queue = NULL;
+
+        misc_deregister(&ltr558_device);
+        input_unregister_device(ltr_558als->input);
+        input_free_device(ltr_558als->input);
+        ltr_558als->input = NULL;
+        free_irq(ltr_558als->client->irq, ltr_558als);
+        gpio_free(irq_to_gpio(ltr_558als->client->irq));
+        kfree(ltr_558als);
+        ltr_558als = NULL;
+        this_client = NULL;
+
+        PRINT_INFO("ltr558_remove\n");
+        return 0;
+}
+
+static const struct i2c_device_id ltr558_id[] = {
+        {LTR558_I2C_NAME, 0},
+        {}
+};
+
+static const struct of_device_id ltr558_of_match[] = {
+       { .compatible = "LITEON,ltr_558als", },
+        {}
+};
+MODULE_DEVICE_TABLE(of, ltr558_of_match);
+static struct i2c_driver ltr558_driver = {
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = LTR558_I2C_NAME,
+                .of_match_table = ltr558_of_match,
+        },
+        .probe = ltr558_probe,
+        .remove = ltr558_remove,
+        .id_table = ltr558_id,
+};
+
+static int __init ltr558_init(void)
+{
+        int ret = -1;
+        ret = i2c_add_driver(&ltr558_driver);
+        if(ret) {
+                PRINT_ERR("i2c_add_driver failed!\n");
+                return ret;
+        }
+        return ret;
+}
+
+static void __exit ltr558_exit(void)
+{
+        i2c_del_driver(&ltr558_driver);
+}
+
+late_initcall(ltr558_init);
+module_exit(ltr558_exit);
+
+MODULE_AUTHOR("Yaochuan Li <yaochuan.li@spreadtrum.com>");
+MODULE_DESCRIPTION("Proximity&Light Sensor LTR558ALS DRIVER");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/m68kspkr.c b/drivers/input/misc/m68kspkr.c
new file mode 100644
index 00000000..b40ee4b4
--- /dev/null
+++ b/drivers/input/misc/m68kspkr.c
@@ -0,0 +1,151 @@
+/*
+ *  m68k beeper driver for Linux
+ *
+ *  Copyright (c) 2002 Richard Zidlicky
+ *  Copyright (c) 2002 Vojtech Pavlik
+ *  Copyright (c) 1992 Orest Zborowski
+ *
+ */
+
+/*
+ * 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/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/platform_device.h>
+#include <asm/machdep.h>
+#include <asm/io.h>
+
+MODULE_AUTHOR("Richard Zidlicky <rz@linux-m68k.org>");
+MODULE_DESCRIPTION("m68k beeper driver");
+MODULE_LICENSE("GPL");
+
+static struct platform_device *m68kspkr_platform_device;
+
+static int m68kspkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
+{
+	unsigned int count = 0;
+
+	if (type != EV_SND)
+		return -1;
+
+	switch (code) {
+		case SND_BELL: if (value) value = 1000;
+		case SND_TONE: break;
+		default: return -1;
+	}
+
+	if (value > 20 && value < 32767)
+		count = 1193182 / value;
+
+	mach_beep(count, -1);
+
+	return 0;
+}
+
+static int m68kspkr_probe(struct platform_device *dev)
+{
+	struct input_dev *input_dev;
+	int err;
+
+	input_dev = input_allocate_device();
+	if (!input_dev)
+		return -ENOMEM;
+
+	input_dev->name = "m68k beeper";
+	input_dev->phys = "m68k/generic";
+	input_dev->id.bustype = BUS_HOST;
+	input_dev->id.vendor  = 0x001f;
+	input_dev->id.product = 0x0001;
+	input_dev->id.version = 0x0100;
+	input_dev->dev.parent = &dev->dev;
+
+	input_dev->evbit[0] = BIT_MASK(EV_SND);
+	input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
+	input_dev->event = m68kspkr_event;
+
+	err = input_register_device(input_dev);
+	if (err) {
+		input_free_device(input_dev);
+		return err;
+	}
+
+	platform_set_drvdata(dev, input_dev);
+
+	return 0;
+}
+
+static int m68kspkr_remove(struct platform_device *dev)
+{
+	struct input_dev *input_dev = platform_get_drvdata(dev);
+
+	input_unregister_device(input_dev);
+	platform_set_drvdata(dev, NULL);
+	/* turn off the speaker */
+	m68kspkr_event(NULL, EV_SND, SND_BELL, 0);
+
+	return 0;
+}
+
+static void m68kspkr_shutdown(struct platform_device *dev)
+{
+	/* turn off the speaker */
+	m68kspkr_event(NULL, EV_SND, SND_BELL, 0);
+}
+
+static struct platform_driver m68kspkr_platform_driver = {
+	.driver		= {
+		.name	= "m68kspkr",
+		.owner	= THIS_MODULE,
+	},
+	.probe		= m68kspkr_probe,
+	.remove		= m68kspkr_remove,
+	.shutdown	= m68kspkr_shutdown,
+};
+
+static int __init m68kspkr_init(void)
+{
+	int err;
+
+	if (!mach_beep) {
+		printk(KERN_INFO "m68kspkr: no lowlevel beep support\n");
+		return -ENODEV;
+        }
+
+	err = platform_driver_register(&m68kspkr_platform_driver);
+	if (err)
+		return err;
+
+	m68kspkr_platform_device = platform_device_alloc("m68kspkr", -1);
+	if (!m68kspkr_platform_device) {
+		err = -ENOMEM;
+		goto err_unregister_driver;
+	}
+
+	err = platform_device_add(m68kspkr_platform_device);
+	if (err)
+		goto err_free_device;
+
+	return 0;
+
+ err_free_device:
+	platform_device_put(m68kspkr_platform_device);
+ err_unregister_driver:
+	platform_driver_unregister(&m68kspkr_platform_driver);
+
+	return err;
+}
+
+static void __exit m68kspkr_exit(void)
+{
+	platform_device_unregister(m68kspkr_platform_device);
+	platform_driver_unregister(&m68kspkr_platform_driver);
+}
+
+module_init(m68kspkr_init);
+module_exit(m68kspkr_exit);
diff --git a/drivers/input/misc/max8925_onkey.c b/drivers/input/misc/max8925_onkey.c
new file mode 100644
index 00000000..f9179b25
--- /dev/null
+++ b/drivers/input/misc/max8925_onkey.c
@@ -0,0 +1,201 @@
+/**
+ * MAX8925 ONKEY driver
+ *
+ * Copyright (C) 2009 Marvell International Ltd.
+ *      Haojian Zhuang <haojian.zhuang@marvell.com>
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License. See the file "COPYING" in the main directory of this
+ * archive for more details.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/max8925.h>
+#include <linux/slab.h>
+
+#define SW_INPUT		(1 << 7)	/* 0/1 -- up/down */
+#define HARDRESET_EN		(1 << 7)
+#define PWREN_EN		(1 << 7)
+
+struct max8925_onkey_info {
+	struct input_dev	*idev;
+	struct i2c_client	*i2c;
+	struct device		*dev;
+	unsigned int		irq[2];
+};
+
+/*
+ * MAX8925 gives us an interrupt when ONKEY is pressed or released.
+ * max8925_set_bits() operates I2C bus and may sleep. So implement
+ * it in thread IRQ handler.
+ */
+static irqreturn_t max8925_onkey_handler(int irq, void *data)
+{
+	struct max8925_onkey_info *info = data;
+	int state;
+
+	state = max8925_reg_read(info->i2c, MAX8925_ON_OFF_STATUS);
+
+	input_report_key(info->idev, KEY_POWER, state & SW_INPUT);
+	input_sync(info->idev);
+
+	dev_dbg(info->dev, "onkey state:%d\n", state);
+
+	/* Enable hardreset to halt if system isn't shutdown on time */
+	max8925_set_bits(info->i2c, MAX8925_SYSENSEL,
+			 HARDRESET_EN, HARDRESET_EN);
+
+	return IRQ_HANDLED;
+}
+
+static int max8925_onkey_probe(struct platform_device *pdev)
+{
+	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
+	struct max8925_onkey_info *info;
+	struct input_dev *input;
+	int irq[2], error;
+
+	irq[0] = platform_get_irq(pdev, 0);
+	if (irq[0] < 0) {
+		dev_err(&pdev->dev, "No IRQ resource!\n");
+		return -EINVAL;
+	}
+
+	irq[1] = platform_get_irq(pdev, 1);
+	if (irq[1] < 0) {
+		dev_err(&pdev->dev, "No IRQ resource!\n");
+		return -EINVAL;
+	}
+
+	info = kzalloc(sizeof(struct max8925_onkey_info), GFP_KERNEL);
+	input = input_allocate_device();
+	if (!info || !input) {
+		error = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	info->idev = input;
+	info->i2c = chip->i2c;
+	info->dev = &pdev->dev;
+	info->irq[0] = irq[0];
+	info->irq[1] = irq[1];
+
+	input->name = "max8925_on";
+	input->phys = "max8925_on/input0";
+	input->id.bustype = BUS_I2C;
+	input->dev.parent = &pdev->dev;
+	input_set_capability(input, EV_KEY, KEY_POWER);
+
+	error = request_threaded_irq(irq[0], NULL, max8925_onkey_handler,
+				     IRQF_ONESHOT, "onkey-down", info);
+	if (error < 0) {
+		dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
+			irq[0], error);
+		goto err_free_mem;
+	}
+
+	error = request_threaded_irq(irq[1], NULL, max8925_onkey_handler,
+				     IRQF_ONESHOT, "onkey-up", info);
+	if (error < 0) {
+		dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
+			irq[1], error);
+		goto err_free_irq0;
+	}
+
+	error = input_register_device(info->idev);
+	if (error) {
+		dev_err(chip->dev, "Can't register input device: %d\n", error);
+		goto err_free_irq1;
+	}
+
+	platform_set_drvdata(pdev, info);
+	device_init_wakeup(&pdev->dev, 1);
+
+	return 0;
+
+err_free_irq1:
+	free_irq(irq[1], info);
+err_free_irq0:
+	free_irq(irq[0], info);
+err_free_mem:
+	input_free_device(input);
+	kfree(info);
+
+	return error;
+}
+
+static int max8925_onkey_remove(struct platform_device *pdev)
+{
+	struct max8925_onkey_info *info = platform_get_drvdata(pdev);
+	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
+
+	free_irq(info->irq[0] + chip->irq_base, info);
+	free_irq(info->irq[1] + chip->irq_base, info);
+	input_unregister_device(info->idev);
+	kfree(info);
+
+	platform_set_drvdata(pdev, NULL);
+
+	return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int max8925_onkey_suspend(struct device *dev)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct max8925_onkey_info *info = platform_get_drvdata(pdev);
+	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
+
+	if (device_may_wakeup(dev)) {
+		chip->wakeup_flag |= 1 << info->irq[0];
+		chip->wakeup_flag |= 1 << info->irq[1];
+	}
+
+	return 0;
+}
+
+static int max8925_onkey_resume(struct device *dev)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct max8925_onkey_info *info = platform_get_drvdata(pdev);
+	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
+
+	if (device_may_wakeup(dev)) {
+		chip->wakeup_flag &= ~(1 << info->irq[0]);
+		chip->wakeup_flag &= ~(1 << info->irq[1]);
+	}
+
+	return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(max8925_onkey_pm_ops, max8925_onkey_suspend, max8925_onkey_resume);
+
+static struct platform_driver max8925_onkey_driver = {
+	.driver		= {
+		.name	= "max8925-onkey",
+		.owner	= THIS_MODULE,
+		.pm	= &max8925_onkey_pm_ops,
+	},
+	.probe		= max8925_onkey_probe,
+	.remove		= max8925_onkey_remove,
+};
+module_platform_driver(max8925_onkey_driver);
+
+MODULE_DESCRIPTION("Maxim MAX8925 ONKEY driver");
+MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/max8997_haptic.c b/drivers/input/misc/max8997_haptic.c
new file mode 100644
index 00000000..e9731332
--- /dev/null
+++ b/drivers/input/misc/max8997_haptic.c
@@ -0,0 +1,407 @@
+/*
+ * MAX8997-haptic controller driver
+ *
+ * Copyright (C) 2012 Samsung Electronics
+ * Donggeun Kim <dg77.kim@samsung.com>
+ *
+ * This program is not provided / owned by Maxim Integrated Products.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/err.h>
+#include <linux/pwm.h>
+#include <linux/input.h>
+#include <linux/mfd/max8997-private.h>
+#include <linux/mfd/max8997.h>
+#include <linux/regulator/consumer.h>
+
+/* Haptic configuration 2 register */
+#define MAX8997_MOTOR_TYPE_SHIFT	7
+#define MAX8997_ENABLE_SHIFT		6
+#define MAX8997_MODE_SHIFT		5
+
+/* Haptic driver configuration register */
+#define MAX8997_CYCLE_SHIFT		6
+#define MAX8997_SIG_PERIOD_SHIFT	4
+#define MAX8997_SIG_DUTY_SHIFT		2
+#define MAX8997_PWM_DUTY_SHIFT		0
+
+struct max8997_haptic {
+	struct device *dev;
+	struct i2c_client *client;
+	struct input_dev *input_dev;
+	struct regulator *regulator;
+
+	struct work_struct work;
+	struct mutex mutex;
+
+	bool enabled;
+	unsigned int level;
+
+	struct pwm_device *pwm;
+	unsigned int pwm_period;
+	enum max8997_haptic_pwm_divisor pwm_divisor;
+
+	enum max8997_haptic_motor_type type;
+	enum max8997_haptic_pulse_mode mode;
+
+	unsigned int internal_mode_pattern;
+	unsigned int pattern_cycle;
+	unsigned int pattern_signal_period;
+};
+
+static int max8997_haptic_set_duty_cycle(struct max8997_haptic *chip)
+{
+	int ret = 0;
+
+	if (chip->mode == MAX8997_EXTERNAL_MODE) {
+		unsigned int duty = chip->pwm_period * chip->level / 100;
+		ret = pwm_config(chip->pwm, duty, chip->pwm_period);
+	} else {
+		int i;
+		u8 duty_index = 0;
+
+		for (i = 0; i <= 64; i++) {
+			if (chip->level <= i * 100 / 64) {
+				duty_index = i;
+				break;
+			}
+		}
+		switch (chip->internal_mode_pattern) {
+		case 0:
+			max8997_write_reg(chip->client,
+				MAX8997_HAPTIC_REG_SIGPWMDC1, duty_index);
+			break;
+		case 1:
+			max8997_write_reg(chip->client,
+				MAX8997_HAPTIC_REG_SIGPWMDC2, duty_index);
+			break;
+		case 2:
+			max8997_write_reg(chip->client,
+				MAX8997_HAPTIC_REG_SIGPWMDC3, duty_index);
+			break;
+		case 3:
+			max8997_write_reg(chip->client,
+				MAX8997_HAPTIC_REG_SIGPWMDC4, duty_index);
+			break;
+		default:
+			break;
+		}
+	}
+	return ret;
+}
+
+static void max8997_haptic_configure(struct max8997_haptic *chip)
+{
+	u8 value;
+
+	value = chip->type << MAX8997_MOTOR_TYPE_SHIFT |
+		chip->enabled << MAX8997_ENABLE_SHIFT |
+		chip->mode << MAX8997_MODE_SHIFT | chip->pwm_divisor;
+	max8997_write_reg(chip->client, MAX8997_HAPTIC_REG_CONF2, value);
+
+	if (chip->mode == MAX8997_INTERNAL_MODE && chip->enabled) {
+		value = chip->internal_mode_pattern << MAX8997_CYCLE_SHIFT |
+			chip->internal_mode_pattern << MAX8997_SIG_PERIOD_SHIFT |
+			chip->internal_mode_pattern << MAX8997_SIG_DUTY_SHIFT |
+			chip->internal_mode_pattern << MAX8997_PWM_DUTY_SHIFT;
+		max8997_write_reg(chip->client,
+			MAX8997_HAPTIC_REG_DRVCONF, value);
+
+		switch (chip->internal_mode_pattern) {
+		case 0:
+			value = chip->pattern_cycle << 4;
+			max8997_write_reg(chip->client,
+				MAX8997_HAPTIC_REG_CYCLECONF1, value);
+			value = chip->pattern_signal_period;
+			max8997_write_reg(chip->client,
+				MAX8997_HAPTIC_REG_SIGCONF1, value);
+			break;
+
+		case 1:
+			value = chip->pattern_cycle;
+			max8997_write_reg(chip->client,
+				MAX8997_HAPTIC_REG_CYCLECONF1, value);
+			value = chip->pattern_signal_period;
+			max8997_write_reg(chip->client,
+				MAX8997_HAPTIC_REG_SIGCONF2, value);
+			break;
+
+		case 2:
+			value = chip->pattern_cycle << 4;
+			max8997_write_reg(chip->client,
+				MAX8997_HAPTIC_REG_CYCLECONF2, value);
+			value = chip->pattern_signal_period;
+			max8997_write_reg(chip->client,
+				MAX8997_HAPTIC_REG_SIGCONF3, value);
+			break;
+
+		case 3:
+			value = chip->pattern_cycle;
+			max8997_write_reg(chip->client,
+				MAX8997_HAPTIC_REG_CYCLECONF2, value);
+			value = chip->pattern_signal_period;
+			max8997_write_reg(chip->client,
+				MAX8997_HAPTIC_REG_SIGCONF4, value);
+			break;
+
+		default:
+			break;
+		}
+	}
+}
+
+static void max8997_haptic_enable(struct max8997_haptic *chip)
+{
+	int error;
+
+	mutex_lock(&chip->mutex);
+
+	error = max8997_haptic_set_duty_cycle(chip);
+	if (error) {
+		dev_err(chip->dev, "set_pwm_cycle failed, error: %d\n", error);
+		goto out;
+	}
+
+	if (!chip->enabled) {
+		chip->enabled = true;
+		regulator_enable(chip->regulator);
+		max8997_haptic_configure(chip);
+		if (chip->mode == MAX8997_EXTERNAL_MODE)
+			pwm_enable(chip->pwm);
+	}
+
+out:
+	mutex_unlock(&chip->mutex);
+}
+
+static void max8997_haptic_disable(struct max8997_haptic *chip)
+{
+	mutex_lock(&chip->mutex);
+
+	if (chip->enabled) {
+		chip->enabled = false;
+		max8997_haptic_configure(chip);
+		if (chip->mode == MAX8997_EXTERNAL_MODE)
+			pwm_disable(chip->pwm);
+		regulator_disable(chip->regulator);
+	}
+
+	mutex_unlock(&chip->mutex);
+}
+
+static void max8997_haptic_play_effect_work(struct work_struct *work)
+{
+	struct max8997_haptic *chip =
+			container_of(work, struct max8997_haptic, work);
+
+	if (chip->level)
+		max8997_haptic_enable(chip);
+	else
+		max8997_haptic_disable(chip);
+}
+
+static int max8997_haptic_play_effect(struct input_dev *dev, void *data,
+				  struct ff_effect *effect)
+{
+	struct max8997_haptic *chip = input_get_drvdata(dev);
+
+	chip->level = effect->u.rumble.strong_magnitude;
+	if (!chip->level)
+		chip->level = effect->u.rumble.weak_magnitude;
+
+	schedule_work(&chip->work);
+
+	return 0;
+}
+
+static void max8997_haptic_close(struct input_dev *dev)
+{
+	struct max8997_haptic *chip = input_get_drvdata(dev);
+
+	cancel_work_sync(&chip->work);
+	max8997_haptic_disable(chip);
+}
+
+static int max8997_haptic_probe(struct platform_device *pdev)
+{
+	struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
+	const struct max8997_platform_data *pdata =
+					dev_get_platdata(iodev->dev);
+	const struct max8997_haptic_platform_data *haptic_pdata =
+					pdata->haptic_pdata;
+	struct max8997_haptic *chip;
+	struct input_dev *input_dev;
+	int error;
+
+	if (!haptic_pdata) {
+		dev_err(&pdev->dev, "no haptic platform data\n");
+		return -EINVAL;
+	}
+
+	chip = kzalloc(sizeof(struct max8997_haptic), GFP_KERNEL);
+	input_dev = input_allocate_device();
+	if (!chip || !input_dev) {
+		dev_err(&pdev->dev, "unable to allocate memory\n");
+		error = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	INIT_WORK(&chip->work, max8997_haptic_play_effect_work);
+	mutex_init(&chip->mutex);
+
+	chip->client = iodev->haptic;
+	chip->dev = &pdev->dev;
+	chip->input_dev = input_dev;
+	chip->pwm_period = haptic_pdata->pwm_period;
+	chip->type = haptic_pdata->type;
+	chip->mode = haptic_pdata->mode;
+	chip->pwm_divisor = haptic_pdata->pwm_divisor;
+
+	switch (chip->mode) {
+	case MAX8997_INTERNAL_MODE:
+		chip->internal_mode_pattern =
+				haptic_pdata->internal_mode_pattern;
+		chip->pattern_cycle = haptic_pdata->pattern_cycle;
+		chip->pattern_signal_period =
+				haptic_pdata->pattern_signal_period;
+		break;
+
+	case MAX8997_EXTERNAL_MODE:
+		chip->pwm = pwm_request(haptic_pdata->pwm_channel_id,
+					"max8997-haptic");
+		if (IS_ERR(chip->pwm)) {
+			error = PTR_ERR(chip->pwm);
+			dev_err(&pdev->dev,
+				"unable to request PWM for haptic, error: %d\n",
+				error);
+			goto err_free_mem;
+		}
+		break;
+
+	default:
+		dev_err(&pdev->dev,
+			"Invalid chip mode specified (%d)\n", chip->mode);
+		error = -EINVAL;
+		goto err_free_mem;
+	}
+
+	chip->regulator = regulator_get(&pdev->dev, "inmotor");
+	if (IS_ERR(chip->regulator)) {
+		error = PTR_ERR(chip->regulator);
+		dev_err(&pdev->dev,
+			"unable to get regulator, error: %d\n",
+			error);
+		goto err_free_pwm;
+	}
+
+	input_dev->name = "max8997-haptic";
+	input_dev->id.version = 1;
+	input_dev->dev.parent = &pdev->dev;
+	input_dev->close = max8997_haptic_close;
+	input_set_drvdata(input_dev, chip);
+	input_set_capability(input_dev, EV_FF, FF_RUMBLE);
+
+	error = input_ff_create_memless(input_dev, NULL,
+				max8997_haptic_play_effect);
+	if (error) {
+		dev_err(&pdev->dev,
+			"unable to create FF device, error: %d\n",
+			error);
+		goto err_put_regulator;
+	}
+
+	error = input_register_device(input_dev);
+	if (error) {
+		dev_err(&pdev->dev,
+			"unable to register input device, error: %d\n",
+			error);
+		goto err_destroy_ff;
+	}
+
+	platform_set_drvdata(pdev, chip);
+	return 0;
+
+err_destroy_ff:
+	input_ff_destroy(input_dev);
+err_put_regulator:
+	regulator_put(chip->regulator);
+err_free_pwm:
+	if (chip->mode == MAX8997_EXTERNAL_MODE)
+		pwm_free(chip->pwm);
+err_free_mem:
+	input_free_device(input_dev);
+	kfree(chip);
+
+	return error;
+}
+
+static int max8997_haptic_remove(struct platform_device *pdev)
+{
+	struct max8997_haptic *chip = platform_get_drvdata(pdev);
+
+	input_unregister_device(chip->input_dev);
+	regulator_put(chip->regulator);
+
+	if (chip->mode == MAX8997_EXTERNAL_MODE)
+		pwm_free(chip->pwm);
+
+	kfree(chip);
+
+	return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int max8997_haptic_suspend(struct device *dev)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct max8997_haptic *chip = platform_get_drvdata(pdev);
+
+	max8997_haptic_disable(chip);
+
+	return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(max8997_haptic_pm_ops, max8997_haptic_suspend, NULL);
+
+static const struct platform_device_id max8997_haptic_id[] = {
+	{ "max8997-haptic", 0 },
+	{ },
+};
+MODULE_DEVICE_TABLE(i2c, max8997_haptic_id);
+
+static struct platform_driver max8997_haptic_driver = {
+	.driver	= {
+		.name	= "max8997-haptic",
+		.owner	= THIS_MODULE,
+		.pm	= &max8997_haptic_pm_ops,
+	},
+	.probe		= max8997_haptic_probe,
+	.remove		= max8997_haptic_remove,
+	.id_table	= max8997_haptic_id,
+};
+module_platform_driver(max8997_haptic_driver);
+
+MODULE_ALIAS("platform:max8997-haptic");
+MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
+MODULE_DESCRIPTION("max8997_haptic driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/mc13783-pwrbutton.c b/drivers/input/misc/mc13783-pwrbutton.c
new file mode 100644
index 00000000..0906ca59
--- /dev/null
+++ b/drivers/input/misc/mc13783-pwrbutton.c
@@ -0,0 +1,272 @@
+/**
+ * Copyright (C) 2011 Philippe Rétornaz
+ *
+ * Based on twl4030-pwrbutton driver by:
+ *     Peter De Schrijver <peter.de-schrijver@nokia.com>
+ *     Felipe Balbi <felipe.balbi@nokia.com>
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License. See the file "COPYING" in the main directory of this
+ * archive for more details.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335  USA
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/mc13783.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+
+struct mc13783_pwrb {
+	struct input_dev *pwr;
+	struct mc13xxx *mc13783;
+#define MC13783_PWRB_B1_POL_INVERT	(1 << 0)
+#define MC13783_PWRB_B2_POL_INVERT	(1 << 1)
+#define MC13783_PWRB_B3_POL_INVERT	(1 << 2)
+	int flags;
+	unsigned short keymap[3];
+};
+
+#define MC13783_REG_INTERRUPT_SENSE_1		5
+#define MC13783_IRQSENSE1_ONOFD1S		(1 << 3)
+#define MC13783_IRQSENSE1_ONOFD2S		(1 << 4)
+#define MC13783_IRQSENSE1_ONOFD3S		(1 << 5)
+
+#define MC13783_REG_POWER_CONTROL_2		15
+#define MC13783_POWER_CONTROL_2_ON1BDBNC	4
+#define MC13783_POWER_CONTROL_2_ON2BDBNC	6
+#define MC13783_POWER_CONTROL_2_ON3BDBNC	8
+#define MC13783_POWER_CONTROL_2_ON1BRSTEN	(1 << 1)
+#define MC13783_POWER_CONTROL_2_ON2BRSTEN	(1 << 2)
+#define MC13783_POWER_CONTROL_2_ON3BRSTEN	(1 << 3)
+
+static irqreturn_t button_irq(int irq, void *_priv)
+{
+	struct mc13783_pwrb *priv = _priv;
+	int val;
+
+	mc13xxx_irq_ack(priv->mc13783, irq);
+	mc13xxx_reg_read(priv->mc13783, MC13783_REG_INTERRUPT_SENSE_1, &val);
+
+	switch (irq) {
+	case MC13783_IRQ_ONOFD1:
+		val = val & MC13783_IRQSENSE1_ONOFD1S ? 1 : 0;
+		if (priv->flags & MC13783_PWRB_B1_POL_INVERT)
+			val ^= 1;
+		input_report_key(priv->pwr, priv->keymap[0], val);
+		break;
+
+	case MC13783_IRQ_ONOFD2:
+		val = val & MC13783_IRQSENSE1_ONOFD2S ? 1 : 0;
+		if (priv->flags & MC13783_PWRB_B2_POL_INVERT)
+			val ^= 1;
+		input_report_key(priv->pwr, priv->keymap[1], val);
+		break;
+
+	case MC13783_IRQ_ONOFD3:
+		val = val & MC13783_IRQSENSE1_ONOFD3S ? 1 : 0;
+		if (priv->flags & MC13783_PWRB_B3_POL_INVERT)
+			val ^= 1;
+		input_report_key(priv->pwr, priv->keymap[2], val);
+		break;
+	}
+
+	input_sync(priv->pwr);
+
+	return IRQ_HANDLED;
+}
+
+static int mc13783_pwrbutton_probe(struct platform_device *pdev)
+{
+	const struct mc13xxx_buttons_platform_data *pdata;
+	struct mc13xxx *mc13783 = dev_get_drvdata(pdev->dev.parent);
+	struct input_dev *pwr;
+	struct mc13783_pwrb *priv;
+	int err = 0;
+	int reg = 0;
+
+	pdata = dev_get_platdata(&pdev->dev);
+	if (!pdata) {
+		dev_err(&pdev->dev, "missing platform data\n");
+		return -ENODEV;
+	}
+
+	pwr = input_allocate_device();
+	if (!pwr) {
+		dev_dbg(&pdev->dev, "Can't allocate power button\n");
+		return -ENOMEM;
+	}
+
+	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+	if (!priv) {
+		err = -ENOMEM;
+		dev_dbg(&pdev->dev, "Can't allocate power button\n");
+		goto free_input_dev;
+	}
+
+	reg |= (pdata->b1on_flags & 0x3) << MC13783_POWER_CONTROL_2_ON1BDBNC;
+	reg |= (pdata->b2on_flags & 0x3) << MC13783_POWER_CONTROL_2_ON2BDBNC;
+	reg |= (pdata->b3on_flags & 0x3) << MC13783_POWER_CONTROL_2_ON3BDBNC;
+
+	priv->pwr = pwr;
+	priv->mc13783 = mc13783;
+
+	mc13xxx_lock(mc13783);
+
+	if (pdata->b1on_flags & MC13783_BUTTON_ENABLE) {
+		priv->keymap[0] = pdata->b1on_key;
+		if (pdata->b1on_key != KEY_RESERVED)
+			__set_bit(pdata->b1on_key, pwr->keybit);
+
+		if (pdata->b1on_flags & MC13783_BUTTON_POL_INVERT)
+			priv->flags |= MC13783_PWRB_B1_POL_INVERT;
+
+		if (pdata->b1on_flags & MC13783_BUTTON_RESET_EN)
+			reg |= MC13783_POWER_CONTROL_2_ON1BRSTEN;
+
+		err = mc13xxx_irq_request(mc13783, MC13783_IRQ_ONOFD1,
+					  button_irq, "b1on", priv);
+		if (err) {
+			dev_dbg(&pdev->dev, "Can't request irq\n");
+			goto free_priv;
+		}
+	}
+
+	if (pdata->b2on_flags & MC13783_BUTTON_ENABLE) {
+		priv->keymap[1] = pdata->b2on_key;
+		if (pdata->b2on_key != KEY_RESERVED)
+			__set_bit(pdata->b2on_key, pwr->keybit);
+
+		if (pdata->b2on_flags & MC13783_BUTTON_POL_INVERT)
+			priv->flags |= MC13783_PWRB_B2_POL_INVERT;
+
+		if (pdata->b2on_flags & MC13783_BUTTON_RESET_EN)
+			reg |= MC13783_POWER_CONTROL_2_ON2BRSTEN;
+
+		err = mc13xxx_irq_request(mc13783, MC13783_IRQ_ONOFD2,
+					  button_irq, "b2on", priv);
+		if (err) {
+			dev_dbg(&pdev->dev, "Can't request irq\n");
+			goto free_irq_b1;
+		}
+	}
+
+	if (pdata->b3on_flags & MC13783_BUTTON_ENABLE) {
+		priv->keymap[2] = pdata->b3on_key;
+		if (pdata->b3on_key != KEY_RESERVED)
+			__set_bit(pdata->b3on_key, pwr->keybit);
+
+		if (pdata->b3on_flags & MC13783_BUTTON_POL_INVERT)
+			priv->flags |= MC13783_PWRB_B3_POL_INVERT;
+
+		if (pdata->b3on_flags & MC13783_BUTTON_RESET_EN)
+			reg |= MC13783_POWER_CONTROL_2_ON3BRSTEN;
+
+		err = mc13xxx_irq_request(mc13783, MC13783_IRQ_ONOFD3,
+					  button_irq, "b3on", priv);
+		if (err) {
+			dev_dbg(&pdev->dev, "Can't request irq: %d\n", err);
+			goto free_irq_b2;
+		}
+	}
+
+	mc13xxx_reg_rmw(mc13783, MC13783_REG_POWER_CONTROL_2, 0x3FE, reg);
+
+	mc13xxx_unlock(mc13783);
+
+	pwr->name = "mc13783_pwrbutton";
+	pwr->phys = "mc13783_pwrbutton/input0";
+	pwr->dev.parent = &pdev->dev;
+
+	pwr->keycode = priv->keymap;
+	pwr->keycodemax = ARRAY_SIZE(priv->keymap);
+	pwr->keycodesize = sizeof(priv->keymap[0]);
+	__set_bit(EV_KEY, pwr->evbit);
+
+	err = input_register_device(pwr);
+	if (err) {
+		dev_dbg(&pdev->dev, "Can't register power button: %d\n", err);
+		goto free_irq;
+	}
+
+	platform_set_drvdata(pdev, priv);
+
+	return 0;
+
+free_irq:
+	mc13xxx_lock(mc13783);
+
+	if (pdata->b3on_flags & MC13783_BUTTON_ENABLE)
+		mc13xxx_irq_free(mc13783, MC13783_IRQ_ONOFD3, priv);
+
+free_irq_b2:
+	if (pdata->b2on_flags & MC13783_BUTTON_ENABLE)
+		mc13xxx_irq_free(mc13783, MC13783_IRQ_ONOFD2, priv);
+
+free_irq_b1:
+	if (pdata->b1on_flags & MC13783_BUTTON_ENABLE)
+		mc13xxx_irq_free(mc13783, MC13783_IRQ_ONOFD1, priv);
+
+free_priv:
+	mc13xxx_unlock(mc13783);
+	kfree(priv);
+
+free_input_dev:
+	input_free_device(pwr);
+
+	return err;
+}
+
+static int mc13783_pwrbutton_remove(struct platform_device *pdev)
+{
+	struct mc13783_pwrb *priv = platform_get_drvdata(pdev);
+	const struct mc13xxx_buttons_platform_data *pdata;
+
+	pdata = dev_get_platdata(&pdev->dev);
+
+	mc13xxx_lock(priv->mc13783);
+
+	if (pdata->b3on_flags & MC13783_BUTTON_ENABLE)
+		mc13xxx_irq_free(priv->mc13783, MC13783_IRQ_ONOFD3, priv);
+	if (pdata->b2on_flags & MC13783_BUTTON_ENABLE)
+		mc13xxx_irq_free(priv->mc13783, MC13783_IRQ_ONOFD2, priv);
+	if (pdata->b1on_flags & MC13783_BUTTON_ENABLE)
+		mc13xxx_irq_free(priv->mc13783, MC13783_IRQ_ONOFD1, priv);
+
+	mc13xxx_unlock(priv->mc13783);
+
+	input_unregister_device(priv->pwr);
+	kfree(priv);
+	platform_set_drvdata(pdev, NULL);
+
+	return 0;
+}
+
+static struct platform_driver mc13783_pwrbutton_driver = {
+	.probe		= mc13783_pwrbutton_probe,
+	.remove		= mc13783_pwrbutton_remove,
+	.driver		= {
+		.name	= "mc13783-pwrbutton",
+		.owner	= THIS_MODULE,
+	},
+};
+
+module_platform_driver(mc13783_pwrbutton_driver);
+
+MODULE_ALIAS("platform:mc13783-pwrbutton");
+MODULE_DESCRIPTION("MC13783 Power Button");
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Philippe Retornaz");
diff --git a/drivers/input/misc/mma8450.c b/drivers/input/misc/mma8450.c
new file mode 100644
index 00000000..f3309696
--- /dev/null
+++ b/drivers/input/misc/mma8450.c
@@ -0,0 +1,254 @@
+/*
+ *  Driver for Freescale's 3-Axis Accelerometer MMA8450
+ *
+ *  Copyright (C) 2011 Freescale Semiconductor, Inc. All Rights Reserved.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/input-polldev.h>
+#include <linux/of_device.h>
+
+#define MMA8450_DRV_NAME	"mma8450"
+
+#define MODE_CHANGE_DELAY_MS	100
+#define POLL_INTERVAL		100
+#define POLL_INTERVAL_MAX	500
+
+/* register definitions */
+#define MMA8450_STATUS		0x00
+#define MMA8450_STATUS_ZXYDR	0x08
+
+#define MMA8450_OUT_X8		0x01
+#define MMA8450_OUT_Y8		0x02
+#define MMA8450_OUT_Z8		0x03
+
+#define MMA8450_OUT_X_LSB	0x05
+#define MMA8450_OUT_X_MSB	0x06
+#define MMA8450_OUT_Y_LSB	0x07
+#define MMA8450_OUT_Y_MSB	0x08
+#define MMA8450_OUT_Z_LSB	0x09
+#define MMA8450_OUT_Z_MSB	0x0a
+
+#define MMA8450_XYZ_DATA_CFG	0x16
+
+#define MMA8450_CTRL_REG1	0x38
+#define MMA8450_CTRL_REG2	0x39
+
+/* mma8450 status */
+struct mma8450 {
+	struct i2c_client	*client;
+	struct input_polled_dev	*idev;
+};
+
+static int mma8450_read(struct mma8450 *m, unsigned off)
+{
+	struct i2c_client *c = m->client;
+	int ret;
+
+	ret = i2c_smbus_read_byte_data(c, off);
+	if (ret < 0)
+		dev_err(&c->dev,
+			"failed to read register 0x%02x, error %d\n",
+			off, ret);
+
+	return ret;
+}
+
+static int mma8450_write(struct mma8450 *m, unsigned off, u8 v)
+{
+	struct i2c_client *c = m->client;
+	int error;
+
+	error = i2c_smbus_write_byte_data(c, off, v);
+	if (error < 0) {
+		dev_err(&c->dev,
+			"failed to write to register 0x%02x, error %d\n",
+			off, error);
+		return error;
+	}
+
+	return 0;
+}
+
+static int mma8450_read_block(struct mma8450 *m, unsigned off,
+			      u8 *buf, size_t size)
+{
+	struct i2c_client *c = m->client;
+	int err;
+
+	err = i2c_smbus_read_i2c_block_data(c, off, size, buf);
+	if (err < 0) {
+		dev_err(&c->dev,
+			"failed to read block data at 0x%02x, error %d\n",
+			MMA8450_OUT_X_LSB, err);
+		return err;
+	}
+
+	return 0;
+}
+
+static void mma8450_poll(struct input_polled_dev *dev)
+{
+	struct mma8450 *m = dev->private;
+	int x, y, z;
+	int ret;
+	u8 buf[6];
+
+	ret = mma8450_read(m, MMA8450_STATUS);
+	if (ret < 0)
+		return;
+
+	if (!(ret & MMA8450_STATUS_ZXYDR))
+		return;
+
+	ret = mma8450_read_block(m, MMA8450_OUT_X_LSB, buf, sizeof(buf));
+	if (ret < 0)
+		return;
+
+	x = ((int)(s8)buf[1] << 4) | (buf[0] & 0xf);
+	y = ((int)(s8)buf[3] << 4) | (buf[2] & 0xf);
+	z = ((int)(s8)buf[5] << 4) | (buf[4] & 0xf);
+
+	input_report_abs(dev->input, ABS_X, x);
+	input_report_abs(dev->input, ABS_Y, y);
+	input_report_abs(dev->input, ABS_Z, z);
+	input_sync(dev->input);
+}
+
+/* Initialize the MMA8450 chip */
+static void mma8450_open(struct input_polled_dev *dev)
+{
+	struct mma8450 *m = dev->private;
+	int err;
+
+	/* enable all events from X/Y/Z, no FIFO */
+	err = mma8450_write(m, MMA8450_XYZ_DATA_CFG, 0x07);
+	if (err)
+		return;
+
+	/*
+	 * Sleep mode poll rate - 50Hz
+	 * System output data rate - 400Hz
+	 * Full scale selection - Active, +/- 2G
+	 */
+	err = mma8450_write(m, MMA8450_CTRL_REG1, 0x01);
+	if (err < 0)
+		return;
+
+	msleep(MODE_CHANGE_DELAY_MS);
+}
+
+static void mma8450_close(struct input_polled_dev *dev)
+{
+	struct mma8450 *m = dev->private;
+
+	mma8450_write(m, MMA8450_CTRL_REG1, 0x00);
+	mma8450_write(m, MMA8450_CTRL_REG2, 0x01);
+}
+
+/*
+ * I2C init/probing/exit functions
+ */
+static int mma8450_probe(struct i2c_client *c,
+				   const struct i2c_device_id *id)
+{
+	struct input_polled_dev *idev;
+	struct mma8450 *m;
+	int err;
+
+	m = kzalloc(sizeof(struct mma8450), GFP_KERNEL);
+	idev = input_allocate_polled_device();
+	if (!m || !idev) {
+		err = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	m->client = c;
+	m->idev = idev;
+
+	idev->private		= m;
+	idev->input->name	= MMA8450_DRV_NAME;
+	idev->input->id.bustype	= BUS_I2C;
+	idev->poll		= mma8450_poll;
+	idev->poll_interval	= POLL_INTERVAL;
+	idev->poll_interval_max	= POLL_INTERVAL_MAX;
+	idev->open		= mma8450_open;
+	idev->close		= mma8450_close;
+
+	__set_bit(EV_ABS, idev->input->evbit);
+	input_set_abs_params(idev->input, ABS_X, -2048, 2047, 32, 32);
+	input_set_abs_params(idev->input, ABS_Y, -2048, 2047, 32, 32);
+	input_set_abs_params(idev->input, ABS_Z, -2048, 2047, 32, 32);
+
+	err = input_register_polled_device(idev);
+	if (err) {
+		dev_err(&c->dev, "failed to register polled input device\n");
+		goto err_free_mem;
+	}
+
+	return 0;
+
+err_free_mem:
+	input_free_polled_device(idev);
+	kfree(m);
+	return err;
+}
+
+static int mma8450_remove(struct i2c_client *c)
+{
+	struct mma8450 *m = i2c_get_clientdata(c);
+	struct input_polled_dev *idev = m->idev;
+
+	input_unregister_polled_device(idev);
+	input_free_polled_device(idev);
+	kfree(m);
+
+	return 0;
+}
+
+static const struct i2c_device_id mma8450_id[] = {
+	{ MMA8450_DRV_NAME, 0 },
+	{ },
+};
+MODULE_DEVICE_TABLE(i2c, mma8450_id);
+
+static const struct of_device_id mma8450_dt_ids[] = {
+	{ .compatible = "fsl,mma8450", },
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, mma8450_dt_ids);
+
+static struct i2c_driver mma8450_driver = {
+	.driver = {
+		.name	= MMA8450_DRV_NAME,
+		.owner	= THIS_MODULE,
+		.of_match_table = mma8450_dt_ids,
+	},
+	.probe		= mma8450_probe,
+	.remove		= mma8450_remove,
+	.id_table	= mma8450_id,
+};
+
+module_i2c_driver(mma8450_driver);
+
+MODULE_AUTHOR("Freescale Semiconductor, Inc.");
+MODULE_DESCRIPTION("MMA8450 3-Axis Accelerometer Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/mpu3050.c b/drivers/input/misc/mpu3050.c
new file mode 100644
index 00000000..dce0d959
--- /dev/null
+++ b/drivers/input/misc/mpu3050.c
@@ -0,0 +1,482 @@
+/*
+ * MPU3050 Tri-axis gyroscope driver
+ *
+ * Copyright (C) 2011 Wistron Co.Ltd
+ * Joseph Lai <joseph_lai@wistron.com>
+ *
+ * Trimmed down by Alan Cox <alan@linux.intel.com> to produce this version
+ *
+ * This is a 'lite' version of the driver, while we consider the right way
+ * to present the other features to user space. In particular it requires the
+ * device has an IRQ, and it only provides an input interface, so is not much
+ * use for device orientation. A fuller version is available from the Meego
+ * tree.
+ *
+ * This program is based on bma023.c.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/mutex.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/pm_runtime.h>
+
+#define MPU3050_CHIP_ID		0x69
+
+#define MPU3050_AUTO_DELAY	1000
+
+#define MPU3050_MIN_VALUE	-32768
+#define MPU3050_MAX_VALUE	32767
+
+#define MPU3050_DEFAULT_POLL_INTERVAL	200
+#define MPU3050_DEFAULT_FS_RANGE	3
+
+/* Register map */
+#define MPU3050_CHIP_ID_REG	0x00
+#define MPU3050_SMPLRT_DIV	0x15
+#define MPU3050_DLPF_FS_SYNC	0x16
+#define MPU3050_INT_CFG		0x17
+#define MPU3050_XOUT_H		0x1D
+#define MPU3050_PWR_MGM		0x3E
+#define MPU3050_PWR_MGM_POS	6
+
+/* Register bits */
+
+/* DLPF_FS_SYNC */
+#define MPU3050_EXT_SYNC_NONE		0x00
+#define MPU3050_EXT_SYNC_TEMP		0x20
+#define MPU3050_EXT_SYNC_GYROX		0x40
+#define MPU3050_EXT_SYNC_GYROY		0x60
+#define MPU3050_EXT_SYNC_GYROZ		0x80
+#define MPU3050_EXT_SYNC_ACCELX	0xA0
+#define MPU3050_EXT_SYNC_ACCELY	0xC0
+#define MPU3050_EXT_SYNC_ACCELZ	0xE0
+#define MPU3050_EXT_SYNC_MASK		0xE0
+#define MPU3050_FS_250DPS		0x00
+#define MPU3050_FS_500DPS		0x08
+#define MPU3050_FS_1000DPS		0x10
+#define MPU3050_FS_2000DPS		0x18
+#define MPU3050_FS_MASK		0x18
+#define MPU3050_DLPF_CFG_256HZ_NOLPF2	0x00
+#define MPU3050_DLPF_CFG_188HZ		0x01
+#define MPU3050_DLPF_CFG_98HZ		0x02
+#define MPU3050_DLPF_CFG_42HZ		0x03
+#define MPU3050_DLPF_CFG_20HZ		0x04
+#define MPU3050_DLPF_CFG_10HZ		0x05
+#define MPU3050_DLPF_CFG_5HZ		0x06
+#define MPU3050_DLPF_CFG_2100HZ_NOLPF	0x07
+#define MPU3050_DLPF_CFG_MASK		0x07
+/* INT_CFG */
+#define MPU3050_RAW_RDY_EN		0x01
+#define MPU3050_MPU_RDY_EN		0x02
+#define MPU3050_LATCH_INT_EN		0x04
+/* PWR_MGM */
+#define MPU3050_PWR_MGM_PLL_X		0x01
+#define MPU3050_PWR_MGM_PLL_Y		0x02
+#define MPU3050_PWR_MGM_PLL_Z		0x03
+#define MPU3050_PWR_MGM_CLKSEL		0x07
+#define MPU3050_PWR_MGM_STBY_ZG	0x08
+#define MPU3050_PWR_MGM_STBY_YG	0x10
+#define MPU3050_PWR_MGM_STBY_XG	0x20
+#define MPU3050_PWR_MGM_SLEEP		0x40
+#define MPU3050_PWR_MGM_RESET		0x80
+#define MPU3050_PWR_MGM_MASK		0x40
+
+struct axis_data {
+	s16 x;
+	s16 y;
+	s16 z;
+};
+
+struct mpu3050_sensor {
+	struct i2c_client *client;
+	struct device *dev;
+	struct input_dev *idev;
+};
+
+/**
+ *	mpu3050_xyz_read_reg	-	read the axes values
+ *	@buffer: provide register addr and get register
+ *	@length: length of register
+ *
+ *	Reads the register values in one transaction or returns a negative
+ *	error code on failure.
+ */
+static int mpu3050_xyz_read_reg(struct i2c_client *client,
+			       u8 *buffer, int length)
+{
+	/*
+	 * Annoying we can't make this const because the i2c layer doesn't
+	 * declare input buffers const.
+	 */
+	char cmd = MPU3050_XOUT_H;
+	struct i2c_msg msg[] = {
+		{
+			.addr = client->addr,
+			.flags = 0,
+			.len = 1,
+			.buf = &cmd,
+		},
+		{
+			.addr = client->addr,
+			.flags = I2C_M_RD,
+			.len = length,
+			.buf = buffer,
+		},
+	};
+
+	return i2c_transfer(client->adapter, msg, 2);
+}
+
+/**
+ *	mpu3050_read_xyz	-	get co-ordinates from device
+ *	@client: i2c address of sensor
+ *	@coords: co-ordinates to update
+ *
+ *	Return the converted X Y and Z co-ordinates from the sensor device
+ */
+static void mpu3050_read_xyz(struct i2c_client *client,
+			     struct axis_data *coords)
+{
+	u16 buffer[3];
+
+	mpu3050_xyz_read_reg(client, (u8 *)buffer, 6);
+	coords->x = be16_to_cpu(buffer[0]);
+	coords->y = be16_to_cpu(buffer[1]);
+	coords->z = be16_to_cpu(buffer[2]);
+	dev_dbg(&client->dev, "%s: x %d, y %d, z %d\n", __func__,
+					coords->x, coords->y, coords->z);
+}
+
+/**
+ *	mpu3050_set_power_mode	-	set the power mode
+ *	@client: i2c client for the sensor
+ *	@val: value to switch on/off of power, 1: normal power, 0: low power
+ *
+ *	Put device to normal-power mode or low-power mode.
+ */
+static void mpu3050_set_power_mode(struct i2c_client *client, u8 val)
+{
+	u8 value;
+
+	value = i2c_smbus_read_byte_data(client, MPU3050_PWR_MGM);
+	value = (value & ~MPU3050_PWR_MGM_MASK) |
+		(((val << MPU3050_PWR_MGM_POS) & MPU3050_PWR_MGM_MASK) ^
+		 MPU3050_PWR_MGM_MASK);
+	i2c_smbus_write_byte_data(client, MPU3050_PWR_MGM, value);
+}
+
+/**
+ *	mpu3050_input_open	-	called on input event open
+ *	@input: input dev of opened device
+ *
+ *	The input layer calls this function when input event is opened. The
+ *	function will push the device to resume. Then, the device is ready
+ *	to provide data.
+ */
+static int mpu3050_input_open(struct input_dev *input)
+{
+	struct mpu3050_sensor *sensor = input_get_drvdata(input);
+	int error;
+
+	pm_runtime_get(sensor->dev);
+
+	/* Enable interrupts */
+	error = i2c_smbus_write_byte_data(sensor->client, MPU3050_INT_CFG,
+					  MPU3050_LATCH_INT_EN |
+					  MPU3050_RAW_RDY_EN |
+					  MPU3050_MPU_RDY_EN);
+	if (error < 0) {
+		pm_runtime_put(sensor->dev);
+		return error;
+	}
+
+	return 0;
+}
+
+/**
+ *	mpu3050_input_close	-	called on input event close
+ *	@input: input dev of closed device
+ *
+ *	The input layer calls this function when input event is closed. The
+ *	function will push the device to suspend.
+ */
+static void mpu3050_input_close(struct input_dev *input)
+{
+	struct mpu3050_sensor *sensor = input_get_drvdata(input);
+
+	pm_runtime_put(sensor->dev);
+}
+
+/**
+ *	mpu3050_interrupt_thread	-	handle an IRQ
+ *	@irq: interrupt numner
+ *	@data: the sensor
+ *
+ *	Called by the kernel single threaded after an interrupt occurs. Read
+ *	the sensor data and generate an input event for it.
+ */
+static irqreturn_t mpu3050_interrupt_thread(int irq, void *data)
+{
+	struct mpu3050_sensor *sensor = data;
+	struct axis_data axis;
+
+	mpu3050_read_xyz(sensor->client, &axis);
+
+	input_report_abs(sensor->idev, ABS_X, axis.x);
+	input_report_abs(sensor->idev, ABS_Y, axis.y);
+	input_report_abs(sensor->idev, ABS_Z, axis.z);
+	input_sync(sensor->idev);
+
+	return IRQ_HANDLED;
+}
+
+/**
+ *	mpu3050_hw_init	-	initialize hardware
+ *	@sensor: the sensor
+ *
+ *	Called during device probe; configures the sampling method.
+ */
+static int mpu3050_hw_init(struct mpu3050_sensor *sensor)
+{
+	struct i2c_client *client = sensor->client;
+	int ret;
+	u8 reg;
+
+	/* Reset */
+	ret = i2c_smbus_write_byte_data(client, MPU3050_PWR_MGM,
+					MPU3050_PWR_MGM_RESET);
+	if (ret < 0)
+		return ret;
+
+	ret = i2c_smbus_read_byte_data(client, MPU3050_PWR_MGM);
+	if (ret < 0)
+		return ret;
+
+	ret &= ~MPU3050_PWR_MGM_CLKSEL;
+	ret |= MPU3050_PWR_MGM_PLL_Z;
+	ret = i2c_smbus_write_byte_data(client, MPU3050_PWR_MGM, ret);
+	if (ret < 0)
+		return ret;
+
+	/* Output frequency divider. The poll interval */
+	ret = i2c_smbus_write_byte_data(client, MPU3050_SMPLRT_DIV,
+					MPU3050_DEFAULT_POLL_INTERVAL - 1);
+	if (ret < 0)
+		return ret;
+
+	/* Set low pass filter and full scale */
+	reg = MPU3050_DEFAULT_FS_RANGE;
+	reg |= MPU3050_DLPF_CFG_42HZ << 3;
+	reg |= MPU3050_EXT_SYNC_NONE << 5;
+	ret = i2c_smbus_write_byte_data(client, MPU3050_DLPF_FS_SYNC, reg);
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+/**
+ *	mpu3050_probe	-	device detection callback
+ *	@client: i2c client of found device
+ *	@id: id match information
+ *
+ *	The I2C layer calls us when it believes a sensor is present at this
+ *	address. Probe to see if this is correct and to validate the device.
+ *
+ *	If present install the relevant sysfs interfaces and input device.
+ */
+static int mpu3050_probe(struct i2c_client *client,
+				   const struct i2c_device_id *id)
+{
+	struct mpu3050_sensor *sensor;
+	struct input_dev *idev;
+	int ret;
+	int error;
+
+	sensor = kzalloc(sizeof(struct mpu3050_sensor), GFP_KERNEL);
+	idev = input_allocate_device();
+	if (!sensor || !idev) {
+		dev_err(&client->dev, "failed to allocate driver data\n");
+		error = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	sensor->client = client;
+	sensor->dev = &client->dev;
+	sensor->idev = idev;
+
+	mpu3050_set_power_mode(client, 1);
+	msleep(10);
+
+	ret = i2c_smbus_read_byte_data(client, MPU3050_CHIP_ID_REG);
+	if (ret < 0) {
+		dev_err(&client->dev, "failed to detect device\n");
+		error = -ENXIO;
+		goto err_free_mem;
+	}
+
+	if (ret != MPU3050_CHIP_ID) {
+		dev_err(&client->dev, "unsupported chip id\n");
+		error = -ENXIO;
+		goto err_free_mem;
+	}
+
+	idev->name = "MPU3050";
+	idev->id.bustype = BUS_I2C;
+	idev->dev.parent = &client->dev;
+
+	idev->open = mpu3050_input_open;
+	idev->close = mpu3050_input_close;
+
+	__set_bit(EV_ABS, idev->evbit);
+	input_set_abs_params(idev, ABS_X,
+			     MPU3050_MIN_VALUE, MPU3050_MAX_VALUE, 0, 0);
+	input_set_abs_params(idev, ABS_Y,
+			     MPU3050_MIN_VALUE, MPU3050_MAX_VALUE, 0, 0);
+	input_set_abs_params(idev, ABS_Z,
+			     MPU3050_MIN_VALUE, MPU3050_MAX_VALUE, 0, 0);
+
+	input_set_drvdata(idev, sensor);
+
+	pm_runtime_set_active(&client->dev);
+
+	error = mpu3050_hw_init(sensor);
+	if (error)
+		goto err_pm_set_suspended;
+
+	error = request_threaded_irq(client->irq,
+				     NULL, mpu3050_interrupt_thread,
+				     IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+				     "mpu3050", sensor);
+	if (error) {
+		dev_err(&client->dev,
+			"can't get IRQ %d, error %d\n", client->irq, error);
+		goto err_pm_set_suspended;
+	}
+
+	error = input_register_device(idev);
+	if (error) {
+		dev_err(&client->dev, "failed to register input device\n");
+		goto err_free_irq;
+	}
+
+	pm_runtime_enable(&client->dev);
+	pm_runtime_set_autosuspend_delay(&client->dev, MPU3050_AUTO_DELAY);
+
+	return 0;
+
+err_free_irq:
+	free_irq(client->irq, sensor);
+err_pm_set_suspended:
+	pm_runtime_set_suspended(&client->dev);
+err_free_mem:
+	input_free_device(idev);
+	kfree(sensor);
+	return error;
+}
+
+/**
+ *	mpu3050_remove	-	remove a sensor
+ *	@client: i2c client of sensor being removed
+ *
+ *	Our sensor is going away, clean up the resources.
+ */
+static int mpu3050_remove(struct i2c_client *client)
+{
+	struct mpu3050_sensor *sensor = i2c_get_clientdata(client);
+
+	pm_runtime_disable(&client->dev);
+	pm_runtime_set_suspended(&client->dev);
+
+	free_irq(client->irq, sensor);
+	input_unregister_device(sensor->idev);
+	kfree(sensor);
+
+	return 0;
+}
+
+#ifdef CONFIG_PM
+/**
+ *	mpu3050_suspend		-	called on device suspend
+ *	@dev: device being suspended
+ *
+ *	Put the device into sleep mode before we suspend the machine.
+ */
+static int mpu3050_suspend(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+
+	mpu3050_set_power_mode(client, 0);
+
+	return 0;
+}
+
+/**
+ *	mpu3050_resume		-	called on device resume
+ *	@dev: device being resumed
+ *
+ *	Put the device into powered mode on resume.
+ */
+static int mpu3050_resume(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+
+	mpu3050_set_power_mode(client, 1);
+	msleep(100);  /* wait for gyro chip resume */
+
+	return 0;
+}
+#endif
+
+static UNIVERSAL_DEV_PM_OPS(mpu3050_pm, mpu3050_suspend, mpu3050_resume, NULL);
+
+static const struct i2c_device_id mpu3050_ids[] = {
+	{ "mpu3050", 0 },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, mpu3050_ids);
+
+static const struct of_device_id mpu3050_of_match[] = {
+	{ .compatible = "invn,mpu3050", },
+	{ },
+};
+MODULE_DEVICE_TABLE(of, mpu3050_of_match);
+
+static struct i2c_driver mpu3050_i2c_driver = {
+	.driver	= {
+		.name	= "mpu3050",
+		.owner	= THIS_MODULE,
+		.pm	= &mpu3050_pm,
+		.of_match_table = mpu3050_of_match,
+	},
+	.probe		= mpu3050_probe,
+	.remove		= mpu3050_remove,
+	.id_table	= mpu3050_ids,
+};
+
+module_i2c_driver(mpu3050_i2c_driver);
+
+MODULE_AUTHOR("Wistron Corp.");
+MODULE_DESCRIPTION("MPU3050 Tri-axis gyroscope driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/pcap_keys.c b/drivers/input/misc/pcap_keys.c
new file mode 100644
index 00000000..40ac9a5a
--- /dev/null
+++ b/drivers/input/misc/pcap_keys.c
@@ -0,0 +1,133 @@
+/*
+ *  Input driver for PCAP events:
+ *   * Power key
+ *   * Headphone button
+ *
+ *  Copyright (c) 2008,2009 Ilya Petrov <ilya.muromec@gmail.com>
+ *
+ *  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/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/mfd/ezx-pcap.h>
+#include <linux/slab.h>
+
+struct pcap_keys {
+	struct pcap_chip *pcap;
+	struct input_dev *input;
+};
+
+/* PCAP2 interrupts us on keypress */
+static irqreturn_t pcap_keys_handler(int irq, void *_pcap_keys)
+{
+	struct pcap_keys *pcap_keys = _pcap_keys;
+	int pirq = irq_to_pcap(pcap_keys->pcap, irq);
+	u32 pstat;
+
+	ezx_pcap_read(pcap_keys->pcap, PCAP_REG_PSTAT, &pstat);
+	pstat &= 1 << pirq;
+
+	switch (pirq) {
+	case PCAP_IRQ_ONOFF:
+		input_report_key(pcap_keys->input, KEY_POWER, !pstat);
+		break;
+	case PCAP_IRQ_MIC:
+		input_report_key(pcap_keys->input, KEY_HP, !pstat);
+		break;
+	}
+
+	input_sync(pcap_keys->input);
+
+	return IRQ_HANDLED;
+}
+
+static int pcap_keys_probe(struct platform_device *pdev)
+{
+	int err = -ENOMEM;
+	struct pcap_keys *pcap_keys;
+	struct input_dev *input_dev;
+
+	pcap_keys = kmalloc(sizeof(struct pcap_keys), GFP_KERNEL);
+	if (!pcap_keys)
+		return err;
+
+	pcap_keys->pcap = dev_get_drvdata(pdev->dev.parent);
+
+	input_dev = input_allocate_device();
+	if (!input_dev)
+		goto fail;
+
+	pcap_keys->input = input_dev;
+
+	platform_set_drvdata(pdev, pcap_keys);
+	input_dev->name = pdev->name;
+	input_dev->phys = "pcap-keys/input0";
+	input_dev->id.bustype = BUS_HOST;
+	input_dev->dev.parent = &pdev->dev;
+
+	__set_bit(EV_KEY, input_dev->evbit);
+	__set_bit(KEY_POWER, input_dev->keybit);
+	__set_bit(KEY_HP, input_dev->keybit);
+
+	err = input_register_device(input_dev);
+	if (err)
+		goto fail_allocate;
+
+	err = request_irq(pcap_to_irq(pcap_keys->pcap, PCAP_IRQ_ONOFF),
+			pcap_keys_handler, 0, "Power key", pcap_keys);
+	if (err)
+		goto fail_register;
+
+	err = request_irq(pcap_to_irq(pcap_keys->pcap, PCAP_IRQ_MIC),
+			pcap_keys_handler, 0, "Headphone button", pcap_keys);
+	if (err)
+		goto fail_pwrkey;
+
+	return 0;
+
+fail_pwrkey:
+	free_irq(pcap_to_irq(pcap_keys->pcap, PCAP_IRQ_ONOFF), pcap_keys);
+fail_register:
+	input_unregister_device(input_dev);
+	goto fail;
+fail_allocate:
+	input_free_device(input_dev);
+fail:
+	kfree(pcap_keys);
+	return err;
+}
+
+static int pcap_keys_remove(struct platform_device *pdev)
+{
+	struct pcap_keys *pcap_keys = platform_get_drvdata(pdev);
+
+	free_irq(pcap_to_irq(pcap_keys->pcap, PCAP_IRQ_ONOFF), pcap_keys);
+	free_irq(pcap_to_irq(pcap_keys->pcap, PCAP_IRQ_MIC), pcap_keys);
+
+	input_unregister_device(pcap_keys->input);
+	kfree(pcap_keys);
+
+	return 0;
+}
+
+static struct platform_driver pcap_keys_device_driver = {
+	.probe		= pcap_keys_probe,
+	.remove		= pcap_keys_remove,
+	.driver		= {
+		.name	= "pcap-keys",
+		.owner	= THIS_MODULE,
+	}
+};
+module_platform_driver(pcap_keys_device_driver);
+
+MODULE_DESCRIPTION("Motorola PCAP2 input events driver");
+MODULE_AUTHOR("Ilya Petrov <ilya.muromec@gmail.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pcap_keys");
diff --git a/drivers/input/misc/pcf50633-input.c b/drivers/input/misc/pcf50633-input.c
new file mode 100644
index 00000000..73b13eba
--- /dev/null
+++ b/drivers/input/misc/pcf50633-input.c
@@ -0,0 +1,121 @@
+/* NXP PCF50633 Input Driver
+ *
+ * (C) 2006-2008 by Openmoko, Inc.
+ * Author: Balaji Rao <balajirrao@openmoko.org>
+ * All rights reserved.
+ *
+ * Broken down from monstrous PCF50633 driver mainly by
+ * Harald Welte, Andy Green and Werner Almesberger
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+
+#include <linux/mfd/pcf50633/core.h>
+
+#define PCF50633_OOCSTAT_ONKEY	0x01
+#define PCF50633_REG_OOCSTAT	0x12
+#define PCF50633_REG_OOCMODE	0x10
+
+struct pcf50633_input {
+	struct pcf50633 *pcf;
+	struct input_dev *input_dev;
+};
+
+static void
+pcf50633_input_irq(int irq, void *data)
+{
+	struct pcf50633_input *input;
+	int onkey_released;
+
+	input = data;
+
+	/* We report only one event depending on the key press status */
+	onkey_released = pcf50633_reg_read(input->pcf, PCF50633_REG_OOCSTAT)
+						& PCF50633_OOCSTAT_ONKEY;
+
+	if (irq == PCF50633_IRQ_ONKEYF && !onkey_released)
+		input_report_key(input->input_dev, KEY_POWER, 1);
+	else if (irq == PCF50633_IRQ_ONKEYR && onkey_released)
+		input_report_key(input->input_dev, KEY_POWER, 0);
+
+	input_sync(input->input_dev);
+}
+
+static int pcf50633_input_probe(struct platform_device *pdev)
+{
+	struct pcf50633_input *input;
+	struct input_dev *input_dev;
+	int ret;
+
+
+	input = kzalloc(sizeof(*input), GFP_KERNEL);
+	if (!input)
+		return -ENOMEM;
+
+	input_dev = input_allocate_device();
+	if (!input_dev) {
+		kfree(input);
+		return -ENOMEM;
+	}
+
+	platform_set_drvdata(pdev, input);
+	input->pcf = dev_to_pcf50633(pdev->dev.parent);
+	input->input_dev = input_dev;
+
+	input_dev->name = "PCF50633 PMU events";
+	input_dev->id.bustype = BUS_I2C;
+	input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_PWR);
+	set_bit(KEY_POWER, input_dev->keybit);
+
+	ret = input_register_device(input_dev);
+	if (ret) {
+		input_free_device(input_dev);
+		kfree(input);
+		return ret;
+	}
+	pcf50633_register_irq(input->pcf, PCF50633_IRQ_ONKEYR,
+				pcf50633_input_irq, input);
+	pcf50633_register_irq(input->pcf, PCF50633_IRQ_ONKEYF,
+				pcf50633_input_irq, input);
+
+	return 0;
+}
+
+static int pcf50633_input_remove(struct platform_device *pdev)
+{
+	struct pcf50633_input *input  = platform_get_drvdata(pdev);
+
+	pcf50633_free_irq(input->pcf, PCF50633_IRQ_ONKEYR);
+	pcf50633_free_irq(input->pcf, PCF50633_IRQ_ONKEYF);
+
+	input_unregister_device(input->input_dev);
+	kfree(input);
+
+	return 0;
+}
+
+static struct platform_driver pcf50633_input_driver = {
+	.driver = {
+		.name = "pcf50633-input",
+	},
+	.probe = pcf50633_input_probe,
+	.remove = pcf50633_input_remove,
+};
+module_platform_driver(pcf50633_input_driver);
+
+MODULE_AUTHOR("Balaji Rao <balajirrao@openmoko.org>");
+MODULE_DESCRIPTION("PCF50633 input driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pcf50633-input");
diff --git a/drivers/input/misc/pcf8574_keypad.c b/drivers/input/misc/pcf8574_keypad.c
new file mode 100644
index 00000000..e3739297
--- /dev/null
+++ b/drivers/input/misc/pcf8574_keypad.c
@@ -0,0 +1,223 @@
+/*
+ * Driver for a keypad w/16 buttons connected to a PCF8574 I2C I/O expander
+ *
+ * Copyright 2005-2008 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+
+#define DRV_NAME "pcf8574_keypad"
+
+static const unsigned char pcf8574_kp_btncode[] = {
+	[0] = KEY_RESERVED,
+	[1] = KEY_ENTER,
+	[2] = KEY_BACKSLASH,
+	[3] = KEY_0,
+	[4] = KEY_RIGHTBRACE,
+	[5] = KEY_C,
+	[6] = KEY_9,
+	[7] = KEY_8,
+	[8] = KEY_7,
+	[9] = KEY_B,
+	[10] = KEY_6,
+	[11] = KEY_5,
+	[12] = KEY_4,
+	[13] = KEY_A,
+	[14] = KEY_3,
+	[15] = KEY_2,
+	[16] = KEY_1
+};
+
+struct kp_data {
+	unsigned short btncode[ARRAY_SIZE(pcf8574_kp_btncode)];
+	struct input_dev *idev;
+	struct i2c_client *client;
+	char name[64];
+	char phys[32];
+	unsigned char laststate;
+};
+
+static short read_state(struct kp_data *lp)
+{
+	unsigned char x, y, a, b;
+
+	i2c_smbus_write_byte(lp->client, 240);
+	x = 0xF & (~(i2c_smbus_read_byte(lp->client) >> 4));
+
+	i2c_smbus_write_byte(lp->client, 15);
+	y = 0xF & (~i2c_smbus_read_byte(lp->client));
+
+	for (a = 0; x > 0; a++)
+		x = x >> 1;
+	for (b = 0; y > 0; b++)
+		y = y >> 1;
+
+	return ((a - 1) * 4) + b;
+}
+
+static irqreturn_t pcf8574_kp_irq_handler(int irq, void *dev_id)
+{
+	struct kp_data *lp = dev_id;
+	unsigned char nextstate = read_state(lp);
+
+	if (lp->laststate != nextstate) {
+		int key_down = nextstate < ARRAY_SIZE(lp->btncode);
+		unsigned short keycode = key_down ?
+			lp->btncode[nextstate] : lp->btncode[lp->laststate];
+
+		input_report_key(lp->idev, keycode, key_down);
+		input_sync(lp->idev);
+
+		lp->laststate = nextstate;
+	}
+
+	return IRQ_HANDLED;
+}
+
+static int pcf8574_kp_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+	int i, ret;
+	struct input_dev *idev;
+	struct kp_data *lp;
+
+	if (i2c_smbus_write_byte(client, 240) < 0) {
+		dev_err(&client->dev, "probe: write fail\n");
+		return -ENODEV;
+	}
+
+	lp = kzalloc(sizeof(*lp), GFP_KERNEL);
+	if (!lp)
+		return -ENOMEM;
+
+	idev = input_allocate_device();
+	if (!idev) {
+		dev_err(&client->dev, "Can't allocate input device\n");
+		ret = -ENOMEM;
+		goto fail_allocate;
+	}
+
+	lp->idev = idev;
+	lp->client = client;
+
+	idev->evbit[0] = BIT_MASK(EV_KEY);
+	idev->keycode = lp->btncode;
+	idev->keycodesize = sizeof(lp->btncode[0]);
+	idev->keycodemax = ARRAY_SIZE(lp->btncode);
+
+	for (i = 0; i < ARRAY_SIZE(pcf8574_kp_btncode); i++) {
+		lp->btncode[i] = pcf8574_kp_btncode[i];
+		__set_bit(lp->btncode[i] & KEY_MAX, idev->keybit);
+	}
+
+	sprintf(lp->name, DRV_NAME);
+	sprintf(lp->phys, "kp_data/input0");
+
+	idev->name = lp->name;
+	idev->phys = lp->phys;
+	idev->id.bustype = BUS_I2C;
+	idev->id.vendor = 0x0001;
+	idev->id.product = 0x0001;
+	idev->id.version = 0x0100;
+
+	lp->laststate = read_state(lp);
+
+	ret = request_threaded_irq(client->irq, NULL, pcf8574_kp_irq_handler,
+				   IRQF_TRIGGER_LOW | IRQF_ONESHOT,
+				   DRV_NAME, lp);
+	if (ret) {
+		dev_err(&client->dev, "IRQ %d is not free\n", client->irq);
+		goto fail_free_device;
+	}
+
+	ret = input_register_device(idev);
+	if (ret) {
+		dev_err(&client->dev, "input_register_device() failed\n");
+		goto fail_free_irq;
+	}
+
+	i2c_set_clientdata(client, lp);
+	return 0;
+
+ fail_free_irq:
+	free_irq(client->irq, lp);
+ fail_free_device:
+	input_free_device(idev);
+ fail_allocate:
+	kfree(lp);
+
+	return ret;
+}
+
+static int pcf8574_kp_remove(struct i2c_client *client)
+{
+	struct kp_data *lp = i2c_get_clientdata(client);
+
+	free_irq(client->irq, lp);
+
+	input_unregister_device(lp->idev);
+	kfree(lp);
+
+	return 0;
+}
+
+#ifdef CONFIG_PM
+static int pcf8574_kp_resume(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+
+	enable_irq(client->irq);
+
+	return 0;
+}
+
+static int pcf8574_kp_suspend(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+
+	disable_irq(client->irq);
+
+	return 0;
+}
+
+static const struct dev_pm_ops pcf8574_kp_pm_ops = {
+	.suspend	= pcf8574_kp_suspend,
+	.resume		= pcf8574_kp_resume,
+};
+
+#else
+# define pcf8574_kp_resume  NULL
+# define pcf8574_kp_suspend NULL
+#endif
+
+static const struct i2c_device_id pcf8574_kp_id[] = {
+	{ DRV_NAME, 0 },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, pcf8574_kp_id);
+
+static struct i2c_driver pcf8574_kp_driver = {
+	.driver = {
+		.name  = DRV_NAME,
+		.owner = THIS_MODULE,
+#ifdef CONFIG_PM
+		.pm = &pcf8574_kp_pm_ops,
+#endif
+	},
+	.probe    = pcf8574_kp_probe,
+	.remove   = pcf8574_kp_remove,
+	.id_table = pcf8574_kp_id,
+};
+
+module_i2c_driver(pcf8574_kp_driver);
+
+MODULE_AUTHOR("Michael Hennerich");
+MODULE_DESCRIPTION("Keypad input driver for 16 keys connected to PCF8574");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/pcspkr.c b/drivers/input/misc/pcspkr.c
new file mode 100644
index 00000000..199db78a
--- /dev/null
+++ b/drivers/input/misc/pcspkr.c
@@ -0,0 +1,138 @@
+/*
+ *  PC Speaker beeper driver for Linux
+ *
+ *  Copyright (c) 2002 Vojtech Pavlik
+ *  Copyright (c) 1992 Orest Zborowski
+ *
+ */
+
+/*
+ * 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/kernel.h>
+#include <linux/module.h>
+#include <linux/i8253.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/platform_device.h>
+#include <linux/timex.h>
+#include <asm/io.h>
+
+MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
+MODULE_DESCRIPTION("PC Speaker beeper driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pcspkr");
+
+static int pcspkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
+{
+	unsigned int count = 0;
+	unsigned long flags;
+
+	if (type != EV_SND)
+		return -1;
+
+	switch (code) {
+		case SND_BELL: if (value) value = 1000;
+		case SND_TONE: break;
+		default: return -1;
+	}
+
+	if (value > 20 && value < 32767)
+		count = PIT_TICK_RATE / value;
+
+	raw_spin_lock_irqsave(&i8253_lock, flags);
+
+	if (count) {
+		/* set command for counter 2, 2 byte write */
+		outb_p(0xB6, 0x43);
+		/* select desired HZ */
+		outb_p(count & 0xff, 0x42);
+		outb((count >> 8) & 0xff, 0x42);
+		/* enable counter 2 */
+		outb_p(inb_p(0x61) | 3, 0x61);
+	} else {
+		/* disable counter 2 */
+		outb(inb_p(0x61) & 0xFC, 0x61);
+	}
+
+	raw_spin_unlock_irqrestore(&i8253_lock, flags);
+
+	return 0;
+}
+
+static int pcspkr_probe(struct platform_device *dev)
+{
+	struct input_dev *pcspkr_dev;
+	int err;
+
+	pcspkr_dev = input_allocate_device();
+	if (!pcspkr_dev)
+		return -ENOMEM;
+
+	pcspkr_dev->name = "PC Speaker";
+	pcspkr_dev->phys = "isa0061/input0";
+	pcspkr_dev->id.bustype = BUS_ISA;
+	pcspkr_dev->id.vendor = 0x001f;
+	pcspkr_dev->id.product = 0x0001;
+	pcspkr_dev->id.version = 0x0100;
+	pcspkr_dev->dev.parent = &dev->dev;
+
+	pcspkr_dev->evbit[0] = BIT_MASK(EV_SND);
+	pcspkr_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
+	pcspkr_dev->event = pcspkr_event;
+
+	err = input_register_device(pcspkr_dev);
+	if (err) {
+		input_free_device(pcspkr_dev);
+		return err;
+	}
+
+	platform_set_drvdata(dev, pcspkr_dev);
+
+	return 0;
+}
+
+static int pcspkr_remove(struct platform_device *dev)
+{
+	struct input_dev *pcspkr_dev = platform_get_drvdata(dev);
+
+	input_unregister_device(pcspkr_dev);
+	platform_set_drvdata(dev, NULL);
+	/* turn off the speaker */
+	pcspkr_event(NULL, EV_SND, SND_BELL, 0);
+
+	return 0;
+}
+
+static int pcspkr_suspend(struct device *dev)
+{
+	pcspkr_event(NULL, EV_SND, SND_BELL, 0);
+
+	return 0;
+}
+
+static void pcspkr_shutdown(struct platform_device *dev)
+{
+	/* turn off the speaker */
+	pcspkr_event(NULL, EV_SND, SND_BELL, 0);
+}
+
+static const struct dev_pm_ops pcspkr_pm_ops = {
+	.suspend = pcspkr_suspend,
+};
+
+static struct platform_driver pcspkr_platform_driver = {
+	.driver		= {
+		.name	= "pcspkr",
+		.owner	= THIS_MODULE,
+		.pm	= &pcspkr_pm_ops,
+	},
+	.probe		= pcspkr_probe,
+	.remove		= pcspkr_remove,
+	.shutdown	= pcspkr_shutdown,
+};
+module_platform_driver(pcspkr_platform_driver);
+
diff --git a/drivers/input/misc/pm8xxx-vibrator.c b/drivers/input/misc/pm8xxx-vibrator.c
new file mode 100644
index 00000000..a9da65e4
--- /dev/null
+++ b/drivers/input/misc/pm8xxx-vibrator.c
@@ -0,0 +1,285 @@
+/* Copyright (c) 2010-2011, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+#include <linux/mfd/pm8xxx/core.h>
+
+#define VIB_DRV			0x4A
+
+#define VIB_DRV_SEL_MASK	0xf8
+#define VIB_DRV_SEL_SHIFT	0x03
+#define VIB_DRV_EN_MANUAL_MASK	0xfc
+
+#define VIB_MAX_LEVEL_mV	(3100)
+#define VIB_MIN_LEVEL_mV	(1200)
+#define VIB_MAX_LEVELS		(VIB_MAX_LEVEL_mV - VIB_MIN_LEVEL_mV)
+
+#define MAX_FF_SPEED		0xff
+
+/**
+ * struct pm8xxx_vib - structure to hold vibrator data
+ * @vib_input_dev: input device supporting force feedback
+ * @work: work structure to set the vibration parameters
+ * @dev: device supporting force feedback
+ * @speed: speed of vibration set from userland
+ * @active: state of vibrator
+ * @level: level of vibration to set in the chip
+ * @reg_vib_drv: VIB_DRV register value
+ */
+struct pm8xxx_vib {
+	struct input_dev *vib_input_dev;
+	struct work_struct work;
+	struct device *dev;
+	int speed;
+	int level;
+	bool active;
+	u8  reg_vib_drv;
+};
+
+/**
+ * pm8xxx_vib_read_u8 - helper to read a byte from pmic chip
+ * @vib: pointer to vibrator structure
+ * @data: placeholder for data to be read
+ * @reg: register address
+ */
+static int pm8xxx_vib_read_u8(struct pm8xxx_vib *vib,
+				 u8 *data, u16 reg)
+{
+	int rc;
+
+	rc = pm8xxx_readb(vib->dev->parent, reg, data);
+	if (rc < 0)
+		dev_warn(vib->dev, "Error reading pm8xxx reg 0x%x(0x%x)\n",
+				reg, rc);
+	return rc;
+}
+
+/**
+ * pm8xxx_vib_write_u8 - helper to write a byte to pmic chip
+ * @vib: pointer to vibrator structure
+ * @data: data to write
+ * @reg: register address
+ */
+static int pm8xxx_vib_write_u8(struct pm8xxx_vib *vib,
+				 u8 data, u16 reg)
+{
+	int rc;
+
+	rc = pm8xxx_writeb(vib->dev->parent, reg, data);
+	if (rc < 0)
+		dev_warn(vib->dev, "Error writing pm8xxx reg 0x%x(0x%x)\n",
+				reg, rc);
+	return rc;
+}
+
+/**
+ * pm8xxx_vib_set - handler to start/stop vibration
+ * @vib: pointer to vibrator structure
+ * @on: state to set
+ */
+static int pm8xxx_vib_set(struct pm8xxx_vib *vib, bool on)
+{
+	int rc;
+	u8 val = vib->reg_vib_drv;
+
+	if (on)
+		val |= ((vib->level << VIB_DRV_SEL_SHIFT) & VIB_DRV_SEL_MASK);
+	else
+		val &= ~VIB_DRV_SEL_MASK;
+
+	rc = pm8xxx_vib_write_u8(vib, val, VIB_DRV);
+	if (rc < 0)
+		return rc;
+
+	vib->reg_vib_drv = val;
+	return 0;
+}
+
+/**
+ * pm8xxx_work_handler - worker to set vibration level
+ * @work: pointer to work_struct
+ */
+static void pm8xxx_work_handler(struct work_struct *work)
+{
+	struct pm8xxx_vib *vib = container_of(work, struct pm8xxx_vib, work);
+	int rc;
+	u8 val;
+
+	rc = pm8xxx_vib_read_u8(vib, &val, VIB_DRV);
+	if (rc < 0)
+		return;
+
+	/*
+	 * pmic vibrator supports voltage ranges from 1.2 to 3.1V, so
+	 * scale the level to fit into these ranges.
+	 */
+	if (vib->speed) {
+		vib->active = true;
+		vib->level = ((VIB_MAX_LEVELS * vib->speed) / MAX_FF_SPEED) +
+						VIB_MIN_LEVEL_mV;
+		vib->level /= 100;
+	} else {
+		vib->active = false;
+		vib->level = VIB_MIN_LEVEL_mV / 100;
+	}
+
+	pm8xxx_vib_set(vib, vib->active);
+}
+
+/**
+ * pm8xxx_vib_close - callback of input close callback
+ * @dev: input device pointer
+ *
+ * Turns off the vibrator.
+ */
+static void pm8xxx_vib_close(struct input_dev *dev)
+{
+	struct pm8xxx_vib *vib = input_get_drvdata(dev);
+
+	cancel_work_sync(&vib->work);
+	if (vib->active)
+		pm8xxx_vib_set(vib, false);
+}
+
+/**
+ * pm8xxx_vib_play_effect - function to handle vib effects.
+ * @dev: input device pointer
+ * @data: data of effect
+ * @effect: effect to play
+ *
+ * Currently this driver supports only rumble effects.
+ */
+static int pm8xxx_vib_play_effect(struct input_dev *dev, void *data,
+				  struct ff_effect *effect)
+{
+	struct pm8xxx_vib *vib = input_get_drvdata(dev);
+
+	vib->speed = effect->u.rumble.strong_magnitude >> 8;
+	if (!vib->speed)
+		vib->speed = effect->u.rumble.weak_magnitude >> 9;
+
+	schedule_work(&vib->work);
+
+	return 0;
+}
+
+static int pm8xxx_vib_probe(struct platform_device *pdev)
+
+{
+	struct pm8xxx_vib *vib;
+	struct input_dev *input_dev;
+	int error;
+	u8 val;
+
+	vib = kzalloc(sizeof(*vib), GFP_KERNEL);
+	input_dev = input_allocate_device();
+	if (!vib || !input_dev) {
+		dev_err(&pdev->dev, "couldn't allocate memory\n");
+		error = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	INIT_WORK(&vib->work, pm8xxx_work_handler);
+	vib->dev = &pdev->dev;
+	vib->vib_input_dev = input_dev;
+
+	/* operate in manual mode */
+	error = pm8xxx_vib_read_u8(vib, &val, VIB_DRV);
+	if (error < 0)
+		goto err_free_mem;
+	val &= ~VIB_DRV_EN_MANUAL_MASK;
+	error = pm8xxx_vib_write_u8(vib, val, VIB_DRV);
+	if (error < 0)
+		goto err_free_mem;
+
+	vib->reg_vib_drv = val;
+
+	input_dev->name = "pm8xxx_vib_ffmemless";
+	input_dev->id.version = 1;
+	input_dev->dev.parent = &pdev->dev;
+	input_dev->close = pm8xxx_vib_close;
+	input_set_drvdata(input_dev, vib);
+	input_set_capability(vib->vib_input_dev, EV_FF, FF_RUMBLE);
+
+	error = input_ff_create_memless(input_dev, NULL,
+					pm8xxx_vib_play_effect);
+	if (error) {
+		dev_err(&pdev->dev,
+			"couldn't register vibrator as FF device\n");
+		goto err_free_mem;
+	}
+
+	error = input_register_device(input_dev);
+	if (error) {
+		dev_err(&pdev->dev, "couldn't register input device\n");
+		goto err_destroy_memless;
+	}
+
+	platform_set_drvdata(pdev, vib);
+	return 0;
+
+err_destroy_memless:
+	input_ff_destroy(input_dev);
+err_free_mem:
+	input_free_device(input_dev);
+	kfree(vib);
+
+	return error;
+}
+
+static int pm8xxx_vib_remove(struct platform_device *pdev)
+{
+	struct pm8xxx_vib *vib = platform_get_drvdata(pdev);
+
+	input_unregister_device(vib->vib_input_dev);
+	kfree(vib);
+
+	platform_set_drvdata(pdev, NULL);
+
+	return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int pm8xxx_vib_suspend(struct device *dev)
+{
+	struct pm8xxx_vib *vib = dev_get_drvdata(dev);
+
+	/* Turn off the vibrator */
+	pm8xxx_vib_set(vib, false);
+
+	return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(pm8xxx_vib_pm_ops, pm8xxx_vib_suspend, NULL);
+
+static struct platform_driver pm8xxx_vib_driver = {
+	.probe		= pm8xxx_vib_probe,
+	.remove		= pm8xxx_vib_remove,
+	.driver		= {
+		.name	= "pm8xxx-vib",
+		.owner	= THIS_MODULE,
+		.pm	= &pm8xxx_vib_pm_ops,
+	},
+};
+module_platform_driver(pm8xxx_vib_driver);
+
+MODULE_ALIAS("platform:pm8xxx_vib");
+MODULE_DESCRIPTION("PMIC8xxx vibrator driver based on ff-memless framework");
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Amy Maloche <amaloche@codeaurora.org>");
diff --git a/drivers/input/misc/pmic8xxx-pwrkey.c b/drivers/input/misc/pmic8xxx-pwrkey.c
new file mode 100644
index 00000000..4b811be7
--- /dev/null
+++ b/drivers/input/misc/pmic8xxx-pwrkey.c
@@ -0,0 +1,221 @@
+/* Copyright (c) 2010-2011, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/log2.h>
+
+#include <linux/mfd/pm8xxx/core.h>
+#include <linux/input/pmic8xxx-pwrkey.h>
+
+#define PON_CNTL_1 0x1C
+#define PON_CNTL_PULL_UP BIT(7)
+#define PON_CNTL_TRIG_DELAY_MASK (0x7)
+
+/**
+ * struct pmic8xxx_pwrkey - pmic8xxx pwrkey information
+ * @key_press_irq: key press irq number
+ */
+struct pmic8xxx_pwrkey {
+	struct input_dev *pwr;
+	int key_press_irq;
+};
+
+static irqreturn_t pwrkey_press_irq(int irq, void *_pwrkey)
+{
+	struct pmic8xxx_pwrkey *pwrkey = _pwrkey;
+
+	input_report_key(pwrkey->pwr, KEY_POWER, 1);
+	input_sync(pwrkey->pwr);
+
+	return IRQ_HANDLED;
+}
+
+static irqreturn_t pwrkey_release_irq(int irq, void *_pwrkey)
+{
+	struct pmic8xxx_pwrkey *pwrkey = _pwrkey;
+
+	input_report_key(pwrkey->pwr, KEY_POWER, 0);
+	input_sync(pwrkey->pwr);
+
+	return IRQ_HANDLED;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int pmic8xxx_pwrkey_suspend(struct device *dev)
+{
+	struct pmic8xxx_pwrkey *pwrkey = dev_get_drvdata(dev);
+
+	if (device_may_wakeup(dev))
+		enable_irq_wake(pwrkey->key_press_irq);
+
+	return 0;
+}
+
+static int pmic8xxx_pwrkey_resume(struct device *dev)
+{
+	struct pmic8xxx_pwrkey *pwrkey = dev_get_drvdata(dev);
+
+	if (device_may_wakeup(dev))
+		disable_irq_wake(pwrkey->key_press_irq);
+
+	return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(pm8xxx_pwr_key_pm_ops,
+		pmic8xxx_pwrkey_suspend, pmic8xxx_pwrkey_resume);
+
+static int pmic8xxx_pwrkey_probe(struct platform_device *pdev)
+{
+	struct input_dev *pwr;
+	int key_release_irq = platform_get_irq(pdev, 0);
+	int key_press_irq = platform_get_irq(pdev, 1);
+	int err;
+	unsigned int delay;
+	u8 pon_cntl;
+	struct pmic8xxx_pwrkey *pwrkey;
+	const struct pm8xxx_pwrkey_platform_data *pdata =
+					dev_get_platdata(&pdev->dev);
+
+	if (!pdata) {
+		dev_err(&pdev->dev, "power key platform data not supplied\n");
+		return -EINVAL;
+	}
+
+	if (pdata->kpd_trigger_delay_us > 62500) {
+		dev_err(&pdev->dev, "invalid power key trigger delay\n");
+		return -EINVAL;
+	}
+
+	pwrkey = kzalloc(sizeof(*pwrkey), GFP_KERNEL);
+	if (!pwrkey)
+		return -ENOMEM;
+
+	pwr = input_allocate_device();
+	if (!pwr) {
+		dev_dbg(&pdev->dev, "Can't allocate power button\n");
+		err = -ENOMEM;
+		goto free_pwrkey;
+	}
+
+	input_set_capability(pwr, EV_KEY, KEY_POWER);
+
+	pwr->name = "pmic8xxx_pwrkey";
+	pwr->phys = "pmic8xxx_pwrkey/input0";
+	pwr->dev.parent = &pdev->dev;
+
+	delay = (pdata->kpd_trigger_delay_us << 10) / USEC_PER_SEC;
+	delay = 1 + ilog2(delay);
+
+	err = pm8xxx_readb(pdev->dev.parent, PON_CNTL_1, &pon_cntl);
+	if (err < 0) {
+		dev_err(&pdev->dev, "failed reading PON_CNTL_1 err=%d\n", err);
+		goto free_input_dev;
+	}
+
+	pon_cntl &= ~PON_CNTL_TRIG_DELAY_MASK;
+	pon_cntl |= (delay & PON_CNTL_TRIG_DELAY_MASK);
+	if (pdata->pull_up)
+		pon_cntl |= PON_CNTL_PULL_UP;
+	else
+		pon_cntl &= ~PON_CNTL_PULL_UP;
+
+	err = pm8xxx_writeb(pdev->dev.parent, PON_CNTL_1, pon_cntl);
+	if (err < 0) {
+		dev_err(&pdev->dev, "failed writing PON_CNTL_1 err=%d\n", err);
+		goto free_input_dev;
+	}
+
+	err = input_register_device(pwr);
+	if (err) {
+		dev_dbg(&pdev->dev, "Can't register power key: %d\n", err);
+		goto free_input_dev;
+	}
+
+	pwrkey->key_press_irq = key_press_irq;
+	pwrkey->pwr = pwr;
+
+	platform_set_drvdata(pdev, pwrkey);
+
+	err = request_irq(key_press_irq, pwrkey_press_irq,
+		IRQF_TRIGGER_RISING, "pmic8xxx_pwrkey_press", pwrkey);
+	if (err < 0) {
+		dev_dbg(&pdev->dev, "Can't get %d IRQ for pwrkey: %d\n",
+				 key_press_irq, err);
+		goto unreg_input_dev;
+	}
+
+	err = request_irq(key_release_irq, pwrkey_release_irq,
+		 IRQF_TRIGGER_RISING, "pmic8xxx_pwrkey_release", pwrkey);
+	if (err < 0) {
+		dev_dbg(&pdev->dev, "Can't get %d IRQ for pwrkey: %d\n",
+				 key_release_irq, err);
+
+		goto free_press_irq;
+	}
+
+	device_init_wakeup(&pdev->dev, pdata->wakeup);
+
+	return 0;
+
+free_press_irq:
+	free_irq(key_press_irq, NULL);
+unreg_input_dev:
+	platform_set_drvdata(pdev, NULL);
+	input_unregister_device(pwr);
+	pwr = NULL;
+free_input_dev:
+	input_free_device(pwr);
+free_pwrkey:
+	kfree(pwrkey);
+	return err;
+}
+
+static int pmic8xxx_pwrkey_remove(struct platform_device *pdev)
+{
+	struct pmic8xxx_pwrkey *pwrkey = platform_get_drvdata(pdev);
+	int key_release_irq = platform_get_irq(pdev, 0);
+	int key_press_irq = platform_get_irq(pdev, 1);
+
+	device_init_wakeup(&pdev->dev, 0);
+
+	free_irq(key_press_irq, pwrkey);
+	free_irq(key_release_irq, pwrkey);
+	input_unregister_device(pwrkey->pwr);
+	platform_set_drvdata(pdev, NULL);
+	kfree(pwrkey);
+
+	return 0;
+}
+
+static struct platform_driver pmic8xxx_pwrkey_driver = {
+	.probe		= pmic8xxx_pwrkey_probe,
+	.remove		= pmic8xxx_pwrkey_remove,
+	.driver		= {
+		.name	= PM8XXX_PWRKEY_DEV_NAME,
+		.owner	= THIS_MODULE,
+		.pm	= &pm8xxx_pwr_key_pm_ops,
+	},
+};
+module_platform_driver(pmic8xxx_pwrkey_driver);
+
+MODULE_ALIAS("platform:pmic8xxx_pwrkey");
+MODULE_DESCRIPTION("PMIC8XXX Power Key driver");
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Trilok Soni <tsoni@codeaurora.org>");
diff --git a/drivers/input/misc/powermate.c b/drivers/input/misc/powermate.c
new file mode 100644
index 00000000..49c0c3eb
--- /dev/null
+++ b/drivers/input/misc/powermate.c
@@ -0,0 +1,453 @@
+/*
+ * A driver for the Griffin Technology, Inc. "PowerMate" USB controller dial.
+ *
+ * v1.1, (c)2002 William R Sowerbutts <will@sowerbutts.com>
+ *
+ * This device is a anodised aluminium knob which connects over USB. It can measure
+ * clockwise and anticlockwise rotation. The dial also acts as a pushbutton with
+ * a spring for automatic release. The base contains a pair of LEDs which illuminate
+ * the translucent base. It rotates without limit and reports its relative rotation
+ * back to the host when polled by the USB controller.
+ *
+ * Testing with the knob I have has shown that it measures approximately 94 "clicks"
+ * for one full rotation. Testing with my High Speed Rotation Actuator (ok, it was
+ * a variable speed cordless electric drill) has shown that the device can measure
+ * speeds of up to 7 clicks either clockwise or anticlockwise between pollings from
+ * the host. If it counts more than 7 clicks before it is polled, it will wrap back
+ * to zero and start counting again. This was at quite high speed, however, almost
+ * certainly faster than the human hand could turn it. Griffin say that it loses a
+ * pulse or two on a direction change; the granularity is so fine that I never
+ * noticed this in practice.
+ *
+ * The device's microcontroller can be programmed to set the LED to either a constant
+ * intensity, or to a rhythmic pulsing. Several patterns and speeds are available.
+ *
+ * Griffin were very happy to provide documentation and free hardware for development.
+ *
+ * Some userspace tools are available on the web: http://sowerbutts.com/powermate/
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <linux/usb/input.h>
+
+#define POWERMATE_VENDOR	0x077d	/* Griffin Technology, Inc. */
+#define POWERMATE_PRODUCT_NEW	0x0410	/* Griffin PowerMate */
+#define POWERMATE_PRODUCT_OLD	0x04AA	/* Griffin soundKnob */
+
+#define CONTOUR_VENDOR		0x05f3	/* Contour Design, Inc. */
+#define CONTOUR_JOG		0x0240	/* Jog and Shuttle */
+
+/* these are the command codes we send to the device */
+#define SET_STATIC_BRIGHTNESS  0x01
+#define SET_PULSE_ASLEEP       0x02
+#define SET_PULSE_AWAKE        0x03
+#define SET_PULSE_MODE         0x04
+
+/* these refer to bits in the powermate_device's requires_update field. */
+#define UPDATE_STATIC_BRIGHTNESS (1<<0)
+#define UPDATE_PULSE_ASLEEP      (1<<1)
+#define UPDATE_PULSE_AWAKE       (1<<2)
+#define UPDATE_PULSE_MODE        (1<<3)
+
+/* at least two versions of the hardware exist, with differing payload
+   sizes. the first three bytes always contain the "interesting" data in
+   the relevant format. */
+#define POWERMATE_PAYLOAD_SIZE_MAX 6
+#define POWERMATE_PAYLOAD_SIZE_MIN 3
+struct powermate_device {
+	signed char *data;
+	dma_addr_t data_dma;
+	struct urb *irq, *config;
+	struct usb_ctrlrequest *configcr;
+	struct usb_device *udev;
+	struct usb_interface *intf;
+	struct input_dev *input;
+	spinlock_t lock;
+	int static_brightness;
+	int pulse_speed;
+	int pulse_table;
+	int pulse_asleep;
+	int pulse_awake;
+	int requires_update; // physical settings which are out of sync
+	char phys[64];
+};
+
+static char pm_name_powermate[] = "Griffin PowerMate";
+static char pm_name_soundknob[] = "Griffin SoundKnob";
+
+static void powermate_config_complete(struct urb *urb);
+
+/* Callback for data arriving from the PowerMate over the USB interrupt pipe */
+static void powermate_irq(struct urb *urb)
+{
+	struct powermate_device *pm = urb->context;
+	struct device *dev = &pm->intf->dev;
+	int retval;
+
+	switch (urb->status) {
+	case 0:
+		/* success */
+		break;
+	case -ECONNRESET:
+	case -ENOENT:
+	case -ESHUTDOWN:
+		/* this urb is terminated, clean up */
+		dev_dbg(dev, "%s - urb shutting down with status: %d\n",
+			__func__, urb->status);
+		return;
+	default:
+		dev_dbg(dev, "%s - nonzero urb status received: %d\n",
+			__func__, urb->status);
+		goto exit;
+	}
+
+	/* handle updates to device state */
+	input_report_key(pm->input, BTN_0, pm->data[0] & 0x01);
+	input_report_rel(pm->input, REL_DIAL, pm->data[1]);
+	input_sync(pm->input);
+
+exit:
+	retval = usb_submit_urb (urb, GFP_ATOMIC);
+	if (retval)
+		dev_err(dev, "%s - usb_submit_urb failed with result: %d\n",
+			__func__, retval);
+}
+
+/* Decide if we need to issue a control message and do so. Must be called with pm->lock taken */
+static void powermate_sync_state(struct powermate_device *pm)
+{
+	if (pm->requires_update == 0)
+		return; /* no updates are required */
+	if (pm->config->status == -EINPROGRESS)
+		return; /* an update is already in progress; it'll issue this update when it completes */
+
+	if (pm->requires_update & UPDATE_PULSE_ASLEEP){
+		pm->configcr->wValue = cpu_to_le16( SET_PULSE_ASLEEP );
+		pm->configcr->wIndex = cpu_to_le16( pm->pulse_asleep ? 1 : 0 );
+		pm->requires_update &= ~UPDATE_PULSE_ASLEEP;
+	}else if (pm->requires_update & UPDATE_PULSE_AWAKE){
+		pm->configcr->wValue = cpu_to_le16( SET_PULSE_AWAKE );
+		pm->configcr->wIndex = cpu_to_le16( pm->pulse_awake ? 1 : 0 );
+		pm->requires_update &= ~UPDATE_PULSE_AWAKE;
+	}else if (pm->requires_update & UPDATE_PULSE_MODE){
+		int op, arg;
+		/* the powermate takes an operation and an argument for its pulse algorithm.
+		   the operation can be:
+		   0: divide the speed
+		   1: pulse at normal speed
+		   2: multiply the speed
+		   the argument only has an effect for operations 0 and 2, and ranges between
+		   1 (least effect) to 255 (maximum effect).
+
+		   thus, several states are equivalent and are coalesced into one state.
+
+		   we map this onto a range from 0 to 510, with:
+		   0 -- 254    -- use divide (0 = slowest)
+		   255         -- use normal speed
+		   256 -- 510  -- use multiple (510 = fastest).
+
+		   Only values of 'arg' quite close to 255 are particularly useful/spectacular.
+		*/
+		if (pm->pulse_speed < 255) {
+			op = 0;                   // divide
+			arg = 255 - pm->pulse_speed;
+		} else if (pm->pulse_speed > 255) {
+			op = 2;                   // multiply
+			arg = pm->pulse_speed - 255;
+		} else {
+			op = 1;                   // normal speed
+			arg = 0;                  // can be any value
+		}
+		pm->configcr->wValue = cpu_to_le16( (pm->pulse_table << 8) | SET_PULSE_MODE );
+		pm->configcr->wIndex = cpu_to_le16( (arg << 8) | op );
+		pm->requires_update &= ~UPDATE_PULSE_MODE;
+	} else if (pm->requires_update & UPDATE_STATIC_BRIGHTNESS) {
+		pm->configcr->wValue = cpu_to_le16( SET_STATIC_BRIGHTNESS );
+		pm->configcr->wIndex = cpu_to_le16( pm->static_brightness );
+		pm->requires_update &= ~UPDATE_STATIC_BRIGHTNESS;
+	} else {
+		printk(KERN_ERR "powermate: unknown update required");
+		pm->requires_update = 0; /* fudge the bug */
+		return;
+	}
+
+/*	printk("powermate: %04x %04x\n", pm->configcr->wValue, pm->configcr->wIndex); */
+
+	pm->configcr->bRequestType = 0x41; /* vendor request */
+	pm->configcr->bRequest = 0x01;
+	pm->configcr->wLength = 0;
+
+	usb_fill_control_urb(pm->config, pm->udev, usb_sndctrlpipe(pm->udev, 0),
+			     (void *) pm->configcr, NULL, 0,
+			     powermate_config_complete, pm);
+
+	if (usb_submit_urb(pm->config, GFP_ATOMIC))
+		printk(KERN_ERR "powermate: usb_submit_urb(config) failed");
+}
+
+/* Called when our asynchronous control message completes. We may need to issue another immediately */
+static void powermate_config_complete(struct urb *urb)
+{
+	struct powermate_device *pm = urb->context;
+	unsigned long flags;
+
+	if (urb->status)
+		printk(KERN_ERR "powermate: config urb returned %d\n", urb->status);
+
+	spin_lock_irqsave(&pm->lock, flags);
+	powermate_sync_state(pm);
+	spin_unlock_irqrestore(&pm->lock, flags);
+}
+
+/* Set the LED up as described and begin the sync with the hardware if required */
+static void powermate_pulse_led(struct powermate_device *pm, int static_brightness, int pulse_speed,
+				int pulse_table, int pulse_asleep, int pulse_awake)
+{
+	unsigned long flags;
+
+	if (pulse_speed < 0)
+		pulse_speed = 0;
+	if (pulse_table < 0)
+		pulse_table = 0;
+	if (pulse_speed > 510)
+		pulse_speed = 510;
+	if (pulse_table > 2)
+		pulse_table = 2;
+
+	pulse_asleep = !!pulse_asleep;
+	pulse_awake = !!pulse_awake;
+
+
+	spin_lock_irqsave(&pm->lock, flags);
+
+	/* mark state updates which are required */
+	if (static_brightness != pm->static_brightness) {
+		pm->static_brightness = static_brightness;
+		pm->requires_update |= UPDATE_STATIC_BRIGHTNESS;
+	}
+	if (pulse_asleep != pm->pulse_asleep) {
+		pm->pulse_asleep = pulse_asleep;
+		pm->requires_update |= (UPDATE_PULSE_ASLEEP | UPDATE_STATIC_BRIGHTNESS);
+	}
+	if (pulse_awake != pm->pulse_awake) {
+		pm->pulse_awake = pulse_awake;
+		pm->requires_update |= (UPDATE_PULSE_AWAKE | UPDATE_STATIC_BRIGHTNESS);
+	}
+	if (pulse_speed != pm->pulse_speed || pulse_table != pm->pulse_table) {
+		pm->pulse_speed = pulse_speed;
+		pm->pulse_table = pulse_table;
+		pm->requires_update |= UPDATE_PULSE_MODE;
+	}
+
+	powermate_sync_state(pm);
+
+	spin_unlock_irqrestore(&pm->lock, flags);
+}
+
+/* Callback from the Input layer when an event arrives from userspace to configure the LED */
+static int powermate_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int _value)
+{
+	unsigned int command = (unsigned int)_value;
+	struct powermate_device *pm = input_get_drvdata(dev);
+
+	if (type == EV_MSC && code == MSC_PULSELED){
+		/*
+		    bits  0- 7: 8 bits: LED brightness
+		    bits  8-16: 9 bits: pulsing speed modifier (0 ... 510); 0-254 = slower, 255 = standard, 256-510 = faster.
+		    bits 17-18: 2 bits: pulse table (0, 1, 2 valid)
+		    bit     19: 1 bit : pulse whilst asleep?
+		    bit     20: 1 bit : pulse constantly?
+		*/
+		int static_brightness = command & 0xFF;   // bits 0-7
+		int pulse_speed = (command >> 8) & 0x1FF; // bits 8-16
+		int pulse_table = (command >> 17) & 0x3;  // bits 17-18
+		int pulse_asleep = (command >> 19) & 0x1; // bit 19
+		int pulse_awake  = (command >> 20) & 0x1; // bit 20
+
+		powermate_pulse_led(pm, static_brightness, pulse_speed, pulse_table, pulse_asleep, pulse_awake);
+	}
+
+	return 0;
+}
+
+static int powermate_alloc_buffers(struct usb_device *udev, struct powermate_device *pm)
+{
+	pm->data = usb_alloc_coherent(udev, POWERMATE_PAYLOAD_SIZE_MAX,
+				      GFP_ATOMIC, &pm->data_dma);
+	if (!pm->data)
+		return -1;
+
+	pm->configcr = kmalloc(sizeof(*(pm->configcr)), GFP_KERNEL);
+	if (!pm->configcr)
+		return -ENOMEM;
+
+	return 0;
+}
+
+static void powermate_free_buffers(struct usb_device *udev, struct powermate_device *pm)
+{
+	usb_free_coherent(udev, POWERMATE_PAYLOAD_SIZE_MAX,
+			  pm->data, pm->data_dma);
+	kfree(pm->configcr);
+}
+
+/* Called whenever a USB device matching one in our supported devices table is connected */
+static int powermate_probe(struct usb_interface *intf, const struct usb_device_id *id)
+{
+	struct usb_device *udev = interface_to_usbdev (intf);
+	struct usb_host_interface *interface;
+	struct usb_endpoint_descriptor *endpoint;
+	struct powermate_device *pm;
+	struct input_dev *input_dev;
+	int pipe, maxp;
+	int error = -ENOMEM;
+
+	interface = intf->cur_altsetting;
+	endpoint = &interface->endpoint[0].desc;
+	if (!usb_endpoint_is_int_in(endpoint))
+		return -EIO;
+
+	usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+		0x0a, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+		0, interface->desc.bInterfaceNumber, NULL, 0,
+		USB_CTRL_SET_TIMEOUT);
+
+	pm = kzalloc(sizeof(struct powermate_device), GFP_KERNEL);
+	input_dev = input_allocate_device();
+	if (!pm || !input_dev)
+		goto fail1;
+
+	if (powermate_alloc_buffers(udev, pm))
+		goto fail2;
+
+	pm->irq = usb_alloc_urb(0, GFP_KERNEL);
+	if (!pm->irq)
+		goto fail2;
+
+	pm->config = usb_alloc_urb(0, GFP_KERNEL);
+	if (!pm->config)
+		goto fail3;
+
+	pm->udev = udev;
+	pm->intf = intf;
+	pm->input = input_dev;
+
+	usb_make_path(udev, pm->phys, sizeof(pm->phys));
+	strlcat(pm->phys, "/input0", sizeof(pm->phys));
+
+	spin_lock_init(&pm->lock);
+
+	switch (le16_to_cpu(udev->descriptor.idProduct)) {
+	case POWERMATE_PRODUCT_NEW:
+		input_dev->name = pm_name_powermate;
+		break;
+	case POWERMATE_PRODUCT_OLD:
+		input_dev->name = pm_name_soundknob;
+		break;
+	default:
+		input_dev->name = pm_name_soundknob;
+		printk(KERN_WARNING "powermate: unknown product id %04x\n",
+		       le16_to_cpu(udev->descriptor.idProduct));
+	}
+
+	input_dev->phys = pm->phys;
+	usb_to_input_id(udev, &input_dev->id);
+	input_dev->dev.parent = &intf->dev;
+
+	input_set_drvdata(input_dev, pm);
+
+	input_dev->event = powermate_input_event;
+
+	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL) |
+		BIT_MASK(EV_MSC);
+	input_dev->keybit[BIT_WORD(BTN_0)] = BIT_MASK(BTN_0);
+	input_dev->relbit[BIT_WORD(REL_DIAL)] = BIT_MASK(REL_DIAL);
+	input_dev->mscbit[BIT_WORD(MSC_PULSELED)] = BIT_MASK(MSC_PULSELED);
+
+	/* get a handle to the interrupt data pipe */
+	pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);
+	maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
+
+	if (maxp < POWERMATE_PAYLOAD_SIZE_MIN || maxp > POWERMATE_PAYLOAD_SIZE_MAX) {
+		printk(KERN_WARNING "powermate: Expected payload of %d--%d bytes, found %d bytes!\n",
+			POWERMATE_PAYLOAD_SIZE_MIN, POWERMATE_PAYLOAD_SIZE_MAX, maxp);
+		maxp = POWERMATE_PAYLOAD_SIZE_MAX;
+	}
+
+	usb_fill_int_urb(pm->irq, udev, pipe, pm->data,
+			 maxp, powermate_irq,
+			 pm, endpoint->bInterval);
+	pm->irq->transfer_dma = pm->data_dma;
+	pm->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+	/* register our interrupt URB with the USB system */
+	if (usb_submit_urb(pm->irq, GFP_KERNEL)) {
+		error = -EIO;
+		goto fail4;
+	}
+
+	error = input_register_device(pm->input);
+	if (error)
+		goto fail5;
+
+
+	/* force an update of everything */
+	pm->requires_update = UPDATE_PULSE_ASLEEP | UPDATE_PULSE_AWAKE | UPDATE_PULSE_MODE | UPDATE_STATIC_BRIGHTNESS;
+	powermate_pulse_led(pm, 0x80, 255, 0, 1, 0); // set default pulse parameters
+
+	usb_set_intfdata(intf, pm);
+	return 0;
+
+ fail5:	usb_kill_urb(pm->irq);
+ fail4:	usb_free_urb(pm->config);
+ fail3:	usb_free_urb(pm->irq);
+ fail2:	powermate_free_buffers(udev, pm);
+ fail1:	input_free_device(input_dev);
+	kfree(pm);
+	return error;
+}
+
+/* Called when a USB device we've accepted ownership of is removed */
+static void powermate_disconnect(struct usb_interface *intf)
+{
+	struct powermate_device *pm = usb_get_intfdata (intf);
+
+	usb_set_intfdata(intf, NULL);
+	if (pm) {
+		pm->requires_update = 0;
+		usb_kill_urb(pm->irq);
+		input_unregister_device(pm->input);
+		usb_free_urb(pm->irq);
+		usb_free_urb(pm->config);
+		powermate_free_buffers(interface_to_usbdev(intf), pm);
+
+		kfree(pm);
+	}
+}
+
+static struct usb_device_id powermate_devices [] = {
+	{ USB_DEVICE(POWERMATE_VENDOR, POWERMATE_PRODUCT_NEW) },
+	{ USB_DEVICE(POWERMATE_VENDOR, POWERMATE_PRODUCT_OLD) },
+	{ USB_DEVICE(CONTOUR_VENDOR, CONTOUR_JOG) },
+	{ } /* Terminating entry */
+};
+
+MODULE_DEVICE_TABLE (usb, powermate_devices);
+
+static struct usb_driver powermate_driver = {
+        .name =         "powermate",
+        .probe =        powermate_probe,
+        .disconnect =   powermate_disconnect,
+        .id_table =     powermate_devices,
+};
+
+module_usb_driver(powermate_driver);
+
+MODULE_AUTHOR( "William R Sowerbutts" );
+MODULE_DESCRIPTION( "Griffin Technology, Inc PowerMate driver" );
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/pwm-beeper.c b/drivers/input/misc/pwm-beeper.c
new file mode 100644
index 00000000..08088684
--- /dev/null
+++ b/drivers/input/misc/pwm-beeper.c
@@ -0,0 +1,200 @@
+/*
+ *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
+ *  PWM beeper driver
+ *
+ *  This program is free software; you can redistribute it and/or modify it
+ *  under  the terms of the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the License, or (at your
+ *  option) any later version.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <linux/input.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/pwm.h>
+#include <linux/slab.h>
+
+struct pwm_beeper {
+	struct input_dev *input;
+	struct pwm_device *pwm;
+	unsigned long period;
+};
+
+#define HZ_TO_NANOSECONDS(x) (1000000000UL/(x))
+
+static int pwm_beeper_event(struct input_dev *input,
+			    unsigned int type, unsigned int code, int value)
+{
+	int ret = 0;
+	struct pwm_beeper *beeper = input_get_drvdata(input);
+	unsigned long period;
+
+	if (type != EV_SND || value < 0)
+		return -EINVAL;
+
+	switch (code) {
+	case SND_BELL:
+		value = value ? 1000 : 0;
+		break;
+	case SND_TONE:
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	if (value == 0) {
+		pwm_config(beeper->pwm, 0, 0);
+		pwm_disable(beeper->pwm);
+	} else {
+		period = HZ_TO_NANOSECONDS(value);
+		ret = pwm_config(beeper->pwm, period / 2, period);
+		if (ret)
+			return ret;
+		ret = pwm_enable(beeper->pwm);
+		if (ret)
+			return ret;
+		beeper->period = period;
+	}
+
+	return 0;
+}
+
+static int pwm_beeper_probe(struct platform_device *pdev)
+{
+	unsigned long pwm_id = (unsigned long)pdev->dev.platform_data;
+	struct pwm_beeper *beeper;
+	int error;
+
+	beeper = kzalloc(sizeof(*beeper), GFP_KERNEL);
+	if (!beeper)
+		return -ENOMEM;
+
+	beeper->pwm = pwm_get(&pdev->dev, NULL);
+	if (IS_ERR(beeper->pwm)) {
+		dev_dbg(&pdev->dev, "unable to request PWM, trying legacy API\n");
+		beeper->pwm = pwm_request(pwm_id, "pwm beeper");
+	}
+
+	if (IS_ERR(beeper->pwm)) {
+		error = PTR_ERR(beeper->pwm);
+		dev_err(&pdev->dev, "Failed to request pwm device: %d\n", error);
+		goto err_free;
+	}
+
+	beeper->input = input_allocate_device();
+	if (!beeper->input) {
+		dev_err(&pdev->dev, "Failed to allocate input device\n");
+		error = -ENOMEM;
+		goto err_pwm_free;
+	}
+	beeper->input->dev.parent = &pdev->dev;
+
+	beeper->input->name = "pwm-beeper";
+	beeper->input->phys = "pwm/input0";
+	beeper->input->id.bustype = BUS_HOST;
+	beeper->input->id.vendor = 0x001f;
+	beeper->input->id.product = 0x0001;
+	beeper->input->id.version = 0x0100;
+
+	beeper->input->evbit[0] = BIT(EV_SND);
+	beeper->input->sndbit[0] = BIT(SND_TONE) | BIT(SND_BELL);
+
+	beeper->input->event = pwm_beeper_event;
+
+	input_set_drvdata(beeper->input, beeper);
+
+	error = input_register_device(beeper->input);
+	if (error) {
+		dev_err(&pdev->dev, "Failed to register input device: %d\n", error);
+		goto err_input_free;
+	}
+
+	platform_set_drvdata(pdev, beeper);
+
+	return 0;
+
+err_input_free:
+	input_free_device(beeper->input);
+err_pwm_free:
+	pwm_free(beeper->pwm);
+err_free:
+	kfree(beeper);
+
+	return error;
+}
+
+static int pwm_beeper_remove(struct platform_device *pdev)
+{
+	struct pwm_beeper *beeper = platform_get_drvdata(pdev);
+
+	platform_set_drvdata(pdev, NULL);
+	input_unregister_device(beeper->input);
+
+	pwm_disable(beeper->pwm);
+	pwm_free(beeper->pwm);
+
+	kfree(beeper);
+
+	return 0;
+}
+
+#ifdef CONFIG_PM
+static int pwm_beeper_suspend(struct device *dev)
+{
+	struct pwm_beeper *beeper = dev_get_drvdata(dev);
+
+	if (beeper->period)
+		pwm_disable(beeper->pwm);
+
+	return 0;
+}
+
+static int pwm_beeper_resume(struct device *dev)
+{
+	struct pwm_beeper *beeper = dev_get_drvdata(dev);
+
+	if (beeper->period) {
+		pwm_config(beeper->pwm, beeper->period / 2, beeper->period);
+		pwm_enable(beeper->pwm);
+	}
+
+	return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(pwm_beeper_pm_ops,
+			 pwm_beeper_suspend, pwm_beeper_resume);
+
+#define PWM_BEEPER_PM_OPS (&pwm_beeper_pm_ops)
+#else
+#define PWM_BEEPER_PM_OPS NULL
+#endif
+
+#ifdef CONFIG_OF
+static const struct of_device_id pwm_beeper_match[] = {
+	{ .compatible = "pwm-beeper", },
+	{ },
+};
+#endif
+
+static struct platform_driver pwm_beeper_driver = {
+	.probe	= pwm_beeper_probe,
+	.remove = pwm_beeper_remove,
+	.driver = {
+		.name	= "pwm-beeper",
+		.owner	= THIS_MODULE,
+		.pm	= PWM_BEEPER_PM_OPS,
+		.of_match_table = of_match_ptr(pwm_beeper_match),
+	},
+};
+module_platform_driver(pwm_beeper_driver);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("PWM beeper driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pwm-beeper");
diff --git a/drivers/input/misc/rb532_button.c b/drivers/input/misc/rb532_button.c
new file mode 100644
index 00000000..fb4f8ac3
--- /dev/null
+++ b/drivers/input/misc/rb532_button.c
@@ -0,0 +1,108 @@
+/*
+ * Support for the S1 button on Routerboard 532
+ *
+ * Copyright (C) 2009  Phil Sutter <n0-1@freewrt.org>
+ */
+
+#include <linux/input-polldev.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+
+#include <asm/mach-rc32434/gpio.h>
+#include <asm/mach-rc32434/rb.h>
+
+#define DRV_NAME "rb532-button"
+
+#define RB532_BTN_RATE 100 /* msec */
+#define RB532_BTN_KSYM BTN_0
+
+/* The S1 button state is provided by GPIO pin 1. But as this
+ * pin is also used for uart input as alternate function, the
+ * operational modes must be switched first:
+ * 1) disable uart using set_latch_u5()
+ * 2) turn off alternate function implicitly through
+ *    gpio_direction_input()
+ * 3) read the GPIO's current value
+ * 4) undo step 2 by enabling alternate function (in this
+ *    mode the GPIO direction is fixed, so no change needed)
+ * 5) turn on uart again
+ * The GPIO value occurs to be inverted, so pin high means
+ * button is not pressed.
+ */
+static bool rb532_button_pressed(void)
+{
+	int val;
+
+	set_latch_u5(0, LO_FOFF);
+	gpio_direction_input(GPIO_BTN_S1);
+
+	val = gpio_get_value(GPIO_BTN_S1);
+
+	rb532_gpio_set_func(GPIO_BTN_S1);
+	set_latch_u5(LO_FOFF, 0);
+
+	return !val;
+}
+
+static void rb532_button_poll(struct input_polled_dev *poll_dev)
+{
+	input_report_key(poll_dev->input, RB532_BTN_KSYM,
+			 rb532_button_pressed());
+	input_sync(poll_dev->input);
+}
+
+static int rb532_button_probe(struct platform_device *pdev)
+{
+	struct input_polled_dev *poll_dev;
+	int error;
+
+	poll_dev = input_allocate_polled_device();
+	if (!poll_dev)
+		return -ENOMEM;
+
+	poll_dev->poll = rb532_button_poll;
+	poll_dev->poll_interval = RB532_BTN_RATE;
+
+	poll_dev->input->name = "rb532 button";
+	poll_dev->input->phys = "rb532/button0";
+	poll_dev->input->id.bustype = BUS_HOST;
+	poll_dev->input->dev.parent = &pdev->dev;
+
+	dev_set_drvdata(&pdev->dev, poll_dev);
+
+	input_set_capability(poll_dev->input, EV_KEY, RB532_BTN_KSYM);
+
+	error = input_register_polled_device(poll_dev);
+	if (error) {
+		input_free_polled_device(poll_dev);
+		return error;
+	}
+
+	return 0;
+}
+
+static int rb532_button_remove(struct platform_device *pdev)
+{
+	struct input_polled_dev *poll_dev = dev_get_drvdata(&pdev->dev);
+
+	input_unregister_polled_device(poll_dev);
+	input_free_polled_device(poll_dev);
+	dev_set_drvdata(&pdev->dev, NULL);
+
+	return 0;
+}
+
+static struct platform_driver rb532_button_driver = {
+	.probe = rb532_button_probe,
+	.remove = rb532_button_remove,
+	.driver = {
+		.name = DRV_NAME,
+		.owner = THIS_MODULE,
+	},
+};
+module_platform_driver(rb532_button_driver);
+
+MODULE_AUTHOR("Phil Sutter <n0-1@freewrt.org>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Support for S1 button on Routerboard 532");
+MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/input/misc/retu-pwrbutton.c b/drivers/input/misc/retu-pwrbutton.c
new file mode 100644
index 00000000..7ca09baa
--- /dev/null
+++ b/drivers/input/misc/retu-pwrbutton.c
@@ -0,0 +1,99 @@
+/*
+ * Retu power button driver.
+ *
+ * Copyright (C) 2004-2010 Nokia Corporation
+ *
+ * Original code written by Ari Saastamoinen, Juha Yrjölä and Felipe Balbi.
+ * Rewritten by Aaro Koskinen.
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License. See the file "COPYING" in the main directory of this
+ * archive for more details.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/irq.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include <linux/input.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/mfd/retu.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+
+#define RETU_STATUS_PWRONX (1 << 5)
+
+static irqreturn_t retu_pwrbutton_irq(int irq, void *_pwr)
+{
+	struct input_dev *idev = _pwr;
+	struct retu_dev *rdev = input_get_drvdata(idev);
+	bool state;
+
+	state = !(retu_read(rdev, RETU_REG_STATUS) & RETU_STATUS_PWRONX);
+	input_report_key(idev, KEY_POWER, state);
+	input_sync(idev);
+
+	return IRQ_HANDLED;
+}
+
+static int retu_pwrbutton_probe(struct platform_device *pdev)
+{
+	struct retu_dev *rdev = dev_get_drvdata(pdev->dev.parent);
+	struct input_dev *idev;
+	int irq;
+	int error;
+
+	irq = platform_get_irq(pdev, 0);
+	if (irq < 0)
+		return irq;
+
+	idev = devm_input_allocate_device(&pdev->dev);
+	if (!idev)
+		return -ENOMEM;
+
+	idev->name = "retu-pwrbutton";
+	idev->dev.parent = &pdev->dev;
+
+	input_set_capability(idev, EV_KEY, KEY_POWER);
+	input_set_drvdata(idev, rdev);
+
+	error = devm_request_threaded_irq(&pdev->dev, irq,
+					  NULL, retu_pwrbutton_irq, 0,
+					  "retu-pwrbutton", idev);
+	if (error)
+		return error;
+
+	error = input_register_device(idev);
+	if (error)
+		return error;
+
+	return 0;
+}
+
+static int retu_pwrbutton_remove(struct platform_device *pdev)
+{
+	return 0;
+}
+
+static struct platform_driver retu_pwrbutton_driver = {
+	.probe		= retu_pwrbutton_probe,
+	.remove		= retu_pwrbutton_remove,
+	.driver		= {
+		.name	= "retu-pwrbutton",
+		.owner	= THIS_MODULE,
+	},
+};
+module_platform_driver(retu_pwrbutton_driver);
+
+MODULE_ALIAS("platform:retu-pwrbutton");
+MODULE_DESCRIPTION("Retu Power Button");
+MODULE_AUTHOR("Ari Saastamoinen");
+MODULE_AUTHOR("Felipe Balbi");
+MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/rotary_encoder.c b/drivers/input/misc/rotary_encoder.c
new file mode 100644
index 00000000..aff47b2c
--- /dev/null
+++ b/drivers/input/misc/rotary_encoder.c
@@ -0,0 +1,339 @@
+/*
+ * rotary_encoder.c
+ *
+ * (c) 2009 Daniel Mack <daniel@caiaq.de>
+ * Copyright (C) 2011 Johan Hovold <jhovold@gmail.com>
+ *
+ * state machine code inspired by code from Tim Ruetz
+ *
+ * A generic driver for rotary encoders connected to GPIO lines.
+ * See file:Documentation/input/rotary-encoder.txt for more information
+ *
+ * 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/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/input.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/gpio.h>
+#include <linux/rotary_encoder.h>
+#include <linux/slab.h>
+#include <linux/of_platform.h>
+#include <linux/of_gpio.h>
+
+#define DRV_NAME "rotary-encoder"
+
+struct rotary_encoder {
+	struct input_dev *input;
+	const struct rotary_encoder_platform_data *pdata;
+
+	unsigned int axis;
+	unsigned int pos;
+
+	unsigned int irq_a;
+	unsigned int irq_b;
+
+	bool armed;
+	unsigned char dir;	/* 0 - clockwise, 1 - CCW */
+
+	char last_stable;
+};
+
+static int rotary_encoder_get_state(const struct rotary_encoder_platform_data *pdata)
+{
+	int a = !!gpio_get_value(pdata->gpio_a);
+	int b = !!gpio_get_value(pdata->gpio_b);
+
+	a ^= pdata->inverted_a;
+	b ^= pdata->inverted_b;
+
+	return ((a << 1) | b);
+}
+
+static void rotary_encoder_report_event(struct rotary_encoder *encoder)
+{
+	const struct rotary_encoder_platform_data *pdata = encoder->pdata;
+
+	if (pdata->relative_axis) {
+		input_report_rel(encoder->input,
+				 pdata->axis, encoder->dir ? -1 : 1);
+	} else {
+		unsigned int pos = encoder->pos;
+
+		if (encoder->dir) {
+			/* turning counter-clockwise */
+			if (pdata->rollover)
+				pos += pdata->steps;
+			if (pos)
+				pos--;
+		} else {
+			/* turning clockwise */
+			if (pdata->rollover || pos < pdata->steps)
+				pos++;
+		}
+
+		if (pdata->rollover)
+			pos %= pdata->steps;
+
+		encoder->pos = pos;
+		input_report_abs(encoder->input, pdata->axis, encoder->pos);
+	}
+
+	input_sync(encoder->input);
+}
+
+static irqreturn_t rotary_encoder_irq(int irq, void *dev_id)
+{
+	struct rotary_encoder *encoder = dev_id;
+	int state;
+
+	state = rotary_encoder_get_state(encoder->pdata);
+
+	switch (state) {
+	case 0x0:
+		if (encoder->armed) {
+			rotary_encoder_report_event(encoder);
+			encoder->armed = false;
+		}
+		break;
+
+	case 0x1:
+	case 0x2:
+		if (encoder->armed)
+			encoder->dir = state - 1;
+		break;
+
+	case 0x3:
+		encoder->armed = true;
+		break;
+	}
+
+	return IRQ_HANDLED;
+}
+
+static irqreturn_t rotary_encoder_half_period_irq(int irq, void *dev_id)
+{
+	struct rotary_encoder *encoder = dev_id;
+	int state;
+
+	state = rotary_encoder_get_state(encoder->pdata);
+
+	switch (state) {
+	case 0x00:
+	case 0x03:
+		if (state != encoder->last_stable) {
+			rotary_encoder_report_event(encoder);
+			encoder->last_stable = state;
+		}
+		break;
+
+	case 0x01:
+	case 0x02:
+		encoder->dir = (encoder->last_stable + state) & 0x01;
+		break;
+	}
+
+	return IRQ_HANDLED;
+}
+
+#ifdef CONFIG_OF
+static struct of_device_id rotary_encoder_of_match[] = {
+	{ .compatible = "rotary-encoder", },
+	{ },
+};
+MODULE_DEVICE_TABLE(of, rotary_encoder_of_match);
+
+static struct rotary_encoder_platform_data *rotary_encoder_parse_dt(struct device *dev)
+{
+	const struct of_device_id *of_id =
+				of_match_device(rotary_encoder_of_match, dev);
+	struct device_node *np = dev->of_node;
+	struct rotary_encoder_platform_data *pdata;
+	enum of_gpio_flags flags;
+
+	if (!of_id || !np)
+		return NULL;
+
+	pdata = kzalloc(sizeof(struct rotary_encoder_platform_data),
+			GFP_KERNEL);
+	if (!pdata)
+		return ERR_PTR(-ENOMEM);
+
+	of_property_read_u32(np, "rotary-encoder,steps", &pdata->steps);
+	of_property_read_u32(np, "linux,axis", &pdata->axis);
+
+	pdata->gpio_a = of_get_gpio_flags(np, 0, &flags);
+	pdata->inverted_a = flags & OF_GPIO_ACTIVE_LOW;
+
+	pdata->gpio_b = of_get_gpio_flags(np, 1, &flags);
+	pdata->inverted_b = flags & OF_GPIO_ACTIVE_LOW;
+
+	pdata->relative_axis = !!of_get_property(np,
+					"rotary-encoder,relative-axis", NULL);
+	pdata->rollover = !!of_get_property(np,
+					"rotary-encoder,rollover", NULL);
+	pdata->half_period = !!of_get_property(np,
+					"rotary-encoder,half-period", NULL);
+
+	return pdata;
+}
+#else
+static inline struct rotary_encoder_platform_data *
+rotary_encoder_parse_dt(struct device *dev)
+{
+	return NULL;
+}
+#endif
+
+static int rotary_encoder_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	const struct rotary_encoder_platform_data *pdata = dev_get_platdata(dev);
+	struct rotary_encoder *encoder;
+	struct input_dev *input;
+	irq_handler_t handler;
+	int err;
+
+	if (!pdata) {
+		pdata = rotary_encoder_parse_dt(dev);
+		if (IS_ERR(pdata))
+			return PTR_ERR(pdata);
+
+		if (!pdata) {
+			dev_err(dev, "missing platform data\n");
+			return -EINVAL;
+		}
+	}
+
+	encoder = kzalloc(sizeof(struct rotary_encoder), GFP_KERNEL);
+	input = input_allocate_device();
+	if (!encoder || !input) {
+		err = -ENOMEM;
+		goto exit_free_mem;
+	}
+
+	encoder->input = input;
+	encoder->pdata = pdata;
+
+	input->name = pdev->name;
+	input->id.bustype = BUS_HOST;
+	input->dev.parent = dev;
+
+	if (pdata->relative_axis) {
+		input->evbit[0] = BIT_MASK(EV_REL);
+		input->relbit[0] = BIT_MASK(pdata->axis);
+	} else {
+		input->evbit[0] = BIT_MASK(EV_ABS);
+		input_set_abs_params(encoder->input,
+				     pdata->axis, 0, pdata->steps, 0, 1);
+	}
+
+	/* request the GPIOs */
+	err = gpio_request_one(pdata->gpio_a, GPIOF_IN, dev_name(dev));
+	if (err) {
+		dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_a);
+		goto exit_free_mem;
+	}
+
+	err = gpio_request_one(pdata->gpio_b, GPIOF_IN, dev_name(dev));
+	if (err) {
+		dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_b);
+		goto exit_free_gpio_a;
+	}
+
+	encoder->irq_a = gpio_to_irq(pdata->gpio_a);
+	encoder->irq_b = gpio_to_irq(pdata->gpio_b);
+
+	/* request the IRQs */
+	if (pdata->half_period) {
+		handler = &rotary_encoder_half_period_irq;
+		encoder->last_stable = rotary_encoder_get_state(pdata);
+	} else {
+		handler = &rotary_encoder_irq;
+	}
+
+	err = request_irq(encoder->irq_a, handler,
+			  IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+			  DRV_NAME, encoder);
+	if (err) {
+		dev_err(dev, "unable to request IRQ %d\n", encoder->irq_a);
+		goto exit_free_gpio_b;
+	}
+
+	err = request_irq(encoder->irq_b, handler,
+			  IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+			  DRV_NAME, encoder);
+	if (err) {
+		dev_err(dev, "unable to request IRQ %d\n", encoder->irq_b);
+		goto exit_free_irq_a;
+	}
+
+	err = input_register_device(input);
+	if (err) {
+		dev_err(dev, "failed to register input device\n");
+		goto exit_free_irq_b;
+	}
+
+	platform_set_drvdata(pdev, encoder);
+
+	return 0;
+
+exit_free_irq_b:
+	free_irq(encoder->irq_b, encoder);
+exit_free_irq_a:
+	free_irq(encoder->irq_a, encoder);
+exit_free_gpio_b:
+	gpio_free(pdata->gpio_b);
+exit_free_gpio_a:
+	gpio_free(pdata->gpio_a);
+exit_free_mem:
+	input_free_device(input);
+	kfree(encoder);
+	if (!dev_get_platdata(&pdev->dev))
+		kfree(pdata);
+
+	return err;
+}
+
+static int rotary_encoder_remove(struct platform_device *pdev)
+{
+	struct rotary_encoder *encoder = platform_get_drvdata(pdev);
+	const struct rotary_encoder_platform_data *pdata = encoder->pdata;
+
+	free_irq(encoder->irq_a, encoder);
+	free_irq(encoder->irq_b, encoder);
+	gpio_free(pdata->gpio_a);
+	gpio_free(pdata->gpio_b);
+
+	input_unregister_device(encoder->input);
+	kfree(encoder);
+
+	if (!dev_get_platdata(&pdev->dev))
+		kfree(pdata);
+
+	platform_set_drvdata(pdev, NULL);
+
+	return 0;
+}
+
+static struct platform_driver rotary_encoder_driver = {
+	.probe		= rotary_encoder_probe,
+	.remove		= rotary_encoder_remove,
+	.driver		= {
+		.name	= DRV_NAME,
+		.owner	= THIS_MODULE,
+		.of_match_table = of_match_ptr(rotary_encoder_of_match),
+	}
+};
+module_platform_driver(rotary_encoder_driver);
+
+MODULE_ALIAS("platform:" DRV_NAME);
+MODULE_DESCRIPTION("GPIO rotary encoder driver");
+MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>, Johan Hovold");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/misc/sgi_btns.c b/drivers/input/misc/sgi_btns.c
new file mode 100644
index 00000000..ad6415ce
--- /dev/null
+++ b/drivers/input/misc/sgi_btns.c
@@ -0,0 +1,169 @@
+/*
+ *  SGI Volume Button interface driver
+ *
+ *  Copyright (C) 2008  Thomas Bogendoerfer <tsbogend@alpha.franken.de>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#include <linux/init.h>
+#include <linux/input-polldev.h>
+#include <linux/ioport.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#ifdef CONFIG_SGI_IP22
+#include <asm/sgi/ioc.h>
+
+static inline u8 button_status(void)
+{
+	u8 status;
+
+	status = readb(&sgioc->panel) ^ 0xa0;
+	return ((status & 0x80) >> 6) | ((status & 0x20) >> 5);
+}
+#endif
+
+#ifdef CONFIG_SGI_IP32
+#include <asm/ip32/mace.h>
+
+static inline u8 button_status(void)
+{
+	u64 status;
+
+	status = readq(&mace->perif.audio.control);
+	writeq(status & ~(3U << 23), &mace->perif.audio.control);
+
+	return (status >> 23) & 3;
+}
+#endif
+
+#define BUTTONS_POLL_INTERVAL	30	/* msec */
+#define BUTTONS_COUNT_THRESHOLD	3
+
+static const unsigned short sgi_map[] = {
+	KEY_VOLUMEDOWN,
+	KEY_VOLUMEUP
+};
+
+struct buttons_dev {
+	struct input_polled_dev *poll_dev;
+	unsigned short keymap[ARRAY_SIZE(sgi_map)];
+	int count[ARRAY_SIZE(sgi_map)];
+};
+
+static void handle_buttons(struct input_polled_dev *dev)
+{
+	struct buttons_dev *bdev = dev->private;
+	struct input_dev *input = dev->input;
+	u8 status;
+	int i;
+
+	status = button_status();
+
+	for (i = 0; i < ARRAY_SIZE(bdev->keymap); i++) {
+		if (status & (1U << i)) {
+			if (++bdev->count[i] == BUTTONS_COUNT_THRESHOLD) {
+				input_event(input, EV_MSC, MSC_SCAN, i);
+				input_report_key(input, bdev->keymap[i], 1);
+				input_sync(input);
+			}
+		} else {
+			if (bdev->count[i] >= BUTTONS_COUNT_THRESHOLD) {
+				input_event(input, EV_MSC, MSC_SCAN, i);
+				input_report_key(input, bdev->keymap[i], 0);
+				input_sync(input);
+			}
+			bdev->count[i] = 0;
+		}
+	}
+}
+
+static int sgi_buttons_probe(struct platform_device *pdev)
+{
+	struct buttons_dev *bdev;
+	struct input_polled_dev *poll_dev;
+	struct input_dev *input;
+	int error, i;
+
+	bdev = kzalloc(sizeof(struct buttons_dev), GFP_KERNEL);
+	poll_dev = input_allocate_polled_device();
+	if (!bdev || !poll_dev) {
+		error = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	memcpy(bdev->keymap, sgi_map, sizeof(bdev->keymap));
+
+	poll_dev->private = bdev;
+	poll_dev->poll = handle_buttons;
+	poll_dev->poll_interval = BUTTONS_POLL_INTERVAL;
+
+	input = poll_dev->input;
+	input->name = "SGI buttons";
+	input->phys = "sgi/input0";
+	input->id.bustype = BUS_HOST;
+	input->dev.parent = &pdev->dev;
+
+	input->keycode = bdev->keymap;
+	input->keycodemax = ARRAY_SIZE(bdev->keymap);
+	input->keycodesize = sizeof(unsigned short);
+
+	input_set_capability(input, EV_MSC, MSC_SCAN);
+	__set_bit(EV_KEY, input->evbit);
+	for (i = 0; i < ARRAY_SIZE(sgi_map); i++)
+		__set_bit(bdev->keymap[i], input->keybit);
+	__clear_bit(KEY_RESERVED, input->keybit);
+
+	bdev->poll_dev = poll_dev;
+	dev_set_drvdata(&pdev->dev, bdev);
+
+	error = input_register_polled_device(poll_dev);
+	if (error)
+		goto err_free_mem;
+
+	return 0;
+
+ err_free_mem:
+	input_free_polled_device(poll_dev);
+	kfree(bdev);
+	dev_set_drvdata(&pdev->dev, NULL);
+	return error;
+}
+
+static int sgi_buttons_remove(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct buttons_dev *bdev = dev_get_drvdata(dev);
+
+	input_unregister_polled_device(bdev->poll_dev);
+	input_free_polled_device(bdev->poll_dev);
+	kfree(bdev);
+	dev_set_drvdata(dev, NULL);
+
+	return 0;
+}
+
+static struct platform_driver sgi_buttons_driver = {
+	.probe	= sgi_buttons_probe,
+	.remove	= sgi_buttons_remove,
+	.driver	= {
+		.name	= "sgibtns",
+		.owner	= THIS_MODULE,
+	},
+};
+module_platform_driver(sgi_buttons_driver);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/sparcspkr.c b/drivers/input/misc/sparcspkr.c
new file mode 100644
index 00000000..a53586a7
--- /dev/null
+++ b/drivers/input/misc/sparcspkr.c
@@ -0,0 +1,372 @@
+/*
+ *  Driver for PC-speaker like devices found on various Sparc systems.
+ *
+ *  Copyright (c) 2002 Vojtech Pavlik
+ *  Copyright (c) 2002, 2006, 2008 David S. Miller (davem@davemloft.net)
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/of_device.h>
+#include <linux/slab.h>
+
+#include <asm/io.h>
+
+MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
+MODULE_DESCRIPTION("Sparc Speaker beeper driver");
+MODULE_LICENSE("GPL");
+
+struct grover_beep_info {
+	void __iomem	*freq_regs;
+	void __iomem	*enable_reg;
+};
+
+struct bbc_beep_info {
+	u32		clock_freq;
+	void __iomem	*regs;
+};
+
+struct sparcspkr_state {
+	const char		*name;
+	int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
+	spinlock_t		lock;
+	struct input_dev	*input_dev;
+	union {
+		struct grover_beep_info grover;
+		struct bbc_beep_info bbc;
+	} u;
+};
+
+static u32 bbc_count_to_reg(struct bbc_beep_info *info, unsigned int count)
+{
+	u32 val, clock_freq = info->clock_freq;
+	int i;
+
+	if (!count)
+		return 0;
+
+	if (count <= clock_freq >> 20)
+		return 1 << 18;
+
+	if (count >= clock_freq >> 12)
+		return 1 << 10;
+
+	val = 1 << 18;
+	for (i = 19; i >= 11; i--) {
+		val >>= 1;
+		if (count <= clock_freq >> i)
+			break;
+	}
+
+	return val;
+}
+
+static int bbc_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
+{
+	struct sparcspkr_state *state = dev_get_drvdata(dev->dev.parent);
+	struct bbc_beep_info *info = &state->u.bbc;
+	unsigned int count = 0;
+	unsigned long flags;
+
+	if (type != EV_SND)
+		return -1;
+
+	switch (code) {
+		case SND_BELL: if (value) value = 1000;
+		case SND_TONE: break;
+		default: return -1;
+	}
+
+	if (value > 20 && value < 32767)
+		count = 1193182 / value;
+
+	count = bbc_count_to_reg(info, count);
+
+	spin_lock_irqsave(&state->lock, flags);
+
+	if (count) {
+		outb(0x01,                 info->regs + 0);
+		outb(0x00,                 info->regs + 2);
+		outb((count >> 16) & 0xff, info->regs + 3);
+		outb((count >>  8) & 0xff, info->regs + 4);
+		outb(0x00,                 info->regs + 5);
+	} else {
+		outb(0x00,                 info->regs + 0);
+	}
+
+	spin_unlock_irqrestore(&state->lock, flags);
+
+	return 0;
+}
+
+static int grover_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
+{
+	struct sparcspkr_state *state = dev_get_drvdata(dev->dev.parent);
+	struct grover_beep_info *info = &state->u.grover;
+	unsigned int count = 0;
+	unsigned long flags;
+
+	if (type != EV_SND)
+		return -1;
+
+	switch (code) {
+		case SND_BELL: if (value) value = 1000;
+		case SND_TONE: break;
+		default: return -1;
+	}
+
+	if (value > 20 && value < 32767)
+		count = 1193182 / value;
+
+	spin_lock_irqsave(&state->lock, flags);
+
+	if (count) {
+		/* enable counter 2 */
+		outb(inb(info->enable_reg) | 3, info->enable_reg);
+		/* set command for counter 2, 2 byte write */
+		outb(0xB6, info->freq_regs + 1);
+		/* select desired HZ */
+		outb(count & 0xff, info->freq_regs + 0);
+		outb((count >> 8) & 0xff, info->freq_regs + 0);
+	} else {
+		/* disable counter 2 */
+		outb(inb_p(info->enable_reg) & 0xFC, info->enable_reg);
+	}
+
+	spin_unlock_irqrestore(&state->lock, flags);
+
+	return 0;
+}
+
+static int sparcspkr_probe(struct device *dev)
+{
+	struct sparcspkr_state *state = dev_get_drvdata(dev);
+	struct input_dev *input_dev;
+	int error;
+
+	input_dev = input_allocate_device();
+	if (!input_dev)
+		return -ENOMEM;
+
+	input_dev->name = state->name;
+	input_dev->phys = "sparc/input0";
+	input_dev->id.bustype = BUS_ISA;
+	input_dev->id.vendor = 0x001f;
+	input_dev->id.product = 0x0001;
+	input_dev->id.version = 0x0100;
+	input_dev->dev.parent = dev;
+
+	input_dev->evbit[0] = BIT_MASK(EV_SND);
+	input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
+
+	input_dev->event = state->event;
+
+	error = input_register_device(input_dev);
+	if (error) {
+		input_free_device(input_dev);
+		return error;
+	}
+
+	state->input_dev = input_dev;
+
+	return 0;
+}
+
+static void sparcspkr_shutdown(struct platform_device *dev)
+{
+	struct sparcspkr_state *state = dev_get_drvdata(&dev->dev);
+	struct input_dev *input_dev = state->input_dev;
+
+	/* turn off the speaker */
+	state->event(input_dev, EV_SND, SND_BELL, 0);
+}
+
+static int bbc_beep_probe(struct platform_device *op)
+{
+	struct sparcspkr_state *state;
+	struct bbc_beep_info *info;
+	struct device_node *dp;
+	int err = -ENOMEM;
+
+	state = kzalloc(sizeof(*state), GFP_KERNEL);
+	if (!state)
+		goto out_err;
+
+	state->name = "Sparc BBC Speaker";
+	state->event = bbc_spkr_event;
+	spin_lock_init(&state->lock);
+
+	dp = of_find_node_by_path("/");
+	err = -ENODEV;
+	if (!dp)
+		goto out_free;
+
+	info = &state->u.bbc;
+	info->clock_freq = of_getintprop_default(dp, "clock-frequency", 0);
+	if (!info->clock_freq)
+		goto out_free;
+
+	info->regs = of_ioremap(&op->resource[0], 0, 6, "bbc beep");
+	if (!info->regs)
+		goto out_free;
+
+	dev_set_drvdata(&op->dev, state);
+
+	err = sparcspkr_probe(&op->dev);
+	if (err)
+		goto out_clear_drvdata;
+
+	return 0;
+
+out_clear_drvdata:
+	dev_set_drvdata(&op->dev, NULL);
+	of_iounmap(&op->resource[0], info->regs, 6);
+
+out_free:
+	kfree(state);
+out_err:
+	return err;
+}
+
+static int bbc_remove(struct platform_device *op)
+{
+	struct sparcspkr_state *state = dev_get_drvdata(&op->dev);
+	struct input_dev *input_dev = state->input_dev;
+	struct bbc_beep_info *info = &state->u.bbc;
+
+	/* turn off the speaker */
+	state->event(input_dev, EV_SND, SND_BELL, 0);
+
+	input_unregister_device(input_dev);
+
+	of_iounmap(&op->resource[0], info->regs, 6);
+
+	dev_set_drvdata(&op->dev, NULL);
+	kfree(state);
+
+	return 0;
+}
+
+static const struct of_device_id bbc_beep_match[] = {
+	{
+		.name = "beep",
+		.compatible = "SUNW,bbc-beep",
+	},
+	{},
+};
+
+static struct platform_driver bbc_beep_driver = {
+	.driver = {
+		.name = "bbcbeep",
+		.owner = THIS_MODULE,
+		.of_match_table = bbc_beep_match,
+	},
+	.probe		= bbc_beep_probe,
+	.remove		= bbc_remove,
+	.shutdown	= sparcspkr_shutdown,
+};
+
+static int grover_beep_probe(struct platform_device *op)
+{
+	struct sparcspkr_state *state;
+	struct grover_beep_info *info;
+	int err = -ENOMEM;
+
+	state = kzalloc(sizeof(*state), GFP_KERNEL);
+	if (!state)
+		goto out_err;
+
+	state->name = "Sparc Grover Speaker";
+	state->event = grover_spkr_event;
+	spin_lock_init(&state->lock);
+
+	info = &state->u.grover;
+	info->freq_regs = of_ioremap(&op->resource[2], 0, 2, "grover beep freq");
+	if (!info->freq_regs)
+		goto out_free;
+
+	info->enable_reg = of_ioremap(&op->resource[3], 0, 1, "grover beep enable");
+	if (!info->enable_reg)
+		goto out_unmap_freq_regs;
+
+	dev_set_drvdata(&op->dev, state);
+
+	err = sparcspkr_probe(&op->dev);
+	if (err)
+		goto out_clear_drvdata;
+
+	return 0;
+
+out_clear_drvdata:
+	dev_set_drvdata(&op->dev, NULL);
+	of_iounmap(&op->resource[3], info->enable_reg, 1);
+
+out_unmap_freq_regs:
+	of_iounmap(&op->resource[2], info->freq_regs, 2);
+out_free:
+	kfree(state);
+out_err:
+	return err;
+}
+
+static int grover_remove(struct platform_device *op)
+{
+	struct sparcspkr_state *state = dev_get_drvdata(&op->dev);
+	struct grover_beep_info *info = &state->u.grover;
+	struct input_dev *input_dev = state->input_dev;
+
+	/* turn off the speaker */
+	state->event(input_dev, EV_SND, SND_BELL, 0);
+
+	input_unregister_device(input_dev);
+
+	of_iounmap(&op->resource[3], info->enable_reg, 1);
+	of_iounmap(&op->resource[2], info->freq_regs, 2);
+
+	dev_set_drvdata(&op->dev, NULL);
+	kfree(state);
+
+	return 0;
+}
+
+static const struct of_device_id grover_beep_match[] = {
+	{
+		.name = "beep",
+		.compatible = "SUNW,smbus-beep",
+	},
+	{},
+};
+
+static struct platform_driver grover_beep_driver = {
+	.driver = {
+		.name = "groverbeep",
+		.owner = THIS_MODULE,
+		.of_match_table = grover_beep_match,
+	},
+	.probe		= grover_beep_probe,
+	.remove		= grover_remove,
+	.shutdown	= sparcspkr_shutdown,
+};
+
+static int __init sparcspkr_init(void)
+{
+	int err = platform_driver_register(&bbc_beep_driver);
+
+	if (!err) {
+		err = platform_driver_register(&grover_beep_driver);
+		if (err)
+			platform_driver_unregister(&bbc_beep_driver);
+	}
+
+	return err;
+}
+
+static void __exit sparcspkr_exit(void)
+{
+	platform_driver_unregister(&bbc_beep_driver);
+	platform_driver_unregister(&grover_beep_driver);
+}
+
+module_init(sparcspkr_init);
+module_exit(sparcspkr_exit);
diff --git a/drivers/input/misc/stk3x1x.c b/drivers/input/misc/stk3x1x.c
new file mode 100644
index 00000000..a6ed55fb
--- /dev/null
+++ b/drivers/input/misc/stk3x1x.c
@@ -0,0 +1,4262 @@
+/*

+ *  stk3x1x.c - Linux kernel modules for sensortek stk301x, stk321x, stk331x 

+ *  , and stk3410 proximity/ambient light sensor

+ *

+ *  Copyright (C) 2012~2015 Lex Hsieh / sensortek <lex_hsieh@sensortek.com.tw>

+ *

+ *  This program is free software; you can redistribute it and/or modify

+ *  it under the terms of the GNU General Public License as published by

+ *  the Free Software Foundation; either version 2 of the License, or

+ *  (at your option) any later version.

+ *

+ *  This program is distributed in the hope that it will be useful,

+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of

+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ *  GNU General Public License for more details.

+ *

+ *  You should have received a copy of the GNU General Public License

+ *  along with this program; if not, write to the Free Software

+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

+ */

+

+#include <linux/delay.h>

+#include <linux/module.h>

+#include <linux/interrupt.h>

+#include <linux/slab.h>

+#include <linux/i2c.h>

+#include <linux/irq.h>

+#include <linux/input.h>

+#include <linux/gpio.h>

+#ifdef CONFIG_HAS_EARLYSUSPEND

+#include <linux/earlysuspend.h>

+#endif

+#include <linux/fs.h>

+#include <asm/uaccess.h>

+//#include <linux/i2c/stk3x1x.h>

+#include <linux/miscdevice.h>

+

+#include <linux/wakelock.h>

+

+#define DRIVER_VERSION  "3.10.1 20151217"

+

+/* Driver Settings */

+#define CONFIG_STK_PS_ALS_USE_CHANGE_THRESHOLD

+#ifdef CONFIG_STK_PS_ALS_USE_CHANGE_THRESHOLD

+#define STK_ALS_CHANGE_THD      5	//10      /* The threshold to trigger ALS interrupt, unit: lux */

+#endif  /* #ifdef CONFIG_STK_PS_ALS_USE_CHANGE_THRESHOLD */

+#define STK_INT_PS_MODE                 1       /* 1, 2, or 3   */

+//#define STK_POLL_PS

+#define STK_POLL_ALS            /* ALS interrupt is valid only when STK_INT_PS_MODE = 1 or 4*/

+#define STK_TUNE0

+#define CALI_PS_EVERY_TIME

+//#define STK_DEBUG_PRINTF

+#define SPREADTRUM_PLATFORM

+#define STK_ALS_FIR

+//#define STK_IRS

+//#define STK_CHK_REG

+//#define STK_GES

+//#define STK_QUALCOMM_POWER_CTRL

+//#define QUALCOMM_PLATFORM

+

+#if 0

+#ifdef SPREADTRUM_PLATFORM

+#include <linux/i2c/stk3x1x.h>

+#else

+        #include "stk3x1x.h"

+#endif

+#endif

+#include "stk3x1x.h"

+

+/* Define Register Map */

+#define STK_STATE_REG                   0x00

+#define STK_PSCTRL_REG                  0x01

+#define STK_ALSCTRL_REG                         0x02

+#define STK_LEDCTRL_REG                         0x03

+#define STK_INT_REG                             0x04

+#define STK_WAIT_REG                    0x05

+#define STK_THDH1_PS_REG                0x06

+#define STK_THDH2_PS_REG                0x07

+#define STK_THDL1_PS_REG                0x08

+#define STK_THDL2_PS_REG                0x09

+#define STK_THDH1_ALS_REG               0x0A

+#define STK_THDH2_ALS_REG               0x0B

+#define STK_THDL1_ALS_REG               0x0C

+#define STK_THDL2_ALS_REG               0x0D

+#define STK_FLAG_REG                    0x10

+#define STK_DATA1_PS_REG                0x11

+#define STK_DATA2_PS_REG                0x12

+#define STK_DATA1_ALS_REG               0x13

+#define STK_DATA2_ALS_REG               0x14

+#define STK_DATA1_OFFSET_REG    0x15

+#define STK_DATA2_OFFSET_REG    0x16

+#define STK_DATA1_IR_REG                0x17

+#define STK_DATA2_IR_REG                0x18

+#define STK_PDT_ID_REG                  0x3E

+#define STK_RSRVD_REG                   0x3F

+#define STK_SW_RESET_REG                0x80

+

+#define STK_GSCTRL_REG                  0x1A

+#define STK_FLAG2_REG                   0x1C

+

+/* Define state reg */

+#define STK_STATE_EN_IRS_SHIFT          7

+#define STK_STATE_EN_AK_SHIFT   6

+#define STK_STATE_EN_ASO_SHIFT          5

+#define STK_STATE_EN_IRO_SHIFT          4

+#define STK_STATE_EN_WAIT_SHIFT         2

+#define STK_STATE_EN_ALS_SHIFT          1

+#define STK_STATE_EN_PS_SHIFT   0

+

+#define STK_STATE_EN_IRS_MASK   0x80

+#define STK_STATE_EN_AK_MASK    0x40

+#define STK_STATE_EN_ASO_MASK   0x20

+#define STK_STATE_EN_IRO_MASK   0x10

+#define STK_STATE_EN_WAIT_MASK  0x04

+#define STK_STATE_EN_ALS_MASK   0x02

+#define STK_STATE_EN_PS_MASK    0x01

+

+/* Define PS ctrl reg */

+#define STK_PS_PRS_SHIFT                6

+#define STK_PS_GAIN_SHIFT               4

+#define STK_PS_IT_SHIFT                         0

+

+#define STK_PS_PRS_MASK                 0xC0

+#define STK_PS_GAIN_MASK                        0x30

+#define STK_PS_IT_MASK                  0x0F

+

+/* Define ALS ctrl reg */

+#define STK_ALS_PRS_SHIFT               6

+#define STK_ALS_GAIN_SHIFT              4

+#define STK_ALS_IT_SHIFT                        0

+

+#define STK_ALS_PRS_MASK                0xC0

+#define STK_ALS_GAIN_MASK               0x30

+#define STK_ALS_IT_MASK                 0x0F

+

+/* Define LED ctrl reg */

+#define STK_LED_IRDR_SHIFT              6

+#define STK_LED_DT_SHIFT                0

+

+#define STK_LED_IRDR_MASK               0xC0

+#define STK_LED_DT_MASK                 0x3F

+

+/* Define interrupt reg */

+#define STK_INT_CTRL_SHIFT              7

+#define STK_INT_OUI_SHIFT               4

+#define STK_INT_ALS_SHIFT               3

+#define STK_INT_PS_SHIFT                        0

+

+#define STK_INT_CTRL_MASK               0x80

+#define STK_INT_OUI_MASK                        0x10

+#define STK_INT_ALS_MASK                        0x08

+#define STK_INT_PS_MASK                 0x07

+

+#define STK_INT_ALS                             0x08

+

+/* Define flag reg */

+#define STK_FLG_ALSDR_SHIFT             7

+#define STK_FLG_PSDR_SHIFT              6

+#define STK_FLG_ALSINT_SHIFT            5

+#define STK_FLG_PSINT_SHIFT             4

+#define STK_FLG_OUI_SHIFT               2

+#define STK_FLG_IR_RDY_SHIFT            1

+#define STK_FLG_NF_SHIFT                0

+

+#define STK_FLG_ALSDR_MASK              0x80

+#define STK_FLG_PSDR_MASK               0x40

+#define STK_FLG_ALSINT_MASK             0x20

+#define STK_FLG_PSINT_MASK              0x10

+#define STK_FLG_OUI_MASK                        0x04

+#define STK_FLG_IR_RDY_MASK             0x02

+#define STK_FLG_NF_MASK                 0x01

+

+/* Define flag2 reg */

+#define STK_FLG2_INT_GS_SHIFT           6

+#define STK_FLG2_GS10_SHIFT             5

+#define STK_FLG2_GS01_SHIFT             4

+

+#define STK_FLG2_INT_GS_MASK    0x40

+#define STK_FLG2_GS10_MASK              0x20

+#define STK_FLG2_GS01_MASK              0x10

+

+

+/* misc define */

+#define MIN_ALS_POLL_DELAY_NS	60000000

+

+

+#ifdef STK_TUNE0

+	#define STK_MAX_MIN_DIFF	150	//200

+	#define STK_LT_N_CT	50	//100

+	#define STK_HT_N_CT	80	//150

+#endif  /* #ifdef STK_TUNE0 */

+

+#define STK_IRC_MAX_ALS_CODE            20000

+#define STK_IRC_MIN_ALS_CODE            25

+#define STK_IRC_MIN_IR_CODE             50

+#define STK_IRC_ALS_DENOMI              2

+#define STK_IRC_ALS_NUMERA              5

+#define STK_IRC_ALS_CORREC              850

+

+#define STK_IRS_IT_REDUCE			2

+#define STK_ALS_READ_IRS_IT_REDUCE	5

+#define STK_ALS_THRESHOLD			30

+

+#define DEVICE_NAME             "stk_ps"

+#define ALS_NAME "lightsensor-level"

+#define PS_NAME "proximity"

+

+#ifdef STK_QUALCOMM_POWER_CTRL

+        /* POWER SUPPLY VOLTAGE RANGE */

+        #define STK3X1X_VDD_MIN_UV      2000000

+        #define STK3X1X_VDD_MAX_UV      3300000

+        #define STK3X1X_VIO_MIN_UV              1750000

+        #define STK3X1X_VIO_MAX_UV      1950000

+#endif

+

+#define STK3310SA_PID		0x17

+#define STK3311SA_PID		0x1E

+#define STK3311WV_PID	0x1D

+

+#ifdef SPREADTRUM_PLATFORM

+extern int sprd_3rdparty_gpio_pls_irq;

+

+static struct stk3x1x_platform_data stk3x1x_pfdata={ 

+  .state_reg = 0x0,    /* disable all */ 

+  .psctrl_reg = 0x31,    /* ps_persistance=1, ps_gain=64X, PS_IT=0.391ms */ 

+  .alsctrl_reg = 0x39,  /* als_persistance=1, als_gain=64X, ALS_IT=100ms */

+  .ledctrl_reg = 0xFF,   /* 100mA IRDR, 64/64 LED duty */ 

+  .wait_reg = 0xF,    /* 100 ms */   

+  .ps_thd_h =1700, 

+  .ps_thd_l = 1500, 

+  .int_pin = 216,//GPIO_PROX_INT//sprd_3rdparty_gpio_pls_irq

+  .transmittance = 3100, 	//500

+}; 

+#endif

+

+#ifdef STK_ALS_FIR

+	#define STK_FIR_LEN     4 //6	//8

+	#define MAX_FIR_LEN 32

+struct data_filter {

+    u16 raw[MAX_FIR_LEN];

+    int sum;

+    int number;

+    int idx;

+};

+#endif

+

+#ifdef STK_GES

+union stk_ges_operation{

+        uint8_t ops[4];

+        struct {

+                uint8_t rw_len_retry;

+                uint8_t reg;

+                uint8_t reg_value_retry_crit;

+                uint8_t sleep_10ns;

+        }action;

+};

+

+union stk_ges_operation stk_ges_op[10] =

+{

+        {.ops={0xc1, 0x24, 0, 0}},

+        {.ops={0, 0, 0, 0}},

+        {.ops={0, 0, 0, 0}},

+        {.ops={0, 0, 0, 0}},

+        {.ops={0, 0, 0, 0}},

+        {.ops={0, 0, 0, 0}},

+        {.ops={0, 0, 0, 0}},

+        {.ops={0, 0, 0, 0}},

+        {.ops={0, 0, 0, 0}},

+        {.ops={0, 0, 0, 0}}

+};

+#endif

+

+struct stk3x1x_data {

+        struct i2c_client *client;

+        struct stk3x1x_platform_data *pdata;

+#if (!defined(STK_POLL_PS) || !defined(STK_POLL_ALS))

+    int32_t irq;

+    struct work_struct stk_work;

+        struct workqueue_struct *stk_wq;

+#endif

+        uint16_t ir_code;

+        uint16_t als_correct_factor;

+        uint8_t alsctrl_reg;

+        uint8_t psctrl_reg;

+        uint8_t ledctrl_reg;

+        uint8_t state_reg;

+        int             int_pin;

+        uint8_t wait_reg;

+        uint8_t int_reg;

+#ifdef CONFIG_HAS_EARLYSUSPEND

+        //struct early_suspend stk_early_suspend;

+#endif

+        uint16_t ps_thd_h;

+        uint16_t ps_thd_l;

+#ifdef CALI_PS_EVERY_TIME

+        uint16_t ps_high_thd_boot;

+        uint16_t ps_low_thd_boot;

+#endif

+        struct mutex io_lock;

+        struct input_dev *ps_input_dev;

+        int32_t ps_distance_last;

+        bool ps_enabled;

+        bool re_enable_ps;

+        struct wake_lock ps_wakelock;

+#ifdef STK_POLL_PS

+        struct hrtimer ps_timer;

+    struct work_struct stk_ps_work;

+        struct workqueue_struct *stk_ps_wq;

+        struct wake_lock ps_nosuspend_wl;

+#endif

+        struct input_dev *als_input_dev;

+        int32_t als_lux_last;

+        uint32_t als_transmittance;

+        bool als_enabled;

+        bool re_enable_als;

+        ktime_t ps_poll_delay;

+        ktime_t als_poll_delay;

+#ifdef STK_POLL_ALS

+    struct work_struct stk_als_work;

+        struct hrtimer als_timer;

+        struct workqueue_struct *stk_als_wq;

+#endif

+        bool first_boot;

+#ifdef STK_TUNE0

+        uint16_t psa;

+        uint16_t psi;

+        uint16_t psi_set;

+        struct hrtimer ps_tune0_timer;

+        struct workqueue_struct *stk_ps_tune0_wq;

+    struct work_struct stk_ps_tune0_work;

+        ktime_t ps_tune0_delay;

+        bool tune_zero_init_proc;

+        uint32_t ps_stat_data[3];

+        int data_count;

+        int stk_max_min_diff;

+        int stk_lt_n_ct;

+        int stk_ht_n_ct;

+#endif

+#ifdef STK_ALS_FIR

+        struct data_filter      fir;

+        atomic_t                firlength;

+#endif

+        atomic_t        recv_reg;

+

+#ifdef STK_GES

+        struct input_dev *ges_input_dev;

+        int ges_enabled;

+        int re_enable_ges;

+        atomic_t gesture2;

+#endif

+#ifdef STK_IRS

+        int als_data_index;

+#endif

+#ifdef STK_QUALCOMM_POWER_CTRL

+        struct regulator *vdd;

+        struct regulator *vio;

+        bool power_enabled;

+#endif

+	uint8_t pid;

+	uint8_t	p_wv_r_bd_with_co;

+	uint32_t als_code_last;

+};

+

+#if( !defined(CONFIG_STK_PS_ALS_USE_CHANGE_THRESHOLD))

+static uint32_t lux_threshold_table[] =

+{

+        3,

+        10,

+        40,

+        65,

+        145,

+        300,

+        550,

+        930,

+        1250,

+        1700,

+};

+

+#define LUX_THD_TABLE_SIZE (sizeof(lux_threshold_table)/sizeof(uint32_t)+1)

+static uint16_t code_threshold_table[LUX_THD_TABLE_SIZE+1];

+#endif 

+

+static int32_t stk3x1x_enable_ps(struct stk3x1x_data *ps_data, uint8_t enable, uint8_t validate_reg);

+static int32_t stk3x1x_enable_als(struct stk3x1x_data *ps_data, uint8_t enable);

+static int32_t stk3x1x_set_ps_thd_l(struct stk3x1x_data *ps_data, uint16_t thd_l);

+static int32_t stk3x1x_set_ps_thd_h(struct stk3x1x_data *ps_data, uint16_t thd_h);

+static int32_t stk3x1x_set_als_thd_l(struct stk3x1x_data *ps_data, uint16_t thd_l);

+static int32_t stk3x1x_set_als_thd_h(struct stk3x1x_data *ps_data, uint16_t thd_h);

+static int32_t stk3x1x_get_ir_reading(struct stk3x1x_data *ps_data, int32_t als_it_reduce);

+#ifdef STK_TUNE0

+static int stk_ps_tune_zero_func_fae(struct stk3x1x_data *ps_data);

+#endif

+#ifdef STK_CHK_REG

+static int stk3x1x_validate_n_handle(struct i2c_client *client);

+#endif

+static int stk_ps_val(struct stk3x1x_data *ps_data);

+#ifdef STK_QUALCOMM_POWER_CTRL

+static int stk3x1x_device_ctl(struct stk3x1x_data *ps_data, bool enable);

+#endif

+

+static int stk3x1x_i2c_read_data(struct i2c_client *client, unsigned char command, int length, unsigned char *values)

+{

+        uint8_t retry;

+        int err;

+        struct i2c_msg msgs[] = 

+        {

+                {

+                        .addr = client->addr,

+                        .flags = 0,

+                        .len = 1,

+                        .buf = &command,

+                },

+                {

+                        .addr = client->addr,

+                        .flags = I2C_M_RD,

+                        .len = length,

+                        .buf = values,

+                },

+        };

+

+        for (retry = 0; retry < 5; retry++) 

+        {

+                err = i2c_transfer(client->adapter, msgs, 2);

+                if (err == 2)

+                        break;

+                else

+                        mdelay(5);

+        }

+        //printk("stk3x1x_i2c_read_data");

+

+        if (retry >= 5) 

+        {

+                printk(KERN_ERR "%s: i2c read fail, err=%d\n", __func__, err);

+                return -EIO;

+        } 

+        return 0;

+}

+

+static int stk3x1x_i2c_write_data(struct i2c_client *client, unsigned char command, int length, unsigned char *values)

+{

+        int retry;

+        int err;

+        unsigned char data[11];

+        struct i2c_msg msg;

+        int index;

+        //printk("stk3x1x_i2c_write_data");

+

+    if (!client)

+                return -EINVAL;

+    else if (length >= 10) 

+        {        

+        printk(KERN_ERR "%s:length %d exceeds 10\n", __func__, length);

+        return -EINVAL;

+    }   

+

+        data[0] = command;

+        for (index=1;index<=length;index++)

+                data[index] = values[index-1];

+

+        msg.addr = client->addr;

+        msg.flags = 0;

+        msg.len = length+1;

+        msg.buf = data;

+

+        for (retry = 0; retry < 5; retry++) 

+        {

+                err = i2c_transfer(client->adapter, &msg, 1);

+                if (err == 1)

+                        break;

+                else

+                        mdelay(5);

+        }

+

+        if (retry >= 5) 

+        {

+                printk(KERN_ERR "%s: i2c write fail, err=%d\n", __func__, err);

+                return -EIO;

+        }

+        return 0;

+}

+

+static int stk3x1x_i2c_smbus_read_byte_data(struct i2c_client *client, unsigned char command)

+{

+        unsigned char value;

+        int err;

+        err = stk3x1x_i2c_read_data(client, command, 1, &value);

+        if(err < 0)

+                return err;

+        return value;

+}

+

+static int stk3x1x_i2c_smbus_write_byte_data(struct i2c_client *client, unsigned char command, unsigned char value)

+{

+        int err;

+        err = stk3x1x_i2c_write_data(client, command, 1, &value);

+        return err;

+}

+

+uint32_t stk_alscode2lux(struct stk3x1x_data *ps_data, uint32_t alscode)

+{

+        alscode += ((alscode<<7)+(alscode<<3)+(alscode>>1));   

+    alscode<<=3; 

+    alscode/=ps_data->als_transmittance;

+        return alscode;

+}

+

+uint32_t stk_lux2alscode(struct stk3x1x_data *ps_data, uint32_t lux)

+{

+    lux*=ps_data->als_transmittance;

+    lux/=1100;

+    if (unlikely(lux>=(1<<16)))

+        lux = (1<<16) -1;

+    return lux;

+}

+

+#ifndef CONFIG_STK_PS_ALS_USE_CHANGE_THRESHOLD

+static void stk_init_code_threshold_table(struct stk3x1x_data *ps_data)

+{

+    uint32_t i,j;

+    uint32_t alscode;

+

+    code_threshold_table[0] = 0;

+#ifdef STK_DEBUG_PRINTF

+    printk(KERN_INFO "alscode[0]=%d\n",0);

+#endif

+    for (i=1,j=0;i<LUX_THD_TABLE_SIZE;i++,j++)

+    {

+        alscode = stk_lux2alscode(ps_data, lux_threshold_table[j]);

+        printk(KERN_INFO "alscode[%d]=%d\n",i,alscode);

+        code_threshold_table[i] = (uint16_t)(alscode);

+    }

+    code_threshold_table[i] = 0xffff;

+    printk(KERN_INFO "alscode[%d]=%d\n",i,alscode);

+}

+

+static uint32_t stk_get_lux_interval_index(uint16_t alscode)

+{

+    uint32_t i;

+    for (i=1;i<=LUX_THD_TABLE_SIZE;i++)

+    {

+        if ((alscode>=code_threshold_table[i-1])&&(alscode<code_threshold_table[i]))

+        {

+            return i;

+        }

+    }

+    return LUX_THD_TABLE_SIZE;

+}

+#else

+void stk_als_set_new_thd(struct stk3x1x_data *ps_data, uint16_t alscode)

+{

+    int32_t high_thd,low_thd;

+    high_thd = alscode + stk_lux2alscode(ps_data, STK_ALS_CHANGE_THD);

+    low_thd = alscode - stk_lux2alscode(ps_data, STK_ALS_CHANGE_THD);

+    if (high_thd >= (1<<16))

+        high_thd = (1<<16) -1;

+    if (low_thd <0)

+        low_thd = 0;

+    stk3x1x_set_als_thd_h(ps_data, (uint16_t)high_thd);

+    stk3x1x_set_als_thd_l(ps_data, (uint16_t)low_thd);

+}

+#endif // CONFIG_STK_PS_ALS_USE_CHANGE_THRESHOLD

+

+

+static void stk3x1x_proc_plat_data(struct stk3x1x_data *ps_data, struct stk3x1x_platform_data *plat_data)

+{

+        uint8_t w_reg;

+

+        ps_data->state_reg = plat_data->state_reg;

+        ps_data->psctrl_reg = plat_data->psctrl_reg;

+#ifdef STK_POLL_PS

+        ps_data->psctrl_reg &= 0x3F;

+#endif

+        ps_data->alsctrl_reg = plat_data->alsctrl_reg;

+        ps_data->ledctrl_reg = plat_data->ledctrl_reg;

+	if(ps_data->pid == STK3310SA_PID || ps_data->pid == STK3311SA_PID)

+		ps_data->ledctrl_reg &= 0x3F;

+

+        ps_data->wait_reg = plat_data->wait_reg;

+        if(ps_data->wait_reg < 2)

+        {

+                printk(KERN_WARNING "%s: wait_reg should be larger than 2, force to write 2\n", __func__);

+                ps_data->wait_reg = 2;

+        }

+        else if (ps_data->wait_reg > 0xFF)

+        {

+                printk(KERN_WARNING "%s: wait_reg should be less than 0xFF, force to write 0xFF\n", __func__);

+                ps_data->wait_reg = 0xFF;

+        }

+//#ifndef STK_TUNE0

+        if(ps_data->ps_thd_h == 0 && ps_data->ps_thd_l == 0)

+        {

+                ps_data->ps_thd_h = plat_data->ps_thd_h;

+                ps_data->ps_thd_l = plat_data->ps_thd_l;

+        }

+//#endif

+#ifdef CALI_PS_EVERY_TIME

+        ps_data->ps_high_thd_boot = plat_data->ps_thd_h;

+        ps_data->ps_low_thd_boot = plat_data->ps_thd_l;

+#endif

+        w_reg = 0;

+#ifndef STK_POLL_PS

+        w_reg |= STK_INT_PS_MODE;

+#else

+        w_reg |= 0x01;

+#endif

+

+#if (!defined(STK_POLL_ALS) && (STK_INT_PS_MODE != 0x02) && (STK_INT_PS_MODE != 0x03))

+        w_reg |= STK_INT_ALS;

+#endif

+        ps_data->int_reg = w_reg;

+        return;

+}

+

+static int32_t stk3x1x_init_all_reg(struct stk3x1x_data *ps_data)

+{

+        int32_t ret;

+

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_STATE_REG, ps_data->state_reg);

+    if (ret < 0)

+    {

+        printk(KERN_ERR "%s: write i2c error\n", __func__);

+        return ret;

+    }

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_PSCTRL_REG, ps_data->psctrl_reg);

+    if (ret < 0)

+    {

+        printk(KERN_ERR "%s: write i2c error\n", __func__);

+        return ret;

+    }

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_ALSCTRL_REG, ps_data->alsctrl_reg);

+    if (ret < 0)

+    {

+        printk(KERN_ERR "%s: write i2c error\n", __func__);

+        return ret;

+    }

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_LEDCTRL_REG, ps_data->ledctrl_reg);

+    if (ret < 0)

+    {

+        printk(KERN_ERR "%s: write i2c error\n", __func__);

+        return ret;

+    }

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_WAIT_REG, ps_data->wait_reg);

+    if (ret < 0)

+    {

+        printk(KERN_ERR "%s: write i2c error\n", __func__);

+        return ret;

+    }

+#ifdef STK_TUNE0

+        ps_data->psa = 0x0;

+        ps_data->psi = 0xFFFF;

+#endif

+//#else

+        stk3x1x_set_ps_thd_h(ps_data, ps_data->ps_thd_h);

+        stk3x1x_set_ps_thd_l(ps_data, ps_data->ps_thd_l);

+//#endif

+

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_INT_REG, ps_data->int_reg);

+    if (ret < 0)

+        {

+                printk(KERN_ERR "%s: write i2c error\n", __func__);

+                return ret;

+        }

+

+        /*

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, 0x87, 0x60);

+    if (ret < 0)

+        {

+                printk(KERN_ERR "%s: write i2c error\n", __func__);

+                return ret;

+        }

+        */

+

+        return 0;

+}

+

+static int32_t stk3x1x_read_otp25(struct stk3x1x_data *ps_data)	

+{

+	int32_t ret, otp25;

+	

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, 0x0, 0x2);

+    if (ret < 0)

+    {

+        printk(KERN_ERR "%s: write i2c error\n", __func__);

+        return ret;

+    }	

+	

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, 0x90, 0x25);

+    if (ret < 0)

+    {

+        printk(KERN_ERR "%s: write i2c error\n", __func__);

+        return ret;

+    }	

+	

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, 0x92, 0x82);

+    if (ret < 0)

+    {

+        printk(KERN_ERR "%s: write i2c error\n", __func__);

+        return ret;

+    }	

+	usleep_range(1000, 5000);

+

+    ret = stk3x1x_i2c_smbus_read_byte_data(ps_data->client,0x91);

+    if (ret < 0)

+    {

+		printk(KERN_ERR "%s: fail, ret=%d\n", __func__, ret);

+        return ret;

+    }

+	otp25 = ret;

+	

+   ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, 0x0, 0x0);

+    if (ret < 0)

+    {

+        printk(KERN_ERR "%s: write i2c error\n", __func__);

+        return ret;

+    }

+	printk(KERN_INFO "%s: otp25=0x%x\n", __func__, otp25);

+	if(otp25 & 0x80)

+		return 1;

+	return 0;

+}

+

+static int32_t stk3x1x_check_pid(struct stk3x1x_data *ps_data)

+{

+	unsigned char value[2], pid_msb;

+	int err;

+

+	ps_data->p_wv_r_bd_with_co = 0;

+	

+	err = stk3x1x_i2c_read_data(ps_data->client, STK_PDT_ID_REG, 2, &value[0]);

+	if(err < 0)

+	{

+		printk(KERN_ERR "%s: fail, ret=%d\n", __func__, err);

+		return err;

+	}

+

+	printk(KERN_INFO "%s: PID=0x%x, RID=0x%x\n", __func__, value[0], value[1]);

+	ps_data->pid = value[0];

+

+	if(value[0] == STK3311WV_PID)

+		ps_data->p_wv_r_bd_with_co |= 0b100;

+	if(value[1] == 0xC3)

+		ps_data->p_wv_r_bd_with_co |= 0b010;

+		

+	if(stk3x1x_read_otp25(ps_data) == 1)

+	{

+		ps_data->p_wv_r_bd_with_co |= 0b001;

+	}

+	printk(KERN_INFO "%s: p_wv_r_bd_with_co = 0x%x\n", __func__, ps_data->p_wv_r_bd_with_co);	

+

+	if(value[0] == 0)

+	{

+		printk(KERN_ERR "PID=0x0, please make sure the chip is stk3x1x!\n");

+		return -2;			

+	}

+	

+	pid_msb = value[0] & 0xF0;

+	switch(pid_msb)

+	{

+	case 0x10:

+	case 0x20:

+	case 0x30:

+		return 0;

+	default:

+		printk(KERN_ERR "%s: invalid PID(%#x)\n", __func__, value[0]);	

+		return -1;

+	}

+	return 0;

+}

+

+

+static int32_t stk3x1x_software_reset(struct stk3x1x_data *ps_data)

+{

+    int32_t r;

+    uint8_t w_reg;

+

+    w_reg = 0x7F;

+    r = stk3x1x_i2c_smbus_write_byte_data(ps_data->client,STK_WAIT_REG,w_reg);

+    if (r<0)

+    {

+        printk(KERN_ERR "%s: software reset: write i2c error, ret=%d\n", __func__, r);

+        return r;

+    }

+    r = stk3x1x_i2c_smbus_read_byte_data(ps_data->client,STK_WAIT_REG);

+    if (w_reg != r)

+    {

+        printk(KERN_ERR "%s: software reset: read-back value is not the same\n", __func__);

+        return -1;

+    }

+

+    r = stk3x1x_i2c_smbus_write_byte_data(ps_data->client,STK_SW_RESET_REG,0);

+    if (r<0)

+    {

+        printk(KERN_ERR "%s: software reset: read error after reset\n", __func__);

+        return r;

+    }

+	usleep_range(13000, 15000);

+    return 0;

+}

+

+

+static int32_t stk3x1x_set_als_thd_l(struct stk3x1x_data *ps_data, uint16_t thd_l)

+{

+        unsigned char val[2];

+        int ret;

+        val[0] = (thd_l & 0xFF00) >> 8;

+        val[1] = thd_l & 0x00FF;

+        ret = stk3x1x_i2c_write_data(ps_data->client, STK_THDL1_ALS_REG, 2, val);

+        if(ret < 0)

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, ret);

+        return ret;

+}

+static int32_t stk3x1x_set_als_thd_h(struct stk3x1x_data *ps_data, uint16_t thd_h)

+{

+        unsigned char val[2];

+        int ret;

+        val[0] = (thd_h & 0xFF00) >> 8;

+        val[1] = thd_h & 0x00FF;

+        ret = stk3x1x_i2c_write_data(ps_data->client, STK_THDH1_ALS_REG, 2, val);

+        if(ret < 0)

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, ret);

+        return ret;

+}

+

+static int32_t stk3x1x_set_ps_thd_l(struct stk3x1x_data *ps_data, uint16_t thd_l)

+{

+        unsigned char val[2];

+        int ret;

+        val[0] = (thd_l & 0xFF00) >> 8;

+        val[1] = thd_l & 0x00FF;

+        ret = stk3x1x_i2c_write_data(ps_data->client, STK_THDL1_PS_REG, 2, val);

+        if(ret < 0)

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, ret);

+        return ret;

+}

+static int32_t stk3x1x_set_ps_thd_h(struct stk3x1x_data *ps_data, uint16_t thd_h)

+{

+        unsigned char val[2];

+        int ret;

+        val[0] = (thd_h & 0xFF00) >> 8;

+        val[1] = thd_h & 0x00FF;

+        ret = stk3x1x_i2c_write_data(ps_data->client, STK_THDH1_PS_REG, 2, val);

+        if(ret < 0)

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, ret);

+        return ret;

+}

+

+static uint32_t stk3x1x_get_ps_reading(struct stk3x1x_data *ps_data)

+{

+        unsigned char value[2];

+        int err;

+        err = stk3x1x_i2c_read_data(ps_data->client, STK_DATA1_PS_REG, 2, &value[0]);

+        if(err < 0)

+        {

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, err);

+                return err;

+        }

+        return ((value[0]<<8) | value[1]);

+}

+

+

+static int32_t stk3x1x_set_flag(struct stk3x1x_data *ps_data, uint8_t org_flag_reg, uint8_t clr)

+{

+        uint8_t w_flag;

+        int ret;

+

+        w_flag = org_flag_reg | (STK_FLG_ALSINT_MASK | STK_FLG_PSINT_MASK | STK_FLG_OUI_MASK | STK_FLG_IR_RDY_MASK);

+        w_flag &= (~clr);

+        //printk(KERN_INFO "%s: org_flag_reg=0x%x, w_flag = 0x%x\n", __func__, org_flag_reg, w_flag);

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client,STK_FLAG_REG, w_flag);

+        if(ret < 0)

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, ret);

+        return ret;

+}

+

+static int32_t stk3x1x_get_flag(struct stk3x1x_data *ps_data)

+{

+        int ret;

+    ret = stk3x1x_i2c_smbus_read_byte_data(ps_data->client,STK_FLAG_REG);

+        if(ret < 0)

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, ret);

+        return ret;

+}

+

+#ifdef STK_GES

+static int32_t stk3x1x_set_flag2(struct stk3x1x_data *ps_data, uint8_t org_flag2_reg, uint8_t clr)

+{

+        uint8_t w_flag2;

+        int ret;

+

+        w_flag2 = org_flag2_reg | 0x72;

+        w_flag2 &= (~clr);

+        //printk(KERN_INFO "%s: org_flag2_reg=0x%x, w_flag2 = 0x%x\n", __func__, org_flag2_reg, w_flag2);

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client,STK_FLAG2_REG, w_flag2);

+        if(ret < 0)

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, ret);

+        return ret;

+}

+

+static int32_t stk3x1x_get_flag2(struct stk3x1x_data *ps_data)

+{

+        int ret;

+    ret = stk3x1x_i2c_smbus_read_byte_data(ps_data->client,STK_FLAG2_REG);

+        if(ret < 0)

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, ret);

+        return ret;

+}

+#endif

+

+static int32_t stk3x1x_set_state(struct stk3x1x_data *ps_data, uint8_t state)

+{

+        int ret;

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client,STK_STATE_REG, state);

+        if(ret < 0)

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, ret);

+        return ret;

+}

+

+static int32_t stk3x1x_get_state(struct stk3x1x_data *ps_data)

+{

+        int ret;

+    ret = stk3x1x_i2c_smbus_read_byte_data(ps_data->client,STK_STATE_REG);

+        if(ret < 0)

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, ret);

+        return ret;

+}

+

+#ifdef STK_GES

+static int32_t stk3x1x_set_gsctrl(struct stk3x1x_data *ps_data, uint8_t state)

+{

+        int ret;

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client,STK_GSCTRL_REG, state);

+        if(ret < 0)

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, ret);

+        return ret;

+}

+

+static int32_t stk3x1x_get_gsctrl(struct stk3x1x_data *ps_data)

+{

+        int ret;

+    ret = stk3x1x_i2c_smbus_read_byte_data(ps_data->client,STK_GSCTRL_REG);

+        if(ret < 0)

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, ret);

+        return ret;

+}

+

+#if 0

+static uint32_t stk3x1x_get_ges_reading(struct stk3x1x_data *ps_data, unsigned int *ges0,

+                                unsigned int *ges1, unsigned int *ges2)

+{

+        int retry, len, no = 0;

+        uint8_t reg_val_crit;

+        int err;

+        unsigned char value[10];

+

+        while(stk_ges_op[no].ops[1] != 0)

+        {

+                retry = stk_ges_op[no].action.rw_len_retry & 0x0F;

+                len = (stk_ges_op[no].action.rw_len_retry & 0x70) >> 4;

+                reg_val_crit = stk_ges_op[no].action.reg_value_retry_crit;

+                if(stk_ges_op[no].action.rw_len_retry & 0x80)

+                {

+                        while(retry != 0)

+                        {

+                                err = stk3x1x_i2c_read_data(ps_data->client, 

+                                                                stk_ges_op[no].action.reg, len, value);

+                                if(err < 0)

+                                {

+                                        printk(KERN_ERR "%s: fail, ret=%d\n", __func__, err);

+                                        return err;

+                                }

+                                if(reg_val_crit)

+                                {

+                                        if(value[0] & reg_val_crit)

+                                                break;

+                                }

+                                if(stk_ges_op[no].action.sleep_10ns != 0)

+                                        usleep_range(stk_ges_op[no].action.sleep_10ns*10, 

+                                                                        stk_ges_op[no].action.sleep_10ns*10+300);

+                                retry--;

+                        }

+                }

+                else

+                {

+                        while(retry != 0)

+                        {

+                                err = stk3x1x_i2c_write_data(ps_data->client, stk_ges_op[no].action.reg, 

+                                                                len, &reg_val_crit);

+                                if(err < 0)

+                                {

+                                        printk(KERN_ERR "%s: fail, err=%d\n", __func__, err);

+                                        return err;

+                                }

+

+                                if(stk_ges_op[no].action.sleep_10ns != 0)

+                                        usleep_range(stk_ges_op[no].action.sleep_10ns*10, 

+                                                                        stk_ges_op[no].action.sleep_10ns*10+300);

+                                retry--;

+                        }

+                }

+

+                if(stk_ges_op[no].action.reg == 0x24)

+                {

+                        *ges0 = (value[0]<<8) | value[1];

+                        *ges1 = (value[2]<<8) | value[3];

+                }

+                else if(stk_ges_op[no].action.reg == stk_ges_op[9].ops[0])

+                {

+                        *ges2 = (value[0]<<8) | value[1];

+                }

+

+                no++;

+        }

+        return 0;

+}

+

+#else

+static uint32_t stk3x1x_get_ges_reading(struct stk3x1x_data *ps_data, unsigned int *ges0,unsigned int *ges1,unsigned int *ges2)

+{

+        unsigned char value[4];

+        int err, retry = 10;

+

+        do {

+                err = stk3x1x_get_flag(ps_data);

+                if(err < 0)

+                        return err;

+                if(err & STK_FLG_PSDR_MASK)

+                        break;

+                //printk(KERN_INFO "ges: not ready, %d\n", retry);

+                retry--;

+                usleep_range(350, 1000);

+        } while(retry > 0);

+        err = stk3x1x_i2c_read_data(ps_data->client, STK_DATA1_PS_REG, 2, &value[0]);

+

+        err = stk3x1x_i2c_read_data(ps_data->client, 0x24, 4, &value[0]);

+        if(err < 0)

+        {

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, err);

+                return err;

+        }

+        *ges0 = (value[0]<<8) | value[1];

+        *ges1 = (value[2]<<8) | value[3];

+        //printk(KERN_INFO "%s: ges=%d,%d\n",__func__, *ges0, *ges1);

+        return 0;

+}

+#endif

+

+static int32_t stk3x1x_enable_ges(struct stk3x1x_data *ps_data, uint8_t enable, uint8_t mode)

+{

+    int32_t ret;

+        uint8_t w_state_reg, gsctrl_reg;

+        uint8_t org_mode = 0;

+

+        if(ps_data->ps_enabled)

+        {

+                printk(KERN_INFO "%s: since PS is enabled, ges is disabled\n", __func__);

+                ps_data->re_enable_ges = enable;

+                return 0;

+        }

+

+        if(enable == ps_data->ges_enabled)

+                return 0;

+

+        if(enable)

+        {

+#ifdef STK_QUALCOMM_POWER_CTRL

+                ret = stk3x1x_device_ctl(ps_data, enable);

+                if (ret)

+                        return ret;

+#endif

+                if(ps_data->als_enabled) 

+                {

+                        printk(KERN_INFO "%s: force disable ALS\n", __func__);

+                        stk3x1x_enable_als(ps_data, 0);

+                        ps_data->re_enable_als = true;

+                }

+

+                ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_WAIT_REG, 0);

+                if (ret < 0)

+                {

+                        printk(KERN_ERR "%s: write i2c error\n", __func__);

+                        return ret;

+                }

+

+                ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_INT_REG, 0);

+                if (ret < 0)

+                {

+                        printk(KERN_ERR "%s: write i2c error\n", __func__);

+                        return ret;

+                }

+

+                w_state_reg = STK_STATE_EN_WAIT_MASK | STK_STATE_EN_PS_MASK; 

+                ret = stk3x1x_set_state(ps_data, w_state_reg);

+                if(ret < 0)

+                        return ret;

+				ps_data->state_reg = w_state_reg;

+

+                if(mode == 2)

+                {

+                        ret = stk3x1x_get_gsctrl(ps_data);

+                        if(ret < 0)

+                                return ret;

+                        gsctrl_reg = ret & 0xF3;

+#ifdef STK_POLL_PS

+                        gsctrl_reg |= 0x04;

+#else

+                        gsctrl_reg |= 0x0C;

+#endif

+                        ret = stk3x1x_set_gsctrl(ps_data, gsctrl_reg);

+                        if(ret < 0)

+                                return ret;

+#ifdef STK_POLL_PS

+                        hrtimer_start(&ps_data->ps_timer, ps_data->ps_poll_delay, HRTIMER_MODE_REL);

+#else

+                        enable_irq(ps_data->irq);

+#endif

+                }

+                ps_data->ges_enabled = mode;

+        }

+        else

+        {

+                org_mode = ps_data->ges_enabled;

+                if(org_mode == 2)

+                {

+#ifdef STK_POLL_PS

+                        hrtimer_cancel(&ps_data->ps_timer);

+                        cancel_work_sync(&ps_data->stk_ps_work);

+#else

+                        disable_irq(ps_data->irq);

+#endif

+                }

+

+                ret = stk3x1x_set_state(ps_data, 0);

+                if(ret < 0)

+                        return ret;

+				ps_data->state_reg = 0;

+

+                ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_WAIT_REG, ps_data->wait_reg);

+                if (ret < 0)

+                {

+                        printk(KERN_ERR "%s: write i2c error\n", __func__);

+                        return ret;

+                }

+

+                ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_INT_REG, ps_data->int_reg);

+                if (ret < 0)

+                {

+                        printk(KERN_ERR "%s: write i2c error\n", __func__);

+                        return ret;

+                }

+                if(org_mode == 2)

+                {

+                        ret = stk3x1x_get_gsctrl(ps_data);

+                        if(ret < 0)

+                                return ret;

+                        gsctrl_reg = ret & (~0x0C);

+                        ret = stk3x1x_set_gsctrl(ps_data, gsctrl_reg);

+                        if(ret < 0)

+                                return ret;

+                }

+                ps_data->ges_enabled = 0;

+                if(ps_data->re_enable_als) 

+                {

+                        printk(KERN_INFO "%s: re-enable ALS\n", __func__);

+                        stk3x1x_enable_als(ps_data, 1);

+                        ps_data->re_enable_als = false;

+                }

+#ifdef STK_QUALCOMM_POWER_CTRL

+                ret = stk3x1x_device_ctl(ps_data, enable);

+                if (ret)

+                        return ret;

+#endif

+        }

+

+        return 0;

+}

+#endif /* #ifdef STK_GES */

+

+static int32_t stk3x1x_enable_ps(struct stk3x1x_data *ps_data, uint8_t enable, uint8_t validate_reg)

+{

+    int32_t ret;

+        uint8_t w_state_reg;

+        uint8_t curr_ps_enable;

+        uint32_t reading;

+        int32_t near_far_state;

+

+#ifdef STK_QUALCOMM_POWER_CTRL

+        if (enable) {

+                ret = stk3x1x_device_ctl(ps_data, enable);

+                if (ret)

+                        return ret;

+        }

+#endif

+

+#ifdef STK_CHK_REG

+        if(validate_reg)

+        {

+                ret = stk3x1x_validate_n_handle(ps_data->client);

+                if(ret < 0)

+                        printk(KERN_ERR "stk3x1x_validate_n_handle fail: %d\n", ret); 

+        }

+#endif /* #ifdef STK_CHK_REG */

+

+#ifdef STK_GES

+        if(ps_data->ges_enabled && enable)

+        {

+                printk(KERN_INFO "%s: force disable ges\n", __func__);

+                stk3x1x_enable_ges(ps_data, 0, 1);

+                ps_data->re_enable_ges = 1;

+        }

+#endif

+        curr_ps_enable = ps_data->ps_enabled?1:0;

+        if(curr_ps_enable == enable)

+                return 0;

+

+#ifdef STK_TUNE0

+        if (!(ps_data->psi_set) && !enable)

+        {

+                hrtimer_cancel(&ps_data->ps_tune0_timer);

+                cancel_work_sync(&ps_data->stk_ps_tune0_work);

+        }

+#endif

+        if(ps_data->first_boot == true)

+        {

+                ps_data->first_boot = false;

+        }

+

+        ret = stk3x1x_get_state(ps_data);

+        if(ret < 0)

+                return ret;

+        w_state_reg = ret;

+

+

+        w_state_reg &= ~(STK_STATE_EN_PS_MASK | STK_STATE_EN_WAIT_MASK | STK_STATE_EN_AK_MASK); 

+        if(enable)

+        {

+                w_state_reg |= STK_STATE_EN_PS_MASK;

+                if(!(ps_data->als_enabled))

+                        w_state_reg |= STK_STATE_EN_WAIT_MASK;

+        }

+        ret = stk3x1x_set_state(ps_data, w_state_reg);

+        if(ret < 0)

+                return ret;

+		ps_data->state_reg = w_state_reg;

+

+    if(enable)

+        {

+#ifdef STK_TUNE0

+        #ifdef CALI_PS_EVERY_TIME

+                ps_data->psi_set = 0;

+                ps_data->psa = 0;

+                ps_data->psi = 0xFFFF;

+                #ifndef QUALCOMM_PLATFORM

+                ps_data->ps_thd_h = ps_data->ps_high_thd_boot;

+                ps_data->ps_thd_l = ps_data->ps_low_thd_boot;

+                #endif

+                hrtimer_start(&ps_data->ps_tune0_timer, ps_data->ps_tune0_delay, HRTIMER_MODE_REL);

+        #else

+

+                if (!(ps_data->psi_set))

+                        hrtimer_start(&ps_data->ps_tune0_timer, ps_data->ps_tune0_delay, HRTIMER_MODE_REL);

+        #endif  /* #ifdef CALI_PS_EVERY_TIME */

+                stk3x1x_set_ps_thd_h(ps_data, ps_data->ps_thd_h);

+                stk3x1x_set_ps_thd_l(ps_data, ps_data->ps_thd_l);

+#endif

+                printk(KERN_INFO "%s: HT=%d,LT=%d\n", __func__, ps_data->ps_thd_h,  ps_data->ps_thd_l);

+#ifdef STK_POLL_PS

+                hrtimer_start(&ps_data->ps_timer, ps_data->ps_poll_delay, HRTIMER_MODE_REL);

+                ps_data->ps_distance_last = -1;

+#endif

+#ifndef STK_POLL_PS

+        #ifndef STK_POLL_ALS

+                if(!(ps_data->als_enabled))

+        #endif  /* #ifndef STK_POLL_ALS */

+                        enable_irq(ps_data->irq);

+#endif  /* #ifndef STK_POLL_PS */

+                ps_data->ps_enabled = true;

+#ifdef STK_CHK_REG

+                if(!validate_reg)

+                {

+                        ps_data->ps_distance_last = 1;

+                        input_report_abs(ps_data->ps_input_dev, ABS_DISTANCE, 1);

+                        input_sync(ps_data->ps_input_dev);

+                        wake_lock_timeout(&ps_data->ps_wakelock, 3*HZ);

+                        reading = stk3x1x_get_ps_reading(ps_data);

+                        printk(KERN_INFO "%s: force report ps input event=1, ps code = %d\n",__func__, reading);

+                }

+                else

+#endif /* #ifdef STK_CHK_REG */

+                {

+                        usleep_range(4000, 5000);

+                        ret = stk3x1x_get_flag(ps_data);

+                        if (ret < 0)

+                                return ret;

+                        near_far_state = ret & STK_FLG_NF_MASK;

+                        ps_data->ps_distance_last = near_far_state;

+                        input_report_abs(ps_data->ps_input_dev, ABS_DISTANCE, near_far_state);

+                        input_sync(ps_data->ps_input_dev);

+                        wake_lock_timeout(&ps_data->ps_wakelock, 3*HZ);

+                        reading = stk3x1x_get_ps_reading(ps_data);

+                        printk(KERN_INFO "%s: ps input event=%d, ps code = %d\n",__func__, near_far_state, reading);

+                }

+        }

+        else

+        {

+#ifdef STK_POLL_PS

+                hrtimer_cancel(&ps_data->ps_timer);

+                cancel_work_sync(&ps_data->stk_ps_work);

+#else

+#ifndef STK_POLL_ALS

+                if(!(ps_data->als_enabled))

+#endif

+                        disable_irq(ps_data->irq);

+#endif

+                ps_data->ps_enabled = false;

+#ifdef STK_GES

+                if(ps_data->re_enable_ges)

+                {

+                        printk(KERN_INFO "%s: re-enable ges\n", __func__);

+                        stk3x1x_enable_ges(ps_data, 1, 1);

+                        ps_data->re_enable_ges = 0;

+                }

+#endif

+#ifdef STK_QUALCOMM_POWER_CTRL

+                ret = stk3x1x_device_ctl(ps_data, enable);

+                if (ret)

+                        return ret;

+#endif

+        }

+        return ret;

+}

+

+static int32_t stk3x1x_enable_als(struct stk3x1x_data *ps_data, uint8_t enable)

+{

+    int32_t ret;

+        uint8_t w_state_reg;

+        uint8_t curr_als_enable = (ps_data->als_enabled)?1:0;

+

+#ifdef STK_GES

+        if(ps_data->ges_enabled)

+        {

+                printk(KERN_INFO "%s: since ges is enabled, ALS is disabled\n", __func__);

+                ps_data->re_enable_als = enable ? true : false;

+                return 0;

+        }

+#endif  /* #ifdef STK_GES */

+        if(curr_als_enable == enable)

+                return 0;

+#ifdef STK_QUALCOMM_POWER_CTRL

+        if (enable) {

+                ret = stk3x1x_device_ctl(ps_data, enable);

+                if (ret)

+                        return ret;

+        }

+#endif

+#ifndef STK_POLL_ALS

+        #ifdef STK_IRS

+        if(enable && !(ps_data->ps_enabled))

+        {

+		ret = stk3x1x_get_ir_reading(ps_data, STK_IRS_IT_REDUCE	);

+                if(ret > 0)

+                        ps_data->ir_code = ret;

+        }

+        #endif

+

+    if (enable)

+        {

+        stk3x1x_set_als_thd_h(ps_data, 0x0000);

+        stk3x1x_set_als_thd_l(ps_data, 0xFFFF);

+        }

+#endif

+

+        ret = stk3x1x_get_state(ps_data);

+        if(ret < 0)

+                return ret;

+

+        w_state_reg = (uint8_t)(ret & (~(STK_STATE_EN_ALS_MASK | STK_STATE_EN_WAIT_MASK))); 

+        if(enable)

+                w_state_reg |= STK_STATE_EN_ALS_MASK;

+        else if (ps_data->ps_enabled)

+                w_state_reg |= STK_STATE_EN_WAIT_MASK;

+

+        ret = stk3x1x_set_state(ps_data, w_state_reg);

+        if(ret < 0)

+                return ret;

+		ps_data->state_reg = w_state_reg;

+

+    if (enable)

+    {

+                ps_data->als_enabled = true;

+#ifdef STK_POLL_ALS

+                hrtimer_start(&ps_data->als_timer, ps_data->als_poll_delay, HRTIMER_MODE_REL);

+#else

+#ifndef STK_POLL_PS

+                if(!(ps_data->ps_enabled))

+#endif

+                        enable_irq(ps_data->irq);

+#endif

+#ifdef STK_IRS

+                ps_data->als_data_index = 0;

+#endif

+    }

+        else

+        {

+                ps_data->als_enabled = false;

+#ifdef STK_POLL_ALS

+                hrtimer_cancel(&ps_data->als_timer);

+                cancel_work_sync(&ps_data->stk_als_work);

+#else

+#ifndef STK_POLL_PS

+                if(!(ps_data->ps_enabled))

+#endif

+                        disable_irq(ps_data->irq);

+#endif

+#ifdef STK_QUALCOMM_POWER_CTRL

+                ret = stk3x1x_device_ctl(ps_data, enable);

+                if (ret)

+                        return ret;

+#endif

+        }

+    return ret;

+}

+

+static int32_t stk3x1x_get_als_reading(struct stk3x1x_data *ps_data)

+{

+    int32_t als_data, ir_data = 0;

+#ifdef STK_ALS_FIR

+        int index;   

+        int firlen = atomic_read(&ps_data->firlength);   

+#endif

+        unsigned char value[2];

+        int ret;

+	const int ir_enlarge = 1 << (STK_ALS_READ_IRS_IT_REDUCE - STK_IRS_IT_REDUCE);

+

+        ret = stk3x1x_i2c_read_data(ps_data->client, STK_DATA1_ALS_REG, 2, &value[0]);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s fail, ret=0x%x", __func__, ret);

+                return ret;

+        }

+		als_data = (value[0]<<8) | value[1];

+	// printk("%s: raw als_data=%d\n", __func__, als_data);

+	if(ps_data->p_wv_r_bd_with_co & 0b010)

+	{

+		if(als_data < STK_ALS_THRESHOLD && ps_data->als_code_last > 10000)

+		{

+			ir_data = stk3x1x_get_ir_reading(ps_data, STK_ALS_READ_IRS_IT_REDUCE);

+#ifdef STK_IRS				

+			if(ir_data > 0)

+				ps_data->ir_code = ir_data * ir_enlarge;

+#endif			

+			// printk(KERN_INFO "%s: als_data=%d, als_code_last=%d,ir_data=%d\n", 

+					// __func__, als_data, ps_data->als_code_last, ir_data);	

+			if(ir_data > (STK_ALS_THRESHOLD*3))

+			{

+				als_data = ps_data->als_code_last;

+			}

+		}

+#ifdef STK_IRS			

+		else

+		{

+			ps_data->ir_code = 0;

+		}

+#endif		

+	}

+	

+	ps_data->als_code_last = als_data;

+

+#ifdef STK_ALS_FIR

+	if(ps_data->fir.number < firlen)

+	{                

+		ps_data->fir.raw[ps_data->fir.number] = als_data;

+		ps_data->fir.sum += als_data;

+		ps_data->fir.number++;

+		ps_data->fir.idx++;

+	}

+	else

+	{

+		index = ps_data->fir.idx % firlen;

+		ps_data->fir.sum -= ps_data->fir.raw[index];

+		ps_data->fir.raw[index] = als_data;

+		ps_data->fir.sum += als_data;

+		ps_data->fir.idx++;

+		als_data = ps_data->fir.sum/firlen;

+	}	

+#endif	

+

+	return als_data;

+}

+

+

+#if (defined(STK_IRS) && defined(STK_POLL_ALS))

+static int stk_als_ir_skip_als(struct stk3x1x_data *ps_data)

+{

+	int ret;

+	unsigned char value[2];	

+	

+	if(ps_data->als_data_index < 60000)

+		ps_data->als_data_index++;

+	else

+		ps_data->als_data_index = 0;

+	

+	if(	ps_data->als_data_index % 10 == 1)

+	{

+		ret = stk3x1x_i2c_read_data(ps_data->client, STK_DATA1_ALS_REG, 2, &value[0]);

+		if(ret < 0)

+		{

+			printk(KERN_ERR "%s fail, ret=0x%x", __func__, ret);

+			return ret;

+		}

+		return 1;

+	}

+	return 0;

+}

+

+static void stk_als_ir_get_corr(struct stk3x1x_data *ps_data, int32_t als)

+{

+	int32_t als_comperator;

+	

+	if(ps_data->ir_code)

+	{

+		ps_data->als_correct_factor = 1000;

+		if(als < STK_IRC_MAX_ALS_CODE && als > STK_IRC_MIN_ALS_CODE && 

+			ps_data->ir_code > STK_IRC_MIN_IR_CODE)

+		{

+			als_comperator = als * STK_IRC_ALS_NUMERA / STK_IRC_ALS_DENOMI;

+			if(ps_data->ir_code > als_comperator)

+				ps_data->als_correct_factor = STK_IRC_ALS_CORREC;

+		}

+#ifdef STK_DEBUG_PRINTF				

+		printk(KERN_INFO "%s: als=%d, ir=%d, als_correct_factor=%d", __func__, 

+						als, ps_data->ir_code, ps_data->als_correct_factor);

+#endif		

+		ps_data->ir_code = 0;

+	}	

+	return;

+}

+

+static int stk_als_ir_run(struct stk3x1x_data *ps_data)

+{

+	int ret;

+	

+	if(	ps_data->als_data_index % 10 == 0)

+	{

+		if(ps_data->ps_distance_last != 0 && ps_data->ir_code == 0)

+		{

+			ret = stk3x1x_get_ir_reading(ps_data, STK_IRS_IT_REDUCE);

+			if(ret > 0)

+				ps_data->ir_code = ret;

+		}		

+		return ret;

+	}	

+	return 0;

+}

+#endif	/* #if (defined(STK_IRS) && defined(STK_POLL_ALS)) */

+

+

+static int32_t stk3x1x_set_irs_it_slp(struct stk3x1x_data *ps_data, uint16_t *slp_time, int32_t ials_it_reduce)

+{

+	uint8_t irs_alsctrl;

+	int32_t ret;

+		

+	irs_alsctrl = (ps_data->alsctrl_reg & 0x0F) - ials_it_reduce;

+	switch(irs_alsctrl)

+	{

+		case 2:

+			*slp_time = 1;

+			break;			

+		case 3:

+			*slp_time = 2;

+			break;	

+		case 4:

+			*slp_time = 3;

+			break;	

+		case 5:

+			*slp_time = 6;

+			break;

+		case 6:

+			*slp_time = 12;

+			break;

+		case 7:

+			*slp_time = 24;			

+			break;

+		case 8:

+			*slp_time = 48;			

+			break;

+		case 9:

+			*slp_time = 96;			

+			break;				

+		case 10:

+			*slp_time = 192;

+			break;				

+		default:

+			printk(KERN_ERR "%s: unknown ALS IT=0x%x\n", __func__, irs_alsctrl);

+			ret = -EINVAL;	

+			return ret;

+	}

+	irs_alsctrl |= (ps_data->alsctrl_reg & 0xF0);

+	ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_ALSCTRL_REG, irs_alsctrl);

+	if (ret < 0)

+	{

+		printk(KERN_ERR "%s: write i2c error\n", __func__);

+		return ret;		

+	}		

+	return 0;

+}

+

+static int32_t stk3x1x_get_ir_reading(struct stk3x1x_data *ps_data, int32_t als_it_reduce)

+{

+    int32_t word_data, ret;

+	uint8_t w_reg, retry = 0;	

+	uint16_t irs_slp_time = 100;

+	unsigned char value[2];

+	

+	ret = stk3x1x_set_irs_it_slp(ps_data, &irs_slp_time, als_it_reduce);

+	if(ret < 0)

+		goto irs_err_i2c_rw;

+	

+	ret = stk3x1x_get_state(ps_data);

+	if(ret < 0)

+		goto irs_err_i2c_rw;

+	

+	w_reg = ret | STK_STATE_EN_IRS_MASK;		

+	ret = stk3x1x_set_state(ps_data, w_reg);

+	if(ret < 0)

+		goto irs_err_i2c_rw;

+	msleep(irs_slp_time);	

+	

+	do

+	{

+		usleep_range(3000, 4000);

+		ret = stk3x1x_get_flag(ps_data);

+		if (ret < 0)

+			goto irs_err_i2c_rw;

+		retry++;

+	}while(retry < 10 && ((ret&STK_FLG_IR_RDY_MASK) == 0));

+	

+	if(retry == 10)

+	{

+		printk(KERN_ERR "%s: ir data is not ready for a long time\n", __func__);

+		ret = -EINVAL;

+		goto irs_err_i2c_rw;

+	}

+

+	ret = stk3x1x_set_flag(ps_data, ret, STK_FLG_IR_RDY_MASK);

+    if (ret < 0)

+		goto irs_err_i2c_rw;

+	

+	ret = stk3x1x_i2c_read_data(ps_data->client, STK_DATA1_IR_REG, 2, &value[0]);

+	if(ret < 0)

+	{

+		printk(KERN_ERR "%s fail, ret=0x%x", __func__, ret);

+		goto irs_err_i2c_rw;

+	}

+	word_data = ((value[0]<<8) | value[1]);	

+	//printk(KERN_INFO "%s: ir=%d\n", __func__, word_data);

+	

+	ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_ALSCTRL_REG, ps_data->alsctrl_reg );

+	if (ret < 0)

+	{

+		printk(KERN_ERR "%s: write i2c error\n", __func__);

+		goto irs_err_i2c_rw;

+	}

+				

+	return word_data;

+

+irs_err_i2c_rw:		

+	return ret;

+}

+

+#ifdef STK_CHK_REG

+static int stk3x1x_chk_reg_valid(struct stk3x1x_data *ps_data) 

+{

+        unsigned char value[9];

+        int err;

+        /*

+        uint8_t cnt;

+

+        for(cnt=0;cnt<9;cnt++)

+        {

+                value[cnt] = stk3x1x_i2c_smbus_read_byte_data(ps_data->client, (cnt+1));

+                if(value[cnt] < 0)

+                {

+                        printk(KERN_ERR "%s fail, ret=%d", __func__, value[cnt]);

+                        return value[cnt];

+                }

+        }

+        */

+        err = stk3x1x_i2c_read_data(ps_data->client, STK_PSCTRL_REG, 9, &value[0]);

+        if(err < 0)

+        {

+                printk(KERN_ERR "%s: fail, ret=%d\n", __func__, err);

+                return err;

+        }

+

+        if(value[0] != ps_data->psctrl_reg)

+        {

+                printk(KERN_ERR "%s: invalid reg 0x01=0x%2x\n", __func__, value[0]);

+                return 0xFF;

+        }

+#ifdef STK_IRS	

+	if((value[1] != ps_data->alsctrl_reg) && (value[1] != (ps_data->alsctrl_reg - STK_IRS_IT_REDUCE))

+		&& (value[1] != (ps_data->alsctrl_reg - STK_ALS_READ_IRS_IT_REDUCE)))

+#else

+	if((value[1] != ps_data->alsctrl_reg) && (value[1] != (ps_data->alsctrl_reg - STK_ALS_READ_IRS_IT_REDUCE)))

+#endif	

+        {

+                printk(KERN_ERR "%s: invalid reg 0x02=0x%2x\n", __func__, value[1]);

+                return 0xFF;

+        }

+        if(value[2] != ps_data->ledctrl_reg)

+        {

+                printk(KERN_ERR "%s: invalid reg 0x03=0x%2x\n", __func__, value[2]);

+                return 0xFF;

+        }

+        if(value[3] != ps_data->int_reg)

+        {

+                printk(KERN_ERR "%s: invalid reg 0x04=0x%2x\n", __func__, value[3]);

+                return 0xFF;

+        }

+        if(value[4] != ps_data->wait_reg)

+        {

+                printk(KERN_ERR "%s: invalid reg 0x05=0x%2x\n", __func__, value[4]);

+                return 0xFF;

+        }

+        if(value[5] != ((ps_data->ps_thd_h & 0xFF00) >> 8))

+        {

+                printk(KERN_ERR "%s: invalid reg 0x06=0x%2x\n", __func__, value[5]);

+                return 0xFF;

+        }

+        if(value[6] != (ps_data->ps_thd_h & 0x00FF))

+        {

+                printk(KERN_ERR "%s: invalid reg 0x07=0x%2x\n", __func__, value[6]);

+                return 0xFF;

+        }

+        if(value[7] != ((ps_data->ps_thd_l & 0xFF00) >> 8))

+        {

+                printk(KERN_ERR "%s: invalid reg 0x08=0x%2x\n", __func__, value[7]);

+                return 0xFF;

+        }

+        if(value[8] != (ps_data->ps_thd_l & 0x00FF))

+        {

+                printk(KERN_ERR "%s: invalid reg 0x09=0x%2x\n", __func__, value[8]);

+                return 0xFF;

+        }

+

+        return 0;

+}

+

+static int stk3x1x_validate_n_handle(struct i2c_client *client) 

+{

+        struct stk3x1x_data *ps_data = i2c_get_clientdata(client);

+        int err;

+

+        err = stk3x1x_chk_reg_valid(ps_data);

+        if(err < 0)

+        {

+                printk(KERN_ERR "stk3x1x_chk_reg_valid fail: %d\n", err);        

+                return err;

+        }

+

+        if(err == 0xFF)

+        {

+                printk(KERN_ERR "%s: Re-init chip\n", __func__);

+                err = stk3x1x_software_reset(ps_data); 

+                if(err < 0)

+                        return err;

+                err = stk3x1x_init_all_reg(ps_data);

+                if(err < 0)

+                        return err;

+

+                //ps_data->psa = 0;

+                //ps_data->psi = 0xFFFF;

+                stk3x1x_set_ps_thd_h(ps_data, ps_data->ps_thd_h);

+                stk3x1x_set_ps_thd_l(ps_data, ps_data->ps_thd_l);

+#ifdef STK_ALS_FIR

+                memset(&ps_data->fir, 0x00, sizeof(ps_data->fir));  

+#endif

+                return 0xFF;

+        }

+        return 0;

+}

+#endif /* #ifdef STK_CHK_REG */

+

+static ssize_t stk_als_code_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+    int32_t reading;

+#ifdef STK_POLL_ALS	

+	reading = ps_data->als_code_last;

+#else

+	unsigned char value[2];	

+	int ret;

+	ret = stk3x1x_i2c_read_data(ps_data->client, STK_DATA1_ALS_REG, 2, &value[0]);

+	if(ret < 0)

+	{

+		printk(KERN_ERR "%s fail, ret=0x%x", __func__, ret);

+		return ret;

+	}

+	reading = (value[0]<<8) | value[1];	

+#endif	

+    return scnprintf(buf, PAGE_SIZE, "%d\n", reading);

+}

+

+

+static ssize_t stk_als_enable_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+    int32_t ret;

+

+        ret = stk3x1x_get_state(ps_data);

+        if(ret < 0)

+                return ret;

+    ret = (ret & STK_STATE_EN_ALS_MASK)?1:0;

+

+        return scnprintf(buf, PAGE_SIZE, "%d\n", ret);

+}

+

+static ssize_t stk_als_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data = dev_get_drvdata(dev);

+        uint8_t en;

+        if (sysfs_streq(buf, "1"))

+                en = 1;

+        else if (sysfs_streq(buf, "0"))

+                en = 0;

+        else 

+        {

+                printk(KERN_ERR "%s, invalid value %d\n", __func__, *buf);

+                return -EINVAL;

+        }

+    printk(KERN_INFO "%s: Enable ALS : %d\n", __func__, en);

+    mutex_lock(&ps_data->io_lock);

+    stk3x1x_enable_als(ps_data, en);

+    mutex_unlock(&ps_data->io_lock);

+    return size;

+}

+

+static ssize_t stk_als_lux_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data = dev_get_drvdata(dev);

+    int32_t als_reading;

+        uint32_t als_lux;

+    als_reading = stk3x1x_get_als_reading(ps_data);    

+        als_lux = stk_alscode2lux(ps_data, als_reading);

+    return scnprintf(buf, PAGE_SIZE, "%d lux\n", als_lux);

+}

+

+static ssize_t stk_als_lux_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        unsigned long value = 0;

+        int ret;

+        ret = kstrtoul(buf, 16, &value);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=0x%x\n", __func__, ret);

+                return ret;

+        }

+    ps_data->als_lux_last = value;

+        input_report_abs(ps_data->als_input_dev, ABS_MISC, value);

+        input_sync(ps_data->als_input_dev);

+        printk(KERN_INFO "%s: als input event %ld lux\n",__func__, value);

+

+    return size;

+}

+

+

+static ssize_t stk_als_transmittance_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+    int32_t transmittance;

+    transmittance = ps_data->als_transmittance;

+    return scnprintf(buf, PAGE_SIZE, "%d\n", transmittance);

+}

+

+

+static ssize_t stk_als_transmittance_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        unsigned long value = 0;

+        int ret;

+        ret = kstrtoul(buf, 10, &value);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=0x%x\n", __func__, ret);

+                return ret;         

+        }

+    ps_data->als_transmittance = value;

+    return size;

+}

+

+static ssize_t stk_als_delay_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        int64_t delay;

+        mutex_lock(&ps_data->io_lock);

+        delay = ktime_to_ns(ps_data->als_poll_delay);

+        mutex_unlock(&ps_data->io_lock);

+        return scnprintf(buf, PAGE_SIZE, "%lld\n", delay);

+}

+

+

+static ssize_t stk_als_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+    uint64_t value = 0;

+        int ret;

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        ret = kstrtoull(buf, 10, &value);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoull failed, ret=0x%x\n", __func__, ret);

+                return ret;

+        }

+#ifdef STK_DEBUG_PRINTF

+        printk(KERN_INFO "%s: set als poll delay=%lld\n", __func__, value);

+#endif

+        if(value < MIN_ALS_POLL_DELAY_NS)

+        {

+                printk(KERN_ERR "%s: delay is too small\n", __func__);

+                value = MIN_ALS_POLL_DELAY_NS;

+        }

+        mutex_lock(&ps_data->io_lock);

+        if(value != ktime_to_ns(ps_data->als_poll_delay))

+                ps_data->als_poll_delay = ns_to_ktime(value);

+#ifdef STK_ALS_FIR

+        ps_data->fir.number = 0;

+        ps_data->fir.idx = 0;

+        ps_data->fir.sum = 0;

+#endif

+        mutex_unlock(&ps_data->io_lock);

+        return size;

+}

+

+static ssize_t stk_als_ir_code_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+    int32_t reading;

+    reading = stk3x1x_get_ir_reading(ps_data, STK_IRS_IT_REDUCE);

+    return scnprintf(buf, PAGE_SIZE, "%d\n", reading);

+}

+

+#ifdef STK_ALS_FIR

+static ssize_t stk_als_firlen_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        int len = atomic_read(&ps_data->firlength);

+

+        printk(KERN_INFO "%s: len = %2d, idx = %2d\n", __func__, len, ps_data->fir.idx);

+        printk(KERN_INFO "%s: sum = %5d, ave = %5d\n", __func__, ps_data->fir.sum, ps_data->fir.sum/len);

+

+        return scnprintf(buf, PAGE_SIZE, "%d\n", len);

+}

+

+

+static ssize_t stk_als_firlen_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+    uint64_t value = 0;

+        int ret;

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        ret = kstrtoull(buf, 10, &value);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoull failed, ret=0x%x\n", __func__, ret);

+                return ret;

+        }

+

+        if(value > MAX_FIR_LEN)

+        {

+                printk(KERN_ERR "%s: firlen exceed maximum filter length\n", __func__);

+        }

+        else if (value < 1)

+        {

+                atomic_set(&ps_data->firlength, 1);

+                memset(&ps_data->fir, 0x00, sizeof(ps_data->fir));

+        }

+        else

+        { 

+                atomic_set(&ps_data->firlength, value);

+                memset(&ps_data->fir, 0x00, sizeof(ps_data->fir));

+        }

+        return size;

+}

+#endif  /* #ifdef STK_ALS_FIR */

+

+#ifdef STK_GES

+static ssize_t stk_ges_code_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+    int ret;

+        unsigned int gest0 = 0, gest1 = 0, gest2 = 0;

+

+        if(!ps_data->ges_enabled)

+                return 0;

+

+    ret = stk3x1x_get_ges_reading(ps_data, &gest0, &gest1, &gest2);

+        if(ret < 0)

+                return ret;

+        else if(ret == 0xFFFF)

+                atomic_set(&ps_data->gesture2, 0);

+

+    return scnprintf(buf, PAGE_SIZE, "%5d,%5d,%5d\n", gest0, gest1, atomic_read(&ps_data->gesture2));

+}

+

+static ssize_t stk_ges_code_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        uint8_t ges;

+        unsigned long value = 0;

+        int ret;

+

+        ret = kstrtoul(buf, 16, &value);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=%d\n", __func__, ret);

+                return ret;

+        }

+

+        switch(value)

+        {

+        case 3:

+                //printk(KERN_INFO "%s: ges input event, not detected\n",__func__);

+        case 0:

+                return size;

+        case 1:

+                ges = KEY_PAGEUP;

+                atomic_set(&ps_data->gesture2, 0);

+                printk(KERN_INFO "%s: ges input event >>>\n",__func__);

+                break;

+        case 2:

+                ges = KEY_PAGEDOWN;

+                atomic_set(&ps_data->gesture2, 0);

+                printk(KERN_INFO "%s: ges input event <<<\n",__func__);

+                break;

+        case 32:

+                ges = KEY_VOLUMEDOWN;

+                printk(KERN_INFO "%s: ges input event near\n",__func__);

+                break;

+        case 48:

+                ges = KEY_VOLUMEUP;

+                printk(KERN_INFO "%s: ges input event far\n",__func__);

+                break;

+        default:

+                printk(KERN_ERR "%s, invalid value %d\n", __func__, (int)value);

+                return -EINVAL;

+        }

+

+        input_report_key(ps_data->ges_input_dev, ges, 1);

+        input_report_key(ps_data->ges_input_dev, ges, 0);

+        input_sync(ps_data->ges_input_dev);

+    return size;

+}

+

+static ssize_t stk_ges_poll_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        int len = 0, ii = 0, jj = 0;

+

+        while(stk_ges_op[ii].ops[0] != 0)

+        {

+                len += scnprintf(buf + len, PAGE_SIZE - len, "%x ", ii);

+                for(jj=0;jj<4;jj++)

+                        len += scnprintf(buf + len, PAGE_SIZE - len, "%x ", stk_ges_op[ii].ops[jj]);

+                len += scnprintf(buf + len, PAGE_SIZE - len, "\n");

+                ii++;

+        }

+        return len;

+}

+

+

+static ssize_t stk_ges_poll_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        int32_t ret, i = 0, index = 0;

+        char *token;

+        unsigned long value = 0;

+

+        while(buf != '\0')

+        {

+                token = strsep((char **)&buf, " ");

+                if((ret = kstrtoul(token, 16, &value)) < 0)

+                {

+                        printk(KERN_ERR "%s:kstrtoul failed, ret=0x%x\n", __func__, ret);

+                        return ret;

+                }

+

+                if(i == 0)

+                {

+                        if(value >= 10)

+                        {

+                                memset(stk_ges_op, 0, sizeof(stk_ges_op));

+                                break;

+                        }

+                        else

+                                index = value;

+                }

+                else

+                {

+                        stk_ges_op[index].ops[i-1] = value;

+                }

+                i++;

+                if(i == 5)

+                        break;

+        }

+        if(i != 5)

+        {

+                printk(KERN_ERR "%s: invalid length(%d)\n", __func__, i);

+                memset(&(stk_ges_op[index]), 0, sizeof(union stk_ges_operation));

+        }

+        return size;

+}

+

+static ssize_t stk_ges_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        unsigned long value = 0;

+        int ret;

+

+        ret = kstrtoul(buf, 10, &value);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=%d\n", __func__, ret);

+                return ret;

+        }

+    printk(KERN_INFO "%s: Enable GES : %d\n", __func__, (int)value);

+

+        switch(value)

+        {

+        case 0:

+                mutex_lock(&ps_data->io_lock);

+                if(ps_data->ges_enabled == 1)

+                        stk3x1x_enable_ges(ps_data, 0, 1);

+                else

+                        stk3x1x_enable_ges(ps_data, 0, 2);

+                mutex_unlock(&ps_data->io_lock);

+                break;

+        case 1:

+                mutex_lock(&ps_data->io_lock);

+                stk3x1x_enable_ges(ps_data, 1, 1);

+                mutex_unlock(&ps_data->io_lock);

+                break;

+        case 2:

+                mutex_lock(&ps_data->io_lock);

+                stk3x1x_enable_ges(ps_data, 1, 2);

+                mutex_unlock(&ps_data->io_lock);

+                break;

+        default:

+                printk(KERN_ERR "%s, invalid value %d\n", __func__, *buf);

+                return -EINVAL;

+                break;

+        }

+

+    return size;

+}

+

+static ssize_t stk_ges_enable_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        return scnprintf(buf, PAGE_SIZE, "%d\n", ps_data->ges_enabled);

+}

+

+#endif  /* #ifdef STK_GES */

+

+static ssize_t stk_ps_code_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+    uint32_t reading;

+    reading = stk3x1x_get_ps_reading(ps_data);

+    return scnprintf(buf, PAGE_SIZE, "%d\n", reading);

+}

+

+static ssize_t stk_ps_enable_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+    int32_t ret;

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+

+        ret = stk3x1x_get_state(ps_data);

+        if(ret < 0)

+                return ret;

+    ret = (ret & STK_STATE_EN_PS_MASK)?1:0;

+

+        return scnprintf(buf, PAGE_SIZE, "%d\n", ret);

+}

+

+static ssize_t stk_ps_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        uint8_t en;

+        if (sysfs_streq(buf, "1"))

+                en = 1;

+        else if (sysfs_streq(buf, "0"))

+                en = 0;

+        else 

+        {

+                printk(KERN_ERR "%s, invalid value %d\n", __func__, *buf);

+                return -EINVAL;

+        }

+    printk(KERN_INFO "%s: Enable PS : %d\n", __func__, en);

+    mutex_lock(&ps_data->io_lock);

+    stk3x1x_enable_ps(ps_data, en, 1);

+    mutex_unlock(&ps_data->io_lock);

+    return size;

+}

+

+static ssize_t stk_ps_enable_aso_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+    int32_t ret;

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+

+    ret = stk3x1x_i2c_smbus_read_byte_data(ps_data->client,STK_STATE_REG);

+    ret = (ret & STK_STATE_EN_ASO_MASK)?1:0;

+

+        return scnprintf(buf, PAGE_SIZE, "%d\n", ret);

+}

+

+static ssize_t stk_ps_enable_aso_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        uint8_t en;

+    int32_t ret;

+        uint8_t w_state_reg;

+

+        if (sysfs_streq(buf, "1"))

+                en = 1;

+        else if (sysfs_streq(buf, "0"))

+                en = 0;

+        else 

+        {

+                printk(KERN_ERR "%s, invalid value %d\n", __func__, *buf);

+                return -EINVAL;

+        }

+    printk(KERN_INFO "%s: Enable PS ASO : %d\n", __func__, en);

+    

+    ret = stk3x1x_i2c_smbus_read_byte_data(ps_data->client, STK_STATE_REG);

+    if (ret < 0)

+    {

+        printk(KERN_ERR "%s: write i2c error\n", __func__);

+                return ret;

+    }

+        w_state_reg = (uint8_t)(ret & (~STK_STATE_EN_ASO_MASK)); 

+        if(en)

+                w_state_reg |= STK_STATE_EN_ASO_MASK;

+

+    ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_STATE_REG, w_state_reg);

+    if (ret < 0)

+        {

+                printk(KERN_ERR "%s: write i2c error\n", __func__);

+                return ret;

+        }

+

+        return size;

+}

+

+

+static ssize_t stk_ps_offset_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+    int32_t word_data;

+        unsigned char value[2];

+        int ret;

+

+        ret = stk3x1x_i2c_read_data(ps_data->client, STK_DATA1_OFFSET_REG, 2, &value[0]);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s fail, ret=0x%x", __func__, ret);

+                return ret;

+        }

+        word_data = (value[0]<<8) | value[1];

+

+        return scnprintf(buf, PAGE_SIZE, "%d\n", word_data);

+}

+ 

+static ssize_t stk_ps_offset_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        unsigned long offset = 0;

+        int ret;

+        unsigned char val[2];

+

+        ret = kstrtoul(buf, 10, &offset);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=0x%x\n", __func__, ret);

+                return ret;

+        }

+        if(offset > 65535)

+        {

+                printk(KERN_ERR "%s: invalid value, offset=%ld\n", __func__, offset);

+                return -EINVAL;

+        }

+

+        val[0] = (offset & 0xFF00) >> 8;

+        val[1] = offset & 0x00FF;

+        ret = stk3x1x_i2c_write_data(ps_data->client, STK_DATA1_OFFSET_REG, 2, val);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s: write i2c error\n", __func__);

+                return ret;

+        }

+

+        return size;

+}

+

+

+static ssize_t stk_ps_distance_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+    int32_t dist=1, ret;

+

+    ret = stk3x1x_get_flag(ps_data);

+        if(ret < 0)

+                return ret;

+    dist = (ret & STK_FLG_NF_MASK)?1:0;

+

+    ps_data->ps_distance_last = dist;

+        input_report_abs(ps_data->ps_input_dev, ABS_DISTANCE, dist);

+        input_sync(ps_data->ps_input_dev);

+        wake_lock_timeout(&ps_data->ps_wakelock, 3*HZ);

+        printk(KERN_INFO "%s: ps input event %d cm\n",__func__, dist);

+    return scnprintf(buf, PAGE_SIZE, "%d\n", dist);

+}

+

+

+static ssize_t stk_ps_distance_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        unsigned long value = 0;

+        int ret;

+        ret = kstrtoul(buf, 10, &value);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=0x%x\n", __func__, ret);

+                return ret;

+        }

+    ps_data->ps_distance_last = value;

+        input_report_abs(ps_data->ps_input_dev, ABS_DISTANCE, value);

+        input_sync(ps_data->ps_input_dev);

+        wake_lock_timeout(&ps_data->ps_wakelock, 3*HZ);

+        printk(KERN_INFO "%s: ps input event %ld cm\n",__func__, value);

+    return size;

+}

+

+

+static ssize_t stk_ps_code_thd_l_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+    int32_t ps_thd_l1_reg, ps_thd_l2_reg;

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+    ps_thd_l1_reg = stk3x1x_i2c_smbus_read_byte_data(ps_data->client,STK_THDL1_PS_REG);

+    if(ps_thd_l1_reg < 0)

+        {

+                printk(KERN_ERR "%s fail, err=0x%x", __func__, ps_thd_l1_reg);

+                return -EINVAL;

+        }

+    ps_thd_l2_reg = stk3x1x_i2c_smbus_read_byte_data(ps_data->client,STK_THDL2_PS_REG);

+    if(ps_thd_l2_reg < 0)

+        {

+                printk(KERN_ERR "%s fail, err=0x%x", __func__, ps_thd_l2_reg);

+                return -EINVAL;

+        }

+        ps_thd_l1_reg = ps_thd_l1_reg<<8 | ps_thd_l2_reg;

+    return scnprintf(buf, PAGE_SIZE, "%d\n", ps_thd_l1_reg);

+}

+

+

+static ssize_t stk_ps_code_thd_l_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        unsigned long value = 0;

+        int ret;

+        ret = kstrtoul(buf, 10, &value);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=0x%x\n", __func__, ret);

+                return ret;         

+        }

+    stk3x1x_set_ps_thd_l(ps_data, value);

+    return size;

+}

+

+static ssize_t stk_ps_code_thd_h_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+    int32_t ps_thd_h1_reg, ps_thd_h2_reg;

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+    ps_thd_h1_reg = stk3x1x_i2c_smbus_read_byte_data(ps_data->client,STK_THDH1_PS_REG);

+    if(ps_thd_h1_reg < 0)

+        {

+                printk(KERN_ERR "%s fail, err=0x%x", __func__, ps_thd_h1_reg);

+                return -EINVAL;

+        }

+    ps_thd_h2_reg = stk3x1x_i2c_smbus_read_byte_data(ps_data->client,STK_THDH2_PS_REG);

+    if(ps_thd_h2_reg < 0)

+        {

+                printk(KERN_ERR "%s fail, err=0x%x", __func__, ps_thd_h2_reg);

+                return -EINVAL;

+        }

+        ps_thd_h1_reg = ps_thd_h1_reg<<8 | ps_thd_h2_reg;

+    return scnprintf(buf, PAGE_SIZE, "%d\n", ps_thd_h1_reg);

+}

+

+

+static ssize_t stk_ps_code_thd_h_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        unsigned long value = 0;

+        int ret;

+        ret = kstrtoul(buf, 10, &value);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=0x%x\n", __func__, ret);

+                return ret;         

+        }

+    stk3x1x_set_ps_thd_h(ps_data, value);

+    return size;

+}

+

+

+static ssize_t stk_all_reg_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+    int32_t ps_reg[0x22];

+        uint8_t cnt;

+        int len = 0;

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+

+        for(cnt=0;cnt<0x20;cnt++)

+        {

+                ps_reg[cnt] = stk3x1x_i2c_smbus_read_byte_data(ps_data->client, (cnt));

+                if(ps_reg[cnt] < 0)

+                {

+                        printk(KERN_ERR "%s fail, ret=%d", __func__, ps_reg[cnt]);

+                        return -EINVAL;

+                }

+                else

+                {

+                        printk(KERN_INFO "reg[0x%2X]=0x%2X\n", cnt, ps_reg[cnt]);

+                        len += scnprintf(buf+len, PAGE_SIZE-len, "[%2X]%2X,", cnt, ps_reg[cnt]);

+                }

+        }

+        ps_reg[cnt] = stk3x1x_i2c_smbus_read_byte_data(ps_data->client, STK_PDT_ID_REG);

+        if(ps_reg[cnt] < 0)

+        {

+                printk( KERN_ERR "%s fail, ret=%d", __func__, ps_reg[cnt]);

+                return -EINVAL;

+        }

+        printk( KERN_INFO "reg[0x%x]=0x%2X\n", STK_PDT_ID_REG, ps_reg[cnt]);

+        cnt++;

+        ps_reg[cnt] = stk3x1x_i2c_smbus_read_byte_data(ps_data->client, STK_RSRVD_REG);

+        if(ps_reg[cnt] < 0)

+        {

+                printk( KERN_ERR "%s fail, ret=%d", __func__, ps_reg[cnt]);

+                return -EINVAL;

+        }

+        printk( KERN_INFO "reg[0x%x]=0x%2X\n", STK_RSRVD_REG, ps_reg[cnt]);

+        len += scnprintf(buf+len, PAGE_SIZE-len, "[%2X]%2X,[%2X]%2X\n", cnt-1, ps_reg[cnt-1], cnt, ps_reg[cnt]);

+        return len;

+/*

+    return scnprintf(buf, PAGE_SIZE, "[0]%2X [1]%2X [2]%2X [3]%2X [4]%2X [5]%2X [6/7 HTHD]%2X,%2X [8/9 LTHD]%2X, %2X [A]%2X [B]%2X [C]%2X [D]%2X [E/F Aoff]%2X,%2X,[10]%2X [11/12 PS]%2X,%2X [13]%2X [14]%2X [15/16 Foff]%2X,%2X [17]%2X [18]%2X [3E]%2X [3F]%2X\n", 

+                ps_reg[0], ps_reg[1], ps_reg[2], ps_reg[3], ps_reg[4], ps_reg[5], ps_reg[6], ps_reg[7], ps_reg[8], 

+                ps_reg[9], ps_reg[10], ps_reg[11], ps_reg[12], ps_reg[13], ps_reg[14], ps_reg[15], ps_reg[16], ps_reg[17], 

+                ps_reg[18], ps_reg[19], ps_reg[20], ps_reg[21], ps_reg[22], ps_reg[23], ps_reg[24], ps_reg[25], ps_reg[26]);

+                */

+}

+

+static ssize_t stk_status_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+    int32_t ps_reg[27];

+        uint8_t cnt;

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        for(cnt=0;cnt<25;cnt++)

+        {

+                ps_reg[cnt] = stk3x1x_i2c_smbus_read_byte_data(ps_data->client, (cnt));

+                if(ps_reg[cnt] < 0)

+                {

+                        printk(KERN_ERR "%s fail, ret=%d", __func__, ps_reg[cnt]);

+                        return -EINVAL;

+                }

+                else

+                {

+                        printk(KERN_INFO "reg[0x%2X]=0x%2X\n", cnt, ps_reg[cnt]);

+                }

+        }

+        ps_reg[cnt] = stk3x1x_i2c_smbus_read_byte_data(ps_data->client, STK_PDT_ID_REG);

+        if(ps_reg[cnt] < 0)

+        {

+                printk( KERN_ERR "%s fail, ret=%d", __func__, ps_reg[cnt]);

+                return -EINVAL;

+        }

+        printk( KERN_INFO "reg[0x%x]=0x%2X\n", STK_PDT_ID_REG, ps_reg[cnt]);

+        cnt++;

+        ps_reg[cnt] = stk3x1x_i2c_smbus_read_byte_data(ps_data->client, STK_RSRVD_REG);

+        if(ps_reg[cnt] < 0)

+        {

+                printk( KERN_ERR "%s fail, ret=%d", __func__, ps_reg[cnt]);

+                return -EINVAL;

+        }

+        printk( KERN_INFO "reg[0x%x]=0x%2X\n", STK_RSRVD_REG, ps_reg[cnt]);

+

+    return scnprintf(buf, PAGE_SIZE, "[PS=%2X] [ALS=%2X] [WAIT=0x%4Xms] [EN_ASO=%2X] [EN_AK=%2X] [NEAR/FAR=%2X] [FLAG_OUI=%2X] [FLAG_PSINT=%2X] [FLAG_ALSINT=%2X]\n", 

+                ps_reg[0]&0x01,(ps_reg[0]&0x02)>>1,((ps_reg[0]&0x04)>>2)*ps_reg[5]*6,(ps_reg[0]&0x20)>>5,

+                (ps_reg[0]&0x40)>>6,ps_reg[16]&0x01,(ps_reg[16]&0x04)>>2,(ps_reg[16]&0x10)>>4,(ps_reg[16]&0x20)>>5);

+}

+

+static ssize_t stk_recv_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        return scnprintf(buf, PAGE_SIZE, "0x%04X\n", atomic_read(&ps_data->recv_reg));     

+}

+

+

+static ssize_t stk_recv_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+    unsigned long value = 0;

+        int ret;

+        int32_t recv_data;

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+

+        if((ret = kstrtoul(buf, 16, &value)) < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=0x%x\n", __func__, ret);

+                return ret;

+        }

+        recv_data = stk3x1x_i2c_smbus_read_byte_data(ps_data->client,value);

+//      printk("%s: reg 0x%x=0x%x\n", __func__, (int)value, recv_data);

+        atomic_set(&ps_data->recv_reg, recv_data);

+        return size;

+}

+

+

+static ssize_t stk_send_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        return 0;

+}

+

+

+static ssize_t stk_send_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        int addr, cmd;

+        int32_t ret, i;

+        char *token[10];

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+

+        for (i = 0; i < 2; i++)

+                token[i] = strsep((char **)&buf, " ");

+        if((ret = kstrtoul(token[0], 16, (unsigned long *)&(addr))) < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=0x%x\n", __func__, ret);

+                return ret;

+        }

+        if((ret = kstrtoul(token[1], 16, (unsigned long *)&(cmd))) < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=0x%x\n", __func__, ret);

+                return ret;

+        }

+        printk(KERN_INFO "%s: write reg 0x%x=0x%x\n", __func__, addr, cmd);

+

+        ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, (unsigned char)addr, (unsigned char)cmd);

+        if (0 != ret)

+        {

+                printk(KERN_ERR "%s: stk3x1x_i2c_smbus_write_byte_data fail\n", __func__);

+                return ret;

+        }

+

+        return size;

+}

+

+#ifdef STK_TUNE0

+

+static ssize_t stk_ps_cali_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        int32_t word_data;

+        unsigned char value[2];

+        int ret;

+

+        ret = stk3x1x_i2c_read_data(ps_data->client, 0x20, 2, &value[0]);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s fail, ret=0x%x", __func__, ret);

+                return ret;

+        }

+        word_data = (value[0]<<8) | value[1];

+

+        ret = stk3x1x_i2c_read_data(ps_data->client, 0x22, 2, &value[0]);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s fail, ret=0x%x", __func__, ret);

+                return ret;

+        }

+        word_data += ((value[0]<<8) | value[1]);

+

+        printk("%s: psi_set=%d, psa=%d,psi=%d, word_data=%d\n", __func__, 

+                ps_data->psi_set, ps_data->psa, ps_data->psi, word_data);

+#ifdef CALI_PS_EVERY_TIME

+        printk("%s: boot HT=%d, LT=%d\n", __func__, ps_data->ps_high_thd_boot, ps_data->ps_low_thd_boot);

+#endif

+        return 0;

+}

+

+static ssize_t stk_ps_maxdiff_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+    unsigned long value = 0;

+        int ret;

+

+        if((ret = kstrtoul(buf, 10, &value)) < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=0x%x\n", __func__, ret);

+                return ret;

+        }

+        ps_data->stk_max_min_diff = (int) value;

+        return size;

+}

+

+

+static ssize_t stk_ps_maxdiff_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        return scnprintf(buf, PAGE_SIZE, "%d\n", ps_data->stk_max_min_diff);     

+}

+

+static ssize_t stk_ps_ltnct_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+    unsigned long value = 0;

+        int ret;

+

+        if((ret = kstrtoul(buf, 10, &value)) < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=0x%x\n", __func__, ret);

+                return ret;

+        }

+        ps_data->stk_lt_n_ct = (int) value;

+        return size;

+}

+

+static ssize_t stk_ps_ltnct_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        return scnprintf(buf, PAGE_SIZE, "%d\n", ps_data->stk_lt_n_ct);     

+}

+

+static ssize_t stk_ps_htnct_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+    unsigned long value = 0;

+        int ret;

+

+        if((ret = kstrtoul(buf, 10, &value)) < 0)

+        {

+                printk(KERN_ERR "%s:kstrtoul failed, ret=0x%x\n", __func__, ret);

+                return ret;

+        }

+        ps_data->stk_ht_n_ct = (int) value;

+        return size;

+}

+

+static ssize_t stk_ps_htnct_show(struct device *dev, struct device_attribute *attr, char *buf)

+{

+        struct stk3x1x_data *ps_data =  dev_get_drvdata(dev);

+        return scnprintf(buf, PAGE_SIZE, "%d\n", ps_data->stk_ht_n_ct);     

+}

+#endif  /* #ifdef STK_TUNE0 */

+

+static struct device_attribute als_enable_attribute = __ATTR(enable,0666,stk_als_enable_show,stk_als_enable_store);

+static struct device_attribute als_lux_attribute = __ATTR(lux,0664,stk_als_lux_show,stk_als_lux_store);

+static struct device_attribute als_code_attribute = __ATTR(code, 0444, stk_als_code_show, NULL);

+static struct device_attribute als_transmittance_attribute = __ATTR(transmittance,0664,stk_als_transmittance_show,stk_als_transmittance_store);

+static struct device_attribute als_poll_delay_attribute = __ATTR(delay,0664,stk_als_delay_show,stk_als_delay_store);

+static struct device_attribute als_ir_code_attribute = __ATTR(ircode,0444,stk_als_ir_code_show,NULL);

+#ifdef STK_ALS_FIR

+static struct device_attribute als_firlen_attribute = __ATTR(firlen,0664,stk_als_firlen_show,stk_als_firlen_store);

+#endif

+

+static struct attribute *stk_als_attrs [] =

+{

+        &als_enable_attribute.attr,

+    &als_lux_attribute.attr,

+    &als_code_attribute.attr,

+    &als_transmittance_attribute.attr,

+        &als_poll_delay_attribute.attr,

+        &als_ir_code_attribute.attr,

+#ifdef STK_ALS_FIR

+        &als_firlen_attribute.attr,

+#endif

+    NULL

+};

+

+static struct attribute_group stk_als_attribute_group = {

+#ifndef QUALCOMM_PLATFORM

+        .name = "driver",

+#endif

+        .attrs = stk_als_attrs,

+};

+

+#ifdef STK_GES

+static struct device_attribute ges_enable_attribute = __ATTR(enable,0666,stk_ges_enable_show,stk_ges_enable_store);

+static struct device_attribute ges_code_attribute = __ATTR(code, 0664, stk_ges_code_show, stk_ges_code_store);

+static struct device_attribute ges_poll_attribute = __ATTR(poll, 0664, stk_ges_poll_show, stk_ges_poll_store);

+static struct device_attribute ges_recv_attribute = __ATTR(recv,0664,stk_recv_show,stk_recv_store);

+static struct device_attribute ges_send_attribute = __ATTR(send,0664,stk_send_show, stk_send_store);

+

+static struct attribute *stk_ges_attrs [] =

+{

+    &ges_enable_attribute.attr,

+    &ges_code_attribute.attr,

+    &ges_poll_attribute.attr,

+        &ges_recv_attribute.attr,

+        &ges_send_attribute.attr,

+    NULL

+};

+

+static struct attribute_group stk_ges_attribute_group = 

+{

+        .name = "driver",

+        .attrs = stk_ges_attrs,

+};

+#endif  /* #ifdef STK_GES */

+

+static struct device_attribute ps_enable_attribute = __ATTR(enable,0666,stk_ps_enable_show,stk_ps_enable_store);

+static struct device_attribute ps_enable_aso_attribute = __ATTR(enableaso,0664,stk_ps_enable_aso_show,stk_ps_enable_aso_store);

+static struct device_attribute ps_distance_attribute = __ATTR(distance,0664,stk_ps_distance_show, stk_ps_distance_store);

+static struct device_attribute ps_offset_attribute = __ATTR(offset,0664,stk_ps_offset_show, stk_ps_offset_store);

+static struct device_attribute ps_code_attribute = __ATTR(code, 0444, stk_ps_code_show, NULL);

+static struct device_attribute ps_code_thd_l_attribute = __ATTR(codethdl,0664,stk_ps_code_thd_l_show,stk_ps_code_thd_l_store);

+static struct device_attribute ps_code_thd_h_attribute = __ATTR(codethdh,0664,stk_ps_code_thd_h_show,stk_ps_code_thd_h_store);

+static struct device_attribute ps_recv_attribute = __ATTR(recv,0664,stk_recv_show,stk_recv_store);

+static struct device_attribute ps_send_attribute = __ATTR(send,0664,stk_send_show, stk_send_store);

+static struct device_attribute all_reg_attribute = __ATTR(allreg, 0444, stk_all_reg_show, NULL);

+static struct device_attribute status_attribute = __ATTR(status, 0444, stk_status_show, NULL);

+#ifdef STK_TUNE0

+static struct device_attribute ps_cali_attribute = __ATTR(cali,0444,stk_ps_cali_show, NULL);

+static struct device_attribute ps_maxdiff_attribute = __ATTR(maxdiff,0664,stk_ps_maxdiff_show, stk_ps_maxdiff_store);

+static struct device_attribute ps_ltnct_attribute = __ATTR(ltnct,0664,stk_ps_ltnct_show, stk_ps_ltnct_store);

+static struct device_attribute ps_htnct_attribute = __ATTR(htnct,0664,stk_ps_htnct_show, stk_ps_htnct_store);

+#endif

+

+static struct attribute *stk_ps_attrs [] =

+{

+    &ps_enable_attribute.attr,

+    &ps_enable_aso_attribute.attr,

+    &ps_distance_attribute.attr,

+        &ps_offset_attribute.attr,

+    &ps_code_attribute.attr,

+        &ps_code_thd_l_attribute.attr,

+        &ps_code_thd_h_attribute.attr,

+        &ps_recv_attribute.attr,

+        &ps_send_attribute.attr,

+        &all_reg_attribute.attr,

+        &status_attribute.attr,

+#ifdef STK_TUNE0

+        &ps_cali_attribute.attr,

+        &ps_maxdiff_attribute.attr,

+        &ps_ltnct_attribute.attr,

+        &ps_htnct_attribute.attr,

+#endif

+    NULL

+};

+

+static struct attribute_group stk_ps_attribute_group = {

+#ifndef QUALCOMM_PLATFORM

+        .name = "driver",

+#endif

+        .attrs = stk_ps_attrs,

+};

+

+static int stk_ps_val(struct stk3x1x_data *ps_data)

+{

+        int mode;

+        int32_t word_data, lii;

+        unsigned char value[4];

+        int ret;

+

+        ret = stk3x1x_i2c_read_data(ps_data->client, 0x20, 4, value);

+        if(ret < 0)

+        {

+                printk(KERN_ERR "%s fail, ret=0x%x", __func__, ret);

+                return ret;

+        }

+        word_data = (value[0]<<8) | value[1];

+        word_data += ((value[2]<<8) | value[3]);

+

+        mode = (ps_data->psctrl_reg) & 0x3F;

+        if(mode == 0x30)

+                lii = 100;

+        else if (mode == 0x31)

+                lii = 200;

+        else if (mode == 0x32)

+                lii = 400;

+        else if (mode == 0x33)

+                lii = 800;

+        else

+        {

+                printk(KERN_ERR "%s: unsupported PS_IT(0x%x)\n", __func__, mode);

+                return -1;

+        }

+

+        if(word_data > lii)

+        {

+                printk(KERN_INFO "%s: word_data=%d, lii=%d\n", __func__, word_data, lii);

+                return 0xFFFF;

+        }

+        return 0;

+}

+

+#ifdef STK_TUNE0

+

+static int stk_ps_tune_zero_final(struct stk3x1x_data *ps_data)

+{

+        int ret;

+

+        ps_data->tune_zero_init_proc = false;

+        ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_INT_REG, ps_data->int_reg);

+        if (ret < 0)

+        {

+                printk(KERN_ERR "%s: write i2c error\n", __func__);

+                return ret;

+        }

+

+        ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_STATE_REG, 0);

+        if (ret < 0)

+        {

+                printk(KERN_ERR "%s: write i2c error\n", __func__);

+                return ret;

+        }

+

+        if(ps_data->data_count == -1)

+        {

+                printk(KERN_INFO "%s: exceed limit\n", __func__);

+                hrtimer_cancel(&ps_data->ps_tune0_timer);

+                return 0;

+        }

+

+        ps_data->psa = ps_data->ps_stat_data[0];

+        ps_data->psi = ps_data->ps_stat_data[2];

+

+#ifdef CALI_PS_EVERY_TIME

+        ps_data->ps_high_thd_boot = ps_data->ps_stat_data[1] + ps_data->stk_ht_n_ct*3;

+        ps_data->ps_low_thd_boot = ps_data->ps_stat_data[1] + ps_data->stk_lt_n_ct*3;

+        ps_data->ps_thd_h = ps_data->ps_high_thd_boot ;

+        ps_data->ps_thd_l = ps_data->ps_low_thd_boot ;

+#else

+        ps_data->ps_thd_h = ps_data->ps_stat_data[1] + ps_data->stk_ht_n_ct;

+        ps_data->ps_thd_l = ps_data->ps_stat_data[1] + ps_data->stk_lt_n_ct;

+#endif

+        stk3x1x_set_ps_thd_h(ps_data, ps_data->ps_thd_h);

+        stk3x1x_set_ps_thd_l(ps_data, ps_data->ps_thd_l);

+        printk(KERN_INFO "%s: set HT=%d,LT=%d\n", __func__, ps_data->ps_thd_h,  ps_data->ps_thd_l);

+        hrtimer_cancel(&ps_data->ps_tune0_timer);

+        return 0;

+}

+

+static int32_t stk_tune_zero_get_ps_data(struct stk3x1x_data *ps_data)

+{

+        uint32_t ps_adc;

+        int ret;

+

+        ret = stk_ps_val(ps_data);

+        if(ret == 0xFFFF)

+        {

+                ps_data->data_count = -1;

+                stk_ps_tune_zero_final(ps_data);

+                return 0;

+        }

+

+        ps_adc = stk3x1x_get_ps_reading(ps_data);

+        printk(KERN_INFO "%s: ps_adc #%d=%d\n", __func__, ps_data->data_count, ps_adc);

+        if(ps_adc < 0)

+                return ps_adc;

+

+        ps_data->ps_stat_data[1]  +=  ps_adc;

+        if(ps_adc > ps_data->ps_stat_data[0])

+                ps_data->ps_stat_data[0] = ps_adc;

+        if(ps_adc < ps_data->ps_stat_data[2])

+                ps_data->ps_stat_data[2] = ps_adc;

+        ps_data->data_count++;

+

+        if(ps_data->data_count == 5)

+        {

+                ps_data->ps_stat_data[1]  /= ps_data->data_count;

+                stk_ps_tune_zero_final(ps_data);

+        }

+

+        return 0;

+}

+static int stk_ps_tune_zero_init(struct stk3x1x_data *ps_data)

+{

+        int32_t ret = 0;

+        uint8_t w_state_reg;

+

+        ps_data->psi_set = 0;

+        ps_data->ps_stat_data[0] = 0;

+        ps_data->ps_stat_data[2] = 9999;

+        ps_data->ps_stat_data[1] = 0;

+        ps_data->data_count = 0;

+

+        ps_data->tune_zero_init_proc = true;

+        ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_INT_REG, 0);

+        if (ret < 0)

+        {

+                printk(KERN_ERR "%s: write i2c error\n", __func__);

+                return ret;

+        }

+

+        w_state_reg = (STK_STATE_EN_PS_MASK | STK_STATE_EN_WAIT_MASK);

+        ret = stk3x1x_i2c_smbus_write_byte_data(ps_data->client, STK_STATE_REG, w_state_reg);

+        if (ret < 0)

+        {

+                printk(KERN_ERR "%s: write i2c error\n", __func__);

+                return ret;

+        }

+        hrtimer_start(&ps_data->ps_tune0_timer, ps_data->ps_tune0_delay, HRTIMER_MODE_REL);

+

+        return 0;

+}

+static int stk_ps_tune_zero_func_fae(struct stk3x1x_data *ps_data)

+{

+        int32_t word_data;

+        int ret, diff;

+        unsigned char value[2];

+

+#ifdef CALI_PS_EVERY_TIME

+        if(!(ps_data->ps_enabled))

+#else

+        if(ps_data->psi_set || !(ps_data->ps_enabled))

+#endif

+        {

+                return 0;

+        }

+

+        ret = stk3x1x_get_flag(ps_data);

+        if(ret < 0)

+                return ret;

+        if(!(ret&STK_FLG_PSDR_MASK))

+        {

+                //printk(KERN_INFO "%s: ps data is not ready yet\n", __func__);

+                return 0;

+        }

+

+        ret = stk_ps_val(ps_data);

+        if(ret == 0)

+        {

+                ret = stk3x1x_i2c_read_data(ps_data->client, 0x11, 2, &value[0]);

+                if(ret < 0)

+                {

+                        printk(KERN_ERR "%s fail, ret=0x%x", __func__, ret);

+                        return ret;

+                }

+                word_data = (value[0]<<8) | value[1];

+                //printk(KERN_INFO "%s: word_data=%d\n", __func__, word_data);

+

+                if(word_data == 0)

+                {

+                        //printk(KERN_ERR "%s: incorrect word data (0)\n", __func__);

+                        return 0xFFFF;

+                }

+

+                if(word_data > ps_data->psa)

+                {

+                        ps_data->psa = word_data;

+                        printk(KERN_INFO "%s: update psa: psa=%d,psi=%d\n", __func__, ps_data->psa, ps_data->psi);

+                }

+                if(word_data < ps_data->psi)

+                {

+                        ps_data->psi = word_data;

+                        printk(KERN_INFO "%s: update psi: psa=%d,psi=%d\n", __func__, ps_data->psa, ps_data->psi);

+                }

+        }

+        diff = ps_data->psa - ps_data->psi;

+        if(diff > ps_data->stk_max_min_diff)

+        {

+                ps_data->psi_set = ps_data->psi;

+                ps_data->ps_thd_h = ps_data->psi + ps_data->stk_ht_n_ct;

+                ps_data->ps_thd_l = ps_data->psi + ps_data->stk_lt_n_ct;

+

+

+#ifdef CALI_PS_EVERY_TIME

+                if(ps_data->ps_thd_h > ps_data->ps_high_thd_boot)

+                {

+                        ps_data->ps_high_thd_boot = ps_data->ps_thd_h;

+                        ps_data->ps_low_thd_boot = ps_data->ps_thd_l;

+                        printk(KERN_INFO "%s: update boot HT=%d, LT=%d\n", __func__, ps_data->ps_high_thd_boot, ps_data->ps_low_thd_boot);

+                }

+#endif

+

+                stk3x1x_set_ps_thd_h(ps_data, ps_data->ps_thd_h);

+                stk3x1x_set_ps_thd_l(ps_data, ps_data->ps_thd_l);

+#ifdef STK_DEBUG_PRINTF

+                printk(KERN_INFO "%s: FAE tune0 psa-psi(%d) > STK_DIFF found\n", __func__, diff);

+#endif

+                hrtimer_cancel(&ps_data->ps_tune0_timer);

+        }

+

+        return 0;

+}

+

+static void stk_ps_tune0_work_func(struct work_struct *work)

+{

+        struct stk3x1x_data *ps_data = container_of(work, struct stk3x1x_data, stk_ps_tune0_work);

+        if(ps_data->tune_zero_init_proc)

+                stk_tune_zero_get_ps_data(ps_data);

+        else

+                stk_ps_tune_zero_func_fae(ps_data);

+        return;

+}

+

+

+static enum hrtimer_restart stk_ps_tune0_timer_func(struct hrtimer *timer)

+{

+        struct stk3x1x_data *ps_data = container_of(timer, struct stk3x1x_data, ps_tune0_timer);

+        queue_work(ps_data->stk_ps_tune0_wq, &ps_data->stk_ps_tune0_work);

+        hrtimer_forward_now(&ps_data->ps_tune0_timer, ps_data->ps_tune0_delay);

+        return HRTIMER_RESTART;

+}

+#endif

+

+#ifdef STK_POLL_ALS

+static enum hrtimer_restart stk_als_timer_func(struct hrtimer *timer)

+{

+        struct stk3x1x_data *ps_data = container_of(timer, struct stk3x1x_data, als_timer);

+        queue_work(ps_data->stk_als_wq, &ps_data->stk_als_work);

+        hrtimer_forward_now(&ps_data->als_timer, ps_data->als_poll_delay);

+        return HRTIMER_RESTART;

+

+}

+

+static void stk_als_poll_work_func(struct work_struct *work)

+{

+	struct stk3x1x_data *ps_data = container_of(work, struct stk3x1x_data, stk_als_work);	

+	int32_t reading = 0, reading_lux, flag_reg;

+#ifdef STK_IRS	

+	int ret;

+#endif	

+#ifdef STK_GES			

+	if(ps_data->ges_enabled)

+	{

+		input_report_abs(ps_data->als_input_dev, ABS_MISC, ps_data->als_lux_last);

+		input_sync(ps_data->als_input_dev);

+#ifdef STK_DEBUG_PRINTF				

+		printk(KERN_INFO "%s: ges_enabled=1, als input event %d lux\n",__func__, ps_data->als_lux_last);		

+		return;

+#endif

+	}

+#endif

+	

+	flag_reg = stk3x1x_get_flag(ps_data);

+	if(flag_reg < 0)

+		return;		

+	if(!(flag_reg&STK_FLG_ALSDR_MASK))

+	{

+		//printk(KERN_INFO "%s: als is not ready\n", __func__);

+		return;

+	}

+

+#ifdef STK_IRS

+	ret = stk_als_ir_skip_als(ps_data);

+	if(ret == 1)

+		return;

+#endif	

+	

+	reading = stk3x1x_get_als_reading(ps_data);

+	if(reading < 0)

+		return;

+	// printk("%s: als_data_index=%d, als_data=%d\n", __func__, ps_data->als_data_index, reading);

+#ifdef STK_IRS

+	stk_als_ir_get_corr(ps_data, reading);

+	reading = reading * ps_data->als_correct_factor / 1000;

+#endif	

+	reading_lux = stk_alscode2lux(ps_data, reading);

+	if(abs(ps_data->als_lux_last - reading_lux) >= STK_ALS_CHANGE_THD)

+	{

+		ps_data->als_lux_last = reading_lux;

+		input_report_abs(ps_data->als_input_dev, ABS_MISC, reading_lux);

+		input_sync(ps_data->als_input_dev);

+#ifdef STK_DEBUG_PRINTF				

+		printk(KERN_INFO "%s: als input event %d lux\n",__func__, reading_lux);		

+#endif		

+	}

+

+#ifdef STK_IRS		

+	stk_als_ir_run(ps_data);

+#endif

+	return;

+}

+#endif /* #ifdef STK_POLL_ALS */

+

+

+#ifdef STK_POLL_PS

+static enum hrtimer_restart stk_ps_timer_func(struct hrtimer *timer)

+{

+        struct stk3x1x_data *ps_data = container_of(timer, struct stk3x1x_data, ps_timer);

+        queue_work(ps_data->stk_ps_wq, &ps_data->stk_ps_work);

+        hrtimer_forward_now(&ps_data->ps_timer, ps_data->ps_poll_delay);

+        return HRTIMER_RESTART;

+}

+

+static void stk_ps_poll_work_func(struct work_struct *work)

+{

+        struct stk3x1x_data *ps_data = container_of(work, struct stk3x1x_data, stk_ps_work);

+        uint32_t reading;

+        int32_t near_far_state;

+    uint8_t org_flag_reg;

+#ifdef STK_GES

+        int32_t ret;

+    //uint8_t disable_flag = 0;

+        uint8_t disable_flag2 = 0, org_flag2_reg;

+        if(ps_data->ges_enabled == 2)

+        {

+                ret = stk3x1x_get_flag2(ps_data);

+                if(ret < 0)

+                        goto err_i2c_rw;

+                org_flag2_reg = ret;

+

+                disable_flag2 = org_flag2_reg & (STK_FLG2_INT_GS_MASK | 

+                        STK_FLG2_GS10_MASK | STK_FLG2_GS01_MASK);

+                if(org_flag2_reg & STK_FLG2_GS10_MASK)

+                {

+                        printk(KERN_INFO "%s: >>>>>>>>>>>>\n", __func__);

+                }

+                if(org_flag2_reg & STK_FLG2_GS01_MASK)

+                {

+                        printk(KERN_INFO "%s: <<<<<<<<<<<<\n", __func__);

+                }

+                atomic_set(&ps_data->gesture2, (disable_flag2 & 

+                                (STK_FLG2_GS10_MASK | STK_FLG2_GS01_MASK)));  

+

+                if(disable_flag2)

+                {

+                        ret = stk3x1x_set_flag2(ps_data, org_flag2_reg, disable_flag2);

+                        if(ret < 0)

+                                goto err_i2c_rw;

+                }

+        }

+#endif

+

+        if(ps_data->ps_enabled)

+        {

+#ifdef STK_TUNE0

+                // if(!(ps_data->psi_set))

+                        // return;

+#endif

+                org_flag_reg = stk3x1x_get_flag(ps_data);

+                if(org_flag_reg < 0)

+                        goto err_i2c_rw;

+

+                if(!(org_flag_reg&STK_FLG_PSDR_MASK))

+                {

+                        //printk(KERN_INFO "%s: ps is not ready\n", __func__);

+                        return;

+                }

+

+                near_far_state = (org_flag_reg & STK_FLG_NF_MASK)?1:0;

+                reading = stk3x1x_get_ps_reading(ps_data);

+                if(ps_data->ps_distance_last != near_far_state)

+                {

+                        ps_data->ps_distance_last = near_far_state;

+                        input_report_abs(ps_data->ps_input_dev, ABS_DISTANCE, near_far_state);

+                        input_sync(ps_data->ps_input_dev);

+                        wake_lock_timeout(&ps_data->ps_wakelock, 3*HZ);

+#ifdef STK_DEBUG_PRINTF

+                        printk(KERN_INFO "%s: ps input event %d cm, ps code = %d\n",__func__, near_far_state, reading);

+#endif

+                }

+                // ret = stk3x1x_set_flag(ps_data, org_flag_reg, disable_flag);

+                // if(ret < 0)

+                        // goto err_i2c_rw;

+                return;

+        }

+

+err_i2c_rw:

+        msleep(30);

+        return;

+}

+#endif

+

+#if (!defined(STK_POLL_PS) || !defined(STK_POLL_ALS))

+static void stk_work_func(struct work_struct *work)

+{

+        uint32_t reading;

+#if ((STK_INT_PS_MODE != 0x03) && (STK_INT_PS_MODE != 0x02))

+    int32_t ret;

+    uint8_t disable_flag = 0;

+    int32_t org_flag_reg;

+#endif  /* #if ((STK_INT_PS_MODE != 0x03) && (STK_INT_PS_MODE != 0x02)) */

+

+#ifndef CONFIG_STK_PS_ALS_USE_CHANGE_THRESHOLD

+        uint32_t nLuxIndex;

+#endif

+        struct stk3x1x_data *ps_data = container_of(work, struct stk3x1x_data, stk_work);

+        int32_t near_far_state;

+        int32_t als_comperator;

+#ifdef STK_GES

+        uint8_t disable_flag2 = 0, org_flag2_reg;

+#endif

+

+#if (STK_INT_PS_MODE    == 0x03)

+        near_far_state = gpio_get_value(ps_data->int_pin);

+#elif   (STK_INT_PS_MODE        == 0x02)

+        near_far_state = !(gpio_get_value(ps_data->int_pin));

+#endif

+

+#if ((STK_INT_PS_MODE == 0x03) || (STK_INT_PS_MODE      == 0x02))

+        ps_data->ps_distance_last = near_far_state;

+        input_report_abs(ps_data->ps_input_dev, ABS_DISTANCE, near_far_state);

+        input_sync(ps_data->ps_input_dev);

+        wake_lock_timeout(&ps_data->ps_wakelock, 3*HZ);

+        reading = stk3x1x_get_ps_reading(ps_data);

+#ifdef STK_DEBUG_PRINTF

+        printk(KERN_INFO "%s: ps input event %d cm, ps code = %d\n",__func__, near_far_state, reading);

+#endif

+#else

+        /* mode 0x01 or 0x04 */

+        org_flag_reg = stk3x1x_get_flag(ps_data);

+        if(org_flag_reg < 0)

+                goto err_i2c_rw;

+

+    if (org_flag_reg & STK_FLG_ALSINT_MASK)

+    {

+                disable_flag |= STK_FLG_ALSINT_MASK;

+        reading = stk3x1x_get_als_reading(ps_data);

+                if(reading < 0)

+                {

+                        printk(KERN_ERR "%s: stk3x1x_get_als_reading fail, ret=%d", __func__, reading);

+                        goto err_i2c_rw;

+                }

+#ifndef CONFIG_STK_PS_ALS_USE_CHANGE_THRESHOLD

+        nLuxIndex = stk_get_lux_interval_index(reading);

+        stk3x1x_set_als_thd_h(ps_data, code_threshold_table[nLuxIndex]);

+        stk3x1x_set_als_thd_l(ps_data, code_threshold_table[nLuxIndex-1]);

+#else

+        stk_als_set_new_thd(ps_data, reading);

+#endif //CONFIG_STK_PS_ALS_USE_CHANGE_THRESHOLD

+

+                if(ps_data->ir_code)

+                {

+                        if(reading < STK_IRC_MAX_ALS_CODE && reading > STK_IRC_MIN_ALS_CODE && 

+                        ps_data->ir_code > STK_IRC_MIN_IR_CODE)

+                        {

+                                als_comperator = reading * STK_IRC_ALS_NUMERA / STK_IRC_ALS_DENOMI;

+                                if(ps_data->ir_code > als_comperator)

+                                        ps_data->als_correct_factor = STK_IRC_ALS_CORREC;

+                                else

+                                        ps_data->als_correct_factor = 1000;

+                        }

+                        printk(KERN_INFO "%s: als=%d, ir=%d, als_correct_factor=%d", __func__, reading, ps_data->ir_code, ps_data->als_correct_factor);

+                        ps_data->ir_code = 0;

+                }

+

+                reading = reading * ps_data->als_correct_factor / 1000;

+

+                ps_data->als_lux_last = stk_alscode2lux(ps_data, reading);

+                input_report_abs(ps_data->als_input_dev, ABS_MISC, ps_data->als_lux_last);

+                input_sync(ps_data->als_input_dev);

+#ifdef STK_DEBUG_PRINTF

+                printk(KERN_INFO "%s: als input event %d lux\n",__func__, ps_data->als_lux_last);

+#endif

+    }

+    if (org_flag_reg & STK_FLG_PSINT_MASK)

+    {

+                disable_flag |= STK_FLG_PSINT_MASK;

+                near_far_state = (org_flag_reg & STK_FLG_NF_MASK)?1:0;

+

+                ps_data->ps_distance_last = near_far_state;

+                input_report_abs(ps_data->ps_input_dev, ABS_DISTANCE, near_far_state);

+                input_sync(ps_data->ps_input_dev);

+                wake_lock_timeout(&ps_data->ps_wakelock, 3*HZ);

+                reading = stk3x1x_get_ps_reading(ps_data);

+#ifdef STK_DEBUG_PRINTF

+                printk(KERN_INFO "%s: ps input event=%d, ps code = %d\n",__func__, near_far_state, reading);

+#endif

+        }

+

+        if(disable_flag)

+        {

+                ret = stk3x1x_set_flag(ps_data, org_flag_reg, disable_flag);

+                if(ret < 0)

+                        goto err_i2c_rw;

+        }

+#endif

+        usleep_range(1000, 2000);

+        //msleep(1);

+    enable_irq(ps_data->irq);

+        return;

+

+err_i2c_rw:

+        msleep(30);

+        enable_irq(ps_data->irq);

+        return;

+}

+

+static irqreturn_t stk_oss_irq_handler(int irq, void *data)

+{

+        struct stk3x1x_data *pData = data;

+        disable_irq_nosync(irq);

+        queue_work(pData->stk_wq,&pData->stk_work);

+        return IRQ_HANDLED;

+}

+#endif  /*      #if (!defined(STK_POLL_PS) || !defined(STK_POLL_ALS))   */

+

+#ifdef STK_POLL_ALS

+static void stk3x1x_als_set_poll_delay(struct stk3x1x_data *ps_data)

+{

+	uint8_t als_it = ps_data->alsctrl_reg & 0x0F;

+		

+	if(als_it == 0x8)

+	{

+		ps_data->als_poll_delay = ns_to_ktime(60 * NSEC_PER_MSEC);	

+	}

+	else if(als_it == 0x9)

+	{

+		ps_data->als_poll_delay = ns_to_ktime(110 * NSEC_PER_MSEC);

+	}

+	else if(als_it == 0xA)

+	{

+		ps_data->als_poll_delay = ns_to_ktime(220 * NSEC_PER_MSEC);		

+	}

+	else if(als_it == 0xB)

+	{

+		ps_data->als_poll_delay = ns_to_ktime(440 * NSEC_PER_MSEC);		

+	}

+	else if(als_it == 0xC)

+	{

+		ps_data->als_poll_delay = ns_to_ktime(880 * NSEC_PER_MSEC);		

+	}

+	else

+	{

+		ps_data->als_poll_delay = ns_to_ktime(110 * NSEC_PER_MSEC);		

+		printk(KERN_INFO "%s: unknown ALS_IT=%d, set als_poll_delay=110ms\n", __func__, als_it);

+	}	

+}

+#endif

+

+static int32_t stk3x1x_init_all_setting(struct i2c_client *client, struct stk3x1x_platform_data *plat_data)

+{

+	int32_t ret;

+	struct stk3x1x_data *ps_data = i2c_get_clientdata(client);		

+	

+	ret = stk3x1x_software_reset(ps_data); 

+	if(ret < 0)

+		return ret;

+	

+	ret = stk3x1x_check_pid(ps_data);

+	if(ret < 0)

+		return ret;

+	stk3x1x_proc_plat_data(ps_data, plat_data);

+	ret = stk3x1x_init_all_reg(ps_data);

+	if(ret < 0)

+		return ret;	

+#ifdef STK_POLL_ALS

+	stk3x1x_als_set_poll_delay(ps_data);

+#endif	

+	ps_data->als_enabled = false;

+	ps_data->ps_enabled = false;		

+	ps_data->re_enable_als = false;

+	ps_data->re_enable_ps = false;

+	ps_data->ir_code = 0;

+	ps_data->als_correct_factor = 1000;

+	ps_data->first_boot = true;	

+#ifndef CONFIG_STK_PS_ALS_USE_CHANGE_THRESHOLD

+	stk_init_code_threshold_table(ps_data);

+#endif			

+#ifdef STK_TUNE0

+	#ifdef QUALCOMM_PLATFORM		

+	ps_data->tune_zero_init_proc = false;	

+	ps_data->psi_set = 0;		

+	#else

+	stk_ps_tune_zero_init(ps_data);

+	#endif	

+#endif	

+#ifdef STK_ALS_FIR

+	memset(&ps_data->fir, 0x00, sizeof(ps_data->fir));  

+	atomic_set(&ps_data->firlength, STK_FIR_LEN);	

+#endif

+	atomic_set(&ps_data->recv_reg, 0);  

+#ifdef STK_GES	

+	ps_data->re_enable_ges = 0;	

+	atomic_set(&ps_data->gesture2, 0);  

+	//memset(stk_ges_op, 0, sizeof(stk_ges_op));

+#endif	

+#ifdef STK_IRS

+	ps_data->als_data_index = 0;

+#endif	

+	ps_data->ps_distance_last = 1;

+	ps_data->als_code_last = 0;

+    return 0;

+}

+

+#if (!defined(STK_POLL_PS) || !defined(STK_POLL_ALS))

+static int stk3x1x_setup_irq(struct i2c_client *client)

+{

+        int irq, err = -EIO;

+        struct stk3x1x_data *ps_data = i2c_get_clientdata(client);

+

+//#ifdef SPREADTRUM_PLATFORM

+//        irq = sprd_alloc_gpio_irq(ps_data->int_pin);

+//#else

+        irq = gpio_to_irq(ps_data->int_pin);

+//#endif

+#ifdef STK_DEBUG_PRINTF

+        printk(KERN_INFO "%s: int pin #=%d, irq=%d\n",__func__, ps_data->int_pin, irq);

+#endif

+        if (irq <= 0)

+        {

+                printk(KERN_ERR "irq number is not specified, irq # = %d, int pin=%d\n",irq, ps_data->int_pin);

+                return irq;

+        }

+        ps_data->irq = irq;

+        err = gpio_request(ps_data->int_pin,"stk-int");        

+        if(err < 0)

+        {

+                printk(KERN_ERR "%s: gpio_request, err=%d", __func__, err);

+                return err;

+        }

+        err = gpio_direction_input(ps_data->int_pin);

+        if(err < 0)

+        {

+                printk(KERN_ERR "%s: gpio_direction_input, err=%d", __func__, err);

+                return err;

+        }

+#if ((STK_INT_PS_MODE == 0x03) || (STK_INT_PS_MODE      == 0x02))

+        err = request_any_context_irq(irq, stk_oss_irq_handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, DEVICE_NAME, ps_data);

+#else

+        err = request_any_context_irq(irq, stk_oss_irq_handler, IRQF_TRIGGER_LOW|IRQF_NO_SUSPEND|IRQF_ONESHOT, DEVICE_NAME, ps_data);

+#endif

+        if (err < 0) 

+        {

+                printk(KERN_WARNING "%s: request_any_context_irq(%d) failed for (%d)\n", __func__, irq, err);

+                goto err_request_any_context_irq;

+        }

+        disable_irq(irq);

+

+        return 0;

+err_request_any_context_irq:

+//#ifdef SPREADTRUM_PLATFORM

+//        sprd_free_gpio_irq(ps_data->int_pin);

+//#else

+        gpio_free(ps_data->int_pin);

+//#endif

+        return err;

+}

+#endif

+

+

+static int stk3x1x_suspend(struct device *dev)

+{

+        struct stk3x1x_data *ps_data = dev_get_drvdata(dev);

+#if (defined(STK_CHK_REG) || !defined(STK_POLL_PS))

+	int err;

+#endif

+	

+#ifndef STK_POLL_PS

+    struct i2c_client *client = to_i2c_client(dev);

+#endif

+

+        printk(KERN_INFO "%s", __func__);

+#ifndef SPREADTRUM_PLATFORM

+        mutex_lock(&ps_data->io_lock);  

+#endif

+#ifdef STK_CHK_REG

+        err = stk3x1x_validate_n_handle(ps_data->client);

+        if(err < 0)

+        {

+                printk(KERN_ERR "stk3x1x_validate_n_handle fail: %d\n", err); 

+        }

+        else if (err == 0xFF)

+        {

+                if(ps_data->ps_enabled)

+                        stk3x1x_enable_ps(ps_data, 1, 0);

+        }

+#endif /* #ifdef STK_CHK_REG */

+#ifdef STK_GES

+        if(ps_data->ges_enabled == 1)

+        {

+                ps_data->re_enable_ges = ps_data->ges_enabled;

+                stk3x1x_enable_ges(ps_data, 0, 1);

+        }

+        else if(ps_data->ges_enabled == 2)

+        {

+                ps_data->re_enable_ges = ps_data->ges_enabled;

+                stk3x1x_enable_ges(ps_data, 0, 2);

+        }

+#endif

+#ifndef SPREADTRUM_PLATFORM

+        if(ps_data->als_enabled)

+        {

+                printk(KERN_INFO "%s: Enable ALS : 0\n", __func__);

+                stk3x1x_enable_als(ps_data, 0);

+                ps_data->re_enable_als = true;

+        }  

+#endif

+        if(ps_data->ps_enabled)

+        {

+#ifdef STK_POLL_PS

+                wake_lock(&ps_data->ps_nosuspend_wl);

+#else

+                if(device_may_wakeup(&client->dev))

+                {

+                        err = enable_irq_wake(ps_data->irq);

+                        if (err)

+                                printk(KERN_WARNING "%s: set_irq_wake(%d) failed, err=(%d)\n", __func__, ps_data->irq, err);

+                }

+                else

+                {

+                        printk(KERN_ERR "%s: not support wakeup source", __func__);

+                }

+#endif

+        }

+#ifndef SPREADTRUM_PLATFORM

+        mutex_unlock(&ps_data->io_lock);

+#endif

+        return 0;

+}

+

+static int stk3x1x_resume(struct device *dev)

+{

+        struct stk3x1x_data *ps_data = dev_get_drvdata(dev);

+#if (defined(STK_CHK_REG) || !defined(STK_POLL_PS))	

+	int err;

+#endif

+	

+#ifndef STK_POLL_PS         

+    struct i2c_client *client = to_i2c_client(dev);

+#endif

+        printk("%s called\n", __func__);

+        printk(KERN_INFO "%s", __func__);

+#ifndef SPREADTRUM_PLATFORM

+        mutex_lock(&ps_data->io_lock); 

+#endif

+#ifdef STK_CHK_REG

+        err = stk3x1x_validate_n_handle(ps_data->client);

+        if(err < 0)

+        {

+                printk(KERN_ERR "stk3x1x_validate_n_handle fail: %d\n", err); 

+        }

+        else if (err == 0xFF)

+        {

+                if(ps_data->ps_enabled)

+                        stk3x1x_enable_ps(ps_data, 1, 0);

+        }

+#endif /* #ifdef STK_CHK_REG */

+#ifdef STK_GES

+        if(ps_data->re_enable_ges == 1)

+        {

+                stk3x1x_enable_ges(ps_data, 1, 1);

+                ps_data->re_enable_ges = 0;

+        }

+        else if(ps_data->re_enable_ges == 2)

+        {

+                stk3x1x_enable_ges(ps_data, 1, 2);

+                ps_data->re_enable_ges = 0;

+        }

+#endif

+#ifndef SPREADTRUM_PLATFORM

+        if(ps_data->re_enable_als)

+        {

+                printk(KERN_INFO "%s: Enable ALS : 1\n", __func__);

+                stk3x1x_enable_als(ps_data, 1);

+                ps_data->re_enable_als = false;

+        }

+#endif

+        if(ps_data->ps_enabled)

+        {

+#ifdef STK_POLL_PS

+                wake_unlock(&ps_data->ps_nosuspend_wl);

+#else

+                if(device_may_wakeup(&client->dev))

+                {

+                        err = disable_irq_wake(ps_data->irq);

+                        if (err)

+                                printk(KERN_WARNING "%s: disable_irq_wake(%d) failed, err=(%d)\n", __func__, ps_data->irq, err);

+                }

+#endif

+        }

+#ifndef SPREADTRUM_PLATFORM

+        mutex_unlock(&ps_data->io_lock);

+#endif

+        return 0;

+}

+

+static const struct dev_pm_ops stk3x1x_pm_ops = {

+        SET_SYSTEM_SLEEP_PM_OPS(stk3x1x_suspend, stk3x1x_resume)

+};

+

+//#ifdef CONFIG_HAS_EARLYSUSPEND

+#if 0

+static void stk3x1x_early_suspend(struct early_suspend *h)

+{

+

+}

+

+static void stk3x1x_late_resume(struct early_suspend *h)

+{

+

+}

+#endif  //#ifdef CONFIG_HAS_EARLYSUSPEND

+

+

+#ifdef STK_QUALCOMM_POWER_CTRL

+static int stk3x1x_power_ctl(struct stk3x1x_data *data, bool on)

+{

+        int ret = 0;

+

+        if (!on && data->power_enabled) {

+                ret = regulator_disable(data->vdd);

+                if (ret) {

+                        dev_err(&data->client->dev,

+                                "Regulator vdd disable failed ret=%d\n", ret);

+                        return ret;

+                }

+

+                ret = regulator_disable(data->vio);

+                if (ret) {

+                        dev_err(&data->client->dev,

+                                "Regulator vio disable failed ret=%d\n", ret);

+                        regulator_enable(data->vdd);

+                        return ret;

+                }

+                data->power_enabled = on;

+                printk(KERN_INFO "%s: disable stk3x1x power", __func__);

+                dev_dbg(&data->client->dev, "stk3x1x_power_ctl on=%d\n",

+                                on);

+        } else if (on && !data->power_enabled) {

+                ret = regulator_enable(data->vdd);

+                if (ret) {

+                        dev_err(&data->client->dev,

+                                "Regulator vdd enable failed ret=%d\n", ret);

+                        return ret;

+                }

+

+                ret = regulator_enable(data->vio);

+                if (ret) {

+                        dev_err(&data->client->dev,

+                                "Regulator vio enable failed ret=%d\n", ret);

+                        regulator_disable(data->vdd);

+                        return ret;

+                }

+                data->power_enabled = on;

+                printk(KERN_INFO "%s: enable stk3x1x power", __func__);

+                dev_dbg(&data->client->dev, "stk3x1x_power_ctl on=%d\n",

+                                on);

+        } else {

+                dev_warn(&data->client->dev,

+                                "Power on=%d. enabled=%d\n",

+                                on, data->power_enabled);

+        }

+

+        return ret;

+}

+

+static int stk3x1x_power_init(struct stk3x1x_data *data, bool on)

+{

+        int ret;

+

+        if (!on) {

+                if (regulator_count_voltages(data->vdd) > 0)

+                        regulator_set_voltage(data->vdd,

+                                        0, STK3X1X_VDD_MAX_UV);

+

+                regulator_put(data->vdd);

+

+                if (regulator_count_voltages(data->vio) > 0)

+                        regulator_set_voltage(data->vio,

+                                        0, STK3X1X_VIO_MAX_UV);

+

+                regulator_put(data->vio);

+        } else {

+                data->vdd = regulator_get(&data->client->dev, "vdd");

+                if (IS_ERR(data->vdd)) {

+                        ret = PTR_ERR(data->vdd);

+                        dev_err(&data->client->dev,

+                                "Regulator get failed vdd ret=%d\n", ret);

+                        return ret;

+                }

+

+                if (regulator_count_voltages(data->vdd) > 0) {

+                        ret = regulator_set_voltage(data->vdd,

+                                        STK3X1X_VDD_MIN_UV,

+                                        STK3X1X_VDD_MAX_UV);

+                        if (ret) {

+                                dev_err(&data->client->dev,

+                                        "Regulator set failed vdd ret=%d\n",

+                                        ret);

+                                goto reg_vdd_put;

+                        }

+                }

+

+                data->vio = regulator_get(&data->client->dev, "vio");

+                if (IS_ERR(data->vio)) {

+                        ret = PTR_ERR(data->vio);

+                        dev_err(&data->client->dev,

+                                "Regulator get failed vio ret=%d\n", ret);

+                        goto reg_vdd_set;

+                }

+

+                if (regulator_count_voltages(data->vio) > 0) {

+                        ret = regulator_set_voltage(data->vio,

+                                        STK3X1X_VIO_MIN_UV,

+                                        STK3X1X_VIO_MAX_UV);

+                        if (ret) {

+                                dev_err(&data->client->dev,

+                                "Regulator set failed vio ret=%d\n", ret);

+                                goto reg_vio_put;

+                        }

+                }

+        }

+

+        return 0;

+

+reg_vio_put:

+        regulator_put(data->vio);

+reg_vdd_set:

+        if (regulator_count_voltages(data->vdd) > 0)

+                regulator_set_voltage(data->vdd, 0, STK3X1X_VDD_MAX_UV);

+reg_vdd_put:

+        regulator_put(data->vdd);

+        return ret;

+}

+

+static int stk3x1x_device_ctl(struct stk3x1x_data *ps_data, bool enable)

+{

+        int ret;

+        struct device *dev = &ps_data->client->dev;

+

+        if (enable && !ps_data->power_enabled) {

+                ret = stk3x1x_power_ctl(ps_data, true);

+                if (ret) {

+                        dev_err(dev, "Failed to enable device power\n");

+                        goto err_exit;

+                }

+                ret = stk3x1x_init_all_setting(ps_data->client, ps_data->pdata);

+                if (ret < 0) {

+                        stk3x1x_power_ctl(ps_data, false);

+                        dev_err(dev, "Failed to re-init device setting\n");

+                        goto err_exit;

+                }

+        } else if (!enable && ps_data->power_enabled) {

+        #ifdef STK_GES

+                if (!ps_data->als_enabled && !ps_data->ps_enabled && !ps_data->ges_enabled) {

+        #else

+                if (!ps_data->als_enabled && !ps_data->ps_enabled) {

+        #endif

+                        ret = stk3x1x_power_ctl(ps_data, false);

+                        if (ret) {

+                                dev_err(dev, "Failed to disable device power\n");

+                                goto err_exit;

+                        }

+                } else {

+                        dev_dbg(dev, "device control: als_enabled=%d, ps_enabled=%d\n",

+                                ps_data->als_enabled, ps_data->ps_enabled);

+                }

+        } else {

+                dev_dbg(dev, "device control: enable=%d, power_enabled=%d\n",

+                        enable, ps_data->power_enabled);

+        }

+        return 0;

+

+err_exit:

+        return ret;

+}

+#endif  /* #ifdef STK_QUALCOMM_POWER_CTRL */

+

+#ifdef CONFIG_OF

+static int stk3x1x_parse_dt(struct device *dev,

+                        struct stk3x1x_platform_data *pdata)

+{

+#if 0

+        int rc;

+        struct device_node *np = dev->of_node;

+        u32 temp_val;

+

+        pdata->int_pin = of_get_named_gpio_flags(np, "stk,irq-gpio",

+                                0, &pdata->int_flags);

+        if (pdata->int_pin < 0) {

+                dev_err(dev, "Unable to read irq-gpio\n");

+                return pdata->int_pin;

+        }

+

+        rc = of_property_read_u32(np, "stk,transmittance", &temp_val);

+        if (!rc)

+                pdata->transmittance = temp_val;

+        else {

+                dev_err(dev, "Unable to read transmittance\n");

+                return rc;

+        }

+

+        rc = of_property_read_u32(np, "stk,state-reg", &temp_val);

+        if (!rc)

+                pdata->state_reg = temp_val;

+        else {

+                dev_err(dev, "Unable to read state-reg\n");

+                return rc;

+        }

+

+        rc = of_property_read_u32(np, "stk,psctrl-reg", &temp_val);

+        if (!rc)

+                pdata->psctrl_reg = (u8)temp_val;

+        else {

+                dev_err(dev, "Unable to read psctrl-reg\n");

+                return rc;

+        }

+

+        rc = of_property_read_u32(np, "stk,alsctrl-reg", &temp_val);

+        if (!rc)

+                pdata->alsctrl_reg = (u8)temp_val;

+        else {

+                dev_err(dev, "Unable to read alsctrl-reg\n");

+                return rc;

+        }

+

+        rc = of_property_read_u32(np, "stk,ledctrl-reg", &temp_val);

+        if (!rc)

+                pdata->ledctrl_reg = (u8)temp_val;

+        else {

+                dev_err(dev, "Unable to read ledctrl-reg\n");

+                return rc;

+        }

+

+        rc = of_property_read_u32(np, "stk,wait-reg", &temp_val);

+        if (!rc)

+                pdata->wait_reg = (u8)temp_val;

+        else {

+                dev_err(dev, "Unable to read wait-reg\n");

+                return rc;

+        }

+

+        rc = of_property_read_u32(np, "stk,ps-thdh", &temp_val);

+        if (!rc)

+                pdata->ps_thd_h = (u16)temp_val;

+        else {

+                dev_err(dev, "Unable to read ps-thdh\n");

+                return rc;

+        }

+

+        rc = of_property_read_u32(np, "stk,ps-thdl", &temp_val);

+        if (!rc)

+                pdata->ps_thd_l = (u16)temp_val;

+        else {

+                dev_err(dev, "Unable to read ps-thdl\n");

+                return rc;

+        }

+

+        //pdata->use_fir = of_property_read_bool(np, "stk,use-fir");

+#endif

+

+        return 0;

+}

+#else

+static int stk3x1x_parse_dt(struct device *dev,

+                        struct stk3x1x_platform_data *pdata)

+{

+        return -ENODEV;

+}

+#endif /* !CONFIG_OF */

+

+static int stk3x1x_set_wq(struct stk3x1x_data *ps_data)

+{

+#ifdef STK_POLL_ALS

+        ps_data->stk_als_wq = create_singlethread_workqueue("stk_als_wq");

+        INIT_WORK(&ps_data->stk_als_work, stk_als_poll_work_func);

+        hrtimer_init(&ps_data->als_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

+        ps_data->als_poll_delay = ns_to_ktime(110 * NSEC_PER_MSEC);

+        ps_data->als_timer.function = stk_als_timer_func;

+#endif

+

+#ifdef STK_POLL_PS

+        ps_data->stk_ps_wq = create_singlethread_workqueue("stk_ps_wq");

+        INIT_WORK(&ps_data->stk_ps_work, stk_ps_poll_work_func);

+        hrtimer_init(&ps_data->ps_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

+        ps_data->ps_poll_delay = ns_to_ktime(60 * NSEC_PER_MSEC);

+        ps_data->ps_timer.function = stk_ps_timer_func;

+#endif

+

+#ifdef STK_TUNE0

+        ps_data->stk_ps_tune0_wq = create_singlethread_workqueue("stk_ps_tune0_wq");

+        INIT_WORK(&ps_data->stk_ps_tune0_work, stk_ps_tune0_work_func);

+        hrtimer_init(&ps_data->ps_tune0_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

+        ps_data->ps_tune0_delay = ns_to_ktime(60 * NSEC_PER_MSEC);

+        ps_data->ps_tune0_timer.function = stk_ps_tune0_timer_func;

+#endif

+

+#if (!defined(STK_POLL_ALS) || !defined(STK_POLL_PS))

+        ps_data->stk_wq = create_singlethread_workqueue("stk_wq");

+        INIT_WORK(&ps_data->stk_work, stk_work_func);

+#endif

+        return 0;

+}

+

+

+static int stk3x1x_set_input_devices(struct stk3x1x_data *ps_data)

+{

+        int err;

+

+        ps_data->als_input_dev = input_allocate_device();

+        if (ps_data->als_input_dev==NULL)

+        {

+                printk(KERN_ERR "%s: could not allocate als device\n", __func__);

+                err = -ENOMEM;

+                return err;

+        }

+        ps_data->ps_input_dev = input_allocate_device();

+        if (ps_data->ps_input_dev==NULL)

+        {

+                printk(KERN_ERR "%s: could not allocate ps device\n", __func__);

+                err = -ENOMEM;

+                return err;

+        }

+        ps_data->als_input_dev->name = ALS_NAME;

+        ps_data->ps_input_dev->name = PS_NAME;

+        set_bit(EV_ABS, ps_data->als_input_dev->evbit);

+        set_bit(EV_ABS, ps_data->ps_input_dev->evbit);

+        input_set_abs_params(ps_data->als_input_dev, ABS_MISC, 0, stk_alscode2lux(ps_data, (1<<16)-1), 0, 0);

+        input_set_abs_params(ps_data->ps_input_dev, ABS_DISTANCE, 0,1, 0, 0);

+        err = input_register_device(ps_data->als_input_dev);

+        if (err<0)

+        {

+                printk(KERN_ERR "%s: can not register als input device\n", __func__);

+                return err;

+        }

+        err = input_register_device(ps_data->ps_input_dev);

+        if (err<0)

+        {

+                printk(KERN_ERR "%s: can not register ps input device\n", __func__);

+                return err;

+        }

+

+        err = sysfs_create_group(&ps_data->als_input_dev->dev.kobj, &stk_als_attribute_group);

+        if (err < 0) 

+        {

+                printk(KERN_ERR "%s:could not create sysfs group for als\n", __func__);

+                return err;

+        }

+        err = sysfs_create_group(&ps_data->ps_input_dev->dev.kobj, &stk_ps_attribute_group);

+        if (err < 0) 

+        {

+                printk(KERN_ERR "%s:could not create sysfs group for ps\n", __func__);

+                return err;

+        }

+        input_set_drvdata(ps_data->als_input_dev, ps_data);

+        input_set_drvdata(ps_data->ps_input_dev, ps_data);

+

+#ifdef STK_GES

+        ps_data->ges_input_dev = input_allocate_device();

+        if (ps_data->ges_input_dev==NULL)

+        {

+                printk(KERN_ERR "%s: could not allocate ps device\n", __func__);

+                err = -ENOMEM;

+                return err;

+        }

+        ps_data->ges_input_dev->name = "stk_ges";

+        ps_data->ges_input_dev->evbit[0] = BIT_MASK(EV_KEY);

+        set_bit(KEY_PAGEUP, ps_data->ges_input_dev->keybit);

+        set_bit(KEY_PAGEDOWN, ps_data->ges_input_dev->keybit);

+        set_bit(KEY_VOLUMEUP, ps_data->ges_input_dev->keybit);

+        set_bit(KEY_VOLUMEDOWN, ps_data->ges_input_dev->keybit);

+        /*

+        set_bit(KEY_LEFT, ps_data->ges_input_dev->keybit);

+        set_bit(KEY_RIGHT, ps_data->ges_input_dev->keybit);

+        set_bit(KEY_UP, ps_data->ges_input_dev->keybit);

+        set_bit(KEY_DOWN, ps_data->ges_input_dev->keybit);

+        */

+        err = input_register_device(ps_data->ges_input_dev);

+        if (err<0)

+        {

+                printk(KERN_ERR "%s: can not register ps input device\n", __func__);

+                return err;

+        }

+

+        err = sysfs_create_group(&ps_data->ges_input_dev->dev.kobj, &stk_ges_attribute_group);

+        if (err < 0) 

+        {

+                printk(KERN_ERR "%s:could not create sysfs group for ps\n", __func__);

+                return err;

+        }

+        input_set_drvdata(ps_data->ges_input_dev, ps_data);

+#endif

+

+        return 0;

+}

+

+static int stk3x1x_probe(struct i2c_client *client,

+                        const struct i2c_device_id *id)

+{

+    int err = -ENODEV;

+    struct stk3x1x_data *ps_data;

+        struct stk3x1x_platform_data *plat_data;

+    printk(KERN_INFO "%s: driver version = %s\n", __func__, DRIVER_VERSION);

+

+    if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))

+    {

+        printk(KERN_ERR "%s: No Support for I2C_FUNC_I2C\n", __func__);

+        return -ENODEV;

+    }

+

+        ps_data = kzalloc(sizeof(struct stk3x1x_data),GFP_KERNEL);

+        if(!ps_data)

+        {

+                printk(KERN_ERR "%s: failed to allocate stk3x1x_data\n", __func__);

+                return -ENOMEM;

+        }

+        ps_data->client = client;

+        i2c_set_clientdata(client,ps_data);

+        mutex_init(&ps_data->io_lock);

+        wake_lock_init(&ps_data->ps_wakelock,WAKE_LOCK_SUSPEND, "stk_input_wakelock");

+

+#ifdef STK_POLL_PS

+        wake_lock_init(&ps_data->ps_nosuspend_wl,WAKE_LOCK_SUSPEND, "stk_nosuspend_wakelock");

+#endif

+

+        if (client->dev.of_node) {

+                printk(KERN_INFO "%s: probe with device tree\n", __func__);

+                plat_data = devm_kzalloc(&client->dev,

+                        sizeof(struct stk3x1x_platform_data), GFP_KERNEL);

+                if (!plat_data) {

+                        dev_err(&client->dev, "Failed to allocate memory\n");

+                        return -ENOMEM;

+                }

+

+                err = stk3x1x_parse_dt(&client->dev, plat_data);

+//huanggq

+                  plat_data->state_reg = stk3x1x_pfdata.state_reg; 

+                  plat_data->psctrl_reg = stk3x1x_pfdata.psctrl_reg;

+                  plat_data->alsctrl_reg = stk3x1x_pfdata.alsctrl_reg; 

+                  plat_data->ledctrl_reg = stk3x1x_pfdata.ledctrl_reg; 

+                  plat_data->wait_reg = stk3x1x_pfdata.wait_reg;

+                  plat_data->ps_thd_h = stk3x1x_pfdata.ps_thd_h; 

+                  plat_data->ps_thd_l = stk3x1x_pfdata.ps_thd_l;

+                  plat_data->int_pin = stk3x1x_pfdata.int_pin;

+                  plat_data->transmittance = stk3x1x_pfdata.transmittance;

+//end

+                dev_err(&client->dev,

+                        "%s: stk3x1x_parse_dt ret=%d\n", __func__, err);

+                if (err)

+                        return err;

+        } else {

+                printk(KERN_INFO "%s: probe with platform data\n", __func__);

+#ifdef SPREADTRUM_PLATFORM

+                plat_data = &stk3x1x_pfdata;

+#else

+                plat_data = client->dev.platform_data;

+#endif

+        }

+        if (!plat_data) {

+                dev_err(&client->dev,

+                        "%s: no stk3x1x platform data!\n", __func__);

+                goto err_als_input_allocate;

+        }

+        ps_data->als_transmittance = plat_data->transmittance;

+        ps_data->int_pin = plat_data->int_pin;

+        ps_data->pdata = plat_data;

+

+        if (ps_data->als_transmittance == 0) {

+                dev_err(&client->dev,

+                        "%s: Please set als_transmittance\n", __func__);

+                goto err_als_input_allocate;

+        }

+

+        stk3x1x_set_wq(ps_data);

+#ifdef QUALCOMM_PLATFORM

+        ps_data->ps_thd_h = 0;

+        ps_data->ps_thd_l = 0;

+#endif

+        ps_data->stk_max_min_diff = STK_MAX_MIN_DIFF;

+        ps_data->stk_lt_n_ct = STK_LT_N_CT;

+        ps_data->stk_ht_n_ct = STK_HT_N_CT;

+

+#ifdef STK_QUALCOMM_POWER_CTRL

+        err = stk3x1x_power_init(ps_data, true);

+        if (err)

+                goto err_init_all_setting;

+

+        err = stk3x1x_power_ctl(ps_data, true);

+        if (err)

+                goto err_power_on;

+

+        ps_data->als_enabled = false;

+        ps_data->ps_enabled = false;

+#endif

+

+        err = stk3x1x_init_all_setting(client, plat_data);

+        if(err < 0)

+                goto err_init_all_setting;

+

+        err = stk3x1x_set_input_devices(ps_data);

+        if(err < 0)

+                goto err_setup_input_device;

+

+#if (!defined(STK_POLL_ALS) || !defined(STK_POLL_PS))

+        err = stk3x1x_setup_irq(client);

+        if(err < 0)

+                goto err_stk3x1x_setup_irq;

+#endif

+        device_init_wakeup(&client->dev, true);

+

+//#ifdef CONFIG_HAS_EARLYSUSPEND

+#if 0

+        ps_data->stk_early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;

+        ps_data->stk_early_suspend.suspend = stk3x1x_early_suspend;

+        ps_data->stk_early_suspend.resume = stk3x1x_late_resume;

+        register_early_suspend(&ps_data->stk_early_suspend);

+#endif

+

+#ifdef STK_QUALCOMM_POWER_CTRL

+        /* enable device power only when it is enabled */

+        err = stk3x1x_power_ctl(ps_data, false);

+        if (err)

+                goto err_stk3x1x_setup_irq;

+#endif

+        printk(KERN_INFO "%s: probe successfully", __func__);

+        return 0;

+

+        //device_init_wakeup(&client->dev, false);

+err_stk3x1x_setup_irq:

+#if (!defined(STK_POLL_ALS) || !defined(STK_POLL_PS))

+        free_irq(ps_data->irq, ps_data);

+        //#ifdef SPREADTRUM_PLATFORM

+        //        sprd_free_gpio_irq(ps_data->int_pin);

+        //#else

+                gpio_free(ps_data->int_pin);

+        //#endif

+#endif

+err_setup_input_device:

+#ifdef STK_GES

+        sysfs_remove_group(&ps_data->ges_input_dev->dev.kobj, &stk_ges_attribute_group);

+        input_unregister_device(ps_data->ges_input_dev);

+        input_free_device(ps_data->ges_input_dev);

+#endif

+        sysfs_remove_group(&ps_data->ps_input_dev->dev.kobj, &stk_ps_attribute_group);

+        sysfs_remove_group(&ps_data->als_input_dev->dev.kobj, &stk_als_attribute_group);

+        input_unregister_device(ps_data->ps_input_dev);

+        input_unregister_device(ps_data->als_input_dev);

+        input_free_device(ps_data->ps_input_dev);

+        input_free_device(ps_data->als_input_dev);

+#ifdef STK_QUALCOMM_POWER_CTRL

+        stk3x1x_power_ctl(ps_data, false);

+err_power_on:

+        stk3x1x_power_init(ps_data, false);

+#endif

+err_init_all_setting:

+#ifdef STK_POLL_ALS

+        hrtimer_try_to_cancel(&ps_data->als_timer);

+        destroy_workqueue(ps_data->stk_als_wq);

+#endif

+#ifdef STK_TUNE0

+        destroy_workqueue(ps_data->stk_ps_tune0_wq);

+#endif

+#ifdef STK_POLL_PS

+        hrtimer_try_to_cancel(&ps_data->ps_timer);

+        destroy_workqueue(ps_data->stk_ps_wq);

+#endif

+#if (!defined(STK_POLL_ALS) || !defined(STK_POLL_PS))

+        destroy_workqueue(ps_data->stk_wq);

+#endif

+err_als_input_allocate:

+#ifdef STK_POLL_PS

+    wake_lock_destroy(&ps_data->ps_nosuspend_wl);

+#endif

+    wake_lock_destroy(&ps_data->ps_wakelock);

+    mutex_destroy(&ps_data->io_lock);

+        kfree(ps_data);

+    return err;

+}

+

+

+static int stk3x1x_remove(struct i2c_client *client)

+{

+        struct stk3x1x_data *ps_data = i2c_get_clientdata(client);

+        device_init_wakeup(&client->dev, false);

+#if (!defined(STK_POLL_ALS) || !defined(STK_POLL_PS))

+        free_irq(ps_data->irq, ps_data);

+        //#ifdef SPREADTRUM_PLATFORM

+        //        sprd_free_gpio_irq(ps_data->int_pin);

+        //#else

+                gpio_free(ps_data->int_pin);

+        //#endif

+#endif  /* #if (!defined(STK_POLL_ALS) || !defined(STK_POLL_PS)) */

+

+

+#ifdef STK_GES

+        sysfs_remove_group(&ps_data->ges_input_dev->dev.kobj, &stk_ges_attribute_group);

+        input_unregister_device(ps_data->ges_input_dev);

+        input_free_device(ps_data->ges_input_dev);

+#endif

+#if (!defined(STK_POLL_ALS) || !defined(STK_POLL_PS))

+        destroy_workqueue(ps_data->stk_wq);

+#endif

+        sysfs_remove_group(&ps_data->ps_input_dev->dev.kobj, &stk_ps_attribute_group);

+        sysfs_remove_group(&ps_data->als_input_dev->dev.kobj, &stk_als_attribute_group);

+        input_unregister_device(ps_data->ps_input_dev);

+        input_unregister_device(ps_data->als_input_dev);

+        input_free_device(ps_data->ps_input_dev);

+        input_free_device(ps_data->als_input_dev);

+#ifdef STK_QUALCOMM_POWER_CTRL

+        stk3x1x_power_ctl(ps_data, false);

+        stk3x1x_power_init(ps_data, false);

+#endif

+#ifdef STK_POLL_ALS

+        hrtimer_try_to_cancel(&ps_data->als_timer);

+        destroy_workqueue(ps_data->stk_als_wq);

+#endif

+#ifdef STK_TUNE0

+        destroy_workqueue(ps_data->stk_ps_tune0_wq);

+#endif

+#ifdef STK_POLL_PS

+        hrtimer_try_to_cancel(&ps_data->ps_timer);

+        destroy_workqueue(ps_data->stk_ps_wq);

+        wake_lock_destroy(&ps_data->ps_nosuspend_wl);

+#endif

+        wake_lock_destroy(&ps_data->ps_wakelock);

+    mutex_destroy(&ps_data->io_lock);

+        kfree(ps_data);

+

+    return 0;

+}

+

+static const struct i2c_device_id stk_ps_id[] =

+{

+    { "stk_ps", 0},

+    {}

+};

+MODULE_DEVICE_TABLE(i2c, stk_ps_id);

+

+static struct of_device_id stk_match_table[] = {

+        { .compatible = "stk,stk3x1x", },

+        { },

+};

+

+static struct i2c_driver stk_ps_driver =

+{

+    .driver = {

+        .name = DEVICE_NAME,

+                .owner = THIS_MODULE,

+#ifdef CONFIG_OF

+                .of_match_table = stk_match_table,

+#endif

+                .pm = &stk3x1x_pm_ops,

+    },

+    .probe = stk3x1x_probe,

+    .remove = stk3x1x_remove,

+    .id_table = stk_ps_id,

+};

+

+static int __init stk3x1x_init(void)

+{

+        int ret;

+

+        printk("stk3x1x_init");

+

+    ret = i2c_add_driver(&stk_ps_driver);

+    if (ret)

+        {

+                i2c_del_driver(&stk_ps_driver);

+        return ret;

+        }

+    return 0;

+}

+

+static void __exit stk3x1x_exit(void)

+{

+    i2c_del_driver(&stk_ps_driver);

+}

+

+module_init(stk3x1x_init);

+module_exit(stk3x1x_exit);

+MODULE_AUTHOR("Lex Hsieh <lex_hsieh@sensortek.com.tw>");

+MODULE_DESCRIPTION("Sensortek stk3x1x Proximity Sensor driver");

+MODULE_LICENSE("GPL");

+MODULE_VERSION(DRIVER_VERSION);
\ No newline at end of file
diff --git a/drivers/input/misc/stk3x1x.h b/drivers/input/misc/stk3x1x.h
new file mode 100644
index 00000000..2d3cc79b
--- /dev/null
+++ b/drivers/input/misc/stk3x1x.h
@@ -0,0 +1,31 @@
+/*

+ *

+ * $Id: stk3x1x.h

+ *

+ * Copyright (C) 2012~2013 Lex Hsieh     <lex_hsieh@sensortek.com.tw> 

+ *

+ * This file is subject to the terms and conditions of the GNU General Public

+ * License.  See the file COPYING in the main directory of this archive for

+ * more details.

+ *

+ */

+#ifndef __STK3X1X_H__

+#define __STK3X1X_H__

+

+/* platform data */

+struct stk3x1x_platform_data

+{

+        uint8_t state_reg;

+        uint8_t psctrl_reg;

+        uint8_t alsctrl_reg;

+        uint8_t ledctrl_reg;

+        uint8_t wait_reg;

+        uint16_t ps_thd_h;

+        uint16_t ps_thd_l;

+        int int_pin;

+        uint32_t transmittance;

+        uint32_t int_flags;

+};

+

+

+#endif // __STK3X1X_H__
\ No newline at end of file
diff --git a/drivers/input/misc/tmd2771_pls.c b/drivers/input/misc/tmd2771_pls.c
new file mode 100644
index 00000000..e3cc465e
--- /dev/null
+++ b/drivers/input/misc/tmd2771_pls.c
@@ -0,0 +1,1591 @@
+/*******************************************************************************
+*                                                                              *
+*   File Name:    taos.c                                                      *
+*   Description:   Linux device driver for Taos ambient light and         *
+*   proximity sensors.                                     *
+*   Author:         John Koshi                                             *
+*   History:   09/16/2009 - Initial creation                          *
+*           10/09/2009 - Triton version         *
+*           12/21/2009 - Probe/remove mode                *
+*           02/07/2010 - Add proximity          *
+*                                                                              *
+********************************************************************************
+*    Proprietary to Taos Inc., 1001 Klein Road #300, Plano, TX 75074        *
+*******************************************************************************/
+// includes
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/cdev.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/timer.h>
+#include <asm/uaccess.h>
+#include <asm/errno.h>
+#include <asm/delay.h>
+#include <linux/i2c/tmd2771_pls.h>
+#include <linux/delay.h>
+//iVIZM
+#include <linux/irq.h> 
+#include <linux/interrupt.h> 
+#include <linux/slab.h>
+#include <mach/gpio.h> 
+#include <linux/poll.h> 
+#include <linux/wakelock.h>
+#include <linux/input.h>
+#include <linux/regulator/consumer.h>
+#include <mach/regulator.h>
+
+#include <linux/miscdevice.h>
+
+// device name/id/address/counts
+#define TAOS_DEVICE_NAME                "tmd2771_pls"
+#define TAOS_DEVICE_ID                  "tritonFN"
+#define TAOS_ID_NAME_SIZE               10
+#define TAOS_TRITON_CHIPIDVAL           0x00
+#define TAOS_TRITON_MAXREGS             32
+#define TAOS_DEVICE_ADDR1               0x29
+#define TAOS_DEVICE_ADDR2               0x39
+#define TAOS_DEVICE_ADDR3               0x49
+#define TAOS_MAX_NUM_DEVICES            3
+#define TAOS_MAX_DEVICE_REGS            32
+#define I2C_MAX_ADAPTERS                8
+
+// TRITON register offsets
+#define TAOS_TRITON_CNTRL               0x00
+#define TAOS_TRITON_ALS_TIME            0X01
+#define TAOS_TRITON_PRX_TIME            0x02
+#define TAOS_TRITON_WAIT_TIME           0x03
+#define TAOS_TRITON_ALS_MINTHRESHLO     0X04
+#define TAOS_TRITON_ALS_MINTHRESHHI     0X05
+#define TAOS_TRITON_ALS_MAXTHRESHLO     0X06
+#define TAOS_TRITON_ALS_MAXTHRESHHI     0X07
+#define TAOS_TRITON_PRX_MINTHRESHLO     0X08
+#define TAOS_TRITON_PRX_MINTHRESHHI     0X09
+#define TAOS_TRITON_PRX_MAXTHRESHLO     0X0A
+#define TAOS_TRITON_PRX_MAXTHRESHHI     0X0B
+#define TAOS_TRITON_INTERRUPT           0x0C
+#define TAOS_TRITON_PRX_CFG             0x0D
+#define TAOS_TRITON_PRX_COUNT           0x0E
+#define TAOS_TRITON_GAIN                0x0F
+#define TAOS_TRITON_REVID               0x11
+#define TAOS_TRITON_CHIPID              0x12
+#define TAOS_TRITON_STATUS              0x13
+#define TAOS_TRITON_ALS_CHAN0LO         0x14
+#define TAOS_TRITON_ALS_CHAN0HI         0x15
+#define TAOS_TRITON_ALS_CHAN1LO         0x16
+#define TAOS_TRITON_ALS_CHAN1HI         0x17
+#define TAOS_TRITON_PRX_LO              0x18
+#define TAOS_TRITON_PRX_HI              0x19
+#define TAOS_TRITON_TEST_STATUS         0x1F
+
+// Triton cmd reg masks
+#define TAOS_TRITON_CMD_REG             0X80
+#define TAOS_TRITON_CMD_AUTO            0x10 //iVIZM
+#define TAOS_TRITON_CMD_BYTE_RW         0x00
+#define TAOS_TRITON_CMD_WORD_BLK_RW     0x20
+#define TAOS_TRITON_CMD_SPL_FN          0x60
+#define TAOS_TRITON_CMD_PROX_INTCLR     0X05
+#define TAOS_TRITON_CMD_ALS_INTCLR      0X06
+#define TAOS_TRITON_CMD_PROXALS_INTCLR  0X07
+#define TAOS_TRITON_CMD_TST_REG         0X08
+#define TAOS_TRITON_CMD_USER_REG        0X09
+
+// Triton cntrl reg masks
+#define TAOS_TRITON_CNTL_PROX_INT_ENBL  0X20
+#define TAOS_TRITON_CNTL_ALS_INT_ENBL   0X10
+#define TAOS_TRITON_CNTL_WAIT_TMR_ENBL  0X08
+#define TAOS_TRITON_CNTL_PROX_DET_ENBL  0X04
+#define TAOS_TRITON_CNTL_ADC_ENBL       0x02
+#define TAOS_TRITON_CNTL_PWRON          0x01
+
+// Triton status reg masks
+#define TAOS_TRITON_STATUS_ADCVALID     0x01
+#define TAOS_TRITON_STATUS_PRXVALID     0x02
+#define TAOS_TRITON_STATUS_ADCINTR      0x10
+#define TAOS_TRITON_STATUS_PRXINTR      0x20
+
+// lux constants
+#define TAOS_MAX_LUX                    10000
+#define TAOS_SCALE_MILLILUX             3
+#define TAOS_FILTER_DEPTH               3
+#define CHIP_ID                         0x3d
+
+#define TAOS_INPUT_NAME    "light sensor"
+// forward declarations
+static int taos_probe(struct i2c_client *clientp, const struct i2c_device_id *idp);
+static int taos_remove(struct i2c_client *client);
+static int taos_open(struct inode *inode, struct file *file);
+static int taos_release(struct inode *inode, struct file *file);
+static int taos_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
+static int taos_get_lux(void);
+//static int taos_lux_filter(int raw_lux);
+static int taos_device_name(unsigned char *bufp, char **device_name);
+static int taos_prox_poll(struct taos_prox_info *prxp);
+static void taos_prox_poll_timer_func(unsigned long param);
+static void taos_prox_poll_timer_start(void);
+//iVIZM
+static int taos_als_threshold_set(void);
+static int taos_prox_threshold_set(void);
+static int taos_als_get_data(void);
+static int taos_interrupts_clear(void);
+//static unsigned int taos_poll(struct file *filp, poll_table *wait);
+//static int taos_resume(struct i2c_client *client);
+//static int taos_suspend(struct i2c_client *client,pm_message_t mesg);
+
+
+DECLARE_WAIT_QUEUE_HEAD(waitqueue_read);//iVIZM
+
+#define ALS_PROX_DEBUG //iVIZM
+
+// first device number
+static dev_t taos_dev_number;
+
+// workqueue struct
+//static struct workqueue_struct *taos_wq; //iVIZM
+
+// class structure for this device
+struct class *taos_class;
+
+// module device table
+static struct i2c_device_id taos_idtable[] = {
+    {TAOS_DEVICE_NAME, 0},
+    {}
+};
+MODULE_DEVICE_TABLE(i2c, taos_idtable);
+
+// board and address info   iVIZM
+struct i2c_board_info taos_board_info[] = {
+    {I2C_BOARD_INFO(TAOS_DEVICE_ID, TAOS_DEVICE_ADDR2),},
+};
+
+unsigned short const taos_addr_list[2] = {TAOS_DEVICE_ADDR2, I2C_CLIENT_END};//iVIZM
+
+// client and device
+struct i2c_client *my_clientp;
+struct i2c_client *bad_clientp[TAOS_MAX_NUM_DEVICES];
+static int num_bad = 0;
+static int device_found = 0;
+//iVIZM
+static char pro_buf[4]; //iVIZM
+static int mcount = 0; //iVIZM
+static char als_buf[4]; //iVIZM
+u16 status = 0;
+static int ALS_ON;
+
+// driver definition
+static struct i2c_driver taos_driver = {
+    .driver = {
+        .owner = THIS_MODULE,
+        .name = TAOS_DEVICE_NAME,
+    },
+    .id_table = taos_idtable,
+    .probe = taos_probe,
+    //.resume = taos_resume,//iVIZM
+    //.suspend = taos_suspend,//iVIZM
+    .remove = __devexit_p(taos_remove),
+};
+
+// per-device data
+struct taos_data {
+    struct i2c_client *client;
+    struct cdev cdev;
+    unsigned int addr;
+    struct input_dev *input_dev;//iVIZM
+    struct work_struct work;//iVIZM
+    struct wake_lock taos_wake_lock;//iVIZM
+    char taos_id;
+    char taos_name[TAOS_ID_NAME_SIZE];
+    struct semaphore update_lock;
+    char valid;
+    //int working;
+    unsigned long last_updated;
+    struct regulator *reg_vdd;
+} *taos_datap;
+
+// file operations
+static struct file_operations taos_fops = {
+    .owner = THIS_MODULE,
+    .open = taos_open,
+    .release = taos_release,
+    .unlocked_ioctl = taos_ioctl,
+};
+
+// device configuration
+struct taos_cfg *taos_cfgp;
+
+#if 1 //zwj add 
+static struct file_operations taos_fops_2 = {
+	.owner				= THIS_MODULE,
+	.open				= taos_open,
+	.release			= taos_release,
+	.unlocked_ioctl				= taos_ioctl,
+};
+
+static struct miscdevice taos_device = {
+	.minor = MISC_DYNAMIC_MINOR,
+	.name = TAOS_DEVICE_NAME,
+	.fops = &taos_fops_2,
+};
+#endif
+  
+   
+static u32 calibrate_target_param = 300000;
+static u16 als_time_param = 200;
+static u16 scale_factor_param = 1;
+static u16 gain_trim_param = 512;
+static u8 filter_history_param = 3;
+static u8 filter_count_param = 1;
+static u8 gain_param = 2;
+static u16 prox_threshold_hi_param = 560;	//120;
+static u16 prox_threshold_lo_param = 500;	//80;
+static u16 als_threshold_hi_param = 3000;//iVIZM
+static u16 als_threshold_lo_param = 10;//iVIZM
+static u8 prox_int_time_param = 0xEE;//50ms
+static u8 prox_adc_time_param = 0xFF;
+static u8 prox_wait_time_param = 0xEE;
+static u8 prox_intr_filter_param = 0x23;
+static u8 prox_config_param = 0x00;
+static u8 prox_pulse_cnt_param = 0x04;	//0x01;
+static u8 prox_gain_param = 0xA2;	//0x22;
+
+// prox info
+struct taos_prox_info prox_cal_info[20];
+struct taos_prox_info prox_cur_info;
+struct taos_prox_info *prox_cur_infop = &prox_cur_info;
+static u8 prox_history_hi = 0;
+static u8 prox_history_lo = 0;
+static struct timer_list prox_poll_timer;
+static int prox_on = 0;
+static int device_released = 0;
+static u16 sat_als = 0;
+static u16 sat_prox = 0;
+
+// device reg init values
+u8 taos_triton_reg_init[16] = {0x00,0xFF,0XFF,0XFF,0X00,0X00,0XFF,0XFF,0X00,0X00,0XFF,0XFF,0X00,0X00,0X00,0X00};
+
+// lux time scale
+struct time_scale_factor  {
+    u16 numerator;
+    u16 denominator;
+    u16 saturation;
+};
+struct time_scale_factor TritonTime = {1, 0, 0};
+struct time_scale_factor *lux_timep = &TritonTime;
+
+// gain table
+u8 taos_triton_gain_table[] = {1, 8, 16, 120};
+
+// lux data
+    
+struct lux_data {
+    u16 ratio;
+    u16 clear;
+    u16 ir;
+  
+};
+struct lux_data TritonFN_lux_data[] = {
+    { 9830,  8320,  15360 },
+    { 12452, 10554, 22797 },
+    { 14746, 6234,  11430 },
+    { 17695, 3968,  6400  },
+    { 0,     0,     0     }
+};
+struct lux_data *lux_tablep = TritonFN_lux_data;
+static int lux_history[TAOS_FILTER_DEPTH] = {-ENODATA, -ENODATA, -ENODATA};//iVIZM
+
+static int tmd2711_pls_irq;
+
+
+
+static irqreturn_t taos_irq_handler(int irq, void *dev_id) //iVIZM
+{
+    //disable_irq_nosync(tmd2711_pls_irq);
+    //queue_work(taos_wq,&taos_datap->work);
+    //printk("^^^^^^^^^^^^^^^^^^ taos_irq_handler ^^^^^^^^^^^^^^^^^^^^\n");
+    schedule_work(&taos_datap->work);
+    //enable_irq(tmd2711_pls_irq);
+
+    return IRQ_HANDLED;
+}
+
+static int taos_get_data(void)//iVIZM
+{
+    int ret = 0;
+	
+    //printk("^^^^^^^^^^^^^^^^^^ taos_get_data ^^^^^^^^^^^^^^^^^^^^\n");
+	
+    if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | 0x13)))) < 0) {
+        //printk(KERN_ERR "TAOS: i2c_smbus_write_byte(1) failed in taos_work_func()\n");
+        return (ret);
+    }
+    status = i2c_smbus_read_byte(taos_datap->client);
+  //  if (down_interruptible(&taos_datap->update_lock))
+       // return -ERESTARTSYS;  
+	printk(" kl# %s, line=%d, status=%x\n", __func__, __LINE__, status);
+	// status : 5:4    =  pint:aint //It has a little error here
+	//               1:1    = pint:aint
+	//			  1:0	  = pint
+	// 			  0:1   = aint
+	if((status & 0x20) == 0x20) {	// ps
+        ret = taos_prox_threshold_set();
+    } else if((status & 0x10) == 0x10) {	// as
+        taos_als_threshold_set();
+        taos_als_get_data();
+    }
+    //up(&taos_datap->update_lock);
+    return ret;
+}
+
+static int taos_interrupts_clear(void)//iVIZM
+{
+    int ret = 0;
+    if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_CMD_SPL_FN|0x07)))) < 0) {
+        //printk(KERN_ERR "TAOS: i2c_smbus_write_byte(2) failed in taos_work_func()\n");
+        return (ret);
+    }
+    return ret;
+}
+static void taos_work_func(struct work_struct * work) //iVIZM
+{
+    wake_lock(&taos_datap->taos_wake_lock);
+    printk("^^^^^^^^^^^^^^^^^^  taos_work_func ^^^^^^^^^^^^^^^^^^^^\n");
+    taos_get_data();
+    taos_interrupts_clear();
+    wake_unlock(&taos_datap->taos_wake_lock);
+}
+
+static int taos_als_get_data(void)//iVIZM
+{
+    int ret = 0;
+    u8 reg_val;
+    int lux_val = 0;
+    if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+        //printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_data\n");
+        return (ret);
+    }
+    reg_val = i2c_smbus_read_byte(taos_datap->client);
+    if ((reg_val & (TAOS_TRITON_CNTL_ADC_ENBL | TAOS_TRITON_CNTL_PWRON)) != (TAOS_TRITON_CNTL_ADC_ENBL | TAOS_TRITON_CNTL_PWRON))
+        return -ENODATA;
+    if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_STATUS)))) < 0) {
+        //printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_data\n");
+        return (ret);
+    }
+    reg_val = i2c_smbus_read_byte(taos_datap->client);
+    if ((reg_val & TAOS_TRITON_STATUS_ADCVALID) != TAOS_TRITON_STATUS_ADCVALID)
+        return -ENODATA;
+    if ((lux_val = taos_get_lux()) < 0)
+        printk(KERN_ERR "TAOS: call to taos_get_lux() returned error %d in ioctl als_data\n", lux_val);
+    printk("********** before taos_als_get_data ********* lux_val = %d \n",lux_val);
+        input_report_abs(taos_datap->input_dev,ABS_MISC,lux_val);
+        input_sync(taos_datap->input_dev);      // zwj add test
+    return ret;
+}
+
+
+static int taos_als_threshold_set(void)//iVIZM
+{
+    int i,ret = 0;
+    u8 chdata[2];
+    u16 ch0;
+		
+	printk("kl# %s, line=%d \n", __func__, __LINE__);
+
+    for (i = 0; i < 2; i++) {
+        chdata[i] = (i2c_smbus_read_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CMD_WORD_BLK_RW | (TAOS_TRITON_ALS_CHAN0LO + i))));
+    }
+    ch0 = chdata[0] + chdata[1]*256;
+    als_threshold_hi_param = (12*ch0)/10;
+	if (als_threshold_hi_param >= 65535)
+        als_threshold_hi_param = 65535;	 
+    als_threshold_lo_param = (8*ch0)/10;
+    als_buf[0] = als_threshold_lo_param & 0x0ff;
+    als_buf[1] = als_threshold_lo_param >> 8;
+    als_buf[2] = als_threshold_hi_param & 0x0ff;
+    als_buf[3] = als_threshold_hi_param >> 8;
+
+    for( mcount=0; mcount<4; mcount++ ) { 
+        if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x04) + mcount, als_buf[mcount]))) < 0) {
+             //printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in taos als threshold set\n");
+             return (ret);
+        }
+    }
+    return ret;
+}
+
+static int taos_prox_threshold_set(void)//iVIZM
+{
+    int i,ret = 0;
+    u8 chdata[6];
+    u16 proxdata = 0;
+    u16 cleardata = 0;
+	int data = 0;
+
+   // int ch0,ch1;
+//   printk("kl# %s, line=%d \n", __func__, __LINE__);
+
+    for (i = 0; i < 6; i++) {
+        chdata[i] = (i2c_smbus_read_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CMD_WORD_BLK_RW| (TAOS_TRITON_ALS_CHAN0LO + i))));
+    }
+    cleardata = chdata[0] + chdata[1]*256;
+    proxdata = chdata[4] + chdata[5]*256;
+    printk("kl## = proxdata = %d, cleardata=%d\n",proxdata, cleardata);
+
+   //ch0= i2c_smbus_read_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | 0x18 ));
+   //ch1= i2c_smbus_read_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | 0x19 ));
+
+   //printk("================= proxdatatest = %d\n",ch1<<8 |ch0);	
+   
+    if(prox_on || (proxdata < (taos_cfgp->prox_threshold_lo ))) 
+    {
+        pro_buf[0] = 0x0;
+        pro_buf[1] = 0x0;
+        pro_buf[2] = taos_cfgp->prox_threshold_hi & 0x0ff;
+        pro_buf[3] = taos_cfgp->prox_threshold_hi >> 8;
+			data = 1;
+	printk(KERN_ERR "report pls data 1\n");
+	input_report_abs(taos_datap->input_dev,ABS_DISTANCE,data);		
+	input_sync(taos_datap->input_dev);
+    } 
+    else if(proxdata > (taos_cfgp->prox_threshold_hi) )
+       {
+        if (cleardata > ((sat_als*80)/100)){
+	    	data = 0;
+	}
+	else{
+        	pro_buf[0] = taos_cfgp->prox_threshold_lo & 0x0ff;
+        	pro_buf[1] = taos_cfgp->prox_threshold_lo >> 8;
+        	pro_buf[2] = 0xff;
+        	pro_buf[3] = 0xff;
+		data = 0;
+	}
+	    input_report_abs(taos_datap->input_dev,ABS_DISTANCE,data);
+		
+ 	    input_sync(taos_datap->input_dev);
+    }
+	
+   // printk("prox_threshold_hi=%d, prox_threshold_lo= %d\n",pro_buf[3]<<8 |pro_buf[2], pro_buf[1]<<8 |pro_buf[0]);
+	
+    for( mcount=0; mcount<4; mcount++ ) { 
+        if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x08) + mcount, pro_buf[mcount]))) < 0) {
+             printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in taos prox threshold set\n");
+             return (ret);
+        }
+    }
+	
+    prox_on = 0;
+    return ret;
+}
+
+static int taos_reg_init(struct i2c_client *clientp)
+{	
+	int ret = 0;
+	int i = 0;
+	unsigned char buf[TAOS_MAX_DEVICE_REGS];
+	char *device_name;
+	int chip_id;
+	
+	for (i = 0; i < TAOS_MAX_DEVICE_REGS; i++) {
+			if ((ret = (i2c_smbus_write_byte(clientp, (TAOS_TRITON_CMD_REG | (TAOS_TRITON_CNTRL + i))))) < 0) {
+					printk(KERN_ERR "TAOS: i2c_smbus_write_byte() to control reg failed in taos_probe()\n");
+					return(ret);
+			}
+			buf[i] = i2c_smbus_read_byte(clientp);
+	}
+	if ((ret = taos_device_name(buf, &device_name)) == 0) {
+			printk(KERN_ERR "TAOS: chip id that was read found mismatched by taos_device_name(), in taos_probe()\n");
+			return -ENODEV;
+	}
+	if (strcmp(device_name, TAOS_DEVICE_ID)) {
+			printk(KERN_ERR "TAOS: chip id that was read does not match expected id in taos_probe()\n");
+			return -ENODEV;
+	}
+	else {
+			printk(KERN_ERR "TAOS: chip id of %s that was read matches expected id in taos_probe()\n", device_name);
+			device_found = 1;
+	}
+	if ((ret = (i2c_smbus_write_byte(clientp, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+			printk(KERN_ERR "TAOS: i2c_smbus_write_byte() to control reg failed in taos_probe()\n");
+			return(ret);
+	}
+	strlcpy(clientp->name, TAOS_DEVICE_ID, I2C_NAME_SIZE);
+	strlcpy(taos_datap->taos_name, TAOS_DEVICE_ID, TAOS_ID_NAME_SIZE);
+	taos_datap->valid = 0;
+	if (!(taos_cfgp = kmalloc(sizeof(struct taos_cfg), GFP_KERNEL))) {
+			printk(KERN_ERR "TAOS: kmalloc for struct taos_cfg failed in taos_probe()\n");
+			return -ENOMEM;
+	}
+	taos_cfgp->calibrate_target = calibrate_target_param;
+	taos_cfgp->als_time = als_time_param;
+	taos_cfgp->scale_factor = scale_factor_param;
+	taos_cfgp->gain_trim = gain_trim_param;
+	taos_cfgp->filter_history = filter_history_param;
+	taos_cfgp->filter_count = filter_count_param;
+	taos_cfgp->gain = gain_param;
+	taos_cfgp->als_threshold_hi = als_threshold_hi_param;//iVIZM
+	taos_cfgp->als_threshold_lo = als_threshold_lo_param;//iVIZM
+	taos_cfgp->prox_threshold_hi = prox_threshold_hi_param;
+	taos_cfgp->prox_threshold_lo = prox_threshold_lo_param;
+	taos_cfgp->prox_int_time = prox_int_time_param;
+	taos_cfgp->prox_adc_time = prox_adc_time_param;
+	taos_cfgp->prox_wait_time = prox_wait_time_param;
+	taos_cfgp->prox_intr_filter = prox_intr_filter_param;
+	taos_cfgp->prox_config = prox_config_param;
+	taos_cfgp->prox_pulse_cnt = prox_pulse_cnt_param;
+	taos_cfgp->prox_gain = prox_gain_param;
+	sat_als = (256 - taos_cfgp->prox_int_time) << 10;
+	sat_prox = (256 - taos_cfgp->prox_adc_time) << 10;
+
+	/*dmobile ::power down for init ,Rambo liu*/
+	printk("Rambo::light sensor will pwr down \n");
+	if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x00), 0x00))) < 0) {
+			printk(KERN_ERR "TAOS:Rambo, i2c_smbus_write_byte_data failed in power down\n");
+			return (ret);
+	}
+}
+
+static void tmd2771_pls_pininit(int irq_pin)
+{
+        printk(KERN_INFO "%s [irq=%d]\n",__func__,irq_pin);
+        gpio_request(irq_pin, "tmd2771_pls irq");
+	gpio_direction_input(irq_pin);
+}
+
+
+// client probe
+static int taos_probe(struct i2c_client *clientp, const struct i2c_device_id *idp) {
+    int ret = 0;
+    int i = 0;
+    int chip_id;
+    int ch0,ch1,ch2,ch3,ch4,ch5;
+    struct regulator *reg_vdd;
+    //unsigned char buf[TAOS_MAX_DEVICE_REGS];
+    //char *device_name;
+	struct i2c_adapter *adapter = to_i2c_adapter(clientp->dev.parent);
+	struct tmd2771_pls_platform_data *pdata = clientp->dev.platform_data;
+
+   	printk("kl# tmd2771 probe!!!!line=%d\n", __LINE__);
+
+	//reg_vdd = regulator_get(NULL,REGU_NAMES_VDD28);
+	//regulator_enable(reg_vdd);
+	 
+	if (!i2c_check_functionality(clientp->adapter, I2C_FUNC_I2C)) {
+		printk("%s: functionality check failed\n", __func__);
+		ret = -ENODEV;
+		goto exit_check_functionality_failed;
+	}
+	
+	taos_datap = kmalloc(sizeof(struct taos_data), GFP_KERNEL);
+	if (!taos_datap) {
+		printk(KERN_ERR "TAOS: kmalloc for struct taos_data failed in taos_init()\n");
+		//return -ENOMEM;
+		ret = -ENOMEM;
+		goto exit_request_memory_failed;
+	}
+	memset(taos_datap, 0, sizeof(struct taos_data));
+	taos_datap->reg_vdd = reg_vdd;
+
+	// get chip id
+    chip_id = i2c_smbus_read_byte_data(clientp, (TAOS_TRITON_CMD_REG | (TAOS_TRITON_CNTRL + 0x12))); //iVIZM
+	printk(" toas1 chip_id = %d\n",chip_id);
+    if(chip_id < 0)  	{
+		ret = chip_id;
+		goto exit_request_memory_failed;
+    	}
+
+	tmd2771_pls_pininit(pdata->irq_gpio_number);
+
+
+        /*get irq*/
+        clientp->irq = gpio_to_irq(pdata->irq_gpio_number);
+
+	tmd2711_pls_irq = clientp->irq;
+
+
+    taos_datap->client = clientp;
+    i2c_set_clientdata(clientp, taos_datap);
+    INIT_WORK(&(taos_datap->work),taos_work_func);
+    mutex_init(&taos_datap->update_lock);
+
+	// input devices 
+   taos_datap->input_dev = input_allocate_device();//iVIZM
+   if (taos_datap->input_dev == NULL) {
+		ret = -ENOMEM;
+		goto exit_input_dev_allocate_failed;
+   }
+   
+   taos_datap->input_dev->name = TAOS_INPUT_NAME;
+   taos_datap->input_dev->id.bustype = BUS_I2C;
+   set_bit(EV_ABS,taos_datap->input_dev->evbit);
+   set_bit(ABS_MISC, taos_datap->input_dev->absbit);
+   set_bit(ABS_DISTANCE, taos_datap->input_dev->absbit);
+        /*for proximity*/
+        input_set_abs_params(taos_datap->input_dev, ABS_DISTANCE, 0, 1, 0, 0);
+        /*for lightsensor*/
+        input_set_abs_params(taos_datap->input_dev, ABS_MISC, 0, 100001, 0, 0);
+
+   ret = input_register_device(taos_datap->input_dev);
+	if (ret < 0)	 {
+		 printk("%s: input device regist failed\n", __func__);
+		 goto exit_input_register_failed;
+	}
+	// chip init 
+	if(taos_reg_init(clientp)<0)
+	{
+		printk("%s: device init failed\n", __func__);
+		ret=-1;
+		goto exit_device_init_failed;
+	}
+
+	// create char device
+	if ((ret = (alloc_chrdev_region(&taos_dev_number, 0, TAOS_MAX_NUM_DEVICES, TAOS_DEVICE_NAME))) < 0) {
+			printk(KERN_ERR "TAOS: alloc_chrdev_region() failed in taos_init()\n");
+			goto exit_chrdev_region_failed;
+	}
+	taos_class = class_create(THIS_MODULE, TAOS_DEVICE_NAME);
+	cdev_init(&taos_datap->cdev, &taos_fops);
+	taos_datap->cdev.owner = THIS_MODULE;
+	if ((ret = (cdev_add(&taos_datap->cdev, taos_dev_number, 1))) < 0) {
+		printk(KERN_ERR "TAOS: cdev_add() failed in taos_init()\n");
+		goto exit_chrdev_add_failed;
+	}
+	wake_lock_init(&taos_datap->taos_wake_lock, WAKE_LOCK_SUSPEND, "taos-wake-lock");
+	device_create(taos_class, NULL, MKDEV(MAJOR(taos_dev_number), 0), &taos_driver ,"taos");
+
+	
+
+	// interrupt 
+	ret = request_irq(tmd2711_pls_irq,taos_irq_handler, IRQ_TYPE_EDGE_FALLING, "taos_irq",taos_datap);//iVIZM
+	if (ret != 0) {
+		goto irq_request_err;
+	}
+	disable_irq(tmd2711_pls_irq);//iVIZM
+	for(i = 0; i < 50; i++)
+		taos_als_get_data();
+
+	printk("%s probe success!\n", __func__);
+	return (ret);
+ 
+irq_request_err:	
+	device_destroy(taos_class, MKDEV(MAJOR(taos_dev_number), 0));
+	gpio_free(pdata->irq_gpio_number);
+exit_chrdev_add_failed:
+	cdev_del(&taos_datap->cdev);
+	class_destroy(taos_class);	
+exit_chrdev_region_failed:
+	unregister_chrdev_region(taos_dev_number, TAOS_MAX_NUM_DEVICES);
+exit_device_init_failed:	
+exit_input_register_failed:	
+	input_free_device(taos_datap->input_dev);
+exit_input_dev_allocate_failed:		
+exit_device_register_failed:
+	kfree(taos_datap);
+exit_request_memory_failed:	
+exit_check_functionality_failed:
+	//wake_lock_destroy(&pls_delayed_work_wake_lock);
+	printk("kl %s: Probe Fail!\n",__func__);
+	return ret;
+}
+# if 0
+//resume  iVIZM
+static int taos_resume(struct i2c_client *client) {
+    u8 reg_val = 0,reg_cntrl = 0;
+    int ret = -1;
+    if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+        printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in taos_resume\n");
+        return (ret);
+    }
+    reg_val = i2c_smbus_read_byte(taos_datap->client);
+    if ( taos_datap->working == 1) {
+        taos_datap->working = 0;
+        reg_cntrl = reg_val | TAOS_TRITON_CNTL_PWRON;
+        if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL), reg_cntrl))) < 0) {
+            printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_off\n");
+            return (ret);
+        }
+    }
+    enable_irq(tmd2711_pls_irq);
+    return ret;
+}
+
+//suspend  iVIZM
+static int taos_suspend(struct i2c_client *client, pm_message_t mesg) {
+    u8 reg_val = 0,reg_cntrl = 0;
+    int ret = -1;
+    disable_irq(tmd2711_pls_irq);
+    if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+        printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in taos_resume\n");
+        return (ret);
+    }
+    reg_val = i2c_smbus_read_byte(taos_datap->client);
+    if (reg_val & TAOS_TRITON_CNTL_PWRON) {
+        taos_datap->working = 1;
+        reg_cntrl = reg_val & (~TAOS_TRITON_CNTL_PWRON);
+        if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL), reg_cntrl))) < 0) {
+            printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in taos_suspend\n");
+            return (ret);
+        }
+    }
+    return ret;
+}
+#endif 
+// client remove
+static int __devexit taos_remove(struct i2c_client *client) {
+    int ret = 0;
+		
+#if 1 // zwj mv from taos_exit		
+    unregister_chrdev_region(taos_dev_number, TAOS_MAX_NUM_DEVICES);
+    device_destroy(taos_class, MKDEV(MAJOR(taos_dev_number), 0));
+    cdev_del(&taos_datap->cdev);
+    class_destroy(taos_class);
+    disable_irq(tmd2711_pls_irq);//iVIZM
+    //if (taos_wq)
+    //    destroy_workqueue(taos_wq);//iVIZM
+    kfree(taos_datap);
+#endif
+
+    return (ret);
+}
+
+// open
+static int taos_open(struct inode *inode, struct file *file) {
+    struct taos_data *taos_datap;
+    int ret = 0;
+
+    device_released = 0;
+    taos_datap = container_of(inode->i_cdev, struct taos_data, cdev);
+    if (strcmp(taos_datap->taos_name, TAOS_DEVICE_ID) != 0) {
+        printk(KERN_ERR "TAOS: device name incorrect during taos_open(), get %s\n", taos_datap->taos_name);
+        ret = -ENODEV;
+    }
+    
+    enable_irq(tmd2711_pls_irq);//iVIZM
+    return (ret);
+}
+
+// release
+static int taos_release(struct inode *inode, struct file *file) {
+    struct taos_data *taos_datap;
+    int ret = 0;
+
+    device_released = 1;
+    prox_on = 0;
+    prox_history_hi = 0;
+    prox_history_lo = 0;
+    taos_datap = container_of(inode->i_cdev, struct taos_data, cdev);
+    if (strcmp(taos_datap->taos_name, TAOS_DEVICE_ID) != 0) {
+        printk(KERN_ERR "TAOS: device name incorrect during taos_release(), get %s\n", taos_datap->taos_name);
+        ret = -ENODEV;
+    }
+    disable_irq(tmd2711_pls_irq);
+    return (ret);
+}
+
+static int taos_sensors_als_on(void) {
+    int  ret = 0, i = 0;
+    u8 itime = 0, reg_val = 0, reg_cntrl = 0;
+    //int lux_val = 0, ret = 0, i = 0, tmp = 0;
+    
+//		printk("kl# %s, line=%d \n", __func__, __LINE__);
+
+            for (i = 0; i < TAOS_FILTER_DEPTH; i++)
+                lux_history[i] = -ENODATA;
+            //taos_als_threshold_set();//iVIZM
+            if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_CMD_SPL_FN|TAOS_TRITON_CMD_ALS_INTCLR)))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_on\n");
+                return (ret);
+            }
+            itime = (((taos_cfgp->als_time/50) * 18) - 1);
+            itime = (~itime);
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_ALS_TIME), itime))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_on\n");
+                return (ret);
+            }
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_INTERRUPT), taos_cfgp->prox_intr_filter))) < 0) {//golden
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_on\n");
+                return (ret);
+            }
+            if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_GAIN)))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_on\n");
+                return (ret);
+            }
+            reg_val = i2c_smbus_read_byte(taos_datap->client);
+            reg_val = reg_val & 0xFC;
+            reg_val = reg_val | (taos_cfgp->gain & 0x03);
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_GAIN), reg_val))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_on\n");
+                return (ret);
+            }
+            //if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+            //    printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_calibrate\n");
+            //    return (ret);
+            //}
+            //reg_val = i2c_smbus_read_byte(taos_datap->client);
+            //reg_cntrl = reg_val | (TAOS_TRITON_CNTL_ADC_ENBL | TAOS_TRITON_CNTL_PWRON | TAOS_TRITON_CNTL_ALS_INT_ENBL);
+            reg_cntrl = (TAOS_TRITON_CNTL_ADC_ENBL | TAOS_TRITON_CNTL_PWRON | TAOS_TRITON_CNTL_ALS_INT_ENBL);
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL), reg_cntrl))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_on\n");
+                return (ret);
+            }
+
+	    mdelay(100);
+		
+            taos_als_threshold_set();//iVIZM
+	    return ret;
+}	
+
+// ioctls
+//static int taos_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) {
+static int taos_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
+    int prox_sum = 0, prox_mean = 0, prox_max = 0;
+    int lux_val = 0, ret = 0, i = 0, tmp = 0;
+    u16 gain_trim_val = 0;
+    u8 reg_val = 0, reg_cntrl = 0;
+    int ret_check=0;
+    int ret_m=0;
+    u8 reg_val_temp=0;
+
+    printk("k#### %s, line=%d \n", __func__, __LINE__);
+		
+    switch (cmd) {
+    case TAOS_IOCTL_SENSOR_CHECK:
+        reg_val_temp=0;
+        if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+            printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_CHECK failed\n");
+            return (ret);
+        }
+        reg_val_temp = i2c_smbus_read_byte(taos_datap->client);
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_CHECK,prox_adc_time,%d~\n",reg_val_temp);
+        if ((reg_val_temp & 0xFF) == 0xF)
+            return -ENODATA;
+
+        break;
+
+    case TAOS_IOCTL_SENSOR_CONFIG:
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_CONFIG,test01~\n");
+        ret = copy_from_user(taos_cfgp, (struct taos_cfg *)arg, sizeof(struct taos_cfg));
+        if (ret) {
+            printk(KERN_ERR "TAOS: copy_from_user failed in ioctl config_set\n");
+            return -ENODATA;
+        }
+
+        break;
+
+     case TAOS_IOCTL_SENSOR_ON:
+        ret=0;
+        reg_val=0;
+        ret_m=0;
+
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test01~\n");
+
+#if 0
+        /*decide the numbers of sensors*/
+        ret_m=taos_sensor_mark();
+        if(ret_m <0){
+            printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, error~~\n");
+            return -1;
+        }
+        if(ret_m ==0){
+            printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, num >0 ~~\n");
+            return 1;
+        }
+#endif
+#if 1
+        /*Register init and turn off */
+        for (i = 0; i < TAOS_FILTER_DEPTH; i++){
+            /*Rambo ??*/
+            lux_history[i] = -ENODATA;
+        }
+#endif
+
+#if 0
+        for (i = 0; i < sizeof(taos_triton_reg_init); i++){
+            if(i !=11){
+                if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|(TAOS_TRITON_CNTRL +i)), taos_triton_reg_init[i]))) < 0) {
+                    printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_on\n");
+                    return (ret);
+                }
+            }
+        }
+#endif
+        /*ALS interrupt clear*/
+        if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_CMD_SPL_FN|TAOS_TRITON_CMD_ALS_INTCLR)))) < 0) {
+            printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_on\n");
+            return (ret);
+        }
+
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test02~\n");
+        /*Register setting*/
+#if 0
+        if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x00), 0x00))) < 0) {
+            printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+            return (ret);
+        }
+#endif
+
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test03,prox_int_time,%d~\n",taos_cfgp->prox_int_time);
+        if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_ALS_TIME), taos_cfgp->prox_int_time))) < 0) {
+            printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+            return (ret);
+        }
+
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test04,prox_adc_time,%d~\n",taos_cfgp->prox_adc_time);
+        if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_PRX_TIME), taos_cfgp->prox_adc_time))) < 0) {
+            printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+            return (ret);
+        }
+
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test05,prox_wait_time,%d~\n", taos_cfgp->prox_wait_time);
+        if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_WAIT_TIME), taos_cfgp->prox_wait_time))) < 0) {
+            printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+            return (ret);
+        }
+
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test05-1,prox_intr_filter,%d~\n", taos_cfgp->prox_intr_filter);
+        if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_INTERRUPT), taos_cfgp->prox_intr_filter))) < 0) {
+            printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+            return (ret);
+        }
+
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test06,prox_config,%d~\n",taos_cfgp->prox_config);
+        if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_PRX_CFG), taos_cfgp->prox_config))) < 0) {
+            printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+            return (ret);
+        }
+
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test06,prox_pulse_cnt,%d~\n",taos_cfgp->prox_pulse_cnt);
+        if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_PRX_COUNT), taos_cfgp->prox_pulse_cnt))) < 0) {
+            printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+            return (ret);
+        }
+        /*gain*/
+#if 0
+        reg_val_temp=0;
+        if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_GAIN)))) < 0) {
+            printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON failed in ioctl als_calibrate\n");
+            return (ret);
+        }
+        reg_val_temp = i2c_smbus_read_byte(taos_datap->client);
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test07-1,gain_init&0xC,%d~\n",reg_val_temp&0xC);
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test07-2,prox_gain&0xFC,%d~\n",(taos_cfgp->prox_gain&0xFC));
+        reg_val_temp=(taos_cfgp->prox_gain&0xFC)|(reg_val_temp&0xC);
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test07,%d~\n",reg_val_temp);
+#endif
+        if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_GAIN), taos_cfgp->prox_gain))) < 0) {
+            printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+            return (ret);
+        }
+
+        /*turn on*/
+#if 0
+        reg_val_temp=0;
+        if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+            printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON failed in ioctl als_calibrate\n");
+            return (ret);
+        }
+        reg_val_temp = i2c_smbus_read_byte(taos_datap->client);
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test08-1,%d~\n",reg_val_temp);
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test08-2,%d~\n",(reg_val_temp&0x40));
+        reg_val_temp=(0xF&0x3F)|(reg_val_temp&0x40);
+
+        printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, test08,%d~\n",reg_val_temp);
+#endif
+        if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_CNTRL), 0xF))) < 0) {
+            printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+            return (ret);
+        }
+
+        break;
+
+
+        case TAOS_IOCTL_SENSOR_OFF:
+            ret=0;
+            reg_val=0;
+            ret_check=0;
+            ret_m=0;
+
+#if 0
+            /*chech the num of used sensor*/
+            ret_check=taos_sensor_check();
+
+            printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_OFF,test01~\n");
+            if(ret_check <0){
+                printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_OFF, error~~\n");
+                return -1;
+            }
+            if(ret_check ==0){
+                printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_ON, num >1 ~~\n");
+                return 1;
+            }
+#endif
+            /*turn off*/
+            printk(KERN_ERR "TAOS: TAOS_IOCTL_SENSOR_OFF,test02~\n");
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x00), 0x00))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_off\n");
+                return (ret);
+            }
+
+             break;
+        case TAOS_IOCTL_ALS_ON:
+            printk("####################################\n");
+            printk("######## TAOS IOCTL ALS ON #########\n");
+            printk("####################################\n");
+
+	
+ 	    printk("taos==== TAOS IOCTL ALS ON ===00==ALS_ON=%d    prox_on=%d\n",ALS_ON,prox_on);
+		
+            if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_calibrate\n");
+                return (ret);
+            }
+            reg_val = i2c_smbus_read_byte(taos_datap->client);
+			
+			if ((reg_val & TAOS_TRITON_CNTL_PROX_DET_ENBL) == 0x0) {
+		printk("taos==== TAOS_IOCTL_ALS_ON ===TAOS_IOCTL_PROX_OFF\n");
+                taos_sensors_als_on();
+			}	
+
+       /*     for (i = 0; i < TAOS_FILTER_DEPTH; i++)
+                lux_history[i] = -ENODATA;
+            //taos_als_threshold_set();//iVIZM
+            if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_CMD_SPL_FN|TAOS_TRITON_CMD_ALS_INTCLR)))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_on\n");
+                return (ret);
+            }
+            itime = (((taos_cfgp->als_time/50) * 18) - 1);
+            itime = (~itime);
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_ALS_TIME), itime))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_on\n");
+                return (ret);
+            }
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|TAOS_TRITON_INTERRUPT), taos_cfgp->prox_intr_filter))) < 0) {//golden
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_on\n");
+                return (ret);
+            }
+            if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_GAIN)))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_on\n");
+                return (ret);
+            }
+            reg_val = i2c_smbus_read_byte(taos_datap->client);
+            reg_val = reg_val & 0xFC;
+            reg_val = reg_val | (taos_cfgp->gain & 0x03);
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_GAIN), reg_val))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_on\n");
+                return (ret);
+            }
+            if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_calibrate\n");
+                return (ret);
+            }
+            reg_val = i2c_smbus_read_byte(taos_datap->client);
+            reg_cntrl = reg_val | (TAOS_TRITON_CNTL_ADC_ENBL | TAOS_TRITON_CNTL_PWRON | TAOS_TRITON_CNTL_ALS_INT_ENBL);
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL), reg_cntrl))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_on\n");
+                return (ret);
+            }
+            taos_als_threshold_set();//iVIZM
+			*/
+			ALS_ON = 1;
+	    printk("taos==== TAOS IOCTL ALS ON ===11==ALS_ON=%d    prox_on=%d\n",ALS_ON,prox_on);
+            return (ret);
+            break;
+        case TAOS_IOCTL_ALS_OFF:
+            printk("#####################################\n");
+            printk("######## TAOS IOCTL ALS OFF #########\n");
+            printk("#####################################\n");
+
+	     printk("taos==== TAOS IOCTL ALS OFF ===00==ALS_ON=%d    prox_on=%d\n",ALS_ON,prox_on);
+			
+            for (i = 0; i < TAOS_FILTER_DEPTH; i++)
+                lux_history[i] = -ENODATA;
+            if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_calibrate\n");
+                return (ret);
+            }
+            reg_val = i2c_smbus_read_byte(taos_datap->client);
+            if ((reg_val & TAOS_TRITON_CNTL_PROX_DET_ENBL) == 0x0) {
+				
+		printk("taos==== TAOS_IOCTL_ALS_OFF ===TAOS_IOCTL_PROX_OFF\n");
+		
+               if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL), 0x00))) < 0) {
+                   printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_off\n");
+                   return (ret);
+			   }
+			   cancel_work_sync(&taos_datap->work);//golden
+          //      reg_cntrl = reg_val & (~TAOS_TRITON_CNTL_ALS_INT_ENBL);
+		//	} else {
+        //        reg_cntrl = reg_val & (~(TAOS_TRITON_CNTL_ADC_ENBL | TAOS_TRITON_CNTL_PWRON | TAOS_TRITON_CNTL_ALS_INT_ENBL));
+        //    printk("===========cancel_work_sync======als====\n");
+		//		cancel_work_sync(&taos_datap->work);//golden
+		//	}
+        //    if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL), reg_cntrl))) < 0) {
+        //        printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_off\n");
+        //        return (ret);
+            }
+			ALS_ON = 0;
+		printk("taos==== TAOS IOCTL ALS OFF ===11==ALS_ON=%d    prox_on=%d\n",ALS_ON,prox_on);
+            return (ret);
+            break;
+        case TAOS_IOCTL_ALS_DATA:
+            if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_data\n");
+                return (ret);
+            }
+            reg_val = i2c_smbus_read_byte(taos_datap->client);
+            if ((reg_val & (TAOS_TRITON_CNTL_ADC_ENBL | TAOS_TRITON_CNTL_PWRON)) != (TAOS_TRITON_CNTL_ADC_ENBL | TAOS_TRITON_CNTL_PWRON))
+                return -ENODATA;
+            if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_STATUS)))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_data\n");
+                return (ret);
+            }
+            reg_val = i2c_smbus_read_byte(taos_datap->client);
+            if ((reg_val & TAOS_TRITON_STATUS_ADCVALID) != TAOS_TRITON_STATUS_ADCVALID)
+                return -ENODATA;
+            if ((lux_val = taos_get_lux()) < 0)
+                printk(KERN_ERR "TAOS: call to taos_get_lux() returned error %d in ioctl als_data\n", lux_val);
+            //lux_val = taos_lux_filter(lux_val);
+            return (lux_val);
+            break;
+        case TAOS_IOCTL_ALS_CALIBRATE:
+            if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_calibrate\n");
+                return (ret);
+            }
+            reg_val = i2c_smbus_read_byte(taos_datap->client);
+            if ((reg_val & 0x07) != 0x07)
+                return -ENODATA;
+            if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_STATUS)))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_calibrate\n");
+
+                return (ret);
+            }
+            reg_val = i2c_smbus_read_byte(taos_datap->client);
+            if ((reg_val & 0x01) != 0x01)
+                return -ENODATA;
+            if ((lux_val = taos_get_lux()) < 0) {
+                printk(KERN_ERR "TAOS: call to lux_val() returned error %d in ioctl als_data\n", lux_val);
+                return (lux_val);
+            }
+            gain_trim_val = (u16)(((taos_cfgp->calibrate_target) * 512)/lux_val);
+            taos_cfgp->gain_trim = (int)gain_trim_val;
+            return ((int)gain_trim_val);
+            break;
+        case TAOS_IOCTL_CONFIG_GET:
+            ret = copy_to_user((struct taos_cfg *)arg, taos_cfgp, sizeof(struct taos_cfg));
+            if (ret) {
+                printk(KERN_ERR "TAOS: copy_to_user failed in ioctl config_get\n");
+                return -ENODATA;
+            }
+            return (ret);
+            break;
+        case TAOS_IOCTL_CONFIG_SET:
+            printk("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
+            printk("^^^^^^^^^ TAOS INCTL CONFIG SET  ^^^^^^^\n");
+            printk("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
+            ret = copy_from_user(taos_cfgp, (struct taos_cfg *)arg, sizeof(struct taos_cfg));
+            if (ret) {
+                printk(KERN_ERR "TAOS: copy_from_user failed in ioctl config_set\n");
+                return -ENODATA;
+            }
+            if(taos_cfgp->als_time < 50)
+                taos_cfgp->als_time = 50;
+            if(taos_cfgp->als_time > 650)
+                taos_cfgp->als_time = 650;
+            tmp = (taos_cfgp->als_time + 25)/50;
+            taos_cfgp->als_time = tmp*50;
+            sat_als = (256 - taos_cfgp->prox_int_time) << 10;
+            sat_prox = (256 - taos_cfgp->prox_adc_time) << 10;
+            break;
+        case TAOS_IOCTL_PROX_ON:
+            printk("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
+            printk("^^^^^^^^^ TAOS IOCTL PROX ON  ^^^^^^^\n");
+            printk("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
+
+           printk("taos==== TAOS_IOCTL_PROX_ON ===00==ALS_ON=%d    prox_on=%d\n",ALS_ON,prox_on);
+			
+            prox_on = 1;
+
+
+             reg_cntrl = TAOS_TRITON_CNTL_PROX_DET_ENBL | TAOS_TRITON_CNTL_PWRON | TAOS_TRITON_CNTL_PROX_INT_ENBL | 
+				                                      TAOS_TRITON_CNTL_ADC_ENBL | TAOS_TRITON_CNTL_WAIT_TMR_ENBL  ;
+
+	    printk("taos==== TAOS_IOCTL_PROX_ON ===00==reg_cntrl=%x\n",reg_cntrl);		 
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL), reg_cntrl))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x01), taos_cfgp->prox_int_time))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x02), taos_cfgp->prox_adc_time))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x03), taos_cfgp->prox_wait_time))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x0C), taos_cfgp->prox_intr_filter))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x0D), taos_cfgp->prox_config))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x0E), taos_cfgp->prox_pulse_cnt))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x0F), taos_cfgp->prox_gain))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+            //if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+            //    printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl prox_on\n");
+            //    return (ret);
+            //}
+            //reg_val = i2c_smbus_read_byte(taos_datap->client);
+            //reg_cntrl = reg_val | (TAOS_TRITON_CNTL_PROX_DET_ENBL | TAOS_TRITON_CNTL_PWRON | TAOS_TRITON_CNTL_PROX_INT_ENBL | TAOS_TRITON_CNTL_ADC_ENBL);
+
+	   mdelay(100);		
+				
+            taos_prox_threshold_set();//iVIZM
+            
+             printk("taos==== TAOS_IOCTL_PROX_ON ===11==ALS_ON=%d    prox_on=%d\n",ALS_ON,prox_on);
+            break;
+        case TAOS_IOCTL_PROX_OFF:
+            printk("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
+            printk("^^^^^^^^^ TAOS IOCTL PROX OFF  ^^^^^^^\n");
+            printk("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
+
+
+	    printk("taos==== TAOS_IOCTL_PROX_OFF ===00==ALS_ON=%d    prox_on=%d\n",ALS_ON,prox_on);	
+            //if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+            //    printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl als_calibrate\n");
+            //    return (ret);
+            //}
+            //reg_val = i2c_smbus_read_byte(taos_datap->client);
+            //if (reg_val & TAOS_TRITON_CNTL_ALS_INT_ENBL) {
+            //    reg_cntrl = reg_val & (~(TAOS_TRITON_CNTL_PROX_DET_ENBL | TAOS_TRITON_CNTL_PROX_INT_ENBL));
+			//} else {
+            //    reg_cntrl = reg_val & (~(TAOS_TRITON_CNTL_PROX_DET_ENBL | TAOS_TRITON_CNTL_PWRON | TAOS_TRITON_CNTL_PROX_INT_ENBL));
+            //reg_cntrl = reg_val & (~(TAOS_TRITON_CNTL_PROX_DET_ENBL | TAOS_TRITON_CNTL_PWRON | TAOS_TRITON_CNTL_PROX_INT_ENBL));
+           // printk("===========cancel_work_sync=====prox=====\n");
+			//	cancel_work_sync(&taos_datap->work);//golden
+			//}
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL), 0x00))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_off\n");
+                return (ret);
+            }
+			if (ALS_ON == 1) {
+                taos_sensors_als_on();
+			} else {
+				cancel_work_sync(&taos_datap->work);//golden
+			}
+            prox_on = 0;
+	   printk("taos==== TAOS_IOCTL_PROX_OFF ===11==ALS_ON=%d    prox_on=%d\n",ALS_ON,prox_on);
+            break;
+        case TAOS_IOCTL_PROX_DATA:
+            //Rambo
+#if 1
+            if ((ret = taos_prox_poll(prox_cur_infop)) < 0) {
+                printk(KERN_ERR "TAOS: call to prox_poll failed in taos_prox_poll_timer_func()\n");
+                return ret;
+            }
+#endif
+            ret = copy_to_user((struct taos_prox_info *)arg, prox_cur_infop, sizeof(struct taos_prox_info));
+            if (ret) {
+                printk(KERN_ERR "TAOS: copy_to_user failed in ioctl prox_data\n");
+                return -ENODATA;
+            }
+            return (ret);
+            break;
+        case TAOS_IOCTL_PROX_EVENT:
+            if ((ret = taos_prox_poll(prox_cur_infop)) < 0) {
+                printk(KERN_ERR "TAOS: call to prox_poll failed in taos_prox_poll_timer_func()\n");
+                return ret;
+            }
+
+            return (prox_cur_infop->prox_event);
+            break;
+        case TAOS_IOCTL_PROX_CALIBRATE:
+            //if (prox_on) golden
+            //del_timer(&prox_poll_timer);
+            //else {
+            //printk(KERN_ERR "TAOS: ioctl prox_calibrate was called before ioctl prox_on was called\n");
+            //return -EPERM;
+            //}
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x01), taos_cfgp->prox_int_time))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x02), taos_cfgp->prox_adc_time))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x03), taos_cfgp->prox_wait_time))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x0D), taos_cfgp->prox_config))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x0E), taos_cfgp->prox_pulse_cnt))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|0x0F), taos_cfgp->prox_gain))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+            //if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL)))) < 0) {
+            //    printk(KERN_ERR "TAOS: i2c_smbus_write_byte failed in ioctl prox_on\n");
+            //    return (ret);
+            //}
+            //reg_val = i2c_smbus_read_byte(taos_datap->client);
+            reg_cntrl = reg_val | (TAOS_TRITON_CNTL_PROX_DET_ENBL | TAOS_TRITON_CNTL_PWRON | TAOS_TRITON_CNTL_ADC_ENBL);
+            if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CNTRL), reg_cntrl))) < 0) {
+                printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl prox_on\n");
+                return (ret);
+            }
+
+            prox_sum = 0;
+            prox_max = 0;
+            for (i = 0; i < 20; i++) {
+                if ((ret = taos_prox_poll(&prox_cal_info[i])) < 0) {
+                    printk(KERN_ERR "TAOS: call to prox_poll failed in ioctl prox_calibrate\n");
+                    return (ret);
+                }
+                prox_sum += prox_cal_info[i].prox_data;
+                if (prox_cal_info[i].prox_data > prox_max)
+                    prox_max = prox_cal_info[i].prox_data;
+                mdelay(100);
+            }
+            prox_mean = prox_sum/20;
+            taos_cfgp->prox_threshold_hi = ((((prox_max - prox_mean) * 200) + 50)/100) + prox_mean;
+            taos_cfgp->prox_threshold_lo = ((((prox_max - prox_mean) * 170) + 50)/100) + prox_mean;
+             printk("TAOS:------------ taos_cfgp->prox_threshold_hi = %d\n",taos_cfgp->prox_threshold_hi );
+             printk("TAOS:------------ taos_cfgp->prox_threshold_lo = %d\n",taos_cfgp->prox_threshold_lo );
+           // if (taos_cfgp->prox_threshold_lo < ((sat_prox*12)/100)) {
+           //     taos_cfgp->prox_threshold_lo = ((sat_prox*12)/100);
+           //     taos_cfgp->prox_threshold_hi = ((sat_prox*15)/100);
+           // }
+            for (i = 0; i < sizeof(taos_triton_reg_init); i++){
+                if(i !=11){
+                    if ((ret = (i2c_smbus_write_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG|(TAOS_TRITON_CNTRL +i)), taos_triton_reg_init[i]))) < 0) {
+                        printk(KERN_ERR "TAOS: i2c_smbus_write_byte_data failed in ioctl als_on\n");
+                        return (ret);
+                    }
+                 }
+             }
+
+            //taos_prox_poll_timer_start();//Rambo
+            break;
+        default:
+            return -EINVAL;
+            break;
+    }
+    return (ret);
+}
+
+// read/calculate lux value
+static int taos_get_lux(void) {
+    u16 raw_clear = 0, raw_ir = 0, raw_lux = 0;
+    u32 lux = 0;
+    u32 ratio = 0;
+    u8 dev_gain = 0;
+    u16 Tint = 0;
+    struct lux_data *p;
+    int ret = 0;
+    u8 chdata[4];
+    int tmp = 0, i = 0;
+
+    for (i = 0; i < 4; i++) {
+        if ((ret = (i2c_smbus_write_byte(taos_datap->client, (TAOS_TRITON_CMD_REG | (TAOS_TRITON_ALS_CHAN0LO + i))))) < 0) {
+            printk(KERN_ERR "TAOS: i2c_smbus_write_byte() to chan0/1/lo/hi reg failed in taos_get_lux()\n");
+            return (ret);
+        }
+        chdata[i] = i2c_smbus_read_byte(taos_datap->client);
+        printk("ch(%d),data=%d\n",i,chdata[i]);
+    }
+    printk("ch0=%d\n",chdata[0]+chdata[1]*256);
+    printk("ch1=%d\n",chdata[2]+chdata[3]*256);
+
+    tmp = (taos_cfgp->als_time + 25)/50;            //if atime =100  tmp = (atime+25)/50=2.5   tine = 2.7*(256-atime)=  412.5
+    TritonTime.numerator = 1;
+    TritonTime.denominator = tmp;
+
+    tmp = 300 * taos_cfgp->als_time;               //tmp = 300*atime  400
+    if(tmp > 65535)
+        tmp = 65535;
+    TritonTime.saturation = tmp;
+    raw_clear = chdata[1];
+    raw_clear <<= 8;
+    raw_clear |= chdata[0];
+    raw_ir    = chdata[3];
+    raw_ir    <<= 8;
+    raw_ir    |= chdata[2];
+
+    raw_clear *= (taos_cfgp->scale_factor *11 );
+    raw_ir *= (taos_cfgp->scale_factor *3 );
+
+    if(raw_ir > raw_clear) {
+        raw_lux = raw_ir;
+        raw_ir = raw_clear;
+        raw_clear = raw_lux;
+    }
+    dev_gain = taos_triton_gain_table[taos_cfgp->gain & 0x3];
+    if(raw_clear >= lux_timep->saturation)
+        return(TAOS_MAX_LUX);
+    if(raw_ir >= lux_timep->saturation)
+        return(TAOS_MAX_LUX);
+    if(raw_clear == 0)
+        return(0);
+    if(dev_gain == 0 || dev_gain > 127) {
+        printk(KERN_ERR "TAOS: dev_gain = 0 or > 127 in taos_get_lux()\n");
+        return -1;
+    }
+    if(lux_timep->denominator == 0) {
+        printk(KERN_ERR "TAOS: lux_timep->denominator = 0 in taos_get_lux()\n");
+        return -1;
+    }
+    ratio = (raw_ir<<15)/raw_clear;
+    for (p = lux_tablep; p->ratio && p->ratio < ratio; p++);
+    if(!p->ratio) {//iVIZM
+        if(lux_history[0] < 0)
+            return 0;
+        else
+            return lux_history[0];
+    }
+    Tint = taos_cfgp->als_time;
+    raw_clear = ((raw_clear*400 + (dev_gain>>1))/dev_gain + (Tint>>1))/Tint;
+    raw_ir = ((raw_ir*400 +(dev_gain>>1))/dev_gain + (Tint>>1))/Tint;
+    lux = ((raw_clear*(p->clear)) - (raw_ir*(p->ir)));
+    lux = (lux + 32768)/65536;
+    if(lux > TAOS_MAX_LUX) {
+        lux = TAOS_MAX_LUX;
+    }
+    //return(lux)*taos_cfgp->filter_count;
+    return(lux);
+}
+
+/*static int taos_lux_filter(int lux)
+{
+    static u8 middle[] = {1,0,2,0,0,2,0,1};
+    int index;
+
+    lux_history[2] = lux_history[1];
+    lux_history[1] = lux_history[0];
+    lux_history[0] = lux;
+
+    if(lux_history[2] < 0) { //iVIZM
+        if(lux_history[1] > 0)
+            return lux_history[1];       
+        else 
+            return lux_history[0];
+    }
+    index = 0;
+    if( lux_history[0] > lux_history[1] ) 
+        index += 4;
+    if( lux_history[1] > lux_history[2] ) 
+        index += 2;
+    if( lux_history[0] > lux_history[2] )
+        index++;
+    return(lux_history[middle[index]]);
+}*/
+
+
+// verify device
+static int taos_device_name(unsigned char *bufp, char **device_name) {
+    if( (bufp[0x12]&0x00)!=0x00)
+        return(0);
+    //if(bufp[0x10]|bufp[0x1a]|bufp[0x1b]|bufp[0x1c]|bufp[0x1d]|bufp[0x1e])
+     //   return(0);
+    if(bufp[0x13]&0x0c)
+        return(0);
+    *device_name="tritonFN";
+    return(1);
+}
+
+// proximity poll
+static int taos_prox_poll(struct taos_prox_info *prxp) {
+    //static int event = 0;
+    //u16 status = 0;
+    int i = 0, ret = 0; //wait_count = 0;
+    u8 chdata[6];
+
+    for (i = 0; i < 6; i++) {
+        chdata[i] = (i2c_smbus_read_byte_data(taos_datap->client, (TAOS_TRITON_CMD_REG | TAOS_TRITON_CMD_AUTO | (TAOS_TRITON_ALS_CHAN0LO + i))));
+    }
+    prxp->prox_clear = chdata[1];
+    prxp->prox_clear <<= 8;
+    prxp->prox_clear |= chdata[0];
+    if (prxp->prox_clear > ((sat_als*80)/100))
+        return -ENODATA;
+    prxp->prox_data = chdata[5];
+    prxp->prox_data <<= 8;
+    prxp->prox_data |= chdata[4];
+
+    return (ret);
+}
+
+// prox poll timer function
+static void taos_prox_poll_timer_func(unsigned long param) {
+    int ret = 0;
+
+    if (!device_released) {
+        if ((ret = taos_prox_poll(prox_cur_infop)) < 0) {
+            printk(KERN_ERR "TAOS: call to prox_poll failed in taos_prox_poll_timer_func()\n");
+            return;
+        }
+        taos_prox_poll_timer_start();
+    }
+    return;
+}
+
+// start prox poll timer
+static void taos_prox_poll_timer_start(void) {
+    init_timer(&prox_poll_timer);
+    prox_poll_timer.expires = jiffies + (HZ/10);
+    prox_poll_timer.function = taos_prox_poll_timer_func;
+    add_timer(&prox_poll_timer);
+    return;
+}
+
+// driver init
+static int __init taos_init(void) {
+    int ret = 0, i = 0, k = 0;
+    //struct i2c_adapter *my_adap;
+ 
+    //tmd2711_pls_config_pins();
+    //LDO_TurnOnLDO(LDO_LDO_VDD28);
+    //printk(KERN_ERR "TAOS:init()\n");
+
+    if ((ret = (i2c_add_driver(&taos_driver))) < 0) {
+        printk(KERN_ERR "TAOS: i2c_add_driver() failed in taos_init()\n");
+        return (ret);
+    }
+    //printk(KERN_ERR "TAOS:end(ret [%d])\n ",ret);    
+    return (ret);
+}
+
+// driver exit
+static void __exit taos_exit(void) {
+    i2c_del_driver(&taos_driver);
+}
+
+MODULE_AUTHOR("John Koshi - Surya Software");
+MODULE_DESCRIPTION("TAOS ambient light and proximity sensor driver");
+MODULE_LICENSE("GPL");
+
+module_init(taos_init);
+module_exit(taos_exit);
+
diff --git a/drivers/input/misc/twl4030-pwrbutton.c b/drivers/input/misc/twl4030-pwrbutton.c
new file mode 100644
index 00000000..b9a05fda
--- /dev/null
+++ b/drivers/input/misc/twl4030-pwrbutton.c
@@ -0,0 +1,125 @@
+/**
+ * twl4030-pwrbutton.c - TWL4030 Power Button Input Driver
+ *
+ * Copyright (C) 2008-2009 Nokia Corporation
+ *
+ * Written by Peter De Schrijver <peter.de-schrijver@nokia.com>
+ * Several fixes by Felipe Balbi <felipe.balbi@nokia.com>
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License. See the file "COPYING" in the main directory of this
+ * archive for more details.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/i2c/twl.h>
+
+#define PWR_PWRON_IRQ (1 << 0)
+
+#define STS_HW_CONDITIONS 0xf
+
+static irqreturn_t powerbutton_irq(int irq, void *_pwr)
+{
+	struct input_dev *pwr = _pwr;
+	int err;
+	u8 value;
+
+	err = twl_i2c_read_u8(TWL_MODULE_PM_MASTER, &value, STS_HW_CONDITIONS);
+	if (!err)  {
+		pm_wakeup_event(pwr->dev.parent, 0);
+		input_report_key(pwr, KEY_POWER, value & PWR_PWRON_IRQ);
+		input_sync(pwr);
+	} else {
+		dev_err(pwr->dev.parent, "twl4030: i2c error %d while reading"
+			" TWL4030 PM_MASTER STS_HW_CONDITIONS register\n", err);
+	}
+
+	return IRQ_HANDLED;
+}
+
+static int __init twl4030_pwrbutton_probe(struct platform_device *pdev)
+{
+	struct input_dev *pwr;
+	int irq = platform_get_irq(pdev, 0);
+	int err;
+
+	pwr = input_allocate_device();
+	if (!pwr) {
+		dev_dbg(&pdev->dev, "Can't allocate power button\n");
+		return -ENOMEM;
+	}
+
+	pwr->evbit[0] = BIT_MASK(EV_KEY);
+	pwr->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
+	pwr->name = "twl4030_pwrbutton";
+	pwr->phys = "twl4030_pwrbutton/input0";
+	pwr->dev.parent = &pdev->dev;
+
+	err = request_threaded_irq(irq, NULL, powerbutton_irq,
+			IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
+			"twl4030_pwrbutton", pwr);
+	if (err < 0) {
+		dev_dbg(&pdev->dev, "Can't get IRQ for pwrbutton: %d\n", err);
+		goto free_input_dev;
+	}
+
+	err = input_register_device(pwr);
+	if (err) {
+		dev_dbg(&pdev->dev, "Can't register power button: %d\n", err);
+		goto free_irq;
+	}
+
+	platform_set_drvdata(pdev, pwr);
+
+	return 0;
+
+free_irq:
+	free_irq(irq, pwr);
+free_input_dev:
+	input_free_device(pwr);
+	return err;
+}
+
+static int __exit twl4030_pwrbutton_remove(struct platform_device *pdev)
+{
+	struct input_dev *pwr = platform_get_drvdata(pdev);
+	int irq = platform_get_irq(pdev, 0);
+
+	free_irq(irq, pwr);
+	input_unregister_device(pwr);
+
+	return 0;
+}
+
+static struct platform_driver twl4030_pwrbutton_driver = {
+	.remove		= __exit_p(twl4030_pwrbutton_remove),
+	.driver		= {
+		.name	= "twl4030_pwrbutton",
+		.owner	= THIS_MODULE,
+	},
+};
+
+module_platform_driver_probe(twl4030_pwrbutton_driver,
+			twl4030_pwrbutton_probe);
+
+MODULE_ALIAS("platform:twl4030_pwrbutton");
+MODULE_DESCRIPTION("Triton2 Power Button");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Peter De Schrijver <peter.de-schrijver@nokia.com>");
+MODULE_AUTHOR("Felipe Balbi <felipe.balbi@nokia.com>");
+
diff --git a/drivers/input/misc/twl4030-vibra.c b/drivers/input/misc/twl4030-vibra.c
new file mode 100644
index 00000000..68a5f331
--- /dev/null
+++ b/drivers/input/misc/twl4030-vibra.c
@@ -0,0 +1,263 @@
+/*
+ * twl4030-vibra.c - TWL4030 Vibrator driver
+ *
+ * Copyright (C) 2008-2010 Nokia Corporation
+ *
+ * Written by Henrik Saari <henrik.saari@nokia.com>
+ * Updates by Felipe Balbi <felipe.balbi@nokia.com>
+ * Input by Jari Vanhala <ext-jari.vanhala@nokia.com>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/jiffies.h>
+#include <linux/platform_device.h>
+#include <linux/of.h>
+#include <linux/workqueue.h>
+#include <linux/i2c/twl.h>
+#include <linux/mfd/twl4030-audio.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+
+/* MODULE ID2 */
+#define LEDEN		0x00
+
+/* ForceFeedback */
+#define EFFECT_DIR_180_DEG	0x8000 /* range is 0 - 0xFFFF */
+
+struct vibra_info {
+	struct device		*dev;
+	struct input_dev	*input_dev;
+
+	struct work_struct	play_work;
+
+	bool			enabled;
+	int			speed;
+	int			direction;
+
+	bool			coexist;
+};
+
+static void vibra_disable_leds(void)
+{
+	u8 reg;
+
+	/* Disable LEDA & LEDB, cannot be used with vibra (PWM) */
+	twl_i2c_read_u8(TWL4030_MODULE_LED, &reg, LEDEN);
+	reg &= ~0x03;
+	twl_i2c_write_u8(TWL4030_MODULE_LED, LEDEN, reg);
+}
+
+/* Powers H-Bridge and enables audio clk */
+static void vibra_enable(struct vibra_info *info)
+{
+	u8 reg;
+
+	twl4030_audio_enable_resource(TWL4030_AUDIO_RES_POWER);
+
+	/* turn H-Bridge on */
+	twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE,
+			&reg, TWL4030_REG_VIBRA_CTL);
+	twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
+			 (reg | TWL4030_VIBRA_EN), TWL4030_REG_VIBRA_CTL);
+
+	twl4030_audio_enable_resource(TWL4030_AUDIO_RES_APLL);
+
+	info->enabled = true;
+}
+
+static void vibra_disable(struct vibra_info *info)
+{
+	u8 reg;
+
+	/* Power down H-Bridge */
+	twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE,
+			&reg, TWL4030_REG_VIBRA_CTL);
+	twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
+			 (reg & ~TWL4030_VIBRA_EN), TWL4030_REG_VIBRA_CTL);
+
+	twl4030_audio_disable_resource(TWL4030_AUDIO_RES_APLL);
+	twl4030_audio_disable_resource(TWL4030_AUDIO_RES_POWER);
+
+	info->enabled = false;
+}
+
+static void vibra_play_work(struct work_struct *work)
+{
+	struct vibra_info *info = container_of(work,
+			struct vibra_info, play_work);
+	int dir;
+	int pwm;
+	u8 reg;
+
+	dir = info->direction;
+	pwm = info->speed;
+
+	twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE,
+			&reg, TWL4030_REG_VIBRA_CTL);
+	if (pwm && (!info->coexist || !(reg & TWL4030_VIBRA_SEL))) {
+
+		if (!info->enabled)
+			vibra_enable(info);
+
+		/* set vibra rotation direction */
+		twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE,
+				&reg, TWL4030_REG_VIBRA_CTL);
+		reg = (dir) ? (reg | TWL4030_VIBRA_DIR) :
+			(reg & ~TWL4030_VIBRA_DIR);
+		twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
+				 reg, TWL4030_REG_VIBRA_CTL);
+
+		/* set PWM, 1 = max, 255 = min */
+		twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
+				 256 - pwm, TWL4030_REG_VIBRA_SET);
+	} else {
+		if (info->enabled)
+			vibra_disable(info);
+	}
+}
+
+/*** Input/ForceFeedback ***/
+
+static int vibra_play(struct input_dev *input, void *data,
+		      struct ff_effect *effect)
+{
+	struct vibra_info *info = input_get_drvdata(input);
+
+	info->speed = effect->u.rumble.strong_magnitude >> 8;
+	if (!info->speed)
+		info->speed = effect->u.rumble.weak_magnitude >> 9;
+	info->direction = effect->direction < EFFECT_DIR_180_DEG ? 0 : 1;
+	schedule_work(&info->play_work);
+	return 0;
+}
+
+static void twl4030_vibra_close(struct input_dev *input)
+{
+	struct vibra_info *info = input_get_drvdata(input);
+
+	cancel_work_sync(&info->play_work);
+
+	if (info->enabled)
+		vibra_disable(info);
+}
+
+/*** Module ***/
+#ifdef CONFIG_PM_SLEEP
+static int twl4030_vibra_suspend(struct device *dev)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct vibra_info *info = platform_get_drvdata(pdev);
+
+	if (info->enabled)
+		vibra_disable(info);
+
+	return 0;
+}
+
+static int twl4030_vibra_resume(struct device *dev)
+{
+	vibra_disable_leds();
+	return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(twl4030_vibra_pm_ops,
+			 twl4030_vibra_suspend, twl4030_vibra_resume);
+
+static bool twl4030_vibra_check_coexist(struct twl4030_vibra_data *pdata,
+			      struct device_node *node)
+{
+	if (pdata && pdata->coexist)
+		return true;
+
+	if (of_find_node_by_name(node, "codec"))
+		return true;
+
+	return false;
+}
+
+static int twl4030_vibra_probe(struct platform_device *pdev)
+{
+	struct twl4030_vibra_data *pdata = pdev->dev.platform_data;
+	struct device_node *twl4030_core_node = pdev->dev.parent->of_node;
+	struct vibra_info *info;
+	int ret;
+
+	if (!pdata && !twl4030_core_node) {
+		dev_dbg(&pdev->dev, "platform_data not available\n");
+		return -EINVAL;
+	}
+
+	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
+	if (!info)
+		return -ENOMEM;
+
+	info->dev = &pdev->dev;
+	info->coexist = twl4030_vibra_check_coexist(pdata, twl4030_core_node);
+	INIT_WORK(&info->play_work, vibra_play_work);
+
+	info->input_dev = devm_input_allocate_device(&pdev->dev);
+	if (info->input_dev == NULL) {
+		dev_err(&pdev->dev, "couldn't allocate input device\n");
+		return -ENOMEM;
+	}
+
+	input_set_drvdata(info->input_dev, info);
+
+	info->input_dev->name = "twl4030:vibrator";
+	info->input_dev->id.version = 1;
+	info->input_dev->dev.parent = pdev->dev.parent;
+	info->input_dev->close = twl4030_vibra_close;
+	__set_bit(FF_RUMBLE, info->input_dev->ffbit);
+
+	ret = input_ff_create_memless(info->input_dev, NULL, vibra_play);
+	if (ret < 0) {
+		dev_dbg(&pdev->dev, "couldn't register vibrator to FF\n");
+		return ret;
+	}
+
+	ret = input_register_device(info->input_dev);
+	if (ret < 0) {
+		dev_dbg(&pdev->dev, "couldn't register input device\n");
+		goto err_iff;
+	}
+
+	vibra_disable_leds();
+
+	platform_set_drvdata(pdev, info);
+	return 0;
+
+err_iff:
+	input_ff_destroy(info->input_dev);
+	return ret;
+}
+
+static struct platform_driver twl4030_vibra_driver = {
+	.probe		= twl4030_vibra_probe,
+	.driver		= {
+		.name	= "twl4030-vibra",
+		.owner	= THIS_MODULE,
+		.pm	= &twl4030_vibra_pm_ops,
+	},
+};
+module_platform_driver(twl4030_vibra_driver);
+
+MODULE_ALIAS("platform:twl4030-vibra");
+MODULE_DESCRIPTION("TWL4030 Vibra driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Nokia Corporation");
diff --git a/drivers/input/misc/twl6040-vibra.c b/drivers/input/misc/twl6040-vibra.c
new file mode 100644
index 00000000..0c2dfc8e
--- /dev/null
+++ b/drivers/input/misc/twl6040-vibra.c
@@ -0,0 +1,431 @@
+/*
+ * twl6040-vibra.c - TWL6040 Vibrator driver
+ *
+ * Author:      Jorge Eduardo Candelaria <jorge.candelaria@ti.com>
+ * Author:      Misael Lopez Cruz <misael.lopez@ti.com>
+ *
+ * Copyright:   (C) 2011 Texas Instruments, Inc.
+ *
+ * Based on twl4030-vibra.c by Henrik Saari <henrik.saari@nokia.com>
+ *				Felipe Balbi <felipe.balbi@nokia.com>
+ *				Jari Vanhala <ext-javi.vanhala@nokia.com>
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/of.h>
+#include <linux/workqueue.h>
+#include <linux/input.h>
+#include <linux/mfd/twl6040.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/regulator/consumer.h>
+
+#define EFFECT_DIR_180_DEG	0x8000
+
+/* Recommended modulation index 85% */
+#define TWL6040_VIBRA_MOD	85
+
+#define TWL6040_NUM_SUPPLIES 2
+
+struct vibra_info {
+	struct device *dev;
+	struct input_dev *input_dev;
+	struct workqueue_struct *workqueue;
+	struct work_struct play_work;
+	struct mutex mutex;
+	int irq;
+
+	bool enabled;
+	int weak_speed;
+	int strong_speed;
+	int direction;
+
+	unsigned int vibldrv_res;
+	unsigned int vibrdrv_res;
+	unsigned int viblmotor_res;
+	unsigned int vibrmotor_res;
+
+	struct regulator_bulk_data supplies[TWL6040_NUM_SUPPLIES];
+
+	struct twl6040 *twl6040;
+};
+
+static irqreturn_t twl6040_vib_irq_handler(int irq, void *data)
+{
+	struct vibra_info *info = data;
+	struct twl6040 *twl6040 = info->twl6040;
+	u8 status;
+
+	status = twl6040_reg_read(twl6040, TWL6040_REG_STATUS);
+	if (status & TWL6040_VIBLOCDET) {
+		dev_warn(info->dev, "Left Vibrator overcurrent detected\n");
+		twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLL,
+				   TWL6040_VIBENA);
+	}
+	if (status & TWL6040_VIBROCDET) {
+		dev_warn(info->dev, "Right Vibrator overcurrent detected\n");
+		twl6040_clear_bits(twl6040, TWL6040_REG_VIBCTLR,
+				   TWL6040_VIBENA);
+	}
+
+	return IRQ_HANDLED;
+}
+
+static void twl6040_vibra_enable(struct vibra_info *info)
+{
+	struct twl6040 *twl6040 = info->twl6040;
+	int ret;
+
+	ret = regulator_bulk_enable(ARRAY_SIZE(info->supplies), info->supplies);
+	if (ret) {
+		dev_err(info->dev, "failed to enable regulators %d\n", ret);
+		return;
+	}
+
+	twl6040_power(info->twl6040, 1);
+	if (twl6040_get_revid(twl6040) <= TWL6040_REV_ES1_1) {
+		/*
+		 * ERRATA: Disable overcurrent protection for at least
+		 * 3ms when enabling vibrator drivers to avoid false
+		 * overcurrent detection
+		 */
+		twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLL,
+				  TWL6040_VIBENA | TWL6040_VIBCTRL);
+		twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLR,
+				  TWL6040_VIBENA | TWL6040_VIBCTRL);
+		usleep_range(3000, 3500);
+	}
+
+	twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLL,
+			  TWL6040_VIBENA);
+	twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLR,
+			  TWL6040_VIBENA);
+
+	info->enabled = true;
+}
+
+static void twl6040_vibra_disable(struct vibra_info *info)
+{
+	struct twl6040 *twl6040 = info->twl6040;
+
+	twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLL, 0x00);
+	twl6040_reg_write(twl6040, TWL6040_REG_VIBCTLR, 0x00);
+	twl6040_power(info->twl6040, 0);
+
+	regulator_bulk_disable(ARRAY_SIZE(info->supplies), info->supplies);
+
+	info->enabled = false;
+}
+
+static u8 twl6040_vibra_code(int vddvib, int vibdrv_res, int motor_res,
+			     int speed, int direction)
+{
+	int vpk, max_code;
+	u8 vibdat;
+
+	/* output swing */
+	vpk = (vddvib * motor_res * TWL6040_VIBRA_MOD) /
+		(100 * (vibdrv_res + motor_res));
+
+	/* 50mV per VIBDAT code step */
+	max_code = vpk / 50;
+	if (max_code > TWL6040_VIBDAT_MAX)
+		max_code = TWL6040_VIBDAT_MAX;
+
+	/* scale speed to max allowed code */
+	vibdat = (u8)((speed * max_code) / USHRT_MAX);
+
+	/* 2's complement for direction > 180 degrees */
+	vibdat *= direction;
+
+	return vibdat;
+}
+
+static void twl6040_vibra_set_effect(struct vibra_info *info)
+{
+	struct twl6040 *twl6040 = info->twl6040;
+	u8 vibdatl, vibdatr;
+	int volt;
+
+	/* weak motor */
+	volt = regulator_get_voltage(info->supplies[0].consumer) / 1000;
+	vibdatl = twl6040_vibra_code(volt, info->vibldrv_res,
+				     info->viblmotor_res,
+				     info->weak_speed, info->direction);
+
+	/* strong motor */
+	volt = regulator_get_voltage(info->supplies[1].consumer) / 1000;
+	vibdatr = twl6040_vibra_code(volt, info->vibrdrv_res,
+				     info->vibrmotor_res,
+				     info->strong_speed, info->direction);
+
+	twl6040_reg_write(twl6040, TWL6040_REG_VIBDATL, vibdatl);
+	twl6040_reg_write(twl6040, TWL6040_REG_VIBDATR, vibdatr);
+}
+
+static void vibra_play_work(struct work_struct *work)
+{
+	struct vibra_info *info = container_of(work,
+				struct vibra_info, play_work);
+
+	mutex_lock(&info->mutex);
+
+	if (info->weak_speed || info->strong_speed) {
+		if (!info->enabled)
+			twl6040_vibra_enable(info);
+
+		twl6040_vibra_set_effect(info);
+	} else if (info->enabled)
+		twl6040_vibra_disable(info);
+
+	mutex_unlock(&info->mutex);
+}
+
+static int vibra_play(struct input_dev *input, void *data,
+		      struct ff_effect *effect)
+{
+	struct vibra_info *info = input_get_drvdata(input);
+	int ret;
+
+	/* Do not allow effect, while the routing is set to use audio */
+	ret = twl6040_get_vibralr_status(info->twl6040);
+	if (ret & TWL6040_VIBSEL) {
+		dev_info(&input->dev, "Vibra is configured for audio\n");
+		return -EBUSY;
+	}
+
+	info->weak_speed = effect->u.rumble.weak_magnitude;
+	info->strong_speed = effect->u.rumble.strong_magnitude;
+	info->direction = effect->direction < EFFECT_DIR_180_DEG ? 1 : -1;
+
+	ret = queue_work(info->workqueue, &info->play_work);
+	if (!ret) {
+		dev_info(&input->dev, "work is already on queue\n");
+		return ret;
+	}
+
+	return 0;
+}
+
+static void twl6040_vibra_close(struct input_dev *input)
+{
+	struct vibra_info *info = input_get_drvdata(input);
+
+	cancel_work_sync(&info->play_work);
+
+	mutex_lock(&info->mutex);
+
+	if (info->enabled)
+		twl6040_vibra_disable(info);
+
+	mutex_unlock(&info->mutex);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int twl6040_vibra_suspend(struct device *dev)
+{
+	struct platform_device *pdev = to_platform_device(dev);
+	struct vibra_info *info = platform_get_drvdata(pdev);
+
+	mutex_lock(&info->mutex);
+
+	if (info->enabled)
+		twl6040_vibra_disable(info);
+
+	mutex_unlock(&info->mutex);
+
+	return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(twl6040_vibra_pm_ops, twl6040_vibra_suspend, NULL);
+
+static int twl6040_vibra_probe(struct platform_device *pdev)
+{
+	struct twl6040_vibra_data *pdata = pdev->dev.platform_data;
+	struct device *twl6040_core_dev = pdev->dev.parent;
+	struct device_node *twl6040_core_node = NULL;
+	struct vibra_info *info;
+	int vddvibl_uV = 0;
+	int vddvibr_uV = 0;
+	int ret;
+
+#ifdef CONFIG_OF
+	twl6040_core_node = of_find_node_by_name(twl6040_core_dev->of_node,
+						 "vibra");
+#endif
+
+	if (!pdata && !twl6040_core_node) {
+		dev_err(&pdev->dev, "platform_data not available\n");
+		return -EINVAL;
+	}
+
+	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
+	if (!info) {
+		dev_err(&pdev->dev, "couldn't allocate memory\n");
+		return -ENOMEM;
+	}
+
+	info->dev = &pdev->dev;
+
+	info->twl6040 = dev_get_drvdata(pdev->dev.parent);
+	if (pdata) {
+		info->vibldrv_res = pdata->vibldrv_res;
+		info->vibrdrv_res = pdata->vibrdrv_res;
+		info->viblmotor_res = pdata->viblmotor_res;
+		info->vibrmotor_res = pdata->vibrmotor_res;
+		vddvibl_uV = pdata->vddvibl_uV;
+		vddvibr_uV = pdata->vddvibr_uV;
+	} else {
+		of_property_read_u32(twl6040_core_node, "ti,vibldrv-res",
+				     &info->vibldrv_res);
+		of_property_read_u32(twl6040_core_node, "ti,vibrdrv-res",
+				     &info->vibrdrv_res);
+		of_property_read_u32(twl6040_core_node, "ti,viblmotor-res",
+				     &info->viblmotor_res);
+		of_property_read_u32(twl6040_core_node, "ti,vibrmotor-res",
+				     &info->vibrmotor_res);
+		of_property_read_u32(twl6040_core_node, "ti,vddvibl-uV",
+				     &vddvibl_uV);
+		of_property_read_u32(twl6040_core_node, "ti,vddvibr-uV",
+				     &vddvibr_uV);
+	}
+
+	if ((!info->vibldrv_res && !info->viblmotor_res) ||
+	    (!info->vibrdrv_res && !info->vibrmotor_res)) {
+		dev_err(info->dev, "invalid vibra driver/motor resistance\n");
+		return -EINVAL;
+	}
+
+	info->irq = platform_get_irq(pdev, 0);
+	if (info->irq < 0) {
+		dev_err(info->dev, "invalid irq\n");
+		return -EINVAL;
+	}
+
+	mutex_init(&info->mutex);
+
+	ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
+					twl6040_vib_irq_handler, 0,
+					"twl6040_irq_vib", info);
+	if (ret) {
+		dev_err(info->dev, "VIB IRQ request failed: %d\n", ret);
+		return ret;
+	}
+
+	info->supplies[0].supply = "vddvibl";
+	info->supplies[1].supply = "vddvibr";
+	/*
+	 * When booted with Device tree the regulators are attached to the
+	 * parent device (twl6040 MFD core)
+	 */
+	ret = regulator_bulk_get(pdata ? info->dev : twl6040_core_dev,
+				 ARRAY_SIZE(info->supplies), info->supplies);
+	if (ret) {
+		dev_err(info->dev, "couldn't get regulators %d\n", ret);
+		return ret;
+	}
+
+	if (vddvibl_uV) {
+		ret = regulator_set_voltage(info->supplies[0].consumer,
+					    vddvibl_uV, vddvibl_uV);
+		if (ret) {
+			dev_err(info->dev, "failed to set VDDVIBL volt %d\n",
+				ret);
+			goto err_regulator;
+		}
+	}
+
+	if (vddvibr_uV) {
+		ret = regulator_set_voltage(info->supplies[1].consumer,
+					    vddvibr_uV, vddvibr_uV);
+		if (ret) {
+			dev_err(info->dev, "failed to set VDDVIBR volt %d\n",
+				ret);
+			goto err_regulator;
+		}
+	}
+
+	INIT_WORK(&info->play_work, vibra_play_work);
+
+	info->input_dev = input_allocate_device();
+	if (info->input_dev == NULL) {
+		dev_err(info->dev, "couldn't allocate input device\n");
+		ret = -ENOMEM;
+		goto err_regulator;
+	}
+
+	input_set_drvdata(info->input_dev, info);
+
+	info->input_dev->name = "twl6040:vibrator";
+	info->input_dev->id.version = 1;
+	info->input_dev->dev.parent = pdev->dev.parent;
+	info->input_dev->close = twl6040_vibra_close;
+	__set_bit(FF_RUMBLE, info->input_dev->ffbit);
+
+	ret = input_ff_create_memless(info->input_dev, NULL, vibra_play);
+	if (ret < 0) {
+		dev_err(info->dev, "couldn't register vibrator to FF\n");
+		goto err_ialloc;
+	}
+
+	ret = input_register_device(info->input_dev);
+	if (ret < 0) {
+		dev_err(info->dev, "couldn't register input device\n");
+		goto err_iff;
+	}
+
+	platform_set_drvdata(pdev, info);
+
+	return 0;
+
+err_iff:
+	input_ff_destroy(info->input_dev);
+err_ialloc:
+	input_free_device(info->input_dev);
+err_regulator:
+	regulator_bulk_free(ARRAY_SIZE(info->supplies), info->supplies);
+	return ret;
+}
+
+static int twl6040_vibra_remove(struct platform_device *pdev)
+{
+	struct vibra_info *info = platform_get_drvdata(pdev);
+
+	input_unregister_device(info->input_dev);
+	regulator_bulk_free(ARRAY_SIZE(info->supplies), info->supplies);
+
+	return 0;
+}
+
+static struct platform_driver twl6040_vibra_driver = {
+	.probe		= twl6040_vibra_probe,
+	.remove		= twl6040_vibra_remove,
+	.driver		= {
+		.name	= "twl6040-vibra",
+		.owner	= THIS_MODULE,
+		.pm	= &twl6040_vibra_pm_ops,
+	},
+};
+module_platform_driver(twl6040_vibra_driver);
+
+MODULE_ALIAS("platform:twl6040-vibra");
+MODULE_DESCRIPTION("TWL6040 Vibra driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jorge Eduardo Candelaria <jorge.candelaria@ti.com>");
+MODULE_AUTHOR("Misael Lopez Cruz <misael.lopez@ti.com>");
diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c
new file mode 100644
index 00000000..a0a4bbae
--- /dev/null
+++ b/drivers/input/misc/uinput.c
@@ -0,0 +1,883 @@
+/*
+ *  User level driver support for input subsystem
+ *
+ * Heavily based on evdev.c by Vojtech Pavlik
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Author: Aristeu Sergio Rozanski Filho <aris@cathedrallabs.org>
+ *
+ * Changes/Revisions:
+ *	0.3	09/04/2006 (Anssi Hannula <anssi.hannula@gmail.com>)
+ *		- updated ff support for the changes in kernel interface
+ *		- added MODULE_VERSION
+ *	0.2	16/10/2004 (Micah Dowty <micah@navi.cx>)
+ *		- added force feedback support
+ *              - added UI_SET_PHYS
+ *	0.1	20/06/2002
+ *		- first public version
+ */
+#include <linux/poll.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/uinput.h>
+#include <linux/input/mt.h>
+#include "../input-compat.h"
+
+static int uinput_dev_event(struct input_dev *dev,
+			    unsigned int type, unsigned int code, int value)
+{
+	struct uinput_device	*udev = input_get_drvdata(dev);
+
+	udev->buff[udev->head].type = type;
+	udev->buff[udev->head].code = code;
+	udev->buff[udev->head].value = value;
+	do_gettimeofday(&udev->buff[udev->head].time);
+	udev->head = (udev->head + 1) % UINPUT_BUFFER_SIZE;
+
+	wake_up_interruptible(&udev->waitq);
+
+	return 0;
+}
+
+/* Atomically allocate an ID for the given request. Returns 0 on success. */
+static bool uinput_request_alloc_id(struct uinput_device *udev,
+				    struct uinput_request *request)
+{
+	unsigned int id;
+	bool reserved = false;
+
+	spin_lock(&udev->requests_lock);
+
+	for (id = 0; id < UINPUT_NUM_REQUESTS; id++) {
+		if (!udev->requests[id]) {
+			request->id = id;
+			udev->requests[id] = request;
+			reserved = true;
+			break;
+		}
+	}
+
+	spin_unlock(&udev->requests_lock);
+	return reserved;
+}
+
+static struct uinput_request *uinput_request_find(struct uinput_device *udev,
+						  unsigned int id)
+{
+	/* Find an input request, by ID. Returns NULL if the ID isn't valid. */
+	if (id >= UINPUT_NUM_REQUESTS)
+		return NULL;
+
+	return udev->requests[id];
+}
+
+static int uinput_request_reserve_slot(struct uinput_device *udev,
+				       struct uinput_request *request)
+{
+	/* Allocate slot. If none are available right away, wait. */
+	return wait_event_interruptible(udev->requests_waitq,
+					uinput_request_alloc_id(udev, request));
+}
+
+static void uinput_request_done(struct uinput_device *udev,
+				struct uinput_request *request)
+{
+	/* Mark slot as available */
+	udev->requests[request->id] = NULL;
+	wake_up(&udev->requests_waitq);
+
+	complete(&request->done);
+}
+
+static int uinput_request_send(struct uinput_device *udev,
+			       struct uinput_request *request)
+{
+	int retval;
+
+	retval = mutex_lock_interruptible(&udev->mutex);
+	if (retval)
+		return retval;
+
+	if (udev->state != UIST_CREATED) {
+		retval = -ENODEV;
+		goto out;
+	}
+
+	init_completion(&request->done);
+
+	/*
+	 * Tell our userspace application about this new request
+	 * by queueing an input event.
+	 */
+	uinput_dev_event(udev->dev, EV_UINPUT, request->code, request->id);
+
+ out:
+	mutex_unlock(&udev->mutex);
+	return retval;
+}
+
+static int uinput_request_submit(struct uinput_device *udev,
+				 struct uinput_request *request)
+{
+	int error;
+
+	error = uinput_request_reserve_slot(udev, request);
+	if (error)
+		return error;
+
+	error = uinput_request_send(udev, request);
+	if (error) {
+		uinput_request_done(udev, request);
+		return error;
+	}
+
+	wait_for_completion(&request->done);
+	return request->retval;
+}
+
+/*
+ * Fail all outstanding requests so handlers don't wait for the userspace
+ * to finish processing them.
+ */
+static void uinput_flush_requests(struct uinput_device *udev)
+{
+	struct uinput_request *request;
+	int i;
+
+	spin_lock(&udev->requests_lock);
+
+	for (i = 0; i < UINPUT_NUM_REQUESTS; i++) {
+		request = udev->requests[i];
+		if (request) {
+			request->retval = -ENODEV;
+			uinput_request_done(udev, request);
+		}
+	}
+
+	spin_unlock(&udev->requests_lock);
+}
+
+static void uinput_dev_set_gain(struct input_dev *dev, u16 gain)
+{
+	uinput_dev_event(dev, EV_FF, FF_GAIN, gain);
+}
+
+static void uinput_dev_set_autocenter(struct input_dev *dev, u16 magnitude)
+{
+	uinput_dev_event(dev, EV_FF, FF_AUTOCENTER, magnitude);
+}
+
+static int uinput_dev_playback(struct input_dev *dev, int effect_id, int value)
+{
+	return uinput_dev_event(dev, EV_FF, effect_id, value);
+}
+
+static int uinput_dev_upload_effect(struct input_dev *dev,
+				    struct ff_effect *effect,
+				    struct ff_effect *old)
+{
+	struct uinput_device *udev = input_get_drvdata(dev);
+	struct uinput_request request;
+
+	/*
+	 * uinput driver does not currently support periodic effects with
+	 * custom waveform since it does not have a way to pass buffer of
+	 * samples (custom_data) to userspace. If ever there is a device
+	 * supporting custom waveforms we would need to define an additional
+	 * ioctl (UI_UPLOAD_SAMPLES) but for now we just bail out.
+	 */
+	if (effect->type == FF_PERIODIC &&
+			effect->u.periodic.waveform == FF_CUSTOM)
+		return -EINVAL;
+
+	request.code = UI_FF_UPLOAD;
+	request.u.upload.effect = effect;
+	request.u.upload.old = old;
+
+	return uinput_request_submit(udev, &request);
+}
+
+static int uinput_dev_erase_effect(struct input_dev *dev, int effect_id)
+{
+	struct uinput_device *udev = input_get_drvdata(dev);
+	struct uinput_request request;
+
+	if (!test_bit(EV_FF, dev->evbit))
+		return -ENOSYS;
+
+	request.code = UI_FF_ERASE;
+	request.u.effect_id = effect_id;
+
+	return uinput_request_submit(udev, &request);
+}
+
+static void uinput_destroy_device(struct uinput_device *udev)
+{
+	const char *name, *phys;
+	struct input_dev *dev = udev->dev;
+	enum uinput_state old_state = udev->state;
+
+	udev->state = UIST_NEW_DEVICE;
+
+	if (dev) {
+		name = dev->name;
+		phys = dev->phys;
+		if (old_state == UIST_CREATED) {
+			uinput_flush_requests(udev);
+			input_unregister_device(dev);
+		} else {
+			input_free_device(dev);
+		}
+		kfree(name);
+		kfree(phys);
+		udev->dev = NULL;
+	}
+}
+
+static int uinput_create_device(struct uinput_device *udev)
+{
+	struct input_dev *dev = udev->dev;
+	int error;
+
+	if (udev->state != UIST_SETUP_COMPLETE) {
+		printk(KERN_DEBUG "%s: write device info first\n", UINPUT_NAME);
+		return -EINVAL;
+	}
+
+	if (udev->ff_effects_max) {
+		error = input_ff_create(dev, udev->ff_effects_max);
+		if (error)
+			goto fail1;
+
+		dev->ff->upload = uinput_dev_upload_effect;
+		dev->ff->erase = uinput_dev_erase_effect;
+		dev->ff->playback = uinput_dev_playback;
+		dev->ff->set_gain = uinput_dev_set_gain;
+		dev->ff->set_autocenter = uinput_dev_set_autocenter;
+	}
+
+	error = input_register_device(udev->dev);
+	if (error)
+		goto fail2;
+
+	udev->state = UIST_CREATED;
+
+	return 0;
+
+ fail2:	input_ff_destroy(dev);
+ fail1: uinput_destroy_device(udev);
+	return error;
+}
+
+static int uinput_open(struct inode *inode, struct file *file)
+{
+	struct uinput_device *newdev;
+
+	newdev = kzalloc(sizeof(struct uinput_device), GFP_KERNEL);
+	if (!newdev)
+		return -ENOMEM;
+
+	mutex_init(&newdev->mutex);
+	spin_lock_init(&newdev->requests_lock);
+	init_waitqueue_head(&newdev->requests_waitq);
+	init_waitqueue_head(&newdev->waitq);
+	newdev->state = UIST_NEW_DEVICE;
+
+	file->private_data = newdev;
+	nonseekable_open(inode, file);
+
+	return 0;
+}
+
+static int uinput_validate_absbits(struct input_dev *dev)
+{
+	unsigned int cnt;
+	int retval = 0;
+
+	for (cnt = 0; cnt < ABS_CNT; cnt++) {
+		int min, max;
+		if (!test_bit(cnt, dev->absbit))
+			continue;
+
+		min = input_abs_get_min(dev, cnt);
+		max = input_abs_get_max(dev, cnt);
+
+		if ((min != 0 || max != 0) && max <= min) {
+			printk(KERN_DEBUG
+				"%s: invalid abs[%02x] min:%d max:%d\n",
+				UINPUT_NAME, cnt,
+				input_abs_get_min(dev, cnt),
+				input_abs_get_max(dev, cnt));
+			retval = -EINVAL;
+			break;
+		}
+
+		if (input_abs_get_flat(dev, cnt) >
+		    input_abs_get_max(dev, cnt) - input_abs_get_min(dev, cnt)) {
+			printk(KERN_DEBUG
+				"%s: abs_flat #%02x out of range: %d "
+				"(min:%d/max:%d)\n",
+				UINPUT_NAME, cnt,
+				input_abs_get_flat(dev, cnt),
+				input_abs_get_min(dev, cnt),
+				input_abs_get_max(dev, cnt));
+			retval = -EINVAL;
+			break;
+		}
+	}
+	return retval;
+}
+
+static int uinput_allocate_device(struct uinput_device *udev)
+{
+	udev->dev = input_allocate_device();
+	if (!udev->dev)
+		return -ENOMEM;
+
+	udev->dev->event = uinput_dev_event;
+	input_set_drvdata(udev->dev, udev);
+
+	return 0;
+}
+
+static int uinput_setup_device(struct uinput_device *udev,
+			       const char __user *buffer, size_t count)
+{
+	struct uinput_user_dev	*user_dev;
+	struct input_dev	*dev;
+	int			i;
+	int			retval;
+
+	if (count != sizeof(struct uinput_user_dev))
+		return -EINVAL;
+
+	if (!udev->dev) {
+		retval = uinput_allocate_device(udev);
+		if (retval)
+			return retval;
+	}
+
+	dev = udev->dev;
+
+	user_dev = memdup_user(buffer, sizeof(struct uinput_user_dev));
+	if (IS_ERR(user_dev))
+		return PTR_ERR(user_dev);
+
+	udev->ff_effects_max = user_dev->ff_effects_max;
+
+	/* Ensure name is filled in */
+	if (!user_dev->name[0]) {
+		retval = -EINVAL;
+		goto exit;
+	}
+
+	kfree(dev->name);
+	dev->name = kstrndup(user_dev->name, UINPUT_MAX_NAME_SIZE,
+			     GFP_KERNEL);
+	if (!dev->name) {
+		retval = -ENOMEM;
+		goto exit;
+	}
+
+	dev->id.bustype	= user_dev->id.bustype;
+	dev->id.vendor	= user_dev->id.vendor;
+	dev->id.product	= user_dev->id.product;
+	dev->id.version	= user_dev->id.version;
+
+	for (i = 0; i < ABS_CNT; i++) {
+		input_abs_set_max(dev, i, user_dev->absmax[i]);
+		input_abs_set_min(dev, i, user_dev->absmin[i]);
+		input_abs_set_fuzz(dev, i, user_dev->absfuzz[i]);
+		input_abs_set_flat(dev, i, user_dev->absflat[i]);
+	}
+
+	/* check if absmin/absmax/absfuzz/absflat are filled as
+	 * told in Documentation/input/input-programming.txt */
+	if (test_bit(EV_ABS, dev->evbit)) {
+		retval = uinput_validate_absbits(dev);
+		if (retval < 0)
+			goto exit;
+		if (test_bit(ABS_MT_SLOT, dev->absbit)) {
+			int nslot = input_abs_get_max(dev, ABS_MT_SLOT) + 1;
+			input_mt_init_slots(dev, nslot, 0);
+		} else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
+			input_set_events_per_packet(dev, 60);
+		}
+	}
+
+	udev->state = UIST_SETUP_COMPLETE;
+	retval = count;
+
+ exit:
+	kfree(user_dev);
+	return retval;
+}
+
+static ssize_t uinput_inject_event(struct uinput_device *udev,
+				   const char __user *buffer, size_t count)
+{
+	struct input_event ev;
+
+	if (count < input_event_size())
+		return -EINVAL;
+
+	if (input_event_from_user(buffer, &ev))
+		return -EFAULT;
+
+	input_event(udev->dev, ev.type, ev.code, ev.value);
+
+	return input_event_size();
+}
+
+static ssize_t uinput_write(struct file *file, const char __user *buffer,
+			    size_t count, loff_t *ppos)
+{
+	struct uinput_device *udev = file->private_data;
+	int retval;
+
+	if (count == 0)
+		return 0;
+
+	retval = mutex_lock_interruptible(&udev->mutex);
+	if (retval)
+		return retval;
+
+	retval = udev->state == UIST_CREATED ?
+			uinput_inject_event(udev, buffer, count) :
+			uinput_setup_device(udev, buffer, count);
+
+	mutex_unlock(&udev->mutex);
+
+	return retval;
+}
+
+static bool uinput_fetch_next_event(struct uinput_device *udev,
+				    struct input_event *event)
+{
+	bool have_event;
+
+	spin_lock_irq(&udev->dev->event_lock);
+
+	have_event = udev->head != udev->tail;
+	if (have_event) {
+		*event = udev->buff[udev->tail];
+		udev->tail = (udev->tail + 1) % UINPUT_BUFFER_SIZE;
+	}
+
+	spin_unlock_irq(&udev->dev->event_lock);
+
+	return have_event;
+}
+
+static ssize_t uinput_events_to_user(struct uinput_device *udev,
+				     char __user *buffer, size_t count)
+{
+	struct input_event event;
+	size_t read = 0;
+
+	while (read + input_event_size() <= count &&
+	       uinput_fetch_next_event(udev, &event)) {
+
+		if (input_event_to_user(buffer + read, &event))
+			return -EFAULT;
+
+		read += input_event_size();
+	}
+
+	return read;
+}
+
+static ssize_t uinput_read(struct file *file, char __user *buffer,
+			   size_t count, loff_t *ppos)
+{
+	struct uinput_device *udev = file->private_data;
+	ssize_t retval;
+
+	if (count != 0 && count < input_event_size())
+		return -EINVAL;
+
+	do {
+		retval = mutex_lock_interruptible(&udev->mutex);
+		if (retval)
+			return retval;
+
+		if (udev->state != UIST_CREATED)
+			retval = -ENODEV;
+		else if (udev->head == udev->tail &&
+			 (file->f_flags & O_NONBLOCK))
+			retval = -EAGAIN;
+		else
+			retval = uinput_events_to_user(udev, buffer, count);
+
+		mutex_unlock(&udev->mutex);
+
+		if (retval || count == 0)
+			break;
+
+		if (!(file->f_flags & O_NONBLOCK))
+			retval = wait_event_interruptible(udev->waitq,
+						  udev->head != udev->tail ||
+						  udev->state != UIST_CREATED);
+	} while (retval == 0);
+
+	return retval;
+}
+
+static unsigned int uinput_poll(struct file *file, poll_table *wait)
+{
+	struct uinput_device *udev = file->private_data;
+
+	poll_wait(file, &udev->waitq, wait);
+
+	if (udev->head != udev->tail)
+		return POLLIN | POLLRDNORM;
+
+	return 0;
+}
+
+static int uinput_release(struct inode *inode, struct file *file)
+{
+	struct uinput_device *udev = file->private_data;
+
+	uinput_destroy_device(udev);
+	kfree(udev);
+
+	return 0;
+}
+
+#ifdef CONFIG_COMPAT
+struct uinput_ff_upload_compat {
+	__u32			request_id;
+	__s32			retval;
+	struct ff_effect_compat	effect;
+	struct ff_effect_compat	old;
+};
+
+static int uinput_ff_upload_to_user(char __user *buffer,
+				    const struct uinput_ff_upload *ff_up)
+{
+	if (INPUT_COMPAT_TEST) {
+		struct uinput_ff_upload_compat ff_up_compat;
+
+		ff_up_compat.request_id = ff_up->request_id;
+		ff_up_compat.retval = ff_up->retval;
+		/*
+		 * It so happens that the pointer that gives us the trouble
+		 * is the last field in the structure. Since we don't support
+		 * custom waveforms in uinput anyway we can just copy the whole
+		 * thing (to the compat size) and ignore the pointer.
+		 */
+		memcpy(&ff_up_compat.effect, &ff_up->effect,
+			sizeof(struct ff_effect_compat));
+		memcpy(&ff_up_compat.old, &ff_up->old,
+			sizeof(struct ff_effect_compat));
+
+		if (copy_to_user(buffer, &ff_up_compat,
+				 sizeof(struct uinput_ff_upload_compat)))
+			return -EFAULT;
+	} else {
+		if (copy_to_user(buffer, ff_up,
+				 sizeof(struct uinput_ff_upload)))
+			return -EFAULT;
+	}
+
+	return 0;
+}
+
+static int uinput_ff_upload_from_user(const char __user *buffer,
+				      struct uinput_ff_upload *ff_up)
+{
+	if (INPUT_COMPAT_TEST) {
+		struct uinput_ff_upload_compat ff_up_compat;
+
+		if (copy_from_user(&ff_up_compat, buffer,
+				   sizeof(struct uinput_ff_upload_compat)))
+			return -EFAULT;
+
+		ff_up->request_id = ff_up_compat.request_id;
+		ff_up->retval = ff_up_compat.retval;
+		memcpy(&ff_up->effect, &ff_up_compat.effect,
+			sizeof(struct ff_effect_compat));
+		memcpy(&ff_up->old, &ff_up_compat.old,
+			sizeof(struct ff_effect_compat));
+
+	} else {
+		if (copy_from_user(ff_up, buffer,
+				   sizeof(struct uinput_ff_upload)))
+			return -EFAULT;
+	}
+
+	return 0;
+}
+
+#else
+
+static int uinput_ff_upload_to_user(char __user *buffer,
+				    const struct uinput_ff_upload *ff_up)
+{
+	if (copy_to_user(buffer, ff_up, sizeof(struct uinput_ff_upload)))
+		return -EFAULT;
+
+	return 0;
+}
+
+static int uinput_ff_upload_from_user(const char __user *buffer,
+				      struct uinput_ff_upload *ff_up)
+{
+	if (copy_from_user(ff_up, buffer, sizeof(struct uinput_ff_upload)))
+		return -EFAULT;
+
+	return 0;
+}
+
+#endif
+
+#define uinput_set_bit(_arg, _bit, _max)		\
+({							\
+	int __ret = 0;					\
+	if (udev->state == UIST_CREATED)		\
+		__ret =  -EINVAL;			\
+	else if ((_arg) > (_max))			\
+		__ret = -EINVAL;			\
+	else set_bit((_arg), udev->dev->_bit);		\
+	__ret;						\
+})
+
+static long uinput_ioctl_handler(struct file *file, unsigned int cmd,
+				 unsigned long arg, void __user *p)
+{
+	int			retval;
+	struct uinput_device	*udev = file->private_data;
+	struct uinput_ff_upload ff_up;
+	struct uinput_ff_erase  ff_erase;
+	struct uinput_request   *req;
+	char			*phys;
+
+	retval = mutex_lock_interruptible(&udev->mutex);
+	if (retval)
+		return retval;
+
+	if (!udev->dev) {
+		retval = uinput_allocate_device(udev);
+		if (retval)
+			goto out;
+	}
+
+	switch (cmd) {
+		case UI_DEV_CREATE:
+			retval = uinput_create_device(udev);
+			break;
+
+		case UI_DEV_DESTROY:
+			uinput_destroy_device(udev);
+			break;
+
+		case UI_SET_EVBIT:
+			retval = uinput_set_bit(arg, evbit, EV_MAX);
+			break;
+
+		case UI_SET_KEYBIT:
+			retval = uinput_set_bit(arg, keybit, KEY_MAX);
+			break;
+
+		case UI_SET_RELBIT:
+			retval = uinput_set_bit(arg, relbit, REL_MAX);
+			break;
+
+		case UI_SET_ABSBIT:
+			retval = uinput_set_bit(arg, absbit, ABS_MAX);
+			break;
+
+		case UI_SET_MSCBIT:
+			retval = uinput_set_bit(arg, mscbit, MSC_MAX);
+			break;
+
+		case UI_SET_LEDBIT:
+			retval = uinput_set_bit(arg, ledbit, LED_MAX);
+			break;
+
+		case UI_SET_SNDBIT:
+			retval = uinput_set_bit(arg, sndbit, SND_MAX);
+			break;
+
+		case UI_SET_FFBIT:
+			retval = uinput_set_bit(arg, ffbit, FF_MAX);
+			break;
+
+		case UI_SET_SWBIT:
+			retval = uinput_set_bit(arg, swbit, SW_MAX);
+			break;
+
+		case UI_SET_PROPBIT:
+			retval = uinput_set_bit(arg, propbit, INPUT_PROP_MAX);
+			break;
+
+		case UI_SET_PHYS:
+			if (udev->state == UIST_CREATED) {
+				retval = -EINVAL;
+				goto out;
+			}
+
+			phys = strndup_user(p, 1024);
+			if (IS_ERR(phys)) {
+				retval = PTR_ERR(phys);
+				goto out;
+			}
+
+			kfree(udev->dev->phys);
+			udev->dev->phys = phys;
+			break;
+
+		case UI_BEGIN_FF_UPLOAD:
+			retval = uinput_ff_upload_from_user(p, &ff_up);
+			if (retval)
+				break;
+
+			req = uinput_request_find(udev, ff_up.request_id);
+			if (!req || req->code != UI_FF_UPLOAD ||
+			    !req->u.upload.effect) {
+				retval = -EINVAL;
+				break;
+			}
+
+			ff_up.retval = 0;
+			ff_up.effect = *req->u.upload.effect;
+			if (req->u.upload.old)
+				ff_up.old = *req->u.upload.old;
+			else
+				memset(&ff_up.old, 0, sizeof(struct ff_effect));
+
+			retval = uinput_ff_upload_to_user(p, &ff_up);
+			break;
+
+		case UI_BEGIN_FF_ERASE:
+			if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) {
+				retval = -EFAULT;
+				break;
+			}
+
+			req = uinput_request_find(udev, ff_erase.request_id);
+			if (!req || req->code != UI_FF_ERASE) {
+				retval = -EINVAL;
+				break;
+			}
+
+			ff_erase.retval = 0;
+			ff_erase.effect_id = req->u.effect_id;
+			if (copy_to_user(p, &ff_erase, sizeof(ff_erase))) {
+				retval = -EFAULT;
+				break;
+			}
+
+			break;
+
+		case UI_END_FF_UPLOAD:
+			retval = uinput_ff_upload_from_user(p, &ff_up);
+			if (retval)
+				break;
+
+			req = uinput_request_find(udev, ff_up.request_id);
+			if (!req || req->code != UI_FF_UPLOAD ||
+			    !req->u.upload.effect) {
+				retval = -EINVAL;
+				break;
+			}
+
+			req->retval = ff_up.retval;
+			uinput_request_done(udev, req);
+			break;
+
+		case UI_END_FF_ERASE:
+			if (copy_from_user(&ff_erase, p, sizeof(ff_erase))) {
+				retval = -EFAULT;
+				break;
+			}
+
+			req = uinput_request_find(udev, ff_erase.request_id);
+			if (!req || req->code != UI_FF_ERASE) {
+				retval = -EINVAL;
+				break;
+			}
+
+			req->retval = ff_erase.retval;
+			uinput_request_done(udev, req);
+			break;
+
+		default:
+			retval = -EINVAL;
+	}
+
+ out:
+	mutex_unlock(&udev->mutex);
+	return retval;
+}
+
+static long uinput_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	return uinput_ioctl_handler(file, cmd, arg, (void __user *)arg);
+}
+
+#ifdef CONFIG_COMPAT
+static long uinput_compat_ioctl(struct file *file,
+				unsigned int cmd, unsigned long arg)
+{
+	return uinput_ioctl_handler(file, cmd, arg, compat_ptr(arg));
+}
+#endif
+
+static const struct file_operations uinput_fops = {
+	.owner		= THIS_MODULE,
+	.open		= uinput_open,
+	.release	= uinput_release,
+	.read		= uinput_read,
+	.write		= uinput_write,
+	.poll		= uinput_poll,
+	.unlocked_ioctl	= uinput_ioctl,
+#ifdef CONFIG_COMPAT
+	.compat_ioctl	= uinput_compat_ioctl,
+#endif
+	.llseek		= no_llseek,
+};
+
+static struct miscdevice uinput_misc = {
+	.fops		= &uinput_fops,
+	.minor		= UINPUT_MINOR,
+	.name		= UINPUT_NAME,
+};
+MODULE_ALIAS_MISCDEV(UINPUT_MINOR);
+MODULE_ALIAS("devname:" UINPUT_NAME);
+
+static int __init uinput_init(void)
+{
+	return misc_register(&uinput_misc);
+}
+
+static void __exit uinput_exit(void)
+{
+	misc_deregister(&uinput_misc);
+}
+
+MODULE_AUTHOR("Aristeu Sergio Rozanski Filho");
+MODULE_DESCRIPTION("User level driver support for input subsystem");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("0.3");
+
+module_init(uinput_init);
+module_exit(uinput_exit);
diff --git a/drivers/input/misc/wistron_btns.c b/drivers/input/misc/wistron_btns.c
new file mode 100644
index 00000000..56536f4b
--- /dev/null
+++ b/drivers/input/misc/wistron_btns.c
@@ -0,0 +1,1389 @@
+/*
+ * Wistron laptop button driver
+ * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
+ * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
+ * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
+ *
+ * You can redistribute and/or modify this program under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place Suite 330, Boston, MA 02111-1307, USA.
+ */
+#include <linux/io.h>
+#include <linux/dmi.h>
+#include <linux/init.h>
+#include <linux/input-polldev.h>
+#include <linux/input/sparse-keymap.h>
+#include <linux/interrupt.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/mc146818rtc.h>
+#include <linux/module.h>
+#include <linux/preempt.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+#include <linux/platform_device.h>
+#include <linux/leds.h>
+
+/* How often we poll keys - msecs */
+#define POLL_INTERVAL_DEFAULT	500 /* when idle */
+#define POLL_INTERVAL_BURST	100 /* when a key was recently pressed */
+
+/* BIOS subsystem IDs */
+#define WIFI		0x35
+#define BLUETOOTH	0x34
+#define MAIL_LED	0x31
+
+MODULE_AUTHOR("Miloslav Trmac <mitr@volny.cz>");
+MODULE_DESCRIPTION("Wistron laptop button driver");
+MODULE_LICENSE("GPL v2");
+MODULE_VERSION("0.3");
+
+static bool force; /* = 0; */
+module_param(force, bool, 0);
+MODULE_PARM_DESC(force, "Load even if computer is not in database");
+
+static char *keymap_name; /* = NULL; */
+module_param_named(keymap, keymap_name, charp, 0);
+MODULE_PARM_DESC(keymap, "Keymap name, if it can't be autodetected [generic, 1557/MS2141]");
+
+static struct platform_device *wistron_device;
+
+ /* BIOS interface implementation */
+
+static void __iomem *bios_entry_point; /* BIOS routine entry point */
+static void __iomem *bios_code_map_base;
+static void __iomem *bios_data_map_base;
+
+static u8 cmos_address;
+
+struct regs {
+	u32 eax, ebx, ecx;
+};
+
+static void call_bios(struct regs *regs)
+{
+	unsigned long flags;
+
+	preempt_disable();
+	local_irq_save(flags);
+	asm volatile ("pushl %%ebp;"
+		      "movl %7, %%ebp;"
+		      "call *%6;"
+		      "popl %%ebp"
+		      : "=a" (regs->eax), "=b" (regs->ebx), "=c" (regs->ecx)
+		      : "0" (regs->eax), "1" (regs->ebx), "2" (regs->ecx),
+			"m" (bios_entry_point), "m" (bios_data_map_base)
+		      : "edx", "edi", "esi", "memory");
+	local_irq_restore(flags);
+	preempt_enable();
+}
+
+static ssize_t __init locate_wistron_bios(void __iomem *base)
+{
+	static unsigned char __initdata signature[] =
+		{ 0x42, 0x21, 0x55, 0x30 };
+	ssize_t offset;
+
+	for (offset = 0; offset < 0x10000; offset += 0x10) {
+		if (check_signature(base + offset, signature,
+				    sizeof(signature)) != 0)
+			return offset;
+	}
+	return -1;
+}
+
+static int __init map_bios(void)
+{
+	void __iomem *base;
+	ssize_t offset;
+	u32 entry_point;
+
+	base = ioremap(0xF0000, 0x10000); /* Can't fail */
+	offset = locate_wistron_bios(base);
+	if (offset < 0) {
+		printk(KERN_ERR "wistron_btns: BIOS entry point not found\n");
+		iounmap(base);
+		return -ENODEV;
+	}
+
+	entry_point = readl(base + offset + 5);
+	printk(KERN_DEBUG
+		"wistron_btns: BIOS signature found at %p, entry point %08X\n",
+		base + offset, entry_point);
+
+	if (entry_point >= 0xF0000) {
+		bios_code_map_base = base;
+		bios_entry_point = bios_code_map_base + (entry_point & 0xFFFF);
+	} else {
+		iounmap(base);
+		bios_code_map_base = ioremap(entry_point & ~0x3FFF, 0x4000);
+		if (bios_code_map_base == NULL) {
+			printk(KERN_ERR
+				"wistron_btns: Can't map BIOS code at %08X\n",
+				entry_point & ~0x3FFF);
+			goto err;
+		}
+		bios_entry_point = bios_code_map_base + (entry_point & 0x3FFF);
+	}
+	/* The Windows driver maps 0x10000 bytes, we keep only one page... */
+	bios_data_map_base = ioremap(0x400, 0xc00);
+	if (bios_data_map_base == NULL) {
+		printk(KERN_ERR "wistron_btns: Can't map BIOS data\n");
+		goto err_code;
+	}
+	return 0;
+
+err_code:
+	iounmap(bios_code_map_base);
+err:
+	return -ENOMEM;
+}
+
+static inline void unmap_bios(void)
+{
+	iounmap(bios_code_map_base);
+	iounmap(bios_data_map_base);
+}
+
+ /* BIOS calls */
+
+static u16 bios_pop_queue(void)
+{
+	struct regs regs;
+
+	memset(&regs, 0, sizeof (regs));
+	regs.eax = 0x9610;
+	regs.ebx = 0x061C;
+	regs.ecx = 0x0000;
+	call_bios(&regs);
+
+	return regs.eax;
+}
+
+static void bios_attach(void)
+{
+	struct regs regs;
+
+	memset(&regs, 0, sizeof (regs));
+	regs.eax = 0x9610;
+	regs.ebx = 0x012E;
+	call_bios(&regs);
+}
+
+static void bios_detach(void)
+{
+	struct regs regs;
+
+	memset(&regs, 0, sizeof (regs));
+	regs.eax = 0x9610;
+	regs.ebx = 0x002E;
+	call_bios(&regs);
+}
+
+static u8 bios_get_cmos_address(void)
+{
+	struct regs regs;
+
+	memset(&regs, 0, sizeof (regs));
+	regs.eax = 0x9610;
+	regs.ebx = 0x051C;
+	call_bios(&regs);
+
+	return regs.ecx;
+}
+
+static u16 bios_get_default_setting(u8 subsys)
+{
+	struct regs regs;
+
+	memset(&regs, 0, sizeof (regs));
+	regs.eax = 0x9610;
+	regs.ebx = 0x0200 | subsys;
+	call_bios(&regs);
+
+	return regs.eax;
+}
+
+static void bios_set_state(u8 subsys, int enable)
+{
+	struct regs regs;
+
+	memset(&regs, 0, sizeof (regs));
+	regs.eax = 0x9610;
+	regs.ebx = (enable ? 0x0100 : 0x0000) | subsys;
+	call_bios(&regs);
+}
+
+/* Hardware database */
+
+#define KE_WIFI		(KE_LAST + 1)
+#define KE_BLUETOOTH	(KE_LAST + 2)
+
+#define FE_MAIL_LED 0x01
+#define FE_WIFI_LED 0x02
+#define FE_UNTESTED 0x80
+
+static struct key_entry *keymap; /* = NULL; Current key map */
+static bool have_wifi;
+static bool have_bluetooth;
+static int leds_present;	/* bitmask of leds present */
+
+static int __init dmi_matched(const struct dmi_system_id *dmi)
+{
+	const struct key_entry *key;
+
+	keymap = dmi->driver_data;
+	for (key = keymap; key->type != KE_END; key++) {
+		if (key->type == KE_WIFI)
+			have_wifi = true;
+		else if (key->type == KE_BLUETOOTH)
+			have_bluetooth = true;
+	}
+	leds_present = key->code & (FE_MAIL_LED | FE_WIFI_LED);
+
+	return 1;
+}
+
+static struct key_entry keymap_empty[] __initdata = {
+	{ KE_END, 0 }
+};
+
+static struct key_entry keymap_fs_amilo_pro_v2000[] __initdata = {
+	{ KE_KEY,  0x01, {KEY_HELP} },
+	{ KE_KEY,  0x11, {KEY_PROG1} },
+	{ KE_KEY,  0x12, {KEY_PROG2} },
+	{ KE_WIFI, 0x30 },
+	{ KE_KEY,  0x31, {KEY_MAIL} },
+	{ KE_KEY,  0x36, {KEY_WWW} },
+	{ KE_END,  0 }
+};
+
+static struct key_entry keymap_fs_amilo_pro_v3505[] __initdata = {
+	{ KE_KEY,       0x01, {KEY_HELP} },          /* Fn+F1 */
+	{ KE_KEY,       0x06, {KEY_DISPLAYTOGGLE} }, /* Fn+F4 */
+	{ KE_BLUETOOTH, 0x30 },                      /* Fn+F10 */
+	{ KE_KEY,       0x31, {KEY_MAIL} },          /* mail button */
+	{ KE_KEY,       0x36, {KEY_WWW} },           /* www button */
+	{ KE_WIFI,      0x78 },                      /* satellite dish button */
+	{ KE_END,       0 }
+};
+
+static struct key_entry keymap_fujitsu_n3510[] __initdata = {
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x71, {KEY_STOPCD} },
+	{ KE_KEY, 0x72, {KEY_PLAYPAUSE} },
+	{ KE_KEY, 0x74, {KEY_REWIND} },
+	{ KE_KEY, 0x78, {KEY_FORWARD} },
+	{ KE_END, 0 }
+};
+
+static struct key_entry keymap_wistron_ms2111[] __initdata = {
+	{ KE_KEY,  0x11, {KEY_PROG1} },
+	{ KE_KEY,  0x12, {KEY_PROG2} },
+	{ KE_KEY,  0x13, {KEY_PROG3} },
+	{ KE_KEY,  0x31, {KEY_MAIL} },
+	{ KE_KEY,  0x36, {KEY_WWW} },
+	{ KE_END, FE_MAIL_LED }
+};
+
+static struct key_entry keymap_wistron_md40100[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_KEY, 0x37, {KEY_DISPLAYTOGGLE} }, /* Display on/off */
+	{ KE_END, FE_MAIL_LED | FE_WIFI_LED | FE_UNTESTED }
+};
+
+static struct key_entry keymap_wistron_ms2141[] __initdata = {
+	{ KE_KEY,  0x11, {KEY_PROG1} },
+	{ KE_KEY,  0x12, {KEY_PROG2} },
+	{ KE_WIFI, 0x30 },
+	{ KE_KEY,  0x22, {KEY_REWIND} },
+	{ KE_KEY,  0x23, {KEY_FORWARD} },
+	{ KE_KEY,  0x24, {KEY_PLAYPAUSE} },
+	{ KE_KEY,  0x25, {KEY_STOPCD} },
+	{ KE_KEY,  0x31, {KEY_MAIL} },
+	{ KE_KEY,  0x36, {KEY_WWW} },
+	{ KE_END,  0 }
+};
+
+static struct key_entry keymap_acer_aspire_1500[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x03, {KEY_POWER} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_WIFI, 0x30 },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_KEY, 0x49, {KEY_CONFIG} },
+	{ KE_BLUETOOTH, 0x44 },
+	{ KE_END, FE_UNTESTED }
+};
+
+static struct key_entry keymap_acer_aspire_1600[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x03, {KEY_POWER} },
+	{ KE_KEY, 0x08, {KEY_MUTE} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x13, {KEY_PROG3} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_KEY, 0x49, {KEY_CONFIG} },
+	{ KE_WIFI, 0x30 },
+	{ KE_BLUETOOTH, 0x44 },
+	{ KE_END, FE_MAIL_LED | FE_UNTESTED }
+};
+
+/* 3020 has been tested */
+static struct key_entry keymap_acer_aspire_5020[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x03, {KEY_POWER} },
+	{ KE_KEY, 0x05, {KEY_SWITCHVIDEOMODE} }, /* Display selection */
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_KEY, 0x6a, {KEY_CONFIG} },
+	{ KE_WIFI, 0x30 },
+	{ KE_BLUETOOTH, 0x44 },
+	{ KE_END, FE_MAIL_LED | FE_UNTESTED }
+};
+
+static struct key_entry keymap_acer_travelmate_2410[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x6d, {KEY_POWER} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_KEY, 0x6a, {KEY_CONFIG} },
+	{ KE_WIFI, 0x30 },
+	{ KE_BLUETOOTH, 0x44 },
+	{ KE_END, FE_MAIL_LED | FE_UNTESTED }
+};
+
+static struct key_entry keymap_acer_travelmate_110[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x03, {KEY_POWER} },
+	{ KE_KEY, 0x08, {KEY_MUTE} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x20, {KEY_VOLUMEUP} },
+	{ KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_SW, 0x4a, {.sw = {SW_LID, 1}} }, /* lid close */
+	{ KE_SW, 0x4b, {.sw = {SW_LID, 0}} }, /* lid open */
+	{ KE_WIFI, 0x30 },
+	{ KE_END, FE_MAIL_LED | FE_UNTESTED }
+};
+
+static struct key_entry keymap_acer_travelmate_300[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x03, {KEY_POWER} },
+	{ KE_KEY, 0x08, {KEY_MUTE} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x20, {KEY_VOLUMEUP} },
+	{ KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_WIFI, 0x30 },
+	{ KE_BLUETOOTH, 0x44 },
+	{ KE_END, FE_MAIL_LED | FE_UNTESTED }
+};
+
+static struct key_entry keymap_acer_travelmate_380[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x03, {KEY_POWER} }, /* not 370 */
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x13, {KEY_PROG3} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_WIFI, 0x30 },
+	{ KE_END, FE_MAIL_LED | FE_UNTESTED }
+};
+
+/* unusual map */
+static struct key_entry keymap_acer_travelmate_220[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x11, {KEY_MAIL} },
+	{ KE_KEY, 0x12, {KEY_WWW} },
+	{ KE_KEY, 0x13, {KEY_PROG2} },
+	{ KE_KEY, 0x31, {KEY_PROG1} },
+	{ KE_END, FE_WIFI_LED | FE_UNTESTED }
+};
+
+static struct key_entry keymap_acer_travelmate_230[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_END, FE_WIFI_LED | FE_UNTESTED }
+};
+
+static struct key_entry keymap_acer_travelmate_240[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x03, {KEY_POWER} },
+	{ KE_KEY, 0x08, {KEY_MUTE} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_BLUETOOTH, 0x44 },
+	{ KE_WIFI, 0x30 },
+	{ KE_END, FE_UNTESTED }
+};
+
+static struct key_entry keymap_acer_travelmate_350[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x13, {KEY_MAIL} },
+	{ KE_KEY, 0x14, {KEY_PROG3} },
+	{ KE_KEY, 0x15, {KEY_WWW} },
+	{ KE_END, FE_MAIL_LED | FE_WIFI_LED | FE_UNTESTED }
+};
+
+static struct key_entry keymap_acer_travelmate_360[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x13, {KEY_MAIL} },
+	{ KE_KEY, 0x14, {KEY_PROG3} },
+	{ KE_KEY, 0x15, {KEY_WWW} },
+	{ KE_KEY, 0x40, {KEY_WLAN} },
+	{ KE_END, FE_WIFI_LED | FE_UNTESTED } /* no mail led */
+};
+
+/* Wifi subsystem only activates the led. Therefore we need to pass
+ * wifi event as a normal key, then userspace can really change the wifi state.
+ * TODO we need to export led state to userspace (wifi and mail) */
+static struct key_entry keymap_acer_travelmate_610[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x13, {KEY_PROG3} },
+	{ KE_KEY, 0x14, {KEY_MAIL} },
+	{ KE_KEY, 0x15, {KEY_WWW} },
+	{ KE_KEY, 0x40, {KEY_WLAN} },
+	{ KE_END, FE_MAIL_LED | FE_WIFI_LED }
+};
+
+static struct key_entry keymap_acer_travelmate_630[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x03, {KEY_POWER} },
+	{ KE_KEY, 0x08, {KEY_MUTE} }, /* not 620 */
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x13, {KEY_PROG3} },
+	{ KE_KEY, 0x20, {KEY_VOLUMEUP} },
+	{ KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_WIFI, 0x30 },
+	{ KE_END, FE_MAIL_LED | FE_UNTESTED }
+};
+
+static struct key_entry keymap_aopen_1559as[] __initdata = {
+	{ KE_KEY,  0x01, {KEY_HELP} },
+	{ KE_KEY,  0x06, {KEY_PROG3} },
+	{ KE_KEY,  0x11, {KEY_PROG1} },
+	{ KE_KEY,  0x12, {KEY_PROG2} },
+	{ KE_WIFI, 0x30 },
+	{ KE_KEY,  0x31, {KEY_MAIL} },
+	{ KE_KEY,  0x36, {KEY_WWW} },
+	{ KE_END,  0 },
+};
+
+static struct key_entry keymap_fs_amilo_d88x0[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x08, {KEY_MUTE} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x13, {KEY_PROG3} },
+	{ KE_END, FE_MAIL_LED | FE_WIFI_LED | FE_UNTESTED }
+};
+
+static struct key_entry keymap_wistron_md2900[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_WIFI, 0x30 },
+	{ KE_END, FE_MAIL_LED | FE_UNTESTED }
+};
+
+static struct key_entry keymap_wistron_md96500[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x05, {KEY_SWITCHVIDEOMODE} }, /* Display selection */
+	{ KE_KEY, 0x06, {KEY_DISPLAYTOGGLE} }, /* Display on/off */
+	{ KE_KEY, 0x08, {KEY_MUTE} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x20, {KEY_VOLUMEUP} },
+	{ KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
+	{ KE_KEY, 0x22, {KEY_REWIND} },
+	{ KE_KEY, 0x23, {KEY_FORWARD} },
+	{ KE_KEY, 0x24, {KEY_PLAYPAUSE} },
+	{ KE_KEY, 0x25, {KEY_STOPCD} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_WIFI, 0x30 },
+	{ KE_BLUETOOTH, 0x44 },
+	{ KE_END, FE_UNTESTED }
+};
+
+static struct key_entry keymap_wistron_generic[] __initdata = {
+	{ KE_KEY, 0x01, {KEY_HELP} },
+	{ KE_KEY, 0x02, {KEY_CONFIG} },
+	{ KE_KEY, 0x03, {KEY_POWER} },
+	{ KE_KEY, 0x05, {KEY_SWITCHVIDEOMODE} }, /* Display selection */
+	{ KE_KEY, 0x06, {KEY_DISPLAYTOGGLE} }, /* Display on/off */
+	{ KE_KEY, 0x08, {KEY_MUTE} },
+	{ KE_KEY, 0x11, {KEY_PROG1} },
+	{ KE_KEY, 0x12, {KEY_PROG2} },
+	{ KE_KEY, 0x13, {KEY_PROG3} },
+	{ KE_KEY, 0x14, {KEY_MAIL} },
+	{ KE_KEY, 0x15, {KEY_WWW} },
+	{ KE_KEY, 0x20, {KEY_VOLUMEUP} },
+	{ KE_KEY, 0x21, {KEY_VOLUMEDOWN} },
+	{ KE_KEY, 0x22, {KEY_REWIND} },
+	{ KE_KEY, 0x23, {KEY_FORWARD} },
+	{ KE_KEY, 0x24, {KEY_PLAYPAUSE} },
+	{ KE_KEY, 0x25, {KEY_STOPCD} },
+	{ KE_KEY, 0x31, {KEY_MAIL} },
+	{ KE_KEY, 0x36, {KEY_WWW} },
+	{ KE_KEY, 0x37, {KEY_DISPLAYTOGGLE} }, /* Display on/off */
+	{ KE_KEY, 0x40, {KEY_WLAN} },
+	{ KE_KEY, 0x49, {KEY_CONFIG} },
+	{ KE_SW, 0x4a, {.sw = {SW_LID, 1}} }, /* lid close */
+	{ KE_SW, 0x4b, {.sw = {SW_LID, 0}} }, /* lid open */
+	{ KE_KEY, 0x6a, {KEY_CONFIG} },
+	{ KE_KEY, 0x6d, {KEY_POWER} },
+	{ KE_KEY, 0x71, {KEY_STOPCD} },
+	{ KE_KEY, 0x72, {KEY_PLAYPAUSE} },
+	{ KE_KEY, 0x74, {KEY_REWIND} },
+	{ KE_KEY, 0x78, {KEY_FORWARD} },
+	{ KE_WIFI, 0x30 },
+	{ KE_BLUETOOTH, 0x44 },
+	{ KE_END, 0 }
+};
+
+static struct key_entry keymap_aopen_1557[] __initdata = {
+	{ KE_KEY,  0x01, {KEY_HELP} },
+	{ KE_KEY,  0x11, {KEY_PROG1} },
+	{ KE_KEY,  0x12, {KEY_PROG2} },
+	{ KE_WIFI, 0x30 },
+	{ KE_KEY,  0x22, {KEY_REWIND} },
+	{ KE_KEY,  0x23, {KEY_FORWARD} },
+	{ KE_KEY,  0x24, {KEY_PLAYPAUSE} },
+	{ KE_KEY,  0x25, {KEY_STOPCD} },
+	{ KE_KEY,  0x31, {KEY_MAIL} },
+	{ KE_KEY,  0x36, {KEY_WWW} },
+	{ KE_END,  0 }
+};
+
+static struct key_entry keymap_prestigio[] __initdata = {
+	{ KE_KEY,  0x11, {KEY_PROG1} },
+	{ KE_KEY,  0x12, {KEY_PROG2} },
+	{ KE_WIFI, 0x30 },
+	{ KE_KEY,  0x22, {KEY_REWIND} },
+	{ KE_KEY,  0x23, {KEY_FORWARD} },
+	{ KE_KEY,  0x24, {KEY_PLAYPAUSE} },
+	{ KE_KEY,  0x25, {KEY_STOPCD} },
+	{ KE_KEY,  0x31, {KEY_MAIL} },
+	{ KE_KEY,  0x36, {KEY_WWW} },
+	{ KE_END,  0 }
+};
+
+
+/*
+ * If your machine is not here (which is currently rather likely), please send
+ * a list of buttons and their key codes (reported when loading this module
+ * with force=1) and the output of dmidecode to $MODULE_AUTHOR.
+ */
+static const struct dmi_system_id __initconst dmi_ids[] = {
+	{
+		/* Fujitsu-Siemens Amilo Pro V2000 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pro V2000"),
+		},
+		.driver_data = keymap_fs_amilo_pro_v2000
+	},
+	{
+		/* Fujitsu-Siemens Amilo Pro Edition V3505 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pro Edition V3505"),
+		},
+		.driver_data = keymap_fs_amilo_pro_v3505
+	},
+	{
+		/* Fujitsu-Siemens Amilo M7400 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "AMILO M        "),
+		},
+		.driver_data = keymap_fs_amilo_pro_v2000
+	},
+	{
+		/* Maxdata Pro 7000 DX */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "MAXDATA"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "Pro 7000"),
+		},
+		.driver_data = keymap_fs_amilo_pro_v2000
+	},
+	{
+		/* Fujitsu N3510 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "N3510"),
+		},
+		.driver_data = keymap_fujitsu_n3510
+	},
+	{
+		/* Acer Aspire 1500 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1500"),
+		},
+		.driver_data = keymap_acer_aspire_1500
+	},
+	{
+		/* Acer Aspire 1600 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1600"),
+		},
+		.driver_data = keymap_acer_aspire_1600
+	},
+	{
+		/* Acer Aspire 3020 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 3020"),
+		},
+		.driver_data = keymap_acer_aspire_5020
+	},
+	{
+		/* Acer Aspire 5020 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5020"),
+		},
+		.driver_data = keymap_acer_aspire_5020
+	},
+	{
+		/* Acer TravelMate 2100 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2100"),
+		},
+		.driver_data = keymap_acer_aspire_5020
+	},
+	{
+		/* Acer TravelMate 2410 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2410"),
+		},
+		.driver_data = keymap_acer_travelmate_2410
+	},
+	{
+		/* Acer TravelMate C300 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate C300"),
+		},
+		.driver_data = keymap_acer_travelmate_300
+	},
+	{
+		/* Acer TravelMate C100 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate C100"),
+		},
+		.driver_data = keymap_acer_travelmate_300
+	},
+	{
+		/* Acer TravelMate C110 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate C110"),
+		},
+		.driver_data = keymap_acer_travelmate_110
+	},
+	{
+		/* Acer TravelMate 380 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 380"),
+		},
+		.driver_data = keymap_acer_travelmate_380
+	},
+	{
+		/* Acer TravelMate 370 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 370"),
+		},
+		.driver_data = keymap_acer_travelmate_380 /* keyboard minus 1 key */
+	},
+	{
+		/* Acer TravelMate 220 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 220"),
+		},
+		.driver_data = keymap_acer_travelmate_220
+	},
+	{
+		/* Acer TravelMate 260 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 260"),
+		},
+		.driver_data = keymap_acer_travelmate_220
+	},
+	{
+		/* Acer TravelMate 230 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 230"),
+			/* acerhk looks for "TravelMate F4..." ?! */
+		},
+		.driver_data = keymap_acer_travelmate_230
+	},
+	{
+		/* Acer TravelMate 280 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 280"),
+		},
+		.driver_data = keymap_acer_travelmate_230
+	},
+	{
+		/* Acer TravelMate 240 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 240"),
+		},
+		.driver_data = keymap_acer_travelmate_240
+	},
+	{
+		/* Acer TravelMate 250 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 250"),
+		},
+		.driver_data = keymap_acer_travelmate_240
+	},
+	{
+		/* Acer TravelMate 2424NWXCi */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2420"),
+		},
+		.driver_data = keymap_acer_travelmate_240
+	},
+	{
+		/* Acer TravelMate 350 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 350"),
+		},
+		.driver_data = keymap_acer_travelmate_350
+	},
+	{
+		/* Acer TravelMate 360 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 360"),
+		},
+		.driver_data = keymap_acer_travelmate_360
+	},
+	{
+		/* Acer TravelMate 610 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "ACER"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 610"),
+		},
+		.driver_data = keymap_acer_travelmate_610
+	},
+	{
+		/* Acer TravelMate 620 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 620"),
+		},
+		.driver_data = keymap_acer_travelmate_630
+	},
+	{
+		/* Acer TravelMate 630 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 630"),
+		},
+		.driver_data = keymap_acer_travelmate_630
+	},
+	{
+		/* AOpen 1559AS */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_PRODUCT_NAME, "E2U"),
+			DMI_MATCH(DMI_BOARD_NAME, "E2U"),
+		},
+		.driver_data = keymap_aopen_1559as
+	},
+	{
+		/* Medion MD 9783 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "MEDIONNB"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "MD 9783"),
+		},
+		.driver_data = keymap_wistron_ms2111
+	},
+	{
+		/* Medion MD 40100 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "MEDIONNB"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "WID2000"),
+		},
+		.driver_data = keymap_wistron_md40100
+	},
+	{
+		/* Medion MD 2900 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "MEDIONNB"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "WIM 2000"),
+		},
+		.driver_data = keymap_wistron_md2900
+	},
+	{
+		/* Medion MD 42200 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "Medion"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "WIM 2030"),
+		},
+		.driver_data = keymap_fs_amilo_pro_v2000
+	},
+	{
+		/* Medion MD 96500 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "MEDIONPC"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "WIM 2040"),
+		},
+		.driver_data = keymap_wistron_md96500
+	},
+	{
+		/* Medion MD 95400 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "MEDIONPC"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "WIM 2050"),
+		},
+		.driver_data = keymap_wistron_md96500
+	},
+	{
+		/* Fujitsu Siemens Amilo D7820 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), /* not sure */
+			DMI_MATCH(DMI_PRODUCT_NAME, "Amilo D"),
+		},
+		.driver_data = keymap_fs_amilo_d88x0
+	},
+	{
+		/* Fujitsu Siemens Amilo D88x0 */
+		.callback = dmi_matched,
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
+			DMI_MATCH(DMI_PRODUCT_NAME, "AMILO D"),
+		},
+		.driver_data = keymap_fs_amilo_d88x0
+	},
+	{ NULL, }
+};
+
+/* Copy the good keymap, as the original ones are free'd */
+static int __init copy_keymap(void)
+{
+	const struct key_entry *key;
+	struct key_entry *new_keymap;
+	unsigned int length = 1;
+
+	for (key = keymap; key->type != KE_END; key++)
+		length++;
+
+	new_keymap = kmemdup(keymap, length * sizeof(struct key_entry),
+			     GFP_KERNEL);
+	if (!new_keymap)
+		return -ENOMEM;
+
+	keymap = new_keymap;
+
+	return 0;
+}
+
+static int __init select_keymap(void)
+{
+	dmi_check_system(dmi_ids);
+	if (keymap_name != NULL) {
+		if (strcmp (keymap_name, "1557/MS2141") == 0)
+			keymap = keymap_wistron_ms2141;
+		else if (strcmp (keymap_name, "aopen1557") == 0)
+			keymap = keymap_aopen_1557;
+		else if (strcmp (keymap_name, "prestigio") == 0)
+			keymap = keymap_prestigio;
+		else if (strcmp (keymap_name, "generic") == 0)
+			keymap = keymap_wistron_generic;
+		else {
+			printk(KERN_ERR "wistron_btns: Keymap unknown\n");
+			return -EINVAL;
+		}
+	}
+	if (keymap == NULL) {
+		if (!force) {
+			printk(KERN_ERR "wistron_btns: System unknown\n");
+			return -ENODEV;
+		}
+		keymap = keymap_empty;
+	}
+
+	return copy_keymap();
+}
+
+ /* Input layer interface */
+
+static struct input_polled_dev *wistron_idev;
+static unsigned long jiffies_last_press;
+static bool wifi_enabled;
+static bool bluetooth_enabled;
+
+ /* led management */
+static void wistron_mail_led_set(struct led_classdev *led_cdev,
+				enum led_brightness value)
+{
+	bios_set_state(MAIL_LED, (value != LED_OFF) ? 1 : 0);
+}
+
+/* same as setting up wifi card, but for laptops on which the led is managed */
+static void wistron_wifi_led_set(struct led_classdev *led_cdev,
+				enum led_brightness value)
+{
+	bios_set_state(WIFI, (value != LED_OFF) ? 1 : 0);
+}
+
+static struct led_classdev wistron_mail_led = {
+	.name			= "wistron:green:mail",
+	.brightness_set		= wistron_mail_led_set,
+};
+
+static struct led_classdev wistron_wifi_led = {
+	.name			= "wistron:red:wifi",
+	.brightness_set		= wistron_wifi_led_set,
+};
+
+static void wistron_led_init(struct device *parent)
+{
+	if (leds_present & FE_WIFI_LED) {
+		u16 wifi = bios_get_default_setting(WIFI);
+		if (wifi & 1) {
+			wistron_wifi_led.brightness = (wifi & 2) ? LED_FULL : LED_OFF;
+			if (led_classdev_register(parent, &wistron_wifi_led))
+				leds_present &= ~FE_WIFI_LED;
+			else
+				bios_set_state(WIFI, wistron_wifi_led.brightness);
+
+		} else
+			leds_present &= ~FE_WIFI_LED;
+	}
+
+	if (leds_present & FE_MAIL_LED) {
+		/* bios_get_default_setting(MAIL) always retuns 0, so just turn the led off */
+		wistron_mail_led.brightness = LED_OFF;
+		if (led_classdev_register(parent, &wistron_mail_led))
+			leds_present &= ~FE_MAIL_LED;
+		else
+			bios_set_state(MAIL_LED, wistron_mail_led.brightness);
+	}
+}
+
+static void wistron_led_remove(void)
+{
+	if (leds_present & FE_MAIL_LED)
+		led_classdev_unregister(&wistron_mail_led);
+
+	if (leds_present & FE_WIFI_LED)
+		led_classdev_unregister(&wistron_wifi_led);
+}
+
+static inline void wistron_led_suspend(void)
+{
+	if (leds_present & FE_MAIL_LED)
+		led_classdev_suspend(&wistron_mail_led);
+
+	if (leds_present & FE_WIFI_LED)
+		led_classdev_suspend(&wistron_wifi_led);
+}
+
+static inline void wistron_led_resume(void)
+{
+	if (leds_present & FE_MAIL_LED)
+		led_classdev_resume(&wistron_mail_led);
+
+	if (leds_present & FE_WIFI_LED)
+		led_classdev_resume(&wistron_wifi_led);
+}
+
+static void handle_key(u8 code)
+{
+	const struct key_entry *key =
+		sparse_keymap_entry_from_scancode(wistron_idev->input, code);
+
+	if (key) {
+		switch (key->type) {
+		case KE_WIFI:
+			if (have_wifi) {
+				wifi_enabled = !wifi_enabled;
+				bios_set_state(WIFI, wifi_enabled);
+			}
+			break;
+
+		case KE_BLUETOOTH:
+			if (have_bluetooth) {
+				bluetooth_enabled = !bluetooth_enabled;
+				bios_set_state(BLUETOOTH, bluetooth_enabled);
+			}
+			break;
+
+		default:
+			sparse_keymap_report_entry(wistron_idev->input,
+						   key, 1, true);
+			break;
+		}
+		jiffies_last_press = jiffies;
+	} else
+		printk(KERN_NOTICE
+			"wistron_btns: Unknown key code %02X\n", code);
+}
+
+static void poll_bios(bool discard)
+{
+	u8 qlen;
+	u16 val;
+
+	for (;;) {
+		qlen = CMOS_READ(cmos_address);
+		if (qlen == 0)
+			break;
+		val = bios_pop_queue();
+		if (val != 0 && !discard)
+			handle_key((u8)val);
+	}
+}
+
+static void wistron_flush(struct input_polled_dev *dev)
+{
+	/* Flush stale event queue */
+	poll_bios(true);
+}
+
+static void wistron_poll(struct input_polled_dev *dev)
+{
+	poll_bios(false);
+
+	/* Increase poll frequency if user is currently pressing keys (< 2s ago) */
+	if (time_before(jiffies, jiffies_last_press + 2 * HZ))
+		dev->poll_interval = POLL_INTERVAL_BURST;
+	else
+		dev->poll_interval = POLL_INTERVAL_DEFAULT;
+}
+
+static int wistron_setup_keymap(struct input_dev *dev,
+					  struct key_entry *entry)
+{
+	switch (entry->type) {
+
+	/* if wifi or bluetooth are not available, create normal keys */
+	case KE_WIFI:
+		if (!have_wifi) {
+			entry->type = KE_KEY;
+			entry->keycode = KEY_WLAN;
+		}
+		break;
+
+	case KE_BLUETOOTH:
+		if (!have_bluetooth) {
+			entry->type = KE_KEY;
+			entry->keycode = KEY_BLUETOOTH;
+		}
+		break;
+
+	case KE_END:
+		if (entry->code & FE_UNTESTED)
+			printk(KERN_WARNING "Untested laptop multimedia keys, "
+				"please report success or failure to "
+				"eric.piel@tremplin-utc.net\n");
+		break;
+	}
+
+	return 0;
+}
+
+static int setup_input_dev(void)
+{
+	struct input_dev *input_dev;
+	int error;
+
+	wistron_idev = input_allocate_polled_device();
+	if (!wistron_idev)
+		return -ENOMEM;
+
+	wistron_idev->open = wistron_flush;
+	wistron_idev->poll = wistron_poll;
+	wistron_idev->poll_interval = POLL_INTERVAL_DEFAULT;
+
+	input_dev = wistron_idev->input;
+	input_dev->name = "Wistron laptop buttons";
+	input_dev->phys = "wistron/input0";
+	input_dev->id.bustype = BUS_HOST;
+	input_dev->dev.parent = &wistron_device->dev;
+
+	error = sparse_keymap_setup(input_dev, keymap, wistron_setup_keymap);
+	if (error)
+		goto err_free_dev;
+
+	error = input_register_polled_device(wistron_idev);
+	if (error)
+		goto err_free_keymap;
+
+	return 0;
+
+ err_free_keymap:
+	sparse_keymap_free(input_dev);
+ err_free_dev:
+	input_free_polled_device(wistron_idev);
+	return error;
+}
+
+/* Driver core */
+
+static int wistron_probe(struct platform_device *dev)
+{
+	int err;
+
+	bios_attach();
+	cmos_address = bios_get_cmos_address();
+
+	if (have_wifi) {
+		u16 wifi = bios_get_default_setting(WIFI);
+		if (wifi & 1)
+			wifi_enabled = wifi & 2;
+		else
+			have_wifi = 0;
+
+		if (have_wifi)
+			bios_set_state(WIFI, wifi_enabled);
+	}
+
+	if (have_bluetooth) {
+		u16 bt = bios_get_default_setting(BLUETOOTH);
+		if (bt & 1)
+			bluetooth_enabled = bt & 2;
+		else
+			have_bluetooth = false;
+
+		if (have_bluetooth)
+			bios_set_state(BLUETOOTH, bluetooth_enabled);
+	}
+
+	wistron_led_init(&dev->dev);
+
+	err = setup_input_dev();
+	if (err) {
+		bios_detach();
+		return err;
+	}
+
+	return 0;
+}
+
+static int wistron_remove(struct platform_device *dev)
+{
+	wistron_led_remove();
+	input_unregister_polled_device(wistron_idev);
+	sparse_keymap_free(wistron_idev->input);
+	input_free_polled_device(wistron_idev);
+	bios_detach();
+
+	return 0;
+}
+
+#ifdef CONFIG_PM
+static int wistron_suspend(struct device *dev)
+{
+	if (have_wifi)
+		bios_set_state(WIFI, 0);
+
+	if (have_bluetooth)
+		bios_set_state(BLUETOOTH, 0);
+
+	wistron_led_suspend();
+
+	return 0;
+}
+
+static int wistron_resume(struct device *dev)
+{
+	if (have_wifi)
+		bios_set_state(WIFI, wifi_enabled);
+
+	if (have_bluetooth)
+		bios_set_state(BLUETOOTH, bluetooth_enabled);
+
+	wistron_led_resume();
+
+	poll_bios(true);
+
+	return 0;
+}
+
+static const struct dev_pm_ops wistron_pm_ops = {
+	.suspend	= wistron_suspend,
+	.resume		= wistron_resume,
+	.poweroff	= wistron_suspend,
+	.restore	= wistron_resume,
+};
+#endif
+
+static struct platform_driver wistron_driver = {
+	.driver		= {
+		.name	= "wistron-bios",
+		.owner	= THIS_MODULE,
+#ifdef CONFIG_PM
+		.pm	= &wistron_pm_ops,
+#endif
+	},
+	.probe		= wistron_probe,
+	.remove		= wistron_remove,
+};
+
+static int __init wb_module_init(void)
+{
+	int err;
+
+	err = select_keymap();
+	if (err)
+		return err;
+
+	err = map_bios();
+	if (err)
+		goto err_free_keymap;
+
+	err = platform_driver_register(&wistron_driver);
+	if (err)
+		goto err_unmap_bios;
+
+	wistron_device = platform_device_alloc("wistron-bios", -1);
+	if (!wistron_device) {
+		err = -ENOMEM;
+		goto err_unregister_driver;
+	}
+
+	err = platform_device_add(wistron_device);
+	if (err)
+		goto err_free_device;
+
+	return 0;
+
+ err_free_device:
+	platform_device_put(wistron_device);
+ err_unregister_driver:
+	platform_driver_unregister(&wistron_driver);
+ err_unmap_bios:
+	unmap_bios();
+ err_free_keymap:
+	kfree(keymap);
+
+	return err;
+}
+
+static void __exit wb_module_exit(void)
+{
+	platform_device_unregister(wistron_device);
+	platform_driver_unregister(&wistron_driver);
+	unmap_bios();
+	kfree(keymap);
+}
+
+module_init(wb_module_init);
+module_exit(wb_module_exit);
diff --git a/drivers/input/misc/wm831x-on.c b/drivers/input/misc/wm831x-on.c
new file mode 100644
index 00000000..caa2c406
--- /dev/null
+++ b/drivers/input/misc/wm831x-on.c
@@ -0,0 +1,151 @@
+/**
+ * wm831x-on.c - WM831X ON pin driver
+ *
+ * Copyright (C) 2009 Wolfson Microelectronics plc
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License. See the file "COPYING" in the main directory of this
+ * archive for more details.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+#include <linux/mfd/wm831x/core.h>
+
+struct wm831x_on {
+	struct input_dev *dev;
+	struct delayed_work work;
+	struct wm831x *wm831x;
+};
+
+/*
+ * The chip gives us an interrupt when the ON pin is asserted but we
+ * then need to poll to see when the pin is deasserted.
+ */
+static void wm831x_poll_on(struct work_struct *work)
+{
+	struct wm831x_on *wm831x_on = container_of(work, struct wm831x_on,
+						   work.work);
+	struct wm831x *wm831x = wm831x_on->wm831x;
+	int poll, ret;
+
+	ret = wm831x_reg_read(wm831x, WM831X_ON_PIN_CONTROL);
+	if (ret >= 0) {
+		poll = !(ret & WM831X_ON_PIN_STS);
+
+		input_report_key(wm831x_on->dev, KEY_POWER, poll);
+		input_sync(wm831x_on->dev);
+	} else {
+		dev_err(wm831x->dev, "Failed to read ON status: %d\n", ret);
+		poll = 1;
+	}
+
+	if (poll)
+		schedule_delayed_work(&wm831x_on->work, 100);
+}
+
+static irqreturn_t wm831x_on_irq(int irq, void *data)
+{
+	struct wm831x_on *wm831x_on = data;
+
+	schedule_delayed_work(&wm831x_on->work, 0);
+
+	return IRQ_HANDLED;
+}
+
+static int wm831x_on_probe(struct platform_device *pdev)
+{
+	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+	struct wm831x_on *wm831x_on;
+	int irq = wm831x_irq(wm831x, platform_get_irq(pdev, 0));
+	int ret;
+
+	wm831x_on = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_on),
+				 GFP_KERNEL);
+	if (!wm831x_on) {
+		dev_err(&pdev->dev, "Can't allocate data\n");
+		return -ENOMEM;
+	}
+
+	wm831x_on->wm831x = wm831x;
+	INIT_DELAYED_WORK(&wm831x_on->work, wm831x_poll_on);
+
+	wm831x_on->dev = devm_input_allocate_device(&pdev->dev);
+	if (!wm831x_on->dev) {
+		dev_err(&pdev->dev, "Can't allocate input dev\n");
+		ret = -ENOMEM;
+		goto err;
+	}
+
+	wm831x_on->dev->evbit[0] = BIT_MASK(EV_KEY);
+	wm831x_on->dev->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
+	wm831x_on->dev->name = "wm831x_on";
+	wm831x_on->dev->phys = "wm831x_on/input0";
+	wm831x_on->dev->dev.parent = &pdev->dev;
+
+	ret = request_threaded_irq(irq, NULL, wm831x_on_irq,
+				   IRQF_TRIGGER_RISING, "wm831x_on",
+				   wm831x_on);
+	if (ret < 0) {
+		dev_err(&pdev->dev, "Unable to request IRQ: %d\n", ret);
+		goto err_input_dev;
+	}
+	ret = input_register_device(wm831x_on->dev);
+	if (ret) {
+		dev_dbg(&pdev->dev, "Can't register input device: %d\n", ret);
+		goto err_irq;
+	}
+
+	platform_set_drvdata(pdev, wm831x_on);
+
+	return 0;
+
+err_irq:
+	free_irq(irq, wm831x_on);
+err_input_dev:
+err:
+	return ret;
+}
+
+static int wm831x_on_remove(struct platform_device *pdev)
+{
+	struct wm831x_on *wm831x_on = platform_get_drvdata(pdev);
+	int irq = platform_get_irq(pdev, 0);
+
+	free_irq(irq, wm831x_on);
+	cancel_delayed_work_sync(&wm831x_on->work);
+
+	return 0;
+}
+
+static struct platform_driver wm831x_on_driver = {
+	.probe		= wm831x_on_probe,
+	.remove		= wm831x_on_remove,
+	.driver		= {
+		.name	= "wm831x-on",
+		.owner	= THIS_MODULE,
+	},
+};
+module_platform_driver(wm831x_on_driver);
+
+MODULE_ALIAS("platform:wm831x-on");
+MODULE_DESCRIPTION("WM831x ON pin");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+
diff --git a/drivers/input/misc/xen-kbdfront.c b/drivers/input/misc/xen-kbdfront.c
new file mode 100644
index 00000000..e21c1816
--- /dev/null
+++ b/drivers/input/misc/xen-kbdfront.c
@@ -0,0 +1,396 @@
+/*
+ * Xen para-virtual input device
+ *
+ * Copyright (C) 2005 Anthony Liguori <aliguori@us.ibm.com>
+ * Copyright (C) 2006-2008 Red Hat, Inc., Markus Armbruster <armbru@redhat.com>
+ *
+ *  Based on linux/drivers/input/mouse/sermouse.c
+ *
+ *  This file is subject to the terms and conditions of the GNU General Public
+ *  License. See the file COPYING in the main directory of this archive for
+ *  more details.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/module.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+
+#include <asm/xen/hypervisor.h>
+
+#include <xen/xen.h>
+#include <xen/events.h>
+#include <xen/page.h>
+#include <xen/grant_table.h>
+#include <xen/interface/grant_table.h>
+#include <xen/interface/io/fbif.h>
+#include <xen/interface/io/kbdif.h>
+#include <xen/xenbus.h>
+
+struct xenkbd_info {
+	struct input_dev *kbd;
+	struct input_dev *ptr;
+	struct xenkbd_page *page;
+	int gref;
+	int irq;
+	struct xenbus_device *xbdev;
+	char phys[32];
+};
+
+static int xenkbd_remove(struct xenbus_device *);
+static int xenkbd_connect_backend(struct xenbus_device *, struct xenkbd_info *);
+static void xenkbd_disconnect_backend(struct xenkbd_info *);
+
+/*
+ * Note: if you need to send out events, see xenfb_do_update() for how
+ * to do that.
+ */
+
+static irqreturn_t input_handler(int rq, void *dev_id)
+{
+	struct xenkbd_info *info = dev_id;
+	struct xenkbd_page *page = info->page;
+	__u32 cons, prod;
+
+	prod = page->in_prod;
+	if (prod == page->in_cons)
+		return IRQ_HANDLED;
+	rmb();			/* ensure we see ring contents up to prod */
+	for (cons = page->in_cons; cons != prod; cons++) {
+		union xenkbd_in_event *event;
+		struct input_dev *dev;
+		event = &XENKBD_IN_RING_REF(page, cons);
+
+		dev = info->ptr;
+		switch (event->type) {
+		case XENKBD_TYPE_MOTION:
+			input_report_rel(dev, REL_X, event->motion.rel_x);
+			input_report_rel(dev, REL_Y, event->motion.rel_y);
+			if (event->motion.rel_z)
+				input_report_rel(dev, REL_WHEEL,
+						 -event->motion.rel_z);
+			break;
+		case XENKBD_TYPE_KEY:
+			dev = NULL;
+			if (test_bit(event->key.keycode, info->kbd->keybit))
+				dev = info->kbd;
+			if (test_bit(event->key.keycode, info->ptr->keybit))
+				dev = info->ptr;
+			if (dev)
+				input_report_key(dev, event->key.keycode,
+						 event->key.pressed);
+			else
+				pr_warning("unhandled keycode 0x%x\n",
+					   event->key.keycode);
+			break;
+		case XENKBD_TYPE_POS:
+			input_report_abs(dev, ABS_X, event->pos.abs_x);
+			input_report_abs(dev, ABS_Y, event->pos.abs_y);
+			if (event->pos.rel_z)
+				input_report_rel(dev, REL_WHEEL,
+						 -event->pos.rel_z);
+			break;
+		}
+		if (dev)
+			input_sync(dev);
+	}
+	mb();			/* ensure we got ring contents */
+	page->in_cons = cons;
+	notify_remote_via_irq(info->irq);
+
+	return IRQ_HANDLED;
+}
+
+static int xenkbd_probe(struct xenbus_device *dev,
+				  const struct xenbus_device_id *id)
+{
+	int ret, i, abs;
+	struct xenkbd_info *info;
+	struct input_dev *kbd, *ptr;
+
+	info = kzalloc(sizeof(*info), GFP_KERNEL);
+	if (!info) {
+		xenbus_dev_fatal(dev, -ENOMEM, "allocating info structure");
+		return -ENOMEM;
+	}
+	dev_set_drvdata(&dev->dev, info);
+	info->xbdev = dev;
+	info->irq = -1;
+	info->gref = -1;
+	snprintf(info->phys, sizeof(info->phys), "xenbus/%s", dev->nodename);
+
+	info->page = (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
+	if (!info->page)
+		goto error_nomem;
+
+	if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-abs-pointer", "%d", &abs) < 0)
+		abs = 0;
+	if (abs)
+		xenbus_printf(XBT_NIL, dev->nodename, "request-abs-pointer", "1");
+
+	/* keyboard */
+	kbd = input_allocate_device();
+	if (!kbd)
+		goto error_nomem;
+	kbd->name = "Xen Virtual Keyboard";
+	kbd->phys = info->phys;
+	kbd->id.bustype = BUS_PCI;
+	kbd->id.vendor = 0x5853;
+	kbd->id.product = 0xffff;
+
+	__set_bit(EV_KEY, kbd->evbit);
+	for (i = KEY_ESC; i < KEY_UNKNOWN; i++)
+		__set_bit(i, kbd->keybit);
+	for (i = KEY_OK; i < KEY_MAX; i++)
+		__set_bit(i, kbd->keybit);
+
+	ret = input_register_device(kbd);
+	if (ret) {
+		input_free_device(kbd);
+		xenbus_dev_fatal(dev, ret, "input_register_device(kbd)");
+		goto error;
+	}
+	info->kbd = kbd;
+
+	/* pointing device */
+	ptr = input_allocate_device();
+	if (!ptr)
+		goto error_nomem;
+	ptr->name = "Xen Virtual Pointer";
+	ptr->phys = info->phys;
+	ptr->id.bustype = BUS_PCI;
+	ptr->id.vendor = 0x5853;
+	ptr->id.product = 0xfffe;
+
+	if (abs) {
+		__set_bit(EV_ABS, ptr->evbit);
+		input_set_abs_params(ptr, ABS_X, 0, XENFB_WIDTH, 0, 0);
+		input_set_abs_params(ptr, ABS_Y, 0, XENFB_HEIGHT, 0, 0);
+	} else {
+		input_set_capability(ptr, EV_REL, REL_X);
+		input_set_capability(ptr, EV_REL, REL_Y);
+	}
+	input_set_capability(ptr, EV_REL, REL_WHEEL);
+
+	__set_bit(EV_KEY, ptr->evbit);
+	for (i = BTN_LEFT; i <= BTN_TASK; i++)
+		__set_bit(i, ptr->keybit);
+
+	ret = input_register_device(ptr);
+	if (ret) {
+		input_free_device(ptr);
+		xenbus_dev_fatal(dev, ret, "input_register_device(ptr)");
+		goto error;
+	}
+	info->ptr = ptr;
+
+	ret = xenkbd_connect_backend(dev, info);
+	if (ret < 0)
+		goto error;
+
+	return 0;
+
+ error_nomem:
+	ret = -ENOMEM;
+	xenbus_dev_fatal(dev, ret, "allocating device memory");
+ error:
+	xenkbd_remove(dev);
+	return ret;
+}
+
+static int xenkbd_resume(struct xenbus_device *dev)
+{
+	struct xenkbd_info *info = dev_get_drvdata(&dev->dev);
+
+	xenkbd_disconnect_backend(info);
+	memset(info->page, 0, PAGE_SIZE);
+	return xenkbd_connect_backend(dev, info);
+}
+
+static int xenkbd_remove(struct xenbus_device *dev)
+{
+	struct xenkbd_info *info = dev_get_drvdata(&dev->dev);
+
+	xenkbd_disconnect_backend(info);
+	if (info->kbd)
+		input_unregister_device(info->kbd);
+	if (info->ptr)
+		input_unregister_device(info->ptr);
+	free_page((unsigned long)info->page);
+	kfree(info);
+	return 0;
+}
+
+static int xenkbd_connect_backend(struct xenbus_device *dev,
+				  struct xenkbd_info *info)
+{
+	int ret, evtchn;
+	struct xenbus_transaction xbt;
+
+	ret = gnttab_grant_foreign_access(dev->otherend_id,
+	                                  virt_to_mfn(info->page), 0);
+	if (ret < 0)
+		return ret;
+	info->gref = ret;
+
+	ret = xenbus_alloc_evtchn(dev, &evtchn);
+	if (ret)
+		goto error_grant;
+	ret = bind_evtchn_to_irqhandler(evtchn, input_handler,
+					0, dev->devicetype, info);
+	if (ret < 0) {
+		xenbus_dev_fatal(dev, ret, "bind_evtchn_to_irqhandler");
+		goto error_evtchan;
+	}
+	info->irq = ret;
+
+ again:
+	ret = xenbus_transaction_start(&xbt);
+	if (ret) {
+		xenbus_dev_fatal(dev, ret, "starting transaction");
+		goto error_irqh;
+	}
+	ret = xenbus_printf(xbt, dev->nodename, "page-ref", "%lu",
+			    virt_to_mfn(info->page));
+	if (ret)
+		goto error_xenbus;
+	ret = xenbus_printf(xbt, dev->nodename, "page-gref", "%u", info->gref);
+	if (ret)
+		goto error_xenbus;
+	ret = xenbus_printf(xbt, dev->nodename, "event-channel", "%u",
+			    evtchn);
+	if (ret)
+		goto error_xenbus;
+	ret = xenbus_transaction_end(xbt, 0);
+	if (ret) {
+		if (ret == -EAGAIN)
+			goto again;
+		xenbus_dev_fatal(dev, ret, "completing transaction");
+		goto error_irqh;
+	}
+
+	xenbus_switch_state(dev, XenbusStateInitialised);
+	return 0;
+
+ error_xenbus:
+	xenbus_transaction_end(xbt, 1);
+	xenbus_dev_fatal(dev, ret, "writing xenstore");
+ error_irqh:
+	unbind_from_irqhandler(info->irq, info);
+	info->irq = -1;
+ error_evtchan:
+	xenbus_free_evtchn(dev, evtchn);
+ error_grant:
+	gnttab_end_foreign_access_ref(info->gref, 0);
+	info->gref = -1;
+	return ret;
+}
+
+static void xenkbd_disconnect_backend(struct xenkbd_info *info)
+{
+	if (info->irq >= 0)
+		unbind_from_irqhandler(info->irq, info);
+	info->irq = -1;
+	if (info->gref >= 0)
+		gnttab_end_foreign_access_ref(info->gref, 0);
+	info->gref = -1;
+}
+
+static void xenkbd_backend_changed(struct xenbus_device *dev,
+				   enum xenbus_state backend_state)
+{
+	struct xenkbd_info *info = dev_get_drvdata(&dev->dev);
+	int ret, val;
+
+	switch (backend_state) {
+	case XenbusStateInitialising:
+	case XenbusStateInitialised:
+	case XenbusStateReconfiguring:
+	case XenbusStateReconfigured:
+	case XenbusStateUnknown:
+		break;
+
+	case XenbusStateInitWait:
+InitWait:
+		ret = xenbus_scanf(XBT_NIL, info->xbdev->otherend,
+				   "feature-abs-pointer", "%d", &val);
+		if (ret < 0)
+			val = 0;
+		if (val) {
+			ret = xenbus_printf(XBT_NIL, info->xbdev->nodename,
+					    "request-abs-pointer", "1");
+			if (ret)
+				pr_warning("xenkbd: can't request abs-pointer");
+		}
+
+		xenbus_switch_state(dev, XenbusStateConnected);
+		break;
+
+	case XenbusStateConnected:
+		/*
+		 * Work around xenbus race condition: If backend goes
+		 * through InitWait to Connected fast enough, we can
+		 * get Connected twice here.
+		 */
+		if (dev->state != XenbusStateConnected)
+			goto InitWait; /* no InitWait seen yet, fudge it */
+
+		/* Set input abs params to match backend screen res */
+		if (xenbus_scanf(XBT_NIL, info->xbdev->otherend,
+				 "width", "%d", &val) > 0)
+			input_set_abs_params(info->ptr, ABS_X, 0, val, 0, 0);
+
+		if (xenbus_scanf(XBT_NIL, info->xbdev->otherend,
+				 "height", "%d", &val) > 0)
+			input_set_abs_params(info->ptr, ABS_Y, 0, val, 0, 0);
+
+		break;
+
+	case XenbusStateClosed:
+		if (dev->state == XenbusStateClosed)
+			break;
+		/* Missed the backend's CLOSING state -- fallthrough */
+	case XenbusStateClosing:
+		xenbus_frontend_closed(dev);
+		break;
+	}
+}
+
+static const struct xenbus_device_id xenkbd_ids[] = {
+	{ "vkbd" },
+	{ "" }
+};
+
+static DEFINE_XENBUS_DRIVER(xenkbd, ,
+	.probe = xenkbd_probe,
+	.remove = xenkbd_remove,
+	.resume = xenkbd_resume,
+	.otherend_changed = xenkbd_backend_changed,
+);
+
+static int __init xenkbd_init(void)
+{
+	if (!xen_domain())
+		return -ENODEV;
+
+	/* Nothing to do if running in dom0. */
+	if (xen_initial_domain())
+		return -ENODEV;
+
+	return xenbus_register_frontend(&xenkbd_driver);
+}
+
+static void __exit xenkbd_cleanup(void)
+{
+	xenbus_unregister_driver(&xenkbd_driver);
+}
+
+module_init(xenkbd_init);
+module_exit(xenkbd_cleanup);
+
+MODULE_DESCRIPTION("Xen virtual keyboard/pointer device frontend");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("xen:vkbd");
diff --git a/drivers/input/misc/yealink.c b/drivers/input/misc/yealink.c
new file mode 100644
index 00000000..285a5bd6
--- /dev/null
+++ b/drivers/input/misc/yealink.c
@@ -0,0 +1,1008 @@
+/*
+ * drivers/usb/input/yealink.c
+ *
+ * Copyright (c) 2005 Henk Vergonet <Henk.Vergonet@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+/*
+ * Description:
+ *   Driver for the USB-P1K voip usb phone.
+ *   This device is produced by Yealink Network Technology Co Ltd
+ *   but may be branded under several names:
+ *	- Yealink usb-p1k
+ *	- Tiptel 115
+ *	- ...
+ *
+ * This driver is based on:
+ *   - the usbb2k-api	http://savannah.nongnu.org/projects/usbb2k-api/
+ *   - information from	http://memeteau.free.fr/usbb2k
+ *   - the xpad-driver	drivers/input/joystick/xpad.c
+ *
+ * Thanks to:
+ *   - Olivier Vandorpe, for providing the usbb2k-api.
+ *   - Martin Diehl, for spotting my memory allocation bug.
+ *
+ * History:
+ *   20050527 henk	First version, functional keyboard. Keyboard events
+ *			will pop-up on the ../input/eventX bus.
+ *   20050531 henk	Added led, LCD, dialtone and sysfs interface.
+ *   20050610 henk	Cleanups, make it ready for public consumption.
+ *   20050630 henk	Cleanups, fixes in response to comments.
+ *   20050701 henk	sysfs write serialisation, fix potential unload races
+ *   20050801 henk	Added ringtone, restructure USB
+ *   20050816 henk	Merge 2.6.13-rc6
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/rwsem.h>
+#include <linux/usb/input.h>
+#include <linux/map_to_7segment.h>
+
+#include "yealink.h"
+
+#define DRIVER_VERSION "yld-20051230"
+#define DRIVER_AUTHOR "Henk Vergonet"
+#define DRIVER_DESC "Yealink phone driver"
+
+#define YEALINK_POLLING_FREQUENCY	10	/* in [Hz] */
+
+struct yld_status {
+	u8	lcd[24];
+	u8	led;
+	u8	dialtone;
+	u8	ringtone;
+	u8	keynum;
+} __attribute__ ((packed));
+
+/*
+ * Register the LCD segment and icon map
+ */
+#define _LOC(k,l)	{ .a = (k), .m = (l) }
+#define _SEG(t, a, am, b, bm, c, cm, d, dm, e, em, f, fm, g, gm)	\
+	{ .type	= (t),							\
+	  .u = { .s = {	_LOC(a, am), _LOC(b, bm), _LOC(c, cm),		\
+		        _LOC(d, dm), _LOC(e, em), _LOC(g, gm),		\
+			_LOC(f, fm) } } }
+#define _PIC(t, h, hm, n)						\
+	{ .type	= (t),							\
+ 	  .u = { .p = { .name = (n), .a = (h), .m = (hm) } } }
+
+static const struct lcd_segment_map {
+	char	type;
+	union {
+		struct pictogram_map {
+			u8	a,m;
+			char	name[10];
+		}	p;
+		struct segment_map {
+			u8	a,m;
+		} s[7];
+	} u;
+} lcdMap[] = {
+#include "yealink.h"
+};
+
+struct yealink_dev {
+	struct input_dev *idev;		/* input device */
+	struct usb_device *udev;	/* usb device */
+	struct usb_interface *intf;	/* usb interface */
+
+	/* irq input channel */
+	struct yld_ctl_packet	*irq_data;
+	dma_addr_t		irq_dma;
+	struct urb		*urb_irq;
+
+	/* control output channel */
+	struct yld_ctl_packet	*ctl_data;
+	dma_addr_t		ctl_dma;
+	struct usb_ctrlrequest	*ctl_req;
+	struct urb		*urb_ctl;
+
+	char phys[64];			/* physical device path */
+
+	u8 lcdMap[ARRAY_SIZE(lcdMap)];	/* state of LCD, LED ... */
+	int key_code;			/* last reported key	 */
+
+	unsigned int shutdown:1;
+
+	int	stat_ix;
+	union {
+		struct yld_status s;
+		u8		  b[sizeof(struct yld_status)];
+	} master, copy;
+};
+
+
+/*******************************************************************************
+ * Yealink lcd interface
+ ******************************************************************************/
+
+/*
+ * Register a default 7 segment character set
+ */
+static SEG7_DEFAULT_MAP(map_seg7);
+
+ /* Display a char,
+  * char '\9' and '\n' are placeholders and do not overwrite the original text.
+  * A space will always hide an icon.
+  */
+static int setChar(struct yealink_dev *yld, int el, int chr)
+{
+	int i, a, m, val;
+
+	if (el >= ARRAY_SIZE(lcdMap))
+		return -EINVAL;
+
+	if (chr == '\t' || chr == '\n')
+	    return 0;
+
+	yld->lcdMap[el] = chr;
+
+	if (lcdMap[el].type == '.') {
+		a = lcdMap[el].u.p.a;
+		m = lcdMap[el].u.p.m;
+		if (chr != ' ')
+			yld->master.b[a] |= m;
+		else
+			yld->master.b[a] &= ~m;
+		return 0;
+	}
+
+	val = map_to_seg7(&map_seg7, chr);
+	for (i = 0; i < ARRAY_SIZE(lcdMap[0].u.s); i++) {
+		m = lcdMap[el].u.s[i].m;
+
+		if (m == 0)
+			continue;
+
+		a = lcdMap[el].u.s[i].a;
+		if (val & 1)
+			yld->master.b[a] |= m;
+		else
+			yld->master.b[a] &= ~m;
+		val = val >> 1;
+	}
+	return 0;
+};
+
+/*******************************************************************************
+ * Yealink key interface
+ ******************************************************************************/
+
+/* Map device buttons to internal key events.
+ *
+ * USB-P1K button layout:
+ *
+ *             up
+ *       IN           OUT
+ *            down
+ *
+ *     pickup   C    hangup
+ *       1      2      3
+ *       4      5      6
+ *       7      8      9
+ *       *      0      #
+ *
+ * The "up" and "down" keys, are symbolised by arrows on the button.
+ * The "pickup" and "hangup" keys are symbolised by a green and red phone
+ * on the button.
+ */
+static int map_p1k_to_key(int scancode)
+{
+	switch(scancode) {		/* phone key:	*/
+	case 0x23: return KEY_LEFT;	/*   IN		*/
+	case 0x33: return KEY_UP;	/*   up		*/
+	case 0x04: return KEY_RIGHT;	/*   OUT	*/
+	case 0x24: return KEY_DOWN;	/*   down	*/
+	case 0x03: return KEY_ENTER;	/*   pickup	*/
+	case 0x14: return KEY_BACKSPACE; /*  C		*/
+	case 0x13: return KEY_ESC;	/*   hangup	*/
+	case 0x00: return KEY_1;	/*   1		*/
+	case 0x01: return KEY_2;	/*   2 		*/
+	case 0x02: return KEY_3;	/*   3		*/
+	case 0x10: return KEY_4;	/*   4		*/
+	case 0x11: return KEY_5;	/*   5		*/
+	case 0x12: return KEY_6;	/*   6		*/
+	case 0x20: return KEY_7;	/*   7		*/
+	case 0x21: return KEY_8;	/*   8		*/
+	case 0x22: return KEY_9;	/*   9		*/
+	case 0x30: return KEY_KPASTERISK; /* *		*/
+	case 0x31: return KEY_0;	/*   0		*/
+	case 0x32: return KEY_LEFTSHIFT |
+			  KEY_3 << 8;	/*   #		*/
+	}
+	return -EINVAL;
+}
+
+/* Completes a request by converting the data into events for the
+ * input subsystem.
+ *
+ * The key parameter can be cascaded: key2 << 8 | key1
+ */
+static void report_key(struct yealink_dev *yld, int key)
+{
+	struct input_dev *idev = yld->idev;
+
+	if (yld->key_code >= 0) {
+		/* old key up */
+		input_report_key(idev, yld->key_code & 0xff, 0);
+		if (yld->key_code >> 8)
+			input_report_key(idev, yld->key_code >> 8, 0);
+	}
+
+	yld->key_code = key;
+	if (key >= 0) {
+		/* new valid key */
+		input_report_key(idev, key & 0xff, 1);
+		if (key >> 8)
+			input_report_key(idev, key >> 8, 1);
+	}
+	input_sync(idev);
+}
+
+/*******************************************************************************
+ * Yealink usb communication interface
+ ******************************************************************************/
+
+static int yealink_cmd(struct yealink_dev *yld, struct yld_ctl_packet *p)
+{
+	u8	*buf = (u8 *)p;
+	int	i;
+	u8	sum = 0;
+
+	for(i=0; i<USB_PKT_LEN-1; i++)
+		sum -= buf[i];
+	p->sum = sum;
+	return usb_control_msg(yld->udev,
+			usb_sndctrlpipe(yld->udev, 0),
+			USB_REQ_SET_CONFIGURATION,
+			USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
+			0x200, 3,
+			p, sizeof(*p),
+			USB_CTRL_SET_TIMEOUT);
+}
+
+static u8 default_ringtone[] = {
+	0xEF,			/* volume [0-255] */
+	0xFB, 0x1E, 0x00, 0x0C,	/* 1250 [hz], 12/100 [s] */
+	0xFC, 0x18, 0x00, 0x0C,	/* 1000 [hz], 12/100 [s] */
+	0xFB, 0x1E, 0x00, 0x0C,
+	0xFC, 0x18, 0x00, 0x0C,
+	0xFB, 0x1E, 0x00, 0x0C,
+	0xFC, 0x18, 0x00, 0x0C,
+	0xFB, 0x1E, 0x00, 0x0C,
+	0xFC, 0x18, 0x00, 0x0C,
+	0xFF, 0xFF, 0x01, 0x90,	/* silent, 400/100 [s] */
+	0x00, 0x00		/* end of sequence */
+};
+
+static int yealink_set_ringtone(struct yealink_dev *yld, u8 *buf, size_t size)
+{
+	struct yld_ctl_packet *p = yld->ctl_data;
+	int	ix, len;
+
+	if (size <= 0)
+		return -EINVAL;
+
+	/* Set the ringtone volume */
+	memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
+	yld->ctl_data->cmd	= CMD_RING_VOLUME;
+	yld->ctl_data->size	= 1;
+	yld->ctl_data->data[0]	= buf[0];
+	yealink_cmd(yld, p);
+
+	buf++;
+	size--;
+
+	p->cmd = CMD_RING_NOTE;
+	ix = 0;
+	while (size != ix) {
+		len = size - ix;
+		if (len > sizeof(p->data))
+			len = sizeof(p->data);
+		p->size	  = len;
+		p->offset = cpu_to_be16(ix);
+		memcpy(p->data, &buf[ix], len);
+		yealink_cmd(yld, p);
+		ix += len;
+	}
+	return 0;
+}
+
+/* keep stat_master & stat_copy in sync.
+ */
+static int yealink_do_idle_tasks(struct yealink_dev *yld)
+{
+	u8 val;
+	int i, ix, len;
+
+	ix = yld->stat_ix;
+
+	memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
+	yld->ctl_data->cmd  = CMD_KEYPRESS;
+	yld->ctl_data->size = 1;
+	yld->ctl_data->sum  = 0xff - CMD_KEYPRESS;
+
+	/* If state update pointer wraps do a KEYPRESS first. */
+	if (ix >= sizeof(yld->master)) {
+		yld->stat_ix = 0;
+		return 0;
+	}
+
+	/* find update candidates: copy != master */
+	do {
+		val = yld->master.b[ix];
+		if (val != yld->copy.b[ix])
+			goto send_update;
+	} while (++ix < sizeof(yld->master));
+
+	/* nothing todo, wait a bit and poll for a KEYPRESS */
+	yld->stat_ix = 0;
+	/* TODO how can we wait abit. ??
+	 * msleep_interruptible(1000 / YEALINK_POLLING_FREQUENCY);
+	 */
+	return 0;
+
+send_update:
+
+	/* Setup an appropriate update request */
+	yld->copy.b[ix] = val;
+	yld->ctl_data->data[0] = val;
+
+	switch(ix) {
+	case offsetof(struct yld_status, led):
+		yld->ctl_data->cmd	= CMD_LED;
+		yld->ctl_data->sum	= -1 - CMD_LED - val;
+		break;
+	case offsetof(struct yld_status, dialtone):
+		yld->ctl_data->cmd	= CMD_DIALTONE;
+		yld->ctl_data->sum	= -1 - CMD_DIALTONE - val;
+		break;
+	case offsetof(struct yld_status, ringtone):
+		yld->ctl_data->cmd	= CMD_RINGTONE;
+		yld->ctl_data->sum	= -1 - CMD_RINGTONE - val;
+		break;
+	case offsetof(struct yld_status, keynum):
+		val--;
+		val &= 0x1f;
+		yld->ctl_data->cmd	= CMD_SCANCODE;
+		yld->ctl_data->offset	= cpu_to_be16(val);
+		yld->ctl_data->data[0]	= 0;
+		yld->ctl_data->sum	= -1 - CMD_SCANCODE - val;
+		break;
+	default:
+		len = sizeof(yld->master.s.lcd) - ix;
+		if (len > sizeof(yld->ctl_data->data))
+			len = sizeof(yld->ctl_data->data);
+
+		/* Combine up to <len> consecutive LCD bytes in a singe request
+		 */
+		yld->ctl_data->cmd	= CMD_LCD;
+		yld->ctl_data->offset	= cpu_to_be16(ix);
+		yld->ctl_data->size	= len;
+		yld->ctl_data->sum	= -CMD_LCD - ix - val - len;
+		for(i=1; i<len; i++) {
+			ix++;
+			val = yld->master.b[ix];
+			yld->copy.b[ix]		= val;
+			yld->ctl_data->data[i]	= val;
+			yld->ctl_data->sum     -= val;
+		}
+	}
+	yld->stat_ix = ix + 1;
+	return 1;
+}
+
+/* Decide on how to handle responses
+ *
+ * The state transition diagram is somethhing like:
+ *
+ *          syncState<--+
+ *               |      |
+ *               |    idle
+ *              \|/     |
+ * init --ok--> waitForKey --ok--> getKey
+ *  ^               ^                |
+ *  |               +-------ok-------+
+ * error,start
+ *
+ */
+static void urb_irq_callback(struct urb *urb)
+{
+	struct yealink_dev *yld = urb->context;
+	int ret, status = urb->status;
+
+	if (status)
+		dev_err(&yld->intf->dev, "%s - urb status %d\n",
+			__func__, status);
+
+	switch (yld->irq_data->cmd) {
+	case CMD_KEYPRESS:
+
+		yld->master.s.keynum = yld->irq_data->data[0];
+		break;
+
+	case CMD_SCANCODE:
+		dev_dbg(&yld->intf->dev, "get scancode %x\n",
+			yld->irq_data->data[0]);
+
+		report_key(yld, map_p1k_to_key(yld->irq_data->data[0]));
+		break;
+
+	default:
+		dev_err(&yld->intf->dev, "unexpected response %x\n",
+			yld->irq_data->cmd);
+	}
+
+	yealink_do_idle_tasks(yld);
+
+	if (!yld->shutdown) {
+		ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
+		if (ret && ret != -EPERM)
+			dev_err(&yld->intf->dev,
+				"%s - usb_submit_urb failed %d\n",
+				__func__, ret);
+	}
+}
+
+static void urb_ctl_callback(struct urb *urb)
+{
+	struct yealink_dev *yld = urb->context;
+	int ret = 0, status = urb->status;
+
+	if (status)
+		dev_err(&yld->intf->dev, "%s - urb status %d\n",
+			__func__, status);
+
+	switch (yld->ctl_data->cmd) {
+	case CMD_KEYPRESS:
+	case CMD_SCANCODE:
+		/* ask for a response */
+		if (!yld->shutdown)
+			ret = usb_submit_urb(yld->urb_irq, GFP_ATOMIC);
+		break;
+	default:
+		/* send new command */
+		yealink_do_idle_tasks(yld);
+		if (!yld->shutdown)
+			ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
+		break;
+	}
+
+	if (ret && ret != -EPERM)
+		dev_err(&yld->intf->dev, "%s - usb_submit_urb failed %d\n",
+			__func__, ret);
+}
+
+/*******************************************************************************
+ * input event interface
+ ******************************************************************************/
+
+/* TODO should we issue a ringtone on a SND_BELL event?
+static int input_ev(struct input_dev *dev, unsigned int type,
+		unsigned int code, int value)
+{
+
+	if (type != EV_SND)
+		return -EINVAL;
+
+	switch (code) {
+	case SND_BELL:
+	case SND_TONE:
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+*/
+
+static int input_open(struct input_dev *dev)
+{
+	struct yealink_dev *yld = input_get_drvdata(dev);
+	int i, ret;
+
+	dev_dbg(&yld->intf->dev, "%s\n", __func__);
+
+	/* force updates to device */
+	for (i = 0; i<sizeof(yld->master); i++)
+		yld->copy.b[i] = ~yld->master.b[i];
+	yld->key_code = -1;	/* no keys pressed */
+
+        yealink_set_ringtone(yld, default_ringtone, sizeof(default_ringtone));
+
+	/* issue INIT */
+	memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
+	yld->ctl_data->cmd	= CMD_INIT;
+	yld->ctl_data->size	= 10;
+	yld->ctl_data->sum	= 0x100-CMD_INIT-10;
+	if ((ret = usb_submit_urb(yld->urb_ctl, GFP_KERNEL)) != 0) {
+		dev_dbg(&yld->intf->dev,
+			"%s - usb_submit_urb failed with result %d\n",
+			__func__, ret);
+		return ret;
+	}
+	return 0;
+}
+
+static void input_close(struct input_dev *dev)
+{
+	struct yealink_dev *yld = input_get_drvdata(dev);
+
+	yld->shutdown = 1;
+	/*
+	 * Make sure the flag is seen by other CPUs before we start
+	 * killing URBs so new URBs won't be submitted
+	 */
+	smp_wmb();
+
+	usb_kill_urb(yld->urb_ctl);
+	usb_kill_urb(yld->urb_irq);
+
+	yld->shutdown = 0;
+	smp_wmb();
+}
+
+/*******************************************************************************
+ * sysfs interface
+ ******************************************************************************/
+
+static DECLARE_RWSEM(sysfs_rwsema);
+
+/* Interface to the 7-segments translation table aka. char set.
+ */
+static ssize_t show_map(struct device *dev, struct device_attribute *attr,
+				char *buf)
+{
+	memcpy(buf, &map_seg7, sizeof(map_seg7));
+	return sizeof(map_seg7);
+}
+
+static ssize_t store_map(struct device *dev, struct device_attribute *attr,
+				const char *buf, size_t cnt)
+{
+	if (cnt != sizeof(map_seg7))
+		return -EINVAL;
+	memcpy(&map_seg7, buf, sizeof(map_seg7));
+	return sizeof(map_seg7);
+}
+
+/* Interface to the LCD.
+ */
+
+/* Reading /sys/../lineX will return the format string with its settings:
+ *
+ * Example:
+ * cat ./line3
+ * 888888888888
+ * Linux Rocks!
+ */
+static ssize_t show_line(struct device *dev, char *buf, int a, int b)
+{
+	struct yealink_dev *yld;
+	int i;
+
+	down_read(&sysfs_rwsema);
+	yld = dev_get_drvdata(dev);
+	if (yld == NULL) {
+		up_read(&sysfs_rwsema);
+		return -ENODEV;
+	}
+
+	for (i = a; i < b; i++)
+		*buf++ = lcdMap[i].type;
+	*buf++ = '\n';
+	for (i = a; i < b; i++)
+		*buf++ = yld->lcdMap[i];
+	*buf++ = '\n';
+	*buf = 0;
+
+	up_read(&sysfs_rwsema);
+	return 3 + ((b - a) << 1);
+}
+
+static ssize_t show_line1(struct device *dev, struct device_attribute *attr,
+			char *buf)
+{
+	return show_line(dev, buf, LCD_LINE1_OFFSET, LCD_LINE2_OFFSET);
+}
+
+static ssize_t show_line2(struct device *dev, struct device_attribute *attr,
+			char *buf)
+{
+	return show_line(dev, buf, LCD_LINE2_OFFSET, LCD_LINE3_OFFSET);
+}
+
+static ssize_t show_line3(struct device *dev, struct device_attribute *attr,
+			char *buf)
+{
+	return show_line(dev, buf, LCD_LINE3_OFFSET, LCD_LINE4_OFFSET);
+}
+
+/* Writing to /sys/../lineX will set the coresponding LCD line.
+ * - Excess characters are ignored.
+ * - If less characters are written than allowed, the remaining digits are
+ *   unchanged.
+ * - The '\n' or '\t' char is a placeholder, it does not overwrite the
+ *   original content.
+ */
+static ssize_t store_line(struct device *dev, const char *buf, size_t count,
+		int el, size_t len)
+{
+	struct yealink_dev *yld;
+	int i;
+
+	down_write(&sysfs_rwsema);
+	yld = dev_get_drvdata(dev);
+	if (yld == NULL) {
+		up_write(&sysfs_rwsema);
+		return -ENODEV;
+	}
+
+	if (len > count)
+		len = count;
+	for (i = 0; i < len; i++)
+		setChar(yld, el++, buf[i]);
+
+	up_write(&sysfs_rwsema);
+	return count;
+}
+
+static ssize_t store_line1(struct device *dev, struct device_attribute *attr,
+				const char *buf, size_t count)
+{
+	return store_line(dev, buf, count, LCD_LINE1_OFFSET, LCD_LINE1_SIZE);
+}
+
+static ssize_t store_line2(struct device *dev, struct device_attribute *attr,
+				const char *buf, size_t count)
+{
+	return store_line(dev, buf, count, LCD_LINE2_OFFSET, LCD_LINE2_SIZE);
+}
+
+static ssize_t store_line3(struct device *dev, struct device_attribute *attr,
+				const char *buf, size_t count)
+{
+	return store_line(dev, buf, count, LCD_LINE3_OFFSET, LCD_LINE3_SIZE);
+}
+
+/* Interface to visible and audible "icons", these include:
+ * pictures on the LCD, the LED, and the dialtone signal.
+ */
+
+/* Get a list of "switchable elements" with their current state. */
+static ssize_t get_icons(struct device *dev, struct device_attribute *attr,
+			char *buf)
+{
+	struct yealink_dev *yld;
+	int i, ret = 1;
+
+	down_read(&sysfs_rwsema);
+	yld = dev_get_drvdata(dev);
+	if (yld == NULL) {
+		up_read(&sysfs_rwsema);
+		return -ENODEV;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(lcdMap); i++) {
+		if (lcdMap[i].type != '.')
+			continue;
+		ret += sprintf(&buf[ret], "%s %s\n",
+				yld->lcdMap[i] == ' ' ? "  " : "on",
+				lcdMap[i].u.p.name);
+	}
+	up_read(&sysfs_rwsema);
+	return ret;
+}
+
+/* Change the visibility of a particular element. */
+static ssize_t set_icon(struct device *dev, const char *buf, size_t count,
+			int chr)
+{
+	struct yealink_dev *yld;
+	int i;
+
+	down_write(&sysfs_rwsema);
+	yld = dev_get_drvdata(dev);
+	if (yld == NULL) {
+		up_write(&sysfs_rwsema);
+		return -ENODEV;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(lcdMap); i++) {
+		if (lcdMap[i].type != '.')
+			continue;
+		if (strncmp(buf, lcdMap[i].u.p.name, count) == 0) {
+			setChar(yld, i, chr);
+			break;
+		}
+	}
+
+	up_write(&sysfs_rwsema);
+	return count;
+}
+
+static ssize_t show_icon(struct device *dev, struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	return set_icon(dev, buf, count, buf[0]);
+}
+
+static ssize_t hide_icon(struct device *dev, struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	return set_icon(dev, buf, count, ' ');
+}
+
+/* Upload a ringtone to the device.
+ */
+
+/* Stores raw ringtone data in the phone */
+static ssize_t store_ringtone(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	struct yealink_dev *yld;
+
+	down_write(&sysfs_rwsema);
+	yld = dev_get_drvdata(dev);
+	if (yld == NULL) {
+		up_write(&sysfs_rwsema);
+		return -ENODEV;
+	}
+
+	/* TODO locking with async usb control interface??? */
+	yealink_set_ringtone(yld, (char *)buf, count);
+	up_write(&sysfs_rwsema);
+	return count;
+}
+
+#define _M444	S_IRUGO
+#define _M664	S_IRUGO|S_IWUSR|S_IWGRP
+#define _M220	S_IWUSR|S_IWGRP
+
+static DEVICE_ATTR(map_seg7	, _M664, show_map	, store_map	);
+static DEVICE_ATTR(line1	, _M664, show_line1	, store_line1	);
+static DEVICE_ATTR(line2	, _M664, show_line2	, store_line2	);
+static DEVICE_ATTR(line3	, _M664, show_line3	, store_line3	);
+static DEVICE_ATTR(get_icons	, _M444, get_icons	, NULL		);
+static DEVICE_ATTR(show_icon	, _M220, NULL		, show_icon	);
+static DEVICE_ATTR(hide_icon	, _M220, NULL		, hide_icon	);
+static DEVICE_ATTR(ringtone	, _M220, NULL		, store_ringtone);
+
+static struct attribute *yld_attributes[] = {
+	&dev_attr_line1.attr,
+	&dev_attr_line2.attr,
+	&dev_attr_line3.attr,
+	&dev_attr_get_icons.attr,
+	&dev_attr_show_icon.attr,
+	&dev_attr_hide_icon.attr,
+	&dev_attr_map_seg7.attr,
+	&dev_attr_ringtone.attr,
+	NULL
+};
+
+static struct attribute_group yld_attr_group = {
+	.attrs = yld_attributes
+};
+
+/*******************************************************************************
+ * Linux interface and usb initialisation
+ ******************************************************************************/
+
+struct driver_info {
+	char *name;
+};
+
+static const struct driver_info info_P1K = {
+	.name	= "Yealink usb-p1k",
+};
+
+static const struct usb_device_id usb_table [] = {
+	{
+		.match_flags		= USB_DEVICE_ID_MATCH_DEVICE |
+						USB_DEVICE_ID_MATCH_INT_INFO,
+		.idVendor		= 0x6993,
+		.idProduct		= 0xb001,
+		.bInterfaceClass	= USB_CLASS_HID,
+		.bInterfaceSubClass	= 0,
+		.bInterfaceProtocol	= 0,
+		.driver_info		= (kernel_ulong_t)&info_P1K
+	},
+	{ }
+};
+
+static int usb_cleanup(struct yealink_dev *yld, int err)
+{
+	if (yld == NULL)
+		return err;
+
+        if (yld->idev) {
+		if (err)
+			input_free_device(yld->idev);
+		else
+			input_unregister_device(yld->idev);
+	}
+
+	usb_free_urb(yld->urb_irq);
+	usb_free_urb(yld->urb_ctl);
+
+	kfree(yld->ctl_req);
+	usb_free_coherent(yld->udev, USB_PKT_LEN, yld->ctl_data, yld->ctl_dma);
+	usb_free_coherent(yld->udev, USB_PKT_LEN, yld->irq_data, yld->irq_dma);
+
+	kfree(yld);
+	return err;
+}
+
+static void usb_disconnect(struct usb_interface *intf)
+{
+	struct yealink_dev *yld;
+
+	down_write(&sysfs_rwsema);
+	yld = usb_get_intfdata(intf);
+	sysfs_remove_group(&intf->dev.kobj, &yld_attr_group);
+	usb_set_intfdata(intf, NULL);
+	up_write(&sysfs_rwsema);
+
+	usb_cleanup(yld, 0);
+}
+
+static int usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
+{
+	struct usb_device *udev = interface_to_usbdev (intf);
+	struct driver_info *nfo = (struct driver_info *)id->driver_info;
+	struct usb_host_interface *interface;
+	struct usb_endpoint_descriptor *endpoint;
+	struct yealink_dev *yld;
+	struct input_dev *input_dev;
+	int ret, pipe, i;
+
+	interface = intf->cur_altsetting;
+	endpoint = &interface->endpoint[0].desc;
+	if (!usb_endpoint_is_int_in(endpoint))
+		return -ENODEV;
+
+	yld = kzalloc(sizeof(struct yealink_dev), GFP_KERNEL);
+	if (!yld)
+		return -ENOMEM;
+
+	yld->udev = udev;
+	yld->intf = intf;
+
+	yld->idev = input_dev = input_allocate_device();
+	if (!input_dev)
+		return usb_cleanup(yld, -ENOMEM);
+
+	/* allocate usb buffers */
+	yld->irq_data = usb_alloc_coherent(udev, USB_PKT_LEN,
+					   GFP_ATOMIC, &yld->irq_dma);
+	if (yld->irq_data == NULL)
+		return usb_cleanup(yld, -ENOMEM);
+
+	yld->ctl_data = usb_alloc_coherent(udev, USB_PKT_LEN,
+					   GFP_ATOMIC, &yld->ctl_dma);
+	if (!yld->ctl_data)
+		return usb_cleanup(yld, -ENOMEM);
+
+	yld->ctl_req = kmalloc(sizeof(*(yld->ctl_req)), GFP_KERNEL);
+	if (yld->ctl_req == NULL)
+		return usb_cleanup(yld, -ENOMEM);
+
+	/* allocate urb structures */
+	yld->urb_irq = usb_alloc_urb(0, GFP_KERNEL);
+        if (yld->urb_irq == NULL)
+		return usb_cleanup(yld, -ENOMEM);
+
+	yld->urb_ctl = usb_alloc_urb(0, GFP_KERNEL);
+        if (yld->urb_ctl == NULL)
+		return usb_cleanup(yld, -ENOMEM);
+
+	/* get a handle to the interrupt data pipe */
+	pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);
+	ret = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
+	if (ret != USB_PKT_LEN)
+		dev_err(&intf->dev, "invalid payload size %d, expected %zd\n",
+			ret, USB_PKT_LEN);
+
+	/* initialise irq urb */
+	usb_fill_int_urb(yld->urb_irq, udev, pipe, yld->irq_data,
+			USB_PKT_LEN,
+			urb_irq_callback,
+			yld, endpoint->bInterval);
+	yld->urb_irq->transfer_dma = yld->irq_dma;
+	yld->urb_irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+	yld->urb_irq->dev = udev;
+
+	/* initialise ctl urb */
+	yld->ctl_req->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE |
+				      USB_DIR_OUT;
+	yld->ctl_req->bRequest	= USB_REQ_SET_CONFIGURATION;
+	yld->ctl_req->wValue	= cpu_to_le16(0x200);
+	yld->ctl_req->wIndex	= cpu_to_le16(interface->desc.bInterfaceNumber);
+	yld->ctl_req->wLength	= cpu_to_le16(USB_PKT_LEN);
+
+	usb_fill_control_urb(yld->urb_ctl, udev, usb_sndctrlpipe(udev, 0),
+			(void *)yld->ctl_req, yld->ctl_data, USB_PKT_LEN,
+			urb_ctl_callback, yld);
+	yld->urb_ctl->transfer_dma	= yld->ctl_dma;
+	yld->urb_ctl->transfer_flags	|= URB_NO_TRANSFER_DMA_MAP;
+	yld->urb_ctl->dev = udev;
+
+	/* find out the physical bus location */
+	usb_make_path(udev, yld->phys, sizeof(yld->phys));
+	strlcat(yld->phys,  "/input0", sizeof(yld->phys));
+
+	/* register settings for the input device */
+	input_dev->name = nfo->name;
+	input_dev->phys = yld->phys;
+	usb_to_input_id(udev, &input_dev->id);
+	input_dev->dev.parent = &intf->dev;
+
+	input_set_drvdata(input_dev, yld);
+
+	input_dev->open = input_open;
+	input_dev->close = input_close;
+	/* input_dev->event = input_ev;	TODO */
+
+	/* register available key events */
+	input_dev->evbit[0] = BIT_MASK(EV_KEY);
+	for (i = 0; i < 256; i++) {
+		int k = map_p1k_to_key(i);
+		if (k >= 0) {
+			set_bit(k & 0xff, input_dev->keybit);
+			if (k >> 8)
+				set_bit(k >> 8, input_dev->keybit);
+		}
+	}
+
+	ret = input_register_device(yld->idev);
+	if (ret)
+		return usb_cleanup(yld, ret);
+
+	usb_set_intfdata(intf, yld);
+
+	/* clear visible elements */
+	for (i = 0; i < ARRAY_SIZE(lcdMap); i++)
+		setChar(yld, i, ' ');
+
+	/* display driver version on LCD line 3 */
+	store_line3(&intf->dev, NULL,
+			DRIVER_VERSION, sizeof(DRIVER_VERSION));
+
+	/* Register sysfs hooks (don't care about failure) */
+	ret = sysfs_create_group(&intf->dev.kobj, &yld_attr_group);
+	return 0;
+}
+
+static struct usb_driver yealink_driver = {
+	.name		= "yealink",
+	.probe		= usb_probe,
+	.disconnect	= usb_disconnect,
+	.id_table	= usb_table,
+};
+
+module_usb_driver(yealink_driver);
+
+MODULE_DEVICE_TABLE (usb, usb_table);
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/yealink.h b/drivers/input/misc/yealink.h
new file mode 100644
index 00000000..1e0f5239
--- /dev/null
+++ b/drivers/input/misc/yealink.h
@@ -0,0 +1,220 @@
+/*
+ * drivers/usb/input/yealink.h
+ *
+ * Copyright (c) 2005 Henk Vergonet <Henk.Vergonet@gmail.com>
+ *
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#ifndef INPUT_YEALINK_H
+#define INPUT_YEALINK_H
+
+/* Using the control channel on interface 3 various aspects of the phone
+ * can be controlled like LCD, LED, dialtone and the ringtone.
+ */
+
+struct yld_ctl_packet {
+	u8	cmd;		/* command code, see below */
+	u8	size;		/* 1-11, size of used data bytes. */
+	u16	offset;		/* internal packet offset */
+	u8	data[11];
+	s8	sum;		/* negative sum of 15 preceding bytes */
+} __attribute__ ((packed));
+
+#define USB_PKT_LEN	sizeof(struct yld_ctl_packet)
+
+/* The following yld_ctl_packet's are available: */
+
+/* Init registers
+ *
+ * cmd		0x8e
+ * size		10
+ * offset	0
+ * data		0,0,0,0....
+ */
+#define CMD_INIT		0x8e
+
+/* Request key scan
+ *
+ * cmd		0x80
+ * size		1
+ * offset	0
+ * data[0]	on return returns the key number, if it changes there's a new
+ * 		key pressed.
+ */
+#define CMD_KEYPRESS		0x80
+
+/* Request scancode
+ *
+ * cmd		0x81
+ * size		1
+ * offset	key number [0-1f]
+ * data[0]	on return returns the scancode
+ */
+#define CMD_SCANCODE		0x81
+
+/* Set LCD
+ *
+ * cmd		0x04
+ * size		1-11
+ * offset	0-23
+ * data		segment bits
+ */
+#define CMD_LCD			0x04
+
+/* Set led
+ *
+ * cmd		0x05
+ * size		1
+ * offset	0
+ * data[0]	0 OFF / 1 ON
+ */
+#define CMD_LED			0x05
+
+/* Set ringtone volume
+ *
+ * cmd		0x11
+ * size		1
+ * offset	0
+ * data[0]	0-0xff  volume
+ */
+#define CMD_RING_VOLUME		0x11
+
+/* Set ringtone notes
+ *
+ * cmd		0x02
+ * size		1-11
+ * offset	0->
+ * data		binary representation LE16(-freq), LE16(duration) ....
+ */
+#define CMD_RING_NOTE		0x02
+
+/* Sound ringtone via the speaker on the back
+ *
+ * cmd		0x03
+ * size		1
+ * offset	0
+ * data[0]	0 OFF / 0x24 ON
+ */
+#define CMD_RINGTONE		0x03
+
+/* Sound dial tone via the ear speaker
+ *
+ * cmd		0x09
+ * size		1
+ * offset	0
+ * data[0]	0 OFF / 1 ON
+ */
+#define CMD_DIALTONE		0x09
+
+#endif /* INPUT_YEALINK_H */
+
+
+#if defined(_SEG) && defined(_PIC)
+/* This table maps the LCD segments onto individual bit positions in the
+ * yld_status struct.
+ */
+
+/* LCD, each segment must be driven separately.
+ *
+ * Layout:
+ *
+ *   |[]   [][]   [][]   [][]   in   |[][]
+ *   |[] M [][] D [][] : [][]   out  |[][]
+ *                             store
+ *
+ *    NEW REP         SU MO TU WE TH FR SA
+ *
+ *    [] [] [] [] [] [] [] [] [] [] [] []
+ *    [] [] [] [] [] [] [] [] [] [] [] []
+ */
+
+/* Line 1
+ *	Format		: 18.e8.M8.88...188
+ *	Icon names	: M D : IN OUT STORE
+ */
+#define LCD_LINE1_OFFSET	0
+#define LCD_LINE1_SIZE		17
+
+/* Note: first g then f =>			       !      !      */
+/* _SEG(    type    a      b      c      d      e      g      f   )  */
+	_SEG('1',  0,0 , 22,2 , 22,2 ,  0,0 ,  0,0 ,  0,0 ,  0,0	),
+	_SEG('8', 20,1 , 20,2 , 20,4 , 20,8 , 21,4 , 21,2 , 21,1	),
+	_PIC('.', 22,1 , "M"						),
+	_SEG('e', 18,1 , 18,2 , 18,4 , 18,1 , 19,2 , 18,1 , 19,1	),
+	_SEG('8', 16,1 , 16,2 , 16,4 , 16,8 , 17,4 , 17,2 , 17,1	),
+	_PIC('.', 15,8 , "D"						),
+	_SEG('M', 14,1 , 14,2 , 14,4 , 14,1 , 15,4 , 15,2 , 15,1	),
+	_SEG('8', 12,1 , 12,2 , 12,4 , 12,8 , 13,4 , 13,2 , 13,1	),
+	_PIC('.', 11,8 , ":"						),
+	_SEG('8', 10,1 , 10,2 , 10,4 , 10,8 , 11,4 , 11,2 , 11,1	),
+	_SEG('8',  8,1 ,  8,2 ,  8,4 ,  8,8 ,  9,4 ,  9,2 ,  9,1	),
+	_PIC('.',  7,1 , "IN"						),
+	_PIC('.',  7,2 , "OUT"						),
+	_PIC('.',  7,4 , "STORE"					),
+	_SEG('1',  0,0 ,  5,1 ,  5,1 ,  0,0 ,  0,0 ,  0,0 ,  0,0	),
+	_SEG('8',  4,1 ,  4,2 ,  4,4 ,  4,8 ,  5,8 ,  5,4 ,  5,2	),
+	_SEG('8',  2,1 ,  2,2 ,  2,4 ,  2,8 ,  3,4 ,  3,2 ,  3,1	),
+
+/* Line 2
+ *	Format		: .........
+ *	Pict. name	: NEW REP SU MO TU WE TH FR SA
+ */
+#define LCD_LINE2_OFFSET	LCD_LINE1_OFFSET + LCD_LINE1_SIZE
+#define LCD_LINE2_SIZE		9
+
+	_PIC('.', 23,2 , "NEW"	),
+	_PIC('.', 23,4 , "REP"	),
+	_PIC('.',  1,8 , "SU"	),
+	_PIC('.',  1,4 , "MO"	),
+	_PIC('.',  1,2 , "TU"	),
+	_PIC('.',  1,1 , "WE"	),
+	_PIC('.',  0,1 , "TH"	),
+	_PIC('.',  0,2 , "FR"	),
+	_PIC('.',  0,4 , "SA"	),
+
+/* Line 3
+ *	Format		: 888888888888
+ */
+#define LCD_LINE3_OFFSET	LCD_LINE2_OFFSET + LCD_LINE2_SIZE
+#define LCD_LINE3_SIZE		12
+
+	_SEG('8', 22,16, 22,32, 22,64, 22,128, 23,128, 23,64, 23,32  ),
+	_SEG('8', 20,16, 20,32, 20,64, 20,128, 21,128, 21,64, 21,32  ),
+	_SEG('8', 18,16, 18,32, 18,64, 18,128, 19,128, 19,64, 19,32  ),
+	_SEG('8', 16,16, 16,32, 16,64, 16,128, 17,128, 17,64, 17,32  ),
+	_SEG('8', 14,16, 14,32, 14,64, 14,128, 15,128, 15,64, 15,32  ),
+	_SEG('8', 12,16, 12,32, 12,64, 12,128, 13,128, 13,64, 13,32  ),
+	_SEG('8', 10,16, 10,32, 10,64, 10,128, 11,128, 11,64, 11,32  ),
+	_SEG('8',  8,16,  8,32,  8,64,  8,128,  9,128,  9,64,  9,32  ),
+	_SEG('8',  6,16,  6,32,  6,64,  6,128,  7,128,  7,64,  7,32  ),
+	_SEG('8',  4,16,  4,32,  4,64,  4,128,  5,128,  5,64,  5,32  ),
+	_SEG('8',  2,16,  2,32,  2,64,  2,128,  3,128,  3,64,  3,32  ),
+	_SEG('8',  0,16,  0,32,  0,64,  0,128,  1,128,  1,64,  1,32  ),
+
+/* Line 4
+ *
+ * The LED, DIALTONE and RINGTONE are implemented as icons and use the same
+ * sysfs interface.
+ */
+#define LCD_LINE4_OFFSET	LCD_LINE3_OFFSET + LCD_LINE3_SIZE
+
+	_PIC('.', offsetof(struct yld_status, led)	, 0x01, "LED" ),
+	_PIC('.', offsetof(struct yld_status, dialtone) , 0x01, "DIALTONE" ),
+	_PIC('.', offsetof(struct yld_status, ringtone) , 0x24, "RINGTONE" ),
+
+#undef _SEG
+#undef _PIC
+#endif /* _SEG && _PIC */