MIPS: Alchemy: Basic support for the DB1300 board.
[linux-2.6.git] / drivers / pcmcia / ds.c
index d2ec458..749c2a1 100644 (file)
@@ -10,7 +10,7 @@
  * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  *
  * (C) 1999            David A. Hinds
- * (C) 2003 - 2006     Dominik Brodowski
+ * (C) 2003 - 2010     Dominik Brodowski
  */
 
 #include <linux/kernel.h>
@@ -26,8 +26,6 @@
 #include <linux/dma-mapping.h>
 #include <linux/slab.h>
 
-#include <pcmcia/cs_types.h>
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 #include <pcmcia/ss.h>
@@ -47,13 +45,13 @@ MODULE_LICENSE("GPL");
 
 static void pcmcia_check_driver(struct pcmcia_driver *p_drv)
 {
-       struct pcmcia_device_id *did = p_drv->id_table;
+       const struct pcmcia_device_id *did = p_drv->id_table;
        unsigned int i;
        u32 hash;
 
        if (!p_drv->probe || !p_drv->remove)
                printk(KERN_DEBUG "pcmcia: %s lacks a requisite callback "
-                      "function\n", p_drv->drv.name);
+                      "function\n", p_drv->name);
 
        while (did && did->match_flags) {
                for (i = 0; i < 4; i++) {
@@ -66,7 +64,7 @@ static void pcmcia_check_driver(struct pcmcia_driver *p_drv)
 
                        printk(KERN_DEBUG "pcmcia: %s: invalid hash for "
                               "product string \"%s\": is 0x%x, should "
-                              "be 0x%x\n", p_drv->drv.name, did->prod_id[i],
+                              "be 0x%x\n", p_drv->name, did->prod_id[i],
                               did->prod_id_hash[i], hash);
                        printk(KERN_DEBUG "pcmcia: see "
                                "Documentation/pcmcia/devicetable.txt for "
@@ -181,10 +179,11 @@ int pcmcia_register_driver(struct pcmcia_driver *driver)
        /* initialize common fields */
        driver->drv.bus = &pcmcia_bus_type;
        driver->drv.owner = driver->owner;
+       driver->drv.name = driver->name;
        mutex_init(&driver->dynids.lock);
        INIT_LIST_HEAD(&driver->dynids.list);
 
-       pr_debug("registering driver %s\n", driver->drv.name);
+       pr_debug("registering driver %s\n", driver->name);
 
        error = driver_register(&driver->drv);
        if (error < 0)
@@ -204,7 +203,7 @@ EXPORT_SYMBOL(pcmcia_register_driver);
  */
 void pcmcia_unregister_driver(struct pcmcia_driver *driver)
 {
-       pr_debug("unregistering driver %s\n", driver->drv.name);
+       pr_debug("unregistering driver %s\n", driver->name);
        driver_unregister(&driver->drv);
        pcmcia_free_dynids(driver);
 }
@@ -265,7 +264,7 @@ static int pcmcia_device_probe(struct device *dev)
        p_drv = to_pcmcia_drv(dev->driver);
        s = p_dev->socket;
 
-       dev_dbg(dev, "trying to bind to %s\n", p_drv->drv.name);
+       dev_dbg(dev, "trying to bind to %s\n", p_drv->name);
 
        if ((!p_drv->probe) || (!p_dev->function_config) ||
            (!try_module_get(p_drv->owner))) {
@@ -277,24 +276,31 @@ static int pcmcia_device_probe(struct device *dev)
        ret = pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_CONFIG,
                                &cis_config);
        if (!ret) {
-               p_dev->conf.ConfigBase = cis_config.base;
-               p_dev->conf.Present = cis_config.rmask[0];
+               p_dev->config_base = cis_config.base;
+               p_dev->config_regs = cis_config.rmask[0];
+               dev_dbg(dev, "base %x, regs %x", p_dev->config_base,
+                       p_dev->config_regs);
        } else {
                dev_printk(KERN_INFO, dev,
                           "pcmcia: could not parse base and rmask0 of CIS\n");
-               p_dev->conf.ConfigBase = 0;
-               p_dev->conf.Present = 0;
+               p_dev->config_base = 0;
+               p_dev->config_regs = 0;
        }
 
        ret = p_drv->probe(p_dev);
        if (ret) {
                dev_dbg(dev, "binding to %s failed with %d\n",
-                          p_drv->drv.name, ret);
+                          p_drv->name, ret);
                goto put_module;
        }
+       dev_dbg(dev, "%s bound: Vpp %d.%d, idx %x, IRQ %d", p_drv->name,
+               p_dev->vpp/10, p_dev->vpp%10, p_dev->config_index, p_dev->irq);
+       dev_dbg(dev, "resources: ioport %pR %pR iomem %pR %pR %pR",
+               p_dev->resource[0], p_dev->resource[1], p_dev->resource[2],
+               p_dev->resource[3], p_dev->resource[4]);
 
        mutex_lock(&s->ops_mutex);
-       if ((s->pcmcia_state.has_pfc) &&
+       if ((s->pcmcia_pfc) &&
            (p_dev->socket->device_count == 1) && (p_dev->device_no == 0))
                pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY);
        mutex_unlock(&s->ops_mutex);
@@ -359,7 +365,7 @@ static int pcmcia_device_remove(struct device *dev)
         * pseudo multi-function card, we need to unbind
         * all devices
         */
-       if ((p_dev->socket->pcmcia_state.has_pfc) &&
+       if ((p_dev->socket->pcmcia_pfc) &&
            (p_dev->socket->device_count > 0) &&
            (p_dev->device_no == 0))
                pcmcia_card_remove(p_dev->socket, p_dev);
@@ -375,13 +381,13 @@ static int pcmcia_device_remove(struct device *dev)
        if (p_dev->_irq || p_dev->_io || p_dev->_locked)
                dev_printk(KERN_INFO, dev,
                        "pcmcia: driver %s did not release config properly\n",
-                       p_drv->drv.name);
+                       p_drv->name);
 
        for (i = 0; i < MAX_WIN; i++)
                if (p_dev->_win & CLIENT_WIN_REQ(i))
                        dev_printk(KERN_INFO, dev,
                          "pcmcia: driver %s did not release window properly\n",
-                          p_drv->drv.name);
+                          p_drv->name);
 
        /* references from pcmcia_probe_device */
        pcmcia_put_dev(p_dev);
@@ -532,7 +538,6 @@ static struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s,
        list_for_each_entry(tmp_dev, &s->devices_list, socket_device_list)
                if (p_dev->func == tmp_dev->func) {
                        p_dev->function_config = tmp_dev->function_config;
-                       p_dev->io = tmp_dev->io;
                        p_dev->irq = tmp_dev->irq;
                        kref_get(&p_dev->function_config->ref);
                }
@@ -545,15 +550,29 @@ static struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s,
                        "IRQ setup failed -- device might not work\n");
 
        if (!p_dev->function_config) {
+               config_t *c;
                dev_dbg(&p_dev->dev, "creating config_t\n");
-               p_dev->function_config = kzalloc(sizeof(struct config_t),
-                                                GFP_KERNEL);
-               if (!p_dev->function_config) {
+               c = kzalloc(sizeof(struct config_t), GFP_KERNEL);
+               if (!c) {
                        mutex_unlock(&s->ops_mutex);
                        goto err_unreg;
                }
-               kref_init(&p_dev->function_config->ref);
+               p_dev->function_config = c;
+               kref_init(&c->ref);
+               for (i = 0; i < MAX_IO_WIN; i++) {
+                       c->io[i].name = p_dev->devname;
+                       c->io[i].flags = IORESOURCE_IO;
+               }
+               for (i = 0; i< MAX_WIN; i++) {
+                       c->mem[i].name = p_dev->devname;
+                       c->mem[i].flags = IORESOURCE_MEM;
+               }
        }
+       for (i = 0; i < MAX_IO_WIN; i++)
+               p_dev->resource[i] = &p_dev->function_config->io[i];
+       for (; i < (MAX_IO_WIN + MAX_WIN); i++)
+               p_dev->resource[i] = &p_dev->function_config->mem[i-MAX_IO_WIN];
+
        mutex_unlock(&s->ops_mutex);
 
        dev_printk(KERN_NOTICE, &p_dev->dev,
@@ -681,7 +700,7 @@ static void pcmcia_requery(struct pcmcia_socket *s)
         * call pcmcia_device_add() -- which will fail if both
         * devices are already registered. */
        mutex_lock(&s->ops_mutex);
-       has_pfc = s->pcmcia_state.has_pfc;
+       has_pfc = s->pcmcia_pfc;
        mutex_unlock(&s->ops_mutex);
        if (has_pfc)
                pcmcia_device_add(s, 0);
@@ -765,7 +784,7 @@ static inline int pcmcia_load_firmware(struct pcmcia_device *dev, char * filenam
 
 
 static inline int pcmcia_devmatch(struct pcmcia_device *dev,
-                                 struct pcmcia_device_id *did)
+                                 const struct pcmcia_device_id *did)
 {
        if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) {
                if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id))
@@ -813,7 +832,7 @@ static inline int pcmcia_devmatch(struct pcmcia_device *dev,
        if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) {
                dev_dbg(&dev->dev, "this is a pseudo-multi-function device\n");
                mutex_lock(&dev->socket->ops_mutex);
-               dev->socket->pcmcia_state.has_pfc = 1;
+               dev->socket->pcmcia_pfc = 1;
                mutex_unlock(&dev->socket->ops_mutex);
                if (dev->device_no != did->device_no)
                        return 0;
@@ -827,7 +846,7 @@ static inline int pcmcia_devmatch(struct pcmcia_device *dev,
 
                /* if this is a pseudo-multi-function device,
                 * we need explicit matches */
-               if (dev->socket->pcmcia_state.has_pfc)
+               if (dev->socket->pcmcia_pfc)
                        return 0;
                if (dev->device_no)
                        return 0;
@@ -871,7 +890,7 @@ static int pcmcia_bus_match(struct device *dev, struct device_driver *drv)
 {
        struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
        struct pcmcia_driver *p_drv = to_pcmcia_drv(drv);
-       struct pcmcia_device_id *did = p_drv->id_table;
+       const struct pcmcia_device_id *did = p_drv->id_table;
        struct pcmcia_dynid *dynid;
 
        /* match dynamic devices first */
@@ -999,6 +1018,18 @@ pcmcia_device_stringattr(prod_id2, prod_id[1]);
 pcmcia_device_stringattr(prod_id3, prod_id[2]);
 pcmcia_device_stringattr(prod_id4, prod_id[3]);
 
+static ssize_t pcmcia_show_resources(struct device *dev,
+                                    struct device_attribute *attr, char *buf)
+{
+       struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
+       char *str = buf;
+       int i;
+
+       for (i = 0; i < PCMCIA_NUM_RESOURCES; i++)
+               str += sprintf(str, "%pr\n", p_dev->resource[i]);
+
+       return str - buf;
+}
 
 static ssize_t pcmcia_show_pm_state(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -1069,6 +1100,7 @@ static ssize_t pcmcia_store_allow_func_id_match(struct device *dev,
 static struct device_attribute pcmcia_dev_attrs[] = {
        __ATTR(function, 0444, func_show, NULL),
        __ATTR(pm_state, 0644, pcmcia_show_pm_state, pcmcia_store_pm_state),
+       __ATTR(resources, 0444, pcmcia_show_resources, NULL),
        __ATTR_RO(func_id),
        __ATTR_RO(manf_id),
        __ATTR_RO(card_id),
@@ -1111,7 +1143,7 @@ static int pcmcia_dev_suspend(struct device *dev, pm_message_t state)
                        dev_printk(KERN_ERR, dev,
                                   "pcmcia: device %s (driver %s) did "
                                   "not want to go to sleep (%d)\n",
-                                  p_dev->devname, p_drv->drv.name, ret);
+                                  p_dev->devname, p_drv->name, ret);
                        mutex_lock(&p_dev->socket->ops_mutex);
                        p_dev->suspended = 0;
                        mutex_unlock(&p_dev->socket->ops_mutex);
@@ -1153,7 +1185,7 @@ static int pcmcia_dev_resume(struct device *dev)
 
        if (p_dev->device_no == p_dev->func) {
                dev_dbg(dev, "requesting configuration\n");
-               ret = pcmcia_request_configuration(p_dev, &p_dev->conf);
+               ret = pcmcia_enable_device(p_dev);
                if (ret)
                        goto out;
        }
@@ -1208,82 +1240,57 @@ static int pcmcia_bus_suspend(struct pcmcia_socket *skt)
        return 0;
 }
 
+static int pcmcia_bus_remove(struct pcmcia_socket *skt)
+{
+       atomic_set(&skt->present, 0);
+       pcmcia_card_remove(skt, NULL);
 
-/*======================================================================
+       mutex_lock(&skt->ops_mutex);
+       destroy_cis_cache(skt);
+       pcmcia_cleanup_irq(skt);
+       mutex_unlock(&skt->ops_mutex);
 
-    The card status event handler.
+       return 0;
+}
 
-======================================================================*/
+static int pcmcia_bus_add(struct pcmcia_socket *skt)
+{
+       atomic_set(&skt->present, 1);
 
-/* Normally, the event is passed to individual drivers after
- * informing userspace. Only for CS_EVENT_CARD_REMOVAL this
- * is inversed to maintain historic compatibility.
- */
+       mutex_lock(&skt->ops_mutex);
+       skt->pcmcia_pfc = 0;
+       destroy_cis_cache(skt); /* to be on the safe side... */
+       mutex_unlock(&skt->ops_mutex);
 
-static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
-{
-       struct pcmcia_socket *s = pcmcia_get_socket(skt);
+       pcmcia_card_add(skt);
 
-       if (!s) {
-               dev_printk(KERN_ERR, &skt->dev,
-                          "PCMCIA obtaining reference to socket "      \
-                          "failed, event 0x%x lost!\n", event);
-               return -ENODEV;
+       return 0;
+}
+
+static int pcmcia_bus_early_resume(struct pcmcia_socket *skt)
+{
+       if (!verify_cis_cache(skt)) {
+               pcmcia_put_socket(skt);
+               return 0;
        }
 
-       dev_dbg(&skt->dev, "ds_event(0x%06x, %d, 0x%p)\n",
-                  event, priority, skt);
+       dev_dbg(&skt->dev, "cis mismatch - different card\n");
 
-       switch (event) {
-       case CS_EVENT_CARD_REMOVAL:
-               atomic_set(&skt->present, 0);
-               pcmcia_card_remove(skt, NULL);
-               mutex_lock(&s->ops_mutex);
-               destroy_cis_cache(s);
-               pcmcia_cleanup_irq(s);
-               mutex_unlock(&s->ops_mutex);
-               break;
+       /* first, remove the card */
+       pcmcia_bus_remove(skt);
 
-       case CS_EVENT_CARD_INSERTION:
-               atomic_set(&skt->present, 1);
-               mutex_lock(&s->ops_mutex);
-               s->pcmcia_state.has_pfc = 0;
-               destroy_cis_cache(s); /* to be on the safe side... */
-               mutex_unlock(&s->ops_mutex);
-               pcmcia_card_add(skt);
-               break;
-
-       case CS_EVENT_EJECTION_REQUEST:
-               break;
-
-       case CS_EVENT_PM_RESUME:
-               if (verify_cis_cache(skt) != 0) {
-                       dev_dbg(&skt->dev, "cis mismatch - different card\n");
-                       /* first, remove the card */
-                       ds_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
-                       mutex_lock(&s->ops_mutex);
-                       destroy_cis_cache(skt);
-                       kfree(skt->fake_cis);
-                       skt->fake_cis = NULL;
-                       s->functions = 0;
-                       mutex_unlock(&s->ops_mutex);
-                       /* now, add the new card */
-                       ds_event(skt, CS_EVENT_CARD_INSERTION,
-                                CS_EVENT_PRI_LOW);
-               }
-               break;
+       mutex_lock(&skt->ops_mutex);
+       destroy_cis_cache(skt);
+       kfree(skt->fake_cis);
+       skt->fake_cis = NULL;
+       skt->functions = 0;
+       mutex_unlock(&skt->ops_mutex);
 
-       case CS_EVENT_PM_SUSPEND:
-       case CS_EVENT_RESET_PHYSICAL:
-       case CS_EVENT_CARD_RESET:
-       default:
-               break;
-    }
-
-    pcmcia_put_socket(s);
+       /* now, add the new card */
+       pcmcia_bus_add(skt);
+       return 0;
+}
 
-    return 0;
-} /* ds_event */
 
 /*
  * NOTE: This is racy. There's no guarantee the card will still be
@@ -1312,10 +1319,12 @@ EXPORT_SYMBOL(pcmcia_dev_present);
 
 static struct pcmcia_callback pcmcia_bus_callback = {
        .owner = THIS_MODULE,
-       .event = ds_event,
+       .add = pcmcia_bus_add,
+       .remove = pcmcia_bus_remove,
        .requery = pcmcia_requery,
        .validate = pccard_validate_cis,
        .suspend = pcmcia_bus_suspend,
+       .early_resume = pcmcia_bus_early_resume,
        .resume = pcmcia_bus_resume,
 };
 
@@ -1340,7 +1349,7 @@ static int __devinit pcmcia_bus_add_socket(struct device *dev,
        }
 
        INIT_LIST_HEAD(&socket->devices_list);
-       memset(&socket->pcmcia_state, 0, sizeof(u8));
+       socket->pcmcia_pfc = 0;
        socket->device_count = 0;
        atomic_set(&socket->present, 0);