*  publishhed by the Free Software Foundation.
  */
 #include <linux/gpio.h>
+#include <linux/gpio-pxa.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
        GPIO121_KP_MKIN4,
 };
 
+static struct pxa_gpio_platform_data pxa168_gpio_pdata = {
+       .irq_base       = MMP_GPIO_TO_IRQ(0),
+};
+
 static struct smc91x_platdata smc91x_info = {
        .flags  = SMC91X_USE_16BIT | SMC91X_NOWAIT,
 };
        pxa168_add_nand(&aspenite_nand_info);
        pxa168_add_fb(&aspenite_lcd_info);
        pxa168_add_keypad(&aspenite_keypad_info);
+       platform_device_add_data(&pxa168_device_gpio, &pxa168_gpio_pdata,
+                                sizeof(struct pxa_gpio_platform_data));
        platform_device_register(&pxa168_device_gpio);
 
        /* off-chip devices */
 
 
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/gpio-pxa.h>
 #include <linux/platform_device.h>
 
 #include <asm/mach-types.h>
        GPIO89_UART2_RXD,
 };
 
+static struct pxa_gpio_platform_data pxa168_gpio_pdata = {
+       .irq_base       = MMP_GPIO_TO_IRQ(0),
+};
+
 static void __init avengers_lite_init(void)
 {
        mfp_config(ARRAY_AND_SIZE(avengers_lite_pin_config_V16F));
 
        /* on-chip devices */
        pxa168_add_uart(2);
+       platform_device_add_data(&pxa168_device_gpio, &pxa168_gpio_pdata,
+                                sizeof(struct pxa_gpio_platform_data));
        platform_device_register(&pxa168_device_gpio);
 }
 
 
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
+#include <linux/gpio-pxa.h>
 #include <linux/regulator/machine.h>
 #include <linux/regulator/max8649.h>
 #include <linux/regulator/fixed.h>
        GPIO89_GPIO,
 };
 
+static struct pxa_gpio_platform_data mmp2_gpio_pdata = {
+       .irq_base       = MMP_GPIO_TO_IRQ(0),
+};
+
 static struct regulator_consumer_supply max8649_supply[] = {
        REGULATOR_SUPPLY("vcc_core", NULL),
 };
        /* on-chip devices */
        mmp2_add_uart(1);
        mmp2_add_uart(3);
+       platform_device_add_data(&mmp2_device_gpio, &mmp2_gpio_pdata,
+                                sizeof(struct pxa_gpio_platform_data));
        platform_device_register(&mmp2_device_gpio);
        mmp2_add_twsi(1, NULL, ARRAY_AND_SIZE(brownstone_twsi1_info));
        mmp2_add_sdhost(0, &mmp2_sdh_platdata_mmc0); /* SD/MMC */
 
 #include <linux/smc91x.h>
 #include <linux/io.h>
 #include <linux/gpio.h>
+#include <linux/gpio-pxa.h>
 #include <linux/interrupt.h>
 
 #include <asm/mach-types.h>
        GPIO160_ND_RDY1,
 };
 
+static struct pxa_gpio_platform_data mmp2_gpio_pdata = {
+       .irq_base       = MMP_GPIO_TO_IRQ(0),
+};
+
 static struct smc91x_platdata flint_smc91x_info = {
        .flags  = SMC91X_USE_16BIT | SMC91X_NOWAIT,
 };
        /* on-chip devices */
        mmp2_add_uart(1);
        mmp2_add_uart(2);
+       platform_device_add_data(&mmp2_device_gpio, &mmp2_gpio_pdata,
+                                sizeof(struct pxa_gpio_platform_data));
        platform_device_register(&mmp2_device_gpio);
 
        /* off-chip devices */
 
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/gpio.h>
+#include <linux/gpio-pxa.h>
 
 #include <asm/mach/arch.h>
 #include <asm/mach-types.h>
        GPIO116_I2S_TXD
 };
 
