31 files changed, 962 insertions, 102 deletions

diff --git a/drivers/pcmcia/Kconfig b/drivers/pcmcia/Kconfig
index fbf965b31c1..17f38a781d4 100644
--- a/drivers/pcmcia/Kconfig
+++ b/drivers/pcmcia/Kconfig
@@ -192,6 +192,10 @@ config PCMCIA_AU1X00
         tristate "Au1x00 pcmcia support"
         depends on SOC_AU1X00 && PCMCIA
 
+config PCMCIA_BCM63XX
+        tristate "bcm63xx pcmcia support"
+        depends on BCM63XX && PCMCIA
+
 config PCMCIA_SA1100
         tristate "SA1100 support"
         depends on ARM && ARCH_SA1100 && PCMCIA
diff --git a/drivers/pcmcia/Makefile b/drivers/pcmcia/Makefile
index 047394d98ac..a03a38acd77 100644
--- a/drivers/pcmcia/Makefile
+++ b/drivers/pcmcia/Makefile
@@ -27,6 +27,7 @@ obj-$(CONFIG_PCMCIA_SA1111)			+= sa11xx_core.o sa1111_cs.o
 obj-$(CONFIG_M32R_PCC)                          += m32r_pcc.o
 obj-$(CONFIG_M32R_CFC)                          += m32r_cfc.o
 obj-$(CONFIG_PCMCIA_AU1X00)                     += au1x00_ss.o
+obj-$(CONFIG_PCMCIA_BCM63XX)                    += bcm63xx_pcmcia.o
 obj-$(CONFIG_PCMCIA_VRC4171)                    += vrc4171_card.o
 obj-$(CONFIG_PCMCIA_VRC4173)                    += vrc4173_cardu.o
 obj-$(CONFIG_OMAP_CF)                           += omap_cf.o
@@ -71,6 +72,7 @@ pxa2xx-obj-$(CONFIG_MACH_ARMCORE)		+= pxa2xx_cm_x2xx_cs.o
 pxa2xx-obj-$(CONFIG_ARCH_VIPER)                 += pxa2xx_viper.o
 pxa2xx-obj-$(CONFIG_TRIZEPS_PCMCIA)             += pxa2xx_trizeps4.o
 pxa2xx-obj-$(CONFIG_MACH_PALMTX)                += pxa2xx_palmtx.o
+pxa2xx-obj-$(CONFIG_MACH_PALMTC)                += pxa2xx_palmtc.o
 pxa2xx-obj-$(CONFIG_MACH_PALMLD)                += pxa2xx_palmld.o
 pxa2xx-obj-$(CONFIG_MACH_E740)                  += pxa2xx_e740.o
 pxa2xx-obj-$(CONFIG_MACH_STARGATE2)             += pxa2xx_stargate2.o
diff --git a/drivers/pcmcia/at91_cf.c b/drivers/pcmcia/at91_cf.c
index 9e1140f085f..e1dccedc596 100644
--- a/drivers/pcmcia/at91_cf.c
+++ b/drivers/pcmcia/at91_cf.c
@@ -363,7 +363,7 @@ static int at91_cf_suspend(struct platform_device *pdev, pm_message_t mesg)
         struct at91_cf_socket   *cf = platform_get_drvdata(pdev);
         struct at91_cf_data     *board = cf->board;
 
