struct pcmcia_config_check {
-       config_info_t conf;
        unsigned long ctl_base;
        int skip_vcc;
        int is_kme;
 static int pcmcia_check_one_config(struct pcmcia_device *pdev,
                                   cistpl_cftable_entry_t *cfg,
                                   cistpl_cftable_entry_t *dflt,
+                                  unsigned int vcc,
                                   void *priv_data)
 {
        struct pcmcia_config_check *stk = priv_data;
        /* Check for matching Vcc, unless we're desperate */
        if (!stk->skip_vcc) {
                if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                       if (stk->conf.Vcc !=
-                           cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
+                       if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
                                return -ENODEV;
                } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                       if (stk->conf.Vcc !=
-                           dflt->vcc.param[CISTPL_POWER_VNOM] / 10000)
+                       if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000)
                                return -ENODEV;
                }
        }
        if (!stk)
                goto out1;
        stk->is_kme = is_kme;
-
-       /* Not sure if this is right... look up the current Vcc */
-       CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(pdev, &stk->conf));
        stk->skip_vcc = io_base = ctl_base = 0;
+
        if (pcmcia_loop_config(pdev, pcmcia_check_one_config, stk)) {
                stk->skip_vcc = 1;
                if (pcmcia_loop_config(pdev, pcmcia_check_one_config, stk))
 
 static int bt3c_check_config(struct pcmcia_device *p_dev,
                             cistpl_cftable_entry_t *cf,
                             cistpl_cftable_entry_t *dflt,
+                            unsigned int vcc,
                             void *priv_data)
 {
        unsigned long try = (unsigned long) priv_data;
 static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
                                      cistpl_cftable_entry_t *cf,
                                      cistpl_cftable_entry_t *dflt,
+                                     unsigned int vcc,
                                      void *priv_data)
 {
        static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 
 static int btuart_check_config(struct pcmcia_device *p_dev,
                               cistpl_cftable_entry_t *cf,
                               cistpl_cftable_entry_t *dflt,
+                              unsigned int vcc,
                               void *priv_data)
 {
-       unsigned long try = (unsigned long) priv_data;
+       int *try = priv_data;
 
        if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
                p_dev->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
        if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) &&
            (cf->io.win[0].base != 0)) {
                p_dev->io.BasePort1 = cf->io.win[0].base;
-               p_dev->io.IOAddrLines = (try == 0) ? 16 :
+               p_dev->io.IOAddrLines = (*try == 0) ? 16 :
                        cf->io.flags & CISTPL_IO_LINES_MASK;
                if (!pcmcia_request_io(p_dev, &p_dev->io))
                        return 0;
 static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
                                        cistpl_cftable_entry_t *cf,
                                        cistpl_cftable_entry_t *dflt,
+                                       unsigned int vcc,
                                        void *priv_data)
 {
        static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 {
        btuart_info_t *info = link->priv;
        int i;
-       unsigned long try;
+       int try;
 
        /* First pass: look for a config entry that looks normal.
           Two tries: without IO aliases, then with aliases */
        for (try = 0; try < 2; try++)
-               if (!pcmcia_loop_config(link, btuart_check_config,
-                                       (void *) try))
+               if (!pcmcia_loop_config(link, btuart_check_config, &try))
                        goto found_port;
 
        /* Second pass: try to find an entry that isn't picky about
 
 static int dtl1_confcheck(struct pcmcia_device *p_dev,
                          cistpl_cftable_entry_t *cf,
                          cistpl_cftable_entry_t *dflt,
+                         unsigned int vcc,
                          void *priv_data)
 {
        if ((cf->io.nwin == 1) && (cf->io.win[0].len > 8)) {
 
 static int cm4000_config_check(struct pcmcia_device *p_dev,
                               cistpl_cftable_entry_t *cfg,
                               cistpl_cftable_entry_t *dflt,
+                              unsigned int vcc,
                               void *priv_data)
 {
        if (!cfg->io.nwin)
 
 static int cm4040_config_check(struct pcmcia_device *p_dev,
                               cistpl_cftable_entry_t *cfg,
                               cistpl_cftable_entry_t *dflt,
+                              unsigned int vcc,
                               void *priv_data)
 {
        int rc;
 
 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 
 struct pcmcia_config_check {
-       config_info_t conf;
        unsigned long ctl_base;
        int skip_vcc;
        int is_kme;
 static int pcmcia_check_one_config(struct pcmcia_device *pdev,
                                   cistpl_cftable_entry_t *cfg,
                                   cistpl_cftable_entry_t *dflt,
+                                  unsigned int vcc,
                                   void *priv_data)
 {
        struct pcmcia_config_check *stk = priv_data;
        /* Check for matching Vcc, unless we're desperate */
        if (!stk->skip_vcc) {
                if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                       if (stk->conf.Vcc !=
-                           cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
+                       if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
                                return -ENODEV;
                } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                       if (stk->conf.Vcc !=
-                           dflt->vcc.param[CISTPL_POWER_VNOM] / 10000)
+                       if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000)
                                return -ENODEV;
                }
        }
     if (!stk)
            goto err_mem;
     stk->is_kme = is_kme;
-
-    /* Not sure if this is right... look up the current Vcc */
-    CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link, &stk->conf));
     stk->skip_vcc = io_base = ctl_base = 0;
