path: root/recipes-kernel/linux/linux-toradex-mainline-4.14/0012-apalis-tk1-support-for-k20-mfd.patch

From 55301c43044ec23e14509a5515a868b7ae995aa1 Mon Sep 17 00:00:00 2001
Message-Id: <55301c43044ec23e14509a5515a868b7ae995aa1.1531317141.git.marcel.ziswiler@toradex.com>
In-Reply-To: <6654e1bd342708a683daf47e7558455f709a3e7e.1531317141.git.marcel.ziswiler@toradex.com>
References: <6654e1bd342708a683daf47e7558455f709a3e7e.1531317141.git.marcel.ziswiler@toradex.com>
From: Dominik Sliwa <dominik.sliwa@toradex.com>
Date: Wed, 18 Apr 2018 12:22:26 +0200
Subject: [PATCH 12/33] apalis-tk1: support for k20 mfd

Signed-off-by: Dominik Sliwa <dominik.sliwa@toradex.com>
Acked-by: Marcel Ziswiler <marcel.ziswiler@toradex.com>
---
 arch/arm/boot/dts/tegra124-apalis-v1.2.dtsi   |   28 +
 arch/arm/configs/tegra_defconfig              |    7 +
 drivers/gpio/Kconfig                          |    6 +
 drivers/gpio/Makefile                         |    1 +
 drivers/gpio/gpio-apalis-tk1-k20.c            |  221 +++++
 drivers/iio/adc/Kconfig                       |    6 +
 drivers/iio/adc/Makefile                      |    1 +
 drivers/iio/adc/apalis-tk1-k20_adc.c          |  200 +++++
 drivers/input/touchscreen/Kconfig             |   10 +
 drivers/input/touchscreen/Makefile            |    1 +
 drivers/input/touchscreen/apalis-tk1-k20_ts.c |  234 ++++++
 drivers/mfd/Kconfig                           |   14 +
 drivers/mfd/Makefile                          |    1 +
 drivers/mfd/apalis-tk1-k20-ezp.h              |   47 ++
 drivers/mfd/apalis-tk1-k20.c                  | 1062 +++++++++++++++++++++++++
 drivers/net/can/Kconfig                       |    6 +
 drivers/net/can/Makefile                      |    1 +
 drivers/net/can/apalis-tk1-k20-can.c          |  817 +++++++++++++++++++
 drivers/spi/spi-tegra114.c                    |    7 +-
 include/linux/mfd/apalis-tk1-k20-api.h        |  123 +++
 include/linux/mfd/apalis-tk1-k20.h            |  114 +++
 21 files changed, 2901 insertions(+), 6 deletions(-)
 create mode 100644 drivers/gpio/gpio-apalis-tk1-k20.c
 create mode 100644 drivers/iio/adc/apalis-tk1-k20_adc.c
 create mode 100644 drivers/input/touchscreen/apalis-tk1-k20_ts.c
 create mode 100644 drivers/mfd/apalis-tk1-k20-ezp.h
 create mode 100644 drivers/mfd/apalis-tk1-k20.c
 create mode 100644 drivers/net/can/apalis-tk1-k20-can.c
 create mode 100644 include/linux/mfd/apalis-tk1-k20-api.h
 create mode 100644 include/linux/mfd/apalis-tk1-k20.h