-        pcmcia_socket_dev_suspend(&pdev->dev, mesg);
+        pcmcia_socket_dev_suspend(&pdev->dev);
         if (device_may_wakeup(&pdev->dev)) {
                 enable_irq_wake(board->det_pin);
                 if (board->irq_pin)
diff --git a/drivers/pcmcia/au1000_generic.c b/drivers/pcmcia/au1000_generic.c
index 90013341cd5..02088704ac2 100644
--- a/drivers/pcmcia/au1000_generic.c
+++ b/drivers/pcmcia/au1000_generic.c
@@ -515,7 +515,7 @@ static int au1x00_drv_pcmcia_probe(struct platform_device *dev)
 static int au1x00_drv_pcmcia_suspend(struct platform_device *dev,
                                      pm_message_t state)
 {
-        return pcmcia_socket_dev_suspend(&dev->dev, state);
+        return pcmcia_socket_dev_suspend(&dev->dev);
 }
 
 static int au1x00_drv_pcmcia_resume(struct platform_device *dev)
diff --git a/drivers/pcmcia/bcm63xx_pcmcia.c b/drivers/pcmcia/bcm63xx_pcmcia.c
new file mode 100644
index 00000000000..bc88a3b19bb
--- /dev/null
+++ b/drivers/pcmcia/bcm63xx_pcmcia.c
@@ -0,0 +1,536 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2008 Maxime Bizon <mbizon@freebox.fr>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/ioport.h>
+#include <linux/timer.h>
+#include <linux/platform_device.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+#include <linux/gpio.h>
+
+#include <bcm63xx_regs.h>
+#include <bcm63xx_io.h>
+#include "bcm63xx_pcmcia.h"
+
+#define PFX     "bcm63xx_pcmcia: "
+
+#ifdef CONFIG_CARDBUS
+/* if cardbus is used, platform device needs reference to actual pci
+ * device */
+static struct pci_dev *bcm63xx_cb_dev;
+#endif
+
+/*
+ * read/write helper for pcmcia regs
+ */
+static inline u32 pcmcia_readl(struct bcm63xx_pcmcia_socket *skt, u32 off)
+{
+        return bcm_readl(skt->base + off);
+}
+
+static inline void pcmcia_writel(struct bcm63xx_pcmcia_socket *skt,
+                                 u32 val, u32 off)
+{
+        bcm_writel(val, skt->base + off);
+}
+
+/*
+ * This callback should (re-)initialise the socket, turn on status
+ * interrupts and PCMCIA bus, and wait for power to stabilise so that
+ * the card status signals report correctly.
+ *
+ * Hardware cannot do that.
+ */
+static int bcm63xx_pcmcia_sock_init(struct pcmcia_socket *sock)
+{
+        return 0;
+}
+
+/*
+ * This callback should remove power on the socket, disable IRQs from
+ * the card, turn off status interrupts, and disable the PCMCIA bus.
+ *
+ * Hardware cannot do that.
+ */
+static int bcm63xx_pcmcia_suspend(struct pcmcia_socket *sock)
+{
+        return 0;
+}
+
+/*
+ * Implements the set_socket() operation for the in-kernel PCMCIA
+ * service (formerly SS_SetSocket in Card Services). We more or
+ * less punt all of this work and let the kernel handle the details
+ * of power configuration, reset, &c. We also record the value of
+ * `state' in order to regurgitate it to the PCMCIA core later.
+ */
+static int bcm63xx_pcmcia_set_socket(struct pcmcia_socket *sock,
+                                     socket_state_t *state)
+{
+        struct bcm63xx_pcmcia_socket *skt;
+        unsigned long flags;
+        u32 val;
+
+        skt = sock->driver_data;
+
+        spin_lock_irqsave(&skt->lock, flags);
+
+        /* note: hardware cannot control socket power, so we will
+         * always report SS_POWERON */
+
+        /* apply socket reset */
+        val = pcmcia_readl(skt, PCMCIA_C1_REG);
+        if (state->flags & SS_RESET)
+                val |= PCMCIA_C1_RESET_MASK;
+        else
+                val &= ~PCMCIA_C1_RESET_MASK;
+
+        /* reverse reset logic for cardbus card */
+        if (skt->card_detected && (skt->card_type & CARD_CARDBUS))
+                val ^= PCMCIA_C1_RESET_MASK;
+
+        pcmcia_writel(skt, val, PCMCIA_C1_REG);
+
+        /* keep requested state for event reporting */
+        skt->requested_state = *state;
+
+        spin_unlock_irqrestore(&skt->lock, flags);
+
+        return 0;
+}
+
+/*
+ * identity cardtype from VS[12] input, CD[12] input while only VS2 is
+ * floating, and CD[12] input while only VS1 is floating
+ */
+enum {
+        IN_VS1 = (1 << 0),
+        IN_VS2 = (1 << 1),
+        IN_CD1_VS2H = (1 << 2),
+        IN_CD2_VS2H = (1 << 3),
+        IN_CD1_VS1H = (1 << 4),
+        IN_CD2_VS1H = (1 << 5),
+};
+
+static const u8 vscd_to_cardtype[] = {
+
+        /* VS1 float, VS2 float */
+        [IN_VS1 | IN_VS2] = (CARD_PCCARD | CARD_5V),
+
+        /* VS1 grounded, VS2 float */
+        [IN_VS2] = (CARD_PCCARD | CARD_5V | CARD_3V),
+
+        /* VS1 grounded, VS2 grounded */
+        [0] = (CARD_PCCARD | CARD_5V | CARD_3V | CARD_XV),
+
+        /* VS1 tied to CD1, VS2 float */
+        [IN_VS1 | IN_VS2 | IN_CD1_VS1H] = (CARD_CARDBUS | CARD_3V),
+
+        /* VS1 grounded, VS2 tied to CD2 */
+        [IN_VS2 | IN_CD2_VS2H] = (CARD_CARDBUS | CARD_3V | CARD_XV),
+
+        /* VS1 tied to CD2, VS2 grounded */
+        [IN_VS1 | IN_CD2_VS1H] = (CARD_CARDBUS | CARD_3V | CARD_XV | CARD_YV),
+
+        /* VS1 float, VS2 grounded */
+        [IN_VS1] = (CARD_PCCARD | CARD_XV),
+
+        /* VS1 float, VS2 tied to CD2 */
+        [IN_VS1 | IN_VS2 | IN_CD2_VS2H] = (CARD_CARDBUS | CARD_3V),
+
+        /* VS1 float, VS2 tied to CD1 */
+        [IN_VS1 | IN_VS2 | IN_CD1_VS2H] = (CARD_CARDBUS | CARD_XV | CARD_YV),
+
+        /* VS1 tied to CD2, VS2 float */
+        [IN_VS1 | IN_VS2 | IN_CD2_VS1H] = (CARD_CARDBUS | CARD_YV),
+
+        /* VS2 grounded, VS1 is tied to CD1, CD2 is grounded */
+        [IN_VS1 | IN_CD1_VS1H] = 0, /* ignore cardbay */
+};
+
+/*
+ * poll hardware to check card insertion status
+ */
+static unsigned int __get_socket_status(struct bcm63xx_pcmcia_socket *skt)
+{
+        unsigned int stat;
+        u32 val;
+
+        stat = 0;
+
+        /* check CD for card presence */
+        val = pcmcia_readl(skt, PCMCIA_C1_REG);
+
+        if (!(val & PCMCIA_C1_CD1_MASK) && !(val & PCMCIA_C1_CD2_MASK))
+                stat |= SS_DETECT;
+
+        /* if new insertion, detect cardtype */
+        if ((stat & SS_DETECT) && !skt->card_detected) {
+                unsigned int stat = 0;
+
+                /* float VS1, float VS2 */
+                val |= PCMCIA_C1_VS1OE_MASK;
+                val |= PCMCIA_C1_VS2OE_MASK;
+                pcmcia_writel(skt, val, PCMCIA_C1_REG);
+
+                /* wait for output to stabilize and read VS[12] */
+                udelay(10);
+                val = pcmcia_readl(skt, PCMCIA_C1_REG);
+                stat |= (val & PCMCIA_C1_VS1_MASK) ? IN_VS1 : 0;
+                stat |= (val & PCMCIA_C1_VS2_MASK) ? IN_VS2 : 0;
+
+                /* drive VS1 low, float VS2 */
+                val &= ~PCMCIA_C1_VS1OE_MASK;
+                val |= PCMCIA_C1_VS2OE_MASK;
+                pcmcia_writel(skt, val, PCMCIA_C1_REG);
+
+                /* wait for output to stabilize and read CD[12] */
+                udelay(10);
+                val = pcmcia_readl(skt, PCMCIA_C1_REG);
+                stat |= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS2H : 0;
+                stat |= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS2H : 0;
+
+                /* float VS1, drive VS2 low */
+                val |= PCMCIA_C1_VS1OE_MASK;
+                val &= ~PCMCIA_C1_VS2OE_MASK;
+                pcmcia_writel(skt, val, PCMCIA_C1_REG);
+
+                /* wait for output to stabilize and read CD[12] */
+                udelay(10);
+                val = pcmcia_readl(skt, PCMCIA_C1_REG);
+                stat |= (val & PCMCIA_C1_CD1_MASK) ? IN_CD1_VS1H : 0;
+                stat |= (val & PCMCIA_C1_CD2_MASK) ? IN_CD2_VS1H : 0;
+
+                /* guess cardtype from all this */
+                skt->card_type = vscd_to_cardtype[stat];
+                if (!skt->card_type)
+                        dev_err(&skt->socket.dev, "unsupported card type\n");
+
+                /* drive both VS pin to 0 again */
+                val &= ~(PCMCIA_C1_VS1OE_MASK | PCMCIA_C1_VS2OE_MASK);
+
+                /* enable correct logic */
+                val &= ~(PCMCIA_C1_EN_PCMCIA_MASK | PCMCIA_C1_EN_CARDBUS_MASK);
+                if (skt->card_type & CARD_PCCARD)
+                        val |= PCMCIA_C1_EN_PCMCIA_MASK;
+                else
+                        val |= PCMCIA_C1_EN_CARDBUS_MASK;
+
+                pcmcia_writel(skt, val, PCMCIA_C1_REG);
+        }
+        skt->card_detected = (stat & SS_DETECT) ? 1 : 0;
+
+        /* report card type/voltage */
+        if (skt->card_type & CARD_CARDBUS)
+                stat |= SS_CARDBUS;
+        if (skt->card_type & CARD_3V)
+                stat |= SS_3VCARD;
+        if (skt->card_type & CARD_XV)
+                stat |= SS_XVCARD;
+        stat |= SS_POWERON;
+
+        if (gpio_get_value(skt->pd->ready_gpio))
+                stat |= SS_READY;
+
+        return stat;
+}
+
+/*
+ * core request to get current socket status
+ */
+static int bcm63xx_pcmcia_get_status(struct pcmcia_socket *sock,
+                                     unsigned int *status)
+{
+        struct bcm63xx_pcmcia_socket *skt;
+
+        skt = sock->driver_data;
+
+        spin_lock_bh(&skt->lock);
+        *status = __get_socket_status(skt);
+        spin_unlock_bh(&skt->lock);
+
+        return 0;
+}
+
+/*
+ * socket polling timer callback
+ */
+static void bcm63xx_pcmcia_poll(unsigned long data)
+{
+        struct bcm63xx_pcmcia_socket *skt;
+        unsigned int stat, events;
+
+        skt = (struct bcm63xx_pcmcia_socket *)data;
+
+        spin_lock_bh(&skt->lock);
+
+        stat = __get_socket_status(skt);
+
+        /* keep only changed bits, and mask with required one from the
+         * core */
+        events = (stat ^ skt->old_status) & skt->requested_state.csc_mask;
+        skt->old_status = stat;
+        spin_unlock_bh(&skt->lock);
+
+        if (events)
+                pcmcia_parse_events(&skt->socket, events);
+
+        mod_timer(&skt->timer,
+                  jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE));
+}
+
+static int bcm63xx_pcmcia_set_io_map(struct pcmcia_socket *sock,
+                                     struct pccard_io_map *map)
+{
+        /* this doesn't seem to be called by pcmcia layer if static
+         * mapping is used */
+        return 0;
+}
+
+static int bcm63xx_pcmcia_set_mem_map(struct pcmcia_socket *sock,
+                                      struct pccard_mem_map *map)
+{
+        struct bcm63xx_pcmcia_socket *skt;
+        struct resource *res;
+
+        skt = sock->driver_data;
+        if (map->flags & MAP_ATTRIB)
+                res = skt->attr_res;
+        else
+                res = skt->common_res;
+
+        map->static_start = res->start + map->card_start;
+        return 0;
+}
+
+static struct pccard_operations bcm63xx_pcmcia_operations = {
+        .init                   = bcm63xx_pcmcia_sock_init,
+        .suspend                = bcm63xx_pcmcia_suspend,
+        .get_status             = bcm63xx_pcmcia_get_status,
+        .set_socket             = bcm63xx_pcmcia_set_socket,
+        .set_io_map             = bcm63xx_pcmcia_set_io_map,
+        .set_mem_map            = bcm63xx_pcmcia_set_mem_map,
+};
+
+/*
+ * register pcmcia socket to core
+ */
+static int __devinit bcm63xx_drv_pcmcia_probe(struct platform_device *pdev)
+{
+        struct bcm63xx_pcmcia_socket *skt;
+        struct pcmcia_socket *sock;
+        struct resource *res, *irq_res;
+        unsigned int regmem_size = 0, iomem_size = 0;
+        u32 val;
+        int ret;
+
+        skt = kzalloc(sizeof(*skt), GFP_KERNEL);
+        if (!skt)
+                return -ENOMEM;
+        spin_lock_init(&skt->lock);
+        sock = &skt->socket;
+        sock->driver_data = skt;
+
+        /* make sure we have all resources we need */
+        skt->common_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        skt->attr_res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
+        irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        skt->pd = pdev->dev.platform_data;
+        if (!skt->common_res || !skt->attr_res || !irq_res || !skt->pd) {
+                ret = -EINVAL;
+                goto err;
+        }
+
+        /* remap pcmcia registers */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        regmem_size = resource_size(res);
+        if (!request_mem_region(res->start, regmem_size, "bcm63xx_pcmcia")) {
+                ret = -EINVAL;
+                goto err;
+        }
+        skt->reg_res = res;
+
+        skt->base = ioremap(res->start, regmem_size);
+        if (!skt->base) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        /* remap io registers */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 3);
+        iomem_size = resource_size(res);
+        skt->io_base = ioremap(res->start, iomem_size);
+        if (!skt->io_base) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        /* resources are static */
+        sock->resource_ops = &pccard_static_ops;
+        sock->ops = &bcm63xx_pcmcia_operations;
+        sock->owner = THIS_MODULE;
+        sock->dev.parent = &pdev->dev;
+        sock->features = SS_CAP_STATIC_MAP | SS_CAP_PCCARD;
+        sock->io_offset = (unsigned long)skt->io_base;
+        sock->pci_irq = irq_res->start;
+
+#ifdef CONFIG_CARDBUS
+        sock->cb_dev = bcm63xx_cb_dev;
+        if (bcm63xx_cb_dev)
+                sock->features |= SS_CAP_CARDBUS;
+#endif
+
+        /* assume common & attribute memory have the same size */
+        sock->map_size = resource_size(skt->common_res);
+
+        /* initialize polling timer */
+        setup_timer(&skt->timer, bcm63xx_pcmcia_poll, (unsigned long)skt);
+
+        /* initialize  pcmcia  control register,  drive  VS[12] to  0,
+         * leave CB IDSEL to the old  value since it is set by the PCI
+         * layer */
+        val = pcmcia_readl(skt, PCMCIA_C1_REG);
+        val &= PCMCIA_C1_CBIDSEL_MASK;
+        val |= PCMCIA_C1_EN_PCMCIA_GPIO_MASK;
+        pcmcia_writel(skt, val, PCMCIA_C1_REG);
+
+        /*
+         * Hardware has only one set of timings registers, not one for
+         * each memory access type, so we configure them for the
+         * slowest one: attribute memory.
+         */
+        val = PCMCIA_C2_DATA16_MASK;
+        val |= 10 << PCMCIA_C2_RWCOUNT_SHIFT;
+        val |= 6 << PCMCIA_C2_INACTIVE_SHIFT;
+        val |= 3 << PCMCIA_C2_SETUP_SHIFT;
+        val |= 3 << PCMCIA_C2_HOLD_SHIFT;
+        pcmcia_writel(skt, val, PCMCIA_C2_REG);
+
+        ret = pcmcia_register_socket(sock);
+        if (ret)
+                goto err;
+
+        /* start polling socket */
+        mod_timer(&skt->timer,
+                  jiffies + msecs_to_jiffies(BCM63XX_PCMCIA_POLL_RATE));
+
+        platform_set_drvdata(pdev, skt);
+        return 0;
+
+err:
+        if (skt->io_base)
+                iounmap(skt->io_base);
+        if (skt->base)
+                iounmap(skt->base);
+        if (skt->reg_res)
+                release_mem_region(skt->reg_res->start, regmem_size);
+        kfree(skt);
+        return ret;
+}
+
+static int __devexit bcm63xx_drv_pcmcia_remove(struct platform_device *pdev)
+{
+        struct bcm63xx_pcmcia_socket *skt;
+        struct resource *res;
+
+        skt = platform_get_drvdata(pdev);
+        del_timer_sync(&skt->timer);
+        iounmap(skt->base);
+        iounmap(skt->io_base);
+        res = skt->reg_res;
+        release_mem_region(res->start, resource_size(res));
+        kfree(skt);
+        return 0;
+}
+
+struct platform_driver bcm63xx_pcmcia_driver = {
+        .probe  = bcm63xx_drv_pcmcia_probe,
+        .remove = __devexit_p(bcm63xx_drv_pcmcia_remove),
+        .driver = {
+                .name   = "bcm63xx_pcmcia",
+                .owner  = THIS_MODULE,
+        },
+};
+
+#ifdef CONFIG_CARDBUS
+static int __devinit bcm63xx_cb_probe(struct pci_dev *dev,
+                                      const struct pci_device_id *id)
+{
+        /* keep pci device */
+        bcm63xx_cb_dev = dev;
+        return platform_driver_register(&bcm63xx_pcmcia_driver);
+}
+
+static void __devexit bcm63xx_cb_exit(struct pci_dev *dev)
+{
+        platform_driver_unregister(&bcm63xx_pcmcia_driver);
+        bcm63xx_cb_dev = NULL;
+}
+
+static struct pci_device_id bcm63xx_cb_table[] = {
+        {
+                .vendor         = PCI_VENDOR_ID_BROADCOM,
+                .device         = BCM6348_CPU_ID,
+                .subvendor      = PCI_VENDOR_ID_BROADCOM,
+                .subdevice      = PCI_ANY_ID,
+                .class          = PCI_CLASS_BRIDGE_CARDBUS << 8,
+                .class_mask     = ~0,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_BROADCOM,
+                .device         = BCM6358_CPU_ID,
+                .subvendor      = PCI_VENDOR_ID_BROADCOM,
+                .subdevice      = PCI_ANY_ID,
+                .class          = PCI_CLASS_BRIDGE_CARDBUS << 8,
+                .class_mask     = ~0,
+        },
+
+        { },
+};
+
+MODULE_DEVICE_TABLE(pci, bcm63xx_cb_table);
+
+static struct pci_driver bcm63xx_cardbus_driver = {
+        .name           = "bcm63xx_cardbus",
+        .id_table       = bcm63xx_cb_table,
+        .probe          = bcm63xx_cb_probe,
+        .remove         = __devexit_p(bcm63xx_cb_exit),
+};
+#endif
+
+/*
+ * if cardbus support is enabled, register our platform device after
+ * our fake cardbus bridge has been registered
+ */
+static int __init bcm63xx_pcmcia_init(void)
+{
+#ifdef CONFIG_CARDBUS
+        return pci_register_driver(&bcm63xx_cardbus_driver);
+#else
+        return platform_driver_register(&bcm63xx_pcmcia_driver);
+#endif
+}
+
+static void __exit bcm63xx_pcmcia_exit(void)
+{
+#ifdef CONFIG_CARDBUS
+        return pci_unregister_driver(&bcm63xx_cardbus_driver);
+#else
+        platform_driver_unregister(&bcm63xx_pcmcia_driver);
+#endif
+}
+
+module_init(bcm63xx_pcmcia_init);
+module_exit(bcm63xx_pcmcia_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Maxime Bizon <mbizon@freebox.fr>");
+MODULE_DESCRIPTION("Linux PCMCIA Card Services: bcm63xx Socket Controller");
diff --git a/drivers/pcmcia/bcm63xx_pcmcia.h b/drivers/pcmcia/bcm63xx_pcmcia.h
new file mode 100644
index 00000000000..ed957399d86
--- /dev/null
+++ b/drivers/pcmcia/bcm63xx_pcmcia.h
@@ -0,0 +1,60 @@
+#ifndef BCM63XX_PCMCIA_H_
+#define BCM63XX_PCMCIA_H_
+
+#include <linux/types.h>
+#include <linux/timer.h>
+#include <pcmcia/ss.h>
+#include <bcm63xx_dev_pcmcia.h>
+
+/* socket polling rate in ms */
+#define BCM63XX_PCMCIA_POLL_RATE        500
+
+enum {
+        CARD_CARDBUS = (1 << 0),
+        CARD_PCCARD = (1 << 1),
+        CARD_5V = (1 << 2),
+        CARD_3V = (1 << 3),
+        CARD_XV = (1 << 4),
+        CARD_YV = (1 << 5),
+};
+
+struct bcm63xx_pcmcia_socket {
+        struct pcmcia_socket socket;
+
+        /* platform specific data */
+        struct bcm63xx_pcmcia_platform_data *pd;
+
+        /* all regs access are protected by this spinlock */
+        spinlock_t lock;
+
+        /* pcmcia registers resource */
+        struct resource *reg_res;
+
+        /* base remapped address of registers */
+        void __iomem *base;
+
+        /* whether a card is detected at the moment */
+        int card_detected;
+
+        /* type of detected card (mask of above enum) */
+        u8 card_type;
+
+        /* keep last socket status to implement event reporting */
+        unsigned int old_status;
+
+        /* backup of requested socket state */
+        socket_state_t requested_state;
+
+        /* timer used for socket status polling */
+        struct timer_list timer;
+
+        /* attribute/common memory resources */
+        struct resource *attr_res;
+        struct resource *common_res;
+        struct resource *io_res;
+
+        /* base address of io memory */
+        void __iomem *io_base;
+};
+
+#endif /* BCM63XX_PCMCIA_H_ */
diff --git a/drivers/pcmcia/bfin_cf_pcmcia.c b/drivers/pcmcia/bfin_cf_pcmcia.c
index b59d4115d20..300b368605c 100644
--- a/drivers/pcmcia/bfin_cf_pcmcia.c
+++ b/drivers/pcmcia/bfin_cf_pcmcia.c
@@ -302,7 +302,7 @@ static int __devexit bfin_cf_remove(struct platform_device *pdev)
 
 static int bfin_cf_suspend(struct platform_device *pdev, pm_message_t mesg)
 {
-        return pcmcia_socket_dev_suspend(&pdev->dev, mesg);
+        return pcmcia_socket_dev_suspend(&pdev->dev);
 }
 
 static int bfin_cf_resume(struct platform_device *pdev)
diff --git a/drivers/pcmcia/cistpl.c b/drivers/pcmcia/cistpl.c
index 4a110b7b267..6c4a4fc8363 100644
--- a/drivers/pcmcia/cistpl.c
+++ b/drivers/pcmcia/cistpl.c
@@ -1463,7 +1463,9 @@ int pccard_read_tuple(struct pcmcia_socket *s, unsigned int function, cisdata_t
             return -ENOMEM;
     }
     tuple.DesiredTuple = code;
-    tuple.Attributes = TUPLE_RETURN_COMMON;
+    tuple.Attributes = 0;
+    if (function == BIND_FN_ALL)
+            tuple.Attributes = TUPLE_RETURN_COMMON;
     ret = pccard_get_first_tuple(s, function, &tuple);
     if (ret != 0)
             goto done;
@@ -1490,7 +1492,7 @@ EXPORT_SYMBOL(pccard_read_tuple);
     
 ======================================================================*/
 
-int pccard_validate_cis(struct pcmcia_socket *s, unsigned int function, unsigned int *info)
+int pccard_validate_cis(struct pcmcia_socket *s, unsigned int *info)
 {
     tuple_t *tuple;
     cisparse_t *p;
@@ -1515,30 +1517,30 @@ int pccard_validate_cis(struct pcmcia_socket *s, unsigned int function, unsigned
     count = reserved = 0;
     tuple->DesiredTuple = RETURN_FIRST_TUPLE;
     tuple->Attributes = TUPLE_RETURN_COMMON;
-    ret = pccard_get_first_tuple(s, function, tuple);
+    ret = pccard_get_first_tuple(s, BIND_FN_ALL, tuple);
     if (ret != 0)
         goto done;
 
     /* First tuple should be DEVICE; we should really have either that
        or a CFTABLE_ENTRY of some sort */
     if ((tuple->TupleCode == CISTPL_DEVICE) ||
-        (pccard_read_tuple(s, function, CISTPL_CFTABLE_ENTRY, p) == 0) ||
-        (pccard_read_tuple(s, function, CISTPL_CFTABLE_ENTRY_CB, p) == 0))
+        (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_CFTABLE_ENTRY, p) == 0) ||
+        (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_CFTABLE_ENTRY_CB, p) == 0))
         dev_ok++;
 
     /* All cards should have a MANFID tuple, and/or a VERS_1 or VERS_2
        tuple, for card identification.  Certain old D-Link and Linksys
        cards have only a broken VERS_2 tuple; hence the bogus test. */
