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