+static struct pxa_gpio_platform_data pxa168_gpio_pdata = {
+       .irq_base       = MMP_GPIO_TO_IRQ(0),
+};
+
 static struct i2c_board_info gplugd_i2c_board_info[] = {
        {
                .type = "isl1208",
        pxa168_add_uart(3);
        pxa168_add_ssp(1);
        pxa168_add_twsi(0, NULL, ARRAY_AND_SIZE(gplugd_i2c_board_info));
+       platform_device_add_data(&pxa168_device_gpio, &pxa168_gpio_pdata,
+                                sizeof(struct pxa_gpio_platform_data));
        platform_device_register(&pxa168_device_gpio);
 
        pxa168_add_eth(&gplugd_eth_platform_data);
 
 
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/gpio-pxa.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
 #include <linux/regulator/machine.h>
        GPIO151_MMC3_CLK,
 };
 
+static struct pxa_gpio_platform_data mmp2_gpio_pdata = {
+       .irq_base       = MMP_GPIO_TO_IRQ(0),
+};
+
 static struct regulator_consumer_supply max8649_supply[] = {
        REGULATOR_SUPPLY("vcc_core", NULL),
 };
        mmp2_add_uart(1);
        mmp2_add_uart(3);
        mmp2_add_twsi(1, NULL, ARRAY_AND_SIZE(jasper_twsi1_info));
+       platform_device_add_data(&mmp2_device_gpio, &mmp2_gpio_pdata,
+                                sizeof(struct pxa_gpio_platform_data));
+       platform_device_register(&mmp2_device_gpio);
        mmp2_add_sdhost(0, &mmp2_sdh_platdata_mmc0); /* SD/MMC */
 
        regulator_has_full_constraints();
 
  *  publishhed by the Free Software Foundation.
  */
 #include <linux/gpio.h>
+#include <linux/gpio-pxa.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
        DF_RDY0_DF_RDY0,
 };
 
+static struct pxa_gpio_platform_data pxa910_gpio_pdata = {
+       .irq_base       = MMP_GPIO_TO_IRQ(0),
+};
+
 static struct smc91x_platdata tavorevb_smc91x_info = {
        .flags  = SMC91X_USE_16BIT | SMC91X_NOWAIT,
 };
 
        /* on-chip devices */
        pxa910_add_uart(1);
+       platform_device_add_data(&pxa910_device_gpio, &pxa910_gpio_pdata,
+                                sizeof(struct pxa_gpio_platform_data));
        platform_device_register(&pxa910_device_gpio);
 
        /* off-chip devices */
 
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
 #include <linux/gpio.h>
+#include <linux/gpio-pxa.h>
 #include <linux/input.h>
 #include <linux/platform_data/keypad-pxa27x.h>
 #include <linux/i2c.h>
        GPIO78_GPIO,
 };
 
+static struct pxa_gpio_platform_data pxa168_gpio_pdata = {
+       .irq_base       = MMP_GPIO_TO_IRQ(0),
+};
+
 static unsigned int teton_bga_matrix_key_map[] = {
        KEY(0, 6, KEY_ESC),
        KEY(0, 7, KEY_ENTER),
        pxa168_add_uart(1);
        pxa168_add_keypad(&teton_bga_keypad_info);
        pxa168_add_twsi(0, NULL, ARRAY_AND_SIZE(teton_bga_i2c_info));
+       platform_device_add_data(&pxa168_device_gpio, &pxa168_gpio_pdata,
+                                sizeof(struct pxa_gpio_platform_data));
        platform_device_register(&pxa168_device_gpio);
 }
 
 
 #include <linux/interrupt.h>
 #include <linux/i2c/pca953x.h>
 #include <linux/gpio.h>
+#include <linux/gpio-pxa.h>
 #include <linux/mfd/88pm860x.h>
 #include <linux/platform_data/mv_usb.h>
 #include <linux/spi/spi.h>
        DF_RDY0_DF_RDY0,
 };
 