-    if ((pccard_read_tuple(s, function, CISTPL_MANFID, p) == 0) ||
-        (pccard_read_tuple(s, function, CISTPL_VERS_1, p) == 0) ||
-        (pccard_read_tuple(s, function, CISTPL_VERS_2, p) != -ENOSPC))
+    if ((pccard_read_tuple(s, BIND_FN_ALL, CISTPL_MANFID, p) == 0) ||
+        (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_VERS_1, p) == 0) ||
+        (pccard_read_tuple(s, BIND_FN_ALL, CISTPL_VERS_2, p) != -ENOSPC))
         ident_ok++;
 
     if (!dev_ok && !ident_ok)
         goto done;
 
     for (count = 1; count < MAX_TUPLES; count++) {
-        ret = pccard_get_next_tuple(s, function, tuple);
+        ret = pccard_get_next_tuple(s, BIND_FN_ALL, tuple);
         if (ret != 0)
                 break;
         if (((tuple->TupleCode > 0x23) && (tuple->TupleCode < 0x40)) ||
diff --git a/drivers/pcmcia/cs.c b/drivers/pcmcia/cs.c
index 0660ad18258..934d4bee39a 100644
--- a/drivers/pcmcia/cs.c
+++ b/drivers/pcmcia/cs.c
@@ -101,7 +101,7 @@ EXPORT_SYMBOL(pcmcia_socket_list_rwsem);
 static int socket_resume(struct pcmcia_socket *skt);
 static int socket_suspend(struct pcmcia_socket *skt);
 
-int pcmcia_socket_dev_suspend(struct device *dev, pm_message_t state)
+int pcmcia_socket_dev_suspend(struct device *dev)
 {
         struct pcmcia_socket *socket;
 
diff --git a/drivers/pcmcia/cs_internal.h b/drivers/pcmcia/cs_internal.h
index 79615e6d540..1f4098f1354 100644
--- a/drivers/pcmcia/cs_internal.h
+++ b/drivers/pcmcia/cs_internal.h
@@ -197,8 +197,7 @@ int pccard_read_tuple(struct pcmcia_socket *s, unsigned int function,
                       cisdata_t code, void *parse);
 int pcmcia_replace_cis(struct pcmcia_socket *s,
                        const u8 *data, const size_t len);
-int pccard_validate_cis(struct pcmcia_socket *s, unsigned int function,
-                        unsigned int *count);
+int pccard_validate_cis(struct pcmcia_socket *s, unsigned int *count);
 
 /* rsrc_mgr.c */
 int pcmcia_validate_mem(struct pcmcia_socket *s);
diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c
index 9f300d3cb12..f5b7079f13d 100644
--- a/drivers/pcmcia/ds.c
+++ b/drivers/pcmcia/ds.c
@@ -547,7 +547,7 @@ static int pcmcia_device_query(struct pcmcia_device *p_dev)
         if (!vers1)
                 return -ENOMEM;
 
-        if (!pccard_read_tuple(p_dev->socket, p_dev->func,
+        if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL,
                                CISTPL_MANFID, &manf_id)) {
                 p_dev->manf_id = manf_id.manf;
                 p_dev->card_id = manf_id.card;
@@ -581,9 +581,9 @@ static int pcmcia_device_query(struct pcmcia_device *p_dev)
                 kfree(devgeo);
         }
 
-        if (!pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_VERS_1,
+        if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL, CISTPL_VERS_1,
                                vers1)) {
-                for (i=0; i < vers1->ns; i++) {
+                for (i = 0; i < min_t(unsigned int, 4, vers1->ns); i++) {
                         char *tmp;
                         unsigned int length;
 
@@ -733,7 +733,7 @@ static int pcmcia_card_add(struct pcmcia_socket *s)
                 return -EAGAIN; /* try again, but later... */
         }
 
-        ret = pccard_validate_cis(s, BIND_FN_ALL, &no_chains);
+        ret = pccard_validate_cis(s, &no_chains);
         if (ret || !no_chains) {
                 ds_dev_dbg(0, &s->dev, "invalid CIS or invalid resources\n");
                 return -ENODEV;
diff --git a/drivers/pcmcia/i82092.c b/drivers/pcmcia/i82092.c
index 46561face12..a04f21c8170 100644
--- a/drivers/pcmcia/i82092.c
+++ b/drivers/pcmcia/i82092.c
@@ -42,7 +42,7 @@ MODULE_DEVICE_TABLE(pci, i82092aa_pci_ids);
 #ifdef CONFIG_PM
 static int i82092aa_socket_suspend (struct pci_dev *dev, pm_message_t state)
 {
-        return pcmcia_socket_dev_suspend(&dev->dev, state);
+        return pcmcia_socket_dev_suspend(&dev->dev);
 }
 
 static int i82092aa_socket_resume (struct pci_dev *dev)
diff --git a/drivers/pcmcia/i82365.c b/drivers/pcmcia/i82365.c
index 40d4953e4b1..a4aacb830b8 100644
--- a/drivers/pcmcia/i82365.c
+++ b/drivers/pcmcia/i82365.c
@@ -1053,8 +1053,8 @@ static int i365_set_io_map(u_short sock, struct pccard_io_map *io)
     u_char map, ioctl;
     
     debug(1, "SetIOMap(%d, %d, %#2.2x, %d ns, "
-          "%#x-%#x)\n", sock, io->map, io->flags,
-          io->speed, io->start, io->stop);
+          "%#llx-%#llx)\n", sock, io->map, io->flags, io->speed,
+          (unsigned long long)io->start, (unsigned long long)io->stop);
     map = io->map;
     if ((map > 1) || (io->start > 0xffff) || (io->stop > 0xffff) ||
         (io->stop < io->start)) return -EINVAL;
@@ -1241,7 +1241,7 @@ static int pcic_init(struct pcmcia_socket *s)
 static int i82365_drv_pcmcia_suspend(struct platform_device *dev,
                                      pm_message_t state)
 {
-        return pcmcia_socket_dev_suspend(&dev->dev, state);
+        return pcmcia_socket_dev_suspend(&dev->dev);
 }
 
 static int i82365_drv_pcmcia_resume(struct platform_device *dev)
diff --git a/drivers/pcmcia/m32r_cfc.c b/drivers/pcmcia/m32r_cfc.c
index 62b4ecc97c4..7dfbee1dcd7 100644
--- a/drivers/pcmcia/m32r_cfc.c
+++ b/drivers/pcmcia/m32r_cfc.c
@@ -537,8 +537,9 @@ static int _pcc_set_io_map(u_short sock, struct pccard_io_map *io)
         u_char map;
 
         debug(3, "m32r_cfc: SetIOMap(%d, %d, %#2.2x, %d ns, "
-                  "%#lx-%#lx)\n", sock, io->map, io->flags,
-                  io->speed, io->start, io->stop);
+                  "%#llx-%#llx)\n", sock, io->map, io->flags,
+                  io->speed, (unsigned long long)io->start,
+                  (unsigned long long)io->stop);
         map = io->map;
 
         return 0;
@@ -554,8 +555,9 @@ static int _pcc_set_mem_map(u_short sock, struct pccard_mem_map *mem)
         pcc_socket_t *t = &socket[sock];
 
         debug(3, "m32r_cfc: SetMemMap(%d, %d, %#2.2x, %d ns, "
-                 "%#lx, %#x)\n", sock, map, mem->flags,
-                 mem->speed, mem->static_start, mem->card_start);
+                 "%#llx, %#x)\n", sock, map, mem->flags,
+                 mem->speed, (unsigned long long)mem->static_start,
+                 mem->card_start);
 
         /*
          * sanity check
@@ -699,7 +701,7 @@ static struct pccard_operations pcc_operations = {
 static int cfc_drv_pcmcia_suspend(struct platform_device *dev,
                                      pm_message_t state)
 {
-        return pcmcia_socket_dev_suspend(&dev->dev, state);
+        return pcmcia_socket_dev_suspend(&dev->dev);
 }
 
 static int cfc_drv_pcmcia_resume(struct platform_device *dev)
diff --git a/drivers/pcmcia/m32r_pcc.c b/drivers/pcmcia/m32r_pcc.c
index 12034b41d19..c6524f99ccc 100644
--- a/drivers/pcmcia/m32r_pcc.c
+++ b/drivers/pcmcia/m32r_pcc.c
@@ -492,8 +492,9 @@ static int _pcc_set_io_map(u_short sock, struct pccard_io_map *io)
         u_char map;
 
         debug(3, "m32r-pcc: SetIOMap(%d, %d, %#2.2x, %d ns, "
-                  "%#x-%#x)\n", sock, io->map, io->flags,
-                  io->speed, io->start, io->stop);
+                  "%#llx-%#llx)\n", sock, io->map, io->flags,
+                  io->speed, (unsigned long long)io->start,
+                  (unsigned long long)io->stop);
         map = io->map;
 
         return 0;
@@ -515,8 +516,9 @@ static int _pcc_set_mem_map(u_short sock, struct pccard_mem_map *mem)
 #endif
 
         debug(3, "m32r-pcc: SetMemMap(%d, %d, %#2.2x, %d ns, "
-                 "%#lx,  %#x)\n", sock, map, mem->flags,
-                 mem->speed, mem->static_start, mem->card_start);
+                 "%#llx,  %#x)\n", sock, map, mem->flags,
+                 mem->speed, (unsigned long long)mem->static_start,
+                 mem->card_start);
 
         /*
          * sanity check
@@ -675,7 +677,7 @@ static struct pccard_operations pcc_operations = {
 static int pcc_drv_pcmcia_suspend(struct platform_device *dev,
                                      pm_message_t state)
 {
-        return pcmcia_socket_dev_suspend(&dev->dev, state);
+        return pcmcia_socket_dev_suspend(&dev->dev);
 }
 
 static int pcc_drv_pcmcia_resume(struct platform_device *dev)
diff --git a/drivers/pcmcia/m8xx_pcmcia.c b/drivers/pcmcia/m8xx_pcmcia.c
index d1ad0966392..403559ba49d 100644
--- a/drivers/pcmcia/m8xx_pcmcia.c
+++ b/drivers/pcmcia/m8xx_pcmcia.c
@@ -975,8 +975,9 @@ static int m8xx_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io)
 #define M8XX_BASE (PCMCIA_IO_WIN_BASE + io->start)
 
         dprintk("SetIOMap(%d, %d, %#2.2x, %d ns, "
-                "%#4.4x-%#4.4x)\n", lsock, io->map, io->flags,
-                io->speed, io->start, io->stop);
+                "%#4.4llx-%#4.4llx)\n", lsock, io->map, io->flags,
+                io->speed, (unsigned long long)io->start,
+                (unsigned long long)io->stop);
 
         if ((io->map >= PCMCIA_IO_WIN_NO) || (io->start > 0xffff)
             || (io->stop > 0xffff) || (io->stop < io->start))
@@ -1055,8 +1056,9 @@ static int m8xx_set_mem_map(struct pcmcia_socket *sock,
         pcmconf8xx_t *pcmcia = s->pcmcia;
 
         dprintk("SetMemMap(%d, %d, %#2.2x, %d ns, "
-                "%#5.5lx, %#5.5x)\n", lsock, mem->map, mem->flags,
-                mem->speed, mem->static_start, mem->card_start);
+                "%#5.5llx, %#5.5x)\n", lsock, mem->map, mem->flags,
+                mem->speed, (unsigned long long)mem->static_start,
+                mem->card_start);
 
         if ((mem->map >= PCMCIA_MEM_WIN_NO)
 //          || ((mem->s) >= PCMCIA_MEM_WIN_SIZE)
@@ -1107,8 +1109,9 @@ static int m8xx_set_mem_map(struct pcmcia_socket *sock,
         }
 
         dprintk("SetMemMap(%d, %d, %#2.2x, %d ns, "
-                "%#5.5lx, %#5.5x)\n", lsock, mem->map, mem->flags,
-                mem->speed, mem->static_start, mem->card_start);
+                "%#5.5llx, %#5.5x)\n", lsock, mem->map, mem->flags,
+                mem->speed, (unsigned long long)mem->static_start,
+                mem->card_start);
 
         /* copy the struct and modify the copy */
 
@@ -1296,7 +1299,7 @@ static int m8xx_remove(struct of_device *ofdev)
 #ifdef CONFIG_PM
 static int m8xx_suspend(struct platform_device *pdev, pm_message_t state)
 {
-        return pcmcia_socket_dev_suspend(&pdev->dev, state);
+        return pcmcia_socket_dev_suspend(&pdev->dev);
 }
 
 static int m8xx_resume(struct platform_device *pdev)
diff --git a/drivers/pcmcia/omap_cf.c b/drivers/pcmcia/omap_cf.c
index f3736398900..68570bc3ac8 100644
--- a/drivers/pcmcia/omap_cf.c
+++ b/drivers/pcmcia/omap_cf.c
@@ -334,7 +334,7 @@ static int __exit omap_cf_remove(struct platform_device *pdev)
 
 static int omap_cf_suspend(struct platform_device *pdev, pm_message_t mesg)
 {
-        return pcmcia_socket_dev_suspend(&pdev->dev, mesg);
+        return pcmcia_socket_dev_suspend(&pdev->dev);
 }
 
 static int omap_cf_resume(struct platform_device *pdev)
diff --git a/drivers/pcmcia/pcmcia_ioctl.c b/drivers/pcmcia/pcmcia_ioctl.c
index 32c44040c1e..30cf71d2ee2 100644
--- a/drivers/pcmcia/pcmcia_ioctl.c
+++ b/drivers/pcmcia/pcmcia_ioctl.c
@@ -881,7 +881,7 @@ static int ds_ioctl(struct inode * inode, struct file * file,
         mutex_lock(&s->skt_mutex);
         pcmcia_validate_mem(s);
         mutex_unlock(&s->skt_mutex);
-        ret = pccard_validate_cis(s, BIND_FN_ALL, &buf->cisinfo.Chains);
+        ret = pccard_validate_cis(s, &buf->cisinfo.Chains);
         break;
     case DS_SUSPEND_CARD:
         ret = pcmcia_suspend_card(s);
diff --git a/drivers/pcmcia/pd6729.c b/drivers/pcmcia/pd6729.c
index 8bed1dab903..70a33468bcd 100644
--- a/drivers/pcmcia/pd6729.c
+++ b/drivers/pcmcia/pd6729.c
@@ -641,6 +641,12 @@ static int __devinit pd6729_pci_probe(struct pci_dev *dev,
         if ((ret = pci_enable_device(dev)))
                 goto err_out_free_mem;
 
+        if (!pci_resource_start(dev, 0)) {
+                printk(KERN_INFO "pd6729: refusing to load the driver "
+                                 "as the io_base is 0.\n");
+                goto err_out_free_mem;
+        }
+
         printk(KERN_INFO "pd6729: Cirrus PD6729 PCI to PCMCIA Bridge "
                 "at 0x%llx on irq %d\n",
                 (unsigned long long)pci_resource_start(dev, 0), dev->irq);
@@ -758,7 +764,7 @@ static void __devexit pd6729_pci_remove(struct pci_dev *dev)
 #ifdef CONFIG_PM
 static int pd6729_socket_suspend(struct pci_dev *dev, pm_message_t state)
 {
-        return pcmcia_socket_dev_suspend(&dev->dev, state);
+        return pcmcia_socket_dev_suspend(&dev->dev);
 }
 
 static int pd6729_socket_resume(struct pci_dev *dev)
diff --git a/drivers/pcmcia/pxa2xx_base.c b/drivers/pcmcia/pxa2xx_base.c
index c49a7269f6d..0e35acb1366 100644
--- a/drivers/pcmcia/pxa2xx_base.c
+++ b/drivers/pcmcia/pxa2xx_base.c
@@ -300,25 +300,29 @@ static int pxa2xx_drv_pcmcia_remove(struct platform_device *dev)
         return soc_common_drv_pcmcia_remove(&dev->dev);
 }
 
-static int pxa2xx_drv_pcmcia_suspend(struct platform_device *dev, pm_message_t state)
+static int pxa2xx_drv_pcmcia_suspend(struct device *dev)
 {
-        return pcmcia_socket_dev_suspend(&dev->dev, state);
+        return pcmcia_socket_dev_suspend(dev);
 }
 
-static int pxa2xx_drv_pcmcia_resume(struct platform_device *dev)
+static int pxa2xx_drv_pcmcia_resume(struct device *dev)
 {
-        pxa2xx_configure_sockets(&dev->dev);
-        return pcmcia_socket_dev_resume(&dev->dev);
+        pxa2xx_configure_sockets(dev);
+        return pcmcia_socket_dev_resume(dev);
 }
 
+static struct dev_pm_ops  pxa2xx_drv_pcmcia_pm_ops = {
+        .suspend        = pxa2xx_drv_pcmcia_suspend,
+        .resume         = pxa2xx_drv_pcmcia_resume,
+};
+
 static struct platform_driver pxa2xx_pcmcia_driver = {
         .probe          = pxa2xx_drv_pcmcia_probe,
         .remove         = pxa2xx_drv_pcmcia_remove,
-        .suspend        = pxa2xx_drv_pcmcia_suspend,
-        .resume         = pxa2xx_drv_pcmcia_resume,
         .driver         = {
                 .name   = "pxa2xx-pcmcia",
                 .owner  = THIS_MODULE,
+                .pm     = &pxa2xx_drv_pcmcia_pm_ops,
         },
 };
 
diff --git a/drivers/pcmcia/pxa2xx_palmtc.c b/drivers/pcmcia/pxa2xx_palmtc.c
new file mode 100644
index 00000000000..3a8993ed562
--- /dev/null
+++ b/drivers/pcmcia/pxa2xx_palmtc.c
@@ -0,0 +1,230 @@
+/*
+ * linux/drivers/pcmcia/pxa2xx_palmtc.c
+ *
+ * Driver for Palm Tungsten|C PCMCIA
+ *
+ * Copyright (C) 2008 Alex Osborne <ato@meshy.org>
+ * Copyright (C) 2009 Marek Vasut <marek.vasut@gmail.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/module.h>
+#include <linux/platform_device.h>
+#include <linux/gpio.h>
+#include <linux/delay.h>
+
+#include <asm/mach-types.h>
+#include <mach/palmtc.h>
+#include "soc_common.h"
+
+static int palmtc_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
+{
+        int ret;
+
+        ret = gpio_request(GPIO_NR_PALMTC_PCMCIA_POWER1, "PCMCIA PWR1");
+        if (ret)
+                goto err1;
+        ret = gpio_direction_output(GPIO_NR_PALMTC_PCMCIA_POWER1, 0);
+        if (ret)
+                goto err2;
+
+        ret = gpio_request(GPIO_NR_PALMTC_PCMCIA_POWER2, "PCMCIA PWR2");
+        if (ret)
+                goto err2;
+        ret = gpio_direction_output(GPIO_NR_PALMTC_PCMCIA_POWER2, 0);
+        if (ret)
+                goto err3;
+
+        ret = gpio_request(GPIO_NR_PALMTC_PCMCIA_POWER3, "PCMCIA PWR3");
+        if (ret)
+                goto err3;
+        ret = gpio_direction_output(GPIO_NR_PALMTC_PCMCIA_POWER3, 0);
+        if (ret)
+                goto err4;
+
+        ret = gpio_request(GPIO_NR_PALMTC_PCMCIA_RESET, "PCMCIA RST");
+        if (ret)
+                goto err4;
+        ret = gpio_direction_output(GPIO_NR_PALMTC_PCMCIA_RESET, 1);
+        if (ret)
+                goto err5;
+
+        ret = gpio_request(GPIO_NR_PALMTC_PCMCIA_READY, "PCMCIA RDY");
+        if (ret)
+                goto err5;
+        ret = gpio_direction_input(GPIO_NR_PALMTC_PCMCIA_READY);
+        if (ret)
+                goto err6;
+
+        ret = gpio_request(GPIO_NR_PALMTC_PCMCIA_PWRREADY, "PCMCIA PWRRDY");
+        if (ret)
+                goto err6;
+        ret = gpio_direction_input(GPIO_NR_PALMTC_PCMCIA_PWRREADY);
+        if (ret)
+                goto err7;
+
+        skt->irq = IRQ_GPIO(GPIO_NR_PALMTC_PCMCIA_READY);
+        return 0;
+
+err7:
+        gpio_free(GPIO_NR_PALMTC_PCMCIA_PWRREADY);
+err6:
+        gpio_free(GPIO_NR_PALMTC_PCMCIA_READY);
+err5:
+        gpio_free(GPIO_NR_PALMTC_PCMCIA_RESET);
+err4:
+        gpio_free(GPIO_NR_PALMTC_PCMCIA_POWER3);
+err3:
+        gpio_free(GPIO_NR_PALMTC_PCMCIA_POWER2);
+err2:
+        gpio_free(GPIO_NR_PALMTC_PCMCIA_POWER1);
+err1:
+        return ret;
+}
+
+static void palmtc_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt)
+{
+        gpio_free(GPIO_NR_PALMTC_PCMCIA_PWRREADY);
+        gpio_free(GPIO_NR_PALMTC_PCMCIA_READY);
+        gpio_free(GPIO_NR_PALMTC_PCMCIA_RESET);
+        gpio_free(GPIO_NR_PALMTC_PCMCIA_POWER3);
+        gpio_free(GPIO_NR_PALMTC_PCMCIA_POWER2);
+        gpio_free(GPIO_NR_PALMTC_PCMCIA_POWER1);
+}
+
+static void palmtc_pcmcia_socket_state(struct soc_pcmcia_socket *skt,
+                                        struct pcmcia_state *state)
+{
+        state->detect = 1; /* always inserted */
+        state->ready  = !!gpio_get_value(GPIO_NR_PALMTC_PCMCIA_READY);
+        state->bvd1   = 1;
+        state->bvd2   = 1;
+        state->wrprot = 0;
+        state->vs_3v  = 1;
+        state->vs_Xv  = 0;
+}
+
+static int palmtc_wifi_powerdown(void)
+{
+        gpio_set_value(GPIO_NR_PALMTC_PCMCIA_RESET, 1);
+        gpio_set_value(GPIO_NR_PALMTC_PCMCIA_POWER2, 0);
+        mdelay(40);
+        gpio_set_value(GPIO_NR_PALMTC_PCMCIA_POWER1, 0);
+        return 0;
+}
+
+static int palmtc_wifi_powerup(void)
+{
+        int timeout = 50;
+
+        gpio_set_value(GPIO_NR_PALMTC_PCMCIA_POWER3, 1);
+        mdelay(50);
+
+        /* Power up the card, 1.8V first, after a while 3.3V */
+        gpio_set_value(GPIO_NR_PALMTC_PCMCIA_POWER1, 1);
+        mdelay(100);
+        gpio_set_value(GPIO_NR_PALMTC_PCMCIA_POWER2, 1);
+
+        /* Wait till the card is ready */
+        while (!gpio_get_value(GPIO_NR_PALMTC_PCMCIA_PWRREADY) &&
+                timeout) {
+                mdelay(1);
+                timeout--;
+        }
+
+        /* Power down the WiFi in case of error */
+        if (!timeout) {
+                palmtc_wifi_powerdown();
+                return 1;
+        }
+
+        /* Reset the card */
+        gpio_set_value(GPIO_NR_PALMTC_PCMCIA_RESET, 1);
+        mdelay(20);
+        gpio_set_value(GPIO_NR_PALMTC_PCMCIA_RESET, 0);
+        mdelay(25);
+
+        gpio_set_value(GPIO_NR_PALMTC_PCMCIA_POWER3, 0);
+
+        return 0;
+}
+
+static int palmtc_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
+                                        const socket_state_t *state)
+{
+        int ret = 1;
+
+        if (state->Vcc == 0)
+                ret = palmtc_wifi_powerdown();
+        else if (state->Vcc == 33)
+                ret = palmtc_wifi_powerup();
+
+        return ret;
+}
+
+static void palmtc_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
+{
+}
+
+static void palmtc_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
+{
+}
+
+static struct pcmcia_low_level palmtc_pcmcia_ops = {
+        .owner                  = THIS_MODULE,
+
+        .first                  = 0,
+        .nr                     = 1,
+
+        .hw_init                = palmtc_pcmcia_hw_init,
+        .hw_shutdown            = palmtc_pcmcia_hw_shutdown,
+
+        .socket_state           = palmtc_pcmcia_socket_state,
+        .configure_socket       = palmtc_pcmcia_configure_socket,
+
+        .socket_init            = palmtc_pcmcia_socket_init,
+        .socket_suspend         = palmtc_pcmcia_socket_suspend,
+};
+
+static struct platform_device *palmtc_pcmcia_device;
+
+static int __init palmtc_pcmcia_init(void)
+{
+        int ret;
+
+        if (!machine_is_palmtc())
+                return -ENODEV;
+
+        palmtc_pcmcia_device = platform_device_alloc("pxa2xx-pcmcia", -1);
+        if (!palmtc_pcmcia_device)
+                return -ENOMEM;
+
+        ret = platform_device_add_data(palmtc_pcmcia_device, &palmtc_pcmcia_ops,
+                                        sizeof(palmtc_pcmcia_ops));
+
+        if (!ret)
+                ret = platform_device_add(palmtc_pcmcia_device);
+
+        if (ret)
+                platform_device_put(palmtc_pcmcia_device);
+
+        return ret;
+}
+
+static void __exit palmtc_pcmcia_exit(void)
+{
+        platform_device_unregister(palmtc_pcmcia_device);
+}
+
+module_init(palmtc_pcmcia_init);
+module_exit(palmtc_pcmcia_exit);
+
+MODULE_AUTHOR("Alex Osborne <ato@meshy.org>,"
+            " Marek Vasut <marek.vasut@gmail.com>");
+MODULE_DESCRIPTION("PCMCIA support for Palm Tungsten|C");
+MODULE_ALIAS("platform:pxa2xx-pcmcia");
+MODULE_LICENSE("GPL");
diff --git a/drivers/pcmcia/rsrc_nonstatic.c b/drivers/pcmcia/rsrc_nonstatic.c
index 9ca22c7aafb..7039f3cf5b7 100644
--- a/drivers/pcmcia/rsrc_nonstatic.c
+++ b/drivers/pcmcia/rsrc_nonstatic.c
@@ -206,6 +206,7 @@ static void do_io_probe(struct pcmcia_socket *s, unsigned int base,
     /* First, what does a floating port look like? */
     b = kzalloc(256, GFP_KERNEL);
     if (!b) {
+            printk("\n");
             dev_printk(KERN_ERR, &s->dev,
                    "do_io_probe: unable to kmalloc 256 bytes");
             return;
@@ -275,7 +276,7 @@ static int readable(struct pcmcia_socket *s, struct resource *res,
         s->cis_mem.res = res;
         s->cis_virt = ioremap(res->start, s->map_size);
         if (s->cis_virt) {
-                ret = pccard_validate_cis(s, BIND_FN_ALL, count);
+                ret = pccard_validate_cis(s, count);
                 /* invalidate mapping and CIS cache */
                 iounmap(s->cis_virt);
                 s->cis_virt = NULL;
diff --git a/drivers/pcmcia/sa1100_assabet.c b/drivers/pcmcia/sa1100_assabet.c
index f424146a2bc..ac8aa09ba0d 100644
--- a/drivers/pcmcia/sa1100_assabet.c
+++ b/drivers/pcmcia/sa1100_assabet.c
@@ -130,7 +130,7 @@ static struct pcmcia_low_level assabet_pcmcia_ops = {
         .socket_suspend         = assabet_pcmcia_socket_suspend,
 };
 
-int __init pcmcia_assabet_init(struct device *dev)
+int pcmcia_assabet_init(struct device *dev)
 {
         int ret = -ENODEV;
 
diff --git a/drivers/pcmcia/sa1100_generic.c b/drivers/pcmcia/sa1100_generic.c
index d8da5ac844e..2d0e9975153 100644
--- a/drivers/pcmcia/sa1100_generic.c
+++ b/drivers/pcmcia/sa1100_generic.c
@@ -89,7 +89,7 @@ static int sa11x0_drv_pcmcia_remove(struct platform_device *dev)
 static int sa11x0_drv_pcmcia_suspend(struct platform_device *dev,
                                      pm_message_t state)
 {
-        return pcmcia_socket_dev_suspend(&dev->dev, state);
+        return pcmcia_socket_dev_suspend(&dev->dev);
 }
 
 static int sa11x0_drv_pcmcia_resume(struct platform_device *dev)
diff --git a/drivers/pcmcia/sa1100_neponset.c b/drivers/pcmcia/sa1100_neponset.c
index 4c41e86ccff..0c76d337815 100644
--- a/drivers/pcmcia/sa1100_neponset.c
+++ b/drivers/pcmcia/sa1100_neponset.c
@@ -123,7 +123,7 @@ static struct pcmcia_low_level neponset_pcmcia_ops = {
         .socket_suspend         = sa1111_pcmcia_socket_suspend,
 };
 
-int __init pcmcia_neponset_init(struct sa1111_dev *sadev)
+int pcmcia_neponset_init(struct sa1111_dev *sadev)
 {
         int ret = -ENODEV;
 
diff --git a/drivers/pcmcia/sa1111_generic.c b/drivers/pcmcia/sa1111_generic.c
index 401052a21ce..4be4e172ffa 100644
--- a/drivers/pcmcia/sa1111_generic.c
+++ b/drivers/pcmcia/sa1111_generic.c
@@ -159,7 +159,7 @@ static int __devexit pcmcia_remove(struct sa1111_dev *dev)
 
 static int pcmcia_suspend(struct sa1111_dev *dev, pm_message_t state)
 {
-        return pcmcia_socket_dev_suspend(&dev->dev, state);
+        return pcmcia_socket_dev_suspend(&dev->dev);
 }
 
 static int pcmcia_resume(struct sa1111_dev *dev)
diff --git a/drivers/pcmcia/soc_common.c b/drivers/pcmcia/soc_common.c
index 163cf98e238..ef7e9e58782 100644
--- a/drivers/pcmcia/soc_common.c
+++ b/drivers/pcmcia/soc_common.c
@@ -336,8 +336,9 @@ soc_common_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *m
         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
         unsigned short speed = map->speed;
 
-        debug(skt, 2, "map %u  speed %u start 0x%08x stop 0x%08x\n",
-                map->map, map->speed, map->start, map->stop);
+        debug(skt, 2, "map %u  speed %u start 0x%08llx stop 0x%08llx\n",
+                map->map, map->speed, (unsigned long long)map->start,
+                (unsigned long long)map->stop);
         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
                 (map->flags==0)?"<NONE>":"",
                 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
diff --git a/drivers/pcmcia/socket_sysfs.c b/drivers/pcmcia/socket_sysfs.c
index ff9a3bb3c88..78d5aab542f 100644
--- a/drivers/pcmcia/socket_sysfs.c
+++ b/drivers/pcmcia/socket_sysfs.c
@@ -300,7 +300,7 @@ static ssize_t pccard_show_cis(struct kobject *kobj,
 
                 if (!(s->state & SOCKET_PRESENT))
                         return -ENODEV;
-                if (pccard_validate_cis(s, BIND_FN_ALL, &chains))
+                if (pccard_validate_cis(s, &chains))
                         return -EIO;
                 if (!chains)
                         return -ENODATA;
diff --git a/drivers/pcmcia/tcic.c b/drivers/pcmcia/tcic.c
index 8eb04230fec..6918849d511 100644
--- a/drivers/pcmcia/tcic.c
+++ b/drivers/pcmcia/tcic.c
@@ -366,7 +366,7 @@ static int __init get_tcic_id(void)
 static int tcic_drv_pcmcia_suspend(struct platform_device *dev,
                                      pm_message_t state)
 {
-        return pcmcia_socket_dev_suspend(&dev->dev, state);
+        return pcmcia_socket_dev_suspend(&dev->dev);
 }
 
 static int tcic_drv_pcmcia_resume(struct platform_device *dev)
@@ -732,8 +732,8 @@ static int tcic_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io)
     u_short base, len, ioctl;
     
     debug(1, "SetIOMap(%d, %d, %#2.2x, %d ns, "
-          "%#x-%#x)\n", psock, io->map, io->flags,
-          io->speed, io->start, io->stop);
+          "%#llx-%#llx)\n", psock, io->map, io->flags, io->speed,
+          (unsigned long long)io->start, (unsigned long long)io->stop);
     if ((io->map > 1) || (io->start > 0xffff) || (io->stop > 0xffff) ||
         (io->stop < io->start)) return -EINVAL;
     tcic_setw(TCIC_ADDR+2, TCIC_ADR2_INDREG | (psock << TCIC_SS_SHFT));
diff --git a/drivers/pcmcia/vrc4171_card.c b/drivers/pcmcia/vrc4171_card.c
index d4ad50d737b..c9fcbdc164e 100644
--- a/drivers/pcmcia/vrc4171_card.c
+++ b/drivers/pcmcia/vrc4171_card.c
@@ -707,7 +707,7 @@ __setup("vrc4171_card=", vrc4171_card_setup);
 static int vrc4171_card_suspend(struct platform_device *dev,
                                      pm_message_t state)
 {
-        return pcmcia_socket_dev_suspend(&dev->dev, state);
+        return pcmcia_socket_dev_suspend(&dev->dev);
 }
 
 static int vrc4171_card_resume(struct platform_device *dev)
diff --git a/drivers/pcmcia/yenta_socket.c b/drivers/pcmcia/yenta_socket.c
index b459e87a30a..abe0e44c6e9 100644
--- a/drivers/pcmcia/yenta_socket.c
+++ b/drivers/pcmcia/yenta_socket.c
@@ -1225,60 +1225,71 @@ static int __devinit yenta_probe (struct pci_dev *dev, const struct pci_device_i
 }
 
 #ifdef CONFIG_PM
-static int yenta_dev_suspend (struct pci_dev *dev, pm_message_t state)
+static int yenta_dev_suspend_noirq(struct device *dev)
 {
-        struct yenta_socket *socket = pci_get_drvdata(dev);
+        struct pci_dev *pdev = to_pci_dev(dev);
+        struct yenta_socket *socket = pci_get_drvdata(pdev);
         int ret;
 
-        ret = pcmcia_socket_dev_suspend(&dev->dev, state);
+        ret = pcmcia_socket_dev_suspend(dev);
 
-        if (socket) {
-                if (socket->type && socket->type->save_state)
-                        socket->type->save_state(socket);
+        if (!socket)
+                return ret;
 
-                /* FIXME: pci_save_state needs to have a better interface */
-                pci_save_state(dev);
-                pci_read_config_dword(dev, 16*4, &socket->saved_state[0]);
-                pci_read_config_dword(dev, 17*4, &socket->saved_state[1]);
-                pci_disable_device(dev);
+        if (socket->type && socket->type->save_state)
+                socket->type->save_state(socket);
 
-                /*
-                 * Some laptops (IBM T22) do not like us putting the Cardbus
-                 * bridge into D3.  At a guess, some other laptop will
-                 * probably require this, so leave it commented out for now.
-                 */
-                /* pci_set_power_state(dev, 3); */
-        }
+        pci_save_state(pdev);
+        pci_read_config_dword(pdev, 16*4, &socket->saved_state[0]);
+        pci_read_config_dword(pdev, 17*4, &socket->saved_state[1]);
+        pci_disable_device(pdev);
+
+        /*
+         * Some laptops (IBM T22) do not like us putting the Cardbus
+         * bridge into D3.  At a guess, some other laptop will
+         * probably require this, so leave it commented out for now.
+         */
+        /* pci_set_power_state(dev, 3); */
 
         return ret;
 }
 
-
-static int yenta_dev_resume (struct pci_dev *dev)
+static int yenta_dev_resume_noirq(struct device *dev)
 {
-        struct yenta_socket *socket = pci_get_drvdata(dev);
+        struct pci_dev *pdev = to_pci_dev(dev);
+        struct yenta_socket *socket = pci_get_drvdata(pdev);
+        int ret;
 
-        if (socket) {
-                int rc;
+        if (!socket)
+                return 0;
 
-                pci_set_power_state(dev, 0);
-                /* FIXME: pci_restore_state needs to have a better interface */
-                pci_restore_state(dev);
-                pci_write_config_dword(dev, 16*4, socket->saved_state[0]);
-                pci_write_config_dword(dev, 17*4, socket->saved_state[1]);
+        pci_write_config_dword(pdev, 16*4, socket->saved_state[0]);
+        pci_write_config_dword(pdev, 17*4, socket->saved_state[1]);
 
-                rc = pci_enable_device(dev);
-                if (rc)
-                        return rc;
+        ret = pci_enable_device(pdev);
+        if (ret)
+                return ret;
 
-                pci_set_master(dev);
+        pci_set_master(pdev);
 
-                if (socket->type && socket->type->restore_state)
-                        socket->type->restore_state(socket);
-        }
+        if (socket->type && socket->type->restore_state)
+                socket->type->restore_state(socket);
 
-        return pcmcia_socket_dev_resume(&dev->dev);
+        return pcmcia_socket_dev_resume(dev);
 }
+
+static struct dev_pm_ops yenta_pm_ops = {
+        .suspend_noirq = yenta_dev_suspend_noirq,
+        .resume_noirq = yenta_dev_resume_noirq,
+        .freeze_noirq = yenta_dev_suspend_noirq,
+        .thaw_noirq = yenta_dev_resume_noirq,
+        .poweroff_noirq = yenta_dev_suspend_noirq,
+        .restore_noirq = yenta_dev_resume_noirq,
+};
+
+#define YENTA_PM_OPS    (&yenta_pm_ops)
+#else
+#define YENTA_PM_OPS    NULL
 #endif
 
 #define CB_ID(vend,dev,type)                            \
@@ -1376,10 +1387,7 @@ static struct pci_driver yenta_cardbus_driver = {
         .id_table       = yenta_table,
         .probe          = yenta_probe,
         .remove         = __devexit_p(yenta_close),
-#ifdef CONFIG_PM
-        .suspend        = yenta_dev_suspend,
-        .resume         = yenta_dev_resume,
-#endif
+        .driver.pm      = YENTA_PM_OPS,
 };