8 files changed, 442 insertions, 44 deletions

diff --git a/drivers/pcmcia/Kconfig b/drivers/pcmcia/Kconfig
index 6485f75d2fb3..ddc741e6ecbf 100644
--- a/drivers/pcmcia/Kconfig
+++ b/drivers/pcmcia/Kconfig
@@ -221,6 +221,13 @@ config PCMCIA_VRC4173
         tristate "NEC VRC4173 CARDU support"
         depends on CPU_VR41XX && PCI && PCMCIA
 
+config OMAP_CF
+        tristate "OMAP CompactFlash Controller"
+        depends on PCMCIA && ARCH_OMAP16XX
+        help
+          Say Y here to support the CompactFlash controller on OMAP.
+          Note that this doesn't support "True IDE" mode.
+
 config PCCARD_NONSTATIC
         tristate
 
diff --git a/drivers/pcmcia/Makefile b/drivers/pcmcia/Makefile
index ef694c74dfb7..a41fbb38fdcb 100644
--- a/drivers/pcmcia/Makefile
+++ b/drivers/pcmcia/Makefile
@@ -34,6 +34,7 @@ obj-$(CONFIG_M32R_CFC)				+= m32r_cfc.o
 obj-$(CONFIG_PCMCIA_AU1X00)                     += au1x00_ss.o
 obj-$(CONFIG_PCMCIA_VRC4171)                    += vrc4171_card.o
 obj-$(CONFIG_PCMCIA_VRC4173)                    += vrc4173_cardu.o
+obj-$(CONFIG_OMAP_CF)                           += omap_cf.o
 
 sa11xx_core-y                                   += soc_common.o sa11xx_base.o
 pxa2xx_core-y                                   += soc_common.o pxa2xx_base.o
diff --git a/drivers/pcmcia/cs.c b/drivers/pcmcia/cs.c
index e39178fc59d0..fabd3529cebc 100644
--- a/drivers/pcmcia/cs.c
+++ b/drivers/pcmcia/cs.c
@@ -654,9 +654,10 @@ static int pccardd(void *__skt)
                 skt->thread = NULL;
                 complete_and_exit(&skt->thread_done, 0);
         }
-        complete(&skt->thread_done);
 
         add_wait_queue(&skt->thread_wait, &wait);
+        complete(&skt->thread_done);
+
         for (;;) {
                 unsigned long flags;
                 unsigned int events;
@@ -682,11 +683,11 @@ static int pccardd(void *__skt)
                         continue;
                 }
 
-                schedule();
-                try_to_freeze();
-
                 if (!skt->thread)
                         break;
+
+                schedule();
+                try_to_freeze();
         }
         remove_wait_queue(&skt->thread_wait, &wait);
 
diff --git a/drivers/pcmcia/cs_internal.h b/drivers/pcmcia/cs_internal.h
index 6bbfbd0e02a5..55867bc7f199 100644
--- a/drivers/pcmcia/cs_internal.h
+++ b/drivers/pcmcia/cs_internal.h
@@ -17,9 +17,6 @@
 
 #include <linux/config.h>
 
-#define CLIENT_MAGIC    0x51E6
-typedef struct client_t client_t;
-
 /* Flags in client state */
 #define CLIENT_CONFIG_LOCKED    0x0001
 #define CLIENT_IRQ_REQ          0x0002
