1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * linux/drivers/mmc/core/sdio_bus.c |
4 | * |
5 | * Copyright 2007 Pierre Ossman |
6 | * |
7 | * SDIO function driver model |
8 | */ |
9 | |
10 | #include <linux/device.h> |
11 | #include <linux/err.h> |
12 | #include <linux/export.h> |
13 | #include <linux/slab.h> |
14 | #include <linux/pm_runtime.h> |
15 | #include <linux/pm_domain.h> |
16 | #include <linux/acpi.h> |
17 | #include <linux/sysfs.h> |
18 | |
19 | #include <linux/mmc/card.h> |
20 | #include <linux/mmc/host.h> |
21 | #include <linux/mmc/sdio_func.h> |
22 | #include <linux/of.h> |
23 | |
24 | #include "core.h" |
25 | #include "card.h" |
26 | #include "sdio_cis.h" |
27 | #include "sdio_bus.h" |
28 | |
29 | #define to_sdio_driver(d) container_of(d, struct sdio_driver, drv) |
30 | |
31 | /* show configuration fields */ |
32 | #define sdio_config_attr(field, format_string, args...) \ |
33 | static ssize_t \ |
34 | field##_show(struct device *dev, struct device_attribute *attr, char *buf) \ |
35 | { \ |
36 | struct sdio_func *func; \ |
37 | \ |
38 | func = dev_to_sdio_func (dev); \ |
39 | return sysfs_emit(buf, format_string, args); \ |
40 | } \ |
41 | static DEVICE_ATTR_RO(field) |
42 | |
43 | sdio_config_attr(class, "0x%02x\n" , func->class); |
44 | sdio_config_attr(vendor, "0x%04x\n" , func->vendor); |
45 | sdio_config_attr(device, "0x%04x\n" , func->device); |
46 | sdio_config_attr(revision, "%u.%u\n" , func->major_rev, func->minor_rev); |
47 | sdio_config_attr(modalias, "sdio:c%02Xv%04Xd%04X\n" , func->class, func->vendor, func->device); |
48 | |
49 | #define sdio_info_attr(num) \ |
50 | static ssize_t info##num##_show(struct device *dev, struct device_attribute *attr, char *buf) \ |
51 | { \ |
52 | struct sdio_func *func = dev_to_sdio_func(dev); \ |
53 | \ |
54 | if (num > func->num_info) \ |
55 | return -ENODATA; \ |
56 | if (!func->info[num - 1][0]) \ |
57 | return 0; \ |
58 | return sysfs_emit(buf, "%s\n", func->info[num - 1]); \ |
59 | } \ |
60 | static DEVICE_ATTR_RO(info##num) |
61 | |
62 | sdio_info_attr(1); |
63 | sdio_info_attr(2); |
64 | sdio_info_attr(3); |
65 | sdio_info_attr(4); |
66 | |
67 | static struct attribute *sdio_dev_attrs[] = { |
68 | &dev_attr_class.attr, |
69 | &dev_attr_vendor.attr, |
70 | &dev_attr_device.attr, |
71 | &dev_attr_revision.attr, |
72 | &dev_attr_info1.attr, |
73 | &dev_attr_info2.attr, |
74 | &dev_attr_info3.attr, |
75 | &dev_attr_info4.attr, |
76 | &dev_attr_modalias.attr, |
77 | NULL, |
78 | }; |
79 | ATTRIBUTE_GROUPS(sdio_dev); |
80 | |
81 | static const struct sdio_device_id *sdio_match_one(struct sdio_func *func, |
82 | const struct sdio_device_id *id) |
83 | { |
84 | if (id->class != (__u8)SDIO_ANY_ID && id->class != func->class) |
85 | return NULL; |
86 | if (id->vendor != (__u16)SDIO_ANY_ID && id->vendor != func->vendor) |
87 | return NULL; |
88 | if (id->device != (__u16)SDIO_ANY_ID && id->device != func->device) |
89 | return NULL; |
90 | return id; |
91 | } |
92 | |
93 | static const struct sdio_device_id *sdio_match_device(struct sdio_func *func, |
94 | struct sdio_driver *sdrv) |
95 | { |
96 | const struct sdio_device_id *ids; |
97 | |
98 | ids = sdrv->id_table; |
99 | |
100 | if (ids) { |
101 | while (ids->class || ids->vendor || ids->device) { |
102 | if (sdio_match_one(func, id: ids)) |
103 | return ids; |
104 | ids++; |
105 | } |
106 | } |
107 | |
108 | return NULL; |
109 | } |
110 | |
111 | static int sdio_bus_match(struct device *dev, struct device_driver *drv) |
112 | { |
113 | struct sdio_func *func = dev_to_sdio_func(dev); |
114 | struct sdio_driver *sdrv = to_sdio_driver(drv); |
115 | |
116 | if (sdio_match_device(func, sdrv)) |
117 | return 1; |
118 | |
119 | return 0; |
120 | } |
121 | |
122 | static int |
123 | sdio_bus_uevent(const struct device *dev, struct kobj_uevent_env *env) |
124 | { |
125 | const struct sdio_func *func = dev_to_sdio_func(dev); |
126 | unsigned int i; |
127 | |
128 | if (add_uevent_var(env, |
129 | format: "SDIO_CLASS=%02X" , func->class)) |
130 | return -ENOMEM; |
131 | |
132 | if (add_uevent_var(env, |
133 | format: "SDIO_ID=%04X:%04X" , func->vendor, func->device)) |
134 | return -ENOMEM; |
135 | |
136 | if (add_uevent_var(env, |
137 | format: "SDIO_REVISION=%u.%u" , func->major_rev, func->minor_rev)) |
138 | return -ENOMEM; |
139 | |
140 | for (i = 0; i < func->num_info; i++) { |
141 | if (add_uevent_var(env, format: "SDIO_INFO%u=%s" , i+1, func->info[i])) |
142 | return -ENOMEM; |
143 | } |
144 | |
145 | if (add_uevent_var(env, |
146 | format: "MODALIAS=sdio:c%02Xv%04Xd%04X" , |
147 | func->class, func->vendor, func->device)) |
148 | return -ENOMEM; |
149 | |
150 | return 0; |
151 | } |
152 | |
153 | static int sdio_bus_probe(struct device *dev) |
154 | { |
155 | struct sdio_driver *drv = to_sdio_driver(dev->driver); |
156 | struct sdio_func *func = dev_to_sdio_func(dev); |
157 | const struct sdio_device_id *id; |
158 | int ret; |
159 | |
160 | id = sdio_match_device(func, sdrv: drv); |
161 | if (!id) |
162 | return -ENODEV; |
163 | |
164 | ret = dev_pm_domain_attach(dev, power_on: false); |
165 | if (ret) |
166 | return ret; |
167 | |
168 | atomic_inc(v: &func->card->sdio_funcs_probed); |
169 | |
170 | /* Unbound SDIO functions are always suspended. |
171 | * During probe, the function is set active and the usage count |
172 | * is incremented. If the driver supports runtime PM, |
173 | * it should call pm_runtime_put_noidle() in its probe routine and |
174 | * pm_runtime_get_noresume() in its remove routine. |
175 | */ |
176 | if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) { |
177 | ret = pm_runtime_get_sync(dev); |
178 | if (ret < 0) |
179 | goto disable_runtimepm; |
180 | } |
181 | |
182 | /* Set the default block size so the driver is sure it's something |
183 | * sensible. */ |
184 | sdio_claim_host(func); |
185 | if (mmc_card_removed(func->card)) |
186 | ret = -ENOMEDIUM; |
187 | else |
188 | ret = sdio_set_block_size(func, blksz: 0); |
189 | sdio_release_host(func); |
190 | if (ret) |
191 | goto disable_runtimepm; |
192 | |
193 | ret = drv->probe(func, id); |
194 | if (ret) |
195 | goto disable_runtimepm; |
196 | |
197 | return 0; |
198 | |
199 | disable_runtimepm: |
200 | atomic_dec(v: &func->card->sdio_funcs_probed); |
201 | if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) |
202 | pm_runtime_put_noidle(dev); |
203 | dev_pm_domain_detach(dev, power_off: false); |
204 | return ret; |
205 | } |
206 | |
207 | static void sdio_bus_remove(struct device *dev) |
208 | { |
209 | struct sdio_driver *drv = to_sdio_driver(dev->driver); |
210 | struct sdio_func *func = dev_to_sdio_func(dev); |
211 | |
212 | /* Make sure card is powered before invoking ->remove() */ |
213 | if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) |
214 | pm_runtime_get_sync(dev); |
215 | |
216 | drv->remove(func); |
217 | atomic_dec(v: &func->card->sdio_funcs_probed); |
218 | |
219 | if (func->irq_handler) { |
220 | pr_warn("WARNING: driver %s did not remove its interrupt handler!\n" , |
221 | drv->name); |
222 | sdio_claim_host(func); |
223 | sdio_release_irq(func); |
224 | sdio_release_host(func); |
225 | } |
226 | |
227 | /* First, undo the increment made directly above */ |
228 | if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) |
229 | pm_runtime_put_noidle(dev); |
230 | |
231 | /* Then undo the runtime PM settings in sdio_bus_probe() */ |
232 | if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) |
233 | pm_runtime_put_sync(dev); |
234 | |
235 | dev_pm_domain_detach(dev, power_off: false); |
236 | } |
237 | |
238 | static const struct dev_pm_ops sdio_bus_pm_ops = { |
239 | SET_SYSTEM_SLEEP_PM_OPS(pm_generic_suspend, pm_generic_resume) |
240 | SET_RUNTIME_PM_OPS( |
241 | pm_generic_runtime_suspend, |
242 | pm_generic_runtime_resume, |
243 | NULL |
244 | ) |
245 | }; |
246 | |
247 | static struct bus_type sdio_bus_type = { |
248 | .name = "sdio" , |
249 | .dev_groups = sdio_dev_groups, |
250 | .match = sdio_bus_match, |
251 | .uevent = sdio_bus_uevent, |
252 | .probe = sdio_bus_probe, |
253 | .remove = sdio_bus_remove, |
254 | .pm = &sdio_bus_pm_ops, |
255 | }; |
256 | |
257 | int sdio_register_bus(void) |
258 | { |
259 | return bus_register(bus: &sdio_bus_type); |
260 | } |
261 | |
262 | void sdio_unregister_bus(void) |
263 | { |
264 | bus_unregister(bus: &sdio_bus_type); |
265 | } |
266 | |
267 | /** |
268 | * sdio_register_driver - register a function driver |
269 | * @drv: SDIO function driver |
270 | */ |
271 | int sdio_register_driver(struct sdio_driver *drv) |
272 | { |
273 | drv->drv.name = drv->name; |
274 | drv->drv.bus = &sdio_bus_type; |
275 | return driver_register(drv: &drv->drv); |
276 | } |
277 | EXPORT_SYMBOL_GPL(sdio_register_driver); |
278 | |
279 | /** |
280 | * sdio_unregister_driver - unregister a function driver |
281 | * @drv: SDIO function driver |
282 | */ |
283 | void sdio_unregister_driver(struct sdio_driver *drv) |
284 | { |
285 | drv->drv.bus = &sdio_bus_type; |
286 | driver_unregister(drv: &drv->drv); |
287 | } |
288 | EXPORT_SYMBOL_GPL(sdio_unregister_driver); |
289 | |
290 | static void sdio_release_func(struct device *dev) |
291 | { |
292 | struct sdio_func *func = dev_to_sdio_func(dev); |
293 | |
294 | if (!(func->card->quirks & MMC_QUIRK_NONSTD_SDIO)) |
295 | sdio_free_func_cis(func); |
296 | |
297 | /* |
298 | * We have now removed the link to the tuples in the |
299 | * card structure, so remove the reference. |
300 | */ |
301 | put_device(dev: &func->card->dev); |
302 | |
303 | kfree(objp: func->info); |
304 | kfree(objp: func->tmpbuf); |
305 | kfree(objp: func); |
306 | } |
307 | |
308 | /* |
309 | * Allocate and initialise a new SDIO function structure. |
310 | */ |
311 | struct sdio_func *sdio_alloc_func(struct mmc_card *card) |
312 | { |
313 | struct sdio_func *func; |
314 | |
315 | func = kzalloc(size: sizeof(struct sdio_func), GFP_KERNEL); |
316 | if (!func) |
317 | return ERR_PTR(error: -ENOMEM); |
318 | |
319 | /* |
320 | * allocate buffer separately to make sure it's properly aligned for |
321 | * DMA usage (incl. 64 bit DMA) |
322 | */ |
323 | func->tmpbuf = kmalloc(size: 4, GFP_KERNEL); |
324 | if (!func->tmpbuf) { |
325 | kfree(objp: func); |
326 | return ERR_PTR(error: -ENOMEM); |
327 | } |
328 | |
329 | func->card = card; |
330 | |
331 | device_initialize(dev: &func->dev); |
332 | |
333 | /* |
334 | * We may link to tuples in the card structure, |
335 | * we need make sure we have a reference to it. |
336 | */ |
337 | get_device(dev: &func->card->dev); |
338 | |
339 | func->dev.parent = &card->dev; |
340 | func->dev.bus = &sdio_bus_type; |
341 | func->dev.release = sdio_release_func; |
342 | |
343 | return func; |
344 | } |
345 | |
346 | #ifdef CONFIG_ACPI |
347 | static void sdio_acpi_set_handle(struct sdio_func *func) |
348 | { |
349 | struct mmc_host *host = func->card->host; |
350 | u64 addr = ((u64)host->slotno << 16) | func->num; |
351 | |
352 | acpi_preset_companion(dev: &func->dev, ACPI_COMPANION(host->parent), addr); |
353 | } |
354 | #else |
355 | static inline void sdio_acpi_set_handle(struct sdio_func *func) {} |
356 | #endif |
357 | |
358 | static void sdio_set_of_node(struct sdio_func *func) |
359 | { |
360 | struct mmc_host *host = func->card->host; |
361 | |
362 | func->dev.of_node = mmc_of_find_child_device(host, func_num: func->num); |
363 | } |
364 | |
365 | /* |
366 | * Register a new SDIO function with the driver model. |
367 | */ |
368 | int sdio_add_func(struct sdio_func *func) |
369 | { |
370 | int ret; |
371 | |
372 | dev_set_name(dev: &func->dev, name: "%s:%d" , mmc_card_id(func->card), func->num); |
373 | |
374 | sdio_set_of_node(func); |
375 | sdio_acpi_set_handle(func); |
376 | device_enable_async_suspend(dev: &func->dev); |
377 | ret = device_add(dev: &func->dev); |
378 | if (ret == 0) |
379 | sdio_func_set_present(func); |
380 | |
381 | return ret; |
382 | } |
383 | |
384 | /* |
385 | * Unregister a SDIO function with the driver model, and |
386 | * (eventually) free it. |
387 | * This function can be called through error paths where sdio_add_func() was |
388 | * never executed (because a failure occurred at an earlier point). |
389 | */ |
390 | void sdio_remove_func(struct sdio_func *func) |
391 | { |
392 | if (sdio_func_present(func)) |
393 | device_del(dev: &func->dev); |
394 | |
395 | of_node_put(node: func->dev.of_node); |
396 | put_device(dev: &func->dev); |
397 | } |
398 | |
399 | |