mach-ux500: Add mmio device files and device

Updates board_mop500.c  so that mmio driver can obtain gpio
config from platform
Adds sensor clock configuration to board specific file.
Adds support for impplementing different power cycling schemes for
primary and secondary camera sensors.

Signed-off-by: Robert Marklund <robert.marklund@stericsson.com>

6 files changed, 520 insertions, 1 deletions

diff --git a/arch/arm/mach-ux500/Makefile b/arch/arm/mach-ux500/Makefile
index 2d13aa051fc..b065d2b57ca 100644
--- a/arch/arm/mach-ux500/Makefile
+++ b/arch/arm/mach-ux500/Makefile
@@ -26,6 +26,7 @@ obj-$(CONFIG_MACH_U8500)	+= board-mop500.o board-mop500-sdi.o \
 obj-$(CONFIG_MACH_U5500)	+= board-u5500.o board-u5500-sdi.o \
 				   board-u5500-mcde.o board-u5500-regulators.o \
 				   board-u5500-pins.o
+obj-$(CONFIG_U8500_MMIO)	+= board-mop500-mmio.o
 obj-$(CONFIG_SMP)		+= platsmp.o headsmp.o
 obj-$(CONFIG_HOTPLUG_CPU)	+= hotplug.o
 obj-$(CONFIG_LOCAL_TIMERS)	+= localtimer.o
