xref: /openbmc/linux/drivers/mmc/core/sd.c (revision ef9303fd)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  linux/drivers/mmc/core/sd.c
4  *
5  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
6  *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
7  *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
8  */
9 
10 #include <linux/err.h>
11 #include <linux/sizes.h>
12 #include <linux/slab.h>
13 #include <linux/stat.h>
14 #include <linux/pm_runtime.h>
15 
16 #include <linux/mmc/host.h>
17 #include <linux/mmc/card.h>
18 #include <linux/mmc/mmc.h>
19 #include <linux/mmc/sd.h>
20 
21 #include "core.h"
22 #include "card.h"
23 #include "host.h"
24 #include "bus.h"
25 #include "mmc_ops.h"
26 #include "sd.h"
27 #include "sd_ops.h"
28 
29 static const unsigned int tran_exp[] = {
30 	10000,		100000,		1000000,	10000000,
31 	0,		0,		0,		0
32 };
33 
34 static const unsigned char tran_mant[] = {
35 	0,	10,	12,	13,	15,	20,	25,	30,
36 	35,	40,	45,	50,	55,	60,	70,	80,
37 };
38 
39 static const unsigned int taac_exp[] = {
40 	1,	10,	100,	1000,	10000,	100000,	1000000, 10000000,
41 };
42 
43 static const unsigned int taac_mant[] = {
44 	0,	10,	12,	13,	15,	20,	25,	30,
45 	35,	40,	45,	50,	55,	60,	70,	80,
46 };
47 
48 static const unsigned int sd_au_size[] = {
49 	0,		SZ_16K / 512,		SZ_32K / 512,	SZ_64K / 512,
50 	SZ_128K / 512,	SZ_256K / 512,		SZ_512K / 512,	SZ_1M / 512,
51 	SZ_2M / 512,	SZ_4M / 512,		SZ_8M / 512,	(SZ_8M + SZ_4M) / 512,
52 	SZ_16M / 512,	(SZ_16M + SZ_8M) / 512,	SZ_32M / 512,	SZ_64M / 512,
53 };
54 
55 #define UNSTUFF_BITS(resp,start,size)					\
56 	({								\
57 		const int __size = size;				\
58 		const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1;	\
59 		const int __off = 3 - ((start) / 32);			\
60 		const int __shft = (start) & 31;			\
61 		u32 __res;						\
62 									\
63 		__res = resp[__off] >> __shft;				\
64 		if (__size + __shft > 32)				\
65 			__res |= resp[__off-1] << ((32 - __shft) % 32);	\
66 		__res & __mask;						\
67 	})
68 
69 /*
70  * Given the decoded CSD structure, decode the raw CID to our CID structure.
71  */
72 void mmc_decode_cid(struct mmc_card *card)
73 {
74 	u32 *resp = card->raw_cid;
75 
76 	/*
77 	 * SD doesn't currently have a version field so we will
78 	 * have to assume we can parse this.
79 	 */
80 	card->cid.manfid		= UNSTUFF_BITS(resp, 120, 8);
81 	card->cid.oemid			= UNSTUFF_BITS(resp, 104, 16);
82 	card->cid.prod_name[0]		= UNSTUFF_BITS(resp, 96, 8);
83 	card->cid.prod_name[1]		= UNSTUFF_BITS(resp, 88, 8);
84 	card->cid.prod_name[2]		= UNSTUFF_BITS(resp, 80, 8);
85 	card->cid.prod_name[3]		= UNSTUFF_BITS(resp, 72, 8);
86 	card->cid.prod_name[4]		= UNSTUFF_BITS(resp, 64, 8);
87 	card->cid.hwrev			= UNSTUFF_BITS(resp, 60, 4);
88 	card->cid.fwrev			= UNSTUFF_BITS(resp, 56, 4);
89 	card->cid.serial		= UNSTUFF_BITS(resp, 24, 32);
90 	card->cid.year			= UNSTUFF_BITS(resp, 12, 8);
91 	card->cid.month			= UNSTUFF_BITS(resp, 8, 4);
92 
93 	card->cid.year += 2000; /* SD cards year offset */
94 }
95 
96 /*
97  * Given a 128-bit response, decode to our card CSD structure.
98  */
99 static int mmc_decode_csd(struct mmc_card *card)
100 {
101 	struct mmc_csd *csd = &card->csd;
102 	unsigned int e, m, csd_struct;
103 	u32 *resp = card->raw_csd;
104 
105 	csd_struct = UNSTUFF_BITS(resp, 126, 2);
106 
107 	switch (csd_struct) {
108 	case 0:
109 		m = UNSTUFF_BITS(resp, 115, 4);
110 		e = UNSTUFF_BITS(resp, 112, 3);
111 		csd->taac_ns	 = (taac_exp[e] * taac_mant[m] + 9) / 10;
112 		csd->taac_clks	 = UNSTUFF_BITS(resp, 104, 8) * 100;
113 
114 		m = UNSTUFF_BITS(resp, 99, 4);
115 		e = UNSTUFF_BITS(resp, 96, 3);
116 		csd->max_dtr	  = tran_exp[e] * tran_mant[m];
117 		csd->cmdclass	  = UNSTUFF_BITS(resp, 84, 12);
118 
119 		e = UNSTUFF_BITS(resp, 47, 3);
120 		m = UNSTUFF_BITS(resp, 62, 12);
121 		csd->capacity	  = (1 + m) << (e + 2);
122 
123 		csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
124 		csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
125 		csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
126 		csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
127 		csd->dsr_imp = UNSTUFF_BITS(resp, 76, 1);
128 		csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
129 		csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
130 		csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
131 
132 		if (UNSTUFF_BITS(resp, 46, 1)) {
133 			csd->erase_size = 1;
134 		} else if (csd->write_blkbits >= 9) {
135 			csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
136 			csd->erase_size <<= csd->write_blkbits - 9;
137 		}
138 		break;
139 	case 1:
140 		/*
141 		 * This is a block-addressed SDHC or SDXC card. Most
142 		 * interesting fields are unused and have fixed
143 		 * values. To avoid getting tripped by buggy cards,
144 		 * we assume those fixed values ourselves.
145 		 */
146 		mmc_card_set_blockaddr(card);
147 
148 		csd->taac_ns	 = 0; /* Unused */
149 		csd->taac_clks	 = 0; /* Unused */
150 
151 		m = UNSTUFF_BITS(resp, 99, 4);
152 		e = UNSTUFF_BITS(resp, 96, 3);
153 		csd->max_dtr	  = tran_exp[e] * tran_mant[m];
154 		csd->cmdclass	  = UNSTUFF_BITS(resp, 84, 12);
155 		csd->c_size	  = UNSTUFF_BITS(resp, 48, 22);
156 
157 		/* SDXC cards have a minimum C_SIZE of 0x00FFFF */
158 		if (csd->c_size >= 0xFFFF)
159 			mmc_card_set_ext_capacity(card);
160 
161 		m = UNSTUFF_BITS(resp, 48, 22);
162 		csd->capacity     = (1 + m) << 10;
163 
164 		csd->read_blkbits = 9;
165 		csd->read_partial = 0;
166 		csd->write_misalign = 0;
167 		csd->read_misalign = 0;
168 		csd->r2w_factor = 4; /* Unused */
169 		csd->write_blkbits = 9;
170 		csd->write_partial = 0;
171 		csd->erase_size = 1;
172 		break;
173 	default:
174 		pr_err("%s: unrecognised CSD structure version %d\n",
175 			mmc_hostname(card->host), csd_struct);
176 		return -EINVAL;
177 	}
178 
179 	card->erase_size = csd->erase_size;
180 
181 	return 0;
182 }
183 
184 /*
185  * Given a 64-bit response, decode to our card SCR structure.
186  */
187 static int mmc_decode_scr(struct mmc_card *card)
188 {
189 	struct sd_scr *scr = &card->scr;
190 	unsigned int scr_struct;
191 	u32 resp[4];
192 
193 	resp[3] = card->raw_scr[1];
194 	resp[2] = card->raw_scr[0];
195 
196 	scr_struct = UNSTUFF_BITS(resp, 60, 4);
197 	if (scr_struct != 0) {
198 		pr_err("%s: unrecognised SCR structure version %d\n",
199 			mmc_hostname(card->host), scr_struct);
200 		return -EINVAL;
201 	}
202 
203 	scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
204 	scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
205 	if (scr->sda_vsn == SCR_SPEC_VER_2)
206 		/* Check if Physical Layer Spec v3.0 is supported */
207 		scr->sda_spec3 = UNSTUFF_BITS(resp, 47, 1);
208 
209 	if (scr->sda_spec3) {
210 		scr->sda_spec4 = UNSTUFF_BITS(resp, 42, 1);
211 		scr->sda_specx = UNSTUFF_BITS(resp, 38, 4);
212 	}
213 
214 	if (UNSTUFF_BITS(resp, 55, 1))
215 		card->erased_byte = 0xFF;
216 	else
217 		card->erased_byte = 0x0;
218 
219 	if (scr->sda_spec3)
220 		scr->cmds = UNSTUFF_BITS(resp, 32, 2);
221 
222 	/* SD Spec says: any SD Card shall set at least bits 0 and 2 */
223 	if (!(scr->bus_widths & SD_SCR_BUS_WIDTH_1) ||
224 	    !(scr->bus_widths & SD_SCR_BUS_WIDTH_4)) {
225 		pr_err("%s: invalid bus width\n", mmc_hostname(card->host));
226 		return -EINVAL;
227 	}
228 
229 	return 0;
230 }
231 
232 /*
233  * Fetch and process SD Status register.
234  */
235 static int mmc_read_ssr(struct mmc_card *card)
236 {
237 	unsigned int au, es, et, eo;
238 	__be32 *raw_ssr;
239 	u32 resp[4] = {};
240 	u8 discard_support;
241 	int i;
242 
243 	if (!(card->csd.cmdclass & CCC_APP_SPEC)) {
244 		pr_warn("%s: card lacks mandatory SD Status function\n",
245 			mmc_hostname(card->host));
246 		return 0;
247 	}
248 
249 	raw_ssr = kmalloc(sizeof(card->raw_ssr), GFP_KERNEL);
250 	if (!raw_ssr)
251 		return -ENOMEM;
252 
253 	if (mmc_app_sd_status(card, raw_ssr)) {
254 		pr_warn("%s: problem reading SD Status register\n",
255 			mmc_hostname(card->host));
256 		kfree(raw_ssr);
257 		return 0;
258 	}
259 
260 	for (i = 0; i < 16; i++)
261 		card->raw_ssr[i] = be32_to_cpu(raw_ssr[i]);
262 
263 	kfree(raw_ssr);
264 
265 	/*
266 	 * UNSTUFF_BITS only works with four u32s so we have to offset the
267 	 * bitfield positions accordingly.
268 	 */
269 	au = UNSTUFF_BITS(card->raw_ssr, 428 - 384, 4);
270 	if (au) {
271 		if (au <= 9 || card->scr.sda_spec3) {
272 			card->ssr.au = sd_au_size[au];
273 			es = UNSTUFF_BITS(card->raw_ssr, 408 - 384, 16);
274 			et = UNSTUFF_BITS(card->raw_ssr, 402 - 384, 6);
275 			if (es && et) {
276 				eo = UNSTUFF_BITS(card->raw_ssr, 400 - 384, 2);
277 				card->ssr.erase_timeout = (et * 1000) / es;
278 				card->ssr.erase_offset = eo * 1000;
279 			}
280 		} else {
281 			pr_warn("%s: SD Status: Invalid Allocation Unit size\n",
282 				mmc_hostname(card->host));
283 		}
284 	}
285 
286 	/*
287 	 * starting SD5.1 discard is supported if DISCARD_SUPPORT (b313) is set
288 	 */
289 	resp[3] = card->raw_ssr[6];
290 	discard_support = UNSTUFF_BITS(resp, 313 - 288, 1);
291 	card->erase_arg = (card->scr.sda_specx && discard_support) ?
292 			    SD_DISCARD_ARG : SD_ERASE_ARG;
293 
294 	return 0;
295 }
296 
297 /*
298  * Fetches and decodes switch information
299  */
300 static int mmc_read_switch(struct mmc_card *card)
301 {
302 	int err;
303 	u8 *status;
304 
305 	if (card->scr.sda_vsn < SCR_SPEC_VER_1)
306 		return 0;
307 
308 	if (!(card->csd.cmdclass & CCC_SWITCH)) {
309 		pr_warn("%s: card lacks mandatory switch function, performance might suffer\n",
310 			mmc_hostname(card->host));
311 		return 0;
312 	}
313 
314 	status = kmalloc(64, GFP_KERNEL);
315 	if (!status)
316 		return -ENOMEM;
317 
318 	/*
319 	 * Find out the card's support bits with a mode 0 operation.
320 	 * The argument does not matter, as the support bits do not
321 	 * change with the arguments.
322 	 */
323 	err = mmc_sd_switch(card, 0, 0, 0, status);
324 	if (err) {
325 		/*
326 		 * If the host or the card can't do the switch,
327 		 * fail more gracefully.
328 		 */
329 		if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
330 			goto out;
331 
332 		pr_warn("%s: problem reading Bus Speed modes\n",
333 			mmc_hostname(card->host));
334 		err = 0;
335 
336 		goto out;
337 	}
338 
339 	if (status[13] & SD_MODE_HIGH_SPEED)
340 		card->sw_caps.hs_max_dtr = HIGH_SPEED_MAX_DTR;
341 
342 	if (card->scr.sda_spec3) {
343 		card->sw_caps.sd3_bus_mode = status[13];
344 		/* Driver Strengths supported by the card */
345 		card->sw_caps.sd3_drv_type = status[9];
346 		card->sw_caps.sd3_curr_limit = status[7] | status[6] << 8;
347 	}
348 
349 out:
350 	kfree(status);
351 
352 	return err;
353 }
354 
355 /*
356  * Test if the card supports high-speed mode and, if so, switch to it.
357  */
358 int mmc_sd_switch_hs(struct mmc_card *card)
359 {
360 	int err;
361 	u8 *status;
362 
363 	if (card->scr.sda_vsn < SCR_SPEC_VER_1)
364 		return 0;
365 
366 	if (!(card->csd.cmdclass & CCC_SWITCH))
367 		return 0;
368 
369 	if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
370 		return 0;
371 
372 	if (card->sw_caps.hs_max_dtr == 0)
373 		return 0;
374 
375 	status = kmalloc(64, GFP_KERNEL);
376 	if (!status)
377 		return -ENOMEM;
378 
379 	err = mmc_sd_switch(card, 1, 0, HIGH_SPEED_BUS_SPEED, status);
380 	if (err)
381 		goto out;
382 
383 	if ((status[16] & 0xF) != HIGH_SPEED_BUS_SPEED) {
384 		pr_warn("%s: Problem switching card into high-speed mode!\n",
385 			mmc_hostname(card->host));
386 		err = 0;
387 	} else {
388 		err = 1;
389 	}
390 
391 out:
392 	kfree(status);
393 
394 	return err;
395 }
396 
397 static int sd_select_driver_type(struct mmc_card *card, u8 *status)
398 {
399 	int card_drv_type, drive_strength, drv_type;
400 	int err;
401 
402 	card->drive_strength = 0;
403 
404 	card_drv_type = card->sw_caps.sd3_drv_type | SD_DRIVER_TYPE_B;
405 
406 	drive_strength = mmc_select_drive_strength(card,
407 						   card->sw_caps.uhs_max_dtr,
408 						   card_drv_type, &drv_type);
409 
410 	if (drive_strength) {
411 		err = mmc_sd_switch(card, 1, 2, drive_strength, status);
412 		if (err)
413 			return err;
414 		if ((status[15] & 0xF) != drive_strength) {
415 			pr_warn("%s: Problem setting drive strength!\n",
416 				mmc_hostname(card->host));
417 			return 0;
418 		}
419 		card->drive_strength = drive_strength;
420 	}
421 
422 	if (drv_type)
423 		mmc_set_driver_type(card->host, drv_type);
424 
425 	return 0;
426 }
427 
428 static void sd_update_bus_speed_mode(struct mmc_card *card)
429 {
430 	/*
431 	 * If the host doesn't support any of the UHS-I modes, fallback on
432 	 * default speed.
433 	 */
434 	if (!mmc_host_uhs(card->host)) {
435 		card->sd_bus_speed = 0;
436 		return;
437 	}
438 
439 	if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
440 	    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
441 			card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
442 	} else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
443 		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
444 			card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
445 	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
446 		    MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
447 		    SD_MODE_UHS_SDR50)) {
448 			card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
449 	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
450 		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
451 		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
452 			card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
453 	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
454 		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
455 		    MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
456 		    SD_MODE_UHS_SDR12)) {
457 			card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
458 	}
459 }
460 
461 static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
462 {
463 	int err;
464 	unsigned int timing = 0;
465 
466 	switch (card->sd_bus_speed) {
467 	case UHS_SDR104_BUS_SPEED:
468 		timing = MMC_TIMING_UHS_SDR104;
469 		card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
470 		break;
471 	case UHS_DDR50_BUS_SPEED:
472 		timing = MMC_TIMING_UHS_DDR50;
473 		card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
474 		break;
475 	case UHS_SDR50_BUS_SPEED:
476 		timing = MMC_TIMING_UHS_SDR50;
477 		card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
478 		break;
479 	case UHS_SDR25_BUS_SPEED:
480 		timing = MMC_TIMING_UHS_SDR25;
481 		card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
482 		break;
483 	case UHS_SDR12_BUS_SPEED:
484 		timing = MMC_TIMING_UHS_SDR12;
485 		card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
486 		break;
487 	default:
488 		return 0;
489 	}
490 
491 	err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status);
492 	if (err)
493 		return err;
494 
495 	if ((status[16] & 0xF) != card->sd_bus_speed)
496 		pr_warn("%s: Problem setting bus speed mode!\n",
497 			mmc_hostname(card->host));
498 	else {
499 		mmc_set_timing(card->host, timing);
500 		mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
501 	}
502 
503 	return 0;
504 }
505 
506 /* Get host's max current setting at its current voltage */
507 static u32 sd_get_host_max_current(struct mmc_host *host)
508 {
509 	u32 voltage, max_current;
510 
511 	voltage = 1 << host->ios.vdd;
512 	switch (voltage) {
513 	case MMC_VDD_165_195:
514 		max_current = host->max_current_180;
515 		break;
516 	case MMC_VDD_29_30:
517 	case MMC_VDD_30_31:
518 		max_current = host->max_current_300;
519 		break;
520 	case MMC_VDD_32_33:
521 	case MMC_VDD_33_34:
522 		max_current = host->max_current_330;
523 		break;
524 	default:
525 		max_current = 0;
526 	}
527 
528 	return max_current;
529 }
530 
531 static int sd_set_current_limit(struct mmc_card *card, u8 *status)
532 {
533 	int current_limit = SD_SET_CURRENT_NO_CHANGE;
534 	int err;
535 	u32 max_current;
536 
537 	/*
538 	 * Current limit switch is only defined for SDR50, SDR104, and DDR50
539 	 * bus speed modes. For other bus speed modes, we do not change the
540 	 * current limit.
541 	 */
542 	if ((card->sd_bus_speed != UHS_SDR50_BUS_SPEED) &&
543 	    (card->sd_bus_speed != UHS_SDR104_BUS_SPEED) &&
544 	    (card->sd_bus_speed != UHS_DDR50_BUS_SPEED))
545 		return 0;
546 
547 	/*
548 	 * Host has different current capabilities when operating at
549 	 * different voltages, so find out its max current first.
550 	 */
551 	max_current = sd_get_host_max_current(card->host);
552 
553 	/*
554 	 * We only check host's capability here, if we set a limit that is
555 	 * higher than the card's maximum current, the card will be using its
556 	 * maximum current, e.g. if the card's maximum current is 300ma, and
557 	 * when we set current limit to 200ma, the card will draw 200ma, and
558 	 * when we set current limit to 400/600/800ma, the card will draw its
559 	 * maximum 300ma from the host.
560 	 *
561 	 * The above is incorrect: if we try to set a current limit that is
562 	 * not supported by the card, the card can rightfully error out the
563 	 * attempt, and remain at the default current limit.  This results
564 	 * in a 300mA card being limited to 200mA even though the host
565 	 * supports 800mA. Failures seen with SanDisk 8GB UHS cards with
566 	 * an iMX6 host. --rmk
567 	 */
568 	if (max_current >= 800 &&
569 	    card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_800)
570 		current_limit = SD_SET_CURRENT_LIMIT_800;
571 	else if (max_current >= 600 &&
572 		 card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_600)
573 		current_limit = SD_SET_CURRENT_LIMIT_600;
574 	else if (max_current >= 400 &&
575 		 card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_400)
576 		current_limit = SD_SET_CURRENT_LIMIT_400;
577 	else if (max_current >= 200 &&
578 		 card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_200)
579 		current_limit = SD_SET_CURRENT_LIMIT_200;
580 
581 	if (current_limit != SD_SET_CURRENT_NO_CHANGE) {
582 		err = mmc_sd_switch(card, 1, 3, current_limit, status);
583 		if (err)
584 			return err;
585 
586 		if (((status[15] >> 4) & 0x0F) != current_limit)
587 			pr_warn("%s: Problem setting current limit!\n",
588 				mmc_hostname(card->host));
589 
590 	}
591 
592 	return 0;
593 }
594 
595 /*
596  * UHS-I specific initialization procedure
597  */
598 static int mmc_sd_init_uhs_card(struct mmc_card *card)
599 {
600 	int err;
601 	u8 *status;
602 
603 	if (!(card->csd.cmdclass & CCC_SWITCH))
604 		return 0;
605 
606 	status = kmalloc(64, GFP_KERNEL);
607 	if (!status)
608 		return -ENOMEM;
609 
610 	/* Set 4-bit bus width */
611 	err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
612 	if (err)
613 		goto out;
614 
615 	mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
616 
617 	/*
618 	 * Select the bus speed mode depending on host
619 	 * and card capability.
620 	 */
621 	sd_update_bus_speed_mode(card);
622 
623 	/* Set the driver strength for the card */
624 	err = sd_select_driver_type(card, status);
625 	if (err)
626 		goto out;
627 
628 	/* Set current limit for the card */
629 	err = sd_set_current_limit(card, status);
630 	if (err)
631 		goto out;
632 
633 	/* Set bus speed mode of the card */
634 	err = sd_set_bus_speed_mode(card, status);
635 	if (err)
636 		goto out;
637 
638 	/*
639 	 * SPI mode doesn't define CMD19 and tuning is only valid for SDR50 and
640 	 * SDR104 mode SD-cards. Note that tuning is mandatory for SDR104.
641 	 */
642 	if (!mmc_host_is_spi(card->host) &&
643 		(card->host->ios.timing == MMC_TIMING_UHS_SDR50 ||
644 		 card->host->ios.timing == MMC_TIMING_UHS_DDR50 ||
645 		 card->host->ios.timing == MMC_TIMING_UHS_SDR104)) {
646 		err = mmc_execute_tuning(card);
647 
648 		/*
649 		 * As SD Specifications Part1 Physical Layer Specification
650 		 * Version 3.01 says, CMD19 tuning is available for unlocked
651 		 * cards in transfer state of 1.8V signaling mode. The small
652 		 * difference between v3.00 and 3.01 spec means that CMD19
653 		 * tuning is also available for DDR50 mode.
654 		 */
655 		if (err && card->host->ios.timing == MMC_TIMING_UHS_DDR50) {
656 			pr_warn("%s: ddr50 tuning failed\n",
657 				mmc_hostname(card->host));
658 			err = 0;
659 		}
660 	}
661 
662 out:
663 	kfree(status);
664 
665 	return err;
666 }
667 
668 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
669 	card->raw_cid[2], card->raw_cid[3]);
670 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
671 	card->raw_csd[2], card->raw_csd[3]);
672 MMC_DEV_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
673 MMC_DEV_ATTR(ssr,
674 	"%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n",
675 		card->raw_ssr[0], card->raw_ssr[1], card->raw_ssr[2],
676 		card->raw_ssr[3], card->raw_ssr[4], card->raw_ssr[5],
677 		card->raw_ssr[6], card->raw_ssr[7], card->raw_ssr[8],
678 		card->raw_ssr[9], card->raw_ssr[10], card->raw_ssr[11],
679 		card->raw_ssr[12], card->raw_ssr[13], card->raw_ssr[14],
680 		card->raw_ssr[15]);
681 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
682 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
683 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
684 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
685 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
686 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
687 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
688 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
689 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
690 MMC_DEV_ATTR(ocr, "0x%08x\n", card->ocr);
691 MMC_DEV_ATTR(rca, "0x%04x\n", card->rca);
692 
693 
694 static ssize_t mmc_dsr_show(struct device *dev,
695                            struct device_attribute *attr,
696                            char *buf)
697 {
698        struct mmc_card *card = mmc_dev_to_card(dev);
699        struct mmc_host *host = card->host;
700 
701        if (card->csd.dsr_imp && host->dsr_req)
702                return sprintf(buf, "0x%x\n", host->dsr);
703        else
704                /* return default DSR value */
705                return sprintf(buf, "0x%x\n", 0x404);
706 }
707 
708 static DEVICE_ATTR(dsr, S_IRUGO, mmc_dsr_show, NULL);
709 
710 MMC_DEV_ATTR(vendor, "0x%04x\n", card->cis.vendor);
711 MMC_DEV_ATTR(device, "0x%04x\n", card->cis.device);
712 
713 static struct attribute *sd_std_attrs[] = {
714 	&dev_attr_vendor.attr,
715 	&dev_attr_device.attr,
716 	&dev_attr_cid.attr,
717 	&dev_attr_csd.attr,
718 	&dev_attr_scr.attr,
719 	&dev_attr_ssr.attr,
720 	&dev_attr_date.attr,
721 	&dev_attr_erase_size.attr,
722 	&dev_attr_preferred_erase_size.attr,
723 	&dev_attr_fwrev.attr,
724 	&dev_attr_hwrev.attr,
725 	&dev_attr_manfid.attr,
726 	&dev_attr_name.attr,
727 	&dev_attr_oemid.attr,
728 	&dev_attr_serial.attr,
729 	&dev_attr_ocr.attr,
730 	&dev_attr_rca.attr,
731 	&dev_attr_dsr.attr,
732 	NULL,
733 };
734 
735 static umode_t sd_std_is_visible(struct kobject *kobj, struct attribute *attr,
736 				 int index)
737 {
738 	struct device *dev = container_of(kobj, struct device, kobj);
739 	struct mmc_card *card = mmc_dev_to_card(dev);
740 
741 	/* CIS vendor and device ids are available only for Combo cards */
742 	if ((attr == &dev_attr_vendor.attr || attr == &dev_attr_device.attr) &&
743 	    card->type != MMC_TYPE_SD_COMBO)
744 		return 0;
745 
746 	return attr->mode;
747 }
748 
749 static const struct attribute_group sd_std_group = {
750 	.attrs = sd_std_attrs,
751 	.is_visible = sd_std_is_visible,
752 };
753 __ATTRIBUTE_GROUPS(sd_std);
754 
755 struct device_type sd_type = {
756 	.groups = sd_std_groups,
757 };
758 
759 /*
760  * Fetch CID from card.
761  */
762 int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
763 {
764 	int err;
765 	u32 max_current;
766 	int retries = 10;
767 	u32 pocr = ocr;
768 
769 try_again:
770 	if (!retries) {
771 		ocr &= ~SD_OCR_S18R;
772 		pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host));
773 	}
774 
775 	/*
776 	 * Since we're changing the OCR value, we seem to
777 	 * need to tell some cards to go back to the idle
778 	 * state.  We wait 1ms to give cards time to
779 	 * respond.
780 	 */
781 	mmc_go_idle(host);
782 
783 	/*
784 	 * If SD_SEND_IF_COND indicates an SD 2.0
785 	 * compliant card and we should set bit 30
786 	 * of the ocr to indicate that we can handle
787 	 * block-addressed SDHC cards.
788 	 */
789 	err = mmc_send_if_cond(host, ocr);
790 	if (!err)
791 		ocr |= SD_OCR_CCS;
792 
793 	/*
794 	 * If the host supports one of UHS-I modes, request the card
795 	 * to switch to 1.8V signaling level. If the card has failed
796 	 * repeatedly to switch however, skip this.
797 	 */
798 	if (retries && mmc_host_uhs(host))
799 		ocr |= SD_OCR_S18R;
800 
801 	/*
802 	 * If the host can supply more than 150mA at current voltage,
803 	 * XPC should be set to 1.
804 	 */
805 	max_current = sd_get_host_max_current(host);
806 	if (max_current > 150)
807 		ocr |= SD_OCR_XPC;
808 
809 	err = mmc_send_app_op_cond(host, ocr, rocr);
810 	if (err)
811 		return err;
812 
813 	/*
814 	 * In case CCS and S18A in the response is set, start Signal Voltage
815 	 * Switch procedure. SPI mode doesn't support CMD11.
816 	 */
817 	if (!mmc_host_is_spi(host) && rocr &&
818 	   ((*rocr & 0x41000000) == 0x41000000)) {
819 		err = mmc_set_uhs_voltage(host, pocr);
820 		if (err == -EAGAIN) {
821 			retries--;
822 			goto try_again;
823 		} else if (err) {
824 			retries = 0;
825 			goto try_again;
826 		}
827 	}
828 
829 	err = mmc_send_cid(host, cid);
830 	return err;
831 }
832 
833 int mmc_sd_get_csd(struct mmc_host *host, struct mmc_card *card)
834 {
835 	int err;
836 
837 	/*
838 	 * Fetch CSD from card.
839 	 */
840 	err = mmc_send_csd(card, card->raw_csd);
841 	if (err)
842 		return err;
843 
844 	err = mmc_decode_csd(card);
845 	if (err)
846 		return err;
847 
848 	return 0;
849 }
850 
851 static int mmc_sd_get_ro(struct mmc_host *host)
852 {
853 	int ro;
854 
855 	/*
856 	 * Some systems don't feature a write-protect pin and don't need one.
857 	 * E.g. because they only have micro-SD card slot. For those systems
858 	 * assume that the SD card is always read-write.
859 	 */
860 	if (host->caps2 & MMC_CAP2_NO_WRITE_PROTECT)
861 		return 0;
862 
863 	if (!host->ops->get_ro)
864 		return -1;
865 
866 	ro = host->ops->get_ro(host);
867 
868 	return ro;
869 }
870 
871 int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
872 	bool reinit)
873 {
874 	int err;
875 
876 	if (!reinit) {
877 		/*
878 		 * Fetch SCR from card.
879 		 */
880 		err = mmc_app_send_scr(card);
881 		if (err)
882 			return err;
883 
884 		err = mmc_decode_scr(card);
885 		if (err)
886 			return err;
887 
888 		/*
889 		 * Fetch and process SD Status register.
890 		 */
891 		err = mmc_read_ssr(card);
892 		if (err)
893 			return err;
894 
895 		/* Erase init depends on CSD and SSR */
896 		mmc_init_erase(card);
897 
898 		/*
899 		 * Fetch switch information from card.
900 		 */
901 		err = mmc_read_switch(card);
902 		if (err)
903 			return err;
904 	}
905 
906 	/*
907 	 * For SPI, enable CRC as appropriate.
908 	 * This CRC enable is located AFTER the reading of the
909 	 * card registers because some SDHC cards are not able
910 	 * to provide valid CRCs for non-512-byte blocks.
911 	 */
912 	if (mmc_host_is_spi(host)) {
913 		err = mmc_spi_set_crc(host, use_spi_crc);
914 		if (err)
915 			return err;
916 	}
917 
918 	/*
919 	 * Check if read-only switch is active.
920 	 */
921 	if (!reinit) {
922 		int ro = mmc_sd_get_ro(host);
923 
924 		if (ro < 0) {
925 			pr_warn("%s: host does not support reading read-only switch, assuming write-enable\n",
926 				mmc_hostname(host));
927 		} else if (ro > 0) {
928 			mmc_card_set_readonly(card);
929 		}
930 	}
931 
932 	return 0;
933 }
934 
935 unsigned mmc_sd_get_max_clock(struct mmc_card *card)
936 {
937 	unsigned max_dtr = (unsigned int)-1;
938 
939 	if (mmc_card_hs(card)) {
940 		if (max_dtr > card->sw_caps.hs_max_dtr)
941 			max_dtr = card->sw_caps.hs_max_dtr;
942 	} else if (max_dtr > card->csd.max_dtr) {
943 		max_dtr = card->csd.max_dtr;
944 	}
945 
946 	return max_dtr;
947 }
948 
949 static bool mmc_sd_card_using_v18(struct mmc_card *card)
950 {
951 	/*
952 	 * According to the SD spec., the Bus Speed Mode (function group 1) bits
953 	 * 2 to 4 are zero if the card is initialized at 3.3V signal level. Thus
954 	 * they can be used to determine if the card has already switched to
955 	 * 1.8V signaling.
956 	 */
957 	return card->sw_caps.sd3_bus_mode &
958 	       (SD_MODE_UHS_SDR50 | SD_MODE_UHS_SDR104 | SD_MODE_UHS_DDR50);
959 }
960 
961 /*
962  * Handle the detection and initialisation of a card.
963  *
964  * In the case of a resume, "oldcard" will contain the card
965  * we're trying to reinitialise.
966  */
967 static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
968 	struct mmc_card *oldcard)
969 {
970 	struct mmc_card *card;
971 	int err;
972 	u32 cid[4];
973 	u32 rocr = 0;
974 	bool v18_fixup_failed = false;
975 
976 	WARN_ON(!host->claimed);
977 retry:
978 	err = mmc_sd_get_cid(host, ocr, cid, &rocr);
979 	if (err)
980 		return err;
981 
982 	if (oldcard) {
983 		if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
984 			pr_debug("%s: Perhaps the card was replaced\n",
985 				mmc_hostname(host));
986 			return -ENOENT;
987 		}
988 
989 		card = oldcard;
990 	} else {
991 		/*
992 		 * Allocate card structure.
993 		 */
994 		card = mmc_alloc_card(host, &sd_type);
995 		if (IS_ERR(card))
996 			return PTR_ERR(card);
997 
998 		card->ocr = ocr;
999 		card->type = MMC_TYPE_SD;
1000 		memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
1001 	}
1002 
1003 	/*
1004 	 * Call the optional HC's init_card function to handle quirks.
1005 	 */
1006 	if (host->ops->init_card)
1007 		host->ops->init_card(host, card);
1008 
1009 	/*
1010 	 * For native busses:  get card RCA and quit open drain mode.
1011 	 */
1012 	if (!mmc_host_is_spi(host)) {
1013 		err = mmc_send_relative_addr(host, &card->rca);
1014 		if (err)
1015 			goto free_card;
1016 	}
1017 
1018 	if (!oldcard) {
1019 		err = mmc_sd_get_csd(host, card);
1020 		if (err)
1021 			goto free_card;
1022 
1023 		mmc_decode_cid(card);
1024 	}
1025 
1026 	/*
1027 	 * handling only for cards supporting DSR and hosts requesting
1028 	 * DSR configuration
1029 	 */
1030 	if (card->csd.dsr_imp && host->dsr_req)
1031 		mmc_set_dsr(host);
1032 
1033 	/*
1034 	 * Select card, as all following commands rely on that.
1035 	 */
1036 	if (!mmc_host_is_spi(host)) {
1037 		err = mmc_select_card(card);
1038 		if (err)
1039 			goto free_card;
1040 	}
1041 
1042 	err = mmc_sd_setup_card(host, card, oldcard != NULL);
1043 	if (err)
1044 		goto free_card;
1045 
1046 	/*
1047 	 * If the card has not been power cycled, it may still be using 1.8V
1048 	 * signaling. Detect that situation and try to initialize a UHS-I (1.8V)
1049 	 * transfer mode.
1050 	 */
1051 	if (!v18_fixup_failed && !mmc_host_is_spi(host) && mmc_host_uhs(host) &&
1052 	    mmc_sd_card_using_v18(card) &&
1053 	    host->ios.signal_voltage != MMC_SIGNAL_VOLTAGE_180) {
1054 		/*
1055 		 * Re-read switch information in case it has changed since
1056 		 * oldcard was initialized.
1057 		 */
1058 		if (oldcard) {
1059 			err = mmc_read_switch(card);
1060 			if (err)
1061 				goto free_card;
1062 		}
1063 		if (mmc_sd_card_using_v18(card)) {
1064 			if (mmc_host_set_uhs_voltage(host) ||
1065 			    mmc_sd_init_uhs_card(card)) {
1066 				v18_fixup_failed = true;
1067 				mmc_power_cycle(host, ocr);
1068 				if (!oldcard)
1069 					mmc_remove_card(card);
1070 				goto retry;
1071 			}
1072 			goto done;
1073 		}
1074 	}
1075 
1076 	/* Initialization sequence for UHS-I cards */
1077 	if (rocr & SD_ROCR_S18A && mmc_host_uhs(host)) {
1078 		err = mmc_sd_init_uhs_card(card);
1079 		if (err)
1080 			goto free_card;
1081 	} else {
1082 		/*
1083 		 * Attempt to change to high-speed (if supported)
1084 		 */
1085 		err = mmc_sd_switch_hs(card);
1086 		if (err > 0)
1087 			mmc_set_timing(card->host, MMC_TIMING_SD_HS);
1088 		else if (err)
1089 			goto free_card;
1090 
1091 		/*
1092 		 * Set bus speed.
1093 		 */
1094 		mmc_set_clock(host, mmc_sd_get_max_clock(card));
1095 
1096 		/*
1097 		 * Switch to wider bus (if supported).
1098 		 */
1099 		if ((host->caps & MMC_CAP_4_BIT_DATA) &&
1100 			(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
1101 			err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
1102 			if (err)
1103 				goto free_card;
1104 
1105 			mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
1106 		}
1107 	}
1108 
1109 	if (host->cqe_ops && !host->cqe_enabled) {
1110 		err = host->cqe_ops->cqe_enable(host, card);
1111 		if (!err) {
1112 			host->cqe_enabled = true;
1113 			host->hsq_enabled = true;
1114 			pr_info("%s: Host Software Queue enabled\n",
1115 				mmc_hostname(host));
1116 		}
1117 	}
1118 
1119 	if (host->caps2 & MMC_CAP2_AVOID_3_3V &&
1120 	    host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
1121 		pr_err("%s: Host failed to negotiate down from 3.3V\n",
1122 			mmc_hostname(host));
1123 		err = -EINVAL;
1124 		goto free_card;
1125 	}
1126 done:
1127 	host->card = card;
1128 	return 0;
1129 
1130 free_card:
1131 	if (!oldcard)
1132 		mmc_remove_card(card);
1133 
1134 	return err;
1135 }
1136 
1137 /*
1138  * Host is being removed. Free up the current card.
1139  */
1140 static void mmc_sd_remove(struct mmc_host *host)
1141 {
1142 	mmc_remove_card(host->card);
1143 	host->card = NULL;
1144 }
1145 
1146 /*
1147  * Card detection - card is alive.
1148  */
1149 static int mmc_sd_alive(struct mmc_host *host)
1150 {
1151 	return mmc_send_status(host->card, NULL);
1152 }
1153 
1154 /*
1155  * Card detection callback from host.
1156  */
1157 static void mmc_sd_detect(struct mmc_host *host)
1158 {
1159 	int err;
1160 
1161 	mmc_get_card(host->card, NULL);
1162 
1163 	/*
1164 	 * Just check if our card has been removed.
1165 	 */
1166 	err = _mmc_detect_card_removed(host);
1167 
1168 	mmc_put_card(host->card, NULL);
1169 
1170 	if (err) {
1171 		mmc_sd_remove(host);
1172 
1173 		mmc_claim_host(host);
1174 		mmc_detach_bus(host);
1175 		mmc_power_off(host);
1176 		mmc_release_host(host);
1177 	}
1178 }
1179 
1180 static int _mmc_sd_suspend(struct mmc_host *host)
1181 {
1182 	int err = 0;
1183 
1184 	mmc_claim_host(host);
1185 
1186 	if (mmc_card_suspended(host->card))
1187 		goto out;
1188 
1189 	if (!mmc_host_is_spi(host))
1190 		err = mmc_deselect_cards(host);
1191 
1192 	if (!err) {
1193 		mmc_power_off(host);
1194 		mmc_card_set_suspended(host->card);
1195 	}
1196 
1197 out:
1198 	mmc_release_host(host);
1199 	return err;
1200 }
1201 
1202 /*
1203  * Callback for suspend
1204  */
1205 static int mmc_sd_suspend(struct mmc_host *host)
1206 {
1207 	int err;
1208 
1209 	err = _mmc_sd_suspend(host);
1210 	if (!err) {
1211 		pm_runtime_disable(&host->card->dev);
1212 		pm_runtime_set_suspended(&host->card->dev);
1213 	}
1214 
1215 	return err;
1216 }
1217 
1218 /*
1219  * This function tries to determine if the same card is still present
1220  * and, if so, restore all state to it.
1221  */
1222 static int _mmc_sd_resume(struct mmc_host *host)
1223 {
1224 	int err = 0;
1225 
1226 	mmc_claim_host(host);
1227 
1228 	if (!mmc_card_suspended(host->card))
1229 		goto out;
1230 
1231 	mmc_power_up(host, host->card->ocr);
1232 	err = mmc_sd_init_card(host, host->card->ocr, host->card);
1233 	mmc_card_clr_suspended(host->card);
1234 
1235 out:
1236 	mmc_release_host(host);
1237 	return err;
1238 }
1239 
1240 /*
1241  * Callback for resume
1242  */
1243 static int mmc_sd_resume(struct mmc_host *host)
1244 {
1245 	pm_runtime_enable(&host->card->dev);
1246 	return 0;
1247 }
1248 
1249 /*
1250  * Callback for runtime_suspend.
1251  */
1252 static int mmc_sd_runtime_suspend(struct mmc_host *host)
1253 {
1254 	int err;
1255 
1256 	if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1257 		return 0;
1258 
1259 	err = _mmc_sd_suspend(host);
1260 	if (err)
1261 		pr_err("%s: error %d doing aggressive suspend\n",
1262 			mmc_hostname(host), err);
1263 
1264 	return err;
1265 }
1266 
1267 /*
1268  * Callback for runtime_resume.
1269  */
1270 static int mmc_sd_runtime_resume(struct mmc_host *host)
1271 {
1272 	int err;
1273 
1274 	err = _mmc_sd_resume(host);
1275 	if (err && err != -ENOMEDIUM)
1276 		pr_err("%s: error %d doing runtime resume\n",
1277 			mmc_hostname(host), err);
1278 
1279 	return 0;
1280 }
1281 
1282 static int mmc_sd_hw_reset(struct mmc_host *host)
1283 {
1284 	mmc_power_cycle(host, host->card->ocr);
1285 	return mmc_sd_init_card(host, host->card->ocr, host->card);
1286 }
1287 
1288 static const struct mmc_bus_ops mmc_sd_ops = {
1289 	.remove = mmc_sd_remove,
1290 	.detect = mmc_sd_detect,
1291 	.runtime_suspend = mmc_sd_runtime_suspend,
1292 	.runtime_resume = mmc_sd_runtime_resume,
1293 	.suspend = mmc_sd_suspend,
1294 	.resume = mmc_sd_resume,
1295 	.alive = mmc_sd_alive,
1296 	.shutdown = mmc_sd_suspend,
1297 	.hw_reset = mmc_sd_hw_reset,
1298 };
1299 
1300 /*
1301  * Starting point for SD card init.
1302  */
1303 int mmc_attach_sd(struct mmc_host *host)
1304 {
1305 	int err;
1306 	u32 ocr, rocr;
1307 
1308 	WARN_ON(!host->claimed);
1309 
1310 	err = mmc_send_app_op_cond(host, 0, &ocr);
1311 	if (err)
1312 		return err;
1313 
1314 	mmc_attach_bus(host, &mmc_sd_ops);
1315 	if (host->ocr_avail_sd)
1316 		host->ocr_avail = host->ocr_avail_sd;
1317 
1318 	/*
1319 	 * We need to get OCR a different way for SPI.
1320 	 */
1321 	if (mmc_host_is_spi(host)) {
1322 		mmc_go_idle(host);
1323 
1324 		err = mmc_spi_read_ocr(host, 0, &ocr);
1325 		if (err)
1326 			goto err;
1327 	}
1328 
1329 	/*
1330 	 * Some SD cards claims an out of spec VDD voltage range. Let's treat
1331 	 * these bits as being in-valid and especially also bit7.
1332 	 */
1333 	ocr &= ~0x7FFF;
1334 
1335 	rocr = mmc_select_voltage(host, ocr);
1336 
1337 	/*
1338 	 * Can we support the voltage(s) of the card(s)?
1339 	 */
1340 	if (!rocr) {
1341 		err = -EINVAL;
1342 		goto err;
1343 	}
1344 
1345 	/*
1346 	 * Detect and init the card.
1347 	 */
1348 	err = mmc_sd_init_card(host, rocr, NULL);
1349 	if (err)
1350 		goto err;
1351 
1352 	mmc_release_host(host);
1353 	err = mmc_add_card(host->card);
1354 	if (err)
1355 		goto remove_card;
1356 
1357 	mmc_claim_host(host);
1358 	return 0;
1359 
1360 remove_card:
1361 	mmc_remove_card(host->card);
1362 	host->card = NULL;
1363 	mmc_claim_host(host);
1364 err:
1365 	mmc_detach_bus(host);
1366 
1367 	pr_err("%s: error %d whilst initialising SD card\n",
1368 		mmc_hostname(host), err);
1369 
1370 	return err;
1371 }
1372