@@ -45,7 +42,6 @@ typedef struct region_t {
 typedef struct config_t {
     u_int               state;
     u_int               Attributes;
-    u_int               Vcc, Vpp1, Vpp2;
     u_int               IntType;
     u_int               ConfigBase;
     u_char              Status, Pin, Copy, Option, ExtStatus;
diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c
index 43da2e92d50f..080608c7381a 100644
--- a/drivers/pcmcia/ds.c
+++ b/drivers/pcmcia/ds.c
@@ -354,6 +354,7 @@ static void pcmcia_release_dev(struct device *dev)
         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
         ds_dbg(1, "releasing dev %p\n", p_dev);
         pcmcia_put_socket(p_dev->socket);
+        kfree(p_dev->devname);
         kfree(p_dev);
 }
 
@@ -424,9 +425,13 @@ static int pcmcia_device_query(struct pcmcia_device *p_dev)
 {
         cistpl_manfid_t manf_id;
         cistpl_funcid_t func_id;
-        cistpl_vers_1_t vers1;
+        cistpl_vers_1_t *vers1;
         unsigned int i;
 
+        vers1 = kmalloc(sizeof(*vers1), GFP_KERNEL);
+        if (!vers1)
+                return -ENOMEM;
+
         if (!pccard_read_tuple(p_dev->socket, p_dev->func,
                                CISTPL_MANFID, &manf_id)) {
                 p_dev->manf_id = manf_id.manf;
@@ -443,23 +448,30 @@ static int pcmcia_device_query(struct pcmcia_device *p_dev)
                 /* rule of thumb: cards with no FUNCID, but with
                  * common memory device geometry information, are
                  * probably memory cards (from pcmcia-cs) */
-                cistpl_device_geo_t devgeo;
+                cistpl_device_geo_t *devgeo;
+
+                devgeo = kmalloc(sizeof(*devgeo), GFP_KERNEL);
+                if (!devgeo) {
+                        kfree(vers1);
+                        return -ENOMEM;
+                }
                 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
-                                      CISTPL_DEVICE_GEO, &devgeo)) {
+                                      CISTPL_DEVICE_GEO, devgeo)) {
                         ds_dbg(0, "mem device geometry probably means "
                                "FUNCID_MEMORY\n");
                         p_dev->func_id = CISTPL_FUNCID_MEMORY;
                         p_dev->has_func_id = 1;
                 }
+                kfree(devgeo);
         }
 
         if (!pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_VERS_1,
-                               &vers1)) {
-                for (i=0; i < vers1.ns; i++) {
+                               vers1)) {
+                for (i=0; i < vers1->ns; i++) {
                         char *tmp;
                         unsigned int length;
 
-                        tmp = vers1.str + vers1.ofs[i];
+                        tmp = vers1->str + vers1->ofs[i];
 
                         length = strlen(tmp) + 1;
                         if ((length < 3) || (length > 255))
@@ -475,6 +487,7 @@ static int pcmcia_device_query(struct pcmcia_device *p_dev)
                 }
         }
 
+        kfree(vers1);
         return 0;
 }
 
