Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * linux/drivers/mmc/core/bus.c
4 : : *
5 : : * Copyright (C) 2003 Russell King, All Rights Reserved.
6 : : * Copyright (C) 2007 Pierre Ossman
7 : : *
8 : : * MMC card bus driver model
9 : : */
10 : :
11 : : #include <linux/export.h>
12 : : #include <linux/device.h>
13 : : #include <linux/err.h>
14 : : #include <linux/slab.h>
15 : : #include <linux/stat.h>
16 : : #include <linux/of.h>
17 : : #include <linux/pm_runtime.h>
18 : :
19 : : #include <linux/mmc/card.h>
20 : : #include <linux/mmc/host.h>
21 : :
22 : : #include "core.h"
23 : : #include "card.h"
24 : : #include "host.h"
25 : : #include "sdio_cis.h"
26 : : #include "bus.h"
27 : :
28 : : #define to_mmc_driver(d) container_of(d, struct mmc_driver, drv)
29 : :
30 : 0 : static ssize_t type_show(struct device *dev,
31 : : struct device_attribute *attr, char *buf)
32 : : {
33 : : struct mmc_card *card = mmc_dev_to_card(dev);
34 : :
35 [ # # # # : 0 : switch (card->type) {
# ]
36 : : case MMC_TYPE_MMC:
37 : 0 : return sprintf(buf, "MMC\n");
38 : : case MMC_TYPE_SD:
39 : 0 : return sprintf(buf, "SD\n");
40 : : case MMC_TYPE_SDIO:
41 : 0 : return sprintf(buf, "SDIO\n");
42 : : case MMC_TYPE_SD_COMBO:
43 : 0 : return sprintf(buf, "SDcombo\n");
44 : : default:
45 : : return -EFAULT;
46 : : }
47 : : }
48 : : static DEVICE_ATTR_RO(type);
49 : :
50 : : static struct attribute *mmc_dev_attrs[] = {
51 : : &dev_attr_type.attr,
52 : : NULL,
53 : : };
54 : : ATTRIBUTE_GROUPS(mmc_dev);
55 : :
56 : : /*
57 : : * This currently matches any MMC driver to any MMC card - drivers
58 : : * themselves make the decision whether to drive this card in their
59 : : * probe method.
60 : : */
61 : 404 : static int mmc_bus_match(struct device *dev, struct device_driver *drv)
62 : : {
63 : 404 : return 1;
64 : : }
65 : :
66 : : static int
67 : 2426 : mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
68 : : {
69 : : struct mmc_card *card = mmc_dev_to_card(dev);
70 : : const char *type;
71 : : int retval = 0;
72 : :
73 [ - + ]: 2426 : switch (card->type) {
74 : : case MMC_TYPE_MMC:
75 : : type = "MMC";
76 : : break;
77 : : case MMC_TYPE_SD:
78 : : type = "SD";
79 : : break;
80 : : case MMC_TYPE_SDIO:
81 : : type = "SDIO";
82 : : break;
83 : : case MMC_TYPE_SD_COMBO:
84 : : type = "SDcombo";
85 : : break;
86 : : default:
87 : : type = NULL;
88 : : }
89 : :
90 [ + - ]: 2426 : if (type) {
91 : 2426 : retval = add_uevent_var(env, "MMC_TYPE=%s", type);
92 [ + - ]: 2426 : if (retval)
93 : : return retval;
94 : : }
95 : :
96 : 2426 : retval = add_uevent_var(env, "MMC_NAME=%s", mmc_card_name(card));
97 [ + - ]: 2426 : if (retval)
98 : : return retval;
99 : :
100 : : /*
101 : : * Request the mmc_block device. Note: that this is a direct request
102 : : * for the module it carries no information as to what is inserted.
103 : : */
104 : 2426 : retval = add_uevent_var(env, "MODALIAS=mmc:block");
105 : :
106 : 2426 : return retval;
107 : : }
108 : :
109 : 404 : static int mmc_bus_probe(struct device *dev)
110 : : {
111 : 404 : struct mmc_driver *drv = to_mmc_driver(dev->driver);
112 : 404 : struct mmc_card *card = mmc_dev_to_card(dev);
113 : :
114 : 404 : return drv->probe(card);
115 : : }
116 : :
117 : 0 : static int mmc_bus_remove(struct device *dev)
118 : : {
119 : 0 : struct mmc_driver *drv = to_mmc_driver(dev->driver);
120 : 0 : struct mmc_card *card = mmc_dev_to_card(dev);
121 : :
122 : 0 : drv->remove(card);
123 : :
124 : 0 : return 0;
125 : : }
126 : :
127 : 0 : static void mmc_bus_shutdown(struct device *dev)
128 : : {
129 : 0 : struct mmc_driver *drv = to_mmc_driver(dev->driver);
130 : 0 : struct mmc_card *card = mmc_dev_to_card(dev);
131 : 0 : struct mmc_host *host = card->host;
132 : : int ret;
133 : :
134 [ # # # # ]: 0 : if (dev->driver && drv->shutdown)
135 : 0 : drv->shutdown(card);
136 : :
137 [ # # ]: 0 : if (host->bus_ops->shutdown) {
138 : 0 : ret = host->bus_ops->shutdown(host);
139 [ # # ]: 0 : if (ret)
140 : 0 : pr_warn("%s: error %d during shutdown\n",
141 : : mmc_hostname(host), ret);
142 : : }
143 : 0 : }
144 : :
145 : : #ifdef CONFIG_PM_SLEEP
146 : : static int mmc_bus_suspend(struct device *dev)
147 : : {
148 : : struct mmc_card *card = mmc_dev_to_card(dev);
149 : : struct mmc_host *host = card->host;
150 : : int ret;
151 : :
152 : : ret = pm_generic_suspend(dev);
153 : : if (ret)
154 : : return ret;
155 : :
156 : : ret = host->bus_ops->suspend(host);
157 : : if (ret)
158 : : pm_generic_resume(dev);
159 : :
160 : : return ret;
161 : : }
162 : :
163 : : static int mmc_bus_resume(struct device *dev)
164 : : {
165 : : struct mmc_card *card = mmc_dev_to_card(dev);
166 : : struct mmc_host *host = card->host;
167 : : int ret;
168 : :
169 : : ret = host->bus_ops->resume(host);
170 : : if (ret)
171 : : pr_warn("%s: error %d during resume (card was removed?)\n",
172 : : mmc_hostname(host), ret);
173 : :
174 : : ret = pm_generic_resume(dev);
175 : : return ret;
176 : : }
177 : : #endif
178 : :
179 : : #ifdef CONFIG_PM
180 : 22 : static int mmc_runtime_suspend(struct device *dev)
181 : : {
182 : : struct mmc_card *card = mmc_dev_to_card(dev);
183 : 22 : struct mmc_host *host = card->host;
184 : :
185 : 22 : return host->bus_ops->runtime_suspend(host);
186 : : }
187 : :
188 : 22 : static int mmc_runtime_resume(struct device *dev)
189 : : {
190 : : struct mmc_card *card = mmc_dev_to_card(dev);
191 : 22 : struct mmc_host *host = card->host;
192 : :
193 : 22 : return host->bus_ops->runtime_resume(host);
194 : : }
195 : : #endif /* !CONFIG_PM */
196 : :
197 : : static const struct dev_pm_ops mmc_bus_pm_ops = {
198 : : SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume, NULL)
199 : : SET_SYSTEM_SLEEP_PM_OPS(mmc_bus_suspend, mmc_bus_resume)
200 : : };
201 : :
202 : : static struct bus_type mmc_bus_type = {
203 : : .name = "mmc",
204 : : .dev_groups = mmc_dev_groups,
205 : : .match = mmc_bus_match,
206 : : .uevent = mmc_bus_uevent,
207 : : .probe = mmc_bus_probe,
208 : : .remove = mmc_bus_remove,
209 : : .shutdown = mmc_bus_shutdown,
210 : : .pm = &mmc_bus_pm_ops,
211 : : };
212 : :
213 : 404 : int mmc_register_bus(void)
214 : : {
215 : 404 : return bus_register(&mmc_bus_type);
216 : : }
217 : :
218 : 0 : void mmc_unregister_bus(void)
219 : : {
220 : 0 : bus_unregister(&mmc_bus_type);
221 : 0 : }
222 : :
223 : : /**
224 : : * mmc_register_driver - register a media driver
225 : : * @drv: MMC media driver
226 : : */
227 : 404 : int mmc_register_driver(struct mmc_driver *drv)
228 : : {
229 : 404 : drv->drv.bus = &mmc_bus_type;
230 : 404 : return driver_register(&drv->drv);
231 : : }
232 : :
233 : : EXPORT_SYMBOL(mmc_register_driver);
234 : :
235 : : /**
236 : : * mmc_unregister_driver - unregister a media driver
237 : : * @drv: MMC media driver
238 : : */
239 : 0 : void mmc_unregister_driver(struct mmc_driver *drv)
240 : : {
241 : 0 : drv->drv.bus = &mmc_bus_type;
242 : 0 : driver_unregister(&drv->drv);
243 : 0 : }
244 : :
245 : : EXPORT_SYMBOL(mmc_unregister_driver);
246 : :
247 : 0 : static void mmc_release_card(struct device *dev)
248 : : {
249 : 0 : struct mmc_card *card = mmc_dev_to_card(dev);
250 : :
251 : 0 : sdio_free_common_cis(card);
252 : :
253 : 0 : kfree(card->info);
254 : :
255 : 0 : kfree(card);
256 : 0 : }
257 : :
258 : : /*
259 : : * Allocate and initialise a new MMC card structure.
260 : : */
261 : 404 : struct mmc_card *mmc_alloc_card(struct mmc_host *host, struct device_type *type)
262 : : {
263 : : struct mmc_card *card;
264 : :
265 : 404 : card = kzalloc(sizeof(struct mmc_card), GFP_KERNEL);
266 [ + - ]: 404 : if (!card)
267 : : return ERR_PTR(-ENOMEM);
268 : :
269 : 404 : card->host = host;
270 : :
271 : 404 : device_initialize(&card->dev);
272 : :
273 : 404 : card->dev.parent = mmc_classdev(host);
274 : 404 : card->dev.bus = &mmc_bus_type;
275 : 404 : card->dev.release = mmc_release_card;
276 : 404 : card->dev.type = type;
277 : :
278 : 404 : return card;
279 : : }
280 : :
281 : : /*
282 : : * Register a new MMC card with the driver model.
283 : : */
284 : 404 : int mmc_add_card(struct mmc_card *card)
285 : : {
286 : : int ret;
287 : : const char *type;
288 : : const char *uhs_bus_speed_mode = "";
289 : : static const char *const uhs_speeds[] = {
290 : : [UHS_SDR12_BUS_SPEED] = "SDR12 ",
291 : : [UHS_SDR25_BUS_SPEED] = "SDR25 ",
292 : : [UHS_SDR50_BUS_SPEED] = "SDR50 ",
293 : : [UHS_SDR104_BUS_SPEED] = "SDR104 ",
294 : : [UHS_DDR50_BUS_SPEED] = "DDR50 ",
295 : : };
296 : :
297 : :
298 : 808 : dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca);
299 : :
300 [ + - - - : 404 : switch (card->type) {
- ]
301 : : case MMC_TYPE_MMC:
302 : : type = "MMC";
303 : : break;
304 : : case MMC_TYPE_SD:
305 : : type = "SD";
306 [ + - ]: 404 : if (mmc_card_blockaddr(card)) {
307 [ + - ]: 404 : if (mmc_card_ext_capacity(card))
308 : : type = "SDXC";
309 : : else
310 : : type = "SDHC";
311 : : }
312 : : break;
313 : : case MMC_TYPE_SDIO:
314 : : type = "SDIO";
315 : 0 : break;
316 : : case MMC_TYPE_SD_COMBO:
317 : : type = "SD-combo";
318 [ # # ]: 0 : if (mmc_card_blockaddr(card))
319 : : type = "SDHC-combo";
320 : : break;
321 : : default:
322 : : type = "?";
323 : 0 : break;
324 : : }
325 : :
326 [ - + # # ]: 404 : if (mmc_card_uhs(card) &&
327 : 0 : (card->sd_bus_speed < ARRAY_SIZE(uhs_speeds)))
328 : 0 : uhs_bus_speed_mode = uhs_speeds[card->sd_bus_speed];
329 : :
330 [ - + ]: 404 : if (mmc_host_is_spi(card->host)) {
331 [ # # # # ]: 0 : pr_info("%s: new %s%s%s card on SPI\n",
332 : : mmc_hostname(card->host),
333 : : mmc_card_hs(card) ? "high speed " : "",
334 : : mmc_card_ddr52(card) ? "DDR " : "",
335 : : type);
336 : : } else {
337 [ + - + + : 1212 : pr_info("%s: new %s%s%s%s%s%s card at address %04x\n",
+ - + - +
- + - ]
338 : : mmc_hostname(card->host),
339 : : mmc_card_uhs(card) ? "ultra high speed " :
340 : : (mmc_card_hs(card) ? "high speed " : ""),
341 : : mmc_card_hs400(card) ? "HS400 " :
342 : : (mmc_card_hs200(card) ? "HS200 " : ""),
343 : : mmc_card_hs400es(card) ? "Enhanced strobe " : "",
344 : : mmc_card_ddr52(card) ? "DDR " : "",
345 : : uhs_bus_speed_mode, type, card->rca);
346 : : }
347 : :
348 : : #ifdef CONFIG_DEBUG_FS
349 : 404 : mmc_add_card_debugfs(card);
350 : : #endif
351 : 404 : card->dev.of_node = mmc_of_find_child_device(card->host, 0);
352 : :
353 : : device_enable_async_suspend(&card->dev);
354 : :
355 : 404 : ret = device_add(&card->dev);
356 [ + - ]: 404 : if (ret)
357 : : return ret;
358 : :
359 : 404 : mmc_card_set_present(card);
360 : :
361 : 404 : return 0;
362 : : }
363 : :
364 : : /*
365 : : * Unregister a new MMC card with the driver model, and
366 : : * (eventually) free it.
367 : : */
368 : 0 : void mmc_remove_card(struct mmc_card *card)
369 : : {
370 : 0 : struct mmc_host *host = card->host;
371 : :
372 : : #ifdef CONFIG_DEBUG_FS
373 : 0 : mmc_remove_card_debugfs(card);
374 : : #endif
375 : :
376 [ # # ]: 0 : if (host->cqe_enabled) {
377 : 0 : host->cqe_ops->cqe_disable(host);
378 : 0 : host->cqe_enabled = false;
379 : : }
380 : :
381 [ # # ]: 0 : if (mmc_card_present(card)) {
382 [ # # ]: 0 : if (mmc_host_is_spi(card->host)) {
383 : 0 : pr_info("%s: SPI card removed\n",
384 : : mmc_hostname(card->host));
385 : : } else {
386 : 0 : pr_info("%s: card %04x removed\n",
387 : : mmc_hostname(card->host), card->rca);
388 : : }
389 : 0 : device_del(&card->dev);
390 : 0 : of_node_put(card->dev.of_node);
391 : : }
392 : :
393 : 0 : put_device(&card->dev);
394 : 0 : }
395 : :
|
