build/patch/kernel/sun8i-default/matrix-support-Matrix-starter-kit.patch

From 9d43538162796100f16026a6ee26d826dd82320f Mon Sep 17 00:00:00 2001
From: wwd <ericrock@foxmail.com>
Date: Mon, 16 May 2016 13:20:02 +0800
Subject: [PATCH] matrix: support Matrix starter kit

---
 arch/arm/configs/sun8iw7p1smp_defconfig  | 204 +++++++++++-
 arch/arm/mach-sunxi/sun8i.c              |  55 ++++
 drivers/char/Kconfig                     |  24 ++
 drivers/char/Makefile                    |   5 +
 drivers/char/matrix_gpio_int.c           | 309 +++++++++++++++++
 drivers/char/matrix_hcsr04.c             | 184 +++++++++++
 drivers/char/matrix_pwm.c                | 206 ++++++++++++
 drivers/char/matrix_rotary_encoder.c     | 205 ++++++++++++
 drivers/input/misc/adxl34x.c             |  33 +-
 drivers/staging/iio/Kconfig              |   1 +
 drivers/staging/iio/Makefile             |   1 +
 drivers/staging/iio/humidity/Kconfig     |  15 +
 drivers/staging/iio/humidity/Makefile    |   5 +
 drivers/staging/iio/humidity/dht11.c     | 366 +++++++++++++++++++++
 drivers/staging/iio/industrialio-core.c  |   1 +
 drivers/staging/iio/types.h              |   1 +
 drivers/w1/masters/Makefile              |   2 +-
 drivers/w1/masters/w1-gpio-board.c       |  59 ++++
 drivers/w1/masters/w1-gpio.c             |  13 +-
 .../sun8iw7p1/configs/nanopi-h3/sys_config.fex     |   9 +-
 21 files changed, 1684 insertions(+), 28 deletions(-)
 create mode 100644 drivers/char/matrix_gpio_int.c
 create mode 100644 drivers/char/matrix_hcsr04.c
 create mode 100644 drivers/char/matrix_pwm.c
 create mode 100644 drivers/char/matrix_rotary_encoder.c
 create mode 100644 drivers/staging/iio/humidity/Kconfig
 create mode 100644 drivers/staging/iio/humidity/Makefile
 create mode 100644 drivers/staging/iio/humidity/dht11.c
 create mode 100644 drivers/w1/masters/w1-gpio-board.c

diff --git a/arch/arm/configs/sun8iw7p1smp_defconfig b/arch/arm/configs/sun8iw7p1smp_defconfig
index bc86f3d..8cec706 100644
--- a/arch/arm/configs/sun8iw7p1smp_defconfig
+++ b/arch/arm/configs/sun8iw7p1smp_defconfig
@@ -1079,7 +1079,7 @@ CONFIG_BLK_DEV_CRYPTOLOOP=y
 # CONFIG_DS1682 is not set
 # CONFIG_TI_DAC7512 is not set
 CONFIG_UID_STAT=y
-# CONFIG_BMP085 is not set
+CONFIG_BMP085=m
 # CONFIG_USB_SWITCH_FSA9480 is not set
 # CONFIG_SUNXI_BROM_READ is not set
 # CONFIG_C2PORT is not set
@@ -1396,7 +1396,9 @@ CONFIG_INPUT_UINPUT=y
 # CONFIG_INPUT_GPIO is not set
 # CONFIG_INPUT_PCF8574 is not set
 # CONFIG_INPUT_GPIO_ROTARY_ENCODER is not set
-# CONFIG_INPUT_ADXL34X is not set
+CONFIG_INPUT_ADXL34X=m
+CONFIG_INPUT_ADXL34X_I2C=m
+# CONFIG_INPUT_ADXL34X_SPI is not set
 # CONFIG_INPUT_CMA3000 is not set
 # CONFIG_INPUT_SHAFT_ENCODER is not set
 
@@ -1461,6 +1463,10 @@ CONFIG_SERIAL_SUNXI_CONSOLE=y
 # CONFIG_DCC_TTY is not set
 # CONFIG_RAMOOPS is not set
 # CONFIG_SUNXI_D7S is not set
+CONFIG_MATRIX_GPIO_INT=m
+CONFIG_MATRIX_PWM=m
+CONFIG_MATRIX_ROTARY_ENCODER=m
+CONFIG_MATRIX_HCSR04=m
 # CONFIG_IR_CUT is not set
 CONFIG_SUNXI_CMATESET=y
 # CONFIG_SUNXI_ARISC_TEST is not set
@@ -1475,7 +1481,7 @@ CONFIG_SUNXI_SOC_INFO=y
 CONFIG_I2C=y
 CONFIG_I2C_BOARDINFO=y
 CONFIG_I2C_COMPAT=y
-# CONFIG_I2C_CHARDEV is not set
+CONFIG_I2C_CHARDEV=y
 # CONFIG_I2C_MUX is not set
 CONFIG_I2C_HELPER_AUTO=y
 CONFIG_I2C_ALGOBIT=y
@@ -1530,7 +1536,7 @@ CONFIG_SPI_SUNXI=y
 #
 # SPI Protocol Masters
 #
-# CONFIG_SPI_SPIDEV is not set
+CONFIG_SPI_SPIDEV=y
 # CONFIG_SPI_TLE62X0 is not set
 # CONFIG_HSI is not set
 
@@ -1602,7 +1608,29 @@ CONFIG_GPIO_SYSFS=y
 # MODULbus GPIO expanders:
 #
 CONFIG_GPIO_SUNXI=m
-# CONFIG_W1 is not set
+CONFIG_W1=y
+
+#
+# 1-wire Bus Masters
+#
+# CONFIG_W1_MASTER_DS2490 is not set
+# CONFIG_W1_MASTER_DS2482 is not set
+# CONFIG_W1_MASTER_DS1WM is not set
+CONFIG_W1_MASTER_GPIO=m
+
+#
+# 1-wire Slaves
+#
+CONFIG_W1_SLAVE_THERM=y
+# CONFIG_W1_SLAVE_SMEM is not set
+# CONFIG_W1_SLAVE_DS2408 is not set
+# CONFIG_W1_SLAVE_DS2423 is not set
+# CONFIG_W1_SLAVE_DS2431 is not set
+# CONFIG_W1_SLAVE_DS2433 is not set
+# CONFIG_W1_SLAVE_DS2760 is not set
+# CONFIG_W1_SLAVE_DS2780 is not set
+# CONFIG_W1_SLAVE_DS2781 is not set
+# CONFIG_W1_SLAVE_BQ27000 is not set
 # CONFIG_POWER_SUPPLY is not set
 CONFIG_HWMON=y
 # CONFIG_HWMON_VID is not set
@@ -1677,7 +1705,7 @@ CONFIG_HWMON=y
 # CONFIG_SENSORS_NTC_THERMISTOR is not set
 # CONFIG_SENSORS_PC87360 is not set
 # CONFIG_SENSORS_PC87427 is not set
-# CONFIG_SENSORS_PCF8591 is not set
+CONFIG_SENSORS_PCF8591=m
 # CONFIG_PMBUS is not set
 # CONFIG_DA380 is not set
 # CONFIG_SENSORS_SHT15 is not set
@@ -1809,7 +1837,8 @@ CONFIG_BCMA_POSSIBLE=y
 # CONFIG_MFD_AAT2870_CORE is not set
 # CONFIG_MFD_RC5T583 is not set
 # CONFIG_REGULATOR is not set
-# CONFIG_PWM is not set
+CONFIG_PWM=y
+CONFIG_PWM_SUNXI=y
 CONFIG_MEDIA_SUPPORT=y
 
 #
@@ -2574,7 +2603,7 @@ CONFIG_RTC_INTF_DEV=y
 #
 # I2C RTC drivers
 #
-# CONFIG_RTC_DRV_DS1307 is not set
+CONFIG_RTC_DRV_DS1307=m
 # CONFIG_RTC_DRV_DS1374 is not set
 # CONFIG_RTC_DRV_DS1672 is not set
 # CONFIG_RTC_DRV_DS3232 is not set
@@ -2658,7 +2687,164 @@ CONFIG_SUNXI_DMA=y
 #
 # Microsoft Hyper-V guest support
 #
