xref: /openbmc/u-boot/drivers/mmc/mmc.c (revision 7382e691ca528785d9d3ca8b74c4811b4f0bfe07)
1 /*
2  * Copyright 2008, Freescale Semiconductor, Inc
3  * Andy Fleming
4  *
5  * Based vaguely on the Linux code
6  *
7  * SPDX-License-Identifier:	GPL-2.0+
8  */
9 
10 #include <config.h>
11 #include <common.h>
12 #include <command.h>
13 #include <dm.h>
14 #include <dm/device-internal.h>
15 #include <errno.h>
16 #include <mmc.h>
17 #include <part.h>
18 #include <power/regulator.h>
19 #include <malloc.h>
20 #include <memalign.h>
21 #include <linux/list.h>
22 #include <div64.h>
23 #include "mmc_private.h"
24 
25 static const unsigned int sd_au_size[] = {
26 	0,		SZ_16K / 512,		SZ_32K / 512,
27 	SZ_64K / 512,	SZ_128K / 512,		SZ_256K / 512,
28 	SZ_512K / 512,	SZ_1M / 512,		SZ_2M / 512,
29 	SZ_4M / 512,	SZ_8M / 512,		(SZ_8M + SZ_4M) / 512,
30 	SZ_16M / 512,	(SZ_16M + SZ_8M) / 512,	SZ_32M / 512,	SZ_64M / 512,
31 };
32 
33 #if CONFIG_IS_ENABLED(MMC_TINY)
34 static struct mmc mmc_static;
35 struct mmc *find_mmc_device(int dev_num)
36 {
37 	return &mmc_static;
38 }
39 
40 void mmc_do_preinit(void)
41 {
42 	struct mmc *m = &mmc_static;
43 #ifdef CONFIG_FSL_ESDHC_ADAPTER_IDENT
44 	mmc_set_preinit(m, 1);
45 #endif
46 	if (m->preinit)
47 		mmc_start_init(m);
48 }
49 
50 struct blk_desc *mmc_get_blk_desc(struct mmc *mmc)
51 {
52 	return &mmc->block_dev;
53 }
54 #endif
55 
56 #if !CONFIG_IS_ENABLED(DM_MMC)
57 __weak int board_mmc_getwp(struct mmc *mmc)
58 {
59 	return -1;
60 }
61 
62 int mmc_getwp(struct mmc *mmc)
63 {
64 	int wp;
65 
66 	wp = board_mmc_getwp(mmc);
67 
68 	if (wp < 0) {
69 		if (mmc->cfg->ops->getwp)
70 			wp = mmc->cfg->ops->getwp(mmc);
71 		else
72 			wp = 0;
73 	}
74 
75 	return wp;
76 }
77 
78 __weak int board_mmc_getcd(struct mmc *mmc)
79 {
80 	return -1;
81 }
82 #endif
83 
84 #ifdef CONFIG_MMC_TRACE
85 void mmmc_trace_before_send(struct mmc *mmc, struct mmc_cmd *cmd)
86 {
87 	printf("CMD_SEND:%d\n", cmd->cmdidx);
88 	printf("\t\tARG\t\t\t 0x%08X\n", cmd->cmdarg);
89 }
90 
91 void mmmc_trace_after_send(struct mmc *mmc, struct mmc_cmd *cmd, int ret)
92 {
93 	int i;
94 	u8 *ptr;
95 
96 	if (ret) {
97 		printf("\t\tRET\t\t\t %d\n", ret);
98 	} else {
99 		switch (cmd->resp_type) {
100 		case MMC_RSP_NONE:
101 			printf("\t\tMMC_RSP_NONE\n");
102 			break;
103 		case MMC_RSP_R1:
104 			printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n",
105 				cmd->response[0]);
106 			break;
107 		case MMC_RSP_R1b:
108 			printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n",
109 				cmd->response[0]);
110 			break;
111 		case MMC_RSP_R2:
112 			printf("\t\tMMC_RSP_R2\t\t 0x%08X \n",
113 				cmd->response[0]);
114 			printf("\t\t          \t\t 0x%08X \n",
115 				cmd->response[1]);
116 			printf("\t\t          \t\t 0x%08X \n",
117 				cmd->response[2]);
118 			printf("\t\t          \t\t 0x%08X \n",
119 				cmd->response[3]);
120 			printf("\n");
121 			printf("\t\t\t\t\tDUMPING DATA\n");
122 			for (i = 0; i < 4; i++) {
123 				int j;
124 				printf("\t\t\t\t\t%03d - ", i*4);
125 				ptr = (u8 *)&cmd->response[i];
126 				ptr += 3;
127 				for (j = 0; j < 4; j++)
128 					printf("%02X ", *ptr--);
129 				printf("\n");
130 			}
131 			break;
132 		case MMC_RSP_R3:
133 			printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n",
134 				cmd->response[0]);
135 			break;
136 		default:
137 			printf("\t\tERROR MMC rsp not supported\n");
138 			break;
139 		}
140 	}
141 }
142 
143 void mmc_trace_state(struct mmc *mmc, struct mmc_cmd *cmd)
144 {
145 	int status;
146 
147 	status = (cmd->response[0] & MMC_STATUS_CURR_STATE) >> 9;
148 	printf("CURR STATE:%d\n", status);
149 }
150 #endif
151 
152 #if !CONFIG_IS_ENABLED(DM_MMC)
153 int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
154 {
155 	int ret;
156 
157 	mmmc_trace_before_send(mmc, cmd);
158 	ret = mmc->cfg->ops->send_cmd(mmc, cmd, data);
159 	mmmc_trace_after_send(mmc, cmd, ret);
160 
161 	return ret;
162 }
163 #endif
164 
165 int mmc_send_status(struct mmc *mmc, int timeout)
166 {
167 	struct mmc_cmd cmd;
168 	int err, retries = 5;
169 
170 	cmd.cmdidx = MMC_CMD_SEND_STATUS;
171 	cmd.resp_type = MMC_RSP_R1;
172 	if (!mmc_host_is_spi(mmc))
173 		cmd.cmdarg = mmc->rca << 16;
174 
175 	while (1) {
176 		err = mmc_send_cmd(mmc, &cmd, NULL);
177 		if (!err) {
178 			if ((cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) &&
179 			    (cmd.response[0] & MMC_STATUS_CURR_STATE) !=
180 			     MMC_STATE_PRG)
181 				break;
182 			else if (cmd.response[0] & MMC_STATUS_MASK) {
183 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
184 				printf("Status Error: 0x%08X\n",
185 					cmd.response[0]);
186 #endif
187 				return -ECOMM;
188 			}
189 		} else if (--retries < 0)
190 			return err;
191 
192 		if (timeout-- <= 0)
193 			break;
194 
195 		udelay(1000);
196 	}
197 
198 	mmc_trace_state(mmc, &cmd);
199 	if (timeout <= 0) {
200 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
201 		printf("Timeout waiting card ready\n");
202 #endif
203 		return -ETIMEDOUT;
204 	}
205 
206 	return 0;
207 }
208 
209 int mmc_set_blocklen(struct mmc *mmc, int len)
210 {
211 	struct mmc_cmd cmd;
212 
213 	if (mmc->ddr_mode)
214 		return 0;
215 
216 	cmd.cmdidx = MMC_CMD_SET_BLOCKLEN;
217 	cmd.resp_type = MMC_RSP_R1;
218 	cmd.cmdarg = len;
219 
220 	return mmc_send_cmd(mmc, &cmd, NULL);
221 }
222 
223 static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start,
224 			   lbaint_t blkcnt)
225 {
226 	struct mmc_cmd cmd;
227 	struct mmc_data data;
228 
229 	if (blkcnt > 1)
230 		cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK;
231 	else
232 		cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK;
233 
234 	if (mmc->high_capacity)
235 		cmd.cmdarg = start;
236 	else
237 		cmd.cmdarg = start * mmc->read_bl_len;
238 
239 	cmd.resp_type = MMC_RSP_R1;
240 
241 	data.dest = dst;
242 	data.blocks = blkcnt;
243 	data.blocksize = mmc->read_bl_len;
244 	data.flags = MMC_DATA_READ;
245 
246 	if (mmc_send_cmd(mmc, &cmd, &data))
247 		return 0;
248 
249 	if (blkcnt > 1) {
250 		cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
251 		cmd.cmdarg = 0;
252 		cmd.resp_type = MMC_RSP_R1b;
253 		if (mmc_send_cmd(mmc, &cmd, NULL)) {
254 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
255 			printf("mmc fail to send stop cmd\n");
256 #endif
257 			return 0;
258 		}
259 	}
260 
261 	return blkcnt;
262 }
263 
264 #if CONFIG_IS_ENABLED(BLK)
265 ulong mmc_bread(struct udevice *dev, lbaint_t start, lbaint_t blkcnt, void *dst)
266 #else
267 ulong mmc_bread(struct blk_desc *block_dev, lbaint_t start, lbaint_t blkcnt,
268 		void *dst)
269 #endif
270 {
271 #if CONFIG_IS_ENABLED(BLK)
272 	struct blk_desc *block_dev = dev_get_uclass_platdata(dev);
273 #endif
274 	int dev_num = block_dev->devnum;
275 	int err;
276 	lbaint_t cur, blocks_todo = blkcnt;
277 
278 	if (blkcnt == 0)
279 		return 0;
280 
281 	struct mmc *mmc = find_mmc_device(dev_num);
282 	if (!mmc)
283 		return 0;
284 
285 	if (CONFIG_IS_ENABLED(MMC_TINY))
286 		err = mmc_switch_part(mmc, block_dev->hwpart);
287 	else
288 		err = blk_dselect_hwpart(block_dev, block_dev->hwpart);
289 
290 	if (err < 0)
291 		return 0;
292 
293 	if ((start + blkcnt) > block_dev->lba) {
294 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
295 		printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n",
296 			start + blkcnt, block_dev->lba);
297 #endif
298 		return 0;
299 	}
300 
301 	if (mmc_set_blocklen(mmc, mmc->read_bl_len)) {
302 		debug("%s: Failed to set blocklen\n", __func__);
303 		return 0;
304 	}
305 
306 	do {
307 		cur = (blocks_todo > mmc->cfg->b_max) ?
308 			mmc->cfg->b_max : blocks_todo;
309 		if (mmc_read_blocks(mmc, dst, start, cur) != cur) {
310 			debug("%s: Failed to read blocks\n", __func__);
311 			return 0;
312 		}
313 		blocks_todo -= cur;
314 		start += cur;
315 		dst += cur * mmc->read_bl_len;
316 	} while (blocks_todo > 0);
317 
318 	return blkcnt;
319 }
320 
321 static int mmc_go_idle(struct mmc *mmc)
322 {
323 	struct mmc_cmd cmd;
324 	int err;
325 
326 	udelay(1000);
327 
328 	cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
329 	cmd.cmdarg = 0;
330 	cmd.resp_type = MMC_RSP_NONE;
331 
332 	err = mmc_send_cmd(mmc, &cmd, NULL);
333 
334 	if (err)
335 		return err;
336 
337 	udelay(2000);
338 
339 	return 0;
340 }
341 
342 static int sd_send_op_cond(struct mmc *mmc)
343 {
344 	int timeout = 1000;
345 	int err;
346 	struct mmc_cmd cmd;
347 
348 	while (1) {
349 		cmd.cmdidx = MMC_CMD_APP_CMD;
350 		cmd.resp_type = MMC_RSP_R1;
351 		cmd.cmdarg = 0;
352 
353 		err = mmc_send_cmd(mmc, &cmd, NULL);
354 
355 		if (err)
356 			return err;
357 
358 		cmd.cmdidx = SD_CMD_APP_SEND_OP_COND;
359 		cmd.resp_type = MMC_RSP_R3;
360 
361 		/*
362 		 * Most cards do not answer if some reserved bits
363 		 * in the ocr are set. However, Some controller
364 		 * can set bit 7 (reserved for low voltages), but
365 		 * how to manage low voltages SD card is not yet
366 		 * specified.
367 		 */
368 		cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 :
369 			(mmc->cfg->voltages & 0xff8000);
370 
371 		if (mmc->version == SD_VERSION_2)
372 			cmd.cmdarg |= OCR_HCS;
373 
374 		err = mmc_send_cmd(mmc, &cmd, NULL);
375 
376 		if (err)
377 			return err;
378 
379 		if (cmd.response[0] & OCR_BUSY)
380 			break;
381 
382 		if (timeout-- <= 0)
383 			return -EOPNOTSUPP;
384 
385 		udelay(1000);
386 	}
387 
388 	if (mmc->version != SD_VERSION_2)
389 		mmc->version = SD_VERSION_1_0;
390 
391 	if (mmc_host_is_spi(mmc)) { /* read OCR for spi */
392 		cmd.cmdidx = MMC_CMD_SPI_READ_OCR;
393 		cmd.resp_type = MMC_RSP_R3;
394 		cmd.cmdarg = 0;
395 
396 		err = mmc_send_cmd(mmc, &cmd, NULL);
397 
398 		if (err)
399 			return err;
400 	}
401 
402 	mmc->ocr = cmd.response[0];
403 
404 	mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
405 	mmc->rca = 0;
406 
407 	return 0;
408 }
409 
410 static int mmc_send_op_cond_iter(struct mmc *mmc, int use_arg)
411 {
412 	struct mmc_cmd cmd;
413 	int err;
414 
415 	cmd.cmdidx = MMC_CMD_SEND_OP_COND;
416 	cmd.resp_type = MMC_RSP_R3;
417 	cmd.cmdarg = 0;
418 	if (use_arg && !mmc_host_is_spi(mmc))
419 		cmd.cmdarg = OCR_HCS |
420 			(mmc->cfg->voltages &
421 			(mmc->ocr & OCR_VOLTAGE_MASK)) |
422 			(mmc->ocr & OCR_ACCESS_MODE);
423 
424 	err = mmc_send_cmd(mmc, &cmd, NULL);
425 	if (err)
426 		return err;
427 	mmc->ocr = cmd.response[0];
428 	return 0;
429 }
430 
431 static int mmc_send_op_cond(struct mmc *mmc)
432 {
433 	int err, i;
434 
435 	/* Some cards seem to need this */
436 	mmc_go_idle(mmc);
437 
438  	/* Asking to the card its capabilities */
439 	for (i = 0; i < 2; i++) {
440 		err = mmc_send_op_cond_iter(mmc, i != 0);
441 		if (err)
442 			return err;
443 
444 		/* exit if not busy (flag seems to be inverted) */
445 		if (mmc->ocr & OCR_BUSY)
446 			break;
447 	}
448 	mmc->op_cond_pending = 1;
449 	return 0;
450 }
451 
452 static int mmc_complete_op_cond(struct mmc *mmc)
453 {
454 	struct mmc_cmd cmd;
455 	int timeout = 1000;
456 	uint start;
457 	int err;
458 
459 	mmc->op_cond_pending = 0;
460 	if (!(mmc->ocr & OCR_BUSY)) {
461 		/* Some cards seem to need this */
462 		mmc_go_idle(mmc);
463 
464 		start = get_timer(0);
465 		while (1) {
466 			err = mmc_send_op_cond_iter(mmc, 1);
467 			if (err)
468 				return err;
469 			if (mmc->ocr & OCR_BUSY)
470 				break;
471 			if (get_timer(start) > timeout)
472 				return -EOPNOTSUPP;
473 			udelay(100);
474 		}
475 	}
476 
477 	if (mmc_host_is_spi(mmc)) { /* read OCR for spi */
478 		cmd.cmdidx = MMC_CMD_SPI_READ_OCR;
479 		cmd.resp_type = MMC_RSP_R3;
480 		cmd.cmdarg = 0;
481 
482 		err = mmc_send_cmd(mmc, &cmd, NULL);
483 
484 		if (err)
485 			return err;
486 
487 		mmc->ocr = cmd.response[0];
488 	}
489 
490 	mmc->version = MMC_VERSION_UNKNOWN;
491 
492 	mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
493 	mmc->rca = 1;
494 
495 	return 0;
496 }
497 
498 
499 static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd)
500 {
501 	struct mmc_cmd cmd;
502 	struct mmc_data data;
503 	int err;
504 
505 	/* Get the Card Status Register */
506 	cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
507 	cmd.resp_type = MMC_RSP_R1;
508 	cmd.cmdarg = 0;
509 
510 	data.dest = (char *)ext_csd;
511 	data.blocks = 1;
512 	data.blocksize = MMC_MAX_BLOCK_LEN;
513 	data.flags = MMC_DATA_READ;
514 
515 	err = mmc_send_cmd(mmc, &cmd, &data);
516 
517 	return err;
518 }
519 
520 int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
521 {
522 	struct mmc_cmd cmd;
523 	int timeout = 1000;
524 	int retries = 3;
525 	int ret;
526 
527 	cmd.cmdidx = MMC_CMD_SWITCH;
528 	cmd.resp_type = MMC_RSP_R1b;
529 	cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
530 				 (index << 16) |
531 				 (value << 8);
532 
533 	while (retries > 0) {
534 		ret = mmc_send_cmd(mmc, &cmd, NULL);
535 
536 		/* Waiting for the ready status */
537 		if (!ret) {
538 			ret = mmc_send_status(mmc, timeout);
539 			return ret;
540 		}
541 
542 		retries--;
543 	}
544 
545 	return ret;
546 
547 }
548 
549 static int mmc_change_freq(struct mmc *mmc)
550 {
551 	ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
552 	char cardtype;
553 	int err;
554 
555 	mmc->card_caps = 0;
556 
557 	if (mmc_host_is_spi(mmc))
558 		return 0;
559 
560 	/* Only version 4 supports high-speed */
561 	if (mmc->version < MMC_VERSION_4)
562 		return 0;
563 
564 	mmc->card_caps |= MMC_MODE_4BIT | MMC_MODE_8BIT;
565 
566 	err = mmc_send_ext_csd(mmc, ext_csd);
567 
568 	if (err)
569 		return err;
570 
571 	cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf;
572 
573 	err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
574 
575 	if (err)
576 		return err;
577 
578 	/* Now check to see that it worked */
579 	err = mmc_send_ext_csd(mmc, ext_csd);
580 
581 	if (err)
582 		return err;
583 
584 	/* No high-speed support */
585 	if (!ext_csd[EXT_CSD_HS_TIMING])
586 		return 0;
587 
588 	/* High Speed is set, there are two types: 52MHz and 26MHz */
589 	if (cardtype & EXT_CSD_CARD_TYPE_52) {
590 		if (cardtype & EXT_CSD_CARD_TYPE_DDR_1_8V)
591 			mmc->card_caps |= MMC_MODE_DDR_52MHz;
592 		mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
593 	} else {
594 		mmc->card_caps |= MMC_MODE_HS;
595 	}
596 
597 	return 0;
598 }
599 
600 static int mmc_set_capacity(struct mmc *mmc, int part_num)
601 {
602 	switch (part_num) {
603 	case 0:
604 		mmc->capacity = mmc->capacity_user;
605 		break;
606 	case 1:
607 	case 2:
608 		mmc->capacity = mmc->capacity_boot;
609 		break;
610 	case 3:
611 		mmc->capacity = mmc->capacity_rpmb;
612 		break;
613 	case 4:
614 	case 5:
615 	case 6:
616 	case 7:
617 		mmc->capacity = mmc->capacity_gp[part_num - 4];
618 		break;
619 	default:
620 		return -1;
621 	}
622 
623 	mmc_get_blk_desc(mmc)->lba = lldiv(mmc->capacity, mmc->read_bl_len);
624 
625 	return 0;
626 }
627 
628 int mmc_switch_part(struct mmc *mmc, unsigned int part_num)
629 {
630 	int ret;
631 
632 	ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
633 			 (mmc->part_config & ~PART_ACCESS_MASK)
634 			 | (part_num & PART_ACCESS_MASK));
635 
636 	/*
637 	 * Set the capacity if the switch succeeded or was intended
638 	 * to return to representing the raw device.
639 	 */
640 	if ((ret == 0) || ((ret == -ENODEV) && (part_num == 0))) {
641 		ret = mmc_set_capacity(mmc, part_num);
642 		mmc_get_blk_desc(mmc)->hwpart = part_num;
643 	}
644 
645 	return ret;
646 }
647 
648 int mmc_hwpart_config(struct mmc *mmc,
649 		      const struct mmc_hwpart_conf *conf,
650 		      enum mmc_hwpart_conf_mode mode)
651 {
652 	u8 part_attrs = 0;
653 	u32 enh_size_mult;
654 	u32 enh_start_addr;
655 	u32 gp_size_mult[4];
656 	u32 max_enh_size_mult;
657 	u32 tot_enh_size_mult = 0;
658 	u8 wr_rel_set;
659 	int i, pidx, err;
660 	ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
661 
662 	if (mode < MMC_HWPART_CONF_CHECK || mode > MMC_HWPART_CONF_COMPLETE)
663 		return -EINVAL;
664 
665 	if (IS_SD(mmc) || (mmc->version < MMC_VERSION_4_41)) {
666 		printf("eMMC >= 4.4 required for enhanced user data area\n");
667 		return -EMEDIUMTYPE;
668 	}
669 
670 	if (!(mmc->part_support & PART_SUPPORT)) {
671 		printf("Card does not support partitioning\n");
672 		return -EMEDIUMTYPE;
673 	}
674 
675 	if (!mmc->hc_wp_grp_size) {
676 		printf("Card does not define HC WP group size\n");
677 		return -EMEDIUMTYPE;
678 	}
679 
680 	/* check partition alignment and total enhanced size */
681 	if (conf->user.enh_size) {
682 		if (conf->user.enh_size % mmc->hc_wp_grp_size ||
683 		    conf->user.enh_start % mmc->hc_wp_grp_size) {
684 			printf("User data enhanced area not HC WP group "
685 			       "size aligned\n");
686 			return -EINVAL;
687 		}
688 		part_attrs |= EXT_CSD_ENH_USR;
689 		enh_size_mult = conf->user.enh_size / mmc->hc_wp_grp_size;
690 		if (mmc->high_capacity) {
691 			enh_start_addr = conf->user.enh_start;
692 		} else {
693 			enh_start_addr = (conf->user.enh_start << 9);
694 		}
695 	} else {
696 		enh_size_mult = 0;
697 		enh_start_addr = 0;
698 	}
699 	tot_enh_size_mult += enh_size_mult;
700 
701 	for (pidx = 0; pidx < 4; pidx++) {
702 		if (conf->gp_part[pidx].size % mmc->hc_wp_grp_size) {
703 			printf("GP%i partition not HC WP group size "
704 			       "aligned\n", pidx+1);
705 			return -EINVAL;
706 		}
707 		gp_size_mult[pidx] = conf->gp_part[pidx].size / mmc->hc_wp_grp_size;
708 		if (conf->gp_part[pidx].size && conf->gp_part[pidx].enhanced) {
709 			part_attrs |= EXT_CSD_ENH_GP(pidx);
710 			tot_enh_size_mult += gp_size_mult[pidx];
711 		}
712 	}
713 
714 	if (part_attrs && ! (mmc->part_support & ENHNCD_SUPPORT)) {
715 		printf("Card does not support enhanced attribute\n");
716 		return -EMEDIUMTYPE;
717 	}
718 
719 	err = mmc_send_ext_csd(mmc, ext_csd);
720 	if (err)
721 		return err;
722 
723 	max_enh_size_mult =
724 		(ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT+2] << 16) +
725 		(ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT+1] << 8) +
726 		ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT];
727 	if (tot_enh_size_mult > max_enh_size_mult) {
728 		printf("Total enhanced size exceeds maximum (%u > %u)\n",
729 		       tot_enh_size_mult, max_enh_size_mult);
730 		return -EMEDIUMTYPE;
731 	}
732 
733 	/* The default value of EXT_CSD_WR_REL_SET is device
734 	 * dependent, the values can only be changed if the
735 	 * EXT_CSD_HS_CTRL_REL bit is set. The values can be
736 	 * changed only once and before partitioning is completed. */
737 	wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET];
738 	if (conf->user.wr_rel_change) {
739 		if (conf->user.wr_rel_set)
740 			wr_rel_set |= EXT_CSD_WR_DATA_REL_USR;
741 		else
742 			wr_rel_set &= ~EXT_CSD_WR_DATA_REL_USR;
743 	}
744 	for (pidx = 0; pidx < 4; pidx++) {
745 		if (conf->gp_part[pidx].wr_rel_change) {
746 			if (conf->gp_part[pidx].wr_rel_set)
747 				wr_rel_set |= EXT_CSD_WR_DATA_REL_GP(pidx);
748 			else
749 				wr_rel_set &= ~EXT_CSD_WR_DATA_REL_GP(pidx);
750 		}
751 	}
752 
753 	if (wr_rel_set != ext_csd[EXT_CSD_WR_REL_SET] &&
754 	    !(ext_csd[EXT_CSD_WR_REL_PARAM] & EXT_CSD_HS_CTRL_REL)) {
755 		puts("Card does not support host controlled partition write "
756 		     "reliability settings\n");
757 		return -EMEDIUMTYPE;
758 	}
759 
760 	if (ext_csd[EXT_CSD_PARTITION_SETTING] &
761 	    EXT_CSD_PARTITION_SETTING_COMPLETED) {
762 		printf("Card already partitioned\n");
763 		return -EPERM;
764 	}
765 
766 	if (mode == MMC_HWPART_CONF_CHECK)
767 		return 0;
768 
769 	/* Partitioning requires high-capacity size definitions */
770 	if (!(ext_csd[EXT_CSD_ERASE_GROUP_DEF] & 0x01)) {
771 		err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
772 				 EXT_CSD_ERASE_GROUP_DEF, 1);
773 
774 		if (err)
775 			return err;
776 
777 		ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1;
778 
779 		/* update erase group size to be high-capacity */
780 		mmc->erase_grp_size =
781 			ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 1024;
782 
783 	}
784 
785 	/* all OK, write the configuration */
786 	for (i = 0; i < 4; i++) {
787 		err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
788 				 EXT_CSD_ENH_START_ADDR+i,
789 				 (enh_start_addr >> (i*8)) & 0xFF);
790 		if (err)
791 			return err;
792 	}
793 	for (i = 0; i < 3; i++) {
794 		err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
795 				 EXT_CSD_ENH_SIZE_MULT+i,
796 				 (enh_size_mult >> (i*8)) & 0xFF);
797 		if (err)
798 			return err;
799 	}
800 	for (pidx = 0; pidx < 4; pidx++) {
801 		for (i = 0; i < 3; i++) {
802 			err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
803 					 EXT_CSD_GP_SIZE_MULT+pidx*3+i,
804 					 (gp_size_mult[pidx] >> (i*8)) & 0xFF);
805 			if (err)
806 				return err;
807 		}
808 	}
809 	err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
810 			 EXT_CSD_PARTITIONS_ATTRIBUTE, part_attrs);
811 	if (err)
812 		return err;
813 
814 	if (mode == MMC_HWPART_CONF_SET)
815 		return 0;
816 
817 	/* The WR_REL_SET is a write-once register but shall be
818 	 * written before setting PART_SETTING_COMPLETED. As it is
819 	 * write-once we can only write it when completing the
820 	 * partitioning. */
821 	if (wr_rel_set != ext_csd[EXT_CSD_WR_REL_SET]) {
822 		err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
823 				 EXT_CSD_WR_REL_SET, wr_rel_set);
824 		if (err)
825 			return err;
826 	}
827 
828 	/* Setting PART_SETTING_COMPLETED confirms the partition
829 	 * configuration but it only becomes effective after power
830 	 * cycle, so we do not adjust the partition related settings
831 	 * in the mmc struct. */
832 
833 	err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
834 			 EXT_CSD_PARTITION_SETTING,
835 			 EXT_CSD_PARTITION_SETTING_COMPLETED);
836 	if (err)
837 		return err;
838 
839 	return 0;
840 }
841 
842 #if !CONFIG_IS_ENABLED(DM_MMC)
843 int mmc_getcd(struct mmc *mmc)
844 {
845 	int cd;
846 
847 	cd = board_mmc_getcd(mmc);
848 
849 	if (cd < 0) {
850 		if (mmc->cfg->ops->getcd)
851 			cd = mmc->cfg->ops->getcd(mmc);
852 		else
853 			cd = 1;
854 	}
855 
856 	return cd;
857 }
858 #endif
859 
860 static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp)
861 {
862 	struct mmc_cmd cmd;
863 	struct mmc_data data;
864 
865 	/* Switch the frequency */
866 	cmd.cmdidx = SD_CMD_SWITCH_FUNC;
867 	cmd.resp_type = MMC_RSP_R1;
868 	cmd.cmdarg = (mode << 31) | 0xffffff;
869 	cmd.cmdarg &= ~(0xf << (group * 4));
870 	cmd.cmdarg |= value << (group * 4);
871 
872 	data.dest = (char *)resp;
873 	data.blocksize = 64;
874 	data.blocks = 1;
875 	data.flags = MMC_DATA_READ;
876 
877 	return mmc_send_cmd(mmc, &cmd, &data);
878 }
879 
880 
881 static int sd_change_freq(struct mmc *mmc)
882 {
883 	int err;
884 	struct mmc_cmd cmd;
885 	ALLOC_CACHE_ALIGN_BUFFER(__be32, scr, 2);
886 	ALLOC_CACHE_ALIGN_BUFFER(__be32, switch_status, 16);
887 	struct mmc_data data;
888 	int timeout;
889 
890 	mmc->card_caps = 0;
891 
892 	if (mmc_host_is_spi(mmc))
893 		return 0;
894 
895 	/* Read the SCR to find out if this card supports higher speeds */
896 	cmd.cmdidx = MMC_CMD_APP_CMD;
897 	cmd.resp_type = MMC_RSP_R1;
898 	cmd.cmdarg = mmc->rca << 16;
899 
900 	err = mmc_send_cmd(mmc, &cmd, NULL);
901 
902 	if (err)
903 		return err;
904 
905 	cmd.cmdidx = SD_CMD_APP_SEND_SCR;
906 	cmd.resp_type = MMC_RSP_R1;
907 	cmd.cmdarg = 0;
908 
909 	timeout = 3;
910 
911 retry_scr:
912 	data.dest = (char *)scr;
913 	data.blocksize = 8;
914 	data.blocks = 1;
915 	data.flags = MMC_DATA_READ;
916 
917 	err = mmc_send_cmd(mmc, &cmd, &data);
918 
919 	if (err) {
920 		if (timeout--)
921 			goto retry_scr;
922 
923 		return err;
924 	}
925 
926 	mmc->scr[0] = __be32_to_cpu(scr[0]);
927 	mmc->scr[1] = __be32_to_cpu(scr[1]);
928 
929 	switch ((mmc->scr[0] >> 24) & 0xf) {
930 	case 0:
931 		mmc->version = SD_VERSION_1_0;
932 		break;
933 	case 1:
934 		mmc->version = SD_VERSION_1_10;
935 		break;
936 	case 2:
937 		mmc->version = SD_VERSION_2;
938 		if ((mmc->scr[0] >> 15) & 0x1)
939 			mmc->version = SD_VERSION_3;
940 		break;
941 	default:
942 		mmc->version = SD_VERSION_1_0;
943 		break;
944 	}
945 
946 	if (mmc->scr[0] & SD_DATA_4BIT)
947 		mmc->card_caps |= MMC_MODE_4BIT;
948 
949 	/* Version 1.0 doesn't support switching */
950 	if (mmc->version == SD_VERSION_1_0)
951 		return 0;
952 
953 	timeout = 4;
954 	while (timeout--) {
955 		err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
956 				(u8 *)switch_status);
957 
958 		if (err)
959 			return err;
960 
961 		/* The high-speed function is busy.  Try again */
962 		if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
963 			break;
964 	}
965 
966 	/* If high-speed isn't supported, we return */
967 	if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
968 		return 0;
969 
970 	/*
971 	 * If the host doesn't support SD_HIGHSPEED, do not switch card to
972 	 * HIGHSPEED mode even if the card support SD_HIGHSPPED.
973 	 * This can avoid furthur problem when the card runs in different
974 	 * mode between the host.
975 	 */
976 	if (!((mmc->cfg->host_caps & MMC_MODE_HS_52MHz) &&
977 		(mmc->cfg->host_caps & MMC_MODE_HS)))
978 		return 0;
979 
980 	err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status);
981 
982 	if (err)
983 		return err;
984 
985 	if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
986 		mmc->card_caps |= MMC_MODE_HS;
987 
988 	return 0;
989 }
990 
991 static int sd_read_ssr(struct mmc *mmc)
992 {
993 	int err, i;
994 	struct mmc_cmd cmd;
995 	ALLOC_CACHE_ALIGN_BUFFER(uint, ssr, 16);
996 	struct mmc_data data;
997 	int timeout = 3;
998 	unsigned int au, eo, et, es;
999 
1000 	cmd.cmdidx = MMC_CMD_APP_CMD;
1001 	cmd.resp_type = MMC_RSP_R1;
1002 	cmd.cmdarg = mmc->rca << 16;
1003 
1004 	err = mmc_send_cmd(mmc, &cmd, NULL);
1005 	if (err)
1006 		return err;
1007 
1008 	cmd.cmdidx = SD_CMD_APP_SD_STATUS;
1009 	cmd.resp_type = MMC_RSP_R1;
1010 	cmd.cmdarg = 0;
1011 
1012 retry_ssr:
1013 	data.dest = (char *)ssr;
1014 	data.blocksize = 64;
1015 	data.blocks = 1;
1016 	data.flags = MMC_DATA_READ;
1017 
1018 	err = mmc_send_cmd(mmc, &cmd, &data);
1019 	if (err) {
1020 		if (timeout--)
1021 			goto retry_ssr;
1022 
1023 		return err;
1024 	}
1025 
1026 	for (i = 0; i < 16; i++)
1027 		ssr[i] = be32_to_cpu(ssr[i]);
1028 
1029 	au = (ssr[2] >> 12) & 0xF;
1030 	if ((au <= 9) || (mmc->version == SD_VERSION_3)) {
1031 		mmc->ssr.au = sd_au_size[au];
1032 		es = (ssr[3] >> 24) & 0xFF;
1033 		es |= (ssr[2] & 0xFF) << 8;
1034 		et = (ssr[3] >> 18) & 0x3F;
1035 		if (es && et) {
1036 			eo = (ssr[3] >> 16) & 0x3;
1037 			mmc->ssr.erase_timeout = (et * 1000) / es;
1038 			mmc->ssr.erase_offset = eo * 1000;
1039 		}
1040 	} else {
1041 		debug("Invalid Allocation Unit Size.\n");
1042 	}
1043 
1044 	return 0;
1045 }
1046 
1047 /* frequency bases */
1048 /* divided by 10 to be nice to platforms without floating point */
1049 static const int fbase[] = {
1050 	10000,
1051 	100000,
1052 	1000000,
1053 	10000000,
1054 };
1055 
1056 /* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
1057  * to platforms without floating point.
1058  */
1059 static const u8 multipliers[] = {
1060 	0,	/* reserved */
1061 	10,
1062 	12,
1063 	13,
1064 	15,
1065 	20,
1066 	25,
1067 	30,
1068 	35,
1069 	40,
1070 	45,
1071 	50,
1072 	55,
1073 	60,
1074 	70,
1075 	80,
1076 };
1077 
1078 #if !CONFIG_IS_ENABLED(DM_MMC)
1079 static void mmc_set_ios(struct mmc *mmc)
1080 {
1081 	if (mmc->cfg->ops->set_ios)
1082 		mmc->cfg->ops->set_ios(mmc);
1083 }
1084 #endif
1085 
1086 void mmc_set_clock(struct mmc *mmc, uint clock)
1087 {
1088 	if (clock > mmc->cfg->f_max)
1089 		clock = mmc->cfg->f_max;
1090 
1091 	if (clock < mmc->cfg->f_min)
1092 		clock = mmc->cfg->f_min;
1093 
1094 	mmc->clock = clock;
1095 
1096 	mmc_set_ios(mmc);
1097 }
1098 
1099 static void mmc_set_bus_width(struct mmc *mmc, uint width)
1100 {
1101 	mmc->bus_width = width;
1102 
1103 	mmc_set_ios(mmc);
1104 }
1105 
1106 static int sd_select_bus_freq_width(struct mmc *mmc)
1107 {
1108 	int err;
1109 	struct mmc_cmd cmd;
1110 
1111 	err = sd_change_freq(mmc);
1112 	if (err)
1113 		return err;
1114 
1115 	/* Restrict card's capabilities by what the host can do */
1116 	mmc->card_caps &= mmc->cfg->host_caps;
1117 
1118 	if (mmc->card_caps & MMC_MODE_4BIT) {
1119 		cmd.cmdidx = MMC_CMD_APP_CMD;
1120 		cmd.resp_type = MMC_RSP_R1;
1121 		cmd.cmdarg = mmc->rca << 16;
1122 
1123 		err = mmc_send_cmd(mmc, &cmd, NULL);
1124 		if (err)
1125 			return err;
1126 
1127 		cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
1128 		cmd.resp_type = MMC_RSP_R1;
1129 		cmd.cmdarg = 2;
1130 		err = mmc_send_cmd(mmc, &cmd, NULL);
1131 		if (err)
1132 			return err;
1133 
1134 		mmc_set_bus_width(mmc, 4);
1135 	}
1136 
1137 	err = sd_read_ssr(mmc);
1138 	if (err)
1139 		return err;
1140 
1141 	if (mmc->card_caps & MMC_MODE_HS)
1142 		mmc->tran_speed = 50000000;
1143 	else
1144 		mmc->tran_speed = 25000000;
1145 
1146 	return 0;
1147 }
1148 
1149 /*
1150  * read the compare the part of ext csd that is constant.
1151  * This can be used to check that the transfer is working
1152  * as expected.
1153  */
1154 static int mmc_read_and_compare_ext_csd(struct mmc *mmc)
1155 {
1156 	int err;
1157 	const u8 *ext_csd = mmc->ext_csd;
1158 	ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, MMC_MAX_BLOCK_LEN);
1159 
1160 	err = mmc_send_ext_csd(mmc, test_csd);
1161 	if (err)
1162 		return err;
1163 
1164 	/* Only compare read only fields */
1165 	if (ext_csd[EXT_CSD_PARTITIONING_SUPPORT]
1166 		== test_csd[EXT_CSD_PARTITIONING_SUPPORT] &&
1167 	    ext_csd[EXT_CSD_HC_WP_GRP_SIZE]
1168 		== test_csd[EXT_CSD_HC_WP_GRP_SIZE] &&
1169 	    ext_csd[EXT_CSD_REV]
1170 		== test_csd[EXT_CSD_REV] &&
1171 	    ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
1172 		== test_csd[EXT_CSD_HC_ERASE_GRP_SIZE] &&
1173 	    memcmp(&ext_csd[EXT_CSD_SEC_CNT],
1174 		   &test_csd[EXT_CSD_SEC_CNT], 4) == 0)
1175 		return 0;
1176 
1177 	return -EBADMSG;
1178 }
1179 
1180 static int mmc_select_bus_freq_width(struct mmc *mmc)
1181 {
1182 	/* An array of possible bus widths in order of preference */
1183 	static const unsigned int ext_csd_bits[] = {
1184 		EXT_CSD_DDR_BUS_WIDTH_8,
1185 		EXT_CSD_DDR_BUS_WIDTH_4,
1186 		EXT_CSD_BUS_WIDTH_8,
1187 		EXT_CSD_BUS_WIDTH_4,
1188 		EXT_CSD_BUS_WIDTH_1,
1189 	};
1190 	/* An array to map CSD bus widths to host cap bits */
1191 	static const unsigned int ext_to_hostcaps[] = {
1192 		[EXT_CSD_DDR_BUS_WIDTH_4] =
1193 			MMC_MODE_DDR_52MHz | MMC_MODE_4BIT,
1194 		[EXT_CSD_DDR_BUS_WIDTH_8] =
1195 			MMC_MODE_DDR_52MHz | MMC_MODE_8BIT,
1196 		[EXT_CSD_BUS_WIDTH_4] = MMC_MODE_4BIT,
1197 		[EXT_CSD_BUS_WIDTH_8] = MMC_MODE_8BIT,
1198 	};
1199 	/* An array to map chosen bus width to an integer */
1200 	static const unsigned int widths[] = {
1201 		8, 4, 8, 4, 1,
1202 	};
1203 	int err;
1204 	int idx;
1205 
1206 	err = mmc_change_freq(mmc);
1207 	if (err)
1208 		return err;
1209 
1210 	/* Restrict card's capabilities by what the host can do */
1211 	mmc->card_caps &= mmc->cfg->host_caps;
1212 
1213 	/* Only version 4 of MMC supports wider bus widths */
1214 	if (mmc->version < MMC_VERSION_4)
1215 		return 0;
1216 
1217 	if (!mmc->ext_csd) {
1218 		debug("No ext_csd found!\n"); /* this should enver happen */
1219 		return -ENOTSUPP;
1220 	}
1221 
1222 	for (idx = 0; idx < ARRAY_SIZE(ext_csd_bits); idx++) {
1223 		unsigned int extw = ext_csd_bits[idx];
1224 		unsigned int caps = ext_to_hostcaps[extw];
1225 		/*
1226 		 * If the bus width is still not changed,
1227 		 * don't try to set the default again.
1228 		 * Otherwise, recover from switch attempts
1229 		 * by switching to 1-bit bus width.
1230 		 */
1231 		if (extw == EXT_CSD_BUS_WIDTH_1 &&
1232 		    mmc->bus_width == 1) {
1233 			err = 0;
1234 			break;
1235 		}
1236 
1237 		/*
1238 		 * Check to make sure the card and controller support
1239 		 * these capabilities
1240 		 */
1241 		if ((mmc->card_caps & caps) != caps)
1242 			continue;
1243 
1244 		err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1245 				 EXT_CSD_BUS_WIDTH, extw);
1246 
1247 		if (err)
1248 			continue;
1249 
1250 		mmc->ddr_mode = (caps & MMC_MODE_DDR_52MHz) ? 1 : 0;
1251 		mmc_set_bus_width(mmc, widths[idx]);
1252 
1253 		err = mmc_read_and_compare_ext_csd(mmc);
1254 		if (!err)
1255 			break;
1256 	}
1257 
1258 	if (err)
1259 		return err;
1260 
1261 	if (mmc->card_caps & MMC_MODE_HS) {
1262 		if (mmc->card_caps & MMC_MODE_HS_52MHz)
1263 			mmc->tran_speed = 52000000;
1264 		else
1265 			mmc->tran_speed = 26000000;
1266 	}
1267 
1268 	return err;
1269 }
1270 
1271 static int mmc_startup_v4(struct mmc *mmc)
1272 {
1273 	int err, i;
1274 	u64 capacity;
1275 	bool has_parts = false;
1276 	bool part_completed;
1277 	u8 *ext_csd;
1278 
1279 	if (IS_SD(mmc) || (mmc->version < MMC_VERSION_4))
1280 		return 0;
1281 
1282 	ext_csd = malloc_cache_aligned(MMC_MAX_BLOCK_LEN);
1283 	if (!ext_csd)
1284 		return -ENOMEM;
1285 
1286 	mmc->ext_csd = ext_csd;
1287 
1288 	/* check  ext_csd version and capacity */
1289 	err = mmc_send_ext_csd(mmc, ext_csd);
1290 	if (err)
1291 		return err;
1292 	if (ext_csd[EXT_CSD_REV] >= 2) {
1293 		/*
1294 		 * According to the JEDEC Standard, the value of
1295 		 * ext_csd's capacity is valid if the value is more
1296 		 * than 2GB
1297 		 */
1298 		capacity = ext_csd[EXT_CSD_SEC_CNT] << 0
1299 				| ext_csd[EXT_CSD_SEC_CNT + 1] << 8
1300 				| ext_csd[EXT_CSD_SEC_CNT + 2] << 16
1301 				| ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
1302 		capacity *= MMC_MAX_BLOCK_LEN;
1303 		if ((capacity >> 20) > 2 * 1024)
1304 			mmc->capacity_user = capacity;
1305 	}
1306 
1307 	switch (ext_csd[EXT_CSD_REV]) {
1308 	case 1:
1309 		mmc->version = MMC_VERSION_4_1;
1310 		break;
1311 	case 2:
1312 		mmc->version = MMC_VERSION_4_2;
1313 		break;
1314 	case 3:
1315 		mmc->version = MMC_VERSION_4_3;
1316 		break;
1317 	case 5:
1318 		mmc->version = MMC_VERSION_4_41;
1319 		break;
1320 	case 6:
1321 		mmc->version = MMC_VERSION_4_5;
1322 		break;
1323 	case 7:
1324 		mmc->version = MMC_VERSION_5_0;
1325 		break;
1326 	case 8:
1327 		mmc->version = MMC_VERSION_5_1;
1328 		break;
1329 	}
1330 
1331 	/* The partition data may be non-zero but it is only
1332 	 * effective if PARTITION_SETTING_COMPLETED is set in
1333 	 * EXT_CSD, so ignore any data if this bit is not set,
1334 	 * except for enabling the high-capacity group size
1335 	 * definition (see below).
1336 	 */
1337 	part_completed = !!(ext_csd[EXT_CSD_PARTITION_SETTING] &
1338 			    EXT_CSD_PARTITION_SETTING_COMPLETED);
1339 
1340 	/* store the partition info of emmc */
1341 	mmc->part_support = ext_csd[EXT_CSD_PARTITIONING_SUPPORT];
1342 	if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) ||
1343 	    ext_csd[EXT_CSD_BOOT_MULT])
1344 		mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
1345 	if (part_completed &&
1346 	    (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & ENHNCD_SUPPORT))
1347 		mmc->part_attr = ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE];
1348 
1349 	mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17;
1350 
1351 	mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17;
1352 
1353 	for (i = 0; i < 4; i++) {
1354 		int idx = EXT_CSD_GP_SIZE_MULT + i * 3;
1355 		uint mult = (ext_csd[idx + 2] << 16) +
1356 			(ext_csd[idx + 1] << 8) + ext_csd[idx];
1357 		if (mult)
1358 			has_parts = true;
1359 		if (!part_completed)
1360 			continue;
1361 		mmc->capacity_gp[i] = mult;
1362 		mmc->capacity_gp[i] *=
1363 			ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
1364 		mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1365 		mmc->capacity_gp[i] <<= 19;
1366 	}
1367 
1368 	if (part_completed) {
1369 		mmc->enh_user_size =
1370 			(ext_csd[EXT_CSD_ENH_SIZE_MULT + 2] << 16) +
1371 			(ext_csd[EXT_CSD_ENH_SIZE_MULT + 1] << 8) +
1372 			ext_csd[EXT_CSD_ENH_SIZE_MULT];
1373 		mmc->enh_user_size *= ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
1374 		mmc->enh_user_size *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1375 		mmc->enh_user_size <<= 19;
1376 		mmc->enh_user_start =
1377 			(ext_csd[EXT_CSD_ENH_START_ADDR + 3] << 24) +
1378 			(ext_csd[EXT_CSD_ENH_START_ADDR + 2] << 16) +
1379 			(ext_csd[EXT_CSD_ENH_START_ADDR + 1] << 8) +
1380 			ext_csd[EXT_CSD_ENH_START_ADDR];
1381 		if (mmc->high_capacity)
1382 			mmc->enh_user_start <<= 9;
1383 	}
1384 
1385 	/*
1386 	 * Host needs to enable ERASE_GRP_DEF bit if device is
1387 	 * partitioned. This bit will be lost every time after a reset
1388 	 * or power off. This will affect erase size.
1389 	 */
1390 	if (part_completed)
1391 		has_parts = true;
1392 	if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) &&
1393 	    (ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE] & PART_ENH_ATTRIB))
1394 		has_parts = true;
1395 	if (has_parts) {
1396 		err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1397 				 EXT_CSD_ERASE_GROUP_DEF, 1);
1398 
1399 		if (err)
1400 			return err;
1401 
1402 		ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1;
1403 	}
1404 
1405 	if (ext_csd[EXT_CSD_ERASE_GROUP_DEF] & 0x01) {
1406 		/* Read out group size from ext_csd */
1407 		mmc->erase_grp_size =
1408 			ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 1024;
1409 		/*
1410 		 * if high capacity and partition setting completed
1411 		 * SEC_COUNT is valid even if it is smaller than 2 GiB
1412 		 * JEDEC Standard JESD84-B45, 6.2.4
1413 		 */
1414 		if (mmc->high_capacity && part_completed) {
1415 			capacity = (ext_csd[EXT_CSD_SEC_CNT]) |
1416 				(ext_csd[EXT_CSD_SEC_CNT + 1] << 8) |
1417 				(ext_csd[EXT_CSD_SEC_CNT + 2] << 16) |
1418 				(ext_csd[EXT_CSD_SEC_CNT + 3] << 24);
1419 			capacity *= MMC_MAX_BLOCK_LEN;
1420 			mmc->capacity_user = capacity;
1421 		}
1422 	} else {
1423 		/* Calculate the group size from the csd value. */
1424 		int erase_gsz, erase_gmul;
1425 
1426 		erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
1427 		erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
1428 		mmc->erase_grp_size = (erase_gsz + 1)
1429 			* (erase_gmul + 1);
1430 	}
1431 
1432 	mmc->hc_wp_grp_size = 1024
1433 		* ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
1434 		* ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1435 
1436 	mmc->wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET];
1437 
1438 	return 0;
1439 }
1440 
1441 static int mmc_startup(struct mmc *mmc)
1442 {
1443 	int err, i;
1444 	uint mult, freq;
1445 	u64 cmult, csize;
1446 	struct mmc_cmd cmd;
1447 	struct blk_desc *bdesc;
1448 
1449 #ifdef CONFIG_MMC_SPI_CRC_ON
1450 	if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */
1451 		cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF;
1452 		cmd.resp_type = MMC_RSP_R1;
1453 		cmd.cmdarg = 1;
1454 		err = mmc_send_cmd(mmc, &cmd, NULL);
1455 
1456 		if (err)
1457 			return err;
1458 	}
1459 #endif
1460 
1461 	/* Put the Card in Identify Mode */
1462 	cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID :
1463 		MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */
1464 	cmd.resp_type = MMC_RSP_R2;
1465 	cmd.cmdarg = 0;
1466 
1467 	err = mmc_send_cmd(mmc, &cmd, NULL);
1468 
1469 	if (err)
1470 		return err;
1471 
1472 	memcpy(mmc->cid, cmd.response, 16);
1473 
1474 	/*
1475 	 * For MMC cards, set the Relative Address.
1476 	 * For SD cards, get the Relatvie Address.
1477 	 * This also puts the cards into Standby State
1478 	 */
1479 	if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
1480 		cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
1481 		cmd.cmdarg = mmc->rca << 16;
1482 		cmd.resp_type = MMC_RSP_R6;
1483 
1484 		err = mmc_send_cmd(mmc, &cmd, NULL);
1485 
1486 		if (err)
1487 			return err;
1488 
1489 		if (IS_SD(mmc))
1490 			mmc->rca = (cmd.response[0] >> 16) & 0xffff;
1491 	}
1492 
1493 	/* Get the Card-Specific Data */
1494 	cmd.cmdidx = MMC_CMD_SEND_CSD;
1495 	cmd.resp_type = MMC_RSP_R2;
1496 	cmd.cmdarg = mmc->rca << 16;
1497 
1498 	err = mmc_send_cmd(mmc, &cmd, NULL);
1499 
1500 	if (err)
1501 		return err;
1502 
1503 	mmc->csd[0] = cmd.response[0];
1504 	mmc->csd[1] = cmd.response[1];
1505 	mmc->csd[2] = cmd.response[2];
1506 	mmc->csd[3] = cmd.response[3];
1507 
1508 	if (mmc->version == MMC_VERSION_UNKNOWN) {
1509 		int version = (cmd.response[0] >> 26) & 0xf;
1510 
1511 		switch (version) {
1512 		case 0:
1513 			mmc->version = MMC_VERSION_1_2;
1514 			break;
1515 		case 1:
1516 			mmc->version = MMC_VERSION_1_4;
1517 			break;
1518 		case 2:
1519 			mmc->version = MMC_VERSION_2_2;
1520 			break;
1521 		case 3:
1522 			mmc->version = MMC_VERSION_3;
1523 			break;
1524 		case 4:
1525 			mmc->version = MMC_VERSION_4;
1526 			break;
1527 		default:
1528 			mmc->version = MMC_VERSION_1_2;
1529 			break;
1530 		}
1531 	}
1532 
1533 	/* divide frequency by 10, since the mults are 10x bigger */
1534 	freq = fbase[(cmd.response[0] & 0x7)];
1535 	mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
1536 
1537 	mmc->tran_speed = freq * mult;
1538 
1539 	mmc->dsr_imp = ((cmd.response[1] >> 12) & 0x1);
1540 	mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
1541 
1542 	if (IS_SD(mmc))
1543 		mmc->write_bl_len = mmc->read_bl_len;
1544 	else
1545 		mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
1546 
1547 	if (mmc->high_capacity) {
1548 		csize = (mmc->csd[1] & 0x3f) << 16
1549 			| (mmc->csd[2] & 0xffff0000) >> 16;
1550 		cmult = 8;
1551 	} else {
1552 		csize = (mmc->csd[1] & 0x3ff) << 2
1553 			| (mmc->csd[2] & 0xc0000000) >> 30;
1554 		cmult = (mmc->csd[2] & 0x00038000) >> 15;
1555 	}
1556 
1557 	mmc->capacity_user = (csize + 1) << (cmult + 2);
1558 	mmc->capacity_user *= mmc->read_bl_len;
1559 	mmc->capacity_boot = 0;
1560 	mmc->capacity_rpmb = 0;
1561 	for (i = 0; i < 4; i++)
1562 		mmc->capacity_gp[i] = 0;
1563 
1564 	if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN)
1565 		mmc->read_bl_len = MMC_MAX_BLOCK_LEN;
1566 
1567 	if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN)
1568 		mmc->write_bl_len = MMC_MAX_BLOCK_LEN;
1569 
1570 	if ((mmc->dsr_imp) && (0xffffffff != mmc->dsr)) {
1571 		cmd.cmdidx = MMC_CMD_SET_DSR;
1572 		cmd.cmdarg = (mmc->dsr & 0xffff) << 16;
1573 		cmd.resp_type = MMC_RSP_NONE;
1574 		if (mmc_send_cmd(mmc, &cmd, NULL))
1575 			printf("MMC: SET_DSR failed\n");
1576 	}
1577 
1578 	/* Select the card, and put it into Transfer Mode */
1579 	if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
1580 		cmd.cmdidx = MMC_CMD_SELECT_CARD;
1581 		cmd.resp_type = MMC_RSP_R1;
1582 		cmd.cmdarg = mmc->rca << 16;
1583 		err = mmc_send_cmd(mmc, &cmd, NULL);
1584 
1585 		if (err)
1586 			return err;
1587 	}
1588 
1589 	/*
1590 	 * For SD, its erase group is always one sector
1591 	 */
1592 	mmc->erase_grp_size = 1;
1593 	mmc->part_config = MMCPART_NOAVAILABLE;
1594 
1595 	err = mmc_startup_v4(mmc);
1596 	if (err)
1597 		return err;
1598 
1599 	err = mmc_set_capacity(mmc, mmc_get_blk_desc(mmc)->hwpart);
1600 	if (err)
1601 		return err;
1602 
1603 	if (IS_SD(mmc))
1604 		err = sd_select_bus_freq_width(mmc);
1605 	else
1606 		err = mmc_select_bus_freq_width(mmc);
1607 
1608 	if (err)
1609 		return err;
1610 
1611 	mmc_set_clock(mmc, mmc->tran_speed);
1612 
1613 	/* Fix the block length for DDR mode */
1614 	if (mmc->ddr_mode) {
1615 		mmc->read_bl_len = MMC_MAX_BLOCK_LEN;
1616 		mmc->write_bl_len = MMC_MAX_BLOCK_LEN;
1617 	}
1618 
1619 	/* fill in device description */
1620 	bdesc = mmc_get_blk_desc(mmc);
1621 	bdesc->lun = 0;
1622 	bdesc->hwpart = 0;
1623 	bdesc->type = 0;
1624 	bdesc->blksz = mmc->read_bl_len;
1625 	bdesc->log2blksz = LOG2(bdesc->blksz);
1626 	bdesc->lba = lldiv(mmc->capacity, mmc->read_bl_len);
1627 #if !defined(CONFIG_SPL_BUILD) || \
1628 		(defined(CONFIG_SPL_LIBCOMMON_SUPPORT) && \
1629 		!defined(CONFIG_USE_TINY_PRINTF))
1630 	sprintf(bdesc->vendor, "Man %06x Snr %04x%04x",
1631 		mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff),
1632 		(mmc->cid[3] >> 16) & 0xffff);
1633 	sprintf(bdesc->product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff,
1634 		(mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
1635 		(mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff,
1636 		(mmc->cid[2] >> 24) & 0xff);
1637 	sprintf(bdesc->revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf,
1638 		(mmc->cid[2] >> 16) & 0xf);
1639 #else
1640 	bdesc->vendor[0] = 0;
1641 	bdesc->product[0] = 0;
1642 	bdesc->revision[0] = 0;
1643 #endif
1644 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT)
1645 	part_init(bdesc);
1646 #endif
1647 
1648 	return 0;
1649 }
1650 
1651 static int mmc_send_if_cond(struct mmc *mmc)
1652 {
1653 	struct mmc_cmd cmd;
1654 	int err;
1655 
1656 	cmd.cmdidx = SD_CMD_SEND_IF_COND;
1657 	/* We set the bit if the host supports voltages between 2.7 and 3.6 V */
1658 	cmd.cmdarg = ((mmc->cfg->voltages & 0xff8000) != 0) << 8 | 0xaa;
1659 	cmd.resp_type = MMC_RSP_R7;
1660 
1661 	err = mmc_send_cmd(mmc, &cmd, NULL);
1662 
1663 	if (err)
1664 		return err;
1665 
1666 	if ((cmd.response[0] & 0xff) != 0xaa)
1667 		return -EOPNOTSUPP;
1668 	else
1669 		mmc->version = SD_VERSION_2;
1670 
1671 	return 0;
1672 }
1673 
1674 #if !CONFIG_IS_ENABLED(DM_MMC)
1675 /* board-specific MMC power initializations. */
1676 __weak void board_mmc_power_init(void)
1677 {
1678 }
1679 #endif
1680 
1681 static int mmc_power_init(struct mmc *mmc)
1682 {
1683 #if CONFIG_IS_ENABLED(DM_MMC)
1684 #if CONFIG_IS_ENABLED(DM_REGULATOR)
1685 	int ret;
1686 
1687 	ret = device_get_supply_regulator(mmc->dev, "vmmc-supply",
1688 					  &mmc->vmmc_supply);
1689 	if (ret)
1690 		debug("%s: No vmmc supply\n", mmc->dev->name);
1691 
1692 	ret = device_get_supply_regulator(mmc->dev, "vqmmc-supply",
1693 					  &mmc->vqmmc_supply);
1694 	if (ret)
1695 		debug("%s: No vqmmc supply\n", mmc->dev->name);
1696 
1697 	if (mmc->vmmc_supply) {
1698 		ret = regulator_set_enable(mmc->vmmc_supply, true);
1699 		if (ret) {
1700 			puts("Error enabling VMMC supply\n");
1701 			return ret;
1702 		}
1703 	}
1704 #endif
1705 #else /* !CONFIG_DM_MMC */
1706 	/*
1707 	 * Driver model should use a regulator, as above, rather than calling
1708 	 * out to board code.
1709 	 */
1710 	board_mmc_power_init();
1711 #endif
1712 	return 0;
1713 }
1714 
1715 int mmc_start_init(struct mmc *mmc)
1716 {
1717 	bool no_card;
1718 	int err;
1719 
1720 	/* we pretend there's no card when init is NULL */
1721 	no_card = mmc_getcd(mmc) == 0;
1722 #if !CONFIG_IS_ENABLED(DM_MMC)
1723 	no_card = no_card || (mmc->cfg->ops->init == NULL);
1724 #endif
1725 	if (no_card) {
1726 		mmc->has_init = 0;
1727 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1728 		printf("MMC: no card present\n");
1729 #endif
1730 		return -ENOMEDIUM;
1731 	}
1732 
1733 	if (mmc->has_init)
1734 		return 0;
1735 
1736 #ifdef CONFIG_FSL_ESDHC_ADAPTER_IDENT
1737 	mmc_adapter_card_type_ident();
1738 #endif
1739 	err = mmc_power_init(mmc);
1740 	if (err)
1741 		return err;
1742 
1743 #if CONFIG_IS_ENABLED(DM_MMC)
1744 	/* The device has already been probed ready for use */
1745 #else
1746 	/* made sure it's not NULL earlier */
1747 	err = mmc->cfg->ops->init(mmc);
1748 	if (err)
1749 		return err;
1750 #endif
1751 	mmc->ddr_mode = 0;
1752 	mmc_set_bus_width(mmc, 1);
1753 	mmc_set_clock(mmc, 1);
1754 
1755 	/* Reset the Card */
1756 	err = mmc_go_idle(mmc);
1757 
1758 	if (err)
1759 		return err;
1760 
1761 	/* The internal partition reset to user partition(0) at every CMD0*/
1762 	mmc_get_blk_desc(mmc)->hwpart = 0;
1763 
1764 	/* Test for SD version 2 */
1765 	err = mmc_send_if_cond(mmc);
1766 
1767 	/* Now try to get the SD card's operating condition */
1768 	err = sd_send_op_cond(mmc);
1769 
1770 	/* If the command timed out, we check for an MMC card */
1771 	if (err == -ETIMEDOUT) {
1772 		err = mmc_send_op_cond(mmc);
1773 
1774 		if (err) {
1775 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1776 			printf("Card did not respond to voltage select!\n");
1777 #endif
1778 			return -EOPNOTSUPP;
1779 		}
1780 	}
1781 
1782 	if (!err)
1783 		mmc->init_in_progress = 1;
1784 
1785 	return err;
1786 }
1787 
1788 static int mmc_complete_init(struct mmc *mmc)
1789 {
1790 	int err = 0;
1791 
1792 	mmc->init_in_progress = 0;
1793 	if (mmc->op_cond_pending)
1794 		err = mmc_complete_op_cond(mmc);
1795 
1796 	if (!err)
1797 		err = mmc_startup(mmc);
1798 	if (err)
1799 		mmc->has_init = 0;
1800 	else
1801 		mmc->has_init = 1;
1802 	return err;
1803 }
1804 
1805 int mmc_init(struct mmc *mmc)
1806 {
1807 	int err = 0;
1808 	__maybe_unused unsigned start;
1809 #if CONFIG_IS_ENABLED(DM_MMC)
1810 	struct mmc_uclass_priv *upriv = dev_get_uclass_priv(mmc->dev);
1811 
1812 	upriv->mmc = mmc;
1813 #endif
1814 	if (mmc->has_init)
1815 		return 0;
1816 
1817 	start = get_timer(0);
1818 
1819 	if (!mmc->init_in_progress)
1820 		err = mmc_start_init(mmc);
1821 
1822 	if (!err)
1823 		err = mmc_complete_init(mmc);
1824 	if (err)
1825 		printf("%s: %d, time %lu\n", __func__, err, get_timer(start));
1826 
1827 	return err;
1828 }
1829 
1830 int mmc_set_dsr(struct mmc *mmc, u16 val)
1831 {
1832 	mmc->dsr = val;
1833 	return 0;
1834 }
1835 
1836 /* CPU-specific MMC initializations */
1837 __weak int cpu_mmc_init(bd_t *bis)
1838 {
1839 	return -1;
1840 }
1841 
1842 /* board-specific MMC initializations. */
1843 __weak int board_mmc_init(bd_t *bis)
1844 {
1845 	return -1;
1846 }
1847 
1848 void mmc_set_preinit(struct mmc *mmc, int preinit)
1849 {
1850 	mmc->preinit = preinit;
1851 }
1852 
1853 #if CONFIG_IS_ENABLED(DM_MMC) && defined(CONFIG_SPL_BUILD)
1854 static int mmc_probe(bd_t *bis)
1855 {
1856 	return 0;
1857 }
1858 #elif CONFIG_IS_ENABLED(DM_MMC)
1859 static int mmc_probe(bd_t *bis)
1860 {
1861 	int ret, i;
1862 	struct uclass *uc;
1863 	struct udevice *dev;
1864 
1865 	ret = uclass_get(UCLASS_MMC, &uc);
1866 	if (ret)
1867 		return ret;
1868 
1869 	/*
1870 	 * Try to add them in sequence order. Really with driver model we
1871 	 * should allow holes, but the current MMC list does not allow that.
1872 	 * So if we request 0, 1, 3 we will get 0, 1, 2.
1873 	 */
1874 	for (i = 0; ; i++) {
1875 		ret = uclass_get_device_by_seq(UCLASS_MMC, i, &dev);
1876 		if (ret == -ENODEV)
1877 			break;
1878 	}
1879 	uclass_foreach_dev(dev, uc) {
1880 		ret = device_probe(dev);
1881 		if (ret)
1882 			printf("%s - probe failed: %d\n", dev->name, ret);
1883 	}
1884 
1885 	return 0;
1886 }
1887 #else
1888 static int mmc_probe(bd_t *bis)
1889 {
1890 	if (board_mmc_init(bis) < 0)
1891 		cpu_mmc_init(bis);
1892 
1893 	return 0;
1894 }
1895 #endif
1896 
1897 int mmc_initialize(bd_t *bis)
1898 {
1899 	static int initialized = 0;
1900 	int ret;
1901 	if (initialized)	/* Avoid initializing mmc multiple times */
1902 		return 0;
1903 	initialized = 1;
1904 
1905 #if !CONFIG_IS_ENABLED(BLK)
1906 #if !CONFIG_IS_ENABLED(MMC_TINY)
1907 	mmc_list_init();
1908 #endif
1909 #endif
1910 	ret = mmc_probe(bis);
1911 	if (ret)
1912 		return ret;
1913 
1914 #ifndef CONFIG_SPL_BUILD
1915 	print_mmc_devices(',');
1916 #endif
1917 
1918 	mmc_do_preinit();
1919 	return 0;
1920 }
1921 
1922 #ifdef CONFIG_CMD_BKOPS_ENABLE
1923 int mmc_set_bkops_enable(struct mmc *mmc)
1924 {
1925 	int err;
1926 	ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
1927 
1928 	err = mmc_send_ext_csd(mmc, ext_csd);
1929 	if (err) {
1930 		puts("Could not get ext_csd register values\n");
1931 		return err;
1932 	}
1933 
1934 	if (!(ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1)) {
1935 		puts("Background operations not supported on device\n");
1936 		return -EMEDIUMTYPE;
1937 	}
1938 
1939 	if (ext_csd[EXT_CSD_BKOPS_EN] & 0x1) {
1940 		puts("Background operations already enabled\n");
1941 		return 0;
1942 	}
1943 
1944 	err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BKOPS_EN, 1);
1945 	if (err) {
1946 		puts("Failed to enable manual background operations\n");
1947 		return err;
1948 	}
1949 
1950 	puts("Enabled manual background operations\n");
1951 
1952 	return 0;
1953 }
1954 #endif
1955