+
     if (pcmcia_loop_config(link, pcmcia_check_one_config, stk)) {
            stk->skip_vcc = 1;
            if (pcmcia_loop_config(link, pcmcia_check_one_config, stk))
 
 static int avmcs_configcheck(struct pcmcia_device *p_dev,
                             cistpl_cftable_entry_t *cf,
                             cistpl_cftable_entry_t *dflt,
+                            unsigned int vcc,
                             void *priv_data)
 {
        if (cf->io.nwin <= 0)
 
 static int avma1cs_configcheck(struct pcmcia_device *p_dev,
                               cistpl_cftable_entry_t *cf,
                               cistpl_cftable_entry_t *dflt,
+                              unsigned int vcc,
                               void *priv_data)
 {
        if (cf->io.nwin <= 0)
 
 static int elsa_cs_configcheck(struct pcmcia_device *p_dev,
                               cistpl_cftable_entry_t *cf,
                               cistpl_cftable_entry_t *dflt,
+                              unsigned int vcc,
                               void *priv_data)
 {
        int j;
 
 #define CS_CHECK(fn, ret) \
 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 
-struct sedlbauer_config_data {
-       config_info_t conf;
-       win_req_t req;
-};
-
 static int sedlbauer_config_check(struct pcmcia_device *p_dev,
                                  cistpl_cftable_entry_t *cfg,
                                  cistpl_cftable_entry_t *dflt,
+                                 unsigned int vcc,
                                  void *priv_data)
 {
-       struct sedlbauer_config_data *cfg_mem = priv_data;
+       win_req_t *req = priv_data;
 
        if (cfg->index == 0)
                return -ENODEV;
        /* Use power settings for Vcc and Vpp if present */
        /*  Note that the CIS values need to be rescaled */
        if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-               if (cfg_mem->conf.Vcc !=
-                   cfg->vcc.param[CISTPL_POWER_VNOM]/10000)
+               if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM]/10000)
                        return -ENODEV;
        } else if (dflt->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-               if (cfg_mem->conf.Vcc !=
-                   dflt->vcc.param[CISTPL_POWER_VNOM]/10000)
+               if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM]/10000)
                        return -ENODEV;
        }
 
        if ((cfg->mem.nwin > 0) || (dflt->mem.nwin > 0)) {
                cistpl_mem_t *mem = (cfg->mem.nwin) ? &cfg->mem : &dflt->mem;
                memreq_t map;
-               cfg_mem->req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
-               cfg_mem->req.Attributes |= WIN_ENABLE;
-               cfg_mem->req.Base = mem->win[0].host_addr;
-               cfg_mem->req.Size = mem->win[0].len;
-               cfg_mem->req.AccessSpeed = 0;
-               if (pcmcia_request_window(&p_dev, &cfg_mem->req, &p_dev->win) != 0)
+               req->Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
+               req->Attributes |= WIN_ENABLE;
+               req->Base = mem->win[0].host_addr;
+               req->Size = mem->win[0].len;
+               req->AccessSpeed = 0;
+               if (pcmcia_request_window(&p_dev, req, &p_dev->win) != 0)
                        return -ENODEV;
                map.Page = 0;
                map.CardOffset = mem->win[0].card_addr;
 static int sedlbauer_config(struct pcmcia_device *link)
 {
     local_info_t *dev = link->priv;
-    struct sedlbauer_config_data *cfg_mem;
+    win_req_t *req;
     int last_fn, last_ret;
     IsdnCard_t  icard;
 
     DEBUG(0, "sedlbauer_config(0x%p)\n", link);
 
-    cfg_mem = kzalloc(sizeof(struct sedlbauer_config_data), GFP_KERNEL);
-    if (!cfg_mem)
+    req = kzalloc(sizeof(win_req_t), GFP_KERNEL);
+    if (!req)
            return -ENOMEM;
 
-    /* Look up the current Vcc */
-    CS_CHECK(GetConfigurationInfo,
-            pcmcia_get_configuration_info(link, &cfg_mem->conf));
-
     /*
       In this loop, we scan the CIS for configuration table entries,
       each of which describes a valid card configuration, including
       these things without consulting the CIS, and most client drivers
       will only use the CIS to fill in implementation-defined details.
     */
-    last_ret = pcmcia_loop_config(link, sedlbauer_config_check, cfg_mem);
+    last_ret = pcmcia_loop_config(link, sedlbauer_config_check, req);
     if (last_ret)
            goto failed;
 
        printk(" & 0x%04x-0x%04x", link->io.BasePort2,
               link->io.BasePort2+link->io.NumPorts2-1);
     if (link->win)
-       printk(", mem 0x%06lx-0x%06lx", cfg_mem->req.Base,
-              cfg_mem->req.Base+cfg_mem->req.Size-1);
+       printk(", mem 0x%06lx-0x%06lx", req->Base,
+              req->Base+req->Size-1);
     printk("\n");
 
     icard.para[0] = link->irq.AssignedIRQ;
 
 static int teles_cs_configcheck(struct pcmcia_device *p_dev,
                                cistpl_cftable_entry_t *cf,
                                cistpl_cftable_entry_t *dflt,
+                               unsigned int vcc,
                                void *priv_data)
 {
        int j;
 
 static int axnet_configcheck(struct pcmcia_device *p_dev,
                             cistpl_cftable_entry_t *cfg,
                             cistpl_cftable_entry_t *dflt,
+                            unsigned int vcc,
                             void *priv_data)
 {
        int i;
 
 static int pcnet_confcheck(struct pcmcia_device *p_dev,
                           cistpl_cftable_entry_t *cfg,
                           cistpl_cftable_entry_t *dflt,
+                          unsigned int vcc,
                           void *priv_data)
 {
        int *has_shmem = priv_data;
 
 static int mhz_mfc_config_check(struct pcmcia_device *p_dev,
                                cistpl_cftable_entry_t *cf,
                                cistpl_cftable_entry_t *dflt,
+                               unsigned int vcc,
                                void *priv_data)
 {
        int k;
 static int smc_configcheck(struct pcmcia_device *p_dev,
                           cistpl_cftable_entry_t *cf,
                           cistpl_cftable_entry_t *dflt,
+                          unsigned int vcc,
                           void *priv_data)
 {
        p_dev->io.BasePort1 = cf->io.win[0].base;
 
 xirc2ps_config_modem(struct pcmcia_device *p_dev,
                     cistpl_cftable_entry_t *cf,
                     cistpl_cftable_entry_t *dflt,
+                    unsigned int vcc,
                     void *priv_data)
 {
        unsigned int ioaddr;
 xirc2ps_config_check(struct pcmcia_device *p_dev,
                     cistpl_cftable_entry_t *cf,
                     cistpl_cftable_entry_t *dflt,
+                    unsigned int vcc,
                     void *priv_data)
 {
        int *pass = priv_data;
 
 static int airo_cs_config_check(struct pcmcia_device *p_dev,
                                cistpl_cftable_entry_t *cfg,
                                cistpl_cftable_entry_t *dflt,
+                               unsigned int vcc,
                                void *priv_data)
 {
        win_req_t *req = priv_data;
 
 static int atmel_config_check(struct pcmcia_device *p_dev,
                              cistpl_cftable_entry_t *cfg,
                              cistpl_cftable_entry_t *dflt,
+                             unsigned int vcc,
                              void *priv_data)
 {
        if (cfg->index == 0)
 
 /* run after a CARD_INSERTION event is received to configure the PCMCIA
  * socket and make the device available to the system */
 
-struct prism2_config_data {
-       config_info_t conf;
-};
-
 static int prism2_config_check(struct pcmcia_device *p_dev,
                               cistpl_cftable_entry_t *cfg,
                               cistpl_cftable_entry_t *dflt,
+                              unsigned int vcc,
                               void *priv_data)
 {
-       struct prism2_config_data *cfg_mem = priv_data;
-
        if (cfg->index == 0)
                return -ENODEV;
 
        /* Use power settings for Vcc and Vpp if present */
        /*  Note that the CIS values need to be rescaled */
        if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-               if (cfg_mem->conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM] /
+               if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] /
                    10000 && !ignore_cis_vcc) {
                        PDEBUG(DEBUG_EXTRA, "  Vcc mismatch - skipping"
                               " this entry\n");
                        return -ENODEV;
                }
        } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-               if (cfg_mem->conf.Vcc != dflt->vcc.param[CISTPL_POWER_VNOM] /
+               if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] /
                    10000 && !ignore_cis_vcc) {
                        PDEBUG(DEBUG_EXTRA, "  Vcc (default) mismatch "
                               "- skipping this entry\n");
 {
        struct net_device *dev;
        struct hostap_interface *iface;
-       struct prism2_config_data *cfg_mem;
        local_info_t *local;
        int ret = 1;
        int last_fn, last_ret;
 
        PDEBUG(DEBUG_FLOW, "prism2_config()\n");
 
-       cfg_mem = kzalloc(sizeof(struct prism2_config_data), GFP_KERNEL);
-       if (!cfg_mem)
-               return -ENOMEM;
-
        hw_priv = kzalloc(sizeof(*hw_priv), GFP_KERNEL);
        if (hw_priv == NULL) {
                ret = -ENOMEM;
                goto failed;
        }
 
-       CS_CHECK(GetConfigurationInfo,
-                pcmcia_get_configuration_info(link, &cfg_mem->conf));
-
        /* Look for an appropriate configuration table entry in the CIS */
-       last_ret = pcmcia_loop_config(link, prism2_config_check, cfg_mem);
+       last_ret = pcmcia_loop_config(link, prism2_config_check, NULL);
        if (last_ret) {
                if (!ignore_cis_vcc)
                        printk(KERN_ERR "GetNextTuple(): No matching "
                if (ret == 0 && local->ddev)
                        strcpy(hw_priv->node.dev_name, local->ddev->name);
        }
-       kfree(cfg_mem);
        return ret;
 
  cs_failed:
 
  failed:
        kfree(hw_priv);
-       kfree(cfg_mem);
        prism2_release((u_long)link);
        return ret;
 }
 
                last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; \
        } while (0)
 
-struct orinoco_cs_config_data {
-       config_info_t conf;
-};
-
 static int orinoco_cs_config_check(struct pcmcia_device *p_dev,
                                   cistpl_cftable_entry_t *cfg,
                                   cistpl_cftable_entry_t *dflt,
+                                  unsigned int vcc,
                                   void *priv_data)
 {
-       struct orinoco_cs_config_data *cfg_mem = priv_data;
-
        if (cfg->index == 0)
                goto next_entry;
 
        /* Use power settings for Vcc and Vpp if present */
        /* Note that the CIS values need to be rescaled */
        if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-               if (cfg_mem->conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) {
-                       DEBUG(2, "spectrum_cs_config: Vcc mismatch (cfg_mem->conf.Vcc = %d, CIS = %d)\n",  cfg_mem->conf.Vcc, cfg->vcc.param[CISTPL_POWER_VNOM] / 10000);
+               if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) {
+                       DEBUG(2, "spectrum_cs_config: Vcc mismatch (vcc = %d, CIS = %d)\n",  vcc, cfg->vcc.param[CISTPL_POWER_VNOM] / 10000);
                        if (!ignore_cis_vcc)
                                goto next_entry;
                }
        } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-               if (cfg_mem->conf.Vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000) {
-                       DEBUG(2, "spectrum_cs_config: Vcc mismatch (cfg_mem->conf.Vcc = %d, CIS = %d)\n",  cfg_mem->conf.Vcc, dflt->vcc.param[CISTPL_POWER_VNOM] / 10000);
+               if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000) {
+                       DEBUG(2, "spectrum_cs_config: Vcc mismatch (vcc = %d, CIS = %d)\n",  vcc, dflt->vcc.param[CISTPL_POWER_VNOM] / 10000);
                        if (!ignore_cis_vcc)
                                goto next_entry;
                }
 static int
 orinoco_cs_config(struct pcmcia_device *link)
 {
-       struct orinoco_cs_config_data *cfg_mem;
        struct net_device *dev = link->priv;
        struct orinoco_private *priv = netdev_priv(dev);
        struct orinoco_pccard *card = priv->card;
        int last_fn, last_ret;
        void __iomem *mem;
 
-       cfg_mem = kzalloc(sizeof(struct orinoco_cs_config_data), GFP_KERNEL);
-       if (!cfg_mem)
-               return -ENOMEM;
-
-       /* Look up the current Vcc */
-       CS_CHECK(GetConfigurationInfo,
-                pcmcia_get_configuration_info(link, &cfg_mem->conf));
-
        /*
         * In this loop, we scan the CIS for configuration table
         * entries, each of which describes a valid card
         * and most client drivers will only use the CIS to fill in
         * implementation-defined details.
         */
-       last_ret = pcmcia_loop_config(link, orinoco_cs_config_check, cfg_mem);
+       last_ret = pcmcia_loop_config(link, orinoco_cs_config_check, NULL);
        if (last_ret) {
                if (!ignore_cis_vcc)
                        printk(KERN_ERR PFX "GetNextTuple(): No matching "
               "0x%04x-0x%04x\n", dev->name, dev->dev.parent->bus_id,
               link->irq.AssignedIRQ, link->io.BasePort1,
               link->io.BasePort1 + link->io.NumPorts1 - 1);
-       kfree(cfg_mem);
        return 0;
 
  cs_failed:
 
  failed:
        orinoco_cs_release(link);
-       kfree(cfg_mem);
        return -ENODEV;
 }                              /* orinoco_cs_config */
 
 
  * device available to the system.
  */
 
-struct spectrum_cs_config_data {
-       config_info_t conf;
-};
-
 static int spectrum_cs_config_check(struct pcmcia_device *p_dev,
                                    cistpl_cftable_entry_t *cfg,
                                    cistpl_cftable_entry_t *dflt,
+                                   unsigned int vcc,
                                    void *priv_data)
 {
-       struct spectrum_cs_config_data *cfg_mem = priv_data;
-
        if (cfg->index == 0)
                goto next_entry;
 
        /* Use power settings for Vcc and Vpp if present */
        /* Note that the CIS values need to be rescaled */
        if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-               if (cfg_mem->conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) {
-                       DEBUG(2, "spectrum_cs_config: Vcc mismatch (cfg_mem->conf.Vcc = %d, CIS = %d)\n",  cfg_mem->conf.Vcc, cfg->vcc.param[CISTPL_POWER_VNOM] / 10000);
+               if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) {
+                       DEBUG(2, "spectrum_cs_config: Vcc mismatch (vcc = %d, CIS = %d)\n",  vcc, cfg->vcc.param[CISTPL_POWER_VNOM] / 10000);
                        if (!ignore_cis_vcc)
                                goto next_entry;
                }
        } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-               if (cfg_mem->conf.Vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000) {
-                       DEBUG(2, "spectrum_cs_config: Vcc mismatch (cfg_mem->conf.Vcc = %d, CIS = %d)\n",  cfg_mem->conf.Vcc, dflt->vcc.param[CISTPL_POWER_VNOM] / 10000);
+               if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000) {
+                       DEBUG(2, "spectrum_cs_config: Vcc mismatch (vcc = %d, CIS = %d)\n",  vcc, dflt->vcc.param[CISTPL_POWER_VNOM] / 10000);
                        if (!ignore_cis_vcc)
                                goto next_entry;
                }
 static int
 spectrum_cs_config(struct pcmcia_device *link)
 {
-       struct spectrum_cs_config_data *cfg_mem;
        struct net_device *dev = link->priv;
        struct orinoco_private *priv = netdev_priv(dev);
        struct orinoco_pccard *card = priv->card;
        int last_fn, last_ret;
        void __iomem *mem;
 
-       cfg_mem = kzalloc(sizeof(struct spectrum_cs_config_data), GFP_KERNEL);
-       if (!cfg_mem)
-               return -ENOMEM;
-
-       /* Look up the current Vcc */
-       CS_CHECK(GetConfigurationInfo,
-                pcmcia_get_configuration_info(link, &cfg_mem->conf));
-
        /*
         * In this loop, we scan the CIS for configuration table
         * entries, each of which describes a valid card
         * and most client drivers will only use the CIS to fill in
         * implementation-defined details.
         */
-       last_ret = pcmcia_loop_config(link, spectrum_cs_config_check, cfg_mem);
+       last_ret = pcmcia_loop_config(link, spectrum_cs_config_check, NULL);
        if (last_ret) {
                if (!ignore_cis_vcc)
                        printk(KERN_ERR PFX "GetNextTuple(): No matching "
               link->irq.AssignedIRQ, link->io.BasePort1,
               link->io.BasePort1 + link->io.NumPorts1 - 1);
 
-       kfree(cfg_mem);
        return 0;
 
  cs_failed:
 
  failed:
        spectrum_cs_release(link);
-       kfree(cfg_mem);
        return -ENODEV;
 }                              /* spectrum_cs_config */
 
 
 static int parport_config_check(struct pcmcia_device *p_dev,
                                cistpl_cftable_entry_t *cfg,
                                cistpl_cftable_entry_t *dflt,
+                               unsigned int vcc,
                                void *priv_data)
 {
        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
                        return -ENODEV;
                return 0;
        }
+       return -ENODEV;
 }
 
 static int parport_config(struct pcmcia_device *link)
 
                       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)
 {
 
        tuple_t *tuple;
        int ret = -ENODEV;
+       unsigned int vcc;
 
        cfg_mem = kzalloc(sizeof(struct pcmcia_cfg_mem), GFP_KERNEL);
        if (cfg_mem == NULL)
                return -ENOMEM;
 
+       /* get the current Vcc setting */
+       vcc = p_dev->socket->socket.Vcc;
+
        tuple = &cfg_mem->tuple;
        tuple->TupleData = cfg_mem->buf;
        tuple->TupleDataMax = 255;
                if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
                        cfg_mem->dflt = *cfg;
 
-               ret = conf_check(p_dev, cfg, &cfg_mem->dflt, priv_data);
+               ret = conf_check(p_dev, cfg, &cfg_mem->dflt, vcc, priv_data);
                if (!ret)
                        break;
 
 
 static int aha152x_config_check(struct pcmcia_device *p_dev,
                                cistpl_cftable_entry_t *cfg,
                                cistpl_cftable_entry_t *dflt,
+                               unsigned int vcc,
                                void *priv_data)
 {
        /* For New Media T&J, look for a SCSI window */
 
 static int fdomain_config_check(struct pcmcia_device *p_dev,
                                cistpl_cftable_entry_t *cfg,
                                cistpl_cftable_entry_t *dflt,
+                               unsigned int vcc,
                                void *priv_data)
 {
        p_dev->io.BasePort1 = cfg->io.win[0].base;
 
 struct nsp_cs_configdata {
        nsp_hw_data             *data;
        win_req_t               req;
-       config_info_t           conf;
 };
 
 static int nsp_cs_config_check(struct pcmcia_device *p_dev,
                               cistpl_cftable_entry_t *cfg,
                               cistpl_cftable_entry_t *dflt,
+                              unsigned int vcc,
                               void *priv_data)
 {
        struct nsp_cs_configdata *cfg_mem = priv_data;
        /* Use power settings for Vcc and Vpp if present */
        /*  Note that the CIS values need to be rescaled */
        if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-               if (cfg_mem->conf.Vcc != cfg->vcc.param[CISTPL_POWER_VNOM]/10000)
+               if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM]/10000)
                        return -ENODEV;
                else if (dflt->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-                       if (cfg_mem->conf.Vcc != dflt->vcc.param[CISTPL_POWER_VNOM]/10000)
+                       if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM]/10000)
                                return -ENODEV;
                }
 
                return -ENOMEM;
        cfg_mem->data = data;
 
-       /* Look up the current Vcc */
-       CS_CHECK(GetConfigurationInfo, pcmcia_get_configuration_info(link, &cfg_mem->conf));
        ret = pcmcia_loop_config(link, nsp_cs_config_check, cfg_mem);
                goto cs_failed;
 
 
 static int qlogic_config_check(struct pcmcia_device *p_dev,
                               cistpl_cftable_entry_t *cfg,
                               cistpl_cftable_entry_t *dflt,
+                              unsigned int vcc,
                               void *priv_data)
 {
        p_dev->io.BasePort1 = cfg->io.win[0].base;
 
 static int SYM53C500_config_check(struct pcmcia_device *p_dev,
                                  cistpl_cftable_entry_t *cfg,
                                  cistpl_cftable_entry_t *dflt,
+                                 unsigned int vcc,
                                  void *priv_data)
 {
        p_dev->io.BasePort1 = cfg->io.win[0].base;
 
 static int simple_config_check(struct pcmcia_device *p_dev,
                               cistpl_cftable_entry_t *cf,
                               cistpl_cftable_entry_t *dflt,
+                              unsigned int vcc,
                               void *priv_data)
 {
        static const int size_table[2] = { 8, 16 };
 static int simple_config_check_notpicky(struct pcmcia_device *p_dev,
                                        cistpl_cftable_entry_t *cf,
                                        cistpl_cftable_entry_t *dflt,
+                                       unsigned int vcc,
                                        void *priv_data)
 {
        static const unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
 static int multi_config_check(struct pcmcia_device *p_dev,
                              cistpl_cftable_entry_t *cf,
                              cistpl_cftable_entry_t *dflt,
+                             unsigned int vcc,
                              void *priv_data)
 {
        int *base2 = priv_data;
 static int multi_config_check_notpicky(struct pcmcia_device *p_dev,
                                       cistpl_cftable_entry_t *cf,
                                       cistpl_cftable_entry_t *dflt,
+                                      unsigned int vcc,
                                       void *priv_data)
 {
        int *base2 = priv_data;
 
 static int ixj_config_check(struct pcmcia_device *p_dev,
                            cistpl_cftable_entry_t *cfg,
                            cistpl_cftable_entry_t *dflt,
+                           unsigned int vcc,
                            void *priv_data)
 {
        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
 
        platform_device_unregister(&platform_dev);
 }
 
-struct sl811_css_cfg {
-       config_info_t           conf;
-};
-
 static int sl811_cs_config_check(struct pcmcia_device *p_dev,
                                 cistpl_cftable_entry_t *cfg,
                                 cistpl_cftable_entry_t *dflt,
+                                unsigned int vcc,
                                 void *priv_data)
 {
-       struct sl811_css_cfg    *cfg_mem = priv_data;
-
        if (cfg->index == 0)
                return -ENODEV;
 
        /* Use power settings for Vcc and Vpp if present */
        /*  Note that the CIS values need to be rescaled */
        if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-               if (cfg->vcc.param[CISTPL_POWER_VNOM]/10000 !=
-                   cfg_mem->conf.Vcc)
+               if (cfg->vcc.param[CISTPL_POWER_VNOM]/10000 != vcc)
                        return -ENODEV;
        } else if (dflt->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-               if (dflt->vcc.param[CISTPL_POWER_VNOM]/10000
-                   != cfg_mem->conf.Vcc)
+               if (dflt->vcc.param[CISTPL_POWER_VNOM]/10000 != vcc)
                        return -ENODEV;
                }
 
        struct device           *parent = &handle_to_dev(link);
        local_info_t            *dev = link->priv;
        int                     last_fn, last_ret;
-       struct sl811_css_cfg    *cfg_mem;
 
        DBG(0, "sl811_cs_config(0x%p)\n", link);
 
-       cfg_mem = kzalloc(sizeof(struct sl811_css_cfg), GFP_KERNEL);
-       if (!cfg_mem)
-               return -ENOMEM;
-
-       /* Look up the current Vcc */
-       CS_CHECK(GetConfigurationInfo,
-                       pcmcia_get_configuration_info(link, &cfg_mem->conf));
-
-       if (pcmcia_loop_config(link, sl811_cs_config_check, cfg_mem))
-               return -ENODEV;
+       if (pcmcia_loop_config(link, sl811_cs_config_check, NULL))
+               goto failed;
 
        /* require an IRQ and two registers */
        if (!link->io.NumPorts1 || link->io.NumPorts1 < 2)
-               goto cs_failed;
+               goto failed;
        if (link->conf.Attributes & CONF_ENABLE_IRQ)
                CS_CHECK(RequestIRQ,
                        pcmcia_request_irq(link, &link->irq));
        else
-               goto cs_failed;
+               goto failed;
 
        CS_CHECK(RequestConfiguration,
                pcmcia_request_configuration(link, &link->conf));
        if (sl811_hc_init(parent, link->io.BasePort1, link->irq.AssignedIRQ)
                        < 0) {
 cs_failed:
-               printk("sl811_cs_config failed\n");
                cs_error(link, last_fn, last_ret);
+failed:
+               printk(KERN_WARNING "sl811_cs_config failed\n");
                sl811_cs_release(link);
-               kfree(cfg_mem);
                return  -ENODEV;
        }
-       kfree(cfg_mem);
        return 0;
 }
 
 
                       int      (*conf_check)   (struct pcmcia_device *p_dev,
                                                 cistpl_cftable_entry_t *cf,
                                                 cistpl_cftable_entry_t *dflt,
+                                                unsigned int vcc,
                                                 void *priv_data),
                       void *priv_data);