mmc: sdhci-tegra: add platform code for UHS signaling
[linux-2.6.git] / drivers / mmc / core / sdio_bus.c
index 683d917..e4e6822 100644 (file)
 
 #include <linux/device.h>
 #include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/pm_runtime.h>
 
 #include <linux/mmc/card.h>
+#include <linux/mmc/host.h>
 #include <linux/mmc/sdio_func.h>
 
 #include "sdio_cis.h"
 #include "sdio_bus.h"
 
-#define dev_to_sdio_func(d)    container_of(d, struct sdio_func, dev)
-#define to_sdio_driver(d)      container_of(d, struct sdio_driver, drv)
-
 /* show configuration fields */
 #define sdio_config_attr(field, format_string)                         \
 static ssize_t                                                         \
@@ -96,30 +96,23 @@ static int sdio_bus_match(struct device *dev, struct device_driver *drv)
 }
 
 static int
-sdio_bus_uevent(struct device *dev, char **envp, int num_envp, char *buf,
-               int buf_size)
+sdio_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
        struct sdio_func *func = dev_to_sdio_func(dev);
-       int i = 0, length = 0;
 
-       if (add_uevent_var(envp, num_envp, &i,
-                       buf, buf_size, &length,
+       if (add_uevent_var(env,
                        "SDIO_CLASS=%02X", func->class))
                return -ENOMEM;
 
-       if (add_uevent_var(envp, num_envp, &i,
-                       buf, buf_size, &length,
+       if (add_uevent_var(env, 
                        "SDIO_ID=%04X:%04X", func->vendor, func->device))
                return -ENOMEM;
 
-       if (add_uevent_var(envp, num_envp, &i,
-                       buf, buf_size, &length,
+       if (add_uevent_var(env,
                        "MODALIAS=sdio:c%02Xv%04Xd%04X",
                        func->class, func->vendor, func->device))
                return -ENOMEM;
 
-       envp[i] = NULL;
-
        return 0;
 }
 
@@ -134,21 +127,48 @@ static int sdio_bus_probe(struct device *dev)
        if (!id)
                return -ENODEV;
 
+       /* Unbound SDIO functions are always suspended.
+        * During probe, the function is set active and the usage count
+        * is incremented.  If the driver supports runtime PM,
+        * it should call pm_runtime_put_noidle() in its probe routine and
+        * pm_runtime_get_noresume() in its remove routine.
+        */
+       if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) {
+               ret = pm_runtime_get_sync(dev);
+               if (ret < 0)
+                       goto out;
+       }
+
        /* Set the default block size so the driver is sure it's something
         * sensible. */
        sdio_claim_host(func);
        ret = sdio_set_block_size(func, 0);
        sdio_release_host(func);
        if (ret)
-               return ret;
+               goto disable_runtimepm;
+
+       ret = drv->probe(func, id);
+       if (ret)
+               goto disable_runtimepm;
 
-       return drv->probe(func, id);
+       return 0;
+
+disable_runtimepm:
+       if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
+               pm_runtime_put_noidle(dev);
+out:
+       return ret;
 }
 
 static int sdio_bus_remove(struct device *dev)
 {
        struct sdio_driver *drv = to_sdio_driver(dev->driver);
        struct sdio_func *func = dev_to_sdio_func(dev);
+       int ret = 0;
+
+       /* Make sure card is powered before invoking ->remove() */
+       if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
+               pm_runtime_get_sync(dev);
 
        drv->remove(func);
 
@@ -160,9 +180,35 @@ static int sdio_bus_remove(struct device *dev)
                sdio_release_host(func);
        }
 
-       return 0;
+       /* First, undo the increment made directly above */
+       if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
+               pm_runtime_put_noidle(dev);
+
+       /* Then undo the runtime PM settings in sdio_bus_probe() */
+       if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
+               pm_runtime_put_sync(dev);
+
+       return ret;
 }
 
+#ifdef CONFIG_PM_RUNTIME
+
+static const struct dev_pm_ops sdio_bus_pm_ops = {
+       SET_RUNTIME_PM_OPS(
+               pm_generic_runtime_suspend,
+               pm_generic_runtime_resume,
+               pm_generic_runtime_idle
+       )
+};
+
+#define SDIO_PM_OPS_PTR        (&sdio_bus_pm_ops)
+
+#else /* !CONFIG_PM_RUNTIME */
+
+#define SDIO_PM_OPS_PTR        NULL
+
+#endif /* !CONFIG_PM_RUNTIME */
+
 static struct bus_type sdio_bus_type = {
        .name           = "sdio",
        .dev_attrs      = sdio_dev_attrs,
@@ -170,6 +216,7 @@ static struct bus_type sdio_bus_type = {
        .uevent         = sdio_bus_uevent,
        .probe          = sdio_bus_probe,
        .remove         = sdio_bus_remove,
+       .pm             = SDIO_PM_OPS_PTR,
 };
 
 int sdio_register_bus(void)
@@ -211,6 +258,9 @@ static void sdio_release_func(struct device *dev)
 
        sdio_free_func_cis(func);
 
+       if (func->info)
+               kfree(func->info);
+
        kfree(func);
 }
 
@@ -243,8 +293,7 @@ int sdio_add_func(struct sdio_func *func)
 {
        int ret;
 
-       snprintf(func->dev.bus_id, sizeof(func->dev.bus_id),
-                "%s:%d", mmc_card_id(func->card), func->num);
+       dev_set_name(&func->dev, "%s:%d", mmc_card_id(func->card), func->num);
 
        ret = device_add(&func->dev);
        if (ret == 0)
@@ -256,12 +305,15 @@ int sdio_add_func(struct sdio_func *func)
 /*
  * Unregister a SDIO function with the driver model, and
  * (eventually) free it.
+ * This function can be called through error paths where sdio_add_func() was
+ * never executed (because a failure occurred at an earlier point).
  */
 void sdio_remove_func(struct sdio_func *func)
 {
-       if (sdio_func_present(func))
-               device_del(&func->dev);
+       if (!sdio_func_present(func))
+               return;
 
+       device_del(&func->dev);
        put_device(&func->dev);
 }