@@ -492,6 +505,7 @@ struct pcmcia_device * pcmcia_device_add(struct pcmcia_socket *s, unsigned int f
 {
         struct pcmcia_device *p_dev;
         unsigned long flags;
+        int bus_id_len;
 
         s = pcmcia_get_socket(s);
         if (!s)
@@ -515,7 +529,12 @@ struct pcmcia_device * pcmcia_device_add(struct pcmcia_socket *s, unsigned int f
         p_dev->dev.bus = &pcmcia_bus_type;
         p_dev->dev.parent = s->dev.dev;
         p_dev->dev.release = pcmcia_release_dev;
-        sprintf (p_dev->dev.bus_id, "%d.%d", p_dev->socket->sock, p_dev->device_no);
+        bus_id_len = sprintf (p_dev->dev.bus_id, "%d.%d", p_dev->socket->sock, p_dev->device_no);
+
+        p_dev->devname = kmalloc(6 + bus_id_len + 1, GFP_KERNEL);
+        if (!p_dev->devname)
+                goto err_free;
+        sprintf (p_dev->devname, "pcmcia%s", p_dev->dev.bus_id);
 
         /* compat */
         p_dev->state = CLIENT_UNBOUND;
@@ -540,6 +559,7 @@ struct pcmcia_device * pcmcia_device_add(struct pcmcia_socket *s, unsigned int f
         return p_dev;
 
  err_free:
+        kfree(p_dev->devname);
         kfree(p_dev);
         s->device_count--;
  err_put:
diff --git a/drivers/pcmcia/omap_cf.c b/drivers/pcmcia/omap_cf.c
new file mode 100644
index 000000000000..08d1c9288264
--- /dev/null
+++ b/drivers/pcmcia/omap_cf.c
@@ -0,0 +1,373 @@
+/*
+ * omap_cf.c -- OMAP 16xx CompactFlash controller driver
+ *
+ * Copyright (c) 2005 David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+
+#include <pcmcia/ss.h>
+
+#include <asm/hardware.h>
+#include <asm/io.h>
+#include <asm/mach-types.h>
+#include <asm/sizes.h>
+
+#include <asm/arch/mux.h>
+#include <asm/arch/tc.h>
+
+
+/* NOTE:  don't expect this to support many I/O cards.  The 16xx chips have
+ * hard-wired timings to support Compact Flash memory cards; they won't work
+ * with various other devices (like WLAN adapters) without some external
+ * logic to help out.
+ *
+ * NOTE:  CF controller docs disagree with address space docs as to where
+ * CF_BASE really lives; this is a doc erratum.
+ */
+#define CF_BASE 0xfffe2800
+
+/* status; read after IRQ */
+#define CF_STATUS_REG           __REG16(CF_BASE + 0x00)
+#       define  CF_STATUS_BAD_READ      (1 << 2)
+#       define  CF_STATUS_BAD_WRITE     (1 << 1)
+#       define  CF_STATUS_CARD_DETECT   (1 << 0)
+
+/* which chipselect (CS0..CS3) is used for CF (active low) */
+#define CF_CFG_REG              __REG16(CF_BASE + 0x02)
+
+/* card reset */
+#define CF_CONTROL_REG          __REG16(CF_BASE + 0x04)
+#       define  CF_CONTROL_RESET        (1 << 0)
+
+#define omap_cf_present() (!(CF_STATUS_REG & CF_STATUS_CARD_DETECT))
+
+/*--------------------------------------------------------------------------*/
+
+static const char driver_name[] = "omap_cf";
+
+struct omap_cf_socket {
+        struct pcmcia_socket    socket;
+
+        struct timer_list       timer;
+        unsigned                present:1;
+        unsigned                active:1;
+
+        struct platform_device  *pdev;
+        unsigned long           phys_cf;
+        u_int                   irq;
+};
+
+#define POLL_INTERVAL           (2 * HZ)
+
+#define SZ_2K                   (2 * SZ_1K)
+
+/*--------------------------------------------------------------------------*/
+
+static int omap_cf_ss_init(struct pcmcia_socket *s)
+{
+        return 0;
+}
+
+/* the timer is primarily to kick this socket's pccardd */
+static void omap_cf_timer(unsigned long _cf)
+{
+        struct omap_cf_socket   *cf = (void *) _cf;
+        unsigned                present = omap_cf_present();
+
+        if (present != cf->present) {
+                cf->present = present;
+                pr_debug("%s: card %s\n", driver_name,
+                        present ? "present" : "gone");
+                pcmcia_parse_events(&cf->socket, SS_DETECT);
+        }
+
+        if (cf->active)
+                mod_timer(&cf->timer, jiffies + POLL_INTERVAL);
+}
+
+/* This irq handler prevents "irqNNN: nobody cared" messages as drivers
+ * claim the card's IRQ.  It may also detect some card insertions, but
+ * not removals; it can't always eliminate timer irqs.
+ */
+static irqreturn_t omap_cf_irq(int irq, void *_cf, struct pt_regs *r)
+{
+        omap_cf_timer((unsigned long)_cf);
+        return IRQ_HANDLED;
+}
+
+static int omap_cf_get_status(struct pcmcia_socket *s, u_int *sp)
+{
+        if (!sp)
+                return -EINVAL;
+
+        /* FIXME power management should probably be board-specific:
+         *  - 3VCARD vs XVCARD (OSK only handles 3VCARD)
+         *  - POWERON (switched on/off by set_socket)
+         */
+        if (omap_cf_present()) {
+                struct omap_cf_socket   *cf;
+
+                *sp = SS_READY | SS_DETECT | SS_POWERON | SS_3VCARD;
+                cf = container_of(s, struct omap_cf_socket, socket);
+                s->irq.AssignedIRQ = cf->irq;
+        } else
+                *sp = 0;
+        return 0;
+}
+
+static int
+omap_cf_set_socket(struct pcmcia_socket *sock, struct socket_state_t *s)
+{
+        u16             control;
+
+        /* FIXME some non-OSK boards will support power switching */
+        switch (s->Vcc) {
+        case 0:
+        case 33:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        control = CF_CONTROL_REG;
+        if (s->flags & SS_RESET)
+                CF_CONTROL_REG = CF_CONTROL_RESET;
+        else
+                CF_CONTROL_REG = 0;
+
+        pr_debug("%s: Vcc %d, io_irq %d, flags %04x csc %04x\n",
+                driver_name, s->Vcc, s->io_irq, s->flags, s->csc_mask);
+
+        return 0;
+}
+
+static int omap_cf_ss_suspend(struct pcmcia_socket *s)
+{
+        pr_debug("%s: %s\n", driver_name, __FUNCTION__);
+        return omap_cf_set_socket(s, &dead_socket);
+}
+
+/* regions are 2K each:  mem, attrib, io (and reserved-for-ide) */
+
+static int
+omap_cf_set_io_map(struct pcmcia_socket *s, struct pccard_io_map *io)
+{
+        struct omap_cf_socket   *cf;
+
+        cf = container_of(s, struct omap_cf_socket, socket);
+        io->flags &= MAP_ACTIVE|MAP_ATTRIB|MAP_16BIT;
+        io->start = cf->phys_cf + SZ_4K;
+        io->stop = io->start + SZ_2K - 1;
+        return 0;
+}
+
+static int
+omap_cf_set_mem_map(struct pcmcia_socket *s, struct pccard_mem_map *map)
+{
+        struct omap_cf_socket   *cf;
+
+        if (map->card_start)
+                return -EINVAL;
+        cf = container_of(s, struct omap_cf_socket, socket);
+        map->static_start = cf->phys_cf;
+        map->flags &= MAP_ACTIVE|MAP_ATTRIB|MAP_16BIT;
+        if (map->flags & MAP_ATTRIB)
+                map->static_start += SZ_2K;
+        return 0;
+}
+
+static struct pccard_operations omap_cf_ops = {
+        .init                   = omap_cf_ss_init,
+        .suspend                = omap_cf_ss_suspend,
+        .get_status             = omap_cf_get_status,
+        .set_socket             = omap_cf_set_socket,
+        .set_io_map             = omap_cf_set_io_map,
+        .set_mem_map            = omap_cf_set_mem_map,
+};
+
+/*--------------------------------------------------------------------------*/
+
+/*
+ * NOTE:  right now the only board-specific platform_data is
+ * "what chipselect is used".  Boards could want more.
+ */
+
+static int __init omap_cf_probe(struct device *dev)
+{
+        unsigned                seg;
+        struct omap_cf_socket   *cf;
+        struct platform_device  *pdev = to_platform_device(dev);
+        int                     irq;
+        int                     status;
+
+        seg = (int) dev->platform_data;
+        if (seg == 0 || seg > 3)
+                return -ENODEV;
+
+        /* either CFLASH.IREQ (INT_1610_CF) or some GPIO */
+        irq = platform_get_irq(pdev, 0);
+        if (!irq)
+                return -EINVAL;
+
+        cf = kcalloc(1, sizeof *cf, GFP_KERNEL);
+        if (!cf)
+                return -ENOMEM;
+        init_timer(&cf->timer);
+        cf->timer.function = omap_cf_timer;
+        cf->timer.data = (unsigned long) cf;
+
+        cf->pdev = pdev;
+        dev_set_drvdata(dev, cf);
+
+        /* this primarily just shuts up irq handling noise */
+        status = request_irq(irq, omap_cf_irq, SA_SHIRQ,
+                        driver_name, cf);
+        if (status < 0)
+                goto fail0;
+        cf->irq = irq;
+        cf->socket.pci_irq = irq;
+
+        switch (seg) {
+        /* NOTE: CS0 could be configured too ... */
+        case 1:
+                cf->phys_cf = OMAP_CS1_PHYS;
+                break;
+        case 2:
+                cf->phys_cf = OMAP_CS2_PHYS;
+                break;
+        case 3:
+                cf->phys_cf = omap_cs3_phys();
+                break;
+        default:
+                goto  fail1;
+        }
+
+        /* pcmcia layer only remaps "real" memory */
+        cf->socket.io_offset = (unsigned long)
+                        ioremap(cf->phys_cf + SZ_4K, SZ_2K);
+        if (!cf->socket.io_offset)
+                goto fail1;
+
+        if (!request_mem_region(cf->phys_cf, SZ_8K, driver_name))
+                goto fail1;
+
+        /* NOTE:  CF conflicts with MMC1 */
+        omap_cfg_reg(W11_1610_CF_CD1);
+        omap_cfg_reg(P11_1610_CF_CD2);
+        omap_cfg_reg(R11_1610_CF_IOIS16);
+        omap_cfg_reg(V10_1610_CF_IREQ);
+        omap_cfg_reg(W10_1610_CF_RESET);
+
+        CF_CFG_REG = ~(1 << seg);
+
+        pr_info("%s: cs%d on irq %d\n", driver_name, seg, irq);
+
+        /* NOTE:  better EMIFS setup might support more cards; but the
+         * TRM only shows how to affect regular flash signals, not their
+         * CF/PCMCIA variants...
+         */
+        pr_debug("%s: cs%d, previous ccs %08x acs %08x\n", driver_name,
+                        seg, EMIFS_CCS(seg), EMIFS_ACS(seg));
+        EMIFS_CCS(seg) = 0x0004a1b3;    /* synch mode 4 etc */
+        EMIFS_ACS(seg) = 0x00000000;    /* OE hold/setup */
+
+        /* CF uses armxor_ck, which is "always" available */
+
+        pr_debug("%s: sts %04x cfg %04x control %04x %s\n", driver_name,
+                CF_STATUS_REG, CF_CFG_REG, CF_CONTROL_REG,
+                omap_cf_present() ? "present" : "(not present)");
+
+        cf->socket.owner = THIS_MODULE;
+        cf->socket.dev.dev = dev;
+        cf->socket.ops = &omap_cf_ops;
+        cf->socket.resource_ops = &pccard_static_ops;
+        cf->socket.features = SS_CAP_PCCARD | SS_CAP_STATIC_MAP
+                                | SS_CAP_MEM_ALIGN;
+        cf->socket.map_size = SZ_2K;
+
+        status = pcmcia_register_socket(&cf->socket);
+        if (status < 0)
+                goto fail2;
+
+        cf->active = 1;
+        mod_timer(&cf->timer, jiffies + POLL_INTERVAL);
+        return 0;
+
+fail2:
+        iounmap((void __iomem *) cf->socket.io_offset);
+        release_mem_region(cf->phys_cf, SZ_8K);
+fail1:
+        free_irq(irq, cf);
+fail0:
+        kfree(cf);
+        return status;
+}
+
+static int __devexit omap_cf_remove(struct device *dev)
+{
+        struct omap_cf_socket *cf = dev_get_drvdata(dev);
+
+        cf->active = 0;
+        pcmcia_unregister_socket(&cf->socket);
+        del_timer_sync(&cf->timer);
+        iounmap((void __iomem *) cf->socket.io_offset);
+        release_mem_region(cf->phys_cf, SZ_8K);
+        free_irq(cf->irq, cf);
+        kfree(cf);
+        return 0;
+}
+
+static int omap_cf_suspend(struct device *dev, pm_message_t mesg, u32 level)
+{
+        if (level != SUSPEND_SAVE_STATE)
+                return 0;
+        return pcmcia_socket_dev_suspend(dev, mesg);
+}
+
+static int omap_cf_resume(struct device *dev, u32 level)
+{
+        if (level != RESUME_RESTORE_STATE)
+                return 0;
+        return pcmcia_socket_dev_resume(dev);
+}
+
+static struct device_driver omap_cf_driver = {
+        .name           = (char *) driver_name,
+        .bus            = &platform_bus_type,
+        .probe          = omap_cf_probe,
+        .remove         = __devexit_p(omap_cf_remove),
+        .suspend        = omap_cf_suspend,
+        .resume         = omap_cf_resume,
+};
+
+static int __init omap_cf_init(void)
+{
+        if (cpu_is_omap16xx())
+                driver_register(&omap_cf_driver);
+        return 0;
+}
+
+static void __exit omap_cf_exit(void)
+{
+        if (cpu_is_omap16xx())
+                driver_unregister(&omap_cf_driver);
+}
+
+module_init(omap_cf_init);
+module_exit(omap_cf_exit);
+
+MODULE_DESCRIPTION("OMAP CF Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/pcmcia/pcmcia_resource.c b/drivers/pcmcia/pcmcia_resource.c
index 599b116d9747..89022ad5b520 100644
--- a/drivers/pcmcia/pcmcia_resource.c
+++ b/drivers/pcmcia/pcmcia_resource.c
@@ -447,7 +447,7 @@ int pcmcia_modify_configuration(struct pcmcia_device *p_dev,
             (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
                 if (mod->Vpp1 != mod->Vpp2)
                         return CS_BAD_VPP;
-                c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1;
+                s->socket.Vpp = mod->Vpp1;
                 if (s->ops->set_socket(s, &s->socket))
                         return CS_BAD_VPP;
         } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
@@ -623,8 +623,6 @@ int pcmcia_request_configuration(struct pcmcia_device *p_dev,
         if (s->ops->set_socket(s, &s->socket))
                 return CS_BAD_VPP;
 
-        c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1;
-
         /* Pick memory or I/O card, DMA mode, interrupt */
         c->IntType = req->IntType;
         c->Attributes = req->Attributes;
@@ -822,7 +820,7 @@ int pcmcia_request_irq(struct pcmcia_device *p_dev, irq_req_t *req)
                                           ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
                                            (s->functions > 1) ||
                                            (irq == s->pci_irq)) ? SA_SHIRQ : 0,
-                                          p_dev->dev.bus_id,
+                                          p_dev->devname,
                                           (req->Attributes & IRQ_HANDLE_PRESENT) ? req->Instance : data);
                         if (!ret) {
                                 if (!(req->Attributes & IRQ_HANDLE_PRESENT))
@@ -832,7 +830,8 @@ int pcmcia_request_irq(struct pcmcia_device *p_dev, irq_req_t *req)
                 }
         }
 #endif
-        if (ret) {
+        /* only assign PCI irq if no IRQ already assigned */
+        if (ret && !s->irq.AssignedIRQ) {
                 if (!s->pci_irq)
                         return ret;
                 irq = s->pci_irq;
@@ -843,7 +842,7 @@ int pcmcia_request_irq(struct pcmcia_device *p_dev, irq_req_t *req)
                                 ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
                                  (s->functions > 1) ||
                                  (irq == s->pci_irq)) ? SA_SHIRQ : 0,
-                                p_dev->dev.bus_id, req->Instance))
+                                p_dev->devname, req->Instance))
                         return CS_IN_USE;
         }
 
diff --git a/drivers/pcmcia/yenta_socket.c b/drivers/pcmcia/yenta_socket.c
index 0347a29f297b..f0997c36c9b7 100644
--- a/drivers/pcmcia/yenta_socket.c
+++ b/drivers/pcmcia/yenta_socket.c
@@ -72,6 +72,7 @@ static inline void cb_writel(struct yenta_socket *socket, unsigned reg, u32 val)
 {
         debug("%p %04x %08x\n", socket, reg, val);
         writel(val, socket->base + reg);
+        readl(socket->base + reg); /* avoid problems with PCI write posting */
 }
 
 static inline u8 config_readb(struct yenta_socket *socket, unsigned offset)
@@ -136,6 +137,7 @@ static inline void exca_writeb(struct yenta_socket *socket, unsigned reg, u8 val
 {
         debug("%p %04x %02x\n", socket, reg, val);
         writeb(val, socket->base + 0x800 + reg);
+        readb(socket->base + 0x800 + reg); /* PCI write posting... */
 }
 
 static void exca_writew(struct yenta_socket *socket, unsigned reg, u16 val)
@@ -143,6 +145,10 @@ static void exca_writew(struct yenta_socket *socket, unsigned reg, u16 val)
         debug("%p %04x %04x\n", socket, reg, val);
         writeb(val, socket->base + 0x800 + reg);
         writeb(val >> 8, socket->base + 0x800 + reg + 1);
+
+        /* PCI write posting... */
+        readb(socket->base + 0x800 + reg);
+        readb(socket->base + 0x800 + reg + 1);
 }
 
 /*
@@ -667,7 +673,7 @@ static int yenta_search_res(struct yenta_socket *socket, struct resource *res,
         return 0;
 }
 
-static void yenta_allocate_res(struct yenta_socket *socket, int nr, unsigned type, int addr_start, int addr_end)
+static int yenta_allocate_res(struct yenta_socket *socket, int nr, unsigned type, int addr_start, int addr_end)
 {
         struct resource *root, *res;
         struct pci_bus_region region;
@@ -676,7 +682,7 @@ static void yenta_allocate_res(struct yenta_socket *socket, int nr, unsigned typ
         res = socket->dev->resource + PCI_BRIDGE_RESOURCES + nr;
         /* Already allocated? */
         if (res->parent)
-                return;
+                return 0;
 
         /* The granularity of the memory limit is 4kB, on IO it's 4 bytes */
         mask = ~0xfff;
@@ -692,7 +698,7 @@ static void yenta_allocate_res(struct yenta_socket *socket, int nr, unsigned typ
                 pcibios_bus_to_resource(socket->dev, res, &region);
                 root = pci_find_parent_resource(socket->dev, res);
                 if (root && (request_resource(root, res) == 0))
-                        return;
+                        return 0;
                 printk(KERN_INFO "yenta %s: Preassigned resource %d busy or not available, reconfiguring...\n",
                                 pci_name(socket->dev), nr);
         }
@@ -700,35 +706,27 @@ static void yenta_allocate_res(struct yenta_socket *socket, int nr, unsigned typ
         if (type & IORESOURCE_IO) {
                 if ((yenta_search_res(socket, res, BRIDGE_IO_MAX)) ||
                     (yenta_search_res(socket, res, BRIDGE_IO_ACC)) ||
-                    (yenta_search_res(socket, res, BRIDGE_IO_MIN))) {
-                        config_writel(socket, addr_start, res->start);
-                        config_writel(socket, addr_end, res->end);
-                        return;
-                }
+                    (yenta_search_res(socket, res, BRIDGE_IO_MIN)))
+                        return 1;
         } else {
                 if (type & IORESOURCE_PREFETCH) {
                         if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) ||
                             (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) ||
-                            (yenta_search_res(socket, res, BRIDGE_MEM_MIN))) {
-                                config_writel(socket, addr_start, res->start);
-                                config_writel(socket, addr_end, res->end);
-                                return;
-                        }
+                            (yenta_search_res(socket, res, BRIDGE_MEM_MIN)))
+                                return 1;
                         /* Approximating prefetchable by non-prefetchable */
                         res->flags = IORESOURCE_MEM;
                 }
                 if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) ||
                     (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) ||