diff --git a/arch/arm/boot/dts/tegra124-apalis-v1.2.dtsi b/arch/arm/boot/dts/tegra124-apalis-v1.2.dtsi
index bb67edb016c5..93cf49c10954 100644
--- a/arch/arm/boot/dts/tegra124-apalis-v1.2.dtsi
+++ b/arch/arm/boot/dts/tegra124-apalis-v1.2.dtsi
@@ -1756,6 +1756,34 @@
 	spi@7000d600 {
 		status = "okay";
 		spi-max-frequency = <25000000>;
+
+		k20mcu: apalis-tk1-k20@1 {
+			compatible = "toradex,apalis-tk1-k20";
+			reg = <1>;
+			spi-max-frequency = <6120000>;
+			interrupt-parent =<&gpio>;
+			interrupts = <TEGRA_GPIO(K, 2) (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING)>,
+							<TEGRA_GPIO(I, 5) (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING)>, /* INT3 CAN0 */
+							<TEGRA_GPIO(J, 0) (IRQ_TYPE_EDGE_FALLING  | IRQ_TYPE_EDGE_RISING)>; /* INT4 CAN1 */
+			rst-gpio = <&gpio TEGRA_GPIO(BB, 6) GPIO_ACTIVE_HIGH>;
+
+			/* GPIO based CS used to enter K20 EzPort mode */
+			ezport-cs-gpio = <&gpio TEGRA_GPIO(W, 2) GPIO_ACTIVE_HIGH>;
+			/* extra INT lines between K20 and TK1 */
+			int2-gpio = <&gpio TEGRA_GPIO(J, 2) GPIO_ACTIVE_HIGH>;
+
+			toradex,apalis-tk1-k20-uses-adc;
+			toradex,apalis-tk1-k20-uses-can;
+			toradex,apalis-tk1-k20-uses-gpio;
+			toradex,apalis-tk1-k20-uses-tsc;
+
+			controller-data {
+				nvidia,enable-hw-based-cs;
+				nvidia,cs-setup-clk-count = <1>;
+				nvidia,cs-hold-clk-count = <1>;
+			};
+		};
+
 	};
 
 	pmc@7000e400 {
diff --git a/arch/arm/configs/tegra_defconfig b/arch/arm/configs/tegra_defconfig
index cfe997c617fc..e8c9bdafa1b9 100644
--- a/arch/arm/configs/tegra_defconfig
+++ b/arch/arm/configs/tegra_defconfig
@@ -63,6 +63,7 @@ CONFIG_IPV6_MIP6=y
 CONFIG_IPV6_TUNNEL=y
 CONFIG_IPV6_MULTIPLE_TABLES=y
 CONFIG_CAN=y
+CONFIG_CAN_APALIS_TK1_K20=m
 CONFIG_CAN_MCP251X=y
 CONFIG_BT=y
 CONFIG_BT_RFCOMM=y
@@ -126,6 +127,7 @@ CONFIG_KEYBOARD_TEGRA=y
 CONFIG_KEYBOARD_CROS_EC=y
 CONFIG_MOUSE_PS2_ELANTECH=y
 CONFIG_INPUT_TOUCHSCREEN=y
+CONFIG_TOUCHSCREEN_APALIS_TK1_K20=m
 CONFIG_TOUCHSCREEN_ATMEL_MXT=y
 CONFIG_TOUCHSCREEN_WM97XX=y
 # CONFIG_TOUCHSCREEN_WM9705 is not set
@@ -155,6 +157,7 @@ CONFIG_GPIO_PCA953X_IRQ=y
 CONFIG_GPIO_PALMAS=y
 CONFIG_GPIO_TPS6586X=y
 CONFIG_GPIO_TPS65910=y
+CONFIG_GPIO_APALIS_TK1_K20=m
 CONFIG_POWER_RESET=y
 CONFIG_POWER_RESET_AS3722=y
 CONFIG_POWER_RESET_GPIO=y
@@ -165,6 +168,8 @@ CONFIG_SENSORS_LM95245=y
 CONFIG_WATCHDOG=y
 CONFIG_TEGRA_WATCHDOG=y
 CONFIG_MFD_AS3722=y
+CONFIG_MFD_APALIS_TK1_K20=m
+CONFIG_APALIS_TK1_K20_EZP=y
 CONFIG_MFD_CROS_EC=y
 CONFIG_MFD_CROS_EC_SPI=y
 CONFIG_MFD_MAX8907=y
@@ -276,6 +281,7 @@ CONFIG_ARCH_TEGRA_114_SOC=y
 CONFIG_ARCH_TEGRA_124_SOC=y
 CONFIG_MEMORY=y
 CONFIG_IIO=y
+CONFIG_APALIS_TK1_K20_ADC=m
 CONFIG_MPU3050_I2C=y
 CONFIG_SENSORS_ISL29018=y
 CONFIG_SENSORS_ISL29028=y
@@ -309,6 +315,7 @@ CONFIG_ROOT_NFS=y
 CONFIG_NLS_CODEPAGE_437=y
 CONFIG_NLS_ISO8859_1=y
 CONFIG_PRINTK_TIME=y
+CONFIG_DYNAMIC_DEBUG=y
 CONFIG_DEBUG_INFO=y
 CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_SLAB=y
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 3f80f167ed56..c5b006c10d37 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -1248,6 +1248,12 @@ endmenu
 menu "SPI GPIO expanders"
 	depends on SPI_MASTER
 
+config GPIO_APALIS_TK1_K20
+	tristate "GPIOs of K20 MCU on Apalis TK1"
+	depends on MFD_APALIS_TK1_K20
+	help
+	  This enables support for GPIOs of K20 MCU found on Apalis TK1.
+
 config GPIO_74X164
 	tristate "74x164 serial-in/parallel-out 8-bits shift register"
 	depends on OF_GPIO
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 8a2dfba3b231..8ea42ecdf87e 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -29,6 +29,7 @@ obj-$(CONFIG_GPIO_ALTERA)  	+= gpio-altera.o
 obj-$(CONFIG_GPIO_ALTERA_A10SR)	+= gpio-altera-a10sr.o
 obj-$(CONFIG_GPIO_AMD8111)	+= gpio-amd8111.o
 obj-$(CONFIG_GPIO_AMDPT)	+= gpio-amdpt.o
+obj-$(CONFIG_GPIO_APALIS_TK1_K20)	+= gpio-apalis-tk1-k20.o
 obj-$(CONFIG_GPIO_ARIZONA)	+= gpio-arizona.o
 obj-$(CONFIG_GPIO_ATH79)	+= gpio-ath79.o
 obj-$(CONFIG_GPIO_ASPEED)	+= gpio-aspeed.o
diff --git a/drivers/gpio/gpio-apalis-tk1-k20.c b/drivers/gpio/gpio-apalis-tk1-k20.c
new file mode 100644
index 000000000000..7b44f93df85b
--- /dev/null
+++ b/drivers/gpio/gpio-apalis-tk1-k20.c
@@ -0,0 +1,221 @@
+/*
+ * Copyright 2016-2017 Toradex AG
+ * Dominik Sliwa <dominik.sliwa@toradex.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License version 2 as published by the
+ * Free Software Foundation.
+ */
+
+#include <linux/mfd/apalis-tk1-k20.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+
+struct apalis_tk1_k20_gpio {
+	struct gpio_chip chip;
+	struct apalis_tk1_k20_regmap *apalis_tk1_k20;
+};
+
+static int apalis_tk1_k20_gpio_input(struct gpio_chip *chip,
+				     unsigned int offset)
+{
+	struct apalis_tk1_k20_gpio *gpio = container_of(chip,
+			struct apalis_tk1_k20_gpio, chip);
+
+	apalis_tk1_k20_lock(gpio->apalis_tk1_k20);
+
+	apalis_tk1_k20_reg_write(gpio->apalis_tk1_k20, APALIS_TK1_K20_GPIO_NO,
+			offset);
+	apalis_tk1_k20_reg_write(gpio->apalis_tk1_k20, APALIS_TK1_K20_GPIO_STA,
+			0);
+
+	apalis_tk1_k20_unlock(gpio->apalis_tk1_k20);
+
+	return 0;
+}
+
+static int apalis_tk1_k20_gpio_output(struct gpio_chip *chip,
+				      unsigned int offset,
+				      int value)
+{
+	struct apalis_tk1_k20_gpio *gpio = container_of(chip,
+			struct apalis_tk1_k20_gpio, chip);
+	int status;
+
+	apalis_tk1_k20_lock(gpio->apalis_tk1_k20);
+
+	apalis_tk1_k20_reg_write(gpio->apalis_tk1_k20, APALIS_TK1_K20_GPIO_NO,
+			offset);
+	status = APALIS_TK1_K20_GPIO_STA_OE;
+	status += value ? APALIS_TK1_K20_GPIO_STA_VAL : 0;
+	apalis_tk1_k20_reg_write(gpio->apalis_tk1_k20, APALIS_TK1_K20_GPIO_STA,
+			status);
+
+	apalis_tk1_k20_unlock(gpio->apalis_tk1_k20);
+
+	return 0;
+}
+
+static int apalis_tk1_k20_gpio_get(struct gpio_chip *chip, unsigned int offset)
+{
+	struct apalis_tk1_k20_gpio *gpio = container_of(chip,
+			struct apalis_tk1_k20_gpio, chip);
+	int value;
+
+	apalis_tk1_k20_lock(gpio->apalis_tk1_k20);
+
+	apalis_tk1_k20_reg_write(gpio->apalis_tk1_k20, APALIS_TK1_K20_GPIO_NO,
+			offset);
+	if (apalis_tk1_k20_reg_read(gpio->apalis_tk1_k20,
+			APALIS_TK1_K20_GPIO_STA, &value) < 0) {
+		apalis_tk1_k20_unlock(gpio->apalis_tk1_k20);
+		return -ENODEV;
+	}
+	value &= APALIS_TK1_K20_GPIO_STA_VAL;
+
+	apalis_tk1_k20_unlock(gpio->apalis_tk1_k20);
+
+	return value ? 1 : 0;
+}
+
+static int apalis_tk1_k20_gpio_request(struct gpio_chip *chip,
+				       unsigned int offset)
+{
+	struct apalis_tk1_k20_gpio *gpio = container_of(chip,
+			struct apalis_tk1_k20_gpio, chip);
+	int status = 0;
+
+	dev_dbg(gpio->apalis_tk1_k20->dev, "APALIS TK1 K20 GPIO %d\n",
+		offset);
+
+	apalis_tk1_k20_lock(gpio->apalis_tk1_k20);
+
+	apalis_tk1_k20_reg_write(gpio->apalis_tk1_k20, APALIS_TK1_K20_GPIO_NO,
+			offset);
+	if (apalis_tk1_k20_reg_read(gpio->apalis_tk1_k20,
+			APALIS_TK1_K20_GPIO_NO, &status) < 0) {
+		apalis_tk1_k20_unlock(gpio->apalis_tk1_k20);
+		return -ENODEV;
+	}
+
+	apalis_tk1_k20_unlock(gpio->apalis_tk1_k20);
+
+	return status;
+}
+
+static void apalis_tk1_k20_gpio_free(struct gpio_chip *chip,
+				     unsigned int offset)
+{
+	struct apalis_tk1_k20_gpio *gpio =
+			container_of(chip, struct apalis_tk1_k20_gpio, chip);
+
+	apalis_tk1_k20_lock(gpio->apalis_tk1_k20);
+
+	apalis_tk1_k20_reg_write(gpio->apalis_tk1_k20, APALIS_TK1_K20_GPIO_NO,
+			offset);
+	apalis_tk1_k20_reg_write(gpio->apalis_tk1_k20,
+			APALIS_TK1_K20_GPIO_STA, 0);
+
+	apalis_tk1_k20_unlock(gpio->apalis_tk1_k20);
+}
+
+
+static void apalis_tk1_k20_gpio_set(struct gpio_chip *chip, unsigned int offset,
+		int value)
+{
+	struct apalis_tk1_k20_gpio *gpio = container_of(chip,
+			struct apalis_tk1_k20_gpio, chip);
+	int status;
+
+	apalis_tk1_k20_lock(gpio->apalis_tk1_k20);
+
+	apalis_tk1_k20_reg_write(gpio->apalis_tk1_k20, APALIS_TK1_K20_GPIO_NO,
+			offset);
+	if (apalis_tk1_k20_reg_read(gpio->apalis_tk1_k20,
+			APALIS_TK1_K20_GPIO_STA, &status) < 0) {
+		apalis_tk1_k20_unlock(gpio->apalis_tk1_k20);
+		return;
+	}
+
+	status &= ~APALIS_TK1_K20_GPIO_STA_VAL;
+	status += value ? APALIS_TK1_K20_GPIO_STA_VAL : 0;
+	apalis_tk1_k20_reg_write(gpio->apalis_tk1_k20, APALIS_TK1_K20_GPIO_STA,
+			status);
+
+	apalis_tk1_k20_unlock(gpio->apalis_tk1_k20);
+}
+
+static int apalis_tk1_k20_gpio_probe(struct platform_device *pdev)
+{
+	struct apalis_tk1_k20_gpio *priv;
+	struct apalis_tk1_k20_regmap *apalis_tk1_k20;
+	int status;
+
+	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+	if (!priv)
+		return -ENOMEM;
+
+	apalis_tk1_k20 = dev_get_drvdata(pdev->dev.parent);
+	if (!apalis_tk1_k20)
+		return -ENODEV;
+	priv->apalis_tk1_k20 = apalis_tk1_k20;
+
+	platform_set_drvdata(pdev, priv);
+
+	apalis_tk1_k20_lock(apalis_tk1_k20);
+
+	/* TBD: some code */
+
+	apalis_tk1_k20_unlock(apalis_tk1_k20);
+
+	priv->chip.base			= -1;
+	priv->chip.can_sleep		= 1;
+	priv->chip.parent			= &pdev->dev;
+	priv->chip.owner		= THIS_MODULE;
+	priv->chip.get			= apalis_tk1_k20_gpio_get;
+	priv->chip.set			= apalis_tk1_k20_gpio_set;
+	priv->chip.direction_input	= apalis_tk1_k20_gpio_input;
+	priv->chip.direction_output	= apalis_tk1_k20_gpio_output;
+	priv->chip.request		= apalis_tk1_k20_gpio_request;
+	priv->chip.free			= apalis_tk1_k20_gpio_free;
+	/* TODO: include as a define somewhere */
+	priv->chip.ngpio		= 160;
+
+	status = gpiochip_add(&priv->chip);
+
+	return status;
+}
+
+static int apalis_tk1_k20_gpio_remove(struct platform_device *pdev)
+{
+	struct apalis_tk1_k20_gpio *priv = platform_get_drvdata(pdev);
+
+	gpiochip_remove(&priv->chip);
+	return 0;
+}
+
+static const struct platform_device_id apalis_tk1_k20_gpio_idtable[] = {
+	{
+		.name = "apalis-tk1-k20-gpio",
+	},
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(platform, apalis_tk1_k20_gpio_idtable);
+
+static struct platform_driver apalis_tk1_k20_gpio_driver = {
+	.id_table = apalis_tk1_k20_gpio_idtable,
+	.remove = apalis_tk1_k20_gpio_remove,
+	.probe = apalis_tk1_k20_gpio_probe,
+	.driver = {
+		.name = "apalis-tk1-k20-gpio",
+	},
+};
+
+module_platform_driver(apalis_tk1_k20_gpio_driver);
+
+MODULE_DESCRIPTION("GPIO driver for K20 MCU on Apalis TK1");
+MODULE_AUTHOR("Dominik Sliwa <dominik.sliwa@toradex.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig
index 369a2c632e46..d4ec5fad1467 100644
--- a/drivers/iio/adc/Kconfig
+++ b/drivers/iio/adc/Kconfig
@@ -116,6 +116,12 @@ config AD7923
 	  To compile this driver as a module, choose M here: the
 	  module will be called ad7923.
 
+config APALIS_TK1_K20_ADC
+	tristate "ADCs of K20 MCU on Apalis TK1"
+	depends on MFD_APALIS_TK1_K20
+	help
+	  This enables support for ADCs of K20 MCU found on Apalis TK1.
+
 config AD799X
 	tristate "Analog Devices AD799x ADC driver"
 	depends on I2C
diff --git a/drivers/iio/adc/Makefile b/drivers/iio/adc/Makefile
index 9572c1090f35..5f761384b305 100644
--- a/drivers/iio/adc/Makefile
+++ b/drivers/iio/adc/Makefile
@@ -16,6 +16,7 @@ obj-$(CONFIG_AD7793) += ad7793.o
 obj-$(CONFIG_AD7887) += ad7887.o
 obj-$(CONFIG_AD799X) += ad799x.o
 obj-$(CONFIG_ASPEED_ADC) += aspeed_adc.o
+obj-$(CONFIG_APALIS_TK1_K20_ADC) += apalis-tk1-k20_adc.o
 obj-$(CONFIG_AT91_ADC) += at91_adc.o
 obj-$(CONFIG_AT91_SAMA5D2_ADC) += at91-sama5d2_adc.o
 obj-$(CONFIG_AXP20X_ADC) += axp20x_adc.o
diff --git a/drivers/iio/adc/apalis-tk1-k20_adc.c b/drivers/iio/adc/apalis-tk1-k20_adc.c
new file mode 100644
index 000000000000..b45e51df5c81
--- /dev/null
+++ b/drivers/iio/adc/apalis-tk1-k20_adc.c
@@ -0,0 +1,200 @@
+/*
+ * Copyright 2016-2017 Toradex AG
+ * Dominik Sliwa <dominik.sliwa@toradex.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License version 2 as published by the
+ * Free Software Foundation.
+ */
+
+#include <linux/mfd/apalis-tk1-k20.h>
+#include <linux/delay.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/driver.h>
+#include <linux/iio/machine.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+struct apalis_tk1_k20_adc {
+	struct iio_dev chip;
+	struct apalis_tk1_k20_regmap *apalis_tk1_k20;
+};
+
+static int apalis_tk1_k20_get_adc_result(struct apalis_tk1_k20_adc *adc, int id,
+		int *val)
+{
+	uint8_t adc_read[2];
+	int adc_register;
+
+	switch (id) {
+	case APALIS_TK1_K20_ADC1:
+		adc_register = APALIS_TK1_K20_ADC_CH0L;
+		break;
+	case APALIS_TK1_K20_ADC2:
+		adc_register = APALIS_TK1_K20_ADC_CH1L;
+		break;
+	case APALIS_TK1_K20_ADC3:
+		adc_register = APALIS_TK1_K20_ADC_CH2L;
+		break;
+	case APALIS_TK1_K20_ADC4:
+		adc_register = APALIS_TK1_K20_ADC_CH3L;
+		break;
+	default:
+		return -ENODEV;
+	}
+
+	apalis_tk1_k20_lock(adc->apalis_tk1_k20);
+
+	if (apalis_tk1_k20_reg_read_bulk(adc->apalis_tk1_k20, adc_register,
+			adc_read, 2) < 0) {
+		apalis_tk1_k20_unlock(adc->apalis_tk1_k20);
+		return -EIO;
+	}
+	*val = (adc_read[1] << 8) + adc_read[0];
+
+	apalis_tk1_k20_unlock(adc->apalis_tk1_k20);
+
+	return 0;
+}
+
+static int apalis_tk1_k20_adc_read_raw(struct iio_dev *indio_dev,
+			struct iio_chan_spec const *chan,
+			int *val, int *val2, long mask)
+{
+	struct apalis_tk1_k20_adc *adc = iio_priv(indio_dev);
+	enum apalis_tk1_k20_adc_id id = chan->channel;
+	int ret;
+
+	switch (mask) {
+	case IIO_CHAN_INFO_RAW:
+		ret = apalis_tk1_k20_get_adc_result(adc, id, val) ?
+				-EIO : IIO_VAL_INT;
+		break;
+	case IIO_CHAN_INFO_SCALE:
+		*val = APALIS_TK1_K20_VADC_MILI;
+		*val2 = APALIS_TK1_K20_ADC_BITS;
+		ret = IIO_VAL_FRACTIONAL_LOG2;
+		break;
+	default:
+		ret = -EINVAL;
+		break;
+	}
+
+	return ret;
+}
+
+static const struct iio_info apalis_tk1_k20_adc_info = {
+	.read_raw = &apalis_tk1_k20_adc_read_raw,
+	.driver_module = THIS_MODULE,
+};
+
+#define APALIS_TK1_K20_CHAN(_id, _type) {			\
+		.type = _type,					\
+		.indexed = 1,					\
+		.channel = APALIS_TK1_K20_##_id,		\
+		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |	\
+				      BIT(IIO_CHAN_INFO_SCALE),	\
+		.datasheet_name = #_id,				\
+}
+
+static const struct iio_chan_spec apalis_tk1_k20_adc_channels[] = {
+	[APALIS_TK1_K20_ADC1] = APALIS_TK1_K20_CHAN(ADC1, IIO_VOLTAGE),
+	[APALIS_TK1_K20_ADC2] = APALIS_TK1_K20_CHAN(ADC2, IIO_VOLTAGE),
+	[APALIS_TK1_K20_ADC3] = APALIS_TK1_K20_CHAN(ADC3, IIO_VOLTAGE),
+	[APALIS_TK1_K20_ADC4] = APALIS_TK1_K20_CHAN(ADC4, IIO_VOLTAGE),
+};
+
+
+static int apalis_tk1_k20_adc_probe(struct platform_device *pdev)
+{
+	struct apalis_tk1_k20_adc *priv;
+	struct apalis_tk1_k20_regmap *apalis_tk1_k20;
+	struct iio_dev *indio_dev;
+	int ret;
+
+	indio_dev = iio_device_alloc(sizeof(*priv));
+	if (!indio_dev)
+		return -ENOMEM;
+
+	apalis_tk1_k20 = dev_get_drvdata(pdev->dev.parent);
+	if (!apalis_tk1_k20) {
+		ret = -ENODEV;
+		goto err_iio_device;
+	}
+
+	priv = iio_priv(indio_dev);
+	priv->apalis_tk1_k20 = apalis_tk1_k20;
+
+	apalis_tk1_k20_lock(apalis_tk1_k20);
+
+	/* Enable ADC */
+	apalis_tk1_k20_reg_write(apalis_tk1_k20, APALIS_TK1_K20_ADCREG, 0x01);
+
+	apalis_tk1_k20_unlock(apalis_tk1_k20);
+
+	platform_set_drvdata(pdev, indio_dev);
+
+	indio_dev->dev.of_node	= pdev->dev.of_node;
+	indio_dev->dev.parent	= &pdev->dev;
+	indio_dev->name		= pdev->name;
+	indio_dev->modes	= INDIO_DIRECT_MODE;
+	indio_dev->info		= &apalis_tk1_k20_adc_info;
+	indio_dev->channels	= apalis_tk1_k20_adc_channels;
+	indio_dev->num_channels	= ARRAY_SIZE(apalis_tk1_k20_adc_channels);
+
+	ret = iio_device_register(indio_dev);
+	if (ret) {
+		dev_err(&pdev->dev, "iio dev register err: %d\n", ret);
+		goto err_iio_device;
+	}
+
+	return 0;
+
+err_iio_device:
+	iio_device_free(indio_dev);
+	return ret;
+}
+
+static int apalis_tk1_k20_adc_remove(struct platform_device *pdev)
+{
+	struct iio_dev *indio_dev = platform_get_drvdata(pdev);
+	struct apalis_tk1_k20_regmap *apalis_tk1_k20 = dev_get_drvdata(
+			pdev->dev.parent);
+
+	apalis_tk1_k20_lock(apalis_tk1_k20);
+
+	/* Disable ADC */
+	apalis_tk1_k20_reg_write(apalis_tk1_k20, APALIS_TK1_K20_ADCREG, 0x00);
+
+	apalis_tk1_k20_unlock(apalis_tk1_k20);
+
+	iio_device_unregister(indio_dev);
+	iio_device_free(indio_dev);
+
+	return 0;
+}
+
+static const struct platform_device_id apalis_tk1_k20_adc_idtable[] = {
+	{
+		.name = "apalis-tk1-k20-adc",
+	},
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(platform, apalis_tk1_k20_adc_idtable);
+
+static struct platform_driver apalis_tk1_k20_adc_driver = {
+	.id_table = apalis_tk1_k20_adc_idtable,
+	.remove = apalis_tk1_k20_adc_remove,
+	.probe = apalis_tk1_k20_adc_probe,
+	.driver = {
+		.name = "apalis-tk1-k20-adc",
+	},
+};
+
+module_platform_driver(apalis_tk1_k20_adc_driver);
+
+MODULE_DESCRIPTION("K20 ADCs on Apalis TK1");
+MODULE_AUTHOR("Dominik Sliwa");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 64b30fe273fd..81e9c604f612 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -92,6 +92,16 @@ config TOUCHSCREEN_AD7879_SPI
 	  To compile this driver as a module, choose M here: the
 	  module will be called ad7879-spi.
 
+config TOUCHSCREEN_APALIS_TK1_K20
+	tristate "K20 based touchscreen controller on Apalis TK1"
+	depends on MFD_APALIS_TK1_K20
+	help
+	  Say Y here if you want to support the touchscreen controller
+	  implemented in the K20 found on Apalis TK1.
+
+	  To compile this driver as a module, choose M here: the module will be
+	  called apalis-tk1-k20_ts.
+
 config TOUCHSCREEN_AR1021_I2C
 	tristate "Microchip AR1020/1021 i2c touchscreen"
 	depends on I2C && OF
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 850c1562555a..d9352ec30431 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_TOUCHSCREEN_AD7879)	+= ad7879.o
 obj-$(CONFIG_TOUCHSCREEN_AD7879_I2C)	+= ad7879-i2c.o
 obj-$(CONFIG_TOUCHSCREEN_AD7879_SPI)	+= ad7879-spi.o
 obj-$(CONFIG_TOUCHSCREEN_ADS7846)	+= ads7846.o
+obj-$(CONFIG_TOUCHSCREEN_APALIS_TK1_K20)	+= apalis-tk1-k20_ts.o
 obj-$(CONFIG_TOUCHSCREEN_AR1021_I2C)	+= ar1021_i2c.o
 obj-$(CONFIG_TOUCHSCREEN_ATMEL_MXT)	+= atmel_mxt_ts.o
 obj-$(CONFIG_TOUCHSCREEN_AUO_PIXCIR)	+= auo-pixcir-ts.o
diff --git a/drivers/input/touchscreen/apalis-tk1-k20_ts.c b/drivers/input/touchscreen/apalis-tk1-k20_ts.c
new file mode 100644
index 000000000000..ef9e56c94685
--- /dev/null
+++ b/drivers/input/touchscreen/apalis-tk1-k20_ts.c
@@ -0,0 +1,234 @@
+/*
+ * Copyright 2016-2017 Toradex AG
+ * Dominik Sliwa <dominik.sliwa@toradex.com>
+ *
+ * Based on driver for the Freescale Semiconductor MC13783 touchscreen by:
+ * Copyright 2004-2007 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright (C) 2009 Sascha Hauer, Pengutronix
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/mfd/apalis-tk1-k20.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/input.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+
+#define APALIS_TK1_K20_TS_NAME	"apalis-tk1-k20-ts"
+
+struct apalis_tk1_k20_ts {
+	struct input_dev *idev;
+	struct apalis_tk1_k20_regmap *apalis_tk1_k20;
+	struct delayed_work work;
+	struct workqueue_struct *workq;
+	uint16_t sample[4];
+};
+
+static irqreturn_t apalis_tk1_k20_ts_handler(int irq, void *data)
+{
+	struct apalis_tk1_k20_ts *priv = data;
+
+	/*
+	 * Kick off reading coordinates. Note that if work happens already
+	 * be queued for future execution (it rearms itself) it will not
+	 * be rescheduled for immediate execution here. However the rearm
+	 * delay is HZ / 25 which is acceptable.
+	 */
+	queue_delayed_work(priv->workq, &priv->work, 0);
+
+	return IRQ_HANDLED;
+}
+
+static void apalis_tk1_k20_ts_report_sample(struct apalis_tk1_k20_ts *priv)
+{
+	struct input_dev *idev = priv->idev;
+	int xp, xm, yp, ym;
+	int x, y, press, btn;
+
+	xp = priv->sample[1];
+	xm = priv->sample[0];
+	yp = priv->sample[3];
+	ym = priv->sample[2];
+
+	x = (xp + xm) / 2;
+	y = (yp + ym) / 2;
+	press = (abs(yp - ym) + abs(xp - xm)) / 2;
+
+	if ((yp != 0) && (xp != 0)) {
+		btn = 1;
+		input_report_abs(idev, ABS_X, x);
+		input_report_abs(idev, ABS_Y, y);
+
+		dev_dbg(&idev->dev, "report (%d, %d, %d)\n",
+				x, y, press);
+		queue_delayed_work(priv->workq, &priv->work, HZ / 25);
+	} else {
+		dev_dbg(&idev->dev, "report release\n");
+		btn = 0;
+	}
+
+	input_report_abs(idev, ABS_PRESSURE, press);
+	input_report_key(idev, BTN_TOUCH, btn);
+	input_sync(idev);
+}
+
+static void apalis_tk1_k20_ts_work(struct work_struct *work)
+{
+	struct apalis_tk1_k20_ts *priv =
+		container_of(work, struct apalis_tk1_k20_ts, work.work);
+	uint8_t buf[8], i;
+
+	apalis_tk1_k20_lock(priv->apalis_tk1_k20);
+
+	if (apalis_tk1_k20_reg_read_bulk(priv->apalis_tk1_k20,
+			APALIS_TK1_K20_TSC_XML, buf, 8) < 0) {
+		apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+		dev_err(&priv->idev->dev, "Error reading data\n");
+		return;
+	}
+
+	apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+
+	for (i = 0; i < 4; i++)
+		priv->sample[i] = (buf[(2 * i) + 1] << 8) + buf[2 * i];
+
+	apalis_tk1_k20_ts_report_sample(priv);
+}
+
+static int apalis_tk1_k20_ts_open(struct input_dev *dev)
+{
+	struct apalis_tk1_k20_ts *priv = input_get_drvdata(dev);
+	int ret;
+
+	apalis_tk1_k20_lock(priv->apalis_tk1_k20);
+
+	ret = apalis_tk1_k20_irq_request(priv->apalis_tk1_k20,
+			APALIS_TK1_K20_TSC_IRQ, apalis_tk1_k20_ts_handler,
+			APALIS_TK1_K20_TS_NAME, priv);
+	if (ret)
+		goto out;
+
+	ret = apalis_tk1_k20_reg_rmw(priv->apalis_tk1_k20,
+			APALIS_TK1_K20_TSCREG, APALIS_TK1_K20_TSC_ENA_MASK,
+			APALIS_TK1_K20_TSC_ENA);
+	if (ret)
+		apalis_tk1_k20_irq_free(priv->apalis_tk1_k20,
+				APALIS_TK1_K20_TSC_IRQ, priv);
+
+out:
+	apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+
+	return ret;
+}
+
+static void apalis_tk1_k20_ts_close(struct input_dev *dev)
+{
+	struct apalis_tk1_k20_ts *priv = input_get_drvdata(dev);
+
+	apalis_tk1_k20_lock(priv->apalis_tk1_k20);
+
+	apalis_tk1_k20_reg_rmw(priv->apalis_tk1_k20, APALIS_TK1_K20_TSCREG,
+			APALIS_TK1_K20_TSC_ENA_MASK, 0);
+	apalis_tk1_k20_irq_free(priv->apalis_tk1_k20, APALIS_TK1_K20_TSC_IRQ,
+			priv);
+
+	apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+
+	cancel_delayed_work_sync(&priv->work);
+}
+
+static int apalis_tk1_k20_ts_probe(struct platform_device *pdev)
+{
+	struct apalis_tk1_k20_ts *priv;
+	struct input_dev *idev;
+	int ret = -ENOMEM;
+
+	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+	idev = input_allocate_device();
+	if (!priv || !idev)
+		goto err_free_mem;
+
+	INIT_DELAYED_WORK(&priv->work, apalis_tk1_k20_ts_work);
+
+	priv->apalis_tk1_k20 = dev_get_drvdata(pdev->dev.parent);
+	priv->idev = idev;
+
+	priv->workq = create_singlethread_workqueue("apalis_tk1_k20_ts");
+	if (!priv->workq)
+		goto err_free_mem;
+
+	idev->name = APALIS_TK1_K20_TS_NAME;
+	idev->dev.parent = &pdev->dev;
+
+	idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+	idev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+	input_set_abs_params(idev, ABS_X, 0, 0xfff, 0, 0);
+	input_set_abs_params(idev, ABS_Y, 0, 0xfff, 0, 0);
+	input_set_abs_params(idev, ABS_PRESSURE, 0, 0xfff, 0, 0);
+
+	idev->open = apalis_tk1_k20_ts_open;
+	idev->close = apalis_tk1_k20_ts_close;
+
+	input_set_drvdata(idev, priv);
+
+	ret = input_register_device(priv->idev);
+	if (ret) {
+		dev_err(&pdev->dev,
+			"register input device failed with %d\n", ret);
+		goto err_destroy_wq;
+	}
+
+	platform_set_drvdata(pdev, priv);
+
+	return 0;
+
+err_destroy_wq:
+	destroy_workqueue(priv->workq);
+err_free_mem:
+	input_free_device(idev);
+	kfree(priv);
+
+	return ret;
+}
+
+static int apalis_tk1_k20_ts_remove(struct platform_device *pdev)
+{
+	struct apalis_tk1_k20_ts *priv = platform_get_drvdata(pdev);
+
+	platform_set_drvdata(pdev, NULL);
+
+	destroy_workqueue(priv->workq);
+	input_unregister_device(priv->idev);
+	kfree(priv);
+
+	return 0;
+}
+
+static const struct platform_device_id apalis_tk1_k20_ts_idtable[] = {
+	{
+		.name = "apalis-tk1-k20-ts",
+	},
+	{ /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(platform, apalis_tk1_k20_ts_idtable);
+
+static struct platform_driver apalis_tk1_k20_ts_driver = {
+	.id_table = apalis_tk1_k20_ts_idtable,
+	.probe = apalis_tk1_k20_ts_probe,
+	.remove = apalis_tk1_k20_ts_remove,
+	.driver		= {
+		.name	= APALIS_TK1_K20_TS_NAME,
+	},
+};
+
+module_platform_driver(apalis_tk1_k20_ts_driver);
+
+MODULE_DESCRIPTION("K20 touchscreen controller on Apalis TK1");
+MODULE_AUTHOR("Dominik Sliwa <dominik.sliwa@toradex.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index fc5e4fef89d2..cd0a1dfd0a63 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -190,6 +190,20 @@ config MFD_AXP20X_RSB
 	  components like regulators or the PEK (Power Enable Key) under the
 	  corresponding menus.
 
+config MFD_APALIS_TK1_K20
+	tristate "K20 on Apalis TK1"
+	depends on SPI_MASTER
+	select MFD_CORE
+	help
+	  The Kinetis MK20DN512 companion micro controller found on Apalis TK1
+	  supports CAN, resistive touch, GPIOs and analog inputs.
+
+config APALIS_TK1_K20_EZP
+	bool "K20 on Apalis TK1 programming via EZ Port"
+	depends on MFD_APALIS_TK1_K20
+	help
+		Support for flashing new K20 firmware using EZ-Port functionality.
+
 config MFD_CROS_EC
 	tristate "ChromeOS Embedded Controller"
 	select MFD_CORE
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 8703ff17998e..ba4f60862f9f 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_MFD_88PM800)	+= 88pm800.o 88pm80x.o
 obj-$(CONFIG_MFD_88PM805)	+= 88pm805.o 88pm80x.o
 obj-$(CONFIG_MFD_ACT8945A)	+= act8945a.o
 obj-$(CONFIG_MFD_SM501)		+= sm501.o
+obj-$(CONFIG_MFD_APALIS_TK1_K20)	+= apalis-tk1-k20.o
 obj-$(CONFIG_MFD_ASIC3)		+= asic3.o tmio_core.o
 obj-$(CONFIG_MFD_BCM590XX)	+= bcm590xx.o
 obj-$(CONFIG_MFD_BD9571MWV)	+= bd9571mwv.o
diff --git a/drivers/mfd/apalis-tk1-k20-ezp.h b/drivers/mfd/apalis-tk1-k20-ezp.h
new file mode 100644
index 000000000000..e89d6adbe471
--- /dev/null
+++ b/drivers/mfd/apalis-tk1-k20-ezp.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2016-2017 Toradex AG
+ * Dominik Sliwa <dominik.sliwa@toradex.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License version 2 as published by the
+ * Free Software Foundation.
+ */
+
+#ifndef __DRIVERS_MFD_APALIS_TK1_K20_H
+#define __DRIVERS_MFD_APALIS_TK1_K20_H
+
+#ifdef CONFIG_APALIS_TK1_K20_EZP
+#define APALIS_TK1_K20_FW_FOPT_ADDR	0x40D
+#define APALIS_TK1_K20_FOPT_EZP_ENA	BIT(1)
+#define APALIS_TK1_K20_FW_VER_ADDR	0x410
+
+#define APALIS_TK1_K20_FLASH_SIZE	0x80000
+
+/* EZ Port commands */
+#define APALIS_TK1_K20_EZP_WREN		0x06
+#define APALIS_TK1_K20_EZP_WRDI		0x04
+#define APALIS_TK1_K20_EZP_RDSR		0x05
+#define APALIS_TK1_K20_EZP_READ		0x03
+#define APALIS_TK1_K20_EZP_FREAD	0x0B
+#define APALIS_TK1_K20_EZP_SP		0x02
+#define APALIS_TK1_K20_EZP_SE		0xD8
+#define APALIS_TK1_K20_EZP_BE		0xC7
+#define APALIS_TK1_K20_EZP_RESET	0xB9
+#define APALIS_TK1_K20_EZP_WRFCCOB	0xBA
+#define APALIS_TK1_K20_EZP_FRDFCOOB	0xBB
+
+/* Bits of EZ Port status register */
+#define APALIS_TK1_K20_EZP_STA_WIP	BIT(0)
+#define APALIS_TK1_K20_EZP_STA_WEN	BIT(1)
+#define APALIS_TK1_K20_EZP_STA_BEDIS	BIT(2)
+#define APALIS_TK1_K20_EZP_STA_WEF	BIT(6)
+#define APALIS_TK1_K20_EZP_STA_FS	BIT(7)
+
+#define APALIS_TK1_K20_EZP_MAX_SPEED	4080000
+#define APALIS_TK1_K20_EZP_MAX_DATA	32
+#define APALIS_TK1_K20_EZP_WRITE_SIZE	32
+
+static const struct firmware *fw_entry;
+#endif /* CONFIG_APALIS_TK1_K20_EZP */
+
+#endif /* __DRIVERS_MFD_APALIS_TK1_K20_H */
diff --git a/drivers/mfd/apalis-tk1-k20.c b/drivers/mfd/apalis-tk1-k20.c
new file mode 100644
index 000000000000..913be65c33e6
--- /dev/null
+++ b/drivers/mfd/apalis-tk1-k20.c
@@ -0,0 +1,1062 @@
+/*
+ * Copyright 2016-2017 Toradex AG
+ * Dominik Sliwa <dominik.sliwa@toradex.com>
+ *
+ * based on an driver for MC13xxx by:
+ * Copyright 2009-2010 Pengutronix
+ * Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License version 2 as published by the
+ * Free Software Foundation.
+ */
+
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/apalis-tk1-k20.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+#include <linux/of_irq.h>
+#include <linux/err.h>
+#include <linux/firmware.h>
+#include <linux/spi/spi.h>
+#include <linux/delay.h>
+
+#include "apalis-tk1-k20-ezp.h"
+#define APALIS_TK1_K20_MAX_MSG 4
+
+static const struct spi_device_id apalis_tk1_k20_device_ids[] = {
+	{
+		.name = "apalis-tk1-k20",
+	}, {
+		/* sentinel */
+	}
+};
+MODULE_DEVICE_TABLE(spi, apalis_tk1_k20_device_ids);
+
+static const struct of_device_id apalis_tk1_k20_dt_ids[] = {
+	{
+		.compatible = "toradex,apalis-tk1-k20",
+	}, {
+		/* sentinel */
+	}
+};
+MODULE_DEVICE_TABLE(of, apalis_tk1_k20_dt_ids);
+
+static const struct regmap_config apalis_tk1_k20_regmap_spi_config = {
+	.reg_bits = 8,
+	.pad_bits = 0,
+	.val_bits = 8,
+
+	.max_register = APALIS_TK1_K20_LAST_REG,
+
+	.cache_type = REGCACHE_NONE,
+	.use_single_rw = 0,
+};
+
+static int apalis_tk1_k20_spi_read(void *context, const void *reg,
+		size_t reg_size, void *val, size_t val_size)
+{
+	unsigned char w[APALIS_TK1_K20_MAX_BULK] = {APALIS_TK1_K20_READ_INST,
+			 *((unsigned char *) reg), val_size, 0x00, 0x00, 0x00,
+			0x00};
+	unsigned char r[APALIS_TK1_K20_MAX_BULK];
+	unsigned char *p = val;
+	int i = 0, j = 0;
+	struct device *dev = context;
+	struct spi_device *spi = to_spi_device(dev);
+	struct spi_transfer t = {
+		.tx_buf = w,
+		.rx_buf = r,
+		.len = 8,
+		.cs_change = 0,
+		.delay_usecs = 0,
+	};
+
+	struct spi_message m;
+	int ret;
+	spi->mode = SPI_MODE_1;
+
+	if (reg_size != 1)
+		return -ENOTSUPP;
+
+	if (val_size == 1) {
+		spi_message_init(&m);
+		spi_message_add_tail(&t, &m);
+		ret = spi_sync(spi, &m);
+
+		for (i = 3; i < 7; i++ )
+		{
+			if (((unsigned char *)t.rx_buf)[i] == 0x55) {
+				*p = ((unsigned char *)t.rx_buf)[i + 1];
+				return ret;
+			}
+		}
+
+		for (j = 0; j < APALIS_TK1_MAX_RETRY_CNT; j++) {
+			udelay(250 * j * j);
+			t.tx_buf = w;
+			t.rx_buf = r;
+			spi_message_init(&m);
+			spi_message_add_tail(&t, &m);
+			ret = spi_sync(spi, &m);
+			for (i = 3; i < 7; i++ )
+			{
+				if (((unsigned char *)t.rx_buf)[i] == 0x55) {
+					*p = ((unsigned char *)t.rx_buf)[i + 1];
+					return ret;
+				}
+			}
+		}
+		ret = -EIO;
+
+	} else if ((val_size > 1) && (val_size < APALIS_TK1_K20_MAX_BULK)) {
+		t.len = 5;
+		w[0] = APALIS_TK1_K20_BULK_READ_INST;
+		spi_message_init(&m);
+		spi_message_add_tail(&t, &m);
+		ret = spi_sync(spi, &m);
+		/* no need to reinit the message*/
+		t.len = val_size;
+		t.rx_buf = p;
+		/* just use the same transfer */
+		ret = spi_sync(spi, &m);
+
+	} else {
+		return -ENOTSUPP;
+	}
+
+	return ret;
+}
+
+
+static int apalis_tk1_k20_spi_write(void *context, const void *data,
+		size_t count)
+{
+	struct device *dev = context;
+	struct spi_device *spi = to_spi_device(dev);
+	uint8_t out_data[APALIS_TK1_K20_MAX_BULK];
+	int ret;
+
+
+	spi->mode = SPI_MODE_1;
+
+	if (count == 2) {
+		out_data[0] = APALIS_TK1_K20_WRITE_INST;
+		out_data[1] = ((uint8_t *)data)[0];
+		out_data[2] = ((uint8_t *)data)[1];
+		ret = spi_write(spi, out_data, 3);
+
+	} else if ((count > 2) && (count < APALIS_TK1_K20_MAX_BULK)) {
+		out_data[0] = APALIS_TK1_K20_BULK_WRITE_INST;
+		out_data[1] = ((uint8_t *)data)[0];
+		out_data[2] = count - 1;
+		memcpy(&out_data[3], &((uint8_t *)data)[1], count - 1);
+		ret = spi_write(spi, out_data, count + 2);
+	} else {
+		dev_err(dev, "Apalis TK1 K20 MFD invalid write count = %d\n",
+				count);
+		return -ENOTSUPP;
+	}
+	return ret;
+}
+
+static struct regmap_bus regmap_apalis_tk1_k20_bus = {
+	.write = apalis_tk1_k20_spi_write,
+	.read = apalis_tk1_k20_spi_read,
+};
+
+void apalis_tk1_k20_lock(struct apalis_tk1_k20_regmap *apalis_tk1_k20)
+{
+	if (!mutex_trylock(&apalis_tk1_k20->lock)) {
+		dev_dbg(apalis_tk1_k20->dev, "wait for %s from %ps\n",
+				__func__, __builtin_return_address(0));
+
+		mutex_lock(&apalis_tk1_k20->lock);
+	}
+	dev_dbg(apalis_tk1_k20->dev, "%s from %ps\n",
+			__func__, __builtin_return_address(0));
+}
+EXPORT_SYMBOL(apalis_tk1_k20_lock);
+
+void apalis_tk1_k20_unlock(struct apalis_tk1_k20_regmap *apalis_tk1_k20)
+{
+	dev_dbg(apalis_tk1_k20->dev, "%s from %ps\n",
+			__func__, __builtin_return_address(0));
+	mutex_unlock(&apalis_tk1_k20->lock);
+}
+EXPORT_SYMBOL(apalis_tk1_k20_unlock);
+
+int apalis_tk1_k20_reg_read(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
+		unsigned int offset, u32 *val)
+{
+	int ret;
+
+	ret = regmap_read(apalis_tk1_k20->regmap, offset, val);
+	dev_dbg(apalis_tk1_k20->dev, "[0x%02x] -> 0x%02x ret = %d\n", offset,
+			*val, ret);
+
+	return ret;
+}
+EXPORT_SYMBOL(apalis_tk1_k20_reg_read);
+
+int apalis_tk1_k20_reg_write(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
+		unsigned int offset, u32 val)
+{
+	int ret;
+
+	if (val >= BIT(24))
+		return -EINVAL;
+
+	ret = regmap_write(apalis_tk1_k20->regmap, offset, val);
+
+	dev_dbg(apalis_tk1_k20->dev, "[0x%02x] <- 0x%02x ret = %d\n", offset, val,
+			 ret);
+
+	return ret;
+}
+EXPORT_SYMBOL(apalis_tk1_k20_reg_write);
+
+int apalis_tk1_k20_reg_read_bulk(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
+		unsigned int offset,
+		uint8_t *val, size_t size)
+{
+	int ret;
+
+	if (size > APALIS_TK1_K20_MAX_BULK)
+		return -EINVAL;
+
+	ret = regmap_bulk_read(apalis_tk1_k20->regmap, offset, val, size);
+	dev_dbg(apalis_tk1_k20->dev, "bulk read %d bytes from [0x%02x]\n",
+			size, offset);
+
+	return ret;
+}
+EXPORT_SYMBOL(apalis_tk1_k20_reg_read_bulk);
+
+int apalis_tk1_k20_reg_write_bulk(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
+		unsigned int offset, uint8_t *buf, size_t size)
+{
+	dev_dbg(apalis_tk1_k20->dev, "bulk write %d bytes to [0x%02x]\n",
+			(unsigned int)size, offset);
+
+	if (size > APALIS_TK1_K20_MAX_BULK)
+		return -EINVAL;
+	return regmap_bulk_write(apalis_tk1_k20->regmap, offset, buf, size);
+}
+EXPORT_SYMBOL(apalis_tk1_k20_reg_write_bulk);
+
+int apalis_tk1_k20_reg_rmw(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
+		unsigned int offset, u32 mask, u32 val)
+{
+	dev_dbg(apalis_tk1_k20->dev, "[0x%02x] <- 0x%06x (mask: 0x%06x)\n",
+			offset, val, mask);
+
+	return regmap_update_bits(apalis_tk1_k20->regmap, offset, mask, val);
+}
+EXPORT_SYMBOL(apalis_tk1_k20_reg_rmw);
+
+int apalis_tk1_k20_irq_mask(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
+		int irq)
+{
+	int virq = -1;
+	if (irq != APALIS_TK1_K20_CAN1_IRQ && irq != APALIS_TK1_K20_CAN0_IRQ) {
+		virq = regmap_irq_get_virq(apalis_tk1_k20->irq_data, irq);
+
+	} else {
+		virq = (irq == APALIS_TK1_K20_CAN0_IRQ) ?
+			apalis_tk1_k20->can0_irq:apalis_tk1_k20->can1_irq;
+	}
+
+	disable_irq_nosync(virq);
+
+	return 0;
+}
+EXPORT_SYMBOL(apalis_tk1_k20_irq_mask);
+
+int apalis_tk1_k20_irq_unmask(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
+		int irq)
+{
+	int virq = -1;
+	if (irq != APALIS_TK1_K20_CAN1_IRQ && irq != APALIS_TK1_K20_CAN0_IRQ) {
+		virq = regmap_irq_get_virq(apalis_tk1_k20->irq_data, irq);
+
+	} else {
+		virq = (irq == APALIS_TK1_K20_CAN0_IRQ) ?
+			apalis_tk1_k20->can0_irq:apalis_tk1_k20->can1_irq;
+	}
+
+	enable_irq(virq);
+
+	return 0;
+}
+EXPORT_SYMBOL(apalis_tk1_k20_irq_unmask);
+
+int apalis_tk1_k20_irq_status(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
+		int irq, int *enabled, int *pending)
+{
+	int ret;
+	unsigned int offmask = APALIS_TK1_K20_MSQREG;
+	unsigned int offstat = APALIS_TK1_K20_IRQREG;
+	u32 irqbit = 1 << irq;
+
+	if (irq < 0 || irq >= ARRAY_SIZE(apalis_tk1_k20->irqs))
+		return -EINVAL;
+
+	if (enabled) {
+		u32 mask;
+
+		ret = apalis_tk1_k20_reg_read(apalis_tk1_k20, offmask, &mask);
+		if (ret)
+			return ret;
+
+		*enabled = mask & irqbit;
+	}
+
+	if (pending) {
+		u32 stat;
+
+		ret = apalis_tk1_k20_reg_read(apalis_tk1_k20, offstat, &stat);
+		if (ret)
+			return ret;
+
+		*pending = stat & irqbit;
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL(apalis_tk1_k20_irq_status);
+
+int apalis_tk1_k20_irq_request(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
+		int irq, irq_handler_t handler, const char *name, void *dev)
+{
+	int virq = -1;
+	int irq_flags = IRQF_ONESHOT;
+	if (irq != APALIS_TK1_K20_CAN1_IRQ && irq != APALIS_TK1_K20_CAN0_IRQ) {
+		virq = regmap_irq_get_virq(apalis_tk1_k20->irq_data, irq);
+		irq_flags = IRQF_ONESHOT;
+	} else {
+		virq = (irq == APALIS_TK1_K20_CAN0_IRQ) ?
+			apalis_tk1_k20->can0_irq:apalis_tk1_k20->can1_irq;
+		irq_flags = IRQF_ONESHOT | IRQF_TRIGGER_FALLING |
+				IRQF_TRIGGER_RISING;
+	}
+	return devm_request_threaded_irq(apalis_tk1_k20->dev, virq,
+			 NULL, handler, irq_flags, name, dev);
+}
+EXPORT_SYMBOL(apalis_tk1_k20_irq_request);
+
+int apalis_tk1_k20_irq_free(struct apalis_tk1_k20_regmap *apalis_tk1_k20,
+		int irq, void *dev)
+{
+	int virq = -1;
+	if (irq != APALIS_TK1_K20_CAN1_IRQ && irq != APALIS_TK1_K20_CAN0_IRQ) {
+		virq = regmap_irq_get_virq(apalis_tk1_k20->irq_data, irq);
+
+	} else {
+		virq = (irq == APALIS_TK1_K20_CAN0_IRQ) ?
+			apalis_tk1_k20->can0_irq:apalis_tk1_k20->can1_irq;
+	}
+
+	devm_free_irq(apalis_tk1_k20->dev, virq, dev);
+
+	return 0;
+}
+EXPORT_SYMBOL(apalis_tk1_k20_irq_free);
+
+
+static int apalis_tk1_k20_add_subdevice_pdata_id(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20, const char *name,
+		void *pdata, size_t pdata_size, int id)
+{
+	struct mfd_cell cell = {
+		.platform_data = pdata,
+		.pdata_size = pdata_size,
+	};
+
+	cell.name = kmemdup(name, strlen(name) + 1, GFP_KERNEL);
+	if (!cell.name)
+		return -ENOMEM;
+
+	return mfd_add_devices(apalis_tk1_k20->dev, id, &cell, 1, NULL, 0,
+			       regmap_irq_get_domain(apalis_tk1_k20->irq_data));
+}
+
+static int apalis_tk1_k20_add_subdevice_pdata(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20, const char *name,
+		void *pdata, size_t pdata_size)
+{
+	return apalis_tk1_k20_add_subdevice_pdata_id(apalis_tk1_k20, name,
+			pdata, pdata_size, -1);
+}
+
+static int apalis_tk1_k20_add_subdevice(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20, const char *name)
+{
+	return apalis_tk1_k20_add_subdevice_pdata(apalis_tk1_k20, name, NULL,
+						  0);
+}
+
+static void apalis_tk1_k20_reset_chip(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
+{
+	udelay(10);
+	gpio_set_value(apalis_tk1_k20->reset_gpio, 0);
+	msleep(10);
+	gpio_set_value(apalis_tk1_k20->reset_gpio, 1);
+	udelay(10);
+}
+
+#ifdef CONFIG_APALIS_TK1_K20_EZP
+static int apalis_tk1_k20_read_ezport(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20, uint8_t command,
+		int addr, int count, uint8_t *buffer)
+{
+	uint8_t w[4 + APALIS_TK1_K20_EZP_MAX_DATA];
+	uint8_t r[4 + APALIS_TK1_K20_EZP_MAX_DATA];
+	uint8_t *out;
+	struct spi_message m;
+	struct spi_device *spi = to_spi_device(apalis_tk1_k20->dev);
+	struct spi_transfer t = {
+		.tx_buf = w,
+		.rx_buf = r,
+		.speed_hz = APALIS_TK1_K20_EZP_MAX_SPEED,
+	};
+	int ret;
+
+	spi->mode = SPI_MODE_0;
+
+	if (count > APALIS_TK1_K20_EZP_MAX_DATA)
+		return -ENOSPC;
+
+	memset(w, 0, 4 + count);
+
+	switch (command) {
+	case APALIS_TK1_K20_EZP_READ:
+	case APALIS_TK1_K20_EZP_FREAD:
+		t.len = 4 + count;
+		w[1] = (addr & 0xFF0000) >> 16;
+		w[2] = (addr & 0xFF00) >> 8;
+		w[3] = (addr & 0xFC);
+		out = &r[4];
+		break;
+	case APALIS_TK1_K20_EZP_RDSR:
+	case APALIS_TK1_K20_EZP_FRDFCOOB:
+		t.len = 1 + count;
+		out = &r[1];
+		break;
+	default:
+		return -EINVAL;
+	}
+	w[0] = command;
+
+	gpio_set_value(apalis_tk1_k20->ezpcs_gpio, 0);
+	spi_message_init(&m);
+	spi_message_add_tail(&t, &m);
+	ret = spi_sync(spi, &m);
+	gpio_set_value(apalis_tk1_k20->ezpcs_gpio, 1);
+	if (ret != 0)
+		return ret;
+
+	memcpy(buffer, out, count);
+
+	return 0;
+}
+
+static int apalis_tk1_k20_write_ezport(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20, uint8_t command,
+		int addr, int count, const uint8_t *buffer)
+{
+	uint8_t w[4 + APALIS_TK1_K20_EZP_MAX_DATA];
+	uint8_t r[4 + APALIS_TK1_K20_EZP_MAX_DATA];
+	struct spi_message m;
+	struct spi_device *spi = to_spi_device(apalis_tk1_k20->dev);
+	struct spi_transfer t = {
+		.tx_buf = w,
+		.rx_buf = r,
+		.speed_hz = APALIS_TK1_K20_EZP_MAX_SPEED,
+	};
+	int ret;
+
+	spi->mode = SPI_MODE_0;
+
+	if (count > APALIS_TK1_K20_EZP_MAX_DATA)
+		return -ENOSPC;
+
+	switch (command) {
+	case APALIS_TK1_K20_EZP_SP:
+	case APALIS_TK1_K20_EZP_SE:
+		t.len = 4 + count;
+		w[1] = (addr & 0xFF0000) >> 16;
+		w[2] = (addr & 0xFF00) >> 8;
+		w[3] = (addr & 0xF8);
+		memcpy(&w[4], buffer, count);
+		break;
+	case APALIS_TK1_K20_EZP_WREN:
+	case APALIS_TK1_K20_EZP_WRDI:
+	case APALIS_TK1_K20_EZP_BE:
+	case APALIS_TK1_K20_EZP_RESET:
+	case APALIS_TK1_K20_EZP_WRFCCOB:
+		t.len = 1 + count;
+		memcpy(&w[1], buffer, count);
+		break;
+	default:
+		return -EINVAL;
+	}
+	w[0] = command;
+
+	gpio_set_value(apalis_tk1_k20->ezpcs_gpio, 0);
+	spi_message_init(&m);
+	spi_message_add_tail(&t, &m);
+	ret = spi_sync(spi, &m);
+	gpio_set_value(apalis_tk1_k20->ezpcs_gpio, 1);
+
+	return ret;
+}
+
+static int apalis_tk1_k20_set_wren_ezport(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
+{
+	uint8_t buffer;
+
+	if (apalis_tk1_k20_write_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_WREN,
+			0, 0, NULL) < 0)
+		return -EIO;
+	if (apalis_tk1_k20_read_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_RDSR,
+			0, 1, &buffer) < 0)
+		return -EIO;
+	if ((buffer & APALIS_TK1_K20_EZP_STA_WEN))
+		return 0;
+
+	/* If it failed try one last time */
+	if (apalis_tk1_k20_write_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_WREN,
+			0, 0, NULL) < 0)
+		return -EIO;
+	if (apalis_tk1_k20_read_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_RDSR,
+			0, 1, &buffer) < 0)
+		return -EIO;
+	if ((buffer & APALIS_TK1_K20_EZP_STA_WEN))
+		return 0;
+
+	return -EIO;
+
+}
+
+static int apalis_tk1_k20_enter_ezport(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
+{
+	uint8_t status = 0x00;
+	uint8_t buffer;
+
+	gpio_set_value(apalis_tk1_k20->ezpcs_gpio, 0);
+	msleep(10);
+	apalis_tk1_k20_reset_chip(apalis_tk1_k20);
+	msleep(10);
+	gpio_set_value(apalis_tk1_k20->ezpcs_gpio, 1);
+	if (apalis_tk1_k20_read_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_RDSR,
+			0, 1, &buffer) < 0)
+		goto bad;
+	status = buffer;
+	if (apalis_tk1_k20_write_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_WREN,
+			0, 0, NULL) < 0)
+		goto bad;
+	if (apalis_tk1_k20_read_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_RDSR,
+			0, 1, &buffer) < 0)
+		goto bad;
+	if ((buffer & APALIS_TK1_K20_EZP_STA_WEN) && buffer != status)
+		return 0;
+
+bad:
+	dev_err(apalis_tk1_k20->dev, "Error entering EZ Port mode.\n");
+	return -EIO;
+}
+
+static int apalis_tk1_k20_erase_chip_ezport(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
+{
+	uint8_t buffer[16];
+	int i;
+
+	if (apalis_tk1_k20_set_wren_ezport(apalis_tk1_k20))
+		goto bad;
+	if (apalis_tk1_k20_write_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_BE,
+			0, 0, NULL) < 0)
+		goto bad;
+
+	if (apalis_tk1_k20_read_ezport(apalis_tk1_k20, APALIS_TK1_K20_EZP_RDSR,
+			0, 1, buffer) < 0)
+		goto bad;
+
+	i = 0;
+	while (buffer[0] & APALIS_TK1_K20_EZP_STA_WIP) {
+		msleep(20);
+		if ((apalis_tk1_k20_read_ezport(apalis_tk1_k20,
+		     APALIS_TK1_K20_EZP_RDSR, 0, 1, buffer) < 0) || (i > 50))
+			goto bad;
+		i++;
+	}
+
+	return 0;
+
+bad:
+	dev_err(apalis_tk1_k20->dev, "Error erasing the chip.\n");
+	return -EIO;
+}
+
+static int apalis_tk1_k20_flash_chip_ezport(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
+{
+	uint8_t buffer;
+	const uint8_t *fw_chunk;
+	int i, j, transfer_size;
+
+	for (i = 0; i < fw_entry->size;) {
+		if (apalis_tk1_k20_set_wren_ezport(apalis_tk1_k20))
+			goto bad;
+
+		fw_chunk = fw_entry->data + i;
+		transfer_size = (i + APALIS_TK1_K20_EZP_WRITE_SIZE <
+				 fw_entry->size) ? APALIS_TK1_K20_EZP_WRITE_SIZE
+				 : (fw_entry->size - i - 1);
+		dev_dbg(apalis_tk1_k20->dev,
+			 "Apalis TK1 K20 MFD transfer_size = %d addr = 0x%X\n",
+				 transfer_size, i);
+		if (apalis_tk1_k20_write_ezport(apalis_tk1_k20,
+				APALIS_TK1_K20_EZP_SP, i,
+			transfer_size, fw_chunk) < 0)
+			goto bad;
+		udelay(2000);
+		if (apalis_tk1_k20_read_ezport(apalis_tk1_k20,
+				APALIS_TK1_K20_EZP_RDSR, 0, 1, &buffer) < 0)
+			goto bad;
+
+		j = 0;
+		while (buffer & APALIS_TK1_K20_EZP_STA_WIP) {
+			msleep(10);
+			if ((apalis_tk1_k20_read_ezport(apalis_tk1_k20,
+					APALIS_TK1_K20_EZP_RDSR, 0, 1,
+					&buffer) < 0) || (j > 10000))
+				goto bad;
+			j++;
+		}
+		i += APALIS_TK1_K20_EZP_WRITE_SIZE;
+	}
+
+	return 0;
+
+bad:
+	dev_err(apalis_tk1_k20->dev, "Error writing to the chip.\n");
+	return -EIO;
+}
+
+static uint8_t apalis_tk1_k20_fw_ezport_status(void)
+{
+	return fw_entry->data[APALIS_TK1_K20_FW_FOPT_ADDR] &
+			APALIS_TK1_K20_FOPT_EZP_ENA;
+}
+
+static uint8_t apalis_tk1_k20_get_fw_revision(void)
+{
+	if (fw_entry)
+		if (fw_entry->size > APALIS_TK1_K20_FW_VER_ADDR)
+			return fw_entry->data[APALIS_TK1_K20_FW_VER_ADDR];
+	return 0;
+}
+#endif /* CONFIG_APALIS_TK1_K20_EZP */
+
+
+#ifdef CONFIG_OF
+static int apalis_tk1_k20_probe_flags_dt(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
+{
+	struct device_node *np = apalis_tk1_k20->dev->of_node;
+
+	if (!np)
+		return -ENODEV;
+
+	if (of_property_read_bool(np, "toradex,apalis-tk1-k20-uses-adc"))
+		apalis_tk1_k20->flags |= APALIS_TK1_K20_USES_ADC;
+
+	if (of_property_read_bool(np, "toradex,apalis-tk1-k20-uses-tsc"))
+		apalis_tk1_k20->flags |= APALIS_TK1_K20_USES_TSC;
+
+	if (of_property_read_bool(np, "toradex,apalis-tk1-k20-uses-can"))
+		apalis_tk1_k20->flags |= APALIS_TK1_K20_USES_CAN;
+
+	if (of_property_read_bool(np, "toradex,apalis-tk1-k20-uses-gpio"))
+		apalis_tk1_k20->flags |= APALIS_TK1_K20_USES_GPIO;
+
+	return 0;
+}
+
+static int apalis_tk1_k20_probe_gpios_dt(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
+{
+	struct device_node *np = apalis_tk1_k20->dev->of_node;
+
+	if (!np)
+		return -ENODEV;
+
+	apalis_tk1_k20->reset_gpio = of_get_named_gpio(np, "rst-gpio", 0);
+	if (apalis_tk1_k20->reset_gpio < 0)
+		return apalis_tk1_k20->reset_gpio;
+	gpio_request(apalis_tk1_k20->reset_gpio, "apalis-tk1-k20-reset");
+	gpio_direction_output(apalis_tk1_k20->reset_gpio, 1);
+
+	apalis_tk1_k20->ezpcs_gpio = of_get_named_gpio(np, "ezport-cs-gpio", 0);
+	if (apalis_tk1_k20->ezpcs_gpio < 0)
+		return apalis_tk1_k20->ezpcs_gpio;
+	gpio_request(apalis_tk1_k20->ezpcs_gpio, "apalis-tk1-k20-ezpcs");
+	gpio_direction_output(apalis_tk1_k20->ezpcs_gpio, 1);
+
+	apalis_tk1_k20->int2_gpio = of_get_named_gpio(np, "int2-gpio", 0);
+	if (apalis_tk1_k20->int2_gpio < 0)
+		return apalis_tk1_k20->int2_gpio;
+	gpio_request(apalis_tk1_k20->int2_gpio, "apalis-tk1-k20-int2");
+	gpio_direction_output(apalis_tk1_k20->int2_gpio, 1);
+
+	return 0;
+}
+#else
+static inline int apalis_tk1_k20_probe_flags_dt(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
+{
+	return -ENODEV;
+}
+static inline int apalis_tk1_k20_probe_gpios_dt(
+		struct apalis_tk1_k20_regmap *apalis_tk1_k20)
+{
+	return -ENODEV;
+}
+#endif
+
+int apalis_tk1_k20_dev_init(struct device *dev)
+{
+	struct apalis_tk1_k20_platform_data *pdata = dev_get_platdata(dev);
+	struct apalis_tk1_k20_regmap *apalis_tk1_k20 = dev_get_drvdata(dev);
+	uint32_t revision = 0x00;
+	int ret, i;
+	int erase_only = 0;
+
+	apalis_tk1_k20->dev = dev;
+
+	ret = apalis_tk1_k20_probe_gpios_dt(apalis_tk1_k20);
+	if ((ret < 0) && pdata) {
+		if (pdata) {
+			apalis_tk1_k20->ezpcs_gpio = pdata->ezpcs_gpio;
+			apalis_tk1_k20->reset_gpio = pdata->reset_gpio;
+			apalis_tk1_k20->int2_gpio = pdata->int2_gpio;
+		} else {
+			dev_err(dev, "Error claiming GPIOs\n");
+			ret = -EINVAL;
+			goto bad;
+		}
+	}
+	apalis_tk1_k20_reset_chip(apalis_tk1_k20);
+	msleep(10);
+	ret = apalis_tk1_k20_reg_read(apalis_tk1_k20, APALIS_TK1_K20_REVREG,
+			&revision);
+
+#ifdef CONFIG_APALIS_TK1_K20_EZP
+	if ((request_firmware(&fw_entry, "apalis-tk1-k20.bin", dev) < 0)
+	    && (revision != APALIS_TK1_K20_FW_VER)) {
+		dev_err(apalis_tk1_k20->dev,
+			"Unsupported firmware version %d.%d and no local" \
+			" firmware file available.\n",
+			(revision & 0xF0 >> 8),
+			(revision & 0x0F));
+		ret = -ENOTSUPP;
+		goto bad;
+	}
+
+	if ((fw_entry == NULL) && (revision != APALIS_TK1_K20_FW_VER)) {
+		dev_err(apalis_tk1_k20->dev,
+			"Unsupported firmware version %d.%d and no local" \
+			" firmware file available.\n",
+			(revision & 0xF0 >> 8),
+			(revision & 0x0F));
+		ret = -ENOTSUPP;
+		goto bad;
+	}
+
+	if (fw_entry != NULL) {
+		if (fw_entry->size == 1)
+			erase_only = 1;
+	}
+
+	if ((apalis_tk1_k20_get_fw_revision() != APALIS_TK1_K20_FW_VER) &&
+		(revision != APALIS_TK1_K20_FW_VER) && !erase_only &&
+		(fw_entry != NULL)) {
+		dev_err(apalis_tk1_k20->dev,
+			"Unsupported firmware version in both the device " \
+			"as well as the local firmware file.\n");
+		release_firmware(fw_entry);
+		ret = -ENOTSUPP;
+		goto bad;
+	}
+
+	if ((revision != APALIS_TK1_K20_FW_VER) && !erase_only &&
+			(!apalis_tk1_k20_fw_ezport_status()) &&
+			(fw_entry != NULL)) {
+		dev_err(apalis_tk1_k20->dev,
+			"Unsupported firmware version in the device and the " \
+			"local firmware file disables the EZ Port.\n");
+		release_firmware(fw_entry);
+		ret = -ENOTSUPP;
+		goto bad;
+	}
+
+	if (((revision != APALIS_TK1_K20_FW_VER) || erase_only) &&
+			(fw_entry != NULL)) {
+		i = 0;
+		while (apalis_tk1_k20_enter_ezport(apalis_tk1_k20) < 0
+				&& i++ < 5) {
+			msleep(50);
+		}
+		if (i >= 5) {
+			dev_err(apalis_tk1_k20->dev,
+				"Problem entering EZ port mode.\n");
+			release_firmware(fw_entry);
+			ret = -EIO;
+			goto bad;
+		}
+		if (apalis_tk1_k20_erase_chip_ezport(apalis_tk1_k20) < 0) {
+			dev_err(apalis_tk1_k20->dev,
+				"Problem erasing the chip.\n");
+			release_firmware(fw_entry);
+			ret = -EPROBE_DEFER;
+			goto bad;
+		}
+		if (erase_only) {
+			dev_err(apalis_tk1_k20->dev,
+				"Chip fully erased.\n");
+			release_firmware(fw_entry);
+			ret = -EIO;
+			goto bad;
+		}
+		if (apalis_tk1_k20_flash_chip_ezport(apalis_tk1_k20) < 0) {
+			dev_err(apalis_tk1_k20->dev,
+				"Problem flashing new firmware.\n");
+			release_firmware(fw_entry);
+			ret = -EPROBE_DEFER;
+			goto bad;
+		}
+	}
+	if (fw_entry != NULL)
+		release_firmware(fw_entry);
+
+	msleep(10);
+	apalis_tk1_k20_reset_chip(apalis_tk1_k20);
+	msleep(10);
+
+	ret = apalis_tk1_k20_reg_read(apalis_tk1_k20, APALIS_TK1_K20_REVREG,
+			&revision);
+#endif /* CONFIG_APALIS_TK1_K20_EZP */
+
+	if (ret) {
+		dev_err(apalis_tk1_k20->dev, "Device is not answering.\n");
+		goto bad;
+	}
+
+	if (revision != APALIS_TK1_K20_FW_VER) {
+		dev_err(apalis_tk1_k20->dev,
+			"Unsupported firmware version %d.%d.\n",
+			((revision & 0xF0) >> 4), (revision & 0x0F));
+		ret = -ENOTSUPP;
+		goto bad;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(apalis_tk1_k20->irqs); i++) {
+		apalis_tk1_k20->irqs[i].reg_offset = i /
+						     APALIS_TK1_K20_IRQ_PER_REG;
+		apalis_tk1_k20->irqs[i].mask = BIT(i %
+						   APALIS_TK1_K20_IRQ_PER_REG);
+	}
+
+	apalis_tk1_k20->irq_chip.name		= dev_name(dev);
+	apalis_tk1_k20->irq_chip.status_base	= APALIS_TK1_K20_IRQREG;
+	apalis_tk1_k20->irq_chip.mask_base	= APALIS_TK1_K20_MSQREG;
+	apalis_tk1_k20->irq_chip.ack_base	= 0;
+	apalis_tk1_k20->irq_chip.irq_reg_stride	= 0;
+	apalis_tk1_k20->irq_chip.num_regs	= APALIS_TK1_K20_IRQ_REG_CNT;
+	apalis_tk1_k20->irq_chip.irqs		= apalis_tk1_k20->irqs;
+	apalis_tk1_k20->irq_chip.num_irqs = ARRAY_SIZE(apalis_tk1_k20->irqs);
+
+	ret = regmap_add_irq_chip(apalis_tk1_k20->regmap, apalis_tk1_k20->irq,
+			IRQF_ONESHOT | IRQF_TRIGGER_FALLING |
+			IRQF_TRIGGER_RISING, 0, &apalis_tk1_k20->irq_chip,
+			&apalis_tk1_k20->irq_data);
+	if (ret)
+		goto bad;
+
+	mutex_init(&apalis_tk1_k20->lock);
+
+	if (apalis_tk1_k20_probe_flags_dt(apalis_tk1_k20) < 0 && pdata)
+		apalis_tk1_k20->flags = pdata->flags;
+
+	if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_CAN) {
+		apalis_tk1_k20->can0_irq = irq_of_parse_and_map(
+					apalis_tk1_k20->dev->of_node, 1);
+		apalis_tk1_k20->can1_irq = irq_of_parse_and_map(
+					apalis_tk1_k20->dev->of_node, 2);
+		if (apalis_tk1_k20->can0_irq == 0 ||
+				apalis_tk1_k20->can1_irq == 0) {
+			apalis_tk1_k20->flags &= ~APALIS_TK1_K20_USES_CAN;
+			dev_err(apalis_tk1_k20->dev,
+					"Missing CAN interrupts.\n");
+		}
+	}
+
+	if (pdata) {
+		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_TSC)
+			apalis_tk1_k20_add_subdevice_pdata(apalis_tk1_k20,
+					"apalis-tk1-k20-ts",
+					&pdata->touch, sizeof(pdata->touch));
+
+		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_ADC)
+			apalis_tk1_k20_add_subdevice_pdata(apalis_tk1_k20,
+					"apalis-tk1-k20-adc",
+					&pdata->adc, sizeof(pdata->adc));
+
+		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_CAN) {
+			/* We have 2 CAN devices inside K20 */
+			pdata->can0.id = 0;
+			pdata->can1.id = 1;
+			apalis_tk1_k20_add_subdevice_pdata(apalis_tk1_k20,
+					"apalis-tk1-k20-can",
+					&pdata->can0, sizeof(pdata->can0));
+			apalis_tk1_k20_add_subdevice_pdata(apalis_tk1_k20,
+					"apalis-tk1-k20-can",
+					&pdata->can1, sizeof(pdata->can1));
+		}
+		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_GPIO)
+			apalis_tk1_k20_add_subdevice_pdata(apalis_tk1_k20,
+					"apalis-tk1-k20-gpio",
+					&pdata->gpio, sizeof(pdata->gpio));
+	} else {
+		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_TSC)
+			apalis_tk1_k20_add_subdevice(apalis_tk1_k20,
+					"apalis-tk1-k20-ts");
+
+		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_ADC)
+			apalis_tk1_k20_add_subdevice(apalis_tk1_k20,
+					"apalis-tk1-k20-adc");
+
+		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_CAN) {
+			/* We have 2 CAN devices inside K20 */
+			apalis_tk1_k20_add_subdevice_pdata_id(apalis_tk1_k20,
+					"apalis-tk1-k20-can",
+					NULL, 0, 0);
+			apalis_tk1_k20_add_subdevice_pdata_id(apalis_tk1_k20,
+					"apalis-tk1-k20-can",
+					NULL, 0, 1);
+		}
+
+		if (apalis_tk1_k20->flags & APALIS_TK1_K20_USES_GPIO)
+			apalis_tk1_k20_add_subdevice(apalis_tk1_k20,
+					"apalis-tk1-k20-gpio");
+	}
+
+	dev_info(apalis_tk1_k20->dev, "Apalis TK1 K20 MFD driver. "
+			"Firmware version %d.%d.\n", FW_MAJOR, FW_MINOR);
+
+	return 0;
+
+bad:
+	if (apalis_tk1_k20->ezpcs_gpio >= 0)
+		gpio_free(apalis_tk1_k20->ezpcs_gpio);
+	if (apalis_tk1_k20->reset_gpio >= 0)
+		gpio_free(apalis_tk1_k20->reset_gpio);
+	if (apalis_tk1_k20->int2_gpio >= 0)
+		gpio_free(apalis_tk1_k20->int2_gpio);
+
+	return ret;
+}
+
+
+static int apalis_tk1_k20_spi_probe(struct spi_device *spi)
+{
+	struct apalis_tk1_k20_regmap *apalis_tk1_k20;
+	int ret;
+
+	apalis_tk1_k20 = devm_kzalloc(&spi->dev, sizeof(*apalis_tk1_k20),
+			GFP_KERNEL);
+	if (!apalis_tk1_k20)
+		return -ENOMEM;
+
+	dev_set_drvdata(&spi->dev, apalis_tk1_k20);
+
+	spi->mode = SPI_MODE_1;
+
+	apalis_tk1_k20->irq = spi->irq;
+
+	spi->max_speed_hz = (spi->max_speed_hz >= APALIS_TK1_K20_MAX_SPI_SPEED)
+				? APALIS_TK1_K20_MAX_SPI_SPEED : spi->max_speed_hz;
+
+	ret = spi_setup(spi);
+	if (ret)
+		return ret;
+
+	apalis_tk1_k20->regmap = devm_regmap_init(&spi->dev,
+			&regmap_apalis_tk1_k20_bus, &spi->dev,
+			&apalis_tk1_k20_regmap_spi_config);
+	if (IS_ERR(apalis_tk1_k20->regmap)) {
+		ret = PTR_ERR(apalis_tk1_k20->regmap);
+		dev_err(&spi->dev, "Failed to initialize regmap: %d\n", ret);
+		return ret;
+	}
+
+	return apalis_tk1_k20_dev_init(&spi->dev);
+}
+
+static int apalis_tk1_k20_spi_remove(struct spi_device *spi)
+{
+	struct apalis_tk1_k20_regmap *apalis_tk1_k20 =
+			dev_get_drvdata(&spi->dev);
+
+	if (apalis_tk1_k20->ezpcs_gpio >= 0)
+		gpio_free(apalis_tk1_k20->ezpcs_gpio);
+	if (apalis_tk1_k20->reset_gpio >= 0)
+		gpio_free(apalis_tk1_k20->reset_gpio);
+	if (apalis_tk1_k20->int2_gpio >= 0)
+		gpio_free(apalis_tk1_k20->int2_gpio);
+
+	kfree(spi->controller_data);
+	spi->controller_data = NULL;
+
+	mfd_remove_devices(&spi->dev);
+	regmap_del_irq_chip(apalis_tk1_k20->irq, apalis_tk1_k20->irq_data);
+	mutex_destroy(&apalis_tk1_k20->lock);
+
+	return 0;
+}
+
+static struct spi_driver apalis_tk1_k20_spi_driver = {
+	.id_table = apalis_tk1_k20_device_ids,
+	.driver = {
+		.name = "apalis-tk1-k20",
+		.of_match_table = apalis_tk1_k20_dt_ids,
+	},
+	.probe = apalis_tk1_k20_spi_probe,
+	.remove = apalis_tk1_k20_spi_remove,
+};
+
+static int __init apalis_tk1_k20_init(void)
+{
+	return spi_register_driver(&apalis_tk1_k20_spi_driver);
+}
+subsys_initcall(apalis_tk1_k20_init);
+
+static void __exit apalis_tk1_k20_exit(void)
+{
+	spi_unregister_driver(&apalis_tk1_k20_spi_driver);
+}
+module_exit(apalis_tk1_k20_exit);
+
+MODULE_DESCRIPTION("MFD driver for Kinetis MK20DN512 MCU on Apalis TK1");
+MODULE_AUTHOR("Dominik Sliwa <dominik.sliwa@toradex.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/net/can/Kconfig b/drivers/net/can/Kconfig
index ac4ff394bc56..16b2d8e2d16a 100644
--- a/drivers/net/can/Kconfig
+++ b/drivers/net/can/Kconfig
@@ -88,6 +88,12 @@ config CAN_AT91
 	  This is a driver for the SoC CAN controller in Atmel's AT91SAM9263
 	  and AT91SAM9X5 processors.
 
+config CAN_APALIS_TK1_K20
+	tristate "Apalis TK1 K20 CAN controllers"
+	depends on MFD_APALIS_TK1_K20
+	---help---
+	  Driver for the Apalis TK1 K20 CAN controllers.
+
 config CAN_BFIN
 	depends on BF534 || BF536 || BF537 || BF538 || BF539 || BF54x
 	tristate "Analog Devices Blackfin on-chip CAN"
diff --git a/drivers/net/can/Makefile b/drivers/net/can/Makefile
index 02b8ed794564..80ca9eba724a 100644
--- a/drivers/net/can/Makefile
+++ b/drivers/net/can/Makefile
@@ -19,6 +19,7 @@ obj-y				+= usb/
 obj-y				+= softing/
 
 obj-$(CONFIG_CAN_AT91)		+= at91_can.o
+obj-$(CONFIG_CAN_APALIS_TK1_K20)	+= apalis-tk1-k20-can.o
 obj-$(CONFIG_CAN_BFIN)		+= bfin_can.o
 obj-$(CONFIG_CAN_CC770)		+= cc770/
 obj-$(CONFIG_CAN_C_CAN)		+= c_can/
diff --git a/drivers/net/can/apalis-tk1-k20-can.c b/drivers/net/can/apalis-tk1-k20-can.c
new file mode 100644
index 000000000000..e24adbb35dfd
--- /dev/null
+++ b/drivers/net/can/apalis-tk1-k20-can.c
@@ -0,0 +1,817 @@
+/*
+ * Copyright 2016-2017 Toradex AG
+ * Dominik Sliwa <dominik.sliwa@toradex.com>
+ *
+ * CAN bus driver for Apalis TK1 K20 CAN Controller over MFD device
+ * based on MCP251x CAN driver
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License version 2 as published by the
+ * Free Software Foundation.
+ */
+
+#include <linux/can/core.h>
+#include <linux/can/dev.h>
+#include <linux/can/led.h>
+#include <linux/completion.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/freezer.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/mfd/apalis-tk1-k20.h>
+#include <linux/module.h>
+#include <linux/netdevice.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+
+/* Buffer size required for the largest transfer (i.e., reading a
+ * frame)
+ */
+#define CAN_FRAME_MAX_LEN	8
+#define CAN_HEADER_MAX_LEN	5
+#define CAN_TRANSFER_BUF_LEN	(CAN_HEADER_MAX_LEN + CAN_FRAME_MAX_LEN)
+
+#define MB_DLC_OFF	4
+#define MB_EID_OFF	0
+#define MB_RTR_SHIFT	4
+#define MB_IDE_SHIFT	5
+#define MB_DLC_MASK	0xF
+#define MB_EID_LEN	4
+
+#define CANCTRL_MODMASK	0x03
+#define CANCTRL_INTEN	BIT(2)
+#define CANINTF_RX	BIT(3)
+#define CANINTF_TX	BIT(4)
+#define CANINTF_ERR	BIT(5)
+#define CANCTRL_INTMASK	(CANINTF_RX | CANINTF_TX | CANINTF_ERR)
+
+#define EFLG_EWARN	0x01
+#define EFLG_RXWAR	0x02
+#define EFLG_TXWAR	0x04
+#define EFLG_RXEP	0x08
+#define EFLG_TXEP	0x10
+#define EFLG_TXBO	0x20
+#define EFLG_RXOVR	0x40
+
+#define TX_ECHO_SKB_MAX	1
+
+#define K20_CAN_MAX_ID	1
+
+#define DEVICE_NAME "apalis-tk1-k20-can"
+
+static const struct can_bittiming_const apalis_tk1_k20_can_bittiming_const = {
+	.name = "tk1-k20-can",
+	.tseg1_min = 3,
+	.tseg1_max = 16,
+	.tseg2_min = 2,
+	.tseg2_max = 8,
+	.sjw_max = 4,
+	.brp_min = 1,
+	.brp_max = 64,
+	.brp_inc = 1,
+};
+
+struct apalis_tk1_k20_priv {
+	struct can_priv can;
+	struct net_device *net;
+	struct apalis_tk1_k20_regmap *apalis_tk1_k20;
+	struct apalis_tk1_k20_can_platform_data *pdata;
+
+	struct sk_buff *tx_skb;
+	int tx_len;
+
+	struct workqueue_struct *wq;
+	struct work_struct tx_work;
+	struct work_struct restart_work;
+	struct mutex apalis_tk1_k20_can_lock;
+
+	int force_quit;
+	int after_suspend;
+#define AFTER_SUSPEND_UP	1
+#define AFTER_SUSPEND_DOWN	2
+#define AFTER_SUSPEND_RESTART	4
+	int restart_tx;
+};
+
+static void apalis_tk1_k20_can_clean(struct net_device *net)
+{
+	struct apalis_tk1_k20_priv *priv = netdev_priv(net);
+
+	if (priv->tx_skb || priv->tx_len)
+		net->stats.tx_errors++;
+	if (priv->tx_skb)
+		dev_kfree_skb(priv->tx_skb);
+	if (priv->tx_len)
+		can_free_echo_skb(priv->net, 0);
+	priv->tx_skb = NULL;
+	priv->tx_len = 0;
+}
+
+static void apalis_tk1_k20_can_hw_tx_frame(struct net_device *net, u8 *buf,
+					   int len, int tx_buf_idx)
+{
+	/* TODO: Implement multiple TX buffer handling */
+	struct apalis_tk1_k20_priv *priv = netdev_priv(net);
+
+	apalis_tk1_k20_lock(priv->apalis_tk1_k20);
+	apalis_tk1_k20_reg_write_bulk(priv->apalis_tk1_k20,
+				      APALIS_TK1_K20_CAN_OUT_BUF
+				      + APALIS_TK1_K20_CAN_DEV_OFFSET(
+				      priv->pdata->id), buf, len);
+	apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+}
+
+static void apalis_tk1_k20_can_hw_tx(struct net_device *net,
+				     struct can_frame *frame, int tx_buf_idx)
+{
+	u8 buf[CAN_TRANSFER_BUF_LEN];
+
+	buf[MB_DLC_OFF] = frame->can_dlc;
+	memcpy(buf + MB_EID_OFF, &frame->can_id, MB_EID_LEN);
+	memcpy(buf + CAN_HEADER_MAX_LEN, frame->data, frame->can_dlc);
+
+	apalis_tk1_k20_can_hw_tx_frame(net, buf, frame->can_dlc
+			+ CAN_HEADER_MAX_LEN, tx_buf_idx);
+}
+
+static void apalis_tk1_k20_can_hw_rx(struct net_device *net, int buf_idx)
+{
+	int i = 0;
+	struct apalis_tk1_k20_priv *priv = netdev_priv(net);
+	struct sk_buff *skb;
+	struct can_frame *frame;
+	u8 buf[CAN_TRANSFER_BUF_LEN * APALIS_TK1_MAX_CAN_DMA_XREF];
+	u32 frame_available = 0;
+
+	apalis_tk1_k20_lock(priv->apalis_tk1_k20);
+	apalis_tk1_k20_reg_read(priv->apalis_tk1_k20,
+				      APALIS_TK1_K20_CAN_IN_BUF_CNT
+				      + APALIS_TK1_K20_CAN_DEV_OFFSET(
+				      priv->pdata->id), &frame_available);
+	frame_available = min(frame_available, APALIS_TK1_MAX_CAN_DMA_XREF);
+	apalis_tk1_k20_reg_read_bulk(priv->apalis_tk1_k20,
+				     APALIS_TK1_K20_CAN_IN_BUF
+				     + APALIS_TK1_K20_CAN_DEV_OFFSET(
+				     priv->pdata->id), buf,
+				     CAN_TRANSFER_BUF_LEN * frame_available);
+	apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+
+	for (i = 0; i < frame_available; i++) {
+		skb = alloc_can_skb(priv->net, &frame);
+		if (!skb) {
+			dev_err(&net->dev, "cannot allocate RX skb\n");
+			priv->net->stats.rx_dropped++;
+			return;
+		}
+		memcpy(&frame->can_id, &buf[i * CAN_TRANSFER_BUF_LEN]
+				 + MB_EID_OFF, MB_EID_LEN);
+		/* Data length */
+		frame->can_dlc = get_can_dlc(buf[i * CAN_TRANSFER_BUF_LEN
+						 + MB_DLC_OFF]);
+		memcpy(frame->data, &buf[i * CAN_TRANSFER_BUF_LEN]
+				 + CAN_HEADER_MAX_LEN, frame->can_dlc);
+
+		priv->net->stats.rx_packets++;
+		priv->net->stats.rx_bytes += frame->can_dlc;
+
+		can_led_event(priv->net, CAN_LED_EVENT_RX);
+
+		netif_rx_ni(skb);
+	}
+
+
+}
+
+static netdev_tx_t apalis_tk1_k20_can_hard_start_xmit(struct sk_buff *skb,
+						      struct net_device *net)
+{
+	struct apalis_tk1_k20_priv *priv = netdev_priv(net);
+
+	if (priv->tx_skb || priv->tx_len) {
+		dev_warn(&net->dev, "hard_xmit called while TX busy\n");
+		return NETDEV_TX_BUSY;
+	}
+
+	if (can_dropped_invalid_skb(net, skb))
+		return NETDEV_TX_OK;
+
+	netif_stop_queue(net);
+	priv->tx_skb = skb;
+	queue_work(priv->wq, &priv->tx_work);
+
+	return NETDEV_TX_OK;
+}
+
+static int apalis_tk1_k20_can_do_set_mode(struct net_device *net,
+					  enum can_mode mode)
+{
+	struct apalis_tk1_k20_priv *priv = netdev_priv(net);
+
+	switch (mode) {
+	case CAN_MODE_START:
+		apalis_tk1_k20_can_clean(net);
+		/* We have to delay work since I/O may sleep */
+		priv->can.state = CAN_STATE_ERROR_ACTIVE;
+		priv->restart_tx = 1;
+		if (priv->can.restart_ms == 0)
+			priv->after_suspend = AFTER_SUSPEND_RESTART;
+		queue_work(priv->wq, &priv->restart_work);
+		break;
+	default:
+		return -EOPNOTSUPP;
+	}
+
+	return 0;
+}
+
+static int apalis_tk1_k20_can_set_normal_mode(struct net_device *net)
+{
+	struct apalis_tk1_k20_priv *priv = netdev_priv(net);
+
+	apalis_tk1_k20_lock(priv->apalis_tk1_k20);
+	/* Enable interrupts */
+	apalis_tk1_k20_reg_rmw(priv->apalis_tk1_k20, APALIS_TK1_K20_CANREG
+			       + APALIS_TK1_K20_CAN_DEV_OFFSET(
+			       priv->pdata->id),
+			       CANCTRL_INTEN, CANCTRL_INTEN);
+
+	if (priv->can.ctrlmode & CAN_CTRLMODE_LOOPBACK) {
+		/* Put device into loopback mode */
+		apalis_tk1_k20_reg_rmw(priv->apalis_tk1_k20,
+				       APALIS_TK1_K20_CANREG
+				       + APALIS_TK1_K20_CAN_DEV_OFFSET(
+				       priv->pdata->id), CANCTRL_MODMASK,
+				       CAN_CTRLMODE_LOOPBACK);
+	} else if (priv->can.ctrlmode & CAN_CTRLMODE_LISTENONLY) {
+		/* Put device into listen-only mode */
+		apalis_tk1_k20_reg_rmw(priv->apalis_tk1_k20,
+				       APALIS_TK1_K20_CANREG
+				       + APALIS_TK1_K20_CAN_DEV_OFFSET(
+				       priv->pdata->id), CANCTRL_MODMASK,
+				       CAN_CTRLMODE_LISTENONLY);
+	} else {
+		/* Put device into normal mode */
+		apalis_tk1_k20_reg_rmw(priv->apalis_tk1_k20,
+				       APALIS_TK1_K20_CANREG
+				       + APALIS_TK1_K20_CAN_DEV_OFFSET(
+				       priv->pdata->id), CANCTRL_MODMASK,
+				       0x00);
+	}
+	apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+	priv->can.state = CAN_STATE_ERROR_ACTIVE;
+	return 0;
+}
+
+static int apalis_tk1_k20_can_do_set_bittiming(struct net_device *net)
+{
+	struct apalis_tk1_k20_priv *priv = netdev_priv(net);
+	struct can_bittiming *bt = &priv->can.bittiming;
+
+	if ((bt->bitrate / APALIS_TK1_CAN_CLK_UNIT) > 0xFF)
+		return -EINVAL;
+
+	apalis_tk1_k20_lock(priv->apalis_tk1_k20);
+	apalis_tk1_k20_reg_write(priv->apalis_tk1_k20,
+				 APALIS_TK1_K20_CAN_BAUD_REG
+				 + APALIS_TK1_K20_CAN_DEV_OFFSET(
+				 priv->pdata->id), (bt->bitrate /
+				 APALIS_TK1_CAN_CLK_UNIT) & 0xFF);
+	apalis_tk1_k20_reg_write(priv->apalis_tk1_k20,
+				 APALIS_TK1_K20_CAN_BIT_1
+				 + APALIS_TK1_K20_CAN_DEV_OFFSET(
+				 priv->pdata->id),
+				 ((bt->sjw & 0x3) << 6) |
+				  ((bt->phase_seg2 & 0x7) << 3) |
+				  (bt->phase_seg1 & 0x7));
+	apalis_tk1_k20_reg_write(priv->apalis_tk1_k20,
+				 APALIS_TK1_K20_CAN_BIT_2
+				 + APALIS_TK1_K20_CAN_DEV_OFFSET(
+				 priv->pdata->id),
+				 (bt->prop_seg & 0x7));
+	apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+	dev_dbg(priv->apalis_tk1_k20->dev, "Setting CAN%d bitrate " \
+		"to %d (0x%X * 6.25kHz)\n", priv->pdata->id, bt->bitrate,
+		(bt->bitrate / APALIS_TK1_CAN_CLK_UNIT) & 0xFF);
+	dev_dbg(priv->apalis_tk1_k20->dev, "Setting CAN%d bit timing " \
+		"RJW = %d, PSEG1 = %d, PSEG2 = %d, PROPSEG = %d\n",
+		priv->pdata->id, bt->sjw, bt->phase_seg1,
+		bt->phase_seg2, bt->prop_seg);
+	dev_dbg(priv->apalis_tk1_k20->dev, "Setting CAN%d bit timing " \
+		"bitrate = %d\n", priv->pdata->id, bt->bitrate);
+
+	return 0;
+}
+
+static int apalis_tk1_k20_can_setup(struct net_device *net,
+				    struct apalis_tk1_k20_priv *priv)
+{
+	apalis_tk1_k20_can_do_set_bittiming(net);
+
+	return 0;
+}
+
+static int apalis_tk1_k20_can_hw_reset(struct net_device *net)
+{
+	return 0;
+}
+
+static void apalis_tk1_k20_can_open_clean(struct net_device *net)
+{
+	struct apalis_tk1_k20_priv *priv = netdev_priv(net);
+	struct apalis_tk1_k20_can_platform_data *pdata = priv->pdata;
+
+	if (pdata->id == 0)
+		apalis_tk1_k20_irq_free(priv->apalis_tk1_k20,
+					APALIS_TK1_K20_CAN0_IRQ, priv);
+	if (pdata->id == 1)
+		apalis_tk1_k20_irq_free(priv->apalis_tk1_k20,
+					APALIS_TK1_K20_CAN1_IRQ, priv);
+	close_candev(net);
+}
+
+static int apalis_tk1_k20_can_stop(struct net_device *net)
+{
+	struct apalis_tk1_k20_priv *priv = netdev_priv(net);
+	struct apalis_tk1_k20_can_platform_data *pdata = priv->pdata;
+
+	close_candev(net);
+
+	priv->force_quit = 1;
+	if (pdata->id == 0)
+		apalis_tk1_k20_irq_free(priv->apalis_tk1_k20,
+					APALIS_TK1_K20_CAN0_IRQ, priv);
+	if (pdata->id == 1)
+		apalis_tk1_k20_irq_free(priv->apalis_tk1_k20,
+					APALIS_TK1_K20_CAN1_IRQ, priv);
+	destroy_workqueue(priv->wq);
+	priv->wq = NULL;
+
+	mutex_lock(&priv->apalis_tk1_k20_can_lock);
+	apalis_tk1_k20_lock(priv->apalis_tk1_k20);
+	if (pdata->id == 0)
+		apalis_tk1_k20_irq_mask(priv->apalis_tk1_k20,
+					APALIS_TK1_K20_CAN0_IRQ);
+	if (pdata->id == 1)
+		apalis_tk1_k20_irq_mask(priv->apalis_tk1_k20,
+					APALIS_TK1_K20_CAN1_IRQ);
+	/* Disable and clear pending interrupts */
+	priv->can.state = CAN_STATE_STOPPED;
+	apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+	mutex_unlock(&priv->apalis_tk1_k20_can_lock);
+
+	can_led_event(net, CAN_LED_EVENT_STOP);
+
+	return 0;
+}
+
+static void apalis_tk1_k20_can_error_skb(struct net_device *net, int can_id,
+					 int data1)
+{
+	struct sk_buff *skb;
+	struct can_frame *frame;
+
+	skb = alloc_can_err_skb(net, &frame);
+	if (skb) {
+		frame->can_id |= can_id;
+		frame->data[1] = data1;
+		netif_rx_ni(skb);
+	} else {
+		netdev_err(net, "cannot allocate error skb\n");
+	}
+}
+
+static void apalis_tk1_k20_can_tx_work_handler(struct work_struct *ws)
+{
+	struct apalis_tk1_k20_priv *priv = container_of(ws,
+			struct apalis_tk1_k20_priv, tx_work);
+	struct net_device *net = priv->net;
+	struct can_frame *frame;
+
+	mutex_lock(&priv->apalis_tk1_k20_can_lock);
+	if (priv->tx_skb) {
+		if (priv->can.state == CAN_STATE_BUS_OFF) {
+			apalis_tk1_k20_can_clean(net);
+		} else {
+			frame = (struct can_frame *)priv->tx_skb->data;
+
+			if (frame->can_dlc > CAN_FRAME_MAX_LEN)
+				frame->can_dlc = CAN_FRAME_MAX_LEN;
+			apalis_tk1_k20_can_hw_tx(net, frame, 0);
+			priv->tx_len = 1 + frame->can_dlc;
+			can_put_echo_skb(priv->tx_skb, net, 0);
+			priv->tx_skb = NULL;
+		}
+	}
+	mutex_unlock(&priv->apalis_tk1_k20_can_lock);
+}
+
+#ifdef CONFIG_PM_SLEEP
+
+static int apalis_tk1_k20_can_suspend(struct device *dev)
+{
+	struct apalis_tk1_k20_priv *priv = dev_get_drvdata(dev);
+	struct apalis_tk1_k20_can_platform_data *pdata = priv->pdata;
+
+	priv->force_quit = 1;
+
+	mutex_lock(&priv->apalis_tk1_k20_can_lock);
+	apalis_tk1_k20_lock(priv->apalis_tk1_k20);
+	if (pdata->id == 0)
+		apalis_tk1_k20_irq_mask(priv->apalis_tk1_k20,
+					APALIS_TK1_K20_CAN0_IRQ);
+	if (pdata->id == 1)
+		apalis_tk1_k20_irq_mask(priv->apalis_tk1_k20,
+					APALIS_TK1_K20_CAN1_IRQ);
+	/* Disable interrupts */
+	apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+	mutex_unlock(&priv->apalis_tk1_k20_can_lock);
+	/* Note: at this point neither IST nor workqueues are running.
+	 * open/stop cannot be called anyway so locking is not needed
+	 */
+	if (netif_running(priv->net)) {
+		netif_device_detach(priv->net);
+
+		priv->after_suspend = AFTER_SUSPEND_UP;
+	} else {
+		priv->after_suspend = AFTER_SUSPEND_DOWN;
+	}
+
+	return 0;
+}
+
+static int apalis_tk1_k20_can_resume(struct device *dev)
+{
+	struct apalis_tk1_k20_priv *priv = dev_get_drvdata(dev);
+	struct apalis_tk1_k20_can_platform_data *pdata = priv->pdata;
+
+	if (priv->after_suspend & AFTER_SUSPEND_UP)
+		queue_work(priv->wq, &priv->restart_work);
+	else
+		priv->after_suspend = 0;
+
+	priv->force_quit = 0;
+	mutex_lock(&priv->apalis_tk1_k20_can_lock);
+	apalis_tk1_k20_lock(priv->apalis_tk1_k20);
+	if (pdata->id == 0)
+		apalis_tk1_k20_irq_unmask(priv->apalis_tk1_k20,
+					  APALIS_TK1_K20_CAN0_IRQ);
+	if (pdata->id == 1)
+		apalis_tk1_k20_irq_unmask(priv->apalis_tk1_k20,
+					  APALIS_TK1_K20_CAN1_IRQ);
+	/* Enable interrupts */
+	priv->can.state = CAN_STATE_STOPPED;
+	apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+	mutex_unlock(&priv->apalis_tk1_k20_can_lock);
+	return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(apalis_tk1_k20_can_pm_ops, apalis_tk1_k20_can_suspend,
+		apalis_tk1_k20_can_resume);
+
+#endif
+
+static void apalis_tk1_k20_can_restart_work_handler(struct work_struct *ws)
+{
+	struct apalis_tk1_k20_priv *priv = container_of(ws,
+			struct apalis_tk1_k20_priv, restart_work);
+	struct net_device *net = priv->net;
+
+	mutex_lock(&priv->apalis_tk1_k20_can_lock);
+	if (priv->after_suspend) {
+		mdelay(10);
+		apalis_tk1_k20_can_hw_reset(net);
+		apalis_tk1_k20_can_setup(net, priv);
+		if (priv->after_suspend & AFTER_SUSPEND_RESTART) {
+			apalis_tk1_k20_can_set_normal_mode(net);
+		} else if (priv->after_suspend & AFTER_SUSPEND_UP) {
+			netif_device_attach(net);
+			apalis_tk1_k20_can_clean(net);
+			apalis_tk1_k20_can_set_normal_mode(net);
+			netif_wake_queue(net);
+		}
+		priv->after_suspend = 0;
+		priv->force_quit = 0;
+	}
+
+	if (priv->restart_tx) {
+		priv->restart_tx = 0;
+		apalis_tk1_k20_can_clean(net);
+		netif_wake_queue(net);
+		apalis_tk1_k20_can_error_skb(net, CAN_ERR_RESTARTED, 0);
+	}
+	mutex_unlock(&priv->apalis_tk1_k20_can_lock);
+}
+
+static irqreturn_t apalis_tk1_k20_can_ist(int irq, void *dev_id)
+{
+	struct apalis_tk1_k20_priv *priv = dev_id;
+	struct net_device *net = priv->net;
+
+	mutex_lock(&priv->apalis_tk1_k20_can_lock);
+	while (!priv->force_quit) {
+		enum can_state new_state = CAN_STATE_ERROR_ACTIVE;
+		int ret;
+		u32 intf, eflag;
+		u8 clear_intf = 0;
+		int can_id = 0, data1 = 0;
+
+		apalis_tk1_k20_lock(priv->apalis_tk1_k20);
+		ret = apalis_tk1_k20_reg_read(priv->apalis_tk1_k20,
+					      APALIS_TK1_K20_CANREG
+					      + APALIS_TK1_K20_CAN_DEV_OFFSET(
+					      priv->pdata->id), &intf);
+		apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+
+		if (ret) {
+			dev_err(&net->dev, "Communication error\n");
+			break;
+		}
+
+		intf &= CANCTRL_INTMASK;
+		/* receive */
+		if (intf & CANINTF_RX)
+			apalis_tk1_k20_can_hw_rx(net, 0);
+
+		/* any error interrupt we need to clear? */
+		if (intf & CANINTF_ERR)
+			clear_intf |= intf & CANINTF_ERR;
+		apalis_tk1_k20_lock(priv->apalis_tk1_k20);
+		if (clear_intf)
+			ret = apalis_tk1_k20_reg_write(priv->apalis_tk1_k20,
+						APALIS_TK1_K20_CANREG_CLR
+						+ APALIS_TK1_K20_CAN_DEV_OFFSET(
+						priv->pdata->id),clear_intf);
+		if (ret) {
+			apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+			dev_err(&net->dev, "Communication error\n");
+			break;
+		}
+
+		/* Update can state */
+		if (intf & CANINTF_ERR) {
+			ret = apalis_tk1_k20_reg_read(priv->apalis_tk1_k20,
+						      APALIS_TK1_K20_CANERR +
+						      APALIS_TK1_K20_CAN_DEV_OFFSET(
+						      priv->pdata->id), &eflag);
+			apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+			if (ret) {
+				dev_err(&net->dev, "Communication error\n");
+				break;
+			}
+			if (eflag & EFLG_TXBO) {
+				new_state = CAN_STATE_BUS_OFF;
+				can_id |= CAN_ERR_BUSOFF;
+			} else if (eflag & EFLG_TXEP) {
+				new_state = CAN_STATE_ERROR_PASSIVE;
+				can_id |= CAN_ERR_CRTL;
+				data1 |= CAN_ERR_CRTL_TX_PASSIVE;
+			} else if (eflag & EFLG_RXEP) {
+				new_state = CAN_STATE_ERROR_PASSIVE;
+				can_id |= CAN_ERR_CRTL;
+				data1 |= CAN_ERR_CRTL_RX_PASSIVE;
+			} else if (eflag & EFLG_TXWAR) {
+				new_state = CAN_STATE_ERROR_WARNING;
+				can_id |= CAN_ERR_CRTL;
+				data1 |= CAN_ERR_CRTL_TX_WARNING;
+			} else if (eflag & EFLG_RXWAR) {
+				new_state = CAN_STATE_ERROR_WARNING;
+				can_id |= CAN_ERR_CRTL;
+				data1 |= CAN_ERR_CRTL_RX_WARNING;
+			} else {
+				new_state = CAN_STATE_ERROR_ACTIVE;
+			}
+		}
+		else {
+			apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+		}
+
+		/* Update can state statistics */
+		switch (priv->can.state) {
+		case CAN_STATE_ERROR_ACTIVE:
+			if (new_state >= CAN_STATE_ERROR_WARNING &&
+			    new_state <= CAN_STATE_BUS_OFF)
+				priv->can.can_stats.error_warning++;
+		case CAN_STATE_ERROR_WARNING: /* fallthrough */
+			if (new_state >= CAN_STATE_ERROR_PASSIVE &&
+			    new_state <= CAN_STATE_BUS_OFF)
+				priv->can.can_stats.error_passive++;
+			break;
+		default:
+			break;
+		}
+		priv->can.state = new_state;
+
+		if (intf & CANINTF_ERR) {
+			/* Handle overflow counters */
+			if (eflag & EFLG_RXOVR) {
+				if (eflag & EFLG_RXOVR) {
+					net->stats.rx_over_errors++;
+					net->stats.rx_errors++;
+				}
+				can_id |= CAN_ERR_CRTL;
+				data1 |= CAN_ERR_CRTL_RX_OVERFLOW;
+			}
+			apalis_tk1_k20_can_error_skb(net, can_id, data1);
+		}
+
+		if (priv->can.state == CAN_STATE_BUS_OFF &&
+		    priv->can.restart_ms == 0) {
+			priv->force_quit = 1;
+			can_bus_off(net);
+			break;
+		}
+
+		if (intf == 0)
+			break;
+
+		if (intf & CANINTF_TX) {
+			net->stats.tx_packets++;
+			net->stats.tx_bytes += priv->tx_len - 1;
+			can_led_event(net, CAN_LED_EVENT_TX);
+			if (priv->tx_len) {
+				can_get_echo_skb(net, 0);
+				priv->tx_len = 0;
+			}
+			netif_wake_queue(net);
+			if (!(intf & (CANINTF_RX | CANINTF_ERR)))
+				break;
+		}
+	}
+	mutex_unlock(&priv->apalis_tk1_k20_can_lock);
+	return IRQ_HANDLED;
+}
+
+static int apalis_tk1_k20_can_open(struct net_device *net)
+{
+	struct apalis_tk1_k20_priv *priv = netdev_priv(net);
+	struct apalis_tk1_k20_can_platform_data *pdata = priv->pdata;
+	int ret;
+
+	ret = open_candev(net);
+	if (ret) {
+		dev_err(&net->dev, "unable to initialize CAN\n");
+		return ret;
+	}
+
+	mutex_lock(&priv->apalis_tk1_k20_can_lock);
+
+	priv->force_quit = 0;
+	priv->tx_skb = NULL;
+	priv->tx_len = 0;
+	apalis_tk1_k20_lock(priv->apalis_tk1_k20);
+	if (pdata->id == 0)
+		ret = apalis_tk1_k20_irq_request(priv->apalis_tk1_k20,
+						 APALIS_TK1_K20_CAN0_IRQ,
+						 apalis_tk1_k20_can_ist,
+						 DEVICE_NAME, priv);
+	if (pdata->id == 1)
+		ret = apalis_tk1_k20_irq_request(priv->apalis_tk1_k20,
+						 APALIS_TK1_K20_CAN1_IRQ,
+						 apalis_tk1_k20_can_ist,
+						 DEVICE_NAME, priv);
+	apalis_tk1_k20_unlock(priv->apalis_tk1_k20);
+	if (ret) {
+		dev_err(&net->dev, "failed to acquire IRQ\n");
+		close_candev(net);
+		goto open_unlock;
+	}
+
+	priv->wq = create_freezable_workqueue("apalis_tk1_k20_wq");
+	INIT_WORK(&priv->tx_work, apalis_tk1_k20_can_tx_work_handler);
+	INIT_WORK(&priv->restart_work, apalis_tk1_k20_can_restart_work_handler);
+
+	ret = apalis_tk1_k20_can_hw_reset(net);
+	if (ret) {
+		apalis_tk1_k20_can_open_clean(net);
+		goto open_unlock;
+	}
+
+	ret = apalis_tk1_k20_can_setup(net, priv);
+	if (ret) {
+		apalis_tk1_k20_can_open_clean(net);
+		goto open_unlock;
+	}
+
+	ret = apalis_tk1_k20_can_set_normal_mode(net);
+	if (ret) {
+		apalis_tk1_k20_can_open_clean(net);
+		goto open_unlock;
+	}
+
+	can_led_event(net, CAN_LED_EVENT_OPEN);
+
+	netif_wake_queue(net);
+
+open_unlock:
+	mutex_unlock(&priv->apalis_tk1_k20_can_lock);
+	return ret;
+}
+
+static const struct net_device_ops apalis_tk1_k20_netdev_ops = {
+		.ndo_open = apalis_tk1_k20_can_open,
+		.ndo_stop = apalis_tk1_k20_can_stop,
+		.ndo_start_xmit = apalis_tk1_k20_can_hard_start_xmit,
+};
+
+static int apalis_tk1_k20_can_probe(struct platform_device *pdev)
+{
+	struct net_device *net;
+	struct apalis_tk1_k20_priv *priv;
+	struct apalis_tk1_k20_can_platform_data *pdata =
+			pdev->dev.platform_data;
+	int ret = -ENODEV;
+
+	if (!pdata) {
+		pdata = kmalloc(sizeof(struct apalis_tk1_k20_can_platform_data),
+				GFP_KERNEL);
+		if (pdev->id == -1)
+			pdata->id = 0;
+		if (pdev->id >= 0 && pdev->id <= K20_CAN_MAX_ID)
+			pdata->id = pdev->id;
+		else
+			goto error_out;
+	}
+
+	if (pdata->id > K20_CAN_MAX_ID)
+		goto error_out;
+	/* Allocate can/net device */
+	net = alloc_candev(sizeof(struct apalis_tk1_k20_priv), TX_ECHO_SKB_MAX);
+	if (!net) {
+		ret = -ENOMEM;
+		goto error_out;
+	}
+
+	net->netdev_ops = &apalis_tk1_k20_netdev_ops;
+	net->flags |= IFF_ECHO;
+
+	priv = netdev_priv(net);
+	priv->can.bittiming_const = &apalis_tk1_k20_can_bittiming_const;
+	priv->can.do_set_mode = apalis_tk1_k20_can_do_set_mode;
+	priv->can.clock.freq = 8000000;
+	priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES |
+			CAN_CTRLMODE_LOOPBACK | CAN_CTRLMODE_LISTENONLY;
+	priv->net = net;
+	priv->pdata = pdata;
+	priv->apalis_tk1_k20 = dev_get_drvdata(pdev->dev.parent);
+
+	mutex_init(&priv->apalis_tk1_k20_can_lock);
+
+	SET_NETDEV_DEV(net, &pdev->dev);
+
+	platform_set_drvdata(pdev, priv);
+
+	ret = register_candev(net);
+	if (ret)
+		goto error_probe;
+
+	devm_can_led_init(net);
+
+	dev_info(&pdev->dev, "probed %d\n", pdev->id);
+
+	return ret;
+
+error_probe:
+	free_candev(net);
+error_out:
+	return ret;
+}
+
+static int apalis_tk1_k20_can_remove(struct platform_device *pdev)
+{
+	struct apalis_tk1_k20_priv *priv = platform_get_drvdata(pdev);
+	struct net_device *net = priv->net;
+
+	unregister_candev(net);
+	free_candev(net);
+
+	return 0;
+}
+
+static const struct platform_device_id apalis_tk1_k20_can_idtable[] = {
+		{.name = "apalis-tk1-k20-can", },
+		{ /* sentinel */}
+};
+
+MODULE_DEVICE_TABLE(platform, apalis_tk1_k20_can_idtable);
+
+static struct platform_driver apalis_tk1_k20_can_driver = {
+		.id_table = apalis_tk1_k20_can_idtable,
+		.remove = apalis_tk1_k20_can_remove,
+		.probe = apalis_tk1_k20_can_probe,
+		.driver = {
+				.name = DEVICE_NAME,
+#ifdef CONFIG_PM_SLEEP
+				.pm = &apalis_tk1_k20_can_pm_ops,
+#endif
+		},
+};
+
+module_platform_driver(apalis_tk1_k20_can_driver);
+
+MODULE_DESCRIPTION("CAN driver for K20 MCU on Apalis TK1");
+MODULE_AUTHOR("Dominik Sliwa <dominik.sliwa@toradex.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/spi/spi-tegra114.c b/drivers/spi/spi-tegra114.c
index 44550182a4a3..329dd49724a1 100644
--- a/drivers/spi/spi-tegra114.c
+++ b/drivers/spi/spi-tegra114.c
@@ -703,12 +703,6 @@ static u32 tegra_spi_setup_transfer_one(struct spi_device *spi,
 		} else
 			tegra_spi_writel(tspi, command1, SPI_COMMAND1);
 
-		command1 |= SPI_CS_SW_HW;
-		if (spi->mode & SPI_CS_HIGH)
-			command1 |= SPI_CS_SS_VAL;
-		else
-			command1 &= ~SPI_CS_SS_VAL;
-
 		tegra_spi_writel(tspi, 0, SPI_COMMAND2);
 	} else {
 		command1 = tspi->command1_reg;
@@ -776,6 +770,7 @@ static int tegra_spi_setup(struct spi_device *spi)
 
 	spin_lock_irqsave(&tspi->lock, flags);
 	val = tspi->def_command1_reg;
+	val |= SPI_CS_SEL(spi->chip_select);
 	if (spi->mode & SPI_CS_HIGH)
 		val &= ~SPI_CS_POL_INACTIVE(spi->chip_select);
 	else
diff --git a/include/linux/mfd/apalis-tk1-k20-api.h b/include/linux/mfd/apalis-tk1-k20-api.h
new file mode 100644
index 000000000000..85bbf9f28ca4
--- /dev/null
+++ b/include/linux/mfd/apalis-tk1-k20-api.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2016-2017 Toradex AG
+ * Dominik Sliwa <dominik.sliwa@toradex.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License version 2 as published by the
+ * Free Software Foundation.
+ */
+
+#ifndef __LINUX_MFD_APALIS_TK1_K20_API_H
+#define __LINUX_MFD_APALIS_TK1_K20_API_H
+
+/* Commands and registers used in SPI communication */
+
+/* Commands*/
+#define APALIS_TK1_K20_READ_INST		0x0F
+#define APALIS_TK1_K20_WRITE_INST		0xF0
+#define APALIS_TK1_K20_BULK_WRITE_INST		0x3C
+#define APALIS_TK1_K20_BULK_READ_INST		0xC3
+
+#define APALIS_TK1_K20_MAX_BULK			250u
+#define APALIS_TK1_K20_HEADER			4u
+
+/* General registers*/
+#define APALIS_TK1_K20_STAREG			0x00 /* general status register RO */
+#define APALIS_TK1_K20_REVREG			0x01 /* FW revision register RO*/
+#define APALIS_TK1_K20_IRQREG			0x02 /* IRQ status RO(reset of read) */
+#define APALIS_TK1_K20_CTRREG			0x03 /* general control register RW */
+#define APALIS_TK1_K20_MSQREG			0x04 /* IRQ mask register RW */
+
+/* 0x05-0x0F Reserved */
+
+/* CAN Registers */
+#define APALIS_TK1_K20_CANREG			0x10 /* CAN0 control & status register RW */
+#define APALIS_TK1_K20_CANREG_CLR		0x11 /* CAN0 CANREG clear register WO */
+#define APALIS_TK1_K20_CANERR			0x12 /* CAN0 error register RW */
+#define APALIS_TK1_K20_CAN_BAUD_REG		0x13 /* CAN0 baud set register RW */
+#define APALIS_TK1_K20_CAN_BIT_1		0x14 /* CAN0 bit timing register 1 RW */
+#define APALIS_TK1_K20_CAN_BIT_2		0x15 /* CAN0 bit timing register 2 RW */
+#define APALIS_TK1_K20_CAN_IN_BUF_CNT		0x16 /* CAN0 IN received data count RO */
+#define APALIS_TK1_K20_CAN_IN_BUF		0x17 /* CAN0 IN RO */
+/* buffer size is 13 bytes */
+#define APALIS_TK1_K20_CAN_IN_BUF_END		0x23 /* CAN0 IN RO */
+#define APALIS_TK1_K20_CAN_OUT_BUF		0x24 /* CAN0 OUT WO */
+/* buffer size is 13 bytes */
+#define APALIS_TK1_K20_CAN_OUT_BUF_END		(APALIS_TK1_K20_CAN_OUT_BUF + 13 - 1)/* CAN OUT BUF END */
+#define APALIS_TK1_K20_CAN_OFFSET		0x30
+#define APALIS_TK1_K20_CAN_DEV_OFFSET(x)	(x ? APALIS_TK1_K20_CAN_OFFSET : 0)
+
+/* 0x30-0x3F Reserved */
+/* 0x40-0x62 CAN1 registers same layout as CAN0*/
+/* 0x63-0x6F Reserved */
+
+/* ADC Registers */
+#define APALIS_TK1_K20_ADCREG			0x70 /* ADC control & status register RW */
+#define APALIS_TK1_K20_ADC_CH0L			0x71 /* ADC Channel 0 LSB RO */
+#define APALIS_TK1_K20_ADC_CH0H			0x72 /* ADC Channel 0 MSB RO */
+#define APALIS_TK1_K20_ADC_CH1L			0x73 /* ADC Channel 1 LSB RO */
+#define APALIS_TK1_K20_ADC_CH1H			0x74 /* ADC Channel 1 MSB RO */
+#define APALIS_TK1_K20_ADC_CH2L			0x75 /* ADC Channel 2 LSB RO */
+#define APALIS_TK1_K20_ADC_CH2H			0x76 /* ADC Channel 2 MSB RO */
+#define APALIS_TK1_K20_ADC_CH3L			0x77 /* ADC Channel 3 LSB RO */
+#define APALIS_TK1_K20_ADC_CH3H			0x78 /* ADC Channel 3 MSB RO */
+/* Bulk read of LSB register can be use to read entire 16-bit in one command */
+/* Bulk read of APALIS_TK1_K20_ADC_CH0L register can be use to read all
+ * ADC channels in one command */
+
+/* 0x79-0x7F reserved */
+
+/* TSC Register */
+#define APALIS_TK1_K20_TSCREG			0x80 /* TSC control & status register RW */
+#define APALIS_TK1_K20_TSC_XML			0x81 /* TSC X- data LSB RO */
+#define APALIS_TK1_K20_TSC_XMH			0x82 /* TSC X- data MSB RO */
+#define APALIS_TK1_K20_TSC_XPL			0x83 /* TSC X+ data LSB RO */
+#define APALIS_TK1_K20_TSC_XPH			0x84 /* TSC X+ data MSB RO */
+#define APALIS_TK1_K20_TSC_YML			0x85 /* TSC Y- data LSB RO */
+#define APALIS_TK1_K20_TSC_YMH			0x86 /* TSC Y- data MSB RO */
+#define APALIS_TK1_K20_TSC_YPL			0x87 /* TSC Y+ data LSB RO */
+#define APALIS_TK1_K20_TSC_YPH			0x88 /* TSC Y+ data MSB RO */
+/* Bulk read of LSB register can be use to read entire 16-bit in one command */
+#define APALIS_TK1_K20_TSC_ENA			BIT(0)
+#define APALIS_TK1_K20_TSC_ENA_MASK		BIT(0)
+
+/* 0x89-0x8F Reserved */
+
+/* GPIO Registers */
+#define APALIS_TK1_K20_GPIOREG			0x90 /* GPIO control & status register RW */
+#define APALIS_TK1_K20_GPIO_NO			0x91 /* currently configured GPIO RW */
+#define APALIS_TK1_K20_GPIO_STA			0x92 /* Status register for the APALIS_TK1_K20_GPIO_NO GPIO RW */
+/* MSB | 0 ... 0 | VALUE | Output-1 / Input-0 | LSB  */
+#define APALIS_TK1_K20_GPIO_STA_OE		BIT(0)
+#define APALIS_TK1_K20_GPIO_STA_VAL		BIT(1)
+
+/* 0x93-0xFC Reserved */
+#define APALIS_TK1_K20_LAST_REG			0xFD
+#define APALIS_TK1_K20_RET_REQ			0xFE
+/* 0xFF Reserved */
+
+/* Interrupt flags */
+#define APALIS_TK1_K20_GEN_IRQ			0
+#define APALIS_TK1_K20_CAN0_IRQ			1
+#define APALIS_TK1_K20_CAN1_IRQ			2
+#define APALIS_TK1_K20_ADC_IRQ			3
+#define APALIS_TK1_K20_TSC_IRQ			4
+#define APALIS_TK1_K20_GPIO_IRQ			5
+
+#define APALIS_TK1_K20_FW_VER			0x10
+
+#define FW_MINOR (APALIS_TK1_K20_FW_VER & 0x0F)
+#define FW_MAJOR ((APALIS_TK1_K20_FW_VER & 0xF0) >> 4)
+
+#define TK1_K20_SENTINEL			0x55
+#define TK1_K20_INVAL				0xAA
+
+#define APALIS_TK1_K20_NUMREGS			0x3f
+#define APALIS_TK1_K20_IRQ_REG_CNT		1
+#define APALIS_TK1_K20_IRQ_PER_REG		8
+
+#define APALIS_TK1_CAN_CLK_UNIT			6250
+
+#define APALIS_TK1_MAX_CAN_DMA_XREF		19u
+
+#endif /* ifndef __LINUX_MFD_APALIS_TK1_K20_API_H */
diff --git a/include/linux/mfd/apalis-tk1-k20.h b/include/linux/mfd/apalis-tk1-k20.h
new file mode 100644
index 000000000000..6d9e42b6002e
--- /dev/null
+++ b/include/linux/mfd/apalis-tk1-k20.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2016-2017 Toradex AG
+ * Dominik Sliwa <dominik.sliwa@toradex.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License version 2 as published by the
+ * Free Software Foundation.
+ */
+
+#ifndef __LINUX_MFD_APALIS_TK1_K20_H
+#define __LINUX_MFD_APALIS_TK1_K20_H
+
+#include <linux/interrupt.h>
+#include <linux/mutex.h>
+#include <linux/regmap.h>
+#include <linux/mfd/apalis-tk1-k20-api.h>
+
+#define APALIS_TK1_MAX_RETRY_CNT		4
+
+#define APALIS_TK1_K20_MAX_SPI_SPEED		6120000
+
+struct apalis_tk1_k20_regmap {
+	struct regmap *regmap;
+
+	struct device *dev;
+
+	struct regmap_irq irqs[APALIS_TK1_K20_IRQ_REG_CNT * APALIS_TK1_K20_IRQ_PER_REG];
+	struct regmap_irq_chip irq_chip;
+	struct regmap_irq_chip_data *irq_data;
+	int can0_irq;
+	int can1_irq;
+
+	struct mutex lock;
+	int irq;
+	int flags;
+
+	int ezpcs_gpio;
+	int reset_gpio;
+	int appcs_gpio;
+	int int2_gpio;
+};
+
+void apalis_tk1_k20_lock(struct apalis_tk1_k20_regmap *apalis_tk1_k20);
+void apalis_tk1_k20_unlock(struct apalis_tk1_k20_regmap *apalis_tk1_k20);
+
+int apalis_tk1_k20_reg_read(struct apalis_tk1_k20_regmap *apalis_tk1_k20, unsigned int offset, u32 *val);
+int apalis_tk1_k20_reg_write(struct apalis_tk1_k20_regmap *apalis_tk1_k20, unsigned int offset, u32 val);
+int apalis_tk1_k20_reg_read_bulk(struct apalis_tk1_k20_regmap *apalis_tk1_k20, unsigned int offset,
+		uint8_t *val, size_t size);
+int apalis_tk1_k20_reg_write_bulk(struct apalis_tk1_k20_regmap *apalis_tk1_k20, unsigned int offset,
+		uint8_t *val, size_t size);
+int apalis_tk1_k20_reg_rmw(struct apalis_tk1_k20_regmap *apalis_tk1_k20, unsigned int offset,
+		u32 mask, u32 val);
+
+int apalis_tk1_k20_irq_mask(struct apalis_tk1_k20_regmap *apalis_tk1_k20, int irq);
+int apalis_tk1_k20_irq_unmask(struct apalis_tk1_k20_regmap *apalis_tk1_k20, int irq);
+int apalis_tk1_k20_irq_request(struct apalis_tk1_k20_regmap *apalis_tk1_k20, int irq,
+		irq_handler_t handler, const char *name, void *dev);
+int apalis_tk1_k20_irq_free(struct apalis_tk1_k20_regmap *apalis_tk1_k20, int irq, void *dev);
+
+int apalis_tk1_k20_irq_status(struct apalis_tk1_k20_regmap *apalis_tk1_k20, int irq,
+		int *enabled, int *pending);
+
+int apalis_tk1_k20_get_flags(struct apalis_tk1_k20_regmap *apalis_tk1_k20);
+
+struct apalis_tk1_k20_can_platform_data {
+	uint8_t id;
+	u16 status;
+};
+
+struct apalis_tk1_k20_tsc_platform_data {
+	u16 status;
+};
+
+struct apalis_tk1_k20_adc_platform_data {
+	u16 status;
+};
+
+struct apalis_tk1_k20_gpio_platform_data {
+	u16 status;
+};
+
+#define APALIS_TK1_K20_USES_TSC		BIT(0)
+#define APALIS_TK1_K20_USES_ADC		BIT(1)
+#define APALIS_TK1_K20_USES_CAN		BIT(2)
+#define APALIS_TK1_K20_USES_GPIO	BIT(3)
+
+struct apalis_tk1_k20_platform_data {
+	unsigned int flags;
+
+	struct apalis_tk1_k20_tsc_platform_data touch;
+	struct apalis_tk1_k20_adc_platform_data adc;
+	struct apalis_tk1_k20_can_platform_data can0;
+	struct apalis_tk1_k20_can_platform_data can1;
+	struct apalis_tk1_k20_gpio_platform_data gpio;
+
+	int ezpcs_gpio;
+	int reset_gpio;
+	int appcs_gpio;
+	int int2_gpio;
+};
+
+#define APALIS_TK1_K20_ADC_CHANNELS	4
+#define APALIS_TK1_K20_ADC_BITS		16
+#define APALIS_TK1_K20_VADC_MILI	3300
+
+enum apalis_tk1_k20_adc_id {
+	APALIS_TK1_K20_ADC1,
+	APALIS_TK1_K20_ADC2,
+	APALIS_TK1_K20_ADC3,
+	APALIS_TK1_K20_ADC4
+};
+
+#endif /* ifndef __LINUX_MFD_APALIS_TK1_K20_H */
-- 
2.14.4