+static struct pxa_gpio_platform_data pxa910_gpio_pdata = {
+       .irq_base       = MMP_GPIO_TO_IRQ(0),
+};
+
 static struct mtd_partition ttc_dkb_onenand_partitions[] = {
        {
                .name           = "bootloader",
 
        /* off-chip devices */
        pxa910_add_twsi(0, NULL, ARRAY_AND_SIZE(ttc_dkb_i2c_info));
+       platform_device_add_data(&pxa910_device_gpio, &pxa910_gpio_pdata,
+                                sizeof(struct pxa_gpio_platform_data));
        platform_add_devices(ARRAY_AND_SIZE(ttc_dkb_devices));
 
 #ifdef CONFIG_USB_MV_UDC
 
 }
 
 static struct pxa_gpio_platform_data pxa25x_gpio_info __initdata = {
-       .gpio_set_wake = gpio_set_wake,
+       .irq_base       = PXA_GPIO_TO_IRQ(0),
+       .gpio_set_wake  = gpio_set_wake,
 };
 
 static struct platform_device *pxa25x_devices[] __initdata = {
 
 }
 
 static struct pxa_gpio_platform_data pxa27x_gpio_info __initdata = {
-       .gpio_set_wake = gpio_set_wake,
+       .irq_base       = PXA_GPIO_TO_IRQ(0),
+       .gpio_set_wake  = gpio_set_wake,
 };
 
 static struct platform_device *devices[] __initdata = {
 
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
+#include <linux/gpio-pxa.h>
 #include <linux/pm.h>
 #include <linux/platform_device.h>
 #include <linux/irq.h>
        pxa_register_device(&pxa3xx_device_i2c_power, info);
 }
 
+static struct pxa_gpio_platform_data pxa3xx_gpio_pdata = {
+       .irq_base       = PXA_GPIO_TO_IRQ(0),
+};
+
 static struct platform_device *devices[] __initdata = {
        &pxa27x_device_udc,
        &pxa_device_pmu,
                ret = platform_add_devices(devices, ARRAY_SIZE(devices));
                if (ret)
                        return ret;
-               if (cpu_is_pxa300() || cpu_is_pxa310() || cpu_is_pxa320())
+               if (cpu_is_pxa300() || cpu_is_pxa310() || cpu_is_pxa320()) {
+                       platform_device_add_data(&pxa3xx_device_gpio,
+                                                &pxa3xx_gpio_pdata,
+                                                sizeof(pxa3xx_gpio_pdata));
                        ret = platform_device_register(&pxa3xx_device_gpio);
+               }
        }
 
        return ret;
 
 
 #include <linux/module.h>
 #include <linux/kernel.h>
-#include <linux/platform_device.h>
-#include <linux/irq.h>
 #include <linux/dma-mapping.h>
+#include <linux/irq.h>
+#include <linux/gpio-pxa.h>
+#include <linux/platform_device.h>
 
 #include <mach/pxa930.h>
 
        MFP_ADDR_END,
 };
 
+static struct pxa_gpio_platform_data pxa93x_gpio_pdata = {
+       .irq_base       = PXA_GPIO_TO_IRQ(0),
+};
+
 static int __init pxa930_init(void)
 {
        int ret = 0;
        if (cpu_is_pxa93x()) {
                mfp_init_base(io_p2v(MFPR_BASE));
                mfp_init_addr(pxa930_mfp_addr_map);
+               platform_device_add_data(&pxa93x_device_gpio,
+                                        &pxa93x_gpio_pdata,
+                                        sizeof(pxa93x_gpio_pdata));
                ret = platform_device_register(&pxa93x_device_gpio);
        }
 
 
        int gpio, irq, ret, use_of = 0;
        int irq0 = 0, irq1 = 0, irq_mux, gpio_offset = 0;
 
-       ret = pxa_gpio_probe_dt(pdev);
-       if (ret < 0) {
+       info = dev_get_platdata(&pdev->dev);
+       if (info) {
+               irq_base = info->irq_base;
+               if (irq_base <= 0)
+                       return -EINVAL;
                pxa_last_gpio = pxa_gpio_nums(pdev);
-#ifdef CONFIG_ARCH_PXA
-               if (gpio_is_pxa_type(gpio_type))
-                       irq_base = PXA_GPIO_TO_IRQ(0);
-#endif
-#ifdef CONFIG_ARCH_MMP
-               if (gpio_is_mmp_type(gpio_type))
-                       irq_base = MMP_GPIO_TO_IRQ(0);
-#endif
        } else {
+               irq_base = 0;
                use_of = 1;
+               ret = pxa_gpio_probe_dt(pdev);
+               if (ret < 0)
+                       return -EINVAL;
        }
 
        if (!pxa_last_gpio)
        }
 
        /* Initialize GPIO chips */
-       info = dev_get_platdata(&pdev->dev);
        pxa_init_gpio_chip(pxa_last_gpio, info ? info->gpio_set_wake : NULL);
 
        /* clear all GPIO edge detects */
 
 extern int pxa_irq_to_gpio(int irq);
 
 struct pxa_gpio_platform_data {
+       int irq_base;
        int (*gpio_set_wake)(unsigned int gpio, unsigned int on);
 };