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/export.h>
17 #include <linux/slab.h>
18 #include <linux/pm_runtime.h>
19 #include <linux/pm_domain.h>
20 #include <linux/acpi.h>
22 #include <linux/mmc/card.h>
23 #include <linux/mmc/host.h>
24 #include <linux/mmc/sdio_func.h>
31 #ifdef CONFIG_MMC_EMBEDDED_SDIO
32 #include <linux/mmc/host.h>
35 #define to_sdio_driver(d) container_of(d, struct sdio_driver, drv)
37 /* show configuration fields */
38 #define sdio_config_attr(field, format_string) \
40 field##_show(struct device *dev, struct device_attribute *attr, char *buf) \
42 struct sdio_func *func; \
44 func = dev_to_sdio_func (dev); \
45 return sprintf (buf, format_string, func->field); \
47 static DEVICE_ATTR_RO(field)
49 sdio_config_attr(class, "0x%02x\n");
50 sdio_config_attr(vendor
, "0x%04x\n");
51 sdio_config_attr(device
, "0x%04x\n");
53 static ssize_t
modalias_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
55 struct sdio_func
*func
= dev_to_sdio_func (dev
);
57 return sprintf(buf
, "sdio:c%02Xv%04Xd%04X\n",
58 func
->class, func
->vendor
, func
->device
);
60 static DEVICE_ATTR_RO(modalias
);
62 static struct attribute
*sdio_dev_attrs
[] = {
64 &dev_attr_vendor
.attr
,
65 &dev_attr_device
.attr
,
66 &dev_attr_modalias
.attr
,
69 ATTRIBUTE_GROUPS(sdio_dev
);
71 static const struct sdio_device_id
*sdio_match_one(struct sdio_func
*func
,
72 const struct sdio_device_id
*id
)
74 if (id
->class != (__u8
)SDIO_ANY_ID
&& id
->class != func
->class)
76 if (id
->vendor
!= (__u16
)SDIO_ANY_ID
&& id
->vendor
!= func
->vendor
)
78 if (id
->device
!= (__u16
)SDIO_ANY_ID
&& id
->device
!= func
->device
)
83 static const struct sdio_device_id
*sdio_match_device(struct sdio_func
*func
,
84 struct sdio_driver
*sdrv
)
86 const struct sdio_device_id
*ids
;
91 while (ids
->class || ids
->vendor
|| ids
->device
) {
92 if (sdio_match_one(func
, ids
))
101 static int sdio_bus_match(struct device
*dev
, struct device_driver
*drv
)
103 struct sdio_func
*func
= dev_to_sdio_func(dev
);
104 struct sdio_driver
*sdrv
= to_sdio_driver(drv
);
106 if (sdio_match_device(func
, sdrv
))
113 sdio_bus_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
115 struct sdio_func
*func
= dev_to_sdio_func(dev
);
117 if (add_uevent_var(env
,
118 "SDIO_CLASS=%02X", func
->class))
121 if (add_uevent_var(env
,
122 "SDIO_ID=%04X:%04X", func
->vendor
, func
->device
))
125 if (add_uevent_var(env
,
126 "MODALIAS=sdio:c%02Xv%04Xd%04X",
127 func
->class, func
->vendor
, func
->device
))
133 static int sdio_bus_probe(struct device
*dev
)
135 struct sdio_driver
*drv
= to_sdio_driver(dev
->driver
);
136 struct sdio_func
*func
= dev_to_sdio_func(dev
);
137 const struct sdio_device_id
*id
;
140 id
= sdio_match_device(func
, drv
);
144 ret
= dev_pm_domain_attach(dev
, false);
145 if (ret
== -EPROBE_DEFER
)
148 /* Unbound SDIO functions are always suspended.
149 * During probe, the function is set active and the usage count
150 * is incremented. If the driver supports runtime PM,
151 * it should call pm_runtime_put_noidle() in its probe routine and
152 * pm_runtime_get_noresume() in its remove routine.
154 if (func
->card
->host
->caps
& MMC_CAP_POWER_OFF_CARD
) {
155 ret
= pm_runtime_get_sync(dev
);
157 goto disable_runtimepm
;
160 /* Set the default block size so the driver is sure it's something
162 sdio_claim_host(func
);
163 ret
= sdio_set_block_size(func
, 0);
164 sdio_release_host(func
);
166 goto disable_runtimepm
;
168 ret
= drv
->probe(func
, id
);
170 goto disable_runtimepm
;
175 if (func
->card
->host
->caps
& MMC_CAP_POWER_OFF_CARD
)
176 pm_runtime_put_noidle(dev
);
177 dev_pm_domain_detach(dev
, false);
181 static int sdio_bus_remove(struct device
*dev
)
183 struct sdio_driver
*drv
= to_sdio_driver(dev
->driver
);
184 struct sdio_func
*func
= dev_to_sdio_func(dev
);
187 /* Make sure card is powered before invoking ->remove() */
188 if (func
->card
->host
->caps
& MMC_CAP_POWER_OFF_CARD
)
189 pm_runtime_get_sync(dev
);
193 if (func
->irq_handler
) {
194 pr_warn("WARNING: driver %s did not remove its interrupt handler!\n",
196 sdio_claim_host(func
);
197 sdio_release_irq(func
);
198 sdio_release_host(func
);
201 /* First, undo the increment made directly above */
202 if (func
->card
->host
->caps
& MMC_CAP_POWER_OFF_CARD
)
203 pm_runtime_put_noidle(dev
);
205 /* Then undo the runtime PM settings in sdio_bus_probe() */
206 if (func
->card
->host
->caps
& MMC_CAP_POWER_OFF_CARD
)
207 pm_runtime_put_sync(dev
);
209 dev_pm_domain_detach(dev
, false);
214 static const struct dev_pm_ops sdio_bus_pm_ops
= {
215 SET_SYSTEM_SLEEP_PM_OPS(pm_generic_suspend
, pm_generic_resume
)
217 pm_generic_runtime_suspend
,
218 pm_generic_runtime_resume
,
223 static struct bus_type sdio_bus_type
= {
225 .dev_groups
= sdio_dev_groups
,
226 .match
= sdio_bus_match
,
227 .uevent
= sdio_bus_uevent
,
228 .probe
= sdio_bus_probe
,
229 .remove
= sdio_bus_remove
,
230 .pm
= &sdio_bus_pm_ops
,
233 int sdio_register_bus(void)
235 return bus_register(&sdio_bus_type
);
238 void sdio_unregister_bus(void)
240 bus_unregister(&sdio_bus_type
);
244 * sdio_register_driver - register a function driver
245 * @drv: SDIO function driver
247 int sdio_register_driver(struct sdio_driver
*drv
)
249 drv
->drv
.name
= drv
->name
;
250 drv
->drv
.bus
= &sdio_bus_type
;
251 return driver_register(&drv
->drv
);
253 EXPORT_SYMBOL_GPL(sdio_register_driver
);
256 * sdio_unregister_driver - unregister a function driver
257 * @drv: SDIO function driver
259 void sdio_unregister_driver(struct sdio_driver
*drv
)
261 drv
->drv
.bus
= &sdio_bus_type
;
262 driver_unregister(&drv
->drv
);
264 EXPORT_SYMBOL_GPL(sdio_unregister_driver
);
266 static void sdio_release_func(struct device
*dev
)
268 struct sdio_func
*func
= dev_to_sdio_func(dev
);
270 #ifdef CONFIG_MMC_EMBEDDED_SDIO
272 * If this device is embedded then we never allocated
273 * cis tables for this func
275 if (!func
->card
->host
->embedded_sdio_data
.funcs
)
277 sdio_free_func_cis(func
);
285 * Allocate and initialise a new SDIO function structure.
287 struct sdio_func
*sdio_alloc_func(struct mmc_card
*card
)
289 struct sdio_func
*func
;
291 func
= kzalloc(sizeof(struct sdio_func
), GFP_KERNEL
);
293 return ERR_PTR(-ENOMEM
);
297 device_initialize(&func
->dev
);
299 func
->dev
.parent
= &card
->dev
;
300 func
->dev
.bus
= &sdio_bus_type
;
301 func
->dev
.release
= sdio_release_func
;
307 static void sdio_acpi_set_handle(struct sdio_func
*func
)
309 struct mmc_host
*host
= func
->card
->host
;
310 u64 addr
= ((u64
)host
->slotno
<< 16) | func
->num
;
312 acpi_preset_companion(&func
->dev
, ACPI_COMPANION(host
->parent
), addr
);
315 static inline void sdio_acpi_set_handle(struct sdio_func
*func
) {}
318 static void sdio_set_of_node(struct sdio_func
*func
)
320 struct mmc_host
*host
= func
->card
->host
;
322 func
->dev
.of_node
= mmc_of_find_child_device(host
, func
->num
);
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 sdio_set_of_node(func
);
335 sdio_acpi_set_handle(func
);
336 ret
= device_add(&func
->dev
);
338 sdio_func_set_present(func
);
344 * Unregister a SDIO function with the driver model, and
345 * (eventually) free it.
346 * This function can be called through error paths where sdio_add_func() was
347 * never executed (because a failure occurred at an earlier point).
349 void sdio_remove_func(struct sdio_func
*func
)
351 if (!sdio_func_present(func
))
354 device_del(&func
->dev
);
355 of_node_put(func
->dev
.of_node
);
356 put_device(&func
->dev
);