diff --git a/arch/arm/mach-ux500/board-mop500-mmio.c b/arch/arm/mach-ux500/board-mop500-mmio.c
new file mode 100644
index 00000000000..762ac2553bc
--- /dev/null
+++ b/arch/arm/mach-ux500/board-mop500-mmio.c
@@ -0,0 +1,510 @@
+/*
+ * Copyright (C) 2011 ST-Ericsson
+ * Author: Joakim Axelsson <joakim.axelsson@stericsson.com> for ST-Ericsson
+ * Author: Rajat Verma <rajat.verma@stericsson.com> for ST-Ericsson.
+ *
+ * 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/types.h>
+#include <linux/kernel.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/regulator/consumer.h>
+#include <linux/vmalloc.h>
+#include <asm/mach-types.h>
+#include <plat/pincfg.h>
+#include <mach/gpio.h>
+#include <mach/devices.h>
+#include <mach/hardware.h>
+
+#include "pins-db8500.h"
+#include "pins.h"
+#include "board-mop500.h"
+#include "../drivers/staging/mmio/mmio.h"
+
+static pin_cfg_t i2c2_pins[] = {
+	GPIO8_I2C2_SDA,
+	GPIO9_I2C2_SCL
+};
+static pin_cfg_t ipi2c_pins[] = {
+	GPIO8_IPI2C_SDA,
+	GPIO9_IPI2C_SCL
+};
+static pin_cfg_t i2c_disable_pins[] = {
+	GPIO8_GPIO,
+	GPIO9_GPIO
+};
+static pin_cfg_t xshutdown_host[] = {
+	GPIO141_GPIO,
+	GPIO142_GPIO
+};
+static pin_cfg_t xshutdown_fw[] = {
+	GPIO141_IP_GPIO2,
+	GPIO142_IP_GPIO3
+};
+static pin_cfg_t xshutdown_disable[] = {
+	GPIO141_GPIO,
+	GPIO142_GPIO
+};
+
+struct mmio_board_data{
+	int number_of_regulators;
+	struct regulator **mmio_regulators;
+	/* Pin configs  */
+	int xenon_charge;
+	struct mmio_gpio xshutdown_pins[CAMERA_SLOT_END];
+	/* Internal clocks */
+	struct clk *clk_ptr_bml;
+	struct clk *clk_ptr_ipi2c;
+	/* External clocks */
+	struct clk *clk_ptr_ext[CAMERA_SLOT_END];
+};
+
+/* Fill names of regulators required for powering up the
+ * camera sensor in below array */
+static char *regulator_names[] = {"v-mmio-camera" , "v-ana"};
+
+/* This function is used to translate the physical GPIO used for reset GPIO
+ * to logical IPGPIO that needs to be communicated to Firmware. so that
+ * firmware can control reset GPIO of a RAW Bayer sensor */
+static int mmio_get_ipgpio(struct mmio_platform_data *pdata, int gpio,
+			   int *ip_gpio)
+{
+	int err = 0;
+	dev_dbg(pdata->dev, "%s() : IPGPIO requested for %d", __func__, gpio);
+	switch (gpio) {
+	case 67:
+	case 140:
+		*ip_gpio = 7;
+		break;
+	case 5:
+	case 66:
+		*ip_gpio = 6;
+		break;
+	case 81:
+	case 65:
+		*ip_gpio = 5;
+		break;
+	case 80:
+	case 64:
+		*ip_gpio = 4;
+		break;
+	case 10:
+	case 79:
+	case 142:
+		*ip_gpio = 3;
+		break;
+	case 11:
+	case 78:
+	case 141:
+		*ip_gpio = 2;
+		break;
+	case 7:
+	case 150:
+		*ip_gpio = 1;
+		break;
+	case 6:
+	case 149:
+		*ip_gpio = 0;
+		break;
+	default:
+		*ip_gpio = -1;
+		err = -1;
+		break;
+	}
+	return err;
+}
+
+static int mmio_clock_init(struct mmio_platform_data *pdata)
+{
+	int err;
+	struct mmio_board_data *extra = pdata->extra;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+
+	extra->clk_ptr_bml = clk_get_sys("bml", NULL);
+	if (IS_ERR(extra->clk_ptr_bml)) {
+		err = PTR_ERR(extra->clk_ptr_bml);
+		dev_err(pdata->dev, "Error %d getting clock 'bml'\n", err);
+		goto err_bml_clk;
+	}
+	extra->clk_ptr_ipi2c = clk_get_sys("ipi2", NULL);
+	if (IS_ERR(extra->clk_ptr_ipi2c)) {
+		err = PTR_ERR(extra->clk_ptr_ipi2c);
+		dev_err(pdata->dev, "Error %d getting clock 'ipi2'\n", err);
+		goto err_ipi2c_clk;
+	}
+	extra->clk_ptr_ext[PRIMARY_CAMERA] = clk_get_sys("pri-cam", NULL);
+	if (IS_ERR(extra->clk_ptr_ext[PRIMARY_CAMERA])) {
+		err = PTR_ERR(extra->clk_ptr_ext[PRIMARY_CAMERA]);
+		dev_err(pdata->dev, "Error %d getting clock 'pri-cam'\n", err);
+		goto err_pri_ext_clk;
+	}
+	extra->clk_ptr_ext[SECONDARY_CAMERA] = clk_get_sys("sec-cam", NULL);
+	if (IS_ERR(extra->clk_ptr_ext[SECONDARY_CAMERA])) {
+		err = PTR_ERR(extra->clk_ptr_ext[SECONDARY_CAMERA]);
+		dev_err(pdata->dev, "Error %d getting clock 'sec-cam'\n", err);
+		goto err_sec_ext_clk;
+	}
+	dev_dbg(pdata->dev , "Board %s() Exit\n", __func__);
+	return 0;
+err_sec_ext_clk:
+	clk_put(extra->clk_ptr_ext[PRIMARY_CAMERA]);
+err_pri_ext_clk:
+	clk_put(extra->clk_ptr_ipi2c);
+err_ipi2c_clk:
+	clk_put(extra->clk_ptr_bml);
+err_bml_clk:
+	return err;
+}
+static void mmio_clock_exit(struct mmio_platform_data *pdata)
+{
+	struct mmio_board_data *extra = pdata->extra;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+	clk_put(extra->clk_ptr_bml);
+	clk_put(extra->clk_ptr_ipi2c);
+	clk_put(extra->clk_ptr_ext[PRIMARY_CAMERA]);
+	clk_put(extra->clk_ptr_ext[SECONDARY_CAMERA]);
+}
+
+
+static int mmio_pin_cfg_init(struct mmio_platform_data *pdata)
+{
+	int err;
+	struct mmio_board_data *extra = pdata->extra;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+
+	extra->xshutdown_pins[PRIMARY_CAMERA].gpio = XSHUTDOWN_PRIMARY_SENSOR;
+	extra->xshutdown_pins[PRIMARY_CAMERA].active_high = 0;
+	extra->xshutdown_pins[PRIMARY_CAMERA].udelay = 500;
+
+	extra->xshutdown_pins[SECONDARY_CAMERA].active_high = 0;
+	extra->xshutdown_pins[SECONDARY_CAMERA].udelay = 500;
+
+	/* Update GPIO mappings according to board */
+	if (machine_is_hrefv60()) {
+		extra->xenon_charge = HREFV60_MMIO_XENON_CHARGE;
+		xshutdown_host[SECONDARY_CAMERA] = GPIO140_GPIO;
+		xshutdown_fw[SECONDARY_CAMERA] = GPIO140_IP_GPIO7;
+		xshutdown_disable[SECONDARY_CAMERA] = GPIO140_GPIO;
+		extra->xshutdown_pins[SECONDARY_CAMERA].gpio = 140;
+	} else {
+		extra->xenon_charge = GPIO_MMIO_XENON_CHARGE;
+		xshutdown_host[SECONDARY_CAMERA] = GPIO142_GPIO;
+		xshutdown_fw[SECONDARY_CAMERA] = GPIO142_IP_GPIO3;
+		xshutdown_disable[SECONDARY_CAMERA] = GPIO142_GPIO;
+		extra->xshutdown_pins[SECONDARY_CAMERA].gpio = 142;
+	}
+	/* Setup Xenon Charge */
+	err = gpio_request(extra->xenon_charge, "xenon charge");
+	if (err) {
+		dev_err(pdata->dev, "Error %d while requesting xenon charge\n",
+			err);
+		goto err_xenon_gpio_req;
+	}
+	err = gpio_direction_output(extra->xenon_charge, 0);
+	if (err) {
+		dev_err(pdata->dev, "Error %d while setting xenon charge in"
+			"output mode\n", err);
+		goto err_xenon_gpio_set_dir;
+	}
+	dev_dbg(pdata->dev , "Board %s() Exit\n", __func__);
+	return 0;
+err_xenon_gpio_set_dir:
+	gpio_free(extra->xenon_charge);
+err_xenon_gpio_req:
+	return err;
+}
+
+static void mmio_pin_cfg_exit(struct mmio_platform_data *pdata)
+{
+	struct mmio_board_data *extra = pdata->extra;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+	gpio_free(extra->xenon_charge);
+}
+
+/* For now, both sensors on HREF have some power up sequence. If different
+ * sequences are needed for primary and secondary sensors, it can be
+ * implemented easily. Just use camera_slot field of mmio_platform_data
+ * to determine which camera needs to be powered up */
+static int mmio_power_init(struct mmio_platform_data *pdata)
+{
+	int err = 0, i = 0;
+	struct mmio_board_data *extra = pdata->extra;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+	extra->number_of_regulators = sizeof(regulator_names)/
+					sizeof(regulator_names[0]);
+	extra->mmio_regulators =
+	    kzalloc(sizeof(struct regulator *) * extra->number_of_regulators,
+		    GFP_KERNEL);
+	if (!extra->mmio_regulators) {
+		dev_err(pdata->dev , "Error while allocating memory for mmio"
+				"regulators\n");
+		err = -ENOMEM;
+		goto err_no_mem_reg;
+	}
+	for (i = 0; i <
+		extra->number_of_regulators; i++) {
+		extra->mmio_regulators[i] =
+			regulator_get(pdata->dev, regulator_names[i]);
+		if (IS_ERR(extra->mmio_regulators[i])) {
+			err = PTR_ERR(extra->mmio_regulators[i]);
+			dev_err(pdata->dev , "Error %d getting regulator '%s'"
+			"\n", err, regulator_names[i]);
+			goto err_regulator;
+		}
+	}
+	dev_dbg(pdata->dev , "Board %s() Exit\n", __func__);
+	return 0;
+err_regulator:
+	/* Return regulators we have already requested */
+	while (i--)
+		regulator_put(extra->mmio_regulators[i]);
+	kfree(extra->mmio_regulators);
+err_no_mem_reg:
+	return err;
+}
+static void mmio_power_exit(struct mmio_platform_data *pdata)
+{
+	int i = 0;
+	struct mmio_board_data *extra = pdata->extra;;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+	for (i = 0; i < extra->number_of_regulators; i++)
+		regulator_put(extra->mmio_regulators[i]);
+	kfree(extra->mmio_regulators);
+}
+
+static int mmio_platform_init(struct mmio_platform_data *pdata)
+{
+	int err = 0;
+	struct mmio_board_data *extra = NULL;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+	/* Alloc memory for our own extra data */
+	extra = kzalloc(sizeof(struct mmio_board_data), GFP_KERNEL);
+	if (!extra) {
+		dev_err(pdata->dev, "%s: memory alloc failed for "
+		"mmio_board_data\n", __func__);
+		err = -ENOMEM;
+		goto err_no_mem_extra;
+	}
+	/* Hook the data for other callbacks to use */
+	pdata->extra = extra;
+
+	pdata->camera_slot = -1;
+
+	err = mmio_power_init(pdata);
+	if (err)
+		goto err_regulator;
+	err = mmio_clock_init(pdata);
+	if (err)
+		goto err_clock;
+	err = mmio_pin_cfg_init(pdata);
+	if (err)
+		goto err_pin_cfg;
+	/* Store logical IPGPIO for physical reset GPIOs used */
+	err = mmio_get_ipgpio(pdata,
+		extra->xshutdown_pins[PRIMARY_CAMERA].gpio,
+		&(pdata->reset_ipgpio[PRIMARY_CAMERA]));
+	if (err) {
+		dev_err(pdata->dev, "Error getting ipgpio for pri cam\n");
+		goto err_ipgpio;
+	}
+	err = mmio_get_ipgpio(pdata,
+		extra->xshutdown_pins[SECONDARY_CAMERA].gpio,
+		&(pdata->reset_ipgpio[SECONDARY_CAMERA]));
+	if (err) {
+		dev_err(pdata->dev, "Error getting ipgpio for sec cam\n");
+		goto err_ipgpio;
+	}
+	dev_dbg(pdata->dev , "Board %s() Exit\n", __func__);
+	return 0;
+err_ipgpio:
+	mmio_pin_cfg_exit(pdata);
+err_pin_cfg:
+	mmio_clock_exit(pdata);
+err_clock:
+	mmio_power_exit(pdata);
+err_regulator:
+	kfree(extra);
+err_no_mem_extra:
+	return err;
+}
+static void mmio_platform_exit(struct mmio_platform_data *pdata)
+{
+	struct mmio_board_data *extra = pdata->extra;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+	mmio_power_exit(pdata);
+	mmio_clock_exit(pdata);
+	mmio_pin_cfg_exit(pdata);
+	kfree(extra);
+	pdata->extra = NULL;
+}
+
+static int mmio_power_enable(struct mmio_platform_data *pdata)
+{
+	int err = 0, i = 0;
+	struct mmio_board_data *extra = pdata->extra;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+	/* Enable the regulators */
+	for (i = 0; i < extra->number_of_regulators; i++) {
+		err = regulator_enable(extra->mmio_regulators[i]);
+		if (IS_ERR(extra->mmio_regulators[i])) {
+			err = PTR_ERR(extra->mmio_regulators[i]);
+			dev_err(pdata->dev , "Error %d enabling regulator '%s'"
+			"\n", err, regulator_names[i]);
+			goto err_regulator;
+		}
+	}
+	/* Set Xenon Charge */
+	gpio_set_value(extra->xenon_charge, 1);
+	dev_dbg(pdata->dev , "Board %s() Exit\n", __func__);
+	return 0;
+err_regulator:
+	/* Disable regulators we already enabled */
+	while (i--)
+		regulator_disable(extra->mmio_regulators[i]);
+	return err;
+}
+
+static void mmio_power_disable(struct mmio_platform_data *pdata)
+{
+	int i;
+	struct mmio_board_data *extra = pdata->extra;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+	/* Disable the regulators */
+	for (i = 0; i < extra->number_of_regulators; i++)
+		regulator_disable(extra->mmio_regulators[i]);
+	/* Disable Xenon Charge */
+	gpio_set_value(extra->xenon_charge, 0);
+}
+static int mmio_clock_enable(struct mmio_platform_data *pdata)
+{
+	int err = 0;
+	struct mmio_board_data *extra = pdata->extra;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+	/* Enable internal clocks */
+	err = clk_enable(extra->clk_ptr_bml);
+	if (err) {
+		dev_err(pdata->dev, "Error activating bml clock %d\n", err);
+		goto err_bml_clk;
+	}
+	err = clk_enable(extra->clk_ptr_ipi2c);
+	if (err) {
+		dev_err(pdata->dev, "Error activating i2c2 clock %d\n", err);
+		goto err_ipi2c_clk;
+	}
+	/* Enable appropriate external clock */
+	err = clk_enable(extra->clk_ptr_ext[pdata->camera_slot]);
+	if (err) {
+		dev_err(pdata->dev, "Error activating clock for sensor %d, err"
+			"%d\n", pdata->camera_slot, err);
+		goto err_ext_clk;
+	}
+	dev_dbg(pdata->dev , "Board %s() Exit\n", __func__);
+	return 0;
+err_ext_clk:
+	clk_disable(extra->clk_ptr_ipi2c);
+err_ipi2c_clk:
+	clk_disable(extra->clk_ptr_bml);
+err_bml_clk:
+	return err;
+}
+
+static void mmio_clock_disable(struct mmio_platform_data *pdata)
+{
+	struct mmio_board_data *extra = pdata->extra;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+	clk_disable(extra->clk_ptr_bml);
+	clk_disable(extra->clk_ptr_ipi2c);
+	clk_disable(extra->clk_ptr_ext[pdata->camera_slot]);
+}
+
+
+static int mmio_config_xshutdown_pins(struct mmio_platform_data *pdata,
+				      enum mmio_select_xshutdown_t select,
+				      int is_active_high)
+{
+	int err = 0;
+	struct mmio_board_data *extra = pdata->extra;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+	switch (select) {
+	case MMIO_ENABLE_XSHUTDOWN_HOST:
+		extra->xshutdown_pins[pdata->camera_slot].active_high =
+			is_active_high;
+		err = nmk_config_pin(xshutdown_host[pdata->camera_slot] |
+			(is_active_high ? PIN_OUTPUT_LOW : PIN_OUTPUT_HIGH),
+			0);
+		break;
+	case MMIO_ENABLE_XSHUTDOWN_FW:
+		err = nmk_config_pin(xshutdown_fw[pdata->camera_slot], 0);
+		break;
+	case MMIO_DISABLE_XSHUTDOWN:
+		err = nmk_config_pin(xshutdown_disable[pdata->camera_slot],
+			0);
+		break;
+	default:
+		break;
+	}
+	if (err)
+		dev_dbg(pdata->dev , "Error configuring xshutdown, err = %d\n",
+		err);
+	return err;
+}
+static void mmio_set_xshutdown(struct mmio_platform_data *pdata)
+{
+	struct mmio_board_data *extra = pdata->extra;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+	gpio_set_value(extra->xshutdown_pins[pdata->camera_slot].gpio ,
+		(extra->xshutdown_pins[pdata->camera_slot].active_high ? 1 :
+		0));
+	udelay(extra->xshutdown_pins[pdata->camera_slot].udelay);
+}
+static int mmio_config_i2c_pins(struct mmio_platform_data *pdata,
+				enum mmio_select_i2c_t select)
+{
+	int err = 0;
+	dev_dbg(pdata->dev , "Board %s() Enter\n", __func__);
+	switch (select) {
+	case MMIO_ACTIVATE_I2C_HOST:
+		err = nmk_config_pins(i2c2_pins, ARRAY_SIZE(i2c2_pins));
+		break;
+	case MMIO_ACTIVATE_IPI2C2:
+		err = nmk_config_pins(ipi2c_pins, ARRAY_SIZE(ipi2c_pins));
+		break;
+	case MMIO_DEACTIVATE_I2C:
+		err = nmk_config_pins(i2c_disable_pins,
+			ARRAY_SIZE(i2c_disable_pins));
+		break;
+	default:
+		break;
+	}
+
+	return err;
+}
+static struct mmio_platform_data mmio_config = {
+	.platform_init = mmio_platform_init,
+	.platform_exit = mmio_platform_exit,
+	.power_enable = mmio_power_enable,
+	.power_disable = mmio_power_disable,
+	.clock_enable = mmio_clock_enable,
+	.clock_disable = mmio_clock_disable,
+	.config_i2c_pins = mmio_config_i2c_pins,
+	.config_xshutdown_pins = mmio_config_xshutdown_pins,
+	.set_xshutdown = mmio_set_xshutdown,
+	.sia_base = U8500_SIA_BASE,
+	.cr_base = U8500_CR_BASE
+};
+
+struct platform_device ux500_mmio_device = {
+	.name = MMIO_NAME,
+	.id = -1,
+	.dev = {
+		.platform_data = &mmio_config,
+	}
+};
diff --git a/arch/arm/mach-ux500/board-mop500-pins.c b/arch/arm/mach-ux500/board-mop500-pins.c
index 13736c8560a..0a79b58a8d1 100644
--- a/arch/arm/mach-ux500/board-mop500-pins.c
+++ b/arch/arm/mach-ux500/board-mop500-pins.c
@@ -127,7 +127,6 @@ static pin_cfg_t mop500_pins_hrefv60[] = {
 	/* XENON Flashgun INTERFACE */
 	GPIO6_IP_GPIO0	| PIN_INPUT_PULLUP,/* XENON_FLASH_ID */
 	GPIO7_IP_GPIO1	| PIN_INPUT_PULLUP,/* XENON_READY */
-	GPIO170_GPIO	| PIN_OUTPUT_LOW, /* XENON_CHARGE */
 
 	/* Assistant LED INTERFACE */
 	GPIO21_GPIO | PIN_OUTPUT_LOW,  /* XENON_EN1 */
diff --git a/arch/arm/mach-ux500/board-mop500.c b/arch/arm/mach-ux500/board-mop500.c
index 2383cb3f6e8..b7c5375fbf5 100644
--- a/arch/arm/mach-ux500/board-mop500.c
+++ b/arch/arm/mach-ux500/board-mop500.c
@@ -643,6 +643,9 @@ static struct hsi_board_info __initdata u8500_hsi_devices[] = {
 /* add any platform devices here - TODO */
 static struct platform_device *mop500_platform_devs[] __initdata = {
 	&u8500_shrm_device,
+#ifdef CONFIG_U8500_MMIO
+	&ux500_mmio_device,
+#endif
 	&ux500_hwmem_device,
 	&u8500_mcde_device,
 	&u8500_b2r2_device,
diff --git a/arch/arm/mach-ux500/board-mop500.h b/arch/arm/mach-ux500/board-mop500.h
index 8e9285b3741..08869354bcf 100644
--- a/arch/arm/mach-ux500/board-mop500.h
+++ b/arch/arm/mach-ux500/board-mop500.h
@@ -27,6 +27,10 @@
 #define HREFV60_MAGNET_DRDY_GPIO	32
 #define HREFV60_DISP1_RST_GPIO		65
 #define HREFV60_DISP2_RST_GPIO		66
+#define HREFV60_MMIO_XENON_CHARGE 	170
+#define HREFV60_XSHUTDOWN_SECONDARY_SENSOR 140
+#define XSHUTDOWN_PRIMARY_SENSOR 	141
+#define XSHUTDOWN_SECONDARY_SENSOR 	142
 
 /* MOP500 generic GPIOs */
 #define MOP500_HDMI_RST_GPIO		196
@@ -35,6 +39,7 @@
 #define MOP500_EGPIO(x)			(NOMADIK_NR_GPIO + (x))
 #define GPIO_MAGNET_DRDY		MOP500_EGPIO(1)
 #define GPIO_SDMMC_CD			MOP500_EGPIO(3)
+#define GPIO_MMIO_XENON_CHARGE 		MOP500_EGPIO(5)
 #define GPIO_PROX_SENSOR		MOP500_EGPIO(7)
 #define GPIO_HAL_SENSOR			MOP500_EGPIO(8)
 #define GPIO_ACCEL_INT1			MOP500_EGPIO(10)
diff --git a/arch/arm/mach-ux500/include/mach/devices.h b/arch/arm/mach-ux500/include/mach/devices.h
index a1ae8a2a702..33d29990680 100644
--- a/arch/arm/mach-ux500/include/mach/devices.h
+++ b/arch/arm/mach-ux500/include/mach/devices.h
@@ -30,6 +30,7 @@ extern struct platform_device u8500_thsens_device;
 extern struct platform_device u8500_dma40_device;
 extern struct platform_device ux500_ske_keypad_device;
 extern struct platform_device u8500_hsi_device;
+extern struct platform_device ux500_mmio_device;
 
 void dma40_u8500ed_fixup(void);