sunxi: add initial 3.18 support

Signed-off-by: Zoltan HERPAI <wigyori@uid0.hu>

SVN-Revision: 43337

18 files changed, 3863 insertions, 0 deletions

diff --git a/target/linux/sunxi/patches-3.18/100-dt-sun7i-add_spi0_pins_a.patch b/target/linux/sunxi/patches-3.18/100-dt-sun7i-add_spi0_pins_a.patch
new file mode 100644
index 0000000..f0e3eea
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/100-dt-sun7i-add_spi0_pins_a.patch
@@ -0,0 +1,28 @@
+From 0253d14782f80cfd1741d4ddd82b83dd7d44a91e Mon Sep 17 00:00:00 2001
+From: Hans de Goede <hdegoede@redhat.com>
+Date: Mon, 28 Jul 2014 22:44:59 +0200
+Subject: [PATCH] ARM: dts: sun7i: Add spi0_pins_a pinctrl setting
+
+Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+---
+ arch/arm/boot/dts/sun7i-a20.dtsi | 7 +++++++
+ 1 file changed, 7 insertions(+)
+
+diff --git a/arch/arm/boot/dts/sun7i-a20.dtsi b/arch/arm/boot/dts/sun7i-a20.dtsi
+index 82097c9..4fb8930 100644
+--- a/arch/arm/boot/dts/sun7i-a20.dtsi
++++ b/arch/arm/boot/dts/sun7i-a20.dtsi
+@@ -784,6 +784,13 @@
+ 				allwinner,pull = <0>;
+ 			};
+ 
++			spi0_pins_a: spi0@0 {
++				allwinner,pins = "PI10", "PI11", "PI12", "PI13", "PI14";
++				allwinner,function = "spi0";
++				allwinner,drive = <0>;
++				allwinner,pull = <0>;
++			};
++
+ 			spi1_pins_a: spi1@0 {
+ 				allwinner,pins = "PI16", "PI17", "PI18", "PI19";
+ 				allwinner,function = "spi1";
diff --git a/target/linux/sunxi/patches-3.18/101-dt-sun7i-add-uart3_pins.patch b/target/linux/sunxi/patches-3.18/101-dt-sun7i-add-uart3_pins.patch
new file mode 100644
index 0000000..8f9c0e8
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/101-dt-sun7i-add-uart3_pins.patch
@@ -0,0 +1,31 @@
+From e37ccbcd4587b7a2b943e23a9943b8917010b336 Mon Sep 17 00:00:00 2001
+From: Hans de Goede <hdegoede@redhat.com>
+Date: Wed, 1 Oct 2014 08:39:58 +0200
+Subject: [PATCH] ARM: dts: sun7i: Add uart3_pins_b pinctrl setting
+
+The uart3_pins_a multiplexes the uart3 pins to port G, add a pinctrl entry
+for mapping them to port H (as used on the Bananapi).
+
+Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+---
+ arch/arm/boot/dts/sun7i-a20.dtsi | 7 +++++++
+ 1 file changed, 7 insertions(+)
+
+diff --git a/arch/arm/boot/dts/sun7i-a20.dtsi b/arch/arm/boot/dts/sun7i-a20.dtsi
+index 4fb8930..cecf32c 100644
+--- a/arch/arm/boot/dts/sun7i-a20.dtsi
++++ b/arch/arm/boot/dts/sun7i-a20.dtsi
+@@ -677,6 +677,13 @@
+ 				allwinner,pull = <0>;
+ 			};
+ 
++			uart3_pins_b: uart3@1 {
++				allwinner,pins = "PH0", "PH1";
++				allwinner,function = "uart3";
++				allwinner,drive = <0>;
++				allwinner,pull = <0>;
++			};
++
+ 			uart4_pins_a: uart4@0 {
+ 				allwinner,pins = "PG10", "PG11";
+ 				allwinner,function = "uart4";
diff --git a/target/linux/sunxi/patches-3.18/102-dt-sun7i-add_mmc2_pins.patch b/target/linux/sunxi/patches-3.18/102-dt-sun7i-add_mmc2_pins.patch
new file mode 100644
index 0000000..6a5878e
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/102-dt-sun7i-add_mmc2_pins.patch
@@ -0,0 +1,28 @@
+From f65624ca1b67c5683317b75da2c09ffadc22fa2e Mon Sep 17 00:00:00 2001
+From: Hans de Goede <hdegoede@redhat.com>
+Date: Wed, 1 Oct 2014 00:40:57 +0200
+Subject: [PATCH] ARM: dts: sun7i: Add mmc2_pins_a pinctrl definition
+
+Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+---
+ arch/arm/boot/dts/sun7i-a20.dtsi | 7 +++++++
+ 1 file changed, 7 insertions(+)
+
+diff --git a/arch/arm/boot/dts/sun7i-a20.dtsi b/arch/arm/boot/dts/sun7i-a20.dtsi
+index cecf32c..f0a75c6 100644
+--- a/arch/arm/boot/dts/sun7i-a20.dtsi
++++ b/arch/arm/boot/dts/sun7i-a20.dtsi
+@@ -833,6 +833,13 @@
+ 				allwinner,pull = <1>;
+ 			};
+ 
++			mmc2_pins_a: mmc2@0 {
++				allwinner,pins = "PC6","PC7","PC8","PC9","PC10","PC11";
++				allwinner,function = "mmc2";
++				allwinner,drive = <2>;
++				allwinner,pull = <1>;
++			};
++
+ 			mmc3_pins_a: mmc3@0 {
+ 				allwinner,pins = "PI4","PI5","PI6","PI7","PI8","PI9";
+ 				allwinner,function = "mmc3";
diff --git a/target/linux/sunxi/patches-3.18/110-input-add-sun4i-lradc.patch b/target/linux/sunxi/patches-3.18/110-input-add-sun4i-lradc.patch
new file mode 100644
index 0000000..0772f15
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/110-input-add-sun4i-lradc.patch
@@ -0,0 +1,412 @@
+From 2c1fab89e83245a520871e807e233e66cbdb7c57 Mon Sep 17 00:00:00 2001
+From: Hans de Goede <hdegoede@redhat.com>
+Date: Wed, 1 Jan 2014 19:44:49 +0100
+Subject: [PATCH] input: Add new sun4i-lradc-keys driver
+
+Allwinnner sunxi SoCs have a low resolution adc (called lradc) which is
+specifically designed to have various (tablet) keys (ie home, back, search,
+etc). attached to it using a resistor network. This adds a driver for this.
+
+There are 2 channels, currently this driver only supports chan0 since there
+are no boards known to use chan1.
+
+This has been tested on an olimex a10s-olinuxino-micro, a13-olinuxino, and
+a20-olinuxino-micro.
+
+Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+--
+Changes in v2:
+-Change devicetree bindings to use a per key subnode, like gpio-keys does
+---
+ .../devicetree/bindings/input/sun4i-lradc-keys.txt |  62 +++++
+ MAINTAINERS                                        |   7 +
+ drivers/input/keyboard/Kconfig                     |  10 +
+ drivers/input/keyboard/Makefile                    |   1 +
+ drivers/input/keyboard/sun4i-lradc-keys.c          | 258 +++++++++++++++++++++
+ 5 files changed, 338 insertions(+)
+ create mode 100644 Documentation/devicetree/bindings/input/sun4i-lradc-keys.txt
+ create mode 100644 drivers/input/keyboard/sun4i-lradc-keys.c
+
+diff --git a/Documentation/devicetree/bindings/input/sun4i-lradc-keys.txt b/Documentation/devicetree/bindings/input/sun4i-lradc-keys.txt
+new file mode 100644
+index 0000000..b9c32f6
+--- /dev/null
++++ b/Documentation/devicetree/bindings/input/sun4i-lradc-keys.txt
+@@ -0,0 +1,62 @@
++Allwinner sun4i low res adc attached tablet keys
++------------------------------------------------
++
++Required properties:
++ - compatible: "allwinner,sun4i-a10-lradc-keys"
++ - reg: mmio address range of the chip
++ - interrupts: interrupt to which the chip is connected
++ - vref-supply: powersupply for the lradc reference voltage
++
++Each key is represented as a sub-node of "allwinner,sun4i-a10-lradc-keys":
++
++Required subnode-properties:
++	- label: Descriptive name of the key.
++	- linux,code: Keycode to emit.
++	- channel: Channel this key is attached to, mut be 0 or 1.
++	- voltage: Voltage in µV at lradc input when this key is pressed.
++
++Example:
++
++#include <dt-bindings/input/input.h>
++
++	lradc: lradc@01c22800 {
++		compatible = "allwinner,sun4i-a10-lradc-keys";
++		reg = <0x01c22800 0x100>;
++		interrupts = <31>;
++		vref-supply = <&reg_vcc3v0>;
++
++		button@191 {
++			label = "Volume Up";
++			linux,code = <KEY_VOLUMEUP>;
++			channel = <0>;
++			voltage = <191274>;
++		};
++
++		button@392 {
++			label = "Volume Down";
++			linux,code = <KEY_VOLUMEDOWN>;
++			channel = <0>;
++			voltage = <392644>;
++		};
++
++		button@601 {
++			label = "Menu";
++			linux,code = <KEY_MENU>;
++			channel = <0>;
++			voltage = <601151>;
++		};
++
++		button@795 {
++			label = "Enter";
++			linux,code = <KEY_ENTER>;
++			channel = <0>;
++			voltage = <795090>;
++		};
++
++		button@987 {
++			label = "Home";
++			linux,code = <KEY_HOMEPAGE>;
++			channel = <0>;
++			voltage = <987387>;
++		};
++	};
+diff --git a/MAINTAINERS b/MAINTAINERS
+index a20df9b..73d1aef 100644
+--- a/MAINTAINERS
++++ b/MAINTAINERS
+@@ -8932,6 +8932,13 @@ F:	arch/m68k/sun3*/
+ F:	arch/m68k/include/asm/sun3*
+ F:	drivers/net/ethernet/i825xx/sun3*
+ 
++SUN4I LOW RES ADC ATTACHED TABLET KEYS DRIVER
++M:	Hans de Goede <hdegoede@redhat.com>
++L:	linux-input@vger.kernel.org
++S:	Maintained
++F:	Documentation/devicetree/bindings/input/sun4i-lradc-keys.txt
++F:	drivers/input/keyboard/sun4i-lradc-keys.c
++
+ SUNDANCE NETWORK DRIVER
+ M:	Denis Kirjanov <kda@linux-powerpc.org>
+ L:	netdev@vger.kernel.org
+diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
+index a3958c6..2d11b44 100644
+--- a/drivers/input/keyboard/Kconfig
++++ b/drivers/input/keyboard/Kconfig
+@@ -567,6 +567,16 @@ config KEYBOARD_STMPE
+ 	  To compile this driver as a module, choose M here: the module will be
+ 	  called stmpe-keypad.
+ 
++config KEYBOARD_SUN4I_LRADC
++	tristate "Allwinner sun4i low res adc attached tablet keys support"
++	depends on ARCH_SUNXI
++	help
++	  This selects support for the Allwinner low res adc attached tablet
++	  keys found on Allwinner sunxi SoCs.
++
++	  To compile this driver as a module, choose M here: the
++	  module will be called sun4i-lradc-keys.
++
+ config KEYBOARD_DAVINCI
+ 	tristate "TI DaVinci Key Scan"
+ 	depends on ARCH_DAVINCI_DM365
+diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
+index 0a33456..a35269a 100644
+--- a/drivers/input/keyboard/Makefile
++++ b/drivers/input/keyboard/Makefile
+@@ -53,6 +53,7 @@ obj-$(CONFIG_KEYBOARD_SPEAR)		+= spear-keyboard.o
+ obj-$(CONFIG_KEYBOARD_STMPE)		+= stmpe-keypad.o
+ obj-$(CONFIG_KEYBOARD_STOWAWAY)		+= stowaway.o
+ obj-$(CONFIG_KEYBOARD_ST_KEYSCAN)	+= st-keyscan.o
++obj-$(CONFIG_KEYBOARD_SUN4I_LRADC)	+= sun4i-lradc-keys.o
+ obj-$(CONFIG_KEYBOARD_SUNKBD)		+= sunkbd.o
+ obj-$(CONFIG_KEYBOARD_TC3589X)		+= tc3589x-keypad.o
+ obj-$(CONFIG_KEYBOARD_TEGRA)		+= tegra-kbc.o
+diff --git a/drivers/input/keyboard/sun4i-lradc-keys.c b/drivers/input/keyboard/sun4i-lradc-keys.c
+new file mode 100644
+index 0000000..f11f002
+--- /dev/null
++++ b/drivers/input/keyboard/sun4i-lradc-keys.c
+@@ -0,0 +1,258 @@
++/*
++ * Allwinner sun4i low res adc attached tablet keys driver
++ *
++ * Copyright (C) 2014 Hans de Goede <hdegoede@redhat.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.
++ */
++
++/*
++ * Allwinnner sunxi SoCs have a lradc which is specifically designed to have
++ * various (tablet) keys (ie home, back, search, etc). attached to it using
++ * a resistor network. This driver is for the keys on such boards.
++ *
++ * There are 2 channels, currently this driver only supports channel 0 since
++ * there are no boards known to use channel 1.
++ */
++
++#include <linux/err.h>
++#include <linux/init.h>
++#include <linux/input.h>
++#include <linux/interrupt.h>
++#include <linux/io.h>
++#include <linux/module.h>
++#include <linux/of_platform.h>
++#include <linux/platform_device.h>
++#include <linux/regulator/consumer.h>
++#include <linux/slab.h>
++
++#define LRADC_CTRL		0x00
++#define LRADC_INTC		0x04
++#define LRADC_INTS		0x08
++#define LRADC_DATA0		0x0c
++#define LRADC_DATA1		0x10
++
++/* LRADC_CTRL bits */
++#define FIRST_CONVERT_DLY(x)	((x) << 24) /* 8 bits */
++#define CHAN_SELECT(x)		((x) << 22) /* 2 bits */
++#define CONTINUE_TIME_SEL(x)	((x) << 16) /* 4 bits */
++#define KEY_MODE_SEL(x)		((x) << 12) /* 2 bits */
++#define LEVELA_B_CNT(x)		((x) << 8)  /* 4 bits */
++#define HOLD_EN(x)		((x) << 6)
++#define LEVELB_VOL(x)		((x) << 4)  /* 2 bits */
++#define SAMPLE_RATE(x)		((x) << 2)  /* 2 bits */
++#define ENABLE(x)		((x) << 0)
++
++/* LRADC_INTC and LRADC_INTS bits */
++#define CHAN1_KEYUP_IRQ		BIT(12)
++#define CHAN1_ALRDY_HOLD_IRQ	BIT(11)
++#define CHAN1_HOLD_IRQ		BIT(10)
++#define	CHAN1_KEYDOWN_IRQ	BIT(9)
++#define CHAN1_DATA_IRQ		BIT(8)
++#define CHAN0_KEYUP_IRQ		BIT(4)
++#define CHAN0_ALRDY_HOLD_IRQ	BIT(3)
++#define CHAN0_HOLD_IRQ		BIT(2)
++#define	CHAN0_KEYDOWN_IRQ	BIT(1)
++#define CHAN0_DATA_IRQ		BIT(0)
++
++struct sun4i_lradc_keymap {
++	u32 voltage;
++	u32 keycode;
++};
++
++struct sun4i_lradc_data {
++	struct device *dev;
++	struct input_dev *input;
++	void __iomem *base;
++	struct regulator *vref_supply;
++	struct sun4i_lradc_keymap *chan0_map;
++	u32 chan0_map_count;
++	u32 chan0_keycode;
++	u32 vref;
++};
++
++static irqreturn_t sun4i_lradc_irq(int irq, void *dev_id)
++{
++	struct sun4i_lradc_data *lradc = dev_id;
++	u32 i, ints, val, voltage, diff, keycode = 0, closest = 0xffffffff;
++
++	ints  = readl(lradc->base + LRADC_INTS);
++
++	/*
++	 * lradc supports only one keypress at a time, release does not give
++	 * any info as to which key was released, so we cache the keycode.
++	 */
++	if ((ints & CHAN0_KEYDOWN_IRQ) && lradc->chan0_keycode == 0) {
++		val = readl(lradc->base + LRADC_DATA0) & 0x3f;
++		voltage = val * lradc->vref / 63;
++
++		for (i = 0; i < lradc->chan0_map_count; i++) {
++			diff = abs(lradc->chan0_map[i].voltage - voltage);
++			if (diff < closest) {
++				closest = diff;
++				keycode = lradc->chan0_map[i].keycode;
++			}
++		}
++
++		lradc->chan0_keycode = keycode;
++		input_report_key(lradc->input, lradc->chan0_keycode, 1);
++	}
++
++	if (ints & CHAN0_KEYUP_IRQ) {
++		input_report_key(lradc->input, lradc->chan0_keycode, 0);
++		lradc->chan0_keycode = 0;
++	}
++
++	input_sync(lradc->input);
++
++	writel(ints, lradc->base + LRADC_INTS);
++
++	return IRQ_HANDLED;
++}
++
++static int sun4i_lradc_open(struct input_dev *dev)
++{
++	struct sun4i_lradc_data *lradc = input_get_drvdata(dev);
++	int ret;
++
++	ret = regulator_enable(lradc->vref_supply);
++	if (ret)
++		return ret;
++
++	/* lradc Vref internally is divided by 2/3 */
++	lradc->vref = regulator_get_voltage(lradc->vref_supply) * 2 / 3;
++
++	/*
++	 * Set sample time to 4 ms / 250 Hz. Wait 2 * 4 ms for key to
++	 * stabilize on press, wait (1 + 1) * 4 ms for key release
++	 */
++	writel(FIRST_CONVERT_DLY(2) | LEVELA_B_CNT(1) | HOLD_EN(1) |
++		SAMPLE_RATE(0) | ENABLE(1), lradc->base + LRADC_CTRL);
++
++	writel(CHAN0_KEYUP_IRQ | CHAN0_KEYDOWN_IRQ, lradc->base + LRADC_INTC);
++
++	return 0;
++}
++
++static void sun4i_lradc_close(struct input_dev *dev)
++{
++	struct sun4i_lradc_data *lradc = input_get_drvdata(dev);
++
++	/* Disable lradc, leave other settings unchanged */
++	writel(FIRST_CONVERT_DLY(2) | LEVELA_B_CNT(1) | HOLD_EN(1) |
++		SAMPLE_RATE(2), lradc->base + LRADC_CTRL);
++	writel(0, lradc->base + LRADC_INTC);
++
++	regulator_disable(lradc->vref_supply);
++}
++
++static int sun4i_lradc_probe(struct platform_device *pdev)
++{
++	struct sun4i_lradc_data *lradc;
++	struct device *dev = &pdev->dev;
++	struct device_node *pp, *np = dev->of_node;
++	u32 channel;
++	int i, ret;
++
++	lradc = devm_kzalloc(dev, sizeof(struct sun4i_lradc_data), GFP_KERNEL);
++	if (!lradc)
++		return -ENOMEM;
++
++	lradc->chan0_map_count = of_get_child_count(np);
++	lradc->chan0_map = devm_kmalloc(dev, lradc->chan0_map_count *
++				sizeof(struct sun4i_lradc_keymap), GFP_KERNEL);
++	if (!lradc->chan0_map)
++		return -ENOMEM;
++
++	i = 0;
++	for_each_child_of_node(np, pp) {
++		struct sun4i_lradc_keymap *map = &lradc->chan0_map[i];
++
++		ret = of_property_read_u32(pp, "channel", &channel);
++		if (ret || channel != 0) {
++			dev_err(dev, "%s: Inval channel prop\n", pp->name);
++			return -EINVAL;
++		}
++
++		ret = of_property_read_u32(pp, "voltage", &map->voltage);
++		if (ret) {
++			dev_err(dev, "%s: Inval voltage prop\n", pp->name);
++			return -EINVAL;
++		}
++
++		ret = of_property_read_u32(pp, "linux,code", &map->keycode);
++		if (ret) {
++			dev_err(dev, "%s: Inval linux,code prop\n", pp->name);
++			return -EINVAL;
++		}
++
++		i++;
++	}
++
++	lradc->vref_supply = devm_regulator_get(dev, "vref");
++	if (IS_ERR(lradc->vref_supply))
++		return PTR_ERR(lradc->vref_supply);
++
++	lradc->dev = dev;
++	lradc->input = devm_input_allocate_device(dev);
++	if (!lradc->input)
++		return -ENOMEM;
++
++	lradc->input->name = pdev->name;
++	lradc->input->phys = "sun4i_lradc/input0";
++	lradc->input->open = sun4i_lradc_open;
++	lradc->input->close = sun4i_lradc_close;
++	lradc->input->id.bustype = BUS_HOST;
++	lradc->input->id.vendor = 0x0001;
++	lradc->input->id.product = 0x0001;
++	lradc->input->id.version = 0x0100;
++	lradc->input->evbit[0] =  BIT(EV_SYN) | BIT(EV_KEY);
++	for (i = 0; i < lradc->chan0_map_count; i++)
++		set_bit(lradc->chan0_map[i].keycode, lradc->input->keybit);
++	input_set_drvdata(lradc->input, lradc);
++
++	lradc->base = devm_ioremap_resource(dev,
++			      platform_get_resource(pdev, IORESOURCE_MEM, 0));
++	if (IS_ERR(lradc->base))
++		return PTR_ERR(lradc->base);
++
++	ret = devm_request_irq(dev, platform_get_irq(pdev, 0), sun4i_lradc_irq,
++			       0, "sun4i-a10-lradc-keys", lradc);
++	if (ret)
++		return ret;
++
++	ret = input_register_device(lradc->input);
++	if (ret)
++		return ret;
++
++	platform_set_drvdata(pdev, lradc);
++	return 0;
++}
++
++static const struct of_device_id sun4i_lradc_of_match[] = {
++	{ .compatible = "allwinner,sun4i-a10-lradc-keys", },
++	{ /* sentinel */ }
++};
++MODULE_DEVICE_TABLE(of, sun4i_lradc_of_match);
++
++static struct platform_driver sun4i_lradc_driver = {
++	.driver = {
++		.name	= "sun4i-a10-lradc-keys",
++		.of_match_table = of_match_ptr(sun4i_lradc_of_match),
++	},
++	.probe	= sun4i_lradc_probe,
++};
++
++module_platform_driver(sun4i_lradc_driver);
++
++MODULE_DESCRIPTION("Allwinner sun4i low res adc attached tablet keys driver");
++MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
++MODULE_LICENSE("GPL");
diff --git a/target/linux/sunxi/patches-3.18/111-dt-sun4i-add-lradc.patch b/target/linux/sunxi/patches-3.18/111-dt-sun4i-add-lradc.patch
new file mode 100644
index 0000000..0ffe4e8
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/111-dt-sun4i-add-lradc.patch
@@ -0,0 +1,28 @@
+From f39ea4358d2e4b939b8ca55ee344d3c8fdfc0a6a Mon Sep 17 00:00:00 2001
+From: Hans de Goede <hdegoede@redhat.com>
+Date: Wed, 1 Jan 2014 19:51:36 +0100
+Subject: [PATCH] ARM: dts: sun4i: Add lradc node
+
+Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+---
+ arch/arm/boot/dts/sun4i-a10.dtsi | 7 +++++++
+ 1 file changed, 7 insertions(+)
+
+diff --git a/arch/arm/boot/dts/sun4i-a10.dtsi b/arch/arm/boot/dts/sun4i-a10.dtsi
+index 380f914..1ef7d57 100644
+--- a/arch/arm/boot/dts/sun4i-a10.dtsi
++++ b/arch/arm/boot/dts/sun4i-a10.dtsi
+@@ -669,6 +669,13 @@
+ 			status = "disabled";
+ 		};
+ 
++		lradc: lradc@01c22800 {
++			compatible = "allwinner,sun4i-a10-lradc-keys";
++			reg = <0x01c22800 0x100>;
++			interrupts = <31>;
++			status = "disabled";
++		};
++
+ 		sid: eeprom@01c23800 {
+ 			compatible = "allwinner,sun4i-a10-sid";
+ 			reg = <0x01c23800 0x10>;
diff --git a/target/linux/sunxi/patches-3.18/112-dt-sun5i-add-lradc.patch b/target/linux/sunxi/patches-3.18/112-dt-sun5i-add-lradc.patch
new file mode 100644
index 0000000..22dfe51
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/112-dt-sun5i-add-lradc.patch
@@ -0,0 +1,175 @@
+From 3bf1194692f3a275e0776d3c0b6f17826cc01baa Mon Sep 17 00:00:00 2001
+From: Hans de Goede <hdegoede@redhat.com>
+Date: Wed, 1 Jan 2014 19:50:33 +0100
+Subject: [PATCH] ARM: dts: sun5i: Add lradc node
+
+Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+---
+ arch/arm/boot/dts/sun5i-a10s-olinuxino-micro.dts | 45 ++++++++++++++++++++++--
+ arch/arm/boot/dts/sun5i-a10s.dtsi                |  7 ++++
+ arch/arm/boot/dts/sun5i-a13-olinuxino.dts        | 45 ++++++++++++++++++++++--
+ arch/arm/boot/dts/sun5i-a13.dtsi                 |  7 ++++
+ 4 files changed, 100 insertions(+), 4 deletions(-)
+
+diff --git a/arch/arm/boot/dts/sun5i-a10s-olinuxino-micro.dts b/arch/arm/boot/dts/sun5i-a10s-olinuxino-micro.dts
+index ea9519d..0b82d20 100644
+--- a/arch/arm/boot/dts/sun5i-a10s-olinuxino-micro.dts
++++ b/arch/arm/boot/dts/sun5i-a10s-olinuxino-micro.dts
+@@ -12,8 +12,9 @@
+  */
+ 
+ /dts-v1/;
+-/include/ "sun5i-a10s.dtsi"
+-/include/ "sunxi-common-regulators.dtsi"
++#include "sun5i-a10s.dtsi"
++#include "sunxi-common-regulators.dtsi"
++#include <dt-bindings/input/input.h>
+ 
+ / {
+ 	model = "Olimex A10s-Olinuxino Micro";
+@@ -98,6 +99,46 @@
+ 			};
+ 		};
+ 
++		lradc: lradc@01c22800 {
++			vref-supply = <&reg_vcc3v0>;
++			status = "okay";
++
++			button@191 {
++				label = "Volume Up";
++				linux,code = <KEY_VOLUMEUP>;
++				channel = <0>;
++				voltage = <191274>;
++			};
++
++			button@392 {
++				label = "Volume Down";
++				linux,code = <KEY_VOLUMEDOWN>;
++				channel = <0>;
++				voltage = <392644>;
++			};
++
++			button@601 {
++				label = "Menu";
++				linux,code = <KEY_MENU>;
++				channel = <0>;
++				voltage = <601151>;
++			};
++
++			button@795 {
++				label = "Enter";
++				linux,code = <KEY_ENTER>;
++				channel = <0>;
++				voltage = <795090>;
++			};
++
++			button@987 {
++				label = "Home";
++				linux,code = <KEY_HOMEPAGE>;
++				channel = <0>;
++				voltage = <987387>;
++			};
++		};
++
+ 		uart0: serial@01c28000 {
+ 			pinctrl-names = "default";
+ 			pinctrl-0 = <&uart0_pins_a>;
+diff --git a/arch/arm/boot/dts/sun5i-a10s.dtsi b/arch/arm/boot/dts/sun5i-a10s.dtsi
+index 531272c..7c6c883 100644
+--- a/arch/arm/boot/dts/sun5i-a10s.dtsi
++++ b/arch/arm/boot/dts/sun5i-a10s.dtsi
+@@ -520,6 +520,13 @@
+ 			reg = <0x01c20c90 0x10>;
+ 		};
+ 
++		lradc: lradc@01c22800 {
++			compatible = "allwinner,sun4i-a10-lradc-keys";
++			reg = <0x01c22800 0x100>;
++			interrupts = <31>;
++			status = "disabled";
++		};
++
+ 		sid: eeprom@01c23800 {
+ 			compatible = "allwinner,sun4i-a10-sid";
+ 			reg = <0x01c23800 0x10>;
+diff --git a/arch/arm/boot/dts/sun5i-a13-olinuxino.dts b/arch/arm/boot/dts/sun5i-a13-olinuxino.dts
+index 429994e..b4ec8eb 100644
+--- a/arch/arm/boot/dts/sun5i-a13-olinuxino.dts
++++ b/arch/arm/boot/dts/sun5i-a13-olinuxino.dts
+@@ -12,8 +12,9 @@
+  */
+ 
+ /dts-v1/;
+-/include/ "sun5i-a13.dtsi"
+-/include/ "sunxi-common-regulators.dtsi"
++#include "sun5i-a13.dtsi"
++#include "sunxi-common-regulators.dtsi"
++#include <dt-bindings/input/input.h>
+ 
+ / {
+ 	model = "Olimex A13-Olinuxino";
+@@ -66,6 +67,46 @@
+ 			};
+ 		};
+ 
++		lradc: lradc@01c22800 {
++			vref-supply = <&reg_vcc3v0>;
++			status = "okay";
++
++			button@191 {
++				label = "Volume Up";
++				linux,code = <KEY_VOLUMEUP>;
++				channel = <0>;
++				voltage = <191274>;
++			};
++
++			button@392 {
++				label = "Volume Down";
++				linux,code = <KEY_VOLUMEDOWN>;
++				channel = <0>;
++				voltage = <392644>;
++			};
++
++			button@601 {
++				label = "Menu";
++				linux,code = <KEY_MENU>;
++				channel = <0>;
++				voltage = <601151>;
++			};
++
++			button@795 {
++				label = "Enter";
++				linux,code = <KEY_ENTER>;
++				channel = <0>;
++				voltage = <795090>;
++			};
++
++			button@987 {
++				label = "Home";
++				linux,code = <KEY_HOMEPAGE>;
++				channel = <0>;
++				voltage = <987387>;
++			};
++		};
++
+ 		uart1: serial@01c28400 {
+ 			pinctrl-names = "default";
+ 			pinctrl-0 = <&uart1_pins_b>;
+diff --git a/arch/arm/boot/dts/sun5i-a13.dtsi b/arch/arm/boot/dts/sun5i-a13.dtsi
+index b131068..aa0482c 100644
+--- a/arch/arm/boot/dts/sun5i-a13.dtsi
++++ b/arch/arm/boot/dts/sun5i-a13.dtsi
+@@ -468,6 +468,13 @@
+ 			reg = <0x01c20c90 0x10>;
+ 		};
+ 
++		lradc: lradc@01c22800 {
++			compatible = "allwinner,sun4i-a10-lradc-keys";
++			reg = <0x01c22800 0x100>;
++			interrupts = <31>;
++			status = "disabled";
++		};
++
+ 		sid: eeprom@01c23800 {
+ 			compatible = "allwinner,sun4i-a10-sid";
+ 			reg = <0x01c23800 0x10>;
diff --git a/target/linux/sunxi/patches-3.18/113-dt-sun7i-add-lradc.patch b/target/linux/sunxi/patches-3.18/113-dt-sun7i-add-lradc.patch
new file mode 100644
index 0000000..50a66b6
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/113-dt-sun7i-add-lradc.patch
@@ -0,0 +1,106 @@
+From a735a9b354ebc1a17b648ef8c3482c71fdbf40da Mon Sep 17 00:00:00 2001
+From: Hans de Goede <hdegoede@redhat.com>
+Date: Wed, 1 Jan 2014 20:26:21 +0100
+Subject: [PATCH] ARM: dts: sun7i: Add lradc node
+
+Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+---
+ arch/arm/boot/dts/sun7i-a20-olinuxino-micro.dts | 59 ++++++++++++++++++++++++-
+ arch/arm/boot/dts/sun7i-a20.dtsi                |  7 +++
+ 2 files changed, 64 insertions(+), 2 deletions(-)
+
+diff --git a/arch/arm/boot/dts/sun7i-a20-olinuxino-micro.dts b/arch/arm/boot/dts/sun7i-a20-olinuxino-micro.dts
+index 9d669cdf..c00badd 100644
+--- a/arch/arm/boot/dts/sun7i-a20-olinuxino-micro.dts
++++ b/arch/arm/boot/dts/sun7i-a20-olinuxino-micro.dts
+@@ -12,8 +12,9 @@
+  */
+ 
+ /dts-v1/;
+-/include/ "sun7i-a20.dtsi"
+-/include/ "sunxi-common-regulators.dtsi"
++#include "sun7i-a20.dtsi"
++#include "sunxi-common-regulators.dtsi"
++#include <dt-bindings/input/input.h>
+ 
+ / {
+ 	model = "Olimex A20-Olinuxino Micro";
+@@ -100,6 +101,60 @@
+ 			};
+ 		};
+ 
++		lradc: lradc@01c22800 {
++			vref-supply = <&reg_vcc3v0>;
++			status = "okay";
++
++			button@191 {
++				label = "Volume Up";
++				linux,code = <KEY_VOLUMEUP>;
++				channel = <0>;
++				voltage = <191274>;
++			};
++
++			button@392 {
++				label = "Volume Down";
++				linux,code = <KEY_VOLUMEDOWN>;
++				channel = <0>;
++				voltage = <392644>;
++			};
++
++			button@601 {
++				label = "Menu";
++				linux,code = <KEY_MENU>;
++				channel = <0>;
++				voltage = <601151>;
++			};
++
++			button@795 {
++				label = "Search";
++				linux,code = <KEY_SEARCH>;
++				channel = <0>;
++				voltage = <795090>;
++			};
++
++			button@987 {
++				label = "Home";
++				linux,code = <KEY_HOMEPAGE>;
++				channel = <0>;
++				voltage = <987387>;
++			};
++
++			button@1184 {
++				label = "Esc";
++				linux,code = <KEY_ESC>;
++				channel = <0>;
++				voltage = <1184678>;
++			};
++
++			button@1398 {
++				label = "Enter";
++				linux,code = <KEY_ENTER>;
++				channel = <0>;
++				voltage = <1398804>;
++			};
++		};
++
+ 		uart0: serial@01c28000 {
+ 			pinctrl-names = "default";
+ 			pinctrl-0 = <&uart0_pins_a>;
+diff --git a/arch/arm/boot/dts/sun7i-a20.dtsi b/arch/arm/boot/dts/sun7i-a20.dtsi
+index f0a75c6..9174423 100644
+--- a/arch/arm/boot/dts/sun7i-a20.dtsi
++++ b/arch/arm/boot/dts/sun7i-a20.dtsi
+@@ -911,6 +911,13 @@
+ 			status = "disabled";
+ 		};
+ 
++		lradc: lradc@01c22800 {
++			compatible = "allwinner,sun4i-a10-lradc-keys";
++			reg = <0x01c22800 0x100>;
++			interrupts = <0 31 4>;
++			status = "disabled";
++		};
++
+ 		sid: eeprom@01c23800 {
+ 			compatible = "allwinner,sun7i-a20-sid";
+ 			reg = <0x01c23800 0x200>;
diff --git a/target/linux/sunxi/patches-3.18/115-input-sun4i-ts-update-temp-curve.patch b/target/linux/sunxi/patches-3.18/115-input-sun4i-ts-update-temp-curve.patch
new file mode 100644
index 0000000..bff74e4
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/115-input-sun4i-ts-update-temp-curve.patch
@@ -0,0 +1,83 @@
+From 2e2493cd07405dfa88e53199b47bdbbb5336fdce Mon Sep 17 00:00:00 2001
+From: Hans de Goede <hdegoede@redhat.com>
+Date: Mon, 16 Jun 2014 20:01:12 +0200
+Subject: [PATCH] touchscreen: sun4i-ts: A10 (sun4i) has a different
+ temperature curve
+
+Testing has revealed that the temperature in the rtp controller of the A10
+(sun4i) SoC has a different curve then on the A13 (sun5i) and later models.
+
+Add a new sun5i-a13-ts compatible to differentiate the newer models and
+set the curve based on the compatible string.
+
+This fixes the temperature reported on the A10 being much higher then
+expected.
+
+Note the new curve is still not ideal on all A10-s, that seems to have to
+do with there being a large spread between different A10-s out there.
+
+Reported-by: Tong Zhang <lovewilliam@gmail.com>
+Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+---
+ .../devicetree/bindings/input/touchscreen/sun4i.txt         |  2 +-
+ drivers/input/touchscreen/sun4i-ts.c                        | 13 ++++++++++++-
+ 2 files changed, 13 insertions(+), 2 deletions(-)
+
+diff --git a/Documentation/devicetree/bindings/input/touchscreen/sun4i.txt b/Documentation/devicetree/bindings/input/touchscreen/sun4i.txt
+index aef5779..5106709 100644
+--- a/Documentation/devicetree/bindings/input/touchscreen/sun4i.txt
++++ b/Documentation/devicetree/bindings/input/touchscreen/sun4i.txt
+@@ -2,7 +2,7 @@ sun4i resistive touchscreen controller
+ --------------------------------------
+ 
+ Required properties:
+- - compatible: "allwinner,sun4i-a10-ts"
++ - compatible: "allwinner,sun4i-a10-ts" or "allwinner,sun5i-a13-ts"
+  - reg: mmio address range of the chip
+  - interrupts: interrupt to which the chip is connected
+ 
+diff --git a/drivers/input/touchscreen/sun4i-ts.c b/drivers/input/touchscreen/sun4i-ts.c
+index 2ba8260..52b7114 100644
+--- a/drivers/input/touchscreen/sun4i-ts.c
++++ b/drivers/input/touchscreen/sun4i-ts.c
+@@ -111,6 +111,8 @@ struct sun4i_ts_data {
+ 	unsigned int irq;
+ 	bool ignore_fifo_data;
+ 	int temp_data;
++	int temp_offset;
++	int temp_step;
+ };
+ 
+ static void sun4i_ts_irq_handle_input(struct sun4i_ts_data *ts, u32 reg_val)
+@@ -189,7 +191,8 @@ static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
+ 	if (ts->temp_data == -1)
+ 		return -EAGAIN;
+ 
+-	return sprintf(buf, "%d\n", (ts->temp_data - 1447) * 100);
++	return sprintf(buf, "%d\n",
++		       (ts->temp_data - ts->temp_offset) * ts->temp_step);
+ }
+ 
+ static ssize_t show_temp_label(struct device *dev,
+@@ -224,6 +227,13 @@ static int sun4i_ts_probe(struct platform_device *pdev)
+ 	ts->dev = dev;
+ 	ts->ignore_fifo_data = true;
+ 	ts->temp_data = -1;
++	if (of_device_is_compatible(np, "allwinner,sun4i-a10-ts")) {
++		ts->temp_offset = 1900;
++		ts->temp_step = 100;
++	} else {
++		ts->temp_offset = 1447;
++		ts->temp_step = 100;
++	}
+ 
+ 	ts_attached = of_property_read_bool(np, "allwinner,ts-attached");
+ 	if (ts_attached) {
+@@ -318,6 +328,7 @@ static int sun4i_ts_remove(struct platform_device *pdev)
+ 
+ static const struct of_device_id sun4i_ts_of_match[] = {
+ 	{ .compatible = "allwinner,sun4i-a10-ts", },
++	{ .compatible = "allwinner,sun5i-a13-ts", },
+ 	{ /* sentinel */ }
+ };
+ MODULE_DEVICE_TABLE(of, sun4i_ts_of_match);
diff --git a/target/linux/sunxi/patches-3.18/116-dt-sunxi-update-compats-for-tempcurves.patch b/target/linux/sunxi/patches-3.18/116-dt-sunxi-update-compats-for-tempcurves.patch
new file mode 100644
index 0000000..861538f
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/116-dt-sunxi-update-compats-for-tempcurves.patch
@@ -0,0 +1,57 @@
+From ff774d842a2bf9136b9c7ddd7f5085a9062705ac Mon Sep 17 00:00:00 2001
+From: Hans de Goede <hdegoede@redhat.com>
+Date: Mon, 16 Jun 2014 20:06:43 +0200
+Subject: [PATCH] ARM: dts: sunxi: Adjust touchscreen compatible for sun5i and
+ later
+
+The touchscreen controller in the A13 and later has a different temperature
+curve than the one in the original A10, change the compatible for the A13 and
+later so that the kernel will use the correct curve.
+
+Reported-by: Tong Zhang <lovewilliam@gmail.com>
+Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+---
+ arch/arm/boot/dts/sun5i-a10s.dtsi | 2 +-
+ arch/arm/boot/dts/sun5i-a13.dtsi  | 2 +-
+ arch/arm/boot/dts/sun7i-a20.dtsi  | 2 +-
+ 3 files changed, 3 insertions(+), 3 deletions(-)
+
+diff --git a/arch/arm/boot/dts/sun5i-a10s.dtsi b/arch/arm/boot/dts/sun5i-a10s.dtsi
+index 7c6c883..7089284 100644
+--- a/arch/arm/boot/dts/sun5i-a10s.dtsi
++++ b/arch/arm/boot/dts/sun5i-a10s.dtsi
+@@ -533,7 +533,7 @@
+ 		};
+ 
+ 		rtp: rtp@01c25000 {
+-			compatible = "allwinner,sun4i-a10-ts";
++			compatible = "allwinner,sun5i-a13-ts";
+ 			reg = <0x01c25000 0x100>;
+ 			interrupts = <29>;
+ 		};
+diff --git a/arch/arm/boot/dts/sun5i-a13.dtsi b/arch/arm/boot/dts/sun5i-a13.dtsi
+index aa0482c..b05ab04 100644
+--- a/arch/arm/boot/dts/sun5i-a13.dtsi
++++ b/arch/arm/boot/dts/sun5i-a13.dtsi
+@@ -481,7 +481,7 @@
+ 		};
+ 
+ 		rtp: rtp@01c25000 {
+-			compatible = "allwinner,sun4i-a10-ts";
++			compatible = "allwinner,sun5i-a13-ts";
+ 			reg = <0x01c25000 0x100>;
+ 			interrupts = <29>;
+ 		};
+diff --git a/arch/arm/boot/dts/sun7i-a20.dtsi b/arch/arm/boot/dts/sun7i-a20.dtsi
+index 9174423..81d4e55 100644
+--- a/arch/arm/boot/dts/sun7i-a20.dtsi
++++ b/arch/arm/boot/dts/sun7i-a20.dtsi
+@@ -924,7 +924,7 @@
+ 		};
+ 
+ 		rtp: rtp@01c25000 {
+-			compatible = "allwinner,sun4i-a10-ts";
++			compatible = "allwinner,sun5i-a13-ts";
+ 			reg = <0x01c25000 0x100>;
+ 			interrupts = <0 29 4>;
+ 		};
diff --git a/target/linux/sunxi/patches-3.18/130-input-add-axp20x-pek.patch b/target/linux/sunxi/patches-3.18/130-input-add-axp20x-pek.patch
new file mode 100644
index 0000000..537ba36
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/130-input-add-axp20x-pek.patch
@@ -0,0 +1,339 @@
+From 63d559304a15ffead2fa1014b93dbcabf516c257 Mon Sep 17 00:00:00 2001
+From: Carlo Caione <carlo@caione.org>
+Date: Mon, 19 May 2014 21:47:45 +0200
+Subject: [PATCH] input: misc: Add driver for AXP20x Power Enable Key
+
+This patch add support for the Power Enable Key found on MFD AXP202 and
+AXP209. Besides the basic support for the button, the driver adds two
+entries in sysfs to configure the time delay for power on/off.
+
+Signed-off-by: Carlo Caione <carlo@caione.org>
+Acked-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
+---
+ drivers/input/misc/Kconfig      |  11 ++
+ drivers/input/misc/Makefile     |   1 +
+ drivers/input/misc/axp20x-pek.c | 281 ++++++++++++++++++++++++++++++++++++++++
+ 3 files changed, 293 insertions(+)
+ create mode 100644 drivers/input/misc/axp20x-pek.c
+
+diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
+index 23297ab..a49bcd3 100644
+--- a/drivers/input/misc/Kconfig
++++ b/drivers/input/misc/Kconfig
+@@ -404,6 +404,17 @@ config INPUT_RETU_PWRBUTTON
+ 	  To compile this driver as a module, choose M here. The module will
+ 	  be called retu-pwrbutton.
+ 
++config INPUT_AXP20X_PEK
++	tristate "X-Powers AXP20X power button driver"
++	depends on MFD_AXP20X
++	help
++	  Say Y here if you want to enable power key reporting via the
++	  AXP20X PMIC.
++
++	  To compile this driver as a module, choose M here. The module will
++	  be called axp20x-pek.
++
++
+ config INPUT_TWL4030_PWRBUTTON
+ 	tristate "TWL4030 Power button Driver"
+ 	depends on TWL4030_CORE
+diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
+index 19c7603..04ea87f 100644
+--- a/drivers/input/misc/Makefile
++++ b/drivers/input/misc/Makefile
+@@ -54,6 +54,7 @@ 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_AXP20X_PEK)		+= axp20x-pek.o
+ obj-$(CONFIG_INPUT_GPIO_ROTARY_ENCODER)	+= rotary_encoder.o
+ obj-$(CONFIG_INPUT_SGI_BTNS)		+= sgi_btns.o
+ obj-$(CONFIG_INPUT_SIRFSOC_ONKEY)	+= sirfsoc-onkey.o
+diff --git a/drivers/input/misc/axp20x-pek.c b/drivers/input/misc/axp20x-pek.c
+new file mode 100644
+index 0000000..0fba252
+--- /dev/null
++++ b/drivers/input/misc/axp20x-pek.c
+@@ -0,0 +1,281 @@
++/*
++ * axp20x power button driver.
++ *
++ * Copyright (C) 2013 Carlo Caione <carlo@caione.org>
++ *
++ * 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/errno.h>
++#include <linux/irq.h>
++#include <linux/init.h>
++#include <linux/input.h>
++#include <linux/interrupt.h>
++#include <linux/kernel.h>
++#include <linux/mfd/axp20x.h>
++#include <linux/module.h>
++#include <linux/platform_device.h>
++#include <linux/regmap.h>
++#include <linux/slab.h>
++
++#define AXP20X_PEK_STARTUP_MASK		(0xc0)
++#define AXP20X_PEK_SHUTDOWN_MASK	(0x03)
++
++struct axp20x_pek {
++	struct axp20x_dev *axp20x;
++	struct input_dev *input;
++	int irq_dbr;
++	int irq_dbf;
++};
++
++struct axp20x_time {
++	unsigned int time;
++	unsigned int idx;
++};
++
++static const struct axp20x_time startup_time[] = {
++	{ .time = 128,  .idx = 0 },
++	{ .time = 1000, .idx = 2 },
++	{ .time = 3000, .idx = 1 },
++	{ .time = 2000, .idx = 3 },
++};
++
++static const struct axp20x_time shutdown_time[] = {
++	{ .time = 4000,  .idx = 0 },
++	{ .time = 6000,  .idx = 1 },
++	{ .time = 8000,  .idx = 2 },
++	{ .time = 10000, .idx = 3 },
++};
++
++struct axp20x_pek_ext_attr {
++	const struct axp20x_time *p_time;
++	unsigned int mask;
++};
++
++static struct axp20x_pek_ext_attr axp20x_pek_startup_ext_attr = {
++	.p_time	= startup_time,
++	.mask	= AXP20X_PEK_STARTUP_MASK,
++};
++
++static struct axp20x_pek_ext_attr axp20x_pek_shutdown_ext_attr = {
++	.p_time	= shutdown_time,
++	.mask	= AXP20X_PEK_SHUTDOWN_MASK,
++};
++
++static struct axp20x_pek_ext_attr *get_axp_ext_attr(struct device_attribute *attr)
++{
++	return container_of(attr, struct dev_ext_attribute, attr)->var;
++}
++
++static ssize_t axp20x_show_ext_attr(struct device *dev, struct device_attribute *attr,
++				    char *buf)
++{
++	struct axp20x_pek *axp20x_pek = dev_get_drvdata(dev);
++	struct axp20x_pek_ext_attr *axp20x_ea = get_axp_ext_attr(attr);
++	unsigned int val;
++	int ret, i;
++
++	ret = regmap_read(axp20x_pek->axp20x->regmap, AXP20X_PEK_KEY, &val);
++	if (ret != 0)
++		return ret;
++
++	val &= axp20x_ea->mask;
++	val >>= ffs(axp20x_ea->mask) - 1;
++
++	for (i = 0; i < 4; i++)
++		if (val == axp20x_ea->p_time[i].idx)
++			val = axp20x_ea->p_time[i].time;
++
++	return sprintf(buf, "%u\n", val);
++}
++
++static ssize_t axp20x_store_ext_attr(struct device *dev, struct device_attribute *attr,
++				     const char *buf, size_t count)
++{
++	struct axp20x_pek *axp20x_pek = dev_get_drvdata(dev);
++	struct axp20x_pek_ext_attr *axp20x_ea = get_axp_ext_attr(attr);
++	char val_str[20];
++	size_t len;
++	int ret, i;
++	unsigned int val, idx = 0;
++	unsigned int best_err = UINT_MAX;
++
++	val_str[sizeof(val_str) - 1] = '\0';
++	strncpy(val_str, buf, sizeof(val_str) - 1);
++	len = strlen(val_str);
++
++	if (len && val_str[len - 1] == '\n')
++		val_str[len - 1] = '\0';
++
++	ret = kstrtouint(val_str, 10, &val);
++	if (ret)
++		return ret;
++
++	for (i = 3; i >= 0; i--) {
++		unsigned int err;
++
++		err = abs(axp20x_ea->p_time[i].time - val);
++		if (err < best_err) {
++			best_err = err;
++			idx = axp20x_ea->p_time[i].idx;
++		}
++
++		if (!err)
++			break;
++	}
++
++	idx <<= ffs(axp20x_ea->mask) - 1;
++	ret = regmap_update_bits(axp20x_pek->axp20x->regmap,
++				 AXP20X_PEK_KEY,
++				 axp20x_ea->mask, idx);
++	if (ret != 0)
++		return -EINVAL;
++	return count;
++}
++
++static struct dev_ext_attribute axp20x_dev_attr_startup = {
++	.attr	= __ATTR(startup, 0644, axp20x_show_ext_attr, axp20x_store_ext_attr),
++	.var	= &axp20x_pek_startup_ext_attr
++};
++
++static struct dev_ext_attribute axp20x_dev_attr_shutdown = {
++	.attr	= __ATTR(shutdown, 0644, axp20x_show_ext_attr, axp20x_store_ext_attr),
++	.var	= &axp20x_pek_shutdown_ext_attr
++};
++
++static irqreturn_t axp20x_pek_irq(int irq, void *pwr)
++{
++	struct input_dev *idev = pwr;
++	struct axp20x_pek *axp20x_pek = input_get_drvdata(idev);
++
++	if (irq == axp20x_pek->irq_dbr)
++		input_report_key(idev, KEY_POWER, true);
++	else if (irq == axp20x_pek->irq_dbf)
++		input_report_key(idev, KEY_POWER, false);
++
++	input_sync(idev);
++
++	return IRQ_HANDLED;
++}
++
++static int axp20x_pek_probe(struct platform_device *pdev)
++{
++	struct axp20x_pek *axp20x_pek;
++	struct axp20x_dev *axp20x;
++	struct input_dev *idev;
++	int error;
++
++	axp20x_pek = devm_kzalloc(&pdev->dev, sizeof(struct axp20x_pek),
++				  GFP_KERNEL);
++	if (!axp20x_pek)
++		return -ENOMEM;
++
++	axp20x_pek->axp20x = dev_get_drvdata(pdev->dev.parent);
++	axp20x = axp20x_pek->axp20x;
++
++	axp20x_pek->irq_dbr = platform_get_irq_byname(pdev, "PEK_DBR");
++	if (axp20x_pek->irq_dbr < 0) {
++		dev_err(&pdev->dev, "No IRQ for PEK_DBR, error=%d\n",
++				axp20x_pek->irq_dbr);
++		return axp20x_pek->irq_dbr;
++	}
++	axp20x_pek->irq_dbr = regmap_irq_get_virq(axp20x->regmap_irqc,
++						  axp20x_pek->irq_dbr);
++
++	axp20x_pek->irq_dbf = platform_get_irq_byname(pdev, "PEK_DBF");
++	if (axp20x_pek->irq_dbf < 0) {
++		dev_err(&pdev->dev, "No IRQ for PEK_DBF, error=%d\n",
++				axp20x_pek->irq_dbf);
++		return axp20x_pek->irq_dbf;
++	}
++	axp20x_pek->irq_dbf = regmap_irq_get_virq(axp20x->regmap_irqc,
++						  axp20x_pek->irq_dbf);
++
++	axp20x_pek->input = devm_input_allocate_device(&pdev->dev);
++	if (!axp20x_pek->input)
++		return -ENOMEM;
++
++	idev = axp20x_pek->input;
++
++	idev->name = "axp20x-pek";
++	idev->phys = "m1kbd/input2";
++	idev->dev.parent = &pdev->dev;
++
++	input_set_capability(idev, EV_KEY, KEY_POWER);
++
++	input_set_drvdata(idev, axp20x_pek);
++
++	error = devm_request_any_context_irq(&pdev->dev, axp20x_pek->irq_dbr,
++					  axp20x_pek_irq, 0,
++					  "axp20x-pek-dbr", idev);
++	if (error < 0) {
++		dev_err(axp20x->dev, "Failed to request dbr IRQ#%d: %d\n",
++			axp20x_pek->irq_dbr, error);
++
++		return error;
++	}
++
++	error = devm_request_any_context_irq(&pdev->dev, axp20x_pek->irq_dbf,
++					  axp20x_pek_irq, 0,
++					  "axp20x-pek-dbf", idev);
++	if (error < 0) {
++		dev_err(axp20x->dev, "Failed to request dbf IRQ#%d: %d\n",
++			axp20x_pek->irq_dbf, error);
++		return error;
++	}
++
++	error = device_create_file(&pdev->dev, &axp20x_dev_attr_startup.attr);
++	if (error)
++		return error;
++
++	error = device_create_file(&pdev->dev, &axp20x_dev_attr_shutdown.attr);
++	if (error)
++		goto clear_startup_attr;
++
++	error = input_register_device(idev);
++	if (error) {
++		dev_err(axp20x->dev, "Can't register input device: %d\n", error);
++		goto clear_attr;
++	}
++
++	platform_set_drvdata(pdev, axp20x_pek);
++
++	return 0;
++
++clear_attr:
++	device_remove_file(&pdev->dev, &axp20x_dev_attr_shutdown.attr);
++
++clear_startup_attr:
++	device_remove_file(&pdev->dev, &axp20x_dev_attr_startup.attr);
++
++	return error;
++}
++
++int axp20x_pek_remove(struct platform_device *pdev)
++{
++	device_remove_file(&pdev->dev, &axp20x_dev_attr_shutdown.attr);
++	device_remove_file(&pdev->dev, &axp20x_dev_attr_startup.attr);
++
++	return 0;
++}
++
++static struct platform_driver axp20x_pek_driver = {
++	.probe		= axp20x_pek_probe,
++	.remove		= axp20x_pek_remove,
++	.driver		= {
++		.name		= "axp20x-pek",
++		.owner		= THIS_MODULE,
++	},
++};
++module_platform_driver(axp20x_pek_driver);
++
++MODULE_DESCRIPTION("axp20x Power Button");
++MODULE_AUTHOR("Carlo Caione <carlo@caione.org>");
++MODULE_LICENSE("GPL");
diff --git a/target/linux/sunxi/patches-3.18/135-ahci-fix-threaded-interrupt-setup.patch b/target/linux/sunxi/patches-3.18/135-ahci-fix-threaded-interrupt-setup.patch
new file mode 100644
index 0000000..6d316c2
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/135-ahci-fix-threaded-interrupt-setup.patch
@@ -0,0 +1,97 @@
+From 4bfd40ed0046299e4a5ffba31bfbbcc39cf74e03 Mon Sep 17 00:00:00 2001
+From: Marc Zyngier <marc.zyngier@arm.com>
+Date: Thu, 23 Oct 2014 17:49:30 +0100
+Subject: [PATCH] AHCI: Fix threaded interrupt setup
+
+Commit 18dcf433f3de (AHCI: Optimize single IRQ interrupt processing)
+switched the single IRQ case of the AHCI driver to use threaded
+threaded interrupts.
+
+During this conversion, only the IRQF_SHARED flag was provided. The net
+effect of this in the presence of level interrupts is that the
+interrupt will not be masked during the execution of the treaded
+handler, leading to a screaming interrupt if the thread is not
+scheduled quickly enough, specially in error conditions:
+
+[    2.728051] ahci-sunxi 1c18000.sata: controller can't do PMP, turning off CAP_PMP
+[    2.735578] ahci-sunxi 1c18000.sata: SSS flag set, parallel bus scan disabled
+[    2.742792] ahci-sunxi 1c18000.sata: AHCI 0001.0100 32 slots 1 ports 3 Gbps 0x1 impl platform mode
+[    2.751789] ahci-sunxi 1c18000.sata: flags: ncq sntf stag pm led clo only pio slum part ccc
+[    2.761539] scsi host0: ahci_platform
+[    2.765754] ata1: SATA max UDMA/133 mmio [mem 0x01c18000-0x01c18fff] port 0x100 irq 88
+[...]
+[    3.127977] ata1: SATA link down (SStatus 0 SControl 300)
+[...]
+[    3.162035] Waiting for root device /dev/sda1...
+[    3.163700] random: nonblocking pool is initialized
+[    3.326593] irq 88: nobody cared (try booting with the "irqpoll" option)
+[    3.333296] CPU: 0 PID: 0 Comm: swapper/0 Not tainted 3.18.0-rc1+ #3077
+[    3.339936] [<c002b318>] (unwind_backtrace) from [<c0026980>] (show_stack+0x20/0x24)
+[    3.347681] [<c0026980>] (show_stack) from [<c067dd18>] (dump_stack+0x9c/0xd4)
+[    3.354904] [<c067dd18>] (dump_stack) from [<c007ac08>] (__report_bad_irq+0x38/0xd4)
+[    3.362643] [<c007ac08>] (__report_bad_irq) from [<c007b1dc>] (note_interrupt+0x280/0x2d0)
+[    3.370903] [<c007b1dc>] (note_interrupt) from [<c0078a70>] (handle_irq_event_percpu+0x210/0x27c)
+[    3.379771] [<c0078a70>] (handle_irq_event_percpu) from [<c0078b28>] (handle_irq_event+0x4c/0x6c)
+[    3.388636] [<c0078b28>] (handle_irq_event) from [<c007b860>] (handle_fasteoi_irq+0xbc/0x1a0)
+[    3.397156] [<c007b860>] (handle_fasteoi_irq) from [<c0077f5c>] (generic_handle_irq+0x3c/0x4c)
+[    3.405764] [<c0077f5c>] (generic_handle_irq) from [<c0078220>] (__handle_domain_irq+0x6c/0xb4)
+[    3.414456] [<c0078220>] (__handle_domain_irq) from [<c0008754>] (gic_handle_irq+0x34/0x6c)
+[    3.422802] [<c0008754>] (gic_handle_irq) from [<c0027540>] (__irq_svc+0x40/0x74)
+[    3.430274] Exception stack(0xc09c1df8 to 0xc09c1e40)
+[    3.435321] 1de0:                                                       00000001 c0a27ec0
+[    3.443491] 1e00: 00000000 00000000 c09c0028 0000001e 00000282 00000000 ee00c400 c0a239f8
+[    3.451660] 1e20: c09c0000 c09c1ea4 c0a27ec0 c09c1e40 00200000 c003c7cc 20000113 ffffffff
+[    3.459835] [<c0027540>] (__irq_svc) from [<c003c7cc>] (__do_softirq+0xbc/0x34c)
+[    3.467229] [<c003c7cc>] (__do_softirq) from [<c003cd44>] (irq_exit+0xbc/0x104)
+[    3.474536] [<c003cd44>] (irq_exit) from [<c0078224>] (__handle_domain_irq+0x70/0xb4)
+[    3.482362] [<c0078224>] (__handle_domain_irq) from [<c0008754>] (gic_handle_x74)
+[    3.498169] Exception stack(0xc09c1f10 to 0xc09c1f58)
+[    3.503216] 1f00:                                     ee7ca310 00000000 00000ab4 c0035560
+[    3.511386] 1f20: c09c0000 00000000 c0a23f84 c09c8474 c09c84bc c09c0000 c0688bf8 c09c1f64
+[    3.519554] 1f40: c09c1f68 c09c1f58 c00235d8 c00235dc 60000113 ffffffff
+[    3.526165] [<c0027540>] (__irq_svc) from [<c00235dc>] (arch_cpu_idle+0x48/0x4c)
+[    3.533557] [<c00235dc>] (arch_cpu_idle) from [<c00701fc>] (cpu_startup_entry+0x13c/0x27c)
+[    3.541816] [<c00701fc>] (cpu_startup_entry) from [<c067af1c>] (rest_init+0x94/0x98)
+[    3.549557] [<c067af1c>] (rest_init) from [<c093dd38>] (start_kernel+0x3f0/0x3fc)
+[    3.557036] [<c093dd38>] (start_kernel) from [<40008084>] (0x40008084)
+[    3.563555] handlers:
+[    3.565830] [<c03a1a80>] ahci_single_irq_intr threaded [<c03a223c>] ahci_thread_fn
+[    3.573415] Disabling IRQ #88
+[    3.576532] ata1: exception Emask 0x10 SAct 0x0 SErr 0x4050002 action 0xe frozen
+[    3.583977] ata1: irq_stat 0x00400040, connection status changed
+[    3.590006] ata1: SError: { RecovComm PHYRdyChg CommWake DevExch }
+[    3.596209] ata1: hard resetting link
+[...]
+
+Not good. The culprit is a missing IRQF_ONESHOT flag, which addition
+solves the problem entierly. The number of interrupts drops radically:
+
+[Booting Debian Jessie to a prompt]
+Before fix:
+ 88:       3562          0       GIC  88  ahci-sunxi
+After fix:
+ 88:       1992          0       GIC  88  ahci-sunxi
+
+Tested on a A20 board (ahci-sunxi).
+
+Cc: Alexander Gordeev <agordeev@redhat.com>
+Cc: Tejun Heo <tj@kernel.org>
+Cc: linux-ide@vger.kernel.org
+Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
+---
+ drivers/ata/libahci.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/drivers/ata/libahci.c b/drivers/ata/libahci.c
+index 5eb61c9..49c649f 100644
+--- a/drivers/ata/libahci.c
++++ b/drivers/ata/libahci.c
+@@ -2492,7 +2492,7 @@ static int ahci_host_activate_single_irq(struct ata_host *host, int irq,
+ 		return rc;
+ 
+ 	rc = devm_request_threaded_irq(host->dev, irq, ahci_single_irq_intr,
+-				       ahci_thread_fn, IRQF_SHARED,
++				       ahci_thread_fn, IRQF_SHARED | IRQF_ONESHOT,
+ 				       dev_driver_string(host->dev), host);
+ 	if (rc)
+ 		return rc;
diff --git a/target/linux/sunxi/patches-3.18/150-pwm-add-sunxi-driver.patch b/target/linux/sunxi/patches-3.18/150-pwm-add-sunxi-driver.patch
new file mode 100644
index 0000000..2d467c0
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/150-pwm-add-sunxi-driver.patch
@@ -0,0 +1,409 @@
+diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig
+index 3865dfb9ed08..424359d3cbb1 100644
+--- a/drivers/pwm/Kconfig
++++ b/drivers/pwm/Kconfig
+@@ -262,6 +262,15 @@ config PWM_STI
+ 	  To compile this driver as a module, choose M here: the module
+ 	  will be called pwm-sti.
+ 
++config PWM_SUN4I
++	tristate "Allwinner sun4i PWM support"
++	depends on ARCH_SUNXI || COMPILE_TEST
++	help
++	  Generic PWM framework driver for Allwinner sun4i and sun7i SoCs.
++
++	  To compile this driver as a module, choose M here: the module
++	  will be called pwm-sun4i.
++
+ config PWM_TEGRA
+ 	tristate "NVIDIA Tegra PWM support"
+ 	depends on ARCH_TEGRA
+diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile
+index c458606c3755..d607804deea1 100644
+--- a/drivers/pwm/Makefile
++++ b/drivers/pwm/Makefile
+@@ -24,6 +24,7 @@ obj-$(CONFIG_PWM_ROCKCHIP)	+= pwm-rockchip.o
+ obj-$(CONFIG_PWM_SAMSUNG)	+= pwm-samsung.o
+ obj-$(CONFIG_PWM_SPEAR)		+= pwm-spear.o
+ obj-$(CONFIG_PWM_STI)		+= pwm-sti.o
++obj-$(CONFIG_PWM_SUN4I)		+= pwm-sun4i.o
+ obj-$(CONFIG_PWM_TEGRA)		+= pwm-tegra.o
+ obj-$(CONFIG_PWM_TIECAP)	+= pwm-tiecap.o
+ obj-$(CONFIG_PWM_TIEHRPWM)	+= pwm-tiehrpwm.o
+diff --git a/drivers/pwm/pwm-sun4i.c b/drivers/pwm/pwm-sun4i.c
+new file mode 100644
+index 000000000000..918f8ee79b51
+--- /dev/null
++++ b/drivers/pwm/pwm-sun4i.c
+@@ -0,0 +1,371 @@
++/*
++ * Driver for Allwinner sun4i Pulse Width Modulation Controller
++ *
++ * Copyright (C) 2014 Alexandre Belloni <alexandre.belloni@free-electrons.com>
++ *
++ * Licensed under GPLv2.
++ */
++
++#include <linux/bitops.h>
++#include <linux/clk.h>
++#include <linux/err.h>
++#include <linux/io.h>
++#include <linux/module.h>
++#include <linux/mutex.h>
++#include <linux/of.h>
++#include <linux/of_device.h>
++#include <linux/platform_device.h>
++#include <linux/pwm.h>
++#include <linux/slab.h>
++#include <linux/time.h>
++
++#define PWM_CTRL_REG		0x0
++
++#define PWM_CH_PRD_BASE		0x4
++#define PWM_CH_PRD_OFFSET	0x4
++#define PWM_CH_PRD(ch)		(PWM_CH_PRD_BASE + PWM_CH_PRD_OFFSET * (ch))
++
++#define PWMCH_OFFSET		15
++#define PWM_PRESCAL_MASK	GENMASK(3, 0)
++#define PWM_PRESCAL_OFF		0
++#define PWM_EN			BIT(4)
++#define PWM_ACT_STATE		BIT(5)
++#define PWM_CLK_GATING		BIT(6)
++#define PWM_MODE		BIT(7)
++#define PWM_PULSE		BIT(8)
++#define PWM_BYPASS		BIT(9)
++
++#define PWM_RDY_BASE		28
++#define PWM_RDY_OFFSET		1
++#define PWM_RDY(ch)		BIT(PWM_RDY_BASE + PWM_RDY_OFFSET * (ch))
++
++#define PWM_PRD(prd)		(((prd) - 1) << 16)
++#define PWM_PRD_MASK		GENMASK(15, 0)
++
++#define PWM_DTY_MASK		GENMASK(15, 0)
++
++#define BIT_CH(bit, chan)	((bit) << ((chan) * PWMCH_OFFSET))
++
++static const u32 prescaler_table[] = {
++	120,
++	180,
++	240,
++	360,
++	480,
++	0,
++	0,
++	0,
++	12000,
++	24000,
++	36000,
++	48000,
++	72000,
++	0,
++	0,
++	0, /* Actually 1 but tested separately */
++};
++
++struct sun4i_pwm_data {
++	bool has_prescaler_bypass;
++	bool has_rdy;
++};
++
++struct sun4i_pwm_chip {
++	struct pwm_chip chip;
++	struct clk *clk;
++	void __iomem *base;
++	struct mutex ctrl_lock;
++	const struct sun4i_pwm_data *data;
++};
++
++static inline struct sun4i_pwm_chip *to_sun4i_pwm_chip(struct pwm_chip *chip)
++{
++	return container_of(chip, struct sun4i_pwm_chip, chip);
++}
++
++static inline u32 sun4i_pwm_readl(struct sun4i_pwm_chip *chip,
++				  unsigned long offset)
++{
++	return readl(chip->base + offset);
++}
++
++static inline void sun4i_pwm_writel(struct sun4i_pwm_chip *chip,
++				    u32 val, unsigned long offset)
++{
++	writel(val, chip->base + offset);
++}
++
++static int sun4i_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
++			    int duty_ns, int period_ns)
++{
++	struct sun4i_pwm_chip *sun4i_pwm = to_sun4i_pwm_chip(chip);
++	u32 clk_rate, prd, dty, val, clk_gate;
++	u64 div = 0;
++	unsigned int prescaler = 0;
++	int err;
++
++	clk_rate = clk_get_rate(sun4i_pwm->clk);
++
++	if (sun4i_pwm->data->has_prescaler_bypass) {
++		/* First, test without any prescaler when available */
++		prescaler = PWM_PRESCAL_MASK;
++		/*
++		 * When not using any prescaler, the clock period in nanoseconds
++		 * is not an integer so round it half up instead of
++		 * truncating to get less surprising values.
++		 */
++		div = clk_rate * (u64)period_ns + NSEC_PER_SEC/2;
++		do_div(div, NSEC_PER_SEC);
++		if (div - 1 > PWM_PRD_MASK)
++			prescaler = 0;
++	}
++
++	if (prescaler == 0) {
++		/* Go up from the first divider */
++		for (prescaler = 0; prescaler < PWM_PRESCAL_MASK; prescaler++) {
++			if (!prescaler_table[prescaler])
++				continue;
++			div = clk_rate / prescaler_table[prescaler];
++			div = div * (u64)period_ns;
++			do_div(div, NSEC_PER_SEC);
++			if (div - 1 <= PWM_PRD_MASK)
++				break;
++		}
++
++		if (div - 1 > PWM_PRD_MASK) {
++			dev_err(chip->dev, "period exceeds the maximum value\n");
++			return -EINVAL;
++		}
++	}
++
++	prd = div;
++	div *= duty_ns;
++	do_div(div, period_ns);
++	dty = div;
++
++	err = clk_prepare_enable(sun4i_pwm->clk);
++	if (err) {
++		dev_err(chip->dev, "failed to enable PWM clock\n");
++		return err;
++	}
++
++	mutex_lock(&sun4i_pwm->ctrl_lock);
++	val = sun4i_pwm_readl(sun4i_pwm, PWM_CTRL_REG);
++
++	if (sun4i_pwm->data->has_rdy && (val & PWM_RDY(pwm->hwpwm))) {
++		mutex_unlock(&sun4i_pwm->ctrl_lock);
++		clk_disable_unprepare(sun4i_pwm->clk);
++		return -EBUSY;
++	}
++
++	clk_gate = val & BIT_CH(PWM_CLK_GATING, pwm->hwpwm);
++	if (clk_gate) {
++		val &= ~BIT_CH(PWM_CLK_GATING, pwm->hwpwm);
++		sun4i_pwm_writel(sun4i_pwm, val, PWM_CTRL_REG);
++	}
++
++	val = sun4i_pwm_readl(sun4i_pwm, PWM_CTRL_REG);
++	val &= ~BIT_CH(PWM_PRESCAL_MASK, pwm->hwpwm);
++	val |= BIT_CH(prescaler, pwm->hwpwm);
++	sun4i_pwm_writel(sun4i_pwm, val, PWM_CTRL_REG);
++
++	val = (dty & PWM_DTY_MASK) | PWM_PRD(prd);
++	sun4i_pwm_writel(sun4i_pwm, val, PWM_CH_PRD(pwm->hwpwm));
++
++	if (clk_gate) {
++		val = sun4i_pwm_readl(sun4i_pwm, PWM_CTRL_REG);
++		val |= clk_gate;
++		sun4i_pwm_writel(sun4i_pwm, val, PWM_CTRL_REG);
++	}
++
++	mutex_unlock(&sun4i_pwm->ctrl_lock);
++	clk_disable_unprepare(sun4i_pwm->clk);
++
++	return 0;
++}
++
++static int sun4i_pwm_set_polarity(struct pwm_chip *chip, struct pwm_device *pwm,
++				  enum pwm_polarity polarity)
++{
++	struct sun4i_pwm_chip *sun4i_pwm = to_sun4i_pwm_chip(chip);
++	u32 val;
++	int ret;
++
++	ret = clk_prepare_enable(sun4i_pwm->clk);
++	if (ret) {
++		dev_err(chip->dev, "failed to enable PWM clock\n");
++		return ret;
++	}
++
++	mutex_lock(&sun4i_pwm->ctrl_lock);
++	val = sun4i_pwm_readl(sun4i_pwm, PWM_CTRL_REG);
++
++	if (polarity != PWM_POLARITY_NORMAL)
++		val &= ~BIT_CH(PWM_ACT_STATE, pwm->hwpwm);
++	else
++		val |= BIT_CH(PWM_ACT_STATE, pwm->hwpwm);
++
++	sun4i_pwm_writel(sun4i_pwm, val, PWM_CTRL_REG);
++
++	mutex_unlock(&sun4i_pwm->ctrl_lock);
++	clk_disable_unprepare(sun4i_pwm->clk);
++
++	return 0;
++}
++
++static int sun4i_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
++{
++	struct sun4i_pwm_chip *sun4i_pwm = to_sun4i_pwm_chip(chip);
++	u32 val;
++	int ret;
++
++	ret = clk_prepare_enable(sun4i_pwm->clk);
++	if (ret) {
++		dev_err(chip->dev, "failed to enable PWM clock\n");
++		return ret;
++	}
++
++	mutex_lock(&sun4i_pwm->ctrl_lock);
++	val = sun4i_pwm_readl(sun4i_pwm, PWM_CTRL_REG);
++	val |= BIT_CH(PWM_EN, pwm->hwpwm);
++	val |= BIT_CH(PWM_CLK_GATING, pwm->hwpwm);
++	sun4i_pwm_writel(sun4i_pwm, val, PWM_CTRL_REG);
++	mutex_unlock(&sun4i_pwm->ctrl_lock);
++
++	return 0;
++}
++
++static void sun4i_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
++{
++	struct sun4i_pwm_chip *sun4i_pwm = to_sun4i_pwm_chip(chip);
++	u32 val;
++
++	mutex_lock(&sun4i_pwm->ctrl_lock);
++	val = sun4i_pwm_readl(sun4i_pwm, PWM_CTRL_REG);
++	val &= ~BIT_CH(PWM_EN, pwm->hwpwm);
++	val &= ~BIT_CH(PWM_CLK_GATING, pwm->hwpwm);
++	sun4i_pwm_writel(sun4i_pwm, val, PWM_CTRL_REG);
++	mutex_unlock(&sun4i_pwm->ctrl_lock);
++
++	clk_disable_unprepare(sun4i_pwm->clk);
++}
++
++static const struct pwm_ops sun4i_pwm_ops = {
++	.config = sun4i_pwm_config,
++	.set_polarity = sun4i_pwm_set_polarity,
++	.enable = sun4i_pwm_enable,
++	.disable = sun4i_pwm_disable,
++	.owner = THIS_MODULE,
++};
++
++static const struct sun4i_pwm_data sun4i_pwm_data_a10 = {
++	.has_prescaler_bypass = false,
++	.has_rdy = false,
++};
++
++static const struct sun4i_pwm_data sun4i_pwm_data_a20 = {
++	.has_prescaler_bypass = true,
++	.has_rdy = true,
++};
++
++static const struct of_device_id sun4i_pwm_dt_ids[] = {
++	{
++		.compatible = "allwinner,sun4i-a10-pwm",
++		.data = &sun4i_pwm_data_a10,
++	}, {
++		.compatible = "allwinner,sun7i-a20-pwm",
++		.data = &sun4i_pwm_data_a20,
++	}, {
++		/* sentinel */
++	},
++};
++MODULE_DEVICE_TABLE(of, sun4i_pwm_dt_ids);
++
++static int sun4i_pwm_probe(struct platform_device *pdev)
++{
++	struct sun4i_pwm_chip *pwm;
++	struct resource *res;
++	u32 val;
++	int i, ret;
++	const struct of_device_id *match;
++
++	match = of_match_device(sun4i_pwm_dt_ids, &pdev->dev);
++
++	pwm = devm_kzalloc(&pdev->dev, sizeof(*pwm), GFP_KERNEL);
++	if (!pwm)
++		return -ENOMEM;
++
++	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
++	pwm->base = devm_ioremap_resource(&pdev->dev, res);
++	if (IS_ERR(pwm->base))
++		return PTR_ERR(pwm->base);
++
++	pwm->clk = devm_clk_get(&pdev->dev, NULL);
++	if (IS_ERR(pwm->clk))
++		return PTR_ERR(pwm->clk);
++
++	pwm->chip.dev = &pdev->dev;
++	pwm->chip.ops = &sun4i_pwm_ops;
++	pwm->chip.base = -1;
++	pwm->chip.npwm = 2;
++	pwm->chip.can_sleep = true;
++	pwm->chip.of_xlate = of_pwm_xlate_with_flags;
++	pwm->chip.of_pwm_n_cells = 3;
++	pwm->data = match->data;
++
++	mutex_init(&pwm->ctrl_lock);
++
++	ret = pwmchip_add(&pwm->chip);
++	if (ret < 0) {
++		dev_err(&pdev->dev, "failed to add PWM chip: %d\n", ret);
++		goto error;
++	}
++
++	platform_set_drvdata(pdev, pwm);
++
++	ret = clk_prepare_enable(pwm->clk);
++	if (ret) {
++		dev_err(&pdev->dev, "failed to enable PWM clock\n");
++		goto clk_error;
++	}
++
++	val = sun4i_pwm_readl(pwm, PWM_CTRL_REG);
++	for (i = 0; i < pwm->chip.npwm; i++) {
++		if (!(val & BIT_CH(PWM_ACT_STATE, i)))
++			pwm->chip.pwms[i].polarity = PWM_POLARITY_INVERSED;
++	}
++	clk_disable_unprepare(pwm->clk);
++
++	return 0;
++
++clk_error:
++	pwmchip_remove(&pwm->chip);
++
++error:
++	mutex_destroy(&pwm->ctrl_lock);
++	return ret;
++}
++
++static int sun4i_pwm_remove(struct platform_device *pdev)
++{
++	struct sun4i_pwm_chip *pwm = platform_get_drvdata(pdev);
++
++	mutex_destroy(&pwm->ctrl_lock);
++
++	return pwmchip_remove(&pwm->chip);
++}
++
++static struct platform_driver sun4i_pwm_driver = {
++	.driver = {
++		.name = "sun4i-pwm",
++		.of_match_table = sun4i_pwm_dt_ids,
++	},
++	.probe = sun4i_pwm_probe,
++	.remove = sun4i_pwm_remove,
++};
++module_platform_driver(sun4i_pwm_driver);
++
++MODULE_ALIAS("platform:sun4i-pwm");
++MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@free-electrons.com>");
++MODULE_DESCRIPTION("Allwinner sun4i PWM driver");
++MODULE_LICENSE("GPL v2");
diff --git a/target/linux/sunxi/patches-3.18/200-mmc-add-sdio-function-subnode.patch b/target/linux/sunxi/patches-3.18/200-mmc-add-sdio-function-subnode.patch
new file mode 100644
index 0000000..6427df5
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/200-mmc-add-sdio-function-subnode.patch
@@ -0,0 +1,148 @@
+From 8c2057afe84c074ef7cd3ee2ec8e9bed835b9e93 Mon Sep 17 00:00:00 2001
+From: Sascha Hauer <s.hauer@pengutronix.de>
+Date: Wed, 21 May 2014 19:50:04 +0200
+Subject: [PATCH] mmc: Add SDIO function devicetree subnode parsing
+
+This adds SDIO devicetree subnode parsing to the mmc core. While
+SDIO devices are runtime probable they sometimes need nonprobable
+additional information on embedded systems, like an additional gpio
+interrupt or a clock. This patch makes it possible to supply this
+information from the devicetree. SDIO drivers will find a pointer
+to the devicenode in their devices of_node pointer.
+
+Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
+[hdegoede@redhat.com: Misc. cleanups]
+Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+---
+ drivers/mmc/core/bus.c      |  4 ++++
+ drivers/mmc/core/core.c     | 28 ++++++++++++++++++++++++++++
+ drivers/mmc/core/core.h     |  3 +++
+ drivers/mmc/core/sdio_bus.c | 11 +++++++++++
+ 4 files changed, 46 insertions(+)
+
+diff --git a/drivers/mmc/core/bus.c b/drivers/mmc/core/bus.c
+index 8a1f124..7868565 100644
+--- a/drivers/mmc/core/bus.c
++++ b/drivers/mmc/core/bus.c
+@@ -16,6 +16,7 @@
+ #include <linux/err.h>
+ #include <linux/slab.h>
+ #include <linux/stat.h>
++#include <linux/of.h>
+ #include <linux/pm_runtime.h>
+ 
+ #include <linux/mmc/card.h>
+@@ -352,6 +353,8 @@ int mmc_add_card(struct mmc_card *card)
+ #endif
+ 	mmc_init_context_info(card->host);
+ 
++	card->dev.of_node = mmc_of_find_child_device(card->host, 0);
++
+ 	ret = device_add(&card->dev);
+ 	if (ret)
+ 		return ret;
+@@ -380,6 +383,7 @@ void mmc_remove_card(struct mmc_card *card)
+ 				mmc_hostname(card->host), card->rca);
+ 		}
+ 		device_del(&card->dev);
++		of_node_put(card->dev.of_node);
+ 	}
+ 
+ 	put_device(&card->dev);
+diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
+index f26a5f1..7f7f66c 100644
+--- a/drivers/mmc/core/core.c
++++ b/drivers/mmc/core/core.c
+@@ -1205,6 +1205,34 @@ EXPORT_SYMBOL(mmc_of_parse_voltage);
+ 
+ #endif /* CONFIG_OF */
+ 
++static int mmc_of_get_func_num(struct device_node *node)
++{
++	u32 reg;
++	int ret;
++
++	ret = of_property_read_u32(node, "reg", &reg);
++	if (ret < 0)
++		return ret;
++
++	return reg;
++}
++
++struct device_node *mmc_of_find_child_device(struct mmc_host *host,
++		unsigned func_num)
++{
++	struct device_node *node;
++
++	if (!host->parent || !host->parent->of_node)
++		return NULL;
++
++	for_each_child_of_node(host->parent->of_node, node) {
++		if (mmc_of_get_func_num(node) == func_num)
++			return node;
++	}
++
++	return NULL;
++}
++
+ #ifdef CONFIG_REGULATOR
+ 
+ /**
+diff --git a/drivers/mmc/core/core.h b/drivers/mmc/core/core.h
+index 443a5846..f712f6e 100644
+--- a/drivers/mmc/core/core.h
++++ b/drivers/mmc/core/core.h
+@@ -32,6 +32,9 @@ struct mmc_bus_ops {
+ void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops);
+ void mmc_detach_bus(struct mmc_host *host);
+ 
++struct device_node *mmc_of_find_child_device(struct mmc_host *host,
++		unsigned func_num);
++
+ void mmc_init_erase(struct mmc_card *card);
+ 
+ void mmc_set_chip_select(struct mmc_host *host, int mode);
+diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
+index 6da97b1..f63223a 100644
+--- a/drivers/mmc/core/sdio_bus.c
++++ b/drivers/mmc/core/sdio_bus.c
+@@ -22,7 +22,9 @@
+ #include <linux/mmc/card.h>
+ #include <linux/mmc/host.h>
+ #include <linux/mmc/sdio_func.h>
++#include <linux/of.h>
+ 
++#include "core.h"
+ #include "sdio_cis.h"
+ #include "sdio_bus.h"
+ 
+@@ -303,6 +305,13 @@ static void sdio_acpi_set_handle(struct sdio_func *func)
+ static inline void sdio_acpi_set_handle(struct sdio_func *func) {}
+ #endif
+ 
++static void sdio_set_of_node(struct sdio_func *func)
++{
++	struct mmc_host *host = func->card->host;
++
++	func->dev.of_node = mmc_of_find_child_device(host, func->num);
++}
++
+ /*
+  * Register a new SDIO function with the driver model.
+  */
+@@ -312,6 +321,7 @@ int sdio_add_func(struct sdio_func *func)
+ 
+ 	dev_set_name(&func->dev, "%s:%d", mmc_card_id(func->card), func->num);
+ 
++	sdio_set_of_node(func);
+ 	sdio_acpi_set_handle(func);
+ 	ret = device_add(&func->dev);
+ 	if (ret == 0) {
+@@ -335,6 +345,7 @@ void sdio_remove_func(struct sdio_func *func)
+ 
+ 	dev_pm_domain_detach(&func->dev, false);
+ 	device_del(&func->dev);
++	of_node_put(func->dev.of_node);
+ 	put_device(&func->dev);
+ }
+ 
diff --git a/target/linux/sunxi/patches-3.18/201-dt-sun7i-add-oob-irq-to-bcm-sdio-wifi.patch b/target/linux/sunxi/patches-3.18/201-dt-sun7i-add-oob-irq-to-bcm-sdio-wifi.patch
new file mode 100644
index 0000000..c6790b7
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/201-dt-sun7i-add-oob-irq-to-bcm-sdio-wifi.patch
@@ -0,0 +1,68 @@
+From e4127db9b980a5684c537d9010ed2aaa05a1e79a Mon Sep 17 00:00:00 2001
+From: Hans de Goede <hdegoede@redhat.com>
+Date: Sat, 24 May 2014 20:53:49 +0200
+Subject: [PATCH] ARM: dts: sun7i: Add OOB irq support to boards with broadcom
+ sdio wifi
+
+Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+---
+ arch/arm/boot/dts/sun7i-a20-cubietruck.dts | 11 +++++++++++
+ arch/arm/boot/dts/sun7i-a20-i12-tvbox.dts  | 11 +++++++++++
+ 2 files changed, 22 insertions(+)
+
+diff --git a/arch/arm/boot/dts/sun7i-a20-cubietruck.dts b/arch/arm/boot/dts/sun7i-a20-cubietruck.dts
+index a6c1a3c..f9ab5d4 100644
+--- a/arch/arm/boot/dts/sun7i-a20-cubietruck.dts
++++ b/arch/arm/boot/dts/sun7i-a20-cubietruck.dts
+@@ -31,12 +31,23 @@
+ 		};
+ 
+ 		mmc3: mmc@01c12000 {
++			#address-cells = <1>;
++			#size-cells = <0>;
++
+ 			pinctrl-names = "default";
+ 			pinctrl-0 = <&mmc3_pins_a>;
+ 			vmmc-supply = <&reg_vmmc3>;
+ 			bus-width = <4>;
+ 			non-removable;
+ 			status = "okay";
++
++			brcmf: bcrmf@1 {
++				reg = <1>;
++				compatible = "brcm,bcm4329-fmac";
++				interrupt-parent = <&pio>;
++				interrupts = <10 8>; /* PH10 / EINT10 */
++				interrupt-names = "host-wake";
++			};
+ 		};
+ 
+ 		usbphy: phy@01c13400 {
+diff --git a/arch/arm/boot/dts/sun7i-a20-i12-tvbox.dts b/arch/arm/boot/dts/sun7i-a20-i12-tvbox.dts
+index 6a67712d..f620aea 100644
+--- a/arch/arm/boot/dts/sun7i-a20-i12-tvbox.dts
++++ b/arch/arm/boot/dts/sun7i-a20-i12-tvbox.dts
+@@ -29,12 +29,23 @@
+ 		};
+ 
+ 		mmc3: mmc@01c12000 {
++			#address-cells = <1>;
++			#size-cells = <0>;
++
+ 			pinctrl-names = "default";
+ 			pinctrl-0 = <&mmc3_pins_a>;
+ 			vmmc-supply = <&reg_vmmc3>;
+ 			bus-width = <4>;
+ 			non-removable;
+ 			status = "okay";
++
++			brcmf: bcrmf@1 {
++				reg = <1>;
++				compatible = "brcm,bcm4329-fmac";
++				interrupt-parent = <&pio>;
++				interrupts = <10 8>; /* PH10 / EINT10 */
++				interrupt-names = "host-wake";
++			};
+ 		};
+ 
+ 		usbphy: phy@01c13400 {
diff --git a/target/linux/sunxi/patches-3.18/202-dt-sun7i-add-bluetooth-to-cubietruck.patch b/target/linux/sunxi/patches-3.18/202-dt-sun7i-add-bluetooth-to-cubietruck.patch
new file mode 100644
index 0000000..f819849
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/202-dt-sun7i-add-bluetooth-to-cubietruck.patch
@@ -0,0 +1,75 @@
+From c6e2b7dad39a7887f935458d1c8de84db06243e1 Mon Sep 17 00:00:00 2001
+From: Chen-Yu Tsai <wens@csie.org>
+Date: Thu, 26 Dec 2013 17:15:47 +0800
+Subject: [PATCH] ARM: dts: sun7i: add bluetooth module to CubieTruck DTS
+
+The CubieTruck has an AMPAK AP6210 WiFi+Bluetooth module. The
+Bluetooth part is a BCM20710 IC connected to UART2 in the A20
+SoC. The IC also takes a 32.768 KHz low power clock input, a power
+enable signal and a wake signal via GPIO.
+
+The Bluetooth module supports out-of-band interrupt signaling via
+GPIO, but this is not supported in this patch.
+---
+ arch/arm/boot/dts/sun7i-a20-cubietruck.dts | 36 ++++++++++++++++++++++++++++++
+ 1 file changed, 36 insertions(+)
+
+diff --git a/arch/arm/boot/dts/sun7i-a20-cubietruck.dts b/arch/arm/boot/dts/sun7i-a20-cubietruck.dts
+index f9ab5d4..69d8c4c 100644
+--- a/arch/arm/boot/dts/sun7i-a20-cubietruck.dts
++++ b/arch/arm/boot/dts/sun7i-a20-cubietruck.dts
+@@ -103,6 +103,20 @@
+ 				allwinner,drive = <0>;
+ 				allwinner,pull = <0>;
+ 			};
++
++			bt_pwr_pin: bt_pwr_pin@0 {
++				allwinner,pins = "PH18";
++				allwinner,function = "gpio_out";
++				allwinner,drive = <0>;
++				allwinner,pull = <0>;
++			};
++
++			bt_wake_pin: bt_wake_pin@0 {
++				allwinner,pins = "PH24";
++				allwinner,function = "gpio_out";
++				allwinner,drive = <0>;
++				allwinner,pull = <0>;
++			};
+ 		};
+ 
+ 		pwm: pwm@01c20e00 {
+@@ -123,6 +137,12 @@
+ 			status = "okay";
+ 		};
+ 
++		uart2: serial@01c28800 {
++			pinctrl-names = "default";
++			pinctrl-0 = <&uart2_pins_a>;
++			status = "okay";
++		};
++
+ 		i2c0: i2c@01c2ac00 {
+ 			pinctrl-names = "default";
+ 			pinctrl-0 = <&i2c0_pins_a>;
+@@ -214,4 +234,20 @@
+ 		enable-active-high;
+ 		gpio = <&pio 7 9 0>;
+ 	};
++
++	rfkill-switches {
++		compatible = "simple-bus";
++		pinctrl-names = "default";
++
++		rfkill_bt {
++			compatible = "rfkill-gpio";
++			pinctrl-0 = <&bt_pwr_pin>, <&clk_out_a_pins_a>;
++			rfkill-name = "bt";
++			rfkill-type = <2>;
++			bt_shutdown-gpios = <0>, <&pio 7 18 0>; /* PH18 */
++			bt_reset-gpios = <&pio 7 24 0>; /* PH24 */
++			clocks = <&clk_out_a>;
++			clock-frequency = <32768>;
++		};
++	};
+ };
diff --git a/target/linux/sunxi/patches-3.18/270-dt-sun7i-add-ss-to-a20.patch b/target/linux/sunxi/patches-3.18/270-dt-sun7i-add-ss-to-a20.patch
new file mode 100644
index 0000000..11a6ed0
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/270-dt-sun7i-add-ss-to-a20.patch
@@ -0,0 +1,17 @@
+--- a/arch/arm/boot/dts/sun7i-a20.dtsi
++++ b/arch/arm/boot/dts/sun7i-a20.dtsi
+@@ -529,6 +529,14 @@
+ 			status = "disabled";
+ 		};
+ 
++		crypto: crypto-engine@01c15000 {
++			compatible = "allwinner,sun7i-a20-crypto";
++			reg = <0x01c15000 0x1000>;
++			interrupts = <0 86 4>;
++			clocks = <&ahb_gates 5>, <&ss_clk>;
++			clock-names = "ahb", "mod";
++		};
++
+ 		spi2: spi@01c17000 {
+ 			compatible = "allwinner,sun4i-a10-spi";
+ 			reg = <0x01c17000 0x1000>;
diff --git a/target/linux/sunxi/patches-3.18/271-crypto-add-ss.patch b/target/linux/sunxi/patches-3.18/271-crypto-add-ss.patch
new file mode 100644
index 0000000..090624d
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/271-crypto-add-ss.patch
@@ -0,0 +1,1512 @@
+diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig
+index 2fb0fdf..9ba9759 100644
+--- a/drivers/crypto/Kconfig
++++ b/drivers/crypto/Kconfig
+@@ -436,4 +436,21 @@ config CRYPTO_DEV_QCE
+ 	  hardware. To compile this driver as a module, choose M here. The
+ 	  module will be called qcrypto.
+ 
++config CRYPTO_DEV_SUNXI_SS
++	tristate "Support for Allwinner Security System cryptographic accelerator"
++	depends on ARCH_SUNXI
++	select CRYPTO_MD5
++	select CRYPTO_SHA1
++	select CRYPTO_AES
++	select CRYPTO_DES
++	select CRYPTO_BLKCIPHER
++	help
++	  Some Allwinner SoC have a crypto accelerator named
++	  Security System. Select this if you want to use it.
++	  The Security System handle AES/DES/3DES ciphers in CBC mode
++	  and SHA1 and MD5 hash algorithms.
++
++	  To compile this driver as a module, choose M here: the module
++	  will be called sunxi-ss.
++
+ endif # CRYPTO_HW
+diff --git a/drivers/crypto/Makefile b/drivers/crypto/Makefile
+index 3924f93..856545c 100644
+--- a/drivers/crypto/Makefile
++++ b/drivers/crypto/Makefile
+@@ -25,3 +25,4 @@ obj-$(CONFIG_CRYPTO_DEV_TALITOS) += talitos.o
+ obj-$(CONFIG_CRYPTO_DEV_UX500) += ux500/
+ obj-$(CONFIG_CRYPTO_DEV_QAT) += qat/
+ obj-$(CONFIG_CRYPTO_DEV_QCE) += qce/
++obj-$(CONFIG_CRYPTO_DEV_SUNXI_SS) += sunxi-ss/
+diff --git a/drivers/crypto/sunxi-ss/Makefile b/drivers/crypto/sunxi-ss/Makefile
+new file mode 100644
+index 0000000..8bb287d
+--- /dev/null
++++ b/drivers/crypto/sunxi-ss/Makefile
+@@ -0,0 +1,2 @@
++obj-$(CONFIG_CRYPTO_DEV_SUNXI_SS) += sunxi-ss.o
++sunxi-ss-y += sunxi-ss-core.o sunxi-ss-hash.o sunxi-ss-cipher.o
+diff --git a/drivers/crypto/sunxi-ss/sunxi-ss-cipher.c b/drivers/crypto/sunxi-ss/sunxi-ss-cipher.c
+new file mode 100644
+index 0000000..8d0416e
+--- /dev/null
++++ b/drivers/crypto/sunxi-ss/sunxi-ss-cipher.c
+@@ -0,0 +1,489 @@
++/*
++ * sunxi-ss-cipher.c - hardware cryptographic accelerator for Allwinner A20 SoC
++ *
++ * Copyright (C) 2013-2014 Corentin LABBE <clabbe.montjoie@gmail.com>
++ *
++ * This file add support for AES cipher with 128,192,256 bits
++ * keysize in CBC mode.
++ * Add support also for DES and 3DES in CBC mode.
++ *
++ * You could find the datasheet in Documentation/arm/sunxi/README
++ *
++ * 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 "sunxi-ss.h"
++
++extern struct sunxi_ss_ctx *ss;
++
++static int sunxi_ss_cipher(struct ablkcipher_request *areq, u32 mode)
++{
++	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(areq);
++	struct sunxi_tfm_ctx *op = crypto_ablkcipher_ctx(tfm);
++	const char *cipher_type;
++
++	if (areq->nbytes == 0)
++		return 0;
++
++	if (areq->info == NULL) {
++		dev_err(ss->dev, "ERROR: Empty IV\n");
++		return -EINVAL;
++	}
++
++	if (areq->src == NULL || areq->dst == NULL) {
++		dev_err(ss->dev, "ERROR: Some SGs are NULL\n");
++		return -EINVAL;
++	}
++
++	cipher_type = crypto_tfm_alg_name(crypto_ablkcipher_tfm(tfm));
++
++	if (strcmp("cbc(aes)", cipher_type) == 0) {
++		mode |= SS_OP_AES | SS_CBC | SS_ENABLED | op->keymode;
++		return sunxi_ss_aes_poll(areq, mode);
++	}
++
++	if (strcmp("cbc(des)", cipher_type) == 0) {
++		mode |= SS_OP_DES | SS_CBC | SS_ENABLED | op->keymode;
++		return sunxi_ss_des_poll(areq, mode);
++	}
++
++	if (strcmp("cbc(des3_ede)", cipher_type) == 0) {
++		mode |= SS_OP_3DES | SS_CBC | SS_ENABLED | op->keymode;
++		return sunxi_ss_des_poll(areq, mode);
++	}
++
++	dev_err(ss->dev, "ERROR: Cipher %s not handled\n", cipher_type);
++	return -EINVAL;
++}
++
++int sunxi_ss_cipher_encrypt(struct ablkcipher_request *areq)
++{
++	return sunxi_ss_cipher(areq, SS_ENCRYPTION);
++}
++
++int sunxi_ss_cipher_decrypt(struct ablkcipher_request *areq)
++{
++	return sunxi_ss_cipher(areq, SS_DECRYPTION);
++}
++
++int sunxi_ss_cipher_init(struct crypto_tfm *tfm)
++{
++	struct sunxi_tfm_ctx *op = crypto_tfm_ctx(tfm);
++
++	memset(op, 0, sizeof(struct sunxi_tfm_ctx));
++	return 0;
++}
++
++/*
++ * Optimized function for the case where we have only one SG,
++ * so we can use kmap_atomic
++ */
++static int sunxi_ss_aes_poll_atomic(struct ablkcipher_request *areq)
++{
++	u32 spaces;
++	struct scatterlist *in_sg = areq->src;
++	struct scatterlist *out_sg = areq->dst;
++	void *src_addr;
++	void *dst_addr;
++	unsigned int ileft = areq->nbytes;
++	unsigned int oleft = areq->nbytes;
++	unsigned int todo;
++	u32 *src32;
++	u32 *dst32;
++	u32 rx_cnt = 32;
++	u32 tx_cnt = 0;
++	int i;
++
++	src_addr = kmap_atomic(sg_page(in_sg)) + in_sg->offset;
++	if (src_addr == NULL) {
++		dev_err(ss->dev, "kmap_atomic error for src SG\n");
++		writel(0, ss->base + SS_CTL);
++		mutex_unlock(&ss->lock);
++		return -EINVAL;
++	}
++
++	dst_addr = kmap_atomic(sg_page(out_sg)) + out_sg->offset;
++	if (dst_addr == NULL) {
++		dev_err(ss->dev, "kmap_atomic error for dst SG\n");
++		writel(0, ss->base + SS_CTL);
++		kunmap_atomic(src_addr);
++		mutex_unlock(&ss->lock);
++		return -EINVAL;
++	}
++
++	src32 = (u32 *)src_addr;
++	dst32 = (u32 *)dst_addr;
++	ileft = areq->nbytes / 4;
++	oleft = areq->nbytes / 4;
++	i = 0;
++	do {
++		if (ileft > 0 && rx_cnt > 0) {
++			todo = min(rx_cnt, ileft);
++			ileft -= todo;
++			do {
++				writel_relaxed(*src32++,
++						ss->base +
++						SS_RXFIFO);
++				todo--;
++			} while (todo > 0);
++		}
++		if (tx_cnt > 0) {
++			todo = min(tx_cnt, oleft);
++			oleft -= todo;
++			do {
++				*dst32++ = readl_relaxed(ss->base +
++						SS_TXFIFO);
++				todo--;
++			} while (todo > 0);
++		}
++		spaces = readl_relaxed(ss->base + SS_FCSR);
++		rx_cnt = SS_RXFIFO_SPACES(spaces);
++		tx_cnt = SS_TXFIFO_SPACES(spaces);
++	} while (oleft > 0);
++	writel(0, ss->base + SS_CTL);
++	kunmap_atomic(src_addr);
++	kunmap_atomic(dst_addr);
++	mutex_unlock(&ss->lock);
++	return 0;
++}
++
++int sunxi_ss_aes_poll(struct ablkcipher_request *areq, u32 mode)
++{
++	u32 spaces;
++	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(areq);
++	struct sunxi_tfm_ctx *op = crypto_ablkcipher_ctx(tfm);
++	unsigned int ivsize = crypto_ablkcipher_ivsize(tfm);
++	/* when activating SS, the default FIFO space is 32 */
++	u32 rx_cnt = 32;
++	u32 tx_cnt = 0;
++	u32 v;
++	int i;
++	struct scatterlist *in_sg = areq->src;
++	struct scatterlist *out_sg = areq->dst;
++	void *src_addr;
++	void *dst_addr;
++	unsigned int ileft = areq->nbytes;
++	unsigned int oleft = areq->nbytes;
++	unsigned int sgileft = areq->src->length;
++	unsigned int sgoleft = areq->dst->length;
++	unsigned int todo;
++	u32 *src32;
++	u32 *dst32;
++
++	mutex_lock(&ss->lock);
++
++	for (i = 0; i < op->keylen; i += 4)
++		writel(*(op->key + i/4), ss->base + SS_KEY0 + i);
++
++	if (areq->info != NULL) {
++		for (i = 0; i < 4 && i < ivsize / 4; i++) {
++			v = *(u32 *)(areq->info + i * 4);
++			writel(v, ss->base + SS_IV0 + i * 4);
++		}
++	}
++	writel(mode, ss->base + SS_CTL);
++
++	/* If we have only one SG, we can use kmap_atomic */
++	if (sg_next(in_sg) == NULL && sg_next(out_sg) == NULL)
++		return sunxi_ss_aes_poll_atomic(areq);
++
++	/*
++	 * If we have more than one SG, we cannot use kmap_atomic since
++	 * we hold the mapping too long
++	 */
++	src_addr = kmap(sg_page(in_sg)) + in_sg->offset;
++	if (src_addr == NULL) {
++		dev_err(ss->dev, "KMAP error for src SG\n");
++		mutex_unlock(&ss->lock);
++		return -EINVAL;
++	}
++	dst_addr = kmap(sg_page(out_sg)) + out_sg->offset;
++	if (dst_addr == NULL) {
++		kunmap(sg_page(in_sg));
++		dev_err(ss->dev, "KMAP error for dst SG\n");
++		mutex_unlock(&ss->lock);
++		return -EINVAL;
++	}
++	src32 = (u32 *)src_addr;
++	dst32 = (u32 *)dst_addr;
++	ileft = areq->nbytes / 4;
++	oleft = areq->nbytes / 4;
++	sgileft = in_sg->length / 4;
++	sgoleft = out_sg->length / 4;
++	do {
++		spaces = readl_relaxed(ss->base + SS_FCSR);
++		rx_cnt = SS_RXFIFO_SPACES(spaces);
++		tx_cnt = SS_TXFIFO_SPACES(spaces);
++		todo = min3(rx_cnt, ileft, sgileft);
++		if (todo > 0) {
++			ileft -= todo;
++			sgileft -= todo;
++		}
++		while (todo > 0) {
++			writel_relaxed(*src32++, ss->base + SS_RXFIFO);
++			todo--;
++		}
++		if (in_sg != NULL && sgileft == 0 && ileft > 0) {
++			kunmap(sg_page(in_sg));
++			in_sg = sg_next(in_sg);
++			while (in_sg != NULL && in_sg->length == 0)
++				in_sg = sg_next(in_sg);
++			if (in_sg != NULL && ileft > 0) {
++				src_addr = kmap(sg_page(in_sg)) + in_sg->offset;
++				if (src_addr == NULL) {
++					dev_err(ss->dev, "ERROR: KMAP for src SG\n");
++					mutex_unlock(&ss->lock);
++					return -EINVAL;
++				}
++				src32 = src_addr;
++				sgileft = in_sg->length / 4;
++			}
++		}
++		/* do not test oleft since when oleft == 0 we have finished */
++		todo = min3(tx_cnt, oleft, sgoleft);
++		if (todo > 0) {
++			oleft -= todo;
++			sgoleft -= todo;
++		}
++		while (todo > 0) {
++			*dst32++ = readl_relaxed(ss->base + SS_TXFIFO);
++			todo--;
++		}
++		if (out_sg != NULL && sgoleft == 0 && oleft >= 0) {
++			kunmap(sg_page(out_sg));
++			out_sg = sg_next(out_sg);
++			while (out_sg != NULL && out_sg->length == 0)
++				out_sg = sg_next(out_sg);
++			if (out_sg != NULL && oleft > 0) {
++				dst_addr = kmap(sg_page(out_sg)) +
++					out_sg->offset;
++				if (dst_addr == NULL) {
++					dev_err(ss->dev, "KMAP error\n");
++					mutex_unlock(&ss->lock);
++					return -EINVAL;
++				}
++				dst32 = dst_addr;
++				sgoleft = out_sg->length / 4;
++			}
++		}
++	} while (oleft > 0);
++
++	writel_relaxed(0, ss->base + SS_CTL);
++	mutex_unlock(&ss->lock);
++	return 0;
++}
++
++/*
++ * Pure CPU way of doing DES/3DES with SS
++ * Since DES and 3DES SGs could be smaller than 4 bytes, I use sg_copy_to_buffer
++ * for "linearize" them.
++ * The problem with that is that I alloc (2 x areq->nbytes) for buf_in/buf_out
++ * TODO: change this system, I need to support other mode than CBC where len
++ * is not a multiple of 4 and the hack of linearize use too much memory
++ * SGsrc -> buf_in -> SS -> buf_out -> SGdst
++ */
++int sunxi_ss_des_poll(struct ablkcipher_request *areq, u32 mode)
++{
++	u32 value, spaces;
++	size_t nb_in_sg_tx, nb_in_sg_rx;
++	size_t ir, it;
++	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(areq);
++	struct sunxi_tfm_ctx *op = crypto_ablkcipher_ctx(tfm);
++	unsigned int ivsize = crypto_ablkcipher_ivsize(tfm);
++	u32 tx_cnt = 0;
++	u32 rx_cnt = 0;
++	u32 v;
++	int i;
++	int no_chunk = 1;
++	struct scatterlist *in_sg = areq->src;
++	struct scatterlist *out_sg = areq->dst;
++
++	/*
++	 * if we have only SGs with size multiple of 4,
++	 * we can use the SS AES function
++	 */
++	while (in_sg != NULL && no_chunk == 1) {
++		if ((in_sg->length % 4) != 0)
++			no_chunk = 0;
++		in_sg = sg_next(in_sg);
++	}
++	while (out_sg != NULL && no_chunk == 1) {
++		if ((out_sg->length % 4) != 0)
++			no_chunk = 0;
++		out_sg = sg_next(out_sg);
++	}
++
++	if (no_chunk == 1)
++		return sunxi_ss_aes_poll(areq, mode);
++
++	in_sg = areq->src;
++	out_sg = areq->dst;
++
++	nb_in_sg_rx = sg_nents(in_sg);
++	nb_in_sg_tx = sg_nents(out_sg);
++
++	/*
++	 * buf_in and buf_out are allocated only one time
++	 * then we keep the buffer until driver end
++	 * the allocation can only grow more
++	 * we do not reduce it for simplification
++	 */
++	mutex_lock(&ss->bufin_lock);
++	if (ss->buf_in == NULL) {
++		ss->buf_in = kmalloc(areq->nbytes, GFP_KERNEL);
++		ss->buf_in_size = areq->nbytes;
++	} else {
++		if (areq->nbytes > ss->buf_in_size) {
++			kfree(ss->buf_in);
++			ss->buf_in = kmalloc(areq->nbytes, GFP_KERNEL);
++			ss->buf_in_size = areq->nbytes;
++		}
++	}
++	if (ss->buf_in == NULL) {
++		ss->buf_in_size = 0;
++		mutex_unlock(&ss->bufin_lock);
++		dev_err(ss->dev, "Unable to allocate pages.\n");
++		return -ENOMEM;
++	}
++	mutex_lock(&ss->bufout_lock);
++	if (ss->buf_out == NULL) {
++		ss->buf_out = kmalloc(areq->nbytes, GFP_KERNEL);
++		if (ss->buf_out == NULL) {
++			ss->buf_out_size = 0;
++			mutex_unlock(&ss->bufin_lock);
++			mutex_unlock(&ss->bufout_lock);
++			dev_err(ss->dev, "Unable to allocate pages.\n");
++			return -ENOMEM;
++		}
++		ss->buf_out_size = areq->nbytes;
++	} else {
++		if (areq->nbytes > ss->buf_out_size) {
++			kfree(ss->buf_out);
++			ss->buf_out = kmalloc(areq->nbytes, GFP_KERNEL);
++			if (ss->buf_out == NULL) {
++				ss->buf_out_size = 0;
++				mutex_unlock(&ss->bufin_lock);
++				mutex_unlock(&ss->bufout_lock);
++				dev_err(ss->dev, "Unable to allocate pages.\n");
++				return -ENOMEM;
++			}
++			ss->buf_out_size = areq->nbytes;
++		}
++	}
++
++	sg_copy_to_buffer(areq->src, nb_in_sg_rx, ss->buf_in, areq->nbytes);
++
++	ir = 0;
++	it = 0;
++	mutex_lock(&ss->lock);
++
++	for (i = 0; i < op->keylen; i += 4)
++		writel(*(op->key + i/4), ss->base + SS_KEY0 + i);
++	if (areq->info != NULL) {
++		for (i = 0; i < 4 && i < ivsize / 4; i++) {
++			v = *(u32 *)(areq->info + i * 4);
++			writel(v, ss->base + SS_IV0 + i * 4);
++		}
++	}
++	writel(mode, ss->base + SS_CTL);
++
++	do {
++		if (rx_cnt == 0 || tx_cnt == 0) {
++			spaces = readl(ss->base + SS_FCSR);
++			rx_cnt = SS_RXFIFO_SPACES(spaces);
++			tx_cnt = SS_TXFIFO_SPACES(spaces);
++		}
++		if (rx_cnt > 0 && ir < areq->nbytes) {
++			do {
++				value = *(u32 *)(ss->buf_in + ir);
++				writel(value, ss->base + SS_RXFIFO);
++				ir += 4;
++				rx_cnt--;
++			} while (rx_cnt > 0 && ir < areq->nbytes);
++		}
++		if (tx_cnt > 0 && it < areq->nbytes) {
++			do {
++				value = readl(ss->base + SS_TXFIFO);
++				*(u32 *)(ss->buf_out + it) = value;
++				it += 4;
++				tx_cnt--;
++			} while (tx_cnt > 0 && it < areq->nbytes);
++		}
++		if (ir == areq->nbytes) {
++			mutex_unlock(&ss->bufin_lock);
++			ir++;
++		}
++	} while (it < areq->nbytes);
++
++	writel(0, ss->base + SS_CTL);
++	mutex_unlock(&ss->lock);
++
++	/*
++	 * a simple optimization, since we dont need the hardware for this copy
++	 * we release the lock and do the copy. With that we gain 5/10% perf
++	 */
++	sg_copy_from_buffer(areq->dst, nb_in_sg_tx, ss->buf_out, areq->nbytes);
++
++	mutex_unlock(&ss->bufout_lock);
++	return 0;
++}
++
++/* check and set the AES key, prepare the mode to be used */
++int sunxi_ss_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
++		unsigned int keylen)
++{
++	struct sunxi_tfm_ctx *op = crypto_ablkcipher_ctx(tfm);
++
++	switch (keylen) {
++	case 128 / 8:
++		op->keymode = SS_AES_128BITS;
++		break;
++	case 192 / 8:
++		op->keymode = SS_AES_192BITS;
++		break;
++	case 256 / 8:
++		op->keymode = SS_AES_256BITS;
++		break;
++	default:
++		dev_err(ss->dev, "ERROR: Invalid keylen %u\n", keylen);
++		crypto_ablkcipher_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
++		return -EINVAL;
++	}
++	op->keylen = keylen;
++	memcpy(op->key, key, keylen);
++	return 0;
++}
++
++/* check and set the DES key, prepare the mode to be used */
++int sunxi_ss_des_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
++		unsigned int keylen)
++{
++	struct sunxi_tfm_ctx *op = crypto_ablkcipher_ctx(tfm);
++
++	if (keylen != DES_KEY_SIZE) {
++		dev_err(ss->dev, "Invalid keylen %u\n", keylen);
++		crypto_ablkcipher_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
++		return -EINVAL;
++	}
++	op->keylen = keylen;
++	memcpy(op->key, key, keylen);
++	return 0;
++}
++
++/* check and set the 3DES key, prepare the mode to be used */
++int sunxi_ss_des3_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
++		unsigned int keylen)
++{
++	struct sunxi_tfm_ctx *op = crypto_ablkcipher_ctx(tfm);
++
++	if (keylen != 3 * DES_KEY_SIZE) {
++		dev_err(ss->dev, "Invalid keylen %u\n", keylen);
++		crypto_ablkcipher_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
++		return -EINVAL;
++	}
++	op->keylen = keylen;
++	memcpy(op->key, key, keylen);
++	return 0;
++}
+diff --git a/drivers/crypto/sunxi-ss/sunxi-ss-core.c b/drivers/crypto/sunxi-ss/sunxi-ss-core.c
+new file mode 100644
+index 0000000..e66d7e2
+--- /dev/null
++++ b/drivers/crypto/sunxi-ss/sunxi-ss-core.c
+@@ -0,0 +1,318 @@
++/*
++ * sunxi-ss-core.c - hardware cryptographic accelerator for Allwinner A20 SoC
++ *
++ * Copyright (C) 2013-2014 Corentin LABBE <clabbe.montjoie@gmail.com>
++ *
++ * Core file which registers crypto algorithms supported by the SS.
++ *
++ * You could find a link for the datasheet in Documentation/arm/sunxi/README
++ *
++ * 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/clk.h>
++#include <linux/crypto.h>
++#include <linux/io.h>
++#include <linux/module.h>
++#include <linux/of.h>
++#include <linux/platform_device.h>
++#include <crypto/scatterwalk.h>
++#include <linux/scatterlist.h>
++#include <linux/interrupt.h>
++#include <linux/delay.h>
++
++#include "sunxi-ss.h"
++
++struct sunxi_ss_ctx *ss;
++
++/*
++ * General notes for whole driver:
++ *
++ * After each request the device must be disabled with a write of 0 in SS_CTL
++ *
++ * For performance reason, we use writel_relaxed/read_relaxed for all
++ * operations on RX and TX FIFO and also SS_FCSR.
++ * Excepts for the last write on TX FIFO.
++ * For all other registers, we use writel/readl.
++ * See http://permalink.gmane.org/gmane.linux.ports.arm.kernel/117644
++ * and http://permalink.gmane.org/gmane.linux.ports.arm.kernel/117640
++ */
++
++static struct ahash_alg sunxi_md5_alg = {
++	.init = sunxi_hash_init,
++	.update = sunxi_hash_update,
++	.final = sunxi_hash_final,
++	.finup = sunxi_hash_finup,
++	.digest = sunxi_hash_digest,
++	.halg = {
++		.digestsize = MD5_DIGEST_SIZE,
++		.base = {
++			.cra_name = "md5",
++			.cra_driver_name = "md5-sunxi-ss",
++			.cra_priority = 300,
++			.cra_alignmask = 3,
++			.cra_flags = CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
++			.cra_blocksize = MD5_HMAC_BLOCK_SIZE,
++			.cra_ctxsize = sizeof(struct sunxi_req_ctx),
++			.cra_module = THIS_MODULE,
++			.cra_type = &crypto_ahash_type,
++			.cra_init = sunxi_hash_crainit
++		}
++	}
++};
++
++static struct ahash_alg sunxi_sha1_alg = {
++	.init = sunxi_hash_init,
++	.update = sunxi_hash_update,
++	.final = sunxi_hash_final,
++	.finup = sunxi_hash_finup,
++	.digest = sunxi_hash_digest,
++	.halg = {
++		.digestsize = SHA1_DIGEST_SIZE,
++		.base = {
++			.cra_name = "sha1",
++			.cra_driver_name = "sha1-sunxi-ss",
++			.cra_priority = 300,
++			.cra_alignmask = 3,
++			.cra_flags = CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC,
++			.cra_blocksize = SHA1_BLOCK_SIZE,
++			.cra_ctxsize = sizeof(struct sunxi_req_ctx),
++			.cra_module = THIS_MODULE,
++			.cra_type = &crypto_ahash_type,
++			.cra_init = sunxi_hash_crainit
++		}
++	}
++};
++
++static struct crypto_alg sunxi_cipher_algs[] = {
++{
++	.cra_name = "cbc(aes)",
++	.cra_driver_name = "cbc-aes-sunxi-ss",
++	.cra_priority = 300,
++	.cra_blocksize = AES_BLOCK_SIZE,
++	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER,
++	.cra_ctxsize = sizeof(struct sunxi_tfm_ctx),
++	.cra_module = THIS_MODULE,
++	.cra_alignmask = 3,
++	.cra_type = &crypto_ablkcipher_type,
++	.cra_init = sunxi_ss_cipher_init,
++	.cra_u = {
++		.ablkcipher = {
++			.min_keysize    = AES_MIN_KEY_SIZE,
++			.max_keysize    = AES_MAX_KEY_SIZE,
++			.ivsize         = AES_BLOCK_SIZE,
++			.setkey         = sunxi_ss_aes_setkey,
++			.encrypt        = sunxi_ss_cipher_encrypt,
++			.decrypt        = sunxi_ss_cipher_decrypt,
++		}
++	}
++}, {
++	.cra_name = "cbc(des)",
++	.cra_driver_name = "cbc-des-sunxi-ss",
++	.cra_priority = 300,
++	.cra_blocksize = DES_BLOCK_SIZE,
++	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER,
++	.cra_ctxsize = sizeof(struct sunxi_req_ctx),
++	.cra_module = THIS_MODULE,
++	.cra_alignmask = 3,
++	.cra_type = &crypto_ablkcipher_type,
++	.cra_init = sunxi_ss_cipher_init,
++	.cra_u.ablkcipher = {
++		.min_keysize    = DES_KEY_SIZE,
++		.max_keysize    = DES_KEY_SIZE,
++		.ivsize         = DES_BLOCK_SIZE,
++		.setkey         = sunxi_ss_des_setkey,
++		.encrypt        = sunxi_ss_cipher_encrypt,
++		.decrypt        = sunxi_ss_cipher_decrypt,
++	}
++}, {
++	.cra_name = "cbc(des3_ede)",
++	.cra_driver_name = "cbc-des3-sunxi-ss",
++	.cra_priority = 300,
++	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
++	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER,
++	.cra_ctxsize = sizeof(struct sunxi_req_ctx),
++	.cra_module = THIS_MODULE,
++	.cra_alignmask = 3,
++	.cra_type = &crypto_ablkcipher_type,
++	.cra_init = sunxi_ss_cipher_init,
++	.cra_u.ablkcipher = {
++		.min_keysize    = DES3_EDE_KEY_SIZE,
++		.max_keysize    = DES3_EDE_KEY_SIZE,
++		.ivsize         = DES3_EDE_BLOCK_SIZE,
++		.setkey         = sunxi_ss_des3_setkey,
++		.encrypt        = sunxi_ss_cipher_encrypt,
++		.decrypt        = sunxi_ss_cipher_decrypt,
++	}
++}
++};
++
++static int sunxi_ss_probe(struct platform_device *pdev)
++{
++	struct resource *res;
++	u32 v;
++	int err;
++	unsigned long cr;
++	const unsigned long cr_ahb = 24 * 1000 * 1000;
++	const unsigned long cr_mod = 150 * 1000 * 1000;
++
++	if (!pdev->dev.of_node)
++		return -ENODEV;
++
++	ss = devm_kzalloc(&pdev->dev, sizeof(*ss), GFP_KERNEL);
++	if (ss == NULL)
++		return -ENOMEM;
++
++	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
++	ss->base = devm_ioremap_resource(&pdev->dev, res);
++	if (IS_ERR(ss->base)) {
++		dev_err(&pdev->dev, "Cannot request MMIO\n");
++		return PTR_ERR(ss->base);
++	}
++
++	ss->ssclk = devm_clk_get(&pdev->dev, "mod");
++	if (IS_ERR(ss->ssclk)) {
++		err = PTR_ERR(ss->ssclk);
++		dev_err(&pdev->dev, "Cannot get SS clock err=%d\n", err);
++		return err;
++	}
++	dev_dbg(&pdev->dev, "clock ss acquired\n");
++
++	ss->busclk = devm_clk_get(&pdev->dev, "ahb");
++	if (IS_ERR(ss->busclk)) {
++		err = PTR_ERR(ss->busclk);
++		dev_err(&pdev->dev, "Cannot get AHB SS clock err=%d\n", err);
++		return err;
++	}
++	dev_dbg(&pdev->dev, "clock ahb_ss acquired\n");
++
++	/* Enable both clocks */
++	err = clk_prepare_enable(ss->busclk);
++	if (err != 0) {
++		dev_err(&pdev->dev, "Cannot prepare_enable busclk\n");
++		return err;
++	}
++	err = clk_prepare_enable(ss->ssclk);
++	if (err != 0) {
++		dev_err(&pdev->dev, "Cannot prepare_enable ssclk\n");
++		clk_disable_unprepare(ss->busclk);
++		return err;
++	}
++
++	/*
++	 * Check that clock have the correct rates gived in the datasheet
++	 * Try to set the clock to the maximum allowed
++	 */
++	err = clk_set_rate(ss->ssclk, cr_mod);
++	if (err != 0) {
++		dev_err(&pdev->dev, "Cannot set clock rate to ssclk\n");
++		clk_disable_unprepare(ss->ssclk);
++		clk_disable_unprepare(ss->busclk);
++		return err;
++	}
++
++	cr = clk_get_rate(ss->busclk);
++	if (cr >= cr_ahb)
++		dev_dbg(&pdev->dev, "Clock bus %lu (%lu MHz) (must be >= %lu)\n",
++				cr, cr / 1000000, cr_ahb);
++	else
++		dev_warn(&pdev->dev, "Clock bus %lu (%lu MHz) (must be >= %lu)\n",
++				cr, cr / 1000000, cr_ahb);
++
++	cr = clk_get_rate(ss->ssclk);
++	if (cr <= cr_mod)
++		if (cr < cr_mod)
++			dev_info(&pdev->dev, "Clock ss %lu (%lu MHz) (must be <= %lu)\n",
++					cr, cr / 1000000, cr_mod);
++		else
++			dev_dbg(&pdev->dev, "Clock ss %lu (%lu MHz) (must be <= %lu)\n",
++					cr, cr / 1000000, cr_mod);
++	else
++		dev_warn(&pdev->dev, "Clock ss is at %lu (%lu MHz) (must be <= %lu)\n",
++				cr, cr / 1000000, cr_mod);
++
++	/*
++	 * Datasheet named it "Die Bonding ID"
++	 * I expect to be a sort of Security System Revision number.
++	 * Since the A80 seems to have an other version of SS
++	 * this info could be useful
++	 */
++	writel(SS_ENABLED, ss->base + SS_CTL);
++	v = readl(ss->base + SS_CTL);
++	v >>= 16;
++	v &= 0x07;
++	dev_info(&pdev->dev, "Die ID %d\n", v);
++	writel(0, ss->base + SS_CTL);
++
++	ss->dev = &pdev->dev;
++
++	mutex_init(&ss->lock);
++	mutex_init(&ss->bufin_lock);
++	mutex_init(&ss->bufout_lock);
++
++	err = crypto_register_ahash(&sunxi_md5_alg);
++	if (err)
++		goto error_md5;
++	err = crypto_register_ahash(&sunxi_sha1_alg);
++	if (err)
++		goto error_sha1;
++	err = crypto_register_algs(sunxi_cipher_algs,
++			ARRAY_SIZE(sunxi_cipher_algs));
++	if (err)
++		goto error_ciphers;
++
++	return 0;
++error_ciphers:
++	crypto_unregister_ahash(&sunxi_sha1_alg);
++error_sha1:
++	crypto_unregister_ahash(&sunxi_md5_alg);
++error_md5:
++	clk_disable_unprepare(ss->ssclk);
++	clk_disable_unprepare(ss->busclk);
++	return err;
++}
++
++static int __exit sunxi_ss_remove(struct platform_device *pdev)
++{
++	if (!pdev->dev.of_node)
++		return 0;
++
++	crypto_unregister_ahash(&sunxi_md5_alg);
++	crypto_unregister_ahash(&sunxi_sha1_alg);
++	crypto_unregister_algs(sunxi_cipher_algs,
++			ARRAY_SIZE(sunxi_cipher_algs));
++
++	if (ss->buf_in != NULL)
++		kfree(ss->buf_in);
++	if (ss->buf_out != NULL)
++		kfree(ss->buf_out);
++
++	writel(0, ss->base + SS_CTL);
++	clk_disable_unprepare(ss->busclk);
++	clk_disable_unprepare(ss->ssclk);
++	return 0;
++}
++
++static const struct of_device_id a20ss_crypto_of_match_table[] = {
++	{ .compatible = "allwinner,sun7i-a20-crypto" },
++	{}
++};
++MODULE_DEVICE_TABLE(of, a20ss_crypto_of_match_table);
++
++static struct platform_driver sunxi_ss_driver = {
++	.probe          = sunxi_ss_probe,
++	.remove         = __exit_p(sunxi_ss_remove),
++	.driver         = {
++		.owner          = THIS_MODULE,
++		.name           = "sunxi-ss",
++		.of_match_table	= a20ss_crypto_of_match_table,
++	},
++};
++
++module_platform_driver(sunxi_ss_driver);
++
++MODULE_DESCRIPTION("Allwinner Security System cryptographic accelerator");
++MODULE_LICENSE("GPL");
++MODULE_AUTHOR("Corentin LABBE <clabbe.montjoie@gmail.com>");
+diff --git a/drivers/crypto/sunxi-ss/sunxi-ss-hash.c b/drivers/crypto/sunxi-ss/sunxi-ss-hash.c
+new file mode 100644
+index 0000000..ec8758f
+--- /dev/null
++++ b/drivers/crypto/sunxi-ss/sunxi-ss-hash.c
+@@ -0,0 +1,445 @@
++/*
++ * sunxi-ss-hash.c - hardware cryptographic accelerator for Allwinner A20 SoC
++ *
++ * Copyright (C) 2013-2014 Corentin LABBE <clabbe.montjoie@gmail.com>
++ *
++ * This file add support for MD5 and SHA1.
++ *
++ * You could find the datasheet in Documentation/arm/sunxi/README
++ *
++ * 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 "sunxi-ss.h"
++
++/* This is a totaly arbitrary value */
++#define SS_TIMEOUT 100
++
++extern struct sunxi_ss_ctx *ss;
++
++int sunxi_hash_crainit(struct crypto_tfm *tfm)
++{
++	crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
++			sizeof(struct sunxi_req_ctx));
++	return 0;
++}
++
++/* sunxi_hash_init: initialize request context */
++int sunxi_hash_init(struct ahash_request *areq)
++{
++	const char *hash_type;
++	struct sunxi_req_ctx *op = ahash_request_ctx(areq);
++
++	memset(op, 0, sizeof(struct sunxi_req_ctx));
++
++	hash_type = crypto_tfm_alg_name(areq->base.tfm);
++
++	if (strcmp(hash_type, "sha1") == 0)
++		op->mode = SS_OP_SHA1;
++	if (strcmp(hash_type, "md5") == 0)
++		op->mode = SS_OP_MD5;
++	if (op->mode == 0)
++		return -EINVAL;
++
++	return 0;
++}
++
++static u32 rx_cnt;
++
++inline void ss_writer(const u32 v)
++{
++	u32 spaces;
++
++	writel(v, ss->base + SS_RXFIFO);
++	rx_cnt--;
++	while (rx_cnt == 0) {
++		spaces = readl_relaxed(ss->base + SS_FCSR);
++		rx_cnt = SS_RXFIFO_SPACES(spaces);
++	}
++}
++
++inline void ss_writer_relaxed(const u32 v)
++{
++	u32 spaces;
++
++	writel_relaxed(v, ss->base + SS_RXFIFO);
++	rx_cnt--;
++	while (rx_cnt == 0) {
++		spaces = readl_relaxed(ss->base + SS_FCSR);
++		rx_cnt = SS_RXFIFO_SPACES(spaces);
++	}
++}
++
++/*
++ * sunxi_hash_update: update hash engine
++ *
++ * Could be used for both SHA1 and MD5
++ * Write data by step of 32bits and put then in the SS.
++ *
++ * Since we cannot leave partial data and hash state in the engine,
++ * we need to get the hash state at the end of this function.
++ * After some work, I have found that we can get the hash state every 64o
++ *
++ * So the first work is to get the number of bytes to write to SS modulo 64
++ * The extra bytes will go to two different destination:
++ * op->wait for full 32bits word
++ * op->wb (waiting bytes) for partial 32 bits word
++ * So we can have up to (64/4)-1 op->wait words and 0/1/2/3 bytes in wb
++ *
++ * So at the begin of update()
++ * if op->nwait * 4 + areq->nbytes < 64
++ * => all data writed to wait buffers and end=0
++ * if not write all nwait to the device and position end to complete to 64o
++ *
++ * example 1:
++ * update1 60o => nwait=15
++ * update2 60o => need one more word to have 64o
++ * end=4
++ * so write all data in op->wait and one word of SGs
++ * write remaining data in op->wait
++ * final state op->nwait=14
++ */
++int sunxi_hash_update(struct ahash_request *areq)
++{
++	u32 v, ivmode = 0;
++	unsigned int i = 0;
++	/*
++	 * i is the total bytes read from SGs, to be compared to areq->nbytes
++	 * i is important because we cannot rely on SG length since the sum of
++	 * SG->length could be greater than areq->nbytes
++	 */
++
++	struct sunxi_req_ctx *op = ahash_request_ctx(areq);
++	struct scatterlist *in_sg;
++	unsigned int in_i = 0; /* advancement in the current SG */
++	u64 end;
++	/*
++	 * end is the position when we need to stop writing to the device,
++	 * to be compared to i
++	 */
++	int in_r;
++	void *src_addr;
++
++	dev_dbg(ss->dev, "%s %s bc=%llu len=%u mode=%x bw=%u ww=%u",
++			__func__, crypto_tfm_alg_name(areq->base.tfm),
++			op->byte_count, areq->nbytes, op->mode,
++			op->nbw, op->nwait);
++
++	if (areq->nbytes == 0)
++		return 0;
++
++	end = ((areq->nbytes + op->nwait * 4 + op->nbw) / 64) * 64
++		- op->nbw - op->nwait * 4;
++
++	if (end > areq->nbytes || areq->nbytes - end > 63) {
++		dev_err(ss->dev, "ERROR: Bound error %llu %u\n",
++				end, areq->nbytes);
++		return -EINVAL;
++	}
++
++	if (op->nwait > 0 && end > 0) {
++		/* a precedent update was done */
++		for (i = 0; i < op->nwait; i++) {
++			ss_writer(op->wait[i]);
++			op->byte_count += 4;
++		}
++		op->nwait = 0;
++	}
++
++	mutex_lock(&ss->lock);
++	/*
++	 * if some data have been processed before,
++	 * we need to restore the partial hash state
++	 */
++	if (op->byte_count > 0) {
++		ivmode = SS_IV_ARBITRARY;
++		for (i = 0; i < 5; i++)
++			writel(op->hash[i], ss->base + SS_IV0 + i * 4);
++	}
++	/* Enable the device */
++	writel(op->mode | SS_ENABLED | ivmode, ss->base + SS_CTL);
++
++	rx_cnt = 0;
++	i = 0;
++
++	in_sg = areq->src;
++	src_addr = kmap(sg_page(in_sg)) + in_sg->offset;
++	if (src_addr == NULL) {
++		mutex_unlock(&ss->lock);
++		dev_err(ss->dev, "ERROR: Cannot kmap source buffer\n");
++		return -EFAULT;
++	}
++	do {
++		/*
++		 * step 1, if some bytes remains from last SG,
++		 * try to complete them to 4 and send that word
++		 */
++		if (op->nbw > 0) {
++			while (op->nbw < 4 && i < areq->nbytes &&
++					in_i < in_sg->length) {
++				op->wb |= (*(u8 *)(src_addr + in_i))
++					<< (8 * op->nbw);
++				dev_dbg(ss->dev, "%s Complete w=%d wb=%x\n",
++						__func__, op->nbw, op->wb);
++				i++;
++				in_i++;
++				op->nbw++;
++			}
++			if (op->nbw == 4) {
++				if (i <= end) {
++					ss_writer(op->wb);
++					op->byte_count += 4;
++				} else {
++					op->wait[op->nwait] = op->wb;
++					op->nwait++;
++					dev_dbg(ss->dev, "%s Keep %u bytes after %llu\n",
++						__func__, op->nwait, end);
++				}
++				op->nbw = 0;
++				op->wb = 0;
++			}
++		}
++		/* step 2, main loop, read data 4bytes at a time */
++		while (i < areq->nbytes && in_i < in_sg->length) {
++			/* how many bytes we can read, (we need 4) */
++			in_r = min(in_sg->length - in_i, areq->nbytes - i);
++			if (in_r < 4) {
++				/* Not enough data to write to the device */
++				op->wb = 0;
++				while (in_r > 0) {
++					op->wb |= (*(u8 *)(src_addr + in_i))
++						<< (8 * op->nbw);
++					dev_dbg(ss->dev, "%s ending bw=%d wb=%x\n",
++						__func__, op->nbw, op->wb);
++					in_r--;
++					i++;
++					in_i++;
++					op->nbw++;
++				}
++				goto nextsg;
++			}
++			v = *(u32 *)(src_addr + in_i);
++			if (i < end) {
++				/* last write must be done without relaxed */
++				if (i + 4 >= end)
++					ss_writer(v);
++				else
++					ss_writer_relaxed(v);
++				i += 4;
++				op->byte_count += 4;
++				in_i += 4;
++			} else {
++				op->wait[op->nwait] = v;
++				i += 4;
++				in_i += 4;
++				op->nwait++;
++				dev_dbg(ss->dev, "%s Keep word ww=%u after %llu\n",
++						__func__, op->nwait, end);
++				if (op->nwait > 15) {
++					dev_err(ss->dev, "FATAL: Cannot enqueue more, bug?\n");
++					writel(0, ss->base + SS_CTL);
++					mutex_unlock(&ss->lock);
++					return -EIO;
++				}
++			}
++		}
++nextsg:
++		/* Nothing more to read in this SG */
++		if (in_i == in_sg->length) {
++			kunmap(sg_page(in_sg));
++			do {
++				in_sg = sg_next(in_sg);
++			} while (in_sg != NULL && in_sg->length == 0);
++			in_i = 0;
++			if (in_sg != NULL) {
++				src_addr = kmap(sg_page(in_sg)) + in_sg->offset;
++				if (src_addr == NULL) {
++					mutex_unlock(&ss->lock);
++					dev_err(ss->dev, "ERROR: Cannot kmap source buffer\n");
++					return -EFAULT;
++				}
++			}
++		}
++	} while (in_sg != NULL && i < areq->nbytes);
++
++	/* ask the device to finish the hashing */
++	writel(op->mode | SS_ENABLED | SS_DATA_END, ss->base + SS_CTL);
++	i = 0;
++	do {
++		v = readl(ss->base + SS_CTL);
++		i++;
++	} while (i < SS_TIMEOUT && (v & SS_DATA_END) > 0);
++	if (i >= SS_TIMEOUT) {
++		dev_err(ss->dev, "ERROR: %s hash end timeout after %d loop, CTL=%x\n",
++				__func__, i, v);
++		writel(0, ss->base + SS_CTL);
++		mutex_unlock(&ss->lock);
++		return -EIO;
++	}
++
++	/* get the partial hash */
++	if (op->mode == SS_OP_SHA1) {
++		for (i = 0; i < 5; i++)
++			op->hash[i] = readl(ss->base + SS_MD0 + i * 4);
++	} else {
++		for (i = 0; i < 4; i++)
++			op->hash[i] = readl(ss->base + SS_MD0 + i * 4);
++	}
++
++	writel(0, ss->base + SS_CTL);
++	mutex_unlock(&ss->lock);
++	return 0;
++}
++
++/*
++ * sunxi_hash_final: finalize hashing operation
++ *
++ * If we have some remaining bytes, we write them.
++ * Then ask the SS for finalizing the hashing operation
++ */
++int sunxi_hash_final(struct ahash_request *areq)
++{
++	u32 v, ivmode = 0;
++	unsigned int i;
++	int zeros;
++	unsigned int index, padlen;
++	__be64 bits;
++	struct sunxi_req_ctx *op = ahash_request_ctx(areq);
++
++	dev_dbg(ss->dev, "%s byte=%llu len=%u mode=%x bw=%u %x h=%x ww=%u",
++			__func__, op->byte_count, areq->nbytes, op->mode,
++			op->nbw, op->wb, op->hash[0], op->nwait);
++
++	mutex_lock(&ss->lock);
++	rx_cnt = 0;
++
++	/*
++	 * if we have already writed something,
++	 * restore the partial hash state
++	 */
++	if (op->byte_count > 0) {
++		ivmode = SS_IV_ARBITRARY;
++		for (i = 0; i < 5; i++)
++			writel(op->hash[i], ss->base + SS_IV0 + i * 4);
++	}
++	writel(op->mode | SS_ENABLED | ivmode, ss->base + SS_CTL);
++
++	/* write the remaining words of the wait buffer */
++	if (op->nwait > 0) {
++		for (i = 0; i < op->nwait; i++) {
++			v = op->wait[i];
++			ss_writer(v);
++			op->byte_count += 4;
++			dev_dbg(ss->dev, "%s write %llu i=%u %x\n",
++					__func__, op->byte_count, i, v);
++		}
++		op->nwait = 0;
++	}
++
++	/* write the remaining bytes of the nbw buffer */
++	if (op->nbw > 0) {
++		op->wb |= ((1 << 7) << (op->nbw * 8));
++		ss_writer(op->wb);
++	} else {
++		ss_writer((1 << 7));
++	}
++
++	/*
++	 * number of space to pad to obtain 64o minus 8(size) minus 4 (final 1)
++	 * I take the operations from other md5/sha1 implementations
++	 */
++
++	/* we have already send 4 more byte of which nbw data */
++	if (op->mode == SS_OP_MD5) {
++		index = (op->byte_count + 4) & 0x3f;
++		op->byte_count += op->nbw;
++		if (index > 56)
++			zeros = (120 - index) / 4;
++		else
++			zeros = (56 - index) / 4;
++	} else {
++		op->byte_count += op->nbw;
++		index = op->byte_count & 0x3f;
++		padlen = (index < 56) ? (56 - index) : ((64+56) - index);
++		zeros = (padlen - 1) / 4;
++	}
++	for (i = 0; i < zeros; i++)
++		ss_writer(0);
++
++	/* write the length of data */
++	if (op->mode == SS_OP_SHA1) {
++		bits = cpu_to_be64(op->byte_count << 3);
++		ss_writer(bits & 0xffffffff);
++		ss_writer((bits >> 32) & 0xffffffff);
++	} else {
++		ss_writer((op->byte_count << 3) & 0xffffffff);
++		ss_writer((op->byte_count >> 29) & 0xffffffff);
++	}
++
++	/* Tell the SS to stop the hashing */
++	writel(op->mode | SS_ENABLED | SS_DATA_END, ss->base + SS_CTL);
++
++	/*
++	 * Wait for SS to finish the hash.
++	 * The timeout could happend only in case of bad overcloking
++	 * or driver bug.
++	 */
++	i = 0;
++	do {
++		v = readl(ss->base + SS_CTL);
++		i++;
++	} while (i < SS_TIMEOUT && (v & SS_DATA_END) > 0);
++	if (i >= SS_TIMEOUT) {
++		dev_err(ss->dev, "ERROR: hash end timeout %d>%d ctl=%x len=%u\n",
++				i, SS_TIMEOUT, v, areq->nbytes);
++		writel(0, ss->base + SS_CTL);
++		mutex_unlock(&ss->lock);
++		return -EIO;
++	}
++
++	/* Get the hash from the device */
++	if (op->mode == SS_OP_SHA1) {
++		for (i = 0; i < 5; i++) {
++			v = cpu_to_be32(readl(ss->base + SS_MD0 + i * 4));
++			memcpy(areq->result + i * 4, &v, 4);
++		}
++	} else {
++		for (i = 0; i < 4; i++) {
++			v = readl(ss->base + SS_MD0 + i * 4);
++			memcpy(areq->result + i * 4, &v, 4);
++		}
++	}
++	writel(0, ss->base + SS_CTL);
++	mutex_unlock(&ss->lock);
++	return 0;
++}
++
++/* sunxi_hash_finup: finalize hashing operation after an update */
++int sunxi_hash_finup(struct ahash_request *areq)
++{
++	int err;
++
++	err = sunxi_hash_update(areq);
++	if (err != 0)
++		return err;
++
++	return sunxi_hash_final(areq);
++}
++
++/* combo of init/update/final functions */
++int sunxi_hash_digest(struct ahash_request *areq)
++{
++	int err;
++
++	err = sunxi_hash_init(areq);
++	if (err != 0)
++		return err;
++
++	err = sunxi_hash_update(areq);
++	if (err != 0)
++		return err;
++
++	return sunxi_hash_final(areq);
++}
+diff --git a/drivers/crypto/sunxi-ss/sunxi-ss.h b/drivers/crypto/sunxi-ss/sunxi-ss.h
+new file mode 100644
+index 0000000..331e75b
+--- /dev/null
++++ b/drivers/crypto/sunxi-ss/sunxi-ss.h
+@@ -0,0 +1,193 @@
++/*
++ * sunxi-ss.c - hardware cryptographic accelerator for Allwinner A20 SoC
++ *
++ * Copyright (C) 2013-2014 Corentin LABBE <clabbe.montjoie@gmail.com>
++ *
++ * Support AES cipher with 128,192,256 bits keysize.
++ * Support MD5 and SHA1 hash algorithms.
++ * Support DES and 3DES
++ *
++ * You could find the datasheet in Documentation/arm/sunxi/README
++ *
++ * Licensed under the GPL-2.
++ */
++
++#include <linux/clk.h>
++#include <linux/crypto.h>
++#include <linux/io.h>
++#include <linux/module.h>
++#include <linux/of.h>
++#include <linux/platform_device.h>
++#include <crypto/scatterwalk.h>
++#include <linux/scatterlist.h>
++#include <linux/interrupt.h>
++#include <linux/delay.h>
++#include <crypto/md5.h>
++#include <crypto/sha.h>
++#include <crypto/hash.h>
++#include <crypto/internal/hash.h>
++#include <crypto/aes.h>
++#include <crypto/des.h>
++#include <crypto/internal/rng.h>
++
++#define SS_CTL            0x00
++#define SS_KEY0           0x04
++#define SS_KEY1           0x08
++#define SS_KEY2           0x0C
++#define SS_KEY3           0x10
++#define SS_KEY4           0x14
++#define SS_KEY5           0x18
++#define SS_KEY6           0x1C
++#define SS_KEY7           0x20
++
++#define SS_IV0            0x24
++#define SS_IV1            0x28
++#define SS_IV2            0x2C
++#define SS_IV3            0x30
++
++#define SS_CNT0           0x34
++#define SS_CNT1           0x38
++#define SS_CNT2           0x3C
++#define SS_CNT3           0x40
++
++#define SS_FCSR           0x44
++#define SS_ICSR           0x48
++
++#define SS_MD0            0x4C
++#define SS_MD1            0x50
++#define SS_MD2            0x54
++#define SS_MD3            0x58
++#define SS_MD4            0x5C
++
++#define SS_RXFIFO         0x200
++#define SS_TXFIFO         0x204
++
++/* SS_CTL configuration values */
++
++/* PRNG generator mode - bit 15 */
++#define SS_PRNG_ONESHOT		(0 << 15)
++#define SS_PRNG_CONTINUE	(1 << 15)
++
++/* IV mode for hash */
++#define SS_IV_ARBITRARY		(1 << 14)
++
++/* SS operation mode - bits 12-13 */
++#define SS_ECB			(0 << 12)
++#define SS_CBC			(1 << 12)
++#define SS_CNT			(2 << 12)
++
++/* Counter width for CNT mode - bits 10-11 */
++#define SS_CNT_16BITS		(0 << 10)
++#define SS_CNT_32BITS		(1 << 10)
++#define SS_CNT_64BITS		(2 << 10)
++
++/* Key size for AES - bits 8-9 */
++#define SS_AES_128BITS		(0 << 8)
++#define SS_AES_192BITS		(1 << 8)
++#define SS_AES_256BITS		(2 << 8)
++
++/* Operation direction - bit 7 */
++#define SS_ENCRYPTION		(0 << 7)
++#define SS_DECRYPTION		(1 << 7)
++
++/* SS Method - bits 4-6 */
++#define SS_OP_AES		(0 << 4)
++#define SS_OP_DES		(1 << 4)
++#define SS_OP_3DES		(2 << 4)
++#define SS_OP_SHA1		(3 << 4)
++#define SS_OP_MD5		(4 << 4)
++#define SS_OP_PRNG		(5 << 4)
++
++/* Data end bit - bit 2 */
++#define SS_DATA_END		(1 << 2)
++
++/* PRNG start bit - bit 1 */
++#define SS_PRNG_START		(1 << 1)
++
++/* SS Enable bit - bit 0 */
++#define SS_DISABLED		(0 << 0)
++#define SS_ENABLED		(1 << 0)
++
++/* SS_FCSR configuration values */
++/* RX FIFO status - bit 30 */
++#define SS_RXFIFO_FREE		(1 << 30)
++
++/* RX FIFO empty spaces - bits 24-29 */
++#define SS_RXFIFO_SPACES(val)	(((val) >> 24) & 0x3f)
++
++/* TX FIFO status - bit 22 */
++#define SS_TXFIFO_AVAILABLE	(1 << 22)
++
++/* TX FIFO available spaces - bits 16-21 */
++#define SS_TXFIFO_SPACES(val)	(((val) >> 16) & 0x3f)
++
++#define SS_RXFIFO_EMP_INT_PENDING	(1 << 10)
++#define SS_TXFIFO_AVA_INT_PENDING	(1 << 8)
++#define SS_RXFIFO_EMP_INT_ENABLE	(1 << 2)
++#define SS_TXFIFO_AVA_INT_ENABLE	(1 << 0)
++
++/* SS_ICSR configuration values */
++#define SS_ICS_DRQ_ENABLE		(1 << 4)
++
++struct sunxi_ss_ctx {
++	void __iomem *base;
++	int irq;
++	struct clk *busclk;
++	struct clk *ssclk;
++	struct device *dev;
++	struct resource *res;
++	void *buf_in; /* pointer to data to be uploaded to the device */
++	size_t buf_in_size; /* size of buf_in */
++	void *buf_out;
++	size_t buf_out_size;
++	struct mutex lock; /* control the use of the device */
++	struct mutex bufout_lock; /* control the use of buf_out*/
++	struct mutex bufin_lock; /* control the sue of buf_in*/
++};
++
++struct sunxi_tfm_ctx {
++	u32 key[AES_MAX_KEY_SIZE / 4];/* divided by sizeof(u32) */
++	u32 keylen;
++	u32 keymode;
++};
++
++struct sunxi_req_ctx {
++	u32 mode;
++	u64 byte_count; /* number of bytes "uploaded" to the device */
++	u32 wb; /* a partial word waiting to be completed and
++			uploaded to the device */
++	/* number of bytes to be uploaded in the wb word */
++	unsigned int nbw;
++	u32 hash[5];
++	u32 wait[64];
++	unsigned int nwait;
++};
++
++#define SS_SEED_LEN (192/8)
++#define SS_DATA_LEN (160/8)
++
++struct prng_context {
++	u32 seed[SS_SEED_LEN/4];
++	unsigned int slen;
++};
++
++int sunxi_hash_crainit(struct crypto_tfm *tfm);
++int sunxi_hash_init(struct ahash_request *areq);
++int sunxi_hash_update(struct ahash_request *areq);
++int sunxi_hash_final(struct ahash_request *areq);
++int sunxi_hash_finup(struct ahash_request *areq);
++int sunxi_hash_digest(struct ahash_request *areq);
++int sunxi_hash_export(struct ahash_request *areq, void *out);
++int sunxi_hash_import(struct ahash_request *areq, const void *in);
++
++int sunxi_ss_aes_poll(struct ablkcipher_request *areq, u32 mode);
++int sunxi_ss_des_poll(struct ablkcipher_request *areq, u32 mode);
++int sunxi_ss_cipher_init(struct crypto_tfm *tfm);
++int sunxi_ss_cipher_encrypt(struct ablkcipher_request *areq);
++int sunxi_ss_cipher_decrypt(struct ablkcipher_request *areq);
++int sunxi_ss_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
++		unsigned int keylen);
++int sunxi_ss_des_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
++		unsigned int keylen);
++int sunxi_ss_des3_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
++		unsigned int keylen);
diff --git a/target/linux/sunxi/patches-3.18/300-dt-sun7i-add-bananapi.patch b/target/linux/sunxi/patches-3.18/300-dt-sun7i-add-bananapi.patch
new file mode 100644
index 0000000..0ee3195
--- /dev/null
+++ b/target/linux/sunxi/patches-3.18/300-dt-sun7i-add-bananapi.patch
@@ -0,0 +1,250 @@
+From 29b4146ec174f0f598d6b454caa335e8f57e392b Mon Sep 17 00:00:00 2001
+From: Hans de Goede <hdegoede@redhat.com>
+Date: Mon, 28 Jul 2014 23:05:14 +0200
+Subject: [PATCH] ARM: dts: sun7i: Add Banana Pi board
+
+The Banana Pi is an A20 based development board using Raspberry Pi compatible
+IO headers. It comes with 1 GB RAM, 1 Gb ethernet, 2x USB host, sata, hdmi
+and stereo audio out + various expenansion headers:
+
+http://www.lemaker.org/
+
+Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+---
+ arch/arm/boot/dts/Makefile               |   1 +
+ arch/arm/boot/dts/sun7i-a20-bananapi.dts | 214 +++++++++++++++++++++++++++++++
+ 2 files changed, 215 insertions(+)
+ create mode 100644 arch/arm/boot/dts/sun7i-a20-bananapi.dts
+
+diff --git a/arch/arm/boot/dts/Makefile b/arch/arm/boot/dts/Makefile
+index 38c89ca..63422bd 100644
+--- a/arch/arm/boot/dts/Makefile
++++ b/arch/arm/boot/dts/Makefile
+@@ -435,6 +435,7 @@ dtb-$(CONFIG_MACH_SUN6I) += \
+ 	sun6i-a31-hummingbird.dtb \
+ 	sun6i-a31-m9.dtb
+ dtb-$(CONFIG_MACH_SUN7I) += \
++	sun7i-a20-bananapi.dtb \
+ 	sun7i-a20-cubieboard2.dtb \
+ 	sun7i-a20-cubietruck.dtb \
+ 	sun7i-a20-hummingbird.dtb \
+diff --git a/arch/arm/boot/dts/sun7i-a20-bananapi.dts b/arch/arm/boot/dts/sun7i-a20-bananapi.dts
+new file mode 100644
+index 0000000..0e7c9f5
+--- /dev/null
++++ b/arch/arm/boot/dts/sun7i-a20-bananapi.dts
+@@ -0,0 +1,214 @@
++/*
++ * Copyright 2014 Hans de Goede <hdegoede@redhat.com>
++ *
++ * Hans de Goede <hdegoede@redhat.com>
++ *
++ * This file is dual-licensed: you can use it either under the terms
++ * of the GPL or the X11 license, at your option. Note that this dual
++ * licensing only applies to this file, and not this project as a
++ * whole.
++ *
++ *  a) This library 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 library 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 library; if not, write to the Free
++ *     Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
++ *     MA 02110-1301 USA
++ *
++ * Or, alternatively,
++ *
++ *  b) Permission is hereby granted, free of charge, to any person
++ *     obtaining a copy of this software and associated documentation
++ *     files (the "Software"), to deal in the Software without
++ *     restriction, including without limitation the rights to use,
++ *     copy, modify, merge, publish, distribute, sublicense, and/or
++ *     sell copies of the Software, and to permit persons to whom the
++ *     Software is furnished to do so, subject to the following
++ *     conditions:
++ *
++ *     The above copyright notice and this permission notice shall be
++ *     included in all copies or substantial portions of the Software.
++ *
++ *     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
++ *     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
++ *     OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
++ *     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
++ *     HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
++ *     WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ *     FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
++ *     OTHER DEALINGS IN THE SOFTWARE.
++ */
++
++/dts-v1/;
++/include/ "sun7i-a20.dtsi"
++/include/ "sunxi-common-regulators.dtsi"
++
++/ {
++	model = "LeMaker Banana Pi";
++	compatible = "lemaker,bananapi", "allwinner,sun7i-a20";
++
++	soc@01c00000 {
++		spi0: spi@01c05000 {
++			pinctrl-names = "default";
++			pinctrl-0 = <&spi0_pins_a>;
++			status = "okay";
++		};
++
++		mmc0: mmc@01c0f000 {
++			pinctrl-names = "default";
++			pinctrl-0 = <&mmc0_pins_a>, <&mmc0_cd_pin_bananapi>;
++			vmmc-supply = <&reg_vcc3v3>;
++			bus-width = <4>;
++			cd-gpios = <&pio 7 10 0>; /* PH10 */
++			cd-inverted;
++			status = "okay";
++		};
++
++		usbphy: phy@01c13400 {
++			usb1_vbus-supply = <&reg_usb1_vbus>;
++			usb2_vbus-supply = <&reg_usb2_vbus>;
++			status = "okay";
++		};
++
++		ehci0: usb@01c14000 {
++			status = "okay";
++		};
++
++		ohci0: usb@01c14400 {
++			status = "okay";
++		};
++
++		ahci: sata@01c18000 {
++			status = "okay";
++		};
++
++		ehci1: usb@01c1c000 {
++			status = "okay";
++		};
++
++		ohci1: usb@01c1c400 {
++			status = "okay";
++		};
++
++		pinctrl@01c20800 {
++			mmc0_cd_pin_bananapi: mmc0_cd_pin@0 {
++				allwinner,pins = "PH10";
++				allwinner,function = "gpio_in";
++				allwinner,drive = <0>;
++				allwinner,pull = <1>;
++			};
++
++			gmac_power_pin_bananapi: gmac_power_pin@0 {
++				allwinner,pins = "PH23";
++				allwinner,function = "gpio_out";
++				allwinner,drive = <0>;
++				allwinner,pull = <0>;
++			};
++
++			led_pins_bananapi: led_pins@0 {
++				allwinner,pins = "PH24";
++				allwinner,function = "gpio_out";
++				allwinner,drive = <0>;
++				allwinner,pull = <0>;
++			};
++		};
++
++		ir0: ir@01c21800 {
++			pinctrl-names = "default";
++			pinctrl-0 = <&ir0_pins_a>;
++			status = "okay";
++		};
++
++		uart0: serial@01c28000 {
++			pinctrl-names = "default";
++			pinctrl-0 = <&uart0_pins_a>;
++			status = "okay";
++		};
++
++		uart3: serial@01c28c00 {
++			pinctrl-names = "default";
++			pinctrl-0 = <&uart3_pins_b>;
++			status = "okay";
++		};
++
++		uart7: serial@01c29c00 {
++			pinctrl-names = "default";
++			pinctrl-0 = <&uart7_pins_a>;
++			status = "okay";
++		};
++
++		i2c0: i2c@01c2ac00 {
++			pinctrl-names = "default";
++			pinctrl-0 = <&i2c0_pins_a>;
++			status = "okay";
++
++			axp209: pmic@34 {
++				compatible = "x-powers,axp209";
++				reg = <0x34>;
++				interrupt-parent = <&nmi_intc>;
++				interrupts = <0 8>;
++
++				interrupt-controller;
++				#interrupt-cells = <1>;
++			};
++		};
++
++		i2c2: i2c@01c2b400 {
++			pinctrl-names = "default";
++			pinctrl-0 = <&i2c2_pins_a>;
++			status = "okay";
++		};
++
++		gmac: ethernet@01c50000 {
++			pinctrl-names = "default";
++			pinctrl-0 = <&gmac_pins_rgmii_a>;
++			phy = <&phy1>;
++			phy-mode = "rgmii";
++			phy-supply = <&reg_gmac_3v3>;
++			status = "okay";
++
++			phy1: ethernet-phy@1 {
++				reg = <1>;
++			};
++		};
++	};
++
++	leds {
++		compatible = "gpio-leds";
++		pinctrl-names = "default";
++		pinctrl-0 = <&led_pins_bananapi>;
++
++		green {
++			label = "bananapi:green:usr";
++			gpios = <&pio 7 24 0>;
++		};
++	};
++
++	reg_usb1_vbus: usb1-vbus {
++		status = "okay";
++	};
++
++	reg_usb2_vbus: usb2-vbus {
++		status = "okay";
++	};
++
++	reg_gmac_3v3: gmac-3v3 {
++		compatible = "regulator-fixed";
++		pinctrl-names = "default";
++		pinctrl-0 = <&gmac_power_pin_bananapi>;
++		regulator-name = "gmac-3v3";
++		regulator-min-microvolt = <3300000>;
++		regulator-max-microvolt = <3300000>;
++		startup-delay-us = <50000>;
++		enable-active-high;
++		gpio = <&pio 7 23 0>;
++	};
++};