2 * linux/drivers/mmc/core/sdio_bus.c
4 * Copyright 2007 Pierre Ossman
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or (at
9 * your option) any later version.
11 * SDIO function driver model
14 #include <linux/device.h>
15 #include <linux/err.h>
16 #include <linux/slab.h>
17 #include <linux/pm_runtime.h>
19 #include <linux/mmc/card.h>
20 #include <linux/mmc/host.h>
21 #include <linux/mmc/sdio_func.h>
26 /* show configuration fields */
27 #define sdio_config_attr(field, format_string) \
29 field##_show(struct device *dev, struct device_attribute *attr, char *buf) \
31 struct sdio_func *func; \
33 func = dev_to_sdio_func (dev); \
34 return sprintf (buf, format_string, func->field); \
37 sdio_config_attr(class, "0x%02x\n");
38 sdio_config_attr(vendor, "0x%04x\n");
39 sdio_config_attr(device, "0x%04x\n");
41 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
43 struct sdio_func *func = dev_to_sdio_func (dev);
45 return sprintf(buf, "sdio:c%02Xv%04Xd%04X\n",
46 func->class, func->vendor, func->device);
49 static struct device_attribute sdio_dev_attrs[] = {
57 static const struct sdio_device_id *sdio_match_one(struct sdio_func *func,
58 const struct sdio_device_id *id)
60 if (id->class != (__u8)SDIO_ANY_ID && id->class != func->class)
62 if (id->vendor != (__u16)SDIO_ANY_ID && id->vendor != func->vendor)
64 if (id->device != (__u16)SDIO_ANY_ID && id->device != func->device)
69 static const struct sdio_device_id *sdio_match_device(struct sdio_func *func,
70 struct sdio_driver *sdrv)
72 const struct sdio_device_id *ids;
77 while (ids->class || ids->vendor || ids->device) {
78 if (sdio_match_one(func, ids))
87 static int sdio_bus_match(struct device *dev, struct device_driver *drv)
89 struct sdio_func *func = dev_to_sdio_func(dev);
90 struct sdio_driver *sdrv = to_sdio_driver(drv);
92 if (sdio_match_device(func, sdrv))
99 sdio_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
101 struct sdio_func *func = dev_to_sdio_func(dev);
103 if (add_uevent_var(env,
104 "SDIO_CLASS=%02X", func->class))
107 if (add_uevent_var(env,
108 "SDIO_ID=%04X:%04X", func->vendor, func->device))
111 if (add_uevent_var(env,
112 "MODALIAS=sdio:c%02Xv%04Xd%04X",
113 func->class, func->vendor, func->device))
119 static int sdio_bus_probe(struct device *dev)
121 struct sdio_driver *drv = to_sdio_driver(dev->driver);
122 struct sdio_func *func = dev_to_sdio_func(dev);
123 const struct sdio_device_id *id;
126 id = sdio_match_device(func, drv);
130 /* Unbound SDIO functions are always suspended.
131 * During probe, the function is set active and the usage count
132 * is incremented. If the driver supports runtime PM,
133 * it should call pm_runtime_put_noidle() in its probe routine and
134 * pm_runtime_get_noresume() in its remove routine.
136 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) {
137 ret = pm_runtime_get_sync(dev);
142 /* Set the default block size so the driver is sure it's something
144 sdio_claim_host(func);
145 ret = sdio_set_block_size(func, 0);
146 sdio_release_host(func);
148 goto disable_runtimepm;
150 ret = drv->probe(func, id);
152 goto disable_runtimepm;
157 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
158 pm_runtime_put_noidle(dev);
163 static int sdio_bus_remove(struct device *dev)
165 struct sdio_driver *drv = to_sdio_driver(dev->driver);
166 struct sdio_func *func = dev_to_sdio_func(dev);
169 /* Make sure card is powered before invoking ->remove() */
170 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) {
171 ret = pm_runtime_get_sync(dev);
178 if (func->irq_handler) {
179 printk(KERN_WARNING "WARNING: driver %s did not remove "
180 "its interrupt handler!\n", drv->name);
181 sdio_claim_host(func);
182 sdio_release_irq(func);
183 sdio_release_host(func);
186 /* First, undo the increment made directly above */
187 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
188 pm_runtime_put_noidle(dev);
190 /* Then undo the runtime PM settings in sdio_bus_probe() */
191 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
192 pm_runtime_put_noidle(dev);
198 #ifdef CONFIG_PM_RUNTIME
200 static int sdio_bus_pm_prepare(struct device *dev)
202 struct sdio_func *func = dev_to_sdio_func(dev);
205 * Resume an SDIO device which was suspended at run time at this
206 * point, in order to allow standard SDIO suspend/resume paths
207 * to keep working as usual.
209 * Ultimately, the SDIO driver itself will decide (in its
210 * suspend handler, or lack thereof) whether the card should be
211 * removed or kept, and if kept, at what power state.
213 * At this point, PM core have increased our use count, so it's
214 * safe to directly resume the device. After system is resumed
215 * again, PM core will drop back its runtime PM use count, and if
216 * needed device will be suspended again.
218 * The end result is guaranteed to be a power state that is
219 * coherent with the device's runtime PM use count.
221 * The return value of pm_runtime_resume is deliberately unchecked
222 * since there is little point in failing system suspend if a
223 * device can't be resumed.
225 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD)
226 pm_runtime_resume(dev);
231 static const struct dev_pm_ops sdio_bus_pm_ops = {
233 pm_generic_runtime_suspend,
234 pm_generic_runtime_resume,
235 pm_generic_runtime_idle
237 .prepare = sdio_bus_pm_prepare,
240 #define SDIO_PM_OPS_PTR (&sdio_bus_pm_ops)
242 #else /* !CONFIG_PM_RUNTIME */
244 #define SDIO_PM_OPS_PTR NULL
246 #endif /* !CONFIG_PM_RUNTIME */
248 static struct bus_type sdio_bus_type = {
250 .dev_attrs = sdio_dev_attrs,
251 .match = sdio_bus_match,
252 .uevent = sdio_bus_uevent,
253 .probe = sdio_bus_probe,
254 .remove = sdio_bus_remove,
255 .pm = SDIO_PM_OPS_PTR,
258 int sdio_register_bus(void)
260 return bus_register(&sdio_bus_type);
263 void sdio_unregister_bus(void)
265 bus_unregister(&sdio_bus_type);
269 * sdio_register_driver - register a function driver
270 * @drv: SDIO function driver
272 int sdio_register_driver(struct sdio_driver *drv)
274 drv->drv.name = drv->name;
275 drv->drv.bus = &sdio_bus_type;
276 return driver_register(&drv->drv);
278 EXPORT_SYMBOL_GPL(sdio_register_driver);
281 * sdio_unregister_driver - unregister a function driver
282 * @drv: SDIO function driver
284 void sdio_unregister_driver(struct sdio_driver *drv)
286 drv->drv.bus = &sdio_bus_type;
287 driver_unregister(&drv->drv);
289 EXPORT_SYMBOL_GPL(sdio_unregister_driver);
291 static void sdio_release_func(struct device *dev)
293 struct sdio_func *func = dev_to_sdio_func(dev);
295 sdio_free_func_cis(func);
304 * Allocate and initialise a new SDIO function structure.
306 struct sdio_func *sdio_alloc_func(struct mmc_card *card)
308 struct sdio_func *func;
310 func = kzalloc(sizeof(struct sdio_func), GFP_KERNEL);
312 return ERR_PTR(-ENOMEM);
316 device_initialize(&func->dev);
318 func->dev.parent = &card->dev;
319 func->dev.bus = &sdio_bus_type;
320 func->dev.release = sdio_release_func;
326 * Register a new SDIO function with the driver model.
328 int sdio_add_func(struct sdio_func *func)
332 dev_set_name(&func->dev, "%s:%d", mmc_card_id(func->card), func->num);
334 ret = device_add(&func->dev);
336 sdio_func_set_present(func);
342 * Unregister a SDIO function with the driver model, and
343 * (eventually) free it.
344 * This function can be called through error paths where sdio_add_func() was
345 * never executed (because a failure occurred at an earlier point).
347 void sdio_remove_func(struct sdio_func *func)
349 if (!sdio_func_present(func))
352 device_del(&func->dev);
353 put_device(&func->dev);