1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * linux/drivers/mmc/sdio.c |
4 | * |
5 | * Copyright 2006-2007 Pierre Ossman |
6 | */ |
7 | |
8 | #include <linux/err.h> |
9 | #include <linux/pm_runtime.h> |
10 | #include <linux/sysfs.h> |
11 | |
12 | #include <linux/mmc/host.h> |
13 | #include <linux/mmc/card.h> |
14 | #include <linux/mmc/mmc.h> |
15 | #include <linux/mmc/sdio.h> |
16 | #include <linux/mmc/sdio_func.h> |
17 | #include <linux/mmc/sdio_ids.h> |
18 | |
19 | #include "core.h" |
20 | #include "card.h" |
21 | #include "host.h" |
22 | #include "bus.h" |
23 | #include "quirks.h" |
24 | #include "sd.h" |
25 | #include "sdio_bus.h" |
26 | #include "mmc_ops.h" |
27 | #include "sd_ops.h" |
28 | #include "sdio_ops.h" |
29 | #include "sdio_cis.h" |
30 | |
31 | MMC_DEV_ATTR(vendor, "0x%04x\n" , card->cis.vendor); |
32 | MMC_DEV_ATTR(device, "0x%04x\n" , card->cis.device); |
33 | MMC_DEV_ATTR(revision, "%u.%u\n" , card->major_rev, card->minor_rev); |
34 | MMC_DEV_ATTR(ocr, "0x%08x\n" , card->ocr); |
35 | MMC_DEV_ATTR(rca, "0x%04x\n" , card->rca); |
36 | |
37 | #define sdio_info_attr(num) \ |
38 | static ssize_t info##num##_show(struct device *dev, struct device_attribute *attr, char *buf) \ |
39 | { \ |
40 | struct mmc_card *card = mmc_dev_to_card(dev); \ |
41 | \ |
42 | if (num > card->num_info) \ |
43 | return -ENODATA; \ |
44 | if (!card->info[num - 1][0]) \ |
45 | return 0; \ |
46 | return sysfs_emit(buf, "%s\n", card->info[num - 1]); \ |
47 | } \ |
48 | static DEVICE_ATTR_RO(info##num) |
49 | |
50 | sdio_info_attr(1); |
51 | sdio_info_attr(2); |
52 | sdio_info_attr(3); |
53 | sdio_info_attr(4); |
54 | |
55 | static struct attribute *sdio_std_attrs[] = { |
56 | &dev_attr_vendor.attr, |
57 | &dev_attr_device.attr, |
58 | &dev_attr_revision.attr, |
59 | &dev_attr_info1.attr, |
60 | &dev_attr_info2.attr, |
61 | &dev_attr_info3.attr, |
62 | &dev_attr_info4.attr, |
63 | &dev_attr_ocr.attr, |
64 | &dev_attr_rca.attr, |
65 | NULL, |
66 | }; |
67 | ATTRIBUTE_GROUPS(sdio_std); |
68 | |
69 | static struct device_type sdio_type = { |
70 | .groups = sdio_std_groups, |
71 | }; |
72 | |
73 | static int sdio_read_fbr(struct sdio_func *func) |
74 | { |
75 | int ret; |
76 | unsigned char data; |
77 | |
78 | if (mmc_card_nonstd_func_interface(c: func->card)) { |
79 | func->class = SDIO_CLASS_NONE; |
80 | return 0; |
81 | } |
82 | |
83 | ret = mmc_io_rw_direct(card: func->card, write: 0, fn: 0, |
84 | SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF, in: 0, out: &data); |
85 | if (ret) |
86 | goto out; |
87 | |
88 | data &= 0x0f; |
89 | |
90 | if (data == 0x0f) { |
91 | ret = mmc_io_rw_direct(card: func->card, write: 0, fn: 0, |
92 | SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF_EXT, in: 0, out: &data); |
93 | if (ret) |
94 | goto out; |
95 | } |
96 | |
97 | func->class = data; |
98 | |
99 | out: |
100 | return ret; |
101 | } |
102 | |
103 | static int sdio_init_func(struct mmc_card *card, unsigned int fn) |
104 | { |
105 | int ret; |
106 | struct sdio_func *func; |
107 | |
108 | if (WARN_ON(fn > SDIO_MAX_FUNCS)) |
109 | return -EINVAL; |
110 | |
111 | func = sdio_alloc_func(card); |
112 | if (IS_ERR(ptr: func)) |
113 | return PTR_ERR(ptr: func); |
114 | |
115 | func->num = fn; |
116 | |
117 | if (!(card->quirks & MMC_QUIRK_NONSTD_SDIO)) { |
118 | ret = sdio_read_fbr(func); |
119 | if (ret) |
120 | goto fail; |
121 | |
122 | ret = sdio_read_func_cis(func); |
123 | if (ret) |
124 | goto fail; |
125 | } else { |
126 | func->vendor = func->card->cis.vendor; |
127 | func->device = func->card->cis.device; |
128 | func->max_blksize = func->card->cis.blksize; |
129 | } |
130 | |
131 | card->sdio_func[fn - 1] = func; |
132 | |
133 | return 0; |
134 | |
135 | fail: |
136 | /* |
137 | * It is okay to remove the function here even though we hold |
138 | * the host lock as we haven't registered the device yet. |
139 | */ |
140 | sdio_remove_func(func); |
141 | return ret; |
142 | } |
143 | |
144 | static int sdio_read_cccr(struct mmc_card *card, u32 ocr) |
145 | { |
146 | int ret; |
147 | int cccr_vsn; |
148 | int uhs = ocr & R4_18V_PRESENT; |
149 | unsigned char data; |
150 | unsigned char speed; |
151 | |
152 | ret = mmc_io_rw_direct(card, write: 0, fn: 0, SDIO_CCCR_CCCR, in: 0, out: &data); |
153 | if (ret) |
154 | goto out; |
155 | |
156 | cccr_vsn = data & 0x0f; |
157 | |
158 | if (cccr_vsn > SDIO_CCCR_REV_3_00) { |
159 | pr_err("%s: unrecognised CCCR structure version %d\n" , |
160 | mmc_hostname(card->host), cccr_vsn); |
161 | return -EINVAL; |
162 | } |
163 | |
164 | card->cccr.sdio_vsn = (data & 0xf0) >> 4; |
165 | |
166 | ret = mmc_io_rw_direct(card, write: 0, fn: 0, SDIO_CCCR_CAPS, in: 0, out: &data); |
167 | if (ret) |
168 | goto out; |
169 | |
170 | if (data & SDIO_CCCR_CAP_SMB) |
171 | card->cccr.multi_block = 1; |
172 | if (data & SDIO_CCCR_CAP_LSC) |
173 | card->cccr.low_speed = 1; |
174 | if (data & SDIO_CCCR_CAP_4BLS) |
175 | card->cccr.wide_bus = 1; |
176 | |
177 | if (cccr_vsn >= SDIO_CCCR_REV_1_10) { |
178 | ret = mmc_io_rw_direct(card, write: 0, fn: 0, SDIO_CCCR_POWER, in: 0, out: &data); |
179 | if (ret) |
180 | goto out; |
181 | |
182 | if (data & SDIO_POWER_SMPC) |
183 | card->cccr.high_power = 1; |
184 | } |
185 | |
186 | if (cccr_vsn >= SDIO_CCCR_REV_1_20) { |
187 | ret = mmc_io_rw_direct(card, write: 0, fn: 0, SDIO_CCCR_SPEED, in: 0, out: &speed); |
188 | if (ret) |
189 | goto out; |
190 | |
191 | card->scr.sda_spec3 = 0; |
192 | card->sw_caps.sd3_bus_mode = 0; |
193 | card->sw_caps.sd3_drv_type = 0; |
194 | if (cccr_vsn >= SDIO_CCCR_REV_3_00 && uhs) { |
195 | card->scr.sda_spec3 = 1; |
196 | ret = mmc_io_rw_direct(card, write: 0, fn: 0, |
197 | SDIO_CCCR_UHS, in: 0, out: &data); |
198 | if (ret) |
199 | goto out; |
200 | |
201 | if (mmc_host_uhs(host: card->host)) { |
202 | if (data & SDIO_UHS_DDR50) |
203 | card->sw_caps.sd3_bus_mode |
204 | |= SD_MODE_UHS_DDR50 | SD_MODE_UHS_SDR50 |
205 | | SD_MODE_UHS_SDR25 | SD_MODE_UHS_SDR12; |
206 | |
207 | if (data & SDIO_UHS_SDR50) |
208 | card->sw_caps.sd3_bus_mode |
209 | |= SD_MODE_UHS_SDR50 | SD_MODE_UHS_SDR25 |
210 | | SD_MODE_UHS_SDR12; |
211 | |
212 | if (data & SDIO_UHS_SDR104) |
213 | card->sw_caps.sd3_bus_mode |
214 | |= SD_MODE_UHS_SDR104 | SD_MODE_UHS_SDR50 |
215 | | SD_MODE_UHS_SDR25 | SD_MODE_UHS_SDR12; |
216 | } |
217 | |
218 | ret = mmc_io_rw_direct(card, write: 0, fn: 0, |
219 | SDIO_CCCR_DRIVE_STRENGTH, in: 0, out: &data); |
220 | if (ret) |
221 | goto out; |
222 | |
223 | if (data & SDIO_DRIVE_SDTA) |
224 | card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_A; |
225 | if (data & SDIO_DRIVE_SDTC) |
226 | card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_C; |
227 | if (data & SDIO_DRIVE_SDTD) |
228 | card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_D; |
229 | |
230 | ret = mmc_io_rw_direct(card, write: 0, fn: 0, SDIO_CCCR_INTERRUPT_EXT, in: 0, out: &data); |
231 | if (ret) |
232 | goto out; |
233 | |
234 | if (data & SDIO_INTERRUPT_EXT_SAI) { |
235 | data |= SDIO_INTERRUPT_EXT_EAI; |
236 | ret = mmc_io_rw_direct(card, write: 1, fn: 0, SDIO_CCCR_INTERRUPT_EXT, |
237 | in: data, NULL); |
238 | if (ret) |
239 | goto out; |
240 | |
241 | card->cccr.enable_async_irq = 1; |
242 | } |
243 | } |
244 | |
245 | /* if no uhs mode ensure we check for high speed */ |
246 | if (!card->sw_caps.sd3_bus_mode) { |
247 | if (speed & SDIO_SPEED_SHS) { |
248 | card->cccr.high_speed = 1; |
249 | card->sw_caps.hs_max_dtr = 50000000; |
250 | } else { |
251 | card->cccr.high_speed = 0; |
252 | card->sw_caps.hs_max_dtr = 25000000; |
253 | } |
254 | } |
255 | } |
256 | |
257 | out: |
258 | return ret; |
259 | } |
260 | |
261 | static int sdio_enable_wide(struct mmc_card *card) |
262 | { |
263 | int ret; |
264 | u8 ctrl; |
265 | |
266 | if (!(card->host->caps & MMC_CAP_4_BIT_DATA)) |
267 | return 0; |
268 | |
269 | if (card->cccr.low_speed && !card->cccr.wide_bus) |
270 | return 0; |
271 | |
272 | ret = mmc_io_rw_direct(card, write: 0, fn: 0, SDIO_CCCR_IF, in: 0, out: &ctrl); |
273 | if (ret) |
274 | return ret; |
275 | |
276 | if ((ctrl & SDIO_BUS_WIDTH_MASK) == SDIO_BUS_WIDTH_RESERVED) |
277 | pr_warn("%s: SDIO_CCCR_IF is invalid: 0x%02x\n" , |
278 | mmc_hostname(card->host), ctrl); |
279 | |
280 | /* set as 4-bit bus width */ |
281 | ctrl &= ~SDIO_BUS_WIDTH_MASK; |
282 | ctrl |= SDIO_BUS_WIDTH_4BIT; |
283 | |
284 | ret = mmc_io_rw_direct(card, write: 1, fn: 0, SDIO_CCCR_IF, in: ctrl, NULL); |
285 | if (ret) |
286 | return ret; |
287 | |
288 | return 1; |
289 | } |
290 | |
291 | /* |
292 | * If desired, disconnect the pull-up resistor on CD/DAT[3] (pin 1) |
293 | * of the card. This may be required on certain setups of boards, |
294 | * controllers and embedded sdio device which do not need the card's |
295 | * pull-up. As a result, card detection is disabled and power is saved. |
296 | */ |
297 | static int sdio_disable_cd(struct mmc_card *card) |
298 | { |
299 | int ret; |
300 | u8 ctrl; |
301 | |
302 | if (!mmc_card_disable_cd(c: card)) |
303 | return 0; |
304 | |
305 | ret = mmc_io_rw_direct(card, write: 0, fn: 0, SDIO_CCCR_IF, in: 0, out: &ctrl); |
306 | if (ret) |
307 | return ret; |
308 | |
309 | ctrl |= SDIO_BUS_CD_DISABLE; |
310 | |
311 | return mmc_io_rw_direct(card, write: 1, fn: 0, SDIO_CCCR_IF, in: ctrl, NULL); |
312 | } |
313 | |
314 | /* |
315 | * Devices that remain active during a system suspend are |
316 | * put back into 1-bit mode. |
317 | */ |
318 | static int sdio_disable_wide(struct mmc_card *card) |
319 | { |
320 | int ret; |
321 | u8 ctrl; |
322 | |
323 | if (!(card->host->caps & MMC_CAP_4_BIT_DATA)) |
324 | return 0; |
325 | |
326 | if (card->cccr.low_speed && !card->cccr.wide_bus) |
327 | return 0; |
328 | |
329 | ret = mmc_io_rw_direct(card, write: 0, fn: 0, SDIO_CCCR_IF, in: 0, out: &ctrl); |
330 | if (ret) |
331 | return ret; |
332 | |
333 | if (!(ctrl & SDIO_BUS_WIDTH_4BIT)) |
334 | return 0; |
335 | |
336 | ctrl &= ~SDIO_BUS_WIDTH_4BIT; |
337 | ctrl |= SDIO_BUS_ASYNC_INT; |
338 | |
339 | ret = mmc_io_rw_direct(card, write: 1, fn: 0, SDIO_CCCR_IF, in: ctrl, NULL); |
340 | if (ret) |
341 | return ret; |
342 | |
343 | mmc_set_bus_width(host: card->host, MMC_BUS_WIDTH_1); |
344 | |
345 | return 0; |
346 | } |
347 | |
348 | static int sdio_disable_4bit_bus(struct mmc_card *card) |
349 | { |
350 | int err; |
351 | |
352 | if (mmc_card_sdio(card)) |
353 | goto out; |
354 | |
355 | if (!(card->host->caps & MMC_CAP_4_BIT_DATA)) |
356 | return 0; |
357 | |
358 | if (!(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) |
359 | return 0; |
360 | |
361 | err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_1); |
362 | if (err) |
363 | return err; |
364 | |
365 | out: |
366 | return sdio_disable_wide(card); |
367 | } |
368 | |
369 | |
370 | static int sdio_enable_4bit_bus(struct mmc_card *card) |
371 | { |
372 | int err; |
373 | |
374 | err = sdio_enable_wide(card); |
375 | if (err <= 0) |
376 | return err; |
377 | if (mmc_card_sdio(card)) |
378 | goto out; |
379 | |
380 | if (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4) { |
381 | err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4); |
382 | if (err) { |
383 | sdio_disable_wide(card); |
384 | return err; |
385 | } |
386 | } |
387 | out: |
388 | mmc_set_bus_width(host: card->host, MMC_BUS_WIDTH_4); |
389 | |
390 | return 0; |
391 | } |
392 | |
393 | |
394 | /* |
395 | * Test if the card supports high-speed mode and, if so, switch to it. |
396 | */ |
397 | static int mmc_sdio_switch_hs(struct mmc_card *card, int enable) |
398 | { |
399 | int ret; |
400 | u8 speed; |
401 | |
402 | if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED)) |
403 | return 0; |
404 | |
405 | if (!card->cccr.high_speed) |
406 | return 0; |
407 | |
408 | ret = mmc_io_rw_direct(card, write: 0, fn: 0, SDIO_CCCR_SPEED, in: 0, out: &speed); |
409 | if (ret) |
410 | return ret; |
411 | |
412 | if (enable) |
413 | speed |= SDIO_SPEED_EHS; |
414 | else |
415 | speed &= ~SDIO_SPEED_EHS; |
416 | |
417 | ret = mmc_io_rw_direct(card, write: 1, fn: 0, SDIO_CCCR_SPEED, in: speed, NULL); |
418 | if (ret) |
419 | return ret; |
420 | |
421 | return 1; |
422 | } |
423 | |
424 | /* |
425 | * Enable SDIO/combo card's high-speed mode. Return 0/1 if [not]supported. |
426 | */ |
427 | static int sdio_enable_hs(struct mmc_card *card) |
428 | { |
429 | int ret; |
430 | |
431 | ret = mmc_sdio_switch_hs(card, enable: true); |
432 | if (ret <= 0 || mmc_card_sdio(card)) |
433 | return ret; |
434 | |
435 | ret = mmc_sd_switch_hs(card); |
436 | if (ret <= 0) |
437 | mmc_sdio_switch_hs(card, enable: false); |
438 | |
439 | return ret; |
440 | } |
441 | |
442 | static unsigned mmc_sdio_get_max_clock(struct mmc_card *card) |
443 | { |
444 | unsigned max_dtr; |
445 | |
446 | if (mmc_card_hs(card)) { |
447 | /* |
448 | * The SDIO specification doesn't mention how |
449 | * the CIS transfer speed register relates to |
450 | * high-speed, but it seems that 50 MHz is |
451 | * mandatory. |
452 | */ |
453 | max_dtr = 50000000; |
454 | } else { |
455 | max_dtr = card->cis.max_dtr; |
456 | } |
457 | |
458 | if (mmc_card_sd_combo(card)) |
459 | max_dtr = min(max_dtr, mmc_sd_get_max_clock(card)); |
460 | |
461 | return max_dtr; |
462 | } |
463 | |
464 | static unsigned char host_drive_to_sdio_drive(int host_strength) |
465 | { |
466 | switch (host_strength) { |
467 | case MMC_SET_DRIVER_TYPE_A: |
468 | return SDIO_DTSx_SET_TYPE_A; |
469 | case MMC_SET_DRIVER_TYPE_B: |
470 | return SDIO_DTSx_SET_TYPE_B; |
471 | case MMC_SET_DRIVER_TYPE_C: |
472 | return SDIO_DTSx_SET_TYPE_C; |
473 | case MMC_SET_DRIVER_TYPE_D: |
474 | return SDIO_DTSx_SET_TYPE_D; |
475 | default: |
476 | return SDIO_DTSx_SET_TYPE_B; |
477 | } |
478 | } |
479 | |
480 | static void sdio_select_driver_type(struct mmc_card *card) |
481 | { |
482 | int card_drv_type, drive_strength, drv_type; |
483 | unsigned char card_strength; |
484 | int err; |
485 | |
486 | card->drive_strength = 0; |
487 | |
488 | card_drv_type = card->sw_caps.sd3_drv_type | SD_DRIVER_TYPE_B; |
489 | |
490 | drive_strength = mmc_select_drive_strength(card, |
491 | max_dtr: card->sw_caps.uhs_max_dtr, |
492 | card_drv_type, drv_type: &drv_type); |
493 | |
494 | if (drive_strength) { |
495 | /* if error just use default for drive strength B */ |
496 | err = mmc_io_rw_direct(card, write: 0, fn: 0, SDIO_CCCR_DRIVE_STRENGTH, in: 0, |
497 | out: &card_strength); |
498 | if (err) |
499 | return; |
500 | |
501 | card_strength &= ~(SDIO_DRIVE_DTSx_MASK<<SDIO_DRIVE_DTSx_SHIFT); |
502 | card_strength |= host_drive_to_sdio_drive(host_strength: drive_strength); |
503 | |
504 | /* if error default to drive strength B */ |
505 | err = mmc_io_rw_direct(card, write: 1, fn: 0, SDIO_CCCR_DRIVE_STRENGTH, |
506 | in: card_strength, NULL); |
507 | if (err) |
508 | return; |
509 | card->drive_strength = drive_strength; |
510 | } |
511 | |
512 | if (drv_type) |
513 | mmc_set_driver_type(host: card->host, drv_type); |
514 | } |
515 | |
516 | |
517 | static int sdio_set_bus_speed_mode(struct mmc_card *card) |
518 | { |
519 | unsigned int bus_speed, timing; |
520 | int err; |
521 | unsigned char speed; |
522 | unsigned int max_rate; |
523 | |
524 | /* |
525 | * If the host doesn't support any of the UHS-I modes, fallback on |
526 | * default speed. |
527 | */ |
528 | if (!mmc_host_uhs(host: card->host)) |
529 | return 0; |
530 | |
531 | bus_speed = SDIO_SPEED_SDR12; |
532 | timing = MMC_TIMING_UHS_SDR12; |
533 | if ((card->host->caps & MMC_CAP_UHS_SDR104) && |
534 | (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) { |
535 | bus_speed = SDIO_SPEED_SDR104; |
536 | timing = MMC_TIMING_UHS_SDR104; |
537 | card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR; |
538 | card->sd_bus_speed = UHS_SDR104_BUS_SPEED; |
539 | } else if ((card->host->caps & MMC_CAP_UHS_DDR50) && |
540 | (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) { |
541 | bus_speed = SDIO_SPEED_DDR50; |
542 | timing = MMC_TIMING_UHS_DDR50; |
543 | card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR; |
544 | card->sd_bus_speed = UHS_DDR50_BUS_SPEED; |
545 | } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | |
546 | MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode & |
547 | SD_MODE_UHS_SDR50)) { |
548 | bus_speed = SDIO_SPEED_SDR50; |
549 | timing = MMC_TIMING_UHS_SDR50; |
550 | card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR; |
551 | card->sd_bus_speed = UHS_SDR50_BUS_SPEED; |
552 | } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | |
553 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) && |
554 | (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) { |
555 | bus_speed = SDIO_SPEED_SDR25; |
556 | timing = MMC_TIMING_UHS_SDR25; |
557 | card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR; |
558 | card->sd_bus_speed = UHS_SDR25_BUS_SPEED; |
559 | } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | |
560 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 | |
561 | MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode & |
562 | SD_MODE_UHS_SDR12)) { |
563 | bus_speed = SDIO_SPEED_SDR12; |
564 | timing = MMC_TIMING_UHS_SDR12; |
565 | card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR; |
566 | card->sd_bus_speed = UHS_SDR12_BUS_SPEED; |
567 | } |
568 | |
569 | err = mmc_io_rw_direct(card, write: 0, fn: 0, SDIO_CCCR_SPEED, in: 0, out: &speed); |
570 | if (err) |
571 | return err; |
572 | |
573 | speed &= ~SDIO_SPEED_BSS_MASK; |
574 | speed |= bus_speed; |
575 | err = mmc_io_rw_direct(card, write: 1, fn: 0, SDIO_CCCR_SPEED, in: speed, NULL); |
576 | if (err) |
577 | return err; |
578 | |
579 | max_rate = min_not_zero(card->quirk_max_rate, |
580 | card->sw_caps.uhs_max_dtr); |
581 | |
582 | mmc_set_timing(host: card->host, timing); |
583 | mmc_set_clock(host: card->host, hz: max_rate); |
584 | |
585 | return 0; |
586 | } |
587 | |
588 | /* |
589 | * UHS-I specific initialization procedure |
590 | */ |
591 | static int mmc_sdio_init_uhs_card(struct mmc_card *card) |
592 | { |
593 | int err; |
594 | |
595 | if (!card->scr.sda_spec3) |
596 | return 0; |
597 | |
598 | /* Switch to wider bus */ |
599 | err = sdio_enable_4bit_bus(card); |
600 | if (err) |
601 | goto out; |
602 | |
603 | /* Set the driver strength for the card */ |
604 | sdio_select_driver_type(card); |
605 | |
606 | /* Set bus speed mode of the card */ |
607 | err = sdio_set_bus_speed_mode(card); |
608 | if (err) |
609 | goto out; |
610 | |
611 | /* |
612 | * SPI mode doesn't define CMD19 and tuning is only valid for SDR50 and |
613 | * SDR104 mode SD-cards. Note that tuning is mandatory for SDR104. |
614 | */ |
615 | if (!mmc_host_is_spi(card->host) && |
616 | ((card->host->ios.timing == MMC_TIMING_UHS_SDR50) || |
617 | (card->host->ios.timing == MMC_TIMING_UHS_SDR104))) |
618 | err = mmc_execute_tuning(card); |
619 | out: |
620 | return err; |
621 | } |
622 | |
623 | static int mmc_sdio_pre_init(struct mmc_host *host, u32 ocr, |
624 | struct mmc_card *card) |
625 | { |
626 | if (card) |
627 | mmc_remove_card(card); |
628 | |
629 | /* |
630 | * Reset the card by performing the same steps that are taken by |
631 | * mmc_rescan_try_freq() and mmc_attach_sdio() during a "normal" probe. |
632 | * |
633 | * sdio_reset() is technically not needed. Having just powered up the |
634 | * hardware, it should already be in reset state. However, some |
635 | * platforms (such as SD8686 on OLPC) do not instantly cut power, |
636 | * meaning that a reset is required when restoring power soon after |
637 | * powering off. It is harmless in other cases. |
638 | * |
639 | * The CMD5 reset (mmc_send_io_op_cond()), according to the SDIO spec, |
640 | * is not necessary for non-removable cards. However, it is required |
641 | * for OLPC SD8686 (which expects a [CMD5,5,3,7] init sequence), and |
642 | * harmless in other situations. |
643 | * |
644 | */ |
645 | |
646 | sdio_reset(host); |
647 | mmc_go_idle(host); |
648 | mmc_send_if_cond(host, ocr); |
649 | return mmc_send_io_op_cond(host, ocr: 0, NULL); |
650 | } |
651 | |
652 | /* |
653 | * Handle the detection and initialisation of a card. |
654 | * |
655 | * In the case of a resume, "oldcard" will contain the card |
656 | * we're trying to reinitialise. |
657 | */ |
658 | static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr, |
659 | struct mmc_card *oldcard) |
660 | { |
661 | struct mmc_card *card; |
662 | int err; |
663 | int retries = 10; |
664 | u32 rocr = 0; |
665 | u32 ocr_card = ocr; |
666 | |
667 | WARN_ON(!host->claimed); |
668 | |
669 | /* to query card if 1.8V signalling is supported */ |
670 | if (mmc_host_uhs(host)) |
671 | ocr |= R4_18V_PRESENT; |
672 | |
673 | try_again: |
674 | if (!retries) { |
675 | pr_warn("%s: Skipping voltage switch\n" , mmc_hostname(host)); |
676 | ocr &= ~R4_18V_PRESENT; |
677 | } |
678 | |
679 | /* |
680 | * Inform the card of the voltage |
681 | */ |
682 | err = mmc_send_io_op_cond(host, ocr, rocr: &rocr); |
683 | if (err) |
684 | return err; |
685 | |
686 | /* |
687 | * For SPI, enable CRC as appropriate. |
688 | */ |
689 | if (mmc_host_is_spi(host)) { |
690 | err = mmc_spi_set_crc(host, use_crc: use_spi_crc); |
691 | if (err) |
692 | return err; |
693 | } |
694 | |
695 | /* |
696 | * Allocate card structure. |
697 | */ |
698 | card = mmc_alloc_card(host, type: &sdio_type); |
699 | if (IS_ERR(ptr: card)) |
700 | return PTR_ERR(ptr: card); |
701 | |
702 | if ((rocr & R4_MEMORY_PRESENT) && |
703 | mmc_sd_get_cid(host, ocr: ocr & rocr, cid: card->raw_cid, NULL) == 0) { |
704 | card->type = MMC_TYPE_SD_COMBO; |
705 | |
706 | if (oldcard && (!mmc_card_sd_combo(oldcard) || |
707 | memcmp(p: card->raw_cid, q: oldcard->raw_cid, size: sizeof(card->raw_cid)) != 0)) { |
708 | err = -ENOENT; |
709 | goto mismatch; |
710 | } |
711 | } else { |
712 | card->type = MMC_TYPE_SDIO; |
713 | |
714 | if (oldcard && !mmc_card_sdio(oldcard)) { |
715 | err = -ENOENT; |
716 | goto mismatch; |
717 | } |
718 | } |
719 | |
720 | /* |
721 | * Call the optional HC's init_card function to handle quirks. |
722 | */ |
723 | if (host->ops->init_card) |
724 | host->ops->init_card(host, card); |
725 | mmc_fixup_device(card, table: sdio_card_init_methods); |
726 | |
727 | card->ocr = ocr_card; |
728 | |
729 | /* |
730 | * If the host and card support UHS-I mode request the card |
731 | * to switch to 1.8V signaling level. No 1.8v signalling if |
732 | * UHS mode is not enabled to maintain compatibility and some |
733 | * systems that claim 1.8v signalling in fact do not support |
734 | * it. Per SDIO spec v3, section 3.1.2, if the voltage is already |
735 | * 1.8v, the card sets S18A to 0 in the R4 response. So it will |
736 | * fails to check rocr & R4_18V_PRESENT, but we still need to |
737 | * try to init uhs card. sdio_read_cccr will take over this task |
738 | * to make sure which speed mode should work. |
739 | */ |
740 | if (rocr & ocr & R4_18V_PRESENT) { |
741 | err = mmc_set_uhs_voltage(host, ocr: ocr_card); |
742 | if (err == -EAGAIN) { |
743 | mmc_sdio_pre_init(host, ocr: ocr_card, card); |
744 | retries--; |
745 | goto try_again; |
746 | } else if (err) { |
747 | ocr &= ~R4_18V_PRESENT; |
748 | } |
749 | } |
750 | |
751 | /* |
752 | * For native busses: set card RCA and quit open drain mode. |
753 | */ |
754 | if (!mmc_host_is_spi(host)) { |
755 | err = mmc_send_relative_addr(host, rca: &card->rca); |
756 | if (err) |
757 | goto remove; |
758 | |
759 | /* |
760 | * Update oldcard with the new RCA received from the SDIO |
761 | * device -- we're doing this so that it's updated in the |
762 | * "card" struct when oldcard overwrites that later. |
763 | */ |
764 | if (oldcard) |
765 | oldcard->rca = card->rca; |
766 | } |
767 | |
768 | /* |
769 | * Read CSD, before selecting the card |
770 | */ |
771 | if (!oldcard && mmc_card_sd_combo(card)) { |
772 | err = mmc_sd_get_csd(card); |
773 | if (err) |
774 | goto remove; |
775 | |
776 | mmc_decode_cid(card); |
777 | } |
778 | |
779 | /* |
780 | * Select card, as all following commands rely on that. |
781 | */ |
782 | if (!mmc_host_is_spi(host)) { |
783 | err = mmc_select_card(card); |
784 | if (err) |
785 | goto remove; |
786 | } |
787 | |
788 | if (card->quirks & MMC_QUIRK_NONSTD_SDIO) { |
789 | /* |
790 | * This is non-standard SDIO device, meaning it doesn't |
791 | * have any CIA (Common I/O area) registers present. |
792 | * It's host's responsibility to fill cccr and cis |
793 | * structures in init_card(). |
794 | */ |
795 | mmc_set_clock(host, hz: card->cis.max_dtr); |
796 | |
797 | if (card->cccr.high_speed) { |
798 | mmc_set_timing(host: card->host, MMC_TIMING_SD_HS); |
799 | } |
800 | |
801 | if (oldcard) |
802 | mmc_remove_card(card); |
803 | else |
804 | host->card = card; |
805 | |
806 | return 0; |
807 | } |
808 | |
809 | /* |
810 | * Read the common registers. Note that we should try to |
811 | * validate whether UHS would work or not. |
812 | */ |
813 | err = sdio_read_cccr(card, ocr); |
814 | if (err) { |
815 | mmc_sdio_pre_init(host, ocr: ocr_card, card); |
816 | if (ocr & R4_18V_PRESENT) { |
817 | /* Retry init sequence, but without R4_18V_PRESENT. */ |
818 | retries = 0; |
819 | goto try_again; |
820 | } |
821 | return err; |
822 | } |
823 | |
824 | /* |
825 | * Read the common CIS tuples. |
826 | */ |
827 | err = sdio_read_common_cis(card); |
828 | if (err) |
829 | goto remove; |
830 | |
831 | if (oldcard) { |
832 | if (card->cis.vendor == oldcard->cis.vendor && |
833 | card->cis.device == oldcard->cis.device) { |
834 | mmc_remove_card(card); |
835 | card = oldcard; |
836 | } else { |
837 | err = -ENOENT; |
838 | goto mismatch; |
839 | } |
840 | } |
841 | |
842 | mmc_fixup_device(card, table: sdio_fixup_methods); |
843 | |
844 | if (mmc_card_sd_combo(card)) { |
845 | err = mmc_sd_setup_card(host, card, reinit: oldcard != NULL); |
846 | /* handle as SDIO-only card if memory init failed */ |
847 | if (err) { |
848 | mmc_go_idle(host); |
849 | if (mmc_host_is_spi(host)) |
850 | /* should not fail, as it worked previously */ |
851 | mmc_spi_set_crc(host, use_crc: use_spi_crc); |
852 | card->type = MMC_TYPE_SDIO; |
853 | } else |
854 | card->dev.type = &sd_type; |
855 | } |
856 | |
857 | /* |
858 | * If needed, disconnect card detection pull-up resistor. |
859 | */ |
860 | err = sdio_disable_cd(card); |
861 | if (err) |
862 | goto remove; |
863 | |
864 | /* Initialization sequence for UHS-I cards */ |
865 | /* Only if card supports 1.8v and UHS signaling */ |
866 | if ((ocr & R4_18V_PRESENT) && card->sw_caps.sd3_bus_mode) { |
867 | err = mmc_sdio_init_uhs_card(card); |
868 | if (err) |
869 | goto remove; |
870 | } else { |
871 | /* |
872 | * Switch to high-speed (if supported). |
873 | */ |
874 | err = sdio_enable_hs(card); |
875 | if (err > 0) |
876 | mmc_set_timing(host: card->host, MMC_TIMING_SD_HS); |
877 | else if (err) |
878 | goto remove; |
879 | |
880 | /* |
881 | * Change to the card's maximum speed. |
882 | */ |
883 | mmc_set_clock(host, hz: mmc_sdio_get_max_clock(card)); |
884 | |
885 | /* |
886 | * Switch to wider bus (if supported). |
887 | */ |
888 | err = sdio_enable_4bit_bus(card); |
889 | if (err) |
890 | goto remove; |
891 | } |
892 | |
893 | if (host->caps2 & MMC_CAP2_AVOID_3_3V && |
894 | host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) { |
895 | pr_err("%s: Host failed to negotiate down from 3.3V\n" , |
896 | mmc_hostname(host)); |
897 | err = -EINVAL; |
898 | goto remove; |
899 | } |
900 | |
901 | host->card = card; |
902 | return 0; |
903 | |
904 | mismatch: |
905 | pr_debug("%s: Perhaps the card was replaced\n" , mmc_hostname(host)); |
906 | remove: |
907 | if (oldcard != card) |
908 | mmc_remove_card(card); |
909 | return err; |
910 | } |
911 | |
912 | static int mmc_sdio_reinit_card(struct mmc_host *host) |
913 | { |
914 | int ret; |
915 | |
916 | ret = mmc_sdio_pre_init(host, ocr: host->card->ocr, NULL); |
917 | if (ret) |
918 | return ret; |
919 | |
920 | return mmc_sdio_init_card(host, ocr: host->card->ocr, oldcard: host->card); |
921 | } |
922 | |
923 | /* |
924 | * Host is being removed. Free up the current card. |
925 | */ |
926 | static void mmc_sdio_remove(struct mmc_host *host) |
927 | { |
928 | int i; |
929 | |
930 | for (i = 0;i < host->card->sdio_funcs;i++) { |
931 | if (host->card->sdio_func[i]) { |
932 | sdio_remove_func(func: host->card->sdio_func[i]); |
933 | host->card->sdio_func[i] = NULL; |
934 | } |
935 | } |
936 | |
937 | mmc_remove_card(card: host->card); |
938 | host->card = NULL; |
939 | } |
940 | |
941 | /* |
942 | * Card detection - card is alive. |
943 | */ |
944 | static int mmc_sdio_alive(struct mmc_host *host) |
945 | { |
946 | return mmc_select_card(card: host->card); |
947 | } |
948 | |
949 | /* |
950 | * Card detection callback from host. |
951 | */ |
952 | static void mmc_sdio_detect(struct mmc_host *host) |
953 | { |
954 | int err; |
955 | |
956 | /* Make sure card is powered before detecting it */ |
957 | if (host->caps & MMC_CAP_POWER_OFF_CARD) { |
958 | err = pm_runtime_resume_and_get(dev: &host->card->dev); |
959 | if (err < 0) |
960 | goto out; |
961 | } |
962 | |
963 | mmc_claim_host(host); |
964 | |
965 | /* |
966 | * Just check if our card has been removed. |
967 | */ |
968 | err = _mmc_detect_card_removed(host); |
969 | |
970 | mmc_release_host(host); |
971 | |
972 | /* |
973 | * Tell PM core it's OK to power off the card now. |
974 | * |
975 | * The _sync variant is used in order to ensure that the card |
976 | * is left powered off in case an error occurred, and the card |
977 | * is going to be removed. |
978 | * |
979 | * Since there is no specific reason to believe a new user |
980 | * is about to show up at this point, the _sync variant is |
981 | * desirable anyway. |
982 | */ |
983 | if (host->caps & MMC_CAP_POWER_OFF_CARD) |
984 | pm_runtime_put_sync(dev: &host->card->dev); |
985 | |
986 | out: |
987 | if (err) { |
988 | mmc_sdio_remove(host); |
989 | |
990 | mmc_claim_host(host); |
991 | mmc_detach_bus(host); |
992 | mmc_power_off(host); |
993 | mmc_release_host(host); |
994 | } |
995 | } |
996 | |
997 | /* |
998 | * SDIO pre_suspend. We need to suspend all functions separately. |
999 | * Therefore all registered functions must have drivers with suspend |
1000 | * and resume methods. Failing that we simply remove the whole card. |
1001 | */ |
1002 | static int mmc_sdio_pre_suspend(struct mmc_host *host) |
1003 | { |
1004 | int i; |
1005 | |
1006 | for (i = 0; i < host->card->sdio_funcs; i++) { |
1007 | struct sdio_func *func = host->card->sdio_func[i]; |
1008 | if (func && sdio_func_present(func) && func->dev.driver) { |
1009 | const struct dev_pm_ops *pmops = func->dev.driver->pm; |
1010 | if (!pmops || !pmops->suspend || !pmops->resume) |
1011 | /* force removal of entire card in that case */ |
1012 | goto remove; |
1013 | } |
1014 | } |
1015 | |
1016 | return 0; |
1017 | |
1018 | remove: |
1019 | if (!mmc_card_is_removable(host)) { |
1020 | dev_warn(mmc_dev(host), |
1021 | "missing suspend/resume ops for non-removable SDIO card\n" ); |
1022 | /* Don't remove a non-removable card - we can't re-detect it. */ |
1023 | return 0; |
1024 | } |
1025 | |
1026 | /* Remove the SDIO card and let it be re-detected later on. */ |
1027 | mmc_sdio_remove(host); |
1028 | mmc_claim_host(host); |
1029 | mmc_detach_bus(host); |
1030 | mmc_power_off(host); |
1031 | mmc_release_host(host); |
1032 | host->pm_flags = 0; |
1033 | |
1034 | return 0; |
1035 | } |
1036 | |
1037 | /* |
1038 | * SDIO suspend. Suspend all functions separately. |
1039 | */ |
1040 | static int mmc_sdio_suspend(struct mmc_host *host) |
1041 | { |
1042 | WARN_ON(host->sdio_irqs && !mmc_card_keep_power(host)); |
1043 | |
1044 | /* Prevent processing of SDIO IRQs in suspended state. */ |
1045 | mmc_card_set_suspended(host->card); |
1046 | cancel_work_sync(work: &host->sdio_irq_work); |
1047 | |
1048 | mmc_claim_host(host); |
1049 | |
1050 | if (mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host)) |
1051 | sdio_disable_4bit_bus(card: host->card); |
1052 | |
1053 | if (!mmc_card_keep_power(host)) { |
1054 | mmc_power_off(host); |
1055 | } else if (host->retune_period) { |
1056 | mmc_retune_timer_stop(host); |
1057 | mmc_retune_needed(host); |
1058 | } |
1059 | |
1060 | mmc_release_host(host); |
1061 | |
1062 | return 0; |
1063 | } |
1064 | |
1065 | static int mmc_sdio_resume(struct mmc_host *host) |
1066 | { |
1067 | int err = 0; |
1068 | |
1069 | /* Basic card reinitialization. */ |
1070 | mmc_claim_host(host); |
1071 | |
1072 | /* |
1073 | * Restore power and reinitialize the card when needed. Note that a |
1074 | * removable card is checked from a detect work later on in the resume |
1075 | * process. |
1076 | */ |
1077 | if (!mmc_card_keep_power(host)) { |
1078 | mmc_power_up(host, ocr: host->card->ocr); |
1079 | /* |
1080 | * Tell runtime PM core we just powered up the card, |
1081 | * since it still believes the card is powered off. |
1082 | * Note that currently runtime PM is only enabled |
1083 | * for SDIO cards that are MMC_CAP_POWER_OFF_CARD |
1084 | */ |
1085 | if (host->caps & MMC_CAP_POWER_OFF_CARD) { |
1086 | pm_runtime_disable(dev: &host->card->dev); |
1087 | pm_runtime_set_active(dev: &host->card->dev); |
1088 | pm_runtime_enable(dev: &host->card->dev); |
1089 | } |
1090 | err = mmc_sdio_reinit_card(host); |
1091 | } else if (mmc_card_wake_sdio_irq(host)) { |
1092 | /* |
1093 | * We may have switched to 1-bit mode during suspend, |
1094 | * need to hold retuning, because tuning only supprt |
1095 | * 4-bit mode or 8 bit mode. |
1096 | */ |
1097 | mmc_retune_hold_now(host); |
1098 | err = sdio_enable_4bit_bus(card: host->card); |
1099 | mmc_retune_release(host); |
1100 | } |
1101 | |
1102 | if (err) |
1103 | goto out; |
1104 | |
1105 | /* Allow SDIO IRQs to be processed again. */ |
1106 | mmc_card_clr_suspended(host->card); |
1107 | |
1108 | if (host->sdio_irqs) { |
1109 | if (!(host->caps2 & MMC_CAP2_SDIO_IRQ_NOTHREAD)) |
1110 | wake_up_process(tsk: host->sdio_irq_thread); |
1111 | else if (host->caps & MMC_CAP_SDIO_IRQ) |
1112 | schedule_work(work: &host->sdio_irq_work); |
1113 | } |
1114 | |
1115 | out: |
1116 | mmc_release_host(host); |
1117 | |
1118 | host->pm_flags &= ~MMC_PM_KEEP_POWER; |
1119 | return err; |
1120 | } |
1121 | |
1122 | static int mmc_sdio_runtime_suspend(struct mmc_host *host) |
1123 | { |
1124 | /* No references to the card, cut the power to it. */ |
1125 | mmc_claim_host(host); |
1126 | mmc_power_off(host); |
1127 | mmc_release_host(host); |
1128 | |
1129 | return 0; |
1130 | } |
1131 | |
1132 | static int mmc_sdio_runtime_resume(struct mmc_host *host) |
1133 | { |
1134 | int ret; |
1135 | |
1136 | /* Restore power and re-initialize. */ |
1137 | mmc_claim_host(host); |
1138 | mmc_power_up(host, ocr: host->card->ocr); |
1139 | ret = mmc_sdio_reinit_card(host); |
1140 | mmc_release_host(host); |
1141 | |
1142 | return ret; |
1143 | } |
1144 | |
1145 | /* |
1146 | * SDIO HW reset |
1147 | * |
1148 | * Returns 0 if the HW reset was executed synchronously, returns 1 if the HW |
1149 | * reset was asynchronously scheduled, else a negative error code. |
1150 | */ |
1151 | static int mmc_sdio_hw_reset(struct mmc_host *host) |
1152 | { |
1153 | struct mmc_card *card = host->card; |
1154 | |
1155 | /* |
1156 | * In case the card is shared among multiple func drivers, reset the |
1157 | * card through a rescan work. In this way it will be removed and |
1158 | * re-detected, thus all func drivers becomes informed about it. |
1159 | */ |
1160 | if (atomic_read(v: &card->sdio_funcs_probed) > 1) { |
1161 | if (mmc_card_removed(card)) |
1162 | return 1; |
1163 | host->rescan_entered = 0; |
1164 | mmc_card_set_removed(card); |
1165 | _mmc_detect_change(host, delay: 0, cd_irq: false); |
1166 | return 1; |
1167 | } |
1168 | |
1169 | /* |
1170 | * A single func driver has been probed, then let's skip the heavy |
1171 | * hotplug dance above and execute the reset immediately. |
1172 | */ |
1173 | mmc_power_cycle(host, ocr: card->ocr); |
1174 | return mmc_sdio_reinit_card(host); |
1175 | } |
1176 | |
1177 | static int mmc_sdio_sw_reset(struct mmc_host *host) |
1178 | { |
1179 | mmc_set_clock(host, hz: host->f_init); |
1180 | sdio_reset(host); |
1181 | mmc_go_idle(host); |
1182 | |
1183 | mmc_set_initial_state(host); |
1184 | mmc_set_initial_signal_voltage(host); |
1185 | |
1186 | return mmc_sdio_reinit_card(host); |
1187 | } |
1188 | |
1189 | static const struct mmc_bus_ops mmc_sdio_ops = { |
1190 | .remove = mmc_sdio_remove, |
1191 | .detect = mmc_sdio_detect, |
1192 | .pre_suspend = mmc_sdio_pre_suspend, |
1193 | .suspend = mmc_sdio_suspend, |
1194 | .resume = mmc_sdio_resume, |
1195 | .runtime_suspend = mmc_sdio_runtime_suspend, |
1196 | .runtime_resume = mmc_sdio_runtime_resume, |
1197 | .alive = mmc_sdio_alive, |
1198 | .hw_reset = mmc_sdio_hw_reset, |
1199 | .sw_reset = mmc_sdio_sw_reset, |
1200 | }; |
1201 | |
1202 | |
1203 | /* |
1204 | * Starting point for SDIO card init. |
1205 | */ |
1206 | int mmc_attach_sdio(struct mmc_host *host) |
1207 | { |
1208 | int err, i, funcs; |
1209 | u32 ocr, rocr; |
1210 | struct mmc_card *card; |
1211 | |
1212 | WARN_ON(!host->claimed); |
1213 | |
1214 | err = mmc_send_io_op_cond(host, ocr: 0, rocr: &ocr); |
1215 | if (err) |
1216 | return err; |
1217 | |
1218 | mmc_attach_bus(host, ops: &mmc_sdio_ops); |
1219 | if (host->ocr_avail_sdio) |
1220 | host->ocr_avail = host->ocr_avail_sdio; |
1221 | |
1222 | |
1223 | rocr = mmc_select_voltage(host, ocr); |
1224 | |
1225 | /* |
1226 | * Can we support the voltage(s) of the card(s)? |
1227 | */ |
1228 | if (!rocr) { |
1229 | err = -EINVAL; |
1230 | goto err; |
1231 | } |
1232 | |
1233 | /* |
1234 | * Detect and init the card. |
1235 | */ |
1236 | err = mmc_sdio_init_card(host, ocr: rocr, NULL); |
1237 | if (err) |
1238 | goto err; |
1239 | |
1240 | card = host->card; |
1241 | |
1242 | /* |
1243 | * Enable runtime PM only if supported by host+card+board |
1244 | */ |
1245 | if (host->caps & MMC_CAP_POWER_OFF_CARD) { |
1246 | /* |
1247 | * Do not allow runtime suspend until after SDIO function |
1248 | * devices are added. |
1249 | */ |
1250 | pm_runtime_get_noresume(dev: &card->dev); |
1251 | |
1252 | /* |
1253 | * Let runtime PM core know our card is active |
1254 | */ |
1255 | err = pm_runtime_set_active(dev: &card->dev); |
1256 | if (err) |
1257 | goto remove; |
1258 | |
1259 | /* |
1260 | * Enable runtime PM for this card |
1261 | */ |
1262 | pm_runtime_enable(dev: &card->dev); |
1263 | } |
1264 | |
1265 | /* |
1266 | * The number of functions on the card is encoded inside |
1267 | * the ocr. |
1268 | */ |
1269 | funcs = (ocr & 0x70000000) >> 28; |
1270 | card->sdio_funcs = 0; |
1271 | |
1272 | /* |
1273 | * Initialize (but don't add) all present functions. |
1274 | */ |
1275 | for (i = 0; i < funcs; i++, card->sdio_funcs++) { |
1276 | err = sdio_init_func(card: host->card, fn: i + 1); |
1277 | if (err) |
1278 | goto remove; |
1279 | |
1280 | /* |
1281 | * Enable Runtime PM for this func (if supported) |
1282 | */ |
1283 | if (host->caps & MMC_CAP_POWER_OFF_CARD) |
1284 | pm_runtime_enable(dev: &card->sdio_func[i]->dev); |
1285 | } |
1286 | |
1287 | /* |
1288 | * First add the card to the driver model... |
1289 | */ |
1290 | mmc_release_host(host); |
1291 | err = mmc_add_card(card: host->card); |
1292 | if (err) |
1293 | goto remove_added; |
1294 | |
1295 | /* |
1296 | * ...then the SDIO functions. |
1297 | */ |
1298 | for (i = 0;i < funcs;i++) { |
1299 | err = sdio_add_func(func: host->card->sdio_func[i]); |
1300 | if (err) |
1301 | goto remove_added; |
1302 | } |
1303 | |
1304 | if (host->caps & MMC_CAP_POWER_OFF_CARD) |
1305 | pm_runtime_put(dev: &card->dev); |
1306 | |
1307 | mmc_claim_host(host); |
1308 | return 0; |
1309 | |
1310 | |
1311 | remove: |
1312 | mmc_release_host(host); |
1313 | remove_added: |
1314 | /* |
1315 | * The devices are being deleted so it is not necessary to disable |
1316 | * runtime PM. Similarly we also don't pm_runtime_put() the SDIO card |
1317 | * because it needs to be active to remove any function devices that |
1318 | * were probed, and after that it gets deleted. |
1319 | */ |
1320 | mmc_sdio_remove(host); |
1321 | mmc_claim_host(host); |
1322 | err: |
1323 | mmc_detach_bus(host); |
1324 | |
1325 | pr_err("%s: error %d whilst initialising SDIO card\n" , |
1326 | mmc_hostname(host), err); |
1327 | |
1328 | return err; |
1329 | } |
1330 | |
1331 | |