-# CONFIG_STAGING is not set
+CONFIG_STAGING=y
+# CONFIG_USBIP_CORE is not set
+# CONFIG_ECHO is not set
+# CONFIG_ASUS_OLED is not set
+# CONFIG_RTLLIB is not set
+# CONFIG_R8712U is not set
+# CONFIG_RTS5139 is not set
+# CONFIG_TRANZPORT is not set
+# CONFIG_LINE6_USB is not set
+# CONFIG_USB_SERIAL_QUATECH2 is not set
+# CONFIG_USB_SERIAL_QUATECH_USB2 is not set
+# CONFIG_VT6656 is not set
+CONFIG_IIO=y
+# CONFIG_IIO_ST_HWMON is not set
+# CONFIG_IIO_BUFFER is not set
+# CONFIG_IIO_TRIGGER is not set
+
+#
+# Accelerometers
+#
+# CONFIG_ADIS16201 is not set
+# CONFIG_ADIS16203 is not set
+# CONFIG_ADIS16204 is not set
+# CONFIG_ADIS16209 is not set
+# CONFIG_ADIS16220 is not set
+# CONFIG_ADIS16240 is not set
+# CONFIG_KXSD9 is not set
+# CONFIG_LIS3L02DQ is not set
+
+#
+# Analog to digital converters
+#
+# CONFIG_AD7291 is not set
+# CONFIG_AD7298 is not set
+# CONFIG_AD7606 is not set
+# CONFIG_AD799X is not set
+# CONFIG_AD7476 is not set
+# CONFIG_AD7887 is not set
+# CONFIG_AD7780 is not set
+# CONFIG_AD7793 is not set
+# CONFIG_AD7816 is not set
+# CONFIG_AD7192 is not set
+# CONFIG_ADT7310 is not set
+# CONFIG_ADT7410 is not set
+# CONFIG_AD7280 is not set
+# CONFIG_MAX1363 is not set
+
+#
+# Analog digital bi-direction converters
+#
+# CONFIG_ADT7316 is not set
+
+#
+# Capacitance to digital converters
+#
+# CONFIG_AD7150 is not set
+# CONFIG_AD7152 is not set
+# CONFIG_AD7746 is not set
+
+#
+# Digital to analog converters
+#
+# CONFIG_AD5064 is not set
+# CONFIG_AD5360 is not set
+# CONFIG_AD5380 is not set
+# CONFIG_AD5421 is not set
+# CONFIG_AD5624R_SPI is not set
+# CONFIG_AD5446 is not set
+# CONFIG_AD5504 is not set
+# CONFIG_AD5764 is not set
+# CONFIG_AD5791 is not set
+# CONFIG_AD5686 is not set
+# CONFIG_MAX517 is not set
+
+#
+# Direct Digital Synthesis
+#
+# CONFIG_AD5930 is not set
+# CONFIG_AD9832 is not set
+# CONFIG_AD9834 is not set
+# CONFIG_AD9850 is not set
+# CONFIG_AD9852 is not set
+# CONFIG_AD9910 is not set
+# CONFIG_AD9951 is not set
+
+#
+# Digital gyroscope sensors
+#
+# CONFIG_ADIS16060 is not set
+# CONFIG_ADIS16080 is not set
+# CONFIG_ADIS16130 is not set
+# CONFIG_ADIS16260 is not set
+# CONFIG_ADXRS450 is not set
+
+#
+# Humidity sensors
+#
+CONFIG_DHT11=m
+
+#
+# Network Analyzer, Impedance Converters
+#
+# CONFIG_AD5933 is not set
+CONFIG_INV_SENSOR=y
+
+#
+# Light sensors
+#
+# CONFIG_SENSORS_ISL29018 is not set
+# CONFIG_SENSORS_TSL2563 is not set
+# CONFIG_TSL2583 is not set
+
+#
+# Magnetometer sensors
+#
+# CONFIG_SENSORS_HMC5843 is not set
+
+#
+# Active energy metering IC
+#
+# CONFIG_ADE7753 is not set
+# CONFIG_ADE7754 is not set
+# CONFIG_ADE7758 is not set
+# CONFIG_ADE7759 is not set
+# CONFIG_ADE7854 is not set
+
+#
+# Resolver to digital converters
+#
+# CONFIG_AD2S90 is not set
+# CONFIG_AD2S1200 is not set
+# CONFIG_AD2S1210 is not set
+
+#
+# Triggers - standalone
+#
+# CONFIG_IIO_SIMPLE_DUMMY is not set
+# CONFIG_ZSMALLOC is not set
+# CONFIG_FB_SM7XX is not set
+# CONFIG_USB_ENESTORAGE is not set
+# CONFIG_BCM_WIMAX is not set
+# CONFIG_FT1000 is not set
+
+#
+# Speakup console speech
+#
+# CONFIG_SPEAKUP is not set
+# CONFIG_TOUCHSCREEN_CLEARPAD_TM1217 is not set
+# CONFIG_TOUCHSCREEN_SYNAPTICS_I2C_RMI4 is not set
+# CONFIG_STAGING_MEDIA is not set
+
+#
+# Android
+#
+# CONFIG_ANDROID is not set
+# CONFIG_PHONE is not set
+# CONFIG_USB_WPAN_HCD is not set
+# CONFIG_SUNXIOOPS is not set
 CONFIG_CLKDEV_LOOKUP=y
 CONFIG_HAVE_CLK_PREPARE=y
 CONFIG_COMMON_CLK=y
diff --git a/arch/arm/mach-sunxi/sun8i.c b/arch/arm/mach-sunxi/sun8i.c
index 2c35075..7700d04 100755
--- a/arch/arm/mach-sunxi/sun8i.c
+++ b/arch/arm/mach-sunxi/sun8i.c
@@ -117,6 +117,40 @@ static struct i2c_board_info i2c_ina219_devs[] __initdata = {
 };
 #endif
 
+/*------------------------------------------------------------------------------
+ * Matrix device
+ */
+#if defined(CONFIG_INPUT_ADXL34X_I2C_MODULE)
+#define ADXL34X_I2C_BUS     (0)
+static struct i2c_board_info __initdata adxl34x_i2c_bdi = {
+	I2C_BOARD_INFO("adxl34x", 0x1d),
+	.irq	= -1,
+};
+#endif
+
+#if defined(CONFIG_BMP085_MODULE)
+#define BMP085_I2C_BUS (0)
+static struct i2c_board_info __initdata bmp085_i2c_bdi = {
+	I2C_BOARD_INFO("bmp085", 0x77),
+	.irq	= -1,
+};
+#endif
+
+#if defined(CONFIG_RTC_DRV_DS1307_MODULE)
+#define DS1307_I2C_BUS (0)
+static struct i2c_board_info __initdata ds1307_i2c_bdi = {
+	I2C_BOARD_INFO("ds1307", 0X68),
+	.irq	= -1,
+};
+#endif
+
+#if defined(CONFIG_SENSORS_PCF8591_MODULE)
+#define PCF8591_I2C_BUS (0)
+static struct i2c_board_info __initdata pcf8591_i2c_bdi = {
+        I2C_BOARD_INFO("pcf8591", 0x48),
+};
+#endif
+
 #if defined(CONFIG_ION) || defined(CONFIG_ION_MODULE)
 #define DEFAULT_SUNXI_ION_RESERVE_SIZE	96
 #define ION_CARVEOUT_INIT_MAX	4
@@ -461,6 +495,27 @@ static void __init sunxi_dev_init(void)
 	}
 	printk("ina219 device registered\n");
 #endif
+
+#if defined(CONFIG_INPUT_ADXL34X_I2C_MODULE)
+	printk("plat: add adxl34x device\n");
+	i2c_register_board_info(ADXL34X_I2C_BUS, &adxl34x_i2c_bdi, 1);
+#endif
+
+#if defined(CONFIG_BMP085_MODULE)
+	printk("plat: add bmp085 device\n");
+	i2c_register_board_info(BMP085_I2C_BUS, &bmp085_i2c_bdi, 1);
+#endif
+
+#if defined(CONFIG_RTC_DRV_DS1307_MODULE)
+	printk("plat: add ds1307 device\n");
+	i2c_register_board_info(DS1307_I2C_BUS, &ds1307_i2c_bdi, 1);
+#endif
+
+#if defined(CONFIG_SENSORS_PCF8591_MODULE)
+	printk("plat: add pcf8591 device\n");
+	i2c_register_board_info(PCF8591_I2C_BUS, &pcf8591_i2c_bdi, 1);
+#endif	
+
 #ifdef CONFIG_ANDROID_RAM_CONSOLE
 	/*	ram console	platform device initialize*/
 	ram_console_device_init();
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 6614788..5090528 100755
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -636,6 +636,30 @@ config SUNXI_D7S
 	---help---
 	  Sunxi display 7 segment for h3.
 
+config MATRIX_GPIO_INT
+	tristate "Matrix GPIO int sensor module"
+	default m
+	---help---
+	  Driver for Matrix GPIO int sensor module.
+
+config MATRIX_PWM
+	tristate "Matrix PWM module"
+	default m
+	---help---
+	  Driver for Matrix PWM module.
+
+config MATRIX_ROTARY_ENCODER
+	tristate "Matrix rotary encoder"
+	default m
+	---help---
+	  Driver for Matrix rotary encoder.
+
+config MATRIX_HCSR04
+	tristate "Matrix hcsr04"
+	default m
+	---help---
+	  Driver for Matrix hcsr04.
+	  
 source "drivers/char/sunxi_g2d/Kconfig"
 source "drivers/char/sunxi_ir_cut/Kconfig"
 source "drivers/char/cma_test/Kconfig"
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 399be2b..f0bda58 100755
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -82,3 +82,8 @@ obj-y				+= sunxi-di/
 obj-${CONFIG_ID}       += sunxi_id/
 obj-${CONFIG_RESET_KEY} += sunxi_key/
 obj-$(CONFIG_IR_CUT)   += sunxi_ir_cut/
