1 files changed, 162 insertions, 472 deletions

diff --git a/drivers/pcmcia/pcmcia_resource.c b/drivers/pcmcia/pcmcia_resource.c
index 7c3d03bb4f30..29f91fac1dff 100644
--- a/drivers/pcmcia/pcmcia_resource.c
+++ b/drivers/pcmcia/pcmcia_resource.c
@@ -23,6 +23,8 @@
 #include <linux/netdevice.h>
 #include <linux/slab.h>
 
+#include <asm/irq.h>
+
 #include <pcmcia/cs_types.h>
 #include <pcmcia/ss.h>
 #include <pcmcia/cs.h>
@@ -38,29 +40,6 @@ static int io_speed;
 module_param(io_speed, int, 0444);
 
 
-#ifdef CONFIG_PCMCIA_PROBE
-#include <asm/irq.h>
-/* mask of IRQs already reserved by other cards, we should avoid using them */
-static u8 pcmcia_used_irq[NR_IRQS];
-#endif
-
-static int pcmcia_adjust_io_region(struct resource *res, unsigned long start,
-                                   unsigned long end, struct pcmcia_socket *s)
-{
-        if (s->resource_ops->adjust_io_region)
-                return s->resource_ops->adjust_io_region(res, start, end, s);
-        return -ENOMEM;
-}
-
-static struct resource *pcmcia_find_io_region(unsigned long base, int num,
-                                              unsigned long align,
-                                              struct pcmcia_socket *s)
-{
-        if (s->resource_ops->find_io)
-                return s->resource_ops->find_io(base, num, align, s);
-        return NULL;
-}
-
 int pcmcia_validate_mem(struct pcmcia_socket *s)
 {
         if (s->resource_ops->validate_mem)
@@ -86,8 +65,7 @@ struct resource *pcmcia_find_mem_region(u_long base, u_long num, u_long align,
 static int alloc_io_space(struct pcmcia_socket *s, u_int attr,
                           unsigned int *base, unsigned int num, u_int lines)
 {
-        int i;
-        unsigned int try, align;
+        unsigned int align;
 
         align = (*base) ? (lines ? 1<<lines : 0) : 1;
         if (align && (align < num)) {
@@ -104,50 +82,8 @@ static int alloc_io_space(struct pcmcia_socket *s, u_int attr,
                        *base, align);
                 align = 0;
         }
-        if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
-                *base = s->io_offset | (*base & 0x0fff);
-                return 0;
-        }
-        /* Check for an already-allocated window that must conflict with
-         * what was asked for.  It is a hack because it does not catch all
-         * potential conflicts, just the most obvious ones.
-         */
-        for (i = 0; i < MAX_IO_WIN; i++)
-                if ((s->io[i].res) && *base &&
-                    ((s->io[i].res->start & (align-1)) == *base))
-                        return 1;
-        for (i = 0; i < MAX_IO_WIN; i++) {
-                if (!s->io[i].res) {
-                        s->io[i].res = pcmcia_find_io_region(*base, num, align, s);
-                        if (s->io[i].res) {
-                                *base = s->io[i].res->start;
-                                s->io[i].res->flags = (s->io[i].res->flags & ~IORESOURCE_BITS) | (attr & IORESOURCE_BITS);
-                                s->io[i].InUse = num;
-                                break;
-                        } else
-                                return 1;
-                } else if ((s->io[i].res->flags & IORESOURCE_BITS) != (attr & IORESOURCE_BITS))
-                        continue;
-                /* Try to extend top of window */
-                try = s->io[i].res->end + 1;
-                if ((*base == 0) || (*base == try))
-                        if (pcmcia_adjust_io_region(s->io[i].res, s->io[i].res->start,
-                                                    s->io[i].res->end + num, s) == 0) {
-                                *base = try;
-                                s->io[i].InUse += num;
-                                break;
-                        }
-                /* Try to extend bottom of window */
-                try = s->io[i].res->start - num;
-                if ((*base == 0) || (*base == try))
-                        if (pcmcia_adjust_io_region(s->io[i].res, s->io[i].res->start - num,
-                                                    s->io[i].res->end, s) == 0) {
-                                *base = try;
-                                s->io[i].InUse += num;
-                                break;
-                        }
-        }
-        return (i == MAX_IO_WIN);
+
+        return s->resource_ops->find_io(s, attr, base, num, align);
 } /* alloc_io_space */
 
 
@@ -187,6 +123,7 @@ int pcmcia_access_configuration_register(struct pcmcia_device *p_dev,
         config_t *c;
         int addr;
         u_char val;
+        int ret = 0;
 
         if (!p_dev || !p_dev->function_config)
                 return -EINVAL;
@@ -203,11 +140,10 @@ int pcmcia_access_configuration_register(struct pcmcia_device *p_dev,
         }
 
         addr = (c->ConfigBase + reg->Offset) >> 1;
-        mutex_unlock(&s->ops_mutex);
 
         switch (reg->Action) {
         case CS_READ:
-                pcmcia_read_cis_mem(s, 1, addr, 1, &val);
+                ret = pcmcia_read_cis_mem(s, 1, addr, 1, &val);
                 reg->Value = val;
                 break;
         case CS_WRITE:
@@ -216,10 +152,11 @@ int pcmcia_access_configuration_register(struct pcmcia_device *p_dev,
                 break;
         default:
                 dev_dbg(&s->dev, "Invalid conf register request\n");
-                return -EINVAL;
+                ret = -EINVAL;
                 break;
         }
-        return 0;
+        mutex_unlock(&s->ops_mutex);
+        return ret;
 } /* pcmcia_access_configuration_register */
 EXPORT_SYMBOL(pcmcia_access_configuration_register);
 
@@ -275,19 +212,9 @@ int pcmcia_modify_configuration(struct pcmcia_device *p_dev,
                 goto unlock;
         }
 
-        if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
-                if (mod->Attributes & CONF_ENABLE_IRQ) {
-                        c->Attributes |= CONF_ENABLE_IRQ;
-                        s->socket.io_irq = s->irq.AssignedIRQ;
-                } else {
-                        c->Attributes &= ~CONF_ENABLE_IRQ;
-                        s->socket.io_irq = 0;
-                }
-                s->ops->set_socket(s, &s->socket);
-        }
-
-        if (mod->Attributes & CONF_VCC_CHANGE_VALID) {
-                dev_dbg(&s->dev, "changing Vcc is not allowed at this time\n");
+        if (mod->Attributes & (CONF_IRQ_CHANGE_VALID | CONF_VCC_CHANGE_VALID)) {
+                dev_dbg(&s->dev,
+                        "changing Vcc or IRQ is not allowed at this time\n");
                 ret = -EINVAL;
                 goto unlock;
         }
@@ -422,52 +349,6 @@ out:
 } /* pcmcia_release_io */
 
 
-static int pcmcia_release_irq(struct pcmcia_device *p_dev, irq_req_t *req)
-{
-        struct pcmcia_socket *s = p_dev->socket;
-        config_t *c;
-        int ret = -EINVAL;
-
-        mutex_lock(&s->ops_mutex);
-
-        c = p_dev->function_config;
-
-        if (!p_dev->_irq)
-                goto out;
-
-        p_dev->_irq = 0;
-
-        if (c->state & CONFIG_LOCKED)
-                goto out;
-
-        if (c->irq.Attributes != req->Attributes) {
-                dev_dbg(&s->dev, "IRQ attributes must match assigned ones\n");
-                goto out;
-        }
-        if (s->irq.AssignedIRQ != req->AssignedIRQ) {
-                dev_dbg(&s->dev, "IRQ must match assigned one\n");
-                goto out;
-        }
-        if (--s->irq.Config == 0) {
-                c->state &= ~CONFIG_IRQ_REQ;
-                s->irq.AssignedIRQ = 0;
-        }
-
-        if (req->Handler)
-                free_irq(req->AssignedIRQ, p_dev->priv);
-
-#ifdef CONFIG_PCMCIA_PROBE
-        pcmcia_used_irq[req->AssignedIRQ]--;
-#endif
-        ret = 0;
-
-out:
-        mutex_unlock(&s->ops_mutex);
-
-        return ret;
-} /* pcmcia_release_irq */
-
-
 int pcmcia_release_window(struct pcmcia_device *p_dev, window_handle_t wh)
 {
         struct pcmcia_socket *s = p_dev->socket;
@@ -551,12 +432,11 @@ int pcmcia_request_configuration(struct pcmcia_device *p_dev,
         if (req->Attributes & CONF_ENABLE_SPKR)
                 s->socket.flags |= SS_SPKR_ENA;
         if (req->Attributes & CONF_ENABLE_IRQ)
-                s->socket.io_irq = s->irq.AssignedIRQ;
+                s->socket.io_irq = s->pcmcia_irq;
         else
                 s->socket.io_irq = 0;
         s->ops->set_socket(s, &s->socket);
         s->lock_count++;
-        mutex_unlock(&s->ops_mutex);
 
         /* Set up CIS configuration registers */
         base = c->ConfigBase = req->ConfigBase;
@@ -574,9 +454,9 @@ int pcmcia_request_configuration(struct pcmcia_device *p_dev,
                         if (req->Present & PRESENT_IOBASE_0)
                                 c->Option |= COR_ADDR_DECODE;
                 }
-                if (c->state & CONFIG_IRQ_REQ)
-                        if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
-                                c->Option |= COR_LEVEL_REQ;
+                if ((req->Attributes & CONF_ENABLE_IRQ) &&
+                        !(req->Attributes & CONF_ENABLE_PULSE_IRQ))
+                        c->Option |= COR_LEVEL_REQ;
                 pcmcia_write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
                 mdelay(40);
         }
@@ -605,7 +485,6 @@ int pcmcia_request_configuration(struct pcmcia_device *p_dev,
 
         /* Configure I/O windows */
         if (c->state & CONFIG_IO_REQ) {
-                mutex_lock(&s->ops_mutex);
                 iomap.speed = io_speed;
                 for (i = 0; i < MAX_IO_WIN; i++)
                         if (s->io[i].res) {
@@ -624,11 +503,11 @@ int pcmcia_request_configuration(struct pcmcia_device *p_dev,
                                 s->ops->set_io_map(s, &iomap);
                                 s->io[i].Config++;
                         }
-                mutex_unlock(&s->ops_mutex);
         }
 
         c->state |= CONFIG_LOCKED;
         p_dev->_locked = 1;
+        mutex_unlock(&s->ops_mutex);
         return 0;
 } /* pcmcia_request_configuration */
 EXPORT_SYMBOL(pcmcia_request_configuration);
@@ -706,137 +585,176 @@ out:
 EXPORT_SYMBOL(pcmcia_request_io);
 
 
-/** pcmcia_request_irq
+/**
+ * pcmcia_request_irq() - attempt to request a IRQ for a PCMCIA device
  *
- * Request_irq() reserves an irq for this client.
+ * pcmcia_request_irq() is a wrapper around request_irq which will allow
+ * the PCMCIA core to clean up the registration in pcmcia_disable_device().
+ * Drivers are free to use request_irq() directly, but then they need to
+ * call free_irq themselfves, too. Also, only IRQF_SHARED capable IRQ
+ * handlers are allowed.
+ */
+int __must_check pcmcia_request_irq(struct pcmcia_device *p_dev,
+                                    irq_handler_t handler)
+{
+        int ret;
+
+        if (!p_dev->irq)
+                return -EINVAL;
+
+        ret = request_irq(p_dev->irq, handler, IRQF_SHARED,
+                        p_dev->devname, p_dev->priv);
+        if (!ret)
+                p_dev->_irq = 1;
+
+        return ret;
+}
+EXPORT_SYMBOL(pcmcia_request_irq);
+
+
+/**
+ * pcmcia_request_exclusive_irq() - attempt to request an exclusive IRQ first
  *
- * Also, since Linux only reserves irq's when they are actually
- * hooked, we don't guarantee that an irq will still be available
- * when the configuration is locked.  Now that I think about it,
- * there might be a way to fix this using a dummy handler.
+ * pcmcia_request_exclusive_irq() is a wrapper around request_irq which
+ * attempts first to request an exclusive IRQ. If it fails, it also accepts
+ * a shared IRQ, but prints out a warning. PCMCIA drivers should allow for
+ * IRQ sharing and either use request_irq directly (then they need to call
+ * free_irq themselves, too), or the pcmcia_request_irq() function.
  */
+int __must_check
+__pcmcia_request_exclusive_irq(struct pcmcia_device *p_dev,
+                        irq_handler_t handler)
+{
+        int ret;
+
+        if (!p_dev->irq)
+                return -EINVAL;
+
+        ret = request_irq(p_dev->irq, handler, 0, p_dev->devname, p_dev->priv);
+        if (ret) {
+                ret = pcmcia_request_irq(p_dev, handler);
+                dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: "
+                        "request for exclusive IRQ could not be fulfilled.\n");
+                dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: the driver "
+                        "needs updating to supported shared IRQ lines.\n");
+        }
+        if (ret)
+                dev_printk(KERN_INFO, &p_dev->dev, "request_irq() failed\n");
+        else
+                p_dev->_irq = 1;
+
+        return ret;
+} /* pcmcia_request_exclusive_irq */
+EXPORT_SYMBOL(__pcmcia_request_exclusive_irq);
+
 
 #ifdef CONFIG_PCMCIA_PROBE
+
+/* mask of IRQs already reserved by other cards, we should avoid using them */
+static u8 pcmcia_used_irq[NR_IRQS];
+
 static irqreturn_t test_action(int cpl, void *dev_id)
 {
         return IRQ_NONE;
 }
-#endif
 
-int pcmcia_request_irq(struct pcmcia_device *p_dev, irq_req_t *req)
+/**
+ * pcmcia_setup_isa_irq() - determine whether an ISA IRQ can be used
+ * @p_dev - the associated PCMCIA device
+ *
+ * locking note: must be called with ops_mutex locked.
+ */
+static int pcmcia_setup_isa_irq(struct pcmcia_device *p_dev, int type)
 {
         struct pcmcia_socket *s = p_dev->socket;
-        config_t *c;
-        int ret = -EINVAL, irq = 0;
-        int type;
+        unsigned int try, irq;
+        u32 mask = s->irq_mask;
+        int ret = -ENODEV;
 
-        mutex_lock(&s->ops_mutex);
+        for (try = 0; try < 64; try++) {
+                irq = try % 32;
 
-        if (!(s->state & SOCKET_PRESENT)) {
-                dev_dbg(&s->dev, "No card present\n");
-                goto out;
-        }
-        c = p_dev->function_config;
-        if (c->state & CONFIG_LOCKED) {
-                dev_dbg(&s->dev, "Configuration is locked\n");
-                goto out;
-        }
-        if (c->state & CONFIG_IRQ_REQ) {
-                dev_dbg(&s->dev, "IRQ already configured\n");
-                goto out;
+                /* marked as available by driver, not blocked by userspace? */
+                if (!((mask >> irq) & 1))
+                        continue;
+
+                /* avoid an IRQ which is already used by another PCMCIA card */
+                if ((try < 32) && pcmcia_used_irq[irq])
+                        continue;
+
+                /* register the correct driver, if possible, to check whether
+                 * registering a dummy handle works, i.e. if the IRQ isn't
+                 * marked as used by the kernel resource management core */
+                ret = request_irq(irq, test_action, type, p_dev->devname,
+                                  p_dev);
+                if (!ret) {
+                        free_irq(irq, p_dev);
+                        p_dev->irq = s->pcmcia_irq = irq;
+                        pcmcia_used_irq[irq]++;
+                        break;
+                }
         }
 
-        /* Decide what type of interrupt we are registering */
-        type = 0;
-        if (s->functions > 1)           /* All of this ought to be handled higher up */
-                type = IRQF_SHARED;
-        else if (req->Attributes & IRQ_TYPE_DYNAMIC_SHARING)
-                type = IRQF_SHARED;
-        else
-                printk(KERN_WARNING "pcmcia: Driver needs updating to support IRQ sharing.\n");
+        return ret;
+}
 
-        /* If the interrupt is already assigned, it must be the same */
-        if (s->irq.AssignedIRQ != 0)
-                irq = s->irq.AssignedIRQ;
+void pcmcia_cleanup_irq(struct pcmcia_socket *s)
+{
+        pcmcia_used_irq[s->pcmcia_irq]--;
+        s->pcmcia_irq = 0;
+}
 
-#ifdef CONFIG_PCMCIA_PROBE
-        if (!irq) {
-                int try;
-                u32 mask = s->irq_mask;
-                void *data = p_dev; /* something unique to this device */
+#else /* CONFIG_PCMCIA_PROBE */
 
-                for (try = 0; try < 64; try++) {
-                        irq = try % 32;
+static int pcmcia_setup_isa_irq(struct pcmcia_device *p_dev, int type)
+{
+        return -EINVAL;
+}
 
-                        /* marked as available by driver, and not blocked by userspace? */
-                        if (!((mask >> irq) & 1))
-                                continue;
+void pcmcia_cleanup_irq(struct pcmcia_socket *s)
+{
+        s->pcmcia_irq = 0;
+        return;
+}
 
-                        /* avoid an IRQ which is already used by a PCMCIA card */
-                        if ((try < 32) && pcmcia_used_irq[irq])
-                                continue;
+#endif  /* CONFIG_PCMCIA_PROBE */
 
-                        /* register the correct driver, if possible, of check whether
-                         * registering a dummy handle works, i.e. if the IRQ isn't
-                         * marked as used by the kernel resource management core */
-                        ret = request_irq(irq,
-                                          (req->Handler) ? req->Handler : test_action,
-                                          type,
-                                          p_dev->devname,
-                                          (req->Handler) ? p_dev->priv : data);
-                        if (!ret) {
-                                if (!req->Handler)
-                                        free_irq(irq, data);
-                                break;
-                        }
-                }
-        }
-#endif
-        /* only assign PCI irq if no IRQ already assigned */
-        if (ret && !s->irq.AssignedIRQ) {
-                if (!s->pci_irq) {
-                        dev_printk(KERN_INFO, &s->dev, "no IRQ found\n");
-                        goto out;
-                }
-                type = IRQF_SHARED;
-                irq = s->pci_irq;
-        }
 
-        if (ret && req->Handler) {
-                ret = request_irq(irq, req->Handler, type,
-                                  p_dev->devname, p_dev->priv);
-                if (ret) {
-                        dev_printk(KERN_INFO, &s->dev,
-                                "request_irq() failed\n");
-                        goto out;
-                }
-        }
+/**
+ * pcmcia_setup_irq() - determine IRQ to be used for device
+ * @p_dev - the associated PCMCIA device
+ *
+ * locking note: must be called with ops_mutex locked.
+ */
+int pcmcia_setup_irq(struct pcmcia_device *p_dev)
+{
+        struct pcmcia_socket *s = p_dev->socket;
 
-        /* Make sure the fact the request type was overridden is passed back */
-        if (type == IRQF_SHARED && !(req->Attributes & IRQ_TYPE_DYNAMIC_SHARING)) {
-                req->Attributes |= IRQ_TYPE_DYNAMIC_SHARING;
-                dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: "
-                        "request for exclusive IRQ could not be fulfilled.\n");
-                dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: the driver "
-                        "needs updating to supported shared IRQ lines.\n");
+        if (p_dev->irq)
+                return 0;
+
+        /* already assigned? */
+        if (s->pcmcia_irq) {
+                p_dev->irq = s->pcmcia_irq;
+                return 0;
         }
-        c->irq.Attributes = req->Attributes;
-        s->irq.AssignedIRQ = req->AssignedIRQ = irq;
-        s->irq.Config++;
 
-        c->state |= CONFIG_IRQ_REQ;
-        p_dev->_irq = 1;
+        /* prefer an exclusive ISA irq */
+        if (!pcmcia_setup_isa_irq(p_dev, 0))
+                return 0;
 
-#ifdef CONFIG_PCMCIA_PROBE
-        pcmcia_used_irq[irq]++;
-#endif
+        /* but accept a shared ISA irq */
+        if (!pcmcia_setup_isa_irq(p_dev, IRQF_SHARED))
+                return 0;
 
-        ret = 0;
-out:
-        mutex_unlock(&s->ops_mutex);
-        return ret;
-} /* pcmcia_request_irq */
-EXPORT_SYMBOL(pcmcia_request_irq);
+        /* but use the PCI irq otherwise */
+        if (s->pci_irq) {
+                p_dev->irq = s->pcmcia_irq = s->pci_irq;
+                return 0;
+        }
+
+        return -EINVAL;
+}
 
 
 /** pcmcia_request_window
@@ -939,237 +857,9 @@ void pcmcia_disable_device(struct pcmcia_device *p_dev)
 {
         pcmcia_release_configuration(p_dev);
         pcmcia_release_io(p_dev, &p_dev->io);
-        pcmcia_release_irq(p_dev, &p_dev->irq);
+        if (p_dev->_irq)
+                free_irq(p_dev->irq, p_dev->priv);
         if (p_dev->win)
                 pcmcia_release_window(p_dev, p_dev->win);
 }
 EXPORT_SYMBOL(pcmcia_disable_device);
-
-
-struct pcmcia_cfg_mem {
-        struct pcmcia_device *p_dev;
-        void *priv_data;
-        int (*conf_check) (struct pcmcia_device *p_dev,
-                           cistpl_cftable_entry_t *cfg,
-                           cistpl_cftable_entry_t *dflt,
-                           unsigned int vcc,
-                           void *priv_data);
-        cisparse_t parse;
-        cistpl_cftable_entry_t dflt;
-};
-
-/**
- * pcmcia_do_loop_config() - internal helper for pcmcia_loop_config()
- *
- * pcmcia_do_loop_config() is the internal callback for the call from
- * pcmcia_loop_config() to pccard_loop_tuple(). Data is transferred
- * by a struct pcmcia_cfg_mem.
- */
-static int pcmcia_do_loop_config(tuple_t *tuple, cisparse_t *parse, void *priv)
-{
-        cistpl_cftable_entry_t *cfg = &parse->cftable_entry;
-        struct pcmcia_cfg_mem *cfg_mem = priv;
-
-        /* default values */
-        cfg_mem->p_dev->conf.ConfigIndex = cfg->index;
-        if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
-                cfg_mem->dflt = *cfg;
-
-        return cfg_mem->conf_check(cfg_mem->p_dev, cfg, &cfg_mem->dflt,
-                                   cfg_mem->p_dev->socket->socket.Vcc,
-                                   cfg_mem->priv_data);
-}
-
-/**
- * pcmcia_loop_config() - loop over configuration options
- * @p_dev:      the struct pcmcia_device which we need to loop for.
- * @conf_check: function to call for each configuration option.
- *              It gets passed the struct pcmcia_device, the CIS data
- *              describing the configuration option, and private data
- *              being passed to pcmcia_loop_config()
- * @priv_data:  private data to be passed to the conf_check function.
- *
- * pcmcia_loop_config() loops over all configuration options, and calls
- * the driver-specific conf_check() for each one, checking whether
- * it is a valid one. Returns 0 on success or errorcode otherwise.
- */
-int pcmcia_loop_config(struct pcmcia_device *p_dev,
-                       int      (*conf_check)   (struct pcmcia_device *p_dev,
-                                                 cistpl_cftable_entry_t *cfg,
-                                                 cistpl_cftable_entry_t *dflt,
-                                                 unsigned int vcc,
-                                                 void *priv_data),
-                       void *priv_data)
-{
-        struct pcmcia_cfg_mem *cfg_mem;
-        int ret;
-
-        cfg_mem = kzalloc(sizeof(struct pcmcia_cfg_mem), GFP_KERNEL);
-        if (cfg_mem == NULL)
-                return -ENOMEM;
-
-        cfg_mem->p_dev = p_dev;
-        cfg_mem->conf_check = conf_check;
-        cfg_mem->priv_data = priv_data;
-
-        ret = pccard_loop_tuple(p_dev->socket, p_dev->func,
-                                CISTPL_CFTABLE_ENTRY, &cfg_mem->parse,
-                                cfg_mem, pcmcia_do_loop_config);
-
-        kfree(cfg_mem);
-        return ret;
-}
-EXPORT_SYMBOL(pcmcia_loop_config);
-
-
-struct pcmcia_loop_mem {
-        struct pcmcia_device *p_dev;
-        void *priv_data;
-        int (*loop_tuple) (struct pcmcia_device *p_dev,
-                           tuple_t *tuple,
-                           void *priv_data);
-};
-
-/**
- * pcmcia_do_loop_tuple() - internal helper for pcmcia_loop_config()
- *
- * pcmcia_do_loop_tuple() is the internal callback for the call from
- * pcmcia_loop_tuple() to pccard_loop_tuple(). Data is transferred
- * by a struct pcmcia_cfg_mem.
- */
-static int pcmcia_do_loop_tuple(tuple_t *tuple, cisparse_t *parse, void *priv)
-{
-        struct pcmcia_loop_mem *loop = priv;
-
-        return loop->loop_tuple(loop->p_dev, tuple, loop->priv_data);
-};
-
-/**
- * pcmcia_loop_tuple() - loop over tuples in the CIS
- * @p_dev:      the struct pcmcia_device which we need to loop for.
- * @code:       which CIS code shall we look for?
- * @priv_data:  private data to be passed to the loop_tuple function.
- * @loop_tuple: function to call for each CIS entry of type @function. IT
- *              gets passed the raw tuple and @priv_data.
- *
- * pcmcia_loop_tuple() loops over all CIS entries of type @function, and
- * calls the @loop_tuple function for each entry. If the call to @loop_tuple
- * returns 0, the loop exits. Returns 0 on success or errorcode otherwise.
- */
-int pcmcia_loop_tuple(struct pcmcia_device *p_dev, cisdata_t code,
-                      int (*loop_tuple) (struct pcmcia_device *p_dev,
-                                         tuple_t *tuple,
-                                         void *priv_data),
-                      void *priv_data)
-{
-        struct pcmcia_loop_mem loop = {
-                .p_dev = p_dev,
-                .loop_tuple = loop_tuple,
-                .priv_data = priv_data};
-
-        return pccard_loop_tuple(p_dev->socket, p_dev->func, code, NULL,
-                                 &loop, pcmcia_do_loop_tuple);
-}
-EXPORT_SYMBOL(pcmcia_loop_tuple);
-
-
-struct pcmcia_loop_get {
-        size_t len;
-        cisdata_t **buf;
-};
-
-/**
- * pcmcia_do_get_tuple() - internal helper for pcmcia_get_tuple()
- *
- * pcmcia_do_get_tuple() is the internal callback for the call from
- * pcmcia_get_tuple() to pcmcia_loop_tuple(). As we're only interested in
- * the first tuple, return 0 unconditionally. Create a memory buffer large
- * enough to hold the content of the tuple, and fill it with the tuple data.
- * The caller is responsible to free the buffer.
- */
-static int pcmcia_do_get_tuple(struct pcmcia_device *p_dev, tuple_t *tuple,
-                               void *priv)
-{
-        struct pcmcia_loop_get *get = priv;
-
-        *get->buf = kzalloc(tuple->TupleDataLen, GFP_KERNEL);
-        if (*get->buf) {
-                get->len = tuple->TupleDataLen;
-                memcpy(*get->buf, tuple->TupleData, tuple->TupleDataLen);
-        } else
-                dev_dbg(&p_dev->dev, "do_get_tuple: out of memory\n");
-        return 0;
-}
-
-/**
- * pcmcia_get_tuple() - get first tuple from CIS
- * @p_dev:      the struct pcmcia_device which we need to loop for.
- * @code:       which CIS code shall we look for?
- * @buf:        pointer to store the buffer to.
- *
- * pcmcia_get_tuple() gets the content of the first CIS entry of type @code.
- * It returns the buffer length (or zero). The caller is responsible to free
- * the buffer passed in @buf.
- */
-size_t pcmcia_get_tuple(struct pcmcia_device *p_dev, cisdata_t code,
-                        unsigned char **buf)
-{
-        struct pcmcia_loop_get get = {
-                .len = 0,
-                .buf = buf,
-        };
-
-        *get.buf = NULL;
-        pcmcia_loop_tuple(p_dev, code, pcmcia_do_get_tuple, &get);
-
-        return get.len;
-}
-EXPORT_SYMBOL(pcmcia_get_tuple);
-
-
-/**
- * pcmcia_do_get_mac() - internal helper for pcmcia_get_mac_from_cis()
- *
- * pcmcia_do_get_mac() is the internal callback for the call from
- * pcmcia_get_mac_from_cis() to pcmcia_loop_tuple(). We check whether the
- * tuple contains a proper LAN_NODE_ID of length 6, and copy the data
- * to struct net_device->dev_addr[i].
- */
-static int pcmcia_do_get_mac(struct pcmcia_device *p_dev, tuple_t *tuple,
-                             void *priv)
-{
-        struct net_device *dev = priv;
-        int i;
-
-        if (tuple->TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID)
-                return -EINVAL;
-        if (tuple->TupleDataLen < ETH_ALEN + 2) {
-                dev_warn(&p_dev->dev, "Invalid CIS tuple length for "
-                        "LAN_NODE_ID\n");
-                return -EINVAL;
-        }
-
-        if (tuple->TupleData[1] != ETH_ALEN) {
-                dev_warn(&p_dev->dev, "Invalid header for LAN_NODE_ID\n");
-                return -EINVAL;
-        }
-        for (i = 0; i < 6; i++)
-                dev->dev_addr[i] = tuple->TupleData[i+2];
-        return 0;
-}
-
-/**
- * pcmcia_get_mac_from_cis() - read out MAC address from CISTPL_FUNCE
- * @p_dev:      the struct pcmcia_device for which we want the address.
- * @dev:        a properly prepared struct net_device to store the info to.
- *
- * pcmcia_get_mac_from_cis() reads out the hardware MAC address from
- * CISTPL_FUNCE and stores it into struct net_device *dev->dev_addr which
- * must be set up properly by the driver (see examples!).
- */
-int pcmcia_get_mac_from_cis(struct pcmcia_device *p_dev, struct net_device *dev)
-{
-        return pcmcia_loop_tuple(p_dev, CISTPL_FUNCE, pcmcia_do_get_mac, dev);
-}
-EXPORT_SYMBOL(pcmcia_get_mac_from_cis);
-