-                    (yenta_search_res(socket, res, BRIDGE_MEM_MIN))) {
-                        config_writel(socket, addr_start, res->start);
-                        config_writel(socket, addr_end, res->end);
-                        return;
-                }
+                    (yenta_search_res(socket, res, BRIDGE_MEM_MIN)))
+                        return 1;
         }
 
         printk(KERN_INFO "yenta %s: no resource of type %x available, trying to continue...\n",
                pci_name(socket->dev), type);
         res->start = res->end = res->flags = 0;
+        return 0;
 }
 
 /*
@@ -736,14 +734,17 @@ static void yenta_allocate_res(struct yenta_socket *socket, int nr, unsigned typ
  */
 static void yenta_allocate_resources(struct yenta_socket *socket)
 {
-        yenta_allocate_res(socket, 0, IORESOURCE_IO,
+        int program = 0;
+        program += yenta_allocate_res(socket, 0, IORESOURCE_IO,
                            PCI_CB_IO_BASE_0, PCI_CB_IO_LIMIT_0);
-        yenta_allocate_res(socket, 1, IORESOURCE_IO,
+        program += yenta_allocate_res(socket, 1, IORESOURCE_IO,
                            PCI_CB_IO_BASE_1, PCI_CB_IO_LIMIT_1);
-        yenta_allocate_res(socket, 2, IORESOURCE_MEM|IORESOURCE_PREFETCH,
+        program += yenta_allocate_res(socket, 2, IORESOURCE_MEM|IORESOURCE_PREFETCH,
                            PCI_CB_MEMORY_BASE_0, PCI_CB_MEMORY_LIMIT_0);
-        yenta_allocate_res(socket, 3, IORESOURCE_MEM,
+        program += yenta_allocate_res(socket, 3, IORESOURCE_MEM,
                            PCI_CB_MEMORY_BASE_1, PCI_CB_MEMORY_LIMIT_1);
+        if (program)
+                pci_setup_cardbus(socket->dev->subordinate);
 }
 
 
@@ -758,7 +759,7 @@ static void yenta_free_resources(struct yenta_socket *socket)
                 res = socket->dev->resource + PCI_BRIDGE_RESOURCES + i;
                 if (res->start != 0 && res->end != 0)
                         release_resource(res);
-                res->start = res->end = 0;
+                res->start = res->end = res->flags = 0;
         }
 }