+
+obj-$(CONFIG_MATRIX_GPIO_INT)	+= matrix_gpio_int.o
+obj-$(CONFIG_MATRIX_PWM)	+= matrix_pwm.o
+obj-$(CONFIG_MATRIX_ROTARY_ENCODER)	+= matrix_rotary_encoder.o
+obj-$(CONFIG_MATRIX_HCSR04) 	+= matrix_hcsr04.o
\ No newline at end of file
diff --git a/drivers/char/matrix_gpio_int.c b/drivers/char/matrix_gpio_int.c
new file mode 100644
index 0000000..cbe29ca
--- /dev/null
+++ b/drivers/char/matrix_gpio_int.c
@@ -0,0 +1,309 @@
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/poll.h>
+#include <linux/sched.h>
+#include <linux/irq.h>
+#include <asm/irq.h>
+#include <asm/io.h>
+#include <linux/interrupt.h>
+#include <asm/uaccess.h>
+#include <linux/platform_device.h>
+#include <linux/cdev.h>
+#include <linux/miscdevice.h>
+#include <linux/gpio.h>
+
+#define DEVICE_NAME		"sensor"
+#define MAX_SENDEV_NUM      8
+
+struct sensor {
+    int gpio;
+    int int_type;
+};
+
+
+struct sensor_desc {
+    int ID;
+	int gpio;	
+    int int_type;
+	char *name;	
+	int is_used;
+	struct timer_list timer;
+};
+
+static size_t sensor_num = -1;				// number of sensor has been registered
+static int is_started = 0;
+static struct semaphore lock;
+
+static struct sensor_desc sensor_dev[MAX_SENDEV_NUM] = {
+	{ 0, -1, -1, "gpio_int_sensor1"},
+	{ 1, -1, -1, "gpio_int_sensor2"},
+	{ 2, -1, -1, "gpio_int_sensor3"},
+	{ 3, -1, -1, "gpio_int_sensor4"},
+	{ 4, -1, -1, "gpio_int_sensor5"},
+	{ 5, -1, -1, "gpio_int_sensor6"},
+	{ 6, -1, -1, "gpio_int_sensor7"},
+	{ 7, -1, -1, "gpio_int_sensor8"},
+};
+
+static volatile char sensor_dev_value[MAX_SENDEV_NUM] = {
+};
+
+static DECLARE_WAIT_QUEUE_HEAD(sensor_dev_waitq);
+
+static volatile int ev_press = 0;
+
+// static int timer_counter = 0;
+static void gpio_int_sensors_timer(unsigned long _data)
+{
+
+	struct sensor_desc *bdata = (struct sensor_desc *)_data;
+	int ID;
+	unsigned tmp = gpio_get_value(bdata->gpio);
+	ID = bdata->ID;
+
+	// printk("%s %d value=%d int_type=%d\n", __FUNCTION__, timer_counter++, tmp, bdata->int_type);
+	if (bdata->int_type == IRQ_TYPE_EDGE_RISING) {
+		if(tmp == 1) {
+			sensor_dev_value[ID] = 1;
+			ev_press = 1;
+			wake_up_interruptible(&sensor_dev_waitq);
+		}
+	} else if (bdata->int_type == IRQ_TYPE_EDGE_FALLING) {	
+		if(tmp == 0) {
+			sensor_dev_value[ID] = 1;
+			ev_press = 1;
+			wake_up_interruptible(&sensor_dev_waitq);
+		}
+	} else if (bdata->int_type == IRQ_TYPE_EDGE_BOTH) {
+		sensor_dev_value[ID] = tmp;
+		ev_press = 1;
+		wake_up_interruptible(&sensor_dev_waitq);
+	}
+}
+
+// static int int_counter=0;
+static irqreturn_t gpio_int_sensor_interrupt(int irq, void *dev_id)
+{
+	// printk("%s %d\n", __FUNCTION__, int_counter++);
+	struct sensor_desc *bdata = (struct sensor_desc *)dev_id;
+	mod_timer(&bdata->timer, jiffies + msecs_to_jiffies(100));
+	return IRQ_HANDLED;
+}
+
+static int start_all_sensor(void)
+{
+	int irq;
+	int i;
+	int err = 0;
+
+	for (i = 0; i < sensor_num; i++) {
+		if (!sensor_dev[i].gpio)
+			continue;
+
+		setup_timer(&sensor_dev[i].timer, gpio_int_sensors_timer,
+				(unsigned long)&sensor_dev[i]);
+
+		err = gpio_request(sensor_dev[i].gpio, "gpio_int_sensor");			
+		if (err) {
+			printk("%s gpio_request %d fail\n", __FUNCTION__, sensor_dev[i].gpio);
+            break;
+		}
+
+		irq = gpio_to_irq(sensor_dev[i].gpio);
+		err = request_irq(irq, gpio_int_sensor_interrupt, IRQ_TYPE_EDGE_FALLING, 
+				sensor_dev[i].name, (void *)&sensor_dev[i]);
+		if (err) {
+		    printk("%s request_irq %d fail\n", __FUNCTION__, irq);
+            break;
+		}
+	}
+
+	if (err) {
+		i--;
+		for (; i >= 0; i--) {
+			if (!sensor_dev[i].gpio)
+				continue;
+
+			gpio_free(sensor_dev[i].gpio);
+			irq = gpio_to_irq(sensor_dev[i].gpio);
+			disable_irq(irq);
+			free_irq(irq, (void *)&sensor_dev[i]);
+
+			del_timer_sync(&sensor_dev[i].timer);
+		}
+
+		return -EBUSY;
+	}
+
+	ev_press = 0;
+	return 0;
+}
+
+static int gpio_int_sensors_open(struct inode *inode, struct file *file)
+{
+	if (down_trylock(&lock))
+		return -EBUSY;
+    sensor_num = 0;
+    is_started = 0;
+	return 0;
+}
+
+static int stop_all_sensor(void)
+{
+	int irq, i;
+
+	for (i = 0; i < sensor_num; i++) {
+		if (!sensor_dev[i].gpio)
+			continue;
+
+		gpio_free(sensor_dev[i].gpio);
+		irq = gpio_to_irq(sensor_dev[i].gpio);
+		free_irq(irq, (void *)&sensor_dev[i]);
+
+		del_timer_sync(&sensor_dev[i].timer);
+	}
+	return 0;
+}
+
+static int gpio_int_sensors_close(struct inode *inode, struct file *file)
+{
+	// printk("%s sensor_num=%d is_started=%d\n",__FUNCTION__, sensor_num, is_started);
+	if (is_started && sensor_num > 0) {
+		stop_all_sensor();
+	}
+	sensor_num = -1;
+	is_started = 0;
+	ev_press = 0;
+	up(&lock);
+	return 0;
+}
+
+// static int read_counter = 0;
+static int gpio_int_sensors_read(struct file *filp, char __user *buff,
+		size_t count, loff_t *offp)
+{
+	unsigned long err;
+	int i = 0;
+
+	if (!ev_press) {
+		if (filp->f_flags & O_NONBLOCK)
+			return -EAGAIN;
+		else
+			wait_event_interruptible(sensor_dev_waitq, ev_press);
+	}
+
+	ev_press = 0;
+
+	err = copy_to_user((void *)buff, (const void *)(&sensor_dev_value),
+			min(sensor_num, count));
+	for (i = 0; i<sensor_num; i++) {
+		sensor_dev_value[i] = 0;
+	}
+
+	return err ? -EFAULT : min(sensor_num, count);
+}
+
+static unsigned int gpio_int_sensors_poll( struct file *file,
+		struct poll_table_struct *wait)
+{
+	unsigned int mask = 0;
+
+	poll_wait(file, &sensor_dev_waitq, wait);
+	if (ev_press)
+		mask |= POLLIN | POLLRDNORM;
+
+	return mask;
+}
+
+static long gpio_int_sensors_ioctl(struct file *filp, unsigned int cmd,
+		unsigned long arg)
+{
+#define ADD_SENSOR                  (0)
+#define DEL_SENSOR                  (1)
+#define START_ALL_SENSOR            (4)
+#define STOP_ALL_SENSOR             (8)
+
+	struct sensor sen;
+	void __user *argp;
+	int del_dev;
+	int ret;
+
+	//printk("%s cmd=%d\n", __func__, cmd);
+	switch(cmd) {
+		case ADD_SENSOR:
+			if (is_started != 0 || sensor_num >= MAX_SENDEV_NUM)
+				return -EBUSY;
+			argp = (void __user *)arg;
+			if (copy_from_user(&sen, argp, sizeof sen))
+				return -EINVAL;
+			sensor_dev[sensor_num].gpio = sen.gpio;
+			sensor_dev[sensor_num].int_type= sen.int_type;
+			sensor_num++;
+			break;
+		case DEL_SENSOR:
+			del_dev = (int)arg;
+			// printk("%s del_dev=%d\n", __func__, del_dev);
+			if (is_started != 0 || sensor_num <= 0 || del_dev != sensor_num) 
+				return -EINVAL;			
+			sensor_dev[sensor_num].gpio = -1;					
+			sensor_dev[sensor_num].int_type= -1;			
+			sensor_num--;
+			break;
+		case START_ALL_SENSOR:
+			if (is_started != 0 || sensor_num <= 0)
+				return -EBUSY;
+			if((ret = start_all_sensor()) < 0)
+				return ret;
+			is_started = 1;					
+			break;
+		case STOP_ALL_SENSOR:
+			if (is_started != 1 || sensor_num <= 0)
+				return -EBUSY;
+			stop_all_sensor();
+			is_started = 0;
+			break;
+		default:
+			return -EINVAL;
+	}
+
+	return 0;
+}
+
+
+static struct file_operations dev_fops = {
+	.owner		= THIS_MODULE,
+	.open		= gpio_int_sensors_open,
+	.release	= gpio_int_sensors_close, 
+	.read		= gpio_int_sensors_read,
+	.poll		= gpio_int_sensors_poll,
+	.unlocked_ioctl	= gpio_int_sensors_ioctl,
+};
+
+static struct miscdevice misc = {
+	.minor		= MISC_DYNAMIC_MINOR,
+	.name		= DEVICE_NAME,
+	.fops		= &dev_fops,
+};
+
+static int __init sensor_dev_init(void)
+{
+	printk("Matirx GPIO Int sensor init\n");
+	sema_init(&lock, 1);
+	return misc_register(&misc);
+}
+
+static void __exit sensor_dev_exit(void)
+{
+	printk("Matirx GPIO Int sensor exit\n");
+	misc_deregister(&misc);
+}
+
+module_init(sensor_dev_init);
+module_exit(sensor_dev_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("FriendlyARM Inc.");
+
diff --git a/drivers/char/matrix_hcsr04.c b/drivers/char/matrix_hcsr04.c
new file mode 100644
index 0000000..3f4961b
--- /dev/null
+++ b/drivers/char/matrix_hcsr04.c
@@ -0,0 +1,184 @@
+#include <linux/module.h>
+#include <linux/gpio.h>
+#include <linux/delay.h>
+#include <linux/kernel.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/hrtimer.h>
+#include <linux/ktime.h>
+#include <linux/device.h>
+#include <linux/kdev_t.h>
+#include <linux/interrupt.h> 
+#include <linux/sched.h>
+
+MODULE_LICENSE("Dual BSD/GPL");
+MODULE_AUTHOR("DA BAI");
+MODULE_DESCRIPTION("Driver for HC-SR04 ultrasonic sensor");
+
+// #define HCSR04_IRQ_DEUBG
+struct HCSR04_resource {
+    int pin;
+};
+
+static int HCSR04_PIN = -1;
+static int hasResource = 0;
+static int irq_num = 0;
+static int irq_time[3];
+static int valid_value = 0;
+static DECLARE_WAIT_QUEUE_HEAD(hcsr_waitq);
+
+static int hcsr04_hwexit(void);
+static int hcsr04_hwinit(void);
+static ssize_t hcsr04_value_read(struct class *class, struct class_attribute *attr, char *buf);
+static irqreturn_t gpio_isr(int irq, void *data);
+
+static ssize_t hcsr04_value_write(struct class *class, struct class_attribute *attr, const char *buf, size_t len) 
+{
+    struct HCSR04_resource *res;
+    if (len == 4) {
+        res = (struct HCSR04_resource *)buf;
+
+        if (res->pin != -1 && hasResource == 0) {
+            HCSR04_PIN = res->pin;
+            if (hcsr04_hwinit() == -1) {
+                return -1;
+            }
+            hasResource = 1;
+        } else if (res->pin == -1 && hasResource == 1) {
+            if (hcsr04_hwexit() == -1) {
+                return -1;
+            }
+            hasResource = 0;
+        }
+    }
+    return len;
+}
+
+// This function is called when you read /sys/class/hcsr04/value
+static ssize_t hcsr04_value_read(struct class *class, struct class_attribute *attr, char *buf)
+{
+    int ret = -1;
+	int gpio_irq=-1;
+
+    if (hasResource == 0) {
+        return 0;
+    }    
+    irq_num = 0;
+	valid_value = 0;
+    gpio_direction_output(HCSR04_PIN, 0);
+    udelay(50);
+    gpio_set_value(HCSR04_PIN, 1);
+    udelay(50);
+    gpio_set_value(HCSR04_PIN, 0);
+    udelay(50);
+
+    ret = gpio_to_irq(HCSR04_PIN);
+    if (ret < 0) {
+        printk(KERN_ERR"%s fail to gpio_to_irq\n", __func__);
+        goto fail;
+    } else {
+        gpio_irq = ret;
+    }
+
+    ret = request_irq(gpio_irq, gpio_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING , "hc-sr04", NULL);
+    if (ret) {
+        printk(KERN_ERR"%s fail to request_irq\n", __func__);
+        goto fail;
+    }
+	
+	if(wait_event_interruptible_timeout(hcsr_waitq, valid_value, HZ) == 0) {
+		printk(KERN_ERR"%s timeout\n", __func__);
+		free_irq(gpio_irq, NULL);
+		goto fail;
+	}
+    free_irq(gpio_irq, NULL);
+#ifdef HCSR04_IRQ_DEUBG	    
+    printk("%s irq_time[1]=%d irq_time[0]=%d %d\n", __func__, irq_time[1], irq_time[0], irq_time[1]-irq_time[0]);
+#endif
+    return sprintf(buf, "%d\n", irq_time[1]-irq_time[0]);
+ fail:
+    return sprintf(buf, "%d\n", -1);;
+}
+
+// Sysfs definitions for hcsr04 class
+static struct class_attribute hcsr04_class_attrs[] = {
+        __ATTR(value,	S_IRUGO | S_IWUSR, hcsr04_value_read, hcsr04_value_write),
+        __ATTR_NULL,
+};
+
+// Name of directory created in /sys/class
+static struct class hcsr04_class = {
+        .name =			"hcsr04",
+        .owner =		THIS_MODULE, 
+        .class_attrs =	hcsr04_class_attrs,
+};
+
+// Interrupt handler on ECHO signal
+static irqreturn_t gpio_isr(int irq, void *data)
+{	
+	if (valid_value == 0) {	
+		if((irq_num == 0 && gpio_get_value(HCSR04_PIN) != 1) || 
+			(irq_num == 1 && gpio_get_value(HCSR04_PIN) != 0) ||
+			(irq_num == 2 && gpio_get_value(HCSR04_PIN) != 1)
+		) {
+			return IRQ_HANDLED;
+		}	
+	    irq_time[irq_num] = ktime_to_us(ktime_get());
+	    if(irq_num == 2) {
+#ifdef HCSR04_IRQ_DEUBG	    			
+			int i = 0;
+	    	for(i=0; i<3; i++)
+	    		printk("%d:%d\n", i, irq_time[i]);
+#endif      		
+			valid_value = 1;
+			wake_up_interruptible(&hcsr_waitq);
+	    	return IRQ_HANDLED;
+	    }		
+		irq_num++;
+	}
+    return IRQ_HANDLED;
+}
+
+static int hcsr04_hwinit(void)
+{	
+    int rtc;
+
+    rtc=gpio_request(HCSR04_PIN, "HCSR04");
+    if (rtc!=0) {
+        printk(KERN_INFO "Error %d\n",__LINE__);
+        goto fail;
+    }
+    return 0;
+
+    fail:
+    return -1;	
+}
+
+static int hcsr04_init(void)
+{		
+    printk(KERN_INFO "HC-SR04 driver v0.32 initializing.\n");
+
+    if (class_register(&hcsr04_class)<0) 
+        goto fail;
+    return 0;
+
+    fail:
+    return -1;
+
+}
+
+static int hcsr04_hwexit(void)
+{
+    gpio_free(HCSR04_PIN);
+    return 0;
+}
+
+static void hcsr04_exit(void)
+{
+    class_unregister(&hcsr04_class);
+    printk(KERN_INFO "HC-SR04 disabled.\n");
+}
+
+module_init(hcsr04_init);
+module_exit(hcsr04_exit);
+
diff --git a/drivers/char/matrix_pwm.c b/drivers/char/matrix_pwm.c
new file mode 100644
index 0000000..5cdd951
--- /dev/null
+++ b/drivers/char/matrix_pwm.c
@@ -0,0 +1,206 @@
+/*
+ * linux/drivers/char/matrix_pwm.c
+ *
+ * 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/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/fs.h>
+#include <linux/backlight.h>
+#include <linux/err.h>
+#include <linux/pwm.h>
+#include <linux/slab.h>
+#include <linux/miscdevice.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+
+#include <mach/platform.h>
+#include <asm/uaccess.h>
+
+#define DEVICE_NAME				"pwm"
+#define PWM_NUM					(2)
+#define PWM_IOCTL_SET_FREQ		(0x1)
+#define PWM_IOCTL_STOP			(0x0)
+#define NS_IN_1HZ				(1000000000UL)
+
+static int is_pwm_working[PWM_NUM] = {0, 0};
+static struct pwm_device *matrix_pwm[PWM_NUM];
+static struct semaphore lock;
+
+static int pwm_set_freq(int index, int pin, unsigned long freq, int duty) 
+{
+	int ret=0;
+	int period_ns = NS_IN_1HZ / freq;
+	int duty_ns = period_ns  / 1000 * duty;
+
+	printk("%s %d %d\n", __func__, period_ns, duty_ns);
+	if ((ret = pwm_config(matrix_pwm[index], duty_ns, period_ns))) {
+		printk("fail to pwm_config\n");
+		return ret;
+	}
+	if ((ret = pwm_enable(matrix_pwm[index]))) {
+		printk("fail to pwm_enable\n");
+		return ret;
+	}
+	return ret;
+}
+
+static void pwm_stop(int index, int pin) 
+{
+	pwm_config(matrix_pwm[index], 0, NS_IN_1HZ / 100);
+	pwm_disable(matrix_pwm[index]);
+}
+
+static int matrix_pwm_hw_init(int index, int pin)
+{
+	int ret=0;
+
+#if 0
+	ret = gpio_request(pin, DEVICE_NAME);
+	if (ret) {
+		printk("request gpio %d for pwm failed\n", pin);
+		return ret;
+	}
+	gpio_direction_output(pin, 0);
+#endif
+
+	matrix_pwm[index] = pwm_request(index, DEVICE_NAME);
+	if (IS_ERR(matrix_pwm[index])) {
+		printk("request pwm%d failed\n", index);
+#if 0
+		gpio_free(pin);
+#endif
+		return -ENODEV;
+	}
+
+	pwm_stop(index, pin);
+	return ret;
+}
+
+static void matrix_pwm_hw_exit(int index,int pin) 
+{
+	pwm_stop(index, pin);
+	pwm_free(matrix_pwm[index]);
+#if 0
+	gpio_free(pin);
+#endif
+}
+
+static int matrix_pwm_open(struct inode *inode, struct file *file) {
+	if (!down_trylock(&lock))
+		return 0;
+	else
+		return -EBUSY;
+}
+
+static int matrix_pwm_close(struct inode *inode, struct file *file) {
+	up(&lock);
+	return 0;
+}
+
+static long matrix_pwm_ioctl(struct file *filep, unsigned int cmd,unsigned long arg)
+{
+	int pwm_id;
+	int param[3];
+	int gpio;
+	int freq;
+	int duty;
+	int ret;
+	
+	switch (cmd) {
+		case PWM_IOCTL_SET_FREQ:
+			if (copy_from_user(param, (void __user *)arg, sizeof(param)))
+				return -EINVAL;
+			gpio = param[0];
+			freq = param[1];
+			duty = param[2];
+			if (gpio == (SUNXI_PA_BASE + 5)) {
+				pwm_id = 0;
+			} else if (gpio == (SUNXI_PA_BASE + 6)) {
+				pwm_id = 1;
+			} else {
+				printk("Invalid pwm gpio %d\n", gpio);
+				return -EINVAL;
+			}
+
+			if (duty < 0 || duty > 1000) {
+				printk("Invalid pwm duty %d\n", duty);
+				return -EINVAL;
+			}
+			
+			if (is_pwm_working[pwm_id] == 1) {
+				matrix_pwm_hw_exit(pwm_id, gpio);
+			}
+			
+			if ((ret = matrix_pwm_hw_init(pwm_id, gpio))) {
+				return ret;
+			}
+			is_pwm_working[pwm_id] = 1;
+			if ((ret = pwm_set_freq(pwm_id, gpio, freq, duty))) {
+				return ret;
+			}
+			break;
+		case PWM_IOCTL_STOP:
+			if (copy_from_user(&gpio, (void __user *)arg, sizeof(gpio)))
+				return -EINVAL;
+			if (gpio == (SUNXI_PA_BASE + 5)) {
+				pwm_id = 0;
+			} else if (gpio == (SUNXI_PA_BASE + 6)) {
+				pwm_id = 1;
+			} else {
+				printk("Invalid pwm gpio %d\n", gpio);
+				return -EINVAL;
+			}
+			if (is_pwm_working[pwm_id] == 1) {
+				matrix_pwm_hw_exit(pwm_id, gpio);
+				is_pwm_working[pwm_id] = 0;
+			}
+			break;
+		default:
+			printk("%s unsupported pwm ioctl %d", __FUNCTION__, cmd);
+			break;
+	}
+
+	return 0;
+}
+
+static struct file_operations matrix_pwm_ops = {
+	.owner			= THIS_MODULE,
+	.open			= matrix_pwm_open,
+	.release		= matrix_pwm_close, 
+	.unlocked_ioctl	= matrix_pwm_ioctl,
+};
+
+static struct miscdevice matrix_misc_dev = {
+	.minor = MISC_DYNAMIC_MINOR,
+	.name = DEVICE_NAME,
+	.fops = &matrix_pwm_ops,
+};
+
+static int __init matrix_pwm_init(void) 
+{
+	int ret;
+	ret = misc_register(&matrix_misc_dev);
+	printk("Matirx PWM init\n");
+
+	sema_init(&lock, 1);
+	return ret;
+}
+
+static void __exit matrix_pwm_exit(void) {
+	misc_deregister(&matrix_misc_dev);
+	printk("Matirx PWM exit\n");
+}
+
+module_init(matrix_pwm_init);
+module_exit(matrix_pwm_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("FriendlyARM Inc.");
+MODULE_DESCRIPTION("FriendlyARM Matrix PWM Driver");
+
diff --git a/drivers/char/matrix_rotary_encoder.c b/drivers/char/matrix_rotary_encoder.c
new file mode 100644
index 0000000..97fcb76
--- /dev/null
+++ b/drivers/char/matrix_rotary_encoder.c
@@ -0,0 +1,205 @@
+#include <linux/module.h>
+#include <linux/gpio.h>
+#include <linux/delay.h>
+#include <linux/kernel.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/hrtimer.h>
+#include <linux/ktime.h>
+#include <linux/device.h>
+#include <linux/kdev_t.h>
+#include <linux/interrupt.h> 
+#include <linux/sched.h>
+#include <linux/of_device.h>
+
+#include <asm/mach/irq.h>
+#include <mach/platform.h>
+
+static int has_init = 0;
+static int sw_pin = -1;			// func: int 
+static int sia_pin = -1;		// func: int
+static int sib_pin = -1;		// func: input
+static int sia_irq = -1;
+static int sw_irq = -1;
+static int counter = 0;
+static int sw = 0;
+
+static void rotary_sensor_hw_exit(void);
+static int rotary_sensor_hw_init(void );
+
+
+static ssize_t rotary_sensor_sw_read(struct device *dev, struct device_attribute *attr, char *buf)
+{
+	if ( sw_pin != -1 && sia_pin != -1 && sib_pin != -1) {
+		return sprintf(buf, "%d\n", sw);
+    }
+    return -1;
+}
+
+static ssize_t rotary_sensor_value_read(struct device *dev, struct device_attribute *attr, char *buf)
+{
+	if ( sw_pin != -1 && sia_pin != -1 && sib_pin != -1) {
+	    return sprintf(buf, "%d\n", counter);
+	}
+	return -1;
+}
+
+static ssize_t rotary_sensor_gpio_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+	return sprintf(buf, "%d,%d,%d\n", sw_pin, sia_pin, sib_pin);
+}
+
+static ssize_t rotary_sensor_gpio_store(struct device *device, struct device_attribute *attr, const char *buf, size_t count)
+{
+	if ( has_init ==0 ) {
+		sscanf(buf,"%d,%d,%d ", &sw_pin, &sia_pin, &sib_pin);
+		printk(KERN_ERR"buf=%s\n", buf);
+		if (rotary_sensor_hw_init()) {
+			has_init = 0;
+			return -1;
+		}	
+		else {
+			has_init = 1;
+		}	
+	} else {
+		rotary_sensor_hw_exit();
+		has_init = 0;
+	}	
+		
+	return count;
+}
+static struct device_attribute value_attr = __ATTR(value, S_IRUGO, rotary_sensor_value_read, NULL);
+static struct device_attribute sw_attr = __ATTR(sw,S_IRUGO, rotary_sensor_sw_read, NULL);
+static struct device_attribute gpio_attr = __ATTR(gpio, S_IRUGO|S_IWUGO, rotary_sensor_gpio_show, rotary_sensor_gpio_store);
+
+/* sys attribte group */
+static struct attribute *attrs[] = {
+	&value_attr.attr, &sw_attr.attr, &gpio_attr.attr, NULL,
+};
+
+static struct attribute_group attr_group = {
+		.attrs = (struct attribute **)attrs,
+};
+
+
+static irqreturn_t sw_isr(int irq, void *data)
+{	
+	if (gpio_get_value(sw_pin) == 1) {
+		sw = 0;
+	} else {
+		sw = 1;
+	}
+    // printk("%s sw=%d\n", __func__, sw);
+    return IRQ_HANDLED;
+}
+
+static irqreturn_t rotate_isr(int irq, void *data)
+{	
+	if (gpio_get_value(sib_pin) == 1) {
+		counter++;
+	} else {
+		counter--;
+	}
+    // printk("%s value=%d\n", __func__, counter);
+    return IRQ_HANDLED;
+}
+
+static void rotary_sensor_hw_exit(void)
+{
+	if (sia_irq != -1)
+	    free_irq(sia_irq, NULL);
+	if (sw_irq != -1)    
+		free_irq(sw_irq, NULL);
+	if (sib_pin != -1)
+		gpio_free(sib_pin);    
+	if (sia_pin != -1)	
+	    gpio_free(sia_pin);
+	if (sw_pin != -1)    
+	    gpio_free(sw_pin);	
+	sw_pin = sia_pin = sib_pin = -1;    
+}
+
+static int rotary_sensor_hw_init(void )
+{
+	int ret = -1;
+
+    ret = gpio_request(sw_pin, "sw");
+    if (ret) {
+        printk(KERN_ERR"gpio request sw_pin fail:%d\n", sw_pin);
+        return -1;
+    }
+    ret = gpio_request(sia_pin, "sia_pin");
+    if (ret) {
+        printk(KERN_ERR"gpio request sia_pin fail:%d\n", sia_pin);
+        goto fail_gpio_sw;
+    }
+    ret = gpio_request(sib_pin, "sib_pin");
+    if (ret) {
+        printk(KERN_ERR"gpio request sib_pin fail:%d\n", sia_pin);
+        goto fail_gpio_sia;
+    }
+
+    sw_irq = gpio_to_irq(sw_pin);
+    ret = request_irq(sw_irq, sw_isr, IRQ_TYPE_EDGE_BOTH, "rotary_sensor_sw", NULL);
+    if (ret) {
+        printk(KERN_ERR"%s fail to request_irq, gpio=%d irq=%d\n", __func__, sw_pin, sw_irq);
+        goto fail_gpio_sib;
+    }
+    
+    sia_irq = gpio_to_irq(sia_pin);
+    ret = request_irq(sia_irq, rotate_isr, IRQ_TYPE_EDGE_FALLING , "rotary_sensor_sia", NULL);
+    if (ret) {
+        printk(KERN_ERR"%s fail to request_irq, gpio=%d irq=%d\n", __func__, sia_pin, sia_irq);
+        goto fail_irq_sw;
+    }
+
+	gpio_direction_input(sib_pin);
+
+	return ret;
+
+fail_irq_sw:
+	free_irq(sw_irq, NULL);
+fail_gpio_sib:
+    gpio_free(sib_pin);
+fail_gpio_sia:
+	gpio_free(sia_pin);
+fail_gpio_sw:
+	gpio_free(sw_pin);
+    return ret;
+
+}
+static struct kobject *kobj = NULL;
+static int rotary_sensor_init(void)
+{		
+	int ret = 0;
+    printk(KERN_INFO "Matrix-rotary_encoder init.\n");
+	
+	kobj = kobject_create_and_add("rotary_encoder", &platform_bus.kobj);
+	if (!kobj) {
+		pr_err("%s: failed to kobject_create_and_add for rotary_encoder\n", __func__);
+		return -EINVAL;
+	}
+
+	ret = sysfs_create_group(kobj, &attr_group);
+	if (ret) {
+		pr_err("%s: failed to sysfs_create_group for rotary_encoder\n", __func__);
+		kobject_del(kobj);
+		return -EINVAL;
+	}
+	return ret;
+}
+
+static void rotary_sensor_exit(void)
+{
+    printk(KERN_INFO "Matrix-rotary_encoder exit.\n");
+    sysfs_remove_group(kobj, &attr_group);
+    kobject_put(kobj);
+	kobj = NULL;
+}
+
+module_init(rotary_sensor_init);
+module_exit(rotary_sensor_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("FriendlyARM");
+MODULE_DESCRIPTION("Driver for Matrix-Rotary_Sensor");
diff --git a/drivers/input/misc/adxl34x.c b/drivers/input/misc/adxl34x.c
index 1cf72fe..81fbe55 100644
--- a/drivers/input/misc/adxl34x.c
+++ b/drivers/input/misc/adxl34x.c
@@ -223,7 +223,7 @@ static const struct adxl34x_platform_data adxl34x_default_init = {
 	.free_fall_threshold = 8,
 	.free_fall_time = 0x20,
 	.data_rate = 8,
-	.data_range = ADXL_FULL_RES,
+	.data_range = ADXL_FULL_RES | INT_INVERT,
 
 	.ev_type = EV_ABS,
 	.ev_code_x = ABS_X,	/* EV_REL */
@@ -236,6 +236,9 @@ static const struct adxl34x_platform_data adxl34x_default_init = {
 	.watermark = 0,
 };
 
+static irqreturn_t adxl34x_irq(int irq, void *handle);
+static int adxl34x_read_without_int(int irq, void* handle);
+
 static void adxl34x_get_triple(struct adxl34x *ac, struct axis_triple *axis)
 {
 	short buf[3];
@@ -296,6 +299,14 @@ static void adxl34x_do_tap(struct adxl34x *ac,
 	adxl34x_send_key_events(ac, pdata, status, false);
 }
 
+static int adxl34x_read_without_int(int irq, void* handle)
+{
+	if (adxl34x_irq(irq, handle) != IRQ_HANDLED) {
+		return -1;
+	}
+	return 0;
+}
+
 static irqreturn_t adxl34x_irq(int irq, void *handle)
 {
 	struct adxl34x *ac = handle;
@@ -486,6 +497,10 @@ static ssize_t adxl34x_calibrate_show(struct device *dev,
 	struct adxl34x *ac = dev_get_drvdata(dev);
 	ssize_t count;
 
+	if (adxl34x_read_without_int(0, ac)) {
+		return 0;
+	}
+
 	mutex_lock(&ac->mutex);
 	count = sprintf(buf, "%d,%d,%d\n",
 			ac->hwcal.x * 4 + ac->swcal.x,
@@ -607,6 +622,9 @@ static ssize_t adxl34x_position_show(struct device *dev,
 	struct adxl34x *ac = dev_get_drvdata(dev);
 	ssize_t count;
 
+	if (adxl34x_read_without_int(0, ac)) {
+		return 0;
+	}
 	mutex_lock(&ac->mutex);
 	count = sprintf(buf, "(%d, %d, %d)\n",
 			ac->saved.x, ac->saved.y, ac->saved.z);
@@ -810,14 +828,16 @@ struct adxl34x *adxl34x_probe(struct device *dev, int irq,
 		ac->fifo_delay = false;
 
 	ac->bops->write(dev, POWER_CTL, 0);
-
+	// not use int
+#if 0
 	err = request_threaded_irq(ac->irq, NULL, adxl34x_irq,
-				   IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
+				   IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 				   dev_name(dev), ac);
 	if (err) {
 		dev_err(dev, "irq %d busy?\n", ac->irq);
 		goto err_free_mem;
 	}
+#endif
 
 	err = sysfs_create_group(&dev->kobj, &adxl34x_attr_group);
 	if (err)
@@ -884,6 +904,13 @@ struct adxl34x *adxl34x_probe(struct device *dev, int irq,
 
 	ac->pdata.power_mode &= (PCTL_AUTO_SLEEP | PCTL_LINK);
 
+	__adxl34x_enable(ac);
+#if 0	
+	int start = 0x1D;
+	for(; start < 0x3C; start++) {
+		printk("reg[%x]=%x\n", start, AC_READ(ac, start));
+	}
+#endif
 	return ac;
 
  err_remove_attr:
diff --git a/drivers/staging/iio/humidity/Makefile b/drivers/staging/iio/humidity/Makefile
new file mode 100644
index 0000000..d5d36c0
--- /dev/null
+++ b/drivers/staging/iio/humidity/Makefile
@@ -0,0 +1,5 @@
+#
+# Makefile for IIO humidity sensor drivers
+#
+
+obj-$(CONFIG_DHT11) += dht11.o
diff --git a/drivers/staging/iio/humidity/dht11.c b/drivers/staging/iio/humidity/dht11.c
new file mode 100644
index 0000000..a751a54
--- /dev/null
+++ b/drivers/staging/iio/humidity/dht11.c
@@ -0,0 +1,366 @@
+/*
+ * DHT11/DHT22 bit banging GPIO driver
+ *
+ * Copyright (c) Harald Geyer <harald@ccbib.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.
+ */
+
+#include <linux/err.h>
+#include <linux/interrupt.h>
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/printk.h>
+#include <linux/slab.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/sysfs.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/wait.h>
+#include <linux/bitops.h>
+#include <linux/completion.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <linux/of_gpio.h>
+#include <linux/pinctrl/pinconf.h>
+#include <linux/pinctrl/pinconf-sunxi.h>
+#include <linux/pinctrl/consumer.h>
+#include <linux/kthread.h>
+
+#include <mach/platform.h>
+
+#include "../iio.h"
+
+//#define DHT11_DEBUG 1
+#define DRIVER_NAME	"dht11"
+
+#define DHT11_DATA_VALID_TIME	2000000000  /* 2s in ns */
+
+#define DHT11_EDGES_PREAMBLE 4
+#define DHT11_BITS_PER_READ 40
+#define DHT11_EDGES_PER_READ (2*DHT11_BITS_PER_READ + DHT11_EDGES_PREAMBLE)
+
+/* Data transmission timing (nano seconds) */
+#define DHT11_START_TRANSMISSION	18  /* ms */
+#define DHT11_SENSOR_RESPONSE	80000
+#define DHT11_START_BIT		50000
+#define DHT11_DATA_BIT_LOW	27000
+#define DHT11_DATA_BIT_HIGH	70000
+
+#define DATA_START_FLAG_MIN 	(50000)
+#define DATA_START_FLAG_MAX 	(60000)
+#define DATA_ONE_MIN 			(65000)
+#define DATA_ONE_MAX 			(75000)
+#define DATA_ZERO_MIN 			(20000)
+#define DATA_ZERO_MAX 			(30000)
+
+
+struct dht11 {
+	struct device			*dev;
+
+	int				gpio;
+	int				irq;
+
+	struct completion		completion;
+
+	s64				timestamp;
+	int				temperature;
+	int				humidity;
+
+	/* num_edges: -1 means "no transmission in progress" */
+	int				num_edges;
+	struct {s64 ts; int value; }	edges[DHT11_EDGES_PER_READ];
+};
+
+static int gpio = -1;
+static int dht11_read_flag = 0;
+static unsigned char dht11_decode_byte(int *timing)
+{
+	unsigned char ret = 0;
+	int i;
+
+	for (i = 0; i < 8; ++i) {
+		ret <<= 1;
+		ret +=timing[i];
+	}
+
+	return ret;
+}
+
+static int dht11_decode(struct dht11 *dht11, int *timing)
+{
+	unsigned char temp_int, temp_dec, hum_int, hum_dec, checksum;
+
+#ifdef DHT11_DEBUG
+	int i = 0;
+	for(i=0; i<DHT11_BITS_PER_READ; i++)
+		printk(KERN_ERR"%02d %d\n", i, timing[i]);
+#endif
+	hum_int = dht11_decode_byte(timing);
+	hum_dec = dht11_decode_byte(&timing[8]);
+	temp_int = dht11_decode_byte(&timing[16]);
+	temp_dec = dht11_decode_byte(&timing[24]);
+	checksum = dht11_decode_byte(&timing[32]);
+
+#ifdef DHT11_DEBUG
+	printk(KERN_ERR"%d + %d + %d + %d = %d\n", hum_int, hum_dec, temp_int, temp_dec, checksum);
+#endif
+	if (((hum_int + hum_dec + temp_int + temp_dec) & 0xff) != checksum) {
+		dev_err(dht11->dev,
+			"checksum error %d %d %d %d %d\n",
+			hum_int, hum_dec, temp_int, temp_dec, checksum);
+		return -EIO;
+	}	
+
+	dht11->timestamp = iio_get_time_ns();
+	if (hum_int < 20) {  /* DHT22 */
+		dht11->temperature = (((temp_int & 0x7f) << 8) + temp_dec) *
+					((temp_int & 0x80) ? -100 : 100);
+		dht11->humidity = ((hum_int << 8) + hum_dec) * 100;
+	} else if (temp_dec == 0 && hum_dec == 0) {  /* DHT11 */
+		dht11->temperature = temp_int * 1000;
+		dht11->humidity = hum_int * 1000;
+	} else {
+		dev_err(dht11->dev,
+			"Don't know how to decode data: %d %d %d %d\n",
+			hum_int, hum_dec, temp_int, temp_dec);
+		return -EIO;
+	}
+
+	return 0;
+}
+
+static int dht11_read_thread(void *__dev)
+{
+	struct dht11 *dht11 = (struct dht11 *)__dev;
+	int value = 0;
+	
+#ifdef DHT11_DEBUG
+	printk(KERN_INFO"%s start\n", __func__);
+#endif
+	if (gpio_direction_output(dht11->gpio, 0))
+		return -1;
+	msleep(DHT11_START_TRANSMISSION);
+	gpio_direction_input(dht11->gpio);
+	dht11->edges[dht11->num_edges].value = gpio_get_value(dht11->gpio);
+	dht11->edges[dht11->num_edges].ts = iio_get_time_ns();
+	while (dht11->num_edges < DHT11_EDGES_PER_READ && dht11_read_flag == 1) {
+		value = gpio_get_value(dht11->gpio);
+		if (dht11->edges[dht11->num_edges].value != value) {
+			dht11->num_edges++;
+			dht11->edges[dht11->num_edges].ts = iio_get_time_ns();
+			dht11->edges[dht11->num_edges].value = value;
+			if (dht11->num_edges == DHT11_EDGES_PER_READ)
+				complete(&dht11->completion);
+		}
+	}
+	return 0;
+}
+
+static int dht11_read_raw(struct iio_dev *iio_dev,
+			const struct iio_chan_spec *chan,
+			int *val, int *val2, long m)
+{
+	struct dht11 *dht11 = iio_priv(iio_dev);
+	int ret;
+	int i, j;
+	int timing[DHT11_BITS_PER_READ], time;
+	struct task_struct *th;
+
+	if (dht11->timestamp + DHT11_DATA_VALID_TIME < iio_get_time_ns()) {
+		dht11->num_edges = 0;
+		dht11->completion.done = 0;
+		th = kthread_create(dht11_read_thread, dht11, "dht11-read");
+		if (IS_ERR(th)) {
+			ret = -1;
+			goto err;
+		}
+		dht11_read_flag = 1;
+		wake_up_process(th);
+		ret = wait_for_completion_killable_timeout(&dht11->completion, HZ);
+		dht11_read_flag = 0;
+		if(th)
+			kthread_stop(th);
+		if (ret == 0) {
+			dev_err(&iio_dev->dev, "dht11 read raw timeout\n");
+			ret = -1;
+			//goto err;
+		}	
+		for(i=0,j=0; i<dht11->num_edges; i++) {
+			if (i != 0) {
+#ifdef DHT11_DEBUG
+				printk(KERN_DEBUG"%02d ts=%lld value=%d pass=%lld\n", i, dht11->edges[i].ts, dht11->edges[i].value, dht11->edges[i].ts - dht11->edges[i-1].ts);
+#endif
+				time = dht11->edges[i].ts - dht11->edges[i-1].ts;
+			}
+			if (i > 3) {
+				if ((i%2) == 0) {	// one bit start always about 50us
+					if (time<DATA_START_FLAG_MIN || time>DATA_START_FLAG_MAX) {
+						printk(KERN_ERR"bit start without 50us, time=%d\n", time);
+						ret = -EINVAL;
+						goto err;
+					}	
+				} else {
+					time = dht11->edges[i].ts - dht11->edges[i-1].ts;
+					if (time > DATA_ZERO_MIN && time < DATA_ZERO_MAX)
+						timing[j] = 0;
+					else if (time > DATA_ONE_MIN && time < DATA_ONE_MAX)
+						timing[j]= 1;
+					else {
+						printk(KERN_ERR"bit value is not 1 or 0, time=%d\n", time);
+						ret = -EINVAL;
+						goto err;
+					}
+					j++;
+				}
+			}
+		}
+
+		ret = dht11_decode(dht11, timing);
+		if (ret)
+			goto err;
+	}
+
+	ret = IIO_VAL_INT;
+	if (chan->type == IIO_TEMP)
+		*val = dht11->temperature;
+	else if (chan->type == IIO_HUMIDITYRELATIVE)
+		*val = dht11->humidity;
+	else
+		ret = -EINVAL;
+err:
+	dht11->num_edges = -1;
+	return ret;
+}
+
+static const struct iio_info dht11_iio_info = {
+	.driver_module		= THIS_MODULE,
+	.read_raw		= dht11_read_raw,
+};
+
+static const struct iio_chan_spec dht11_chan_spec[] = {
+	{ 
+		.type = IIO_TEMP,
+	  	.processed_val = IIO_PROCESSED,
+	},
+	{ 
+		.type = IIO_HUMIDITYRELATIVE,
+	  	.processed_val = IIO_PROCESSED,
+	}
+};
+
+static const struct of_device_id dht11_dt_ids[] = {
+	{ .compatible = "dht11", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, dht11_dt_ids);
+
+static int dht11_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct dht11 *dht11;
+	struct iio_dev *iio;
+	int ret = -1;
+
+	iio = iio_allocate_device(sizeof(*dht11));
+	if (!iio) {
+		dev_err(dev, "Failed to allocate IIO device\n");
+		return -ENOMEM;
+	}
+
+	dht11 = iio_priv(iio);
+	dht11->dev = dev;
+	dht11->gpio = gpio;
+
+	ret = gpio_request(dht11->gpio, pdev->name);
+	if (ret)
+		return ret;
+
+	dht11->timestamp = iio_get_time_ns() - DHT11_DATA_VALID_TIME - 1;
+	dht11->num_edges = -1;
+
+	platform_set_drvdata(pdev, iio);
+
+	init_completion(&dht11->completion);
+	iio->name = pdev->name;
+	iio->dev.parent = &pdev->dev;
+	iio->info = &dht11_iio_info;
+	iio->modes = INDIO_DIRECT_MODE;
+	iio->channels = dht11_chan_spec;
+	iio->num_channels = ARRAY_SIZE(dht11_chan_spec);
+
+	return iio_device_register(iio);
+}
+
+static int dht11_remove(struct platform_device *pdev)
+{
+	struct iio_dev *iio = platform_get_drvdata(pdev);
+	struct dht11 *dht11 = iio_priv(iio);
+
+	iio_device_unregister(iio);
+	gpio_free(dht11->gpio);
+	iio_free_device(iio);
+	return 0;
+}
+
+static struct platform_driver dht11_driver = {
+	.driver = {
+		.name	= DRIVER_NAME,
+		.owner	= THIS_MODULE,
+		.of_match_table = dht11_dt_ids,
+	},
+	.probe  = dht11_probe,
+	.remove = dht11_remove,
+};
+
+void matrix_dht11_device_release(struct device *dev)
+{
+}
+
+static struct platform_device dht11_device = {
+	.name			= "dht11",
+	.id				= -1,
+	.num_resources	= 0,
+	.dev = {        
+        	.release 			= matrix_dht11_device_release,
+        }
+};
+
+static int __init dht11_init(void)
+{
+	int ret = -1;
+	
+	printk("plat: add device matrix-dht11, gpio=%d\n", gpio);
+	if ((ret = platform_device_register(&dht11_device))) {
+		return ret;
+	}
+
+	if ((ret = platform_driver_register(&dht11_driver))) {
+		platform_device_unregister(&dht11_device);
+	}
+	return ret;
+}
+
+static void __exit dht11_exit(void)
+{
+	platform_driver_unregister(&dht11_driver);
+	platform_device_unregister(&dht11_device);
+	gpio = -1;
+}
+
+module_init(dht11_init);
+module_exit(dht11_exit);
+MODULE_AUTHOR("Harald Geyer <harald@ccbib.org>");
+MODULE_DESCRIPTION("DHT11 humidity/temperature sensor driver");
+MODULE_LICENSE("GPL v2");
+module_param(gpio, int, 0644);
diff --git a/drivers/staging/iio/industrialio-core.c b/drivers/staging/iio/industrialio-core.c
index e16500a..7e4421e 100755
--- a/drivers/staging/iio/industrialio-core.c
+++ b/drivers/staging/iio/industrialio-core.c
@@ -68,6 +68,7 @@ static const char * const iio_chan_type_name_spec[] = {
 	[IIO_ANGL] = "angl",
 	[IIO_TIMESTAMP] = "timestamp",
 	[IIO_CAPACITANCE] = "capacitance",
+	[IIO_HUMIDITYRELATIVE] = "humidityrelative",
 	[IIO_QUATERNION] = "quaternion",
 };
 
diff --git a/drivers/staging/iio/types.h b/drivers/staging/iio/types.h
index 291c783..616c141 100755
--- a/drivers/staging/iio/types.h
+++ b/drivers/staging/iio/types.h
@@ -27,6 +27,7 @@ enum iio_chan_type {
 	IIO_ANGL,
 	IIO_TIMESTAMP,
 	IIO_CAPACITANCE,
+	IIO_HUMIDITYRELATIVE,
 	IIO_QUATERNION,
 };
 
diff --git a/drivers/w1/masters/Makefile b/drivers/w1/masters/Makefile
index c5a3e96..88ee685 100644
--- a/drivers/w1/masters/Makefile
+++ b/drivers/w1/masters/Makefile
@@ -8,5 +8,5 @@ obj-$(CONFIG_W1_MASTER_DS2482)		+= ds2482.o
 obj-$(CONFIG_W1_MASTER_MXC)		+= mxc_w1.o
 
 obj-$(CONFIG_W1_MASTER_DS1WM)		+= ds1wm.o
-obj-$(CONFIG_W1_MASTER_GPIO)		+= w1-gpio.o
+obj-$(CONFIG_W1_MASTER_GPIO)		+= w1-gpio.o w1-gpio-board.o
 obj-$(CONFIG_HDQ_MASTER_OMAP)		+= omap_hdq.o
diff --git a/drivers/w1/masters/w1-gpio-board.c b/drivers/w1/masters/w1-gpio-board.c
new file mode 100644
index 0000000..11aa1e4
--- /dev/null
+++ b/drivers/w1/masters/w1-gpio-board.c
@@ -0,0 +1,59 @@
+/*
+ * w1-gpio-board.c - Board driver for GPIO w1 bus master
+ *
+ * Copyright (C) 2016 FriendlyARM (www.friendlyarm.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/init.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/w1-gpio.h>
+#include <linux/gpio.h>
+
+#include <mach/platform.h>
+
+static int gpio = -1;
+module_param(gpio, int, 0644);
+
+
+static struct w1_gpio_platform_data w1_gpio_pdata = {
+	.pin		= -1,
+	.is_open_drain	= 0,
+};
+
+static void w1_device_release(struct device *dev) {
+	// nothing here yet
+}
+
+static struct platform_device matrix_w1_device = {
+	.name		= "w1-gpio",
+	.id			= -1,
+	.dev		= {
+		.release	= w1_device_release,
+		.platform_data	= &w1_gpio_pdata,
+	}
+};
+
+
+static int __init w1_gpio_board_init(void)
+{
+	w1_gpio_pdata.pin = gpio;
+	printk("plat: add device w1-gpio, gpio=%d\n", w1_gpio_pdata.pin);
+	return platform_device_register(&matrix_w1_device);
+}
+
+static void __exit w1_gpio_board_exit(void)
+{
+	platform_device_unregister(&matrix_w1_device);
+}
+
+module_init(w1_gpio_board_init);
+module_exit(w1_gpio_board_exit);
+
+MODULE_DESCRIPTION("Board driver for GPIO w1 bus master");
+MODULE_AUTHOR("FriendlyARM");
+MODULE_LICENSE("GPL");
diff --git a/drivers/w1/masters/w1-gpio.c b/drivers/w1/masters/w1-gpio.c
index df600d1..28f8d7d 100644
--- a/drivers/w1/masters/w1-gpio.c
+++ b/drivers/w1/masters/w1-gpio.c
@@ -42,7 +42,7 @@ static u8 w1_gpio_read_bit(void *data)
 	return gpio_get_value(pdata->pin) ? 1 : 0;
 }
 
-static int __init w1_gpio_probe(struct platform_device *pdev)
+static int w1_gpio_probe(struct platform_device *pdev)
 {
 	struct w1_bus_master *master;
 	struct w1_gpio_platform_data *pdata = pdev->dev.platform_data;
@@ -56,8 +56,10 @@ static int __init w1_gpio_probe(struct platform_device *pdev)
 		return -ENOMEM;
 
 	err = gpio_request(pdata->pin, "w1");
-	if (err)
+	if (err) {
+		dev_err(&pdev->dev, "failed to request GPIO %d\n", pdata->pin);
 		goto free_master;
+	}
 
 	master->data = pdata;
 	master->read_bit = w1_gpio_read_bit;
@@ -89,7 +91,7 @@ static int __init w1_gpio_probe(struct platform_device *pdev)
 	return err;
 }
 
-static int __exit w1_gpio_remove(struct platform_device *pdev)
+static int w1_gpio_remove(struct platform_device *pdev)
 {
 	struct w1_bus_master *master = platform_get_drvdata(pdev);
 	struct w1_gpio_platform_data *pdata = pdev->dev.platform_data;
@@ -136,14 +138,15 @@ static struct platform_driver w1_gpio_driver = {
 		.name	= "w1-gpio",
 		.owner	= THIS_MODULE,
 	},
-	.remove	= __exit_p(w1_gpio_remove),
+	.probe = w1_gpio_probe,
+	.remove	= w1_gpio_remove,
 	.suspend = w1_gpio_suspend,
 	.resume = w1_gpio_resume,
 };
 
 static int __init w1_gpio_init(void)
 {
-	return platform_driver_probe(&w1_gpio_driver, w1_gpio_probe);
+	return platform_driver_register(&w1_gpio_driver);
 }
 
 static void __exit w1_gpio_exit(void)